(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = _default;

var _i18n = require("@wordpress/i18n");

/* eslint no-undef: 0 */
// Temporary turned off no undefined variable for localStorage
var $ = jQuery;
var wcCountries = JSON.parse(wc_country_select_params.countries);

function _default() {
  var parent = $('#sellkit-checkout-multistep-inner-wrap');
  var sidebar = $('.sellkit-checkout-right-column');
  var first = $('.sellkit-multistep-checkout-first');
  var second = $('.sellkit-multistep-checkout-second');
  var third = $('.sellkit-multistep-checkout-third');
  var breadcrumb = $('.sellkit-checkout-widget-breadcrumb-desktop, .sellkit-checkout-widget-breadcrumb-mobile');
  $('.go-to-shipping').on('click', function () {
    // Checks if required fields are filled.
    var requiredFieldsError = checkRequiredFields();

    if (true === requiredFieldsError) {
      return;
    }

    secondStepHeader();
    var secondTrigger = true;
    first.hide();

    if ($('.sellkit-one-page-shipping-methods').length > 0) {
      second.show();
    } else {
      third.show();
      secondTrigger = false;
    }

    if ($(window).width() > 600 && secondTrigger) {
      sidebar.css('background-color', '#effdf5');
    } //Fix Header & wrapper height.


    parent.css('height', 'auto');
    second.css('height', 'auto');
    second.css('min-height', $('.sellkit-checkout-left-column').height());
    $('.multistep-headers').css('height', 'auto'); // Manage Breadcrumb.

    breadcrumb.find('.information').removeClass('current').addClass('blue-line');
    breadcrumb.find('.shipping').addClass('current').removeClass('inactive');
  });
  $('.go-to-first').on('click', function () {
    first.show();
    third.hide();
    second.hide();
    parent.css('height', 'auto');
    first.css('height', 'auto');
    sidebar.css('background-color', '#ffffff'); // Manage Breadcrumb.

    breadcrumb.find('.information').removeClass('blue-line').addClass('current');
    breadcrumb.find('.shipping, .payment').removeClass('current').removeClass('blue-line').addClass('inactive');
  });
  $('.go-to-payment').on('click', function () {
    // Checks if required fields are filled.
    var requiredFieldsError = checkRequiredFields();

    if (true === requiredFieldsError) {
      return;
    }

    secondStepHeader();
    second.hide();
    first.hide();
    third.show();
    $('.sellkit-one-page-checkout-payment-heading').css('margin-top', '0px');
    sidebar.css('background-color', '#ffffff'); //Fix Header & wrapper height.

    parent.css('height', 'auto');
    third.css('height', 'auto');
    $('.multistep-headers').css('height', 'auto'); // Manage Breadcrumb.

    breadcrumb.find('.shipping').addClass('blue-line').removeClass('current');
    breadcrumb.find('.payment').addClass('current').removeClass('inactive');
  });
  $('.go-to-second , .go-to-second-header').on('click', function () {
    // Checks if required fields are filled.
    var requiredFieldsError = checkRequiredFields();

    if (true === requiredFieldsError) {
      return;
    }

    var secondTrigger = true;

    if ($('.sellkit-one-page-shipping-methods').length > 0) {
      second.show();
      first.hide();
    } else {
      second.hide();
      first.show();
      secondTrigger = false;
    }

    third.hide();
    parent.css('height', 'auto');
    second.css('height', 'auto');
    second.css('height', $('.sellkit-checkout-left-column').height());
    $('.multistep-headers').css('height', 'auto');

    if ($(window).width() > 600 && secondTrigger) {
      sidebar.css('background-color', '#effdf5');
    } // Manage Breadcrumb.


    breadcrumb.find('.shipping').addClass('current').removeClass('blue-line');
    breadcrumb.find('.payment').removeClass('current').addClass('inactive');
  }); //Inject login wrapper & functionality.

  emailProcess();
  LoginProcess(); // Billing method toggle.

  manageBillingMethod(); // Mobile summary.

  mobileSummary(); // Breadcrumb click management.

  breadcrumbLinks(); // Fix shipping & billing fields space issue.

  fixFieldSpaceIssue(); // Fields focus.

  organizeFieldsonLoad();
  fieldFocus();
  jQuery(document).ajaxComplete(function () {
    // Run after ajax
    sellkitCheckoutUpdateCartItem();
    applyCoupon();
    couponToggle();
  }); //Run when page loads.

  sellkitCheckoutUpdateCartItem(); // Apply coupon.

  applyCoupon(); // Coupon toggle.

  couponToggle(); // Postal code autocomplete.

  sellkitPostalCodeAutocomplete(); // Klarma checkout integration.

  sellkitKlarmaIntegration(); // Fix state change issue on load.

  fixStateIssueOnLoad(); // Shipping & billing country & state update on change

  fixClientCountryOnReload(); // Configure bundled products.

  sellkitCheckoutConfigureBundleProducts(); // Order bump.

  sellkitCheckoutOrderBump();
}

var emailProcess = function emailProcess() {
  var emailField = $('#billing_email');
  var searchIcon = $('.jupiter-checkout-widget-email-search');
  var errorText = $('.sellkit-checkout-widget-email-error');
  var emptyError = $('.sellkit-checkout-widget-email-empty');
  var passwordWrap = $('.sellkit-checkout-widget-password-field');
  var passwordField = passwordWrap.find('#register_pass');
  var usernameWrap = $('.sellkit-checkout-widget-username-field');
  var usernameField = usernameWrap.find('input');
  var loginBtn = $('.login-wrapper');
  var createBox = $('.create-desc');
  var createCheck = $('#createaccount');
  emailField.on('keyup', function () {
    var _this = this;

    setTimeout(function () {
      var emailAddress = $(_this).val();

      if (_.isEmpty(emailAddress)) {
        emptyError.show().css('display', 'inline-block');
        errorText.hide();
        createBox.css('display', 'none');
        passwordWrap.addClass('login_hidden_section');
        usernameWrap.addClass('login_hidden_section');
        loginBtn.addClass('login_hidden_section');
        searchIcon.hide();
        return;
      }

      var check = validateEmailAddress(emailAddress);
      $('#createaccount').prop('checked', false);

      if (false === check) {
        errorText.show().css('display', 'inline-block');
        emptyError.hide();
        createBox.css('display', 'none');
        passwordWrap.addClass('login_hidden_section');
        usernameWrap.addClass('login_hidden_section');
        loginBtn.addClass('login_hidden_section');
        searchIcon.hide();
        return;
      }

      emptyError.hide();
      errorText.hide();
      searchIcon.show().css('display', 'inline-block');
      wp.ajax.post({
        action: 'sellkit_checkout_ajax_handler',
        sub_action: 'search_for_email',
        email: emailAddress,
        dataType: 'json',
        nonce: sellkit_elementor.nonce
      }).done(function () {
        successResultEmailCheck();
      }).fail(function () {
        errorResultEmailCheck();
      });
    }, 500);
  });
  usernameField.on('keyup', function () {
    var _this2 = this;

    setTimeout(function () {
      var userValue = $(_this2).val();
      wp.ajax.post({
        action: 'sellkit_checkout_ajax_handler',
        sub_action: 'search_for_username',
        user: userValue,
        dataType: 'json',
        nonce: sellkit_elementor.nonce
      }).done(function () {
        $('.sellkit-checkout-widget-username-error').hide();
      }).fail(function () {
        $('.sellkit-checkout-widget-username-error').show();
      });
    }, 500);
  }); // If user is going to create account show password and username fields if exists.

  createCheck.on('click', function () {
    if ($(this).is(':checked')) {
      if (passwordField.length > 0) {
        passwordWrap.removeClass('login_hidden_section');
      }

      if (usernameField.length > 0) {
        usernameWrap.removeClass('login_hidden_section');
      }
    } else {
      usernameWrap.addClass('login_hidden_section');
      passwordWrap.addClass('login_hidden_section');
    }
  });

  var successResultEmailCheck = function successResultEmailCheck() {
    createBox.css('display', 'none');
    passwordWrap.removeClass('login_hidden_section');
    usernameWrap.addClass('login_hidden_section');
    loginBtn.removeClass('login_hidden_section');
    searchIcon.hide();
  };

  var errorResultEmailCheck = function errorResultEmailCheck() {
    createBox.css('display', 'flex');
    passwordWrap.addClass('login_hidden_section');
    usernameWrap.addClass('login_hidden_section');
    loginBtn.addClass('login_hidden_section');
    searchIcon.hide();
  };
};

var validateEmailAddress = function validateEmailAddress(emailAddress) {
  var pattern = /^([a-z\d!#$%&'*+\-\/=?^_`{|}~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+(\.[a-z\d!#$%&'*+\-\/=?^_`{|}~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+)*|"((([ \t]*\r\n)?[ \t]+)?([\x01-\x08\x0b\x0c\x0e-\x1f\x7f\x21\x23-\x5b\x5d-\x7e\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]|\\[\x01-\x09\x0b\x0c\x0d-\x7f\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))*(([ \t]*\r\n)?[ \t]+)?")@(([a-z\d\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]|[a-z\d\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF][a-z\d\-._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]*[a-z\d\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])\.)+([a-z\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]|[a-z\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF][a-z\d\-._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]*[a-z\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])\.?$/i;
  return pattern.test(emailAddress);
};

var LoginProcess = function LoginProcess() {
  var submitBtn = $('.login-submit');
  var email = $('.login-mail');
  var pass = $('.login-pass');
  var result = $('.login-result');
  submitBtn.on('click', function () {
    if ('' === email.val() || '' === pass.val()) {
      result.text((0, _i18n.__)('Both Field required.', 'sellkit')).css({
        color: 'red'
      });
      return;
    }

    wp.ajax.post({
      beforeSend: function beforeSend() {
        $('.login-submit').css('opacity', '0.5');
      },
      action: 'sellkit_checkout_ajax_handler',
      sub_action: 'auth_user',
      email: email.val(),
      pass: pass.val(),
      nonce: sellkit_elementor.nonce
    }).done(function () {
      location.reload();
    }).fail(function (response) {
      $('.login-submit').css('opacity', '1');
      $('.login-result').html(response).css({
        color: 'red'
      });
    });
  });
};

var secondStepHeader = function secondStepHeader() {
  var email = $('#billing_email');
  $('.multistep-headers > .info-a > div > .mail').text(email.val());
  var countryValue = $('#shipping_country option:selected').text();
  var state = $('#sellkit-shipping_state');
  var postcode = $('#shipping_postcode');
  var city = $('#shipping_city');
  var addressA = $('#shipping_address_1');
  var addressB = $('#shipping_address_2');
  var finalAddress = postcode.val() ? ', ' + postcode.val() : '';
  finalAddress += addressB.val() ? ', ' + addressB.val() : '';
  finalAddress += addressA.val() ? ', ' + addressA.val() : '';
  finalAddress += city.val() ? ', ' + city.val() : '';
  finalAddress += state.val() ? ', ' + state.val() : '';
  finalAddress += countryValue && !countryValue.includes('/') ? ', ' + countryValue : '';

  if (',' === finalAddress.charAt(0)) {
    finalAddress = finalAddress.substring(1);
  }

  $('.multistep-headers > .info-b > div > .address').text(finalAddress);
  var method = $('#shipping_method').find('input[type=radio]:checked');
  var methodTxt = method.siblings('label').text();
  $('.multistep-headers > .info-c > div > .method').text(methodTxt);
};

var manageBillingMethod = function manageBillingMethod() {
  var billingWrap = $('.sellkit-one-page-checkout-billing');
  var methodA = billingWrap.find('.method-a');
  var methodB = billingWrap.find('.method-b'); // Get shipping values.

  var name = $('#shipping_first_name');
  var last = $('#shipping_last_name');
  var addressA = $('#shipping_address_1');
  var addressB = $('#shipping_address_2');
  var country = $('#shipping_country');
  var state = $('#sellkit-shipping_state');
  var postcode = $('#shipping_postcode');
  var city = $('#shipping_city');
  methodA.on('click', function () {
    billingWrap.find('.woocommerce-billing-fields__field-wrapper').hide();
    $('#billing_first_name').val(name.val());
    $('#billing_last_name').val(last.val());
    $('#billing_address_1').val(addressA.val());
    $('#billing_address_2').val(addressB.val());
    $('#billing_country').val(country.val()).trigger('change');
    $('#sellkit-billing_state').val(state.val()).trigger('change');
    $('#billing_postcode').val(postcode.val());
    $('#billing_city').val(city.val());
  });
  methodB.on('click', function () {
    $('.inner_wrapper').css('height', 'auto');
    billingWrap.find('.woocommerce-billing-fields__field-wrapper').show();
  });
};

var mobileSummary = function mobileSummary() {
  if ($(window).width() < 600) {
    $('#order_review').addClass('sellkit-mobile-multistep-order-summary');
  }

  var toggleBtn = $('.summary_toggle > .title, .summary_toggle > i, .summary_toggle > .icon');
  var wrap = $('.summary_toggle');
  toggleBtn.on('click', function () {
    $('#order_review').toggle();

    if ('Hide order summary' === toggleBtn.text()) {
      wrap.find('.title').text((0, _i18n.__)('Show order summary', 'sellkit'));
      wrap.find('i').addClass('fa-chevron-down').removeClass('fa-chevron-up');
      wrap.css('border-bottom-width', '0px');
    } else {
      wrap.find('.title').text((0, _i18n.__)('Hide order summary', 'sellkit'));
      wrap.find('i').addClass('fa-chevron-up').removeClass('fa-chevron-down');
      wrap.css('border-bottom-width', '1px');
    }

    var parent = $('#sellkit-checkout-multistep-inner-wrap');
    parent.css('height', 'auto');
  });
};

var fieldFocus = function fieldFocus() {
  var $fields = $('.sellkit-checkout-local-fields').find('input, select, hidden, textarea, #sellkit-billing_state ,#sellkit-shipping_state, .validate-email');
  $fields.each(function () {
    var _this3 = this;

    var miniTitle = $(this).parent().parent().parent().find('.mini-title');
    var $thisValue = $(this).val(); // On load.

    if (!_.isEmpty($thisValue)) {
      $(this).addClass('filled').removeClass('empty');
      miniTitle.css({
        display: 'flex'
      });
    } // On change/focusOut


    $(this).on('change input focusout', function (e) {
      var changedValue = $(_this3).val();

      if (changedValue || $(_this3).find('option').length) {
        $(_this3).addClass('filled');
        $(_this3).removeClass('empty');
        $(_this3).parents('.sellkit-widget-checkout-fields').find('.mini-title').css('display', 'flex');
      } else {
        $(_this3).addClass('empty');
        $(_this3).removeClass('filled');
        $(_this3).parents('.sellkit-widget-checkout-fields').find('.mini-title').hide();
      } // On focusout validate fields.


      if ('focusout' === e.type) {
        FieldsMiniTitles($(_this3), 'focusout');
        var parent = $(_this3).parent().parent().parent(); // Required validation. return if required field rule is not followed.

        if (parent.hasClass('validate-required')) {
          if ('INPUT' === _this3.nodeName && 'checkbox' === $(_this3).attr('type')) {
            if (!_this3.checked) {
              parent.find('.sellkit-required-validation').css('display', 'inline-flex');
              return;
            }
          }

          if (_.isEmpty($(_this3).val())) {
            parent.find('.sellkit-required-validation').css('display', 'inline-flex');
            return;
          }

          parent.find('.sellkit-required-validation').css('display', 'none');
        } // Required validation of this field if exists, passed successfully. now postcode validation.


        if (parent.hasClass('sellkit-checkout-fields-validation-postcode')) {
          var postcodeVal = $(_this3).val();

          if (_.isEmpty(postcodeVal)) {
            return;
          } // Check field type to get related country value. we can't validate without country code.


          var postcodeName = $(_this3).attr('name');
          var postcodeCountry = $('#billing_country');

          if (postcodeName.includes('shipping')) {
            postcodeCountry = $('#shipping_country');
          } // Keep validating only if country field is present.


          if (!postcodeCountry.length) {
            return;
          }

          var countryCode = postcodeCountry.val();

          if (_.isEmpty(countryCode)) {
            parent.find('.sellkit-checkout-field-global-errors').show().text((0, _i18n.__)('Please select a country.', 'sellkit'));
            return;
          } else {
            // eslint-disable-line
            parent.find('.sellkit-checkout-field-global-errors').hide().text('');
          }

          parent.find('.sellkit-checkout-field-global-errors').hide().text('');
          postcodeValidation(postcodeVal, countryCode, $(_this3));
        } // Phone validation using woocommerce way.


        if (parent.hasClass('sellkit-checkout-fields-validation-phone')) {
          var phone = $(_this3).val();

          if (_.isEmpty(phone)) {
            return;
          }

          phoneNumberValidation(phone, $(_this3));
        }
      }

      if ('change' === e.type && ('billing_country' === $(_this3).attr('id') || 'shipping_country' === $(_this3).attr('id'))) {
        var _countryCode = $(_this3).val();

        var states = wcCountries[_countryCode];
        var state = 'sellkit-shipping_state';

        if ('billing_country' === $(_this3).attr('id')) {
          state = 'sellkit-billing_state';
        }

        var stateField = document.getElementById(state);
        $(stateField).empty();

        for (var keys in states) {
          var option = document.createElement('option');
          option.value = keys;
          option.innerHTML = states[keys];
          stateField.appendChild(option);
        }
      }
    });
  });
};

var breadcrumbLinks = function breadcrumbLinks() {
  var $parent = $('.sellkit-checkout-widget-breadcrumb-mobile, .sellkit-checkout-widget-breadcrumb-desktop');
  var detector = $('.sellkit-multistep-checkout-first');
  $parent.find('.information').on('click', function () {
    $('.go-to-first').click();
  });
  $parent.find('.shipping').on('click', function () {
    var display = detector.css('display');

    if ('none' === display) {
      $('.go-to-second').click();
    } else {
      $('.go-to-shipping').click();
    }
  });
  $parent.find('.payment').on('click', function () {
    $('.go-to-payment').click();
    $('.information').removeClass('current').addClass('inactive, blue-line');
  });
};

var fixFieldSpaceIssue = function fixFieldSpaceIssue() {
  $(function () {
    var shippingFields = $('#customer_details .sellkit-widget-checkout-fields');
    shippingFields.each(function (index) {
      if ($(shippingFields[index + 1]).length) {
        var next = $(shippingFields[index + 1]).offset().top;
        var current = $(shippingFields[index]).offset().top;

        if (next > current) {
          $(shippingFields[index]).addClass('sellkit-checkout-excluded-wrapper-fields');
        }
      } else {
        $(shippingFields[index]).addClass('sellkit-checkout-excluded-wrapper-fields');
      }
    });
  });
};

var organizeFieldsonLoad = function organizeFieldsonLoad() {
  $(function () {
    var fields = $('.sellkit-widget-checkout-fields').find('input, select, textarea');
    fields.each(function () {
      var tag = this.nodeName;

      if ('SELECT' === tag) {
        $(this).parent().parent().parent().addClass('sellkit-checkout-field-select');
      }

      FieldsMiniTitles($(this), 'load');
    });
  });
  $(document).on('mousemove change', function (e) {
    var fields = $('.sellkit-widget-checkout-fields').find('input, select, textarea');
    fields.each(function () {
      var tag = this.nodeName;

      if ('SELECT' === tag) {
        $(this).parent().parent().parent().addClass('sellkit-checkout-field-select');
      }

      FieldsMiniTitles($(this), e.type);
    });
  });
};

var FieldsMiniTitles = function FieldsMiniTitles(field, event) {
  if (field.attr('multiple')) {
    field.addClass('filled');
    field.removeClass('empty');
    field.parents('.sellkit-widget-checkout-fields').find('.mini-title').css('display', 'flex');
    return;
  }

  if (_.isEmpty(field.val())) {
    field.addClass('empty');
    field.removeClass('filled');
    field.parents('.sellkit-widget-checkout-fields').find('.mini-title').css('display', 'none');
  } else {
    field.addClass('filled');
    field.removeClass('empty');
    field.parents('.sellkit-widget-checkout-fields').find('.mini-title').css('display', 'flex');
  } // Hide wrapper if field is hidden


  if ('hidden' === field.attr('type')) {
    field.parents('.sellkit-widget-checkout-fields').addClass('sellkit-hide-completely');
  }

  if ('change' !== event) {
    return;
  } // Hide Billing state wrapper when these fields are hidden.


  if ('billing_country' === field.attr('id')) {
    var $state = document.getElementById('sellkit-billing_state');

    if ('SELECT' === $state.nodeName && $('#sellkit-billing_state option').length < 1) {
      var stateField = $('#sellkit-billing_state');
      var parent = stateField.parent().parent().parent();
      parent.removeClass('sellkit-checkout-field-select');
      var placeholder = stateField.attr('placeholder');
      var stateInput = document.createElement('input');
      stateInput.setAttribute('type', 'text');
      stateInput.setAttribute('id', 'sellkit-billing_state');
      stateInput.setAttribute('name', 'billing_state');
      stateInput.setAttribute('placeholder', placeholder); // Replace select field with text.

      stateField.remove();
      parent.find('.woocommerce-input-wrapper').append(stateInput);
    }

    var countryCode = field.val();
    var states = wcCountries[countryCode];

    if ('INPUT' === $state.nodeName && !_.isEmpty(states)) {
      var _stateField = $('#sellkit-billing_state');

      var _placeholder = _stateField.attr('placeholder');

      var _parent = _stateField.parent().parent().parent();

      _parent.addClass('sellkit-checkout-field-select');

      if (_.isUndefined(_placeholder) || _.isEmpty(_placeholder)) {
        _placeholder = (0, _i18n.__)('State', 'sellkit');
      } // Replace text field with select field.


      _stateField.remove();

      var stateSelect = document.createElement('select');
      stateSelect.setAttribute('name', 'billing_state');
      stateSelect.setAttribute('id', 'sellkit-billing_state');
      stateSelect.setAttribute('placeholder', _placeholder);
      stateSelect.addEventListener('change', function () {
        sellkitSetAddressDetails();
      });

      for (var keys in states) {
        var option = document.createElement('option');
        option.value = keys;
        option.innerHTML = states[keys];
        stateSelect.appendChild(option);
      }

      _parent.find('.woocommerce-input-wrapper').append(stateSelect);
    }
  } // Remove select icon when field is text for the shipping/billing state fields.


  if ('shipping_country' === field.attr('id')) {
    var _$state = document.getElementById('sellkit-shipping_state');

    if ('SELECT' === _$state.nodeName && $('#sellkit-shipping_state option').length < 1) {
      var _stateField2 = $('#sellkit-shipping_state');

      var _parent2 = _stateField2.parent().parent().parent();

      _parent2.removeClass('sellkit-checkout-field-select');

      var _placeholder2 = _stateField2.attr('placeholder');

      var _stateInput = document.createElement('input');

      _stateInput.setAttribute('type', 'text');

      _stateInput.setAttribute('id', 'sellkit-shipping_state');

      _stateInput.setAttribute('name', 'shipping_state');

      _stateInput.setAttribute('placeholder', _placeholder2); // Replace select field with text.


      _stateField2.remove();

      _parent2.find('.woocommerce-input-wrapper').append(_stateInput);
    }

    var _countryCode2 = field.val();

    var _states = wcCountries[_countryCode2];

    if ('INPUT' === _$state.nodeName && !_.isEmpty(_states)) {
      var _stateField3 = $('#sellkit-shipping_state');

      var _placeholder3 = _stateField3.attr('placeholder');

      var _parent3 = _stateField3.parent().parent().parent();

      _parent3.addClass('sellkit-checkout-field-select');

      if (_.isUndefined(_placeholder3) || _.isEmpty(_placeholder3)) {
        _placeholder3 = (0, _i18n.__)('State', 'sellkit');
      } // Replace text field with select field.


      _stateField3.remove();

      var _stateSelect = document.createElement('select');

      _stateSelect.setAttribute('name', 'shipping_state');

      _stateSelect.setAttribute('id', 'sellkit-shipping_state');

      _stateSelect.setAttribute('placeholder', _placeholder3);

      _stateSelect.addEventListener('change', function () {
        sellkitSetAddressDetails();
      });

      for (var _keys in _states) {
        var _option = document.createElement('option');

        _option.value = _keys;
        _option.innerHTML = _states[_keys];

        _stateSelect.appendChild(_option);
      }

      _parent3.find('.woocommerce-input-wrapper').append(_stateSelect);
    }
  }
};

var sellkitCheckoutUpdateCartItem = function sellkitCheckoutUpdateCartItem() {
  $('.sellkit-one-page-checkout-product-qty').off('change').on('change', function () {
    $(this).attr('readonly', true);
    wp.ajax.post({
      action: 'sellkit_checkout_ajax_handler',
      sub_action: 'change_cart_item_qty',
      qty: $(this).val(),
      id: $(this).attr('data-id'),
      mode: 'edit',
      nonce: sellkit_elementor.nonce
    }).always(function () {
      $(document.body).trigger('update_checkout');
      $('.sellkit-one-page-checkout-product-qty').attr('readonly', false);
    });
  });
  $('.sellkit-one-page-pay-method').on('click', function () {
    $('.sellkit_payment_box').hide();
    $(this).parent().parent().next().show();
  });
  var count = $('.sellkit-checkout-widget-order-summary-tfoot').children().length;

  if (count <= 3) {
    $('.cart-subtotal td').css('padding-bottom', '8px');
    $('.cart-subtotal th').css('padding-bottom', '8px');
  }
};

var applyCoupon = function applyCoupon() {
  $('.sellkit-apply-coupon').off('click').on('click', function () {
    wp.ajax.post({
      beforeSend: function beforeSend() {
        $('.jx-apply-coupon').css('opacity', 0.5);
      },
      action: 'sellkit_checkout_ajax_handler',
      sub_action: 'apply_coupon',
      code: jQuery('.sellkit-custom-coupon-form').find('.jx-coupon').val(),
      nonce: sellkit_elementor.nonce
    }).done(function () {
      $(document.body).trigger('update_checkout');
      $('.jx-apply-coupon').css('opacity', 1);
    }).fail(function () {
      $('.jx-apply-coupon').css('opacity', 1);
    });
  });
};

var couponToggle = function couponToggle() {
  if ($('.sellkit-coupon-toggle').length) {
    $('.sellkit-custom-coupon-form').css('display', 'none');
  }

  $('.sellkit-coupon-toggle').off('click').on('click', function () {
    var direction = 'row';
    var status = $('.sellkit-custom-coupon-form').css('display');
    var displayValue = '';

    if ($(window).width() < 600) {
      direction = 'column';
    }

    if ('none' === status) {
      displayValue = 'inline-flex';
    } else {
      displayValue = 'none';
    }

    $('.sellkit-custom-coupon-form').css({
      display: displayValue,
      flexDirection: direction
    });
  });
};

var postcodeValidation = function postcodeValidation(postcode, country, element) {
  var parentElement = element.attr('id');
  wp.ajax.post({
    action: 'sellkit_checkout_ajax_handler',
    sub_action: 'validate_postcode',
    post_code: postcode,
    country_code: country,
    parent: parentElement,
    nonce: sellkit_elementor.nonce
  }).done(function (response) {
    var field = $('#' + response);
    var parent = field.parent().parent().parent();
    parent.find('.sellkit-checkout-field-global-errors').hide().text('');
  }).fail(function (response) {
    var field = $('#' + response);
    var parent = field.parent().parent().parent();
    parent.find('.sellkit-checkout-field-global-errors').show().text((0, _i18n.__)('Postcode is not valid.', 'sellkit'));
  });
};

var phoneNumberValidation = function phoneNumberValidation(phone, element) {
  var parentElement = element.attr('id');
  wp.ajax.post({
    action: 'sellkit_checkout_ajax_handler',
    sub_action: 'validate_phone_number',
    phone_number: phone,
    parent: parentElement,
    nonce: sellkit_elementor.nonce
  }).done(function (response) {
    var field = $('#' + response);
    var parent = field.parent().parent().parent();
    parent.find('.sellkit-checkout-field-global-errors').hide().text('');
  }).fail(function (response) {
    var field = $('#' + response);
    var parent = field.parent().parent().parent();
    parent.find('.sellkit-checkout-field-global-errors').show().text((0, _i18n.__)('Phone number is not valid.', 'sellkit'));
  });
};

var sellkitPostalCodeAutocomplete = function sellkitPostalCodeAutocomplete() {
  $('.post_code_autocomplete').find('input').on('paste focusout', function () {
    var postcode = $(this).val();
    var country = $('#shipping_country').val();
    var state = $('#sellkit-shipping_state');
    var city = $('#shipping_city');
    var parent = $(this).parent().parent().parent();

    if ('billing_postcode' === $(this).attr('id')) {
      country = $('#billing_country').val();
      state = $('#sellkit-billing_state');
      city = $('#billing_city');
    }

    if (_.isEmpty(postcode) || _.isEmpty(country)) {
      return;
    }

    wp.ajax.post({
      action: 'sellkit_checkout_ajax_handler',
      sub_action: 'sellkit_state_lookup_by_postcode',
      country_value: country,
      postcode_value: postcode,
      nonce: sellkit_elementor.nonce
    }).done(function (response) {
      var body = response.body;
      body = JSON.parse(body);
      var placeCity = body.places[0]['place name'];
      var placeState = body.places[0]['state abbreviation'];
      setFields(placeCity, placeState);
    }).fail(function (response) {
      setError(response);
    });

    var setFields = function setFields(placeCity, placeState) {
      state.val(placeState).addClass('filled');
      city.val(placeCity).addClass('filled');
    };

    var setError = function setError(response) {
      parent.find('.sellkit-checkout-field-global-errors').text(response);
    };
  });
};

var sellkitKlarmaIntegration = function sellkitKlarmaIntegration() {
  $(document).ready(function () {
    $('#sellkit-klarna-pay-button').on('click', function () {
      $('#payment_method_kco').trigger('click');
    });
  });
}; // This also is supposed to update shipping method.


var fixClientCountryOnReload = function fixClientCountryOnReload() {
  $('#shipping_country, #billing_country, #sellkit-shipping_state, #sellkit-billing_state').on('change', function () {
    sellkitSetAddressDetails();
  });
};

var sellkitSetAddressDetails = function sellkitSetAddressDetails() {
  wp.ajax.post({
    action: 'sellkit_checkout_ajax_handler',
    sub_action: 'set_customer_details_ajax',
    country: document.querySelector('#billing_country') ? document.getElementById('billing_country').value : '',
    state: document.querySelector('#sellkit-billing_state') ? document.getElementById('sellkit-billing_state').value : '',
    shipping_country: document.querySelector('#shipping_country') ? document.getElementById('shipping_country').value : '',
    shipping_state: document.querySelector('#sellkit-shipping_state') ? document.getElementById('sellkit-shipping_state').value : '',
    nonce: sellkit_elementor.nonce
  }).always(function () {
    $(document.body).trigger('update_checkout');
  });
};

var fixStateIssueOnLoad = function fixStateIssueOnLoad() {
  var primaryValue = '';

  if (document.querySelector('#shipping_country')) {
    primaryValue = $('#shipping_country').val();
    $('#shipping_country').val($('#shipping_country option:eq(1)').val());
    $('#shipping_country').val(primaryValue).trigger('change');
  }

  if (document.querySelector('#billing_country')) {
    primaryValue = $('#billing_country').val();
    $('#billing_country').val($('#billing_country option:eq(1)').val());
    $('#billing_country').val(primaryValue).trigger('change');
  }
};

var sellkitCheckoutConfigureBundleProducts = function sellkitCheckoutConfigureBundleProducts() {
  var radioProducts = $('.sellkit-checkout-bundle-item');
  radioProducts.off('change').on('change', function () {
    $('.sellkit-checkout-bump-order-products').each(function () {
      if ($(this).is(':checked')) {
        $(this).trigger('click');
      }
    });
    var product = $(this).val();
    var quantity = $(this).parent().parent().find('.sellkit-checkout-single-bundle-item-quantity').val();
    wp.ajax.post({
      action: 'sellkit_checkout_ajax_handler',
      sub_action: 'sellkit_checkout_modify_cart_by_bundle_products',
      id: product,
      qty: quantity,
      type: 'radio',
      nonce: sellkit_elementor.nonce
    }).always(function () {
      $(document.body).trigger('update_checkout');
    });
  });
};

var sellkitCheckoutOrderBump = function sellkitCheckoutOrderBump() {
  $('.sellkit-checkout-bump-order-products').on('click', function () {
    var subAction;

    if ($(this).is(':checked')) {
      subAction = 'add';
    } else {
      subAction = 'remove';
    }

    wp.ajax.post({
      action: 'sellkit_checkout_ajax_handler',
      sub_action: 'change_cart_item_qty',
      qty: $(this).attr('data-qty'),
      id: $(this).val(),
      mode: subAction,
      nonce: sellkit_elementor.nonce
    }).always(function () {
      $(document.body).trigger('update_checkout');
    });
  });
};

var checkRequiredFields = function checkRequiredFields() {
  var fields = document.querySelectorAll('#sellkit-checkout-widget-shipping-fields > .validate-required');
  var error = false;

  if (fields.length < 1) {
    return error;
  }

  fields.forEach(function (item) {
    var target = $(item).find('input, select, textarea').val();

    if ('' === target) {
      error = true;
      $(item).find('.sellkit-required-validation').css('display', 'inline-flex');
    }
  });
  return error;
};

},{"@wordpress/i18n":12}],2:[function(require,module,exports){
"use strict";

(function ($) {
  var SellkitFrontend = function SellkitFrontend() {
    var widgets = {
      'sellkit-product-images.default': require('./product-images')["default"],
      'sellkit-checkout.default': require('./checkout')["default"]
    };

    function elementorInit() {
      for (var widget in widgets) {
        elementorFrontend.hooks.addAction("frontend/element_ready/".concat(widget), widgets[widget]);
      }
    }

    this.init = function () {
      $(window).on('elementor/frontend/init', elementorInit);
    };

    this.init();
  };

  window.sellkitFrontend = new SellkitFrontend();
})(jQuery);

},{"./checkout":1,"./product-images":3}],3:[function(require,module,exports){
"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = _default;
var ProductImages = elementorModules.frontend.handlers.Base.extend({
  onInit: function onInit() {
    elementorModules.frontend.handlers.Base.prototype.onInit.apply(this, arguments);

    if (document.body.classList.contains('elementor-editor-active')) {
      this.$element.find('.woocommerce-product-gallery').wc_product_gallery();
    }

    var self = this;

    if (typeof window.elementor === 'undefined') {
      return;
    }

    window.elementor.channels.editor.on('change', function (controlView) {
      self.onElementChange(controlView.model.get('name'), controlView);
    });
    this.handleThumbnailBorderRadius(this.getElementSettings('thumbnail_border_radius'));
  },
  onElementChange: function onElementChange(propertyName, controlView) {
    if ('thumbnail_border_radius' === propertyName) {
      var borderRadius = controlView.container.settings.get('thumbnail_border_radius');
      this.handleThumbnailBorderRadius(borderRadius);
    }
  },
  handleThumbnailBorderRadius: function handleThumbnailBorderRadius(borderRadius) {
    var unit = borderRadius.unit;
    this.$element.find('.flex-control-nav li').css({
      'border-radius': borderRadius.top + unit + ' ' + borderRadius.right + unit + ' ' + borderRadius.bottom + unit + ' ' + borderRadius.left + unit
    });
  },
  bindEvents: function bindEvents() {
    this.$element.find('.woocommerce-product-gallery__image a').on('click', function (e) {
      e.stopImmediatePropagation();
      e.preventDefault();
    });
  }
});

function _default($scope) {
  new ProductImages({
    $element: $scope
  });
}

},{}],4:[function(require,module,exports){
function _defineProperty(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }

  return obj;
}

module.exports = _defineProperty;
},{}],5:[function(require,module,exports){
function _interopRequireDefault(obj) {
  return obj && obj.__esModule ? obj : {
    "default": obj
  };
}

module.exports = _interopRequireDefault;
},{}],6:[function(require,module,exports){
'use strict';

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

var postfix = _interopDefault(require('@tannin/postfix'));
var evaluate = _interopDefault(require('@tannin/evaluate'));

/**
 * Given a C expression, returns a function which can be called to evaluate its
 * result.
 *
 * @example
 *
 * ```js
 * import compile from '@tannin/compile';
 *
 * const evaluate = compile( 'n > 1' );
 *
 * evaluate( { n: 2 } );
 * // ⇒ true
 * ```
 *
 * @param {string} expression C expression.
 *
 * @return {(variables?:{[variable:string]:*})=>*} Compiled evaluator.
 */
function compile( expression ) {
	var terms = postfix( expression );

	return function( variables ) {
		return evaluate( terms, variables );
	};
}

module.exports = compile;

},{"@tannin/evaluate":7,"@tannin/postfix":9}],7:[function(require,module,exports){
'use strict';

/**
 * Operator callback functions.
 *
 * @type {Object}
 */
var OPERATORS = {
	'!': function( a ) {
		return ! a;
	},
	'*': function( a, b ) {
		return a * b;
	},
	'/': function( a, b ) {
		return a / b;
	},
	'%': function( a, b ) {
		return a % b;
	},
	'+': function( a, b ) {
		return a + b;
	},
	'-': function( a, b ) {
		return a - b;
	},
	'<': function( a, b ) {
		return a < b;
	},
	'<=': function( a, b ) {
		return a <= b;
	},
	'>': function( a, b ) {
		return a > b;
	},
	'>=': function( a, b ) {
		return a >= b;
	},
	'==': function( a, b ) {
		return a === b;
	},
	'!=': function( a, b ) {
		return a !== b;
	},
	'&&': function( a, b ) {
		return a && b;
	},
	'||': function( a, b ) {
		return a || b;
	},
	'?:': function( a, b, c ) {
		if ( a ) {
			throw b;
		}

		return c;
	},
};

/**
 * Given an array of postfix terms and operand variables, returns the result of
 * the postfix evaluation.
 *
 * @example
 *
 * ```js
 * import evaluate from '@tannin/evaluate';
 *
 * // 3 + 4 * 5 / 6 ⇒ '3 4 5 * 6 / +'
 * const terms = [ '3', '4', '5', '*', '6', '/', '+' ];
 *
 * evaluate( terms, {} );
 * // ⇒ 6.333333333333334
 * ```
 *
 * @param {string[]} postfix   Postfix terms.
 * @param {Object}   variables Operand variables.
 *
 * @return {*} Result of evaluation.
 */
function evaluate( postfix, variables ) {
	var stack = [],
		i, j, args, getOperatorResult, term, value;

	for ( i = 0; i < postfix.length; i++ ) {
		term = postfix[ i ];

		getOperatorResult = OPERATORS[ term ];
		if ( getOperatorResult ) {
			// Pop from stack by number of function arguments.
			j = getOperatorResult.length;
			args = Array( j );
			while ( j-- ) {
				args[ j ] = stack.pop();
			}

			try {
				value = getOperatorResult.apply( null, args );
			} catch ( earlyReturn ) {
				return earlyReturn;
			}
		} else if ( variables.hasOwnProperty( term ) ) {
			value = variables[ term ];
		} else {
			value = +term;
		}

		stack.push( value );
	}

	return stack[ 0 ];
}

module.exports = evaluate;

},{}],8:[function(require,module,exports){
'use strict';

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

var compile = _interopDefault(require('@tannin/compile'));

/**
 * Given a C expression, returns a function which, when called with a value,
 * evaluates the result with the value assumed to be the "n" variable of the
 * expression. The result will be coerced to its numeric equivalent.
 *
 * @param {string} expression C expression.
 *
 * @return {Function} Evaluator function.
 */
function pluralForms( expression ) {
	var evaluate = compile( expression );

	return function( n ) {
		return +evaluate( { n: n } );
	};
}

module.exports = pluralForms;

},{"@tannin/compile":6}],9:[function(require,module,exports){
'use strict';

var PRECEDENCE, OPENERS, TERMINATORS, PATTERN;

/**
 * Operator precedence mapping.
 *
 * @type {Object}
 */
PRECEDENCE = {
	'(': 9,
	'!': 8,
	'*': 7,
	'/': 7,
	'%': 7,
	'+': 6,
	'-': 6,
	'<': 5,
	'<=': 5,
	'>': 5,
	'>=': 5,
	'==': 4,
	'!=': 4,
	'&&': 3,
	'||': 2,
	'?': 1,
	'?:': 1,
};

/**
 * Characters which signal pair opening, to be terminated by terminators.
 *
 * @type {string[]}
 */
OPENERS = [ '(', '?' ];

/**
 * Characters which signal pair termination, the value an array with the
 * opener as its first member. The second member is an optional operator
 * replacement to push to the stack.
 *
 * @type {string[]}
 */
TERMINATORS = {
	')': [ '(' ],
	':': [ '?', '?:' ],
};

/**
 * Pattern matching operators and openers.
 *
 * @type {RegExp}
 */
PATTERN = /<=|>=|==|!=|&&|\|\||\?:|\(|!|\*|\/|%|\+|-|<|>|\?|\)|:/;

/**
 * Given a C expression, returns the equivalent postfix (Reverse Polish)
 * notation terms as an array.
 *
 * If a postfix string is desired, simply `.join( ' ' )` the result.
 *
 * @example
 *
 * ```js
 * import postfix from '@tannin/postfix';
 *
 * postfix( 'n > 1' );
 * // ⇒ [ 'n', '1', '>' ]
 * ```
 *
 * @param {string} expression C expression.
 *
 * @return {string[]} Postfix terms.
 */
function postfix( expression ) {
	var terms = [],
		stack = [],
		match, operator, term, element;

	while ( ( match = expression.match( PATTERN ) ) ) {
		operator = match[ 0 ];

		// Term is the string preceding the operator match. It may contain
		// whitespace, and may be empty (if operator is at beginning).
		term = expression.substr( 0, match.index ).trim();
		if ( term ) {
			terms.push( term );
		}

		while ( ( element = stack.pop() ) ) {
			if ( TERMINATORS[ operator ] ) {
				if ( TERMINATORS[ operator ][ 0 ] === element ) {
					// Substitution works here under assumption that because
					// the assigned operator will no longer be a terminator, it
					// will be pushed to the stack during the condition below.
					operator = TERMINATORS[ operator ][ 1 ] || operator;
					break;
				}
			} else if ( OPENERS.indexOf( element ) >= 0 || PRECEDENCE[ element ] < PRECEDENCE[ operator ] ) {
				// Push to stack if either an opener or when pop reveals an
				// element of lower precedence.
				stack.push( element );
				break;
			}

			// For each popped from stack, push to terms.
			terms.push( element );
		}

		if ( ! TERMINATORS[ operator ] ) {
			stack.push( operator );
		}

		// Slice matched fragment from expression to continue match.
		expression = expression.substr( match.index + operator.length );
	}

	// Push remainder of operand, if exists, to terms.
	expression = expression.trim();
	if ( expression ) {
		terms.push( expression );
	}

	// Pop remaining items from stack into terms.
	return terms.concat( stack.reverse() );
}

module.exports = postfix;

},{}],10:[function(require,module,exports){
"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.createI18n = void 0;

var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));

