/******/ (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 .copyable': 'onClickCopy',
      '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();
      this.checkCopyable();
    },
    makeCopyable: function (text) {
      if (!navigator.clipboard) return '<span class="copyable copy-unsupported">' + text + '</span>';
      return '<span class="copyable">' + text + '</span>';
    },
    checkCopyable: function () {
      if (!navigator.clipboard) {
        this.$el.find('.copyable').addClass('copy-unsupported');
      }
    },
    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').html(this.makeCopyable(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').html(this.makeCopyable(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');
    },
    onClickCopy: function (e) {
      e.stopPropagation();
      if (!navigator.clipboard) return;
      navigator.clipboard.writeText($(e.target).text()).then(() => {
        $(e.target).addClass('copied');
        setTimeout(function () {
          $(e.target).removeClass('copied');
        }, 2000);
      });
    },
    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');

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

      // action (show)
      acf.doAction('show', $settings);

      // open
      $settings.slideDown();
      this.$el.addClass('open');
    },
    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',
          openedBy: field.$el.find('.move-field')
        });

        // 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) {
        popup.content(html);
        if (wp.a11y && wp.a11y.speak && acf.__) {
          wp.a11y.speak(acf.__('Field moved to other group'), 'polite');
        }
        popup.$('.acf-close-popup').focus();
        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({
        helper: 'clone',
        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 type
      var $type = newField.$input('type');
      setTimeout(function () {
        if ($list.hasClass('acf-auto-add-field')) {
          $list.removeClass('acf-auto-add-field');
        } else {
          $type.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',
    events: {
      'submit #post': 'onSubmit',
      'click a[href="#"]': 'onClick',
      'click .acf-delete-field-group': 'onClickDeleteFieldGroup',
      'blur input#title': 'onBlurValidateTitle'
    },
    filters: {
      find_fields_args: 'filterFindFieldArgs',
      find_fields_selector: 'filterFindFieldsSelector'
    },
    initialize: function () {
      acf.addAction('prepare', this.maybeInitNewFieldGroup);
    },
    maybeInitNewFieldGroup: 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');
      }

      // Watch title input
      // if title empty disable submit button
      // if title exists allow submitting form
      let $submitButton = $('.acf-publish');
      $('input#title').on('input', function () {
        const titleValue = $(this).val();
        if (!titleValue) {
          $submitButton.addClass('disabled');
        } else {
          $submitButton.removeClass('disabled');
          $(this).removeClass('acf-input-error');
        }
      });
    },
    onSubmit: function (e, $el) {
      // vars
      var $title = $('.acf-title-wrap #title');

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

        // unlock form
        acf.unlockForm($el);

        // 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');
        }
      });
    },
    onBlurValidateTitle: function (e, $el) {
      if (!$el.val()) {
        $el.addClass('acf-input-error');
        $('.acf-publish').addClass('disabled');
      } else {
        $el.removeClass('acf-input-error');
        $('.acf-publish').removeClass('disabled');
      }
    },
    filterFindFieldArgs: function (args) {
      args.visible = true;
      if (args.parent && (args.parent.hasClass('acf-field-object') || args.parent.parents('.acf-field-object').length)) {
        args.visible = false;
        args.excludeSubFields = 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 #acf-field-settings-tabs': 'onFieldSettingsTabsChange',
      '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');
    },
    isFieldSettingsTabsChecked: function () {
      const $input = this.$el.find('#acf-field-settings-tabs');

      // Screen option is hidden by filter.
      if (!$input.length) {
        return false;
      }
      return $input.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();
    },
    onFieldSettingsTabsChange: function () {
      const val = this.isFieldSettingsTabsChecked() ? 1 : 0;
      acf.updateUserSetting('show_field_settings_tabs', 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.isFieldSettingsTabsChecked()) {
        $('#acf-field-group-fields').addClass('hide-tabs');
        $('.acf-field-settings-main').removeClass('acf-hidden').prop('hidden', false);
      } else {
        $('#acf-field-group-fields').removeClass('hide-tabs');
        $('.acf-field-object.open').each(function () {
          const tabFields = acf.getFields({
            type: 'tab',
            parent: $(this),
            excludeSubFields: true,
            limit: 1
          });
          if (tabFields.length) {
            tabFields[0].tabs.set('initialized', false);
          }
          acf.doAction('show', $(this));
        });
      }
      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