tags and queues brushes
	 * for the languages used.
	 *
	 * This filter only runs when a reusable block is used in a post.
	 * It was easier to implement than loading the block, which then could
	 * have child blocks and so forth. Technically this means that we're
	 * parsing any regular SyntaxHighlighter blocks again, but oh well. :)
	 *
	 * @since 3.4.2
	 *
	* @param string $content The post content.
	 *
	 * @return string Unmodified $content.
	 */
	public function enable_brushes_via_raw_html_parsing( $content ) {
		if ( false === strpos( $content,'
brushes, true ) ) {
					$this->usedbrushes[ $this->brushes[ $language ] ] = true;
				}
			}
		}

		return $content;
	}

	/**
	 * Renders the content of the Gutenberg block on the front end
	 * using the shortcode callback. This ensures one source of truth
	 * and allows for forward compatibility.
	 *
	* @param string $content The block's content.
	 *
	 * @return string The rendered content.
	 */
	public function render_block( $attributes, $content ) {
		$remaps = array(
			'lineNumbers'       => 'gutter',
			'firstLineNumber'   => 'firstline',
			'highlightLines'    => 'highlight',
			'wrapLines'         => 'wraplines',
			'makeURLsClickable' => 'autolinks',
			'quickCode'         => 'quickcode',
		);
		$classnames = ! empty( $attributes['className'] ) ? [ esc_attr( $attributes['className'] ) ] : [];
		if ( ! empty( $attributes['align'] ) ) {
			$classnames[] = 'align' . esc_attr( $attributes['align'] );
		}

		foreach ( $remaps as $from => $to ) {
			if ( isset( $attributes[ $from ] ) ) {
				if ( is_bool( $attributes[ $from ] ) ) {
					$attributes[ $to ] = ( $attributes[ $from ] ) ? '1' : '0';
				} else {
					$attributes[ $to ] = $attributes[ $from ];
				}

				unset( $attributes[ $from ] );
			}
		}

		$code = preg_replace( '#
]+>([^<]+)?
#', '$1', $content );

		// Undo escaping done by WordPress
		$code = htmlspecialchars_decode( $code );
		$code = preg_replace( '/^(\s*https?:)�?47;�?47;([^\s<>"]+\s*)$/m', '$1//$2', $code );

		$code = $this->shortcode_callback( $attributes, $code, 'code' );

		return '
' . $code . '
';
	}

	// Add the custom TinyMCE plugin which wraps plugin shortcodes in 
 in TinyMCE
	function add_tinymce_plugin( $plugins ) {
		global $tinymce_version;

		add_action( 'admin_print_footer_scripts', array( $this, 'output_shortcodes_for_tinymce' ), 9 );

		if ( substr( $tinymce_version, 0, 1 ) < 4 ) {
			$plugins['syntaxhighlighter'] = plugins_url( 'syntaxhighlighter_mce.js', __FILE__ );
		} else {
			$plugins['syntaxhighlighter'] = add_query_arg( 'ver', $this->pluginver, plugins_url( 'syntaxhighlighter_mce-4.js', __FILE__ ) );
			wp_enqueue_script( 'syntaxhighlighter', plugins_url( 'syntaxhighlighter.js', __FILE__ ), array(), false, true );
		}

		return $plugins;
	}


	// Break the TinyMCE cache
	function break_tinymce_cache( $version ) {
		return $version . '-sh' . $this->pluginver;
	}


	// Add a "Settings" link to the plugins page
	function settings_link( $links, $file ) {
		static $this_plugin;

		if ( empty( $this_plugin ) ) {
			$this_plugin = plugin_basename(__FILE__);
		}

		if ( $file == $this_plugin ) {
			$links[] = '' . __( 'Settings', 'syntaxhighlighter' ) . '';
		}

		return $links;
	}


	// Output list of shortcode tags for the TinyMCE plugin
	function output_shortcodes_for_tinymce() {
		$shortcodes = array();

		foreach ( $this->shortcodes as $shortcode )
			$shortcodes[] = preg_quote( $shortcode );

		echo "\n";
	}


	/**
	 * Returns all shortcodes not handled by SyntaxHighlighter unchanged, so they
	 * can be processed by their original handlers after SyntaxHighlighter has
	 * run.
	 *
	 * @param mixed $output The shortcode's returned value (false by default).
	 * @param string $tag The name of the shortcode.
	 * @param array|null $attr The shortcode attributes.
	 * @param array $m Regular expression match array.
	 * @return string|false Return the matched shortcode as-is for all shortcodes not handled by SyntaxHighlighter, returns $output otherwise.
	 */
	function pre_do_shortcode_shortcode_hack_skip_others( $output, $tag, $attr, $m ) {
		if ( ! in_array( $tag, $this->shortcodes, true ) ) {
			return $m[0];
		}
		return $output;
	}

	/**
	 * Process only this plugin's shortcodes.
	 *
	 * If we waited for the normal do_shortcode() call at priority 11,
	 * then wpautop() and maybe others would mangle all of the code.
	 *
	 * So instead we hook in earlier with this function and process
	 * just this plugins's shortcodes. To do this requires some trickery.
	 *
	 * First we need to clear out all existing shortcodes, then register
	 * just this plugin's ones, process them, and then restore the original
	 * list of shortcodes. Additionally, we have to add another hack to other
	 * shortcodes, such as [gallery], to return the entire shortcode string as
	 * it appears in the original content to allow SyntaxHighlighter's shortcode
	 * strings (e.g., [c]) be used within other shortcodes without interference
	 * from SyntaxHighlighter.
	 *
	 * To make matters more complicated, if someone has done [[code]foo[/code]]
	 * in order to display the shortcode (not render it), then do_shortcode()
	 * will strip the outside brackets and when do_shortcode() runs a second
	 * time later on, it will render it.
	 *
	 * So instead before do_shortcode() runs for the first time, we add
	 * even more brackets escaped shortcodes in order to result in
	 * the shortcodes actually being displayed instead rendered.
	 *
	 * Phew!
	 *
	 * @param string $content     The post content.
	 * @param array  $callback    The callback function that should be used for add_shortcode()
	 * @param bool   $ignore_html When true, shortcodes inside HTML elements will be skipped.
	 *
	 * @return string The filtered content, with this plugin's shortcodes parsed.
	 */
	function shortcode_hack( $content, $callback, $ignore_html = true ) {
		global $shortcode_tags;

		// Regex is slow. Let's do some strpos() checks first.
		if ( ! $this->string_has_shortcodes( $content, $this->shortcodes ) ) {
			return $content;
		}

		// Backup current registered shortcodes and clear them all out (we do not backup our own, because we will add and parse them below)
		$orig_shortcode_tags = array_diff_key( $shortcode_tags, array_flip( $this->shortcodes ) );
		remove_all_shortcodes();

		// Register all of this plugin's shortcodes
		foreach ( $this->shortcodes as $shortcode ) {
			add_shortcode( $shortcode, $callback );
		}

		// Register all other shortcodes, ensuring their content remains unchanged using yet another hack.
		foreach ( $orig_shortcode_tags as $shortcode_tagname => $shortcode ) {
			add_shortcode( $shortcode_tagname, '__return_empty_string' );
		}
		add_filter( 'pre_do_shortcode_tag', array( $this, 'pre_do_shortcode_shortcode_hack_skip_others' ), 10, 4 );

		$regex = '/' . get_shortcode_regex() . '/';

		// Parse the shortcodes (only this plugins's are registered)
		if ( $ignore_html ) {
			// Extra escape escaped shortcodes because do_shortcode_tag() called by do_shortcode() is going to strip a pair of square brackets when it runs
			$content = preg_replace_callback(
				$regex,
				array( $this, 'shortcode_hack_extra_escape_escaped_shortcodes' ),
				$content
			);

			// Normal, safe parsing
			$content = do_shortcode( $content, true );
		} else {
			// Extra escape escaped shortcodes because do_shortcode_tag() called by do_shortcode() is going to strip a pair of square brackets when it runs.
			// Then call do_shortcode_tag(). This is basically do_shortcode() without calling do_shortcodes_in_html_tags() which breaks things.
			// For context, see https://wordpress.org/support/topic/php-opening-closing-tags-break-code-blocks
			$content = preg_replace_callback(
				$regex,
				array( $this, 'shortcode_hack_extra_escape_escaped_shortcodes_and_parse' ),
				$content
			);
		}

		// Put the original shortcodes back, and remove the hacky pre_do_shortcode_tag filter
		$shortcode_tags = $orig_shortcode_tags;
		remove_filter('pre_do_shortcode_tag', array($this, 'pre_do_shortcode_shortcode_hack_skip_others'), 10);

		return $content;
	}


	/**
	 * A quick checker to see if any of this plugin's shortcodes are in use in a string.
	 * Since all of the tags can't be self-closing, we look for the closing tag.
	 *
	 * @param string $string     The string to look through. This is a post's contents usually.
	 * @param array  $shortcodes The array of shortcodes to look for.
	 *
	 * @return bool Whether any shortcode usage was found.
	 */
	function string_has_shortcodes( $string, $shortcodes ) {
		foreach ( $shortcodes as $shortcode ) {
			if ( false !== strpos( $string, "[/{$shortcode}]" ) ) {
				return true;
			}
		}

		return false;
	}


	/**
	 * Add extra square brackets around escaped shortcodes.
	 * This is to counteract the beginning of the do_shortcode_tag() function.
	 *
	 * @param array $match The array of matches generated by get_shortcode_regex()
	 *
	 * @return string What should be placed into the post content. In this case it's the raw match, or an extra-wrapped raw match.
	 */
	function shortcode_hack_extra_escape_escaped_shortcodes( $match ) {
		if ( $match[1] == '[' && $match[6] == ']' ) {
			return '[' . $match[0] . ']';
		}

		return $match[0];
	}

	/**
	 * This is a combination of this class's shortcode_hack_extra_escape_escaped_shortcodes()
  	 * and do_shortcode_tag() for performance reasons so that we don't have to run some regex twice.
 	 *
	 * @param array $match Regular expression match array.
	 *
	 * @return string|false False on failure, otherwise a parse shortcode tag.
	 */
	function shortcode_hack_extra_escape_escaped_shortcodes_and_parse( $match ) {
		$match[0] = $this->shortcode_hack_extra_escape_escaped_shortcodes( $match );

		return do_shortcode_tag( $match );
	}

	// The main filter for the post contents. The regular shortcode filter can't be used as it's post-wpautop().
	function parse_shortcodes( $content ) {
		return $this->shortcode_hack( $content, array( $this, 'shortcode_callback' ) );
	}


	// HTML entity encode the contents of shortcodes
	function encode_shortcode_contents( $content ) {
		return $this->shortcode_hack( $content, array( $this, 'encode_shortcode_contents_callback' ), false );
	}


	// HTML entity encode the contents of shortcodes. Expects slashed content.
	function encode_shortcode_contents_slashed( $content ) {
		return addslashes( $this->encode_shortcode_contents( stripslashes( $content ) ) );
	}


	// HTML entity encode the contents of shortcodes. Expects slashed content. Aborts if AJAX.
	function encode_shortcode_contents_slashed_noquickedit( $content ) {

		// In certain weird circumstances, the content gets run through "content_save_pre" twice
		// Keep track and don't allow this filter to be run twice
		// I couldn't easily figure out why this happens and didn't bother looking into it further as this works fine
		if ( true == $this->content_save_pre_ran ) {
			return $content;
		}
		$this->content_save_pre_ran = true;

		// Post quick edits aren't decoded for display, so we don't need to encode them (again)
		// This also aborts for (un)trashing to avoid extra encoding.
		if ( empty( $_POST ) || ( ! empty( $_POST['action'] ) && 'inline-save' == $_POST['action'] ) ) {
			return $content;
		}

		return $this->encode_shortcode_contents_slashed( $content );
	}


	// HTML entity decode the contents of shortcodes
	function decode_shortcode_contents( $content ) {
		return $this->shortcode_hack( $content, array( $this, 'decode_shortcode_contents_callback' ), false );
	}


	// The callback function for SyntaxHighlighter::encode_shortcode_contents()
	function encode_shortcode_contents_callback( $atts, $code = '', $tag = false ) {
		$this->encoded = true;
		$code = str_replace( array_keys( $this->specialchars ), array_values( $this->specialchars ), htmlspecialchars( $code ) );
		return '[' . $tag . $this->atts2string( $atts ) . "]{$code}[/$tag]";
	}


	// The callback function for SyntaxHighlighter::decode_shortcode_contents()
	// Shortcode attribute values need to not be quoted with TinyMCE disabled for some reason (weird bug)
	function decode_shortcode_contents_callback( $atts, $code = '', $tag = false ) {
		$quotes = ( user_can_richedit() ) ? true : false;
		$code = str_replace( array_values( $this->specialchars ), array_keys( $this->specialchars ), htmlspecialchars_decode( $code ) );
		return '[' . $tag . $this->atts2string( $atts, $quotes ) . "]{$code}[/$tag]";
	}


	// Dynamically format the post content for the edit form
	function the_editor_content( $content ) {
		global $post;

		// New code format (stored encoded in database)
		if ( 2 == $this->get_code_format( $post ) ) {
			// If TinyMCE is disabled or the HTML tab is set to be displayed first, we need to decode the HTML
			if ( !user_can_richedit() || 'html' == wp_default_editor() )
				$content = $this->decode_shortcode_contents( $content );
		}

		// Old code format (stored raw in database)
		else {
			// If TinyMCE is enabled and is set to be displayed first, we need to encode the HTML
			if ( user_can_richedit() && 'html' != wp_default_editor() )
				$content = $this->encode_shortcode_contents( $content );
		}

		return $content;
	}


	// Run SyntaxHighlighter::encode_shortcode_contents() on the contents of the text widget
	function widget_text_save( $instance, $new_instance, $old_instance, $widgetclass ) {
		if ( 'text' == $widgetclass->id_base ) {
			// Re-save the widget settings but this time with the shortcode contents encoded
			$new_instance['text'] = $this->encode_shortcode_contents( $new_instance['text'] );
			$instance = $widgetclass->update( $new_instance, $old_instance );

			// And flag it as encoded
			$instance['syntaxhighlighter_encoded'] = true;
		}

		return $instance;
	}


	// Run SyntaxHighlighter::decode_shortcode_contents_callback() on the contents of the text widget form
	function widget_text_form( $instance, $widgetclass ) {
		if ( 'text' == $widgetclass->id_base && ! empty( $instance['syntaxhighlighter_encoded'] ) ) {
			$instance['text'] = $this->shortcode_hack( $instance['text'], array( $this, 'decode_shortcode_contents_callback' ) );
		}

		return $instance;
	}


	// Run SyntaxHighlighter::parse_shortcodes() on the contents of a text widget
	function widget_text_output( $content, $instance = false ) {
		$this->codeformat = ( false === $instance || empty( $instance['syntaxhighlighter_encoded'] ) ) ? 1 : 2;
		$content = $this->parse_shortcodes( $content );
		$this->codeformat = false;

		return $content;
	}


	// Run SyntaxHighlighter::parse_shortcodes() on the contents of a comment
	function parse_shortcodes_comment( $content ) {
		$this->codeformat = 2;
		$content = $this->parse_shortcodes( $content );
		$this->codeformat = false;

		return $content;
	}


	// This function determines what version of SyntaxHighlighter was used when the post was written
	// This is because the code was stored differently for different versions of SyntaxHighlighter
	function get_code_format( $post ) {
		if ( false !== $this->codeformat ) {
			return $this->codeformat;
		}

		if ( empty( $post ) ) {
			$post = new stdClass();
		}

		if ( null !== $version = apply_filters( 'syntaxhighlighter_pre_getcodeformat', null, $post ) )
			return $version;

		$version = ( empty( $post->ID ) || get_post_meta( $post->ID, '_syntaxhighlighter_encoded', true ) || get_post_meta( $post->ID, 'syntaxhighlighter_encoded', true ) ) ? 2 : 1;

		return apply_filters( 'syntaxhighlighter_getcodeformat', $version, $post );
	}


	// Adds a post meta saying that HTML entities are encoded (for backwards compatibility)
	function mark_as_encoded( $post_ID, $post ) {
		if ( false == $this->encoded || 'revision' == $post->post_type )
			return;

		delete_post_meta( $post_ID, 'syntaxhighlighter_encoded' ); // Previously used
		add_post_meta( $post_ID, '_syntaxhighlighter_encoded', true, true );
	}


	// Transforms an attributes array into a 'key="value"' format (i.e. reverses the process)
	function atts2string( $atts, $quotes = true ) {
		if ( empty( $atts ) ) {
			return '';
		}

		$atts = $this->attributefix( $atts );

		// Re-map [code="php"] style tags
		if ( isset( $atts[0] ) ) {
			if ( empty( $atts['language'] ) ) {
				$atts['language'] = $atts[0];
			}

			unset( $atts[0] );
		}

		$strings = array();
		foreach ( $atts as $key => $value )
			$strings[] = ( $quotes ) ? $key . '="' . esc_attr( $value ) . '"' : $key . '=' . esc_attr( $value );

		return ' ' . implode( ' ', $strings );
	}


	// Simple function for escaping just single quotes (the original js_escape() escapes more than we need)
	function js_escape_singlequotes( $string ) {
		return str_replace( "'", "\'", $string );
	}


	// Output any needed scripts. This is meant for the footer.
	function maybe_output_scripts() {
		global $wp_styles;

		if ( 1 == $this->settings['loadallbrushes'] ) {
			$this->usedbrushes = array_flip( array_values( $this->brushes ) );
		}

		if ( empty( $this->usedbrushes ) ) {
			return;
		}

		$scripts = array();
		foreach ( $this->usedbrushes as $brush => $unused )
			$scripts[] = 'syntaxhighlighter-brush-' . strtolower( $brush );

		wp_print_scripts( $scripts );

		// Stylesheets can't be in the footer, so inject them via Javascript
		echo "
's
	function shortcode_callback( $atts, $code = '', $tag = false ) {
		global $post;

		if ( false === $tag || empty( $code ) ) {
			return $code;
		}

		// Avoid PHP notices
		if ( ! isset( $post ) ) {
			$post = null;
		}

		$code = apply_filters( 'syntaxhighlighter_precode', $code, $atts, $tag );

		// Error fixing for [tag="language"]
		if ( isset( $atts[0] ) ) {
			$atts = $this->attributefix( $atts );
			$atts['language'] = $atts[0];
			unset( $atts[0] );
		}

		// Default out all of the available parameters to "false" (easy way to check if they're set or not)
		// Note this isn't the same as if the user passes the string "false" to the shortcode
		$atts = (array) apply_filters( 'syntaxhighlighter_shortcodeatts', shortcode_atts( array(
			'language'       => false,
			'lang'           => false,
			'type'           => false, // language alias
			'autolinks'      => false,
			'classname'      => false,
			'collapse'       => false,
			'firstline'      => false,
			'fontsize'       => false,
			'gutter'         => false,
			'highlight'      => false,
			'htmlscript'     => false,
			'light'          => false,
			'padlinenumbers' => false,
			'smarttabs'      => false,
			'tabsize'        => false,
			'title'          => $this->settings['title'],
			'toolbar'        => false,
			'wraplines'      => false,
			'quickcode'      => false,
		), $atts ) );

		// Check for language shortcode tag such as [php]code[/php]
		if ( isset( $this->brushes[ $tag ] ) ) {
			$lang = $tag;
		}

		// If a valid tag is not used, it must be sourcecode/source/code
		else {
			$atts = $this->attributefix( $atts );

			// Check for the "language" attribute
			if ( false !== $atts['language'] )
				$lang = $atts['language'];

			// Check for the "lang" attribute
			elseif ( false !== $atts['lang'] )
				$lang = $atts['lang'];

			// Default to plain text
			else
				$lang = 'text';

			// All language aliases are lowercase
			$lang = strtolower( $lang );

			// Validate passed attribute
			if ( ! isset( $this->brushes[ $lang ] ) ) {
				return $code;
			}
		}

		// Switch from the alias to the real brush name (so custom aliases can be used)
		$lang = $this->brushes[ $lang ];

		// Register this brush as used so it's script will be outputted
		$this->usedbrushes[ $lang ] = true;

		$params = array();
		$params[] = "brush: $lang;";

		// Fix bug that prevents collapse from working if the toolbar is off or light mode is on
		if ( 'true' == $atts['collapse'] || '1' === $atts['collapse'] || 1 == $this->settings['collapse'] ) {
			$atts['toolbar'] = 'true';
			$atts['light'] = 'false';
		}

		// Parameter renaming (the shortcode API doesn't like parameter names with dashes)
		$rename_map = array(
			'autolinks'      => 'auto-links',
			'classname'      => 'class-name',
			'firstline'      => 'first-line',
			'fontsize'       => 'font-size',
			'htmlscript'     => 'html-script',
			'padlinenumbers' => 'pad-line-numbers',
			'smarttabs'      => 'smart-tabs',
			'tabsize'        => 'tab-size',
			'wraplines'      => 'wrap-lines',
			'quickcode'      => 'quick-code',
		);

		// Allowed configuration parameters and their type
		// Use the proper names (see above)
		$allowed_atts = (array) apply_filters( 'syntaxhighlighter_allowedatts', array(
			'auto-links'       => 'boolean',
			'class-name'       => 'other',
			'collapse'         => 'boolean',
			'first-line'       => 'integer',
			'font-size'        => 'integer',
			'gutter'           => 'boolean',
			'highlight'        => 'other',
			'html-script'      => 'boolean',
			'light'            => 'boolean',
			'pad-line-numbers' => 'other',
			'smart-tabs'       => 'boolean',
			'tab-size'         => 'integer',
			'title'            => 'other',
			'toolbar'          => 'boolean',
			'wrap-lines'       => 'boolean',
			'quick-code'       => 'boolean',
		) );

		$title = '';

		// Sanitize configuration parameters and such
		foreach ( $atts as $key => $value ) {
			$key = strtolower( $key );

			// Put back parameter names that have been renamed for shortcode use
			if ( ! empty( $rename_map[ $key ] ) ) {
				$key = $rename_map[ $key ];
			}

			// This this parameter if it's unknown, not set, or the language which was already handled
			if ( empty( $allowed_atts[ $key ] ) || false === $value || in_array( $key, array( 'language', 'lang' ) ) ) {
				continue;
			}

			// Sanitize values
			switch ( $allowed_atts[ $key ] ) {
				case 'boolean':
					$value = strtolower( $value );
					if ( 'true' === $value || '1' === $value || 'on' == $value )
						$value = 'true';
					elseif ( 'false' === $value || '0' === $value || 'off' == $value )
						$value = 'false';
					else
						continue 2; // Invalid value, ditch parameter
					break;

				// integer
				case 'integer':
					$value = (int) $value;
					break;
			}

			// Sanitize the "classname" parameter
			if ( 'class-name' == $key )
				$value = "'" . trim( preg_replace( '/[^a-zA-Z0-9 _-]/i', '', $value ) ) . "'";

			// Special sanitization for "pad-line-numbers"
			if ( 'pad-line-numbers' == $key ) {
				$value = strtolower( $value );
				if ( 'true' === $value || '1' === $value )
					$value = 'true';
				elseif ( 'false' === $value || '0' === $value )
					$value = 'false';
				else
					$value = (int) $value;
			}

			// Add % sign to "font-size"
			if ( 'font-size' == $key )
				$value = $value . '%';

			// If "html-script", then include the XML brush as it's needed
			if ( 'html-script' == $key && 'true' == $value )
				$this->usedbrushes['xml'] = true;

			// Sanitize row highlights
			if ( 'highlight' == $key ) {
				if ( false === strpos( $value, ',' ) && false === strpos( $value, '-' ) ) {
					$value = (int) $value;
				} else {
					$lines = explode( ',', $value );
					$highlights = array();

					foreach ( $lines as $line ) {
						// Line range
						if ( false !== strpos( $line, '-' ) ) {
							list( $range_start, $range_end ) = array_map( 'intval', explode( '-', $line ) );
							if ( ! $range_start || ! $range_end || $range_end <= $range_start )
								continue;

							for ( $i = $range_start; $i <= $range_end; $i++ )
								$highlights[] = $i;
						} else {
							$highlights[] = (int) $line;
						}
					}

					natsort( $highlights );

					$value = implode( ',', $highlights );
				}

				if ( empty( $value ) )
					continue;

				// Wrap highlight in [ ]
				$params[] = "$key: [$value];";
				continue;
			}

			// Don't allow HTML in the title parameter
			if ( 'title' == $key ) {
				$value = strip_tags( html_entity_decode( strip_tags( $value ) ) );
			}

			$params[] = "$key: $value;";

			// Set the title variable if the title parameter is set (but not for feeds)
			if ( 'title' == $key && ! is_feed() )
				$title = ' title="' . esc_attr( $value ) . '"';
		}

		$code = ( false === strpos( $code, '<' ) && false === strpos( $code, '>' ) && 2 == $this->get_code_format( $post ) ) ? strip_tags( $code ) : htmlspecialchars( $code );

		// Escape shortcodes
		$code = preg_replace( '/\[/', '[', $code );

		$params[] = 'notranslate'; // For Google, see http://otto42.com/9k

		$params = apply_filters( 'syntaxhighlighter_cssclasses', $params ); // Use this to add additional CSS classes / SH parameters

		return apply_filters( 'syntaxhighlighter_htmlresult', '
' . $code . '
' );
	}


	// Settings page
	function settings_page() { ?>




	


	


	


	

		

			

			

				
 __( 'Version 3.x', 'syntaxhighlighter' ),
						2 => __( 'Version 2.x', 'syntaxhighlighter' ),
					);

					foreach ( $versions as $version => $name ) {
						echo '					settings['shversion'], $version, false ) . '>' . esc_html( $name ) . " \n";
					}
?>
				

				

				
			
		
		

			

			

				
themes as $theme => $name ) {
						echo '					settings['theme'], $theme, false ) . '>' . esc_html( $name ) . " \n";
					}
?>
				
			
		
		

			

			

				

					

					
						settings['loadallbrushes'], 1 ); ?> />
						<pre> tags rather than shortcodes). If left unchecked (default), then language files will only be loaded when needed. If unsure, leave this box unchecked.', 'syntaxhighlighter' ), array( 'code' => array(), 'br' => array() ) );
						?>
					
				
			
		
	

	


	


	

		

			

			

				

					


					settings['gutter'], 1 ); ?> /> 

					settings['toolbar'], 1 ); ?> /> 

					settings['autolinks'], 1 ); ?> /> 

					settings['collapse'], 1 ); ?> /> 

					settings['light'], 1 ); ?> /> 

					settings['smarttabs'], 1 ); ?> /> 

					settings['wraplines'], 1 ); ?> /> 

					settings['quickcode'], 1 ); ?> /> 

					
				
			
		
		

			

			

		
		

			

			

		
		

			

			

				
 __( 'Off', 'syntaxhighlighter' ),
						'true'  => __( 'Automatic', 'syntaxhighlighter' ),
						1       => 1,
						2       => 2,
						3       => 3,
						4       => 4,
						5       => 5,
					);

					foreach ( $linepaddings as $value => $name ) {
						echo '					settings['padlinenumbers'], $value, false ) . '>' . esc_html( $name ) . " \n";
					}
