text: this["wp"] = this["wp"] || {}; this["wp"]["i18n"] =
  /******/ (function(modules) { // webpackBootstrap
  /******/ 	// The module cache
  /******/ 	var installedModules = {};
  /******/
  /******/ 	// The require function
  /******/ 	function __webpack_require__(moduleId) {
  /******/
  /******/ 		// Check if module is in cache
  /******/ 		if(installedModules[moduleId]) {
  /******/ 			return installedModules[moduleId].exports;
  /******/ 		}
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = installedModules[moduleId] = {
  /******/ 			i: moduleId,
  /******/ 			l: false,
  /******/ 			exports: {}
  /******/ 		};
  /******/
  /******/ 		// Execute the module function
  /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  /******/
  /******/ 		// Flag the module as loaded
  /******/ 		module.l = true;
  /******/
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  /******/
  /******/
  /******/ 	// expose the modules object (__webpack_modules__)
  /******/ 	__webpack_require__.m = modules;
  /******/
  /******/ 	// expose the module cache
  /******/ 	__webpack_require__.c = installedModules;
  /******/
  /******/ 	// define getter function for harmony exports
  /******/ 	__webpack_require__.d = function(exports, name, getter) {
  /******/ 		if(!__webpack_require__.o(exports, name)) {
  /******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
  /******/ 		}
  /******/ 	};
  /******/
  /******/ 	// define __esModule on exports
  /******/ 	__webpack_require__.r = function(exports) {
  /******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
  /******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
  /******/ 		}
  /******/ 		Object.defineProperty(exports, '__esModule', { value: true });
  /******/ 	};
  /******/
  /******/ 	// create a fake namespace object
  /******/ 	// mode & 1: value is a module id, require it
  /******/ 	// mode & 2: merge all properties of value into the ns
  /******/ 	// mode & 4: return value when already ns object
  /******/ 	// mode & 8|1: behave like require
  /******/ 	__webpack_require__.t = function(value, mode) {
  /******/ 		if(mode & 1) value = __webpack_require__(value);
  /******/ 		if(mode & 8) return value;
  /******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
  /******/ 		var ns = Object.create(null);
  /******/ 		__webpack_require__.r(ns);
  /******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
  /******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
  /******/ 		return ns;
  /******/ 	};
  /******/
  /******/ 	// getDefaultExport function for compatibility with non-harmony modules
  /******/ 	__webpack_require__.n = function(module) {
  /******/ 		var getter = module && module.__esModule ?
  /******/ 			function getDefault() { return module['default']; } :
  /******/ 			function getModuleExports() { return module; };
  /******/ 		__webpack_require__.d(getter, 'a', getter);
  /******/ 		return getter;
  /******/ 	};
  /******/
  /******/ 	// Object.prototype.hasOwnProperty.call
  /******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
  /******/
  /******/ 	// __webpack_public_path__
  /******/ 	__webpack_require__.p = "";
  /******/
  /******/
  /******/ 	// Load entry module and return exports
  /******/ 	return __webpack_require__(__webpack_require__.s = "./node_modules/@wordpress/i18n/build-module/index.js");
  /******/ })
  /************************************************************************/
  /******/ ({
  
  /***/ "./node_modules/@wordpress/i18n/build-module/index.js":
  /*!************************************************************!*\
    !*** ./node_modules/@wordpress/i18n/build-module/index.js ***!
    \************************************************************/
  /*! exports provided: setLocaleData, __, _x, _n, _nx, sprintf */
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  __webpack_require__.r(__webpack_exports__);
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "setLocaleData", function() { return setLocaleData; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__", function() { return __; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "_x", function() { return _x; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "_n", function() { return _n; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "_nx", function() { return _nx; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sprintf", function() { return sprintf; });
  /* harmony import */ var jed__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! jed */ "./node_modules/jed/jed.js");
  /* harmony import */ var jed__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(jed__WEBPACK_IMPORTED_MODULE_0__);
  /* harmony import */ var memize__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! memize */ "./node_modules/memize/index.js");
  /* harmony import */ var memize__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(memize__WEBPACK_IMPORTED_MODULE_1__);
  /**
   * External dependencies
   */
  
  
  var i18n;
  /**
   * Log to console, once per message; or more precisely, per referentially equal
   * argument set. Because Jed throws errors, we log these to the console instead
   * to avoid crashing the application.
   *
   * @param {...*} args Arguments to pass to `console.error`
   */
  
  var logErrorOnce = memize__WEBPACK_IMPORTED_MODULE_1___default()(console.error); // eslint-disable-line no-console
  
  /**
   * Merges locale data into the Jed instance by domain. Creates a new Jed
   * instance if one has not yet been assigned.
   *
   * @see http://messageformat.github.io/Jed/
   *
   * @param {?Object} localeData Locale data configuration.
   * @param {?string} domain     Domain for which configuration applies.
   */
  
  function setLocaleData() {
    var localeData = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
      '': {}
    };
    var domain = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'default';
  
    if (!i18n) {
      i18n = new jed__WEBPACK_IMPORTED_MODULE_0___default.a({
        domain: 'default',
        locale_data: {
          default: {
            '': {}
          }
        }
      });
    }
  
    i18n.options.locale_data[domain] = Object.assign({}, i18n.options.locale_data[domain], localeData);
  }
  /**
   * Returns the current Jed instance, initializing with a default configuration
   * if not already assigned.
   *
   * @return {Jed} Jed instance.
   */
  
  function getI18n() {
    if (!i18n) {
      setLocaleData();
    }
  
    return i18n;
  }
  /**
   * Wrapper for Jed's `dcnpgettext`, its most qualified function. Absorbs errors
   * which are thrown as the result of invalid translation.
   *
   * @param {?string} domain  Domain to retrieve the translated text.
   * @param {?string} context Context information for the translators.
   * @param {string}  single  Text to translate if non-plural. Used as fallback
   *                          return value on a caught error.
   * @param {?string} plural  The text to be used if the number is plural.
   * @param {?number} number  The number to compare against to use either the
   *                          singular or plural form.
   *
   * @return {string} The translated string.
   */
  
  
  var dcnpgettext = memize__WEBPACK_IMPORTED_MODULE_1___default()(function () {
    var domain = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'default';
    var context = arguments.length > 1 ? arguments[1] : undefined;
    var single = arguments.length > 2 ? arguments[2] : undefined;
    var plural = arguments.length > 3 ? arguments[3] : undefined;
    var number = arguments.length > 4 ? arguments[4] : undefined;
  
    try {
      return getI18n().dcnpgettext(domain, context, single, plural, number);
    } catch (error) {
      logErrorOnce('Jed localization error: \n\n' + error.toString());
      return single;
    }
  });
  /**
   * Retrieve the translation of text.
   *
   * @see https://developer.wordpress.org/reference/functions/__/
   *
   * @param {string}  text   Text to translate.
   * @param {?string} domain Domain to retrieve the translated text.
   *
   * @return {string} Translated text.
   */
  
  function __(text, domain) {
    return dcnpgettext(domain, undefined, text);
  }
  /**
   * Retrieve translated string with gettext context.
   *
   * @see https://developer.wordpress.org/reference/functions/_x/
   *
   * @param {string}  text    Text to translate.
   * @param {string}  context Context information for the translators.
   * @param {?string} domain  Domain to retrieve the translated text.
   *
   * @return {string} Translated context string without pipe.
   */
  
  function _x(text, context, domain) {
    return dcnpgettext(domain, context, text);
  }
  /**
   * Translates and retrieves the singular or plural form based on the supplied
   * number.
   *
   * @see https://developer.wordpress.org/reference/functions/_n/
   *
   * @param {string}  single The text to be used if the number is singular.
   * @param {string}  plural The text to be used if the number is plural.
   * @param {number}  number The number to compare against to use either the
   *                         singular or plural form.
   * @param {?string} domain Domain to retrieve the translated text.
   *
   * @return {string} The translated singular or plural form.
   */
  
  function _n(single, plural, number, domain) {
    return dcnpgettext(domain, undefined, single, plural, number);
  }
  /**
   * Translates and retrieves the singular or plural form based on the supplied
   * number, with gettext context.
   *
   * @see https://developer.wordpress.org/reference/functions/_nx/
   *
   * @param {string}  single  The text to be used if the number is singular.
   * @param {string}  plural  The text to be used if the number is plural.
   * @param {number}  number  The number to compare against to use either the
   *                          singular or plural form.
   * @param {string}  context Context information for the translators.
   * @param {?string} domain  Domain to retrieve the translated text.
   *
   * @return {string} The translated singular or plural form.
   */
  
  function _nx(single, plural, number, context, domain) {
    return dcnpgettext(domain, context, single, plural, number);
  }
  /**
   * Returns a formatted string. If an error occurs in applying the format, the
   * original format string is returned.
   *
   * @param {string}   format  The format of the string to generate.
   * @param {string[]} ...args Arguments to apply to the format.
   *
   * @see http://www.diveintojavascript.com/projects/javascript-sprintf
   *
   * @return {string} The formatted string.
   */
  
  function sprintf(format) {
    try {
      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
        args[_key - 1] = arguments[_key];
      }
  
      return jed__WEBPACK_IMPORTED_MODULE_0___default.a.sprintf.apply(jed__WEBPACK_IMPORTED_MODULE_0___default.a, [format].concat(args));
    } catch (error) {
      logErrorOnce('Jed sprintf error: \n\n' + error.toString());
      return format;
    }
  }
  
  
  /***/ }),
  
  /***/ "./node_modules/jed/jed.js":
  /*!*********************************!*\
    !*** ./node_modules/jed/jed.js ***!
    \*********************************/
  /*! no static exports found */
  /***/ (function(module, exports, __webpack_require__) {
  
  /**
   * @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
  */
  (function (root, undef) {
  
    // 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( 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( obj ) {
        this.forEach( slice.call( arguments, 1 ), function ( source ) {
          for ( var prop in source ) {
            obj[prop] = source[prop];
          }
        });
        return obj;
      }
    };
    // END Miniature underscore impl
  
    // Jed is a constructor function
    var Jed = function ( 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);");
    }
  
    function Chain( key, i18n ){
      this._key = key;
      this._i18n = i18n;
    }
  
    // Create a chainable api for adding args prettily
    _.extend( Chain.prototype, {
      onDomain : function ( domain ) {
        this._domain = domain;
        return this;
      },
      withContext : function ( context ) {
        this._context = context;
        return this;
      },
      ifPlural : function ( num, pkey ) {
        this._val = num;
        this._pkey = pkey;
        return this;
      },
      fetch : function ( sArr ) {
        if ( {}.toString.call( sArr ) != '[object Array]' ) {
          sArr = [].slice.call(arguments, 0);
        }
        return ( sArr && sArr.length ? Jed.sprintf : function(x){ return x; } )(
          this._i18n.dcnpgettext(this._domain, this._context, this._key, this._pkey, this._val),
          sArr
        );
      }
    });
  
    // 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, {
      // The sexier api start point
      translate : function ( key ) {
        return new Chain( key, this );
      },
  
      textdomain : function ( domain ) {
        if ( ! domain ) {
          return this._textdomain;
        }
        this._textdomain = domain;
      },
  
      gettext : function ( key ) {
        return this.dcnpgettext.call( this, undef, undef, key );
      },
  
      dgettext : function ( domain, key ) {
       return this.dcnpgettext.call( this, domain, undef, key );
      },
  
      dcgettext : function ( domain , key /*, category */ ) {
        // Ignores the category anyways
        return this.dcnpgettext.call( this, domain, undef, key );
      },
  
      ngettext : function ( skey, pkey, val ) {
        return this.dcnpgettext.call( this, undef, undef, skey, pkey, val );
      },
  
      dngettext : function ( domain, skey, pkey, val ) {
        return this.dcnpgettext.call( this, domain, undef, skey, pkey, val );
      },
  
      dcngettext : function ( domain, skey, pkey, val/*, category */) {
        return this.dcnpgettext.call( this, domain, undef, skey, pkey, val );
      },
  
      pgettext : function ( context, key ) {
        return this.dcnpgettext.call( this, undef, context, key );
      },
  
      dpgettext : function ( domain, context, key ) {
        return this.dcnpgettext.call( this, domain, context, key );
      },
  
      dcpgettext : function ( domain, context, key/*, category */) {
        return this.dcnpgettext.call( this, domain, context, key );
      },
  
      npgettext : function ( context, skey, pkey, val ) {
        return this.dcnpgettext.call( this, undef, context, skey, pkey, val );
      },
  
      dnpgettext : function ( 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 ( 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;
      }
    });
  
  
    // We add in sprintf capabilities for post translation value interolation
    // This is not internally used, so you can remove it if you have this
    // available somewhere else, or want to use a different system.
  
    // We _slightly_ modify the normal sprintf behavior to more gracefully handle
    // undefined values.
  
    /**
     sprintf() for JavaScript 0.7-beta1
     http://www.diveintojavascript.com/projects/javascript-sprintf
  
     Copyright (c) Alexandru Marasteanu <alexaholic [at) gmail (dot] com>
     All rights reserved.
  
     Redistribution and use in source and binary forms, with or without
     modification, are permitted provided that the following conditions are met:
         * Redistributions of source code must retain the above copyright
           notice, this list of conditions and the following disclaimer.
         * Redistributions in binary form must reproduce the above copyright
           notice, this list of conditions and the following disclaimer in the
           documentation and/or other materials provided with the distribution.
         * Neither the name of sprintf() for JavaScript nor the
           names of its contributors may be used to endorse or promote products
           derived from this software without specific prior written permission.
  
     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
     ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
     DISCLAIMED. IN NO EVENT SHALL Alexandru Marasteanu BE LIABLE FOR ANY
     DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
     (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
     ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
     SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    */
    var sprintf = (function() {
      function get_type(variable) {
        return Object.prototype.toString.call(variable).slice(8, -1).toLowerCase();
      }
      function str_repeat(input, multiplier) {
        for (var output = []; multiplier > 0; output[--multiplier] = input) {/* do nothing */}
        return output.join('');
      }
  
      var str_format = function() {
        if (!str_format.cache.hasOwnProperty(arguments[0])) {
          str_format.cache[arguments[0]] = str_format.parse(arguments[0]);
        }
        return str_format.format.call(null, str_format.cache[arguments[0]], arguments);
      };
  
      str_format.format = function(parse_tree, argv) {
        var cursor = 1, tree_length = parse_tree.length, node_type = '', arg, output = [], i, k, match, pad, pad_character, pad_length;
        for (i = 0; i < tree_length; i++) {
          node_type = get_type(parse_tree[i]);
          if (node_type === 'string') {
            output.push(parse_tree[i]);
          }
          else if (node_type === 'array') {
            match = parse_tree[i]; // convenience purposes only
            if (match[2]) { // keyword argument
              arg = argv[cursor];
              for (k = 0; k < match[2].length; k++) {
                if (!arg.hasOwnProperty(match[2][k])) {
                  throw(sprintf('[sprintf] property "%s" does not exist', match[2][k]));
                }
                arg = arg[match[2][k]];
              }
            }
            else if (match[1]) { // positional argument (explicit)
              arg = argv[match[1]];
            }
            else { // positional argument (implicit)
              arg = argv[cursor++];
            }
  
            if (/[^s]/.test(match[8]) && (get_type(arg) != 'number')) {
              throw(sprintf('[sprintf] expecting number but found %s', get_type(arg)));
            }
  
            // Jed EDIT
            if ( typeof arg == 'undefined' || arg === null ) {
              arg = '';
            }
            // Jed EDIT
  
            switch (match[8]) {
              case 'b': arg = arg.toString(2); break;
              case 'c': arg = String.fromCharCode(arg); break;
              case 'd': arg = parseInt(arg, 10); break;
              case 'e': arg = match[7] ? arg.toExponential(match[7]) : arg.toExponential(); break;
              case 'f': arg = match[7] ? parseFloat(arg).toFixed(match[7]) : parseFloat(arg); break;
              case 'o': arg = arg.toString(8); break;
              case 's': arg = ((arg = String(arg)) && match[7] ? arg.substring(0, match[7]) : arg); break;
              case 'u': arg = Math.abs(arg); break;
              case 'x': arg = arg.toString(16); break;
              case 'X': arg = arg.toString(16).toUpperCase(); break;
            }
            arg = (/[def]/.test(match[8]) && match[3] && arg >= 0 ? '+'+ arg : arg);
            pad_character = match[4] ? match[4] == '0' ? '0' : match[4].charAt(1) : ' ';
            pad_length = match[6] - String(arg).length;
            pad = match[6] ? str_repeat(pad_character, pad_length) : '';
            output.push(match[5] ? arg + pad : pad + arg);
          }
        }
        return output.join('');
      };
  
      str_format.cache = {};
  
      str_format.parse = function(fmt) {
        var _fmt = fmt, match = [], parse_tree = [], arg_names = 0;
        while (_fmt) {
          if ((match = /^[^\x25]+/.exec(_fmt)) !== null) {
            parse_tree.push(match[0]);
          }
          else if ((match = /^\x25{2}/.exec(_fmt)) !== null) {
            parse_tree.push('%');
          }
          else if ((match = /^\x25(?:([1-9]\d*)\$|\(([^\)]+)\))?(\+)?(0|'[^$])?(-)?(\d+)?(?:\.(\d+))?([b-fosuxX])/.exec(_fmt)) !== null) {
            if (match[2]) {
              arg_names |= 1;
              var field_list = [], replacement_field = match[2], field_match = [];
              if ((field_match = /^([a-z_][a-z_\d]*)/i.exec(replacement_field)) !== null) {
                field_list.push(field_match[1]);
                while ((replacement_field = replacement_field.substring(field_match[0].length)) !== '') {
                  if ((field_match = /^\.([a-z_][a-z_\d]*)/i.exec(replacement_field)) !== null) {
                    field_list.push(field_match[1]);
                  }
                  else if ((field_match = /^\[(\d+)\]/.exec(replacement_field)) !== null) {
                    field_list.push(field_match[1]);
                  }
                  else {
                    throw('[sprintf] huh?');
                  }
                }
              }
              else {
                throw('[sprintf] huh?');
              }
              match[2] = field_list;
            }
            else {
              arg_names |= 2;
            }
            if (arg_names === 3) {
              throw('[sprintf] mixing positional and named placeholders is not (yet) supported');
            }
            parse_tree.push(match);
          }
          else {
            throw('[sprintf] huh?');
          }
          _fmt = _fmt.substring(match[0].length);
        }
        return parse_tree;
      };
  
      return str_format;
    })();
  
    var vsprintf = function(fmt, argv) {
      argv.unshift(fmt);
      return sprintf.apply(null, argv);
    };
  
    Jed.parse_plural = function ( plural_forms, n ) {
      plural_forms = plural_forms.replace(/n/g, n);
      return Jed.parse_expression(plural_forms);
    };
  
    Jed.sprintf = function ( fmt, args ) {
      if ( {}.toString.call( args ) == '[object Array]' ) {
        return vsprintf( fmt, [].slice.call(args) );
      }
      return sprintf.apply(this, [].slice.call(arguments) );
    };
  
    Jed.prototype.sprintf = function () {
      return Jed.sprintf.apply(this, arguments);
    };
    // END sprintf Implementation
  
    // 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.extractPluralExpr = function ( p ) {
      // trim first
      p = p.replace(/^\s\s*/, '').replace(/\s\s*$/, '');
  
      if (! /;\s*$/.test(p)) {
        p = p.concat(';');
      }
  
      var nplurals_re = /nplurals\=(\d+);/,
          plural_re = /plural\=(.*);/,
          nplurals_matches = p.match( nplurals_re ),
          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( nplurals_re, "" );
      plural_matches = p.match( plural_re );
  
      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 (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 () {
          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 (ch) {
          this._input = ch + this._input;
          return this;
      },
  more:function () {
          this._more = true;
          return this;
      },
  pastInput:function () {
          var past = this.matched.substr(0, this.matched.length - this.match.length);
          return (past.length > 20 ? '...':'') + past.substr(-20).replace(/\n/g, "");
      },
  upcomingInput:function () {
          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 () {
          var pre = this.pastInput();
          var c = new Array(pre.length + 1).join("-");
          return pre + this.upcomingInput() + "\n" + c+"^";
      },
  next:function () {
          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 () {
          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
  
    // Handle node, amd, and global systems
    if (true) {
      if ( true && module.exports) {
        exports = module.exports = Jed;
      }
      exports.Jed = Jed;
    }
    else {}
  
  })(this);
  
  
  /***/ }),
  
  /***/ "./node_modules/memize/index.js":
  /*!**************************************!*\
    !*** ./node_modules/memize/index.js ***!
    \**************************************/
  /*! no static exports found */
  /***/ (function(module, exports, __webpack_require__) {
  
  module.exports = function memize( fn, options ) {
  	var size = 0,
  		maxSize, head, tail;
  
  	if ( options && options.maxSize ) {
  		maxSize = options.maxSize;
  	}
  
  	function memoized( /* ...args */ ) {
  		var node = head,
  			len = arguments.length,
  			args, i;
  
  		searchCache: while ( node ) {
  			// Perform a shallow equality test to confirm that whether the node
  			// under test is a candidate for the arguments passed. Two arrays
  			// are shallowly equal if their length matches and each entry is
  			// strictly equal between the two sets. Avoid abstracting to a
  			// function which could incur an arguments leaking deoptimization.
  
  			// Check whether node arguments match arguments length
  			if ( node.args.length !== arguments.length ) {
  				node = node.next;
  				continue;
  			}
  
  			// Check whether node arguments match arguments values
  			for ( i = 0; i < len; i++ ) {
  				if ( node.args[ i ] !== arguments[ i ] ) {
  					node = node.next;
  					continue searchCache;
  				}
  			}
  
  			// At this point we can assume we've found a match
  
  			// Surface matched node to head if not already
  			if ( node !== head ) {
  				// As tail, shift to previous. Must only shift if not also
  				// head, since if both head and tail, there is no previous.
  				if ( node === tail ) {
  					tail = node.prev;
  				}
  
  				// Adjust siblings to point to each other. If node was tail,
  				// this also handles new tail's empty `next` assignment.
  				node.prev.next = node.next;
  				if ( node.next ) {
  					node.next.prev = node.prev;
  				}
  
  				node.next = head;
  				node.prev = null;
  				head.prev = node;
  				head = node;
  			}
  
  			// Return immediately
  			return node.val;
  		}
  
  		// No cached value found. Continue to insertion phase:
  
  		// Create a copy of arguments (avoid leaking deoptimization)
  		args = new Array( len );
  		for ( i = 0; i < len; i++ ) {
  			args[ i ] = arguments[ i ];
  		}
  
  		node = {
  			args: args,
  
  			// Generate the result from original function
  			val: fn.apply( null, args )
  		};
  
  		// Don't need to check whether node is already head, since it would
  		// have been returned above already if it was
  
  		// Shift existing head down list
  		if ( head ) {
  			head.prev = node;
  			node.next = head;
  		} else {
  			// If no head, follows that there's no tail (at initial or reset)
  			tail = node;
  		}
  
  		// Trim tail if we're reached max size and are pending cache insertion
  		if ( size === maxSize ) {
  			tail = tail.prev;
  			tail.next = null;
  		} else {
  			size++;
  		}
  
  		head = node;
  
  		return node.val;
  	}
  
  	memoized.clear = function() {
  		head = null;
  		tail = null;
  		size = 0;
  	};
  
  	if ( false ) {}
  
  	return memoized;
  };
  
  
  /***/ })
  
  /******/ });
  //# sourceMappingURL=i18n.js.map