mongo-ejson 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ad82ad33cec308c20018042c44a50361619d79813bb866e830126794f35daed1
+  data.tar.gz: 7d2bec415b3328b6c112e382819f3d6c9b0b97fbdbbbf3d40ec4779a8926b36c
+SHA512:
+  metadata.gz: 7fcd47f32cbb62d40ea9d268746f4bd7ebb8611a5c044297c16bb4a9dbd14d7d79933f6a0bf4b58d731c93d7bc7abe2dac3cf281ce1a62ea3d956abec3c8a826
+  data.tar.gz: 412d8ed39076c303b704016dfda59d25ad05a7e40a5314a430d59b5fdaf7902fe0a18f019100b9ebbf77a0715f5a455c1a01559d7247f6a758fe130871243199

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,9 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.6
+  - 2.5
+  - jruby-9.2
+before_install: gem install bundler -v 2.0.1

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in mongo-ejson.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,39 @@
+PATH
+  remote: .
+  specs:
+    mongo-ejson (0.2.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    bson (4.4.2)
+    bson (4.4.2-java)
+    diff-lcs (1.3)
+    rake (10.5.0)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+
+PLATFORMS
+  java
+  ruby
+
+DEPENDENCIES
+  bson
+  bundler (~> 2.0)
+  mongo-ejson!
+  rake (~> 10.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   2.0.1

data/README.md

@@ -0,0 +1,57 @@
+# mongo-ejson
+
+[![Build Status](https://travis-ci.org/db-ai/mongo-ejson.svg?branch=master)](https://travis-ci.org/db-ai/mongo-ejson)
+
+This is a parser for mongo "flavoured" JSON, that supports mongo specific literals like `ISODate` or `ObjectId`, as well as some other nasty non-json things.
+
+It can instantiate corresponding BSON objects or produce Extended JSON objects.
+
+## Requirements
+
+Runtime:
+  * Ruby 2.5+
+  * JRuby 9.2+
+
+Development:
+  * [canopy](https://github.com/jcoglan/canopy) from master branch
+
+## Supported literals
+
+* `undefined`
+* `MinKey`
+* `MaxKey`
+* `ObjectId(<object_id_hex_string>)`
+* `BinData(<type_string>, <bindata_base64_string>)`
+* `BinData(<type_integer>, <base64_bindata>)`
+* `Timestamp(<time_interger>, <increment_integer>)`
+* `NumberLong(<value_string>)`
+* `NumberLong(<value_integer>)`
+* `NumberDecimal(<value_string>)`
+* `NumberDecimal(<value_number>)`
+* `ISODate(<time_iso8601_string>)`
+* `ISODate(<time_interger>)`
+* `new Date(<time_iso8601_string>)`
+* `new Date(<time_interger>)`
+* `/<regexp>/<options>`
+* `DBRef(<name_string>, <object_id_hex_string>)`
+
+## Supported JSON extensions:
+
+* Single quoted strings
+* Single line comments `//`
+
+## Planned JSON extensions:
+
+* Multi-line comments: `/* */`
+
+## Issues
+
+* String: following not escaped chars should fail, but pass
+
+    * Backspace (must be replaced with `\b`). no fixture
+    * Form feed (must be replaced with `\f`), no fixture
+    * Newline (must be replaced with `\n`)
+    * Carriage return (must be replaced with `\r`), no fixture
+    * Tab (must be replaced with `\t`)
+
+

data/Rakefile

@@ -0,0 +1,26 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require 'fileutils'
+
+CANOPY_BIN = ENV.fetch('CANOPY_BIN') { 'canopy' }
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+task :compile_js do
+  sh %{ #{CANOPY_BIN} src/ejson.peg --lang javascript }
+end
+
+task :compile_ruby do
+  sh %{ #{CANOPY_BIN} src/ejson.peg --lang ruby }
+end
+
+desc "Build and run test suite"
+task :test => [:compile_ruby, :spec] do
+end
+
+desc "Prepare assets"
+task :assets => [:test, :compile_js] do
+  mv 'src/ejson.js', 'lib/assets/ejson.js'
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "ejson"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ejson.gemspec

@@ -0,0 +1,46 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "ejson/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "mongo-ejson"
+  spec.version       = EJSON::VERSION
+  spec.authors       = ["Alex Bondar"]
+  spec.email         = ["mongo-ejson-gem@db-ai.co"]
+
+  spec.summary       = %q{MongoDB Extended JS(ON) parser}
+  spec.description   = %q{Parses MongoDB favoured JS(ON) string into objects}
+  spec.homepage      = "https://gibhub.com/db-ai/mongo-ejson"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the
+  # 'allowed_push_host' to allow pushing to a single host or delete this
+  # section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = "https://rubygems.org/"
+
+    spec.metadata["homepage_uri"] = spec.homepage
+    spec.metadata["source_code_uri"] = "https://gibhub.com/db-ai/mongo-ejson"
+    spec.metadata["changelog_uri"] = "https://gibhub.com/db-ai/mongo-ejson"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+          "public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been
+  # added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`
+      .split("\x0")
+      .reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "bson"
+end

data/lib/assets/ejson.js

@@ -0,0 +1,4061 @@
+/**
+ * This file was generated from src/ejson.peg
+ * See http://canopy.jcoglan.com/ for documentation.
+ */
+
+(function() {
+  'use strict';
+
+  var extend = function(destination, source) {
+    if (!destination || !source) return destination;
+    for (var key in source) {
+      if (destination[key] !== source[key])
+        destination[key] = source[key];
+    }
+    return destination;
+  };
+
+  var formatError = function(input, offset, expected) {
+    var lines = input.split(/\n/g),
+        lineNo = 0,
+        position = 0;
+
+    while (position <= offset) {
+      position += lines[lineNo].length + 1;
+      lineNo += 1;
+    }
+    var message = 'Line ' + lineNo + ': expected ' + expected.join(', ') + '\n',
+        line = lines[lineNo - 1];
+
+    message += line + '\n';
+    position -= line.length + 1;
+
+    while (position < offset) {
+      message += ' ';
+      position += 1;
+    }
+    return message + '^';
+  };
+
+  var inherit = function(subclass, parent) {
+    var chain = function() {};
+    chain.prototype = parent.prototype;
+    subclass.prototype = new chain();
+    subclass.prototype.constructor = subclass;
+  };
+
+  var TreeNode = function(text, offset, elements) {
+    this.text = text;
+    this.offset = offset;
+    this.elements = elements || [];
+  };
+
+  TreeNode.prototype.forEach = function(block, context) {
+    for (var el = this.elements, i = 0, n = el.length; i < n; i++) {
+      block.call(context, el[i], i, el);
+    }
+  };
+
+  var TreeNode1 = function(text, offset, elements) {
+    TreeNode.apply(this, arguments);
+    this['string'] = elements[0];
+    this['value'] = elements[1];
+  };
+  inherit(TreeNode1, TreeNode);
+
+  var TreeNode2 = function(text, offset, elements) {
+    TreeNode.apply(this, arguments);
+    this['pair'] = elements[0];
+  };
+  inherit(TreeNode2, TreeNode);
+
+  var TreeNode3 = function(text, offset, elements) {
+    TreeNode.apply(this, arguments);
+    this['pair'] = elements[0];
+  };
+  inherit(TreeNode3, TreeNode);
+
+  var TreeNode4 = function(text, offset, elements) {
+    TreeNode.apply(this, arguments);
+    this['value'] = elements[0];
+  };
+  inherit(TreeNode4, TreeNode);
+
+  var TreeNode5 = function(text, offset, elements) {
+    TreeNode.apply(this, arguments);
+    this['value'] = elements[0];
+  };
+  inherit(TreeNode5, TreeNode);
+
+  var TreeNode6 = function(text, offset, elements) {
+    TreeNode.apply(this, arguments);
+    this['hex_value'] = elements[0];
+  };
+  inherit(TreeNode6, TreeNode);
+
+  var TreeNode7 = function(text, offset, elements) {
+    TreeNode.apply(this, arguments);
+    this['hex_value'] = elements[0];
+  };
+  inherit(TreeNode7, TreeNode);
+
+  var TreeNode8 = function(text, offset, elements) {
+    TreeNode.apply(this, arguments);
+    this['integer_number'] = elements[0];
+  };
+  inherit(TreeNode8, TreeNode);
+
+  var TreeNode9 = function(text, offset, elements) {
+    TreeNode.apply(this, arguments);
+    this['integer_number'] = elements[0];
+  };
+  inherit(TreeNode9, TreeNode);
+
+  var TreeNode10 = function(text, offset, elements) {
+    TreeNode.apply(this, arguments);
+    this['number'] = elements[0];
+  };
+  inherit(TreeNode10, TreeNode);
+
+  var TreeNode11 = function(text, offset, elements) {
+    TreeNode.apply(this, arguments);
+    this['number'] = elements[0];
+  };
+  inherit(TreeNode11, TreeNode);
+
+  var TreeNode12 = function(text, offset, elements) {
+    TreeNode.apply(this, arguments);
+    this['base64_value'] = elements[0];
+  };
+  inherit(TreeNode12, TreeNode);
+
+  var TreeNode13 = function(text, offset, elements) {
+    TreeNode.apply(this, arguments);
+    this['base64_value'] = elements[0];
+  };
+  inherit(TreeNode13, TreeNode);
+
+  var TreeNode14 = function(text, offset, elements) {
+    TreeNode.apply(this, arguments);
+    this['integer'] = elements[1];
+  };
+  inherit(TreeNode14, TreeNode);
+
+  var TreeNode15 = function(text, offset, elements) {
+    TreeNode.apply(this, arguments);
+    this['integer'] = elements[1];
+  };
+  inherit(TreeNode15, TreeNode);
+
+  var TreeNode16 = function(text, offset, elements) {
+    TreeNode.apply(this, arguments);
+    this['integer'] = elements[0];
+  };
+  inherit(TreeNode16, TreeNode);
+
+  var TreeNode17 = function(text, offset, elements) {
+    TreeNode.apply(this, arguments);
+    this['hex_string'] = elements[0];
+  };
+  inherit(TreeNode17, TreeNode);
+
+  var TreeNode18 = function(text, offset, elements) {
+    TreeNode.apply(this, arguments);
+    this['bin_data_type'] = elements[0];
+    this['base64_string'] = elements[1];
+  };
+  inherit(TreeNode18, TreeNode);
+
+  var TreeNode19 = function(text, offset, elements) {
+    TreeNode.apply(this, arguments);
+    this['integer_number'] = elements[1];
+  };
+  inherit(TreeNode19, TreeNode);
+
+  var TreeNode20 = function(text, offset, elements) {
+    TreeNode.apply(this, arguments);
+    this['number_long_value'] = elements[0];
+  };
+  inherit(TreeNode20, TreeNode);
+
+  var TreeNode21 = function(text, offset, elements) {
+    TreeNode.apply(this, arguments);
+    this['number_decimal_value'] = elements[0];
+  };
+  inherit(TreeNode21, TreeNode);
+
+  var TreeNode22 = function(text, offset, elements) {
+    TreeNode.apply(this, arguments);
+    this['date_value'] = elements[0];
+  };
+  inherit(TreeNode22, TreeNode);
+
+  var TreeNode23 = function(text, offset, elements) {
+    TreeNode.apply(this, arguments);
+    this['string'] = elements[1];
+  };
+  inherit(TreeNode23, TreeNode);
+
+  var TreeNode24 = function(text, offset, elements) {
+    TreeNode.apply(this, arguments);
+    this['comma'] = elements[0];
+  };
+  inherit(TreeNode24, TreeNode);
+
+  var FAILURE = {};
+
+  var Grammar = {
+    _read_root: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._root = this._cache._root || {};
+      var cached = this._cache._root[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = new Array(1);
+      var address1 = FAILURE;
+      address1 = this._read___();
+      if (address1 !== FAILURE) {
+        var address2 = FAILURE;
+        var index2 = this._offset;
+        address2 = this._read_object();
+        if (address2 === FAILURE) {
+          this._offset = index2;
+          address2 = this._read_array();
+          if (address2 === FAILURE) {
+            this._offset = index2;
+          }
+        }
+        if (address2 !== FAILURE) {
+          elements0[0] = address2;
+          var address3 = FAILURE;
+          address3 = this._read___();
+          if (address3 !== FAILURE) {
+          } else {
+            elements0 = null;
+            this._offset = index1;
+          }
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = this._actions.make_root(this._input, index1, this._offset, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._root[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_object: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._object = this._cache._object || {};
+      var cached = this._cache._object[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset;
+      address0 = this._read_non_empty_object();
+      if (address0 === FAILURE) {
+        this._offset = index1;
+        address0 = this._read_empty_object();
+        if (address0 === FAILURE) {
+          this._offset = index1;
+        }
+      }
+      this._cache._object[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_pair: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._pair = this._cache._pair || {};
+      var cached = this._cache._pair[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = new Array(2);
+      var address1 = FAILURE;
+      address1 = this._read___();
+      if (address1 !== FAILURE) {
+        var address2 = FAILURE;
+        address2 = this._read_string();
+        if (address2 !== FAILURE) {
+          elements0[0] = address2;
+          var address3 = FAILURE;
+          address3 = this._read_assignment();
+          if (address3 !== FAILURE) {
+            var address4 = FAILURE;
+            address4 = this._read_value();
+            if (address4 !== FAILURE) {
+              elements0[1] = address4;
+            } else {
+              elements0 = null;
+              this._offset = index1;
+            }
+          } else {
+            elements0 = null;
+            this._offset = index1;
+          }
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = this._actions.make_pair(this._input, index1, this._offset, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._pair[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_non_empty_object: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._non_empty_object = this._cache._non_empty_object || {};
+      var cached = this._cache._non_empty_object[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = new Array(2);
+      var address1 = FAILURE;
+      address1 = this._read_object_open();
+      if (address1 !== FAILURE) {
+        var address2 = FAILURE;
+        address2 = this._read_pair();
+        if (address2 !== FAILURE) {
+          elements0[0] = address2;
+          var address3 = FAILURE;
+          var remaining0 = 0, index2 = this._offset, elements1 = [], address4 = true;
+          while (address4 !== FAILURE) {
+            var index3 = this._offset, elements2 = new Array(1);
+            var address5 = FAILURE;
+            address5 = this._read_delimiter();
+            if (address5 !== FAILURE) {
+              var address6 = FAILURE;
+              address6 = this._read_pair();
+              if (address6 !== FAILURE) {
+                elements2[0] = address6;
+              } else {
+                elements2 = null;
+                this._offset = index3;
+              }
+            } else {
+              elements2 = null;
+              this._offset = index3;
+            }
+            if (elements2 === null) {
+              address4 = FAILURE;
+            } else {
+              address4 = new TreeNode3(this._input.substring(index3, this._offset), index3, elements2);
+              this._offset = this._offset;
+            }
+            if (address4 !== FAILURE) {
+              elements1.push(address4);
+              --remaining0;
+            }
+          }
+          if (remaining0 <= 0) {
+            address3 = new TreeNode(this._input.substring(index2, this._offset), index2, elements1);
+            this._offset = this._offset;
+          } else {
+            address3 = FAILURE;
+          }
+          if (address3 !== FAILURE) {
+            elements0[1] = address3;
+            var address7 = FAILURE;
+            address7 = this._read_object_close();
+            if (address7 !== FAILURE) {
+            } else {
+              elements0 = null;
+              this._offset = index1;
+            }
+          } else {
+            elements0 = null;
+            this._offset = index1;
+          }
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = this._actions.make_object(this._input, index1, this._offset, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._non_empty_object[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_empty_object: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._empty_object = this._cache._empty_object || {};
+      var cached = this._cache._empty_object[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = [];
+      var address1 = FAILURE;
+      address1 = this._read_object_open();
+      if (address1 !== FAILURE) {
+        var address2 = FAILURE;
+        address2 = this._read_object_close();
+        if (address2 !== FAILURE) {
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = this._actions.make_empty_object(this._input, index1, this._offset, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._empty_object[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_array: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._array = this._cache._array || {};
+      var cached = this._cache._array[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset;
+      address0 = this._read_non_empty_array();
+      if (address0 === FAILURE) {
+        this._offset = index1;
+        address0 = this._read_empty_array();
+        if (address0 === FAILURE) {
+          this._offset = index1;
+        }
+      }
+      this._cache._array[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_non_empty_array: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._non_empty_array = this._cache._non_empty_array || {};
+      var cached = this._cache._non_empty_array[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = new Array(2);
+      var address1 = FAILURE;
+      address1 = this._read_array_open();
+      if (address1 !== FAILURE) {
+        var address2 = FAILURE;
+        address2 = this._read_value();
+        if (address2 !== FAILURE) {
+          elements0[0] = address2;
+          var address3 = FAILURE;
+          var remaining0 = 0, index2 = this._offset, elements1 = [], address4 = true;
+          while (address4 !== FAILURE) {
+            var index3 = this._offset, elements2 = new Array(1);
+            var address5 = FAILURE;
+            address5 = this._read_delimiter();
+            if (address5 !== FAILURE) {
+              var address6 = FAILURE;
+              address6 = this._read_value();
+              if (address6 !== FAILURE) {
+                elements2[0] = address6;
+              } else {
+                elements2 = null;
+                this._offset = index3;
+              }
+            } else {
+              elements2 = null;
+              this._offset = index3;
+            }
+            if (elements2 === null) {
+              address4 = FAILURE;
+            } else {
+              address4 = new TreeNode5(this._input.substring(index3, this._offset), index3, elements2);
+              this._offset = this._offset;
+            }
+            if (address4 !== FAILURE) {
+              elements1.push(address4);
+              --remaining0;
+            }
+          }
+          if (remaining0 <= 0) {
+            address3 = new TreeNode(this._input.substring(index2, this._offset), index2, elements1);
+            this._offset = this._offset;
+          } else {
+            address3 = FAILURE;
+          }
+          if (address3 !== FAILURE) {
+            elements0[1] = address3;
+            var address7 = FAILURE;
+            address7 = this._read_array_close();
+            if (address7 !== FAILURE) {
+            } else {
+              elements0 = null;
+              this._offset = index1;
+            }
+          } else {
+            elements0 = null;
+            this._offset = index1;
+          }
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = this._actions.make_array(this._input, index1, this._offset, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._non_empty_array[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_empty_array: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._empty_array = this._cache._empty_array || {};
+      var cached = this._cache._empty_array[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = [];
+      var address1 = FAILURE;
+      address1 = this._read_array_open();
+      if (address1 !== FAILURE) {
+        var address2 = FAILURE;
+        address2 = this._read_array_close();
+        if (address2 !== FAILURE) {
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = this._actions.make_empty_array(this._input, index1, this._offset, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._empty_array[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_value: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._value = this._cache._value || {};
+      var cached = this._cache._value[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset;
+      address0 = this._read_json_values();
+      if (address0 === FAILURE) {
+        this._offset = index1;
+        address0 = this._read_mongo_literals();
+        if (address0 === FAILURE) {
+          this._offset = index1;
+          address0 = this._read_mongo_types();
+          if (address0 === FAILURE) {
+            this._offset = index1;
+          }
+        }
+      }
+      this._cache._value[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_json_values: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._json_values = this._cache._json_values || {};
+      var cached = this._cache._json_values[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset;
+      address0 = this._read_object();
+      if (address0 === FAILURE) {
+        this._offset = index1;
+        address0 = this._read_array();
+        if (address0 === FAILURE) {
+          this._offset = index1;
+          address0 = this._read_number();
+          if (address0 === FAILURE) {
+            this._offset = index1;
+            address0 = this._read_string();
+            if (address0 === FAILURE) {
+              this._offset = index1;
+              address0 = this._read_boolean();
+              if (address0 === FAILURE) {
+                this._offset = index1;
+                address0 = this._read_null();
+                if (address0 === FAILURE) {
+                  this._offset = index1;
+                }
+              }
+            }
+          }
+        }
+      }
+      this._cache._json_values[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_mongo_literals: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._mongo_literals = this._cache._mongo_literals || {};
+      var cached = this._cache._mongo_literals[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset;
+      address0 = this._read_min_key();
+      if (address0 === FAILURE) {
+        this._offset = index1;
+        address0 = this._read_max_key();
+        if (address0 === FAILURE) {
+          this._offset = index1;
+          address0 = this._read_undefined();
+          if (address0 === FAILURE) {
+            this._offset = index1;
+            address0 = this._read_regexp_string();
+            if (address0 === FAILURE) {
+              this._offset = index1;
+            }
+          }
+        }
+      }
+      this._cache._mongo_literals[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_mongo_types: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._mongo_types = this._cache._mongo_types || {};
+      var cached = this._cache._mongo_types[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset;
+      address0 = this._read_object_id();
+      if (address0 === FAILURE) {
+        this._offset = index1;
+        address0 = this._read_bin_data();
+        if (address0 === FAILURE) {
+          this._offset = index1;
+          address0 = this._read_timestamp();
+          if (address0 === FAILURE) {
+            this._offset = index1;
+            address0 = this._read_number_long();
+            if (address0 === FAILURE) {
+              this._offset = index1;
+              address0 = this._read_number_decimal();
+              if (address0 === FAILURE) {
+                this._offset = index1;
+                address0 = this._read_date();
+                if (address0 === FAILURE) {
+                  this._offset = index1;
+                  address0 = this._read_db_ref_type();
+                  if (address0 === FAILURE) {
+                    this._offset = index1;
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      this._cache._mongo_types[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_boolean: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._boolean = this._cache._boolean || {};
+      var cached = this._cache._boolean[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset;
+      address0 = this._read_true();
+      if (address0 === FAILURE) {
+        this._offset = index1;
+        address0 = this._read_false();
+        if (address0 === FAILURE) {
+          this._offset = index1;
+        }
+      }
+      this._cache._boolean[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_true: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._true = this._cache._true || {};
+      var cached = this._cache._true[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var chunk0 = null;
+      if (this._offset < this._inputSize) {
+        chunk0 = this._input.substring(this._offset, this._offset + 4);
+      }
+      if (chunk0 === 'true') {
+        address0 = this._actions.make_true(this._input, this._offset, this._offset + 4);
+        this._offset = this._offset + 4;
+      } else {
+        address0 = FAILURE;
+        if (this._offset > this._failure) {
+          this._failure = this._offset;
+          this._expected = [];
+        }
+        if (this._offset === this._failure) {
+          this._expected.push('"true"');
+        }
+      }
+      this._cache._true[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_false: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._false = this._cache._false || {};
+      var cached = this._cache._false[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var chunk0 = null;
+      if (this._offset < this._inputSize) {
+        chunk0 = this._input.substring(this._offset, this._offset + 5);
+      }
+      if (chunk0 === 'false') {
+        address0 = this._actions.make_false(this._input, this._offset, this._offset + 5);
+        this._offset = this._offset + 5;
+      } else {
+        address0 = FAILURE;
+        if (this._offset > this._failure) {
+          this._failure = this._offset;
+          this._expected = [];
+        }
+        if (this._offset === this._failure) {
+          this._expected.push('"false"');
+        }
+      }
+      this._cache._false[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_null: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._null = this._cache._null || {};
+      var cached = this._cache._null[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var chunk0 = null;
+      if (this._offset < this._inputSize) {
+        chunk0 = this._input.substring(this._offset, this._offset + 4);
+      }
+      if (chunk0 === 'null') {
+        address0 = this._actions.make_null(this._input, this._offset, this._offset + 4);
+        this._offset = this._offset + 4;
+      } else {
+        address0 = FAILURE;
+        if (this._offset > this._failure) {
+          this._failure = this._offset;
+          this._expected = [];
+        }
+        if (this._offset === this._failure) {
+          this._expected.push('"null"');
+        }
+      }
+      this._cache._null[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_string: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._string = this._cache._string || {};
+      var cached = this._cache._string[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset;
+      address0 = this._read_double_quote_string();
+      if (address0 === FAILURE) {
+        this._offset = index1;
+        address0 = this._read_single_quote_string();
+        if (address0 === FAILURE) {
+          this._offset = index1;
+        }
+      }
+      this._cache._string[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_double_quote_string: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._double_quote_string = this._cache._double_quote_string || {};
+      var cached = this._cache._double_quote_string[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = new Array(1);
+      var address1 = FAILURE;
+      address1 = this._read_double_quote();
+      if (address1 !== FAILURE) {
+        var address2 = FAILURE;
+        var remaining0 = 0, index2 = this._offset, elements1 = [], address3 = true;
+        while (address3 !== FAILURE) {
+          var index3 = this._offset;
+          var index4 = this._offset, elements2 = new Array(2);
+          var address4 = FAILURE;
+          var chunk0 = null;
+          if (this._offset < this._inputSize) {
+            chunk0 = this._input.substring(this._offset, this._offset + 1);
+          }
+          if (chunk0 === '\\') {
+            address4 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+            this._offset = this._offset + 1;
+          } else {
+            address4 = FAILURE;
+            if (this._offset > this._failure) {
+              this._failure = this._offset;
+              this._expected = [];
+            }
+            if (this._offset === this._failure) {
+              this._expected.push('"\\\\"');
+            }
+          }
+          if (address4 !== FAILURE) {
+            elements2[0] = address4;
+            var address5 = FAILURE;
+            if (this._offset < this._inputSize) {
+              address5 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+              this._offset = this._offset + 1;
+            } else {
+              address5 = FAILURE;
+              if (this._offset > this._failure) {
+                this._failure = this._offset;
+                this._expected = [];
+              }
+              if (this._offset === this._failure) {
+                this._expected.push('<any char>');
+              }
+            }
+            if (address5 !== FAILURE) {
+              elements2[1] = address5;
+            } else {
+              elements2 = null;
+              this._offset = index4;
+            }
+          } else {
+            elements2 = null;
+            this._offset = index4;
+          }
+          if (elements2 === null) {
+            address3 = FAILURE;
+          } else {
+            address3 = new TreeNode(this._input.substring(index4, this._offset), index4, elements2);
+            this._offset = this._offset;
+          }
+          if (address3 === FAILURE) {
+            this._offset = index3;
+            var chunk1 = null;
+            if (this._offset < this._inputSize) {
+              chunk1 = this._input.substring(this._offset, this._offset + 1);
+            }
+            if (chunk1 !== null && /^[^"]/.test(chunk1)) {
+              address3 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+              this._offset = this._offset + 1;
+            } else {
+              address3 = FAILURE;
+              if (this._offset > this._failure) {
+                this._failure = this._offset;
+                this._expected = [];
+              }
+              if (this._offset === this._failure) {
+                this._expected.push('[^"]');
+              }
+            }
+            if (address3 === FAILURE) {
+              this._offset = index3;
+            }
+          }
+          if (address3 !== FAILURE) {
+            elements1.push(address3);
+            --remaining0;
+          }
+        }
+        if (remaining0 <= 0) {
+          address2 = new TreeNode(this._input.substring(index2, this._offset), index2, elements1);
+          this._offset = this._offset;
+        } else {
+          address2 = FAILURE;
+        }
+        if (address2 !== FAILURE) {
+          elements0[0] = address2;
+          var address6 = FAILURE;
+          address6 = this._read_double_quote();
+          if (address6 !== FAILURE) {
+          } else {
+            elements0 = null;
+            this._offset = index1;
+          }
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = this._actions.make_string(this._input, index1, this._offset, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._double_quote_string[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_single_quote_string: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._single_quote_string = this._cache._single_quote_string || {};
+      var cached = this._cache._single_quote_string[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = new Array(1);
+      var address1 = FAILURE;
+      address1 = this._read_single_quote();
+      if (address1 !== FAILURE) {
+        var address2 = FAILURE;
+        var remaining0 = 0, index2 = this._offset, elements1 = [], address3 = true;
+        while (address3 !== FAILURE) {
+          var index3 = this._offset;
+          var index4 = this._offset, elements2 = new Array(2);
+          var address4 = FAILURE;
+          var chunk0 = null;
+          if (this._offset < this._inputSize) {
+            chunk0 = this._input.substring(this._offset, this._offset + 1);
+          }
+          if (chunk0 === '\\') {
+            address4 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+            this._offset = this._offset + 1;
+          } else {
+            address4 = FAILURE;
+            if (this._offset > this._failure) {
+              this._failure = this._offset;
+              this._expected = [];
+            }
+            if (this._offset === this._failure) {
+              this._expected.push('"\\\\"');
+            }
+          }
+          if (address4 !== FAILURE) {
+            elements2[0] = address4;
+            var address5 = FAILURE;
+            if (this._offset < this._inputSize) {
+              address5 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+              this._offset = this._offset + 1;
+            } else {
+              address5 = FAILURE;
+              if (this._offset > this._failure) {
+                this._failure = this._offset;
+                this._expected = [];
+              }
+              if (this._offset === this._failure) {
+                this._expected.push('<any char>');
+              }
+            }
+            if (address5 !== FAILURE) {
+              elements2[1] = address5;
+            } else {
+              elements2 = null;
+              this._offset = index4;
+            }
+          } else {
+            elements2 = null;
+            this._offset = index4;
+          }
+          if (elements2 === null) {
+            address3 = FAILURE;
+          } else {
+            address3 = new TreeNode(this._input.substring(index4, this._offset), index4, elements2);
+            this._offset = this._offset;
+          }
+          if (address3 === FAILURE) {
+            this._offset = index3;
+            var chunk1 = null;
+            if (this._offset < this._inputSize) {
+              chunk1 = this._input.substring(this._offset, this._offset + 1);
+            }
+            if (chunk1 !== null && /^[^']/.test(chunk1)) {
+              address3 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+              this._offset = this._offset + 1;
+            } else {
+              address3 = FAILURE;
+              if (this._offset > this._failure) {
+                this._failure = this._offset;
+                this._expected = [];
+              }
+              if (this._offset === this._failure) {
+                this._expected.push('[^\']');
+              }
+            }
+            if (address3 === FAILURE) {
+              this._offset = index3;
+            }
+          }
+          if (address3 !== FAILURE) {
+            elements1.push(address3);
+            --remaining0;
+          }
+        }
+        if (remaining0 <= 0) {
+          address2 = new TreeNode(this._input.substring(index2, this._offset), index2, elements1);
+          this._offset = this._offset;
+        } else {
+          address2 = FAILURE;
+        }
+        if (address2 !== FAILURE) {
+          elements0[0] = address2;
+          var address6 = FAILURE;
+          address6 = this._read_single_quote();
+          if (address6 !== FAILURE) {
+          } else {
+            elements0 = null;
+            this._offset = index1;
+          }
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = this._actions.make_string(this._input, index1, this._offset, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._single_quote_string[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_hex_string: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._hex_string = this._cache._hex_string || {};
+      var cached = this._cache._hex_string[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset;
+      address0 = this._read_hex_single_quote();
+      if (address0 === FAILURE) {
+        this._offset = index1;
+        address0 = this._read_hex_double_quote();
+        if (address0 === FAILURE) {
+          this._offset = index1;
+        }
+      }
+      this._cache._hex_string[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_hex_value: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._hex_value = this._cache._hex_value || {};
+      var cached = this._cache._hex_value[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var remaining0 = 1, index1 = this._offset, elements0 = [], address1 = true;
+      while (address1 !== FAILURE) {
+        var chunk0 = null;
+        if (this._offset < this._inputSize) {
+          chunk0 = this._input.substring(this._offset, this._offset + 1);
+        }
+        if (chunk0 !== null && /^[a-fA-F0-9]/.test(chunk0)) {
+          address1 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+          this._offset = this._offset + 1;
+        } else {
+          address1 = FAILURE;
+          if (this._offset > this._failure) {
+            this._failure = this._offset;
+            this._expected = [];
+          }
+          if (this._offset === this._failure) {
+            this._expected.push('[a-fA-F0-9]');
+          }
+        }
+        if (address1 !== FAILURE) {
+          elements0.push(address1);
+          --remaining0;
+        }
+      }
+      if (remaining0 <= 0) {
+        address0 = new TreeNode(this._input.substring(index1, this._offset), index1, elements0);
+        this._offset = this._offset;
+      } else {
+        address0 = FAILURE;
+      }
+      this._cache._hex_value[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_hex_single_quote: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._hex_single_quote = this._cache._hex_single_quote || {};
+      var cached = this._cache._hex_single_quote[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = new Array(1);
+      var address1 = FAILURE;
+      address1 = this._read_single_quote();
+      if (address1 !== FAILURE) {
+        var address2 = FAILURE;
+        address2 = this._read_hex_value();
+        if (address2 !== FAILURE) {
+          elements0[0] = address2;
+          var address3 = FAILURE;
+          address3 = this._read_single_quote();
+          if (address3 !== FAILURE) {
+          } else {
+            elements0 = null;
+            this._offset = index1;
+          }
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = this._actions.make_string(this._input, index1, this._offset, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._hex_single_quote[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_hex_double_quote: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._hex_double_quote = this._cache._hex_double_quote || {};
+      var cached = this._cache._hex_double_quote[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = new Array(1);
+      var address1 = FAILURE;
+      address1 = this._read_double_quote();
+      if (address1 !== FAILURE) {
+        var address2 = FAILURE;
+        address2 = this._read_hex_value();
+        if (address2 !== FAILURE) {
+          elements0[0] = address2;
+          var address3 = FAILURE;
+          address3 = this._read_double_quote();
+          if (address3 !== FAILURE) {
+          } else {
+            elements0 = null;
+            this._offset = index1;
+          }
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = this._actions.make_string(this._input, index1, this._offset, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._hex_double_quote[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_integer_string: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._integer_string = this._cache._integer_string || {};
+      var cached = this._cache._integer_string[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset;
+      address0 = this._read_integer_string_single();
+      if (address0 === FAILURE) {
+        this._offset = index1;
+        address0 = this._read_integer_string_double();
+        if (address0 === FAILURE) {
+          this._offset = index1;
+        }
+      }
+      this._cache._integer_string[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_integer_string_single: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._integer_string_single = this._cache._integer_string_single || {};
+      var cached = this._cache._integer_string_single[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = new Array(1);
+      var address1 = FAILURE;
+      address1 = this._read_single_quote();
+      if (address1 !== FAILURE) {
+        var address2 = FAILURE;
+        address2 = this._read_integer_number();
+        if (address2 !== FAILURE) {
+          elements0[0] = address2;
+          var address3 = FAILURE;
+          address3 = this._read_single_quote();
+          if (address3 !== FAILURE) {
+          } else {
+            elements0 = null;
+            this._offset = index1;
+          }
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = this._actions.make_numeric_string(this._input, index1, this._offset, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._integer_string_single[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_integer_string_double: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._integer_string_double = this._cache._integer_string_double || {};
+      var cached = this._cache._integer_string_double[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = new Array(1);
+      var address1 = FAILURE;
+      address1 = this._read_double_quote();
+      if (address1 !== FAILURE) {
+        var address2 = FAILURE;
+        address2 = this._read_integer_number();
+        if (address2 !== FAILURE) {
+          elements0[0] = address2;
+          var address3 = FAILURE;
+          address3 = this._read_double_quote();
+          if (address3 !== FAILURE) {
+          } else {
+            elements0 = null;
+            this._offset = index1;
+          }
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = this._actions.make_numeric_string(this._input, index1, this._offset, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._integer_string_double[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_number_string: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._number_string = this._cache._number_string || {};
+      var cached = this._cache._number_string[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset;
+      address0 = this._read_number_string_single();
+      if (address0 === FAILURE) {
+        this._offset = index1;
+        address0 = this._read_number_string_double();
+        if (address0 === FAILURE) {
+          this._offset = index1;
+        }
+      }
+      this._cache._number_string[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_number_string_single: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._number_string_single = this._cache._number_string_single || {};
+      var cached = this._cache._number_string_single[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = new Array(1);
+      var address1 = FAILURE;
+      address1 = this._read_single_quote();
+      if (address1 !== FAILURE) {
+        var address2 = FAILURE;
+        address2 = this._read_number();
+        if (address2 !== FAILURE) {
+          elements0[0] = address2;
+          var address3 = FAILURE;
+          address3 = this._read_single_quote();
+          if (address3 !== FAILURE) {
+          } else {
+            elements0 = null;
+            this._offset = index1;
+          }
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = this._actions.make_numeric_string(this._input, index1, this._offset, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._number_string_single[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_number_string_double: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._number_string_double = this._cache._number_string_double || {};
+      var cached = this._cache._number_string_double[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = new Array(1);
+      var address1 = FAILURE;
+      address1 = this._read_double_quote();
+      if (address1 !== FAILURE) {
+        var address2 = FAILURE;
+        address2 = this._read_number();
+        if (address2 !== FAILURE) {
+          elements0[0] = address2;
+          var address3 = FAILURE;
+          address3 = this._read_double_quote();
+          if (address3 !== FAILURE) {
+          } else {
+            elements0 = null;
+            this._offset = index1;
+          }
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = this._actions.make_numeric_string(this._input, index1, this._offset, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._number_string_double[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_regexp_string: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._regexp_string = this._cache._regexp_string || {};
+      var cached = this._cache._regexp_string[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = new Array(2);
+      var address1 = FAILURE;
+      address1 = this._read_slash();
+      if (address1 !== FAILURE) {
+        var address2 = FAILURE;
+        var remaining0 = 0, index2 = this._offset, elements1 = [], address3 = true;
+        while (address3 !== FAILURE) {
+          var index3 = this._offset;
+          var index4 = this._offset, elements2 = new Array(2);
+          var address4 = FAILURE;
+          var chunk0 = null;
+          if (this._offset < this._inputSize) {
+            chunk0 = this._input.substring(this._offset, this._offset + 1);
+          }
+          if (chunk0 === '\\') {
+            address4 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+            this._offset = this._offset + 1;
+          } else {
+            address4 = FAILURE;
+            if (this._offset > this._failure) {
+              this._failure = this._offset;
+              this._expected = [];
+            }
+            if (this._offset === this._failure) {
+              this._expected.push('"\\\\"');
+            }
+          }
+          if (address4 !== FAILURE) {
+            elements2[0] = address4;
+            var address5 = FAILURE;
+            if (this._offset < this._inputSize) {
+              address5 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+              this._offset = this._offset + 1;
+            } else {
+              address5 = FAILURE;
+              if (this._offset > this._failure) {
+                this._failure = this._offset;
+                this._expected = [];
+              }
+              if (this._offset === this._failure) {
+                this._expected.push('<any char>');
+              }
+            }
+            if (address5 !== FAILURE) {
+              elements2[1] = address5;
+            } else {
+              elements2 = null;
+              this._offset = index4;
+            }
+          } else {
+            elements2 = null;
+            this._offset = index4;
+          }
+          if (elements2 === null) {
+            address3 = FAILURE;
+          } else {
+            address3 = new TreeNode(this._input.substring(index4, this._offset), index4, elements2);
+            this._offset = this._offset;
+          }
+          if (address3 === FAILURE) {
+            this._offset = index3;
+            var chunk1 = null;
+            if (this._offset < this._inputSize) {
+              chunk1 = this._input.substring(this._offset, this._offset + 1);
+            }
+            if (chunk1 !== null && /^[^\/]/.test(chunk1)) {
+              address3 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+              this._offset = this._offset + 1;
+            } else {
+              address3 = FAILURE;
+              if (this._offset > this._failure) {
+                this._failure = this._offset;
+                this._expected = [];
+              }
+              if (this._offset === this._failure) {
+                this._expected.push('[^\\/]');
+              }
+            }
+            if (address3 === FAILURE) {
+              this._offset = index3;
+            }
+          }
+          if (address3 !== FAILURE) {
+            elements1.push(address3);
+            --remaining0;
+          }
+        }
+        if (remaining0 <= 0) {
+          address2 = new TreeNode(this._input.substring(index2, this._offset), index2, elements1);
+          this._offset = this._offset;
+        } else {
+          address2 = FAILURE;
+        }
+        if (address2 !== FAILURE) {
+          elements0[0] = address2;
+          var address6 = FAILURE;
+          address6 = this._read_slash();
+          if (address6 !== FAILURE) {
+            var address7 = FAILURE;
+            var index5 = this._offset;
+            address7 = this._read_regexp_options();
+            if (address7 === FAILURE) {
+              address7 = new TreeNode(this._input.substring(index5, index5), index5);
+              this._offset = index5;
+            }
+            if (address7 !== FAILURE) {
+              elements0[1] = address7;
+            } else {
+              elements0 = null;
+              this._offset = index1;
+            }
+          } else {
+            elements0 = null;
+            this._offset = index1;
+          }
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = this._actions.make_regexp(this._input, index1, this._offset, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._regexp_string[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_regexp_options: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._regexp_options = this._cache._regexp_options || {};
+      var cached = this._cache._regexp_options[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var remaining0 = 1, index1 = this._offset, elements0 = [], address1 = true;
+      while (address1 !== FAILURE) {
+        var chunk0 = null;
+        if (this._offset < this._inputSize) {
+          chunk0 = this._input.substring(this._offset, this._offset + 1);
+        }
+        if (chunk0 !== null && /^[gims]/.test(chunk0)) {
+          address1 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+          this._offset = this._offset + 1;
+        } else {
+          address1 = FAILURE;
+          if (this._offset > this._failure) {
+            this._failure = this._offset;
+            this._expected = [];
+          }
+          if (this._offset === this._failure) {
+            this._expected.push('[gims]');
+          }
+        }
+        if (address1 !== FAILURE) {
+          elements0.push(address1);
+          --remaining0;
+        }
+      }
+      if (remaining0 <= 0) {
+        address0 = new TreeNode(this._input.substring(index1, this._offset), index1, elements0);
+        this._offset = this._offset;
+      } else {
+        address0 = FAILURE;
+      }
+      this._cache._regexp_options[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_base64_string: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._base64_string = this._cache._base64_string || {};
+      var cached = this._cache._base64_string[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset;
+      address0 = this._read_base64_single_quote();
+      if (address0 === FAILURE) {
+        this._offset = index1;
+        address0 = this._read_base64_dobule_quote();
+        if (address0 === FAILURE) {
+          this._offset = index1;
+        }
+      }
+      this._cache._base64_string[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_base64_value: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._base64_value = this._cache._base64_value || {};
+      var cached = this._cache._base64_value[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = new Array(2);
+      var address1 = FAILURE;
+      var remaining0 = 1, index2 = this._offset, elements1 = [], address2 = true;
+      while (address2 !== FAILURE) {
+        var chunk0 = null;
+        if (this._offset < this._inputSize) {
+          chunk0 = this._input.substring(this._offset, this._offset + 1);
+        }
+        if (chunk0 !== null && /^[a-zA-Z0-9+\/]/.test(chunk0)) {
+          address2 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+          this._offset = this._offset + 1;
+        } else {
+          address2 = FAILURE;
+          if (this._offset > this._failure) {
+            this._failure = this._offset;
+            this._expected = [];
+          }
+          if (this._offset === this._failure) {
+            this._expected.push('[a-zA-Z0-9+\\/]');
+          }
+        }
+        if (address2 !== FAILURE) {
+          elements1.push(address2);
+          --remaining0;
+        }
+      }
+      if (remaining0 <= 0) {
+        address1 = new TreeNode(this._input.substring(index2, this._offset), index2, elements1);
+        this._offset = this._offset;
+      } else {
+        address1 = FAILURE;
+      }
+      if (address1 !== FAILURE) {
+        elements0[0] = address1;
+        var address3 = FAILURE;
+        var index3 = this._offset;
+        var index4 = this._offset;
+        var chunk1 = null;
+        if (this._offset < this._inputSize) {
+          chunk1 = this._input.substring(this._offset, this._offset + 1);
+        }
+        if (chunk1 === '=') {
+          address3 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+          this._offset = this._offset + 1;
+        } else {
+          address3 = FAILURE;
+          if (this._offset > this._failure) {
+            this._failure = this._offset;
+            this._expected = [];
+          }
+          if (this._offset === this._failure) {
+            this._expected.push('"="');
+          }
+        }
+        if (address3 === FAILURE) {
+          this._offset = index4;
+          var chunk2 = null;
+          if (this._offset < this._inputSize) {
+            chunk2 = this._input.substring(this._offset, this._offset + 2);
+          }
+          if (chunk2 === '==') {
+            address3 = new TreeNode(this._input.substring(this._offset, this._offset + 2), this._offset);
+            this._offset = this._offset + 2;
+          } else {
+            address3 = FAILURE;
+            if (this._offset > this._failure) {
+              this._failure = this._offset;
+              this._expected = [];
+            }
+            if (this._offset === this._failure) {
+              this._expected.push('"=="');
+            }
+          }
+          if (address3 === FAILURE) {
+            this._offset = index4;
+          }
+        }
+        if (address3 === FAILURE) {
+          address3 = new TreeNode(this._input.substring(index3, index3), index3);
+          this._offset = index3;
+        }
+        if (address3 !== FAILURE) {
+          elements0[1] = address3;
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = new TreeNode(this._input.substring(index1, this._offset), index1, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._base64_value[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_base64_single_quote: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._base64_single_quote = this._cache._base64_single_quote || {};
+      var cached = this._cache._base64_single_quote[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = new Array(1);
+      var address1 = FAILURE;
+      address1 = this._read_single_quote();
+      if (address1 !== FAILURE) {
+        var address2 = FAILURE;
+        address2 = this._read_base64_value();
+        if (address2 !== FAILURE) {
+          elements0[0] = address2;
+          var address3 = FAILURE;
+          address3 = this._read_single_quote();
+          if (address3 !== FAILURE) {
+          } else {
+            elements0 = null;
+            this._offset = index1;
+          }
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = this._actions.make_string(this._input, index1, this._offset, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._base64_single_quote[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_base64_dobule_quote: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._base64_dobule_quote = this._cache._base64_dobule_quote || {};
+      var cached = this._cache._base64_dobule_quote[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = new Array(1);
+      var address1 = FAILURE;
+      address1 = this._read_double_quote();
+      if (address1 !== FAILURE) {
+        var address2 = FAILURE;
+        address2 = this._read_base64_value();
+        if (address2 !== FAILURE) {
+          elements0[0] = address2;
+          var address3 = FAILURE;
+          address3 = this._read_double_quote();
+          if (address3 !== FAILURE) {
+          } else {
+            elements0 = null;
+            this._offset = index1;
+          }
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = this._actions.make_string(this._input, index1, this._offset, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._base64_dobule_quote[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_number: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._number = this._cache._number || {};
+      var cached = this._cache._number[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = new Array(4);
+      var address1 = FAILURE;
+      var index2 = this._offset;
+      var chunk0 = null;
+      if (this._offset < this._inputSize) {
+        chunk0 = this._input.substring(this._offset, this._offset + 1);
+      }
+      if (chunk0 === '-') {
+        address1 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+        this._offset = this._offset + 1;
+      } else {
+        address1 = FAILURE;
+        if (this._offset > this._failure) {
+          this._failure = this._offset;
+          this._expected = [];
+        }
+        if (this._offset === this._failure) {
+          this._expected.push('"-"');
+        }
+      }
+      if (address1 === FAILURE) {
+        address1 = new TreeNode(this._input.substring(index2, index2), index2);
+        this._offset = index2;
+      }
+      if (address1 !== FAILURE) {
+        elements0[0] = address1;
+        var address2 = FAILURE;
+        address2 = this._read_integer();
+        if (address2 !== FAILURE) {
+          elements0[1] = address2;
+          var address3 = FAILURE;
+          var index3 = this._offset;
+          address3 = this._read_fraction();
+          if (address3 === FAILURE) {
+            address3 = new TreeNode(this._input.substring(index3, index3), index3);
+            this._offset = index3;
+          }
+          if (address3 !== FAILURE) {
+            elements0[2] = address3;
+            var address4 = FAILURE;
+            var index4 = this._offset;
+            address4 = this._read_exponent();
+            if (address4 === FAILURE) {
+              address4 = new TreeNode(this._input.substring(index4, index4), index4);
+              this._offset = index4;
+            }
+            if (address4 !== FAILURE) {
+              elements0[3] = address4;
+            } else {
+              elements0 = null;
+              this._offset = index1;
+            }
+          } else {
+            elements0 = null;
+            this._offset = index1;
+          }
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = this._actions.make_number(this._input, index1, this._offset, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._number[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_number_as_string: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._number_as_string = this._cache._number_as_string || {};
+      var cached = this._cache._number_as_string[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = new Array(4);
+      var address1 = FAILURE;
+      var index2 = this._offset;
+      var chunk0 = null;
+      if (this._offset < this._inputSize) {
+        chunk0 = this._input.substring(this._offset, this._offset + 1);
+      }
+      if (chunk0 === '-') {
+        address1 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+        this._offset = this._offset + 1;
+      } else {
+        address1 = FAILURE;
+        if (this._offset > this._failure) {
+          this._failure = this._offset;
+          this._expected = [];
+        }
+        if (this._offset === this._failure) {
+          this._expected.push('"-"');
+        }
+      }
+      if (address1 === FAILURE) {
+        address1 = new TreeNode(this._input.substring(index2, index2), index2);
+        this._offset = index2;
+      }
+      if (address1 !== FAILURE) {
+        elements0[0] = address1;
+        var address2 = FAILURE;
+        address2 = this._read_integer();
+        if (address2 !== FAILURE) {
+          elements0[1] = address2;
+          var address3 = FAILURE;
+          var index3 = this._offset;
+          address3 = this._read_fraction();
+          if (address3 === FAILURE) {
+            address3 = new TreeNode(this._input.substring(index3, index3), index3);
+            this._offset = index3;
+          }
+          if (address3 !== FAILURE) {
+            elements0[2] = address3;
+            var address4 = FAILURE;
+            var index4 = this._offset;
+            address4 = this._read_exponent();
+            if (address4 === FAILURE) {
+              address4 = new TreeNode(this._input.substring(index4, index4), index4);
+              this._offset = index4;
+            }
+            if (address4 !== FAILURE) {
+              elements0[3] = address4;
+            } else {
+              elements0 = null;
+              this._offset = index1;
+            }
+          } else {
+            elements0 = null;
+            this._offset = index1;
+          }
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = this._actions.make_number_as_string(this._input, index1, this._offset, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._number_as_string[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_integer: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._integer = this._cache._integer || {};
+      var cached = this._cache._integer[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset;
+      var chunk0 = null;
+      if (this._offset < this._inputSize) {
+        chunk0 = this._input.substring(this._offset, this._offset + 1);
+      }
+      if (chunk0 === '0') {
+        address0 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+        this._offset = this._offset + 1;
+      } else {
+        address0 = FAILURE;
+        if (this._offset > this._failure) {
+          this._failure = this._offset;
+          this._expected = [];
+        }
+        if (this._offset === this._failure) {
+          this._expected.push('"0"');
+        }
+      }
+      if (address0 === FAILURE) {
+        this._offset = index1;
+        var index2 = this._offset, elements0 = new Array(2);
+        var address1 = FAILURE;
+        var chunk1 = null;
+        if (this._offset < this._inputSize) {
+          chunk1 = this._input.substring(this._offset, this._offset + 1);
+        }
+        if (chunk1 !== null && /^[1-9]/.test(chunk1)) {
+          address1 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+          this._offset = this._offset + 1;
+        } else {
+          address1 = FAILURE;
+          if (this._offset > this._failure) {
+            this._failure = this._offset;
+            this._expected = [];
+          }
+          if (this._offset === this._failure) {
+            this._expected.push('[1-9]');
+          }
+        }
+        if (address1 !== FAILURE) {
+          elements0[0] = address1;
+          var address2 = FAILURE;
+          var remaining0 = 0, index3 = this._offset, elements1 = [], address3 = true;
+          while (address3 !== FAILURE) {
+            var chunk2 = null;
+            if (this._offset < this._inputSize) {
+              chunk2 = this._input.substring(this._offset, this._offset + 1);
+            }
+            if (chunk2 !== null && /^[0-9]/.test(chunk2)) {
+              address3 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+              this._offset = this._offset + 1;
+            } else {
+              address3 = FAILURE;
+              if (this._offset > this._failure) {
+                this._failure = this._offset;
+                this._expected = [];
+              }
+              if (this._offset === this._failure) {
+                this._expected.push('[0-9]');
+              }
+            }
+            if (address3 !== FAILURE) {
+              elements1.push(address3);
+              --remaining0;
+            }
+          }
+          if (remaining0 <= 0) {
+            address2 = new TreeNode(this._input.substring(index3, this._offset), index3, elements1);
+            this._offset = this._offset;
+          } else {
+            address2 = FAILURE;
+          }
+          if (address2 !== FAILURE) {
+            elements0[1] = address2;
+          } else {
+            elements0 = null;
+            this._offset = index2;
+          }
+        } else {
+          elements0 = null;
+          this._offset = index2;
+        }
+        if (elements0 === null) {
+          address0 = FAILURE;
+        } else {
+          address0 = new TreeNode(this._input.substring(index2, this._offset), index2, elements0);
+          this._offset = this._offset;
+        }
+        if (address0 === FAILURE) {
+          this._offset = index1;
+        }
+      }
+      this._cache._integer[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_fraction: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._fraction = this._cache._fraction || {};
+      var cached = this._cache._fraction[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = new Array(2);
+      var address1 = FAILURE;
+      var chunk0 = null;
+      if (this._offset < this._inputSize) {
+        chunk0 = this._input.substring(this._offset, this._offset + 1);
+      }
+      if (chunk0 === '.') {
+        address1 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+        this._offset = this._offset + 1;
+      } else {
+        address1 = FAILURE;
+        if (this._offset > this._failure) {
+          this._failure = this._offset;
+          this._expected = [];
+        }
+        if (this._offset === this._failure) {
+          this._expected.push('"."');
+        }
+      }
+      if (address1 !== FAILURE) {
+        elements0[0] = address1;
+        var address2 = FAILURE;
+        var remaining0 = 1, index2 = this._offset, elements1 = [], address3 = true;
+        while (address3 !== FAILURE) {
+          var chunk1 = null;
+          if (this._offset < this._inputSize) {
+            chunk1 = this._input.substring(this._offset, this._offset + 1);
+          }
+          if (chunk1 !== null && /^[0-9]/.test(chunk1)) {
+            address3 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+            this._offset = this._offset + 1;
+          } else {
+            address3 = FAILURE;
+            if (this._offset > this._failure) {
+              this._failure = this._offset;
+              this._expected = [];
+            }
+            if (this._offset === this._failure) {
+              this._expected.push('[0-9]');
+            }
+          }
+          if (address3 !== FAILURE) {
+            elements1.push(address3);
+            --remaining0;
+          }
+        }
+        if (remaining0 <= 0) {
+          address2 = new TreeNode(this._input.substring(index2, this._offset), index2, elements1);
+          this._offset = this._offset;
+        } else {
+          address2 = FAILURE;
+        }
+        if (address2 !== FAILURE) {
+          elements0[1] = address2;
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = new TreeNode(this._input.substring(index1, this._offset), index1, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._fraction[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_exponent: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._exponent = this._cache._exponent || {};
+      var cached = this._cache._exponent[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = new Array(3);
+      var address1 = FAILURE;
+      var index2 = this._offset;
+      var chunk0 = null;
+      if (this._offset < this._inputSize) {
+        chunk0 = this._input.substring(this._offset, this._offset + 1);
+      }
+      if (chunk0 === 'e') {
+        address1 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+        this._offset = this._offset + 1;
+      } else {
+        address1 = FAILURE;
+        if (this._offset > this._failure) {
+          this._failure = this._offset;
+          this._expected = [];
+        }
+        if (this._offset === this._failure) {
+          this._expected.push('"e"');
+        }
+      }
+      if (address1 === FAILURE) {
+        this._offset = index2;
+        var chunk1 = null;
+        if (this._offset < this._inputSize) {
+          chunk1 = this._input.substring(this._offset, this._offset + 1);
+        }
+        if (chunk1 === 'E') {
+          address1 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+          this._offset = this._offset + 1;
+        } else {
+          address1 = FAILURE;
+          if (this._offset > this._failure) {
+            this._failure = this._offset;
+            this._expected = [];
+          }
+          if (this._offset === this._failure) {
+            this._expected.push('"E"');
+          }
+        }
+        if (address1 === FAILURE) {
+          this._offset = index2;
+        }
+      }
+      if (address1 !== FAILURE) {
+        elements0[0] = address1;
+        var address2 = FAILURE;
+        var index3 = this._offset;
+        var chunk2 = null;
+        if (this._offset < this._inputSize) {
+          chunk2 = this._input.substring(this._offset, this._offset + 1);
+        }
+        if (chunk2 === '+') {
+          address2 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+          this._offset = this._offset + 1;
+        } else {
+          address2 = FAILURE;
+          if (this._offset > this._failure) {
+            this._failure = this._offset;
+            this._expected = [];
+          }
+          if (this._offset === this._failure) {
+            this._expected.push('"+"');
+          }
+        }
+        if (address2 === FAILURE) {
+          this._offset = index3;
+          var chunk3 = null;
+          if (this._offset < this._inputSize) {
+            chunk3 = this._input.substring(this._offset, this._offset + 1);
+          }
+          if (chunk3 === '-') {
+            address2 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+            this._offset = this._offset + 1;
+          } else {
+            address2 = FAILURE;
+            if (this._offset > this._failure) {
+              this._failure = this._offset;
+              this._expected = [];
+            }
+            if (this._offset === this._failure) {
+              this._expected.push('"-"');
+            }
+          }
+          if (address2 === FAILURE) {
+            this._offset = index3;
+            var chunk4 = null;
+            if (this._offset < this._inputSize) {
+              chunk4 = this._input.substring(this._offset, this._offset + 0);
+            }
+            if (chunk4 === '') {
+              address2 = new TreeNode(this._input.substring(this._offset, this._offset + 0), this._offset);
+              this._offset = this._offset + 0;
+            } else {
+              address2 = FAILURE;
+              if (this._offset > this._failure) {
+                this._failure = this._offset;
+                this._expected = [];
+              }
+              if (this._offset === this._failure) {
+                this._expected.push('""');
+              }
+            }
+            if (address2 === FAILURE) {
+              this._offset = index3;
+            }
+          }
+        }
+        if (address2 !== FAILURE) {
+          elements0[1] = address2;
+          var address3 = FAILURE;
+          var remaining0 = 1, index4 = this._offset, elements1 = [], address4 = true;
+          while (address4 !== FAILURE) {
+            var chunk5 = null;
+            if (this._offset < this._inputSize) {
+              chunk5 = this._input.substring(this._offset, this._offset + 1);
+            }
+            if (chunk5 !== null && /^[0-9]/.test(chunk5)) {
+              address4 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+              this._offset = this._offset + 1;
+            } else {
+              address4 = FAILURE;
+              if (this._offset > this._failure) {
+                this._failure = this._offset;
+                this._expected = [];
+              }
+              if (this._offset === this._failure) {
+                this._expected.push('[0-9]');
+              }
+            }
+            if (address4 !== FAILURE) {
+              elements1.push(address4);
+              --remaining0;
+            }
+          }
+          if (remaining0 <= 0) {
+            address3 = new TreeNode(this._input.substring(index4, this._offset), index4, elements1);
+            this._offset = this._offset;
+          } else {
+            address3 = FAILURE;
+          }
+          if (address3 !== FAILURE) {
+            elements0[2] = address3;
+          } else {
+            elements0 = null;
+            this._offset = index1;
+          }
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = new TreeNode(this._input.substring(index1, this._offset), index1, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._exponent[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_integer_number: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._integer_number = this._cache._integer_number || {};
+      var cached = this._cache._integer_number[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = new Array(1);
+      var address1 = FAILURE;
+      address1 = this._read_integer();
+      if (address1 !== FAILURE) {
+        elements0[0] = address1;
+        var address2 = FAILURE;
+        var chunk0 = null;
+        if (this._offset < this._inputSize) {
+          chunk0 = this._input.substring(this._offset, this._offset + 0);
+        }
+        if (chunk0 === '') {
+          address2 = new TreeNode(this._input.substring(this._offset, this._offset + 0), this._offset);
+          this._offset = this._offset + 0;
+        } else {
+          address2 = FAILURE;
+          if (this._offset > this._failure) {
+            this._failure = this._offset;
+            this._expected = [];
+          }
+          if (this._offset === this._failure) {
+            this._expected.push('""');
+          }
+        }
+        if (address2 !== FAILURE) {
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = this._actions.make_number(this._input, index1, this._offset, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._integer_number[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_min_key: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._min_key = this._cache._min_key || {};
+      var cached = this._cache._min_key[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var chunk0 = null;
+      if (this._offset < this._inputSize) {
+        chunk0 = this._input.substring(this._offset, this._offset + 6);
+      }
+      if (chunk0 === 'MinKey') {
+        address0 = this._actions.make_min_key(this._input, this._offset, this._offset + 6);
+        this._offset = this._offset + 6;
+      } else {
+        address0 = FAILURE;
+        if (this._offset > this._failure) {
+          this._failure = this._offset;
+          this._expected = [];
+        }
+        if (this._offset === this._failure) {
+          this._expected.push('"MinKey"');
+        }
+      }
+      this._cache._min_key[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_max_key: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._max_key = this._cache._max_key || {};
+      var cached = this._cache._max_key[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var chunk0 = null;
+      if (this._offset < this._inputSize) {
+        chunk0 = this._input.substring(this._offset, this._offset + 6);
+      }
+      if (chunk0 === 'MaxKey') {
+        address0 = this._actions.make_max_key(this._input, this._offset, this._offset + 6);
+        this._offset = this._offset + 6;
+      } else {
+        address0 = FAILURE;
+        if (this._offset > this._failure) {
+          this._failure = this._offset;
+          this._expected = [];
+        }
+        if (this._offset === this._failure) {
+          this._expected.push('"MaxKey"');
+        }
+      }
+      this._cache._max_key[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_undefined: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._undefined = this._cache._undefined || {};
+      var cached = this._cache._undefined[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var chunk0 = null;
+      if (this._offset < this._inputSize) {
+        chunk0 = this._input.substring(this._offset, this._offset + 9);
+      }
+      if (chunk0 === 'undefined') {
+        address0 = this._actions.make_undefined(this._input, this._offset, this._offset + 9);
+        this._offset = this._offset + 9;
+      } else {
+        address0 = FAILURE;
+        if (this._offset > this._failure) {
+          this._failure = this._offset;
+          this._expected = [];
+        }
+        if (this._offset === this._failure) {
+          this._expected.push('"undefined"');
+        }
+      }
+      this._cache._undefined[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_object_id: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._object_id = this._cache._object_id || {};
+      var cached = this._cache._object_id[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = new Array(1);
+      var address1 = FAILURE;
+      var chunk0 = null;
+      if (this._offset < this._inputSize) {
+        chunk0 = this._input.substring(this._offset, this._offset + 8);
+      }
+      if (chunk0 === 'ObjectId') {
+        address1 = new TreeNode(this._input.substring(this._offset, this._offset + 8), this._offset);
+        this._offset = this._offset + 8;
+      } else {
+        address1 = FAILURE;
+        if (this._offset > this._failure) {
+          this._failure = this._offset;
+          this._expected = [];
+        }
+        if (this._offset === this._failure) {
+          this._expected.push('"ObjectId"');
+        }
+      }
+      if (address1 !== FAILURE) {
+        var address2 = FAILURE;
+        address2 = this._read_type_open();
+        if (address2 !== FAILURE) {
+          var address3 = FAILURE;
+          address3 = this._read_hex_string();
+          if (address3 !== FAILURE) {
+            elements0[0] = address3;
+            var address4 = FAILURE;
+            address4 = this._read_type_close();
+            if (address4 !== FAILURE) {
+            } else {
+              elements0 = null;
+              this._offset = index1;
+            }
+          } else {
+            elements0 = null;
+            this._offset = index1;
+          }
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = this._actions.make_object_id(this._input, index1, this._offset, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._object_id[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_bin_data_type: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._bin_data_type = this._cache._bin_data_type || {};
+      var cached = this._cache._bin_data_type[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset;
+      address0 = this._read_string();
+      if (address0 === FAILURE) {
+        this._offset = index1;
+        address0 = this._read_integer_number();
+        if (address0 === FAILURE) {
+          this._offset = index1;
+        }
+      }
+      this._cache._bin_data_type[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_bin_data: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._bin_data = this._cache._bin_data || {};
+      var cached = this._cache._bin_data[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = new Array(2);
+      var address1 = FAILURE;
+      var chunk0 = null;
+      if (this._offset < this._inputSize) {
+        chunk0 = this._input.substring(this._offset, this._offset + 7);
+      }
+      if (chunk0 === 'BinData') {
+        address1 = new TreeNode(this._input.substring(this._offset, this._offset + 7), this._offset);
+        this._offset = this._offset + 7;
+      } else {
+        address1 = FAILURE;
+        if (this._offset > this._failure) {
+          this._failure = this._offset;
+          this._expected = [];
+        }
+        if (this._offset === this._failure) {
+          this._expected.push('"BinData"');
+        }
+      }
+      if (address1 !== FAILURE) {
+        var address2 = FAILURE;
+        address2 = this._read_type_open();
+        if (address2 !== FAILURE) {
+          var address3 = FAILURE;
+          address3 = this._read_bin_data_type();
+          if (address3 !== FAILURE) {
+            elements0[0] = address3;
+            var address4 = FAILURE;
+            address4 = this._read_delimiter();
+            if (address4 !== FAILURE) {
+              var address5 = FAILURE;
+              address5 = this._read_base64_string();
+              if (address5 !== FAILURE) {
+                elements0[1] = address5;
+                var address6 = FAILURE;
+                address6 = this._read_type_close();
+                if (address6 !== FAILURE) {
+                } else {
+                  elements0 = null;
+                  this._offset = index1;
+                }
+              } else {
+                elements0 = null;
+                this._offset = index1;
+              }
+            } else {
+              elements0 = null;
+              this._offset = index1;
+            }
+          } else {
+            elements0 = null;
+            this._offset = index1;
+          }
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = this._actions.make_bin_data(this._input, index1, this._offset, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._bin_data[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_timestamp: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._timestamp = this._cache._timestamp || {};
+      var cached = this._cache._timestamp[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = new Array(2);
+      var address1 = FAILURE;
+      var chunk0 = null;
+      if (this._offset < this._inputSize) {
+        chunk0 = this._input.substring(this._offset, this._offset + 9);
+      }
+      if (chunk0 === 'Timestamp') {
+        address1 = new TreeNode(this._input.substring(this._offset, this._offset + 9), this._offset);
+        this._offset = this._offset + 9;
+      } else {
+        address1 = FAILURE;
+        if (this._offset > this._failure) {
+          this._failure = this._offset;
+          this._expected = [];
+        }
+        if (this._offset === this._failure) {
+          this._expected.push('"Timestamp"');
+        }
+      }
+      if (address1 !== FAILURE) {
+        var address2 = FAILURE;
+        address2 = this._read_type_open();
+        if (address2 !== FAILURE) {
+          var address3 = FAILURE;
+          address3 = this._read_integer_number();
+          if (address3 !== FAILURE) {
+            elements0[0] = address3;
+            var address4 = FAILURE;
+            address4 = this._read_delimiter();
+            if (address4 !== FAILURE) {
+              var address5 = FAILURE;
+              address5 = this._read_integer_number();
+              if (address5 !== FAILURE) {
+                elements0[1] = address5;
+                var address6 = FAILURE;
+                address6 = this._read_type_close();
+                if (address6 !== FAILURE) {
+                } else {
+                  elements0 = null;
+                  this._offset = index1;
+                }
+              } else {
+                elements0 = null;
+                this._offset = index1;
+              }
+            } else {
+              elements0 = null;
+              this._offset = index1;
+            }
+          } else {
+            elements0 = null;
+            this._offset = index1;
+          }
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = this._actions.make_timestamp(this._input, index1, this._offset, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._timestamp[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_number_long_value: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._number_long_value = this._cache._number_long_value || {};
+      var cached = this._cache._number_long_value[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset;
+      address0 = this._read_integer_number();
+      if (address0 === FAILURE) {
+        this._offset = index1;
+        address0 = this._read_integer_string();
+        if (address0 === FAILURE) {
+          this._offset = index1;
+        }
+      }
+      this._cache._number_long_value[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_number_long: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._number_long = this._cache._number_long || {};
+      var cached = this._cache._number_long[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = new Array(1);
+      var address1 = FAILURE;
+      var chunk0 = null;
+      if (this._offset < this._inputSize) {
+        chunk0 = this._input.substring(this._offset, this._offset + 10);
+      }
+      if (chunk0 === 'NumberLong') {
+        address1 = new TreeNode(this._input.substring(this._offset, this._offset + 10), this._offset);
+        this._offset = this._offset + 10;
+      } else {
+        address1 = FAILURE;
+        if (this._offset > this._failure) {
+          this._failure = this._offset;
+          this._expected = [];
+        }
+        if (this._offset === this._failure) {
+          this._expected.push('"NumberLong"');
+        }
+      }
+      if (address1 !== FAILURE) {
+        var address2 = FAILURE;
+        address2 = this._read_type_open();
+        if (address2 !== FAILURE) {
+          var address3 = FAILURE;
+          address3 = this._read_number_long_value();
+          if (address3 !== FAILURE) {
+            elements0[0] = address3;
+            var address4 = FAILURE;
+            address4 = this._read_type_close();
+            if (address4 !== FAILURE) {
+            } else {
+              elements0 = null;
+              this._offset = index1;
+            }
+          } else {
+            elements0 = null;
+            this._offset = index1;
+          }
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = this._actions.make_number_long(this._input, index1, this._offset, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._number_long[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_number_decimal_value: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._number_decimal_value = this._cache._number_decimal_value || {};
+      var cached = this._cache._number_decimal_value[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset;
+      address0 = this._read_number_as_string();
+      if (address0 === FAILURE) {
+        this._offset = index1;
+        address0 = this._read_number_string();
+        if (address0 === FAILURE) {
+          this._offset = index1;
+        }
+      }
+      this._cache._number_decimal_value[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_number_decimal: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._number_decimal = this._cache._number_decimal || {};
+      var cached = this._cache._number_decimal[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = new Array(1);
+      var address1 = FAILURE;
+      var chunk0 = null;
+      if (this._offset < this._inputSize) {
+        chunk0 = this._input.substring(this._offset, this._offset + 13);
+      }
+      if (chunk0 === 'NumberDecimal') {
+        address1 = new TreeNode(this._input.substring(this._offset, this._offset + 13), this._offset);
+        this._offset = this._offset + 13;
+      } else {
+        address1 = FAILURE;
+        if (this._offset > this._failure) {
+          this._failure = this._offset;
+          this._expected = [];
+        }
+        if (this._offset === this._failure) {
+          this._expected.push('"NumberDecimal"');
+        }
+      }
+      if (address1 !== FAILURE) {
+        var address2 = FAILURE;
+        address2 = this._read_type_open();
+        if (address2 !== FAILURE) {
+          var address3 = FAILURE;
+          address3 = this._read_number_decimal_value();
+          if (address3 !== FAILURE) {
+            elements0[0] = address3;
+            var address4 = FAILURE;
+            address4 = this._read_type_close();
+            if (address4 !== FAILURE) {
+            } else {
+              elements0 = null;
+              this._offset = index1;
+            }
+          } else {
+            elements0 = null;
+            this._offset = index1;
+          }
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = this._actions.make_number_decimal(this._input, index1, this._offset, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._number_decimal[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_date_type: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._date_type = this._cache._date_type || {};
+      var cached = this._cache._date_type[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset;
+      var index2 = this._offset, elements0 = new Array(3);
+      var address1 = FAILURE;
+      var chunk0 = null;
+      if (this._offset < this._inputSize) {
+        chunk0 = this._input.substring(this._offset, this._offset + 3);
+      }
+      if (chunk0 === 'new') {
+        address1 = new TreeNode(this._input.substring(this._offset, this._offset + 3), this._offset);
+        this._offset = this._offset + 3;
+      } else {
+        address1 = FAILURE;
+        if (this._offset > this._failure) {
+          this._failure = this._offset;
+          this._expected = [];
+        }
+        if (this._offset === this._failure) {
+          this._expected.push('"new"');
+        }
+      }
+      if (address1 !== FAILURE) {
+        elements0[0] = address1;
+        var address2 = FAILURE;
+        var remaining0 = 1, index3 = this._offset, elements1 = [], address3 = true;
+        while (address3 !== FAILURE) {
+          address3 = this._read_space();
+          if (address3 !== FAILURE) {
+            elements1.push(address3);
+            --remaining0;
+          }
+        }
+        if (remaining0 <= 0) {
+          address2 = new TreeNode(this._input.substring(index3, this._offset), index3, elements1);
+          this._offset = this._offset;
+        } else {
+          address2 = FAILURE;
+        }
+        if (address2 !== FAILURE) {
+          elements0[1] = address2;
+          var address4 = FAILURE;
+          var chunk1 = null;
+          if (this._offset < this._inputSize) {
+            chunk1 = this._input.substring(this._offset, this._offset + 4);
+          }
+          if (chunk1 === 'Date') {
+            address4 = new TreeNode(this._input.substring(this._offset, this._offset + 4), this._offset);
+            this._offset = this._offset + 4;
+          } else {
+            address4 = FAILURE;
+            if (this._offset > this._failure) {
+              this._failure = this._offset;
+              this._expected = [];
+            }
+            if (this._offset === this._failure) {
+              this._expected.push('"Date"');
+            }
+          }
+          if (address4 !== FAILURE) {
+            elements0[2] = address4;
+          } else {
+            elements0 = null;
+            this._offset = index2;
+          }
+        } else {
+          elements0 = null;
+          this._offset = index2;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index2;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = new TreeNode(this._input.substring(index2, this._offset), index2, elements0);
+        this._offset = this._offset;
+      }
+      if (address0 === FAILURE) {
+        this._offset = index1;
+        var chunk2 = null;
+        if (this._offset < this._inputSize) {
+          chunk2 = this._input.substring(this._offset, this._offset + 7);
+        }
+        if (chunk2 === 'ISODate') {
+          address0 = new TreeNode(this._input.substring(this._offset, this._offset + 7), this._offset);
+          this._offset = this._offset + 7;
+        } else {
+          address0 = FAILURE;
+          if (this._offset > this._failure) {
+            this._failure = this._offset;
+            this._expected = [];
+          }
+          if (this._offset === this._failure) {
+            this._expected.push('"ISODate"');
+          }
+        }
+        if (address0 === FAILURE) {
+          this._offset = index1;
+        }
+      }
+      this._cache._date_type[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_date_value: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._date_value = this._cache._date_value || {};
+      var cached = this._cache._date_value[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset;
+      address0 = this._read_integer_number();
+      if (address0 === FAILURE) {
+        this._offset = index1;
+        address0 = this._read_string();
+        if (address0 === FAILURE) {
+          this._offset = index1;
+        }
+      }
+      this._cache._date_value[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_date: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._date = this._cache._date || {};
+      var cached = this._cache._date[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = new Array(1);
+      var address1 = FAILURE;
+      address1 = this._read_date_type();
+      if (address1 !== FAILURE) {
+        var address2 = FAILURE;
+        address2 = this._read_type_open();
+        if (address2 !== FAILURE) {
+          var address3 = FAILURE;
+          address3 = this._read_date_value();
+          if (address3 !== FAILURE) {
+            elements0[0] = address3;
+            var address4 = FAILURE;
+            address4 = this._read_type_close();
+            if (address4 !== FAILURE) {
+            } else {
+              elements0 = null;
+              this._offset = index1;
+            }
+          } else {
+            elements0 = null;
+            this._offset = index1;
+          }
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = this._actions.make_date(this._input, index1, this._offset, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._date[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_db_ref_type: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._db_ref_type = this._cache._db_ref_type || {};
+      var cached = this._cache._db_ref_type[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = new Array(2);
+      var address1 = FAILURE;
+      var chunk0 = null;
+      if (this._offset < this._inputSize) {
+        chunk0 = this._input.substring(this._offset, this._offset + 5);
+      }
+      if (chunk0 === 'DBRef') {
+        address1 = new TreeNode(this._input.substring(this._offset, this._offset + 5), this._offset);
+        this._offset = this._offset + 5;
+      } else {
+        address1 = FAILURE;
+        if (this._offset > this._failure) {
+          this._failure = this._offset;
+          this._expected = [];
+        }
+        if (this._offset === this._failure) {
+          this._expected.push('"DBRef"');
+        }
+      }
+      if (address1 !== FAILURE) {
+        var address2 = FAILURE;
+        address2 = this._read_type_open();
+        if (address2 !== FAILURE) {
+          var address3 = FAILURE;
+          address3 = this._read_string();
+          if (address3 !== FAILURE) {
+            elements0[0] = address3;
+            var address4 = FAILURE;
+            address4 = this._read_delimiter();
+            if (address4 !== FAILURE) {
+              var address5 = FAILURE;
+              address5 = this._read_string();
+              if (address5 !== FAILURE) {
+                elements0[1] = address5;
+                var address6 = FAILURE;
+                address6 = this._read_type_close();
+                if (address6 !== FAILURE) {
+                } else {
+                  elements0 = null;
+                  this._offset = index1;
+                }
+              } else {
+                elements0 = null;
+                this._offset = index1;
+              }
+            } else {
+              elements0 = null;
+              this._offset = index1;
+            }
+          } else {
+            elements0 = null;
+            this._offset = index1;
+          }
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = this._actions.make_db_ref(this._input, index1, this._offset, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._db_ref_type[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_single_quote: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._single_quote = this._cache._single_quote || {};
+      var cached = this._cache._single_quote[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var chunk0 = null;
+      if (this._offset < this._inputSize) {
+        chunk0 = this._input.substring(this._offset, this._offset + 1);
+      }
+      if (chunk0 === '\'') {
+        address0 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+        this._offset = this._offset + 1;
+      } else {
+        address0 = FAILURE;
+        if (this._offset > this._failure) {
+          this._failure = this._offset;
+          this._expected = [];
+        }
+        if (this._offset === this._failure) {
+          this._expected.push('"\'"');
+        }
+      }
+      this._cache._single_quote[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_double_quote: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._double_quote = this._cache._double_quote || {};
+      var cached = this._cache._double_quote[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var chunk0 = null;
+      if (this._offset < this._inputSize) {
+        chunk0 = this._input.substring(this._offset, this._offset + 1);
+      }
+      if (chunk0 === '"') {
+        address0 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+        this._offset = this._offset + 1;
+      } else {
+        address0 = FAILURE;
+        if (this._offset > this._failure) {
+          this._failure = this._offset;
+          this._expected = [];
+        }
+        if (this._offset === this._failure) {
+          this._expected.push('\'"\'');
+        }
+      }
+      this._cache._double_quote[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_left_paren: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._left_paren = this._cache._left_paren || {};
+      var cached = this._cache._left_paren[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var chunk0 = null;
+      if (this._offset < this._inputSize) {
+        chunk0 = this._input.substring(this._offset, this._offset + 1);
+      }
+      if (chunk0 === '(') {
+        address0 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+        this._offset = this._offset + 1;
+      } else {
+        address0 = FAILURE;
+        if (this._offset > this._failure) {
+          this._failure = this._offset;
+          this._expected = [];
+        }
+        if (this._offset === this._failure) {
+          this._expected.push('\'(\'');
+        }
+      }
+      this._cache._left_paren[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_right_paren: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._right_paren = this._cache._right_paren || {};
+      var cached = this._cache._right_paren[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var chunk0 = null;
+      if (this._offset < this._inputSize) {
+        chunk0 = this._input.substring(this._offset, this._offset + 1);
+      }
+      if (chunk0 === ')') {
+        address0 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+        this._offset = this._offset + 1;
+      } else {
+        address0 = FAILURE;
+        if (this._offset > this._failure) {
+          this._failure = this._offset;
+          this._expected = [];
+        }
+        if (this._offset === this._failure) {
+          this._expected.push('\')\'');
+        }
+      }
+      this._cache._right_paren[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_left_brace: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._left_brace = this._cache._left_brace || {};
+      var cached = this._cache._left_brace[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var chunk0 = null;
+      if (this._offset < this._inputSize) {
+        chunk0 = this._input.substring(this._offset, this._offset + 1);
+      }
+      if (chunk0 === '{') {
+        address0 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+        this._offset = this._offset + 1;
+      } else {
+        address0 = FAILURE;
+        if (this._offset > this._failure) {
+          this._failure = this._offset;
+          this._expected = [];
+        }
+        if (this._offset === this._failure) {
+          this._expected.push('\'{\'');
+        }
+      }
+      this._cache._left_brace[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_right_brace: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._right_brace = this._cache._right_brace || {};
+      var cached = this._cache._right_brace[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var chunk0 = null;
+      if (this._offset < this._inputSize) {
+        chunk0 = this._input.substring(this._offset, this._offset + 1);
+      }
+      if (chunk0 === '}') {
+        address0 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+        this._offset = this._offset + 1;
+      } else {
+        address0 = FAILURE;
+        if (this._offset > this._failure) {
+          this._failure = this._offset;
+          this._expected = [];
+        }
+        if (this._offset === this._failure) {
+          this._expected.push('\'}\'');
+        }
+      }
+      this._cache._right_brace[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_left_bracket: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._left_bracket = this._cache._left_bracket || {};
+      var cached = this._cache._left_bracket[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var chunk0 = null;
+      if (this._offset < this._inputSize) {
+        chunk0 = this._input.substring(this._offset, this._offset + 1);
+      }
+      if (chunk0 === '[') {
+        address0 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+        this._offset = this._offset + 1;
+      } else {
+        address0 = FAILURE;
+        if (this._offset > this._failure) {
+          this._failure = this._offset;
+          this._expected = [];
+        }
+        if (this._offset === this._failure) {
+          this._expected.push('\'[\'');
+        }
+      }
+      this._cache._left_bracket[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_right_bracket: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._right_bracket = this._cache._right_bracket || {};
+      var cached = this._cache._right_bracket[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var chunk0 = null;
+      if (this._offset < this._inputSize) {
+        chunk0 = this._input.substring(this._offset, this._offset + 1);
+      }
+      if (chunk0 === ']') {
+        address0 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+        this._offset = this._offset + 1;
+      } else {
+        address0 = FAILURE;
+        if (this._offset > this._failure) {
+          this._failure = this._offset;
+          this._expected = [];
+        }
+        if (this._offset === this._failure) {
+          this._expected.push('\']\'');
+        }
+      }
+      this._cache._right_bracket[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_comma: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._comma = this._cache._comma || {};
+      var cached = this._cache._comma[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var chunk0 = null;
+      if (this._offset < this._inputSize) {
+        chunk0 = this._input.substring(this._offset, this._offset + 1);
+      }
+      if (chunk0 === ',') {
+        address0 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+        this._offset = this._offset + 1;
+      } else {
+        address0 = FAILURE;
+        if (this._offset > this._failure) {
+          this._failure = this._offset;
+          this._expected = [];
+        }
+        if (this._offset === this._failure) {
+          this._expected.push('\',\'');
+        }
+      }
+      this._cache._comma[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_colon: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._colon = this._cache._colon || {};
+      var cached = this._cache._colon[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var chunk0 = null;
+      if (this._offset < this._inputSize) {
+        chunk0 = this._input.substring(this._offset, this._offset + 1);
+      }
+      if (chunk0 === ':') {
+        address0 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+        this._offset = this._offset + 1;
+      } else {
+        address0 = FAILURE;
+        if (this._offset > this._failure) {
+          this._failure = this._offset;
+          this._expected = [];
+        }
+        if (this._offset === this._failure) {
+          this._expected.push('\':\'');
+        }
+      }
+      this._cache._colon[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_slash: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._slash = this._cache._slash || {};
+      var cached = this._cache._slash[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var chunk0 = null;
+      if (this._offset < this._inputSize) {
+        chunk0 = this._input.substring(this._offset, this._offset + 1);
+      }
+      if (chunk0 === '/') {
+        address0 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+        this._offset = this._offset + 1;
+      } else {
+        address0 = FAILURE;
+        if (this._offset > this._failure) {
+          this._failure = this._offset;
+          this._expected = [];
+        }
+        if (this._offset === this._failure) {
+          this._expected.push('\'/\'');
+        }
+      }
+      this._cache._slash[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_space: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._space = this._cache._space || {};
+      var cached = this._cache._space[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var chunk0 = null;
+      if (this._offset < this._inputSize) {
+        chunk0 = this._input.substring(this._offset, this._offset + 1);
+      }
+      if (chunk0 !== null && /^[\s]/.test(chunk0)) {
+        address0 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+        this._offset = this._offset + 1;
+      } else {
+        address0 = FAILURE;
+        if (this._offset > this._failure) {
+          this._failure = this._offset;
+          this._expected = [];
+        }
+        if (this._offset === this._failure) {
+          this._expected.push('[\\s]');
+        }
+      }
+      this._cache._space[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_new_line: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._new_line = this._cache._new_line || {};
+      var cached = this._cache._new_line[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var chunk0 = null;
+      if (this._offset < this._inputSize) {
+        chunk0 = this._input.substring(this._offset, this._offset + 1);
+      }
+      if (chunk0 !== null && /^[\n]/.test(chunk0)) {
+        address0 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+        this._offset = this._offset + 1;
+      } else {
+        address0 = FAILURE;
+        if (this._offset > this._failure) {
+          this._failure = this._offset;
+          this._expected = [];
+        }
+        if (this._offset === this._failure) {
+          this._expected.push('[\\n]');
+        }
+      }
+      this._cache._new_line[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_comment: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._comment = this._cache._comment || {};
+      var cached = this._cache._comment[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = new Array(2);
+      var address1 = FAILURE;
+      var chunk0 = null;
+      if (this._offset < this._inputSize) {
+        chunk0 = this._input.substring(this._offset, this._offset + 2);
+      }
+      if (chunk0 === '//') {
+        address1 = new TreeNode(this._input.substring(this._offset, this._offset + 2), this._offset);
+        this._offset = this._offset + 2;
+      } else {
+        address1 = FAILURE;
+        if (this._offset > this._failure) {
+          this._failure = this._offset;
+          this._expected = [];
+        }
+        if (this._offset === this._failure) {
+          this._expected.push('"//"');
+        }
+      }
+      if (address1 !== FAILURE) {
+        elements0[0] = address1;
+        var address2 = FAILURE;
+        var remaining0 = 0, index2 = this._offset, elements1 = [], address3 = true;
+        while (address3 !== FAILURE) {
+          var chunk1 = null;
+          if (this._offset < this._inputSize) {
+            chunk1 = this._input.substring(this._offset, this._offset + 1);
+          }
+          if (chunk1 !== null && /^[^\n]/.test(chunk1)) {
+            address3 = new TreeNode(this._input.substring(this._offset, this._offset + 1), this._offset);
+            this._offset = this._offset + 1;
+          } else {
+            address3 = FAILURE;
+            if (this._offset > this._failure) {
+              this._failure = this._offset;
+              this._expected = [];
+            }
+            if (this._offset === this._failure) {
+              this._expected.push('[^\\n]');
+            }
+          }
+          if (address3 !== FAILURE) {
+            elements1.push(address3);
+            --remaining0;
+          }
+        }
+        if (remaining0 <= 0) {
+          address2 = new TreeNode(this._input.substring(index2, this._offset), index2, elements1);
+          this._offset = this._offset;
+        } else {
+          address2 = FAILURE;
+        }
+        if (address2 !== FAILURE) {
+          elements0[1] = address2;
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = new TreeNode(this._input.substring(index1, this._offset), index1, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._comment[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read___: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache.___ = this._cache.___ || {};
+      var cached = this._cache.___[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var remaining0 = 0, index1 = this._offset, elements0 = [], address1 = true;
+      while (address1 !== FAILURE) {
+        var index2 = this._offset;
+        address1 = this._read_space();
+        if (address1 === FAILURE) {
+          this._offset = index2;
+          address1 = this._read_new_line();
+          if (address1 === FAILURE) {
+            this._offset = index2;
+            address1 = this._read_comment();
+            if (address1 === FAILURE) {
+              this._offset = index2;
+            }
+          }
+        }
+        if (address1 !== FAILURE) {
+          elements0.push(address1);
+          --remaining0;
+        }
+      }
+      if (remaining0 <= 0) {
+        address0 = new TreeNode(this._input.substring(index1, this._offset), index1, elements0);
+        this._offset = this._offset;
+      } else {
+        address0 = FAILURE;
+      }
+      this._cache.___[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_delimiter: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._delimiter = this._cache._delimiter || {};
+      var cached = this._cache._delimiter[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = new Array(1);
+      var address1 = FAILURE;
+      address1 = this._read___();
+      if (address1 !== FAILURE) {
+        var address2 = FAILURE;
+        address2 = this._read_comma();
+        if (address2 !== FAILURE) {
+          elements0[0] = address2;
+          var address3 = FAILURE;
+          address3 = this._read___();
+          if (address3 !== FAILURE) {
+          } else {
+            elements0 = null;
+            this._offset = index1;
+          }
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = new TreeNode24(this._input.substring(index1, this._offset), index1, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._delimiter[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_assignment: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._assignment = this._cache._assignment || {};
+      var cached = this._cache._assignment[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = [];
+      var address1 = FAILURE;
+      address1 = this._read___();
+      if (address1 !== FAILURE) {
+        var address2 = FAILURE;
+        address2 = this._read_colon();
+        if (address2 !== FAILURE) {
+          var address3 = FAILURE;
+          address3 = this._read___();
+          if (address3 !== FAILURE) {
+          } else {
+            elements0 = null;
+            this._offset = index1;
+          }
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = new TreeNode(this._input.substring(index1, this._offset), index1, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._assignment[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_object_open: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._object_open = this._cache._object_open || {};
+      var cached = this._cache._object_open[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = [];
+      var address1 = FAILURE;
+      address1 = this._read___();
+      if (address1 !== FAILURE) {
+        var address2 = FAILURE;
+        address2 = this._read_left_brace();
+        if (address2 !== FAILURE) {
+          var address3 = FAILURE;
+          address3 = this._read___();
+          if (address3 !== FAILURE) {
+          } else {
+            elements0 = null;
+            this._offset = index1;
+          }
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = new TreeNode(this._input.substring(index1, this._offset), index1, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._object_open[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_object_close: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._object_close = this._cache._object_close || {};
+      var cached = this._cache._object_close[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = [];
+      var address1 = FAILURE;
+      address1 = this._read___();
+      if (address1 !== FAILURE) {
+        var address2 = FAILURE;
+        address2 = this._read_right_brace();
+        if (address2 !== FAILURE) {
+          var address3 = FAILURE;
+          address3 = this._read___();
+          if (address3 !== FAILURE) {
+          } else {
+            elements0 = null;
+            this._offset = index1;
+          }
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = new TreeNode(this._input.substring(index1, this._offset), index1, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._object_close[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_array_open: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._array_open = this._cache._array_open || {};
+      var cached = this._cache._array_open[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = [];
+      var address1 = FAILURE;
+      address1 = this._read___();
+      if (address1 !== FAILURE) {
+        var address2 = FAILURE;
+        address2 = this._read_left_bracket();
+        if (address2 !== FAILURE) {
+          var address3 = FAILURE;
+          address3 = this._read___();
+          if (address3 !== FAILURE) {
+          } else {
+            elements0 = null;
+            this._offset = index1;
+          }
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = new TreeNode(this._input.substring(index1, this._offset), index1, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._array_open[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_array_close: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._array_close = this._cache._array_close || {};
+      var cached = this._cache._array_close[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = [];
+      var address1 = FAILURE;
+      address1 = this._read___();
+      if (address1 !== FAILURE) {
+        var address2 = FAILURE;
+        address2 = this._read_right_bracket();
+        if (address2 !== FAILURE) {
+          var address3 = FAILURE;
+          address3 = this._read___();
+          if (address3 !== FAILURE) {
+          } else {
+            elements0 = null;
+            this._offset = index1;
+          }
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = new TreeNode(this._input.substring(index1, this._offset), index1, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._array_close[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_type_open: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._type_open = this._cache._type_open || {};
+      var cached = this._cache._type_open[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = [];
+      var address1 = FAILURE;
+      var remaining0 = 0, index2 = this._offset, elements1 = [], address2 = true;
+      while (address2 !== FAILURE) {
+        address2 = this._read_space();
+        if (address2 !== FAILURE) {
+          elements1.push(address2);
+          --remaining0;
+        }
+      }
+      if (remaining0 <= 0) {
+        address1 = new TreeNode(this._input.substring(index2, this._offset), index2, elements1);
+        this._offset = this._offset;
+      } else {
+        address1 = FAILURE;
+      }
+      if (address1 !== FAILURE) {
+        var address3 = FAILURE;
+        address3 = this._read_left_paren();
+        if (address3 !== FAILURE) {
+          var address4 = FAILURE;
+          var remaining1 = 0, index3 = this._offset, elements2 = [], address5 = true;
+          while (address5 !== FAILURE) {
+            address5 = this._read_space();
+            if (address5 !== FAILURE) {
+              elements2.push(address5);
+              --remaining1;
+            }
+          }
+          if (remaining1 <= 0) {
+            address4 = new TreeNode(this._input.substring(index3, this._offset), index3, elements2);
+            this._offset = this._offset;
+          } else {
+            address4 = FAILURE;
+          }
+          if (address4 !== FAILURE) {
+          } else {
+            elements0 = null;
+            this._offset = index1;
+          }
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = new TreeNode(this._input.substring(index1, this._offset), index1, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._type_open[index0] = [address0, this._offset];
+      return address0;
+    },
+
+    _read_type_close: function() {
+      var address0 = FAILURE, index0 = this._offset;
+      this._cache._type_close = this._cache._type_close || {};
+      var cached = this._cache._type_close[index0];
+      if (cached) {
+        this._offset = cached[1];
+        return cached[0];
+      }
+      var index1 = this._offset, elements0 = [];
+      var address1 = FAILURE;
+      var remaining0 = 0, index2 = this._offset, elements1 = [], address2 = true;
+      while (address2 !== FAILURE) {
+        address2 = this._read_space();
+        if (address2 !== FAILURE) {
+          elements1.push(address2);
+          --remaining0;
+        }
+      }
+      if (remaining0 <= 0) {
+        address1 = new TreeNode(this._input.substring(index2, this._offset), index2, elements1);
+        this._offset = this._offset;
+      } else {
+        address1 = FAILURE;
+      }
+      if (address1 !== FAILURE) {
+        var address3 = FAILURE;
+        address3 = this._read_right_paren();
+        if (address3 !== FAILURE) {
+        } else {
+          elements0 = null;
+          this._offset = index1;
+        }
+      } else {
+        elements0 = null;
+        this._offset = index1;
+      }
+      if (elements0 === null) {
+        address0 = FAILURE;
+      } else {
+        address0 = new TreeNode(this._input.substring(index1, this._offset), index1, elements0);
+        this._offset = this._offset;
+      }
+      this._cache._type_close[index0] = [address0, this._offset];
+      return address0;
+    }
+  };
+
+  var Parser = function(input, actions, types) {
+    this._input = input;
+    this._inputSize = input.length;
+    this._actions = actions;
+    this._types = types;
+    this._offset = 0;
+    this._cache = {};
+    this._failure = 0;
+    this._expected = [];
+  };
+
+  Parser.prototype.parse = function() {
+    var tree = this._read_root();
+    if (tree !== FAILURE && this._offset === this._inputSize) {
+      return tree;
+    }
+    if (this._expected.length === 0) {
+      this._failure = this._offset;
+      this._expected.push('<EOF>');
+    }
+    this.constructor.lastError = {offset: this._offset, expected: this._expected};
+    throw new SyntaxError(formatError(this._input, this._failure, this._expected));
+  };
+
+  var parse = function(input, options) {
+    options = options || {};
+    var parser = new Parser(input, options.actions, options.types);
+    return parser.parse();
+  };
+  extend(Parser.prototype, Grammar);
+
+  var exported = {Grammar: Grammar, Parser: Parser, parse: parse};
+
+  if (typeof require === 'function' && typeof exports === 'object') {
+    extend(exports, exported);
+  } else {
+    var namespace = typeof this !== 'undefined' ? this : window;
+    namespace.ExtendedJSON = exported;
+  }
+})();