?>
				
			
		
		

			

			

		
		

			

			

				

				
			
		
	

	

' . "\n";
			echo '' . "\n";
		}
?>
	

	

	


	


	';

		$title = ( empty( $this->settings['title'] ) && 1 != $this->settings['collapse'] ) ? ' title="Code example: (this example was added using the title parameter)"' : '';

		// Site owners may opt to disable the short tags, i.e. [php]
		$democode = apply_filters( 'syntaxhighlighter_democode', '[sourcecode language="php" htmlscript="true" highlight="12"' . $title . ']


	
	


	
' . __( 'PHP Code Example', 'syntaxhighlighter' ) . '

	


	
' . __( 'This line is highlighted.', 'syntaxhighlighter' ) . '

	

' . __( '		This	is	an
		example	of	smart
		tabs.', 'syntaxhighlighter' ) . '
	

	
' . __( 'WordPress' ) . '

[/sourcecode]' );

		$this->codeformat = 1;
		echo $this->parse_shortcodes( $democode );
		$this->codeformat = false;

		echo '
';
?>

	


	
true', '1', 'false', '0' ); ?>

	

		

			[php]code[/php]. Available tags: %3$s.', 'language parameter', 'syntaxhighlighter' ),
						'lang',
						'language',
						implode( ', ', array_keys( $this->brushes ) )
					),
					array(
						'a' => array(
							'href' => array(),
						),
						'code' => array(),
					)
				);
			?>
		
		

			autolinks'
				);
			?>
		
		

			classname'
				);
			?>
		
		

			collapse'
				);
			?>
		
		

			firstline'
				);
			?>
		
		

			gutter'
				);
			?>
		
		

			highlight',
					'2,5-10,12'
				);
			?>
		
		

			htmlscript'
				);
			?>
		
		

			light'
				);
			?>
		
		

			false (no padding), true (automatic padding), or an integer (forced padding).', 'padlinenumbers parameter', 'syntaxhighlighter' ),
					'padlinenumbers'
				);
			?>
		
		

			title',
					'collapse'
				);
			?>
		
		

			toolbar'
				);
			?>
		
		

			wraplines'
				);
			?>
		
		

			quickcode'
				);
			?>
		
	

	


	

		
