Sync plugins from current page

Signed-off-by: Adrian Nöthlich <git@promasu.tech>

wp-content/plugins/advanced-custom-fields/README.md

@@ -0,0 +1,25 @@
+# Advanced Custom Fields
+
+Welcome to the official Advanced Custom Fields repository on GitHub. ACF is a WordPress plugin used to take full control of your edit screens & custom field data.
+
+Looking for ACF version 4? Please use the [previous ACF repository](https://github.com/elliotcondon/acf).
+
+Upgrading from ACF version 4? Please read our [Upgrading from v4 to v5 guide](https://www.advancedcustomfields.com/resources/upgrading-v4-v5/).
+
+## Documentation
+
+Do you need help getting started with ACF, or do you have questions about one of the ACF features? You can [search through our documentation here](https://www.advancedcustomfields.com/resources). If you don't find the answers you're looking for, you can [submit a support ticket](https://support.advancedcustomfields.com/new-ticket/) or start a new forum thread in the [support forum](https://support.advancedcustomfields.com/).
+
+## Support
+
+This repository is not suitable for support. Please don't use our issue tracker for support requests, but for core issues only. 
+Support can take place in the appropriate channels:
+
+* Email based ticket system 
+* Community forum
+
+These channels can be accessed from our [support website](https://support.advancedcustomfields.com/).
+
+## Contributing
+
+If you have a patch, or stumbled upon an issue with ACF core, you can contribute this back to the code. Please create a new github issue with as much information as possible.

wp-content/plugins/advanced-custom-fields/acf.php

@@ -0,0 +1,680 @@
+<?php
+/*
+Plugin Name: Advanced Custom Fields
+Plugin URI: https://www.advancedcustomfields.com
+Description: Customize WordPress with powerful, professional and intuitive fields.
+Version: 5.8.3
+Author: Elliot Condon
+Author URI: https://www.advancedcustomfields.com
+Text Domain: acf
+Domain Path: /lang
+*/
+
+if( ! defined( 'ABSPATH' ) ) exit; // Exit if accessed directly
+
+if( ! class_exists('ACF') ) :
+
+class ACF {
+	
+	/** @var string The plugin version number */
+	var $version = '5.8.3';
+	
+	/** @var array The plugin settings array */
+	var $settings = array();
+	
+	/** @var array The plugin data array */
+	var $data = array();
+	
+	/** @var array Storage for class instances */
+	var $instances = array();
+	
+	
+	/*
+	*  __construct
+	*
+	*  A dummy constructor to ensure ACF is only initialized once
+	*
+	*  @type	function
+	*  @date	23/06/12
+	*  @since	5.0.0
+	*
+	*  @param	N/A
+	*  @return	N/A
+	*/
+	
+	function __construct() {
+		
+		/* Do nothing here */
+		
+	}
+	
+	
+	/*
+	*  initialize
+	*
+	*  The real constructor to initialize ACF
+	*
+	*  @type	function
+	*  @date	28/09/13
+	*  @since	5.0.0
+	*
+	*  @param	$post_id (int)
+	*  @return	$post_id (int)
+	*/
+		
+	function initialize() {
+		
+		// vars
+		$version = $this->version;
+		$basename = plugin_basename( __FILE__ );
+		$path = plugin_dir_path( __FILE__ );
+		$url = plugin_dir_url( __FILE__ );
+		$slug = dirname($basename);
+		
+		
+		// settings
+		$this->settings = array(
+			
+			// basic
+			'name'				=> __('Advanced Custom Fields', 'acf'),
+			'version'			=> $version,
+						
+			// urls
+			'file'				=> __FILE__,
+			'basename'			=> $basename,
+			'path'				=> $path,
+			'url'				=> $url,
+			'slug'				=> $slug,
+			
+			// options
+			'show_admin'				=> true,
+			'show_updates'				=> true,
+			'stripslashes'				=> false,
+			'local'						=> true,
+			'json'						=> true,
+			'save_json'					=> '',
+			'load_json'					=> array(),
+			'default_language'			=> '',
+			'current_language'			=> '',
+			'capability'				=> 'manage_options',
+			'uploader'					=> 'wp',
+			'autoload'					=> false,
+			'l10n'						=> true,
+			'l10n_textdomain'			=> '',
+			'google_api_key'			=> '',
+			'google_api_client'			=> '',
+			'enqueue_google_maps'		=> true,
+			'enqueue_select2'			=> true,
+			'enqueue_datepicker'		=> true,
+			'enqueue_datetimepicker'	=> true,
+			'select2_version'			=> 4,
+			'row_index_offset'			=> 1,
+			'remove_wp_meta_box'		=> true
+		);
+		
+		
+		// constants
+		$this->define( 'ACF', 			true );
+		$this->define( 'ACF_VERSION', 	$version );
+		$this->define( 'ACF_PATH', 		$path );
+		
+		// Include utility functions.
+		include_once( ACF_PATH . 'includes/acf-utility-functions.php');
+		
+		// Include previous API functions.
+		acf_include('includes/api/api-helpers.php');
+		acf_include('includes/api/api-template.php');
+		acf_include('includes/api/api-term.php');
+		
+		// Include classes.
+		acf_include('includes/class-acf-data.php');
+		
+		// Include functions.
+		acf_include('includes/acf-helper-functions.php');
+		acf_include('includes/acf-hook-functions.php');
+		acf_include('includes/acf-field-functions.php');
+		acf_include('includes/acf-field-group-functions.php');
+		acf_include('includes/acf-form-functions.php');
+		acf_include('includes/acf-meta-functions.php');
+		acf_include('includes/acf-post-functions.php');
+		acf_include('includes/acf-user-functions.php');
+		acf_include('includes/acf-value-functions.php');
+		acf_include('includes/acf-input-functions.php');
+		
+		// fields
+		acf_include('includes/fields.php');
+		acf_include('includes/fields/class-acf-field.php');
+				
+		
+		// locations
+		acf_include('includes/locations.php');
+		acf_include('includes/locations/class-acf-location.php');
+		
+		
+		// core
+		acf_include('includes/assets.php');
+		acf_include('includes/compatibility.php');
+		acf_include('includes/deprecated.php');
+		acf_include('includes/json.php');
+		acf_include('includes/l10n.php');
+		acf_include('includes/local-fields.php');
+		acf_include('includes/local-meta.php');
+		acf_include('includes/loop.php');
+		acf_include('includes/media.php');
+		acf_include('includes/revisions.php');
+		acf_include('includes/updates.php');
+		acf_include('includes/upgrades.php');
+		acf_include('includes/validation.php');
+		
+		// ajax
+		acf_include('includes/ajax/class-acf-ajax.php');
+		acf_include('includes/ajax/class-acf-ajax-check-screen.php');
+		acf_include('includes/ajax/class-acf-ajax-user-setting.php');
+		acf_include('includes/ajax/class-acf-ajax-upgrade.php');
+		
+		// forms
+		acf_include('includes/forms/form-attachment.php');
+		acf_include('includes/forms/form-comment.php');
+		acf_include('includes/forms/form-customizer.php');
+		acf_include('includes/forms/form-front.php');
+		acf_include('includes/forms/form-nav-menu.php');
+		acf_include('includes/forms/form-post.php');
+		acf_include('includes/forms/form-gutenberg.php');
+		acf_include('includes/forms/form-taxonomy.php');
+		acf_include('includes/forms/form-user.php');
+		acf_include('includes/forms/form-widget.php');
+		
+		
+		// admin
+		if( is_admin() ) {
+			acf_include('includes/admin/admin.php');
+			acf_include('includes/admin/admin-field-group.php');
+			acf_include('includes/admin/admin-field-groups.php');
+			acf_include('includes/admin/admin-notices.php');
+			acf_include('includes/admin/admin-tools.php');
+			acf_include('includes/admin/admin-upgrade.php');
+			acf_include('includes/admin/settings-info.php');
+		}
+		
+		
+		// pro
+		acf_include('pro/acf-pro.php');
+		
+		// Include tests.
+		if( defined('ACF_DEV') && ACF_DEV ) {
+			acf_include('tests/tests.php');
+		}
+		
+		// actions
+		add_action('init',	array($this, 'init'), 5);
+		add_action('init',	array($this, 'register_post_types'), 5);
+		add_action('init',	array($this, 'register_post_status'), 5);
+		
+		
+		// filters
+		add_filter('posts_where',		array($this, 'posts_where'), 10, 2 );
+		//add_filter('posts_request',	array($this, 'posts_request'), 10, 1 );
+	}
+	
+	
+	/*
+	*  init
+	*
+	*  This function will run after all plugins and theme functions have been included
+	*
+	*  @type	action (init)
+	*  @date	28/09/13
+	*  @since	5.0.0
+	*
+	*  @param	N/A
+	*  @return	N/A
+	*/
+	
+	function init() {
+		
+		// bail early if too early
+		// ensures all plugins have a chance to add fields, etc
+		if( !did_action('plugins_loaded') ) return;
+		
+		
+		// bail early if already init
+		if( acf_has_done('init') ) return;
+		
+		
+		// vars
+		$major = intval( acf_get_setting('version') );
+		
+		
+		// update url
+		// - allow another plugin to modify dir (maybe force SSL)
+		acf_update_setting('url', plugin_dir_url( __FILE__ ));
+		
+		
+		// textdomain
+		acf_load_textdomain();
+		
+		// include 3rd party support
+		acf_include('includes/third-party.php');
+		
+		// include wpml support
+		if( defined('ICL_SITEPRESS_VERSION') ) {
+			acf_include('includes/wpml.php');
+		}
+		
+		// fields
+		acf_include('includes/fields/class-acf-field-text.php');
+		acf_include('includes/fields/class-acf-field-textarea.php');
+		acf_include('includes/fields/class-acf-field-number.php');
+		acf_include('includes/fields/class-acf-field-range.php');
+		acf_include('includes/fields/class-acf-field-email.php');
+		acf_include('includes/fields/class-acf-field-url.php');
+		acf_include('includes/fields/class-acf-field-password.php');
+		
+		acf_include('includes/fields/class-acf-field-image.php');
+		acf_include('includes/fields/class-acf-field-file.php');
+		acf_include('includes/fields/class-acf-field-wysiwyg.php');
+		acf_include('includes/fields/class-acf-field-oembed.php');
+		
+		acf_include('includes/fields/class-acf-field-select.php');
+		acf_include('includes/fields/class-acf-field-checkbox.php');
+		acf_include('includes/fields/class-acf-field-radio.php');
+		acf_include('includes/fields/class-acf-field-button-group.php');
+		acf_include('includes/fields/class-acf-field-true_false.php');
+		
+		acf_include('includes/fields/class-acf-field-link.php');
+		acf_include('includes/fields/class-acf-field-post_object.php');
+		acf_include('includes/fields/class-acf-field-page_link.php');
+		acf_include('includes/fields/class-acf-field-relationship.php');
+		acf_include('includes/fields/class-acf-field-taxonomy.php');
+		acf_include('includes/fields/class-acf-field-user.php');
+		
+		acf_include('includes/fields/class-acf-field-google-map.php');
+		acf_include('includes/fields/class-acf-field-date_picker.php');
+		acf_include('includes/fields/class-acf-field-date_time_picker.php');
+		acf_include('includes/fields/class-acf-field-time_picker.php');
+		acf_include('includes/fields/class-acf-field-color_picker.php');
+		
+		acf_include('includes/fields/class-acf-field-message.php');
+		acf_include('includes/fields/class-acf-field-accordion.php');
+		acf_include('includes/fields/class-acf-field-tab.php');
+		acf_include('includes/fields/class-acf-field-group.php');
+		do_action('acf/include_field_types', $major);
+		
+		
+		// locations
+		acf_include('includes/locations/class-acf-location-post-type.php');
+		acf_include('includes/locations/class-acf-location-post-template.php');
+		acf_include('includes/locations/class-acf-location-post-status.php');
+		acf_include('includes/locations/class-acf-location-post-format.php');
+		acf_include('includes/locations/class-acf-location-post-category.php');
+		acf_include('includes/locations/class-acf-location-post-taxonomy.php');
+		acf_include('includes/locations/class-acf-location-post.php');
+		acf_include('includes/locations/class-acf-location-page-template.php');
+		acf_include('includes/locations/class-acf-location-page-type.php');
+		acf_include('includes/locations/class-acf-location-page-parent.php');
+		acf_include('includes/locations/class-acf-location-page.php');
+		acf_include('includes/locations/class-acf-location-current-user.php');
+		acf_include('includes/locations/class-acf-location-current-user-role.php');
+		acf_include('includes/locations/class-acf-location-user-form.php');
+		acf_include('includes/locations/class-acf-location-user-role.php');
+		acf_include('includes/locations/class-acf-location-taxonomy.php');
+		acf_include('includes/locations/class-acf-location-attachment.php');
+		acf_include('includes/locations/class-acf-location-comment.php');
+		acf_include('includes/locations/class-acf-location-widget.php');
+		acf_include('includes/locations/class-acf-location-nav-menu.php');
+		acf_include('includes/locations/class-acf-location-nav-menu-item.php');
+		do_action('acf/include_location_rules', $major);
+		
+		
+		// local fields
+		do_action('acf/include_fields', $major);
+		
+		
+		// action for 3rd party
+		do_action('acf/init');
+	}
+	
+	
+	/*
+	*  register_post_types
+	*
+	*  This function will register post types and statuses
+	*
+	*  @type	function
+	*  @date	22/10/2015
+	*  @since	5.3.2
+	*
+	*  @param	n/a
+	*  @return	n/a
+	*/
+	
+	function register_post_types() {
+		
+		// vars
+		$cap = acf_get_setting('capability');
+		
+		
+		// register post type 'acf-field-group'
+		register_post_type('acf-field-group', array(
+			'labels'			=> array(
+			    'name'					=> __( 'Field Groups', 'acf' ),
+				'singular_name'			=> __( 'Field Group', 'acf' ),
+			    'add_new'				=> __( 'Add New' , 'acf' ),
+			    'add_new_item'			=> __( 'Add New Field Group' , 'acf' ),
+			    'edit_item'				=> __( 'Edit Field Group' , 'acf' ),
+			    'new_item'				=> __( 'New Field Group' , 'acf' ),
+			    'view_item'				=> __( 'View Field Group', 'acf' ),
+			    'search_items'			=> __( 'Search Field Groups', 'acf' ),
+			    'not_found'				=> __( 'No Field Groups found', 'acf' ),
+			    'not_found_in_trash'	=> __( 'No Field Groups found in Trash', 'acf' ), 
+			),
+			'public'			=> false,
+			'show_ui'			=> true,
+			'_builtin'			=> false,
+			'capability_type'	=> 'post',
+			'capabilities'		=> array(
+				'edit_post'			=> $cap,
+				'delete_post'		=> $cap,
+				'edit_posts'		=> $cap,
+				'delete_posts'		=> $cap,
+			),
+			'hierarchical'		=> true,
+			'rewrite'			=> false,
+			'query_var'			=> false,
+			'supports' 			=> array('title'),
+			'show_in_menu'		=> false,
+		));
+		
+		
+		// register post type 'acf-field'
+		register_post_type('acf-field', array(
+			'labels'			=> array(
+			    'name'					=> __( 'Fields', 'acf' ),
+				'singular_name'			=> __( 'Field', 'acf' ),
+			    'add_new'				=> __( 'Add New' , 'acf' ),
+			    'add_new_item'			=> __( 'Add New Field' , 'acf' ),
+			    'edit_item'				=> __( 'Edit Field' , 'acf' ),
+			    'new_item'				=> __( 'New Field' , 'acf' ),
+			    'view_item'				=> __( 'View Field', 'acf' ),
+			    'search_items'			=> __( 'Search Fields', 'acf' ),
+			    'not_found'				=> __( 'No Fields found', 'acf' ),
+			    'not_found_in_trash'	=> __( 'No Fields found in Trash', 'acf' ), 
+			),
+			'public'			=> false,
+			'show_ui'			=> false,
+			'_builtin'			=> false,
+			'capability_type'	=> 'post',
+			'capabilities'		=> array(
+				'edit_post'			=> $cap,
+				'delete_post'		=> $cap,
+				'edit_posts'		=> $cap,
+				'delete_posts'		=> $cap,
+			),
+			'hierarchical'		=> true,
+			'rewrite'			=> false,
+			'query_var'			=> false,
+			'supports' 			=> array('title'),
+			'show_in_menu'		=> false,
+		));
+		
+	}
+	
+	
+	/*
+	*  register_post_status
+	*
+	*  This function will register custom post statuses
+	*
+	*  @type	function
+	*  @date	22/10/2015
+	*  @since	5.3.2
+	*
+	*  @param	$post_id (int)
+	*  @return	$post_id (int)
+	*/
+	
+	function register_post_status() {
+		
+		// acf-disabled
+		register_post_status('acf-disabled', array(
+			'label'                     => __( 'Inactive', 'acf' ),
+			'public'                    => true,
+			'exclude_from_search'       => false,
+			'show_in_admin_all_list'    => true,
+			'show_in_admin_status_list' => true,
+			'label_count'               => _n_noop( 'Inactive <span class="count">(%s)</span>', 'Inactive <span class="count">(%s)</span>', 'acf' ),
+		));
+		
+	}
+	
+	
+	/*
+	*  posts_where
+	*
+	*  This function will add in some new parameters to the WP_Query args allowing fields to be found via key / name
+	*
+	*  @type	filter
+	*  @date	5/12/2013
+	*  @since	5.0.0
+	*
+	*  @param	$where (string)
+	*  @param	$wp_query (object)
+	*  @return	$where (string)
+	*/
+	
+	function posts_where( $where, $wp_query ) {
+		
+		// global
+		global $wpdb;
+		
+		
+		// acf_field_key
+		if( $field_key = $wp_query->get('acf_field_key') ) {
+			$where .= $wpdb->prepare(" AND {$wpdb->posts}.post_name = %s", $field_key );
+	    }
+	    
+	    // acf_field_name
+	    if( $field_name = $wp_query->get('acf_field_name') ) {
+			$where .= $wpdb->prepare(" AND {$wpdb->posts}.post_excerpt = %s", $field_name );
+	    }
+	    
+	    // acf_group_key
+		if( $group_key = $wp_query->get('acf_group_key') ) {
+			$where .= $wpdb->prepare(" AND {$wpdb->posts}.post_name = %s", $group_key );
+	    }
+	    
+	    
+	    // return
+	    return $where;
+	    
+	}
+	
+	
+	/*
+	*  define
+	*
+	*  This function will safely define a constant
+	*
+	*  @type	function
+	*  @date	3/5/17
+	*  @since	5.5.13
+	*
+	*  @param	$name (string)
+	*  @param	$value (mixed)
+	*  @return	n/a
+	*/
+	
+	function define( $name, $value = true ) {
+		
+		if( !defined($name) ) {
+			define( $name, $value );
+		}
+		
+	}
+	
+	/**
+	*  has_setting
+	*
+	*  Returns true if has setting.
+	*
+	*  @date	2/2/18
+	*  @since	5.6.5
+	*
+	*  @param	string $name
+	*  @return	boolean
+	*/
+	
+	function has_setting( $name ) {
+		return isset($this->settings[ $name ]);
+	}
+	
+	/**
+	*  get_setting
+	*
+	*  Returns a setting.
+	*
+	*  @date	28/09/13
+	*  @since	5.0.0
+	*
+	*  @param	string $name
+	*  @return	mixed
+	*/
+	
+	function get_setting( $name ) {
+		return isset($this->settings[ $name ]) ? $this->settings[ $name ] : null;
+	}
+	
+	/**
+	*  update_setting
+	*
+	*  Updates a setting.
+	*
+	*  @date	28/09/13
+	*  @since	5.0.0
+	*
+	*  @param	string $name
+	*  @param	mixed $value
+	*  @return	n/a
+	*/
+	
+	function update_setting( $name, $value ) {
+		$this->settings[ $name ] = $value;
+		return true;
+	}
+	
+	/**
+	*  get_data
+	*
+	*  Returns data.
+	*
+	*  @date	28/09/13
+	*  @since	5.0.0
+	*
+	*  @param	string $name
+	*  @return	mixed
+	*/
+	
+	function get_data( $name ) {
+		return isset($this->data[ $name ]) ? $this->data[ $name ] : null;
+	}
+	
+	
+	/**
+	*  set_data
+	*
+	*  Sets data.
+	*
+	*  @date	28/09/13
+	*  @since	5.0.0
+	*
+	*  @param	string $name
+	*  @param	mixed $value
+	*  @return	n/a
+	*/
+	
+	function set_data( $name, $value ) {
+		$this->data[ $name ] = $value;
+	}
+	
+	
+	/**
+	*  get_instance
+	*
+	*  Returns an instance.
+	*
+	*  @date	13/2/18
+	*  @since	5.6.9
+	*
+	*  @param	string $class The instance class name.
+	*  @return	object
+	*/
+	
+	function get_instance( $class ) {
+		$name = strtolower($class);
+		return isset($this->instances[ $name ]) ? $this->instances[ $name ] : null;
+	}
+	
+	/**
+	*  new_instance
+	*
+	*  Creates and stores an instance.
+	*
+	*  @date	13/2/18
+	*  @since	5.6.9
+	*
+	*  @param	string $class The instance class name.
+	*  @return	object
+	*/
+	
+	function new_instance( $class ) {
+		$instance = new $class();
+		$name = strtolower($class);
+		$this->instances[ $name ] = $instance;
+		return $instance;
+	}
+	
+}
+
+
+/*
+*  acf
+*
+*  The main function responsible for returning the one true acf Instance to functions everywhere.
+*  Use this function like you would a global variable, except without needing to declare the global.
+*
+*  Example: <?php $acf = acf(); ?>
+*
+*  @type	function
+*  @date	4/09/13
+*  @since	4.3.0
+*
+*  @param	N/A
+*  @return	(object)
+*/
+
+function acf() {
+	
+	// globals
+	global $acf;
+	
+	
+	// initialize
+	if( !isset($acf) ) {
+		$acf = new ACF();
+		$acf->initialize();
+	}
+	
+	
+	// return
+	return $acf;
+	
+}
+
+
+// initialize
+acf();
+
+
+endif; // class_exists check
+
+?>

wp-content/plugins/advanced-custom-fields/assets/build/css/_dark.scss

@@ -0,0 +1,437 @@
+/*--------------------------------------------------------------------------------------------
+*
+*  Dark mode
+*  
+*  WordPress plugin: https://en-au.wordpress.org/plugins/dark-mode/
+*  Github Documentation: https://github.com/danieltj27/Dark-Mode/wiki/Help:-Plugin-Compatibility-Guide
+*
+*--------------------------------------------------------------------------------------------*/
+
+// Dark Mode Colours.
+$white:           #ffffff;
+$black:           #000000;
+$blue:            #0073aa;
+$medium-blue:     #00a0d2;
+$clear:           transparent;
+
+$accent-red:      #dc3232;
+$accent-orange:   #f56e28;
+$accent-yellow:   #ffb900;
+$accent-green:    #46b450;
+$accent-blue:     $blue;
+$accent-purple:   #826eb4;
+
+$base-grey:       #23282d;
+$light-grey:      #bbc8d4;
+$heavy-grey:      #37444c;
+$dark-grey:       #32373c;
+$ultra-grey:      #191f25;
+$dark-silver:     #50626f;
+$base-blue:       #2e74aa;
+$light-blue:      #4092d2;
+$dark-blue:       #2c5f88;
+$ultra-blue:      #1f3f58;
+$bright-blue:     #30ceff;
+
+$editor-lavender: #c678dd;
+$editor-sunglo:   #e06c75;
+$editor-olivine:  #98c379;
+
+// Custom variables.
+$body_text: 			#bbc8d4;
+$body_background: 		#23282d;
+$body_background2: 		#191f25;
+$postbox_background: 	#32373c;
+$postbox_border: 		#191f25;
+$postbox_divider: 		#23282d;
+$input_background: 		#50626f;
+$input_text: 			#fff;
+$input_border: 			#191f25;
+
+// Mixins.
+@mixin dark-text() {
+	color: $body_text;
+}
+@mixin dark-heading() {
+	color: $body_text;
+}
+@mixin dark-border() {
+	border-color: $postbox_border;
+}
+@mixin dark-background() {
+	background: $body_background;
+}
+@mixin darker-background() {
+	background: darken($body_background, 5%);
+}
+@mixin dark-postbox() {
+	background-color: $postbox_background;
+	border-color: $postbox_border;
+	color: $body_text;
+}
+@mixin dark-postbox-block() {
+	background-color: #2d3136;
+	border-color: $postbox_divider;
+}
+@mixin dark-divider() {
+	border-color: $postbox_divider;
+}
+@mixin dark-input() {
+	background-color: $input_background;
+	border-color: $input_border;
+	color: $input_text;
+}
+
+
+/*---------------------------------------------------------------------------------------------
+*
+*  Global
+*
+*---------------------------------------------------------------------------------------------*/
+
+// acf-box
+.acf-box {
+	@include dark-postbox();
+			
+	.title,
+	.footer {
+		@include dark-divider();
+	}
+	
+	h2 {
+		@include dark-heading();
+	}
+	
+	table, tbody, tr {
+		background: transparent !important;
+	}
+}
+
+// thead
+.acf-thead {
+	@include dark-heading();
+	@include dark-border();
+}
+.acf-tfoot {
+	@include dark-postbox-block();
+}
+
+// table clear
+.acf-table.-clear,
+.acf-table.-clear tr {
+	background: transparent !important;
+}
+
+// loading overlay
+.acf-loading-overlay {
+	background: rgba(0,0,0,0.5);
+}
+
+
+/*---------------------------------------------------------------------------------------------
+*
+*  Fields
+*
+*---------------------------------------------------------------------------------------------*/
+
+// fields
+.acf-fields {
+	
+	// field
+	> .acf-field {
+		@include dark-divider();
+	}
+}
+
+// fields (left)
+.acf-fields.-left {
+	
+	> .acf-field {
+		&:before {
+			background: rgba(0,0,0,0.1);
+			@include dark-divider();
+		}
+	}
+}
+
+// fields (border)
+.acf-fields.-border {
+	@include dark-postbox();
+}
+
+// width
+.acf-field[data-width] + .acf-field[data-width] {
+	@include dark-divider();
+}
+
+// text
+.acf-input-prepend, 
+.acf-input-append {
+	@include dark-postbox();
+}
+
+// tab
+.acf-tab-wrap {
+	
+}
+
+.acf-fields > .acf-tab-wrap {
+	@include dark-postbox();
+	
+	.acf-tab-group {
+		@include dark-postbox-block();
+		
+		li {
+			a {
+				@include dark-postbox-block();
+				
+				&:hover {
+					@include dark-postbox-block();
+					@include dark-text();
+				}
+			}
+			
+			&.active a {
+				@include dark-postbox();
+			}
+		}
+	}
+}
+
+.acf-fields.-sidebar {
+	&:before {
+		@include dark-postbox-block();
+	}
+}
+
+.acf-fields.-sidebar.-left {
+	&:before {
+		@include dark-postbox-block();
+		background: $body_background;
+	}
+	> .acf-tab-wrap.-left {
+		.acf-tab-group li a {
+			@include dark-postbox-block();
+		}
+		
+		.acf-tab-group li.active a {
+			@include dark-postbox-block();
+		}
+	}
+}
+
+// file
+.acf-file-uploader {
+	
+	.show-if-value {
+		@include dark-postbox();
+		
+		.file-icon {
+			@include dark-postbox-block();
+		}
+	}
+}
+
+// acf-oembed
+.acf-oembed {
+	@include dark-postbox-block();
+	
+	.title {
+		@include dark-input();
+	}
+}
+
+// gallery
+.acf-gallery {
+	@include dark-postbox-block();
+	
+	.acf-gallery-main {
+		@include dark-background();
+	}
+	
+	.acf-gallery-attachment {
+		.margin {
+			@include dark-postbox-block();
+		}
+	}	
+		
+	.acf-gallery-side {
+		@include dark-postbox-block();
+		
+		.acf-gallery-side-info {
+			@include dark-postbox-block();
+		}
+	}
+	
+	.acf-gallery-toolbar {
+		@include dark-postbox-block();
+	}
+}
+
+// button group
+.acf-button-group {
+	
+	label:not(.selected) {
+		@include dark-postbox-block();
+	}
+}
+
+// switch
+.acf-switch:not(.-on) {
+	@include dark-postbox-block();
+	.acf-switch-slider {
+		@include dark-input();
+	}
+}
+
+// link
+.acf-link .link-wrap {
+	@include dark-postbox-block();
+}
+
+// relationship
+.acf-relationship {
+	.filters {
+		@include dark-postbox();
+	}
+	.selection {
+		@include dark-postbox-block();
+		.choices,
+		.choices-list,
+		.values {
+			@include dark-postbox-block();	
+		}
+	}
+}
+
+// checkbox
+.acf-taxonomy-field .categorychecklist-holder {
+	@include dark-postbox-block();
+}
+
+// google map
+.acf-google-map {
+	@include dark-postbox-block();
+	
+	.title {
+		@include dark-input();
+	}
+}
+
+// accordion
+.acf-accordion {
+	@include dark-postbox();
+}
+.acf-field.acf-accordion .acf-accordion-content > .acf-fields {
+	@include dark-border();
+}
+
+// flexible content
+.acf-flexible-content {
+	.layout {
+		@include dark-postbox();
+		
+		.acf-fc-layout-handle {
+			@include dark-postbox-block();
+			
+			.acf-fc-layout-order {
+				@include dark-postbox();
+			}
+		}
+	}
+}
+
+// repeater
+#wpbody .acf-table {
+	@include dark-postbox-block();
+	
+	> tbody,
+	> thead {
+		> tr {
+			background: transparent;
+			
+			> td,
+			> th {
+				@include dark-border();
+			}
+		}
+	}
+}
+
+// Select
+.acf-field select {
+	optgroup, optgroup:nth-child(2n) {
+		background: $input_background;
+	}
+}
+
+/*---------------------------------------------------------------------------------------------
+*
+*  Field Group
+*
+*---------------------------------------------------------------------------------------------*/
+
+// fields
+#acf-field-group-fields {
+	
+	// field list
+	.acf-field-list-wrap {
+		@include dark-postbox();
+	}
+	
+	.acf-field-list {
+		.no-fields-message {
+			@include dark-postbox();
+		}
+	}
+	
+	// field
+	.acf-field-object {
+		@include dark-postbox();
+		@include dark-divider();
+		
+		
+		table, tbody, tr, td, th {
+			background: transparent;
+			@include dark-divider();
+		}
+		
+		.acf-field {
+			.acf-label {
+				@include dark-postbox-block();
+			}
+		}
+		
+		// sortable
+		&.ui-sortable-helper {
+			@include dark-border();
+			box-shadow: none;
+		}
+		
+		&.ui-sortable-placeholder {
+			@include dark-postbox-block();
+			box-shadow: none;
+		}
+	}
+	
+	.acf-field-object + .acf-field-object-tab::before,
+	.acf-field-object + .acf-field-object-accordion::before {
+		@include dark-postbox-block();
+	}
+}
+
+
+/*---------------------------------------------------------------------------------------------
+*
+*  Admin: Tools
+*
+*---------------------------------------------------------------------------------------------*/
+
+// tools
+.acf-meta-box-wrap {
+	
+	.acf-fields {
+		@include dark-input();
+		background: transparent;
+	}
+}

wp-content/plugins/advanced-custom-fields/assets/build/css/_field-group.scss

@@ -0,0 +1,600 @@
+/*---------------------------------------------------------------------------------------------
+*
+*  Global
+*
+*---------------------------------------------------------------------------------------------*/
+
+#adv-settings .show-field-keys label {
+	padding: 0 5px;
+}
+
+
+#acf-field-group-fields > .inside,
+#acf-field-group-locations > .inside,
+#acf-field-group-options > .inside {
+	padding: 0;
+	margin: 0;
+}
+
+.acf-field {
+
+	p.description {
+		font-style: normal;
+		font-size: 12px;
+		color: #777777;
+	}
+	
+}
+
+
+/*---------------------------------------------------------------------------------------------
+*
+*  Postbox: Publish
+*
+*---------------------------------------------------------------------------------------------*/
+
+#minor-publishing-actions,
+#misc-publishing-actions #visibility {
+	display: none;
+}
+
+#minor-publishing {
+	border-bottom: 0 none;
+}
+
+#misc-pub-section {
+	border-bottom: 0 none;
+}
+
+#misc-publishing-actions .misc-pub-section {
+	border-bottom-color: #F5F5F5;
+}
+
+
+/*---------------------------------------------------------------------------------------------
+*
+*  Postbox: Fields
+*
+*---------------------------------------------------------------------------------------------*/
+
+#acf-field-group-fields {
+	border: 0 none;
+    box-shadow: none;
+    
+    
+    /* metabox */
+    > .handlediv,
+	> .hndle {
+		display: none;
+	}
+	
+	
+	/* links */
+	a {
+		text-decoration: none;
+		
+		&:active,
+		&:focus {
+			outline: none;
+			box-shadow: none;
+		}
+	}
+	
+	
+	/* table header */
+	.li-field-order { width: 20%; }
+	.li-field-label { width: 30%; }
+	.li-field-name { width: 25%; }
+	.li-field-type { width: 25%; }
+	.li-field-key { display: none; }
+	
+	
+	/* show keys */
+	&.show-field-keys {
+		
+		.li-field-label,
+		.li-field-name,
+		.li-field-type,
+		.li-field-key { width: 20%; }
+		.li-field-key { display: block; }
+	}
+	
+	
+	/* fields */
+	.acf-field-list-wrap {
+		border: #DFDFDF solid 1px;
+	}
+	
+	.acf-field-list {
+		background: #F9F9F9;
+		margin-top: -1px;
+		
+		/* no fields */
+		.no-fields-message {
+			padding: 15px 15px;
+			background: #fff;
+			display: none;
+		}
+		
+		/* empty */
+		&.-empty {
+			.no-fields-message {
+				display: block;
+			}
+		}
+	}
+	
+}
+
+
+/* field object */
+.acf-field-object {
+	border-top: #F0F0F0 solid 1px;
+	background: #fff;
+	
+	/* sortable */
+	&.ui-sortable-helper {
+		border-top-color: #fff;
+		box-shadow: 0 0 0 1px #DFDFDF, 0 1px 4px rgba(0,0,0,0.1);
+	}
+	
+	&.ui-sortable-placeholder {
+		box-shadow: 0 -1px 0 0 #DFDFDF;
+		visibility: visible !important;
+		background: #F9F9F9;
+		border-top-color: transparent;
+		min-height: 54px;
+		
+		// hide tab field separator
+		&:after, &:before {
+			visibility: hidden;
+		}
+	}
+	
+	
+	/* meta */
+	> .meta {
+		display: none;
+	}
+	
+	
+	/* handle */
+	> .handle {
+		
+		a {
+			-webkit-transition: none;
+			-moz-transition: none;
+			-o-transition: none; 	
+			transition: none;
+		}
+		
+		li {
+			padding-top: 10px;
+			padding-bottom: 10px;
+			word-wrap: break-word;
+		}
+		
+		.acf-icon {
+			margin: 1px 0 0;
+			cursor: move;
+			background: transparent;
+			float: left;
+			
+			height: 28px;
+		    line-height: 28px;
+		    width: 28px;
+		    font-size: 13px;
+		    color: #444;
+		    position: relative;
+		    z-index: 1;
+		}
+		
+		strong {
+			display: block;
+			padding-bottom: 6px;
+			font-size: 14px;
+			line-height: 14px;
+			min-height: 14px;
+		}
+		
+		.row-options {
+			visibility: hidden;
+			
+			a {
+				margin-right: 4px;
+			}
+			
+			a.delete-field {
+				color: #a00;
+				
+				&:hover { color: #f00; }
+			}
+		}
+
+	}
+	
+	/* open */
+	&.open {
+		
+		+ .acf-field-object {
+			border-top-color: #E1E1E1;
+		}
+		
+		> .handle {
+			background: $acf_blue;
+			border: darken($acf_blue, 2%) solid 1px;
+			text-shadow: #268FBB 0 1px 0;
+			color: #fff;
+			position: relative;
+			margin: -1px -1px 0 -1px;
+			
+			a {
+				color: #fff !important;
+				
+				&:hover {
+					text-decoration: underline !important;
+				}
+			}
+			
+			.acf-icon {
+				border-color: #fff;
+				color: #fff;
+			}
+			
+			.acf-required {
+				color: #fff;
+			}
+		}
+	}
+	
+
+/*
+	// debug
+	&[data-save="meta"] {
+		> .handle {
+			border-left: #ffb700 solid 5px !important;
+		}
+	}
+	
+	&[data-save="settings"] {
+		> .handle {
+			border-left: #0ec563 solid 5px !important;
+		}
+	}
+*/
+	
+	
+	/* hover */
+	&:hover, &.-hover {
+		
+		> .handle {
+			
+			.row-options {
+				visibility: visible;
+			}
+				
+		}
+	}
+	
+	
+	/* settings */
+	> .settings {
+		display: none;
+		width: 100%;
+		
+		> .acf-table {
+			border: none;
+		}
+	}
+	
+	
+	/* conditional logic */
+	.rule-groups {
+		margin-top: 20px;
+	}
+	
+}
+
+
+/*---------------------------------------------------------------------------------------------
+*
+* Postbox: Locations
+*
+*---------------------------------------------------------------------------------------------*/
+
+.rule-groups {
+	
+	h4 {
+		margin: 15px 0 5px;
+	}
+	
+	.rule-group {
+		margin: 0 0 5px;
+		
+		h4 {
+			margin: 0 0 3px;
+		}
+		
+		td.param {
+			width: 35%;
+		}
+		
+		td.operator {
+			width: 20%;
+		}
+		
+		td.add {
+			width: 40px;
+		}
+		
+		td.remove {
+			width: 28px;
+			vertical-align: middle;
+			
+			a {
+				visibility: hidden;
+			}
+		}
+		
+		tr:hover td.remove a {
+			visibility: visible;
+		}
+		
+		/* Don't allow user to delete the first field group */
+		&:first-child tr:first-child td.remove a {
+			visibility: hidden !important;
+		}
+		
+		// empty select
+		select:empty {
+			background: #f8f8f8;
+		}
+	}
+}
+
+
+/*---------------------------------------------------------------------------------------------
+*
+*	Options
+*	
+*---------------------------------------------------------------------------------------------*/
+
+#acf-field-group-options tr[data-name="hide_on_screen"] li {
+	float: left;
+	width: 33%;
+}
+
+@media (max-width: 1100px) {
+	
+	#acf-field-group-options tr[data-name="hide_on_screen"] li {
+		width: 50%;
+	}
+	
+}
+
+
+/*---------------------------------------------------------------------------------------------
+*
+*	Conditional Logic
+*	
+*---------------------------------------------------------------------------------------------*/
+
+table.conditional-logic-rules {
+	background: transparent;
+	border: 0 none;
+	border-radius: 0;
+}
+
+table.conditional-logic-rules tbody td {
+	background: transparent;
+	border: 0 none !important;
+	padding: 5px 2px !important;
+}
+
+
+/*---------------------------------------------------------------------------------------------
+*
+*	Field: Tab
+*	
+*---------------------------------------------------------------------------------------------*/
+
+.acf-field-object-tab {
+	
+	// hide setting
+	.acf-field-setting-name,
+	.acf-field-setting-instructions,
+	.acf-field-setting-required,
+	.acf-field-setting-warning,
+	.acf-field-setting-wrapper {
+		display: none;
+	}
+	
+	// hide name
+	.li-field-name {
+		visibility: hidden;
+	}
+	
+	// add spacer
+	.acf-field-object + & {
+		
+		&:before {
+			display: block;
+			content: "";
+			height: 5px;
+			width: 100%;
+			background: #f9f9f9;
+			border-bottom: #f0f0f0 solid 1px;
+		}
+	}
+	
+	p:first-child {
+		margin: 0.5em 0;
+	}
+}
+
+
+/*---------------------------------------------------------------------------------------------
+*
+*	Field: Accordion
+*	
+*---------------------------------------------------------------------------------------------*/
+
+.acf-field-object-accordion {
+	@extend .acf-field-object-tab;
+	
+	// show settings
+	.acf-field-setting-instructions {
+		display: table-row;
+	}
+	
+}
+
+
+/*---------------------------------------------------------------------------------------------
+*
+*	Field: Message
+*	
+*---------------------------------------------------------------------------------------------*/
+
+.acf-field-object-message tr[data-name="name"],
+.acf-field-object-message tr[data-name="instructions"],
+.acf-field-object-message tr[data-name="required"] {
+	display: none !important;
+}
+
+.acf-field-object-message .li-field-name {
+	visibility: hidden;
+}
+
+.acf-field-object-message textarea {
+	height: 175px !important;
+}
+
+
+/*---------------------------------------------------------------------------------------------
+*
+*	Field: Separator
+*	
+*---------------------------------------------------------------------------------------------*/
+
+.acf-field-object-separator tr[data-name="name"],
+.acf-field-object-separator tr[data-name="instructions"],
+.acf-field-object-separator tr[data-name="required"] {
+	display: none !important;
+}
+
+
+/*---------------------------------------------------------------------------------------------
+*
+*	Field: Date Picker
+*	
+*---------------------------------------------------------------------------------------------*/
+
+.acf-field-object-date-picker,
+.acf-field-object-time-picker,
+.acf-field-object-date-time-picker {
+	
+	.acf-radio-list {
+		
+		li {
+			line-height: 25px;
+		}
+		
+		span {
+			display: inline-block;
+			min-width: 10em;
+		}
+		
+		input[type="text"] {
+			width: 100px;
+		}
+	}
+
+}
+
+.acf-field-object-date-time-picker {
+	
+	.acf-radio-list {
+		
+		span {
+			min-width: 15em;
+		}
+		
+		input[type="text"] {
+			width: 200px;
+		}
+	}
+	
+}
+
+
+/*--------------------------------------------------------------------------------------------
+*
+*	Slug
+*
+*--------------------------------------------------------------------------------------------*/
+
+#slugdiv {
+	
+	.inside {
+		padding: 12px;
+		margin: 0;
+	}
+	
+	input[type="text"] {
+		width: 100%;
+		height: 28px;
+		font-size: 14px;
+	}
+}
+
+
+/*--------------------------------------------------------------------------------------------
+*
+*	RTL
+*
+*--------------------------------------------------------------------------------------------*/
+
+html[dir="rtl"] .acf-field-object.open > .handle {
+	margin: -1px -1px 0;
+}
+
+html[dir="rtl"] .acf-field-object.open > .handle .acf-icon {
+	float: right;
+}
+
+html[dir="rtl"] .acf-field-object.open > .handle .li-field-order {
+    padding-left: 0 !important;
+    padding-right: 15px !important;
+}
+
+
+/*---------------------------------------------------------------------------------------------
+*
+*  Device
+*
+*---------------------------------------------------------------------------------------------*/
+
+@media only screen and (max-width: 850px) {
+	
+	tr.acf-field,
+	td.acf-label,
+	td.acf-input {
+		display: block !important;
+		width: auto !important;
+		border: 0 none !important;
+	}
+	
+	tr.acf-field {
+		border-top: #ededed solid 1px !important;
+		margin-bottom: 0 !important;
+	}
+	
+	td.acf-label {
+		background: transparent !important;
+		padding-bottom: 0 !important;
+
+	}
+	
+}
+

