/******/ (() => { // 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 ($, 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 ($, 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 ($, 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 ($, 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 ($, 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 ($, 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 ($, 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 ($, 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 ($, 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 ($, 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 ($, undefined) {
  var Field = acf.models.ImageField.extend({
    type: 'file',
    $control: function () {
      return this.$('.acf-file-uploader');
    },
    $input: function () {
      return this.$('input[type="hidden"]:first');
    },
    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 ($, 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 ($, undefined) {
  var Field = acf.Field.extend({
    type: 'image',
    $control: function () {
      return this.$('.acf-image-uploader');
    },
    $input: function () {
      return this.$('input[type="hidden"]:first');
    },
    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 ($, 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 ($, 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 ($, 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 ($, 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 ($, 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 ($, 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 ($, 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 ($, 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 ($, 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 ($, 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 ($, 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 ($, 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 ($, 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 ($, 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 ($, 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 ($, 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 ($, 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 ($, 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 ($, 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 ($, 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 ($, 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 ($, 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 ($, 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 ($, 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 ($, 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 */
/******/ 	(() => {
/******/ 		// getDefaultExport function for compatibility with non-harmony modules
/******/ 		__webpack_require__.n = (module) => {
/******/ 			var getter = module && module.__esModule ?
/******/ 				() => (module['default']) :
/******/ 				() => (module);
/******/ 			__webpack_require__.d(getter, { a: getter });
/******/ 			return getter;
/******/ 		};
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/define property getters */
/******/ 	(() => {
/******/ 		// define getter functions for harmony exports
/******/ 		__webpack_require__.d = (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 */
/******/ 	(() => {
/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/make namespace object */
/******/ 	(() => {
/******/ 		// define __esModule on exports
/******/ 		__webpack_require__.r = (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.
(() => {
"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