var _tannin = _interopRequireDefault(require("tannin"));

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

/**
 * @typedef {Record<string,any>} LocaleData
 */

/**
 * Default locale data to use for Tannin domain when not otherwise provided.
 * Assumes an English plural forms expression.
 *
 * @type {LocaleData}
 */
var DEFAULT_LOCALE_DATA = {
  '': {
    /** @param {number} n */
    plural_forms: function plural_forms(n) {
      return n === 1 ? 0 : 1;
    }
  }
};
/**
 * An i18n instance
 *
 * @typedef {Object} I18n
 * @property {Function} setLocaleData Merges locale data into the Tannin instance by domain. Accepts data in a
 *                                    Jed-formatted JSON object shape.
 * @property {Function} __            Retrieve the translation of text.
 * @property {Function} _x            Retrieve translated string with gettext context.
 * @property {Function} _n            Translates and retrieves the singular or plural form based on the supplied
 *                                    number.
 * @property {Function} _nx           Translates and retrieves the singular or plural form based on the supplied
 *                                    number, with gettext context.
 * @property {Function} isRTL         Check if current locale is RTL.
 */

/**
 * Create an i18n instance
 *
 * @param {LocaleData} [initialData]    Locale data configuration.
 * @param {string}     [initialDomain]  Domain for which configuration applies.
 * @return {I18n}                       I18n instance
 */