[php][/php]
		
[css autolinks="false" classname="myclass" collapse="false" firstline="1" gutter="true" highlight="1-3,6,9" htmlscript="false" light="false" padlinenumbers="false" smarttabs="true" tabsize="4" toolbar="true" title=""][/css]
		
[code lang="js"][/code]
		
[sourcecode language="plain"][/sourcecode]
	

maybe_output_scripts(); ?>



defaultsettings;
			$_REQUEST['_wp_http_referer'] = add_query_arg( 'defaults', 'true', $_REQUEST['_wp_http_referer'] );
		} else {
			$settings['shversion']      = ( ! empty( $settings['shversion'] ) && 2 == $settings['shversion'] ) ? 2 : 3;

			$settings['theme']          = ( ! empty( $settings['theme'] ) && isset( $this->themes[ $settings['theme'] ] ) ) ? strtolower( $settings['theme'] ) : $this->defaultsettings['theme'];

			$settings['loadallbrushes'] = ( ! empty( $settings['loadallbrushes'] ) ) ? 1 : 0;
			$settings['autolinks']      = ( ! empty( $settings['autolinks'] ) ) ? 1 : 0;
			$settings['collapse']       = ( ! empty( $settings['collapse'] ) ) ? 1 : 0;
			$settings['gutter']         = ( ! empty( $settings['gutter'] ) ) ? 1 : 0;
			$settings['light']          = ( ! empty( $settings['light'] ) ) ? 1 : 0;
			$settings['smarttabs']      = ( ! empty( $settings['smarttabs'] ) ) ? 1 : 0;
			$settings['toolbar']        = ( ! empty( $settings['toolbar'] ) ) ? 1 : 0; // May be overridden below
			$settings['wraplines']      = ( ! empty( $settings['wraplines'] ) ) ? 1 : 0; // 2.x only for now
			$settings['quickcode']      = ( ! empty( $settings['quickcode'] ) ) ? 1 : 0; // 3.x only for now

			// If the version changed, then force change the toolbar version setting
			if ( $settings['shversion'] != $this->settings['shversion'] ) {
				$settings['toolbar'] = ( 2 == $settings['shversion'] ) ? 1 : 0;
			}

			if ( 'true' != $settings['padlinenumbers'] && 'false' != $settings['padlinenumbers'] )
				$settings['padlinenumbers'] = (int) $settings['padlinenumbers'];

			$settings['classname']      = ( ! empty( $settings['classname'] ) ) ? preg_replace( '/[^ A-Za-z0-9_-]*/', '', $settings['classname'] ) : '';
			$settings['firstline']      = (int) ( ( ! empty( $settings['firstline'] ) ) ? $settings['firstline'] : $this->defaultsettings['firstline'] );
			$settings['tabsize']        = (int) ( ( ! empty( $settings['tabsize'] ) ) ? $settings['tabsize'] : $this->defaultsettings['tabsize'] );
		}

		return $settings;
	}
}


// Start this plugin once all other plugins are fully loaded
add_action( 'init', 'SyntaxHighlighter', 5 );
function SyntaxHighlighter() {
	global $SyntaxHighlighter;
	$SyntaxHighlighter = new SyntaxHighlighter();
}