@loaders.gl/json 3.1.0-alpha.4 → 3.1.0-beta.3

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

@@ -5,55 +5,41 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = exports.EVENTS = void 0;
-
-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;
-var MAX_BUFFER_LENGTH = Number.MAX_SAFE_INTEGER;
-var DEBUG = env.CDEBUG === 'debug';
-var buffers = {
-  textNode: undefined,
-  numberNode: ''
-};
-var S = 0;
-var STATE = {
-  BEGIN: S++,
-  VALUE: S++,
-  OPEN_OBJECT: S++,
-  CLOSE_OBJECT: S++,
-  OPEN_ARRAY: S++,
-  CLOSE_ARRAY: S++,
-  TEXT_ESCAPE: S++,
-  STRING: S++,
-  BACKSLASH: S++,
-  END: S++,
-  OPEN_KEY: S++,
-  CLOSE_KEY: S++,
-  TRUE: S++,
-  TRUE2: S++,
-  TRUE3: S++,
-  FALSE: S++,
-  FALSE2: S++,
-  FALSE3: S++,
-  FALSE4: S++,
-  NULL: S++,
-  NULL2: S++,
-  NULL3: S++,
-  NUMBER_DECIMAL_POINT: S++,
-  NUMBER_DIGIT: S++
-};
-
-for (var s_ in STATE) {
-  STATE[STATE[s_]] = s_;
-}
-
-S = STATE;
-var Char = {
+exports.default = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+const MAX_BUFFER_LENGTH = Number.MAX_SAFE_INTEGER;
+var STATE;
+
+(function (STATE) {
+  STATE[STATE["BEGIN"] = 0] = "BEGIN";
+  STATE[STATE["VALUE"] = 1] = "VALUE";
+  STATE[STATE["OPEN_OBJECT"] = 2] = "OPEN_OBJECT";
+  STATE[STATE["CLOSE_OBJECT"] = 3] = "CLOSE_OBJECT";
+  STATE[STATE["OPEN_ARRAY"] = 4] = "OPEN_ARRAY";
+  STATE[STATE["CLOSE_ARRAY"] = 5] = "CLOSE_ARRAY";
+  STATE[STATE["TEXT_ESCAPE"] = 6] = "TEXT_ESCAPE";
+  STATE[STATE["STRING"] = 7] = "STRING";
+  STATE[STATE["BACKSLASH"] = 8] = "BACKSLASH";
+  STATE[STATE["END"] = 9] = "END";
+  STATE[STATE["OPEN_KEY"] = 10] = "OPEN_KEY";
+  STATE[STATE["CLOSE_KEY"] = 11] = "CLOSE_KEY";
+  STATE[STATE["TRUE"] = 12] = "TRUE";
+  STATE[STATE["TRUE2"] = 13] = "TRUE2";
+  STATE[STATE["TRUE3"] = 14] = "TRUE3";
+  STATE[STATE["FALSE"] = 15] = "FALSE";
+  STATE[STATE["FALSE2"] = 16] = "FALSE2";
+  STATE[STATE["FALSE3"] = 17] = "FALSE3";
+  STATE[STATE["FALSE4"] = 18] = "FALSE4";
+  STATE[STATE["NULL"] = 19] = "NULL";
+  STATE[STATE["NULL2"] = 20] = "NULL2";
+  STATE[STATE["NULL3"] = 21] = "NULL3";
+  STATE[STATE["NUMBER_DECIMAL_POINT"] = 22] = "NUMBER_DECIMAL_POINT";
+  STATE[STATE["NUMBER_DIGIT"] = 23] = "NUMBER_DIGIT";
+})(STATE || (STATE = {}));
+
+const Char = {
   tab: 0x09,
   lineFeed: 0x0a,
   carriageReturn: 0x0d,
@@ -83,504 +69,443 @@ var Char = {
   openBrace: 0x7b,
   closeBrace: 0x7d
 };
+const stringTokenPattern = /[\\"\n]/g;
+const DEFAULT_OPTIONS = {
+  onready: () => {},
+  onopenobject: () => {},
+  onkey: () => {},
+  oncloseobject: () => {},
+  onopenarray: () => {},
+  onclosearray: () => {},
+  onvalue: () => {},
+  onerror: () => {},
+  onend: () => {},
+  onchunkparsed: () => {}
+};
 
-function checkBufferLength(parser) {
-  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;
-
-    if (len > maxAllowed) {
-      switch (buffer) {
-        case 'text':
-          closeText(parser);
-          break;
-
-        default:
-          error(parser, 'Max buffer length exceeded: ' + buffer);
-      }
-    }
-
-    maxActual = Math.max(maxActual, len);
+class ClarinetParser {
+  constructor(options = {}) {
+    (0, _defineProperty2.default)(this, "options", DEFAULT_OPTIONS);
+    (0, _defineProperty2.default)(this, "bufferCheckPosition", MAX_BUFFER_LENGTH);
+    (0, _defineProperty2.default)(this, "q", '');
+    (0, _defineProperty2.default)(this, "c", '');
+    (0, _defineProperty2.default)(this, "p", '');
+    (0, _defineProperty2.default)(this, "closed", false);
+    (0, _defineProperty2.default)(this, "closedRoot", false);
+    (0, _defineProperty2.default)(this, "sawRoot", false);
+    (0, _defineProperty2.default)(this, "error", null);
+    (0, _defineProperty2.default)(this, "state", STATE.BEGIN);
+    (0, _defineProperty2.default)(this, "stack", []);
+    (0, _defineProperty2.default)(this, "position", 0);
+    (0, _defineProperty2.default)(this, "column", 0);
+    (0, _defineProperty2.default)(this, "line", 1);
+    (0, _defineProperty2.default)(this, "slashed", false);
+    (0, _defineProperty2.default)(this, "unicodeI", 0);
+    (0, _defineProperty2.default)(this, "unicodeS", null);
+    (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.textNode = undefined;
+    this.numberNode = '';
+    this.emit('onready');
   }
 
-  parser.bufferCheckPosition = MAX_BUFFER_LENGTH - maxActual + parser.position;
-}
-
-var stringTokenPattern = /[\\"\n]/g;
+  end() {
+    if (this.state !== STATE.VALUE || this.depth !== 0) this._error('Unexpected end');
 
-var ClarinetParser = function () {
-  function ClarinetParser() {
-    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    (0, _classCallCheck2.default)(this, ClarinetParser);
+    this._closeValue();
 
-    this._initialize(options);
+    this.c = '';
+    this.closed = true;
+    this.emit('onend');
+    return this;
   }
 
-  (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 ('onopenobject' in options) {
-        this.onopenobject = options.onopenobject;
-      }
-
-      if ('onkey' in options) {
-        this.onkey = options.onkey;
-      }
-
-      if ('oncloseobject' in options) {
-        this.oncloseobject = options.oncloseobject;
-      }
-
-      if ('onopenarray' in options) {
-        this.onopenarray = options.onopenarray;
-      }
+  resume() {
+    this.error = null;
+    return this;
+  }
 
-      if ('onclosearray' in options) {
-        this.onclosearray = options.onclosearray;
-      }
+  close() {
+    return this.write(null);
+  }
 
-      if ('onvalue' in options) {
-        this.onvalue = options.onvalue;
-      }
+  emit(event, data) {
+    var _this$options$event, _this$options;
 
-      if ('onerror' in options) {
-        this.onerror = options.onerror;
-      }
+    (_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 ('onend' in options) {
-        this.onend = options.onend;
-      }
+  emitNode(event, data) {
+    this._closeValue();
 
-      if ('onchunkparsed' in options) {
-        this.onchunkparsed = options.onchunkparsed;
-      }
+    this.emit(event, data);
+  }
 
-      emit(this, 'onready');
-    }
-  }, {
-    key: "_clearBuffers",
-    value: function _clearBuffers() {
-      for (var buffer in buffers) {
-        this[buffer] = buffers[buffer];
-      }
+  write(chunk) {
+    if (this.error) {
+      throw this.error;
     }
-  }, {
-    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;
-    }
-  }, {
-    key: "resume",
-    value: function resume() {
-      this.error = null;
-      return this;
+
+    if (this.closed) {
+      return this._error('Cannot write after close. Assign an onready handler.');
     }
-  }, {
-    key: "close",
-    value: function close() {
-      return this.write(null);
+
+    if (chunk === null) {
+      return this.end();
     }
-  }, {
-    key: "write",
-    value: function write(chunk) {
-      if (this.error) {
-        throw this.error;
-      }
 
-      if (this.closed) {
-        return error(this, 'Cannot write after close. Assign an onready handler.');
-      }
+    let i = 0;
+    let c = chunk.charCodeAt(0);
+    let p = this.p;
 
-      if (chunk === null) {
-        return this.end();
-      }
+    while (c) {
+      p = c;
+      this.c = c = chunk.charCodeAt(i++);
 
-      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;
+      if (p !== c) {
+        this.p = p;
+      } else {
+        p = this.p;
+      }
 
-          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 "');
+      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;
 
-          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;
-            } 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');
+        case STATE.CLOSE_KEY:
+        case STATE.CLOSE_OBJECT:
+          if (isWhitespace(c)) continue;
 
-            continue;
+          if (c === Char.colon) {
+            if (this.state === STATE.CLOSE_OBJECT) {
+              this.stack.push(STATE.CLOSE_OBJECT);
 
-          case S.OPEN_ARRAY:
-          case S.VALUE:
-            if (isWhitespace(c)) continue;
+              this._closeValue('onopenobject');
 
-            if (this.state === S.OPEN_ARRAY) {
-              emit(this, 'onopenarray');
               this.depth++;
-              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;
+            } else this._closeValue('onkey');
 
-          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 = '';
-            }
+            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);
 
-            var starti = i - 1,
-                slashed = this.slashed,
-                unicodeI = this.unicodeI;
+            this._closeValue();
 
-            STRING_BIGLOOP: while (true) {
-              if (DEBUG) console.log(i, c, STATE[this.state], slashed);
+            this.state = STATE.OPEN_KEY;
+          } else this._error('Bad object');
 
-              while (unicodeI > 0) {
-                this.unicodeS += String.fromCharCode(c);
-                c = chunk.charCodeAt(i++);
-                this.position++;
+          continue;
 
-                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;
-              }
+        case STATE.OPEN_ARRAY:
+        case STATE.VALUE:
+          if (isWhitespace(c)) continue;
 
-              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 (this.state === STATE.OPEN_ARRAY) {
+            this.emit('onopenarray');
+            this.depth++;
+            this.state = STATE.VALUE;
 
-              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++;
+            if (c === Char.closeBracket) {
+              this.emit('onclosearray');
+              this.depth--;
+              this.state = this.stack.pop() || STATE.VALUE;
+              continue;
+            } else {
+              this.stack.push(STATE.CLOSE_ARRAY);
+            }
+          }
+
+          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;
                 starti = i - 1;
-                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;
+              } else {
+                unicodeI++;
               }
 
-              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) break STRING_BIGLOOP;
             }
 
-            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;
+            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;
+            }
 
-          case S.NULL:
-            if (c === Char.u) this.state = S.NULL2;else error(this, 'Invalid null started with n' + c);
-            continue;
+            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;
+            }
 
-          case S.NULL2:
-            if (c === Char.l) this.state = S.NULL3;else error(this, 'Invalid null started with nu' + c);
-            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.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);
+              c = chunk.charCodeAt(i++);
+              this.position++;
+              starti = i - 1;
+              if (!c) break;else continue;
+            }
 
-            continue;
+            stringTokenPattern.lastIndex = i;
+            const reResult = stringTokenPattern.exec(chunk);
 
-          case S.NUMBER_DECIMAL_POINT:
-            if (c === Char.period) {
-              this.numberNode += '.';
-              this.state = S.NUMBER_DIGIT;
-            } else error(this, 'Leading zero not followed by .');
+            if (reResult === null) {
+              i = chunk.length + 1;
+              this.textNode += chunk.substring(starti, i - 1);
+              this.position += i - 1 - starti;
+              break;
+            }
 
-            continue;
+            i = reResult.index + 1;
+            c = chunk.charCodeAt(reResult.index);
 
-          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;
+            if (!c) {
+              this.textNode += chunk.substring(starti, i - 1);
+              this.position += i - 1 - starti;
+              break;
             }
-            continue;
+          }
+
+          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;
 
-          default:
-            error(this, 'Unknown state: ' + this.state);
-        }
-      }
+        default:
+          this._error("Unknown state: ".concat(this.state));
 
-      if (this.position >= this.bufferCheckPosition) {
-        checkBufferLength(this);
       }
-
-      emit(this, 'onchunkparsed');
-      return this;
     }
-  }]);
-  return ClarinetParser;
-}();
 