var createI18n = function createI18n(initialData, initialDomain) {
  /**
   * The underlying instance of Tannin to which exported functions interface.
   *
   * @type {Tannin}
   */
  var tannin = new _tannin.default({});
  /**
   * Merges locale data into the Tannin instance by domain. Accepts data in a
   * Jed-formatted JSON object shape.
   *
   * @see http://messageformat.github.io/Jed/
   *
   * @param {LocaleData} [data]   Locale data configuration.
   * @param {string}     [domain] Domain for which configuration applies.
   */

  var setLocaleData = function setLocaleData(data) {
    var domain = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'default';
    tannin.data[domain] = _objectSpread({}, DEFAULT_LOCALE_DATA, {}, tannin.data[domain], {}, data); // Populate default domain configuration (supported locale date which omits
    // a plural forms expression).

    tannin.data[domain][''] = _objectSpread({}, DEFAULT_LOCALE_DATA[''], {}, tannin.data[domain]['']);
  };
  /**
   * Wrapper for Tannin's `dcnpgettext`. Populates default locale data if not
   * otherwise previously assigned.
   *
   * @param {string|undefined} domain   Domain to retrieve the translated text.
   * @param {string|undefined} 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 = function dcnpgettext() {
    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;

    if (!tannin.data[domain]) {
      setLocaleData(undefined, domain);
    }

    return tannin.dcnpgettext(domain, context, single, plural, number);
  };
  /**
   * 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.
   */


  var __ = 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.
   */


  var _x = 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.
   */


  var _n = 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.
   */


  var _nx = function _nx(single, plural, number, context, domain) {
    return dcnpgettext(domain, context, single, plural, number);
  };
  /**
   * Check if current locale is RTL.
   *
   * **RTL (Right To Left)** is a locale property indicating that text is written from right to left.
   * For example, the `he` locale (for Hebrew) specifies right-to-left. Arabic (ar) is another common
   * language written RTL. The opposite of RTL, LTR (Left To Right) is used in other languages,
   * including English (`en`, `en-US`, `en-GB`, etc.), Spanish (`es`), and French (`fr`).
   *
   * @return {boolean} Whether locale is RTL.
   */


  var isRTL = function isRTL() {
    return 'rtl' === _x('ltr', 'text direction');
  };

  if (initialData) {
    setLocaleData(initialData, initialDomain);
  }

  return {
    setLocaleData: setLocaleData,
    __: __,
    _x: _x,
    _n: _n,
    _nx: _nx,
    isRTL: isRTL
  };
};

