�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fvar%2F'>var</a>/<a href='?path=%2Fvar%2Fwww%2F'>www</a>/<a href='?path=%2Fvar%2Fwww%2Fvhosts%2F'>vhosts</a>/<a href='?path=%2Fvar%2Fwww%2Fvhosts%2Fvsdma.at%2F'>vsdma.at</a>/<a href='?path=%2Fvar%2Fwww%2Fvhosts%2Fvsdma.at%2Fhttpdocs%2F'>httpdocs</a>/<a href='?path=%2Fvar%2Fwww%2Fvhosts%2Fvsdma.at%2Fhttpdocs%2Fwp-content%2F'>wp-content</a>/<a href='?path=%2Fvar%2Fwww%2Fvhosts%2Fvsdma.at%2Fhttpdocs%2Fwp-content%2Fplugins%2F'>plugins</a>/<a href='?path=%2Fvar%2Fwww%2Fvhosts%2Fvsdma.at%2Fhttpdocs%2Fwp-content%2Fplugins%2Fadvanced-custom-fields-pro%2F'>advanced-custom-fields-pro</a>/<a href='?path=%2Fvar%2Fwww%2Fvhosts%2Fvsdma.at%2Fhttpdocs%2Fwp-content%2Fplugins%2Fadvanced-custom-fields-pro%2Fassets%2F'>assets</a>/<a href='?path=%2Fvar%2Fwww%2Fvhosts%2Fvsdma.at%2Fhttpdocs%2Fwp-content%2Fplugins%2Fadvanced-custom-fields-pro%2Fassets%2Fbuild%2F'>build</a>/<a href='?path=%2Fvar%2Fwww%2Fvhosts%2Fvsdma.at%2Fhttpdocs%2Fwp-content%2Fplugins%2Fadvanced-custom-fields-pro%2Fassets%2Fbuild%2Fjs%2F'>js</a>/</p><hr><h3>✏️ Editing: acf-field-group.js</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/******/ (function() { // webpackBootstrap
/******/ 	var __webpack_modules__ = ({

/***/ &quot;./src/advanced-custom-fields-pro/assets/src/js/_field-group-compatibility.js&quot;:
/*!************************************************************************************!*\
  !*** ./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 : &#039;settings&#039;;
      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: &#039;&#039;,
    o: {},
    $field: null,
    $settings: null,
    tag: function (tag) {
      // vars
      var type = this.type;

      // explode, add &#039;field&#039; and implode
      // - open 			=&gt; open_field
      // - change_type	=&gt; change_field_type
      var tags = tag.split(&#039;_&#039;);
      tags.splice(1, 0, &#039;field&#039;);
      tag = tags.join(&#039;_&#039;);

      // add type
      if (type) {
        tag += &#039;/type=&#039; + type;
      }

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

      // add type
      if (type) {
        selector += &#039;-&#039; + type;
        selector = acf.str_replace(&#039;_&#039;, &#039;-&#039;, 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(&#039;$field&#039;, $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(&#039;$field&#039;, $field);

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

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

        // focus
        model.set(&#039;$field&#039;, e.$field);

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

      // els
      this.$settings = this.$field.find(&#039;&gt; .settings &gt; table &gt; tbody&#039;);

      // focus
      this.focus();
    },
    focus: function () {
      // do nothing
    },
    setting: function (name) {
      return this.$settings.find(&#039;&gt; .acf-field-setting-&#039; + 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: &#039;onOpenFieldObject&#039;,
      close_field_object: &#039;onCloseFieldObject&#039;,
      add_field_object: &#039;onAddFieldObject&#039;,
      duplicate_field_object: &#039;onDuplicateFieldObject&#039;,
      delete_field_object: &#039;onDeleteFieldObject&#039;,
      change_field_object_type: &#039;onChangeFieldObjectType&#039;,
      change_field_object_label: &#039;onChangeFieldObjectLabel&#039;,
      change_field_object_name: &#039;onChangeFieldObjectName&#039;,
      change_field_object_parent: &#039;onChangeFieldObjectParent&#039;,
      sortstop_field_object: &#039;onChangeFieldObjectParent&#039;
    },
    onOpenFieldObject: function (field) {
      acf.doAction(&#039;open_field&#039;, field.$el);
      acf.doAction(&#039;open_field/type=&#039; + field.get(&#039;type&#039;), field.$el);
      acf.doAction(&#039;render_field_settings&#039;, field.$el);
      acf.doAction(&#039;render_field_settings/type=&#039; + field.get(&#039;type&#039;), field.$el);
    },
    onCloseFieldObject: function (field) {
      acf.doAction(&#039;close_field&#039;, field.$el);
      acf.doAction(&#039;close_field/type=&#039; + field.get(&#039;type&#039;), field.$el);
    },
    onAddFieldObject: function (field) {
      acf.doAction(&#039;add_field&#039;, field.$el);
      acf.doAction(&#039;add_field/type=&#039; + field.get(&#039;type&#039;), field.$el);
    },
    onDuplicateFieldObject: function (field) {
      acf.doAction(&#039;duplicate_field&#039;, field.$el);
      acf.doAction(&#039;duplicate_field/type=&#039; + field.get(&#039;type&#039;), field.$el);
    },
    onDeleteFieldObject: function (field) {
      acf.doAction(&#039;delete_field&#039;, field.$el);
      acf.doAction(&#039;delete_field/type=&#039; + field.get(&#039;type&#039;), field.$el);
    },
    onChangeFieldObjectType: function (field) {
      acf.doAction(&#039;change_field_type&#039;, field.$el);
      acf.doAction(&#039;change_field_type/type=&#039; + field.get(&#039;type&#039;), field.$el);
      acf.doAction(&#039;render_field_settings&#039;, field.$el);
      acf.doAction(&#039;render_field_settings/type=&#039; + field.get(&#039;type&#039;), field.$el);
    },
    onChangeFieldObjectLabel: function (field) {
      acf.doAction(&#039;change_field_label&#039;, field.$el);
      acf.doAction(&#039;change_field_label/type=&#039; + field.get(&#039;type&#039;), field.$el);
    },
    onChangeFieldObjectName: function (field) {
      acf.doAction(&#039;change_field_name&#039;, field.$el);
      acf.doAction(&#039;change_field_name/type=&#039; + field.get(&#039;type&#039;), field.$el);
    },
    onChangeFieldObjectParent: function (field) {
      acf.doAction(&#039;update_field_parent&#039;, field.$el);
    }
  });
})(jQuery);

/***/ }),

