text: /******/ (function() { // webpackBootstrap
  /******/ 	var __webpack_modules__ = ({
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-compatibility.js":
  /*!****************************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-compatibility.js ***!
    \****************************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    /**
     *  acf.newCompatibility
     *
     *  Inserts a new __proto__ object compatibility layer
     *
     *  @date	15/2/18
     *  @since	5.6.9
     *
     *  @param	object instance The object to modify.
     *  @param	object compatibilty Optional. The compatibilty layer.
     *  @return	object compatibilty
     */
    acf.newCompatibility = function (instance, compatibilty) {
      // defaults
      compatibilty = compatibilty || {}; // inherit __proto_-
  
      compatibilty.__proto__ = instance.__proto__; // inject
  
      instance.__proto__ = compatibilty; // reference
  
      instance.compatibility = compatibilty; // return
  
      return compatibilty;
    };
    /**
     *  acf.getCompatibility
     *
     *  Returns the compatibility layer for a given instance
     *
     *  @date	13/3/18
     *  @since	5.6.9
     *
     *  @param	object		instance		The object to look in.
     *  @return	object|null	compatibility	The compatibility object or null on failure.
     */
  
  
    acf.getCompatibility = function (instance) {
      return instance.compatibility || null;
    };
    /**
     *  acf (compatibility)
     *
     *  Compatibility layer for the acf object
     *
     *  @date	15/2/18
     *  @since	5.6.9
     *
     *  @param	void
     *  @return	void
     */
  
  
    var _acf = acf.newCompatibility(acf, {
      // storage
      l10n: {},
      o: {},
      fields: {},
      // changed function names
      update: acf.set,
      add_action: acf.addAction,
      remove_action: acf.removeAction,
      do_action: acf.doAction,
      add_filter: acf.addFilter,
      remove_filter: acf.removeFilter,
      apply_filters: acf.applyFilters,
      parse_args: acf.parseArgs,
      disable_el: acf.disable,
      disable_form: acf.disable,
      enable_el: acf.enable,
      enable_form: acf.enable,
      update_user_setting: acf.updateUserSetting,
      prepare_for_ajax: acf.prepareForAjax,
      is_ajax_success: acf.isAjaxSuccess,
      remove_el: acf.remove,
      remove_tr: acf.remove,
      str_replace: acf.strReplace,
      render_select: acf.renderSelect,
      get_uniqid: acf.uniqid,
      serialize_form: acf.serialize,
      esc_html: acf.strEscape,
      str_sanitize: acf.strSanitize
    });
  
    _acf._e = function (k1, k2) {
      // defaults
      k1 = k1 || '';
      k2 = k2 || ''; // compability
  
      var compatKey = k2 ? k1 + '.' + k2 : k1;
      var compats = {
        'image.select': 'Select Image',
        'image.edit': 'Edit Image',
        'image.update': 'Update Image'
      };
  
      if (compats[compatKey]) {
        return acf.__(compats[compatKey]);
      } // try k1
  
  
      var string = this.l10n[k1] || ''; // try k2
  
      if (k2) {
        string = string[k2] || '';
      } // return
  
  
      return string;
    };
  
    _acf.get_selector = function (s) {
      // vars
      var selector = '.acf-field'; // bail early if no search
  
      if (!s) {
        return selector;
      } // compatibility with object
  
  
      if ($.isPlainObject(s)) {
        if ($.isEmptyObject(s)) {
          return selector;
        } else {
          for (var k in s) {
            s = s[k];
            break;
          }
        }
      } // append
  
  
      selector += '-' + s; // replace underscores (split/join replaces all and is faster than regex!)
  
      selector = acf.strReplace('_', '-', selector); // remove potential double up
  
      selector = acf.strReplace('field-field-', 'field-', selector); // return
  
      return selector;
    };
  
    _acf.get_fields = function (s, $el, all) {
      // args
      var args = {
        is: s || '',
        parent: $el || false,
        suppressFilters: all || false
      }; // change 'field_123' to '.acf-field-123'
  
      if (args.is) {
        args.is = this.get_selector(args.is);
      } // return
  
  
      return acf.findFields(args);
    };
  
    _acf.get_field = function (s, $el) {
      // get fields
      var $fields = this.get_fields.apply(this, arguments); // return
  
      if ($fields.length) {
        return $fields.first();
      } else {
        return false;
      }
    };
  
    _acf.get_closest_field = function ($el, s) {
      return $el.closest(this.get_selector(s));
    };
  
    _acf.get_field_wrap = function ($el) {
      return $el.closest(this.get_selector());
    };
  
    _acf.get_field_key = function ($field) {
      return $field.data('key');
    };
  
    _acf.get_field_type = function ($field) {
      return $field.data('type');
    };
  
    _acf.get_data = function ($el, defaults) {
      return acf.parseArgs($el.data(), defaults);
    };
  
    _acf.maybe_get = function (obj, key, value) {
      // default
      if (value === undefined) {
        value = null;
      } // get keys
  
  
      keys = String(key).split('.'); // acf.isget
  
      for (var i = 0; i < keys.length; i++) {
        if (!obj.hasOwnProperty(keys[i])) {
          return value;
        }
  
        obj = obj[keys[i]];
      }
  
      return obj;
    };
    /**
     *  hooks
     *
     *  Modify add_action and add_filter functions to add compatibility with changed $field parameter
     *  Using the acf.add_action() or acf.add_filter() functions will interpret new field parameters as jQuery $field
     *
     *  @date	12/5/18
     *  @since	5.6.9
     *
     *  @param	void
     *  @return	void
     */
  
  
    var compatibleArgument = function (arg) {
      return arg instanceof acf.Field ? arg.$el : arg;
    };
  
    var compatibleArguments = function (args) {
      return acf.arrayArgs(args).map(compatibleArgument);
    };
  
    var compatibleCallback = function (origCallback) {
      return function () {
        // convert to compatible arguments
        if (arguments.length) {
          var args = compatibleArguments(arguments); // add default argument for 'ready', 'append' and 'load' events
        } else {
          var args = [$(document)];
        } // return
  
  
        return origCallback.apply(this, args);
      };
    };
  
    _acf.add_action = function (action, callback, priority, context) {
      // handle multiple actions
      var actions = action.split(' ');
      var length = actions.length;
  
      if (length > 1) {
        for (var i = 0; i < length; i++) {
          action = actions[i];
  
          _acf.add_action.apply(this, arguments);
        }
  
        return this;
      } // single
  
  
      var callback = compatibleCallback(callback);
      return acf.addAction.apply(this, arguments);
    };
  
    _acf.add_filter = function (action, callback, priority, context) {
      var callback = compatibleCallback(callback);
      return acf.addFilter.apply(this, arguments);
    };
    /*
     *  acf.model
     *
     *  This model acts as a scafold for action.event driven modules
     *
     *  @type	object
     *  @date	8/09/2014
     *  @since	5.0.0
     *
     *  @param	(object)
     *  @return	(object)
     */
  
  
    _acf.model = {
      actions: {},
      filters: {},
      events: {},
      extend: function (args) {
        // extend
        var model = $.extend({}, this, args); // setup actions
  
        $.each(model.actions, function (name, callback) {
          model._add_action(name, callback);
        }); // setup filters
  
        $.each(model.filters, function (name, callback) {
          model._add_filter(name, callback);
        }); // setup events
  
        $.each(model.events, function (name, callback) {
          model._add_event(name, callback);
        }); // return
  
        return model;
      },
      _add_action: function (name, callback) {
        // split
        var model = this,
            data = name.split(' '); // add missing priority
  
        var name = data[0] || '',
            priority = data[1] || 10; // add action
  
        acf.add_action(name, model[callback], priority, model);
      },
      _add_filter: function (name, callback) {
        // split
        var model = this,
            data = name.split(' '); // add missing priority
  
        var name = data[0] || '',
            priority = data[1] || 10; // add action
  
        acf.add_filter(name, model[callback], priority, model);
      },
      _add_event: function (name, callback) {
        // vars
        var model = this,
            i = name.indexOf(' '),
            event = i > 0 ? name.substr(0, i) : name,
            selector = i > 0 ? name.substr(i + 1) : ''; // event
  
        var fn = function (e) {
          // append $el to event object
          e.$el = $(this); // append $field to event object (used in field group)
  
          if (acf.field_group) {
            e.$field = e.$el.closest('.acf-field-object');
          } // event
  
  
          if (typeof model.event === 'function') {
            e = model.event(e);
          } // callback
  
  
          model[callback].apply(model, arguments);
        }; // add event
  
  
        if (selector) {
          $(document).on(event, selector, fn);
        } else {
          $(document).on(event, fn);
        }
      },
      get: function (name, value) {
        // defaults
        value = value || null; // get
  
        if (typeof this[name] !== 'undefined') {
          value = this[name];
        } // return
  
  
        return value;
      },
      set: function (name, value) {
        // set
        this[name] = value; // function for 3rd party
  
        if (typeof this['_set_' + name] === 'function') {
          this['_set_' + name].apply(this);
        } // return for chaining
  
  
        return this;
      }
    };
    /*
     *  field
     *
     *  This model sets up many of the field's interactions
     *
     *  @type	function
     *  @date	21/02/2014
     *  @since	3.5.1
     *
     *  @param	n/a
     *  @return	n/a
     */
  
    _acf.field = acf.model.extend({
      type: '',
      o: {},
      $field: null,
      _add_action: function (name, callback) {
        // vars
        var model = this; // update name
  
        name = name + '_field/type=' + model.type; // add action
  
        acf.add_action(name, function ($field) {
          // focus
          model.set('$field', $field); // callback
  
          model[callback].apply(model, arguments);
        });
      },
      _add_filter: function (name, callback) {
        // vars
        var model = this; // update name
  
        name = name + '_field/type=' + model.type; // add action
  
        acf.add_filter(name, function ($field) {
          // focus
          model.set('$field', $field); // callback
  
          model[callback].apply(model, arguments);
        });
      },
      _add_event: function (name, callback) {
        // vars
        var model = this,
            event = name.substr(0, name.indexOf(' ')),
            selector = name.substr(name.indexOf(' ') + 1),
            context = acf.get_selector(model.type); // add event
  
        $(document).on(event, context + ' ' + selector, function (e) {
          // vars
          var $el = $(this);
          var $field = acf.get_closest_field($el, model.type); // bail early if no field
  
          if (!$field.length) return; // focus
  
          if (!$field.is(model.$field)) {
            model.set('$field', $field);
          } // append to event
  
  
          e.$el = $el;
          e.$field = $field; // callback
  
          model[callback].apply(model, [e]);
        });
      },
      _set_$field: function () {
        // callback
        if (typeof this.focus === 'function') {
          this.focus();
        }
      },
      // depreciated
      doFocus: function ($field) {
        return this.set('$field', $field);
      }
    });
    /**
     *  validation
     *
     *  description
     *
     *  @date	15/2/18
     *  @since	5.6.9
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
  
    var _validation = acf.newCompatibility(acf.validation, {
      remove_error: function ($field) {
        acf.getField($field).removeError();
      },
      add_warning: function ($field, message) {
        acf.getField($field).showNotice({
          text: message,
          type: 'warning',
          timeout: 1000
        });
      },
      fetch: acf.validateForm,
      enableSubmit: acf.enableSubmit,
      disableSubmit: acf.disableSubmit,
      showSpinner: acf.showSpinner,
      hideSpinner: acf.hideSpinner,
      unlockForm: acf.unlockForm,
      lockForm: acf.lockForm
    });
    /**
     *  tooltip
     *
     *  description
     *
     *  @date	15/2/18
     *  @since	5.6.9
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
  
  
    _acf.tooltip = {
      tooltip: function (text, $el) {
        var tooltip = acf.newTooltip({
          text: text,
          target: $el
        }); // return
  
        return tooltip.$el;
      },
      temp: function (text, $el) {
        var tooltip = acf.newTooltip({
          text: text,
          target: $el,
          timeout: 250
        });
      },
      confirm: function ($el, callback, text, button_y, button_n) {
        var tooltip = acf.newTooltip({
          confirm: true,
          text: text,
          target: $el,
          confirm: function () {
            callback(true);
          },
          cancel: function () {
            callback(false);
          }
        });
      },
      confirm_remove: function ($el, callback) {
        var tooltip = acf.newTooltip({
          confirmRemove: true,
          target: $el,
          confirm: function () {
            callback(true);
          },
          cancel: function () {
            callback(false);
          }
        });
      }
    };
    /**
     *  tooltip
     *
     *  description
     *
     *  @date	15/2/18
     *  @since	5.6.9
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
  
    _acf.media = new acf.Model({
      activeFrame: false,
      actions: {
        new_media_popup: 'onNewMediaPopup'
      },
      frame: function () {
        return this.activeFrame;
      },
      onNewMediaPopup: function (popup) {
        this.activeFrame = popup.frame;
      },
      popup: function (props) {
        // update props
        if (props.mime_types) {
          props.allowedTypes = props.mime_types;
        }
  
        if (props.id) {
          props.attachment = props.id;
        } // new
  
  
        var popup = acf.newMediaPopup(props); // append
  
        /*
        if( props.selected ) {
        	popup.selected = props.selected;
        }
        */
        // return
  
        return popup.frame;
      }
    });
    /**
     *  Select2
     *
     *  description
     *
     *  @date	11/6/18
     *  @since	5.6.9
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
  
    _acf.select2 = {
      init: function ($select, args, $field) {
        // compatible args
        if (args.allow_null) {
          args.allowNull = args.allow_null;
        }
  
        if (args.ajax_action) {
          args.ajaxAction = args.ajax_action;
        }
  
        if ($field) {
          args.field = acf.getField($field);
        } // return
  
  
        return acf.newSelect2($select, args);
      },
      destroy: function ($select) {
        return acf.getInstance($select).destroy();
      }
    };
    /**
     *  postbox
     *
     *  description
     *
     *  @date	11/6/18
     *  @since	5.6.9
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
  
    _acf.postbox = {
      render: function (args) {
        // compatible args
        if (args.edit_url) {
          args.editLink = args.edit_url;
        }
  
        if (args.edit_title) {
          args.editTitle = args.edit_title;
        } // return
  
  
        return acf.newPostbox(args);
      }
    };
    /**
     *  acf.screen
     *
     *  description
     *
     *  @date	11/6/18
     *  @since	5.6.9
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
  
    acf.newCompatibility(acf.screen, {
      update: function () {
        return this.set.apply(this, arguments);
      },
      fetch: acf.screen.check
    });
    _acf.ajax = acf.screen;
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-condition-types.js":
  /*!******************************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-condition-types.js ***!
    \******************************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    var __ = acf.__;
  
    var parseString = function (val) {
      return val ? '' + val : '';
    };
  
    var isEqualTo = function (v1, v2) {
      return parseString(v1).toLowerCase() === parseString(v2).toLowerCase();
    };
  
    var isEqualToNumber = function (v1, v2) {
      return parseFloat(v1) === parseFloat(v2);
    };
  
    var isGreaterThan = function (v1, v2) {
      return parseFloat(v1) > parseFloat(v2);
    };
  
    var isLessThan = function (v1, v2) {
      return parseFloat(v1) < parseFloat(v2);
    };
  
    var inArray = function (v1, array) {
      // cast all values as string
      array = array.map(function (v2) {
        return parseString(v2);
      });
      return array.indexOf(v1) > -1;
    };
  
    var containsString = function (haystack, needle) {
      return parseString(haystack).indexOf(parseString(needle)) > -1;
    };
  
    var matchesPattern = function (v1, pattern) {
      var regexp = new RegExp(parseString(pattern), 'gi');
      return parseString(v1).match(regexp);
    };
    /**
     *  hasValue
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	void
     *  @return	void
     */
  
  
    var HasValue = acf.Condition.extend({
      type: 'hasValue',
      operator: '!=empty',
      label: __('Has any value'),
      fieldTypes: ['text', 'textarea', 'number', 'range', 'email', 'url', 'password', 'image', 'file', 'wysiwyg', 'oembed', 'select', 'checkbox', 'radio', 'button_group', 'link', 'post_object', 'page_link', 'relationship', 'taxonomy', 'user', 'google_map', 'date_picker', 'date_time_picker', 'time_picker', 'color_picker'],
      match: function (rule, field) {
        let val = field.val();
  
        if (val instanceof Array) {
          val = val.length;
        }
  
        return val ? true : false;
      },
      choices: function (fieldObject) {
        return '<input type="text" disabled="" />';
      }
    });
    acf.registerConditionType(HasValue);
    /**
     *  hasValue
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	void
     *  @return	void
     */
  
    var HasNoValue = HasValue.extend({
      type: 'hasNoValue',
      operator: '==empty',
      label: __('Has no value'),
      match: function (rule, field) {
        return !HasValue.prototype.match.apply(this, arguments);
      }
    });
    acf.registerConditionType(HasNoValue);
    /**
     *  EqualTo
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	void
     *  @return	void
     */
  
    var EqualTo = acf.Condition.extend({
      type: 'equalTo',
      operator: '==',
      label: __('Value is equal to'),
      fieldTypes: ['text', 'textarea', 'number', 'range', 'email', 'url', 'password'],
      match: function (rule, field) {
        if (acf.isNumeric(rule.value)) {
          return isEqualToNumber(rule.value, field.val());
        } else {
          return isEqualTo(rule.value, field.val());
        }
      },
      choices: function (fieldObject) {
        return '<input type="text" />';
      }
    });
    acf.registerConditionType(EqualTo);
    /**
     *  NotEqualTo
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	void
     *  @return	void
     */
  
    var NotEqualTo = EqualTo.extend({
      type: 'notEqualTo',
      operator: '!=',
      label: __('Value is not equal to'),
      match: function (rule, field) {
        return !EqualTo.prototype.match.apply(this, arguments);
      }
    });
    acf.registerConditionType(NotEqualTo);
    /**
     *  PatternMatch
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	void
     *  @return	void
     */
  
    var PatternMatch = acf.Condition.extend({
      type: 'patternMatch',
      operator: '==pattern',
      label: __('Value matches pattern'),
      fieldTypes: ['text', 'textarea', 'email', 'url', 'password', 'wysiwyg'],
      match: function (rule, field) {
        return matchesPattern(field.val(), rule.value);
      },
      choices: function (fieldObject) {
        return '<input type="text" placeholder="[a-z0-9]" />';
      }
    });
    acf.registerConditionType(PatternMatch);
    /**
     *  Contains
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	void
     *  @return	void
     */
  
    var Contains = acf.Condition.extend({
      type: 'contains',
      operator: '==contains',
      label: __('Value contains'),
      fieldTypes: ['text', 'textarea', 'number', 'email', 'url', 'password', 'wysiwyg', 'oembed', 'select'],
      match: function (rule, field) {
        return containsString(field.val(), rule.value);
      },
      choices: function (fieldObject) {
        return '<input type="text" />';
      }
    });
    acf.registerConditionType(Contains);
    /**
     *  TrueFalseEqualTo
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	void
     *  @return	void
     */
  
    var TrueFalseEqualTo = EqualTo.extend({
      type: 'trueFalseEqualTo',
      choiceType: 'select',
      fieldTypes: ['true_false'],
      choices: function (field) {
        return [{
          id: 1,
          text: __('Checked')
        }];
      }
    });
    acf.registerConditionType(TrueFalseEqualTo);
    /**
     *  TrueFalseNotEqualTo
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	void
     *  @return	void
     */
  
    var TrueFalseNotEqualTo = NotEqualTo.extend({
      type: 'trueFalseNotEqualTo',
      choiceType: 'select',
      fieldTypes: ['true_false'],
      choices: function (field) {
        return [{
          id: 1,
          text: __('Checked')
        }];
      }
    });
    acf.registerConditionType(TrueFalseNotEqualTo);
    /**
     *  SelectEqualTo
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	void
     *  @return	void
     */
  
    var SelectEqualTo = acf.Condition.extend({
      type: 'selectEqualTo',
      operator: '==',
      label: __('Value is equal to'),
      fieldTypes: ['select', 'checkbox', 'radio', 'button_group'],
      match: function (rule, field) {
        var val = field.val();
  
        if (val instanceof Array) {
          return inArray(rule.value, val);
        } else {
          return isEqualTo(rule.value, val);
        }
      },
      choices: function (fieldObject) {
        // vars
        var choices = [];
        var lines = fieldObject.$setting('choices textarea').val().split('\n'); // allow null
  
        if (fieldObject.$input('allow_null').prop('checked')) {
          choices.push({
            id: '',
            text: __('Null')
          });
        } // loop
  
  
        lines.map(function (line) {
          // split
          line = line.split(':'); // default label to value
  
          line[1] = line[1] || line[0]; // append
  
          choices.push({
            id: line[0].trim(),
            text: line[1].trim()
          });
        }); // return
  
        return choices;
      }
    });
    acf.registerConditionType(SelectEqualTo);
    /**
     *  SelectNotEqualTo
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	void
     *  @return	void
     */
  
    var SelectNotEqualTo = SelectEqualTo.extend({
      type: 'selectNotEqualTo',
      operator: '!=',
      label: __('Value is not equal to'),
      match: function (rule, field) {
        return !SelectEqualTo.prototype.match.apply(this, arguments);
      }
    });
    acf.registerConditionType(SelectNotEqualTo);
    /**
     *  GreaterThan
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	void
     *  @return	void
     */
  
    var GreaterThan = acf.Condition.extend({
      type: 'greaterThan',
      operator: '>',
      label: __('Value is greater than'),
      fieldTypes: ['number', 'range'],
      match: function (rule, field) {
        var val = field.val();
  
        if (val instanceof Array) {
          val = val.length;
        }
  
        return isGreaterThan(val, rule.value);
      },
      choices: function (fieldObject) {
        return '<input type="number" />';
      }
    });
    acf.registerConditionType(GreaterThan);
    /**
     *  LessThan
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	void
     *  @return	void
     */
  
    var LessThan = GreaterThan.extend({
      type: 'lessThan',
      operator: '<',
      label: __('Value is less than'),
      match: function (rule, field) {
        var val = field.val();
  
        if (val instanceof Array) {
          val = val.length;
        }
  
        if (val === undefined || val === null || val === false) {
          return true;
        }
  
        return isLessThan(val, rule.value);
      },
      choices: function (fieldObject) {
        return '<input type="number" />';
      }
    });
    acf.registerConditionType(LessThan);
    /**
     *  SelectedGreaterThan
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	void
     *  @return	void
     */
  
    var SelectionGreaterThan = GreaterThan.extend({
      type: 'selectionGreaterThan',
      label: __('Selection is greater than'),
      fieldTypes: ['checkbox', 'select', 'post_object', 'page_link', 'relationship', 'taxonomy', 'user']
    });
    acf.registerConditionType(SelectionGreaterThan);
    /**
     *  SelectedGreaterThan
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	void
     *  @return	void
     */
  
    var SelectionLessThan = LessThan.extend({
      type: 'selectionLessThan',
      label: __('Selection is less than'),
      fieldTypes: ['checkbox', 'select', 'post_object', 'page_link', 'relationship', 'taxonomy', 'user']
    });
    acf.registerConditionType(SelectionLessThan);
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-condition.js":
  /*!************************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-condition.js ***!
    \************************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    // vars
    var storage = [];
    /**
     *  acf.Condition
     *
     *  description
     *
     *  @date	23/3/18
     *  @since	5.6.9
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
  
    acf.Condition = acf.Model.extend({
      type: '',
      // used for model name
      operator: '==',
      // rule operator
      label: '',
      // label shown when editing fields
      choiceType: 'input',
      // input, select
      fieldTypes: [],
      // auto connect this conditions with these field types
      data: {
        conditions: false,
        // the parent instance
        field: false,
        // the field which we query against
        rule: {} // the rule [field, operator, value]
  
      },
      events: {
        change: 'change',
        keyup: 'change',
        enableField: 'change',
        disableField: 'change'
      },
      setup: function (props) {
        $.extend(this.data, props);
      },
      getEventTarget: function ($el, event) {
        return $el || this.get('field').$el;
      },
      change: function (e, $el) {
        this.get('conditions').change(e);
      },
      match: function (rule, field) {
        return false;
      },
      calculate: function () {
        return this.match(this.get('rule'), this.get('field'));
      },
      choices: function (field) {
        return '<input type="text" />';
      }
    });
    /**
     *  acf.newCondition
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
  
    acf.newCondition = function (rule, conditions) {
      // currently setting up conditions for fieldX, this field is the 'target'
      var target = conditions.get('field'); // use the 'target' to find the 'trigger' field.
      // - this field is used to setup the conditional logic events
  
      var field = target.getField(rule.field); // bail ealry if no target or no field (possible if field doesn't exist due to HTML error)
  
      if (!target || !field) {
        return false;
      } // vars
  
  
      var args = {
        rule: rule,
        target: target,
        conditions: conditions,
        field: field
      }; // vars
  
      var fieldType = field.get('type');
      var operator = rule.operator; // get avaibale conditions
  
      var conditionTypes = acf.getConditionTypes({
        fieldType: fieldType,
        operator: operator
      }); // instantiate
  
      var model = conditionTypes[0] || acf.Condition; // instantiate
  
      var condition = new model(args); // return
  
      return condition;
    };
    /**
     *  mid
     *
     *  Calculates the model ID for a field type
     *
     *  @date	15/12/17
     *  @since	5.6.5
     *
     *  @param	string type
     *  @return	string
     */
  
  
    var modelId = function (type) {
      return acf.strPascalCase(type || '') + 'Condition';
    };
    /**
     *  acf.registerConditionType
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
  
  
    acf.registerConditionType = function (model) {
      // vars
      var proto = model.prototype;
      var type = proto.type;
      var mid = modelId(type); // store model
  
      acf.models[mid] = model; // store reference
  
      storage.push(type);
    };
    /**
     *  acf.getConditionType
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
  
  
    acf.getConditionType = function (type) {
      var mid = modelId(type);
      return acf.models[mid] || false;
    };
    /**
     *  acf.registerConditionForFieldType
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
  
  
    acf.registerConditionForFieldType = function (conditionType, fieldType) {
      // get model
      var model = acf.getConditionType(conditionType); // append
  
      if (model) {
        model.prototype.fieldTypes.push(fieldType);
      }
    };
    /**
     *  acf.getConditionTypes
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
  
  
    acf.getConditionTypes = function (args) {
      // defaults
      args = acf.parseArgs(args, {
        fieldType: '',
        operator: ''
      }); // clonse available types
  
      var types = []; // loop
  
      storage.map(function (type) {
        // vars
        var model = acf.getConditionType(type);
        var ProtoFieldTypes = model.prototype.fieldTypes;
        var ProtoOperator = model.prototype.operator; // check fieldType
  
        if (args.fieldType && ProtoFieldTypes.indexOf(args.fieldType) === -1) {
          return;
        } // check operator
  
  
        if (args.operator && ProtoOperator !== args.operator) {
          return;
        } // append
  
  
        types.push(model);
      }); // return
  
      return types;
    };
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-conditions.js":
  /*!*************************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-conditions.js ***!
    \*************************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    // vars
    var CONTEXT = 'conditional_logic';
    /**
     *  conditionsManager
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
  
    var conditionsManager = new acf.Model({
      id: 'conditionsManager',
      priority: 20,
      // run actions later
      actions: {
        new_field: 'onNewField'
      },
      onNewField: function (field) {
        if (field.has('conditions')) {
          field.getConditions().render();
        }
      }
    });
    /**
     *  acf.Field.prototype.getField
     *
     *  Finds a field that is related to another field
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
  
    var getSiblingField = function (field, key) {
      // find sibling (very fast)
      var fields = acf.getFields({
        key: key,
        sibling: field.$el,
        suppressFilters: true
      }); // find sibling-children (fast)
      // needed for group fields, accordions, etc
  
      if (!fields.length) {
        fields = acf.getFields({
          key: key,
          parent: field.$el.parent(),
          suppressFilters: true
        });
      } // return
  
  
      if (fields.length) {
        return fields[0];
      }
  
      return false;
    };
  
    acf.Field.prototype.getField = function (key) {
      // get sibling field
      var field = getSiblingField(this, key); // return early
  
      if (field) {
        return field;
      } // move up through each parent and try again
  
  
      var parents = this.parents();
  
      for (var i = 0; i < parents.length; i++) {
        // get sibling field
        field = getSiblingField(parents[i], key); // return early
  
        if (field) {
          return field;
        }
      } // return
  
  
      return false;
    };
    /**
     *  acf.Field.prototype.getConditions
     *
     *  Returns the field's conditions instance
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
  
  
    acf.Field.prototype.getConditions = function () {
      // instantiate
      if (!this.conditions) {
        this.conditions = new Conditions(this);
      } // return
  
  
      return this.conditions;
    };
    /**
     *  Conditions
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
  
  
    var timeout = false;
    var Conditions = acf.Model.extend({
      id: 'Conditions',
      data: {
        field: false,
        // The field with "data-conditions" (target).
        timeStamp: false,
        // Reference used during "change" event.
        groups: [] // The groups of condition instances.
  
      },
      setup: function (field) {
        // data
        this.data.field = field; // vars
  
        var conditions = field.get('conditions'); // detect groups
  
        if (conditions instanceof Array) {
          // detect groups
          if (conditions[0] instanceof Array) {
            // loop
            conditions.map(function (rules, i) {
              this.addRules(rules, i);
            }, this); // detect rules
          } else {
            this.addRules(conditions);
          } // detect rule
  
        } else {
          this.addRule(conditions);
        }
      },
      change: function (e) {
        // this function may be triggered multiple times per event due to multiple condition classes
        // compare timestamp to allow only 1 trigger per event
        if (this.get('timeStamp') === e.timeStamp) {
          return false;
        } else {
          this.set('timeStamp', e.timeStamp, true);
        } // render condition and store result
  
  
        var changed = this.render();
      },
      render: function () {
        return this.calculate() ? this.show() : this.hide();
      },
      show: function () {
        return this.get('field').showEnable(this.cid, CONTEXT);
      },
      hide: function () {
        return this.get('field').hideDisable(this.cid, CONTEXT);
      },
      calculate: function () {
        // vars
        var pass = false; // loop
  
        this.getGroups().map(function (group) {
          // igrnore this group if another group passed
          if (pass) return; // find passed
  
          var passed = group.filter(function (condition) {
            return condition.calculate();
          }); // if all conditions passed, update the global var
  
          if (passed.length == group.length) {
            pass = true;
          }
        });
        return pass;
      },
      hasGroups: function () {
        return this.data.groups != null;
      },
      getGroups: function () {
        return this.data.groups;
      },
      addGroup: function () {
        var group = [];
        this.data.groups.push(group);
        return group;
      },
      hasGroup: function (i) {
        return this.data.groups[i] != null;
      },
      getGroup: function (i) {
        return this.data.groups[i];
      },
      removeGroup: function (i) {
        this.data.groups[i].delete;
        return this;
      },
      addRules: function (rules, group) {
        rules.map(function (rule) {
          this.addRule(rule, group);
        }, this);
      },
      addRule: function (rule, group) {
        // defaults
        group = group || 0; // vars
  
        var groupArray; // get group
  
        if (this.hasGroup(group)) {
          groupArray = this.getGroup(group);
        } else {
          groupArray = this.addGroup();
        } // instantiate
  
  
        var condition = acf.newCondition(rule, this); // bail ealry if condition failed (field did not exist)
  
        if (!condition) {
          return false;
        } // add rule
  
  
        groupArray.push(condition);
      },
      hasRule: function () {},
      getRule: function (rule, group) {
        // defaults
        rule = rule || 0;
        group = group || 0;
        return this.data.groups[group][rule];
      },
      removeRule: function () {}
    });
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-accordion.js":
  /*!******************************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-field-accordion.js ***!
    \******************************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    var i = 0;
    var Field = acf.Field.extend({
      type: 'accordion',
      wait: '',
      $control: function () {
        return this.$('.acf-fields:first');
      },
      initialize: function () {
        // Bail early if this is a duplicate of an existing initialized accordion.
        if (this.$el.hasClass('acf-accordion')) {
          return;
        } // bail early if is cell
  
  
        if (this.$el.is('td')) return; // enpoint
  
        if (this.get('endpoint')) {
          return this.remove();
        } // vars
  
  
        var $field = this.$el;
        var $label = this.$labelWrap();
        var $input = this.$inputWrap();
        var $wrap = this.$control();
        var $instructions = $input.children('.description'); // force description into label
  
        if ($instructions.length) {
          $label.append($instructions);
        } // table
  
  
        if (this.$el.is('tr')) {
          // vars
          var $table = this.$el.closest('table');
          var $newLabel = $('<div class="acf-accordion-title"/>');
          var $newInput = $('<div class="acf-accordion-content"/>');
          var $newTable = $('<table class="' + $table.attr('class') + '"/>');
          var $newWrap = $('<tbody/>'); // dom
  
          $newLabel.append($label.html());
          $newTable.append($newWrap);
          $newInput.append($newTable);
          $input.append($newLabel);
          $input.append($newInput); // modify
  
          $label.remove();
          $wrap.remove();
          $input.attr('colspan', 2); // update vars
  
          $label = $newLabel;
          $input = $newInput;
          $wrap = $newWrap;
        } // add classes
  
  
        $field.addClass('acf-accordion');
        $label.addClass('acf-accordion-title');
        $input.addClass('acf-accordion-content'); // index
  
        i++; // multi-expand
  
        if (this.get('multi_expand')) {
          $field.attr('multi-expand', 1);
        } // open
  
  
        var order = acf.getPreference('this.accordions') || [];
  
        if (order[i - 1] !== undefined) {
          this.set('open', order[i - 1]);
        }
  
        if (this.get('open')) {
          $field.addClass('-open');
          $input.css('display', 'block'); // needed for accordion to close smoothly
        } // add icon
  
  
        $label.prepend(accordionManager.iconHtml({
          open: this.get('open')
        })); // classes
        // - remove 'inside' which is a #poststuff WP class
  
        var $parent = $field.parent();
        $wrap.addClass($parent.hasClass('-left') ? '-left' : '');
        $wrap.addClass($parent.hasClass('-clear') ? '-clear' : ''); // append
  
        $wrap.append($field.nextUntil('.acf-field-accordion', '.acf-field')); // clean up
  
        $wrap.removeAttr('data-open data-multi_expand data-endpoint');
      }
    });
    acf.registerFieldType(Field);
    /**
     *  accordionManager
     *
     *  Events manager for the acf accordion
     *
     *  @date	14/2/18
     *  @since	5.6.9
     *
     *  @param	void
     *  @return	void
     */
  
    var accordionManager = new acf.Model({
      actions: {
        unload: 'onUnload'
      },
      events: {
        'click .acf-accordion-title': 'onClick',
        'invalidField .acf-accordion': 'onInvalidField'
      },
      isOpen: function ($el) {
        return $el.hasClass('-open');
      },
      toggle: function ($el) {
        if (this.isOpen($el)) {
          this.close($el);
        } else {
          this.open($el);
        }
      },
      iconHtml: function (props) {
        // Use SVG inside Gutenberg editor.
        if (acf.isGutenberg()) {
          if (props.open) {
            return '<svg class="acf-accordion-icon" width="24px" height="24px" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg" role="img" aria-hidden="true" focusable="false"><g><path fill="none" d="M0,0h24v24H0V0z"></path></g><g><path d="M12,8l-6,6l1.41,1.41L12,10.83l4.59,4.58L18,14L12,8z"></path></g></svg>';
          } else {
            return '<svg class="acf-accordion-icon" width="24px" height="24px" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg" role="img" aria-hidden="true" focusable="false"><g><path fill="none" d="M0,0h24v24H0V0z"></path></g><g><path d="M7.41,8.59L12,13.17l4.59-4.58L18,10l-6,6l-6-6L7.41,8.59z"></path></g></svg>';
          }
        } else {
          if (props.open) {
            return '<i class="acf-accordion-icon dashicons dashicons-arrow-down"></i>';
          } else {
            return '<i class="acf-accordion-icon dashicons dashicons-arrow-right"></i>';
          }
        }
      },
      open: function ($el) {
        var duration = acf.isGutenberg() ? 0 : 300; // open
  
        $el.find('.acf-accordion-content:first').slideDown(duration).css('display', 'block');
        $el.find('.acf-accordion-icon:first').replaceWith(this.iconHtml({
          open: true
        }));
        $el.addClass('-open'); // action
  
        acf.doAction('show', $el); // close siblings
  
        if (!$el.attr('multi-expand')) {
          $el.siblings('.acf-accordion.-open').each(function () {
            accordionManager.close($(this));
          });
        }
      },
      close: function ($el) {
        var duration = acf.isGutenberg() ? 0 : 300; // close
  
        $el.find('.acf-accordion-content:first').slideUp(duration);
        $el.find('.acf-accordion-icon:first').replaceWith(this.iconHtml({
          open: false
        }));
        $el.removeClass('-open'); // action
  
        acf.doAction('hide', $el);
      },
      onClick: function (e, $el) {
        // prevent Defailt
        e.preventDefault(); // open close
  
        this.toggle($el.parent());
      },
      onInvalidField: function (e, $el) {
        // bail early if already focused
        if (this.busy) {
          return;
        } // disable functionality for 1sec (allow next validation to work)
  
  
        this.busy = true;
        this.setTimeout(function () {
          this.busy = false;
        }, 1000); // open accordion
  
        this.open($el);
      },
      onUnload: function (e) {
        // vars
        var order = []; // loop
  
        $('.acf-accordion').each(function () {
          var open = $(this).hasClass('-open') ? 1 : 0;
          order.push(open);
        }); // set
  
        if (order.length) {
          acf.setPreference('this.accordions', order);
        }
      }
    });
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-button-group.js":
  /*!*********************************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-field-button-group.js ***!
    \*********************************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    var Field = acf.Field.extend({
      type: 'button_group',
      events: {
        'click input[type="radio"]': 'onClick'
      },
      $control: function () {
        return this.$('.acf-button-group');
      },
      $input: function () {
        return this.$('input:checked');
      },
      setValue: function (val) {
        this.$('input[value="' + val + '"]').prop('checked', true).trigger('change');
      },
      onClick: function (e, $el) {
        // vars
        var $label = $el.parent('label');
        var selected = $label.hasClass('selected'); // remove previous selected
  
        this.$('.selected').removeClass('selected'); // add active class
  
        $label.addClass('selected'); // allow null
  
        if (this.get('allow_null') && selected) {
          $label.removeClass('selected');
          $el.prop('checked', false).trigger('change');
        }
      }
    });
    acf.registerFieldType(Field);
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-checkbox.js":
  /*!*****************************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-field-checkbox.js ***!
    \*****************************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    var Field = acf.Field.extend({
      type: 'checkbox',
      events: {
        'change input': 'onChange',
        'click .acf-add-checkbox': 'onClickAdd',
        'click .acf-checkbox-toggle': 'onClickToggle',
        'click .acf-checkbox-custom': 'onClickCustom'
      },
      $control: function () {
        return this.$('.acf-checkbox-list');
      },
      $toggle: function () {
        return this.$('.acf-checkbox-toggle');
      },
      $input: function () {
        return this.$('input[type="hidden"]');
      },
      $inputs: function () {
        return this.$('input[type="checkbox"]').not('.acf-checkbox-toggle');
      },
      getValue: function () {
        var val = [];
        this.$(':checked').each(function () {
          val.push($(this).val());
        });
        return val.length ? val : false;
      },
      onChange: function (e, $el) {
        // Vars.
        var checked = $el.prop('checked');
        var $label = $el.parent('label');
        var $toggle = this.$toggle(); // Add or remove "selected" class.
  
        if (checked) {
          $label.addClass('selected');
        } else {
          $label.removeClass('selected');
        } // Update toggle state if all inputs are checked.
  
  
        if ($toggle.length) {
          var $inputs = this.$inputs(); // all checked
  
          if ($inputs.not(':checked').length == 0) {
            $toggle.prop('checked', true);
          } else {
            $toggle.prop('checked', false);
          }
        }
      },
      onClickAdd: function (e, $el) {
        var html = '<li><input class="acf-checkbox-custom" type="checkbox" checked="checked" /><input type="text" name="' + this.getInputName() + '[]" /></li>';
        $el.parent('li').before(html);
      },
      onClickToggle: function (e, $el) {
        // Vars.
        var checked = $el.prop('checked');
        var $inputs = this.$('input[type="checkbox"]');
        var $labels = this.$('label'); // Update "checked" state.
  
        $inputs.prop('checked', checked); // Add or remove "selected" class.
  
        if (checked) {
          $labels.addClass('selected');
        } else {
          $labels.removeClass('selected');
        }
      },
      onClickCustom: function (e, $el) {
        var checked = $el.prop('checked');
        var $text = $el.next('input[type="text"]'); // checked
  
        if (checked) {
          $text.prop('disabled', false); // not checked
        } else {
          $text.prop('disabled', true); // remove
  
          if ($text.val() == '') {
            $el.parent('li').remove();
          }
        }
      }
    });
    acf.registerFieldType(Field);
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-color-picker.js":
  /*!*********************************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-field-color-picker.js ***!
    \*********************************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    var Field = acf.Field.extend({
      type: 'color_picker',
      wait: 'load',
      events: {
        duplicateField: 'onDuplicate'
      },
      $control: function () {
        return this.$('.acf-color-picker');
      },
      $input: function () {
        return this.$('input[type="hidden"]');
      },
      $inputText: function () {
        return this.$('input[type="text"]');
      },
      setValue: function (val) {
        // update input (with change)
        acf.val(this.$input(), val); // update iris
  
        this.$inputText().iris('color', val);
      },
      initialize: function () {
        // vars
        var $input = this.$input();
        var $inputText = this.$inputText(); // event
  
        var onChange = function (e) {
          // timeout is required to ensure the $input val is correct
          setTimeout(function () {
            acf.val($input, $inputText.val());
          }, 1);
        }; // args
  
  
        var args = {
          defaultColor: false,
          palettes: true,
          hide: true,
          change: onChange,
          clear: onChange
        }; // filter
  
        var args = acf.applyFilters('color_picker_args', args, this); // initialize
  
        $inputText.wpColorPicker(args);
      },
      onDuplicate: function (e, $el, $duplicate) {
        // The wpColorPicker library does not provide a destroy method.
        // Manually reset DOM by replacing elements back to their original state.
        $colorPicker = $duplicate.find('.wp-picker-container');
        $inputText = $duplicate.find('input[type="text"]');
        $colorPicker.replaceWith($inputText);
      }
    });
    acf.registerFieldType(Field);
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-date-picker.js":
  /*!********************************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-field-date-picker.js ***!
    \********************************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    var Field = acf.Field.extend({
      type: 'date_picker',
      events: {
        'blur input[type="text"]': 'onBlur',
        duplicateField: 'onDuplicate'
      },
      $control: function () {
        return this.$('.acf-date-picker');
      },
      $input: function () {
        return this.$('input[type="hidden"]');
      },
      $inputText: function () {
        return this.$('input[type="text"]');
      },
      initialize: function () {
        // save_format: compatibility with ACF < 5.0.0
        if (this.has('save_format')) {
          return this.initializeCompatibility();
        } // vars
  
  
        var $input = this.$input();
        var $inputText = this.$inputText(); // args
  
        var args = {
          dateFormat: this.get('date_format'),
          altField: $input,
          altFormat: 'yymmdd',
          changeYear: true,
          yearRange: '-100:+100',
          changeMonth: true,
          showButtonPanel: true,
          firstDay: this.get('first_day')
        }; // filter
  
        args = acf.applyFilters('date_picker_args', args, this); // add date picker
  
        acf.newDatePicker($inputText, args); // action
  
        acf.doAction('date_picker_init', $inputText, args, this);
      },
      initializeCompatibility: function () {
        // vars
        var $input = this.$input();
        var $inputText = this.$inputText(); // get and set value from alt field
  
        $inputText.val($input.val()); // args
  
        var args = {
          dateFormat: this.get('date_format'),
          altField: $input,
          altFormat: this.get('save_format'),
          changeYear: true,
          yearRange: '-100:+100',
          changeMonth: true,
          showButtonPanel: true,
          firstDay: this.get('first_day')
        }; // filter for 3rd party customization
  
        args = acf.applyFilters('date_picker_args', args, this); // backup
  
        var dateFormat = args.dateFormat; // change args.dateFormat
  
        args.dateFormat = this.get('save_format'); // add date picker
  
        acf.newDatePicker($inputText, args); // now change the format back to how it should be.
  
        $inputText.datepicker('option', 'dateFormat', dateFormat); // action for 3rd party customization
  
        acf.doAction('date_picker_init', $inputText, args, this);
      },
      onBlur: function () {
        if (!this.$inputText().val()) {
          acf.val(this.$input(), '');
        }
      },
      onDuplicate: function (e, $el, $duplicate) {
        $duplicate.find('input[type="text"]').removeClass('hasDatepicker').removeAttr('id');
      }
    });
    acf.registerFieldType(Field); // manager
  
    var datePickerManager = new acf.Model({
      priority: 5,
      wait: 'ready',
      initialize: function () {
        // vars
        var locale = acf.get('locale');
        var rtl = acf.get('rtl');
        var l10n = acf.get('datePickerL10n'); // bail ealry if no l10n
  
        if (!l10n) {
          return false;
        } // bail ealry if no datepicker library
  
  
        if (typeof $.datepicker === 'undefined') {
          return false;
        } // rtl
  
  
        l10n.isRTL = rtl; // append
  
        $.datepicker.regional[locale] = l10n;
        $.datepicker.setDefaults(l10n);
      }
    }); // add
  
    acf.newDatePicker = function ($input, args) {
      // bail ealry if no datepicker library
      if (typeof $.datepicker === 'undefined') {
        return false;
      } // defaults
  
  
      args = args || {}; // initialize
  
      $input.datepicker(args); // wrap the datepicker (only if it hasn't already been wrapped)
  
      if ($('body > #ui-datepicker-div').exists()) {
        $('body > #ui-datepicker-div').wrap('<div class="acf-ui-datepicker" />');
      }
    };
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-date-time-picker.js":
  /*!*************************************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-field-date-time-picker.js ***!
    \*************************************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    var Field = acf.models.DatePickerField.extend({
      type: 'date_time_picker',
      $control: function () {
        return this.$('.acf-date-time-picker');
      },
      initialize: function () {
        // vars
        var $input = this.$input();
        var $inputText = this.$inputText(); // args
  
        var args = {
          dateFormat: this.get('date_format'),
          timeFormat: this.get('time_format'),
          altField: $input,
          altFieldTimeOnly: false,
          altFormat: 'yy-mm-dd',
          altTimeFormat: 'HH:mm:ss',
          changeYear: true,
          yearRange: '-100:+100',
          changeMonth: true,
          showButtonPanel: true,
          firstDay: this.get('first_day'),
          controlType: 'select',
          oneLine: true
        }; // filter
  
        args = acf.applyFilters('date_time_picker_args', args, this); // add date time picker
  
        acf.newDateTimePicker($inputText, args); // action
  
        acf.doAction('date_time_picker_init', $inputText, args, this);
      }
    });
    acf.registerFieldType(Field); // manager
  
    var dateTimePickerManager = new acf.Model({
      priority: 5,
      wait: 'ready',
      initialize: function () {
        // vars
        var locale = acf.get('locale');
        var rtl = acf.get('rtl');
        var l10n = acf.get('dateTimePickerL10n'); // bail ealry if no l10n
  
        if (!l10n) {
          return false;
        } // bail ealry if no datepicker library
  
  
        if (typeof $.timepicker === 'undefined') {
          return false;
        } // rtl
  
  
        l10n.isRTL = rtl; // append
  
        $.timepicker.regional[locale] = l10n;
        $.timepicker.setDefaults(l10n);
      }
    }); // add
  
    acf.newDateTimePicker = function ($input, args) {
      // bail ealry if no datepicker library
      if (typeof $.timepicker === 'undefined') {
        return false;
      } // defaults
  
  
      args = args || {}; // initialize
  
      $input.datetimepicker(args); // wrap the datepicker (only if it hasn't already been wrapped)
  
      if ($('body > #ui-datepicker-div').exists()) {
        $('body > #ui-datepicker-div').wrap('<div class="acf-ui-datepicker" />');
      }
    };
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-file.js":
  /*!*************************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-field-file.js ***!
    \*************************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    var Field = acf.models.ImageField.extend({
      type: 'file',
      $control: function () {
        return this.$('.acf-file-uploader');
      },
      $input: function () {
        return this.$('input[type="hidden"]');
      },
      validateAttachment: function (attachment) {
        // defaults
        attachment = attachment || {}; // WP attachment
  
        if (attachment.id !== undefined) {
          attachment = attachment.attributes;
        } // args
  
  
        attachment = acf.parseArgs(attachment, {
          url: '',
          alt: '',
          title: '',
          filename: '',
          filesizeHumanReadable: '',
          icon: '/wp-includes/images/media/default.png'
        }); // return
  
        return attachment;
      },
      render: function (attachment) {
        // vars
        attachment = this.validateAttachment(attachment); // update image
  
        this.$('img').attr({
          src: attachment.icon,
          alt: attachment.alt,
          title: attachment.title
        }); // update elements
  
        this.$('[data-name="title"]').text(attachment.title);
        this.$('[data-name="filename"]').text(attachment.filename).attr('href', attachment.url);
        this.$('[data-name="filesize"]').text(attachment.filesizeHumanReadable); // vars
  
        var val = attachment.id || ''; // update val
  
        acf.val(this.$input(), val); // update class
  
        if (val) {
          this.$control().addClass('has-value');
        } else {
          this.$control().removeClass('has-value');
        }
      },
      selectAttachment: function () {
        // vars
        var parent = this.parent();
        var multiple = parent && parent.get('type') === 'repeater'; // new frame
  
        var frame = acf.newMediaPopup({
          mode: 'select',
          title: acf.__('Select File'),
          field: this.get('key'),
          multiple: multiple,
          library: this.get('library'),
          allowedTypes: this.get('mime_types'),
          select: $.proxy(function (attachment, i) {
            if (i > 0) {
              this.append(attachment, parent);
            } else {
              this.render(attachment);
            }
          }, this)
        });
      },
      editAttachment: function () {
        // vars
        var val = this.val(); // bail early if no val
  
        if (!val) {
          return false;
        } // popup
  
  
        var frame = acf.newMediaPopup({
          mode: 'edit',
          title: acf.__('Edit File'),
          button: acf.__('Update File'),
          attachment: val,
          field: this.get('key'),
          select: $.proxy(function (attachment, i) {
            this.render(attachment);
          }, this)
        });
      }
    });
    acf.registerFieldType(Field);
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-google-map.js":
  /*!*******************************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-field-google-map.js ***!
    \*******************************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    var Field = acf.Field.extend({
      type: 'google_map',
      map: false,
      wait: 'load',
      events: {
        'click a[data-name="clear"]': 'onClickClear',
        'click a[data-name="locate"]': 'onClickLocate',
        'click a[data-name="search"]': 'onClickSearch',
        'keydown .search': 'onKeydownSearch',
        'keyup .search': 'onKeyupSearch',
        'focus .search': 'onFocusSearch',
        'blur .search': 'onBlurSearch',
        showField: 'onShow'
      },
      $control: function () {
        return this.$('.acf-google-map');
      },
      $search: function () {
        return this.$('.search');
      },
      $canvas: function () {
        return this.$('.canvas');
      },
      setState: function (state) {
        // Remove previous state classes.
        this.$control().removeClass('-value -loading -searching'); // Determine auto state based of current value.
  
        if (state === 'default') {
          state = this.val() ? 'value' : '';
        } // Update state class.
  
  
        if (state) {
          this.$control().addClass('-' + state);
        }
      },
      getValue: function () {
        var val = this.$input().val();
  
        if (val) {
          return JSON.parse(val);
        } else {
          return false;
        }
      },
      setValue: function (val, silent) {
        // Convert input value.
        var valAttr = '';
  
        if (val) {
          valAttr = JSON.stringify(val);
        } // Update input (with change).
  
  
        acf.val(this.$input(), valAttr); // Bail early if silent update.
  
        if (silent) {
          return;
        } // Render.
  
  
        this.renderVal(val);
        /**
         * Fires immediately after the value has changed.
         *
         * @date	12/02/2014
         * @since	5.0.0
         *
         * @param	object|string val The new value.
         * @param	object map The Google Map isntance.
         * @param	object field The field instance.
         */
  
        acf.doAction('google_map_change', val, this.map, this);
      },
      renderVal: function (val) {
        // Value.
        if (val) {
          this.setState('value');
          this.$search().val(val.address);
          this.setPosition(val.lat, val.lng); // No value.
        } else {
          this.setState('');
          this.$search().val('');
          this.map.marker.setVisible(false);
        }
      },
      newLatLng: function (lat, lng) {
        return new google.maps.LatLng(parseFloat(lat), parseFloat(lng));
      },
      setPosition: function (lat, lng) {
        // Update marker position.
        this.map.marker.setPosition({
          lat: parseFloat(lat),
          lng: parseFloat(lng)
        }); // Show marker.
  
        this.map.marker.setVisible(true); // Center map.
  
        this.center();
      },
      center: function () {
        // Find marker position.
        var position = this.map.marker.getPosition();
  
        if (position) {
          var lat = position.lat();
          var lng = position.lng(); // Or find default settings.
        } else {
          var lat = this.get('lat');
          var lng = this.get('lng');
        } // Center map.
  
  
        this.map.setCenter({
          lat: parseFloat(lat),
          lng: parseFloat(lng)
        });
      },
      initialize: function () {
        // Ensure Google API is loaded and then initialize map.
        withAPI(this.initializeMap.bind(this));
      },
      initializeMap: function () {
        // Get value ignoring conditional logic status.
        var val = this.getValue(); // Construct default args.
  
        var args = acf.parseArgs(val, {
          zoom: this.get('zoom'),
          lat: this.get('lat'),
          lng: this.get('lng')
        }); // Create Map.
  
        var mapArgs = {
          scrollwheel: false,
          zoom: parseInt(args.zoom),
          center: {
            lat: parseFloat(args.lat),
            lng: parseFloat(args.lng)
          },
          mapTypeId: google.maps.MapTypeId.ROADMAP,
          marker: {
            draggable: true,
            raiseOnDrag: true
          },
          autocomplete: {}
        };
        mapArgs = acf.applyFilters('google_map_args', mapArgs, this);
        var map = new google.maps.Map(this.$canvas()[0], mapArgs); // Create Marker.
  
        var markerArgs = acf.parseArgs(mapArgs.marker, {
          draggable: true,
          raiseOnDrag: true,
          map: map
        });
        markerArgs = acf.applyFilters('google_map_marker_args', markerArgs, this);
        var marker = new google.maps.Marker(markerArgs); // Maybe Create Autocomplete.
  
        var autocomplete = false;
  
        if (acf.isset(google, 'maps', 'places', 'Autocomplete')) {
          var autocompleteArgs = mapArgs.autocomplete || {};
          autocompleteArgs = acf.applyFilters('google_map_autocomplete_args', autocompleteArgs, this);
          autocomplete = new google.maps.places.Autocomplete(this.$search()[0], autocompleteArgs);
          autocomplete.bindTo('bounds', map);
        } // Add map events.
  
  
        this.addMapEvents(this, map, marker, autocomplete); // Append references.
  
        map.acf = this;
        map.marker = marker;
        map.autocomplete = autocomplete;
        this.map = map; // Set position.
  
        if (val) {
          this.setPosition(val.lat, val.lng);
        }
        /**
         * Fires immediately after the Google Map has been initialized.
         *
         * @date	12/02/2014
         * @since	5.0.0
         *
         * @param	object map The Google Map isntance.
         * @param	object marker The Google Map marker isntance.
         * @param	object field The field instance.
         */
  
  
        acf.doAction('google_map_init', map, marker, this);
      },
      addMapEvents: function (field, map, marker, autocomplete) {
        // Click map.
        google.maps.event.addListener(map, 'click', function (e) {
          var lat = e.latLng.lat();
          var lng = e.latLng.lng();
          field.searchPosition(lat, lng);
        }); // Drag marker.
  
        google.maps.event.addListener(marker, 'dragend', function () {
          var lat = this.getPosition().lat();
          var lng = this.getPosition().lng();
          field.searchPosition(lat, lng);
        }); // Autocomplete search.
  
        if (autocomplete) {
          google.maps.event.addListener(autocomplete, 'place_changed', function () {
            var place = this.getPlace();
            field.searchPlace(place);
          });
        } // Detect zoom change.
  
  
        google.maps.event.addListener(map, 'zoom_changed', function () {
          var val = field.val();
  
          if (val) {
            val.zoom = map.getZoom();
            field.setValue(val, true);
          }
        });
      },
      searchPosition: function (lat, lng) {
        //console.log('searchPosition', lat, lng );
        // Start Loading.
        this.setState('loading'); // Query Geocoder.
  
        var latLng = {
          lat: lat,
          lng: lng
        };
        geocoder.geocode({
          location: latLng
        }, function (results, status) {
          //console.log('searchPosition', arguments );
          // End Loading.
          this.setState(''); // Status failure.
  
          if (status !== 'OK') {
            this.showNotice({
              text: acf.__('Location not found: %s').replace('%s', status),
              type: 'warning'
            }); // Success.
          } else {
            var val = this.parseResult(results[0]); // Override lat/lng to match user defined marker location.
            // Avoids issue where marker "snaps" to nearest result.
  
            val.lat = lat;
            val.lng = lng;
            this.val(val);
          }
        }.bind(this));
      },
      searchPlace: function (place) {
        //console.log('searchPlace', place );
        // Bail early if no place.
        if (!place) {
          return;
        } // Selecting from the autocomplete dropdown will return a rich PlaceResult object.
        // Be sure to over-write the "formatted_address" value with the one displayed to the user for best UX.
  
  
        if (place.geometry) {
          place.formatted_address = this.$search().val();
          var val = this.parseResult(place);
          this.val(val); // Searching a custom address will return an empty PlaceResult object.
        } else if (place.name) {
          this.searchAddress(place.name);
        }
      },
      searchAddress: function (address) {
        //console.log('searchAddress', address );
        // Bail early if no address.
        if (!address) {
          return;
        } // Allow "lat,lng" search.
  
  
        var latLng = address.split(',');
  
        if (latLng.length == 2) {
          var lat = parseFloat(latLng[0]);
          var lng = parseFloat(latLng[1]);
  
          if (lat && lng) {
            return this.searchPosition(lat, lng);
          }
        } // Start Loading.
  
  
        this.setState('loading'); // Query Geocoder.
  
        geocoder.geocode({
          address: address
        }, function (results, status) {
          //console.log('searchPosition', arguments );
          // End Loading.
          this.setState(''); // Status failure.
  
          if (status !== 'OK') {
            this.showNotice({
              text: acf.__('Location not found: %s').replace('%s', status),
              type: 'warning'
            }); // Success.
          } else {
            var val = this.parseResult(results[0]); // Override address data with parameter allowing custom address to be defined in search.
  
            val.address = address; // Update value.
  
            this.val(val);
          }
        }.bind(this));
      },
      searchLocation: function () {
        //console.log('searchLocation' );
        // Check HTML5 geolocation.
        if (!navigator.geolocation) {
          return alert(acf.__('Sorry, this browser does not support geolocation'));
        } // Start Loading.
  
  
        this.setState('loading'); // Query Geolocation.
  
        navigator.geolocation.getCurrentPosition( // Success.
        function (results) {
          // End Loading.
          this.setState(''); // Search position.
  
          var lat = results.coords.latitude;
          var lng = results.coords.longitude;
          this.searchPosition(lat, lng);
        }.bind(this), // Failure.
        function (error) {
          this.setState('');
        }.bind(this));
      },
  
      /**
       * parseResult
       *
       * Returns location data for the given GeocoderResult object.
       *
       * @date	15/10/19
       * @since	5.8.6
       *
       * @param	object obj A GeocoderResult object.
       * @return	object
       */
      parseResult: function (obj) {
        // Construct basic data.
        var result = {
          address: obj.formatted_address,
          lat: obj.geometry.location.lat(),
          lng: obj.geometry.location.lng()
        }; // Add zoom level.
  
        result.zoom = this.map.getZoom(); // Add place ID.
  
        if (obj.place_id) {
          result.place_id = obj.place_id;
        } // Add place name.
  
  
        if (obj.name) {
          result.name = obj.name;
        } // Create search map for address component data.
  
  
        var map = {
          street_number: ['street_number'],
          street_name: ['street_address', 'route'],
          city: ['locality', 'postal_town'],
          state: ['administrative_area_level_1', 'administrative_area_level_2', 'administrative_area_level_3', 'administrative_area_level_4', 'administrative_area_level_5'],
          post_code: ['postal_code'],
          country: ['country']
        }; // Loop over map.
  
        for (var k in map) {
          var keywords = map[k]; // Loop over address components.
  
          for (var i = 0; i < obj.address_components.length; i++) {
            var component = obj.address_components[i];
            var component_type = component.types[0]; // Look for matching component type.
  
            if (keywords.indexOf(component_type) !== -1) {
              // Append to result.
              result[k] = component.long_name; // Append short version.
  
              if (component.long_name !== component.short_name) {
                result[k + '_short'] = component.short_name;
              }
            }
          }
        }
        /**
         * Filters the parsed result.
         *
         * @date	18/10/19
         * @since	5.8.6
         *
         * @param	object result The parsed result value.
         * @param	object obj The GeocoderResult object.
         */
  
  
        return acf.applyFilters('google_map_result', result, obj, this.map, this);
      },
      onClickClear: function () {
        this.val(false);
      },
      onClickLocate: function () {
        this.searchLocation();
      },
      onClickSearch: function () {
        this.searchAddress(this.$search().val());
      },
      onFocusSearch: function (e, $el) {
        this.setState('searching');
      },
      onBlurSearch: function (e, $el) {
        // Get saved address value.
        var val = this.val();
        var address = val ? val.address : ''; // Remove 'is-searching' if value has not changed.
  
        if ($el.val() === address) {
          this.setState('default');
        }
      },
      onKeyupSearch: function (e, $el) {
        // Clear empty value.
        if (!$el.val()) {
          this.val(false);
        }
      },
      // Prevent form from submitting.
      onKeydownSearch: function (e, $el) {
        if (e.which == 13) {
          e.preventDefault();
          $el.blur();
        }
      },
      // Center map once made visible.
      onShow: function () {
        if (this.map) {
          this.setTimeout(this.center);
        }
      }
    });
    acf.registerFieldType(Field); // Vars.
  
    var loading = false;
    var geocoder = false;
    /**
     * withAPI
     *
     * Loads the Google Maps API library and troggers callback.
     *
     * @date	28/3/19
     * @since	5.7.14
     *
     * @param	function callback The callback to excecute.
     * @return	void
     */
  
    function withAPI(callback) {
      // Check if geocoder exists.
      if (geocoder) {
        return callback();
      } // Check if geocoder API exists.
  
  
      if (acf.isset(window, 'google', 'maps', 'Geocoder')) {
        geocoder = new google.maps.Geocoder();
        return callback();
      } // Geocoder will need to be loaded. Hook callback to action.
  
  
      acf.addAction('google_map_api_loaded', callback); // Bail early if already loading API.
  
      if (loading) {
        return;
      } // load api
  
  
      var url = acf.get('google_map_api');
  
      if (url) {
        // Set loading status.
        loading = true; // Load API
  
        $.ajax({
          url: url,
          dataType: 'script',
          cache: true,
          success: function () {
            geocoder = new google.maps.Geocoder();
            acf.doAction('google_map_api_loaded');
          }
        });
      }
    }
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-image.js":
  /*!**************************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-field-image.js ***!
    \**************************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    var Field = acf.Field.extend({
      type: 'image',
      $control: function () {
        return this.$('.acf-image-uploader');
      },
      $input: function () {
        return this.$('input[type="hidden"]');
      },
      events: {
        'click a[data-name="add"]': 'onClickAdd',
        'click a[data-name="edit"]': 'onClickEdit',
        'click a[data-name="remove"]': 'onClickRemove',
        'change input[type="file"]': 'onChange'
      },
      initialize: function () {
        // add attribute to form
        if (this.get('uploader') === 'basic') {
          this.$el.closest('form').attr('enctype', 'multipart/form-data');
        }
      },
      validateAttachment: function (attachment) {
        // Use WP attachment attributes when available.
        if (attachment && attachment.attributes) {
          attachment = attachment.attributes;
        } // Apply defaults.
  
  
        attachment = acf.parseArgs(attachment, {
          id: 0,
          url: '',
          alt: '',
          title: '',
          caption: '',
          description: '',
          width: 0,
          height: 0
        }); // Override with "preview size".
  
        var size = acf.isget(attachment, 'sizes', this.get('preview_size'));
  
        if (size) {
          attachment.url = size.url;
          attachment.width = size.width;
          attachment.height = size.height;
        } // Return.
  
  
        return attachment;
      },
      render: function (attachment) {
        attachment = this.validateAttachment(attachment); // Update DOM.
  
        this.$('img').attr({
          src: attachment.url,
          alt: attachment.alt
        });
  
        if (attachment.id) {
          this.val(attachment.id);
          this.$control().addClass('has-value');
        } else {
          this.val('');
          this.$control().removeClass('has-value');
        }
      },
      // create a new repeater row and render value
      append: function (attachment, parent) {
        // create function to find next available field within parent
        var getNext = function (field, parent) {
          // find existing file fields within parent
          var fields = acf.getFields({
            key: field.get('key'),
            parent: parent.$el
          }); // find the first field with no value
  
          for (var i = 0; i < fields.length; i++) {
            if (!fields[i].val()) {
              return fields[i];
            }
          } // return
  
  
          return false;
        }; // find existing file fields within parent
  
  
        var field = getNext(this, parent); // add new row if no available field
  
        if (!field) {
          parent.$('.acf-button:last').trigger('click');
          field = getNext(this, parent);
        } // render
  
  
        if (field) {
          field.render(attachment);
        }
      },
      selectAttachment: function () {
        // vars
        var parent = this.parent();
        var multiple = parent && parent.get('type') === 'repeater'; // new frame
  
        var frame = acf.newMediaPopup({
          mode: 'select',
          type: 'image',
          title: acf.__('Select Image'),
          field: this.get('key'),
          multiple: multiple,
          library: this.get('library'),
          allowedTypes: this.get('mime_types'),
          select: $.proxy(function (attachment, i) {
            if (i > 0) {
              this.append(attachment, parent);
            } else {
              this.render(attachment);
            }
          }, this)
        });
      },
      editAttachment: function () {
        // vars
        var val = this.val(); // bail early if no val
  
        if (!val) return; // popup
  
        var frame = acf.newMediaPopup({
          mode: 'edit',
          title: acf.__('Edit Image'),
          button: acf.__('Update Image'),
          attachment: val,
          field: this.get('key'),
          select: $.proxy(function (attachment, i) {
            this.render(attachment);
          }, this)
        });
      },
      removeAttachment: function () {
        this.render(false);
      },
      onClickAdd: function (e, $el) {
        this.selectAttachment();
      },
      onClickEdit: function (e, $el) {
        this.editAttachment();
      },
      onClickRemove: function (e, $el) {
        this.removeAttachment();
      },
      onChange: function (e, $el) {
        var $hiddenInput = this.$input();
  
        if (!$el.val()) {
          $hiddenInput.val('');
        }
  
        acf.getFileInputData($el, function (data) {
          $hiddenInput.val($.param(data));
        });
      }
    });
    acf.registerFieldType(Field);
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-link.js":
  /*!*************************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-field-link.js ***!
    \*************************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    var Field = acf.Field.extend({
      type: 'link',
      events: {
        'click a[data-name="add"]': 'onClickEdit',
        'click a[data-name="edit"]': 'onClickEdit',
        'click a[data-name="remove"]': 'onClickRemove',
        'change .link-node': 'onChange'
      },
      $control: function () {
        return this.$('.acf-link');
      },
      $node: function () {
        return this.$('.link-node');
      },
      getValue: function () {
        // vars
        var $node = this.$node(); // return false if empty
  
        if (!$node.attr('href')) {
          return false;
        } // return
  
  
        return {
          title: $node.html(),
          url: $node.attr('href'),
          target: $node.attr('target')
        };
      },
      setValue: function (val) {
        // default
        val = acf.parseArgs(val, {
          title: '',
          url: '',
          target: ''
        }); // vars
  
        var $div = this.$control();
        var $node = this.$node(); // remove class
  
        $div.removeClass('-value -external'); // add class
  
        if (val.url) $div.addClass('-value');
        if (val.target === '_blank') $div.addClass('-external'); // update text
  
        this.$('.link-title').html(val.title);
        this.$('.link-url').attr('href', val.url).html(val.url); // update node
  
        $node.html(val.title);
        $node.attr('href', val.url);
        $node.attr('target', val.target); // update inputs
  
        this.$('.input-title').val(val.title);
        this.$('.input-target').val(val.target);
        this.$('.input-url').val(val.url).trigger('change');
      },
      onClickEdit: function (e, $el) {
        acf.wpLink.open(this.$node());
      },
      onClickRemove: function (e, $el) {
        this.setValue(false);
      },
      onChange: function (e, $el) {
        // get the changed value
        var val = this.getValue(); // update inputs
  
        this.setValue(val);
      }
    });
    acf.registerFieldType(Field); // manager
  
    acf.wpLink = new acf.Model({
      getNodeValue: function () {
        var $node = this.get('node');
        return {
          title: acf.decode($node.html()),
          url: $node.attr('href'),
          target: $node.attr('target')
        };
      },
      setNodeValue: function (val) {
        var $node = this.get('node');
        $node.text(val.title);
        $node.attr('href', val.url);
        $node.attr('target', val.target);
        $node.trigger('change');
      },
      getInputValue: function () {
        return {
          title: $('#wp-link-text').val(),
          url: $('#wp-link-url').val(),
          target: $('#wp-link-target').prop('checked') ? '_blank' : ''
        };
      },
      setInputValue: function (val) {
        $('#wp-link-text').val(val.title);
        $('#wp-link-url').val(val.url);
        $('#wp-link-target').prop('checked', val.target === '_blank');
      },
      open: function ($node) {
        // add events
        this.on('wplink-open', 'onOpen');
        this.on('wplink-close', 'onClose'); // set node
  
        this.set('node', $node); // create textarea
  
        var $textarea = $('<textarea id="acf-link-textarea" style="display:none;"></textarea>');
        $('body').append($textarea); // vars
  
        var val = this.getNodeValue(); // open popup
  
        wpLink.open('acf-link-textarea', val.url, val.title, null);
      },
      onOpen: function () {
        // always show title (WP will hide title if empty)
        $('#wp-link-wrap').addClass('has-text-field'); // set inputs
  
        var val = this.getNodeValue();
        this.setInputValue(val); // Update button text.
  
        if (val.url && wpLinkL10n) {
          $('#wp-link-submit').val(wpLinkL10n.update);
        }
      },
      close: function () {
        wpLink.close();
      },
      onClose: function () {
        // Bail early if no node.
        // Needed due to WP triggering this event twice.
        if (!this.has('node')) {
          return false;
        } // Determine context.
  
  
        var $submit = $('#wp-link-submit');
        var isSubmit = $submit.is(':hover') || $submit.is(':focus'); // Set value
  
        if (isSubmit) {
          var val = this.getInputValue();
          this.setNodeValue(val);
        } // Cleanup.
  
  
        this.off('wplink-open');
        this.off('wplink-close');
        $('#acf-link-textarea').remove();
        this.set('node', null);
      }
    });
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-oembed.js":
  /*!***************************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-field-oembed.js ***!
    \***************************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    var Field = acf.Field.extend({
      type: 'oembed',
      events: {
        'click [data-name="clear-button"]': 'onClickClear',
        'keypress .input-search': 'onKeypressSearch',
        'keyup .input-search': 'onKeyupSearch',
        'change .input-search': 'onChangeSearch'
      },
      $control: function () {
        return this.$('.acf-oembed');
      },
      $input: function () {
        return this.$('.input-value');
      },
      $search: function () {
        return this.$('.input-search');
      },
      getValue: function () {
        return this.$input().val();
      },
      getSearchVal: function () {
        return this.$search().val();
      },
      setValue: function (val) {
        // class
        if (val) {
          this.$control().addClass('has-value');
        } else {
          this.$control().removeClass('has-value');
        }
  
        acf.val(this.$input(), val);
      },
      showLoading: function (show) {
        acf.showLoading(this.$('.canvas'));
      },
      hideLoading: function () {
        acf.hideLoading(this.$('.canvas'));
      },
      maybeSearch: function () {
        // vars
        var prevUrl = this.val();
        var url = this.getSearchVal(); // no value
  
        if (!url) {
          return this.clear();
        } // fix missing 'http://' - causes the oembed code to error and fail
  
  
        if (url.substr(0, 4) != 'http') {
          url = 'http://' + url;
        } // bail early if no change
  
  
        if (url === prevUrl) return; // clear existing timeout
  
        var timeout = this.get('timeout');
  
        if (timeout) {
          clearTimeout(timeout);
        } // set new timeout
  
  
        var callback = $.proxy(this.search, this, url);
        this.set('timeout', setTimeout(callback, 300));
      },
      search: function (url) {
        // ajax
        var ajaxData = {
          action: 'acf/fields/oembed/search',
          s: url,
          field_key: this.get('key')
        }; // clear existing timeout
  
        var xhr = this.get('xhr');
  
        if (xhr) {
          xhr.abort();
        } // loading
  
  
        this.showLoading(); // query
  
        var xhr = $.ajax({
          url: acf.get('ajaxurl'),
          data: acf.prepareForAjax(ajaxData),
          type: 'post',
          dataType: 'json',
          context: this,
          success: function (json) {
            // error
            if (!json || !json.html) {
              json = {
                url: false,
                html: ''
              };
            } // update vars
  
  
            this.val(json.url);
            this.$('.canvas-media').html(json.html);
          },
          complete: function () {
            this.hideLoading();
          }
        });
        this.set('xhr', xhr);
      },
      clear: function () {
        this.val('');
        this.$search().val('');
        this.$('.canvas-media').html('');
      },
      onClickClear: function (e, $el) {
        this.clear();
      },
      onKeypressSearch: function (e, $el) {
        if (e.which == 13) {
          e.preventDefault();
          this.maybeSearch();
        }
      },
      onKeyupSearch: function (e, $el) {
        if ($el.val()) {
          this.maybeSearch();
        }
      },
      onChangeSearch: function (e, $el) {
        this.maybeSearch();
      }
    });
    acf.registerFieldType(Field);
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-page-link.js":
  /*!******************************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-field-page-link.js ***!
    \******************************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    var Field = acf.models.SelectField.extend({
      type: 'page_link'
    });
    acf.registerFieldType(Field);
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-post-object.js":
  /*!********************************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-field-post-object.js ***!
    \********************************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    var Field = acf.models.SelectField.extend({
      type: 'post_object'
    });
    acf.registerFieldType(Field);
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-radio.js":
  /*!**************************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-field-radio.js ***!
    \**************************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    var Field = acf.Field.extend({
      type: 'radio',
      events: {
        'click input[type="radio"]': 'onClick'
      },
      $control: function () {
        return this.$('.acf-radio-list');
      },
      $input: function () {
        return this.$('input:checked');
      },
      $inputText: function () {
        return this.$('input[type="text"]');
      },
      getValue: function () {
        var val = this.$input().val();
  
        if (val === 'other' && this.get('other_choice')) {
          val = this.$inputText().val();
        }
  
        return val;
      },
      onClick: function (e, $el) {
        // vars
        var $label = $el.parent('label');
        var selected = $label.hasClass('selected');
        var val = $el.val(); // remove previous selected
  
        this.$('.selected').removeClass('selected'); // add active class
  
        $label.addClass('selected'); // allow null
  
        if (this.get('allow_null') && selected) {
          $label.removeClass('selected');
          $el.prop('checked', false).trigger('change');
          val = false;
        } // other
  
  
        if (this.get('other_choice')) {
          // enable
          if (val === 'other') {
            this.$inputText().prop('disabled', false); // disable
          } else {
            this.$inputText().prop('disabled', true);
          }
        }
      }
    });
    acf.registerFieldType(Field);
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-range.js":
  /*!**************************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-field-range.js ***!
    \**************************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    var Field = acf.Field.extend({
      type: 'range',
      events: {
        'input input[type="range"]': 'onChange',
        'change input': 'onChange'
      },
      $input: function () {
        return this.$('input[type="range"]');
      },
      $inputAlt: function () {
        return this.$('input[type="number"]');
      },
      setValue: function (val) {
        this.busy = true; // Update range input (with change).
  
        acf.val(this.$input(), val); // Update alt input (without change).
        // Read in input value to inherit min/max validation.
  
        acf.val(this.$inputAlt(), this.$input().val(), true);
        this.busy = false;
      },
      onChange: function (e, $el) {
        if (!this.busy) {
          this.setValue($el.val());
        }
      }
    });
    acf.registerFieldType(Field);
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-relationship.js":
  /*!*********************************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-field-relationship.js ***!
    \*********************************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    var Field = acf.Field.extend({
      type: 'relationship',
      events: {
        'keypress [data-filter]': 'onKeypressFilter',
        'change [data-filter]': 'onChangeFilter',
        'keyup [data-filter]': 'onChangeFilter',
        'click .choices-list .acf-rel-item': 'onClickAdd',
        'click [data-name="remove_item"]': 'onClickRemove'
      },
      $control: function () {
        return this.$('.acf-relationship');
      },
      $list: function (list) {
        return this.$('.' + list + '-list');
      },
      $listItems: function (list) {
        return this.$list(list).find('.acf-rel-item');
      },
      $listItem: function (list, id) {
        return this.$list(list).find('.acf-rel-item[data-id="' + id + '"]');
      },
      getValue: function () {
        var val = [];
        this.$listItems('values').each(function () {
          val.push($(this).data('id'));
        });
        return val.length ? val : false;
      },
      newChoice: function (props) {
        return ['<li>', '<span data-id="' + props.id + '" class="acf-rel-item">' + props.text + '</span>', '</li>'].join('');
      },
      newValue: function (props) {
        return ['<li>', '<input type="hidden" name="' + this.getInputName() + '[]" value="' + props.id + '" />', '<span data-id="' + props.id + '" class="acf-rel-item">' + props.text, '<a href="#" class="acf-icon -minus small dark" data-name="remove_item"></a>', '</span>', '</li>'].join('');
      },
      initialize: function () {
        // Delay initialization until "interacted with" or "in view".
        var delayed = this.proxy(acf.once(function () {
          // Add sortable.
          this.$list('values').sortable({
            items: 'li',
            forceHelperSize: true,
            forcePlaceholderSize: true,
            scroll: true,
            update: this.proxy(function () {
              this.$input().trigger('change');
            })
          }); // Avoid browser remembering old scroll position and add event.
  
          this.$list('choices').scrollTop(0).on('scroll', this.proxy(this.onScrollChoices)); // Fetch choices.
  
          this.fetch();
        })); // Bind "interacted with".
  
        this.$el.one('mouseover', delayed);
        this.$el.one('focus', 'input', delayed); // Bind "in view".
  
        acf.onceInView(this.$el, delayed);
      },
      onScrollChoices: function (e) {
        // bail early if no more results
        if (this.get('loading') || !this.get('more')) {
          return;
        } // Scrolled to bottom
  
  
        var $list = this.$list('choices');
        var scrollTop = Math.ceil($list.scrollTop());
        var scrollHeight = Math.ceil($list[0].scrollHeight);
        var innerHeight = Math.ceil($list.innerHeight());
        var paged = this.get('paged') || 1;
  
        if (scrollTop + innerHeight >= scrollHeight) {
          // update paged
          this.set('paged', paged + 1); // fetch
  
          this.fetch();
        }
      },
      onKeypressFilter: function (e, $el) {
        // don't submit form
        if (e.which == 13) {
          e.preventDefault();
        }
      },
      onChangeFilter: function (e, $el) {
        // vars
        var val = $el.val();
        var filter = $el.data('filter'); // Bail early if filter has not changed
  
        if (this.get(filter) === val) {
          return;
        } // update attr
  
  
        this.set(filter, val); // reset paged
  
        this.set('paged', 1); // fetch
  
        if ($el.is('select')) {
          this.fetch(); // search must go through timeout
        } else {
          this.maybeFetch();
        }
      },
      onClickAdd: function (e, $el) {
        // vars
        var val = this.val();
        var max = parseInt(this.get('max')); // can be added?
  
        if ($el.hasClass('disabled')) {
          return false;
        } // validate
  
  
        if (max > 0 && val && val.length >= max) {
          // add notice
          this.showNotice({
            text: acf.__('Maximum values reached ( {max} values )').replace('{max}', max),
            type: 'warning'
          });
          return false;
        } // disable
  
  
        $el.addClass('disabled'); // add
  
        var html = this.newValue({
          id: $el.data('id'),
          text: $el.html()
        });
        this.$list('values').append(html); // trigger change
  
        this.$input().trigger('change');
      },
      onClickRemove: function (e, $el) {
        // Prevent default here because generic handler wont be triggered.
        e.preventDefault(); // vars
  
        var $span = $el.parent();
        var $li = $span.parent();
        var id = $span.data('id'); // remove value
  
        $li.remove(); // show choice
  
        this.$listItem('choices', id).removeClass('disabled'); // trigger change
  
        this.$input().trigger('change');
      },
      maybeFetch: function () {
        // vars
        var timeout = this.get('timeout'); // abort timeout
  
        if (timeout) {
          clearTimeout(timeout);
        } // fetch
  
  
        timeout = this.setTimeout(this.fetch, 300);
        this.set('timeout', timeout);
      },
      getAjaxData: function () {
        // load data based on element attributes
        var ajaxData = this.$control().data();
  
        for (var name in ajaxData) {
          ajaxData[name] = this.get(name);
        } // extra
  
  
        ajaxData.action = 'acf/fields/relationship/query';
        ajaxData.field_key = this.get('key'); // Filter.
  
        ajaxData = acf.applyFilters('relationship_ajax_data', ajaxData, this); // return
  
        return ajaxData;
      },
      fetch: function () {
        // abort XHR if this field is already loading AJAX data
        var xhr = this.get('xhr');
  
        if (xhr) {
          xhr.abort();
        } // add to this.o
  
  
        var ajaxData = this.getAjaxData(); // clear html if is new query
  
        var $choiceslist = this.$list('choices');
  
        if (ajaxData.paged == 1) {
          $choiceslist.html('');
        } // loading
  
  
        var $loading = $('<li><i class="acf-loading"></i> ' + acf.__('Loading') + '</li>');
        $choiceslist.append($loading);
        this.set('loading', true); // callback
  
        var onComplete = function () {
          this.set('loading', false);
          $loading.remove();
        };
  
        var onSuccess = function (json) {
          // no results
          if (!json || !json.results || !json.results.length) {
            // prevent pagination
            this.set('more', false); // add message
  
            if (this.get('paged') == 1) {
              this.$list('choices').append('<li>' + acf.__('No matches found') + '</li>');
            } // return
  
  
            return;
          } // set more (allows pagination scroll)
  
  
          this.set('more', json.more); // get new results
  
          var html = this.walkChoices(json.results);
          var $html = $(html); // apply .disabled to left li's
  
          var val = this.val();
  
          if (val && val.length) {
            val.map(function (id) {
              $html.find('.acf-rel-item[data-id="' + id + '"]').addClass('disabled');
            });
          } // append
  
  
          $choiceslist.append($html); // merge together groups
  
          var $prevLabel = false;
          var $prevList = false;
          $choiceslist.find('.acf-rel-label').each(function () {
            var $label = $(this);
            var $list = $label.siblings('ul');
  
            if ($prevLabel && $prevLabel.text() == $label.text()) {
              $prevList.append($list.children());
              $(this).parent().remove();
              return;
            } // update vars
  
  
            $prevLabel = $label;
            $prevList = $list;
          });
        }; // get results
  
  
        var xhr = $.ajax({
          url: acf.get('ajaxurl'),
          dataType: 'json',
          type: 'post',
          data: acf.prepareForAjax(ajaxData),
          context: this,
          success: onSuccess,
          complete: onComplete
        }); // set
  
        this.set('xhr', xhr);
      },
      walkChoices: function (data) {
        // walker
        var walk = function (data) {
          // vars
          var html = ''; // is array
  
          if ($.isArray(data)) {
            data.map(function (item) {
              html += walk(item);
            }); // is item
          } else if ($.isPlainObject(data)) {
            // group
            if (data.children !== undefined) {
              html += '<li><span class="acf-rel-label">' + acf.escHtml(data.text) + '</span><ul class="acf-bl">';
              html += walk(data.children);
              html += '</ul></li>'; // single
            } else {
              html += '<li><span class="acf-rel-item" data-id="' + acf.escAttr(data.id) + '">' + acf.escHtml(data.text) + '</span></li>';
            }
          } // return
  
  
          return html;
        };
  
        return walk(data);
      }
    });
    acf.registerFieldType(Field);
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-select.js":
  /*!***************************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-field-select.js ***!
    \***************************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    var Field = acf.Field.extend({
      type: 'select',
      select2: false,
      wait: 'load',
      events: {
        removeField: 'onRemove',
        duplicateField: 'onDuplicate'
      },
      $input: function () {
        return this.$('select');
      },
      initialize: function () {
        // vars
        var $select = this.$input(); // inherit data
  
        this.inherit($select); // select2
  
        if (this.get('ui')) {
          // populate ajax_data (allowing custom attribute to already exist)
          var ajaxAction = this.get('ajax_action');
  
          if (!ajaxAction) {
            ajaxAction = 'acf/fields/' + this.get('type') + '/query';
          } // select2
  
  
          this.select2 = acf.newSelect2($select, {
            field: this,
            ajax: this.get('ajax'),
            multiple: this.get('multiple'),
            placeholder: this.get('placeholder'),
            allowNull: this.get('allow_null'),
            ajaxAction: ajaxAction
          });
        }
      },
      onRemove: function () {
        if (this.select2) {
          this.select2.destroy();
        }
      },
      onDuplicate: function (e, $el, $duplicate) {
        if (this.select2) {
          $duplicate.find('.select2-container').remove();
          $duplicate.find('select').removeClass('select2-hidden-accessible');
        }
      }
    });
    acf.registerFieldType(Field);
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-tab.js":
  /*!************************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-field-tab.js ***!
    \************************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    // vars
    var CONTEXT = 'tab';
    var Field = acf.Field.extend({
      type: 'tab',
      wait: '',
      tabs: false,
      tab: false,
      events: {
        duplicateField: 'onDuplicate'
      },
      findFields: function () {
        return this.$el.nextUntil('.acf-field-tab', '.acf-field');
      },
      getFields: function () {
        return acf.getFields(this.findFields());
      },
      findTabs: function () {
        return this.$el.prevAll('.acf-tab-wrap:first');
      },
      findTab: function () {
        return this.$('.acf-tab-button');
      },
      initialize: function () {
        // bail early if is td
        if (this.$el.is('td')) {
          this.events = {};
          return false;
        } // vars
  
  
        var $tabs = this.findTabs();
        var $tab = this.findTab();
        var settings = acf.parseArgs($tab.data(), {
          endpoint: false,
          placement: '',
          before: this.$el
        }); // create wrap
  
        if (!$tabs.length || settings.endpoint) {
          this.tabs = new Tabs(settings);
        } else {
          this.tabs = $tabs.data('acf');
        } // add tab
  
  
        this.tab = this.tabs.addTab($tab, this);
      },
      isActive: function () {
        return this.tab.isActive();
      },
      showFields: function () {
        // show fields
        this.getFields().map(function (field) {
          field.show(this.cid, CONTEXT);
          field.hiddenByTab = false;
        }, this);
      },
      hideFields: function () {
        // hide fields
        this.getFields().map(function (field) {
          field.hide(this.cid, CONTEXT);
          field.hiddenByTab = this.tab;
        }, this);
      },
      show: function (lockKey) {
        // show field and store result
        var visible = acf.Field.prototype.show.apply(this, arguments); // check if now visible
  
        if (visible) {
          // show tab
          this.tab.show(); // check active tabs
  
          this.tabs.refresh();
        } // return
  
  
        return visible;
      },
      hide: function (lockKey) {
        // hide field and store result
        var hidden = acf.Field.prototype.hide.apply(this, arguments); // check if now hidden
  
        if (hidden) {
          // hide tab
          this.tab.hide(); // reset tabs if this was active
  
          if (this.isActive()) {
            this.tabs.reset();
          }
        } // return
  
  
        return hidden;
      },
      enable: function (lockKey) {
        // enable fields
        this.getFields().map(function (field) {
          field.enable(CONTEXT);
        });
      },
      disable: function (lockKey) {
        // disable fields
        this.getFields().map(function (field) {
          field.disable(CONTEXT);
        });
      },
      onDuplicate: function (e, $el, $duplicate) {
        if (this.isActive()) {
          $duplicate.prevAll('.acf-tab-wrap:first').remove();
        }
      }
    });
    acf.registerFieldType(Field);
    /**
     *  tabs
     *
     *  description
     *
     *  @date	8/2/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
  
    var i = 0;
    var Tabs = acf.Model.extend({
      tabs: [],
      active: false,
      actions: {
        refresh: 'onRefresh'
      },
      data: {
        before: false,
        placement: 'top',
        index: 0,
        initialized: false
      },
      setup: function (settings) {
        // data
        $.extend(this.data, settings); // define this prop to avoid scope issues
  
        this.tabs = [];
        this.active = false; // vars
  
        var placement = this.get('placement');
        var $before = this.get('before');
        var $parent = $before.parent(); // add sidebar for left placement
  
        if (placement == 'left' && $parent.hasClass('acf-fields')) {
          $parent.addClass('-sidebar');
        } // create wrap
  
  
        if ($before.is('tr')) {
          this.$el = $('<tr class="acf-tab-wrap"><td colspan="2"><ul class="acf-hl acf-tab-group"></ul></td></tr>');
        } else {
          this.$el = $('<div class="acf-tab-wrap -' + placement + '"><ul class="acf-hl acf-tab-group"></ul></div>');
        } // append
  
  
        $before.before(this.$el); // set index
  
        this.set('index', i, true);
        i++;
      },
      initializeTabs: function () {
        // find first visible tab
        var tab = this.getVisible().shift(); // remember previous tab state
  
        var order = acf.getPreference('this.tabs') || [];
        var groupIndex = this.get('index');
        var tabIndex = order[groupIndex];
  
        if (this.tabs[tabIndex] && this.tabs[tabIndex].isVisible()) {
          tab = this.tabs[tabIndex];
        } // select
  
  
        if (tab) {
          this.selectTab(tab);
        } else {
          this.closeTabs();
        } // set local variable used by tabsManager
  
  
        this.set('initialized', true);
      },
      getVisible: function () {
        return this.tabs.filter(function (tab) {
          return tab.isVisible();
        });
      },
      getActive: function () {
        return this.active;
      },
      setActive: function (tab) {
        return this.active = tab;
      },
      hasActive: function () {
        return this.active !== false;
      },
      isActive: function (tab) {
        var active = this.getActive();
        return active && active.cid === tab.cid;
      },
      closeActive: function () {
        if (this.hasActive()) {
          this.closeTab(this.getActive());
        }
      },
      openTab: function (tab) {
        // close existing tab
        this.closeActive(); // open
  
        tab.open(); // set active
  
        this.setActive(tab);
      },
      closeTab: function (tab) {
        // close
        tab.close(); // set active
  
        this.setActive(false);
      },
      closeTabs: function () {
        this.tabs.map(this.closeTab, this);
      },
      selectTab: function (tab) {
        // close other tabs
        this.tabs.map(function (t) {
          if (tab.cid !== t.cid) {
            this.closeTab(t);
          }
        }, this); // open
  
        this.openTab(tab);
      },
      addTab: function ($a, field) {
        // create <li>
        var $li = $('<li>' + $a.outerHTML() + '</li>'); // append
  
        this.$('ul').append($li); // initialize
  
        var tab = new Tab({
          $el: $li,
          field: field,
          group: this
        }); // store
  
        this.tabs.push(tab); // return
  
        return tab;
      },
      reset: function () {
        // close existing tab
        this.closeActive(); // find and active a tab
  
        return this.refresh();
      },
      refresh: function () {
        // bail early if active already exists
        if (this.hasActive()) {
          return false;
        } // find next active tab
  
  
        var tab = this.getVisible().shift(); // open tab
  
        if (tab) {
          this.openTab(tab);
        } // return
  
  
        return tab;
      },
      onRefresh: function () {
        // only for left placements
        if (this.get('placement') !== 'left') {
          return;
        } // vars
  
  
        var $parent = this.$el.parent();
        var $list = this.$el.children('ul');
        var attribute = $parent.is('td') ? 'height' : 'min-height'; // find height (minus 1 for border-bottom)
  
        var height = $list.position().top + $list.outerHeight(true) - 1; // add css
  
        $parent.css(attribute, height);
      }
    });
    var Tab = acf.Model.extend({
      group: false,
      field: false,
      events: {
        'click a': 'onClick'
      },
      index: function () {
        return this.$el.index();
      },
      isVisible: function () {
        return acf.isVisible(this.$el);
      },
      isActive: function () {
        return this.$el.hasClass('active');
      },
      open: function () {
        // add class
        this.$el.addClass('active'); // show field
  
        this.field.showFields();
      },
      close: function () {
        // remove class
        this.$el.removeClass('active'); // hide field
  
        this.field.hideFields();
      },
      onClick: function (e, $el) {
        // prevent default
        e.preventDefault(); // toggle
  
        this.toggle();
      },
      toggle: function () {
        // bail early if already active
        if (this.isActive()) {
          return;
        } // toggle this tab
  
  
        this.group.openTab(this);
      }
    });
    var tabsManager = new acf.Model({
      priority: 50,
      actions: {
        prepare: 'render',
        append: 'render',
        unload: 'onUnload',
        invalid_field: 'onInvalidField'
      },
      findTabs: function () {
        return $('.acf-tab-wrap');
      },
      getTabs: function () {
        return acf.getInstances(this.findTabs());
      },
      render: function ($el) {
        this.getTabs().map(function (tabs) {
          if (!tabs.get('initialized')) {
            tabs.initializeTabs();
          }
        });
      },
      onInvalidField: function (field) {
        // bail early if busy
        if (this.busy) {
          return;
        } // ignore if not hidden by tab
  
  
        if (!field.hiddenByTab) {
          return;
        } // toggle tab
  
  
        field.hiddenByTab.toggle(); // ignore other invalid fields
  
        this.busy = true;
        this.setTimeout(function () {
          this.busy = false;
        }, 100);
      },
      onUnload: function () {
        // vars
        var order = []; // loop
  
        this.getTabs().map(function (group) {
          var active = group.hasActive() ? group.getActive().index() : 0;
          order.push(active);
        }); // bail if no tabs
  
        if (!order.length) {
          return;
        } // update
  
  
        acf.setPreference('this.tabs', order);
      }
    });
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-taxonomy.js":
  /*!*****************************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-field-taxonomy.js ***!
    \*****************************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    var Field = acf.Field.extend({
      type: 'taxonomy',
      data: {
        ftype: 'select'
      },
      select2: false,
      wait: 'load',
      events: {
        'click a[data-name="add"]': 'onClickAdd',
        'click input[type="radio"]': 'onClickRadio',
        removeField: 'onRemove'
      },
      $control: function () {
        return this.$('.acf-taxonomy-field');
      },
      $input: function () {
        return this.getRelatedPrototype().$input.apply(this, arguments);
      },
      getRelatedType: function () {
        // vars
        var fieldType = this.get('ftype'); // normalize
  
        if (fieldType == 'multi_select') {
          fieldType = 'select';
        } // return
  
  
        return fieldType;
      },
      getRelatedPrototype: function () {
        return acf.getFieldType(this.getRelatedType()).prototype;
      },
      getValue: function () {
        return this.getRelatedPrototype().getValue.apply(this, arguments);
      },
      setValue: function () {
        return this.getRelatedPrototype().setValue.apply(this, arguments);
      },
      initialize: function () {
        this.getRelatedPrototype().initialize.apply(this, arguments);
      },
      onRemove: function () {
        var proto = this.getRelatedPrototype();
  
        if (proto.onRemove) {
          proto.onRemove.apply(this, arguments);
        }
      },
      onClickAdd: function (e, $el) {
        // vars
        var field = this;
        var popup = false;
        var $form = false;
        var $name = false;
        var $parent = false;
        var $button = false;
        var $message = false;
        var notice = false; // step 1.
  
        var step1 = function () {
          // popup
          popup = acf.newPopup({
            title: $el.attr('title'),
            loading: true,
            width: '300px'
          }); // ajax
  
          var ajaxData = {
            action: 'acf/fields/taxonomy/add_term',
            field_key: field.get('key')
          }; // get HTML
  
          $.ajax({
            url: acf.get('ajaxurl'),
            data: acf.prepareForAjax(ajaxData),
            type: 'post',
            dataType: 'html',
            success: step2
          });
        }; // step 2.
  
  
        var step2 = function (html) {
          // update popup
          popup.loading(false);
          popup.content(html); // vars
  
          $form = popup.$('form');
          $name = popup.$('input[name="term_name"]');
          $parent = popup.$('select[name="term_parent"]');
          $button = popup.$('.acf-submit-button'); // focus
  
          $name.trigger('focus'); // submit form
  
          popup.on('submit', 'form', step3);
        }; // step 3.
  
  
        var step3 = function (e, $el) {
          // prevent
          e.preventDefault();
          e.stopImmediatePropagation(); // basic validation
  
          if ($name.val() === '') {
            $name.trigger('focus');
            return false;
          } // disable
  
  
          acf.startButtonLoading($button); // ajax
  
          var ajaxData = {
            action: 'acf/fields/taxonomy/add_term',
            field_key: field.get('key'),
            term_name: $name.val(),
            term_parent: $parent.length ? $parent.val() : 0
          };
          $.ajax({
            url: acf.get('ajaxurl'),
            data: acf.prepareForAjax(ajaxData),
            type: 'post',
            dataType: 'json',
            success: step4
          });
        }; // step 4.
  
  
        var step4 = function (json) {
          // enable
          acf.stopButtonLoading($button); // remove prev notice
  
          if (notice) {
            notice.remove();
          } // success
  
  
          if (acf.isAjaxSuccess(json)) {
            // clear name
            $name.val(''); // update term lists
  
            step5(json.data); // notice
  
            notice = acf.newNotice({
              type: 'success',
              text: acf.getAjaxMessage(json),
              target: $form,
              timeout: 2000,
              dismiss: false
            });
          } else {
            // notice
            notice = acf.newNotice({
              type: 'error',
              text: acf.getAjaxError(json),
              target: $form,
              timeout: 2000,
              dismiss: false
            });
          } // focus
  
  
          $name.trigger('focus');
        }; // step 5.
  
  
        var step5 = function (term) {
          // update parent dropdown
          var $option = $('<option value="' + term.term_id + '">' + term.term_label + '</option>');
  
          if (term.term_parent) {
            $parent.children('option[value="' + term.term_parent + '"]').after($option);
          } else {
            $parent.append($option);
          } // add this new term to all taxonomy field
  
  
          var fields = acf.getFields({
            type: 'taxonomy'
          });
          fields.map(function (otherField) {
            if (otherField.get('taxonomy') == field.get('taxonomy')) {
              otherField.appendTerm(term);
            }
          }); // select
  
          field.selectTerm(term.term_id);
        }; // run
  
  
        step1();
      },
      appendTerm: function (term) {
        if (this.getRelatedType() == 'select') {
          this.appendTermSelect(term);
        } else {
          this.appendTermCheckbox(term);
        }
      },
      appendTermSelect: function (term) {
        this.select2.addOption({
          id: term.term_id,
          text: term.term_label
        });
      },
      appendTermCheckbox: function (term) {
        // vars
        var name = this.$('[name]:first').attr('name');
        var $ul = this.$('ul:first'); // allow multiple selection
  
        if (this.getRelatedType() == 'checkbox') {
          name += '[]';
        } // create new li
  
  
        var $li = $(['<li data-id="' + term.term_id + '">', '<label>', '<input type="' + this.get('ftype') + '" value="' + term.term_id + '" name="' + name + '" /> ', '<span>' + term.term_name + '</span>', '</label>', '</li>'].join('')); // find parent
  
        if (term.term_parent) {
          // vars
          var $parent = $ul.find('li[data-id="' + term.term_parent + '"]'); // update vars
  
          $ul = $parent.children('ul'); // create ul
  
          if (!$ul.exists()) {
            $ul = $('<ul class="children acf-bl"></ul>');
            $parent.append($ul);
          }
        } // append
  
  
        $ul.append($li);
      },
      selectTerm: function (id) {
        if (this.getRelatedType() == 'select') {
          this.select2.selectOption(id);
        } else {
          var $input = this.$('input[value="' + id + '"]');
          $input.prop('checked', true).trigger('change');
        }
      },
      onClickRadio: function (e, $el) {
        // vars
        var $label = $el.parent('label');
        var selected = $label.hasClass('selected'); // remove previous selected
  
        this.$('.selected').removeClass('selected'); // add active class
  
        $label.addClass('selected'); // allow null
  
        if (this.get('allow_null') && selected) {
          $label.removeClass('selected');
          $el.prop('checked', false).trigger('change');
        }
      }
    });
    acf.registerFieldType(Field);
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-time-picker.js":
  /*!********************************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-field-time-picker.js ***!
    \********************************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    var Field = acf.models.DatePickerField.extend({
      type: 'time_picker',
      $control: function () {
        return this.$('.acf-time-picker');
      },
      initialize: function () {
        // vars
        var $input = this.$input();
        var $inputText = this.$inputText(); // args
  
        var args = {
          timeFormat: this.get('time_format'),
          altField: $input,
          altFieldTimeOnly: false,
          altTimeFormat: 'HH:mm:ss',
          showButtonPanel: true,
          controlType: 'select',
          oneLine: true,
          closeText: acf.get('dateTimePickerL10n').selectText,
          timeOnly: true
        }; // add custom 'Close = Select' functionality
  
        args.onClose = function (value, dp_instance, t_instance) {
          // vars
          var $close = dp_instance.dpDiv.find('.ui-datepicker-close'); // if clicking close button
  
          if (!value && $close.is(':hover')) {
            t_instance._updateDateTime();
          }
        }; // filter
  
  
        args = acf.applyFilters('time_picker_args', args, this); // add date time picker
  
        acf.newTimePicker($inputText, args); // action
  
        acf.doAction('time_picker_init', $inputText, args, this);
      }
    });
    acf.registerFieldType(Field); // add
  
    acf.newTimePicker = function ($input, args) {
      // bail ealry if no datepicker library
      if (typeof $.timepicker === 'undefined') {
        return false;
      } // defaults
  
  
      args = args || {}; // initialize
  
      $input.timepicker(args); // wrap the datepicker (only if it hasn't already been wrapped)
  
      if ($('body > #ui-datepicker-div').exists()) {
        $('body > #ui-datepicker-div').wrap('<div class="acf-ui-datepicker" />');
      }
    };
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-true-false.js":
  /*!*******************************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-field-true-false.js ***!
    \*******************************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    var Field = acf.Field.extend({
      type: 'true_false',
      events: {
        'change .acf-switch-input': 'onChange',
        'focus .acf-switch-input': 'onFocus',
        'blur .acf-switch-input': 'onBlur',
        'keypress .acf-switch-input': 'onKeypress'
      },
      $input: function () {
        return this.$('input[type="checkbox"]');
      },
      $switch: function () {
        return this.$('.acf-switch');
      },
      getValue: function () {
        return this.$input().prop('checked') ? 1 : 0;
      },
      initialize: function () {
        this.render();
      },
      render: function () {
        // vars
        var $switch = this.$switch(); // bail ealry if no $switch
  
        if (!$switch.length) return; // vars
  
        var $on = $switch.children('.acf-switch-on');
        var $off = $switch.children('.acf-switch-off');
        var width = Math.max($on.width(), $off.width()); // bail ealry if no width
  
        if (!width) return; // set widths
  
        $on.css('min-width', width);
        $off.css('min-width', width);
      },
      switchOn: function () {
        this.$input().prop('checked', true);
        this.$switch().addClass('-on');
      },
      switchOff: function () {
        this.$input().prop('checked', false);
        this.$switch().removeClass('-on');
      },
      onChange: function (e, $el) {
        if ($el.prop('checked')) {
          this.switchOn();
        } else {
          this.switchOff();
        }
      },
      onFocus: function (e, $el) {
        this.$switch().addClass('-focus');
      },
      onBlur: function (e, $el) {
        this.$switch().removeClass('-focus');
      },
      onKeypress: function (e, $el) {
        // left
        if (e.keyCode === 37) {
          return this.switchOff();
        } // right
  
  
        if (e.keyCode === 39) {
          return this.switchOn();
        }
      }
    });
    acf.registerFieldType(Field);
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-url.js":
  /*!************************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-field-url.js ***!
    \************************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    var Field = acf.Field.extend({
      type: 'url',
      events: {
        'keyup input[type="url"]': 'onkeyup'
      },
      $control: function () {
        return this.$('.acf-input-wrap');
      },
      $input: function () {
        return this.$('input[type="url"]');
      },
      initialize: function () {
        this.render();
      },
      isValid: function () {
        // vars
        var val = this.val(); // bail early if no val
  
        if (!val) {
          return false;
        } // url
  
  
        if (val.indexOf('://') !== -1) {
          return true;
        } // protocol relative url
  
  
        if (val.indexOf('//') === 0) {
          return true;
        } // return
  
  
        return false;
      },
      render: function () {
        // add class
        if (this.isValid()) {
          this.$control().addClass('-valid');
        } else {
          this.$control().removeClass('-valid');
        }
      },
      onkeyup: function (e, $el) {
        this.render();
      }
    });
    acf.registerFieldType(Field);
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-user.js":
  /*!*************************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-field-user.js ***!
    \*************************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    var Field = acf.models.SelectField.extend({
      type: 'user'
    });
    acf.registerFieldType(Field);
    acf.addFilter('select2_ajax_data', function (data, args, $input, field, select2) {
      if (!field) {
        return data;
      }
  
      const query_nonce = field.get('queryNonce');
  
      if (query_nonce && query_nonce.length) {
        data.user_query_nonce = query_nonce;
      }
  
      return data;
    });
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-wysiwyg.js":
  /*!****************************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-field-wysiwyg.js ***!
    \****************************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    var Field = acf.Field.extend({
      type: 'wysiwyg',
      wait: 'load',
      events: {
        'mousedown .acf-editor-wrap.delay': 'onMousedown',
        unmountField: 'disableEditor',
        remountField: 'enableEditor',
        removeField: 'disableEditor'
      },
      $control: function () {
        return this.$('.acf-editor-wrap');
      },
      $input: function () {
        return this.$('textarea');
      },
      getMode: function () {
        return this.$control().hasClass('tmce-active') ? 'visual' : 'text';
      },
      initialize: function () {
        // initializeEditor if no delay
        if (!this.$control().hasClass('delay')) {
          this.initializeEditor();
        }
      },
      initializeEditor: function () {
        // vars
        var $wrap = this.$control();
        var $textarea = this.$input();
        var args = {
          tinymce: true,
          quicktags: true,
          toolbar: this.get('toolbar'),
          mode: this.getMode(),
          field: this
        }; // generate new id
  
        var oldId = $textarea.attr('id');
        var newId = acf.uniqueId('acf-editor-'); // Backup textarea data.
  
        var inputData = $textarea.data();
        var inputVal = $textarea.val(); // rename
  
        acf.rename({
          target: $wrap,
          search: oldId,
          replace: newId,
          destructive: true
        }); // update id
  
        this.set('id', newId, true); // apply data to new textarea (acf.rename creates a new textarea element due to destructive mode)
        // fixes bug where conditional logic "disabled" is lost during "screen_check"
  
        this.$input().data(inputData).val(inputVal); // initialize
  
        acf.tinymce.initialize(newId, args);
      },
      onMousedown: function (e) {
        // prevent default
        e.preventDefault(); // remove delay class
  
        var $wrap = this.$control();
        $wrap.removeClass('delay');
        $wrap.find('.acf-editor-toolbar').remove(); // initialize
  
        this.initializeEditor();
      },
      enableEditor: function () {
        if (this.getMode() == 'visual') {
          acf.tinymce.enable(this.get('id'));
        }
      },
      disableEditor: function () {
        acf.tinymce.destroy(this.get('id'));
      }
    });
    acf.registerFieldType(Field);
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field.js":
  /*!********************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-field.js ***!
    \********************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    // vars
    var storage = [];
    /**
     *  acf.Field
     *
     *  description
     *
     *  @date	23/3/18
     *  @since	5.6.9
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
  
    acf.Field = acf.Model.extend({
      // field type
      type: '',
      // class used to avoid nested event triggers
      eventScope: '.acf-field',
      // initialize events on 'ready'
      wait: 'ready',
  
      /**
       *  setup
       *
       *  Called during the constructor function to setup this field ready for initialization
       *
       *  @date	8/5/18
       *  @since	5.6.9
       *
       *  @param	jQuery $field The field element.
       *  @return	void
       */
      setup: function ($field) {
        // set $el
        this.$el = $field; // inherit $field data
  
        this.inherit($field); // inherit controll data
  
        this.inherit(this.$control());
      },
  
      /**
       *  val
       *
       *  Sets or returns the field's value
       *
       *  @date	8/5/18
       *  @since	5.6.9
       *
       *  @param	mixed val Optional. The value to set
       *  @return	mixed
       */
      val: function (val) {
        // Set.
        if (val !== undefined) {
          return this.setValue(val); // Get.
        } else {
          return this.prop('disabled') ? null : this.getValue();
        }
      },
  
      /**
       *  getValue
       *
       *  returns the field's value
       *
       *  @date	8/5/18
       *  @since	5.6.9
       *
       *  @param	void
       *  @return	mixed
       */
      getValue: function () {
        return this.$input().val();
      },
  
      /**
       *  setValue
       *
       *  sets the field's value and returns true if changed
       *
       *  @date	8/5/18
       *  @since	5.6.9
       *
       *  @param	mixed val
       *  @return	boolean. True if changed.
       */
      setValue: function (val) {
        return acf.val(this.$input(), val);
      },
  
      /**
       *  __
       *
       *  i18n helper to be removed
       *
       *  @date	8/5/18
       *  @since	5.6.9
       *
       *  @param	type $var Description. Default.
       *  @return	type Description.
       */
      __: function (string) {
        return acf._e(this.type, string);
      },
  
      /**
       *  $control
       *
       *  returns the control jQuery element used for inheriting data. Uses this.control setting.
       *
       *  @date	8/5/18
       *  @since	5.6.9
       *
       *  @param	void
       *  @return	jQuery
       */
      $control: function () {
        return false;
      },
  
      /**
       *  $input
       *
       *  returns the input jQuery element used for saving values. Uses this.input setting.
       *
       *  @date	8/5/18
       *  @since	5.6.9
       *
       *  @param	void
       *  @return	jQuery
       */
      $input: function () {
        return this.$('[name]:first');
      },
  
      /**
       *  $inputWrap
       *
       *  description
       *
       *  @date	12/5/18
       *  @since	5.6.9
       *
       *  @param	type $var Description. Default.
       *  @return	type Description.
       */
      $inputWrap: function () {
        return this.$('.acf-input:first');
      },
  
      /**
       *  $inputWrap
       *
       *  description
       *
       *  @date	12/5/18
       *  @since	5.6.9
       *
       *  @param	type $var Description. Default.
       *  @return	type Description.
       */
      $labelWrap: function () {
        return this.$('.acf-label:first');
      },
  
      /**
       *  getInputName
       *
       *  Returns the field's input name
       *
       *  @date	8/5/18
       *  @since	5.6.9
       *
       *  @param	void
       *  @return	string
       */
      getInputName: function () {
        return this.$input().attr('name') || '';
      },
  
      /**
       *  parent
       *
       *  returns the field's parent field or false on failure.
       *
       *  @date	8/5/18
       *  @since	5.6.9
       *
       *  @param	void
       *  @return	object|false
       */
      parent: function () {
        // vars
        var parents = this.parents(); // return
  
        return parents.length ? parents[0] : false;
      },
  
      /**
       *  parents
       *
       *  description
       *
       *  @date	9/7/18
       *  @since	5.6.9
       *
       *  @param	type $var Description. Default.
       *  @return	type Description.
       */
      parents: function () {
        // vars
        var $parents = this.$el.parents('.acf-field'); // convert
  
        var parents = acf.getFields($parents); // return
  
        return parents;
      },
      show: function (lockKey, context) {
        // show field and store result
        var changed = acf.show(this.$el, lockKey); // do action if visibility has changed
  
        if (changed) {
          this.prop('hidden', false);
          acf.doAction('show_field', this, context);
        } // return
  
  
        return changed;
      },
      hide: function (lockKey, context) {
        // hide field and store result
        var changed = acf.hide(this.$el, lockKey); // do action if visibility has changed
  
        if (changed) {
          this.prop('hidden', true);
          acf.doAction('hide_field', this, context);
        } // return
  
  
        return changed;
      },
      enable: function (lockKey, context) {
        // enable field and store result
        var changed = acf.enable(this.$el, lockKey); // do action if disabled has changed
  
        if (changed) {
          this.prop('disabled', false);
          acf.doAction('enable_field', this, context);
        } // return
  
  
        return changed;
      },
      disable: function (lockKey, context) {
        // disabled field and store result
        var changed = acf.disable(this.$el, lockKey); // do action if disabled has changed
  
        if (changed) {
          this.prop('disabled', true);
          acf.doAction('disable_field', this, context);
        } // return
  
  
        return changed;
      },
      showEnable: function (lockKey, context) {
        // enable
        this.enable.apply(this, arguments); // show and return true if changed
  
        return this.show.apply(this, arguments);
      },
      hideDisable: function (lockKey, context) {
        // disable
        this.disable.apply(this, arguments); // hide and return true if changed
  
        return this.hide.apply(this, arguments);
      },
      showNotice: function (props) {
        // ensure object
        if (typeof props !== 'object') {
          props = {
            text: props
          };
        } // remove old notice
  
  
        if (this.notice) {
          this.notice.remove();
        } // create new notice
  
  
        props.target = this.$inputWrap();
        this.notice = acf.newNotice(props);
      },
      removeNotice: function (timeout) {
        if (this.notice) {
          this.notice.away(timeout || 0);
          this.notice = false;
        }
      },
      showError: function (message) {
        // add class
        this.$el.addClass('acf-error'); // add message
  
        if (message !== undefined) {
          this.showNotice({
            text: message,
            type: 'error',
            dismiss: false
          });
        } // action
  
  
        acf.doAction('invalid_field', this); // add event
  
        this.$el.one('focus change', 'input, select, textarea', $.proxy(this.removeError, this));
      },
      removeError: function () {
        // remove class
        this.$el.removeClass('acf-error'); // remove notice
  
        this.removeNotice(250); // action
  
        acf.doAction('valid_field', this);
      },
      trigger: function (name, args, bubbles) {
        // allow some events to bubble
        if (name == 'invalidField') {
          bubbles = true;
        } // return
  
  
        return acf.Model.prototype.trigger.apply(this, [name, args, bubbles]);
      }
    });
    /**
     *  newField
     *
     *  description
     *
     *  @date	14/12/17
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
  
    acf.newField = function ($field) {
      // vars
      var type = $field.data('type');
      var mid = modelId(type);
      var model = acf.models[mid] || acf.Field; // instantiate
  
      var field = new model($field); // actions
  
      acf.doAction('new_field', field); // return
  
      return field;
    };
    /**
     *  mid
     *
     *  Calculates the model ID for a field type
     *
     *  @date	15/12/17
     *  @since	5.6.5
     *
     *  @param	string type
     *  @return	string
     */
  
  
    var modelId = function (type) {
      return acf.strPascalCase(type || '') + 'Field';
    };
    /**
     *  registerFieldType
     *
     *  description
     *
     *  @date	14/12/17
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
  
  
    acf.registerFieldType = function (model) {
      // vars
      var proto = model.prototype;
      var type = proto.type;
      var mid = modelId(type); // store model
  
      acf.models[mid] = model; // store reference
  
      storage.push(type);
    };
    /**
     *  acf.getFieldType
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
  
  
    acf.getFieldType = function (type) {
      var mid = modelId(type);
      return acf.models[mid] || false;
    };
    /**
     *  acf.getFieldTypes
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
  
  
    acf.getFieldTypes = function (args) {
      // defaults
      args = acf.parseArgs(args, {
        category: '' // hasValue: true
  
      }); // clonse available types
  
      var types = []; // loop
  
      storage.map(function (type) {
        // vars
        var model = acf.getFieldType(type);
        var proto = model.prototype; // check operator
  
        if (args.category && proto.category !== args.category) {
          return;
        } // append
  
  
        types.push(model);
      }); // return
  
      return types;
    };
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-fields.js":
  /*!*********************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-fields.js ***!
    \*********************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    /**
     *  findFields
     *
     *  Returns a jQuery selection object of acf fields.
     *
     *  @date	14/12/17
     *  @since	5.6.5
     *
     *  @param	object $args {
     *		Optional. Arguments to find fields.
     *
     *		@type string			key			The field's key (data-attribute).
     *		@type string			name		The field's name (data-attribute).
     *		@type string			type		The field's type (data-attribute).
     *		@type string			is			jQuery selector to compare against.
     *		@type jQuery			parent		jQuery element to search within.
     *		@type jQuery			sibling		jQuery element to search alongside.
     *		@type limit				int			The number of fields to find.
     *		@type suppressFilters	bool		Whether to allow filters to add/remove results. Default behaviour will ignore clone fields.
     *  }
     *  @return	jQuery
     */
    acf.findFields = function (args) {
      // vars
      var selector = '.acf-field';
      var $fields = false; // args
  
      args = acf.parseArgs(args, {
        key: '',
        name: '',
        type: '',
        is: '',
        parent: false,
        sibling: false,
        limit: false,
        visible: false,
        suppressFilters: false
      }); // filter args
  
      if (!args.suppressFilters) {
        args = acf.applyFilters('find_fields_args', args);
      } // key
  
  
      if (args.key) {
        selector += '[data-key="' + args.key + '"]';
      } // type
  
  
      if (args.type) {
        selector += '[data-type="' + args.type + '"]';
      } // name
  
  
      if (args.name) {
        selector += '[data-name="' + args.name + '"]';
      } // is
  
  
      if (args.is) {
        selector += args.is;
      } // visibility
  
  
      if (args.visible) {
        selector += ':visible';
      } // query
  
  
      if (args.parent) {
        $fields = args.parent.find(selector);
      } else if (args.sibling) {
        $fields = args.sibling.siblings(selector);
      } else {
        $fields = $(selector);
      } // filter
  
  
      if (!args.suppressFilters) {
        $fields = $fields.not('.acf-clone .acf-field');
        $fields = acf.applyFilters('find_fields', $fields);
      } // limit
  
  
      if (args.limit) {
        $fields = $fields.slice(0, args.limit);
      } // return
  
  
      return $fields;
    };
    /**
     *  findField
     *
     *  Finds a specific field with jQuery
     *
     *  @date	14/12/17
     *  @since	5.6.5
     *
     *  @param	string key 		The field's key.
     *  @param	jQuery $parent	jQuery element to search within.
     *  @return	jQuery
     */
  
  
    acf.findField = function (key, $parent) {
      return acf.findFields({
        key: key,
        limit: 1,
        parent: $parent,
        suppressFilters: true
      });
    };
    /**
     *  getField
     *
     *  Returns a field instance
     *
     *  @date	14/12/17
     *  @since	5.6.5
     *
     *  @param	jQuery|string $field	jQuery element or field key.
     *  @return	object
     */
  
  
    acf.getField = function ($field) {
      // allow jQuery
      if ($field instanceof jQuery) {// find fields
      } else {
        $field = acf.findField($field);
      } // instantiate
  
  
      var field = $field.data('acf');
  
      if (!field) {
        field = acf.newField($field);
      } // return
  
  
      return field;
    };
    /**
     *  getFields
     *
     *  Returns multiple field instances
     *
     *  @date	14/12/17
     *  @since	5.6.5
     *
     *  @param	jQuery|object $fields	jQuery elements or query args.
     *  @return	array
     */
  
  
    acf.getFields = function ($fields) {
      // allow jQuery
      if ($fields instanceof jQuery) {// find fields
      } else {
        $fields = acf.findFields($fields);
      } // loop
  
  
      var fields = [];
      $fields.each(function () {
        var field = acf.getField($(this));
        fields.push(field);
      }); // return
  
      return fields;
    };
    /**
     *  findClosestField
     *
     *  Returns the closest jQuery field element
     *
     *  @date	9/4/18
     *  @since	5.6.9
     *
     *  @param	jQuery $el
     *  @return	jQuery
     */
  
  
    acf.findClosestField = function ($el) {
      return $el.closest('.acf-field');
    };
    /**
     *  getClosestField
     *
     *  Returns the closest field instance
     *
     *  @date	22/1/18
     *  @since	5.6.5
     *
     *  @param	jQuery $el
     *  @return	object
     */
  
  
    acf.getClosestField = function ($el) {
      var $field = acf.findClosestField($el);
      return this.getField($field);
    };
    /**
     *  addGlobalFieldAction
     *
     *  Sets up callback logic for global field actions
     *
     *  @date	15/6/18
     *  @since	5.6.9
     *
     *  @param	string action
     *  @return	void
     */
  
  
    var addGlobalFieldAction = function (action) {
      // vars
      var globalAction = action;
      var pluralAction = action + '_fields'; // ready_fields
  
      var singleAction = action + '_field'; // ready_field
      // global action
  
      var globalCallback = function ($el
      /*, arg1, arg2, etc*/
      ) {
        //console.log( action, arguments );
        // get args [$el, ...]
        var args = acf.arrayArgs(arguments);
        var extraArgs = args.slice(1); // find fields
  
        var fields = acf.getFields({
          parent: $el
        }); // check
  
        if (fields.length) {
          // pluralAction
          var pluralArgs = [pluralAction, fields].concat(extraArgs);
          acf.doAction.apply(null, pluralArgs);
        }
      }; // plural action
  
  
      var pluralCallback = function (fields
      /*, arg1, arg2, etc*/
      ) {
        //console.log( pluralAction, arguments );
        // get args [fields, ...]
        var args = acf.arrayArgs(arguments);
        var extraArgs = args.slice(1); // loop
  
        fields.map(function (field, i) {
          //setTimeout(function(){
          // singleAction
          var singleArgs = [singleAction, field].concat(extraArgs);
          acf.doAction.apply(null, singleArgs); //}, i * 100);
        });
      }; // add actions
  
  
      acf.addAction(globalAction, globalCallback);
      acf.addAction(pluralAction, pluralCallback); // also add single action
  
      addSingleFieldAction(action);
    };
    /**
     *  addSingleFieldAction
     *
     *  Sets up callback logic for single field actions
     *
     *  @date	15/6/18
     *  @since	5.6.9
     *
     *  @param	string action
     *  @return	void
     */
  
  
    var addSingleFieldAction = function (action) {
      // vars
      var singleAction = action + '_field'; // ready_field
  
      var singleEvent = action + 'Field'; // readyField
      // single action
  
      var singleCallback = function (field
      /*, arg1, arg2, etc*/
      ) {
        //console.log( singleAction, arguments );
        // get args [field, ...]
        var args = acf.arrayArgs(arguments);
        var extraArgs = args.slice(1); // action variations (ready_field/type=image)
  
        var variations = ['type', 'name', 'key'];
        variations.map(function (variation) {
          // vars
          var prefix = '/' + variation + '=' + field.get(variation); // singleAction
  
          args = [singleAction + prefix, field].concat(extraArgs);
          acf.doAction.apply(null, args);
        }); // event
  
        if (singleFieldEvents.indexOf(action) > -1) {
          field.trigger(singleEvent, extraArgs);
        }
      }; // add actions
  
  
      acf.addAction(singleAction, singleCallback);
    }; // vars
  
  
    var globalFieldActions = ['prepare', 'ready', 'load', 'append', 'remove', 'unmount', 'remount', 'sortstart', 'sortstop', 'show', 'hide', 'unload'];
    var singleFieldActions = ['valid', 'invalid', 'enable', 'disable', 'new', 'duplicate'];
    var singleFieldEvents = ['remove', 'unmount', 'remount', 'sortstart', 'sortstop', 'show', 'hide', 'unload', 'valid', 'invalid', 'enable', 'disable', 'duplicate']; // add
  
    globalFieldActions.map(addGlobalFieldAction);
    singleFieldActions.map(addSingleFieldAction);
    /**
     *  fieldsEventManager
     *
     *  Manages field actions and events
     *
     *  @date	15/12/17
     *  @since	5.6.5
     *
     *  @param	void
     *  @param	void
     */
  
    var fieldsEventManager = new acf.Model({
      id: 'fieldsEventManager',
      events: {
        'click .acf-field a[href="#"]': 'onClick',
        'change .acf-field': 'onChange'
      },
      onClick: function (e) {
        // prevent default of any link with an href of #
        e.preventDefault();
      },
      onChange: function () {
        // preview hack allows post to save with no title or content
        $('#_acf_changed').val(1);
      }
    });
    var duplicateFieldsManager = new acf.Model({
      id: 'duplicateFieldsManager',
      actions: {
        duplicate: 'onDuplicate',
        duplicate_fields: 'onDuplicateFields'
      },
      onDuplicate: function ($el, $el2) {
        var fields = acf.getFields({
          parent: $el
        });
  
        if (fields.length) {
          var $fields = acf.findFields({
            parent: $el2
          });
          acf.doAction('duplicate_fields', fields, $fields);
        }
      },
      onDuplicateFields: function (fields, duplicates) {
        fields.map(function (field, i) {
          acf.doAction('duplicate_field', field, $(duplicates[i]));
        });
      }
    });
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-helpers.js":
  /*!**********************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-helpers.js ***!
    \**********************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    /**
     *  refreshHelper
     *
     *  description
     *
     *  @date	1/7/18
     *  @since	5.6.9
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
    var refreshHelper = new acf.Model({
      priority: 90,
      actions: {
        new_field: 'refresh',
        show_field: 'refresh',
        hide_field: 'refresh',
        remove_field: 'refresh',
        unmount_field: 'refresh',
        remount_field: 'refresh'
      },
      refresh: function () {
        acf.refresh();
      }
    });
    /**
     * mountHelper
     *
     * Adds compatiblity for the 'unmount' and 'remount' actions added in 5.8.0
     *
     * @date	7/3/19
     * @since	5.7.14
     *
     * @param	void
     * @return	void
     */
  
    var mountHelper = new acf.Model({
      priority: 1,
      actions: {
        sortstart: 'onSortstart',
        sortstop: 'onSortstop'
      },
      onSortstart: function ($item) {
        acf.doAction('unmount', $item);
      },
      onSortstop: function ($item) {
        acf.doAction('remount', $item);
      }
    });
    /**
     *  sortableHelper
     *
     *  Adds compatibility for sorting a <tr> element
     *
     *  @date	6/3/18
     *  @since	5.6.9
     *
     *  @param	void
     *  @return	void
     */
  
    var sortableHelper = new acf.Model({
      actions: {
        sortstart: 'onSortstart'
      },
      onSortstart: function ($item, $placeholder) {
        // if $item is a tr, apply some css to the elements
        if ($item.is('tr')) {
          // replace $placeholder children with a single td
          // fixes "width calculation issues" due to conditional logic hiding some children
          $placeholder.html('<td style="padding:0;" colspan="' + $placeholder.children().length + '"></td>'); // add helper class to remove absolute positioning
  
          $item.addClass('acf-sortable-tr-helper'); // set fixed widths for children
  
          $item.children().each(function () {
            $(this).width($(this).width());
          }); // mimic height
  
          $placeholder.height($item.height() + 'px'); // remove class
  
          $item.removeClass('acf-sortable-tr-helper');
        }
      }
    });
    /**
     *  duplicateHelper
     *
     *  Fixes browser bugs when duplicating an element
     *
     *  @date	6/3/18
     *  @since	5.6.9
     *
     *  @param	void
     *  @return	void
     */
  
    var duplicateHelper = new acf.Model({
      actions: {
        after_duplicate: 'onAfterDuplicate'
      },
      onAfterDuplicate: function ($el, $el2) {
        // get original values
        var vals = [];
        $el.find('select').each(function (i) {
          vals.push($(this).val());
        }); // set duplicate values
  
        $el2.find('select').each(function (i) {
          $(this).val(vals[i]);
        });
      }
    });
    /**
     *  tableHelper
     *
     *  description
     *
     *  @date	6/3/18
     *  @since	5.6.9
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
  
    var tableHelper = new acf.Model({
      id: 'tableHelper',
      priority: 20,
      actions: {
        refresh: 'renderTables'
      },
      renderTables: function ($el) {
        // loop
        var self = this;
        $('.acf-table:visible').each(function () {
          self.renderTable($(this));
        });
      },
      renderTable: function ($table) {
        // vars
        var $ths = $table.find('> thead > tr:visible > th[data-key]');
        var $tds = $table.find('> tbody > tr:visible > td[data-key]'); // bail early if no thead
  
        if (!$ths.length || !$tds.length) {
          return false;
        } // visiblity
  
  
        $ths.each(function (i) {
          // vars
          var $th = $(this);
          var key = $th.data('key');
          var $cells = $tds.filter('[data-key="' + key + '"]');
          var $hidden = $cells.filter('.acf-hidden'); // always remove empty and allow cells to be hidden
  
          $cells.removeClass('acf-empty'); // hide $th if all cells are hidden
  
          if ($cells.length === $hidden.length) {
            acf.hide($th); // force all hidden cells to appear empty
          } else {
            acf.show($th);
            $hidden.addClass('acf-empty');
          }
        }); // clear width
  
        $ths.css('width', 'auto'); // get visible
  
        $ths = $ths.not('.acf-hidden'); // vars
  
        var availableWidth = 100;
        var colspan = $ths.length; // set custom widths first
  
        var $fixedWidths = $ths.filter('[data-width]');
        $fixedWidths.each(function () {
          var width = $(this).data('width');
          $(this).css('width', width + '%');
          availableWidth -= width;
        }); // set auto widths
  
        var $auoWidths = $ths.not('[data-width]');
  
        if ($auoWidths.length) {
          var width = availableWidth / $auoWidths.length;
          $auoWidths.css('width', width + '%');
          availableWidth = 0;
        } // avoid stretching issue
  
  
        if (availableWidth > 0) {
          $ths.last().css('width', 'auto');
        } // update colspan on collapsed
  
  
        $tds.filter('.-collapsed-target').each(function () {
          // vars
          var $td = $(this); // check if collapsed
  
          if ($td.parent().hasClass('-collapsed')) {
            $td.attr('colspan', $ths.length);
          } else {
            $td.removeAttr('colspan');
          }
        });
      }
    });
    /**
     *  fieldsHelper
     *
     *  description
     *
     *  @date	6/3/18
     *  @since	5.6.9
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
  
    var fieldsHelper = new acf.Model({
      id: 'fieldsHelper',
      priority: 30,
      actions: {
        refresh: 'renderGroups'
      },
      renderGroups: function () {
        // loop
        var self = this;
        $('.acf-fields:visible').each(function () {
          self.renderGroup($(this));
        });
      },
      renderGroup: function ($el) {
        // vars
        var top = 0;
        var height = 0;
        var $row = $(); // get fields
  
        var $fields = $el.children('.acf-field[data-width]:visible'); // bail early if no fields
  
        if (!$fields.length) {
          return false;
        } // bail ealry if is .-left
  
  
        if ($el.hasClass('-left')) {
          $fields.removeAttr('data-width');
          $fields.css('width', 'auto');
          return false;
        } // reset fields
  
  
        $fields.removeClass('-r0 -c0').css({
          'min-height': 0
        }); // loop
  
        $fields.each(function (i) {
          // vars
          var $field = $(this);
          var position = $field.position();
          var thisTop = Math.ceil(position.top);
          var thisLeft = Math.ceil(position.left); // detect change in row
  
          if ($row.length && thisTop > top) {
            // set previous heights
            $row.css({
              'min-height': height + 'px'
            }); // update position due to change in row above
  
            position = $field.position();
            thisTop = Math.ceil(position.top);
            thisLeft = Math.ceil(position.left); // reset vars
  
            top = 0;
            height = 0;
            $row = $();
          } // rtl
  
  
          if (acf.get('rtl')) {
            thisLeft = Math.ceil($field.parent().width() - (position.left + $field.outerWidth()));
          } // add classes
  
  
          if (thisTop == 0) {
            $field.addClass('-r0');
          } else if (thisLeft == 0) {
            $field.addClass('-c0');
          } // get height after class change
          // - add 1 for subpixel rendering
  
  
          var thisHeight = Math.ceil($field.outerHeight()) + 1; // set height
  
          height = Math.max(height, thisHeight); // set y
  
          top = Math.max(top, thisTop); // append
  
          $row = $row.add($field);
        }); // clean up
  
        if ($row.length) {
          $row.css({
            'min-height': height + 'px'
          });
        }
      }
    });
    /**
     * Adds a body class when holding down the "shift" key.
     *
     * @date	06/05/2020
     * @since	5.9.0
     */
  
    var bodyClassShiftHelper = new acf.Model({
      id: 'bodyClassShiftHelper',
      events: {
        keydown: 'onKeyDown',
        keyup: 'onKeyUp'
      },
      isShiftKey: function (e) {
        return e.keyCode === 16;
      },
      onKeyDown: function (e) {
        if (this.isShiftKey(e)) {
          $('body').addClass('acf-keydown-shift');
        }
      },
      onKeyUp: function (e) {
        if (this.isShiftKey(e)) {
          $('body').removeClass('acf-keydown-shift');
        }
      }
    });
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-media.js":
  /*!********************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-media.js ***!
    \********************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    /**
     *  acf.newMediaPopup
     *
     *  description
     *
     *  @date	10/1/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
    acf.newMediaPopup = function (args) {
      // args
      var popup = null;
      var args = acf.parseArgs(args, {
        mode: 'select',
        // 'select', 'edit'
        title: '',
        // 'Upload Image'
        button: '',
        // 'Select Image'
        type: '',
        // 'image', ''
        field: false,
        // field instance
        allowedTypes: '',
        // '.jpg, .png, etc'
        library: 'all',
        // 'all', 'uploadedTo'
        multiple: false,
        // false, true, 'add'
        attachment: 0,
        // the attachment to edit
        autoOpen: true,
        // open the popup automatically
        open: function () {},
        // callback after close
        select: function () {},
        // callback after select
        close: function () {} // callback after close
  
      }); // initialize
  
      if (args.mode == 'edit') {
        popup = new acf.models.EditMediaPopup(args);
      } else {
        popup = new acf.models.SelectMediaPopup(args);
      } // open popup (allow frame customization before opening)
  
  
      if (args.autoOpen) {
        setTimeout(function () {
          popup.open();
        }, 1);
      } // action
  
  
      acf.doAction('new_media_popup', popup); // return
  
      return popup;
    };
    /**
     *  getPostID
     *
     *  description
     *
     *  @date	10/1/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
  
  
    var getPostID = function () {
      var postID = acf.get('post_id');
      return acf.isNumeric(postID) ? postID : 0;
    };
    /**
     *  acf.getMimeTypes
     *
     *  description
     *
     *  @date	11/1/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
  
  
    acf.getMimeTypes = function () {
      return this.get('mimeTypes');
    };
  
    acf.getMimeType = function (name) {
      // vars
      var allTypes = acf.getMimeTypes(); // search
  
      if (allTypes[name] !== undefined) {
        return allTypes[name];
      } // some types contain a mixed key such as "jpg|jpeg|jpe"
  
  
      for (var key in allTypes) {
        if (key.indexOf(name) !== -1) {
          return allTypes[key];
        }
      } // return
  
  
      return false;
    };
    /**
     *  MediaPopup
     *
     *  description
     *
     *  @date	10/1/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
  
  
    var MediaPopup = acf.Model.extend({
      id: 'MediaPopup',
      data: {},
      defaults: {},
      frame: false,
      setup: function (props) {
        $.extend(this.data, props);
      },
      initialize: function () {
        // vars
        var options = this.getFrameOptions(); // add states
  
        this.addFrameStates(options); // create frame
  
        var frame = wp.media(options); // add args reference
  
        frame.acf = this; // add events
  
        this.addFrameEvents(frame, options); // strore frame
  
        this.frame = frame;
      },
      open: function () {
        this.frame.open();
      },
      close: function () {
        this.frame.close();
      },
      remove: function () {
        this.frame.detach();
        this.frame.remove();
      },
      getFrameOptions: function () {
        // vars
        var options = {
          title: this.get('title'),
          multiple: this.get('multiple'),
          library: {},
          states: []
        }; // type
  
        if (this.get('type')) {
          options.library.type = this.get('type');
        } // type
  
  
        if (this.get('library') === 'uploadedTo') {
          options.library.uploadedTo = getPostID();
        } // attachment
  
  
        if (this.get('attachment')) {
          options.library.post__in = [this.get('attachment')];
        } // button
  
  
        if (this.get('button')) {
          options.button = {
            text: this.get('button')
          };
        } // return
  
  
        return options;
      },
      addFrameStates: function (options) {
        // create query
        var Query = wp.media.query(options.library); // add _acfuploader
        // this is super wack!
        // if you add _acfuploader to the options.library args, new uploads will not be added to the library view.
        // this has been traced back to the wp.media.model.Query initialize function (which can't be overriden)
        // Adding any custom args will cause the Attahcments to not observe the uploader queue
        // To bypass this security issue, we add in the args AFTER the Query has been initialized
        // options.library._acfuploader = settings.field;
  
        if (this.get('field') && acf.isset(Query, 'mirroring', 'args')) {
          Query.mirroring.args._acfuploader = this.get('field');
        } // add states
  
  
        options.states.push( // main state
        new wp.media.controller.Library({
          library: Query,
          multiple: this.get('multiple'),
          title: this.get('title'),
          priority: 20,
          filterable: 'all',
          editable: true,
          allowLocalEdits: true
        })); // edit image functionality (added in WP 3.9)
  
        if (acf.isset(wp, 'media', 'controller', 'EditImage')) {
          options.states.push(new wp.media.controller.EditImage());
        }
      },
      addFrameEvents: function (frame, options) {
        // log all events
        //frame.on('all', function( e ) {
        //	console.log( 'frame all: %o', e );
        //});
        // add class
        frame.on('open', function () {
          this.$el.closest('.media-modal').addClass('acf-media-modal -' + this.acf.get('mode'));
        }, frame); // edit image view
        // source: media-views.js:2410 editImageContent()
  
        frame.on('content:render:edit-image', function () {
          var image = this.state().get('image');
          var view = new wp.media.view.EditImage({
            model: image,
            controller: this
          }).render();
          this.content.set(view); // after creating the wrapper view, load the actual editor via an ajax call
  
          view.loadEditor();
        }, frame); // update toolbar button
        //frame.on( 'toolbar:create:select', function( toolbar ) {
        //	toolbar.view = new wp.media.view.Toolbar.Select({
        //		text: frame.options._button,
        //		controller: this
        //	});
        //}, frame );
        // on select
  
        frame.on('select', function () {
          // vars
          var selection = frame.state().get('selection'); // if selecting images
  
          if (selection) {
            // loop
            selection.each(function (attachment, i) {
              frame.acf.get('select').apply(frame.acf, [attachment, i]);
            });
          }
        }); // on close
  
        frame.on('close', function () {
          // callback and remove
          setTimeout(function () {
            frame.acf.get('close').apply(frame.acf);
            frame.acf.remove();
          }, 1);
        });
      }
    });
    /**
     *  acf.models.SelectMediaPopup
     *
     *  description
     *
     *  @date	10/1/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
  
    acf.models.SelectMediaPopup = MediaPopup.extend({
      id: 'SelectMediaPopup',
      setup: function (props) {
        // default button
        if (!props.button) {
          props.button = acf._x('Select', 'verb');
        } // parent
  
  
        MediaPopup.prototype.setup.apply(this, arguments);
      },
      addFrameEvents: function (frame, options) {
        // plupload
        // adds _acfuploader param to validate uploads
        if (acf.isset(_wpPluploadSettings, 'defaults', 'multipart_params')) {
          // add _acfuploader so that Uploader will inherit
          _wpPluploadSettings.defaults.multipart_params._acfuploader = this.get('field'); // remove acf_field so future Uploaders won't inherit
  
          frame.on('open', function () {
            delete _wpPluploadSettings.defaults.multipart_params._acfuploader;
          });
        } // browse
  
  
        frame.on('content:activate:browse', function () {
          // vars
          var toolbar = false; // populate above vars making sure to allow for failure
          // perhaps toolbar does not exist because the frame open is Upload Files
  
          try {
            toolbar = frame.content.get().toolbar;
          } catch (e) {
            console.log(e);
            return;
          } // callback
  
  
          frame.acf.customizeFilters.apply(frame.acf, [toolbar]);
        }); // parent
  
        MediaPopup.prototype.addFrameEvents.apply(this, arguments);
      },
      customizeFilters: function (toolbar) {
        // vars
        var filters = toolbar.get('filters'); // image
  
        if (this.get('type') == 'image') {
          // update all
          filters.filters.all.text = acf.__('All images'); // remove some filters
  
          delete filters.filters.audio;
          delete filters.filters.video;
          delete filters.filters.image; // update all filters to show images
  
          $.each(filters.filters, function (i, filter) {
            filter.props.type = filter.props.type || 'image';
          });
        } // specific types
  
  
        if (this.get('allowedTypes')) {
          // convert ".jpg, .png" into ["jpg", "png"]
          var allowedTypes = this.get('allowedTypes').split(' ').join('').split('.').join('').split(','); // loop
  
          allowedTypes.map(function (name) {
            // get type
            var mimeType = acf.getMimeType(name); // bail early if no type
  
            if (!mimeType) return; // create new filter
  
            var newFilter = {
              text: mimeType,
              props: {
                status: null,
                type: mimeType,
                uploadedTo: null,
                orderby: 'date',
                order: 'DESC'
              },
              priority: 20
            }; // append
  
            filters.filters[mimeType] = newFilter;
          });
        } // uploaded to post
  
  
        if (this.get('library') === 'uploadedTo') {
          // vars
          var uploadedTo = this.frame.options.library.uploadedTo; // remove some filters
  
          delete filters.filters.unattached;
          delete filters.filters.uploaded; // add uploadedTo to filters
  
          $.each(filters.filters, function (i, filter) {
            filter.text += ' (' + acf.__('Uploaded to this post') + ')';
            filter.props.uploadedTo = uploadedTo;
          });
        } // add _acfuploader to filters
  
  
        var field = this.get('field');
        $.each(filters.filters, function (k, filter) {
          filter.props._acfuploader = field;
        }); // add _acfuplaoder to search
  
        var search = toolbar.get('search');
        search.model.attributes._acfuploader = field; // render (custom function added to prototype)
  
        if (filters.renderFilters) {
          filters.renderFilters();
        }
      }
    });
    /**
     *  acf.models.EditMediaPopup
     *
     *  description
     *
     *  @date	10/1/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
  
    acf.models.EditMediaPopup = MediaPopup.extend({
      id: 'SelectMediaPopup',
      setup: function (props) {
        // default button
        if (!props.button) {
          props.button = acf._x('Update', 'verb');
        } // parent
  
  
        MediaPopup.prototype.setup.apply(this, arguments);
      },
      addFrameEvents: function (frame, options) {
        // add class
        frame.on('open', function () {
          // add class
          this.$el.closest('.media-modal').addClass('acf-expanded'); // set to browse
  
          if (this.content.mode() != 'browse') {
            this.content.mode('browse');
          } // set selection
  
  
          var state = this.state();
          var selection = state.get('selection');
          var attachment = wp.media.attachment(frame.acf.get('attachment'));
          selection.add(attachment);
        }, frame); // parent
  
        MediaPopup.prototype.addFrameEvents.apply(this, arguments);
      }
    });
    /**
     *  customizePrototypes
     *
     *  description
     *
     *  @date	11/1/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
  
    var customizePrototypes = new acf.Model({
      id: 'customizePrototypes',
      wait: 'ready',
      initialize: function () {
        // bail early if no media views
        if (!acf.isset(window, 'wp', 'media', 'view')) {
          return;
        } // fix bug where CPT without "editor" does not set post.id setting which then prevents uploadedTo from working
  
  
        var postID = getPostID();
  
        if (postID && acf.isset(wp, 'media', 'view', 'settings', 'post')) {
          wp.media.view.settings.post.id = postID;
        } // customize
  
  
        this.customizeAttachmentsButton();
        this.customizeAttachmentsRouter();
        this.customizeAttachmentFilters();
        this.customizeAttachmentCompat();
        this.customizeAttachmentLibrary();
      },
      customizeAttachmentsButton: function () {
        // validate
        if (!acf.isset(wp, 'media', 'view', 'Button')) {
          return;
        } // Extend
  
  
        var Button = wp.media.view.Button;
        wp.media.view.Button = Button.extend({
          // Fix bug where "Select" button appears blank after editing an image.
          // Do this by simplifying Button initialize function and avoid deleting this.options.
          initialize: function () {
            var options = _.defaults(this.options, this.defaults);
  
            this.model = new Backbone.Model(options);
            this.listenTo(this.model, 'change', this.render);
          }
        });
      },
      customizeAttachmentsRouter: function () {
        // validate
        if (!acf.isset(wp, 'media', 'view', 'Router')) {
          return;
        } // vars
  
  
        var Parent = wp.media.view.Router; // extend
  
        wp.media.view.Router = Parent.extend({
          addExpand: function () {
            // vars
            var $a = $(['<a href="#" class="acf-expand-details">', '<span class="is-closed"><i class="acf-icon -left -small"></i>' + acf.__('Expand Details') + '</span>', '<span class="is-open"><i class="acf-icon -right -small"></i>' + acf.__('Collapse Details') + '</span>', '</a>'].join('')); // add events
  
            $a.on('click', function (e) {
              e.preventDefault();
              var $div = $(this).closest('.media-modal');
  
              if ($div.hasClass('acf-expanded')) {
                $div.removeClass('acf-expanded');
              } else {
                $div.addClass('acf-expanded');
              }
            }); // append
  
            this.$el.append($a);
          },
          initialize: function () {
            // initialize
            Parent.prototype.initialize.apply(this, arguments); // add buttons
  
            this.addExpand(); // return
  
            return this;
          }
        });
      },
      customizeAttachmentFilters: function () {
        // validate
        if (!acf.isset(wp, 'media', 'view', 'AttachmentFilters', 'All')) {
          return;
        } // vars
  
  
        var Parent = wp.media.view.AttachmentFilters.All; // renderFilters
        // copied from media-views.js:6939
  
        Parent.prototype.renderFilters = function () {
          // Build `<option>` elements.
          this.$el.html(_.chain(this.filters).map(function (filter, value) {
            return {
              el: $('<option></option>').val(value).html(filter.text)[0],
              priority: filter.priority || 50
            };
          }, this).sortBy('priority').pluck('el').value());
        };
      },
      customizeAttachmentCompat: function () {
        // validate
        if (!acf.isset(wp, 'media', 'view', 'AttachmentCompat')) {
          return;
        } // vars
  
  
        var AttachmentCompat = wp.media.view.AttachmentCompat;
        var timeout = false; // extend
  
        wp.media.view.AttachmentCompat = AttachmentCompat.extend({
          render: function () {
            // WP bug
            // When multiple media frames exist on the same page (WP content, WYSIWYG, image, file ),
            // WP creates multiple instances of this AttachmentCompat view.
            // Each instance will attempt to render when a new modal is created.
            // Use a property to avoid this and only render once per instance.
            if (this.rendered) {
              return this;
            } // render HTML
  
  
            AttachmentCompat.prototype.render.apply(this, arguments); // when uploading, render is called twice.
            // ignore first render by checking for #acf-form-data element
  
            if (!this.$('#acf-form-data').length) {
              return this;
            } // clear timeout
  
  
            clearTimeout(timeout); // setTimeout
  
            timeout = setTimeout($.proxy(function () {
              this.rendered = true;
              acf.doAction('append', this.$el);
            }, this), 50); // return
  
            return this;
          },
          save: function (event) {
            var data = {};
  
            if (event) {
              event.preventDefault();
            } //_.each( this.$el.serializeArray(), function( pair ) {
            //	data[ pair.name ] = pair.value;
            //});
            // Serialize data more thoroughly to allow chckbox inputs to save.
  
  
            data = acf.serializeForAjax(this.$el);
            this.controller.trigger('attachment:compat:waiting', ['waiting']);
            this.model.saveCompat(data).always(_.bind(this.postSave, this));
          }
        });
      },
      customizeAttachmentLibrary: function () {
        // validate
        if (!acf.isset(wp, 'media', 'view', 'Attachment', 'Library')) {
          return;
        } // vars
  
  
        var AttachmentLibrary = wp.media.view.Attachment.Library; // extend
  
        wp.media.view.Attachment.Library = AttachmentLibrary.extend({
          render: function () {
            // vars
            var popup = acf.isget(this, 'controller', 'acf');
            var attributes = acf.isget(this, 'model', 'attributes'); // check vars exist to avoid errors
  
            if (popup && attributes) {
              // show errors
              if (attributes.acf_errors) {
                this.$el.addClass('acf-disabled');
              } // disable selected
  
  
              var selected = popup.get('selected');
  
              if (selected && selected.indexOf(attributes.id) > -1) {
                this.$el.addClass('acf-selected');
              }
            } // render
  
  
            return AttachmentLibrary.prototype.render.apply(this, arguments);
          },
  
          /*
           *  toggleSelection
           *
           *  This function is called before an attachment is selected
           *  A good place to check for errors and prevent the 'select' function from being fired
           *
           *  @type	function
           *  @date	29/09/2016
           *  @since	5.4.0
           *
           *  @param	options (object)
           *  @return	n/a
           */
          toggleSelection: function (options) {
            // vars
            // source: wp-includes/js/media-views.js:2880
            var collection = this.collection,
                selection = this.options.selection,
                model = this.model,
                single = selection.single(); // vars
  
            var frame = this.controller;
            var errors = acf.isget(this, 'model', 'attributes', 'acf_errors');
            var $sidebar = frame.$el.find('.media-frame-content .media-sidebar'); // remove previous error
  
            $sidebar.children('.acf-selection-error').remove(); // show attachment details
  
            $sidebar.children().removeClass('acf-hidden'); // add message
  
            if (frame && errors) {
              // vars
              var filename = acf.isget(this, 'model', 'attributes', 'filename'); // hide attachment details
              // Gallery field continues to show previously selected attachment...
  
              $sidebar.children().addClass('acf-hidden'); // append message
  
              $sidebar.prepend(['<div class="acf-selection-error">', '<span class="selection-error-label">' + acf.__('Restricted') + '</span>', '<span class="selection-error-filename">' + filename + '</span>', '<span class="selection-error-message">' + errors + '</span>', '</div>'].join('')); // reset selection (unselects all attachments)
  
              selection.reset(); // set single (attachment displayed in sidebar)
  
              selection.single(model); // return and prevent 'select' form being fired
  
              return;
            } // return
  
  
            return AttachmentLibrary.prototype.toggleSelection.apply(this, arguments);
          }
        });
      }
    });
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-postbox.js":
  /*!**********************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-postbox.js ***!
    \**********************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    /**
     * postboxManager
     *
     * Manages postboxes on the screen.
     *
     * @date	25/5/19
     * @since	5.8.1
     *
     * @param	void
     * @return	void
     */
    var postboxManager = new acf.Model({
      wait: 'prepare',
      priority: 1,
      initialize: function () {
        (acf.get('postboxes') || []).map(acf.newPostbox);
      }
    });
    /**
     *  acf.getPostbox
     *
     *  Returns a postbox instance.
     *
     *  @date	23/9/18
     *  @since	5.7.7
     *
     *  @param	mixed $el Either a jQuery element or the postbox id.
     *  @return	object
     */
  
    acf.getPostbox = function ($el) {
      // allow string parameter
      if (typeof arguments[0] == 'string') {
        $el = $('#' + arguments[0]);
      } // return instance
  
  
      return acf.getInstance($el);
    };
    /**
     *  acf.getPostboxes
     *
     *  Returns an array of postbox instances.
     *
     *  @date	23/9/18
     *  @since	5.7.7
     *
     *  @param	void
     *  @return	array
     */
  
  
    acf.getPostboxes = function () {
      return acf.getInstances($('.acf-postbox'));
    };
    /**
     *  acf.newPostbox
     *
     *  Returns a new postbox instance for the given props.
     *
     *  @date	20/9/18
     *  @since	5.7.6
     *
     *  @param	object props The postbox properties.
     *  @return	object
     */
  
  
    acf.newPostbox = function (props) {
      return new acf.models.Postbox(props);
    };
    /**
     *  acf.models.Postbox
     *
     *  The postbox model.
     *
     *  @date	20/9/18
     *  @since	5.7.6
     *
     *  @param	void
     *  @return	void
     */
  
  
    acf.models.Postbox = acf.Model.extend({
      data: {
        id: '',
        key: '',
        style: 'default',
        label: 'top',
        edit: ''
      },
      setup: function (props) {
        // compatibilty
        if (props.editLink) {
          props.edit = props.editLink;
        } // extend data
  
  
        $.extend(this.data, props); // set $el
  
        this.$el = this.$postbox();
      },
      $postbox: function () {
        return $('#' + this.get('id'));
      },
      $hide: function () {
        return $('#' + this.get('id') + '-hide');
      },
      $hideLabel: function () {
        return this.$hide().parent();
      },
      $hndle: function () {
        return this.$('> .hndle');
      },
      $handleActions: function () {
        return this.$('> .postbox-header .handle-actions');
      },
      $inside: function () {
        return this.$('> .inside');
      },
      isVisible: function () {
        return this.$el.hasClass('acf-hidden');
      },
      isHiddenByScreenOptions: function () {
        return this.$el.hasClass('hide-if-js') || this.$el.css('display') == 'none';
      },
      initialize: function () {
        // Add default class.
        this.$el.addClass('acf-postbox'); // Add field group style class (ignore in block editor).
  
        if (acf.get('editor') !== 'block') {
          var style = this.get('style');
  
          if (style !== 'default') {
            this.$el.addClass(style);
          }
        } // Add .inside class.
  
  
        this.$inside().addClass('acf-fields').addClass('-' + this.get('label')); // Append edit link.
  
        var edit = this.get('edit');
  
        if (edit) {
          var html = '<a href="' + edit + '" class="dashicons dashicons-admin-generic acf-hndle-cog acf-js-tooltip" title="' + acf.__('Edit field group') + '"></a>';
          var $handleActions = this.$handleActions();
  
          if ($handleActions.length) {
            $handleActions.prepend(html);
          } else {
            this.$hndle().append(html);
          }
        } // Show postbox.
  
  
        this.show();
      },
      show: function () {
        // If disabled by screen options, set checked to false and return.
        if (this.$el.hasClass('hide-if-js')) {
          this.$hide().prop('checked', false);
          return;
        } // Show label.
  
  
        this.$hideLabel().show(); // toggle on checkbox
  
        this.$hide().prop('checked', true); // Show postbox
  
        this.$el.show().removeClass('acf-hidden'); // Do action.
  
        acf.doAction('show_postbox', this);
      },
      enable: function () {
        acf.enable(this.$el, 'postbox');
      },
      showEnable: function () {
        this.enable();
        this.show();
      },
      hide: function () {
        // Hide label.
        this.$hideLabel().hide(); // Hide postbox
  
        this.$el.hide().addClass('acf-hidden'); // Do action.
  
        acf.doAction('hide_postbox', this);
      },
      disable: function () {
        acf.disable(this.$el, 'postbox');
      },
      hideDisable: function () {
        this.disable();
        this.hide();
      },
      html: function (html) {
        // Update HTML.
        this.$inside().html(html); // Do action.
  
        acf.doAction('append', this.$el);
      }
    });
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-screen.js":
  /*!*********************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-screen.js ***!
    \*********************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    acf.screen = new acf.Model({
      active: true,
      xhr: false,
      timeout: false,
      wait: 'load',
      events: {
        'change #page_template': 'onChange',
        'change #parent_id': 'onChange',
        'change #post-formats-select': 'onChange',
        'change .categorychecklist': 'onChange',
        'change .tagsdiv': 'onChange',
        'change .acf-taxonomy-field[data-save="1"]': 'onChange',
        'change #product-type': 'onChange'
      },
      isPost: function () {
        return acf.get('screen') === 'post';
      },
      isUser: function () {
        return acf.get('screen') === 'user';
      },
      isTaxonomy: function () {
        return acf.get('screen') === 'taxonomy';
      },
      isAttachment: function () {
        return acf.get('screen') === 'attachment';
      },
      isNavMenu: function () {
        return acf.get('screen') === 'nav_menu';
      },
      isWidget: function () {
        return acf.get('screen') === 'widget';
      },
      isComment: function () {
        return acf.get('screen') === 'comment';
      },
      getPageTemplate: function () {
        var $el = $('#page_template');
        return $el.length ? $el.val() : null;
      },
      getPageParent: function (e, $el) {
        var $el = $('#parent_id');
        return $el.length ? $el.val() : null;
      },
      getPageType: function (e, $el) {
        return this.getPageParent() ? 'child' : 'parent';
      },
      getPostType: function () {
        return $('#post_type').val();
      },
      getPostFormat: function (e, $el) {
        var $el = $('#post-formats-select input:checked');
  
        if ($el.length) {
          var val = $el.val();
          return val == '0' ? 'standard' : val;
        }
  
        return null;
      },
      getPostCoreTerms: function () {
        // vars
        var terms = {}; // serialize WP taxonomy postboxes
  
        var data = acf.serialize($('.categorydiv, .tagsdiv')); // use tax_input (tag, custom-taxonomy) when possible.
        // this data is already formatted in taxonomy => [terms].
  
        if (data.tax_input) {
          terms = data.tax_input;
        } // append "category" which uses a different name
  
  
        if (data.post_category) {
          terms.category = data.post_category;
        } // convert any string values (tags) into array format
  
  
        for (var tax in terms) {
          if (!acf.isArray(terms[tax])) {
            terms[tax] = terms[tax].split(/,[\s]?/);
          }
        } // return
  
  
        return terms;
      },
      getPostTerms: function () {
        // Get core terms.
        var terms = this.getPostCoreTerms(); // loop over taxonomy fields and add their values
  
        acf.getFields({
          type: 'taxonomy'
        }).map(function (field) {
          // ignore fields that don't save
          if (!field.get('save')) {
            return;
          } // vars
  
  
          var val = field.val();
          var tax = field.get('taxonomy'); // check val
  
          if (val) {
            // ensure terms exists
            terms[tax] = terms[tax] || []; // ensure val is an array
  
            val = acf.isArray(val) ? val : [val]; // append
  
            terms[tax] = terms[tax].concat(val);
          }
        }); // add WC product type
  
        if ((productType = this.getProductType()) !== null) {
          terms.product_type = [productType];
        } // remove duplicate values
  
  
        for (var tax in terms) {
          terms[tax] = acf.uniqueArray(terms[tax]);
        } // return
  
  
        return terms;
      },
      getProductType: function () {
        var $el = $('#product-type');
        return $el.length ? $el.val() : null;
      },
      check: function () {
        // bail early if not for post
        if (acf.get('screen') !== 'post') {
          return;
        } // abort XHR if is already loading AJAX data
  
  
        if (this.xhr) {
          this.xhr.abort();
        } // vars
  
  
        var ajaxData = acf.parseArgs(this.data, {
          action: 'acf/ajax/check_screen',
          screen: acf.get('screen'),
          exists: []
        }); // post id
  
        if (this.isPost()) {
          ajaxData.post_id = acf.get('post_id');
        } // post type
  
  
        if ((postType = this.getPostType()) !== null) {
          ajaxData.post_type = postType;
        } // page template
  
  
        if ((pageTemplate = this.getPageTemplate()) !== null) {
          ajaxData.page_template = pageTemplate;
        } // page parent
  
  
        if ((pageParent = this.getPageParent()) !== null) {
          ajaxData.page_parent = pageParent;
        } // page type
  
  
        if ((pageType = this.getPageType()) !== null) {
          ajaxData.page_type = pageType;
        } // post format
  
  
        if ((postFormat = this.getPostFormat()) !== null) {
          ajaxData.post_format = postFormat;
        } // post terms
  
  
        if ((postTerms = this.getPostTerms()) !== null) {
          ajaxData.post_terms = postTerms;
        } // add array of existing postboxes to increase performance and reduce JSON HTML
  
  
        acf.getPostboxes().map(function (postbox) {
          ajaxData.exists.push(postbox.get('key'));
        }); // filter
  
        ajaxData = acf.applyFilters('check_screen_args', ajaxData); // success
  
        var onSuccess = function (json) {
          // Render post screen.
          if (acf.get('screen') == 'post') {
            this.renderPostScreen(json); // Render user screen.
          } else if (acf.get('screen') == 'user') {
            this.renderUserScreen(json);
          } // action
  
  
          acf.doAction('check_screen_complete', json, ajaxData);
        }; // ajax
  
  
        this.xhr = $.ajax({
          url: acf.get('ajaxurl'),
          data: acf.prepareForAjax(ajaxData),
          type: 'post',
          dataType: 'json',
          context: this,
          success: onSuccess
        });
      },
      onChange: function (e, $el) {
        this.setTimeout(this.check, 1);
      },
      renderPostScreen: function (data) {
        // Helper function to copy events
        var copyEvents = function ($from, $to) {
          var events = $._data($from[0]).events;
  
          for (var type in events) {
            for (var i = 0; i < events[type].length; i++) {
              $to.on(type, events[type][i].handler);
            }
          }
        }; // Helper function to sort metabox.
  
  
        var sortMetabox = function (id, ids) {
          // Find position of id within ids.
          var index = ids.indexOf(id); // Bail early if index not found.
  
          if (index == -1) {
            return false;
          } // Loop over metaboxes behind (in reverse order).
  
  
          for (var i = index - 1; i >= 0; i--) {
            if ($('#' + ids[i]).length) {
              return $('#' + ids[i]).after($('#' + id));
            }
          } // Loop over metaboxes infront.
  
  
          for (var i = index + 1; i < ids.length; i++) {
            if ($('#' + ids[i]).length) {
              return $('#' + ids[i]).before($('#' + id));
            }
          } // Return false if not sorted.
  
  
          return false;
        }; // Keep track of visible and hidden postboxes.
  
  
        data.visible = [];
        data.hidden = []; // Show these postboxes.
  
        data.results = data.results.map(function (result, i) {
          // vars
          var postbox = acf.getPostbox(result.id); // Prevent "acf_after_title" position in Block Editor.
  
          if (acf.isGutenberg() && result.position == 'acf_after_title') {
            result.position = 'normal';
          } // Create postbox if doesn't exist.
  
  
          if (!postbox) {
            var wpMinorVersion = parseFloat(acf.get('wp_version'));
  
            if (wpMinorVersion >= 5.5) {
              var postboxHeader = ['<div class="postbox-header">', '<h2 class="hndle ui-sortable-handle">', '<span>' + acf.escHtml(result.title) + '</span>', '</h2>', '<div class="handle-actions hide-if-no-js">', '<button type="button" class="handlediv" aria-expanded="true">', '<span class="screen-reader-text">Toggle panel: ' + acf.escHtml(result.title) + '</span>', '<span class="toggle-indicator" aria-hidden="true"></span>', '</button>', '</div>', '</div>'].join('');
            } else {
              var postboxHeader = ['<button type="button" class="handlediv" aria-expanded="true">', '<span class="screen-reader-text">Toggle panel: ' + acf.escHtml(result.title) + '</span>', '<span class="toggle-indicator" aria-hidden="true"></span>', '</button>', '<h2 class="hndle ui-sortable-handle">', '<span>' + acf.escHtml(result.title) + '</span>', '</h2>'].join('');
            } // Ensure result.classes is set.
  
  
            if (!result.classes) result.classes = ''; // Create it.
  
            var $postbox = $(['<div id="' + result.id + '" class="postbox ' + result.classes + '">', postboxHeader, '<div class="inside">', result.html, '</div>', '</div>'].join('')); // Create new hide toggle.
  
            if ($('#adv-settings').length) {
              var $prefs = $('#adv-settings .metabox-prefs');
              var $label = $(['<label for="' + result.id + '-hide">', '<input class="hide-postbox-tog" name="' + result.id + '-hide" type="checkbox" id="' + result.id + '-hide" value="' + result.id + '" checked="checked">', ' ' + result.title, '</label>'].join('')); // Copy default WP events onto checkbox.
  
              copyEvents($prefs.find('input').first(), $label.find('input')); // Append hide label
  
              $prefs.append($label);
            } // Copy default WP events onto metabox.
  
  
            if ($('.postbox').length) {
              copyEvents($('.postbox .handlediv').first(), $postbox.children('.handlediv'));
              copyEvents($('.postbox .hndle').first(), $postbox.children('.hndle'));
            } // Append metabox to the bottom of "side-sortables".
  
  
            if (result.position === 'side') {
              $('#' + result.position + '-sortables').append($postbox); // Prepend metabox to the top of "normal-sortbables".
            } else {
              $('#' + result.position + '-sortables').prepend($postbox);
            } // Position metabox amongst existing ACF metaboxes within the same location.
  
  
            var order = [];
            data.results.map(function (_result) {
              if (result.position === _result.position && $('#' + result.position + '-sortables #' + _result.id).length) {
                order.push(_result.id);
              }
            });
            sortMetabox(result.id, order); // Check 'sorted' for user preference.
  
            if (data.sorted) {
              // Loop over each position (acf_after_title, side, normal).
              for (var position in data.sorted) {
                // Explode string into array of ids.
                var order = data.sorted[position].split(','); // Position metabox relative to order.
  
                if (sortMetabox(result.id, order)) {
                  break;
                }
              }
            } // Initalize it (modifies HTML).
  
  
            postbox = acf.newPostbox(result); // Trigger action.
  
            acf.doAction('append', $postbox);
            acf.doAction('append_postbox', postbox);
          } // show postbox
  
  
          postbox.showEnable(); // append
  
          data.visible.push(result.id); // Return result (may have changed).
  
          return result;
        }); // Hide these postboxes.
  
        acf.getPostboxes().map(function (postbox) {
          if (data.visible.indexOf(postbox.get('id')) === -1) {
            // Hide postbox.
            postbox.hideDisable(); // Append to data.
  
            data.hidden.push(postbox.get('id'));
          }
        }); // Update style.
  
        $('#acf-style').html(data.style); // Do action.
  
        acf.doAction('refresh_post_screen', data);
      },
      renderUserScreen: function (json) {}
    });
    /**
     *  gutenScreen
     *
     *  Adds compatibility with the Gutenberg edit screen.
     *
     *  @date	11/12/18
     *  @since	5.8.0
     *
     *  @param	void
     *  @return	void
     */
  
    var gutenScreen = new acf.Model({
      // Keep a reference to the most recent post attributes.
      postEdits: {},
      // Wait until assets have been loaded.
      wait: 'prepare',
      initialize: function () {
        // Bail early if not Gutenberg.
        if (!acf.isGutenberg()) {
          return;
        } // Listen for changes (use debounced version as this can fires often).
  
  
        wp.data.subscribe(acf.debounce(this.onChange).bind(this)); // Customize "acf.screen.get" functions.
  
        acf.screen.getPageTemplate = this.getPageTemplate;
        acf.screen.getPageParent = this.getPageParent;
        acf.screen.getPostType = this.getPostType;
        acf.screen.getPostFormat = this.getPostFormat;
        acf.screen.getPostCoreTerms = this.getPostCoreTerms; // Disable unload
  
        acf.unload.disable(); // Refresh metaboxes since WP 5.3.
  
        var wpMinorVersion = parseFloat(acf.get('wp_version'));
  
        if (wpMinorVersion >= 5.3) {
          this.addAction('refresh_post_screen', this.onRefreshPostScreen);
        } // Trigger "refresh" after WP has moved metaboxes into place.
  
  
        wp.domReady(acf.refresh);
      },
      onChange: function () {
        // Determine attributes that can trigger a refresh.
        var attributes = ['template', 'parent', 'format']; // Append taxonomy attribute names to this list.
  
        (wp.data.select('core').getTaxonomies() || []).map(function (taxonomy) {
          attributes.push(taxonomy.rest_base);
        }); // Get relevant current post edits.
  
        var _postEdits = wp.data.select('core/editor').getPostEdits();
  
        var postEdits = {};
        attributes.map(function (k) {
          if (_postEdits[k] !== undefined) {
            postEdits[k] = _postEdits[k];
          }
        }); // Detect change.
  
        if (JSON.stringify(postEdits) !== JSON.stringify(this.postEdits)) {
          this.postEdits = postEdits; // Check screen.
  
          acf.screen.check();
        }
      },
      getPageTemplate: function () {
        return wp.data.select('core/editor').getEditedPostAttribute('template');
      },
      getPageParent: function (e, $el) {
        return wp.data.select('core/editor').getEditedPostAttribute('parent');
      },
      getPostType: function () {
        return wp.data.select('core/editor').getEditedPostAttribute('type');
      },
      getPostFormat: function (e, $el) {
        return wp.data.select('core/editor').getEditedPostAttribute('format');
      },
      getPostCoreTerms: function () {
        // vars
        var terms = {}; // Loop over taxonomies.
  
        var taxonomies = wp.data.select('core').getTaxonomies() || [];
        taxonomies.map(function (taxonomy) {
          // Append selected taxonomies to terms object.
          var postTerms = wp.data.select('core/editor').getEditedPostAttribute(taxonomy.rest_base);
  
          if (postTerms) {
            terms[taxonomy.slug] = postTerms;
          }
        }); // return
  
        return terms;
      },
  
      /**
       * onRefreshPostScreen
       *
       * Fires after the Post edit screen metaboxs are refreshed to update the Block Editor API state.
       *
       * @date	11/11/19
       * @since	5.8.7
       *
       * @param	object data The "check_screen" JSON response data.
       * @return	void
       */
      onRefreshPostScreen: function (data) {
        // Extract vars.
        var select = wp.data.select('core/edit-post');
        var dispatch = wp.data.dispatch('core/edit-post'); // Load current metabox locations and data.
  
        var locations = {};
        select.getActiveMetaBoxLocations().map(function (location) {
          locations[location] = select.getMetaBoxesPerLocation(location);
        }); // Generate flat array of existing ids.
  
        var ids = [];
  
        for (var k in locations) {
          locations[k].map(function (m) {
            ids.push(m.id);
          });
        } // Append new ACF metaboxes (ignore those which already exist).
  
  
        data.results.filter(function (r) {
          return ids.indexOf(r.id) === -1;
        }).map(function (result, i) {
          // Ensure location exists.
          var location = result.position;
          locations[location] = locations[location] || []; // Append.
  
          locations[location].push({
            id: result.id,
            title: result.title
          });
        }); // Remove hidden ACF metaboxes.
  
        for (var k in locations) {
          locations[k] = locations[k].filter(function (m) {
            return data.hidden.indexOf(m.id) === -1;
          });
        } // Update state.
  
  
        dispatch.setAvailableMetaBoxesPerLocation(locations);
      }
    });
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-select2.js":
  /*!**********************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-select2.js ***!
    \**********************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    /**
     *  acf.newSelect2
     *
     *  description
     *
     *  @date	13/1/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
    acf.newSelect2 = function ($select, props) {
      // defaults
      props = acf.parseArgs(props, {
        allowNull: false,
        placeholder: '',
        multiple: false,
        field: false,
        ajax: false,
        ajaxAction: '',
        ajaxData: function (data) {
          return data;
        },
        ajaxResults: function (json) {
          return json;
        }
      }); // initialize
  
      if (getVersion() == 4) {
        var select2 = new Select2_4($select, props);
      } else {
        var select2 = new Select2_3($select, props);
      } // actions
  
  
      acf.doAction('new_select2', select2); // return
  
      return select2;
    };
    /**
     *  getVersion
     *
     *  description
     *
     *  @date	13/1/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
  
  
    function getVersion() {
      // v4
      if (acf.isset(window, 'jQuery', 'fn', 'select2', 'amd')) {
        return 4;
      } // v3
  
  
      if (acf.isset(window, 'Select2')) {
        return 3;
      } // return
  
  
      return false;
    }
    /**
     *  Select2
     *
     *  description
     *
     *  @date	13/1/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
  
  
    var Select2 = acf.Model.extend({
      setup: function ($select, props) {
        $.extend(this.data, props);
        this.$el = $select;
      },
      initialize: function () {},
      selectOption: function (value) {
        var $option = this.getOption(value);
  
        if (!$option.prop('selected')) {
          $option.prop('selected', true).trigger('change');
        }
      },
      unselectOption: function (value) {
        var $option = this.getOption(value);
  
        if ($option.prop('selected')) {
          $option.prop('selected', false).trigger('change');
        }
      },
      getOption: function (value) {
        return this.$('option[value="' + value + '"]');
      },
      addOption: function (option) {
        // defaults
        option = acf.parseArgs(option, {
          id: '',
          text: '',
          selected: false
        }); // vars
  
        var $option = this.getOption(option.id); // append
  
        if (!$option.length) {
          $option = $('<option></option>');
          $option.html(option.text);
          $option.attr('value', option.id);
          $option.prop('selected', option.selected);
          this.$el.append($option);
        } // chain
  
  
        return $option;
      },
      getValue: function () {
        // vars
        var val = [];
        var $options = this.$el.find('option:selected'); // bail early if no selected
  
        if (!$options.exists()) {
          return val;
        } // sort by attribute
  
  
        $options = $options.sort(function (a, b) {
          return +a.getAttribute('data-i') - +b.getAttribute('data-i');
        }); // loop
  
        $options.each(function () {
          var $el = $(this);
          val.push({
            $el: $el,
            id: $el.attr('value'),
            text: $el.text()
          });
        }); // return
  
        return val;
      },
      mergeOptions: function () {},
      getChoices: function () {
        // callback
        var crawl = function ($parent) {
          // vars
          var choices = []; // loop
  
          $parent.children().each(function () {
            // vars
            var $child = $(this); // optgroup
  
            if ($child.is('optgroup')) {
              choices.push({
                text: $child.attr('label'),
                children: crawl($child)
              }); // option
            } else {
              choices.push({
                id: $child.attr('value'),
                text: $child.text()
              });
            }
          }); // return
  
          return choices;
        }; // crawl
  
  
        return crawl(this.$el);
      },
      getAjaxData: function (params) {
        // vars
        var ajaxData = {
          action: this.get('ajaxAction'),
          s: params.term || '',
          paged: params.page || 1
        }; // field helper
  
        var field = this.get('field');
  
        if (field) {
          ajaxData.field_key = field.get('key');
        } // callback
  
  
        var callback = this.get('ajaxData');
  
        if (callback) {
          ajaxData = callback.apply(this, [ajaxData, params]);
        } // filter
  
  
        ajaxData = acf.applyFilters('select2_ajax_data', ajaxData, this.data, this.$el, field || false, this); // return
  
        return acf.prepareForAjax(ajaxData);
      },
      getAjaxResults: function (json, params) {
        // defaults
        json = acf.parseArgs(json, {
          results: false,
          more: false
        }); // callback
  
        var callback = this.get('ajaxResults');
  
        if (callback) {
          json = callback.apply(this, [json, params]);
        } // filter
  
  
        json = acf.applyFilters('select2_ajax_results', json, params, this); // return
  
        return json;
      },
      processAjaxResults: function (json, params) {
        // vars
        var json = this.getAjaxResults(json, params); // change more to pagination
  
        if (json.more) {
          json.pagination = {
            more: true
          };
        } // merge together groups
  
  
        setTimeout($.proxy(this.mergeOptions, this), 1); // return
  
        return json;
      },
      destroy: function () {
        // destroy via api
        if (this.$el.data('select2')) {
          this.$el.select2('destroy');
        } // destory via HTML (duplicating HTML does not contain data)
  
  
        this.$el.siblings('.select2-container').remove();
      }
    });
    /**
     *  Select2_4
     *
     *  description
     *
     *  @date	13/1/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
  
    var Select2_4 = Select2.extend({
      initialize: function () {
        // vars
        var $select = this.$el;
        var options = {
          width: '100%',
          allowClear: this.get('allowNull'),
          placeholder: this.get('placeholder'),
          multiple: this.get('multiple'),
          data: [],
          escapeMarkup: function (markup) {
            if (typeof markup !== 'string') {
              return markup;
            }
  
            return acf.escHtml(markup);
          }
        }; // Only use the template if SelectWoo is not loaded to work around https://github.com/woocommerce/woocommerce/pull/30473
  
        if (!acf.isset(window, 'jQuery', 'fn', 'selectWoo')) {
          options.templateSelection = function (selection) {
            var $selection = $('<span class="acf-selection"></span>');
            $selection.html(acf.escHtml(selection.text));
            $selection.data('element', selection.element);
            return $selection;
          };
        } // multiple
  
  
        if (options.multiple) {
          // reorder options
          this.getValue().map(function (item) {
            item.$el.detach().appendTo($select);
          });
        } // Temporarily remove conflicting attribute.
  
  
        var attrAjax = $select.attr('data-ajax');
  
        if (attrAjax !== undefined) {
          $select.removeData('ajax');
          $select.removeAttr('data-ajax');
        } // ajax
  
  
        if (this.get('ajax')) {
          options.ajax = {
            url: acf.get('ajaxurl'),
            delay: 250,
            dataType: 'json',
            type: 'post',
            cache: false,
            data: $.proxy(this.getAjaxData, this),
            processResults: $.proxy(this.processAjaxResults, this)
          };
        } // filter for 3rd party customization
        //options = acf.applyFilters( 'select2_args', options, $select, this );
  
  
        var field = this.get('field');
        options = acf.applyFilters('select2_args', options, $select, this.data, field || false, this); // add select2
  
        $select.select2(options); // get container (Select2 v4 does not return this from constructor)
  
        var $container = $select.next('.select2-container'); // multiple
  
        if (options.multiple) {
          // vars
          var $ul = $container.find('ul'); // sortable
  
          $ul.sortable({
            stop: function (e) {
              // loop
              $ul.find('.select2-selection__choice').each(function () {
                // Attempt to use .data if it exists (select2 version < 4.0.6) or use our template data instead.
                if ($(this).data('data')) {
                  var $option = $($(this).data('data').element);
                } else {
                  var $option = $($(this).find('span.acf-selection').data('element'));
                } // detach and re-append to end
  
  
                $option.detach().appendTo($select);
              }); // trigger change on input (JS error if trigger on select)
  
              $select.trigger('change');
            }
          }); // on select, move to end
  
          $select.on('select2:select', this.proxy(function (e) {
            this.getOption(e.params.data.id).detach().appendTo(this.$el);
          }));
        } // add handler to auto-focus searchbox (for jQuery 3.6)
  
  
        $select.on('select2:open', () => {
          $('.select2-container--open .select2-search__field').get(-1).focus();
        }); // add class
  
        $container.addClass('-acf'); // Add back temporarily removed attr.
  
        if (attrAjax !== undefined) {
          $select.attr('data-ajax', attrAjax);
        } // action for 3rd party customization
  
  
        acf.doAction('select2_init', $select, options, this.data, field || false, this);
      },
      mergeOptions: function () {
        // vars
        var $prevOptions = false;
        var $prevGroup = false; // loop
  
        $('.select2-results__option[role="group"]').each(function () {
          // vars
          var $options = $(this).children('ul');
          var $group = $(this).children('strong'); // compare to previous
  
          if ($prevGroup && $prevGroup.text() === $group.text()) {
            $prevOptions.append($options.children());
            $(this).remove();
            return;
          } // update vars
  
  
          $prevOptions = $options;
          $prevGroup = $group;
        });
      }
    });
    /**
     *  Select2_3
     *
     *  description
     *
     *  @date	13/1/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
  
    var Select2_3 = Select2.extend({
      initialize: function () {
        // vars
        var $select = this.$el;
        var value = this.getValue();
        var multiple = this.get('multiple');
        var options = {
          width: '100%',
          allowClear: this.get('allowNull'),
          placeholder: this.get('placeholder'),
          separator: '||',
          multiple: this.get('multiple'),
          data: this.getChoices(),
          escapeMarkup: function (string) {
            return acf.escHtml(string);
          },
          dropdownCss: {
            'z-index': '999999999'
          },
          initSelection: function (element, callback) {
            if (multiple) {
              callback(value);
            } else {
              callback(value.shift());
            }
          }
        }; // get hidden input
  
        var $input = $select.siblings('input');
  
        if (!$input.length) {
          $input = $('<input type="hidden" />');
          $select.before($input);
        } // set input value
  
  
        inputValue = value.map(function (item) {
          return item.id;
        }).join('||');
        $input.val(inputValue); // multiple
  
        if (options.multiple) {
          // reorder options
          value.map(function (item) {
            item.$el.detach().appendTo($select);
          });
        } // remove blank option as we have a clear all button
  
  
        if (options.allowClear) {
          options.data = options.data.filter(function (item) {
            return item.id !== '';
          });
        } // remove conflicting atts
  
  
        $select.removeData('ajax');
        $select.removeAttr('data-ajax'); // ajax
  
        if (this.get('ajax')) {
          options.ajax = {
            url: acf.get('ajaxurl'),
            quietMillis: 250,
            dataType: 'json',
            type: 'post',
            cache: false,
            data: $.proxy(this.getAjaxData, this),
            results: $.proxy(this.processAjaxResults, this)
          };
        } // filter for 3rd party customization
  
  
        var field = this.get('field');
        options = acf.applyFilters('select2_args', options, $select, this.data, field || false, this); // add select2
  
        $input.select2(options); // get container
  
        var $container = $input.select2('container'); // helper to find this select's option
  
        var getOption = $.proxy(this.getOption, this); // multiple
  
        if (options.multiple) {
          // vars
          var $ul = $container.find('ul'); // sortable
  
          $ul.sortable({
            stop: function () {
              // loop
              $ul.find('.select2-search-choice').each(function () {
                // vars
                var data = $(this).data('select2Data');
                var $option = getOption(data.id); // detach and re-append to end
  
                $option.detach().appendTo($select);
              }); // trigger change on input (JS error if trigger on select)
  
              $select.trigger('change');
            }
          });
        } // on select, create option and move to end
  
  
        $input.on('select2-selecting', function (e) {
          // vars
          var item = e.choice;
          var $option = getOption(item.id); // create if doesn't exist
  
          if (!$option.length) {
            $option = $('<option value="' + item.id + '">' + item.text + '</option>');
          } // detach and re-append to end
  
  
          $option.detach().appendTo($select);
        }); // add class
  
        $container.addClass('-acf'); // action for 3rd party customization
  
        acf.doAction('select2_init', $select, options, this.data, field || false, this); // change
  
        $input.on('change', function () {
          var val = $input.val();
  
          if (val.indexOf('||')) {
            val = val.split('||');
          }
  
          $select.val(val).trigger('change');
        }); // hide select
  
        $select.hide();
      },
      mergeOptions: function () {
        // vars
        var $prevOptions = false;
        var $prevGroup = false; // loop
  
        $('#select2-drop .select2-result-with-children').each(function () {
          // vars
          var $options = $(this).children('ul');
          var $group = $(this).children('.select2-result-label'); // compare to previous
  
          if ($prevGroup && $prevGroup.text() === $group.text()) {
            $prevGroup.append($options.children());
            $(this).remove();
            return;
          } // update vars
  
  
          $prevOptions = $options;
          $prevGroup = $group;
        });
      },
      getAjaxData: function (term, page) {
        // create Select2 v4 params
        var params = {
          term: term,
          page: page
        }; // filter
  
        var field = this.get('field');
        params = acf.applyFilters('select2_ajax_data', params, this.data, this.$el, field || false, this); // return
  
        return Select2.prototype.getAjaxData.apply(this, [params]);
      }
    }); // manager
  
    var select2Manager = new acf.Model({
      priority: 5,
      wait: 'prepare',
      actions: {
        duplicate: 'onDuplicate'
      },
      initialize: function () {
        // vars
        var locale = acf.get('locale');
        var rtl = acf.get('rtl');
        var l10n = acf.get('select2L10n');
        var version = getVersion(); // bail ealry if no l10n
  
        if (!l10n) {
          return false;
        } // bail early if 'en'
  
  
        if (locale.indexOf('en') === 0) {
          return false;
        } // initialize
  
  
        if (version == 4) {
          this.addTranslations4();
        } else if (version == 3) {
          this.addTranslations3();
        }
      },
      addTranslations4: function () {
        // vars
        var l10n = acf.get('select2L10n');
        var locale = acf.get('locale'); // modify local to match html[lang] attribute (used by Select2)
  
        locale = locale.replace('_', '-'); // select2L10n
  
        var select2L10n = {
          errorLoading: function () {
            return l10n.load_fail;
          },
          inputTooLong: function (args) {
            var overChars = args.input.length - args.maximum;
  
            if (overChars > 1) {
              return l10n.input_too_long_n.replace('%d', overChars);
            }
  
            return l10n.input_too_long_1;
          },
          inputTooShort: function (args) {
            var remainingChars = args.minimum - args.input.length;
  
            if (remainingChars > 1) {
              return l10n.input_too_short_n.replace('%d', remainingChars);
            }
  
            return l10n.input_too_short_1;
          },
          loadingMore: function () {
            return l10n.load_more;
          },
          maximumSelected: function (args) {
            var maximum = args.maximum;
  
            if (maximum > 1) {
              return l10n.selection_too_long_n.replace('%d', maximum);
            }
  
            return l10n.selection_too_long_1;
          },
          noResults: function () {
            return l10n.matches_0;
          },
          searching: function () {
            return l10n.searching;
          }
        }; // append
  
        jQuery.fn.select2.amd.define('select2/i18n/' + locale, [], function () {
          return select2L10n;
        });
      },
      addTranslations3: function () {
        // vars
        var l10n = acf.get('select2L10n');
        var locale = acf.get('locale'); // modify local to match html[lang] attribute (used by Select2)
  
        locale = locale.replace('_', '-'); // select2L10n
  
        var select2L10n = {
          formatMatches: function (matches) {
            if (matches > 1) {
              return l10n.matches_n.replace('%d', matches);
            }
  
            return l10n.matches_1;
          },
          formatNoMatches: function () {
            return l10n.matches_0;
          },
          formatAjaxError: function () {
            return l10n.load_fail;
          },
          formatInputTooShort: function (input, min) {
            var remainingChars = min - input.length;
  
            if (remainingChars > 1) {
              return l10n.input_too_short_n.replace('%d', remainingChars);
            }
  
            return l10n.input_too_short_1;
          },
          formatInputTooLong: function (input, max) {
            var overChars = input.length - max;
  
            if (overChars > 1) {
              return l10n.input_too_long_n.replace('%d', overChars);
            }
  
            return l10n.input_too_long_1;
          },
          formatSelectionTooBig: function (maximum) {
            if (maximum > 1) {
              return l10n.selection_too_long_n.replace('%d', maximum);
            }
  
            return l10n.selection_too_long_1;
          },
          formatLoadMore: function () {
            return l10n.load_more;
          },
          formatSearching: function () {
            return l10n.searching;
          }
        }; // ensure locales exists
  
        $.fn.select2.locales = $.fn.select2.locales || {}; // append
  
        $.fn.select2.locales[locale] = select2L10n;
        $.extend($.fn.select2.defaults, select2L10n);
      },
      onDuplicate: function ($el, $el2) {
        $el2.find('.select2-container').remove();
      }
    });
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-tinymce.js":
  /*!**********************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-tinymce.js ***!
    \**********************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    acf.tinymce = {
      /*
       *  defaults
       *
       *  This function will return default mce and qt settings
       *
       *  @type	function
       *  @date	18/8/17
       *  @since	5.6.0
       *
       *  @param	$post_id (int)
       *  @return	$post_id (int)
       */
      defaults: function () {
        // bail early if no tinyMCEPreInit
        if (typeof tinyMCEPreInit === 'undefined') return false; // vars
  
        var defaults = {
          tinymce: tinyMCEPreInit.mceInit.acf_content,
          quicktags: tinyMCEPreInit.qtInit.acf_content
        }; // return
  
        return defaults;
      },
  
      /*
       *  initialize
       *
       *  This function will initialize the tinymce and quicktags instances
       *
       *  @type	function
       *  @date	18/8/17
       *  @since	5.6.0
       *
       *  @param	$post_id (int)
       *  @return	$post_id (int)
       */
      initialize: function (id, args) {
        // defaults
        args = acf.parseArgs(args, {
          tinymce: true,
          quicktags: true,
          toolbar: 'full',
          mode: 'visual',
          // visual,text
          field: false
        }); // tinymce
  
        if (args.tinymce) {
          this.initializeTinymce(id, args);
        } // quicktags
  
  
        if (args.quicktags) {
          this.initializeQuicktags(id, args);
        }
      },
  
      /*
       *  initializeTinymce
       *
       *  This function will initialize the tinymce instance
       *
       *  @type	function
       *  @date	18/8/17
       *  @since	5.6.0
       *
       *  @param	$post_id (int)
       *  @return	$post_id (int)
       */
      initializeTinymce: function (id, args) {
        // vars
        var $textarea = $('#' + id);
        var defaults = this.defaults();
        var toolbars = acf.get('toolbars');
        var field = args.field || false;
        var $field = field.$el || false; // bail early
  
        if (typeof tinymce === 'undefined') return false;
        if (!defaults) return false; // check if exists
  
        if (tinymce.get(id)) {
          return this.enable(id);
        } // settings
  
  
        var init = $.extend({}, defaults.tinymce, args.tinymce);
        init.id = id;
        init.selector = '#' + id; // toolbar
  
        var toolbar = args.toolbar;
  
        if (toolbar && toolbars && toolbars[toolbar]) {
          for (var i = 1; i <= 4; i++) {
            init['toolbar' + i] = toolbars[toolbar][i] || '';
          }
        } // event
  
  
        init.setup = function (ed) {
          ed.on('change', function (e) {
            ed.save(); // save to textarea
  
            $textarea.trigger('change');
          }); // Fix bug where Gutenberg does not hear "mouseup" event and tries to select multiple blocks.
  
          ed.on('mouseup', function (e) {
            var event = new MouseEvent('mouseup');
            window.dispatchEvent(event);
          }); // Temporarily comment out. May not be necessary due to wysiwyg field actions.
          //ed.on('unload', function(e) {
          //	acf.tinymce.remove( id );
          //});
        }; // disable wp_autoresize_on (no solution yet for fixed toolbar)
  
  
        init.wp_autoresize_on = false; // Enable wpautop allowing value to save without <p> tags.
        // Only if the "TinyMCE Advanced" plugin hasn't already set this functionality.
  
        if (!init.tadv_noautop) {
          init.wpautop = true;
        } // hook for 3rd party customization
  
  
        init = acf.applyFilters('wysiwyg_tinymce_settings', init, id, field); // z-index fix (caused too many conflicts)
        //if( acf.isset(tinymce,'ui','FloatPanel') ) {
        //	tinymce.ui.FloatPanel.zIndex = 900000;
        //}
        // store settings
  
        tinyMCEPreInit.mceInit[id] = init; // visual tab is active
  
        if (args.mode == 'visual') {
          // init
          var result = tinymce.init(init); // get editor
  
          var ed = tinymce.get(id); // validate
  
          if (!ed) {
            return false;
          } // add reference
  
  
          ed.acf = args.field; // action
  
          acf.doAction('wysiwyg_tinymce_init', ed, ed.id, init, field);
        }
      },
  
      /*
       *  initializeQuicktags
       *
       *  This function will initialize the quicktags instance
       *
       *  @type	function
       *  @date	18/8/17
       *  @since	5.6.0
       *
       *  @param	$post_id (int)
       *  @return	$post_id (int)
       */
      initializeQuicktags: function (id, args) {
        // vars
        var defaults = this.defaults(); // bail early
  
        if (typeof quicktags === 'undefined') return false;
        if (!defaults) return false; // settings
  
        var init = $.extend({}, defaults.quicktags, args.quicktags);
        init.id = id; // filter
  
        var field = args.field || false;
        var $field = field.$el || false;
        init = acf.applyFilters('wysiwyg_quicktags_settings', init, init.id, field); // store settings
  
        tinyMCEPreInit.qtInit[id] = init; // init
  
        var ed = quicktags(init); // validate
  
        if (!ed) {
          return false;
        } // generate HTML
  
  
        this.buildQuicktags(ed); // action for 3rd party customization
  
        acf.doAction('wysiwyg_quicktags_init', ed, ed.id, init, field);
      },
  
      /*
       *  buildQuicktags
       *
       *  This function will build the quicktags HTML
       *
       *  @type	function
       *  @date	18/8/17
       *  @since	5.6.0
       *
       *  @param	$post_id (int)
       *  @return	$post_id (int)
       */
      buildQuicktags: function (ed) {
        var canvas,
            name,
            settings,
            theButtons,
            html,
            ed,
            id,
            i,
            use,
            instanceId,
            defaults = ',strong,em,link,block,del,ins,img,ul,ol,li,code,more,close,';
        canvas = ed.canvas;
        name = ed.name;
        settings = ed.settings;
        html = '';
        theButtons = {};
        use = '';
        instanceId = ed.id; // set buttons
  
        if (settings.buttons) {
          use = ',' + settings.buttons + ',';
        }
  
        for (i in edButtons) {
          if (!edButtons[i]) {
            continue;
          }
  
          id = edButtons[i].id;
  
          if (use && defaults.indexOf(',' + id + ',') !== -1 && use.indexOf(',' + id + ',') === -1) {
            continue;
          }
  
          if (!edButtons[i].instance || edButtons[i].instance === instanceId) {
            theButtons[id] = edButtons[i];
  
            if (edButtons[i].html) {
              html += edButtons[i].html(name + '_');
            }
          }
        }
  
        if (use && use.indexOf(',dfw,') !== -1) {
          theButtons.dfw = new QTags.DFWButton();
          html += theButtons.dfw.html(name + '_');
        }
  
        if ('rtl' === document.getElementsByTagName('html')[0].dir) {
          theButtons.textdirection = new QTags.TextDirectionButton();
          html += theButtons.textdirection.html(name + '_');
        }
  
        ed.toolbar.innerHTML = html;
        ed.theButtons = theButtons;
  
        if (typeof jQuery !== 'undefined') {
          jQuery(document).triggerHandler('quicktags-init', [ed]);
        }
      },
      disable: function (id) {
        this.destroyTinymce(id);
      },
      remove: function (id) {
        this.destroyTinymce(id);
      },
      destroy: function (id) {
        this.destroyTinymce(id);
      },
      destroyTinymce: function (id) {
        // bail early
        if (typeof tinymce === 'undefined') return false; // get editor
  
        var ed = tinymce.get(id); // bail early if no editor
  
        if (!ed) return false; // save
  
        ed.save(); // destroy editor
  
        ed.destroy(); // return
  
        return true;
      },
      enable: function (id) {
        this.enableTinymce(id);
      },
      enableTinymce: function (id) {
        // bail early
        if (typeof switchEditors === 'undefined') return false; // bail ealry if not initialized
  
        if (typeof tinyMCEPreInit.mceInit[id] === 'undefined') return false; // Ensure textarea element is visible
        // - Fixes bug in block editor when switching between "Block" and "Document" tabs.
  
        $('#' + id).show(); // toggle
  
        switchEditors.go(id, 'tmce'); // return
  
        return true;
      }
    };
    var editorManager = new acf.Model({
      // hook in before fieldsEventManager, conditions, etc
      priority: 5,
      actions: {
        prepare: 'onPrepare',
        ready: 'onReady'
      },
      onPrepare: function () {
        // find hidden editor which may exist within a field
        var $div = $('#acf-hidden-wp-editor'); // move to footer
  
        if ($div.exists()) {
          $div.appendTo('body');
        }
      },
      onReady: function () {
        // Restore wp.editor functions used by tinymce removed in WP5.
        if (acf.isset(window, 'wp', 'oldEditor')) {
          wp.editor.autop = wp.oldEditor.autop;
          wp.editor.removep = wp.oldEditor.removep;
        } // bail early if no tinymce
  
  
        if (!acf.isset(window, 'tinymce', 'on')) return; // restore default activeEditor
  
        tinymce.on('AddEditor', function (data) {
          // vars
          var editor = data.editor; // bail early if not 'acf'
  
          if (editor.id.substr(0, 3) !== 'acf') return; // override if 'content' exists
  
          editor = tinymce.editors.content || editor; // update vars
  
          tinymce.activeEditor = editor;
          wpActiveEditor = editor.id;
        });
      }
    });
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-unload.js":
  /*!*********************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-unload.js ***!
    \*********************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    acf.unload = new acf.Model({
      wait: 'load',
      active: true,
      changed: false,
      actions: {
        validation_failure: 'startListening',
        validation_success: 'stopListening'
      },
      events: {
        'change form .acf-field': 'startListening',
        'submit form': 'stopListening'
      },
      enable: function () {
        this.active = true;
      },
      disable: function () {
        this.active = false;
      },
      reset: function () {
        this.stopListening();
      },
      startListening: function () {
        // bail ealry if already changed, not active
        if (this.changed || !this.active) {
          return;
        } // update
  
  
        this.changed = true; // add event
  
        $(window).on('beforeunload', this.onUnload);
      },
      stopListening: function () {
        // update
        this.changed = false; // remove event
  
        $(window).off('beforeunload', this.onUnload);
      },
      onUnload: function () {
        return acf.__('The changes you made will be lost if you navigate away from this page');
      }
    });
  })(jQuery);
  
  /***/ }),
  
  /***/ "./src/advanced-custom-fields-pro/assets/src/js/_acf-validation.js":
  /*!*************************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/_acf-validation.js ***!
    \*************************************************************************/
  /***/ (function() {
  
  (function ($, undefined) {
    /**
     *  Validator
     *
     *  The model for validating forms
     *
     *  @date	4/9/18
     *  @since	5.7.5
     *
     *  @param	void
     *  @return	void
     */
    var Validator = acf.Model.extend({
      /** @var string The model identifier. */
      id: 'Validator',
  
      /** @var object The model data. */
      data: {
        /** @var array The form errors. */
        errors: [],
  
        /** @var object The form notice. */
        notice: null,
  
        /** @var string The form status. loading, invalid, valid */
        status: ''
      },
  
      /** @var object The model events. */
      events: {
        'changed:status': 'onChangeStatus'
      },
  
      /**
       *  addErrors
       *
       *  Adds errors to the form.
       *
       *  @date	4/9/18
       *  @since	5.7.5
       *
       *  @param	array errors An array of errors.
       *  @return	void
       */
      addErrors: function (errors) {
        errors.map(this.addError, this);
      },
  
      /**
       *  addError
       *
       *  Adds and error to the form.
       *
       *  @date	4/9/18
       *  @since	5.7.5
       *
       *  @param	object error An error object containing input and message.
       *  @return	void
       */
      addError: function (error) {
        this.data.errors.push(error);
      },
  
      /**
       *  hasErrors
       *
       *  Returns true if the form has errors.
       *
       *  @date	4/9/18
       *  @since	5.7.5
       *
       *  @param	void
       *  @return	bool
       */
      hasErrors: function () {
        return this.data.errors.length;
      },
  
      /**
       *  clearErrors
       *
       *  Removes any errors.
       *
       *  @date	4/9/18
       *  @since	5.7.5
       *
       *  @param	void
       *  @return	void
       */
      clearErrors: function () {
        return this.data.errors = [];
      },
  
      /**
       *  getErrors
       *
       *  Returns the forms errors.
       *
       *  @date	4/9/18
       *  @since	5.7.5
       *
       *  @param	void
       *  @return	array
       */
      getErrors: function () {
        return this.data.errors;
      },
  
      /**
       *  getFieldErrors
       *
       *  Returns the forms field errors.
       *
       *  @date	4/9/18
       *  @since	5.7.5
       *
       *  @param	void
       *  @return	array
       */
      getFieldErrors: function () {
        // vars
        var errors = [];
        var inputs = []; // loop
  
        this.getErrors().map(function (error) {
          // bail early if global
          if (!error.input) return; // update if exists
  
          var i = inputs.indexOf(error.input);
  
          if (i > -1) {
            errors[i] = error; // update
          } else {
            errors.push(error);
            inputs.push(error.input);
          }
        }); // return
  
        return errors;
      },
  
      /**
       *  getGlobalErrors
       *
       *  Returns the forms global errors (errors without a specific input).
       *
       *  @date	4/9/18
       *  @since	5.7.5
       *
       *  @param	void
       *  @return	array
       */
      getGlobalErrors: function () {
        // return array of errors that contain no input
        return this.getErrors().filter(function (error) {
          return !error.input;
        });
      },
  
      /**
       *  showErrors
       *
       *  Displays all errors for this form.
       *
       *  @date	4/9/18
       *  @since	5.7.5
       *
       *  @param	void
       *  @return	void
       */
      showErrors: function () {
        // bail early if no errors
        if (!this.hasErrors()) {
          return;
        } // vars
  
  
        var fieldErrors = this.getFieldErrors();
        var globalErrors = this.getGlobalErrors(); // vars
  
        var errorCount = 0;
        var $scrollTo = false; // loop
  
        fieldErrors.map(function (error) {
          // get input
          var $input = this.$('[name="' + error.input + '"]').first(); // if $_POST value was an array, this $input may not exist
  
          if (!$input.length) {
            $input = this.$('[name^="' + error.input + '"]').first();
          } // bail early if input doesn't exist
  
  
          if (!$input.length) {
            return;
          } // increase
  
  
          errorCount++; // get field
  
          var field = acf.getClosestField($input); // make sure the postbox containing this field is not hidden by screen options
  
          ensureFieldPostBoxIsVisible(field.$el); // show error
  
          field.showError(error.message); // set $scrollTo
  
          if (!$scrollTo) {
            $scrollTo = field.$el;
          }
        }, this); // errorMessage
  
        var errorMessage = acf.__('Validation failed');
  
        globalErrors.map(function (error) {
          errorMessage += '. ' + error.message;
        });
  
        if (errorCount == 1) {
          errorMessage += '. ' + acf.__('1 field requires attention');
        } else if (errorCount > 1) {
          errorMessage += '. ' + acf.__('%d fields require attention').replace('%d', errorCount);
        } // notice
  
  
        if (this.has('notice')) {
          this.get('notice').update({
            type: 'error',
            text: errorMessage
          });
        } else {
          var notice = acf.newNotice({
            type: 'error',
            text: errorMessage,
            target: this.$el
          });
          this.set('notice', notice);
        } // if no $scrollTo, set to message
  
  
        if (!$scrollTo) {
          $scrollTo = this.get('notice').$el;
        } // timeout
  
  
        setTimeout(function () {
          $('html, body').animate({
            scrollTop: $scrollTo.offset().top - $(window).height() / 2
          }, 500);
        }, 10);
      },
  
      /**
       *  onChangeStatus
       *
       *  Update the form class when changing the 'status' data
       *
       *  @date	4/9/18
       *  @since	5.7.5
       *
       *  @param	object e The event object.
       *  @param	jQuery $el The form element.
       *  @param	string value The new status.
       *  @param	string prevValue The old status.
       *  @return	void
       */
      onChangeStatus: function (e, $el, value, prevValue) {
        this.$el.removeClass('is-' + prevValue).addClass('is-' + value);
      },
  
      /**
       *  validate
       *
       *  Vaildates the form via AJAX.
       *
       *  @date	4/9/18
       *  @since	5.7.5
       *
       *  @param	object args A list of settings to customize the validation process.
       *  @return	bool True if the form is valid.
       */
      validate: function (args) {
        // default args
        args = acf.parseArgs(args, {
          // trigger event
          event: false,
          // reset the form after submit
          reset: false,
          // loading callback
          loading: function () {},
          // complete callback
          complete: function () {},
          // failure callback
          failure: function () {},
          // success callback
          success: function ($form) {
            $form.submit();
          }
        }); // return true if is valid - allows form submit
  
        if (this.get('status') == 'valid') {
          return true;
        } // return false if is currently validating - prevents form submit
  
  
        if (this.get('status') == 'validating') {
          return false;
        } // return true if no ACF fields exist (no need to validate)
  
  
        if (!this.$('.acf-field').length) {
          return true;
        } // if event is provided, create a new success callback.
  
  
        if (args.event) {
          var event = $.Event(null, args.event);
  
          args.success = function () {
            acf.enableSubmit($(event.target)).trigger(event);
          };
        } // action for 3rd party
  
  
        acf.doAction('validation_begin', this.$el); // lock form
  
        acf.lockForm(this.$el); // loading callback
  
        args.loading(this.$el, this); // update status
  
        this.set('status', 'validating'); // success callback
  
        var onSuccess = function (json) {
          // validate
          if (!acf.isAjaxSuccess(json)) {
            return;
          } // filter
  
  
          var data = acf.applyFilters('validation_complete', json.data, this.$el, this); // add errors
  
          if (!data.valid) {
            this.addErrors(data.errors);
          }
        }; // complete
  
  
        var onComplete = function () {
          // unlock form
          acf.unlockForm(this.$el); // failure
  
          if (this.hasErrors()) {
            // update status
            this.set('status', 'invalid'); // action
  
            acf.doAction('validation_failure', this.$el, this); // display errors
  
            this.showErrors(); // failure callback
  
            args.failure(this.$el, this); // success
          } else {
            // update status
            this.set('status', 'valid'); // remove previous error message
  
            if (this.has('notice')) {
              this.get('notice').update({
                type: 'success',
                text: acf.__('Validation successful'),
                timeout: 1000
              });
            } // action
  
  
            acf.doAction('validation_success', this.$el, this);
            acf.doAction('submit', this.$el); // success callback (submit form)
  
            args.success(this.$el, this); // lock form
  
            acf.lockForm(this.$el); // reset
  
            if (args.reset) {
              this.reset();
            }
          } // complete callback
  
  
          args.complete(this.$el, this); // clear errors
  
          this.clearErrors();
        }; // serialize form data
  
  
        var data = acf.serialize(this.$el);
        data.action = 'acf/validate_save_post'; // ajax
  
        $.ajax({
          url: acf.get('ajaxurl'),
          data: acf.prepareForAjax(data),
          type: 'post',
          dataType: 'json',
          context: this,
          success: onSuccess,
          complete: onComplete
        }); // return false to fail validation and allow AJAX
  
        return false;
      },
  
      /**
       *  setup
       *
       *  Called during the constructor function to setup this instance
       *
       *  @date	4/9/18
       *  @since	5.7.5
       *
       *  @param	jQuery $form The form element.
       *  @return	void
       */
      setup: function ($form) {
        // set $el
        this.$el = $form;
      },
  
      /**
       *  reset
       *
       *  Rests the validation to be used again.
       *
       *  @date	6/9/18
       *  @since	5.7.5
       *
       *  @param	void
       *  @return	void
       */
      reset: function () {
        // reset data
        this.set('errors', []);
        this.set('notice', null);
        this.set('status', ''); // unlock form
  
        acf.unlockForm(this.$el);
      }
    });
    /**
     *  getValidator
     *
     *  Returns the instance for a given form element.
     *
     *  @date	4/9/18
     *  @since	5.7.5
     *
     *  @param	jQuery $el The form element.
     *  @return	object
     */
  
    var getValidator = function ($el) {
      // instantiate
      var validator = $el.data('acf');
  
      if (!validator) {
        validator = new Validator($el);
      } // return
  
  
      return validator;
    };
    /**
     *  acf.validateForm
     *
     *  A helper function for the Validator.validate() function.
     *  Returns true if form is valid, or fetches a validation request and returns false.
     *
     *  @date	4/4/18
     *  @since	5.6.9
     *
     *  @param	object args A list of settings to customize the validation process.
     *  @return	bool
     */
  
  
    acf.validateForm = function (args) {
      return getValidator(args.form).validate(args);
    };
    /**
     *  acf.enableSubmit
     *
     *  Enables a submit button and returns the element.
     *
     *  @date	30/8/18
     *  @since	5.7.4
     *
     *  @param	jQuery $submit The submit button.
     *  @return	jQuery
     */
  
  
    acf.enableSubmit = function ($submit) {
      return $submit.removeClass('disabled');
    };
    /**
     *  acf.disableSubmit
     *
     *  Disables a submit button and returns the element.
     *
     *  @date	30/8/18
     *  @since	5.7.4
     *
     *  @param	jQuery $submit The submit button.
     *  @return	jQuery
     */
  
  
    acf.disableSubmit = function ($submit) {
      return $submit.addClass('disabled');
    };
    /**
     *  acf.showSpinner
     *
     *  Shows the spinner element.
     *
     *  @date	4/9/18
     *  @since	5.7.5
     *
     *  @param	jQuery $spinner The spinner element.
     *  @return	jQuery
     */
  
  
    acf.showSpinner = function ($spinner) {
      $spinner.addClass('is-active'); // add class (WP > 4.2)
  
      $spinner.css('display', 'inline-block'); // css (WP < 4.2)
  
      return $spinner;
    };
    /**
     *  acf.hideSpinner
     *
     *  Hides the spinner element.
     *
     *  @date	4/9/18
     *  @since	5.7.5
     *
     *  @param	jQuery $spinner The spinner element.
     *  @return	jQuery
     */
  
  
    acf.hideSpinner = function ($spinner) {
      $spinner.removeClass('is-active'); // add class (WP > 4.2)
  
      $spinner.css('display', 'none'); // css (WP < 4.2)
  
      return $spinner;
    };
    /**
     *  acf.lockForm
     *
     *  Locks a form by disabeling its primary inputs and showing a spinner.
     *
     *  @date	4/9/18
     *  @since	5.7.5
     *
     *  @param	jQuery $form The form element.
     *  @return	jQuery
     */
  
  
    acf.lockForm = function ($form) {
      // vars
      var $wrap = findSubmitWrap($form);
      var $submit = $wrap.find('.button, [type="submit"]');
      var $spinner = $wrap.find('.spinner, .acf-spinner'); // hide all spinners (hides the preview spinner)
  
      acf.hideSpinner($spinner); // lock
  
      acf.disableSubmit($submit);
      acf.showSpinner($spinner.last());
      return $form;
    };
    /**
     *  acf.unlockForm
     *
     *  Unlocks a form by enabeling its primary inputs and hiding all spinners.
     *
     *  @date	4/9/18
     *  @since	5.7.5
     *
     *  @param	jQuery $form The form element.
     *  @return	jQuery
     */
  
  
    acf.unlockForm = function ($form) {
      // vars
      var $wrap = findSubmitWrap($form);
      var $submit = $wrap.find('.button, [type="submit"]');
      var $spinner = $wrap.find('.spinner, .acf-spinner'); // unlock
  
      acf.enableSubmit($submit);
      acf.hideSpinner($spinner);
      return $form;
    };
    /**
     *  findSubmitWrap
     *
     *  An internal function to find the 'primary' form submit wrapping element.
     *
     *  @date	4/9/18
     *  @since	5.7.5
     *
     *  @param	jQuery $form The form element.
     *  @return	jQuery
     */
  
  
    var findSubmitWrap = function ($form) {
      // default post submit div
      var $wrap = $form.find('#submitdiv');
  
      if ($wrap.length) {
        return $wrap;
      } // 3rd party publish box
  
  
      var $wrap = $form.find('#submitpost');
  
      if ($wrap.length) {
        return $wrap;
      } // term, user
  
  
      var $wrap = $form.find('p.submit').last();
  
      if ($wrap.length) {
        return $wrap;
      } // front end form
  
  
      var $wrap = $form.find('.acf-form-submit');
  
      if ($wrap.length) {
        return $wrap;
      } // default
  
  
      return $form;
    };
    /**
     * A debounced function to trigger a form submission.
     *
     * @date	15/07/2020
     * @since	5.9.0
     *
     * @param	type Var Description.
     * @return	type Description.
     */
  
  
    var submitFormDebounced = acf.debounce(function ($form) {
      $form.submit();
    });
    /**
     * Ensure field is visible for validation errors
     *
     * @date	20/10/2021
     * @since	5.11.0
     */
  
    var ensureFieldPostBoxIsVisible = function ($el) {
      // Find the postbox element containing this field.
      var $postbox = $el.parents('.acf-postbox');
  
      if ($postbox.length) {
        var acf_postbox = acf.getPostbox($postbox);
  
        if (acf_postbox && acf_postbox.isHiddenByScreenOptions()) {
          // Rather than using .show() here, we don't want the field to appear next reload.
          // So just temporarily show the field group so validation can complete.
          acf_postbox.$el.removeClass('hide-if-js');
          acf_postbox.$el.css('display', '');
        }
      }
    };
    /**
     * Ensure metaboxes which contain browser validation failures are visible.
     *
     * @date	20/10/2021
     * @since	5.11.0
     */
  
  
    var ensureInvalidFieldVisibility = function () {
      // Load each ACF input field and check it's browser validation state.
      var $inputs = $('.acf-field input');
      $inputs.each(function () {
        if (!this.checkValidity()) {
          // Field is invalid, so we need to make sure it's metabox is visible.
          ensureFieldPostBoxIsVisible($(this));
        }
      });
    };
    /**
     *  acf.validation
     *
     *  Global validation logic
     *
     *  @date	4/4/18
     *  @since	5.6.9
     *
     *  @param	void
     *  @return	void
     */
  
  
    acf.validation = new acf.Model({
      /** @var string The model identifier. */
      id: 'validation',
  
      /** @var bool The active state. Set to false before 'prepare' to prevent validation. */
      active: true,
  
      /** @var string The model initialize time. */
      wait: 'prepare',
  
      /** @var object The model actions. */
      actions: {
        ready: 'addInputEvents',
        append: 'addInputEvents'
      },
  
      /** @var object The model events. */
      events: {
        'click input[type="submit"]': 'onClickSubmit',
        'click button[type="submit"]': 'onClickSubmit',
        //'click #editor .editor-post-publish-button': 'onClickSubmitGutenberg',
        'click #save-post': 'onClickSave',
        'submit form#post': 'onSubmitPost',
        'submit form': 'onSubmit'
      },
  
      /**
       *  initialize
       *
       *  Called when initializing the model.
       *
       *  @date	4/9/18
       *  @since	5.7.5
       *
       *  @param	void
       *  @return	void
       */
      initialize: function () {
        // check 'validation' setting
        if (!acf.get('validation')) {
          this.active = false;
          this.actions = {};
          this.events = {};
        }
      },
  
      /**
       *  enable
       *
       *  Enables validation.
       *
       *  @date	4/9/18
       *  @since	5.7.5
       *
       *  @param	void
       *  @return	void
       */
      enable: function () {
        this.active = true;
      },
  
      /**
       *  disable
       *
       *  Disables validation.
       *
       *  @date	4/9/18
       *  @since	5.7.5
       *
       *  @param	void
       *  @return	void
       */
      disable: function () {
        this.active = false;
      },
  
      /**
       *  reset
       *
       *  Rests the form validation to be used again
       *
       *  @date	6/9/18
       *  @since	5.7.5
       *
       *  @param	jQuery $form The form element.
       *  @return	void
       */
      reset: function ($form) {
        getValidator($form).reset();
      },
  
      /**
       *  addInputEvents
       *
       *  Adds 'invalid' event listeners to HTML inputs.
       *
       *  @date	4/9/18
       *  @since	5.7.5
       *
       *  @param	jQuery $el The element being added / readied.
       *  @return	void
       */
      addInputEvents: function ($el) {
        // Bug exists in Safari where custom "invalid" handling prevents draft from saving.
        if (acf.get('browser') === 'safari') return; // vars
  
        var $inputs = $('.acf-field [name]', $el); // check
  
        if ($inputs.length) {
          this.on($inputs, 'invalid', 'onInvalid');
        }
      },
  
      /**
       *  onInvalid
       *
       *  Callback for the 'invalid' event.
       *
       *  @date	4/9/18
       *  @since	5.7.5
       *
       *  @param	object e The event object.
       *  @param	jQuery $el The input element.
       *  @return	void
       */
      onInvalid: function (e, $el) {
        // prevent default
        // - prevents browser error message
        // - also fixes chrome bug where 'hidden-by-tab' field throws focus error
        e.preventDefault(); // vars
  
        var $form = $el.closest('form'); // check form exists
  
        if ($form.length) {
          // add error to validator
          getValidator($form).addError({
            input: $el.attr('name'),
            message: acf.strEscape(e.target.validationMessage)
          }); // trigger submit on $form
          // - allows for "save", "preview" and "publish" to work
  
          submitFormDebounced($form);
        }
      },
  
      /**
       *  onClickSubmit
       *
       *  Callback when clicking submit.
       *
       *  @date	4/9/18
       *  @since	5.7.5
       *
       *  @param	object e The event object.
       *  @param	jQuery $el The input element.
       *  @return	void
       */
      onClickSubmit: function (e, $el) {
        // Some browsers (safari) force their browser validation before our AJAX validation,
        // so we need to make sure fields are visible earlier than showErrors()
        ensureInvalidFieldVisibility(); // store the "click event" for later use in this.onSubmit()
  
        this.set('originalEvent', e);
      },
  
      /**
       *  onClickSave
       *
       *  Set ignore to true when saving a draft.
       *
       *  @date	4/9/18
       *  @since	5.7.5
       *
       *  @param	object e The event object.
       *  @param	jQuery $el The input element.
       *  @return	void
       */
      onClickSave: function (e, $el) {
        this.set('ignore', true);
      },
  
      /**
       *  onClickSubmitGutenberg
       *
       *  Custom validation event for the gutenberg editor.
       *
       *  @date	29/10/18
       *  @since	5.8.0
       *
       *  @param	object e The event object.
       *  @param	jQuery $el The input element.
       *  @return	void
       */
      onClickSubmitGutenberg: function (e, $el) {
        // validate
        var valid = acf.validateForm({
          form: $('#editor'),
          event: e,
          reset: true,
          failure: function ($form, validator) {
            var $notice = validator.get('notice').$el;
            $notice.appendTo('.components-notice-list');
            $notice.find('.acf-notice-dismiss').removeClass('small');
          }
        }); // if not valid, stop event and allow validation to continue
  
        if (!valid) {
          e.preventDefault();
          e.stopImmediatePropagation();
        }
      },
  
      /**
       * onSubmitPost
       *
       * Callback when the 'post' form is submit.
       *
       * @date	5/3/19
       * @since	5.7.13
       *
       * @param	object e The event object.
       * @param	jQuery $el The input element.
       * @return	void
       */
      onSubmitPost: function (e, $el) {
        // Check if is preview.
        if ($('input#wp-preview').val() === 'dopreview') {
          // Ignore validation.
          this.set('ignore', true); // Unlock form to fix conflict with core "submit.edit-post" event causing all submit buttons to be disabled.
  
          acf.unlockForm($el);
        }
      },
  
      /**
       *  onSubmit
       *
       *  Callback when the form is submit.
       *
       *  @date	4/9/18
       *  @since	5.7.5
       *
       *  @param	object e The event object.
       *  @param	jQuery $el The input element.
       *  @return	void
       */
      onSubmit: function (e, $el) {
        // Allow form to submit if...
        if ( // Validation has been disabled.
        !this.active || // Or this event is to be ignored.
        this.get('ignore') || // Or this event has already been prevented.
        e.isDefaultPrevented()) {
          // Return early and call reset function.
          return this.allowSubmit();
        } // Validate form.
  
  
        var valid = acf.validateForm({
          form: $el,
          event: this.get('originalEvent')
        }); // If not valid, stop event to prevent form submit.
  
        if (!valid) {
          e.preventDefault();
        }
      },
  
      /**
       * allowSubmit
       *
       * Resets data during onSubmit when the form is allowed to submit.
       *
       * @date	5/3/19
       * @since	5.7.13
       *
       * @param	void
       * @return	void
       */
      allowSubmit: function () {
        // Reset "ignore" state.
        this.set('ignore', false); // Reset "originalEvent" object.
  
        this.set('originalEvent', false); // Return true
  
        return true;
      }
    });
    var gutenbergValidation = new acf.Model({
      wait: 'prepare',
      initialize: function () {
        // Bail early if not Gutenberg.
        if (!acf.isGutenberg()) {
          return;
        } // Custommize the editor.
  
  
        this.customizeEditor();
      },
      customizeEditor: function () {
        // Extract vars.
        var editor = wp.data.dispatch('core/editor');
        var editorSelect = wp.data.select('core/editor');
        var notices = wp.data.dispatch('core/notices'); // Backup original method.
  
        var savePost = editor.savePost; // Listen for changes to post status and perform actions:
        // a) Enable validation for "publish" action.
        // b) Remember last non "publish" status used for restoring after validation fail.
  
        var useValidation = false;
        var lastPostStatus = '';
        wp.data.subscribe(function () {
          var postStatus = editorSelect.getEditedPostAttribute('status');
          useValidation = postStatus === 'publish' || postStatus === 'future';
          lastPostStatus = postStatus !== 'publish' ? postStatus : lastPostStatus;
        }); // Create validation version.
  
        editor.savePost = function (options) {
          options = options || {}; // Backup vars.
  
          var _this = this;
  
          var _args = arguments; // Perform validation within a Promise.
  
          return new Promise(function (resolve, reject) {
            // Bail early if is autosave or preview.
            if (options.isAutosave || options.isPreview) {
              return resolve('Validation ignored (autosave).');
            } // Bail early if validation is not needed.
  
  
            if (!useValidation) {
              return resolve('Validation ignored (draft).');
            } // Validate the editor form.
  
  
            var valid = acf.validateForm({
              form: $('#editor'),
              reset: true,
              complete: function ($form, validator) {
                // Always unlock the form after AJAX.
                editor.unlockPostSaving('acf');
              },
              failure: function ($form, validator) {
                // Get validation error and append to Gutenberg notices.
                var notice = validator.get('notice');
                notices.createErrorNotice(notice.get('text'), {
                  id: 'acf-validation',
                  isDismissible: true
                });
                notice.remove(); // Restore last non "publish" status.
  
                if (lastPostStatus) {
                  editor.editPost({
                    status: lastPostStatus
                  });
                } // Rejext promise and prevent savePost().
  
  
                reject('Validation failed.');
              },
              success: function () {
                notices.removeNotice('acf-validation'); // Resolve promise and allow savePost().
  
                resolve('Validation success.');
              }
            }); // Resolve promise and allow savePost() if no validation is needed.
  
            if (valid) {
              resolve('Validation bypassed.'); // Otherwise, lock the form and wait for AJAX response.
            } else {
              editor.lockPostSaving('acf');
            }
          }).then(function () {
            return savePost.apply(_this, _args);
          }).catch(function (err) {// Nothing to do here, user is alerted of validation issues.
          });
        };
      }
    });
  })(jQuery);
  
  /***/ })
  
  /******/ 	});
  /************************************************************************/
  /******/ 	// The module cache
  /******/ 	var __webpack_module_cache__ = {};
  /******/ 	
  /******/ 	// The require function
  /******/ 	function __webpack_require__(moduleId) {
  /******/ 		// Check if module is in cache
  /******/ 		var cachedModule = __webpack_module_cache__[moduleId];
  /******/ 		if (cachedModule !== undefined) {
  /******/ 			return cachedModule.exports;
  /******/ 		}
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = __webpack_module_cache__[moduleId] = {
  /******/ 			// no module.id needed
  /******/ 			// no module.loaded needed
  /******/ 			exports: {}
  /******/ 		};
  /******/ 	
  /******/ 		// Execute the module function
  /******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
  /******/ 	
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  /******/ 	
  /************************************************************************/
  /******/ 	/* webpack/runtime/compat get default export */
  /******/ 	!function() {
  /******/ 		// getDefaultExport function for compatibility with non-harmony modules
  /******/ 		__webpack_require__.n = function(module) {
  /******/ 			var getter = module && module.__esModule ?
  /******/ 				function() { return module['default']; } :
  /******/ 				function() { return module; };
  /******/ 			__webpack_require__.d(getter, { a: getter });
  /******/ 			return getter;
  /******/ 		};
  /******/ 	}();
  /******/ 	
  /******/ 	/* webpack/runtime/define property getters */
  /******/ 	!function() {
  /******/ 		// define getter functions for harmony exports
  /******/ 		__webpack_require__.d = function(exports, definition) {
  /******/ 			for(var key in definition) {
  /******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
  /******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
  /******/ 				}
  /******/ 			}
  /******/ 		};
  /******/ 	}();
  /******/ 	
  /******/ 	/* webpack/runtime/hasOwnProperty shorthand */
  /******/ 	!function() {
  /******/ 		__webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }
  /******/ 	}();
  /******/ 	
  /******/ 	/* webpack/runtime/make namespace object */
  /******/ 	!function() {
  /******/ 		// 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 });
  /******/ 		};
  /******/ 	}();
  /******/ 	
  /************************************************************************/
  var __webpack_exports__ = {};
  // This entry need to be wrapped in an IIFE because it need to be in strict mode.
  !function() {
  "use strict";
  /*!*******************************************************************!*\
    !*** ./src/advanced-custom-fields-pro/assets/src/js/acf-input.js ***!
    \*******************************************************************/
  __webpack_require__.r(__webpack_exports__);
  /* harmony import */ var _acf_field_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./_acf-field.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field.js");
  /* harmony import */ var _acf_field_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_acf_field_js__WEBPACK_IMPORTED_MODULE_0__);
  /* harmony import */ var _acf_fields_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./_acf-fields.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-fields.js");
  /* harmony import */ var _acf_fields_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_acf_fields_js__WEBPACK_IMPORTED_MODULE_1__);
  /* harmony import */ var _acf_field_accordion_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./_acf-field-accordion.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-accordion.js");
  /* harmony import */ var _acf_field_accordion_js__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_acf_field_accordion_js__WEBPACK_IMPORTED_MODULE_2__);
  /* harmony import */ var _acf_field_button_group_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./_acf-field-button-group.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-button-group.js");
  /* harmony import */ var _acf_field_button_group_js__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_acf_field_button_group_js__WEBPACK_IMPORTED_MODULE_3__);
  /* harmony import */ var _acf_field_checkbox_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./_acf-field-checkbox.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-checkbox.js");
  /* harmony import */ var _acf_field_checkbox_js__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_acf_field_checkbox_js__WEBPACK_IMPORTED_MODULE_4__);
  /* harmony import */ var _acf_field_color_picker_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./_acf-field-color-picker.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-color-picker.js");
  /* harmony import */ var _acf_field_color_picker_js__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_acf_field_color_picker_js__WEBPACK_IMPORTED_MODULE_5__);
  /* harmony import */ var _acf_field_date_picker_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./_acf-field-date-picker.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-date-picker.js");
  /* harmony import */ var _acf_field_date_picker_js__WEBPACK_IMPORTED_MODULE_6___default = /*#__PURE__*/__webpack_require__.n(_acf_field_date_picker_js__WEBPACK_IMPORTED_MODULE_6__);
  /* harmony import */ var _acf_field_date_time_picker_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./_acf-field-date-time-picker.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-date-time-picker.js");
  /* harmony import */ var _acf_field_date_time_picker_js__WEBPACK_IMPORTED_MODULE_7___default = /*#__PURE__*/__webpack_require__.n(_acf_field_date_time_picker_js__WEBPACK_IMPORTED_MODULE_7__);
  /* harmony import */ var _acf_field_google_map_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./_acf-field-google-map.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-google-map.js");
  /* harmony import */ var _acf_field_google_map_js__WEBPACK_IMPORTED_MODULE_8___default = /*#__PURE__*/__webpack_require__.n(_acf_field_google_map_js__WEBPACK_IMPORTED_MODULE_8__);
  /* harmony import */ var _acf_field_image_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./_acf-field-image.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-image.js");
  /* harmony import */ var _acf_field_image_js__WEBPACK_IMPORTED_MODULE_9___default = /*#__PURE__*/__webpack_require__.n(_acf_field_image_js__WEBPACK_IMPORTED_MODULE_9__);
  /* harmony import */ var _acf_field_file_js__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./_acf-field-file.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-file.js");
  /* harmony import */ var _acf_field_file_js__WEBPACK_IMPORTED_MODULE_10___default = /*#__PURE__*/__webpack_require__.n(_acf_field_file_js__WEBPACK_IMPORTED_MODULE_10__);
  /* harmony import */ var _acf_field_link_js__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./_acf-field-link.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-link.js");
  /* harmony import */ var _acf_field_link_js__WEBPACK_IMPORTED_MODULE_11___default = /*#__PURE__*/__webpack_require__.n(_acf_field_link_js__WEBPACK_IMPORTED_MODULE_11__);
  /* harmony import */ var _acf_field_oembed_js__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ./_acf-field-oembed.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-oembed.js");
  /* harmony import */ var _acf_field_oembed_js__WEBPACK_IMPORTED_MODULE_12___default = /*#__PURE__*/__webpack_require__.n(_acf_field_oembed_js__WEBPACK_IMPORTED_MODULE_12__);
  /* harmony import */ var _acf_field_radio_js__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ./_acf-field-radio.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-radio.js");
  /* harmony import */ var _acf_field_radio_js__WEBPACK_IMPORTED_MODULE_13___default = /*#__PURE__*/__webpack_require__.n(_acf_field_radio_js__WEBPACK_IMPORTED_MODULE_13__);
  /* harmony import */ var _acf_field_range_js__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ./_acf-field-range.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-range.js");
  /* harmony import */ var _acf_field_range_js__WEBPACK_IMPORTED_MODULE_14___default = /*#__PURE__*/__webpack_require__.n(_acf_field_range_js__WEBPACK_IMPORTED_MODULE_14__);
  /* harmony import */ var _acf_field_relationship_js__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(/*! ./_acf-field-relationship.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-relationship.js");
  /* harmony import */ var _acf_field_relationship_js__WEBPACK_IMPORTED_MODULE_15___default = /*#__PURE__*/__webpack_require__.n(_acf_field_relationship_js__WEBPACK_IMPORTED_MODULE_15__);
  /* harmony import */ var _acf_field_select_js__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(/*! ./_acf-field-select.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-select.js");
  /* harmony import */ var _acf_field_select_js__WEBPACK_IMPORTED_MODULE_16___default = /*#__PURE__*/__webpack_require__.n(_acf_field_select_js__WEBPACK_IMPORTED_MODULE_16__);
  /* harmony import */ var _acf_field_tab_js__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(/*! ./_acf-field-tab.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-tab.js");
  /* harmony import */ var _acf_field_tab_js__WEBPACK_IMPORTED_MODULE_17___default = /*#__PURE__*/__webpack_require__.n(_acf_field_tab_js__WEBPACK_IMPORTED_MODULE_17__);
  /* harmony import */ var _acf_field_post_object_js__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(/*! ./_acf-field-post-object.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-post-object.js");
  /* harmony import */ var _acf_field_post_object_js__WEBPACK_IMPORTED_MODULE_18___default = /*#__PURE__*/__webpack_require__.n(_acf_field_post_object_js__WEBPACK_IMPORTED_MODULE_18__);
  /* harmony import */ var _acf_field_page_link_js__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(/*! ./_acf-field-page-link.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-page-link.js");
  /* harmony import */ var _acf_field_page_link_js__WEBPACK_IMPORTED_MODULE_19___default = /*#__PURE__*/__webpack_require__.n(_acf_field_page_link_js__WEBPACK_IMPORTED_MODULE_19__);
  /* harmony import */ var _acf_field_user_js__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__(/*! ./_acf-field-user.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-user.js");
  /* harmony import */ var _acf_field_user_js__WEBPACK_IMPORTED_MODULE_20___default = /*#__PURE__*/__webpack_require__.n(_acf_field_user_js__WEBPACK_IMPORTED_MODULE_20__);
  /* harmony import */ var _acf_field_taxonomy_js__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__(/*! ./_acf-field-taxonomy.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-taxonomy.js");
  /* harmony import */ var _acf_field_taxonomy_js__WEBPACK_IMPORTED_MODULE_21___default = /*#__PURE__*/__webpack_require__.n(_acf_field_taxonomy_js__WEBPACK_IMPORTED_MODULE_21__);
  /* harmony import */ var _acf_field_time_picker_js__WEBPACK_IMPORTED_MODULE_22__ = __webpack_require__(/*! ./_acf-field-time-picker.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-time-picker.js");
  /* harmony import */ var _acf_field_time_picker_js__WEBPACK_IMPORTED_MODULE_22___default = /*#__PURE__*/__webpack_require__.n(_acf_field_time_picker_js__WEBPACK_IMPORTED_MODULE_22__);
  /* harmony import */ var _acf_field_true_false_js__WEBPACK_IMPORTED_MODULE_23__ = __webpack_require__(/*! ./_acf-field-true-false.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-true-false.js");
  /* harmony import */ var _acf_field_true_false_js__WEBPACK_IMPORTED_MODULE_23___default = /*#__PURE__*/__webpack_require__.n(_acf_field_true_false_js__WEBPACK_IMPORTED_MODULE_23__);
  /* harmony import */ var _acf_field_url_js__WEBPACK_IMPORTED_MODULE_24__ = __webpack_require__(/*! ./_acf-field-url.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-url.js");
  /* harmony import */ var _acf_field_url_js__WEBPACK_IMPORTED_MODULE_24___default = /*#__PURE__*/__webpack_require__.n(_acf_field_url_js__WEBPACK_IMPORTED_MODULE_24__);
  /* harmony import */ var _acf_field_wysiwyg_js__WEBPACK_IMPORTED_MODULE_25__ = __webpack_require__(/*! ./_acf-field-wysiwyg.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-field-wysiwyg.js");
  /* harmony import */ var _acf_field_wysiwyg_js__WEBPACK_IMPORTED_MODULE_25___default = /*#__PURE__*/__webpack_require__.n(_acf_field_wysiwyg_js__WEBPACK_IMPORTED_MODULE_25__);
  /* harmony import */ var _acf_condition_js__WEBPACK_IMPORTED_MODULE_26__ = __webpack_require__(/*! ./_acf-condition.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-condition.js");
  /* harmony import */ var _acf_condition_js__WEBPACK_IMPORTED_MODULE_26___default = /*#__PURE__*/__webpack_require__.n(_acf_condition_js__WEBPACK_IMPORTED_MODULE_26__);
  /* harmony import */ var _acf_conditions_js__WEBPACK_IMPORTED_MODULE_27__ = __webpack_require__(/*! ./_acf-conditions.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-conditions.js");
  /* harmony import */ var _acf_conditions_js__WEBPACK_IMPORTED_MODULE_27___default = /*#__PURE__*/__webpack_require__.n(_acf_conditions_js__WEBPACK_IMPORTED_MODULE_27__);
  /* harmony import */ var _acf_condition_types_js__WEBPACK_IMPORTED_MODULE_28__ = __webpack_require__(/*! ./_acf-condition-types.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-condition-types.js");
  /* harmony import */ var _acf_condition_types_js__WEBPACK_IMPORTED_MODULE_28___default = /*#__PURE__*/__webpack_require__.n(_acf_condition_types_js__WEBPACK_IMPORTED_MODULE_28__);
  /* harmony import */ var _acf_unload_js__WEBPACK_IMPORTED_MODULE_29__ = __webpack_require__(/*! ./_acf-unload.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-unload.js");
  /* harmony import */ var _acf_unload_js__WEBPACK_IMPORTED_MODULE_29___default = /*#__PURE__*/__webpack_require__.n(_acf_unload_js__WEBPACK_IMPORTED_MODULE_29__);
  /* harmony import */ var _acf_postbox_js__WEBPACK_IMPORTED_MODULE_30__ = __webpack_require__(/*! ./_acf-postbox.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-postbox.js");
  /* harmony import */ var _acf_postbox_js__WEBPACK_IMPORTED_MODULE_30___default = /*#__PURE__*/__webpack_require__.n(_acf_postbox_js__WEBPACK_IMPORTED_MODULE_30__);
  /* harmony import */ var _acf_media_js__WEBPACK_IMPORTED_MODULE_31__ = __webpack_require__(/*! ./_acf-media.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-media.js");
  /* harmony import */ var _acf_media_js__WEBPACK_IMPORTED_MODULE_31___default = /*#__PURE__*/__webpack_require__.n(_acf_media_js__WEBPACK_IMPORTED_MODULE_31__);
  /* harmony import */ var _acf_screen_js__WEBPACK_IMPORTED_MODULE_32__ = __webpack_require__(/*! ./_acf-screen.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-screen.js");
  /* harmony import */ var _acf_screen_js__WEBPACK_IMPORTED_MODULE_32___default = /*#__PURE__*/__webpack_require__.n(_acf_screen_js__WEBPACK_IMPORTED_MODULE_32__);
  /* harmony import */ var _acf_select2_js__WEBPACK_IMPORTED_MODULE_33__ = __webpack_require__(/*! ./_acf-select2.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-select2.js");
  /* harmony import */ var _acf_select2_js__WEBPACK_IMPORTED_MODULE_33___default = /*#__PURE__*/__webpack_require__.n(_acf_select2_js__WEBPACK_IMPORTED_MODULE_33__);
  /* harmony import */ var _acf_tinymce_js__WEBPACK_IMPORTED_MODULE_34__ = __webpack_require__(/*! ./_acf-tinymce.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-tinymce.js");
  /* harmony import */ var _acf_tinymce_js__WEBPACK_IMPORTED_MODULE_34___default = /*#__PURE__*/__webpack_require__.n(_acf_tinymce_js__WEBPACK_IMPORTED_MODULE_34__);
  /* harmony import */ var _acf_validation_js__WEBPACK_IMPORTED_MODULE_35__ = __webpack_require__(/*! ./_acf-validation.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-validation.js");
  /* harmony import */ var _acf_validation_js__WEBPACK_IMPORTED_MODULE_35___default = /*#__PURE__*/__webpack_require__.n(_acf_validation_js__WEBPACK_IMPORTED_MODULE_35__);
  /* harmony import */ var _acf_helpers_js__WEBPACK_IMPORTED_MODULE_36__ = __webpack_require__(/*! ./_acf-helpers.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-helpers.js");
  /* harmony import */ var _acf_helpers_js__WEBPACK_IMPORTED_MODULE_36___default = /*#__PURE__*/__webpack_require__.n(_acf_helpers_js__WEBPACK_IMPORTED_MODULE_36__);
  /* harmony import */ var _acf_compatibility_js__WEBPACK_IMPORTED_MODULE_37__ = __webpack_require__(/*! ./_acf-compatibility.js */ "./src/advanced-custom-fields-pro/assets/src/js/_acf-compatibility.js");
  /* harmony import */ var _acf_compatibility_js__WEBPACK_IMPORTED_MODULE_37___default = /*#__PURE__*/__webpack_require__.n(_acf_compatibility_js__WEBPACK_IMPORTED_MODULE_37__);
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  }();
  /******/ })()
  ;
  //# sourceMappingURL=acf-input.js.map