-exports.default = ClarinetParser;
+    if (this.position >= this.bufferCheckPosition) {
+      checkBufferLength(this);
+    }
 
-function emit(parser, event, data) {
-  if (DEBUG) {
-    console.log('-- emit', event, data);
+    this.emit('onchunkparsed');
+    return this;
   }
 
-  if (parser[event]) {
-    parser[event](data, parser);
+  _closeValue(event = 'onvalue') {
+    if (this.textNode !== undefined) {
+      this.emit(event, this.textNode);
+    }
+
+    this.textNode = undefined;
   }
-}
 
-function emitNode(parser, event, data) {
-  closeValue(parser);
-  emit(parser, event, data);
-}
+  _closeNumber() {
+    if (this.numberNode) this.emit('onvalue', parseFloat(this.numberNode));
+    this.numberNode = '';
+  }
 
-function closeValue(parser, event) {
-  parser.textNode = textopts(parser.options, parser.textNode);
+  _error(message = '') {
+    this._closeValue();
 
-  if (parser.textNode !== undefined) {
-    emit(parser, event ? event : 'onvalue', parser.textNode);
+    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);
   }
 
-  parser.textNode = undefined;
 }
 
-function closeNumber(parser) {
-  if (parser.numberNode) emit(parser, 'onvalue', parseFloat(parser.numberNode));
-  parser.numberNode = '';
+exports.default = ClarinetParser;
+
+function isWhitespace(c) {
+  return c === Char.carriageReturn || c === Char.lineFeed || c === Char.space || c === Char.tab;
 }
 
-function textopts(opt, text) {
-  if (text === undefined) {
-    return text;
-  }
+function checkBufferLength(parser) {
+  const maxAllowed = Math.max(MAX_BUFFER_LENGTH, 10);
+  let maxActual = 0;
 
-  if (opt.trim) text = text.trim();
-  if (opt.normalize) text = text.replace(/\s+/g, ' ');
-  return text;
-}
+  for (const buffer of ['textNode', 'numberNode']) {
+    const len = parser[buffer] === undefined ? 0 : parser[buffer].length;
 
-function error(parser, er) {
-  closeValue(parser);
-  er += '\nLine: ' + parser.line + '\nColumn: ' + parser.column + '\nChar: ' + parser.c;
-  er = new Error(er);
-  parser.error = er;
-  emit(parser, 'onerror', er);
-  return parser;
-}
+    if (len > maxAllowed) {
+      switch (buffer) {
+        case 'text':
+          break;
 
-function isWhitespace(c) {
-  return c === Char.carriageReturn || c === Char.lineFeed || c === Char.space || c === Char.tab;
+        default:
+          parser._error("Max buffer length exceeded: ".concat(buffer));
+
+      }
+    }
+
+    maxActual = Math.max(maxActual, len);
+  }
+
+  parser.bufferCheckPosition = MAX_BUFFER_LENGTH - maxActual + parser.position;
 }
 //# sourceMappingURL=clarinet.js.map