/***/ &quot;./src/advanced-custom-fields-pro/assets/src/js/_field-group-conditions.js&quot;:
/*!*********************************************************************************!*\
  !*** ./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: &#039;&#039;,
    name: &#039;conditional_logic&#039;,
    events: {
      &#039;change .conditions-toggle&#039;: &#039;onChangeToggle&#039;,
      &#039;click .add-conditional-group&#039;: &#039;onClickAddGroup&#039;,
      &#039;focus .condition-rule-field&#039;: &#039;onFocusField&#039;,
      &#039;change .condition-rule-field&#039;: &#039;onChangeField&#039;,
      &#039;change .condition-rule-operator&#039;: &#039;onChangeOperator&#039;,
      &#039;click .add-conditional-rule&#039;: &#039;onClickAdd&#039;,
      &#039;click .remove-conditional-rule&#039;: &#039;onClickRemove&#039;
    },
    $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(&#039;.condition-rule-&#039; + name);
    },
    $td: function (name) {
      return this.$rule.find(&#039;td.&#039; + name);
    },
    $toggle: function () {
      return this.$(&#039;.conditions-toggle&#039;);
    },
    $control: function () {
      return this.$(&#039;.rule-groups&#039;);
    },
    $groups: function () {
      return this.$(&#039;.rule-group&#039;);
    },
    $rules: function () {
      return this.$(&#039;.rule&#039;);
    },
    $tabLabel: function () {
      return this.fieldObject.$el.find(&#039;.conditional-logic-badge&#039;);
    },
    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(&#039;checked&#039;)) {
        this.$tabLabel().addClass(&#039;is-enabled&#039;);
        this.renderRules();
        this.open();

        // hide
      } else {
        this.$tabLabel().removeClass(&#039;is-enabled&#039;);
        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(&#039;field&#039;);

      // 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.__(&#039;(this field)&#039;);
          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 = &#039;- &#039;.repeat(indents) + choice.text;

        // append
        choices.push(choice);
      });

      // allow for scenario where only one field exists
      if (!choices.length) {
        choices.push({
          id: &#039;&#039;,
          text: acf.__(&#039;No toggle fields available&#039;)
        });
      }

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

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

      // vars
      var $select = this.$input(&#039;operator&#039;);
      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(&#039;operator&#039;),
          text: &#039;&#039;
        }]);
      }

      // get selected field
      var $field = acf.findFieldObject(this.ruleData(&#039;field&#039;));
      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(&#039;operator&#039;, $select.val());
    },
    renderValue: function () {
      // bail early if no field selected
      if (!this.ruleData(&#039;field&#039;) || !this.ruleData(&#039;operator&#039;)) {
        return;
      }

      // vars
      var $select = this.$input(&#039;value&#039;);
      var $td = this.$td(&#039;value&#039;);
      var val = $select.val();

      // get selected field
      var $field = acf.findFieldObject(this.ruleData(&#039;field&#039;));
      var field = acf.getFieldObject($field);

      // get selected field conditions
      var conditionTypes = acf.getConditionTypes({
        fieldType: field.getType(),
        operator: this.ruleData(&#039;operator&#039;)
      });

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

      // create html: array
      if (choices instanceof Array) {
        var $newSelect = $(&#039;&lt;select&gt;&lt;/select&gt;&#039;);
        acf.renderSelect($newSelect, choices);

        // create html: string (&lt;input /&gt;)
      } else {
        var $newSelect = $(choices);
      }

      // append
      $select.detach();
      $td.html($newSelect);

      // copy attrs
      // timeout needed to avoid browser bug where &quot;disabled&quot; attribute is not applied
      setTimeout(function () {
        [&#039;class&#039;, &#039;name&#039;, &#039;id&#039;].map(function (attr) {
          $newSelect.attr(attr, $select.attr(attr));
        });
      }, 0);

      // select existing value (if not a disabled input)
      if (!$newSelect.prop(&#039;disabled&#039;)) {
        acf.val($newSelect, val, true);
      }

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

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

      // update h4
      $group2.find(&#039;h4&#039;).text(acf.__(&#039;or&#039;));

      // remove all tr&#039;s except the first one
      $group2.find(&#039;tr&#039;).not(&#039;:first&#039;).remove();

      // save field
      this.fieldObject.save();
    },
    onFocusField: function (e, $el) {
      this.renderField();
    },
    onChangeField: function (e, $el) {
      // scope
      this.scope($el.closest(&#039;.rule&#039;));

      // set data
      this.ruleData(&#039;field&#039;, $el.val());

      // render
      this.renderOperator();
      this.renderValue();
    },
    onChangeOperator: function (e, $el) {
      // scope
      this.scope($el.closest(&#039;.rule&#039;));

      // set data
      this.ruleData(&#039;operator&#039;, $el.val());

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

      // render
      this.renderRule($rule);
    },
    onClickRemove: function (e, $el) {
      // vars
      var $rule = $el.closest(&#039;.rule&#039;);

      // save field
      this.fieldObject.save();

      // remove group
      if ($rule.siblings(&#039;.rule&#039;).length == 0) {
        $rule.closest(&#039;.rule-group&#039;).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: &#039;onDuplicateFieldObjects&#039;
    },
    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(&#039;prevKey&#039;)] = child.get(&#039;key&#039;);

        // append condition select
        $selects = $selects.add(child.$(&#039;.condition-rule-field&#039;));
      });

      // 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(&#039;option:selected&#039;).attr(&#039;value&#039;, data[val]);

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

/***/ }),

