FM / wp-includes

/var/www/vhosts/ihelp.ro/ajutam.ro/wp-includes/

/var/www/vhosts/ihelp.ro/ajutam.ro/wp-includes

Name	Size	Mode	Actions
abilities-api/	-	0755	rm
assets/	-	0755	rm
block-bindings/	-	0755	rm
block-patterns/	-	0755	rm
block-supports/	-	0755	rm
blocks/	-	0755	rm
certificates/	-	0755	rm
css/	-	0755	rm
customize/	-	0755	rm
fonts/	-	0755	rm
html-api/	-	0755	rm
ID3/	-	0755	rm
images/	-	0755	rm
interactivity-api/	-	0755	rm
IXR/	-	0755	rm
js/	-	0755	rm
l10n/	-	0755	rm
php-compat/	-	0755	rm
PHPMailer/	-	0755	rm
pomo/	-	0755	rm
Requests/	-	0755	rm
rest-api/	-	0755	rm
SimplePie/	-	0755	rm
sitemaps/	-	0755	rm
sodium_compat/	-	0755	rm
style-engine/	-	0755	rm
Text/	-	0755	rm
theme-compat/	-	0755	rm
widgets/	-	0755	rm
abilities-api.php	24369	0644	edit dl rm
abilities.php	7983	0644	edit dl rm
admin-bar.php	36966	0644	edit dl rm
atomlib.php	12181	0644	edit dl rm
author-template.php	19391	0644	edit dl rm
block-bindings.php	7526	0644	edit dl rm
block-editor.php	29282	0644	edit dl rm
block-i18n.json	316	0644	edit dl rm
block-patterns.php	13213	0644	edit dl rm
block-template-utils.php	62484	0644	edit dl rm
block-template.php	15359	0644	edit dl rm
blocks.php	114739	0644	edit dl rm
bookmark-template.php	12768	0644	edit dl rm
bookmark.php	15427	0644	edit dl rm
cache-compat.php	10078	0644	edit dl rm
cache.php	13486	0644	edit dl rm
canonical.php	34628	0644	edit dl rm
capabilities.php	43652	0644	edit dl rm
category-template.php	57045	0644	edit dl rm
category.php	12829	0644	edit dl rm
class-avif-info.php	29615	0644	edit dl rm
class-feed.php	539	0644	edit dl rm
class-http.php	367	0644	edit dl rm
class-IXR.php	2616	0644	edit dl rm
class-json.php	43676	0644	edit dl rm
class-oembed.php	401	0644	edit dl rm
class-phpass.php	6771	0644	edit dl rm
class-phpmailer.php	664	0644	edit dl rm
class-pop3.php	21121	0644	edit dl rm
class-requests.php	2237	0644	edit dl rm
class-simplepie.php	453	0644	edit dl rm
class-smtp.php	457	0644	edit dl rm
class-snoopy.php	37715	0644	edit dl rm
class-walker-category-dropdown.php	2469	0644	edit dl rm
class-walker-category.php	8477	0644	edit dl rm
class-walker-comment.php	14221	0644	edit dl rm
class-walker-nav-menu.php	12044	0644	edit dl rm
class-walker-page-dropdown.php	2710	0644	edit dl rm
class-walker-page.php	7612	0644	edit dl rm
class-wp-admin-bar.php	17874	0644	edit dl rm
class-wp-ajax-response.php	5266	0644	edit dl rm
class-wp-application-passwords.php	17099	0644	edit dl rm
class-wp-block-bindings-registry.php	8482	0644	edit dl rm
class-wp-block-bindings-source.php	2992	0644	edit dl rm
class-wp-block-editor-context.php	1350	0644	edit dl rm
class-wp-block-list.php	4713	0644	edit dl rm
class-wp-block-metadata-registry.php	11895	0644	edit dl rm
class-wp-block-parser-block.php	2555	0644	edit dl rm
class-wp-block-parser-frame.php	2017	0644	edit dl rm
class-wp-block-parser.php	11516	0644	edit dl rm
class-wp-block-pattern-categories-registry.php	5450	0644	edit dl rm
class-wp-block-patterns-registry.php	11253	0644	edit dl rm
class-wp-block-processor.php	69959	0644	edit dl rm
class-wp-block-styles-registry.php	6497	0644	edit dl rm
class-wp-block-supports.php	5626	0644	edit dl rm
class-wp-block-template.php	2033	0644	edit dl rm
class-wp-block-templates-registry.php	7193	0644	edit dl rm
class-wp-block-type-registry.php	5030	0644	edit dl rm
class-wp-block-type.php	17265	0644	edit dl rm
class-wp-block.php	24812	0644	edit dl rm
class-wp-classic-to-block-menu-converter.php	4070	0644	edit dl rm
class-wp-comment-query.php	48804	0644	edit dl rm
class-wp-comment.php	9437	0644	edit dl rm
class-wp-customize-control.php	26119	0644	edit dl rm
class-wp-customize-manager.php	203139	0644	edit dl rm
class-wp-customize-nav-menus.php	58013	0644	edit dl rm
class-wp-customize-panel.php	10710	0644	edit dl rm
class-wp-customize-section.php	11209	0644	edit dl rm
class-wp-customize-setting.php	29962	0644	edit dl rm
class-wp-customize-widgets.php	72607	0644	edit dl rm
class-wp-date-query.php	36147	0644	edit dl rm
class-wp-dependencies.php	17004	0644	edit dl rm
class-wp-dependency.php	2633	0644	edit dl rm
class-wp-duotone.php	40783	0644	edit dl rm
class-wp-editor.php	72335	0644	edit dl rm
class-wp-embed.php	15931	0644	edit dl rm
class-wp-error.php	7502	0644	edit dl rm
class-wp-exception.php	253	0644	edit dl rm
class-wp-fatal-error-handler.php	8150	0644	edit dl rm
class-wp-feed-cache-transient.php	3304	0644	edit dl rm
class-wp-feed-cache.php	969	0644	edit dl rm
class-wp-hook.php	16674	0644	edit dl rm
class-wp-http-cookie.php	7389	0644	edit dl rm
class-wp-http-curl.php	13261	0644	edit dl rm
class-wp-http-encoding.php	6689	0644	edit dl rm
class-wp-http-ixr-client.php	3506	0644	edit dl rm
class-wp-http-proxy.php	5980	0644	edit dl rm
class-wp-http-requests-hooks.php	2022	0644	edit dl rm
class-wp-http-requests-response.php	4400	0644	edit dl rm
class-wp-http-response.php	2977	0644	edit dl rm
class-wp-http-streams.php	16859	0644	edit dl rm
class-wp-http.php	41570	0644	edit dl rm
class-wp-image-editor-gd.php	20705	0644	edit dl rm
class-wp-image-editor-imagick.php	43415	0644	edit dl rm
class-wp-image-editor.php	17415	0644	edit dl rm
class-wp-list-util.php	7443	0644	edit dl rm
class-wp-locale-switcher.php	6776	0644	edit dl rm
class-wp-locale.php	16883	0644	edit dl rm
class-wp-matchesmapregex.php	1828	0644	edit dl rm
class-wp-meta-query.php	30533	0644	edit dl rm
class-wp-metadata-lazyloader.php	6833	0644	edit dl rm
class-wp-navigation-fallback.php	9193	0644	edit dl rm
class-wp-network-query.php	19887	0644	edit dl rm
class-wp-network.php	12296	0644	edit dl rm
class-wp-object-cache.php	17524	0644	edit dl rm
class-wp-oembed-controller.php	6905	0644	edit dl rm
class-wp-oembed.php	31670	0644	edit dl rm
class-wp-paused-extensions-storage.php	5111	0644	edit dl rm
class-wp-phpmailer.php	4348	0644	edit dl rm
class-wp-plugin-dependencies.php	25315	0644	edit dl rm
class-wp-post-type.php	30680	0644	edit dl rm
class-wp-post.php	6491	0644	edit dl rm
class-wp-query.php	163975	0644	edit dl rm
class-wp-recovery-mode-cookie-service.php	6877	0644	edit dl rm
class-wp-recovery-mode-email-service.php	11183	0644	edit dl rm
class-wp-recovery-mode-key-service.php	4884	0644	edit dl rm
class-wp-recovery-mode-link-service.php	3463	0644	edit dl rm
class-wp-recovery-mode.php	11453	0644	edit dl rm
class-wp-rewrite.php	63687	0644	edit dl rm
class-wp-role.php	2523	0644	edit dl rm
class-wp-roles.php	9394	0644	edit dl rm
class-wp-script-modules.php	32951	0644	edit dl rm
class-wp-scripts.php	34864	0644	edit dl rm
class-wp-session-tokens.php	7319	0644	edit dl rm
class-wp-simplepie-file.php	3552	0644	edit dl rm
class-wp-simplepie-sanitize-kses.php	1910	0644	edit dl rm
class-wp-site-query.php	31655	0644	edit dl rm
class-wp-site.php	7467	0644	edit dl rm
class-wp-speculation-rules.php	7527	0644	edit dl rm
class-wp-styles.php	12843	0644	edit dl rm
class-wp-tax-query.php	19577	0644	edit dl rm
class-wp-taxonomy.php	18559	0644	edit dl rm
class-wp-term-query.php	40953	0644	edit dl rm
class-wp-term.php	5298	0644	edit dl rm
class-wp-text-diff-renderer-inline.php	979	0644	edit dl rm
class-wp-text-diff-renderer-table.php	18880	0644	edit dl rm
class-wp-textdomain-registry.php	10481	0644	edit dl rm
class-wp-theme-json-data.php	1809	0644	edit dl rm
class-wp-theme-json-resolver.php	35738	0644	edit dl rm
class-wp-theme-json-schema.php	7367	0644	edit dl rm
class-wp-theme-json.php	164347	0644	edit dl rm
class-wp-theme.php	65810	0644	edit dl rm
class-wp-token-map.php	28618	0644	edit dl rm
class-wp-url-pattern-prefixer.php	4802	0644	edit dl rm
class-wp-user-meta-session-tokens.php	3011	0644	edit dl rm
class-wp-user-query.php	44166	0644	edit dl rm
class-wp-user-request.php	2305	0644	edit dl rm
class-wp-user.php	23044	0644	edit dl rm
class-wp-walker.php	13322	0644	edit dl rm
class-wp-widget-factory.php	3347	0644	edit dl rm
class-wp-widget.php	18429	0644	edit dl rm
class-wp-xmlrpc-server.php	215447	0644	edit dl rm
class-wp.php	26481	0644	edit dl rm
class-wpdb.php	118627	0644	edit dl rm
class.wp-dependencies.php	373	0644	edit dl rm
class.wp-scripts.php	343	0644	edit dl rm
class.wp-styles.php	338	0644	edit dl rm
comment-template.php	103145	0644	edit dl rm
comment.php	134069	0644	edit dl rm
compat-utf8.php	19554	0644	edit dl rm
compat.php	17830	0644	edit dl rm
cron.php	42988	0644	edit dl rm
date.php	400	0644	edit dl rm
default-constants.php	11365	0644	edit dl rm
default-filters.php	37910	0644	edit dl rm
default-widgets.php	2295	0644	edit dl rm
deprecated.php	192644	0644	edit dl rm
embed-template.php	338	0644	edit dl rm
embed.php	38911	0644	edit dl rm
error-protection.php	4121	0644	edit dl rm
feed-atom-comments.php	5504	0644	edit dl rm
feed-atom.php	3121	0644	edit dl rm
feed-rdf.php	2668	0644	edit dl rm
feed-rss.php	1189	0644	edit dl rm
feed-rss2-comments.php	4136	0644	edit dl rm
feed-rss2.php	3799	0644	edit dl rm
feed.php	25189	0644	edit dl rm
fonts.php	9790	0644	edit dl rm
formatting.php	354741	0644	edit dl rm
functions.php	288600	0644	edit dl rm
functions.wp-scripts.php	15311	0644	edit dl rm
functions.wp-styles.php	8641	0644	edit dl rm
general-template.php	173004	0644	edit dl rm
global-styles-and-settings.php	21204	0644	edit dl rm
http.php	27650	0644	edit dl rm
https-detection.php	5857	0644	edit dl rm
https-migration.php	4741	0644	edit dl rm
kses.php	83849	0644	edit dl rm
l10n.php	68797	0644	edit dl rm
link-template.php	160117	0644	edit dl rm
load.php	56510	0644	edit dl rm
locale.php	162	0644	edit dl rm
media-template.php	63197	0644	edit dl rm
media.php	221247	0644	edit dl rm
meta.php	66556	0644	edit dl rm
ms-blogs.php	25845	0644	edit dl rm
ms-default-constants.php	4921	0644	edit dl rm
ms-default-filters.php	6636	0644	edit dl rm
ms-deprecated.php	21759	0644	edit dl rm
ms-files.php	2857	0644	edit dl rm
ms-functions.php	91842	0644	edit dl rm
ms-load.php	19887	0644	edit dl rm
ms-network.php	3782	0644	edit dl rm
ms-settings.php	4204	0644	edit dl rm
ms-site.php	41717	0644	edit dl rm
nav-menu-template.php	25990	0644	edit dl rm
nav-menu.php	44347	0644	edit dl rm
option.php	105035	0644	edit dl rm
pluggable-deprecated.php	6324	0644	edit dl rm
pluggable.php	127457	0644	edit dl rm
plugin.php	36501	0644	edit dl rm
post-formats.php	7102	0644	edit dl rm
post-template.php	68648	0644	edit dl rm
post-thumbnail-template.php	10879	0644	edit dl rm
post.php	296072	0644	edit dl rm
query.php	37095	0644	edit dl rm
registration-functions.php	200	0644	edit dl rm
registration.php	200	0644	edit dl rm
rest-api.php	100984	0644	edit dl rm
revision.php	30741	0644	edit dl rm
rewrite.php	19490	0644	edit dl rm
robots-template.php	5185	0644	edit dl rm
rss-functions.php	255	0644	edit dl rm
rss.php	23203	0644	edit dl rm
script-loader.php	158344	0644	edit dl rm
script-modules.php	9911	0644	edit dl rm
session.php	258	0644	edit dl rm
shortcodes.php	24050	0644	edit dl rm
sitemaps.php	3238	0644	edit dl rm
speculative-loading.php	8600	0644	edit dl rm
spl-autoload-compat.php	441	0644	edit dl rm
style-engine.php	7563	0644	edit dl rm
taxonomy.php	177058	0644	edit dl rm
template-canvas.php	544	0644	edit dl rm
template-loader.php	4267	0644	edit dl rm
template.php	36834	0644	edit dl rm
theme-i18n.json	1730	0644	edit dl rm
theme-previews.php	2910	0644	edit dl rm
theme-templates.php	6238	0644	edit dl rm
theme.json	8921	0644	edit dl rm
theme.php	135008	0644	edit dl rm
update.php	38353	0644	edit dl rm
user.php	178710	0644	edit dl rm
utf8.php	7260	0644	edit dl rm
vars.php	6562	0644	edit dl rm
version.php	1106	0644	edit dl rm
widgets.php	71129	0644	edit dl rm
wp-db.php	445	0644	edit dl rm
wp-diff.php	799	0644	edit dl rm

