(function ($, undefined) {
    // vars
    var storage = [];

    /**
     *  acf.Field
     *
     *  description
     *
     *  @date	23/3/18
     *  @since	5.6.9
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    acf.Field = acf.Model.extend({
        // field type
        type: "",

        // class used to avoid nested event triggers
        eventScope: ".acf-field",

        // initialize events on 'ready'
        wait: "ready",

        /**
         *  setup
         *
         *  Called during the constructor function to setup this field ready for initialization
         *
         *  @date	8/5/18
         *  @since	5.6.9
         *
         *  @param	jQuery $field The field element.
         *  @return	void
         */

        setup: function ($field) {
            // set $el
            this.$el = $field;

            // inherit $field data
            this.inherit($field);

            // inherit controll data
            this.inherit(this.$control());
        },

        /**
         *  val
         *
         *  Sets or returns the field's value
         *
         *  @date	8/5/18
         *  @since	5.6.9
         *
         *  @param	mixed val Optional. The value to set
         *  @return	mixed
         */

        val: function (val) {
            // Set.
            if (val !== undefined) {
                return this.setValue(val);

                // Get.
            } else {
                return this.prop("disabled") ? null : this.getValue();
            }
        },

        /**
         *  getValue
         *
         *  returns the field's value
         *
         *  @date	8/5/18
         *  @since	5.6.9
         *
         *  @param	void
         *  @return	mixed
         */

        getValue: function () {
            return this.$input().val();
        },

        /**
         *  setValue
         *
         *  sets the field's value and returns true if changed
         *
         *  @date	8/5/18
         *  @since	5.6.9
         *
         *  @param	mixed val
         *  @return	boolean. True if changed.
         */

        setValue: function (val) {
            return acf.val(this.$input(), val);
        },

        /**
         *  __
         *
         *  i18n helper to be removed
         *
         *  @date	8/5/18
         *  @since	5.6.9
         *
         *  @param	type $var Description. Default.
         *  @return	type Description.
         */

        __: function (string) {
            return acf._e(this.type, string);
        },

        /**
         *  $control
         *
         *  returns the control jQuery element used for inheriting data. Uses this.control setting.
         *
         *  @date	8/5/18
         *  @since	5.6.9
         *
         *  @param	void
         *  @return	jQuery
         */

        $control: function () {
            return false;
        },

        /**
         *  $input
         *
         *  returns the input jQuery element used for saving values. Uses this.input setting.
         *
         *  @date	8/5/18
         *  @since	5.6.9
         *
         *  @param	void
         *  @return	jQuery
         */

        $input: function () {
            return this.$("[name]:first");
        },

        /**
         *  $inputWrap
         *
         *  description
         *
         *  @date	12/5/18
         *  @since	5.6.9
         *
         *  @param	type $var Description. Default.
         *  @return	type Description.
         */

        $inputWrap: function () {
            return this.$(".acf-input:first");
        },

        /**
         *  $inputWrap
         *
         *  description
         *
         *  @date	12/5/18
         *  @since	5.6.9
         *
         *  @param	type $var Description. Default.
         *  @return	type Description.
         */

        $labelWrap: function () {
            return this.$(".acf-label:first");
        },

        /**
         *  getInputName
         *
         *  Returns the field's input name
         *
         *  @date	8/5/18
         *  @since	5.6.9
         *
         *  @param	void
         *  @return	string
         */

        getInputName: function () {
            return this.$input().attr("name") || "";
        },

        /**
         *  parent
         *
         *  returns the field's parent field or false on failure.
         *
         *  @date	8/5/18
         *  @since	5.6.9
         *
         *  @param	void
         *  @return	object|false
         */

        parent: function () {
            // vars
            var parents = this.parents();

            // return
            return parents.length ? parents[0] : false;
        },

        /**
         *  parents
         *
         *  description
         *
         *  @date	9/7/18
         *  @since	5.6.9
         *
         *  @param	type $var Description. Default.
         *  @return	type Description.
         */

        parents: function () {
            // vars
            var $parents = this.$el.parents(".acf-field");

            // convert
            var parents = acf.getFields($parents);

            // return
            return parents;
        },

        show: function (lockKey, context) {
            // show field and store result
            var changed = acf.show(this.$el, lockKey);

            // do action if visibility has changed
            if (changed) {
                this.prop("hidden", false);
                acf.doAction("show_field", this, context);
            }

            // return
            return changed;
        },

        hide: function (lockKey, context) {
            // hide field and store result
            var changed = acf.hide(this.$el, lockKey);

            // do action if visibility has changed
            if (changed) {
                this.prop("hidden", true);
                acf.doAction("hide_field", this, context);
            }

            // return
            return changed;
        },

        enable: function (lockKey, context) {
            // enable field and store result
            var changed = acf.enable(this.$el, lockKey);

            // do action if disabled has changed
            if (changed) {
                this.prop("disabled", false);
                acf.doAction("enable_field", this, context);
            }

            // return
            return changed;
        },

        disable: function (lockKey, context) {
            // disabled field and store result
            var changed = acf.disable(this.$el, lockKey);

            // do action if disabled has changed
            if (changed) {
                this.prop("disabled", true);
                acf.doAction("disable_field", this, context);
            }

            // return
            return changed;
        },

        showEnable: function (lockKey, context) {
            // enable
            this.enable.apply(this, arguments);

            // show and return true if changed
            return this.show.apply(this, arguments);
        },

        hideDisable: function (lockKey, context) {
            // disable
            this.disable.apply(this, arguments);

            // hide and return true if changed
            return this.hide.apply(this, arguments);
        },

        showNotice: function (props) {
            // ensure object
            if (typeof props !== "object") {
                props = { text: props };
            }

            // remove old notice
            if (this.notice) {
                this.notice.remove();
            }

            // create new notice
            props.target = this.$inputWrap();
            this.notice = acf.newNotice(props);
        },

        removeNotice: function (timeout) {
            if (this.notice) {
                this.notice.away(timeout || 0);
                this.notice = false;
            }
        },

        showError: function (message) {
            // add class
            this.$el.addClass("acf-error");

            // add message
            if (message !== undefined) {
                this.showNotice({
                    text: message,
                    type: "error",
                    dismiss: false,
                });
            }

            // action
            acf.doAction("invalid_field", this);

            // add event
            this.$el.one(
                "focus change",
                "input, select, textarea",
                $.proxy(this.removeError, this)
            );
        },

        removeError: function () {
            // remove class
            this.$el.removeClass("acf-error");

            // remove notice
            this.removeNotice(250);

            // action
            acf.doAction("valid_field", this);
        },

        trigger: function (name, args, bubbles) {
            // allow some events to bubble
            if (name == "invalidField") {
                bubbles = true;
            }

            // return
            return acf.Model.prototype.trigger.apply(this, [
                name,
                args,
                bubbles,
            ]);
        },
    });

    /**
     *  newField
     *
     *  description
     *
     *  @date	14/12/17
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    acf.newField = function ($field) {
        // vars
        var type = $field.data("type");
        var mid = modelId(type);
        var model = acf.models[mid] || acf.Field;

        // instantiate
        var field = new model($field);

        // actions
        acf.doAction("new_field", field);

        // return
        return field;
    };

    /**
     *  mid
     *
     *  Calculates the model ID for a field type
     *
     *  @date	15/12/17
     *  @since	5.6.5
     *
     *  @param	string type
     *  @return	string
     */

    var modelId = function (type) {
        return acf.strPascalCase(type || "") + "Field";
    };

    /**
     *  registerFieldType
     *
     *  description
     *
     *  @date	14/12/17
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    acf.registerFieldType = function (model) {
        // vars
        var proto = model.prototype;
        var type = proto.type;
        var mid = modelId(type);

        // store model
        acf.models[mid] = model;

        // store reference
        storage.push(type);
    };

    /**
     *  acf.getFieldType
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    acf.getFieldType = function (type) {
        var mid = modelId(type);
        return acf.models[mid] || false;
    };

    /**
     *  acf.getFieldTypes
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    acf.getFieldTypes = function (args) {
        // defaults
        args = acf.parseArgs(args, {
            category: "",
            // hasValue: true
        });

        // clonse available types
        var types = [];

        // loop
        storage.map(function (type) {
            // vars
            var model = acf.getFieldType(type);
            var proto = model.prototype;

            // check operator
            if (args.category && proto.category !== args.category) {
                return;
            }

            // append
            types.push(model);
        });

        // return
        return types;
    };
})(jQuery);
(function ($, undefined) {
    /**
     *  findFields
     *
     *  Returns a jQuery selection object of acf fields.
     *
     *  @date	14/12/17
     *  @since	5.6.5
     *
     *  @param	object $args {
     *		Optional. Arguments to find fields.
     *
     *		@type string			key			The field's key (data-attribute).
     *		@type string			name		The field's name (data-attribute).
     *		@type string			type		The field's type (data-attribute).
     *		@type string			is			jQuery selector to compare against.
     *		@type jQuery			parent		jQuery element to search within.
     *		@type jQuery			sibling		jQuery element to search alongside.
     *		@type limit				int			The number of fields to find.
     *		@type suppressFilters	bool		Whether to allow filters to add/remove results. Default behaviour will ignore clone fields.
     *  }
     *  @return	jQuery
     */

    acf.findFields = function (args) {
        // vars
        var selector = ".acf-field";
        var $fields = false;

        // args
        args = acf.parseArgs(args, {
            key: "",
            name: "",
            type: "",
            is: "",
            parent: false,
            sibling: false,
            limit: false,
            visible: false,
            suppressFilters: false,
        });

        // filter args
        if (!args.suppressFilters) {
            args = acf.applyFilters("find_fields_args", args);
        }

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

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

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

        // is
        if (args.is) {
            selector += args.is;
        }

        // visibility
        if (args.visible) {
            selector += ":visible";
        }

        // query
        if (args.parent) {
            $fields = args.parent.find(selector);
        } else if (args.sibling) {
            $fields = args.sibling.siblings(selector);
        } else {
            $fields = $(selector);
        }

        // filter
        if (!args.suppressFilters) {
            $fields = $fields.not(".acf-clone .acf-field");
            $fields = acf.applyFilters("find_fields", $fields);
        }

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

        // return
        return $fields;
    };

    /**
     *  findField
     *
     *  Finds a specific field with jQuery
     *
     *  @date	14/12/17
     *  @since	5.6.5
     *
     *  @param	string key 		The field's key.
     *  @param	jQuery $parent	jQuery element to search within.
     *  @return	jQuery
     */

    acf.findField = function (key, $parent) {
        return acf.findFields({
            key: key,
            limit: 1,
            parent: $parent,
            suppressFilters: true,
        });
    };

    /**
     *  getField
     *
     *  Returns a field instance
     *
     *  @date	14/12/17
     *  @since	5.6.5
     *
     *  @param	jQuery|string $field	jQuery element or field key.
     *  @return	object
     */

    acf.getField = function ($field) {
        // allow jQuery
        if ($field instanceof jQuery) {
            // find fields
        } else {
            $field = acf.findField($field);
        }

        // instantiate
        var field = $field.data("acf");
        if (!field) {
            field = acf.newField($field);
        }

        // return
        return field;
    };

    /**
     *  getFields
     *
     *  Returns multiple field instances
     *
     *  @date	14/12/17
     *  @since	5.6.5
     *
     *  @param	jQuery|object $fields	jQuery elements or query args.
     *  @return	array
     */

    acf.getFields = function ($fields) {
        // allow jQuery
        if ($fields instanceof jQuery) {
            // find fields
        } else {
            $fields = acf.findFields($fields);
        }

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

        // return
        return fields;
    };

    /**
     *  findClosestField
     *
     *  Returns the closest jQuery field element
     *
     *  @date	9/4/18
     *  @since	5.6.9
     *
     *  @param	jQuery $el
     *  @return	jQuery
     */

    acf.findClosestField = function ($el) {
        return $el.closest(".acf-field");
    };

    /**
     *  getClosestField
     *
     *  Returns the closest field instance
     *
     *  @date	22/1/18
     *  @since	5.6.5
     *
     *  @param	jQuery $el
     *  @return	object
     */

    acf.getClosestField = function ($el) {
        var $field = acf.findClosestField($el);
        return this.getField($field);
    };

    /**
     *  addGlobalFieldAction
     *
     *  Sets up callback logic for global field actions
     *
     *  @date	15/6/18
     *  @since	5.6.9
     *
     *  @param	string action
     *  @return	void
     */

    var addGlobalFieldAction = function (action) {
        // vars
        var globalAction = action;
        var pluralAction = action + "_fields"; // ready_fields
        var singleAction = action + "_field"; // ready_field

        // global action
        var globalCallback = function ($el /*, arg1, arg2, etc*/) {
            //console.log( action, arguments );

            // get args [$el, ...]
            var args = acf.arrayArgs(arguments);
            var extraArgs = args.slice(1);

            // find fields
            var fields = acf.getFields({ parent: $el });

            // check
            if (fields.length) {
                // pluralAction
                var pluralArgs = [pluralAction, fields].concat(extraArgs);
                acf.doAction.apply(null, pluralArgs);
            }
        };

        // plural action
        var pluralCallback = function (fields /*, arg1, arg2, etc*/) {
            //console.log( pluralAction, arguments );

            // get args [fields, ...]
            var args = acf.arrayArgs(arguments);
            var extraArgs = args.slice(1);

            // loop
            fields.map(function (field, i) {
                //setTimeout(function(){
                // singleAction
                var singleArgs = [singleAction, field].concat(extraArgs);
                acf.doAction.apply(null, singleArgs);
                //}, i * 100);
            });
        };

        // add actions
        acf.addAction(globalAction, globalCallback);
        acf.addAction(pluralAction, pluralCallback);

        // also add single action
        addSingleFieldAction(action);
    };

    /**
     *  addSingleFieldAction
     *
     *  Sets up callback logic for single field actions
     *
     *  @date	15/6/18
     *  @since	5.6.9
     *
     *  @param	string action
     *  @return	void
     */

    var addSingleFieldAction = function (action) {
        // vars
        var singleAction = action + "_field"; // ready_field
        var singleEvent = action + "Field"; // readyField

        // single action
        var singleCallback = function (field /*, arg1, arg2, etc*/) {
            //console.log( singleAction, arguments );

            // get args [field, ...]
            var args = acf.arrayArgs(arguments);
            var extraArgs = args.slice(1);

            // action variations (ready_field/type=image)
            var variations = ["type", "name", "key"];
            variations.map(function (variation) {
                // vars
                var prefix = "/" + variation + "=" + field.get(variation);

                // singleAction
                args = [singleAction + prefix, field].concat(extraArgs);
                acf.doAction.apply(null, args);
            });

            // event
            if (singleFieldEvents.indexOf(action) > -1) {
                field.trigger(singleEvent, extraArgs);
            }
        };

        // add actions
        acf.addAction(singleAction, singleCallback);
    };

    // vars
    var globalFieldActions = [
        "prepare",
        "ready",
        "load",
        "append",
        "remove",
        "unmount",
        "remount",
        "sortstart",
        "sortstop",
        "show",
        "hide",
        "unload",
    ];
    var singleFieldActions = [
        "valid",
        "invalid",
        "enable",
        "disable",
        "new",
        "duplicate",
    ];
    var singleFieldEvents = [
        "remove",
        "unmount",
        "remount",
        "sortstart",
        "sortstop",
        "show",
        "hide",
        "unload",
        "valid",
        "invalid",
        "enable",
        "disable",
        "duplicate",
    ];

    // add
    globalFieldActions.map(addGlobalFieldAction);
    singleFieldActions.map(addSingleFieldAction);

    /**
     *  fieldsEventManager
     *
     *  Manages field actions and events
     *
     *  @date	15/12/17
     *  @since	5.6.5
     *
     *  @param	void
     *  @param	void
     */

    var fieldsEventManager = new acf.Model({
        id: "fieldsEventManager",
        events: {
            'click .acf-field a[href="#"]': "onClick",
            "change .acf-field": "onChange",
        },
        onClick: function (e) {
            // prevent default of any link with an href of #
            e.preventDefault();
        },
        onChange: function () {
            // preview hack allows post to save with no title or content
            $("#_acf_changed").val(1);
        },
    });

    var duplicateFieldsManager = new acf.Model({
        id: "duplicateFieldsManager",
        actions: {
            duplicate: "onDuplicate",
            duplicate_fields: "onDuplicateFields",
        },
        onDuplicate: function ($el, $el2) {
            var fields = acf.getFields({ parent: $el });
            if (fields.length) {
                var $fields = acf.findFields({ parent: $el2 });
                acf.doAction("duplicate_fields", fields, $fields);
            }
        },
        onDuplicateFields: function (fields, duplicates) {
            fields.map(function (field, i) {
                acf.doAction("duplicate_field", field, $(duplicates[i]));
            });
        },
    });
})(jQuery);
(function ($, undefined) {
    var i = 0;

    var Field = acf.Field.extend({
        type: "accordion",

        wait: "",

        $control: function () {
            return this.$(".acf-fields:first");
        },

        initialize: function () {
            // Bail early if this is a duplicate of an existing initialized accordion.
            if (this.$el.hasClass("acf-accordion")) {
                return;
            }

            // bail early if is cell
            if (this.$el.is("td")) return;

            // enpoint
            if (this.get("endpoint")) {
                return this.remove();
            }

            // vars
            var $field = this.$el;
            var $label = this.$labelWrap();
            var $input = this.$inputWrap();
            var $wrap = this.$control();
            var $instructions = $input.children(".description");

            // force description into label
            if ($instructions.length) {
                $label.append($instructions);
            }

            // table
            if (this.$el.is("tr")) {
                // vars
                var $table = this.$el.closest("table");
                var $newLabel = $('<div class="acf-accordion-title"/>');
                var $newInput = $('<div class="acf-accordion-content"/>');
                var $newTable = $(
                    '<table class="' + $table.attr("class") + '"/>'
                );
                var $newWrap = $("<tbody/>");

                // dom
                $newLabel.append($label.html());
                $newTable.append($newWrap);
                $newInput.append($newTable);
                $input.append($newLabel);
                $input.append($newInput);

                // modify
                $label.remove();
                $wrap.remove();
                $input.attr("colspan", 2);

                // update vars
                $label = $newLabel;
                $input = $newInput;
                $wrap = $newWrap;
            }

            // add classes
            $field.addClass("acf-accordion");
            $label.addClass("acf-accordion-title");
            $input.addClass("acf-accordion-content");

            // index
            i++;

            // multi-expand
            if (this.get("multi_expand")) {
                $field.attr("multi-expand", 1);
            }

            // open
            var order = acf.getPreference("this.accordions") || [];
            if (order[i - 1] !== undefined) {
                this.set("open", order[i - 1]);
            }

            if (this.get("open")) {
                $field.addClass("-open");
                $input.css("display", "block"); // needed for accordion to close smoothly
            }

            // add icon
            $label.prepend(
                accordionManager.iconHtml({ open: this.get("open") })
            );

            // classes
            // - remove 'inside' which is a #poststuff WP class
            var $parent = $field.parent();
            $wrap.addClass($parent.hasClass("-left") ? "-left" : "");
            $wrap.addClass($parent.hasClass("-clear") ? "-clear" : "");

            // append
            $wrap.append(
                $field.nextUntil(".acf-field-accordion", ".acf-field")
            );

            // clean up
            $wrap.removeAttr("data-open data-multi_expand data-endpoint");
        },
    });

    acf.registerFieldType(Field);

    /**
     *  accordionManager
     *
     *  Events manager for the acf accordion
     *
     *  @date	14/2/18
     *  @since	5.6.9
     *
     *  @param	void
     *  @return	void
     */

    var accordionManager = new acf.Model({
        actions: {
            unload: "onUnload",
        },

        events: {
            "click .acf-accordion-title": "onClick",
            "invalidField .acf-accordion": "onInvalidField",
        },

        isOpen: function ($el) {
            return $el.hasClass("-open");
        },

        toggle: function ($el) {
            if (this.isOpen($el)) {
                this.close($el);
            } else {
                this.open($el);
            }
        },

        iconHtml: function (props) {
            // Use SVG inside Gutenberg editor.
            if (acf.isGutenberg()) {
                if (props.open) {
                    return '<svg class="acf-accordion-icon" width="24px" height="24px" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg" role="img" aria-hidden="true" focusable="false"><g><path fill="none" d="M0,0h24v24H0V0z"></path></g><g><path d="M12,8l-6,6l1.41,1.41L12,10.83l4.59,4.58L18,14L12,8z"></path></g></svg>';
                } else {
                    return '<svg class="acf-accordion-icon" width="24px" height="24px" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg" role="img" aria-hidden="true" focusable="false"><g><path fill="none" d="M0,0h24v24H0V0z"></path></g><g><path d="M7.41,8.59L12,13.17l4.59-4.58L18,10l-6,6l-6-6L7.41,8.59z"></path></g></svg>';
                }
            } else {
                if (props.open) {
                    return '<i class="acf-accordion-icon dashicons dashicons-arrow-down"></i>';
                } else {
                    return '<i class="acf-accordion-icon dashicons dashicons-arrow-right"></i>';
                }
            }
        },

        open: function ($el) {
            var duration = acf.isGutenberg() ? 0 : 300;

            // open
            $el.find(".acf-accordion-content:first")
                .slideDown(duration)
                .css("display", "block");
            $el.find(".acf-accordion-icon:first").replaceWith(
                this.iconHtml({ open: true })
            );
            $el.addClass("-open");

            // action
            acf.doAction("show", $el);

            // close siblings
            if (!$el.attr("multi-expand")) {
                $el.siblings(".acf-accordion.-open").each(function () {
                    accordionManager.close($(this));
                });
            }
        },

        close: function ($el) {
            var duration = acf.isGutenberg() ? 0 : 300;

            // close
            $el.find(".acf-accordion-content:first").slideUp(duration);
            $el.find(".acf-accordion-icon:first").replaceWith(
                this.iconHtml({ open: false })
            );
            $el.removeClass("-open");

            // action
            acf.doAction("hide", $el);
        },

        onClick: function (e, $el) {
            // prevent Defailt
            e.preventDefault();

            // open close
            this.toggle($el.parent());
        },

        onInvalidField: function (e, $el) {
            // bail early if already focused
            if (this.busy) {
                return;
            }

            // disable functionality for 1sec (allow next validation to work)
            this.busy = true;
            this.setTimeout(function () {
                this.busy = false;
            }, 1000);

            // open accordion
            this.open($el);
        },

        onUnload: function (e) {
            // vars
            var order = [];

            // loop
            $(".acf-accordion").each(function () {
                var open = $(this).hasClass("-open") ? 1 : 0;
                order.push(open);
            });

            // set
            if (order.length) {
                acf.setPreference("this.accordions", order);
            }
        },
    });
})(jQuery);
(function ($, undefined) {
    var Field = acf.Field.extend({
        type: "button_group",

        events: {
            'click input[type="radio"]': "onClick",
        },

        $control: function () {
            return this.$(".acf-button-group");
        },

        $input: function () {
            return this.$("input:checked");
        },

        setValue: function (val) {
            this.$('input[value="' + val + '"]')
                .prop("checked", true)
                .trigger("change");
        },

        onClick: function (e, $el) {
            // vars
            var $label = $el.parent("label");
            var selected = $label.hasClass("selected");

            // remove previous selected
            this.$(".selected").removeClass("selected");

            // add active class
            $label.addClass("selected");

            // allow null
            if (this.get("allow_null") && selected) {
                $label.removeClass("selected");
                $el.prop("checked", false).trigger("change");
            }
        },
    });

    acf.registerFieldType(Field);
})(jQuery);
(function ($, undefined) {
    var Field = acf.Field.extend({
        type: "checkbox",

        events: {
            "change input": "onChange",
            "click .acf-add-checkbox": "onClickAdd",
            "click .acf-checkbox-toggle": "onClickToggle",
            "click .acf-checkbox-custom": "onClickCustom",
        },

        $control: function () {
            return this.$(".acf-checkbox-list");
        },

        $toggle: function () {
            return this.$(".acf-checkbox-toggle");
        },

        $input: function () {
            return this.$('input[type="hidden"]');
        },

        $inputs: function () {
            return this.$('input[type="checkbox"]').not(".acf-checkbox-toggle");
        },

        getValue: function () {
            var val = [];
            this.$(":checked").each(function () {
                val.push($(this).val());
            });
            return val.length ? val : false;
        },

        onChange: function (e, $el) {
            // Vars.
            var checked = $el.prop("checked");
            var $label = $el.parent("label");
            var $toggle = this.$toggle();

            // Add or remove "selected" class.
            if (checked) {
                $label.addClass("selected");
            } else {
                $label.removeClass("selected");
            }

            // Update toggle state if all inputs are checked.
            if ($toggle.length) {
                var $inputs = this.$inputs();

                // all checked
                if ($inputs.not(":checked").length == 0) {
                    $toggle.prop("checked", true);
                } else {
                    $toggle.prop("checked", false);
                }
            }
        },

        onClickAdd: function (e, $el) {
            var html =
                '<li><input class="acf-checkbox-custom" type="checkbox" checked="checked" /><input type="text" name="' +
                this.getInputName() +
                '[]" /></li>';
            $el.parent("li").before(html);
        },

        onClickToggle: function (e, $el) {
            // Vars.
            var checked = $el.prop("checked");
            var $inputs = this.$('input[type="checkbox"]');
            var $labels = this.$("label");

            // Update "checked" state.
            $inputs.prop("checked", checked);

            // Add or remove "selected" class.
            if (checked) {
                $labels.addClass("selected");
            } else {
                $labels.removeClass("selected");
            }
        },

        onClickCustom: function (e, $el) {
            var checked = $el.prop("checked");
            var $text = $el.next('input[type="text"]');

            // checked
            if (checked) {
                $text.prop("disabled", false);

                // not checked
            } else {
                $text.prop("disabled", true);

                // remove
                if ($text.val() == "") {
                    $el.parent("li").remove();
                }
            }
        },
    });

    acf.registerFieldType(Field);
})(jQuery);
(function ($, undefined) {
    var Field = acf.Field.extend({
        type: "color_picker",

        wait: "load",

        events: {
            duplicateField: "onDuplicate",
        },

        $control: function () {
            return this.$(".acf-color-picker");
        },

        $input: function () {
            return this.$('input[type="hidden"]');
        },

        $inputText: function () {
            return this.$('input[type="text"]');
        },

        setValue: function (val) {
            // update input (with change)
            acf.val(this.$input(), val);

            // update iris
            this.$inputText().iris("color", val);
        },

        initialize: function () {
            // vars
            var $input = this.$input();
            var $inputText = this.$inputText();

            // event
            var onChange = function (e) {
                // timeout is required to ensure the $input val is correct
                setTimeout(function () {
                    acf.val($input, $inputText.val());
                }, 1);
            };

            // args
            var args = {
                defaultColor: false,
                palettes: true,
                hide: true,
                change: onChange,
                clear: onChange,
            };

            // filter
            var args = acf.applyFilters("color_picker_args", args, this);

            // initialize
            $inputText.wpColorPicker(args);
        },

        onDuplicate: function (e, $el, $duplicate) {
            // The wpColorPicker library does not provide a destroy method.
            // Manually reset DOM by replacing elements back to their original state.
            $colorPicker = $duplicate.find(".wp-picker-container");
            $inputText = $duplicate.find('input[type="text"]');
            $colorPicker.replaceWith($inputText);
        },
    });

    acf.registerFieldType(Field);
})(jQuery);
(function ($, undefined) {
    var Field = acf.Field.extend({
        type: "date_picker",

        events: {
            'blur input[type="text"]': "onBlur",
            duplicateField: "onDuplicate",
        },

        $control: function () {
            return this.$(".acf-date-picker");
        },

        $input: function () {
            return this.$('input[type="hidden"]');
        },

        $inputText: function () {
            return this.$('input[type="text"]');
        },

        initialize: function () {
            // save_format: compatibility with ACF < 5.0.0
            if (this.has("save_format")) {
                return this.initializeCompatibility();
            }

            // vars
            var $input = this.$input();
            var $inputText = this.$inputText();

            // args
            var args = {
                dateFormat: this.get("date_format"),
                altField: $input,
                altFormat: "yymmdd",
                changeYear: true,
                yearRange: "-100:+100",
                changeMonth: true,
                showButtonPanel: true,
                firstDay: this.get("first_day"),
            };

            // filter
            args = acf.applyFilters("date_picker_args", args, this);

            // add date picker
            acf.newDatePicker($inputText, args);

            // action
            acf.doAction("date_picker_init", $inputText, args, this);
        },

        initializeCompatibility: function () {
            // vars
            var $input = this.$input();
            var $inputText = this.$inputText();

            // get and set value from alt field
            $inputText.val($input.val());

            // args
            var args = {
                dateFormat: this.get("date_format"),
                altField: $input,
                altFormat: this.get("save_format"),
                changeYear: true,
                yearRange: "-100:+100",
                changeMonth: true,
                showButtonPanel: true,
                firstDay: this.get("first_day"),
            };

            // filter for 3rd party customization
            args = acf.applyFilters("date_picker_args", args, this);

            // backup
            var dateFormat = args.dateFormat;

            // change args.dateFormat
            args.dateFormat = this.get("save_format");

            // add date picker
            acf.newDatePicker($inputText, args);

            // now change the format back to how it should be.
            $inputText.datepicker("option", "dateFormat", dateFormat);

            // action for 3rd party customization
            acf.doAction("date_picker_init", $inputText, args, this);
        },

        onBlur: function () {
            if (!this.$inputText().val()) {
                acf.val(this.$input(), "");
            }
        },

        onDuplicate: function (e, $el, $duplicate) {
            $duplicate
                .find('input[type="text"]')
                .removeClass("hasDatepicker")
                .removeAttr("id");
        },
    });

    acf.registerFieldType(Field);

    // manager
    var datePickerManager = new acf.Model({
        priority: 5,
        wait: "ready",
        initialize: function () {
            // vars
            var locale = acf.get("locale");
            var rtl = acf.get("rtl");
            var l10n = acf.get("datePickerL10n");

            // bail ealry if no l10n
            if (!l10n) {
                return false;
            }

            // bail ealry if no datepicker library
            if (typeof $.datepicker === "undefined") {
                return false;
            }

            // rtl
            l10n.isRTL = rtl;

            // append
            $.datepicker.regional[locale] = l10n;
            $.datepicker.setDefaults(l10n);
        },
    });

    // add
    acf.newDatePicker = function ($input, args) {
        // bail ealry if no datepicker library
        if (typeof $.datepicker === "undefined") {
            return false;
        }

        // defaults
        args = args || {};

        // initialize
        $input.datepicker(args);

        // wrap the datepicker (only if it hasn't already been wrapped)
        if ($("body > #ui-datepicker-div").exists()) {
            $("body > #ui-datepicker-div").wrap(
                '<div class="acf-ui-datepicker" />'
            );
        }
    };
})(jQuery);
(function ($, undefined) {
    var Field = acf.models.DatePickerField.extend({
        type: "date_time_picker",

        $control: function () {
            return this.$(".acf-date-time-picker");
        },

        initialize: function () {
            // vars
            var $input = this.$input();
            var $inputText = this.$inputText();

            // args
            var args = {
                dateFormat: this.get("date_format"),
                timeFormat: this.get("time_format"),
                altField: $input,
                altFieldTimeOnly: false,
                altFormat: "yy-mm-dd",
                altTimeFormat: "HH:mm:ss",
                changeYear: true,
                yearRange: "-100:+100",
                changeMonth: true,
                showButtonPanel: true,
                firstDay: this.get("first_day"),
                controlType: "select",
                oneLine: true,
            };

            // filter
            args = acf.applyFilters("date_time_picker_args", args, this);

            // add date time picker
            acf.newDateTimePicker($inputText, args);

            // action
            acf.doAction("date_time_picker_init", $inputText, args, this);
        },
    });

    acf.registerFieldType(Field);

    // manager
    var dateTimePickerManager = new acf.Model({
        priority: 5,
        wait: "ready",
        initialize: function () {
            // vars
            var locale = acf.get("locale");
            var rtl = acf.get("rtl");
            var l10n = acf.get("dateTimePickerL10n");

            // bail ealry if no l10n
            if (!l10n) {
                return false;
            }

            // bail ealry if no datepicker library
            if (typeof $.timepicker === "undefined") {
                return false;
            }

            // rtl
            l10n.isRTL = rtl;

            // append
            $.timepicker.regional[locale] = l10n;
            $.timepicker.setDefaults(l10n);
        },
    });

    // add
    acf.newDateTimePicker = function ($input, args) {
        // bail ealry if no datepicker library
        if (typeof $.timepicker === "undefined") {
            return false;
        }

        // defaults
        args = args || {};

        // initialize
        $input.datetimepicker(args);

        // wrap the datepicker (only if it hasn't already been wrapped)
        if ($("body > #ui-datepicker-div").exists()) {
            $("body > #ui-datepicker-div").wrap(
                '<div class="acf-ui-datepicker" />'
            );
        }
    };
})(jQuery);
(function ($, undefined) {
    var Field = acf.Field.extend({
        type: "google_map",

        map: false,

        wait: "load",

        events: {
            'click a[data-name="clear"]': "onClickClear",
            'click a[data-name="locate"]': "onClickLocate",
            'click a[data-name="search"]': "onClickSearch",
            "keydown .search": "onKeydownSearch",
            "keyup .search": "onKeyupSearch",
            "focus .search": "onFocusSearch",
            "blur .search": "onBlurSearch",
            showField: "onShow",
        },

        $control: function () {
            return this.$(".acf-google-map");
        },

        $search: function () {
            return this.$(".search");
        },

        $canvas: function () {
            return this.$(".canvas");
        },

        setState: function (state) {
            // Remove previous state classes.
            this.$control().removeClass("-value -loading -searching");

            // Determine auto state based of current value.
            if (state === "default") {
                state = this.val() ? "value" : "";
            }

            // Update state class.
            if (state) {
                this.$control().addClass("-" + state);
            }
        },

        getValue: function () {
            var val = this.$input().val();
            if (val) {
                return JSON.parse(val);
            } else {
                return false;
            }
        },

        setValue: function (val, silent) {
            // Convert input value.
            var valAttr = "";
            if (val) {
                valAttr = JSON.stringify(val);
            }

            // Update input (with change).
            acf.val(this.$input(), valAttr);

            // Bail early if silent update.
            if (silent) {
                return;
            }

            // Render.
            this.renderVal(val);

            /**
             * Fires immediately after the value has changed.
             *
             * @date	12/02/2014
             * @since	5.0.0
             *
             * @param	object|string val The new value.
             * @param	object map The Google Map isntance.
             * @param	object field The field instance.
             */
            acf.doAction("google_map_change", val, this.map, this);
        },

        renderVal: function (val) {
            // Value.
            if (val) {
                this.setState("value");
                this.$search().val(val.address);
                this.setPosition(val.lat, val.lng);

                // No value.
            } else {
                this.setState("");
                this.$search().val("");
                this.map.marker.setVisible(false);
            }
        },

        newLatLng: function (lat, lng) {
            return new google.maps.LatLng(parseFloat(lat), parseFloat(lng));
        },

        setPosition: function (lat, lng) {
            // Update marker position.
            this.map.marker.setPosition({
                lat: parseFloat(lat),
                lng: parseFloat(lng),
            });

            // Show marker.
            this.map.marker.setVisible(true);

            // Center map.
            this.center();
        },

        center: function () {
            // Find marker position.
            var position = this.map.marker.getPosition();
            if (position) {
                var lat = position.lat();
                var lng = position.lng();

                // Or find default settings.
            } else {
                var lat = this.get("lat");
                var lng = this.get("lng");
            }

            // Center map.
            this.map.setCenter({
                lat: parseFloat(lat),
                lng: parseFloat(lng),
            });
        },

        initialize: function () {
            // Ensure Google API is loaded and then initialize map.
            withAPI(this.initializeMap.bind(this));
        },

        initializeMap: function () {
            // Get value ignoring conditional logic status.
            var val = this.getValue();

            // Construct default args.
            var args = acf.parseArgs(val, {
                zoom: this.get("zoom"),
                lat: this.get("lat"),
                lng: this.get("lng"),
            });

            // Create Map.
            var mapArgs = {
                scrollwheel: false,
                zoom: parseInt(args.zoom),
                center: {
                    lat: parseFloat(args.lat),
                    lng: parseFloat(args.lng),
                },
                mapTypeId: google.maps.MapTypeId.ROADMAP,
                marker: {
                    draggable: true,
                    raiseOnDrag: true,
                },
                autocomplete: {},
            };
            mapArgs = acf.applyFilters("google_map_args", mapArgs, this);
            var map = new google.maps.Map(this.$canvas()[0], mapArgs);

            // Create Marker.
            var markerArgs = acf.parseArgs(mapArgs.marker, {
                draggable: true,
                raiseOnDrag: true,
                map: map,
            });
            markerArgs = acf.applyFilters(
                "google_map_marker_args",
                markerArgs,
                this
            );
            var marker = new google.maps.Marker(markerArgs);

            // Maybe Create Autocomplete.
            var autocomplete = false;
            if (acf.isset(google, "maps", "places", "Autocomplete")) {
                var autocompleteArgs = mapArgs.autocomplete || {};
                autocompleteArgs = acf.applyFilters(
                    "google_map_autocomplete_args",
                    autocompleteArgs,
                    this
                );
                autocomplete = new google.maps.places.Autocomplete(
                    this.$search()[0],
                    autocompleteArgs
                );
                autocomplete.bindTo("bounds", map);
            }

            // Add map events.
            this.addMapEvents(this, map, marker, autocomplete);

            // Append references.
            map.acf = this;
            map.marker = marker;
            map.autocomplete = autocomplete;
            this.map = map;

            // Set position.
            if (val) {
                this.setPosition(val.lat, val.lng);
            }

            /**
             * Fires immediately after the Google Map has been initialized.
             *
             * @date	12/02/2014
             * @since	5.0.0
             *
             * @param	object map The Google Map isntance.
             * @param	object marker The Google Map marker isntance.
             * @param	object field The field instance.
             */
            acf.doAction("google_map_init", map, marker, this);
        },

        addMapEvents: function (field, map, marker, autocomplete) {
            // Click map.
            google.maps.event.addListener(map, "click", function (e) {
                var lat = e.latLng.lat();
                var lng = e.latLng.lng();
                field.searchPosition(lat, lng);
            });

            // Drag marker.
            google.maps.event.addListener(marker, "dragend", function () {
                var lat = this.getPosition().lat();
                var lng = this.getPosition().lng();
                field.searchPosition(lat, lng);
            });

            // Autocomplete search.
            if (autocomplete) {
                google.maps.event.addListener(
                    autocomplete,
                    "place_changed",
                    function () {
                        var place = this.getPlace();
                        field.searchPlace(place);
                    }
                );
            }

            // Detect zoom change.
            google.maps.event.addListener(map, "zoom_changed", function () {
                var val = field.val();
                if (val) {
                    val.zoom = map.getZoom();
                    field.setValue(val, true);
                }
            });
        },

        searchPosition: function (lat, lng) {
            //console.log('searchPosition', lat, lng );

            // Start Loading.
            this.setState("loading");

            // Query Geocoder.
            var latLng = { lat: lat, lng: lng };
            geocoder.geocode(
                { location: latLng },
                function (results, status) {
                    //console.log('searchPosition', arguments );

                    // End Loading.
                    this.setState("");

                    // Status failure.
                    if (status !== "OK") {
                        this.showNotice({
                            text: acf
                                .__("Location not found: %s")
                                .replace("%s", status),
                            type: "warning",
                        });

                        // Success.
                    } else {
                        var val = this.parseResult(results[0]);

                        // Override lat/lng to match user defined marker location.
                        // Avoids issue where marker "snaps" to nearest result.
                        val.lat = lat;
                        val.lng = lng;
                        this.val(val);
                    }
                }.bind(this)
            );
        },

        searchPlace: function (place) {
            //console.log('searchPlace', place );

            // Bail early if no place.
            if (!place) {
                return;
            }

            // Selecting from the autocomplete dropdown will return a rich PlaceResult object.
            // Be sure to over-write the "formatted_address" value with the one displayed to the user for best UX.
            if (place.geometry) {
                place.formatted_address = this.$search().val();
                var val = this.parseResult(place);
                this.val(val);

                // Searching a custom address will return an empty PlaceResult object.
            } else if (place.name) {
                this.searchAddress(place.name);
            }
        },

        searchAddress: function (address) {
            //console.log('searchAddress', address );

            // Bail early if no address.
            if (!address) {
                return;
            }

            // Allow "lat,lng" search.
            var latLng = address.split(",");
            if (latLng.length == 2) {
                var lat = parseFloat(latLng[0]);
                var lng = parseFloat(latLng[1]);
                if (lat && lng) {
                    return this.searchPosition(lat, lng);
                }
            }

            // Start Loading.
            this.setState("loading");

            // Query Geocoder.
            geocoder.geocode(
                { address: address },
                function (results, status) {
                    //console.log('searchPosition', arguments );

                    // End Loading.
                    this.setState("");

                    // Status failure.
                    if (status !== "OK") {
                        this.showNotice({
                            text: acf
                                .__("Location not found: %s")
                                .replace("%s", status),
                            type: "warning",
                        });

                        // Success.
                    } else {
                        var val = this.parseResult(results[0]);

                        // Override address data with parameter allowing custom address to be defined in search.
                        val.address = address;

                        // Update value.
                        this.val(val);
                    }
                }.bind(this)
            );
        },

        searchLocation: function () {
            //console.log('searchLocation' );

            // Check HTML5 geolocation.
            if (!navigator.geolocation) {
                return alert(
                    acf.__("Sorry, this browser does not support geolocation")
                );
            }

            // Start Loading.
            this.setState("loading");

            // Query Geolocation.
            navigator.geolocation.getCurrentPosition(
                // Success.
                function (results) {
                    // End Loading.
                    this.setState("");

                    // Search position.
                    var lat = results.coords.latitude;
                    var lng = results.coords.longitude;
                    this.searchPosition(lat, lng);
                }.bind(this),

                // Failure.
                function (error) {
                    this.setState("");
                }.bind(this)
            );
        },

        /**
         * parseResult
         *
         * Returns location data for the given GeocoderResult object.
         *
         * @date	15/10/19
         * @since	5.8.6
         *
         * @param	object obj A GeocoderResult object.
         * @return	object
         */
        parseResult: function (obj) {
            // Construct basic data.
            var result = {
                address: obj.formatted_address,
                lat: obj.geometry.location.lat(),
                lng: obj.geometry.location.lng(),
            };

            // Add zoom level.
            result.zoom = this.map.getZoom();

            // Add place ID.
            if (obj.place_id) {
                result.place_id = obj.place_id;
            }

            // Add place name.
            if (obj.name) {
                result.name = obj.name;
            }

            // Create search map for address component data.
            var map = {
                street_number: ["street_number"],
                street_name: ["street_address", "route"],
                city: ["locality"],
                state: [
                    "administrative_area_level_1",
                    "administrative_area_level_2",
                    "administrative_area_level_3",
                    "administrative_area_level_4",
                    "administrative_area_level_5",
                ],
                post_code: ["postal_code"],
                country: ["country"],
            };

            // Loop over map.
            for (var k in map) {
                var keywords = map[k];

                // Loop over address components.
                for (var i = 0; i < obj.address_components.length; i++) {
                    var component = obj.address_components[i];
                    var component_type = component.types[0];

                    // Look for matching component type.
                    if (keywords.indexOf(component_type) !== -1) {
                        // Append to result.
                        result[k] = component.long_name;

                        // Append short version.
                        if (component.long_name !== component.short_name) {
                            result[k + "_short"] = component.short_name;
                        }
                    }
                }
            }

            /**
             * Filters the parsed result.
             *
             * @date	18/10/19
             * @since	5.8.6
             *
             * @param	object result The parsed result value.
             * @param	object obj The GeocoderResult object.
             */
            return acf.applyFilters(
                "google_map_result",
                result,
                obj,
                this.map,
                this
            );
        },

        onClickClear: function () {
            this.val(false);
        },

        onClickLocate: function () {
            this.searchLocation();
        },

        onClickSearch: function () {
            this.searchAddress(this.$search().val());
        },

        onFocusSearch: function (e, $el) {
            this.setState("searching");
        },

        onBlurSearch: function (e, $el) {
            // Get saved address value.
            var val = this.val();
            var address = val ? val.address : "";

            // Remove 'is-searching' if value has not changed.
            if ($el.val() === address) {
                this.setState("default");
            }
        },

        onKeyupSearch: function (e, $el) {
            // Clear empty value.
            if (!$el.val()) {
                this.val(false);
            }
        },

        // Prevent form from submitting.
        onKeydownSearch: function (e, $el) {
            if (e.which == 13) {
                e.preventDefault();
                $el.blur();
            }
        },

        // Center map once made visible.
        onShow: function () {
            if (this.map) {
                this.setTimeout(this.center);
            }
        },
    });

    acf.registerFieldType(Field);

    // Vars.
    var loading = false;
    var geocoder = false;

    /**
     * withAPI
     *
     * Loads the Google Maps API library and troggers callback.
     *
     * @date	28/3/19
     * @since	5.7.14
     *
     * @param	function callback The callback to excecute.
     * @return	void
     */

    function withAPI(callback) {
        // Check if geocoder exists.
        if (geocoder) {
            return callback();
        }

        // Check if geocoder API exists.
        if (acf.isset(window, "google", "maps", "Geocoder")) {
            geocoder = new google.maps.Geocoder();
            return callback();
        }

        // Geocoder will need to be loaded. Hook callback to action.
        acf.addAction("google_map_api_loaded", callback);

        // Bail early if already loading API.
        if (loading) {
            return;
        }

        // load api
        var url = acf.get("google_map_api");
        if (url) {
            // Set loading status.
            loading = true;

            // Load API
            $.ajax({
                url: url,
                dataType: "script",
                cache: true,
                success: function () {
                    geocoder = new google.maps.Geocoder();
                    acf.doAction("google_map_api_loaded");
                },
            });
        }
    }
})(jQuery);
(function ($, undefined) {
    var Field = acf.Field.extend({
        type: "image",

        $control: function () {
            return this.$(".acf-image-uploader");
        },

        $input: function () {
            return this.$('input[type="hidden"]');
        },

        events: {
            'click a[data-name="add"]': "onClickAdd",
            'click a[data-name="edit"]': "onClickEdit",
            'click a[data-name="remove"]': "onClickRemove",
            'change input[type="file"]': "onChange",
        },

        initialize: function () {
            // add attribute to form
            if (this.get("uploader") === "basic") {
                this.$el.closest("form").attr("enctype", "multipart/form-data");
            }
        },

        validateAttachment: function (attachment) {
            // Use WP attachment attributes when available.
            if (attachment && attachment.attributes) {
                attachment = attachment.attributes;
            }

            // Apply defaults.
            attachment = acf.parseArgs(attachment, {
                id: 0,
                url: "",
                alt: "",
                title: "",
                caption: "",
                description: "",
                width: 0,
                height: 0,
            });

            // Override with "preview size".
            var size = acf.isget(attachment, "sizes", this.get("preview_size"));
            if (size) {
                attachment.url = size.url;
                attachment.width = size.width;
                attachment.height = size.height;
            }

            // Return.
            return attachment;
        },

        render: function (attachment) {
            attachment = this.validateAttachment(attachment);

            // Update DOM.
            this.$("img").attr({
                src: attachment.url,
                alt: attachment.alt,
            });
            if (attachment.id) {
                this.val(attachment.id);
                this.$control().addClass("has-value");
            } else {
                this.val("");
                this.$control().removeClass("has-value");
            }
        },

        // create a new repeater row and render value
        append: function (attachment, parent) {
            // create function to find next available field within parent
            var getNext = function (field, parent) {
                // find existing file fields within parent
                var fields = acf.getFields({
                    key: field.get("key"),
                    parent: parent.$el,
                });

                // find the first field with no value
                for (var i = 0; i < fields.length; i++) {
                    if (!fields[i].val()) {
                        return fields[i];
                    }
                }

                // return
                return false;
            };

            // find existing file fields within parent
            var field = getNext(this, parent);

            // add new row if no available field
            if (!field) {
                parent.$(".acf-button:last").trigger("click");
                field = getNext(this, parent);
            }

            // render
            if (field) {
                field.render(attachment);
            }
        },

        selectAttachment: function () {
            // vars
            var parent = this.parent();
            var multiple = parent && parent.get("type") === "repeater";

            // new frame
            var frame = acf.newMediaPopup({
                mode: "select",
                type: "image",
                title: acf.__("Select Image"),
                field: this.get("key"),
                multiple: multiple,
                library: this.get("library"),
                allowedTypes: this.get("mime_types"),
                select: $.proxy(function (attachment, i) {
                    if (i > 0) {
                        this.append(attachment, parent);
                    } else {
                        this.render(attachment);
                    }
                }, this),
            });
        },

        editAttachment: function () {
            // vars
            var val = this.val();

            // bail early if no val
            if (!val) return;

            // popup
            var frame = acf.newMediaPopup({
                mode: "edit",
                title: acf.__("Edit Image"),
                button: acf.__("Update Image"),
                attachment: val,
                field: this.get("key"),
                select: $.proxy(function (attachment, i) {
                    this.render(attachment);
                }, this),
            });
        },

        removeAttachment: function () {
            this.render(false);
        },

        onClickAdd: function (e, $el) {
            this.selectAttachment();
        },

        onClickEdit: function (e, $el) {
            this.editAttachment();
        },

        onClickRemove: function (e, $el) {
            this.removeAttachment();
        },

        onChange: function (e, $el) {
            var $hiddenInput = this.$input();

            acf.getFileInputData($el, function (data) {
                $hiddenInput.val($.param(data));
            });
        },
    });

    acf.registerFieldType(Field);
})(jQuery);
(function ($, undefined) {
    var Field = acf.models.ImageField.extend({
        type: "file",

        $control: function () {
            return this.$(".acf-file-uploader");
        },

        $input: function () {
            return this.$('input[type="hidden"]');
        },

        validateAttachment: function (attachment) {
            // defaults
            attachment = attachment || {};

            // WP attachment
            if (attachment.id !== undefined) {
                attachment = attachment.attributes;
            }

            // args
            attachment = acf.parseArgs(attachment, {
                url: "",
                alt: "",
                title: "",
                filename: "",
                filesizeHumanReadable: "",
                icon: "/wp-includes/images/media/default.png",
            });

            // return
            return attachment;
        },

        render: function (attachment) {
            // vars
            attachment = this.validateAttachment(attachment);

            // update image
            this.$("img").attr({
                src: attachment.icon,
                alt: attachment.alt,
                title: attachment.title,
            });

            // update elements
            this.$('[data-name="title"]').text(attachment.title);
            this.$('[data-name="filename"]')
                .text(attachment.filename)
                .attr("href", attachment.url);
            this.$('[data-name="filesize"]').text(
                attachment.filesizeHumanReadable
            );

            // vars
            var val = attachment.id || "";

            // update val
            acf.val(this.$input(), val);

            // update class
            if (val) {
                this.$control().addClass("has-value");
            } else {
                this.$control().removeClass("has-value");
            }
        },

        selectAttachment: function () {
            // vars
            var parent = this.parent();
            var multiple = parent && parent.get("type") === "repeater";

            // new frame
            var frame = acf.newMediaPopup({
                mode: "select",
                title: acf.__("Select File"),
                field: this.get("key"),
                multiple: multiple,
                library: this.get("library"),
                allowedTypes: this.get("mime_types"),
                select: $.proxy(function (attachment, i) {
                    if (i > 0) {
                        this.append(attachment, parent);
                    } else {
                        this.render(attachment);
                    }
                }, this),
            });
        },

        editAttachment: function () {
            // vars
            var val = this.val();

            // bail early if no val
            if (!val) {
                return false;
            }

            // popup
            var frame = acf.newMediaPopup({
                mode: "edit",
                title: acf.__("Edit File"),
                button: acf.__("Update File"),
                attachment: val,
                field: this.get("key"),
                select: $.proxy(function (attachment, i) {
                    this.render(attachment);
                }, this),
            });
        },
    });

    acf.registerFieldType(Field);
})(jQuery);
(function ($, undefined) {
    var Field = acf.Field.extend({
        type: "link",

        events: {
            'click a[data-name="add"]': "onClickEdit",
            'click a[data-name="edit"]': "onClickEdit",
            'click a[data-name="remove"]': "onClickRemove",
            "change .link-node": "onChange",
        },

        $control: function () {
            return this.$(".acf-link");
        },

        $node: function () {
            return this.$(".link-node");
        },

        getValue: function () {
            // vars
            var $node = this.$node();

            // return false if empty
            if (!$node.attr("href")) {
                return false;
            }

            // return
            return {
                title: $node.html(),
                url: $node.attr("href"),
                target: $node.attr("target"),
            };
        },

        setValue: function (val) {
            // default
            val = acf.parseArgs(val, {
                title: "",
                url: "",
                target: "",
            });

            // vars
            var $div = this.$control();
            var $node = this.$node();

            // remove class
            $div.removeClass("-value -external");

            // add class
            if (val.url) $div.addClass("-value");
            if (val.target === "_blank") $div.addClass("-external");

            // update text
            this.$(".link-title").html(val.title);
            this.$(".link-url").attr("href", val.url).html(val.url);

            // update node
            $node.html(val.title);
            $node.attr("href", val.url);
            $node.attr("target", val.target);

            // update inputs
            this.$(".input-title").val(val.title);
            this.$(".input-target").val(val.target);
            this.$(".input-url").val(val.url).trigger("change");
        },

        onClickEdit: function (e, $el) {
            acf.wpLink.open(this.$node());
        },

        onClickRemove: function (e, $el) {
            this.setValue(false);
        },

        onChange: function (e, $el) {
            // get the changed value
            var val = this.getValue();

            // update inputs
            this.setValue(val);
        },
    });

    acf.registerFieldType(Field);

    // manager
    acf.wpLink = new acf.Model({
        getNodeValue: function () {
            var $node = this.get("node");
            return {
                title: acf.decode($node.html()),
                url: $node.attr("href"),
                target: $node.attr("target"),
            };
        },

        setNodeValue: function (val) {
            var $node = this.get("node");
            $node.text(val.title);
            $node.attr("href", val.url);
            $node.attr("target", val.target);
            $node.trigger("change");
        },

        getInputValue: function () {
            return {
                title: $("#wp-link-text").val(),
                url: $("#wp-link-url").val(),
                target: $("#wp-link-target").prop("checked") ? "_blank" : "",
            };
        },

        setInputValue: function (val) {
            $("#wp-link-text").val(val.title);
            $("#wp-link-url").val(val.url);
            $("#wp-link-target").prop("checked", val.target === "_blank");
        },

        open: function ($node) {
            // add events
            this.on("wplink-open", "onOpen");
            this.on("wplink-close", "onClose");

            // set node
            this.set("node", $node);

            // create textarea
            var $textarea = $(
                '<textarea id="acf-link-textarea" style="display:none;"></textarea>'
            );
            $("body").append($textarea);

            // vars
            var val = this.getNodeValue();

            // open popup
            wpLink.open("acf-link-textarea", val.url, val.title, null);
        },

        onOpen: function () {
            // always show title (WP will hide title if empty)
            $("#wp-link-wrap").addClass("has-text-field");

            // set inputs
            var val = this.getNodeValue();
            this.setInputValue(val);

            // Update button text.
            if (val.url && wpLinkL10n) {
                $("#wp-link-submit").val(wpLinkL10n.update);
            }
        },

        close: function () {
            wpLink.close();
        },

        onClose: function () {
            // Bail early if no node.
            // Needed due to WP triggering this event twice.
            if (!this.has("node")) {
                return false;
            }

            // Determine context.
            var $submit = $("#wp-link-submit");
            var isSubmit = $submit.is(":hover") || $submit.is(":focus");

            // Set value
            if (isSubmit) {
                var val = this.getInputValue();
                this.setNodeValue(val);
            }

            // Cleanup.
            this.off("wplink-open");
            this.off("wplink-close");
            $("#acf-link-textarea").remove();
            this.set("node", null);
        },
    });
})(jQuery);
(function ($, undefined) {
    var Field = acf.Field.extend({
        type: "oembed",

        events: {
            'click [data-name="clear-button"]': "onClickClear",
            "keypress .input-search": "onKeypressSearch",
            "keyup .input-search": "onKeyupSearch",
            "change .input-search": "onChangeSearch",
        },

        $control: function () {
            return this.$(".acf-oembed");
        },

        $input: function () {
            return this.$(".input-value");
        },

        $search: function () {
            return this.$(".input-search");
        },

        getValue: function () {
            return this.$input().val();
        },

        getSearchVal: function () {
            return this.$search().val();
        },

        setValue: function (val) {
            // class
            if (val) {
                this.$control().addClass("has-value");
            } else {
                this.$control().removeClass("has-value");
            }

            acf.val(this.$input(), val);
        },

        showLoading: function (show) {
            acf.showLoading(this.$(".canvas"));
        },

        hideLoading: function () {
            acf.hideLoading(this.$(".canvas"));
        },

        maybeSearch: function () {
            // vars
            var prevUrl = this.val();
            var url = this.getSearchVal();

            // no value
            if (!url) {
                return this.clear();
            }

            // fix missing 'http://' - causes the oembed code to error and fail
            if (url.substr(0, 4) != "http") {
                url = "http://" + url;
            }

            // bail early if no change
            if (url === prevUrl) return;

            // clear existing timeout
            var timeout = this.get("timeout");
            if (timeout) {
                clearTimeout(timeout);
            }

            // set new timeout
            var callback = $.proxy(this.search, this, url);
            this.set("timeout", setTimeout(callback, 300));
        },

        search: function (url) {
            // ajax
            var ajaxData = {
                action: "acf/fields/oembed/search",
                s: url,
                field_key: this.get("key"),
            };

            // clear existing timeout
            var xhr = this.get("xhr");
            if (xhr) {
                xhr.abort();
            }

            // loading
            this.showLoading();

            // query
            var xhr = $.ajax({
                url: acf.get("ajaxurl"),
                data: acf.prepareForAjax(ajaxData),
                type: "post",
                dataType: "json",
                context: this,
                success: function (json) {
                    // error
                    if (!json || !json.html) {
                        json = {
                            url: false,
                            html: "",
                        };
                    }

                    // update vars
                    this.val(json.url);
                    this.$(".canvas-media").html(json.html);
                },
                complete: function () {
                    this.hideLoading();
                },
            });

            this.set("xhr", xhr);
        },

        clear: function () {
            this.val("");
            this.$search().val("");
            this.$(".canvas-media").html("");
        },

        onClickClear: function (e, $el) {
            this.clear();
        },

        onKeypressSearch: function (e, $el) {
            if (e.which == 13) {
                e.preventDefault();
                this.maybeSearch();
            }
        },

        onKeyupSearch: function (e, $el) {
            if ($el.val()) {
                this.maybeSearch();
            }
        },

        onChangeSearch: function (e, $el) {
            this.maybeSearch();
        },
    });

    acf.registerFieldType(Field);
})(jQuery);
(function ($, undefined) {
    var Field = acf.Field.extend({
        type: "radio",

        events: {
            'click input[type="radio"]': "onClick",
        },

        $control: function () {
            return this.$(".acf-radio-list");
        },

        $input: function () {
            return this.$("input:checked");
        },

        $inputText: function () {
            return this.$('input[type="text"]');
        },

        getValue: function () {
            var val = this.$input().val();
            if (val === "other" && this.get("other_choice")) {
                val = this.$inputText().val();
            }
            return val;
        },

        onClick: function (e, $el) {
            // vars
            var $label = $el.parent("label");
            var selected = $label.hasClass("selected");
            var val = $el.val();

            // remove previous selected
            this.$(".selected").removeClass("selected");

            // add active class
            $label.addClass("selected");

            // allow null
            if (this.get("allow_null") && selected) {
                $label.removeClass("selected");
                $el.prop("checked", false).trigger("change");
                val = false;
            }

            // other
            if (this.get("other_choice")) {
                // enable
                if (val === "other") {
                    this.$inputText().prop("disabled", false);

                    // disable
                } else {
                    this.$inputText().prop("disabled", true);
                }
            }
        },
    });

    acf.registerFieldType(Field);
})(jQuery);
(function ($, undefined) {
    var Field = acf.Field.extend({
        type: "range",

        events: {
            'input input[type="range"]': "onChange",
            "change input": "onChange",
        },

        $input: function () {
            return this.$('input[type="range"]');
        },

        $inputAlt: function () {
            return this.$('input[type="number"]');
        },

        setValue: function (val) {
            this.busy = true;

            // Update range input (with change).
            acf.val(this.$input(), val);

            // Update alt input (without change).
            // Read in input value to inherit min/max validation.
            acf.val(this.$inputAlt(), this.$input().val(), true);

            this.busy = false;
        },

        onChange: function (e, $el) {
            if (!this.busy) {
                this.setValue($el.val());
            }
        },
    });

    acf.registerFieldType(Field);
})(jQuery);
(function ($, undefined) {
    var Field = acf.Field.extend({
        type: "relationship",

        events: {
            "keypress [data-filter]": "onKeypressFilter",
            "change [data-filter]": "onChangeFilter",
            "keyup [data-filter]": "onChangeFilter",
            "click .choices-list .acf-rel-item": "onClickAdd",
            'click [data-name="remove_item"]': "onClickRemove",
        },

        $control: function () {
            return this.$(".acf-relationship");
        },

        $list: function (list) {
            return this.$("." + list + "-list");
        },

        $listItems: function (list) {
            return this.$list(list).find(".acf-rel-item");
        },

        $listItem: function (list, id) {
            return this.$list(list).find('.acf-rel-item[data-id="' + id + '"]');
        },

        getValue: function () {
            var val = [];
            this.$listItems("values").each(function () {
                val.push($(this).data("id"));
            });
            return val.length ? val : false;
        },

        newChoice: function (props) {
            return [
                "<li>",
                '<span data-id="' +
                    props.id +
                    '" class="acf-rel-item">' +
                    props.text +
                    "</span>",
                "</li>",
            ].join("");
        },

        newValue: function (props) {
            return [
                "<li>",
                '<input type="hidden" name="' +
                    this.getInputName() +
                    '[]" value="' +
                    props.id +
                    '" />',
                '<span data-id="' +
                    props.id +
                    '" class="acf-rel-item">' +
                    props.text,
                '<a href="#" class="acf-icon -minus small dark" data-name="remove_item"></a>',
                "</span>",
                "</li>",
            ].join("");
        },

        initialize: function () {
            // Delay initialization until "interacted with" or "in view".
            var delayed = this.proxy(
                acf.once(function () {
                    // Add sortable.
                    this.$list("values").sortable({
                        items: "li",
                        forceHelperSize: true,
                        forcePlaceholderSize: true,
                        scroll: true,
                        update: this.proxy(function () {
                            this.$input().trigger("change");
                        }),
                    });

                    // Avoid browser remembering old scroll position and add event.
                    this.$list("choices")
                        .scrollTop(0)
                        .on("scroll", this.proxy(this.onScrollChoices));

                    // Fetch choices.
                    this.fetch();
                })
            );

            // Bind "interacted with".
            this.$el.one("mouseover", delayed);
            this.$el.one("focus", "input", delayed);

            // Bind "in view".
            acf.onceInView(this.$el, delayed);
        },

        onScrollChoices: function (e) {
            // bail early if no more results
            if (this.get("loading") || !this.get("more")) {
                return;
            }

            // Scrolled to bottom
            var $list = this.$list("choices");
            var scrollTop = Math.ceil($list.scrollTop());
            var scrollHeight = Math.ceil($list[0].scrollHeight);
            var innerHeight = Math.ceil($list.innerHeight());
            var paged = this.get("paged") || 1;
            if (scrollTop + innerHeight >= scrollHeight) {
                // update paged
                this.set("paged", paged + 1);

                // fetch
                this.fetch();
            }
        },

        onKeypressFilter: function (e, $el) {
            // don't submit form
            if (e.which == 13) {
                e.preventDefault();
            }
        },

        onChangeFilter: function (e, $el) {
            // vars
            var val = $el.val();
            var filter = $el.data("filter");

            // Bail early if filter has not changed
            if (this.get(filter) === val) {
                return;
            }

            // update attr
            this.set(filter, val);

            // reset paged
            this.set("paged", 1);

            // fetch
            if ($el.is("select")) {
                this.fetch();

                // search must go through timeout
            } else {
                this.maybeFetch();
            }
        },

        onClickAdd: function (e, $el) {
            // vars
            var val = this.val();
            var max = parseInt(this.get("max"));

            // can be added?
            if ($el.hasClass("disabled")) {
                return false;
            }

            // validate
            if (max > 0 && val && val.length >= max) {
                // add notice
                this.showNotice({
                    text: acf
                        .__("Maximum values reached ( {max} values )")
                        .replace("{max}", max),
                    type: "warning",
                });
                return false;
            }

            // disable
            $el.addClass("disabled");

            // add
            var html = this.newValue({
                id: $el.data("id"),
                text: $el.html(),
            });
            this.$list("values").append(html);

            // trigger change
            this.$input().trigger("change");
        },

        onClickRemove: function (e, $el) {
            // Prevent default here because generic handler wont be triggered.
            e.preventDefault();

            // vars
            var $span = $el.parent();
            var $li = $span.parent();
            var id = $span.data("id");

            // remove value
            $li.remove();

            // show choice
            this.$listItem("choices", id).removeClass("disabled");

            // trigger change
            this.$input().trigger("change");
        },

        maybeFetch: function () {
            // vars
            var timeout = this.get("timeout");

            // abort timeout
            if (timeout) {
                clearTimeout(timeout);
            }

            // fetch
            timeout = this.setTimeout(this.fetch, 300);
            this.set("timeout", timeout);
        },

        getAjaxData: function () {
            // load data based on element attributes
            var ajaxData = this.$control().data();
            for (var name in ajaxData) {
                ajaxData[name] = this.get(name);
            }

            // extra
            ajaxData.action = "acf/fields/relationship/query";
            ajaxData.field_key = this.get("key");

            // Filter.
            ajaxData = acf.applyFilters(
                "relationship_ajax_data",
                ajaxData,
                this
            );

            // return
            return ajaxData;
        },

        fetch: function () {
            // abort XHR if this field is already loading AJAX data
            var xhr = this.get("xhr");
            if (xhr) {
                xhr.abort();
            }

            // add to this.o
            var ajaxData = this.getAjaxData();

            // clear html if is new query
            var $choiceslist = this.$list("choices");
            if (ajaxData.paged == 1) {
                $choiceslist.html("");
            }

            // loading
            var $loading = $(
                '<li><i class="acf-loading"></i> ' + acf.__("Loading") + "</li>"
            );
            $choiceslist.append($loading);
            this.set("loading", true);

            // callback
            var onComplete = function () {
                this.set("loading", false);
                $loading.remove();
            };

            var onSuccess = function (json) {
                // no results
                if (!json || !json.results || !json.results.length) {
                    // prevent pagination
                    this.set("more", false);

                    // add message
                    if (this.get("paged") == 1) {
                        this.$list("choices").append(
                            "<li>" + acf.__("No matches found") + "</li>"
                        );
                    }

                    // return
                    return;
                }

                // set more (allows pagination scroll)
                this.set("more", json.more);

                // get new results
                var html = this.walkChoices(json.results);
                var $html = $(html);

                // apply .disabled to left li's
                var val = this.val();
                if (val && val.length) {
                    val.map(function (id) {
                        $html
                            .find('.acf-rel-item[data-id="' + id + '"]')
                            .addClass("disabled");
                    });
                }

                // append
                $choiceslist.append($html);

                // merge together groups
                var $prevLabel = false;
                var $prevList = false;

                $choiceslist.find(".acf-rel-label").each(function () {
                    var $label = $(this);
                    var $list = $label.siblings("ul");

                    if ($prevLabel && $prevLabel.text() == $label.text()) {
                        $prevList.append($list.children());
                        $(this).parent().remove();
                        return;
                    }

                    // update vars
                    $prevLabel = $label;
                    $prevList = $list;
                });
            };

            // get results
            var xhr = $.ajax({
                url: acf.get("ajaxurl"),
                dataType: "json",
                type: "post",
                data: acf.prepareForAjax(ajaxData),
                context: this,
                success: onSuccess,
                complete: onComplete,
            });

            // set
            this.set("xhr", xhr);
        },

        walkChoices: function (data) {
            // walker
            var walk = function (data) {
                // vars
                var html = "";

                // is array
                if ($.isArray(data)) {
                    data.map(function (item) {
                        html += walk(item);
                    });

                    // is item
                } else if ($.isPlainObject(data)) {
                    // group
                    if (data.children !== undefined) {
                        html +=
                            '<li><span class="acf-rel-label">' +
                            acf.escHtml(data.text) +
                            '</span><ul class="acf-bl">';
                        html += walk(data.children);
                        html += "</ul></li>";

                        // single
                    } else {
                        html +=
                            '<li><span class="acf-rel-item" data-id="' +
                            acf.escAttr(data.id) +
                            '">' +
                            acf.escHtml(data.text) +
                            "</span></li>";
                    }
                }

                // return
                return html;
            };

            return walk(data);
        },
    });

    acf.registerFieldType(Field);
})(jQuery);
(function ($, undefined) {
    var Field = acf.Field.extend({
        type: "select",

        select2: false,

        wait: "load",

        events: {
            removeField: "onRemove",
            duplicateField: "onDuplicate",
        },

        $input: function () {
            return this.$("select");
        },

        initialize: function () {
            // vars
            var $select = this.$input();

            // inherit data
            this.inherit($select);

            // select2
            if (this.get("ui")) {
                // populate ajax_data (allowing custom attribute to already exist)
                var ajaxAction = this.get("ajax_action");
                if (!ajaxAction) {
                    ajaxAction = "acf/fields/" + this.get("type") + "/query";
                }

                // select2
                this.select2 = acf.newSelect2($select, {
                    field: this,
                    ajax: this.get("ajax"),
                    multiple: this.get("multiple"),
                    placeholder: this.get("placeholder"),
                    allowNull: this.get("allow_null"),
                    ajaxAction: ajaxAction,
                });
            }
        },

        onRemove: function () {
            if (this.select2) {
                this.select2.destroy();
            }
        },

        onDuplicate: function (e, $el, $duplicate) {
            if (this.select2) {
                $duplicate.find(".select2-container").remove();
                $duplicate
                    .find("select")
                    .removeClass("select2-hidden-accessible");
            }
        },
    });

    acf.registerFieldType(Field);
})(jQuery);
(function ($, undefined) {
    // vars
    var CONTEXT = "tab";

    var Field = acf.Field.extend({
        type: "tab",

        wait: "",

        tabs: false,

        tab: false,

        events: {
            duplicateField: "onDuplicate",
        },

        findFields: function () {
            return this.$el.nextUntil(".acf-field-tab", ".acf-field");
        },

        getFields: function () {
            return acf.getFields(this.findFields());
        },

        findTabs: function () {
            return this.$el.prevAll(".acf-tab-wrap:first");
        },

        findTab: function () {
            return this.$(".acf-tab-button");
        },

        initialize: function () {
            // bail early if is td
            if (this.$el.is("td")) {
                this.events = {};
                return false;
            }

            // vars
            var $tabs = this.findTabs();
            var $tab = this.findTab();
            var settings = acf.parseArgs($tab.data(), {
                endpoint: false,
                placement: "",
                before: this.$el,
            });

            // create wrap
            if (!$tabs.length || settings.endpoint) {
                this.tabs = new Tabs(settings);
            } else {
                this.tabs = $tabs.data("acf");
            }

            // add tab
            this.tab = this.tabs.addTab($tab, this);
        },

        isActive: function () {
            return this.tab.isActive();
        },

        showFields: function () {
            // show fields
            this.getFields().map(function (field) {
                field.show(this.cid, CONTEXT);
                field.hiddenByTab = false;
            }, this);
        },

        hideFields: function () {
            // hide fields
            this.getFields().map(function (field) {
                field.hide(this.cid, CONTEXT);
                field.hiddenByTab = this.tab;
            }, this);
        },

        show: function (lockKey) {
            // show field and store result
            var visible = acf.Field.prototype.show.apply(this, arguments);

            // check if now visible
            if (visible) {
                // show tab
                this.tab.show();

                // check active tabs
                this.tabs.refresh();
            }

            // return
            return visible;
        },

        hide: function (lockKey) {
            // hide field and store result
            var hidden = acf.Field.prototype.hide.apply(this, arguments);

            // check if now hidden
            if (hidden) {
                // hide tab
                this.tab.hide();

                // reset tabs if this was active
                if (this.isActive()) {
                    this.tabs.reset();
                }
            }

            // return
            return hidden;
        },

        enable: function (lockKey) {
            // enable fields
            this.getFields().map(function (field) {
                field.enable(CONTEXT);
            });
        },

        disable: function (lockKey) {
            // disable fields
            this.getFields().map(function (field) {
                field.disable(CONTEXT);
            });
        },

        onDuplicate: function (e, $el, $duplicate) {
            if (this.isActive()) {
                $duplicate.prevAll(".acf-tab-wrap:first").remove();
            }
        },
    });

    acf.registerFieldType(Field);

    /**
     *  tabs
     *
     *  description
     *
     *  @date	8/2/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    var i = 0;
    var Tabs = acf.Model.extend({
        tabs: [],

        active: false,

        actions: {
            refresh: "onRefresh",
        },

        data: {
            before: false,
            placement: "top",
            index: 0,
            initialized: false,
        },

        setup: function (settings) {
            // data
            $.extend(this.data, settings);

            // define this prop to avoid scope issues
            this.tabs = [];
            this.active = false;

            // vars
            var placement = this.get("placement");
            var $before = this.get("before");
            var $parent = $before.parent();

            // add sidebar for left placement
            if (placement == "left" && $parent.hasClass("acf-fields")) {
                $parent.addClass("-sidebar");
            }

            // create wrap
            if ($before.is("tr")) {
                this.$el = $(
                    '<tr class="acf-tab-wrap"><td colspan="2"><ul class="acf-hl acf-tab-group"></ul></td></tr>'
                );
            } else {
                this.$el = $(
                    '<div class="acf-tab-wrap -' +
                        placement +
                        '"><ul class="acf-hl acf-tab-group"></ul></div>'
                );
            }

            // append
            $before.before(this.$el);

            // set index
            this.set("index", i, true);
            i++;
        },

        initializeTabs: function () {
            // find first visible tab
            var tab = this.getVisible().shift();

            // remember previous tab state
            var order = acf.getPreference("this.tabs") || [];
            var groupIndex = this.get("index");
            var tabIndex = order[groupIndex];

            if (this.tabs[tabIndex] && this.tabs[tabIndex].isVisible()) {
                tab = this.tabs[tabIndex];
            }

            // select
            if (tab) {
                this.selectTab(tab);
            } else {
                this.closeTabs();
            }

            // set local variable used by tabsManager
            this.set("initialized", true);
        },

        getVisible: function () {
            return this.tabs.filter(function (tab) {
                return tab.isVisible();
            });
        },

        getActive: function () {
            return this.active;
        },

        setActive: function (tab) {
            return (this.active = tab);
        },

        hasActive: function () {
            return this.active !== false;
        },

        isActive: function (tab) {
            var active = this.getActive();
            return active && active.cid === tab.cid;
        },

        closeActive: function () {
            if (this.hasActive()) {
                this.closeTab(this.getActive());
            }
        },

        openTab: function (tab) {
            // close existing tab
            this.closeActive();

            // open
            tab.open();

            // set active
            this.setActive(tab);
        },

        closeTab: function (tab) {
            // close
            tab.close();

            // set active
            this.setActive(false);
        },

        closeTabs: function () {
            this.tabs.map(this.closeTab, this);
        },

        selectTab: function (tab) {
            // close other tabs
            this.tabs.map(function (t) {
                if (tab.cid !== t.cid) {
                    this.closeTab(t);
                }
            }, this);

            // open
            this.openTab(tab);
        },

        addTab: function ($a, field) {
            // create <li>
            var $li = $("<li>" + $a.outerHTML() + "</li>");

            // append
            this.$("ul").append($li);

            // initialize
            var tab = new Tab({
                $el: $li,
                field: field,
                group: this,
            });

            // store
            this.tabs.push(tab);

            // return
            return tab;
        },

        reset: function () {
            // close existing tab
            this.closeActive();

            // find and active a tab
            return this.refresh();
        },

        refresh: function () {
            // bail early if active already exists
            if (this.hasActive()) {
                return false;
            }

            // find next active tab
            var tab = this.getVisible().shift();

            // open tab
            if (tab) {
                this.openTab(tab);
            }

            // return
            return tab;
        },

        onRefresh: function () {
            // only for left placements
            if (this.get("placement") !== "left") {
                return;
            }

            // vars
            var $parent = this.$el.parent();
            var $list = this.$el.children("ul");
            var attribute = $parent.is("td") ? "height" : "min-height";

            // find height (minus 1 for border-bottom)
            var height = $list.position().top + $list.outerHeight(true) - 1;

            // add css
            $parent.css(attribute, height);
        },
    });

    var Tab = acf.Model.extend({
        group: false,

        field: false,

        events: {
            "click a": "onClick",
        },

        index: function () {
            return this.$el.index();
        },

        isVisible: function () {
            return acf.isVisible(this.$el);
        },

        isActive: function () {
            return this.$el.hasClass("active");
        },

        open: function () {
            // add class
            this.$el.addClass("active");

            // show field
            this.field.showFields();
        },

        close: function () {
            // remove class
            this.$el.removeClass("active");

            // hide field
            this.field.hideFields();
        },

        onClick: function (e, $el) {
            // prevent default
            e.preventDefault();

            // toggle
            this.toggle();
        },

        toggle: function () {
            // bail early if already active
            if (this.isActive()) {
                return;
            }

            // toggle this tab
            this.group.openTab(this);
        },
    });

    var tabsManager = new acf.Model({
        priority: 50,

        actions: {
            prepare: "render",
            append: "render",
            unload: "onUnload",
            invalid_field: "onInvalidField",
        },

        findTabs: function () {
            return $(".acf-tab-wrap");
        },

        getTabs: function () {
            return acf.getInstances(this.findTabs());
        },

        render: function ($el) {
            this.getTabs().map(function (tabs) {
                if (!tabs.get("initialized")) {
                    tabs.initializeTabs();
                }
            });
        },

        onInvalidField: function (field) {
            // bail early if busy
            if (this.busy) {
                return;
            }

            // ignore if not hidden by tab
            if (!field.hiddenByTab) {
                return;
            }

            // toggle tab
            field.hiddenByTab.toggle();

            // ignore other invalid fields
            this.busy = true;
            this.setTimeout(function () {
                this.busy = false;
            }, 100);
        },

        onUnload: function () {
            // vars
            var order = [];

            // loop
            this.getTabs().map(function (group) {
                var active = group.hasActive() ? group.getActive().index() : 0;
                order.push(active);
            });

            // bail if no tabs
            if (!order.length) {
                return;
            }

            // update
            acf.setPreference("this.tabs", order);
        },
    });
})(jQuery);
(function ($, undefined) {
    var Field = acf.models.SelectField.extend({
        type: "post_object",
    });

    acf.registerFieldType(Field);
})(jQuery);
(function ($, undefined) {
    var Field = acf.models.SelectField.extend({
        type: "page_link",
    });

    acf.registerFieldType(Field);
})(jQuery);
(function ($, undefined) {
    var Field = acf.models.SelectField.extend({
        type: "user",
    });

    acf.registerFieldType(Field);
})(jQuery);
(function ($, undefined) {
    var Field = acf.Field.extend({
        type: "taxonomy",

        data: {
            ftype: "select",
        },

        select2: false,

        wait: "load",

        events: {
            'click a[data-name="add"]': "onClickAdd",
            'click input[type="radio"]': "onClickRadio",
            removeField: "onRemove",
        },

        $control: function () {
            return this.$(".acf-taxonomy-field");
        },

        $input: function () {
            return this.getRelatedPrototype().$input.apply(this, arguments);
        },

        getRelatedType: function () {
            // vars
            var fieldType = this.get("ftype");

            // normalize
            if (fieldType == "multi_select") {
                fieldType = "select";
            }

            // return
            return fieldType;
        },

        getRelatedPrototype: function () {
            return acf.getFieldType(this.getRelatedType()).prototype;
        },

        getValue: function () {
            return this.getRelatedPrototype().getValue.apply(this, arguments);
        },

        setValue: function () {
            return this.getRelatedPrototype().setValue.apply(this, arguments);
        },

        initialize: function () {
            this.getRelatedPrototype().initialize.apply(this, arguments);
        },

        onRemove: function () {
            var proto = this.getRelatedPrototype();
            if (proto.onRemove) {
                proto.onRemove.apply(this, arguments);
            }
        },

        onClickAdd: function (e, $el) {
            // vars
            var field = this;
            var popup = false;
            var $form = false;
            var $name = false;
            var $parent = false;
            var $button = false;
            var $message = false;
            var notice = false;

            // step 1.
            var step1 = function () {
                // popup
                popup = acf.newPopup({
                    title: $el.attr("title"),
                    loading: true,
                    width: "300px",
                });

                // ajax
                var ajaxData = {
                    action: "acf/fields/taxonomy/add_term",
                    field_key: field.get("key"),
                };

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

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

                // vars
                $form = popup.$("form");
                $name = popup.$('input[name="term_name"]');
                $parent = popup.$('select[name="term_parent"]');
                $button = popup.$(".acf-submit-button");

                // focus
                $name.trigger("focus");

                // submit form
                popup.on("submit", "form", step3);
            };

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

                // basic validation
                if ($name.val() === "") {
                    $name.trigger("focus");
                    return false;
                }

                // disable
                acf.startButtonLoading($button);

                // ajax
                var ajaxData = {
                    action: "acf/fields/taxonomy/add_term",
                    field_key: field.get("key"),
                    term_name: $name.val(),
                    term_parent: $parent.length ? $parent.val() : 0,
                };

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

            // step 4.
            var step4 = function (json) {
                // enable
                acf.stopButtonLoading($button);

                // remove prev notice
                if (notice) {
                    notice.remove();
                }

                // success
                if (acf.isAjaxSuccess(json)) {
                    // clear name
                    $name.val("");

                    // update term lists
                    step5(json.data);

                    // notice
                    notice = acf.newNotice({
                        type: "success",
                        text: acf.getAjaxMessage(json),
                        target: $form,
                        timeout: 2000,
                        dismiss: false,
                    });
                } else {
                    // notice
                    notice = acf.newNotice({
                        type: "error",
                        text: acf.getAjaxError(json),
                        target: $form,
                        timeout: 2000,
                        dismiss: false,
                    });
                }

                // focus
                $name.trigger("focus");
            };

            // step 5.
            var step5 = function (term) {
                // update parent dropdown
                var $option = $(
                    '<option value="' +
                        term.term_id +
                        '">' +
                        term.term_label +
                        "</option>"
                );
                if (term.term_parent) {
                    $parent
                        .children('option[value="' + term.term_parent + '"]')
                        .after($option);
                } else {
                    $parent.append($option);
                }

                // add this new term to all taxonomy field
                var fields = acf.getFields({
                    type: "taxonomy",
                });

                fields.map(function (otherField) {
                    if (otherField.get("taxonomy") == field.get("taxonomy")) {
                        otherField.appendTerm(term);
                    }
                });

                // select
                field.selectTerm(term.term_id);
            };

            // run
            step1();
        },

        appendTerm: function (term) {
            if (this.getRelatedType() == "select") {
                this.appendTermSelect(term);
            } else {
                this.appendTermCheckbox(term);
            }
        },

        appendTermSelect: function (term) {
            this.select2.addOption({
                id: term.term_id,
                text: term.term_label,
            });
        },

        appendTermCheckbox: function (term) {
            // vars
            var name = this.$("[name]:first").attr("name");
            var $ul = this.$("ul:first");

            // allow multiple selection
            if (this.getRelatedType() == "checkbox") {
                name += "[]";
            }

            // create new li
            var $li = $(
                [
                    '<li data-id="' + term.term_id + '">',
                    "<label>",
                    '<input type="' +
                        this.get("ftype") +
                        '" value="' +
                        term.term_id +
                        '" name="' +
                        name +
                        '" /> ',
                    "<span>" + term.term_name + "</span>",
                    "</label>",
                    "</li>",
                ].join("")
            );

            // find parent
            if (term.term_parent) {
                // vars
                var $parent = $ul.find(
                    'li[data-id="' + term.term_parent + '"]'
                );

                // update vars
                $ul = $parent.children("ul");

                // create ul
                if (!$ul.exists()) {
                    $ul = $('<ul class="children acf-bl"></ul>');
                    $parent.append($ul);
                }
            }

            // append
            $ul.append($li);
        },

        selectTerm: function (id) {
            if (this.getRelatedType() == "select") {
                this.select2.selectOption(id);
            } else {
                var $input = this.$('input[value="' + id + '"]');
                $input.prop("checked", true).trigger("change");
            }
        },

        onClickRadio: function (e, $el) {
            // vars
            var $label = $el.parent("label");
            var selected = $label.hasClass("selected");

            // remove previous selected
            this.$(".selected").removeClass("selected");

            // add active class
            $label.addClass("selected");

            // allow null
            if (this.get("allow_null") && selected) {
                $label.removeClass("selected");
                $el.prop("checked", false).trigger("change");
            }
        },
    });

    acf.registerFieldType(Field);
})(jQuery);
(function ($, undefined) {
    var Field = acf.models.DatePickerField.extend({
        type: "time_picker",

        $control: function () {
            return this.$(".acf-time-picker");
        },

        initialize: function () {
            // vars
            var $input = this.$input();
            var $inputText = this.$inputText();

            // args
            var args = {
                timeFormat: this.get("time_format"),
                altField: $input,
                altFieldTimeOnly: false,
                altTimeFormat: "HH:mm:ss",
                showButtonPanel: true,
                controlType: "select",
                oneLine: true,
                closeText: acf.get("dateTimePickerL10n").selectText,
                timeOnly: true,
            };

            // add custom 'Close = Select' functionality
            args.onClose = function (value, dp_instance, t_instance) {
                // vars
                var $close = dp_instance.dpDiv.find(".ui-datepicker-close");

                // if clicking close button
                if (!value && $close.is(":hover")) {
                    t_instance._updateDateTime();
                }
            };

            // filter
            args = acf.applyFilters("time_picker_args", args, this);

            // add date time picker
            acf.newTimePicker($inputText, args);

            // action
            acf.doAction("time_picker_init", $inputText, args, this);
        },
    });

    acf.registerFieldType(Field);

    // add
    acf.newTimePicker = function ($input, args) {
        // bail ealry if no datepicker library
        if (typeof $.timepicker === "undefined") {
            return false;
        }

        // defaults
        args = args || {};

        // initialize
        $input.timepicker(args);

        // wrap the datepicker (only if it hasn't already been wrapped)
        if ($("body > #ui-datepicker-div").exists()) {
            $("body > #ui-datepicker-div").wrap(
                '<div class="acf-ui-datepicker" />'
            );
        }
    };
})(jQuery);
(function ($, undefined) {
    var Field = acf.Field.extend({
        type: "true_false",

        events: {
            "change .acf-switch-input": "onChange",
            "focus .acf-switch-input": "onFocus",
            "blur .acf-switch-input": "onBlur",
            "keypress .acf-switch-input": "onKeypress",
        },

        $input: function () {
            return this.$('input[type="checkbox"]');
        },

        $switch: function () {
            return this.$(".acf-switch");
        },

        getValue: function () {
            return this.$input().prop("checked") ? 1 : 0;
        },

        initialize: function () {
            this.render();
        },

        render: function () {
            // vars
            var $switch = this.$switch();

            // bail ealry if no $switch
            if (!$switch.length) return;

            // vars
            var $on = $switch.children(".acf-switch-on");
            var $off = $switch.children(".acf-switch-off");
            var width = Math.max($on.width(), $off.width());

            // bail ealry if no width
            if (!width) return;

            // set widths
            $on.css("min-width", width);
            $off.css("min-width", width);
        },

        switchOn: function () {
            this.$input().prop("checked", true);
            this.$switch().addClass("-on");
        },

        switchOff: function () {
            this.$input().prop("checked", false);
            this.$switch().removeClass("-on");
        },

        onChange: function (e, $el) {
            if ($el.prop("checked")) {
                this.switchOn();
            } else {
                this.switchOff();
            }
        },

        onFocus: function (e, $el) {
            this.$switch().addClass("-focus");
        },

        onBlur: function (e, $el) {
            this.$switch().removeClass("-focus");
        },

        onKeypress: function (e, $el) {
            // left
            if (e.keyCode === 37) {
                return this.switchOff();
            }

            // right
            if (e.keyCode === 39) {
                return this.switchOn();
            }
        },
    });

    acf.registerFieldType(Field);
})(jQuery);
(function ($, undefined) {
    var Field = acf.Field.extend({
        type: "url",

        events: {
            'keyup input[type="url"]': "onkeyup",
        },

        $control: function () {
            return this.$(".acf-input-wrap");
        },

        $input: function () {
            return this.$('input[type="url"]');
        },

        initialize: function () {
            this.render();
        },

        isValid: function () {
            // vars
            var val = this.val();

            // bail early if no val
            if (!val) {
                return false;
            }

            // url
            if (val.indexOf("://") !== -1) {
                return true;
            }

            // protocol relative url
            if (val.indexOf("//") === 0) {
                return true;
            }

            // return
            return false;
        },

        render: function () {
            // add class
            if (this.isValid()) {
                this.$control().addClass("-valid");
            } else {
                this.$control().removeClass("-valid");
            }
        },

        onkeyup: function (e, $el) {
            this.render();
        },
    });

    acf.registerFieldType(Field);
})(jQuery);
(function ($, undefined) {
    var Field = acf.Field.extend({
        type: "wysiwyg",

        wait: "load",

        events: {
            "mousedown .acf-editor-wrap.delay": "onMousedown",
            unmountField: "disableEditor",
            remountField: "enableEditor",
            removeField: "disableEditor",
        },

        $control: function () {
            return this.$(".acf-editor-wrap");
        },

        $input: function () {
            return this.$("textarea");
        },

        getMode: function () {
            return this.$control().hasClass("tmce-active") ? "visual" : "text";
        },

        initialize: function () {
            // initializeEditor if no delay
            if (!this.$control().hasClass("delay")) {
                this.initializeEditor();
            }
        },

        initializeEditor: function () {
            // vars
            var $wrap = this.$control();
            var $textarea = this.$input();
            var args = {
                tinymce: true,
                quicktags: true,
                toolbar: this.get("toolbar"),
                mode: this.getMode(),
                field: this,
            };

            // generate new id
            var oldId = $textarea.attr("id");
            var newId = acf.uniqueId("acf-editor-");

            // Backup textarea data.
            var inputData = $textarea.data();
            var inputVal = $textarea.val();

            // rename
            acf.rename({
                target: $wrap,
                search: oldId,
                replace: newId,
                destructive: true,
            });

            // update id
            this.set("id", newId, true);

            // apply data to new textarea (acf.rename creates a new textarea element due to destructive mode)
            // fixes bug where conditional logic "disabled" is lost during "screen_check"
            this.$input().data(inputData).val(inputVal);

            // initialize
            acf.tinymce.initialize(newId, args);
        },

        onMousedown: function (e) {
            // prevent default
            e.preventDefault();

            // remove delay class
            var $wrap = this.$control();
            $wrap.removeClass("delay");
            $wrap.find(".acf-editor-toolbar").remove();

            // initialize
            this.initializeEditor();
        },

        enableEditor: function () {
            if (this.getMode() == "visual") {
                acf.tinymce.enable(this.get("id"));
            }
        },

        disableEditor: function () {
            acf.tinymce.destroy(this.get("id"));
        },
    });

    acf.registerFieldType(Field);
})(jQuery);
(function ($, undefined) {
    // vars
    var storage = [];

    /**
     *  acf.Condition
     *
     *  description
     *
     *  @date	23/3/18
     *  @since	5.6.9
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    acf.Condition = acf.Model.extend({
        type: "", // used for model name
        operator: "==", // rule operator
        label: "", // label shown when editing fields
        choiceType: "input", // input, select
        fieldTypes: [], // auto connect this conditions with these field types

        data: {
            conditions: false, // the parent instance
            field: false, // the field which we query against
            rule: {}, // the rule [field, operator, value]
        },

        events: {
            change: "change",
            keyup: "change",
            enableField: "change",
            disableField: "change",
        },

        setup: function (props) {
            $.extend(this.data, props);
        },

        getEventTarget: function ($el, event) {
            return $el || this.get("field").$el;
        },

        change: function (e, $el) {
            this.get("conditions").change(e);
        },

        match: function (rule, field) {
            return false;
        },

        calculate: function () {
            return this.match(this.get("rule"), this.get("field"));
        },

        choices: function (field) {
            return '<input type="text" />';
        },
    });

    /**
     *  acf.newCondition
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    acf.newCondition = function (rule, conditions) {
        // currently setting up conditions for fieldX, this field is the 'target'
        var target = conditions.get("field");

        // use the 'target' to find the 'trigger' field.
        // - this field is used to setup the conditional logic events
        var field = target.getField(rule.field);

        // bail ealry if no target or no field (possible if field doesn't exist due to HTML error)
        if (!target || !field) {
            return false;
        }

        // vars
        var args = {
            rule: rule,
            target: target,
            conditions: conditions,
            field: field,
        };

        // vars
        var fieldType = field.get("type");
        var operator = rule.operator;

        // get avaibale conditions
        var conditionTypes = acf.getConditionTypes({
            fieldType: fieldType,
            operator: operator,
        });

        // instantiate
        var model = conditionTypes[0] || acf.Condition;

        // instantiate
        var condition = new model(args);

        // return
        return condition;
    };

    /**
     *  mid
     *
     *  Calculates the model ID for a field type
     *
     *  @date	15/12/17
     *  @since	5.6.5
     *
     *  @param	string type
     *  @return	string
     */

    var modelId = function (type) {
        return acf.strPascalCase(type || "") + "Condition";
    };

    /**
     *  acf.registerConditionType
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    acf.registerConditionType = function (model) {
        // vars
        var proto = model.prototype;
        var type = proto.type;
        var mid = modelId(type);

        // store model
        acf.models[mid] = model;

        // store reference
        storage.push(type);
    };

    /**
     *  acf.getConditionType
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    acf.getConditionType = function (type) {
        var mid = modelId(type);
        return acf.models[mid] || false;
    };

    /**
     *  acf.registerConditionForFieldType
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    acf.registerConditionForFieldType = function (conditionType, fieldType) {
        // get model
        var model = acf.getConditionType(conditionType);

        // append
        if (model) {
            model.prototype.fieldTypes.push(fieldType);
        }
    };

    /**
     *  acf.getConditionTypes
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    acf.getConditionTypes = function (args) {
        // defaults
        args = acf.parseArgs(args, {
            fieldType: "",
            operator: "",
        });

        // clonse available types
        var types = [];

        // loop
        storage.map(function (type) {
            // vars
            var model = acf.getConditionType(type);
            var ProtoFieldTypes = model.prototype.fieldTypes;
            var ProtoOperator = model.prototype.operator;

            // check fieldType
            if (
                args.fieldType &&
                ProtoFieldTypes.indexOf(args.fieldType) === -1
            ) {
                return;
            }

            // check operator
            if (args.operator && ProtoOperator !== args.operator) {
                return;
            }

            // append
            types.push(model);
        });

        // return
        return types;
    };
})(jQuery);
(function ($, undefined) {
    // vars
    var CONTEXT = "conditional_logic";

    /**
     *  conditionsManager
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    var conditionsManager = new acf.Model({
        id: "conditionsManager",

        priority: 20, // run actions later

        actions: {
            new_field: "onNewField",
        },

        onNewField: function (field) {
            if (field.has("conditions")) {
                field.getConditions().render();
            }
        },
    });

    /**
     *  acf.Field.prototype.getField
     *
     *  Finds a field that is related to another field
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    var getSiblingField = function (field, key) {
        // find sibling (very fast)
        var fields = acf.getFields({
            key: key,
            sibling: field.$el,
            suppressFilters: true,
        });

        // find sibling-children (fast)
        // needed for group fields, accordions, etc
        if (!fields.length) {
            fields = acf.getFields({
                key: key,
                parent: field.$el.parent(),
                suppressFilters: true,
            });
        }

        // return
        if (fields.length) {
            return fields[0];
        }
        return false;
    };

    acf.Field.prototype.getField = function (key) {
        // get sibling field
        var field = getSiblingField(this, key);

        // return early
        if (field) {
            return field;
        }

        // move up through each parent and try again
        var parents = this.parents();
        for (var i = 0; i < parents.length; i++) {
            // get sibling field
            field = getSiblingField(parents[i], key);

            // return early
            if (field) {
                return field;
            }
        }

        // return
        return false;
    };

    /**
     *  acf.Field.prototype.getConditions
     *
     *  Returns the field's conditions instance
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    acf.Field.prototype.getConditions = function () {
        // instantiate
        if (!this.conditions) {
            this.conditions = new Conditions(this);
        }

        // return
        return this.conditions;
    };

    /**
     *  Conditions
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */
    var timeout = false;
    var Conditions = acf.Model.extend({
        id: "Conditions",

        data: {
            field: false, // The field with "data-conditions" (target).
            timeStamp: false, // Reference used during "change" event.
            groups: [], // The groups of condition instances.
        },

        setup: function (field) {
            // data
            this.data.field = field;

            // vars
            var conditions = field.get("conditions");

            // detect groups
            if (conditions instanceof Array) {
                // detect groups
                if (conditions[0] instanceof Array) {
                    // loop
                    conditions.map(function (rules, i) {
                        this.addRules(rules, i);
                    }, this);

                    // detect rules
                } else {
                    this.addRules(conditions);
                }

                // detect rule
            } else {
                this.addRule(conditions);
            }
        },

        change: function (e) {
            // this function may be triggered multiple times per event due to multiple condition classes
            // compare timestamp to allow only 1 trigger per event
            if (this.get("timeStamp") === e.timeStamp) {
                return false;
            } else {
                this.set("timeStamp", e.timeStamp, true);
            }

            // render condition and store result
            var changed = this.render();
        },

        render: function () {
            return this.calculate() ? this.show() : this.hide();
        },

        show: function () {
            return this.get("field").showEnable(this.cid, CONTEXT);
        },

        hide: function () {
            return this.get("field").hideDisable(this.cid, CONTEXT);
        },

        calculate: function () {
            // vars
            var pass = false;

            // loop
            this.getGroups().map(function (group) {
                // igrnore this group if another group passed
                if (pass) return;

                // find passed
                var passed = group.filter(function (condition) {
                    return condition.calculate();
                });

                // if all conditions passed, update the global var
                if (passed.length == group.length) {
                    pass = true;
                }
            });

            return pass;
        },

        hasGroups: function () {
            return this.data.groups != null;
        },

        getGroups: function () {
            return this.data.groups;
        },

        addGroup: function () {
            var group = [];
            this.data.groups.push(group);
            return group;
        },

        hasGroup: function (i) {
            return this.data.groups[i] != null;
        },

        getGroup: function (i) {
            return this.data.groups[i];
        },

        removeGroup: function (i) {
            this.data.groups[i].delete;
            return this;
        },

        addRules: function (rules, group) {
            rules.map(function (rule) {
                this.addRule(rule, group);
            }, this);
        },

        addRule: function (rule, group) {
            // defaults
            group = group || 0;

            // vars
            var groupArray;

            // get group
            if (this.hasGroup(group)) {
                groupArray = this.getGroup(group);
            } else {
                groupArray = this.addGroup();
            }

            // instantiate
            var condition = acf.newCondition(rule, this);

            // bail ealry if condition failed (field did not exist)
            if (!condition) {
                return false;
            }

            // add rule
            groupArray.push(condition);
        },

        hasRule: function () {},

        getRule: function (rule, group) {
            // defaults
            rule = rule || 0;
            group = group || 0;

            return this.data.groups[group][rule];
        },

        removeRule: function () {},
    });
})(jQuery);
(function ($, undefined) {
    var __ = acf.__;

    var parseString = function (val) {
        return val ? "" + val : "";
    };

    var isEqualTo = function (v1, v2) {
        return parseString(v1).toLowerCase() === parseString(v2).toLowerCase();
    };

    var isEqualToNumber = function (v1, v2) {
        return parseFloat(v1) === parseFloat(v2);
    };

    var isGreaterThan = function (v1, v2) {
        return parseFloat(v1) > parseFloat(v2);
    };

    var isLessThan = function (v1, v2) {
        return parseFloat(v1) < parseFloat(v2);
    };

    var inArray = function (v1, array) {
        // cast all values as string
        array = array.map(function (v2) {
            return parseString(v2);
        });

        return array.indexOf(v1) > -1;
    };

    var containsString = function (haystack, needle) {
        return parseString(haystack).indexOf(parseString(needle)) > -1;
    };

    var matchesPattern = function (v1, pattern) {
        var regexp = new RegExp(parseString(pattern), "gi");
        return parseString(v1).match(regexp);
    };

    /**
     *  hasValue
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	void
     *  @return	void
     */

    var HasValue = acf.Condition.extend({
        type: "hasValue",
        operator: "!=empty",
        label: __("Has any value"),
        fieldTypes: [
            "text",
            "textarea",
            "number",
            "range",
            "email",
            "url",
            "password",
            "image",
            "file",
            "wysiwyg",
            "oembed",
            "select",
            "checkbox",
            "radio",
            "button_group",
            "link",
            "post_object",
            "page_link",
            "relationship",
            "taxonomy",
            "user",
            "google_map",
            "date_picker",
            "date_time_picker",
            "time_picker",
            "color_picker",
            "image_select",
        ],
        match: function (rule, field) {
            return field.val() ? true : false;
        },
        choices: function (fieldObject) {
            return '<input type="text" disabled="" />';
        },
    });

    acf.registerConditionType(HasValue);

    /**
     *  hasValue
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	void
     *  @return	void
     */

    var HasNoValue = HasValue.extend({
        type: "hasNoValue",
        operator: "==empty",
        label: __("Has no value"),
        match: function (rule, field) {
            return !HasValue.prototype.match.apply(this, arguments);
        },
    });

    acf.registerConditionType(HasNoValue);

    /**
     *  EqualTo
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	void
     *  @return	void
     */

    var EqualTo = acf.Condition.extend({
        type: "equalTo",
        operator: "==",
        label: __("Value is equal to"),
        fieldTypes: [
            "text",
            "textarea",
            "number",
            "range",
            "email",
            "url",
            "password",
        ],
        match: function (rule, field) {
            if (acf.isNumeric(rule.value)) {
                return isEqualToNumber(rule.value, field.val());
            } else {
                return isEqualTo(rule.value, field.val());
            }
        },
        choices: function (fieldObject) {
            return '<input type="text" />';
        },
    });

    acf.registerConditionType(EqualTo);

    /**
     *  NotEqualTo
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	void
     *  @return	void
     */

    var NotEqualTo = EqualTo.extend({
        type: "notEqualTo",
        operator: "!=",
        label: __("Value is not equal to"),
        match: function (rule, field) {
            return !EqualTo.prototype.match.apply(this, arguments);
        },
    });

    acf.registerConditionType(NotEqualTo);

    /**
     *  PatternMatch
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	void
     *  @return	void
     */

    var PatternMatch = acf.Condition.extend({
        type: "patternMatch",
        operator: "==pattern",
        label: __("Value matches pattern"),
        fieldTypes: ["text", "textarea", "email", "url", "password", "wysiwyg"],
        match: function (rule, field) {
            return matchesPattern(field.val(), rule.value);
        },
        choices: function (fieldObject) {
            return '<input type="text" placeholder="[a-z0-9]" />';
        },
    });

    acf.registerConditionType(PatternMatch);

    /**
     *  Contains
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	void
     *  @return	void
     */

    var Contains = acf.Condition.extend({
        type: "contains",
        operator: "==contains",
        label: __("Value contains"),
        fieldTypes: [
            "text",
            "textarea",
            "number",
            "email",
            "url",
            "password",
            "wysiwyg",
            "oembed",
            "select",
        ],
        match: function (rule, field) {
            return containsString(field.val(), rule.value);
        },
        choices: function (fieldObject) {
            return '<input type="text" />';
        },
    });

    acf.registerConditionType(Contains);

    /**
     *  TrueFalseEqualTo
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	void
     *  @return	void
     */

    var TrueFalseEqualTo = EqualTo.extend({
        type: "trueFalseEqualTo",
        choiceType: "select",
        fieldTypes: ["true_false"],
        choices: function (field) {
            return [
                {
                    id: 1,
                    text: __("Checked"),
                },
            ];
        },
    });

    acf.registerConditionType(TrueFalseEqualTo);

    /**
     *  TrueFalseNotEqualTo
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	void
     *  @return	void
     */

    var TrueFalseNotEqualTo = NotEqualTo.extend({
        type: "trueFalseNotEqualTo",
        choiceType: "select",
        fieldTypes: ["true_false"],
        choices: function (field) {
            return [
                {
                    id: 1,
                    text: __("Checked"),
                },
            ];
        },
    });

    acf.registerConditionType(TrueFalseNotEqualTo);

    /**
     *  SelectEqualTo
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	void
     *  @return	void
     */

    var SelectEqualTo = acf.Condition.extend({
        type: "selectEqualTo",
        operator: "==",
        label: __("Value is equal to"),
        fieldTypes: [
            "select",
            "checkbox",
            "radio",
            "button_group",
            "image_select",
        ],
        match: function (rule, field) {
            var val = field.val();
            if (val instanceof Array) {
                return inArray(rule.value, val);
            } else {
                return isEqualTo(rule.value, val);
            }
        },
        choices: function (fieldObject) {
            // vars
            var choices = [];
            var lines = fieldObject
                .$setting("choices textarea")
                .val()
                .split("\n");

            // allow null
            if (fieldObject.$input("allow_null").prop("checked")) {
                choices.push({
                    id: "",
                    text: __("Null"),
                });
            }

            // loop
            lines.map(function (line) {
                // split
                line = line.split(":");

                // default label to value
                line[1] = line[1] || line[0];

                // append
                choices.push({
                    id: line[0].trim(),
                    text: line[1].trim(),
                });
            });

            // return
            return choices;
        },
    });

    acf.registerConditionType(SelectEqualTo);

    /**
     *  SelectNotEqualTo
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	void
     *  @return	void
     */

    var SelectNotEqualTo = SelectEqualTo.extend({
        type: "selectNotEqualTo",
        operator: "!=",
        label: __("Value is not equal to"),
        match: function (rule, field) {
            return !SelectEqualTo.prototype.match.apply(this, arguments);
        },
    });

    acf.registerConditionType(SelectNotEqualTo);

    /**
     *  GreaterThan
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	void
     *  @return	void
     */

    var GreaterThan = acf.Condition.extend({
        type: "greaterThan",
        operator: ">",
        label: __("Value is greater than"),
        fieldTypes: ["number", "range"],
        match: function (rule, field) {
            var val = field.val();
            if (val instanceof Array) {
                val = val.length;
            }
            return isGreaterThan(val, rule.value);
        },
        choices: function (fieldObject) {
            return '<input type="number" />';
        },
    });

    acf.registerConditionType(GreaterThan);

    /**
     *  LessThan
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	void
     *  @return	void
     */

    var LessThan = GreaterThan.extend({
        type: "lessThan",
        operator: "<",
        label: __("Value is less than"),
        match: function (rule, field) {
            var val = field.val();
            if (val instanceof Array) {
                val = val.length;
            }
            return isLessThan(val, rule.value);
        },
        choices: function (fieldObject) {
            return '<input type="number" />';
        },
    });

    acf.registerConditionType(LessThan);

    /**
     *  SelectedGreaterThan
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	void
     *  @return	void
     */

    var SelectionGreaterThan = GreaterThan.extend({
        type: "selectionGreaterThan",
        label: __("Selection is greater than"),
        fieldTypes: [
            "checkbox",
            "select",
            "post_object",
            "page_link",
            "relationship",
            "taxonomy",
            "user",
        ],
    });

    acf.registerConditionType(SelectionGreaterThan);

    /**
     *  SelectedGreaterThan
     *
     *  description
     *
     *  @date	1/2/18
     *  @since	5.6.5
     *
     *  @param	void
     *  @return	void
     */

    var SelectionLessThan = LessThan.extend({
        type: "selectionLessThan",
        label: __("Selection is less than"),
        fieldTypes: [
            "checkbox",
            "select",
            "post_object",
            "page_link",
            "relationship",
            "taxonomy",
            "user",
        ],
    });

    acf.registerConditionType(SelectionLessThan);
})(jQuery);
(function ($, undefined) {
    acf.unload = new acf.Model({
        wait: "load",
        active: true,
        changed: false,

        actions: {
            validation_failure: "startListening",
            validation_success: "stopListening",
        },

        events: {
            "change form .acf-field": "startListening",
            "submit form": "stopListening",
        },

        enable: function () {
            this.active = true;
        },

        disable: function () {
            this.active = false;
        },

        reset: function () {
            this.stopListening();
        },

        startListening: function () {
            // bail ealry if already changed, not active
            if (this.changed || !this.active) {
                return;
            }

            // update
            this.changed = true;

            // add event
            $(window).on("beforeunload", this.onUnload);
        },

        stopListening: function () {
            // update
            this.changed = false;

            // remove event
            $(window).off("beforeunload", this.onUnload);
        },

        onUnload: function () {
            return acf.__(
                "The changes you made will be lost if you navigate away from this page"
            );
        },
    });
})(jQuery);
(function ($, undefined) {
    /**
     * postboxManager
     *
     * Manages postboxes on the screen.
     *
     * @date	25/5/19
     * @since	5.8.1
     *
     * @param	void
     * @return	void
     */
    var postboxManager = new acf.Model({
        wait: "prepare",
        priority: 1,
        initialize: function () {
            (acf.get("postboxes") || []).map(acf.newPostbox);
        },
    });

    /**
     *  acf.getPostbox
     *
     *  Returns a postbox instance.
     *
     *  @date	23/9/18
     *  @since	5.7.7
     *
     *  @param	mixed $el Either a jQuery element or the postbox id.
     *  @return	object
     */
    acf.getPostbox = function ($el) {
        // allow string parameter
        if (typeof arguments[0] == "string") {
            $el = $("#" + arguments[0]);
        }

        // return instance
        return acf.getInstance($el);
    };

    /**
     *  acf.getPostboxes
     *
     *  Returns an array of postbox instances.
     *
     *  @date	23/9/18
     *  @since	5.7.7
     *
     *  @param	void
     *  @return	array
     */
    acf.getPostboxes = function () {
        return acf.getInstances($(".acf-postbox"));
    };

    /**
     *  acf.newPostbox
     *
     *  Returns a new postbox instance for the given props.
     *
     *  @date	20/9/18
     *  @since	5.7.6
     *
     *  @param	object props The postbox properties.
     *  @return	object
     */
    acf.newPostbox = function (props) {
        return new acf.models.Postbox(props);
    };

    /**
     *  acf.models.Postbox
     *
     *  The postbox model.
     *
     *  @date	20/9/18
     *  @since	5.7.6
     *
     *  @param	void
     *  @return	void
     */
    acf.models.Postbox = acf.Model.extend({
        data: {
            id: "",
            key: "",
            style: "default",
            label: "top",
            edit: "",
        },

        setup: function (props) {
            // compatibilty
            if (props.editLink) {
                props.edit = props.editLink;
            }

            // extend data
            $.extend(this.data, props);

            // set $el
            this.$el = this.$postbox();
        },

        $postbox: function () {
            return $("#" + this.get("id"));
        },

        $hide: function () {
            return $("#" + this.get("id") + "-hide");
        },

        $hideLabel: function () {
            return this.$hide().parent();
        },

        $hndle: function () {
            return this.$("> .hndle");
        },

        $handleActions: function () {
            return this.$("> .postbox-header .handle-actions");
        },

        $inside: function () {
            return this.$("> .inside");
        },

        isVisible: function () {
            return this.$el.hasClass("acf-hidden");
        },

        initialize: function () {
            // Add default class.
            this.$el.addClass("acf-postbox");

            // Remove 'hide-if-js class.
            // This class is added by WP to postboxes that are hidden via the "Screen Options" tab.
            this.$el.removeClass("hide-if-js");

            // Add field group style class (ignore in block editor).
            if (acf.get("editor") !== "block") {
                var style = this.get("style");
                if (style !== "default") {
                    this.$el.addClass(style);
                }
            }

            // Add .inside class.
            this.$inside()
                .addClass("acf-fields")
                .addClass("-" + this.get("label"));

            // Append edit link.
            var edit = this.get("edit");
            if (edit) {
                var html =
                    '<a href="' +
                    edit +
                    '" class="dashicons dashicons-admin-generic acf-hndle-cog acf-js-tooltip" title="' +
                    acf.__("Edit field group") +
                    '"></a>';
                var $handleActions = this.$handleActions();
                if ($handleActions.length) {
                    $handleActions.prepend(html);
                } else {
                    this.$hndle().append(html);
                }
            }

            // Show postbox.
            this.show();
        },

        show: function () {
            // Show label.
            this.$hideLabel().show();

            // toggle on checkbox
            this.$hide().prop("checked", true);

            // Show postbox
            this.$el.show().removeClass("acf-hidden");

            // Do action.
            acf.doAction("show_postbox", this);
        },

        enable: function () {
            acf.enable(this.$el, "postbox");
        },

        showEnable: function () {
            this.enable();
            this.show();
        },

        hide: function () {
            // Hide label.
            this.$hideLabel().hide();

            // Hide postbox
            this.$el.hide().addClass("acf-hidden");

            // Do action.
            acf.doAction("hide_postbox", this);
        },

        disable: function () {
            acf.disable(this.$el, "postbox");
        },

        hideDisable: function () {
            this.disable();
            this.hide();
        },

        html: function (html) {
            // Update HTML.
            this.$inside().html(html);

            // Do action.
            acf.doAction("append", this.$el);
        },
    });
})(jQuery);
(function ($, undefined) {
    /**
     *  acf.newMediaPopup
     *
     *  description
     *
     *  @date	10/1/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    acf.newMediaPopup = function (args) {
        // args
        var popup = null;
        var args = acf.parseArgs(args, {
            mode: "select", // 'select', 'edit'
            title: "", // 'Upload Image'
            button: "", // 'Select Image'
            type: "", // 'image', ''
            field: false, // field instance
            allowedTypes: "", // '.jpg, .png, etc'
            library: "all", // 'all', 'uploadedTo'
            multiple: false, // false, true, 'add'
            attachment: 0, // the attachment to edit
            autoOpen: true, // open the popup automatically
            open: function () {}, // callback after close
            select: function () {}, // callback after select
            close: function () {}, // callback after close
        });

        // initialize
        if (args.mode == "edit") {
            popup = new acf.models.EditMediaPopup(args);
        } else {
            popup = new acf.models.SelectMediaPopup(args);
        }

        // open popup (allow frame customization before opening)
        if (args.autoOpen) {
            setTimeout(function () {
                popup.open();
            }, 1);
        }

        // action
        acf.doAction("new_media_popup", popup);

        // return
        return popup;
    };

    /**
     *  getPostID
     *
     *  description
     *
     *  @date	10/1/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    var getPostID = function () {
        var postID = acf.get("post_id");
        return acf.isNumeric(postID) ? postID : 0;
    };

    /**
     *  acf.getMimeTypes
     *
     *  description
     *
     *  @date	11/1/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    acf.getMimeTypes = function () {
        return this.get("mimeTypes");
    };

    acf.getMimeType = function (name) {
        // vars
        var allTypes = acf.getMimeTypes();

        // search
        if (allTypes[name] !== undefined) {
            return allTypes[name];
        }

        // some types contain a mixed key such as "jpg|jpeg|jpe"
        for (var key in allTypes) {
            if (key.indexOf(name) !== -1) {
                return allTypes[key];
            }
        }

        // return
        return false;
    };

    /**
     *  MediaPopup
     *
     *  description
     *
     *  @date	10/1/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    var MediaPopup = acf.Model.extend({
        id: "MediaPopup",
        data: {},
        defaults: {},
        frame: false,

        setup: function (props) {
            $.extend(this.data, props);
        },

        initialize: function () {
            // vars
            var options = this.getFrameOptions();

            // add states
            this.addFrameStates(options);

            // create frame
            var frame = wp.media(options);

            // add args reference
            frame.acf = this;

            // add events
            this.addFrameEvents(frame, options);

            // strore frame
            this.frame = frame;
        },

        open: function () {
            this.frame.open();
        },

        close: function () {
            this.frame.close();
        },

        remove: function () {
            this.frame.detach();
            this.frame.remove();
        },

        getFrameOptions: function () {
            // vars
            var options = {
                title: this.get("title"),
                multiple: this.get("multiple"),
                library: {},
                states: [],
            };

            // type
            if (this.get("type")) {
                options.library.type = this.get("type");
            }

            // type
            if (this.get("library") === "uploadedTo") {
                options.library.uploadedTo = getPostID();
            }

            // attachment
            if (this.get("attachment")) {
                options.library.post__in = [this.get("attachment")];
            }

            // button
            if (this.get("button")) {
                options.button = {
                    text: this.get("button"),
                };
            }

            // return
            return options;
        },

        addFrameStates: function (options) {
            // create query
            var Query = wp.media.query(options.library);

            // add _acfuploader
            // this is super wack!
            // if you add _acfuploader to the options.library args, new uploads will not be added to the library view.
            // this has been traced back to the wp.media.model.Query initialize function (which can't be overriden)
            // Adding any custom args will cause the Attahcments to not observe the uploader queue
            // To bypass this security issue, we add in the args AFTER the Query has been initialized
            // options.library._acfuploader = settings.field;
            if (this.get("field") && acf.isset(Query, "mirroring", "args")) {
                Query.mirroring.args._acfuploader = this.get("field");
            }

            // add states
            options.states.push(
                // main state
                new wp.media.controller.Library({
                    library: Query,
                    multiple: this.get("multiple"),
                    title: this.get("title"),
                    priority: 20,
                    filterable: "all",
                    editable: true,
                    allowLocalEdits: true,
                })
            );

            // edit image functionality (added in WP 3.9)
            if (acf.isset(wp, "media", "controller", "EditImage")) {
                options.states.push(new wp.media.controller.EditImage());
            }
        },

        addFrameEvents: function (frame, options) {
            // log all events
            //frame.on('all', function( e ) {
            //	console.log( 'frame all: %o', e );
            //});

            // add class
            frame.on(
                "open",
                function () {
                    this.$el
                        .closest(".media-modal")
                        .addClass("acf-media-modal -" + this.acf.get("mode"));
                },
                frame
            );

            // edit image view
            // source: media-views.js:2410 editImageContent()
            frame.on(
                "content:render:edit-image",
                function () {
                    var image = this.state().get("image");
                    var view = new wp.media.view.EditImage({
                        model: image,
                        controller: this,
                    }).render();
                    this.content.set(view);

                    // after creating the wrapper view, load the actual editor via an ajax call
                    view.loadEditor();
                },
                frame
            );

            // update toolbar button
            //frame.on( 'toolbar:create:select', function( toolbar ) {
            //	toolbar.view = new wp.media.view.Toolbar.Select({
            //		text: frame.options._button,
            //		controller: this
            //	});
            //}, frame );

            // on select
            frame.on("select", function () {
                // vars
                var selection = frame.state().get("selection");

                // if selecting images
                if (selection) {
                    // loop
                    selection.each(function (attachment, i) {
                        frame.acf
                            .get("select")
                            .apply(frame.acf, [attachment, i]);
                    });
                }
            });

            // on close
            frame.on("close", function () {
                // callback and remove
                setTimeout(function () {
                    frame.acf.get("close").apply(frame.acf);
                    frame.acf.remove();
                }, 1);
            });
        },
    });

    /**
     *  acf.models.SelectMediaPopup
     *
     *  description
     *
     *  @date	10/1/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    acf.models.SelectMediaPopup = MediaPopup.extend({
        id: "SelectMediaPopup",
        setup: function (props) {
            // default button
            if (!props.button) {
                props.button = acf._x("Select", "verb");
            }

            // parent
            MediaPopup.prototype.setup.apply(this, arguments);
        },

        addFrameEvents: function (frame, options) {
            // plupload
            // adds _acfuploader param to validate uploads
            if (
                acf.isset(_wpPluploadSettings, "defaults", "multipart_params")
            ) {
                // add _acfuploader so that Uploader will inherit
                _wpPluploadSettings.defaults.multipart_params._acfuploader =
                    this.get("field");

                // remove acf_field so future Uploaders won't inherit
                frame.on("open", function () {
                    delete _wpPluploadSettings
                        .defaults.multipart_params._acfuploader;
                });
            }

            // browse
            frame.on("content:activate:browse", function () {
                // vars
                var toolbar = false;

                // populate above vars making sure to allow for failure
                // perhaps toolbar does not exist because the frame open is Upload Files
                try {
                    toolbar = frame.content.get().toolbar;
                } catch (e) {
                    console.log(e);
                    return;
                }

                // callback
                frame.acf.customizeFilters.apply(frame.acf, [toolbar]);
            });

            // parent
            MediaPopup.prototype.addFrameEvents.apply(this, arguments);
        },

        customizeFilters: function (toolbar) {
            // vars
            var filters = toolbar.get("filters");

            // image
            if (this.get("type") == "image") {
                // update all
                filters.filters.all.text = acf.__("All images");

                // remove some filters
                delete filters.filters.audio;
                delete filters.filters.video;
                delete filters.filters.image;

                // update all filters to show images
                $.each(filters.filters, function (i, filter) {
                    filter.props.type = filter.props.type || "image";
                });
            }

            // specific types
            if (this.get("allowedTypes")) {
                // convert ".jpg, .png" into ["jpg", "png"]
                var allowedTypes = this.get("allowedTypes")
                    .split(" ")
                    .join("")
                    .split(".")
                    .join("")
                    .split(",");

                // loop
                allowedTypes.map(function (name) {
                    // get type
                    var mimeType = acf.getMimeType(name);

                    // bail early if no type
                    if (!mimeType) return;

                    // create new filter
                    var newFilter = {
                        text: mimeType,
                        props: {
                            status: null,
                            type: mimeType,
                            uploadedTo: null,
                            orderby: "date",
                            order: "DESC",
                        },
                        priority: 20,
                    };

                    // append
                    filters.filters[mimeType] = newFilter;
                });
            }

            // uploaded to post
            if (this.get("library") === "uploadedTo") {
                // vars
                var uploadedTo = this.frame.options.library.uploadedTo;

                // remove some filters
                delete filters.filters.unattached;
                delete filters.filters.uploaded;

                // add uploadedTo to filters
                $.each(filters.filters, function (i, filter) {
                    filter.text += " (" + acf.__("Uploaded to this post") + ")";
                    filter.props.uploadedTo = uploadedTo;
                });
            }

            // add _acfuploader to filters
            var field = this.get("field");
            $.each(filters.filters, function (k, filter) {
                filter.props._acfuploader = field;
            });

            // add _acfuplaoder to search
            var search = toolbar.get("search");
            search.model.attributes._acfuploader = field;

            // render (custom function added to prototype)
            if (filters.renderFilters) {
                filters.renderFilters();
            }
        },
    });

    /**
     *  acf.models.EditMediaPopup
     *
     *  description
     *
     *  @date	10/1/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    acf.models.EditMediaPopup = MediaPopup.extend({
        id: "SelectMediaPopup",
        setup: function (props) {
            // default button
            if (!props.button) {
                props.button = acf._x("Update", "verb");
            }

            // parent
            MediaPopup.prototype.setup.apply(this, arguments);
        },

        addFrameEvents: function (frame, options) {
            // add class
            frame.on(
                "open",
                function () {
                    // add class
                    this.$el.closest(".media-modal").addClass("acf-expanded");

                    // set to browse
                    if (this.content.mode() != "browse") {
                        this.content.mode("browse");
                    }

                    // set selection
                    var state = this.state();
                    var selection = state.get("selection");
                    var attachment = wp.media.attachment(
                        frame.acf.get("attachment")
                    );
                    selection.add(attachment);
                },
                frame
            );

            // parent
            MediaPopup.prototype.addFrameEvents.apply(this, arguments);
        },
    });

    /**
     *  customizePrototypes
     *
     *  description
     *
     *  @date	11/1/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    var customizePrototypes = new acf.Model({
        id: "customizePrototypes",
        wait: "ready",

        initialize: function () {
            // bail early if no media views
            if (!acf.isset(window, "wp", "media", "view")) {
                return;
            }

            // fix bug where CPT without "editor" does not set post.id setting which then prevents uploadedTo from working
            var postID = getPostID();
            if (postID && acf.isset(wp, "media", "view", "settings", "post")) {
                wp.media.view.settings.post.id = postID;
            }

            // customize
            this.customizeAttachmentsButton();
            this.customizeAttachmentsRouter();
            this.customizeAttachmentFilters();
            this.customizeAttachmentCompat();
            this.customizeAttachmentLibrary();
        },

        customizeAttachmentsButton: function () {
            // validate
            if (!acf.isset(wp, "media", "view", "Button")) {
                return;
            }

            // Extend
            var Button = wp.media.view.Button;
            wp.media.view.Button = Button.extend({
                // Fix bug where "Select" button appears blank after editing an image.
                // Do this by simplifying Button initialize function and avoid deleting this.options.
                initialize: function () {
                    var options = _.defaults(this.options, this.defaults);
                    this.model = new Backbone.Model(options);
                    this.listenTo(this.model, "change", this.render);
                },
            });
        },

        customizeAttachmentsRouter: function () {
            // validate
            if (!acf.isset(wp, "media", "view", "Router")) {
                return;
            }

            // vars
            var Parent = wp.media.view.Router;

            // extend
            wp.media.view.Router = Parent.extend({
                addExpand: function () {
                    // vars
                    var $a = $(
                        [
                            '<a href="#" class="acf-expand-details">',
                            '<span class="is-closed"><i class="acf-icon -left -small"></i>' +
                                acf.__("Expand Details") +
                                "</span>",
                            '<span class="is-open"><i class="acf-icon -right -small"></i>' +
                                acf.__("Collapse Details") +
                                "</span>",
                            "</a>",
                        ].join("")
                    );

                    // add events
                    $a.on("click", function (e) {
                        e.preventDefault();
                        var $div = $(this).closest(".media-modal");
                        if ($div.hasClass("acf-expanded")) {
                            $div.removeClass("acf-expanded");
                        } else {
                            $div.addClass("acf-expanded");
                        }
                    });

                    // append
                    this.$el.append($a);
                },

                initialize: function () {
                    // initialize
                    Parent.prototype.initialize.apply(this, arguments);

                    // add buttons
                    this.addExpand();

                    // return
                    return this;
                },
            });
        },

        customizeAttachmentFilters: function () {
            // validate
            if (!acf.isset(wp, "media", "view", "AttachmentFilters", "All")) {
                return;
            }

            // vars
            var Parent = wp.media.view.AttachmentFilters.All;

            // renderFilters
            // copied from media-views.js:6939
            Parent.prototype.renderFilters = function () {
                // Build `<option>` elements.
                this.$el.html(
                    _.chain(this.filters)
                        .map(function (filter, value) {
                            return {
                                el: $("<option></option>")
                                    .val(value)
                                    .html(filter.text)[0],
                                priority: filter.priority || 50,
                            };
                        }, this)
                        .sortBy("priority")
                        .pluck("el")
                        .value()
                );
            };
        },

        customizeAttachmentCompat: function () {
            // validate
            if (!acf.isset(wp, "media", "view", "AttachmentCompat")) {
                return;
            }

            // vars
            var AttachmentCompat = wp.media.view.AttachmentCompat;
            var timeout = false;

            // extend
            wp.media.view.AttachmentCompat = AttachmentCompat.extend({
                render: function () {
                    // WP bug
                    // When multiple media frames exist on the same page (WP content, WYSIWYG, image, file ),
                    // WP creates multiple instances of this AttachmentCompat view.
                    // Each instance will attempt to render when a new modal is created.
                    // Use a property to avoid this and only render once per instance.
                    if (this.rendered) {
                        return this;
                    }

                    // render HTML
                    AttachmentCompat.prototype.render.apply(this, arguments);

                    // when uploading, render is called twice.
                    // ignore first render by checking for #acf-form-data element
                    if (!this.$("#acf-form-data").length) {
                        return this;
                    }

                    // clear timeout
                    clearTimeout(timeout);

                    // setTimeout
                    timeout = setTimeout(
                        $.proxy(function () {
                            this.rendered = true;
                            acf.doAction("append", this.$el);
                        }, this),
                        50
                    );

                    // return
                    return this;
                },

                save: function (event) {
                    var data = {};

                    if (event) {
                        event.preventDefault();
                    }

                    //_.each( this.$el.serializeArray(), function( pair ) {
                    //	data[ pair.name ] = pair.value;
                    //});

                    // Serialize data more thoroughly to allow chckbox inputs to save.
                    data = acf.serializeForAjax(this.$el);

                    this.controller.trigger("attachment:compat:waiting", [
                        "waiting",
                    ]);
                    this.model
                        .saveCompat(data)
                        .always(_.bind(this.postSave, this));
                },
            });
        },

        customizeAttachmentLibrary: function () {
            // validate
            if (!acf.isset(wp, "media", "view", "Attachment", "Library")) {
                return;
            }

            // vars
            var AttachmentLibrary = wp.media.view.Attachment.Library;

            // extend
            wp.media.view.Attachment.Library = AttachmentLibrary.extend({
                render: function () {
                    // vars
                    var popup = acf.isget(this, "controller", "acf");
                    var attributes = acf.isget(this, "model", "attributes");

                    // check vars exist to avoid errors
                    if (popup && attributes) {
                        // show errors
                        if (attributes.acf_errors) {
                            this.$el.addClass("acf-disabled");
                        }

                        // disable selected
                        var selected = popup.get("selected");
                        if (selected && selected.indexOf(attributes.id) > -1) {
                            this.$el.addClass("acf-selected");
                        }
                    }

                    // render
                    return AttachmentLibrary.prototype.render.apply(
                        this,
                        arguments
                    );
                },

                /*
                 *  toggleSelection
                 *
                 *  This function is called before an attachment is selected
                 *  A good place to check for errors and prevent the 'select' function from being fired
                 *
                 *  @type	function
                 *  @date	29/09/2016
                 *  @since	5.4.0
                 *
                 *  @param	options (object)
                 *  @return	n/a
                 */

                toggleSelection: function (options) {
                    // vars
                    // source: wp-includes/js/media-views.js:2880
                    var collection = this.collection,
                        selection = this.options.selection,
                        model = this.model,
                        single = selection.single();

                    // vars
                    var frame = this.controller;
                    var errors = acf.isget(
                        this,
                        "model",
                        "attributes",
                        "acf_errors"
                    );
                    var $sidebar = frame.$el.find(
                        ".media-frame-content .media-sidebar"
                    );

                    // remove previous error
                    $sidebar.children(".acf-selection-error").remove();

                    // show attachment details
                    $sidebar.children().removeClass("acf-hidden");

                    // add message
                    if (frame && errors) {
                        // vars
                        var filename = acf.isget(
                            this,
                            "model",
                            "attributes",
                            "filename"
                        );

                        // hide attachment details
                        // Gallery field continues to show previously selected attachment...
                        $sidebar.children().addClass("acf-hidden");

                        // append message
                        $sidebar.prepend(
                            [
                                '<div class="acf-selection-error">',
                                '<span class="selection-error-label">' +
                                    acf.__("Restricted") +
                                    "</span>",
                                '<span class="selection-error-filename">' +
                                    filename +
                                    "</span>",
                                '<span class="selection-error-message">' +
                                    errors +
                                    "</span>",
                                "</div>",
                            ].join("")
                        );

                        // reset selection (unselects all attachments)
                        selection.reset();

                        // set single (attachment displayed in sidebar)
                        selection.single(model);

                        // return and prevent 'select' form being fired
                        return;
                    }

                    // return
                    return AttachmentLibrary.prototype.toggleSelection.apply(
                        this,
                        arguments
                    );
                },
            });
        },
    });
})(jQuery);
(function ($, undefined) {
    acf.screen = new acf.Model({
        active: true,

        xhr: false,

        timeout: false,

        wait: "load",

        events: {
            "change #page_template": "onChange",
            "change #parent_id": "onChange",
            "change #post-formats-select": "onChange",
            "change .categorychecklist": "onChange",
            "change .tagsdiv": "onChange",
            'change .acf-taxonomy-field[data-save="1"]': "onChange",
            "change #product-type": "onChange",
        },

        isPost: function () {
            return acf.get("screen") === "post";
        },

        isUser: function () {
            return acf.get("screen") === "user";
        },

        isTaxonomy: function () {
            return acf.get("screen") === "taxonomy";
        },

        isAttachment: function () {
            return acf.get("screen") === "attachment";
        },

        isNavMenu: function () {
            return acf.get("screen") === "nav_menu";
        },

        isWidget: function () {
            return acf.get("screen") === "widget";
        },

        isComment: function () {
            return acf.get("screen") === "comment";
        },

        getPageTemplate: function () {
            var $el = $("#page_template");
            return $el.length ? $el.val() : null;
        },

        getPageParent: function (e, $el) {
            var $el = $("#parent_id");
            return $el.length ? $el.val() : null;
        },

        getPageType: function (e, $el) {
            return this.getPageParent() ? "child" : "parent";
        },

        getPostType: function () {
            return $("#post_type").val();
        },

        getPostFormat: function (e, $el) {
            var $el = $("#post-formats-select input:checked");
            if ($el.length) {
                var val = $el.val();
                return val == "0" ? "standard" : val;
            }
            return null;
        },

        getPostCoreTerms: function () {
            // vars
            var terms = {};

            // serialize WP taxonomy postboxes
            var data = acf.serialize($(".categorydiv, .tagsdiv"));

            // use tax_input (tag, custom-taxonomy) when possible.
            // this data is already formatted in taxonomy => [terms].
            if (data.tax_input) {
                terms = data.tax_input;
            }

            // append "category" which uses a different name
            if (data.post_category) {
                terms.category = data.post_category;
            }

            // convert any string values (tags) into array format
            for (var tax in terms) {
                if (!acf.isArray(terms[tax])) {
                    terms[tax] = terms[tax].split(/,[\s]?/);
                }
            }

            // return
            return terms;
        },

        getPostTerms: function () {
            // Get core terms.
            var terms = this.getPostCoreTerms();

            // loop over taxonomy fields and add their values
            acf.getFields({ type: "taxonomy" }).map(function (field) {
                // ignore fields that don't save
                if (!field.get("save")) {
                    return;
                }

                // vars
                var val = field.val();
                var tax = field.get("taxonomy");

                // check val
                if (val) {
                    // ensure terms exists
                    terms[tax] = terms[tax] || [];

                    // ensure val is an array
                    val = acf.isArray(val) ? val : [val];

                    // append
                    terms[tax] = terms[tax].concat(val);
                }
            });

            // add WC product type
            if ((productType = this.getProductType()) !== null) {
                terms.product_type = [productType];
            }

            // remove duplicate values
            for (var tax in terms) {
                terms[tax] = acf.uniqueArray(terms[tax]);
            }

            // return
            return terms;
        },

        getProductType: function () {
            var $el = $("#product-type");
            return $el.length ? $el.val() : null;
        },

        check: function () {
            // bail early if not for post
            if (acf.get("screen") !== "post") {
                return;
            }

            // abort XHR if is already loading AJAX data
            if (this.xhr) {
                this.xhr.abort();
            }

            // vars
            var ajaxData = acf.parseArgs(this.data, {
                action: "acf/ajax/check_screen",
                screen: acf.get("screen"),
                exists: [],
            });

            // post id
            if (this.isPost()) {
                ajaxData.post_id = acf.get("post_id");
            }

            // post type
            if ((postType = this.getPostType()) !== null) {
                ajaxData.post_type = postType;
            }

            // page template
            if ((pageTemplate = this.getPageTemplate()) !== null) {
                ajaxData.page_template = pageTemplate;
            }

            // page parent
            if ((pageParent = this.getPageParent()) !== null) {
                ajaxData.page_parent = pageParent;
            }

            // page type
            if ((pageType = this.getPageType()) !== null) {
                ajaxData.page_type = pageType;
            }

            // post format
            if ((postFormat = this.getPostFormat()) !== null) {
                ajaxData.post_format = postFormat;
            }

            // post terms
            if ((postTerms = this.getPostTerms()) !== null) {
                ajaxData.post_terms = postTerms;
            }

            // add array of existing postboxes to increase performance and reduce JSON HTML
            acf.getPostboxes().map(function (postbox) {
                ajaxData.exists.push(postbox.get("key"));
            });

            // filter
            ajaxData = acf.applyFilters("check_screen_args", ajaxData);

            // success
            var onSuccess = function (json) {
                // Render post screen.
                if (acf.get("screen") == "post") {
                    this.renderPostScreen(json);

                    // Render user screen.
                } else if (acf.get("screen") == "user") {
                    this.renderUserScreen(json);
                }

                // action
                acf.doAction("check_screen_complete", json, ajaxData);
            };

            // ajax
            this.xhr = $.ajax({
                url: acf.get("ajaxurl"),
                data: acf.prepareForAjax(ajaxData),
                type: "post",
                dataType: "json",
                context: this,
                success: onSuccess,
            });
        },

        onChange: function (e, $el) {
            this.setTimeout(this.check, 1);
        },

        renderPostScreen: function (data) {
            // Helper function to copy events
            var copyEvents = function ($from, $to) {
                var events = $._data($from[0]).events;
                for (var type in events) {
                    for (var i = 0; i < events[type].length; i++) {
                        $to.on(type, events[type][i].handler);
                    }
                }
            };

            // Helper function to sort metabox.
            var sortMetabox = function (id, ids) {
                // Find position of id within ids.
                var index = ids.indexOf(id);

                // Bail early if index not found.
                if (index == -1) {
                    return false;
                }

                // Loop over metaboxes behind (in reverse order).
                for (var i = index - 1; i >= 0; i--) {
                    if ($("#" + ids[i]).length) {
                        return $("#" + ids[i]).after($("#" + id));
                    }
                }

                // Loop over metaboxes infront.
                for (var i = index + 1; i < ids.length; i++) {
                    if ($("#" + ids[i]).length) {
                        return $("#" + ids[i]).before($("#" + id));
                    }
                }

                // Return false if not sorted.
                return false;
            };

            // Keep track of visible and hidden postboxes.
            data.visible = [];
            data.hidden = [];

            // Show these postboxes.
            data.results = data.results.map(function (result, i) {
                // vars
                var postbox = acf.getPostbox(result.id);

                // Prevent "acf_after_title" position in Block Editor.
                if (acf.isGutenberg() && result.position == "acf_after_title") {
                    result.position = "normal";
                }

                // Create postbox if doesn't exist.
                if (!postbox) {
                    var wpMinorVersion = parseFloat(acf.get("wp_version"));
                    if (wpMinorVersion >= 5.5) {
                        var postboxHeader = [
                            '<div class="postbox-header">',
                            '<h2 class="hndle ui-sortable-handle">',
                            "<span>" + acf.escHtml(result.title) + "</span>",
                            "</h2>",
                            '<div class="handle-actions hide-if-no-js">',
                            '<button type="button" class="handlediv" aria-expanded="true">',
                            '<span class="screen-reader-text">Toggle panel: ' +
                                acf.escHtml(result.title) +
                                "</span>",
                            '<span class="toggle-indicator" aria-hidden="true"></span>',
                            "</button>",
                            "</div>",
                            "</div>",
                        ].join("");
                    } else {
                        var postboxHeader = [
                            '<button type="button" class="handlediv" aria-expanded="true">',
                            '<span class="screen-reader-text">Toggle panel: ' +
                                acf.escHtml(result.title) +
                                "</span>",
                            '<span class="toggle-indicator" aria-hidden="true"></span>',
                            "</button>",
                            '<h2 class="hndle ui-sortable-handle">',
                            "<span>" + acf.escHtml(result.title) + "</span>",
                            "</h2>",
                        ].join("");
                    }

                    // Create it.
                    var $postbox = $(
                        [
                            '<div id="' + result.id + '" class="postbox">',
                            postboxHeader,
                            '<div class="inside">',
                            result.html,
                            "</div>",
                            "</div>",
                        ].join("")
                    );

                    // Create new hide toggle.
                    if ($("#adv-settings").length) {
                        var $prefs = $("#adv-settings .metabox-prefs");
                        var $label = $(
                            [
                                '<label for="' + result.id + '-hide">',
                                '<input class="hide-postbox-tog" name="' +
                                    result.id +
                                    '-hide" type="checkbox" id="' +
                                    result.id +
                                    '-hide" value="' +
                                    result.id +
                                    '" checked="checked">',
                                " " + result.title,
                                "</label>",
                            ].join("")
                        );

                        // Copy default WP events onto checkbox.
                        copyEvents(
                            $prefs.find("input").first(),
                            $label.find("input")
                        );

                        // Append hide label
                        $prefs.append($label);
                    }

                    // Copy default WP events onto metabox.
                    if ($(".postbox").length) {
                        copyEvents(
                            $(".postbox .handlediv").first(),
                            $postbox.children(".handlediv")
                        );
                        copyEvents(
                            $(".postbox .hndle").first(),
                            $postbox.children(".hndle")
                        );
                    }

                    // Append metabox to the bottom of "side-sortables".
                    if (result.position === "side") {
                        $("#" + result.position + "-sortables").append(
                            $postbox
                        );

                        // Prepend metabox to the top of "normal-sortbables".
                    } else {
                        $("#" + result.position + "-sortables").prepend(
                            $postbox
                        );
                    }

                    // Position metabox amongst existing ACF metaboxes within the same location.
                    var order = [];
                    data.results.map(function (_result) {
                        if (
                            result.position === _result.position &&
                            $(
                                "#" +
                                    result.position +
                                    "-sortables #" +
                                    _result.id
                            ).length
                        ) {
                            order.push(_result.id);
                        }
                    });
                    sortMetabox(result.id, order);

                    // Check 'sorted' for user preference.
                    if (data.sorted) {
                        // Loop over each position (acf_after_title, side, normal).
                        for (var position in data.sorted) {
                            // Explode string into array of ids.
                            var order = data.sorted[position].split(",");

                            // Position metabox relative to order.
                            if (sortMetabox(result.id, order)) {
                                break;
                            }
                        }
                    }

                    // Initalize it (modifies HTML).
                    postbox = acf.newPostbox(result);

                    // Trigger action.
                    acf.doAction("append", $postbox);
                    acf.doAction("append_postbox", postbox);
                }

                // show postbox
                postbox.showEnable();

                // append
                data.visible.push(result.id);

                // Return result (may have changed).
                return result;
            });

            // Hide these postboxes.
            acf.getPostboxes().map(function (postbox) {
                if (data.visible.indexOf(postbox.get("id")) === -1) {
                    // Hide postbox.
                    postbox.hideDisable();

                    // Append to data.
                    data.hidden.push(postbox.get("id"));
                }
            });

            // Update style.
            $("#acf-style").html(data.style);

            // Do action.
            acf.doAction("refresh_post_screen", data);
        },

        renderUserScreen: function (json) {},
    });

    /**
     *  gutenScreen
     *
     *  Adds compatibility with the Gutenberg edit screen.
     *
     *  @date	11/12/18
     *  @since	5.8.0
     *
     *  @param	void
     *  @return	void
     */
    var gutenScreen = new acf.Model({
        // Keep a reference to the most recent post attributes.
        postEdits: {},

        // Wait until assets have been loaded.
        wait: "prepare",

        initialize: function () {
            // Bail early if not Gutenberg.
            if (!acf.isGutenberg()) {
                return;
            }

            // Listen for changes (use debounced version as this can fires often).
            wp.data.subscribe(acf.debounce(this.onChange).bind(this));

            // Customize "acf.screen.get" functions.
            acf.screen.getPageTemplate = this.getPageTemplate;
            acf.screen.getPageParent = this.getPageParent;
            acf.screen.getPostType = this.getPostType;
            acf.screen.getPostFormat = this.getPostFormat;
            acf.screen.getPostCoreTerms = this.getPostCoreTerms;

            // Disable unload
            acf.unload.disable();

            // Refresh metaboxes since WP 5.3.
            var wpMinorVersion = parseFloat(acf.get("wp_version"));
            if (wpMinorVersion >= 5.3) {
                this.addAction("refresh_post_screen", this.onRefreshPostScreen);
            }

            // Trigger "refresh" after WP has moved metaboxes into place.
            wp.domReady(acf.refresh);
        },

        onChange: function () {
            // Determine attributes that can trigger a refresh.
            var attributes = ["template", "parent", "format"];

            // Append taxonomy attribute names to this list.
            (wp.data.select("core").getTaxonomies() || []).map(function (
                taxonomy
            ) {
                attributes.push(taxonomy.rest_base);
            });

            // Get relevant current post edits.
            var _postEdits = wp.data.select("core/editor").getPostEdits();
            var postEdits = {};
            attributes.map(function (k) {
                if (_postEdits[k] !== undefined) {
                    postEdits[k] = _postEdits[k];
                }
            });

            // Detect change.
            if (JSON.stringify(postEdits) !== JSON.stringify(this.postEdits)) {
                this.postEdits = postEdits;

                // Check screen.
                acf.screen.check();
            }
        },

        getPageTemplate: function () {
            return wp.data
                .select("core/editor")
                .getEditedPostAttribute("template");
        },

        getPageParent: function (e, $el) {
            return wp.data
                .select("core/editor")
                .getEditedPostAttribute("parent");
        },

        getPostType: function () {
            return wp.data.select("core/editor").getEditedPostAttribute("type");
        },

        getPostFormat: function (e, $el) {
            return wp.data
                .select("core/editor")
                .getEditedPostAttribute("format");
        },

        getPostCoreTerms: function () {
            // vars
            var terms = {};

            // Loop over taxonomies.
            var taxonomies = wp.data.select("core").getTaxonomies() || [];
            taxonomies.map(function (taxonomy) {
                // Append selected taxonomies to terms object.
                var postTerms = wp.data
                    .select("core/editor")
                    .getEditedPostAttribute(taxonomy.rest_base);
                if (postTerms) {
                    terms[taxonomy.slug] = postTerms;
                }
            });

            // return
            return terms;
        },

        /**
         * onRefreshPostScreen
         *
         * Fires after the Post edit screen metaboxs are refreshed to update the Block Editor API state.
         *
         * @date	11/11/19
         * @since	5.8.7
         *
         * @param	object data The "check_screen" JSON response data.
         * @return	void
         */
        onRefreshPostScreen: function (data) {
            // Extract vars.
            var select = wp.data.select("core/edit-post");
            var dispatch = wp.data.dispatch("core/edit-post");

            // Load current metabox locations and data.
            var locations = {};
            select.getActiveMetaBoxLocations().map(function (location) {
                locations[location] = select.getMetaBoxesPerLocation(location);
            });

            // Generate flat array of existing ids.
            var ids = [];
            for (var k in locations) {
                locations[k].map(function (m) {
                    ids.push(m.id);
                });
            }

            // Append new ACF metaboxes (ignore those which already exist).
            data.results
                .filter(function (r) {
                    return ids.indexOf(r.id) === -1;
                })
                .map(function (result, i) {
                    // Ensure location exists.
                    var location = result.position;
                    locations[location] = locations[location] || [];

                    // Append.
                    locations[location].push({
                        id: result.id,
                        title: result.title,
                    });
                });

            // Remove hidden ACF metaboxes.
            for (var k in locations) {
                locations[k] = locations[k].filter(function (m) {
                    return data.hidden.indexOf(m.id) === -1;
                });
            }

            // Update state.
            dispatch.setAvailableMetaBoxesPerLocation(locations);
        },
    });
})(jQuery);
(function ($, undefined) {
    /**
     *  acf.newSelect2
     *
     *  description
     *
     *  @date	13/1/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    acf.newSelect2 = function ($select, props) {
        // defaults
        props = acf.parseArgs(props, {
            allowNull: false,
            placeholder: "",
            multiple: false,
            field: false,
            ajax: false,
            ajaxAction: "",
            ajaxData: function (data) {
                return data;
            },
            ajaxResults: function (json) {
                return json;
            },
        });

        // initialize
        if (getVersion() == 4) {
            var select2 = new Select2_4($select, props);
        } else {
            var select2 = new Select2_3($select, props);
        }

        // actions
        acf.doAction("new_select2", select2);

        // return
        return select2;
    };

    /**
     *  getVersion
     *
     *  description
     *
     *  @date	13/1/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    function getVersion() {
        // v4
        if (acf.isset(window, "jQuery", "fn", "select2", "amd")) {
            return 4;
        }

        // v3
        if (acf.isset(window, "Select2")) {
            return 3;
        }

        // return
        return false;
    }

    /**
     *  Select2
     *
     *  description
     *
     *  @date	13/1/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    var Select2 = acf.Model.extend({
        setup: function ($select, props) {
            $.extend(this.data, props);
            this.$el = $select;
        },

        initialize: function () {},

        selectOption: function (value) {
            var $option = this.getOption(value);
            if (!$option.prop("selected")) {
                $option.prop("selected", true).trigger("change");
            }
        },

        unselectOption: function (value) {
            var $option = this.getOption(value);
            if ($option.prop("selected")) {
                $option.prop("selected", false).trigger("change");
            }
        },

        getOption: function (value) {
            return this.$('option[value="' + value + '"]');
        },

        addOption: function (option) {
            // defaults
            option = acf.parseArgs(option, {
                id: "",
                text: "",
                selected: false,
            });

            // vars
            var $option = this.getOption(option.id);

            // append
            if (!$option.length) {
                $option = $("<option></option>");
                $option.html(option.text);
                $option.attr("value", option.id);
                $option.prop("selected", option.selected);
                this.$el.append($option);
            }

            // chain
            return $option;
        },

        getValue: function () {
            // vars
            var val = [];
            var $options = this.$el.find("option:selected");

            // bail early if no selected
            if (!$options.exists()) {
                return val;
            }

            // sort by attribute
            $options = $options.sort(function (a, b) {
                return +a.getAttribute("data-i") - +b.getAttribute("data-i");
            });

            // loop
            $options.each(function () {
                var $el = $(this);
                val.push({
                    $el: $el,
                    id: $el.attr("value"),
                    text: $el.text(),
                });
            });

            // return
            return val;
        },

        mergeOptions: function () {},

        getChoices: function () {
            // callback
            var crawl = function ($parent) {
                // vars
                var choices = [];

                // loop
                $parent.children().each(function () {
                    // vars
                    var $child = $(this);

                    // optgroup
                    if ($child.is("optgroup")) {
                        choices.push({
                            text: $child.attr("label"),
                            children: crawl($child),
                        });

                        // option
                    } else {
                        choices.push({
                            id: $child.attr("value"),
                            text: $child.text(),
                        });
                    }
                });

                // return
                return choices;
            };

            // crawl
            return crawl(this.$el);
        },

        getAjaxData: function (params) {
            // vars
            var ajaxData = {
                action: this.get("ajaxAction"),
                s: params.term || "",
                paged: params.page || 1,
            };

            // field helper
            var field = this.get("field");
            if (field) {
                ajaxData.field_key = field.get("key");
            }

            // callback
            var callback = this.get("ajaxData");
            if (callback) {
                ajaxData = callback.apply(this, [ajaxData, params]);
            }

            // filter
            ajaxData = acf.applyFilters(
                "select2_ajax_data",
                ajaxData,
                this.data,
                this.$el,
                field || false,
                this
            );

            // return
            return acf.prepareForAjax(ajaxData);
        },

        getAjaxResults: function (json, params) {
            // defaults
            json = acf.parseArgs(json, {
                results: false,
                more: false,
            });

            // callback
            var callback = this.get("ajaxResults");
            if (callback) {
                json = callback.apply(this, [json, params]);
            }

            // filter
            json = acf.applyFilters("select2_ajax_results", json, params, this);

            // return
            return json;
        },

        processAjaxResults: function (json, params) {
            // vars
            var json = this.getAjaxResults(json, params);

            // change more to pagination
            if (json.more) {
                json.pagination = { more: true };
            }

            // merge together groups
            setTimeout($.proxy(this.mergeOptions, this), 1);

            // return
            return json;
        },

        destroy: function () {
            // destroy via api
            if (this.$el.data("select2")) {
                this.$el.select2("destroy");
            }

            // destory via HTML (duplicating HTML does not contain data)
            this.$el.siblings(".select2-container").remove();
        },
    });

    /**
     *  Select2_4
     *
     *  description
     *
     *  @date	13/1/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    var Select2_4 = Select2.extend({
        initialize: function () {
            // vars
            var $select = this.$el;
            var options = {
                width: "100%",
                allowClear: this.get("allowNull"),
                placeholder: this.get("placeholder"),
                multiple: this.get("multiple"),
                data: [],
                escapeMarkup: function (markup) {
                    if (typeof markup !== "string") {
                        return markup;
                    }
                    return acf.escHtml(markup);
                },
            };

            // Only use the template if SelectWoo is not loaded to work around https://github.com/woocommerce/woocommerce/pull/30473
            if (!acf.isset(window, "jQuery", "fn", "selectWoo")) {
                options.templateSelection = function (selection) {
                    var $selection = $('<span class="acf-selection"></span>');
                    $selection.html(acf.escHtml(selection.text));
                    $selection.data("element", selection.element);
                    return $selection;
                };
            }

            // multiple
            if (options.multiple) {
                // reorder options
                this.getValue().map(function (item) {
                    item.$el.detach().appendTo($select);
                });
            }

            // Temporarily remove conflicting attribute.
            var attrAjax = $select.attr("data-ajax");
            if (attrAjax !== undefined) {
                $select.removeData("ajax");
                $select.removeAttr("data-ajax");
            }

            // ajax
            if (this.get("ajax")) {
                options.ajax = {
                    url: acf.get("ajaxurl"),
                    delay: 250,
                    dataType: "json",
                    type: "post",
                    cache: false,
                    data: $.proxy(this.getAjaxData, this),
                    processResults: $.proxy(this.processAjaxResults, this),
                };
            }

            // filter for 3rd party customization
            //options = acf.applyFilters( 'select2_args', options, $select, this );
            var field = this.get("field");
            options = acf.applyFilters(
                "select2_args",
                options,
                $select,
                this.data,
                field || false,
                this
            );

            // add select2
            $select.select2(options);

            // get container (Select2 v4 does not return this from constructor)
            var $container = $select.next(".select2-container");

            // multiple
            if (options.multiple) {
                // vars
                var $ul = $container.find("ul");

                // sortable
                $ul.sortable({
                    stop: function (e) {
                        // loop
                        $ul.find(".select2-selection__choice").each(
                            function () {
                                // Attempt to use .data if it exists (select2 version < 4.0.6) or use our template data instead.
                                if ($(this).data("data")) {
                                    var $option = $(
                                        $(this).data("data").element
                                    );
                                } else {
                                    var $option = $(
                                        $(this)
                                            .children("span.acf-selection")
                                            .data("element")
                                    );
                                }

                                // detach and re-append to end
                                $option.detach().appendTo($select);
                            }
                        );

                        // trigger change on input (JS error if trigger on select)
                        $select.trigger("change");
                    },
                });

                // on select, move to end
                $select.on(
                    "select2:select",
                    this.proxy(function (e) {
                        this.getOption(e.params.data.id)
                            .detach()
                            .appendTo(this.$el);
                    })
                );
            }

            // add class
            $container.addClass("-acf");

            // Add back temporarily removed attr.
            if (attrAjax !== undefined) {
                $select.attr("data-ajax", attrAjax);
            }

            // action for 3rd party customization
            acf.doAction(
                "select2_init",
                $select,
                options,
                this.data,
                field || false,
                this
            );
        },

        mergeOptions: function () {
            // vars
            var $prevOptions = false;
            var $prevGroup = false;

            // loop
            $('.select2-results__option[role="group"]').each(function () {
                // vars
                var $options = $(this).children("ul");
                var $group = $(this).children("strong");

                // compare to previous
                if ($prevGroup && $prevGroup.text() === $group.text()) {
                    $prevOptions.append($options.children());
                    $(this).remove();
                    return;
                }

                // update vars
                $prevOptions = $options;
                $prevGroup = $group;
            });
        },
    });

    /**
     *  Select2_3
     *
     *  description
     *
     *  @date	13/1/18
     *  @since	5.6.5
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    var Select2_3 = Select2.extend({
        initialize: function () {
            // vars
            var $select = this.$el;
            var value = this.getValue();
            var multiple = this.get("multiple");
            var options = {
                width: "100%",
                allowClear: this.get("allowNull"),
                placeholder: this.get("placeholder"),
                separator: "||",
                multiple: this.get("multiple"),
                data: this.getChoices(),
                escapeMarkup: function (string) {
                    return acf.escHtml(string);
                },
                dropdownCss: {
                    "z-index": "999999999",
                },
                initSelection: function (element, callback) {
                    if (multiple) {
                        callback(value);
                    } else {
                        callback(value.shift());
                    }
                },
            };

            // get hidden input
            var $input = $select.siblings("input");
            if (!$input.length) {
                $input = $('<input type="hidden" />');
                $select.before($input);
            }

            // set input value
            inputValue = value
                .map(function (item) {
                    return item.id;
                })
                .join("||");
            $input.val(inputValue);

            // multiple
            if (options.multiple) {
                // reorder options
                value.map(function (item) {
                    item.$el.detach().appendTo($select);
                });
            }

            // remove blank option as we have a clear all button
            if (options.allowClear) {
                options.data = options.data.filter(function (item) {
                    return item.id !== "";
                });
            }

            // remove conflicting atts
            $select.removeData("ajax");
            $select.removeAttr("data-ajax");

            // ajax
            if (this.get("ajax")) {
                options.ajax = {
                    url: acf.get("ajaxurl"),
                    quietMillis: 250,
                    dataType: "json",
                    type: "post",
                    cache: false,
                    data: $.proxy(this.getAjaxData, this),
                    results: $.proxy(this.processAjaxResults, this),
                };
            }

            // filter for 3rd party customization
            var field = this.get("field");
            options = acf.applyFilters(
                "select2_args",
                options,
                $select,
                this.data,
                field || false,
                this
            );

            // add select2
            $input.select2(options);

            // get container
            var $container = $input.select2("container");

            // helper to find this select's option
            var getOption = $.proxy(this.getOption, this);

            // multiple
            if (options.multiple) {
                // vars
                var $ul = $container.find("ul");

                // sortable
                $ul.sortable({
                    stop: function () {
                        // loop
                        $ul.find(".select2-search-choice").each(function () {
                            // vars
                            var data = $(this).data("select2Data");
                            var $option = getOption(data.id);

                            // detach and re-append to end
                            $option.detach().appendTo($select);
                        });

                        // trigger change on input (JS error if trigger on select)
                        $select.trigger("change");
                    },
                });
            }

            // on select, create option and move to end
            $input.on("select2-selecting", function (e) {
                // vars
                var item = e.choice;
                var $option = getOption(item.id);

                // create if doesn't exist
                if (!$option.length) {
                    $option = $(
                        '<option value="' +
                            item.id +
                            '">' +
                            item.text +
                            "</option>"
                    );
                }

                // detach and re-append to end
                $option.detach().appendTo($select);
            });

            // add class
            $container.addClass("-acf");

            // action for 3rd party customization
            acf.doAction(
                "select2_init",
                $select,
                options,
                this.data,
                field || false,
                this
            );

            // change
            $input.on("change", function () {
                var val = $input.val();
                if (val.indexOf("||")) {
                    val = val.split("||");
                }
                $select.val(val).trigger("change");
            });

            // hide select
            $select.hide();
        },

        mergeOptions: function () {
            // vars
            var $prevOptions = false;
            var $prevGroup = false;

            // loop
            $("#select2-drop .select2-result-with-children").each(function () {
                // vars
                var $options = $(this).children("ul");
                var $group = $(this).children(".select2-result-label");

                // compare to previous
                if ($prevGroup && $prevGroup.text() === $group.text()) {
                    $prevGroup.append($options.children());
                    $(this).remove();
                    return;
                }

                // update vars
                $prevOptions = $options;
                $prevGroup = $group;
            });
        },

        getAjaxData: function (term, page) {
            // create Select2 v4 params
            var params = {
                term: term,
                page: page,
            };

            // return
            return Select2.prototype.getAjaxData.apply(this, [params]);
        },
    });

    // manager
    var select2Manager = new acf.Model({
        priority: 5,
        wait: "prepare",
        actions: {
            duplicate: "onDuplicate",
        },
        initialize: function () {
            // vars
            var locale = acf.get("locale");
            var rtl = acf.get("rtl");
            var l10n = acf.get("select2L10n");
            var version = getVersion();

            // bail ealry if no l10n
            if (!l10n) {
                return false;
            }

            // bail early if 'en'
            if (locale.indexOf("en") === 0) {
                return false;
            }

            // initialize
            if (version == 4) {
                this.addTranslations4();
            } else if (version == 3) {
                this.addTranslations3();
            }
        },

        addTranslations4: function () {
            // vars
            var l10n = acf.get("select2L10n");
            var locale = acf.get("locale");

            // modify local to match html[lang] attribute (used by Select2)
            locale = locale.replace("_", "-");

            // select2L10n
            var select2L10n = {
                errorLoading: function () {
                    return l10n.load_fail;
                },
                inputTooLong: function (args) {
                    var overChars = args.input.length - args.maximum;
                    if (overChars > 1) {
                        return l10n.input_too_long_n.replace("%d", overChars);
                    }
                    return l10n.input_too_long_1;
                },
                inputTooShort: function (args) {
                    var remainingChars = args.minimum - args.input.length;
                    if (remainingChars > 1) {
                        return l10n.input_too_short_n.replace(
                            "%d",
                            remainingChars
                        );
                    }
                    return l10n.input_too_short_1;
                },
                loadingMore: function () {
                    return l10n.load_more;
                },
                maximumSelected: function (args) {
                    var maximum = args.maximum;
                    if (maximum > 1) {
                        return l10n.selection_too_long_n.replace("%d", maximum);
                    }
                    return l10n.selection_too_long_1;
                },
                noResults: function () {
                    return l10n.matches_0;
                },
                searching: function () {
                    return l10n.searching;
                },
            };

            // append
            jQuery.fn.select2.amd.define(
                "select2/i18n/" + locale,
                [],
                function () {
                    return select2L10n;
                }
            );
        },

        addTranslations3: function () {
            // vars
            var l10n = acf.get("select2L10n");
            var locale = acf.get("locale");

            // modify local to match html[lang] attribute (used by Select2)
            locale = locale.replace("_", "-");

            // select2L10n
            var select2L10n = {
                formatMatches: function (matches) {
                    if (matches > 1) {
                        return l10n.matches_n.replace("%d", matches);
                    }
                    return l10n.matches_1;
                },
                formatNoMatches: function () {
                    return l10n.matches_0;
                },
                formatAjaxError: function () {
                    return l10n.load_fail;
                },
                formatInputTooShort: function (input, min) {
                    var remainingChars = min - input.length;
                    if (remainingChars > 1) {
                        return l10n.input_too_short_n.replace(
                            "%d",
                            remainingChars
                        );
                    }
                    return l10n.input_too_short_1;
                },
                formatInputTooLong: function (input, max) {
                    var overChars = input.length - max;
                    if (overChars > 1) {
                        return l10n.input_too_long_n.replace("%d", overChars);
                    }
                    return l10n.input_too_long_1;
                },
                formatSelectionTooBig: function (maximum) {
                    if (maximum > 1) {
                        return l10n.selection_too_long_n.replace("%d", maximum);
                    }
                    return l10n.selection_too_long_1;
                },
                formatLoadMore: function () {
                    return l10n.load_more;
                },
                formatSearching: function () {
                    return l10n.searching;
                },
            };

            // ensure locales exists
            $.fn.select2.locales = $.fn.select2.locales || {};

            // append
            $.fn.select2.locales[locale] = select2L10n;
            $.extend($.fn.select2.defaults, select2L10n);
        },

        onDuplicate: function ($el, $el2) {
            $el2.find(".select2-container").remove();
        },
    });
})(jQuery);
(function ($, undefined) {
    acf.tinymce = {
        /*
         *  defaults
         *
         *  This function will return default mce and qt settings
         *
         *  @type	function
         *  @date	18/8/17
         *  @since	5.6.0
         *
         *  @param	$post_id (int)
         *  @return	$post_id (int)
         */

        defaults: function () {
            // bail early if no tinyMCEPreInit
            if (typeof tinyMCEPreInit === "undefined") return false;

            // vars
            var defaults = {
                tinymce: tinyMCEPreInit.mceInit.acf_content,
                quicktags: tinyMCEPreInit.qtInit.acf_content,
            };

            // return
            return defaults;
        },

        /*
         *  initialize
         *
         *  This function will initialize the tinymce and quicktags instances
         *
         *  @type	function
         *  @date	18/8/17
         *  @since	5.6.0
         *
         *  @param	$post_id (int)
         *  @return	$post_id (int)
         */

        initialize: function (id, args) {
            // defaults
            args = acf.parseArgs(args, {
                tinymce: true,
                quicktags: true,
                toolbar: "full",
                mode: "visual", // visual,text
                field: false,
            });

            // tinymce
            if (args.tinymce) {
                this.initializeTinymce(id, args);
            }

            // quicktags
            if (args.quicktags) {
                this.initializeQuicktags(id, args);
            }
        },

        /*
         *  initializeTinymce
         *
         *  This function will initialize the tinymce instance
         *
         *  @type	function
         *  @date	18/8/17
         *  @since	5.6.0
         *
         *  @param	$post_id (int)
         *  @return	$post_id (int)
         */

        initializeTinymce: function (id, args) {
            // vars
            var $textarea = $("#" + id);
            var defaults = this.defaults();
            var toolbars = acf.get("toolbars");
            var field = args.field || false;
            var $field = field.$el || false;

            // bail early
            if (typeof tinymce === "undefined") return false;
            if (!defaults) return false;

            // check if exists
            if (tinymce.get(id)) {
                return this.enable(id);
            }

            // settings
            var init = $.extend({}, defaults.tinymce, args.tinymce);
            init.id = id;
            init.selector = "#" + id;

            // toolbar
            var toolbar = args.toolbar;
            if (toolbar && toolbars && toolbars[toolbar]) {
                for (var i = 1; i <= 4; i++) {
                    init["toolbar" + i] = toolbars[toolbar][i] || "";
                }
            }

            // event
            init.setup = function (ed) {
                ed.on("change", function (e) {
                    ed.save(); // save to textarea
                    $textarea.trigger("change");
                });

                // Fix bug where Gutenberg does not hear "mouseup" event and tries to select multiple blocks.
                ed.on("mouseup", function (e) {
                    var event = new MouseEvent("mouseup");
                    window.dispatchEvent(event);
                });

                // Temporarily comment out. May not be necessary due to wysiwyg field actions.
                //ed.on('unload', function(e) {
                //	acf.tinymce.remove( id );
                //});
            };

            // disable wp_autoresize_on (no solution yet for fixed toolbar)
            init.wp_autoresize_on = false;

            // Enable wpautop allowing value to save without <p> tags.
            // Only if the "TinyMCE Advanced" plugin hasn't already set this functionality.
            if (!init.tadv_noautop) {
                init.wpautop = true;
            }

            // hook for 3rd party customization
            init = acf.applyFilters(
                "wysiwyg_tinymce_settings",
                init,
                id,
                field
            );

            // z-index fix (caused too many conflicts)
            //if( acf.isset(tinymce,'ui','FloatPanel') ) {
            //	tinymce.ui.FloatPanel.zIndex = 900000;
            //}

            // store settings
            tinyMCEPreInit.mceInit[id] = init;

            // visual tab is active
            if (args.mode == "visual") {
                // init
                var result = tinymce.init(init);

                // get editor
                var ed = tinymce.get(id);

                // validate
                if (!ed) {
                    return false;
                }

                // add reference
                ed.acf = args.field;

                // action
                acf.doAction("wysiwyg_tinymce_init", ed, ed.id, init, field);
            }
        },

        /*
         *  initializeQuicktags
         *
         *  This function will initialize the quicktags instance
         *
         *  @type	function
         *  @date	18/8/17
         *  @since	5.6.0
         *
         *  @param	$post_id (int)
         *  @return	$post_id (int)
         */

        initializeQuicktags: function (id, args) {
            // vars
            var defaults = this.defaults();

            // bail early
            if (typeof quicktags === "undefined") return false;
            if (!defaults) return false;

            // settings
            var init = $.extend({}, defaults.quicktags, args.quicktags);
            init.id = id;

            // filter
            var field = args.field || false;
            var $field = field.$el || false;
            init = acf.applyFilters(
                "wysiwyg_quicktags_settings",
                init,
                init.id,
                field
            );

            // store settings
            tinyMCEPreInit.qtInit[id] = init;

            // init
            var ed = quicktags(init);

            // validate
            if (!ed) {
                return false;
            }

            // generate HTML
            this.buildQuicktags(ed);

            // action for 3rd party customization
            acf.doAction("wysiwyg_quicktags_init", ed, ed.id, init, field);
        },

        /*
         *  buildQuicktags
         *
         *  This function will build the quicktags HTML
         *
         *  @type	function
         *  @date	18/8/17
         *  @since	5.6.0
         *
         *  @param	$post_id (int)
         *  @return	$post_id (int)
         */

        buildQuicktags: function (ed) {
            var canvas,
                name,
                settings,
                theButtons,
                html,
                ed,
                id,
                i,
                use,
                instanceId,
                defaults =
                    ",strong,em,link,block,del,ins,img,ul,ol,li,code,more,close,";

            canvas = ed.canvas;
            name = ed.name;
            settings = ed.settings;
            html = "";
            theButtons = {};
            use = "";
            instanceId = ed.id;

            // set buttons
            if (settings.buttons) {
                use = "," + settings.buttons + ",";
            }

            for (i in edButtons) {
                if (!edButtons[i]) {
                    continue;
                }

                id = edButtons[i].id;
                if (
                    use &&
                    defaults.indexOf("," + id + ",") !== -1 &&
                    use.indexOf("," + id + ",") === -1
                ) {
                    continue;
                }

                if (
                    !edButtons[i].instance ||
                    edButtons[i].instance === instanceId
                ) {
                    theButtons[id] = edButtons[i];

                    if (edButtons[i].html) {
                        html += edButtons[i].html(name + "_");
                    }
                }
            }

            if (use && use.indexOf(",dfw,") !== -1) {
                theButtons.dfw = new QTags.DFWButton();
                html += theButtons.dfw.html(name + "_");
            }

            if ("rtl" === document.getElementsByTagName("html")[0].dir) {
                theButtons.textdirection = new QTags.TextDirectionButton();
                html += theButtons.textdirection.html(name + "_");
            }

            ed.toolbar.innerHTML = html;
            ed.theButtons = theButtons;

            if (typeof jQuery !== "undefined") {
                jQuery(document).triggerHandler("quicktags-init", [ed]);
            }
        },

        disable: function (id) {
            this.destroyTinymce(id);
        },

        remove: function (id) {
            this.destroyTinymce(id);
        },

        destroy: function (id) {
            this.destroyTinymce(id);
        },

        destroyTinymce: function (id) {
            // bail early
            if (typeof tinymce === "undefined") return false;

            // get editor
            var ed = tinymce.get(id);

            // bail early if no editor
            if (!ed) return false;

            // save
            ed.save();

            // destroy editor
            ed.destroy();

            // return
            return true;
        },

        enable: function (id) {
            this.enableTinymce(id);
        },

        enableTinymce: function (id) {
            // bail early
            if (typeof switchEditors === "undefined") return false;

            // bail ealry if not initialized
            if (typeof tinyMCEPreInit.mceInit[id] === "undefined") return false;

            // Ensure textarea element is visible
            // - Fixes bug in block editor when switching between "Block" and "Document" tabs.
            $("#" + id).show();

            // toggle
            switchEditors.go(id, "tmce");

            // return
            return true;
        },
    };

    var editorManager = new acf.Model({
        // hook in before fieldsEventManager, conditions, etc
        priority: 5,

        actions: {
            prepare: "onPrepare",
            ready: "onReady",
        },
        onPrepare: function () {
            // find hidden editor which may exist within a field
            var $div = $("#acf-hidden-wp-editor");

            // move to footer
            if ($div.exists()) {
                $div.appendTo("body");
            }
        },
        onReady: function () {
            // Restore wp.editor functions used by tinymce removed in WP5.
            if (acf.isset(window, "wp", "oldEditor")) {
                wp.editor.autop = wp.oldEditor.autop;
                wp.editor.removep = wp.oldEditor.removep;
            }

            // bail early if no tinymce
            if (!acf.isset(window, "tinymce", "on")) return;

            // restore default activeEditor
            tinymce.on("AddEditor", function (data) {
                // vars
                var editor = data.editor;

                // bail early if not 'acf'
                if (editor.id.substr(0, 3) !== "acf") return;

                // override if 'content' exists
                editor = tinymce.editors.content || editor;

                // update vars
                tinymce.activeEditor = editor;
                wpActiveEditor = editor.id;
            });
        },
    });
})(jQuery);
(function ($, undefined) {
    /**
     *  Validator
     *
     *  The model for validating forms
     *
     *  @date	4/9/18
     *  @since	5.7.5
     *
     *  @param	void
     *  @return	void
     */
    var Validator = acf.Model.extend({
        /** @var string The model identifier. */
        id: "Validator",

        /** @var object The model data. */
        data: {
            /** @var array The form errors. */
            errors: [],

            /** @var object The form notice. */
            notice: null,

            /** @var string The form status. loading, invalid, valid */
            status: "",
        },

        /** @var object The model events. */
        events: {
            "changed:status": "onChangeStatus",
        },

        /**
         *  addErrors
         *
         *  Adds errors to the form.
         *
         *  @date	4/9/18
         *  @since	5.7.5
         *
         *  @param	array errors An array of errors.
         *  @return	void
         */
        addErrors: function (errors) {
            errors.map(this.addError, this);
        },

        /**
         *  addError
         *
         *  Adds and error to the form.
         *
         *  @date	4/9/18
         *  @since	5.7.5
         *
         *  @param	object error An error object containing input and message.
         *  @return	void
         */
        addError: function (error) {
            this.data.errors.push(error);
        },

        /**
         *  hasErrors
         *
         *  Returns true if the form has errors.
         *
         *  @date	4/9/18
         *  @since	5.7.5
         *
         *  @param	void
         *  @return	bool
         */
        hasErrors: function () {
            return this.data.errors.length;
        },

        /**
         *  clearErrors
         *
         *  Removes any errors.
         *
         *  @date	4/9/18
         *  @since	5.7.5
         *
         *  @param	void
         *  @return	void
         */
        clearErrors: function () {
            return (this.data.errors = []);
        },

        /**
         *  getErrors
         *
         *  Returns the forms errors.
         *
         *  @date	4/9/18
         *  @since	5.7.5
         *
         *  @param	void
         *  @return	array
         */
        getErrors: function () {
            return this.data.errors;
        },

        /**
         *  getFieldErrors
         *
         *  Returns the forms field errors.
         *
         *  @date	4/9/18
         *  @since	5.7.5
         *
         *  @param	void
         *  @return	array
         */
        getFieldErrors: function () {
            // vars
            var errors = [];
            var inputs = [];

            // loop
            this.getErrors().map(function (error) {
                // bail early if global
                if (!error.input) return;

                // update if exists
                var i = inputs.indexOf(error.input);
                if (i > -1) {
                    errors[i] = error;

                    // update
                } else {
                    errors.push(error);
                    inputs.push(error.input);
                }
            });

            // return
            return errors;
        },

        /**
         *  getGlobalErrors
         *
         *  Returns the forms global errors (errors without a specific input).
         *
         *  @date	4/9/18
         *  @since	5.7.5
         *
         *  @param	void
         *  @return	array
         */
        getGlobalErrors: function () {
            // return array of errors that contain no input
            return this.getErrors().filter(function (error) {
                return !error.input;
            });
        },

        /**
         *  showErrors
         *
         *  Displays all errors for this form.
         *
         *  @date	4/9/18
         *  @since	5.7.5
         *
         *  @param	void
         *  @return	void
         */
        showErrors: function () {
            // bail early if no errors
            if (!this.hasErrors()) {
                return;
            }

            // vars
            var fieldErrors = this.getFieldErrors();
            var globalErrors = this.getGlobalErrors();

            // vars
            var errorCount = 0;
            var $scrollTo = false;

            // loop
            fieldErrors.map(function (error) {
                // get input
                var $input = this.$('[name="' + error.input + '"]').first();

                // if $_POST value was an array, this $input may not exist
                if (!$input.length) {
                    $input = this.$('[name^="' + error.input + '"]').first();
                }

                // bail early if input doesn't exist
                if (!$input.length) {
                    return;
                }

                // increase
                errorCount++;

                // get field
                var field = acf.getClosestField($input);

                // show error
                field.showError(error.message);

                // set $scrollTo
                if (!$scrollTo) {
                    $scrollTo = field.$el;
                }
            }, this);

            // errorMessage
            var errorMessage = acf.__("Validation failed");
            globalErrors.map(function (error) {
                errorMessage += ". " + error.message;
            });
            if (errorCount == 1) {
                errorMessage += ". " + acf.__("1 field requires attention");
            } else if (errorCount > 1) {
                errorMessage +=
                    ". " +
                    acf
                        .__("%d fields require attention")
                        .replace("%d", errorCount);
            }

            // notice
            if (this.has("notice")) {
                this.get("notice").update({
                    type: "error",
                    text: errorMessage,
                });
            } else {
                var notice = acf.newNotice({
                    type: "error",
                    text: errorMessage,
                    target: this.$el,
                });
                this.set("notice", notice);
            }

            // if no $scrollTo, set to message
            if (!$scrollTo) {
                $scrollTo = this.get("notice").$el;
            }

            // timeout
            setTimeout(function () {
                $("html, body").animate(
                    {
                        scrollTop:
                            $scrollTo.offset().top - $(window).height() / 2,
                    },
                    500
                );
            }, 10);
        },

        /**
         *  onChangeStatus
         *
         *  Update the form class when changing the 'status' data
         *
         *  @date	4/9/18
         *  @since	5.7.5
         *
         *  @param	object e The event object.
         *  @param	jQuery $el The form element.
         *  @param	string value The new status.
         *  @param	string prevValue The old status.
         *  @return	void
         */
        onChangeStatus: function (e, $el, value, prevValue) {
            this.$el.removeClass("is-" + prevValue).addClass("is-" + value);
        },

        /**
         *  validate
         *
         *  Vaildates the form via AJAX.
         *
         *  @date	4/9/18
         *  @since	5.7.5
         *
         *  @param	object args A list of settings to customize the validation process.
         *  @return	bool True if the form is valid.
         */
        validate: function (args) {
            // default args
            args = acf.parseArgs(args, {
                // trigger event
                event: false,

                // reset the form after submit
                reset: false,

                // loading callback
                loading: function () {},

                // complete callback
                complete: function () {},

                // failure callback
                failure: function () {},

                // success callback
                success: function ($form) {
                    $form.submit();
                },
            });

            // return true if is valid - allows form submit
            if (this.get("status") == "valid") {
                return true;
            }

            // return false if is currently validating - prevents form submit
            if (this.get("status") == "validating") {
                return false;
            }

            // return true if no ACF fields exist (no need to validate)
            if (!this.$(".acf-field").length) {
                return true;
            }

            // if event is provided, create a new success callback.
            if (args.event) {
                var event = $.Event(null, args.event);
                args.success = function () {
                    acf.enableSubmit($(event.target)).trigger(event);
                };
            }

            // action for 3rd party
            acf.doAction("validation_begin", this.$el);

            // lock form
            acf.lockForm(this.$el);

            // loading callback
            args.loading(this.$el, this);

            // update status
            this.set("status", "validating");

            // success callback
            var onSuccess = function (json) {
                // validate
                if (!acf.isAjaxSuccess(json)) {
                    return;
                }

                // filter
                var data = acf.applyFilters(
                    "validation_complete",
                    json.data,
                    this.$el,
                    this
                );

                // add errors
                if (!data.valid) {
                    this.addErrors(data.errors);
                }
            };

            // complete
            var onComplete = function () {
                // unlock form
                acf.unlockForm(this.$el);

                // failure
                if (this.hasErrors()) {
                    // update status
                    this.set("status", "invalid");

                    // action
                    acf.doAction("validation_failure", this.$el, this);

                    // display errors
                    this.showErrors();

                    // failure callback
                    args.failure(this.$el, this);

                    // success
                } else {
                    // update status
                    this.set("status", "valid");

                    // remove previous error message
                    if (this.has("notice")) {
                        this.get("notice").update({
                            type: "success",
                            text: acf.__("Validation successful"),
                            timeout: 1000,
                        });
                    }

                    // action
                    acf.doAction("validation_success", this.$el, this);
                    acf.doAction("submit", this.$el);

                    // success callback (submit form)
                    args.success(this.$el, this);

                    // lock form
                    acf.lockForm(this.$el);

                    // reset
                    if (args.reset) {
                        this.reset();
                    }
                }

                // complete callback
                args.complete(this.$el, this);

                // clear errors
                this.clearErrors();
            };

            // serialize form data
            var data = acf.serialize(this.$el);
            data.action = "acf/validate_save_post";

            // ajax
            $.ajax({
                url: acf.get("ajaxurl"),
                data: acf.prepareForAjax(data),
                type: "post",
                dataType: "json",
                context: this,
                success: onSuccess,
                complete: onComplete,
            });

            // return false to fail validation and allow AJAX
            return false;
        },

        /**
         *  setup
         *
         *  Called during the constructor function to setup this instance
         *
         *  @date	4/9/18
         *  @since	5.7.5
         *
         *  @param	jQuery $form The form element.
         *  @return	void
         */
        setup: function ($form) {
            // set $el
            this.$el = $form;
        },

        /**
         *  reset
         *
         *  Rests the validation to be used again.
         *
         *  @date	6/9/18
         *  @since	5.7.5
         *
         *  @param	void
         *  @return	void
         */
        reset: function () {
            // reset data
            this.set("errors", []);
            this.set("notice", null);
            this.set("status", "");

            // unlock form
            acf.unlockForm(this.$el);
        },
    });

    /**
     *  getValidator
     *
     *  Returns the instance for a given form element.
     *
     *  @date	4/9/18
     *  @since	5.7.5
     *
     *  @param	jQuery $el The form element.
     *  @return	object
     */
    var getValidator = function ($el) {
        // instantiate
        var validator = $el.data("acf");
        if (!validator) {
            validator = new Validator($el);
        }

        // return
        return validator;
    };

    /**
     *  acf.validateForm
     *
     *  A helper function for the Validator.validate() function.
     *  Returns true if form is valid, or fetches a validation request and returns false.
     *
     *  @date	4/4/18
     *  @since	5.6.9
     *
     *  @param	object args A list of settings to customize the validation process.
     *  @return	bool
     */

    acf.validateForm = function (args) {
        return getValidator(args.form).validate(args);
    };

    /**
     *  acf.enableSubmit
     *
     *  Enables a submit button and returns the element.
     *
     *  @date	30/8/18
     *  @since	5.7.4
     *
     *  @param	jQuery $submit The submit button.
     *  @return	jQuery
     */
    acf.enableSubmit = function ($submit) {
        return $submit.removeClass("disabled");
    };

    /**
     *  acf.disableSubmit
     *
     *  Disables a submit button and returns the element.
     *
     *  @date	30/8/18
     *  @since	5.7.4
     *
     *  @param	jQuery $submit The submit button.
     *  @return	jQuery
     */
    acf.disableSubmit = function ($submit) {
        return $submit.addClass("disabled");
    };

    /**
     *  acf.showSpinner
     *
     *  Shows the spinner element.
     *
     *  @date	4/9/18
     *  @since	5.7.5
     *
     *  @param	jQuery $spinner The spinner element.
     *  @return	jQuery
     */
    acf.showSpinner = function ($spinner) {
        $spinner.addClass("is-active"); // add class (WP > 4.2)
        $spinner.css("display", "inline-block"); // css (WP < 4.2)
        return $spinner;
    };

    /**
     *  acf.hideSpinner
     *
     *  Hides the spinner element.
     *
     *  @date	4/9/18
     *  @since	5.7.5
     *
     *  @param	jQuery $spinner The spinner element.
     *  @return	jQuery
     */
    acf.hideSpinner = function ($spinner) {
        $spinner.removeClass("is-active"); // add class (WP > 4.2)
        $spinner.css("display", "none"); // css (WP < 4.2)
        return $spinner;
    };

    /**
     *  acf.lockForm
     *
     *  Locks a form by disabeling its primary inputs and showing a spinner.
     *
     *  @date	4/9/18
     *  @since	5.7.5
     *
     *  @param	jQuery $form The form element.
     *  @return	jQuery
     */
    acf.lockForm = function ($form) {
        // vars
        var $wrap = findSubmitWrap($form);
        var $submit = $wrap.find('.button, [type="submit"]');
        var $spinner = $wrap.find(".spinner, .acf-spinner");

        // hide all spinners (hides the preview spinner)
        acf.hideSpinner($spinner);

        // lock
        acf.disableSubmit($submit);
        acf.showSpinner($spinner.last());
        return $form;
    };

    /**
     *  acf.unlockForm
     *
     *  Unlocks a form by enabeling its primary inputs and hiding all spinners.
     *
     *  @date	4/9/18
     *  @since	5.7.5
     *
     *  @param	jQuery $form The form element.
     *  @return	jQuery
     */
    acf.unlockForm = function ($form) {
        // vars
        var $wrap = findSubmitWrap($form);
        var $submit = $wrap.find('.button, [type="submit"]');
        var $spinner = $wrap.find(".spinner, .acf-spinner");

        // unlock
        acf.enableSubmit($submit);
        acf.hideSpinner($spinner);
        return $form;
    };

    /**
     *  findSubmitWrap
     *
     *  An internal function to find the 'primary' form submit wrapping element.
     *
     *  @date	4/9/18
     *  @since	5.7.5
     *
     *  @param	jQuery $form The form element.
     *  @return	jQuery
     */
    var findSubmitWrap = function ($form) {
        // default post submit div
        var $wrap = $form.find("#submitdiv");
        if ($wrap.length) {
            return $wrap;
        }

        // 3rd party publish box
        var $wrap = $form.find("#submitpost");
        if ($wrap.length) {
            return $wrap;
        }

        // term, user
        var $wrap = $form.find("p.submit").last();
        if ($wrap.length) {
            return $wrap;
        }

        // front end form
        var $wrap = $form.find(".acf-form-submit");
        if ($wrap.length) {
            return $wrap;
        }

        // default
        return $form;
    };

    /**
     * A debounced function to trigger a form submission.
     *
     * @date	15/07/2020
     * @since	5.9.0
     *
     * @param	type Var Description.
     * @return	type Description.
     */
    var submitFormDebounced = acf.debounce(function ($form) {
        $form.submit();
    });

    /**
     *  acf.validation
     *
     *  Global validation logic
     *
     *  @date	4/4/18
     *  @since	5.6.9
     *
     *  @param	void
     *  @return	void
     */

    acf.validation = new acf.Model({
        /** @var string The model identifier. */
        id: "validation",

        /** @var bool The active state. Set to false before 'prepare' to prevent validation. */
        active: true,

        /** @var string The model initialize time. */
        wait: "prepare",

        /** @var object The model actions. */
        actions: {
            ready: "addInputEvents",
            append: "addInputEvents",
        },

        /** @var object The model events. */
        events: {
            'click input[type="submit"]': "onClickSubmit",
            'click button[type="submit"]': "onClickSubmit",
            //'click #editor .editor-post-publish-button': 'onClickSubmitGutenberg',
            "click #save-post": "onClickSave",
            "submit form#post": "onSubmitPost",
            "submit form": "onSubmit",
        },

        /**
         *  initialize
         *
         *  Called when initializing the model.
         *
         *  @date	4/9/18
         *  @since	5.7.5
         *
         *  @param	void
         *  @return	void
         */
        initialize: function () {
            // check 'validation' setting
            if (!acf.get("validation")) {
                this.active = false;
                this.actions = {};
                this.events = {};
            }
        },

        /**
         *  enable
         *
         *  Enables validation.
         *
         *  @date	4/9/18
         *  @since	5.7.5
         *
         *  @param	void
         *  @return	void
         */
        enable: function () {
            this.active = true;
        },

        /**
         *  disable
         *
         *  Disables validation.
         *
         *  @date	4/9/18
         *  @since	5.7.5
         *
         *  @param	void
         *  @return	void
         */
        disable: function () {
            this.active = false;
        },

        /**
         *  reset
         *
         *  Rests the form validation to be used again
         *
         *  @date	6/9/18
         *  @since	5.7.5
         *
         *  @param	jQuery $form The form element.
         *  @return	void
         */
        reset: function ($form) {
            getValidator($form).reset();
        },

        /**
         *  addInputEvents
         *
         *  Adds 'invalid' event listeners to HTML inputs.
         *
         *  @date	4/9/18
         *  @since	5.7.5
         *
         *  @param	jQuery $el The element being added / readied.
         *  @return	void
         */
        addInputEvents: function ($el) {
            // Bug exists in Safari where custom "invalid" handeling prevents draft from saving.
            if (acf.get("browser") === "safari") return;

            // vars
            var $inputs = $(".acf-field [name]", $el);

            // check
            if ($inputs.length) {
                this.on($inputs, "invalid", "onInvalid");
            }
        },

        /**
         *  onInvalid
         *
         *  Callback for the 'invalid' event.
         *
         *  @date	4/9/18
         *  @since	5.7.5
         *
         *  @param	object e The event object.
         *  @param	jQuery $el The input element.
         *  @return	void
         */
        onInvalid: function (e, $el) {
            // prevent default
            // - prevents browser error message
            // - also fixes chrome bug where 'hidden-by-tab' field throws focus error
            e.preventDefault();

            // vars
            var $form = $el.closest("form");

            // check form exists
            if ($form.length) {
                // add error to validator
                getValidator($form).addError({
                    input: $el.attr("name"),
                    message: acf.strEscape(e.target.validationMessage),
                });

                // trigger submit on $form
                // - allows for "save", "preview" and "publish" to work
                submitFormDebounced($form);
            }
        },

        /**
         *  onClickSubmit
         *
         *  Callback when clicking submit.
         *
         *  @date	4/9/18
         *  @since	5.7.5
         *
         *  @param	object e The event object.
         *  @param	jQuery $el The input element.
         *  @return	void
         */
        onClickSubmit: function (e, $el) {
            // store the "click event" for later use in this.onSubmit()
            this.set("originalEvent", e);
        },

        /**
         *  onClickSave
         *
         *  Set ignore to true when saving a draft.
         *
         *  @date	4/9/18
         *  @since	5.7.5
         *
         *  @param	object e The event object.
         *  @param	jQuery $el The input element.
         *  @return	void
         */
        onClickSave: function (e, $el) {
            this.set("ignore", true);
        },

        /**
         *  onClickSubmitGutenberg
         *
         *  Custom validation event for the gutenberg editor.
         *
         *  @date	29/10/18
         *  @since	5.8.0
         *
         *  @param	object e The event object.
         *  @param	jQuery $el The input element.
         *  @return	void
         */
        onClickSubmitGutenberg: function (e, $el) {
            // validate
            var valid = acf.validateForm({
                form: $("#editor"),
                event: e,
                reset: true,
                failure: function ($form, validator) {
                    var $notice = validator.get("notice").$el;
                    $notice.appendTo(".components-notice-list");
                    $notice.find(".acf-notice-dismiss").removeClass("small");
                },
            });

            // if not valid, stop event and allow validation to continue
            if (!valid) {
                e.preventDefault();
                e.stopImmediatePropagation();
            }
        },

        /**
         * onSubmitPost
         *
         * Callback when the 'post' form is submit.
         *
         * @date	5/3/19
         * @since	5.7.13
         *
         * @param	object e The event object.
         * @param	jQuery $el The input element.
         * @return	void
         */
        onSubmitPost: function (e, $el) {
            // Check if is preview.
            if ($("input#wp-preview").val() === "dopreview") {
                // Ignore validation.
                this.set("ignore", true);

                // Unlock form to fix conflict with core "submit.edit-post" event causing all submit buttons to be disabled.
                acf.unlockForm($el);
            }
        },

        /**
         *  onSubmit
         *
         *  Callback when the form is submit.
         *
         *  @date	4/9/18
         *  @since	5.7.5
         *
         *  @param	object e The event object.
         *  @param	jQuery $el The input element.
         *  @return	void
         */
        onSubmit: function (e, $el) {
            // Allow form to submit if...
            if (
                // Validation has been disabled.
                !this.active ||
                // Or this event is to be ignored.
                this.get("ignore") ||
                // Or this event has already been prevented.
                e.isDefaultPrevented()
            ) {
                // Return early and call reset function.
                return this.allowSubmit();
            }

            // Validate form.
            var valid = acf.validateForm({
                form: $el,
                event: this.get("originalEvent"),
            });

            // If not valid, stop event to prevent form submit.
            if (!valid) {
                e.preventDefault();
            }
        },

        /**
         * allowSubmit
         *
         * Resets data during onSubmit when the form is allowed to submit.
         *
         * @date	5/3/19
         * @since	5.7.13
         *
         * @param	void
         * @return	void
         */
        allowSubmit: function () {
            // Reset "ignore" state.
            this.set("ignore", false);

            // Reset "originalEvent" object.
            this.set("originalEvent", false);

            // Return true
            return true;
        },
    });

    var gutenbergValidation = new acf.Model({
        wait: "prepare",
        initialize: function () {
            // Bail early if not Gutenberg.
            if (!acf.isGutenberg()) {
                return;
            }

            // Custommize the editor.
            this.customizeEditor();
        },
        customizeEditor: function () {
            // Extract vars.
            var editor = wp.data.dispatch("core/editor");
            var editorSelect = wp.data.select("core/editor");
            var notices = wp.data.dispatch("core/notices");

            // Backup original method.
            var savePost = editor.savePost;

            // Listen for changes to post status and perform actions:
            // a) Enable validation for "publish" action.
            // b) Remember last non "publish" status used for restoring after validation fail.
            var useValidation = false;
            var lastPostStatus = "";
            wp.data.subscribe(function () {
                var postStatus = editorSelect.getEditedPostAttribute("status");
                useValidation =
                    postStatus === "publish" || postStatus === "future";
                lastPostStatus =
                    postStatus !== "publish" ? postStatus : lastPostStatus;
            });

            // Create validation version.
            editor.savePost = function (options) {
                options = options || {};

                // Backup vars.
                var _this = this;
                var _args = arguments;

                // Perform validation within a Promise.
                return new Promise(function (resolve, reject) {
                    // Bail early if is autosave or preview.
                    if (options.isAutosave || options.isPreview) {
                        return resolve("Validation ignored (autosave).");
                    }

                    // Bail early if validation is not needed.
                    if (!useValidation) {
                        return resolve("Validation ignored (draft).");
                    }

                    // Validate the editor form.
                    var valid = acf.validateForm({
                        form: $("#editor"),
                        reset: true,
                        complete: function ($form, validator) {
                            // Always unlock the form after AJAX.
                            editor.unlockPostSaving("acf");
                        },
                        failure: function ($form, validator) {
                            // Get validation error and append to Gutenberg notices.
                            var notice = validator.get("notice");
                            notices.createErrorNotice(notice.get("text"), {
                                id: "acf-validation",
                                isDismissible: true,
                            });
                            notice.remove();

                            // Restore last non "publish" status.
                            if (lastPostStatus) {
                                editor.editPost({
                                    status: lastPostStatus,
                                });
                            }

                            // Rejext promise and prevent savePost().
                            reject("Validation failed.");
                        },
                        success: function () {
                            notices.removeNotice("acf-validation");

                            // Resolve promise and allow savePost().
                            resolve("Validation success.");
                        },
                    });

                    // Resolve promise and allow savePost() if no validation is needed.
                    if (valid) {
                        resolve("Validation bypassed.");

                        // Otherwise, lock the form and wait for AJAX response.
                    } else {
                        editor.lockPostSaving("acf");
                    }
                })
                    .then(function () {
                        return savePost.apply(_this, _args);
                    })
                    .catch(function (err) {
                        // Nothing to do here, user is alerted of validation issues.
                    });
            };
        },
    });
})(jQuery);
(function ($, undefined) {
    /**
     *  refreshHelper
     *
     *  description
     *
     *  @date	1/7/18
     *  @since	5.6.9
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    var refreshHelper = new acf.Model({
        priority: 90,
        actions: {
            new_field: "refresh",
            show_field: "refresh",
            hide_field: "refresh",
            remove_field: "refresh",
            unmount_field: "refresh",
            remount_field: "refresh",
        },
        refresh: function () {
            acf.refresh();
        },
    });

    /**
     * mountHelper
     *
     * Adds compatiblity for the 'unmount' and 'remount' actions added in 5.8.0
     *
     * @date	7/3/19
     * @since	5.7.14
     *
     * @param	void
     * @return	void
     */
    var mountHelper = new acf.Model({
        priority: 1,
        actions: {
            sortstart: "onSortstart",
            sortstop: "onSortstop",
        },
        onSortstart: function ($item) {
            acf.doAction("unmount", $item);
        },
        onSortstop: function ($item) {
            acf.doAction("remount", $item);
        },
    });

    /**
     *  sortableHelper
     *
     *  Adds compatibility for sorting a <tr> element
     *
     *  @date	6/3/18
     *  @since	5.6.9
     *
     *  @param	void
     *  @return	void
     */

    var sortableHelper = new acf.Model({
        actions: {
            sortstart: "onSortstart",
        },
        onSortstart: function ($item, $placeholder) {
            // if $item is a tr, apply some css to the elements
            if ($item.is("tr")) {
                // replace $placeholder children with a single td
                // fixes "width calculation issues" due to conditional logic hiding some children
                $placeholder.html(
                    '<td style="padding:0;" colspan="' +
                        $placeholder.children().length +
                        '"></td>'
                );

                // add helper class to remove absolute positioning
                $item.addClass("acf-sortable-tr-helper");

                // set fixed widths for children
                $item.children().each(function () {
                    $(this).width($(this).width());
                });

                // mimic height
                $placeholder.height($item.height() + "px");

                // remove class
                $item.removeClass("acf-sortable-tr-helper");
            }
        },
    });

    /**
     *  duplicateHelper
     *
     *  Fixes browser bugs when duplicating an element
     *
     *  @date	6/3/18
     *  @since	5.6.9
     *
     *  @param	void
     *  @return	void
     */

    var duplicateHelper = new acf.Model({
        actions: {
            after_duplicate: "onAfterDuplicate",
        },
        onAfterDuplicate: function ($el, $el2) {
            // get original values
            var vals = [];
            $el.find("select").each(function (i) {
                vals.push($(this).val());
            });

            // set duplicate values
            $el2.find("select").each(function (i) {
                $(this).val(vals[i]);
            });
        },
    });

    /**
     *  tableHelper
     *
     *  description
     *
     *  @date	6/3/18
     *  @since	5.6.9
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    var tableHelper = new acf.Model({
        id: "tableHelper",

        priority: 20,

        actions: {
            refresh: "renderTables",
        },

        renderTables: function ($el) {
            // loop
            var self = this;
            $(".acf-table:visible").each(function () {
                self.renderTable($(this));
            });
        },

        renderTable: function ($table) {
            // vars
            var $ths = $table.find("> thead > tr:visible > th[data-key]");
            var $tds = $table.find("> tbody > tr:visible > td[data-key]");

            // bail early if no thead
            if (!$ths.length || !$tds.length) {
                return false;
            }

            // visiblity
            $ths.each(function (i) {
                // vars
                var $th = $(this);
                var key = $th.data("key");
                var $cells = $tds.filter('[data-key="' + key + '"]');
                var $hidden = $cells.filter(".acf-hidden");

                // always remove empty and allow cells to be hidden
                $cells.removeClass("acf-empty");

                // hide $th if all cells are hidden
                if ($cells.length === $hidden.length) {
                    acf.hide($th);

                    // force all hidden cells to appear empty
                } else {
                    acf.show($th);
                    $hidden.addClass("acf-empty");
                }
            });

            // clear width
            $ths.css("width", "auto");

            // get visible
            $ths = $ths.not(".acf-hidden");

            // vars
            var availableWidth = 100;
            var colspan = $ths.length;

            // set custom widths first
            var $fixedWidths = $ths.filter("[data-width]");
            $fixedWidths.each(function () {
                var width = $(this).data("width");
                $(this).css("width", width + "%");
                availableWidth -= width;
            });

            // set auto widths
            var $auoWidths = $ths.not("[data-width]");
            if ($auoWidths.length) {
                var width = availableWidth / $auoWidths.length;
                $auoWidths.css("width", width + "%");
                availableWidth = 0;
            }

            // avoid stretching issue
            if (availableWidth > 0) {
                $ths.last().css("width", "auto");
            }

            // update colspan on collapsed
            $tds.filter(".-collapsed-target").each(function () {
                // vars
                var $td = $(this);

                // check if collapsed
                if ($td.parent().hasClass("-collapsed")) {
                    $td.attr("colspan", $ths.length);
                } else {
                    $td.removeAttr("colspan");
                }
            });
        },
    });

    /**
     *  fieldsHelper
     *
     *  description
     *
     *  @date	6/3/18
     *  @since	5.6.9
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    var fieldsHelper = new acf.Model({
        id: "fieldsHelper",

        priority: 30,

        actions: {
            refresh: "renderGroups",
        },

        renderGroups: function () {
            // loop
            var self = this;
            $(".acf-fields:visible").each(function () {
                self.renderGroup($(this));
            });
        },

        renderGroup: function ($el) {
            // vars
            var top = 0;
            var height = 0;
            var $row = $();

            // get fields
            var $fields = $el.children(".acf-field[data-width]:visible");

            // bail early if no fields
            if (!$fields.length) {
                return false;
            }

            // bail ealry if is .-left
            if ($el.hasClass("-left")) {
                $fields.removeAttr("data-width");
                $fields.css("width", "auto");
                return false;
            }

            // reset fields
            $fields.removeClass("-r0 -c0").css({ "min-height": 0 });

            // loop
            $fields.each(function (i) {
                // vars
                var $field = $(this);
                var position = $field.position();
                var thisTop = Math.ceil(position.top);
                var thisLeft = Math.ceil(position.left);

                // detect change in row
                if ($row.length && thisTop > top) {
                    // set previous heights
                    $row.css({ "min-height": height + "px" });

                    // update position due to change in row above
                    position = $field.position();
                    thisTop = Math.ceil(position.top);
                    thisLeft = Math.ceil(position.left);

                    // reset vars
                    top = 0;
                    height = 0;
                    $row = $();
                }

                // rtl
                if (acf.get("rtl")) {
                    thisLeft = Math.ceil(
                        $field.parent().width() -
                            (position.left + $field.outerWidth())
                    );
                }

                // add classes
                if (thisTop == 0) {
                    $field.addClass("-r0");
                } else if (thisLeft == 0) {
                    $field.addClass("-c0");
                }

                // get height after class change
                // - add 1 for subpixel rendering
                var thisHeight = Math.ceil($field.outerHeight()) + 1;

                // set height
                height = Math.max(height, thisHeight);

                // set y
                top = Math.max(top, thisTop);

                // append
                $row = $row.add($field);
            });

            // clean up
            if ($row.length) {
                $row.css({ "min-height": height + "px" });
            }
        },
    });

    /**
     * Adds a body class when holding down the "shift" key.
     *
     * @date	06/05/2020
     * @since	5.9.0
     */
    var bodyClassShiftHelper = new acf.Model({
        id: "bodyClassShiftHelper",
        events: {
            keydown: "onKeyDown",
            keyup: "onKeyUp",
        },
        isShiftKey: function (e) {
            return e.keyCode === 16;
        },
        onKeyDown: function (e) {
            if (this.isShiftKey(e)) {
                $("body").addClass("acf-keydown-shift");
            }
        },
        onKeyUp: function (e) {
            if (this.isShiftKey(e)) {
                $("body").removeClass("acf-keydown-shift");
            }
        },
    });
})(jQuery);
(function ($, undefined) {
    /**
     *  acf.newCompatibility
     *
     *  Inserts a new __proto__ object compatibility layer
     *
     *  @date	15/2/18
     *  @since	5.6.9
     *
     *  @param	object instance The object to modify.
     *  @param	object compatibilty Optional. The compatibilty layer.
     *  @return	object compatibilty
     */

    acf.newCompatibility = function (instance, compatibilty) {
        // defaults
        compatibilty = compatibilty || {};

        // inherit __proto_-
        compatibilty.__proto__ = instance.__proto__;

        // inject
        instance.__proto__ = compatibilty;

        // reference
        instance.compatibility = compatibilty;

        // return
        return compatibilty;
    };

    /**
     *  acf.getCompatibility
     *
     *  Returns the compatibility layer for a given instance
     *
     *  @date	13/3/18
     *  @since	5.6.9
     *
     *  @param	object		instance		The object to look in.
     *  @return	object|null	compatibility	The compatibility object or null on failure.
     */

    acf.getCompatibility = function (instance) {
        return instance.compatibility || null;
    };

    /**
     *  acf (compatibility)
     *
     *  Compatibility layer for the acf object
     *
     *  @date	15/2/18
     *  @since	5.6.9
     *
     *  @param	void
     *  @return	void
     */

    var _acf = acf.newCompatibility(acf, {
        // storage
        l10n: {},
        o: {},
        fields: {},

        // changed function names
        update: acf.set,
        add_action: acf.addAction,
        remove_action: acf.removeAction,
        do_action: acf.doAction,
        add_filter: acf.addFilter,
        remove_filter: acf.removeFilter,
        apply_filters: acf.applyFilters,
        parse_args: acf.parseArgs,
        disable_el: acf.disable,
        disable_form: acf.disable,
        enable_el: acf.enable,
        enable_form: acf.enable,
        update_user_setting: acf.updateUserSetting,
        prepare_for_ajax: acf.prepareForAjax,
        is_ajax_success: acf.isAjaxSuccess,
        remove_el: acf.remove,
        remove_tr: acf.remove,
        str_replace: acf.strReplace,
        render_select: acf.renderSelect,
        get_uniqid: acf.uniqid,
        serialize_form: acf.serialize,
        esc_html: acf.strEscape,
        str_sanitize: acf.strSanitize,
    });

    _acf._e = function (k1, k2) {
        // defaults
        k1 = k1 || "";
        k2 = k2 || "";

        // compability
        var compatKey = k2 ? k1 + "." + k2 : k1;
        var compats = {
            "image.select": "Select Image",
            "image.edit": "Edit Image",
            "image.update": "Update Image",
        };
        if (compats[compatKey]) {
            return acf.__(compats[compatKey]);
        }

        // try k1
        var string = this.l10n[k1] || "";

        // try k2
        if (k2) {
            string = string[k2] || "";
        }

        // return
        return string;
    };

    _acf.get_selector = function (s) {
        // vars
        var selector = ".acf-field";

        // bail early if no search
        if (!s) {
            return selector;
        }

        // compatibility with object
        if ($.isPlainObject(s)) {
            if ($.isEmptyObject(s)) {
                return selector;
            } else {
                for (var k in s) {
                    s = s[k];
                    break;
                }
            }
        }

        // append
        selector += "-" + s;

        // replace underscores (split/join replaces all and is faster than regex!)
        selector = acf.strReplace("_", "-", selector);

        // remove potential double up
        selector = acf.strReplace("field-field-", "field-", selector);

        // return
        return selector;
    };

    _acf.get_fields = function (s, $el, all) {
        // args
        var args = {
            is: s || "",
            parent: $el || false,
            suppressFilters: all || false,
        };

        // change 'field_123' to '.acf-field-123'
        if (args.is) {
            args.is = this.get_selector(args.is);
        }

        // return
        return acf.findFields(args);
    };

    _acf.get_field = function (s, $el) {
        // get fields
        var $fields = this.get_fields.apply(this, arguments);

        // return
        if ($fields.length) {
            return $fields.first();
        } else {
            return false;
        }
    };

    _acf.get_closest_field = function ($el, s) {
        return $el.closest(this.get_selector(s));
    };

    _acf.get_field_wrap = function ($el) {
        return $el.closest(this.get_selector());
    };

    _acf.get_field_key = function ($field) {
        return $field.data("key");
    };

    _acf.get_field_type = function ($field) {
        return $field.data("type");
    };

    _acf.get_data = function ($el, defaults) {
        return acf.parseArgs($el.data(), defaults);
    };

    _acf.maybe_get = function (obj, key, value) {
        // default
        if (value === undefined) {
            value = null;
        }

        // get keys
        keys = String(key).split(".");

        // acf.isget
        for (var i = 0; i < keys.length; i++) {
            if (!obj.hasOwnProperty(keys[i])) {
                return value;
            }
            obj = obj[keys[i]];
        }
        return obj;
    };

    /**
     *  hooks
     *
     *  Modify add_action and add_filter functions to add compatibility with changed $field parameter
     *  Using the acf.add_action() or acf.add_filter() functions will interpret new field parameters as jQuery $field
     *
     *  @date	12/5/18
     *  @since	5.6.9
     *
     *  @param	void
     *  @return	void
     */

    var compatibleArgument = function (arg) {
        return arg instanceof acf.Field ? arg.$el : arg;
    };

    var compatibleArguments = function (args) {
        return acf.arrayArgs(args).map(compatibleArgument);
    };

    var compatibleCallback = function (origCallback) {
        return function () {
            // convert to compatible arguments
            if (arguments.length) {
                var args = compatibleArguments(arguments);

                // add default argument for 'ready', 'append' and 'load' events
            } else {
                var args = [$(document)];
            }

            // return
            return origCallback.apply(this, args);
        };
    };

    _acf.add_action = function (action, callback, priority, context) {
        // handle multiple actions
        var actions = action.split(" ");
        var length = actions.length;
        if (length > 1) {
            for (var i = 0; i < length; i++) {
                action = actions[i];
                _acf.add_action.apply(this, arguments);
            }
            return this;
        }

        // single
        var callback = compatibleCallback(callback);
        return acf.addAction.apply(this, arguments);
    };

    _acf.add_filter = function (action, callback, priority, context) {
        var callback = compatibleCallback(callback);
        return acf.addFilter.apply(this, arguments);
    };

    /*
     *  acf.model
     *
     *  This model acts as a scafold for action.event driven modules
     *
     *  @type	object
     *  @date	8/09/2014
     *  @since	5.0.0
     *
     *  @param	(object)
     *  @return	(object)
     */

    _acf.model = {
        actions: {},
        filters: {},
        events: {},
        extend: function (args) {
            // extend
            var model = $.extend({}, this, args);

            // setup actions
            $.each(model.actions, function (name, callback) {
                model._add_action(name, callback);
            });

            // setup filters
            $.each(model.filters, function (name, callback) {
                model._add_filter(name, callback);
            });

            // setup events
            $.each(model.events, function (name, callback) {
                model._add_event(name, callback);
            });

            // return
            return model;
        },

        _add_action: function (name, callback) {
            // split
            var model = this,
                data = name.split(" ");

            // add missing priority
            var name = data[0] || "",
                priority = data[1] || 10;

            // add action
            acf.add_action(name, model[callback], priority, model);
        },

        _add_filter: function (name, callback) {
            // split
            var model = this,
                data = name.split(" ");

            // add missing priority
            var name = data[0] || "",
                priority = data[1] || 10;

            // add action
            acf.add_filter(name, model[callback], priority, model);
        },

        _add_event: function (name, callback) {
            // vars
            var model = this,
                i = name.indexOf(" "),
                event = i > 0 ? name.substr(0, i) : name,
                selector = i > 0 ? name.substr(i + 1) : "";

            // event
            var fn = function (e) {
                // append $el to event object
                e.$el = $(this);

                // append $field to event object (used in field group)
                if (acf.field_group) {
                    e.$field = e.$el.closest(".acf-field-object");
                }

                // event
                if (typeof model.event === "function") {
                    e = model.event(e);
                }

                // callback
                model[callback].apply(model, arguments);
            };

            // add event
            if (selector) {
                $(document).on(event, selector, fn);
            } else {
                $(document).on(event, fn);
            }
        },

        get: function (name, value) {
            // defaults
            value = value || null;

            // get
            if (typeof this[name] !== "undefined") {
                value = this[name];
            }

            // return
            return value;
        },

        set: function (name, value) {
            // set
            this[name] = value;

            // function for 3rd party
            if (typeof this["_set_" + name] === "function") {
                this["_set_" + name].apply(this);
            }

            // return for chaining
            return this;
        },
    };

    /*
     *  field
     *
     *  This model sets up many of the field's interactions
     *
     *  @type	function
     *  @date	21/02/2014
     *  @since	3.5.1
     *
     *  @param	n/a
     *  @return	n/a
     */

    _acf.field = acf.model.extend({
        type: "",
        o: {},
        $field: null,
        _add_action: function (name, callback) {
            // vars
            var model = this;

            // update name
            name = name + "_field/type=" + model.type;

            // add action
            acf.add_action(name, function ($field) {
                // focus
                model.set("$field", $field);

                // callback
                model[callback].apply(model, arguments);
            });
        },

        _add_filter: function (name, callback) {
            // vars
            var model = this;

            // update name
            name = name + "_field/type=" + model.type;

            // add action
            acf.add_filter(name, function ($field) {
                // focus
                model.set("$field", $field);

                // callback
                model[callback].apply(model, arguments);
            });
        },

        _add_event: function (name, callback) {
            // vars
            var model = this,
                event = name.substr(0, name.indexOf(" ")),
                selector = name.substr(name.indexOf(" ") + 1),
                context = acf.get_selector(model.type);

            // add event
            $(document).on(event, context + " " + selector, function (e) {
                // vars
                var $el = $(this);
                var $field = acf.get_closest_field($el, model.type);

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

                // focus
                if (!$field.is(model.$field)) {
                    model.set("$field", $field);
                }

                // append to event
                e.$el = $el;
                e.$field = $field;

                // callback
                model[callback].apply(model, [e]);
            });
        },

        _set_$field: function () {
            // callback
            if (typeof this.focus === "function") {
                this.focus();
            }
        },

        // depreciated
        doFocus: function ($field) {
            return this.set("$field", $field);
        },
    });

    /**
     *  validation
     *
     *  description
     *
     *  @date	15/2/18
     *  @since	5.6.9
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    var _validation = acf.newCompatibility(acf.validation, {
        remove_error: function ($field) {
            acf.getField($field).removeError();
        },
        add_warning: function ($field, message) {
            acf.getField($field).showNotice({
                text: message,
                type: "warning",
                timeout: 1000,
            });
        },
        fetch: acf.validateForm,
        enableSubmit: acf.enableSubmit,
        disableSubmit: acf.disableSubmit,
        showSpinner: acf.showSpinner,
        hideSpinner: acf.hideSpinner,
        unlockForm: acf.unlockForm,
        lockForm: acf.lockForm,
    });

    /**
     *  tooltip
     *
     *  description
     *
     *  @date	15/2/18
     *  @since	5.6.9
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    _acf.tooltip = {
        tooltip: function (text, $el) {
            var tooltip = acf.newTooltip({
                text: text,
                target: $el,
            });

            // return
            return tooltip.$el;
        },

        temp: function (text, $el) {
            var tooltip = acf.newTooltip({
                text: text,
                target: $el,
                timeout: 250,
            });
        },

        confirm: function ($el, callback, text, button_y, button_n) {
            var tooltip = acf.newTooltip({
                confirm: true,
                text: text,
                target: $el,
                confirm: function () {
                    callback(true);
                },
                cancel: function () {
                    callback(false);
                },
            });
        },

        confirm_remove: function ($el, callback) {
            var tooltip = acf.newTooltip({
                confirmRemove: true,
                target: $el,
                confirm: function () {
                    callback(true);
                },
                cancel: function () {
                    callback(false);
                },
            });
        },
    };

    /**
     *  tooltip
     *
     *  description
     *
     *  @date	15/2/18
     *  @since	5.6.9
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    _acf.media = new acf.Model({
        activeFrame: false,
        actions: {
            new_media_popup: "onNewMediaPopup",
        },

        frame: function () {
            return this.activeFrame;
        },

        onNewMediaPopup: function (popup) {
            this.activeFrame = popup.frame;
        },

        popup: function (props) {
            // update props
            if (props.mime_types) {
                props.allowedTypes = props.mime_types;
            }
            if (props.id) {
                props.attachment = props.id;
            }

            // new
            var popup = acf.newMediaPopup(props);

            // append
            /*
			if( props.selected ) {
				popup.selected = props.selected;
			}
*/

            // return
            return popup.frame;
        },
    });

    /**
     *  Select2
     *
     *  description
     *
     *  @date	11/6/18
     *  @since	5.6.9
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    _acf.select2 = {
        init: function ($select, args, $field) {
            // compatible args
            if (args.allow_null) {
                args.allowNull = args.allow_null;
            }
            if (args.ajax_action) {
                args.ajaxAction = args.ajax_action;
            }
            if ($field) {
                args.field = acf.getField($field);
            }

            // return
            return acf.newSelect2($select, args);
        },

        destroy: function ($select) {
            return acf.getInstance($select).destroy();
        },
    };

    /**
     *  postbox
     *
     *  description
     *
     *  @date	11/6/18
     *  @since	5.6.9
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    _acf.postbox = {
        render: function (args) {
            // compatible args
            if (args.edit_url) {
                args.editLink = args.edit_url;
            }
            if (args.edit_title) {
                args.editTitle = args.edit_title;
            }

            // return
            return acf.newPostbox(args);
        },
    };

    /**
     *  acf.screen
     *
     *  description
     *
     *  @date	11/6/18
     *  @since	5.6.9
     *
     *  @param	type $var Description. Default.
     *  @return	type Description.
     */

    acf.newCompatibility(acf.screen, {
        update: function () {
            return this.set.apply(this, arguments);
        },
        fetch: acf.screen.check,
    });
    _acf.ajax = acf.screen;
})(jQuery);