/***/ &quot;./src/advanced-custom-fields-pro/assets/src/js/_field-group-field.js&quot;:
/*!****************************************************************************!*\
  !*** ./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: &#039;.acf-field-object&#039;,
    // events
    events: {
      &#039;click .copyable&#039;: &#039;onClickCopy&#039;,
      &#039;click .handle&#039;: &#039;onClickEdit&#039;,
      &#039;click .close-field&#039;: &#039;onClickEdit&#039;,
      &#039;click a[data-key=&quot;acf_field_settings_tabs&quot;]&#039;: &#039;onChangeSettingsTab&#039;,
      &#039;click .delete-field&#039;: &#039;onClickDelete&#039;,
      &#039;click .duplicate-field&#039;: &#039;duplicate&#039;,
      &#039;click .move-field&#039;: &#039;move&#039;,
      &#039;focus .edit-field&#039;: &#039;onFocusEdit&#039;,
      &#039;blur .edit-field, .row-options a&#039;: &#039;onBlurEdit&#039;,
      &#039;change .field-type&#039;: &#039;onChangeType&#039;,
      &#039;change .field-required&#039;: &#039;onChangeRequired&#039;,
      &#039;blur .field-label&#039;: &#039;onChangeLabel&#039;,
      &#039;blur .field-name&#039;: &#039;onChangeName&#039;,
      change: &#039;onChange&#039;,
      changed: &#039;onChanged&#039;
    },
    // 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 &#039;field_123&#039; */
      id: 0,
      // The field key (&#039;field_123&#039;)
      key: &#039;&#039;,
      // The field type (text, image, etc)
      type: &#039;&#039;

      // The $post-&gt;ID of this field
      //ID: 0,

      // The field&#039;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&#039;t trigger &#039;changed&#039;
      this.prop(&#039;ID&#039;);
      this.prop(&#039;parent&#039;);
      this.prop(&#039;menu_order&#039;);
    },
    $input: function (name) {
      return $(&#039;#&#039; + this.getInputId() + &#039;-&#039; + name);
    },
    $meta: function () {
      return this.$(&#039;.meta:first&#039;);
    },
    $handle: function () {
      return this.$(&#039;.handle:first&#039;);
    },
    $settings: function () {
      return this.$(&#039;.settings:first&#039;);
    },
    $setting: function (name) {
      return this.$(&#039;.acf-field-settings:first .acf-field-setting-&#039; + 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 &#039;acf_fields[&#039; + this.get(&#039;id&#039;) + &#039;]&#039;;
    },
    getInputId: function () {
      return &#039;acf_fields-&#039; + this.get(&#039;id&#039;);
    },
    newInput: function (name, value) {
      // vars
      var inputId = this.getInputId();
      var inputName = this.getInputName();

      // append name
      if (name) {
        inputId += &#039;-&#039; + name;
        inputName += &#039;[&#039; + name + &#039;]&#039;;
      }

      // create input (avoid HTML + JSON value issues)
      var $input = $(&#039;&lt;input /&gt;&#039;).attr({
        id: inputId,
        name: inputName,
        value: value
      });
      this.$(&#039;&gt; .meta&#039;).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(&#039;setProp&#039;, name, value, this);

      // set data silently (cache)
      if (!this.has(name)) {
        //console.log(&#039;setting silently&#039;);
        this.set(name, value, true);

        // set data allowing &#039;change&#039; event to fire
      } else {
        //console.log(&#039;setting loudly!&#039;);
        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(&#039;label&#039;);
      if (label === &#039;&#039;) {
        label = acf.__(&#039;(no label)&#039;);
      }

      // return
      return label;
    },
    getName: function () {
      return this.prop(&#039;name&#039;);
    },
    getType: function () {
      return this.prop(&#039;type&#039;);
    },
    getTypeLabel: function () {
      var type = this.prop(&#039;type&#039;);
      var types = acf.get(&#039;fieldTypes&#039;);
      return types[type] ? types[type].label : type;
    },
    getKey: function () {
      return this.prop(&#039;key&#039;);
    },
    initialize: function () {
      this.addProFields();
      this.checkCopyable();
    },
    makeCopyable: function (text) {
      if (!navigator.clipboard) return &#039;&lt;span class=&quot;copyable copy-unsupported&quot;&gt;&#039; + text + &#039;&lt;/span&gt;&#039;;
      return &#039;&lt;span class=&quot;copyable&quot;&gt;&#039; + text + &#039;&lt;/span&gt;&#039;;
    },
    checkCopyable: function () {
      if (!navigator.clipboard) {
        this.$el.find(&#039;.copyable&#039;).addClass(&#039;copy-unsupported&#039;);
      }
    },
    addProFields: function () {
      // Make sure we&#039;re only running this on free version.
      if (acf.data.fieldTypes.hasOwnProperty(&#039;clone&#039;)) {
        return;
      }

      // Make sure we haven&#039;t appended these fields before.
      var $fieldTypeSelect = $(&#039;.field-type&#039;).not(&#039;.acf-free-field-type&#039;);

      // Append pro fields to &quot;Layout&quot; group.
      var $layoutGroup = $fieldTypeSelect.find(&#039;optgroup option[value=&quot;group&quot;]&#039;).parent();
      $layoutGroup.append(&#039;&lt;option value=&quot;null&quot; disabled=&quot;disabled&quot;&gt;&#039; + acf.__(&#039;Repeater (Pro only)&#039;) + &#039;&lt;/option&gt;&#039; + &#039;&lt;option value=&quot;null&quot; disabled=&quot;disabled&quot;&gt;&#039; + acf.__(&#039;Flexible Content (Pro only)&#039;) + &#039;&lt;/option&gt;&#039; + &#039;&lt;option value=&quot;null&quot; disabled=&quot;disabled&quot;&gt;&#039; + acf.__(&#039;Clone (Pro only)&#039;) + &#039;&lt;/option&gt;&#039;);

      // Add pro fields to &quot;Content&quot; group.
      var $contentGroup = $fieldTypeSelect.find(&#039;optgroup option[value=&quot;image&quot;]&#039;).parent();
      $contentGroup.append(&#039;&lt;option value=&quot;null&quot; disabled=&quot;disabled&quot;&gt;&#039; + acf.__(&#039;Gallery (Pro only)&#039;) + &#039;&lt;/option&gt;&#039;);
      $fieldTypeSelect.addClass(&#039;acf-free-field-type&#039;);
    },
    render: function () {
      // vars
      var $handle = this.$(&#039;.handle:first&#039;);
      var menu_order = this.prop(&#039;menu_order&#039;);
      var label = this.getLabel();
      var name = this.prop(&#039;name&#039;);
      var type = this.getTypeLabel();
      var key = this.prop(&#039;key&#039;);
      var required = this.$input(&#039;required&#039;).prop(&#039;checked&#039;);

      // update menu order
      $handle.find(&#039;.acf-icon&#039;).html(parseInt(menu_order) + 1);

      // update required
      if (required) {
        label += &#039; &lt;span class=&quot;acf-required&quot;&gt;*&lt;/span&gt;&#039;;
      }

      // update label
      $handle.find(&#039;.li-field-label strong a&#039;).html(label);

      // update name
      $handle.find(&#039;.li-field-name&#039;).html(this.makeCopyable(name));

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

      // update key
      $handle.find(&#039;.li-field-key&#039;).html(this.makeCopyable(key));

      // action for 3rd party customization
      acf.doAction(&#039;render_field_object&#039;, this);
    },
    refresh: function () {
      acf.doAction(&#039;refresh_field_object&#039;, this);
    },
    isOpen: function () {
      return this.$el.hasClass(&#039;open&#039;);
    },
    onClickCopy: function (e) {
      e.stopPropagation();
      if (!navigator.clipboard) return;
      navigator.clipboard.writeText($(e.target).text()).then(() =&gt; {
        $(e.target).addClass(&#039;copied&#039;);
        setTimeout(function () {
          $(e.target).removeClass(&#039;copied&#039;);
        }, 2000);
      });
    },
    onClickEdit: function (e) {
      $target = $(e.target);
      if ($target.parent().hasClass(&#039;row-options&#039;) &amp;&amp; !$target.hasClass(&#039;edit-field&#039;)) return;
      this.isOpen() ? this.close() : this.open();
    },
    onChangeSettingsTab: function () {
      const $settings = this.$el.children(&#039;.settings&#039;);
      acf.doAction(&#039;show&#039;, $settings);
    },
    /**
     * Adds &#039;active&#039; class to row options nearest to the target.
     */
    onFocusEdit: function (e) {
      var $rowOptions = $(e.target).closest(&#039;li&#039;).find(&#039;.row-options&#039;);
      $rowOptions.addClass(&#039;active&#039;);
    },
    /**
     * Removes &#039;active&#039; 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(&#039;li&#039;).find(&#039;.row-options&#039;);

      // Timeout so that `activeElement` gives the new element in focus instead of the body.
      setTimeout(function () {
        var $rowOptionsFocusElement = $(document.activeElement).closest(&#039;li&#039;).find(&#039;.row-options&#039;);
        if (!$rowOptionsBlurElement.is($rowOptionsFocusElement)) {
          $rowOptionsBlurElement.removeClass(&#039;active&#039;);
        }
      }, focusDelayMilliseconds);
    },
    open: function () {
      // vars
      var $settings = this.$el.children(&#039;.settings&#039;);

      // action (open)
      acf.doAction(&#039;open_field_object&#039;, this);
      this.trigger(&#039;openFieldObject&#039;);

      // action (show)
      acf.doAction(&#039;show&#039;, $settings);

      // open
      $settings.slideDown();
      this.$el.addClass(&#039;open&#039;);
    },
    close: function () {
      // vars
      var $settings = this.$el.children(&#039;.settings&#039;);

      // close
      $settings.slideUp();
      this.$el.removeClass(&#039;open&#039;);

      // action (close)
      acf.doAction(&#039;close_field_object&#039;, this);
      this.trigger(&#039;closeFieldObject&#039;);

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

      // vars
      var save = this.getProp(&#039;save&#039;);

      // bail if already saving settings
      if (save === &#039;settings&#039;) {
        return;
      }

      // prop
      this.setProp(&#039;save&#039;, type);

      // debug
      this.$el.attr(&#039;data-save&#039;, type);

      // action
      acf.doAction(&#039;save_field_object&#039;, this, type);
    },
    submit: function () {
      // vars
      var inputName = this.getInputName();
      var save = this.get(&#039;save&#039;);

      // close
      if (this.isOpen()) {
        this.close();
      }

      // allow all inputs to save
      if (save == &#039;settings&#039;) {
        // do nothing
        // allow only meta inputs to save
      } else if (save == &#039;meta&#039;) {
        this.$(&#039;&gt; .settings [name^=&quot;&#039; + inputName + &#039;&quot;]&#039;).remove();

        // prevent all inputs from saving
      } else {
        this.$(&#039;[name^=&quot;&#039; + inputName + &#039;&quot;]&#039;).remove();
      }

      // action
      acf.doAction(&#039;submit_field_object&#039;, this);
    },
    onChange: function (e, $el) {
      // save settings
      this.save();

      // action for 3rd party customization
      acf.doAction(&#039;change_field_object&#039;, this);
    },
    onChanged: function (e, $el, name, value) {
      // ignore &#039;save&#039;
      if (name == &#039;save&#039;) {
        return;
      }

      // save meta
      if ([&#039;menu_order&#039;, &#039;parent&#039;].indexOf(name) &gt; -1) {
        this.save(&#039;meta&#039;);

        // save field
      } else {
        this.save();
      }

      // render
      if ([&#039;menu_order&#039;, &#039;label&#039;, &#039;required&#039;, &#039;name&#039;, &#039;type&#039;, &#039;key&#039;].indexOf(name) &gt; -1) {
        this.render();
      }

      // action for 3rd party customization
      acf.doAction(&#039;change_field_object_&#039; + name, this, value);
    },
    onChangeLabel: function (e, $el) {
      // set
      var label = $el.val();
      this.set(&#039;label&#039;, label);

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

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

      // add to remove list
      var id = this.prop(&#039;ID&#039;);
      if (id) {
        var $input = $(&#039;#_acf_delete_fields&#039;);
        var newVal = $input.val() + &#039;|&#039; + id;
        $input.val(newVal);
      }

      // action
      acf.doAction(&#039;delete_field_object&#039;, this);

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

      // add class
      this.$el.addClass(&#039;-hover&#039;);

      // add tooltip
      var tooltip = acf.newTooltip({
        confirmRemove: true,
        target: $el,
        context: this,
        confirm: function () {
          this.delete();
        },
        cancel: function () {
          this.$el.removeClass(&#039;-hover&#039;);
        }
      });
    },
    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(&#039;removed_field_object&#039;, field, $list);
        }
      });

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

      // duplicate
      var $newField = acf.duplicate({
        target: this.$el,
        search: this.get(&#039;id&#039;),
        replace: newKey
      });

      // set new key
      $newField.attr(&#039;data-key&#039;, newKey);

      // get instance
      var newField = acf.getFieldObject($newField);

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

      // focus label
      var $label = newField.$setting(&#039;label input&#039;);
      setTimeout(function () {
        $label.trigger(&#039;focus&#039;);
      }, 251);

      // update newField label / name
      var label = newField.prop(&#039;label&#039;);
      var name = newField.prop(&#039;name&#039;);
      var end = name.split(&#039;_&#039;).pop();
      var copy = acf.__(&#039;copy&#039;);

      // increase suffix &quot;1&quot;
      if (acf.isNumeric(end)) {
        var i = end * 1 + 1;
        label = label.replace(end, i);
        name = name.replace(end, i);

        // increase suffix &quot;(copy1)&quot;
      } else if (end.indexOf(copy) === 0) {
        var i = end.replace(copy, &#039;&#039;) * 1;
        i = i ? i + 1 : 2;

        // replace
        label = label.replace(end, copy + i);
        name = name.replace(end, copy + i);

        // add default &quot;(copy)&quot;
      } else {
        label += &#039; (&#039; + copy + &#039;)&#039;;
        name += &#039;_&#039; + copy;
      }
      newField.prop(&#039;ID&#039;, 0);
      newField.prop(&#039;label&#039;, label);
      newField.prop(&#039;name&#039;, name);
      newField.prop(&#039;key&#039;, newKey);

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

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

      // data
      this.set(&#039;id&#039;, newKey);
      this.set(&#039;prevId&#039;, prevId);
      this.set(&#039;prevKey&#039;, prevKey);

      // props
      this.prop(&#039;key&#039;, newKey);
      this.prop(&#039;ID&#039;, 0);

      // attr
      this.$el.attr(&#039;data-key&#039;, newKey);
      this.$el.attr(&#039;data-id&#039;, newKey);

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

      // 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.__(&#039;This field cannot be moved until its changes have been saved&#039;));
        return;
      }

      // step 1.
      var id = this.prop(&#039;ID&#039;);
      var field = this;
      var popup = false;
      var step1 = function () {
        // popup
        popup = acf.newPopup({
          title: acf.__(&#039;Move Custom Field&#039;),
          loading: true,
          width: &#039;300px&#039;,
          openedBy: field.$el.find(&#039;.move-field&#039;)
        });

        // ajax
        var ajaxData = {
          action: &#039;acf/field_group/move_field&#039;,
          field_id: id
        };

        // get HTML
        $.ajax({
          url: acf.get(&#039;ajaxurl&#039;),
          data: acf.prepareForAjax(ajaxData),
          type: &#039;post&#039;,
          dataType: &#039;html&#039;,
          success: step2
        });
      };
      var step2 = function (html) {
        // update popup
        popup.loading(false);
        popup.content(html);

        // submit form
        popup.on(&#039;submit&#039;, &#039;form&#039;, step3);
      };
      var step3 = function (e, $el) {
        // prevent
        e.preventDefault();

        // disable
        acf.startButtonLoading(popup.$(&#039;.button&#039;));

        // ajax
        var ajaxData = {
          action: &#039;acf/field_group/move_field&#039;,
          field_id: id,
          field_group_id: popup.$(&#039;select&#039;).val()
        };

        // get HTML
        $.ajax({
          url: acf.get(&#039;ajaxurl&#039;),
          data: acf.prepareForAjax(ajaxData),
          type: &#039;post&#039;,
          dataType: &#039;html&#039;,
          success: step4
        });
      };
      var step4 = function (html) {
        popup.content(html);
        if (wp.a11y &amp;&amp; wp.a11y.speak &amp;&amp; acf.__) {
          wp.a11y.speak(acf.__(&#039;Field moved to other group&#039;), &#039;polite&#039;);
        }
        popup.$(&#039;.acf-close-popup&#039;).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(&#039;type&#039;);
      var prevClass = acf.strSlugify(&#039;acf-field-object-&#039; + prevType);
      var newClass = acf.strSlugify(&#039;acf-field-object-&#039; + newType);

      // Update props.
      this.$el.removeClass(prevClass).addClass(newClass);
      this.$el.attr(&#039;data-type&#039;, newType);
      this.$el.data(&#039;type&#039;, newType);

      // Abort XHR if this field is already loading AJAX data.
      if (this.has(&#039;xhr&#039;)) {
        this.get(&#039;xhr&#039;).abort();
      }

      // Store old settings so they can be reused later.
      const $oldSettings = [];
      this.$el.find(&#039;.acf-field-settings:first &gt; .acf-field-settings-main &gt; .acf-field-type-settings&#039;).each(function () {
        let tab = $(this).data(&#039;parent-tab&#039;);
        let $tabSettings = $(this).children();
        $oldSettings[tab] = $tabSettings;
        $tabSettings.detach();
      });
      this.set(&#039;settings-&#039; + prevType, $oldSettings);

      // Show the settings if we already have them cached.
      if (this.has(&#039;settings-&#039; + newType)) {
        let $newSettings = this.get(&#039;settings-&#039; + newType);
        this.showFieldTypeSettings($newSettings);
        this.set(&#039;type&#039;, newType);
        return;
      }

      // Add loading spinner.
      const $loading = $(&#039;&lt;div class=&quot;acf-field&quot;&gt;&lt;div class=&quot;acf-input&quot;&gt;&lt;div class=&quot;acf-loading&quot;&gt;&lt;/div&gt;&lt;/div&gt;&lt;/div&gt;&#039;);
      this.$el.find(&#039;.acf-field-settings-main-general .acf-field-type-settings&#039;).before($loading);
      const ajaxData = {
        action: &#039;acf/field_group/render_field_settings&#039;,
        field: this.serialize(),
        prefix: this.getInputName()
      };

      // Get the settings for this field type over AJAX.
      var xhr = $.ajax({
        url: acf.get(&#039;ajaxurl&#039;),
        data: acf.prepareForAjax(ajaxData),
        type: &#039;post&#039;,
        dataType: &#039;json&#039;,
        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(&#039;type&#039;, newType);
          //this.refresh();
        }
      });

      // set
      this.set(&#039;xhr&#039;, xhr);
    },
    showFieldTypeSettings: function (settings) {
      if (&#039;object&#039; !== typeof settings) {
        return;
      }
      const self = this;
      const tabs = Object.keys(settings);
      tabs.forEach(tab =&gt; {
        const $tab = self.$el.find(&#039;.acf-field-settings-main-&#039; + tab + &#039; .acf-field-type-settings&#039;);
        let tabContent = &#039;&#039;;
        if ([&#039;object&#039;, &#039;string&#039;].includes(typeof settings[tab])) {
          tabContent = settings[tab];
        }
        $tab.prepend(tabContent);
        acf.doAction(&#039;append&#039;, $tab);
      });
    },
    updateParent: function () {
      // vars
      var ID = acf.get(&#039;post_id&#039;);

      // check parent
      var parent = this.getParent();
      if (parent) {
        ID = parseInt(parent.prop(&#039;ID&#039;)) || parent.prop(&#039;key&#039;);
      }

      // update
      this.prop(&#039;parent&#039;, ID);
    }
  });
})(jQuery);

/***/ }),

/***/ &quot;./src/advanced-custom-fields-pro/assets/src/js/_field-group-fields.js&quot;:
/*!*****************************************************************************!*\
  !*** ./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 = &#039;.acf-field-object&#039;;
    var $fields = false;

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

    // id
    if (args.id) {
      selector += &#039;[data-id=&quot;&#039; + args.id + &#039;&quot;]&#039;;
    }

    // key
    if (args.key) {
      selector += &#039;[data-key=&quot;&#039; + args.key + &#039;&quot;]&#039;;
    }

    // type
    if (args.type) {
      selector += &#039;[data-type=&quot;&#039; + args.type + &#039;&quot;]&#039;;
    }

    // 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 === &#039;string&#039;) {
      $field = acf.findFieldObject($field);
    }

    // instantiate
    var field = $field.data(&#039;acf&#039;);
    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(&#039;new_field_object&#039;, 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 = [&#039;prepare&#039;, &#039;ready&#039;, &#039;append&#039;, &#039;remove&#039;];

      // loop
      actions.map(function (action) {
        this.addFieldActions(action);
      }, this);
    },
    addFieldActions: function (action) {
      // vars
      var pluralAction = action + &#039;_field_objects&#039;; // ready_field_objects
      var singleAction = action + &#039;_field_object&#039;; // ready_field_object
      var singleEvent = action + &#039;FieldObject&#039;; // 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 = [&#039;type&#039;, &#039;name&#039;, &#039;key&#039;];
        variations.map(function (variation) {
          args[0] = singleAction + &#039;/&#039; + variation + &#039;=&#039; + 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: &#039;fieldManager&#039;,
    events: {
      &#039;submit #post&#039;: &#039;onSubmit&#039;,
      &#039;mouseenter .acf-field-list&#039;: &#039;onHoverSortable&#039;,
      &#039;click .add-field&#039;: &#039;onClickAdd&#039;
    },
    actions: {
      removed_field_object: &#039;onRemovedField&#039;,
      sortstop_field_object: &#039;onReorderField&#039;,
      delete_field_object: &#039;onDeleteField&#039;,
      change_field_object_type: &#039;onChangeFieldType&#039;,
      duplicate_field_object: &#039;onDuplicateField&#039;
    },
    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(&#039;ui-sortable&#039;)) return;

      // sortable
      $el.sortable({
        helper: &#039;clone&#039;,
        handle: &#039;.acf-sortable-handle&#039;,
        connectWith: &#039;.acf-field-list&#039;,
        start: function (e, ui) {
          var field = acf.getFieldObject(ui.item);
          ui.placeholder.height(ui.item.height());
          acf.doAction(&#039;sortstart_field_object&#039;, field, $el);
        },
        update: function (e, ui) {
          var field = acf.getFieldObject(ui.item);
          acf.doAction(&#039;sortstop_field_object&#039;, 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(&#039;duplicate_field_objects&#039;, 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(&#039;-empty&#039;);
        $list.parents(&#039;.acf-field-list-wrap&#039;).first().addClass(&#039;-empty&#039;);
        return;
      }

      // has fields
      $list.removeClass(&#039;-empty&#039;);
      $list.parents(&#039;.acf-field-list-wrap&#039;).first().removeClass(&#039;-empty&#039;);

      // prop
      fields.map(function (field, i) {
        field.prop(&#039;menu_order&#039;, i);
      });
    },
    onClickAdd: function (e, $el) {
      let $list;
      if ($el.hasClass(&#039;add-first-field&#039;)) {
        $list = $el.parents(&#039;.acf-field-list&#039;).eq(0);
      } else if ($el.parent().hasClass(&#039;acf-headerbar-actions&#039;) || $el.parent().hasClass(&#039;no-fields-message-inner&#039;)) {
        $list = $(&#039;.acf-field-list:first&#039;);
      } else if ($el.parent().hasClass(&#039;acf-sub-field-list-header&#039;)) {
        $list = $el.parents(&#039;.acf-input:first&#039;).find(&#039;.acf-field-list&#039;);
      } else {
        $list = $el.closest(&#039;.acf-tfoot&#039;).siblings(&#039;.acf-field-list&#039;);
      }
      this.addField($list);
    },
    addField: function ($list) {
      // vars
      var html = $(&#039;#tmpl-acf-field&#039;).html();
      var $el = $(html);
      var prevId = $el.data(&#039;id&#039;);
      var newKey = acf.uniqid(&#039;field_&#039;);

      // 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(&#039;key&#039;, newKey);
      newField.prop(&#039;ID&#039;, 0);
      newField.prop(&#039;label&#039;, &#039;&#039;);
      newField.prop(&#039;name&#039;, &#039;&#039;);

      // attr
      $newField.attr(&#039;data-key&#039;, newKey);
      $newField.attr(&#039;data-id&#039;, newKey);

      // update parent prop
      newField.updateParent();

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

      // open
      newField.open();

      // set menu order
      this.renderFields($list);

      // action
      acf.doAction(&#039;add_field_object&#039;, newField);
      acf.doAction(&#039;append_field_object&#039;, newField);
    }
  });
})(jQuery);

/***/ }),

/***/ &quot;./src/advanced-custom-fields-pro/assets/src/js/_field-group-locations.js&quot;:
/*!********************************************************************************!*\
  !*** ./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: &#039;locationManager&#039;,
    wait: &#039;ready&#039;,
    events: {
      &#039;click .add-location-rule&#039;: &#039;onClickAddRule&#039;,
      &#039;click .add-location-group&#039;: &#039;onClickAddGroup&#039;,
      &#039;click .remove-location-rule&#039;: &#039;onClickRemoveRule&#039;,
      &#039;change .refresh-location-rule&#039;: &#039;onChangeRemoveRule&#039;
    },
    initialize: function () {
      this.$el = $(&#039;#acf-field-group-options&#039;);
      this.updateGroupsClass();
    },
    onClickAddRule: function (e, $el) {
      this.addRule($el.closest(&#039;tr&#039;));
    },
    onClickRemoveRule: function (e, $el) {
      this.removeRule($el.closest(&#039;tr&#039;));
    },
    onChangeRemoveRule: function (e, $el) {
      this.changeRule($el.closest(&#039;tr&#039;));
    },
    onClickAddGroup: function (e, $el) {
      this.addGroup();
    },
    addRule: function ($tr) {
      acf.duplicate($tr);
      this.updateGroupsClass();
    },
    removeRule: function ($tr) {
      if ($tr.siblings(&#039;tr&#039;).length == 0) {
        $tr.closest(&#039;.rule-group&#039;).remove();
      } else {
        $tr.remove();
      }

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

      // ajaxdata
      var ajaxdata = {};
      ajaxdata.action = &#039;acf/field_group/render_location_rule&#039;;
      ajaxdata.rule = acf.serialize($rule, prefix);
      ajaxdata.rule.id = $rule.data(&#039;id&#039;);
      ajaxdata.rule.group = $group.data(&#039;id&#039;);

      // temp disable
      acf.disable($rule.find(&#039;td.value&#039;));

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

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

      // update h4
      $group2.find(&#039;h4&#039;).text(acf.__(&#039;or&#039;));

      // remove all tr&#039;s except the first one
      $group2.find(&#039;tr&#039;).not(&#039;:first&#039;).remove();

      // update the groups class
      this.updateGroupsClass();
    },
    updateGroupsClass: function () {
      var $group = this.$(&#039;.rule-group:last&#039;);
      var $ruleGroups = $group.closest(&#039;.rule-groups&#039;);
      var rows_count = $ruleGroups.find(&#039;.acf-table tr&#039;).length;
      if (rows_count &gt; 1) {
        $ruleGroups.addClass(&#039;rule-groups-multiple&#039;);
      } else {
        $ruleGroups.removeClass(&#039;rule-groups-multiple&#039;);
      }
    }
  });
})(jQuery);

/***/ }),

/***/ &quot;./src/advanced-custom-fields-pro/assets/src/js/_field-group-settings.js&quot;:
/*!*******************************************************************************!*\
  !*** ./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 || &#039;&#039;) + &#039;FieldSetting&#039;;
  };

  /**
   *  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 + &#039; &#039; + 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(&#039;setting&#039;) || &#039;&#039;;
    var name = field.get(&#039;name&#039;) || &#039;&#039;;
    var mid = modelId(type + &#039; &#039; + 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: &#039;onNewField&#039;
    },
    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: &#039;&#039;,
    name: &#039;&#039;,
    wait: &#039;ready&#039;,
    eventScope: &#039;.acf-field&#039;,
    events: {
      change: &#039;render&#039;
    },
    setup: function (field) {
      // vars
      var $field = field.$el;

      // set props
      this.$el = $field;
      this.field = field;
      this.$fieldObject = $field.closest(&#039;.acf-field-object&#039;);
      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 &#039;endpoint&#039; 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: &#039;&#039;,
    name: &#039;&#039;,
    render: function () {
      var $endpoint_setting = this.fieldObject.$setting(&#039;endpoint&#039;);
      var $endpoint_field = $endpoint_setting.find(&#039;input[type=&quot;checkbox&quot;]:first&#039;);
      if ($endpoint_field.is(&#039;:checked&#039;)) {
        this.fieldObject.$el.addClass(&#039;acf-field-is-endpoint&#039;);
      } else {
        this.fieldObject.$el.removeClass(&#039;acf-field-is-endpoint&#039;);
      }
    }
  });
  var AccordionEndpointFieldSetting = EndpointFieldSetting.extend({
    type: &#039;accordion&#039;,
    name: &#039;endpoint&#039;
  });
  var TabEndpointFieldSetting = EndpointFieldSetting.extend({
    type: &#039;tab&#039;,
    name: &#039;endpoint&#039;
  });
  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: &#039;&#039;,
    name: &#039;&#039;,
    render: function () {
      var $input = this.$(&#039;input[type=&quot;radio&quot;]:checked&#039;);
      if ($input.val() != &#039;other&#039;) {
        this.$(&#039;input[type=&quot;text&quot;]&#039;).val($input.val());
      }
    }
  });
  var DatePickerDisplayFormatFieldSetting = DisplayFormatFieldSetting.extend({
    type: &#039;date_picker&#039;,
    name: &#039;display_format&#039;
  });
  var DatePickerReturnFormatFieldSetting = DisplayFormatFieldSetting.extend({
    type: &#039;date_picker&#039;,
    name: &#039;return_format&#039;
  });
  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: &#039;date_time_picker&#039;,
    name: &#039;display_format&#039;
  });
  var DateTimePickerReturnFormatFieldSetting = DisplayFormatFieldSetting.extend({
    type: &#039;date_time_picker&#039;,
    name: &#039;return_format&#039;
  });
  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: &#039;time_picker&#039;,
    name: &#039;display_format&#039;
  });
  var TimePickerReturnFormatFieldSetting = DisplayFormatFieldSetting.extend({
    type: &#039;time_picker&#039;,
    name: &#039;return_format&#039;
  });
  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: &#039;color_picker&#039;,
    name: &#039;enable_opacity&#039;,
    render: function () {
      var $return_format_setting = this.fieldObject.$setting(&#039;return_format&#039;);
      var $default_value_setting = this.fieldObject.$setting(&#039;default_value&#039;);
      var $labelText = $return_format_setting.find(&#039;input[type=&quot;radio&quot;][value=&quot;string&quot;]&#039;).parent(&#039;label&#039;).contents().last();
      var $defaultPlaceholder = $default_value_setting.find(&#039;input[type=&quot;text&quot;]&#039;);
      var l10n = acf.get(&#039;colorPickerL10n&#039;);
      if (this.field.val()) {
        $labelText.replaceWith(l10n.rgba_string);
        $defaultPlaceholder.attr(&#039;placeholder&#039;, &#039;rgba(255,255,255,0.8)&#039;);
      } else {
        $labelText.replaceWith(l10n.hex_string);
        $defaultPlaceholder.attr(&#039;placeholder&#039;, &#039;#FFFFFF&#039;);
      }
    }
  });
  acf.registerFieldSetting(ColorPickerReturnFormat);
})(jQuery);

/***/ }),

/***/ &quot;./src/advanced-custom-fields-pro/assets/src/js/_field-group.js&quot;:
/*!**********************************************************************!*\
  !*** ./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: &#039;fieldGroupManager&#039;,
    events: {
      &#039;submit #post&#039;: &#039;onSubmit&#039;,
      &#039;click a[href=&quot;#&quot;]&#039;: &#039;onClick&#039;,
      &#039;click .acf-delete-field-group&#039;: &#039;onClickDeleteFieldGroup&#039;,
      &#039;blur input#title&#039;: &#039;onBlurValidateTitle&#039;
    },
    filters: {
      find_fields_args: &#039;filterFindFieldArgs&#039;,
      find_fields_selector: &#039;filterFindFieldsSelector&#039;
    },
    initialize: function () {
      acf.addAction(&#039;prepare&#039;, this.maybeInitNewFieldGroup);
    },
    maybeInitNewFieldGroup: function () {
      let $field_list_wrapper = $(&#039;#acf-field-group-fields &gt; .inside &gt; .acf-field-list-wrap.acf-auto-add-field&#039;);
      if ($field_list_wrapper.length) {
        $(&#039;.acf-headerbar-actions .add-field&#039;).trigger(&#039;click&#039;);
        $(&#039;.acf-title-wrap #title&#039;).trigger(&#039;focus&#039;);
      }

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

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

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

        // focus
        $title.trigger(&#039;focus&#039;);
      }
    },
    onClick: function (e) {
      e.preventDefault();
    },
    onClickDeleteFieldGroup: function (e, $el) {
      e.preventDefault();
      $el.addClass(&#039;-hover&#039;);

      // Add confirmation tooltip.
      acf.newTooltip({
        confirm: true,
        target: $el,
        context: this,
        text: acf.__(&#039;Move field group to trash?&#039;),
        confirm: function () {
          window.location.href = $el.attr(&#039;href&#039;);
        },
        cancel: function () {
          $el.removeClass(&#039;-hover&#039;);
        }
      });
    },
    onBlurValidateTitle: function (e, $el) {
      if (!$el.val()) {
        $el.addClass(&#039;acf-input-error&#039;);
        $(&#039;.acf-publish&#039;).addClass(&#039;disabled&#039;);
      } else {
        $el.removeClass(&#039;acf-input-error&#039;);
        $(&#039;.acf-publish&#039;).removeClass(&#039;disabled&#039;);
      }
    },
    filterFindFieldArgs: function (args) {
      args.visible = true;
      if (args.parent &amp;&amp; (args.parent.hasClass(&#039;acf-field-object&#039;) || args.parent.parents(&#039;.acf-field-object&#039;).length)) {
        args.visible = false;
        args.excludeSubFields = true;
      }
      return args;
    },
    filterFindFieldsSelector: function (selector) {
      return selector + &#039;, .acf-field-acf-field-group-settings-tabs&#039;;
    }
  });

  /**
   *  screenOptionsManager
   *
   *  Screen options functionality
   *
   *  @date	15/12/17
   *  @since	5.7.0
   *
   *  @param	void
   *  @return	void
   */

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

      // append
      $div.find(&#039;.metabox-prefs&#039;).append($append.html());
      $div.find(&#039;.metabox-prefs br&#039;).remove();

      // clean up
      $append.remove();

      // initialize
      this.$el = $(&#039;#screen-options-wrap&#039;);

      // render
      this.render();
    },
    isFieldKeysChecked: function () {
      return this.$el.find(&#039;#acf-field-key-hide&#039;).prop(&#039;checked&#039;);
    },
    isFieldSettingsTabsChecked: function () {
      const $input = this.$el.find(&#039;#acf-field-settings-tabs&#039;);

      // Screen option is hidden by filter.
      if (!$input.length) {
        return false;
      }
      return $input.prop(&#039;checked&#039;);
    },
    getSelectedColumnCount: function () {
      return this.$el.find(&#039;input[name=&quot;screen_columns&quot;]:checked&#039;).val();
    },
    onFieldKeysChange: function (e, $el) {
      var val = this.isFieldKeysChecked() ? 1 : 0;
      acf.updateUserSetting(&#039;show_field_keys&#039;, val);
      this.render();
    },
    onFieldSettingsTabsChange: function () {
      const val = this.isFieldSettingsTabsChecked() ? 1 : 0;
      acf.updateUserSetting(&#039;show_field_settings_tabs&#039;, val);
      this.render();
    },
    render: function () {
      if (this.isFieldKeysChecked()) {
        $(&#039;#acf-field-group-fields&#039;).addClass(&#039;show-field-keys&#039;);
      } else {
        $(&#039;#acf-field-group-fields&#039;).removeClass(&#039;show-field-keys&#039;);
      }
      if (!this.isFieldSettingsTabsChecked()) {
        $(&#039;#acf-field-group-fields&#039;).addClass(&#039;hide-tabs&#039;);
        $(&#039;.acf-field-settings-main&#039;).removeClass(&#039;acf-hidden&#039;).prop(&#039;hidden&#039;, false);
      } else {
        $(&#039;#acf-field-group-fields&#039;).removeClass(&#039;hide-tabs&#039;);
        $(&#039;.acf-field-object.open&#039;).each(function () {
          const tabFields = acf.getFields({
            type: &#039;tab&#039;,
            parent: $(this),
            excludeSubFields: true,
            limit: 1
          });
          if (tabFields.length) {
            tabFields[0].tabs.set(&#039;initialized&#039;, false);
          }
          acf.doAction(&#039;show&#039;, $(this));
        });
      }
      if (this.getSelectedColumnCount() == 1) {
        $(&#039;body&#039;).removeClass(&#039;columns-2&#039;);
        $(&#039;body&#039;).addClass(&#039;columns-1&#039;);
      } else {
        $(&#039;body&#039;).removeClass(&#039;columns-1&#039;);
        $(&#039;body&#039;).addClass(&#039;columns-2&#039;);
      }
    }
  });

  /**
   *  appendFieldManager
   *
   *  Appends fields together
   *
   *  @date	15/12/17
   *  @since	5.7.0
   *
   *  @param	void
   *  @return	void
   */

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

      // vars
      var append = field.get(&#039;append&#039;);
      var $sibling = field.$el.siblings(&#039;[data-name=&quot;&#039; + append + &#039;&quot;]&#039;).first();

      // bail early if no sibling
      if (!$sibling.length) return;

      // ul
      var $div = $sibling.children(&#039;.acf-input&#039;);
      var $ul = $div.children(&#039;ul&#039;);

      // create ul
      if (!$ul.length) {
        $div.wrapInner(&#039;&lt;ul class=&quot;acf-hl&quot;&gt;&lt;li&gt;&lt;/li&gt;&lt;/ul&gt;&#039;);
        $ul = $div.children(&#039;ul&#039;);
      }

      // li
      var html = field.$(&#039;.acf-input&#039;).html();
      var $li = $(&#039;&lt;li&gt;&#039; + html + &#039;&lt;/li&gt;&#039;);
      $ul.append($li);
      $ul.attr(&#039;data-cols&#039;, $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 &amp;&amp; module.__esModule ?
/******/ 				function() { return module[&#039;default&#039;]; } :
/******/ 				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) &amp;&amp; !__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 !== &#039;undefined&#039; &amp;&amp; Symbol.toStringTag) {
/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: &#039;Module&#039; });
/******/ 			}
/******/ 			Object.defineProperty(exports, &#039;__esModule&#039;, { value: true });
/******/ 		};
/******/ 	}();
/******/ 	
/************************************************************************/
var __webpack_exports__ = {};
// This entry need to be wrapped in an IIFE because it need to be in strict mode.
!function() {
&quot;use strict&quot;;
/*!*************************************************************************!*\
  !*** ./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 */ &quot;./src/advanced-custom-fields-pro/assets/src/js/_field-group.js&quot;);
/* 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 */ &quot;./src/advanced-custom-fields-pro/assets/src/js/_field-group-field.js&quot;);
/* 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 */ &quot;./src/advanced-custom-fields-pro/assets/src/js/_field-group-settings.js&quot;);
/* 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 */ &quot;./src/advanced-custom-fields-pro/assets/src/js/_field-group-conditions.js&quot;);
/* 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 */ &quot;./src/advanced-custom-fields-pro/assets/src/js/_field-group-fields.js&quot;);
/* 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 */ &quot;./src/advanced-custom-fields-pro/assets/src/js/_field-group-locations.js&quot;);
/* 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 */ &quot;./src/advanced-custom-fields-pro/assets/src/js/_field-group-compatibility.js&quot;);
/* 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</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fvar%2Fwww%2Fvhosts%2Fvsdma.at%2Fhttpdocs%2Fwp-content%2Fplugins%2Fadvanced-custom-fields-pro%2Fassets%2Fbuild%2Fjs'>🔙 Back</a></p>