exports.createI18n = createI18n;

},{"@babel/runtime/helpers/defineProperty":4,"@babel/runtime/helpers/interopRequireDefault":5,"tannin":17}],11:[function(require,module,exports){
"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.isRTL = exports._nx = exports._n = exports._x = exports.__ = exports.setLocaleData = void 0;

var _createI18n = require("./create-i18n");

/**
 * Internal dependencies
 */
var i18n = (0, _createI18n.createI18n)();
/*
 * Comments in this file are duplicated from ./i18n due to
 * https://github.com/WordPress/gutenberg/pull/20318#issuecomment-590837722
 */

/**
 * @typedef {import('./create-i18n').LocaleData} LocaleData
 */

/**
 * Merges locale data into the Tannin instance by domain. Accepts data in a
 * Jed-formatted JSON object shape.
 *
 * @see http://messageformat.github.io/Jed/
 *
 * @param {LocaleData} [data]   Locale data configuration.
 * @param {string}     [domain] Domain for which configuration applies.
 */

var setLocaleData = i18n.setLocaleData.bind(i18n);
/**
 * 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.
 */

exports.setLocaleData = setLocaleData;

var __ = i18n.__.bind(i18n);
/**
 * 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.
 */


exports.__ = __;

var _x = i18n._x.bind(i18n);
/**
 * 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.
 */


exports._x = _x;

var _n = i18n._n.bind(i18n);
/**
 * 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.
 */


exports._n = _n;

var _nx = i18n._nx.bind(i18n);
/**
 * Check if current locale is RTL.
 *
 * **RTL (Right To Left)** is a locale property indicating that text is written from right to left.
 * For example, the `he` locale (for Hebrew) specifies right-to-left. Arabic (ar) is another common
 * language written RTL. The opposite of RTL, LTR (Left To Right) is used in other languages,
 * including English (`en`, `en-US`, `en-GB`, etc.), Spanish (`es`), and French (`fr`).
 *
 * @return {boolean} Whether locale is RTL.
 */


exports._nx = _nx;
var isRTL = i18n.isRTL.bind(i18n);
exports.isRTL = isRTL;

},{"./create-i18n":10}],12:[function(require,module,exports){
"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
var _exportNames = {
  sprintf: true,
  setLocaleData: true,
  __: true,
  _x: true,
  _n: true,
  _nx: true,
  isRTL: true
};
Object.defineProperty(exports, "sprintf", {
  enumerable: true,
  get: function get() {
    return _sprintf.sprintf;
  }
});
Object.defineProperty(exports, "setLocaleData", {
  enumerable: true,
  get: function get() {
    return _defaultI18n.setLocaleData;
  }
});
Object.defineProperty(exports, "__", {
  enumerable: true,
  get: function get() {
    return _defaultI18n.__;
  }
});
Object.defineProperty(exports, "_x", {
  enumerable: true,
  get: function get() {
    return _defaultI18n._x;
  }
});
Object.defineProperty(exports, "_n", {
  enumerable: true,
  get: function get() {
    return _defaultI18n._n;
  }
});
Object.defineProperty(exports, "_nx", {
  enumerable: true,
  get: function get() {
    return _defaultI18n._nx;
  }
});
Object.defineProperty(exports, "isRTL", {
  enumerable: true,
  get: function get() {
    return _defaultI18n.isRTL;
  }
});

var _sprintf = require("./sprintf");

var _createI18n = require("./create-i18n");

Object.keys(_createI18n).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function get() {
      return _createI18n[key];
    }
  });
});

