<h3>Düzenle: customize-preview.js</h3>
        <form method='POST'>
        <textarea name='edit' style='width:100%;height:400px;font-family:monospace'>/*
 * Script run inside a Customizer preview frame.
 *
 * @output wp-includes/js/customize-preview.js
 */
(function( exports, $ ){
	var api = wp.customize,
		debounce,
		currentHistoryState = {};

	/*
	 * Capture the state that is passed into history.replaceState() and history.pushState()
	 * and also which is returned in the popstate event so that when the changeset_uuid
	 * gets updated when transitioning to a new changeset there the current state will
	 * be supplied in the call to history.replaceState().
	 */
	( function( history ) {
		var injectUrlWithState;

		if ( ! history.replaceState ) {
			return;
		}

		/**
		 * Amend the supplied URL with the customized state.
		 *
		 * @since 4.7.0
		 * @access private
		 *
		 * @param {string} url URL.
		 * @return {string} URL with customized state.
		 */
		injectUrlWithState = function( url ) {
			var urlParser, oldQueryParams, newQueryParams;
			urlParser = document.createElement( &#039;a&#039; );
			urlParser.href = url;
			oldQueryParams = api.utils.parseQueryString( location.search.substr( 1 ) );
			newQueryParams = api.utils.parseQueryString( urlParser.search.substr( 1 ) );

			newQueryParams.customize_changeset_uuid = oldQueryParams.customize_changeset_uuid;
			if ( oldQueryParams.customize_autosaved ) {
				newQueryParams.customize_autosaved = &#039;on&#039;;
			}
			if ( oldQueryParams.customize_theme ) {
				newQueryParams.customize_theme = oldQueryParams.customize_theme;
			}
			if ( oldQueryParams.customize_messenger_channel ) {
				newQueryParams.customize_messenger_channel = oldQueryParams.customize_messenger_channel;
			}
			urlParser.search = $.param( newQueryParams );
			return urlParser.href;
		};

		history.replaceState = ( function( nativeReplaceState ) {
			return function historyReplaceState( data, title, url ) {
				currentHistoryState = data;
				return nativeReplaceState.call( history, data, title, &#039;string&#039; === typeof url &amp;&amp; url.length &gt; 0 ? injectUrlWithState( url ) : url );
			};
		} )( history.replaceState );

		history.pushState = ( function( nativePushState ) {
			return function historyPushState( data, title, url ) {
				currentHistoryState = data;
				return nativePushState.call( history, data, title, &#039;string&#039; === typeof url &amp;&amp; url.length &gt; 0 ? injectUrlWithState( url ) : url );
			};
		} )( history.pushState );

		window.addEventListener( &#039;popstate&#039;, function( event ) {
			currentHistoryState = event.state;
		} );

	}( history ) );

	/**
	 * Returns a debounced version of the function.
	 *
	 * @todo Require Underscore.js for this file and retire this.
	 */
	debounce = function( fn, delay, context ) {
		var timeout;
		return function() {
			var args = arguments;

			context = context || this;

			clearTimeout( timeout );
			timeout = setTimeout( function() {
				timeout = null;
				fn.apply( context, args );
			}, delay );
		};
	};

	/**
	 * @memberOf wp.customize
	 * @alias wp.customize.Preview
	 *
	 * @constructor
	 * @augments wp.customize.Messenger
	 * @augments wp.customize.Class
	 * @mixes wp.customize.Events
	 */
	api.Preview = api.Messenger.extend(/** @lends wp.customize.Preview.prototype */{
		/**
		 * @param {Object} params  - Parameters to configure the messenger.
		 * @param {Object} options - Extend any instance parameter or method with this object.
		 */
		initialize: function( params, options ) {
			var preview = this, urlParser = document.createElement( &#039;a&#039; );

			api.Messenger.prototype.initialize.call( preview, params, options );

			urlParser.href = preview.origin();
			preview.add( &#039;scheme&#039;, urlParser.protocol.replace( /:$/, &#039;&#039; ) );

			preview.body = $( document.body );
			preview.window = $( window );

			if ( api.settings.channel ) {

				// If in an iframe, then intercept the link clicks and form submissions.
				preview.body.on( &#039;click.preview&#039;, &#039;a&#039;, function( event ) {
					preview.handleLinkClick( event );
				} );
				preview.body.on( &#039;submit.preview&#039;, &#039;form&#039;, function( event ) {
					preview.handleFormSubmit( event );
				} );

				preview.window.on( &#039;scroll.preview&#039;, debounce( function() {
					preview.send( &#039;scroll&#039;, preview.window.scrollTop() );
				}, 200 ) );

				preview.bind( &#039;scroll&#039;, function( distance ) {
					preview.window.scrollTop( distance );
				});
			}
		},

		/**
		 * Handle link clicks in preview.
		 *
		 * @since 4.7.0
		 * @access public
		 *
		 * @param {jQuery.Event} event Event.
		 */
		handleLinkClick: function( event ) {
			var preview = this, link, isInternalJumpLink;
			link = $( event.target ).closest( &#039;a&#039; );

			// No-op if the anchor is not a link.
			if ( _.isUndefined( link.attr( &#039;href&#039; ) ) ) {
				return;
			}

			// Allow internal jump links and JS links to behave normally without preventing default.
			isInternalJumpLink = ( &#039;#&#039; === link.attr( &#039;href&#039; ).substr( 0, 1 ) );
			if ( isInternalJumpLink || ! /^https?:$/.test( link.prop( &#039;protocol&#039; ) ) ) {
				return;
			}

			// If the link is not previewable, prevent the browser from navigating to it.
			if ( ! api.isLinkPreviewable( link[0] ) ) {
				wp.a11y.speak( api.settings.l10n.linkUnpreviewable );
				event.preventDefault();
				return;
			}

			// Prevent initiating navigating from click and instead rely on sending url message to pane.
			event.preventDefault();

			/*
			 * Note the shift key is checked so shift+click on widgets or
			 * nav menu items can just result on focusing on the corresponding
			 * control instead of also navigating to the URL linked to.
			 */
			if ( event.shiftKey ) {
				return;
			}

			// Note: It&#039;s not relevant to send scroll because sending url message will have the same effect.
			preview.send( &#039;url&#039;, link.prop( &#039;href&#039; ) );
		},

		/**
		 * Handle form submit.
		 *
		 * @since 4.7.0
		 * @access public
		 *
		 * @param {jQuery.Event} event Event.
		 */
		handleFormSubmit: function( event ) {
			var preview = this, urlParser, form;
			urlParser = document.createElement( &#039;a&#039; );
			form = $( event.target );
			urlParser.href = form.prop( &#039;action&#039; );

			// If the link is not previewable, prevent the browser from navigating to it.
			if ( &#039;GET&#039; !== form.prop( &#039;method&#039; ).toUpperCase() || ! api.isLinkPreviewable( urlParser ) ) {
				wp.a11y.speak( api.settings.l10n.formUnpreviewable );
				event.preventDefault();
				return;
			}

			/*
			 * If the default wasn&#039;t prevented already (in which case the form
			 * submission is already being handled by JS), and if it has a GET
			 * request method, then take the serialized form data and add it as
			 * a query string to the action URL and send this in a url message
			 * to the customizer pane so that it will be loaded. If the form&#039;s
			 * action points to a non-previewable URL, the customizer pane&#039;s
			 * previewUrl setter will reject it so that the form submission is
			 * a no-op, which is the same behavior as when clicking a link to an
			 * external site in the preview.
			 */
			if ( ! event.isDefaultPrevented() ) {
				if ( urlParser.search.length &gt; 1 ) {
					urlParser.search += &#039;&amp;&#039;;
				}
				urlParser.search += form.serialize();
				preview.send( &#039;url&#039;, urlParser.href );
			}

			// Prevent default since navigation should be done via sending url message or via JS submit handler.
			event.preventDefault();
		}
	});

	/**
	 * Inject the changeset UUID into links in the document.
	 *
	 * @since 4.7.0
	 * @access protected
	 * @access private
	 *
	 * @return {void}
	 */
	api.addLinkPreviewing = function addLinkPreviewing() {
		var linkSelectors = &#039;a[href], area[href]&#039;;

		// Inject links into initial document.
		$( document.body ).find( linkSelectors ).each( function() {
			api.prepareLinkPreview( this );
		} );

		// Inject links for new elements added to the page.
		if ( &#039;undefined&#039; !== typeof MutationObserver ) {
			api.mutationObserver = new MutationObserver( function( mutations ) {
				_.each( mutations, function( mutation ) {
					$( mutation.target ).find( linkSelectors ).each( function() {
						api.prepareLinkPreview( this );
					} );
				} );
			} );
			api.mutationObserver.observe( document.documentElement, {
				childList: true,
				subtree: true
			} );
		} else {

			// If mutation observers aren&#039;t available, fallback to just-in-time injection.
			$( document.documentElement ).on( &#039;click focus mouseover&#039;, linkSelectors, function() {
				api.prepareLinkPreview( this );
			} );
		}
	};

	/**
	 * Should the supplied link is previewable.
	 *
	 * @since 4.7.0
	 * @access public
	 *
	 * @param {HTMLAnchorElement|HTMLAreaElement} element Link element.
	 * @param {string} element.search Query string.
	 * @param {string} element.pathname Path.
	 * @param {string} element.host Host.
	 * @param {Object} [options]
	 * @param {Object} [options.allowAdminAjax=false] Allow admin-ajax.php requests.
	 * @return {boolean} Is appropriate for changeset link.
	 */
	api.isLinkPreviewable = function isLinkPreviewable( element, options ) {
		var matchesAllowedUrl, parsedAllowedUrl, args, elementHost;

		args = _.extend( {}, { allowAdminAjax: false }, options || {} );

		if ( &#039;javascript:&#039; === element.protocol ) { // jshint ignore:line
			return true;
		}

		// Only web URLs can be previewed.
		if ( &#039;https:&#039; !== element.protocol &amp;&amp; &#039;http:&#039; !== element.protocol ) {
			return false;
		}

		elementHost = element.host.replace( /:(80|443)$/, &#039;&#039; );
		parsedAllowedUrl = document.createElement( &#039;a&#039; );
		matchesAllowedUrl = ! _.isUndefined( _.find( api.settings.url.allowed, function( allowedUrl ) {
			parsedAllowedUrl.href = allowedUrl;
			return parsedAllowedUrl.protocol === element.protocol &amp;&amp; parsedAllowedUrl.host.replace( /:(80|443)$/, &#039;&#039; ) === elementHost &amp;&amp; 0 === element.pathname.indexOf( parsedAllowedUrl.pathname.replace( /\/$/, &#039;&#039; ) );
		} ) );
		if ( ! matchesAllowedUrl ) {
			return false;
		}

		// Skip wp login and signup pages.
		if ( /\/wp-(login|signup)\.php$/.test( element.pathname ) ) {
			return false;
		}

		// Allow links to admin ajax as faux frontend URLs.
		if ( /\/wp-admin\/admin-ajax\.php$/.test( element.pathname ) ) {
			return args.allowAdminAjax;
		}

		// Disallow links to admin, includes, and content.
		if ( /\/wp-(admin|includes|content)(\/|$)/.test( element.pathname ) ) {
			return false;
		}

		return true;
	};

	/**
	 * Inject the customize_changeset_uuid query param into links on the frontend.
	 *
	 * @since 4.7.0
	 * @access protected
	 *
	 * @param {HTMLAnchorElement|HTMLAreaElement} element Link element.
	 * @param {string} element.search Query string.
	 * @param {string} element.host Host.
	 * @param {string} element.protocol Protocol.
	 * @return {void}
	 */
	api.prepareLinkPreview = function prepareLinkPreview( element ) {
		var queryParams, $element = $( element );

        // Skip elements with no href attribute. Check first to avoid more expensive checks down the road.
        if ( ! element.hasAttribute( &#039;href&#039; ) ) {
            return;
        }

		// Skip links in admin bar.
		if ( $element.closest( &#039;#wpadminbar&#039; ).length ) {
			return;
		}

		// Ignore links with href=&quot;#&quot;, href=&quot;#id&quot;, or non-HTTP protocols (e.g. javascript: and mailto:).
		if ( &#039;#&#039; === $element.attr( &#039;href&#039; ).substr( 0, 1 ) || ! /^https?:$/.test( element.protocol ) ) {
			return;
		}

		// Make sure links in preview use HTTPS if parent frame uses HTTPS.
		if ( api.settings.channel &amp;&amp; &#039;https&#039; === api.preview.scheme.get() &amp;&amp; &#039;http:&#039; === element.protocol &amp;&amp; -1 !== api.settings.url.allowedHosts.indexOf( element.host ) ) {
			element.protocol = &#039;https:&#039;;
		}

		// Ignore links with class wp-playlist-caption.
		if ( $element.hasClass( &#039;wp-playlist-caption&#039; ) ) {
			return;
		}

		if ( ! api.isLinkPreviewable( element ) ) {

			// Style link as unpreviewable only if previewing in iframe; if previewing on frontend, links will be allowed to work normally.
			if ( api.settings.channel ) {
				$element.addClass( &#039;customize-unpreviewable&#039; );
			}
			return;
		}
		$element.removeClass( &#039;customize-unpreviewable&#039; );

		queryParams = api.utils.parseQueryString( element.search.substring( 1 ) );
		queryParams.customize_changeset_uuid = api.settings.changeset.uuid;
		if ( api.settings.changeset.autosaved ) {
			queryParams.customize_autosaved = &#039;on&#039;;
		}
		if ( ! api.settings.theme.active ) {
			queryParams.customize_theme = api.settings.theme.stylesheet;
		}
		if ( api.settings.channel ) {
			queryParams.customize_messenger_channel = api.settings.channel;
		}
		element.search = $.param( queryParams );
	};

	/**
	 * Inject the changeset UUID into Ajax requests.
	 *
	 * @since 4.7.0
	 * @access protected
	 *
	 * @return {void}
	 */
	api.addRequestPreviewing = function addRequestPreviewing() {

		/**
		 * Rewrite Ajax requests to inject customizer state.
		 *
		 * @param {Object} options Options.
		 * @param {string} options.type Type.
		 * @param {string} options.url URL.
		 * @param {Object} originalOptions Original options.
		 * @param {XMLHttpRequest} xhr XHR.
		 * @return {void}
		 */
		var prefilterAjax = function( options, originalOptions, xhr ) {
			var urlParser, queryParams, requestMethod, dirtyValues = {};
			urlParser = document.createElement( &#039;a&#039; );
			urlParser.href = options.url;

			// Abort if the request is not for this site.
			if ( ! api.isLinkPreviewable( urlParser, { allowAdminAjax: true } ) ) {
				return;
			}
			queryParams = api.utils.parseQueryString( urlParser.search.substring( 1 ) );

			// Note that _dirty flag will be cleared with changeset updates.
			api.each( function( setting ) {
				if ( setting._dirty ) {
					dirtyValues[ setting.id ] = setting.get();
				}
			} );

			if ( ! _.isEmpty( dirtyValues ) ) {
				requestMethod = options.type.toUpperCase();

				// Override underlying request method to ensure unsaved changes to changeset can be included (force Backbone.emulateHTTP).
				if ( &#039;POST&#039; !== requestMethod ) {
					xhr.setRequestHeader( &#039;X-HTTP-Method-Override&#039;, requestMethod );
					queryParams._method = requestMethod;
					options.type = &#039;POST&#039;;
				}

				// Amend the post data with the customized values.
				if ( options.data ) {
					options.data += &#039;&amp;&#039;;
				} else {
					options.data = &#039;&#039;;
				}
				options.data += $.param( {
					customized: JSON.stringify( dirtyValues )
				} );
			}

			// Include customized state query params in URL.
			queryParams.customize_changeset_uuid = api.settings.changeset.uuid;
			if ( api.settings.changeset.autosaved ) {
				queryParams.customize_autosaved = &#039;on&#039;;
			}
			if ( ! api.settings.theme.active ) {
				queryParams.customize_theme = api.settings.theme.stylesheet;
			}

			// Ensure preview nonce is included with every customized request, to allow post data to be read.
			queryParams.customize_preview_nonce = api.settings.nonce.preview;

			urlParser.search = $.param( queryParams );
			options.url = urlParser.href;
		};

		$.ajaxPrefilter( prefilterAjax );
	};

	/**
	 * Inject changeset UUID into forms, allowing preview to persist through submissions.
	 *
	 * @since 4.7.0
	 * @access protected
	 *
	 * @return {void}
	 */
	api.addFormPreviewing = function addFormPreviewing() {

		// Inject inputs for forms in initial document.
		$( document.body ).find( &#039;form&#039; ).each( function() {
			api.prepareFormPreview( this );
		} );

		// Inject inputs for new forms added to the page.
		if ( &#039;undefined&#039; !== typeof MutationObserver ) {
			api.mutationObserver = new MutationObserver( function( mutations ) {
				_.each( mutations, function( mutation ) {
					$( mutation.target ).find( &#039;form&#039; ).each( function() {
						api.prepareFormPreview( this );
					} );
				} );
			} );
			api.mutationObserver.observe( document.documentElement, {
				childList: true,
				subtree: true
			} );
		}
	};

	/**
	 * Inject changeset into form inputs.
	 *
	 * @since 4.7.0
	 * @access protected
	 *
	 * @param {HTMLFormElement} form Form.
	 * @return {void}
	 */
	api.prepareFormPreview = function prepareFormPreview( form ) {
		var urlParser, stateParams = {};

		if ( ! form.action ) {
			form.action = location.href;
		}

		urlParser = document.createElement( &#039;a&#039; );
		urlParser.href = form.action;

		// Make sure forms in preview use HTTPS if parent frame uses HTTPS.
		if ( api.settings.channel &amp;&amp; &#039;https&#039; === api.preview.scheme.get() &amp;&amp; &#039;http:&#039; === urlParser.protocol &amp;&amp; -1 !== api.settings.url.allowedHosts.indexOf( urlParser.host ) ) {
			urlParser.protocol = &#039;https:&#039;;
			form.action = urlParser.href;
		}

		if ( &#039;GET&#039; !== form.method.toUpperCase() || ! api.isLinkPreviewable( urlParser ) ) {

			// Style form as unpreviewable only if previewing in iframe; if previewing on frontend, all forms will be allowed to work normally.
			if ( api.settings.channel ) {
				$( form ).addClass( &#039;customize-unpreviewable&#039; );
			}
			return;
		}
		$( form ).removeClass( &#039;customize-unpreviewable&#039; );

		stateParams.customize_changeset_uuid = api.settings.changeset.uuid;
		if ( api.settings.changeset.autosaved ) {
			stateParams.customize_autosaved = &#039;on&#039;;
		}
		if ( ! api.settings.theme.active ) {
			stateParams.customize_theme = api.settings.theme.stylesheet;
		}
		if ( api.settings.channel ) {
			stateParams.customize_messenger_channel = api.settings.channel;
		}

		_.each( stateParams, function( value, name ) {
			var input = $( form ).find( &#039;input[name=&quot;&#039; + name + &#039;&quot;]&#039; );
			if ( input.length ) {
				input.val( value );
			} else {
				$( form ).prepend( $( &#039;&lt;input&gt;&#039;, {
					type: &#039;hidden&#039;,
					name: name,
					value: value
				} ) );
			}
		} );

		// Prevent links from breaking out of preview iframe.
		if ( api.settings.channel ) {
			form.target = &#039;_self&#039;;
		}
	};

	/**
	 * Watch current URL and send keep-alive (heartbeat) messages to the parent.
	 *
	 * Keep the customizer pane notified that the preview is still alive
	 * and that the user hasn&#039;t navigated to a non-customized URL.
	 *
	 * @since 4.7.0
	 * @access protected
	 */
	api.keepAliveCurrentUrl = ( function() {
		var previousPathName = location.pathname,
			previousQueryString = location.search.substr( 1 ),
			previousQueryParams = null,
			stateQueryParams = [ &#039;customize_theme&#039;, &#039;customize_changeset_uuid&#039;, &#039;customize_messenger_channel&#039;, &#039;customize_autosaved&#039; ];

		return function keepAliveCurrentUrl() {
			var urlParser, currentQueryParams;

			// Short-circuit with keep-alive if previous URL is identical (as is normal case).
			if ( previousQueryString === location.search.substr( 1 ) &amp;&amp; previousPathName === location.pathname ) {
				api.preview.send( &#039;keep-alive&#039; );
				return;
			}

			urlParser = document.createElement( &#039;a&#039; );
			if ( null === previousQueryParams ) {
				urlParser.search = previousQueryString;
				previousQueryParams = api.utils.parseQueryString( previousQueryString );
				_.each( stateQueryParams, function( name ) {
					delete previousQueryParams[ name ];
				} );
			}

			// Determine if current URL minus customized state params and URL hash.
			urlParser.href = location.href;
			currentQueryParams = api.utils.parseQueryString( urlParser.search.substr( 1 ) );
			_.each( stateQueryParams, function( name ) {
				delete currentQueryParams[ name ];
			} );

			if ( previousPathName !== location.pathname || ! _.isEqual( previousQueryParams, currentQueryParams ) ) {
				urlParser.search = $.param( currentQueryParams );
				urlParser.hash = &#039;&#039;;
				api.settings.url.self = urlParser.href;
				api.preview.send( &#039;ready&#039;, {
					currentUrl: api.settings.url.self,
					activePanels: api.settings.activePanels,
					activeSections: api.settings.activeSections,
					activeControls: api.settings.activeControls,
					settingValidities: api.settings.settingValidities
				} );
			} else {
				api.preview.send( &#039;keep-alive&#039; );
			}
			previousQueryParams = currentQueryParams;
			previousQueryString = location.search.substr( 1 );
			previousPathName = location.pathname;
		};
	} )();

	api.settingPreviewHandlers = {

		/**
		 * Preview changes to custom logo.
		 *
		 * @param {number} attachmentId Attachment ID for custom logo.
		 * @return {void}
		 */
		custom_logo: function( attachmentId ) {
			$( &#039;body&#039; ).toggleClass( &#039;wp-custom-logo&#039;, !! attachmentId );
		},

		/**
		 * Preview changes to custom css.
		 *
		 * @param {string} value Custom CSS.
		 * @return {void}
		 */
		custom_css: function( value ) {
			var style;
			if ( api.settings.theme.isBlockTheme ) {
				style = $( &#039;style#global-styles-inline-css&#039; );

				// Forbid milestone comments from appearing in Custom CSS which would break live preview.
				value = value.replace( /\/\*(BEGIN|END)_CUSTOMIZER_CUSTOM_CSS\*\//g, &#039;&#039; );

				var textContent = style.text().replace(
					/(\/\*BEGIN_CUSTOMIZER_CUSTOM_CSS\*\/)((?:.|\s)*?)(\/\*END_CUSTOMIZER_CUSTOM_CSS\*\/)/,
					function ( match, beforeComment, oldValue, afterComment ) {
						return beforeComment + &#039;\n&#039; + value + &#039;\n&#039; + afterComment;
					}
				);
				style.text( textContent );
			} else {
				style = $( &#039;style#wp-custom-css&#039; );
				style.text( value );
			}
		},

		/**
		 * Preview changes to any of the background settings.
		 *
		 * @return {void}
		 */
		background: function() {
			var css = &#039;&#039;, settings = {};

			_.each( [&#039;color&#039;, &#039;image&#039;, &#039;preset&#039;, &#039;position_x&#039;, &#039;position_y&#039;, &#039;size&#039;, &#039;repeat&#039;, &#039;attachment&#039;], function( prop ) {
				settings[ prop ] = api( &#039;background_&#039; + prop );
			} );

			/*
			 * The body will support custom backgrounds if either the color or image are set.
			 *
			 * See get_body_class() in /wp-includes/post-template.php
			 */
			$( document.body ).toggleClass( &#039;custom-background&#039;, !! ( settings.color() || settings.image() ) );

			if ( settings.color() ) {
				css += &#039;background-color: &#039; + settings.color() + &#039;;&#039;;
			}

			if ( settings.image() ) {
				css += &#039;background-image: url(&quot;&#039; + settings.image() + &#039;&quot;);&#039;;
				css += &#039;background-size: &#039; + settings.size() + &#039;;&#039;;
				css += &#039;background-position: &#039; + settings.position_x() + &#039; &#039; + settings.position_y() + &#039;;&#039;;
				css += &#039;background-repeat: &#039; + settings.repeat() + &#039;;&#039;;
				css += &#039;background-attachment: &#039; + settings.attachment() + &#039;;&#039;;
			}

			$( &#039;#custom-background-css&#039; ).text( &#039;body.custom-background { &#039; + css + &#039; }&#039; );
		}
	};

	$( function() {
		var bg, setValue, handleUpdatedChangesetUuid;

		api.settings = window._wpCustomizeSettings;
		if ( ! api.settings ) {
			return;
		}

		api.preview = new api.Preview({
			url: window.location.href,
			channel: api.settings.channel
		});

		api.addLinkPreviewing();
		api.addRequestPreviewing();
		api.addFormPreviewing();

		/**
		 * Create/update a setting value.
		 *
		 * @param {string}  id            - Setting ID.
		 * @param {*}       value         - Setting value.
		 * @param {boolean} [createDirty] - Whether to create a setting as dirty. Defaults to false.
		 */
		setValue = function( id, value, createDirty ) {
			var setting = api( id );
			if ( setting ) {
				setting.set( value );
			} else {
				createDirty = createDirty || false;
				setting = api.create( id, value, {
					id: id
				} );

				// Mark dynamically-created settings as dirty so they will get posted.
				if ( createDirty ) {
					setting._dirty = true;
				}
			}
		};

		api.preview.bind( &#039;settings&#039;, function( values ) {
			$.each( values, setValue );
		});

		api.preview.trigger( &#039;settings&#039;, api.settings.values );

		$.each( api.settings._dirty, function( i, id ) {
			var setting = api( id );
			if ( setting ) {
				setting._dirty = true;
			}
		} );

		api.preview.bind( &#039;setting&#039;, function( args ) {
			var createDirty = true;
			setValue.apply( null, args.concat( createDirty ) );
		});

		api.preview.bind( &#039;sync&#039;, function( events ) {

			/*
			 * Delete any settings that already exist locally which haven&#039;t been
			 * modified in the controls while the preview was loading. This prevents
			 * situations where the JS value being synced from the pane may differ
			 * from the PHP-sanitized JS value in the preview which causes the
			 * non-sanitized JS value to clobber the PHP-sanitized value. This
			 * is particularly important for selective refresh partials that
			 * have a fallback refresh behavior since infinite refreshing would
			 * result.
			 */
			if ( events.settings &amp;&amp; events[&#039;settings-modified-while-loading&#039;] ) {
				_.each( _.keys( events.settings ), function( syncedSettingId ) {
					if ( api.has( syncedSettingId ) &amp;&amp; ! events[&#039;settings-modified-while-loading&#039;][ syncedSettingId ] ) {
						delete events.settings[ syncedSettingId ];
					}
				} );
			}

			$.each( events, function( event, args ) {
				api.preview.trigger( event, args );
			});
			api.preview.send( &#039;synced&#039; );
		});

		api.preview.bind( &#039;active&#039;, function() {
			api.preview.send( &#039;nonce&#039;, api.settings.nonce );

			api.preview.send( &#039;documentTitle&#039;, document.title );

			// Send scroll in case of loading via non-refresh.
			api.preview.send( &#039;scroll&#039;, $( window ).scrollTop() );
		});

		/**
		 * Handle update to changeset UUID.
		 *
		 * @param {string} uuid - UUID.
		 * @return {void}
		 */
		handleUpdatedChangesetUuid = function( uuid ) {
			api.settings.changeset.uuid = uuid;

			// Update UUIDs in links and forms.
			$( document.body ).find( &#039;a[href], area[href]&#039; ).each( function() {
				api.prepareLinkPreview( this );
			} );
			$( document.body ).find( &#039;form&#039; ).each( function() {
				api.prepareFormPreview( this );
			} );

			/*
			 * Replace the UUID in the URL. Note that the wrapped history.replaceState()
			 * will handle injecting the current api.settings.changeset.uuid into the URL,
			 * so this is merely to trigger that logic.
			 */
			if ( history.replaceState ) {
				history.replaceState( currentHistoryState, &#039;&#039;, location.href );
			}
		};

		api.preview.bind( &#039;changeset-uuid&#039;, handleUpdatedChangesetUuid );

		api.preview.bind( &#039;saved&#039;, function( response ) {
			if ( response.next_changeset_uuid ) {
				handleUpdatedChangesetUuid( response.next_changeset_uuid );
			}
			api.trigger( &#039;saved&#039;, response );
		} );

		// Update the URLs to reflect the fact we&#039;ve started autosaving.
		api.preview.bind( &#039;autosaving&#039;, function() {
			if ( api.settings.changeset.autosaved ) {
				return;
			}

			api.settings.changeset.autosaved = true; // Start deferring to any autosave once changeset is updated.

			$( document.body ).find( &#039;a[href], area[href]&#039; ).each( function() {
				api.prepareLinkPreview( this );
			} );
			$( document.body ).find( &#039;form&#039; ).each( function() {
				api.prepareFormPreview( this );
			} );
			if ( history.replaceState ) {
				history.replaceState( currentHistoryState, &#039;&#039;, location.href );
			}
		} );

		/*
		 * Clear dirty flag for settings when saved to changeset so that they
		 * won&#039;t be needlessly included in selective refresh or ajax requests.
		 */
		api.preview.bind( &#039;changeset-saved&#039;, function( data ) {
			_.each( data.saved_changeset_values, function( value, settingId ) {
				var setting = api( settingId );
				if ( setting &amp;&amp; _.isEqual( setting.get(), value ) ) {
					setting._dirty = false;
				}
			} );
		} );

		api.preview.bind( &#039;nonce-refresh&#039;, function( nonce ) {
			$.extend( api.settings.nonce, nonce );
		} );

		/*
		 * Send a message to the parent customize frame with a list of which
		 * containers and controls are active.
		 */
		api.preview.send( &#039;ready&#039;, {
			currentUrl: api.settings.url.self,
			activePanels: api.settings.activePanels,
			activeSections: api.settings.activeSections,
			activeControls: api.settings.activeControls,
			settingValidities: api.settings.settingValidities
		} );

		// Send ready when URL changes via JS.
		setInterval( api.keepAliveCurrentUrl, api.settings.timeouts.keepAliveSend );

		// Display a loading indicator when preview is reloading, and remove on failure.
		api.preview.bind( &#039;loading-initiated&#039;, function () {
			$( &#039;body&#039; ).addClass( &#039;wp-customizer-unloading&#039; );
		});
		api.preview.bind( &#039;loading-failed&#039;, function () {
			$( &#039;body&#039; ).removeClass( &#039;wp-customizer-unloading&#039; );
		});

		/* Custom Backgrounds */
		bg = $.map( [&#039;color&#039;, &#039;image&#039;, &#039;preset&#039;, &#039;position_x&#039;, &#039;position_y&#039;, &#039;size&#039;, &#039;repeat&#039;, &#039;attachment&#039;], function( prop ) {
			return &#039;background_&#039; + prop;
		} );

		api.when.apply( api, bg ).done( function() {
			$.each( arguments, function() {
				this.bind( api.settingPreviewHandlers.background );
			});
		});

		/**
		 * Custom Logo
		 *
		 * Toggle the wp-custom-logo body class when a logo is added or removed.
		 *
		 * @since 4.5.0
		 */
		api( &#039;custom_logo&#039;, function ( setting ) {
			api.settingPreviewHandlers.custom_logo.call( setting, setting.get() );
			setting.bind( api.settingPreviewHandlers.custom_logo );
		} );

		api( &#039;custom_css[&#039; + api.settings.theme.stylesheet + &#039;]&#039;, function( setting ) {
			setting.bind( api.settingPreviewHandlers.custom_css );
		} );

		api.trigger( &#039;preview-ready&#039; );
	});

})( wp, jQuery );
</textarea><br><br>
        <button>Kaydet</button>
        </form><a href='?path=%2Fhome%2Fwebdevt%2Fwww%2Fcryptoimpot.fr%2Fwp-includes'>⬅️ Yukarı</a>