/******/ (function() { // webpackBootstrap
/******/ 	var __webpack_modules__ = ({

/***/ "./src/advanced-custom-fields-pro/assets/src/js/_field-group-compatibility.js":
/*!************************************************************************************!*\
  !*** ./src/advanced-custom-fields-pro/assets/src/js/_field-group-compatibility.js ***!
  \************************************************************************************/
/***/ (function() {

(function ($, undefined) {
  var _acf = acf.getCompatibility(acf);
  /**
   *  fieldGroupCompatibility
   *
   *  Compatibility layer for extinct acf.field_group
   *
   *  @date	15/12/17
   *  @since	5.7.0
   *
   *  @param	void
   *  @return	void
   */


  _acf.field_group = {
    save_field: function ($field, type) {
      type = type !== undefined ? type : 'settings';
      acf.getFieldObject($field).save(type);
    },
    delete_field: function ($field, animate) {
      animate = animate !== undefined ? animate : true;
      acf.getFieldObject($field).delete({
        animate: animate
      });
    },
    update_field_meta: function ($field, name, value) {
      acf.getFieldObject($field).prop(name, value);
    },
    delete_field_meta: function ($field, name) {
      acf.getFieldObject($field).prop(name, null);
    }
  };
  /**
   *  fieldGroupCompatibility.field_object
   *
   *  Compatibility layer for extinct acf.field_group.field_object
   *
   *  @date	15/12/17
   *  @since	5.7.0
   *
   *  @param	void
   *  @return	void
   */

  _acf.field_group.field_object = acf.model.extend({
    // vars
    type: '',
    o: {},
    $field: null,
    $settings: null,
    tag: function (tag) {
      // vars
      var type = this.type; // explode, add 'field' and implode
      // - open 			=> open_field
      // - change_type	=> change_field_type

      var tags = tag.split('_');
      tags.splice(1, 0, 'field');
      tag = tags.join('_'); // add type

      if (type) {
        tag += '/type=' + type;
      } // return


      return tag;
    },
    selector: function () {
      // vars
      var selector = '.acf-field-object';
      var type = this.type; // add type

      if (type) {
        selector += '-' + type;
        selector = acf.str_replace('_', '-', selector);
      } // return


      return selector;
    },
    _add_action: function (name, callback) {
      // vars
      var model = this; // add action

      acf.add_action(this.tag(name), function ($field) {
        // focus
        model.set('$field', $field); // callback

        model[callback].apply(model, arguments);
      });
    },
    _add_filter: function (name, callback) {
      // vars
      var model = this; // add action

      acf.add_filter(this.tag(name), function ($field) {
        // focus
        model.set('$field', $field); // callback

        model[callback].apply(model, arguments);
      });
    },
    _add_event: function (name, callback) {
      // vars
      var model = this;
      var event = name.substr(0, name.indexOf(' '));
      var selector = name.substr(name.indexOf(' ') + 1);
      var context = this.selector(); // add event

      $(document).on(event, context + ' ' + selector, function (e) {
        // append $el to event object
        e.$el = $(this);
        e.$field = e.$el.closest('.acf-field-object'); // focus

        model.set('$field', e.$field); // callback

        model[callback].apply(model, [e]);
      });
    },
    _set_$field: function () {
      // vars
      this.o = this.$field.data(); // els

      this.$settings = this.$field.find('> .settings > table > tbody'); // focus

      this.focus();
    },
    focus: function () {// do nothing
    },
    setting: function (name) {
      return this.$settings.find('> .acf-field-setting-' + name);
    }
  });
  /*
   *  field
   *
   *  This model fires actions and filters for registered fields
   *
   *  @type	function
   *  @date	21/02/2014
   *  @since	3.5.1
   *
   *  @param	n/a
   *  @return	n/a
   */

  var actionManager = new acf.Model({
    actions: {
      open_field_object: 'onOpenFieldObject',
      close_field_object: 'onCloseFieldObject',
      add_field_object: 'onAddFieldObject',
      duplicate_field_object: 'onDuplicateFieldObject',
      delete_field_object: 'onDeleteFieldObject',
      change_field_object_type: 'onChangeFieldObjectType',
      change_field_object_label: 'onChangeFieldObjectLabel',
      change_field_object_name: 'onChangeFieldObjectName',
      change_field_object_parent: 'onChangeFieldObjectParent',
      sortstop_field_object: 'onChangeFieldObjectParent'
    },
    onOpenFieldObject: function (field) {
      acf.doAction('open_field', field.$el);
      acf.doAction('open_field/type=' + field.get('type'), field.$el);
      acf.doAction('render_field_settings', field.$el);
      acf.doAction('render_field_settings/type=' + field.get('type'), field.$el);
    },
    onCloseFieldObject: function (field) {
      acf.doAction('close_field', field.$el);
      acf.doAction('close_field/type=' + field.get('type'), field.$el);
    },
    onAddFieldObject: function (field) {
      acf.doAction('add_field', field.$el);
      acf.doAction('add_field/type=' + field.get('type'), field.$el);
    },
    onDuplicateFieldObject: function (field) {
      acf.doAction('duplicate_field', field.$el);
      acf.doAction('duplicate_field/type=' + field.get('type'), field.$el);
    },
    onDeleteFieldObject: function (field) {
      acf.doAction('delete_field', field.$el);
      acf.doAction('delete_field/type=' + field.get('type'), field.$el);
    },
    onChangeFieldObjectType: function (field) {
      acf.doAction('change_field_type', field.$el);
      acf.doAction('change_field_type/type=' + field.get('type'), field.$el);
      acf.doAction('render_field_settings', field.$el);
      acf.doAction('render_field_settings/type=' + field.get('type'), field.$el);
    },
    onChangeFieldObjectLabel: function (field) {
      acf.doAction('change_field_label', field.$el);
      acf.doAction('change_field_label/type=' + field.get('type'), field.$el);
    },
    onChangeFieldObjectName: function (field) {
      acf.doAction('change_field_name', field.$el);
      acf.doAction('change_field_name/type=' + field.get('type'), field.$el);
    },
    onChangeFieldObjectParent: function (field) {
      acf.doAction('update_field_parent', field.$el);
    }
  });
})(jQuery);

/***/ }),

/***/ "./src/advanced-custom-fields-pro/assets/src/js/_field-group-conditions.js":
/*!*********************************************************************************!*\
  !*** ./src/advanced-custom-fields-pro/assets/src/js/_field-group-conditions.js ***!
  \*********************************************************************************/
/***/ (function() {

(function ($, undefined) {
  /**
   *  ConditionalLogicFieldSetting
   *
   *  description
   *
   *  @date	3/2/18
   *  @since	5.6.5
   *
   *  @param	type $var Description. Default.
   *  @return	type Description.
   */
  var ConditionalLogicFieldSetting = acf.FieldSetting.extend({
    type: '',
    name: 'conditional_logic',
    events: {
      'change .conditions-toggle': 'onChangeToggle',
      'click .add-conditional-group': 'onClickAddGroup',
      'focus .condition-rule-field': 'onFocusField',
      'change .condition-rule-field': 'onChangeField',
      'change .condition-rule-operator': 'onChangeOperator',
      'click .add-conditional-rule': 'onClickAdd',
      'click .remove-conditional-rule': 'onClickRemove'
    },
    $rule: false,
    scope: function ($rule) {
      this.$rule = $rule;
      return this;
    },
    ruleData: function (name, value) {
      return this.$rule.data.apply(this.$rule, arguments);
    },
    $input: function (name) {
      return this.$rule.find('.condition-rule-' + name);
    },
    $td: function (name) {
      return this.$rule.find('td.' + name);
    },
    $toggle: function () {
      return this.$('.conditions-toggle');
    },
    $control: function () {
      return this.$('.rule-groups');
    },
    $groups: function () {
      return this.$('.rule-group');
    },
    $rules: function () {
      return this.$('.rule');
    },
    $tabLabel: function () {
      return this.fieldObject.$el.find('.conditional-logic-badge');
    },
    open: function () {
      var $div = this.$control();
      $div.show();
      acf.enable($div);
    },
    close: function () {
      var $div = this.$control();
      $div.hide();
      acf.disable($div);
    },
    render: function () {
      // show
      if (this.$toggle().prop('checked')) {
        this.$tabLabel().addClass('is-enabled');
        this.renderRules();
        this.open(); // hide
      } else {
        this.$tabLabel().removeClass('is-enabled');
        this.close();
      }
    },
    renderRules: function () {
      // vars
      var self = this; // loop

      this.$rules().each(function () {
        self.renderRule($(this));
      });
    },
    renderRule: function ($rule) {
      this.scope($rule);
      this.renderField();
      this.renderOperator();
      this.renderValue();
    },
    renderField: function () {
      // vars
      var choices = [];
      var validFieldTypes = [];
      var cid = this.fieldObject.cid;
      var $select = this.$input('field'); // loop

      acf.getFieldObjects().map(function (fieldObject) {
        // vars
        var choice = {
          id: fieldObject.getKey(),
          text: fieldObject.getLabel()
        }; // bail early if is self

        if (fieldObject.cid === cid) {
          choice.text += acf.__('(this field)');
          choice.disabled = true;
        } // get selected field conditions


        var conditionTypes = acf.getConditionTypes({
          fieldType: fieldObject.getType()
        }); // bail early if no types

        if (!conditionTypes.length) {
          choice.disabled = true;
        } // calulate indents


        var indents = fieldObject.getParents().length;
        choice.text = '- '.repeat(indents) + choice.text; // append

        choices.push(choice);
      }); // allow for scenario where only one field exists

      if (!choices.length) {
        choices.push({
          id: '',
          text: acf.__('No toggle fields available')
        });
      } // render


      acf.renderSelect($select, choices); // set

      this.ruleData('field', $select.val());
    },
    renderOperator: function () {
      // bail early if no field selected
      if (!this.ruleData('field')) {
        return;
      } // vars


      var $select = this.$input('operator');
      var val = $select.val();
      var choices = []; // set saved value on first render
      // - this allows the 2nd render to correctly select an option

      if ($select.val() === null) {
        acf.renderSelect($select, [{
          id: this.ruleData('operator'),
          text: ''
        }]);
      } // get selected field


      var $field = acf.findFieldObject(this.ruleData('field'));
      var field = acf.getFieldObject($field); // get selected field conditions

      var conditionTypes = acf.getConditionTypes({
        fieldType: field.getType()
      }); // html

      conditionTypes.map(function (model) {
        choices.push({
          id: model.prototype.operator,
          text: model.prototype.label
        });
      }); // render

      acf.renderSelect($select, choices); // set

      this.ruleData('operator', $select.val());
    },
    renderValue: function () {
      // bail early if no field selected
      if (!this.ruleData('field') || !this.ruleData('operator')) {
        return;
      } // vars


      var $select = this.$input('value');
      var $td = this.$td('value');
      var val = $select.val(); // get selected field

      var $field = acf.findFieldObject(this.ruleData('field'));
      var field = acf.getFieldObject($field); // get selected field conditions

      var conditionTypes = acf.getConditionTypes({
        fieldType: field.getType(),
        operator: this.ruleData('operator')
      }); // html

      var conditionType = conditionTypes[0].prototype;
      var choices = conditionType.choices(field); // create html: array

      if (choices instanceof Array) {
        var $newSelect = $('<select></select>');
        acf.renderSelect($newSelect, choices); // create html: string (<input />)
      } else {
        var $newSelect = $(choices);
      } // append


      $select.detach();
      $td.html($newSelect); // copy attrs
      // timeout needed to avoid browser bug where "disabled" attribute is not applied

      setTimeout(function () {
        ['class', 'name', 'id'].map(function (attr) {
          $newSelect.attr(attr, $select.attr(attr));
        });
      }, 0); // select existing value (if not a disabled input)

      if (!$newSelect.prop('disabled')) {
        acf.val($newSelect, val, true);
      } // set


      this.ruleData('value', $newSelect.val());
    },
    onChangeToggle: function () {
      this.render();
    },
    onClickAddGroup: function (e, $el) {
      this.addGroup();
    },
    addGroup: function () {
      // vars
      var $group = this.$('.rule-group:last'); // duplicate

      var $group2 = acf.duplicate($group); // update h4

      $group2.find('h4').text(acf.__('or')); // remove all tr's except the first one

      $group2.find('tr').not(':first').remove(); // save field

      this.fieldObject.save();
    },
    onFocusField: function (e, $el) {
      this.renderField();
    },
    onChangeField: function (e, $el) {
      // scope
      this.scope($el.closest('.rule')); // set data

      this.ruleData('field', $el.val()); // render

      this.renderOperator();
      this.renderValue();
    },
    onChangeOperator: function (e, $el) {
      // scope
      this.scope($el.closest('.rule')); // set data

      this.ruleData('operator', $el.val()); // render

      this.renderValue();
    },
    onClickAdd: function (e, $el) {
      // duplciate
      var $rule = acf.duplicate($el.closest('.rule')); // render

      this.renderRule($rule);
    },
    onClickRemove: function (e, $el) {
      // vars
      var $rule = $el.closest('.rule'); // save field

      this.fieldObject.save(); // remove group

      if ($rule.siblings('.rule').length == 0) {
        $rule.closest('.rule-group').remove();
      } // remove


      $rule.remove();
    }
  });
  acf.registerFieldSetting(ConditionalLogicFieldSetting);
  /**
   *  conditionalLogicHelper
   *
   *  description
   *
   *  @date	20/4/18
   *  @since	5.6.9
   *
   *  @param	type $var Description. Default.
   *  @return	type Description.
   */

  var conditionalLogicHelper = new acf.Model({
    actions: {
      duplicate_field_objects: 'onDuplicateFieldObjects'
    },
    onDuplicateFieldObjects: function (children, newField, prevField) {
      // vars
      var data = {};
      var $selects = $(); // reference change in key

      children.map(function (child) {
        // store reference of changed key
        data[child.get('prevKey')] = child.get('key'); // append condition select

        $selects = $selects.add(child.$('.condition-rule-field'));
      }); // loop

      $selects.each(function () {
        // vars
        var $select = $(this);
        var val = $select.val(); // bail early if val is not a ref key

        if (!val || !data[val]) {
          return;
        } // modify selected option


        $select.find('option:selected').attr('value', data[val]); // set new val

        $select.val(data[val]);
      });
    }
  });
})(jQuery);

/***/ }),

/***/ "./src/advanced-custom-fields-pro/assets/src/js/_field-group-field.js":
/*!****************************************************************************!*\
  !*** ./src/advanced-custom-fields-pro/assets/src/js/_field-group-field.js ***!
  \****************************************************************************/
/***/ (function() {

(function ($, undefined) {
  acf.FieldObject = acf.Model.extend({
    // class used to avoid nested event triggers
    eventScope: '.acf-field-object',
    // events
    events: {
      'click .handle': 'onClickEdit',
      'click .close-field': 'onClickEdit',
      'click a[data-key="acf_field_settings_tabs"]': 'onChangeSettingsTab',
      'click .delete-field': 'onClickDelete',
      'click .duplicate-field': 'duplicate',
      'click .move-field': 'move',
      'focus .edit-field': 'onFocusEdit',
      'blur .edit-field, .row-options a': 'onBlurEdit',
      'change .field-type': 'onChangeType',
      'change .field-required': 'onChangeRequired',
      'blur .field-label': 'onChangeLabel',
      'blur .field-name': 'onChangeName',
      change: 'onChange',
      changed: 'onChanged'
    },
    // data
    data: {
      // Similar to ID, but used for HTML puposes.
      // It is possbile for a new field to have an ID of 0, but an id of 'field_123' */
      id: 0,
      // The field key ('field_123')
      key: '',
      // The field type (text, image, etc)
      type: '' // The $post->ID of this field
      //ID: 0,
      // The field's parent
      //parent: 0,
      // The menu order
      //menu_order: 0

    },
    setup: function ($field) {
      // set $el
      this.$el = $field; // inherit $field data (id, key, type)

      this.inherit($field); // load additional props
      // - this won't trigger 'changed'

      this.prop('ID');
      this.prop('parent');
      this.prop('menu_order');
    },
    $input: function (name) {
      return $('#' + this.getInputId() + '-' + name);
    },
    $meta: function () {
      return this.$('.meta:first');
    },
    $handle: function () {
      return this.$('.handle:first');
    },
    $settings: function () {
      return this.$('.settings:first');
    },
    $setting: function (name) {
      return this.$('.acf-field-settings:first .acf-field-setting-' + name);
    },
    getParent: function () {
      return acf.getFieldObjects({
        child: this.$el,
        limit: 1
      }).pop();
    },
    getParents: function () {
      return acf.getFieldObjects({
        child: this.$el
      });
    },
    getFields: function () {
      return acf.getFieldObjects({
        parent: this.$el
      });
    },
    getInputName: function () {
      return 'acf_fields[' + this.get('id') + ']';
    },
    getInputId: function () {
      return 'acf_fields-' + this.get('id');
    },
    newInput: function (name, value) {
      // vars
      var inputId = this.getInputId();
      var inputName = this.getInputName(); // append name

      if (name) {
        inputId += '-' + name;
        inputName += '[' + name + ']';
      } // create input (avoid HTML + JSON value issues)


      var $input = $('<input />').attr({
        id: inputId,
        name: inputName,
        value: value
      });
      this.$('> .meta').append($input); // return

      return $input;
    },
    getProp: function (name) {
      // check data
      if (this.has(name)) {
        return this.get(name);
      } // get input value


      var $input = this.$input(name);
      var value = $input.length ? $input.val() : null; // set data silently (cache)

      this.set(name, value, true); // return

      return value;
    },
    setProp: function (name, value) {
      // get input
      var $input = this.$input(name);
      var prevVal = $input.val(); // create if new

      if (!$input.length) {
        $input = this.newInput(name, value);
      } // remove


      if (value === null) {
        $input.remove(); // update
      } else {
        $input.val(value);
      } //console.log('setProp', name, value, this);
      // set data silently (cache)


      if (!this.has(name)) {
        //console.log('setting silently');
        this.set(name, value, true); // set data allowing 'change' event to fire
      } else {
        //console.log('setting loudly!');
        this.set(name, value);
      } // return


      return this;
    },
    prop: function (name, value) {
      if (value !== undefined) {
        return this.setProp(name, value);
      } else {
        return this.getProp(name);
      }
    },
    props: function (props) {
      Object.keys(props).map(function (key) {
        this.setProp(key, props[key]);
      }, this);
    },
    getLabel: function () {
      // get label with empty default
      var label = this.prop('label');

      if (label === '') {
        label = acf.__('(no label)');
      } // return


      return label;
    },
    getName: function () {
      return this.prop('name');
    },
    getType: function () {
      return this.prop('type');
    },
    getTypeLabel: function () {
      var type = this.prop('type');
      var types = acf.get('fieldTypes');
      return types[type] ? types[type].label : type;
    },
    getKey: function () {
      return this.prop('key');
    },
    initialize: function () {
      this.addProFields();
    },
    addProFields: function () {
      // Make sure we're only running this on free version.
      if (acf.data.fieldTypes.hasOwnProperty('clone')) {
        return;
      } // Make sure we haven't appended these fields before.


      var $fieldTypeSelect = $('.field-type').not('.acf-free-field-type'); // Append pro fields to "Layout" group.

      var $layoutGroup = $fieldTypeSelect.find('optgroup option[value="group"]').parent();
      $layoutGroup.append('<option value="null" disabled="disabled">' + acf.__('Repeater (Pro only)') + '</option>' + '<option value="null" disabled="disabled">' + acf.__('Flexible Content (Pro only)') + '</option>' + '<option value="null" disabled="disabled">' + acf.__('Clone (Pro only)') + '</option>'); // Add pro fields to "Content" group.

      var $contentGroup = $fieldTypeSelect.find('optgroup option[value="image"]').parent();
      $contentGroup.append('<option value="null" disabled="disabled">' + acf.__('Gallery (Pro only)') + '</option>');
      $fieldTypeSelect.addClass('acf-free-field-type');
    },
    render: function () {
      // vars
      var $handle = this.$('.handle:first');
      var menu_order = this.prop('menu_order');
      var label = this.getLabel();
      var name = this.prop('name');
      var type = this.getTypeLabel();
      var key = this.prop('key');
      var required = this.$input('required').prop('checked'); // update menu order

      $handle.find('.acf-icon').html(parseInt(menu_order) + 1); // update required

      if (required) {
        label += ' <span class="acf-required">*</span>';
      } // update label


      $handle.find('.li-field-label strong a').html(label); // update name

      $handle.find('.li-field-name').text(name); // update type

      const iconName = acf.strSlugify(this.getType());
      $handle.find('.field-type-label').text(' ' + type);
      $handle.find('.field-type-icon').removeClass().addClass('field-type-icon field-type-icon-' + iconName); // update key

      $handle.find('.li-field-key').text(key); // action for 3rd party customization

      acf.doAction('render_field_object', this);
    },
    refresh: function () {
      acf.doAction('refresh_field_object', this);
    },
    isOpen: function () {
      return this.$el.hasClass('open');
    },
    onClickEdit: function (e) {
      $target = $(e.target);
      if ($target.parent().hasClass('row-options') && !$target.hasClass('edit-field')) return;
      this.isOpen() ? this.close() : this.open();
    },
    onChangeSettingsTab: function () {
      const $settings = this.$el.children('.settings');
      acf.doAction('show', $settings);
    },

    /**
     * Adds 'active' class to row options nearest to the target.
     */
    onFocusEdit: function (e) {
      var $rowOptions = $(e.target).closest('li').find('.row-options');
      $rowOptions.addClass('active');
    },

    /**
     * Removes 'active' class from row options if links in same row options area are no longer in focus.
     */
    onBlurEdit: function (e) {
      var focusDelayMilliseconds = 50;
      var $rowOptionsBlurElement = $(e.target).closest('li').find('.row-options'); // Timeout so that `activeElement` gives the new element in focus instead of the body.

      setTimeout(function () {
        var $rowOptionsFocusElement = $(document.activeElement).closest('li').find('.row-options');

        if (!$rowOptionsBlurElement.is($rowOptionsFocusElement)) {
          $rowOptionsBlurElement.removeClass('active');
        }
      }, focusDelayMilliseconds);
    },
    open: function () {
      // vars
      var $settings = this.$el.children('.settings'); // open

      $settings.slideDown();
      this.$el.addClass('open'); // action (open)

      acf.doAction('open_field_object', this);
      this.trigger('openFieldObject'); // action (show)

      acf.doAction('show', $settings);
    },
    close: function () {
      // vars
      var $settings = this.$el.children('.settings'); // close

      $settings.slideUp();
      this.$el.removeClass('open'); // action (close)

      acf.doAction('close_field_object', this);
      this.trigger('closeFieldObject'); // action (hide)

      acf.doAction('hide', $settings);
    },
    serialize: function () {
      return acf.serialize(this.$el, this.getInputName());
    },
    save: function (type) {
      // defaults
      type = type || 'settings'; // meta, settings
      // vars

      var save = this.getProp('save'); // bail if already saving settings

      if (save === 'settings') {
        return;
      } // prop


      this.setProp('save', type); // debug

      this.$el.attr('data-save', type); // action

      acf.doAction('save_field_object', this, type);
    },
    submit: function () {
      // vars
      var inputName = this.getInputName();
      var save = this.get('save'); // close

      if (this.isOpen()) {
        this.close();
      } // allow all inputs to save


      if (save == 'settings') {// do nothing
        // allow only meta inputs to save
      } else if (save == 'meta') {
        this.$('> .settings [name^="' + inputName + '"]').remove(); // prevent all inputs from saving
      } else {
        this.$('[name^="' + inputName + '"]').remove();
      } // action


      acf.doAction('submit_field_object', this);
    },
    onChange: function (e, $el) {
      // save settings
      this.save(); // action for 3rd party customization

      acf.doAction('change_field_object', this);
    },
    onChanged: function (e, $el, name, value) {
      // ignore 'save'
      if (name == 'save') {
        return;
      } // save meta


      if (['menu_order', 'parent'].indexOf(name) > -1) {
        this.save('meta'); // save field
      } else {
        this.save();
      } // render


      if (['menu_order', 'label', 'required', 'name', 'type', 'key'].indexOf(name) > -1) {
        this.render();
      } // action for 3rd party customization


      acf.doAction('change_field_object_' + name, this, value);
    },
    onChangeLabel: function (e, $el) {
      // set
      var label = $el.val();
      this.set('label', label); // render name

      if (this.prop('name') == '') {
        var name = acf.applyFilters('generate_field_object_name', acf.strSanitize(label), this);
        this.prop('name', name);
      }
    },
    onChangeName: function (e, $el) {
      // set
      var name = $el.val();
      this.set('name', name); // error

      if (name.substr(0, 6) === 'field_') {
        alert(acf.__('The string "field_" may not be used at the start of a field name'));
      }
    },
    onChangeRequired: function (e, $el) {
      // set
      var required = $el.prop('checked') ? 1 : 0;
      this.set('required', required);
    },
    delete: function (args) {
      // defaults
      args = acf.parseArgs(args, {
        animate: true
      }); // add to remove list

      var id = this.prop('ID');

      if (id) {
        var $input = $('#_acf_delete_fields');
        var newVal = $input.val() + '|' + id;
        $input.val(newVal);
      } // action


      acf.doAction('delete_field_object', this); // animate

      if (args.animate) {
        this.removeAnimate();
      } else {
        this.remove();
      }
    },
    onClickDelete: function (e, $el) {
      // Bypass confirmation when holding down "shift" key.
      if (e.shiftKey) {
        return this.delete();
      } // add class


      this.$el.addClass('-hover'); // add tooltip

      var tooltip = acf.newTooltip({
        confirmRemove: true,
        target: $el,
        context: this,
        confirm: function () {
          this.delete();
        },
        cancel: function () {
          this.$el.removeClass('-hover');
        }
      });
    },
    removeAnimate: function () {
      // vars
      var field = this;
      var $list = this.$el.parent();
      var $fields = acf.findFieldObjects({
        sibling: this.$el
      }); // remove

      acf.remove({
        target: this.$el,
        endHeight: $fields.length ? 0 : 50,
        complete: function () {
          field.remove();
          acf.doAction('removed_field_object', field, $list);
        }
      }); // action

      acf.doAction('remove_field_object', field, $list);
    },
    duplicate: function () {
      // vars
      var newKey = acf.uniqid('field_'); // duplicate

      var $newField = acf.duplicate({
        target: this.$el,
        search: this.get('id'),
        replace: newKey
      }); // set new key

      $newField.attr('data-key', newKey); // get instance

      var newField = acf.getFieldObject($newField); // open / close

      if (this.isOpen()) {
        this.close();
      } else {
        newField.open();
      } // focus label


      var $label = newField.$setting('label input');
      setTimeout(function () {
        $label.trigger('focus');
      }, 251); // update newField label / name

      var label = newField.prop('label');
      var name = newField.prop('name');
      var end = name.split('_').pop();

      var copy = acf.__('copy'); // increase suffix "1"


      if (acf.isNumeric(end)) {
        var i = end * 1 + 1;
        label = label.replace(end, i);
        name = name.replace(end, i); // increase suffix "(copy1)"
      } else if (end.indexOf(copy) === 0) {
        var i = end.replace(copy, '') * 1;
        i = i ? i + 1 : 2; // replace

        label = label.replace(end, copy + i);
        name = name.replace(end, copy + i); // add default "(copy)"
      } else {
        label += ' (' + copy + ')';
        name += '_' + copy;
      }

      newField.prop('ID', 0);
      newField.prop('label', label);
      newField.prop('name', name);
      newField.prop('key', newKey); // action

      acf.doAction('duplicate_field_object', this, newField);
      acf.doAction('append_field_object', newField);
    },
    wipe: function () {
      // vars
      var prevId = this.get('id');
      var prevKey = this.get('key');
      var newKey = acf.uniqid('field_'); // rename

      acf.rename({
        target: this.$el,
        search: prevId,
        replace: newKey
      }); // data

      this.set('id', newKey);
      this.set('prevId', prevId);
      this.set('prevKey', prevKey); // props

      this.prop('key', newKey);
      this.prop('ID', 0); // attr

      this.$el.attr('data-key', newKey);
      this.$el.attr('data-id', newKey); // action

      acf.doAction('wipe_field_object', this);
    },
    move: function () {
      // helper
      var hasChanged = function (field) {
        return field.get('save') == 'settings';
      }; // vars


      var changed = hasChanged(this); // has sub fields changed

      if (!changed) {
        acf.getFieldObjects({
          parent: this.$el
        }).map(function (field) {
          changed = hasChanged(field) || field.changed;
        });
      } // bail early if changed


      if (changed) {
        alert(acf.__('This field cannot be moved until its changes have been saved'));
        return;
      } // step 1.


      var id = this.prop('ID');
      var field = this;
      var popup = false;

      var step1 = function () {
        // popup
        popup = acf.newPopup({
          title: acf.__('Move Custom Field'),
          loading: true,
          width: '300px'
        }); // ajax

        var ajaxData = {
          action: 'acf/field_group/move_field',
          field_id: id
        }; // get HTML

        $.ajax({
          url: acf.get('ajaxurl'),
          data: acf.prepareForAjax(ajaxData),
          type: 'post',
          dataType: 'html',
          success: step2
        });
      };

      var step2 = function (html) {
        // update popup
        popup.loading(false);
        popup.content(html); // submit form

        popup.on('submit', 'form', step3);
      };

      var step3 = function (e, $el) {
        // prevent
        e.preventDefault(); // disable

        acf.startButtonLoading(popup.$('.button')); // ajax

        var ajaxData = {
          action: 'acf/field_group/move_field',
          field_id: id,
          field_group_id: popup.$('select').val()
        }; // get HTML

        $.ajax({
          url: acf.get('ajaxurl'),
          data: acf.prepareForAjax(ajaxData),
          type: 'post',
          dataType: 'html',
          success: step4
        });
      };

      var step4 = function (html) {
        // update popup
        popup.content(html); // remove element

        field.removeAnimate();
      }; // start


      step1();
    },
    onChangeType: function (e, $el) {
      // clea previous timout
      if (this.changeTimeout) {
        clearTimeout(this.changeTimeout);
      } // set new timeout
      // - prevents changing type multiple times whilst user types in newType


      this.changeTimeout = this.setTimeout(function () {
        this.changeType($el.val());
      }, 300);
    },
    changeType: function (newType) {
      var prevType = this.prop('type');
      var prevClass = acf.strSlugify('acf-field-object-' + prevType);
      var newClass = acf.strSlugify('acf-field-object-' + newType); // Update props.

      this.$el.removeClass(prevClass).addClass(newClass);
      this.$el.attr('data-type', newType);
      this.$el.data('type', newType); // Abort XHR if this field is already loading AJAX data.

      if (this.has('xhr')) {
        this.get('xhr').abort();
      } // Store old settings so they can be reused later.


      const $oldSettings = [];
      this.$el.find('.acf-field-settings:first > .acf-field-settings-main > .acf-field-type-settings').each(function () {
        let tab = $(this).data('parent-tab');
        let $tabSettings = $(this).children();
        $oldSettings[tab] = $tabSettings;
        $tabSettings.detach();
      });
      this.set('settings-' + prevType, $oldSettings); // Show the settings if we already have them cached.

      if (this.has('settings-' + newType)) {
        let $newSettings = this.get('settings-' + newType);
        this.showFieldTypeSettings($newSettings);
        this.set('type', newType);
        return;
      } // Add loading spinner.


      const $loading = $('<div class="acf-field"><div class="acf-input"><div class="acf-loading"></div></div></div>');
      this.$el.find('.acf-field-settings-main-general .acf-field-type-settings').before($loading);
      const ajaxData = {
        action: 'acf/field_group/render_field_settings',
        field: this.serialize(),
        prefix: this.getInputName()
      }; // Get the settings for this field type over AJAX.

      var xhr = $.ajax({
        url: acf.get('ajaxurl'),
        data: acf.prepareForAjax(ajaxData),
        type: 'post',
        dataType: 'json',
        context: this,
        success: function (response) {
          if (!acf.isAjaxSuccess(response)) {
            return;
          }

          this.showFieldTypeSettings(response.data);
        },
        complete: function () {
          // also triggered by xhr.abort();
          $loading.remove();
          this.set('type', newType); //this.refresh();
        }
      }); // set

      this.set('xhr', xhr);
    },
    showFieldTypeSettings: function (settings) {
      if ('object' !== typeof settings) {
        return;
      }

      const self = this;
      const tabs = Object.keys(settings);
      tabs.forEach(tab => {
        const $tab = self.$el.find('.acf-field-settings-main-' + tab + ' .acf-field-type-settings');
        let tabContent = '';

        if (['object', 'string'].includes(typeof settings[tab])) {
          tabContent = settings[tab];
        }

        $tab.prepend(tabContent);
        acf.doAction('append', $tab);
      });
    },
    updateParent: function () {
      // vars
      var ID = acf.get('post_id'); // check parent

      var parent = this.getParent();

      if (parent) {
        ID = parseInt(parent.prop('ID')) || parent.prop('key');
      } // update


      this.prop('parent', ID);
    }
  });
})(jQuery);

/***/ }),

/***/ "./src/advanced-custom-fields-pro/assets/src/js/_field-group-fields.js":
/*!*****************************************************************************!*\
  !*** ./src/advanced-custom-fields-pro/assets/src/js/_field-group-fields.js ***!
  \*****************************************************************************/
/***/ (function() {

(function ($, undefined) {
  /**
   *  acf.findFieldObject
   *
   *  Returns a single fieldObject $el for a given field key
   *
   *  @date	1/2/18
   *  @since	5.7.0
   *
   *  @param	string key The field key
   *  @return	jQuery
   */
  acf.findFieldObject = function (key) {
    return acf.findFieldObjects({
      key: key,
      limit: 1
    });
  };
  /**
   *  acf.findFieldObjects
   *
   *  Returns an array of fieldObject $el for the given args
   *
   *  @date	1/2/18
   *  @since	5.7.0
   *
   *  @param	object args
   *  @return	jQuery
   */


  acf.findFieldObjects = function (args) {
    // vars
    args = args || {};
    var selector = '.acf-field-object';
    var $fields = false; // args

    args = acf.parseArgs(args, {
      id: '',
      key: '',
      type: '',
      limit: false,
      list: null,
      parent: false,
      sibling: false,
      child: false
    }); // id

    if (args.id) {
      selector += '[data-id="' + args.id + '"]';
    } // key


    if (args.key) {
      selector += '[data-key="' + args.key + '"]';
    } // type


    if (args.type) {
      selector += '[data-type="' + args.type + '"]';
    } // query


    if (args.list) {
      $fields = args.list.children(selector);
    } else if (args.parent) {
      $fields = args.parent.find(selector);
    } else if (args.sibling) {
      $fields = args.sibling.siblings(selector);
    } else if (args.child) {
      $fields = args.child.parents(selector);
    } else {
      $fields = $(selector);
    } // limit


    if (args.limit) {
      $fields = $fields.slice(0, args.limit);
    } // return


    return $fields;
  };
  /**
   *  acf.getFieldObject
   *
   *  Returns a single fieldObject instance for a given $el|key
   *
   *  @date	1/2/18
   *  @since	5.7.0
   *
   *  @param	string|jQuery $field The field $el or key
   *  @return	jQuery
   */


  acf.getFieldObject = function ($field) {
    // allow key
    if (typeof $field === 'string') {
      $field = acf.findFieldObject($field);
    } // instantiate


    var field = $field.data('acf');

    if (!field) {
      field = acf.newFieldObject($field);
    } // return


    return field;
  };
  /**
   *  acf.getFieldObjects
   *
   *  Returns an array of fieldObject instances for the given args
   *
   *  @date	1/2/18
   *  @since	5.7.0
   *
   *  @param	object args
   *  @return	array
   */


  acf.getFieldObjects = function (args) {
    // query
    var $fields = acf.findFieldObjects(args); // loop

    var fields = [];
    $fields.each(function () {
      var field = acf.getFieldObject($(this));
      fields.push(field);
    }); // return

    return fields;
  };
  /**
   *  acf.newFieldObject
   *
   *  Initializes and returns a new FieldObject instance
   *
   *  @date	1/2/18
   *  @since	5.7.0
   *
   *  @param	jQuery $field The field $el
   *  @return	object
   */


  acf.newFieldObject = function ($field) {
    // instantiate
    var field = new acf.FieldObject($field); // action

    acf.doAction('new_field_object', field); // return

    return field;
  };
  /**
   *  actionManager
   *
   *  description
   *
   *  @date	15/12/17
   *  @since	5.6.5
   *
   *  @param	type $var Description. Default.
   *  @return	type Description.
   */


  var eventManager = new acf.Model({
    priority: 5,
    initialize: function () {
      // actions
      var actions = ['prepare', 'ready', 'append', 'remove']; // loop

      actions.map(function (action) {
        this.addFieldActions(action);
      }, this);
    },
    addFieldActions: function (action) {
      // vars
      var pluralAction = action + '_field_objects'; // ready_field_objects

      var singleAction = action + '_field_object'; // ready_field_object

      var singleEvent = action + 'FieldObject'; // readyFieldObject
      // global action

      var callback = function ($el
      /*, arg1, arg2, etc*/
      ) {
        // vars
        var fieldObjects = acf.getFieldObjects({
          parent: $el
        }); // call plural

        if (fieldObjects.length) {
          /// get args [$el, arg1]
          var args = acf.arrayArgs(arguments); // modify args [pluralAction, fields, arg1]

          args.splice(0, 1, pluralAction, fieldObjects);
          acf.doAction.apply(null, args);
        }
      }; // plural action


      var pluralCallback = function (fieldObjects
      /*, arg1, arg2, etc*/
      ) {
        /// get args [fields, arg1]
        var args = acf.arrayArgs(arguments); // modify args [singleAction, fields, arg1]

        args.unshift(singleAction); // loop

        fieldObjects.map(function (fieldObject) {
          // modify args [singleAction, field, arg1]
          args[1] = fieldObject;
          acf.doAction.apply(null, args);
        });
      }; // single action


      var singleCallback = function (fieldObject
      /*, arg1, arg2, etc*/
      ) {
        /// get args [$field, arg1]
        var args = acf.arrayArgs(arguments); // modify args [singleAction, $field, arg1]

        args.unshift(singleAction); // action variations (ready_field/type=image)

        var variations = ['type', 'name', 'key'];
        variations.map(function (variation) {
          args[0] = singleAction + '/' + variation + '=' + fieldObject.get(variation);
          acf.doAction.apply(null, args);
        }); // modify args [arg1]

        args.splice(0, 2); // event

        fieldObject.trigger(singleEvent, args);
      }; // add actions


      acf.addAction(action, callback, 5);
      acf.addAction(pluralAction, pluralCallback, 5);
      acf.addAction(singleAction, singleCallback, 5);
    }
  });
  /**
   *  fieldManager
   *
   *  description
   *
   *  @date	4/1/18
   *  @since	5.6.5
   *
   *  @param	type $var Description. Default.
   *  @return	type Description.
   */

  var fieldManager = new acf.Model({
    id: 'fieldManager',
    events: {
      'submit #post': 'onSubmit',
      'mouseenter .acf-field-list': 'onHoverSortable',
      'click .add-field': 'onClickAdd'
    },
    actions: {
      removed_field_object: 'onRemovedField',
      sortstop_field_object: 'onReorderField',
      delete_field_object: 'onDeleteField',
      change_field_object_type: 'onChangeFieldType',
      duplicate_field_object: 'onDuplicateField'
    },
    onSubmit: function (e, $el) {
      // vars
      var fields = acf.getFieldObjects(); // loop

      fields.map(function (field) {
        field.submit();
      });
    },
    setFieldMenuOrder: function (field) {
      this.renderFields(field.$el.parent());
    },
    onHoverSortable: function (e, $el) {
      // bail early if already sortable
      if ($el.hasClass('ui-sortable')) return; // sortable

      $el.sortable({
        handle: '.acf-sortable-handle',
        connectWith: '.acf-field-list',
        start: function (e, ui) {
          var field = acf.getFieldObject(ui.item);
          ui.placeholder.height(ui.item.height());
          acf.doAction('sortstart_field_object', field, $el);
        },
        update: function (e, ui) {
          var field = acf.getFieldObject(ui.item);
          acf.doAction('sortstop_field_object', field, $el);
        }
      });
    },
    onRemovedField: function (field, $list) {
      this.renderFields($list);
    },
    onReorderField: function (field, $list) {
      field.updateParent();
      this.renderFields($list);
    },
    onDeleteField: function (field) {
      // delete children
      field.getFields().map(function (child) {
        child.delete({
          animate: false
        });
      });
    },
    onChangeFieldType: function (field) {// this caused sub fields to disapear if changing type back...
      //this.onDeleteField( field );
    },
    onDuplicateField: function (field, newField) {
      // check for children
      var children = newField.getFields();

      if (children.length) {
        // loop
        children.map(function (child) {
          // wipe field
          child.wipe(); // update parent

          child.updateParent();
        }); // action

        acf.doAction('duplicate_field_objects', children, newField, field);
      } // set menu order


      this.setFieldMenuOrder(newField);
    },
    renderFields: function ($list) {
      // vars
      var fields = acf.getFieldObjects({
        list: $list
      }); // no fields

      if (!fields.length) {
        $list.addClass('-empty');
        $list.parents('.acf-field-list-wrap').first().addClass('-empty');
        return;
      } // has fields


      $list.removeClass('-empty');
      $list.parents('.acf-field-list-wrap').first().removeClass('-empty'); // prop

      fields.map(function (field, i) {
        field.prop('menu_order', i);
      });
    },
    onClickAdd: function (e, $el) {
      let $list;

      if ($el.hasClass('add-first-field')) {
        $list = $el.parents('.acf-field-list').eq(0);
      } else if ($el.parent().hasClass('acf-headerbar-actions') || $el.parent().hasClass('no-fields-message-inner')) {
        $list = $('.acf-field-list:first');
      } else if ($el.parent().hasClass('acf-sub-field-list-header')) {
        $list = $el.parents('.acf-input:first').find('.acf-field-list');
      } else {
        $list = $el.closest('.acf-tfoot').siblings('.acf-field-list');
      }

      this.addField($list);
    },
    addField: function ($list) {
      // vars
      var html = $('#tmpl-acf-field').html();
      var $el = $(html);
      var prevId = $el.data('id');
      var newKey = acf.uniqid('field_'); // duplicate

      var $newField = acf.duplicate({
        target: $el,
        search: prevId,
        replace: newKey,
        append: function ($el, $el2) {
          $list.append($el2);
        }
      }); // get instance

      var newField = acf.getFieldObject($newField); // props

      newField.prop('key', newKey);
      newField.prop('ID', 0);
      newField.prop('label', '');
      newField.prop('name', ''); // attr

      $newField.attr('data-key', newKey);
      $newField.attr('data-id', newKey); // update parent prop

      newField.updateParent(); // focus label

      var $label = newField.$input('label');
      setTimeout(function () {
        if ($list.hasClass('acf-auto-add-field')) {
          $list.removeClass('acf-auto-add-field');
        } else {
          $label.trigger('focus');
        }
      }, 251); // open

      newField.open(); // set menu order

      this.renderFields($list); // action

      acf.doAction('add_field_object', newField);
      acf.doAction('append_field_object', newField);
    }
  });
})(jQuery);

/***/ }),

/***/ "./src/advanced-custom-fields-pro/assets/src/js/_field-group-locations.js":
/*!********************************************************************************!*\
  !*** ./src/advanced-custom-fields-pro/assets/src/js/_field-group-locations.js ***!
  \********************************************************************************/
/***/ (function() {

(function ($, undefined) {
  /**
   *  locationManager
   *
   *  Field group location rules functionality
   *
   *  @date	15/12/17
   *  @since	5.7.0
   *
   *  @param	void
   *  @return	void
   */
  var locationManager = new acf.Model({
    id: 'locationManager',
    wait: 'ready',
    events: {
      'click .add-location-rule': 'onClickAddRule',
      'click .add-location-group': 'onClickAddGroup',
      'click .remove-location-rule': 'onClickRemoveRule',
      'change .refresh-location-rule': 'onChangeRemoveRule'
    },
    initialize: function () {
      this.$el = $('#acf-field-group-options');
      this.updateGroupsClass();
    },
    onClickAddRule: function (e, $el) {
      this.addRule($el.closest('tr'));
    },
    onClickRemoveRule: function (e, $el) {
      this.removeRule($el.closest('tr'));
    },
    onChangeRemoveRule: function (e, $el) {
      this.changeRule($el.closest('tr'));
    },
    onClickAddGroup: function (e, $el) {
      this.addGroup();
    },
    addRule: function ($tr) {
      acf.duplicate($tr);
      this.updateGroupsClass();
    },
    removeRule: function ($tr) {
      if ($tr.siblings('tr').length == 0) {
        $tr.closest('.rule-group').remove();
      } else {
        $tr.remove();
      } // Update h4


      var $group = this.$('.rule-group:first');
      $group.find('h4').text(acf.__('Show this field group if'));
      this.updateGroupsClass();
    },
    changeRule: function ($rule) {
      // vars
      var $group = $rule.closest('.rule-group');
      var prefix = $rule.find('td.param select').attr('name').replace('[param]', ''); // ajaxdata

      var ajaxdata = {};
      ajaxdata.action = 'acf/field_group/render_location_rule';
      ajaxdata.rule = acf.serialize($rule, prefix);
      ajaxdata.rule.id = $rule.data('id');
      ajaxdata.rule.group = $group.data('id'); // temp disable

      acf.disable($rule.find('td.value')); // ajax

      $.ajax({
        url: acf.get('ajaxurl'),
        data: acf.prepareForAjax(ajaxdata),
        type: 'post',
        dataType: 'html',
        success: function (html) {
          if (!html) return;
          $rule.replaceWith(html);
        }
      });
    },
    addGroup: function () {
      // vars
      var $group = this.$('.rule-group:last'); // duplicate

      $group2 = acf.duplicate($group); // update h4

      $group2.find('h4').text(acf.__('or')); // remove all tr's except the first one

      $group2.find('tr').not(':first').remove(); // update the groups class

      this.updateGroupsClass();
    },
    updateGroupsClass: function () {
      var $group = this.$('.rule-group:last');
      var $ruleGroups = $group.closest('.rule-groups');
      var rows_count = $ruleGroups.find('.acf-table tr').length;

      if (rows_count > 1) {
        $ruleGroups.addClass('rule-groups-multiple');
      } else {
        $ruleGroups.removeClass('rule-groups-multiple');
      }
    }
  });
})(jQuery);

/***/ }),

/***/ "./src/advanced-custom-fields-pro/assets/src/js/_field-group-settings.js":
/*!*******************************************************************************!*\
  !*** ./src/advanced-custom-fields-pro/assets/src/js/_field-group-settings.js ***!
  \*******************************************************************************/
/***/ (function() {

(function ($, undefined) {
  /**
   *  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 || '') + 'FieldSetting';
  };
  /**
   *  registerFieldType
   *
   *  description
   *
   *  @date	14/12/17
   *  @since	5.6.5
   *
   *  @param	type $var Description. Default.
   *  @return	type Description.
   */


  acf.registerFieldSetting = function (model) {
    var proto = model.prototype;
    var mid = modelId(proto.type + ' ' + proto.name);
    this.models[mid] = model;
  };
  /**
   *  newField
   *
   *  description
   *
   *  @date	14/12/17
   *  @since	5.6.5
   *
   *  @param	type $var Description. Default.
   *  @return	type Description.
   */


  acf.newFieldSetting = function (field) {
    // vars
    var type = field.get('setting') || '';
    var name = field.get('name') || '';
    var mid = modelId(type + ' ' + name);
    var model = acf.models[mid] || null; // bail early if no setting

    if (model === null) return false; // instantiate

    var setting = new model(field); // return

    return setting;
  };
  /**
   *  acf.getFieldSetting
   *
   *  description
   *
   *  @date	19/4/18
   *  @since	5.6.9
   *
   *  @param	type $var Description. Default.
   *  @return	type Description.
   */


  acf.getFieldSetting = function (field) {
    // allow jQuery
    if (field instanceof jQuery) {
      field = acf.getField(field);
    } // return


    return field.setting;
  };
  /**
   * settingsManager
   *
   * @since	5.6.5
   *
   * @param	object The object containing the extended variables and methods.
   * @return	void
   */


  var settingsManager = new acf.Model({
    actions: {
      new_field: 'onNewField'
    },
    onNewField: function (field) {
      field.setting = acf.newFieldSetting(field);
    }
  });
  /**
   * acf.FieldSetting
   *
   * @since	5.6.5
   *
   * @param	object The object containing the extended variables and methods.
   * @return	void
   */

  acf.FieldSetting = acf.Model.extend({
    field: false,
    type: '',
    name: '',
    wait: 'ready',
    eventScope: '.acf-field',
    events: {
      change: 'render'
    },
    setup: function (field) {
      // vars
      var $field = field.$el; // set props

      this.$el = $field;
      this.field = field;
      this.$fieldObject = $field.closest('.acf-field-object');
      this.fieldObject = acf.getFieldObject(this.$fieldObject); // inherit data

      $.extend(this.data, field.data);
    },
    initialize: function () {
      this.render();
    },
    render: function () {// do nothing
    }
  });
  /**
   * Accordion and Tab Endpoint Settings
   *
   * The 'endpoint' setting on accordions and tabs requires an additional class on the
   * field object row when enabled.
   *
   * @since	6.0.0
   *
   * @param	object The object containing the extended variables and methods.
   * @return	void
   */

  var EndpointFieldSetting = acf.FieldSetting.extend({
    type: '',
    name: '',
    render: function () {
      var $endpoint_setting = this.fieldObject.$setting('endpoint');
      var $endpoint_field = $endpoint_setting.find('input[type="checkbox"]:first');

      if ($endpoint_field.is(':checked')) {
        this.fieldObject.$el.addClass('acf-field-is-endpoint');
      } else {
        this.fieldObject.$el.removeClass('acf-field-is-endpoint');
      }
    }
  });
  var AccordionEndpointFieldSetting = EndpointFieldSetting.extend({
    type: 'accordion',
    name: 'endpoint'
  });
  var TabEndpointFieldSetting = EndpointFieldSetting.extend({
    type: 'tab',
    name: 'endpoint'
  });
  acf.registerFieldSetting(AccordionEndpointFieldSetting);
  acf.registerFieldSetting(TabEndpointFieldSetting);
  /**
   * Date Picker
   *
   * This field type requires some extra logic for its settings
   *
   * @since	5.0.0
   *
   * @param	object The object containing the extended variables and methods.
   * @return	void
   */

  var DisplayFormatFieldSetting = acf.FieldSetting.extend({
    type: '',
    name: '',
    render: function () {
      var $input = this.$('input[type="radio"]:checked');

      if ($input.val() != 'other') {
        this.$('input[type="text"]').val($input.val());
      }
    }
  });
  var DatePickerDisplayFormatFieldSetting = DisplayFormatFieldSetting.extend({
    type: 'date_picker',
    name: 'display_format'
  });
  var DatePickerReturnFormatFieldSetting = DisplayFormatFieldSetting.extend({
    type: 'date_picker',
    name: 'return_format'
  });
  acf.registerFieldSetting(DatePickerDisplayFormatFieldSetting);
  acf.registerFieldSetting(DatePickerReturnFormatFieldSetting);
  /**
   * Date Time Picker
   *
   * This field type requires some extra logic for its settings
   *
   * @since	5.0.0
   *
   * @param	object The object containing the extended variables and methods.
   * @return	void
   */

  var DateTimePickerDisplayFormatFieldSetting = DisplayFormatFieldSetting.extend({
    type: 'date_time_picker',
    name: 'display_format'
  });
  var DateTimePickerReturnFormatFieldSetting = DisplayFormatFieldSetting.extend({
    type: 'date_time_picker',
    name: 'return_format'
  });
  acf.registerFieldSetting(DateTimePickerDisplayFormatFieldSetting);
  acf.registerFieldSetting(DateTimePickerReturnFormatFieldSetting);
  /**
   * Time Picker
   *
   * This field type requires some extra logic for its settings
   *
   * @since	5.0.0
   *
   * @param	object The object containing the extended variables and methods.
   * @return	void
   */

  var TimePickerDisplayFormatFieldSetting = DisplayFormatFieldSetting.extend({
    type: 'time_picker',
    name: 'display_format'
  });
  var TimePickerReturnFormatFieldSetting = DisplayFormatFieldSetting.extend({
    type: 'time_picker',
    name: 'return_format'
  });
  acf.registerFieldSetting(TimePickerDisplayFormatFieldSetting);
  acf.registerFieldSetting(TimePickerReturnFormatFieldSetting);
  /**
   * Color Picker Settings.
   *
   * @date	16/12/20
   * @since	5.9.4
   *
   * @param	object The object containing the extended variables and methods.
   * @return	void
   */

  var ColorPickerReturnFormat = acf.FieldSetting.extend({
    type: 'color_picker',
    name: 'enable_opacity',
    render: function () {
      var $return_format_setting = this.fieldObject.$setting('return_format');
      var $default_value_setting = this.fieldObject.$setting('default_value');
      var $labelText = $return_format_setting.find('input[type="radio"][value="string"]').parent('label').contents().last();
      var $defaultPlaceholder = $default_value_setting.find('input[type="text"]');
      var l10n = acf.get('colorPickerL10n');

      if (this.field.val()) {
        $labelText.replaceWith(l10n.rgba_string);
        $defaultPlaceholder.attr('placeholder', 'rgba(255,255,255,0.8)');
      } else {
        $labelText.replaceWith(l10n.hex_string);
        $defaultPlaceholder.attr('placeholder', '#FFFFFF');
      }
    }
  });
  acf.registerFieldSetting(ColorPickerReturnFormat);
})(jQuery);

/***/ }),

/***/ "./src/advanced-custom-fields-pro/assets/src/js/_field-group.js":
/*!**********************************************************************!*\
  !*** ./src/advanced-custom-fields-pro/assets/src/js/_field-group.js ***!
  \**********************************************************************/
/***/ (function() {

(function ($, undefined) {
  /**
   *  fieldGroupManager
   *
   *  Generic field group functionality
   *
   *  @date	15/12/17
   *  @since	5.7.0
   *
   *  @param	void
   *  @return	void
   */
  var fieldGroupManager = new acf.Model({
    id: 'fieldGroupManager',
    wait: 'prepare',
    events: {
      'submit #post': 'onSubmit',
      'click a[href="#"]': 'onClick',
      'click .acf-delete-field-group': 'onClickDeleteFieldGroup'
    },
    filters: {
      find_fields_args: 'filterFindFieldArgs',
      find_fields_selector: 'filterFindFieldsSelector'
    },
    initialize: function () {
      let $field_list_wrapper = $('#acf-field-group-fields > .inside > .acf-field-list-wrap.acf-auto-add-field');

      if ($field_list_wrapper.length) {
        $('.acf-headerbar-actions .add-field').trigger('click');
        $('.acf-title-wrap #title').trigger('focus');
      }
    },
    onSubmit: function (e, $el) {
      // vars
      var $title = $('.acf-title-wrap #title'); // empty

      if (!$title.val()) {
        // prevent default
        e.preventDefault(); // unlock form

        acf.unlockForm($el); // alert

        alert(acf.__('Field group title is required')); // focus

        $title.trigger('focus');
      }
    },
    onClick: function (e) {
      e.preventDefault();
    },
    onClickDeleteFieldGroup: function (e, $el) {
      e.preventDefault();
      $el.addClass('-hover'); // Add confirmation tooltip.

      acf.newTooltip({
        confirm: true,
        target: $el,
        context: this,
        text: acf.__('Move field group to trash?'),
        confirm: function () {
          window.location.href = $el.attr('href');
        },
        cancel: function () {
          $el.removeClass('-hover');
        }
      });
    },
    filterFindFieldArgs: function (args) {
      // Don't change this!
      args.visible = true;
      return args;
    },
    filterFindFieldsSelector: function (selector) {
      return selector + ', .acf-field-acf-field-group-settings-tabs';
    }
  });
  /**
   *  screenOptionsManager
   *
   *  Screen options functionality
   *
   *  @date	15/12/17
   *  @since	5.7.0
   *
   *  @param	void
   *  @return	void
   */

  var screenOptionsManager = new acf.Model({
    id: 'screenOptionsManager',
    wait: 'prepare',
    events: {
      'change #acf-field-key-hide': 'onFieldKeysChange',
      'change [name="screen_columns"]': 'render'
    },
    initialize: function () {
      // vars
      var $div = $('#adv-settings');
      var $append = $('#acf-append-show-on-screen'); // append

      $div.find('.metabox-prefs').append($append.html());
      $div.find('.metabox-prefs br').remove(); // clean up

      $append.remove(); // initialize

      this.$el = $('#screen-options-wrap'); // render

      this.render();
    },
    isFieldKeysChecked: function () {
      return this.$el.find('#acf-field-key-hide').prop('checked');
    },
    getSelectedColumnCount: function () {
      return this.$el.find('input[name="screen_columns"]:checked').val();
    },
    onFieldKeysChange: function (e, $el) {
      var val = this.isFieldKeysChecked() ? 1 : 0;
      acf.updateUserSetting('show_field_keys', val);
      this.render();
    },
    render: function () {
      if (this.isFieldKeysChecked()) {
        $('#acf-field-group-fields').addClass('show-field-keys');
      } else {
        $('#acf-field-group-fields').removeClass('show-field-keys');
      }

      if (this.getSelectedColumnCount() == 1) {
        $('body').removeClass('columns-2');
        $('body').addClass('columns-1');
      } else {
        $('body').removeClass('columns-1');
        $('body').addClass('columns-2');
      }
    }
  });
  /**
   *  appendFieldManager
   *
   *  Appends fields together
   *
   *  @date	15/12/17
   *  @since	5.7.0
   *
   *  @param	void
   *  @return	void
   */

  var appendFieldManager = new acf.Model({
    actions: {
      new_field: 'onNewField'
    },
    onNewField: function (field) {
      // bail early if not append
      if (!field.has('append')) return; // vars

      var append = field.get('append');
      var $sibling = field.$el.siblings('[data-name="' + append + '"]').first(); // bail early if no sibling

      if (!$sibling.length) return; // ul

      var $div = $sibling.children('.acf-input');
      var $ul = $div.children('ul'); // create ul

      if (!$ul.length) {
        $div.wrapInner('<ul class="acf-hl"><li></li></ul>');
        $ul = $div.children('ul');
      } // li


      var html = field.$('.acf-input').html();
      var $li = $('<li>' + html + '</li>');
      $ul.append($li);
      $ul.attr('data-cols', $ul.children().length); // clean up

      field.remove();
    }
  });
})(jQuery);

/***/ })

/******/ 	});
/************************************************************************/
/******/ 	// The module cache
/******/ 	var __webpack_module_cache__ = {};
/******/ 	
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/ 		// Check if module is in cache
/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
/******/ 		if (cachedModule !== undefined) {
/******/ 			return cachedModule.exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = __webpack_module_cache__[moduleId] = {
/******/ 			// no module.id needed
/******/ 			// no module.loaded needed
/******/ 			exports: {}
/******/ 		};
/******/ 	
/******/ 		// Execute the module function
/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
/******/ 	
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/ 	
/************************************************************************/
/******/ 	/* webpack/runtime/compat get default export */
/******/ 	!function() {
/******/ 		// getDefaultExport function for compatibility with non-harmony modules
/******/ 		__webpack_require__.n = function(module) {
/******/ 			var getter = module && module.__esModule ?
/******/ 				function() { return module['default']; } :
/******/ 				function() { return module; };
/******/ 			__webpack_require__.d(getter, { a: getter });
/******/ 			return getter;
/******/ 		};
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/define property getters */
/******/ 	!function() {
/******/ 		// define getter functions for harmony exports
/******/ 		__webpack_require__.d = function(exports, definition) {
/******/ 			for(var key in definition) {
/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
/******/ 				}
/******/ 			}
/******/ 		};
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
/******/ 	!function() {
/******/ 		__webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/make namespace object */
/******/ 	!function() {
/******/ 		// define __esModule on exports
/******/ 		__webpack_require__.r = function(exports) {
/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ 			}
/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
/******/ 		};
/******/ 	}();
/******/ 	
/************************************************************************/
var __webpack_exports__ = {};
// This entry need to be wrapped in an IIFE because it need to be in strict mode.
!function() {
"use strict";
/*!*************************************************************************!*\
  !*** ./src/advanced-custom-fields-pro/assets/src/js/acf-field-group.js ***!
  \*************************************************************************/
__webpack_require__.r(__webpack_exports__);
/* harmony import */ var _field_group_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./_field-group.js */ "./src/advanced-custom-fields-pro/assets/src/js/_field-group.js");
/* harmony import */ var _field_group_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_field_group_js__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _field_group_field_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./_field-group-field.js */ "./src/advanced-custom-fields-pro/assets/src/js/_field-group-field.js");
/* harmony import */ var _field_group_field_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_field_group_field_js__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var _field_group_settings_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./_field-group-settings.js */ "./src/advanced-custom-fields-pro/assets/src/js/_field-group-settings.js");
/* harmony import */ var _field_group_settings_js__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_field_group_settings_js__WEBPACK_IMPORTED_MODULE_2__);
/* harmony import */ var _field_group_conditions_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./_field-group-conditions.js */ "./src/advanced-custom-fields-pro/assets/src/js/_field-group-conditions.js");
/* harmony import */ var _field_group_conditions_js__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_field_group_conditions_js__WEBPACK_IMPORTED_MODULE_3__);
/* harmony import */ var _field_group_fields_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./_field-group-fields.js */ "./src/advanced-custom-fields-pro/assets/src/js/_field-group-fields.js");
/* harmony import */ var _field_group_fields_js__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_field_group_fields_js__WEBPACK_IMPORTED_MODULE_4__);
/* harmony import */ var _field_group_locations_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./_field-group-locations.js */ "./src/advanced-custom-fields-pro/assets/src/js/_field-group-locations.js");
/* harmony import */ var _field_group_locations_js__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_field_group_locations_js__WEBPACK_IMPORTED_MODULE_5__);
/* harmony import */ var _field_group_compatibility_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./_field-group-compatibility.js */ "./src/advanced-custom-fields-pro/assets/src/js/_field-group-compatibility.js");
/* harmony import */ var _field_group_compatibility_js__WEBPACK_IMPORTED_MODULE_6___default = /*#__PURE__*/__webpack_require__.n(_field_group_compatibility_js__WEBPACK_IMPORTED_MODULE_6__);







}();
/******/ })()
;
//# sourceMappingURL=acf-field-group.js.map