wp-content/plugins/advanced-custom-fields/assets/build/css/_forms.scss

@@ -0,0 +1,306 @@
+/*--------------------------------------------------------------------------------------------
+*
+*	User
+*
+*--------------------------------------------------------------------------------------------*/
+
+.form-table > tbody {
+	
+	/* field */
+	> .acf-field {
+		
+		/* label */
+		> .acf-label {
+			padding: 20px 10px 20px 0;
+		    width: 210px;
+		    
+		    /* rtl */
+			html[dir="rtl"] & {
+				padding: 20px 0 20px 10px;
+			}
+			
+		    label {
+				font-size: 14px;
+				color: #23282d;
+			}
+		    
+		}
+		
+		
+		/* input */
+		> .acf-input {
+			padding: 15px 10px;
+			
+			/* rtl */
+			html[dir="rtl"] & {
+				padding: 15px 10px 15px 5%;
+			}
+		}
+		
+	}
+	
+	
+	/* tab wrap */
+	> .acf-tab-wrap td {
+		padding: 15px 5% 15px 0;
+		
+		/* rtl */
+		html[dir="rtl"] & {
+			padding: 15px 0 15px 5%;
+		}
+		
+	}
+	
+	
+	/* misc */
+	.form-table th.acf-th {
+		width: auto;
+	}
+	
+}
+
+#your-profile,
+#createuser {
+	
+	/* override for user css */
+	.acf-field input[type="text"],
+	.acf-field input[type="password"],
+	.acf-field input[type="number"],
+	.acf-field input[type="search"],
+	.acf-field input[type="email"],
+	.acf-field input[type="url"],
+	.acf-field select {
+	    max-width: 25em;
+	}
+	
+	.acf-field textarea {
+		max-width: 500px;
+	}
+	
+	
+	/* allow sub fields to display correctly */
+	.acf-field .acf-field input[type="text"],
+	.acf-field .acf-field input[type="password"],
+	.acf-field .acf-field input[type="number"],
+	.acf-field .acf-field input[type="search"],
+	.acf-field .acf-field input[type="email"],
+	.acf-field .acf-field input[type="url"],
+	.acf-field .acf-field textarea,
+	.acf-field .acf-field select {
+	    max-width: none;
+	}
+}
+
+#registerform {
+	
+	h2 {
+		margin: 1em 0;
+	}
+	
+	.acf-field  {
+		margin-top: 0;
+		
+		.acf-label {
+			margin-bottom: 0;
+			
+			label {
+				font-weight: normal;
+				line-height: 1.5;
+			}
+		}
+		
+/*
+		.acf-input {
+			input {
+				font-size: 24px;
+				padding: 5px;
+				height: auto;
+			}
+		}
+*/
+	}
+	
+	p.submit {
+		text-align: right;
+	}
+
+}
+
+/*--------------------------------------------------------------------------------------------
+*
+*	Term
+*
+*--------------------------------------------------------------------------------------------*/
+
+// add term
+#acf-term-fields {
+	padding-right: 5%;
+	
+	> .acf-field {
+		
+		> .acf-label {
+			margin: 0;
+			
+			label {
+				font-size: 12px;
+				font-weight: normal;
+			}
+		}
+	}
+	
+}
+
+p.submit .spinner,
+p.submit .acf-spinner {
+	vertical-align: top;
+	float: none;
+	margin: 4px 4px 0;
+}
+
+
+// edit term
+#edittag .acf-fields.-left {
+	
+	> .acf-field {
+		padding-left: 220px;
+		
+		&:before {
+			width: 209px;
+		}
+		
+		> .acf-label {
+			width: 220px;
+			margin-left: -220px;
+			padding: 0 10px;
+		}
+		
+		> .acf-input {
+			padding: 0;
+		}
+	}
+}
+
+#edittag > .acf-fields.-left {
+	width: 96%;
+	
+	> .acf-field { 
+		
+		> .acf-label {
+			padding-left: 0;
+		}
+	}
+}
+
+
+/*--------------------------------------------------------------------------------------------
+*
+*	Comment
+*
+*--------------------------------------------------------------------------------------------*/
+
+.editcomment td:first-child {
+    white-space: nowrap;
+    width: 131px;
+}
+
+
+/*--------------------------------------------------------------------------------------------
+*
+*	Widget
+*
+*--------------------------------------------------------------------------------------------*/
+
+#widgets-right .widget .acf-field .description {
+	padding-left: 0;
+	padding-right: 0;
+}
+
+.acf-widget-fields {
+	
+	> .acf-field {
+		
+		.acf-label {
+			margin-bottom: 5px;
+			
+			label {
+				font-weight: normal;
+				margin: 0;
+			}
+		}
+	}
+}
+
+/*--------------------------------------------------------------------------------------------
+*
+*	Nav Menu
+*
+*--------------------------------------------------------------------------------------------*/
+
+.acf-menu-settings {
+	border-top: 1px solid #eee;
+    margin-top: 2em;
+	
+	// seamless
+	&.-seamless {
+		border-top: none;
+		margin-top: 15px;
+		
+		> h2 { display: none; }
+	}
+	
+	// Fix relationship conflict.
+	.list li {
+		display: block;
+		margin-bottom: 0;
+	}
+}
+
+.acf-menu-item-fields {
+	margin-right: 10px;
+	float: left;
+}
+
+/*---------------------------------------------------------------------------------------------
+*
+*  Attachment Form (single)
+*
+*---------------------------------------------------------------------------------------------*/
+
+#post .compat-attachment-fields {
+	
+	.compat-field-acf-form-data {
+		display: none;
+	}
+	
+	&,
+	> tbody,
+	> tbody > tr,
+	> tbody > tr > th,
+	> tbody > tr > td {
+		display: block;
+	}
+	
+	> tbody > .acf-field {
+		margin: 15px 0;
+		
+		> .acf-label {
+			margin: 0;
+			
+			label {
+				margin: 0;
+				padding: 0;
+				
+				p {
+					margin: 0 0 3px !important;
+				}
+			}
+		}
+		
+		> .acf-input {
+			margin: 0;
+		}
+	} 
+}
+
+
+

wp-content/plugins/advanced-custom-fields/assets/build/css/_gutenberg.scss

@@ -0,0 +1,123 @@
+/*--------------------------------------------------------------------------------------------
+*
+*	Gutenberg
+*
+*--------------------------------------------------------------------------------------------*/
+#editor {
+	
+	// main column is split into "editor" and "metaboxes".
+	// remove WP flex that pushed metaboxes to bottom.
+	.edit-post-visual-editor,
+	.edit-post-layout__metaboxes {
+		flex-basis: 0%;
+		flex-grow: 0;
+	}
+	
+	// metabox wrap
+	.edit-post-layout__metaboxes {
+		background: transparent;
+		border-top: 0 none;
+		margin-top: 0;
+		padding: 30px;
+		
+		@media screen and (min-width: 600px) {
+			padding: 46px;
+		}
+		
+		.edit-post-meta-boxes-area {
+			margin: 0;
+		}
+		
+		// make postbox look like a classic box.
+		.postbox {
+			border: #e2e4e7 solid 1px;
+			border-bottom: none;
+			margin: 0 0 20px;
+		}
+	}
+	
+	// improve handle style
+	.postbox {
+		.handlediv {
+			height: 46px;
+			width: auto;
+			padding: 0 14px 0 5px;
+		}
+		.hndle {
+			color: #191e23 !important;
+			font-size: 13px;
+			line-height: 16px;
+			
+			.acf-hndle-cog {
+				line-height: 16px;
+			}
+		}
+		
+		// change icons to match gutenberg sidebar accordions
+		.handlediv .toggle-indicator {
+			color: #191e23;
+		}
+		.handlediv .toggle-indicator:before {
+			content: "\f343";
+			font-size: 18px;
+			width: auto;
+		}
+		&.closed .handlediv .toggle-indicator:before {
+			content: "\f347";
+		}
+	}
+	
+	// acf-input-wrap
+	.acf-input-prepend,
+	.acf-input-append {
+		box-sizing: border-box;
+		height: 28px;
+	}
+	
+	// accordion
+	.acf-accordion {
+		padding: 0 !important;
+		
+		.acf-accordion-title {
+			color: #191e23;
+			font-weight: 600;
+			
+			&:hover {
+				background: #f8f9f9;
+			}
+			
+			label {
+				font-weight: inherit;
+			}
+		}
+	}
+	
+	// table
+	.acf-table {
+		box-sizing: border-box;
+		
+		.acf-row-handle {
+			width: 32px;
+		}
+	}
+	
+	// main error message
+	.components-notice-list .acf-notice.-error {
+		margin: 0 0 5px;
+		min-height: 50px;
+		padding: 6px 12px;
+		border-left: 4px solid #00a0d2;
+		color: #191e23;
+		background-color: #f9e2e2;
+		border-left-color: #d94f4f;
+		
+		p {
+			margin: 1em 0;
+		}
+		
+		.acf-notice-dismiss {
+			top: 15px;
+			right: 15px;
+		}
+	}
+}

wp-content/plugins/advanced-custom-fields/assets/build/css/_input.scss

@@ -0,0 +1,61 @@
+/*--------------------------------------------------------------------------------------------
+*
+*	Confirm remove
+*
+*--------------------------------------------------------------------------------------------*/
+
+.acf-temp-remove {
+	position: relative;
+	opacity: 1;
+	-webkit-transition: all 0.25s ease;
+	-moz-transition: all 0.25s ease;
+	-o-transition: all 0.25s ease;
+	transition: all 0.25s ease;
+	overflow: hidden;
+	
+	/* overlay prevents hover */
+	&:after {
+		display: block;
+		content: "";
+		position: absolute;
+		top: 0;
+		left: 0;
+		right: 0;
+		bottom: 0;
+		z-index: 99;
+	}
+}
+
+
+/*--------------------------------------------------------------------------
+*
+*	Conditional Logic
+*	
+*-------------------------------------------------------------------------*/
+
+/* Hide */
+.hidden-by-conditional-logic {
+    display: none !important;
+}
+
+
+/* Hide (appear empty) */
+.hidden-by-conditional-logic.appear-empty {
+    display: table-cell !important;
+}
+
+.hidden-by-conditional-logic.appear-empty .acf-input {
+	display: none !important;
+}
+
+
+/*--------------------------------------------------------------------------
+*
+*	3rd Party
+*	
+*-------------------------------------------------------------------------*/
+
+/* Tabify shows hidden postboxes */
+.acf-postbox.acf-hidden {
+	display: none !important;
+}

wp-content/plugins/advanced-custom-fields/assets/build/css/_media.scss

@@ -0,0 +1,505 @@
+/*---------------------------------------------------------------------------------------------
+*
+*  Media Model
+*
+*---------------------------------------------------------------------------------------------*/
+
+/* WP sets tables to act as divs. ACF uses tables, so these muct be reset */
+.media-modal .compat-attachment-fields td.acf-input {
+	
+	table {
+		display: table;
+		table-layout: auto;
+		
+		tbody {
+			display: table-row-group;
+		}
+		
+		tr {
+			display: table-row;
+		}
+		
+		td, th {
+			display: table-cell;
+		}
+		
+	}
+	
+}
+
+
+/* field widths floats */
+.media-modal .compat-attachment-fields > tbody > .acf-field {
+	margin: 5px 0;
+	
+	> .acf-label {
+		min-width: 30%;
+		margin: 0;
+		padding: 0;
+		float: left;
+	    text-align: right;
+	    display: block;
+	    float: left;
+	    
+	    > label {
+		    padding-top: 6px;
+			margin: 0;
+			color: #666666;
+		    font-weight: 400;
+		    line-height: 16px;
+	    }
+	}
+	
+	> .acf-input {
+		width: 65%;
+		margin: 0;
+		padding: 0;
+	    float: right;
+	    display: block;
+	}
+	
+	p.description {
+		margin: 0;
+	}
+}
+
+
+/* restricted selection (copy of WP .upload-errors)*/
+.acf-selection-error {
+	background: #ffebe8;
+    border: 1px solid #c00;
+    border-radius: 3px;
+    padding: 8px;
+    margin: 20px 0 0;
+    
+    .selection-error-label {
+		background: #CC0000;
+	    border-radius: 3px;
+	    color: #fff;
+	    font-weight: bold;
+	    margin-right: 8px;
+	    padding: 2px 4px;
+	}
+	
+	.selection-error-message {
+		color: #b44;
+	    display: block;
+	    padding-top: 8px;
+	    word-wrap: break-word;
+	    white-space: pre-wrap;
+	}
+}
+
+
+/* disabled attachment */
+.media-modal .attachment.acf-disabled {
+	
+	.thumbnail {
+		opacity: 0.25 !important;
+	}
+		
+	.attachment-preview:before {
+		background: rgba(0,0,0,0.15);
+		z-index: 1;
+		position: relative;
+	}
+
+}
+
+
+/* misc */
+.media-modal {
+	
+	/* compat-item */
+	.compat-field-acf-form-data,
+	.compat-field-acf-blank {
+		display: none !important;
+	}
+	
+	
+	/* allow line breaks in upload error */
+	.upload-error-message {
+		white-space: pre-wrap;
+	}
+	
+	
+	/* fix required span */
+	.acf-required {
+		padding: 0 !important;
+		margin: 0 !important;
+		float: none !important;
+		color: #f00 !important;
+	}
+	
+	
+	/* sidebar */
+	.media-sidebar {
+		
+		.compat-item{
+			padding-bottom: 20px;
+		}
+		
+	}
+	
+	
+	/* mobile md */
+	@media (max-width: 900px) {
+		
+		/* label */
+		.setting span, 
+		.compat-attachment-fields > tbody > .acf-field > .acf-label {
+			width: 98%;
+			float: none;
+			text-align: left;
+			min-height: 0;
+			padding: 0;
+		}
+		
+		
+		/* field */
+		.setting input, 
+		.setting textarea, 
+		.compat-attachment-fields > tbody > .acf-field > .acf-input {
+			float: none;
+		    height: auto;
+		    max-width: none;
+		    width: 98%;
+		}
+
+	}
+
+	
+}
+
+
+
+/*---------------------------------------------------------------------------------------------
+*
+*  Media Model (expand details)
+*
+*---------------------------------------------------------------------------------------------*/
+
+.media-modal .acf-expand-details {
+	float: right;
+	padding: 1px 10px;
+	margin-right: 6px;
+	height: 18px;
+	line-height: 18px;
+	color: #AAAAAA;
+	font-size: 12px;
+	
+	&:focus, &:active {
+		outline: 0 none;
+		box-shadow: none;
+		color: #AAAAAA;
+	}
+	
+	&:hover {
+		color: #666666 !important;
+	}
+	
+	span {
+		display: block;
+		float: left;
+	}
+	
+	.acf-icon {
+		margin: 0 4px 0 0;
+	}
+	
+	&:hover .acf-icon {
+		border-color: #AAAAAA;
+	}
+	
+	.is-open { display: none; }
+	.is-closed { display: block; }
+	
+	
+	/* mobile sm */
+	@media (max-width: $sm) {
+		display: none;
+	}
+}
+
+
+/* expanded */
+.media-modal.acf-expanded {
+	
+	/* toggle */
+	.acf-expand-details {
+		.is-open { display: block; }
+		.is-closed { display: none; }
+		
+	}
+	
+	// Components.
+	.attachments-browser .media-toolbar, 
+	.attachments-browser .attachments { right: 740px; }
+	.media-sidebar { width: 708px; }
+	
+	// Sidebar.
+	.media-sidebar {
+		
+		// Attachment info.
+		.attachment-info {
+			.thumbnail {
+				float: left;
+				max-height: none;
+
+				img {
+					max-width: 100%;
+					max-height: 200px;
+				}
+			}
+			
+			.details {
+				float: right;
+			}
+		}
+		
+		// Label
+		.attachment-info .thumbnail,
+		.attachment-details .setting span, 
+		.compat-attachment-fields > tbody > .acf-field > .acf-label {
+			min-width: 20%;
+			margin-right: 0;
+		}
+		
+		// Input
+		.attachment-info .details,
+		.attachment-details .setting input, 
+		.attachment-details .setting textarea,
+		.attachment-details .setting + .description,
+		.compat-attachment-fields > tbody > .acf-field > .acf-input {
+			min-width: 77%;
+		}
+	}
+	
+	// Screen: Medium.
+	@media (max-width: 900px) {
+		
+		// Components.
+		.attachments-browser .media-toolbar { display: none; }
+		.attachments { display: none; }
+		.media-sidebar { width: auto; max-width: none !important; bottom: 0 !important; }
+		
+		// Sidebar.
+		.media-sidebar {
+			
+			// Attachment info.
+			.attachment-info {
+				.thumbnail {
+					min-width: 0;
+					max-width: none;
+					width: 30%;
+				}
+				
+				.details {
+					min-width: 0;
+					max-width: none;
+					width: 67%;
+				}
+				
+			}	
+		}
+	}
+	
+	// Screen: small.
+	@media (max-width: 640px) {
+		
+		// Sidebar.
+		.media-sidebar {
+			
+			// Attachment info.
+			.attachment-info {
+				.thumbnail, .details {
+					width: 100%;
+				}
+			}	
+		}
+	}
+}
+
+
+
+/*---------------------------------------------------------------------------------------------
+*
+*  ACF Media Model
+*
+*---------------------------------------------------------------------------------------------*/
+
+.acf-media-modal {
+	
+	/* hide embed settings */
+	.media-embed {
+		
+		.setting.align,
+		.setting.link-to {
+			display: none;
+		}
+		
+	}
+	
+	// only allow for devices larger than mobile
+	@media screen and (min-width: 1024px) {
+		
+		// - requires long selector to override WP core
+		.media-modal-content .media-frame .media-toolbar-secondary {
+			max-width: none;
+			
+			select.attachment-filters {
+				width: auto;
+				min-width: 150px;
+				max-width: none;
+				margin: 11px 6px 0 0;
+				vertical-align: middle;
+			}
+		}
+	}
+}
+
+
+/*---------------------------------------------------------------------------------------------
+*
+*  ACF Media Model (Select Mode)
+*
+*---------------------------------------------------------------------------------------------*/
+
+.acf-media-modal.-select {
+	
+	
+	
+}
+
+
+/*---------------------------------------------------------------------------------------------
+*
+*  ACF Media Model (Edit Mode)
+*
+*---------------------------------------------------------------------------------------------*/
+
+.acf-media-modal.-edit {
+	
+	/* resize modal */
+	left: 15%;
+	right: 15%;
+	top: 100px;
+	bottom: 100px;
+	
+	
+	/* hide elements */
+	.media-frame-menu,
+	.media-frame-router,
+	.media-frame-content .attachments,
+	.media-frame-content .media-toolbar {
+	    display: none;
+	}
+	
+	
+	/* full width */
+	.media-frame-title,
+	.media-frame-content,
+	.media-frame-toolbar,
+	.media-sidebar {
+		width: auto;
+		left: 0;
+		right: 0;
+	}
+	
+	
+	/* tidy up incorrect distance */
+	.media-frame-content {
+	    top: 50px;
+	}
+	
+	
+	/* title box shadow (to match media grid) */
+	.media-frame-title {
+	    border-bottom: 1px solid #DFDFDF;
+	    box-shadow: 0 4px 4px -4px rgba(0, 0, 0, 0.1);
+	}
+	
+	
+	/* sidebar */
+	.media-sidebar {
+		
+		padding: 0 16px;
+		
+		/* WP details */
+		.attachment-details {
+			
+			overflow: visible;
+			
+			/* hide 'Attachment Details' heading */
+			> h3, > h2 {
+				display: none;
+			}
+			
+			
+			/* remove overflow */
+			.attachment-info {
+				background: #fff;
+				border-bottom: #dddddd solid 1px;
+				padding: 16px;
+				margin: 0 -16px 16px;
+			}
+			
+			/* move thumbnail */
+			.thumbnail {
+				margin: 0 16px 0 0;
+			}
+			
+			.setting {
+				margin: 0 0 5px;
+				
+				span {
+					margin: 0;
+				}
+			}
+			
+		}
+		
+		
+		/* ACF fields */
+		.compat-attachment-fields {
+			
+			> tbody > .acf-field {
+				margin: 0 0 5px;
+				
+				p.description {
+					margin-top: 3px;
+				}
+			}
+			
+		}
+		
+		
+		/* WP required message */
+		.media-types-required-info { display: none; }
+		
+	}
+	
+	
+	/* mobile md */
+	@media (max-width: 900px) {
+		top: 30px;
+		right: 30px;
+		bottom: 30px;
+		left: 30px;
+	}
+	
+	
+	/* mobile sm */
+	@media (max-width: 640px) {
+		top: 0;
+		right: 0;
+		bottom: 0;
+		left: 0;
+	}
+	
+	@media (max-width: 480px) {
+		.media-frame-content {
+		    top: 40px;
+		}
+	}
+}

wp-content/plugins/advanced-custom-fields/assets/build/css/_mixins.scss

@@ -0,0 +1,39 @@
+/*--------------------------------------------------------------------------------------------
+*
+*  Mixins
+*
+*--------------------------------------------------------------------------------------------*/
+@mixin clearfix() {
+	&:after {
+		display: block;
+		clear: both;
+		content: "";
+	}
+}
+
+@mixin border-box() {
+	-webkit-box-sizing: border-box;
+	-moz-box-sizing: border-box;
+	box-sizing: border-box;
+}
+
+@mixin centered() {
+	position: absolute;
+	top: 50%;
+	left: 50%;
+	transform: translate(-50%, -50%);
+}
+
+@mixin animate( $properties: 'all' ) {
+	-webkit-transition: $properties 0.3s ease;  // Safari 3.2+, Chrome
+    -moz-transition: $properties 0.3s ease;  	// Firefox 4-15
+    -o-transition: $properties 0.3s ease;  		// Opera 10.5–12.00
+    transition: $properties 0.3s ease;  		// Firefox 16+, Opera 12.50+
+}
+
+@mixin rtl() {
+	html[dir="rtl"] & {
+		text-align: right;
+		@content;
+	}
+}

wp-content/plugins/advanced-custom-fields/assets/build/css/_postbox.scss

@@ -0,0 +1,50 @@
+// Postbox.
+
+// Gutenberg specific styles.
+#editor {
+	
+	// Postbox container.
+	.edit-post-layout__metaboxes {
+		padding: 0;
+	}
+	
+	// Alter postbox to look like panel component.
+	.postbox {
+		color: #444;
+		
+		.handlediv {
+			color: #191e23 !important;
+			height: 46px;
+			width: auto;
+			padding: 0 14px 0 5px;
+			position: relative;
+			z-index: 2;
+		}
+		.hndle {
+			color: #191e23 !important;
+			font-size: 13px;
+			line-height: normal;
+			padding: 15px;
+			
+			&:hover {
+				background: #f2f4f5;
+			}
+			.acf-hndle-cog {
+				line-height: 16px;
+			}
+		}
+		
+		// change icons to match gutenberg sidebar accordions
+		.handlediv .toggle-indicator {
+			color: inherit;
+			&:before {
+				content: "\f343";
+				font-size: 18px;
+				width: auto;
+			}
+		}
+		&.closed .handlediv .toggle-indicator:before {
+			content: "\f347";
+		}
+	}
+}

wp-content/plugins/advanced-custom-fields/assets/build/css/_variables.scss

@@ -0,0 +1,24 @@
+/*--------------------------------------------------------------------------------------------
+*
+*	Vars
+*
+*--------------------------------------------------------------------------------------------*/
+
+/* colors */
+$acf_blue: #2a9bd9;
+$acf_notice: #2a9bd9;
+$acf_error: #F55E4F;
+$acf_success: #46b450;
+$acf_warning: #fd8d3b;
+
+/* acf-field */
+$field_padding: 15px 12px;
+$field_padding_x: 12px;
+$field_padding_y: 15px;
+$fp: 15px 12px;
+$fy: 15px;
+$fx: 12px;
+
+/* responsive */
+$md: 880px;
+$sm: 640px;

wp-content/plugins/advanced-custom-fields/assets/build/css/acf-dark.scss

@@ -0,0 +1 @@
+@import "dark";

wp-content/plugins/advanced-custom-fields/assets/build/css/acf-field-group.scss

@@ -0,0 +1,3 @@
+@import "variables";
+@import "mixins";
+@import "field-group";

wp-content/plugins/advanced-custom-fields/assets/build/css/acf-global.scss

@@ -0,0 +1,3 @@
+@import "variables";
+@import "mixins";
+@import "global";

wp-content/plugins/advanced-custom-fields/assets/build/css/acf-input.scss

@@ -0,0 +1,7 @@
+@import "variables";
+@import "mixins";
+@import "fields";
+@import "forms";
+@import "media";
+@import "input";
+@import "postbox";

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-compatibility.js

@@ -0,0 +1,761 @@
+(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);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-condition-types.js