var _defaultI18n = require("./default-i18n");

},{"./create-i18n":10,"./default-i18n":11,"./sprintf":13}],13:[function(require,module,exports){
"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.sprintf = sprintf;

var _memize = _interopRequireDefault(require("memize"));

var _sprintfJs = _interopRequireDefault(require("sprintf-js"));

/**
 * External dependencies
 */

/**
 * 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 = (0, _memize.default)(console.error); // eslint-disable-line no-console

/**
 * 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 {...*} 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 _sprintfJs.default.sprintf.apply(_sprintfJs.default, [format].concat(args));
  } catch (error) {
    logErrorOnce('sprintf error: \n\n' + error.toString());
    return format;
  }
}

},{"@babel/runtime/helpers/interopRequireDefault":5,"memize":15,"sprintf-js":14}],14:[function(require,module,exports){
/* global window, exports, define */

!function() {
    'use strict'

    var re = {
        not_string: /[^s]/,
        not_bool: /[^t]/,
        not_type: /[^T]/,
        not_primitive: /[^v]/,
        number: /[diefg]/,
        numeric_arg: /[bcdiefguxX]/,
        json: /[j]/,
        not_json: /[^j]/,
        text: /^[^\x25]+/,
        modulo: /^\x25{2}/,
        placeholder: /^\x25(?:([1-9]\d*)\$|\(([^)]+)\))?(\+)?(0|'[^$])?(-)?(\d+)?(?:\.(\d+))?([b-gijostTuvxX])/,
        key: /^([a-z_][a-z_\d]*)/i,
        key_access: /^\.([a-z_][a-z_\d]*)/i,
        index_access: /^\[(\d+)\]/,
        sign: /^[+-]/
    }

    function sprintf(key) {
        // `arguments` is not an array, but should be fine for this call
        return sprintf_format(sprintf_parse(key), arguments)
    }

    function vsprintf(fmt, argv) {
        return sprintf.apply(null, [fmt].concat(argv || []))
    }

    function sprintf_format(parse_tree, argv) {
        var cursor = 1, tree_length = parse_tree.length, arg, output = '', i, k, ph, pad, pad_character, pad_length, is_positive, sign
        for (i = 0; i < tree_length; i++) {
            if (typeof parse_tree[i] === 'string') {
                output += parse_tree[i]
            }
            else if (typeof parse_tree[i] === 'object') {
                ph = parse_tree[i] // convenience purposes only
                if (ph.keys) { // keyword argument
                    arg = argv[cursor]
                    for (k = 0; k < ph.keys.length; k++) {
                        if (arg == undefined) {
                            throw new Error(sprintf('[sprintf] Cannot access property "%s" of undefined value "%s"', ph.keys[k], ph.keys[k-1]))
                        }
                        arg = arg[ph.keys[k]]
                    }
                }
                else if (ph.param_no) { // positional argument (explicit)
                    arg = argv[ph.param_no]
                }
                else { // positional argument (implicit)
                    arg = argv[cursor++]
                }

                if (re.not_type.test(ph.type) && re.not_primitive.test(ph.type) && arg instanceof Function) {
                    arg = arg()
                }

                if (re.numeric_arg.test(ph.type) && (typeof arg !== 'number' && isNaN(arg))) {
                    throw new TypeError(sprintf('[sprintf] expecting number but found %T', arg))
                }

                if (re.number.test(ph.type)) {
                    is_positive = arg >= 0
                }

                switch (ph.type) {
                    case 'b':
                        arg = parseInt(arg, 10).toString(2)
                        break
                    case 'c':
                        arg = String.fromCharCode(parseInt(arg, 10))
                        break
                    case 'd':
                    case 'i':
                        arg = parseInt(arg, 10)
                        break
                    case 'j':
                        arg = JSON.stringify(arg, null, ph.width ? parseInt(ph.width) : 0)
                        break
                    case 'e':
                        arg = ph.precision ? parseFloat(arg).toExponential(ph.precision) : parseFloat(arg).toExponential()
                        break
                    case 'f':
                        arg = ph.precision ? parseFloat(arg).toFixed(ph.precision) : parseFloat(arg)
                        break
                    case 'g':
                        arg = ph.precision ? String(Number(arg.toPrecision(ph.precision))) : parseFloat(arg)
                        break
                    case 'o':
                        arg = (parseInt(arg, 10) >>> 0).toString(8)
                        break
                    case 's':
                        arg = String(arg)
                        arg = (ph.precision ? arg.substring(0, ph.precision) : arg)
                        break
                    case 't':
                        arg = String(!!arg)
                        arg = (ph.precision ? arg.substring(0, ph.precision) : arg)
                        break
                    case 'T':
                        arg = Object.prototype.toString.call(arg).slice(8, -1).toLowerCase()
                        arg = (ph.precision ? arg.substring(0, ph.precision) : arg)
                        break
                    case 'u':
                        arg = parseInt(arg, 10) >>> 0
                        break
                    case 'v':
                        arg = arg.valueOf()
                        arg = (ph.precision ? arg.substring(0, ph.precision) : arg)
                        break
                    case 'x':
                        arg = (parseInt(arg, 10) >>> 0).toString(16)
                        break
                    case 'X':
                        arg = (parseInt(arg, 10) >>> 0).toString(16).toUpperCase()
                        break
                }
                if (re.json.test(ph.type)) {
                    output += arg
                }
                else {
                    if (re.number.test(ph.type) && (!is_positive || ph.sign)) {
                        sign = is_positive ? '+' : '-'
                        arg = arg.toString().replace(re.sign, '')
                    }
                    else {
                        sign = ''
                    }
                    pad_character = ph.pad_char ? ph.pad_char === '0' ? '0' : ph.pad_char.charAt(1) : ' '
                    pad_length = ph.width - (sign + arg).length
                    pad = ph.width ? (pad_length > 0 ? pad_character.repeat(pad_length) : '') : ''
                    output += ph.align ? sign + arg + pad : (pad_character === '0' ? sign + pad + arg : pad + sign + arg)
                }
            }
        }
        return output
    }

    var sprintf_cache = Object.create(null)

    function sprintf_parse(fmt) {
        if (sprintf_cache[fmt]) {
            return sprintf_cache[fmt]
        }

        var _fmt = fmt, match, parse_tree = [], arg_names = 0
        while (_fmt) {
            if ((match = re.text.exec(_fmt)) !== null) {
                parse_tree.push(match[0])
            }
            else if ((match = re.modulo.exec(_fmt)) !== null) {
                parse_tree.push('%')
            }
            else if ((match = re.placeholder.exec(_fmt)) !== null) {
                if (match[2]) {
                    arg_names |= 1
                    var field_list = [], replacement_field = match[2], field_match = []
                    if ((field_match = re.key.exec(replacement_field)) !== null) {
                        field_list.push(field_match[1])
                        while ((replacement_field = replacement_field.substring(field_match[0].length)) !== '') {
                            if ((field_match = re.key_access.exec(replacement_field)) !== null) {
                                field_list.push(field_match[1])
                            }
                            else if ((field_match = re.index_access.exec(replacement_field)) !== null) {
                                field_list.push(field_match[1])
                            }
                            else {
                                throw new SyntaxError('[sprintf] failed to parse named argument key')
                            }
                        }
                    }
                    else {
                        throw new SyntaxError('[sprintf] failed to parse named argument key')
                    }
                    match[2] = field_list
                }
                else {
                    arg_names |= 2
                }
                if (arg_names === 3) {
                    throw new Error('[sprintf] mixing positional and named placeholders is not (yet) supported')
                }

                parse_tree.push(
                    {
                        placeholder: match[0],
                        param_no:    match[1],
                        keys:        match[2],
                        sign:        match[3],
                        pad_char:    match[4],
                        align:       match[5],
                        width:       match[6],
                        precision:   match[7],
                        type:        match[8]
                    }
                )
            }
            else {
                throw new SyntaxError('[sprintf] unexpected placeholder')
            }
            _fmt = _fmt.substring(match[0].length)
        }
        return sprintf_cache[fmt] = parse_tree
    }

    /**
     * export to either browser or node.js
     */
    /* eslint-disable quote-props */
    if (typeof exports !== 'undefined') {
        exports['sprintf'] = sprintf
        exports['vsprintf'] = vsprintf
    }
    if (typeof window !== 'undefined') {
        window['sprintf'] = sprintf
        window['vsprintf'] = vsprintf

        if (typeof define === 'function' && define['amd']) {
            define(function() {
                return {
                    'sprintf': sprintf,
                    'vsprintf': vsprintf
                }
            })
        }
    }
    /* eslint-enable quote-props */
}(); // eslint-disable-line

},{}],15:[function(require,module,exports){
(function (process){
/**
 * Memize options object.
 *
 * @typedef MemizeOptions
 *
 * @property {number} [maxSize] Maximum size of the cache.
 */

/**
 * Internal cache entry.
 *
 * @typedef MemizeCacheNode
 *
 * @property {?MemizeCacheNode|undefined} [prev] Previous node.
 * @property {?MemizeCacheNode|undefined} [next] Next node.
 * @property {Array<*>}                   args   Function arguments for cache
 *                                               entry.
 * @property {*}                          val    Function result.
 */

/**
 * Properties of the enhanced function for controlling cache.
 *
 * @typedef MemizeMemoizedFunction
 *
 * @property {()=>void} clear Clear the cache.
 */

/**
 * Accepts a function to be memoized, and returns a new memoized function, with
 * optional options.
 *
 * @template {Function} F
 *
 * @param {F}             fn        Function to memoize.
 * @param {MemizeOptions} [options] Options object.
 *
 * @return {F & MemizeMemoizedFunction} Memoized function.
 */
function memize( fn, options ) {
	var size = 0;

	/** @type {?MemizeCacheNode|undefined} */
	var head;

	/** @type {?MemizeCacheNode|undefined} */
	var tail;

	options = options || {};

	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.
				/** @type {MemizeCacheNode} */ ( node.prev ).next = node.next;
				if ( node.next ) {
					node.next.prev = node.prev;
				}

				node.next = head;
				node.prev = null;
				/** @type {MemizeCacheNode} */ ( 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 === /** @type {MemizeOptions} */ ( options ).maxSize ) {
			tail = /** @type {MemizeCacheNode} */ ( tail ).prev;
			/** @type {MemizeCacheNode} */ ( tail ).next = null;
		} else {
			size++;
		}

		head = node;

		return node.val;
	}

	memoized.clear = function() {
		head = null;
		tail = null;
		size = 0;
	};

	if ( process.env.NODE_ENV === 'test' ) {
		// Cache is not exposed in the public API, but used in tests to ensure
		// expected list progression
		memoized.getCache = function() {
			return [ head, tail, size ];
		};
	}

	// Ignore reason: There's not a clear solution to create an intersection of
	// the function with additional properties, where the goal is to retain the
	// function signature of the incoming argument and add control properties
	// on the return value.

	// @ts-ignore
	return memoized;
}

module.exports = memize;

}).call(this,require('_process'))
},{"_process":16}],16:[function(require,module,exports){
// shim for using process in browser
var process = module.exports = {};

// cached from whatever global is present so that test runners that stub it
// don't break things.  But we need to wrap it in a try catch in case it is
// wrapped in strict mode code which doesn't define any globals.  It's inside a
// function because try/catches deoptimize in certain engines.

var cachedSetTimeout;
var cachedClearTimeout;

function defaultSetTimout() {
    throw new Error('setTimeout has not been defined');
}
function defaultClearTimeout () {
    throw new Error('clearTimeout has not been defined');
}
(function () {
    try {
        if (typeof setTimeout === 'function') {
            cachedSetTimeout = setTimeout;
        } else {
            cachedSetTimeout = defaultSetTimout;
        }
    } catch (e) {
        cachedSetTimeout = defaultSetTimout;
    }
    try {
        if (typeof clearTimeout === 'function') {
            cachedClearTimeout = clearTimeout;
        } else {
            cachedClearTimeout = defaultClearTimeout;
        }
    } catch (e) {
        cachedClearTimeout = defaultClearTimeout;
    }
} ())
function runTimeout(fun) {
    if (cachedSetTimeout === setTimeout) {
        //normal enviroments in sane situations
        return setTimeout(fun, 0);
    }
    // if setTimeout wasn't available but was latter defined
    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
        cachedSetTimeout = setTimeout;
        return setTimeout(fun, 0);
    }
    try {
        // when when somebody has screwed with setTimeout but no I.E. maddness
        return cachedSetTimeout(fun, 0);
    } catch(e){
        try {
            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
            return cachedSetTimeout.call(null, fun, 0);
        } catch(e){
            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
            return cachedSetTimeout.call(this, fun, 0);
        }
    }


}
function runClearTimeout(marker) {
    if (cachedClearTimeout === clearTimeout) {
        //normal enviroments in sane situations
        return clearTimeout(marker);
    }
    // if clearTimeout wasn't available but was latter defined
    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
        cachedClearTimeout = clearTimeout;
        return clearTimeout(marker);
    }
    try {
        // when when somebody has screwed with setTimeout but no I.E. maddness
        return cachedClearTimeout(marker);
    } catch (e){
        try {
            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
            return cachedClearTimeout.call(null, marker);
        } catch (e){
            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
            return cachedClearTimeout.call(this, marker);
        }
    }



}
var queue = [];
var draining = false;
var currentQueue;
var queueIndex = -1;

