@loaders.gl/json 3.0.13 → 3.0.14

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

@@ -1,20 +1,27 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = exports.EVENTS = void 0;
-const env = {};
-const EVENTS = ['value', 'string', 'key', 'openobject', 'closeobject', 'openarray', 'closearray', 'error', 'end', 'ready'];
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var env = {};
+var EVENTS = ['value', 'string', 'key', 'openobject', 'closeobject', 'openarray', 'closearray', 'error', 'end', 'ready'];
 exports.EVENTS = EVENTS;
-const MAX_BUFFER_LENGTH = Number.MAX_SAFE_INTEGER;
-const DEBUG = env.CDEBUG === 'debug';
-const buffers = {
+var MAX_BUFFER_LENGTH = Number.MAX_SAFE_INTEGER;
+var DEBUG = env.CDEBUG === 'debug';
+var buffers = {
   textNode: undefined,
   numberNode: ''
 };
-let S = 0;
-const STATE = {
+var S = 0;
+var STATE = {
   BEGIN: S++,
   VALUE: S++,
   OPEN_OBJECT: S++,
@@ -41,10 +48,12 @@ const STATE = {
   NUMBER_DIGIT: S++
 };
 
-for (var s_ in STATE) STATE[STATE[s_]] = s_;
+for (var s_ in STATE) {
+  STATE[STATE[s_]] = s_;
+}
 
 S = STATE;
-const Char = {
+var Char = {
   tab: 0x09,
   lineFeed: 0x0a,
   carriageReturn: 0x0d,
@@ -76,8 +85,8 @@ const Char = {
 };
 
 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 (var buffer in buffers) {
     var len = parser[buffer] === undefined ? 0 : parser[buffer].length;
@@ -101,413 +110,424 @@ function checkBufferLength(parser) {
 
 var stringTokenPattern = /[\\"\n]/g;
 
-class ClarinetParser {
-  constructor(options = {}) {
+var ClarinetParser = function () {
+  function ClarinetParser() {
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    (0, _classCallCheck2.default)(this, ClarinetParser);
+
     this._initialize(options);
   }
 
-  _initialize(options) {
-    this._clearBuffers(this);
-
-    this.bufferCheckPosition = MAX_BUFFER_LENGTH;
-    this.q = '';
-    this.c = '';
-    this.p = '';
-    this.options = options || {};
-    this.closed = false;
-    this.closedRoot = false;
-    this.sawRoot = false;
-    this.tag = null;
-    this.error = null;
-    this.state = S.BEGIN;
-    this.stack = new Array();
-    this.position = this.column = 0;
-    this.line = 1;
-    this.slashed = false;
-    this.unicodeI = 0;
-    this.unicodeS = null;
-    this.depth = 0;
-
-    if ('onready' in options) {
-      this.onready = options.onready;
-    }
-
-    if ('onopenobject' in options) {
-      this.onopenobject = options.onopenobject;
-    }
+  (0, _createClass2.default)(ClarinetParser, [{
+    key: "_initialize",
+    value: function _initialize(options) {
+      this._clearBuffers(this);
+
+      this.bufferCheckPosition = MAX_BUFFER_LENGTH;
+      this.q = '';
+      this.c = '';
+      this.p = '';
+      this.options = options || {};
+      this.closed = false;
+      this.closedRoot = false;
+      this.sawRoot = false;
+      this.tag = null;
+      this.error = null;
+      this.state = S.BEGIN;
+      this.stack = new Array();
+      this.position = this.column = 0;
+      this.line = 1;
+      this.slashed = false;
+      this.unicodeI = 0;
+      this.unicodeS = null;
+      this.depth = 0;
+
+      if ('onready' in options) {
+        this.onready = options.onready;
+      }
 
-    if ('onkey' in options) {
-      this.onkey = options.onkey;
-    }
+      if ('onopenobject' in options) {
+        this.onopenobject = options.onopenobject;
+      }
 
-    if ('oncloseobject' in options) {
-      this.oncloseobject = options.oncloseobject;
-    }
+      if ('onkey' in options) {
+        this.onkey = options.onkey;
+      }
 
-    if ('onopenarray' in options) {
-      this.onopenarray = options.onopenarray;
-    }
+      if ('oncloseobject' in options) {
+        this.oncloseobject = options.oncloseobject;
+      }
 
-    if ('onclosearray' in options) {
-      this.onclosearray = options.onclosearray;
-    }
+      if ('onopenarray' in options) {
+        this.onopenarray = options.onopenarray;
+      }
 
-    if ('onvalue' in options) {
-      this.onvalue = options.onvalue;
-    }
+      if ('onclosearray' in options) {
+        this.onclosearray = options.onclosearray;
+      }
 
-    if ('onerror' in options) {
-      this.onerror = options.onerror;
-    }
+      if ('onvalue' in options) {
+        this.onvalue = options.onvalue;
+      }
 
-    if ('onend' in options) {
-      this.onend = options.onend;
-    }
+      if ('onerror' in options) {
+        this.onerror = options.onerror;
+      }
 
-    if ('onchunkparsed' in options) {
-      this.onchunkparsed = options.onchunkparsed;
-    }
+      if ('onend' in options) {
+        this.onend = options.onend;
+      }
 
-    emit(this, 'onready');
-  }
+      if ('onchunkparsed' in options) {
+        this.onchunkparsed = options.onchunkparsed;
+      }
 
-  _clearBuffers() {
-    for (var buffer in buffers) {
-      this[buffer] = buffers[buffer];
+      emit(this, 'onready');
     }
-  }
-
-  end() {
-    if (this.state !== S.VALUE || this.depth !== 0) error(this, 'Unexpected end');
-    closeValue(this);
-    this.c = '';
-    this.closed = true;
-    emit(this, 'onend');
-
-    this._initialize(this.options);
-
-    return this;
-  }
-
-  resume() {
-    this.error = null;
-    return this;
-  }
-
-  close() {
-    return this.write(null);
-  }
-
-  write(chunk) {
-    if (this.error) {
-      throw this.error;
+  }, {
+    key: "_clearBuffers",
+    value: function _clearBuffers() {
+      for (var buffer in buffers) {
+        this[buffer] = buffers[buffer];
+      }
     }
-
-    if (this.closed) {
-      return error(this, 'Cannot write after close. Assign an onready handler.');
+  }, {
+    key: "end",
+    value: function end() {
+      if (this.state !== S.VALUE || this.depth !== 0) error(this, 'Unexpected end');
+      closeValue(this);
+      this.c = '';
+      this.closed = true;
+      emit(this, 'onend');
+
+      this._initialize(this.options);
+
+      return this;
     }
-
-    if (chunk === null) {
-      return this.end();
+  }, {
+    key: "resume",
+    value: function resume() {
+      this.error = null;
+      return this;
     }
+  }, {
+    key: "close",
+    value: function close() {
+      return this.write(null);
+    }
+  }, {
+    key: "write",
+    value: function write(chunk) {
+      if (this.error) {
+        throw this.error;
+      }
 
-    var i = 0,
-        c = chunk.charCodeAt(0),
-        p = this.p;
-    if (DEBUG) console.log('write -> [' + chunk + ']');
-
-    while (c) {
-      p = c;
-      this.c = c = chunk.charCodeAt(i++);
+      if (this.closed) {
+        return error(this, 'Cannot write after close. Assign an onready handler.');
+      }
 
-      if (p !== c) {
-        this.p = p;
-      } else {
-        p = this.p;
+      if (chunk === null) {
+        return this.end();
       }
 
-      if (!c) break;
-      if (DEBUG) console.log(i, c, STATE[this.state]);
-      this.position++;
-
-      if (c === Char.lineFeed) {
-        this.line++;
-        this.column = 0;
-      } else this.column++;
-
-      switch (this.state) {
-        case S.BEGIN:
-          if (c === Char.openBrace) this.state = S.OPEN_OBJECT;else if (c === Char.openBracket) this.state = S.OPEN_ARRAY;else if (!isWhitespace(c)) {
-            error(this, 'Non-whitespace before {[.');
-          }
-          continue;
-
-        case S.OPEN_KEY:
-        case S.OPEN_OBJECT:
-          if (isWhitespace(c)) continue;
-          if (this.state === S.OPEN_KEY) this.stack.push(S.CLOSE_KEY);else {
-            if (c === Char.closeBrace) {
-              emit(this, 'onopenobject');
-              this.depth++;
-              emit(this, 'oncloseobject');
+      var i = 0,
+          c = chunk.charCodeAt(0),
+          p = this.p;
+      if (DEBUG) console.log('write -> [' + chunk + ']');
+
+      while (c) {
+        p = c;
+        this.c = c = chunk.charCodeAt(i++);
+
+        if (p !== c) {
+          this.p = p;
+        } else {
+          p = this.p;
+        }
+
+        if (!c) break;
+        if (DEBUG) console.log(i, c, STATE[this.state]);
+        this.position++;
+
+        if (c === Char.lineFeed) {
+          this.line++;
+          this.column = 0;
+        } else this.column++;
+
+        switch (this.state) {
+          case S.BEGIN:
+            if (c === Char.openBrace) this.state = S.OPEN_OBJECT;else if (c === Char.openBracket) this.state = S.OPEN_ARRAY;else if (!isWhitespace(c)) {
+              error(this, 'Non-whitespace before {[.');
+            }
+            continue;
+
+          case S.OPEN_KEY:
+          case S.OPEN_OBJECT:
+            if (isWhitespace(c)) continue;
+            if (this.state === S.OPEN_KEY) this.stack.push(S.CLOSE_KEY);else {
+              if (c === Char.closeBrace) {
+                emit(this, 'onopenobject');
+                this.depth++;
+                emit(this, 'oncloseobject');
+                this.depth--;
+                this.state = this.stack.pop() || S.VALUE;
+                continue;
+              } else this.stack.push(S.CLOSE_OBJECT);
+            }
+            if (c === Char.doubleQuote) this.state = S.STRING;else error(this, 'Malformed object key should start with "');
+            continue;
+
+          case S.CLOSE_KEY:
+          case S.CLOSE_OBJECT:
+            if (isWhitespace(c)) continue;
+            var event = this.state === S.CLOSE_KEY ? 'key' : 'object';
+
+            if (c === Char.colon) {
+              if (this.state === S.CLOSE_OBJECT) {
+                this.stack.push(S.CLOSE_OBJECT);
+                closeValue(this, 'onopenobject');
+                this.depth++;
+              } else closeValue(this, 'onkey');
+
+              this.state = S.VALUE;
+            } else if (c === Char.closeBrace) {
+              emitNode(this, 'oncloseobject');
               this.depth--;
               this.state = this.stack.pop() || S.VALUE;
-              continue;
-            } else this.stack.push(S.CLOSE_OBJECT);
-          }
-          if (c === Char.doubleQuote) this.state = S.STRING;else error(this, 'Malformed object key should start with "');
-          continue;
-
-        case S.CLOSE_KEY:
-        case S.CLOSE_OBJECT:
-          if (isWhitespace(c)) continue;
-          var event = this.state === S.CLOSE_KEY ? 'key' : 'object';
-
-          if (c === Char.colon) {
-            if (this.state === S.CLOSE_OBJECT) {
-              this.stack.push(S.CLOSE_OBJECT);
-              closeValue(this, 'onopenobject');
+            } else if (c === Char.comma) {
+              if (this.state === S.CLOSE_OBJECT) this.stack.push(S.CLOSE_OBJECT);
+              closeValue(this);
+              this.state = S.OPEN_KEY;
+            } else error(this, 'Bad object');
+
+            continue;
+
+          case S.OPEN_ARRAY:
+          case S.VALUE:
+            if (isWhitespace(c)) continue;
+
+            if (this.state === S.OPEN_ARRAY) {
+              emit(this, 'onopenarray');
               this.depth++;
-            } else closeValue(this, 'onkey');
-
-            this.state = S.VALUE;
-          } else if (c === Char.closeBrace) {
-            emitNode(this, 'oncloseobject');
-            this.depth--;
-            this.state = this.stack.pop() || S.VALUE;
-          } else if (c === Char.comma) {
-            if (this.state === S.CLOSE_OBJECT) this.stack.push(S.CLOSE_OBJECT);
-            closeValue(this);
-            this.state = S.OPEN_KEY;
-          } else error(this, 'Bad object');
-
-          continue;
-
-        case S.OPEN_ARRAY:
-        case S.VALUE:
-          if (isWhitespace(c)) continue;
-
-          if (this.state === S.OPEN_ARRAY) {
-            emit(this, 'onopenarray');
-            this.depth++;
-            this.state = S.VALUE;
-
-            if (c === Char.closeBracket) {
-              emit(this, 'onclosearray');
+              this.state = S.VALUE;
+
+              if (c === Char.closeBracket) {
+                emit(this, 'onclosearray');
+                this.depth--;
+                this.state = this.stack.pop() || S.VALUE;
+                continue;
+              } else {
+                this.stack.push(S.CLOSE_ARRAY);
+              }
+            }
+
+            if (c === Char.doubleQuote) this.state = S.STRING;else if (c === Char.openBrace) this.state = S.OPEN_OBJECT;else if (c === Char.openBracket) this.state = S.OPEN_ARRAY;else if (c === Char.t) this.state = S.TRUE;else if (c === Char.f) this.state = S.FALSE;else if (c === Char.n) this.state = S.NULL;else if (c === Char.minus) {
+              this.numberNode += '-';
+            } else if (Char._0 <= c && c <= Char._9) {
+              this.numberNode += String.fromCharCode(c);
+              this.state = S.NUMBER_DIGIT;
+            } else error(this, 'Bad value');
+            continue;
+
+          case S.CLOSE_ARRAY:
+            if (c === Char.comma) {
+              this.stack.push(S.CLOSE_ARRAY);
+              closeValue(this, 'onvalue');
+              this.state = S.VALUE;
+            } else if (c === Char.closeBracket) {
+              emitNode(this, 'onclosearray');
               this.depth--;
               this.state = this.stack.pop() || S.VALUE;
-              continue;
-            } else {
-              this.stack.push(S.CLOSE_ARRAY);
+            } else if (isWhitespace(c)) continue;else error(this, 'Bad array');
+
+            continue;
+
+          case S.STRING:
+            if (this.textNode === undefined) {
+              this.textNode = '';
             }
-          }
-
-          if (c === Char.doubleQuote) this.state = S.STRING;else if (c === Char.openBrace) this.state = S.OPEN_OBJECT;else if (c === Char.openBracket) this.state = S.OPEN_ARRAY;else if (c === Char.t) this.state = S.TRUE;else if (c === Char.f) this.state = S.FALSE;else if (c === Char.n) this.state = S.NULL;else if (c === Char.minus) {
-            this.numberNode += '-';
-          } else if (Char._0 <= c && c <= Char._9) {
-            this.numberNode += String.fromCharCode(c);
-            this.state = S.NUMBER_DIGIT;
-          } else error(this, 'Bad value');
-          continue;
-
-        case S.CLOSE_ARRAY:
-          if (c === Char.comma) {
-            this.stack.push(S.CLOSE_ARRAY);
-            closeValue(this, 'onvalue');
-            this.state = S.VALUE;
-          } else if (c === Char.closeBracket) {
-            emitNode(this, 'onclosearray');
-            this.depth--;
-            this.state = this.stack.pop() || S.VALUE;
-          } else if (isWhitespace(c)) continue;else error(this, 'Bad array');
-
-          continue;
-
-        case S.STRING:
-          if (this.textNode === undefined) {
-            this.textNode = '';
-          }
-
-          var starti = i - 1,
-              slashed = this.slashed,
-              unicodeI = this.unicodeI;
-
-          STRING_BIGLOOP: while (true) {
-            if (DEBUG) console.log(i, c, STATE[this.state], slashed);
-
-            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,
+                slashed = this.slashed,
+                unicodeI = this.unicodeI;
+
+            STRING_BIGLOOP: while (true) {
+              if (DEBUG) console.log(i, c, STATE[this.state], slashed);
+
+              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() || S.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;
+              }
+
+              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;
               }
 
-              if (!c) break STRING_BIGLOOP;
+              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 S.TRUE:
+            if (c === Char.r) this.state = S.TRUE2;else error(this, 'Invalid true started with t' + c);
+            continue;
+
+          case S.TRUE2:
+            if (c === Char.u) this.state = S.TRUE3;else error(this, 'Invalid true started with tr' + c);
+            continue;
+
+          case S.TRUE3:
+            if (c === Char.e) {
+              emit(this, 'onvalue', true);
               this.state = this.stack.pop() || S.VALUE;
-              this.textNode += chunk.substring(starti, i - 1);
-              this.position += i - 1 - starti;
-              break;
-            }
+            } else error(this, 'Invalid true started with tru' + 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 S.FALSE:
+            if (c === Char.a) this.state = S.FALSE2;else error(this, 'Invalid false started with f' + c);
+            continue;
 
-              c = chunk.charCodeAt(i++);
-              this.position++;
-              starti = i - 1;
-              if (!c) break;else continue;
-            }
+          case S.FALSE2:
+            if (c === Char.l) this.state = S.FALSE3;else error(this, 'Invalid false started with fa' + c);
+            continue;
 
-            stringTokenPattern.lastIndex = i;
-            var reResult = stringTokenPattern.exec(chunk);
+          case S.FALSE3:
+            if (c === Char.s) this.state = S.FALSE4;else error(this, 'Invalid false started with fal' + c);
+            continue;
 
-            if (reResult === null) {
-              i = chunk.length + 1;
-              this.textNode += chunk.substring(starti, i - 1);
-              this.position += i - 1 - starti;
-              break;
-            }
+          case S.FALSE4:
+            if (c === Char.e) {
+              emit(this, 'onvalue', false);
+              this.state = this.stack.pop() || S.VALUE;
+            } else error(this, 'Invalid false started with fals' + c);
+
+            continue;
 
-            i = reResult.index + 1;
-            c = chunk.charCodeAt(reResult.index);
+          case S.NULL:
+            if (c === Char.u) this.state = S.NULL2;else error(this, 'Invalid null started with n' + c);
+            continue;
 
-            if (!c) {
-              this.textNode += chunk.substring(starti, i - 1);
-              this.position += i - 1 - starti;
-              break;
+          case S.NULL2:
+            if (c === Char.l) this.state = S.NULL3;else error(this, 'Invalid null started with nu' + c);
+            continue;
+
+          case S.NULL3:
+            if (c === Char.l) {
+              emit(this, 'onvalue', null);
+              this.state = this.stack.pop() || S.VALUE;
+            } else error(this, 'Invalid null started with nul' + c);
+
+            continue;
+
+          case S.NUMBER_DECIMAL_POINT:
+            if (c === Char.period) {
+              this.numberNode += '.';
+              this.state = S.NUMBER_DIGIT;
+            } else error(this, 'Leading zero not followed by .');
+
+            continue;
+
+          case S.NUMBER_DIGIT:
+            if (Char._0 <= c && c <= Char._9) this.numberNode += String.fromCharCode(c);else if (c === Char.period) {
+              if (this.numberNode.indexOf('.') !== -1) error(this, '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) error(this, 'Invalid number has two exponential');
+              this.numberNode += 'e';
+            } else if (c === Char.plus || c === Char.minus) {
+              if (!(p === Char.e || p === Char.E)) error(this, 'Invalid symbol in number');
+              this.numberNode += String.fromCharCode(c);
+            } else {
+              closeNumber(this);
+              i--;
+              this.state = this.stack.pop() || S.VALUE;
             }
-          }
-
-          this.slashed = slashed;
-          this.unicodeI = unicodeI;
-          continue;
-
-        case S.TRUE:
-          if (c === Char.r) this.state = S.TRUE2;else error(this, 'Invalid true started with t' + c);
-          continue;
-
-        case S.TRUE2:
-          if (c === Char.u) this.state = S.TRUE3;else error(this, 'Invalid true started with tr' + c);
-          continue;
-
-        case S.TRUE3:
-          if (c === Char.e) {
-            emit(this, 'onvalue', true);
-            this.state = this.stack.pop() || S.VALUE;
-          } else error(this, 'Invalid true started with tru' + c);
-
-          continue;
-
-        case S.FALSE:
-          if (c === Char.a) this.state = S.FALSE2;else error(this, 'Invalid false started with f' + c);
-          continue;
-
-        case S.FALSE2:
-          if (c === Char.l) this.state = S.FALSE3;else error(this, 'Invalid false started with fa' + c);
-          continue;
-
-        case S.FALSE3:
-          if (c === Char.s) this.state = S.FALSE4;else error(this, 'Invalid false started with fal' + c);
-          continue;
-
-        case S.FALSE4:
-          if (c === Char.e) {
-            emit(this, 'onvalue', false);
-            this.state = this.stack.pop() || S.VALUE;
-          } else error(this, 'Invalid false started with fals' + c);
-
-          continue;
-
-        case S.NULL:
-          if (c === Char.u) this.state = S.NULL2;else error(this, 'Invalid null started with n' + c);
-          continue;
-
-        case S.NULL2:
-          if (c === Char.l) this.state = S.NULL3;else error(this, 'Invalid null started with nu' + c);
-          continue;
-
-        case S.NULL3:
-          if (c === Char.l) {
-            emit(this, 'onvalue', null);
-            this.state = this.stack.pop() || S.VALUE;
-          } else error(this, 'Invalid null started with nul' + c);
-
-          continue;
-
-        case S.NUMBER_DECIMAL_POINT:
-          if (c === Char.period) {
-            this.numberNode += '.';
-            this.state = S.NUMBER_DIGIT;
-          } else error(this, 'Leading zero not followed by .');
-
-          continue;
-
-        case S.NUMBER_DIGIT:
-          if (Char._0 <= c && c <= Char._9) this.numberNode += String.fromCharCode(c);else if (c === Char.period) {
-            if (this.numberNode.indexOf('.') !== -1) error(this, '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) error(this, 'Invalid number has two exponential');
-            this.numberNode += 'e';
-          } else if (c === Char.plus || c === Char.minus) {
-            if (!(p === Char.e || p === Char.E)) error(this, 'Invalid symbol in number');
-            this.numberNode += String.fromCharCode(c);
-          } else {
-            closeNumber(this);
-            i--;
-            this.state = this.stack.pop() || S.VALUE;
-          }
-          continue;
+            continue;
 
-        default:
-          error(this, 'Unknown state: ' + this.state);
+          default:
+            error(this, 'Unknown state: ' + this.state);
+        }
       }
-    }
 
-    if (this.position >= this.bufferCheckPosition) {
-      checkBufferLength(this);
-    }
-
-    emit(this, 'onchunkparsed');
-    return this;
-  }
+      if (this.position >= this.bufferCheckPosition) {
+        checkBufferLength(this);
+      }
 
-}
+      emit(this, 'onchunkparsed');
+      return this;
+    }
+  }]);
+  return ClarinetParser;
+}();
 
 exports.default = ClarinetParser;