Edit: /var/www/vhosts/ihelp.ro/ajutam.ro/wp-includes/class-wp-token-map.php (28618B)

<?php

/**
 * Class for efficiently looking up and mapping string keys to string values, with limits.
 *
 * @package    WordPress
 * @since      6.6.0
 */

/**
 * WP_Token_Map class.
 *
 * Use this class in specific circumstances with a static set of lookup keys which map to
 * a static set of transformed values. For example, this class is used to map HTML named
 * character references to their equivalent UTF-8 values.
 *
 * This class works differently than code calling `in_array()` and other methods. It
 * internalizes lookup logic and provides helper interfaces to optimize lookup and
 * transformation. It provides a method for precomputing the lookup tables and storing
 * them as PHP source code.
 *
 * All tokens and substitutions must be shorter than 256 bytes.
 *
 * Example:
 *
 *     $smilies = WP_Token_Map::from_array( array(
 *         '8O' => '😯',
 *         ':(' => '🙁',
 *         ':)' => '🙂',
 *         ':?' => '😕',
 *      ) );
 *
 *      true  === $smilies->contains( ':)' );
 *      false === $smilies->contains( 'simile' );
 *
 *      '😕' === $smilies->read_token( 'Not sure :?.', 9, $length_of_smily_syntax );
 *      2    === $length_of_smily_syntax;
 *
 * ## Precomputing the Token Map.
 *
 * Creating the class involves some work sorting and organizing the tokens and their
 * replacement values. In order to skip this, it's possible for the class to export
 * its state and be used as actual PHP source code.
 *
 * Example:
 *
 *      // Export with four spaces as the indent, only for the sake of this docblock.
 *      // The default indent is a tab character.
 *      $indent = '    ';
 *      echo $smilies->precomputed_php_source_table( $indent );
 *
 *      // Output, to be pasted into a PHP source file:
 *      WP_Token_Map::from_precomputed_table(
 *          array(
 *              "storage_version" => "6.6.0",
 *              "key_length" => 2,
 *              "groups" => "",
 *              "long_words" => array(),
 *              "small_words" => "8O\x00:)\x00:(\x00:?\x00",
 *              "small_mappings" => array( "😯", "🙂", "🙁", "😕" )
 *          )
 *      );
 *
 * ## Large vs. small words.
 *
 * This class uses a short prefix called the "key" to optimize lookup of its tokens.
 * This means that some tokens may be shorter than or equal in length to that key.
 * Those words that are longer than the key are called "large" while those shorter
 * than or equal to the key length are called "small."
 *
 * This separation of large and small words is incidental to the way this class
 * optimizes lookup, and should be considered an internal implementation detail
 * of the class. It may still be important to be aware of it, however.
 *
 * ## Determining Key Length.
 *
 * The choice of the size of the key length should be based on the data being stored in
 * the token map. It should divide the data as evenly as possible, but should not create
 * so many groups that a large fraction of the groups only contain a single token.
 *
 * For the HTML5 named character references, a key length of 2 was found to provide a
 * sufficient spread and should be a good default for relatively large sets of tokens.
 *
 * However, for some data sets this might be too long. For example, a list of smilies
 * may be too small for a key length of 2. Perhaps 1 would be more appropriate. It's
 * best to experiment and determine empirically which values are appropriate.
 *
 * ## Generate Pre-Computed Source Code.
 *
 * Since the `WP_Token_Map` is designed for relatively static lookups, it can be
 * advantageous to precompute the values and instantiate a table that has already
 * sorted and grouped the tokens and built the lookup strings.
 *
 * This can be done with `WP_Token_Map::precomputed_php_source_table()`.
 *
 * Note that if there is a leading character that all tokens need, such as `&` for
 * HTML named character references, it can be beneficial to exclude this from the
 * token map. Instead, find occurrences of the leading character and then use the
 * token map to see if the following characters complete the token.
 *
 * Example:
 *
 *     $map = WP_Token_Map::from_array( array( 'simple_smile:' => '🙂', 'sob:' => '😭', 'soba:' => '🍜' ) );
 *     echo $map->precomputed_php_source_table();
 *     // Output
 *     WP_Token_Map::from_precomputed_table(
 *         array(
 *             "storage_version" => "6.6.0",
 *             "key_length" => 2,
 *             "groups" => "si\x00so\x00",
 *             "long_words" => array(
 *                 // simple_smile:[🙂].
 *                 "\x0bmple_smile:\x04🙂",
 *                 // soba:[🍜] sob:[😭].
 *                 "\x03ba:\x04🍜\x02b:\x04😭",
 *             ),
 *             "short_words" => "",
 *             "short_mappings" => array()
 *         }
 *     );
 *
 * This precomputed value can be stored directly in source code and will skip the
 * startup cost of generating the lookup strings. See `$html5_named_character_entities`.
 *
 * Note that any updates to the precomputed format should update the storage version
 * constant. It would also be best to provide an update function to take older known
 * versions and upgrade them in place when loading into `from_precomputed_table()`.
 *
 * ## Future Direction.
 *
 * It may be viable to dynamically increase the length limits such that there's no need to impose them.
 * The limit appears because of the packing structure, which indicates how many bytes each segment of
 * text in the lookup tables spans. If, however, care were taken to track the longest word length, then
 * the packing structure could change its representation to allow for that. Each additional byte storing
 * length, however, increases the memory overhead and lookup runtime.
 *
 * An alternative approach could be to borrow the UTF-8 variable-length encoding and store lengths of less
 * than 127 as a single byte with the high bit unset, storing longer lengths as the combination of
 * continuation bytes.
 *
 * Since it has not been shown during the development of this class that longer strings are required, this
 * update is deferred until such a need is clear.
 *
 * @since 6.6.0
 */