function cleanUpNextTick() {
    if (!draining || !currentQueue) {
        return;
    }
    draining = false;
    if (currentQueue.length) {
        queue = currentQueue.concat(queue);
    } else {
        queueIndex = -1;
    }
    if (queue.length) {
        drainQueue();
    }
}

function drainQueue() {
    if (draining) {
        return;
    }
    var timeout = runTimeout(cleanUpNextTick);
    draining = true;

    var len = queue.length;
    while(len) {
        currentQueue = queue;
        queue = [];
        while (++queueIndex < len) {
            if (currentQueue) {
                currentQueue[queueIndex].run();
            }
        }
        queueIndex = -1;
        len = queue.length;
    }
    currentQueue = null;
    draining = false;
    runClearTimeout(timeout);
}

process.nextTick = function (fun) {
    var args = new Array(arguments.length - 1);
    if (arguments.length > 1) {
        for (var i = 1; i < arguments.length; i++) {
            args[i - 1] = arguments[i];
        }
    }
    queue.push(new Item(fun, args));
    if (queue.length === 1 && !draining) {
        runTimeout(drainQueue);
    }
};

// v8 likes predictible objects
function Item(fun, array) {
    this.fun = fun;
    this.array = array;
}
Item.prototype.run = function () {
    this.fun.apply(null, this.array);
};
process.title = 'browser';
process.browser = true;
process.env = {};
process.argv = [];
process.version = ''; // empty string to avoid regexp issues
process.versions = {};

