@loaders.gl/json 3.1.0-beta.5 → 3.1.2

package/dist/es5/lib/clarinet/clarinet.js

@@ -7,9 +7,17 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
-const MAX_BUFFER_LENGTH = Number.MAX_SAFE_INTEGER;
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var MAX_BUFFER_LENGTH = Number.MAX_SAFE_INTEGER;
 var STATE;
 
 (function (STATE) {
@@ -39,7 +47,7 @@ var STATE;
   STATE[STATE["NUMBER_DIGIT"] = 23] = "NUMBER_DIGIT";
 })(STATE || (STATE = {}));
 
-const Char = {
+var Char = {
   tab: 0x09,
   lineFeed: 0x0a,
   carriageReturn: 0x0d,
@@ -69,22 +77,24 @@ const Char = {
   openBrace: 0x7b,
   closeBrace: 0x7d
 };
-const stringTokenPattern = /[\\"\n]/g;
-const DEFAULT_OPTIONS = {
-  onready: () => {},
-  onopenobject: () => {},
-  onkey: () => {},
-  oncloseobject: () => {},
-  onopenarray: () => {},
-  onclosearray: () => {},
-  onvalue: () => {},
-  onerror: () => {},
-  onend: () => {},
-  onchunkparsed: () => {}
+var stringTokenPattern = /[\\"\n]/g;
+var DEFAULT_OPTIONS = {
+  onready: function onready() {},
+  onopenobject: function onopenobject() {},
+  onkey: function onkey() {},
+  oncloseobject: function oncloseobject() {},
+  onopenarray: function onopenarray() {},
+  onclosearray: function onclosearray() {},
+  onvalue: function onvalue() {},
+  onerror: function onerror() {},
+  onend: function onend() {},
+  onchunkparsed: function onchunkparsed() {}
 };
 
-class ClarinetParser {
-  constructor(options = {}) {
+var ClarinetParser = function () {
+  function ClarinetParser() {
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    (0, _classCallCheck2.default)(this, ClarinetParser);
     (0, _defineProperty2.default)(this, "options", DEFAULT_OPTIONS);
     (0, _defineProperty2.default)(this, "bufferCheckPosition", MAX_BUFFER_LENGTH);
     (0, _defineProperty2.default)(this, "q", '');
@@ -105,379 +115,392 @@ class ClarinetParser {
     (0, _defineProperty2.default)(this, "depth", 0);
     (0, _defineProperty2.default)(this, "textNode", void 0);
     (0, _defineProperty2.default)(this, "numberNode", void 0);
-    this.options = { ...DEFAULT_OPTIONS,
-      ...options
-    };
+    this.options = _objectSpread(_objectSpread({}, DEFAULT_OPTIONS), options);
     this.textNode = undefined;
     this.numberNode = '';
     this.emit('onready');
   }
 
-  end() {
-    if (this.state !== STATE.VALUE || this.depth !== 0) this._error('Unexpected end');
+  (0, _createClass2.default)(ClarinetParser, [{
+    key: "end",
+    value: function end() {
+      if (this.state !== STATE.VALUE || this.depth !== 0) this._error('Unexpected end');
 
-    this._closeValue();
+      this._closeValue();
 
-    this.c = '';
-    this.closed = true;
-    this.emit('onend');
-    return this;
-  }
+      this.c = '';
+      this.closed = true;
+      this.emit('onend');
+      return this;
+    }
+  }, {
+    key: "resume",
+    value: function resume() {
+      this.error = null;
+      return this;
+    }
+  }, {
+    key: "close",
+    value: function close() {
+      return this.write(null);
+    }
+  }, {
+    key: "emit",
+    value: function emit(event, data) {
+      var _this$options$event, _this$options;
 
-  resume() {
-    this.error = null;
-    return this;
-  }
+      (_this$options$event = (_this$options = this.options)[event]) === null || _this$options$event === void 0 ? void 0 : _this$options$event.call(_this$options, data, this);
+    }
+  }, {
+    key: "emitNode",
+    value: function emitNode(event, data) {
+      this._closeValue();
 
-  close() {
-    return this.write(null);
-  }
+      this.emit(event, data);
+    }
+  }, {
+    key: "write",
+    value: function write(chunk) {
+      if (this.error) {
+        throw this.error;
+      }
 
-  emit(event, data) {
-    var _this$options$event, _this$options;
+      if (this.closed) {
+        return this._error('Cannot write after close. Assign an onready handler.');
+      }
 
-    (_this$options$event = (_this$options = this.options)[event]) === null || _this$options$event === void 0 ? void 0 : _this$options$event.call(_this$options, data, this);
-  }
+      if (chunk === null) {
+        return this.end();
+      }
 
-  emitNode(event, data) {
-    this._closeValue();
+      var i = 0;
+      var c = chunk.charCodeAt(0);
+      var p = this.p;
 
-    this.emit(event, data);
-  }
+      while (c) {
+        p = c;
+        this.c = c = chunk.charCodeAt(i++);
 
-  write(chunk) {
-    if (this.error) {
-      throw this.error;
-    }
+        if (p !== c) {
+          this.p = p;
+        } else {
+          p = this.p;
+        }
 
-    if (this.closed) {
-      return this._error('Cannot write after close. Assign an onready handler.');
-    }
+        if (!c) break;
+        this.position++;
 
-    if (chunk === null) {
-      return this.end();
-    }
+        if (c === Char.lineFeed) {
+          this.line++;
+          this.column = 0;
+        } else this.column++;
 
-    let i = 0;
-    let c = chunk.charCodeAt(0);
-    let p = this.p;
+        switch (this.state) {
+          case STATE.BEGIN:
+            if (c === Char.openBrace) this.state = STATE.OPEN_OBJECT;else if (c === Char.openBracket) this.state = STATE.OPEN_ARRAY;else if (!isWhitespace(c)) {
+              this._error('Non-whitespace before {[.');
+            }
+            continue;
 
-    while (c) {
-      p = c;
-      this.c = c = chunk.charCodeAt(i++);
+          case STATE.OPEN_KEY:
+          case STATE.OPEN_OBJECT:
+            if (isWhitespace(c)) continue;
+            if (this.state === STATE.OPEN_KEY) this.stack.push(STATE.CLOSE_KEY);else if (c === Char.closeBrace) {
+              this.emit('onopenobject');
+              this.depth++;
+              this.emit('oncloseobject');
+              this.depth--;
+              this.state = this.stack.pop() || STATE.VALUE;
+              continue;
+            } else this.stack.push(STATE.CLOSE_OBJECT);
+            if (c === Char.doubleQuote) this.state = STATE.STRING;else this._error('Malformed object key should start with "');
+            continue;
 
-      if (p !== c) {
-        this.p = p;
-      } else {
-        p = this.p;
-      }
+          case STATE.CLOSE_KEY:
+          case STATE.CLOSE_OBJECT:
+            if (isWhitespace(c)) continue;
 
-      if (!c) break;
-      this.position++;
-
-      if (c === Char.lineFeed) {
-        this.line++;
-        this.column = 0;
-      } else this.column++;
-
-      switch (this.state) {
-        case STATE.BEGIN:
-          if (c === Char.openBrace) this.state = STATE.OPEN_OBJECT;else if (c === Char.openBracket) this.state = STATE.OPEN_ARRAY;else if (!isWhitespace(c)) {
-            this._error('Non-whitespace before {[.');
-          }
-          continue;
-
-        case STATE.OPEN_KEY:
-        case STATE.OPEN_OBJECT:
-          if (isWhitespace(c)) continue;
-          if (this.state === STATE.OPEN_KEY) this.stack.push(STATE.CLOSE_KEY);else if (c === Char.closeBrace) {
-            this.emit('onopenobject');
-            this.depth++;
-            this.emit('oncloseobject');
-            this.depth--;
-            this.state = this.stack.pop() || STATE.VALUE;
-            continue;
-          } else this.stack.push(STATE.CLOSE_OBJECT);
-          if (c === Char.doubleQuote) this.state = STATE.STRING;else this._error('Malformed object key should start with "');
-          continue;
+            if (c === Char.colon) {
+              if (this.state === STATE.CLOSE_OBJECT) {
+                this.stack.push(STATE.CLOSE_OBJECT);
 
-        case STATE.CLOSE_KEY:
-        case STATE.CLOSE_OBJECT:
-          if (isWhitespace(c)) continue;
+                this._closeValue('onopenobject');
 
-          if (c === Char.colon) {
-            if (this.state === STATE.CLOSE_OBJECT) {
-              this.stack.push(STATE.CLOSE_OBJECT);
+                this.depth++;
+              } else this._closeValue('onkey');
 
-              this._closeValue('onopenobject');
+              this.state = STATE.VALUE;
+            } else if (c === Char.closeBrace) {
+              this.emitNode('oncloseobject');
+              this.depth--;
+              this.state = this.stack.pop() || STATE.VALUE;
+            } else if (c === Char.comma) {
+              if (this.state === STATE.CLOSE_OBJECT) this.stack.push(STATE.CLOSE_OBJECT);
 
-              this.depth++;
-            } else this._closeValue('onkey');
+              this._closeValue();
+
+              this.state = STATE.OPEN_KEY;
+            } else this._error('Bad object');
+
+            continue;
 
-            this.state = STATE.VALUE;
-          } else if (c === Char.closeBrace) {
-            this.emitNode('oncloseobject');
-            this.depth--;
-            this.state = this.stack.pop() || STATE.VALUE;
-          } else if (c === Char.comma) {
-            if (this.state === STATE.CLOSE_OBJECT) this.stack.push(STATE.CLOSE_OBJECT);
+          case STATE.OPEN_ARRAY:
+          case STATE.VALUE:
+            if (isWhitespace(c)) continue;
 
-            this._closeValue();
+            if (this.state === STATE.OPEN_ARRAY) {
+              this.emit('onopenarray');
+              this.depth++;
+              this.state = STATE.VALUE;
 
-            this.state = STATE.OPEN_KEY;
-          } else this._error('Bad object');
+              if (c === Char.closeBracket) {
+                this.emit('onclosearray');
+                this.depth--;
+                this.state = this.stack.pop() || STATE.VALUE;
+                continue;
+              } else {
+                this.stack.push(STATE.CLOSE_ARRAY);
+              }
+            }
 
-          continue;
+            if (c === Char.doubleQuote) this.state = STATE.STRING;else if (c === Char.openBrace) this.state = STATE.OPEN_OBJECT;else if (c === Char.openBracket) this.state = STATE.OPEN_ARRAY;else if (c === Char.t) this.state = STATE.TRUE;else if (c === Char.f) this.state = STATE.FALSE;else if (c === Char.n) this.state = STATE.NULL;else if (c === Char.minus) {
+              this.numberNode += '-';
+            } else if (Char._0 <= c && c <= Char._9) {
+              this.numberNode += String.fromCharCode(c);
+              this.state = STATE.NUMBER_DIGIT;
+            } else this._error('Bad value');
+            continue;
 
-        case STATE.OPEN_ARRAY:
-        case STATE.VALUE:
-          if (isWhitespace(c)) continue;
+          case STATE.CLOSE_ARRAY:
+            if (c === Char.comma) {
+              this.stack.push(STATE.CLOSE_ARRAY);
 
-          if (this.state === STATE.OPEN_ARRAY) {
-            this.emit('onopenarray');
-            this.depth++;
-            this.state = STATE.VALUE;
+              this._closeValue('onvalue');
 
-            if (c === Char.closeBracket) {
-              this.emit('onclosearray');
+              this.state = STATE.VALUE;
+            } else if (c === Char.closeBracket) {
+              this.emitNode('onclosearray');
               this.depth--;
               this.state = this.stack.pop() || STATE.VALUE;
-              continue;
-            } else {
-              this.stack.push(STATE.CLOSE_ARRAY);
+            } else if (isWhitespace(c)) continue;else this._error('Bad array');
+
+            continue;
+
+          case STATE.STRING:
+            if (this.textNode === undefined) {
+              this.textNode = '';
             }
-          }
-
-          if (c === Char.doubleQuote) this.state = STATE.STRING;else if (c === Char.openBrace) this.state = STATE.OPEN_OBJECT;else if (c === Char.openBracket) this.state = STATE.OPEN_ARRAY;else if (c === Char.t) this.state = STATE.TRUE;else if (c === Char.f) this.state = STATE.FALSE;else if (c === Char.n) this.state = STATE.NULL;else if (c === Char.minus) {
-            this.numberNode += '-';
-          } else if (Char._0 <= c && c <= Char._9) {
-            this.numberNode += String.fromCharCode(c);
-            this.state = STATE.NUMBER_DIGIT;
-          } else this._error('Bad value');
-          continue;
-
-        case STATE.CLOSE_ARRAY:
-          if (c === Char.comma) {
-            this.stack.push(STATE.CLOSE_ARRAY);
-
-            this._closeValue('onvalue');
-
-            this.state = STATE.VALUE;
-          } else if (c === Char.closeBracket) {
-            this.emitNode('onclosearray');
-            this.depth--;
-            this.state = this.stack.pop() || STATE.VALUE;
-          } else if (isWhitespace(c)) continue;else this._error('Bad array');
-
-          continue;
-
-        case STATE.STRING:
-          if (this.textNode === undefined) {
-            this.textNode = '';
-          }
-
-          let starti = i - 1;
-          let slashed = this.slashed;
-          let unicodeI = this.unicodeI;
-
-          STRING_BIGLOOP: while (true) {
-            while (unicodeI > 0) {
-              this.unicodeS += String.fromCharCode(c);
-              c = chunk.charCodeAt(i++);
-              this.position++;
-
-              if (unicodeI === 4) {
-                this.textNode += String.fromCharCode(parseInt(this.unicodeS, 16));
-                unicodeI = 0;
+
+            var starti = i - 1;
+            var slashed = this.slashed;
+            var unicodeI = this.unicodeI;
+
+            STRING_BIGLOOP: while (true) {
+              while (unicodeI > 0) {
+                this.unicodeS += String.fromCharCode(c);
+                c = chunk.charCodeAt(i++);
+                this.position++;
+
+                if (unicodeI === 4) {
+                  this.textNode += String.fromCharCode(parseInt(this.unicodeS, 16));
+                  unicodeI = 0;
+                  starti = i - 1;
+                } else {
+                  unicodeI++;
+                }
+
+                if (!c) break STRING_BIGLOOP;
+              }
+
+              if (c === Char.doubleQuote && !slashed) {
+                this.state = this.stack.pop() || STATE.VALUE;
+                this.textNode += chunk.substring(starti, i - 1);
+                this.position += i - 1 - starti;
+                break;
+              }
+
+              if (c === Char.backslash && !slashed) {
+                slashed = true;
+                this.textNode += chunk.substring(starti, i - 1);
+                this.position += i - 1 - starti;
+                c = chunk.charCodeAt(i++);
+                this.position++;
+                if (!c) break;
+              }
+
+              if (slashed) {
+                slashed = false;
+
+                if (c === Char.n) {
+                  this.textNode += '\n';
+                } else if (c === Char.r) {
+                  this.textNode += '\r';
+                } else if (c === Char.t) {
+                  this.textNode += '\t';
+                } else if (c === Char.f) {
+                  this.textNode += '\f';
+                } else if (c === Char.b) {
+                  this.textNode += '\b';
+                } else if (c === Char.u) {
+                  unicodeI = 1;
+                  this.unicodeS = '';
+                } else {
+                  this.textNode += String.fromCharCode(c);
+                }
+
+                c = chunk.charCodeAt(i++);
+                this.position++;
                 starti = i - 1;
-              } else {
-                unicodeI++;
+                if (!c) break;else continue;
               }
 
-              if (!c) break STRING_BIGLOOP;
+              stringTokenPattern.lastIndex = i;
+              var reResult = stringTokenPattern.exec(chunk);
+
+              if (reResult === null) {
+                i = chunk.length + 1;
+                this.textNode += chunk.substring(starti, i - 1);
+                this.position += i - 1 - starti;
+                break;
+              }
+
+              i = reResult.index + 1;
+              c = chunk.charCodeAt(reResult.index);
+
+              if (!c) {
+                this.textNode += chunk.substring(starti, i - 1);
+                this.position += i - 1 - starti;
+                break;
+              }
             }
 
-            if (c === Char.doubleQuote && !slashed) {
+            this.slashed = slashed;
+            this.unicodeI = unicodeI;
+            continue;
+
+          case STATE.TRUE:
+            if (c === Char.r) this.state = STATE.TRUE2;else this._error("Invalid true started with t".concat(c));
+            continue;
+
+          case STATE.TRUE2:
+            if (c === Char.u) this.state = STATE.TRUE3;else this._error("Invalid true started with tr".concat(c));
+            continue;
+
+          case STATE.TRUE3:
+            if (c === Char.e) {
+              this.emit('onvalue', true);
               this.state = this.stack.pop() || STATE.VALUE;
-              this.textNode += chunk.substring(starti, i - 1);
-              this.position += i - 1 - starti;
-              break;
-            }
+            } else this._error("Invalid true started with tru".concat(c));
 
-            if (c === Char.backslash && !slashed) {
-              slashed = true;
-              this.textNode += chunk.substring(starti, i - 1);
-              this.position += i - 1 - starti;
-              c = chunk.charCodeAt(i++);
-              this.position++;
-              if (!c) break;
-            }
+            continue;
 
-            if (slashed) {
-              slashed = false;
-
-              if (c === Char.n) {
-                this.textNode += '\n';
-              } else if (c === Char.r) {
-                this.textNode += '\r';
-              } else if (c === Char.t) {
-                this.textNode += '\t';
-              } else if (c === Char.f) {
-                this.textNode += '\f';
-              } else if (c === Char.b) {
-                this.textNode += '\b';
-              } else if (c === Char.u) {
-                unicodeI = 1;
-                this.unicodeS = '';
-              } else {
-                this.textNode += String.fromCharCode(c);
-              }
+          case STATE.FALSE:
+            if (c === Char.a) this.state = STATE.FALSE2;else this._error("Invalid false started with f".concat(c));
+            continue;
 
-              c = chunk.charCodeAt(i++);
-              this.position++;
-              starti = i - 1;
-              if (!c) break;else continue;
-            }
+          case STATE.FALSE2:
+            if (c === Char.l) this.state = STATE.FALSE3;else this._error("Invalid false started with fa".concat(c));
+            continue;
 
-            stringTokenPattern.lastIndex = i;
-            const reResult = stringTokenPattern.exec(chunk);
+          case STATE.FALSE3:
+            if (c === Char.s) this.state = STATE.FALSE4;else this._error("Invalid false started with fal".concat(c));
+            continue;
 
-            if (reResult === null) {
-              i = chunk.length + 1;
-              this.textNode += chunk.substring(starti, i - 1);
-              this.position += i - 1 - starti;
-              break;
-            }
+          case STATE.FALSE4:
+            if (c === Char.e) {
+              this.emit('onvalue', false);
+              this.state = this.stack.pop() || STATE.VALUE;
+            } else this._error("Invalid false started with fals".concat(c));
+
+            continue;
 
-            i = reResult.index + 1;
-            c = chunk.charCodeAt(reResult.index);
+          case STATE.NULL:
+            if (c === Char.u) this.state = STATE.NULL2;else this._error("Invalid null started with n".concat(c));
+            continue;
 
-            if (!c) {
-              this.textNode += chunk.substring(starti, i - 1);
-              this.position += i - 1 - starti;
-              break;
+          case STATE.NULL2:
+            if (c === Char.l) this.state = STATE.NULL3;else this._error("Invalid null started with nu".concat(c));
+            continue;
+
+          case STATE.NULL3:
+            if (c === Char.l) {
+              this.emit('onvalue', null);
+              this.state = this.stack.pop() || STATE.VALUE;
+            } else this._error("Invalid null started with nul".concat(c));
+
+            continue;
+
+          case STATE.NUMBER_DECIMAL_POINT:
+            if (c === Char.period) {
+              this.numberNode += '.';
+              this.state = STATE.NUMBER_DIGIT;
+            } else this._error('Leading zero not followed by .');
+
+            continue;
+
+          case STATE.NUMBER_DIGIT:
+            if (Char._0 <= c && c <= Char._9) this.numberNode += String.fromCharCode(c);else if (c === Char.period) {
+              if (this.numberNode.indexOf('.') !== -1) this._error('Invalid number has two dots');
+              this.numberNode += '.';
+            } else if (c === Char.e || c === Char.E) {
+              if (this.numberNode.indexOf('e') !== -1 || this.numberNode.indexOf('E') !== -1) this._error('Invalid number has two exponential');
+              this.numberNode += 'e';
+            } else if (c === Char.plus || c === Char.minus) {
+              if (!(p === Char.e || p === Char.E)) this._error('Invalid symbol in number');
+              this.numberNode += String.fromCharCode(c);
+            } else {
+              this._closeNumber();
+
+              i--;
+              this.state = this.stack.pop() || STATE.VALUE;
             }
-          }
-
-          this.slashed = slashed;
-          this.unicodeI = unicodeI;
-          continue;
-
-        case STATE.TRUE:
-          if (c === Char.r) this.state = STATE.TRUE2;else this._error("Invalid true started with t".concat(c));
-          continue;
-
-        case STATE.TRUE2:
-          if (c === Char.u) this.state = STATE.TRUE3;else this._error("Invalid true started with tr".concat(c));
-          continue;
-
-        case STATE.TRUE3:
-          if (c === Char.e) {
-            this.emit('onvalue', true);
-            this.state = this.stack.pop() || STATE.VALUE;
-          } else this._error("Invalid true started with tru".concat(c));
-
-          continue;
-
-        case STATE.FALSE:
-          if (c === Char.a) this.state = STATE.FALSE2;else this._error("Invalid false started with f".concat(c));
-          continue;
-
-        case STATE.FALSE2:
-          if (c === Char.l) this.state = STATE.FALSE3;else this._error("Invalid false started with fa".concat(c));
-          continue;
-
-        case STATE.FALSE3:
-          if (c === Char.s) this.state = STATE.FALSE4;else this._error("Invalid false started with fal".concat(c));
-          continue;
-
-        case STATE.FALSE4:
-          if (c === Char.e) {
-            this.emit('onvalue', false);
-            this.state = this.stack.pop() || STATE.VALUE;
-          } else this._error("Invalid false started with fals".concat(c));
-
-          continue;
-
-        case STATE.NULL:
-          if (c === Char.u) this.state = STATE.NULL2;else this._error("Invalid null started with n".concat(c));
-          continue;
-
-        case STATE.NULL2:
-          if (c === Char.l) this.state = STATE.NULL3;else this._error("Invalid null started with nu".concat(c));
-          continue;
-
-        case STATE.NULL3:
-          if (c === Char.l) {
-            this.emit('onvalue', null);
-            this.state = this.stack.pop() || STATE.VALUE;
-          } else this._error("Invalid null started with nul".concat(c));
-
-          continue;
-
-        case STATE.NUMBER_DECIMAL_POINT:
-          if (c === Char.period) {
-            this.numberNode += '.';
-            this.state = STATE.NUMBER_DIGIT;
-          } else this._error('Leading zero not followed by .');
-
-          continue;
-
-        case STATE.NUMBER_DIGIT:
-          if (Char._0 <= c && c <= Char._9) this.numberNode += String.fromCharCode(c);else if (c === Char.period) {
-            if (this.numberNode.indexOf('.') !== -1) this._error('Invalid number has two dots');
-            this.numberNode += '.';
-          } else if (c === Char.e || c === Char.E) {
-            if (this.numberNode.indexOf('e') !== -1 || this.numberNode.indexOf('E') !== -1) this._error('Invalid number has two exponential');
-            this.numberNode += 'e';
-          } else if (c === Char.plus || c === Char.minus) {
-            if (!(p === Char.e || p === Char.E)) this._error('Invalid symbol in number');
-            this.numberNode += String.fromCharCode(c);
-          } else {
-            this._closeNumber();
-
-            i--;
-            this.state = this.stack.pop() || STATE.VALUE;
-          }
-          continue;
+            continue;
 
-        default:
-          this._error("Unknown state: ".concat(this.state));
+          default:
+            this._error("Unknown state: ".concat(this.state));
 
+        }
       }
-    }
-
-    if (this.position >= this.bufferCheckPosition) {
-      checkBufferLength(this);
-    }
 
-    this.emit('onchunkparsed');
-    return this;
-  }
+      if (this.position >= this.bufferCheckPosition) {
+        checkBufferLength(this);
+      }
 
-  _closeValue(event = 'onvalue') {
-    if (this.textNode !== undefined) {
-      this.emit(event, this.textNode);
+      this.emit('onchunkparsed');
+      return this;
     }
+  }, {
+    key: "_closeValue",
+    value: function _closeValue() {
+      var event = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'onvalue';
 
-    this.textNode = undefined;
-  }
-
-  _closeNumber() {
-    if (this.numberNode) this.emit('onvalue', parseFloat(this.numberNode));
-    this.numberNode = '';
-  }
+      if (this.textNode !== undefined) {
+        this.emit(event, this.textNode);
+      }
 
-  _error(message = '') {
-    this._closeValue();
+      this.textNode = undefined;
+    }
+  }, {
+    key: "_closeNumber",
+    value: function _closeNumber() {
+      if (this.numberNode) this.emit('onvalue', parseFloat(this.numberNode));
+      this.numberNode = '';
+    }
+  }, {
+    key: "_error",
+    value: function _error() {
+      var message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
 
-    message += "\nLine: ".concat(this.line, "\nColumn: ").concat(this.column, "\nChar: ").concat(this.c);
-    const error = new Error(message);
-    this.error = error;
-    this.emit('onerror', error);
-  }
+      this._closeValue();
 
-}
+      message += "\nLine: ".concat(this.line, "\nColumn: ").concat(this.column, "\nChar: ").concat(this.c);
+      var error = new Error(message);
+      this.error = error;
+      this.emit('onerror', error);
+    }
+  }]);
+  return ClarinetParser;
+}();
 
 exports.default = ClarinetParser;
 
@@ -486,11 +509,12 @@ function isWhitespace(c) {
 }
 
 function checkBufferLength(parser) {
-  const maxAllowed = Math.max(MAX_BUFFER_LENGTH, 10);
-  let maxActual = 0;
+  var maxAllowed = Math.max(MAX_BUFFER_LENGTH, 10);
+  var maxActual = 0;
 
-  for (const buffer of ['textNode', 'numberNode']) {
-    const len = parser[buffer] === undefined ? 0 : parser[buffer].length;
+  for (var _i = 0, _arr = ['textNode', 'numberNode']; _i < _arr.length; _i++) {
+    var buffer = _arr[_i];
+    var len = parser[buffer] === undefined ? 0 : parser[buffer].length;
 
     if (len > maxAllowed) {
       switch (buffer) {