@@ -0,0 +1,447 @@
+(function($, undefined){
+	
+	var __ = acf.__;
+	
+	var parseString = function( val ){
+		return val ? '' + val : '';
+	};
+	
+	var isEqualTo = function( v1, v2 ){
+		return ( parseString(v1).toLowerCase() === parseString(v2).toLowerCase() );
+	};
+	
+	var isEqualToNumber = function( v1, v2 ){
+		return ( parseFloat(v1) === parseFloat(v2) );
+	};
+	
+	var isGreaterThan = function( v1, v2 ){
+		return ( parseFloat(v1) > parseFloat(v2) );
+	};
+	
+	var isLessThan = function( v1, v2 ){
+		return ( parseFloat(v1) < parseFloat(v2) );
+	};
+	
+	var inArray = function( v1, array ){
+		
+		// cast all values as string
+		array = array.map(function(v2){
+			return parseString(v2);
+		});
+		
+		return (array.indexOf( v1 ) > -1);
+	}
+	
+	var containsString = function( haystack, needle ){
+		return ( parseString(haystack).indexOf( parseString(needle) ) > -1 );
+	};
+	
+	var matchesPattern = function( v1, pattern ){
+		var regexp = new RegExp(parseString(pattern), 'gi');
+		return parseString(v1).match( regexp );
+	};
+	
+	/**
+	*  hasValue
+	*
+	*  description
+	*
+	*  @date	1/2/18
+	*  @since	5.6.5
+	*
+	*  @param	void
+	*  @return	void
+	*/
+	
+	var HasValue = acf.Condition.extend({
+		type: 'hasValue',
+		operator: '!=empty',
+		label: __('Has any value'),
+		fieldTypes: [ 'text', 'textarea', 'number', 'range', 'email', 'url', 'password', 'image', 'file', 'wysiwyg', 'oembed', 'select', 'checkbox', 'radio', 'button_group', 'link', 'post_object', 'page_link', 'relationship', 'taxonomy', 'user', 'google_map', 'date_picker', 'date_time_picker', 'time_picker', 'color_picker' ],
+		match: function( rule, field ){
+			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( $.isNumeric(rule.value) ) {
+				return isEqualToNumber( rule.value, field.val() );
+			} else {
+				return isEqualTo( rule.value, field.val() );
+			}
+		},
+		choices: function( fieldObject ){
+			return '<input type="text" />';
+		}
+	});
+	
+	acf.registerConditionType( EqualTo );
+	
+	/**
+	*  NotEqualTo
+	*
+	*  description
+	*
+	*  @date	1/2/18
+	*  @since	5.6.5
+	*
+	*  @param	void
+	*  @return	void
+	*/
+	
+	var NotEqualTo = EqualTo.extend({
+		type: 'notEqualTo',
+		operator: '!=',
+		label: __('Value is not equal to'),
+		match: function( rule, field ){
+			return !EqualTo.prototype.match.apply(this, arguments);
+		}
+	});
+	
+	acf.registerConditionType( NotEqualTo );
+	
+	/**
+	*  PatternMatch
+	*
+	*  description
+	*
+	*  @date	1/2/18
+	*  @since	5.6.5
+	*
+	*  @param	void
+	*  @return	void
+	*/
+	
+	var PatternMatch = acf.Condition.extend({
+		type: 'patternMatch',
+		operator: '==pattern',
+		label: __('Value matches pattern'),
+		fieldTypes: [ 'text', 'textarea', 'email', 'url', 'password', 'wysiwyg' ],
+		match: function( rule, field ){
+			return matchesPattern( field.val(), rule.value );
+		},
+		choices: function( fieldObject ){
+			return '<input type="text" placeholder="[a-z0-9]" />';
+		}
+	});
+	
+	acf.registerConditionType( PatternMatch );
+	
+	/**
+	*  Contains
+	*
+	*  description
+	*
+	*  @date	1/2/18
+	*  @since	5.6.5
+	*
+	*  @param	void
+	*  @return	void
+	*/
+	
+	var Contains = acf.Condition.extend({
+		type: 'contains',
+		operator: '==contains',
+		label: __('Value contains'),
+		fieldTypes: [ 'text', 'textarea', 'number', 'email', 'url', 'password', 'wysiwyg', 'oembed', 'select' ],
+		match: function( rule, field ){
+			return containsString( field.val(), rule.value );
+		},
+		choices: function( fieldObject ){
+			return '<input type="text" />';
+		}
+	});
+	
+	acf.registerConditionType( Contains );
+	
+	/**
+	*  TrueFalseEqualTo
+	*
+	*  description
+	*
+	*  @date	1/2/18
+	*  @since	5.6.5
+	*
+	*  @param	void
+	*  @return	void
+	*/
+	
+	var TrueFalseEqualTo = EqualTo.extend({
+		type: 'trueFalseEqualTo',
+		choiceType: 'select',
+		fieldTypes: [ 'true_false' ],
+		choices: function( field ){
+			return [
+				{
+					id:		1,
+					text:	__('Checked')
+				}
+			];
+		},
+	});
+	
+	acf.registerConditionType( TrueFalseEqualTo );
+	
+	/**
+	*  TrueFalseNotEqualTo
+	*
+	*  description
+	*
+	*  @date	1/2/18
+	*  @since	5.6.5
+	*
+	*  @param	void
+	*  @return	void
+	*/
+	
+	var TrueFalseNotEqualTo = NotEqualTo.extend({
+		type: 'trueFalseNotEqualTo',
+		choiceType: 'select',
+		fieldTypes: [ 'true_false' ],
+		choices: function( field ){
+			return [
+				{
+					id:		1,
+					text:	__('Checked')
+				}
+			];
+		},
+	});
+	
+	acf.registerConditionType( TrueFalseNotEqualTo );
+	
+	/**
+	*  SelectEqualTo
+	*
+	*  description
+	*
+	*  @date	1/2/18
+	*  @since	5.6.5
+	*
+	*  @param	void
+	*  @return	void
+	*/
+	
+	var SelectEqualTo = acf.Condition.extend({
+		type: 'selectEqualTo',
+		operator: '==',
+		label: __('Value is equal to'),
+		fieldTypes: [ 'select', 'checkbox', 'radio', 'button_group' ],
+		match: function( rule, field ){
+			var val = field.val();
+			if( val instanceof Array ) {
+				return inArray( rule.value, val );
+			} else {
+				return isEqualTo( rule.value, val );
+			}
+		},
+		choices: function( fieldObject ){
+			
+			// vars
+			var choices = [];
+			var lines = fieldObject.$setting('choices textarea').val().split("\n");	
+			
+			// allow null
+			if( fieldObject.$input('allow_null').prop('checked') ) {
+				choices.push({
+					id: '',
+					text: __('Null')
+				});
+			}
+			
+			// loop
+			lines.map(function( line ){
+				
+				// split
+				line = line.split(':');
+				
+				// default label to value
+				line[1] = line[1] || line[0];
+				
+				// append					
+				choices.push({
+					id: $.trim( line[0] ),
+					text: $.trim( line[1] )
+				});
+			});
+			
+			// 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);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-condition.js

@@ -0,0 +1,249 @@
+(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);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-conditions.js

@@ -0,0 +1,306 @@
+(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);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-field-accordion.js

@@ -0,0 +1,232 @@
+(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 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 ){
+			
+			// Determine icon.
+			//if( acf.isGutenberg() ) {
+			//	var icon = props.open ? 'arrow-up-alt2' : 'arrow-down-alt2';
+			//} else {
+				var icon = props.open ? 'arrow-down' : 'arrow-right';
+			//}
+			
+			// Return HTML.
+			return '<i class="acf-accordion-icon dashicons dashicons-' + icon + '"></i>';
+		},
+		
+		open: function( $el ){
+			
+			// open
+			$el.find('.acf-accordion-content:first').slideDown().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 ){
+			
+			// close
+			$el.find('.acf-accordion-content:first').slideUp();
+			$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);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-field-button-group.js

@@ -0,0 +1,45 @@
+(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);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-field-checkbox.js

@@ -0,0 +1,97 @@
+(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 $toggle = this.$toggle();
+			
+			// selected
+			if( checked ) {
+				$el.parent().addClass('selected');
+			} else {
+				$el.parent().removeClass('selected');
+			}
+			
+			// determine 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 ){
+			var checked = $el.prop('checked');
+			var $inputs = this.$inputs();
+			$inputs.prop('checked', checked);
+		},
+		
+		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);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-field-color-picker.js

@@ -0,0 +1,64 @@
+(function($, undefined){
+	
+	var Field = acf.Field.extend({
+		
+		type: 'color_picker',
+		
+		wait: 'load',
+		
+		$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 );
+		}
+	});
+	
+	acf.registerFieldType( Field );
+	
+})(jQuery);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-field-date-picker.js

@@ -0,0 +1,157 @@
+(function($, undefined){
+	
+	var Field = acf.Field.extend({
+		
+		type: 'date_picker',
+		
+		events: {
+			'blur input[type="text"]': 'onBlur'
+		},
+		
+		$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(), '' );
+			}
+		}
+	});
+	
+	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);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-field-date-time-picker.js

@@ -0,0 +1,99 @@
+(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);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-field-file.js

@@ -0,0 +1,120 @@
+(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);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-field-google-map.js

@@ -0,0 +1,553 @@
+(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');
+		},
+		
+		$input: function( name ){
+			return this.$('input[data-name="' + (name || 'address') + '"]');
+		},
+		
+		$search: function(){
+			return this.$('.search');
+		},
+		
+		$canvas: function(){
+			return this.$('.canvas');
+		},
+		
+		addClass: function( name ){
+			this.$control().addClass( name );
+		},
+		
+		removeClass: function( name ){
+			this.$control().removeClass( name );
+		},
+		
+		getValue: function(){
+			
+			// defaults
+			var val = {
+				lat: '',
+				lng: '',
+				address: ''
+			};
+			
+			// loop
+			this.$('input[type="hidden"]').each(function(){
+				val[ $(this).data('name') ] = $(this).val();
+			});
+			
+			// return false if no lat/lng
+			if( !val.lat || !val.lng ) {
+				val = false;
+			}
+			
+			// return
+			return val;
+		},
+		
+		setValue: function( val ){
+			
+			// defaults
+			val = acf.parseArgs(val, {
+				lat: '',
+				lng: '',
+				address: ''
+			});
+			
+			// loop
+			for( var name in val ) {
+				acf.val( this.$input(name), val[name] );
+			}
+			
+			// return false if no lat/lng
+			if( !val.lat || !val.lng ) {
+				val = false;
+			}
+			
+			// render
+			this.renderVal( val );
+			
+			// action
+			var latLng = this.newLatLng( val.lat, val.lng );
+			acf.doAction('google_map_change', latLng, this.map, this);
+		},
+		
+		renderVal: function( val ){
+			
+		    // has value
+		    if( val ) {
+			     this.addClass('-value');
+			     this.setPosition( val.lat, val.lng );
+			     this.map.marker.setVisible( true );
+			     
+		    // no value
+		    } else {
+			     this.removeClass('-value');
+			     this.map.marker.setVisible( false );
+		    }
+		    
+		    // search
+		    this.$search().val( val.address );
+		},
+		
+		setPosition: function( lat, lng ){
+			
+			// vars
+			var latLng = this.newLatLng( lat, lng );
+			
+			// update marker
+			this.map.marker.setPosition( latLng );
+			
+			// show marker
+			this.map.marker.setVisible( true );
+			
+			// center
+			this.center();
+			
+			// return
+			return this;
+		},
+		
+		center: function(){
+			
+			// vars
+			var position = this.map.marker.getPosition();
+			var lat = this.get('lat');
+			var lng = this.get('lng');
+			
+			// if marker exists, center on the marker
+			if( position ) {
+				lat = position.lat();
+				lng = position.lng();
+			}
+			
+			// latlng
+			var latLng = this.newLatLng( lat, lng );
+				
+			// set center of map
+	        this.map.setCenter( latLng );
+		},
+		
+		getSearchVal: function(){
+			return this.$search().val();
+		},
+		
+		initialize: function(){
+			
+			// Ensure Google API is loaded and then initialize map.
+			withAPI( this.initializeMap.bind(this) );
+		},
+		
+		newLatLng: function( lat, lng ){
+			return new google.maps.LatLng( parseFloat(lat), parseFloat(lng) );
+		},
+		
+		initializeMap: function(){
+			
+			// vars
+			var zoom = this.get('zoom');
+			var lat = this.get('lat');
+			var lng = this.get('lng');
+			
+			// Create Map.
+			var mapArgs = {
+				scrollwheel:	false,
+        		zoom:			parseInt( zoom ),
+        		center:			this.newLatLng(lat, 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;
+        	
+        	// action for 3rd party customization
+			acf.doAction('google_map_init', map, marker, this);
+        	
+        	// set position
+		    var val = this.getValue();
+		    this.renderVal( val );
+		},
+		
+		addMapEvents: function( field, map, marker, autocomplete ){
+			
+			// Click map.
+	        google.maps.event.addListener( map, 'click', function( e ) {
+		        
+				// vars
+				var lat = e.latLng.lat();
+				var lng = e.latLng.lng();
+				
+				 // search
+				field.searchPosition( lat, lng );
+			});
+			
+			// Drag marker.
+		    google.maps.event.addListener( marker, 'dragend', function(){
+			    
+		    	// vars
+				var position = this.getPosition();
+				var lat = position.lat();
+			    var lng = position.lng();
+			    
+			    // search
+				field.searchPosition( lat, lng );
+			});
+			
+			// Autocomplete search.
+	        if( autocomplete ) {
+		        
+				// autocomplete event place_changed is triggered each time the input changes
+				// customize the place object with the current "search value" to allow users controll over the address text
+				google.maps.event.addListener(autocomplete, 'place_changed', function() {
+					var place = this.getPlace();
+					place.address = field.getSearchVal();
+				    field.setPlace( place );
+				});
+	        }
+		},
+		
+		searchPosition: function( lat, lng ){
+			
+			// vars
+			var latLng = this.newLatLng( lat, lng );
+			var $wrap = this.$control();
+			
+			// set position
+			this.setPosition( lat, lng );
+			
+			// add class
+		    $wrap.addClass('-loading');
+		    
+		    // callback
+		    var callback = $.proxy(function( results, status ){
+			    
+			    // remove class
+			    $wrap.removeClass('-loading');
+			    
+			    // vars
+			    var address = '';
+			    
+			    // validate
+				if( status != google.maps.GeocoderStatus.OK ) {
+					console.log('Geocoder failed due to: ' + status);
+				} else if( !results[0] ) {
+					console.log('No results found');
+				} else {
+					address = results[0].formatted_address;
+				}
+				
+				// update val
+				this.val({
+					lat: lat,
+					lng: lng,
+					address: address
+				});
+				
+		    }, this);
+		    
+		    // query
+		    geocoder.geocode({ 'latLng' : latLng }, callback);
+		},
+		
+		setPlace: function( place ){
+			
+			// bail if no place
+			if( !place ) return this;
+			
+			// search name if no geometry
+			// - possible when hitting enter in search address
+			if( place.name && !place.geometry ) {
+				this.searchAddress(place.name);
+				return this;
+			}
+			
+			// vars
+			var lat = place.geometry.location.lat();
+			var lng = place.geometry.location.lng();
+			var address = place.address || place.formatted_address;
+			
+			// update
+			this.setValue({
+				lat: lat,
+				lng: lng,
+				address: address
+			});
+			
+		    // return
+		    return this;
+		},
+		
+		searchAddress: function( address ){
+			
+		    // is address latLng?
+		    var latLng = address.split(',');
+		    if( latLng.length == 2 ) {
+			    
+			    // vars
+			    var lat = latLng[0];
+				var lng = latLng[1];
+			    
+				// check
+			    if( $.isNumeric(lat) && $.isNumeric(lng) ) {
+				    return this.searchPosition( lat, lng );
+			    }
+		    }
+		    
+		    // vars
+		    var $wrap = this.$control();
+		    
+		    // add class
+		    $wrap.addClass('-loading');
+		    
+		    // callback
+		    var callback = this.proxy(function( results, status ){
+			    
+			    // remove class
+			    $wrap.removeClass('-loading');
+			    
+			    // vars
+			    var lat = '';
+			    var lng = '';
+			    
+			    // validate
+				if( status != google.maps.GeocoderStatus.OK ) {
+					console.log('Geocoder failed due to: ' + status);
+				} else if( !results[0] ) {
+					console.log('No results found');
+				} else {
+					lat = results[0].geometry.location.lat();
+					lng = results[0].geometry.location.lng();
+					//address = results[0].formatted_address;
+				}
+				
+				// update val
+				this.val({
+					lat: lat,
+					lng: lng,
+					address: address
+				});
+				
+				//acf.doAction('google_map_geocode_results', results, status, this.$el, this);
+				
+		    });
+		    
+		    // query
+		    geocoder.geocode({ 'address' : address }, callback);
+		},
+		
+		searchLocation: function(){
+			
+			// Try HTML5 geolocation
+			if( !navigator.geolocation ) {
+				return alert( acf.__('Sorry, this browser does not support geolocation') );
+			}
+			
+			// vars
+		    var $wrap = this.$control();
+			
+			// add class
+		    $wrap.addClass('-loading');
+		    
+		    // callback
+		    var onSuccess = $.proxy(function( results, status ){
+			    
+			    // remove class
+			    $wrap.removeClass('-loading');
+			    
+			    // vars
+				var lat = results.coords.latitude;
+			    var lng = results.coords.longitude;
+			    
+			    // search;
+			    this.searchPosition( lat, lng );
+				
+		    }, this);
+		    
+		    var onFailure = function( error ){
+			    $wrap.removeClass('-loading');
+		    }
+		    
+		    // try query
+			navigator.geolocation.getCurrentPosition( onSuccess, onFailure );
+		},
+		
+		onClickClear: function( e, $el ){
+			this.val( false );
+		},
+		
+		onClickLocate: function( e, $el ){
+			this.searchLocation();
+		},
+		
+		onClickSearch: function( e, $el ){
+			this.searchAddress( this.$search().val() );
+		},
+		
+		onFocusSearch: function( e, $el ){
+			this.removeClass('-value');
+			this.onKeyupSearch.apply(this, arguments);
+		},
+		
+		onBlurSearch: function( e, $el ){
+			
+			// timeout to allow onClickLocate event
+			this.setTimeout(function(){
+				this.removeClass('-search');
+				if( $el.val() ) {
+					this.addClass('-value');
+				}
+			}, 100);			
+		},
+		
+		onKeyupSearch: function( e, $el ){
+			if( $el.val() ) {
+				this.addClass('-search');
+			} else {
+				this.removeClass('-search');
+			}
+		},
+		
+		onKeydownSearch: function( e, $el ){
+			
+			// prevent form from submitting
+			if( e.which == 13 ) {
+				e.preventDefault();
+			}
+		},
+		
+		onMousedown: function(){
+			
+/*
+			// clear timeout in 1ms (onMousedown will run before onBlurSearch)
+			this.setTimeout(function(){
+				clearTimeout( this.get('timeout') );
+			}, 1);
+*/
+		},
+		
+		onShow: function(){
+			
+			// bail early if no map
+			// - possible if JS API was not loaded
+			if( !this.map ) {
+				return false;
+			}
+			
+			// center map when it is shown (by a tab / collapsed row)
+			// - use delay to avoid rendering issues with browsers (ensures div is visible)
+			this.setTimeout( this.center, 10 );
+		}
+	});
+	
+	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);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-field-image.js

@@ -0,0 +1,198 @@
+(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 ){
+			
+			// defaults
+			attachment = attachment || {};
+			
+			// WP attachment
+			if( attachment.id !== undefined ) {
+				attachment = attachment.attributes;
+			}
+			
+			// args
+			attachment = acf.parseArgs(attachment, {
+				url: '',
+				alt: '',
+				title: '',
+				caption: '',
+				description: '',
+				width: 0,
+				height: 0
+			});
+			
+			// preview size
+			var url = acf.isget(attachment, 'sizes', this.get('preview_size'), 'url');
+			if( url !== null ) {
+				attachment.url = url;
+			}
+			
+			// return
+			return attachment;
+		},
+		
+		render: function( attachment ){
+			
+			// vars
+			attachment = this.validateAttachment( attachment );
+			
+			// update image
+		 	this.$('img').attr({
+			 	src: attachment.url,
+			 	alt: attachment.alt,
+			 	title: attachment.title
+		 	});
+		 	
+			// vars
+			var val = attachment.id || '';
+						
+			// update val
+			this.val( val );
+		 	
+		 	// update class
+		 	if( val ) {
+			 	this.$control().addClass('has-value');
+		 	} else {
+			 	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);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-field-link.js

@@ -0,0 +1,191 @@
+(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:	$node.html(),
+				url:	$node.attr('href'),
+				target:	$node.attr('target')
+			};
+		},
+		
+		setNodeValue: function( val ){
+			var $node = this.get('node');
+			$node.html( 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 );
+		},
+		
+		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;
+			}
+			
+			// remove events
+			this.off('wplink-open');
+			this.off('wplink-close');
+			
+			// set value
+			var val = this.getInputValue();
+			this.setNodeValue( val );
+			
+			// remove textarea
+			$('#acf-link-textarea').remove();
+			
+			// reset
+			this.set('node', null);
+			
+		}
+	});	
+
+})(jQuery);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-field-oembed.js

@@ -0,0 +1,163 @@
+(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);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-field-page-link.js

@@ -0,0 +1,9 @@
+(function($, undefined){
+	
+	var Field = acf.models.SelectField.extend({
+		type: 'page_link',	
+	});
+	
+	acf.registerFieldType( Field );
+	
+})(jQuery);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-field-post-object.js

@@ -0,0 +1,9 @@
+(function($, undefined){
+	
+	var Field = acf.models.SelectField.extend({
+		type: 'post_object',	
+	});
+	
+	acf.registerFieldType( Field );
+	
+})(jQuery);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-field-radio.js

@@ -0,0 +1,68 @@
+(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);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-field-range.js

@@ -0,0 +1,42 @@
+(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);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-field-relationship.js

@@ -0,0 +1,380 @@
+(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',
+			'mouseover': 							'onHover'
+		},
+		
+		$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('');
+		},
+		
+		addSortable: function( self ){
+			
+			// sortable
+			this.$list('values').sortable({
+				items:					'li',
+				forceHelperSize:		true,
+				forcePlaceholderSize:	true,
+				scroll:					true,
+				update:	function(){
+					self.$input().trigger('change');
+				}
+			});
+		},
+		
+		initialize: function(){
+			
+			// scroll
+			var onScroll = this.proxy(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();
+				}
+				
+			});
+			
+			this.$list('choices').scrollTop(0).on('scroll', onScroll);
+			
+			// fetch
+			this.fetch();
+		},
+		
+		onHover: function( e ){
+			
+			// only once
+			$().off(e);
+			
+			// add sortable
+			this.addSortable( this );
+		},
+		
+		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">' + 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="' + data.id + '">' + data.text + '</span></li>';
+					}
+				}
+				
+				// return
+				return html;
+			};
+			
+			return walk( data );
+		}
+		
+	});
+	
+	acf.registerFieldType( Field );
+	
+})(jQuery);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-field-select.js

@@ -0,0 +1,57 @@
+(function($, undefined){
+	
+	var Field = acf.Field.extend({
+		
+		type: 'select',
+		
+		select2: false,
+		
+		wait: 'load',
+		
+		events: {
+			'removeField': 'onRemove'
+		},
+		
+		$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();
+			}
+		}
+	});
+	
+	acf.registerFieldType( Field );
+	
+})(jQuery);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-field-tab.js

@@ -0,0 +1,505 @@
+(function($, undefined){
+	
+	// vars
+	var CONTEXT = 'tab';
+	
+	var Field = acf.Field.extend({
+		
+		type: 'tab',
+		
+		wait: '',
+		
+		tabs: false,
+		
+		tab: false,
+		
+		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 );		
+			});
+		}
+	});
+	
+	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></li>');
+			
+			// append <a>
+			$li.append( $a );
+			
+			// 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);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-field-taxonomy.js

@@ -0,0 +1,321 @@
+(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',
+		},
+		
+		$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(){
+			if( this.select2 ) {
+				this.select2.destroy();
+			}
+		},
+		
+		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.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.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.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);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-field-time-picker.js

@@ -0,0 +1,77 @@
+(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);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-field-true-false.js

@@ -0,0 +1,95 @@
+(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);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-field-url.js

@@ -0,0 +1,64 @@
+(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);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-field-user.js

@@ -0,0 +1,9 @@
+(function($, undefined){
+	
+	var Field = acf.models.SelectField.extend({
+		type: 'user',	
+	});
+	
+	acf.registerFieldType( Field );
+	
+})(jQuery);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-field-wysiwyg.js

@@ -0,0 +1,102 @@
+(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-');
+			
+			// store copy of textarea data
+			var data = $textarea.data();
+			
+			// rename
+			acf.rename({
+				target: $wrap,
+				search: oldId,
+				replace: newId,
+				destructive: true
+			});	
+			
+			// update id
+			this.set('id', newId, true);
+			
+			// initialize
+			acf.tinymce.initialize( newId, args );
+			
+			// 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(data);
+		},
+		
+		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);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-field.js

@@ -0,0 +1,524 @@
+(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 ){
+			if( val !== undefined ) {
+				return this.setValue( val );
+			} 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);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-fields.js

@@ -0,0 +1,372 @@
+(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' ];
+	var singleFieldEvents = [ 'remove', 'unmount', 'remount', 'sortstart', 'sortstop', 'show', 'hide', 'unload', 'valid', 'invalid', 'enable', 'disable' ];
+	
+	// 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);
+		}
+	});
+	
+})(jQuery);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-helpers.js

@@ -0,0 +1,361 @@
+(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,
+		timeout: 0,
+		actions: {
+			'new_field':	'refresh',
+			'show_field':	'refresh',
+			'hide_field':	'refresh',
+			'remove_field':	'refresh'
+		},
+		refresh: function(){
+			clearTimeout( this.timeout );
+			this.timeout = setTimeout(function(){
+				acf.doAction('refresh');
+			}, 0);
+		}
+	});
+	
+	/**
+	 * 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'});
+			}
+		}
+	});
+		
+})(jQuery);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-hooks.js

@@ -0,0 +1,252 @@
+( function( window, undefined ) {
+	"use strict";
+
+	/**
+	 * Handles managing all events for whatever you plug it into. Priorities for hooks are based on lowest to highest in
+	 * that, lowest priority hooks are fired first.
+	 */
+	var EventManager = function() {
+		/**
+		 * Maintain a reference to the object scope so our public methods never get confusing.
+		 */
+		var MethodsAvailable = {
+			removeFilter : removeFilter,
+			applyFilters : applyFilters,
+			addFilter : addFilter,
+			removeAction : removeAction,
+			doAction : doAction,
+			addAction : addAction,
+			storage : getStorage
+		};
+
+		/**
+		 * Contains the hooks that get registered with this EventManager. The array for storage utilizes a "flat"
+		 * object literal such that looking up the hook utilizes the native object literal hash.
+		 */
+		var STORAGE = {
+			actions : {},
+			filters : {}
+		};
+		
+		function getStorage() {
+			
+			return STORAGE;
+			
+		};
+		
+		/**
+		 * Adds an action to the event manager.
+		 *
+		 * @param action Must contain namespace.identifier
+		 * @param callback Must be a valid callback function before this action is added
+		 * @param [priority=10] Used to control when the function is executed in relation to other callbacks bound to the same hook
+		 * @param [context] Supply a value to be used for this
+		 */
+		function addAction( action, callback, priority, context ) {
+			if( typeof action === 'string' && typeof callback === 'function' ) {
+				priority = parseInt( ( priority || 10 ), 10 );
+				_addHook( 'actions', action, callback, priority, context );
+			}
+
+			return MethodsAvailable;
+		}
+
+		/**
+		 * Performs an action if it exists. You can pass as many arguments as you want to this function; the only rule is
+		 * that the first argument must always be the action.
+		 */
+		function doAction( /* action, arg1, arg2, ... */ ) {
+			var args = Array.prototype.slice.call( arguments );
+			var action = args.shift();
+
+			if( typeof action === 'string' ) {
+				_runHook( 'actions', action, args );
+			}
+
+			return MethodsAvailable;
+		}
+
+		/**
+		 * Removes the specified action if it contains a namespace.identifier & exists.
+		 *
+		 * @param action The action to remove
+		 * @param [callback] Callback function to remove
+		 */
+		function removeAction( action, callback ) {
+			if( typeof action === 'string' ) {
+				_removeHook( 'actions', action, callback );
+			}
+
+			return MethodsAvailable;
+		}
+
+		/**
+		 * Adds a filter to the event manager.
+		 *
+		 * @param filter Must contain namespace.identifier
+		 * @param callback Must be a valid callback function before this action is added
+		 * @param [priority=10] Used to control when the function is executed in relation to other callbacks bound to the same hook
+		 * @param [context] Supply a value to be used for this
+		 */
+		function addFilter( filter, callback, priority, context ) {
+			if( typeof filter === 'string' && typeof callback === 'function' ) {
+				priority = parseInt( ( priority || 10 ), 10 );
+				_addHook( 'filters', filter, callback, priority, context );
+			}
+
+			return MethodsAvailable;
+		}
+
+		/**
+		 * Performs a filter if it exists. You should only ever pass 1 argument to be filtered. The only rule is that
+		 * the first argument must always be the filter.
+		 */
+		function applyFilters( /* filter, filtered arg, arg2, ... */ ) {
+			var args = Array.prototype.slice.call( arguments );
+			var filter = args.shift();
+
+			if( typeof filter === 'string' ) {
+				return _runHook( 'filters', filter, args );
+			}
+
+			return MethodsAvailable;
+		}
+
+		/**
+		 * Removes the specified filter if it contains a namespace.identifier & exists.
+		 *
+		 * @param filter The action to remove
+		 * @param [callback] Callback function to remove
+		 */
+		function removeFilter( filter, callback ) {
+			if( typeof filter === 'string') {
+				_removeHook( 'filters', filter, callback );
+			}
+
+			return MethodsAvailable;
+		}
+
+		/**
+		 * Removes the specified hook by resetting the value of it.
+		 *
+		 * @param type Type of hook, either 'actions' or 'filters'
+		 * @param hook The hook (namespace.identifier) to remove
+		 * @private
+		 */
+		function _removeHook( type, hook, callback, context ) {
+			if ( !STORAGE[ type ][ hook ] ) {
+				return;
+			}
+			if ( !callback ) {
+				STORAGE[ type ][ hook ] = [];
+			} else {
+				var handlers = STORAGE[ type ][ hook ];
+				var i;
+				if ( !context ) {
+					for ( i = handlers.length; i--; ) {
+						if ( handlers[i].callback === callback ) {
+							handlers.splice( i, 1 );
+						}
+					}
+				}
+				else {
+					for ( i = handlers.length; i--; ) {
+						var handler = handlers[i];
+						if ( handler.callback === callback && handler.context === context) {
+							handlers.splice( i, 1 );
+						}
+					}
+				}
+			}
+		}
+
+		/**
+		 * Adds the hook to the appropriate storage container
+		 *
+		 * @param type 'actions' or 'filters'
+		 * @param hook The hook (namespace.identifier) to add to our event manager
+		 * @param callback The function that will be called when the hook is executed.
+		 * @param priority The priority of this hook. Must be an integer.
+		 * @param [context] A value to be used for this
+		 * @private
+		 */
+		function _addHook( type, hook, callback, priority, context ) {
+			var hookObject = {
+				callback : callback,
+				priority : priority,
+				context : context
+			};
+
+			// Utilize 'prop itself' : http://jsperf.com/hasownproperty-vs-in-vs-undefined/19
+			var hooks = STORAGE[ type ][ hook ];
+			if( hooks ) {
+				hooks.push( hookObject );
+				hooks = _hookInsertSort( hooks );
+			}
+			else {
+				hooks = [ hookObject ];
+			}
+
+			STORAGE[ type ][ hook ] = hooks;
+		}
+
+		/**
+		 * Use an insert sort for keeping our hooks organized based on priority. This function is ridiculously faster
+		 * than bubble sort, etc: http://jsperf.com/javascript-sort
+		 *
+		 * @param hooks The custom array containing all of the appropriate hooks to perform an insert sort on.
+		 * @private
+		 */
+		function _hookInsertSort( hooks ) {
+			var tmpHook, j, prevHook;
+			for( var i = 1, len = hooks.length; i < len; i++ ) {
+				tmpHook = hooks[ i ];
+				j = i;
+				while( ( prevHook = hooks[ j - 1 ] ) &&  prevHook.priority > tmpHook.priority ) {
+					hooks[ j ] = hooks[ j - 1 ];
+					--j;
+				}
+				hooks[ j ] = tmpHook;
+			}
+
+			return hooks;
+		}
+
+		/**
+		 * Runs the specified hook. If it is an action, the value is not modified but if it is a filter, it is.
+		 *
+		 * @param type 'actions' or 'filters'
+		 * @param hook The hook ( namespace.identifier ) to be ran.
+		 * @param args Arguments to pass to the action/filter. If it's a filter, args is actually a single parameter.
+		 * @private
+		 */
+		function _runHook( type, hook, args ) {
+			var handlers = STORAGE[ type ][ hook ];
+			
+			if ( !handlers ) {
+				return (type === 'filters') ? args[0] : false;
+			}
+
+			var i = 0, len = handlers.length;
+			if ( type === 'filters' ) {
+				for ( ; i < len; i++ ) {
+					args[ 0 ] = handlers[ i ].callback.apply( handlers[ i ].context, args );
+				}
+			} else {
+				for ( ; i < len; i++ ) {
+					handlers[ i ].callback.apply( handlers[ i ].context, args );
+				}
+			}
+
+			return ( type === 'filters' ) ? args[ 0 ] : true;
+		}
+
+		// return all of the publicly available methods
+		return MethodsAvailable;
+
+	};
+	
+	// instantiate
+	acf.hooks = new EventManager();
+
+} )( window );

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-media.js

@@ -0,0 +1,832 @@
+(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 $.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"><span class="acf-icon -left small grey"></span>' + acf.__('Expand Details') +  '</span>',
+							'<span class="is-open"><span class="acf-icon -right small grey"></span>' + 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);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-model.js