function noop() {}

process.on = noop;
process.addListener = noop;
process.once = noop;
process.off = noop;
process.removeListener = noop;
process.removeAllListeners = noop;
process.emit = noop;
process.prependListener = noop;
process.prependOnceListener = noop;

process.listeners = function (name) { return [] }

process.binding = function (name) {
    throw new Error('process.binding is not supported');
};

process.cwd = function () { return '/' };
process.chdir = function (dir) {
    throw new Error('process.chdir is not supported');
};
process.umask = function() { return 0; };

},{}],17:[function(require,module,exports){
'use strict';

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

var pluralForms = _interopDefault(require('@tannin/plural-forms'));

/**
 * Tannin constructor options.
 *
 * @typedef {Object} TanninOptions
 *
 * @property {string}   [contextDelimiter] Joiner in string lookup with context.
 * @property {Function} [onMissingKey]     Callback to invoke when key missing.
 */

/**
 * Domain metadata.
 *
 * @typedef {Object} TanninDomainMetadata
 *
 * @property {string}            [domain]       Domain name.
 * @property {string}            [lang]         Language code.
 * @property {(string|Function)} [plural_forms] Plural forms expression or
 *                                              function evaluator.
 */

/**
 * Domain translation pair respectively representing the singular and plural
 * translation.
 *
 * @typedef {[string,string]} TanninTranslation
 */

/**
 * Locale data domain. The key is used as reference for lookup, the value an
 * array of two string entries respectively representing the singular and plural
 * translation.
 *
 * @typedef {{[key:string]:TanninDomainMetadata|TanninTranslation,'':TanninDomainMetadata|TanninTranslation}} TanninLocaleDomain
 */

/**
 * Jed-formatted locale data.
 *
 * @see http://messageformat.github.io/Jed/
 *
 * @typedef {{[domain:string]:TanninLocaleDomain}} TanninLocaleData
 */

/**
 * Default Tannin constructor options.
 *
 * @type {TanninOptions}
 */
var DEFAULT_OPTIONS = {
	contextDelimiter: '\u0004',
	onMissingKey: null,
};

/**
 * Given a specific locale data's config `plural_forms` value, returns the
 * expression.
 *
 * @example
 *
 * ```
 * getPluralExpression( 'nplurals=2; plural=(n != 1);' ) === '(n != 1)'
 * ```
 *
 * @param {string} pf Locale data plural forms.
 *
 * @return {string} Plural forms expression.
 */
function getPluralExpression( pf ) {
	var parts, i, part;

	parts = pf.split( ';' );

	for ( i = 0; i < parts.length; i++ ) {
		part = parts[ i ].trim();
		if ( part.indexOf( 'plural=' ) === 0 ) {
			return part.substr( 7 );
		}
	}
}

/**
 * Tannin constructor.
 *
 * @class
 *
 * @param {TanninLocaleData} data      Jed-formatted locale data.
 * @param {TanninOptions}    [options] Tannin options.
 */
function Tannin( data, options ) {
	var key;

	/**
	 * Jed-formatted locale data.
	 *
	 * @name Tannin#data
	 * @type {TanninLocaleData}
	 */
	this.data = data;

	/**
	 * Plural forms function cache, keyed by plural forms string.
	 *
	 * @name Tannin#pluralForms
	 * @type {Object<string,Function>}
	 */
	this.pluralForms = {};

	/**
	 * Effective options for instance, including defaults.
	 *
	 * @name Tannin#options
	 * @type {TanninOptions}
	 */
	this.options = {};

	for ( key in DEFAULT_OPTIONS ) {
		this.options[ key ] = options !== undefined && key in options
			? options[ key ]
			: DEFAULT_OPTIONS[ key ];
	}
}

/**
 * Returns the plural form index for the given domain and value.
 *
 * @param {string} domain Domain on which to calculate plural form.
 * @param {number} n      Value for which plural form is to be calculated.
 *
 * @return {number} Plural form index.
 */
Tannin.prototype.getPluralForm = function( domain, n ) {
	var getPluralForm = this.pluralForms[ domain ],
		config, plural, pf;

	if ( ! getPluralForm ) {
		config = this.data[ domain ][ '' ];

		pf = (
			config[ 'Plural-Forms' ] ||
			config[ 'plural-forms' ] ||
			// Ignore reason: As known, there's no way to document the empty
			// string property on a key to guarantee this as metadata.
			// @ts-ignore
			config.plural_forms
		);

		if ( typeof pf !== 'function' ) {
			plural = getPluralExpression(
				config[ 'Plural-Forms' ] ||
				config[ 'plural-forms' ] ||
				// Ignore reason: As known, there's no way to document the empty
				// string property on a key to guarantee this as metadata.
				// @ts-ignore
				config.plural_forms
			);

			pf = pluralForms( plural );
		}

		getPluralForm = this.pluralForms[ domain ] = pf;
	}

	return getPluralForm( n );
};

/**
 * Translate a string.
 *
 * @param {string}      domain   Translation domain.
 * @param {string|void} context  Context distinguishing terms of the same name.
 * @param {string}      singular Primary key for translation lookup.
 * @param {string=}     plural   Fallback value used for non-zero plural
 *                               form index.
 * @param {number=}     n        Value to use in calculating plural form.
 *
 * @return {string} Translated string.
 */
Tannin.prototype.dcnpgettext = function( domain, context, singular, plural, n ) {
	var index, key, entry;

	if ( n === undefined ) {
		// Default to singular.
		index = 0;
	} else {
		// Find index by evaluating plural form for value.
		index = this.getPluralForm( domain, n );
	}

	key = singular;

	// If provided, context is prepended to key with delimiter.
	if ( context ) {
		key = context + this.options.contextDelimiter + singular;
	}

	entry = this.data[ domain ][ key ];

	// Verify not only that entry exists, but that the intended index is within
	// range and non-empty.
	if ( entry && entry[ index ] ) {
		return entry[ index ];
	}

	if ( this.options.onMissingKey ) {
		this.options.onMissingKey( singular, domain );
	}

	// If entry not found, fall back to singular vs. plural with zero index
	// representing the singular value.
	return index === 0 ? singular : plural;
};

module.exports = Tannin;

},{"@tannin/plural-forms":8}]},{},[2]);