ot-jed 0.0.11

package/lib/jed.js

@@ -0,0 +1,868 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+/**
+ * @preserve jed.js https://github.com/SlexAxton/Jed
+ */
+/*
+-----------
+A gettext compatible i18n library for modern JavaScript Applications
+
+by Alex Sexton - AlexSexton [at] gmail - @SlexAxton
+
+MIT License
+
+A jQuery Foundation project - requires CLA to contribute -
+https://contribute.jquery.org/CLA/
+
+
+
+Jed offers the entire applicable GNU gettext spec'd set of
+functions, but also offers some nicer wrappers around them.
+The api for gettext was written for a language with no function
+overloading, so Jed allows a little more of that.
+
+Many thanks to Joshua I. Miller - unrtst@cpan.org - who wrote
+gettext.js back in 2008. I was able to vet a lot of my ideas
+against his. I also made sure Jed passed against his tests
+in order to offer easy upgrades -- jsgettext.berlios.de
+*/
+
+// Set up some underscore-style functions, if you already have
+// underscore, feel free to delete this section, and use it
+// directly, however, the amount of functions used doesn't
+// warrant having underscore as a full dependency.
+// Underscore 1.3.0 was used to port and is licensed
+// under the MIT License by Jeremy Ashkenas.
+var ArrayProto = Array.prototype,
+    ObjProto = Object.prototype,
+    slice = ArrayProto.slice,
+    hasOwnProp = ObjProto.hasOwnProperty,
+    nativeForEach = ArrayProto.forEach,
+    breaker = {};
+
+// We're not using the OOP style _ so we don't need the
+// extra level of indirection. This still means that you
+// sub out for real `_` though.
+var _ = {
+  forEach: function forEach(obj, iterator, context) {
+    var i, l, key;
+    if (obj === null) {
+      return;
+    }
+
+    if (nativeForEach && obj.forEach === nativeForEach) {
+      obj.forEach(iterator, context);
+    } else if (obj.length === +obj.length) {
+      for (i = 0, l = obj.length; i < l; i++) {
+        if (i in obj && iterator.call(context, obj[i], i, obj) === breaker) {
+          return;
+        }
+      }
+    } else {
+      for (key in obj) {
+        if (hasOwnProp.call(obj, key)) {
+          if (iterator.call(context, obj[key], key, obj) === breaker) {
+            return;
+          }
+        }
+      }
+    }
+  },
+  extend: function extend(obj) {
+    this.forEach(slice.call(arguments, 1), function (source) {
+      for (var prop in source) {
+        obj[prop] = source[prop];
+      }
+    });
+    return obj;
+  },
+  // memoize function taken from lodash@4.17.21
+  // original function included 
+  // memoized.cache = new (memoize.Cache || Map)
+  // changed to memoized.cache = new Map()
+  // added semicolons
+  memoize: function memoize(func, resolver) {
+    if (typeof func !== 'function' || resolver != null && typeof resolver !== 'function') {
+      throw new TypeError('Expected a function');
+    }
+    var memoized = function memoized() {
+      for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      var key = resolver ? resolver.apply(this, args) : args[0];
+      var cache = memoized.cache;
+
+      if (cache.has(key)) {
+        return cache.get(key);
+      }
+      var result = func.apply(this, args);
+      memoized.cache = cache.set(key, result) || cache;
+      return result;
+    };
+    memoized.cache = new Map();
+    return memoized;
+  }
+};
+// END Miniature underscore impl
+
+// Jed is a constructor function
+var Jed = function Jed(options) {
+  // Some minimal defaults
+  this.defaults = {
+    "locale_data": {
+      "messages": {
+        "": {
+          "domain": "messages",
+          "lang": "en",
+          "plural_forms": "nplurals=2; plural=(n != 1);"
+          // There are no default keys, though
+        } }
+    },
+    // The default domain if one is missing
+    "domain": "messages",
+    // enable debug mode to log untranslated strings to the console
+    "debug": false
+  };
+
+  // Mix in the sent options with the default options
+  this.options = _.extend({}, this.defaults, options);
+  this.textdomain(this.options.domain);
+
+  if (options.domain && !this.options.locale_data[this.options.domain]) {
+    throw new Error('Text domain set to non-existent domain: `' + options.domain + '`');
+  }
+};
+
+// The gettext spec sets this character as the default
+// delimiter for context lookups.
+// e.g.: context\u0004key
+// If your translation company uses something different,
+// just change this at any time and it will use that instead.
+Jed.context_delimiter = String.fromCharCode(4);
+
+function _getPluralFormFunc(plural_form_string) {
+  return Jed.PF.compile(plural_form_string || "nplurals=2; plural=(n != 1);");
+}
+
+// Memoizing two parts here
+// 1st the compiler created from plural_form_string
+// 2nd the compiled fn that text values are called on
+
+var getPluralFormFunc = _.memoize(function (plural_form_string) {
+  var compiler = _getPluralFormFunc(plural_form_string);
+  return _.memoize(compiler);
+});
+
+// Add functions to the Jed prototype.
+// These will be the functions on the object that's returned
+// from creating a `new Jed()`
+// These seem redundant, but they gzip pretty well.
+_.extend(Jed.prototype, {
+
+  textdomain: function textdomain(domain) {
+    if (!domain) {
+      return this._textdomain;
+    }
+    this._textdomain = domain;
+  },
+
+  gettext: function gettext(key) {
+    return this.dcnpgettext.call(this, undefined, undefined, key);
+  },
+
+  dgettext: function dgettext(domain, key) {
+    return this.dcnpgettext.call(this, domain, undefined, key);
+  },
+
+  dcgettext: function dcgettext(domain, key /*, category */) {
+    // Ignores the category anyways
+    return this.dcnpgettext.call(this, domain, undefined, key);
+  },
+
+  ngettext: function ngettext(skey, pkey, val) {
+    return this.dcnpgettext.call(this, undefined, undefined, skey, pkey, val);
+  },
+
+  dngettext: function dngettext(domain, skey, pkey, val) {
+    return this.dcnpgettext.call(this, domain, undefined, skey, pkey, val);
+  },
+
+  dcngettext: function dcngettext(domain, skey, pkey, val /*, category */) {
+    return this.dcnpgettext.call(this, domain, undefined, skey, pkey, val);
+  },
+
+  pgettext: function pgettext(context, key) {
+    return this.dcnpgettext.call(this, undefined, context, key);
+  },
+
+  dpgettext: function dpgettext(domain, context, key) {
+    return this.dcnpgettext.call(this, domain, context, key);
+  },
+
+  dcpgettext: function dcpgettext(domain, context, key /*, category */) {
+    return this.dcnpgettext.call(this, domain, context, key);
+  },
+
+  npgettext: function npgettext(context, skey, pkey, val) {
+    return this.dcnpgettext.call(this, undefined, context, skey, pkey, val);
+  },
+
+  dnpgettext: function dnpgettext(domain, context, skey, pkey, val) {
+    return this.dcnpgettext.call(this, domain, context, skey, pkey, val);
+  },
+
+  // The most fully qualified gettext function. It has every option.
+  // Since it has every option, we can use it from every other method.
+  // This is the bread and butter.
+  // Technically there should be one more argument in this function for 'Category',
+  // but since we never use it, we might as well not waste the bytes to define it.
+  dcnpgettext: function dcnpgettext(domain, context, singular_key, plural_key, val) {
+    // Set some defaults
+
+    plural_key = plural_key || singular_key;
+
+    // Use the global domain default if one
+    // isn't explicitly passed in
+    domain = domain || this._textdomain;
+
+    var fallback;
+
+    // Handle special cases
+
+    // No options found
+    if (!this.options) {
+      // There's likely something wrong, but we'll return the correct key for english
+      // We do this by instantiating a brand new Jed instance with the default set
+      // for everything that could be broken.
+      fallback = new Jed();
+      return fallback.dcnpgettext.call(fallback, undefined, undefined, singular_key, plural_key, val);
+    }
+
+    // No translation data provided
+    if (!this.options.locale_data) {
+      throw new Error('No locale data provided.');
+    }
+
+    if (!this.options.locale_data[domain]) {
+      throw new Error('Domain `' + domain + '` was not found.');
+    }
+
+    if (!this.options.locale_data[domain][""]) {
+      throw new Error('No locale meta information provided.');
+    }
+
+    // Make sure we have a truthy key. Otherwise we might start looking
+    // into the empty string key, which is the options for the locale
+    // data.
+    if (!singular_key) {
+      throw new Error('No translation key found.');
+    }
+
+    var key = context ? context + Jed.context_delimiter + singular_key : singular_key,
+        locale_data = this.options.locale_data,
+        dict = locale_data[domain],
+        defaultConf = (locale_data.messages || this.defaults.locale_data.messages)[""],
+        pluralForms = dict[""].plural_forms || dict[""]["Plural-Forms"] || dict[""]["plural-forms"] || defaultConf.plural_forms || defaultConf["Plural-Forms"] || defaultConf["plural-forms"],
+        val_list,
+        res;
+
+    var val_idx;
+    if (val === undefined) {
+      // No value passed in; assume singular key lookup.
+      val_idx = 0;
+    } else {
+      // Value has been passed in; use plural-forms calculations.
+
+      // Handle invalid numbers, but try casting strings for good measure
+      if (typeof val != 'number') {
+        val = parseInt(val, 10);
+
+        if (isNaN(val)) {
+          throw new Error('The number that was passed in is not a number.');
+        }
+      }
+
+      val_idx = getPluralFormFunc(pluralForms)(val);
+    }
+
+    // Throw an error if a domain isn't found
+    if (!dict) {
+      throw new Error('No domain named `' + domain + '` could be found.');
+    }
+
+    val_list = dict[key];
+
+    // If there is no match, then revert back to
+    // english style singular/plural with the keys passed in.
+    if (!val_list || val_idx > val_list.length) {
+      if (this.options.missing_key_callback) {
+        this.options.missing_key_callback(key, domain);
+      }
+      res = [singular_key, plural_key];
+
+      // collect untranslated strings
+      if (this.options.debug === true) {
+        console.log(res[getPluralFormFunc(pluralForms)(val)]);
+      }
+      return res[getPluralFormFunc()(val)];
+    }
+
+    res = val_list[val_idx];
+
+    // This includes empty strings on purpose
+    if (!res) {
+      res = [singular_key, plural_key];
+      return res[getPluralFormFunc()(val)];
+    }
+    return res;
+  }
+});
+
+// Start the Plural forms section
+// This is a full plural form expression parser. It is used to avoid
+// running 'eval' or 'new Function' directly against the plural
+// forms.
+//
+// This can be important if you get translations done through a 3rd
+// party vendor. I encourage you to use this instead, however, I
+// also will provide a 'precompiler' that you can use at build time
+// to output valid/safe function representations of the plural form
+// expressions. This means you can build this code out for the most
+// part.
+Jed.PF = {};
+
+Jed.PF.parse = function (p) {
+  var plural_str = Jed.PF.extractPluralExpr(p);
+  return Jed.PF.parser.parse.call(Jed.PF.parser, plural_str);
+};
+
+Jed.PF.compile = function (p) {
+  // Handle trues and falses as 0 and 1
+  function imply(val) {
+    return val === true ? 1 : val ? val : 0;
+  }
+
+  var ast = Jed.PF.parse(p);
+  return function (n) {
+    return imply(Jed.PF.interpreter(ast)(n));
+  };
+};
+
+Jed.PF.interpreter = function (ast) {
+  return function (n) {
+    var res;
+    switch (ast.type) {
+      case 'GROUP':
+        return Jed.PF.interpreter(ast.expr)(n);
+      case 'TERNARY':
+        if (Jed.PF.interpreter(ast.expr)(n)) {
+          return Jed.PF.interpreter(ast.truthy)(n);
+        }
+        return Jed.PF.interpreter(ast.falsey)(n);
+      case 'OR':
+        return Jed.PF.interpreter(ast.left)(n) || Jed.PF.interpreter(ast.right)(n);
+      case 'AND':
+        return Jed.PF.interpreter(ast.left)(n) && Jed.PF.interpreter(ast.right)(n);
+      case 'LT':
+        return Jed.PF.interpreter(ast.left)(n) < Jed.PF.interpreter(ast.right)(n);
+      case 'GT':
+        return Jed.PF.interpreter(ast.left)(n) > Jed.PF.interpreter(ast.right)(n);
+      case 'LTE':
+        return Jed.PF.interpreter(ast.left)(n) <= Jed.PF.interpreter(ast.right)(n);
+      case 'GTE':
+        return Jed.PF.interpreter(ast.left)(n) >= Jed.PF.interpreter(ast.right)(n);
+      case 'EQ':
+        return Jed.PF.interpreter(ast.left)(n) == Jed.PF.interpreter(ast.right)(n);
+      case 'NEQ':
+        return Jed.PF.interpreter(ast.left)(n) != Jed.PF.interpreter(ast.right)(n);
+      case 'MOD':
+        return Jed.PF.interpreter(ast.left)(n) % Jed.PF.interpreter(ast.right)(n);
+      case 'VAR':
+        return n;
+      case 'NUM':
+        return ast.val;
+      default:
+        throw new Error("Invalid Token found.");
+    }
+  };
+};
+
+Jed.PF.regexps = {
+  TRIM_BEG: /^\s\s*/,
+  TRIM_END: /\s\s*$/,
+  HAS_SEMICOLON: /;\s*$/,
+  NPLURALS: /nplurals\=(\d+);/,
+  PLURAL: /plural\=(.*);/
+};
+
+Jed.PF.extractPluralExpr = function (p) {
+  // trim first
+  p = p.replace(Jed.PF.regexps.TRIM_BEG, '').replace(Jed.PF.regexps.TRIM_END, '');
+
+  if (!Jed.PF.regexps.HAS_SEMICOLON.test(p)) {
+    p = p.concat(';');
+  }
+
+  var nplurals_matches = p.match(Jed.PF.regexps.NPLURALS),
+      res = {},
+      plural_matches;
+
+  // Find the nplurals number
+  if (nplurals_matches.length > 1) {
+    res.nplurals = nplurals_matches[1];
+  } else {
+    throw new Error('nplurals not found in plural_forms string: ' + p);
+  }
+
+  // remove that data to get to the formula
+  p = p.replace(Jed.PF.regexps.NPLURALS, "");
+  plural_matches = p.match(Jed.PF.regexps.PLURAL);
+
+  if (!(plural_matches && plural_matches.length > 1)) {
+    throw new Error('`plural` expression not found: ' + p);
+  }
+  return plural_matches[1];
+};
+
+/* Jison generated parser */
+Jed.PF.parser = function () {
+
+  var parser = { trace: function trace() {},
+    yy: {},
+    symbols_: { "error": 2, "expressions": 3, "e": 4, "EOF": 5, "?": 6, ":": 7, "||": 8, "&&": 9, "<": 10, "<=": 11, ">": 12, ">=": 13, "!=": 14, "==": 15, "%": 16, "(": 17, ")": 18, "n": 19, "NUMBER": 20, "$accept": 0, "$end": 1 },
+    terminals_: { 2: "error", 5: "EOF", 6: "?", 7: ":", 8: "||", 9: "&&", 10: "<", 11: "<=", 12: ">", 13: ">=", 14: "!=", 15: "==", 16: "%", 17: "(", 18: ")", 19: "n", 20: "NUMBER" },
+    productions_: [0, [3, 2], [4, 5], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 1], [4, 1]],
+    performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$) {
+
+      var $0 = $$.length - 1;
+      switch (yystate) {
+        case 1:
+          return { type: 'GROUP', expr: $$[$0 - 1] };
+          break;
+        case 2:
+          this.$ = { type: 'TERNARY', expr: $$[$0 - 4], truthy: $$[$0 - 2], falsey: $$[$0] };
+          break;
+        case 3:
+          this.$ = { type: "OR", left: $$[$0 - 2], right: $$[$0] };
+          break;
+        case 4:
+          this.$ = { type: "AND", left: $$[$0 - 2], right: $$[$0] };
+          break;
+        case 5:
+          this.$ = { type: 'LT', left: $$[$0 - 2], right: $$[$0] };
+          break;
+        case 6:
+          this.$ = { type: 'LTE', left: $$[$0 - 2], right: $$[$0] };
+          break;
+        case 7:
+          this.$ = { type: 'GT', left: $$[$0 - 2], right: $$[$0] };
+          break;
+        case 8:
+          this.$ = { type: 'GTE', left: $$[$0 - 2], right: $$[$0] };
+          break;
+        case 9:
+          this.$ = { type: 'NEQ', left: $$[$0 - 2], right: $$[$0] };
+          break;
+        case 10:
+          this.$ = { type: 'EQ', left: $$[$0 - 2], right: $$[$0] };
+          break;
+        case 11:
+          this.$ = { type: 'MOD', left: $$[$0 - 2], right: $$[$0] };
+          break;
+        case 12:
+          this.$ = { type: 'GROUP', expr: $$[$0 - 1] };
+          break;
+        case 13:
+          this.$ = { type: 'VAR' };
+          break;
+        case 14:
+          this.$ = { type: 'NUM', val: Number(yytext) };
+          break;
+      }
+    },
+    table: [{ 3: 1, 4: 2, 17: [1, 3], 19: [1, 4], 20: [1, 5] }, { 1: [3] }, { 5: [1, 6], 6: [1, 7], 8: [1, 8], 9: [1, 9], 10: [1, 10], 11: [1, 11], 12: [1, 12], 13: [1, 13], 14: [1, 14], 15: [1, 15], 16: [1, 16] }, { 4: 17, 17: [1, 3], 19: [1, 4], 20: [1, 5] }, { 5: [2, 13], 6: [2, 13], 7: [2, 13], 8: [2, 13], 9: [2, 13], 10: [2, 13], 11: [2, 13], 12: [2, 13], 13: [2, 13], 14: [2, 13], 15: [2, 13], 16: [2, 13], 18: [2, 13] }, { 5: [2, 14], 6: [2, 14], 7: [2, 14], 8: [2, 14], 9: [2, 14], 10: [2, 14], 11: [2, 14], 12: [2, 14], 13: [2, 14], 14: [2, 14], 15: [2, 14], 16: [2, 14], 18: [2, 14] }, { 1: [2, 1] }, { 4: 18, 17: [1, 3], 19: [1, 4], 20: [1, 5] }, { 4: 19, 17: [1, 3], 19: [1, 4], 20: [1, 5] }, { 4: 20, 17: [1, 3], 19: [1, 4], 20: [1, 5] }, { 4: 21, 17: [1, 3], 19: [1, 4], 20: [1, 5] }, { 4: 22, 17: [1, 3], 19: [1, 4], 20: [1, 5] }, { 4: 23, 17: [1, 3], 19: [1, 4], 20: [1, 5] }, { 4: 24, 17: [1, 3], 19: [1, 4], 20: [1, 5] }, { 4: 25, 17: [1, 3], 19: [1, 4], 20: [1, 5] }, { 4: 26, 17: [1, 3], 19: [1, 4], 20: [1, 5] }, { 4: 27, 17: [1, 3], 19: [1, 4], 20: [1, 5] }, { 6: [1, 7], 8: [1, 8], 9: [1, 9], 10: [1, 10], 11: [1, 11], 12: [1, 12], 13: [1, 13], 14: [1, 14], 15: [1, 15], 16: [1, 16], 18: [1, 28] }, { 6: [1, 7], 7: [1, 29], 8: [1, 8], 9: [1, 9], 10: [1, 10], 11: [1, 11], 12: [1, 12], 13: [1, 13], 14: [1, 14], 15: [1, 15], 16: [1, 16] }, { 5: [2, 3], 6: [2, 3], 7: [2, 3], 8: [2, 3], 9: [1, 9], 10: [1, 10], 11: [1, 11], 12: [1, 12], 13: [1, 13], 14: [1, 14], 15: [1, 15], 16: [1, 16], 18: [2, 3] }, { 5: [2, 4], 6: [2, 4], 7: [2, 4], 8: [2, 4], 9: [2, 4], 10: [1, 10], 11: [1, 11], 12: [1, 12], 13: [1, 13], 14: [1, 14], 15: [1, 15], 16: [1, 16], 18: [2, 4] }, { 5: [2, 5], 6: [2, 5], 7: [2, 5], 8: [2, 5], 9: [2, 5], 10: [2, 5], 11: [2, 5], 12: [2, 5], 13: [2, 5], 14: [2, 5], 15: [2, 5], 16: [1, 16], 18: [2, 5] }, { 5: [2, 6], 6: [2, 6], 7: [2, 6], 8: [2, 6], 9: [2, 6], 10: [2, 6], 11: [2, 6], 12: [2, 6], 13: [2, 6], 14: [2, 6], 15: [2, 6], 16: [1, 16], 18: [2, 6] }, { 5: [2, 7], 6: [2, 7], 7: [2, 7], 8: [2, 7], 9: [2, 7], 10: [2, 7], 11: [2, 7], 12: [2, 7], 13: [2, 7], 14: [2, 7], 15: [2, 7], 16: [1, 16], 18: [2, 7] }, { 5: [2, 8], 6: [2, 8], 7: [2, 8], 8: [2, 8], 9: [2, 8], 10: [2, 8], 11: [2, 8], 12: [2, 8], 13: [2, 8], 14: [2, 8], 15: [2, 8], 16: [1, 16], 18: [2, 8] }, { 5: [2, 9], 6: [2, 9], 7: [2, 9], 8: [2, 9], 9: [2, 9], 10: [2, 9], 11: [2, 9], 12: [2, 9], 13: [2, 9], 14: [2, 9], 15: [2, 9], 16: [1, 16], 18: [2, 9] }, { 5: [2, 10], 6: [2, 10], 7: [2, 10], 8: [2, 10], 9: [2, 10], 10: [2, 10], 11: [2, 10], 12: [2, 10], 13: [2, 10], 14: [2, 10], 15: [2, 10], 16: [1, 16], 18: [2, 10] }, { 5: [2, 11], 6: [2, 11], 7: [2, 11], 8: [2, 11], 9: [2, 11], 10: [2, 11], 11: [2, 11], 12: [2, 11], 13: [2, 11], 14: [2, 11], 15: [2, 11], 16: [2, 11], 18: [2, 11] }, { 5: [2, 12], 6: [2, 12], 7: [2, 12], 8: [2, 12], 9: [2, 12], 10: [2, 12], 11: [2, 12], 12: [2, 12], 13: [2, 12], 14: [2, 12], 15: [2, 12], 16: [2, 12], 18: [2, 12] }, { 4: 30, 17: [1, 3], 19: [1, 4], 20: [1, 5] }, { 5: [2, 2], 6: [1, 7], 7: [2, 2], 8: [1, 8], 9: [1, 9], 10: [1, 10], 11: [1, 11], 12: [1, 12], 13: [1, 13], 14: [1, 14], 15: [1, 15], 16: [1, 16], 18: [2, 2] }],
+    defaultActions: { 6: [2, 1] },
+    parseError: function parseError(str, hash) {
+      throw new Error(str);
+    },
+    parse: function parse(input) {
+      var self = this,
+          stack = [0],
+          vstack = [null],
+          // semantic value stack
+      lstack = [],
+          // location stack
+      table = this.table,
+          yytext = '',
+          yylineno = 0,
+          yyleng = 0,
+          recovering = 0,
+          TERROR = 2,
+          EOF = 1;
+
+      //this.reductionCount = this.shiftCount = 0;
+
+      this.lexer.setInput(input);
+      this.lexer.yy = this.yy;
+      this.yy.lexer = this.lexer;
+      if (typeof this.lexer.yylloc == 'undefined') this.lexer.yylloc = {};
+      var yyloc = this.lexer.yylloc;
+      lstack.push(yyloc);
+
+      if (typeof this.yy.parseError === 'function') this.parseError = this.yy.parseError;
+
+      function popStack(n) {
+        stack.length = stack.length - 2 * n;
+        vstack.length = vstack.length - n;
+        lstack.length = lstack.length - n;
+      }
+
+      function lex() {
+        var token;
+        token = self.lexer.lex() || 1; // $end = 1
+        // if token isn't its numeric value, convert
+        if (typeof token !== 'number') {
+          token = self.symbols_[token] || token;
+        }
+        return token;
+      }
+
+      var symbol,
+          preErrorSymbol,
+          state,
+          action,
+          a,
+          r,
+          yyval = {},
+          p,
+          len,
+          newState,
+          expected;
+      while (true) {
+        // retreive state number from top of stack
+        state = stack[stack.length - 1];
+
+        // use default actions if available
+        if (this.defaultActions[state]) {
+          action = this.defaultActions[state];
+        } else {
+          if (symbol == null) symbol = lex();
+          // read action for current state and first input
+          action = table[state] && table[state][symbol];
+        }
+
+        // handle parse error
+        _handle_error: if (typeof action === 'undefined' || !action.length || !action[0]) {
+
+          if (!recovering) {
+            // Report error
+            expected = [];
+            for (p in table[state]) {
+              if (this.terminals_[p] && p > 2) {
+                expected.push("'" + this.terminals_[p] + "'");
+              }
+            }var errStr = '';
+            if (this.lexer.showPosition) {
+              errStr = 'Parse error on line ' + (yylineno + 1) + ":\n" + this.lexer.showPosition() + "\nExpecting " + expected.join(', ') + ", got '" + this.terminals_[symbol] + "'";
+            } else {
+              errStr = 'Parse error on line ' + (yylineno + 1) + ": Unexpected " + (symbol == 1 /*EOF*/ ? "end of input" : "'" + (this.terminals_[symbol] || symbol) + "'");
+            }
+            this.parseError(errStr, { text: this.lexer.match, token: this.terminals_[symbol] || symbol, line: this.lexer.yylineno, loc: yyloc, expected: expected });
+          }
+
+          // just recovered from another error
+          if (recovering == 3) {
+            if (symbol == EOF) {
+              throw new Error(errStr || 'Parsing halted.');
+            }
+
+            // discard current lookahead and grab another
+            yyleng = this.lexer.yyleng;
+            yytext = this.lexer.yytext;
+            yylineno = this.lexer.yylineno;
+            yyloc = this.lexer.yylloc;
+            symbol = lex();
+          }
+
+          // try to recover from error
+          while (1) {
+            // check for error recovery rule in this state
+            if (TERROR.toString() in table[state]) {
+              break;
+            }
+            if (state == 0) {
+              throw new Error(errStr || 'Parsing halted.');
+            }
+            popStack(1);
+            state = stack[stack.length - 1];
+          }
+
+          preErrorSymbol = symbol; // save the lookahead token
+          symbol = TERROR; // insert generic error symbol as new lookahead
+          state = stack[stack.length - 1];
+          action = table[state] && table[state][TERROR];
+          recovering = 3; // allow 3 real symbols to be shifted before reporting a new error
+        }
+
+        // this shouldn't happen, unless resolve defaults are off
+        if (action[0] instanceof Array && action.length > 1) {
+          throw new Error('Parse Error: multiple actions possible at state: ' + state + ', token: ' + symbol);
+        }
+
+        switch (action[0]) {
+
+          case 1:
+            // shift
+            //this.shiftCount++;
+
+            stack.push(symbol);
+            vstack.push(this.lexer.yytext);
+            lstack.push(this.lexer.yylloc);
+            stack.push(action[1]); // push state
+            symbol = null;
+            if (!preErrorSymbol) {
+              // normal execution/no error
+              yyleng = this.lexer.yyleng;
+              yytext = this.lexer.yytext;
+              yylineno = this.lexer.yylineno;
+              yyloc = this.lexer.yylloc;
+              if (recovering > 0) recovering--;
+            } else {
+              // error just occurred, resume old lookahead f/ before error
+              symbol = preErrorSymbol;
+              preErrorSymbol = null;
+            }
+            break;
+
+          case 2:
+            // reduce
+            //this.reductionCount++;
+
+            len = this.productions_[action[1]][1];
+
+            // perform semantic action
+            yyval.$ = vstack[vstack.length - len]; // default to $$ = $1
+            // default location, uses first token for firsts, last for lasts
+            yyval._$ = {
+              first_line: lstack[lstack.length - (len || 1)].first_line,
+              last_line: lstack[lstack.length - 1].last_line,
+              first_column: lstack[lstack.length - (len || 1)].first_column,
+              last_column: lstack[lstack.length - 1].last_column
+            };
+            r = this.performAction.call(yyval, yytext, yyleng, yylineno, this.yy, action[1], vstack, lstack);
+
+            if (typeof r !== 'undefined') {
+              return r;
+            }
+
+            // pop off stack
+            if (len) {
+              stack = stack.slice(0, -1 * len * 2);
+              vstack = vstack.slice(0, -1 * len);
+              lstack = lstack.slice(0, -1 * len);
+            }
+
+            stack.push(this.productions_[action[1]][0]); // push nonterminal (reduce)
+            vstack.push(yyval.$);
+            lstack.push(yyval._$);
+            // goto new state = table[STATE][NONTERMINAL]
+            newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
+            stack.push(newState);
+            break;
+
+          case 3:
+            // accept
+            return true;
+        }
+      }
+
+      return true;
+    } }; /* Jison generated lexer */
+  var lexer = function () {
+
+    var lexer = { EOF: 1,
+      parseError: function parseError(str, hash) {
+        if (this.yy.parseError) {
+          this.yy.parseError(str, hash);
+        } else {
+          throw new Error(str);
+        }
+      },
+      setInput: function setInput(input) {
+        this._input = input;
+        this._more = this._less = this.done = false;
+        this.yylineno = this.yyleng = 0;
+        this.yytext = this.matched = this.match = '';
+        this.conditionStack = ['INITIAL'];
+        this.yylloc = { first_line: 1, first_column: 0, last_line: 1, last_column: 0 };
+        return this;
+      },
+      input: function input() {
+        var ch = this._input[0];
+        this.yytext += ch;
+        this.yyleng++;
+        this.match += ch;
+        this.matched += ch;
+        var lines = ch.match(/\n/);
+        if (lines) this.yylineno++;
+        this._input = this._input.slice(1);
+        return ch;
+      },
+      unput: function unput(ch) {
+        this._input = ch + this._input;
+        return this;
+      },
+      more: function more() {
+        this._more = true;
+        return this;
+      },
+      pastInput: function pastInput() {
+        var past = this.matched.substr(0, this.matched.length - this.match.length);
+        return (past.length > 20 ? '...' : '') + past.substr(-20).replace(/\n/g, "");
+      },
+      upcomingInput: function upcomingInput() {
+        var next = this.match;
+        if (next.length < 20) {
+          next += this._input.substr(0, 20 - next.length);
+        }
+        return (next.substr(0, 20) + (next.length > 20 ? '...' : '')).replace(/\n/g, "");
+      },
+      showPosition: function showPosition() {
+        var pre = this.pastInput();
+        var c = new Array(pre.length + 1).join("-");
+        return pre + this.upcomingInput() + "\n" + c + "^";
+      },
+      next: function next() {
+        if (this.done) {
+          return this.EOF;
+        }
+        if (!this._input) this.done = true;
+
+        var token, match, col, lines;
+        if (!this._more) {
+          this.yytext = '';
+          this.match = '';
+        }
+        var rules = this._currentRules();
+        for (var i = 0; i < rules.length; i++) {
+          match = this._input.match(this.rules[rules[i]]);
+          if (match) {
+            lines = match[0].match(/\n.*/g);
+            if (lines) this.yylineno += lines.length;
+            this.yylloc = { first_line: this.yylloc.last_line,
+              last_line: this.yylineno + 1,
+              first_column: this.yylloc.last_column,
+              last_column: lines ? lines[lines.length - 1].length - 1 : this.yylloc.last_column + match[0].length };
+            this.yytext += match[0];
+            this.match += match[0];
+            this.matches = match;
+            this.yyleng = this.yytext.length;
+            this._more = false;
+            this._input = this._input.slice(match[0].length);
+            this.matched += match[0];
+            token = this.performAction.call(this, this.yy, this, rules[i], this.conditionStack[this.conditionStack.length - 1]);
+            if (token) return token;else return;
+          }
+        }
+        if (this._input === "") {
+          return this.EOF;
+        } else {
+          this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. Unrecognized text.\n' + this.showPosition(), { text: "", token: null, line: this.yylineno });
+        }
+      },
+      lex: function lex() {
+        var r = this.next();
+        if (typeof r !== 'undefined') {
+          return r;
+        } else {
+          return this.lex();
+        }
+      },
+      begin: function begin(condition) {
+        this.conditionStack.push(condition);
+      },
+      popState: function popState() {
+        return this.conditionStack.pop();
+      },
+      _currentRules: function _currentRules() {
+        return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;
+      },
+      topState: function topState() {
+        return this.conditionStack[this.conditionStack.length - 2];
+      },
+      pushState: function begin(condition) {
+        this.begin(condition);
+      } };
+    lexer.performAction = function anonymous(yy, yy_, $avoiding_name_collisions, YY_START) {
+
+      var YYSTATE = YY_START;
+      switch ($avoiding_name_collisions) {
+        case 0:
+          /* skip whitespace */
+          break;
+        case 1:
+          return 20;
+          break;
+        case 2:
+          return 19;
+          break;
+        case 3:
+          return 8;
+          break;
+        case 4:
+          return 9;
+          break;
+        case 5:
+          return 6;
+          break;
+        case 6:
+          return 7;
+          break;
+        case 7:
+          return 11;
+          break;
+        case 8:
+          return 13;
+          break;
+        case 9:
+          return 10;
+          break;
+        case 10:
+          return 12;
+          break;
+        case 11:
+          return 14;
+          break;
+        case 12:
+          return 15;
+          break;
+        case 13:
+          return 16;
+          break;
+        case 14:
+          return 17;
+          break;
+        case 15:
+          return 18;
+          break;
+        case 16:
+          return 5;
+          break;
+        case 17:
+          return 'INVALID';
+          break;
+      }
+    };
+    lexer.rules = [/^\s+/, /^[0-9]+(\.[0-9]+)?\b/, /^n\b/, /^\|\|/, /^&&/, /^\?/, /^:/, /^<=/, /^>=/, /^</, /^>/, /^!=/, /^==/, /^%/, /^\(/, /^\)/, /^$/, /^./];
+    lexer.conditions = { "INITIAL": { "rules": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17], "inclusive": true } };return lexer;
+  }();
+  parser.lexer = lexer;
+  return parser;
+}();
+// End parser
+
+exports.default = Jed;

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "ot-jed",
+  "version": "0.0.11",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "",
+  "license": "MIT",
+  "author": "hopntbl-jed",
+  "main": "lib/jed.js",
+  "repository": {
+    "type": "git",
+    "url": "https://SlexAxton@github.com/SlexAxton/Jed.git"
+  },
+  "scripts": {
+    "build": "npm run mkdir && node build.js",
+    "mkdir": "node build.js",
+    "prepublishOnly": "npm run build",
+    "test": "make test"
+  },
+  "dependencies" : {},
+  "devDependencies" : {
+    "mocha" : "*",
+    "expect.js" : "*",
+    "serve": "*"
+  }
+}