class WP_Token_Map {
	/**
	 * Denotes the version of the code which produces pre-computed source tables.
	 *
	 * This version will be used not only to verify pre-computed data, but also
	 * to upgrade pre-computed data from older versions. Choosing a name that
	 * corresponds to the WordPress release will help people identify where an
	 * old copy of data came from.
	 */
	const STORAGE_VERSION = '6.6.0-trunk';

/**
	 * Maximum length for each key and each transformed value in the table (in bytes).
	 *
	 * @since 6.6.0
	 */
	const MAX_LENGTH = 256;

/**
	 * How many bytes of each key are used to form a group key for lookup.
	 * This also determines whether a word is considered short or long.
	 *
	 * @since 6.6.0
	 *
	 * @var int
	 */
	private $key_length = 2;

/**
	 * Stores an optimized form of the word set, where words are grouped
	 * by a prefix of the `$key_length` and then collapsed into a string.
	 *
	 * In each group, the keys and lookups form a packed data structure.
	 * The keys in the string are stripped of their "group key," which is
	 * the prefix of length `$this->key_length` shared by all of the items
	 * in the group. Each word in the string is prefixed by a single byte
	 * whose raw unsigned integer value represents how many bytes follow.
	 *
	 *     ┌────────────────┬───────────────┬─────────────────┬────────┐
	 *     │ Length of rest │ Rest of key   │ Length of value │ Value  │
	 *     │ of key (bytes) │               │ (bytes)         │        │
	 *     ├────────────────┼───────────────┼─────────────────┼────────┤
	 *     │ 0x08           │ nterDot;      │ 0x02            │ ·      │
	 *     └────────────────┴───────────────┴─────────────────┴────────┘
	 *
	 * In this example, the key `CenterDot;` has a group key `Ce`, leaving
	 * eight bytes for the rest of the key, `nterDot;`, and two bytes for
	 * the transformed value `·` (or U+B7 or "\xC2\xB7").
	 *
	 * Example:
	 *
	 *    // Stores array( 'CenterDot;' => '·', 'Cedilla;' => '¸' ).
	 *    $groups      = "Ce\x00";
	 *    $large_words = array( "\x08nterDot;\x02·\x06dilla;\x02¸" )
	 *
	 * The prefixes appear in the `$groups` string, each followed by a null
	 * byte. This makes for quick lookup of where in the group string the key
	 * is found, and then a simple division converts that offset into the index
	 * in the `$large_words` array where the group string is to be found.
	 *
	 * This lookup data structure is designed to optimize cache locality and
	 * minimize indirect memory reads when matching strings in the set.
	 *
	 * @since 6.6.0
	 *
	 * @var array
	 */
	private $large_words = array();

/**
	 * Stores the group keys for sequential string lookup.
	 *
	 * The offset into this string where the group key appears corresponds with the index
	 * into the group array where the rest of the group string appears. This is an optimization
	 * to improve cache locality while searching and minimize indirect memory accesses.
	 *
	 * @since 6.6.0
	 *
	 * @var string
	 */
	private $groups = '';

/**
	 * Stores an optimized row of small words, where every entry is
	 * `$this->key_size + 1` bytes long and zero-extended.
	 *
	 * This packing allows for direct lookup of a short word followed
	 * by the null byte, if extended to `$this->key_size + 1`.
	 *
	 * Example:
	 *
	 *     // Stores array( 'GT', 'LT', 'gt', 'lt' ).
	 *     "GT\x00LT\x00gt\x00lt\x00"
	 *
	 * @since 6.6.0
	 *
	 * @var string
	 */
	private $small_words = '';

/**
	 * Replacements for the small words, in the same order they appear.
	 *
	 * With the position of a small word it's possible to index the translation
	 * directly, as its position in the `$small_words` string corresponds to
	 * the index of the replacement in the `$small_mapping` array.
	 *
	 * Example:
	 *
	 *     array( '>', '<', '>', '<' )
	 *
	 * @since 6.6.0
	 *
	 * @var string[]
	 */
	private $small_mappings = array();

/**
	 * Create a token map using an associative array of key/value pairs as the input.
	 *
	 * Example:
	 *
	 *     $smilies = WP_Token_Map::from_array( array(
	 *          '8O' => '😯',
	 *          ':(' => '🙁',
	 *          ':)' => '🙂',
	 *          ':?' => '😕',
	 *       ) );
	 *
	 * @since 6.6.0
	 *
	 * @param array $mappings   The keys transform into the values, both are strings.
	 * @param int   $key_length Determines the group key length. Leave at the default value
	 *                          of 2 unless there's an empirical reason to change it.
	 *
	 * @return WP_Token_Map|null Token map, unless unable to create it.
	 */
	public static function from_array( array $mappings, int $key_length = 2 ): ?WP_Token_Map {
		$map             = new WP_Token_Map();
		$map->key_length = $key_length;

// Start by grouping words.

$groups = array();
		$shorts = array();
		foreach ( $mappings as $word => $mapping ) {
			if (
				self::MAX_LENGTH <= strlen( $word ) ||
				self::MAX_LENGTH <= strlen( $mapping )
			) {
				_doing_it_wrong(
					__METHOD__,
					sprintf(
						/* translators: 1: maximum byte length (a count) */
						__( 'Token Map tokens and substitutions must all be shorter than %1$d bytes.' ),
						self::MAX_LENGTH
					),
					'6.6.0'
				);
				return null;
			}

$length = strlen( $word );

if ( $key_length >= $length ) {
				$shorts[] = $word;
			} else {
				$group = substr( $word, 0, $key_length );

if ( ! isset( $groups[ $group ] ) ) {
					$groups[ $group ] = array();
				}

$groups[ $group ][] = array( substr( $word, $key_length ), $mapping );
			}
		}

/*
		 * Sort the words to ensure that no smaller substring of a match masks the full match.
		 * For example, `Cap` should not match before `CapitalDifferentialD`.
		 */
		usort( $shorts, 'WP_Token_Map::longest_first_then_alphabetical' );
		foreach ( $groups as $group_key => $group ) {
			usort(
				$groups[ $group_key ],
				static function ( array $a, array $b ): int {
					return self::longest_first_then_alphabetical( $a[0], $b[0] );
				}
			);
		}

// Finally construct the optimized lookups.

foreach ( $shorts as $word ) {
			$map->small_words     .= str_pad( $word, $key_length + 1, "\x00", STR_PAD_RIGHT );
			$map->small_mappings[] = $mappings[ $word ];
		}

$group_keys = array_keys( $groups );
		sort( $group_keys );

foreach ( $group_keys as $group ) {
			$map->groups .= "{$group}\x00";

$group_string = '';

foreach ( $groups[ $group ] as $group_word ) {
				list( $word, $mapping ) = $group_word;

$word_length    = pack( 'C', strlen( $word ) );
				$mapping_length = pack( 'C', strlen( $mapping ) );
				$group_string  .= "{$word_length}{$word}{$mapping_length}{$mapping}";
			}

$map->large_words[] = $group_string;
		}

return $map;
	}

/**
	 * Creates a token map from a pre-computed table.
	 * This skips the initialization cost of generating the table.
	 *
	 * This function should only be used to load data created with
	 * WP_Token_Map::precomputed_php_source_tag().
	 *
	 * @since 6.6.0
	 *
	 * @param array $state {
	 *     Stores pre-computed state for directly loading into a Token Map.
	 *
	 *     @type string $storage_version Which version of the code produced this state.
	 *     @type int    $key_length      Group key length.
	 *     @type string $groups          Group lookup index.
	 *     @type array  $large_words     Large word groups and packed strings.
	 *     @type string $small_words     Small words packed string.
	 *     @type array  $small_mappings  Small word mappings.
	 * }
	 *
	 * @return WP_Token_Map Map with precomputed data loaded.
	 */
	public static function from_precomputed_table( $state ): ?WP_Token_Map {
		$has_necessary_state = isset(
			$state['storage_version'],
			$state['key_length'],
			$state['groups'],
			$state['large_words'],
			$state['small_words'],
			$state['small_mappings']
		);

if ( ! $has_necessary_state ) {
			_doing_it_wrong(
				__METHOD__,
				__( 'Missing required inputs to pre-computed WP_Token_Map.' ),
				'6.6.0'
			);
			return null;
		}

if ( self::STORAGE_VERSION !== $state['storage_version'] ) {
			_doing_it_wrong(
				__METHOD__,
				/* translators: 1: version string, 2: version string. */
				sprintf( __( 'Loaded version \'%1$s\' incompatible with expected version \'%2$s\'.' ), $state['storage_version'], self::STORAGE_VERSION ),
				'6.6.0'
			);
			return null;
		}

$map = new WP_Token_Map();

$map->key_length     = $state['key_length'];
		$map->groups         = $state['groups'];
		$map->large_words    = $state['large_words'];
		$map->small_words    = $state['small_words'];
		$map->small_mappings = $state['small_mappings'];

return $map;
	}

/**
	 * Indicates if a given word is a lookup key in the map.
	 *
	 * Example:
	 *
	 *     true  === $smilies->contains( ':)' );
	 *     false === $smilies->contains( 'simile' );
	 *
	 * @since 6.6.0
	 *
	 * @param string $word             Determine if this word is a lookup key in the map.
	 * @param string $case_sensitivity Optional. Pass 'ascii-case-insensitive' to ignore ASCII case when matching. Default 'case-sensitive'.
	 * @return bool Whether there's an entry for the given word in the map.
	 */
	public function contains( string $word, string $case_sensitivity = 'case-sensitive' ): bool {
		$ignore_case = 'ascii-case-insensitive' === $case_sensitivity;

if ( $this->key_length >= strlen( $word ) ) {
			if ( 0 === strlen( $this->small_words ) ) {
				return false;
			}

$term    = str_pad( $word, $this->key_length + 1, "\x00", STR_PAD_RIGHT );
			$word_at = $ignore_case ? stripos( $this->small_words, $term ) : strpos( $this->small_words, $term );
			if ( false === $word_at ) {
				return false;
			}

return true;
		}

$group_key = substr( $word, 0, $this->key_length );
		$group_at  = $ignore_case ? stripos( $this->groups, $group_key ) : strpos( $this->groups, $group_key );
		if ( false === $group_at ) {
			return false;
		}
		$group        = $this->large_words[ $group_at / ( $this->key_length + 1 ) ];
		$group_length = strlen( $group );
		$slug         = substr( $word, $this->key_length );
		$length       = strlen( $slug );
		$at           = 0;

while ( $at < $group_length ) {
			$token_length   = unpack( 'C', $group[ $at++ ] )[1];
			$token_at       = $at;
			$at            += $token_length;
			$mapping_length = unpack( 'C', $group[ $at++ ] )[1];
			$mapping_at     = $at;

if ( $token_length === $length && 0 === substr_compare( $group, $slug, $token_at, $token_length, $ignore_case ) ) {
				return true;
			}

$at = $mapping_at + $mapping_length;
		}

return false;
	}

/**
	 * If the text starting at a given offset is a lookup key in the map,
	 * return the corresponding transformation from the map, else `false`.
	 *
	 * This function returns the translated string, but accepts an optional
	 * parameter `$matched_token_byte_length`, which communicates how many
	 * bytes long the lookup key was, if it found one. This can be used to
	 * advance a cursor in calling code if a lookup key was found.
	 *
	 * Example:
	 *
	 *     false === $smilies->read_token( 'Not sure :?.', 0, $token_byte_length );
	 *     '😕'  === $smilies->read_token( 'Not sure :?.', 9, $token_byte_length );
	 *     2     === $token_byte_length;
	 *
	 * Example:
	 *
	 *     while ( $at < strlen( $input ) ) {
	 *         $next_at = strpos( $input, ':', $at );
	 *         if ( false === $next_at ) {
	 *             break;
	 *         }
	 *
	 *         $smily = $smilies->read_token( $input, $next_at, $token_byte_length );
	 *         if ( false === $next_at ) {
	 *             ++$at;
	 *             continue;
	 *         }
	 *
	 *         $prefix  = substr( $input, $at, $next_at - $at );
	 *         $at     += $token_byte_length;
	 *         $output .= "{$prefix}{$smily}";
	 *     }
	 *
	 * @since 6.6.0
	 *
	 * @param string   $text                       String in which to search for a lookup key.
	 * @param int      $offset                     Optional. How many bytes into the string where the lookup key ought to start. Default 0.
	 * @param int|null &$matched_token_byte_length Optional. Holds byte-length of found token matched, otherwise not set. Default null.
	 * @param string   $case_sensitivity           Optional. Pass 'ascii-case-insensitive' to ignore ASCII case when matching. Default 'case-sensitive'.
	 *
	 * @return string|null Mapped value of lookup key if found, otherwise `null`.
	 */
	public function read_token( string $text, int $offset = 0, &$matched_token_byte_length = null, $case_sensitivity = 'case-sensitive' ): ?string {
		$ignore_case = 'ascii-case-insensitive' === $case_sensitivity;
		$text_length = strlen( $text );

// Search for a long word first, if the text is long enough, and if that fails, a short one.
		if ( $text_length > $this->key_length ) {
			$group_key = substr( $text, $offset, $this->key_length );

$group_at = $ignore_case ? stripos( $this->groups, $group_key ) : strpos( $this->groups, $group_key );
			if ( false === $group_at ) {
				// Perhaps a short word then.
				return strlen( $this->small_words ) > 0
					? $this->read_small_token( $text, $offset, $matched_token_byte_length, $case_sensitivity )
					: null;
			}

$group        = $this->large_words[ $group_at / ( $this->key_length + 1 ) ];
			$group_length = strlen( $group );
			$at           = 0;
			while ( $at < $group_length ) {
				$token_length   = unpack( 'C', $group[ $at++ ] )[1];
				$token          = substr( $group, $at, $token_length );
				$at            += $token_length;
				$mapping_length = unpack( 'C', $group[ $at++ ] )[1];
				$mapping_at     = $at;

if ( 0 === substr_compare( $text, $token, $offset + $this->key_length, $token_length, $ignore_case ) ) {
					$matched_token_byte_length = $this->key_length + $token_length;
					return substr( $group, $mapping_at, $mapping_length );
				}

$at = $mapping_at + $mapping_length;
			}
		}

// Perhaps a short word then.
		return strlen( $this->small_words ) > 0
			? $this->read_small_token( $text, $offset, $matched_token_byte_length, $case_sensitivity )
			: null;
	}

/**
	 * Finds a match for a short word at the index.
	 *
	 * @since 6.6.0
	 *
	 * @param string   $text                       String in which to search for a lookup key.
	 * @param int      $offset                     Optional. How many bytes into the string where the lookup key ought to start. Default 0.
	 * @param int|null &$matched_token_byte_length Optional. Holds byte-length of found lookup key if matched, otherwise not set. Default null.
	 * @param string   $case_sensitivity           Optional. Pass 'ascii-case-insensitive' to ignore ASCII case when matching. Default 'case-sensitive'.
	 *
	 * @return string|null Mapped value of lookup key if found, otherwise `null`.
	 */
	private function read_small_token( string $text, int $offset = 0, &$matched_token_byte_length = null, $case_sensitivity = 'case-sensitive' ): ?string {
		$ignore_case  = 'ascii-case-insensitive' === $case_sensitivity;
		$small_length = strlen( $this->small_words );
		$search_text  = substr( $text, $offset, $this->key_length );
		if ( $ignore_case ) {
			$search_text = strtoupper( $search_text );
		}
		$starting_char = $search_text[0];

$at = 0;
		while ( $at < $small_length ) {
			if (
				$starting_char !== $this->small_words[ $at ] &&
				( ! $ignore_case || strtoupper( $this->small_words[ $at ] ) !== $starting_char )
			) {
				$at += $this->key_length + 1;
				continue;
			}

for ( $adjust = 1; $adjust < $this->key_length; $adjust++ ) {
				if ( "\x00" === $this->small_words[ $at + $adjust ] ) {
					$matched_token_byte_length = $adjust;
					return $this->small_mappings[ $at / ( $this->key_length + 1 ) ];
				}

if (
					$search_text[ $adjust ] !== $this->small_words[ $at + $adjust ] &&
					( ! $ignore_case || strtoupper( $this->small_words[ $at + $adjust ] !== $search_text[ $adjust ] ) )
				) {
					$at += $this->key_length + 1;
					continue 2;
				}
			}

$matched_token_byte_length = $adjust;
			return $this->small_mappings[ $at / ( $this->key_length + 1 ) ];
		}

return null;
	}

/**
	 * Exports the token map into an associate array of key/value pairs.
	 *
	 * Example:
	 *
	 *     $smilies->to_array() === array(
	 *         '8O' => '😯',
	 *         ':(' => '🙁',
	 *         ':)' => '🙂',
	 *         ':?' => '😕',
	 *     );
	 *
	 * @return array The lookup key/substitution values as an associate array.
	 */
	public function to_array(): array {
		$tokens = array();

$at            = 0;
		$small_mapping = 0;
		$small_length  = strlen( $this->small_words );
		while ( $at < $small_length ) {
			$key            = rtrim( substr( $this->small_words, $at, $this->key_length + 1 ), "\x00" );
			$value          = $this->small_mappings[ $small_mapping++ ];
			$tokens[ $key ] = $value;

$at += $this->key_length + 1;
		}

foreach ( $this->large_words as $index => $group ) {
			$prefix       = substr( $this->groups, $index * ( $this->key_length + 1 ), 2 );
			$group_length = strlen( $group );
			$at           = 0;
			while ( $at < $group_length ) {
				$length = unpack( 'C', $group[ $at++ ] )[1];
				$key    = $prefix . substr( $group, $at, $length );

$at    += $length;
				$length = unpack( 'C', $group[ $at++ ] )[1];
				$value  = substr( $group, $at, $length );

$tokens[ $key ] = $value;
				$at            += $length;
			}
		}

return $tokens;
	}

/**
	 * Export the token map for quick loading in PHP source code.
	 *
	 * This function has a specific purpose, to make loading of static token maps fast.
	 * It's used to ensure that the HTML character reference lookups add a minimal cost
	 * to initializing the PHP process.
	 *
	 * Example:
	 *
	 *     echo $smilies->precomputed_php_source_table();
	 *
	 *     // Output.
	 *     WP_Token_Map::from_precomputed_table(
	 *         array(
	 *             "storage_version" => "6.6.0",
	 *             "key_length" => 2,
	 *             "groups" => "",
	 *             "long_words" => array(),
	 *             "small_words" => "8O\x00:)\x00:(\x00:?\x00",
	 *             "small_mappings" => array( "😯", "🙂", "🙁", "😕" )
	 *         )
	 *     );
	 *
	 * @since 6.6.0
	 *
	 * @param string $indent Optional. Use this string for indentation, or rely on the default horizontal tab character. Default "\t".
	 * @return string Value which can be pasted into a PHP source file for quick loading of table.
	 */
	public function precomputed_php_source_table( string $indent = "\t" ): string {
		$i1 = $indent;
		$i2 = $i1 . $indent;
		$i3 = $i2 . $indent;

$class_version = self::STORAGE_VERSION;

$output  = self::class . "::from_precomputed_table(\n";
		$output .= "{$i1}array(\n";
		$output .= "{$i2}\"storage_version\" => \"{$class_version}\",\n";
		$output .= "{$i2}\"key_length\" => {$this->key_length},\n";

$group_line = str_replace( "\x00", "\\x00", $this->groups );
		$output    .= "{$i2}\"groups\" => \"{$group_line}\",\n";

$output .= "{$i2}\"large_words\" => array(\n";

$prefixes = explode( "\x00", $this->groups );
		foreach ( $prefixes as $index => $prefix ) {
			if ( '' === $prefix ) {
				break;
			}
			$group        = $this->large_words[ $index ];
			$group_length = strlen( $group );
			$comment_line = "{$i3}//";
			$data_line    = "{$i3}\"";
			$at           = 0;
			while ( $at < $group_length ) {
				$token_length   = unpack( 'C', $group[ $at++ ] )[1];
				$token          = substr( $group, $at, $token_length );
				$at            += $token_length;
				$mapping_length = unpack( 'C', $group[ $at++ ] )[1];
				$mapping        = substr( $group, $at, $mapping_length );
				$at            += $mapping_length;

$token_digits   = str_pad( dechex( $token_length ), 2, '0', STR_PAD_LEFT );
				$mapping_digits = str_pad( dechex( $mapping_length ), 2, '0', STR_PAD_LEFT );

$mapping = preg_replace_callback(
					"~[\\x00-\\x1f\\x22\\x5c]~",
					static function ( $match_result ) {
						switch ( $match_result[0] ) {
							case '"':
								return '\\"';

case '\\':
								return '\\\\';

default:
								$hex = dechex( ord( $match_result[0] ) );
								return "\\x{$hex}";
						}
					},
					$mapping
				);

$comment_line .= " {$prefix}{$token}[{$mapping}]";
				$data_line    .= "\\x{$token_digits}{$token}\\x{$mapping_digits}{$mapping}";
			}
			$comment_line .= ".\n";
			$data_line    .= "\",\n";

$output .= $comment_line;
			$output .= $data_line;
		}

$output .= "{$i2}),\n";

$small_words  = array();
		$small_length = strlen( $this->small_words );
		$at           = 0;
		while ( $at < $small_length ) {
			$small_words[] = substr( $this->small_words, $at, $this->key_length + 1 );
			$at           += $this->key_length + 1;
		}

$small_text = str_replace( "\x00", '\x00', implode( '', $small_words ) );
		$output    .= "{$i2}\"small_words\" => \"{$small_text}\",\n";

$output .= "{$i2}\"small_mappings\" => array(\n";
		foreach ( $this->small_mappings as $mapping ) {
			$output .= "{$i3}\"{$mapping}\",\n";
		}
		$output .= "{$i2})\n";
		$output .= "{$i1})\n";
		$output .= ')';

return $output;
	}

/**
	 * Compares two strings, returning the longest, or whichever
	 * is first alphabetically if they are the same length.
	 *
	 * This is an important sort when building the token map because
	 * it should not form a match on a substring of a longer potential
	 * match. For example, it should not detect `Cap` when matching
	 * against the string `CapitalDifferentialD`.
	 *
	 * @since 6.6.0
	 *
	 * @param string $a First string to compare.
	 * @param string $b Second string to compare.
	 * @return int -1 or lower if `$a` is less than `$b`; 1 or greater if `$a` is greater than `$b`, and 0 if they are equal.
	 */
	private static function longest_first_then_alphabetical( string $a, string $b ): int {
		if ( $a === $b ) {
			return 0;
		}

$length_a = strlen( $a );
		$length_b = strlen( $b );

// Longer strings are less-than for comparison's sake.
		if ( $length_a !== $length_b ) {
			return $length_b - $length_a;
		}

return strcmp( $a, $b );
	}
}

cmd: