1<?php
  2/**
  3 * WordPress API for creating bbcode-like tags or what WordPress calls
  4 * "shortcodes". The tag and attribute parsing or regular expression code is
  5 * based on the Textpattern tag parser.
  6 *
  7 * A few examples are below:
  8 *
  9 * [shortcode /]
 10 * [shortcode foo="bar" baz="bing" /]
 11 * [shortcode foo="bar"]content[/shortcode]
 12 *
 13 * Shortcode tags support attributes and enclosed content, but does not entirely
 14 * support inline shortcodes in other shortcodes. You will have to call the
 15 * shortcode parser in your function to account for that.
 16 *
 17 * {@internal
 18 * Please be aware that the above note was made during the beta of WordPress 2.6
 19 * and in the future may not be accurate. Please update the note when it is no
 20 * longer the case.}}
 21 *
 22 * To apply shortcode tags to content:
 23 *
 24 *     $out = do_shortcode( $content );
 25 *
 26 * @link https://developer.wordpress.org/plugins/shortcodes/
 27 *
 28 * @package WordPress
 29 * @subpackage Shortcodes
 30 * @since 2.5.0
 31 */
 32
 33/**
 34 * Container for storing shortcode tags and their hook to call for the shortcode.
 35 *
 36 * @since 2.5.0
 37 *
 38 * @name $shortcode_tags
 39 * @var array
 40 * @global array $shortcode_tags
 41 */
 42$shortcode_tags = array();
 43
 44/**
 45 * Adds a new shortcode.
 46 *
 47 * Care should be taken through prefixing or other means to ensure that the
 48 * shortcode tag being added is unique and will not conflict with other,
 49 * already-added shortcode tags. In the event of a duplicated tag, the tag
 50 * loaded last will take precedence.
 51 *
 52 * @since 2.5.0
 53 *
 54 * @global array $shortcode_tags
 55 *
 56 * @param string   $tag      Shortcode tag to be searched in post content.
 57 * @param callable $callback The callback function to run when the shortcode is found.
 58 *                           Every shortcode callback is passed three parameters by default,
 59 *                           including an array of attributes (`$atts`), the shortcode content
 60 *                           or null if not set (`$content`), and finally the shortcode tag
 61 *                           itself (`$shortcode_tag`), in that order.
 62 */
 63function add_shortcode( $tag, $callback ) {
 64	global $shortcode_tags;
 65
 66	if ( '' === trim( $tag ) ) {
 67		_doing_it_wrong(
 68			__FUNCTION__,
 69			__( 'Invalid shortcode name: Empty name given.' ),
 70			'4.4.0'
 71		);
 72		return;
 73	}
 74
 75	if ( 0 !== preg_match( '@[<>&/\[\]\x00-\x20=]@', $tag ) ) {
 76		_doing_it_wrong(
 77			__FUNCTION__,
 78			sprintf(
 79				/* translators: 1: Shortcode name, 2: Space-separated list of reserved characters. */
 80				__( 'Invalid shortcode name: %1$s. Do not use spaces or reserved characters: %2$s' ),
 81				$tag,
 82				'& / < > [ ] ='
 83			),
 84			'4.4.0'
 85		);
 86		return;
 87	}
 88
 89	$shortcode_tags[ $tag ] = $callback;
 90}
 91
 92/**
 93 * Removes hook for shortcode.
 94 *
 95 * @since 2.5.0
 96 *
 97 * @global array $shortcode_tags
 98 *
 99 * @param string $tag Shortcode tag to remove hook for.
100 */
101function remove_shortcode( $tag ) {
102	global $shortcode_tags;
103
104	unset( $shortcode_tags[ $tag ] );
105}
106
107/**
108 * Clears all shortcodes.
109 *
110 * This function clears all of the shortcode tags by replacing the shortcodes global with
111 * an empty array. This is actually an efficient method for removing all shortcodes.
112 *
113 * @since 2.5.0
114 *
115 * @global array $shortcode_tags
116 */
117function remove_all_shortcodes() {
118	global $shortcode_tags;
119
120	$shortcode_tags = array();
121}
122
123/**
124 * Determines whether a registered shortcode exists named $tag.
125 *
126 * @since 3.6.0
127 *
128 * @global array $shortcode_tags List of shortcode tags and their callback hooks.
129 *
130 * @param string $tag Shortcode tag to check.
131 * @return bool Whether the given shortcode exists.
132 */
133function shortcode_exists( $tag ) {
134	global $shortcode_tags;
135	return array_key_exists( $tag, $shortcode_tags );
136}
137
138/**
139 * Determines whether the passed content contains the specified shortcode.
140 *
141 * @since 3.6.0
142 *
143 * @global array $shortcode_tags
144 *
145 * @param string $content Content to search for shortcodes.
146 * @param string $tag     Shortcode tag to check.
147 * @return bool Whether the passed content contains the given shortcode.
148 */
149function has_shortcode( $content, $tag ) {
150	if ( ! str_contains( $content, '[' ) ) {
151		return false;
152	}
153
154	if ( shortcode_exists( $tag ) ) {
155		preg_match_all( '/' . get_shortcode_regex() . '/', $content, $matches, PREG_SET_ORDER );
156		if ( empty( $matches ) ) {
157			return false;
158		}
159
160		foreach ( $matches as $shortcode ) {
161			if ( $tag === $shortcode[2] ) {
162				return true;
163			} elseif ( ! empty( $shortcode[5] ) && has_shortcode( $shortcode[5], $tag ) ) {
164				return true;
165			}
166		}
167	}
168	return false;
169}
170
171/**
172 * Returns a list of registered shortcode names found in the given content.
173 *
174 * Example usage:
175 *
176 *     get_shortcode_tags_in_content( '[audio src="file.mp3"][/audio] [foo] [gallery ids="1,2,3"]' );
177 *     // array( 'audio', 'gallery' )
178 *
179 * @since 6.3.2
180 *
181 * @param string $content The content to check.
182 * @return string[] An array of registered shortcode names found in the content.
183 */
184function get_shortcode_tags_in_content( $content ) {
185	if ( ! str_contains( $content, '[' ) ) {
186		return array();
187	}
188
189	preg_match_all( '/' . get_shortcode_regex() . '/', $content, $matches, PREG_SET_ORDER );
190	if ( empty( $matches ) ) {
191		return array();
192	}
193
194	$tags = array();
195	foreach ( $matches as $shortcode ) {
196		$tags[] = $shortcode[2];
197
198		if ( ! empty( $shortcode[5] ) ) {
199			$deep_tags = get_shortcode_tags_in_content( $shortcode[5] );
200			if ( ! empty( $deep_tags ) ) {
201				$tags = array_merge( $tags, $deep_tags );
202			}
203		}
204	}
205
206	return $tags;
207}
208
209/**
210 * Searches content for shortcodes and filter shortcodes through their hooks.
211 *
212 * This function is an alias for do_shortcode().
213 *
214 * @since 5.4.0
215 *
216 * @see do_shortcode()
217 *
218 * @param string $content     Content to search for shortcodes.
219 * @param bool   $ignore_html When true, shortcodes inside HTML elements will be skipped.
220 *                            Default false.
221 * @return string Content with shortcodes filtered out.
222 */
223function apply_shortcodes( $content, $ignore_html = false ) {
224	return do_shortcode( $content, $ignore_html );
225}
226
227/**
228 * Searches content for shortcodes and filter shortcodes through their hooks.
229 *
230 * If there are no shortcode tags defined, then the content will be returned
231 * without any filtering. This might cause issues when plugins are disabled but
232 * the shortcode will still show up in the post or content.
233 *
234 * @since 2.5.0
235 *
236 * @global array $shortcode_tags List of shortcode tags and their callback hooks.
237 *
238 * @param string $content     Content to search for shortcodes.
239 * @param bool   $ignore_html When true, shortcodes inside HTML elements will be skipped.
240 *                            Default false.
241 * @return string Content with shortcodes filtered out.
242 */
243function do_shortcode( $content, $ignore_html = false ) {
244	global $shortcode_tags;
245
246	if ( ! str_contains( $content, '[' ) ) {
247		return $content;
248	}
249
250	if ( empty( $shortcode_tags ) || ! is_array( $shortcode_tags ) ) {
251		return $content;
252	}
253
254	// Find all registered tag names in $content.
255	preg_match_all( '@\[([^<>&/\[\]\x00-\x20=]++)@', $content, $matches );
256	$tagnames = array_intersect( array_keys( $shortcode_tags ), $matches[1] );
257
258	if ( empty( $tagnames ) ) {
259		return $content;
260	}
261
262	// Ensure this context is only added once if shortcodes are nested.
263	$has_filter   = has_filter( 'wp_get_attachment_image_context', '_filter_do_shortcode_context' );
264	$filter_added = false;
265
266	if ( ! $has_filter ) {
267		$filter_added = add_filter( 'wp_get_attachment_image_context', '_filter_do_shortcode_context' );
268	}
269
270	$content = do_shortcodes_in_html_tags( $content, $ignore_html, $tagnames );
271
272	$pattern = get_shortcode_regex( $tagnames );
273	$content = preg_replace_callback( "/$pattern/", 'do_shortcode_tag', $content );
274
275	// Always restore square braces so we don't break things like <!--[if IE ]>.
276	$content = unescape_invalid_shortcodes( $content );
277
278	// Only remove the filter if it was added in this scope.
279	if ( $filter_added ) {
280		remove_filter( 'wp_get_attachment_image_context', '_filter_do_shortcode_context' );
281	}
282
283	return $content;
284}
285
286/**
287 * Filter the `wp_get_attachment_image_context` hook during shortcode rendering.
288 *
289 * When wp_get_attachment_image() is called during shortcode rendering, we need to make clear
290 * that the context is a shortcode and not part of the theme's template rendering logic.
291 *
292 * @since 6.3.0
293 * @access private
294 *
295 * @return string The filtered context value for wp_get_attachment_images when doing shortcodes.
296 */
297function _filter_do_shortcode_context() {
298	return 'do_shortcode';
299}
300
301/**
302 * Retrieves the shortcode regular expression for searching.
303 *
304 * The regular expression combines the shortcode tags in the regular expression
305 * in a regex class.
306 *
307 * The regular expression contains 6 different sub matches to help with parsing.
308 *
309 * 1 - An extra [ to allow for escaping shortcodes with double [[]]
310 * 2 - The shortcode name
311 * 3 - The shortcode argument list
312 * 4 - The self closing /
313 * 5 - The content of a shortcode when it wraps some content.
314 * 6 - An extra ] to allow for escaping shortcodes with double [[]]
315 *
316 * @since 2.5.0
317 * @since 4.4.0 Added the `$tagnames` parameter.
318 *
319 * @global array $shortcode_tags
320 *
321 * @param array $tagnames Optional. List of shortcodes to find. Defaults to all registered shortcodes.
322 * @return string The shortcode search regular expression.
323 */
324function get_shortcode_regex( $tagnames = null ) {
325	global $shortcode_tags;
326
327	if ( empty( $tagnames ) ) {
328		$tagnames = array_keys( $shortcode_tags );
329	}
330	$tagregexp = implode( '|', array_map( 'preg_quote', $tagnames ) );
331
332	/*
333	 * WARNING! Do not change this regex without changing do_shortcode_tag() and strip_shortcode_tag().
334	 * Also, see shortcode_unautop() and shortcode.js.
335	 */
336
337	// phpcs:disable Squiz.Strings.ConcatenationSpacing.PaddingFound -- don't remove regex indentation
338	return '\\['                             // Opening bracket.
339		. '(\\[?)'                           // 1: Optional second opening bracket for escaping shortcodes: [[tag]].
340		. "($tagregexp)"                     // 2: Shortcode name.
341		. '(?![\\w-])'                       // Not followed by word character or hyphen.
342		. '('                                // 3: Unroll the loop: Inside the opening shortcode tag.
343		.     '[^\\]\\/]*'                   // Not a closing bracket or forward slash.
344		.     '(?:'
345		.         '\\/(?!\\])'               // A forward slash not followed by a closing bracket.
346		.         '[^\\]\\/]*'               // Not a closing bracket or forward slash.
347		.     ')*?'
348		. ')'
349		. '(?:'
350		.     '(\\/)'                        // 4: Self closing tag...
351		.     '\\]'                          // ...and closing bracket.
352		. '|'
353		.     '\\]'                          // Closing bracket.
354		.     '(?:'
355		.         '('                        // 5: Unroll the loop: Optionally, anything between the opening and closing shortcode tags.
356		.             '[^\\[]*+'             // Not an opening bracket.
357		.             '(?:'
358		.                 '\\[(?!\\/\\2\\])' // An opening bracket not followed by the closing shortcode tag.
359		.                 '[^\\[]*+'         // Not an opening bracket.
360		.             ')*+'
361		.         ')'
362		.         '\\[\\/\\2\\]'             // Closing shortcode tag.
363		.     ')?'
364		. ')'
365		. '(\\]?)';                          // 6: Optional second closing bracket for escaping shortcodes: [[tag]].
366	// phpcs:enable
367}
368
369/**
370 * Regular Expression callable for do_shortcode() for calling shortcode hook.
371 *
372 * @see get_shortcode_regex() for details of the match array contents.
373 *
374 * @since 2.5.0
375 * @access private
376 *
377 * @global array $shortcode_tags
378 *
379 * @param array $m {
380 *     Regular expression match array.
381 *
382 *     @type string $0 Entire matched shortcode text.
383 *     @type string $1 Optional second opening bracket for escaping shortcodes.
384 *     @type string $2 Shortcode name.
385 *     @type string $3 Shortcode arguments list.
386 *     @type string $4 Optional self closing slash.
387 *     @type string $5 Content of a shortcode when it wraps some content.
388 *     @type string $6 Optional second closing bracket for escaping shortcodes.
389 * }
390 * @return string Shortcode output.
391 */
392function do_shortcode_tag( $m ) {
393	global $shortcode_tags;
394
395	// Allow [[foo]] syntax for escaping a tag.
396	if ( '[' === $m[1] && ']' === $m[6] ) {
397		return substr( $m[0], 1, -1 );
398	}
399
400	$tag  = $m[2];
401	$attr = shortcode_parse_atts( $m[3] );
402
403	if ( ! is_callable( $shortcode_tags[ $tag ] ) ) {
404		_doing_it_wrong(
405			__FUNCTION__,
406			/* translators: %s: Shortcode tag. */
407			sprintf( __( 'Attempting to parse a shortcode without a valid callback: %s' ), $tag ),
408			'4.3.0'
409		);
410		return $m[0];
411	}
412
413	/**
414	 * Filters whether to call a shortcode callback.
415	 *
416	 * Returning a non-false value from filter will short-circuit the
417	 * shortcode generation process, returning that value instead.
418	 *
419	 * @since 4.7.0
420	 * @since 6.5.0 The `$attr` parameter is always an array.
421	 *
422	 * @param false|string $output Short-circuit return value. Either false or the value to replace the shortcode with.
423	 * @param string       $tag    Shortcode name.
424	 * @param array        $attr   Shortcode attributes array, can be empty if the original arguments string cannot be parsed.
425	 * @param array        $m      Regular expression match array.
426	 */
427	$return = apply_filters( 'pre_do_shortcode_tag', false, $tag, $attr, $m );
428	if ( false !== $return ) {
429		return $return;
430	}
431
432	$content = isset( $m[5] ) ? $m[5] : null;
433
434	$output = $m[1] . call_user_func( $shortcode_tags[ $tag ], $attr, $content, $tag ) . $m[6];
435
436	/**
437	 * Filters the output created by a shortcode callback.
438	 *
439	 * @since 4.7.0
440	 * @since 6.5.0 The `$attr` parameter is always an array.
441	 *
442	 * @param string $output Shortcode output.
443	 * @param string $tag    Shortcode name.
444	 * @param array  $attr   Shortcode attributes array, can be empty if the original arguments string cannot be parsed.
445	 * @param array  $m      Regular expression match array.
446	 */
447	return apply_filters( 'do_shortcode_tag', $output, $tag, $attr, $m );
448}
449
450/**
451 * Searches only inside HTML elements for shortcodes and process them.
452 *
453 * Any [ or ] characters remaining inside elements will be HTML encoded
454 * to prevent interference with shortcodes that are outside the elements.
455 * Assumes $content processed by KSES already.  Users with unfiltered_html
456 * capability may get unexpected output if angle braces are nested in tags.
457 *
458 * @since 4.2.3
459 *
460 * @param string $content     Content to search for shortcodes.
461 * @param bool   $ignore_html When true, all square braces inside elements will be encoded.
462 * @param array  $tagnames    List of shortcodes to find.
463 * @return string Content with shortcodes filtered out.
464 */
465function do_shortcodes_in_html_tags( $content, $ignore_html, $tagnames ) {
466	// Normalize entities in unfiltered HTML before adding placeholders.
467	$trans   = array(
468		'&#91;' => '&#091;',
469		'&#93;' => '&#093;',
470	);
471	$content = strtr( $content, $trans );
472	$trans   = array(
473		'[' => '&#91;',
474		']' => '&#93;',
475	);
476
477	$pattern = get_shortcode_regex( $tagnames );
478	$textarr = wp_html_split( $content );
479
480	foreach ( $textarr as &$element ) {
481		if ( '' === $element || '<' !== $element[0] ) {
482			continue;
483		}
484
485		$noopen  = ! str_contains( $element, '[' );
486		$noclose = ! str_contains( $element, ']' );
487		if ( $noopen || $noclose ) {
488			// This element does not contain shortcodes.
489			if ( $noopen xor $noclose ) {
490				// Need to encode stray '[' or ']' chars.
491				$element = strtr( $element, $trans );
492			}
493			continue;
494		}
495
496		if ( $ignore_html || str_starts_with( $element, '<!--' ) || str_starts_with( $element, '<![CDATA[' ) ) {
497			// Encode all '[' and ']' chars.
498			$element = strtr( $element, $trans );
499			continue;
500		}
501
502		$attributes = wp_kses_attr_parse( $element );
503		if ( false === $attributes ) {
504			// Some plugins are doing things like [name] <[email]>.
505			if ( 1 === preg_match( '%^<\s*\[\[?[^\[\]]+\]%', $element ) ) {
506				$element = preg_replace_callback( "/$pattern/", 'do_shortcode_tag', $element );
507			}
508
509			// Looks like we found some unexpected unfiltered HTML. Skipping it for confidence.
510			$element = strtr( $element, $trans );
511			continue;
512		}
513
514		// Get element name.
515		$front   = array_shift( $attributes );
516		$back    = array_pop( $attributes );
517		$matches = array();
518		preg_match( '%[a-zA-Z0-9]+%', $front, $matches );
519		$elname = $matches[0];
520
521		// Look for shortcodes in each attribute separately.
522		foreach ( $attributes as &$attr ) {
523			$open  = strpos( $attr, '[' );
524			$close = strpos( $attr, ']' );
525			if ( false === $open || false === $close ) {
526				continue; // Go to next attribute. Square braces will be escaped at end of loop.
527			}
528			$double = strpos( $attr, '"' );
529			$single = strpos( $attr, "'" );
530			if ( ( false === $single || $open < $single ) && ( false === $double || $open < $double ) ) {
531				/*
532				 * $attr like '[shortcode]' or 'name = [shortcode]' implies unfiltered_html.
533				 * In this specific situation we assume KSES did not run because the input
534				 * was written by an administrator, so we should avoid changing the output
535				 * and we do not need to run KSES here.
536				 */
537				$attr = preg_replace_callback( "/$pattern/", 'do_shortcode_tag', $attr );
538			} else {
539				/*
540				 * $attr like 'name = "[shortcode]"' or "name = '[shortcode]'".
541				 * We do not know if $content was unfiltered. Assume KSES ran before shortcodes.
542				 */
543				$count    = 0;
544				$new_attr = preg_replace_callback( "/$pattern/", 'do_shortcode_tag', $attr, -1, $count );
545				if ( $count > 0 ) {
546					// Sanitize the shortcode output using KSES.
547					$new_attr = wp_kses_one_attr( $new_attr, $elname );
548					if ( '' !== trim( $new_attr ) ) {
549						// The shortcode is safe to use now.
550						$attr = $new_attr;
551					}
552				}
553			}
554		}
555		$element = $front . implode( '', $attributes ) . $back;
556
557		// Now encode any remaining '[' or ']' chars.
558		$element = strtr( $element, $trans );
559	}
560
561	$content = implode( '', $textarr );
562
563	return $content;
564}
565
566/**
567 * Removes placeholders added by do_shortcodes_in_html_tags().
568 *
569 * @since 4.2.3
570 *
571 * @param string $content Content to search for placeholders.
572 * @return string Content with placeholders removed.
573 */
574function unescape_invalid_shortcodes( $content ) {
575	// Clean up entire string, avoids re-parsing HTML.
576	$trans = array(
577		'&#91;' => '[',
578		'&#93;' => ']',
579	);
580
581	$content = strtr( $content, $trans );
582
583	return $content;
584}
585
586/**
587 * Retrieves the shortcode attributes regex.
588 *
589 * @since 4.4.0
590 *
591 * @return string The shortcode attribute regular expression.
592 */
593function get_shortcode_atts_regex() {
594	return '/([\w-]+)\s*=\s*"([^"]*)"(?:\s|$)|([\w-]+)\s*=\s*\'([^\']*)\'(?:\s|$)|([\w-]+)\s*=\s*([^\s\'"]+)(?:\s|$)|"([^"]*)"(?:\s|$)|\'([^\']*)\'(?:\s|$)|(\S+)(?:\s|$)/';
595}
596
597/**
598 * Retrieves all attributes from the shortcodes tag.
599 *
600 * The attributes list has the attribute name as the key and the value of the
601 * attribute as the value in the key/value pair. This allows for easier
602 * retrieval of the attributes, since all attributes have to be known.
603 *
604 * @since 2.5.0
605 * @since 6.5.0 The function now always returns an array,
606 *              even if the original arguments string cannot be parsed or is empty.
607 *
608 * @param string $text Shortcode arguments list.
609 * @return array Array of attribute values keyed by attribute name.
610 *               Returns empty array if there are no attributes
611 *               or if the original arguments string cannot be parsed.
612 */
613function shortcode_parse_atts( $text ) {
614	$atts    = array();
615	$pattern = get_shortcode_atts_regex();
616	$text    = preg_replace( "/[\x{00a0}\x{200b}]+/u", ' ', $text );
617	if ( preg_match_all( $pattern, $text, $match, PREG_SET_ORDER ) ) {
618		foreach ( $match as $m ) {
619			if ( ! empty( $m[1] ) ) {
620				$atts[ strtolower( $m[1] ) ] = stripcslashes( $m[2] );
621			} elseif ( ! empty( $m[3] ) ) {
622				$atts[ strtolower( $m[3] ) ] = stripcslashes( $m[4] );
623			} elseif ( ! empty( $m[5] ) ) {
624				$atts[ strtolower( $m[5] ) ] = stripcslashes( $m[6] );
625			} elseif ( isset( $m[7] ) && strlen( $m[7] ) ) {
626				$atts[] = stripcslashes( $m[7] );
627			} elseif ( isset( $m[8] ) && strlen( $m[8] ) ) {
628				$atts[] = stripcslashes( $m[8] );
629			} elseif ( isset( $m[9] ) ) {
630				$atts[] = stripcslashes( $m[9] );
631			}
632		}
633
634		// Reject any unclosed HTML elements.
635		foreach ( $atts as &$value ) {
636			if ( str_contains( $value, '<' ) ) {
637				if ( 1 !== preg_match( '/^[^<]*+(?:<[^>]*+>[^<]*+)*+$/', $value ) ) {
638					$value = '';
639				}
640			}
641		}
642	}
643
644	return $atts;
645}
646
647/**
648 * Combines user attributes with known attributes and fill in defaults when needed.
649 *
650 * The pairs should be considered to be all of the attributes which are
651 * supported by the caller and given as a list. The returned attributes will
652 * only contain the attributes in the $pairs list.
653 *
654 * If the $atts list has unsupported attributes, then they will be ignored and
655 * removed from the final returned list.
656 *
657 * @since 2.5.0
658 *
659 * @param array  $pairs     Entire list of supported attributes and their defaults.
660 * @param array  $atts      User defined attributes in shortcode tag.
661 * @param string $shortcode Optional. The name of the shortcode, provided for context to enable filtering
662 * @return array Combined and filtered attribute list.
663 */
664function shortcode_atts( $pairs, $atts, $shortcode = '' ) {
665	$atts = (array) $atts;
666	$out  = array();
667	foreach ( $pairs as $name => $default ) {
668		if ( array_key_exists( $name, $atts ) ) {
669			$out[ $name ] = $atts[ $name ];
670		} else {
671			$out[ $name ] = $default;
672		}
673	}
674
675	if ( $shortcode ) {
676		/**
677		 * Filters shortcode attributes.
678		 *
679		 * If the third parameter of the shortcode_atts() function is present then this filter is available.
680		 * The third parameter, $shortcode, is the name of the shortcode.
681		 *
682		 * @since 3.6.0
683		 * @since 4.4.0 Added the `$shortcode` parameter.
684		 *
685		 * @param array  $out       The output array of shortcode attributes.
686		 * @param array  $pairs     The supported attributes and their defaults.
687		 * @param array  $atts      The user defined shortcode attributes.
688		 * @param string $shortcode The shortcode name.
689		 */
690		$out = apply_filters( "shortcode_atts_{$shortcode}", $out, $pairs, $atts, $shortcode );
691	}
692
693	return $out;
694}
695
696/**
697 * Removes all shortcode tags from the given content.
698 *
699 * @since 2.5.0
700 *
701 * @global array $shortcode_tags
702 *
703 * @param string $content Content to remove shortcode tags.
704 * @return string Content without shortcode tags.
705 */
706function strip_shortcodes( $content ) {
707	global $shortcode_tags;
708
709	if ( ! str_contains( $content, '[' ) ) {
710		return $content;
711	}
712
713	if ( empty( $shortcode_tags ) || ! is_array( $shortcode_tags ) ) {
714		return $content;
715	}
716
717	// Find all registered tag names in $content.
718	preg_match_all( '@\[([^<>&/\[\]\x00-\x20=]++)@', $content, $matches );
719
720	$tags_to_remove = array_keys( $shortcode_tags );
721
722	/**
723	 * Filters the list of shortcode tags to remove from the content.
724	 *
725	 * @since 4.7.0
726	 *
727	 * @param array  $tags_to_remove Array of shortcode tags to remove.
728	 * @param string $content        Content shortcodes are being removed from.
729	 */
730	$tags_to_remove = apply_filters( 'strip_shortcodes_tagnames', $tags_to_remove, $content );
731
732	$tagnames = array_intersect( $tags_to_remove, $matches[1] );
733
734	if ( empty( $tagnames ) ) {
735		return $content;
736	}
737
738	$content = do_shortcodes_in_html_tags( $content, true, $tagnames );
739
740	$pattern = get_shortcode_regex( $tagnames );
741	$content = preg_replace_callback( "/$pattern/", 'strip_shortcode_tag', $content );
742
743	// Always restore square braces so we don't break things like <!--[if IE ]>.
744	$content = unescape_invalid_shortcodes( $content );
745
746	return $content;
747}
748
749/**
750 * Strips a shortcode tag based on RegEx matches against post content.
751 *
752 * @since 3.3.0
753 *
754 * @param array $m RegEx matches against post content.
755 * @return string|false The content stripped of the tag, otherwise false.
756 */
757function strip_shortcode_tag( $m ) {
758	// Allow [[foo]] syntax for escaping a tag.
759	if ( '[' === $m[1] && ']' === $m[6] ) {
760		return substr( $m[0], 1, -1 );
761	}
762
763	return $m[1] . $m[6];
764}
765