Created
September 4, 2013 10:42
-
-
Save hughsk/6435396 to your computer and use it in GitHub Desktop.
requirebin sketch
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| // This version is unminified | |
| var observer = require('continuous-observer') | |
| var cave = require('cave-automata-2d') | |
| var fill = require('ndarray-fill') | |
| var zero = require('zeros') | |
| var raf = require('raf') | |
| var canvas = document.createElement('canvas') | |
| var ctx = canvas.getContext('2d') | |
| // Set up the controls, so that we can control | |
| // the camera with the arrow keys or WASD. | |
| var controls = require('kb-controls-iframed')({ | |
| '<up>': 'up', | |
| '<down>': 'down', | |
| '<left>': 'left', | |
| '<right>': 'right', | |
| 'W': 'up', | |
| 'S': 'down', | |
| 'A': 'left', | |
| 'D': 'right' | |
| }) | |
| var field = require('ndarray-continuous')({ | |
| shape: [28, 28], // Make each chunk 28 elements high/wide | |
| getter: getter | |
| }) | |
| // This method generates a new chunk for | |
| // the continuous ndarray if it's needed. | |
| // | |
| // Here we're creating an empty ndarray, then | |
| // filling it up with cave-automata-2d. We're | |
| // also inverting it so that we can get links | |
| // between the chunks without much extra work. | |
| function getter(position, done) { | |
| var array = zero(this.shape) | |
| cave(array)(10) | |
| invert(array) | |
| return done(null, array) | |
| } | |
| function invert(array) { | |
| return fill(array, function(x, y) { | |
| return 1 - array.get(x, y) | |
| }) | |
| } | |
| // We'll use continuous-observer to add and remove | |
| // chunks as needed, based on the camera's position | |
| // each frame. | |
| var moveTo = observer(field) | |
| var camera = { | |
| x: 0, | |
| y: 0 | |
| } | |
| raf().on('data', function() { | |
| if (controls.up) camera.y -= 0.25 | |
| if (controls.down) camera.y += 0.25 | |
| if (controls.left) camera.x -= 0.25 | |
| if (controls.right) camera.x += 0.25 | |
| moveTo([camera.x, camera.y]) | |
| ctx.fillStyle = '#f2f2f2' | |
| ctx.fillRect(0, 0, canvas.width, canvas.height) | |
| // Iterate over each chunk in the continuous-ndarray, | |
| // drawing each one according to their position on the | |
| // grid. | |
| field.each(function(chunk) { | |
| var pos = chunk.position | |
| var w = chunk.shape[0] | |
| var h = chunk.shape[1] | |
| var offset = { | |
| x: chunk.position[0] * chunk.shape[0], | |
| y: chunk.position[1] * chunk.shape[1] | |
| } | |
| ctx.fillStyle = '#af3' | |
| for (var x = 0; x < w; x += 1) { | |
| for (var y = 0; y < h; y += 1) { | |
| if (chunk.get(x, y) > 0) { | |
| ctx.fillRect( | |
| (offset.x + x - camera.x) * 40, | |
| (offset.y + y - camera.y) * 40, | |
| 39, | |
| 39 | |
| ) | |
| } | |
| } | |
| } | |
| }) | |
| }) | |
| document.body.style.margin = | |
| document.body.style.padding = 0 | |
| document.body.style.overflow = 'hidden' | |
| document.body.appendChild(canvas) | |
| canvas.width = window.innerWidth | |
| canvas.height = window.innerHeight |
This file has been truncated, but you can view the full file.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| require=(function(e,t,n){function i(n,s){if(!t[n]){if(!e[n]){var o=typeof require=="function"&&require;if(!s&&o)return o(n,!0);if(r)return r(n,!0);throw new Error("Cannot find module '"+n+"'")}var u=t[n]={exports:{}};e[n][0].call(u.exports,function(t){var r=e[n][1][t];return i(r?r:t)},u,u.exports)}return t[n].exports}var r=typeof require=="function"&&require;for(var s=0;s<n.length;s++)i(n[s]);return i})({1:[function(require,module,exports){ | |
| "use strict" | |
| function dupe_array(count, value, i) { | |
| var c = count[i]|0 | |
| if(c <= 0) { | |
| return [] | |
| } | |
| var result = new Array(c), j | |
| if(i === count.length-1) { | |
| for(j=0; j<c; ++j) { | |
| result[j] = value | |
| } | |
| } else { | |
| for(j=0; j<c; ++j) { | |
| result[j] = dupe_array(count, value, i+1) | |
| } | |
| } | |
| return result | |
| } | |
| function dupe_number(count, value) { | |
| var result, i | |
| result = new Array(count) | |
| for(i=0; i<count; ++i) { | |
| result[i] = value | |
| } | |
| return result | |
| } | |
| function dupe(count, value) { | |
| if(typeof value === "undefined") { | |
| value = 0 | |
| } | |
| switch(typeof count) { | |
| case "number": | |
| if(count > 0) { | |
| return dupe_number(count|0, value) | |
| } | |
| break | |
| case "object": | |
| if(typeof (count.length) === "number") { | |
| return dupe_array(count, value, 0) | |
| } | |
| break | |
| } | |
| return [] | |
| } | |
| module.exports = dupe | |
| },{}],"continuous-observer":[function(require,module,exports){ | |
| module.exports=require('cvAJoq'); | |
| },{}],"cvAJoq":[function(require,module,exports){ | |
| var dup = require('dup') | |
| var map = require('map-async') | |
| var cells = require('cell-range') | |
| var round = Math.round | |
| var min = Math.min | |
| var max = Math.max | |
| var abs = Math.abs | |
| module.exports = observer | |
| function observer(field, range, linger) { | |
| range = (+range|0) || 1 | |
| linger = max((+linger|0) - range, range) | |
| var shape = field.shape | |
| var dims = shape.length | |
| var neighbours = cells(dup(dims, -range), dup(dims, range)) | |
| var singletemp = [] | |
| function observeone(place, callback) { | |
| singletemp[0] = place | |
| return observe(singletemp, callback) | |
| } | |
| return observe | |
| function observe(places, callback) { | |
| if (!Array.isArray(places[0])) return observeone(places, callback) | |
| callback = callback || function(){} | |
| map(places, function(coord, next) { | |
| coord = coord.slice() | |
| var i = dims | |
| while (i--) coord[i] = round(coord[i] / shape[i]) | |
| map(neighbours, function(offset, next) { | |
| var pos = coord.slice() | |
| var i = dims | |
| while (i--) pos[i] += offset[i] | |
| field.chunk(pos, next) | |
| }, next) | |
| }, function(err) { | |
| if (err) return next(err) | |
| var closest = Infinity | |
| var flagged = [] | |
| var distance = 0 | |
| var l = places.length | |
| var pos | |
| var i | |
| var pages = field.index.pages | |
| for (var p = 0; p < pages.length; p += 1) | |
| for (var c = 0; c < pages[p].length; c += 1) { | |
| pos = pages[p][c].position | |
| closest = Infinity | |
| for (i = 0; i < l; i += 1) { | |
| distance = 0 | |
| for (var d = 0; d < dims; d += 1) { | |
| distance += abs(pos[d] - places[i][d] / shape[d]) | |
| } | |
| closest = distance < closest | |
| ? distance | |
| : closest | |
| } | |
| if (closest > range + linger) flagged.push(pos) | |
| } | |
| i = flagged.length | |
| while (i--) field.remove(flagged[i]) | |
| return callback(null) | |
| }) | |
| } | |
| } | |
| },{"dup":1,"cell-range":2,"map-async":3}],2:[function(require,module,exports){ | |
| module.exports = cells | |
| function cells(hi, lo) { | |
| if (hi.length !== lo.length) throw new Error( | |
| 'Both arguments must be arrays of equal length' | |
| ) | |
| var dims = hi.length | |
| var lod = lo[lo.length - 1] | |
| return recurse([], [], 0) | |
| function recurse(array, temp, d) { | |
| if (d === dims - 1) { | |
| for (var i = hi[d]; i <= lo[d]; i += 1) { | |
| if (i === lo[d]) { | |
| temp.push(i) | |
| array.push(temp) | |
| } else { | |
| array.push(temp.concat(i)) | |
| } | |
| } | |
| } else { | |
| for (var i = hi[d]; i <= lo[d]; i += 1) { | |
| if (i == lo[d]) { | |
| temp.push(i) | |
| recurse(array, temp, d + 1) | |
| } else { | |
| recurse(array, temp.concat(i), d + 1) | |
| } | |
| } | |
| } | |
| return array | |
| } | |
| } | |
| },{}],3:[function(require,module,exports){ | |
| module.exports = map | |
| function map(list, iterator, context, callback) { | |
| var keys = Object.keys(list) | |
| , returnValue = Array.isArray(list) ? [] : {} | |
| , count = keys.length | |
| if (typeof context === "function") { | |
| callback = context | |
| context = this | |
| } | |
| if (keys.length === 0) { | |
| return callback(null, returnValue) | |
| } | |
| for (var i = 0, len = keys.length; i < len; i++) { | |
| var key = keys[i] | |
| , value = list[key] | |
| invokeIterator(iterator, | |
| next(key), context, value, key, list) | |
| } | |
| function next(key) { | |
| return handler | |
| function handler(err, newValue) { | |
| if (err) { | |
| return callback && callback(err) | |
| } | |
| returnValue[key] = newValue | |
| if (--count === 0) { | |
| callback && callback(null, returnValue) | |
| } | |
| } | |
| } | |
| } | |
| function invokeIterator(iterator, done, self, value, key, list) { | |
| var length = iterator.length | |
| if (length === 1) { | |
| iterator.call(self, done) | |
| } else if (length === 2) { | |
| iterator.call(self, value, done) | |
| } else if (length === 3) { | |
| iterator.call(self, value, key, done) | |
| } else { | |
| iterator.call(self, value, key, list, done) | |
| } | |
| } | |
| },{}]},{},[]) | |
| //@ sourceMappingURL=data:application/json;base64,{"version":3,"file":"generated.js","sources":["/private/var/folders/43/z7pv8pvd4x57nt_1zz2561tw0000gn/T/continuous-observer11384-42346-l4a19e/node_modules/continuous-observer/node_modules/dup/dup.js","/private/var/folders/43/z7pv8pvd4x57nt_1zz2561tw0000gn/T/continuous-observer11384-42346-l4a19e/node_modules/continuous-observer/index.js","/private/var/folders/43/z7pv8pvd4x57nt_1zz2561tw0000gn/T/continuous-observer11384-42346-l4a19e/node_modules/continuous-observer/node_modules/cell-range/index.js","/private/var/folders/43/z7pv8pvd4x57nt_1zz2561tw0000gn/T/continuous-observer11384-42346-l4a19e/node_modules/continuous-observer/node_modules/map-async/index.js"],"names":[],"mappings":";AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AChDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","sourcesContent":["\"use strict\"\n\nfunction dupe_array(count, value, i) {\n  var c = count[i]|0\n  if(c <= 0) {\n    return []\n  }\n  var result = new Array(c), j\n  if(i === count.length-1) {\n    for(j=0; j<c; ++j) {\n      result[j] = value\n    }\n  } else {\n    for(j=0; j<c; ++j) {\n      result[j] = dupe_array(count, value, i+1)\n    }\n  }\n  return result\n}\n\nfunction dupe_number(count, value) {\n  var result, i\n  result = new Array(count)\n  for(i=0; i<count; ++i) {\n    result[i] = value\n  }\n  return result\n}\n\nfunction dupe(count, value) {\n  if(typeof value === \"undefined\") {\n    value = 0\n  }\n  switch(typeof count) {\n    case \"number\":\n      if(count > 0) {\n        return dupe_number(count|0, value)\n      }\n    break\n    case \"object\":\n      if(typeof (count.length) === \"number\") {\n        return dupe_array(count, value, 0)\n      }\n    break\n  }\n  return []\n}\n\nmodule.exports = dupe","var dup = require('dup')\nvar map = require('map-async')\nvar cells = require('cell-range')\nvar round = Math.round\nvar min = Math.min\nvar max = Math.max\nvar abs = Math.abs\n\nmodule.exports = observer\n\nfunction observer(field, range, linger) {\n  range = (+range|0) || 1\n  linger = max((+linger|0) - range, range)\n\n  var shape = field.shape\n  var dims = shape.length\n  var neighbours = cells(dup(dims, -range), dup(dims, range))\n\n  var singletemp = []\n  function observeone(place, callback) {\n    singletemp[0] = place\n    return observe(singletemp, callback)\n  }\n\n  return observe\n\n  function observe(places, callback) {\n    if (!Array.isArray(places[0])) return observeone(places, callback)\n    callback = callback || function(){}\n\n    map(places, function(coord, next) {\n      coord = coord.slice()\n      var i = dims\n      while (i--) coord[i] = round(coord[i] / shape[i])\n\n      map(neighbours, function(offset, next) {\n        var pos = coord.slice()\n        var i = dims\n        while (i--) pos[i] += offset[i]\n        field.chunk(pos, next)\n      }, next)\n    }, function(err) {\n      if (err) return next(err)\n\n      var closest = Infinity\n      var flagged = []\n      var distance = 0\n      var l = places.length\n      var pos\n      var i\n\n      var pages = field.index.pages\n      for (var p = 0; p < pages.length; p += 1)\n      for (var c = 0; c < pages[p].length; c += 1) {\n        pos = pages[p][c].position\n        closest = Infinity\n\n        for (i = 0; i < l; i += 1) {\n          distance = 0\n          for (var d = 0; d < dims; d += 1) {\n            distance += abs(pos[d] - places[i][d] / shape[d])\n          }\n\n          closest = distance < closest\n            ? distance\n            : closest\n        }\n\n        if (closest > range + linger) flagged.push(pos)\n      }\n\n      i = flagged.length\n      while (i--) field.remove(flagged[i])\n\n      return callback(null)\n    })\n  }\n}\n","module.exports = cells\n\nfunction cells(hi, lo) {\n  if (hi.length !== lo.length) throw new Error(\n    'Both arguments must be arrays of equal length'\n  )\n\n  var dims = hi.length\n  var lod = lo[lo.length - 1]\n\n  return recurse([], [], 0)\n\n  function recurse(array, temp, d) {\n    if (d === dims - 1) {\n      for (var i = hi[d]; i <= lo[d]; i += 1) {\n        if (i === lo[d]) {\n          temp.push(i)\n          array.push(temp)\n        } else {\n          array.push(temp.concat(i))\n        }\n      }\n    } else {\n      for (var i = hi[d]; i <= lo[d]; i += 1) {\n        if (i == lo[d]) {\n          temp.push(i)\n          recurse(array, temp, d + 1)\n        } else {\n          recurse(array, temp.concat(i), d + 1)\n        }\n      }\n    }\n    return array\n  }\n}\n","module.exports = map\n\nfunction map(list, iterator, context, callback) {\n    var keys = Object.keys(list)\n        , returnValue = Array.isArray(list) ? [] : {}\n        , count = keys.length\n\n    if (typeof context === \"function\") {\n        callback = context\n        context = this\n    }\n\n    if (keys.length === 0) {\n        return callback(null, returnValue)\n    }\n\n    for (var i = 0, len = keys.length; i < len; i++) {\n        var key = keys[i]\n            , value = list[key]\n\n        invokeIterator(iterator,\n            next(key), context, value, key, list)\n    }\n\n    function next(key) {\n        return handler\n\n        function handler(err, newValue) {\n            if (err) {\n                return callback && callback(err)\n            }\n\n            returnValue[key] = newValue\n\n            if (--count === 0) {\n                callback && callback(null, returnValue)\n            }\n        }\n    }\n}\n\nfunction invokeIterator(iterator, done, self, value, key, list) {\n    var length = iterator.length\n\n    if (length === 1) {\n        iterator.call(self, done)\n    } else if (length === 2) {\n        iterator.call(self, value, done)\n    } else if (length === 3) {\n        iterator.call(self, value, key, done)\n    } else {\n        iterator.call(self, value, key, list, done)\n    }\n}\n"]} | |
| ;require=(function(e,t,n){function i(n,s){if(!t[n]){if(!e[n]){var o=typeof require=="function"&&require;if(!s&&o)return o(n,!0);if(r)return r(n,!0);throw new Error("Cannot find module '"+n+"'")}var u=t[n]={exports:{}};e[n][0].call(u.exports,function(t){var r=e[n][1][t];return i(r?r:t)},u,u.exports)}return t[n].exports}var r=typeof require=="function"&&require;for(var s=0;s<n.length;s++)i(n[s]);return i})({"cave-automata-2d":[function(require,module,exports){ | |
| module.exports=require('5cLkHa'); | |
| },{}],"5cLkHa":[function(require,module,exports){ | |
| var neighborhood = require('moore')(1, 2).concat([[0,0]]) | |
| var stencil = require('ndarray-stencil') | |
| var fill = require('ndarray-fill') | |
| var zero = require('zeros') | |
| var neighbors = neighborhood.length | |
| var stencils = {} | |
| module.exports = generate | |
| // ndarray-stencil generates code using cwise, and as | |
| // such incurs a slight performance hit initially. | |
| // To work around this, we can keep two cached functions | |
| // which use shared parameters. See `iterator` for more info. | |
| var sharedWidth = null | |
| var sharedHeight = null | |
| var sharedBorder = null | |
| var sharedThreshold = null | |
| stencils.vanilla = stencil(neighborhood, function(p1,p2,p3,p4,p5,p6,p7,p8,p9,pos) { | |
| return ( | |
| p1+p2+p3+p4+p5+p6+p7+p8+p9 >= sharedThreshold | |
| ) ? 1 : 0 | |
| }, { useIndex: false }) | |
| stencils.border = stencil(neighborhood, function(p1,p2,p3,p4,p5,p6,p7,p8,p9,pos) { | |
| return ( | |
| p1+p2+p3+p4+p5+p6+p7+p8+p9 >= sharedThreshold || | |
| pos[0] < sharedBorder || | |
| pos[0] > sharedWidth - sharedBorder - 3 || | |
| pos[1] < sharedBorder || | |
| pos[1] > sharedHeight - sharedBorder - 3 | |
| ) ? 1 : 0 | |
| }, { useIndex: true }) | |
| function generate(array, opts) { | |
| opts = opts || {} | |
| var width = array.shape[0] | |
| , height = array.shape[1] | |
| , buffer = opts.buffer || zero([ width, height ]) | |
| var density = opts.density || 0.5 | |
| , threshold = opts.threshold || 5 | |
| , border = 'border' in opts ? opts.border : 1 | |
| , shouldFill = 'fill' in opts ? opts.fill : true | |
| , iterate = stencils[ | |
| border ? 'border' : 'vanilla' | |
| ] | |
| if (shouldFill) fill(array, function(x, y) { | |
| return Math.random() <= density || ( | |
| x <= 1 || x >= width-2 || | |
| y <= 1 || y >= height-2 | |
| ) ? 1 : 0 | |
| }) | |
| if (opts.iterations) { | |
| iterator(opts.iterations) | |
| } | |
| return iterator | |
| // Updates the shared variables that are available | |
| // on the module-level scope. This is a synchronous | |
| // operation, so it's totally safe (though not | |
| // necessarily pretty) provided these values are | |
| // updated before any iteration. | |
| function iterator(iterations) { | |
| sharedWidth = width | |
| sharedHeight = height | |
| sharedBorder = border | |
| sharedThreshold = threshold | |
| iterations = iterations || 1 | |
| for (var i = 0; i < iterations; i += 1) { | |
| if (i % 2) { | |
| iterate(array, buffer) | |
| } else { | |
| iterate(buffer, array) | |
| } | |
| } | |
| if (iterations % 2) { | |
| fill(array, function(x, y) { | |
| return buffer.get(x, y) | |
| }) | |
| } | |
| return array | |
| } | |
| } | |
| },{"ndarray-stencil":1,"zeros":2,"ndarray-fill":3,"moore":4}],4:[function(require,module,exports){ | |
| module.exports = moore | |
| function moore(range, dims) { | |
| dims = dims || 2 | |
| range = range || 1 | |
| return recurse([], [], 0) | |
| function recurse(array, temp, d) { | |
| if (d === dims-1) { | |
| for (var i = -range; i <= range; i += 1) { | |
| if (i || temp.some(function(n) { | |
| return n | |
| })) array.push(temp.concat(i)) | |
| } | |
| } else { | |
| for (var i = -range; i <= range; i += 1) { | |
| recurse(array, temp.concat(i), d+1) | |
| } | |
| } | |
| return array | |
| } | |
| } | |
| },{}],1:[function(require,module,exports){ | |
| "use strict" | |
| var dup = require("dup") | |
| var cwise = require("cwise") | |
| function generateCWiseLoop(n, d, func, options) { | |
| var body_args = [] | |
| var args = ["scalar", "array"] | |
| for(var i=0; i<n; ++i) { | |
| args.push("array") | |
| body_args.push("a"+i) | |
| } | |
| if(options.useIndex) { | |
| body_args.push("idx") | |
| args.push("index") | |
| } | |
| body_args.push(["out=func(",body_args.join(","),")"].join("")) | |
| body_args.unshift("out") | |
| body_args.unshift("func") | |
| var loop = cwise({ | |
| args: args, | |
| body: Function.apply(undefined, body_args), | |
| funcName: "StencilOp" | |
| }) | |
| return loop.bind(undefined, func) | |
| } | |
| function hiOffset(hi, point) { | |
| var out = new Array(point.length) | |
| for(var i=0; i<hi.length; ++i) { | |
| var d = -point[i]-hi[i] | |
| if(d === 0) { | |
| out[i] = "s" + i | |
| } else { | |
| out[i] = ["s", i, "-", (-d)].join("") | |
| } | |
| } | |
| return out.join(",") | |
| } | |
| function loOffset(lo, point) { | |
| var out = new Array(point.length) | |
| for(var i=0; i<lo.length; ++i) { | |
| var d = -lo[i]-point[i] | |
| if(d === 0) { | |
| out[i] = "0" | |
| } else { | |
| out[i] = d | |
| } | |
| } | |
| return out.join(",") | |
| } | |
| function generateWrapper(points, lo, hi, loop) { | |
| var n = points.length | |
| var d = lo.length | |
| var code = ["'use strict'"] | |
| code.push("var s=out.shape") | |
| for(var i=0; i<d; ++i) { | |
| code.push(["var s", i, "=s[", i, "]|0"].join("")) | |
| } | |
| code.push(["func(out.hi(", hiOffset(hi, dup(d)), ").lo(", loOffset(lo, dup(d)), ")"].join("")) | |
| for(var i=0; i<points.length; ++i) { | |
| code.push([",inp.hi(", hiOffset(hi, points[i]), ").lo(", loOffset(lo, points[i]), ")"].join("")) | |
| } | |
| code.push(")") | |
| var proc = new Function("func", "out", "inp", code.join("\n")) | |
| return proc.bind(undefined, loop) | |
| } | |
| function stencilOp(points, func, options) { | |
| options = options || {} | |
| if(points.length === 0) { | |
| throw new Error("ndarray-stencil: Need to specify at least one point for stencil") | |
| } | |
| var n = points.length | |
| var d = points[0].length | |
| var lo = dup(d) | |
| var hi = dup(d) | |
| for(var i=0; i<n; ++i) { | |
| var p = points[i] | |
| for(var j=0; j<d; ++j) { | |
| lo[j] = Math.min(lo[j], p[j]) | |
| hi[j] = Math.max(hi[j], p[j]) | |
| } | |
| } | |
| var cwiseLoop = generateCWiseLoop(n, d, func, options) | |
| return generateWrapper(points, lo, hi, cwiseLoop) | |
| } | |
| module.exports = stencilOp | |
| },{"dup":5,"cwise":6}],2:[function(require,module,exports){ | |
| "use strict" | |
| var ndarray = require("ndarray") | |
| module.exports = function zeros(shape) { | |
| var sz = 1 | |
| for(var i=0; i<shape.length; ++i) { | |
| sz *= shape[i] | |
| } | |
| return ndarray(new Float64Array(sz), shape) | |
| } | |
| },{"ndarray":7}],3:[function(require,module,exports){ | |
| "use strict" | |
| var fill = require("cwise")({ | |
| args: ["index", "array", "scalar"], | |
| body: function(idx, out, f) { | |
| out = f.apply(undefined, idx) | |
| } | |
| }) | |
| module.exports = function(array, f) { | |
| fill(array, f) | |
| return array | |
| } | |
| },{"cwise":8}],5:[function(require,module,exports){ | |
| "use strict" | |
| function dupe_array(count, value, i) { | |
| var c = count[i]|0 | |
| if(c <= 0) { | |
| return [] | |
| } | |
| var result = new Array(c), j | |
| if(i === count.length-1) { | |
| for(j=0; j<c; ++j) { | |
| result[j] = value | |
| } | |
| } else { | |
| for(j=0; j<c; ++j) { | |
| result[j] = dupe_array(count, value, i+1) | |
| } | |
| } | |
| return result | |
| } | |
| function dupe_number(count, value) { | |
| var result, i | |
| result = new Array(count) | |
| for(i=0; i<count; ++i) { | |
| result[i] = value | |
| } | |
| return result | |
| } | |
| function dupe(count, value) { | |
| if(typeof value === "undefined") { | |
| value = 0 | |
| } | |
| switch(typeof count) { | |
| case "number": | |
| if(count > 0) { | |
| return dupe_number(count|0, value) | |
| } | |
| break | |
| case "object": | |
| if(typeof (count.length) === "number") { | |
| return dupe_array(count, value, 0) | |
| } | |
| break | |
| } | |
| return [] | |
| } | |
| module.exports = dupe | |
| },{}],6:[function(require,module,exports){ | |
| "use strict" | |
| var parse = require("cwise-parser") | |
| var compile = require("cwise-compiler") | |
| var REQUIRED_FIELDS = [ "args", "body" ] | |
| var OPTIONAL_FIELDS = [ "pre", "post", "printCode", "funcName", "blockSize" ] | |
| function createCWise(user_args) { | |
| //Check parameters | |
| for(var id in user_args) { | |
| if(REQUIRED_FIELDS.indexOf(id) < 0 && | |
| OPTIONAL_FIELDS.indexOf(id) < 0) { | |
| console.warn("cwise: Unknown argument '"+id+"' passed to expression compiler") | |
| } | |
| } | |
| for(var i=0; i<REQUIRED_FIELDS.length; ++i) { | |
| if(!user_args[REQUIRED_FIELDS[i]]) { | |
| throw new Error("cwise: Missing argument: " + REQUIRED_FIELDS[i]) | |
| } | |
| } | |
| //Parse blocks | |
| return compile({ | |
| args: user_args.args, | |
| pre: parse(user_args.pre || function(){}), | |
| body: parse(user_args.body), | |
| post: parse(user_args.post || function(){}), | |
| debug: !!user_args.printCode, | |
| funcName: user_args.funcName || user_args.body.name || "cwise", | |
| blockSize: user_args.blockSize || 64 | |
| }) | |
| } | |
| module.exports = createCWise | |
| },{"cwise-parser":9,"cwise-compiler":10}],7:[function(require,module,exports){ | |
| "use strict" | |
| var iota = require("iota-array") | |
| var arrayMethods = [ | |
| "concat", | |
| "join", | |
| "slice", | |
| "toString", | |
| "indexOf", | |
| "lastIndexOf", | |
| "forEach", | |
| "every", | |
| "some", | |
| "filter", | |
| "map", | |
| "reduce", | |
| "reduceRight" | |
| ] | |
| function compare1st(a, b) { | |
| return a[0] - b[0] | |
| } | |
| function order() { | |
| var stride = this.stride | |
| var terms = new Array(stride.length) | |
| var i | |
| for(i=0; i<terms.length; ++i) { | |
| terms[i] = [Math.abs(stride[i]), i] | |
| } | |
| terms.sort(compare1st) | |
| var result = new Array(terms.length) | |
| for(i=0; i<result.length; ++i) { | |
| result[i] = terms[i][1] | |
| } | |
| return result | |
| } | |
| var ZeroArray = "function ZeroArray(a,d) {\ | |
| this.data = a;\ | |
| this.offset = d\ | |
| };\ | |
| var proto=ZeroArray.prototype;\ | |
| proto.size=0;\ | |
| proto.shape=[];\ | |
| proto.stride=[];\ | |
| proto.order=[];\ | |
| proto.get=proto.set=function() {\ | |
| return Number.NaN\ | |
| };\ | |
| proto.lo=\ | |
| proto.hi=\ | |
| proto.transpose=\ | |
| proto.step=\ | |
| proto.pick=function() {\ | |
| return new ZeroArray(this.data,this.shape,this.stride,this.offset)\ | |
| }" | |
| function compileConstructor(dtype, dimension) { | |
| //Special case for 0d arrays | |
| if(dimension === 0) { | |
| var compiledProc = new Function([ | |
| ZeroArray, | |
| "ZeroArray.prototype.dtype='"+dtype+"'", | |
| "return function construct_ZeroArray(a,b,c,d){return new ZeroArray(a,d)}"].join("\n")) | |
| return compiledProc() | |
| } | |
| var useGetters = (dtype === "generic") | |
| var code = ["'use strict'"] | |
| //Create constructor for view | |
| var indices = iota(dimension) | |
| var args = indices.map(function(i) { return "i"+i }) | |
| var index_str = "this.offset+" + indices.map(function(i) { | |
| return ["this._stride", i, "*i",i].join("") | |
| }).join("+") | |
| var className = ["View", dimension, "d", dtype].join("") | |
| code.push(["function ", className, "(a,", | |
| indices.map(function(i) { | |
| return "b"+i | |
| }).join(","), ",", | |
| indices.map(function(i) { | |
| return "c"+i | |
| }).join(","), ",d){this.data=a"].join("")) | |
| for(var i=0; i<dimension; ++i) { | |
| code.push(["this._shape",i,"=b",i,"|0"].join("")) | |
| } | |
| for(var i=0; i<dimension; ++i) { | |
| code.push(["this._stride",i,"=c",i,"|0"].join("")) | |
| } | |
| code.push("this.offset=d|0}") | |
| //Get prototype | |
| code.push(["var proto=",className,".prototype"].join("")) | |
| //view.dtype: | |
| code.push(["proto.dtype='", dtype, "'"].join("")) | |
| code.push("proto.dimension="+dimension) | |
| //view.stride and view.shape | |
| var strideClassName = ["VStride", dimension, "d", dtype].join("") | |
| var shapeClassName = ["VShape", dimension, "d", dtype].join("") | |
| var props = {"stride":strideClassName, "shape":shapeClassName} | |
| for(var prop in props) { | |
| var arrayName = props[prop] | |
| code.push(["function ", arrayName, "(v) {this._v=v} var aproto=", arrayName, ".prototype"].join("")) | |
| code.push(["aproto.length=",dimension].join("")) | |
| var array_elements = [] | |
| for(var i=0; i<dimension; ++i) { | |
| array_elements.push(["this._v._", prop, i].join("")) | |
| } | |
| code.push(["aproto.toJSON=function ", arrayName, "_toJSON(){return [", array_elements.join(","), "]}"].join("")) | |
| code.push(["aproto.toString=function ", arrayName, "_toString(){return [", array_elements.join(","), "].join()}"].join("")) | |
| for(var i=0; i<dimension; ++i) { | |
| code.push(["Object.defineProperty(aproto,", i, ",{get:function(){return this._v._", prop, i, "},set:function(v){return this._v._", prop, i, "=v|0},enumerable:true})"].join("")) | |
| } | |
| for(var i=0; i<arrayMethods.length; ++i) { | |
| if(arrayMethods[i] in Array.prototype) { | |
| code.push(["aproto.", arrayMethods[i], "=Array.prototype.", arrayMethods[i]].join("")) | |
| } | |
| } | |
| code.push(["Object.defineProperty(proto,'",prop,"',{get:function ", arrayName, "_get(){return new ", arrayName, "(this)},set: function ", arrayName, "_set(v){"].join("")) | |
| for(var i=0; i<dimension; ++i) { | |
| code.push(["this._", prop, i, "=v[", i, "]|0"].join("")) | |
| } | |
| code.push("return v}})") | |
| } | |
| //view.size: | |
| code.push(["Object.defineProperty(proto,'size',{get:function ",className,"_size(){\ | |
| return ", indices.map(function(i) { return ["this._shape", i].join("") }).join("*"), | |
| "}})"].join("")) | |
| //view.order: | |
| if(dimension === 1) { | |
| code.push("proto.order=[0]") | |
| } else { | |
| code.push("Object.defineProperty(proto,'order',{get:") | |
| if(dimension < 4) { | |
| code.push(["function ",className,"_order(){"].join("")) | |
| if(dimension === 2) { | |
| code.push("return (Math.abs(this._stride0)>Math.abs(this._stride1))?[1,0]:[0,1]}})") | |
| } else if(dimension === 3) { | |
| code.push( | |
| "var s0=Math.abs(this._stride0),s1=Math.abs(this._stride1),s2=Math.abs(this._stride2);\ | |
| if(s0>s1){\ | |
| if(s1>s2){\ | |
| return [2,1,0];\ | |
| }else if(s0>s2){\ | |
| return [1,2,0];\ | |
| }else{\ | |
| return [1,0,2];\ | |
| }\ | |
| }else if(s0>s2){\ | |
| return [2,0,1];\ | |
| }else if(s2>s1){\ | |
| return [0,1,2];\ | |
| }else{\ | |
| return [0,2,1];\ | |
| }}})") | |
| } | |
| } else { | |
| code.push("ORDER})") | |
| } | |
| } | |
| //view.set(i0, ..., v): | |
| code.push([ | |
| "proto.set=function ",className,"_set(", args.join(","), ",v){"].join("")) | |
| if(useGetters) { | |
| code.push(["return this.data.set(", index_str, ",v)}"].join("")) | |
| } else { | |
| code.push(["return this.data[", index_str, "]=v}"].join("")) | |
| } | |
| //view.get(i0, ...): | |
| code.push(["proto.get=function ",className,"_get(", args.join(","), "){"].join("")) | |
| if(useGetters) { | |
| code.push(["return this.data.get(", index_str, ")}"].join("")) | |
| } else { | |
| code.push(["return this.data[", index_str, "]}"].join("")) | |
| } | |
| //view.hi(): | |
| code.push(["proto.hi=function ",className,"_hi(",args.join(","),"){return new ", className, "(this.data,", | |
| indices.map(function(i) { | |
| return ["(typeof i",i,"!=='number'||i",i,"<0)?this._shape", i, ":i", i,"|0"].join("") | |
| }).join(","), ",", | |
| indices.map(function(i) { | |
| return "this._stride"+i | |
| }).join(","), ",this.offset)}"].join("")) | |
| //view.lo(): | |
| var a_vars = indices.map(function(i) { return "a"+i+"=this._shape"+i }) | |
| var c_vars = indices.map(function(i) { return "c"+i+"=this._stride"+i }) | |
| code.push(["proto.lo=function ",className,"_lo(",args.join(","),"){var b=this.offset,d=0,", a_vars.join(","), ",", c_vars.join(",")].join("")) | |
| for(var i=0; i<dimension; ++i) { | |
| code.push([ | |
| "if(typeof i",i,"==='number'&&i",i,">=0){\ | |
| d=i",i,"|0;\ | |
| b+=c",i,"*d;\ | |
| a",i,"-=d}"].join("")) | |
| } | |
| code.push(["return new ", className, "(this.data,", | |
| indices.map(function(i) { | |
| return "a"+i | |
| }).join(","),",", | |
| indices.map(function(i) { | |
| return "c"+i | |
| }).join(","), ",b)}"].join("")) | |
| //view.step(): | |
| code.push(["proto.step=function ",className,"_step(",args.join(","),"){var ", | |
| indices.map(function(i) { | |
| return "a"+i+"=this._shape"+i | |
| }).join(","), ",", | |
| indices.map(function(i) { | |
| return "b"+i+"=this._stride"+i | |
| }).join(","),",c=this.offset,d=0,ceil=Math.ceil"].join("")) | |
| for(var i=0; i<dimension; ++i) { | |
| code.push([ | |
| "if(typeof i",i,"==='number'){\ | |
| d=i",i,"|0;\ | |
| if(d<0){\ | |
| c+=b",i,"*(a",i,"-1);\ | |
| a",i,"=ceil(-a",i,"/d)\ | |
| }else{\ | |
| a",i,"=ceil(a",i,"/d)\ | |
| }\ | |
| b",i,"*=d\ | |
| }"].join("")) | |
| } | |
| code.push(["return new ", className, "(this.data,", | |
| indices.map(function(i) { | |
| return "a" + i | |
| }).join(","), ",", | |
| indices.map(function(i) { | |
| return "b" + i | |
| }).join(","), ",c)}"].join("")) | |
| //view.transpose(): | |
| var tShape = new Array(dimension) | |
| var tStride = new Array(dimension) | |
| for(var i=0; i<dimension; ++i) { | |
| tShape[i] = ["a[i", i, "|0]"].join("") | |
| tStride[i] = ["b[i", i, "|0]"].join("") | |
| } | |
| code.push(["proto.transpose=function ",className,"_transpose(",args,"){var a=this.shape,b=this.stride;return new ", className, "(this.data,", tShape.join(","), ",", tStride.join(","), ",this.offset)}"].join("")) | |
| //view.pick(): | |
| code.push(["proto.pick=function ",className,"_pick(",args,"){var a=[],b=[],c=this.offset"].join("")) | |
| for(var i=0; i<dimension; ++i) { | |
| code.push(["if(typeof i",i,"==='number'&&i",i,">=0){c=(c+this._stride",i,"*i",i,")|0}else{a.push(this._shape",i,");b.push(this._stride",i,")}"].join("")) | |
| } | |
| code.push("var ctor=CTOR_LIST[a.length];return ctor(this.data,a,b,c)}") | |
| //Add return statement | |
| code.push(["return function construct_",className,"(data,shape,stride,offset){return new ", className,"(data,", | |
| indices.map(function(i) { | |
| return "shape["+i+"]" | |
| }).join(","), ",", | |
| indices.map(function(i) { | |
| return "stride["+i+"]" | |
| }).join(","), ",offset)}"].join("")) | |
| //Compile procedure | |
| var procedure = new Function("CTOR_LIST", "ORDER", code.join("\n")) | |
| return procedure(CACHED_CONSTRUCTORS[dtype], order) | |
| } | |
| function arrayDType(data) { | |
| if(data instanceof Float64Array) { | |
| return "float64"; | |
| } else if(data instanceof Float32Array) { | |
| return "float32" | |
| } else if(data instanceof Int32Array) { | |
| return "int32" | |
| } else if(data instanceof Uint32Array) { | |
| return "uint32" | |
| } else if(data instanceof Uint8Array) { | |
| return "uint8" | |
| } else if(data instanceof Uint16Array) { | |
| return "uint16" | |
| } else if(data instanceof Int16Array) { | |
| return "int16" | |
| } else if(data instanceof Int8Array) { | |
| return "int8" | |
| } else if(data instanceof Array) { | |
| return "array" | |
| } | |
| return "generic" | |
| } | |
| var CACHED_CONSTRUCTORS = { | |
| "float32":[], | |
| "float64":[], | |
| "int8":[], | |
| "int16":[], | |
| "int32":[], | |
| "uint8":[], | |
| "uint16":[], | |
| "uint32":[], | |
| "array":[], | |
| "generic":[] | |
| } | |
| function wrappedNDArrayCtor(data, shape, stride, offset) { | |
| if(shape === undefined) { | |
| shape = [ data.length ] | |
| } | |
| var d = shape.length | |
| if(stride === undefined) { | |
| stride = new Array(d) | |
| for(var i=d-1, sz=1; i>=0; --i) { | |
| stride[i] = sz | |
| sz *= shape[i] | |
| } | |
| } | |
| if(offset === undefined) { | |
| offset = 0 | |
| for(var i=0; i<d; ++i) { | |
| if(stride[i] < 0) { | |
| offset -= (shape[i]-1)*stride[i] | |
| } | |
| } | |
| } | |
| var dtype = arrayDType(data) | |
| var ctor_list = CACHED_CONSTRUCTORS[dtype] | |
| while(ctor_list.length <= d) { | |
| ctor_list.push(compileConstructor(dtype, ctor_list.length)) | |
| } | |
| var ctor = ctor_list[d] | |
| return ctor(data, shape, stride, offset) | |
| } | |
| module.exports = wrappedNDArrayCtor | |
| },{"iota-array":11}],8:[function(require,module,exports){ | |
| "use strict" | |
| var parse = require("cwise-parser") | |
| var compile = require("cwise-compiler") | |
| var REQUIRED_FIELDS = [ "args", "body" ] | |
| var OPTIONAL_FIELDS = [ "pre", "post", "printCode", "funcName", "blockSize" ] | |
| function createCWise(user_args) { | |
| //Check parameters | |
| for(var id in user_args) { | |
| if(REQUIRED_FIELDS.indexOf(id) < 0 && | |
| OPTIONAL_FIELDS.indexOf(id) < 0) { | |
| console.warn("cwise: Unknown argument '"+id+"' passed to expression compiler") | |
| } | |
| } | |
| for(var i=0; i<REQUIRED_FIELDS.length; ++i) { | |
| if(!user_args[REQUIRED_FIELDS[i]]) { | |
| throw new Error("cwise: Missing argument: " + REQUIRED_FIELDS[i]) | |
| } | |
| } | |
| //Parse blocks | |
| return compile({ | |
| args: user_args.args, | |
| pre: parse(user_args.pre || function(){}), | |
| body: parse(user_args.body), | |
| post: parse(user_args.post || function(){}), | |
| debug: !!user_args.printCode, | |
| funcName: user_args.funcName || user_args.body.name || "cwise", | |
| blockSize: user_args.blockSize || 64 | |
| }) | |
| } | |
| module.exports = createCWise | |
| },{"cwise-parser":12,"cwise-compiler":13}],11:[function(require,module,exports){ | |
| "use strict" | |
| function iota(n) { | |
| var result = new Array(n) | |
| for(var i=0; i<n; ++i) { | |
| result[i] = i | |
| } | |
| return result | |
| } | |
| module.exports = iota | |
| },{}],10:[function(require,module,exports){ | |
| "use strict" | |
| var createThunk = require("./lib/thunk.js") | |
| function Procedure() { | |
| this.argTypes = [] | |
| this.shimArgs = [] | |
| this.arrayArgs = [] | |
| this.scalarArgs = [] | |
| this.indexArgs = [] | |
| this.shapeArgs = [] | |
| this.funcName = "" | |
| this.pre = null | |
| this.body = null | |
| this.post = null | |
| this.debug = false | |
| } | |
| function compileCwise(user_args) { | |
| //Create procedure | |
| var proc = new Procedure() | |
| //Parse blocks | |
| proc.pre = user_args.pre | |
| proc.body = user_args.body | |
| proc.post = user_args.post | |
| //Parse arguments | |
| var proc_args = user_args.args.slice(0) | |
| proc.argTypes = proc_args | |
| for(var i=0; i<proc_args.length; ++i) { | |
| switch(proc_args[i]) { | |
| case "array": | |
| proc.arrayArgs.push(i) | |
| proc.shimArgs.push("array" + i) | |
| if(i < proc.pre.args.length && proc.pre.args[i].count>0) { | |
| throw new Error("cwise: pre() block may not reference array args") | |
| } | |
| if(i < proc.post.args.length && proc.post.args[i].count>0) { | |
| throw new Error("cwise: post() block may not reference array args") | |
| } | |
| break | |
| case "scalar": | |
| proc.scalarArgs.push(i) | |
| proc.shimArgs.push("scalar" + i) | |
| break | |
| case "index": | |
| proc.indexArgs.push(i) | |
| if(i < proc.pre.args.length && proc.pre.args[i].count > 0) { | |
| throw new Error("cwise: pre() block may not reference array index") | |
| } | |
| if(i < proc.body.args.length && proc.body.args[i].lvalue) { | |
| throw new Error("cwise: body() block may not write to array index") | |
| } | |
| if(i < proc.post.args.length && proc.post.args[i].count > 0) { | |
| throw new Error("cwise: post() block may not reference array index") | |
| } | |
| break | |
| case "shape": | |
| proc.shapeArgs.push(i) | |
| if(i < proc.pre.args.length && proc.pre.args[i].lvalue) { | |
| throw new Error("cwise: pre() block may not write to array shape") | |
| } | |
| if(i < proc.body.args.length && proc.body.args[i].lvalue) { | |
| throw new Error("cwise: body() block may not write to array shape") | |
| } | |
| if(i < proc.post.args.length && proc.post.args[i].lvalue) { | |
| throw new Error("cwise: post() block may not write to array shape") | |
| } | |
| break | |
| default: | |
| throw new Error("cwise: Unknown argument type " + proc_args[i]) | |
| } | |
| } | |
| //Make sure at least one array argument was specified | |
| if(proc.arrayArgs.length <= 0) { | |
| throw new Error("cwise: No array arguments specified") | |
| } | |
| //Make sure arguments are correct | |
| if(proc.pre.args.length > proc_args.length) { | |
| throw new Error("cwise: Too many arguments in pre() block") | |
| } | |
| if(proc.body.args.length > proc_args.length) { | |
| throw new Error("cwise: Too many arguments in body() block") | |
| } | |
| if(proc.post.args.length > proc_args.length) { | |
| throw new Error("cwise: Too many arguments in post() block") | |
| } | |
| //Check debug flag | |
| proc.debug = !!user_args.printCode || !!user_args.debug | |
| //Retrieve name | |
| proc.funcName = user_args.funcName || "cwise" | |
| //Read in block size | |
| proc.blockSize = user_args.blockSize || 64 | |
| return createThunk(proc) | |
| } | |
| module.exports = compileCwise | |
| },{"./lib/thunk.js":14}],13:[function(require,module,exports){ | |
| "use strict" | |
| var createThunk = require("./lib/thunk.js") | |
| function Procedure() { | |
| this.argTypes = [] | |
| this.shimArgs = [] | |
| this.arrayArgs = [] | |
| this.scalarArgs = [] | |
| this.indexArgs = [] | |
| this.shapeArgs = [] | |
| this.funcName = "" | |
| this.pre = null | |
| this.body = null | |
| this.post = null | |
| this.debug = false | |
| } | |
| function compileCwise(user_args) { | |
| //Create procedure | |
| var proc = new Procedure() | |
| //Parse blocks | |
| proc.pre = user_args.pre | |
| proc.body = user_args.body | |
| proc.post = user_args.post | |
| //Parse arguments | |
| var proc_args = user_args.args.slice(0) | |
| proc.argTypes = proc_args | |
| for(var i=0; i<proc_args.length; ++i) { | |
| switch(proc_args[i]) { | |
| case "array": | |
| proc.arrayArgs.push(i) | |
| proc.shimArgs.push("array" + i) | |
| if(i < proc.pre.args.length && proc.pre.args[i].count>0) { | |
| throw new Error("cwise: pre() block may not reference array args") | |
| } | |
| if(i < proc.post.args.length && proc.post.args[i].count>0) { | |
| throw new Error("cwise: post() block may not reference array args") | |
| } | |
| break | |
| case "scalar": | |
| proc.scalarArgs.push(i) | |
| proc.shimArgs.push("scalar" + i) | |
| break | |
| case "index": | |
| proc.indexArgs.push(i) | |
| if(i < proc.pre.args.length && proc.pre.args[i].count > 0) { | |
| throw new Error("cwise: pre() block may not reference array index") | |
| } | |
| if(i < proc.body.args.length && proc.body.args[i].lvalue) { | |
| throw new Error("cwise: body() block may not write to array index") | |
| } | |
| if(i < proc.post.args.length && proc.post.args[i].count > 0) { | |
| throw new Error("cwise: post() block may not reference array index") | |
| } | |
| break | |
| case "shape": | |
| proc.shapeArgs.push(i) | |
| if(i < proc.pre.args.length && proc.pre.args[i].lvalue) { | |
| throw new Error("cwise: pre() block may not write to array shape") | |
| } | |
| if(i < proc.body.args.length && proc.body.args[i].lvalue) { | |
| throw new Error("cwise: body() block may not write to array shape") | |
| } | |
| if(i < proc.post.args.length && proc.post.args[i].lvalue) { | |
| throw new Error("cwise: post() block may not write to array shape") | |
| } | |
| break | |
| default: | |
| throw new Error("cwise: Unknown argument type " + proc_args[i]) | |
| } | |
| } | |
| //Make sure at least one array argument was specified | |
| if(proc.arrayArgs.length <= 0) { | |
| throw new Error("cwise: No array arguments specified") | |
| } | |
| //Make sure arguments are correct | |
| if(proc.pre.args.length > proc_args.length) { | |
| throw new Error("cwise: Too many arguments in pre() block") | |
| } | |
| if(proc.body.args.length > proc_args.length) { | |
| throw new Error("cwise: Too many arguments in body() block") | |
| } | |
| if(proc.post.args.length > proc_args.length) { | |
| throw new Error("cwise: Too many arguments in post() block") | |
| } | |
| //Check debug flag | |
| proc.debug = !!user_args.printCode || !!user_args.debug | |
| //Retrieve name | |
| proc.funcName = user_args.funcName || "cwise" | |
| //Read in block size | |
| proc.blockSize = user_args.blockSize || 64 | |
| return createThunk(proc) | |
| } | |
| module.exports = compileCwise | |
| },{"./lib/thunk.js":15}],9:[function(require,module,exports){ | |
| "use strict" | |
| var esprima = require("esprima") | |
| var uniq = require("uniq") | |
| var PREFIX_COUNTER = 0 | |
| function CompiledArgument(name, lvalue, rvalue) { | |
| this.name = name | |
| this.lvalue = lvalue | |
| this.rvalue = rvalue | |
| this.count = 0 | |
| } | |
| function CompiledRoutine(body, args, thisVars, localVars) { | |
| this.body = body | |
| this.args = args | |
| this.thisVars = thisVars | |
| this.localVars = localVars | |
| } | |
| function isGlobal(identifier) { | |
| if(identifier === "eval") { | |
| throw new Error("cwise-parser: eval() not allowed") | |
| } | |
| if(typeof window !== "undefined") { | |
| return identifier in window | |
| } else if(typeof GLOBAL !== "undefined") { | |
| return identifier in GLOBAL | |
| } else if(typeof self !== "undefined") { | |
| return identifier in self | |
| } else { | |
| return false | |
| } | |
| } | |
| function getArgNames(ast) { | |
| var params = ast.body[0].expression.callee.params | |
| var names = new Array(params.length) | |
| for(var i=0; i<params.length; ++i) { | |
| names[i] = params[i].name | |
| } | |
| return names | |
| } | |
| function preprocess(func) { | |
| var src = ["(", func, ")()"].join("") | |
| var ast = esprima.parse(src, { range: true }) | |
| //Compute new prefix | |
| var prefix = "_inline_" + (PREFIX_COUNTER++) + "_" | |
| //Parse out arguments | |
| var argNames = getArgNames(ast) | |
| var compiledArgs = new Array(argNames.length) | |
| for(var i=0; i<argNames.length; ++i) { | |
| compiledArgs[i] = new CompiledArgument([prefix, "arg", i, "_"].join(""), false, false) | |
| } | |
| //Create temporary data structure for source rewriting | |
| var exploded = new Array(src.length) | |
| for(var i=0, n=src.length; i<n; ++i) { | |
| exploded[i] = src.charAt(i) | |
| } | |
| //Local variables | |
| var localVars = [] | |
| var thisVars = [] | |
| var computedThis = false | |
| //Retrieves a local variable | |
| function createLocal(id) { | |
| var nstr = prefix + id.replace(/\_/g, "__") | |
| localVars.push(nstr) | |
| return nstr | |
| } | |
| //Creates a this variable | |
| function createThisVar(id) { | |
| var nstr = "this_" + id.replace(/\_/g, "__") | |
| thisVars.push(nstr) | |
| return nstr | |
| } | |
| //Rewrites an ast node | |
| function rewrite(node, nstr) { | |
| var lo = node.range[0], hi = node.range[1] | |
| for(var i=lo+1; i<hi; ++i) { | |
| exploded[i] = "" | |
| } | |
| exploded[lo] = nstr | |
| } | |
| //Remove any underscores | |
| function escapeString(str) { | |
| return "'"+(str.replace(/\_/g, "\\_").replace(/\'/g, "\'"))+"'" | |
| } | |
| //Returns the source of an identifier | |
| function source(node) { | |
| return exploded.slice(node.range[0], node.range[1]).join("") | |
| } | |
| //Computes the usage of a node | |
| var LVALUE = 1 | |
| var RVALUE = 2 | |
| function getUsage(node) { | |
| if(node.parent.type === "AssignmentExpression") { | |
| if(node.parent.left === node) { | |
| if(node.parent.operator === "=") { | |
| return LVALUE | |
| } | |
| return LVALUE|RVALUE | |
| } | |
| } | |
| if(node.parent.type === "UpdateExpression") { | |
| return LVALUE|RVALUE | |
| } | |
| return RVALUE | |
| } | |
| //Handle visiting a node | |
| (function visit(node, parent) { | |
| node.parent = parent | |
| if(node.type === "MemberExpression") { | |
| //Handle member expression | |
| if(node.computed) { | |
| visit(node.object, node) | |
| visit(node.property, node) | |
| } else if(node.object.type === "ThisExpression") { | |
| rewrite(node, createThisVar(node.property.name)) | |
| } else { | |
| visit(node.object, node) | |
| } | |
| } else if(node.type === "ThisExpression") { | |
| throw new Error("cwise-parser: Computed this is not allowed") | |
| } else if(node.type === "Identifier") { | |
| //Handle identifier | |
| var name = node.name | |
| var argNo = argNames.indexOf(name) | |
| if(argNo >= 0) { | |
| var carg = compiledArgs[argNo] | |
| var usage = getUsage(node) | |
| if(usage & LVALUE) { | |
| carg.lvalue = true | |
| } | |
| if(usage & RVALUE) { | |
| carg.rvalue = true | |
| } | |
| ++carg.count | |
| rewrite(node, carg.name) | |
| } else if(isGlobal(name)) { | |
| //Don't rewrite globals | |
| } else { | |
| rewrite(node, createLocal(name)) | |
| } | |
| } else if(node.type === "Literal") { | |
| if(typeof node.value === "string") { | |
| rewrite(node, escapeString(node.value)) | |
| } | |
| } else if(node.type === "WithStatement") { | |
| throw new Error("cwise-parser: with() statements not allowed") | |
| } else { | |
| //Visit all children | |
| var keys = Object.keys(node) | |
| for(var i=0, n=keys.length; i<n; ++i) { | |
| if(keys[i] === "parent") { | |
| continue | |
| } | |
| var value = node[keys[i]] | |
| if(value) { | |
| if(value instanceof Array) { | |
| for(var j=0; j<value.length; ++j) { | |
| if(value[j] && typeof value[j].type === "string") { | |
| visit(value[j], node) | |
| } | |
| } | |
| } else if(typeof value.type === "string") { | |
| visit(value, node) | |
| } | |
| } | |
| } | |
| } | |
| })(ast.body[0].expression.callee.body, undefined) | |
| //Remove duplicate variables | |
| uniq(localVars) | |
| uniq(thisVars) | |
| //Return body | |
| var routine = new CompiledRoutine(source(ast.body[0].expression.callee.body), compiledArgs, thisVars, localVars) | |
| return routine | |
| } | |
| module.exports = preprocess | |
| },{"esprima":16,"uniq":17}],12:[function(require,module,exports){ | |
| "use strict" | |
| var esprima = require("esprima") | |
| var uniq = require("uniq") | |
| var PREFIX_COUNTER = 0 | |
| function CompiledArgument(name, lvalue, rvalue) { | |
| this.name = name | |
| this.lvalue = lvalue | |
| this.rvalue = rvalue | |
| this.count = 0 | |
| } | |
| function CompiledRoutine(body, args, thisVars, localVars) { | |
| this.body = body | |
| this.args = args | |
| this.thisVars = thisVars | |
| this.localVars = localVars | |
| } | |
| function isGlobal(identifier) { | |
| if(identifier === "eval") { | |
| throw new Error("cwise-parser: eval() not allowed") | |
| } | |
| if(typeof window !== "undefined") { | |
| return identifier in window | |
| } else if(typeof GLOBAL !== "undefined") { | |
| return identifier in GLOBAL | |
| } else if(typeof self !== "undefined") { | |
| return identifier in self | |
| } else { | |
| return false | |
| } | |
| } | |
| function getArgNames(ast) { | |
| var params = ast.body[0].expression.callee.params | |
| var names = new Array(params.length) | |
| for(var i=0; i<params.length; ++i) { | |
| names[i] = params[i].name | |
| } | |
| return names | |
| } | |
| function preprocess(func) { | |
| var src = ["(", func, ")()"].join("") | |
| var ast = esprima.parse(src, { range: true }) | |
| //Compute new prefix | |
| var prefix = "_inline_" + (PREFIX_COUNTER++) + "_" | |
| //Parse out arguments | |
| var argNames = getArgNames(ast) | |
| var compiledArgs = new Array(argNames.length) | |
| for(var i=0; i<argNames.length; ++i) { | |
| compiledArgs[i] = new CompiledArgument([prefix, "arg", i, "_"].join(""), false, false) | |
| } | |
| //Create temporary data structure for source rewriting | |
| var exploded = new Array(src.length) | |
| for(var i=0, n=src.length; i<n; ++i) { | |
| exploded[i] = src.charAt(i) | |
| } | |
| //Local variables | |
| var localVars = [] | |
| var thisVars = [] | |
| var computedThis = false | |
| //Retrieves a local variable | |
| function createLocal(id) { | |
| var nstr = prefix + id.replace(/\_/g, "__") | |
| localVars.push(nstr) | |
| return nstr | |
| } | |
| //Creates a this variable | |
| function createThisVar(id) { | |
| var nstr = "this_" + id.replace(/\_/g, "__") | |
| thisVars.push(nstr) | |
| return nstr | |
| } | |
| //Rewrites an ast node | |
| function rewrite(node, nstr) { | |
| var lo = node.range[0], hi = node.range[1] | |
| for(var i=lo+1; i<hi; ++i) { | |
| exploded[i] = "" | |
| } | |
| exploded[lo] = nstr | |
| } | |
| //Remove any underscores | |
| function escapeString(str) { | |
| return "'"+(str.replace(/\_/g, "\\_").replace(/\'/g, "\'"))+"'" | |
| } | |
| //Returns the source of an identifier | |
| function source(node) { | |
| return exploded.slice(node.range[0], node.range[1]).join("") | |
| } | |
| //Computes the usage of a node | |
| var LVALUE = 1 | |
| var RVALUE = 2 | |
| function getUsage(node) { | |
| if(node.parent.type === "AssignmentExpression") { | |
| if(node.parent.left === node) { | |
| if(node.parent.operator === "=") { | |
| return LVALUE | |
| } | |
| return LVALUE|RVALUE | |
| } | |
| } | |
| if(node.parent.type === "UpdateExpression") { | |
| return LVALUE|RVALUE | |
| } | |
| return RVALUE | |
| } | |
| //Handle visiting a node | |
| (function visit(node, parent) { | |
| node.parent = parent | |
| if(node.type === "MemberExpression") { | |
| //Handle member expression | |
| if(node.computed) { | |
| visit(node.object, node) | |
| visit(node.property, node) | |
| } else if(node.object.type === "ThisExpression") { | |
| rewrite(node, createThisVar(node.property.name)) | |
| } else { | |
| visit(node.object, node) | |
| } | |
| } else if(node.type === "ThisExpression") { | |
| throw new Error("cwise-parser: Computed this is not allowed") | |
| } else if(node.type === "Identifier") { | |
| //Handle identifier | |
| var name = node.name | |
| var argNo = argNames.indexOf(name) | |
| if(argNo >= 0) { | |
| var carg = compiledArgs[argNo] | |
| var usage = getUsage(node) | |
| if(usage & LVALUE) { | |
| carg.lvalue = true | |
| } | |
| if(usage & RVALUE) { | |
| carg.rvalue = true | |
| } | |
| ++carg.count | |
| rewrite(node, carg.name) | |
| } else if(isGlobal(name)) { | |
| //Don't rewrite globals | |
| } else { | |
| rewrite(node, createLocal(name)) | |
| } | |
| } else if(node.type === "Literal") { | |
| if(typeof node.value === "string") { | |
| rewrite(node, escapeString(node.value)) | |
| } | |
| } else if(node.type === "WithStatement") { | |
| throw new Error("cwise-parser: with() statements not allowed") | |
| } else { | |
| //Visit all children | |
| var keys = Object.keys(node) | |
| for(var i=0, n=keys.length; i<n; ++i) { | |
| if(keys[i] === "parent") { | |
| continue | |
| } | |
| var value = node[keys[i]] | |
| if(value) { | |
| if(value instanceof Array) { | |
| for(var j=0; j<value.length; ++j) { | |
| if(value[j] && typeof value[j].type === "string") { | |
| visit(value[j], node) | |
| } | |
| } | |
| } else if(typeof value.type === "string") { | |
| visit(value, node) | |
| } | |
| } | |
| } | |
| } | |
| })(ast.body[0].expression.callee.body, undefined) | |
| //Remove duplicate variables | |
| uniq(localVars) | |
| uniq(thisVars) | |
| //Return body | |
| var routine = new CompiledRoutine(source(ast.body[0].expression.callee.body), compiledArgs, thisVars, localVars) | |
| return routine | |
| } | |
| module.exports = preprocess | |
| },{"esprima":18,"uniq":19}],14:[function(require,module,exports){ | |
| "use strict" | |
| var compile = require("./compile.js") | |
| function createThunk(proc) { | |
| var code = ["'use strict'", "var CACHED={}"] | |
| var vars = [] | |
| var thunkName = proc.funcName + "_cwise_thunk" | |
| //Build thunk | |
| code.push(["return function ", thunkName, "(", proc.shimArgs.join(","), "){"].join("")) | |
| var typesig = [] | |
| var string_typesig = [] | |
| var proc_args = [["array",proc.arrayArgs[0],".shape"].join("")] | |
| for(var i=0; i<proc.arrayArgs.length; ++i) { | |
| var j = proc.arrayArgs[i] | |
| vars.push(["t", j, "=array", j, ".dtype,", | |
| "r", j, "=array", j, ".order"].join("")) | |
| typesig.push("t" + j) | |
| typesig.push("r" + j) | |
| string_typesig.push("t"+j) | |
| string_typesig.push("r"+j+".join()") | |
| proc_args.push("array" + j + ".data") | |
| proc_args.push("array" + j + ".stride") | |
| proc_args.push("array" + j + ".offset|0") | |
| } | |
| for(var i=0; i<proc.scalarArgs.length; ++i) { | |
| proc_args.push("scalar" + proc.scalarArgs[i]) | |
| } | |
| vars.push(["type=[", string_typesig.join(","), "].join()"].join("")) | |
| vars.push("proc=CACHED[type]") | |
| code.push("var " + vars.join(",")) | |
| code.push(["if(!proc){", | |
| "CACHED[type]=proc=compile([", typesig.join(","), "])}", | |
| "return proc(", proc_args.join(","), ")}"].join("")) | |
| if(proc.debug) { | |
| console.log("Generated thunk:", code.join("\n")) | |
| } | |
| //Compile thunk | |
| var thunk = new Function("compile", code.join("\n")) | |
| return thunk(compile.bind(undefined, proc)) | |
| } | |
| module.exports = createThunk | |
| },{"./compile.js":20}],16:[function(require,module,exports){ | |
| (function(){/* | |
| Copyright (C) 2012 Ariya Hidayat <[email protected]> | |
| Copyright (C) 2012 Mathias Bynens <[email protected]> | |
| Copyright (C) 2012 Joost-Wim Boekesteijn <[email protected]> | |
| Copyright (C) 2012 Kris Kowal <[email protected]> | |
| Copyright (C) 2012 Yusuke Suzuki <[email protected]> | |
| Copyright (C) 2012 Arpad Borsos <[email protected]> | |
| Copyright (C) 2011 Ariya Hidayat <[email protected]> | |
| Redistribution and use in source and binary forms, with or without | |
| modification, are permitted provided that the following conditions are met: | |
| * Redistributions of source code must retain the above copyright | |
| notice, this list of conditions and the following disclaimer. | |
| * Redistributions in binary form must reproduce the above copyright | |
| notice, this list of conditions and the following disclaimer in the | |
| documentation and/or other materials provided with the distribution. | |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" | |
| AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
| IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
| ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY | |
| DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | |
| (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | |
| LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | |
| ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
| (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF | |
| THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| */ | |
| /*jslint bitwise:true plusplus:true */ | |
| /*global esprima:true, define:true, exports:true, window: true, | |
| throwError: true, createLiteral: true, generateStatement: true, | |
| parseAssignmentExpression: true, parseBlock: true, parseExpression: true, | |
| parseFunctionDeclaration: true, parseFunctionExpression: true, | |
| parseFunctionSourceElements: true, parseVariableIdentifier: true, | |
| parseLeftHandSideExpression: true, | |
| parseStatement: true, parseSourceElement: true */ | |
| (function (root, factory) { | |
| 'use strict'; | |
| // Universal Module Definition (UMD) to support AMD, CommonJS/Node.js, | |
| // Rhino, and plain browser loading. | |
| if (typeof define === 'function' && define.amd) { | |
| define(['exports'], factory); | |
| } else if (typeof exports !== 'undefined') { | |
| factory(exports); | |
| } else { | |
| factory((root.esprima = {})); | |
| } | |
| }(this, function (exports) { | |
| 'use strict'; | |
| var Token, | |
| TokenName, | |
| Syntax, | |
| PropertyKind, | |
| Messages, | |
| Regex, | |
| source, | |
| strict, | |
| index, | |
| lineNumber, | |
| lineStart, | |
| length, | |
| buffer, | |
| state, | |
| extra; | |
| Token = { | |
| BooleanLiteral: 1, | |
| EOF: 2, | |
| Identifier: 3, | |
| Keyword: 4, | |
| NullLiteral: 5, | |
| NumericLiteral: 6, | |
| Punctuator: 7, | |
| StringLiteral: 8 | |
| }; | |
| TokenName = {}; | |
| TokenName[Token.BooleanLiteral] = 'Boolean'; | |
| TokenName[Token.EOF] = '<end>'; | |
| TokenName[Token.Identifier] = 'Identifier'; | |
| TokenName[Token.Keyword] = 'Keyword'; | |
| TokenName[Token.NullLiteral] = 'Null'; | |
| TokenName[Token.NumericLiteral] = 'Numeric'; | |
| TokenName[Token.Punctuator] = 'Punctuator'; | |
| TokenName[Token.StringLiteral] = 'String'; | |
| Syntax = { | |
| AssignmentExpression: 'AssignmentExpression', | |
| ArrayExpression: 'ArrayExpression', | |
| BlockStatement: 'BlockStatement', | |
| BinaryExpression: 'BinaryExpression', | |
| BreakStatement: 'BreakStatement', | |
| CallExpression: 'CallExpression', | |
| CatchClause: 'CatchClause', | |
| ConditionalExpression: 'ConditionalExpression', | |
| ContinueStatement: 'ContinueStatement', | |
| DoWhileStatement: 'DoWhileStatement', | |
| DebuggerStatement: 'DebuggerStatement', | |
| EmptyStatement: 'EmptyStatement', | |
| ExpressionStatement: 'ExpressionStatement', | |
| ForStatement: 'ForStatement', | |
| ForInStatement: 'ForInStatement', | |
| FunctionDeclaration: 'FunctionDeclaration', | |
| FunctionExpression: 'FunctionExpression', | |
| Identifier: 'Identifier', | |
| IfStatement: 'IfStatement', | |
| Literal: 'Literal', | |
| LabeledStatement: 'LabeledStatement', | |
| LogicalExpression: 'LogicalExpression', | |
| MemberExpression: 'MemberExpression', | |
| NewExpression: 'NewExpression', | |
| ObjectExpression: 'ObjectExpression', | |
| Program: 'Program', | |
| Property: 'Property', | |
| ReturnStatement: 'ReturnStatement', | |
| SequenceExpression: 'SequenceExpression', | |
| SwitchStatement: 'SwitchStatement', | |
| SwitchCase: 'SwitchCase', | |
| ThisExpression: 'ThisExpression', | |
| ThrowStatement: 'ThrowStatement', | |
| TryStatement: 'TryStatement', | |
| UnaryExpression: 'UnaryExpression', | |
| UpdateExpression: 'UpdateExpression', | |
| VariableDeclaration: 'VariableDeclaration', | |
| VariableDeclarator: 'VariableDeclarator', | |
| WhileStatement: 'WhileStatement', | |
| WithStatement: 'WithStatement' | |
| }; | |
| PropertyKind = { | |
| Data: 1, | |
| Get: 2, | |
| Set: 4 | |
| }; | |
| // Error messages should be identical to V8. | |
| Messages = { | |
| UnexpectedToken: 'Unexpected token %0', | |
| UnexpectedNumber: 'Unexpected number', | |
| UnexpectedString: 'Unexpected string', | |
| UnexpectedIdentifier: 'Unexpected identifier', | |
| UnexpectedReserved: 'Unexpected reserved word', | |
| UnexpectedEOS: 'Unexpected end of input', | |
| NewlineAfterThrow: 'Illegal newline after throw', | |
| InvalidRegExp: 'Invalid regular expression', | |
| UnterminatedRegExp: 'Invalid regular expression: missing /', | |
| InvalidLHSInAssignment: 'Invalid left-hand side in assignment', | |
| InvalidLHSInForIn: 'Invalid left-hand side in for-in', | |
| MultipleDefaultsInSwitch: 'More than one default clause in switch statement', | |
| NoCatchOrFinally: 'Missing catch or finally after try', | |
| UnknownLabel: 'Undefined label \'%0\'', | |
| Redeclaration: '%0 \'%1\' has already been declared', | |
| IllegalContinue: 'Illegal continue statement', | |
| IllegalBreak: 'Illegal break statement', | |
| IllegalReturn: 'Illegal return statement', | |
| StrictModeWith: 'Strict mode code may not include a with statement', | |
| StrictCatchVariable: 'Catch variable may not be eval or arguments in strict mode', | |
| StrictVarName: 'Variable name may not be eval or arguments in strict mode', | |
| StrictParamName: 'Parameter name eval or arguments is not allowed in strict mode', | |
| StrictParamDupe: 'Strict mode function may not have duplicate parameter names', | |
| StrictFunctionName: 'Function name may not be eval or arguments in strict mode', | |
| StrictOctalLiteral: 'Octal literals are not allowed in strict mode.', | |
| StrictDelete: 'Delete of an unqualified identifier in strict mode.', | |
| StrictDuplicateProperty: 'Duplicate data property in object literal not allowed in strict mode', | |
| AccessorDataProperty: 'Object literal may not have data and accessor property with the same name', | |
| AccessorGetSet: 'Object literal may not have multiple get/set accessors with the same name', | |
| StrictLHSAssignment: 'Assignment to eval or arguments is not allowed in strict mode', | |
| StrictLHSPostfix: 'Postfix increment/decrement may not have eval or arguments operand in strict mode', | |
| StrictLHSPrefix: 'Prefix increment/decrement may not have eval or arguments operand in strict mode', | |
| StrictReservedWord: 'Use of future reserved word in strict mode' | |
| }; | |
| // See also tools/generate-unicode-regex.py. | |
| Regex = { | |
| NonAsciiIdentifierStart: new RegExp('[\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0\u08a2-\u08ac\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097f\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d\u0c58\u0c59\u0c60\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d60\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191c\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19c1-\u19c7\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua697\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa80-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc]'), | |
| NonAsciiIdentifierPart: new RegExp('[\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0300-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u0483-\u0487\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u05d0-\u05ea\u05f0-\u05f2\u0610-\u061a\u0620-\u0669\u066e-\u06d3\u06d5-\u06dc\u06df-\u06e8\u06ea-\u06fc\u06ff\u0710-\u074a\u074d-\u07b1\u07c0-\u07f5\u07fa\u0800-\u082d\u0840-\u085b\u08a0\u08a2-\u08ac\u08e4-\u08fe\u0900-\u0963\u0966-\u096f\u0971-\u0977\u0979-\u097f\u0981-\u0983\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bc-\u09c4\u09c7\u09c8\u09cb-\u09ce\u09d7\u09dc\u09dd\u09df-\u09e3\u09e6-\u09f1\u0a01-\u0a03\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a59-\u0a5c\u0a5e\u0a66-\u0a75\u0a81-\u0a83\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abc-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ad0\u0ae0-\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3c-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b5c\u0b5d\u0b5f-\u0b63\u0b66-\u0b6f\u0b71\u0b82\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd0\u0bd7\u0be6-\u0bef\u0c01-\u0c03\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c58\u0c59\u0c60-\u0c63\u0c66-\u0c6f\u0c82\u0c83\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbc-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0cde\u0ce0-\u0ce3\u0ce6-\u0cef\u0cf1\u0cf2\u0d02\u0d03\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d-\u0d44\u0d46-\u0d48\u0d4a-\u0d4e\u0d57\u0d60-\u0d63\u0d66-\u0d6f\u0d7a-\u0d7f\u0d82\u0d83\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2\u0df3\u0e01-\u0e3a\u0e40-\u0e4e\u0e50-\u0e59\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb9\u0ebb-\u0ebd\u0ec0-\u0ec4\u0ec6\u0ec8-\u0ecd\u0ed0-\u0ed9\u0edc-\u0edf\u0f00\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e-\u0f47\u0f49-\u0f6c\u0f71-\u0f84\u0f86-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1049\u1050-\u109d\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u135d-\u135f\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176c\u176e-\u1770\u1772\u1773\u1780-\u17d3\u17d7\u17dc\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u1820-\u1877\u1880-\u18aa\u18b0-\u18f5\u1900-\u191c\u1920-\u192b\u1930-\u193b\u1946-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u19d0-\u19d9\u1a00-\u1a1b\u1a20-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1aa7\u1b00-\u1b4b\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1bf3\u1c00-\u1c37\u1c40-\u1c49\u1c4d-\u1c7d\u1cd0-\u1cd2\u1cd4-\u1cf6\u1d00-\u1de6\u1dfc-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u200c\u200d\u203f\u2040\u2054\u2071\u207f\u2090-\u209c\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d7f-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2de0-\u2dff\u2e2f\u3005-\u3007\u3021-\u302f\u3031-\u3035\u3038-\u303c\u3041-\u3096\u3099\u309a\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua62b\ua640-\ua66f\ua674-\ua67d\ua67f-\ua697\ua69f-\ua6f1\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua827\ua840-\ua873\ua880-\ua8c4\ua8d0-\ua8d9\ua8e0-\ua8f7\ua8fb\ua900-\ua92d\ua930-\ua953\ua960-\ua97c\ua980-\ua9c0\ua9cf-\ua9d9\uaa00-\uaa36\uaa40-\uaa4d\uaa50-\uaa59\uaa60-\uaa76\uaa7a\uaa7b\uaa80-\uaac2\uaadb-\uaadd\uaae0-\uaaef\uaaf2-\uaaf6\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabea\uabec\uabed\uabf0-\uabf9\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe00-\ufe0f\ufe20-\ufe26\ufe33\ufe34\ufe4d-\ufe4f\ufe70-\ufe74\ufe76-\ufefc\uff10-\uff19\uff21-\uff3a\uff3f\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc]') | |
| }; | |
| // Ensure the condition is true, otherwise throw an error. | |
| // This is only to have a better contract semantic, i.e. another safety net | |
| // to catch a logic error. The condition shall be fulfilled in normal case. | |
| // Do NOT use this to enforce a certain condition on any user input. | |
| function assert(condition, message) { | |
| if (!condition) { | |
| throw new Error('ASSERT: ' + message); | |
| } | |
| } | |
| function sliceSource(from, to) { | |
| return source.slice(from, to); | |
| } | |
| if (typeof 'esprima'[0] === 'undefined') { | |
| sliceSource = function sliceArraySource(from, to) { | |
| return source.slice(from, to).join(''); | |
| }; | |
| } | |
| function isDecimalDigit(ch) { | |
| return '0123456789'.indexOf(ch) >= 0; | |
| } | |
| function isHexDigit(ch) { | |
| return '0123456789abcdefABCDEF'.indexOf(ch) >= 0; | |
| } | |
| function isOctalDigit(ch) { | |
| return '01234567'.indexOf(ch) >= 0; | |
| } | |
| // 7.2 White Space | |
| function isWhiteSpace(ch) { | |
| return (ch === ' ') || (ch === '\u0009') || (ch === '\u000B') || | |
| (ch === '\u000C') || (ch === '\u00A0') || | |
| (ch.charCodeAt(0) >= 0x1680 && | |
| '\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\uFEFF'.indexOf(ch) >= 0); | |
| } | |
| // 7.3 Line Terminators | |
| function isLineTerminator(ch) { | |
| return (ch === '\n' || ch === '\r' || ch === '\u2028' || ch === '\u2029'); | |
| } | |
| // 7.6 Identifier Names and Identifiers | |
| function isIdentifierStart(ch) { | |
| return (ch === '$') || (ch === '_') || (ch === '\\') || | |
| (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || | |
| ((ch.charCodeAt(0) >= 0x80) && Regex.NonAsciiIdentifierStart.test(ch)); | |
| } | |
| function isIdentifierPart(ch) { | |
| return (ch === '$') || (ch === '_') || (ch === '\\') || | |
| (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || | |
| ((ch >= '0') && (ch <= '9')) || | |
| ((ch.charCodeAt(0) >= 0x80) && Regex.NonAsciiIdentifierPart.test(ch)); | |
| } | |
| // 7.6.1.2 Future Reserved Words | |
| function isFutureReservedWord(id) { | |
| switch (id) { | |
| // Future reserved words. | |
| case 'class': | |
| case 'enum': | |
| case 'export': | |
| case 'extends': | |
| case 'import': | |
| case 'super': | |
| return true; | |
| } | |
| return false; | |
| } | |
| function isStrictModeReservedWord(id) { | |
| switch (id) { | |
| // Strict Mode reserved words. | |
| case 'implements': | |
| case 'interface': | |
| case 'package': | |
| case 'private': | |
| case 'protected': | |
| case 'public': | |
| case 'static': | |
| case 'yield': | |
| case 'let': | |
| return true; | |
| } | |
| return false; | |
| } | |
| function isRestrictedWord(id) { | |
| return id === 'eval' || id === 'arguments'; | |
| } | |
| // 7.6.1.1 Keywords | |
| function isKeyword(id) { | |
| var keyword = false; | |
| switch (id.length) { | |
| case 2: | |
| keyword = (id === 'if') || (id === 'in') || (id === 'do'); | |
| break; | |
| case 3: | |
| keyword = (id === 'var') || (id === 'for') || (id === 'new') || (id === 'try'); | |
| break; | |
| case 4: | |
| keyword = (id === 'this') || (id === 'else') || (id === 'case') || (id === 'void') || (id === 'with'); | |
| break; | |
| case 5: | |
| keyword = (id === 'while') || (id === 'break') || (id === 'catch') || (id === 'throw'); | |
| break; | |
| case 6: | |
| keyword = (id === 'return') || (id === 'typeof') || (id === 'delete') || (id === 'switch'); | |
| break; | |
| case 7: | |
| keyword = (id === 'default') || (id === 'finally'); | |
| break; | |
| case 8: | |
| keyword = (id === 'function') || (id === 'continue') || (id === 'debugger'); | |
| break; | |
| case 10: | |
| keyword = (id === 'instanceof'); | |
| break; | |
| } | |
| if (keyword) { | |
| return true; | |
| } | |
| switch (id) { | |
| // Future reserved words. | |
| // 'const' is specialized as Keyword in V8. | |
| case 'const': | |
| return true; | |
| // For compatiblity to SpiderMonkey and ES.next | |
| case 'yield': | |
| case 'let': | |
| return true; | |
| } | |
| if (strict && isStrictModeReservedWord(id)) { | |
| return true; | |
| } | |
| return isFutureReservedWord(id); | |
| } | |
| // 7.4 Comments | |
| function skipComment() { | |
| var ch, blockComment, lineComment; | |
| blockComment = false; | |
| lineComment = false; | |
| while (index < length) { | |
| ch = source[index]; | |
| if (lineComment) { | |
| ch = source[index++]; | |
| if (isLineTerminator(ch)) { | |
| lineComment = false; | |
| if (ch === '\r' && source[index] === '\n') { | |
| ++index; | |
| } | |
| ++lineNumber; | |
| lineStart = index; | |
| } | |
| } else if (blockComment) { | |
| if (isLineTerminator(ch)) { | |
| if (ch === '\r' && source[index + 1] === '\n') { | |
| ++index; | |
| } | |
| ++lineNumber; | |
| ++index; | |
| lineStart = index; | |
| if (index >= length) { | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| } else { | |
| ch = source[index++]; | |
| if (index >= length) { | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| if (ch === '*') { | |
| ch = source[index]; | |
| if (ch === '/') { | |
| ++index; | |
| blockComment = false; | |
| } | |
| } | |
| } | |
| } else if (ch === '/') { | |
| ch = source[index + 1]; | |
| if (ch === '/') { | |
| index += 2; | |
| lineComment = true; | |
| } else if (ch === '*') { | |
| index += 2; | |
| blockComment = true; | |
| if (index >= length) { | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| } else { | |
| break; | |
| } | |
| } else if (isWhiteSpace(ch)) { | |
| ++index; | |
| } else if (isLineTerminator(ch)) { | |
| ++index; | |
| if (ch === '\r' && source[index] === '\n') { | |
| ++index; | |
| } | |
| ++lineNumber; | |
| lineStart = index; | |
| } else { | |
| break; | |
| } | |
| } | |
| } | |
| function scanHexEscape(prefix) { | |
| var i, len, ch, code = 0; | |
| len = (prefix === 'u') ? 4 : 2; | |
| for (i = 0; i < len; ++i) { | |
| if (index < length && isHexDigit(source[index])) { | |
| ch = source[index++]; | |
| code = code * 16 + '0123456789abcdef'.indexOf(ch.toLowerCase()); | |
| } else { | |
| return ''; | |
| } | |
| } | |
| return String.fromCharCode(code); | |
| } | |
| function scanIdentifier() { | |
| var ch, start, id, restore; | |
| ch = source[index]; | |
| if (!isIdentifierStart(ch)) { | |
| return; | |
| } | |
| start = index; | |
| if (ch === '\\') { | |
| ++index; | |
| if (source[index] !== 'u') { | |
| return; | |
| } | |
| ++index; | |
| restore = index; | |
| ch = scanHexEscape('u'); | |
| if (ch) { | |
| if (ch === '\\' || !isIdentifierStart(ch)) { | |
| return; | |
| } | |
| id = ch; | |
| } else { | |
| index = restore; | |
| id = 'u'; | |
| } | |
| } else { | |
| id = source[index++]; | |
| } | |
| while (index < length) { | |
| ch = source[index]; | |
| if (!isIdentifierPart(ch)) { | |
| break; | |
| } | |
| if (ch === '\\') { | |
| ++index; | |
| if (source[index] !== 'u') { | |
| return; | |
| } | |
| ++index; | |
| restore = index; | |
| ch = scanHexEscape('u'); | |
| if (ch) { | |
| if (ch === '\\' || !isIdentifierPart(ch)) { | |
| return; | |
| } | |
| id += ch; | |
| } else { | |
| index = restore; | |
| id += 'u'; | |
| } | |
| } else { | |
| id += source[index++]; | |
| } | |
| } | |
| // There is no keyword or literal with only one character. | |
| // Thus, it must be an identifier. | |
| if (id.length === 1) { | |
| return { | |
| type: Token.Identifier, | |
| value: id, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| if (isKeyword(id)) { | |
| return { | |
| type: Token.Keyword, | |
| value: id, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| // 7.8.1 Null Literals | |
| if (id === 'null') { | |
| return { | |
| type: Token.NullLiteral, | |
| value: id, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| // 7.8.2 Boolean Literals | |
| if (id === 'true' || id === 'false') { | |
| return { | |
| type: Token.BooleanLiteral, | |
| value: id, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| return { | |
| type: Token.Identifier, | |
| value: id, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| // 7.7 Punctuators | |
| function scanPunctuator() { | |
| var start = index, | |
| ch1 = source[index], | |
| ch2, | |
| ch3, | |
| ch4; | |
| // Check for most common single-character punctuators. | |
| if (ch1 === ';' || ch1 === '{' || ch1 === '}') { | |
| ++index; | |
| return { | |
| type: Token.Punctuator, | |
| value: ch1, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| if (ch1 === ',' || ch1 === '(' || ch1 === ')') { | |
| ++index; | |
| return { | |
| type: Token.Punctuator, | |
| value: ch1, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| // Dot (.) can also start a floating-point number, hence the need | |
| // to check the next character. | |
| ch2 = source[index + 1]; | |
| if (ch1 === '.' && !isDecimalDigit(ch2)) { | |
| return { | |
| type: Token.Punctuator, | |
| value: source[index++], | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| // Peek more characters. | |
| ch3 = source[index + 2]; | |
| ch4 = source[index + 3]; | |
| // 4-character punctuator: >>>= | |
| if (ch1 === '>' && ch2 === '>' && ch3 === '>') { | |
| if (ch4 === '=') { | |
| index += 4; | |
| return { | |
| type: Token.Punctuator, | |
| value: '>>>=', | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| } | |
| // 3-character punctuators: === !== >>> <<= >>= | |
| if (ch1 === '=' && ch2 === '=' && ch3 === '=') { | |
| index += 3; | |
| return { | |
| type: Token.Punctuator, | |
| value: '===', | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| if (ch1 === '!' && ch2 === '=' && ch3 === '=') { | |
| index += 3; | |
| return { | |
| type: Token.Punctuator, | |
| value: '!==', | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| if (ch1 === '>' && ch2 === '>' && ch3 === '>') { | |
| index += 3; | |
| return { | |
| type: Token.Punctuator, | |
| value: '>>>', | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| if (ch1 === '<' && ch2 === '<' && ch3 === '=') { | |
| index += 3; | |
| return { | |
| type: Token.Punctuator, | |
| value: '<<=', | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| if (ch1 === '>' && ch2 === '>' && ch3 === '=') { | |
| index += 3; | |
| return { | |
| type: Token.Punctuator, | |
| value: '>>=', | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| // 2-character punctuators: <= >= == != ++ -- << >> && || | |
| // += -= *= %= &= |= ^= /= | |
| if (ch2 === '=') { | |
| if ('<>=!+-*%&|^/'.indexOf(ch1) >= 0) { | |
| index += 2; | |
| return { | |
| type: Token.Punctuator, | |
| value: ch1 + ch2, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| } | |
| if (ch1 === ch2 && ('+-<>&|'.indexOf(ch1) >= 0)) { | |
| if ('+-<>&|'.indexOf(ch2) >= 0) { | |
| index += 2; | |
| return { | |
| type: Token.Punctuator, | |
| value: ch1 + ch2, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| } | |
| // The remaining 1-character punctuators. | |
| if ('[]<>+-*%&|^!~?:=/'.indexOf(ch1) >= 0) { | |
| return { | |
| type: Token.Punctuator, | |
| value: source[index++], | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| } | |
| // 7.8.3 Numeric Literals | |
| function scanNumericLiteral() { | |
| var number, start, ch; | |
| ch = source[index]; | |
| assert(isDecimalDigit(ch) || (ch === '.'), | |
| 'Numeric literal must start with a decimal digit or a decimal point'); | |
| start = index; | |
| number = ''; | |
| if (ch !== '.') { | |
| number = source[index++]; | |
| ch = source[index]; | |
| // Hex number starts with '0x'. | |
| // Octal number starts with '0'. | |
| if (number === '0') { | |
| if (ch === 'x' || ch === 'X') { | |
| number += source[index++]; | |
| while (index < length) { | |
| ch = source[index]; | |
| if (!isHexDigit(ch)) { | |
| break; | |
| } | |
| number += source[index++]; | |
| } | |
| if (number.length <= 2) { | |
| // only 0x | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| if (index < length) { | |
| ch = source[index]; | |
| if (isIdentifierStart(ch)) { | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| } | |
| return { | |
| type: Token.NumericLiteral, | |
| value: parseInt(number, 16), | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } else if (isOctalDigit(ch)) { | |
| number += source[index++]; | |
| while (index < length) { | |
| ch = source[index]; | |
| if (!isOctalDigit(ch)) { | |
| break; | |
| } | |
| number += source[index++]; | |
| } | |
| if (index < length) { | |
| ch = source[index]; | |
| if (isIdentifierStart(ch) || isDecimalDigit(ch)) { | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| } | |
| return { | |
| type: Token.NumericLiteral, | |
| value: parseInt(number, 8), | |
| octal: true, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| // decimal number starts with '0' such as '09' is illegal. | |
| if (isDecimalDigit(ch)) { | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| } | |
| while (index < length) { | |
| ch = source[index]; | |
| if (!isDecimalDigit(ch)) { | |
| break; | |
| } | |
| number += source[index++]; | |
| } | |
| } | |
| if (ch === '.') { | |
| number += source[index++]; | |
| while (index < length) { | |
| ch = source[index]; | |
| if (!isDecimalDigit(ch)) { | |
| break; | |
| } | |
| number += source[index++]; | |
| } | |
| } | |
| if (ch === 'e' || ch === 'E') { | |
| number += source[index++]; | |
| ch = source[index]; | |
| if (ch === '+' || ch === '-') { | |
| number += source[index++]; | |
| } | |
| ch = source[index]; | |
| if (isDecimalDigit(ch)) { | |
| number += source[index++]; | |
| while (index < length) { | |
| ch = source[index]; | |
| if (!isDecimalDigit(ch)) { | |
| break; | |
| } | |
| number += source[index++]; | |
| } | |
| } else { | |
| ch = 'character ' + ch; | |
| if (index >= length) { | |
| ch = '<end>'; | |
| } | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| } | |
| if (index < length) { | |
| ch = source[index]; | |
| if (isIdentifierStart(ch)) { | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| } | |
| return { | |
| type: Token.NumericLiteral, | |
| value: parseFloat(number), | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| // 7.8.4 String Literals | |
| function scanStringLiteral() { | |
| var str = '', quote, start, ch, code, unescaped, restore, octal = false; | |
| quote = source[index]; | |
| assert((quote === '\'' || quote === '"'), | |
| 'String literal must starts with a quote'); | |
| start = index; | |
| ++index; | |
| while (index < length) { | |
| ch = source[index++]; | |
| if (ch === quote) { | |
| quote = ''; | |
| break; | |
| } else if (ch === '\\') { | |
| ch = source[index++]; | |
| if (!isLineTerminator(ch)) { | |
| switch (ch) { | |
| case 'n': | |
| str += '\n'; | |
| break; | |
| case 'r': | |
| str += '\r'; | |
| break; | |
| case 't': | |
| str += '\t'; | |
| break; | |
| case 'u': | |
| case 'x': | |
| restore = index; | |
| unescaped = scanHexEscape(ch); | |
| if (unescaped) { | |
| str += unescaped; | |
| } else { | |
| index = restore; | |
| str += ch; | |
| } | |
| break; | |
| case 'b': | |
| str += '\b'; | |
| break; | |
| case 'f': | |
| str += '\f'; | |
| break; | |
| case 'v': | |
| str += '\x0B'; | |
| break; | |
| default: | |
| if (isOctalDigit(ch)) { | |
| code = '01234567'.indexOf(ch); | |
| // \0 is not octal escape sequence | |
| if (code !== 0) { | |
| octal = true; | |
| } | |
| if (index < length && isOctalDigit(source[index])) { | |
| octal = true; | |
| code = code * 8 + '01234567'.indexOf(source[index++]); | |
| // 3 digits are only allowed when string starts | |
| // with 0, 1, 2, 3 | |
| if ('0123'.indexOf(ch) >= 0 && | |
| index < length && | |
| isOctalDigit(source[index])) { | |
| code = code * 8 + '01234567'.indexOf(source[index++]); | |
| } | |
| } | |
| str += String.fromCharCode(code); | |
| } else { | |
| str += ch; | |
| } | |
| break; | |
| } | |
| } else { | |
| ++lineNumber; | |
| if (ch === '\r' && source[index] === '\n') { | |
| ++index; | |
| } | |
| } | |
| } else if (isLineTerminator(ch)) { | |
| break; | |
| } else { | |
| str += ch; | |
| } | |
| } | |
| if (quote !== '') { | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| return { | |
| type: Token.StringLiteral, | |
| value: str, | |
| octal: octal, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| function scanRegExp() { | |
| var str, ch, start, pattern, flags, value, classMarker = false, restore, terminated = false; | |
| buffer = null; | |
| skipComment(); | |
| start = index; | |
| ch = source[index]; | |
| assert(ch === '/', 'Regular expression literal must start with a slash'); | |
| str = source[index++]; | |
| while (index < length) { | |
| ch = source[index++]; | |
| str += ch; | |
| if (ch === '\\') { | |
| ch = source[index++]; | |
| // ECMA-262 7.8.5 | |
| if (isLineTerminator(ch)) { | |
| throwError({}, Messages.UnterminatedRegExp); | |
| } | |
| str += ch; | |
| } else if (classMarker) { | |
| if (ch === ']') { | |
| classMarker = false; | |
| } | |
| } else { | |
| if (ch === '/') { | |
| terminated = true; | |
| break; | |
| } else if (ch === '[') { | |
| classMarker = true; | |
| } else if (isLineTerminator(ch)) { | |
| throwError({}, Messages.UnterminatedRegExp); | |
| } | |
| } | |
| } | |
| if (!terminated) { | |
| throwError({}, Messages.UnterminatedRegExp); | |
| } | |
| // Exclude leading and trailing slash. | |
| pattern = str.substr(1, str.length - 2); | |
| flags = ''; | |
| while (index < length) { | |
| ch = source[index]; | |
| if (!isIdentifierPart(ch)) { | |
| break; | |
| } | |
| ++index; | |
| if (ch === '\\' && index < length) { | |
| ch = source[index]; | |
| if (ch === 'u') { | |
| ++index; | |
| restore = index; | |
| ch = scanHexEscape('u'); | |
| if (ch) { | |
| flags += ch; | |
| str += '\\u'; | |
| for (; restore < index; ++restore) { | |
| str += source[restore]; | |
| } | |
| } else { | |
| index = restore; | |
| flags += 'u'; | |
| str += '\\u'; | |
| } | |
| } else { | |
| str += '\\'; | |
| } | |
| } else { | |
| flags += ch; | |
| str += ch; | |
| } | |
| } | |
| try { | |
| value = new RegExp(pattern, flags); | |
| } catch (e) { | |
| throwError({}, Messages.InvalidRegExp); | |
| } | |
| return { | |
| literal: str, | |
| value: value, | |
| range: [start, index] | |
| }; | |
| } | |
| function isIdentifierName(token) { | |
| return token.type === Token.Identifier || | |
| token.type === Token.Keyword || | |
| token.type === Token.BooleanLiteral || | |
| token.type === Token.NullLiteral; | |
| } | |
| function advance() { | |
| var ch, token; | |
| skipComment(); | |
| if (index >= length) { | |
| return { | |
| type: Token.EOF, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [index, index] | |
| }; | |
| } | |
| token = scanPunctuator(); | |
| if (typeof token !== 'undefined') { | |
| return token; | |
| } | |
| ch = source[index]; | |
| if (ch === '\'' || ch === '"') { | |
| return scanStringLiteral(); | |
| } | |
| if (ch === '.' || isDecimalDigit(ch)) { | |
| return scanNumericLiteral(); | |
| } | |
| token = scanIdentifier(); | |
| if (typeof token !== 'undefined') { | |
| return token; | |
| } | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| function lex() { | |
| var token; | |
| if (buffer) { | |
| index = buffer.range[1]; | |
| lineNumber = buffer.lineNumber; | |
| lineStart = buffer.lineStart; | |
| token = buffer; | |
| buffer = null; | |
| return token; | |
| } | |
| buffer = null; | |
| return advance(); | |
| } | |
| function lookahead() { | |
| var pos, line, start; | |
| if (buffer !== null) { | |
| return buffer; | |
| } | |
| pos = index; | |
| line = lineNumber; | |
| start = lineStart; | |
| buffer = advance(); | |
| index = pos; | |
| lineNumber = line; | |
| lineStart = start; | |
| return buffer; | |
| } | |
| // Return true if there is a line terminator before the next token. | |
| function peekLineTerminator() { | |
| var pos, line, start, found; | |
| pos = index; | |
| line = lineNumber; | |
| start = lineStart; | |
| skipComment(); | |
| found = lineNumber !== line; | |
| index = pos; | |
| lineNumber = line; | |
| lineStart = start; | |
| return found; | |
| } | |
| // Throw an exception | |
| function throwError(token, messageFormat) { | |
| var error, | |
| args = Array.prototype.slice.call(arguments, 2), | |
| msg = messageFormat.replace( | |
| /%(\d)/g, | |
| function (whole, index) { | |
| return args[index] || ''; | |
| } | |
| ); | |
| if (typeof token.lineNumber === 'number') { | |
| error = new Error('Line ' + token.lineNumber + ': ' + msg); | |
| error.index = token.range[0]; | |
| error.lineNumber = token.lineNumber; | |
| error.column = token.range[0] - lineStart + 1; | |
| } else { | |
| error = new Error('Line ' + lineNumber + ': ' + msg); | |
| error.index = index; | |
| error.lineNumber = lineNumber; | |
| error.column = index - lineStart + 1; | |
| } | |
| throw error; | |
| } | |
| function throwErrorTolerant() { | |
| try { | |
| throwError.apply(null, arguments); | |
| } catch (e) { | |
| if (extra.errors) { | |
| extra.errors.push(e); | |
| } else { | |
| throw e; | |
| } | |
| } | |
| } | |
| // Throw an exception because of the token. | |
| function throwUnexpected(token) { | |
| if (token.type === Token.EOF) { | |
| throwError(token, Messages.UnexpectedEOS); | |
| } | |
| if (token.type === Token.NumericLiteral) { | |
| throwError(token, Messages.UnexpectedNumber); | |
| } | |
| if (token.type === Token.StringLiteral) { | |
| throwError(token, Messages.UnexpectedString); | |
| } | |
| if (token.type === Token.Identifier) { | |
| throwError(token, Messages.UnexpectedIdentifier); | |
| } | |
| if (token.type === Token.Keyword) { | |
| if (isFutureReservedWord(token.value)) { | |
| throwError(token, Messages.UnexpectedReserved); | |
| } else if (strict && isStrictModeReservedWord(token.value)) { | |
| throwErrorTolerant(token, Messages.StrictReservedWord); | |
| return; | |
| } | |
| throwError(token, Messages.UnexpectedToken, token.value); | |
| } | |
| // BooleanLiteral, NullLiteral, or Punctuator. | |
| throwError(token, Messages.UnexpectedToken, token.value); | |
| } | |
| // Expect the next token to match the specified punctuator. | |
| // If not, an exception will be thrown. | |
| function expect(value) { | |
| var token = lex(); | |
| if (token.type !== Token.Punctuator || token.value !== value) { | |
| throwUnexpected(token); | |
| } | |
| } | |
| // Expect the next token to match the specified keyword. | |
| // If not, an exception will be thrown. | |
| function expectKeyword(keyword) { | |
| var token = lex(); | |
| if (token.type !== Token.Keyword || token.value !== keyword) { | |
| throwUnexpected(token); | |
| } | |
| } | |
| // Return true if the next token matches the specified punctuator. | |
| function match(value) { | |
| var token = lookahead(); | |
| return token.type === Token.Punctuator && token.value === value; | |
| } | |
| // Return true if the next token matches the specified keyword | |
| function matchKeyword(keyword) { | |
| var token = lookahead(); | |
| return token.type === Token.Keyword && token.value === keyword; | |
| } | |
| // Return true if the next token is an assignment operator | |
| function matchAssign() { | |
| var token = lookahead(), | |
| op = token.value; | |
| if (token.type !== Token.Punctuator) { | |
| return false; | |
| } | |
| return op === '=' || | |
| op === '*=' || | |
| op === '/=' || | |
| op === '%=' || | |
| op === '+=' || | |
| op === '-=' || | |
| op === '<<=' || | |
| op === '>>=' || | |
| op === '>>>=' || | |
| op === '&=' || | |
| op === '^=' || | |
| op === '|='; | |
| } | |
| function consumeSemicolon() { | |
| var token, line; | |
| // Catch the very common case first. | |
| if (source[index] === ';') { | |
| lex(); | |
| return; | |
| } | |
| line = lineNumber; | |
| skipComment(); | |
| if (lineNumber !== line) { | |
| return; | |
| } | |
| if (match(';')) { | |
| lex(); | |
| return; | |
| } | |
| token = lookahead(); | |
| if (token.type !== Token.EOF && !match('}')) { | |
| throwUnexpected(token); | |
| } | |
| } | |
| // Return true if provided expression is LeftHandSideExpression | |
| function isLeftHandSide(expr) { | |
| return expr.type === Syntax.Identifier || expr.type === Syntax.MemberExpression; | |
| } | |
| // 11.1.4 Array Initialiser | |
| function parseArrayInitialiser() { | |
| var elements = []; | |
| expect('['); | |
| while (!match(']')) { | |
| if (match(',')) { | |
| lex(); | |
| elements.push(null); | |
| } else { | |
| elements.push(parseAssignmentExpression()); | |
| if (!match(']')) { | |
| expect(','); | |
| } | |
| } | |
| } | |
| expect(']'); | |
| return { | |
| type: Syntax.ArrayExpression, | |
| elements: elements | |
| }; | |
| } | |
| // 11.1.5 Object Initialiser | |
| function parsePropertyFunction(param, first) { | |
| var previousStrict, body; | |
| previousStrict = strict; | |
| body = parseFunctionSourceElements(); | |
| if (first && strict && isRestrictedWord(param[0].name)) { | |
| throwErrorTolerant(first, Messages.StrictParamName); | |
| } | |
| strict = previousStrict; | |
| return { | |
| type: Syntax.FunctionExpression, | |
| id: null, | |
| params: param, | |
| defaults: [], | |
| body: body, | |
| rest: null, | |
| generator: false, | |
| expression: false | |
| }; | |
| } | |
| function parseObjectPropertyKey() { | |
| var token = lex(); | |
| // Note: This function is called only from parseObjectProperty(), where | |
| // EOF and Punctuator tokens are already filtered out. | |
| if (token.type === Token.StringLiteral || token.type === Token.NumericLiteral) { | |
| if (strict && token.octal) { | |
| throwErrorTolerant(token, Messages.StrictOctalLiteral); | |
| } | |
| return createLiteral(token); | |
| } | |
| return { | |
| type: Syntax.Identifier, | |
| name: token.value | |
| }; | |
| } | |
| function parseObjectProperty() { | |
| var token, key, id, param; | |
| token = lookahead(); | |
| if (token.type === Token.Identifier) { | |
| id = parseObjectPropertyKey(); | |
| // Property Assignment: Getter and Setter. | |
| if (token.value === 'get' && !match(':')) { | |
| key = parseObjectPropertyKey(); | |
| expect('('); | |
| expect(')'); | |
| return { | |
| type: Syntax.Property, | |
| key: key, | |
| value: parsePropertyFunction([]), | |
| kind: 'get' | |
| }; | |
| } else if (token.value === 'set' && !match(':')) { | |
| key = parseObjectPropertyKey(); | |
| expect('('); | |
| token = lookahead(); | |
| if (token.type !== Token.Identifier) { | |
| expect(')'); | |
| throwErrorTolerant(token, Messages.UnexpectedToken, token.value); | |
| return { | |
| type: Syntax.Property, | |
| key: key, | |
| value: parsePropertyFunction([]), | |
| kind: 'set' | |
| }; | |
| } else { | |
| param = [ parseVariableIdentifier() ]; | |
| expect(')'); | |
| return { | |
| type: Syntax.Property, | |
| key: key, | |
| value: parsePropertyFunction(param, token), | |
| kind: 'set' | |
| }; | |
| } | |
| } else { | |
| expect(':'); | |
| return { | |
| type: Syntax.Property, | |
| key: id, | |
| value: parseAssignmentExpression(), | |
| kind: 'init' | |
| }; | |
| } | |
| } else if (token.type === Token.EOF || token.type === Token.Punctuator) { | |
| throwUnexpected(token); | |
| } else { | |
| key = parseObjectPropertyKey(); | |
| expect(':'); | |
| return { | |
| type: Syntax.Property, | |
| key: key, | |
| value: parseAssignmentExpression(), | |
| kind: 'init' | |
| }; | |
| } | |
| } | |
| function parseObjectInitialiser() { | |
| var properties = [], property, name, kind, map = {}, toString = String; | |
| expect('{'); | |
| while (!match('}')) { | |
| property = parseObjectProperty(); | |
| if (property.key.type === Syntax.Identifier) { | |
| name = property.key.name; | |
| } else { | |
| name = toString(property.key.value); | |
| } | |
| kind = (property.kind === 'init') ? PropertyKind.Data : (property.kind === 'get') ? PropertyKind.Get : PropertyKind.Set; | |
| if (Object.prototype.hasOwnProperty.call(map, name)) { | |
| if (map[name] === PropertyKind.Data) { | |
| if (strict && kind === PropertyKind.Data) { | |
| throwErrorTolerant({}, Messages.StrictDuplicateProperty); | |
| } else if (kind !== PropertyKind.Data) { | |
| throwErrorTolerant({}, Messages.AccessorDataProperty); | |
| } | |
| } else { | |
| if (kind === PropertyKind.Data) { | |
| throwErrorTolerant({}, Messages.AccessorDataProperty); | |
| } else if (map[name] & kind) { | |
| throwErrorTolerant({}, Messages.AccessorGetSet); | |
| } | |
| } | |
| map[name] |= kind; | |
| } else { | |
| map[name] = kind; | |
| } | |
| properties.push(property); | |
| if (!match('}')) { | |
| expect(','); | |
| } | |
| } | |
| expect('}'); | |
| return { | |
| type: Syntax.ObjectExpression, | |
| properties: properties | |
| }; | |
| } | |
| // 11.1.6 The Grouping Operator | |
| function parseGroupExpression() { | |
| var expr; | |
| expect('('); | |
| expr = parseExpression(); | |
| expect(')'); | |
| return expr; | |
| } | |
| // 11.1 Primary Expressions | |
| function parsePrimaryExpression() { | |
| var token = lookahead(), | |
| type = token.type; | |
| if (type === Token.Identifier) { | |
| return { | |
| type: Syntax.Identifier, | |
| name: lex().value | |
| }; | |
| } | |
| if (type === Token.StringLiteral || type === Token.NumericLiteral) { | |
| if (strict && token.octal) { | |
| throwErrorTolerant(token, Messages.StrictOctalLiteral); | |
| } | |
| return createLiteral(lex()); | |
| } | |
| if (type === Token.Keyword) { | |
| if (matchKeyword('this')) { | |
| lex(); | |
| return { | |
| type: Syntax.ThisExpression | |
| }; | |
| } | |
| if (matchKeyword('function')) { | |
| return parseFunctionExpression(); | |
| } | |
| } | |
| if (type === Token.BooleanLiteral) { | |
| lex(); | |
| token.value = (token.value === 'true'); | |
| return createLiteral(token); | |
| } | |
| if (type === Token.NullLiteral) { | |
| lex(); | |
| token.value = null; | |
| return createLiteral(token); | |
| } | |
| if (match('[')) { | |
| return parseArrayInitialiser(); | |
| } | |
| if (match('{')) { | |
| return parseObjectInitialiser(); | |
| } | |
| if (match('(')) { | |
| return parseGroupExpression(); | |
| } | |
| if (match('/') || match('/=')) { | |
| return createLiteral(scanRegExp()); | |
| } | |
| return throwUnexpected(lex()); | |
| } | |
| // 11.2 Left-Hand-Side Expressions | |
| function parseArguments() { | |
| var args = []; | |
| expect('('); | |
| if (!match(')')) { | |
| while (index < length) { | |
| args.push(parseAssignmentExpression()); | |
| if (match(')')) { | |
| break; | |
| } | |
| expect(','); | |
| } | |
| } | |
| expect(')'); | |
| return args; | |
| } | |
| function parseNonComputedProperty() { | |
| var token = lex(); | |
| if (!isIdentifierName(token)) { | |
| throwUnexpected(token); | |
| } | |
| return { | |
| type: Syntax.Identifier, | |
| name: token.value | |
| }; | |
| } | |
| function parseNonComputedMember() { | |
| expect('.'); | |
| return parseNonComputedProperty(); | |
| } | |
| function parseComputedMember() { | |
| var expr; | |
| expect('['); | |
| expr = parseExpression(); | |
| expect(']'); | |
| return expr; | |
| } | |
| function parseNewExpression() { | |
| var expr; | |
| expectKeyword('new'); | |
| expr = { | |
| type: Syntax.NewExpression, | |
| callee: parseLeftHandSideExpression(), | |
| 'arguments': [] | |
| }; | |
| if (match('(')) { | |
| expr['arguments'] = parseArguments(); | |
| } | |
| return expr; | |
| } | |
| function parseLeftHandSideExpressionAllowCall() { | |
| var expr; | |
| expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression(); | |
| while (match('.') || match('[') || match('(')) { | |
| if (match('(')) { | |
| expr = { | |
| type: Syntax.CallExpression, | |
| callee: expr, | |
| 'arguments': parseArguments() | |
| }; | |
| } else if (match('[')) { | |
| expr = { | |
| type: Syntax.MemberExpression, | |
| computed: true, | |
| object: expr, | |
| property: parseComputedMember() | |
| }; | |
| } else { | |
| expr = { | |
| type: Syntax.MemberExpression, | |
| computed: false, | |
| object: expr, | |
| property: parseNonComputedMember() | |
| }; | |
| } | |
| } | |
| return expr; | |
| } | |
| function parseLeftHandSideExpression() { | |
| var expr; | |
| expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression(); | |
| while (match('.') || match('[')) { | |
| if (match('[')) { | |
| expr = { | |
| type: Syntax.MemberExpression, | |
| computed: true, | |
| object: expr, | |
| property: parseComputedMember() | |
| }; | |
| } else { | |
| expr = { | |
| type: Syntax.MemberExpression, | |
| computed: false, | |
| object: expr, | |
| property: parseNonComputedMember() | |
| }; | |
| } | |
| } | |
| return expr; | |
| } | |
| // 11.3 Postfix Expressions | |
| function parsePostfixExpression() { | |
| var expr = parseLeftHandSideExpressionAllowCall(), token; | |
| token = lookahead(); | |
| if (token.type !== Token.Punctuator) { | |
| return expr; | |
| } | |
| if ((match('++') || match('--')) && !peekLineTerminator()) { | |
| // 11.3.1, 11.3.2 | |
| if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) { | |
| throwErrorTolerant({}, Messages.StrictLHSPostfix); | |
| } | |
| if (!isLeftHandSide(expr)) { | |
| throwErrorTolerant({}, Messages.InvalidLHSInAssignment); | |
| } | |
| expr = { | |
| type: Syntax.UpdateExpression, | |
| operator: lex().value, | |
| argument: expr, | |
| prefix: false | |
| }; | |
| } | |
| return expr; | |
| } | |
| // 11.4 Unary Operators | |
| function parseUnaryExpression() { | |
| var token, expr; | |
| token = lookahead(); | |
| if (token.type !== Token.Punctuator && token.type !== Token.Keyword) { | |
| return parsePostfixExpression(); | |
| } | |
| if (match('++') || match('--')) { | |
| token = lex(); | |
| expr = parseUnaryExpression(); | |
| // 11.4.4, 11.4.5 | |
| if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) { | |
| throwErrorTolerant({}, Messages.StrictLHSPrefix); | |
| } | |
| if (!isLeftHandSide(expr)) { | |
| throwErrorTolerant({}, Messages.InvalidLHSInAssignment); | |
| } | |
| expr = { | |
| type: Syntax.UpdateExpression, | |
| operator: token.value, | |
| argument: expr, | |
| prefix: true | |
| }; | |
| return expr; | |
| } | |
| if (match('+') || match('-') || match('~') || match('!')) { | |
| expr = { | |
| type: Syntax.UnaryExpression, | |
| operator: lex().value, | |
| argument: parseUnaryExpression(), | |
| prefix: true | |
| }; | |
| return expr; | |
| } | |
| if (matchKeyword('delete') || matchKeyword('void') || matchKeyword('typeof')) { | |
| expr = { | |
| type: Syntax.UnaryExpression, | |
| operator: lex().value, | |
| argument: parseUnaryExpression(), | |
| prefix: true | |
| }; | |
| if (strict && expr.operator === 'delete' && expr.argument.type === Syntax.Identifier) { | |
| throwErrorTolerant({}, Messages.StrictDelete); | |
| } | |
| return expr; | |
| } | |
| return parsePostfixExpression(); | |
| } | |
| // 11.5 Multiplicative Operators | |
| function parseMultiplicativeExpression() { | |
| var expr = parseUnaryExpression(); | |
| while (match('*') || match('/') || match('%')) { | |
| expr = { | |
| type: Syntax.BinaryExpression, | |
| operator: lex().value, | |
| left: expr, | |
| right: parseUnaryExpression() | |
| }; | |
| } | |
| return expr; | |
| } | |
| // 11.6 Additive Operators | |
| function parseAdditiveExpression() { | |
| var expr = parseMultiplicativeExpression(); | |
| while (match('+') || match('-')) { | |
| expr = { | |
| type: Syntax.BinaryExpression, | |
| operator: lex().value, | |
| left: expr, | |
| right: parseMultiplicativeExpression() | |
| }; | |
| } | |
| return expr; | |
| } | |
| // 11.7 Bitwise Shift Operators | |
| function parseShiftExpression() { | |
| var expr = parseAdditiveExpression(); | |
| while (match('<<') || match('>>') || match('>>>')) { | |
| expr = { | |
| type: Syntax.BinaryExpression, | |
| operator: lex().value, | |
| left: expr, | |
| right: parseAdditiveExpression() | |
| }; | |
| } | |
| return expr; | |
| } | |
| // 11.8 Relational Operators | |
| function parseRelationalExpression() { | |
| var expr, previousAllowIn; | |
| previousAllowIn = state.allowIn; | |
| state.allowIn = true; | |
| expr = parseShiftExpression(); | |
| while (match('<') || match('>') || match('<=') || match('>=') || (previousAllowIn && matchKeyword('in')) || matchKeyword('instanceof')) { | |
| expr = { | |
| type: Syntax.BinaryExpression, | |
| operator: lex().value, | |
| left: expr, | |
| right: parseShiftExpression() | |
| }; | |
| } | |
| state.allowIn = previousAllowIn; | |
| return expr; | |
| } | |
| // 11.9 Equality Operators | |
| function parseEqualityExpression() { | |
| var expr = parseRelationalExpression(); | |
| while (match('==') || match('!=') || match('===') || match('!==')) { | |
| expr = { | |
| type: Syntax.BinaryExpression, | |
| operator: lex().value, | |
| left: expr, | |
| right: parseRelationalExpression() | |
| }; | |
| } | |
| return expr; | |
| } | |
| // 11.10 Binary Bitwise Operators | |
| function parseBitwiseANDExpression() { | |
| var expr = parseEqualityExpression(); | |
| while (match('&')) { | |
| lex(); | |
| expr = { | |
| type: Syntax.BinaryExpression, | |
| operator: '&', | |
| left: expr, | |
| right: parseEqualityExpression() | |
| }; | |
| } | |
| return expr; | |
| } | |
| function parseBitwiseXORExpression() { | |
| var expr = parseBitwiseANDExpression(); | |
| while (match('^')) { | |
| lex(); | |
| expr = { | |
| type: Syntax.BinaryExpression, | |
| operator: '^', | |
| left: expr, | |
| right: parseBitwiseANDExpression() | |
| }; | |
| } | |
| return expr; | |
| } | |
| function parseBitwiseORExpression() { | |
| var expr = parseBitwiseXORExpression(); | |
| while (match('|')) { | |
| lex(); | |
| expr = { | |
| type: Syntax.BinaryExpression, | |
| operator: '|', | |
| left: expr, | |
| right: parseBitwiseXORExpression() | |
| }; | |
| } | |
| return expr; | |
| } | |
| // 11.11 Binary Logical Operators | |
| function parseLogicalANDExpression() { | |
| var expr = parseBitwiseORExpression(); | |
| while (match('&&')) { | |
| lex(); | |
| expr = { | |
| type: Syntax.LogicalExpression, | |
| operator: '&&', | |
| left: expr, | |
| right: parseBitwiseORExpression() | |
| }; | |
| } | |
| return expr; | |
| } | |
| function parseLogicalORExpression() { | |
| var expr = parseLogicalANDExpression(); | |
| while (match('||')) { | |
| lex(); | |
| expr = { | |
| type: Syntax.LogicalExpression, | |
| operator: '||', | |
| left: expr, | |
| right: parseLogicalANDExpression() | |
| }; | |
| } | |
| return expr; | |
| } | |
| // 11.12 Conditional Operator | |
| function parseConditionalExpression() { | |
| var expr, previousAllowIn, consequent; | |
| expr = parseLogicalORExpression(); | |
| if (match('?')) { | |
| lex(); | |
| previousAllowIn = state.allowIn; | |
| state.allowIn = true; | |
| consequent = parseAssignmentExpression(); | |
| state.allowIn = previousAllowIn; | |
| expect(':'); | |
| expr = { | |
| type: Syntax.ConditionalExpression, | |
| test: expr, | |
| consequent: consequent, | |
| alternate: parseAssignmentExpression() | |
| }; | |
| } | |
| return expr; | |
| } | |
| // 11.13 Assignment Operators | |
| function parseAssignmentExpression() { | |
| var token, expr; | |
| token = lookahead(); | |
| expr = parseConditionalExpression(); | |
| if (matchAssign()) { | |
| // LeftHandSideExpression | |
| if (!isLeftHandSide(expr)) { | |
| throwErrorTolerant({}, Messages.InvalidLHSInAssignment); | |
| } | |
| // 11.13.1 | |
| if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) { | |
| throwErrorTolerant(token, Messages.StrictLHSAssignment); | |
| } | |
| expr = { | |
| type: Syntax.AssignmentExpression, | |
| operator: lex().value, | |
| left: expr, | |
| right: parseAssignmentExpression() | |
| }; | |
| } | |
| return expr; | |
| } | |
| // 11.14 Comma Operator | |
| function parseExpression() { | |
| var expr = parseAssignmentExpression(); | |
| if (match(',')) { | |
| expr = { | |
| type: Syntax.SequenceExpression, | |
| expressions: [ expr ] | |
| }; | |
| while (index < length) { | |
| if (!match(',')) { | |
| break; | |
| } | |
| lex(); | |
| expr.expressions.push(parseAssignmentExpression()); | |
| } | |
| } | |
| return expr; | |
| } | |
| // 12.1 Block | |
| function parseStatementList() { | |
| var list = [], | |
| statement; | |
| while (index < length) { | |
| if (match('}')) { | |
| break; | |
| } | |
| statement = parseSourceElement(); | |
| if (typeof statement === 'undefined') { | |
| break; | |
| } | |
| list.push(statement); | |
| } | |
| return list; | |
| } | |
| function parseBlock() { | |
| var block; | |
| expect('{'); | |
| block = parseStatementList(); | |
| expect('}'); | |
| return { | |
| type: Syntax.BlockStatement, | |
| body: block | |
| }; | |
| } | |
| // 12.2 Variable Statement | |
| function parseVariableIdentifier() { | |
| var token = lex(); | |
| if (token.type !== Token.Identifier) { | |
| throwUnexpected(token); | |
| } | |
| return { | |
| type: Syntax.Identifier, | |
| name: token.value | |
| }; | |
| } | |
| function parseVariableDeclaration(kind) { | |
| var id = parseVariableIdentifier(), | |
| init = null; | |
| // 12.2.1 | |
| if (strict && isRestrictedWord(id.name)) { | |
| throwErrorTolerant({}, Messages.StrictVarName); | |
| } | |
| if (kind === 'const') { | |
| expect('='); | |
| init = parseAssignmentExpression(); | |
| } else if (match('=')) { | |
| lex(); | |
| init = parseAssignmentExpression(); | |
| } | |
| return { | |
| type: Syntax.VariableDeclarator, | |
| id: id, | |
| init: init | |
| }; | |
| } | |
| function parseVariableDeclarationList(kind) { | |
| var list = []; | |
| do { | |
| list.push(parseVariableDeclaration(kind)); | |
| if (!match(',')) { | |
| break; | |
| } | |
| lex(); | |
| } while (index < length); | |
| return list; | |
| } | |
| function parseVariableStatement() { | |
| var declarations; | |
| expectKeyword('var'); | |
| declarations = parseVariableDeclarationList(); | |
| consumeSemicolon(); | |
| return { | |
| type: Syntax.VariableDeclaration, | |
| declarations: declarations, | |
| kind: 'var' | |
| }; | |
| } | |
| // kind may be `const` or `let` | |
| // Both are experimental and not in the specification yet. | |
| // see http://wiki.ecmascript.org/doku.php?id=harmony:const | |
| // and http://wiki.ecmascript.org/doku.php?id=harmony:let | |
| function parseConstLetDeclaration(kind) { | |
| var declarations; | |
| expectKeyword(kind); | |
| declarations = parseVariableDeclarationList(kind); | |
| consumeSemicolon(); | |
| return { | |
| type: Syntax.VariableDeclaration, | |
| declarations: declarations, | |
| kind: kind | |
| }; | |
| } | |
| // 12.3 Empty Statement | |
| function parseEmptyStatement() { | |
| expect(';'); | |
| return { | |
| type: Syntax.EmptyStatement | |
| }; | |
| } | |
| // 12.4 Expression Statement | |
| function parseExpressionStatement() { | |
| var expr = parseExpression(); | |
| consumeSemicolon(); | |
| return { | |
| type: Syntax.ExpressionStatement, | |
| expression: expr | |
| }; | |
| } | |
| // 12.5 If statement | |
| function parseIfStatement() { | |
| var test, consequent, alternate; | |
| expectKeyword('if'); | |
| expect('('); | |
| test = parseExpression(); | |
| expect(')'); | |
| consequent = parseStatement(); | |
| if (matchKeyword('else')) { | |
| lex(); | |
| alternate = parseStatement(); | |
| } else { | |
| alternate = null; | |
| } | |
| return { | |
| type: Syntax.IfStatement, | |
| test: test, | |
| consequent: consequent, | |
| alternate: alternate | |
| }; | |
| } | |
| // 12.6 Iteration Statements | |
| function parseDoWhileStatement() { | |
| var body, test, oldInIteration; | |
| expectKeyword('do'); | |
| oldInIteration = state.inIteration; | |
| state.inIteration = true; | |
| body = parseStatement(); | |
| state.inIteration = oldInIteration; | |
| expectKeyword('while'); | |
| expect('('); | |
| test = parseExpression(); | |
| expect(')'); | |
| if (match(';')) { | |
| lex(); | |
| } | |
| return { | |
| type: Syntax.DoWhileStatement, | |
| body: body, | |
| test: test | |
| }; | |
| } | |
| function parseWhileStatement() { | |
| var test, body, oldInIteration; | |
| expectKeyword('while'); | |
| expect('('); | |
| test = parseExpression(); | |
| expect(')'); | |
| oldInIteration = state.inIteration; | |
| state.inIteration = true; | |
| body = parseStatement(); | |
| state.inIteration = oldInIteration; | |
| return { | |
| type: Syntax.WhileStatement, | |
| test: test, | |
| body: body | |
| }; | |
| } | |
| function parseForVariableDeclaration() { | |
| var token = lex(); | |
| return { | |
| type: Syntax.VariableDeclaration, | |
| declarations: parseVariableDeclarationList(), | |
| kind: token.value | |
| }; | |
| } | |
| function parseForStatement() { | |
| var init, test, update, left, right, body, oldInIteration; | |
| init = test = update = null; | |
| expectKeyword('for'); | |
| expect('('); | |
| if (match(';')) { | |
| lex(); | |
| } else { | |
| if (matchKeyword('var') || matchKeyword('let')) { | |
| state.allowIn = false; | |
| init = parseForVariableDeclaration(); | |
| state.allowIn = true; | |
| if (init.declarations.length === 1 && matchKeyword('in')) { | |
| lex(); | |
| left = init; | |
| right = parseExpression(); | |
| init = null; | |
| } | |
| } else { | |
| state.allowIn = false; | |
| init = parseExpression(); | |
| state.allowIn = true; | |
| if (matchKeyword('in')) { | |
| // LeftHandSideExpression | |
| if (!isLeftHandSide(init)) { | |
| throwErrorTolerant({}, Messages.InvalidLHSInForIn); | |
| } | |
| lex(); | |
| left = init; | |
| right = parseExpression(); | |
| init = null; | |
| } | |
| } | |
| if (typeof left === 'undefined') { | |
| expect(';'); | |
| } | |
| } | |
| if (typeof left === 'undefined') { | |
| if (!match(';')) { | |
| test = parseExpression(); | |
| } | |
| expect(';'); | |
| if (!match(')')) { | |
| update = parseExpression(); | |
| } | |
| } | |
| expect(')'); | |
| oldInIteration = state.inIteration; | |
| state.inIteration = true; | |
| body = parseStatement(); | |
| state.inIteration = oldInIteration; | |
| if (typeof left === 'undefined') { | |
| return { | |
| type: Syntax.ForStatement, | |
| init: init, | |
| test: test, | |
| update: update, | |
| body: body | |
| }; | |
| } | |
| return { | |
| type: Syntax.ForInStatement, | |
| left: left, | |
| right: right, | |
| body: body, | |
| each: false | |
| }; | |
| } | |
| // 12.7 The continue statement | |
| function parseContinueStatement() { | |
| var token, label = null; | |
| expectKeyword('continue'); | |
| // Optimize the most common form: 'continue;'. | |
| if (source[index] === ';') { | |
| lex(); | |
| if (!state.inIteration) { | |
| throwError({}, Messages.IllegalContinue); | |
| } | |
| return { | |
| type: Syntax.ContinueStatement, | |
| label: null | |
| }; | |
| } | |
| if (peekLineTerminator()) { | |
| if (!state.inIteration) { | |
| throwError({}, Messages.IllegalContinue); | |
| } | |
| return { | |
| type: Syntax.ContinueStatement, | |
| label: null | |
| }; | |
| } | |
| token = lookahead(); | |
| if (token.type === Token.Identifier) { | |
| label = parseVariableIdentifier(); | |
| if (!Object.prototype.hasOwnProperty.call(state.labelSet, label.name)) { | |
| throwError({}, Messages.UnknownLabel, label.name); | |
| } | |
| } | |
| consumeSemicolon(); | |
| if (label === null && !state.inIteration) { | |
| throwError({}, Messages.IllegalContinue); | |
| } | |
| return { | |
| type: Syntax.ContinueStatement, | |
| label: label | |
| }; | |
| } | |
| // 12.8 The break statement | |
| function parseBreakStatement() { | |
| var token, label = null; | |
| expectKeyword('break'); | |
| // Optimize the most common form: 'break;'. | |
| if (source[index] === ';') { | |
| lex(); | |
| if (!(state.inIteration || state.inSwitch)) { | |
| throwError({}, Messages.IllegalBreak); | |
| } | |
| return { | |
| type: Syntax.BreakStatement, | |
| label: null | |
| }; | |
| } | |
| if (peekLineTerminator()) { | |
| if (!(state.inIteration || state.inSwitch)) { | |
| throwError({}, Messages.IllegalBreak); | |
| } | |
| return { | |
| type: Syntax.BreakStatement, | |
| label: null | |
| }; | |
| } | |
| token = lookahead(); | |
| if (token.type === Token.Identifier) { | |
| label = parseVariableIdentifier(); | |
| if (!Object.prototype.hasOwnProperty.call(state.labelSet, label.name)) { | |
| throwError({}, Messages.UnknownLabel, label.name); | |
| } | |
| } | |
| consumeSemicolon(); | |
| if (label === null && !(state.inIteration || state.inSwitch)) { | |
| throwError({}, Messages.IllegalBreak); | |
| } | |
| return { | |
| type: Syntax.BreakStatement, | |
| label: label | |
| }; | |
| } | |
| // 12.9 The return statement | |
| function parseReturnStatement() { | |
| var token, argument = null; | |
| expectKeyword('return'); | |
| if (!state.inFunctionBody) { | |
| throwErrorTolerant({}, Messages.IllegalReturn); | |
| } | |
| // 'return' followed by a space and an identifier is very common. | |
| if (source[index] === ' ') { | |
| if (isIdentifierStart(source[index + 1])) { | |
| argument = parseExpression(); | |
| consumeSemicolon(); | |
| return { | |
| type: Syntax.ReturnStatement, | |
| argument: argument | |
| }; | |
| } | |
| } | |
| if (peekLineTerminator()) { | |
| return { | |
| type: Syntax.ReturnStatement, | |
| argument: null | |
| }; | |
| } | |
| if (!match(';')) { | |
| token = lookahead(); | |
| if (!match('}') && token.type !== Token.EOF) { | |
| argument = parseExpression(); | |
| } | |
| } | |
| consumeSemicolon(); | |
| return { | |
| type: Syntax.ReturnStatement, | |
| argument: argument | |
| }; | |
| } | |
| // 12.10 The with statement | |
| function parseWithStatement() { | |
| var object, body; | |
| if (strict) { | |
| throwErrorTolerant({}, Messages.StrictModeWith); | |
| } | |
| expectKeyword('with'); | |
| expect('('); | |
| object = parseExpression(); | |
| expect(')'); | |
| body = parseStatement(); | |
| return { | |
| type: Syntax.WithStatement, | |
| object: object, | |
| body: body | |
| }; | |
| } | |
| // 12.10 The swith statement | |
| function parseSwitchCase() { | |
| var test, | |
| consequent = [], | |
| statement; | |
| if (matchKeyword('default')) { | |
| lex(); | |
| test = null; | |
| } else { | |
| expectKeyword('case'); | |
| test = parseExpression(); | |
| } | |
| expect(':'); | |
| while (index < length) { | |
| if (match('}') || matchKeyword('default') || matchKeyword('case')) { | |
| break; | |
| } | |
| statement = parseStatement(); | |
| if (typeof statement === 'undefined') { | |
| break; | |
| } | |
| consequent.push(statement); | |
| } | |
| return { | |
| type: Syntax.SwitchCase, | |
| test: test, | |
| consequent: consequent | |
| }; | |
| } | |
| function parseSwitchStatement() { | |
| var discriminant, cases, clause, oldInSwitch, defaultFound; | |
| expectKeyword('switch'); | |
| expect('('); | |
| discriminant = parseExpression(); | |
| expect(')'); | |
| expect('{'); | |
| cases = []; | |
| if (match('}')) { | |
| lex(); | |
| return { | |
| type: Syntax.SwitchStatement, | |
| discriminant: discriminant, | |
| cases: cases | |
| }; | |
| } | |
| oldInSwitch = state.inSwitch; | |
| state.inSwitch = true; | |
| defaultFound = false; | |
| while (index < length) { | |
| if (match('}')) { | |
| break; | |
| } | |
| clause = parseSwitchCase(); | |
| if (clause.test === null) { | |
| if (defaultFound) { | |
| throwError({}, Messages.MultipleDefaultsInSwitch); | |
| } | |
| defaultFound = true; | |
| } | |
| cases.push(clause); | |
| } | |
| state.inSwitch = oldInSwitch; | |
| expect('}'); | |
| return { | |
| type: Syntax.SwitchStatement, | |
| discriminant: discriminant, | |
| cases: cases | |
| }; | |
| } | |
| // 12.13 The throw statement | |
| function parseThrowStatement() { | |
| var argument; | |
| expectKeyword('throw'); | |
| if (peekLineTerminator()) { | |
| throwError({}, Messages.NewlineAfterThrow); | |
| } | |
| argument = parseExpression(); | |
| consumeSemicolon(); | |
| return { | |
| type: Syntax.ThrowStatement, | |
| argument: argument | |
| }; | |
| } | |
| // 12.14 The try statement | |
| function parseCatchClause() { | |
| var param; | |
| expectKeyword('catch'); | |
| expect('('); | |
| if (match(')')) { | |
| throwUnexpected(lookahead()); | |
| } | |
| param = parseVariableIdentifier(); | |
| // 12.14.1 | |
| if (strict && isRestrictedWord(param.name)) { | |
| throwErrorTolerant({}, Messages.StrictCatchVariable); | |
| } | |
| expect(')'); | |
| return { | |
| type: Syntax.CatchClause, | |
| param: param, | |
| body: parseBlock() | |
| }; | |
| } | |
| function parseTryStatement() { | |
| var block, handlers = [], finalizer = null; | |
| expectKeyword('try'); | |
| block = parseBlock(); | |
| if (matchKeyword('catch')) { | |
| handlers.push(parseCatchClause()); | |
| } | |
| if (matchKeyword('finally')) { | |
| lex(); | |
| finalizer = parseBlock(); | |
| } | |
| if (handlers.length === 0 && !finalizer) { | |
| throwError({}, Messages.NoCatchOrFinally); | |
| } | |
| return { | |
| type: Syntax.TryStatement, | |
| block: block, | |
| guardedHandlers: [], | |
| handlers: handlers, | |
| finalizer: finalizer | |
| }; | |
| } | |
| // 12.15 The debugger statement | |
| function parseDebuggerStatement() { | |
| expectKeyword('debugger'); | |
| consumeSemicolon(); | |
| return { | |
| type: Syntax.DebuggerStatement | |
| }; | |
| } | |
| // 12 Statements | |
| function parseStatement() { | |
| var token = lookahead(), | |
| expr, | |
| labeledBody; | |
| if (token.type === Token.EOF) { | |
| throwUnexpected(token); | |
| } | |
| if (token.type === Token.Punctuator) { | |
| switch (token.value) { | |
| case ';': | |
| return parseEmptyStatement(); | |
| case '{': | |
| return parseBlock(); | |
| case '(': | |
| return parseExpressionStatement(); | |
| default: | |
| break; | |
| } | |
| } | |
| if (token.type === Token.Keyword) { | |
| switch (token.value) { | |
| case 'break': | |
| return parseBreakStatement(); | |
| case 'continue': | |
| return parseContinueStatement(); | |
| case 'debugger': | |
| return parseDebuggerStatement(); | |
| case 'do': | |
| return parseDoWhileStatement(); | |
| case 'for': | |
| return parseForStatement(); | |
| case 'function': | |
| return parseFunctionDeclaration(); | |
| case 'if': | |
| return parseIfStatement(); | |
| case 'return': | |
| return parseReturnStatement(); | |
| case 'switch': | |
| return parseSwitchStatement(); | |
| case 'throw': | |
| return parseThrowStatement(); | |
| case 'try': | |
| return parseTryStatement(); | |
| case 'var': | |
| return parseVariableStatement(); | |
| case 'while': | |
| return parseWhileStatement(); | |
| case 'with': | |
| return parseWithStatement(); | |
| default: | |
| break; | |
| } | |
| } | |
| expr = parseExpression(); | |
| // 12.12 Labelled Statements | |
| if ((expr.type === Syntax.Identifier) && match(':')) { | |
| lex(); | |
| if (Object.prototype.hasOwnProperty.call(state.labelSet, expr.name)) { | |
| throwError({}, Messages.Redeclaration, 'Label', expr.name); | |
| } | |
| state.labelSet[expr.name] = true; | |
| labeledBody = parseStatement(); | |
| delete state.labelSet[expr.name]; | |
| return { | |
| type: Syntax.LabeledStatement, | |
| label: expr, | |
| body: labeledBody | |
| }; | |
| } | |
| consumeSemicolon(); | |
| return { | |
| type: Syntax.ExpressionStatement, | |
| expression: expr | |
| }; | |
| } | |
| // 13 Function Definition | |
| function parseFunctionSourceElements() { | |
| var sourceElement, sourceElements = [], token, directive, firstRestricted, | |
| oldLabelSet, oldInIteration, oldInSwitch, oldInFunctionBody; | |
| expect('{'); | |
| while (index < length) { | |
| token = lookahead(); | |
| if (token.type !== Token.StringLiteral) { | |
| break; | |
| } | |
| sourceElement = parseSourceElement(); | |
| sourceElements.push(sourceElement); | |
| if (sourceElement.expression.type !== Syntax.Literal) { | |
| // this is not directive | |
| break; | |
| } | |
| directive = sliceSource(token.range[0] + 1, token.range[1] - 1); | |
| if (directive === 'use strict') { | |
| strict = true; | |
| if (firstRestricted) { | |
| throwErrorTolerant(firstRestricted, Messages.StrictOctalLiteral); | |
| } | |
| } else { | |
| if (!firstRestricted && token.octal) { | |
| firstRestricted = token; | |
| } | |
| } | |
| } | |
| oldLabelSet = state.labelSet; | |
| oldInIteration = state.inIteration; | |
| oldInSwitch = state.inSwitch; | |
| oldInFunctionBody = state.inFunctionBody; | |
| state.labelSet = {}; | |
| state.inIteration = false; | |
| state.inSwitch = false; | |
| state.inFunctionBody = true; | |
| while (index < length) { | |
| if (match('}')) { | |
| break; | |
| } | |
| sourceElement = parseSourceElement(); | |
| if (typeof sourceElement === 'undefined') { | |
| break; | |
| } | |
| sourceElements.push(sourceElement); | |
| } | |
| expect('}'); | |
| state.labelSet = oldLabelSet; | |
| state.inIteration = oldInIteration; | |
| state.inSwitch = oldInSwitch; | |
| state.inFunctionBody = oldInFunctionBody; | |
| return { | |
| type: Syntax.BlockStatement, | |
| body: sourceElements | |
| }; | |
| } | |
| function parseFunctionDeclaration() { | |
| var id, param, params = [], body, token, stricted, firstRestricted, message, previousStrict, paramSet; | |
| expectKeyword('function'); | |
| token = lookahead(); | |
| id = parseVariableIdentifier(); | |
| if (strict) { | |
| if (isRestrictedWord(token.value)) { | |
| throwErrorTolerant(token, Messages.StrictFunctionName); | |
| } | |
| } else { | |
| if (isRestrictedWord(token.value)) { | |
| firstRestricted = token; | |
| message = Messages.StrictFunctionName; | |
| } else if (isStrictModeReservedWord(token.value)) { | |
| firstRestricted = token; | |
| message = Messages.StrictReservedWord; | |
| } | |
| } | |
| expect('('); | |
| if (!match(')')) { | |
| paramSet = {}; | |
| while (index < length) { | |
| token = lookahead(); | |
| param = parseVariableIdentifier(); | |
| if (strict) { | |
| if (isRestrictedWord(token.value)) { | |
| stricted = token; | |
| message = Messages.StrictParamName; | |
| } | |
| if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) { | |
| stricted = token; | |
| message = Messages.StrictParamDupe; | |
| } | |
| } else if (!firstRestricted) { | |
| if (isRestrictedWord(token.value)) { | |
| firstRestricted = token; | |
| message = Messages.StrictParamName; | |
| } else if (isStrictModeReservedWord(token.value)) { | |
| firstRestricted = token; | |
| message = Messages.StrictReservedWord; | |
| } else if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) { | |
| firstRestricted = token; | |
| message = Messages.StrictParamDupe; | |
| } | |
| } | |
| params.push(param); | |
| paramSet[param.name] = true; | |
| if (match(')')) { | |
| break; | |
| } | |
| expect(','); | |
| } | |
| } | |
| expect(')'); | |
| previousStrict = strict; | |
| body = parseFunctionSourceElements(); | |
| if (strict && firstRestricted) { | |
| throwError(firstRestricted, message); | |
| } | |
| if (strict && stricted) { | |
| throwErrorTolerant(stricted, message); | |
| } | |
| strict = previousStrict; | |
| return { | |
| type: Syntax.FunctionDeclaration, | |
| id: id, | |
| params: params, | |
| defaults: [], | |
| body: body, | |
| rest: null, | |
| generator: false, | |
| expression: false | |
| }; | |
| } | |
| function parseFunctionExpression() { | |
| var token, id = null, stricted, firstRestricted, message, param, params = [], body, previousStrict, paramSet; | |
| expectKeyword('function'); | |
| if (!match('(')) { | |
| token = lookahead(); | |
| id = parseVariableIdentifier(); | |
| if (strict) { | |
| if (isRestrictedWord(token.value)) { | |
| throwErrorTolerant(token, Messages.StrictFunctionName); | |
| } | |
| } else { | |
| if (isRestrictedWord(token.value)) { | |
| firstRestricted = token; | |
| message = Messages.StrictFunctionName; | |
| } else if (isStrictModeReservedWord(token.value)) { | |
| firstRestricted = token; | |
| message = Messages.StrictReservedWord; | |
| } | |
| } | |
| } | |
| expect('('); | |
| if (!match(')')) { | |
| paramSet = {}; | |
| while (index < length) { | |
| token = lookahead(); | |
| param = parseVariableIdentifier(); | |
| if (strict) { | |
| if (isRestrictedWord(token.value)) { | |
| stricted = token; | |
| message = Messages.StrictParamName; | |
| } | |
| if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) { | |
| stricted = token; | |
| message = Messages.StrictParamDupe; | |
| } | |
| } else if (!firstRestricted) { | |
| if (isRestrictedWord(token.value)) { | |
| firstRestricted = token; | |
| message = Messages.StrictParamName; | |
| } else if (isStrictModeReservedWord(token.value)) { | |
| firstRestricted = token; | |
| message = Messages.StrictReservedWord; | |
| } else if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) { | |
| firstRestricted = token; | |
| message = Messages.StrictParamDupe; | |
| } | |
| } | |
| params.push(param); | |
| paramSet[param.name] = true; | |
| if (match(')')) { | |
| break; | |
| } | |
| expect(','); | |
| } | |
| } | |
| expect(')'); | |
| previousStrict = strict; | |
| body = parseFunctionSourceElements(); | |
| if (strict && firstRestricted) { | |
| throwError(firstRestricted, message); | |
| } | |
| if (strict && stricted) { | |
| throwErrorTolerant(stricted, message); | |
| } | |
| strict = previousStrict; | |
| return { | |
| type: Syntax.FunctionExpression, | |
| id: id, | |
| params: params, | |
| defaults: [], | |
| body: body, | |
| rest: null, | |
| generator: false, | |
| expression: false | |
| }; | |
| } | |
| // 14 Program | |
| function parseSourceElement() { | |
| var token = lookahead(); | |
| if (token.type === Token.Keyword) { | |
| switch (token.value) { | |
| case 'const': | |
| case 'let': | |
| return parseConstLetDeclaration(token.value); | |
| case 'function': | |
| return parseFunctionDeclaration(); | |
| default: | |
| return parseStatement(); | |
| } | |
| } | |
| if (token.type !== Token.EOF) { | |
| return parseStatement(); | |
| } | |
| } | |
| function parseSourceElements() { | |
| var sourceElement, sourceElements = [], token, directive, firstRestricted; | |
| while (index < length) { | |
| token = lookahead(); | |
| if (token.type !== Token.StringLiteral) { | |
| break; | |
| } | |
| sourceElement = parseSourceElement(); | |
| sourceElements.push(sourceElement); | |
| if (sourceElement.expression.type !== Syntax.Literal) { | |
| // this is not directive | |
| break; | |
| } | |
| directive = sliceSource(token.range[0] + 1, token.range[1] - 1); | |
| if (directive === 'use strict') { | |
| strict = true; | |
| if (firstRestricted) { | |
| throwErrorTolerant(firstRestricted, Messages.StrictOctalLiteral); | |
| } | |
| } else { | |
| if (!firstRestricted && token.octal) { | |
| firstRestricted = token; | |
| } | |
| } | |
| } | |
| while (index < length) { | |
| sourceElement = parseSourceElement(); | |
| if (typeof sourceElement === 'undefined') { | |
| break; | |
| } | |
| sourceElements.push(sourceElement); | |
| } | |
| return sourceElements; | |
| } | |
| function parseProgram() { | |
| var program; | |
| strict = false; | |
| program = { | |
| type: Syntax.Program, | |
| body: parseSourceElements() | |
| }; | |
| return program; | |
| } | |
| // The following functions are needed only when the option to preserve | |
| // the comments is active. | |
| function addComment(type, value, start, end, loc) { | |
| assert(typeof start === 'number', 'Comment must have valid position'); | |
| // Because the way the actual token is scanned, often the comments | |
| // (if any) are skipped twice during the lexical analysis. | |
| // Thus, we need to skip adding a comment if the comment array already | |
| // handled it. | |
| if (extra.comments.length > 0) { | |
| if (extra.comments[extra.comments.length - 1].range[1] > start) { | |
| return; | |
| } | |
| } | |
| extra.comments.push({ | |
| type: type, | |
| value: value, | |
| range: [start, end], | |
| loc: loc | |
| }); | |
| } | |
| function scanComment() { | |
| var comment, ch, loc, start, blockComment, lineComment; | |
| comment = ''; | |
| blockComment = false; | |
| lineComment = false; | |
| while (index < length) { | |
| ch = source[index]; | |
| if (lineComment) { | |
| ch = source[index++]; | |
| if (isLineTerminator(ch)) { | |
| loc.end = { | |
| line: lineNumber, | |
| column: index - lineStart - 1 | |
| }; | |
| lineComment = false; | |
| addComment('Line', comment, start, index - 1, loc); | |
| if (ch === '\r' && source[index] === '\n') { | |
| ++index; | |
| } | |
| ++lineNumber; | |
| lineStart = index; | |
| comment = ''; | |
| } else if (index >= length) { | |
| lineComment = false; | |
| comment += ch; | |
| loc.end = { | |
| line: lineNumber, | |
| column: length - lineStart | |
| }; | |
| addComment('Line', comment, start, length, loc); | |
| } else { | |
| comment += ch; | |
| } | |
| } else if (blockComment) { | |
| if (isLineTerminator(ch)) { | |
| if (ch === '\r' && source[index + 1] === '\n') { | |
| ++index; | |
| comment += '\r\n'; | |
| } else { | |
| comment += ch; | |
| } | |
| ++lineNumber; | |
| ++index; | |
| lineStart = index; | |
| if (index >= length) { | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| } else { | |
| ch = source[index++]; | |
| if (index >= length) { | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| comment += ch; | |
| if (ch === '*') { | |
| ch = source[index]; | |
| if (ch === '/') { | |
| comment = comment.substr(0, comment.length - 1); | |
| blockComment = false; | |
| ++index; | |
| loc.end = { | |
| line: lineNumber, | |
| column: index - lineStart | |
| }; | |
| addComment('Block', comment, start, index, loc); | |
| comment = ''; | |
| } | |
| } | |
| } | |
| } else if (ch === '/') { | |
| ch = source[index + 1]; | |
| if (ch === '/') { | |
| loc = { | |
| start: { | |
| line: lineNumber, | |
| column: index - lineStart | |
| } | |
| }; | |
| start = index; | |
| index += 2; | |
| lineComment = true; | |
| if (index >= length) { | |
| loc.end = { | |
| line: lineNumber, | |
| column: index - lineStart | |
| }; | |
| lineComment = false; | |
| addComment('Line', comment, start, index, loc); | |
| } | |
| } else if (ch === '*') { | |
| start = index; | |
| index += 2; | |
| blockComment = true; | |
| loc = { | |
| start: { | |
| line: lineNumber, | |
| column: index - lineStart - 2 | |
| } | |
| }; | |
| if (index >= length) { | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| } else { | |
| break; | |
| } | |
| } else if (isWhiteSpace(ch)) { | |
| ++index; | |
| } else if (isLineTerminator(ch)) { | |
| ++index; | |
| if (ch === '\r' && source[index] === '\n') { | |
| ++index; | |
| } | |
| ++lineNumber; | |
| lineStart = index; | |
| } else { | |
| break; | |
| } | |
| } | |
| } | |
| function filterCommentLocation() { | |
| var i, entry, comment, comments = []; | |
| for (i = 0; i < extra.comments.length; ++i) { | |
| entry = extra.comments[i]; | |
| comment = { | |
| type: entry.type, | |
| value: entry.value | |
| }; | |
| if (extra.range) { | |
| comment.range = entry.range; | |
| } | |
| if (extra.loc) { | |
| comment.loc = entry.loc; | |
| } | |
| comments.push(comment); | |
| } | |
| extra.comments = comments; | |
| } | |
| function collectToken() { | |
| var start, loc, token, range, value; | |
| skipComment(); | |
| start = index; | |
| loc = { | |
| start: { | |
| line: lineNumber, | |
| column: index - lineStart | |
| } | |
| }; | |
| token = extra.advance(); | |
| loc.end = { | |
| line: lineNumber, | |
| column: index - lineStart | |
| }; | |
| if (token.type !== Token.EOF) { | |
| range = [token.range[0], token.range[1]]; | |
| value = sliceSource(token.range[0], token.range[1]); | |
| extra.tokens.push({ | |
| type: TokenName[token.type], | |
| value: value, | |
| range: range, | |
| loc: loc | |
| }); | |
| } | |
| return token; | |
| } | |
| function collectRegex() { | |
| var pos, loc, regex, token; | |
| skipComment(); | |
| pos = index; | |
| loc = { | |
| start: { | |
| line: lineNumber, | |
| column: index - lineStart | |
| } | |
| }; | |
| regex = extra.scanRegExp(); | |
| loc.end = { | |
| line: lineNumber, | |
| column: index - lineStart | |
| }; | |
| // Pop the previous token, which is likely '/' or '/=' | |
| if (extra.tokens.length > 0) { | |
| token = extra.tokens[extra.tokens.length - 1]; | |
| if (token.range[0] === pos && token.type === 'Punctuator') { | |
| if (token.value === '/' || token.value === '/=') { | |
| extra.tokens.pop(); | |
| } | |
| } | |
| } | |
| extra.tokens.push({ | |
| type: 'RegularExpression', | |
| value: regex.literal, | |
| range: [pos, index], | |
| loc: loc | |
| }); | |
| return regex; | |
| } | |
| function filterTokenLocation() { | |
| var i, entry, token, tokens = []; | |
| for (i = 0; i < extra.tokens.length; ++i) { | |
| entry = extra.tokens[i]; | |
| token = { | |
| type: entry.type, | |
| value: entry.value | |
| }; | |
| if (extra.range) { | |
| token.range = entry.range; | |
| } | |
| if (extra.loc) { | |
| token.loc = entry.loc; | |
| } | |
| tokens.push(token); | |
| } | |
| extra.tokens = tokens; | |
| } | |
| function createLiteral(token) { | |
| return { | |
| type: Syntax.Literal, | |
| value: token.value | |
| }; | |
| } | |
| function createRawLiteral(token) { | |
| return { | |
| type: Syntax.Literal, | |
| value: token.value, | |
| raw: sliceSource(token.range[0], token.range[1]) | |
| }; | |
| } | |
| function createLocationMarker() { | |
| var marker = {}; | |
| marker.range = [index, index]; | |
| marker.loc = { | |
| start: { | |
| line: lineNumber, | |
| column: index - lineStart | |
| }, | |
| end: { | |
| line: lineNumber, | |
| column: index - lineStart | |
| } | |
| }; | |
| marker.end = function () { | |
| this.range[1] = index; | |
| this.loc.end.line = lineNumber; | |
| this.loc.end.column = index - lineStart; | |
| }; | |
| marker.applyGroup = function (node) { | |
| if (extra.range) { | |
| node.groupRange = [this.range[0], this.range[1]]; | |
| } | |
| if (extra.loc) { | |
| node.groupLoc = { | |
| start: { | |
| line: this.loc.start.line, | |
| column: this.loc.start.column | |
| }, | |
| end: { | |
| line: this.loc.end.line, | |
| column: this.loc.end.column | |
| } | |
| }; | |
| } | |
| }; | |
| marker.apply = function (node) { | |
| if (extra.range) { | |
| node.range = [this.range[0], this.range[1]]; | |
| } | |
| if (extra.loc) { | |
| node.loc = { | |
| start: { | |
| line: this.loc.start.line, | |
| column: this.loc.start.column | |
| }, | |
| end: { | |
| line: this.loc.end.line, | |
| column: this.loc.end.column | |
| } | |
| }; | |
| } | |
| }; | |
| return marker; | |
| } | |
| function trackGroupExpression() { | |
| var marker, expr; | |
| skipComment(); | |
| marker = createLocationMarker(); | |
| expect('('); | |
| expr = parseExpression(); | |
| expect(')'); | |
| marker.end(); | |
| marker.applyGroup(expr); | |
| return expr; | |
| } | |
| function trackLeftHandSideExpression() { | |
| var marker, expr; | |
| skipComment(); | |
| marker = createLocationMarker(); | |
| expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression(); | |
| while (match('.') || match('[')) { | |
| if (match('[')) { | |
| expr = { | |
| type: Syntax.MemberExpression, | |
| computed: true, | |
| object: expr, | |
| property: parseComputedMember() | |
| }; | |
| marker.end(); | |
| marker.apply(expr); | |
| } else { | |
| expr = { | |
| type: Syntax.MemberExpression, | |
| computed: false, | |
| object: expr, | |
| property: parseNonComputedMember() | |
| }; | |
| marker.end(); | |
| marker.apply(expr); | |
| } | |
| } | |
| return expr; | |
| } | |
| function trackLeftHandSideExpressionAllowCall() { | |
| var marker, expr; | |
| skipComment(); | |
| marker = createLocationMarker(); | |
| expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression(); | |
| while (match('.') || match('[') || match('(')) { | |
| if (match('(')) { | |
| expr = { | |
| type: Syntax.CallExpression, | |
| callee: expr, | |
| 'arguments': parseArguments() | |
| }; | |
| marker.end(); | |
| marker.apply(expr); | |
| } else if (match('[')) { | |
| expr = { | |
| type: Syntax.MemberExpression, | |
| computed: true, | |
| object: expr, | |
| property: parseComputedMember() | |
| }; | |
| marker.end(); | |
| marker.apply(expr); | |
| } else { | |
| expr = { | |
| type: Syntax.MemberExpression, | |
| computed: false, | |
| object: expr, | |
| property: parseNonComputedMember() | |
| }; | |
| marker.end(); | |
| marker.apply(expr); | |
| } | |
| } | |
| return expr; | |
| } | |
| function filterGroup(node) { | |
| var n, i, entry; | |
| n = (Object.prototype.toString.apply(node) === '[object Array]') ? [] : {}; | |
| for (i in node) { | |
| if (node.hasOwnProperty(i) && i !== 'groupRange' && i !== 'groupLoc') { | |
| entry = node[i]; | |
| if (entry === null || typeof entry !== 'object' || entry instanceof RegExp) { | |
| n[i] = entry; | |
| } else { | |
| n[i] = filterGroup(entry); | |
| } | |
| } | |
| } | |
| return n; | |
| } | |
| function wrapTrackingFunction(range, loc) { | |
| return function (parseFunction) { | |
| function isBinary(node) { | |
| return node.type === Syntax.LogicalExpression || | |
| node.type === Syntax.BinaryExpression; | |
| } | |
| function visit(node) { | |
| var start, end; | |
| if (isBinary(node.left)) { | |
| visit(node.left); | |
| } | |
| if (isBinary(node.right)) { | |
| visit(node.right); | |
| } | |
| if (range) { | |
| if (node.left.groupRange || node.right.groupRange) { | |
| start = node.left.groupRange ? node.left.groupRange[0] : node.left.range[0]; | |
| end = node.right.groupRange ? node.right.groupRange[1] : node.right.range[1]; | |
| node.range = [start, end]; | |
| } else if (typeof node.range === 'undefined') { | |
| start = node.left.range[0]; | |
| end = node.right.range[1]; | |
| node.range = [start, end]; | |
| } | |
| } | |
| if (loc) { | |
| if (node.left.groupLoc || node.right.groupLoc) { | |
| start = node.left.groupLoc ? node.left.groupLoc.start : node.left.loc.start; | |
| end = node.right.groupLoc ? node.right.groupLoc.end : node.right.loc.end; | |
| node.loc = { | |
| start: start, | |
| end: end | |
| }; | |
| } else if (typeof node.loc === 'undefined') { | |
| node.loc = { | |
| start: node.left.loc.start, | |
| end: node.right.loc.end | |
| }; | |
| } | |
| } | |
| } | |
| return function () { | |
| var marker, node; | |
| skipComment(); | |
| marker = createLocationMarker(); | |
| node = parseFunction.apply(null, arguments); | |
| marker.end(); | |
| if (range && typeof node.range === 'undefined') { | |
| marker.apply(node); | |
| } | |
| if (loc && typeof node.loc === 'undefined') { | |
| marker.apply(node); | |
| } | |
| if (isBinary(node)) { | |
| visit(node); | |
| } | |
| return node; | |
| }; | |
| }; | |
| } | |
| function patch() { | |
| var wrapTracking; | |
| if (extra.comments) { | |
| extra.skipComment = skipComment; | |
| skipComment = scanComment; | |
| } | |
| if (extra.raw) { | |
| extra.createLiteral = createLiteral; | |
| createLiteral = createRawLiteral; | |
| } | |
| if (extra.range || extra.loc) { | |
| extra.parseGroupExpression = parseGroupExpression; | |
| extra.parseLeftHandSideExpression = parseLeftHandSideExpression; | |
| extra.parseLeftHandSideExpressionAllowCall = parseLeftHandSideExpressionAllowCall; | |
| parseGroupExpression = trackGroupExpression; | |
| parseLeftHandSideExpression = trackLeftHandSideExpression; | |
| parseLeftHandSideExpressionAllowCall = trackLeftHandSideExpressionAllowCall; | |
| wrapTracking = wrapTrackingFunction(extra.range, extra.loc); | |
| extra.parseAdditiveExpression = parseAdditiveExpression; | |
| extra.parseAssignmentExpression = parseAssignmentExpression; | |
| extra.parseBitwiseANDExpression = parseBitwiseANDExpression; | |
| extra.parseBitwiseORExpression = parseBitwiseORExpression; | |
| extra.parseBitwiseXORExpression = parseBitwiseXORExpression; | |
| extra.parseBlock = parseBlock; | |
| extra.parseFunctionSourceElements = parseFunctionSourceElements; | |
| extra.parseCatchClause = parseCatchClause; | |
| extra.parseComputedMember = parseComputedMember; | |
| extra.parseConditionalExpression = parseConditionalExpression; | |
| extra.parseConstLetDeclaration = parseConstLetDeclaration; | |
| extra.parseEqualityExpression = parseEqualityExpression; | |
| extra.parseExpression = parseExpression; | |
| extra.parseForVariableDeclaration = parseForVariableDeclaration; | |
| extra.parseFunctionDeclaration = parseFunctionDeclaration; | |
| extra.parseFunctionExpression = parseFunctionExpression; | |
| extra.parseLogicalANDExpression = parseLogicalANDExpression; | |
| extra.parseLogicalORExpression = parseLogicalORExpression; | |
| extra.parseMultiplicativeExpression = parseMultiplicativeExpression; | |
| extra.parseNewExpression = parseNewExpression; | |
| extra.parseNonComputedProperty = parseNonComputedProperty; | |
| extra.parseObjectProperty = parseObjectProperty; | |
| extra.parseObjectPropertyKey = parseObjectPropertyKey; | |
| extra.parsePostfixExpression = parsePostfixExpression; | |
| extra.parsePrimaryExpression = parsePrimaryExpression; | |
| extra.parseProgram = parseProgram; | |
| extra.parsePropertyFunction = parsePropertyFunction; | |
| extra.parseRelationalExpression = parseRelationalExpression; | |
| extra.parseStatement = parseStatement; | |
| extra.parseShiftExpression = parseShiftExpression; | |
| extra.parseSwitchCase = parseSwitchCase; | |
| extra.parseUnaryExpression = parseUnaryExpression; | |
| extra.parseVariableDeclaration = parseVariableDeclaration; | |
| extra.parseVariableIdentifier = parseVariableIdentifier; | |
| parseAdditiveExpression = wrapTracking(extra.parseAdditiveExpression); | |
| parseAssignmentExpression = wrapTracking(extra.parseAssignmentExpression); | |
| parseBitwiseANDExpression = wrapTracking(extra.parseBitwiseANDExpression); | |
| parseBitwiseORExpression = wrapTracking(extra.parseBitwiseORExpression); | |
| parseBitwiseXORExpression = wrapTracking(extra.parseBitwiseXORExpression); | |
| parseBlock = wrapTracking(extra.parseBlock); | |
| parseFunctionSourceElements = wrapTracking(extra.parseFunctionSourceElements); | |
| parseCatchClause = wrapTracking(extra.parseCatchClause); | |
| parseComputedMember = wrapTracking(extra.parseComputedMember); | |
| parseConditionalExpression = wrapTracking(extra.parseConditionalExpression); | |
| parseConstLetDeclaration = wrapTracking(extra.parseConstLetDeclaration); | |
| parseEqualityExpression = wrapTracking(extra.parseEqualityExpression); | |
| parseExpression = wrapTracking(extra.parseExpression); | |
| parseForVariableDeclaration = wrapTracking(extra.parseForVariableDeclaration); | |
| parseFunctionDeclaration = wrapTracking(extra.parseFunctionDeclaration); | |
| parseFunctionExpression = wrapTracking(extra.parseFunctionExpression); | |
| parseLeftHandSideExpression = wrapTracking(parseLeftHandSideExpression); | |
| parseLogicalANDExpression = wrapTracking(extra.parseLogicalANDExpression); | |
| parseLogicalORExpression = wrapTracking(extra.parseLogicalORExpression); | |
| parseMultiplicativeExpression = wrapTracking(extra.parseMultiplicativeExpression); | |
| parseNewExpression = wrapTracking(extra.parseNewExpression); | |
| parseNonComputedProperty = wrapTracking(extra.parseNonComputedProperty); | |
| parseObjectProperty = wrapTracking(extra.parseObjectProperty); | |
| parseObjectPropertyKey = wrapTracking(extra.parseObjectPropertyKey); | |
| parsePostfixExpression = wrapTracking(extra.parsePostfixExpression); | |
| parsePrimaryExpression = wrapTracking(extra.parsePrimaryExpression); | |
| parseProgram = wrapTracking(extra.parseProgram); | |
| parsePropertyFunction = wrapTracking(extra.parsePropertyFunction); | |
| parseRelationalExpression = wrapTracking(extra.parseRelationalExpression); | |
| parseStatement = wrapTracking(extra.parseStatement); | |
| parseShiftExpression = wrapTracking(extra.parseShiftExpression); | |
| parseSwitchCase = wrapTracking(extra.parseSwitchCase); | |
| parseUnaryExpression = wrapTracking(extra.parseUnaryExpression); | |
| parseVariableDeclaration = wrapTracking(extra.parseVariableDeclaration); | |
| parseVariableIdentifier = wrapTracking(extra.parseVariableIdentifier); | |
| } | |
| if (typeof extra.tokens !== 'undefined') { | |
| extra.advance = advance; | |
| extra.scanRegExp = scanRegExp; | |
| advance = collectToken; | |
| scanRegExp = collectRegex; | |
| } | |
| } | |
| function unpatch() { | |
| if (typeof extra.skipComment === 'function') { | |
| skipComment = extra.skipComment; | |
| } | |
| if (extra.raw) { | |
| createLiteral = extra.createLiteral; | |
| } | |
| if (extra.range || extra.loc) { | |
| parseAdditiveExpression = extra.parseAdditiveExpression; | |
| parseAssignmentExpression = extra.parseAssignmentExpression; | |
| parseBitwiseANDExpression = extra.parseBitwiseANDExpression; | |
| parseBitwiseORExpression = extra.parseBitwiseORExpression; | |
| parseBitwiseXORExpression = extra.parseBitwiseXORExpression; | |
| parseBlock = extra.parseBlock; | |
| parseFunctionSourceElements = extra.parseFunctionSourceElements; | |
| parseCatchClause = extra.parseCatchClause; | |
| parseComputedMember = extra.parseComputedMember; | |
| parseConditionalExpression = extra.parseConditionalExpression; | |
| parseConstLetDeclaration = extra.parseConstLetDeclaration; | |
| parseEqualityExpression = extra.parseEqualityExpression; | |
| parseExpression = extra.parseExpression; | |
| parseForVariableDeclaration = extra.parseForVariableDeclaration; | |
| parseFunctionDeclaration = extra.parseFunctionDeclaration; | |
| parseFunctionExpression = extra.parseFunctionExpression; | |
| parseGroupExpression = extra.parseGroupExpression; | |
| parseLeftHandSideExpression = extra.parseLeftHandSideExpression; | |
| parseLeftHandSideExpressionAllowCall = extra.parseLeftHandSideExpressionAllowCall; | |
| parseLogicalANDExpression = extra.parseLogicalANDExpression; | |
| parseLogicalORExpression = extra.parseLogicalORExpression; | |
| parseMultiplicativeExpression = extra.parseMultiplicativeExpression; | |
| parseNewExpression = extra.parseNewExpression; | |
| parseNonComputedProperty = extra.parseNonComputedProperty; | |
| parseObjectProperty = extra.parseObjectProperty; | |
| parseObjectPropertyKey = extra.parseObjectPropertyKey; | |
| parsePrimaryExpression = extra.parsePrimaryExpression; | |
| parsePostfixExpression = extra.parsePostfixExpression; | |
| parseProgram = extra.parseProgram; | |
| parsePropertyFunction = extra.parsePropertyFunction; | |
| parseRelationalExpression = extra.parseRelationalExpression; | |
| parseStatement = extra.parseStatement; | |
| parseShiftExpression = extra.parseShiftExpression; | |
| parseSwitchCase = extra.parseSwitchCase; | |
| parseUnaryExpression = extra.parseUnaryExpression; | |
| parseVariableDeclaration = extra.parseVariableDeclaration; | |
| parseVariableIdentifier = extra.parseVariableIdentifier; | |
| } | |
| if (typeof extra.scanRegExp === 'function') { | |
| advance = extra.advance; | |
| scanRegExp = extra.scanRegExp; | |
| } | |
| } | |
| function stringToArray(str) { | |
| var length = str.length, | |
| result = [], | |
| i; | |
| for (i = 0; i < length; ++i) { | |
| result[i] = str.charAt(i); | |
| } | |
| return result; | |
| } | |
| function parse(code, options) { | |
| var program, toString; | |
| toString = String; | |
| if (typeof code !== 'string' && !(code instanceof String)) { | |
| code = toString(code); | |
| } | |
| source = code; | |
| index = 0; | |
| lineNumber = (source.length > 0) ? 1 : 0; | |
| lineStart = 0; | |
| length = source.length; | |
| buffer = null; | |
| state = { | |
| allowIn: true, | |
| labelSet: {}, | |
| inFunctionBody: false, | |
| inIteration: false, | |
| inSwitch: false | |
| }; | |
| extra = {}; | |
| if (typeof options !== 'undefined') { | |
| extra.range = (typeof options.range === 'boolean') && options.range; | |
| extra.loc = (typeof options.loc === 'boolean') && options.loc; | |
| extra.raw = (typeof options.raw === 'boolean') && options.raw; | |
| if (typeof options.tokens === 'boolean' && options.tokens) { | |
| extra.tokens = []; | |
| } | |
| if (typeof options.comment === 'boolean' && options.comment) { | |
| extra.comments = []; | |
| } | |
| if (typeof options.tolerant === 'boolean' && options.tolerant) { | |
| extra.errors = []; | |
| } | |
| } | |
| if (length > 0) { | |
| if (typeof source[0] === 'undefined') { | |
| // Try first to convert to a string. This is good as fast path | |
| // for old IE which understands string indexing for string | |
| // literals only and not for string object. | |
| if (code instanceof String) { | |
| source = code.valueOf(); | |
| } | |
| // Force accessing the characters via an array. | |
| if (typeof source[0] === 'undefined') { | |
| source = stringToArray(code); | |
| } | |
| } | |
| } | |
| patch(); | |
| try { | |
| program = parseProgram(); | |
| if (typeof extra.comments !== 'undefined') { | |
| filterCommentLocation(); | |
| program.comments = extra.comments; | |
| } | |
| if (typeof extra.tokens !== 'undefined') { | |
| filterTokenLocation(); | |
| program.tokens = extra.tokens; | |
| } | |
| if (typeof extra.errors !== 'undefined') { | |
| program.errors = extra.errors; | |
| } | |
| if (extra.range || extra.loc) { | |
| program.body = filterGroup(program.body); | |
| } | |
| } catch (e) { | |
| throw e; | |
| } finally { | |
| unpatch(); | |
| extra = {}; | |
| } | |
| return program; | |
| } | |
| // Sync with package.json. | |
| exports.version = '1.0.4'; | |
| exports.parse = parse; | |
| // Deep copy. | |
| exports.Syntax = (function () { | |
| var name, types = {}; | |
| if (typeof Object.create === 'function') { | |
| types = Object.create(null); | |
| } | |
| for (name in Syntax) { | |
| if (Syntax.hasOwnProperty(name)) { | |
| types[name] = Syntax[name]; | |
| } | |
| } | |
| if (typeof Object.freeze === 'function') { | |
| Object.freeze(types); | |
| } | |
| return types; | |
| }()); | |
| })); | |
| /* vim: set sw=4 ts=4 et tw=80 : */ | |
| })() | |
| },{}],17:[function(require,module,exports){ | |
| "use strict" | |
| function unique_pred(list, compare) { | |
| var ptr = 1 | |
| , len = list.length | |
| , a=list[0], b=list[0] | |
| for(var i=1; i<len; ++i) { | |
| b = a | |
| a = list[i] | |
| if(compare(a, b)) { | |
| if(i === ptr) { | |
| ptr++ | |
| continue | |
| } | |
| list[ptr++] = a | |
| } | |
| } | |
| list.length = ptr | |
| return list | |
| } | |
| function unique_eq(list) { | |
| var ptr = 1 | |
| , len = list.length | |
| , a=list[0], b = list[0] | |
| for(var i=1; i<len; ++i, b=a) { | |
| b = a | |
| a = list[i] | |
| if(a !== b) { | |
| if(i === ptr) { | |
| ptr++ | |
| continue | |
| } | |
| list[ptr++] = a | |
| } | |
| } | |
| list.length = ptr | |
| return list | |
| } | |
| function unique(list, compare, sorted) { | |
| if(list.length === 0) { | |
| return [] | |
| } | |
| if(compare) { | |
| if(!sorted) { | |
| list.sort(compare) | |
| } | |
| return unique_pred(list, compare) | |
| } | |
| if(!sorted) { | |
| list.sort() | |
| } | |
| return unique_eq(list) | |
| } | |
| module.exports = unique | |
| },{}],18:[function(require,module,exports){ | |
| (function(){/* | |
| Copyright (C) 2012 Ariya Hidayat <[email protected]> | |
| Copyright (C) 2012 Mathias Bynens <[email protected]> | |
| Copyright (C) 2012 Joost-Wim Boekesteijn <[email protected]> | |
| Copyright (C) 2012 Kris Kowal <[email protected]> | |
| Copyright (C) 2012 Yusuke Suzuki <[email protected]> | |
| Copyright (C) 2012 Arpad Borsos <[email protected]> | |
| Copyright (C) 2011 Ariya Hidayat <[email protected]> | |
| Redistribution and use in source and binary forms, with or without | |
| modification, are permitted provided that the following conditions are met: | |
| * Redistributions of source code must retain the above copyright | |
| notice, this list of conditions and the following disclaimer. | |
| * Redistributions in binary form must reproduce the above copyright | |
| notice, this list of conditions and the following disclaimer in the | |
| documentation and/or other materials provided with the distribution. | |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" | |
| AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
| IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
| ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY | |
| DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | |
| (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | |
| LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | |
| ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
| (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF | |
| THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| */ | |
| /*jslint bitwise:true plusplus:true */ | |
| /*global esprima:true, define:true, exports:true, window: true, | |
| throwError: true, createLiteral: true, generateStatement: true, | |
| parseAssignmentExpression: true, parseBlock: true, parseExpression: true, | |
| parseFunctionDeclaration: true, parseFunctionExpression: true, | |
| parseFunctionSourceElements: true, parseVariableIdentifier: true, | |
| parseLeftHandSideExpression: true, | |
| parseStatement: true, parseSourceElement: true */ | |
| (function (root, factory) { | |
| 'use strict'; | |
| // Universal Module Definition (UMD) to support AMD, CommonJS/Node.js, | |
| // Rhino, and plain browser loading. | |
| if (typeof define === 'function' && define.amd) { | |
| define(['exports'], factory); | |
| } else if (typeof exports !== 'undefined') { | |
| factory(exports); | |
| } else { | |
| factory((root.esprima = {})); | |
| } | |
| }(this, function (exports) { | |
| 'use strict'; | |
| var Token, | |
| TokenName, | |
| Syntax, | |
| PropertyKind, | |
| Messages, | |
| Regex, | |
| source, | |
| strict, | |
| index, | |
| lineNumber, | |
| lineStart, | |
| length, | |
| buffer, | |
| state, | |
| extra; | |
| Token = { | |
| BooleanLiteral: 1, | |
| EOF: 2, | |
| Identifier: 3, | |
| Keyword: 4, | |
| NullLiteral: 5, | |
| NumericLiteral: 6, | |
| Punctuator: 7, | |
| StringLiteral: 8 | |
| }; | |
| TokenName = {}; | |
| TokenName[Token.BooleanLiteral] = 'Boolean'; | |
| TokenName[Token.EOF] = '<end>'; | |
| TokenName[Token.Identifier] = 'Identifier'; | |
| TokenName[Token.Keyword] = 'Keyword'; | |
| TokenName[Token.NullLiteral] = 'Null'; | |
| TokenName[Token.NumericLiteral] = 'Numeric'; | |
| TokenName[Token.Punctuator] = 'Punctuator'; | |
| TokenName[Token.StringLiteral] = 'String'; | |
| Syntax = { | |
| AssignmentExpression: 'AssignmentExpression', | |
| ArrayExpression: 'ArrayExpression', | |
| BlockStatement: 'BlockStatement', | |
| BinaryExpression: 'BinaryExpression', | |
| BreakStatement: 'BreakStatement', | |
| CallExpression: 'CallExpression', | |
| CatchClause: 'CatchClause', | |
| ConditionalExpression: 'ConditionalExpression', | |
| ContinueStatement: 'ContinueStatement', | |
| DoWhileStatement: 'DoWhileStatement', | |
| DebuggerStatement: 'DebuggerStatement', | |
| EmptyStatement: 'EmptyStatement', | |
| ExpressionStatement: 'ExpressionStatement', | |
| ForStatement: 'ForStatement', | |
| ForInStatement: 'ForInStatement', | |
| FunctionDeclaration: 'FunctionDeclaration', | |
| FunctionExpression: 'FunctionExpression', | |
| Identifier: 'Identifier', | |
| IfStatement: 'IfStatement', | |
| Literal: 'Literal', | |
| LabeledStatement: 'LabeledStatement', | |
| LogicalExpression: 'LogicalExpression', | |
| MemberExpression: 'MemberExpression', | |
| NewExpression: 'NewExpression', | |
| ObjectExpression: 'ObjectExpression', | |
| Program: 'Program', | |
| Property: 'Property', | |
| ReturnStatement: 'ReturnStatement', | |
| SequenceExpression: 'SequenceExpression', | |
| SwitchStatement: 'SwitchStatement', | |
| SwitchCase: 'SwitchCase', | |
| ThisExpression: 'ThisExpression', | |
| ThrowStatement: 'ThrowStatement', | |
| TryStatement: 'TryStatement', | |
| UnaryExpression: 'UnaryExpression', | |
| UpdateExpression: 'UpdateExpression', | |
| VariableDeclaration: 'VariableDeclaration', | |
| VariableDeclarator: 'VariableDeclarator', | |
| WhileStatement: 'WhileStatement', | |
| WithStatement: 'WithStatement' | |
| }; | |
| PropertyKind = { | |
| Data: 1, | |
| Get: 2, | |
| Set: 4 | |
| }; | |
| // Error messages should be identical to V8. | |
| Messages = { | |
| UnexpectedToken: 'Unexpected token %0', | |
| UnexpectedNumber: 'Unexpected number', | |
| UnexpectedString: 'Unexpected string', | |
| UnexpectedIdentifier: 'Unexpected identifier', | |
| UnexpectedReserved: 'Unexpected reserved word', | |
| UnexpectedEOS: 'Unexpected end of input', | |
| NewlineAfterThrow: 'Illegal newline after throw', | |
| InvalidRegExp: 'Invalid regular expression', | |
| UnterminatedRegExp: 'Invalid regular expression: missing /', | |
| InvalidLHSInAssignment: 'Invalid left-hand side in assignment', | |
| InvalidLHSInForIn: 'Invalid left-hand side in for-in', | |
| MultipleDefaultsInSwitch: 'More than one default clause in switch statement', | |
| NoCatchOrFinally: 'Missing catch or finally after try', | |
| UnknownLabel: 'Undefined label \'%0\'', | |
| Redeclaration: '%0 \'%1\' has already been declared', | |
| IllegalContinue: 'Illegal continue statement', | |
| IllegalBreak: 'Illegal break statement', | |
| IllegalReturn: 'Illegal return statement', | |
| StrictModeWith: 'Strict mode code may not include a with statement', | |
| StrictCatchVariable: 'Catch variable may not be eval or arguments in strict mode', | |
| StrictVarName: 'Variable name may not be eval or arguments in strict mode', | |
| StrictParamName: 'Parameter name eval or arguments is not allowed in strict mode', | |
| StrictParamDupe: 'Strict mode function may not have duplicate parameter names', | |
| StrictFunctionName: 'Function name may not be eval or arguments in strict mode', | |
| StrictOctalLiteral: 'Octal literals are not allowed in strict mode.', | |
| StrictDelete: 'Delete of an unqualified identifier in strict mode.', | |
| StrictDuplicateProperty: 'Duplicate data property in object literal not allowed in strict mode', | |
| AccessorDataProperty: 'Object literal may not have data and accessor property with the same name', | |
| AccessorGetSet: 'Object literal may not have multiple get/set accessors with the same name', | |
| StrictLHSAssignment: 'Assignment to eval or arguments is not allowed in strict mode', | |
| StrictLHSPostfix: 'Postfix increment/decrement may not have eval or arguments operand in strict mode', | |
| StrictLHSPrefix: 'Prefix increment/decrement may not have eval or arguments operand in strict mode', | |
| StrictReservedWord: 'Use of future reserved word in strict mode' | |
| }; | |
| // See also tools/generate-unicode-regex.py. | |
| Regex = { | |
| NonAsciiIdentifierStart: new RegExp('[\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0\u08a2-\u08ac\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097f\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d\u0c58\u0c59\u0c60\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d60\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191c\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19c1-\u19c7\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua697\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa80-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc]'), | |
| NonAsciiIdentifierPart: new RegExp('[\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0300-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u0483-\u0487\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u05d0-\u05ea\u05f0-\u05f2\u0610-\u061a\u0620-\u0669\u066e-\u06d3\u06d5-\u06dc\u06df-\u06e8\u06ea-\u06fc\u06ff\u0710-\u074a\u074d-\u07b1\u07c0-\u07f5\u07fa\u0800-\u082d\u0840-\u085b\u08a0\u08a2-\u08ac\u08e4-\u08fe\u0900-\u0963\u0966-\u096f\u0971-\u0977\u0979-\u097f\u0981-\u0983\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bc-\u09c4\u09c7\u09c8\u09cb-\u09ce\u09d7\u09dc\u09dd\u09df-\u09e3\u09e6-\u09f1\u0a01-\u0a03\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a59-\u0a5c\u0a5e\u0a66-\u0a75\u0a81-\u0a83\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abc-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ad0\u0ae0-\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3c-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b5c\u0b5d\u0b5f-\u0b63\u0b66-\u0b6f\u0b71\u0b82\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd0\u0bd7\u0be6-\u0bef\u0c01-\u0c03\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c58\u0c59\u0c60-\u0c63\u0c66-\u0c6f\u0c82\u0c83\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbc-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0cde\u0ce0-\u0ce3\u0ce6-\u0cef\u0cf1\u0cf2\u0d02\u0d03\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d-\u0d44\u0d46-\u0d48\u0d4a-\u0d4e\u0d57\u0d60-\u0d63\u0d66-\u0d6f\u0d7a-\u0d7f\u0d82\u0d83\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2\u0df3\u0e01-\u0e3a\u0e40-\u0e4e\u0e50-\u0e59\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb9\u0ebb-\u0ebd\u0ec0-\u0ec4\u0ec6\u0ec8-\u0ecd\u0ed0-\u0ed9\u0edc-\u0edf\u0f00\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e-\u0f47\u0f49-\u0f6c\u0f71-\u0f84\u0f86-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1049\u1050-\u109d\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u135d-\u135f\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176c\u176e-\u1770\u1772\u1773\u1780-\u17d3\u17d7\u17dc\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u1820-\u1877\u1880-\u18aa\u18b0-\u18f5\u1900-\u191c\u1920-\u192b\u1930-\u193b\u1946-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u19d0-\u19d9\u1a00-\u1a1b\u1a20-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1aa7\u1b00-\u1b4b\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1bf3\u1c00-\u1c37\u1c40-\u1c49\u1c4d-\u1c7d\u1cd0-\u1cd2\u1cd4-\u1cf6\u1d00-\u1de6\u1dfc-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u200c\u200d\u203f\u2040\u2054\u2071\u207f\u2090-\u209c\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d7f-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2de0-\u2dff\u2e2f\u3005-\u3007\u3021-\u302f\u3031-\u3035\u3038-\u303c\u3041-\u3096\u3099\u309a\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua62b\ua640-\ua66f\ua674-\ua67d\ua67f-\ua697\ua69f-\ua6f1\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua827\ua840-\ua873\ua880-\ua8c4\ua8d0-\ua8d9\ua8e0-\ua8f7\ua8fb\ua900-\ua92d\ua930-\ua953\ua960-\ua97c\ua980-\ua9c0\ua9cf-\ua9d9\uaa00-\uaa36\uaa40-\uaa4d\uaa50-\uaa59\uaa60-\uaa76\uaa7a\uaa7b\uaa80-\uaac2\uaadb-\uaadd\uaae0-\uaaef\uaaf2-\uaaf6\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabea\uabec\uabed\uabf0-\uabf9\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe00-\ufe0f\ufe20-\ufe26\ufe33\ufe34\ufe4d-\ufe4f\ufe70-\ufe74\ufe76-\ufefc\uff10-\uff19\uff21-\uff3a\uff3f\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc]') | |
| }; | |
| // Ensure the condition is true, otherwise throw an error. | |
| // This is only to have a better contract semantic, i.e. another safety net | |
| // to catch a logic error. The condition shall be fulfilled in normal case. | |
| // Do NOT use this to enforce a certain condition on any user input. | |
| function assert(condition, message) { | |
| if (!condition) { | |
| throw new Error('ASSERT: ' + message); | |
| } | |
| } | |
| function sliceSource(from, to) { | |
| return source.slice(from, to); | |
| } | |
| if (typeof 'esprima'[0] === 'undefined') { | |
| sliceSource = function sliceArraySource(from, to) { | |
| return source.slice(from, to).join(''); | |
| }; | |
| } | |
| function isDecimalDigit(ch) { | |
| return '0123456789'.indexOf(ch) >= 0; | |
| } | |
| function isHexDigit(ch) { | |
| return '0123456789abcdefABCDEF'.indexOf(ch) >= 0; | |
| } | |
| function isOctalDigit(ch) { | |
| return '01234567'.indexOf(ch) >= 0; | |
| } | |
| // 7.2 White Space | |
| function isWhiteSpace(ch) { | |
| return (ch === ' ') || (ch === '\u0009') || (ch === '\u000B') || | |
| (ch === '\u000C') || (ch === '\u00A0') || | |
| (ch.charCodeAt(0) >= 0x1680 && | |
| '\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\uFEFF'.indexOf(ch) >= 0); | |
| } | |
| // 7.3 Line Terminators | |
| function isLineTerminator(ch) { | |
| return (ch === '\n' || ch === '\r' || ch === '\u2028' || ch === '\u2029'); | |
| } | |
| // 7.6 Identifier Names and Identifiers | |
| function isIdentifierStart(ch) { | |
| return (ch === '$') || (ch === '_') || (ch === '\\') || | |
| (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || | |
| ((ch.charCodeAt(0) >= 0x80) && Regex.NonAsciiIdentifierStart.test(ch)); | |
| } | |
| function isIdentifierPart(ch) { | |
| return (ch === '$') || (ch === '_') || (ch === '\\') || | |
| (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || | |
| ((ch >= '0') && (ch <= '9')) || | |
| ((ch.charCodeAt(0) >= 0x80) && Regex.NonAsciiIdentifierPart.test(ch)); | |
| } | |
| // 7.6.1.2 Future Reserved Words | |
| function isFutureReservedWord(id) { | |
| switch (id) { | |
| // Future reserved words. | |
| case 'class': | |
| case 'enum': | |
| case 'export': | |
| case 'extends': | |
| case 'import': | |
| case 'super': | |
| return true; | |
| } | |
| return false; | |
| } | |
| function isStrictModeReservedWord(id) { | |
| switch (id) { | |
| // Strict Mode reserved words. | |
| case 'implements': | |
| case 'interface': | |
| case 'package': | |
| case 'private': | |
| case 'protected': | |
| case 'public': | |
| case 'static': | |
| case 'yield': | |
| case 'let': | |
| return true; | |
| } | |
| return false; | |
| } | |
| function isRestrictedWord(id) { | |
| return id === 'eval' || id === 'arguments'; | |
| } | |
| // 7.6.1.1 Keywords | |
| function isKeyword(id) { | |
| var keyword = false; | |
| switch (id.length) { | |
| case 2: | |
| keyword = (id === 'if') || (id === 'in') || (id === 'do'); | |
| break; | |
| case 3: | |
| keyword = (id === 'var') || (id === 'for') || (id === 'new') || (id === 'try'); | |
| break; | |
| case 4: | |
| keyword = (id === 'this') || (id === 'else') || (id === 'case') || (id === 'void') || (id === 'with'); | |
| break; | |
| case 5: | |
| keyword = (id === 'while') || (id === 'break') || (id === 'catch') || (id === 'throw'); | |
| break; | |
| case 6: | |
| keyword = (id === 'return') || (id === 'typeof') || (id === 'delete') || (id === 'switch'); | |
| break; | |
| case 7: | |
| keyword = (id === 'default') || (id === 'finally'); | |
| break; | |
| case 8: | |
| keyword = (id === 'function') || (id === 'continue') || (id === 'debugger'); | |
| break; | |
| case 10: | |
| keyword = (id === 'instanceof'); | |
| break; | |
| } | |
| if (keyword) { | |
| return true; | |
| } | |
| switch (id) { | |
| // Future reserved words. | |
| // 'const' is specialized as Keyword in V8. | |
| case 'const': | |
| return true; | |
| // For compatiblity to SpiderMonkey and ES.next | |
| case 'yield': | |
| case 'let': | |
| return true; | |
| } | |
| if (strict && isStrictModeReservedWord(id)) { | |
| return true; | |
| } | |
| return isFutureReservedWord(id); | |
| } | |
| // 7.4 Comments | |
| function skipComment() { | |
| var ch, blockComment, lineComment; | |
| blockComment = false; | |
| lineComment = false; | |
| while (index < length) { | |
| ch = source[index]; | |
| if (lineComment) { | |
| ch = source[index++]; | |
| if (isLineTerminator(ch)) { | |
| lineComment = false; | |
| if (ch === '\r' && source[index] === '\n') { | |
| ++index; | |
| } | |
| ++lineNumber; | |
| lineStart = index; | |
| } | |
| } else if (blockComment) { | |
| if (isLineTerminator(ch)) { | |
| if (ch === '\r' && source[index + 1] === '\n') { | |
| ++index; | |
| } | |
| ++lineNumber; | |
| ++index; | |
| lineStart = index; | |
| if (index >= length) { | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| } else { | |
| ch = source[index++]; | |
| if (index >= length) { | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| if (ch === '*') { | |
| ch = source[index]; | |
| if (ch === '/') { | |
| ++index; | |
| blockComment = false; | |
| } | |
| } | |
| } | |
| } else if (ch === '/') { | |
| ch = source[index + 1]; | |
| if (ch === '/') { | |
| index += 2; | |
| lineComment = true; | |
| } else if (ch === '*') { | |
| index += 2; | |
| blockComment = true; | |
| if (index >= length) { | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| } else { | |
| break; | |
| } | |
| } else if (isWhiteSpace(ch)) { | |
| ++index; | |
| } else if (isLineTerminator(ch)) { | |
| ++index; | |
| if (ch === '\r' && source[index] === '\n') { | |
| ++index; | |
| } | |
| ++lineNumber; | |
| lineStart = index; | |
| } else { | |
| break; | |
| } | |
| } | |
| } | |
| function scanHexEscape(prefix) { | |
| var i, len, ch, code = 0; | |
| len = (prefix === 'u') ? 4 : 2; | |
| for (i = 0; i < len; ++i) { | |
| if (index < length && isHexDigit(source[index])) { | |
| ch = source[index++]; | |
| code = code * 16 + '0123456789abcdef'.indexOf(ch.toLowerCase()); | |
| } else { | |
| return ''; | |
| } | |
| } | |
| return String.fromCharCode(code); | |
| } | |
| function scanIdentifier() { | |
| var ch, start, id, restore; | |
| ch = source[index]; | |
| if (!isIdentifierStart(ch)) { | |
| return; | |
| } | |
| start = index; | |
| if (ch === '\\') { | |
| ++index; | |
| if (source[index] !== 'u') { | |
| return; | |
| } | |
| ++index; | |
| restore = index; | |
| ch = scanHexEscape('u'); | |
| if (ch) { | |
| if (ch === '\\' || !isIdentifierStart(ch)) { | |
| return; | |
| } | |
| id = ch; | |
| } else { | |
| index = restore; | |
| id = 'u'; | |
| } | |
| } else { | |
| id = source[index++]; | |
| } | |
| while (index < length) { | |
| ch = source[index]; | |
| if (!isIdentifierPart(ch)) { | |
| break; | |
| } | |
| if (ch === '\\') { | |
| ++index; | |
| if (source[index] !== 'u') { | |
| return; | |
| } | |
| ++index; | |
| restore = index; | |
| ch = scanHexEscape('u'); | |
| if (ch) { | |
| if (ch === '\\' || !isIdentifierPart(ch)) { | |
| return; | |
| } | |
| id += ch; | |
| } else { | |
| index = restore; | |
| id += 'u'; | |
| } | |
| } else { | |
| id += source[index++]; | |
| } | |
| } | |
| // There is no keyword or literal with only one character. | |
| // Thus, it must be an identifier. | |
| if (id.length === 1) { | |
| return { | |
| type: Token.Identifier, | |
| value: id, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| if (isKeyword(id)) { | |
| return { | |
| type: Token.Keyword, | |
| value: id, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| // 7.8.1 Null Literals | |
| if (id === 'null') { | |
| return { | |
| type: Token.NullLiteral, | |
| value: id, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| // 7.8.2 Boolean Literals | |
| if (id === 'true' || id === 'false') { | |
| return { | |
| type: Token.BooleanLiteral, | |
| value: id, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| return { | |
| type: Token.Identifier, | |
| value: id, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| // 7.7 Punctuators | |
| function scanPunctuator() { | |
| var start = index, | |
| ch1 = source[index], | |
| ch2, | |
| ch3, | |
| ch4; | |
| // Check for most common single-character punctuators. | |
| if (ch1 === ';' || ch1 === '{' || ch1 === '}') { | |
| ++index; | |
| return { | |
| type: Token.Punctuator, | |
| value: ch1, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| if (ch1 === ',' || ch1 === '(' || ch1 === ')') { | |
| ++index; | |
| return { | |
| type: Token.Punctuator, | |
| value: ch1, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| // Dot (.) can also start a floating-point number, hence the need | |
| // to check the next character. | |
| ch2 = source[index + 1]; | |
| if (ch1 === '.' && !isDecimalDigit(ch2)) { | |
| return { | |
| type: Token.Punctuator, | |
| value: source[index++], | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| // Peek more characters. | |
| ch3 = source[index + 2]; | |
| ch4 = source[index + 3]; | |
| // 4-character punctuator: >>>= | |
| if (ch1 === '>' && ch2 === '>' && ch3 === '>') { | |
| if (ch4 === '=') { | |
| index += 4; | |
| return { | |
| type: Token.Punctuator, | |
| value: '>>>=', | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| } | |
| // 3-character punctuators: === !== >>> <<= >>= | |
| if (ch1 === '=' && ch2 === '=' && ch3 === '=') { | |
| index += 3; | |
| return { | |
| type: Token.Punctuator, | |
| value: '===', | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| if (ch1 === '!' && ch2 === '=' && ch3 === '=') { | |
| index += 3; | |
| return { | |
| type: Token.Punctuator, | |
| value: '!==', | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| if (ch1 === '>' && ch2 === '>' && ch3 === '>') { | |
| index += 3; | |
| return { | |
| type: Token.Punctuator, | |
| value: '>>>', | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| if (ch1 === '<' && ch2 === '<' && ch3 === '=') { | |
| index += 3; | |
| return { | |
| type: Token.Punctuator, | |
| value: '<<=', | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| if (ch1 === '>' && ch2 === '>' && ch3 === '=') { | |
| index += 3; | |
| return { | |
| type: Token.Punctuator, | |
| value: '>>=', | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| // 2-character punctuators: <= >= == != ++ -- << >> && || | |
| // += -= *= %= &= |= ^= /= | |
| if (ch2 === '=') { | |
| if ('<>=!+-*%&|^/'.indexOf(ch1) >= 0) { | |
| index += 2; | |
| return { | |
| type: Token.Punctuator, | |
| value: ch1 + ch2, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| } | |
| if (ch1 === ch2 && ('+-<>&|'.indexOf(ch1) >= 0)) { | |
| if ('+-<>&|'.indexOf(ch2) >= 0) { | |
| index += 2; | |
| return { | |
| type: Token.Punctuator, | |
| value: ch1 + ch2, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| } | |
| // The remaining 1-character punctuators. | |
| if ('[]<>+-*%&|^!~?:=/'.indexOf(ch1) >= 0) { | |
| return { | |
| type: Token.Punctuator, | |
| value: source[index++], | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| } | |
| // 7.8.3 Numeric Literals | |
| function scanNumericLiteral() { | |
| var number, start, ch; | |
| ch = source[index]; | |
| assert(isDecimalDigit(ch) || (ch === '.'), | |
| 'Numeric literal must start with a decimal digit or a decimal point'); | |
| start = index; | |
| number = ''; | |
| if (ch !== '.') { | |
| number = source[index++]; | |
| ch = source[index]; | |
| // Hex number starts with '0x'. | |
| // Octal number starts with '0'. | |
| if (number === '0') { | |
| if (ch === 'x' || ch === 'X') { | |
| number += source[index++]; | |
| while (index < length) { | |
| ch = source[index]; | |
| if (!isHexDigit(ch)) { | |
| break; | |
| } | |
| number += source[index++]; | |
| } | |
| if (number.length <= 2) { | |
| // only 0x | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| if (index < length) { | |
| ch = source[index]; | |
| if (isIdentifierStart(ch)) { | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| } | |
| return { | |
| type: Token.NumericLiteral, | |
| value: parseInt(number, 16), | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } else if (isOctalDigit(ch)) { | |
| number += source[index++]; | |
| while (index < length) { | |
| ch = source[index]; | |
| if (!isOctalDigit(ch)) { | |
| break; | |
| } | |
| number += source[index++]; | |
| } | |
| if (index < length) { | |
| ch = source[index]; | |
| if (isIdentifierStart(ch) || isDecimalDigit(ch)) { | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| } | |
| return { | |
| type: Token.NumericLiteral, | |
| value: parseInt(number, 8), | |
| octal: true, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| // decimal number starts with '0' such as '09' is illegal. | |
| if (isDecimalDigit(ch)) { | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| } | |
| while (index < length) { | |
| ch = source[index]; | |
| if (!isDecimalDigit(ch)) { | |
| break; | |
| } | |
| number += source[index++]; | |
| } | |
| } | |
| if (ch === '.') { | |
| number += source[index++]; | |
| while (index < length) { | |
| ch = source[index]; | |
| if (!isDecimalDigit(ch)) { | |
| break; | |
| } | |
| number += source[index++]; | |
| } | |
| } | |
| if (ch === 'e' || ch === 'E') { | |
| number += source[index++]; | |
| ch = source[index]; | |
| if (ch === '+' || ch === '-') { | |
| number += source[index++]; | |
| } | |
| ch = source[index]; | |
| if (isDecimalDigit(ch)) { | |
| number += source[index++]; | |
| while (index < length) { | |
| ch = source[index]; | |
| if (!isDecimalDigit(ch)) { | |
| break; | |
| } | |
| number += source[index++]; | |
| } | |
| } else { | |
| ch = 'character ' + ch; | |
| if (index >= length) { | |
| ch = '<end>'; | |
| } | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| } | |
| if (index < length) { | |
| ch = source[index]; | |
| if (isIdentifierStart(ch)) { | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| } | |
| return { | |
| type: Token.NumericLiteral, | |
| value: parseFloat(number), | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| // 7.8.4 String Literals | |
| function scanStringLiteral() { | |
| var str = '', quote, start, ch, code, unescaped, restore, octal = false; | |
| quote = source[index]; | |
| assert((quote === '\'' || quote === '"'), | |
| 'String literal must starts with a quote'); | |
| start = index; | |
| ++index; | |
| while (index < length) { | |
| ch = source[index++]; | |
| if (ch === quote) { | |
| quote = ''; | |
| break; | |
| } else if (ch === '\\') { | |
| ch = source[index++]; | |
| if (!isLineTerminator(ch)) { | |
| switch (ch) { | |
| case 'n': | |
| str += '\n'; | |
| break; | |
| case 'r': | |
| str += '\r'; | |
| break; | |
| case 't': | |
| str += '\t'; | |
| break; | |
| case 'u': | |
| case 'x': | |
| restore = index; | |
| unescaped = scanHexEscape(ch); | |
| if (unescaped) { | |
| str += unescaped; | |
| } else { | |
| index = restore; | |
| str += ch; | |
| } | |
| break; | |
| case 'b': | |
| str += '\b'; | |
| break; | |
| case 'f': | |
| str += '\f'; | |
| break; | |
| case 'v': | |
| str += '\x0B'; | |
| break; | |
| default: | |
| if (isOctalDigit(ch)) { | |
| code = '01234567'.indexOf(ch); | |
| // \0 is not octal escape sequence | |
| if (code !== 0) { | |
| octal = true; | |
| } | |
| if (index < length && isOctalDigit(source[index])) { | |
| octal = true; | |
| code = code * 8 + '01234567'.indexOf(source[index++]); | |
| // 3 digits are only allowed when string starts | |
| // with 0, 1, 2, 3 | |
| if ('0123'.indexOf(ch) >= 0 && | |
| index < length && | |
| isOctalDigit(source[index])) { | |
| code = code * 8 + '01234567'.indexOf(source[index++]); | |
| } | |
| } | |
| str += String.fromCharCode(code); | |
| } else { | |
| str += ch; | |
| } | |
| break; | |
| } | |
| } else { | |
| ++lineNumber; | |
| if (ch === '\r' && source[index] === '\n') { | |
| ++index; | |
| } | |
| } | |
| } else if (isLineTerminator(ch)) { | |
| break; | |
| } else { | |
| str += ch; | |
| } | |
| } | |
| if (quote !== '') { | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| return { | |
| type: Token.StringLiteral, | |
| value: str, | |
| octal: octal, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| function scanRegExp() { | |
| var str, ch, start, pattern, flags, value, classMarker = false, restore, terminated = false; | |
| buffer = null; | |
| skipComment(); | |
| start = index; | |
| ch = source[index]; | |
| assert(ch === '/', 'Regular expression literal must start with a slash'); | |
| str = source[index++]; | |
| while (index < length) { | |
| ch = source[index++]; | |
| str += ch; | |
| if (ch === '\\') { | |
| ch = source[index++]; | |
| // ECMA-262 7.8.5 | |
| if (isLineTerminator(ch)) { | |
| throwError({}, Messages.UnterminatedRegExp); | |
| } | |
| str += ch; | |
| } else if (classMarker) { | |
| if (ch === ']') { | |
| classMarker = false; | |
| } | |
| } else { | |
| if (ch === '/') { | |
| terminated = true; | |
| break; | |
| } else if (ch === '[') { | |
| classMarker = true; | |
| } else if (isLineTerminator(ch)) { | |
| throwError({}, Messages.UnterminatedRegExp); | |
| } | |
| } | |
| } | |
| if (!terminated) { | |
| throwError({}, Messages.UnterminatedRegExp); | |
| } | |
| // Exclude leading and trailing slash. | |
| pattern = str.substr(1, str.length - 2); | |
| flags = ''; | |
| while (index < length) { | |
| ch = source[index]; | |
| if (!isIdentifierPart(ch)) { | |
| break; | |
| } | |
| ++index; | |
| if (ch === '\\' && index < length) { | |
| ch = source[index]; | |
| if (ch === 'u') { | |
| ++index; | |
| restore = index; | |
| ch = scanHexEscape('u'); | |
| if (ch) { | |
| flags += ch; | |
| str += '\\u'; | |
| for (; restore < index; ++restore) { | |
| str += source[restore]; | |
| } | |
| } else { | |
| index = restore; | |
| flags += 'u'; | |
| str += '\\u'; | |
| } | |
| } else { | |
| str += '\\'; | |
| } | |
| } else { | |
| flags += ch; | |
| str += ch; | |
| } | |
| } | |
| try { | |
| value = new RegExp(pattern, flags); | |
| } catch (e) { | |
| throwError({}, Messages.InvalidRegExp); | |
| } | |
| return { | |
| literal: str, | |
| value: value, | |
| range: [start, index] | |
| }; | |
| } | |
| function isIdentifierName(token) { | |
| return token.type === Token.Identifier || | |
| token.type === Token.Keyword || | |
| token.type === Token.BooleanLiteral || | |
| token.type === Token.NullLiteral; | |
| } | |
| function advance() { | |
| var ch, token; | |
| skipComment(); | |
| if (index >= length) { | |
| return { | |
| type: Token.EOF, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [index, index] | |
| }; | |
| } | |
| token = scanPunctuator(); | |
| if (typeof token !== 'undefined') { | |
| return token; | |
| } | |
| ch = source[index]; | |
| if (ch === '\'' || ch === '"') { | |
| return scanStringLiteral(); | |
| } | |
| if (ch === '.' || isDecimalDigit(ch)) { | |
| return scanNumericLiteral(); | |
| } | |
| token = scanIdentifier(); | |
| if (typeof token !== 'undefined') { | |
| return token; | |
| } | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| function lex() { | |
| var token; | |
| if (buffer) { | |
| index = buffer.range[1]; | |
| lineNumber = buffer.lineNumber; | |
| lineStart = buffer.lineStart; | |
| token = buffer; | |
| buffer = null; | |
| return token; | |
| } | |
| buffer = null; | |
| return advance(); | |
| } | |
| function lookahead() { | |
| var pos, line, start; | |
| if (buffer !== null) { | |
| return buffer; | |
| } | |
| pos = index; | |
| line = lineNumber; | |
| start = lineStart; | |
| buffer = advance(); | |
| index = pos; | |
| lineNumber = line; | |
| lineStart = start; | |
| return buffer; | |
| } | |
| // Return true if there is a line terminator before the next token. | |
| function peekLineTerminator() { | |
| var pos, line, start, found; | |
| pos = index; | |
| line = lineNumber; | |
| start = lineStart; | |
| skipComment(); | |
| found = lineNumber !== line; | |
| index = pos; | |
| lineNumber = line; | |
| lineStart = start; | |
| return found; | |
| } | |
| // Throw an exception | |
| function throwError(token, messageFormat) { | |
| var error, | |
| args = Array.prototype.slice.call(arguments, 2), | |
| msg = messageFormat.replace( | |
| /%(\d)/g, | |
| function (whole, index) { | |
| return args[index] || ''; | |
| } | |
| ); | |
| if (typeof token.lineNumber === 'number') { | |
| error = new Error('Line ' + token.lineNumber + ': ' + msg); | |
| error.index = token.range[0]; | |
| error.lineNumber = token.lineNumber; | |
| error.column = token.range[0] - lineStart + 1; | |
| } else { | |
| error = new Error('Line ' + lineNumber + ': ' + msg); | |
| error.index = index; | |
| error.lineNumber = lineNumber; | |
| error.column = index - lineStart + 1; | |
| } | |
| throw error; | |
| } | |
| function throwErrorTolerant() { | |
| try { | |
| throwError.apply(null, arguments); | |
| } catch (e) { | |
| if (extra.errors) { | |
| extra.errors.push(e); | |
| } else { | |
| throw e; | |
| } | |
| } | |
| } | |
| // Throw an exception because of the token. | |
| function throwUnexpected(token) { | |
| if (token.type === Token.EOF) { | |
| throwError(token, Messages.UnexpectedEOS); | |
| } | |
| if (token.type === Token.NumericLiteral) { | |
| throwError(token, Messages.UnexpectedNumber); | |
| } | |
| if (token.type === Token.StringLiteral) { | |
| throwError(token, Messages.UnexpectedString); | |
| } | |
| if (token.type === Token.Identifier) { | |
| throwError(token, Messages.UnexpectedIdentifier); | |
| } | |
| if (token.type === Token.Keyword) { | |
| if (isFutureReservedWord(token.value)) { | |
| throwError(token, Messages.UnexpectedReserved); | |
| } else if (strict && isStrictModeReservedWord(token.value)) { | |
| throwErrorTolerant(token, Messages.StrictReservedWord); | |
| return; | |
| } | |
| throwError(token, Messages.UnexpectedToken, token.value); | |
| } | |
| // BooleanLiteral, NullLiteral, or Punctuator. | |
| throwError(token, Messages.UnexpectedToken, token.value); | |
| } | |
| // Expect the next token to match the specified punctuator. | |
| // If not, an exception will be thrown. | |
| function expect(value) { | |
| var token = lex(); | |
| if (token.type !== Token.Punctuator || token.value !== value) { | |
| throwUnexpected(token); | |
| } | |
| } | |
| // Expect the next token to match the specified keyword. | |
| // If not, an exception will be thrown. | |
| function expectKeyword(keyword) { | |
| var token = lex(); | |
| if (token.type !== Token.Keyword || token.value !== keyword) { | |
| throwUnexpected(token); | |
| } | |
| } | |
| // Return true if the next token matches the specified punctuator. | |
| function match(value) { | |
| var token = lookahead(); | |
| return token.type === Token.Punctuator && token.value === value; | |
| } | |
| // Return true if the next token matches the specified keyword | |
| function matchKeyword(keyword) { | |
| var token = lookahead(); | |
| return token.type === Token.Keyword && token.value === keyword; | |
| } | |
| // Return true if the next token is an assignment operator | |
| function matchAssign() { | |
| var token = lookahead(), | |
| op = token.value; | |
| if (token.type !== Token.Punctuator) { | |
| return false; | |
| } | |
| return op === '=' || | |
| op === '*=' || | |
| op === '/=' || | |
| op === '%=' || | |
| op === '+=' || | |
| op === '-=' || | |
| op === '<<=' || | |
| op === '>>=' || | |
| op === '>>>=' || | |
| op === '&=' || | |
| op === '^=' || | |
| op === '|='; | |
| } | |
| function consumeSemicolon() { | |
| var token, line; | |
| // Catch the very common case first. | |
| if (source[index] === ';') { | |
| lex(); | |
| return; | |
| } | |
| line = lineNumber; | |
| skipComment(); | |
| if (lineNumber !== line) { | |
| return; | |
| } | |
| if (match(';')) { | |
| lex(); | |
| return; | |
| } | |
| token = lookahead(); | |
| if (token.type !== Token.EOF && !match('}')) { | |
| throwUnexpected(token); | |
| } | |
| } | |
| // Return true if provided expression is LeftHandSideExpression | |
| function isLeftHandSide(expr) { | |
| return expr.type === Syntax.Identifier || expr.type === Syntax.MemberExpression; | |
| } | |
| // 11.1.4 Array Initialiser | |
| function parseArrayInitialiser() { | |
| var elements = []; | |
| expect('['); | |
| while (!match(']')) { | |
| if (match(',')) { | |
| lex(); | |
| elements.push(null); | |
| } else { | |
| elements.push(parseAssignmentExpression()); | |
| if (!match(']')) { | |
| expect(','); | |
| } | |
| } | |
| } | |
| expect(']'); | |
| return { | |
| type: Syntax.ArrayExpression, | |
| elements: elements | |
| }; | |
| } | |
| // 11.1.5 Object Initialiser | |
| function parsePropertyFunction(param, first) { | |
| var previousStrict, body; | |
| previousStrict = strict; | |
| body = parseFunctionSourceElements(); | |
| if (first && strict && isRestrictedWord(param[0].name)) { | |
| throwErrorTolerant(first, Messages.StrictParamName); | |
| } | |
| strict = previousStrict; | |
| return { | |
| type: Syntax.FunctionExpression, | |
| id: null, | |
| params: param, | |
| defaults: [], | |
| body: body, | |
| rest: null, | |
| generator: false, | |
| expression: false | |
| }; | |
| } | |
| function parseObjectPropertyKey() { | |
| var token = lex(); | |
| // Note: This function is called only from parseObjectProperty(), where | |
| // EOF and Punctuator tokens are already filtered out. | |
| if (token.type === Token.StringLiteral || token.type === Token.NumericLiteral) { | |
| if (strict && token.octal) { | |
| throwErrorTolerant(token, Messages.StrictOctalLiteral); | |
| } | |
| return createLiteral(token); | |
| } | |
| return { | |
| type: Syntax.Identifier, | |
| name: token.value | |
| }; | |
| } | |
| function parseObjectProperty() { | |
| var token, key, id, param; | |
| token = lookahead(); | |
| if (token.type === Token.Identifier) { | |
| id = parseObjectPropertyKey(); | |
| // Property Assignment: Getter and Setter. | |
| if (token.value === 'get' && !match(':')) { | |
| key = parseObjectPropertyKey(); | |
| expect('('); | |
| expect(')'); | |
| return { | |
| type: Syntax.Property, | |
| key: key, | |
| value: parsePropertyFunction([]), | |
| kind: 'get' | |
| }; | |
| } else if (token.value === 'set' && !match(':')) { | |
| key = parseObjectPropertyKey(); | |
| expect('('); | |
| token = lookahead(); | |
| if (token.type !== Token.Identifier) { | |
| expect(')'); | |
| throwErrorTolerant(token, Messages.UnexpectedToken, token.value); | |
| return { | |
| type: Syntax.Property, | |
| key: key, | |
| value: parsePropertyFunction([]), | |
| kind: 'set' | |
| }; | |
| } else { | |
| param = [ parseVariableIdentifier() ]; | |
| expect(')'); | |
| return { | |
| type: Syntax.Property, | |
| key: key, | |
| value: parsePropertyFunction(param, token), | |
| kind: 'set' | |
| }; | |
| } | |
| } else { | |
| expect(':'); | |
| return { | |
| type: Syntax.Property, | |
| key: id, | |
| value: parseAssignmentExpression(), | |
| kind: 'init' | |
| }; | |
| } | |
| } else if (token.type === Token.EOF || token.type === Token.Punctuator) { | |
| throwUnexpected(token); | |
| } else { | |
| key = parseObjectPropertyKey(); | |
| expect(':'); | |
| return { | |
| type: Syntax.Property, | |
| key: key, | |
| value: parseAssignmentExpression(), | |
| kind: 'init' | |
| }; | |
| } | |
| } | |
| function parseObjectInitialiser() { | |
| var properties = [], property, name, kind, map = {}, toString = String; | |
| expect('{'); | |
| while (!match('}')) { | |
| property = parseObjectProperty(); | |
| if (property.key.type === Syntax.Identifier) { | |
| name = property.key.name; | |
| } else { | |
| name = toString(property.key.value); | |
| } | |
| kind = (property.kind === 'init') ? PropertyKind.Data : (property.kind === 'get') ? PropertyKind.Get : PropertyKind.Set; | |
| if (Object.prototype.hasOwnProperty.call(map, name)) { | |
| if (map[name] === PropertyKind.Data) { | |
| if (strict && kind === PropertyKind.Data) { | |
| throwErrorTolerant({}, Messages.StrictDuplicateProperty); | |
| } else if (kind !== PropertyKind.Data) { | |
| throwErrorTolerant({}, Messages.AccessorDataProperty); | |
| } | |
| } else { | |
| if (kind === PropertyKind.Data) { | |
| throwErrorTolerant({}, Messages.AccessorDataProperty); | |
| } else if (map[name] & kind) { | |
| throwErrorTolerant({}, Messages.AccessorGetSet); | |
| } | |
| } | |
| map[name] |= kind; | |
| } else { | |
| map[name] = kind; | |
| } | |
| properties.push(property); | |
| if (!match('}')) { | |
| expect(','); | |
| } | |
| } | |
| expect('}'); | |
| return { | |
| type: Syntax.ObjectExpression, | |
| properties: properties | |
| }; | |
| } | |
| // 11.1.6 The Grouping Operator | |
| function parseGroupExpression() { | |
| var expr; | |
| expect('('); | |
| expr = parseExpression(); | |
| expect(')'); | |
| return expr; | |
| } | |
| // 11.1 Primary Expressions | |
| function parsePrimaryExpression() { | |
| var token = lookahead(), | |
| type = token.type; | |
| if (type === Token.Identifier) { | |
| return { | |
| type: Syntax.Identifier, | |
| name: lex().value | |
| }; | |
| } | |
| if (type === Token.StringLiteral || type === Token.NumericLiteral) { | |
| if (strict && token.octal) { | |
| throwErrorTolerant(token, Messages.StrictOctalLiteral); | |
| } | |
| return createLiteral(lex()); | |
| } | |
| if (type === Token.Keyword) { | |
| if (matchKeyword('this')) { | |
| lex(); | |
| return { | |
| type: Syntax.ThisExpression | |
| }; | |
| } | |
| if (matchKeyword('function')) { | |
| return parseFunctionExpression(); | |
| } | |
| } | |
| if (type === Token.BooleanLiteral) { | |
| lex(); | |
| token.value = (token.value === 'true'); | |
| return createLiteral(token); | |
| } | |
| if (type === Token.NullLiteral) { | |
| lex(); | |
| token.value = null; | |
| return createLiteral(token); | |
| } | |
| if (match('[')) { | |
| return parseArrayInitialiser(); | |
| } | |
| if (match('{')) { | |
| return parseObjectInitialiser(); | |
| } | |
| if (match('(')) { | |
| return parseGroupExpression(); | |
| } | |
| if (match('/') || match('/=')) { | |
| return createLiteral(scanRegExp()); | |
| } | |
| return throwUnexpected(lex()); | |
| } | |
| // 11.2 Left-Hand-Side Expressions | |
| function parseArguments() { | |
| var args = []; | |
| expect('('); | |
| if (!match(')')) { | |
| while (index < length) { | |
| args.push(parseAssignmentExpression()); | |
| if (match(')')) { | |
| break; | |
| } | |
| expect(','); | |
| } | |
| } | |
| expect(')'); | |
| return args; | |
| } | |
| function parseNonComputedProperty() { | |
| var token = lex(); | |
| if (!isIdentifierName(token)) { | |
| throwUnexpected(token); | |
| } | |
| return { | |
| type: Syntax.Identifier, | |
| name: token.value | |
| }; | |
| } | |
| function parseNonComputedMember() { | |
| expect('.'); | |
| return parseNonComputedProperty(); | |
| } | |
| function parseComputedMember() { | |
| var expr; | |
| expect('['); | |
| expr = parseExpression(); | |
| expect(']'); | |
| return expr; | |
| } | |
| function parseNewExpression() { | |
| var expr; | |
| expectKeyword('new'); | |
| expr = { | |
| type: Syntax.NewExpression, | |
| callee: parseLeftHandSideExpression(), | |
| 'arguments': [] | |
| }; | |
| if (match('(')) { | |
| expr['arguments'] = parseArguments(); | |
| } | |
| return expr; | |
| } | |
| function parseLeftHandSideExpressionAllowCall() { | |
| var expr; | |
| expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression(); | |
| while (match('.') || match('[') || match('(')) { | |
| if (match('(')) { | |
| expr = { | |
| type: Syntax.CallExpression, | |
| callee: expr, | |
| 'arguments': parseArguments() | |
| }; | |
| } else if (match('[')) { | |
| expr = { | |
| type: Syntax.MemberExpression, | |
| computed: true, | |
| object: expr, | |
| property: parseComputedMember() | |
| }; | |
| } else { | |
| expr = { | |
| type: Syntax.MemberExpression, | |
| computed: false, | |
| object: expr, | |
| property: parseNonComputedMember() | |
| }; | |
| } | |
| } | |
| return expr; | |
| } | |
| function parseLeftHandSideExpression() { | |
| var expr; | |
| expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression(); | |
| while (match('.') || match('[')) { | |
| if (match('[')) { | |
| expr = { | |
| type: Syntax.MemberExpression, | |
| computed: true, | |
| object: expr, | |
| property: parseComputedMember() | |
| }; | |
| } else { | |
| expr = { | |
| type: Syntax.MemberExpression, | |
| computed: false, | |
| object: expr, | |
| property: parseNonComputedMember() | |
| }; | |
| } | |
| } | |
| return expr; | |
| } | |
| // 11.3 Postfix Expressions | |
| function parsePostfixExpression() { | |
| var expr = parseLeftHandSideExpressionAllowCall(), token; | |
| token = lookahead(); | |
| if (token.type !== Token.Punctuator) { | |
| return expr; | |
| } | |
| if ((match('++') || match('--')) && !peekLineTerminator()) { | |
| // 11.3.1, 11.3.2 | |
| if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) { | |
| throwErrorTolerant({}, Messages.StrictLHSPostfix); | |
| } | |
| if (!isLeftHandSide(expr)) { | |
| throwErrorTolerant({}, Messages.InvalidLHSInAssignment); | |
| } | |
| expr = { | |
| type: Syntax.UpdateExpression, | |
| operator: lex().value, | |
| argument: expr, | |
| prefix: false | |
| }; | |
| } | |
| return expr; | |
| } | |
| // 11.4 Unary Operators | |
| function parseUnaryExpression() { | |
| var token, expr; | |
| token = lookahead(); | |
| if (token.type !== Token.Punctuator && token.type !== Token.Keyword) { | |
| return parsePostfixExpression(); | |
| } | |
| if (match('++') || match('--')) { | |
| token = lex(); | |
| expr = parseUnaryExpression(); | |
| // 11.4.4, 11.4.5 | |
| if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) { | |
| throwErrorTolerant({}, Messages.StrictLHSPrefix); | |
| } | |
| if (!isLeftHandSide(expr)) { | |
| throwErrorTolerant({}, Messages.InvalidLHSInAssignment); | |
| } | |
| expr = { | |
| type: Syntax.UpdateExpression, | |
| operator: token.value, | |
| argument: expr, | |
| prefix: true | |
| }; | |
| return expr; | |
| } | |
| if (match('+') || match('-') || match('~') || match('!')) { | |
| expr = { | |
| type: Syntax.UnaryExpression, | |
| operator: lex().value, | |
| argument: parseUnaryExpression(), | |
| prefix: true | |
| }; | |
| return expr; | |
| } | |
| if (matchKeyword('delete') || matchKeyword('void') || matchKeyword('typeof')) { | |
| expr = { | |
| type: Syntax.UnaryExpression, | |
| operator: lex().value, | |
| argument: parseUnaryExpression(), | |
| prefix: true | |
| }; | |
| if (strict && expr.operator === 'delete' && expr.argument.type === Syntax.Identifier) { | |
| throwErrorTolerant({}, Messages.StrictDelete); | |
| } | |
| return expr; | |
| } | |
| return parsePostfixExpression(); | |
| } | |
| // 11.5 Multiplicative Operators | |
| function parseMultiplicativeExpression() { | |
| var expr = parseUnaryExpression(); | |
| while (match('*') || match('/') || match('%')) { | |
| expr = { | |
| type: Syntax.BinaryExpression, | |
| operator: lex().value, | |
| left: expr, | |
| right: parseUnaryExpression() | |
| }; | |
| } | |
| return expr; | |
| } | |
| // 11.6 Additive Operators | |
| function parseAdditiveExpression() { | |
| var expr = parseMultiplicativeExpression(); | |
| while (match('+') || match('-')) { | |
| expr = { | |
| type: Syntax.BinaryExpression, | |
| operator: lex().value, | |
| left: expr, | |
| right: parseMultiplicativeExpression() | |
| }; | |
| } | |
| return expr; | |
| } | |
| // 11.7 Bitwise Shift Operators | |
| function parseShiftExpression() { | |
| var expr = parseAdditiveExpression(); | |
| while (match('<<') || match('>>') || match('>>>')) { | |
| expr = { | |
| type: Syntax.BinaryExpression, | |
| operator: lex().value, | |
| left: expr, | |
| right: parseAdditiveExpression() | |
| }; | |
| } | |
| return expr; | |
| } | |
| // 11.8 Relational Operators | |
| function parseRelationalExpression() { | |
| var expr, previousAllowIn; | |
| previousAllowIn = state.allowIn; | |
| state.allowIn = true; | |
| expr = parseShiftExpression(); | |
| while (match('<') || match('>') || match('<=') || match('>=') || (previousAllowIn && matchKeyword('in')) || matchKeyword('instanceof')) { | |
| expr = { | |
| type: Syntax.BinaryExpression, | |
| operator: lex().value, | |
| left: expr, | |
| right: parseShiftExpression() | |
| }; | |
| } | |
| state.allowIn = previousAllowIn; | |
| return expr; | |
| } | |
| // 11.9 Equality Operators | |
| function parseEqualityExpression() { | |
| var expr = parseRelationalExpression(); | |
| while (match('==') || match('!=') || match('===') || match('!==')) { | |
| expr = { | |
| type: Syntax.BinaryExpression, | |
| operator: lex().value, | |
| left: expr, | |
| right: parseRelationalExpression() | |
| }; | |
| } | |
| return expr; | |
| } | |
| // 11.10 Binary Bitwise Operators | |
| function parseBitwiseANDExpression() { | |
| var expr = parseEqualityExpression(); | |
| while (match('&')) { | |
| lex(); | |
| expr = { | |
| type: Syntax.BinaryExpression, | |
| operator: '&', | |
| left: expr, | |
| right: parseEqualityExpression() | |
| }; | |
| } | |
| return expr; | |
| } | |
| function parseBitwiseXORExpression() { | |
| var expr = parseBitwiseANDExpression(); | |
| while (match('^')) { | |
| lex(); | |
| expr = { | |
| type: Syntax.BinaryExpression, | |
| operator: '^', | |
| left: expr, | |
| right: parseBitwiseANDExpression() | |
| }; | |
| } | |
| return expr; | |
| } | |
| function parseBitwiseORExpression() { | |
| var expr = parseBitwiseXORExpression(); | |
| while (match('|')) { | |
| lex(); | |
| expr = { | |
| type: Syntax.BinaryExpression, | |
| operator: '|', | |
| left: expr, | |
| right: parseBitwiseXORExpression() | |
| }; | |
| } | |
| return expr; | |
| } | |
| // 11.11 Binary Logical Operators | |
| function parseLogicalANDExpression() { | |
| var expr = parseBitwiseORExpression(); | |
| while (match('&&')) { | |
| lex(); | |
| expr = { | |
| type: Syntax.LogicalExpression, | |
| operator: '&&', | |
| left: expr, | |
| right: parseBitwiseORExpression() | |
| }; | |
| } | |
| return expr; | |
| } | |
| function parseLogicalORExpression() { | |
| var expr = parseLogicalANDExpression(); | |
| while (match('||')) { | |
| lex(); | |
| expr = { | |
| type: Syntax.LogicalExpression, | |
| operator: '||', | |
| left: expr, | |
| right: parseLogicalANDExpression() | |
| }; | |
| } | |
| return expr; | |
| } | |
| // 11.12 Conditional Operator | |
| function parseConditionalExpression() { | |
| var expr, previousAllowIn, consequent; | |
| expr = parseLogicalORExpression(); | |
| if (match('?')) { | |
| lex(); | |
| previousAllowIn = state.allowIn; | |
| state.allowIn = true; | |
| consequent = parseAssignmentExpression(); | |
| state.allowIn = previousAllowIn; | |
| expect(':'); | |
| expr = { | |
| type: Syntax.ConditionalExpression, | |
| test: expr, | |
| consequent: consequent, | |
| alternate: parseAssignmentExpression() | |
| }; | |
| } | |
| return expr; | |
| } | |
| // 11.13 Assignment Operators | |
| function parseAssignmentExpression() { | |
| var token, expr; | |
| token = lookahead(); | |
| expr = parseConditionalExpression(); | |
| if (matchAssign()) { | |
| // LeftHandSideExpression | |
| if (!isLeftHandSide(expr)) { | |
| throwErrorTolerant({}, Messages.InvalidLHSInAssignment); | |
| } | |
| // 11.13.1 | |
| if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) { | |
| throwErrorTolerant(token, Messages.StrictLHSAssignment); | |
| } | |
| expr = { | |
| type: Syntax.AssignmentExpression, | |
| operator: lex().value, | |
| left: expr, | |
| right: parseAssignmentExpression() | |
| }; | |
| } | |
| return expr; | |
| } | |
| // 11.14 Comma Operator | |
| function parseExpression() { | |
| var expr = parseAssignmentExpression(); | |
| if (match(',')) { | |
| expr = { | |
| type: Syntax.SequenceExpression, | |
| expressions: [ expr ] | |
| }; | |
| while (index < length) { | |
| if (!match(',')) { | |
| break; | |
| } | |
| lex(); | |
| expr.expressions.push(parseAssignmentExpression()); | |
| } | |
| } | |
| return expr; | |
| } | |
| // 12.1 Block | |
| function parseStatementList() { | |
| var list = [], | |
| statement; | |
| while (index < length) { | |
| if (match('}')) { | |
| break; | |
| } | |
| statement = parseSourceElement(); | |
| if (typeof statement === 'undefined') { | |
| break; | |
| } | |
| list.push(statement); | |
| } | |
| return list; | |
| } | |
| function parseBlock() { | |
| var block; | |
| expect('{'); | |
| block = parseStatementList(); | |
| expect('}'); | |
| return { | |
| type: Syntax.BlockStatement, | |
| body: block | |
| }; | |
| } | |
| // 12.2 Variable Statement | |
| function parseVariableIdentifier() { | |
| var token = lex(); | |
| if (token.type !== Token.Identifier) { | |
| throwUnexpected(token); | |
| } | |
| return { | |
| type: Syntax.Identifier, | |
| name: token.value | |
| }; | |
| } | |
| function parseVariableDeclaration(kind) { | |
| var id = parseVariableIdentifier(), | |
| init = null; | |
| // 12.2.1 | |
| if (strict && isRestrictedWord(id.name)) { | |
| throwErrorTolerant({}, Messages.StrictVarName); | |
| } | |
| if (kind === 'const') { | |
| expect('='); | |
| init = parseAssignmentExpression(); | |
| } else if (match('=')) { | |
| lex(); | |
| init = parseAssignmentExpression(); | |
| } | |
| return { | |
| type: Syntax.VariableDeclarator, | |
| id: id, | |
| init: init | |
| }; | |
| } | |
| function parseVariableDeclarationList(kind) { | |
| var list = []; | |
| do { | |
| list.push(parseVariableDeclaration(kind)); | |
| if (!match(',')) { | |
| break; | |
| } | |
| lex(); | |
| } while (index < length); | |
| return list; | |
| } | |
| function parseVariableStatement() { | |
| var declarations; | |
| expectKeyword('var'); | |
| declarations = parseVariableDeclarationList(); | |
| consumeSemicolon(); | |
| return { | |
| type: Syntax.VariableDeclaration, | |
| declarations: declarations, | |
| kind: 'var' | |
| }; | |
| } | |
| // kind may be `const` or `let` | |
| // Both are experimental and not in the specification yet. | |
| // see http://wiki.ecmascript.org/doku.php?id=harmony:const | |
| // and http://wiki.ecmascript.org/doku.php?id=harmony:let | |
| function parseConstLetDeclaration(kind) { | |
| var declarations; | |
| expectKeyword(kind); | |
| declarations = parseVariableDeclarationList(kind); | |
| consumeSemicolon(); | |
| return { | |
| type: Syntax.VariableDeclaration, | |
| declarations: declarations, | |
| kind: kind | |
| }; | |
| } | |
| // 12.3 Empty Statement | |
| function parseEmptyStatement() { | |
| expect(';'); | |
| return { | |
| type: Syntax.EmptyStatement | |
| }; | |
| } | |
| // 12.4 Expression Statement | |
| function parseExpressionStatement() { | |
| var expr = parseExpression(); | |
| consumeSemicolon(); | |
| return { | |
| type: Syntax.ExpressionStatement, | |
| expression: expr | |
| }; | |
| } | |
| // 12.5 If statement | |
| function parseIfStatement() { | |
| var test, consequent, alternate; | |
| expectKeyword('if'); | |
| expect('('); | |
| test = parseExpression(); | |
| expect(')'); | |
| consequent = parseStatement(); | |
| if (matchKeyword('else')) { | |
| lex(); | |
| alternate = parseStatement(); | |
| } else { | |
| alternate = null; | |
| } | |
| return { | |
| type: Syntax.IfStatement, | |
| test: test, | |
| consequent: consequent, | |
| alternate: alternate | |
| }; | |
| } | |
| // 12.6 Iteration Statements | |
| function parseDoWhileStatement() { | |
| var body, test, oldInIteration; | |
| expectKeyword('do'); | |
| oldInIteration = state.inIteration; | |
| state.inIteration = true; | |
| body = parseStatement(); | |
| state.inIteration = oldInIteration; | |
| expectKeyword('while'); | |
| expect('('); | |
| test = parseExpression(); | |
| expect(')'); | |
| if (match(';')) { | |
| lex(); | |
| } | |
| return { | |
| type: Syntax.DoWhileStatement, | |
| body: body, | |
| test: test | |
| }; | |
| } | |
| function parseWhileStatement() { | |
| var test, body, oldInIteration; | |
| expectKeyword('while'); | |
| expect('('); | |
| test = parseExpression(); | |
| expect(')'); | |
| oldInIteration = state.inIteration; | |
| state.inIteration = true; | |
| body = parseStatement(); | |
| state.inIteration = oldInIteration; | |
| return { | |
| type: Syntax.WhileStatement, | |
| test: test, | |
| body: body | |
| }; | |
| } | |
| function parseForVariableDeclaration() { | |
| var token = lex(); | |
| return { | |
| type: Syntax.VariableDeclaration, | |
| declarations: parseVariableDeclarationList(), | |
| kind: token.value | |
| }; | |
| } | |
| function parseForStatement() { | |
| var init, test, update, left, right, body, oldInIteration; | |
| init = test = update = null; | |
| expectKeyword('for'); | |
| expect('('); | |
| if (match(';')) { | |
| lex(); | |
| } else { | |
| if (matchKeyword('var') || matchKeyword('let')) { | |
| state.allowIn = false; | |
| init = parseForVariableDeclaration(); | |
| state.allowIn = true; | |
| if (init.declarations.length === 1 && matchKeyword('in')) { | |
| lex(); | |
| left = init; | |
| right = parseExpression(); | |
| init = null; | |
| } | |
| } else { | |
| state.allowIn = false; | |
| init = parseExpression(); | |
| state.allowIn = true; | |
| if (matchKeyword('in')) { | |
| // LeftHandSideExpression | |
| if (!isLeftHandSide(init)) { | |
| throwErrorTolerant({}, Messages.InvalidLHSInForIn); | |
| } | |
| lex(); | |
| left = init; | |
| right = parseExpression(); | |
| init = null; | |
| } | |
| } | |
| if (typeof left === 'undefined') { | |
| expect(';'); | |
| } | |
| } | |
| if (typeof left === 'undefined') { | |
| if (!match(';')) { | |
| test = parseExpression(); | |
| } | |
| expect(';'); | |
| if (!match(')')) { | |
| update = parseExpression(); | |
| } | |
| } | |
| expect(')'); | |
| oldInIteration = state.inIteration; | |
| state.inIteration = true; | |
| body = parseStatement(); | |
| state.inIteration = oldInIteration; | |
| if (typeof left === 'undefined') { | |
| return { | |
| type: Syntax.ForStatement, | |
| init: init, | |
| test: test, | |
| update: update, | |
| body: body | |
| }; | |
| } | |
| return { | |
| type: Syntax.ForInStatement, | |
| left: left, | |
| right: right, | |
| body: body, | |
| each: false | |
| }; | |
| } | |
| // 12.7 The continue statement | |
| function parseContinueStatement() { | |
| var token, label = null; | |
| expectKeyword('continue'); | |
| // Optimize the most common form: 'continue;'. | |
| if (source[index] === ';') { | |
| lex(); | |
| if (!state.inIteration) { | |
| throwError({}, Messages.IllegalContinue); | |
| } | |
| return { | |
| type: Syntax.ContinueStatement, | |
| label: null | |
| }; | |
| } | |
| if (peekLineTerminator()) { | |
| if (!state.inIteration) { | |
| throwError({}, Messages.IllegalContinue); | |
| } | |
| return { | |
| type: Syntax.ContinueStatement, | |
| label: null | |
| }; | |
| } | |
| token = lookahead(); | |
| if (token.type === Token.Identifier) { | |
| label = parseVariableIdentifier(); | |
| if (!Object.prototype.hasOwnProperty.call(state.labelSet, label.name)) { | |
| throwError({}, Messages.UnknownLabel, label.name); | |
| } | |
| } | |
| consumeSemicolon(); | |
| if (label === null && !state.inIteration) { | |
| throwError({}, Messages.IllegalContinue); | |
| } | |
| return { | |
| type: Syntax.ContinueStatement, | |
| label: label | |
| }; | |
| } | |
| // 12.8 The break statement | |
| function parseBreakStatement() { | |
| var token, label = null; | |
| expectKeyword('break'); | |
| // Optimize the most common form: 'break;'. | |
| if (source[index] === ';') { | |
| lex(); | |
| if (!(state.inIteration || state.inSwitch)) { | |
| throwError({}, Messages.IllegalBreak); | |
| } | |
| return { | |
| type: Syntax.BreakStatement, | |
| label: null | |
| }; | |
| } | |
| if (peekLineTerminator()) { | |
| if (!(state.inIteration || state.inSwitch)) { | |
| throwError({}, Messages.IllegalBreak); | |
| } | |
| return { | |
| type: Syntax.BreakStatement, | |
| label: null | |
| }; | |
| } | |
| token = lookahead(); | |
| if (token.type === Token.Identifier) { | |
| label = parseVariableIdentifier(); | |
| if (!Object.prototype.hasOwnProperty.call(state.labelSet, label.name)) { | |
| throwError({}, Messages.UnknownLabel, label.name); | |
| } | |
| } | |
| consumeSemicolon(); | |
| if (label === null && !(state.inIteration || state.inSwitch)) { | |
| throwError({}, Messages.IllegalBreak); | |
| } | |
| return { | |
| type: Syntax.BreakStatement, | |
| label: label | |
| }; | |
| } | |
| // 12.9 The return statement | |
| function parseReturnStatement() { | |
| var token, argument = null; | |
| expectKeyword('return'); | |
| if (!state.inFunctionBody) { | |
| throwErrorTolerant({}, Messages.IllegalReturn); | |
| } | |
| // 'return' followed by a space and an identifier is very common. | |
| if (source[index] === ' ') { | |
| if (isIdentifierStart(source[index + 1])) { | |
| argument = parseExpression(); | |
| consumeSemicolon(); | |
| return { | |
| type: Syntax.ReturnStatement, | |
| argument: argument | |
| }; | |
| } | |
| } | |
| if (peekLineTerminator()) { | |
| return { | |
| type: Syntax.ReturnStatement, | |
| argument: null | |
| }; | |
| } | |
| if (!match(';')) { | |
| token = lookahead(); | |
| if (!match('}') && token.type !== Token.EOF) { | |
| argument = parseExpression(); | |
| } | |
| } | |
| consumeSemicolon(); | |
| return { | |
| type: Syntax.ReturnStatement, | |
| argument: argument | |
| }; | |
| } | |
| // 12.10 The with statement | |
| function parseWithStatement() { | |
| var object, body; | |
| if (strict) { | |
| throwErrorTolerant({}, Messages.StrictModeWith); | |
| } | |
| expectKeyword('with'); | |
| expect('('); | |
| object = parseExpression(); | |
| expect(')'); | |
| body = parseStatement(); | |
| return { | |
| type: Syntax.WithStatement, | |
| object: object, | |
| body: body | |
| }; | |
| } | |
| // 12.10 The swith statement | |
| function parseSwitchCase() { | |
| var test, | |
| consequent = [], | |
| statement; | |
| if (matchKeyword('default')) { | |
| lex(); | |
| test = null; | |
| } else { | |
| expectKeyword('case'); | |
| test = parseExpression(); | |
| } | |
| expect(':'); | |
| while (index < length) { | |
| if (match('}') || matchKeyword('default') || matchKeyword('case')) { | |
| break; | |
| } | |
| statement = parseStatement(); | |
| if (typeof statement === 'undefined') { | |
| break; | |
| } | |
| consequent.push(statement); | |
| } | |
| return { | |
| type: Syntax.SwitchCase, | |
| test: test, | |
| consequent: consequent | |
| }; | |
| } | |
| function parseSwitchStatement() { | |
| var discriminant, cases, clause, oldInSwitch, defaultFound; | |
| expectKeyword('switch'); | |
| expect('('); | |
| discriminant = parseExpression(); | |
| expect(')'); | |
| expect('{'); | |
| cases = []; | |
| if (match('}')) { | |
| lex(); | |
| return { | |
| type: Syntax.SwitchStatement, | |
| discriminant: discriminant, | |
| cases: cases | |
| }; | |
| } | |
| oldInSwitch = state.inSwitch; | |
| state.inSwitch = true; | |
| defaultFound = false; | |
| while (index < length) { | |
| if (match('}')) { | |
| break; | |
| } | |
| clause = parseSwitchCase(); | |
| if (clause.test === null) { | |
| if (defaultFound) { | |
| throwError({}, Messages.MultipleDefaultsInSwitch); | |
| } | |
| defaultFound = true; | |
| } | |
| cases.push(clause); | |
| } | |
| state.inSwitch = oldInSwitch; | |
| expect('}'); | |
| return { | |
| type: Syntax.SwitchStatement, | |
| discriminant: discriminant, | |
| cases: cases | |
| }; | |
| } | |
| // 12.13 The throw statement | |
| function parseThrowStatement() { | |
| var argument; | |
| expectKeyword('throw'); | |
| if (peekLineTerminator()) { | |
| throwError({}, Messages.NewlineAfterThrow); | |
| } | |
| argument = parseExpression(); | |
| consumeSemicolon(); | |
| return { | |
| type: Syntax.ThrowStatement, | |
| argument: argument | |
| }; | |
| } | |
| // 12.14 The try statement | |
| function parseCatchClause() { | |
| var param; | |
| expectKeyword('catch'); | |
| expect('('); | |
| if (match(')')) { | |
| throwUnexpected(lookahead()); | |
| } | |
| param = parseVariableIdentifier(); | |
| // 12.14.1 | |
| if (strict && isRestrictedWord(param.name)) { | |
| throwErrorTolerant({}, Messages.StrictCatchVariable); | |
| } | |
| expect(')'); | |
| return { | |
| type: Syntax.CatchClause, | |
| param: param, | |
| body: parseBlock() | |
| }; | |
| } | |
| function parseTryStatement() { | |
| var block, handlers = [], finalizer = null; | |
| expectKeyword('try'); | |
| block = parseBlock(); | |
| if (matchKeyword('catch')) { | |
| handlers.push(parseCatchClause()); | |
| } | |
| if (matchKeyword('finally')) { | |
| lex(); | |
| finalizer = parseBlock(); | |
| } | |
| if (handlers.length === 0 && !finalizer) { | |
| throwError({}, Messages.NoCatchOrFinally); | |
| } | |
| return { | |
| type: Syntax.TryStatement, | |
| block: block, | |
| guardedHandlers: [], | |
| handlers: handlers, | |
| finalizer: finalizer | |
| }; | |
| } | |
| // 12.15 The debugger statement | |
| function parseDebuggerStatement() { | |
| expectKeyword('debugger'); | |
| consumeSemicolon(); | |
| return { | |
| type: Syntax.DebuggerStatement | |
| }; | |
| } | |
| // 12 Statements | |
| function parseStatement() { | |
| var token = lookahead(), | |
| expr, | |
| labeledBody; | |
| if (token.type === Token.EOF) { | |
| throwUnexpected(token); | |
| } | |
| if (token.type === Token.Punctuator) { | |
| switch (token.value) { | |
| case ';': | |
| return parseEmptyStatement(); | |
| case '{': | |
| return parseBlock(); | |
| case '(': | |
| return parseExpressionStatement(); | |
| default: | |
| break; | |
| } | |
| } | |
| if (token.type === Token.Keyword) { | |
| switch (token.value) { | |
| case 'break': | |
| return parseBreakStatement(); | |
| case 'continue': | |
| return parseContinueStatement(); | |
| case 'debugger': | |
| return parseDebuggerStatement(); | |
| case 'do': | |
| return parseDoWhileStatement(); | |
| case 'for': | |
| return parseForStatement(); | |
| case 'function': | |
| return parseFunctionDeclaration(); | |
| case 'if': | |
| return parseIfStatement(); | |
| case 'return': | |
| return parseReturnStatement(); | |
| case 'switch': | |
| return parseSwitchStatement(); | |
| case 'throw': | |
| return parseThrowStatement(); | |
| case 'try': | |
| return parseTryStatement(); | |
| case 'var': | |
| return parseVariableStatement(); | |
| case 'while': | |
| return parseWhileStatement(); | |
| case 'with': | |
| return parseWithStatement(); | |
| default: | |
| break; | |
| } | |
| } | |
| expr = parseExpression(); | |
| // 12.12 Labelled Statements | |
| if ((expr.type === Syntax.Identifier) && match(':')) { | |
| lex(); | |
| if (Object.prototype.hasOwnProperty.call(state.labelSet, expr.name)) { | |
| throwError({}, Messages.Redeclaration, 'Label', expr.name); | |
| } | |
| state.labelSet[expr.name] = true; | |
| labeledBody = parseStatement(); | |
| delete state.labelSet[expr.name]; | |
| return { | |
| type: Syntax.LabeledStatement, | |
| label: expr, | |
| body: labeledBody | |
| }; | |
| } | |
| consumeSemicolon(); | |
| return { | |
| type: Syntax.ExpressionStatement, | |
| expression: expr | |
| }; | |
| } | |
| // 13 Function Definition | |
| function parseFunctionSourceElements() { | |
| var sourceElement, sourceElements = [], token, directive, firstRestricted, | |
| oldLabelSet, oldInIteration, oldInSwitch, oldInFunctionBody; | |
| expect('{'); | |
| while (index < length) { | |
| token = lookahead(); | |
| if (token.type !== Token.StringLiteral) { | |
| break; | |
| } | |
| sourceElement = parseSourceElement(); | |
| sourceElements.push(sourceElement); | |
| if (sourceElement.expression.type !== Syntax.Literal) { | |
| // this is not directive | |
| break; | |
| } | |
| directive = sliceSource(token.range[0] + 1, token.range[1] - 1); | |
| if (directive === 'use strict') { | |
| strict = true; | |
| if (firstRestricted) { | |
| throwErrorTolerant(firstRestricted, Messages.StrictOctalLiteral); | |
| } | |
| } else { | |
| if (!firstRestricted && token.octal) { | |
| firstRestricted = token; | |
| } | |
| } | |
| } | |
| oldLabelSet = state.labelSet; | |
| oldInIteration = state.inIteration; | |
| oldInSwitch = state.inSwitch; | |
| oldInFunctionBody = state.inFunctionBody; | |
| state.labelSet = {}; | |
| state.inIteration = false; | |
| state.inSwitch = false; | |
| state.inFunctionBody = true; | |
| while (index < length) { | |
| if (match('}')) { | |
| break; | |
| } | |
| sourceElement = parseSourceElement(); | |
| if (typeof sourceElement === 'undefined') { | |
| break; | |
| } | |
| sourceElements.push(sourceElement); | |
| } | |
| expect('}'); | |
| state.labelSet = oldLabelSet; | |
| state.inIteration = oldInIteration; | |
| state.inSwitch = oldInSwitch; | |
| state.inFunctionBody = oldInFunctionBody; | |
| return { | |
| type: Syntax.BlockStatement, | |
| body: sourceElements | |
| }; | |
| } | |
| function parseFunctionDeclaration() { | |
| var id, param, params = [], body, token, stricted, firstRestricted, message, previousStrict, paramSet; | |
| expectKeyword('function'); | |
| token = lookahead(); | |
| id = parseVariableIdentifier(); | |
| if (strict) { | |
| if (isRestrictedWord(token.value)) { | |
| throwErrorTolerant(token, Messages.StrictFunctionName); | |
| } | |
| } else { | |
| if (isRestrictedWord(token.value)) { | |
| firstRestricted = token; | |
| message = Messages.StrictFunctionName; | |
| } else if (isStrictModeReservedWord(token.value)) { | |
| firstRestricted = token; | |
| message = Messages.StrictReservedWord; | |
| } | |
| } | |
| expect('('); | |
| if (!match(')')) { | |
| paramSet = {}; | |
| while (index < length) { | |
| token = lookahead(); | |
| param = parseVariableIdentifier(); | |
| if (strict) { | |
| if (isRestrictedWord(token.value)) { | |
| stricted = token; | |
| message = Messages.StrictParamName; | |
| } | |
| if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) { | |
| stricted = token; | |
| message = Messages.StrictParamDupe; | |
| } | |
| } else if (!firstRestricted) { | |
| if (isRestrictedWord(token.value)) { | |
| firstRestricted = token; | |
| message = Messages.StrictParamName; | |
| } else if (isStrictModeReservedWord(token.value)) { | |
| firstRestricted = token; | |
| message = Messages.StrictReservedWord; | |
| } else if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) { | |
| firstRestricted = token; | |
| message = Messages.StrictParamDupe; | |
| } | |
| } | |
| params.push(param); | |
| paramSet[param.name] = true; | |
| if (match(')')) { | |
| break; | |
| } | |
| expect(','); | |
| } | |
| } | |
| expect(')'); | |
| previousStrict = strict; | |
| body = parseFunctionSourceElements(); | |
| if (strict && firstRestricted) { | |
| throwError(firstRestricted, message); | |
| } | |
| if (strict && stricted) { | |
| throwErrorTolerant(stricted, message); | |
| } | |
| strict = previousStrict; | |
| return { | |
| type: Syntax.FunctionDeclaration, | |
| id: id, | |
| params: params, | |
| defaults: [], | |
| body: body, | |
| rest: null, | |
| generator: false, | |
| expression: false | |
| }; | |
| } | |
| function parseFunctionExpression() { | |
| var token, id = null, stricted, firstRestricted, message, param, params = [], body, previousStrict, paramSet; | |
| expectKeyword('function'); | |
| if (!match('(')) { | |
| token = lookahead(); | |
| id = parseVariableIdentifier(); | |
| if (strict) { | |
| if (isRestrictedWord(token.value)) { | |
| throwErrorTolerant(token, Messages.StrictFunctionName); | |
| } | |
| } else { | |
| if (isRestrictedWord(token.value)) { | |
| firstRestricted = token; | |
| message = Messages.StrictFunctionName; | |
| } else if (isStrictModeReservedWord(token.value)) { | |
| firstRestricted = token; | |
| message = Messages.StrictReservedWord; | |
| } | |
| } | |
| } | |
| expect('('); | |
| if (!match(')')) { | |
| paramSet = {}; | |
| while (index < length) { | |
| token = lookahead(); | |
| param = parseVariableIdentifier(); | |
| if (strict) { | |
| if (isRestrictedWord(token.value)) { | |
| stricted = token; | |
| message = Messages.StrictParamName; | |
| } | |
| if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) { | |
| stricted = token; | |
| message = Messages.StrictParamDupe; | |
| } | |
| } else if (!firstRestricted) { | |
| if (isRestrictedWord(token.value)) { | |
| firstRestricted = token; | |
| message = Messages.StrictParamName; | |
| } else if (isStrictModeReservedWord(token.value)) { | |
| firstRestricted = token; | |
| message = Messages.StrictReservedWord; | |
| } else if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) { | |
| firstRestricted = token; | |
| message = Messages.StrictParamDupe; | |
| } | |
| } | |
| params.push(param); | |
| paramSet[param.name] = true; | |
| if (match(')')) { | |
| break; | |
| } | |
| expect(','); | |
| } | |
| } | |
| expect(')'); | |
| previousStrict = strict; | |
| body = parseFunctionSourceElements(); | |
| if (strict && firstRestricted) { | |
| throwError(firstRestricted, message); | |
| } | |
| if (strict && stricted) { | |
| throwErrorTolerant(stricted, message); | |
| } | |
| strict = previousStrict; | |
| return { | |
| type: Syntax.FunctionExpression, | |
| id: id, | |
| params: params, | |
| defaults: [], | |
| body: body, | |
| rest: null, | |
| generator: false, | |
| expression: false | |
| }; | |
| } | |
| // 14 Program | |
| function parseSourceElement() { | |
| var token = lookahead(); | |
| if (token.type === Token.Keyword) { | |
| switch (token.value) { | |
| case 'const': | |
| case 'let': | |
| return parseConstLetDeclaration(token.value); | |
| case 'function': | |
| return parseFunctionDeclaration(); | |
| default: | |
| return parseStatement(); | |
| } | |
| } | |
| if (token.type !== Token.EOF) { | |
| return parseStatement(); | |
| } | |
| } | |
| function parseSourceElements() { | |
| var sourceElement, sourceElements = [], token, directive, firstRestricted; | |
| while (index < length) { | |
| token = lookahead(); | |
| if (token.type !== Token.StringLiteral) { | |
| break; | |
| } | |
| sourceElement = parseSourceElement(); | |
| sourceElements.push(sourceElement); | |
| if (sourceElement.expression.type !== Syntax.Literal) { | |
| // this is not directive | |
| break; | |
| } | |
| directive = sliceSource(token.range[0] + 1, token.range[1] - 1); | |
| if (directive === 'use strict') { | |
| strict = true; | |
| if (firstRestricted) { | |
| throwErrorTolerant(firstRestricted, Messages.StrictOctalLiteral); | |
| } | |
| } else { | |
| if (!firstRestricted && token.octal) { | |
| firstRestricted = token; | |
| } | |
| } | |
| } | |
| while (index < length) { | |
| sourceElement = parseSourceElement(); | |
| if (typeof sourceElement === 'undefined') { | |
| break; | |
| } | |
| sourceElements.push(sourceElement); | |
| } | |
| return sourceElements; | |
| } | |
| function parseProgram() { | |
| var program; | |
| strict = false; | |
| program = { | |
| type: Syntax.Program, | |
| body: parseSourceElements() | |
| }; | |
| return program; | |
| } | |
| // The following functions are needed only when the option to preserve | |
| // the comments is active. | |
| function addComment(type, value, start, end, loc) { | |
| assert(typeof start === 'number', 'Comment must have valid position'); | |
| // Because the way the actual token is scanned, often the comments | |
| // (if any) are skipped twice during the lexical analysis. | |
| // Thus, we need to skip adding a comment if the comment array already | |
| // handled it. | |
| if (extra.comments.length > 0) { | |
| if (extra.comments[extra.comments.length - 1].range[1] > start) { | |
| return; | |
| } | |
| } | |
| extra.comments.push({ | |
| type: type, | |
| value: value, | |
| range: [start, end], | |
| loc: loc | |
| }); | |
| } | |
| function scanComment() { | |
| var comment, ch, loc, start, blockComment, lineComment; | |
| comment = ''; | |
| blockComment = false; | |
| lineComment = false; | |
| while (index < length) { | |
| ch = source[index]; | |
| if (lineComment) { | |
| ch = source[index++]; | |
| if (isLineTerminator(ch)) { | |
| loc.end = { | |
| line: lineNumber, | |
| column: index - lineStart - 1 | |
| }; | |
| lineComment = false; | |
| addComment('Line', comment, start, index - 1, loc); | |
| if (ch === '\r' && source[index] === '\n') { | |
| ++index; | |
| } | |
| ++lineNumber; | |
| lineStart = index; | |
| comment = ''; | |
| } else if (index >= length) { | |
| lineComment = false; | |
| comment += ch; | |
| loc.end = { | |
| line: lineNumber, | |
| column: length - lineStart | |
| }; | |
| addComment('Line', comment, start, length, loc); | |
| } else { | |
| comment += ch; | |
| } | |
| } else if (blockComment) { | |
| if (isLineTerminator(ch)) { | |
| if (ch === '\r' && source[index + 1] === '\n') { | |
| ++index; | |
| comment += '\r\n'; | |
| } else { | |
| comment += ch; | |
| } | |
| ++lineNumber; | |
| ++index; | |
| lineStart = index; | |
| if (index >= length) { | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| } else { | |
| ch = source[index++]; | |
| if (index >= length) { | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| comment += ch; | |
| if (ch === '*') { | |
| ch = source[index]; | |
| if (ch === '/') { | |
| comment = comment.substr(0, comment.length - 1); | |
| blockComment = false; | |
| ++index; | |
| loc.end = { | |
| line: lineNumber, | |
| column: index - lineStart | |
| }; | |
| addComment('Block', comment, start, index, loc); | |
| comment = ''; | |
| } | |
| } | |
| } | |
| } else if (ch === '/') { | |
| ch = source[index + 1]; | |
| if (ch === '/') { | |
| loc = { | |
| start: { | |
| line: lineNumber, | |
| column: index - lineStart | |
| } | |
| }; | |
| start = index; | |
| index += 2; | |
| lineComment = true; | |
| if (index >= length) { | |
| loc.end = { | |
| line: lineNumber, | |
| column: index - lineStart | |
| }; | |
| lineComment = false; | |
| addComment('Line', comment, start, index, loc); | |
| } | |
| } else if (ch === '*') { | |
| start = index; | |
| index += 2; | |
| blockComment = true; | |
| loc = { | |
| start: { | |
| line: lineNumber, | |
| column: index - lineStart - 2 | |
| } | |
| }; | |
| if (index >= length) { | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| } else { | |
| break; | |
| } | |
| } else if (isWhiteSpace(ch)) { | |
| ++index; | |
| } else if (isLineTerminator(ch)) { | |
| ++index; | |
| if (ch === '\r' && source[index] === '\n') { | |
| ++index; | |
| } | |
| ++lineNumber; | |
| lineStart = index; | |
| } else { | |
| break; | |
| } | |
| } | |
| } | |
| function filterCommentLocation() { | |
| var i, entry, comment, comments = []; | |
| for (i = 0; i < extra.comments.length; ++i) { | |
| entry = extra.comments[i]; | |
| comment = { | |
| type: entry.type, | |
| value: entry.value | |
| }; | |
| if (extra.range) { | |
| comment.range = entry.range; | |
| } | |
| if (extra.loc) { | |
| comment.loc = entry.loc; | |
| } | |
| comments.push(comment); | |
| } | |
| extra.comments = comments; | |
| } | |
| function collectToken() { | |
| var start, loc, token, range, value; | |
| skipComment(); | |
| start = index; | |
| loc = { | |
| start: { | |
| line: lineNumber, | |
| column: index - lineStart | |
| } | |
| }; | |
| token = extra.advance(); | |
| loc.end = { | |
| line: lineNumber, | |
| column: index - lineStart | |
| }; | |
| if (token.type !== Token.EOF) { | |
| range = [token.range[0], token.range[1]]; | |
| value = sliceSource(token.range[0], token.range[1]); | |
| extra.tokens.push({ | |
| type: TokenName[token.type], | |
| value: value, | |
| range: range, | |
| loc: loc | |
| }); | |
| } | |
| return token; | |
| } | |
| function collectRegex() { | |
| var pos, loc, regex, token; | |
| skipComment(); | |
| pos = index; | |
| loc = { | |
| start: { | |
| line: lineNumber, | |
| column: index - lineStart | |
| } | |
| }; | |
| regex = extra.scanRegExp(); | |
| loc.end = { | |
| line: lineNumber, | |
| column: index - lineStart | |
| }; | |
| // Pop the previous token, which is likely '/' or '/=' | |
| if (extra.tokens.length > 0) { | |
| token = extra.tokens[extra.tokens.length - 1]; | |
| if (token.range[0] === pos && token.type === 'Punctuator') { | |
| if (token.value === '/' || token.value === '/=') { | |
| extra.tokens.pop(); | |
| } | |
| } | |
| } | |
| extra.tokens.push({ | |
| type: 'RegularExpression', | |
| value: regex.literal, | |
| range: [pos, index], | |
| loc: loc | |
| }); | |
| return regex; | |
| } | |
| function filterTokenLocation() { | |
| var i, entry, token, tokens = []; | |
| for (i = 0; i < extra.tokens.length; ++i) { | |
| entry = extra.tokens[i]; | |
| token = { | |
| type: entry.type, | |
| value: entry.value | |
| }; | |
| if (extra.range) { | |
| token.range = entry.range; | |
| } | |
| if (extra.loc) { | |
| token.loc = entry.loc; | |
| } | |
| tokens.push(token); | |
| } | |
| extra.tokens = tokens; | |
| } | |
| function createLiteral(token) { | |
| return { | |
| type: Syntax.Literal, | |
| value: token.value | |
| }; | |
| } | |
| function createRawLiteral(token) { | |
| return { | |
| type: Syntax.Literal, | |
| value: token.value, | |
| raw: sliceSource(token.range[0], token.range[1]) | |
| }; | |
| } | |
| function createLocationMarker() { | |
| var marker = {}; | |
| marker.range = [index, index]; | |
| marker.loc = { | |
| start: { | |
| line: lineNumber, | |
| column: index - lineStart | |
| }, | |
| end: { | |
| line: lineNumber, | |
| column: index - lineStart | |
| } | |
| }; | |
| marker.end = function () { | |
| this.range[1] = index; | |
| this.loc.end.line = lineNumber; | |
| this.loc.end.column = index - lineStart; | |
| }; | |
| marker.applyGroup = function (node) { | |
| if (extra.range) { | |
| node.groupRange = [this.range[0], this.range[1]]; | |
| } | |
| if (extra.loc) { | |
| node.groupLoc = { | |
| start: { | |
| line: this.loc.start.line, | |
| column: this.loc.start.column | |
| }, | |
| end: { | |
| line: this.loc.end.line, | |
| column: this.loc.end.column | |
| } | |
| }; | |
| } | |
| }; | |
| marker.apply = function (node) { | |
| if (extra.range) { | |
| node.range = [this.range[0], this.range[1]]; | |
| } | |
| if (extra.loc) { | |
| node.loc = { | |
| start: { | |
| line: this.loc.start.line, | |
| column: this.loc.start.column | |
| }, | |
| end: { | |
| line: this.loc.end.line, | |
| column: this.loc.end.column | |
| } | |
| }; | |
| } | |
| }; | |
| return marker; | |
| } | |
| function trackGroupExpression() { | |
| var marker, expr; | |
| skipComment(); | |
| marker = createLocationMarker(); | |
| expect('('); | |
| expr = parseExpression(); | |
| expect(')'); | |
| marker.end(); | |
| marker.applyGroup(expr); | |
| return expr; | |
| } | |
| function trackLeftHandSideExpression() { | |
| var marker, expr; | |
| skipComment(); | |
| marker = createLocationMarker(); | |
| expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression(); | |
| while (match('.') || match('[')) { | |
| if (match('[')) { | |
| expr = { | |
| type: Syntax.MemberExpression, | |
| computed: true, | |
| object: expr, | |
| property: parseComputedMember() | |
| }; | |
| marker.end(); | |
| marker.apply(expr); | |
| } else { | |
| expr = { | |
| type: Syntax.MemberExpression, | |
| computed: false, | |
| object: expr, | |
| property: parseNonComputedMember() | |
| }; | |
| marker.end(); | |
| marker.apply(expr); | |
| } | |
| } | |
| return expr; | |
| } | |
| function trackLeftHandSideExpressionAllowCall() { | |
| var marker, expr; | |
| skipComment(); | |
| marker = createLocationMarker(); | |
| expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression(); | |
| while (match('.') || match('[') || match('(')) { | |
| if (match('(')) { | |
| expr = { | |
| type: Syntax.CallExpression, | |
| callee: expr, | |
| 'arguments': parseArguments() | |
| }; | |
| marker.end(); | |
| marker.apply(expr); | |
| } else if (match('[')) { | |
| expr = { | |
| type: Syntax.MemberExpression, | |
| computed: true, | |
| object: expr, | |
| property: parseComputedMember() | |
| }; | |
| marker.end(); | |
| marker.apply(expr); | |
| } else { | |
| expr = { | |
| type: Syntax.MemberExpression, | |
| computed: false, | |
| object: expr, | |
| property: parseNonComputedMember() | |
| }; | |
| marker.end(); | |
| marker.apply(expr); | |
| } | |
| } | |
| return expr; | |
| } | |
| function filterGroup(node) { | |
| var n, i, entry; | |
| n = (Object.prototype.toString.apply(node) === '[object Array]') ? [] : {}; | |
| for (i in node) { | |
| if (node.hasOwnProperty(i) && i !== 'groupRange' && i !== 'groupLoc') { | |
| entry = node[i]; | |
| if (entry === null || typeof entry !== 'object' || entry instanceof RegExp) { | |
| n[i] = entry; | |
| } else { | |
| n[i] = filterGroup(entry); | |
| } | |
| } | |
| } | |
| return n; | |
| } | |
| function wrapTrackingFunction(range, loc) { | |
| return function (parseFunction) { | |
| function isBinary(node) { | |
| return node.type === Syntax.LogicalExpression || | |
| node.type === Syntax.BinaryExpression; | |
| } | |
| function visit(node) { | |
| var start, end; | |
| if (isBinary(node.left)) { | |
| visit(node.left); | |
| } | |
| if (isBinary(node.right)) { | |
| visit(node.right); | |
| } | |
| if (range) { | |
| if (node.left.groupRange || node.right.groupRange) { | |
| start = node.left.groupRange ? node.left.groupRange[0] : node.left.range[0]; | |
| end = node.right.groupRange ? node.right.groupRange[1] : node.right.range[1]; | |
| node.range = [start, end]; | |
| } else if (typeof node.range === 'undefined') { | |
| start = node.left.range[0]; | |
| end = node.right.range[1]; | |
| node.range = [start, end]; | |
| } | |
| } | |
| if (loc) { | |
| if (node.left.groupLoc || node.right.groupLoc) { | |
| start = node.left.groupLoc ? node.left.groupLoc.start : node.left.loc.start; | |
| end = node.right.groupLoc ? node.right.groupLoc.end : node.right.loc.end; | |
| node.loc = { | |
| start: start, | |
| end: end | |
| }; | |
| } else if (typeof node.loc === 'undefined') { | |
| node.loc = { | |
| start: node.left.loc.start, | |
| end: node.right.loc.end | |
| }; | |
| } | |
| } | |
| } | |
| return function () { | |
| var marker, node; | |
| skipComment(); | |
| marker = createLocationMarker(); | |
| node = parseFunction.apply(null, arguments); | |
| marker.end(); | |
| if (range && typeof node.range === 'undefined') { | |
| marker.apply(node); | |
| } | |
| if (loc && typeof node.loc === 'undefined') { | |
| marker.apply(node); | |
| } | |
| if (isBinary(node)) { | |
| visit(node); | |
| } | |
| return node; | |
| }; | |
| }; | |
| } | |
| function patch() { | |
| var wrapTracking; | |
| if (extra.comments) { | |
| extra.skipComment = skipComment; | |
| skipComment = scanComment; | |
| } | |
| if (extra.raw) { | |
| extra.createLiteral = createLiteral; | |
| createLiteral = createRawLiteral; | |
| } | |
| if (extra.range || extra.loc) { | |
| extra.parseGroupExpression = parseGroupExpression; | |
| extra.parseLeftHandSideExpression = parseLeftHandSideExpression; | |
| extra.parseLeftHandSideExpressionAllowCall = parseLeftHandSideExpressionAllowCall; | |
| parseGroupExpression = trackGroupExpression; | |
| parseLeftHandSideExpression = trackLeftHandSideExpression; | |
| parseLeftHandSideExpressionAllowCall = trackLeftHandSideExpressionAllowCall; | |
| wrapTracking = wrapTrackingFunction(extra.range, extra.loc); | |
| extra.parseAdditiveExpression = parseAdditiveExpression; | |
| extra.parseAssignmentExpression = parseAssignmentExpression; | |
| extra.parseBitwiseANDExpression = parseBitwiseANDExpression; | |
| extra.parseBitwiseORExpression = parseBitwiseORExpression; | |
| extra.parseBitwiseXORExpression = parseBitwiseXORExpression; | |
| extra.parseBlock = parseBlock; | |
| extra.parseFunctionSourceElements = parseFunctionSourceElements; | |
| extra.parseCatchClause = parseCatchClause; | |
| extra.parseComputedMember = parseComputedMember; | |
| extra.parseConditionalExpression = parseConditionalExpression; | |
| extra.parseConstLetDeclaration = parseConstLetDeclaration; | |
| extra.parseEqualityExpression = parseEqualityExpression; | |
| extra.parseExpression = parseExpression; | |
| extra.parseForVariableDeclaration = parseForVariableDeclaration; | |
| extra.parseFunctionDeclaration = parseFunctionDeclaration; | |
| extra.parseFunctionExpression = parseFunctionExpression; | |
| extra.parseLogicalANDExpression = parseLogicalANDExpression; | |
| extra.parseLogicalORExpression = parseLogicalORExpression; | |
| extra.parseMultiplicativeExpression = parseMultiplicativeExpression; | |
| extra.parseNewExpression = parseNewExpression; | |
| extra.parseNonComputedProperty = parseNonComputedProperty; | |
| extra.parseObjectProperty = parseObjectProperty; | |
| extra.parseObjectPropertyKey = parseObjectPropertyKey; | |
| extra.parsePostfixExpression = parsePostfixExpression; | |
| extra.parsePrimaryExpression = parsePrimaryExpression; | |
| extra.parseProgram = parseProgram; | |
| extra.parsePropertyFunction = parsePropertyFunction; | |
| extra.parseRelationalExpression = parseRelationalExpression; | |
| extra.parseStatement = parseStatement; | |
| extra.parseShiftExpression = parseShiftExpression; | |
| extra.parseSwitchCase = parseSwitchCase; | |
| extra.parseUnaryExpression = parseUnaryExpression; | |
| extra.parseVariableDeclaration = parseVariableDeclaration; | |
| extra.parseVariableIdentifier = parseVariableIdentifier; | |
| parseAdditiveExpression = wrapTracking(extra.parseAdditiveExpression); | |
| parseAssignmentExpression = wrapTracking(extra.parseAssignmentExpression); | |
| parseBitwiseANDExpression = wrapTracking(extra.parseBitwiseANDExpression); | |
| parseBitwiseORExpression = wrapTracking(extra.parseBitwiseORExpression); | |
| parseBitwiseXORExpression = wrapTracking(extra.parseBitwiseXORExpression); | |
| parseBlock = wrapTracking(extra.parseBlock); | |
| parseFunctionSourceElements = wrapTracking(extra.parseFunctionSourceElements); | |
| parseCatchClause = wrapTracking(extra.parseCatchClause); | |
| parseComputedMember = wrapTracking(extra.parseComputedMember); | |
| parseConditionalExpression = wrapTracking(extra.parseConditionalExpression); | |
| parseConstLetDeclaration = wrapTracking(extra.parseConstLetDeclaration); | |
| parseEqualityExpression = wrapTracking(extra.parseEqualityExpression); | |
| parseExpression = wrapTracking(extra.parseExpression); | |
| parseForVariableDeclaration = wrapTracking(extra.parseForVariableDeclaration); | |
| parseFunctionDeclaration = wrapTracking(extra.parseFunctionDeclaration); | |
| parseFunctionExpression = wrapTracking(extra.parseFunctionExpression); | |
| parseLeftHandSideExpression = wrapTracking(parseLeftHandSideExpression); | |
| parseLogicalANDExpression = wrapTracking(extra.parseLogicalANDExpression); | |
| parseLogicalORExpression = wrapTracking(extra.parseLogicalORExpression); | |
| parseMultiplicativeExpression = wrapTracking(extra.parseMultiplicativeExpression); | |
| parseNewExpression = wrapTracking(extra.parseNewExpression); | |
| parseNonComputedProperty = wrapTracking(extra.parseNonComputedProperty); | |
| parseObjectProperty = wrapTracking(extra.parseObjectProperty); | |
| parseObjectPropertyKey = wrapTracking(extra.parseObjectPropertyKey); | |
| parsePostfixExpression = wrapTracking(extra.parsePostfixExpression); | |
| parsePrimaryExpression = wrapTracking(extra.parsePrimaryExpression); | |
| parseProgram = wrapTracking(extra.parseProgram); | |
| parsePropertyFunction = wrapTracking(extra.parsePropertyFunction); | |
| parseRelationalExpression = wrapTracking(extra.parseRelationalExpression); | |
| parseStatement = wrapTracking(extra.parseStatement); | |
| parseShiftExpression = wrapTracking(extra.parseShiftExpression); | |
| parseSwitchCase = wrapTracking(extra.parseSwitchCase); | |
| parseUnaryExpression = wrapTracking(extra.parseUnaryExpression); | |
| parseVariableDeclaration = wrapTracking(extra.parseVariableDeclaration); | |
| parseVariableIdentifier = wrapTracking(extra.parseVariableIdentifier); | |
| } | |
| if (typeof extra.tokens !== 'undefined') { | |
| extra.advance = advance; | |
| extra.scanRegExp = scanRegExp; | |
| advance = collectToken; | |
| scanRegExp = collectRegex; | |
| } | |
| } | |
| function unpatch() { | |
| if (typeof extra.skipComment === 'function') { | |
| skipComment = extra.skipComment; | |
| } | |
| if (extra.raw) { | |
| createLiteral = extra.createLiteral; | |
| } | |
| if (extra.range || extra.loc) { | |
| parseAdditiveExpression = extra.parseAdditiveExpression; | |
| parseAssignmentExpression = extra.parseAssignmentExpression; | |
| parseBitwiseANDExpression = extra.parseBitwiseANDExpression; | |
| parseBitwiseORExpression = extra.parseBitwiseORExpression; | |
| parseBitwiseXORExpression = extra.parseBitwiseXORExpression; | |
| parseBlock = extra.parseBlock; | |
| parseFunctionSourceElements = extra.parseFunctionSourceElements; | |
| parseCatchClause = extra.parseCatchClause; | |
| parseComputedMember = extra.parseComputedMember; | |
| parseConditionalExpression = extra.parseConditionalExpression; | |
| parseConstLetDeclaration = extra.parseConstLetDeclaration; | |
| parseEqualityExpression = extra.parseEqualityExpression; | |
| parseExpression = extra.parseExpression; | |
| parseForVariableDeclaration = extra.parseForVariableDeclaration; | |
| parseFunctionDeclaration = extra.parseFunctionDeclaration; | |
| parseFunctionExpression = extra.parseFunctionExpression; | |
| parseGroupExpression = extra.parseGroupExpression; | |
| parseLeftHandSideExpression = extra.parseLeftHandSideExpression; | |
| parseLeftHandSideExpressionAllowCall = extra.parseLeftHandSideExpressionAllowCall; | |
| parseLogicalANDExpression = extra.parseLogicalANDExpression; | |
| parseLogicalORExpression = extra.parseLogicalORExpression; | |
| parseMultiplicativeExpression = extra.parseMultiplicativeExpression; | |
| parseNewExpression = extra.parseNewExpression; | |
| parseNonComputedProperty = extra.parseNonComputedProperty; | |
| parseObjectProperty = extra.parseObjectProperty; | |
| parseObjectPropertyKey = extra.parseObjectPropertyKey; | |
| parsePrimaryExpression = extra.parsePrimaryExpression; | |
| parsePostfixExpression = extra.parsePostfixExpression; | |
| parseProgram = extra.parseProgram; | |
| parsePropertyFunction = extra.parsePropertyFunction; | |
| parseRelationalExpression = extra.parseRelationalExpression; | |
| parseStatement = extra.parseStatement; | |
| parseShiftExpression = extra.parseShiftExpression; | |
| parseSwitchCase = extra.parseSwitchCase; | |
| parseUnaryExpression = extra.parseUnaryExpression; | |
| parseVariableDeclaration = extra.parseVariableDeclaration; | |
| parseVariableIdentifier = extra.parseVariableIdentifier; | |
| } | |
| if (typeof extra.scanRegExp === 'function') { | |
| advance = extra.advance; | |
| scanRegExp = extra.scanRegExp; | |
| } | |
| } | |
| function stringToArray(str) { | |
| var length = str.length, | |
| result = [], | |
| i; | |
| for (i = 0; i < length; ++i) { | |
| result[i] = str.charAt(i); | |
| } | |
| return result; | |
| } | |
| function parse(code, options) { | |
| var program, toString; | |
| toString = String; | |
| if (typeof code !== 'string' && !(code instanceof String)) { | |
| code = toString(code); | |
| } | |
| source = code; | |
| index = 0; | |
| lineNumber = (source.length > 0) ? 1 : 0; | |
| lineStart = 0; | |
| length = source.length; | |
| buffer = null; | |
| state = { | |
| allowIn: true, | |
| labelSet: {}, | |
| inFunctionBody: false, | |
| inIteration: false, | |
| inSwitch: false | |
| }; | |
| extra = {}; | |
| if (typeof options !== 'undefined') { | |
| extra.range = (typeof options.range === 'boolean') && options.range; | |
| extra.loc = (typeof options.loc === 'boolean') && options.loc; | |
| extra.raw = (typeof options.raw === 'boolean') && options.raw; | |
| if (typeof options.tokens === 'boolean' && options.tokens) { | |
| extra.tokens = []; | |
| } | |
| if (typeof options.comment === 'boolean' && options.comment) { | |
| extra.comments = []; | |
| } | |
| if (typeof options.tolerant === 'boolean' && options.tolerant) { | |
| extra.errors = []; | |
| } | |
| } | |
| if (length > 0) { | |
| if (typeof source[0] === 'undefined') { | |
| // Try first to convert to a string. This is good as fast path | |
| // for old IE which understands string indexing for string | |
| // literals only and not for string object. | |
| if (code instanceof String) { | |
| source = code.valueOf(); | |
| } | |
| // Force accessing the characters via an array. | |
| if (typeof source[0] === 'undefined') { | |
| source = stringToArray(code); | |
| } | |
| } | |
| } | |
| patch(); | |
| try { | |
| program = parseProgram(); | |
| if (typeof extra.comments !== 'undefined') { | |
| filterCommentLocation(); | |
| program.comments = extra.comments; | |
| } | |
| if (typeof extra.tokens !== 'undefined') { | |
| filterTokenLocation(); | |
| program.tokens = extra.tokens; | |
| } | |
| if (typeof extra.errors !== 'undefined') { | |
| program.errors = extra.errors; | |
| } | |
| if (extra.range || extra.loc) { | |
| program.body = filterGroup(program.body); | |
| } | |
| } catch (e) { | |
| throw e; | |
| } finally { | |
| unpatch(); | |
| extra = {}; | |
| } | |
| return program; | |
| } | |
| // Sync with package.json. | |
| exports.version = '1.0.4'; | |
| exports.parse = parse; | |
| // Deep copy. | |
| exports.Syntax = (function () { | |
| var name, types = {}; | |
| if (typeof Object.create === 'function') { | |
| types = Object.create(null); | |
| } | |
| for (name in Syntax) { | |
| if (Syntax.hasOwnProperty(name)) { | |
| types[name] = Syntax[name]; | |
| } | |
| } | |
| if (typeof Object.freeze === 'function') { | |
| Object.freeze(types); | |
| } | |
| return types; | |
| }()); | |
| })); | |
| /* vim: set sw=4 ts=4 et tw=80 : */ | |
| })() | |
| },{}],19:[function(require,module,exports){ | |
| "use strict" | |
| function unique_pred(list, compare) { | |
| var ptr = 1 | |
| , len = list.length | |
| , a=list[0], b=list[0] | |
| for(var i=1; i<len; ++i) { | |
| b = a | |
| a = list[i] | |
| if(compare(a, b)) { | |
| if(i === ptr) { | |
| ptr++ | |
| continue | |
| } | |
| list[ptr++] = a | |
| } | |
| } | |
| list.length = ptr | |
| return list | |
| } | |
| function unique_eq(list) { | |
| var ptr = 1 | |
| , len = list.length | |
| , a=list[0], b = list[0] | |
| for(var i=1; i<len; ++i, b=a) { | |
| b = a | |
| a = list[i] | |
| if(a !== b) { | |
| if(i === ptr) { | |
| ptr++ | |
| continue | |
| } | |
| list[ptr++] = a | |
| } | |
| } | |
| list.length = ptr | |
| return list | |
| } | |
| function unique(list, compare, sorted) { | |
| if(list.length === 0) { | |
| return [] | |
| } | |
| if(compare) { | |
| if(!sorted) { | |
| list.sort(compare) | |
| } | |
| return unique_pred(list, compare) | |
| } | |
| if(!sorted) { | |
| list.sort() | |
| } | |
| return unique_eq(list) | |
| } | |
| module.exports = unique | |
| },{}],15:[function(require,module,exports){ | |
| "use strict" | |
| var compile = require("./compile.js") | |
| function createThunk(proc) { | |
| var code = ["'use strict'", "var CACHED={}"] | |
| var vars = [] | |
| var thunkName = proc.funcName + "_cwise_thunk" | |
| //Build thunk | |
| code.push(["return function ", thunkName, "(", proc.shimArgs.join(","), "){"].join("")) | |
| var typesig = [] | |
| var string_typesig = [] | |
| var proc_args = [["array",proc.arrayArgs[0],".shape"].join("")] | |
| for(var i=0; i<proc.arrayArgs.length; ++i) { | |
| var j = proc.arrayArgs[i] | |
| vars.push(["t", j, "=array", j, ".dtype,", | |
| "r", j, "=array", j, ".order"].join("")) | |
| typesig.push("t" + j) | |
| typesig.push("r" + j) | |
| string_typesig.push("t"+j) | |
| string_typesig.push("r"+j+".join()") | |
| proc_args.push("array" + j + ".data") | |
| proc_args.push("array" + j + ".stride") | |
| proc_args.push("array" + j + ".offset|0") | |
| } | |
| for(var i=0; i<proc.scalarArgs.length; ++i) { | |
| proc_args.push("scalar" + proc.scalarArgs[i]) | |
| } | |
| vars.push(["type=[", string_typesig.join(","), "].join()"].join("")) | |
| vars.push("proc=CACHED[type]") | |
| code.push("var " + vars.join(",")) | |
| code.push(["if(!proc){", | |
| "CACHED[type]=proc=compile([", typesig.join(","), "])}", | |
| "return proc(", proc_args.join(","), ")}"].join("")) | |
| if(proc.debug) { | |
| console.log("Generated thunk:", code.join("\n")) | |
| } | |
| //Compile thunk | |
| var thunk = new Function("compile", code.join("\n")) | |
| return thunk(compile.bind(undefined, proc)) | |
| } | |
| module.exports = createThunk | |
| },{"./compile.js":21}],20:[function(require,module,exports){ | |
| "use strict" | |
| var uniq = require("uniq") | |
| function innerFill(order, proc, body) { | |
| var dimension = order.length | |
| , nargs = proc.arrayArgs.length | |
| , has_index = proc.indexArgs.length>0 | |
| , code = [] | |
| , vars = [] | |
| , idx=0, pidx=0, i, j | |
| for(i=0; i<dimension; ++i) { | |
| vars.push(["i",i,"=0"].join("")) | |
| } | |
| //Compute scan deltas | |
| for(j=0; j<nargs; ++j) { | |
| for(i=0; i<dimension; ++i) { | |
| pidx = idx | |
| idx = order[i] | |
| if(i === 0) { | |
| vars.push(["d",j,"s",i,"=t",j,"[",idx,"]"].join("")) | |
| } else { | |
| vars.push(["d",j,"s",i,"=(t",j,"[",idx,"]-s",pidx,"*t",j,"[",pidx,"])"].join("")) | |
| } | |
| } | |
| } | |
| code.push("var " + vars.join(",")) | |
| //Scan loop | |
| for(i=dimension-1; i>=0; --i) { | |
| idx = order[i] | |
| code.push(["for(i",i,"=0;i",i,"<s",idx,";++i",i,"){"].join("")) | |
| } | |
| //Push body of inner loop | |
| code.push(body) | |
| //Advance scan pointers | |
| for(i=0; i<dimension; ++i) { | |
| pidx = idx | |
| idx = order[i] | |
| for(j=0; j<nargs; ++j) { | |
| code.push(["p",j,"+=d",j,"s",i].join("")) | |
| } | |
| if(has_index) { | |
| if(i > 0) { | |
| code.push(["index[",pidx,"]-=s",pidx].join("")) | |
| } | |
| code.push(["++index[",idx,"]"].join("")) | |
| } | |
| code.push("}") | |
| } | |
| return code.join("\n") | |
| } | |
| function outerFill(matched, order, proc, body) { | |
| var dimension = order.length | |
| , nargs = proc.arrayArgs.length | |
| , blockSize = proc.blockSize | |
| , has_index = proc.indexArgs.length > 0 | |
| , code = [] | |
| for(var i=0; i<nargs; ++i) { | |
| code.push(["var offset",i,"=p",i].join("")) | |
| } | |
| //Generate matched loops | |
| for(var i=matched; i<dimension; ++i) { | |
| code.push(["for(var j"+i+"=SS[", order[i], "]|0;j", i, ">0;){"].join("")) | |
| code.push(["if(j",i,"<",blockSize,"){"].join("")) | |
| code.push(["s",order[i],"=j",i].join("")) | |
| code.push(["j",i,"=0"].join("")) | |
| code.push(["}else{s",order[i],"=",blockSize].join("")) | |
| code.push(["j",i,"-=",blockSize,"}"].join("")) | |
| if(has_index) { | |
| code.push(["index[",order[i],"]=j",i].join("")) | |
| } | |
| } | |
| for(var i=0; i<nargs; ++i) { | |
| var indexStr = ["offset"+i] | |
| for(var j=matched; j<dimension; ++j) { | |
| indexStr.push(["j",j,"*t",i,"[",order[j],"]"].join("")) | |
| } | |
| code.push(["p",i,"=(",indexStr.join("+"),")"].join("")) | |
| } | |
| code.push(innerFill(order, proc, body)) | |
| for(var i=matched; i<dimension; ++i) { | |
| code.push("}") | |
| } | |
| return code.join("\n") | |
| } | |
| //Count the number of compatible inner orders | |
| function countMatches(orders) { | |
| var matched = 0, dimension = orders[0].length | |
| while(matched < dimension) { | |
| for(var j=1; j<orders.length; ++j) { | |
| if(orders[j][matched] !== orders[0][matched]) { | |
| return matched | |
| } | |
| } | |
| ++matched | |
| } | |
| return matched | |
| } | |
| //Processes a block according to the given data types | |
| function processBlock(block, proc, dtypes) { | |
| var code = block.body | |
| var pre = [] | |
| var post = [] | |
| for(var i=0; i<block.args.length; ++i) { | |
| var carg = block.args[i] | |
| if(carg.count <= 0) { | |
| continue | |
| } | |
| var re = new RegExp(carg.name, "g") | |
| switch(proc.argTypes[i]) { | |
| case "array": | |
| var arrNum = proc.arrayArgs.indexOf(i) | |
| if(carg.count === 1) { | |
| if(dtypes[arrNum] === "generic") { | |
| if(carg.lvalue) { | |
| pre.push(["var l", arrNum, "=a", arrNum, ".get(p", arrNum, ")"].join("")) | |
| code = code.replace(re, "l"+arrNum) | |
| post.push(["a", arrNum, ".set(p", arrNum, ",l",arrNum,")"].join("")) | |
| } else { | |
| code = code.replace(re, ["a", arrNum, ".get(p", arrNum, ")"].join("")) | |
| } | |
| } else { | |
| code = code.replace(re, ["a", arrNum, "[p", arrNum, "]"].join("")) | |
| } | |
| } else if(dtypes[arrNum] === "generic") { | |
| pre.push(["var l", arrNum, "=a", arrNum, ".get(p", arrNum, ")"].join("")) | |
| code = code.replace(re, "l"+arrNum) | |
| if(carg.lvalue) { | |
| post.push(["a", arrNum, ".set(p", arrNum, ",l",arrNum,")"].join("")) | |
| } | |
| } else { | |
| pre.push(["var l", arrNum, "=a", arrNum, "[p", arrNum, "]"].join("")) | |
| code = code.replace(re, "l"+arrNum) | |
| if(carg.lvalue) { | |
| post.push(["a", arrNum, "[p", arrNum, "]=l",arrNum].join("")) | |
| } | |
| } | |
| break | |
| case "scalar": | |
| code = code.replace(re, "Y" + proc.scalarArgs.indexOf(i)) | |
| break | |
| case "index": | |
| code = code.replace(re, "index") | |
| break | |
| case "shape": | |
| code = code.replace(re, "shape") | |
| break | |
| } | |
| } | |
| return [pre.join("\n"), code, post.join("\n")].join("\n").trim() | |
| } | |
| function typeSummary(dtypes) { | |
| var summary = new Array(dtypes.length) | |
| var allEqual = true | |
| for(var i=0; i<dtypes.length; ++i) { | |
| var t = dtypes[i] | |
| var digits = t.match(/\d+/) | |
| if(!digits) { | |
| digits = "" | |
| } else { | |
| digits = digits[0] | |
| } | |
| if(t.charAt(0) === 0) { | |
| summary[i] = "u" + t.charAt(1) + digits | |
| } else { | |
| summary[i] = t.charAt(0) + digits | |
| } | |
| if(i > 0) { | |
| allEqual = allEqual && summary[i] === summary[i-1] | |
| } | |
| } | |
| if(allEqual) { | |
| return summary[0] | |
| } | |
| return summary.join("") | |
| } | |
| //Generates a cwise operator | |
| function generateCWiseOp(proc, typesig) { | |
| //Compute dimension | |
| var dimension = typesig[1].length|0 | |
| var orders = new Array(proc.arrayArgs.length) | |
| var dtypes = new Array(proc.arrayArgs.length) | |
| //First create arguments for procedure | |
| var arglist = ["SS"] | |
| var code = ["'use strict'"] | |
| var vars = [] | |
| for(var j=0; j<dimension; ++j) { | |
| vars.push(["s", j, "=SS[", j, "]"].join("")) | |
| } | |
| for(var i=0; i<proc.arrayArgs.length; ++i) { | |
| arglist.push("a"+i) | |
| arglist.push("t"+i) | |
| arglist.push("p"+i) | |
| dtypes[i] = typesig[2*i] | |
| orders[i] = typesig[2*i+1] | |
| } | |
| for(var i=0; i<proc.scalarArgs.length; ++i) { | |
| arglist.push("Y" + i) | |
| } | |
| if(proc.shapeArgs.length > 0) { | |
| vars.push("shape=SS.slice(0)") | |
| } | |
| if(proc.indexArgs.length > 0) { | |
| var zeros = new Array(dimension) | |
| for(var i=0; i<dimension; ++i) { | |
| zeros[i] = "0" | |
| } | |
| vars.push(["index=[", zeros.join(","), "]"].join("")) | |
| } | |
| //Prepare this variables | |
| var thisVars = uniq([].concat(proc.pre.thisVars) | |
| .concat(proc.body.thisVars) | |
| .concat(proc.post.thisVars)) | |
| vars = vars.concat(thisVars) | |
| code.push("var " + vars.join(",")) | |
| for(var i=0; i<proc.arrayArgs.length; ++i) { | |
| code.push("p"+i+"|=0") | |
| } | |
| //Inline prelude | |
| if(proc.pre.body.length > 3) { | |
| code.push(processBlock(proc.pre, proc, dtypes)) | |
| } | |
| //Process body | |
| var body = processBlock(proc.body, proc, dtypes) | |
| var matched = countMatches(orders) | |
| if(matched < dimension) { | |
| code.push(outerFill(matched, orders[0], proc, body)) | |
| } else { | |
| code.push(innerFill(orders[0], proc, body)) | |
| } | |
| //Inline epilog | |
| if(proc.post.body.length > 3) { | |
| code.push(processBlock(proc.post, proc, dtypes)) | |
| } | |
| if(proc.debug) { | |
| console.log("Generated cwise routine for ", typesig, ":\n\n", code.join("\n")) | |
| } | |
| var loopName = [(proc.funcName||"unnamed"), "_cwise_loop_", orders[0].join("s"),"m",matched,typeSummary(dtypes)].join("") | |
| var f = new Function(["function ",loopName,"(", arglist.join(","),"){", code.join("\n"),"} return ", loopName].join("")) | |
| return f() | |
| } | |
| module.exports = generateCWiseOp | |
| },{"uniq":22}],21:[function(require,module,exports){ | |
| "use strict" | |
| var uniq = require("uniq") | |
| function innerFill(order, proc, body) { | |
| var dimension = order.length | |
| , nargs = proc.arrayArgs.length | |
| , has_index = proc.indexArgs.length>0 | |
| , code = [] | |
| , vars = [] | |
| , idx=0, pidx=0, i, j | |
| for(i=0; i<dimension; ++i) { | |
| vars.push(["i",i,"=0"].join("")) | |
| } | |
| //Compute scan deltas | |
| for(j=0; j<nargs; ++j) { | |
| for(i=0; i<dimension; ++i) { | |
| pidx = idx | |
| idx = order[i] | |
| if(i === 0) { | |
| vars.push(["d",j,"s",i,"=t",j,"[",idx,"]"].join("")) | |
| } else { | |
| vars.push(["d",j,"s",i,"=(t",j,"[",idx,"]-s",pidx,"*t",j,"[",pidx,"])"].join("")) | |
| } | |
| } | |
| } | |
| code.push("var " + vars.join(",")) | |
| //Scan loop | |
| for(i=dimension-1; i>=0; --i) { | |
| idx = order[i] | |
| code.push(["for(i",i,"=0;i",i,"<s",idx,";++i",i,"){"].join("")) | |
| } | |
| //Push body of inner loop | |
| code.push(body) | |
| //Advance scan pointers | |
| for(i=0; i<dimension; ++i) { | |
| pidx = idx | |
| idx = order[i] | |
| for(j=0; j<nargs; ++j) { | |
| code.push(["p",j,"+=d",j,"s",i].join("")) | |
| } | |
| if(has_index) { | |
| if(i > 0) { | |
| code.push(["index[",pidx,"]-=s",pidx].join("")) | |
| } | |
| code.push(["++index[",idx,"]"].join("")) | |
| } | |
| code.push("}") | |
| } | |
| return code.join("\n") | |
| } | |
| function outerFill(matched, order, proc, body) { | |
| var dimension = order.length | |
| , nargs = proc.arrayArgs.length | |
| , blockSize = proc.blockSize | |
| , has_index = proc.indexArgs.length > 0 | |
| , code = [] | |
| for(var i=0; i<nargs; ++i) { | |
| code.push(["var offset",i,"=p",i].join("")) | |
| } | |
| //Generate matched loops | |
| for(var i=matched; i<dimension; ++i) { | |
| code.push(["for(var j"+i+"=SS[", order[i], "]|0;j", i, ">0;){"].join("")) | |
| code.push(["if(j",i,"<",blockSize,"){"].join("")) | |
| code.push(["s",order[i],"=j",i].join("")) | |
| code.push(["j",i,"=0"].join("")) | |
| code.push(["}else{s",order[i],"=",blockSize].join("")) | |
| code.push(["j",i,"-=",blockSize,"}"].join("")) | |
| if(has_index) { | |
| code.push(["index[",order[i],"]=j",i].join("")) | |
| } | |
| } | |
| for(var i=0; i<nargs; ++i) { | |
| var indexStr = ["offset"+i] | |
| for(var j=matched; j<dimension; ++j) { | |
| indexStr.push(["j",j,"*t",i,"[",order[j],"]"].join("")) | |
| } | |
| code.push(["p",i,"=(",indexStr.join("+"),")"].join("")) | |
| } | |
| code.push(innerFill(order, proc, body)) | |
| for(var i=matched; i<dimension; ++i) { | |
| code.push("}") | |
| } | |
| return code.join("\n") | |
| } | |
| //Count the number of compatible inner orders | |
| function countMatches(orders) { | |
| var matched = 0, dimension = orders[0].length | |
| while(matched < dimension) { | |
| for(var j=1; j<orders.length; ++j) { | |
| if(orders[j][matched] !== orders[0][matched]) { | |
| return matched | |
| } | |
| } | |
| ++matched | |
| } | |
| return matched | |
| } | |
| //Processes a block according to the given data types | |
| function processBlock(block, proc, dtypes) { | |
| var code = block.body | |
| var pre = [] | |
| var post = [] | |
| for(var i=0; i<block.args.length; ++i) { | |
| var carg = block.args[i] | |
| if(carg.count <= 0) { | |
| continue | |
| } | |
| var re = new RegExp(carg.name, "g") | |
| switch(proc.argTypes[i]) { | |
| case "array": | |
| var arrNum = proc.arrayArgs.indexOf(i) | |
| if(carg.count === 1) { | |
| if(dtypes[arrNum] === "generic") { | |
| if(carg.lvalue) { | |
| pre.push(["var l", arrNum, "=a", arrNum, ".get(p", arrNum, ")"].join("")) | |
| code = code.replace(re, "l"+arrNum) | |
| post.push(["a", arrNum, ".set(p", arrNum, ",l",arrNum,")"].join("")) | |
| } else { | |
| code = code.replace(re, ["a", arrNum, ".get(p", arrNum, ")"].join("")) | |
| } | |
| } else { | |
| code = code.replace(re, ["a", arrNum, "[p", arrNum, "]"].join("")) | |
| } | |
| } else if(dtypes[arrNum] === "generic") { | |
| pre.push(["var l", arrNum, "=a", arrNum, ".get(p", arrNum, ")"].join("")) | |
| code = code.replace(re, "l"+arrNum) | |
| if(carg.lvalue) { | |
| post.push(["a", arrNum, ".set(p", arrNum, ",l",arrNum,")"].join("")) | |
| } | |
| } else { | |
| pre.push(["var l", arrNum, "=a", arrNum, "[p", arrNum, "]"].join("")) | |
| code = code.replace(re, "l"+arrNum) | |
| if(carg.lvalue) { | |
| post.push(["a", arrNum, "[p", arrNum, "]=l",arrNum].join("")) | |
| } | |
| } | |
| break | |
| case "scalar": | |
| code = code.replace(re, "Y" + proc.scalarArgs.indexOf(i)) | |
| break | |
| case "index": | |
| code = code.replace(re, "index") | |
| break | |
| case "shape": | |
| code = code.replace(re, "shape") | |
| break | |
| } | |
| } | |
| return [pre.join("\n"), code, post.join("\n")].join("\n").trim() | |
| } | |
| function typeSummary(dtypes) { | |
| var summary = new Array(dtypes.length) | |
| var allEqual = true | |
| for(var i=0; i<dtypes.length; ++i) { | |
| var t = dtypes[i] | |
| var digits = t.match(/\d+/) | |
| if(!digits) { | |
| digits = "" | |
| } else { | |
| digits = digits[0] | |
| } | |
| if(t.charAt(0) === 0) { | |
| summary[i] = "u" + t.charAt(1) + digits | |
| } else { | |
| summary[i] = t.charAt(0) + digits | |
| } | |
| if(i > 0) { | |
| allEqual = allEqual && summary[i] === summary[i-1] | |
| } | |
| } | |
| if(allEqual) { | |
| return summary[0] | |
| } | |
| return summary.join("") | |
| } | |
| //Generates a cwise operator | |
| function generateCWiseOp(proc, typesig) { | |
| //Compute dimension | |
| var dimension = typesig[1].length|0 | |
| var orders = new Array(proc.arrayArgs.length) | |
| var dtypes = new Array(proc.arrayArgs.length) | |
| //First create arguments for procedure | |
| var arglist = ["SS"] | |
| var code = ["'use strict'"] | |
| var vars = [] | |
| for(var j=0; j<dimension; ++j) { | |
| vars.push(["s", j, "=SS[", j, "]"].join("")) | |
| } | |
| for(var i=0; i<proc.arrayArgs.length; ++i) { | |
| arglist.push("a"+i) | |
| arglist.push("t"+i) | |
| arglist.push("p"+i) | |
| dtypes[i] = typesig[2*i] | |
| orders[i] = typesig[2*i+1] | |
| } | |
| for(var i=0; i<proc.scalarArgs.length; ++i) { | |
| arglist.push("Y" + i) | |
| } | |
| if(proc.shapeArgs.length > 0) { | |
| vars.push("shape=SS.slice(0)") | |
| } | |
| if(proc.indexArgs.length > 0) { | |
| var zeros = new Array(dimension) | |
| for(var i=0; i<dimension; ++i) { | |
| zeros[i] = "0" | |
| } | |
| vars.push(["index=[", zeros.join(","), "]"].join("")) | |
| } | |
| //Prepare this variables | |
| var thisVars = uniq([].concat(proc.pre.thisVars) | |
| .concat(proc.body.thisVars) | |
| .concat(proc.post.thisVars)) | |
| vars = vars.concat(thisVars) | |
| code.push("var " + vars.join(",")) | |
| for(var i=0; i<proc.arrayArgs.length; ++i) { | |
| code.push("p"+i+"|=0") | |
| } | |
| //Inline prelude | |
| if(proc.pre.body.length > 3) { | |
| code.push(processBlock(proc.pre, proc, dtypes)) | |
| } | |
| //Process body | |
| var body = processBlock(proc.body, proc, dtypes) | |
| var matched = countMatches(orders) | |
| if(matched < dimension) { | |
| code.push(outerFill(matched, orders[0], proc, body)) | |
| } else { | |
| code.push(innerFill(orders[0], proc, body)) | |
| } | |
| //Inline epilog | |
| if(proc.post.body.length > 3) { | |
| code.push(processBlock(proc.post, proc, dtypes)) | |
| } | |
| if(proc.debug) { | |
| console.log("Generated cwise routine for ", typesig, ":\n\n", code.join("\n")) | |
| } | |
| var loopName = [(proc.funcName||"unnamed"), "_cwise_loop_", orders[0].join("s"),"m",matched,typeSummary(dtypes)].join("") | |
| var f = new Function(["function ",loopName,"(", arglist.join(","),"){", code.join("\n"),"} return ", loopName].join("")) | |
| return f() | |
| } | |
| module.exports = generateCWiseOp | |
| },{"uniq":23}],22:[function(require,module,exports){ | |
| "use strict" | |
| function unique_pred(list, compare) { | |
| var ptr = 1 | |
| , len = list.length | |
| , a=list[0], b=list[0] | |
| for(var i=1; i<len; ++i) { | |
| b = a | |
| a = list[i] | |
| if(compare(a, b)) { | |
| if(i === ptr) { | |
| ptr++ | |
| continue | |
| } | |
| list[ptr++] = a | |
| } | |
| } | |
| list.length = ptr | |
| return list | |
| } | |
| function unique_eq(list) { | |
| var ptr = 1 | |
| , len = list.length | |
| , a=list[0], b = list[0] | |
| for(var i=1; i<len; ++i, b=a) { | |
| b = a | |
| a = list[i] | |
| if(a !== b) { | |
| if(i === ptr) { | |
| ptr++ | |
| continue | |
| } | |
| list[ptr++] = a | |
| } | |
| } | |
| list.length = ptr | |
| return list | |
| } | |
| function unique(list, compare, sorted) { | |
| if(list.length === 0) { | |
| return [] | |
| } | |
| if(compare) { | |
| if(!sorted) { | |
| list.sort(compare) | |
| } | |
| return unique_pred(list, compare) | |
| } | |
| if(!sorted) { | |
| list.sort() | |
| } | |
| return unique_eq(list) | |
| } | |
| module.exports = unique | |
| },{}],23:[function(require,module,exports){ | |
| "use strict" | |
| function unique_pred(list, compare) { | |
| var ptr = 1 | |
| , len = list.length | |
| , a=list[0], b=list[0] | |
| for(var i=1; i<len; ++i) { | |
| b = a | |
| a = list[i] | |
| if(compare(a, b)) { | |
| if(i === ptr) { | |
| ptr++ | |
| continue | |
| } | |
| list[ptr++] = a | |
| } | |
| } | |
| list.length = ptr | |
| return list | |
| } | |
| function unique_eq(list) { | |
| var ptr = 1 | |
| , len = list.length | |
| , a=list[0], b = list[0] | |
| for(var i=1; i<len; ++i, b=a) { | |
| b = a | |
| a = list[i] | |
| if(a !== b) { | |
| if(i === ptr) { | |
| ptr++ | |
| continue | |
| } | |
| list[ptr++] = a | |
| } | |
| } | |
| list.length = ptr | |
| return list | |
| } | |
| function unique(list, compare, sorted) { | |
| if(list.length === 0) { | |
| return [] | |
| } | |
| if(compare) { | |
| if(!sorted) { | |
| list.sort(compare) | |
| } | |
| return unique_pred(list, compare) | |
| } | |
| if(!sorted) { | |
| list.sort() | |
| } | |
| return unique_eq(list) | |
| } | |
| module.exports = unique | |
| },{}]},{},[]) | |
| //@ sourceMappingURL=data:application/json;base64,{"version":3,"file":"generated.js","sources":["/private/var/folders/43/z7pv8pvd4x57nt_1zz2561tw0000gn/T/cave-automata-2d11384-42346-1efasv6/node_modules/cave-automata-2d/index.js","/private/var/folders/43/z7pv8pvd4x57nt_1zz2561tw0000gn/T/cave-automata-2d11384-42346-1efasv6/node_modules/cave-automata-2d/node_modules/moore/index.js","/private/var/folders/43/z7pv8pvd4x57nt_1zz2561tw0000gn/T/cave-automata-2d11384-42346-1efasv6/node_modules/cave-automata-2d/node_modules/ndarray-stencil/stencil.js","/private/var/folders/43/z7pv8pvd4x57nt_1zz2561tw0000gn/T/cave-automata-2d11384-42346-1efasv6/node_modules/cave-automata-2d/node_modules/zeros/zeros.js","/private/var/folders/43/z7pv8pvd4x57nt_1zz2561tw0000gn/T/cave-automata-2d11384-42346-1efasv6/node_modules/cave-automata-2d/node_modules/ndarray-fill/index.js","/private/var/folders/43/z7pv8pvd4x57nt_1zz2561tw0000gn/T/cave-automata-2d11384-42346-1efasv6/node_modules/cave-automata-2d/node_modules/ndarray-stencil/node_modules/dup/dup.js","/private/var/folders/43/z7pv8pvd4x57nt_1zz2561tw0000gn/T/cave-automata-2d11384-42346-1efasv6/node_modules/cave-automata-2d/node_modules/ndarray-stencil/node_modules/cwise/cwise.js","/private/var/folders/43/z7pv8pvd4x57nt_1zz2561tw0000gn/T/cave-automata-2d11384-42346-1efasv6/node_modules/cave-automata-2d/node_modules/zeros/node_modules/ndarray/ndarray.js","/private/var/folders/43/z7pv8pvd4x57nt_1zz2561tw0000gn/T/cave-automata-2d11384-42346-1efasv6/node_modules/cave-automata-2d/node_modules/ndarray-fill/node_modules/cwise/cwise.js","/private/var/folders/43/z7pv8pvd4x57nt_1zz2561tw0000gn/T/cave-automata-2d11384-42346-1efasv6/node_modules/cave-automata-2d/node_modules/zeros/node_modules/ndarray/node_modules/iota-array/iota.js","/private/var/folders/43/z7pv8pvd4x57nt_1zz2561tw0000gn/T/cave-automata-2d11384-42346-1efasv6/node_modules/cave-automata-2d/node_modules/ndarray-stencil/node_modules/cwise/node_modules/cwise-compiler/compiler.js","/private/var/folders/43/z7pv8pvd4x57nt_1zz2561tw0000gn/T/cave-automata-2d11384-42346-1efasv6/node_modules/cave-automata-2d/node_modules/ndarray-fill/node_modules/cwise/node_modules/cwise-compiler/compiler.js","/private/var/folders/43/z7pv8pvd4x57nt_1zz2561tw0000gn/T/cave-automata-2d11384-42346-1efasv6/node_modules/cave-automata-2d/node_modules/ndarray-stencil/node_modules/cwise/node_modules/cwise-parser/index.js","/private/var/folders/43/z7pv8pvd4x57nt_1zz2561tw0000gn/T/cave-automata-2d11384-42346-1efasv6/node_modules/cave-automata-2d/node_modules/ndarray-fill/node_modules/cwise/node_modules/cwise-parser/index.js","/private/var/folders/43/z7pv8pvd4x57nt_1zz2561tw0000gn/T/cave-automata-2d11384-42346-1efasv6/node_modules/cave-automata-2d/node_modules/ndarray-stencil/node_modules/cwise/node_modules/cwise-compiler/lib/thunk.js","/private/var/folders/43/z7pv8pvd4x57nt_1zz2561tw0000gn/T/cave-automata-2d11384-42346-1efasv6/node_modules/cave-automata-2d/node_modules/ndarray-stencil/node_modules/cwise/node_modules/cwise-parser/node_modules/esprima/esprima.js","/private/var/folders/43/z7pv8pvd4x57nt_1zz2561tw0000gn/T/cave-automata-2d11384-42346-1efasv6/node_modules/cave-automata-2d/node_modules/ndarray-stencil/node_modules/cwise/node_modules/cwise-parser/node_modules/uniq/uniq.js","/private/var/folders/43/z7pv8pvd4x57nt_1zz2561tw0000gn/T/cave-automata-2d11384-42346-1efasv6/node_modules/cave-automata-2d/node_modules/ndarray-fill/node_modules/cwise/node_modules/cwise-parser/node_modules/esprima/esprima.js","/private/var/folders/43/z7pv8pvd4x57nt_1zz2561tw0000gn/T/cave-automata-2d11384-42346-1efasv6/node_modules/cave-automata-2d/node_modules/ndarray-fill/node_modules/cwise/node_modules/cwise-parser/node_modules/uniq/uniq.js","/private/var/folders/43/z7pv8pvd4x57nt_1zz2561tw0000gn/T/cave-automata-2d11384-42346-1efasv6/node_modules/cave-automata-2d/node_modules/ndarray-fill/node_modules/cwise/node_modules/cwise-compiler/lib/thunk.js","/private/var/folders/43/z7pv8pvd4x57nt_1zz2561tw0000gn/T/cave-automata-2d11384-42346-1efasv6/node_modules/cave-automata-2d/node_modules/ndarray-stencil/node_modules/cwise/node_modules/cwise-compiler/lib/compile.js","/private/var/folders/43/z7pv8pvd4x57nt_1zz2561tw0000gn/T/cave-automata-2d11384-42346-1efasv6/node_modules/cave-automata-2d/node_modules/ndarray-fill/node_modules/cwise/node_modules/cwise-compiler/lib/compile.js","/private/var/folders/43/z7pv8pvd4x57nt_1zz2561tw0000gn/T/cave-automata-2d11384-42346-1efasv6/node_modules/cave-automata-2d/node_modules/ndarray-stencil/node_modules/cwise/node_modules/cwise-compiler/node_modules/uniq/uniq.js","/private/var/folders/43/z7pv8pvd4x57nt_1zz2561tw0000gn/T/cave-automata-2d11384-42346-1efasv6/node_modules/cave-automata-2d/node_modules/ndarray-fill/node_modules/cwise/node_modules/cwise-compiler/node_modules/uniq/uniq.js"],"names":[],"mappings":";;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACVA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClVA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACVA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACr0HA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACr0HA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/PA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/PA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","sourcesContent":["var neighborhood = require('moore')(1, 2).concat([[0,0]])\nvar stencil = require('ndarray-stencil')\nvar fill = require('ndarray-fill')\nvar zero = require('zeros')\n\nvar neighbors = neighborhood.length\nvar stencils = {}\n\nmodule.exports = generate\n\n// ndarray-stencil generates code using cwise, and as\n// such incurs a slight performance hit initially.\n// To work around this, we can keep two cached functions\n// which use shared parameters. See `iterator` for more info.\nvar sharedWidth = null\nvar sharedHeight = null\nvar sharedBorder = null\nvar sharedThreshold = null\n\nstencils.vanilla = stencil(neighborhood, function(p1,p2,p3,p4,p5,p6,p7,p8,p9,pos) {\n  return (\n    p1+p2+p3+p4+p5+p6+p7+p8+p9 >= sharedThreshold\n  ) ? 1 : 0\n}, { useIndex: false })\n\nstencils.border = stencil(neighborhood, function(p1,p2,p3,p4,p5,p6,p7,p8,p9,pos) {\n  return (\n    p1+p2+p3+p4+p5+p6+p7+p8+p9 >= sharedThreshold ||\n    pos[0] < sharedBorder ||\n    pos[0] > sharedWidth - sharedBorder - 3 ||\n    pos[1] < sharedBorder ||\n    pos[1] > sharedHeight - sharedBorder - 3\n  ) ? 1 : 0\n}, { useIndex: true })\n\nfunction generate(array, opts) {\n  opts = opts || {}\n\n  var width = array.shape[0]\n    , height = array.shape[1]\n    , buffer = opts.buffer || zero([ width, height ])\n\n  var density = opts.density || 0.5\n    , threshold = opts.threshold || 5\n    , border = 'border' in opts ? opts.border : 1\n    , shouldFill = 'fill' in opts ? opts.fill : true\n    , iterate = stencils[\n      border ? 'border' : 'vanilla'\n    ]\n\n  if (shouldFill) fill(array, function(x, y) {\n    return Math.random() <= density || (\n      x <= 1 || x >= width-2 ||\n      y <= 1 || y >= height-2\n    ) ? 1 : 0\n  })\n\n  if (opts.iterations) {\n    iterator(opts.iterations)\n  }\n\n  return iterator\n\n  // Updates the shared variables that are available\n  // on the module-level scope. This is a synchronous\n  // operation, so it's totally safe (though not\n  // necessarily pretty) provided these values are\n  // updated before any iteration.\n  function iterator(iterations) {\n    sharedWidth = width\n    sharedHeight = height\n    sharedBorder = border\n    sharedThreshold = threshold\n\n    iterations = iterations || 1\n\n    for (var i = 0; i < iterations; i += 1) {\n      if (i % 2) {\n        iterate(array, buffer)\n      } else {\n        iterate(buffer, array)\n      }\n    }\n\n    if (iterations % 2) {\n      fill(array, function(x, y) {\n        return buffer.get(x, y)\n      })\n    }\n\n    return array\n  }\n}\n","module.exports = moore\n\nfunction moore(range, dims) {\n  dims = dims || 2\n  range = range || 1\n  return recurse([], [], 0)\n\n  function recurse(array, temp, d) {\n    if (d === dims-1) {\n      for (var i = -range; i <= range; i += 1) {\n        if (i || temp.some(function(n) {\n          return n\n        })) array.push(temp.concat(i))\n      }\n    } else {\n      for (var i = -range; i <= range; i += 1) {\n        recurse(array, temp.concat(i), d+1)\n      }\n    }\n    return array\n  }\n}\n","\"use strict\"\n\nvar dup = require(\"dup\")\nvar cwise = require(\"cwise\")\n\nfunction generateCWiseLoop(n, d, func, options) {\n  var body_args = []\n  var args = [\"scalar\", \"array\"]\n  for(var i=0; i<n; ++i) {\n    args.push(\"array\")\n    body_args.push(\"a\"+i)\n  }\n  \n  if(options.useIndex) {\n    body_args.push(\"idx\")\n    args.push(\"index\")\n  }\n  body_args.push([\"out=func(\",body_args.join(\",\"),\")\"].join(\"\"))\n  body_args.unshift(\"out\")\n  body_args.unshift(\"func\")\n  \n  var loop = cwise({\n    args: args,\n    body: Function.apply(undefined, body_args),\n    funcName: \"StencilOp\"\n  })\n  \n  return loop.bind(undefined, func)\n}\n\nfunction hiOffset(hi, point) {\n  var out = new Array(point.length)\n  for(var i=0; i<hi.length; ++i) {\n    var d = -point[i]-hi[i]\n    if(d === 0) {\n      out[i] = \"s\" + i\n    } else {\n      out[i] = [\"s\", i, \"-\", (-d)].join(\"\")\n    }\n  }\n  return out.join(\",\")\n}\n\nfunction loOffset(lo, point) {\n  var out = new Array(point.length)\n  for(var i=0; i<lo.length; ++i) {\n    var d = -lo[i]-point[i]\n    if(d === 0) {\n      out[i] = \"0\"\n    } else  {\n      out[i] = d\n    }\n  }\n  return out.join(\",\")\n}\n\nfunction generateWrapper(points, lo, hi, loop) {\n  var n = points.length\n  var d = lo.length\n  var code = [\"'use strict'\"]\n  code.push(\"var s=out.shape\")\n  for(var i=0; i<d; ++i) {\n    code.push([\"var s\", i, \"=s[\", i, \"]|0\"].join(\"\"))\n  }\n  code.push([\"func(out.hi(\", hiOffset(hi, dup(d)), \").lo(\", loOffset(lo, dup(d)), \")\"].join(\"\"))\n  for(var i=0; i<points.length; ++i) {\n    code.push([\",inp.hi(\", hiOffset(hi, points[i]), \").lo(\", loOffset(lo, points[i]), \")\"].join(\"\"))\n  }\n  code.push(\")\")\n  var proc = new Function(\"func\", \"out\", \"inp\", code.join(\"\\n\"))\n  return proc.bind(undefined, loop)\n}\n\nfunction stencilOp(points, func, options) {\n  options = options || {}\n  if(points.length === 0) {\n    throw new Error(\"ndarray-stencil: Need to specify at least one point for stencil\")\n  }\n  var n = points.length\n  var d = points[0].length\n  var lo = dup(d)\n  var hi = dup(d)\n  for(var i=0; i<n; ++i) {\n    var p = points[i]\n    for(var j=0; j<d; ++j) {\n      lo[j] = Math.min(lo[j], p[j])\n      hi[j] = Math.max(hi[j], p[j])\n    }\n  }\n  var cwiseLoop = generateCWiseLoop(n, d, func, options)\n  return generateWrapper(points, lo, hi, cwiseLoop)\n}\n\nmodule.exports = stencilOp","\"use strict\"\n\nvar ndarray = require(\"ndarray\")\n\nmodule.exports = function zeros(shape) {\n  var sz = 1\n  for(var i=0; i<shape.length; ++i) {\n    sz *= shape[i]\n  }\n  return ndarray(new Float64Array(sz), shape)\n}","\"use strict\"\n\nvar fill = require(\"cwise\")({\n  args: [\"index\", \"array\", \"scalar\"],\n  body: function(idx, out, f) {\n    out = f.apply(undefined, idx)\n  }\n})\n\nmodule.exports = function(array, f) {\n  fill(array, f)\n  return array\n}\n","\"use strict\"\n\nfunction dupe_array(count, value, i) {\n  var c = count[i]|0\n  if(c <= 0) {\n    return []\n  }\n  var result = new Array(c), j\n  if(i === count.length-1) {\n    for(j=0; j<c; ++j) {\n      result[j] = value\n    }\n  } else {\n    for(j=0; j<c; ++j) {\n      result[j] = dupe_array(count, value, i+1)\n    }\n  }\n  return result\n}\n\nfunction dupe_number(count, value) {\n  var result, i\n  result = new Array(count)\n  for(i=0; i<count; ++i) {\n    result[i] = value\n  }\n  return result\n}\n\nfunction dupe(count, value) {\n  if(typeof value === \"undefined\") {\n    value = 0\n  }\n  switch(typeof count) {\n    case \"number\":\n      if(count > 0) {\n        return dupe_number(count|0, value)\n      }\n    break\n    case \"object\":\n      if(typeof (count.length) === \"number\") {\n        return dupe_array(count, value, 0)\n      }\n    break\n  }\n  return []\n}\n\nmodule.exports = dupe","\"use strict\"\n\nvar parse   = require(\"cwise-parser\")\nvar compile = require(\"cwise-compiler\")\n\nvar REQUIRED_FIELDS = [ \"args\", \"body\" ]\nvar OPTIONAL_FIELDS = [ \"pre\", \"post\", \"printCode\", \"funcName\", \"blockSize\" ]\n\nfunction createCWise(user_args) {\n  //Check parameters\n  for(var id in user_args) {\n    if(REQUIRED_FIELDS.indexOf(id) < 0 &&\n       OPTIONAL_FIELDS.indexOf(id) < 0) {\n      console.warn(\"cwise: Unknown argument '\"+id+\"' passed to expression compiler\")\n    }\n  }\n  for(var i=0; i<REQUIRED_FIELDS.length; ++i) {\n    if(!user_args[REQUIRED_FIELDS[i]]) {\n      throw new Error(\"cwise: Missing argument: \" + REQUIRED_FIELDS[i])\n    }\n  }\n  \n  //Parse blocks\n  return compile({\n    args:       user_args.args,\n    pre:        parse(user_args.pre || function(){}),\n    body:       parse(user_args.body),\n    post:       parse(user_args.post || function(){}),\n    debug:      !!user_args.printCode,\n    funcName:   user_args.funcName || user_args.body.name || \"cwise\",\n    blockSize:  user_args.blockSize || 64\n  })\n}\n\nmodule.exports = createCWise\n","\"use strict\"\n\nvar iota = require(\"iota-array\")\n\nvar arrayMethods = [\n  \"concat\",\n  \"join\",\n  \"slice\",\n  \"toString\",\n  \"indexOf\",\n  \"lastIndexOf\",\n  \"forEach\",\n  \"every\",\n  \"some\",\n  \"filter\",\n  \"map\",\n  \"reduce\",\n  \"reduceRight\"\n]\n\nfunction compare1st(a, b) {\n  return a[0] - b[0]\n}\n\nfunction order() {\n  var stride = this.stride\n  var terms = new Array(stride.length)\n  var i\n  for(i=0; i<terms.length; ++i) {\n    terms[i] = [Math.abs(stride[i]), i]\n  }\n  terms.sort(compare1st)\n  var result = new Array(terms.length)\n  for(i=0; i<result.length; ++i) {\n    result[i] = terms[i][1]\n  }\n  return result\n}\n\nvar ZeroArray = \"function ZeroArray(a,d) {\\\nthis.data = a;\\\nthis.offset = d\\\n};\\\nvar proto=ZeroArray.prototype;\\\nproto.size=0;\\\nproto.shape=[];\\\nproto.stride=[];\\\nproto.order=[];\\\nproto.get=proto.set=function() {\\\nreturn Number.NaN\\\n};\\\nproto.lo=\\\nproto.hi=\\\nproto.transpose=\\\nproto.step=\\\nproto.pick=function() {\\\nreturn new ZeroArray(this.data,this.shape,this.stride,this.offset)\\\n}\"\n\nfunction compileConstructor(dtype, dimension) {\n  //Special case for 0d arrays\n  if(dimension === 0) {\n    var compiledProc = new Function([\n      ZeroArray,\n      \"ZeroArray.prototype.dtype='\"+dtype+\"'\",\n      \"return function construct_ZeroArray(a,b,c,d){return new ZeroArray(a,d)}\"].join(\"\\n\"))\n    return compiledProc()\n  }\n  var useGetters = (dtype === \"generic\")\n  var code = [\"'use strict'\"]\n    \n  //Create constructor for view\n  var indices = iota(dimension)\n  var args = indices.map(function(i) { return \"i\"+i })\n  var index_str = \"this.offset+\" + indices.map(function(i) {\n        return [\"this._stride\", i, \"*i\",i].join(\"\")\n      }).join(\"+\")\n  var className = [\"View\", dimension, \"d\", dtype].join(\"\")\n  code.push([\"function \", className, \"(a,\",\n    indices.map(function(i) {\n      return \"b\"+i\n    }).join(\",\"), \",\",\n    indices.map(function(i) {\n      return \"c\"+i\n    }).join(\",\"), \",d){this.data=a\"].join(\"\"))\n  for(var i=0; i<dimension; ++i) {\n    code.push([\"this._shape\",i,\"=b\",i,\"|0\"].join(\"\"))\n  }\n  for(var i=0; i<dimension; ++i) {\n    code.push([\"this._stride\",i,\"=c\",i,\"|0\"].join(\"\"))\n  }\n  code.push(\"this.offset=d|0}\")\n  \n  //Get prototype\n  code.push([\"var proto=\",className,\".prototype\"].join(\"\"))\n  \n  //view.dtype:\n  code.push([\"proto.dtype='\", dtype, \"'\"].join(\"\"))\n  code.push(\"proto.dimension=\"+dimension)\n  \n  //view.stride and view.shape\n  var strideClassName = [\"VStride\", dimension, \"d\", dtype].join(\"\")\n  var shapeClassName = [\"VShape\", dimension, \"d\", dtype].join(\"\")\n  var props = {\"stride\":strideClassName, \"shape\":shapeClassName}\n  for(var prop in props) {\n    var arrayName = props[prop]\n    code.push([\"function \", arrayName, \"(v) {this._v=v} var aproto=\", arrayName, \".prototype\"].join(\"\"))\n    code.push([\"aproto.length=\",dimension].join(\"\"))\n    \n    var array_elements = []\n    for(var i=0; i<dimension; ++i) {\n      array_elements.push([\"this._v._\", prop, i].join(\"\"))\n    }\n    code.push([\"aproto.toJSON=function \", arrayName, \"_toJSON(){return [\", array_elements.join(\",\"), \"]}\"].join(\"\"))\n    code.push([\"aproto.toString=function \", arrayName, \"_toString(){return [\", array_elements.join(\",\"), \"].join()}\"].join(\"\"))\n    \n    for(var i=0; i<dimension; ++i) {\n      code.push([\"Object.defineProperty(aproto,\", i, \",{get:function(){return this._v._\", prop, i, \"},set:function(v){return this._v._\", prop, i, \"=v|0},enumerable:true})\"].join(\"\"))\n    }\n    for(var i=0; i<arrayMethods.length; ++i) {\n      if(arrayMethods[i] in Array.prototype) {\n        code.push([\"aproto.\", arrayMethods[i], \"=Array.prototype.\", arrayMethods[i]].join(\"\"))\n      }\n    }\n    code.push([\"Object.defineProperty(proto,'\",prop,\"',{get:function \", arrayName, \"_get(){return new \", arrayName, \"(this)},set: function \", arrayName, \"_set(v){\"].join(\"\"))\n    for(var i=0; i<dimension; ++i) {\n      code.push([\"this._\", prop, i, \"=v[\", i, \"]|0\"].join(\"\"))\n    }\n    code.push(\"return v}})\")\n  }\n  \n  //view.size:\n  code.push([\"Object.defineProperty(proto,'size',{get:function \",className,\"_size(){\\\nreturn \", indices.map(function(i) { return [\"this._shape\", i].join(\"\") }).join(\"*\"),\n\"}})\"].join(\"\"))\n\n  //view.order:\n  if(dimension === 1) {\n    code.push(\"proto.order=[0]\")\n  } else {\n    code.push(\"Object.defineProperty(proto,'order',{get:\")\n    if(dimension < 4) {\n      code.push([\"function \",className,\"_order(){\"].join(\"\"))\n      if(dimension === 2) {\n        code.push(\"return (Math.abs(this._stride0)>Math.abs(this._stride1))?[1,0]:[0,1]}})\")\n      } else if(dimension === 3) {\n        code.push(\n\"var s0=Math.abs(this._stride0),s1=Math.abs(this._stride1),s2=Math.abs(this._stride2);\\\nif(s0>s1){\\\nif(s1>s2){\\\nreturn [2,1,0];\\\n}else if(s0>s2){\\\nreturn [1,2,0];\\\n}else{\\\nreturn [1,0,2];\\\n}\\\n}else if(s0>s2){\\\nreturn [2,0,1];\\\n}else if(s2>s1){\\\nreturn [0,1,2];\\\n}else{\\\nreturn [0,2,1];\\\n}}})\")\n      }\n    } else {\n      code.push(\"ORDER})\")\n    }\n  }\n  \n  //view.set(i0, ..., v):\n  code.push([\n\"proto.set=function \",className,\"_set(\", args.join(\",\"), \",v){\"].join(\"\"))\n  if(useGetters) {\n    code.push([\"return this.data.set(\", index_str, \",v)}\"].join(\"\"))\n  } else {\n    code.push([\"return this.data[\", index_str, \"]=v}\"].join(\"\"))\n  }\n  \n  //view.get(i0, ...):\n  code.push([\"proto.get=function \",className,\"_get(\", args.join(\",\"), \"){\"].join(\"\"))\n  if(useGetters) {\n    code.push([\"return this.data.get(\", index_str, \")}\"].join(\"\"))\n  } else {\n    code.push([\"return this.data[\", index_str, \"]}\"].join(\"\"))\n  }\n  \n  //view.hi():\n  code.push([\"proto.hi=function \",className,\"_hi(\",args.join(\",\"),\"){return new \", className, \"(this.data,\",\n    indices.map(function(i) {\n      return [\"(typeof i\",i,\"!=='number'||i\",i,\"<0)?this._shape\", i, \":i\", i,\"|0\"].join(\"\")\n    }).join(\",\"), \",\",\n    indices.map(function(i) {\n      return \"this._stride\"+i\n    }).join(\",\"), \",this.offset)}\"].join(\"\"))\n  \n  //view.lo():\n  var a_vars = indices.map(function(i) { return \"a\"+i+\"=this._shape\"+i })\n  var c_vars = indices.map(function(i) { return \"c\"+i+\"=this._stride\"+i })\n  code.push([\"proto.lo=function \",className,\"_lo(\",args.join(\",\"),\"){var b=this.offset,d=0,\", a_vars.join(\",\"), \",\", c_vars.join(\",\")].join(\"\"))\n  for(var i=0; i<dimension; ++i) {\n    code.push([\n\"if(typeof i\",i,\"==='number'&&i\",i,\">=0){\\\nd=i\",i,\"|0;\\\nb+=c\",i,\"*d;\\\na\",i,\"-=d}\"].join(\"\"))\n  }\n  code.push([\"return new \", className, \"(this.data,\",\n    indices.map(function(i) {\n      return \"a\"+i\n    }).join(\",\"),\",\",\n    indices.map(function(i) {\n      return \"c\"+i\n    }).join(\",\"), \",b)}\"].join(\"\"))\n  \n  //view.step():\n  code.push([\"proto.step=function \",className,\"_step(\",args.join(\",\"),\"){var \",\n    indices.map(function(i) {\n      return \"a\"+i+\"=this._shape\"+i\n    }).join(\",\"), \",\",\n    indices.map(function(i) {\n      return \"b\"+i+\"=this._stride\"+i\n    }).join(\",\"),\",c=this.offset,d=0,ceil=Math.ceil\"].join(\"\"))\n  for(var i=0; i<dimension; ++i) {\n    code.push([\n\"if(typeof i\",i,\"==='number'){\\\nd=i\",i,\"|0;\\\nif(d<0){\\\nc+=b\",i,\"*(a\",i,\"-1);\\\na\",i,\"=ceil(-a\",i,\"/d)\\\n}else{\\\na\",i,\"=ceil(a\",i,\"/d)\\\n}\\\nb\",i,\"*=d\\\n}\"].join(\"\"))\n  }\n  code.push([\"return new \", className, \"(this.data,\",\n    indices.map(function(i) {\n      return \"a\" + i\n    }).join(\",\"), \",\",\n    indices.map(function(i) {\n      return \"b\" + i\n    }).join(\",\"), \",c)}\"].join(\"\"))\n  \n  //view.transpose():\n  var tShape = new Array(dimension)\n  var tStride = new Array(dimension)\n  for(var i=0; i<dimension; ++i) {\n    tShape[i] = [\"a[i\", i, \"|0]\"].join(\"\")\n    tStride[i] = [\"b[i\", i, \"|0]\"].join(\"\")\n  }\n  code.push([\"proto.transpose=function \",className,\"_transpose(\",args,\"){var a=this.shape,b=this.stride;return new \", className, \"(this.data,\", tShape.join(\",\"), \",\", tStride.join(\",\"), \",this.offset)}\"].join(\"\"))\n  \n  //view.pick():\n  code.push([\"proto.pick=function \",className,\"_pick(\",args,\"){var a=[],b=[],c=this.offset\"].join(\"\"))\n  for(var i=0; i<dimension; ++i) {\n    code.push([\"if(typeof i\",i,\"==='number'&&i\",i,\">=0){c=(c+this._stride\",i,\"*i\",i,\")|0}else{a.push(this._shape\",i,\");b.push(this._stride\",i,\")}\"].join(\"\"))\n  }\n  code.push(\"var ctor=CTOR_LIST[a.length];return ctor(this.data,a,b,c)}\")\n    \n  //Add return statement\n  code.push([\"return function construct_\",className,\"(data,shape,stride,offset){return new \", className,\"(data,\",\n    indices.map(function(i) {\n      return \"shape[\"+i+\"]\"\n    }).join(\",\"), \",\",\n    indices.map(function(i) {\n      return \"stride[\"+i+\"]\"\n    }).join(\",\"), \",offset)}\"].join(\"\"))\n  \n  //Compile procedure\n  var procedure = new Function(\"CTOR_LIST\", \"ORDER\", code.join(\"\\n\"))\n  return procedure(CACHED_CONSTRUCTORS[dtype], order)\n}\n\nfunction arrayDType(data) {\n  if(data instanceof Float64Array) {\n    return \"float64\";\n  } else if(data instanceof Float32Array) {\n    return \"float32\"\n  } else if(data instanceof Int32Array) {\n    return \"int32\"\n  } else if(data instanceof Uint32Array) {\n    return \"uint32\"\n  } else if(data instanceof Uint8Array) {\n    return \"uint8\"\n  } else if(data instanceof Uint16Array) {\n    return \"uint16\"\n  } else if(data instanceof Int16Array) {\n    return \"int16\"\n  } else if(data instanceof Int8Array) {\n    return \"int8\"\n  } else if(data instanceof Array) {\n    return \"array\"\n  }\n  return \"generic\"\n}\n\nvar CACHED_CONSTRUCTORS = {\n  \"float32\":[],\n  \"float64\":[],\n  \"int8\":[],\n  \"int16\":[],\n  \"int32\":[],\n  \"uint8\":[],\n  \"uint16\":[],\n  \"uint32\":[],\n  \"array\":[],\n  \"generic\":[]\n}\n\nfunction wrappedNDArrayCtor(data, shape, stride, offset) {\n  if(shape === undefined) {\n    shape = [ data.length ]\n  }\n  var d = shape.length\n  if(stride === undefined) {\n    stride = new Array(d)\n    for(var i=d-1, sz=1; i>=0; --i) {\n      stride[i] = sz\n      sz *= shape[i]\n    }\n  }\n  if(offset === undefined) {\n    offset = 0\n    for(var i=0; i<d; ++i) {\n      if(stride[i] < 0) {\n        offset -= (shape[i]-1)*stride[i]\n      }\n    }\n  }\n  var dtype = arrayDType(data)\n  var ctor_list = CACHED_CONSTRUCTORS[dtype]\n  while(ctor_list.length <= d) {\n    ctor_list.push(compileConstructor(dtype, ctor_list.length))\n  }\n  var ctor = ctor_list[d]\n  return ctor(data, shape, stride, offset)\n}\n\nmodule.exports = wrappedNDArrayCtor","\"use strict\"\n\nvar parse   = require(\"cwise-parser\")\nvar compile = require(\"cwise-compiler\")\n\nvar REQUIRED_FIELDS = [ \"args\", \"body\" ]\nvar OPTIONAL_FIELDS = [ \"pre\", \"post\", \"printCode\", \"funcName\", \"blockSize\" ]\n\nfunction createCWise(user_args) {\n  //Check parameters\n  for(var id in user_args) {\n    if(REQUIRED_FIELDS.indexOf(id) < 0 &&\n       OPTIONAL_FIELDS.indexOf(id) < 0) {\n      console.warn(\"cwise: Unknown argument '\"+id+\"' passed to expression compiler\")\n    }\n  }\n  for(var i=0; i<REQUIRED_FIELDS.length; ++i) {\n    if(!user_args[REQUIRED_FIELDS[i]]) {\n      throw new Error(\"cwise: Missing argument: \" + REQUIRED_FIELDS[i])\n    }\n  }\n  \n  //Parse blocks\n  return compile({\n    args:       user_args.args,\n    pre:        parse(user_args.pre || function(){}),\n    body:       parse(user_args.body),\n    post:       parse(user_args.post || function(){}),\n    debug:      !!user_args.printCode,\n    funcName:   user_args.funcName || user_args.body.name || \"cwise\",\n    blockSize:  user_args.blockSize || 64\n  })\n}\n\nmodule.exports = createCWise\n","\"use strict\"\n\nfunction iota(n) {\n  var result = new Array(n)\n  for(var i=0; i<n; ++i) {\n    result[i] = i\n  }\n  return result\n}\n\nmodule.exports = iota","\"use strict\"\n\nvar createThunk = require(\"./lib/thunk.js\")\n\nfunction Procedure() {\n  this.argTypes = []\n  this.shimArgs = []\n  this.arrayArgs = []\n  this.scalarArgs = []\n  this.indexArgs = []\n  this.shapeArgs = []\n  this.funcName = \"\"\n  this.pre = null\n  this.body = null\n  this.post = null\n  this.debug = false\n}\n\nfunction compileCwise(user_args) {\n  //Create procedure\n  var proc = new Procedure()\n  \n  //Parse blocks\n  proc.pre    = user_args.pre\n  proc.body   = user_args.body\n  proc.post   = user_args.post\n\n  //Parse arguments\n  var proc_args = user_args.args.slice(0)\n  proc.argTypes = proc_args\n  for(var i=0; i<proc_args.length; ++i) {\n    switch(proc_args[i]) {\n      case \"array\":\n        proc.arrayArgs.push(i)\n        proc.shimArgs.push(\"array\" + i)\n        if(i < proc.pre.args.length && proc.pre.args[i].count>0) {\n          throw new Error(\"cwise: pre() block may not reference array args\")\n        }\n        if(i < proc.post.args.length && proc.post.args[i].count>0) {\n          throw new Error(\"cwise: post() block may not reference array args\")\n        }\n      break\n      case \"scalar\":\n        proc.scalarArgs.push(i)\n        proc.shimArgs.push(\"scalar\" + i)\n      break\n      case \"index\":\n        proc.indexArgs.push(i)\n        if(i < proc.pre.args.length && proc.pre.args[i].count > 0) {\n          throw new Error(\"cwise: pre() block may not reference array index\")\n        }\n        if(i < proc.body.args.length && proc.body.args[i].lvalue) {\n          throw new Error(\"cwise: body() block may not write to array index\")\n        }\n        if(i < proc.post.args.length && proc.post.args[i].count > 0) {\n          throw new Error(\"cwise: post() block may not reference array index\")\n        }\n      break\n      case \"shape\":\n        proc.shapeArgs.push(i)\n        if(i < proc.pre.args.length && proc.pre.args[i].lvalue) {\n          throw new Error(\"cwise: pre() block may not write to array shape\")\n        }\n        if(i < proc.body.args.length && proc.body.args[i].lvalue) {\n          throw new Error(\"cwise: body() block may not write to array shape\")\n        }\n        if(i < proc.post.args.length && proc.post.args[i].lvalue) {\n          throw new Error(\"cwise: post() block may not write to array shape\")\n        }\n      break\n      default:\n        throw new Error(\"cwise: Unknown argument type \" + proc_args[i])\n    }\n  }\n  \n  //Make sure at least one array argument was specified\n  if(proc.arrayArgs.length <= 0) {\n    throw new Error(\"cwise: No array arguments specified\")\n  }\n  \n  //Make sure arguments are correct\n  if(proc.pre.args.length > proc_args.length) {\n    throw new Error(\"cwise: Too many arguments in pre() block\")\n  }\n  if(proc.body.args.length > proc_args.length) {\n    throw new Error(\"cwise: Too many arguments in body() block\")\n  }\n  if(proc.post.args.length > proc_args.length) {\n    throw new Error(\"cwise: Too many arguments in post() block\")\n  }\n\n  //Check debug flag\n  proc.debug = !!user_args.printCode || !!user_args.debug\n  \n  //Retrieve name\n  proc.funcName = user_args.funcName || \"cwise\"\n  \n  //Read in block size\n  proc.blockSize = user_args.blockSize || 64\n\n  return createThunk(proc)\n}\n\nmodule.exports = compileCwise\n","\"use strict\"\n\nvar createThunk = require(\"./lib/thunk.js\")\n\nfunction Procedure() {\n  this.argTypes = []\n  this.shimArgs = []\n  this.arrayArgs = []\n  this.scalarArgs = []\n  this.indexArgs = []\n  this.shapeArgs = []\n  this.funcName = \"\"\n  this.pre = null\n  this.body = null\n  this.post = null\n  this.debug = false\n}\n\nfunction compileCwise(user_args) {\n  //Create procedure\n  var proc = new Procedure()\n  \n  //Parse blocks\n  proc.pre    = user_args.pre\n  proc.body   = user_args.body\n  proc.post   = user_args.post\n\n  //Parse arguments\n  var proc_args = user_args.args.slice(0)\n  proc.argTypes = proc_args\n  for(var i=0; i<proc_args.length; ++i) {\n    switch(proc_args[i]) {\n      case \"array\":\n        proc.arrayArgs.push(i)\n        proc.shimArgs.push(\"array\" + i)\n        if(i < proc.pre.args.length && proc.pre.args[i].count>0) {\n          throw new Error(\"cwise: pre() block may not reference array args\")\n        }\n        if(i < proc.post.args.length && proc.post.args[i].count>0) {\n          throw new Error(\"cwise: post() block may not reference array args\")\n        }\n      break\n      case \"scalar\":\n        proc.scalarArgs.push(i)\n        proc.shimArgs.push(\"scalar\" + i)\n      break\n      case \"index\":\n        proc.indexArgs.push(i)\n        if(i < proc.pre.args.length && proc.pre.args[i].count > 0) {\n          throw new Error(\"cwise: pre() block may not reference array index\")\n        }\n        if(i < proc.body.args.length && proc.body.args[i].lvalue) {\n          throw new Error(\"cwise: body() block may not write to array index\")\n        }\n        if(i < proc.post.args.length && proc.post.args[i].count > 0) {\n          throw new Error(\"cwise: post() block may not reference array index\")\n        }\n      break\n      case \"shape\":\n        proc.shapeArgs.push(i)\n        if(i < proc.pre.args.length && proc.pre.args[i].lvalue) {\n          throw new Error(\"cwise: pre() block may not write to array shape\")\n        }\n        if(i < proc.body.args.length && proc.body.args[i].lvalue) {\n          throw new Error(\"cwise: body() block may not write to array shape\")\n        }\n        if(i < proc.post.args.length && proc.post.args[i].lvalue) {\n          throw new Error(\"cwise: post() block may not write to array shape\")\n        }\n      break\n      default:\n        throw new Error(\"cwise: Unknown argument type \" + proc_args[i])\n    }\n  }\n  \n  //Make sure at least one array argument was specified\n  if(proc.arrayArgs.length <= 0) {\n    throw new Error(\"cwise: No array arguments specified\")\n  }\n  \n  //Make sure arguments are correct\n  if(proc.pre.args.length > proc_args.length) {\n    throw new Error(\"cwise: Too many arguments in pre() block\")\n  }\n  if(proc.body.args.length > proc_args.length) {\n    throw new Error(\"cwise: Too many arguments in body() block\")\n  }\n  if(proc.post.args.length > proc_args.length) {\n    throw new Error(\"cwise: Too many arguments in post() block\")\n  }\n\n  //Check debug flag\n  proc.debug = !!user_args.printCode || !!user_args.debug\n  \n  //Retrieve name\n  proc.funcName = user_args.funcName || \"cwise\"\n  \n  //Read in block size\n  proc.blockSize = user_args.blockSize || 64\n\n  return createThunk(proc)\n}\n\nmodule.exports = compileCwise\n","\"use strict\"\n\nvar esprima = require(\"esprima\")\nvar uniq = require(\"uniq\")\n\nvar PREFIX_COUNTER = 0\n\nfunction CompiledArgument(name, lvalue, rvalue) {\n  this.name = name\n  this.lvalue = lvalue\n  this.rvalue = rvalue\n  this.count = 0\n}\n\nfunction CompiledRoutine(body, args, thisVars, localVars) {\n  this.body = body\n  this.args = args\n  this.thisVars = thisVars\n  this.localVars = localVars\n}\n\nfunction isGlobal(identifier) {\n  if(identifier === \"eval\") {\n    throw new Error(\"cwise-parser: eval() not allowed\")\n  }\n  if(typeof window !== \"undefined\") {\n    return identifier in window\n  } else if(typeof GLOBAL !== \"undefined\") {\n    return identifier in GLOBAL\n  } else if(typeof self !== \"undefined\") {\n    return identifier in self\n  } else {\n    return false\n  }\n}\n\nfunction getArgNames(ast) {\n  var params = ast.body[0].expression.callee.params\n  var names = new Array(params.length)\n  for(var i=0; i<params.length; ++i) {\n    names[i] = params[i].name\n  }\n  return names\n}\n\nfunction preprocess(func) {\n  var src = [\"(\", func, \")()\"].join(\"\")\n  var ast = esprima.parse(src, { range: true })\n  \n  //Compute new prefix\n  var prefix = \"_inline_\" + (PREFIX_COUNTER++) + \"_\"\n  \n  //Parse out arguments\n  var argNames = getArgNames(ast)\n  var compiledArgs = new Array(argNames.length)\n  for(var i=0; i<argNames.length; ++i) {\n    compiledArgs[i] = new CompiledArgument([prefix, \"arg\", i, \"_\"].join(\"\"), false, false)\n  }\n  \n  //Create temporary data structure for source rewriting\n  var exploded = new Array(src.length)\n  for(var i=0, n=src.length; i<n; ++i) {\n    exploded[i] = src.charAt(i)\n  }\n  \n  //Local variables\n  var localVars = []\n  var thisVars = []\n  var computedThis = false\n  \n  //Retrieves a local variable\n  function createLocal(id) {\n    var nstr = prefix + id.replace(/\\_/g, \"__\")\n    localVars.push(nstr)\n    return nstr\n  }\n  \n  //Creates a this variable\n  function createThisVar(id) {\n    var nstr = \"this_\" + id.replace(/\\_/g, \"__\")\n    thisVars.push(nstr)\n    return nstr\n  }\n  \n  //Rewrites an ast node\n  function rewrite(node, nstr) {\n    var lo = node.range[0], hi = node.range[1]\n    for(var i=lo+1; i<hi; ++i) {\n      exploded[i] = \"\"\n    }\n    exploded[lo] = nstr\n  }\n  \n  //Remove any underscores\n  function escapeString(str) {\n    return \"'\"+(str.replace(/\\_/g, \"\\\\_\").replace(/\\'/g, \"\\'\"))+\"'\"\n  }\n  \n  //Returns the source of an identifier\n  function source(node) {\n    return exploded.slice(node.range[0], node.range[1]).join(\"\")\n  }\n  \n  //Computes the usage of a node\n  var LVALUE = 1\n  var RVALUE = 2\n  function getUsage(node) {\n    if(node.parent.type === \"AssignmentExpression\") {\n      if(node.parent.left === node) {\n        if(node.parent.operator === \"=\") {\n          return LVALUE\n        }\n        return LVALUE|RVALUE\n      }\n    }\n    if(node.parent.type === \"UpdateExpression\") {\n      return LVALUE|RVALUE\n    }\n    return RVALUE\n  }\n  \n  //Handle visiting a node\n  (function visit(node, parent) {\n    node.parent = parent\n    if(node.type === \"MemberExpression\") {\n      //Handle member expression\n      if(node.computed) {\n        visit(node.object, node)\n        visit(node.property, node)\n      } else if(node.object.type === \"ThisExpression\") {\n        rewrite(node, createThisVar(node.property.name))\n      } else {\n        visit(node.object, node)\n      }\n    } else if(node.type === \"ThisExpression\") {\n      throw new Error(\"cwise-parser: Computed this is not allowed\")\n    } else if(node.type === \"Identifier\") {\n      //Handle identifier\n      var name = node.name\n      var argNo = argNames.indexOf(name)\n      if(argNo >= 0) {\n        var carg = compiledArgs[argNo]\n        var usage = getUsage(node)\n        if(usage & LVALUE) {\n          carg.lvalue = true\n        }\n        if(usage & RVALUE) {\n          carg.rvalue = true\n        }\n        ++carg.count\n        rewrite(node, carg.name)\n      } else if(isGlobal(name)) {\n        //Don't rewrite globals\n      } else {\n        rewrite(node, createLocal(name))\n      }\n    } else if(node.type === \"Literal\") {\n      if(typeof node.value === \"string\") {\n        rewrite(node, escapeString(node.value))\n      }\n    } else if(node.type === \"WithStatement\") {\n      throw new Error(\"cwise-parser: with() statements not allowed\")\n    } else {\n      //Visit all children\n      var keys = Object.keys(node)\n      for(var i=0, n=keys.length; i<n; ++i) {\n        if(keys[i] === \"parent\") {\n          continue\n        }\n        var value = node[keys[i]]\n        if(value) {\n          if(value instanceof Array) {\n            for(var j=0; j<value.length; ++j) {\n              if(value[j] && typeof value[j].type === \"string\") {\n                visit(value[j], node)\n              }\n            }\n          } else if(typeof value.type === \"string\") {\n            visit(value, node)\n          }\n        }\n      }\n    }\n  })(ast.body[0].expression.callee.body, undefined)\n  \n  //Remove duplicate variables\n  uniq(localVars)\n  uniq(thisVars)\n  \n  //Return body\n  var routine = new CompiledRoutine(source(ast.body[0].expression.callee.body), compiledArgs, thisVars, localVars)\n  return routine\n}\n\nmodule.exports = preprocess","\"use strict\"\n\nvar esprima = require(\"esprima\")\nvar uniq = require(\"uniq\")\n\nvar PREFIX_COUNTER = 0\n\nfunction CompiledArgument(name, lvalue, rvalue) {\n  this.name = name\n  this.lvalue = lvalue\n  this.rvalue = rvalue\n  this.count = 0\n}\n\nfunction CompiledRoutine(body, args, thisVars, localVars) {\n  this.body = body\n  this.args = args\n  this.thisVars = thisVars\n  this.localVars = localVars\n}\n\nfunction isGlobal(identifier) {\n  if(identifier === \"eval\") {\n    throw new Error(\"cwise-parser: eval() not allowed\")\n  }\n  if(typeof window !== \"undefined\") {\n    return identifier in window\n  } else if(typeof GLOBAL !== \"undefined\") {\n    return identifier in GLOBAL\n  } else if(typeof self !== \"undefined\") {\n    return identifier in self\n  } else {\n    return false\n  }\n}\n\nfunction getArgNames(ast) {\n  var params = ast.body[0].expression.callee.params\n  var names = new Array(params.length)\n  for(var i=0; i<params.length; ++i) {\n    names[i] = params[i].name\n  }\n  return names\n}\n\nfunction preprocess(func) {\n  var src = [\"(\", func, \")()\"].join(\"\")\n  var ast = esprima.parse(src, { range: true })\n  \n  //Compute new prefix\n  var prefix = \"_inline_\" + (PREFIX_COUNTER++) + \"_\"\n  \n  //Parse out arguments\n  var argNames = getArgNames(ast)\n  var compiledArgs = new Array(argNames.length)\n  for(var i=0; i<argNames.length; ++i) {\n    compiledArgs[i] = new CompiledArgument([prefix, \"arg\", i, \"_\"].join(\"\"), false, false)\n  }\n  \n  //Create temporary data structure for source rewriting\n  var exploded = new Array(src.length)\n  for(var i=0, n=src.length; i<n; ++i) {\n    exploded[i] = src.charAt(i)\n  }\n  \n  //Local variables\n  var localVars = []\n  var thisVars = []\n  var computedThis = false\n  \n  //Retrieves a local variable\n  function createLocal(id) {\n    var nstr = prefix + id.replace(/\\_/g, \"__\")\n    localVars.push(nstr)\n    return nstr\n  }\n  \n  //Creates a this variable\n  function createThisVar(id) {\n    var nstr = \"this_\" + id.replace(/\\_/g, \"__\")\n    thisVars.push(nstr)\n    return nstr\n  }\n  \n  //Rewrites an ast node\n  function rewrite(node, nstr) {\n    var lo = node.range[0], hi = node.range[1]\n    for(var i=lo+1; i<hi; ++i) {\n      exploded[i] = \"\"\n    }\n    exploded[lo] = nstr\n  }\n  \n  //Remove any underscores\n  function escapeString(str) {\n    return \"'\"+(str.replace(/\\_/g, \"\\\\_\").replace(/\\'/g, \"\\'\"))+\"'\"\n  }\n  \n  //Returns the source of an identifier\n  function source(node) {\n    return exploded.slice(node.range[0], node.range[1]).join(\"\")\n  }\n  \n  //Computes the usage of a node\n  var LVALUE = 1\n  var RVALUE = 2\n  function getUsage(node) {\n    if(node.parent.type === \"AssignmentExpression\") {\n      if(node.parent.left === node) {\n        if(node.parent.operator === \"=\") {\n          return LVALUE\n        }\n        return LVALUE|RVALUE\n      }\n    }\n    if(node.parent.type === \"UpdateExpression\") {\n      return LVALUE|RVALUE\n    }\n    return RVALUE\n  }\n  \n  //Handle visiting a node\n  (function visit(node, parent) {\n    node.parent = parent\n    if(node.type === \"MemberExpression\") {\n      //Handle member expression\n      if(node.computed) {\n        visit(node.object, node)\n        visit(node.property, node)\n      } else if(node.object.type === \"ThisExpression\") {\n        rewrite(node, createThisVar(node.property.name))\n      } else {\n        visit(node.object, node)\n      }\n    } else if(node.type === \"ThisExpression\") {\n      throw new Error(\"cwise-parser: Computed this is not allowed\")\n    } else if(node.type === \"Identifier\") {\n      //Handle identifier\n      var name = node.name\n      var argNo = argNames.indexOf(name)\n      if(argNo >= 0) {\n        var carg = compiledArgs[argNo]\n        var usage = getUsage(node)\n        if(usage & LVALUE) {\n          carg.lvalue = true\n        }\n        if(usage & RVALUE) {\n          carg.rvalue = true\n        }\n        ++carg.count\n        rewrite(node, carg.name)\n      } else if(isGlobal(name)) {\n        //Don't rewrite globals\n      } else {\n        rewrite(node, createLocal(name))\n      }\n    } else if(node.type === \"Literal\") {\n      if(typeof node.value === \"string\") {\n        rewrite(node, escapeString(node.value))\n      }\n    } else if(node.type === \"WithStatement\") {\n      throw new Error(\"cwise-parser: with() statements not allowed\")\n    } else {\n      //Visit all children\n      var keys = Object.keys(node)\n      for(var i=0, n=keys.length; i<n; ++i) {\n        if(keys[i] === \"parent\") {\n          continue\n        }\n        var value = node[keys[i]]\n        if(value) {\n          if(value instanceof Array) {\n            for(var j=0; j<value.length; ++j) {\n              if(value[j] && typeof value[j].type === \"string\") {\n                visit(value[j], node)\n              }\n            }\n          } else if(typeof value.type === \"string\") {\n            visit(value, node)\n          }\n        }\n      }\n    }\n  })(ast.body[0].expression.callee.body, undefined)\n  \n  //Remove duplicate variables\n  uniq(localVars)\n  uniq(thisVars)\n  \n  //Return body\n  var routine = new CompiledRoutine(source(ast.body[0].expression.callee.body), compiledArgs, thisVars, localVars)\n  return routine\n}\n\nmodule.exports = preprocess","\"use strict\"\n\nvar compile = require(\"./compile.js\")\n\nfunction createThunk(proc) {\n  var code = [\"'use strict'\", \"var CACHED={}\"]\n  var vars = []\n  var thunkName = proc.funcName + \"_cwise_thunk\"\n  \n  //Build thunk\n  code.push([\"return function \", thunkName, \"(\", proc.shimArgs.join(\",\"), \"){\"].join(\"\"))\n  var typesig = []\n  var string_typesig = []\n  var proc_args = [[\"array\",proc.arrayArgs[0],\".shape\"].join(\"\")]\n  for(var i=0; i<proc.arrayArgs.length; ++i) {\n    var j = proc.arrayArgs[i]\n    vars.push([\"t\", j, \"=array\", j, \".dtype,\",\n               \"r\", j, \"=array\", j, \".order\"].join(\"\"))\n    typesig.push(\"t\" + j)\n    typesig.push(\"r\" + j)\n    string_typesig.push(\"t\"+j)\n    string_typesig.push(\"r\"+j+\".join()\")\n    proc_args.push(\"array\" + j + \".data\")\n    proc_args.push(\"array\" + j + \".stride\")\n    proc_args.push(\"array\" + j + \".offset|0\")\n  }\n  for(var i=0; i<proc.scalarArgs.length; ++i) {\n    proc_args.push(\"scalar\" + proc.scalarArgs[i])\n  }\n  vars.push([\"type=[\", string_typesig.join(\",\"), \"].join()\"].join(\"\"))\n  vars.push(\"proc=CACHED[type]\")\n  code.push(\"var \" + vars.join(\",\"))\n  \n  code.push([\"if(!proc){\",\n             \"CACHED[type]=proc=compile([\", typesig.join(\",\"), \"])}\",\n             \"return proc(\", proc_args.join(\",\"), \")}\"].join(\"\"))\n\n  if(proc.debug) {\n    console.log(\"Generated thunk:\", code.join(\"\\n\"))\n  }\n  \n  //Compile thunk\n  var thunk = new Function(\"compile\", code.join(\"\\n\"))\n  return thunk(compile.bind(undefined, proc))\n}\n\nmodule.exports = createThunk\n","(function(){/*\n  Copyright (C) 2012 Ariya Hidayat <ariya.hidayat@gmail.com>\n  Copyright (C) 2012 Mathias Bynens <mathias@qiwi.be>\n  Copyright (C) 2012 Joost-Wim Boekesteijn <joost-wim@boekesteijn.nl>\n  Copyright (C) 2012 Kris Kowal <kris.kowal@cixar.com>\n  Copyright (C) 2012 Yusuke Suzuki <utatane.tea@gmail.com>\n  Copyright (C) 2012 Arpad Borsos <arpad.borsos@googlemail.com>\n  Copyright (C) 2011 Ariya Hidayat <ariya.hidayat@gmail.com>\n\n  Redistribution and use in source and binary forms, with or without\n  modification, are permitted provided that the following conditions are met:\n\n    * Redistributions of source code must retain the above copyright\n      notice, this list of conditions and the following disclaimer.\n    * Redistributions in binary form must reproduce the above copyright\n      notice, this list of conditions and the following disclaimer in the\n      documentation and/or other materials provided with the distribution.\n\n  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY\n  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\n  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n*/\n\n/*jslint bitwise:true plusplus:true */\n/*global esprima:true, define:true, exports:true, window: true,\nthrowError: true, createLiteral: true, generateStatement: true,\nparseAssignmentExpression: true, parseBlock: true, parseExpression: true,\nparseFunctionDeclaration: true, parseFunctionExpression: true,\nparseFunctionSourceElements: true, parseVariableIdentifier: true,\nparseLeftHandSideExpression: true,\nparseStatement: true, parseSourceElement: true */\n\n(function (root, factory) {\n    'use strict';\n\n    // Universal Module Definition (UMD) to support AMD, CommonJS/Node.js,\n    // Rhino, and plain browser loading.\n    if (typeof define === 'function' && define.amd) {\n        define(['exports'], factory);\n    } else if (typeof exports !== 'undefined') {\n        factory(exports);\n    } else {\n        factory((root.esprima = {}));\n    }\n}(this, function (exports) {\n    'use strict';\n\n    var Token,\n        TokenName,\n        Syntax,\n        PropertyKind,\n        Messages,\n        Regex,\n        source,\n        strict,\n        index,\n        lineNumber,\n        lineStart,\n        length,\n        buffer,\n        state,\n        extra;\n\n    Token = {\n        BooleanLiteral: 1,\n        EOF: 2,\n        Identifier: 3,\n        Keyword: 4,\n        NullLiteral: 5,\n        NumericLiteral: 6,\n        Punctuator: 7,\n        StringLiteral: 8\n    };\n\n    TokenName = {};\n    TokenName[Token.BooleanLiteral] = 'Boolean';\n    TokenName[Token.EOF] = '<end>';\n    TokenName[Token.Identifier] = 'Identifier';\n    TokenName[Token.Keyword] = 'Keyword';\n    TokenName[Token.NullLiteral] = 'Null';\n    TokenName[Token.NumericLiteral] = 'Numeric';\n    TokenName[Token.Punctuator] = 'Punctuator';\n    TokenName[Token.StringLiteral] = 'String';\n\n    Syntax = {\n        AssignmentExpression: 'AssignmentExpression',\n        ArrayExpression: 'ArrayExpression',\n        BlockStatement: 'BlockStatement',\n        BinaryExpression: 'BinaryExpression',\n        BreakStatement: 'BreakStatement',\n        CallExpression: 'CallExpression',\n        CatchClause: 'CatchClause',\n        ConditionalExpression: 'ConditionalExpression',\n        ContinueStatement: 'ContinueStatement',\n        DoWhileStatement: 'DoWhileStatement',\n        DebuggerStatement: 'DebuggerStatement',\n        EmptyStatement: 'EmptyStatement',\n        ExpressionStatement: 'ExpressionStatement',\n        ForStatement: 'ForStatement',\n        ForInStatement: 'ForInStatement',\n        FunctionDeclaration: 'FunctionDeclaration',\n        FunctionExpression: 'FunctionExpression',\n        Identifier: 'Identifier',\n        IfStatement: 'IfStatement',\n        Literal: 'Literal',\n        LabeledStatement: 'LabeledStatement',\n        LogicalExpression: 'LogicalExpression',\n        MemberExpression: 'MemberExpression',\n        NewExpression: 'NewExpression',\n        ObjectExpression: 'ObjectExpression',\n        Program: 'Program',\n        Property: 'Property',\n        ReturnStatement: 'ReturnStatement',\n        SequenceExpression: 'SequenceExpression',\n        SwitchStatement: 'SwitchStatement',\n        SwitchCase: 'SwitchCase',\n        ThisExpression: 'ThisExpression',\n        ThrowStatement: 'ThrowStatement',\n        TryStatement: 'TryStatement',\n        UnaryExpression: 'UnaryExpression',\n        UpdateExpression: 'UpdateExpression',\n        VariableDeclaration: 'VariableDeclaration',\n        VariableDeclarator: 'VariableDeclarator',\n        WhileStatement: 'WhileStatement',\n        WithStatement: 'WithStatement'\n    };\n\n    PropertyKind = {\n        Data: 1,\n        Get: 2,\n        Set: 4\n    };\n\n    // Error messages should be identical to V8.\n    Messages = {\n        UnexpectedToken:  'Unexpected token %0',\n        UnexpectedNumber:  'Unexpected number',\n        UnexpectedString:  'Unexpected string',\n        UnexpectedIdentifier:  'Unexpected identifier',\n        UnexpectedReserved:  'Unexpected reserved word',\n        UnexpectedEOS:  'Unexpected end of input',\n        NewlineAfterThrow:  'Illegal newline after throw',\n        InvalidRegExp: 'Invalid regular expression',\n        UnterminatedRegExp:  'Invalid regular expression: missing /',\n        InvalidLHSInAssignment:  'Invalid left-hand side in assignment',\n        InvalidLHSInForIn:  'Invalid left-hand side in for-in',\n        MultipleDefaultsInSwitch: 'More than one default clause in switch statement',\n        NoCatchOrFinally:  'Missing catch or finally after try',\n        UnknownLabel: 'Undefined label \\'%0\\'',\n        Redeclaration: '%0 \\'%1\\' has already been declared',\n        IllegalContinue: 'Illegal continue statement',\n        IllegalBreak: 'Illegal break statement',\n        IllegalReturn: 'Illegal return statement',\n        StrictModeWith:  'Strict mode code may not include a with statement',\n        StrictCatchVariable:  'Catch variable may not be eval or arguments in strict mode',\n        StrictVarName:  'Variable name may not be eval or arguments in strict mode',\n        StrictParamName:  'Parameter name eval or arguments is not allowed in strict mode',\n        StrictParamDupe: 'Strict mode function may not have duplicate parameter names',\n        StrictFunctionName:  'Function name may not be eval or arguments in strict mode',\n        StrictOctalLiteral:  'Octal literals are not allowed in strict mode.',\n        StrictDelete:  'Delete of an unqualified identifier in strict mode.',\n        StrictDuplicateProperty:  'Duplicate data property in object literal not allowed in strict mode',\n        AccessorDataProperty:  'Object literal may not have data and accessor property with the same name',\n        AccessorGetSet:  'Object literal may not have multiple get/set accessors with the same name',\n        StrictLHSAssignment:  'Assignment to eval or arguments is not allowed in strict mode',\n        StrictLHSPostfix:  'Postfix increment/decrement may not have eval or arguments operand in strict mode',\n        StrictLHSPrefix:  'Prefix increment/decrement may not have eval or arguments operand in strict mode',\n        StrictReservedWord:  'Use of future reserved word in strict mode'\n    };\n\n    // See also tools/generate-unicode-regex.py.\n    Regex = {\n        NonAsciiIdentifierStart: new RegExp('[\\xaa\\xb5\\xba\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\u02c1\\u02c6-\\u02d1\\u02e0-\\u02e4\\u02ec\\u02ee\\u0370-\\u0374\\u0376\\u0377\\u037a-\\u037d\\u0386\\u0388-\\u038a\\u038c\\u038e-\\u03a1\\u03a3-\\u03f5\\u03f7-\\u0481\\u048a-\\u0527\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05d0-\\u05ea\\u05f0-\\u05f2\\u0620-\\u064a\\u066e\\u066f\\u0671-\\u06d3\\u06d5\\u06e5\\u06e6\\u06ee\\u06ef\\u06fa-\\u06fc\\u06ff\\u0710\\u0712-\\u072f\\u074d-\\u07a5\\u07b1\\u07ca-\\u07ea\\u07f4\\u07f5\\u07fa\\u0800-\\u0815\\u081a\\u0824\\u0828\\u0840-\\u0858\\u08a0\\u08a2-\\u08ac\\u0904-\\u0939\\u093d\\u0950\\u0958-\\u0961\\u0971-\\u0977\\u0979-\\u097f\\u0985-\\u098c\\u098f\\u0990\\u0993-\\u09a8\\u09aa-\\u09b0\\u09b2\\u09b6-\\u09b9\\u09bd\\u09ce\\u09dc\\u09dd\\u09df-\\u09e1\\u09f0\\u09f1\\u0a05-\\u0a0a\\u0a0f\\u0a10\\u0a13-\\u0a28\\u0a2a-\\u0a30\\u0a32\\u0a33\\u0a35\\u0a36\\u0a38\\u0a39\\u0a59-\\u0a5c\\u0a5e\\u0a72-\\u0a74\\u0a85-\\u0a8d\\u0a8f-\\u0a91\\u0a93-\\u0aa8\\u0aaa-\\u0ab0\\u0ab2\\u0ab3\\u0ab5-\\u0ab9\\u0abd\\u0ad0\\u0ae0\\u0ae1\\u0b05-\\u0b0c\\u0b0f\\u0b10\\u0b13-\\u0b28\\u0b2a-\\u0b30\\u0b32\\u0b33\\u0b35-\\u0b39\\u0b3d\\u0b5c\\u0b5d\\u0b5f-\\u0b61\\u0b71\\u0b83\\u0b85-\\u0b8a\\u0b8e-\\u0b90\\u0b92-\\u0b95\\u0b99\\u0b9a\\u0b9c\\u0b9e\\u0b9f\\u0ba3\\u0ba4\\u0ba8-\\u0baa\\u0bae-\\u0bb9\\u0bd0\\u0c05-\\u0c0c\\u0c0e-\\u0c10\\u0c12-\\u0c28\\u0c2a-\\u0c33\\u0c35-\\u0c39\\u0c3d\\u0c58\\u0c59\\u0c60\\u0c61\\u0c85-\\u0c8c\\u0c8e-\\u0c90\\u0c92-\\u0ca8\\u0caa-\\u0cb3\\u0cb5-\\u0cb9\\u0cbd\\u0cde\\u0ce0\\u0ce1\\u0cf1\\u0cf2\\u0d05-\\u0d0c\\u0d0e-\\u0d10\\u0d12-\\u0d3a\\u0d3d\\u0d4e\\u0d60\\u0d61\\u0d7a-\\u0d7f\\u0d85-\\u0d96\\u0d9a-\\u0db1\\u0db3-\\u0dbb\\u0dbd\\u0dc0-\\u0dc6\\u0e01-\\u0e30\\u0e32\\u0e33\\u0e40-\\u0e46\\u0e81\\u0e82\\u0e84\\u0e87\\u0e88\\u0e8a\\u0e8d\\u0e94-\\u0e97\\u0e99-\\u0e9f\\u0ea1-\\u0ea3\\u0ea5\\u0ea7\\u0eaa\\u0eab\\u0ead-\\u0eb0\\u0eb2\\u0eb3\\u0ebd\\u0ec0-\\u0ec4\\u0ec6\\u0edc-\\u0edf\\u0f00\\u0f40-\\u0f47\\u0f49-\\u0f6c\\u0f88-\\u0f8c\\u1000-\\u102a\\u103f\\u1050-\\u1055\\u105a-\\u105d\\u1061\\u1065\\u1066\\u106e-\\u1070\\u1075-\\u1081\\u108e\\u10a0-\\u10c5\\u10c7\\u10cd\\u10d0-\\u10fa\\u10fc-\\u1248\\u124a-\\u124d\\u1250-\\u1256\\u1258\\u125a-\\u125d\\u1260-\\u1288\\u128a-\\u128d\\u1290-\\u12b0\\u12b2-\\u12b5\\u12b8-\\u12be\\u12c0\\u12c2-\\u12c5\\u12c8-\\u12d6\\u12d8-\\u1310\\u1312-\\u1315\\u1318-\\u135a\\u1380-\\u138f\\u13a0-\\u13f4\\u1401-\\u166c\\u166f-\\u167f\\u1681-\\u169a\\u16a0-\\u16ea\\u16ee-\\u16f0\\u1700-\\u170c\\u170e-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176c\\u176e-\\u1770\\u1780-\\u17b3\\u17d7\\u17dc\\u1820-\\u1877\\u1880-\\u18a8\\u18aa\\u18b0-\\u18f5\\u1900-\\u191c\\u1950-\\u196d\\u1970-\\u1974\\u1980-\\u19ab\\u19c1-\\u19c7\\u1a00-\\u1a16\\u1a20-\\u1a54\\u1aa7\\u1b05-\\u1b33\\u1b45-\\u1b4b\\u1b83-\\u1ba0\\u1bae\\u1baf\\u1bba-\\u1be5\\u1c00-\\u1c23\\u1c4d-\\u1c4f\\u1c5a-\\u1c7d\\u1ce9-\\u1cec\\u1cee-\\u1cf1\\u1cf5\\u1cf6\\u1d00-\\u1dbf\\u1e00-\\u1f15\\u1f18-\\u1f1d\\u1f20-\\u1f45\\u1f48-\\u1f4d\\u1f50-\\u1f57\\u1f59\\u1f5b\\u1f5d\\u1f5f-\\u1f7d\\u1f80-\\u1fb4\\u1fb6-\\u1fbc\\u1fbe\\u1fc2-\\u1fc4\\u1fc6-\\u1fcc\\u1fd0-\\u1fd3\\u1fd6-\\u1fdb\\u1fe0-\\u1fec\\u1ff2-\\u1ff4\\u1ff6-\\u1ffc\\u2071\\u207f\\u2090-\\u209c\\u2102\\u2107\\u210a-\\u2113\\u2115\\u2119-\\u211d\\u2124\\u2126\\u2128\\u212a-\\u212d\\u212f-\\u2139\\u213c-\\u213f\\u2145-\\u2149\\u214e\\u2160-\\u2188\\u2c00-\\u2c2e\\u2c30-\\u2c5e\\u2c60-\\u2ce4\\u2ceb-\\u2cee\\u2cf2\\u2cf3\\u2d00-\\u2d25\\u2d27\\u2d2d\\u2d30-\\u2d67\\u2d6f\\u2d80-\\u2d96\\u2da0-\\u2da6\\u2da8-\\u2dae\\u2db0-\\u2db6\\u2db8-\\u2dbe\\u2dc0-\\u2dc6\\u2dc8-\\u2dce\\u2dd0-\\u2dd6\\u2dd8-\\u2dde\\u2e2f\\u3005-\\u3007\\u3021-\\u3029\\u3031-\\u3035\\u3038-\\u303c\\u3041-\\u3096\\u309d-\\u309f\\u30a1-\\u30fa\\u30fc-\\u30ff\\u3105-\\u312d\\u3131-\\u318e\\u31a0-\\u31ba\\u31f0-\\u31ff\\u3400-\\u4db5\\u4e00-\\u9fcc\\ua000-\\ua48c\\ua4d0-\\ua4fd\\ua500-\\ua60c\\ua610-\\ua61f\\ua62a\\ua62b\\ua640-\\ua66e\\ua67f-\\ua697\\ua6a0-\\ua6ef\\ua717-\\ua71f\\ua722-\\ua788\\ua78b-\\ua78e\\ua790-\\ua793\\ua7a0-\\ua7aa\\ua7f8-\\ua801\\ua803-\\ua805\\ua807-\\ua80a\\ua80c-\\ua822\\ua840-\\ua873\\ua882-\\ua8b3\\ua8f2-\\ua8f7\\ua8fb\\ua90a-\\ua925\\ua930-\\ua946\\ua960-\\ua97c\\ua984-\\ua9b2\\ua9cf\\uaa00-\\uaa28\\uaa40-\\uaa42\\uaa44-\\uaa4b\\uaa60-\\uaa76\\uaa7a\\uaa80-\\uaaaf\\uaab1\\uaab5\\uaab6\\uaab9-\\uaabd\\uaac0\\uaac2\\uaadb-\\uaadd\\uaae0-\\uaaea\\uaaf2-\\uaaf4\\uab01-\\uab06\\uab09-\\uab0e\\uab11-\\uab16\\uab20-\\uab26\\uab28-\\uab2e\\uabc0-\\uabe2\\uac00-\\ud7a3\\ud7b0-\\ud7c6\\ud7cb-\\ud7fb\\uf900-\\ufa6d\\ufa70-\\ufad9\\ufb00-\\ufb06\\ufb13-\\ufb17\\ufb1d\\ufb1f-\\ufb28\\ufb2a-\\ufb36\\ufb38-\\ufb3c\\ufb3e\\ufb40\\ufb41\\ufb43\\ufb44\\ufb46-\\ufbb1\\ufbd3-\\ufd3d\\ufd50-\\ufd8f\\ufd92-\\ufdc7\\ufdf0-\\ufdfb\\ufe70-\\ufe74\\ufe76-\\ufefc\\uff21-\\uff3a\\uff41-\\uff5a\\uff66-\\uffbe\\uffc2-\\uffc7\\uffca-\\uffcf\\uffd2-\\uffd7\\uffda-\\uffdc]'),\n        NonAsciiIdentifierPart: new RegExp('[\\xaa\\xb5\\xba\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\u02c1\\u02c6-\\u02d1\\u02e0-\\u02e4\\u02ec\\u02ee\\u0300-\\u0374\\u0376\\u0377\\u037a-\\u037d\\u0386\\u0388-\\u038a\\u038c\\u038e-\\u03a1\\u03a3-\\u03f5\\u03f7-\\u0481\\u0483-\\u0487\\u048a-\\u0527\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u0591-\\u05bd\\u05bf\\u05c1\\u05c2\\u05c4\\u05c5\\u05c7\\u05d0-\\u05ea\\u05f0-\\u05f2\\u0610-\\u061a\\u0620-\\u0669\\u066e-\\u06d3\\u06d5-\\u06dc\\u06df-\\u06e8\\u06ea-\\u06fc\\u06ff\\u0710-\\u074a\\u074d-\\u07b1\\u07c0-\\u07f5\\u07fa\\u0800-\\u082d\\u0840-\\u085b\\u08a0\\u08a2-\\u08ac\\u08e4-\\u08fe\\u0900-\\u0963\\u0966-\\u096f\\u0971-\\u0977\\u0979-\\u097f\\u0981-\\u0983\\u0985-\\u098c\\u098f\\u0990\\u0993-\\u09a8\\u09aa-\\u09b0\\u09b2\\u09b6-\\u09b9\\u09bc-\\u09c4\\u09c7\\u09c8\\u09cb-\\u09ce\\u09d7\\u09dc\\u09dd\\u09df-\\u09e3\\u09e6-\\u09f1\\u0a01-\\u0a03\\u0a05-\\u0a0a\\u0a0f\\u0a10\\u0a13-\\u0a28\\u0a2a-\\u0a30\\u0a32\\u0a33\\u0a35\\u0a36\\u0a38\\u0a39\\u0a3c\\u0a3e-\\u0a42\\u0a47\\u0a48\\u0a4b-\\u0a4d\\u0a51\\u0a59-\\u0a5c\\u0a5e\\u0a66-\\u0a75\\u0a81-\\u0a83\\u0a85-\\u0a8d\\u0a8f-\\u0a91\\u0a93-\\u0aa8\\u0aaa-\\u0ab0\\u0ab2\\u0ab3\\u0ab5-\\u0ab9\\u0abc-\\u0ac5\\u0ac7-\\u0ac9\\u0acb-\\u0acd\\u0ad0\\u0ae0-\\u0ae3\\u0ae6-\\u0aef\\u0b01-\\u0b03\\u0b05-\\u0b0c\\u0b0f\\u0b10\\u0b13-\\u0b28\\u0b2a-\\u0b30\\u0b32\\u0b33\\u0b35-\\u0b39\\u0b3c-\\u0b44\\u0b47\\u0b48\\u0b4b-\\u0b4d\\u0b56\\u0b57\\u0b5c\\u0b5d\\u0b5f-\\u0b63\\u0b66-\\u0b6f\\u0b71\\u0b82\\u0b83\\u0b85-\\u0b8a\\u0b8e-\\u0b90\\u0b92-\\u0b95\\u0b99\\u0b9a\\u0b9c\\u0b9e\\u0b9f\\u0ba3\\u0ba4\\u0ba8-\\u0baa\\u0bae-\\u0bb9\\u0bbe-\\u0bc2\\u0bc6-\\u0bc8\\u0bca-\\u0bcd\\u0bd0\\u0bd7\\u0be6-\\u0bef\\u0c01-\\u0c03\\u0c05-\\u0c0c\\u0c0e-\\u0c10\\u0c12-\\u0c28\\u0c2a-\\u0c33\\u0c35-\\u0c39\\u0c3d-\\u0c44\\u0c46-\\u0c48\\u0c4a-\\u0c4d\\u0c55\\u0c56\\u0c58\\u0c59\\u0c60-\\u0c63\\u0c66-\\u0c6f\\u0c82\\u0c83\\u0c85-\\u0c8c\\u0c8e-\\u0c90\\u0c92-\\u0ca8\\u0caa-\\u0cb3\\u0cb5-\\u0cb9\\u0cbc-\\u0cc4\\u0cc6-\\u0cc8\\u0cca-\\u0ccd\\u0cd5\\u0cd6\\u0cde\\u0ce0-\\u0ce3\\u0ce6-\\u0cef\\u0cf1\\u0cf2\\u0d02\\u0d03\\u0d05-\\u0d0c\\u0d0e-\\u0d10\\u0d12-\\u0d3a\\u0d3d-\\u0d44\\u0d46-\\u0d48\\u0d4a-\\u0d4e\\u0d57\\u0d60-\\u0d63\\u0d66-\\u0d6f\\u0d7a-\\u0d7f\\u0d82\\u0d83\\u0d85-\\u0d96\\u0d9a-\\u0db1\\u0db3-\\u0dbb\\u0dbd\\u0dc0-\\u0dc6\\u0dca\\u0dcf-\\u0dd4\\u0dd6\\u0dd8-\\u0ddf\\u0df2\\u0df3\\u0e01-\\u0e3a\\u0e40-\\u0e4e\\u0e50-\\u0e59\\u0e81\\u0e82\\u0e84\\u0e87\\u0e88\\u0e8a\\u0e8d\\u0e94-\\u0e97\\u0e99-\\u0e9f\\u0ea1-\\u0ea3\\u0ea5\\u0ea7\\u0eaa\\u0eab\\u0ead-\\u0eb9\\u0ebb-\\u0ebd\\u0ec0-\\u0ec4\\u0ec6\\u0ec8-\\u0ecd\\u0ed0-\\u0ed9\\u0edc-\\u0edf\\u0f00\\u0f18\\u0f19\\u0f20-\\u0f29\\u0f35\\u0f37\\u0f39\\u0f3e-\\u0f47\\u0f49-\\u0f6c\\u0f71-\\u0f84\\u0f86-\\u0f97\\u0f99-\\u0fbc\\u0fc6\\u1000-\\u1049\\u1050-\\u109d\\u10a0-\\u10c5\\u10c7\\u10cd\\u10d0-\\u10fa\\u10fc-\\u1248\\u124a-\\u124d\\u1250-\\u1256\\u1258\\u125a-\\u125d\\u1260-\\u1288\\u128a-\\u128d\\u1290-\\u12b0\\u12b2-\\u12b5\\u12b8-\\u12be\\u12c0\\u12c2-\\u12c5\\u12c8-\\u12d6\\u12d8-\\u1310\\u1312-\\u1315\\u1318-\\u135a\\u135d-\\u135f\\u1380-\\u138f\\u13a0-\\u13f4\\u1401-\\u166c\\u166f-\\u167f\\u1681-\\u169a\\u16a0-\\u16ea\\u16ee-\\u16f0\\u1700-\\u170c\\u170e-\\u1714\\u1720-\\u1734\\u1740-\\u1753\\u1760-\\u176c\\u176e-\\u1770\\u1772\\u1773\\u1780-\\u17d3\\u17d7\\u17dc\\u17dd\\u17e0-\\u17e9\\u180b-\\u180d\\u1810-\\u1819\\u1820-\\u1877\\u1880-\\u18aa\\u18b0-\\u18f5\\u1900-\\u191c\\u1920-\\u192b\\u1930-\\u193b\\u1946-\\u196d\\u1970-\\u1974\\u1980-\\u19ab\\u19b0-\\u19c9\\u19d0-\\u19d9\\u1a00-\\u1a1b\\u1a20-\\u1a5e\\u1a60-\\u1a7c\\u1a7f-\\u1a89\\u1a90-\\u1a99\\u1aa7\\u1b00-\\u1b4b\\u1b50-\\u1b59\\u1b6b-\\u1b73\\u1b80-\\u1bf3\\u1c00-\\u1c37\\u1c40-\\u1c49\\u1c4d-\\u1c7d\\u1cd0-\\u1cd2\\u1cd4-\\u1cf6\\u1d00-\\u1de6\\u1dfc-\\u1f15\\u1f18-\\u1f1d\\u1f20-\\u1f45\\u1f48-\\u1f4d\\u1f50-\\u1f57\\u1f59\\u1f5b\\u1f5d\\u1f5f-\\u1f7d\\u1f80-\\u1fb4\\u1fb6-\\u1fbc\\u1fbe\\u1fc2-\\u1fc4\\u1fc6-\\u1fcc\\u1fd0-\\u1fd3\\u1fd6-\\u1fdb\\u1fe0-\\u1fec\\u1ff2-\\u1ff4\\u1ff6-\\u1ffc\\u200c\\u200d\\u203f\\u2040\\u2054\\u2071\\u207f\\u2090-\\u209c\\u20d0-\\u20dc\\u20e1\\u20e5-\\u20f0\\u2102\\u2107\\u210a-\\u2113\\u2115\\u2119-\\u211d\\u2124\\u2126\\u2128\\u212a-\\u212d\\u212f-\\u2139\\u213c-\\u213f\\u2145-\\u2149\\u214e\\u2160-\\u2188\\u2c00-\\u2c2e\\u2c30-\\u2c5e\\u2c60-\\u2ce4\\u2ceb-\\u2cf3\\u2d00-\\u2d25\\u2d27\\u2d2d\\u2d30-\\u2d67\\u2d6f\\u2d7f-\\u2d96\\u2da0-\\u2da6\\u2da8-\\u2dae\\u2db0-\\u2db6\\u2db8-\\u2dbe\\u2dc0-\\u2dc6\\u2dc8-\\u2dce\\u2dd0-\\u2dd6\\u2dd8-\\u2dde\\u2de0-\\u2dff\\u2e2f\\u3005-\\u3007\\u3021-\\u302f\\u3031-\\u3035\\u3038-\\u303c\\u3041-\\u3096\\u3099\\u309a\\u309d-\\u309f\\u30a1-\\u30fa\\u30fc-\\u30ff\\u3105-\\u312d\\u3131-\\u318e\\u31a0-\\u31ba\\u31f0-\\u31ff\\u3400-\\u4db5\\u4e00-\\u9fcc\\ua000-\\ua48c\\ua4d0-\\ua4fd\\ua500-\\ua60c\\ua610-\\ua62b\\ua640-\\ua66f\\ua674-\\ua67d\\ua67f-\\ua697\\ua69f-\\ua6f1\\ua717-\\ua71f\\ua722-\\ua788\\ua78b-\\ua78e\\ua790-\\ua793\\ua7a0-\\ua7aa\\ua7f8-\\ua827\\ua840-\\ua873\\ua880-\\ua8c4\\ua8d0-\\ua8d9\\ua8e0-\\ua8f7\\ua8fb\\ua900-\\ua92d\\ua930-\\ua953\\ua960-\\ua97c\\ua980-\\ua9c0\\ua9cf-\\ua9d9\\uaa00-\\uaa36\\uaa40-\\uaa4d\\uaa50-\\uaa59\\uaa60-\\uaa76\\uaa7a\\uaa7b\\uaa80-\\uaac2\\uaadb-\\uaadd\\uaae0-\\uaaef\\uaaf2-\\uaaf6\\uab01-\\uab06\\uab09-\\uab0e\\uab11-\\uab16\\uab20-\\uab26\\uab28-\\uab2e\\uabc0-\\uabea\\uabec\\uabed\\uabf0-\\uabf9\\uac00-\\ud7a3\\ud7b0-\\ud7c6\\ud7cb-\\ud7fb\\uf900-\\ufa6d\\ufa70-\\ufad9\\ufb00-\\ufb06\\ufb13-\\ufb17\\ufb1d-\\ufb28\\ufb2a-\\ufb36\\ufb38-\\ufb3c\\ufb3e\\ufb40\\ufb41\\ufb43\\ufb44\\ufb46-\\ufbb1\\ufbd3-\\ufd3d\\ufd50-\\ufd8f\\ufd92-\\ufdc7\\ufdf0-\\ufdfb\\ufe00-\\ufe0f\\ufe20-\\ufe26\\ufe33\\ufe34\\ufe4d-\\ufe4f\\ufe70-\\ufe74\\ufe76-\\ufefc\\uff10-\\uff19\\uff21-\\uff3a\\uff3f\\uff41-\\uff5a\\uff66-\\uffbe\\uffc2-\\uffc7\\uffca-\\uffcf\\uffd2-\\uffd7\\uffda-\\uffdc]')\n    };\n\n    // Ensure the condition is true, otherwise throw an error.\n    // This is only to have a better contract semantic, i.e. another safety net\n    // to catch a logic error. The condition shall be fulfilled in normal case.\n    // Do NOT use this to enforce a certain condition on any user input.\n\n    function assert(condition, message) {\n        if (!condition) {\n            throw new Error('ASSERT: ' + message);\n        }\n    }\n\n    function sliceSource(from, to) {\n        return source.slice(from, to);\n    }\n\n    if (typeof 'esprima'[0] === 'undefined') {\n        sliceSource = function sliceArraySource(from, to) {\n            return source.slice(from, to).join('');\n        };\n    }\n\n    function isDecimalDigit(ch) {\n        return '0123456789'.indexOf(ch) >= 0;\n    }\n\n    function isHexDigit(ch) {\n        return '0123456789abcdefABCDEF'.indexOf(ch) >= 0;\n    }\n\n    function isOctalDigit(ch) {\n        return '01234567'.indexOf(ch) >= 0;\n    }\n\n\n    // 7.2 White Space\n\n    function isWhiteSpace(ch) {\n        return (ch === ' ') || (ch === '\\u0009') || (ch === '\\u000B') ||\n            (ch === '\\u000C') || (ch === '\\u00A0') ||\n            (ch.charCodeAt(0) >= 0x1680 &&\n             '\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\uFEFF'.indexOf(ch) >= 0);\n    }\n\n    // 7.3 Line Terminators\n\n    function isLineTerminator(ch) {\n        return (ch === '\\n' || ch === '\\r' || ch === '\\u2028' || ch === '\\u2029');\n    }\n\n    // 7.6 Identifier Names and Identifiers\n\n    function isIdentifierStart(ch) {\n        return (ch === '$') || (ch === '_') || (ch === '\\\\') ||\n            (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') ||\n            ((ch.charCodeAt(0) >= 0x80) && Regex.NonAsciiIdentifierStart.test(ch));\n    }\n\n    function isIdentifierPart(ch) {\n        return (ch === '$') || (ch === '_') || (ch === '\\\\') ||\n            (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') ||\n            ((ch >= '0') && (ch <= '9')) ||\n            ((ch.charCodeAt(0) >= 0x80) && Regex.NonAsciiIdentifierPart.test(ch));\n    }\n\n    // 7.6.1.2 Future Reserved Words\n\n    function isFutureReservedWord(id) {\n        switch (id) {\n\n        // Future reserved words.\n        case 'class':\n        case 'enum':\n        case 'export':\n        case 'extends':\n        case 'import':\n        case 'super':\n            return true;\n        }\n\n        return false;\n    }\n\n    function isStrictModeReservedWord(id) {\n        switch (id) {\n\n        // Strict Mode reserved words.\n        case 'implements':\n        case 'interface':\n        case 'package':\n        case 'private':\n        case 'protected':\n        case 'public':\n        case 'static':\n        case 'yield':\n        case 'let':\n            return true;\n        }\n\n        return false;\n    }\n\n    function isRestrictedWord(id) {\n        return id === 'eval' || id === 'arguments';\n    }\n\n    // 7.6.1.1 Keywords\n\n    function isKeyword(id) {\n        var keyword = false;\n        switch (id.length) {\n        case 2:\n            keyword = (id === 'if') || (id === 'in') || (id === 'do');\n            break;\n        case 3:\n            keyword = (id === 'var') || (id === 'for') || (id === 'new') || (id === 'try');\n            break;\n        case 4:\n            keyword = (id === 'this') || (id === 'else') || (id === 'case') || (id === 'void') || (id === 'with');\n            break;\n        case 5:\n            keyword = (id === 'while') || (id === 'break') || (id === 'catch') || (id === 'throw');\n            break;\n        case 6:\n            keyword = (id === 'return') || (id === 'typeof') || (id === 'delete') || (id === 'switch');\n            break;\n        case 7:\n            keyword = (id === 'default') || (id === 'finally');\n            break;\n        case 8:\n            keyword = (id === 'function') || (id === 'continue') || (id === 'debugger');\n            break;\n        case 10:\n            keyword = (id === 'instanceof');\n            break;\n        }\n\n        if (keyword) {\n            return true;\n        }\n\n        switch (id) {\n        // Future reserved words.\n        // 'const' is specialized as Keyword in V8.\n        case 'const':\n            return true;\n\n        // For compatiblity to SpiderMonkey and ES.next\n        case 'yield':\n        case 'let':\n            return true;\n        }\n\n        if (strict && isStrictModeReservedWord(id)) {\n            return true;\n        }\n\n        return isFutureReservedWord(id);\n    }\n\n    // 7.4 Comments\n\n    function skipComment() {\n        var ch, blockComment, lineComment;\n\n        blockComment = false;\n        lineComment = false;\n\n        while (index < length) {\n            ch = source[index];\n\n            if (lineComment) {\n                ch = source[index++];\n                if (isLineTerminator(ch)) {\n                    lineComment = false;\n                    if (ch === '\\r' && source[index] === '\\n') {\n                        ++index;\n                    }\n                    ++lineNumber;\n                    lineStart = index;\n                }\n            } else if (blockComment) {\n                if (isLineTerminator(ch)) {\n                    if (ch === '\\r' && source[index + 1] === '\\n') {\n                        ++index;\n                    }\n                    ++lineNumber;\n                    ++index;\n                    lineStart = index;\n                    if (index >= length) {\n                        throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n                    }\n                } else {\n                    ch = source[index++];\n                    if (index >= length) {\n                        throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n                    }\n                    if (ch === '*') {\n                        ch = source[index];\n                        if (ch === '/') {\n                            ++index;\n                            blockComment = false;\n                        }\n                    }\n                }\n            } else if (ch === '/') {\n                ch = source[index + 1];\n                if (ch === '/') {\n                    index += 2;\n                    lineComment = true;\n                } else if (ch === '*') {\n                    index += 2;\n                    blockComment = true;\n                    if (index >= length) {\n                        throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n                    }\n                } else {\n                    break;\n                }\n            } else if (isWhiteSpace(ch)) {\n                ++index;\n            } else if (isLineTerminator(ch)) {\n                ++index;\n                if (ch ===  '\\r' && source[index] === '\\n') {\n                    ++index;\n                }\n                ++lineNumber;\n                lineStart = index;\n            } else {\n                break;\n            }\n        }\n    }\n\n    function scanHexEscape(prefix) {\n        var i, len, ch, code = 0;\n\n        len = (prefix === 'u') ? 4 : 2;\n        for (i = 0; i < len; ++i) {\n            if (index < length && isHexDigit(source[index])) {\n                ch = source[index++];\n                code = code * 16 + '0123456789abcdef'.indexOf(ch.toLowerCase());\n            } else {\n                return '';\n            }\n        }\n        return String.fromCharCode(code);\n    }\n\n    function scanIdentifier() {\n        var ch, start, id, restore;\n\n        ch = source[index];\n        if (!isIdentifierStart(ch)) {\n            return;\n        }\n\n        start = index;\n        if (ch === '\\\\') {\n            ++index;\n            if (source[index] !== 'u') {\n                return;\n            }\n            ++index;\n            restore = index;\n            ch = scanHexEscape('u');\n            if (ch) {\n                if (ch === '\\\\' || !isIdentifierStart(ch)) {\n                    return;\n                }\n                id = ch;\n            } else {\n                index = restore;\n                id = 'u';\n            }\n        } else {\n            id = source[index++];\n        }\n\n        while (index < length) {\n            ch = source[index];\n            if (!isIdentifierPart(ch)) {\n                break;\n            }\n            if (ch === '\\\\') {\n                ++index;\n                if (source[index] !== 'u') {\n                    return;\n                }\n                ++index;\n                restore = index;\n                ch = scanHexEscape('u');\n                if (ch) {\n                    if (ch === '\\\\' || !isIdentifierPart(ch)) {\n                        return;\n                    }\n                    id += ch;\n                } else {\n                    index = restore;\n                    id += 'u';\n                }\n            } else {\n                id += source[index++];\n            }\n        }\n\n        // There is no keyword or literal with only one character.\n        // Thus, it must be an identifier.\n        if (id.length === 1) {\n            return {\n                type: Token.Identifier,\n                value: id,\n                lineNumber: lineNumber,\n                lineStart: lineStart,\n                range: [start, index]\n            };\n        }\n\n        if (isKeyword(id)) {\n            return {\n                type: Token.Keyword,\n                value: id,\n                lineNumber: lineNumber,\n                lineStart: lineStart,\n                range: [start, index]\n            };\n        }\n\n        // 7.8.1 Null Literals\n\n        if (id === 'null') {\n            return {\n                type: Token.NullLiteral,\n                value: id,\n                lineNumber: lineNumber,\n                lineStart: lineStart,\n                range: [start, index]\n            };\n        }\n\n        // 7.8.2 Boolean Literals\n\n        if (id === 'true' || id === 'false') {\n            return {\n                type: Token.BooleanLiteral,\n                value: id,\n                lineNumber: lineNumber,\n                lineStart: lineStart,\n                range: [start, index]\n            };\n        }\n\n        return {\n            type: Token.Identifier,\n            value: id,\n            lineNumber: lineNumber,\n            lineStart: lineStart,\n            range: [start, index]\n        };\n    }\n\n    // 7.7 Punctuators\n\n    function scanPunctuator() {\n        var start = index,\n            ch1 = source[index],\n            ch2,\n            ch3,\n            ch4;\n\n        // Check for most common single-character punctuators.\n\n        if (ch1 === ';' || ch1 === '{' || ch1 === '}') {\n            ++index;\n            return {\n                type: Token.Punctuator,\n                value: ch1,\n                lineNumber: lineNumber,\n                lineStart: lineStart,\n                range: [start, index]\n            };\n        }\n\n        if (ch1 === ',' || ch1 === '(' || ch1 === ')') {\n            ++index;\n            return {\n                type: Token.Punctuator,\n                value: ch1,\n                lineNumber: lineNumber,\n                lineStart: lineStart,\n                range: [start, index]\n            };\n        }\n\n        // Dot (.) can also start a floating-point number, hence the need\n        // to check the next character.\n\n        ch2 = source[index + 1];\n        if (ch1 === '.' && !isDecimalDigit(ch2)) {\n            return {\n                type: Token.Punctuator,\n                value: source[index++],\n                lineNumber: lineNumber,\n                lineStart: lineStart,\n                range: [start, index]\n            };\n        }\n\n        // Peek more characters.\n\n        ch3 = source[index + 2];\n        ch4 = source[index + 3];\n\n        // 4-character punctuator: >>>=\n\n        if (ch1 === '>' && ch2 === '>' && ch3 === '>') {\n            if (ch4 === '=') {\n                index += 4;\n                return {\n                    type: Token.Punctuator,\n                    value: '>>>=',\n                    lineNumber: lineNumber,\n                    lineStart: lineStart,\n                    range: [start, index]\n                };\n            }\n        }\n\n        // 3-character punctuators: === !== >>> <<= >>=\n\n        if (ch1 === '=' && ch2 === '=' && ch3 === '=') {\n            index += 3;\n            return {\n                type: Token.Punctuator,\n                value: '===',\n                lineNumber: lineNumber,\n                lineStart: lineStart,\n                range: [start, index]\n            };\n        }\n\n        if (ch1 === '!' && ch2 === '=' && ch3 === '=') {\n            index += 3;\n            return {\n                type: Token.Punctuator,\n                value: '!==',\n                lineNumber: lineNumber,\n                lineStart: lineStart,\n                range: [start, index]\n            };\n        }\n\n        if (ch1 === '>' && ch2 === '>' && ch3 === '>') {\n            index += 3;\n            return {\n                type: Token.Punctuator,\n                value: '>>>',\n                lineNumber: lineNumber,\n                lineStart: lineStart,\n                range: [start, index]\n            };\n        }\n\n        if (ch1 === '<' && ch2 === '<' && ch3 === '=') {\n            index += 3;\n            return {\n                type: Token.Punctuator,\n                value: '<<=',\n                lineNumber: lineNumber,\n                lineStart: lineStart,\n                range: [start, index]\n            };\n        }\n\n        if (ch1 === '>' && ch2 === '>' && ch3 === '=') {\n            index += 3;\n            return {\n                type: Token.Punctuator,\n                value: '>>=',\n                lineNumber: lineNumber,\n                lineStart: lineStart,\n                range: [start, index]\n            };\n        }\n\n        // 2-character punctuators: <= >= == != ++ -- << >> && ||\n        // += -= *= %= &= |= ^= /=\n\n        if (ch2 === '=') {\n            if ('<>=!+-*%&|^/'.indexOf(ch1) >= 0) {\n                index += 2;\n                return {\n                    type: Token.Punctuator,\n                    value: ch1 + ch2,\n                    lineNumber: lineNumber,\n                    lineStart: lineStart,\n                    range: [start, index]\n                };\n            }\n        }\n\n        if (ch1 === ch2 && ('+-<>&|'.indexOf(ch1) >= 0)) {\n            if ('+-<>&|'.indexOf(ch2) >= 0) {\n                index += 2;\n                return {\n                    type: Token.Punctuator,\n                    value: ch1 + ch2,\n                    lineNumber: lineNumber,\n                    lineStart: lineStart,\n                    range: [start, index]\n                };\n            }\n        }\n\n        // The remaining 1-character punctuators.\n\n        if ('[]<>+-*%&|^!~?:=/'.indexOf(ch1) >= 0) {\n            return {\n                type: Token.Punctuator,\n                value: source[index++],\n                lineNumber: lineNumber,\n                lineStart: lineStart,\n                range: [start, index]\n            };\n        }\n    }\n\n    // 7.8.3 Numeric Literals\n\n    function scanNumericLiteral() {\n        var number, start, ch;\n\n        ch = source[index];\n        assert(isDecimalDigit(ch) || (ch === '.'),\n            'Numeric literal must start with a decimal digit or a decimal point');\n\n        start = index;\n        number = '';\n        if (ch !== '.') {\n            number = source[index++];\n            ch = source[index];\n\n            // Hex number starts with '0x'.\n            // Octal number starts with '0'.\n            if (number === '0') {\n                if (ch === 'x' || ch === 'X') {\n                    number += source[index++];\n                    while (index < length) {\n                        ch = source[index];\n                        if (!isHexDigit(ch)) {\n                            break;\n                        }\n                        number += source[index++];\n                    }\n\n                    if (number.length <= 2) {\n                        // only 0x\n                        throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n                    }\n\n                    if (index < length) {\n                        ch = source[index];\n                        if (isIdentifierStart(ch)) {\n                            throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n                        }\n                    }\n                    return {\n                        type: Token.NumericLiteral,\n                        value: parseInt(number, 16),\n                        lineNumber: lineNumber,\n                        lineStart: lineStart,\n                        range: [start, index]\n                    };\n                } else if (isOctalDigit(ch)) {\n                    number += source[index++];\n                    while (index < length) {\n                        ch = source[index];\n                        if (!isOctalDigit(ch)) {\n                            break;\n                        }\n                        number += source[index++];\n                    }\n\n                    if (index < length) {\n                        ch = source[index];\n                        if (isIdentifierStart(ch) || isDecimalDigit(ch)) {\n                            throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n                        }\n                    }\n                    return {\n                        type: Token.NumericLiteral,\n                        value: parseInt(number, 8),\n                        octal: true,\n                        lineNumber: lineNumber,\n                        lineStart: lineStart,\n                        range: [start, index]\n                    };\n                }\n\n                // decimal number starts with '0' such as '09' is illegal.\n                if (isDecimalDigit(ch)) {\n                    throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n                }\n            }\n\n            while (index < length) {\n                ch = source[index];\n                if (!isDecimalDigit(ch)) {\n                    break;\n                }\n                number += source[index++];\n            }\n        }\n\n        if (ch === '.') {\n            number += source[index++];\n            while (index < length) {\n                ch = source[index];\n                if (!isDecimalDigit(ch)) {\n                    break;\n                }\n                number += source[index++];\n            }\n        }\n\n        if (ch === 'e' || ch === 'E') {\n            number += source[index++];\n\n            ch = source[index];\n            if (ch === '+' || ch === '-') {\n                number += source[index++];\n            }\n\n            ch = source[index];\n            if (isDecimalDigit(ch)) {\n                number += source[index++];\n                while (index < length) {\n                    ch = source[index];\n                    if (!isDecimalDigit(ch)) {\n                        break;\n                    }\n                    number += source[index++];\n                }\n            } else {\n                ch = 'character ' + ch;\n                if (index >= length) {\n                    ch = '<end>';\n                }\n                throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n            }\n        }\n\n        if (index < length) {\n            ch = source[index];\n            if (isIdentifierStart(ch)) {\n                throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n            }\n        }\n\n        return {\n            type: Token.NumericLiteral,\n            value: parseFloat(number),\n            lineNumber: lineNumber,\n            lineStart: lineStart,\n            range: [start, index]\n        };\n    }\n\n    // 7.8.4 String Literals\n\n    function scanStringLiteral() {\n        var str = '', quote, start, ch, code, unescaped, restore, octal = false;\n\n        quote = source[index];\n        assert((quote === '\\'' || quote === '\"'),\n            'String literal must starts with a quote');\n\n        start = index;\n        ++index;\n\n        while (index < length) {\n            ch = source[index++];\n\n            if (ch === quote) {\n                quote = '';\n                break;\n            } else if (ch === '\\\\') {\n                ch = source[index++];\n                if (!isLineTerminator(ch)) {\n                    switch (ch) {\n                    case 'n':\n                        str += '\\n';\n                        break;\n                    case 'r':\n                        str += '\\r';\n                        break;\n                    case 't':\n                        str += '\\t';\n                        break;\n                    case 'u':\n                    case 'x':\n                        restore = index;\n                        unescaped = scanHexEscape(ch);\n                        if (unescaped) {\n                            str += unescaped;\n                        } else {\n                            index = restore;\n                            str += ch;\n                        }\n                        break;\n                    case 'b':\n                        str += '\\b';\n                        break;\n                    case 'f':\n                        str += '\\f';\n                        break;\n                    case 'v':\n                        str += '\\x0B';\n                        break;\n\n                    default:\n                        if (isOctalDigit(ch)) {\n                            code = '01234567'.indexOf(ch);\n\n                            // \\0 is not octal escape sequence\n                            if (code !== 0) {\n                                octal = true;\n                            }\n\n                            if (index < length && isOctalDigit(source[index])) {\n                                octal = true;\n                                code = code * 8 + '01234567'.indexOf(source[index++]);\n\n                                // 3 digits are only allowed when string starts\n                                // with 0, 1, 2, 3\n                                if ('0123'.indexOf(ch) >= 0 &&\n                                        index < length &&\n                                        isOctalDigit(source[index])) {\n                                    code = code * 8 + '01234567'.indexOf(source[index++]);\n                                }\n                            }\n                            str += String.fromCharCode(code);\n                        } else {\n                            str += ch;\n                        }\n                        break;\n                    }\n                } else {\n                    ++lineNumber;\n                    if (ch ===  '\\r' && source[index] === '\\n') {\n                        ++index;\n                    }\n                }\n            } else if (isLineTerminator(ch)) {\n                break;\n            } else {\n                str += ch;\n            }\n        }\n\n        if (quote !== '') {\n            throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n        }\n\n        return {\n            type: Token.StringLiteral,\n            value: str,\n            octal: octal,\n            lineNumber: lineNumber,\n            lineStart: lineStart,\n            range: [start, index]\n        };\n    }\n\n    function scanRegExp() {\n        var str, ch, start, pattern, flags, value, classMarker = false, restore, terminated = false;\n\n        buffer = null;\n        skipComment();\n\n        start = index;\n        ch = source[index];\n        assert(ch === '/', 'Regular expression literal must start with a slash');\n        str = source[index++];\n\n        while (index < length) {\n            ch = source[index++];\n            str += ch;\n            if (ch === '\\\\') {\n                ch = source[index++];\n                // ECMA-262 7.8.5\n                if (isLineTerminator(ch)) {\n                    throwError({}, Messages.UnterminatedRegExp);\n                }\n                str += ch;\n            } else if (classMarker) {\n                if (ch === ']') {\n                    classMarker = false;\n                }\n            } else {\n                if (ch === '/') {\n                    terminated = true;\n                    break;\n                } else if (ch === '[') {\n                    classMarker = true;\n                } else if (isLineTerminator(ch)) {\n                    throwError({}, Messages.UnterminatedRegExp);\n                }\n            }\n        }\n\n        if (!terminated) {\n            throwError({}, Messages.UnterminatedRegExp);\n        }\n\n        // Exclude leading and trailing slash.\n        pattern = str.substr(1, str.length - 2);\n\n        flags = '';\n        while (index < length) {\n            ch = source[index];\n            if (!isIdentifierPart(ch)) {\n                break;\n            }\n\n            ++index;\n            if (ch === '\\\\' && index < length) {\n                ch = source[index];\n                if (ch === 'u') {\n                    ++index;\n                    restore = index;\n                    ch = scanHexEscape('u');\n                    if (ch) {\n                        flags += ch;\n                        str += '\\\\u';\n                        for (; restore < index; ++restore) {\n                            str += source[restore];\n                        }\n                    } else {\n                        index = restore;\n                        flags += 'u';\n                        str += '\\\\u';\n                    }\n                } else {\n                    str += '\\\\';\n                }\n            } else {\n                flags += ch;\n                str += ch;\n            }\n        }\n\n        try {\n            value = new RegExp(pattern, flags);\n        } catch (e) {\n            throwError({}, Messages.InvalidRegExp);\n        }\n\n        return {\n            literal: str,\n            value: value,\n            range: [start, index]\n        };\n    }\n\n    function isIdentifierName(token) {\n        return token.type === Token.Identifier ||\n            token.type === Token.Keyword ||\n            token.type === Token.BooleanLiteral ||\n            token.type === Token.NullLiteral;\n    }\n\n    function advance() {\n        var ch, token;\n\n        skipComment();\n\n        if (index >= length) {\n            return {\n                type: Token.EOF,\n                lineNumber: lineNumber,\n                lineStart: lineStart,\n                range: [index, index]\n            };\n        }\n\n        token = scanPunctuator();\n        if (typeof token !== 'undefined') {\n            return token;\n        }\n\n        ch = source[index];\n\n        if (ch === '\\'' || ch === '\"') {\n            return scanStringLiteral();\n        }\n\n        if (ch === '.' || isDecimalDigit(ch)) {\n            return scanNumericLiteral();\n        }\n\n        token = scanIdentifier();\n        if (typeof token !== 'undefined') {\n            return token;\n        }\n\n        throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n    }\n\n    function lex() {\n        var token;\n\n        if (buffer) {\n            index = buffer.range[1];\n            lineNumber = buffer.lineNumber;\n            lineStart = buffer.lineStart;\n            token = buffer;\n            buffer = null;\n            return token;\n        }\n\n        buffer = null;\n        return advance();\n    }\n\n    function lookahead() {\n        var pos, line, start;\n\n        if (buffer !== null) {\n            return buffer;\n        }\n\n        pos = index;\n        line = lineNumber;\n        start = lineStart;\n        buffer = advance();\n        index = pos;\n        lineNumber = line;\n        lineStart = start;\n\n        return buffer;\n    }\n\n    // Return true if there is a line terminator before the next token.\n\n    function peekLineTerminator() {\n        var pos, line, start, found;\n\n        pos = index;\n        line = lineNumber;\n        start = lineStart;\n        skipComment();\n        found = lineNumber !== line;\n        index = pos;\n        lineNumber = line;\n        lineStart = start;\n\n        return found;\n    }\n\n    // Throw an exception\n\n    function throwError(token, messageFormat) {\n        var error,\n            args = Array.prototype.slice.call(arguments, 2),\n            msg = messageFormat.replace(\n                /%(\\d)/g,\n                function (whole, index) {\n                    return args[index] || '';\n                }\n            );\n\n        if (typeof token.lineNumber === 'number') {\n            error = new Error('Line ' + token.lineNumber + ': ' + msg);\n            error.index = token.range[0];\n            error.lineNumber = token.lineNumber;\n            error.column = token.range[0] - lineStart + 1;\n        } else {\n            error = new Error('Line ' + lineNumber + ': ' + msg);\n            error.index = index;\n            error.lineNumber = lineNumber;\n            error.column = index - lineStart + 1;\n        }\n\n        throw error;\n    }\n\n    function throwErrorTolerant() {\n        try {\n            throwError.apply(null, arguments);\n        } catch (e) {\n            if (extra.errors) {\n                extra.errors.push(e);\n            } else {\n                throw e;\n            }\n        }\n    }\n\n\n    // Throw an exception because of the token.\n\n    function throwUnexpected(token) {\n        if (token.type === Token.EOF) {\n            throwError(token, Messages.UnexpectedEOS);\n        }\n\n        if (token.type === Token.NumericLiteral) {\n            throwError(token, Messages.UnexpectedNumber);\n        }\n\n        if (token.type === Token.StringLiteral) {\n            throwError(token, Messages.UnexpectedString);\n        }\n\n        if (token.type === Token.Identifier) {\n            throwError(token, Messages.UnexpectedIdentifier);\n        }\n\n        if (token.type === Token.Keyword) {\n            if (isFutureReservedWord(token.value)) {\n                throwError(token, Messages.UnexpectedReserved);\n            } else if (strict && isStrictModeReservedWord(token.value)) {\n                throwErrorTolerant(token, Messages.StrictReservedWord);\n                return;\n            }\n            throwError(token, Messages.UnexpectedToken, token.value);\n        }\n\n        // BooleanLiteral, NullLiteral, or Punctuator.\n        throwError(token, Messages.UnexpectedToken, token.value);\n    }\n\n    // Expect the next token to match the specified punctuator.\n    // If not, an exception will be thrown.\n\n    function expect(value) {\n        var token = lex();\n        if (token.type !== Token.Punctuator || token.value !== value) {\n            throwUnexpected(token);\n        }\n    }\n\n    // Expect the next token to match the specified keyword.\n    // If not, an exception will be thrown.\n\n    function expectKeyword(keyword) {\n        var token = lex();\n        if (token.type !== Token.Keyword || token.value !== keyword) {\n            throwUnexpected(token);\n        }\n    }\n\n    // Return true if the next token matches the specified punctuator.\n\n    function match(value) {\n        var token = lookahead();\n        return token.type === Token.Punctuator && token.value === value;\n    }\n\n    // Return true if the next token matches the specified keyword\n\n    function matchKeyword(keyword) {\n        var token = lookahead();\n        return token.type === Token.Keyword && token.value === keyword;\n    }\n\n    // Return true if the next token is an assignment operator\n\n    function matchAssign() {\n        var token = lookahead(),\n            op = token.value;\n\n        if (token.type !== Token.Punctuator) {\n            return false;\n        }\n        return op === '=' ||\n            op === '*=' ||\n            op === '/=' ||\n            op === '%=' ||\n            op === '+=' ||\n            op === '-=' ||\n            op === '<<=' ||\n            op === '>>=' ||\n            op === '>>>=' ||\n            op === '&=' ||\n            op === '^=' ||\n            op === '|=';\n    }\n\n    function consumeSemicolon() {\n        var token, line;\n\n        // Catch the very common case first.\n        if (source[index] === ';') {\n            lex();\n            return;\n        }\n\n        line = lineNumber;\n        skipComment();\n        if (lineNumber !== line) {\n            return;\n        }\n\n        if (match(';')) {\n            lex();\n            return;\n        }\n\n        token = lookahead();\n        if (token.type !== Token.EOF && !match('}')) {\n            throwUnexpected(token);\n        }\n    }\n\n    // Return true if provided expression is LeftHandSideExpression\n\n    function isLeftHandSide(expr) {\n        return expr.type === Syntax.Identifier || expr.type === Syntax.MemberExpression;\n    }\n\n    // 11.1.4 Array Initialiser\n\n    function parseArrayInitialiser() {\n        var elements = [];\n\n        expect('[');\n\n        while (!match(']')) {\n            if (match(',')) {\n                lex();\n                elements.push(null);\n            } else {\n                elements.push(parseAssignmentExpression());\n\n                if (!match(']')) {\n                    expect(',');\n                }\n            }\n        }\n\n        expect(']');\n\n        return {\n            type: Syntax.ArrayExpression,\n            elements: elements\n        };\n    }\n\n    // 11.1.5 Object Initialiser\n\n    function parsePropertyFunction(param, first) {\n        var previousStrict, body;\n\n        previousStrict = strict;\n        body = parseFunctionSourceElements();\n        if (first && strict && isRestrictedWord(param[0].name)) {\n            throwErrorTolerant(first, Messages.StrictParamName);\n        }\n        strict = previousStrict;\n\n        return {\n            type: Syntax.FunctionExpression,\n            id: null,\n            params: param,\n            defaults: [],\n            body: body,\n            rest: null,\n            generator: false,\n            expression: false\n        };\n    }\n\n    function parseObjectPropertyKey() {\n        var token = lex();\n\n        // Note: This function is called only from parseObjectProperty(), where\n        // EOF and Punctuator tokens are already filtered out.\n\n        if (token.type === Token.StringLiteral || token.type === Token.NumericLiteral) {\n            if (strict && token.octal) {\n                throwErrorTolerant(token, Messages.StrictOctalLiteral);\n            }\n            return createLiteral(token);\n        }\n\n        return {\n            type: Syntax.Identifier,\n            name: token.value\n        };\n    }\n\n    function parseObjectProperty() {\n        var token, key, id, param;\n\n        token = lookahead();\n\n        if (token.type === Token.Identifier) {\n\n            id = parseObjectPropertyKey();\n\n            // Property Assignment: Getter and Setter.\n\n            if (token.value === 'get' && !match(':')) {\n                key = parseObjectPropertyKey();\n                expect('(');\n                expect(')');\n                return {\n                    type: Syntax.Property,\n                    key: key,\n                    value: parsePropertyFunction([]),\n                    kind: 'get'\n                };\n            } else if (token.value === 'set' && !match(':')) {\n                key = parseObjectPropertyKey();\n                expect('(');\n                token = lookahead();\n                if (token.type !== Token.Identifier) {\n                    expect(')');\n                    throwErrorTolerant(token, Messages.UnexpectedToken, token.value);\n                    return {\n                        type: Syntax.Property,\n                        key: key,\n                        value: parsePropertyFunction([]),\n                        kind: 'set'\n                    };\n                } else {\n                    param = [ parseVariableIdentifier() ];\n                    expect(')');\n                    return {\n                        type: Syntax.Property,\n                        key: key,\n                        value: parsePropertyFunction(param, token),\n                        kind: 'set'\n                    };\n                }\n            } else {\n                expect(':');\n                return {\n                    type: Syntax.Property,\n                    key: id,\n                    value: parseAssignmentExpression(),\n                    kind: 'init'\n                };\n            }\n        } else if (token.type === Token.EOF || token.type === Token.Punctuator) {\n            throwUnexpected(token);\n        } else {\n            key = parseObjectPropertyKey();\n            expect(':');\n            return {\n                type: Syntax.Property,\n                key: key,\n                value: parseAssignmentExpression(),\n                kind: 'init'\n            };\n        }\n    }\n\n    function parseObjectInitialiser() {\n        var properties = [], property, name, kind, map = {}, toString = String;\n\n        expect('{');\n\n        while (!match('}')) {\n            property = parseObjectProperty();\n\n            if (property.key.type === Syntax.Identifier) {\n                name = property.key.name;\n            } else {\n                name = toString(property.key.value);\n            }\n            kind = (property.kind === 'init') ? PropertyKind.Data : (property.kind === 'get') ? PropertyKind.Get : PropertyKind.Set;\n            if (Object.prototype.hasOwnProperty.call(map, name)) {\n                if (map[name] === PropertyKind.Data) {\n                    if (strict && kind === PropertyKind.Data) {\n                        throwErrorTolerant({}, Messages.StrictDuplicateProperty);\n                    } else if (kind !== PropertyKind.Data) {\n                        throwErrorTolerant({}, Messages.AccessorDataProperty);\n                    }\n                } else {\n                    if (kind === PropertyKind.Data) {\n                        throwErrorTolerant({}, Messages.AccessorDataProperty);\n                    } else if (map[name] & kind) {\n                        throwErrorTolerant({}, Messages.AccessorGetSet);\n                    }\n                }\n                map[name] |= kind;\n            } else {\n                map[name] = kind;\n            }\n\n            properties.push(property);\n\n            if (!match('}')) {\n                expect(',');\n            }\n        }\n\n        expect('}');\n\n        return {\n            type: Syntax.ObjectExpression,\n            properties: properties\n        };\n    }\n\n    // 11.1.6 The Grouping Operator\n\n    function parseGroupExpression() {\n        var expr;\n\n        expect('(');\n\n        expr = parseExpression();\n\n        expect(')');\n\n        return expr;\n    }\n\n\n    // 11.1 Primary Expressions\n\n    function parsePrimaryExpression() {\n        var token = lookahead(),\n            type = token.type;\n\n        if (type === Token.Identifier) {\n            return {\n                type: Syntax.Identifier,\n                name: lex().value\n            };\n        }\n\n        if (type === Token.StringLiteral || type === Token.NumericLiteral) {\n            if (strict && token.octal) {\n                throwErrorTolerant(token, Messages.StrictOctalLiteral);\n            }\n            return createLiteral(lex());\n        }\n\n        if (type === Token.Keyword) {\n            if (matchKeyword('this')) {\n                lex();\n                return {\n                    type: Syntax.ThisExpression\n                };\n            }\n\n            if (matchKeyword('function')) {\n                return parseFunctionExpression();\n            }\n        }\n\n        if (type === Token.BooleanLiteral) {\n            lex();\n            token.value = (token.value === 'true');\n            return createLiteral(token);\n        }\n\n        if (type === Token.NullLiteral) {\n            lex();\n            token.value = null;\n            return createLiteral(token);\n        }\n\n        if (match('[')) {\n            return parseArrayInitialiser();\n        }\n\n        if (match('{')) {\n            return parseObjectInitialiser();\n        }\n\n        if (match('(')) {\n            return parseGroupExpression();\n        }\n\n        if (match('/') || match('/=')) {\n            return createLiteral(scanRegExp());\n        }\n\n        return throwUnexpected(lex());\n    }\n\n    // 11.2 Left-Hand-Side Expressions\n\n    function parseArguments() {\n        var args = [];\n\n        expect('(');\n\n        if (!match(')')) {\n            while (index < length) {\n                args.push(parseAssignmentExpression());\n                if (match(')')) {\n                    break;\n                }\n                expect(',');\n            }\n        }\n\n        expect(')');\n\n        return args;\n    }\n\n    function parseNonComputedProperty() {\n        var token = lex();\n\n        if (!isIdentifierName(token)) {\n            throwUnexpected(token);\n        }\n\n        return {\n            type: Syntax.Identifier,\n            name: token.value\n        };\n    }\n\n    function parseNonComputedMember() {\n        expect('.');\n\n        return parseNonComputedProperty();\n    }\n\n    function parseComputedMember() {\n        var expr;\n\n        expect('[');\n\n        expr = parseExpression();\n\n        expect(']');\n\n        return expr;\n    }\n\n    function parseNewExpression() {\n        var expr;\n\n        expectKeyword('new');\n\n        expr = {\n            type: Syntax.NewExpression,\n            callee: parseLeftHandSideExpression(),\n            'arguments': []\n        };\n\n        if (match('(')) {\n            expr['arguments'] = parseArguments();\n        }\n\n        return expr;\n    }\n\n    function parseLeftHandSideExpressionAllowCall() {\n        var expr;\n\n        expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression();\n\n        while (match('.') || match('[') || match('(')) {\n            if (match('(')) {\n                expr = {\n                    type: Syntax.CallExpression,\n                    callee: expr,\n                    'arguments': parseArguments()\n                };\n            } else if (match('[')) {\n                expr = {\n                    type: Syntax.MemberExpression,\n                    computed: true,\n                    object: expr,\n                    property: parseComputedMember()\n                };\n            } else {\n                expr = {\n                    type: Syntax.MemberExpression,\n                    computed: false,\n                    object: expr,\n                    property: parseNonComputedMember()\n                };\n            }\n        }\n\n        return expr;\n    }\n\n\n    function parseLeftHandSideExpression() {\n        var expr;\n\n        expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression();\n\n        while (match('.') || match('[')) {\n            if (match('[')) {\n                expr = {\n                    type: Syntax.MemberExpression,\n                    computed: true,\n                    object: expr,\n                    property: parseComputedMember()\n                };\n            } else {\n                expr = {\n                    type: Syntax.MemberExpression,\n                    computed: false,\n                    object: expr,\n                    property: parseNonComputedMember()\n                };\n            }\n        }\n\n        return expr;\n    }\n\n    // 11.3 Postfix Expressions\n\n    function parsePostfixExpression() {\n        var expr = parseLeftHandSideExpressionAllowCall(), token;\n\n        token = lookahead();\n        if (token.type !== Token.Punctuator) {\n            return expr;\n        }\n\n        if ((match('++') || match('--')) && !peekLineTerminator()) {\n            // 11.3.1, 11.3.2\n            if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) {\n                throwErrorTolerant({}, Messages.StrictLHSPostfix);\n            }\n            if (!isLeftHandSide(expr)) {\n                throwErrorTolerant({}, Messages.InvalidLHSInAssignment);\n            }\n\n            expr = {\n                type: Syntax.UpdateExpression,\n                operator: lex().value,\n                argument: expr,\n                prefix: false\n            };\n        }\n\n        return expr;\n    }\n\n    // 11.4 Unary Operators\n\n    function parseUnaryExpression() {\n        var token, expr;\n\n        token = lookahead();\n        if (token.type !== Token.Punctuator && token.type !== Token.Keyword) {\n            return parsePostfixExpression();\n        }\n\n        if (match('++') || match('--')) {\n            token = lex();\n            expr = parseUnaryExpression();\n            // 11.4.4, 11.4.5\n            if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) {\n                throwErrorTolerant({}, Messages.StrictLHSPrefix);\n            }\n\n            if (!isLeftHandSide(expr)) {\n                throwErrorTolerant({}, Messages.InvalidLHSInAssignment);\n            }\n\n            expr = {\n                type: Syntax.UpdateExpression,\n                operator: token.value,\n                argument: expr,\n                prefix: true\n            };\n            return expr;\n        }\n\n        if (match('+') || match('-') || match('~') || match('!')) {\n            expr = {\n                type: Syntax.UnaryExpression,\n                operator: lex().value,\n                argument: parseUnaryExpression(),\n                prefix: true\n            };\n            return expr;\n        }\n\n        if (matchKeyword('delete') || matchKeyword('void') || matchKeyword('typeof')) {\n            expr = {\n                type: Syntax.UnaryExpression,\n                operator: lex().value,\n                argument: parseUnaryExpression(),\n                prefix: true\n            };\n            if (strict && expr.operator === 'delete' && expr.argument.type === Syntax.Identifier) {\n                throwErrorTolerant({}, Messages.StrictDelete);\n            }\n            return expr;\n        }\n\n        return parsePostfixExpression();\n    }\n\n    // 11.5 Multiplicative Operators\n\n    function parseMultiplicativeExpression() {\n        var expr = parseUnaryExpression();\n\n        while (match('*') || match('/') || match('%')) {\n            expr = {\n                type: Syntax.BinaryExpression,\n                operator: lex().value,\n                left: expr,\n                right: parseUnaryExpression()\n            };\n        }\n\n        return expr;\n    }\n\n    // 11.6 Additive Operators\n\n    function parseAdditiveExpression() {\n        var expr = parseMultiplicativeExpression();\n\n        while (match('+') || match('-')) {\n            expr = {\n                type: Syntax.BinaryExpression,\n                operator: lex().value,\n                left: expr,\n                right: parseMultiplicativeExpression()\n            };\n        }\n\n        return expr;\n    }\n\n    // 11.7 Bitwise Shift Operators\n\n    function parseShiftExpression() {\n        var expr = parseAdditiveExpression();\n\n        while (match('<<') || match('>>') || match('>>>')) {\n            expr = {\n                type: Syntax.BinaryExpression,\n                operator: lex().value,\n                left: expr,\n                right: parseAdditiveExpression()\n            };\n        }\n\n        return expr;\n    }\n    // 11.8 Relational Operators\n\n    function parseRelationalExpression() {\n        var expr, previousAllowIn;\n\n        previousAllowIn = state.allowIn;\n        state.allowIn = true;\n\n        expr = parseShiftExpression();\n\n        while (match('<') || match('>') || match('<=') || match('>=') || (previousAllowIn && matchKeyword('in')) || matchKeyword('instanceof')) {\n            expr = {\n                type: Syntax.BinaryExpression,\n                operator: lex().value,\n                left: expr,\n                right: parseShiftExpression()\n            };\n        }\n\n        state.allowIn = previousAllowIn;\n        return expr;\n    }\n\n    // 11.9 Equality Operators\n\n    function parseEqualityExpression() {\n        var expr = parseRelationalExpression();\n\n        while (match('==') || match('!=') || match('===') || match('!==')) {\n            expr = {\n                type: Syntax.BinaryExpression,\n                operator: lex().value,\n                left: expr,\n                right: parseRelationalExpression()\n            };\n        }\n\n        return expr;\n    }\n\n    // 11.10 Binary Bitwise Operators\n\n    function parseBitwiseANDExpression() {\n        var expr = parseEqualityExpression();\n\n        while (match('&')) {\n            lex();\n            expr = {\n                type: Syntax.BinaryExpression,\n                operator: '&',\n                left: expr,\n                right: parseEqualityExpression()\n            };\n        }\n\n        return expr;\n    }\n\n    function parseBitwiseXORExpression() {\n        var expr = parseBitwiseANDExpression();\n\n        while (match('^')) {\n            lex();\n            expr = {\n                type: Syntax.BinaryExpression,\n                operator: '^',\n                left: expr,\n                right: parseBitwiseANDExpression()\n            };\n        }\n\n        return expr;\n    }\n\n    function parseBitwiseORExpression() {\n        var expr = parseBitwiseXORExpression();\n\n        while (match('|')) {\n            lex();\n            expr = {\n                type: Syntax.BinaryExpression,\n                operator: '|',\n                left: expr,\n                right: parseBitwiseXORExpression()\n            };\n        }\n\n        return expr;\n    }\n\n    // 11.11 Binary Logical Operators\n\n    function parseLogicalANDExpression() {\n        var expr = parseBitwiseORExpression();\n\n        while (match('&&')) {\n            lex();\n            expr = {\n                type: Syntax.LogicalExpression,\n                operator: '&&',\n                left: expr,\n                right: parseBitwiseORExpression()\n            };\n        }\n\n        return expr;\n    }\n\n    function parseLogicalORExpression() {\n        var expr = parseLogicalANDExpression();\n\n        while (match('||')) {\n            lex();\n            expr = {\n                type: Syntax.LogicalExpression,\n                operator: '||',\n                left: expr,\n                right: parseLogicalANDExpression()\n            };\n        }\n\n        return expr;\n    }\n\n    // 11.12 Conditional Operator\n\n    function parseConditionalExpression() {\n        var expr, previousAllowIn, consequent;\n\n        expr = parseLogicalORExpression();\n\n        if (match('?')) {\n            lex();\n            previousAllowIn = state.allowIn;\n            state.allowIn = true;\n            consequent = parseAssignmentExpression();\n            state.allowIn = previousAllowIn;\n            expect(':');\n\n            expr = {\n                type: Syntax.ConditionalExpression,\n                test: expr,\n                consequent: consequent,\n                alternate: parseAssignmentExpression()\n            };\n        }\n\n        return expr;\n    }\n\n    // 11.13 Assignment Operators\n\n    function parseAssignmentExpression() {\n        var token, expr;\n\n        token = lookahead();\n        expr = parseConditionalExpression();\n\n        if (matchAssign()) {\n            // LeftHandSideExpression\n            if (!isLeftHandSide(expr)) {\n                throwErrorTolerant({}, Messages.InvalidLHSInAssignment);\n            }\n\n            // 11.13.1\n            if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) {\n                throwErrorTolerant(token, Messages.StrictLHSAssignment);\n            }\n\n            expr = {\n                type: Syntax.AssignmentExpression,\n                operator: lex().value,\n                left: expr,\n                right: parseAssignmentExpression()\n            };\n        }\n\n        return expr;\n    }\n\n    // 11.14 Comma Operator\n\n    function parseExpression() {\n        var expr = parseAssignmentExpression();\n\n        if (match(',')) {\n            expr = {\n                type: Syntax.SequenceExpression,\n                expressions: [ expr ]\n            };\n\n            while (index < length) {\n                if (!match(',')) {\n                    break;\n                }\n                lex();\n                expr.expressions.push(parseAssignmentExpression());\n            }\n\n        }\n        return expr;\n    }\n\n    // 12.1 Block\n\n    function parseStatementList() {\n        var list = [],\n            statement;\n\n        while (index < length) {\n            if (match('}')) {\n                break;\n            }\n            statement = parseSourceElement();\n            if (typeof statement === 'undefined') {\n                break;\n            }\n            list.push(statement);\n        }\n\n        return list;\n    }\n\n    function parseBlock() {\n        var block;\n\n        expect('{');\n\n        block = parseStatementList();\n\n        expect('}');\n\n        return {\n            type: Syntax.BlockStatement,\n            body: block\n        };\n    }\n\n    // 12.2 Variable Statement\n\n    function parseVariableIdentifier() {\n        var token = lex();\n\n        if (token.type !== Token.Identifier) {\n            throwUnexpected(token);\n        }\n\n        return {\n            type: Syntax.Identifier,\n            name: token.value\n        };\n    }\n\n    function parseVariableDeclaration(kind) {\n        var id = parseVariableIdentifier(),\n            init = null;\n\n        // 12.2.1\n        if (strict && isRestrictedWord(id.name)) {\n            throwErrorTolerant({}, Messages.StrictVarName);\n        }\n\n        if (kind === 'const') {\n            expect('=');\n            init = parseAssignmentExpression();\n        } else if (match('=')) {\n            lex();\n            init = parseAssignmentExpression();\n        }\n\n        return {\n            type: Syntax.VariableDeclarator,\n            id: id,\n            init: init\n        };\n    }\n\n    function parseVariableDeclarationList(kind) {\n        var list = [];\n\n        do {\n            list.push(parseVariableDeclaration(kind));\n            if (!match(',')) {\n                break;\n            }\n            lex();\n        } while (index < length);\n\n        return list;\n    }\n\n    function parseVariableStatement() {\n        var declarations;\n\n        expectKeyword('var');\n\n        declarations = parseVariableDeclarationList();\n\n        consumeSemicolon();\n\n        return {\n            type: Syntax.VariableDeclaration,\n            declarations: declarations,\n            kind: 'var'\n        };\n    }\n\n    // kind may be `const` or `let`\n    // Both are experimental and not in the specification yet.\n    // see http://wiki.ecmascript.org/doku.php?id=harmony:const\n    // and http://wiki.ecmascript.org/doku.php?id=harmony:let\n    function parseConstLetDeclaration(kind) {\n        var declarations;\n\n        expectKeyword(kind);\n\n        declarations = parseVariableDeclarationList(kind);\n\n        consumeSemicolon();\n\n        return {\n            type: Syntax.VariableDeclaration,\n            declarations: declarations,\n            kind: kind\n        };\n    }\n\n    // 12.3 Empty Statement\n\n    function parseEmptyStatement() {\n        expect(';');\n\n        return {\n            type: Syntax.EmptyStatement\n        };\n    }\n\n    // 12.4 Expression Statement\n\n    function parseExpressionStatement() {\n        var expr = parseExpression();\n\n        consumeSemicolon();\n\n        return {\n            type: Syntax.ExpressionStatement,\n            expression: expr\n        };\n    }\n\n    // 12.5 If statement\n\n    function parseIfStatement() {\n        var test, consequent, alternate;\n\n        expectKeyword('if');\n\n        expect('(');\n\n        test = parseExpression();\n\n        expect(')');\n\n        consequent = parseStatement();\n\n        if (matchKeyword('else')) {\n            lex();\n            alternate = parseStatement();\n        } else {\n            alternate = null;\n        }\n\n        return {\n            type: Syntax.IfStatement,\n            test: test,\n            consequent: consequent,\n            alternate: alternate\n        };\n    }\n\n    // 12.6 Iteration Statements\n\n    function parseDoWhileStatement() {\n        var body, test, oldInIteration;\n\n        expectKeyword('do');\n\n        oldInIteration = state.inIteration;\n        state.inIteration = true;\n\n        body = parseStatement();\n\n        state.inIteration = oldInIteration;\n\n        expectKeyword('while');\n\n        expect('(');\n\n        test = parseExpression();\n\n        expect(')');\n\n        if (match(';')) {\n            lex();\n        }\n\n        return {\n            type: Syntax.DoWhileStatement,\n            body: body,\n            test: test\n        };\n    }\n\n    function parseWhileStatement() {\n        var test, body, oldInIteration;\n\n        expectKeyword('while');\n\n        expect('(');\n\n        test = parseExpression();\n\n        expect(')');\n\n        oldInIteration = state.inIteration;\n        state.inIteration = true;\n\n        body = parseStatement();\n\n        state.inIteration = oldInIteration;\n\n        return {\n            type: Syntax.WhileStatement,\n            test: test,\n            body: body\n        };\n    }\n\n    function parseForVariableDeclaration() {\n        var token = lex();\n\n        return {\n            type: Syntax.VariableDeclaration,\n            declarations: parseVariableDeclarationList(),\n            kind: token.value\n        };\n    }\n\n    function parseForStatement() {\n        var init, test, update, left, right, body, oldInIteration;\n\n        init = test = update = null;\n\n        expectKeyword('for');\n\n        expect('(');\n\n        if (match(';')) {\n            lex();\n        } else {\n            if (matchKeyword('var') || matchKeyword('let')) {\n                state.allowIn = false;\n                init = parseForVariableDeclaration();\n                state.allowIn = true;\n\n                if (init.declarations.length === 1 && matchKeyword('in')) {\n                    lex();\n                    left = init;\n                    right = parseExpression();\n                    init = null;\n                }\n            } else {\n                state.allowIn = false;\n                init = parseExpression();\n                state.allowIn = true;\n\n                if (matchKeyword('in')) {\n                    // LeftHandSideExpression\n                    if (!isLeftHandSide(init)) {\n                        throwErrorTolerant({}, Messages.InvalidLHSInForIn);\n                    }\n\n                    lex();\n                    left = init;\n                    right = parseExpression();\n                    init = null;\n                }\n            }\n\n            if (typeof left === 'undefined') {\n                expect(';');\n            }\n        }\n\n        if (typeof left === 'undefined') {\n\n            if (!match(';')) {\n                test = parseExpression();\n            }\n            expect(';');\n\n            if (!match(')')) {\n                update = parseExpression();\n            }\n        }\n\n        expect(')');\n\n        oldInIteration = state.inIteration;\n        state.inIteration = true;\n\n        body = parseStatement();\n\n        state.inIteration = oldInIteration;\n\n        if (typeof left === 'undefined') {\n            return {\n                type: Syntax.ForStatement,\n                init: init,\n                test: test,\n                update: update,\n                body: body\n            };\n        }\n\n        return {\n            type: Syntax.ForInStatement,\n            left: left,\n            right: right,\n            body: body,\n            each: false\n        };\n    }\n\n    // 12.7 The continue statement\n\n    function parseContinueStatement() {\n        var token, label = null;\n\n        expectKeyword('continue');\n\n        // Optimize the most common form: 'continue;'.\n        if (source[index] === ';') {\n            lex();\n\n            if (!state.inIteration) {\n                throwError({}, Messages.IllegalContinue);\n            }\n\n            return {\n                type: Syntax.ContinueStatement,\n                label: null\n            };\n        }\n\n        if (peekLineTerminator()) {\n            if (!state.inIteration) {\n                throwError({}, Messages.IllegalContinue);\n            }\n\n            return {\n                type: Syntax.ContinueStatement,\n                label: null\n            };\n        }\n\n        token = lookahead();\n        if (token.type === Token.Identifier) {\n            label = parseVariableIdentifier();\n\n            if (!Object.prototype.hasOwnProperty.call(state.labelSet, label.name)) {\n                throwError({}, Messages.UnknownLabel, label.name);\n            }\n        }\n\n        consumeSemicolon();\n\n        if (label === null && !state.inIteration) {\n            throwError({}, Messages.IllegalContinue);\n        }\n\n        return {\n            type: Syntax.ContinueStatement,\n            label: label\n        };\n    }\n\n    // 12.8 The break statement\n\n    function parseBreakStatement() {\n        var token, label = null;\n\n        expectKeyword('break');\n\n        // Optimize the most common form: 'break;'.\n        if (source[index] === ';') {\n            lex();\n\n            if (!(state.inIteration || state.inSwitch)) {\n                throwError({}, Messages.IllegalBreak);\n            }\n\n            return {\n                type: Syntax.BreakStatement,\n                label: null\n            };\n        }\n\n        if (peekLineTerminator()) {\n            if (!(state.inIteration || state.inSwitch)) {\n                throwError({}, Messages.IllegalBreak);\n            }\n\n            return {\n                type: Syntax.BreakStatement,\n                label: null\n            };\n        }\n\n        token = lookahead();\n        if (token.type === Token.Identifier) {\n            label = parseVariableIdentifier();\n\n            if (!Object.prototype.hasOwnProperty.call(state.labelSet, label.name)) {\n                throwError({}, Messages.UnknownLabel, label.name);\n            }\n        }\n\n        consumeSemicolon();\n\n        if (label === null && !(state.inIteration || state.inSwitch)) {\n            throwError({}, Messages.IllegalBreak);\n        }\n\n        return {\n            type: Syntax.BreakStatement,\n            label: label\n        };\n    }\n\n    // 12.9 The return statement\n\n    function parseReturnStatement() {\n        var token, argument = null;\n\n        expectKeyword('return');\n\n        if (!state.inFunctionBody) {\n            throwErrorTolerant({}, Messages.IllegalReturn);\n        }\n\n        // 'return' followed by a space and an identifier is very common.\n        if (source[index] === ' ') {\n            if (isIdentifierStart(source[index + 1])) {\n                argument = parseExpression();\n                consumeSemicolon();\n                return {\n                    type: Syntax.ReturnStatement,\n                    argument: argument\n                };\n            }\n        }\n\n        if (peekLineTerminator()) {\n            return {\n                type: Syntax.ReturnStatement,\n                argument: null\n            };\n        }\n\n        if (!match(';')) {\n            token = lookahead();\n            if (!match('}') && token.type !== Token.EOF) {\n                argument = parseExpression();\n            }\n        }\n\n        consumeSemicolon();\n\n        return {\n            type: Syntax.ReturnStatement,\n            argument: argument\n        };\n    }\n\n    // 12.10 The with statement\n\n    function parseWithStatement() {\n        var object, body;\n\n        if (strict) {\n            throwErrorTolerant({}, Messages.StrictModeWith);\n        }\n\n        expectKeyword('with');\n\n        expect('(');\n\n        object = parseExpression();\n\n        expect(')');\n\n        body = parseStatement();\n\n        return {\n            type: Syntax.WithStatement,\n            object: object,\n            body: body\n        };\n    }\n\n    // 12.10 The swith statement\n\n    function parseSwitchCase() {\n        var test,\n            consequent = [],\n            statement;\n\n        if (matchKeyword('default')) {\n            lex();\n            test = null;\n        } else {\n            expectKeyword('case');\n            test = parseExpression();\n        }\n        expect(':');\n\n        while (index < length) {\n            if (match('}') || matchKeyword('default') || matchKeyword('case')) {\n                break;\n            }\n            statement = parseStatement();\n            if (typeof statement === 'undefined') {\n                break;\n            }\n            consequent.push(statement);\n        }\n\n        return {\n            type: Syntax.SwitchCase,\n            test: test,\n            consequent: consequent\n        };\n    }\n\n    function parseSwitchStatement() {\n        var discriminant, cases, clause, oldInSwitch, defaultFound;\n\n        expectKeyword('switch');\n\n        expect('(');\n\n        discriminant = parseExpression();\n\n        expect(')');\n\n        expect('{');\n\n        cases = [];\n\n        if (match('}')) {\n            lex();\n            return {\n                type: Syntax.SwitchStatement,\n                discriminant: discriminant,\n                cases: cases\n            };\n        }\n\n        oldInSwitch = state.inSwitch;\n        state.inSwitch = true;\n        defaultFound = false;\n\n        while (index < length) {\n            if (match('}')) {\n                break;\n            }\n            clause = parseSwitchCase();\n            if (clause.test === null) {\n                if (defaultFound) {\n                    throwError({}, Messages.MultipleDefaultsInSwitch);\n                }\n                defaultFound = true;\n            }\n            cases.push(clause);\n        }\n\n        state.inSwitch = oldInSwitch;\n\n        expect('}');\n\n        return {\n            type: Syntax.SwitchStatement,\n            discriminant: discriminant,\n            cases: cases\n        };\n    }\n\n    // 12.13 The throw statement\n\n    function parseThrowStatement() {\n        var argument;\n\n        expectKeyword('throw');\n\n        if (peekLineTerminator()) {\n            throwError({}, Messages.NewlineAfterThrow);\n        }\n\n        argument = parseExpression();\n\n        consumeSemicolon();\n\n        return {\n            type: Syntax.ThrowStatement,\n            argument: argument\n        };\n    }\n\n    // 12.14 The try statement\n\n    function parseCatchClause() {\n        var param;\n\n        expectKeyword('catch');\n\n        expect('(');\n        if (match(')')) {\n            throwUnexpected(lookahead());\n        }\n\n        param = parseVariableIdentifier();\n        // 12.14.1\n        if (strict && isRestrictedWord(param.name)) {\n            throwErrorTolerant({}, Messages.StrictCatchVariable);\n        }\n\n        expect(')');\n\n        return {\n            type: Syntax.CatchClause,\n            param: param,\n            body: parseBlock()\n        };\n    }\n\n    function parseTryStatement() {\n        var block, handlers = [], finalizer = null;\n\n        expectKeyword('try');\n\n        block = parseBlock();\n\n        if (matchKeyword('catch')) {\n            handlers.push(parseCatchClause());\n        }\n\n        if (matchKeyword('finally')) {\n            lex();\n            finalizer = parseBlock();\n        }\n\n        if (handlers.length === 0 && !finalizer) {\n            throwError({}, Messages.NoCatchOrFinally);\n        }\n\n        return {\n            type: Syntax.TryStatement,\n            block: block,\n            guardedHandlers: [],\n            handlers: handlers,\n            finalizer: finalizer\n        };\n    }\n\n    // 12.15 The debugger statement\n\n    function parseDebuggerStatement() {\n        expectKeyword('debugger');\n\n        consumeSemicolon();\n\n        return {\n            type: Syntax.DebuggerStatement\n        };\n    }\n\n    // 12 Statements\n\n    function parseStatement() {\n        var token = lookahead(),\n            expr,\n            labeledBody;\n\n        if (token.type === Token.EOF) {\n            throwUnexpected(token);\n        }\n\n        if (token.type === Token.Punctuator) {\n            switch (token.value) {\n            case ';':\n                return parseEmptyStatement();\n            case '{':\n                return parseBlock();\n            case '(':\n                return parseExpressionStatement();\n            default:\n                break;\n            }\n        }\n\n        if (token.type === Token.Keyword) {\n            switch (token.value) {\n            case 'break':\n                return parseBreakStatement();\n            case 'continue':\n                return parseContinueStatement();\n            case 'debugger':\n                return parseDebuggerStatement();\n            case 'do':\n                return parseDoWhileStatement();\n            case 'for':\n                return parseForStatement();\n            case 'function':\n                return parseFunctionDeclaration();\n            case 'if':\n                return parseIfStatement();\n            case 'return':\n                return parseReturnStatement();\n            case 'switch':\n                return parseSwitchStatement();\n            case 'throw':\n                return parseThrowStatement();\n            case 'try':\n                return parseTryStatement();\n            case 'var':\n                return parseVariableStatement();\n            case 'while':\n                return parseWhileStatement();\n            case 'with':\n                return parseWithStatement();\n            default:\n                break;\n            }\n        }\n\n        expr = parseExpression();\n\n        // 12.12 Labelled Statements\n        if ((expr.type === Syntax.Identifier) && match(':')) {\n            lex();\n\n            if (Object.prototype.hasOwnProperty.call(state.labelSet, expr.name)) {\n                throwError({}, Messages.Redeclaration, 'Label', expr.name);\n            }\n\n            state.labelSet[expr.name] = true;\n            labeledBody = parseStatement();\n            delete state.labelSet[expr.name];\n\n            return {\n                type: Syntax.LabeledStatement,\n                label: expr,\n                body: labeledBody\n            };\n        }\n\n        consumeSemicolon();\n\n        return {\n            type: Syntax.ExpressionStatement,\n            expression: expr\n        };\n    }\n\n    // 13 Function Definition\n\n    function parseFunctionSourceElements() {\n        var sourceElement, sourceElements = [], token, directive, firstRestricted,\n            oldLabelSet, oldInIteration, oldInSwitch, oldInFunctionBody;\n\n        expect('{');\n\n        while (index < length) {\n            token = lookahead();\n            if (token.type !== Token.StringLiteral) {\n                break;\n            }\n\n            sourceElement = parseSourceElement();\n            sourceElements.push(sourceElement);\n            if (sourceElement.expression.type !== Syntax.Literal) {\n                // this is not directive\n                break;\n            }\n            directive = sliceSource(token.range[0] + 1, token.range[1] - 1);\n            if (directive === 'use strict') {\n                strict = true;\n                if (firstRestricted) {\n                    throwErrorTolerant(firstRestricted, Messages.StrictOctalLiteral);\n                }\n            } else {\n                if (!firstRestricted && token.octal) {\n                    firstRestricted = token;\n                }\n            }\n        }\n\n        oldLabelSet = state.labelSet;\n        oldInIteration = state.inIteration;\n        oldInSwitch = state.inSwitch;\n        oldInFunctionBody = state.inFunctionBody;\n\n        state.labelSet = {};\n        state.inIteration = false;\n        state.inSwitch = false;\n        state.inFunctionBody = true;\n\n        while (index < length) {\n            if (match('}')) {\n                break;\n            }\n            sourceElement = parseSourceElement();\n            if (typeof sourceElement === 'undefined') {\n                break;\n            }\n            sourceElements.push(sourceElement);\n        }\n\n        expect('}');\n\n        state.labelSet = oldLabelSet;\n        state.inIteration = oldInIteration;\n        state.inSwitch = oldInSwitch;\n        state.inFunctionBody = oldInFunctionBody;\n\n        return {\n            type: Syntax.BlockStatement,\n            body: sourceElements\n        };\n    }\n\n    function parseFunctionDeclaration() {\n        var id, param, params = [], body, token, stricted, firstRestricted, message, previousStrict, paramSet;\n\n        expectKeyword('function');\n        token = lookahead();\n        id = parseVariableIdentifier();\n        if (strict) {\n            if (isRestrictedWord(token.value)) {\n                throwErrorTolerant(token, Messages.StrictFunctionName);\n            }\n        } else {\n            if (isRestrictedWord(token.value)) {\n                firstRestricted = token;\n                message = Messages.StrictFunctionName;\n            } else if (isStrictModeReservedWord(token.value)) {\n                firstRestricted = token;\n                message = Messages.StrictReservedWord;\n            }\n        }\n\n        expect('(');\n\n        if (!match(')')) {\n            paramSet = {};\n            while (index < length) {\n                token = lookahead();\n                param = parseVariableIdentifier();\n                if (strict) {\n                    if (isRestrictedWord(token.value)) {\n                        stricted = token;\n                        message = Messages.StrictParamName;\n                    }\n                    if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) {\n                        stricted = token;\n                        message = Messages.StrictParamDupe;\n                    }\n                } else if (!firstRestricted) {\n                    if (isRestrictedWord(token.value)) {\n                        firstRestricted = token;\n                        message = Messages.StrictParamName;\n                    } else if (isStrictModeReservedWord(token.value)) {\n                        firstRestricted = token;\n                        message = Messages.StrictReservedWord;\n                    } else if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) {\n                        firstRestricted = token;\n                        message = Messages.StrictParamDupe;\n                    }\n                }\n                params.push(param);\n                paramSet[param.name] = true;\n                if (match(')')) {\n                    break;\n                }\n                expect(',');\n            }\n        }\n\n        expect(')');\n\n        previousStrict = strict;\n        body = parseFunctionSourceElements();\n        if (strict && firstRestricted) {\n            throwError(firstRestricted, message);\n        }\n        if (strict && stricted) {\n            throwErrorTolerant(stricted, message);\n        }\n        strict = previousStrict;\n\n        return {\n            type: Syntax.FunctionDeclaration,\n            id: id,\n            params: params,\n            defaults: [],\n            body: body,\n            rest: null,\n            generator: false,\n            expression: false\n        };\n    }\n\n    function parseFunctionExpression() {\n        var token, id = null, stricted, firstRestricted, message, param, params = [], body, previousStrict, paramSet;\n\n        expectKeyword('function');\n\n        if (!match('(')) {\n            token = lookahead();\n            id = parseVariableIdentifier();\n            if (strict) {\n                if (isRestrictedWord(token.value)) {\n                    throwErrorTolerant(token, Messages.StrictFunctionName);\n                }\n            } else {\n                if (isRestrictedWord(token.value)) {\n                    firstRestricted = token;\n                    message = Messages.StrictFunctionName;\n                } else if (isStrictModeReservedWord(token.value)) {\n                    firstRestricted = token;\n                    message = Messages.StrictReservedWord;\n                }\n            }\n        }\n\n        expect('(');\n\n        if (!match(')')) {\n            paramSet = {};\n            while (index < length) {\n                token = lookahead();\n                param = parseVariableIdentifier();\n                if (strict) {\n                    if (isRestrictedWord(token.value)) {\n                        stricted = token;\n                        message = Messages.StrictParamName;\n                    }\n                    if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) {\n                        stricted = token;\n                        message = Messages.StrictParamDupe;\n                    }\n                } else if (!firstRestricted) {\n                    if (isRestrictedWord(token.value)) {\n                        firstRestricted = token;\n                        message = Messages.StrictParamName;\n                    } else if (isStrictModeReservedWord(token.value)) {\n                        firstRestricted = token;\n                        message = Messages.StrictReservedWord;\n                    } else if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) {\n                        firstRestricted = token;\n                        message = Messages.StrictParamDupe;\n                    }\n                }\n                params.push(param);\n                paramSet[param.name] = true;\n                if (match(')')) {\n                    break;\n                }\n                expect(',');\n            }\n        }\n\n        expect(')');\n\n        previousStrict = strict;\n        body = parseFunctionSourceElements();\n        if (strict && firstRestricted) {\n            throwError(firstRestricted, message);\n        }\n        if (strict && stricted) {\n            throwErrorTolerant(stricted, message);\n        }\n        strict = previousStrict;\n\n        return {\n            type: Syntax.FunctionExpression,\n            id: id,\n            params: params,\n            defaults: [],\n            body: body,\n            rest: null,\n            generator: false,\n            expression: false\n        };\n    }\n\n    // 14 Program\n\n    function parseSourceElement() {\n        var token = lookahead();\n\n        if (token.type === Token.Keyword) {\n            switch (token.value) {\n            case 'const':\n            case 'let':\n                return parseConstLetDeclaration(token.value);\n            case 'function':\n                return parseFunctionDeclaration();\n            default:\n                return parseStatement();\n            }\n        }\n\n        if (token.type !== Token.EOF) {\n            return parseStatement();\n        }\n    }\n\n    function parseSourceElements() {\n        var sourceElement, sourceElements = [], token, directive, firstRestricted;\n\n        while (index < length) {\n            token = lookahead();\n            if (token.type !== Token.StringLiteral) {\n                break;\n            }\n\n            sourceElement = parseSourceElement();\n            sourceElements.push(sourceElement);\n            if (sourceElement.expression.type !== Syntax.Literal) {\n                // this is not directive\n                break;\n            }\n            directive = sliceSource(token.range[0] + 1, token.range[1] - 1);\n            if (directive === 'use strict') {\n                strict = true;\n                if (firstRestricted) {\n                    throwErrorTolerant(firstRestricted, Messages.StrictOctalLiteral);\n                }\n            } else {\n                if (!firstRestricted && token.octal) {\n                    firstRestricted = token;\n                }\n            }\n        }\n\n        while (index < length) {\n            sourceElement = parseSourceElement();\n            if (typeof sourceElement === 'undefined') {\n                break;\n            }\n            sourceElements.push(sourceElement);\n        }\n        return sourceElements;\n    }\n\n    function parseProgram() {\n        var program;\n        strict = false;\n        program = {\n            type: Syntax.Program,\n            body: parseSourceElements()\n        };\n        return program;\n    }\n\n    // The following functions are needed only when the option to preserve\n    // the comments is active.\n\n    function addComment(type, value, start, end, loc) {\n        assert(typeof start === 'number', 'Comment must have valid position');\n\n        // Because the way the actual token is scanned, often the comments\n        // (if any) are skipped twice during the lexical analysis.\n        // Thus, we need to skip adding a comment if the comment array already\n        // handled it.\n        if (extra.comments.length > 0) {\n            if (extra.comments[extra.comments.length - 1].range[1] > start) {\n                return;\n            }\n        }\n\n        extra.comments.push({\n            type: type,\n            value: value,\n            range: [start, end],\n            loc: loc\n        });\n    }\n\n    function scanComment() {\n        var comment, ch, loc, start, blockComment, lineComment;\n\n        comment = '';\n        blockComment = false;\n        lineComment = false;\n\n        while (index < length) {\n            ch = source[index];\n\n            if (lineComment) {\n                ch = source[index++];\n                if (isLineTerminator(ch)) {\n                    loc.end = {\n                        line: lineNumber,\n                        column: index - lineStart - 1\n                    };\n                    lineComment = false;\n                    addComment('Line', comment, start, index - 1, loc);\n                    if (ch === '\\r' && source[index] === '\\n') {\n                        ++index;\n                    }\n                    ++lineNumber;\n                    lineStart = index;\n                    comment = '';\n                } else if (index >= length) {\n                    lineComment = false;\n                    comment += ch;\n                    loc.end = {\n                        line: lineNumber,\n                        column: length - lineStart\n                    };\n                    addComment('Line', comment, start, length, loc);\n                } else {\n                    comment += ch;\n                }\n            } else if (blockComment) {\n                if (isLineTerminator(ch)) {\n                    if (ch === '\\r' && source[index + 1] === '\\n') {\n                        ++index;\n                        comment += '\\r\\n';\n                    } else {\n                        comment += ch;\n                    }\n                    ++lineNumber;\n                    ++index;\n                    lineStart = index;\n                    if (index >= length) {\n                        throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n                    }\n                } else {\n                    ch = source[index++];\n                    if (index >= length) {\n                        throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n                    }\n                    comment += ch;\n                    if (ch === '*') {\n                        ch = source[index];\n                        if (ch === '/') {\n                            comment = comment.substr(0, comment.length - 1);\n                            blockComment = false;\n                            ++index;\n                            loc.end = {\n                                line: lineNumber,\n                                column: index - lineStart\n                            };\n                            addComment('Block', comment, start, index, loc);\n                            comment = '';\n                        }\n                    }\n                }\n            } else if (ch === '/') {\n                ch = source[index + 1];\n                if (ch === '/') {\n                    loc = {\n                        start: {\n                            line: lineNumber,\n                            column: index - lineStart\n                        }\n                    };\n                    start = index;\n                    index += 2;\n                    lineComment = true;\n                    if (index >= length) {\n                        loc.end = {\n                            line: lineNumber,\n                            column: index - lineStart\n                        };\n                        lineComment = false;\n                        addComment('Line', comment, start, index, loc);\n                    }\n                } else if (ch === '*') {\n                    start = index;\n                    index += 2;\n                    blockComment = true;\n                    loc = {\n                        start: {\n                            line: lineNumber,\n                            column: index - lineStart - 2\n                        }\n                    };\n                    if (index >= length) {\n                        throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n                    }\n                } else {\n                    break;\n                }\n            } else if (isWhiteSpace(ch)) {\n                ++index;\n            } else if (isLineTerminator(ch)) {\n                ++index;\n                if (ch ===  '\\r' && source[index] === '\\n') {\n                    ++index;\n                }\n                ++lineNumber;\n                lineStart = index;\n            } else {\n                break;\n            }\n        }\n    }\n\n    function filterCommentLocation() {\n        var i, entry, comment, comments = [];\n\n        for (i = 0; i < extra.comments.length; ++i) {\n            entry = extra.comments[i];\n            comment = {\n                type: entry.type,\n                value: entry.value\n            };\n            if (extra.range) {\n                comment.range = entry.range;\n            }\n            if (extra.loc) {\n                comment.loc = entry.loc;\n            }\n            comments.push(comment);\n        }\n\n        extra.comments = comments;\n    }\n\n    function collectToken() {\n        var start, loc, token, range, value;\n\n        skipComment();\n        start = index;\n        loc = {\n            start: {\n                line: lineNumber,\n                column: index - lineStart\n            }\n        };\n\n        token = extra.advance();\n        loc.end = {\n            line: lineNumber,\n            column: index - lineStart\n        };\n\n        if (token.type !== Token.EOF) {\n            range = [token.range[0], token.range[1]];\n            value = sliceSource(token.range[0], token.range[1]);\n            extra.tokens.push({\n                type: TokenName[token.type],\n                value: value,\n                range: range,\n                loc: loc\n            });\n        }\n\n        return token;\n    }\n\n    function collectRegex() {\n        var pos, loc, regex, token;\n\n        skipComment();\n\n        pos = index;\n        loc = {\n            start: {\n                line: lineNumber,\n                column: index - lineStart\n            }\n        };\n\n        regex = extra.scanRegExp();\n        loc.end = {\n            line: lineNumber,\n            column: index - lineStart\n        };\n\n        // Pop the previous token, which is likely '/' or '/='\n        if (extra.tokens.length > 0) {\n            token = extra.tokens[extra.tokens.length - 1];\n            if (token.range[0] === pos && token.type === 'Punctuator') {\n                if (token.value === '/' || token.value === '/=') {\n                    extra.tokens.pop();\n                }\n            }\n        }\n\n        extra.tokens.push({\n            type: 'RegularExpression',\n            value: regex.literal,\n            range: [pos, index],\n            loc: loc\n        });\n\n        return regex;\n    }\n\n    function filterTokenLocation() {\n        var i, entry, token, tokens = [];\n\n        for (i = 0; i < extra.tokens.length; ++i) {\n            entry = extra.tokens[i];\n            token = {\n                type: entry.type,\n                value: entry.value\n            };\n            if (extra.range) {\n                token.range = entry.range;\n            }\n            if (extra.loc) {\n                token.loc = entry.loc;\n            }\n            tokens.push(token);\n        }\n\n        extra.tokens = tokens;\n    }\n\n    function createLiteral(token) {\n        return {\n            type: Syntax.Literal,\n            value: token.value\n        };\n    }\n\n    function createRawLiteral(token) {\n        return {\n            type: Syntax.Literal,\n            value: token.value,\n            raw: sliceSource(token.range[0], token.range[1])\n        };\n    }\n\n    function createLocationMarker() {\n        var marker = {};\n\n        marker.range = [index, index];\n        marker.loc = {\n            start: {\n                line: lineNumber,\n                column: index - lineStart\n            },\n            end: {\n                line: lineNumber,\n                column: index - lineStart\n            }\n        };\n\n        marker.end = function () {\n            this.range[1] = index;\n            this.loc.end.line = lineNumber;\n            this.loc.end.column = index - lineStart;\n        };\n\n        marker.applyGroup = function (node) {\n            if (extra.range) {\n                node.groupRange = [this.range[0], this.range[1]];\n            }\n            if (extra.loc) {\n                node.groupLoc = {\n                    start: {\n                        line: this.loc.start.line,\n                        column: this.loc.start.column\n                    },\n                    end: {\n                        line: this.loc.end.line,\n                        column: this.loc.end.column\n                    }\n                };\n            }\n        };\n\n        marker.apply = function (node) {\n            if (extra.range) {\n                node.range = [this.range[0], this.range[1]];\n            }\n            if (extra.loc) {\n                node.loc = {\n                    start: {\n                        line: this.loc.start.line,\n                        column: this.loc.start.column\n                    },\n                    end: {\n                        line: this.loc.end.line,\n                        column: this.loc.end.column\n                    }\n                };\n            }\n        };\n\n        return marker;\n    }\n\n    function trackGroupExpression() {\n        var marker, expr;\n\n        skipComment();\n        marker = createLocationMarker();\n        expect('(');\n\n        expr = parseExpression();\n\n        expect(')');\n\n        marker.end();\n        marker.applyGroup(expr);\n\n        return expr;\n    }\n\n    function trackLeftHandSideExpression() {\n        var marker, expr;\n\n        skipComment();\n        marker = createLocationMarker();\n\n        expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression();\n\n        while (match('.') || match('[')) {\n            if (match('[')) {\n                expr = {\n                    type: Syntax.MemberExpression,\n                    computed: true,\n                    object: expr,\n                    property: parseComputedMember()\n                };\n                marker.end();\n                marker.apply(expr);\n            } else {\n                expr = {\n                    type: Syntax.MemberExpression,\n                    computed: false,\n                    object: expr,\n                    property: parseNonComputedMember()\n                };\n                marker.end();\n                marker.apply(expr);\n            }\n        }\n\n        return expr;\n    }\n\n    function trackLeftHandSideExpressionAllowCall() {\n        var marker, expr;\n\n        skipComment();\n        marker = createLocationMarker();\n\n        expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression();\n\n        while (match('.') || match('[') || match('(')) {\n            if (match('(')) {\n                expr = {\n                    type: Syntax.CallExpression,\n                    callee: expr,\n                    'arguments': parseArguments()\n                };\n                marker.end();\n                marker.apply(expr);\n            } else if (match('[')) {\n                expr = {\n                    type: Syntax.MemberExpression,\n                    computed: true,\n                    object: expr,\n                    property: parseComputedMember()\n                };\n                marker.end();\n                marker.apply(expr);\n            } else {\n                expr = {\n                    type: Syntax.MemberExpression,\n                    computed: false,\n                    object: expr,\n                    property: parseNonComputedMember()\n                };\n                marker.end();\n                marker.apply(expr);\n            }\n        }\n\n        return expr;\n    }\n\n    function filterGroup(node) {\n        var n, i, entry;\n\n        n = (Object.prototype.toString.apply(node) === '[object Array]') ? [] : {};\n        for (i in node) {\n            if (node.hasOwnProperty(i) && i !== 'groupRange' && i !== 'groupLoc') {\n                entry = node[i];\n                if (entry === null || typeof entry !== 'object' || entry instanceof RegExp) {\n                    n[i] = entry;\n                } else {\n                    n[i] = filterGroup(entry);\n                }\n            }\n        }\n        return n;\n    }\n\n    function wrapTrackingFunction(range, loc) {\n\n        return function (parseFunction) {\n\n            function isBinary(node) {\n                return node.type === Syntax.LogicalExpression ||\n                    node.type === Syntax.BinaryExpression;\n            }\n\n            function visit(node) {\n                var start, end;\n\n                if (isBinary(node.left)) {\n                    visit(node.left);\n                }\n                if (isBinary(node.right)) {\n                    visit(node.right);\n                }\n\n                if (range) {\n                    if (node.left.groupRange || node.right.groupRange) {\n                        start = node.left.groupRange ? node.left.groupRange[0] : node.left.range[0];\n                        end = node.right.groupRange ? node.right.groupRange[1] : node.right.range[1];\n                        node.range = [start, end];\n                    } else if (typeof node.range === 'undefined') {\n                        start = node.left.range[0];\n                        end = node.right.range[1];\n                        node.range = [start, end];\n                    }\n                }\n                if (loc) {\n                    if (node.left.groupLoc || node.right.groupLoc) {\n                        start = node.left.groupLoc ? node.left.groupLoc.start : node.left.loc.start;\n                        end = node.right.groupLoc ? node.right.groupLoc.end : node.right.loc.end;\n                        node.loc = {\n                            start: start,\n                            end: end\n                        };\n                    } else if (typeof node.loc === 'undefined') {\n                        node.loc = {\n                            start: node.left.loc.start,\n                            end: node.right.loc.end\n                        };\n                    }\n                }\n            }\n\n            return function () {\n                var marker, node;\n\n                skipComment();\n\n                marker = createLocationMarker();\n                node = parseFunction.apply(null, arguments);\n                marker.end();\n\n                if (range && typeof node.range === 'undefined') {\n                    marker.apply(node);\n                }\n\n                if (loc && typeof node.loc === 'undefined') {\n                    marker.apply(node);\n                }\n\n                if (isBinary(node)) {\n                    visit(node);\n                }\n\n                return node;\n            };\n        };\n    }\n\n    function patch() {\n\n        var wrapTracking;\n\n        if (extra.comments) {\n            extra.skipComment = skipComment;\n            skipComment = scanComment;\n        }\n\n        if (extra.raw) {\n            extra.createLiteral = createLiteral;\n            createLiteral = createRawLiteral;\n        }\n\n        if (extra.range || extra.loc) {\n\n            extra.parseGroupExpression = parseGroupExpression;\n            extra.parseLeftHandSideExpression = parseLeftHandSideExpression;\n            extra.parseLeftHandSideExpressionAllowCall = parseLeftHandSideExpressionAllowCall;\n            parseGroupExpression = trackGroupExpression;\n            parseLeftHandSideExpression = trackLeftHandSideExpression;\n            parseLeftHandSideExpressionAllowCall = trackLeftHandSideExpressionAllowCall;\n\n            wrapTracking = wrapTrackingFunction(extra.range, extra.loc);\n\n            extra.parseAdditiveExpression = parseAdditiveExpression;\n            extra.parseAssignmentExpression = parseAssignmentExpression;\n            extra.parseBitwiseANDExpression = parseBitwiseANDExpression;\n            extra.parseBitwiseORExpression = parseBitwiseORExpression;\n            extra.parseBitwiseXORExpression = parseBitwiseXORExpression;\n            extra.parseBlock = parseBlock;\n            extra.parseFunctionSourceElements = parseFunctionSourceElements;\n            extra.parseCatchClause = parseCatchClause;\n            extra.parseComputedMember = parseComputedMember;\n            extra.parseConditionalExpression = parseConditionalExpression;\n            extra.parseConstLetDeclaration = parseConstLetDeclaration;\n            extra.parseEqualityExpression = parseEqualityExpression;\n            extra.parseExpression = parseExpression;\n            extra.parseForVariableDeclaration = parseForVariableDeclaration;\n            extra.parseFunctionDeclaration = parseFunctionDeclaration;\n            extra.parseFunctionExpression = parseFunctionExpression;\n            extra.parseLogicalANDExpression = parseLogicalANDExpression;\n            extra.parseLogicalORExpression = parseLogicalORExpression;\n            extra.parseMultiplicativeExpression = parseMultiplicativeExpression;\n            extra.parseNewExpression = parseNewExpression;\n            extra.parseNonComputedProperty = parseNonComputedProperty;\n            extra.parseObjectProperty = parseObjectProperty;\n            extra.parseObjectPropertyKey = parseObjectPropertyKey;\n            extra.parsePostfixExpression = parsePostfixExpression;\n            extra.parsePrimaryExpression = parsePrimaryExpression;\n            extra.parseProgram = parseProgram;\n            extra.parsePropertyFunction = parsePropertyFunction;\n            extra.parseRelationalExpression = parseRelationalExpression;\n            extra.parseStatement = parseStatement;\n            extra.parseShiftExpression = parseShiftExpression;\n            extra.parseSwitchCase = parseSwitchCase;\n            extra.parseUnaryExpression = parseUnaryExpression;\n            extra.parseVariableDeclaration = parseVariableDeclaration;\n            extra.parseVariableIdentifier = parseVariableIdentifier;\n\n            parseAdditiveExpression = wrapTracking(extra.parseAdditiveExpression);\n            parseAssignmentExpression = wrapTracking(extra.parseAssignmentExpression);\n            parseBitwiseANDExpression = wrapTracking(extra.parseBitwiseANDExpression);\n            parseBitwiseORExpression = wrapTracking(extra.parseBitwiseORExpression);\n            parseBitwiseXORExpression = wrapTracking(extra.parseBitwiseXORExpression);\n            parseBlock = wrapTracking(extra.parseBlock);\n            parseFunctionSourceElements = wrapTracking(extra.parseFunctionSourceElements);\n            parseCatchClause = wrapTracking(extra.parseCatchClause);\n            parseComputedMember = wrapTracking(extra.parseComputedMember);\n            parseConditionalExpression = wrapTracking(extra.parseConditionalExpression);\n            parseConstLetDeclaration = wrapTracking(extra.parseConstLetDeclaration);\n            parseEqualityExpression = wrapTracking(extra.parseEqualityExpression);\n            parseExpression = wrapTracking(extra.parseExpression);\n            parseForVariableDeclaration = wrapTracking(extra.parseForVariableDeclaration);\n            parseFunctionDeclaration = wrapTracking(extra.parseFunctionDeclaration);\n            parseFunctionExpression = wrapTracking(extra.parseFunctionExpression);\n            parseLeftHandSideExpression = wrapTracking(parseLeftHandSideExpression);\n            parseLogicalANDExpression = wrapTracking(extra.parseLogicalANDExpression);\n            parseLogicalORExpression = wrapTracking(extra.parseLogicalORExpression);\n            parseMultiplicativeExpression = wrapTracking(extra.parseMultiplicativeExpression);\n            parseNewExpression = wrapTracking(extra.parseNewExpression);\n            parseNonComputedProperty = wrapTracking(extra.parseNonComputedProperty);\n            parseObjectProperty = wrapTracking(extra.parseObjectProperty);\n            parseObjectPropertyKey = wrapTracking(extra.parseObjectPropertyKey);\n            parsePostfixExpression = wrapTracking(extra.parsePostfixExpression);\n            parsePrimaryExpression = wrapTracking(extra.parsePrimaryExpression);\n            parseProgram = wrapTracking(extra.parseProgram);\n            parsePropertyFunction = wrapTracking(extra.parsePropertyFunction);\n            parseRelationalExpression = wrapTracking(extra.parseRelationalExpression);\n            parseStatement = wrapTracking(extra.parseStatement);\n            parseShiftExpression = wrapTracking(extra.parseShiftExpression);\n            parseSwitchCase = wrapTracking(extra.parseSwitchCase);\n            parseUnaryExpression = wrapTracking(extra.parseUnaryExpression);\n            parseVariableDeclaration = wrapTracking(extra.parseVariableDeclaration);\n            parseVariableIdentifier = wrapTracking(extra.parseVariableIdentifier);\n        }\n\n        if (typeof extra.tokens !== 'undefined') {\n            extra.advance = advance;\n            extra.scanRegExp = scanRegExp;\n\n            advance = collectToken;\n            scanRegExp = collectRegex;\n        }\n    }\n\n    function unpatch() {\n        if (typeof extra.skipComment === 'function') {\n            skipComment = extra.skipComment;\n        }\n\n        if (extra.raw) {\n            createLiteral = extra.createLiteral;\n        }\n\n        if (extra.range || extra.loc) {\n            parseAdditiveExpression = extra.parseAdditiveExpression;\n            parseAssignmentExpression = extra.parseAssignmentExpression;\n            parseBitwiseANDExpression = extra.parseBitwiseANDExpression;\n            parseBitwiseORExpression = extra.parseBitwiseORExpression;\n            parseBitwiseXORExpression = extra.parseBitwiseXORExpression;\n            parseBlock = extra.parseBlock;\n            parseFunctionSourceElements = extra.parseFunctionSourceElements;\n            parseCatchClause = extra.parseCatchClause;\n            parseComputedMember = extra.parseComputedMember;\n            parseConditionalExpression = extra.parseConditionalExpression;\n            parseConstLetDeclaration = extra.parseConstLetDeclaration;\n            parseEqualityExpression = extra.parseEqualityExpression;\n            parseExpression = extra.parseExpression;\n            parseForVariableDeclaration = extra.parseForVariableDeclaration;\n            parseFunctionDeclaration = extra.parseFunctionDeclaration;\n            parseFunctionExpression = extra.parseFunctionExpression;\n            parseGroupExpression = extra.parseGroupExpression;\n            parseLeftHandSideExpression = extra.parseLeftHandSideExpression;\n            parseLeftHandSideExpressionAllowCall = extra.parseLeftHandSideExpressionAllowCall;\n            parseLogicalANDExpression = extra.parseLogicalANDExpression;\n            parseLogicalORExpression = extra.parseLogicalORExpression;\n            parseMultiplicativeExpression = extra.parseMultiplicativeExpression;\n            parseNewExpression = extra.parseNewExpression;\n            parseNonComputedProperty = extra.parseNonComputedProperty;\n            parseObjectProperty = extra.parseObjectProperty;\n            parseObjectPropertyKey = extra.parseObjectPropertyKey;\n            parsePrimaryExpression = extra.parsePrimaryExpression;\n            parsePostfixExpression = extra.parsePostfixExpression;\n            parseProgram = extra.parseProgram;\n            parsePropertyFunction = extra.parsePropertyFunction;\n            parseRelationalExpression = extra.parseRelationalExpression;\n            parseStatement = extra.parseStatement;\n            parseShiftExpression = extra.parseShiftExpression;\n            parseSwitchCase = extra.parseSwitchCase;\n            parseUnaryExpression = extra.parseUnaryExpression;\n            parseVariableDeclaration = extra.parseVariableDeclaration;\n            parseVariableIdentifier = extra.parseVariableIdentifier;\n        }\n\n        if (typeof extra.scanRegExp === 'function') {\n            advance = extra.advance;\n            scanRegExp = extra.scanRegExp;\n        }\n    }\n\n    function stringToArray(str) {\n        var length = str.length,\n            result = [],\n            i;\n        for (i = 0; i < length; ++i) {\n            result[i] = str.charAt(i);\n        }\n        return result;\n    }\n\n    function parse(code, options) {\n        var program, toString;\n\n        toString = String;\n        if (typeof code !== 'string' && !(code instanceof String)) {\n            code = toString(code);\n        }\n\n        source = code;\n        index = 0;\n        lineNumber = (source.length > 0) ? 1 : 0;\n        lineStart = 0;\n        length = source.length;\n        buffer = null;\n        state = {\n            allowIn: true,\n            labelSet: {},\n            inFunctionBody: false,\n            inIteration: false,\n            inSwitch: false\n        };\n\n        extra = {};\n        if (typeof options !== 'undefined') {\n            extra.range = (typeof options.range === 'boolean') && options.range;\n            extra.loc = (typeof options.loc === 'boolean') && options.loc;\n            extra.raw = (typeof options.raw === 'boolean') && options.raw;\n            if (typeof options.tokens === 'boolean' && options.tokens) {\n                extra.tokens = [];\n            }\n            if (typeof options.comment === 'boolean' && options.comment) {\n                extra.comments = [];\n            }\n            if (typeof options.tolerant === 'boolean' && options.tolerant) {\n                extra.errors = [];\n            }\n        }\n\n        if (length > 0) {\n            if (typeof source[0] === 'undefined') {\n                // Try first to convert to a string. This is good as fast path\n                // for old IE which understands string indexing for string\n                // literals only and not for string object.\n                if (code instanceof String) {\n                    source = code.valueOf();\n                }\n\n                // Force accessing the characters via an array.\n                if (typeof source[0] === 'undefined') {\n                    source = stringToArray(code);\n                }\n            }\n        }\n\n        patch();\n        try {\n            program = parseProgram();\n            if (typeof extra.comments !== 'undefined') {\n                filterCommentLocation();\n                program.comments = extra.comments;\n            }\n            if (typeof extra.tokens !== 'undefined') {\n                filterTokenLocation();\n                program.tokens = extra.tokens;\n            }\n            if (typeof extra.errors !== 'undefined') {\n                program.errors = extra.errors;\n            }\n            if (extra.range || extra.loc) {\n                program.body = filterGroup(program.body);\n            }\n        } catch (e) {\n            throw e;\n        } finally {\n            unpatch();\n            extra = {};\n        }\n\n        return program;\n    }\n\n    // Sync with package.json.\n    exports.version = '1.0.4';\n\n    exports.parse = parse;\n\n    // Deep copy.\n    exports.Syntax = (function () {\n        var name, types = {};\n\n        if (typeof Object.create === 'function') {\n            types = Object.create(null);\n        }\n\n        for (name in Syntax) {\n            if (Syntax.hasOwnProperty(name)) {\n                types[name] = Syntax[name];\n            }\n        }\n\n        if (typeof Object.freeze === 'function') {\n            Object.freeze(types);\n        }\n\n        return types;\n    }());\n\n}));\n/* vim: set sw=4 ts=4 et tw=80 : */\n\n})()","\"use strict\"\n\nfunction unique_pred(list, compare) {\n  var ptr = 1\n    , len = list.length\n    , a=list[0], b=list[0]\n  for(var i=1; i<len; ++i) {\n    b = a\n    a = list[i]\n    if(compare(a, b)) {\n      if(i === ptr) {\n        ptr++\n        continue\n      }\n      list[ptr++] = a\n    }\n  }\n  list.length = ptr\n  return list\n}\n\nfunction unique_eq(list) {\n  var ptr = 1\n    , len = list.length\n    , a=list[0], b = list[0]\n  for(var i=1; i<len; ++i, b=a) {\n    b = a\n    a = list[i]\n    if(a !== b) {\n      if(i === ptr) {\n        ptr++\n        continue\n      }\n      list[ptr++] = a\n    }\n  }\n  list.length = ptr\n  return list\n}\n\nfunction unique(list, compare, sorted) {\n  if(list.length === 0) {\n    return []\n  }\n  if(compare) {\n    if(!sorted) {\n      list.sort(compare)\n    }\n    return unique_pred(list, compare)\n  }\n  if(!sorted) {\n    list.sort()\n  }\n  return unique_eq(list)\n}\n\nmodule.exports = unique","(function(){/*\n  Copyright (C) 2012 Ariya Hidayat <ariya.hidayat@gmail.com>\n  Copyright (C) 2012 Mathias Bynens <mathias@qiwi.be>\n  Copyright (C) 2012 Joost-Wim Boekesteijn <joost-wim@boekesteijn.nl>\n  Copyright (C) 2012 Kris Kowal <kris.kowal@cixar.com>\n  Copyright (C) 2012 Yusuke Suzuki <utatane.tea@gmail.com>\n  Copyright (C) 2012 Arpad Borsos <arpad.borsos@googlemail.com>\n  Copyright (C) 2011 Ariya Hidayat <ariya.hidayat@gmail.com>\n\n  Redistribution and use in source and binary forms, with or without\n  modification, are permitted provided that the following conditions are met:\n\n    * Redistributions of source code must retain the above copyright\n      notice, this list of conditions and the following disclaimer.\n    * Redistributions in binary form must reproduce the above copyright\n      notice, this list of conditions and the following disclaimer in the\n      documentation and/or other materials provided with the distribution.\n\n  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY\n  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\n  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n*/\n\n/*jslint bitwise:true plusplus:true */\n/*global esprima:true, define:true, exports:true, window: true,\nthrowError: true, createLiteral: true, generateStatement: true,\nparseAssignmentExpression: true, parseBlock: true, parseExpression: true,\nparseFunctionDeclaration: true, parseFunctionExpression: true,\nparseFunctionSourceElements: true, parseVariableIdentifier: true,\nparseLeftHandSideExpression: true,\nparseStatement: true, parseSourceElement: true */\n\n(function (root, factory) {\n    'use strict';\n\n    // Universal Module Definition (UMD) to support AMD, CommonJS/Node.js,\n    // Rhino, and plain browser loading.\n    if (typeof define === 'function' && define.amd) {\n        define(['exports'], factory);\n    } else if (typeof exports !== 'undefined') {\n        factory(exports);\n    } else {\n        factory((root.esprima = {}));\n    }\n}(this, function (exports) {\n    'use strict';\n\n    var Token,\n        TokenName,\n        Syntax,\n        PropertyKind,\n        Messages,\n        Regex,\n        source,\n        strict,\n        index,\n        lineNumber,\n        lineStart,\n        length,\n        buffer,\n        state,\n        extra;\n\n    Token = {\n        BooleanLiteral: 1,\n        EOF: 2,\n        Identifier: 3,\n        Keyword: 4,\n        NullLiteral: 5,\n        NumericLiteral: 6,\n        Punctuator: 7,\n        StringLiteral: 8\n    };\n\n    TokenName = {};\n    TokenName[Token.BooleanLiteral] = 'Boolean';\n    TokenName[Token.EOF] = '<end>';\n    TokenName[Token.Identifier] = 'Identifier';\n    TokenName[Token.Keyword] = 'Keyword';\n    TokenName[Token.NullLiteral] = 'Null';\n    TokenName[Token.NumericLiteral] = 'Numeric';\n    TokenName[Token.Punctuator] = 'Punctuator';\n    TokenName[Token.StringLiteral] = 'String';\n\n    Syntax = {\n        AssignmentExpression: 'AssignmentExpression',\n        ArrayExpression: 'ArrayExpression',\n        BlockStatement: 'BlockStatement',\n        BinaryExpression: 'BinaryExpression',\n        BreakStatement: 'BreakStatement',\n        CallExpression: 'CallExpression',\n        CatchClause: 'CatchClause',\n        ConditionalExpression: 'ConditionalExpression',\n        ContinueStatement: 'ContinueStatement',\n        DoWhileStatement: 'DoWhileStatement',\n        DebuggerStatement: 'DebuggerStatement',\n        EmptyStatement: 'EmptyStatement',\n        ExpressionStatement: 'ExpressionStatement',\n        ForStatement: 'ForStatement',\n        ForInStatement: 'ForInStatement',\n        FunctionDeclaration: 'FunctionDeclaration',\n        FunctionExpression: 'FunctionExpression',\n        Identifier: 'Identifier',\n        IfStatement: 'IfStatement',\n        Literal: 'Literal',\n        LabeledStatement: 'LabeledStatement',\n        LogicalExpression: 'LogicalExpression',\n        MemberExpression: 'MemberExpression',\n        NewExpression: 'NewExpression',\n        ObjectExpression: 'ObjectExpression',\n        Program: 'Program',\n        Property: 'Property',\n        ReturnStatement: 'ReturnStatement',\n        SequenceExpression: 'SequenceExpression',\n        SwitchStatement: 'SwitchStatement',\n        SwitchCase: 'SwitchCase',\n        ThisExpression: 'ThisExpression',\n        ThrowStatement: 'ThrowStatement',\n        TryStatement: 'TryStatement',\n        UnaryExpression: 'UnaryExpression',\n        UpdateExpression: 'UpdateExpression',\n        VariableDeclaration: 'VariableDeclaration',\n        VariableDeclarator: 'VariableDeclarator',\n        WhileStatement: 'WhileStatement',\n        WithStatement: 'WithStatement'\n    };\n\n    PropertyKind = {\n        Data: 1,\n        Get: 2,\n        Set: 4\n    };\n\n    // Error messages should be identical to V8.\n    Messages = {\n        UnexpectedToken:  'Unexpected token %0',\n        UnexpectedNumber:  'Unexpected number',\n        UnexpectedString:  'Unexpected string',\n        UnexpectedIdentifier:  'Unexpected identifier',\n        UnexpectedReserved:  'Unexpected reserved word',\n        UnexpectedEOS:  'Unexpected end of input',\n        NewlineAfterThrow:  'Illegal newline after throw',\n        InvalidRegExp: 'Invalid regular expression',\n        UnterminatedRegExp:  'Invalid regular expression: missing /',\n        InvalidLHSInAssignment:  'Invalid left-hand side in assignment',\n        InvalidLHSInForIn:  'Invalid left-hand side in for-in',\n        MultipleDefaultsInSwitch: 'More than one default clause in switch statement',\n        NoCatchOrFinally:  'Missing catch or finally after try',\n        UnknownLabel: 'Undefined label \\'%0\\'',\n        Redeclaration: '%0 \\'%1\\' has already been declared',\n        IllegalContinue: 'Illegal continue statement',\n        IllegalBreak: 'Illegal break statement',\n        IllegalReturn: 'Illegal return statement',\n        StrictModeWith:  'Strict mode code may not include a with statement',\n        StrictCatchVariable:  'Catch variable may not be eval or arguments in strict mode',\n        StrictVarName:  'Variable name may not be eval or arguments in strict mode',\n        StrictParamName:  'Parameter name eval or arguments is not allowed in strict mode',\n        StrictParamDupe: 'Strict mode function may not have duplicate parameter names',\n        StrictFunctionName:  'Function name may not be eval or arguments in strict mode',\n        StrictOctalLiteral:  'Octal literals are not allowed in strict mode.',\n        StrictDelete:  'Delete of an unqualified identifier in strict mode.',\n        StrictDuplicateProperty:  'Duplicate data property in object literal not allowed in strict mode',\n        AccessorDataProperty:  'Object literal may not have data and accessor property with the same name',\n        AccessorGetSet:  'Object literal may not have multiple get/set accessors with the same name',\n        StrictLHSAssignment:  'Assignment to eval or arguments is not allowed in strict mode',\n        StrictLHSPostfix:  'Postfix increment/decrement may not have eval or arguments operand in strict mode',\n        StrictLHSPrefix:  'Prefix increment/decrement may not have eval or arguments operand in strict mode',\n        StrictReservedWord:  'Use of future reserved word in strict mode'\n    };\n\n    // See also tools/generate-unicode-regex.py.\n    Regex = {\n        NonAsciiIdentifierStart: new RegExp('[\\xaa\\xb5\\xba\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\u02c1\\u02c6-\\u02d1\\u02e0-\\u02e4\\u02ec\\u02ee\\u0370-\\u0374\\u0376\\u0377\\u037a-\\u037d\\u0386\\u0388-\\u038a\\u038c\\u038e-\\u03a1\\u03a3-\\u03f5\\u03f7-\\u0481\\u048a-\\u0527\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05d0-\\u05ea\\u05f0-\\u05f2\\u0620-\\u064a\\u066e\\u066f\\u0671-\\u06d3\\u06d5\\u06e5\\u06e6\\u06ee\\u06ef\\u06fa-\\u06fc\\u06ff\\u0710\\u0712-\\u072f\\u074d-\\u07a5\\u07b1\\u07ca-\\u07ea\\u07f4\\u07f5\\u07fa\\u0800-\\u0815\\u081a\\u0824\\u0828\\u0840-\\u0858\\u08a0\\u08a2-\\u08ac\\u0904-\\u0939\\u093d\\u0950\\u0958-\\u0961\\u0971-\\u0977\\u0979-\\u097f\\u0985-\\u098c\\u098f\\u0990\\u0993-\\u09a8\\u09aa-\\u09b0\\u09b2\\u09b6-\\u09b9\\u09bd\\u09ce\\u09dc\\u09dd\\u09df-\\u09e1\\u09f0\\u09f1\\u0a05-\\u0a0a\\u0a0f\\u0a10\\u0a13-\\u0a28\\u0a2a-\\u0a30\\u0a32\\u0a33\\u0a35\\u0a36\\u0a38\\u0a39\\u0a59-\\u0a5c\\u0a5e\\u0a72-\\u0a74\\u0a85-\\u0a8d\\u0a8f-\\u0a91\\u0a93-\\u0aa8\\u0aaa-\\u0ab0\\u0ab2\\u0ab3\\u0ab5-\\u0ab9\\u0abd\\u0ad0\\u0ae0\\u0ae1\\u0b05-\\u0b0c\\u0b0f\\u0b10\\u0b13-\\u0b28\\u0b2a-\\u0b30\\u0b32\\u0b33\\u0b35-\\u0b39\\u0b3d\\u0b5c\\u0b5d\\u0b5f-\\u0b61\\u0b71\\u0b83\\u0b85-\\u0b8a\\u0b8e-\\u0b90\\u0b92-\\u0b95\\u0b99\\u0b9a\\u0b9c\\u0b9e\\u0b9f\\u0ba3\\u0ba4\\u0ba8-\\u0baa\\u0bae-\\u0bb9\\u0bd0\\u0c05-\\u0c0c\\u0c0e-\\u0c10\\u0c12-\\u0c28\\u0c2a-\\u0c33\\u0c35-\\u0c39\\u0c3d\\u0c58\\u0c59\\u0c60\\u0c61\\u0c85-\\u0c8c\\u0c8e-\\u0c90\\u0c92-\\u0ca8\\u0caa-\\u0cb3\\u0cb5-\\u0cb9\\u0cbd\\u0cde\\u0ce0\\u0ce1\\u0cf1\\u0cf2\\u0d05-\\u0d0c\\u0d0e-\\u0d10\\u0d12-\\u0d3a\\u0d3d\\u0d4e\\u0d60\\u0d61\\u0d7a-\\u0d7f\\u0d85-\\u0d96\\u0d9a-\\u0db1\\u0db3-\\u0dbb\\u0dbd\\u0dc0-\\u0dc6\\u0e01-\\u0e30\\u0e32\\u0e33\\u0e40-\\u0e46\\u0e81\\u0e82\\u0e84\\u0e87\\u0e88\\u0e8a\\u0e8d\\u0e94-\\u0e97\\u0e99-\\u0e9f\\u0ea1-\\u0ea3\\u0ea5\\u0ea7\\u0eaa\\u0eab\\u0ead-\\u0eb0\\u0eb2\\u0eb3\\u0ebd\\u0ec0-\\u0ec4\\u0ec6\\u0edc-\\u0edf\\u0f00\\u0f40-\\u0f47\\u0f49-\\u0f6c\\u0f88-\\u0f8c\\u1000-\\u102a\\u103f\\u1050-\\u1055\\u105a-\\u105d\\u1061\\u1065\\u1066\\u106e-\\u1070\\u1075-\\u1081\\u108e\\u10a0-\\u10c5\\u10c7\\u10cd\\u10d0-\\u10fa\\u10fc-\\u1248\\u124a-\\u124d\\u1250-\\u1256\\u1258\\u125a-\\u125d\\u1260-\\u1288\\u128a-\\u128d\\u1290-\\u12b0\\u12b2-\\u12b5\\u12b8-\\u12be\\u12c0\\u12c2-\\u12c5\\u12c8-\\u12d6\\u12d8-\\u1310\\u1312-\\u1315\\u1318-\\u135a\\u1380-\\u138f\\u13a0-\\u13f4\\u1401-\\u166c\\u166f-\\u167f\\u1681-\\u169a\\u16a0-\\u16ea\\u16ee-\\u16f0\\u1700-\\u170c\\u170e-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176c\\u176e-\\u1770\\u1780-\\u17b3\\u17d7\\u17dc\\u1820-\\u1877\\u1880-\\u18a8\\u18aa\\u18b0-\\u18f5\\u1900-\\u191c\\u1950-\\u196d\\u1970-\\u1974\\u1980-\\u19ab\\u19c1-\\u19c7\\u1a00-\\u1a16\\u1a20-\\u1a54\\u1aa7\\u1b05-\\u1b33\\u1b45-\\u1b4b\\u1b83-\\u1ba0\\u1bae\\u1baf\\u1bba-\\u1be5\\u1c00-\\u1c23\\u1c4d-\\u1c4f\\u1c5a-\\u1c7d\\u1ce9-\\u1cec\\u1cee-\\u1cf1\\u1cf5\\u1cf6\\u1d00-\\u1dbf\\u1e00-\\u1f15\\u1f18-\\u1f1d\\u1f20-\\u1f45\\u1f48-\\u1f4d\\u1f50-\\u1f57\\u1f59\\u1f5b\\u1f5d\\u1f5f-\\u1f7d\\u1f80-\\u1fb4\\u1fb6-\\u1fbc\\u1fbe\\u1fc2-\\u1fc4\\u1fc6-\\u1fcc\\u1fd0-\\u1fd3\\u1fd6-\\u1fdb\\u1fe0-\\u1fec\\u1ff2-\\u1ff4\\u1ff6-\\u1ffc\\u2071\\u207f\\u2090-\\u209c\\u2102\\u2107\\u210a-\\u2113\\u2115\\u2119-\\u211d\\u2124\\u2126\\u2128\\u212a-\\u212d\\u212f-\\u2139\\u213c-\\u213f\\u2145-\\u2149\\u214e\\u2160-\\u2188\\u2c00-\\u2c2e\\u2c30-\\u2c5e\\u2c60-\\u2ce4\\u2ceb-\\u2cee\\u2cf2\\u2cf3\\u2d00-\\u2d25\\u2d27\\u2d2d\\u2d30-\\u2d67\\u2d6f\\u2d80-\\u2d96\\u2da0-\\u2da6\\u2da8-\\u2dae\\u2db0-\\u2db6\\u2db8-\\u2dbe\\u2dc0-\\u2dc6\\u2dc8-\\u2dce\\u2dd0-\\u2dd6\\u2dd8-\\u2dde\\u2e2f\\u3005-\\u3007\\u3021-\\u3029\\u3031-\\u3035\\u3038-\\u303c\\u3041-\\u3096\\u309d-\\u309f\\u30a1-\\u30fa\\u30fc-\\u30ff\\u3105-\\u312d\\u3131-\\u318e\\u31a0-\\u31ba\\u31f0-\\u31ff\\u3400-\\u4db5\\u4e00-\\u9fcc\\ua000-\\ua48c\\ua4d0-\\ua4fd\\ua500-\\ua60c\\ua610-\\ua61f\\ua62a\\ua62b\\ua640-\\ua66e\\ua67f-\\ua697\\ua6a0-\\ua6ef\\ua717-\\ua71f\\ua722-\\ua788\\ua78b-\\ua78e\\ua790-\\ua793\\ua7a0-\\ua7aa\\ua7f8-\\ua801\\ua803-\\ua805\\ua807-\\ua80a\\ua80c-\\ua822\\ua840-\\ua873\\ua882-\\ua8b3\\ua8f2-\\ua8f7\\ua8fb\\ua90a-\\ua925\\ua930-\\ua946\\ua960-\\ua97c\\ua984-\\ua9b2\\ua9cf\\uaa00-\\uaa28\\uaa40-\\uaa42\\uaa44-\\uaa4b\\uaa60-\\uaa76\\uaa7a\\uaa80-\\uaaaf\\uaab1\\uaab5\\uaab6\\uaab9-\\uaabd\\uaac0\\uaac2\\uaadb-\\uaadd\\uaae0-\\uaaea\\uaaf2-\\uaaf4\\uab01-\\uab06\\uab09-\\uab0e\\uab11-\\uab16\\uab20-\\uab26\\uab28-\\uab2e\\uabc0-\\uabe2\\uac00-\\ud7a3\\ud7b0-\\ud7c6\\ud7cb-\\ud7fb\\uf900-\\ufa6d\\ufa70-\\ufad9\\ufb00-\\ufb06\\ufb13-\\ufb17\\ufb1d\\ufb1f-\\ufb28\\ufb2a-\\ufb36\\ufb38-\\ufb3c\\ufb3e\\ufb40\\ufb41\\ufb43\\ufb44\\ufb46-\\ufbb1\\ufbd3-\\ufd3d\\ufd50-\\ufd8f\\ufd92-\\ufdc7\\ufdf0-\\ufdfb\\ufe70-\\ufe74\\ufe76-\\ufefc\\uff21-\\uff3a\\uff41-\\uff5a\\uff66-\\uffbe\\uffc2-\\uffc7\\uffca-\\uffcf\\uffd2-\\uffd7\\uffda-\\uffdc]'),\n        NonAsciiIdentifierPart: new RegExp('[\\xaa\\xb5\\xba\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\u02c1\\u02c6-\\u02d1\\u02e0-\\u02e4\\u02ec\\u02ee\\u0300-\\u0374\\u0376\\u0377\\u037a-\\u037d\\u0386\\u0388-\\u038a\\u038c\\u038e-\\u03a1\\u03a3-\\u03f5\\u03f7-\\u0481\\u0483-\\u0487\\u048a-\\u0527\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u0591-\\u05bd\\u05bf\\u05c1\\u05c2\\u05c4\\u05c5\\u05c7\\u05d0-\\u05ea\\u05f0-\\u05f2\\u0610-\\u061a\\u0620-\\u0669\\u066e-\\u06d3\\u06d5-\\u06dc\\u06df-\\u06e8\\u06ea-\\u06fc\\u06ff\\u0710-\\u074a\\u074d-\\u07b1\\u07c0-\\u07f5\\u07fa\\u0800-\\u082d\\u0840-\\u085b\\u08a0\\u08a2-\\u08ac\\u08e4-\\u08fe\\u0900-\\u0963\\u0966-\\u096f\\u0971-\\u0977\\u0979-\\u097f\\u0981-\\u0983\\u0985-\\u098c\\u098f\\u0990\\u0993-\\u09a8\\u09aa-\\u09b0\\u09b2\\u09b6-\\u09b9\\u09bc-\\u09c4\\u09c7\\u09c8\\u09cb-\\u09ce\\u09d7\\u09dc\\u09dd\\u09df-\\u09e3\\u09e6-\\u09f1\\u0a01-\\u0a03\\u0a05-\\u0a0a\\u0a0f\\u0a10\\u0a13-\\u0a28\\u0a2a-\\u0a30\\u0a32\\u0a33\\u0a35\\u0a36\\u0a38\\u0a39\\u0a3c\\u0a3e-\\u0a42\\u0a47\\u0a48\\u0a4b-\\u0a4d\\u0a51\\u0a59-\\u0a5c\\u0a5e\\u0a66-\\u0a75\\u0a81-\\u0a83\\u0a85-\\u0a8d\\u0a8f-\\u0a91\\u0a93-\\u0aa8\\u0aaa-\\u0ab0\\u0ab2\\u0ab3\\u0ab5-\\u0ab9\\u0abc-\\u0ac5\\u0ac7-\\u0ac9\\u0acb-\\u0acd\\u0ad0\\u0ae0-\\u0ae3\\u0ae6-\\u0aef\\u0b01-\\u0b03\\u0b05-\\u0b0c\\u0b0f\\u0b10\\u0b13-\\u0b28\\u0b2a-\\u0b30\\u0b32\\u0b33\\u0b35-\\u0b39\\u0b3c-\\u0b44\\u0b47\\u0b48\\u0b4b-\\u0b4d\\u0b56\\u0b57\\u0b5c\\u0b5d\\u0b5f-\\u0b63\\u0b66-\\u0b6f\\u0b71\\u0b82\\u0b83\\u0b85-\\u0b8a\\u0b8e-\\u0b90\\u0b92-\\u0b95\\u0b99\\u0b9a\\u0b9c\\u0b9e\\u0b9f\\u0ba3\\u0ba4\\u0ba8-\\u0baa\\u0bae-\\u0bb9\\u0bbe-\\u0bc2\\u0bc6-\\u0bc8\\u0bca-\\u0bcd\\u0bd0\\u0bd7\\u0be6-\\u0bef\\u0c01-\\u0c03\\u0c05-\\u0c0c\\u0c0e-\\u0c10\\u0c12-\\u0c28\\u0c2a-\\u0c33\\u0c35-\\u0c39\\u0c3d-\\u0c44\\u0c46-\\u0c48\\u0c4a-\\u0c4d\\u0c55\\u0c56\\u0c58\\u0c59\\u0c60-\\u0c63\\u0c66-\\u0c6f\\u0c82\\u0c83\\u0c85-\\u0c8c\\u0c8e-\\u0c90\\u0c92-\\u0ca8\\u0caa-\\u0cb3\\u0cb5-\\u0cb9\\u0cbc-\\u0cc4\\u0cc6-\\u0cc8\\u0cca-\\u0ccd\\u0cd5\\u0cd6\\u0cde\\u0ce0-\\u0ce3\\u0ce6-\\u0cef\\u0cf1\\u0cf2\\u0d02\\u0d03\\u0d05-\\u0d0c\\u0d0e-\\u0d10\\u0d12-\\u0d3a\\u0d3d-\\u0d44\\u0d46-\\u0d48\\u0d4a-\\u0d4e\\u0d57\\u0d60-\\u0d63\\u0d66-\\u0d6f\\u0d7a-\\u0d7f\\u0d82\\u0d83\\u0d85-\\u0d96\\u0d9a-\\u0db1\\u0db3-\\u0dbb\\u0dbd\\u0dc0-\\u0dc6\\u0dca\\u0dcf-\\u0dd4\\u0dd6\\u0dd8-\\u0ddf\\u0df2\\u0df3\\u0e01-\\u0e3a\\u0e40-\\u0e4e\\u0e50-\\u0e59\\u0e81\\u0e82\\u0e84\\u0e87\\u0e88\\u0e8a\\u0e8d\\u0e94-\\u0e97\\u0e99-\\u0e9f\\u0ea1-\\u0ea3\\u0ea5\\u0ea7\\u0eaa\\u0eab\\u0ead-\\u0eb9\\u0ebb-\\u0ebd\\u0ec0-\\u0ec4\\u0ec6\\u0ec8-\\u0ecd\\u0ed0-\\u0ed9\\u0edc-\\u0edf\\u0f00\\u0f18\\u0f19\\u0f20-\\u0f29\\u0f35\\u0f37\\u0f39\\u0f3e-\\u0f47\\u0f49-\\u0f6c\\u0f71-\\u0f84\\u0f86-\\u0f97\\u0f99-\\u0fbc\\u0fc6\\u1000-\\u1049\\u1050-\\u109d\\u10a0-\\u10c5\\u10c7\\u10cd\\u10d0-\\u10fa\\u10fc-\\u1248\\u124a-\\u124d\\u1250-\\u1256\\u1258\\u125a-\\u125d\\u1260-\\u1288\\u128a-\\u128d\\u1290-\\u12b0\\u12b2-\\u12b5\\u12b8-\\u12be\\u12c0\\u12c2-\\u12c5\\u12c8-\\u12d6\\u12d8-\\u1310\\u1312-\\u1315\\u1318-\\u135a\\u135d-\\u135f\\u1380-\\u138f\\u13a0-\\u13f4\\u1401-\\u166c\\u166f-\\u167f\\u1681-\\u169a\\u16a0-\\u16ea\\u16ee-\\u16f0\\u1700-\\u170c\\u170e-\\u1714\\u1720-\\u1734\\u1740-\\u1753\\u1760-\\u176c\\u176e-\\u1770\\u1772\\u1773\\u1780-\\u17d3\\u17d7\\u17dc\\u17dd\\u17e0-\\u17e9\\u180b-\\u180d\\u1810-\\u1819\\u1820-\\u1877\\u1880-\\u18aa\\u18b0-\\u18f5\\u1900-\\u191c\\u1920-\\u192b\\u1930-\\u193b\\u1946-\\u196d\\u1970-\\u1974\\u1980-\\u19ab\\u19b0-\\u19c9\\u19d0-\\u19d9\\u1a00-\\u1a1b\\u1a20-\\u1a5e\\u1a60-\\u1a7c\\u1a7f-\\u1a89\\u1a90-\\u1a99\\u1aa7\\u1b00-\\u1b4b\\u1b50-\\u1b59\\u1b6b-\\u1b73\\u1b80-\\u1bf3\\u1c00-\\u1c37\\u1c40-\\u1c49\\u1c4d-\\u1c7d\\u1cd0-\\u1cd2\\u1cd4-\\u1cf6\\u1d00-\\u1de6\\u1dfc-\\u1f15\\u1f18-\\u1f1d\\u1f20-\\u1f45\\u1f48-\\u1f4d\\u1f50-\\u1f57\\u1f59\\u1f5b\\u1f5d\\u1f5f-\\u1f7d\\u1f80-\\u1fb4\\u1fb6-\\u1fbc\\u1fbe\\u1fc2-\\u1fc4\\u1fc6-\\u1fcc\\u1fd0-\\u1fd3\\u1fd6-\\u1fdb\\u1fe0-\\u1fec\\u1ff2-\\u1ff4\\u1ff6-\\u1ffc\\u200c\\u200d\\u203f\\u2040\\u2054\\u2071\\u207f\\u2090-\\u209c\\u20d0-\\u20dc\\u20e1\\u20e5-\\u20f0\\u2102\\u2107\\u210a-\\u2113\\u2115\\u2119-\\u211d\\u2124\\u2126\\u2128\\u212a-\\u212d\\u212f-\\u2139\\u213c-\\u213f\\u2145-\\u2149\\u214e\\u2160-\\u2188\\u2c00-\\u2c2e\\u2c30-\\u2c5e\\u2c60-\\u2ce4\\u2ceb-\\u2cf3\\u2d00-\\u2d25\\u2d27\\u2d2d\\u2d30-\\u2d67\\u2d6f\\u2d7f-\\u2d96\\u2da0-\\u2da6\\u2da8-\\u2dae\\u2db0-\\u2db6\\u2db8-\\u2dbe\\u2dc0-\\u2dc6\\u2dc8-\\u2dce\\u2dd0-\\u2dd6\\u2dd8-\\u2dde\\u2de0-\\u2dff\\u2e2f\\u3005-\\u3007\\u3021-\\u302f\\u3031-\\u3035\\u3038-\\u303c\\u3041-\\u3096\\u3099\\u309a\\u309d-\\u309f\\u30a1-\\u30fa\\u30fc-\\u30ff\\u3105-\\u312d\\u3131-\\u318e\\u31a0-\\u31ba\\u31f0-\\u31ff\\u3400-\\u4db5\\u4e00-\\u9fcc\\ua000-\\ua48c\\ua4d0-\\ua4fd\\ua500-\\ua60c\\ua610-\\ua62b\\ua640-\\ua66f\\ua674-\\ua67d\\ua67f-\\ua697\\ua69f-\\ua6f1\\ua717-\\ua71f\\ua722-\\ua788\\ua78b-\\ua78e\\ua790-\\ua793\\ua7a0-\\ua7aa\\ua7f8-\\ua827\\ua840-\\ua873\\ua880-\\ua8c4\\ua8d0-\\ua8d9\\ua8e0-\\ua8f7\\ua8fb\\ua900-\\ua92d\\ua930-\\ua953\\ua960-\\ua97c\\ua980-\\ua9c0\\ua9cf-\\ua9d9\\uaa00-\\uaa36\\uaa40-\\uaa4d\\uaa50-\\uaa59\\uaa60-\\uaa76\\uaa7a\\uaa7b\\uaa80-\\uaac2\\uaadb-\\uaadd\\uaae0-\\uaaef\\uaaf2-\\uaaf6\\uab01-\\uab06\\uab09-\\uab0e\\uab11-\\uab16\\uab20-\\uab26\\uab28-\\uab2e\\uabc0-\\uabea\\uabec\\uabed\\uabf0-\\uabf9\\uac00-\\ud7a3\\ud7b0-\\ud7c6\\ud7cb-\\ud7fb\\uf900-\\ufa6d\\ufa70-\\ufad9\\ufb00-\\ufb06\\ufb13-\\ufb17\\ufb1d-\\ufb28\\ufb2a-\\ufb36\\ufb38-\\ufb3c\\ufb3e\\ufb40\\ufb41\\ufb43\\ufb44\\ufb46-\\ufbb1\\ufbd3-\\ufd3d\\ufd50-\\ufd8f\\ufd92-\\ufdc7\\ufdf0-\\ufdfb\\ufe00-\\ufe0f\\ufe20-\\ufe26\\ufe33\\ufe34\\ufe4d-\\ufe4f\\ufe70-\\ufe74\\ufe76-\\ufefc\\uff10-\\uff19\\uff21-\\uff3a\\uff3f\\uff41-\\uff5a\\uff66-\\uffbe\\uffc2-\\uffc7\\uffca-\\uffcf\\uffd2-\\uffd7\\uffda-\\uffdc]')\n    };\n\n    // Ensure the condition is true, otherwise throw an error.\n    // This is only to have a better contract semantic, i.e. another safety net\n    // to catch a logic error. The condition shall be fulfilled in normal case.\n    // Do NOT use this to enforce a certain condition on any user input.\n\n    function assert(condition, message) {\n        if (!condition) {\n            throw new Error('ASSERT: ' + message);\n        }\n    }\n\n    function sliceSource(from, to) {\n        return source.slice(from, to);\n    }\n\n    if (typeof 'esprima'[0] === 'undefined') {\n        sliceSource = function sliceArraySource(from, to) {\n            return source.slice(from, to).join('');\n        };\n    }\n\n    function isDecimalDigit(ch) {\n        return '0123456789'.indexOf(ch) >= 0;\n    }\n\n    function isHexDigit(ch) {\n        return '0123456789abcdefABCDEF'.indexOf(ch) >= 0;\n    }\n\n    function isOctalDigit(ch) {\n        return '01234567'.indexOf(ch) >= 0;\n    }\n\n\n    // 7.2 White Space\n\n    function isWhiteSpace(ch) {\n        return (ch === ' ') || (ch === '\\u0009') || (ch === '\\u000B') ||\n            (ch === '\\u000C') || (ch === '\\u00A0') ||\n            (ch.charCodeAt(0) >= 0x1680 &&\n             '\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\uFEFF'.indexOf(ch) >= 0);\n    }\n\n    // 7.3 Line Terminators\n\n    function isLineTerminator(ch) {\n        return (ch === '\\n' || ch === '\\r' || ch === '\\u2028' || ch === '\\u2029');\n    }\n\n    // 7.6 Identifier Names and Identifiers\n\n    function isIdentifierStart(ch) {\n        return (ch === '$') || (ch === '_') || (ch === '\\\\') ||\n            (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') ||\n            ((ch.charCodeAt(0) >= 0x80) && Regex.NonAsciiIdentifierStart.test(ch));\n    }\n\n    function isIdentifierPart(ch) {\n        return (ch === '$') || (ch === '_') || (ch === '\\\\') ||\n            (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') ||\n            ((ch >= '0') && (ch <= '9')) ||\n            ((ch.charCodeAt(0) >= 0x80) && Regex.NonAsciiIdentifierPart.test(ch));\n    }\n\n    // 7.6.1.2 Future Reserved Words\n\n    function isFutureReservedWord(id) {\n        switch (id) {\n\n        // Future reserved words.\n        case 'class':\n        case 'enum':\n        case 'export':\n        case 'extends':\n        case 'import':\n        case 'super':\n            return true;\n        }\n\n        return false;\n    }\n\n    function isStrictModeReservedWord(id) {\n        switch (id) {\n\n        // Strict Mode reserved words.\n        case 'implements':\n        case 'interface':\n        case 'package':\n        case 'private':\n        case 'protected':\n        case 'public':\n        case 'static':\n        case 'yield':\n        case 'let':\n            return true;\n        }\n\n        return false;\n    }\n\n    function isRestrictedWord(id) {\n        return id === 'eval' || id === 'arguments';\n    }\n\n    // 7.6.1.1 Keywords\n\n    function isKeyword(id) {\n        var keyword = false;\n        switch (id.length) {\n        case 2:\n            keyword = (id === 'if') || (id === 'in') || (id === 'do');\n            break;\n        case 3:\n            keyword = (id === 'var') || (id === 'for') || (id === 'new') || (id === 'try');\n            break;\n        case 4:\n            keyword = (id === 'this') || (id === 'else') || (id === 'case') || (id === 'void') || (id === 'with');\n            break;\n        case 5:\n            keyword = (id === 'while') || (id === 'break') || (id === 'catch') || (id === 'throw');\n            break;\n        case 6:\n            keyword = (id === 'return') || (id === 'typeof') || (id === 'delete') || (id === 'switch');\n            break;\n        case 7:\n            keyword = (id === 'default') || (id === 'finally');\n            break;\n        case 8:\n            keyword = (id === 'function') || (id === 'continue') || (id === 'debugger');\n            break;\n        case 10:\n            keyword = (id === 'instanceof');\n            break;\n        }\n\n        if (keyword) {\n            return true;\n        }\n\n        switch (id) {\n        // Future reserved words.\n        // 'const' is specialized as Keyword in V8.\n        case 'const':\n            return true;\n\n        // For compatiblity to SpiderMonkey and ES.next\n        case 'yield':\n        case 'let':\n            return true;\n        }\n\n        if (strict && isStrictModeReservedWord(id)) {\n            return true;\n        }\n\n        return isFutureReservedWord(id);\n    }\n\n    // 7.4 Comments\n\n    function skipComment() {\n        var ch, blockComment, lineComment;\n\n        blockComment = false;\n        lineComment = false;\n\n        while (index < length) {\n            ch = source[index];\n\n            if (lineComment) {\n                ch = source[index++];\n                if (isLineTerminator(ch)) {\n                    lineComment = false;\n                    if (ch === '\\r' && source[index] === '\\n') {\n                        ++index;\n                    }\n                    ++lineNumber;\n                    lineStart = index;\n                }\n            } else if (blockComment) {\n                if (isLineTerminator(ch)) {\n                    if (ch === '\\r' && source[index + 1] === '\\n') {\n                        ++index;\n                    }\n                    ++lineNumber;\n                    ++index;\n                    lineStart = index;\n                    if (index >= length) {\n                        throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n                    }\n                } else {\n                    ch = source[index++];\n                    if (index >= length) {\n                        throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n                    }\n                    if (ch === '*') {\n                        ch = source[index];\n                        if (ch === '/') {\n                            ++index;\n                            blockComment = false;\n                        }\n                    }\n                }\n            } else if (ch === '/') {\n                ch = source[index + 1];\n                if (ch === '/') {\n                    index += 2;\n                    lineComment = true;\n                } else if (ch === '*') {\n                    index += 2;\n                    blockComment = true;\n                    if (index >= length) {\n                        throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n                    }\n                } else {\n                    break;\n                }\n            } else if (isWhiteSpace(ch)) {\n                ++index;\n            } else if (isLineTerminator(ch)) {\n                ++index;\n                if (ch ===  '\\r' && source[index] === '\\n') {\n                    ++index;\n                }\n                ++lineNumber;\n                lineStart = index;\n            } else {\n                break;\n            }\n        }\n    }\n\n    function scanHexEscape(prefix) {\n        var i, len, ch, code = 0;\n\n        len = (prefix === 'u') ? 4 : 2;\n        for (i = 0; i < len; ++i) {\n            if (index < length && isHexDigit(source[index])) {\n                ch = source[index++];\n                code = code * 16 + '0123456789abcdef'.indexOf(ch.toLowerCase());\n            } else {\n                return '';\n            }\n        }\n        return String.fromCharCode(code);\n    }\n\n    function scanIdentifier() {\n        var ch, start, id, restore;\n\n        ch = source[index];\n        if (!isIdentifierStart(ch)) {\n            return;\n        }\n\n        start = index;\n        if (ch === '\\\\') {\n            ++index;\n            if (source[index] !== 'u') {\n                return;\n            }\n            ++index;\n            restore = index;\n            ch = scanHexEscape('u');\n            if (ch) {\n                if (ch === '\\\\' || !isIdentifierStart(ch)) {\n                    return;\n                }\n                id = ch;\n            } else {\n                index = restore;\n                id = 'u';\n            }\n        } else {\n            id = source[index++];\n        }\n\n        while (index < length) {\n            ch = source[index];\n            if (!isIdentifierPart(ch)) {\n                break;\n            }\n            if (ch === '\\\\') {\n                ++index;\n                if (source[index] !== 'u') {\n                    return;\n                }\n                ++index;\n                restore = index;\n                ch = scanHexEscape('u');\n                if (ch) {\n                    if (ch === '\\\\' || !isIdentifierPart(ch)) {\n                        return;\n                    }\n                    id += ch;\n                } else {\n                    index = restore;\n                    id += 'u';\n                }\n            } else {\n                id += source[index++];\n            }\n        }\n\n        // There is no keyword or literal with only one character.\n        // Thus, it must be an identifier.\n        if (id.length === 1) {\n            return {\n                type: Token.Identifier,\n                value: id,\n                lineNumber: lineNumber,\n                lineStart: lineStart,\n                range: [start, index]\n            };\n        }\n\n        if (isKeyword(id)) {\n            return {\n                type: Token.Keyword,\n                value: id,\n                lineNumber: lineNumber,\n                lineStart: lineStart,\n                range: [start, index]\n            };\n        }\n\n        // 7.8.1 Null Literals\n\n        if (id === 'null') {\n            return {\n                type: Token.NullLiteral,\n                value: id,\n                lineNumber: lineNumber,\n                lineStart: lineStart,\n                range: [start, index]\n            };\n        }\n\n        // 7.8.2 Boolean Literals\n\n        if (id === 'true' || id === 'false') {\n            return {\n                type: Token.BooleanLiteral,\n                value: id,\n                lineNumber: lineNumber,\n                lineStart: lineStart,\n                range: [start, index]\n            };\n        }\n\n        return {\n            type: Token.Identifier,\n            value: id,\n            lineNumber: lineNumber,\n            lineStart: lineStart,\n            range: [start, index]\n        };\n    }\n\n    // 7.7 Punctuators\n\n    function scanPunctuator() {\n        var start = index,\n            ch1 = source[index],\n            ch2,\n            ch3,\n            ch4;\n\n        // Check for most common single-character punctuators.\n\n        if (ch1 === ';' || ch1 === '{' || ch1 === '}') {\n            ++index;\n            return {\n                type: Token.Punctuator,\n                value: ch1,\n                lineNumber: lineNumber,\n                lineStart: lineStart,\n                range: [start, index]\n            };\n        }\n\n        if (ch1 === ',' || ch1 === '(' || ch1 === ')') {\n            ++index;\n            return {\n                type: Token.Punctuator,\n                value: ch1,\n                lineNumber: lineNumber,\n                lineStart: lineStart,\n                range: [start, index]\n            };\n        }\n\n        // Dot (.) can also start a floating-point number, hence the need\n        // to check the next character.\n\n        ch2 = source[index + 1];\n        if (ch1 === '.' && !isDecimalDigit(ch2)) {\n            return {\n                type: Token.Punctuator,\n                value: source[index++],\n                lineNumber: lineNumber,\n                lineStart: lineStart,\n                range: [start, index]\n            };\n        }\n\n        // Peek more characters.\n\n        ch3 = source[index + 2];\n        ch4 = source[index + 3];\n\n        // 4-character punctuator: >>>=\n\n        if (ch1 === '>' && ch2 === '>' && ch3 === '>') {\n            if (ch4 === '=') {\n                index += 4;\n                return {\n                    type: Token.Punctuator,\n                    value: '>>>=',\n                    lineNumber: lineNumber,\n                    lineStart: lineStart,\n                    range: [start, index]\n                };\n            }\n        }\n\n        // 3-character punctuators: === !== >>> <<= >>=\n\n        if (ch1 === '=' && ch2 === '=' && ch3 === '=') {\n            index += 3;\n            return {\n                type: Token.Punctuator,\n                value: '===',\n                lineNumber: lineNumber,\n                lineStart: lineStart,\n                range: [start, index]\n            };\n        }\n\n        if (ch1 === '!' && ch2 === '=' && ch3 === '=') {\n            index += 3;\n            return {\n                type: Token.Punctuator,\n                value: '!==',\n                lineNumber: lineNumber,\n                lineStart: lineStart,\n                range: [start, index]\n            };\n        }\n\n        if (ch1 === '>' && ch2 === '>' && ch3 === '>') {\n            index += 3;\n            return {\n                type: Token.Punctuator,\n                value: '>>>',\n                lineNumber: lineNumber,\n                lineStart: lineStart,\n                range: [start, index]\n            };\n        }\n\n        if (ch1 === '<' && ch2 === '<' && ch3 === '=') {\n            index += 3;\n            return {\n                type: Token.Punctuator,\n                value: '<<=',\n                lineNumber: lineNumber,\n                lineStart: lineStart,\n                range: [start, index]\n            };\n        }\n\n        if (ch1 === '>' && ch2 === '>' && ch3 === '=') {\n            index += 3;\n            return {\n                type: Token.Punctuator,\n                value: '>>=',\n                lineNumber: lineNumber,\n                lineStart: lineStart,\n                range: [start, index]\n            };\n        }\n\n        // 2-character punctuators: <= >= == != ++ -- << >> && ||\n        // += -= *= %= &= |= ^= /=\n\n        if (ch2 === '=') {\n            if ('<>=!+-*%&|^/'.indexOf(ch1) >= 0) {\n                index += 2;\n                return {\n                    type: Token.Punctuator,\n                    value: ch1 + ch2,\n                    lineNumber: lineNumber,\n                    lineStart: lineStart,\n                    range: [start, index]\n                };\n            }\n        }\n\n        if (ch1 === ch2 && ('+-<>&|'.indexOf(ch1) >= 0)) {\n            if ('+-<>&|'.indexOf(ch2) >= 0) {\n                index += 2;\n                return {\n                    type: Token.Punctuator,\n                    value: ch1 + ch2,\n                    lineNumber: lineNumber,\n                    lineStart: lineStart,\n                    range: [start, index]\n                };\n            }\n        }\n\n        // The remaining 1-character punctuators.\n\n        if ('[]<>+-*%&|^!~?:=/'.indexOf(ch1) >= 0) {\n            return {\n                type: Token.Punctuator,\n                value: source[index++],\n                lineNumber: lineNumber,\n                lineStart: lineStart,\n                range: [start, index]\n            };\n        }\n    }\n\n    // 7.8.3 Numeric Literals\n\n    function scanNumericLiteral() {\n        var number, start, ch;\n\n        ch = source[index];\n        assert(isDecimalDigit(ch) || (ch === '.'),\n            'Numeric literal must start with a decimal digit or a decimal point');\n\n        start = index;\n        number = '';\n        if (ch !== '.') {\n            number = source[index++];\n            ch = source[index];\n\n            // Hex number starts with '0x'.\n            // Octal number starts with '0'.\n            if (number === '0') {\n                if (ch === 'x' || ch === 'X') {\n                    number += source[index++];\n                    while (index < length) {\n                        ch = source[index];\n                        if (!isHexDigit(ch)) {\n                            break;\n                        }\n                        number += source[index++];\n                    }\n\n                    if (number.length <= 2) {\n                        // only 0x\n                        throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n                    }\n\n                    if (index < length) {\n                        ch = source[index];\n                        if (isIdentifierStart(ch)) {\n                            throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n                        }\n                    }\n                    return {\n                        type: Token.NumericLiteral,\n                        value: parseInt(number, 16),\n                        lineNumber: lineNumber,\n                        lineStart: lineStart,\n                        range: [start, index]\n                    };\n                } else if (isOctalDigit(ch)) {\n                    number += source[index++];\n                    while (index < length) {\n                        ch = source[index];\n                        if (!isOctalDigit(ch)) {\n                            break;\n                        }\n                        number += source[index++];\n                    }\n\n                    if (index < length) {\n                        ch = source[index];\n                        if (isIdentifierStart(ch) || isDecimalDigit(ch)) {\n                            throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n                        }\n                    }\n                    return {\n                        type: Token.NumericLiteral,\n                        value: parseInt(number, 8),\n                        octal: true,\n                        lineNumber: lineNumber,\n                        lineStart: lineStart,\n                        range: [start, index]\n                    };\n                }\n\n                // decimal number starts with '0' such as '09' is illegal.\n                if (isDecimalDigit(ch)) {\n                    throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n                }\n            }\n\n            while (index < length) {\n                ch = source[index];\n                if (!isDecimalDigit(ch)) {\n                    break;\n                }\n                number += source[index++];\n            }\n        }\n\n        if (ch === '.') {\n            number += source[index++];\n            while (index < length) {\n                ch = source[index];\n                if (!isDecimalDigit(ch)) {\n                    break;\n                }\n                number += source[index++];\n            }\n        }\n\n        if (ch === 'e' || ch === 'E') {\n            number += source[index++];\n\n            ch = source[index];\n            if (ch === '+' || ch === '-') {\n                number += source[index++];\n            }\n\n            ch = source[index];\n            if (isDecimalDigit(ch)) {\n                number += source[index++];\n                while (index < length) {\n                    ch = source[index];\n                    if (!isDecimalDigit(ch)) {\n                        break;\n                    }\n                    number += source[index++];\n                }\n            } else {\n                ch = 'character ' + ch;\n                if (index >= length) {\n                    ch = '<end>';\n                }\n                throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n            }\n        }\n\n        if (index < length) {\n            ch = source[index];\n            if (isIdentifierStart(ch)) {\n                throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n            }\n        }\n\n        return {\n            type: Token.NumericLiteral,\n            value: parseFloat(number),\n            lineNumber: lineNumber,\n            lineStart: lineStart,\n            range: [start, index]\n        };\n    }\n\n    // 7.8.4 String Literals\n\n    function scanStringLiteral() {\n        var str = '', quote, start, ch, code, unescaped, restore, octal = false;\n\n        quote = source[index];\n        assert((quote === '\\'' || quote === '\"'),\n            'String literal must starts with a quote');\n\n        start = index;\n        ++index;\n\n        while (index < length) {\n            ch = source[index++];\n\n            if (ch === quote) {\n                quote = '';\n                break;\n            } else if (ch === '\\\\') {\n                ch = source[index++];\n                if (!isLineTerminator(ch)) {\n                    switch (ch) {\n                    case 'n':\n                        str += '\\n';\n                        break;\n                    case 'r':\n                        str += '\\r';\n                        break;\n                    case 't':\n                        str += '\\t';\n                        break;\n                    case 'u':\n                    case 'x':\n                        restore = index;\n                        unescaped = scanHexEscape(ch);\n                        if (unescaped) {\n                            str += unescaped;\n                        } else {\n                            index = restore;\n                            str += ch;\n                        }\n                        break;\n                    case 'b':\n                        str += '\\b';\n                        break;\n                    case 'f':\n                        str += '\\f';\n                        break;\n                    case 'v':\n                        str += '\\x0B';\n                        break;\n\n                    default:\n                        if (isOctalDigit(ch)) {\n                            code = '01234567'.indexOf(ch);\n\n                            // \\0 is not octal escape sequence\n                            if (code !== 0) {\n                                octal = true;\n                            }\n\n                            if (index < length && isOctalDigit(source[index])) {\n                                octal = true;\n                                code = code * 8 + '01234567'.indexOf(source[index++]);\n\n                                // 3 digits are only allowed when string starts\n                                // with 0, 1, 2, 3\n                                if ('0123'.indexOf(ch) >= 0 &&\n                                        index < length &&\n                                        isOctalDigit(source[index])) {\n                                    code = code * 8 + '01234567'.indexOf(source[index++]);\n                                }\n                            }\n                            str += String.fromCharCode(code);\n                        } else {\n                            str += ch;\n                        }\n                        break;\n                    }\n                } else {\n                    ++lineNumber;\n                    if (ch ===  '\\r' && source[index] === '\\n') {\n                        ++index;\n                    }\n                }\n            } else if (isLineTerminator(ch)) {\n                break;\n            } else {\n                str += ch;\n            }\n        }\n\n        if (quote !== '') {\n            throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n        }\n\n        return {\n            type: Token.StringLiteral,\n            value: str,\n            octal: octal,\n            lineNumber: lineNumber,\n            lineStart: lineStart,\n            range: [start, index]\n        };\n    }\n\n    function scanRegExp() {\n        var str, ch, start, pattern, flags, value, classMarker = false, restore, terminated = false;\n\n        buffer = null;\n        skipComment();\n\n        start = index;\n        ch = source[index];\n        assert(ch === '/', 'Regular expression literal must start with a slash');\n        str = source[index++];\n\n        while (index < length) {\n            ch = source[index++];\n            str += ch;\n            if (ch === '\\\\') {\n                ch = source[index++];\n                // ECMA-262 7.8.5\n                if (isLineTerminator(ch)) {\n                    throwError({}, Messages.UnterminatedRegExp);\n                }\n                str += ch;\n            } else if (classMarker) {\n                if (ch === ']') {\n                    classMarker = false;\n                }\n            } else {\n                if (ch === '/') {\n                    terminated = true;\n                    break;\n                } else if (ch === '[') {\n                    classMarker = true;\n                } else if (isLineTerminator(ch)) {\n                    throwError({}, Messages.UnterminatedRegExp);\n                }\n            }\n        }\n\n        if (!terminated) {\n            throwError({}, Messages.UnterminatedRegExp);\n        }\n\n        // Exclude leading and trailing slash.\n        pattern = str.substr(1, str.length - 2);\n\n        flags = '';\n        while (index < length) {\n            ch = source[index];\n            if (!isIdentifierPart(ch)) {\n                break;\n            }\n\n            ++index;\n            if (ch === '\\\\' && index < length) {\n                ch = source[index];\n                if (ch === 'u') {\n                    ++index;\n                    restore = index;\n                    ch = scanHexEscape('u');\n                    if (ch) {\n                        flags += ch;\n                        str += '\\\\u';\n                        for (; restore < index; ++restore) {\n                            str += source[restore];\n                        }\n                    } else {\n                        index = restore;\n                        flags += 'u';\n                        str += '\\\\u';\n                    }\n                } else {\n                    str += '\\\\';\n                }\n            } else {\n                flags += ch;\n                str += ch;\n            }\n        }\n\n        try {\n            value = new RegExp(pattern, flags);\n        } catch (e) {\n            throwError({}, Messages.InvalidRegExp);\n        }\n\n        return {\n            literal: str,\n            value: value,\n            range: [start, index]\n        };\n    }\n\n    function isIdentifierName(token) {\n        return token.type === Token.Identifier ||\n            token.type === Token.Keyword ||\n            token.type === Token.BooleanLiteral ||\n            token.type === Token.NullLiteral;\n    }\n\n    function advance() {\n        var ch, token;\n\n        skipComment();\n\n        if (index >= length) {\n            return {\n                type: Token.EOF,\n                lineNumber: lineNumber,\n                lineStart: lineStart,\n                range: [index, index]\n            };\n        }\n\n        token = scanPunctuator();\n        if (typeof token !== 'undefined') {\n            return token;\n        }\n\n        ch = source[index];\n\n        if (ch === '\\'' || ch === '\"') {\n            return scanStringLiteral();\n        }\n\n        if (ch === '.' || isDecimalDigit(ch)) {\n            return scanNumericLiteral();\n        }\n\n        token = scanIdentifier();\n        if (typeof token !== 'undefined') {\n            return token;\n        }\n\n        throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n    }\n\n    function lex() {\n        var token;\n\n        if (buffer) {\n            index = buffer.range[1];\n            lineNumber = buffer.lineNumber;\n            lineStart = buffer.lineStart;\n            token = buffer;\n            buffer = null;\n            return token;\n        }\n\n        buffer = null;\n        return advance();\n    }\n\n    function lookahead() {\n        var pos, line, start;\n\n        if (buffer !== null) {\n            return buffer;\n        }\n\n        pos = index;\n        line = lineNumber;\n        start = lineStart;\n        buffer = advance();\n        index = pos;\n        lineNumber = line;\n        lineStart = start;\n\n        return buffer;\n    }\n\n    // Return true if there is a line terminator before the next token.\n\n    function peekLineTerminator() {\n        var pos, line, start, found;\n\n        pos = index;\n        line = lineNumber;\n        start = lineStart;\n        skipComment();\n        found = lineNumber !== line;\n        index = pos;\n        lineNumber = line;\n        lineStart = start;\n\n        return found;\n    }\n\n    // Throw an exception\n\n    function throwError(token, messageFormat) {\n        var error,\n            args = Array.prototype.slice.call(arguments, 2),\n            msg = messageFormat.replace(\n                /%(\\d)/g,\n                function (whole, index) {\n                    return args[index] || '';\n                }\n            );\n\n        if (typeof token.lineNumber === 'number') {\n            error = new Error('Line ' + token.lineNumber + ': ' + msg);\n            error.index = token.range[0];\n            error.lineNumber = token.lineNumber;\n            error.column = token.range[0] - lineStart + 1;\n        } else {\n            error = new Error('Line ' + lineNumber + ': ' + msg);\n            error.index = index;\n            error.lineNumber = lineNumber;\n            error.column = index - lineStart + 1;\n        }\n\n        throw error;\n    }\n\n    function throwErrorTolerant() {\n        try {\n            throwError.apply(null, arguments);\n        } catch (e) {\n            if (extra.errors) {\n                extra.errors.push(e);\n            } else {\n                throw e;\n            }\n        }\n    }\n\n\n    // Throw an exception because of the token.\n\n    function throwUnexpected(token) {\n        if (token.type === Token.EOF) {\n            throwError(token, Messages.UnexpectedEOS);\n        }\n\n        if (token.type === Token.NumericLiteral) {\n            throwError(token, Messages.UnexpectedNumber);\n        }\n\n        if (token.type === Token.StringLiteral) {\n            throwError(token, Messages.UnexpectedString);\n        }\n\n        if (token.type === Token.Identifier) {\n            throwError(token, Messages.UnexpectedIdentifier);\n        }\n\n        if (token.type === Token.Keyword) {\n            if (isFutureReservedWord(token.value)) {\n                throwError(token, Messages.UnexpectedReserved);\n            } else if (strict && isStrictModeReservedWord(token.value)) {\n                throwErrorTolerant(token, Messages.StrictReservedWord);\n                return;\n            }\n            throwError(token, Messages.UnexpectedToken, token.value);\n        }\n\n        // BooleanLiteral, NullLiteral, or Punctuator.\n        throwError(token, Messages.UnexpectedToken, token.value);\n    }\n\n    // Expect the next token to match the specified punctuator.\n    // If not, an exception will be thrown.\n\n    function expect(value) {\n        var token = lex();\n        if (token.type !== Token.Punctuator || token.value !== value) {\n            throwUnexpected(token);\n        }\n    }\n\n    // Expect the next token to match the specified keyword.\n    // If not, an exception will be thrown.\n\n    function expectKeyword(keyword) {\n        var token = lex();\n        if (token.type !== Token.Keyword || token.value !== keyword) {\n            throwUnexpected(token);\n        }\n    }\n\n    // Return true if the next token matches the specified punctuator.\n\n    function match(value) {\n        var token = lookahead();\n        return token.type === Token.Punctuator && token.value === value;\n    }\n\n    // Return true if the next token matches the specified keyword\n\n    function matchKeyword(keyword) {\n        var token = lookahead();\n        return token.type === Token.Keyword && token.value === keyword;\n    }\n\n    // Return true if the next token is an assignment operator\n\n    function matchAssign() {\n        var token = lookahead(),\n            op = token.value;\n\n        if (token.type !== Token.Punctuator) {\n            return false;\n        }\n        return op === '=' ||\n            op === '*=' ||\n            op === '/=' ||\n            op === '%=' ||\n            op === '+=' ||\n            op === '-=' ||\n            op === '<<=' ||\n            op === '>>=' ||\n            op === '>>>=' ||\n            op === '&=' ||\n            op === '^=' ||\n            op === '|=';\n    }\n\n    function consumeSemicolon() {\n        var token, line;\n\n        // Catch the very common case first.\n        if (source[index] === ';') {\n            lex();\n            return;\n        }\n\n        line = lineNumber;\n        skipComment();\n        if (lineNumber !== line) {\n            return;\n        }\n\n        if (match(';')) {\n            lex();\n            return;\n        }\n\n        token = lookahead();\n        if (token.type !== Token.EOF && !match('}')) {\n            throwUnexpected(token);\n        }\n    }\n\n    // Return true if provided expression is LeftHandSideExpression\n\n    function isLeftHandSide(expr) {\n        return expr.type === Syntax.Identifier || expr.type === Syntax.MemberExpression;\n    }\n\n    // 11.1.4 Array Initialiser\n\n    function parseArrayInitialiser() {\n        var elements = [];\n\n        expect('[');\n\n        while (!match(']')) {\n            if (match(',')) {\n                lex();\n                elements.push(null);\n            } else {\n                elements.push(parseAssignmentExpression());\n\n                if (!match(']')) {\n                    expect(',');\n                }\n            }\n        }\n\n        expect(']');\n\n        return {\n            type: Syntax.ArrayExpression,\n            elements: elements\n        };\n    }\n\n    // 11.1.5 Object Initialiser\n\n    function parsePropertyFunction(param, first) {\n        var previousStrict, body;\n\n        previousStrict = strict;\n        body = parseFunctionSourceElements();\n        if (first && strict && isRestrictedWord(param[0].name)) {\n            throwErrorTolerant(first, Messages.StrictParamName);\n        }\n        strict = previousStrict;\n\n        return {\n            type: Syntax.FunctionExpression,\n            id: null,\n            params: param,\n            defaults: [],\n            body: body,\n            rest: null,\n            generator: false,\n            expression: false\n        };\n    }\n\n    function parseObjectPropertyKey() {\n        var token = lex();\n\n        // Note: This function is called only from parseObjectProperty(), where\n        // EOF and Punctuator tokens are already filtered out.\n\n        if (token.type === Token.StringLiteral || token.type === Token.NumericLiteral) {\n            if (strict && token.octal) {\n                throwErrorTolerant(token, Messages.StrictOctalLiteral);\n            }\n            return createLiteral(token);\n        }\n\n        return {\n            type: Syntax.Identifier,\n            name: token.value\n        };\n    }\n\n    function parseObjectProperty() {\n        var token, key, id, param;\n\n        token = lookahead();\n\n        if (token.type === Token.Identifier) {\n\n            id = parseObjectPropertyKey();\n\n            // Property Assignment: Getter and Setter.\n\n            if (token.value === 'get' && !match(':')) {\n                key = parseObjectPropertyKey();\n                expect('(');\n                expect(')');\n                return {\n                    type: Syntax.Property,\n                    key: key,\n                    value: parsePropertyFunction([]),\n                    kind: 'get'\n                };\n            } else if (token.value === 'set' && !match(':')) {\n                key = parseObjectPropertyKey();\n                expect('(');\n                token = lookahead();\n                if (token.type !== Token.Identifier) {\n                    expect(')');\n                    throwErrorTolerant(token, Messages.UnexpectedToken, token.value);\n                    return {\n                        type: Syntax.Property,\n                        key: key,\n                        value: parsePropertyFunction([]),\n                        kind: 'set'\n                    };\n                } else {\n                    param = [ parseVariableIdentifier() ];\n                    expect(')');\n                    return {\n                        type: Syntax.Property,\n                        key: key,\n                        value: parsePropertyFunction(param, token),\n                        kind: 'set'\n                    };\n                }\n            } else {\n                expect(':');\n                return {\n                    type: Syntax.Property,\n                    key: id,\n                    value: parseAssignmentExpression(),\n                    kind: 'init'\n                };\n            }\n        } else if (token.type === Token.EOF || token.type === Token.Punctuator) {\n            throwUnexpected(token);\n        } else {\n            key = parseObjectPropertyKey();\n            expect(':');\n            return {\n                type: Syntax.Property,\n                key: key,\n                value: parseAssignmentExpression(),\n                kind: 'init'\n            };\n        }\n    }\n\n    function parseObjectInitialiser() {\n        var properties = [], property, name, kind, map = {}, toString = String;\n\n        expect('{');\n\n        while (!match('}')) {\n            property = parseObjectProperty();\n\n            if (property.key.type === Syntax.Identifier) {\n                name = property.key.name;\n            } else {\n                name = toString(property.key.value);\n            }\n            kind = (property.kind === 'init') ? PropertyKind.Data : (property.kind === 'get') ? PropertyKind.Get : PropertyKind.Set;\n            if (Object.prototype.hasOwnProperty.call(map, name)) {\n                if (map[name] === PropertyKind.Data) {\n                    if (strict && kind === PropertyKind.Data) {\n                        throwErrorTolerant({}, Messages.StrictDuplicateProperty);\n                    } else if (kind !== PropertyKind.Data) {\n                        throwErrorTolerant({}, Messages.AccessorDataProperty);\n                    }\n                } else {\n                    if (kind === PropertyKind.Data) {\n                        throwErrorTolerant({}, Messages.AccessorDataProperty);\n                    } else if (map[name] & kind) {\n                        throwErrorTolerant({}, Messages.AccessorGetSet);\n                    }\n                }\n                map[name] |= kind;\n            } else {\n                map[name] = kind;\n            }\n\n            properties.push(property);\n\n            if (!match('}')) {\n                expect(',');\n            }\n        }\n\n        expect('}');\n\n        return {\n            type: Syntax.ObjectExpression,\n            properties: properties\n        };\n    }\n\n    // 11.1.6 The Grouping Operator\n\n    function parseGroupExpression() {\n        var expr;\n\n        expect('(');\n\n        expr = parseExpression();\n\n        expect(')');\n\n        return expr;\n    }\n\n\n    // 11.1 Primary Expressions\n\n    function parsePrimaryExpression() {\n        var token = lookahead(),\n            type = token.type;\n\n        if (type === Token.Identifier) {\n            return {\n                type: Syntax.Identifier,\n                name: lex().value\n            };\n        }\n\n        if (type === Token.StringLiteral || type === Token.NumericLiteral) {\n            if (strict && token.octal) {\n                throwErrorTolerant(token, Messages.StrictOctalLiteral);\n            }\n            return createLiteral(lex());\n        }\n\n        if (type === Token.Keyword) {\n            if (matchKeyword('this')) {\n                lex();\n                return {\n                    type: Syntax.ThisExpression\n                };\n            }\n\n            if (matchKeyword('function')) {\n                return parseFunctionExpression();\n            }\n        }\n\n        if (type === Token.BooleanLiteral) {\n            lex();\n            token.value = (token.value === 'true');\n            return createLiteral(token);\n        }\n\n        if (type === Token.NullLiteral) {\n            lex();\n            token.value = null;\n            return createLiteral(token);\n        }\n\n        if (match('[')) {\n            return parseArrayInitialiser();\n        }\n\n        if (match('{')) {\n            return parseObjectInitialiser();\n        }\n\n        if (match('(')) {\n            return parseGroupExpression();\n        }\n\n        if (match('/') || match('/=')) {\n            return createLiteral(scanRegExp());\n        }\n\n        return throwUnexpected(lex());\n    }\n\n    // 11.2 Left-Hand-Side Expressions\n\n    function parseArguments() {\n        var args = [];\n\n        expect('(');\n\n        if (!match(')')) {\n            while (index < length) {\n                args.push(parseAssignmentExpression());\n                if (match(')')) {\n                    break;\n                }\n                expect(',');\n            }\n        }\n\n        expect(')');\n\n        return args;\n    }\n\n    function parseNonComputedProperty() {\n        var token = lex();\n\n        if (!isIdentifierName(token)) {\n            throwUnexpected(token);\n        }\n\n        return {\n            type: Syntax.Identifier,\n            name: token.value\n        };\n    }\n\n    function parseNonComputedMember() {\n        expect('.');\n\n        return parseNonComputedProperty();\n    }\n\n    function parseComputedMember() {\n        var expr;\n\n        expect('[');\n\n        expr = parseExpression();\n\n        expect(']');\n\n        return expr;\n    }\n\n    function parseNewExpression() {\n        var expr;\n\n        expectKeyword('new');\n\n        expr = {\n            type: Syntax.NewExpression,\n            callee: parseLeftHandSideExpression(),\n            'arguments': []\n        };\n\n        if (match('(')) {\n            expr['arguments'] = parseArguments();\n        }\n\n        return expr;\n    }\n\n    function parseLeftHandSideExpressionAllowCall() {\n        var expr;\n\n        expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression();\n\n        while (match('.') || match('[') || match('(')) {\n            if (match('(')) {\n                expr = {\n                    type: Syntax.CallExpression,\n                    callee: expr,\n                    'arguments': parseArguments()\n                };\n            } else if (match('[')) {\n                expr = {\n                    type: Syntax.MemberExpression,\n                    computed: true,\n                    object: expr,\n                    property: parseComputedMember()\n                };\n            } else {\n                expr = {\n                    type: Syntax.MemberExpression,\n                    computed: false,\n                    object: expr,\n                    property: parseNonComputedMember()\n                };\n            }\n        }\n\n        return expr;\n    }\n\n\n    function parseLeftHandSideExpression() {\n        var expr;\n\n        expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression();\n\n        while (match('.') || match('[')) {\n            if (match('[')) {\n                expr = {\n                    type: Syntax.MemberExpression,\n                    computed: true,\n                    object: expr,\n                    property: parseComputedMember()\n                };\n            } else {\n                expr = {\n                    type: Syntax.MemberExpression,\n                    computed: false,\n                    object: expr,\n                    property: parseNonComputedMember()\n                };\n            }\n        }\n\n        return expr;\n    }\n\n    // 11.3 Postfix Expressions\n\n    function parsePostfixExpression() {\n        var expr = parseLeftHandSideExpressionAllowCall(), token;\n\n        token = lookahead();\n        if (token.type !== Token.Punctuator) {\n            return expr;\n        }\n\n        if ((match('++') || match('--')) && !peekLineTerminator()) {\n            // 11.3.1, 11.3.2\n            if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) {\n                throwErrorTolerant({}, Messages.StrictLHSPostfix);\n            }\n            if (!isLeftHandSide(expr)) {\n                throwErrorTolerant({}, Messages.InvalidLHSInAssignment);\n            }\n\n            expr = {\n                type: Syntax.UpdateExpression,\n                operator: lex().value,\n                argument: expr,\n                prefix: false\n            };\n        }\n\n        return expr;\n    }\n\n    // 11.4 Unary Operators\n\n    function parseUnaryExpression() {\n        var token, expr;\n\n        token = lookahead();\n        if (token.type !== Token.Punctuator && token.type !== Token.Keyword) {\n            return parsePostfixExpression();\n        }\n\n        if (match('++') || match('--')) {\n            token = lex();\n            expr = parseUnaryExpression();\n            // 11.4.4, 11.4.5\n            if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) {\n                throwErrorTolerant({}, Messages.StrictLHSPrefix);\n            }\n\n            if (!isLeftHandSide(expr)) {\n                throwErrorTolerant({}, Messages.InvalidLHSInAssignment);\n            }\n\n            expr = {\n                type: Syntax.UpdateExpression,\n                operator: token.value,\n                argument: expr,\n                prefix: true\n            };\n            return expr;\n        }\n\n        if (match('+') || match('-') || match('~') || match('!')) {\n            expr = {\n                type: Syntax.UnaryExpression,\n                operator: lex().value,\n                argument: parseUnaryExpression(),\n                prefix: true\n            };\n            return expr;\n        }\n\n        if (matchKeyword('delete') || matchKeyword('void') || matchKeyword('typeof')) {\n            expr = {\n                type: Syntax.UnaryExpression,\n                operator: lex().value,\n                argument: parseUnaryExpression(),\n                prefix: true\n            };\n            if (strict && expr.operator === 'delete' && expr.argument.type === Syntax.Identifier) {\n                throwErrorTolerant({}, Messages.StrictDelete);\n            }\n            return expr;\n        }\n\n        return parsePostfixExpression();\n    }\n\n    // 11.5 Multiplicative Operators\n\n    function parseMultiplicativeExpression() {\n        var expr = parseUnaryExpression();\n\n        while (match('*') || match('/') || match('%')) {\n            expr = {\n                type: Syntax.BinaryExpression,\n                operator: lex().value,\n                left: expr,\n                right: parseUnaryExpression()\n            };\n        }\n\n        return expr;\n    }\n\n    // 11.6 Additive Operators\n\n    function parseAdditiveExpression() {\n        var expr = parseMultiplicativeExpression();\n\n        while (match('+') || match('-')) {\n            expr = {\n                type: Syntax.BinaryExpression,\n                operator: lex().value,\n                left: expr,\n                right: parseMultiplicativeExpression()\n            };\n        }\n\n        return expr;\n    }\n\n    // 11.7 Bitwise Shift Operators\n\n    function parseShiftExpression() {\n        var expr = parseAdditiveExpression();\n\n        while (match('<<') || match('>>') || match('>>>')) {\n            expr = {\n                type: Syntax.BinaryExpression,\n                operator: lex().value,\n                left: expr,\n                right: parseAdditiveExpression()\n            };\n        }\n\n        return expr;\n    }\n    // 11.8 Relational Operators\n\n    function parseRelationalExpression() {\n        var expr, previousAllowIn;\n\n        previousAllowIn = state.allowIn;\n        state.allowIn = true;\n\n        expr = parseShiftExpression();\n\n        while (match('<') || match('>') || match('<=') || match('>=') || (previousAllowIn && matchKeyword('in')) || matchKeyword('instanceof')) {\n            expr = {\n                type: Syntax.BinaryExpression,\n                operator: lex().value,\n                left: expr,\n                right: parseShiftExpression()\n            };\n        }\n\n        state.allowIn = previousAllowIn;\n        return expr;\n    }\n\n    // 11.9 Equality Operators\n\n    function parseEqualityExpression() {\n        var expr = parseRelationalExpression();\n\n        while (match('==') || match('!=') || match('===') || match('!==')) {\n            expr = {\n                type: Syntax.BinaryExpression,\n                operator: lex().value,\n                left: expr,\n                right: parseRelationalExpression()\n            };\n        }\n\n        return expr;\n    }\n\n    // 11.10 Binary Bitwise Operators\n\n    function parseBitwiseANDExpression() {\n        var expr = parseEqualityExpression();\n\n        while (match('&')) {\n            lex();\n            expr = {\n                type: Syntax.BinaryExpression,\n                operator: '&',\n                left: expr,\n                right: parseEqualityExpression()\n            };\n        }\n\n        return expr;\n    }\n\n    function parseBitwiseXORExpression() {\n        var expr = parseBitwiseANDExpression();\n\n        while (match('^')) {\n            lex();\n            expr = {\n                type: Syntax.BinaryExpression,\n                operator: '^',\n                left: expr,\n                right: parseBitwiseANDExpression()\n            };\n        }\n\n        return expr;\n    }\n\n    function parseBitwiseORExpression() {\n        var expr = parseBitwiseXORExpression();\n\n        while (match('|')) {\n            lex();\n            expr = {\n                type: Syntax.BinaryExpression,\n                operator: '|',\n                left: expr,\n                right: parseBitwiseXORExpression()\n            };\n        }\n\n        return expr;\n    }\n\n    // 11.11 Binary Logical Operators\n\n    function parseLogicalANDExpression() {\n        var expr = parseBitwiseORExpression();\n\n        while (match('&&')) {\n            lex();\n            expr = {\n                type: Syntax.LogicalExpression,\n                operator: '&&',\n                left: expr,\n                right: parseBitwiseORExpression()\n            };\n        }\n\n        return expr;\n    }\n\n    function parseLogicalORExpression() {\n        var expr = parseLogicalANDExpression();\n\n        while (match('||')) {\n            lex();\n            expr = {\n                type: Syntax.LogicalExpression,\n                operator: '||',\n                left: expr,\n                right: parseLogicalANDExpression()\n            };\n        }\n\n        return expr;\n    }\n\n    // 11.12 Conditional Operator\n\n    function parseConditionalExpression() {\n        var expr, previousAllowIn, consequent;\n\n        expr = parseLogicalORExpression();\n\n        if (match('?')) {\n            lex();\n            previousAllowIn = state.allowIn;\n            state.allowIn = true;\n            consequent = parseAssignmentExpression();\n            state.allowIn = previousAllowIn;\n            expect(':');\n\n            expr = {\n                type: Syntax.ConditionalExpression,\n                test: expr,\n                consequent: consequent,\n                alternate: parseAssignmentExpression()\n            };\n        }\n\n        return expr;\n    }\n\n    // 11.13 Assignment Operators\n\n    function parseAssignmentExpression() {\n        var token, expr;\n\n        token = lookahead();\n        expr = parseConditionalExpression();\n\n        if (matchAssign()) {\n            // LeftHandSideExpression\n            if (!isLeftHandSide(expr)) {\n                throwErrorTolerant({}, Messages.InvalidLHSInAssignment);\n            }\n\n            // 11.13.1\n            if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) {\n                throwErrorTolerant(token, Messages.StrictLHSAssignment);\n            }\n\n            expr = {\n                type: Syntax.AssignmentExpression,\n                operator: lex().value,\n                left: expr,\n                right: parseAssignmentExpression()\n            };\n        }\n\n        return expr;\n    }\n\n    // 11.14 Comma Operator\n\n    function parseExpression() {\n        var expr = parseAssignmentExpression();\n\n        if (match(',')) {\n            expr = {\n                type: Syntax.SequenceExpression,\n                expressions: [ expr ]\n            };\n\n            while (index < length) {\n                if (!match(',')) {\n                    break;\n                }\n                lex();\n                expr.expressions.push(parseAssignmentExpression());\n            }\n\n        }\n        return expr;\n    }\n\n    // 12.1 Block\n\n    function parseStatementList() {\n        var list = [],\n            statement;\n\n        while (index < length) {\n            if (match('}')) {\n                break;\n            }\n            statement = parseSourceElement();\n            if (typeof statement === 'undefined') {\n                break;\n            }\n            list.push(statement);\n        }\n\n        return list;\n    }\n\n    function parseBlock() {\n        var block;\n\n        expect('{');\n\n        block = parseStatementList();\n\n        expect('}');\n\n        return {\n            type: Syntax.BlockStatement,\n            body: block\n        };\n    }\n\n    // 12.2 Variable Statement\n\n    function parseVariableIdentifier() {\n        var token = lex();\n\n        if (token.type !== Token.Identifier) {\n            throwUnexpected(token);\n        }\n\n        return {\n            type: Syntax.Identifier,\n            name: token.value\n        };\n    }\n\n    function parseVariableDeclaration(kind) {\n        var id = parseVariableIdentifier(),\n            init = null;\n\n        // 12.2.1\n        if (strict && isRestrictedWord(id.name)) {\n            throwErrorTolerant({}, Messages.StrictVarName);\n        }\n\n        if (kind === 'const') {\n            expect('=');\n            init = parseAssignmentExpression();\n        } else if (match('=')) {\n            lex();\n            init = parseAssignmentExpression();\n        }\n\n        return {\n            type: Syntax.VariableDeclarator,\n            id: id,\n            init: init\n        };\n    }\n\n    function parseVariableDeclarationList(kind) {\n        var list = [];\n\n        do {\n            list.push(parseVariableDeclaration(kind));\n            if (!match(',')) {\n                break;\n            }\n            lex();\n        } while (index < length);\n\n        return list;\n    }\n\n    function parseVariableStatement() {\n        var declarations;\n\n        expectKeyword('var');\n\n        declarations = parseVariableDeclarationList();\n\n        consumeSemicolon();\n\n        return {\n            type: Syntax.VariableDeclaration,\n            declarations: declarations,\n            kind: 'var'\n        };\n    }\n\n    // kind may be `const` or `let`\n    // Both are experimental and not in the specification yet.\n    // see http://wiki.ecmascript.org/doku.php?id=harmony:const\n    // and http://wiki.ecmascript.org/doku.php?id=harmony:let\n    function parseConstLetDeclaration(kind) {\n        var declarations;\n\n        expectKeyword(kind);\n\n        declarations = parseVariableDeclarationList(kind);\n\n        consumeSemicolon();\n\n        return {\n            type: Syntax.VariableDeclaration,\n            declarations: declarations,\n            kind: kind\n        };\n    }\n\n    // 12.3 Empty Statement\n\n    function parseEmptyStatement() {\n        expect(';');\n\n        return {\n            type: Syntax.EmptyStatement\n        };\n    }\n\n    // 12.4 Expression Statement\n\n    function parseExpressionStatement() {\n        var expr = parseExpression();\n\n        consumeSemicolon();\n\n        return {\n            type: Syntax.ExpressionStatement,\n            expression: expr\n        };\n    }\n\n    // 12.5 If statement\n\n    function parseIfStatement() {\n        var test, consequent, alternate;\n\n        expectKeyword('if');\n\n        expect('(');\n\n        test = parseExpression();\n\n        expect(')');\n\n        consequent = parseStatement();\n\n        if (matchKeyword('else')) {\n            lex();\n            alternate = parseStatement();\n        } else {\n            alternate = null;\n        }\n\n        return {\n            type: Syntax.IfStatement,\n            test: test,\n            consequent: consequent,\n            alternate: alternate\n        };\n    }\n\n    // 12.6 Iteration Statements\n\n    function parseDoWhileStatement() {\n        var body, test, oldInIteration;\n\n        expectKeyword('do');\n\n        oldInIteration = state.inIteration;\n        state.inIteration = true;\n\n        body = parseStatement();\n\n        state.inIteration = oldInIteration;\n\n        expectKeyword('while');\n\n        expect('(');\n\n        test = parseExpression();\n\n        expect(')');\n\n        if (match(';')) {\n            lex();\n        }\n\n        return {\n            type: Syntax.DoWhileStatement,\n            body: body,\n            test: test\n        };\n    }\n\n    function parseWhileStatement() {\n        var test, body, oldInIteration;\n\n        expectKeyword('while');\n\n        expect('(');\n\n        test = parseExpression();\n\n        expect(')');\n\n        oldInIteration = state.inIteration;\n        state.inIteration = true;\n\n        body = parseStatement();\n\n        state.inIteration = oldInIteration;\n\n        return {\n            type: Syntax.WhileStatement,\n            test: test,\n            body: body\n        };\n    }\n\n    function parseForVariableDeclaration() {\n        var token = lex();\n\n        return {\n            type: Syntax.VariableDeclaration,\n            declarations: parseVariableDeclarationList(),\n            kind: token.value\n        };\n    }\n\n    function parseForStatement() {\n        var init, test, update, left, right, body, oldInIteration;\n\n        init = test = update = null;\n\n        expectKeyword('for');\n\n        expect('(');\n\n        if (match(';')) {\n            lex();\n        } else {\n            if (matchKeyword('var') || matchKeyword('let')) {\n                state.allowIn = false;\n                init = parseForVariableDeclaration();\n                state.allowIn = true;\n\n                if (init.declarations.length === 1 && matchKeyword('in')) {\n                    lex();\n                    left = init;\n                    right = parseExpression();\n                    init = null;\n                }\n            } else {\n                state.allowIn = false;\n                init = parseExpression();\n                state.allowIn = true;\n\n                if (matchKeyword('in')) {\n                    // LeftHandSideExpression\n                    if (!isLeftHandSide(init)) {\n                        throwErrorTolerant({}, Messages.InvalidLHSInForIn);\n                    }\n\n                    lex();\n                    left = init;\n                    right = parseExpression();\n                    init = null;\n                }\n            }\n\n            if (typeof left === 'undefined') {\n                expect(';');\n            }\n        }\n\n        if (typeof left === 'undefined') {\n\n            if (!match(';')) {\n                test = parseExpression();\n            }\n            expect(';');\n\n            if (!match(')')) {\n                update = parseExpression();\n            }\n        }\n\n        expect(')');\n\n        oldInIteration = state.inIteration;\n        state.inIteration = true;\n\n        body = parseStatement();\n\n        state.inIteration = oldInIteration;\n\n        if (typeof left === 'undefined') {\n            return {\n                type: Syntax.ForStatement,\n                init: init,\n                test: test,\n                update: update,\n                body: body\n            };\n        }\n\n        return {\n            type: Syntax.ForInStatement,\n            left: left,\n            right: right,\n            body: body,\n            each: false\n        };\n    }\n\n    // 12.7 The continue statement\n\n    function parseContinueStatement() {\n        var token, label = null;\n\n        expectKeyword('continue');\n\n        // Optimize the most common form: 'continue;'.\n        if (source[index] === ';') {\n            lex();\n\n            if (!state.inIteration) {\n                throwError({}, Messages.IllegalContinue);\n            }\n\n            return {\n                type: Syntax.ContinueStatement,\n                label: null\n            };\n        }\n\n        if (peekLineTerminator()) {\n            if (!state.inIteration) {\n                throwError({}, Messages.IllegalContinue);\n            }\n\n            return {\n                type: Syntax.ContinueStatement,\n                label: null\n            };\n        }\n\n        token = lookahead();\n        if (token.type === Token.Identifier) {\n            label = parseVariableIdentifier();\n\n            if (!Object.prototype.hasOwnProperty.call(state.labelSet, label.name)) {\n                throwError({}, Messages.UnknownLabel, label.name);\n            }\n        }\n\n        consumeSemicolon();\n\n        if (label === null && !state.inIteration) {\n            throwError({}, Messages.IllegalContinue);\n        }\n\n        return {\n            type: Syntax.ContinueStatement,\n            label: label\n        };\n    }\n\n    // 12.8 The break statement\n\n    function parseBreakStatement() {\n        var token, label = null;\n\n        expectKeyword('break');\n\n        // Optimize the most common form: 'break;'.\n        if (source[index] === ';') {\n            lex();\n\n            if (!(state.inIteration || state.inSwitch)) {\n                throwError({}, Messages.IllegalBreak);\n            }\n\n            return {\n                type: Syntax.BreakStatement,\n                label: null\n            };\n        }\n\n        if (peekLineTerminator()) {\n            if (!(state.inIteration || state.inSwitch)) {\n                throwError({}, Messages.IllegalBreak);\n            }\n\n            return {\n                type: Syntax.BreakStatement,\n                label: null\n            };\n        }\n\n        token = lookahead();\n        if (token.type === Token.Identifier) {\n            label = parseVariableIdentifier();\n\n            if (!Object.prototype.hasOwnProperty.call(state.labelSet, label.name)) {\n                throwError({}, Messages.UnknownLabel, label.name);\n            }\n        }\n\n        consumeSemicolon();\n\n        if (label === null && !(state.inIteration || state.inSwitch)) {\n            throwError({}, Messages.IllegalBreak);\n        }\n\n        return {\n            type: Syntax.BreakStatement,\n            label: label\n        };\n    }\n\n    // 12.9 The return statement\n\n    function parseReturnStatement() {\n        var token, argument = null;\n\n        expectKeyword('return');\n\n        if (!state.inFunctionBody) {\n            throwErrorTolerant({}, Messages.IllegalReturn);\n        }\n\n        // 'return' followed by a space and an identifier is very common.\n        if (source[index] === ' ') {\n            if (isIdentifierStart(source[index + 1])) {\n                argument = parseExpression();\n                consumeSemicolon();\n                return {\n                    type: Syntax.ReturnStatement,\n                    argument: argument\n                };\n            }\n        }\n\n        if (peekLineTerminator()) {\n            return {\n                type: Syntax.ReturnStatement,\n                argument: null\n            };\n        }\n\n        if (!match(';')) {\n            token = lookahead();\n            if (!match('}') && token.type !== Token.EOF) {\n                argument = parseExpression();\n            }\n        }\n\n        consumeSemicolon();\n\n        return {\n            type: Syntax.ReturnStatement,\n            argument: argument\n        };\n    }\n\n    // 12.10 The with statement\n\n    function parseWithStatement() {\n        var object, body;\n\n        if (strict) {\n            throwErrorTolerant({}, Messages.StrictModeWith);\n        }\n\n        expectKeyword('with');\n\n        expect('(');\n\n        object = parseExpression();\n\n        expect(')');\n\n        body = parseStatement();\n\n        return {\n            type: Syntax.WithStatement,\n            object: object,\n            body: body\n        };\n    }\n\n    // 12.10 The swith statement\n\n    function parseSwitchCase() {\n        var test,\n            consequent = [],\n            statement;\n\n        if (matchKeyword('default')) {\n            lex();\n            test = null;\n        } else {\n            expectKeyword('case');\n            test = parseExpression();\n        }\n        expect(':');\n\n        while (index < length) {\n            if (match('}') || matchKeyword('default') || matchKeyword('case')) {\n                break;\n            }\n            statement = parseStatement();\n            if (typeof statement === 'undefined') {\n                break;\n            }\n            consequent.push(statement);\n        }\n\n        return {\n            type: Syntax.SwitchCase,\n            test: test,\n            consequent: consequent\n        };\n    }\n\n    function parseSwitchStatement() {\n        var discriminant, cases, clause, oldInSwitch, defaultFound;\n\n        expectKeyword('switch');\n\n        expect('(');\n\n        discriminant = parseExpression();\n\n        expect(')');\n\n        expect('{');\n\n        cases = [];\n\n        if (match('}')) {\n            lex();\n            return {\n                type: Syntax.SwitchStatement,\n                discriminant: discriminant,\n                cases: cases\n            };\n        }\n\n        oldInSwitch = state.inSwitch;\n        state.inSwitch = true;\n        defaultFound = false;\n\n        while (index < length) {\n            if (match('}')) {\n                break;\n            }\n            clause = parseSwitchCase();\n            if (clause.test === null) {\n                if (defaultFound) {\n                    throwError({}, Messages.MultipleDefaultsInSwitch);\n                }\n                defaultFound = true;\n            }\n            cases.push(clause);\n        }\n\n        state.inSwitch = oldInSwitch;\n\n        expect('}');\n\n        return {\n            type: Syntax.SwitchStatement,\n            discriminant: discriminant,\n            cases: cases\n        };\n    }\n\n    // 12.13 The throw statement\n\n    function parseThrowStatement() {\n        var argument;\n\n        expectKeyword('throw');\n\n        if (peekLineTerminator()) {\n            throwError({}, Messages.NewlineAfterThrow);\n        }\n\n        argument = parseExpression();\n\n        consumeSemicolon();\n\n        return {\n            type: Syntax.ThrowStatement,\n            argument: argument\n        };\n    }\n\n    // 12.14 The try statement\n\n    function parseCatchClause() {\n        var param;\n\n        expectKeyword('catch');\n\n        expect('(');\n        if (match(')')) {\n            throwUnexpected(lookahead());\n        }\n\n        param = parseVariableIdentifier();\n        // 12.14.1\n        if (strict && isRestrictedWord(param.name)) {\n            throwErrorTolerant({}, Messages.StrictCatchVariable);\n        }\n\n        expect(')');\n\n        return {\n            type: Syntax.CatchClause,\n            param: param,\n            body: parseBlock()\n        };\n    }\n\n    function parseTryStatement() {\n        var block, handlers = [], finalizer = null;\n\n        expectKeyword('try');\n\n        block = parseBlock();\n\n        if (matchKeyword('catch')) {\n            handlers.push(parseCatchClause());\n        }\n\n        if (matchKeyword('finally')) {\n            lex();\n            finalizer = parseBlock();\n        }\n\n        if (handlers.length === 0 && !finalizer) {\n            throwError({}, Messages.NoCatchOrFinally);\n        }\n\n        return {\n            type: Syntax.TryStatement,\n            block: block,\n            guardedHandlers: [],\n            handlers: handlers,\n            finalizer: finalizer\n        };\n    }\n\n    // 12.15 The debugger statement\n\n    function parseDebuggerStatement() {\n        expectKeyword('debugger');\n\n        consumeSemicolon();\n\n        return {\n            type: Syntax.DebuggerStatement\n        };\n    }\n\n    // 12 Statements\n\n    function parseStatement() {\n        var token = lookahead(),\n            expr,\n            labeledBody;\n\n        if (token.type === Token.EOF) {\n            throwUnexpected(token);\n        }\n\n        if (token.type === Token.Punctuator) {\n            switch (token.value) {\n            case ';':\n                return parseEmptyStatement();\n            case '{':\n                return parseBlock();\n            case '(':\n                return parseExpressionStatement();\n            default:\n                break;\n            }\n        }\n\n        if (token.type === Token.Keyword) {\n            switch (token.value) {\n            case 'break':\n                return parseBreakStatement();\n            case 'continue':\n                return parseContinueStatement();\n            case 'debugger':\n                return parseDebuggerStatement();\n            case 'do':\n                return parseDoWhileStatement();\n            case 'for':\n                return parseForStatement();\n            case 'function':\n                return parseFunctionDeclaration();\n            case 'if':\n                return parseIfStatement();\n            case 'return':\n                return parseReturnStatement();\n            case 'switch':\n                return parseSwitchStatement();\n            case 'throw':\n                return parseThrowStatement();\n            case 'try':\n                return parseTryStatement();\n            case 'var':\n                return parseVariableStatement();\n            case 'while':\n                return parseWhileStatement();\n            case 'with':\n                return parseWithStatement();\n            default:\n                break;\n            }\n        }\n\n        expr = parseExpression();\n\n        // 12.12 Labelled Statements\n        if ((expr.type === Syntax.Identifier) && match(':')) {\n            lex();\n\n            if (Object.prototype.hasOwnProperty.call(state.labelSet, expr.name)) {\n                throwError({}, Messages.Redeclaration, 'Label', expr.name);\n            }\n\n            state.labelSet[expr.name] = true;\n            labeledBody = parseStatement();\n            delete state.labelSet[expr.name];\n\n            return {\n                type: Syntax.LabeledStatement,\n                label: expr,\n                body: labeledBody\n            };\n        }\n\n        consumeSemicolon();\n\n        return {\n            type: Syntax.ExpressionStatement,\n            expression: expr\n        };\n    }\n\n    // 13 Function Definition\n\n    function parseFunctionSourceElements() {\n        var sourceElement, sourceElements = [], token, directive, firstRestricted,\n            oldLabelSet, oldInIteration, oldInSwitch, oldInFunctionBody;\n\n        expect('{');\n\n        while (index < length) {\n            token = lookahead();\n            if (token.type !== Token.StringLiteral) {\n                break;\n            }\n\n            sourceElement = parseSourceElement();\n            sourceElements.push(sourceElement);\n            if (sourceElement.expression.type !== Syntax.Literal) {\n                // this is not directive\n                break;\n            }\n            directive = sliceSource(token.range[0] + 1, token.range[1] - 1);\n            if (directive === 'use strict') {\n                strict = true;\n                if (firstRestricted) {\n                    throwErrorTolerant(firstRestricted, Messages.StrictOctalLiteral);\n                }\n            } else {\n                if (!firstRestricted && token.octal) {\n                    firstRestricted = token;\n                }\n            }\n        }\n\n        oldLabelSet = state.labelSet;\n        oldInIteration = state.inIteration;\n        oldInSwitch = state.inSwitch;\n        oldInFunctionBody = state.inFunctionBody;\n\n        state.labelSet = {};\n        state.inIteration = false;\n        state.inSwitch = false;\n        state.inFunctionBody = true;\n\n        while (index < length) {\n            if (match('}')) {\n                break;\n            }\n            sourceElement = parseSourceElement();\n            if (typeof sourceElement === 'undefined') {\n                break;\n            }\n            sourceElements.push(sourceElement);\n        }\n\n        expect('}');\n\n        state.labelSet = oldLabelSet;\n        state.inIteration = oldInIteration;\n        state.inSwitch = oldInSwitch;\n        state.inFunctionBody = oldInFunctionBody;\n\n        return {\n            type: Syntax.BlockStatement,\n            body: sourceElements\n        };\n    }\n\n    function parseFunctionDeclaration() {\n        var id, param, params = [], body, token, stricted, firstRestricted, message, previousStrict, paramSet;\n\n        expectKeyword('function');\n        token = lookahead();\n        id = parseVariableIdentifier();\n        if (strict) {\n            if (isRestrictedWord(token.value)) {\n                throwErrorTolerant(token, Messages.StrictFunctionName);\n            }\n        } else {\n            if (isRestrictedWord(token.value)) {\n                firstRestricted = token;\n                message = Messages.StrictFunctionName;\n            } else if (isStrictModeReservedWord(token.value)) {\n                firstRestricted = token;\n                message = Messages.StrictReservedWord;\n            }\n        }\n\n        expect('(');\n\n        if (!match(')')) {\n            paramSet = {};\n            while (index < length) {\n                token = lookahead();\n                param = parseVariableIdentifier();\n                if (strict) {\n                    if (isRestrictedWord(token.value)) {\n                        stricted = token;\n                        message = Messages.StrictParamName;\n                    }\n                    if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) {\n                        stricted = token;\n                        message = Messages.StrictParamDupe;\n                    }\n                } else if (!firstRestricted) {\n                    if (isRestrictedWord(token.value)) {\n                        firstRestricted = token;\n                        message = Messages.StrictParamName;\n                    } else if (isStrictModeReservedWord(token.value)) {\n                        firstRestricted = token;\n                        message = Messages.StrictReservedWord;\n                    } else if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) {\n                        firstRestricted = token;\n                        message = Messages.StrictParamDupe;\n                    }\n                }\n                params.push(param);\n                paramSet[param.name] = true;\n                if (match(')')) {\n                    break;\n                }\n                expect(',');\n            }\n        }\n\n        expect(')');\n\n        previousStrict = strict;\n        body = parseFunctionSourceElements();\n        if (strict && firstRestricted) {\n            throwError(firstRestricted, message);\n        }\n        if (strict && stricted) {\n            throwErrorTolerant(stricted, message);\n        }\n        strict = previousStrict;\n\n        return {\n            type: Syntax.FunctionDeclaration,\n            id: id,\n            params: params,\n            defaults: [],\n            body: body,\n            rest: null,\n            generator: false,\n            expression: false\n        };\n    }\n\n    function parseFunctionExpression() {\n        var token, id = null, stricted, firstRestricted, message, param, params = [], body, previousStrict, paramSet;\n\n        expectKeyword('function');\n\n        if (!match('(')) {\n            token = lookahead();\n            id = parseVariableIdentifier();\n            if (strict) {\n                if (isRestrictedWord(token.value)) {\n                    throwErrorTolerant(token, Messages.StrictFunctionName);\n                }\n            } else {\n                if (isRestrictedWord(token.value)) {\n                    firstRestricted = token;\n                    message = Messages.StrictFunctionName;\n                } else if (isStrictModeReservedWord(token.value)) {\n                    firstRestricted = token;\n                    message = Messages.StrictReservedWord;\n                }\n            }\n        }\n\n        expect('(');\n\n        if (!match(')')) {\n            paramSet = {};\n            while (index < length) {\n                token = lookahead();\n                param = parseVariableIdentifier();\n                if (strict) {\n                    if (isRestrictedWord(token.value)) {\n                        stricted = token;\n                        message = Messages.StrictParamName;\n                    }\n                    if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) {\n                        stricted = token;\n                        message = Messages.StrictParamDupe;\n                    }\n                } else if (!firstRestricted) {\n                    if (isRestrictedWord(token.value)) {\n                        firstRestricted = token;\n                        message = Messages.StrictParamName;\n                    } else if (isStrictModeReservedWord(token.value)) {\n                        firstRestricted = token;\n                        message = Messages.StrictReservedWord;\n                    } else if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) {\n                        firstRestricted = token;\n                        message = Messages.StrictParamDupe;\n                    }\n                }\n                params.push(param);\n                paramSet[param.name] = true;\n                if (match(')')) {\n                    break;\n                }\n                expect(',');\n            }\n        }\n\n        expect(')');\n\n        previousStrict = strict;\n        body = parseFunctionSourceElements();\n        if (strict && firstRestricted) {\n            throwError(firstRestricted, message);\n        }\n        if (strict && stricted) {\n            throwErrorTolerant(stricted, message);\n        }\n        strict = previousStrict;\n\n        return {\n            type: Syntax.FunctionExpression,\n            id: id,\n            params: params,\n            defaults: [],\n            body: body,\n            rest: null,\n            generator: false,\n            expression: false\n        };\n    }\n\n    // 14 Program\n\n    function parseSourceElement() {\n        var token = lookahead();\n\n        if (token.type === Token.Keyword) {\n            switch (token.value) {\n            case 'const':\n            case 'let':\n                return parseConstLetDeclaration(token.value);\n            case 'function':\n                return parseFunctionDeclaration();\n            default:\n                return parseStatement();\n            }\n        }\n\n        if (token.type !== Token.EOF) {\n            return parseStatement();\n        }\n    }\n\n    function parseSourceElements() {\n        var sourceElement, sourceElements = [], token, directive, firstRestricted;\n\n        while (index < length) {\n            token = lookahead();\n            if (token.type !== Token.StringLiteral) {\n                break;\n            }\n\n            sourceElement = parseSourceElement();\n            sourceElements.push(sourceElement);\n            if (sourceElement.expression.type !== Syntax.Literal) {\n                // this is not directive\n                break;\n            }\n            directive = sliceSource(token.range[0] + 1, token.range[1] - 1);\n            if (directive === 'use strict') {\n                strict = true;\n                if (firstRestricted) {\n                    throwErrorTolerant(firstRestricted, Messages.StrictOctalLiteral);\n                }\n            } else {\n                if (!firstRestricted && token.octal) {\n                    firstRestricted = token;\n                }\n            }\n        }\n\n        while (index < length) {\n            sourceElement = parseSourceElement();\n            if (typeof sourceElement === 'undefined') {\n                break;\n            }\n            sourceElements.push(sourceElement);\n        }\n        return sourceElements;\n    }\n\n    function parseProgram() {\n        var program;\n        strict = false;\n        program = {\n            type: Syntax.Program,\n            body: parseSourceElements()\n        };\n        return program;\n    }\n\n    // The following functions are needed only when the option to preserve\n    // the comments is active.\n\n    function addComment(type, value, start, end, loc) {\n        assert(typeof start === 'number', 'Comment must have valid position');\n\n        // Because the way the actual token is scanned, often the comments\n        // (if any) are skipped twice during the lexical analysis.\n        // Thus, we need to skip adding a comment if the comment array already\n        // handled it.\n        if (extra.comments.length > 0) {\n            if (extra.comments[extra.comments.length - 1].range[1] > start) {\n                return;\n            }\n        }\n\n        extra.comments.push({\n            type: type,\n            value: value,\n            range: [start, end],\n            loc: loc\n        });\n    }\n\n    function scanComment() {\n        var comment, ch, loc, start, blockComment, lineComment;\n\n        comment = '';\n        blockComment = false;\n        lineComment = false;\n\n        while (index < length) {\n            ch = source[index];\n\n            if (lineComment) {\n                ch = source[index++];\n                if (isLineTerminator(ch)) {\n                    loc.end = {\n                        line: lineNumber,\n                        column: index - lineStart - 1\n                    };\n                    lineComment = false;\n                    addComment('Line', comment, start, index - 1, loc);\n                    if (ch === '\\r' && source[index] === '\\n') {\n                        ++index;\n                    }\n                    ++lineNumber;\n                    lineStart = index;\n                    comment = '';\n                } else if (index >= length) {\n                    lineComment = false;\n                    comment += ch;\n                    loc.end = {\n                        line: lineNumber,\n                        column: length - lineStart\n                    };\n                    addComment('Line', comment, start, length, loc);\n                } else {\n                    comment += ch;\n                }\n            } else if (blockComment) {\n                if (isLineTerminator(ch)) {\n                    if (ch === '\\r' && source[index + 1] === '\\n') {\n                        ++index;\n                        comment += '\\r\\n';\n                    } else {\n                        comment += ch;\n                    }\n                    ++lineNumber;\n                    ++index;\n                    lineStart = index;\n                    if (index >= length) {\n                        throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n                    }\n                } else {\n                    ch = source[index++];\n                    if (index >= length) {\n                        throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n                    }\n                    comment += ch;\n                    if (ch === '*') {\n                        ch = source[index];\n                        if (ch === '/') {\n                            comment = comment.substr(0, comment.length - 1);\n                            blockComment = false;\n                            ++index;\n                            loc.end = {\n                                line: lineNumber,\n                                column: index - lineStart\n                            };\n                            addComment('Block', comment, start, index, loc);\n                            comment = '';\n                        }\n                    }\n                }\n            } else if (ch === '/') {\n                ch = source[index + 1];\n                if (ch === '/') {\n                    loc = {\n                        start: {\n                            line: lineNumber,\n                            column: index - lineStart\n                        }\n                    };\n                    start = index;\n                    index += 2;\n                    lineComment = true;\n                    if (index >= length) {\n                        loc.end = {\n                            line: lineNumber,\n                            column: index - lineStart\n                        };\n                        lineComment = false;\n                        addComment('Line', comment, start, index, loc);\n                    }\n                } else if (ch === '*') {\n                    start = index;\n                    index += 2;\n                    blockComment = true;\n                    loc = {\n                        start: {\n                            line: lineNumber,\n                            column: index - lineStart - 2\n                        }\n                    };\n                    if (index >= length) {\n                        throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n                    }\n                } else {\n                    break;\n                }\n            } else if (isWhiteSpace(ch)) {\n                ++index;\n            } else if (isLineTerminator(ch)) {\n                ++index;\n                if (ch ===  '\\r' && source[index] === '\\n') {\n                    ++index;\n                }\n                ++lineNumber;\n                lineStart = index;\n            } else {\n                break;\n            }\n        }\n    }\n\n    function filterCommentLocation() {\n        var i, entry, comment, comments = [];\n\n        for (i = 0; i < extra.comments.length; ++i) {\n            entry = extra.comments[i];\n            comment = {\n                type: entry.type,\n                value: entry.value\n            };\n            if (extra.range) {\n                comment.range = entry.range;\n            }\n            if (extra.loc) {\n                comment.loc = entry.loc;\n            }\n            comments.push(comment);\n        }\n\n        extra.comments = comments;\n    }\n\n    function collectToken() {\n        var start, loc, token, range, value;\n\n        skipComment();\n        start = index;\n        loc = {\n            start: {\n                line: lineNumber,\n                column: index - lineStart\n            }\n        };\n\n        token = extra.advance();\n        loc.end = {\n            line: lineNumber,\n            column: index - lineStart\n        };\n\n        if (token.type !== Token.EOF) {\n            range = [token.range[0], token.range[1]];\n            value = sliceSource(token.range[0], token.range[1]);\n            extra.tokens.push({\n                type: TokenName[token.type],\n                value: value,\n                range: range,\n                loc: loc\n            });\n        }\n\n        return token;\n    }\n\n    function collectRegex() {\n        var pos, loc, regex, token;\n\n        skipComment();\n\n        pos = index;\n        loc = {\n            start: {\n                line: lineNumber,\n                column: index - lineStart\n            }\n        };\n\n        regex = extra.scanRegExp();\n        loc.end = {\n            line: lineNumber,\n            column: index - lineStart\n        };\n\n        // Pop the previous token, which is likely '/' or '/='\n        if (extra.tokens.length > 0) {\n            token = extra.tokens[extra.tokens.length - 1];\n            if (token.range[0] === pos && token.type === 'Punctuator') {\n                if (token.value === '/' || token.value === '/=') {\n                    extra.tokens.pop();\n                }\n            }\n        }\n\n        extra.tokens.push({\n            type: 'RegularExpression',\n            value: regex.literal,\n            range: [pos, index],\n            loc: loc\n        });\n\n        return regex;\n    }\n\n    function filterTokenLocation() {\n        var i, entry, token, tokens = [];\n\n        for (i = 0; i < extra.tokens.length; ++i) {\n            entry = extra.tokens[i];\n            token = {\n                type: entry.type,\n                value: entry.value\n            };\n            if (extra.range) {\n                token.range = entry.range;\n            }\n            if (extra.loc) {\n                token.loc = entry.loc;\n            }\n            tokens.push(token);\n        }\n\n        extra.tokens = tokens;\n    }\n\n    function createLiteral(token) {\n        return {\n            type: Syntax.Literal,\n            value: token.value\n        };\n    }\n\n    function createRawLiteral(token) {\n        return {\n            type: Syntax.Literal,\n            value: token.value,\n            raw: sliceSource(token.range[0], token.range[1])\n        };\n    }\n\n    function createLocationMarker() {\n        var marker = {};\n\n        marker.range = [index, index];\n        marker.loc = {\n            start: {\n                line: lineNumber,\n                column: index - lineStart\n            },\n            end: {\n                line: lineNumber,\n                column: index - lineStart\n            }\n        };\n\n        marker.end = function () {\n            this.range[1] = index;\n            this.loc.end.line = lineNumber;\n            this.loc.end.column = index - lineStart;\n        };\n\n        marker.applyGroup = function (node) {\n            if (extra.range) {\n                node.groupRange = [this.range[0], this.range[1]];\n            }\n            if (extra.loc) {\n                node.groupLoc = {\n                    start: {\n                        line: this.loc.start.line,\n                        column: this.loc.start.column\n                    },\n                    end: {\n                        line: this.loc.end.line,\n                        column: this.loc.end.column\n                    }\n                };\n            }\n        };\n\n        marker.apply = function (node) {\n            if (extra.range) {\n                node.range = [this.range[0], this.range[1]];\n            }\n            if (extra.loc) {\n                node.loc = {\n                    start: {\n                        line: this.loc.start.line,\n                        column: this.loc.start.column\n                    },\n                    end: {\n                        line: this.loc.end.line,\n                        column: this.loc.end.column\n                    }\n                };\n            }\n        };\n\n        return marker;\n    }\n\n    function trackGroupExpression() {\n        var marker, expr;\n\n        skipComment();\n        marker = createLocationMarker();\n        expect('(');\n\n        expr = parseExpression();\n\n        expect(')');\n\n        marker.end();\n        marker.applyGroup(expr);\n\n        return expr;\n    }\n\n    function trackLeftHandSideExpression() {\n        var marker, expr;\n\n        skipComment();\n        marker = createLocationMarker();\n\n        expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression();\n\n        while (match('.') || match('[')) {\n            if (match('[')) {\n                expr = {\n                    type: Syntax.MemberExpression,\n                    computed: true,\n                    object: expr,\n                    property: parseComputedMember()\n                };\n                marker.end();\n                marker.apply(expr);\n            } else {\n                expr = {\n                    type: Syntax.MemberExpression,\n                    computed: false,\n                    object: expr,\n                    property: parseNonComputedMember()\n                };\n                marker.end();\n                marker.apply(expr);\n            }\n        }\n\n        return expr;\n    }\n\n    function trackLeftHandSideExpressionAllowCall() {\n        var marker, expr;\n\n        skipComment();\n        marker = createLocationMarker();\n\n        expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression();\n\n        while (match('.') || match('[') || match('(')) {\n            if (match('(')) {\n                expr = {\n                    type: Syntax.CallExpression,\n                    callee: expr,\n                    'arguments': parseArguments()\n                };\n                marker.end();\n                marker.apply(expr);\n            } else if (match('[')) {\n                expr = {\n                    type: Syntax.MemberExpression,\n                    computed: true,\n                    object: expr,\n                    property: parseComputedMember()\n                };\n                marker.end();\n                marker.apply(expr);\n            } else {\n                expr = {\n                    type: Syntax.MemberExpression,\n                    computed: false,\n                    object: expr,\n                    property: parseNonComputedMember()\n                };\n                marker.end();\n                marker.apply(expr);\n            }\n        }\n\n        return expr;\n    }\n\n    function filterGroup(node) {\n        var n, i, entry;\n\n        n = (Object.prototype.toString.apply(node) === '[object Array]') ? [] : {};\n        for (i in node) {\n            if (node.hasOwnProperty(i) && i !== 'groupRange' && i !== 'groupLoc') {\n                entry = node[i];\n                if (entry === null || typeof entry !== 'object' || entry instanceof RegExp) {\n                    n[i] = entry;\n                } else {\n                    n[i] = filterGroup(entry);\n                }\n            }\n        }\n        return n;\n    }\n\n    function wrapTrackingFunction(range, loc) {\n\n        return function (parseFunction) {\n\n            function isBinary(node) {\n                return node.type === Syntax.LogicalExpression ||\n                    node.type === Syntax.BinaryExpression;\n            }\n\n            function visit(node) {\n                var start, end;\n\n                if (isBinary(node.left)) {\n                    visit(node.left);\n                }\n                if (isBinary(node.right)) {\n                    visit(node.right);\n                }\n\n                if (range) {\n                    if (node.left.groupRange || node.right.groupRange) {\n                        start = node.left.groupRange ? node.left.groupRange[0] : node.left.range[0];\n                        end = node.right.groupRange ? node.right.groupRange[1] : node.right.range[1];\n                        node.range = [start, end];\n                    } else if (typeof node.range === 'undefined') {\n                        start = node.left.range[0];\n                        end = node.right.range[1];\n                        node.range = [start, end];\n                    }\n                }\n                if (loc) {\n                    if (node.left.groupLoc || node.right.groupLoc) {\n                        start = node.left.groupLoc ? node.left.groupLoc.start : node.left.loc.start;\n                        end = node.right.groupLoc ? node.right.groupLoc.end : node.right.loc.end;\n                        node.loc = {\n                            start: start,\n                            end: end\n                        };\n                    } else if (typeof node.loc === 'undefined') {\n                        node.loc = {\n                            start: node.left.loc.start,\n                            end: node.right.loc.end\n                        };\n                    }\n                }\n            }\n\n            return function () {\n                var marker, node;\n\n                skipComment();\n\n                marker = createLocationMarker();\n                node = parseFunction.apply(null, arguments);\n                marker.end();\n\n                if (range && typeof node.range === 'undefined') {\n                    marker.apply(node);\n                }\n\n                if (loc && typeof node.loc === 'undefined') {\n                    marker.apply(node);\n                }\n\n                if (isBinary(node)) {\n                    visit(node);\n                }\n\n                return node;\n            };\n        };\n    }\n\n    function patch() {\n\n        var wrapTracking;\n\n        if (extra.comments) {\n            extra.skipComment = skipComment;\n            skipComment = scanComment;\n        }\n\n        if (extra.raw) {\n            extra.createLiteral = createLiteral;\n            createLiteral = createRawLiteral;\n        }\n\n        if (extra.range || extra.loc) {\n\n            extra.parseGroupExpression = parseGroupExpression;\n            extra.parseLeftHandSideExpression = parseLeftHandSideExpression;\n            extra.parseLeftHandSideExpressionAllowCall = parseLeftHandSideExpressionAllowCall;\n            parseGroupExpression = trackGroupExpression;\n            parseLeftHandSideExpression = trackLeftHandSideExpression;\n            parseLeftHandSideExpressionAllowCall = trackLeftHandSideExpressionAllowCall;\n\n            wrapTracking = wrapTrackingFunction(extra.range, extra.loc);\n\n            extra.parseAdditiveExpression = parseAdditiveExpression;\n            extra.parseAssignmentExpression = parseAssignmentExpression;\n            extra.parseBitwiseANDExpression = parseBitwiseANDExpression;\n            extra.parseBitwiseORExpression = parseBitwiseORExpression;\n            extra.parseBitwiseXORExpression = parseBitwiseXORExpression;\n            extra.parseBlock = parseBlock;\n            extra.parseFunctionSourceElements = parseFunctionSourceElements;\n            extra.parseCatchClause = parseCatchClause;\n            extra.parseComputedMember = parseComputedMember;\n            extra.parseConditionalExpression = parseConditionalExpression;\n            extra.parseConstLetDeclaration = parseConstLetDeclaration;\n            extra.parseEqualityExpression = parseEqualityExpression;\n            extra.parseExpression = parseExpression;\n            extra.parseForVariableDeclaration = parseForVariableDeclaration;\n            extra.parseFunctionDeclaration = parseFunctionDeclaration;\n            extra.parseFunctionExpression = parseFunctionExpression;\n            extra.parseLogicalANDExpression = parseLogicalANDExpression;\n            extra.parseLogicalORExpression = parseLogicalORExpression;\n            extra.parseMultiplicativeExpression = parseMultiplicativeExpression;\n            extra.parseNewExpression = parseNewExpression;\n            extra.parseNonComputedProperty = parseNonComputedProperty;\n            extra.parseObjectProperty = parseObjectProperty;\n            extra.parseObjectPropertyKey = parseObjectPropertyKey;\n            extra.parsePostfixExpression = parsePostfixExpression;\n            extra.parsePrimaryExpression = parsePrimaryExpression;\n            extra.parseProgram = parseProgram;\n            extra.parsePropertyFunction = parsePropertyFunction;\n            extra.parseRelationalExpression = parseRelationalExpression;\n            extra.parseStatement = parseStatement;\n            extra.parseShiftExpression = parseShiftExpression;\n            extra.parseSwitchCase = parseSwitchCase;\n            extra.parseUnaryExpression = parseUnaryExpression;\n            extra.parseVariableDeclaration = parseVariableDeclaration;\n            extra.parseVariableIdentifier = parseVariableIdentifier;\n\n            parseAdditiveExpression = wrapTracking(extra.parseAdditiveExpression);\n            parseAssignmentExpression = wrapTracking(extra.parseAssignmentExpression);\n            parseBitwiseANDExpression = wrapTracking(extra.parseBitwiseANDExpression);\n            parseBitwiseORExpression = wrapTracking(extra.parseBitwiseORExpression);\n            parseBitwiseXORExpression = wrapTracking(extra.parseBitwiseXORExpression);\n            parseBlock = wrapTracking(extra.parseBlock);\n            parseFunctionSourceElements = wrapTracking(extra.parseFunctionSourceElements);\n            parseCatchClause = wrapTracking(extra.parseCatchClause);\n            parseComputedMember = wrapTracking(extra.parseComputedMember);\n            parseConditionalExpression = wrapTracking(extra.parseConditionalExpression);\n            parseConstLetDeclaration = wrapTracking(extra.parseConstLetDeclaration);\n            parseEqualityExpression = wrapTracking(extra.parseEqualityExpression);\n            parseExpression = wrapTracking(extra.parseExpression);\n            parseForVariableDeclaration = wrapTracking(extra.parseForVariableDeclaration);\n            parseFunctionDeclaration = wrapTracking(extra.parseFunctionDeclaration);\n            parseFunctionExpression = wrapTracking(extra.parseFunctionExpression);\n            parseLeftHandSideExpression = wrapTracking(parseLeftHandSideExpression);\n            parseLogicalANDExpression = wrapTracking(extra.parseLogicalANDExpression);\n            parseLogicalORExpression = wrapTracking(extra.parseLogicalORExpression);\n            parseMultiplicativeExpression = wrapTracking(extra.parseMultiplicativeExpression);\n            parseNewExpression = wrapTracking(extra.parseNewExpression);\n            parseNonComputedProperty = wrapTracking(extra.parseNonComputedProperty);\n            parseObjectProperty = wrapTracking(extra.parseObjectProperty);\n            parseObjectPropertyKey = wrapTracking(extra.parseObjectPropertyKey);\n            parsePostfixExpression = wrapTracking(extra.parsePostfixExpression);\n            parsePrimaryExpression = wrapTracking(extra.parsePrimaryExpression);\n            parseProgram = wrapTracking(extra.parseProgram);\n            parsePropertyFunction = wrapTracking(extra.parsePropertyFunction);\n            parseRelationalExpression = wrapTracking(extra.parseRelationalExpression);\n            parseStatement = wrapTracking(extra.parseStatement);\n            parseShiftExpression = wrapTracking(extra.parseShiftExpression);\n            parseSwitchCase = wrapTracking(extra.parseSwitchCase);\n            parseUnaryExpression = wrapTracking(extra.parseUnaryExpression);\n            parseVariableDeclaration = wrapTracking(extra.parseVariableDeclaration);\n            parseVariableIdentifier = wrapTracking(extra.parseVariableIdentifier);\n        }\n\n        if (typeof extra.tokens !== 'undefined') {\n            extra.advance = advance;\n            extra.scanRegExp = scanRegExp;\n\n            advance = collectToken;\n            scanRegExp = collectRegex;\n        }\n    }\n\n    function unpatch() {\n        if (typeof extra.skipComment === 'function') {\n            skipComment = extra.skipComment;\n        }\n\n        if (extra.raw) {\n            createLiteral = extra.createLiteral;\n        }\n\n        if (extra.range || extra.loc) {\n            parseAdditiveExpression = extra.parseAdditiveExpression;\n            parseAssignmentExpression = extra.parseAssignmentExpression;\n            parseBitwiseANDExpression = extra.parseBitwiseANDExpression;\n            parseBitwiseORExpression = extra.parseBitwiseORExpression;\n            parseBitwiseXORExpression = extra.parseBitwiseXORExpression;\n            parseBlock = extra.parseBlock;\n            parseFunctionSourceElements = extra.parseFunctionSourceElements;\n            parseCatchClause = extra.parseCatchClause;\n            parseComputedMember = extra.parseComputedMember;\n            parseConditionalExpression = extra.parseConditionalExpression;\n            parseConstLetDeclaration = extra.parseConstLetDeclaration;\n            parseEqualityExpression = extra.parseEqualityExpression;\n            parseExpression = extra.parseExpression;\n            parseForVariableDeclaration = extra.parseForVariableDeclaration;\n            parseFunctionDeclaration = extra.parseFunctionDeclaration;\n            parseFunctionExpression = extra.parseFunctionExpression;\n            parseGroupExpression = extra.parseGroupExpression;\n            parseLeftHandSideExpression = extra.parseLeftHandSideExpression;\n            parseLeftHandSideExpressionAllowCall = extra.parseLeftHandSideExpressionAllowCall;\n            parseLogicalANDExpression = extra.parseLogicalANDExpression;\n            parseLogicalORExpression = extra.parseLogicalORExpression;\n            parseMultiplicativeExpression = extra.parseMultiplicativeExpression;\n            parseNewExpression = extra.parseNewExpression;\n            parseNonComputedProperty = extra.parseNonComputedProperty;\n            parseObjectProperty = extra.parseObjectProperty;\n            parseObjectPropertyKey = extra.parseObjectPropertyKey;\n            parsePrimaryExpression = extra.parsePrimaryExpression;\n            parsePostfixExpression = extra.parsePostfixExpression;\n            parseProgram = extra.parseProgram;\n            parsePropertyFunction = extra.parsePropertyFunction;\n            parseRelationalExpression = extra.parseRelationalExpression;\n            parseStatement = extra.parseStatement;\n            parseShiftExpression = extra.parseShiftExpression;\n            parseSwitchCase = extra.parseSwitchCase;\n            parseUnaryExpression = extra.parseUnaryExpression;\n            parseVariableDeclaration = extra.parseVariableDeclaration;\n            parseVariableIdentifier = extra.parseVariableIdentifier;\n        }\n\n        if (typeof extra.scanRegExp === 'function') {\n            advance = extra.advance;\n            scanRegExp = extra.scanRegExp;\n        }\n    }\n\n    function stringToArray(str) {\n        var length = str.length,\n            result = [],\n            i;\n        for (i = 0; i < length; ++i) {\n            result[i] = str.charAt(i);\n        }\n        return result;\n    }\n\n    function parse(code, options) {\n        var program, toString;\n\n        toString = String;\n        if (typeof code !== 'string' && !(code instanceof String)) {\n            code = toString(code);\n        }\n\n        source = code;\n        index = 0;\n        lineNumber = (source.length > 0) ? 1 : 0;\n        lineStart = 0;\n        length = source.length;\n        buffer = null;\n        state = {\n            allowIn: true,\n            labelSet: {},\n            inFunctionBody: false,\n            inIteration: false,\n            inSwitch: false\n        };\n\n        extra = {};\n        if (typeof options !== 'undefined') {\n            extra.range = (typeof options.range === 'boolean') && options.range;\n            extra.loc = (typeof options.loc === 'boolean') && options.loc;\n            extra.raw = (typeof options.raw === 'boolean') && options.raw;\n            if (typeof options.tokens === 'boolean' && options.tokens) {\n                extra.tokens = [];\n            }\n            if (typeof options.comment === 'boolean' && options.comment) {\n                extra.comments = [];\n            }\n            if (typeof options.tolerant === 'boolean' && options.tolerant) {\n                extra.errors = [];\n            }\n        }\n\n        if (length > 0) {\n            if (typeof source[0] === 'undefined') {\n                // Try first to convert to a string. This is good as fast path\n                // for old IE which understands string indexing for string\n                // literals only and not for string object.\n                if (code instanceof String) {\n                    source = code.valueOf();\n                }\n\n                // Force accessing the characters via an array.\n                if (typeof source[0] === 'undefined') {\n                    source = stringToArray(code);\n                }\n            }\n        }\n\n        patch();\n        try {\n            program = parseProgram();\n            if (typeof extra.comments !== 'undefined') {\n                filterCommentLocation();\n                program.comments = extra.comments;\n            }\n            if (typeof extra.tokens !== 'undefined') {\n                filterTokenLocation();\n                program.tokens = extra.tokens;\n            }\n            if (typeof extra.errors !== 'undefined') {\n                program.errors = extra.errors;\n            }\n            if (extra.range || extra.loc) {\n                program.body = filterGroup(program.body);\n            }\n        } catch (e) {\n            throw e;\n        } finally {\n            unpatch();\n            extra = {};\n        }\n\n        return program;\n    }\n\n    // Sync with package.json.\n    exports.version = '1.0.4';\n\n    exports.parse = parse;\n\n    // Deep copy.\n    exports.Syntax = (function () {\n        var name, types = {};\n\n        if (typeof Object.create === 'function') {\n            types = Object.create(null);\n        }\n\n        for (name in Syntax) {\n            if (Syntax.hasOwnProperty(name)) {\n                types[name] = Syntax[name];\n            }\n        }\n\n        if (typeof Object.freeze === 'function') {\n            Object.freeze(types);\n        }\n\n        return types;\n    }());\n\n}));\n/* vim: set sw=4 ts=4 et tw=80 : */\n\n})()","\"use strict\"\n\nfunction unique_pred(list, compare) {\n  var ptr = 1\n    , len = list.length\n    , a=list[0], b=list[0]\n  for(var i=1; i<len; ++i) {\n    b = a\n    a = list[i]\n    if(compare(a, b)) {\n      if(i === ptr) {\n        ptr++\n        continue\n      }\n      list[ptr++] = a\n    }\n  }\n  list.length = ptr\n  return list\n}\n\nfunction unique_eq(list) {\n  var ptr = 1\n    , len = list.length\n    , a=list[0], b = list[0]\n  for(var i=1; i<len; ++i, b=a) {\n    b = a\n    a = list[i]\n    if(a !== b) {\n      if(i === ptr) {\n        ptr++\n        continue\n      }\n      list[ptr++] = a\n    }\n  }\n  list.length = ptr\n  return list\n}\n\nfunction unique(list, compare, sorted) {\n  if(list.length === 0) {\n    return []\n  }\n  if(compare) {\n    if(!sorted) {\n      list.sort(compare)\n    }\n    return unique_pred(list, compare)\n  }\n  if(!sorted) {\n    list.sort()\n  }\n  return unique_eq(list)\n}\n\nmodule.exports = unique","\"use strict\"\n\nvar compile = require(\"./compile.js\")\n\nfunction createThunk(proc) {\n  var code = [\"'use strict'\", \"var CACHED={}\"]\n  var vars = []\n  var thunkName = proc.funcName + \"_cwise_thunk\"\n  \n  //Build thunk\n  code.push([\"return function \", thunkName, \"(\", proc.shimArgs.join(\",\"), \"){\"].join(\"\"))\n  var typesig = []\n  var string_typesig = []\n  var proc_args = [[\"array\",proc.arrayArgs[0],\".shape\"].join(\"\")]\n  for(var i=0; i<proc.arrayArgs.length; ++i) {\n    var j = proc.arrayArgs[i]\n    vars.push([\"t\", j, \"=array\", j, \".dtype,\",\n               \"r\", j, \"=array\", j, \".order\"].join(\"\"))\n    typesig.push(\"t\" + j)\n    typesig.push(\"r\" + j)\n    string_typesig.push(\"t\"+j)\n    string_typesig.push(\"r\"+j+\".join()\")\n    proc_args.push(\"array\" + j + \".data\")\n    proc_args.push(\"array\" + j + \".stride\")\n    proc_args.push(\"array\" + j + \".offset|0\")\n  }\n  for(var i=0; i<proc.scalarArgs.length; ++i) {\n    proc_args.push(\"scalar\" + proc.scalarArgs[i])\n  }\n  vars.push([\"type=[\", string_typesig.join(\",\"), \"].join()\"].join(\"\"))\n  vars.push(\"proc=CACHED[type]\")\n  code.push(\"var \" + vars.join(\",\"))\n  \n  code.push([\"if(!proc){\",\n             \"CACHED[type]=proc=compile([\", typesig.join(\",\"), \"])}\",\n             \"return proc(\", proc_args.join(\",\"), \")}\"].join(\"\"))\n\n  if(proc.debug) {\n    console.log(\"Generated thunk:\", code.join(\"\\n\"))\n  }\n  \n  //Compile thunk\n  var thunk = new Function(\"compile\", code.join(\"\\n\"))\n  return thunk(compile.bind(undefined, proc))\n}\n\nmodule.exports = createThunk\n","\"use strict\"\n\nvar uniq = require(\"uniq\")\n\nfunction innerFill(order, proc, body) {\n  var dimension = order.length\n    , nargs = proc.arrayArgs.length\n    , has_index = proc.indexArgs.length>0\n    , code = []\n    , vars = []\n    , idx=0, pidx=0, i, j\n  for(i=0; i<dimension; ++i) {\n    vars.push([\"i\",i,\"=0\"].join(\"\"))\n  }\n  //Compute scan deltas\n  for(j=0; j<nargs; ++j) {\n    for(i=0; i<dimension; ++i) {\n      pidx = idx\n      idx = order[i]\n      if(i === 0) {\n        vars.push([\"d\",j,\"s\",i,\"=t\",j,\"[\",idx,\"]\"].join(\"\"))\n      } else {\n        vars.push([\"d\",j,\"s\",i,\"=(t\",j,\"[\",idx,\"]-s\",pidx,\"*t\",j,\"[\",pidx,\"])\"].join(\"\"))\n      }\n    }\n  }\n  code.push(\"var \" + vars.join(\",\"))\n  //Scan loop\n  for(i=dimension-1; i>=0; --i) {\n    idx = order[i]\n    code.push([\"for(i\",i,\"=0;i\",i,\"<s\",idx,\";++i\",i,\"){\"].join(\"\"))\n  }\n  //Push body of inner loop\n  code.push(body)\n  //Advance scan pointers\n  for(i=0; i<dimension; ++i) {\n    pidx = idx\n    idx = order[i]\n    for(j=0; j<nargs; ++j) {\n      code.push([\"p\",j,\"+=d\",j,\"s\",i].join(\"\"))\n    }\n    if(has_index) {\n      if(i > 0) {\n        code.push([\"index[\",pidx,\"]-=s\",pidx].join(\"\"))\n      }\n      code.push([\"++index[\",idx,\"]\"].join(\"\"))\n    }\n    code.push(\"}\")\n  }\n  return code.join(\"\\n\")\n}\n\nfunction outerFill(matched, order, proc, body) {\n  var dimension = order.length\n    , nargs = proc.arrayArgs.length\n    , blockSize = proc.blockSize\n    , has_index = proc.indexArgs.length > 0\n    , code = []\n  for(var i=0; i<nargs; ++i) {\n    code.push([\"var offset\",i,\"=p\",i].join(\"\"))\n  }\n  //Generate matched loops\n  for(var i=matched; i<dimension; ++i) {\n    code.push([\"for(var j\"+i+\"=SS[\", order[i], \"]|0;j\", i, \">0;){\"].join(\"\"))\n    code.push([\"if(j\",i,\"<\",blockSize,\"){\"].join(\"\"))\n    code.push([\"s\",order[i],\"=j\",i].join(\"\"))\n    code.push([\"j\",i,\"=0\"].join(\"\"))\n    code.push([\"}else{s\",order[i],\"=\",blockSize].join(\"\"))\n    code.push([\"j\",i,\"-=\",blockSize,\"}\"].join(\"\"))\n    if(has_index) {\n      code.push([\"index[\",order[i],\"]=j\",i].join(\"\"))\n    }\n  }\n  for(var i=0; i<nargs; ++i) {\n    var indexStr = [\"offset\"+i]\n    for(var j=matched; j<dimension; ++j) {\n      indexStr.push([\"j\",j,\"*t\",i,\"[\",order[j],\"]\"].join(\"\"))\n    }\n    code.push([\"p\",i,\"=(\",indexStr.join(\"+\"),\")\"].join(\"\"))\n  }\n  code.push(innerFill(order, proc, body))\n  for(var i=matched; i<dimension; ++i) {\n    code.push(\"}\")\n  }\n  return code.join(\"\\n\")\n}\n\n//Count the number of compatible inner orders\nfunction countMatches(orders) {\n  var matched = 0, dimension = orders[0].length\n  while(matched < dimension) {\n    for(var j=1; j<orders.length; ++j) {\n      if(orders[j][matched] !== orders[0][matched]) {\n        return matched\n      }\n    }\n    ++matched\n  }\n  return matched\n}\n\n//Processes a block according to the given data types\nfunction processBlock(block, proc, dtypes) {\n  var code = block.body\n  var pre = []\n  var post = []\n  for(var i=0; i<block.args.length; ++i) {\n    var carg = block.args[i]\n    if(carg.count <= 0) {\n      continue\n    }\n    var re = new RegExp(carg.name, \"g\")\n    switch(proc.argTypes[i]) {\n      case \"array\":\n        var arrNum = proc.arrayArgs.indexOf(i)\n        if(carg.count === 1) {\n          if(dtypes[arrNum] === \"generic\") {\n            if(carg.lvalue) {\n              pre.push([\"var l\", arrNum, \"=a\", arrNum, \".get(p\", arrNum, \")\"].join(\"\"))\n              code = code.replace(re, \"l\"+arrNum)\n              post.push([\"a\", arrNum, \".set(p\", arrNum, \",l\",arrNum,\")\"].join(\"\"))\n            } else {\n              code = code.replace(re, [\"a\", arrNum, \".get(p\", arrNum, \")\"].join(\"\"))\n            }\n          } else {\n            code = code.replace(re, [\"a\", arrNum, \"[p\", arrNum, \"]\"].join(\"\"))\n          }\n        } else if(dtypes[arrNum] === \"generic\") {\n          pre.push([\"var l\", arrNum, \"=a\", arrNum, \".get(p\", arrNum, \")\"].join(\"\"))\n          code = code.replace(re, \"l\"+arrNum)\n          if(carg.lvalue) {\n            post.push([\"a\", arrNum, \".set(p\", arrNum, \",l\",arrNum,\")\"].join(\"\"))\n          }\n        } else {\n          pre.push([\"var l\", arrNum, \"=a\", arrNum, \"[p\", arrNum, \"]\"].join(\"\"))\n          code = code.replace(re, \"l\"+arrNum)\n          if(carg.lvalue) {\n            post.push([\"a\", arrNum, \"[p\", arrNum, \"]=l\",arrNum].join(\"\"))\n          }\n        }\n      break\n      case \"scalar\":\n        code = code.replace(re, \"Y\" + proc.scalarArgs.indexOf(i))\n      break\n      case \"index\":\n        code = code.replace(re, \"index\")\n      break\n      case \"shape\":\n        code = code.replace(re, \"shape\")\n      break\n    }\n  }\n  return [pre.join(\"\\n\"), code, post.join(\"\\n\")].join(\"\\n\").trim()\n}\n\nfunction typeSummary(dtypes) {\n  var summary = new Array(dtypes.length)\n  var allEqual = true\n  for(var i=0; i<dtypes.length; ++i) {\n    var t = dtypes[i]\n    var digits = t.match(/\\d+/)\n    if(!digits) {\n      digits = \"\"\n    } else {\n      digits = digits[0]\n    }\n    if(t.charAt(0) === 0) {\n      summary[i] = \"u\" + t.charAt(1) + digits\n    } else {\n      summary[i] = t.charAt(0) + digits\n    }\n    if(i > 0) {\n      allEqual = allEqual && summary[i] === summary[i-1]\n    }\n  }\n  if(allEqual) {\n    return summary[0]\n  }\n  return summary.join(\"\")\n}\n\n//Generates a cwise operator\nfunction generateCWiseOp(proc, typesig) {\n\n  //Compute dimension\n  var dimension = typesig[1].length|0\n  var orders = new Array(proc.arrayArgs.length)\n  var dtypes = new Array(proc.arrayArgs.length)\n\n  //First create arguments for procedure\n  var arglist = [\"SS\"]\n  var code = [\"'use strict'\"]\n  var vars = []\n  \n  for(var j=0; j<dimension; ++j) {\n    vars.push([\"s\", j, \"=SS[\", j, \"]\"].join(\"\"))\n  }\n  for(var i=0; i<proc.arrayArgs.length; ++i) {\n    arglist.push(\"a\"+i)\n    arglist.push(\"t\"+i)\n    arglist.push(\"p\"+i)\n    dtypes[i] = typesig[2*i]\n    orders[i] = typesig[2*i+1]\n  }\n  for(var i=0; i<proc.scalarArgs.length; ++i) {\n    arglist.push(\"Y\" + i)\n  }\n  if(proc.shapeArgs.length > 0) {\n    vars.push(\"shape=SS.slice(0)\")\n  }\n  if(proc.indexArgs.length > 0) {\n    var zeros = new Array(dimension)\n    for(var i=0; i<dimension; ++i) {\n      zeros[i] = \"0\"\n    }\n    vars.push([\"index=[\", zeros.join(\",\"), \"]\"].join(\"\"))\n  }\n\n  //Prepare this variables\n  var thisVars = uniq([].concat(proc.pre.thisVars)\n                      .concat(proc.body.thisVars)\n                      .concat(proc.post.thisVars))\n  vars = vars.concat(thisVars)\n  code.push(\"var \" + vars.join(\",\"))\n  for(var i=0; i<proc.arrayArgs.length; ++i) {\n    code.push(\"p\"+i+\"|=0\")\n  }\n  \n  //Inline prelude\n  if(proc.pre.body.length > 3) {\n    code.push(processBlock(proc.pre, proc, dtypes))\n  }\n\n  //Process body\n  var body = processBlock(proc.body, proc, dtypes)\n  var matched = countMatches(orders)\n  if(matched < dimension) {\n    code.push(outerFill(matched, orders[0], proc, body))\n  } else {\n    code.push(innerFill(orders[0], proc, body))\n  }\n\n  //Inline epilog\n  if(proc.post.body.length > 3) {\n    code.push(processBlock(proc.post, proc, dtypes))\n  }\n  \n  if(proc.debug) {\n    console.log(\"Generated cwise routine for \", typesig, \":\\n\\n\", code.join(\"\\n\"))\n  }\n  \n  var loopName = [(proc.funcName||\"unnamed\"), \"_cwise_loop_\", orders[0].join(\"s\"),\"m\",matched,typeSummary(dtypes)].join(\"\")\n  var f = new Function([\"function \",loopName,\"(\", arglist.join(\",\"),\"){\", code.join(\"\\n\"),\"} return \", loopName].join(\"\"))\n  return f()\n}\nmodule.exports = generateCWiseOp","\"use strict\"\n\nvar uniq = require(\"uniq\")\n\nfunction innerFill(order, proc, body) {\n  var dimension = order.length\n    , nargs = proc.arrayArgs.length\n    , has_index = proc.indexArgs.length>0\n    , code = []\n    , vars = []\n    , idx=0, pidx=0, i, j\n  for(i=0; i<dimension; ++i) {\n    vars.push([\"i\",i,\"=0\"].join(\"\"))\n  }\n  //Compute scan deltas\n  for(j=0; j<nargs; ++j) {\n    for(i=0; i<dimension; ++i) {\n      pidx = idx\n      idx = order[i]\n      if(i === 0) {\n        vars.push([\"d\",j,\"s\",i,\"=t\",j,\"[\",idx,\"]\"].join(\"\"))\n      } else {\n        vars.push([\"d\",j,\"s\",i,\"=(t\",j,\"[\",idx,\"]-s\",pidx,\"*t\",j,\"[\",pidx,\"])\"].join(\"\"))\n      }\n    }\n  }\n  code.push(\"var \" + vars.join(\",\"))\n  //Scan loop\n  for(i=dimension-1; i>=0; --i) {\n    idx = order[i]\n    code.push([\"for(i\",i,\"=0;i\",i,\"<s\",idx,\";++i\",i,\"){\"].join(\"\"))\n  }\n  //Push body of inner loop\n  code.push(body)\n  //Advance scan pointers\n  for(i=0; i<dimension; ++i) {\n    pidx = idx\n    idx = order[i]\n    for(j=0; j<nargs; ++j) {\n      code.push([\"p\",j,\"+=d\",j,\"s\",i].join(\"\"))\n    }\n    if(has_index) {\n      if(i > 0) {\n        code.push([\"index[\",pidx,\"]-=s\",pidx].join(\"\"))\n      }\n      code.push([\"++index[\",idx,\"]\"].join(\"\"))\n    }\n    code.push(\"}\")\n  }\n  return code.join(\"\\n\")\n}\n\nfunction outerFill(matched, order, proc, body) {\n  var dimension = order.length\n    , nargs = proc.arrayArgs.length\n    , blockSize = proc.blockSize\n    , has_index = proc.indexArgs.length > 0\n    , code = []\n  for(var i=0; i<nargs; ++i) {\n    code.push([\"var offset\",i,\"=p\",i].join(\"\"))\n  }\n  //Generate matched loops\n  for(var i=matched; i<dimension; ++i) {\n    code.push([\"for(var j\"+i+\"=SS[\", order[i], \"]|0;j\", i, \">0;){\"].join(\"\"))\n    code.push([\"if(j\",i,\"<\",blockSize,\"){\"].join(\"\"))\n    code.push([\"s\",order[i],\"=j\",i].join(\"\"))\n    code.push([\"j\",i,\"=0\"].join(\"\"))\n    code.push([\"}else{s\",order[i],\"=\",blockSize].join(\"\"))\n    code.push([\"j\",i,\"-=\",blockSize,\"}\"].join(\"\"))\n    if(has_index) {\n      code.push([\"index[\",order[i],\"]=j\",i].join(\"\"))\n    }\n  }\n  for(var i=0; i<nargs; ++i) {\n    var indexStr = [\"offset\"+i]\n    for(var j=matched; j<dimension; ++j) {\n      indexStr.push([\"j\",j,\"*t\",i,\"[\",order[j],\"]\"].join(\"\"))\n    }\n    code.push([\"p\",i,\"=(\",indexStr.join(\"+\"),\")\"].join(\"\"))\n  }\n  code.push(innerFill(order, proc, body))\n  for(var i=matched; i<dimension; ++i) {\n    code.push(\"}\")\n  }\n  return code.join(\"\\n\")\n}\n\n//Count the number of compatible inner orders\nfunction countMatches(orders) {\n  var matched = 0, dimension = orders[0].length\n  while(matched < dimension) {\n    for(var j=1; j<orders.length; ++j) {\n      if(orders[j][matched] !== orders[0][matched]) {\n        return matched\n      }\n    }\n    ++matched\n  }\n  return matched\n}\n\n//Processes a block according to the given data types\nfunction processBlock(block, proc, dtypes) {\n  var code = block.body\n  var pre = []\n  var post = []\n  for(var i=0; i<block.args.length; ++i) {\n    var carg = block.args[i]\n    if(carg.count <= 0) {\n      continue\n    }\n    var re = new RegExp(carg.name, \"g\")\n    switch(proc.argTypes[i]) {\n      case \"array\":\n        var arrNum = proc.arrayArgs.indexOf(i)\n        if(carg.count === 1) {\n          if(dtypes[arrNum] === \"generic\") {\n            if(carg.lvalue) {\n              pre.push([\"var l\", arrNum, \"=a\", arrNum, \".get(p\", arrNum, \")\"].join(\"\"))\n              code = code.replace(re, \"l\"+arrNum)\n              post.push([\"a\", arrNum, \".set(p\", arrNum, \",l\",arrNum,\")\"].join(\"\"))\n            } else {\n              code = code.replace(re, [\"a\", arrNum, \".get(p\", arrNum, \")\"].join(\"\"))\n            }\n          } else {\n            code = code.replace(re, [\"a\", arrNum, \"[p\", arrNum, \"]\"].join(\"\"))\n          }\n        } else if(dtypes[arrNum] === \"generic\") {\n          pre.push([\"var l\", arrNum, \"=a\", arrNum, \".get(p\", arrNum, \")\"].join(\"\"))\n          code = code.replace(re, \"l\"+arrNum)\n          if(carg.lvalue) {\n            post.push([\"a\", arrNum, \".set(p\", arrNum, \",l\",arrNum,\")\"].join(\"\"))\n          }\n        } else {\n          pre.push([\"var l\", arrNum, \"=a\", arrNum, \"[p\", arrNum, \"]\"].join(\"\"))\n          code = code.replace(re, \"l\"+arrNum)\n          if(carg.lvalue) {\n            post.push([\"a\", arrNum, \"[p\", arrNum, \"]=l\",arrNum].join(\"\"))\n          }\n        }\n      break\n      case \"scalar\":\n        code = code.replace(re, \"Y\" + proc.scalarArgs.indexOf(i))\n      break\n      case \"index\":\n        code = code.replace(re, \"index\")\n      break\n      case \"shape\":\n        code = code.replace(re, \"shape\")\n      break\n    }\n  }\n  return [pre.join(\"\\n\"), code, post.join(\"\\n\")].join(\"\\n\").trim()\n}\n\nfunction typeSummary(dtypes) {\n  var summary = new Array(dtypes.length)\n  var allEqual = true\n  for(var i=0; i<dtypes.length; ++i) {\n    var t = dtypes[i]\n    var digits = t.match(/\\d+/)\n    if(!digits) {\n      digits = \"\"\n    } else {\n      digits = digits[0]\n    }\n    if(t.charAt(0) === 0) {\n      summary[i] = \"u\" + t.charAt(1) + digits\n    } else {\n      summary[i] = t.charAt(0) + digits\n    }\n    if(i > 0) {\n      allEqual = allEqual && summary[i] === summary[i-1]\n    }\n  }\n  if(allEqual) {\n    return summary[0]\n  }\n  return summary.join(\"\")\n}\n\n//Generates a cwise operator\nfunction generateCWiseOp(proc, typesig) {\n\n  //Compute dimension\n  var dimension = typesig[1].length|0\n  var orders = new Array(proc.arrayArgs.length)\n  var dtypes = new Array(proc.arrayArgs.length)\n\n  //First create arguments for procedure\n  var arglist = [\"SS\"]\n  var code = [\"'use strict'\"]\n  var vars = []\n  \n  for(var j=0; j<dimension; ++j) {\n    vars.push([\"s\", j, \"=SS[\", j, \"]\"].join(\"\"))\n  }\n  for(var i=0; i<proc.arrayArgs.length; ++i) {\n    arglist.push(\"a\"+i)\n    arglist.push(\"t\"+i)\n    arglist.push(\"p\"+i)\n    dtypes[i] = typesig[2*i]\n    orders[i] = typesig[2*i+1]\n  }\n  for(var i=0; i<proc.scalarArgs.length; ++i) {\n    arglist.push(\"Y\" + i)\n  }\n  if(proc.shapeArgs.length > 0) {\n    vars.push(\"shape=SS.slice(0)\")\n  }\n  if(proc.indexArgs.length > 0) {\n    var zeros = new Array(dimension)\n    for(var i=0; i<dimension; ++i) {\n      zeros[i] = \"0\"\n    }\n    vars.push([\"index=[\", zeros.join(\",\"), \"]\"].join(\"\"))\n  }\n\n  //Prepare this variables\n  var thisVars = uniq([].concat(proc.pre.thisVars)\n                      .concat(proc.body.thisVars)\n                      .concat(proc.post.thisVars))\n  vars = vars.concat(thisVars)\n  code.push(\"var \" + vars.join(\",\"))\n  for(var i=0; i<proc.arrayArgs.length; ++i) {\n    code.push(\"p\"+i+\"|=0\")\n  }\n  \n  //Inline prelude\n  if(proc.pre.body.length > 3) {\n    code.push(processBlock(proc.pre, proc, dtypes))\n  }\n\n  //Process body\n  var body = processBlock(proc.body, proc, dtypes)\n  var matched = countMatches(orders)\n  if(matched < dimension) {\n    code.push(outerFill(matched, orders[0], proc, body))\n  } else {\n    code.push(innerFill(orders[0], proc, body))\n  }\n\n  //Inline epilog\n  if(proc.post.body.length > 3) {\n    code.push(processBlock(proc.post, proc, dtypes))\n  }\n  \n  if(proc.debug) {\n    console.log(\"Generated cwise routine for \", typesig, \":\\n\\n\", code.join(\"\\n\"))\n  }\n  \n  var loopName = [(proc.funcName||\"unnamed\"), \"_cwise_loop_\", orders[0].join(\"s\"),\"m\",matched,typeSummary(dtypes)].join(\"\")\n  var f = new Function([\"function \",loopName,\"(\", arglist.join(\",\"),\"){\", code.join(\"\\n\"),\"} return \", loopName].join(\"\"))\n  return f()\n}\nmodule.exports = generateCWiseOp","\"use strict\"\n\nfunction unique_pred(list, compare) {\n  var ptr = 1\n    , len = list.length\n    , a=list[0], b=list[0]\n  for(var i=1; i<len; ++i) {\n    b = a\n    a = list[i]\n    if(compare(a, b)) {\n      if(i === ptr) {\n        ptr++\n        continue\n      }\n      list[ptr++] = a\n    }\n  }\n  list.length = ptr\n  return list\n}\n\nfunction unique_eq(list) {\n  var ptr = 1\n    , len = list.length\n    , a=list[0], b = list[0]\n  for(var i=1; i<len; ++i, b=a) {\n    b = a\n    a = list[i]\n    if(a !== b) {\n      if(i === ptr) {\n        ptr++\n        continue\n      }\n      list[ptr++] = a\n    }\n  }\n  list.length = ptr\n  return list\n}\n\nfunction unique(list, compare, sorted) {\n  if(list.length === 0) {\n    return []\n  }\n  if(compare) {\n    if(!sorted) {\n      list.sort(compare)\n    }\n    return unique_pred(list, compare)\n  }\n  if(!sorted) {\n    list.sort()\n  }\n  return unique_eq(list)\n}\n\nmodule.exports = unique","\"use strict\"\n\nfunction unique_pred(list, compare) {\n  var ptr = 1\n    , len = list.length\n    , a=list[0], b=list[0]\n  for(var i=1; i<len; ++i) {\n    b = a\n    a = list[i]\n    if(compare(a, b)) {\n      if(i === ptr) {\n        ptr++\n        continue\n      }\n      list[ptr++] = a\n    }\n  }\n  list.length = ptr\n  return list\n}\n\nfunction unique_eq(list) {\n  var ptr = 1\n    , len = list.length\n    , a=list[0], b = list[0]\n  for(var i=1; i<len; ++i, b=a) {\n    b = a\n    a = list[i]\n    if(a !== b) {\n      if(i === ptr) {\n        ptr++\n        continue\n      }\n      list[ptr++] = a\n    }\n  }\n  list.length = ptr\n  return list\n}\n\nfunction unique(list, compare, sorted) {\n  if(list.length === 0) {\n    return []\n  }\n  if(compare) {\n    if(!sorted) {\n      list.sort(compare)\n    }\n    return unique_pred(list, compare)\n  }\n  if(!sorted) {\n    list.sort()\n  }\n  return unique_eq(list)\n}\n\nmodule.exports = unique"]} | |
| ;require=(function(e,t,n){function i(n,s){if(!t[n]){if(!e[n]){var o=typeof require=="function"&&require;if(!s&&o)return o(n,!0);if(r)return r(n,!0);throw new Error("Cannot find module '"+n+"'")}var u=t[n]={exports:{}};e[n][0].call(u.exports,function(t){var r=e[n][1][t];return i(r?r:t)},u,u.exports)}return t[n].exports}var r=typeof require=="function"&&require;for(var s=0;s<n.length;s++)i(n[s]);return i})({"ndarray-fill":[function(require,module,exports){ | |
| module.exports=require('uqHaBP'); | |
| },{}],"uqHaBP":[function(require,module,exports){ | |
| "use strict" | |
| var fill = require("cwise")({ | |
| args: ["index", "array", "scalar"], | |
| body: function(idx, out, f) { | |
| out = f.apply(undefined, idx) | |
| } | |
| }) | |
| module.exports = function(array, f) { | |
| fill(array, f) | |
| return array | |
| } | |
| },{"cwise":1}],1:[function(require,module,exports){ | |
| "use strict" | |
| var parse = require("cwise-parser") | |
| var compile = require("cwise-compiler") | |
| var REQUIRED_FIELDS = [ "args", "body" ] | |
| var OPTIONAL_FIELDS = [ "pre", "post", "printCode", "funcName", "blockSize" ] | |
| function createCWise(user_args) { | |
| //Check parameters | |
| for(var id in user_args) { | |
| if(REQUIRED_FIELDS.indexOf(id) < 0 && | |
| OPTIONAL_FIELDS.indexOf(id) < 0) { | |
| console.warn("cwise: Unknown argument '"+id+"' passed to expression compiler") | |
| } | |
| } | |
| for(var i=0; i<REQUIRED_FIELDS.length; ++i) { | |
| if(!user_args[REQUIRED_FIELDS[i]]) { | |
| throw new Error("cwise: Missing argument: " + REQUIRED_FIELDS[i]) | |
| } | |
| } | |
| //Parse blocks | |
| return compile({ | |
| args: user_args.args, | |
| pre: parse(user_args.pre || function(){}), | |
| body: parse(user_args.body), | |
| post: parse(user_args.post || function(){}), | |
| debug: !!user_args.printCode, | |
| funcName: user_args.funcName || user_args.body.name || "cwise", | |
| blockSize: user_args.blockSize || 64 | |
| }) | |
| } | |
| module.exports = createCWise | |
| },{"cwise-parser":2,"cwise-compiler":3}],3:[function(require,module,exports){ | |
| "use strict" | |
| var createThunk = require("./lib/thunk.js") | |
| function Procedure() { | |
| this.argTypes = [] | |
| this.shimArgs = [] | |
| this.arrayArgs = [] | |
| this.scalarArgs = [] | |
| this.indexArgs = [] | |
| this.shapeArgs = [] | |
| this.funcName = "" | |
| this.pre = null | |
| this.body = null | |
| this.post = null | |
| this.debug = false | |
| } | |
| function compileCwise(user_args) { | |
| //Create procedure | |
| var proc = new Procedure() | |
| //Parse blocks | |
| proc.pre = user_args.pre | |
| proc.body = user_args.body | |
| proc.post = user_args.post | |
| //Parse arguments | |
| var proc_args = user_args.args.slice(0) | |
| proc.argTypes = proc_args | |
| for(var i=0; i<proc_args.length; ++i) { | |
| switch(proc_args[i]) { | |
| case "array": | |
| proc.arrayArgs.push(i) | |
| proc.shimArgs.push("array" + i) | |
| if(i < proc.pre.args.length && proc.pre.args[i].count>0) { | |
| throw new Error("cwise: pre() block may not reference array args") | |
| } | |
| if(i < proc.post.args.length && proc.post.args[i].count>0) { | |
| throw new Error("cwise: post() block may not reference array args") | |
| } | |
| break | |
| case "scalar": | |
| proc.scalarArgs.push(i) | |
| proc.shimArgs.push("scalar" + i) | |
| break | |
| case "index": | |
| proc.indexArgs.push(i) | |
| if(i < proc.pre.args.length && proc.pre.args[i].count > 0) { | |
| throw new Error("cwise: pre() block may not reference array index") | |
| } | |
| if(i < proc.body.args.length && proc.body.args[i].lvalue) { | |
| throw new Error("cwise: body() block may not write to array index") | |
| } | |
| if(i < proc.post.args.length && proc.post.args[i].count > 0) { | |
| throw new Error("cwise: post() block may not reference array index") | |
| } | |
| break | |
| case "shape": | |
| proc.shapeArgs.push(i) | |
| if(i < proc.pre.args.length && proc.pre.args[i].lvalue) { | |
| throw new Error("cwise: pre() block may not write to array shape") | |
| } | |
| if(i < proc.body.args.length && proc.body.args[i].lvalue) { | |
| throw new Error("cwise: body() block may not write to array shape") | |
| } | |
| if(i < proc.post.args.length && proc.post.args[i].lvalue) { | |
| throw new Error("cwise: post() block may not write to array shape") | |
| } | |
| break | |
| default: | |
| throw new Error("cwise: Unknown argument type " + proc_args[i]) | |
| } | |
| } | |
| //Make sure at least one array argument was specified | |
| if(proc.arrayArgs.length <= 0) { | |
| throw new Error("cwise: No array arguments specified") | |
| } | |
| //Make sure arguments are correct | |
| if(proc.pre.args.length > proc_args.length) { | |
| throw new Error("cwise: Too many arguments in pre() block") | |
| } | |
| if(proc.body.args.length > proc_args.length) { | |
| throw new Error("cwise: Too many arguments in body() block") | |
| } | |
| if(proc.post.args.length > proc_args.length) { | |
| throw new Error("cwise: Too many arguments in post() block") | |
| } | |
| //Check debug flag | |
| proc.debug = !!user_args.printCode || !!user_args.debug | |
| //Retrieve name | |
| proc.funcName = user_args.funcName || "cwise" | |
| //Read in block size | |
| proc.blockSize = user_args.blockSize || 64 | |
| return createThunk(proc) | |
| } | |
| module.exports = compileCwise | |
| },{"./lib/thunk.js":4}],2:[function(require,module,exports){ | |
| "use strict" | |
| var esprima = require("esprima") | |
| var uniq = require("uniq") | |
| var PREFIX_COUNTER = 0 | |
| function CompiledArgument(name, lvalue, rvalue) { | |
| this.name = name | |
| this.lvalue = lvalue | |
| this.rvalue = rvalue | |
| this.count = 0 | |
| } | |
| function CompiledRoutine(body, args, thisVars, localVars) { | |
| this.body = body | |
| this.args = args | |
| this.thisVars = thisVars | |
| this.localVars = localVars | |
| } | |
| function isGlobal(identifier) { | |
| if(identifier === "eval") { | |
| throw new Error("cwise-parser: eval() not allowed") | |
| } | |
| if(typeof window !== "undefined") { | |
| return identifier in window | |
| } else if(typeof GLOBAL !== "undefined") { | |
| return identifier in GLOBAL | |
| } else if(typeof self !== "undefined") { | |
| return identifier in self | |
| } else { | |
| return false | |
| } | |
| } | |
| function getArgNames(ast) { | |
| var params = ast.body[0].expression.callee.params | |
| var names = new Array(params.length) | |
| for(var i=0; i<params.length; ++i) { | |
| names[i] = params[i].name | |
| } | |
| return names | |
| } | |
| function preprocess(func) { | |
| var src = ["(", func, ")()"].join("") | |
| var ast = esprima.parse(src, { range: true }) | |
| //Compute new prefix | |
| var prefix = "_inline_" + (PREFIX_COUNTER++) + "_" | |
| //Parse out arguments | |
| var argNames = getArgNames(ast) | |
| var compiledArgs = new Array(argNames.length) | |
| for(var i=0; i<argNames.length; ++i) { | |
| compiledArgs[i] = new CompiledArgument([prefix, "arg", i, "_"].join(""), false, false) | |
| } | |
| //Create temporary data structure for source rewriting | |
| var exploded = new Array(src.length) | |
| for(var i=0, n=src.length; i<n; ++i) { | |
| exploded[i] = src.charAt(i) | |
| } | |
| //Local variables | |
| var localVars = [] | |
| var thisVars = [] | |
| var computedThis = false | |
| //Retrieves a local variable | |
| function createLocal(id) { | |
| var nstr = prefix + id.replace(/\_/g, "__") | |
| localVars.push(nstr) | |
| return nstr | |
| } | |
| //Creates a this variable | |
| function createThisVar(id) { | |
| var nstr = "this_" + id.replace(/\_/g, "__") | |
| thisVars.push(nstr) | |
| return nstr | |
| } | |
| //Rewrites an ast node | |
| function rewrite(node, nstr) { | |
| var lo = node.range[0], hi = node.range[1] | |
| for(var i=lo+1; i<hi; ++i) { | |
| exploded[i] = "" | |
| } | |
| exploded[lo] = nstr | |
| } | |
| //Remove any underscores | |
| function escapeString(str) { | |
| return "'"+(str.replace(/\_/g, "\\_").replace(/\'/g, "\'"))+"'" | |
| } | |
| //Returns the source of an identifier | |
| function source(node) { | |
| return exploded.slice(node.range[0], node.range[1]).join("") | |
| } | |
| //Computes the usage of a node | |
| var LVALUE = 1 | |
| var RVALUE = 2 | |
| function getUsage(node) { | |
| if(node.parent.type === "AssignmentExpression") { | |
| if(node.parent.left === node) { | |
| if(node.parent.operator === "=") { | |
| return LVALUE | |
| } | |
| return LVALUE|RVALUE | |
| } | |
| } | |
| if(node.parent.type === "UpdateExpression") { | |
| return LVALUE|RVALUE | |
| } | |
| return RVALUE | |
| } | |
| //Handle visiting a node | |
| (function visit(node, parent) { | |
| node.parent = parent | |
| if(node.type === "MemberExpression") { | |
| //Handle member expression | |
| if(node.computed) { | |
| visit(node.object, node) | |
| visit(node.property, node) | |
| } else if(node.object.type === "ThisExpression") { | |
| rewrite(node, createThisVar(node.property.name)) | |
| } else { | |
| visit(node.object, node) | |
| } | |
| } else if(node.type === "ThisExpression") { | |
| throw new Error("cwise-parser: Computed this is not allowed") | |
| } else if(node.type === "Identifier") { | |
| //Handle identifier | |
| var name = node.name | |
| var argNo = argNames.indexOf(name) | |
| if(argNo >= 0) { | |
| var carg = compiledArgs[argNo] | |
| var usage = getUsage(node) | |
| if(usage & LVALUE) { | |
| carg.lvalue = true | |
| } | |
| if(usage & RVALUE) { | |
| carg.rvalue = true | |
| } | |
| ++carg.count | |
| rewrite(node, carg.name) | |
| } else if(isGlobal(name)) { | |
| //Don't rewrite globals | |
| } else { | |
| rewrite(node, createLocal(name)) | |
| } | |
| } else if(node.type === "Literal") { | |
| if(typeof node.value === "string") { | |
| rewrite(node, escapeString(node.value)) | |
| } | |
| } else if(node.type === "WithStatement") { | |
| throw new Error("cwise-parser: with() statements not allowed") | |
| } else { | |
| //Visit all children | |
| var keys = Object.keys(node) | |
| for(var i=0, n=keys.length; i<n; ++i) { | |
| if(keys[i] === "parent") { | |
| continue | |
| } | |
| var value = node[keys[i]] | |
| if(value) { | |
| if(value instanceof Array) { | |
| for(var j=0; j<value.length; ++j) { | |
| if(value[j] && typeof value[j].type === "string") { | |
| visit(value[j], node) | |
| } | |
| } | |
| } else if(typeof value.type === "string") { | |
| visit(value, node) | |
| } | |
| } | |
| } | |
| } | |
| })(ast.body[0].expression.callee.body, undefined) | |
| //Remove duplicate variables | |
| uniq(localVars) | |
| uniq(thisVars) | |
| //Return body | |
| var routine = new CompiledRoutine(source(ast.body[0].expression.callee.body), compiledArgs, thisVars, localVars) | |
| return routine | |
| } | |
| module.exports = preprocess | |
| },{"esprima":5,"uniq":6}],5:[function(require,module,exports){ | |
| (function(){/* | |
| Copyright (C) 2012 Ariya Hidayat <[email protected]> | |
| Copyright (C) 2012 Mathias Bynens <[email protected]> | |
| Copyright (C) 2012 Joost-Wim Boekesteijn <[email protected]> | |
| Copyright (C) 2012 Kris Kowal <[email protected]> | |
| Copyright (C) 2012 Yusuke Suzuki <[email protected]> | |
| Copyright (C) 2012 Arpad Borsos <[email protected]> | |
| Copyright (C) 2011 Ariya Hidayat <[email protected]> | |
| Redistribution and use in source and binary forms, with or without | |
| modification, are permitted provided that the following conditions are met: | |
| * Redistributions of source code must retain the above copyright | |
| notice, this list of conditions and the following disclaimer. | |
| * Redistributions in binary form must reproduce the above copyright | |
| notice, this list of conditions and the following disclaimer in the | |
| documentation and/or other materials provided with the distribution. | |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" | |
| AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
| IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
| ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY | |
| DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | |
| (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | |
| LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | |
| ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
| (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF | |
| THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| */ | |
| /*jslint bitwise:true plusplus:true */ | |
| /*global esprima:true, define:true, exports:true, window: true, | |
| throwError: true, createLiteral: true, generateStatement: true, | |
| parseAssignmentExpression: true, parseBlock: true, parseExpression: true, | |
| parseFunctionDeclaration: true, parseFunctionExpression: true, | |
| parseFunctionSourceElements: true, parseVariableIdentifier: true, | |
| parseLeftHandSideExpression: true, | |
| parseStatement: true, parseSourceElement: true */ | |
| (function (root, factory) { | |
| 'use strict'; | |
| // Universal Module Definition (UMD) to support AMD, CommonJS/Node.js, | |
| // Rhino, and plain browser loading. | |
| if (typeof define === 'function' && define.amd) { | |
| define(['exports'], factory); | |
| } else if (typeof exports !== 'undefined') { | |
| factory(exports); | |
| } else { | |
| factory((root.esprima = {})); | |
| } | |
| }(this, function (exports) { | |
| 'use strict'; | |
| var Token, | |
| TokenName, | |
| Syntax, | |
| PropertyKind, | |
| Messages, | |
| Regex, | |
| source, | |
| strict, | |
| index, | |
| lineNumber, | |
| lineStart, | |
| length, | |
| buffer, | |
| state, | |
| extra; | |
| Token = { | |
| BooleanLiteral: 1, | |
| EOF: 2, | |
| Identifier: 3, | |
| Keyword: 4, | |
| NullLiteral: 5, | |
| NumericLiteral: 6, | |
| Punctuator: 7, | |
| StringLiteral: 8 | |
| }; | |
| TokenName = {}; | |
| TokenName[Token.BooleanLiteral] = 'Boolean'; | |
| TokenName[Token.EOF] = '<end>'; | |
| TokenName[Token.Identifier] = 'Identifier'; | |
| TokenName[Token.Keyword] = 'Keyword'; | |
| TokenName[Token.NullLiteral] = 'Null'; | |
| TokenName[Token.NumericLiteral] = 'Numeric'; | |
| TokenName[Token.Punctuator] = 'Punctuator'; | |
| TokenName[Token.StringLiteral] = 'String'; | |
| Syntax = { | |
| AssignmentExpression: 'AssignmentExpression', | |
| ArrayExpression: 'ArrayExpression', | |
| BlockStatement: 'BlockStatement', | |
| BinaryExpression: 'BinaryExpression', | |
| BreakStatement: 'BreakStatement', | |
| CallExpression: 'CallExpression', | |
| CatchClause: 'CatchClause', | |
| ConditionalExpression: 'ConditionalExpression', | |
| ContinueStatement: 'ContinueStatement', | |
| DoWhileStatement: 'DoWhileStatement', | |
| DebuggerStatement: 'DebuggerStatement', | |
| EmptyStatement: 'EmptyStatement', | |
| ExpressionStatement: 'ExpressionStatement', | |
| ForStatement: 'ForStatement', | |
| ForInStatement: 'ForInStatement', | |
| FunctionDeclaration: 'FunctionDeclaration', | |
| FunctionExpression: 'FunctionExpression', | |
| Identifier: 'Identifier', | |
| IfStatement: 'IfStatement', | |
| Literal: 'Literal', | |
| LabeledStatement: 'LabeledStatement', | |
| LogicalExpression: 'LogicalExpression', | |
| MemberExpression: 'MemberExpression', | |
| NewExpression: 'NewExpression', | |
| ObjectExpression: 'ObjectExpression', | |
| Program: 'Program', | |
| Property: 'Property', | |
| ReturnStatement: 'ReturnStatement', | |
| SequenceExpression: 'SequenceExpression', | |
| SwitchStatement: 'SwitchStatement', | |
| SwitchCase: 'SwitchCase', | |
| ThisExpression: 'ThisExpression', | |
| ThrowStatement: 'ThrowStatement', | |
| TryStatement: 'TryStatement', | |
| UnaryExpression: 'UnaryExpression', | |
| UpdateExpression: 'UpdateExpression', | |
| VariableDeclaration: 'VariableDeclaration', | |
| VariableDeclarator: 'VariableDeclarator', | |
| WhileStatement: 'WhileStatement', | |
| WithStatement: 'WithStatement' | |
| }; | |
| PropertyKind = { | |
| Data: 1, | |
| Get: 2, | |
| Set: 4 | |
| }; | |
| // Error messages should be identical to V8. | |
| Messages = { | |
| UnexpectedToken: 'Unexpected token %0', | |
| UnexpectedNumber: 'Unexpected number', | |
| UnexpectedString: 'Unexpected string', | |
| UnexpectedIdentifier: 'Unexpected identifier', | |
| UnexpectedReserved: 'Unexpected reserved word', | |
| UnexpectedEOS: 'Unexpected end of input', | |
| NewlineAfterThrow: 'Illegal newline after throw', | |
| InvalidRegExp: 'Invalid regular expression', | |
| UnterminatedRegExp: 'Invalid regular expression: missing /', | |
| InvalidLHSInAssignment: 'Invalid left-hand side in assignment', | |
| InvalidLHSInForIn: 'Invalid left-hand side in for-in', | |
| MultipleDefaultsInSwitch: 'More than one default clause in switch statement', | |
| NoCatchOrFinally: 'Missing catch or finally after try', | |
| UnknownLabel: 'Undefined label \'%0\'', | |
| Redeclaration: '%0 \'%1\' has already been declared', | |
| IllegalContinue: 'Illegal continue statement', | |
| IllegalBreak: 'Illegal break statement', | |
| IllegalReturn: 'Illegal return statement', | |
| StrictModeWith: 'Strict mode code may not include a with statement', | |
| StrictCatchVariable: 'Catch variable may not be eval or arguments in strict mode', | |
| StrictVarName: 'Variable name may not be eval or arguments in strict mode', | |
| StrictParamName: 'Parameter name eval or arguments is not allowed in strict mode', | |
| StrictParamDupe: 'Strict mode function may not have duplicate parameter names', | |
| StrictFunctionName: 'Function name may not be eval or arguments in strict mode', | |
| StrictOctalLiteral: 'Octal literals are not allowed in strict mode.', | |
| StrictDelete: 'Delete of an unqualified identifier in strict mode.', | |
| StrictDuplicateProperty: 'Duplicate data property in object literal not allowed in strict mode', | |
| AccessorDataProperty: 'Object literal may not have data and accessor property with the same name', | |
| AccessorGetSet: 'Object literal may not have multiple get/set accessors with the same name', | |
| StrictLHSAssignment: 'Assignment to eval or arguments is not allowed in strict mode', | |
| StrictLHSPostfix: 'Postfix increment/decrement may not have eval or arguments operand in strict mode', | |
| StrictLHSPrefix: 'Prefix increment/decrement may not have eval or arguments operand in strict mode', | |
| StrictReservedWord: 'Use of future reserved word in strict mode' | |
| }; | |
| // See also tools/generate-unicode-regex.py. | |
| Regex = { | |
| NonAsciiIdentifierStart: new RegExp('[\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0\u08a2-\u08ac\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097f\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d\u0c58\u0c59\u0c60\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d60\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191c\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19c1-\u19c7\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua697\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa80-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc]'), | |
| NonAsciiIdentifierPart: new RegExp('[\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0300-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u0483-\u0487\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u05d0-\u05ea\u05f0-\u05f2\u0610-\u061a\u0620-\u0669\u066e-\u06d3\u06d5-\u06dc\u06df-\u06e8\u06ea-\u06fc\u06ff\u0710-\u074a\u074d-\u07b1\u07c0-\u07f5\u07fa\u0800-\u082d\u0840-\u085b\u08a0\u08a2-\u08ac\u08e4-\u08fe\u0900-\u0963\u0966-\u096f\u0971-\u0977\u0979-\u097f\u0981-\u0983\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bc-\u09c4\u09c7\u09c8\u09cb-\u09ce\u09d7\u09dc\u09dd\u09df-\u09e3\u09e6-\u09f1\u0a01-\u0a03\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a59-\u0a5c\u0a5e\u0a66-\u0a75\u0a81-\u0a83\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abc-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ad0\u0ae0-\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3c-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b5c\u0b5d\u0b5f-\u0b63\u0b66-\u0b6f\u0b71\u0b82\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd0\u0bd7\u0be6-\u0bef\u0c01-\u0c03\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c58\u0c59\u0c60-\u0c63\u0c66-\u0c6f\u0c82\u0c83\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbc-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0cde\u0ce0-\u0ce3\u0ce6-\u0cef\u0cf1\u0cf2\u0d02\u0d03\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d-\u0d44\u0d46-\u0d48\u0d4a-\u0d4e\u0d57\u0d60-\u0d63\u0d66-\u0d6f\u0d7a-\u0d7f\u0d82\u0d83\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2\u0df3\u0e01-\u0e3a\u0e40-\u0e4e\u0e50-\u0e59\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb9\u0ebb-\u0ebd\u0ec0-\u0ec4\u0ec6\u0ec8-\u0ecd\u0ed0-\u0ed9\u0edc-\u0edf\u0f00\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e-\u0f47\u0f49-\u0f6c\u0f71-\u0f84\u0f86-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1049\u1050-\u109d\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u135d-\u135f\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176c\u176e-\u1770\u1772\u1773\u1780-\u17d3\u17d7\u17dc\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u1820-\u1877\u1880-\u18aa\u18b0-\u18f5\u1900-\u191c\u1920-\u192b\u1930-\u193b\u1946-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u19d0-\u19d9\u1a00-\u1a1b\u1a20-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1aa7\u1b00-\u1b4b\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1bf3\u1c00-\u1c37\u1c40-\u1c49\u1c4d-\u1c7d\u1cd0-\u1cd2\u1cd4-\u1cf6\u1d00-\u1de6\u1dfc-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u200c\u200d\u203f\u2040\u2054\u2071\u207f\u2090-\u209c\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d7f-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2de0-\u2dff\u2e2f\u3005-\u3007\u3021-\u302f\u3031-\u3035\u3038-\u303c\u3041-\u3096\u3099\u309a\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua62b\ua640-\ua66f\ua674-\ua67d\ua67f-\ua697\ua69f-\ua6f1\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua827\ua840-\ua873\ua880-\ua8c4\ua8d0-\ua8d9\ua8e0-\ua8f7\ua8fb\ua900-\ua92d\ua930-\ua953\ua960-\ua97c\ua980-\ua9c0\ua9cf-\ua9d9\uaa00-\uaa36\uaa40-\uaa4d\uaa50-\uaa59\uaa60-\uaa76\uaa7a\uaa7b\uaa80-\uaac2\uaadb-\uaadd\uaae0-\uaaef\uaaf2-\uaaf6\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabea\uabec\uabed\uabf0-\uabf9\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe00-\ufe0f\ufe20-\ufe26\ufe33\ufe34\ufe4d-\ufe4f\ufe70-\ufe74\ufe76-\ufefc\uff10-\uff19\uff21-\uff3a\uff3f\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc]') | |
| }; | |
| // Ensure the condition is true, otherwise throw an error. | |
| // This is only to have a better contract semantic, i.e. another safety net | |
| // to catch a logic error. The condition shall be fulfilled in normal case. | |
| // Do NOT use this to enforce a certain condition on any user input. | |
| function assert(condition, message) { | |
| if (!condition) { | |
| throw new Error('ASSERT: ' + message); | |
| } | |
| } | |
| function sliceSource(from, to) { | |
| return source.slice(from, to); | |
| } | |
| if (typeof 'esprima'[0] === 'undefined') { | |
| sliceSource = function sliceArraySource(from, to) { | |
| return source.slice(from, to).join(''); | |
| }; | |
| } | |
| function isDecimalDigit(ch) { | |
| return '0123456789'.indexOf(ch) >= 0; | |
| } | |
| function isHexDigit(ch) { | |
| return '0123456789abcdefABCDEF'.indexOf(ch) >= 0; | |
| } | |
| function isOctalDigit(ch) { | |
| return '01234567'.indexOf(ch) >= 0; | |
| } | |
| // 7.2 White Space | |
| function isWhiteSpace(ch) { | |
| return (ch === ' ') || (ch === '\u0009') || (ch === '\u000B') || | |
| (ch === '\u000C') || (ch === '\u00A0') || | |
| (ch.charCodeAt(0) >= 0x1680 && | |
| '\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\uFEFF'.indexOf(ch) >= 0); | |
| } | |
| // 7.3 Line Terminators | |
| function isLineTerminator(ch) { | |
| return (ch === '\n' || ch === '\r' || ch === '\u2028' || ch === '\u2029'); | |
| } | |
| // 7.6 Identifier Names and Identifiers | |
| function isIdentifierStart(ch) { | |
| return (ch === '$') || (ch === '_') || (ch === '\\') || | |
| (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || | |
| ((ch.charCodeAt(0) >= 0x80) && Regex.NonAsciiIdentifierStart.test(ch)); | |
| } | |
| function isIdentifierPart(ch) { | |
| return (ch === '$') || (ch === '_') || (ch === '\\') || | |
| (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || | |
| ((ch >= '0') && (ch <= '9')) || | |
| ((ch.charCodeAt(0) >= 0x80) && Regex.NonAsciiIdentifierPart.test(ch)); | |
| } | |
| // 7.6.1.2 Future Reserved Words | |
| function isFutureReservedWord(id) { | |
| switch (id) { | |
| // Future reserved words. | |
| case 'class': | |
| case 'enum': | |
| case 'export': | |
| case 'extends': | |
| case 'import': | |
| case 'super': | |
| return true; | |
| } | |
| return false; | |
| } | |
| function isStrictModeReservedWord(id) { | |
| switch (id) { | |
| // Strict Mode reserved words. | |
| case 'implements': | |
| case 'interface': | |
| case 'package': | |
| case 'private': | |
| case 'protected': | |
| case 'public': | |
| case 'static': | |
| case 'yield': | |
| case 'let': | |
| return true; | |
| } | |
| return false; | |
| } | |
| function isRestrictedWord(id) { | |
| return id === 'eval' || id === 'arguments'; | |
| } | |
| // 7.6.1.1 Keywords | |
| function isKeyword(id) { | |
| var keyword = false; | |
| switch (id.length) { | |
| case 2: | |
| keyword = (id === 'if') || (id === 'in') || (id === 'do'); | |
| break; | |
| case 3: | |
| keyword = (id === 'var') || (id === 'for') || (id === 'new') || (id === 'try'); | |
| break; | |
| case 4: | |
| keyword = (id === 'this') || (id === 'else') || (id === 'case') || (id === 'void') || (id === 'with'); | |
| break; | |
| case 5: | |
| keyword = (id === 'while') || (id === 'break') || (id === 'catch') || (id === 'throw'); | |
| break; | |
| case 6: | |
| keyword = (id === 'return') || (id === 'typeof') || (id === 'delete') || (id === 'switch'); | |
| break; | |
| case 7: | |
| keyword = (id === 'default') || (id === 'finally'); | |
| break; | |
| case 8: | |
| keyword = (id === 'function') || (id === 'continue') || (id === 'debugger'); | |
| break; | |
| case 10: | |
| keyword = (id === 'instanceof'); | |
| break; | |
| } | |
| if (keyword) { | |
| return true; | |
| } | |
| switch (id) { | |
| // Future reserved words. | |
| // 'const' is specialized as Keyword in V8. | |
| case 'const': | |
| return true; | |
| // For compatiblity to SpiderMonkey and ES.next | |
| case 'yield': | |
| case 'let': | |
| return true; | |
| } | |
| if (strict && isStrictModeReservedWord(id)) { | |
| return true; | |
| } | |
| return isFutureReservedWord(id); | |
| } | |
| // 7.4 Comments | |
| function skipComment() { | |
| var ch, blockComment, lineComment; | |
| blockComment = false; | |
| lineComment = false; | |
| while (index < length) { | |
| ch = source[index]; | |
| if (lineComment) { | |
| ch = source[index++]; | |
| if (isLineTerminator(ch)) { | |
| lineComment = false; | |
| if (ch === '\r' && source[index] === '\n') { | |
| ++index; | |
| } | |
| ++lineNumber; | |
| lineStart = index; | |
| } | |
| } else if (blockComment) { | |
| if (isLineTerminator(ch)) { | |
| if (ch === '\r' && source[index + 1] === '\n') { | |
| ++index; | |
| } | |
| ++lineNumber; | |
| ++index; | |
| lineStart = index; | |
| if (index >= length) { | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| } else { | |
| ch = source[index++]; | |
| if (index >= length) { | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| if (ch === '*') { | |
| ch = source[index]; | |
| if (ch === '/') { | |
| ++index; | |
| blockComment = false; | |
| } | |
| } | |
| } | |
| } else if (ch === '/') { | |
| ch = source[index + 1]; | |
| if (ch === '/') { | |
| index += 2; | |
| lineComment = true; | |
| } else if (ch === '*') { | |
| index += 2; | |
| blockComment = true; | |
| if (index >= length) { | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| } else { | |
| break; | |
| } | |
| } else if (isWhiteSpace(ch)) { | |
| ++index; | |
| } else if (isLineTerminator(ch)) { | |
| ++index; | |
| if (ch === '\r' && source[index] === '\n') { | |
| ++index; | |
| } | |
| ++lineNumber; | |
| lineStart = index; | |
| } else { | |
| break; | |
| } | |
| } | |
| } | |
| function scanHexEscape(prefix) { | |
| var i, len, ch, code = 0; | |
| len = (prefix === 'u') ? 4 : 2; | |
| for (i = 0; i < len; ++i) { | |
| if (index < length && isHexDigit(source[index])) { | |
| ch = source[index++]; | |
| code = code * 16 + '0123456789abcdef'.indexOf(ch.toLowerCase()); | |
| } else { | |
| return ''; | |
| } | |
| } | |
| return String.fromCharCode(code); | |
| } | |
| function scanIdentifier() { | |
| var ch, start, id, restore; | |
| ch = source[index]; | |
| if (!isIdentifierStart(ch)) { | |
| return; | |
| } | |
| start = index; | |
| if (ch === '\\') { | |
| ++index; | |
| if (source[index] !== 'u') { | |
| return; | |
| } | |
| ++index; | |
| restore = index; | |
| ch = scanHexEscape('u'); | |
| if (ch) { | |
| if (ch === '\\' || !isIdentifierStart(ch)) { | |
| return; | |
| } | |
| id = ch; | |
| } else { | |
| index = restore; | |
| id = 'u'; | |
| } | |
| } else { | |
| id = source[index++]; | |
| } | |
| while (index < length) { | |
| ch = source[index]; | |
| if (!isIdentifierPart(ch)) { | |
| break; | |
| } | |
| if (ch === '\\') { | |
| ++index; | |
| if (source[index] !== 'u') { | |
| return; | |
| } | |
| ++index; | |
| restore = index; | |
| ch = scanHexEscape('u'); | |
| if (ch) { | |
| if (ch === '\\' || !isIdentifierPart(ch)) { | |
| return; | |
| } | |
| id += ch; | |
| } else { | |
| index = restore; | |
| id += 'u'; | |
| } | |
| } else { | |
| id += source[index++]; | |
| } | |
| } | |
| // There is no keyword or literal with only one character. | |
| // Thus, it must be an identifier. | |
| if (id.length === 1) { | |
| return { | |
| type: Token.Identifier, | |
| value: id, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| if (isKeyword(id)) { | |
| return { | |
| type: Token.Keyword, | |
| value: id, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| // 7.8.1 Null Literals | |
| if (id === 'null') { | |
| return { | |
| type: Token.NullLiteral, | |
| value: id, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| // 7.8.2 Boolean Literals | |
| if (id === 'true' || id === 'false') { | |
| return { | |
| type: Token.BooleanLiteral, | |
| value: id, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| return { | |
| type: Token.Identifier, | |
| value: id, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| // 7.7 Punctuators | |
| function scanPunctuator() { | |
| var start = index, | |
| ch1 = source[index], | |
| ch2, | |
| ch3, | |
| ch4; | |
| // Check for most common single-character punctuators. | |
| if (ch1 === ';' || ch1 === '{' || ch1 === '}') { | |
| ++index; | |
| return { | |
| type: Token.Punctuator, | |
| value: ch1, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| if (ch1 === ',' || ch1 === '(' || ch1 === ')') { | |
| ++index; | |
| return { | |
| type: Token.Punctuator, | |
| value: ch1, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| // Dot (.) can also start a floating-point number, hence the need | |
| // to check the next character. | |
| ch2 = source[index + 1]; | |
| if (ch1 === '.' && !isDecimalDigit(ch2)) { | |
| return { | |
| type: Token.Punctuator, | |
| value: source[index++], | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| // Peek more characters. | |
| ch3 = source[index + 2]; | |
| ch4 = source[index + 3]; | |
| // 4-character punctuator: >>>= | |
| if (ch1 === '>' && ch2 === '>' && ch3 === '>') { | |
| if (ch4 === '=') { | |
| index += 4; | |
| return { | |
| type: Token.Punctuator, | |
| value: '>>>=', | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| } | |
| // 3-character punctuators: === !== >>> <<= >>= | |
| if (ch1 === '=' && ch2 === '=' && ch3 === '=') { | |
| index += 3; | |
| return { | |
| type: Token.Punctuator, | |
| value: '===', | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| if (ch1 === '!' && ch2 === '=' && ch3 === '=') { | |
| index += 3; | |
| return { | |
| type: Token.Punctuator, | |
| value: '!==', | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| if (ch1 === '>' && ch2 === '>' && ch3 === '>') { | |
| index += 3; | |
| return { | |
| type: Token.Punctuator, | |
| value: '>>>', | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| if (ch1 === '<' && ch2 === '<' && ch3 === '=') { | |
| index += 3; | |
| return { | |
| type: Token.Punctuator, | |
| value: '<<=', | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| if (ch1 === '>' && ch2 === '>' && ch3 === '=') { | |
| index += 3; | |
| return { | |
| type: Token.Punctuator, | |
| value: '>>=', | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| // 2-character punctuators: <= >= == != ++ -- << >> && || | |
| // += -= *= %= &= |= ^= /= | |
| if (ch2 === '=') { | |
| if ('<>=!+-*%&|^/'.indexOf(ch1) >= 0) { | |
| index += 2; | |
| return { | |
| type: Token.Punctuator, | |
| value: ch1 + ch2, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| } | |
| if (ch1 === ch2 && ('+-<>&|'.indexOf(ch1) >= 0)) { | |
| if ('+-<>&|'.indexOf(ch2) >= 0) { | |
| index += 2; | |
| return { | |
| type: Token.Punctuator, | |
| value: ch1 + ch2, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| } | |
| // The remaining 1-character punctuators. | |
| if ('[]<>+-*%&|^!~?:=/'.indexOf(ch1) >= 0) { | |
| return { | |
| type: Token.Punctuator, | |
| value: source[index++], | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| } | |
| // 7.8.3 Numeric Literals | |
| function scanNumericLiteral() { | |
| var number, start, ch; | |
| ch = source[index]; | |
| assert(isDecimalDigit(ch) || (ch === '.'), | |
| 'Numeric literal must start with a decimal digit or a decimal point'); | |
| start = index; | |
| number = ''; | |
| if (ch !== '.') { | |
| number = source[index++]; | |
| ch = source[index]; | |
| // Hex number starts with '0x'. | |
| // Octal number starts with '0'. | |
| if (number === '0') { | |
| if (ch === 'x' || ch === 'X') { | |
| number += source[index++]; | |
| while (index < length) { | |
| ch = source[index]; | |
| if (!isHexDigit(ch)) { | |
| break; | |
| } | |
| number += source[index++]; | |
| } | |
| if (number.length <= 2) { | |
| // only 0x | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| if (index < length) { | |
| ch = source[index]; | |
| if (isIdentifierStart(ch)) { | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| } | |
| return { | |
| type: Token.NumericLiteral, | |
| value: parseInt(number, 16), | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } else if (isOctalDigit(ch)) { | |
| number += source[index++]; | |
| while (index < length) { | |
| ch = source[index]; | |
| if (!isOctalDigit(ch)) { | |
| break; | |
| } | |
| number += source[index++]; | |
| } | |
| if (index < length) { | |
| ch = source[index]; | |
| if (isIdentifierStart(ch) || isDecimalDigit(ch)) { | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| } | |
| return { | |
| type: Token.NumericLiteral, | |
| value: parseInt(number, 8), | |
| octal: true, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| // decimal number starts with '0' such as '09' is illegal. | |
| if (isDecimalDigit(ch)) { | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| } | |
| while (index < length) { | |
| ch = source[index]; | |
| if (!isDecimalDigit(ch)) { | |
| break; | |
| } | |
| number += source[index++]; | |
| } | |
| } | |
| if (ch === '.') { | |
| number += source[index++]; | |
| while (index < length) { | |
| ch = source[index]; | |
| if (!isDecimalDigit(ch)) { | |
| break; | |
| } | |
| number += source[index++]; | |
| } | |
| } | |
| if (ch === 'e' || ch === 'E') { | |
| number += source[index++]; | |
| ch = source[index]; | |
| if (ch === '+' || ch === '-') { | |
| number += source[index++]; | |
| } | |
| ch = source[index]; | |
| if (isDecimalDigit(ch)) { | |
| number += source[index++]; | |
| while (index < length) { | |
| ch = source[index]; | |
| if (!isDecimalDigit(ch)) { | |
| break; | |
| } | |
| number += source[index++]; | |
| } | |
| } else { | |
| ch = 'character ' + ch; | |
| if (index >= length) { | |
| ch = '<end>'; | |
| } | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| } | |
| if (index < length) { | |
| ch = source[index]; | |
| if (isIdentifierStart(ch)) { | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| } | |
| return { | |
| type: Token.NumericLiteral, | |
| value: parseFloat(number), | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| // 7.8.4 String Literals | |
| function scanStringLiteral() { | |
| var str = '', quote, start, ch, code, unescaped, restore, octal = false; | |
| quote = source[index]; | |
| assert((quote === '\'' || quote === '"'), | |
| 'String literal must starts with a quote'); | |
| start = index; | |
| ++index; | |
| while (index < length) { | |
| ch = source[index++]; | |
| if (ch === quote) { | |
| quote = ''; | |
| break; | |
| } else if (ch === '\\') { | |
| ch = source[index++]; | |
| if (!isLineTerminator(ch)) { | |
| switch (ch) { | |
| case 'n': | |
| str += '\n'; | |
| break; | |
| case 'r': | |
| str += '\r'; | |
| break; | |
| case 't': | |
| str += '\t'; | |
| break; | |
| case 'u': | |
| case 'x': | |
| restore = index; | |
| unescaped = scanHexEscape(ch); | |
| if (unescaped) { | |
| str += unescaped; | |
| } else { | |
| index = restore; | |
| str += ch; | |
| } | |
| break; | |
| case 'b': | |
| str += '\b'; | |
| break; | |
| case 'f': | |
| str += '\f'; | |
| break; | |
| case 'v': | |
| str += '\x0B'; | |
| break; | |
| default: | |
| if (isOctalDigit(ch)) { | |
| code = '01234567'.indexOf(ch); | |
| // \0 is not octal escape sequence | |
| if (code !== 0) { | |
| octal = true; | |
| } | |
| if (index < length && isOctalDigit(source[index])) { | |
| octal = true; | |
| code = code * 8 + '01234567'.indexOf(source[index++]); | |
| // 3 digits are only allowed when string starts | |
| // with 0, 1, 2, 3 | |
| if ('0123'.indexOf(ch) >= 0 && | |
| index < length && | |
| isOctalDigit(source[index])) { | |
| code = code * 8 + '01234567'.indexOf(source[index++]); | |
| } | |
| } | |
| str += String.fromCharCode(code); | |
| } else { | |
| str += ch; | |
| } | |
| break; | |
| } | |
| } else { | |
| ++lineNumber; | |
| if (ch === '\r' && source[index] === '\n') { | |
| ++index; | |
| } | |
| } | |
| } else if (isLineTerminator(ch)) { | |
| break; | |
| } else { | |
| str += ch; | |
| } | |
| } | |
| if (quote !== '') { | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| return { | |
| type: Token.StringLiteral, | |
| value: str, | |
| octal: octal, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [start, index] | |
| }; | |
| } | |
| function scanRegExp() { | |
| var str, ch, start, pattern, flags, value, classMarker = false, restore, terminated = false; | |
| buffer = null; | |
| skipComment(); | |
| start = index; | |
| ch = source[index]; | |
| assert(ch === '/', 'Regular expression literal must start with a slash'); | |
| str = source[index++]; | |
| while (index < length) { | |
| ch = source[index++]; | |
| str += ch; | |
| if (ch === '\\') { | |
| ch = source[index++]; | |
| // ECMA-262 7.8.5 | |
| if (isLineTerminator(ch)) { | |
| throwError({}, Messages.UnterminatedRegExp); | |
| } | |
| str += ch; | |
| } else if (classMarker) { | |
| if (ch === ']') { | |
| classMarker = false; | |
| } | |
| } else { | |
| if (ch === '/') { | |
| terminated = true; | |
| break; | |
| } else if (ch === '[') { | |
| classMarker = true; | |
| } else if (isLineTerminator(ch)) { | |
| throwError({}, Messages.UnterminatedRegExp); | |
| } | |
| } | |
| } | |
| if (!terminated) { | |
| throwError({}, Messages.UnterminatedRegExp); | |
| } | |
| // Exclude leading and trailing slash. | |
| pattern = str.substr(1, str.length - 2); | |
| flags = ''; | |
| while (index < length) { | |
| ch = source[index]; | |
| if (!isIdentifierPart(ch)) { | |
| break; | |
| } | |
| ++index; | |
| if (ch === '\\' && index < length) { | |
| ch = source[index]; | |
| if (ch === 'u') { | |
| ++index; | |
| restore = index; | |
| ch = scanHexEscape('u'); | |
| if (ch) { | |
| flags += ch; | |
| str += '\\u'; | |
| for (; restore < index; ++restore) { | |
| str += source[restore]; | |
| } | |
| } else { | |
| index = restore; | |
| flags += 'u'; | |
| str += '\\u'; | |
| } | |
| } else { | |
| str += '\\'; | |
| } | |
| } else { | |
| flags += ch; | |
| str += ch; | |
| } | |
| } | |
| try { | |
| value = new RegExp(pattern, flags); | |
| } catch (e) { | |
| throwError({}, Messages.InvalidRegExp); | |
| } | |
| return { | |
| literal: str, | |
| value: value, | |
| range: [start, index] | |
| }; | |
| } | |
| function isIdentifierName(token) { | |
| return token.type === Token.Identifier || | |
| token.type === Token.Keyword || | |
| token.type === Token.BooleanLiteral || | |
| token.type === Token.NullLiteral; | |
| } | |
| function advance() { | |
| var ch, token; | |
| skipComment(); | |
| if (index >= length) { | |
| return { | |
| type: Token.EOF, | |
| lineNumber: lineNumber, | |
| lineStart: lineStart, | |
| range: [index, index] | |
| }; | |
| } | |
| token = scanPunctuator(); | |
| if (typeof token !== 'undefined') { | |
| return token; | |
| } | |
| ch = source[index]; | |
| if (ch === '\'' || ch === '"') { | |
| return scanStringLiteral(); | |
| } | |
| if (ch === '.' || isDecimalDigit(ch)) { | |
| return scanNumericLiteral(); | |
| } | |
| token = scanIdentifier(); | |
| if (typeof token !== 'undefined') { | |
| return token; | |
| } | |
| throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); | |
| } | |
| function lex() { | |
| var token; | |
| if (buffer) { | |
| index = buffer.range[1]; | |
| lineNumber = buffer.lineNumber; | |
| lineStart = buffer.lineStart; | |
| token = buffer; | |
| buffer = null; | |
| return token; | |
| } | |
| buffer = null; | |
| return advance(); | |
| } | |
| function lookahead() { | |
| var pos, line, start; | |
| if (buffer !== null) { | |
| return buffer; | |
| } | |
| pos = index; | |
| line = lineNumber; | |
| start = lineStart; | |
| buffer = advance(); | |
| index = pos; | |
| lineNumber = line; | |
| lineStart = start; | |
| return buffer; | |
| } | |
| // Return true if there is a line terminator before the next token. | |
| function peekLineTerminator() { | |
| var pos, line, start, found; | |
| pos = index; | |
| line = lineNumber; | |
| start = lineStart; | |
| skipComment(); | |
| found = lineNumber !== line; | |
| index = pos; | |
| lineNumber = line; | |
| lineStart = start; | |
| return found; | |
| } | |
| // Throw an exception | |
| function throwError(token, messageFormat) { | |
| var error, | |
| args = Array.prototype.slice.call(arguments, 2), | |
| msg = messageFormat.replace( | |
| /%(\d)/g, | |
| function (whole, index) { | |
| return args[index] || ''; | |
| } | |
| ); | |
| if (typeof token.lineNumber === 'number') { | |
| error = new Error('Line ' + token.lineNumber + ': ' + msg); | |
| error.index = token.range[0]; | |
| error.lineNumber = token.lineNumber; | |
| error.column = token.range[0] - lineStart + 1; | |
| } else { | |
| error = new Error('Line ' + lineNumber + ': ' + msg); | |
| error.index = index; | |
| error.lineNumber = lineNumber; | |
| error.column = index - lineStart + 1; | |
| } | |
| throw error; | |
| } | |
| function throwErrorTolerant() { | |
| try { | |
| throwError.apply(null, arguments); | |
| } catch (e) { | |
| if (extra.errors) { | |
| extra.errors.push(e); | |
| } else { | |
| throw e; | |
| } | |
| } | |
| } | |
| // Throw an exception because of the token. | |
| function throwUnexpected(token) { | |
| if (token.type === Token.EOF) { | |
| throwError(token, Messages.UnexpectedEOS); | |
| } | |
| if (token.type === Token.NumericLiteral) { | |
| throwError(token, Messages.UnexpectedNumber); | |
| } | |
| if (token.type === Token.StringLiteral) { | |
| throwError(token, Messages.UnexpectedString); | |
| } | |
| if (token.type === Token.Identifier) { | |
| throwError(token, Messages.UnexpectedIdentifier); | |
| } | |
| if (token.type === Token.Keyword) { | |
| if (isFutureReservedWord(token.value)) { | |
| throwError(token, Messages.UnexpectedReserved); | |
| } else if (strict && isStrictModeReservedWord(token.value)) { | |
| throwErrorTolerant(token, Messages.StrictReservedWord); | |
| return; | |
| } | |
| throwError(token, Messages.UnexpectedToken, token.value); | |
| } | |
| // BooleanLiteral, NullLiteral, or Punctuator. | |
| throwError(token, Messages.UnexpectedToken, token.value); | |
| } | |
| // Expect the next token to match the specified punctuator. | |
| // If not, an exception will be thrown. | |
| function expect(value) { | |
| var token = lex(); | |
| if (token.type !== Token.Punctuator || token.value !== value) { | |
| throwUnexpected(token); | |
| } | |
| } | |
| // Expect the next token to match the specified keyword. | |
| // If not, an exception will be thrown. | |
| function expectKeyword(keyword) { | |
| var token = lex(); | |
| if (token.type !== Token.Keyword || token.value !== keyword) { | |
| throwUnexpected(token); | |
| } | |
| } | |
| // Return true if the next token matches the specified punctuator. | |
| function match(value) { | |
| var token = lookahead(); | |
| return token.type === Token.Punctuator && token.value === value; | |
| } | |
| // Return true if the next token matches the specified keyword | |
| function matchKeyword(keyword) { | |
| var token = lookahead(); | |
| return token.type === Token.Keyword && token.value === keyword; | |
| } | |
| // Return true if the next token is an assignment operator | |
| function matchAssign() { | |
| var token = lookahead(), | |
| op = token.value; | |
| if (token.type !== Token.Punctuator) { | |
| return false; | |
| } | |
| return op === '=' || | |
| op === '*=' || | |
| op === '/=' || | |
| op === '%=' || | |
| op === '+=' || | |
| op === '-=' || | |
| op === '<<=' || | |
| op === '>>=' || | |
| op === '>>>=' || | |
| op === '&=' || | |
| op === '^=' || | |
| op === '|='; | |
| } | |
| function consumeSemicolon() { | |
| var token, line; | |
| // Catch the very common case first. | |
| if (source[index] === ';') { | |
| lex(); | |
| return; | |
| } | |
| line = lineNumber; | |
| skipComment(); | |
| if (lineNumber !== line) { | |
| return; | |
| } | |
| if (match(';')) { | |
| lex(); | |
| return; | |
| } | |
| token = lookahead(); | |
| if (token.type !== Token.EOF && !match('}')) { | |
| throwUnexpected(token); | |
| } | |
| } | |
| // Return true if provided expression is LeftHandSideExpression | |
| function isLeftHandSide(expr) { | |
| return expr.type === Syntax.Identifier || expr.type === Syntax.MemberExpression; | |
| } | |
| // 11.1.4 Array Initialiser | |
| function parseArrayInitialiser() { | |
| var elements = []; | |
| expect('['); | |
| while (!match(']')) { | |
| if (match(',')) { | |
| lex(); | |
| elements.push(null); | |
| } else { | |
| elements.push(parseAssignmentExpression()); | |
| if (!match(']')) { | |
| expect(','); | |
| } | |
| } | |
| } | |
| expect(']'); | |
| return { | |
| type: Syntax.ArrayExpression, | |
| elements: elements | |
| }; | |
| } | |
| // 11.1.5 Object Initialiser | |
| function parsePropertyFunction(param, first) { | |
| var previousStrict, body; | |
| previousStrict = strict; | |
| body = parseFunctionSourceElements(); | |
| if (first && strict && isRestrictedWord(param[0].name)) { | |
| throwErrorTolerant(first, Messages.StrictParamName); | |
| } | |
| strict = previousStrict; | |
| return { | |
| type: Syntax.FunctionExpression, | |
| id: null, | |
| params: param, | |
| defaults: [], | |
| body: body, | |
| rest: null, | |
| generator: false, | |
| expression: false | |
| }; | |
| } | |
| function parseObjectPropertyKey() { | |
| var token = lex(); | |
| // Note: This function is called only from parseObjectProperty(), where | |
| // EOF and Punctuator tokens are already filtered out. | |
| if (token.type === Token.StringLiteral || token.type === Token.NumericLiteral) { | |
| if (strict && token.octal) { | |
| throwErrorTolerant(token, Messages.StrictOctalLiteral); | |
| } | |
| return createLiteral(token); | |
| } | |
| return { | |
| type: Syntax.Identifier, | |
| name: token.value | |
| }; | |
| } | |
| function parseObjectProperty() { | |
| var token, key, id, param; | |
| token = lookahead(); | |
| if (token.type === Token.Identifier) { | |
| id = parseObjectPropertyKey(); | |
| // Property Assignment: Getter and Setter. | |
| if (token.value === 'get' && !match(':')) { | |
| key = parseObjectPropertyKey(); | |
| expect('('); | |
| expect(')'); | |
| return { | |
| type: Syntax.Property, | |
| key: key, | |
| value: parsePropertyFunction([]), | |
| kind: 'get' | |
| }; | |
| } else if (token.value === 'set' && !match(':')) { | |
| key = parseObjectPropertyKey(); | |
| expect('('); | |
| token = lookahead(); | |
| if (token.type !== Token.Identifier) { | |
| expect(')'); | |
| throwErrorTolerant(token, Messages.UnexpectedToken, token.value); | |
| return { | |
| type: Syntax.Property, | |
| key: key, | |
| value: parsePropertyFunction([]), | |
| kind: 'set' | |
| }; | |
| } else { | |
| param = [ parseVariableIdentifier() ]; | |
| expect(')'); | |
| return { | |
| type: Syntax.Property, | |
| key: key, | |
| value: parsePropertyFunction(param, token), | |
| kind: 'set' | |
| }; | |
| } | |
| } else { | |
| expect(':'); | |
| return { | |
| type: Syntax.Property, | |
| key: id, | |
| value: parseAssignmentExpression(), | |
| kind: 'init' | |
| }; | |
| } | |
| } else if (token.type === Token.EOF || token.type === Token.Punctuator) { | |
| throwUnexpected(token); | |
| } else { | |
| key = parseObjectPropertyKey(); | |
| expect(':'); | |
| return { | |
| type: Syntax.Property, | |
| key: key, | |
| value: parseAssignmentExpression(), | |
| kind: 'init' | |
| }; | |
| } | |
| } | |
| function parseObjectInitialiser() { | |
| var properties = [], property, name, kind, map = {}, toString = String; | |
| expect('{'); | |
| while (!match('}')) { | |
| property = parseObjectProperty(); | |
| if (property.key.type === Syntax.Identifier) { | |
| name = property.key.name; | |
| } else { | |
| name = toString(property.key.value); | |
| } | |
| kind = (property.kind === 'init') ? PropertyKind.Data : (property.kind === 'get') ? PropertyKind.Get : PropertyKind.Set; | |
| if (Object.prototype.hasOwnProperty.call(map, name)) { | |
| if (map[name] === PropertyKind.Data) { | |
| if (strict && kind === PropertyKind.Data) { | |
| throwErrorTolerant({}, Messages.StrictDuplicateProperty); | |
| } else if (kind !== PropertyKind.Data) { | |
| throwErrorTolerant({}, Messages.AccessorDataProperty); | |
| } | |
| } else { | |
| if (kind === PropertyKind.Data) { | |
| throwErrorTolerant({}, Messages.AccessorDataProperty); | |
| } else if (map[name] & kind) { | |
| throwErrorTolerant({}, Messages.AccessorGetSet); | |
| } | |
| } | |
| map[name] |= kind; | |
| } else { | |
| map[name] = kind; | |
| } | |
| properties.push(property); | |
| if (!match('}')) { | |
| expect(','); | |
| } | |
| } | |
| expect('}'); | |
| return { | |
| type: Syntax.ObjectExpression, | |
| properties: properties | |
| }; | |
| } | |
| // 11.1.6 The Grouping Operator | |
| function parseGroupExpression() { | |
| var expr; | |
| expect('('); | |
| expr = parseExpression(); | |
| expect(')'); | |
| return expr; | |
| } | |
| // 11.1 Primary Expressions | |
| function parsePrimaryExpression() { | |
| var token = lookahead(), | |
| type = token.type; | |
| if (type === Token.Identifier) { | |
| return { | |
| type: Syntax.Identifier, | |
| name: lex().value | |
| }; | |
| } | |
| if (type === Token.StringLiteral || type === Token.NumericLiteral) { | |
| if (strict && token.octal) { | |
| throwErrorTolerant(token, Messages.StrictOctalLiteral); | |
| } | |
| return createLiteral(lex()); | |
| } | |
| if (type === Token.Keyword) { | |
| if (matchKeyword('this')) { | |
| lex(); | |
| return { | |
| type: Syntax.ThisExpression | |
| }; | |
| } | |
| if (matchKeyword('function')) { | |
| return parseFunctionExpression(); | |
| } | |
| } | |
| if (type === Token.BooleanLiteral) { | |
| lex(); | |
| token.value = (token.value === 'true'); | |
| return createLiteral(token); | |
| } | |
| if (type === Token.NullLiteral) { | |
| lex(); | |
| token.value = null; | |
| return createLiteral(token); | |
| } | |
| if (match('[')) { | |
| return parseArrayInitialiser(); | |
| } | |
| if (match('{')) { | |
| return parseObjectInitialiser(); | |
| } | |
| if (match('(')) { | |
| return parseGroupExpression(); | |
| } | |
| if (match('/') || match('/=')) { | |
| return createLiteral(scanRegExp()); | |
| } | |
| return throwUnexpected(lex()); | |
| } | |
| // 11.2 Left-Hand-Side Expressions | |
| function parseArguments() { | |
| var args = []; | |
| expect('('); | |
| if (!match(')')) { | |
| while (index < length) { | |
| args.push(parseAssignmentExpression()); | |
| if (match(')')) { | |
| break; | |
| } | |
| expect(','); | |
| } | |
| } | |
| expect(')'); | |
| return args; | |
| } | |
| function parseNonComputedProperty() { | |
| var token = lex(); | |
| if (!isIdentifierName(token)) { | |
| throwUnexpected(token); | |
| } | |
| return { | |
| type: Syntax.Identifier, | |
| name: token.value | |
| }; | |
| } | |
| function parseNonComputedMember() { | |
| expect('.'); | |
| return parseNonComputedProperty(); | |
| } | |
| function parseComputedMember() { | |
| var expr; | |
| expect('['); | |
| expr = parseExpression(); | |
| expect(']'); | |
| return expr; | |
| } | |
| function parseNewExpression() { | |
| var expr; | |
| expectKeyword('new'); | |
| expr = { | |
| type: Syntax.NewExpression, | |
| callee: parseLeftHandSideExpression(), | |
| 'arguments': [] | |
| }; | |
| if (match('(')) { | |
| expr['arguments'] = parseArguments(); | |
| } | |
| return expr; | |
| } | |
| function parseLeftHandSideExpressionAllowCall() { | |
| var expr; | |
| expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression(); | |
| while (match('.') || match('[') || match('(')) { | |
| if (match('(')) { | |
| expr = { | |
| type: Syntax.CallExpression, | |
| callee: expr, | |
| 'arguments': parseArguments() | |
| }; | |
| } else if (match('[')) { | |
| expr = { | |
| type: Syntax.MemberExpression, | |
| computed: true, | |
| object: expr, | |
| property: parseComputedMember() | |
| }; | |
| } else { | |
| expr = { | |
| type: Syntax.MemberExpression, | |
| computed: false, | |
| object: expr, | |
| property: parseNonComputedMember() | |
| }; | |
| } | |
| } | |
| return expr; | |
| } | |
| function parseLeftHandSideExpression() { | |
| var expr; | |
| expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression(); | |
| while (match('.') || match('[')) { | |
| if (match('[')) { | |
| expr = { | |
| type: Syntax.MemberExpression, | |
| computed: true, | |
| object: expr, | |
| property: parseComputedMember() | |
| }; | |
| } else { | |
| expr = { | |
| type: Syntax.MemberExpression, | |
| computed: false, | |
| object: expr, | |
| property: parseNonComputedMember() | |
| }; | |
| } | |
| } | |
| return expr; | |
| } | |
| // 11.3 Postfix Expressions | |
| function parsePostfixExpression() { | |
| var expr = parseLeftHandSideExpressionAllowCall(), token; | |
| token = lookahead(); | |
| if (token.type !== Token.Punctuator) { | |
| return expr; | |
| } | |
| if ((match('++') || match('--')) && !peekLineTerminator()) { | |
| // 11.3.1, 11.3.2 | |
| if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) { | |
| throwErrorTolerant({}, Messages.StrictLHSPostfix); | |
| } | |
| if (!isLeftHandSide(expr)) { | |
| throwErrorTolerant({}, Messages.InvalidLHSInAssignment); | |
| } | |
| expr = { | |
| type: Syntax.UpdateExpression, | |
| operator: lex().value, | |
| argument: expr, | |
| prefix: false | |
| }; | |
| } | |
| return expr; | |
| } | |
| // 11.4 Unary Operators | |
| function parseUnaryExpression() { | |
| var token, expr; | |
| token = lookahead(); | |
| if (token.type !== Token.Punctuator && token.type !== Token.Keyword) { | |
| return parsePostfixExpression(); | |
| } | |
| if (match('++') || match('--')) { | |
| token = lex(); | |
| expr = parseUnaryExpression(); | |
| // 11.4.4, 11.4.5 | |
| if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) { | |
| throwErrorTolerant({}, Messages.StrictLHSPrefix); | |
| } | |
| if (!isLeftHandSide(expr)) { | |
| throwErrorTolerant({}, Messages.InvalidLHSInAssignment); | |
| } | |
| expr = { | |
| type: Syntax.UpdateExpression, | |
| operator: token.value, | |
| argument: expr, | |
| prefix: true | |
| }; | |
| return expr; | |
| } | |
| if (match('+') || match('-') || match('~') || match('!')) { | |
| expr = { | |
| type: Syntax.UnaryExpression, | |
| operator: lex().value, | |
| argument: parseUnaryExpression(), | |
| prefix: true | |
| }; | |
| return expr; | |
| } | |
| if (matchKeyword('delete') || matchKeyword('void') || matchKeyword('typeof')) { | |
| expr = { | |
| type: Syntax.UnaryExpression, | |
| operator: lex().value, | |
| argument: parseUnaryExpression(), | |
| prefix: true | |
| }; | |
| if (strict && expr.operator === 'delete' && expr.argument.type === Syntax.Identifier) { | |
| throwErrorTolerant({}, Messages.StrictDelete); | |
| } | |
| return expr; | |
| } | |
| return parsePostfixExpression(); | |
| } | |
| // 11.5 Multiplicative Operators | |
| function parseMultiplicativeExpression() { | |
| var expr = parseUnaryExpression(); | |
| while (match('*') || match('/') || match('%')) { | |
| expr = { | |
| type: Syntax.BinaryExpression, | |
| operator: lex().value, | |
| left: expr, | |
| right: parseUnaryExpression() | |
| }; | |
| } | |
| return expr; | |
| } | |
| // 11.6 Additive Operators | |
| function parseAdditiveExpression() { | |
| var expr = parseMultiplicativeExpression(); | |
| while (match('+') || match('-')) { | |
| expr = { | |
| type: Syntax.BinaryExpression, | |
| operator: lex().value, | |
| left: expr, | |
| right: parseMultiplicativeExpression() | |
| }; | |
| } | |
| return expr; | |
| } | |
| // 11.7 Bitwise Shift Operators | |
| function parseShiftExpression() { | |
| var expr = parseAdditiveExpression(); | |
| while (match('<<') || match('>>') || match('>>>')) { | |
| expr = { | |
| type: Syntax.BinaryExpression, | |
| operator: lex().value, | |
| left: expr, | |
| right: parseAdditiveExpression() | |
| }; | |
| } | |
| return expr; | |
| } | |
| // 11.8 Relational Operators | |
| function parseRelationalExpression() { | |
| var expr, previousAllowIn; | |
| previousAllowIn = state.allowIn; | |
| state.allowIn = true; | |
| expr = parseShiftExpression(); | |
| while (match('<') || match('>') || match('<=') || match('>=') || (previousAllowIn && matchKeyword('in')) || matchKeyword('instanceof')) { | |
| expr = { | |
| type: Syntax.BinaryExpression, | |
| operator: lex().value, | |
| left: expr, | |
| right: parseShiftExpression() | |
| }; | |
| } | |
| state.allowIn = previousAllowIn; | |
| return expr; | |
| } | |
| // 11.9 Equality Operators | |
| function parseEqualityExpression() { | |
| var expr = parseRelationalExpression(); | |
| while (match('==') || match('!=') || match('===') || match('!==')) { | |
| expr = { | |
| type: Syntax.BinaryExpression, | |
| operator: lex().value, | |
| left: expr, | |
| right: parseRelationalExpression() | |
| }; | |
| } | |
| return expr; | |
| } | |
| // 11.10 Binary Bitwise Operators | |
| function parseBitwiseANDExpression() { | |
| var expr = parseEqualityExpression(); | |
| while (match('&')) { | |
| lex(); | |
| expr = { | |
| type: Syntax.BinaryExpression, | |
| operator: '&', | |
| left: expr, | |
| right: parseEqualityExpression() | |
| }; | |
| } | |
| return expr; | |
| } | |
| function parseBitwiseXORExpression() { | |
| var expr = parseBitwiseANDExpression(); | |
| while (match('^')) { | |
| lex(); | |
| expr = { | |
| type: Syntax.BinaryExpression, | |
| operator: '^', | |
| left: expr, | |
| right: parseBitwiseANDExpression() | |
| }; | |
| } | |
| return expr; | |
| } | |
| function parseBitwiseORExpression() { | |
| var expr = parseBitwiseXORExpression(); | |
| while (match('|')) { | |
| lex(); | |
| expr = { | |
| type: Syntax.BinaryExpression, | |
| operator: '|', | |
| left: expr, | |
| right: parseBitwiseXORExpression() | |
| }; | |
| } | |
| return expr; | |
| } | |
| // 11.11 Binary Logical Operators | |
| function parseLogicalANDExpression() { | |
| var expr = parseBitwiseORExpression(); | |
| while (match('&&')) { | |
| lex(); | |
| expr = { | |
| type: Syntax.LogicalExpression, | |
| operator: '&&', | |
| left: expr, | |
| right: parseBitwiseORExpression() | |
| }; | |
| } | |
| return expr; | |
| } | |
| function parseLogicalORExpression() { | |
| var expr = parseLogicalANDExpression(); | |
| while (match('||')) { | |
| lex(); | |
| expr = { | |
| type: Syntax.LogicalExpression, | |
| operator: '||', | |
| left: expr, | |
| right: parseLogicalANDExpression() | |
| }; | |
| } | |
| return expr; | |
| } | |
| // 11.12 Conditional Operator | |
| function parseConditionalExpression() { | |
| var expr, previousAllowIn, consequent; | |
| expr = parseLogicalORExpression(); | |
| if (match('?')) { | |
| lex(); | |
| previousAllowIn = state.allowIn; | |
| state.allowIn = true; | |
| consequent = parseAssignmentExpression(); | |
| state.allowIn = previousAllowIn; | |
| expect(':'); | |
| expr = { | |
| type: Syntax.ConditionalExpression, | |
| test: expr, | |
| consequent: consequent, | |
| alternate: parseAssignmentExpression() | |
| }; | |
| } | |
| return expr; | |
| } | |
| // 11.13 Assignment Operators | |
| function parseAssignmentExpression() { | |
| var token, expr; | |
| token = lookahead(); | |
| expr = parseConditionalExpression(); | |
| if (matchAssign()) { | |
| // LeftHandSideExpression | |
| if (!isLeftHandSide(expr)) { | |
| throwErrorTolerant({}, Messages.InvalidLHSInAssignment); | |
| } | |
| // 11.13.1 | |
| if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) { | |
| throwErrorTolerant(token, Messages.StrictLHSAssignment); | |
| } | |
| expr = { | |
| type: Syntax.AssignmentExpression, | |
| operator: lex().value, | |
| left: expr, | |
| right: parseAssignmentExpression() | |
| }; | |
| } | |
| return expr; | |
| } | |
| // 11.14 Comma Operator | |
| function parseExpression() { | |
| var expr = parseAssignmentExpression(); | |
| if (match(',')) { | |
| expr = { | |
| type: Syntax.SequenceExpression, | |
| expressions: [ expr ] | |
| }; | |
| while (index < length) { | |
| if (!match(',')) { | |
| break; | |
| } | |
| lex(); | |
| expr.expressions.push(parseAssignmentExpression()); | |
| } | |
| } | |
| return expr; | |
| } | |
| // 12.1 Block | |
| function parseStatementList() { | |
| var list = [], | |
| statement; | |
| while (index < length) { | |
| if (match('}')) { | |
| break; | |
| } | |
| statement = parseSourceElement(); | |
| if (typeof statement === 'undefined') { | |
| break; | |
| } | |
| list.push(statement); | |
| } | |
| return list; | |
| } | |
| function parseBlock() { | |
| var block; | |
| expect('{'); | |
| block = parseStatementList(); | |
| expect('}'); | |
| return { | |
| type: Syntax.BlockStatement, | |
| body: block | |
| }; | |
| } | |
| // 12.2 Variable Statement | |
| function parseVariableIdentifier() { | |
| var token = lex(); | |
| if (token.type !== Token.Identifier) { | |
| throwUnexpected(token); | |
| } | |
| return { | |
| type: Syntax.Identifier, | |
| name: token.value | |
| }; | |
| } | |
| function parseVariableDeclaration(kind) { | |
| var id = parseVariableIdentifier(), | |
| init = null; | |
| // 12.2.1 | |
| if (strict && isRestrictedWord(id.name)) { | |
| throwErrorTolerant({}, Messages.StrictVarName); | |
| } | |
| if (kind === 'const') { | |
| expect('='); | |
| init = parseAssignmentExpression(); | |
| } else if (match('=')) { | |
| lex(); | |
| init = parseAssignmentExpression(); | |
| } | |
| return { | |
| type: Syntax.VariableDeclarator, | |
| id: id, | |
| init: init | |
| }; | |
| } | |
| function parseVariableDeclarationList(kind) { | |
| var list = []; | |
| do { | |
| list.push(parseVariableDeclaration(kind)); | |
| if (!match(',')) { | |
| break; | |
| } | |
| lex(); | |
| } while (index < length); | |
| return list; | |
| } | |
| function parseVariableStatement() { | |
| var declarations; | |
| expectKeyword('var'); | |
| declarations = parseVariableDeclarationList(); | |
| consumeSemicolon(); | |
| return { | |
| type: Syntax.VariableDeclaration, | |
| declarations: declarations, | |
| kind: 'var' | |
| }; | |
| } | |
| // kind may be `const` or `let` | |
| // Both are experimental and not in the specification yet. | |
| // see http://wiki.ecmascript.org/doku.php?id=harmony:const | |
| // and http://wiki.ecmascript.org/doku.php?id=harmony:let | |
| function parseConstLetDeclaration(kind) { | |
| var declarations; | |
| expectKeyword(kind); | |
| declarations = parseVariableDeclarationList(kind); | |
| consumeSemicolon(); | |
| return { | |
| type: Syntax.VariableDeclaration, | |
| declarations: declarations, | |
| kind: kind | |
| }; | |
| } | |
| // 12.3 Empty Statement | |
| function parseEmptyStatement() { | |
| expect(';'); | |
| return { | |
| type: Syntax.EmptyStatement | |
| }; | |
| } | |
| // 12.4 Expression Statement | |
| function parseExpressionStatement() { | |
| var expr = parseExpression(); | |
| consumeSemicolon(); | |
| return { | |
| type: Syntax.ExpressionStatement, | |
| expression: expr | |
| }; | |
| } | |
| // 12.5 If statement | |
| function parseIfStatement() { | |
| var test, consequent, alternate; | |
| expectKeyword('if'); | |
| expect('('); | |
| test = parseExpression(); | |
| expect(')'); | |
| consequent = parseStatement(); | |
| if (matchKeyword('else')) { | |
| lex(); | |
| alternate = parseStatement(); | |
| } else { | |
| alternate = null; | |
| } | |
| return { | |
| type: Syntax.IfStatement, | |
| test: test, | |
| consequent: consequent, | |
| alternate: alternate | |
| }; | |
| } | |
| // 12.6 Iteration Statements | |
| function parseDoWhileStatement() { | |
| var body, test, oldInIteration; | |
| expectKeyword('do'); | |
| oldInIteration = state.inIteration; | |
| state.inIteration = true; | |
| body = parseStatement(); | |
| state.inIteration = oldInIteration; | |
| expectKeyword('while'); | |
| expect('('); | |
| test = parseExpression(); | |
| expect(')'); | |
| if (match(';')) { | |
| lex(); | |
| } | |
| return { | |
| type: Syntax.DoWhileStatement, | |
| body: body, | |
| test: test | |
| }; | |
| } | |
| function parseWhileStatement() { | |
| var test, body, oldInIteration; | |
| expectKeyword('while'); | |
| expect('('); | |
| test = parseExpression(); | |
| expect(')'); | |
| oldInIteration = state.inIteration; | |
| state.inIteration = true; | |
| body = parseStatement(); | |
| state.inIteration = oldInIteration; | |
| return { | |
| type: Syntax.WhileStatement, | |
| test: test, | |
| body: body | |
| }; | |
| } | |
| function parseForVariableDeclaration() { | |
| var token = lex(); | |
| return { | |
| type: Syntax.VariableDeclaration, | |
| declarations: parseVariableDeclarationList(), | |
| kind: token.value | |
| }; | |
| } | |
| function parseForStatement() { | |
| var init, test, update, left, right, body, oldInIteration; | |
| init = test = update = null; | |
| expectKeyword('for'); | |
| expect('('); | |
| if (match(';')) { | |
| lex(); | |
| } else { | |
| if (matchKeyword('var') || matchKeyword('let')) { | |
| state.allowIn = false; | |
| init = parseForVariableDeclaration(); | |
| state.allowIn = true; | |
| if (init.declarations.length === 1 && matchKeyword('in')) { | |
| lex(); | |
| left = init; | |
| right = parseExpression(); | |
| init = null; | |
| } | |
| } else { | |
| state.allowIn = false; | |
| init = parseExpression(); | |
| state.allowIn = true; | |
| if (matchKeyword('in')) { | |
| // LeftHandSideExpression | |
| if (!isLeftHandSide(init)) { | |
| throwErrorTolerant({}, Messages.InvalidLHSInForIn); | |
| } | |
| lex(); | |
| left = init; | |
| right = parseExpression(); | |
| init = null; | |
| } | |
| } | |
| if (typeof left === 'undefined') { | |
| expect(';'); | |
| } | |
| } | |
| if (typeof left === 'undefined') { | |
| if (!match(';')) { | |
| test = parseExpression(); | |
| } | |
| expect(';'); | |
| if (!match(')')) { | |
| update = parseExpression(); | |
| } | |
| } | |
| expect(')'); | |
| oldInIteration = state.inIteration; | |
| state.inIteration = true; | |
| body = parseStatement(); | |
| state.inIteration = oldInIteration; | |
| if (typeof left === 'undefined') { | |
| return { | |
| type: Syntax.ForStatement, | |
| init: init, | |
| test: test, | |
| update: update, | |
| body: body | |
| }; | |
| } | |
| return { | |
| type: Syntax.ForInStatement, | |
| left: left, | |
| right: right, | |
| body: body, | |
| each: false | |
| }; | |
| } | |
| // 12.7 The continue statement | |
| function parseContinueStatement() { | |
| var token, label = null; | |
| expectKeyword('continue'); | |
| // Optimize the most common form: 'continue;'. | |
| if (source[index] === ';') { | |
| lex(); | |
| if (!state.inIteration) { | |
| throwError({}, Messages.IllegalContinue); | |
| } | |
| return { | |
| type: Syntax.ContinueStatement, | |
| label: null | |
| }; | |
| } | |
| if (peekLineTerminator()) { | |
| if (!state.inIteration) { | |
| throwError({}, Messages.IllegalContinue); | |
| } | |
| return { | |
| type: Syntax.ContinueStatement, | |
| label: null | |
| }; | |
| } | |
| token = lookahead(); | |
| if (token.type === Token.Identifier) { | |
| label = parseVariableIdentifier(); | |
| if (!Object.prototype.hasOwnProperty.call(state.labelSet, label.name)) { | |
| throwError({}, Messages.UnknownLabel, label.name); | |
| } | |
| } | |
| consumeSemicolon(); | |
| if (label === null && !state.inIteration) { | |
| throwError({}, Messages.IllegalContinue); | |
| } | |
| return { | |
| type: Syntax.ContinueStatement, | |
| label: label | |
| }; | |
| } | |
| // 12.8 The break statement | |
| function parseBreakStatement() { | |
| var token, label = null; | |
| expectKeyword('break'); | |
| // Optimize the most common form: 'break;'. | |
| if (source[index] === ';') { | |
| lex(); | |
| if (!(state.inIteration || state.inSwitch)) { | |
| throwError({}, Messages.IllegalBreak); | |
| } | |
| return { | |
| type: Syntax.BreakStatement, | |
| label: null | |
| }; | |
| } | |
| if (peekLineTerminator()) { | |
| if (!(state.inIteration || state.inSwitch)) { | |
| throwError({}, Messages.IllegalBreak); | |
| } | |
| return { | |
| type: Syntax.BreakStatement, | |
| label: null | |
| }; | |
| } | |
| token = lookahead(); | |
| if (token.type === Token.Identifier) { | |
| label = parseVariableIdentifier(); | |
| if (!Object.prototype.hasOwnProperty.call(state.labelSet, label.name)) { | |
| throwError({}, Messages.UnknownLabel, label.name); | |
| } | |
| } | |
| consumeSemicolon(); | |
| if (label === null && !(state.inIteration || state.inSwitch)) { | |
| throwError({}, Messages.IllegalBreak); | |
| } | |
| return { | |
| type: Syntax.BreakStatement, | |
| label: label | |
| }; | |
| } | |
| // 12.9 The return statement | |
| function parseReturnStatement() { | |
| var token, argument = null; | |
| expectKeyword('return'); | |
| if (!state.inFunctionBody) { | |
| throwErrorTolerant({}, Messages.IllegalReturn); | |
| } | |
| // 'return' followed by a space and an identifier is very common. | |
| if (source[index] === ' ') { | |
| if (isIdentifierStart(source[index + 1])) { | |
| argument = parseExpression(); | |
| consumeSemicolon(); | |
| return { | |
| type: Syntax.ReturnStatement, | |
| argument: argument | |
| }; | |
| } | |
| } | |
| if (peekLineTerminator()) { | |
| return { | |
| type: Syntax.ReturnStatement, | |
| argument: null | |
| }; | |
| } | |
| if (!match(';')) { | |
| token = lookahead(); | |
| if (!match('}') && token.type !== Token.EOF) { | |
| argument = parseExpression(); | |
| } | |
| } | |
| consumeSemicolon(); | |
| return { | |
| type: Syntax.ReturnStatement, | |
| argument: argument | |
| }; | |
| } | |
| // 12.10 The with statement | |
| function parseWithStatement() { | |
| var object, body; | |
| if (strict) { | |
| throwErrorTolerant({}, Messages.StrictModeWith); | |
| } | |
| expectKeyword('with'); | |
| expect('('); | |
| object = parseExpression(); | |
| expect(')'); | |
| body = parseStatement(); | |
| return { | |
| type: Syntax.WithStatement, | |
| object: object, | |
| body: body | |
| }; | |
| } | |
| // 12.10 The swith statement | |
| function parseSwitchCase() { | |
| var test, | |
| consequent = [], | |
| statement; | |
| if (matchKeyword('default')) { | |
| lex(); | |
| test = null; | |
| } else { | |
| expectKeyword('case'); | |
| test = parseExpression(); | |
| } | |
| expect(':'); | |
| while (index < length) { | |
| if (match('}') || matchKeyword('default') || matchKeyword('case')) { | |
| break; | |
| } | |
| statement = parseStatement(); | |
| if (typeof statement === 'undefined') { | |
| break; | |
| } | |
| consequent.push(statement); | |
| } | |
| return { | |
| type: Syntax.SwitchCase, | |
| test: test, | |
| consequent: consequent | |
| }; | |
| } | |
| function parseSwitchStatement() { | |
| var discriminant, cases, clause, oldInSwitch, defaultFound; | |
| expectKeyword('switch'); | |
| expect('('); | |
| discriminant = parseExpression(); | |
| expect(')'); | |
| expect('{'); | |
| cases = []; | |
| if (match('}')) { | |
| lex(); | |
| return { | |
| type: Syntax.SwitchStatement, | |
| discriminant: discriminant, | |
| cases: cases | |
| }; | |
| } | |
| oldInSwitch = state.inSwitch; | |
| state.inSwitch = true; | |
| defaultFound = false; | |
| while (index < length) { | |
| if (match('}')) { | |
| break; | |
| } | |
| clause = parseSwitchCase(); | |
| if (clause.test === null) { | |
| if (defaultFound) { | |
| throwError({}, Messages.MultipleDefaultsInSwitch); | |
| } | |
| defaultFound = true; | |
| } | |
| cases.push(clause); | |
| } | |
| state.inSwitch = oldInSwitch; | |
| expect('}'); | |
| return { | |
| type: Syntax.SwitchStatement, | |
| discriminant: discriminant, | |
| cases: cases | |
| }; | |
| } | |
| // 12.13 The throw statement | |
| function parseThrowStatement() { | |
| var argument; | |
| expectKeyword('throw'); | |
| if (peekLineTerminator()) { | |
| throwError({}, Messages.NewlineAfterThrow); | |
| } | |
| argument = parseExpression(); | |
| consumeSemicolon(); | |
| return { | |
| type: Syntax.ThrowStatement, | |
| argument: argument | |
| }; | |
| } | |
| // 12.14 The try statement | |
| function parseCatchClause() { | |
| var param; | |
| expectKeyword('catch'); | |
| expect('('); | |
| if (match(')')) { | |
| throwUnexpected(lookahead()); | |
| } | |
| param = parseVariableIdentifier(); | |
| // 12.14.1 | |
| if (strict && isRestrictedWord(param.name)) { | |
| throwErrorTolerant({}, Messages.StrictCatchVariable); | |
| } | |
| expect(')'); | |
| return { | |
| type: Syntax.CatchClause, | |
| param: param, | |
| body: parseBlock() | |
| }; | |
| } | |
| function parseTryStatement() { | |
| var block, handlers = [], finalizer = null; | |
| expectKeyword('try'); | |
| block = parseBlock(); | |
| if (matchKeyword('catch')) { | |
| handlers.push(parseCatchClause()); | |
| } | |
| if (matchKeyword('finally')) { | |
| lex(); | |
| finalizer = parseBlock(); | |
| } | |
| if (handlers.length === 0 && !finalizer) { | |
| throwError({}, Messages.NoCatchOrFinally); | |
| } | |
| return { | |
| type: Syntax.TryStatement, | |
| block: block, | |
View raw
(Sorry about that, but we can’t show files that are this big right now.)
View raw
(Sorry about that, but we can’t show files that are this big right now.)
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment