@wp-playground/wordpress 3.1.1 → 3.1.3

package/index.js

@@ -1,458 +1,595 @@
-import { phpVars as m, joinPaths as o, dirname as b, basename as y, phpVar as u } from "@php-wasm/util";
-import { createMemoizedFetch as P, unzipFile as f } from "@wp-playground/common";
+import { phpVars as $, joinPaths as s, dirname as y, basename as b, phpVar as d } from "@php-wasm/util";
+import { createMemoizedFetch as P, unzipFile as p } from "@wp-playground/common";
 import { logger as g } from "@php-wasm/logger";
-import { sandboxedSpawnHandlerFactory as k, PHPRequestHandler as E, PHP as R, setPhpIniEntries as T, writeFiles as c, withPHPIniValues as S } from "@php-wasm/universal";
-const x = `<?php
+import { sandboxedSpawnHandlerFactory as T, PHPRequestHandler as E, PHP as v, setPhpIniEntries as R, writeFiles as f, withPHPIniValues as S } from "@php-wasm/universal";
+const m = `<?php
 
 /**
- * Rewrites the wp-config.php file to ensure specific constants are defined
- * with specific values.
- * 
- * Example:
- * 
- * \`\`\`php
- * <?php
- * define('WP_DEBUG', true);
- * // The third define() argument is also supported:
- * define('SAVEQUERIES', false, true);
- * 
- * // Expression
- * define(true ? 'WP_DEBUG_LOG' : 'WP_DEBUG_LOG', 123);
- * 
- * // Guarded expressions shouldn't be wrapped twice
- * if(!defined(1 ? 'A' : 'B')) {
- *     define(1 ? 'A' : 'B', 0);
- * }
- * 
- * // More advanced expression
- * define((function() use($x) {
- *     return [$x, 'a'];
- * })(), 123);
- * \`\`\`
- * 
- * Rewritten with
- * 
- *     $constants = [
- *        'WP_DEBUG' => false,
- *        'WP_DEBUG_LOG' => true,
- *        'SAVEQUERIES' => true,
- *        'NEW_CONSTANT' => "new constant",
- *     ];
- * 
- * \`\`\`php
- * <?php
- * define('WP_DEBUG_LOG',true);
- * define('NEW_CONSTANT','new constant');
- * ?><?php
- * define('WP_DEBUG',false);
- * // The third define() argument is also supported:
- * define('SAVEQUERIES',true, true);
- * 
- * // Expression
- * if(!defined($const ? 'WP_DEBUG_LOG' : 'WP_DEBUG_LOG')) {
- *      define($const ? 'WP_DEBUG_LOG' : 'WP_DEBUG_LOG', 123);
- * }
- * 
- * // Guarded expressions shouldn't be wrapped twice
- * if(!defined(1 ? 'A' : 'B')) {
- *     define(1 ? 'A' : 'B', 0);
- * }
- * 
- * // More advanced expression
- * if(!defined((function() use($x) {
- *    return [$x, 'a'];
- * })())) {
- *     define((function() use($x) {
- *         return [$x, 'a'];
- *     })(), 123);
- * }
- * \`\`\`
+ * Transforms the "wp-config.php" file.
  *
- * @param mixed $content              A PHP file content.
- * @param array $constants            An array of constants to define.
- * @param bool  $when_already_defined Optional. What to do if the constant is already defined.
- *                                    Possible values are:
- *                                      'rewrite' - Rewrite the constant, using the new value.
- *                                      'skip'    - Skip the definition, keeping the existing value.
- *                                    Default: 'rewrite'
- * @return string
+ * This parses the "wp-config.php" file contents into a token array and provides
+ * methods to modify it and serialize it back to a string with the modifications.
  */
-function rewrite_wp_config_to_define_constants($content, $constants = [], $when_already_defined = 'rewrite')
-{
-    $tokens = array_reverse(token_get_all($content));
-    $output = [];
-    $defined_expressions = [];
-
-    // Look through all the tokens and find the define calls
-    do {
-        $buffer = [];
-        $name_buffer = [];
-        $value_buffer = [];
-        $third_arg_buffer = [];
-
-        // Capture everything until the define call into output.
-        // Capturing the define call into a buffer.
-        // Example:
-        //     <?php echo 'a'; define  (
-        //     ^^^^^^^^^^^^^^^^^^^^^^
-        //           output   |buffer
-        while ($token = array_pop($tokens)) {
-            if (is_array($token) && $token[0] === T_STRING && (strtolower($token[1]) === 'define' || strtolower($token[1]) === 'defined')) {
-                $buffer[] = $token;
-                break;
-            }
-            $output[] = $token;
-        }
+class WP_Config_Transformer {
+	/**
+	 * The tokens of the wp-config.php file.
+	 *
+	 * @var array<array|string>
+	 */
+	private $tokens;
 
-        // Maybe we didn't find a define call and reached the end of the file?
-        if (!count($tokens)) {
-            break;
-        }
+	/**
+	 * Constructor.
+	 *
+	 * @param string $content The contents of the wp-config.php file.
+	 */
+	public function __construct( string $content ) {
+		$this->tokens = token_get_all( $content );
 
-        // Keep track of the "defined" expressions that are already accounted for
-        if($token[1] === 'defined') {
-            $output[] = $token;
-            $defined_expression = [];
-            $open_parenthesis = 0;
-            // Capture everything up to the opening parenthesis, including the parenthesis
-            // e.g. defined  (
-            //           ^^^^
-            while ($token = array_pop($tokens)) {
-                $output[] = $token;
-                if ($token === "(") {
-                    ++$open_parenthesis;
-                    break;
-                }
-            }
+		// Check if the file is a valid PHP file.
+		$is_valid_php_file = false;
+		foreach ( $this->tokens as $token ) {
+			if ( is_array( $token ) && T_OPEN_TAG === $token[0] ) {
+				$is_valid_php_file = true;
+				break;
+			}
+		}
+		if ( ! $is_valid_php_file ) {
+			throw new Exception( "The 'wp-config.php' file is not a valid PHP file." );
+		}
+	}
 
-            // Capture everything up to the closing parenthesis, including the parenthesis
-            // e.g. defined  (
-            //           ^^^^
-            while ($token = array_pop($tokens)) {
-                $output[] = $token;
-                if ($token === ")") {
-                    --$open_parenthesis;
-                }
-                if ($open_parenthesis === 0) {
-                    break;
-                }
-                $defined_expression[] = $token;
-            }
+	/**
+	 * Create a new config transformer instance from a file.
+	 *
+	 * @param string $path The path to the wp-config.php file.
+	 * @return self        The new config transformer instance.
+	 */
+	public static function from_file( string $path ): self {
+		if ( ! is_file( $path ) ) {
+			throw new Exception( sprintf( "The '%s' file does not exist.", $path ) );
+		}
+		return new self( file_get_contents( $path ) );
+	}
 
-            $defined_expressions[] = stringify_tokens(skip_whitespace($defined_expression));
-            continue;
-        }
+	/**
+	 * Get the transformed wp-config.php file contents.
+	 *
+	 * @return string The transformed wp-config.php file contents.
+	 */
+	public function to_string(): string {
+		$output = '';
+		foreach ( $this->tokens as $token ) {
+			$output .= is_array( $token ) ? $token[1] : $token;
+		}
+		return $output;
+	}
 
-        // Capture everything up to the opening parenthesis, including the parenthesis
-        // e.g. define  (
-        //           ^^^^
-        while ($token = array_pop($tokens)) {
-            $buffer[] = $token;
-            if ($token === "(") {
-                break;
-            }
-        }
+	/**
+	 * Save the transformed wp-config.php file contents to a file.
+	 *
+	 * @param string $path The path to the wp-config.php file.
+	 */
+	public function to_file( string $path ): void {
+		$result = file_put_contents( $path, $this->to_string() );
+		if ( false === $result ) {
+			throw new Exception( sprintf( "Failed to write to the '%s' file.", $path ) );
+		}
+	}
 
-        // Capture the first argument – it's the first expression after the opening
-        // parenthesis and before the comma:
-        // Examples:
-        //     define("WP_DEBUG", true);
-        //            ^^^^^^^^^^^
-        //
-        //     define(count([1,2]) > 2 ? 'WP_DEBUG' : 'FOO', true);
-        //            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-        $open_parenthesis = 0;
-        while ($token = array_pop($tokens)) {
-            $buffer[] = $token;
-            if ($token === "(" || $token === "[" || $token === "{") {
-                ++$open_parenthesis;
-            } elseif ($token === ")" || $token === "]" || $token === "}") {
-                --$open_parenthesis;
-            } elseif ($token === "," && $open_parenthesis === 0) {
-                break;
-            }
+	/**
+	 * Check if a constant is defined in the wp-config.php file.
+	 *
+	 * @param  string $name The name of the constant.
+	 * @return bool         True if the constant is defined, false otherwise.
+	 */
+	public function constant_exists( string $name ): bool {
+		foreach ( $this->tokens as $i => $token ) {
+			$is_string_token = is_array( $token ) && T_STRING === $token[0];
+			if ( $is_string_token && 'define' === strtolower( $token[1] ) ) {
+				$args       = $this->collect_function_call_argument_locations( $i );
+				$const_name = $this->evaluate_constant_name(
+					array_slice( $this->tokens, $args[0][0], $args[0][1] )
+				);
+				if ( $name === $const_name ) {
+					return true;
+				}
+			}
+		}
+		return false;
+	}
 
-            // Don't capture the comma as a part of the constant name
-            $name_buffer[] = $token;
-        }
+	/**
+	 * Define a constant in the wp-config.php file.
+	 *
+	 * @param string $name  The name of the constant.
+	 * @param mixed  $value The value of the constant.
+	 */
+	public function define_constant( string $name, $value ): void {
+		// Tokenize the new constant value for insertion in the tokens array.
+		$definition_tokens = token_get_all(
+			sprintf(
+				"<?php define( %s, %s );\\n",
+				var_export( $name, true ),
+				var_export( $value, true )
+			)
+		);
 
-        // Capture everything until the closing parenthesis
-        //     define("WP_DEBUG", true);
-        //                       ^^^^^^
-        $open_parenthesis = 0;
-        $is_second_argument = true;
-        while ($token = array_pop($tokens)) {
-            $buffer[] = $token;
-            if ($token === ")" && $open_parenthesis === 0) {
-                // Final parenthesis of the define call.
-                break;
-            } else if ($token === "(" || $token === "[" || $token === "{") {
-                ++$open_parenthesis;
-            } elseif ($token === ")" || $token === "]" || $token === "}") {
-                --$open_parenthesis;
-            } elseif ($token === "," && $open_parenthesis === 0) {
-                // This define call has more than 2 arguments! The third one is the
-                // boolean value indicating $is_case_insensitive. Let's continue capturing
-                // to $third_arg_buffer.
-                $is_second_argument = false;
-            }
-            if ($is_second_argument) {
-                $value_buffer[] = $token;
-            } else {
-                $third_arg_buffer[] = $token;
-            }
-        }
+		// Full constant definition statement, e.g.: define( 'WP_DEBUG', true );\\n
+		$define_tokens = array_slice( $definition_tokens, 1 );
 
-        // Capture until the semicolon
-        //     define("WP_DEBUG", true)  ;
-        //                             ^^^
-        while ($token = array_pop($tokens)) {
-            $buffer[] = $token;
-            if ($token === ";") {
-                break;
-            }
-        }
+		// The value of the constant, e.g.: "my-database-name"
+		$value_tokens = array_slice( $definition_tokens, 7, -4 );
 
-        // Decide whether $name_buffer is a constant name or an expression
-        $name_token = null;
-        $name_token_index = $token;
-        $name_is_literal = true;
-        foreach ($name_buffer as $k => $token) {
-            if (is_array($token)) {
-                if ($token[0] === T_WHITESPACE || $token[0] === T_COMMENT || $token[0] === T_DOC_COMMENT) {
-                    continue;
-                } else if ($token[0] === T_STRING || $token[0] === T_CONSTANT_ENCAPSED_STRING) {
-                    $name_token = $token;
-                    $name_token_index = $k;
-                } else {
-                    $name_is_literal = false;
-                    break;
-                }
-            } else if ($token !== "(" && $token !== ")") {
-                $name_is_literal = false;
-                break;
-            }
-        }
+		// Collect all locations where the constant value needs to be updated.
+		$updates = array();
+		foreach ( $this->tokens as $i => $token ) {
+			$is_string_token = is_array( $token ) && T_STRING === $token[0];
+			if ( $is_string_token && 'define' === strtolower( $token[1] ) ) {
+				$args       = $this->collect_function_call_argument_locations( $i );
+				$const_name = $this->evaluate_constant_name(
+					array_slice( $this->tokens, $args[0][0], $args[0][1] )
+				);
 
-        // We can't handle expressions as constant names. Let's wrap that define
-        // call in an if(!defined()) statement, just in case it collides with
-        // a constant name.
-        if (!$name_is_literal) {
-            // Ensure the defined expression is not already accounted for
-            foreach ($defined_expressions as $defined_expression) {
-                if ($defined_expression === stringify_tokens(skip_whitespace($name_buffer))) {
-                    $output = array_merge($output, $buffer);
-                    continue 2;
-                }
-            }
-            $output = array_merge(
-                $output,
-                ["if(!defined("],
-                $name_buffer,
-                [")) {\\n     "],
-                ['define('],
-                $name_buffer,
-                [','],
-                $value_buffer,
-                $third_arg_buffer,
-                [");"],
-                ["\\n}\\n"]
-            );
-            continue;
-        }
+				if ( $name === $const_name ) {
+					$updates[] = $args[1];
+				}
+			}
+		}
 
-        // Yay, we have a literal constant name in the buffer now. Let's
-        // get its value:
-        $name = eval('return ' . $name_token[1] . ';');
+		// Modify the token array to define the constant. Apply updates in reverse
+		// order, so splices at earlier positions don't shift indices after them.
+		for ( $i = count( $updates ) - 1; $i >= 0; $i -= 1 ) {
+			list ( $value_start, $value_length ) = $updates[ $i ];
+			array_splice( $this->tokens, $value_start, $value_length, $value_tokens );
+		}
 
-        // If the constant name is not in the list of constants we're looking,
-        // we can ignore it.
-        if (!array_key_exists($name, $constants)) {
-            $output = array_merge($output, $buffer);
-            continue;
-        }
+		// If it's a new constant, inject it at the anchor location.
+		if ( 0 === count( $updates ) ) {
+			$anchor = $this->get_new_constant_location();
+			array_splice( $this->tokens, $anchor, 0, $define_tokens );
 
-        // If "$when_already_defined" is set to 'skip', ignore the definition, and
-		// remove the constant from the list so it doesn't get added to the output.
-        if ('skip' === $when_already_defined) {
-            $output = array_merge($output, $buffer);
-            unset($constants[$name]);
-            continue;
-        }
+			/*
+			 * Ensure at least one newline (one "\\n") before the new constant.
+			 * This must be done after inserting the constant definition in order
+			 * to avoid shifting the anchor location when a new token is inserted.
+			 */
+			$this->ensure_newlines( $anchor - 1, 1 );
+		}
+	}
 
-        // We now have a define() call that defines a constant we're looking for.
-        // Let's rewrite its value to the one 
-        $output = array_merge(
-            $output,
-            ['define('],
-            $name_buffer,
-            [','],
-            [var_export($constants[$name], true)],
-            $third_arg_buffer,
-            [");"]
-        );
+	/**
+	 * Define multiple constants in the wp-config.php file.
+	 *
+	 * @param array<string, mixed> $constants An array of name-value pairs of constants to define.
+	 */
+	public function define_constants( array $constants ): void {
+		foreach ( $constants as $name => $value ) {
+			$this->define_constant( $name, $value );
+		}
+	}
 
-        // Remove the constant from the list so we can process any remaining
-        // constants later.
-        unset($constants[$name]);
-    } while (count($tokens));
-
-    // Add any constants that weren't found in the file
-    if (count($constants)) {
-        $prepend = [
-            "<?php \\n"
-        ];
-        foreach ($constants as $name => $value) {
-            $prepend = array_merge(
-                $prepend,
-                [
-                    "define(",
-                    var_export($name, true),
-                    ',',
-                    var_export($value, true),
-                    ");\\n"
-                ]
-            );
-        }
-        $prepend[] = "?>";
-        $output = array_merge(
-            $prepend,
-            $output
-        );
-    }
+	/**
+	 * Inject code block into the wp-config.php file.
+	 *
+	 * @param string $code The code to inject.
+	 */
+	public function inject_code_block( string $code ): void {
+		// Tokenize the injected code for insertion in the token array.
+		$tokens      = token_get_all( sprintf( '<?php %s', trim( $code ) ) );
+		$code_tokens = array_slice( $tokens, 1 );
 
-    // Translate the output tokens back into a string
-    return stringify_tokens($output);
-}
+		// Inject the code at the anchor location.
+		$anchor = $this->get_injected_code_location();
+		array_splice( $this->tokens, $anchor, 0, $code_tokens );
 
-function stringify_tokens($tokens) {
-    $output = '';
-    foreach ($tokens as $token) {
-        if (is_array($token)) {
-            $output .= $token[1];
-        } else {
-            $output .= $token;
-        }
-    }
-    return $output;
-}
+		/*
+		 * Ensure empty line before and after the code block (at least two "\\n").
+		 * This must be done after inserting the injected code, and the location
+		 * AFTER must be updated prior to the location BEFORE, in order to avoid
+		 * shifting the anchor location when a new token is inserted.
+		 */
+		$this->ensure_newlines( $anchor + count( $code_tokens ), 2 );
+		$this->ensure_newlines( $anchor - 1, 2 );
+	}
 
-function skip_whitespace($tokens) {
-    $output = [];
-    foreach ($tokens as $token) {
-        if (is_array($token) && ($token[0] === T_WHITESPACE || $token[0] === T_COMMENT || $token[0] === T_DOC_COMMENT)) {
-            continue;
-        }
-        $output[] = $token;
-    }
-    return $output;
+	/**
+	 * Remove code block defined by two comment fragments from the wp-config.php file.
+	 *
+	 * @param string $from_comment_fragment A comment fragment from which to remove the code.
+	 * @param string $to_comment_fragment   A comment fragment to which to remove the code.
+	 */
+	public function remove_code_block( string $from_comment_fragment, string $to_comment_fragment ): void {
+		$start = $this->find_first_token_location( T_COMMENT, $from_comment_fragment );
+		$end   = $this->find_first_token_location( T_COMMENT, $to_comment_fragment );
+		if ( null === $start || null === $end ) {
+			return;
+		}
+
+		// Remove the code, including the comment fragments.
+		array_splice( $this->tokens, $start, $end - $start + 1 );
+
+		// If previous and next tokens are whitespace, merge them.
+		$prev = $this->tokens[ $start - 1 ];
+		$next = $this->tokens[ $start ] ?? null;
+		if (
+			is_array( $prev ) && T_WHITESPACE === $prev[0]
+			&& is_array( $next ) && T_WHITESPACE === $next[0]
+		) {
+			$this->tokens[ $start - 1 ][1] = $prev[1] . $next[1];
+			array_splice( $this->tokens, $start, 1 );
+		}
+
+		// Remove up to two empty lines (before & after), keeping at least one.
+		$token = $this->tokens[ $start - 1 ];
+		if ( is_array( $token ) && T_WHITESPACE === $token[0] ) {
+			$newlines = substr_count( $token[1], "\\n" );
+			if ( $newlines > 2 ) {
+				$limit = min( $newlines - 2, 4 );
+				$value = $token[1];
+				for ( $i = 0; $limit > 0; $i += 1 ) {
+					if ( "\\n" === $value[ $i ] ) {
+						$value  = substr_replace( $value, '', $i, 1 );
+						$limit -= 1;
+					}
+				}
+				$this->tokens[ $start - 1 ][1] = $value;
+			}
+		}
+	}
+
+	/**
+	 * Parse arguments of a function call and collect their locations.
+	 *
+	 * @param  int $start             The location of the first token of the function call.
+	 * @return array<array<int, int>> The arguments of the function call.
+	 */
+	private function collect_function_call_argument_locations( int $start ): array {
+		// Find location of the opening parenthesis after the function name.
+		$i = $start;
+		while ( '(' !== $this->tokens[ $i ] ) {
+			$i += 1;
+		}
+		$i += 1;
+
+		// Collect all function call argument locations.
+		$args         = array();
+		$arg_start    = $this->skip_whitespace_and_comments( $i );
+		$parens_level = 0;
+		for ( $i = $arg_start; $i < count( $this->tokens ); $i += 1 ) {
+			// Skip whitespace and comments, but preserve the index of the last
+			// non-whitespace token to calculate the exact argument boundaries.
+			$prev_i = $i;
+			$i      = $this->skip_whitespace_and_comments( $i );
+			$token  = $this->tokens[ $i ];
+
+			if ( 0 === $parens_level && ( ',' === $token || ')' === $token ) ) {
+				$args[] = array( $arg_start, $prev_i - $arg_start );
+				if ( ',' === $token ) {
+					// Start of the next argument.
+					$arg_start = $this->skip_whitespace_and_comments( $i + 1 );
+					$i         = $arg_start;
+				} else {
+					// End of the argument list.
+					break;
+				}
+			} elseif ( '(' === $token || '[' === $token || '{' === $token ) {
+				$parens_level += 1;
+			} elseif ( ')' === $token || ']' === $token || '}' === $token ) {
+				$parens_level -= 1;
+			}
+		}
+		return $args;
+	}
+
+	/**
+	 * Evaluate the constant name value from its tokens.
+	 *
+	 * @param  array $name_tokens The tokens containing the constant name.
+	 * @return string|null        The evaluated constant name.
+	 */
+	private function evaluate_constant_name( array $name_tokens ): ?string {
+		// Decide whether the array represents a constant name or an expression.
+		$name_token = null;
+		foreach ( $name_tokens as $token ) {
+			if ( $this->is_whitespace( $token ) ) {
+				continue;
+			}
+			if ( is_array( $token ) ) {
+				if ( T_STRING === $token[0] || T_CONSTANT_ENCAPSED_STRING === $token[0] ) {
+					$name_token = $token;
+				} else {
+					return null;
+				}
+			} elseif ( '(' !== $token && ')' !== $token ) {
+				return null;
+			}
+		}
+
+		if ( null === $name_token ) {
+			return null;
+		}
+
+		// Get the constant name value.
+		return eval( 'return ' . $name_token[1] . ';' );
+	}
+
+	/**
+	 * Skip whitespace and comment tokens and return the location of the first
+	 * non-whitespace and non-comment token after the specified start location.
+	 *
+	 * @param  int $start The start location in the token array.
+	 * @return int        The location of the first non-whitespace and non-comment token.
+	 */
+	private function skip_whitespace_and_comments( int $start ): int {
+		for ( $i = $start; $i < count( $this->tokens ); $i += 1 ) {
+			if ( $this->is_whitespace( $this->tokens[ $i ] ) ) {
+				continue;
+			}
+			break;
+		}
+		return $i;
+	}
+
+	/**
+	 * Ensure minimum number of newlines are present at the given index.
+	 *
+	 * @param int $index The index of the token to ensure newlines.
+	 * @param int $count The number of newlines that should be present.
+	 */
+	private function ensure_newlines( int $index, int $count ): void {
+		$token = $this->tokens[ $index ] ?? null;
+		if ( is_array( $token ) && ( T_WHITESPACE === $token[0] || T_OPEN_TAG === $token[0] ) ) {
+			$newlines = substr_count( $token[1], "\\n" );
+			if ( $newlines < $count ) {
+				$this->tokens[ $index ][1] .= str_repeat( "\\n", $count - $newlines );
+			}
+		} else {
+			$new_token = array( T_WHITESPACE, str_repeat( "\\n", $count ) );
+			array_splice( $this->tokens, $index, 0, array( $new_token ) );
+		}
+	}
+
+	/**
+	 * Get the location to inject new constant definitions in the token array.
+	 *
+	 * @return int The location for new constant definitions in the token array.
+	 */
+	private function get_new_constant_location(): int {
+		// First try to find the "That's all, stop editing!" comment.
+		$anchor = $this->find_first_token_location( T_COMMENT, "That's all, stop editing!" );
+		if ( null !== $anchor ) {
+			return $anchor;
+		}
+
+		// If not found, try the "Absolute path to the WordPress directory." doc comment.
+		$anchor = $this->find_first_token_location( T_DOC_COMMENT, 'Absolute path to the WordPress directory.' );
+		if ( null !== $anchor ) {
+			return $anchor;
+		}
+
+		// If not found, try the "Sets up WordPress vars and included files." doc comment.
+		$anchor = $this->find_first_token_location( T_DOC_COMMENT, 'Sets up WordPress vars and included files.' );
+		if ( null !== $anchor ) {
+			return $anchor;
+		}
+
+		// If not found, try "require_once ABSPATH . 'wp-settings.php';".
+		$anchor = $this->find_first_token_location( T_REQUIRE_ONCE );
+		if ( null !== $anchor ) {
+			return $anchor;
+		}
+
+		// If not found, fall back to the PHP opening tag.
+		$open_tag_anchor = $this->find_first_token_location( T_OPEN_TAG );
+		if ( null !== $open_tag_anchor ) {
+			return $open_tag_anchor + 1;
+		}
+
+		// If we still don't have an anchor, the file is not a valid PHP file.
+		throw new Exception( "The 'wp-config.php' file is not a valid PHP file." );
+	}
+
+	/**
+	 * Get the location to inject new code in the token array.
+	 *
+	 * @return int The location for injected code in the token array.
+	 */
+	private function get_injected_code_location(): int {
+		// First try to find the "/** Sets up WordPress vars and included files. */" comment.
+		$anchor = $this->find_first_token_location( T_DOC_COMMENT, 'Sets up WordPress vars and included files.' );
+		if ( null !== $anchor ) {
+			return $anchor;
+		}
+
+		// If not found, try "require_once ABSPATH . 'wp-settings.php';".
+		$anchor = $this->find_require_wp_settings_location();
+		if ( null !== $anchor ) {
+			return $anchor;
+		}
+
+		// If not found, fall back to the PHP opening tag.
+		$open_tag_anchor = $this->find_first_token_location( T_OPEN_TAG );
+		if ( null !== $open_tag_anchor ) {
+			return $open_tag_anchor + 1;
+		}
+
+		// If we still don't have an anchor, the file is not a valid PHP file.
+		throw new Exception( "The 'wp-config.php' file is not a valid PHP file." );
+	}
+
+	/**
+	 * Find location of the "wp-settings.php" require statement in the token array.
+	 *
+	 * This method searches for the following statement:
+	 *
+	 *   require_once ABSPATH . 'wp-settings.php';
+	 *
+	 * @return int|null The location of the require statement.
+	 */
+	private function find_require_wp_settings_location(): ?int {
+		$require_anchor = $this->find_first_token_location( T_REQUIRE_ONCE );
+		if ( null === $require_anchor ) {
+			return null;
+		}
+
+		$abspath = $this->tokens[ $require_anchor + 2 ] ?? null;
+		$path    = $this->tokens[ $require_anchor + 6 ] ?? null;
+		if (
+			( is_array( $abspath ) && 'ABSPATH' === $abspath[1] )
+			&& ( is_array( $path ) && "'wp-settings.php'" === $path[1] )
+		) {
+			return $require_anchor;
+		}
+		return null;
+	}
+
+	/**
+	 * Find location of the first token of a given type in the token array.
+	 *
+	 * @param  int    $type   The type of the token.
+	 * @param  string $search Optional. A search string to match against the token content.
+	 * @return int|null       The location of the first token.
+	 */
+	private function find_first_token_location( int $type, ?string $search = null ): ?int {
+		foreach ( $this->tokens as $i => $token ) {
+			if ( is_array( $token ) && $type === $token[0] ) {
+				if ( null === $search || false !== strpos( $token[1], $search ) ) {
+					return $i;
+				}
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * Check if a token is whitespace or a comment.
+	 *
+	 * @param  array|string $token The token to check.
+	 * @return bool                True if the token is whitespace or a comment.
+	 */
+	private function is_whitespace( $token ): bool {
+		return is_array( $token )
+			&& ( T_WHITESPACE === $token[0] || T_COMMENT === $token[0] || T_DOC_COMMENT === $token[0] );
+	}
 }
 `;
-async function v(e, n, t, i = "rewrite") {
-  const r = m({ wpConfigPath: n, constants: t, whenAlreadyDefined: i });
-  if ((await e.run({
-    code: `<?php ob_start(); ?>
-			${x}
-			$wp_config_path = ${r.wpConfigPath};
-			$wp_config = file_get_contents($wp_config_path);
-			$new_wp_config = rewrite_wp_config_to_define_constants($wp_config, ${r.constants}, ${r.whenAlreadyDefined});
-			$return_value = file_put_contents($wp_config_path, $new_wp_config);
-			ob_clean();
-			echo false === $return_value ? '0' : '1';
-			ob_end_flush();
-		`
-  })).text !== "1")
-    throw new Error("Failed to rewrite constants in wp-config.php.");
-}
-async function I(e, n) {
-  const t = o(n, "wp-config.php"), i = {
+async function I(t, e) {
+  const n = s(e, "wp-config.php"), i = {
     DB_NAME: "wordpress"
   };
-  !e.fileExists(t) && e.fileExists(o(n, "wp-config-sample.php")) && await e.writeFile(
-    t,
-    await e.readFileAsBuffer(
-      o(n, "wp-config-sample.php")
+  if (!t.fileExists(n) && t.fileExists(s(e, "wp-config-sample.php")) && await t.writeFile(
+    n,
+    await t.readFileAsBuffer(
+      s(e, "wp-config-sample.php")
     )
-  ), await v(e, t, i, "skip");
+  ), !t.fileExists(n))
+    return;
+  const a = $({ wpConfigPath: n, constants: i });
+  if ((await t.run({
+    code: `${m}
+		$wp_config_path = ${a.wpConfigPath};
+		$transformer    = WP_Config_Transformer::from_file($wp_config_path);
+		foreach ( ${a.constants} as $name => $value ) {
+			if ( ! $transformer->constant_exists( $name ) ) {
+				$transformer->define_constant($name, $value);
+			}
+		}
+		$transformer->to_file($wp_config_path);
+		`
+  })).errors.length > 0)
+    throw new Error("Failed to auto-configure wp-config.php.");
+}
+async function B(t, e, n) {
+  const i = $({ wpConfigPath: e, constants: n });
+  if ((await t.run({
+    code: `${m}
+		$wp_config_path = ${i.wpConfigPath};
+		$transformer = WP_Config_Transformer::from_file($wp_config_path);
+		$transformer->define_constants(${i.constants});
+		$transformer->to_file($wp_config_path);
+		`
+  })).errors.length > 0)
+    throw new Error("Failed to rewrite constants in wp-config.php.");
 }
-async function V(e) {
-  const n = await U(e);
-  return await L(n, e), n;
+async function Q(t) {
+  const e = await C(t);
+  return await x(e, t), e;
 }
-async function L(e, n) {
-  var d, a;
-  const t = await e.getPrimaryPhp();
-  if ((d = n.hooks) != null && d.beforeWordPressFiles && await n.hooks.beforeWordPressFiles(t), n.wordPressZip && await N(t, await n.wordPressZip), n.constants)
-    for (const l in n.constants)
-      t.defineConstant(l, n.constants[l]);
-  n.dataSqlPath && (t.defineConstant("DB_DIR", b(n.dataSqlPath)), t.defineConstant("DB_FILE", y(n.dataSqlPath))), t.defineConstant("WP_HOME", n.siteUrl), t.defineConstant("WP_SITEURL", n.siteUrl), await I(t, e.documentRoot), (a = n.hooks) != null && a.beforeDatabaseSetup && await n.hooks.beforeDatabaseSetup(t);
+async function x(t, e) {
+  var c, r;
+  const n = await t.getPrimaryPhp();
+  if ((c = e.hooks) != null && c.beforeWordPressFiles && await e.hooks.beforeWordPressFiles(n), e.wordPressZip && await N(n, await e.wordPressZip), e.constants)
+    for (const l in e.constants)
+      n.defineConstant(l, e.constants[l]);
+  e.dataSqlPath && (n.defineConstant("DB_DIR", y(e.dataSqlPath)), n.defineConstant("DB_FILE", b(e.dataSqlPath))), n.defineConstant("WP_HOME", e.siteUrl), n.defineConstant("WP_SITEURL", e.siteUrl), await I(n, t.documentRoot), (r = e.hooks) != null && r.beforeDatabaseSetup && await e.hooks.beforeDatabaseSetup(n);
   let i = !1;
-  n.sqliteIntegrationPluginZip && (i = !0, await F(
-    t,
-    await n.sqliteIntegrationPluginZip
+  e.sqliteIntegrationPluginZip && (i = !0, await F(
+    n,
+    await e.sqliteIntegrationPluginZip
   ));
-  const r = n.wordpressInstallMode ?? "download-and-install", s = !!n.dataSqlPath;
+  const a = e.wordpressInstallMode ?? "download-and-install", o = !!e.dataSqlPath;
   if (["download-and-install", "install-from-existing-files"].includes(
-    r
+    a
   )) {
-    await _(e, {
+    await h(t, {
       usesSqlite: i,
-      hasCustomDatabasePath: s
+      hasCustomDatabasePath: o
     });
     try {
-      await h(t);
+      await _(n);
     } catch (l) {
-      throw s || await p(e), l;
+      throw o || await u(t), l;
     }
-    s || await p(e);
-  } else if (r === "install-from-existing-files-if-needed") {
-    if (await _(e, {
+    o || await u(t);
+  } else if (a === "install-from-existing-files-if-needed") {
+    if (await h(t, {
       usesSqlite: i,
-      hasCustomDatabasePath: s
-    }), !await $(t))
+      hasCustomDatabasePath: o
+    }), !await w(n))
       try {
-        await h(t);
+        await _(n);
       } catch (l) {
-        throw s || await p(e), l;
+        throw o || await u(t), l;
       }
-    s || await p(e);
+    o || await u(t);
   }
-  return e;
+  return t;
 }
-async function _(e, {
-  usesSqlite: n,
-  hasCustomDatabasePath: t
+async function h(t, {
+  usesSqlite: e,
+  hasCustomDatabasePath: n
 }) {
-  const i = await e.getPrimaryPhp();
+  const i = await t.getPrimaryPhp();
   if (i.isFile("/internal/shared/preload/0-sqlite.php"))
     return;
-  const r = o(
-    e.documentRoot,
+  const a = s(
+    t.documentRoot,
     "wp-content/mu-plugins/sqlite-database-integration"
   );
-  if (!i.isDir(r) && !n && !t)
+  if (!i.isDir(a) && !e && !n)
     throw new Error("Error connecting to the MySQL database.");
 }
-async function p(e) {
-  const n = await e.getPrimaryPhp();
-  if (await C(n))
+async function u(t) {
+  const e = await t.getPrimaryPhp();
+  if (await O(e))
     return;
-  if (n.isFile("/internal/shared/preload/0-sqlite.php"))
+  if (e.isFile("/internal/shared/preload/0-sqlite.php"))
     throw new Error("Error connecting to the SQLite database.");
-  const i = o(
-    e.documentRoot,
+  const i = s(
+    t.documentRoot,
     "wp-content/mu-plugins/sqlite-database-integration"
   );
-  throw n.isDir(i) ? new Error("Error connecting to the SQLite database.") : new Error("Error connecting to the MySQL database.");
+  throw e.isDir(i) ? new Error("Error connecting to the SQLite database.") : new Error("Error connecting to the MySQL database.");
 }
-async function U(e) {
-  const n = e.spawnHandler ?? k;
-  async function t(r, s = !1) {
-    const d = await e.createPhpRuntime(s), a = new R(d);
-    if (e.sapiName && a.setSapiName(e.sapiName), r && (a.requestHandler = r), e.phpIniEntries && T(a, e.phpIniEntries), a.defineConstant("WP_SQLITE_AST_DRIVER", !0), e.constants)
-      for (const l in e.constants)
-        a.defineConstant(l, e.constants[l]);
-    return s && /**
+async function C(t) {
+  const e = t.spawnHandler ?? T;
+  async function n(a, o = !1) {
+    const c = await t.createPhpRuntime(o), r = new v(c);
+    if (t.sapiName && r.setSapiName(t.sapiName), a && (r.requestHandler = a), t.phpIniEntries && R(r, t.phpIniEntries), r.defineConstant("WP_SQLITE_AST_DRIVER", !0), t.constants)
+      for (const l in t.constants)
+        r.defineConstant(l, t.constants[l]);
+    return o && /**
     * Only the first PHP instance of the first worker created
     * during WordPress boot writes these files – otherwise we'll keep
     * overwriting them with concurrent writers living in other worker
@@ -462,45 +599,45 @@ async function U(e) {
     * mechanism. It works, because secondary workers are only booted
     * once the primary worker has fully booted.
     */
-    !a.isFile("/internal/.boot-files-written") && (await A(a), await c(a, "/", e.createFiles || {}), await q(
-      a,
-      o(new URL(e.siteUrl).pathname, "phpinfo.php")
-    ), await c(a, "/internal", {
+    !r.isFile("/internal/.boot-files-written") && (await U(r), await f(r, "/", t.createFiles || {}), await W(
+      r,
+      s(new URL(t.siteUrl).pathname, "phpinfo.php")
+    ), await f(r, "/internal", {
       ".boot-files-written": ""
-    })), n && await a.setSpawnHandler(
-      n(
-        r ? () => r.instanceManager.acquirePHPInstance() : void 0
+    })), e && await r.setSpawnHandler(
+      e(
+        a ? () => a.instanceManager.acquirePHPInstance() : void 0
       )
-    ), a.enableRuntimeRotation({
-      recreateRuntime: e.createPhpRuntime,
+    ), r.enableRuntimeRotation({
+      recreateRuntime: t.createPhpRuntime,
       maxRequests: 400
-    }), e.onPHPInstanceCreated && await e.onPHPInstanceCreated(a, { isPrimary: s }), a;
+    }), t.onPHPInstanceCreated && await t.onPHPInstanceCreated(r, { isPrimary: o }), r;
   }
   const i = new E({
-    documentRoot: e.documentRoot || "/wordpress",
-    absoluteUrl: e.siteUrl,
-    rewriteRules: D,
-    pathAliases: e.pathAliases,
-    getFileNotFoundAction: e.getFileNotFoundAction ?? W,
-    cookieStore: e.cookieStore,
+    documentRoot: t.documentRoot || "/wordpress",
+    absoluteUrl: t.siteUrl,
+    rewriteRules: q,
+    pathAliases: t.pathAliases,
+    getFileNotFoundAction: t.getFileNotFoundAction ?? L,
+    cookieStore: t.cookieStore,
     /**
      * If maxPhpInstances is 1, the PHPRequestHandler constructor needs
      * a PHP instance. Internally, it creates a SinglePHPInstanceManager
      * and uses the same PHP instance to handle all requests.
      */
-    php: e.maxPhpInstances === 1 ? await t(void 0, !0) : void 0,
+    php: t.maxPhpInstances === 1 ? await n(void 0, !0) : void 0,
     /**
      * If maxPhpInstances is not 1, the PHPRequestHandler constructor needs
      * a PHP factory function. Internally, it creates a PHPProcessManager that
      * maintains a pool of reusable PHP instances.
      */
-    phpFactory: e.maxPhpInstances !== 1 ? async ({ isPrimary: r }) => t(i, r) : void 0,
-    maxPhpInstances: e.maxPhpInstances
+    phpFactory: t.maxPhpInstances !== 1 ? async ({ isPrimary: a }) => n(i, a) : void 0,
+    maxPhpInstances: t.maxPhpInstances
   });
   return i;
 }
-async function $(e) {
-  return (await e.run({
+async function w(t) {
+  return (await t.run({
     code: `<?php
 			ob_start();
 			$wp_load = getenv('DOCUMENT_ROOT') . '/wp-load.php';
@@ -514,19 +651,19 @@ async function $(e) {
 			ob_end_flush();
 		`,
     env: {
-      DOCUMENT_ROOT: e.documentRoot
+      DOCUMENT_ROOT: t.documentRoot
     }
   })).text === "1";
 }
-async function h(e) {
+async function _(t) {
   var i;
-  const n = await S(
-    e,
+  const e = await S(
+    t,
     {
       disable_functions: "fsockopen",
       allow_url_fopen: "0"
     },
-    async () => await e.request({
+    async () => await t.request({
       url: "/wp-admin/install.php?step=2",
       method: "POST",
       body: {
@@ -543,14 +680,14 @@ async function h(e) {
       }
     })
   );
-  if (!await $(e))
+  if (!await w(t))
     throw new Error(
-      `Failed to install WordPress – installer responded with "${(i = n.text) == null ? void 0 : i.substring(
+      `Failed to install WordPress – installer responded with "${(i = e.text) == null ? void 0 : i.substring(
         0,
         100
       )}"`
     );
-  (await e.run({
+  (await t.run({
     code: `<?php
 			ob_start();
 			$wp_load = getenv('DOCUMENT_ROOT') . '/wp-load.php';
@@ -573,18 +710,18 @@ async function h(e) {
 			ob_end_flush();
 		`,
     env: {
-      DOCUMENT_ROOT: e.documentRoot
+      DOCUMENT_ROOT: t.documentRoot
     }
   })).text !== "1" && g.warn("Failed to default to pretty permalinks after WP install.");
 }
-function W(e) {
+function L(t) {
   return {
     type: "internal-redirect",
     uri: "/index.php"
   };
 }
-async function C(e) {
-  return (await e.run({
+async function O(t) {
+  return (await t.run({
     code: `<?php
 			ob_start();
 			$wp_load = getenv('DOCUMENT_ROOT') . '/wp-load.php';
@@ -598,35 +735,35 @@ async function C(e) {
 			ob_end_flush();
 		`,
     env: {
-      DOCUMENT_ROOT: e.documentRoot
+      DOCUMENT_ROOT: t.documentRoot
     }
   })).text === "1";
 }
-async function j(e) {
-  const { php: n, reap: t } = await e.instanceManager.acquirePHPInstance();
+async function V(t) {
+  const { php: e, reap: n } = await t.instanceManager.acquirePHPInstance();
   try {
-    const r = (await n.run({
+    const a = (await e.run({
       code: `<?php
-				require '${e.documentRoot}/wp-includes/version.php';
+				require '${t.documentRoot}/wp-includes/version.php';
 				echo $wp_version;
 			`
     })).text;
-    if (!r)
+    if (!a)
       throw new Error("Unable to read loaded WordPress version.");
-    return O(r);
+    return A(a);
   } finally {
-    t();
+    n();
   }
 }
-function O(e) {
-  if (/-(alpha|beta|RC)\d*-\d+$/.test(e))
+function A(t) {
+  if (/-(alpha|beta|RC)\d*-\d+$/.test(t))
     return "trunk";
-  if (/-(beta|RC)\d*$/.test(e))
+  if (/-(beta|RC)\d*$/.test(t))
     return "beta";
-  const i = e.match(/^(\d+\.\d+)(?:\.\d+)?$/);
-  return i !== null ? i[1] : e;
+  const i = t.match(/^(\d+\.\d+)(?:\.\d+)?$/);
+  return i !== null ? i[1] : t;
 }
-const D = [
+const q = [
   /**
    * Substitutes the multisite WordPress rewrite rule:
    *
@@ -642,8 +779,8 @@ const D = [
     replacement: "$2"
   }
 ];
-async function A(e) {
-  await e.mkdir("/internal/shared/mu-plugins"), await e.writeFile(
+async function U(t) {
+  await t.mkdir("/internal/shared/mu-plugins"), await t.writeFile(
     "/internal/shared/preload/env.php",
     `<?php
 
@@ -673,7 +810,7 @@ async function A(e) {
             }
         }
     `
-  ), await e.writeFile(
+  ), await t.writeFile(
     "/internal/shared/mu-plugins/1-auto-login.php",
     `<?php
 		/**
@@ -830,7 +967,7 @@ async function A(e) {
 			return $interval;
 		});
 		`
-  ), await e.writeFile(
+  ), await t.writeFile(
     "/internal/shared/mu-plugins/0-playground.php",
     `<?php
         // Needed because gethostbyname( 'wordpress.org' ) returns
@@ -875,7 +1012,7 @@ async function A(e) {
         define('ERROR_LOG_FILE', $log_file);
         ini_set('error_log', $log_file);
         ?>`
-  ), await e.writeFile(
+  ), await t.writeFile(
     "/internal/shared/mu-plugins/sitemap-redirect.php",
     `<?php
 		/**
@@ -902,7 +1039,7 @@ async function A(e) {
 			}
 		}
 		`
-  ), await e.writeFile(
+  ), await t.writeFile(
     "/internal/shared/preload/error-handler.php",
     `<?php
 		(function() {
@@ -955,13 +1092,13 @@ async function A(e) {
 		})();`
   );
 }
-async function q(e, n = "/phpinfo.php") {
-  await e.writeFile(
+async function W(t, e = "/phpinfo.php") {
+  await t.writeFile(
     "/internal/shared/preload/phpinfo.php",
     `<?php
     // Render PHPInfo if the requested page is /phpinfo.php
-    if ( isset($_SERVER['REQUEST_URI']) && ${u(
-      n
+    if ( isset($_SERVER['REQUEST_URI']) && ${d(
+      e
     )} === $_SERVER['REQUEST_URI'] ) {
         phpinfo();
         exit;
@@ -969,29 +1106,29 @@ async function q(e, n = "/phpinfo.php") {
     `
   );
 }
-async function F(e, n) {
-  await e.isDir("/tmp/sqlite-database-integration") && await e.rmdir("/tmp/sqlite-database-integration", {
+async function F(t, e) {
+  await t.isDir("/tmp/sqlite-database-integration") && await t.rmdir("/tmp/sqlite-database-integration", {
     recursive: !0
-  }), await e.mkdir("/tmp/sqlite-database-integration"), await f(e, n, "/tmp/sqlite-database-integration");
-  const t = "/internal/shared/sqlite-database-integration", i = `/tmp/sqlite-database-integration/${(await e.listFiles("/tmp/sqlite-database-integration"))[0]}`;
-  await e.mv(i, t), await e.defineConstant("SQLITE_MAIN_FILE", "1");
-  const s = (await e.readFileAsText(
-    o(t, "db.copy")
+  }), await t.mkdir("/tmp/sqlite-database-integration"), await p(t, e, "/tmp/sqlite-database-integration");
+  const n = "/internal/shared/sqlite-database-integration", i = `/tmp/sqlite-database-integration/${(await t.listFiles("/tmp/sqlite-database-integration"))[0]}`;
+  await t.mv(i, n), await t.defineConstant("SQLITE_MAIN_FILE", "1");
+  const o = (await t.readFileAsText(
+    s(n, "db.copy")
   )).replace(
     "'{SQLITE_IMPLEMENTATION_FOLDER_PATH}'",
-    u(t)
+    d(n)
   ).replace(
     "'{SQLITE_PLUGIN}'",
-    u(o(t, "load.php"))
-  ), d = o(await e.documentRoot, "wp-content/db.php"), a = `<?php
+    d(s(n, "load.php"))
+  ), c = s(await t.documentRoot, "wp-content/db.php"), r = `<?php
 	// Do not preload this if WordPress comes with a custom db.php file.
-	if(file_exists(${u(d)})) {
+	if(file_exists(${d(c)})) {
 		return;
 	}
 	?>`, l = "/internal/shared/mu-plugins/sqlite-database-integration.php";
-  await e.writeFile(l, a + s), await e.writeFile(
+  await t.writeFile(l, r + o), await t.writeFile(
     "/internal/shared/preload/0-sqlite.php",
-    a + `<?php
+    r + `<?php
 
 /**
  * Loads the SQLite integration plugin before WordPress is loaded
@@ -1041,7 +1178,7 @@ class Playground_SQLite_Integration_Loader {
 		$GLOBALS['wpdb']->$name = $value;
 	}
     protected function load_sqlite_integration() {
-        require_once ${u(l)};
+        require_once ${d(l)};
     }
 }
 /**
@@ -1067,7 +1204,7 @@ if(!function_exists('mysqli_connect')) {
 }
 
 		`
-  ), await e.writeFile(
+  ), await t.writeFile(
     "/internal/shared/mu-plugins/sqlite-test.php",
     `<?php
 		global $wpdb;
@@ -1078,64 +1215,64 @@ if(!function_exists('mysqli_connect')) {
 		`
   );
 }
-async function N(e, n) {
-  e.mkdir("/tmp/unzipped-wordpress"), await f(e, n, "/tmp/unzipped-wordpress"), e.fileExists("/tmp/unzipped-wordpress/wordpress.zip") && await f(
-    e,
+async function N(t, e) {
+  t.mkdir("/tmp/unzipped-wordpress"), await p(t, e, "/tmp/unzipped-wordpress"), t.fileExists("/tmp/unzipped-wordpress/wordpress.zip") && await p(
+    t,
     "/tmp/unzipped-wordpress/wordpress.zip",
     "/tmp/unzipped-wordpress"
   );
-  let t = e.fileExists("/tmp/unzipped-wordpress/wordpress") ? "/tmp/unzipped-wordpress/wordpress" : e.fileExists("/tmp/unzipped-wordpress/build") ? "/tmp/unzipped-wordpress/build" : "/tmp/unzipped-wordpress";
-  if (!e.fileExists(o(t, "wp-config-sample.php"))) {
-    const r = e.listFiles(t);
-    if (r.length) {
-      const s = r[0];
-      e.fileExists(
-        o(t, s, "wp-config-sample.php")
-      ) && (t = o(t, s));
+  let n = t.fileExists("/tmp/unzipped-wordpress/wordpress") ? "/tmp/unzipped-wordpress/wordpress" : t.fileExists("/tmp/unzipped-wordpress/build") ? "/tmp/unzipped-wordpress/build" : "/tmp/unzipped-wordpress";
+  if (!t.fileExists(s(n, "wp-config-sample.php"))) {
+    const a = t.listFiles(n);
+    if (a.length) {
+      const o = a[0];
+      t.fileExists(
+        s(n, o, "wp-config-sample.php")
+      ) && (n = s(n, o));
     }
   }
-  const i = (r, s, d) => {
-    if (d.isDir(r) && d.isDir(s))
-      for (const a of d.listFiles(r)) {
-        const l = o(r, a), w = o(s, a);
-        i(l, w, d);
+  const i = (a, o, c) => {
+    if (c.isDir(a) && c.isDir(o))
+      for (const r of c.listFiles(a)) {
+        const l = s(a, r), k = s(o, r);
+        i(l, k, c);
       }
     else {
-      if (d.fileExists(s)) {
-        const a = r.replace(
+      if (c.fileExists(o)) {
+        const r = a.replace(
           /^\/tmp\/unzipped-wordpress\//,
           "/"
         );
         g.warn(
-          `Cannot unzip WordPress files at ${s}: ${a} already exists.`
+          `Cannot unzip WordPress files at ${o}: ${r} already exists.`
         );
         return;
       }
-      d.mv(r, s);
+      c.mv(a, o);
     }
   };
-  i(t, e.documentRoot, e), e.fileExists(t) && e.rmdir(t, { recursive: !0 }), !e.fileExists(o(e.documentRoot, "wp-config.php")) && e.fileExists(o(e.documentRoot, "wp-config-sample.php")) && e.writeFile(
-    o(e.documentRoot, "wp-config.php"),
-    e.readFileAsText(
-      o(e.documentRoot, "/wp-config-sample.php")
+  i(n, t.documentRoot, t), t.fileExists(n) && t.rmdir(n, { recursive: !0 }), !t.fileExists(s(t.documentRoot, "wp-config.php")) && t.fileExists(s(t.documentRoot, "wp-config-sample.php")) && t.writeFile(
+    s(t.documentRoot, "wp-config.php"),
+    t.readFileAsText(
+      s(t.documentRoot, "/wp-config-sample.php")
     )
   );
 }
-const G = P(fetch), M = "https://github.com/WordPress/WordPress/archive/refs/heads/master.zip";
-async function Z(e = "latest") {
-  if (e === null)
-    e = "latest";
-  else if (e.startsWith("https://") || e.startsWith("http://")) {
+const D = P(fetch), M = "https://github.com/WordPress/WordPress/archive/refs/heads/master.zip";
+async function Z(t = "latest") {
+  if (t === null)
+    t = "latest";
+  else if (t.startsWith("https://") || t.startsWith("http://")) {
     const i = await crypto.subtle.digest(
       "SHA-1",
-      new TextEncoder().encode(e)
-    ), r = Array.from(new Uint8Array(i)).map((s) => s.toString(16).padStart(2, "0")).join("");
+      new TextEncoder().encode(t)
+    ), a = Array.from(new Uint8Array(i)).map((o) => o.toString(16).padStart(2, "0")).join("");
     return {
-      releaseUrl: e,
-      version: "custom-" + r.substring(0, 8),
+      releaseUrl: t,
+      version: "custom-" + a.substring(0, 8),
       source: "inferred"
     };
-  } else if (e === "trunk" || e === "nightly") {
+  } else if (t === "trunk" || t === "nightly") {
     const i = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     return {
       releaseUrl: `${M}?ts=${i}`,
@@ -1143,52 +1280,52 @@ async function Z(e = "latest") {
       source: "inferred"
     };
   }
-  let t = await (await G(
+  let n = await (await D(
     "https://api.wordpress.org/core/version-check/1.7/?channel=beta"
   )).json();
-  t = t.offers.filter(
+  n = n.offers.filter(
     (i) => i.response === "autoupdate"
   );
-  for (const i of t) {
-    if (e === "beta" && (i.version.includes("beta") || i.version.includes("RC")))
+  for (const i of n) {
+    if (t === "beta" && (i.version.includes("beta") || i.version.includes("RC")))
       return {
         releaseUrl: i.download,
         version: i.version,
         source: "api"
       };
-    if (e === "latest" && !i.version.includes("beta") && !i.version.includes("RC"))
+    if (t === "latest" && !i.version.includes("beta") && !i.version.includes("RC"))
       return {
         releaseUrl: i.download,
         version: i.version,
         source: "api"
       };
-    if (i.version.substring(0, e.length) === e)
+    if (i.version.substring(0, t.length) === t)
       return {
         releaseUrl: i.download,
         version: i.version,
         source: "api"
       };
   }
-  return e.match(/^\d+\.\d+\.0$/) && (e = e.split(".").slice(0, 2).join(".")), {
-    releaseUrl: `https://wordpress.org/wordpress-${e}.zip`,
-    version: e,
+  return t.match(/^\d+\.\d+\.0$/) && (t = t.split(".").slice(0, 2).join(".")), {
+    releaseUrl: `https://wordpress.org/wordpress-${t}.zip`,
+    version: t,
     source: "inferred"
   };
 }
 export {
-  U as bootRequestHandler,
-  L as bootWordPress,
-  V as bootWordPressAndRequestHandler,
-  v as defineWpConfigConstants,
+  C as bootRequestHandler,
+  x as bootWordPress,
+  Q as bootWordPressAndRequestHandler,
+  B as defineWpConfigConstants,
   I as ensureWpConfig,
-  W as getFileNotFoundActionForWordPress,
-  j as getLoadedWordPressVersion,
-  q as preloadPhpInfoRoute,
+  L as getFileNotFoundActionForWordPress,
+  V as getLoadedWordPressVersion,
+  W as preloadPhpInfoRoute,
   F as preloadSqliteIntegration,
   Z as resolveWordPressRelease,
-  A as setupPlatformLevelMuPlugins,
+  U as setupPlatformLevelMuPlugins,
   N as unzipWordPress,
-  O as versionStringToLoadedWordPressVersion,
-  D as wordPressRewriteRules
+  A as versionStringToLoadedWordPressVersion,
+  q as wordPressRewriteRules
 };
 //# sourceMappingURL=index.js.map