@@ -0,0 +1,908 @@
+(function($, undefined){
+	
+	// Cached regex to split keys for `addEvent`.
+	var delegateEventSplitter = /^(\S+)\s*(.*)$/;
+  
+	/**
+	*  extend
+	*
+	*  Helper function to correctly set up the prototype chain for subclasses
+	*  Heavily inspired by backbone.js
+	*
+	*  @date	14/12/17
+	*  @since	5.6.5
+	*
+	*  @param	object protoProps New properties for this object.
+	*  @return	function.
+	*/
+	
+	var extend = function( protoProps ) {
+		
+		// vars
+		var Parent = this;
+		var Child;
+		
+	    // The constructor function for the new subclass is either defined by you
+	    // (the "constructor" property in your `extend` definition), or defaulted
+	    // by us to simply call the parent constructor.
+	    if( protoProps && protoProps.hasOwnProperty('constructor') ) {
+	      Child = protoProps.constructor;
+	    } else {
+	      Child = function(){ return Parent.apply(this, arguments); };
+	    }
+	    
+		// Add static properties to the constructor function, if supplied.
+		$.extend(Child, Parent);
+		
+		// Set the prototype chain to inherit from `parent`, without calling
+		// `parent`'s constructor function and add the prototype properties.
+		Child.prototype = Object.create(Parent.prototype);
+		$.extend(Child.prototype, protoProps);
+		Child.prototype.constructor = Child;
+		
+		// Set a convenience property in case the parent's prototype is needed later.
+	    //Child.prototype.__parent__ = Parent.prototype;
+
+	    // return
+		return Child;
+		
+	};
+	
+
+	/**
+	*  Model
+	*
+	*  Base class for all inheritence
+	*
+	*  @date	14/12/17
+	*  @since	5.6.5
+	*
+	*  @param	object props
+	*  @return	function.
+	*/
+	
+	var Model = acf.Model = function(){
+		
+		// generate uique client id
+		this.cid = acf.uniqueId('acf');
+		
+		// set vars to avoid modifying prototype
+		this.data = $.extend(true, {}, this.data);
+		
+		// pass props to setup function
+		this.setup.apply(this, arguments);
+		
+		// store on element (allow this.setup to create this.$el)
+		if( this.$el && !this.$el.data('acf') ) {
+			this.$el.data('acf', this);
+		}
+		
+		// initialize
+		var initialize = function(){
+			this.initialize();
+			this.addEvents();
+			this.addActions();
+			this.addFilters();
+		};
+		
+		// initialize on action
+		if( this.wait && !acf.didAction(this.wait) ) {
+			this.addAction(this.wait, initialize);
+		
+		// initialize now
+		} else {
+			initialize.apply(this);
+		}
+	};
+	
+	// Attach all inheritable methods to the Model prototype.
+	$.extend(Model.prototype, {
+		
+		// Unique model id
+		id: '',
+		
+		// Unique client id
+		cid: '',
+		
+		// jQuery element
+		$el: null,
+		
+		// Data specific to this instance
+		data: {},
+		
+		// toggle used when changing data
+		busy: false,
+		changed: false,
+		
+		// Setup events hooks
+		events: {},
+		actions: {},
+		filters: {},
+		
+		// class used to avoid nested event triggers
+		eventScope: '',
+		
+		// action to wait until initialize
+		wait: false,
+		
+		// action priority default
+		priority: 10,
+		
+		/**
+		*  get
+		*
+		*  Gets a specific data value
+		*
+		*  @date	14/12/17
+		*  @since	5.6.5
+		*
+		*  @param	string name
+		*  @return	mixed
+		*/
+		
+		get: function( name ) {
+			return this.data[name];
+		},
+		
+		/**
+		*  has
+		*
+		*  Returns `true` if the data exists and is not null
+		*
+		*  @date	14/12/17
+		*  @since	5.6.5
+		*
+		*  @param	string name
+		*  @return	boolean
+		*/
+		
+		has: function( name ) {
+			return this.get(name) != null;
+		},
+		
+		/**
+		*  set
+		*
+		*  Sets a specific data value
+		*
+		*  @date	14/12/17
+		*  @since	5.6.5
+		*
+		*  @param	string name
+		*  @param	mixed value
+		*  @return	this
+		*/
+		
+		set: function( name, value, silent ) {
+			
+			// bail if unchanged
+			var prevValue = this.get(name);
+			if( prevValue == value ) {
+				return this;
+			}
+			
+			// set data
+			this.data[ name ] = value;
+			
+			// trigger events
+			if( !silent ) {
+				this.changed = true;
+				this.trigger('changed:' + name, [value, prevValue]);
+				this.trigger('changed', [name, value, prevValue]);
+			}
+			
+			// return
+			return this;
+		},
+		
+		/**
+		*  inherit
+		*
+		*  Inherits the data from a jQuery element
+		*
+		*  @date	14/12/17
+		*  @since	5.6.5
+		*
+		*  @param	jQuery $el
+		*  @return	this
+		*/
+		
+		inherit: function( data ){
+			
+			// allow jQuery
+			if( data instanceof jQuery ) {
+				data = data.data();
+			}
+			
+			// extend
+			$.extend(this.data, data);
+			
+			// return
+			return this;
+		},
+		
+		/**
+		*  prop
+		*
+		*  mimics the jQuery prop function
+		*
+		*  @date	4/6/18
+		*  @since	5.6.9
+		*
+		*  @param	type $var Description. Default.
+		*  @return	type Description.
+		*/
+		
+		prop: function(){
+			return this.$el.prop.apply(this.$el, arguments);
+		},
+		
+		/**
+		*  setup
+		*
+		*  Run during constructor function
+		*
+		*  @date	14/12/17
+		*  @since	5.6.5
+		*
+		*  @param	n/a
+		*  @return	n/a
+		*/
+		
+		setup: function( props ){
+			$.extend(this, props);
+		},
+		
+		/**
+		*  initialize
+		*
+		*  Also run during constructor function
+		*
+		*  @date	14/12/17
+		*  @since	5.6.5
+		*
+		*  @param	n/a
+		*  @return	n/a
+		*/
+		
+		initialize: function(){},
+		
+		/**
+		*  addElements
+		*
+		*  Adds multiple jQuery elements to this object
+		*
+		*  @date	9/5/18
+		*  @since	5.6.9
+		*
+		*  @param	type $var Description. Default.
+		*  @return	type Description.
+		*/
+		
+		addElements: function( elements ){
+			elements = elements || this.elements || null;
+			if( !elements || !Object.keys(elements).length ) return false;
+			for( var i in elements ) {
+				this.addElement( i, elements[i] );
+			}
+		},
+		
+		/**
+		*  addElement
+		*
+		*  description
+		*
+		*  @date	9/5/18
+		*  @since	5.6.9
+		*
+		*  @param	type $var Description. Default.
+		*  @return	type Description.
+		*/
+		
+		addElement: function( name, selector){
+			this[ '$' + name ] = this.$( selector );
+		},
+		
+		/**
+		*  addEvents
+		*
+		*  Adds multiple event handlers
+		*
+		*  @date	14/12/17
+		*  @since	5.6.5
+		*
+		*  @param	object events {event1 : callback, event2 : callback, etc }
+		*  @return	n/a
+		*/
+		
+		addEvents: function( events ){
+			events = events || this.events || null;
+			if( !events ) return false;
+			for( var key in events ) {
+				var match = key.match(delegateEventSplitter);
+				this.on(match[1], match[2], events[key]);
+			}	
+		},
+		
+		/**
+		*  removeEvents
+		*
+		*  Removes multiple event handlers
+		*
+		*  @date	14/12/17
+		*  @since	5.6.5
+		*
+		*  @param	object events {event1 : callback, event2 : callback, etc }
+		*  @return	n/a
+		*/
+		
+		removeEvents: function( events ){
+			events = events || this.events || null;
+			if( !events ) return false;
+			for( var key in events ) {
+				var match = key.match(delegateEventSplitter);
+				this.off(match[1], match[2], events[key]);
+			}	
+		},
+		
+		/**
+		*  getEventTarget
+		*
+		*  Returns a jQUery element to tigger an event on
+		*
+		*  @date	5/6/18
+		*  @since	5.6.9
+		*
+		*  @param	jQuery $el		The default jQuery element. Optional.
+		*  @param	string event	The event name. Optional.
+		*  @return	jQuery
+		*/
+		
+		getEventTarget: function( $el, event ){
+			return $el || this.$el || $(document);
+		},
+		
+		/**
+		*  validateEvent
+		*
+		*  Returns true if the event target's closest $el is the same as this.$el
+		*  Requires both this.el and this.$el to be defined
+		*
+		*  @date	5/6/18
+		*  @since	5.6.9
+		*
+		*  @param	type $var Description. Default.
+		*  @return	type Description.
+		*/
+		
+		validateEvent: function( e ){
+			if( this.eventScope ) {
+				return $( e.target ).closest( this.eventScope ).is( this.$el );
+			} else {
+				return true;
+			}
+		},
+		
+		/**
+		*  proxyEvent
+		*
+		*  Returns a new event callback function scoped to this model
+		*
+		*  @date	29/3/18
+		*  @since	5.6.9
+		*
+		*  @param	function callback
+		*  @return	function
+		*/
+		
+		proxyEvent: function( callback ){
+			return this.proxy(function(e){
+				
+				// validate
+				if( !this.validateEvent(e) ) {
+					return;
+				}
+				
+				// construct args
+				var args = acf.arrayArgs( arguments );
+				var extraArgs = args.slice(1);
+				var eventArgs = [ e, $(e.currentTarget) ].concat( extraArgs );
+				
+				// callback
+				callback.apply(this, eventArgs);
+			});
+		},
+		
+		/**
+		*  on
+		*
+		*  Adds an event handler similar to jQuery
+		*  Uses the instance 'cid' to namespace event
+		*
+		*  @date	14/12/17
+		*  @since	5.6.5
+		*
+		*  @param	string name
+		*  @param	string callback
+		*  @return	n/a
+		*/
+		
+		on: function( a1, a2, a3, a4 ){
+			
+			// vars
+			var $el, event, selector, callback, args;
+			
+			// find args
+			if( a1 instanceof jQuery ) {
+				
+				// 1. args( $el, event, selector, callback )
+				if( a4 ) {
+					$el = a1; event = a2; selector = a3; callback = a4;
+					
+				// 2. args( $el, event, callback )
+				} else {
+					$el = a1; event = a2; callback = a3;
+				}
+			} else {
+				
+				// 3. args( event, selector, callback )
+				if( a3 ) {
+					event = a1; selector = a2; callback = a3;
+				
+				// 4. args( event, callback )
+				} else {
+					event = a1; callback = a2;
+				}
+			}
+			
+			// element
+			$el = this.getEventTarget( $el );
+			
+			// modify callback
+			if( typeof callback === 'string' ) {
+				callback = this.proxyEvent( this[callback] );
+			}
+			
+			// modify event
+			event = event + '.' + this.cid;
+			
+			// args
+			if( selector ) {
+				args = [ event, selector, callback ];
+			} else {
+				args = [ event, callback ];
+			}
+			
+			// on()
+			$el.on.apply($el, args);
+		},
+				
+		/**
+		*  off
+		*
+		*  Removes an event handler similar to jQuery
+		*
+		*  @date	14/12/17
+		*  @since	5.6.5
+		*
+		*  @param	string name
+		*  @param	string callback
+		*  @return	n/a
+		*/
+		
+		off: function( a1, a2 ,a3 ){
+			
+			// vars
+			var $el, event, selector, args;
+						
+			// find args
+			if( a1 instanceof jQuery ) {
+				
+				// 1. args( $el, event, selector )
+				if( a3 ) {
+					$el = a1; event = a2; selector = a3;
+				
+				// 2. args( $el, event )
+				} else {
+					$el = a1; event = a2;
+				}
+			} else {
+											
+				// 3. args( event, selector )
+				if( a2 ) {
+					event = a1; selector = a2;
+					
+				// 4. args( event )
+				} else {
+					event = a1;
+				}
+			}
+			
+			// element
+			$el = this.getEventTarget( $el );
+			
+			// modify event
+			event = event + '.' + this.cid;
+			
+			// args
+			if( selector ) {
+				args = [ event, selector ];
+			} else {
+				args = [ event ];
+			}
+			
+			// off()
+			$el.off.apply($el, args);			
+		},
+		
+		/**
+		*  trigger
+		*
+		*  Triggers an event similar to jQuery
+		*
+		*  @date	14/12/17
+		*  @since	5.6.5
+		*
+		*  @param	string name
+		*  @param	string callback
+		*  @return	n/a
+		*/
+		
+		trigger: function( name, args, bubbles ){
+			var $el = this.getEventTarget();
+			if( bubbles ) {
+				$el.trigger.apply( $el, arguments );
+			} else {
+				$el.triggerHandler.apply( $el, arguments );
+			}
+			return this;
+		},
+		
+		/**
+		*  addActions
+		*
+		*  Adds multiple action handlers
+		*
+		*  @date	14/12/17
+		*  @since	5.6.5
+		*
+		*  @param	object actions {action1 : callback, action2 : callback, etc }
+		*  @return	n/a
+		*/
+		
+		addActions: function( actions ){
+			actions = actions || this.actions || null;
+			if( !actions ) return false;
+			for( var i in actions ) {
+				this.addAction( i, actions[i] );
+			}	
+		},
+		
+		/**
+		*  removeActions
+		*
+		*  Removes multiple action handlers
+		*
+		*  @date	14/12/17
+		*  @since	5.6.5
+		*
+		*  @param	object actions {action1 : callback, action2 : callback, etc }
+		*  @return	n/a
+		*/
+		
+		removeActions: function( actions ){
+			actions = actions || this.actions || null;
+			if( !actions ) return false;
+			for( var i in actions ) {
+				this.removeAction( i, actions[i] );
+			}	
+		},
+		
+		/**
+		*  addAction
+		*
+		*  Adds an action using the wp.hooks library
+		*
+		*  @date	14/12/17
+		*  @since	5.6.5
+		*
+		*  @param	string name
+		*  @param	string callback
+		*  @return	n/a
+		*/
+		
+		addAction: function( name, callback, priority ){
+			//console.log('addAction', name, priority);
+			// defaults
+			priority = priority || this.priority;
+			
+			// modify callback
+			if( typeof callback === 'string' ) {
+				callback = this[ callback ];
+			}
+			
+			// add
+			acf.addAction(name, callback, priority, this);
+			
+		},
+		
+		/**
+		*  removeAction
+		*
+		*  Remove an action using the wp.hooks library
+		*
+		*  @date	14/12/17
+		*  @since	5.6.5
+		*
+		*  @param	string name
+		*  @param	string callback
+		*  @return	n/a
+		*/
+		
+		removeAction: function( name, callback ){
+			acf.removeAction(name, this[ callback ]);
+		},
+		
+		/**
+		*  addFilters
+		*
+		*  Adds multiple filter handlers
+		*
+		*  @date	14/12/17
+		*  @since	5.6.5
+		*
+		*  @param	object filters {filter1 : callback, filter2 : callback, etc }
+		*  @return	n/a
+		*/
+		
+		addFilters: function( filters ){
+			filters = filters || this.filters || null;
+			if( !filters ) return false;
+			for( var i in filters ) {
+				this.addFilter( i, filters[i] );
+			}	
+		},
+		
+		/**
+		*  addFilter
+		*
+		*  Adds a filter using the wp.hooks library
+		*
+		*  @date	14/12/17
+		*  @since	5.6.5
+		*
+		*  @param	string name
+		*  @param	string callback
+		*  @return	n/a
+		*/
+		
+		addFilter: function( name, callback, priority ){
+			
+			// defaults
+			priority = priority || this.priority;
+			
+			// modify callback
+			if( typeof callback === 'string' ) {
+				callback = this[ callback ];
+			}
+			
+			// add
+			acf.addFilter(name, callback, priority, this);
+			
+		},
+		
+		/**
+		*  removeFilters
+		*
+		*  Removes multiple filter handlers
+		*
+		*  @date	14/12/17
+		*  @since	5.6.5
+		*
+		*  @param	object filters {filter1 : callback, filter2 : callback, etc }
+		*  @return	n/a
+		*/
+		
+		removeFilters: function( filters ){
+			filters = filters || this.filters || null;
+			if( !filters ) return false;
+			for( var i in filters ) {
+				this.removeFilter( i, filters[i] );
+			}	
+		},
+		
+		/**
+		*  removeFilter
+		*
+		*  Remove a filter using the wp.hooks library
+		*
+		*  @date	14/12/17
+		*  @since	5.6.5
+		*
+		*  @param	string name
+		*  @param	string callback
+		*  @return	n/a
+		*/
+		
+		removeFilter: function( name, callback ){
+			acf.removeFilter(name, this[ callback ]);
+		},
+		
+		/**
+		*  $
+		*
+		*  description
+		*
+		*  @date	16/12/17
+		*  @since	5.6.5
+		*
+		*  @param	type $var Description. Default.
+		*  @return	type Description.
+		*/
+		
+		$: function( selector ){
+			return this.$el.find( selector );
+		},
+		
+		/**
+		*  remove
+		*
+		*  Removes the element and listenters
+		*
+		*  @date	19/12/17
+		*  @since	5.6.5
+		*
+		*  @param	type $var Description. Default.
+		*  @return	type Description.
+		*/
+		
+		remove: function(){
+			this.removeEvents();
+			this.removeActions();
+			this.removeFilters();
+			this.$el.remove();
+		},
+		
+		/**
+		*  setTimeout
+		*
+		*  description
+		*
+		*  @date	16/1/18
+		*  @since	5.6.5
+		*
+		*  @param	type $var Description. Default.
+		*  @return	type Description.
+		*/
+		
+		setTimeout: function( callback, milliseconds ){
+			return setTimeout( this.proxy(callback), milliseconds );
+		},
+		
+		/**
+		*  time
+		*
+		*  used for debugging
+		*
+		*  @date	7/3/18
+		*  @since	5.6.9
+		*
+		*  @param	type $var Description. Default.
+		*  @return	type Description.
+		*/
+		
+		time: function(){
+			console.time( this.id || this.cid );
+		},
+		
+		/**
+		*  timeEnd
+		*
+		*  used for debugging
+		*
+		*  @date	7/3/18
+		*  @since	5.6.9
+		*
+		*  @param	type $var Description. Default.
+		*  @return	type Description.
+		*/
+		
+		timeEnd: function(){
+			console.timeEnd( this.id || this.cid );
+		},
+		
+		/**
+		*  show
+		*
+		*  description
+		*
+		*  @date	15/3/18
+		*  @since	5.6.9
+		*
+		*  @param	type $var Description. Default.
+		*  @return	type Description.
+		*/
+		
+		show: function(){
+			acf.show( this.$el );
+		},
+		
+		
+		/**
+		*  hide
+		*
+		*  description
+		*
+		*  @date	15/3/18
+		*  @since	5.6.9
+		*
+		*  @param	type $var Description. Default.
+		*  @return	type Description.
+		*/
+		
+		hide: function(){
+			acf.hide( this.$el );
+		},
+		
+		/**
+		*  proxy
+		*
+		*  Returns a new function scoped to this model
+		*
+		*  @date	29/3/18
+		*  @since	5.6.9
+		*
+		*  @param	function callback
+		*  @return	function
+		*/
+		
+		proxy: function( callback ){
+			return $.proxy( callback, this );
+		}
+		
+		
+	});
+	
+	// Set up inheritance for the model
+	Model.extend = extend;
+	
+	// Global model storage
+	acf.models = {};
+	
+	/**
+	*  acf.getInstance
+	*
+	*  This function will get an instance from an element
+	*
+	*  @date	5/3/18
+	*  @since	5.6.9
+	*
+	*  @param	type $var Description. Default.
+	*  @return	type Description.
+	*/
+	
+	acf.getInstance = function( $el ){
+		return $el.data('acf');	
+	};
+	
+	/**
+	*  acf.getInstances
+	*
+	*  This function will get an array of instances from multiple elements
+	*
+	*  @date	5/3/18
+	*  @since	5.6.9
+	*
+	*  @param	type $var Description. Default.
+	*  @return	type Description.
+	*/
+	
+	acf.getInstances = function( $el ){
+		var instances = [];
+		$el.each(function(){
+			instances.push( acf.getInstance( $(this) ) );
+		});
+		return instances;	
+	};
+	
+})(jQuery);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-notice.js

@@ -0,0 +1,146 @@
+(function($, undefined){
+	
+	var Notice = acf.Model.extend({
+		
+		data: {
+			text: '',
+			type: '',
+			timeout: 0,
+			dismiss: true,
+			target: false,
+			close: function(){}
+		},
+		
+		events: {
+			'click .acf-notice-dismiss': 'onClickClose',
+		},
+		
+		tmpl: function(){
+			return '<div class="acf-notice"></div>';
+		},
+		
+		setup: function( props ){
+			$.extend(this.data, props);
+			this.$el = $(this.tmpl());
+		},
+		
+		initialize: function(){
+			
+			// render
+			this.render();
+			
+			// show
+			this.show();
+		},
+		
+		render: function(){
+			
+			// class
+			this.type( this.get('type') );
+			
+			// text
+			this.html( '<p>' + this.get('text') + '</p>' );
+			
+			// close
+			if( this.get('dismiss') ) {
+				this.$el.append('<a href="#" class="acf-notice-dismiss acf-icon -cancel small"></a>');
+				this.$el.addClass('-dismiss');
+			}
+			
+			// timeout
+			var timeout = this.get('timeout');
+			if( timeout ) {
+				this.away( timeout );
+			}
+		},
+		
+		update: function( props ){
+			
+			// update
+			$.extend(this.data, props);
+			
+			// re-initialize
+			this.initialize();
+			
+			// refresh events
+			this.removeEvents();
+			this.addEvents();
+		},
+		
+		show: function(){
+			var $target = this.get('target');
+			if( $target ) {
+				$target.prepend( this.$el );
+			}
+		},
+		
+		hide: function(){
+			this.$el.remove();
+		},
+		
+		away: function( timeout ){
+			this.setTimeout(function(){
+				acf.remove( this.$el );
+			}, timeout );
+		},
+		
+		type: function( type ){
+			
+			// remove prev type
+			var prevType = this.get('type');
+			if( prevType ) {
+				this.$el.removeClass('-' + prevType);
+			}
+			
+			// add new type
+			this.$el.addClass('-' + type);
+			
+			// backwards compatibility
+			if( type == 'error' ) {
+				this.$el.addClass('acf-error-message');
+			}
+		},
+		
+		html: function( html ){
+			this.$el.html( html );
+		},
+		
+		text: function( text ){
+			this.$('p').html( text );
+		},
+		
+		onClickClose: function( e, $el ){
+			e.preventDefault();
+			this.get('close').apply(this, arguments);
+			this.remove();
+		}
+	});
+	
+	acf.newNotice = function( props ){
+		
+		// ensure object
+		if( typeof props !== 'object' ) {
+			props = { text: props };
+		}
+		
+		// instantiate
+		return new Notice( props );
+	};
+	
+	var noticeManager = new acf.Model({
+		wait: 'prepare',
+		priority: 1,
+		initialize: function(){
+			
+			// vars
+			var $notice = $('.acf-admin-notice');
+			
+			// move to avoid WP flicker
+			if( $notice.length ) {
+				$('h1:first').after( $notice );
+			}
+		}	 
+	});
+	
+	
+})(jQuery);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-panel.js

@@ -0,0 +1,34 @@
+(function($, undefined){
+	
+	var panel = new acf.Model({
+		
+		events: {
+			'click .acf-panel-title': 'onClick',
+		},
+		
+		onClick: function( e, $el ){
+			e.preventDefault();
+			this.toggle( $el.parent() );
+		},
+		
+		isOpen: function( $el ) {
+			return $el.hasClass('-open');
+		},
+		
+		toggle: function( $el ){
+			this.isOpen($el) ? this.close( $el ) : this.open( $el );
+		},
+		
+		open: function( $el ){
+			$el.addClass('-open');
+			$el.find('.acf-panel-title i').attr('class', 'dashicons dashicons-arrow-down');
+		},
+		
+		close: function( $el ){
+			$el.removeClass('-open');
+			$el.find('.acf-panel-title i').attr('class', 'dashicons dashicons-arrow-right');
+		}
+				 
+	});
+		
+})(jQuery);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-popup.js

@@ -0,0 +1,121 @@
+(function($, undefined){
+	
+	acf.models.Popup = acf.Model.extend({
+			
+		data: {
+			title: '',
+			content: '',
+			width: 0,
+			height: 0,
+			loading: false,
+		},
+		
+		events: {
+			'click [data-event="close"]': 'onClickClose',
+			'click .acf-close-popup': 'onClickClose',
+		},
+		
+		setup: function( props ){
+			$.extend(this.data, props);
+			this.$el = $(this.tmpl());
+		},
+		
+		initialize: function(){
+			this.render();
+			this.open();
+		},
+		
+		tmpl: function(){
+			return [
+				'<div id="acf-popup">',
+					'<div class="acf-popup-box acf-box">',
+						'<div class="title"><h3></h3><a href="#" class="acf-icon -cancel grey" data-event="close"></a></div>',
+						'<div class="inner"></div>',
+						'<div class="loading"><i class="acf-loading"></i></div>',
+					'</div>',
+					'<div class="bg" data-event="close"></div>',
+				'</div>'
+			].join('');
+		},
+		
+		render: function(){
+			
+			// vars
+			var title = this.get('title');
+			var content = this.get('content');
+			var loading = this.get('loading');
+			var width = this.get('width');
+			var height = this.get('height');
+			
+			// html
+			this.title( title );
+			this.content( content );
+			
+			// width
+			if( width ) {
+				this.$('.acf-popup-box').css('width', width);
+			}
+			
+			// height
+			if( height ) {
+				this.$('.acf-popup-box').css('min-height', height);
+			}
+			
+			// loading
+			this.loading( loading );
+			
+			// action
+			acf.doAction('append', this.$el);
+
+		},
+		
+		update: function( props ){
+			this.data = acf.parseArgs(props, this.data);
+			this.render();
+		},
+		
+		title: function( title ){
+			this.$('.title:first h3').html( title );
+		},
+		
+		content: function( content ){
+			this.$('.inner:first').html( content );
+		},
+		
+		loading: function( show ){
+			var $loading = this.$('.loading:first');
+			show ? $loading.show() : $loading.hide();
+		},
+
+		open: function(){
+			$('body').append( this.$el );
+		},
+		
+		close: function(){
+			this.remove();
+		},
+		
+		onClickClose: function( e, $el ){
+			e.preventDefault();
+			this.close();
+		}
+		
+	});
+	
+	/**
+	*  newPopup
+	*
+	*  Creates a new Popup with the supplied props
+	*
+	*  @date	17/12/17
+	*  @since	5.6.5
+	*
+	*  @param	object props
+	*  @return	object
+	*/
+	
+	acf.newPopup = function( props ){
+		return new acf.models.Popup( props );
+	};
+	
+})(jQuery);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-postbox.js

@@ -0,0 +1,212 @@
+(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');
+		},
+		
+		$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 ) {
+				this.$hndle().append('<a href="' + edit + '" class="dashicons dashicons-admin-generic acf-hndle-cog acf-js-tooltip" title="' + acf.__('Edit field group') + '"></a>');
+			}
+			
+			// 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');
+		},
+		
+		enable: function(){
+			acf.enable( this.$el, 'postbox' );
+		},
+		
+		showEnable: function(){
+			this.show();
+			this.enable();
+		},
+		
+		hide: function(){
+			
+			// Hide label.
+			this.$hideLabel().hide();
+			
+			// Hide postbox
+			this.$el.hide().addClass('acf-hidden');
+		},
+		
+		disable: function(){
+			acf.disable( this.$el, 'postbox' );
+		},
+		
+		hideDisable: function(){
+			this.hide();
+			this.disable();
+		},
+		
+		html: function( html ){
+			
+			// Update HTML.
+			this.$inside().html( html );
+			
+			// Do action.
+			acf.doAction('append', this.$el);
+		}
+	});
+		
+})(jQuery);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-screen.js

@@ -0,0 +1,593 @@
+(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 ){
+				
+				// Check success.
+				if( acf.isAjaxSuccess(json) ) {
+					
+					// Render post screen.
+					if( acf.get('screen') == 'post' ) {
+						this.renderPostScreen( json.data );
+					
+					// Render user screen.
+					} else if( acf.get('screen') == 'user' ) {
+						this.renderUserScreen( json.data );
+					}
+				}
+				
+				// action
+				acf.doAction('check_screen_complete', json.data, 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 ){
+			
+			// vars
+			var visible = [];
+			
+			// 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;
+			};
+			
+			// Show these postboxes.
+			data.results.map(function( result, i ){
+				
+				// vars
+				var postbox = acf.getPostbox( result.id );
+				
+				// Create postbox if doesn't exist.
+				if( !postbox ) {
+					
+					// Create it.
+					var $postbox = $([
+						'<div id="' + result.id + '" class="postbox">',
+							'<button type="button" class="handlediv" aria-expanded="false">',
+								'<span class="screen-reader-text">Toggle panel: ' + result.title + '</span>',
+								'<span class="toggle-indicator" aria-hidden="true"></span>',
+							'</button>',
+							'<h2 class="hndle ui-sortable-handle">',
+								'<span>' + result.title + '</span>',
+							'</h2>',
+							'<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 );
+					}
+					
+					// 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;
+							}
+						}
+					}
+					
+					// Copy default WP events onto metabox.
+					var $submitdiv = $('#submitdiv');
+					if( $('#submitdiv').length ) {
+						copyEvents( $submitdiv.children('.handlediv'), $postbox.children('.handlediv') );
+						copyEvents( $submitdiv.children('.hndle'), $postbox.children('.hndle') );
+					}
+					
+					// Initalize it (modifies HTML).
+					postbox = acf.newPostbox( result );
+					
+					// Trigger action.
+					acf.doAction('append', $postbox);
+					acf.doAction('append_postbox', postbox);
+				}
+				
+				// show postbox
+				postbox.showEnable();
+				
+				// Do action.
+				acf.doAction('show_postbox', postbox);
+				
+				// append
+				visible.push( result.id );
+			});
+			
+			// Hide these postboxes.
+			acf.getPostboxes().map(function( postbox ){
+				if( visible.indexOf( postbox.get('id') ) === -1 ) {
+					postbox.hideDisable();
+					
+					// Do action.
+					acf.doAction('hide_postbox', postbox);
+				}
+			});
+			
+			// Update style.
+			$('#acf-style').html( data.style );	
+		},
+		
+		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({
+		
+		// Wait until load to avoid 'core' issues when loading taxonomies.
+		wait: 'load',
+
+		initialize: function(){
+			
+			// Bail early if not Gutenberg.
+			if( !acf.isGutenberg() ) {
+				return;
+			}
+			
+			// Listen for changes.
+			wp.data.subscribe(this.proxy(this.onChange));
+			
+			// 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();
+			
+			// Add actions.
+			//this.addAction( 'append_postbox', acf.screen.refreshAvailableMetaBoxesPerLocation );
+		},
+		
+		onChange: function(){
+			
+			// Get edits.
+			var edits = wp.data.select( 'core/editor' ).getPostEdits();
+			
+			// Check specific attributes.
+			var attributes = [
+				'template',
+				'parent',
+				'format'
+			];
+			
+			// Append taxonomy attributes.
+			var taxonomies = wp.data.select( 'core' ).getTaxonomies() || [];
+			taxonomies.map(function( taxonomy ){
+				attributes.push( taxonomy.rest_base );
+			});
+			
+			// Filter out attributes that have not changed.
+			attributes = attributes.filter(this.proxy(function( attr ){
+				return ( edits[attr] !== undefined && edits[attr] !== this.get(attr) );
+			}));
+			
+			// Trigger change if has attributes.
+			if( attributes.length ) {
+				this.triggerChange( edits )
+			}
+		},
+		
+		triggerChange: function( edits ){
+			
+			// Update this.data if edits are provided.
+			if( edits !== undefined ) {
+				this.data = edits;
+			}
+			
+			// 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;
+		}
+	});
+	
+	/**
+	 * acf.screen.refreshAvailableMetaBoxesPerLocation
+	 *
+	 * Refreshes the WP data state based on metaboxes found in the DOM.
+	 *
+	 * Caution. Not safe to use.
+	 * Causes duplicate dispatch listeners when saving post resulting in duplicate postmeta.
+	 *
+	 * @date	6/3/19
+	 * @since	5.7.13
+	 *
+	 * @param	void
+	 * @return	void
+	 */
+	acf.screen.refreshAvailableMetaBoxesPerLocation = function() {
+		
+		// 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 data = {};
+		select.getActiveMetaBoxLocations().map(function( location ){
+			data[ location ] = select.getMetaBoxesPerLocation( location );
+		});
+		
+		// Generate flat array of existing ids.
+		var ids = [];
+		for( var k in data ) {
+			ids = ids.concat( data[k].map(function(m){ return m.id; }) );
+		}
+		
+		// Append ACF metaboxes.
+		acf.getPostboxes().map(function( postbox ){
+			
+			// Ignore if already exists in data.
+			if( ids.indexOf( postbox.get('id') ) !== -1 ) {
+				return;
+			}
+			
+			// Get metabox location looking at parent form.
+			var location = postbox.$el.closest('form').attr('class').replace('metabox-location-', '');
+			
+			// Ensure location exists.
+			data[ location ] = data[ location ] || [];
+			
+			// Append.
+			data[ location ].push({
+				id: postbox.get('id'),
+				title: postbox.get('title')
+			});
+		});
+		
+		// Update state.
+		dispatch.setAvailableMetaBoxesPerLocation(data);	
+	};
+
+})(jQuery);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-select2.js

@@ -0,0 +1,793 @@
+(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 );
+		},
+		
+		decodeChoices: function( choices ){
+			
+			// callback
+			var crawl = function( items ){
+				items.map(function( item ){
+					item.text = acf.decode( item.text );
+					if( item.children ) {
+						item.children = crawl( item.children );
+					}
+					return item;
+				});
+				return items;
+			};
+			
+			// crawl
+			return crawl( choices );
+		},
+		
+		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,
+			});
+			
+			// decode
+			if( json.results ) {
+				json.results = this.decodeChoices(json.results);
+			}
+			
+			// 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( m ){ return m; }
+			};
+			
+			// multiple
+			if( options.multiple ) {
+				
+				// reorder options
+				this.getValue().map(function( item ){
+					item.$el.detach().appendTo( $select );
+				});
+			}
+			
+		    // remove conflicting atts
+		    $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() {
+				            
+				            // vars
+							var $option = $( $(this).data('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');
+			
+			// 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( m ){ return m; },
+				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',
+		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);
+		}
+		
+	});
+	
+})(jQuery);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-tinymce.js

@@ -0,0 +1,398 @@
+(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;
+						
+			// 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);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-tooltip.js

@@ -0,0 +1,324 @@
+(function($, undefined){
+	
+	acf.newTooltip = function( props ){
+		
+		// ensure object
+		if( typeof props !== 'object' ) {
+			props = { text: props };
+		}
+		
+		// confirmRemove
+		if( props.confirmRemove !== undefined ) {
+			
+			props.textConfirm = acf.__('Remove');
+			props.textCancel = acf.__('Cancel');
+			return new TooltipConfirm( props );
+			
+		// confirm
+		} else if( props.confirm !== undefined ) {
+			
+			return new TooltipConfirm( props );
+		
+		// default
+		} else {
+			return new Tooltip( props );
+		}
+		
+	};
+	
+	var Tooltip = acf.Model.extend({
+		
+		data: {
+			text: '',
+			timeout: 0,
+			target: null
+		},
+		
+		tmpl: function(){
+			return '<div class="acf-tooltip"></div>';
+		},
+		
+		setup: function( props ){
+			$.extend(this.data, props);
+			this.$el = $(this.tmpl());
+		},
+		
+		initialize: function(){
+			
+			// render
+			this.render();
+			
+			// append
+			this.show();
+			
+			// position
+			this.position();
+			
+			// timeout
+			var timeout = this.get('timeout');
+			if( timeout ) {
+				setTimeout( $.proxy(this.fade, this), timeout );
+			}
+		},
+		
+		update: function( props ){
+			$.extend(this.data, props);
+			this.initialize();
+		},
+		
+		render: function(){
+			this.html( this.get('text') );
+		},
+		
+		show: function(){
+			$('body').append( this.$el );
+		},
+		
+		hide: function(){
+			this.$el.remove();
+		},
+		
+		fade: function(){
+			
+			// add class
+			this.$el.addClass('acf-fade-up');
+			
+			// remove
+			this.setTimeout(function(){
+				this.remove();
+			}, 250);
+		},
+		
+		html: function( html ){
+			this.$el.html( html );
+		},
+		
+		position: function(){
+			
+			// vars
+			var $tooltip = this.$el;
+			var $target = this.get('target');
+			if( !$target ) return;
+			
+			// Reset position.
+			$tooltip.removeClass('right left bottom top').css({ top: 0, left: 0 });
+			
+			// Declare tollerance to edge of screen.
+			var tolerance = 10;
+			
+			// Find target position.
+			var targetWidth = $target.outerWidth();
+			var targetHeight = $target.outerHeight();
+			var targetTop = $target.offset().top;
+			var targetLeft = $target.offset().left;
+			
+			// Find tooltip position.
+			var tooltipWidth = $tooltip.outerWidth();
+			var tooltipHeight = $tooltip.outerHeight();
+			var tooltipTop = $tooltip.offset().top; // Should be 0, but WP media grid causes this to be 32 (toolbar padding).
+			
+			// Assume default top alignment.
+			var top = targetTop - tooltipHeight - tooltipTop;
+			var left = targetLeft + (targetWidth / 2) - (tooltipWidth / 2);
+			
+			// Check if too far left.
+			if( left < tolerance ) {
+				$tooltip.addClass('right');
+				left = targetLeft + targetWidth;
+				top = targetTop + (targetHeight / 2) - (tooltipHeight / 2) - tooltipTop;
+			
+			// Check if too far right.
+			} else if( (left + tooltipWidth + tolerance) > $(window).width() ) {
+				$tooltip.addClass('left');
+				left = targetLeft - tooltipWidth;
+				top = targetTop + (targetHeight / 2) - (tooltipHeight / 2) - tooltipTop;
+			
+			// Check if too far up.
+			} else if( top - $(window).scrollTop() < tolerance ) {
+				$tooltip.addClass('bottom');
+				top = targetTop + targetHeight - tooltipTop;
+				
+			// No colision with edges.
+			} else {
+				$tooltip.addClass('top');
+			}
+			
+			// update css
+			$tooltip.css({ 'top': top, 'left': left });	
+		}
+	});
+	
+	var TooltipConfirm = Tooltip.extend({
+		
+		data: {
+			text: '',
+			textConfirm: '',
+			textCancel: '',
+			target: null,
+			targetConfirm: true,
+			confirm: function(){},
+			cancel: function(){},
+			context: false
+		},
+		
+		events: {
+			'click [data-event="cancel"]': 'onCancel',
+			'click [data-event="confirm"]': 'onConfirm',
+		},
+		
+		addEvents: function(){
+			
+			// add events
+			acf.Model.prototype.addEvents.apply(this);
+			
+			// vars
+			var $document = $(document);
+			var $target = this.get('target');
+			
+			// add global 'cancel' click event
+			// - use timeout to avoid the current 'click' event triggering the onCancel function
+			this.setTimeout(function(){
+				this.on( $document, 'click', 'onCancel' );
+			});
+			
+			// add target 'confirm' click event
+			// - allow setting to control this feature
+			if( this.get('targetConfirm') ) {
+				this.on( $target, 'click', 'onConfirm' );
+			}
+		},
+		
+		removeEvents: function(){
+			
+			// remove events
+			acf.Model.prototype.removeEvents.apply(this);
+			
+			// vars
+			var $document = $(document);
+			var $target = this.get('target');
+			
+			// remove custom events
+			this.off( $document, 'click' );
+			this.off( $target, 'click' );
+		},
+		
+		render: function(){
+			
+			// defaults
+			var text = this.get('text') || acf.__('Are you sure?');
+			var textConfirm = this.get('textConfirm') || acf.__('Yes');
+			var textCancel = this.get('textCancel') || acf.__('No');
+			
+			// html
+			var html = [
+				text,
+				'<a href="#" data-event="confirm">' + textConfirm + '</a>',
+				'<a href="#" data-event="cancel">' + textCancel + '</a>'
+			].join(' ');
+			
+			// html
+			this.html( html );
+			
+			// class
+			this.$el.addClass('-confirm');
+		},
+		
+		onCancel: function( e, $el ){
+			
+			// prevent default
+			e.preventDefault();
+			e.stopImmediatePropagation();
+			
+			// callback
+			var callback = this.get('cancel');
+			var context = this.get('context') || this;
+			callback.apply( context, arguments );
+			
+			//remove
+			this.remove();
+		},
+		
+		onConfirm: function( e, $el ){
+			
+			// prevent default
+			e.preventDefault();
+			e.stopImmediatePropagation();
+			
+			// callback
+			var callback = this.get('confirm');
+			var context = this.get('context') || this;
+			callback.apply( context, arguments );
+			
+			//remove
+			this.remove();
+		}
+	});
+	
+	// storage
+	acf.models.Tooltip = Tooltip;
+	acf.models.TooltipConfirm = TooltipConfirm;
+	
+	
+	/**
+	*  tooltipManager
+	*
+	*  description
+	*
+	*  @date	17/4/18
+	*  @since	5.6.9
+	*
+	*  @param	type $var Description. Default.
+	*  @return	type Description.
+	*/
+	
+	var tooltipHoverHelper = new acf.Model({
+		
+		tooltip: false,
+		
+		events: {
+			'mouseenter .acf-js-tooltip':	'showTitle',
+			'mouseup .acf-js-tooltip':		'hideTitle',
+			'mouseleave .acf-js-tooltip':	'hideTitle'
+		},
+		
+		showTitle: function( e, $el ){
+			
+			// vars
+			var title = $el.attr('title');
+			
+			// bail ealry if no title
+			if( !title ) {
+				return;
+			}
+			
+			// clear title to avoid default browser tooltip
+			$el.attr('title', '');
+			
+			// create
+			if( !this.tooltip ) {
+				this.tooltip = acf.newTooltip({
+					text: title,
+					target: $el
+				});
+			
+			// update
+			} else {
+				this.tooltip.update({
+					text: title,
+					target: $el
+				});
+			}
+			
+		},
+		
+		hideTitle: function( e, $el ){
+			
+			// hide tooltip
+			this.tooltip.hide();
+			
+			// restore title
+			$el.attr('title', this.tooltip.get('text'));
+		}
+	});
+	
+})(jQuery);

wp-content/plugins/advanced-custom-fields/assets/build/js/_acf-unload.js

@@ -0,0 +1,62 @@
+(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);

wp-content/plugins/advanced-custom-fields/assets/build/js/_field-group-compatibility.js

@@ -0,0 +1,281 @@
+(function($, undefined){
+	
+	var _acf = acf.getCompatibility( acf );
+	
+	/**
+	*  fieldGroupCompatibility
+	*
+	*  Compatibility layer for extinct acf.field_group 
+	*
+	*  @date	15/12/17
+	*  @since	5.7.0
+	*
+	*  @param	void
+	*  @return	void
+	*/
+	
+	_acf.field_group = {
+		
+		save_field: function( $field, type ){
+			type = (type !== undefined) ? type : 'settings';
+			acf.getFieldObject( $field ).save( type );
+		},
+		
+		delete_field: function( $field, animate ){
+			animate = (animate !== undefined) ? animate : true;
+			acf.getFieldObject( $field ).delete({
+				animate: animate
+			});
+		},
+		
+		update_field_meta: function( $field, name, value ){
+			acf.getFieldObject( $field ).prop( name, value );
+		},
+		
+		delete_field_meta: function( $field, name ){
+			acf.getFieldObject( $field ).prop( name, null );
+		}
+	};
+	
+	/**
+	*  fieldGroupCompatibility.field_object
+	*
+	*  Compatibility layer for extinct acf.field_group.field_object
+	*
+	*  @date	15/12/17
+	*  @since	5.7.0
+	*
+	*  @param	void
+	*  @return	void
+	*/
+	
+	_acf.field_group.field_object = acf.model.extend({
+		
+		// vars
+		type:		'',
+		o:			{},
+		$field:		null,
+		$settings:	null,
+		
+		tag: function( tag ) {
+			
+			// vars
+			var type = this.type;
+			
+			
+			// explode, add 'field' and implode
+			// - open 			=> open_field
+			// - change_type	=> change_field_type
+			var tags = tag.split('_');
+			tags.splice(1, 0, 'field');
+			tag = tags.join('_');
+			
+			
+			// add type
+			if( type ) {
+				tag += '/type=' + type;
+			}
+			
+			
+			// return
+			return tag;
+						
+		},
+		
+		selector: function(){
+			
+			// vars
+			var selector = '.acf-field-object';
+			var type = this.type;
+			
+
+			// add type
+			if( type ) {
+				selector += '-' + type;
+				selector = acf.str_replace('_', '-', selector);
+			}
+			
+			
+			// return
+			return selector;
+			
+		},
+		
+		_add_action: function( name, callback ) {
+			
+			// vars
+			var model = this;
+			
+			
+			// add action
+			acf.add_action( this.tag(name), function( $field ){
+				
+				// focus
+				model.set('$field', $field);
+				
+				
+				// callback
+				model[ callback ].apply(model, arguments);
+				
+			});
+			
+		},
+		
+		_add_filter: function( name, callback ) {
+			
+			// vars
+			var model = this;
+			
+			
+			// add action
+			acf.add_filter( this.tag(name), function( $field ){
+				
+				// focus
+				model.set('$field', $field);
+				
+				
+				// callback
+				model[ callback ].apply(model, arguments);
+				
+			});
+			
+		},
+		
+		_add_event: function( name, callback ) {
+			
+			// vars
+			var model = this;
+			var event = name.substr(0,name.indexOf(' '));
+			var selector = name.substr(name.indexOf(' ')+1);
+			var context = this.selector();
+			
+			
+			// add event
+			$(document).on(event, context + ' ' + selector, function( e ){
+				
+				// append $el to event object
+				e.$el = $(this);
+				e.$field = e.$el.closest('.acf-field-object');
+				
+				
+				// focus
+				model.set('$field', e.$field);
+				
+				
+				// callback
+				model[ callback ].apply(model, [e]);
+				
+			});
+			
+		},
+		
+		_set_$field: function(){
+			
+			// vars
+			this.o = this.$field.data();
+			
+			
+			// els
+			this.$settings = this.$field.find('> .settings > table > tbody');
+			
+			
+			// focus
+			this.focus();
+			
+		},
+		
+		focus: function(){
+			
+			// do nothing
+			
+		},
+		
+		setting: function( name ) {
+			
+			return this.$settings.find('> .acf-field-setting-' + name);
+			
+		}
+		
+	});
+	
+	
+	/*
+	*  field
+	*
+	*  This model fires actions and filters for registered fields
+	*
+	*  @type	function
+	*  @date	21/02/2014
+	*  @since	3.5.1
+	*
+	*  @param	n/a
+	*  @return	n/a
+	*/
+	
+	var actionManager = new acf.Model({
+		
+		actions: {
+			'open_field_object': 			'onOpenFieldObject',
+			'close_field_object': 			'onCloseFieldObject',
+			'add_field_object': 			'onAddFieldObject',
+			'duplicate_field_object': 		'onDuplicateFieldObject',
+			'delete_field_object': 			'onDeleteFieldObject',
+			'change_field_object_type': 	'onChangeFieldObjectType',
+			'change_field_object_label': 	'onChangeFieldObjectLabel',
+			'change_field_object_name': 	'onChangeFieldObjectName',
+			'change_field_object_parent': 	'onChangeFieldObjectParent',
+			'sortstop_field_object':		'onChangeFieldObjectParent'
+		},
+		
+		onOpenFieldObject: function( field ){
+			acf.doAction('open_field', field.$el);
+			acf.doAction('open_field/type=' + field.get('type'), field.$el);
+			
+			acf.doAction('render_field_settings', field.$el);
+			acf.doAction('render_field_settings/type=' + field.get('type'), field.$el);
+		},
+		
+		onCloseFieldObject: function( field ){
+			acf.doAction('close_field', field.$el);
+			acf.doAction('close_field/type=' + field.get('type'), field.$el);
+		},
+		
+		onAddFieldObject: function( field ){
+			acf.doAction('add_field', field.$el);
+			acf.doAction('add_field/type=' + field.get('type'), field.$el);
+		},
+		
+		onDuplicateFieldObject: function( field ){
+			acf.doAction('duplicate_field', field.$el);
+			acf.doAction('duplicate_field/type=' + field.get('type'), field.$el);
+		},
+		
+		onDeleteFieldObject: function( field ){
+			acf.doAction('delete_field', field.$el);
+			acf.doAction('delete_field/type=' + field.get('type'), field.$el);
+		},
+		
+		onChangeFieldObjectType: function( field ){
+			acf.doAction('change_field_type', field.$el);
+			acf.doAction('change_field_type/type=' + field.get('type'), field.$el);
+			
+			acf.doAction('render_field_settings', field.$el);
+			acf.doAction('render_field_settings/type=' + field.get('type'), field.$el);
+		},
+		
+		onChangeFieldObjectLabel: function( field ){
+			acf.doAction('change_field_label', field.$el);
+			acf.doAction('change_field_label/type=' + field.get('type'), field.$el);
+		},
+		
+		onChangeFieldObjectName: function( field ){
+			acf.doAction('change_field_name', field.$el);
+			acf.doAction('change_field_name/type=' + field.get('type'), field.$el);
+		},
+		
+		onChangeFieldObjectParent: function( field ){
+			acf.doAction('update_field_parent', field.$el);
+		}
+	});
+	
+})(jQuery);

wp-content/plugins/advanced-custom-fields/assets/build/js/_field-group-conditions.js

@@ -0,0 +1,403 @@
+(function($, undefined){
+	
+	/**
+	*  ConditionalLogicFieldSetting
+	*
+	*  description
+	*
+	*  @date	3/2/18
+	*  @since	5.6.5
+	*
+	*  @param	type $var Description. Default.
+	*  @return	type Description.
+	*/
+	
+	var ConditionalLogicFieldSetting = acf.FieldSetting.extend({
+		type: '',
+		name: 'conditional_logic',
+		events: {
+			'change .conditions-toggle': 		'onChangeToggle',
+			'click .add-conditional-group': 	'onClickAddGroup',
+			'focus .condition-rule-field': 		'onFocusField',
+			'change .condition-rule-field': 	'onChangeField',
+			'change .condition-rule-operator': 	'onChangeOperator',
+			'click .add-conditional-rule':		'onClickAdd',
+			'click .remove-conditional-rule':	'onClickRemove'
+		},
+		
+		$rule: false,
+		
+		scope: function( $rule ){
+			this.$rule = $rule;
+			return this;
+		},
+		
+		ruleData: function( name, value ){
+			return this.$rule.data.apply( this.$rule, arguments );
+		},
+		
+		$input: function( name ){
+			return this.$rule.find('.condition-rule-' + name);
+		},
+		
+		$td: function( name ){
+			return this.$rule.find('td.' + name);
+		},
+		
+		$toggle: function(){
+			return this.$('.conditions-toggle');
+		},
+		
+		$control: function(){
+			return this.$('.rule-groups');
+		},
+		
+		$groups: function(){
+			return this.$('.rule-group');
+		},
+		
+		$rules: function(){
+			return this.$('.rule');
+		},
+		
+		open: function(){
+			var $div = this.$control();
+			$div.show();
+			acf.enable( $div );
+		},
+		
+		close: function(){
+			var $div = this.$control();
+			$div.hide();
+			acf.disable( $div );
+		},
+		
+		render: function(){
+			
+			// show
+			if( this.$toggle().prop('checked') ) {
+				this.renderRules();
+				this.open();
+			
+			// hide
+			} else {
+				this.close();
+			}
+		},
+		
+		renderRules: function(){
+			
+			// vars
+			var self = this;
+			
+			// loop
+			this.$rules().each(function(){
+				self.renderRule( $(this) );
+			});
+		},
+		
+		renderRule: function( $rule ){
+			this.scope( $rule );
+			this.renderField();
+			this.renderOperator();
+			this.renderValue();
+		},
+		
+		renderField: function(){
+			
+			// vars
+			var choices = [];
+			var validFieldTypes = [];
+			var cid = this.fieldObject.cid;
+			var $select = this.$input('field');
+			
+			// loop
+			acf.getFieldObjects().map(function( fieldObject ){
+				
+				// vars
+				var choice = {
+					id:		fieldObject.getKey(),
+					text:	fieldObject.getLabel()
+				};
+				
+				// bail early if is self
+				if( fieldObject.cid === cid  ) {
+					choice.text += acf.__('(this field)');
+					choice.disabled = true;
+				}
+				
+				// get selected field conditions 
+				var conditionTypes = acf.getConditionTypes({
+					fieldType: fieldObject.getType()
+				});
+				
+				// bail early if no types
+				if( !conditionTypes.length ) {
+					choice.disabled = true;
+				}
+				
+				// calulate indents
+				var indents = fieldObject.getParents().length;
+				choice.text = '- '.repeat(indents) + choice.text;
+				
+				// append
+				choices.push(choice);
+			});
+			
+			// allow for scenario where only one field exists
+			if( !choices.length ) {
+				choices.push({
+					id: '',
+					text: acf.__('No toggle fields available'),
+				});
+			}
+			
+			// render
+			acf.renderSelect( $select, choices );
+			
+			// set
+			this.ruleData('field', $select.val());
+		},
+		
+		renderOperator: function(){
+			
+			// bail early if no field selected
+			if( !this.ruleData('field') ) {
+				return;
+			}
+			
+			// vars
+			var $select = this.$input('operator');
+			var val = $select.val();
+			var choices = [];
+			
+			// set saved value on first render
+			// - this allows the 2nd render to correctly select an option
+			if( $select.val() === null ) {
+				acf.renderSelect($select, [{
+					id: this.ruleData('operator'),
+					text: ''
+				}]);
+			}
+			
+			// get selected field
+			var $field = acf.findFieldObject( this.ruleData('field') );
+			var field = acf.getFieldObject( $field );
+			
+			// get selected field conditions 
+			var conditionTypes = acf.getConditionTypes({
+				fieldType: field.getType()
+			});
+			
+			// html
+			conditionTypes.map(function( model ){
+				choices.push({
+					id:		model.prototype.operator,
+					text:	acf.strEscape(model.prototype.label)
+				});
+			});
+			
+			// render
+			acf.renderSelect( $select, choices );
+			
+			// set
+			this.ruleData('operator', $select.val());
+		},
+		
+		renderValue: function(){
+			
+			// bail early if no field selected
+			if( !this.ruleData('field') || !this.ruleData('operator') ) {
+				return;
+			}
+			
+			// vars
+			var $select = this.$input('value');
+			var $td = this.$td('value');
+			var val = $select.val();
+			
+			// get selected field
+			var $field = acf.findFieldObject( this.ruleData('field') );
+			var field = acf.getFieldObject( $field );
+			
+			// get selected field conditions
+			var conditionTypes = acf.getConditionTypes({
+				fieldType: field.getType(),
+				operator: this.ruleData('operator')
+			});
+			
+			// html
+			var conditionType = conditionTypes[0].prototype;
+			var choices = conditionType.choices( field );
+			
+			// create html: array
+			if( choices instanceof Array ) {
+				var $newSelect = $('<select></select>');
+				acf.renderSelect( $newSelect, choices );
+			
+			// create html: string (<input />)
+			} else {
+				var $newSelect = $(choices);
+			}
+			
+			// append
+			$select.detach();
+			$td.html( $newSelect );
+			
+			// copy attrs
+			// timeout needed to avoid browser bug where "disabled" attribute is not applied
+			setTimeout(function(){
+				['class', 'name', 'id'].map(function( attr ){
+					$newSelect.attr( attr, $select.attr(attr));
+				});
+			}, 0);
+			
+			// select existing value (if not a disabled input)
+			if( !$newSelect.prop('disabled') ) {
+				acf.val( $newSelect, val, true );
+			}
+			
+			// set
+			this.ruleData('value', $newSelect.val());
+		},
+		
+		onChangeToggle: function(){
+			this.render();
+		},
+		
+		onClickAddGroup: function( e, $el ){
+			this.addGroup();
+		},
+		
+		addGroup: function(){
+			
+			// vars
+			var $group = this.$('.rule-group:last');
+			
+			// duplicate
+			var $group2 = acf.duplicate( $group );
+			
+			// update h4
+			$group2.find('h4').text( acf.__('or') );
+			
+			// remove all tr's except the first one
+			$group2.find('tr').not(':first').remove();
+			
+			// save field
+			this.fieldObject.save();
+		},
+		
+		onFocusField: function( e, $el ){
+			this.renderField();
+		},
+		
+		onChangeField: function( e, $el ){
+			
+			// scope
+			this.scope( $el.closest('.rule') );
+			
+			// set data
+			this.ruleData('field', $el.val());
+			
+			// render
+			this.renderOperator();
+			this.renderValue();
+		},
+		
+		onChangeOperator: function( e, $el ){
+			
+			// scope
+			this.scope( $el.closest('.rule') );
+			
+			// set data
+			this.ruleData('operator', $el.val());
+			
+			// render
+			this.renderValue();
+		},
+		
+		onClickAdd: function( e, $el ){
+			
+			// duplciate
+			var $rule = acf.duplicate( $el.closest('.rule') );
+			
+			// render
+			this.renderRule( $rule );
+		},
+		
+		onClickRemove: function( e, $el ){
+			
+			// vars
+			var $rule = $el.closest('.rule');
+			
+			// save field
+			this.fieldObject.save();
+			
+			// remove group
+			if( $rule.siblings('.rule').length == 0 ) {
+				$rule.closest('.rule-group').remove();
+			}
+			
+			// remove
+			$rule.remove();
+		}
+	});
+	
+	acf.registerFieldSetting( ConditionalLogicFieldSetting );
+	
+	
+	/**
+	*  conditionalLogicHelper
+	*
+	*  description
+	*
+	*  @date	20/4/18
+	*  @since	5.6.9
+	*
+	*  @param	type $var Description. Default.
+	*  @return	type Description.
+	*/
+	
+	var conditionalLogicHelper = new acf.Model({
+		actions: {
+			'duplicate_field_objects':	'onDuplicateFieldObjects',
+		},
+		
+		onDuplicateFieldObjects: function( children, newField, prevField ){
+			
+			// vars
+			var data = {};
+			var $selects = $();
+			
+			// reference change in key
+			children.map(function( child ){
+				
+				// store reference of changed key
+				data[ child.get('prevKey') ] = child.get('key');
+				
+				// append condition select
+				$selects = $selects.add( child.$('.condition-rule-field') );
+			});
+			
+			// loop
+	    	$selects.each(function(){
+		    	
+		    	// vars
+		    	var $select = $(this);
+		    	var val = $select.val();
+		    	
+		    	// bail early if val is not a ref key
+		    	if( !val || !data[val] ) {
+			    	return;
+		    	}
+		    	
+		    	// modify selected option
+		    	$select.find('option:selected').attr('value', data[val]);
+		    	
+		    	// set new val
+		    	$select.val( data[val] );
+		    	
+	    	});
+		},
+	});
+})(jQuery);

wp-content/plugins/advanced-custom-fields/assets/build/js/_field-group-field.js

@@ -0,0 +1,808 @@
+(function($, undefined){
+	
+	acf.FieldObject = acf.Model.extend({
+		
+		// class used to avoid nested event triggers
+		eventScope: '.acf-field-object',
+		
+		// events
+		events: {
+			'click .edit-field':		'onClickEdit',
+			'click .delete-field':		'onClickDelete',
+			'click .duplicate-field':	'duplicate',
+			'click .move-field':		'move',
+			
+			'change .field-type':		'onChangeType',
+			'change .field-required':	'onChangeRequired',
+			'blur .field-label':		'onChangeLabel',
+			'blur .field-name':			'onChangeName',
+			
+			'change':					'onChange',
+			'changed':					'onChanged',
+		},
+		
+		// data
+		data: {
+			
+			// Similar to ID, but used for HTML puposes.
+			// It is possbile for a new field to have an ID of 0, but an id of 'field_123' */
+			id: 0,
+			
+			// The field key ('field_123')
+			key: '',
+			
+			// The field type (text, image, etc)
+			type: '',
+			
+			// The $post->ID of this field
+			//ID: 0,
+			
+			// The field's parent
+			//parent: 0,
+			
+			// The menu order
+			//menu_order: 0
+		},
+		
+		setup: function( $field ){
+			
+			// set $el
+			this.$el = $field;
+			
+			// inherit $field data (id, key, type)
+			this.inherit( $field );
+			
+			// load additional props
+			// - this won't trigger 'changed'
+			this.prop('ID');
+			this.prop('parent');
+			this.prop('menu_order');
+		},
+		
+		$input: function( name ){
+			return $('#' + this.getInputId() + '-' + name);
+		},
+		
+		$meta: function(){
+			return this.$('.meta:first');
+		},
+		
+		$handle: function(){
+			return this.$('.handle:first');
+		},
+		
+		$settings: function(){
+			return this.$('.settings:first');
+		},
+		
+		$setting: function( name ){
+			return this.$('.acf-field-settings:first > .acf-field-setting-' + name);
+		},
+		
+		getParent: function(){
+			return acf.getFieldObjects({ child: this.$el, limit: 1 }).pop();
+		},
+		
+		getParents: function(){
+			return acf.getFieldObjects({ child: this.$el });
+		},
+		
+		getFields: function(){
+			return acf.getFieldObjects({ parent: this.$el });
+		},
+		
+		getInputName: function(){
+			return 'acf_fields[' + this.get('id') + ']';
+		},
+		
+		getInputId: function(){
+			return 'acf_fields-' + this.get('id');
+		},
+		
+		newInput: function( name, value ){
+			
+			// vars
+			var inputId = this.getInputId();
+			var inputName = this.getInputName();
+			
+			// append name
+			if( name ) {
+				inputId += '-'+name;
+				inputName += '['+name+']';
+			}
+			
+			// create input (avoid HTML + JSON value issues)
+			var $input = $('<input />').attr({
+				id: inputId,
+				name: inputName,
+				value: value
+			});
+			this.$('> .meta').append( $input );
+			
+			// return
+			return $input;
+		},
+		
+		getProp: function( name ){
+			
+			// check data
+			if( this.has(name) ) {
+				return this.get(name);
+			}
+			
+			// get input value
+			var $input = this.$input( name );
+			var value = $input.length ? $input.val() : null;
+			
+			// set data silently (cache)
+			this.set(name, value, true);
+			
+			// return
+			return value;
+		},
+		
+		setProp: function( name, value ) {
+			
+			// get input
+			var $input = this.$input( name );
+			var prevVal = $input.val();
+			
+			// create if new
+			if( !$input.length ) {
+				$input = this.newInput( name, value );
+			}
+			
+			// remove
+			if( value === null ) {
+				$input.remove();
+				
+			// update
+			} else {
+				$input.val( value );	
+			}
+			
+			//console.log('setProp', name, value, this);
+			
+			// set data silently (cache)
+			if( !this.has(name) ) {
+				//console.log('setting silently');
+				this.set(name, value, true);
+				
+			// set data allowing 'change' event to fire
+			} else {
+				//console.log('setting loudly!');
+				this.set(name, value);
+			}
+			
+			// return
+			return this;
+			
+		},
+		
+		prop: function( name, value ){
+			if( value !== undefined ) {
+				return this.setProp( name, value );
+			} else {
+				return this.getProp( name );
+			}
+		},
+		
+		props: function( props ){
+			Object.keys( props ).map(function( key ){
+				this.setProp( key, props[key] );
+			}, this);
+		},
+		
+		getLabel: function(){
+			
+			// get label with empty default
+			var label = this.prop('label');
+			if( label === '' ) {
+				label = acf.__('(no label)')
+			}
+			
+			// return
+			return label;
+		},
+		
+		getName: function(){
+			return this.prop('name');
+		},
+		
+		getType: function(){
+			return this.prop('type');
+		},
+		
+		getTypeLabel: function(){
+			var type = this.prop('type');
+			var types = acf.get('fieldTypes');
+			return ( types[type] ) ? types[type].label : type;
+		},
+		
+		getKey: function(){
+			return this.prop('key');
+		},
+			
+		initialize: function(){
+			// do nothing
+		},
+		
+		render: function(){
+					
+			// vars
+			var $handle = this.$('.handle:first');
+			var menu_order = this.prop('menu_order');
+			var label = this.getLabel();
+			var name = this.prop('name');
+			var type = this.getTypeLabel();
+			var key = this.prop('key');
+			var required = this.$input('required').prop('checked');
+			
+			// update menu order
+			$handle.find('.acf-icon').html( parseInt(menu_order) + 1 );
+			
+			// update required
+			if( required ) {
+				label += ' <span class="acf-required">*</span>';
+			}
+			
+			// update label
+			$handle.find('.li-field-label strong a').html( label );
+						
+			// update name
+			$handle.find('.li-field-name').text( name );
+			
+			// update type
+			$handle.find('.li-field-type').text( type );
+			
+			// update key
+			$handle.find('.li-field-key').text( key );
+			
+			// action for 3rd party customization
+			acf.doAction('render_field_object', this);
+		},
+		
+		refresh: function(){
+			acf.doAction('refresh_field_object', this);
+		},
+		
+		isOpen: function() {
+			return this.$el.hasClass('open');
+		},
+		
+		onClickEdit: function( e ){
+			this.isOpen() ? this.close() : this.open();
+		},
+		
+		open: function(){
+			
+			// vars
+			var $settings = this.$el.children('.settings');
+			
+			// open
+			$settings.slideDown();
+			this.$el.addClass('open');
+			
+			// action (open)
+			acf.doAction('open_field_object', this);
+			this.trigger('openFieldObject');
+			
+			// action (show)
+			acf.doAction('show', $settings);
+		},
+		
+		close: function(){
+			
+			// vars
+			var $settings = this.$el.children('.settings');
+			
+			// close
+			$settings.slideUp();
+			this.$el.removeClass('open');
+			
+			// action (close)
+			acf.doAction('close_field_object', this);
+			this.trigger('closeFieldObject');
+			
+			// action (hide)
+			acf.doAction('hide', $settings);
+		},
+		
+		serialize: function(){
+			return acf.serialize( this.$el, this.getInputName() );
+		},
+		
+		save: function( type ){
+			
+			// defaults
+			type = type || 'settings'; // meta, settings
+			
+			// vars
+			var save = this.getProp('save');
+			
+			// bail if already saving settings
+			if( save === 'settings' ) {
+				return;
+			}
+			
+			// prop
+			this.setProp('save', type);
+			
+			// debug
+			this.$el.attr('data-save', type);
+			
+			// action
+			acf.doAction('save_field_object', this, type);
+		},
+		
+		submit: function(){
+			
+			// vars
+			var inputName = this.getInputName();
+			var save = this.get('save');
+			
+			// close
+			if( this.isOpen() ) {
+				this.close();
+			}
+			
+			// allow all inputs to save
+			if( save == 'settings' ) {
+				// do nothing
+			
+			// allow only meta inputs to save	
+			} else if( save == 'meta' ) {
+				this.$('> .settings [name^="' + inputName + '"]').remove();
+				
+			// prevent all inputs from saving
+			} else {
+				this.$('[name^="' + inputName + '"]').remove();
+			}
+			
+			// action
+			acf.doAction('submit_field_object', this);
+		},
+		
+		onChange: function( e, $el ){
+			
+			// save settings
+			this.save();
+			
+			// action for 3rd party customization
+			acf.doAction('change_field_object', this);
+		},
+		
+		onChanged: function( e, $el, name, value ){
+			
+			// ignore 'save'
+			if( name == 'save' ) {
+				return;
+			}
+			
+			// save meta
+			if( ['menu_order', 'parent'].indexOf(name) > -1 ) {
+				this.save('meta');
+			
+			// save field
+			} else {
+				this.save();
+			}			
+			
+			// render
+			if( ['menu_order', 'label', 'required', 'name', 'type', 'key'].indexOf(name) > -1 ) {
+				this.render();
+			}
+						
+			// action for 3rd party customization
+			acf.doAction('change_field_object_' + name, this, value);
+		},
+		
+		onChangeLabel: function( e, $el ){
+			
+			// set
+			var label = $el.val();
+			this.set('label', label);
+			
+			// render name
+			if( this.prop('name') == '' ) {
+				var name = acf.applyFilters('generate_field_object_name', acf.strSanitize(label), this);
+				this.prop('name', name);
+			}
+		},
+		
+		onChangeName: function( e, $el){
+			
+			// set
+			var name = $el.val();
+			this.set('name', name);
+			
+			// error
+			if( name.substr(0, 6) === 'field_' ) {
+				alert( acf.__('The string "field_" may not be used at the start of a field name') );
+			}
+		},
+		
+		onChangeRequired: function( e, $el ){
+			
+			// set
+			var required = $el.prop('checked') ? 1 : 0;
+			this.set('required', required);
+		},
+		
+		delete: function( args ){
+			
+			// defaults
+			args = acf.parseArgs(args, {
+				animate: true
+			});
+			
+			// add to remove list
+			var id = this.prop('ID');
+			
+			if( id ) {
+				var $input = $('#_acf_delete_fields');
+				var newVal = $input.val() + '|' + id;
+				$input.val( newVal );
+			}
+			
+			// action
+			acf.doAction('delete_field_object', this);
+			
+			// animate
+			if( args.animate ) {
+				this.removeAnimate();
+			} else {
+				this.remove();
+			}
+		},
+		
+		onClickDelete: function( e, $el ){
+			
+			// add class
+			this.$el.addClass('-hover');
+			
+			// add tooltip
+			var self = this;
+			var tooltip = acf.newTooltip({
+				confirmRemove: true,
+				target: $el,
+				confirm: function(){
+					self.delete( true );
+				},
+				cancel: function(){
+					self.$el.removeClass('-hover');
+				}
+			});
+		},
+		
+		removeAnimate: function(){
+			
+			// vars
+			var field = this;
+			var $list = this.$el.parent();
+			var $fields = acf.findFieldObjects({
+				sibling: this.$el
+			});
+			
+			// remove
+			acf.remove({
+				target: this.$el,
+				endHeight: $fields.length ? 0 : 50,
+				complete: function(){
+					field.remove();
+					acf.doAction('removed_field_object', field, $list);
+				}
+			});
+			
+			// action
+			acf.doAction('remove_field_object', field, $list);
+		},
+		
+		duplicate: function(){
+			
+			// vars
+			var newKey = acf.uniqid('field_');
+			
+			// duplicate
+			var $newField = acf.duplicate({
+				target: this.$el,
+				search: this.get('id'),
+				replace: newKey,
+			});
+			
+			// set new key
+			$newField.attr('data-key', newKey);
+			
+			// get instance
+			var newField = acf.getFieldObject( $newField );
+			
+			// open / close
+			if( this.isOpen() ) {
+				this.close();
+			} else {
+				newField.open();
+			}
+			
+			// focus label
+			var $label = newField.$setting('label input');
+			setTimeout(function(){
+	        	$label.focus();
+	        }, 251);
+			
+			// update newField label / name
+			var label = newField.prop('label');
+			var name = newField.prop('name');
+			var end = name.split('_').pop();
+			var copy = acf.__('copy');
+			
+			// increase suffix "1"
+			if( $.isNumeric(end) ) {
+				var i = (end*1) + 1;
+				label = label.replace( end, i );
+				name = name.replace( end, i );
+			
+			// increase suffix "(copy1)"
+			} else if( end.indexOf(copy) === 0 ) {
+				var i = end.replace(copy, '') * 1;
+				i = i ? i+1 : 2;
+				
+				// replace
+				label = label.replace( end, copy + i );
+				name = name.replace( end, copy + i );
+			
+			// add default "(copy)"
+			} else {
+				label += ' (' + copy + ')';
+				name += '_' + copy;
+			}
+			
+			newField.prop('ID', 0);
+			newField.prop('label', label);
+			newField.prop('name', name);
+			newField.prop('key', newKey);
+			
+			// action
+			acf.doAction('duplicate_field_object', this, newField);
+			acf.doAction('append_field_object', newField);
+		},
+		
+		wipe: function(){
+			
+			// vars
+			var prevId = this.get('id');
+			var prevKey = this.get('key');
+			var newKey = acf.uniqid('field_');
+			
+			// rename
+			acf.rename({
+				target: this.$el,
+				search: prevId,
+				replace: newKey,
+			});
+			
+			// data
+			this.set('id', newKey);
+			this.set('prevId', prevId);
+			this.set('prevKey', prevKey);
+			
+			// props
+			this.prop('key', newKey);
+			this.prop('ID', 0);
+			
+			// attr
+			this.$el.attr('data-key', newKey);
+			this.$el.attr('data-id', newKey);
+			
+			// action
+			acf.doAction('wipe_field_object', this);
+		},
+		
+		move: function(){
+			
+			// helper
+			var hasChanged = function( field ){
+				return (field.get('save') == 'settings');
+			};
+			
+			// vars
+			var changed = hasChanged(this);
+			
+			// has sub fields changed
+			if( !changed ) {
+				acf.getFieldObjects({
+					parent: this.$el
+				}).map(function( field ){
+					changed = hasChanged(field) || field.changed;
+				});
+			}
+			
+			// bail early if changed
+			if( changed ) {
+				alert( acf.__('This field cannot be moved until its changes have been saved') );
+				return;
+			}
+			
+			// step 1.
+			var id = this.prop('ID');
+			var field = this;
+			var popup = false;
+			var step1 = function(){
+				
+				// popup
+				popup = acf.newPopup({
+					title: acf.__('Move Custom Field'),
+					loading: true,
+					width: '300px'
+				});
+				
+				// ajax
+				var ajaxData = {
+					action:		'acf/field_group/move_field',
+					field_id:	id
+				};
+				
+				// get HTML
+				$.ajax({
+					url: acf.get('ajaxurl'),
+					data: acf.prepareForAjax(ajaxData),
+					type: 'post',
+					dataType: 'html',
+					success: step2
+				});
+			};
+			
+			var step2 = function( html ){
+				
+				// update popup
+				popup.loading(false);
+				popup.content(html);
+				
+				// submit form
+				popup.on('submit', 'form', step3);
+			};
+			
+			var step3 = function( e, $el ){
+				
+				// prevent
+				e.preventDefault();
+				
+				// disable
+				acf.startButtonLoading( popup.$('.button') );
+				
+				// ajax
+				var ajaxData = {
+					action: 'acf/field_group/move_field',
+					field_id: id,
+					field_group_id: popup.$('select').val()
+				};
+				
+				// get HTML
+				$.ajax({
+					url: acf.get('ajaxurl'),
+					data: acf.prepareForAjax(ajaxData),
+					type: 'post',
+					dataType: 'html',
+					success: step4
+				});
+			};
+			
+			var step4 = function( html ){
+				
+				// update popup
+				popup.content(html);
+				
+				// remove element
+				field.removeAnimate();
+			};
+			
+			// start
+			step1();
+			
+		},
+		
+		onChangeType: function( e, $el ){
+			
+			// clea previous timout
+			if( this.changeTimeout ) {
+				clearTimeout(this.changeTimeout);
+			}
+			
+			// set new timeout
+			// - prevents changing type multiple times whilst user types in newType
+			this.changeTimeout = this.setTimeout(function(){
+				this.changeType( $el.val() );
+			}, 300);
+		},
+		
+		changeType: function( newType ){
+			
+			// vars
+			var prevType = this.prop('type');
+			var prevClass = acf.strSlugify( 'acf-field-object-' + prevType );
+			var newClass = acf.strSlugify( 'acf-field-object-' + newType );
+			
+			// update props
+			this.$el.removeClass(prevClass).addClass(newClass);
+			this.$el.attr('data-type', newType);
+			this.$el.data('type', newType);
+			
+			// abort XHR if this field is already loading AJAX data
+			if( this.has('xhr') ) {
+				this.get('xhr').abort();
+			}
+			
+			// store settings
+			var $tbody = this.$('> .settings > table > tbody');
+			var $settings = $tbody.children('[data-setting="' + prevType + '"]');			
+			this.set( 'settings-' + prevType, $settings );
+			$settings.detach();
+						
+			// show settings
+			if( this.has('settings-' + newType) ) {
+				var $newSettings = this.get('settings-' + newType);
+				this.$setting('conditional_logic').before( $newSettings );
+				this.set('type', newType);
+				//this.refresh();
+				return;
+			}
+			
+			// load settings
+			var $loading = $('<tr class="acf-field"><td class="acf-label"></td><td class="acf-input"><div class="acf-loading"></div></td></tr>');
+			this.$setting('conditional_logic').before( $loading );
+			
+			// ajax
+			var ajaxData = {
+				action: 'acf/field_group/render_field_settings',
+				field: this.serialize(),
+				prefix: this.getInputName()
+			};			
+			
+			// ajax
+			var xhr = $.ajax({
+				url: acf.get('ajaxurl'),
+				data: acf.prepareForAjax(ajaxData),
+				type: 'post',
+				dataType: 'html',
+				context: this,
+				success: function( html ){
+					
+					// bail early if no settings
+					if( !html ) return;
+					
+					// append settings
+					$loading.after( html );
+					
+					// events
+					acf.doAction('append', $tbody);
+				},
+				complete: function(){
+					// also triggered by xhr.abort();
+					$loading.remove();
+					this.set('type', newType);
+					//this.refresh();
+				}
+			});
+			
+			// set
+			this.set('xhr', xhr);
+			
+		},
+		
+		updateParent: function(){
+			
+			// vars
+			var ID = acf.get('post_id');
+			
+			// check parent
+			var parent = this.getParent();
+			if( parent ) {
+				ID = parseInt(parent.prop('ID')) || parent.prop('key');
+			}
+			
+			// update
+			this.prop('parent', ID);
+		}
+				
+	});
+	
+})(jQuery);

wp-content/plugins/advanced-custom-fields/assets/build/js/_field-group-fields.js

@@ -0,0 +1,468 @@
+(function($, undefined){
+	
+	/**
+	*  acf.findFieldObject
+	*
+	*  Returns a single fieldObject $el for a given field key
+	*
+	*  @date	1/2/18
+	*  @since	5.7.0
+	*
+	*  @param	string key The field key
+	*  @return	jQuery
+	*/
+	
+	acf.findFieldObject = function( key ){
+		return acf.findFieldObjects({
+			key: key,
+			limit: 1
+		});
+	};
+	
+	/**
+	*  acf.findFieldObjects
+	*
+	*  Returns an array of fieldObject $el for the given args
+	*
+	*  @date	1/2/18
+	*  @since	5.7.0
+	*
+	*  @param	object args
+	*  @return	jQuery
+	*/
+	
+	acf.findFieldObjects = function( args ){
+		
+		// vars
+		args = args || {};
+		var selector = '.acf-field-object';
+		var $fields = false;
+		
+		// args
+		args = acf.parseArgs(args, {
+			id: '',
+			key: '',
+			type: '',
+			limit: false,
+			list: null,
+			parent: false,
+			sibling: false,
+			child: false,
+		});
+		
+		// id
+		if( args.id ) {
+			selector += '[data-id="' + args.id + '"]';
+		}
+		
+		// key
+		if( args.key ) {
+			selector += '[data-key="' + args.key + '"]';
+		}
+		
+		// type
+		if( args.type ) {
+			selector += '[data-type="' + args.type + '"]';
+		}
+		
+		// query
+		if( args.list ) {
+			$fields = args.list.children( selector );
+		} else if( args.parent ) {
+			$fields = args.parent.find( selector );
+		} else if( args.sibling ) {
+			$fields = args.sibling.siblings( selector );
+		} else if( args.child ) {
+			$fields = args.child.parents( selector );
+		} else {
+			$fields = $( selector );
+		}
+		
+		// limit
+		if( args.limit ) {
+			$fields = $fields.slice( 0, args.limit );
+		}
+		
+		// return
+		return $fields;
+	};
+	
+	/**
+	*  acf.getFieldObject
+	*
+	*  Returns a single fieldObject instance for a given $el|key
+	*
+	*  @date	1/2/18
+	*  @since	5.7.0
+	*
+	*  @param	string|jQuery $field The field $el or key
+	*  @return	jQuery
+	*/
+	
+	acf.getFieldObject = function( $field ){
+		
+		// allow key
+		if( typeof $field === 'string' ) {
+			$field = acf.findFieldObject( $field );
+		}
+		
+		// instantiate
+		var field = $field.data('acf');
+		if( !field ) {
+			field = acf.newFieldObject( $field );
+		}
+		
+		// return
+		return field;
+	};
+	
+	/**
+	*  acf.getFieldObjects
+	*
+	*  Returns an array of fieldObject instances for the given args
+	*
+	*  @date	1/2/18
+	*  @since	5.7.0
+	*
+	*  @param	object args
+	*  @return	array
+	*/
+	
+	acf.getFieldObjects = function( args ){
+		
+		// query
+		var $fields = acf.findFieldObjects( args );
+		
+		// loop
+		var fields = [];
+		$fields.each(function(){
+			var field = acf.getFieldObject( $(this) );
+			fields.push( field );
+		});
+		
+		// return
+		return fields;
+	};
+	
+	/**
+	*  acf.newFieldObject
+	*
+	*  Initializes and returns a new FieldObject instance
+	*
+	*  @date	1/2/18
+	*  @since	5.7.0
+	*
+	*  @param	jQuery $field The field $el
+	*  @return	object
+	*/
+	
+	acf.newFieldObject = function( $field ){
+		
+		// instantiate
+		var field = new acf.FieldObject( $field );
+		
+		// action
+		acf.doAction('new_field_object', field);
+		
+		// return
+		return field;
+	};
+	
+	/**
+	*  actionManager
+	*
+	*  description
+	*
+	*  @date	15/12/17
+	*  @since	5.6.5
+	*
+	*  @param	type $var Description. Default.
+	*  @return	type Description.
+	*/
+	
+	var eventManager = new acf.Model({
+		
+		priority: 5,
+		
+		initialize: function(){
+			
+			// actions
+			var actions = [
+				'prepare',
+				'ready',
+				'append',
+				'remove'
+			];
+			
+			// loop
+			actions.map(function( action ){
+				this.addFieldActions( action );
+			}, this);
+		},
+		
+		addFieldActions: function( action ){
+			
+			// vars
+			var pluralAction = action + '_field_objects';	// ready_field_objects
+			var singleAction = action + '_field_object';	// ready_field_object
+			var singleEvent = action + 'FieldObject';		// readyFieldObject
+			
+			// global action
+			var callback = function( $el /*, arg1, arg2, etc*/ ){
+				
+				// vars
+				var fieldObjects = acf.getFieldObjects({ parent: $el });
+				
+				// call plural
+				if( fieldObjects.length ) {
+					
+					/// get args [$el, arg1]
+					var args = acf.arrayArgs( arguments );
+					
+					// modify args [pluralAction, fields, arg1]
+					args.splice(0, 1, pluralAction, fieldObjects);
+					acf.doAction.apply(null, args);
+				}
+			};
+			
+			// plural action
+			var pluralCallback = function( fieldObjects /*, arg1, arg2, etc*/ ){
+				
+				/// get args [fields, arg1]
+				var args = acf.arrayArgs( arguments );
+				
+				// modify args [singleAction, fields, arg1]
+				args.unshift(singleAction);
+					
+				// loop
+				fieldObjects.map(function( fieldObject ){
+					
+					// modify args [singleAction, field, arg1]
+					args[1] = fieldObject;
+					acf.doAction.apply(null, args);
+				});
+			};
+			
+			// single action
+			var singleCallback = function( fieldObject /*, arg1, arg2, etc*/ ){
+				
+				/// get args [$field, arg1]
+				var args = acf.arrayArgs( arguments );
+				
+				// modify args [singleAction, $field, arg1]
+				args.unshift(singleAction);
+				
+				// action variations (ready_field/type=image)
+				var variations = ['type', 'name', 'key'];
+				variations.map(function( variation ){
+					args[0] = singleAction + '/' + variation + '=' + fieldObject.get(variation);
+					acf.doAction.apply(null, args);
+				});
+				
+				// modify args [arg1]
+				args.splice(0, 2);
+
+				// event
+				fieldObject.trigger(singleEvent, args);
+			};
+			
+			// add actions
+			acf.addAction(action, callback, 5);
+			acf.addAction(pluralAction, pluralCallback, 5);
+			acf.addAction(singleAction, singleCallback, 5);
+			
+		}
+	});		
+	
+	/**
+	*  fieldManager
+	*
+	*  description
+	*
+	*  @date	4/1/18
+	*  @since	5.6.5
+	*
+	*  @param	type $var Description. Default.
+	*  @return	type Description.
+	*/
+	
+	var fieldManager = new acf.Model({
+		
+		id: 'fieldManager',
+		
+		events: {
+			'submit #post':					'onSubmit',
+			'mouseenter .acf-field-list': 	'onHoverSortable',
+			'click .add-field':				'onClickAdd',
+		},
+		
+		actions: {
+			'removed_field_object':			'onRemovedField',
+			'sortstop_field_object':		'onReorderField',
+			'delete_field_object':			'onDeleteField',
+			'change_field_object_type':		'onChangeFieldType',
+			'duplicate_field_object':		'onDuplicateField'
+		},
+		
+		onSubmit: function( e, $el ){
+			
+			// vars
+			var fields = acf.getFieldObjects();
+			
+			// loop
+			fields.map(function( field ){
+				field.submit();
+			});
+		},
+		
+		setFieldMenuOrder: function( field ){
+			this.renderFields( field.$el.parent() );
+		},
+		
+		onHoverSortable: function( e, $el ){
+			
+			// bail early if already sortable
+			if( $el.hasClass('ui-sortable') ) return;
+			
+			// sortable
+			$el.sortable({
+				handle: '.acf-sortable-handle',
+				connectWith: '.acf-field-list',
+				start: function( e, ui ){
+					var field = acf.getFieldObject( ui.item );
+			        ui.placeholder.height( ui.item.height() );
+			        acf.doAction('sortstart_field_object', field, $el);
+			    },
+				update: function( e, ui ){
+					var field = acf.getFieldObject( ui.item );
+					acf.doAction('sortstop_field_object', field, $el);
+				}
+			});
+		},
+		
+		onRemovedField: function( field, $list ){
+			this.renderFields( $list );
+		},
+		
+		onReorderField: function( field, $list ){
+			field.updateParent();
+			this.renderFields( $list );
+		},
+		
+		onDeleteField: function( field ){
+			
+			// delete children
+			field.getFields().map(function( child ){
+				child.delete({ animate: false });
+			});
+		},
+		
+		onChangeFieldType: function( field ){
+			// this caused sub fields to disapear if changing type back...
+			//this.onDeleteField( field );	
+		},
+		
+		onDuplicateField: function( field, newField ){
+			
+			// check for children
+			var children = newField.getFields();
+			if( children.length ) {
+				
+				// loop
+				children.map(function( child ){
+					
+					// wipe field
+					child.wipe();
+					
+					// update parent
+					child.updateParent();
+				});
+			
+				// action
+				acf.doAction('duplicate_field_objects', children, newField, field);
+			}
+			
+			// set menu order
+			this.setFieldMenuOrder( newField );
+		},
+		
+		renderFields: function( $list ){
+			
+			// vars
+			var fields = acf.getFieldObjects({
+				list: $list
+			});
+			
+			// no fields
+			if( !fields.length ) {
+				$list.addClass('-empty');
+				return;
+			}
+			
+			// has fields
+			$list.removeClass('-empty');
+			
+			// prop
+			fields.map(function( field, i ){
+				field.prop('menu_order', i);
+			});
+		},
+		
+		onClickAdd: function( e, $el ){
+			var $list = $el.closest('.acf-tfoot').siblings('.acf-field-list');
+			this.addField( $list );
+		},
+		
+		addField: function( $list ){
+			
+			// vars
+			var html = $('#tmpl-acf-field').html();
+			var $el = $(html);
+			var prevId = $el.data('id');
+			var newKey = acf.uniqid('field_');
+			
+			// duplicate
+			var $newField = acf.duplicate({
+				target: $el,
+				search: prevId,
+				replace: newKey,
+				append: function( $el, $el2 ){ 
+					$list.append( $el2 );
+				}
+			});
+			
+			// get instance
+			var newField = acf.getFieldObject( $newField );
+			
+			// props
+			newField.prop('key', newKey);
+			newField.prop('ID', 0);
+			newField.prop('label', '');
+			newField.prop('name', '');
+			
+			// attr
+			$newField.attr('data-key', newKey);
+			$newField.attr('data-id', newKey);
+			
+			// update parent prop
+			newField.updateParent();
+			
+			// focus label
+			var $label = newField.$input('label');
+			setTimeout(function(){
+	        	$label.focus();
+	        }, 251);
+	        
+	        // open
+			newField.open();
+			
+			// set menu order
+			this.renderFields( $list );
+			
+			// action
+			acf.doAction('add_field_object', newField);
+			acf.doAction('append_field_object', newField);
+		}
+	});
+	
+})(jQuery);

wp-content/plugins/advanced-custom-fields/assets/build/js/_field-group-locations.js

@@ -0,0 +1,104 @@
+(function($, undefined){
+	
+	/**
+	*  locationManager
+	*
+	*  Field group location rules functionality 
+	*
+	*  @date	15/12/17
+	*  @since	5.7.0
+	*
+	*  @param	void
+	*  @return	void
+	*/
+	
+	var locationManager = new acf.Model({
+		
+		id: 'locationManager',
+		wait: 'ready',
+		
+		events: {
+			'click .add-location-rule':			'onClickAddRule',
+			'click .add-location-group':		'onClickAddGroup',
+			'click .remove-location-rule':		'onClickRemoveRule',
+			'change .refresh-location-rule':	'onChangeRemoveRule'
+		},
+		
+		initialize: function(){
+			this.$el = $('#acf-field-group-locations');
+		},
+		
+		onClickAddRule: function( e, $el ){
+			this.addRule( $el.closest('tr') );
+		},
+		
+		onClickRemoveRule: function( e, $el ){
+			this.removeRule( $el.closest('tr') );
+		},
+		
+		onChangeRemoveRule: function( e, $el ){
+			this.changeRule( $el.closest('tr') );
+		},
+		
+		onClickAddGroup: function( e, $el ){
+			this.addGroup();
+		},
+		
+		addRule: function( $tr ){
+			acf.duplicate( $tr );
+		},
+		
+		removeRule: function( $tr ){
+			if( $tr.siblings('tr').length == 0 ) {
+				$tr.closest('.rule-group').remove();
+			} else {
+				$tr.remove();
+			}
+		},
+		
+		changeRule: function( $rule ){
+			
+			// vars
+			var $group = $rule.closest('.rule-group');
+			var prefix = $rule.find('td.param select').attr('name').replace('[param]', '');
+			
+			// ajaxdata
+			var ajaxdata = {};
+			ajaxdata.action = 'acf/field_group/render_location_rule';
+			ajaxdata.rule = acf.serialize( $rule, prefix );
+			ajaxdata.rule.id = $rule.data('id');
+			ajaxdata.rule.group = $group.data('id');
+			
+			// temp disable
+			acf.disable( $rule.find('td.value') );
+			
+			// ajax
+			$.ajax({
+				url: acf.get('ajaxurl'),
+				data: acf.prepareForAjax(ajaxdata),
+				type: 'post',
+				dataType: 'html',
+				success: function( html ){
+					if( !html ) return;
+					$rule.replaceWith( html );
+				}
+			});
+		},
+		
+		addGroup: function(){
+			
+			// vars
+			var $group = this.$('.rule-group:last');
+			
+			// duplicate
+			$group2 = acf.duplicate( $group );
+			
+			// update h4
+			$group2.find('h4').text( acf.__('or') );
+			
+			// remove all tr's except the first one
+			$group2.find('tr').not(':first').remove();
+		}
+	});
+	
+})(jQuery);

wp-content/plugins/advanced-custom-fields/assets/build/js/_field-group-settings.js

@@ -0,0 +1,248 @@
+(function($, undefined){
+	
+	/**
+	*  mid
+	*
+	*  Calculates the model ID for a field type
+	*
+	*  @date	15/12/17
+	*  @since	5.6.5
+	*
+	*  @param	string type
+	*  @return	string
+	*/
+	
+	var modelId = function( type ) {
+		return acf.strPascalCase( type || '' ) + 'FieldSetting';
+	};
+	
+	/**
+	*  registerFieldType
+	*
+	*  description
+	*
+	*  @date	14/12/17
+	*  @since	5.6.5
+	*
+	*  @param	type $var Description. Default.
+	*  @return	type Description.
+	*/
+	
+	acf.registerFieldSetting = function( model ){
+		var proto = model.prototype;
+		var mid = modelId(proto.type + ' ' + proto.name);
+		this.models[ mid ] = model;
+	};
+	
+	/**
+	*  newField
+	*
+	*  description
+	*
+	*  @date	14/12/17
+	*  @since	5.6.5
+	*
+	*  @param	type $var Description. Default.
+	*  @return	type Description.
+	*/
+	
+	acf.newFieldSetting = function( field ){
+		
+		// vars
+		var type = field.get('setting') || '';
+		var name = field.get('name') || '';
+		var mid = modelId( type + ' ' + name );
+		var model = acf.models[ mid ] || null;
+		
+		// bail ealry if no setting
+		if( model === null ) return false;
+		
+		// instantiate
+		var setting = new model( field );
+		
+		// return
+		return setting;
+	};
+	
+	/**
+	*  acf.getFieldSetting
+	*
+	*  description
+	*
+	*  @date	19/4/18
+	*  @since	5.6.9
+	*
+	*  @param	type $var Description. Default.
+	*  @return	type Description.
+	*/
+	
+	acf.getFieldSetting = function( field ) {
+		
+		// allow jQuery
+		if( field instanceof jQuery ) {
+			field = acf.getField(field);
+		}
+		
+		// return
+		return field.setting;
+	};
+	
+	/**
+	*  settingsManager
+	*
+	*  description
+	*
+	*  @date	6/1/18
+	*  @since	5.6.5
+	*
+	*  @param	type $var Description. Default.
+	*  @return	type Description.
+	*/
+	
+	var settingsManager = new acf.Model({
+		actions: {
+			'new_field': 'onNewField'
+		},
+		onNewField: function( field ){
+			field.setting = acf.newFieldSetting( field );
+		}
+	});
+	
+	/**
+	*  acf.FieldSetting
+	*
+	*  description
+	*
+	*  @date	6/1/18
+	*  @since	5.6.5
+	*
+	*  @param	type $var Description. Default.
+	*  @return	type Description.
+	*/
+	
+	acf.FieldSetting = acf.Model.extend({
+
+		field: false,
+		type: '',
+		name: '',
+		wait: 'ready',
+		eventScope: '.acf-field',
+		
+		events: {
+			'change': 'render'
+		},
+		
+		setup: function( field ){
+			
+			// vars
+			var $field = field.$el;
+			
+			// set props
+			this.$el = $field;
+			this.field = field;
+			this.$fieldObject = $field.closest('.acf-field-object');
+			this.fieldObject = acf.getFieldObject( this.$fieldObject );
+			
+			// inherit data
+			$.extend(this.data, field.data);
+		},
+		
+		initialize: function(){
+			this.render();
+		},
+		
+		render: function(){
+			// do nothing
+		}
+	});
+	
+	/*
+	*  Date Picker
+	*
+	*  This field type requires some extra logic for its settings
+	*
+	*  @type	function
+	*  @date	24/10/13
+	*  @since	5.0.0
+	*
+	*  @param	n/a
+	*  @return	n/a
+	*/
+	
+	var DisplayFormatFieldSetting = acf.FieldSetting.extend({
+		type: '',
+		name: '',
+		render: function(){
+			var $input = this.$('input[type="radio"]:checked');
+			if( $input.val() != 'other' ) {
+				this.$('input[type="text"]').val( $input.val() );
+			}
+		}
+	});
+	
+	var DatePickerDisplayFormatFieldSetting = DisplayFormatFieldSetting.extend({
+		type: 'date_picker',
+		name: 'display_format'
+	});
+	
+	var DatePickerReturnFormatFieldSetting = DisplayFormatFieldSetting.extend({
+		type: 'date_picker',
+		name: 'return_format'
+	});
+	
+	acf.registerFieldSetting( DatePickerDisplayFormatFieldSetting );
+	acf.registerFieldSetting( DatePickerReturnFormatFieldSetting );
+	
+	/*
+	*  Date Time Picker
+	*
+	*  This field type requires some extra logic for its settings
+	*
+	*  @type	function
+	*  @date	24/10/13
+	*  @since	5.0.0
+	*
+	*  @param	n/a
+	*  @return	n/a
+	*/
+	
+	var DateTimePickerDisplayFormatFieldSetting = DisplayFormatFieldSetting.extend({
+		type: 'date_time_picker',
+		name: 'display_format'
+	});
+	
+	var DateTimePickerReturnFormatFieldSetting = DisplayFormatFieldSetting.extend({
+		type: 'date_time_picker',
+		name: 'return_format'
+	});
+	
+	acf.registerFieldSetting( DateTimePickerDisplayFormatFieldSetting );
+	acf.registerFieldSetting( DateTimePickerReturnFormatFieldSetting );
+	
+	/*
+	*  Time Picker
+	*
+	*  This field type requires some extra logic for its settings
+	*
+	*  @type	function
+	*  @date	24/10/13
+	*  @since	5.0.0
+	*
+	*  @param	n/a
+	*  @return	n/a
+	*/
+	
+	var TimePickerDisplayFormatFieldSetting = DisplayFormatFieldSetting.extend({
+		type: 'time_picker',
+		name: 'display_format'
+	});
+	
+	var TimePickerReturnFormatFieldSetting = DisplayFormatFieldSetting.extend({
+		name: 'time_picker',
+		name: 'return_format'
+	});
+	
+	acf.registerFieldSetting( TimePickerDisplayFormatFieldSetting );
+	acf.registerFieldSetting( TimePickerReturnFormatFieldSetting );
+	
+})(jQuery);

wp-content/plugins/advanced-custom-fields/assets/build/js/_field-group.js

@@ -0,0 +1,182 @@
+(function($, undefined){
+	
+	/**
+	*  fieldGroupManager
+	*
+	*  Generic field group functionality 
+	*
+	*  @date	15/12/17
+	*  @since	5.7.0
+	*
+	*  @param	void
+	*  @return	void
+	*/
+	
+	var fieldGroupManager = new acf.Model({
+		
+		id: 'fieldGroupManager',
+		
+		events: {
+			'submit #post':					'onSubmit',
+			'click a[href="#"]':			'onClick',
+			'click .submitdelete': 			'onClickTrash',
+		},
+		
+		filters: {
+			'find_fields_args':				'filterFindFieldArgs'
+		},
+		
+		onSubmit: function( e, $el ){
+			
+			// vars
+			var $title = $('#titlewrap #title');
+			
+			// empty
+			if( !$title.val() ) {
+				
+				// prevent default
+				e.preventDefault();
+				
+				// unlock form
+				acf.unlockForm( $el );
+				
+				// alert
+				alert( acf.__('Field group title is required') );
+				
+				// focus
+				$title.focus();
+			}
+		},
+		
+		onClick: function( e ){
+			e.preventDefault();
+		},
+		
+		onClickTrash: function( e ){
+			var result = confirm( acf.__('Move to trash. Are you sure?') );
+			if( !result ) {
+				e.preventDefault();
+			}
+		},
+		
+		filterFindFieldArgs: function( args ){
+			args.visible = true;
+			return args;
+		}
+	});
+	
+	
+	/**
+	*  screenOptionsManager
+	*
+	*  Screen options functionality 
+	*
+	*  @date	15/12/17
+	*  @since	5.7.0
+	*
+	*  @param	void
+	*  @return	void
+	*/
+		
+	var screenOptionsManager = new acf.Model({
+		
+		id: 'screenOptionsManager',
+		wait: 'prepare',
+		
+		events: {
+			'change': 'onChange'
+		},
+		
+		initialize: function(){
+			
+			// vars
+			var $div = $('#adv-settings');
+			var $append = $('#acf-append-show-on-screen');
+			
+			// append
+			$div.find('.metabox-prefs').append( $append.html() );
+			$div.find('.metabox-prefs br').remove();
+			
+			// clean up
+			$append.remove();
+			
+			// initialize
+			this.$el = $('#acf-field-key-hide');
+			
+			// render
+			this.render();
+		},
+		
+		isChecked: function(){
+			return this.$el.prop('checked');
+		},
+		
+		onChange: function( e, $el ) {
+			var val = this.isChecked() ? 1 : 0;
+			acf.updateUserSetting('show_field_keys', val);
+			this.render();
+		},
+		
+		render: function(){
+			if( this.isChecked() ) {
+				$('#acf-field-group-fields').addClass('show-field-keys');
+			} else {
+				$('#acf-field-group-fields').removeClass('show-field-keys');
+			}
+		}
+		
+	});
+	
+	
+	/**
+	*  appendFieldManager
+	*
+	*  Appends fields together
+	*
+	*  @date	15/12/17
+	*  @since	5.7.0
+	*
+	*  @param	void
+	*  @return	void
+	*/
+	
+	var appendFieldManager = new acf.Model({
+		
+		actions: {
+			'new_field' : 'onNewField'
+		},
+		
+		onNewField: function( field ){
+			
+			// bail ealry if not append
+			if( !field.has('append') ) return;
+			
+			// vars
+			var append = field.get('append');
+			var $sibling = field.$el.siblings('[data-name="' + append + '"]').first();
+			
+			// bail early if no sibling
+			if( !$sibling.length ) return;
+			
+			// ul
+			var $div = $sibling.children('.acf-input');
+			var $ul = $div.children('ul');
+			
+			// create ul
+			if( !$ul.length ) {
+				$div.wrapInner('<ul class="acf-hl"><li></li></ul>');
+				$ul = $div.children('ul');
+			}
+			
+			// li
+			var html = field.$('.acf-input').html();
+			var $li = $('<li>' + html + '</li>');
+			$ul.append( $li );
+			$ul.attr('data-cols', $ul.children().length );
+			
+			// clean up
+			field.remove();
+		}
+	});
+	
+})(jQuery);

wp-content/plugins/advanced-custom-fields/assets/build/js/acf-field-group.js

@@ -0,0 +1,7 @@
+// @codekit-prepend "_field-group.js";
+// @codekit-prepend "_field-group-field.js";
+// @codekit-prepend "_field-group-settings.js";
+// @codekit-prepend "_field-group-conditions.js";
+// @codekit-prepend "_field-group-fields.js";
+// @codekit-prepend "_field-group-locations.js";
+// @codekit-prepend "_field-group-compatibility.js";

wp-content/plugins/advanced-custom-fields/assets/build/js/acf-field-group.min.js

@@ -0,0 +1,7 @@
+// @codekit-prepend "_field-group.js";
+// @codekit-prepend "_field-group-field.js";
+// @codekit-prepend "_field-group-settings.js";
+// @codekit-prepend "_field-group-conditions.js";
+// @codekit-prepend "_field-group-fields.js";
+// @codekit-prepend "_field-group-locations.js";
+// @codekit-prepend "_field-group-compatibility.js";

wp-content/plugins/advanced-custom-fields/assets/build/js/acf-input.js

@@ -0,0 +1,45 @@
+// @codekit-prepend "_acf.js";
+// @codekit-prepend "_acf-hooks.js";
+// @codekit-prepend "_acf-model.js";
+// @codekit-prepend "_acf-popup.js";
+// @codekit-prepend "_acf-unload.js";
+// @codekit-prepend "_acf-panel.js";
+// @codekit-prepend "_acf-notice.js";
+// @codekit-prepend "_acf-postbox.js";
+// @codekit-prepend "_acf-tooltip.js";
+// @codekit-prepend "_acf-field.js";
+// @codekit-prepend "_acf-fields.js";
+// @codekit-prepend "_acf-field-accordion.js";
+// @codekit-prepend "_acf-field-button-group.js";
+// @codekit-prepend "_acf-field-checkbox.js";
+// @codekit-prepend "_acf-field-color-picker.js";
+// @codekit-prepend "_acf-field-date-picker.js";
+// @codekit-prepend "_acf-field-date-time-picker.js";
+// @codekit-prepend "_acf-field-google-map.js";
+// @codekit-prepend "_acf-field-image.js";
+// @codekit-prepend "_acf-field-file.js";
+// @codekit-prepend "_acf-field-link.js";
+// @codekit-prepend "_acf-field-oembed.js";
+// @codekit-prepend "_acf-field-radio.js";
+// @codekit-prepend "_acf-field-range.js";
+// @codekit-prepend "_acf-field-relationship.js";
+// @codekit-prepend "_acf-field-select.js";
+// @codekit-prepend "_acf-field-tab.js";
+// @codekit-prepend "_acf-field-post-object.js";
+// @codekit-prepend "_acf-field-page-link.js";
+// @codekit-prepend "_acf-field-user.js";
+// @codekit-prepend "_acf-field-taxonomy.js";
+// @codekit-prepend "_acf-field-time-picker.js";
+// @codekit-prepend "_acf-field-true-false.js";
+// @codekit-prepend "_acf-field-url.js";
+// @codekit-prepend "_acf-field-wysiwyg.js";
+// @codekit-prepend "_acf-condition.js";
+// @codekit-prepend "_acf-conditions.js";
+// @codekit-prepend "_acf-condition-types.js";
+// @codekit-prepend "_acf-media.js";
+// @codekit-prepend "_acf-screen.js";
+// @codekit-prepend "_acf-select2.js";
+// @codekit-prepend "_acf-tinymce.js";
+// @codekit-prepend "_acf-validation.js";
+// @codekit-prepend "_acf-helpers.js";
+// @codekit-prepend "_acf-compatibility";

wp-content/plugins/advanced-custom-fields/assets/build/js/acf-input.min.js

@@ -0,0 +1,45 @@
+// @codekit-prepend "_acf.js";
+// @codekit-prepend "_acf-hooks.js";
+// @codekit-prepend "_acf-model.js";
+// @codekit-prepend "_acf-popup.js";
+// @codekit-prepend "_acf-unload.js";
+// @codekit-prepend "_acf-panel.js";
+// @codekit-prepend "_acf-notice.js";
+// @codekit-prepend "_acf-postbox.js";
+// @codekit-prepend "_acf-tooltip.js";
+// @codekit-prepend "_acf-field.js";
+// @codekit-prepend "_acf-fields.js";
+// @codekit-prepend "_acf-field-accordion.js";
+// @codekit-prepend "_acf-field-button-group.js";
+// @codekit-prepend "_acf-field-checkbox.js";
+// @codekit-prepend "_acf-field-color-picker.js";
+// @codekit-prepend "_acf-field-date-picker.js";
+// @codekit-prepend "_acf-field-date-time-picker.js";
+// @codekit-prepend "_acf-field-google-map.js";
+// @codekit-prepend "_acf-field-image.js";
+// @codekit-prepend "_acf-field-file.js";
+// @codekit-prepend "_acf-field-link.js";
+// @codekit-prepend "_acf-field-oembed.js";
+// @codekit-prepend "_acf-field-radio.js";
+// @codekit-prepend "_acf-field-range.js";
+// @codekit-prepend "_acf-field-relationship.js";
+// @codekit-prepend "_acf-field-select.js";
+// @codekit-prepend "_acf-field-tab.js";
+// @codekit-prepend "_acf-field-post-object.js";
+// @codekit-prepend "_acf-field-page-link.js";
+// @codekit-prepend "_acf-field-user.js";
+// @codekit-prepend "_acf-field-taxonomy.js";
+// @codekit-prepend "_acf-field-time-picker.js";
+// @codekit-prepend "_acf-field-true-false.js";
+// @codekit-prepend "_acf-field-url.js";
+// @codekit-prepend "_acf-field-wysiwyg.js";
+// @codekit-prepend "_acf-condition.js";
+// @codekit-prepend "_acf-conditions.js";
+// @codekit-prepend "_acf-condition-types.js";
+// @codekit-prepend "_acf-media.js";
+// @codekit-prepend "_acf-screen.js";
+// @codekit-prepend "_acf-select2.js";
+// @codekit-prepend "_acf-tinymce.js";
+// @codekit-prepend "_acf-validation.js";
+// @codekit-prepend "_acf-helpers.js";
+// @codekit-prepend "_acf-compatibility";

wp-content/plugins/advanced-custom-fields/assets/font/LICENSE.txt

@@ -0,0 +1,48 @@
+Font license info
+
+
+## Entypo
+
+   Copyright (C) 2012 by Daniel Bruce
+
+   Author:    Daniel Bruce
+   License:   SIL (http://scripts.sil.org/OFL)
+   Homepage:  http://www.entypo.com
+
+
+## Typicons
+
+   (c) Stephen Hutchings 2012
+
+   Author:    Stephen Hutchings
+   License:   SIL (http://scripts.sil.org/OFL)
+   Homepage:  http://typicons.com/
+
+
+## Font Awesome
+
+   Copyright (C) 2016 by Dave Gandy
+
+   Author:    Dave Gandy
+   License:   SIL ()
+   Homepage:  http://fortawesome.github.com/Font-Awesome/
+
+
+## Elusive
+
+   Copyright (C) 2013 by Aristeides Stathopoulos
+
+   Author:    Aristeides Stathopoulos
+   License:   SIL (http://scripts.sil.org/OFL)
+   Homepage:  http://aristeides.com/
+
+
+## Modern Pictograms
+
+   Copyright (c) 2012 by John Caserta. All rights reserved.
+
+   Author:    John Caserta
+   License:   SIL (http://scripts.sil.org/OFL)
+   Homepage:  http://thedesignoffice.org/project/modern-pictograms/
+
+

wp-content/plugins/advanced-custom-fields/assets/font/README.txt

@@ -0,0 +1,75 @@
+This webfont is generated by http://fontello.com open source project.
+
+
+================================================================================
+Please, note, that you should obey original font licenses, used to make this
+webfont pack. Details available in LICENSE.txt file.
+
+- Usually, it's enough to publish content of LICENSE.txt file somewhere on your
+  site in "About" section.
+
+- If your project is open-source, usually, it will be ok to make LICENSE.txt
+  file publicly available in your repository.
+
+- Fonts, used in Fontello, don't require a clickable link on your site.
+  But any kind of additional authors crediting is welcome.
+================================================================================
+
+
+Comments on archive content
+---------------------------
+
+- /font/* - fonts in different formats
+
+- /css/*  - different kinds of css, for all situations. Should be ok with 
+  twitter bootstrap. Also, you can skip <i> style and assign icon classes
+  directly to text elements, if you don't mind about IE7.
+
+- demo.html - demo file, to show your webfont content
+
+- LICENSE.txt - license info about source fonts, used to build your one.
+
+- config.json - keeps your settings. You can import it back into fontello
+  anytime, to continue your work
+
+
+Why so many CSS files ?
+-----------------------
+
+Because we like to fit all your needs :)
+
+- basic file, <your_font_name>.css - is usually enough, it contains @font-face
+  and character code definitions
+
+- *-ie7.css - if you need IE7 support, but still don't wish to put char codes
+  directly into html
+
+- *-codes.css and *-ie7-codes.css - if you like to use your own @font-face
+  rules, but still wish to benefit from css generation. That can be very
+  convenient for automated asset build systems. When you need to update font -
+  no need to manually edit files, just override old version with archive
+  content. See fontello source code for examples.
+
+- *-embedded.css - basic css file, but with embedded WOFF font, to avoid
+  CORS issues in Firefox and IE9+, when fonts are hosted on the separate domain.
+  We strongly recommend to resolve this issue by `Access-Control-Allow-Origin`
+  server headers. But if you ok with dirty hack - this file is for you. Note,
+  that data url moved to separate @font-face to avoid problems with <IE9, when
+  string is too long.
+
+- animate.css - use it to get ideas about spinner rotation animation.
+
+
+Attention for server setup
+--------------------------
+
+You MUST setup server to reply with proper `mime-types` for font files -
+otherwise some browsers will fail to show fonts.
+
+Usually, `apache` already has necessary settings, but `nginx` and other
+webservers should be tuned. Here is list of mime types for our file extensions:
+
+- `application/vnd.ms-fontobject` - eot
+- `application/x-font-woff` - woff
+- `application/x-font-ttf` - ttf
+- `image/svg+xml` - svg

wp-content/plugins/advanced-custom-fields/assets/font/acf.svg

@@ -0,0 +1,48 @@
+<?xml version="1.0" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns="http://www.w3.org/2000/svg">
+<metadata>Copyright (C) 2017 by original authors @ fontello.com</metadata>
+<defs>
+<font id="acf" horiz-adv-x="1000" >
+<font-face font-family="acf" font-weight="400" font-stretch="normal" units-per-em="1000" ascent="850" descent="-150" />
+<missing-glyph horiz-adv-x="1000" />
+<glyph glyph-name="plus" unicode="&#xe800;" d="M550 400q30 0 30-50t-30-50l-210 0 0-210q0-30-50-30t-50 30l0 210-210 0q-30 0-30 50t30 50l210 0 0 210q0 30 50 30t50-30l0-210 210 0z" horiz-adv-x="580" />
+
+<glyph glyph-name="minus" unicode="&#xe801;" d="M550 400q30 0 30-50t-30-50l-520 0q-30 0-30 50t30 50l520 0z" horiz-adv-x="580" />
+
+<glyph glyph-name="cancel" unicode="&#xe802;" d="M452 194q18-18 18-43t-18-43q-18-16-43-16t-43 16l-132 152-132-152q-18-16-43-16t-43 16q-16 18-16 43t16 43l138 156-138 158q-16 18-16 43t16 43q18 16 43 16t43-16l132-152 132 152q18 16 43 16t43-16q18-18 18-43t-18-43l-138-158z" horiz-adv-x="470" />
+
+<glyph glyph-name="pencil" unicode="&#xe803;" d="M938 605q22-22 22-55t-22-55l-570-570q-22-21-60-38t-73-17l-235 0 0 234q0 35 17 74t38 60l570 570q23 22 55 22t55-22z m-794-426l65-64 431 433-64 63z m91-205q14 0 33 8-10 10-27 26t-50 50-56 56l-22 22q-9-21-9-32l0-78 52-52 79 0z m74 40l432 432-63 64-433-431z m469 469l67 67-165 165-67-66z" horiz-adv-x="960" />
+
+<glyph glyph-name="location" unicode="&#xe804;" d="M250 750q104 0 177-73t73-177q0-106-62-243t-126-223l-62-84q-10 12-27 35t-60 89-76 130-60 147-27 149q0 104 73 177t177 73z m0-388q56 0 96 40t40 96-40 95-96 39-95-39-39-95 39-96 95-40z" horiz-adv-x="500" />
+
+<glyph glyph-name="down" unicode="&#xe805;" d="M564 422l-234-224q-18-18-40-18t-40 18l-234 224q-16 16-16 41t16 41q38 38 78 0l196-188 196 188q40 38 78 0 16-16 16-41t-16-41z" horiz-adv-x="580" />
+
+<glyph glyph-name="left" unicode="&#xe806;" d="M242 626q14 16 39 16t41-16q38-36 0-80l-186-196 186-194q38-44 0-80-16-16-40-16t-40 16l-226 236q-16 16-16 38 0 24 16 40 206 214 226 236z" horiz-adv-x="341" />
+
+<glyph glyph-name="right" unicode="&#xe807;" d="M98 626l226-236q16-16 16-40 0-22-16-38l-226-236q-16-16-40-16t-40 16q-36 36 0 80l186 194-186 196q-36 44 0 80 16 16 41 16t39-16z" horiz-adv-x="340" />
+
+<glyph glyph-name="up" unicode="&#xe808;" d="M564 280q16-16 16-41t-16-41q-38-38-78 0l-196 188-196-188q-40-38-78 0-16 16-16 41t16 41l234 224q16 16 40 16t40-16z" horiz-adv-x="580" />
+
+<glyph glyph-name="sync" unicode="&#xe809;" d="M843 261q0-3 0-4-36-150-150-243t-267-93q-81 0-157 31t-136 88l-72-72q-11-11-25-11t-25 11-11 25v250q0 14 11 25t25 11h250q14 0 25-11t10-25-10-25l-77-77q40-36 90-57t105-20q74 0 139 37t104 99q6 10 30 66 4 13 16 13h107q8 0 13-6t5-12z m14 446v-250q0-14-10-25t-26-11h-250q-14 0-25 11t-10 25 10 25l77 77q-82 77-194 77-75 0-140-37t-104-99q-6-10-29-66-5-13-17-13h-111q-7 0-13 6t-5 12v4q36 150 151 243t268 93q81 0 158-31t137-88l72 72q11 11 25 11t26-11 10-25z" horiz-adv-x="857.1" />
+
+<glyph glyph-name="globe" unicode="&#xe80a;" d="M480 830q200 0 340-141t140-339q0-200-140-340t-340-140q-198 0-339 140t-141 340q0 198 141 339t339 141z m410-480q0 132-78 239t-202 149q-18-24-16-32 4-38 18-51t30-7l32 12t20 2q22-24 0-47t-45-56-1-77q34-64 96-64 28-2 43-36t17-66q10-80-14-140-22-44 14-76 86 112 86 250z m-466 404q-112-14-199-84t-127-174q6 0 22-2t28-3 26-4 24-8 12-13q4-12-14-45t-18-61q0-30 38-56t38-46q0-28 8-68t8-44q0-12 36-54t52-42q10 0 11 22t-2 54-3 40q0 32 14 74 12 42 59 70t55 46q16 34 9 61t-17 43-34 28-41 17-37 9-22 4q-16 6-42 7t-36-3-27 11-17 29q0 10 15 27t35 37 28 30q8 14 17 21t22 16 27 21q4 4 25 17t27 23z m-72-794q66-20 128-20 128 0 226 68-26 44-118 34-24-2-65-17t-47-17q-74-16-76-16-12-2-26-14t-22-18z" horiz-adv-x="960" />
+
+<glyph glyph-name="picture" unicode="&#xe80b;" d="M0-68l0 836 1000 0 0-836-1000 0z m76 78l848 0 0 680-848 0 0-680z m90 80l0 59 150 195 102-86 193 291 223-228 0-231-668 0z m0 416q0 37 24 62t62 24q33 0 58-24t24-62q0-33-24-57t-58-25q-37 0-62 25t-24 57z" horiz-adv-x="1000" />
+
+<glyph glyph-name="check" unicode="&#xe80c;" d="M249 0q-34 0-56 28l-180 236q-16 24-12 52t26 46 51 14 47-28l118-154 296 474q16 24 43 30t53-8q24-16 30-43t-8-53l-350-560q-20-32-56-32z" horiz-adv-x="667" />
+
+<glyph glyph-name="dot-3" unicode="&#xe80d;" d="M110 460q46 0 78-32t32-78q0-44-32-77t-78-33-78 33-32 77q0 46 32 78t78 32z m350 0q46 0 78-32t32-78q0-44-33-77t-77-33-77 33-33 77q0 46 32 78t78 32z m350 0q46 0 78-32t32-78q0-44-32-77t-78-33-78 33-32 77q0 46 32 78t78 32z" horiz-adv-x="920" />
+
+<glyph glyph-name="arrow-combo" unicode="&#xe80e;" d="M230 850l230-364-460 0z m0-1000l-230 366 460 0z" horiz-adv-x="460" />
+
+<glyph glyph-name="arrow-down" unicode="&#xe80f;" d="M540 587l-269-473-271 473 540 0z" horiz-adv-x="540" />
+
+<glyph glyph-name="arrow-up" unicode="&#xe810;" d="M0 114l269 473 271-473-540 0z" horiz-adv-x="540" />
+
+<glyph glyph-name="search" unicode="&#xe811;" d="M772 78q30-34 6-62l-46-46q-36-32-68 0l-190 190q-74-42-156-42-128 0-223 95t-95 223 90 219 218 91 224-95 96-223q0-88-46-162z m-678 358q0-88 68-156t156-68 151 63 63 153q0 88-68 155t-156 67-151-63-63-151z" horiz-adv-x="789" />
+
+<glyph glyph-name="link-ext" unicode="&#xf08e;" d="M786 332v-178q0-67-47-114t-114-47h-464q-67 0-114 47t-47 114v464q0 66 47 113t114 48h393q7 0 12-5t5-13v-36q0-8-5-13t-12-5h-393q-37 0-63-26t-27-63v-464q0-37 27-63t63-27h464q37 0 63 27t26 63v178q0 8 5 13t13 5h36q8 0 13-5t5-13z m214 482v-285q0-15-11-25t-25-11-25 11l-98 98-364-364q-5-6-13-6t-12 6l-64 64q-6 5-6 12t6 13l364 364-98 98q-11 11-11 25t11 25 25 11h285q15 0 25-11t11-25z" horiz-adv-x="1000" />
+</font>
+</defs>
+</svg>

wp-content/plugins/advanced-custom-fields/assets/font/config.json

@@ -0,0 +1,124 @@
+{
+  "name": "acf",
+  "css_prefix_text": "acf-icon-",
+  "css_use_suffix": false,
+  "hinting": true,
+  "units_per_em": 1000,
+  "ascent": 850,
+  "glyphs": [
+    {
+      "uid": "a73c5deb486c8d66249811642e5d719a",
+      "css": "sync",
+      "code": 59401,
+      "src": "fontawesome"
+    },
+    {
+      "uid": "7222571caa5c15f83dcfd447c58d68d9",
+      "css": "search",
+      "code": 59409,
+      "src": "entypo"
+    },
+    {
+      "uid": "14017aae737730faeda4a6fd8fb3a5f0",
+      "css": "check",
+      "code": 59404,
+      "src": "entypo"
+    },
+    {
+      "uid": "c709da589c923ba3c2ad48d9fc563e93",
+      "css": "cancel",
+      "code": 59394,
+      "src": "entypo"
+    },
+    {
+      "uid": "70370693ada58ef0a60fa0984fe8d52a",
+      "css": "plus",
+      "code": 59392,
+      "src": "entypo"
+    },
+    {
+      "uid": "1256e3054823e304d7e452a589cf8bb8",
+      "css": "minus",
+      "code": 59393,
+      "src": "entypo"
+    },
+    {
+      "uid": "a42b598e4298f3319b25a2702a02e7ff",
+      "css": "location",
+      "code": 59396,
+      "src": "entypo"
+    },
+    {
+      "uid": "0a3192de65a73ca1501b073ad601f87d",
+      "css": "arrow-combo",
+      "code": 59406,
+      "src": "entypo"
+    },
+    {
+      "uid": "8704cd847a47b64265b8bb110c8b4d62",
+      "css": "down",
+      "code": 59397,
+      "src": "entypo"
+    },
+    {
+      "uid": "c311c48d79488965b0fab7f9cd12b6b5",
+      "css": "left",
+      "code": 59398,
+      "src": "entypo"
+    },
+    {
+      "uid": "749e7d90a9182938180f1d2d8c33584e",
+      "css": "right",
+      "code": 59399,
+      "src": "entypo"
+    },
+    {
+      "uid": "9c7ff134960bb5a82404e4aeaab366d9",
+      "css": "up",
+      "code": 59400,
+      "src": "entypo"
+    },
+    {
+      "uid": "6a12c2b74456ea21cc984e11dec227a1",
+      "css": "globe",
+      "code": 59402,
+      "src": "entypo"
+    },
+    {
+      "uid": "d10920db2e79c997c5e783279291970c",
+      "css": "dot-3",
+      "code": 59405,
+      "src": "entypo"
+    },
+    {
+      "uid": "1e77a2yvsq3owssduo2lcgsiven57iv5",
+      "css": "pencil",
+      "code": 59395,
+      "src": "typicons"
+    },
+    {
+      "uid": "8ax1xqcbzz1hobyd4i7f0unwib1bztip",
+      "css": "arrow-down",
+      "code": 59407,
+      "src": "modernpics"
+    },
+    {
+      "uid": "6ipws8y9gej6vbloufvhi5qux7rluf64",
+      "css": "arrow-up",
+      "code": 59408,
+      "src": "modernpics"
+    },
+    {
+      "uid": "a1be363d4de9be39857893d4134f6215",
+      "css": "picture",
+      "code": 59403,
+      "src": "elusive"
+    },
+    {
+      "uid": "e15f0d620a7897e2035c18c80142f6d9",
+      "css": "link-ext",
+      "code": 61582,
+      "src": "fontawesome"
+    }
+  ]
+}

wp-content/plugins/advanced-custom-fields/assets/inc/datepicker/jquery-ui.css

@@ -0,0 +1,650 @@
+/*! jQuery UI - v1.11.4 - 2016-05-31
+* http://jqueryui.com
+* Includes: core.css, datepicker.css, theme.css
+* To view and modify this theme, visit http://jqueryui.com/themeroller/?ffDefault=%22Open%20Sans%22%2C%E2%80%8B%20sans-serif&fsDefault=14px&fwDefault=normal&cornerRadius=3&bgColorHeader=%23ffffff&bgTextureHeader=highlight_soft&borderColorHeader=%23ffffff&fcHeader=%23222222&iconColorHeader=%23DDDDDD&bgColorContent=%23ffffff&bgTextureContent=flat&borderColorContent=%23E1E1E1&fcContent=%23444444&iconColorContent=%23444444&bgColorDefault=%23F9F9F9&bgTextureDefault=flat&borderColorDefault=%23F0F0F0&fcDefault=%23444444&iconColorDefault=%23444444&bgColorHover=%2398b7e8&bgTextureHover=flat&borderColorHover=%2398b7e8&fcHover=%23ffffff&iconColorHover=%23ffffff&bgColorActive=%233875d7&bgTextureActive=flat&borderColorActive=%233875d7&fcActive=%23ffffff&iconColorActive=%23ffffff&bgColorHighlight=%23ffffff&bgTextureHighlight=flat&borderColorHighlight=%23aaaaaa&fcHighlight=%23444444&iconColorHighlight=%23444444&bgColorError=%23E14D43&bgTextureError=flat&borderColorError=%23E14D43&fcError=%23ffffff&iconColorError=%23ffffff&bgColorOverlay=%23ffffff&bgTextureOverlay=flat&bgImgOpacityOverlay=0&opacityOverlay=30&bgColorShadow=%23aaaaaa&bgTextureShadow=flat&bgImgOpacityShadow=0&opacityShadow=30&thicknessShadow=8px&offsetTopShadow=-8px&offsetLeftShadow=-8px&cornerRadiusShadow=8px&bgImgOpacityHeader=0&bgImgOpacityContent=&bgImgOpacityDefault=0&bgImgOpacityHover=0&bgImgOpacityActive=0&bgImgOpacityHighlight=0&bgImgOpacityError=0
+* Copyright jQuery Foundation and other contributors; Licensed MIT */
+
+/* Layout helpers
+----------------------------------*/
+.ui-helper-hidden {
+	display: none;
+}
+.ui-helper-hidden-accessible {
+	border: 0;
+	clip: rect(0 0 0 0);
+	height: 1px;
+	margin: -1px;
+	overflow: hidden;
+	padding: 0;
+	position: absolute;
+	width: 1px;
+}
+.ui-helper-reset {
+	margin: 0;
+	padding: 0;
+	border: 0;
+	outline: 0;
+	line-height: 1.3;
+	text-decoration: none;
+	font-size: 100%;
+	list-style: none;
+}
+.ui-helper-clearfix:before,
+.ui-helper-clearfix:after {
+	content: "";
+	display: table;
+	border-collapse: collapse;
+}
+.ui-helper-clearfix:after {
+	clear: both;
+}
+.ui-helper-clearfix {
+	min-height: 0; /* support: IE7 */
+}
+.ui-helper-zfix {
+	width: 100%;
+	height: 100%;
+	top: 0;
+	left: 0;
+	position: absolute;
+	opacity: 0;
+	filter:Alpha(Opacity=0); /* support: IE8 */
+}
+
+.ui-front {
+	z-index: 100;
+}
+
+
+/* Interaction Cues
+----------------------------------*/
+.ui-state-disabled {
+	cursor: default !important;
+}
+
+
+/* Icons
+----------------------------------*/
+
+/* states and images */
+.ui-icon {
+	display: block;
+	text-indent: -99999px;
+	overflow: hidden;
+	background-repeat: no-repeat;
+}
+
+
+/* Misc visuals
+----------------------------------*/
+
+/* Overlays */
+.ui-widget-overlay {
+	position: fixed;
+	top: 0;
+	left: 0;
+	width: 100%;
+	height: 100%;
+}
+.ui-datepicker {
+	width: 17em;
+	padding: .2em .2em 0;
+	display: none;
+}
+.ui-datepicker .ui-datepicker-header {
+	position: relative;
+	padding: .2em 0;
+}
+.ui-datepicker .ui-datepicker-prev,
+.ui-datepicker .ui-datepicker-next {
+	position: absolute;
+	top: 2px;
+	width: 1.8em;
+	height: 1.8em;
+}
+.ui-datepicker .ui-datepicker-prev-hover,
+.ui-datepicker .ui-datepicker-next-hover {
+	top: 1px;
+}
+.ui-datepicker .ui-datepicker-prev {
+	left: 2px;
+}
+.ui-datepicker .ui-datepicker-next {
+	right: 2px;
+}
+.ui-datepicker .ui-datepicker-prev-hover {
+	left: 1px;
+}
+.ui-datepicker .ui-datepicker-next-hover {
+	right: 1px;
+}
+.ui-datepicker .ui-datepicker-prev span,
+.ui-datepicker .ui-datepicker-next span {
+	display: block;
+	position: absolute;
+	left: 50%;
+	margin-left: -8px;
+	top: 50%;
+	margin-top: -8px;
+}
+.ui-datepicker .ui-datepicker-title {
+	margin: 0 2.3em;
+	line-height: 1.8em;
+	text-align: center;
+}
+.ui-datepicker .ui-datepicker-title select {
+	font-size: 1em;
+	margin: 1px 0;
+}
+.ui-datepicker select.ui-datepicker-month,
+.ui-datepicker select.ui-datepicker-year {
+	width: 45%;
+}
+.ui-datepicker table {
+	width: 100%;
+	font-size: .9em;
+	border-collapse: collapse;
+	margin: 0 0 .4em;
+}
+.ui-datepicker th {
+	padding: .7em .3em;
+	text-align: center;
+	font-weight: bold;
+	border: 0;
+}
+.ui-datepicker td {
+	border: 0;
+	padding: 1px;
+}
+.ui-datepicker td span,
+.ui-datepicker td a {
+	display: block;
+	padding: .2em;
+	text-align: right;
+	text-decoration: none;
+}
+.ui-datepicker .ui-datepicker-buttonpane {
+	background-image: none;
+	margin: .7em 0 0 0;
+	padding: 0 .2em;
+	border-left: 0;
+	border-right: 0;
+	border-bottom: 0;
+}
+.ui-datepicker .ui-datepicker-buttonpane button {
+	float: right;
+	margin: .5em .2em .4em;
+	cursor: pointer;
+	padding: .2em .6em .3em .6em;
+	width: auto;
+	overflow: visible;
+}
+.ui-datepicker .ui-datepicker-buttonpane button.ui-datepicker-current {
+	float: left;
+}
+
+/* with multiple calendars */
+.ui-datepicker.ui-datepicker-multi {
+	width: auto;
+}
+.ui-datepicker-multi .ui-datepicker-group {
+	float: left;
+}
+.ui-datepicker-multi .ui-datepicker-group table {
+	width: 95%;
+	margin: 0 auto .4em;
+}
+.ui-datepicker-multi-2 .ui-datepicker-group {
+	width: 50%;
+}
+.ui-datepicker-multi-3 .ui-datepicker-group {
+	width: 33.3%;
+}
+.ui-datepicker-multi-4 .ui-datepicker-group {
+	width: 25%;
+}
+.ui-datepicker-multi .ui-datepicker-group-last .ui-datepicker-header,
+.ui-datepicker-multi .ui-datepicker-group-middle .ui-datepicker-header {
+	border-left-width: 0;
+}
+.ui-datepicker-multi .ui-datepicker-buttonpane {
+	clear: left;
+}
+.ui-datepicker-row-break {
+	clear: both;
+	width: 100%;
+	font-size: 0;
+}
+
+/* RTL support */
+.ui-datepicker-rtl {
+	direction: rtl;
+}
+.ui-datepicker-rtl .ui-datepicker-prev {
+	right: 2px;
+	left: auto;
+}
+.ui-datepicker-rtl .ui-datepicker-next {
+	left: 2px;
+	right: auto;
+}
+.ui-datepicker-rtl .ui-datepicker-prev:hover {
+	right: 1px;
+	left: auto;
+}
+.ui-datepicker-rtl .ui-datepicker-next:hover {
+	left: 1px;
+	right: auto;
+}
+.ui-datepicker-rtl .ui-datepicker-buttonpane {
+	clear: right;
+}
+.ui-datepicker-rtl .ui-datepicker-buttonpane button {
+	float: left;
+}
+.ui-datepicker-rtl .ui-datepicker-buttonpane button.ui-datepicker-current,
+.ui-datepicker-rtl .ui-datepicker-group {
+	float: right;
+}
+.ui-datepicker-rtl .ui-datepicker-group-last .ui-datepicker-header,
+.ui-datepicker-rtl .ui-datepicker-group-middle .ui-datepicker-header {
+	border-right-width: 0;
+	border-left-width: 1px;
+}
+
+/* Component containers
+----------------------------------*/
+.acf-ui-datepicker .ui-widget {
+	font-family: inherit;
+	font-size: 14px;
+}
+.acf-ui-datepicker .ui-widget .ui-widget {
+	font-size: 1em;
+}
+.acf-ui-datepicker .ui-widget input,
+.acf-ui-datepicker .ui-widget select,
+.acf-ui-datepicker .ui-widget textarea,
+.acf-ui-datepicker .ui-widget button {
+	font-family: inherit;
+	font-size: 1em;
+}
+.acf-ui-datepicker .ui-widget-content {
+	border: 1px solid #E1E1E1;
+	background: #ffffff;
+	color: #444444;
+}
+.acf-ui-datepicker .ui-widget-content a {
+	color: #444444;
+}
+.acf-ui-datepicker .ui-widget-header {
+	border: 1px solid #ffffff;
+	background: #ffffff url("images/ui-bg_highlight-soft_0_ffffff_1x100.png") 50% 50% repeat-x;
+	color: #222222;
+	font-weight: bold;
+}
+.acf-ui-datepicker .ui-widget-header a {
+	color: #222222;
+}
+
+/* Interaction states
+----------------------------------*/
+.acf-ui-datepicker .ui-state-default,
+.acf-ui-datepicker .ui-widget-content .ui-state-default,
+.acf-ui-datepicker .ui-widget-header .ui-state-default {
+	border: 1px solid #F0F0F0;
+	background: #F9F9F9;
+	font-weight: normal;
+	color: #444444;
+}
+.acf-ui-datepicker .ui-state-default a,
+.acf-ui-datepicker .ui-state-default a:link,
+.acf-ui-datepicker .ui-state-default a:visited {
+	color: #444444;
+	text-decoration: none;
+}
+.acf-ui-datepicker .ui-state-hover,
+.acf-ui-datepicker .ui-widget-content .ui-state-hover,
+.acf-ui-datepicker .ui-widget-header .ui-state-hover,
+.acf-ui-datepicker .ui-state-focus,
+.acf-ui-datepicker .ui-widget-content .ui-state-focus,
+.acf-ui-datepicker .ui-widget-header .ui-state-focus {
+	border: 1px solid #98b7e8;
+	background: #98b7e8;
+	font-weight: normal;
+	color: #ffffff;
+}
+.acf-ui-datepicker .ui-state-hover a,
+.acf-ui-datepicker .ui-state-hover a:hover,
+.acf-ui-datepicker .ui-state-hover a:link,
+.acf-ui-datepicker .ui-state-hover a:visited,
+.acf-ui-datepicker .ui-state-focus a,
+.acf-ui-datepicker .ui-state-focus a:hover,
+.acf-ui-datepicker .ui-state-focus a:link,
+.acf-ui-datepicker .ui-state-focus a:visited {
+	color: #ffffff;
+	text-decoration: none;
+}
+.acf-ui-datepicker .ui-state-active,
+.acf-ui-datepicker .ui-widget-content .ui-state-active,
+.acf-ui-datepicker .ui-widget-header .ui-state-active {
+	border: 1px solid #3875d7;
+	background: #3875d7;
+	font-weight: normal;
+	color: #ffffff;
+}
+.acf-ui-datepicker .ui-state-active a,
+.acf-ui-datepicker .ui-state-active a:link,
+.acf-ui-datepicker .ui-state-active a:visited {
+	color: #ffffff;
+	text-decoration: none;
+}
+
+/* Interaction Cues
+----------------------------------*/
+.acf-ui-datepicker .ui-state-highlight,
+.acf-ui-datepicker .ui-widget-content .ui-state-highlight,
+.acf-ui-datepicker .ui-widget-header .ui-state-highlight {
+	border: 1px solid #aaaaaa;
+	background: #ffffff;
+	color: #444444;
+}
+.acf-ui-datepicker .ui-state-highlight a,
+.acf-ui-datepicker .ui-widget-content .ui-state-highlight a,
+.acf-ui-datepicker .ui-widget-header .ui-state-highlight a {
+	color: #444444;
+}
+.acf-ui-datepicker .ui-state-error,
+.acf-ui-datepicker .ui-widget-content .ui-state-error,
+.acf-ui-datepicker .ui-widget-header .ui-state-error {
+	border: 1px solid #E14D43;
+	background: #E14D43;
+	color: #ffffff;
+}
+.acf-ui-datepicker .ui-state-error a,
+.acf-ui-datepicker .ui-widget-content .ui-state-error a,
+.acf-ui-datepicker .ui-widget-header .ui-state-error a {
+	color: #ffffff;
+}
+.acf-ui-datepicker .ui-state-error-text,
+.acf-ui-datepicker .ui-widget-content .ui-state-error-text,
+.acf-ui-datepicker .ui-widget-header .ui-state-error-text {
+	color: #ffffff;
+}
+.acf-ui-datepicker .ui-priority-primary,
+.acf-ui-datepicker .ui-widget-content .ui-priority-primary,
+.acf-ui-datepicker .ui-widget-header .ui-priority-primary {
+	font-weight: bold;
+}
+.acf-ui-datepicker .ui-priority-secondary,
+.acf-ui-datepicker .ui-widget-content .ui-priority-secondary,
+.acf-ui-datepicker .ui-widget-header .ui-priority-secondary {
+	opacity: .7;
+	filter:Alpha(Opacity=70); /* support: IE8 */
+	font-weight: normal;
+}
+.acf-ui-datepicker .ui-state-disabled,
+.acf-ui-datepicker .ui-widget-content .ui-state-disabled,
+.acf-ui-datepicker .ui-widget-header .ui-state-disabled {
+	opacity: .35;
+	filter:Alpha(Opacity=35); /* support: IE8 */
+	background-image: none;
+}
+.acf-ui-datepicker .ui-state-disabled .ui-icon {
+	filter:Alpha(Opacity=35); /* support: IE8 - See #6059 */
+}
+
+/* Icons
+----------------------------------*/
+
+/* states and images */
+.acf-ui-datepicker .ui-icon {
+	width: 16px;
+	height: 16px;
+}
+.acf-ui-datepicker .ui-icon,
+.acf-ui-datepicker .ui-widget-content .ui-icon {
+	background-image: url("images/ui-icons_444444_256x240.png");
+}
+.acf-ui-datepicker .ui-widget-header .ui-icon {
+	background-image: url("images/ui-icons_DDDDDD_256x240.png");
+}
+.acf-ui-datepicker .ui-state-default .ui-icon {
+	background-image: url("images/ui-icons_444444_256x240.png");
+}
+.acf-ui-datepicker .ui-state-hover .ui-icon,
+.acf-ui-datepicker .ui-state-focus .ui-icon {
+	background-image: url("images/ui-icons_ffffff_256x240.png");
+}
+.acf-ui-datepicker .ui-state-active .ui-icon {
+	background-image: url("images/ui-icons_ffffff_256x240.png");
+}
+.acf-ui-datepicker .ui-state-highlight .ui-icon {
+	background-image: url("images/ui-icons_444444_256x240.png");
+}
+.acf-ui-datepicker .ui-state-error .ui-icon,
+.acf-ui-datepicker .ui-state-error-text .ui-icon {
+	background-image: url("images/ui-icons_ffffff_256x240.png");
+}
+
+/* positioning */
+.acf-ui-datepicker .ui-icon-blank { background-position: 16px 16px; }
+.acf-ui-datepicker .ui-icon-carat-1-n { background-position: 0 0; }
+.acf-ui-datepicker .ui-icon-carat-1-ne { background-position: -16px 0; }
+.acf-ui-datepicker .ui-icon-carat-1-e { background-position: -32px 0; }
+.acf-ui-datepicker .ui-icon-carat-1-se { background-position: -48px 0; }
+.acf-ui-datepicker .ui-icon-carat-1-s { background-position: -64px 0; }
+.acf-ui-datepicker .ui-icon-carat-1-sw { background-position: -80px 0; }
+.acf-ui-datepicker .ui-icon-carat-1-w { background-position: -96px 0; }
+.acf-ui-datepicker .ui-icon-carat-1-nw { background-position: -112px 0; }
+.acf-ui-datepicker .ui-icon-carat-2-n-s { background-position: -128px 0; }
+.acf-ui-datepicker .ui-icon-carat-2-e-w { background-position: -144px 0; }
+.acf-ui-datepicker .ui-icon-triangle-1-n { background-position: 0 -16px; }
+.acf-ui-datepicker .ui-icon-triangle-1-ne { background-position: -16px -16px; }
+.acf-ui-datepicker .ui-icon-triangle-1-e { background-position: -32px -16px; }
+.acf-ui-datepicker .ui-icon-triangle-1-se { background-position: -48px -16px; }
+.acf-ui-datepicker .ui-icon-triangle-1-s { background-position: -64px -16px; }
+.acf-ui-datepicker .ui-icon-triangle-1-sw { background-position: -80px -16px; }
+.acf-ui-datepicker .ui-icon-triangle-1-w { background-position: -96px -16px; }
+.acf-ui-datepicker .ui-icon-triangle-1-nw { background-position: -112px -16px; }
+.acf-ui-datepicker .ui-icon-triangle-2-n-s { background-position: -128px -16px; }
+.acf-ui-datepicker .ui-icon-triangle-2-e-w { background-position: -144px -16px; }
+.acf-ui-datepicker .ui-icon-arrow-1-n { background-position: 0 -32px; }
+.acf-ui-datepicker .ui-icon-arrow-1-ne { background-position: -16px -32px; }
+.acf-ui-datepicker .ui-icon-arrow-1-e { background-position: -32px -32px; }
+.acf-ui-datepicker .ui-icon-arrow-1-se { background-position: -48px -32px; }
+.acf-ui-datepicker .ui-icon-arrow-1-s { background-position: -64px -32px; }
+.acf-ui-datepicker .ui-icon-arrow-1-sw { background-position: -80px -32px; }
+.acf-ui-datepicker .ui-icon-arrow-1-w { background-position: -96px -32px; }
+.acf-ui-datepicker .ui-icon-arrow-1-nw { background-position: -112px -32px; }
+.acf-ui-datepicker .ui-icon-arrow-2-n-s { background-position: -128px -32px; }
+.acf-ui-datepicker .ui-icon-arrow-2-ne-sw { background-position: -144px -32px; }
+.acf-ui-datepicker .ui-icon-arrow-2-e-w { background-position: -160px -32px; }
+.acf-ui-datepicker .ui-icon-arrow-2-se-nw { background-position: -176px -32px; }
+.acf-ui-datepicker .ui-icon-arrowstop-1-n { background-position: -192px -32px; }
+.acf-ui-datepicker .ui-icon-arrowstop-1-e { background-position: -208px -32px; }
+.acf-ui-datepicker .ui-icon-arrowstop-1-s { background-position: -224px -32px; }
+.acf-ui-datepicker .ui-icon-arrowstop-1-w { background-position: -240px -32px; }
+.acf-ui-datepicker .ui-icon-arrowthick-1-n { background-position: 0 -48px; }
+.acf-ui-datepicker .ui-icon-arrowthick-1-ne { background-position: -16px -48px; }
+.acf-ui-datepicker .ui-icon-arrowthick-1-e { background-position: -32px -48px; }
+.acf-ui-datepicker .ui-icon-arrowthick-1-se { background-position: -48px -48px; }
+.acf-ui-datepicker .ui-icon-arrowthick-1-s { background-position: -64px -48px; }
+.acf-ui-datepicker .ui-icon-arrowthick-1-sw { background-position: -80px -48px; }
+.acf-ui-datepicker .ui-icon-arrowthick-1-w { background-position: -96px -48px; }
+.acf-ui-datepicker .ui-icon-arrowthick-1-nw { background-position: -112px -48px; }
+.acf-ui-datepicker .ui-icon-arrowthick-2-n-s { background-position: -128px -48px; }
+.acf-ui-datepicker .ui-icon-arrowthick-2-ne-sw { background-position: -144px -48px; }
+.acf-ui-datepicker .ui-icon-arrowthick-2-e-w { background-position: -160px -48px; }
+.acf-ui-datepicker .ui-icon-arrowthick-2-se-nw { background-position: -176px -48px; }
+.acf-ui-datepicker .ui-icon-arrowthickstop-1-n { background-position: -192px -48px; }
+.acf-ui-datepicker .ui-icon-arrowthickstop-1-e { background-position: -208px -48px; }
+.acf-ui-datepicker .ui-icon-arrowthickstop-1-s { background-position: -224px -48px; }
+.acf-ui-datepicker .ui-icon-arrowthickstop-1-w { background-position: -240px -48px; }
+.acf-ui-datepicker .ui-icon-arrowreturnthick-1-w { background-position: 0 -64px; }
+.acf-ui-datepicker .ui-icon-arrowreturnthick-1-n { background-position: -16px -64px; }
+.acf-ui-datepicker .ui-icon-arrowreturnthick-1-e { background-position: -32px -64px; }
+.acf-ui-datepicker .ui-icon-arrowreturnthick-1-s { background-position: -48px -64px; }
+.acf-ui-datepicker .ui-icon-arrowreturn-1-w { background-position: -64px -64px; }
+.acf-ui-datepicker .ui-icon-arrowreturn-1-n { background-position: -80px -64px; }
+.acf-ui-datepicker .ui-icon-arrowreturn-1-e { background-position: -96px -64px; }
+.acf-ui-datepicker .ui-icon-arrowreturn-1-s { background-position: -112px -64px; }
+.acf-ui-datepicker .ui-icon-arrowrefresh-1-w { background-position: -128px -64px; }
+.acf-ui-datepicker .ui-icon-arrowrefresh-1-n { background-position: -144px -64px; }
+.acf-ui-datepicker .ui-icon-arrowrefresh-1-e { background-position: -160px -64px; }
+.acf-ui-datepicker .ui-icon-arrowrefresh-1-s { background-position: -176px -64px; }
+.acf-ui-datepicker .ui-icon-arrow-4 { background-position: 0 -80px; }
+.acf-ui-datepicker .ui-icon-arrow-4-diag { background-position: -16px -80px; }
+.acf-ui-datepicker .ui-icon-extlink { background-position: -32px -80px; }
+.acf-ui-datepicker .ui-icon-newwin { background-position: -48px -80px; }
+.acf-ui-datepicker .ui-icon-refresh { background-position: -64px -80px; }
+.acf-ui-datepicker .ui-icon-shuffle { background-position: -80px -80px; }
+.acf-ui-datepicker .ui-icon-transfer-e-w { background-position: -96px -80px; }
+.acf-ui-datepicker .ui-icon-transferthick-e-w { background-position: -112px -80px; }
+.acf-ui-datepicker .ui-icon-folder-collapsed { background-position: 0 -96px; }
+.acf-ui-datepicker .ui-icon-folder-open { background-position: -16px -96px; }
+.acf-ui-datepicker .ui-icon-document { background-position: -32px -96px; }
+.acf-ui-datepicker .ui-icon-document-b { background-position: -48px -96px; }
+.acf-ui-datepicker .ui-icon-note { background-position: -64px -96px; }
+.acf-ui-datepicker .ui-icon-mail-closed { background-position: -80px -96px; }
+.acf-ui-datepicker .ui-icon-mail-open { background-position: -96px -96px; }
+.acf-ui-datepicker .ui-icon-suitcase { background-position: -112px -96px; }
+.acf-ui-datepicker .ui-icon-comment { background-position: -128px -96px; }
+.acf-ui-datepicker .ui-icon-person { background-position: -144px -96px; }
+.acf-ui-datepicker .ui-icon-print { background-position: -160px -96px; }
+.acf-ui-datepicker .ui-icon-trash { background-position: -176px -96px; }
+.acf-ui-datepicker .ui-icon-locked { background-position: -192px -96px; }
+.acf-ui-datepicker .ui-icon-unlocked { background-position: -208px -96px; }
+.acf-ui-datepicker .ui-icon-bookmark { background-position: -224px -96px; }
+.acf-ui-datepicker .ui-icon-tag { background-position: -240px -96px; }
+.acf-ui-datepicker .ui-icon-home { background-position: 0 -112px; }
+.acf-ui-datepicker .ui-icon-flag { background-position: -16px -112px; }
+.acf-ui-datepicker .ui-icon-calendar { background-position: -32px -112px; }
+.acf-ui-datepicker .ui-icon-cart { background-position: -48px -112px; }
+.acf-ui-datepicker .ui-icon-pencil { background-position: -64px -112px; }
+.acf-ui-datepicker .ui-icon-clock { background-position: -80px -112px; }
+.acf-ui-datepicker .ui-icon-disk { background-position: -96px -112px; }
+.acf-ui-datepicker .ui-icon-calculator { background-position: -112px -112px; }
+.acf-ui-datepicker .ui-icon-zoomin { background-position: -128px -112px; }
+.acf-ui-datepicker .ui-icon-zoomout { background-position: -144px -112px; }
+.acf-ui-datepicker .ui-icon-search { background-position: -160px -112px; }
+.acf-ui-datepicker .ui-icon-wrench { background-position: -176px -112px; }
+.acf-ui-datepicker .ui-icon-gear { background-position: -192px -112px; }
+.acf-ui-datepicker .ui-icon-heart { background-position: -208px -112px; }
+.acf-ui-datepicker .ui-icon-star { background-position: -224px -112px; }
+.acf-ui-datepicker .ui-icon-link { background-position: -240px -112px; }
+.acf-ui-datepicker .ui-icon-cancel { background-position: 0 -128px; }
+.acf-ui-datepicker .ui-icon-plus { background-position: -16px -128px; }
+.acf-ui-datepicker .ui-icon-plusthick { background-position: -32px -128px; }
+.acf-ui-datepicker .ui-icon-minus { background-position: -48px -128px; }
+.acf-ui-datepicker .ui-icon-minusthick { background-position: -64px -128px; }
+.acf-ui-datepicker .ui-icon-close { background-position: -80px -128px; }
+.acf-ui-datepicker .ui-icon-closethick { background-position: -96px -128px; }
+.acf-ui-datepicker .ui-icon-key { background-position: -112px -128px; }
+.acf-ui-datepicker .ui-icon-lightbulb { background-position: -128px -128px; }
+.acf-ui-datepicker .ui-icon-scissors { background-position: -144px -128px; }
+.acf-ui-datepicker .ui-icon-clipboard { background-position: -160px -128px; }
+.acf-ui-datepicker .ui-icon-copy { background-position: -176px -128px; }
+.acf-ui-datepicker .ui-icon-contact { background-position: -192px -128px; }
+.acf-ui-datepicker .ui-icon-image { background-position: -208px -128px; }
+.acf-ui-datepicker .ui-icon-video { background-position: -224px -128px; }
+.acf-ui-datepicker .ui-icon-script { background-position: -240px -128px; }
+.acf-ui-datepicker .ui-icon-alert { background-position: 0 -144px; }
+.acf-ui-datepicker .ui-icon-info { background-position: -16px -144px; }
+.acf-ui-datepicker .ui-icon-notice { background-position: -32px -144px; }
+.acf-ui-datepicker .ui-icon-help { background-position: -48px -144px; }
+.acf-ui-datepicker .ui-icon-check { background-position: -64px -144px; }
+.acf-ui-datepicker .ui-icon-bullet { background-position: -80px -144px; }
+.acf-ui-datepicker .ui-icon-radio-on { background-position: -96px -144px; }
+.acf-ui-datepicker .ui-icon-radio-off { background-position: -112px -144px; }
+.acf-ui-datepicker .ui-icon-pin-w { background-position: -128px -144px; }
+.acf-ui-datepicker .ui-icon-pin-s { background-position: -144px -144px; }
+.acf-ui-datepicker .ui-icon-play { background-position: 0 -160px; }
+.acf-ui-datepicker .ui-icon-pause { background-position: -16px -160px; }
+.acf-ui-datepicker .ui-icon-seek-next { background-position: -32px -160px; }
+.acf-ui-datepicker .ui-icon-seek-prev { background-position: -48px -160px; }
+.acf-ui-datepicker .ui-icon-seek-end { background-position: -64px -160px; }
+.acf-ui-datepicker .ui-icon-seek-start { background-position: -80px -160px; }
+/* ui-icon-seek-first is deprecated, use ui-icon-seek-start instead */
+.acf-ui-datepicker .ui-icon-seek-first { background-position: -80px -160px; }
+.acf-ui-datepicker .ui-icon-stop { background-position: -96px -160px; }
+.acf-ui-datepicker .ui-icon-eject { background-position: -112px -160px; }
+.acf-ui-datepicker .ui-icon-volume-off { background-position: -128px -160px; }
+.acf-ui-datepicker .ui-icon-volume-on { background-position: -144px -160px; }
+.acf-ui-datepicker .ui-icon-power { background-position: 0 -176px; }
+.acf-ui-datepicker .ui-icon-signal-diag { background-position: -16px -176px; }
+.acf-ui-datepicker .ui-icon-signal { background-position: -32px -176px; }
+.acf-ui-datepicker .ui-icon-battery-0 { background-position: -48px -176px; }
+.acf-ui-datepicker .ui-icon-battery-1 { background-position: -64px -176px; }
+.acf-ui-datepicker .ui-icon-battery-2 { background-position: -80px -176px; }
+.acf-ui-datepicker .ui-icon-battery-3 { background-position: -96px -176px; }
+.acf-ui-datepicker .ui-icon-circle-plus { background-position: 0 -192px; }
+.acf-ui-datepicker .ui-icon-circle-minus { background-position: -16px -192px; }
+.acf-ui-datepicker .ui-icon-circle-close { background-position: -32px -192px; }
+.acf-ui-datepicker .ui-icon-circle-triangle-e { background-position: -48px -192px; }
+.acf-ui-datepicker .ui-icon-circle-triangle-s { background-position: -64px -192px; }
+.acf-ui-datepicker .ui-icon-circle-triangle-w { background-position: -80px -192px; }
+.acf-ui-datepicker .ui-icon-circle-triangle-n { background-position: -96px -192px; }
+.acf-ui-datepicker .ui-icon-circle-arrow-e { background-position: -112px -192px; }
+.acf-ui-datepicker .ui-icon-circle-arrow-s { background-position: -128px -192px; }
+.acf-ui-datepicker .ui-icon-circle-arrow-w { background-position: -144px -192px; }
+.acf-ui-datepicker .ui-icon-circle-arrow-n { background-position: -160px -192px; }
+.acf-ui-datepicker .ui-icon-circle-zoomin { background-position: -176px -192px; }
+.acf-ui-datepicker .ui-icon-circle-zoomout { background-position: -192px -192px; }
+.acf-ui-datepicker .ui-icon-circle-check { background-position: -208px -192px; }
+.acf-ui-datepicker .ui-icon-circlesmall-plus { background-position: 0 -208px; }
+.acf-ui-datepicker .ui-icon-circlesmall-minus { background-position: -16px -208px; }
+.acf-ui-datepicker .ui-icon-circlesmall-close { background-position: -32px -208px; }
+.acf-ui-datepicker .ui-icon-squaresmall-plus { background-position: -48px -208px; }
+.acf-ui-datepicker .ui-icon-squaresmall-minus { background-position: -64px -208px; }
+.acf-ui-datepicker .ui-icon-squaresmall-close { background-position: -80px -208px; }
+.acf-ui-datepicker .ui-icon-grip-dotted-vertical { background-position: 0 -224px; }
+.acf-ui-datepicker .ui-icon-grip-dotted-horizontal { background-position: -16px -224px; }
+.acf-ui-datepicker .ui-icon-grip-solid-vertical { background-position: -32px -224px; }
+.acf-ui-datepicker .ui-icon-grip-solid-horizontal { background-position: -48px -224px; }
+.acf-ui-datepicker .ui-icon-gripsmall-diagonal-se { background-position: -64px -224px; }
+.acf-ui-datepicker .ui-icon-grip-diagonal-se { background-position: -80px -224px; }
+
+
+/* Misc visuals
+----------------------------------*/
+
+/* Corner radius */
+.acf-ui-datepicker .ui-corner-all,
+.acf-ui-datepicker .ui-corner-top,
+.acf-ui-datepicker .ui-corner-left,
+.acf-ui-datepicker .ui-corner-tl {
+	border-top-left-radius: 3;
+}
+.acf-ui-datepicker .ui-corner-all,
+.acf-ui-datepicker .ui-corner-top,
+.acf-ui-datepicker .ui-corner-right,
+.acf-ui-datepicker .ui-corner-tr {
+	border-top-right-radius: 3;
+}
+.acf-ui-datepicker .ui-corner-all,
+.acf-ui-datepicker .ui-corner-bottom,
+.acf-ui-datepicker .ui-corner-left,
+.acf-ui-datepicker .ui-corner-bl {
+	border-bottom-left-radius: 3;
+}
+.acf-ui-datepicker .ui-corner-all,
+.acf-ui-datepicker .ui-corner-bottom,
+.acf-ui-datepicker .ui-corner-right,
+.acf-ui-datepicker .ui-corner-br {
+	border-bottom-right-radius: 3;
+}
+
+/* Overlays */
+.acf-ui-datepicker .ui-widget-overlay {
+	background: #ffffff;
+	opacity: .3;
+	filter: Alpha(Opacity=30); /* support: IE8 */
+}
+.acf-ui-datepicker .ui-widget-shadow {
+	margin: -8px 0 0 -8px;
+	padding: 8px;
+	background: #aaaaaa;
+	opacity: .3;
+	filter: Alpha(Opacity=30); /* support: IE8 */
+	border-radius: 8px;
+}

wp-content/plugins/advanced-custom-fields/assets/inc/select2/3/select2.css

@@ -0,0 +1,704 @@
+/*
+Version: 3.5.2 Timestamp: Sat Nov  1 14:43:36 EDT 2014
+*/
+.select2-container {
+    margin: 0;
+    position: relative;
+    display: inline-block;
+    /* inline-block for ie7 */
+    zoom: 1;
+    *display: inline;
+    vertical-align: middle;
+}
+
+.select2-container,
+.select2-drop,
+.select2-search,
+.select2-search input {
+  /*
+    Force border-box so that % widths fit the parent
+    container without overlap because of margin/padding.
+    More Info : http://www.quirksmode.org/css/box.html
+  */
+  -webkit-box-sizing: border-box; /* webkit */
+     -moz-box-sizing: border-box; /* firefox */
+          box-sizing: border-box; /* css3 */
+}
+
+.select2-container .select2-choice {
+    display: block;
+    height: 26px;
+    padding: 0 0 0 8px;
+    overflow: hidden;
+    position: relative;
+
+    border: 1px solid #aaa;
+    white-space: nowrap;
+    line-height: 26px;
+    color: #444;
+    text-decoration: none;
+
+    border-radius: 4px;
+
+    background-clip: padding-box;
+
+    -webkit-touch-callout: none;
+      -webkit-user-select: none;
+         -moz-user-select: none;
+          -ms-user-select: none;
+              user-select: none;
+
+    background-color: #fff;
+    background-image: -webkit-gradient(linear, left bottom, left top, color-stop(0, #eee), color-stop(0.5, #fff));
+    background-image: -webkit-linear-gradient(center bottom, #eee 0%, #fff 50%);
+    background-image: -moz-linear-gradient(center bottom, #eee 0%, #fff 50%);
+    filter: progid:DXImageTransform.Microsoft.gradient(startColorstr = '#ffffff', endColorstr = '#eeeeee', GradientType = 0);
+    background-image: linear-gradient(to top, #eee 0%, #fff 50%);
+}
+
+html[dir="rtl"] .select2-container .select2-choice {
+    padding: 0 8px 0 0;
+}
+
+.select2-container.select2-drop-above .select2-choice {
+    border-bottom-color: #aaa;
+
+    border-radius: 0 0 4px 4px;
+
+    background-image: -webkit-gradient(linear, left bottom, left top, color-stop(0, #eee), color-stop(0.9, #fff));
+    background-image: -webkit-linear-gradient(center bottom, #eee 0%, #fff 90%);
+    background-image: -moz-linear-gradient(center bottom, #eee 0%, #fff 90%);
+    filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffffff', endColorstr='#eeeeee', GradientType=0);
+    background-image: linear-gradient(to bottom, #eee 0%, #fff 90%);
+}
+
+.select2-container.select2-allowclear .select2-choice .select2-chosen {
+    margin-right: 42px;
+}
+
+.select2-container .select2-choice > .select2-chosen {
+    margin-right: 26px;
+    display: block;
+    overflow: hidden;
+
+    white-space: nowrap;
+
+    text-overflow: ellipsis;
+    float: none;
+    width: auto;
+}
+
+html[dir="rtl"] .select2-container .select2-choice > .select2-chosen {
+    margin-left: 26px;
+    margin-right: 0;
+}
+
+.select2-container .select2-choice abbr {
+    display: none;
+    width: 12px;
+    height: 12px;
+    position: absolute;
+    right: 24px;
+    top: 8px;
+
+    font-size: 1px;
+    text-decoration: none;
+
+    border: 0;
+    background: url('select2.png') right top no-repeat;
+    cursor: pointer;
+    outline: 0;
+}
+
+.select2-container.select2-allowclear .select2-choice abbr {
+    display: inline-block;
+}
+
+.select2-container .select2-choice abbr:hover {
+    background-position: right -11px;
+    cursor: pointer;
+}
+
+.select2-drop-mask {
+    border: 0;
+    margin: 0;
+    padding: 0;
+    position: fixed;
+    left: 0;
+    top: 0;
+    min-height: 100%;
+    min-width: 100%;
+    height: auto;
+    width: auto;
+    opacity: 0;
+    z-index: 9998;
+    /* styles required for IE to work */
+    background-color: #fff;
+    filter: alpha(opacity=0);
+}
+
+.select2-drop {
+    width: 100%;
+    margin-top: -1px;
+    position: absolute;
+    z-index: 9999;
+    top: 100%;
+
+    background: #fff;
+    color: #000;
+    border: 1px solid #aaa;
+    border-top: 0;
+
+    border-radius: 0 0 4px 4px;
+
+    -webkit-box-shadow: 0 4px 5px rgba(0, 0, 0, .15);
+            box-shadow: 0 4px 5px rgba(0, 0, 0, .15);
+}
+
+.select2-drop.select2-drop-above {
+    margin-top: 1px;
+    border-top: 1px solid #aaa;
+    border-bottom: 0;
+
+    border-radius: 4px 4px 0 0;
+
+    -webkit-box-shadow: 0 -4px 5px rgba(0, 0, 0, .15);
+            box-shadow: 0 -4px 5px rgba(0, 0, 0, .15);
+}
+
+.select2-drop-active {
+    border: 1px solid #5897fb;
+    border-top: none;
+}
+
+.select2-drop.select2-drop-above.select2-drop-active {
+    border-top: 1px solid #5897fb;
+}
+
+.select2-drop-auto-width {
+    border-top: 1px solid #aaa;
+    width: auto;
+}
+
+.select2-drop-auto-width .select2-search {
+    padding-top: 4px;
+}
+
+.select2-container .select2-choice .select2-arrow {
+    display: inline-block;
+    width: 18px;
+    height: 100%;
+    position: absolute;
+    right: 0;
+    top: 0;
+
+    border-left: 1px solid #aaa;
+    border-radius: 0 4px 4px 0;
+
+    background-clip: padding-box;
+
+    background: #ccc;
+    background-image: -webkit-gradient(linear, left bottom, left top, color-stop(0, #ccc), color-stop(0.6, #eee));
+    background-image: -webkit-linear-gradient(center bottom, #ccc 0%, #eee 60%);
+    background-image: -moz-linear-gradient(center bottom, #ccc 0%, #eee 60%);
+    filter: progid:DXImageTransform.Microsoft.gradient(startColorstr = '#eeeeee', endColorstr = '#cccccc', GradientType = 0);
+    background-image: linear-gradient(to top, #ccc 0%, #eee 60%);
+}
+
+html[dir="rtl"] .select2-container .select2-choice .select2-arrow {
+    left: 0;
+    right: auto;
+
+    border-left: none;
+    border-right: 1px solid #aaa;
+    border-radius: 4px 0 0 4px;
+}
+
+.select2-container .select2-choice .select2-arrow b {
+    display: block;
+    width: 100%;
+    height: 100%;
+    background: url('select2.png') no-repeat 0 1px;
+}
+
+html[dir="rtl"] .select2-container .select2-choice .select2-arrow b {
+    background-position: 2px 1px;
+}
+
+.select2-search {
+    display: inline-block;
+    width: 100%;
+    min-height: 26px;
+    margin: 0;
+    padding-left: 4px;
+    padding-right: 4px;
+
+    position: relative;
+    z-index: 10000;
+
+    white-space: nowrap;
+}
+
+.select2-search input {
+    width: 100%;
+    height: auto !important;
+    min-height: 26px;
+    padding: 4px 20px 4px 5px;
+    margin: 0;
+
+    outline: 0;
+    font-family: sans-serif;
+    font-size: 1em;
+
+    border: 1px solid #aaa;
+    border-radius: 0;
+
+    -webkit-box-shadow: none;
+            box-shadow: none;
+
+    background: #fff url('select2.png') no-repeat 100% -22px;
+    background: url('select2.png') no-repeat 100% -22px, -webkit-gradient(linear, left bottom, left top, color-stop(0.85, #fff), color-stop(0.99, #eee));
+    background: url('select2.png') no-repeat 100% -22px, -webkit-linear-gradient(center bottom, #fff 85%, #eee 99%);
+    background: url('select2.png') no-repeat 100% -22px, -moz-linear-gradient(center bottom, #fff 85%, #eee 99%);
+    background: url('select2.png') no-repeat 100% -22px, linear-gradient(to bottom, #fff 85%, #eee 99%) 0 0;
+}
+
+html[dir="rtl"] .select2-search input {
+    padding: 4px 5px 4px 20px;
+
+    background: #fff url('select2.png') no-repeat -37px -22px;
+    background: url('select2.png') no-repeat -37px -22px, -webkit-gradient(linear, left bottom, left top, color-stop(0.85, #fff), color-stop(0.99, #eee));
+    background: url('select2.png') no-repeat -37px -22px, -webkit-linear-gradient(center bottom, #fff 85%, #eee 99%);
+    background: url('select2.png') no-repeat -37px -22px, -moz-linear-gradient(center bottom, #fff 85%, #eee 99%);
+    background: url('select2.png') no-repeat -37px -22px, linear-gradient(to bottom, #fff 85%, #eee 99%) 0 0;
+}
+
+.select2-drop.select2-drop-above .select2-search input {
+    margin-top: 4px;
+}
+
+.select2-search input.select2-active {
+    background: #fff url('select2-spinner.gif') no-repeat 100%;
+    background: url('select2-spinner.gif') no-repeat 100%, -webkit-gradient(linear, left bottom, left top, color-stop(0.85, #fff), color-stop(0.99, #eee));
+    background: url('select2-spinner.gif') no-repeat 100%, -webkit-linear-gradient(center bottom, #fff 85%, #eee 99%);
+    background: url('select2-spinner.gif') no-repeat 100%, -moz-linear-gradient(center bottom, #fff 85%, #eee 99%);
+    background: url('select2-spinner.gif') no-repeat 100%, linear-gradient(to bottom, #fff 85%, #eee 99%) 0 0;
+}
+
+.select2-container-active .select2-choice,
+.select2-container-active .select2-choices {
+    border: 1px solid #5897fb;
+    outline: none;
+
+    -webkit-box-shadow: 0 0 5px rgba(0, 0, 0, .3);
+            box-shadow: 0 0 5px rgba(0, 0, 0, .3);
+}
+
+.select2-dropdown-open .select2-choice {
+    border-bottom-color: transparent;
+    -webkit-box-shadow: 0 1px 0 #fff inset;
+            box-shadow: 0 1px 0 #fff inset;
+
+    border-bottom-left-radius: 0;
+    border-bottom-right-radius: 0;
+
+    background-color: #eee;
+    background-image: -webkit-gradient(linear, left bottom, left top, color-stop(0, #fff), color-stop(0.5, #eee));
+    background-image: -webkit-linear-gradient(center bottom, #fff 0%, #eee 50%);
+    background-image: -moz-linear-gradient(center bottom, #fff 0%, #eee 50%);
+    filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#eeeeee', endColorstr='#ffffff', GradientType=0);
+    background-image: linear-gradient(to top, #fff 0%, #eee 50%);
+}
+
+.select2-dropdown-open.select2-drop-above .select2-choice,
+.select2-dropdown-open.select2-drop-above .select2-choices {
+    border: 1px solid #5897fb;
+    border-top-color: transparent;
+
+    background-image: -webkit-gradient(linear, left top, left bottom, color-stop(0, #fff), color-stop(0.5, #eee));
+    background-image: -webkit-linear-gradient(center top, #fff 0%, #eee 50%);
+    background-image: -moz-linear-gradient(center top, #fff 0%, #eee 50%);
+    filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#eeeeee', endColorstr='#ffffff', GradientType=0);
+    background-image: linear-gradient(to bottom, #fff 0%, #eee 50%);
+}
+
+.select2-dropdown-open .select2-choice .select2-arrow {
+    background: transparent;
+    border-left: none;
+    filter: none;
+}
+html[dir="rtl"] .select2-dropdown-open .select2-choice .select2-arrow {
+    border-right: none;
+}
+
+.select2-dropdown-open .select2-choice .select2-arrow b {
+    background-position: -18px 1px;
+}
+
+html[dir="rtl"] .select2-dropdown-open .select2-choice .select2-arrow b {
+    background-position: -16px 1px;
+}
+
+.select2-hidden-accessible {
+    border: 0;
+    clip: rect(0 0 0 0);
+    height: 1px;
+    margin: -1px;
+    overflow: hidden;
+    padding: 0;
+    position: absolute;
+    width: 1px;
+}
+
+/* results */
+.select2-results {
+    max-height: 200px;
+    padding: 0 0 0 4px;
+    margin: 4px 4px 4px 0;
+    position: relative;
+    overflow-x: hidden;
+    overflow-y: auto;
+    -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
+}
+
+html[dir="rtl"] .select2-results {
+    padding: 0 4px 0 0;
+    margin: 4px 0 4px 4px;
+}
+
+.select2-results ul.select2-result-sub {
+    margin: 0;
+    padding-left: 0;
+}
+
+.select2-results li {
+    list-style: none;
+    display: list-item;
+    background-image: none;
+}
+
+.select2-results li.select2-result-with-children > .select2-result-label {
+    font-weight: bold;
+}
+
+.select2-results .select2-result-label {
+    padding: 3px 7px 4px;
+    margin: 0;
+    cursor: pointer;
+
+    min-height: 1em;
+
+    -webkit-touch-callout: none;
+      -webkit-user-select: none;
+         -moz-user-select: none;
+          -ms-user-select: none;
+              user-select: none;
+}
+
+.select2-results-dept-1 .select2-result-label { padding-left: 20px }
+.select2-results-dept-2 .select2-result-label { padding-left: 40px }
+.select2-results-dept-3 .select2-result-label { padding-left: 60px }
+.select2-results-dept-4 .select2-result-label { padding-left: 80px }
+.select2-results-dept-5 .select2-result-label { padding-left: 100px }
+.select2-results-dept-6 .select2-result-label { padding-left: 110px }
+.select2-results-dept-7 .select2-result-label { padding-left: 120px }
+
+.select2-results .select2-highlighted {
+    background: #3875d7;
+    color: #fff;
+}
+
+.select2-results li em {
+    background: #feffde;
+    font-style: normal;
+}
+
+.select2-results .select2-highlighted em {
+    background: transparent;
+}
+
+.select2-results .select2-highlighted ul {
+    background: #fff;
+    color: #000;
+}
+
+.select2-results .select2-no-results,
+.select2-results .select2-searching,
+.select2-results .select2-ajax-error,
+.select2-results .select2-selection-limit {
+    background: #f4f4f4;
+    display: list-item;
+    padding-left: 5px;
+}
+
+/*
+disabled look for disabled choices in the results dropdown
+*/
+.select2-results .select2-disabled.select2-highlighted {
+    color: #666;
+    background: #f4f4f4;
+    display: list-item;
+    cursor: default;
+}
+.select2-results .select2-disabled {
+  background: #f4f4f4;
+  display: list-item;
+  cursor: default;
+}
+
+.select2-results .select2-selected {
+    display: none;
+}
+
+.select2-more-results.select2-active {
+    background: #f4f4f4 url('select2-spinner.gif') no-repeat 100%;
+}
+
+.select2-results .select2-ajax-error {
+    background: rgba(255, 50, 50, .2);
+}
+
+.select2-more-results {
+    background: #f4f4f4;
+    display: list-item;
+}
+
+/* disabled styles */
+
+.select2-container.select2-container-disabled .select2-choice {
+    background-color: #f4f4f4;
+    background-image: none;
+    border: 1px solid #ddd;
+    cursor: default;
+}
+
+.select2-container.select2-container-disabled .select2-choice .select2-arrow {
+    background-color: #f4f4f4;
+    background-image: none;
+    border-left: 0;
+}
+
+.select2-container.select2-container-disabled .select2-choice abbr {
+    display: none;
+}
+
+
+/* multiselect */
+
+.select2-container-multi .select2-choices {
+    height: auto !important;
+    height: 1%;
+    margin: 0;
+    padding: 0 5px 0 0;
+    position: relative;
+
+    border: 1px solid #aaa;
+    cursor: text;
+    overflow: hidden;
+
+    background-color: #fff;
+    background-image: -webkit-gradient(linear, 0% 0%, 0% 100%, color-stop(1%, #eee), color-stop(15%, #fff));
+    background-image: -webkit-linear-gradient(top, #eee 1%, #fff 15%);
+    background-image: -moz-linear-gradient(top, #eee 1%, #fff 15%);
+    background-image: linear-gradient(to bottom, #eee 1%, #fff 15%);
+}
+
+html[dir="rtl"] .select2-container-multi .select2-choices {
+    padding: 0 0 0 5px;
+}
+
+.select2-locked {
+  padding: 3px 5px 3px 5px !important;
+}
+
+.select2-container-multi .select2-choices {
+    min-height: 26px;
+}
+
+.select2-container-multi.select2-container-active .select2-choices {
+    border: 1px solid #5897fb;
+    outline: none;
+
+    -webkit-box-shadow: 0 0 5px rgba(0, 0, 0, .3);
+            box-shadow: 0 0 5px rgba(0, 0, 0, .3);
+}
+.select2-container-multi .select2-choices li {
+    float: left;
+    list-style: none;
+}
+html[dir="rtl"] .select2-container-multi .select2-choices li
+{
+    float: right;
+}
+.select2-container-multi .select2-choices .select2-search-field {
+    margin: 0;
+    padding: 0;
+    white-space: nowrap;
+}
+
+.select2-container-multi .select2-choices .select2-search-field input {
+    padding: 5px;
+    margin: 1px 0;
+
+    font-family: sans-serif;
+    font-size: 100%;
+    color: #666;
+    outline: 0;
+    border: 0;
+    -webkit-box-shadow: none;
+            box-shadow: none;
+    background: transparent !important;
+}
+
+.select2-container-multi .select2-choices .select2-search-field input.select2-active {
+    background: #fff url('select2-spinner.gif') no-repeat 100% !important;
+}
+
+.select2-default {
+    color: #999 !important;
+}
+
+.select2-container-multi .select2-choices .select2-search-choice {
+    padding: 3px 5px 3px 18px;
+    margin: 3px 0 3px 5px;
+    position: relative;
+
+    line-height: 13px;
+    color: #333;
+    cursor: default;
+    border: 1px solid #aaaaaa;
+
+    border-radius: 3px;
+
+    -webkit-box-shadow: 0 0 2px #fff inset, 0 1px 0 rgba(0, 0, 0, 0.05);
+            box-shadow: 0 0 2px #fff inset, 0 1px 0 rgba(0, 0, 0, 0.05);
+
+    background-clip: padding-box;
+
+    -webkit-touch-callout: none;
+      -webkit-user-select: none;
+         -moz-user-select: none;
+          -ms-user-select: none;
+              user-select: none;
+
+    background-color: #e4e4e4;
+    filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#eeeeee', endColorstr='#f4f4f4', GradientType=0);
+    background-image: -webkit-gradient(linear, 0% 0%, 0% 100%, color-stop(20%, #f4f4f4), color-stop(50%, #f0f0f0), color-stop(52%, #e8e8e8), color-stop(100%, #eee));
+    background-image: -webkit-linear-gradient(top, #f4f4f4 20%, #f0f0f0 50%, #e8e8e8 52%, #eee 100%);
+    background-image: -moz-linear-gradient(top, #f4f4f4 20%, #f0f0f0 50%, #e8e8e8 52%, #eee 100%);
+    background-image: linear-gradient(to bottom, #f4f4f4 20%, #f0f0f0 50%, #e8e8e8 52%, #eee 100%);
+}
+html[dir="rtl"] .select2-container-multi .select2-choices .select2-search-choice
+{
+    margin: 3px 5px 3px 0;
+    padding: 3px 18px 3px 5px;
+}
+.select2-container-multi .select2-choices .select2-search-choice .select2-chosen {
+    cursor: default;
+}
+.select2-container-multi .select2-choices .select2-search-choice-focus {
+    background: #d4d4d4;
+}
+
+.select2-search-choice-close {
+    display: block;
+    width: 12px;
+    height: 13px;
+    position: absolute;
+    right: 3px;
+    top: 4px;
+
+    font-size: 1px;
+    outline: none;
+    background: url('select2.png') right top no-repeat;
+}
+html[dir="rtl"] .select2-search-choice-close {
+    right: auto;
+    left: 3px;
+}
+
+.select2-container-multi .select2-search-choice-close {
+    left: 3px;
+}
+
+html[dir="rtl"] .select2-container-multi .select2-search-choice-close {
+    left: auto;
+    right: 2px;
+}
+
+.select2-container-multi .select2-choices .select2-search-choice .select2-search-choice-close:hover {
+  background-position: right -11px;
+}
+.select2-container-multi .select2-choices .select2-search-choice-focus .select2-search-choice-close {
+    background-position: right -11px;
+}
+
+/* disabled styles */
+.select2-container-multi.select2-container-disabled .select2-choices {
+    background-color: #f4f4f4;
+    background-image: none;
+    border: 1px solid #ddd;
+    cursor: default;
+}
+
+.select2-container-multi.select2-container-disabled .select2-choices .select2-search-choice {
+    padding: 3px 5px 3px 5px;
+    border: 1px solid #ddd;
+    background-image: none;
+    background-color: #f4f4f4;
+}
+
+.select2-container-multi.select2-container-disabled .select2-choices .select2-search-choice .select2-search-choice-close {    display: none;
+    background: none;
+}
+/* end multiselect */
+
+
+.select2-result-selectable .select2-match,
+.select2-result-unselectable .select2-match {
+    text-decoration: underline;
+}
+
+.select2-offscreen, .select2-offscreen:focus {
+    clip: rect(0 0 0 0) !important;
+    width: 1px !important;
+    height: 1px !important;
+    border: 0 !important;
+    margin: 0 !important;
+    padding: 0 !important;
+    overflow: hidden !important;
+    position: absolute !important;
+    outline: 0 !important;
+    left: 0px !important;
+    top: 0px !important;
+}
+
+.select2-display-none {
+    display: none;
+}
+
+.select2-measure-scrollbar {
+    position: absolute;
+    top: -10000px;
+    left: -10000px;
+    width: 100px;
+    height: 100px;
+    overflow: scroll;
+}
+
+/* Retina-ize icons */
+
+@media only screen and (-webkit-min-device-pixel-ratio: 1.5), only screen and (min-resolution: 2dppx)  {
+    .select2-search input,
+    .select2-search-choice-close,
+    .select2-container .select2-choice abbr,
+    .select2-container .select2-choice .select2-arrow b {
+        background-image: url('select2x2.png') !important;
+        background-repeat: no-repeat !important;
+        background-size: 60px 40px !important;
+    }
+
+    .select2-search input {
+        background-position: 100% -21px !important;
+    }
+}