@10up/wp-vite-plugins 1.0.0-alpha.0

package/dist/index.js

@@ -0,0 +1,2194 @@
+import { resolve, join, relative, dirname, extname } from 'path';
+import { readdirSync, existsSync, readFileSync } from 'fs';
+import crypto, { createHash } from 'crypto';
+import fg from 'fast-glob';
+import { init, parse } from 'es-module-lexer';
+import MagicString from 'magic-string';
+import { createRequire } from 'module';
+
+// src/wp.ts
+
+// src/php-templates.ts
+var DEFAULT_REST_PRELOAD = [
+  "/?_fields=description,gmt_offset,home,image_sizes,image_size_threshold,name,site_icon,site_icon_url,site_logo,timezone_string,url,page_for_posts,page_on_front,show_on_front",
+  ["/wp/v2/settings", "OPTIONS"]
+];
+var ALL_PAGE_MODES = ["full-page", "wp-admin"];
+function phpString(value) {
+  return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+function phpStringArray(values) {
+  if (values.length === 0) return "array()";
+  return `array( ${values.map(phpString).join(", ")} )`;
+}
+function toUnderscore(value) {
+  return value.replace(/-/g, "_");
+}
+function isValidPhpIdentifier(value) {
+  return /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(toUnderscore(value));
+}
+function isValidSlug(value) {
+  return /^[a-z0-9-]+$/.test(value);
+}
+function pageNames(page, mode) {
+  const slugUnderscore = toUnderscore(page.slug);
+  const isWpAdmin = mode === "wp-admin";
+  return {
+    /** Script handle / module id / hook base: `settings-wp-admin`. */
+    handle: isWpAdmin ? `${page.slug}-wp-admin` : page.slug,
+    /** Function-name infix: `settings_wp_admin`. */
+    fn: isWpAdmin ? `${slugUnderscore}_wp_admin` : slugUnderscore,
+    /** Mount element id. */
+    mountId: isWpAdmin ? `${page.slug}-wp-admin-app` : `${page.slug}-app`
+  };
+}
+function assetFileList(page) {
+  const files = [];
+  for (const route of page.routes) {
+    if (route.hasContent) files.push(`${route.dir}/content.asset.php`);
+    if (route.hasRoute) files.push(`${route.dir}/route.asset.php`);
+  }
+  return files;
+}
+function preloadPathsPhp(entries, indent) {
+  if (entries.length === 0) return `${indent}// No REST paths configured.`;
+  return entries.map((entry) => {
+    const value = Array.isArray(entry) ? `array( ${phpString(entry[0])}, ${phpString(entry[1])} )` : phpString(entry);
+    return `${indent}${value},`;
+  }).join("\n");
+}
+function initModulesPhp(initModules, indent) {
+  if (initModules.length === 0) return `${indent}// No init modules configured.`;
+  return initModules.map(
+    (moduleId) => `${indent}$boot_dependencies[] = array( 'import' => 'static', 'id' => ${phpString(
+      moduleId
+    )} );`
+  ).join("\n");
+}
+function renderPageStateBlock(ctx, page, mode) {
+  const prefix = toUnderscore(ctx.prefix);
+  const { handle, fn } = pageNames(page, mode);
+  const routesGlobal = `$${prefix}_${fn}_routes`;
+  const menuItemsGlobal = `$${prefix}_${fn}_menu_items`;
+  const parentTypeParam = mode === "full-page" ? ", $parent_type = ''" : "";
+  const parentTypeDoc = mode === "full-page" ? " * @param string $parent_type Optional. Parent type: 'drilldown' or 'dropdown'.\n" : "";
+  const parentTypeBody = mode === "full-page" ? `
+	if ( ! empty( $parent_type ) && in_array( $parent_type, array( 'drilldown', 'dropdown' ), true ) ) {
+		$menu_item['parent_type'] = $parent_type;
+	}
+` : "";
+  const routesPad = " ".repeat(Math.max(0, menuItemsGlobal.length - routesGlobal.length));
+  return `// Global storage for ${handle} routes and menu items.
+global ${routesGlobal}, ${menuItemsGlobal};
+${routesGlobal}${routesPad} = array();
+${menuItemsGlobal} = array();
+
+/**
+ * Register a route for the ${handle} page.
+ *
+ * @param string      $path           Route path (e.g., '/types/$type/edit/$id').
+ * @param string|null $content_module Script module ID for content (stage/inspector).
+ * @param string|null $route_module   Script module ID for route lifecycle hooks.
+ */
+function ${prefix}_register_${fn}_route( $path, $content_module = null, $route_module = null ) {
+	global ${routesGlobal};
+
+	$route = array( 'path' => $path );
+	if ( ! empty( $content_module ) ) {
+		$route['content_module'] = $content_module;
+	}
+	if ( ! empty( $route_module ) ) {
+		$route['route_module'] = $route_module;
+	}
+
+	${routesGlobal}[] = $route;
+}
+
+/**
+ * Register a menu item for the ${handle} page.
+ *
+ * @param string $id          Menu item ID.
+ * @param string $label       Display label.
+ * @param string $to          Route path to navigate to.
+ * @param string $parent_id   Optional. Parent menu item ID.
+${parentTypeDoc} */
+function ${prefix}_register_${fn}_menu_item( $id, $label, $to, $parent_id = ''${parentTypeParam} ) {
+	global ${menuItemsGlobal};
+
+	$menu_item = array(
+		'id'    => $id,
+		'label' => $label,
+		'to'    => $to,
+	);
+
+	if ( ! empty( $parent_id ) ) {
+		$menu_item['parent'] = $parent_id;
+	}
+${parentTypeBody}
+	${menuItemsGlobal}[] = $menu_item;
+}
+
+/**
+ * Get all registered routes for the ${handle} page.
+ *
+ * @return array Array of route objects.
+ */
+function ${prefix}_get_${fn}_routes() {
+	global ${routesGlobal};
+	return ${routesGlobal} ?? array();
+}
+
+/**
+ * Get all registered menu items for the ${handle} page.
+ *
+ * @return array Array of menu item objects.
+ */
+function ${prefix}_get_${fn}_menu_items() {
+	global ${menuItemsGlobal};
+	return ${menuItemsGlobal} ?? array();
+}
+
+/**
+ * Preload REST API data for the ${handle} page.
+ * Automatically called during page rendering.
+ */
+function ${prefix}_${fn}_preload_data() {
+	$preload_paths = array(
+${preloadPathsPhp(page.restPreload, "		")}
+	);
+
+	// Use rest_preload_api_request to gather the preloaded data.
+	$preload_data = array_reduce(
+		$preload_paths,
+		'rest_preload_api_request',
+		array()
+	);
+
+	// Register the preloading middleware with wp-api-fetch.
+	wp_add_inline_script(
+		'wp-api-fetch',
+		sprintf(
+			'wp.apiFetch.use( wp.apiFetch.createPreloadingMiddleware( %s ) );',
+			wp_json_encode( $preload_data )
+		),
+		'after'
+	);
+}
+`;
+}
+function renderCarrierBlock(ctx, page, mode) {
+  const { handle } = pageNames(page, mode);
+  const assetFiles = assetFileList(page).map((file) => `		__DIR__ . '/../../${file}',`).join("\n");
+  return `	// Every classic script handle the page's modules read off window.* lives
+	// in their .asset.php sidecars; the carrier depends on the union of them.
+	$asset_files = array(
+${assetFiles}
+	);
+
+	$script_dependencies = array();
+	$version             = false;
+	$has_assets          = false;
+
+	foreach ( $asset_files as $asset_file ) {
+		if ( ! file_exists( $asset_file ) ) {
+			continue;
+		}
+		$has_assets = true;
+		$asset      = require $asset_file;
+		if ( ! empty( $asset['dependencies'] ) ) {
+			$script_dependencies = array_merge( $script_dependencies, $asset['dependencies'] );
+		}
+		if ( false === $version && ! empty( $asset['version'] ) ) {
+			$version = $asset['version'];
+		}
+	}
+
+	// Core's boot module carries classic dependencies of its own.
+	$boot_asset_file = ABSPATH . WPINC . '/js/dist/script-modules/boot/index.min.asset.php';
+	if ( file_exists( $boot_asset_file ) ) {
+		$boot_asset = require $boot_asset_file;
+		if ( ! empty( $boot_asset['dependencies'] ) ) {
+			$script_dependencies = array_merge( $script_dependencies, $boot_asset['dependencies'] );
+		}
+	}
+
+	$script_dependencies = array_values( array_unique( $script_dependencies ) );
+
+	if ( $has_assets ) {
+		// This script serves two purposes:
+		// 1. It ensures all the globals that are made available to the modules are loaded.
+		// 2. It initializes the boot module as an inline script.
+		// The src is \`false\`, not \`''\`: an empty-src carrier script.
+		wp_register_script( '${handle}-prerequisites', false, $script_dependencies, $version, true );
+`;
+}
+function renderBootGraphBlock(ctx, page, mode) {
+  const { handle } = pageNames(page, mode);
+  return `		// Register prerequisites style by filtering script dependencies to find registered styles.
+		$style_dependencies = array_filter(
+			$script_dependencies,
+			function ( $handle ) {
+				return wp_style_is( $handle, 'registered' );
+			}
+		);
+		wp_register_style( '${handle}-prerequisites', false, $style_dependencies, $version );
+
+		// Build dependencies for the ${handle} module.
+		$boot_dependencies = array(
+			array(
+				'import' => 'static',
+				'id'     => '@wordpress/boot',
+			),
+		);
+
+		// Add init modules as static dependencies.
+${initModulesPhp(page.initModules, "		")}
+
+		// Add all registered routes as dependencies.
+		foreach ( $routes as $route ) {
+			if ( isset( $route['route_module'] ) ) {
+				$boot_dependencies[] = array(
+					'import' => 'static',
+					'id'     => $route['route_module'],
+				);
+			}
+			if ( isset( $route['content_module'] ) ) {
+				$boot_dependencies[] = array(
+					'import' => 'dynamic',
+					'id'     => $route['content_module'],
+				);
+			}
+		}
+
+		/**
+		 * Filters the boot script-module dependencies for the
+		 * ${handle} page.
+		 *
+		 * Surfaces extending this page can append entries to the boot
+		 * dependency list. Each entry is an array with 'import' (string
+		 * 'static' or 'dynamic') and 'id' (script-module handle) keys.
+		 *
+		 * @param array $boot_dependencies Boot dependencies for the page.
+		 */
+		$boot_dependencies = apply_filters(
+			'${handle}_boot_dependencies',
+			$boot_dependencies
+		);
+
+		// Dummy script module to ensure dependencies are loaded.
+		wp_register_script_module(
+			'${handle}',
+			$build_constants['build_url'] . 'modules/${page.slug}/loader.js',
+			$boot_dependencies
+		);
+
+		// Enqueue the boot scripts and styles.
+		wp_enqueue_script( '${handle}-prerequisites' );
+		wp_enqueue_script_module( '${handle}' );
+		wp_enqueue_style( '${handle}-prerequisites' );
+	}
+`;
+}
+function renderMenuBlock(ctx, page, mode) {
+  if (!page.menu) return "";
+  const prefix = toUnderscore(ctx.prefix);
+  const slugUnderscore = toUnderscore(page.slug);
+  const { handle, fn } = pageNames(page, mode);
+  const menu = page.menu;
+  const capability = phpString(menu.capability ?? "manage_options");
+  const title = `__( ${phpString(page.title)}, ${phpString(ctx.textdomain)} )`;
+  const renderCallback = phpString(`${prefix}_${fn}_render_page`);
+  const menuSlug = phpString(handle);
+  let call;
+  if (menu.parent === false || menu.parent === "toplevel") {
+    const icon = phpString(menu.icon ?? "dashicons-admin-generic");
+    const position = typeof menu.position === "number" ? String(menu.position) : "null";
+    call = `	add_menu_page(
+		${title},
+		${title},
+		${capability},
+		${menuSlug},
+		${renderCallback},
+		${icon},
+		${position}
+	);`;
+  } else if (menu.parent === void 0 || menu.parent === "options-general.php") {
+    call = `	add_options_page(
+		${title},
+		${title},
+		${capability},
+		${menuSlug},
+		${renderCallback}
+	);`;
+  } else {
+    call = `	add_submenu_page(
+		${phpString(menu.parent)},
+		${title},
+		${title},
+		${capability},
+		${menuSlug},
+		${renderCallback}
+	);`;
+  }
+  return `
+/**
+ * Register the admin menu entry for the ${handle} page.
+ */
+function ${prefix}_register_${slugUnderscore}_menu() {
+${call}
+}
+add_action( 'admin_menu', '${prefix}_register_${slugUnderscore}_menu' );
+`;
+}
+function renderPagePhp(ctx, page) {
+  const prefix = toUnderscore(ctx.prefix);
+  const mode = "full-page";
+  const { handle, fn, mountId } = pageNames(page, mode);
+  return `<?php
+/**
+ * Page: ${handle}
+ * Auto-generated by build process. Do not edit this file manually.
+ *
+ * Full-page takeover mode: renders its own HTML document and boots the app
+ * with \`init()\`, so the wp-admin chrome is replaced entirely.
+ *
+ * @package ${ctx.prefix}
+ */
+
+${renderPageStateBlock(ctx, page, mode)}
+/**
+ * Render the ${handle} page.
+ * Call this function from add_menu_page or add_submenu_page.
+ */
+function ${prefix}_${fn}_render_page() {
+	// Load build constants.
+	$build_constants = require __DIR__ . '/../../constants.php';
+
+	// Set current screen.
+	set_current_screen();
+
+	// Remove unwanted deprecated handler.
+	remove_action( 'admin_head', 'wp_admin_bar_header' );
+
+	// Remove unwanted scripts and styles that were enqueued during \`admin_init\`.
+	foreach ( wp_scripts()->queue as $script ) {
+		wp_dequeue_script( $script );
+	}
+	foreach ( wp_styles()->queue as $style ) {
+		wp_dequeue_style( $style );
+	}
+
+	/**
+	 * Fires when the ${handle} page is initialized so extensions can register routes and menu items.
+	 */
+	do_action( '${handle}_init' );
+
+	// Enqueue command palette assets for boot-based pages.
+	if ( function_exists( 'wp_enqueue_command_palette_assets' ) ) {
+		wp_enqueue_command_palette_assets();
+	}
+
+	// Preload REST API data.
+	${prefix}_${fn}_preload_data();
+
+	// Get all registered routes and menu items.
+	$menu_items = ${prefix}_get_${fn}_menu_items();
+	$routes     = ${prefix}_get_${fn}_routes();
+
+${renderCarrierBlock(ctx, page, mode)}
+		// Add inline script to initialize the app.
+		$init_modules = ${phpStringArray(page.initModules)};
+		wp_add_inline_script(
+			'${handle}-prerequisites',
+			sprintf(
+				'import("@wordpress/boot").then(mod => mod.init({mountId: "%s", menuItems: %s, routes: %s, initModules: %s, dashboardLink: "%s"}));',
+				'${mountId}',
+				wp_json_encode( $menu_items, JSON_HEX_TAG | JSON_UNESCAPED_SLASHES ),
+				wp_json_encode( $routes, JSON_HEX_TAG | JSON_UNESCAPED_SLASHES ),
+				wp_json_encode( $init_modules, JSON_HEX_TAG | JSON_UNESCAPED_SLASHES ),
+				esc_url( admin_url( '/' ) )
+			)
+		);
+
+${renderBootGraphBlock(ctx, page, mode)}
+	// Output the HTML.
+	?>
+	<!DOCTYPE html>
+	<html <?php language_attributes(); ?>>
+	<head>
+		<meta charset="<?php bloginfo( 'charset' ); ?>">
+		<meta name="viewport" content="width=device-width, initial-scale=1">
+		<title><?php echo esc_html( get_admin_page_title() ); ?></title>
+		<style>
+			html {
+				background: #f1f1f1;
+				color: #444;
+				font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen-Sans, Ubuntu, Cantarell, "Helvetica Neue", sans-serif;
+				font-size: 13px;
+				line-height: 1.4em;
+			}
+			body {
+				margin: 0;
+			}
+			#wpadminbar { display: none; }
+		</style>
+	<?php
+	global $hook_suffix;
+	// phpcs:ignore WordPress.WP.GlobalVariablesOverride.Prohibited
+	$hook_suffix = '${handle}';
+
+	// BEGIN see wp-admin/admin-header.php
+	print_admin_styles();
+	print_head_scripts();
+
+	/** This action is documented in wp-admin/admin-header.php */
+	do_action( "admin_head-{$hook_suffix}" ); // phpcs:ignore WordPress.NamingConventions.ValidHookName.UseUnderscores
+
+	/** This action is documented in wp-admin/admin-header.php */
+	do_action( 'admin_head' );
+	// END see wp-admin/admin-header.php
+	?>
+	</head>
+	<body class="${handle}">
+		<div id="${mountId}" style="height: 100vh; box-sizing: border-box;"></div>
+	<?php
+	// BEGIN see wp-admin/admin-footer.php
+
+	/** This action is documented in wp-admin/admin-footer.php */
+	do_action( 'admin_footer', '' );
+
+	// Print import map first so it's available for inline scripts.
+	wp_script_modules()->print_import_map();
+	print_footer_scripts();
+	wp_script_modules()->print_enqueued_script_modules();
+	wp_script_modules()->print_script_module_preloads();
+	wp_script_modules()->print_script_module_data();
+
+	/** This action is documented in wp-admin/admin-footer.php */
+	do_action( "admin_footer-{$hook_suffix}" ); // phpcs:ignore WordPress.NamingConventions.ValidHookName.UseUnderscores
+	// END see wp-admin/admin-footer.php
+	?>
+	</body>
+	</html>
+	<?php
+	exit;
+}
+
+/**
+ * Intercept admin_init to render the page early.
+ * This bypasses the default WordPress admin template.
+ */
+function ${prefix}_${fn}_intercept_render() {
+	// phpcs:ignore WordPress.Security.NonceVerification.Recommended
+	if ( isset( $_GET['page'] ) && '${handle}' === $_GET['page'] ) {
+		${prefix}_${fn}_render_page();
+		exit;
+	}
+}
+
+// Hook the interceptor to admin_init.
+add_action( 'admin_init', '${prefix}_${fn}_intercept_render' );
+${renderMenuBlock(ctx, page, mode)}`;
+}
+function renderPageWpAdminPhp(ctx, page) {
+  const prefix = toUnderscore(ctx.prefix);
+  const mode = "wp-admin";
+  const { handle, fn, mountId } = pageNames(page, mode);
+  return `<?php
+/**
+ * Page: ${page.slug} (wp-admin integrated)
+ * Auto-generated by build process. Do not edit this file manually.
+ *
+ * This version integrates with the standard WordPress admin interface,
+ * keeping the wp-admin sidebar and scripts/styles intact.
+ *
+ * @package ${ctx.prefix}
+ */
+
+${renderPageStateBlock(ctx, page, mode)}
+/**
+ * Enqueue scripts and styles for the ${handle} page.
+ * Hooked to admin_enqueue_scripts.
+ *
+ * @param string $hook_suffix The current admin page.
+ */
+function ${prefix}_${fn}_enqueue_scripts( $hook_suffix ) {
+	// Check all possible ways this page can be accessed:
+	// 1. Menu page via admin.php?page=${handle}
+	// 2. Direct file whose screen ID is '${page.slug}'
+	$current_screen = get_current_screen();
+	$is_our_page    = (
+		( isset( $_GET['page'] ) && '${handle}' === $_GET['page'] ) || // phpcs:ignore WordPress.Security.NonceVerification.Recommended
+		( $current_screen && '${page.slug}' === $current_screen->id )
+	);
+
+	if ( ! $is_our_page ) {
+		return;
+	}
+
+	// Load build constants.
+	$build_constants = require __DIR__ . '/../../constants.php';
+
+	/**
+	 * Fires when the ${handle} page is initialized so extensions can register routes and menu items.
+	 */
+	do_action( '${handle}_init' );
+
+	// Preload REST API data.
+	${prefix}_${fn}_preload_data();
+
+	// Get all registered routes.
+	$routes = ${prefix}_get_${fn}_routes();
+
+${renderCarrierBlock(ctx, page, mode)}
+		$init_modules = ${phpStringArray(page.initModules)};
+
+		/*
+		 * Add inline script to initialize the app using initSinglePage (no menuItems).
+		 * The dynamic import is deferred until DOMContentLoaded so that all classic
+		 * script dependencies of @wordpress/boot (wp-private-apis, wp-components,
+		 * wp-theme, etc.) have finished parsing and executing before the boot module
+		 * evaluates. Otherwise, a modulepreloaded @wordpress/boot can win the race
+		 * against the classic-script-printing pass on fast CDN-fronted hosts in
+		 * Chrome, evaluating before wp.theme.privateApis is defined and throwing
+		 * "Cannot unlock an undefined object". See <https://core.trac.wordpress.org/ticket/65103>.
+		 */
+		$init_js_function = <<<'JS'
+		( mountId, routes, initModules ) => {
+			const run = async () => {
+				const mod = await import( "@wordpress/boot" );
+				mod.initSinglePage( { mountId, routes, initModules } );
+			};
+			if ( document.readyState === "loading" ) {
+				document.addEventListener( "DOMContentLoaded", run );
+			} else {
+				run();
+			}
+		}
+		JS;
+		wp_add_inline_script(
+			'${handle}-prerequisites',
+			sprintf(
+				'( %s )( %s, %s, %s );',
+				$init_js_function,
+				wp_json_encode( '${mountId}', JSON_HEX_TAG | JSON_UNESCAPED_SLASHES ),
+				wp_json_encode( $routes, JSON_HEX_TAG | JSON_UNESCAPED_SLASHES ),
+				wp_json_encode( $init_modules, JSON_HEX_TAG | JSON_UNESCAPED_SLASHES )
+			)
+		);
+
+${renderBootGraphBlock(ctx, page, mode)}}
+
+/**
+ * Render the ${handle} page.
+ * Call this function from add_menu_page or add_submenu_page.
+ * This renders within the normal WordPress admin interface.
+ */
+function ${prefix}_${fn}_render_page() {
+	?>
+	<style>
+		/* Critical styles to prevent layout shifts - inlined for immediate application */
+
+		#wpwrap {
+			overflow-y: auto;
+		}
+		body {
+			background: #fff;
+		}
+
+		/* Reset wp-admin padding */
+		#wpcontent {
+			padding-inline-start: 0;
+		}
+		#wpbody-content {
+			padding-bottom: 0;
+		}
+
+		/* Hide legacy admin elements */
+		#wpbody-content > div:not(.boot-layout-container):not(#screen-meta) {
+			display: none;
+		}
+		#wpfooter {
+			display: none;
+		}
+
+		/* Accessibility regions */
+		.a11y-speak-region {
+			inset-inline-start: -1px;
+			top: -1px;
+		}
+
+		/* Admin menu indicators */
+		ul#adminmenu a.wp-has-current-submenu::after,
+		ul#adminmenu > li.current > a.current::after {
+			border-inline-end-color: #fff;
+		}
+
+		/* Media frame fix */
+		.media-frame select.attachment-filters:last-of-type {
+			width: auto;
+			max-width: 100%;
+		}
+
+		/* Responsive overflow fix for #wpwrap */
+		@media (min-width: 782px) {
+			#wpwrap {
+				overflow-y: initial;
+			}
+		}
+	</style>
+	<div id="${mountId}" class="boot-layout-container"></div>
+	<?php
+}
+
+// Hook the enqueue function to admin_enqueue_scripts.
+add_action( 'admin_enqueue_scripts', '${prefix}_${fn}_enqueue_scripts' );
+${renderMenuBlock(ctx, page, mode)}`;
+}
+function renderPagesPhp(ctx, pages) {
+  const files = [];
+  for (const page of pages) {
+    if (page.modes.includes("full-page")) {
+      files.push(`	__DIR__ . '/pages/${page.slug}/page.php',`);
+    }
+    if (page.modes.includes("wp-admin")) {
+      files.push(`	__DIR__ . '/pages/${page.slug}/page-wp-admin.php',`);
+    }
+  }
+  return `<?php
+/**
+ * Pages loader - Auto-generated by build process.
+ * Do not edit this file manually.
+ *
+ * @package ${ctx.prefix}
+ */
+
+$${toUnderscore(ctx.prefix)}_page_files = array(
+${files.join("\n")}
+);
+
+foreach ( $${toUnderscore(ctx.prefix)}_page_files as $page_file ) {
+	if ( file_exists( $page_file ) ) {
+		require_once $page_file;
+	}
+}
+`;
+}
+function renderBuildPhp(ctx) {
+  return `<?php
+/**
+ * Main entry point for auto-generated asset registration.
+ * Auto-generated by build process. Do not edit this file manually.
+ *
+ * Require this file from your plugin or theme:
+ *
+ *     require_once __DIR__ . '/dist/build.php';
+ *
+ * @package ${ctx.prefix}
+ */
+
+// Load routes registration.
+$routes_file = __DIR__ . '/routes.php';
+if ( file_exists( $routes_file ) ) {
+	require_once $routes_file;
+}
+
+// Load pages registration.
+$pages_file = __DIR__ . '/pages.php';
+if ( file_exists( $pages_file ) ) {
+	require_once $pages_file;
+}
+`;
+}
+function renderConstantsPhp(ctx) {
+  return `<?php
+/**
+ * Plugin constants - Auto-generated by build process.
+ * Do not edit this file manually.
+ *
+ * Returns an array of constants for use in other generated files.
+ *
+ * @package ${ctx.prefix}
+ */
+
+return array(
+	'version'   => ${phpString(ctx.version)},
+	'build_url' => ${ctx.baseUrl},
+);
+`;
+}
+function renderRouteRegistryPhp(ctx, pages) {
+  const rows = [];
+  for (const page of pages) {
+    for (const route of page.routes) {
+      rows.push(`	array(
+		'name'        => ${phpString(route.name)},
+		'path'        => ${phpString(route.path)},
+		'page'        => ${phpString(page.slug)},
+		'dir'         => ${phpString(route.dir)},
+		'has_route'   => ${route.hasRoute ? "true" : "false"},
+		'has_content' => ${route.hasContent ? "true" : "false"},
+	),`);
+    }
+  }
+  return `<?php
+/**
+ * Route registry - Auto-generated by build process.
+ * Do not edit this file manually.
+ *
+ * @package ${ctx.prefix}
+ */
+
+return array(
+${rows.join("\n")}
+);
+`;
+}
+function renderRoutesPageFunctions(ctx, page) {
+  const prefix = toUnderscore(ctx.prefix);
+  const slugUnderscore = toUnderscore(page.slug);
+  const blocks = [];
+  for (const mode of ALL_PAGE_MODES) {
+    if (!page.modes.includes(mode)) continue;
+    const { handle, fn } = pageNames(page, mode);
+    const label = mode === "wp-admin" ? "wp-admin mode" : "full-page mode";
+    blocks.push(`/**
+ * Register routes for the ${page.slug} page (${label}).
+ */
+function ${prefix}_register_${fn}_page_routes() {
+	global $${prefix}_${slugUnderscore}_routes_data;
+	${prefix}_register_page_routes( $${prefix}_${slugUnderscore}_routes_data, '${prefix}_register_${fn}_route' );
+}
+add_action( '${handle}_init', '${prefix}_register_${fn}_page_routes' );`);
+  }
+  return `// Page-specific route registration functions for ${page.slug}.
+${blocks.join("\n\n")}`;
+}
+function renderRoutesPhp(ctx, pages) {
+  const prefix = toUnderscore(ctx.prefix);
+  const pageFunctions = pages.map((page) => renderRoutesPageFunctions(ctx, page)).join("\n\n");
+  return `<?php
+/**
+ * Routes registration - Auto-generated by build process.
+ * Registers all routes on their respective page init hooks.
+ * Do not edit this file manually.
+ *
+ * @package ${ctx.prefix}
+ */
+
+// Load routes registry.
+$routes_file = __DIR__ . '/routes/registry.php';
+if ( ! file_exists( $routes_file ) ) {
+	return;
+}
+
+$routes = require $routes_file;
+
+// Group routes by page and store in globals for page-specific functions.
+$routes_by_page = array();
+foreach ( $routes as $route ) {
+	$page_slug = $route['page'];
+	if ( ! isset( $routes_by_page[ $page_slug ] ) ) {
+		$routes_by_page[ $page_slug ] = array();
+	}
+	$routes_by_page[ $page_slug ][] = $route;
+}
+
+// Store routes data in globals for each page.
+foreach ( $routes_by_page as $page_slug => $page_routes ) {
+	$page_slug_underscore              = str_replace( '-', '_', $page_slug );
+	$GLOBALS[ '${prefix}_' . $page_slug_underscore . '_routes_data' ] = $page_routes;
+}
+
+/**
+ * Generic helper function to register routes for a page.
+ *
+ * @param array  $page_routes            Array of route data for the page.
+ * @param string $register_function_name Name of the function to call for registering each route.
+ */
+function ${prefix}_register_page_routes( $page_routes, $register_function_name ) {
+	// Load build constants.
+	$build_constants = require __DIR__ . '/constants.php';
+
+	foreach ( $page_routes as $route ) {
+		$content_handle = null;
+		$route_handle   = null;
+		$module_prefix  = ${phpString(ctx.handlePrefix)} . '/routes/' . $route['page'] . '/' . $route['name'];
+
+		// Register the content module when the build produced one.
+		if ( $route['has_content'] ) {
+			$content_asset_path = __DIR__ . '/' . $route['dir'] . '/content.asset.php';
+			if ( file_exists( $content_asset_path ) ) {
+				$content_asset  = require $content_asset_path;
+				$content_handle = $module_prefix . '/content';
+				// Deregister first to override any previously registered version
+				// (e.g., Core's default modules when running as a plugin).
+				wp_deregister_script_module( $content_handle );
+				wp_register_script_module(
+					$content_handle,
+					$build_constants['build_url'] . $route['dir'] . '/content.js',
+					$content_asset['module_dependencies'] ?? array(),
+					$content_asset['version'] ?? false
+				);
+
+				// The page stylesheet, when the entry imported any CSS.
+				$content_style_path = __DIR__ . '/' . $route['dir'] . '/content.css';
+				if ( file_exists( $content_style_path ) ) {
+					$style_handle = str_replace( '/', '-', $content_handle );
+					wp_register_style(
+						$style_handle,
+						$build_constants['build_url'] . $route['dir'] . '/content.css',
+						array(),
+						$content_asset['version'] ?? false
+					);
+					wp_enqueue_style( $style_handle );
+				}
+			}
+		}
+
+		// Register the route module when the build produced one.
+		if ( $route['has_route'] ) {
+			$route_asset_path = __DIR__ . '/' . $route['dir'] . '/route.asset.php';
+			if ( file_exists( $route_asset_path ) ) {
+				$route_asset  = require $route_asset_path;
+				$route_handle = $module_prefix . '/route';
+				// Deregister first to override any previously registered version
+				// (e.g., Core's default modules when running as a plugin).
+				wp_deregister_script_module( $route_handle );
+				wp_register_script_module(
+					$route_handle,
+					$build_constants['build_url'] . $route['dir'] . '/route.js',
+					$route_asset['module_dependencies'] ?? array(),
+					$route_asset['version'] ?? false
+				);
+			}
+		}
+
+		// Register route with page.
+		if ( function_exists( $register_function_name ) ) {
+			call_user_func( $register_function_name, $route['path'], $content_handle, $route_handle );
+		}
+	}
+}
+
+${pageFunctions}
+`;
+}
+function generatePhpFiles(ctx, pages) {
+  const files = [
+    { fileName: "build.php", source: renderBuildPhp(ctx) },
+    { fileName: "constants.php", source: renderConstantsPhp(ctx) }
+  ];
+  if (pages.length === 0) return files;
+  files.push({ fileName: "pages.php", source: renderPagesPhp(ctx, pages) });
+  for (const page of pages) {
+    if (page.modes.includes("full-page")) {
+      files.push({
+        fileName: `pages/${page.slug}/page.php`,
+        source: renderPagePhp(ctx, page)
+      });
+    }
+    if (page.modes.includes("wp-admin")) {
+      files.push({
+        fileName: `pages/${page.slug}/page-wp-admin.php`,
+        source: renderPageWpAdminPhp(ctx, page)
+      });
+    }
+  }
+  const hasRoutes = pages.some((page) => page.routes.length > 0);
+  if (hasRoutes) {
+    files.push({ fileName: "routes.php", source: renderRoutesPhp(ctx, pages) });
+    files.push({
+      fileName: "routes/registry.php",
+      source: renderRouteRegistryPhp(ctx, pages)
+    });
+  }
+  return files;
+}
+
+// src/wp-admin-pages.ts
+var ENTRY_EXTENSIONS = [".tsx", ".ts", ".jsx", ".js"];
+var LOADER_SOURCE = "// Empty module loader for page dependencies.\n";
+function wpAdminPages(options) {
+  const buildType = options.buildType ?? "script";
+  let pages = [];
+  let phpFiles = [];
+  return {
+    name: "wp-admin-pages",
+    enforce: "pre",
+    config(userConfig) {
+      if (buildType !== "module") return;
+      const adminPagesDirAbs = resolve(process.cwd(), options.adminPagesDir);
+      pages = discoverPages(adminPagesDirAbs);
+      if (pages.length === 0) return;
+      if (options.php) {
+        const projectRoot = resolve(
+          process.cwd(),
+          options.projectRoot ?? userConfig?.root ?? "."
+        );
+        const phpContext = resolvePhpContext(options.php, projectRoot);
+        phpFiles = generatePhpFiles(phpContext, pages.map(toGeneratedPage));
+      }
+      const input = {};
+      for (const page of pages) {
+        input[`modules/${page.dirName}/content`] = page.content;
+        if (page.route) input[`modules/${page.dirName}/route`] = page.route;
+        for (const subRoute of page.subRoutes) {
+          const base = `modules/${page.dirName}/routes/${subRoute.name}`;
+          if (subRoute.content) input[`${base}/content`] = subRoute.content;
+          if (subRoute.route) input[`${base}/route`] = subRoute.route;
+        }
+      }
+      return {
+        build: {
+          rollupOptions: {
+            input,
+            // Vite defaults app builds to `preserveEntrySignatures:
+            // false`, which tree-shakes an entry's exports away. A
+            // boot page IS its exports (`export const stage`,
+            // `export const route` — imported by
+            // `@wordpress/boot` at runtime), so they have to
+            // survive.
+            preserveEntrySignatures: "exports-only"
+          }
+        }
+      };
+    },
+    generateBundle(_outputOptions, bundle) {
+      if (buildType !== "module" || pages.length === 0) return;
+      for (const page of pages) {
+        this.emitFile({
+          type: "asset",
+          fileName: `modules/${page.dirName}/loader.js`,
+          source: LOADER_SOURCE
+        });
+      }
+      for (const file of phpFiles) {
+        this.emitFile({
+          type: "asset",
+          fileName: file.fileName,
+          source: file.source
+        });
+      }
+      if (!bundle) return;
+      const entryNames = /* @__PURE__ */ new Set();
+      for (const page of pages) {
+        entryNames.add(`modules/${page.dirName}/content`);
+        if (page.route) entryNames.add(`modules/${page.dirName}/route`);
+        for (const subRoute of page.subRoutes) {
+          const base = `modules/${page.dirName}/routes/${subRoute.name}`;
+          if (subRoute.content) entryNames.add(`${base}/content`);
+          if (subRoute.route) entryNames.add(`${base}/route`);
+        }
+      }
+      const referencingChunks = /* @__PURE__ */ new Map();
+      for (const [fileName, output] of Object.entries(bundle)) {
+        if (output.type !== "chunk") continue;
+        for (const cssFileName of output.viteMetadata?.importedCss ?? []) {
+          let chunks = referencingChunks.get(cssFileName);
+          if (!chunks) referencingChunks.set(cssFileName, chunks = /* @__PURE__ */ new Set());
+          chunks.add(fileName);
+        }
+      }
+      const pageEntries = [];
+      for (const [fileName, output] of Object.entries(bundle)) {
+        if (output.type !== "chunk" || !output.isEntry) continue;
+        if (!entryNames.has(output.name)) continue;
+        pageEntries.push([fileName, output]);
+      }
+      const pageEntryFileNames = new Set(pageEntries.map(([fileName]) => fileName));
+      const reachableFromOtherEntries = /* @__PURE__ */ new Set();
+      for (const [fileName, output] of Object.entries(bundle)) {
+        if (output.type !== "chunk" || !output.isEntry) continue;
+        if (pageEntryFileNames.has(fileName)) continue;
+        for (const chunkFileName of reachableChunks(bundle, fileName)) {
+          reachableFromOtherEntries.add(chunkFileName);
+        }
+      }
+      const foldedIntoPages = /* @__PURE__ */ new Set();
+      for (const [fileName, chunk] of pageEntries) {
+        const cssFileNames = collectImportedCss(bundle, fileName);
+        if (cssFileNames.length === 0) continue;
+        const targetFileName = fileName.replace(/\.m?js$/, ".css");
+        const sources = [];
+        for (const cssFileName of cssFileNames) {
+          const asset = bundle[cssFileName];
+          if (!asset || asset.type !== "asset") continue;
+          sources.push(assetSourceToString(asset.source));
+          if (cssFileName !== targetFileName) foldedIntoPages.add(cssFileName);
+        }
+        if (sources.length === 0) continue;
+        if (!(cssFileNames.length === 1 && cssFileNames[0] === targetFileName)) {
+          this.emitFile({
+            type: "asset",
+            fileName: targetFileName,
+            source: sources.join("\n")
+          });
+        }
+        const importedCss = chunk.viteMetadata?.importedCss;
+        if (importedCss) {
+          for (const cssFileName of [...importedCss]) importedCss.delete(cssFileName);
+          importedCss.add(targetFileName);
+        }
+      }
+      for (const cssFileName of foldedIntoPages) {
+        const referencing = referencingChunks.get(cssFileName) ?? /* @__PURE__ */ new Set();
+        let pagesOnly = true;
+        for (const chunkFileName of referencing) {
+          if (reachableFromOtherEntries.has(chunkFileName)) pagesOnly = false;
+        }
+        if (!pagesOnly) continue;
+        delete bundle[cssFileName];
+        for (const output of Object.values(bundle)) {
+          if (output.type !== "chunk") continue;
+          output.viteMetadata?.importedCss.delete(cssFileName);
+        }
+      }
+    }
+  };
+}
+function discoverPages(adminPagesDirAbs) {
+  let dirEntries;
+  try {
+    dirEntries = readdirSync(adminPagesDirAbs, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const pages = [];
+  for (const dirEntry of [...dirEntries].sort((a, b) => a.name.localeCompare(b.name))) {
+    if (!dirEntry.isDirectory()) continue;
+    const pageDir = join(adminPagesDirAbs, dirEntry.name);
+    const content = resolveEntryFile(pageDir, "content");
+    if (!content) continue;
+    const route = resolveEntryFile(pageDir, "route");
+    pages.push({
+      dirName: dirEntry.name,
+      content,
+      ...route ? { route } : {},
+      subRoutes: discoverSubRoutes(pageDir),
+      pageConfig: readPageConfig(pageDir)
+    });
+  }
+  return pages;
+}
+function discoverSubRoutes(pageDir) {
+  const routesDir = join(pageDir, "routes");
+  let dirEntries;
+  try {
+    dirEntries = readdirSync(routesDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const subRoutes = [];
+  for (const dirEntry of [...dirEntries].sort((a, b) => a.name.localeCompare(b.name))) {
+    if (!dirEntry.isDirectory()) continue;
+    const routeDir = join(routesDir, dirEntry.name);
+    const content = resolveEntryFile(routeDir, "content");
+    const route = resolveEntryFile(routeDir, "route");
+    if (!content && !route) continue;
+    subRoutes.push({
+      name: dirEntry.name,
+      path: readRoutePath(routeDir, dirEntry.name),
+      ...content ? { content } : {},
+      ...route ? { route } : {}
+    });
+  }
+  return subRoutes;
+}
+function readPageConfig(pageDir) {
+  const configPath = join(pageDir, "page.json");
+  if (!existsSync(configPath)) return {};
+  const raw = readJsonFile(configPath);
+  const config = {};
+  if (raw.title !== void 0) {
+    if (typeof raw.title !== "string") {
+      throw new Error(`wpAdminPages: ${configPath} \u2014 "title" must be a string.`);
+    }
+    config.title = raw.title;
+  }
+  if (raw.menu !== void 0) {
+    if (typeof raw.menu !== "object" || raw.menu === null || Array.isArray(raw.menu)) {
+      throw new Error(`wpAdminPages: ${configPath} \u2014 "menu" must be an object.`);
+    }
+    const menu = raw.menu;
+    const parsed = {};
+    if (menu.parent !== void 0) {
+      if (typeof menu.parent !== "string" && menu.parent !== false) {
+        throw new Error(
+          `wpAdminPages: ${configPath} \u2014 "menu.parent" must be a string or false.`
+        );
+      }
+      parsed.parent = menu.parent;
+    }
+    if (menu.capability !== void 0) {
+      if (typeof menu.capability !== "string") {
+        throw new Error(
+          `wpAdminPages: ${configPath} \u2014 "menu.capability" must be a string.`
+        );
+      }
+      parsed.capability = menu.capability;
+    }
+    if (menu.position !== void 0) {
+      if (typeof menu.position !== "number" || !Number.isFinite(menu.position)) {
+        throw new Error(`wpAdminPages: ${configPath} \u2014 "menu.position" must be a number.`);
+      }
+      parsed.position = menu.position;
+    }
+    if (menu.icon !== void 0) {
+      if (typeof menu.icon !== "string") {
+        throw new Error(`wpAdminPages: ${configPath} \u2014 "menu.icon" must be a string.`);
+      }
+      parsed.icon = menu.icon;
+    }
+    config.menu = parsed;
+  }
+  if (raw.init !== void 0) {
+    if (!Array.isArray(raw.init) || raw.init.some((id) => typeof id !== "string")) {
+      throw new Error(`wpAdminPages: ${configPath} \u2014 "init" must be an array of strings.`);
+    }
+    for (const moduleId of raw.init) {
+      if (!/^[A-Za-z0-9@._/-]+$/.test(moduleId)) {
+        throw new Error(
+          `wpAdminPages: ${configPath} \u2014 "init" entry "${moduleId}" is not a valid script module id.`
+        );
+      }
+    }
+    config.init = raw.init;
+  }
+  if (raw.modes !== void 0) {
+    if (!Array.isArray(raw.modes) || raw.modes.length === 0 || raw.modes.some((mode) => !ALL_PAGE_MODES.includes(mode))) {
+      throw new Error(
+        `wpAdminPages: ${configPath} \u2014 "modes" must be a non-empty array of ${ALL_PAGE_MODES.map(
+          (mode) => `"${mode}"`
+        ).join(" / ")}.`
+      );
+    }
+    config.modes = raw.modes;
+  }
+  if (raw.restPreload !== void 0) {
+    if (!Array.isArray(raw.restPreload)) {
+      throw new Error(`wpAdminPages: ${configPath} \u2014 "restPreload" must be an array.`);
+    }
+    const entries = [];
+    for (const entry of raw.restPreload) {
+      if (typeof entry === "string") {
+        entries.push(entry);
+        continue;
+      }
+      if (Array.isArray(entry) && entry.length === 2 && entry.every((part) => typeof part === "string")) {
+        entries.push([entry[0], entry[1]]);
+        continue;
+      }
+      throw new Error(
+        `wpAdminPages: ${configPath} \u2014 "restPreload" entries must be a path string or a [path, method] pair.`
+      );
+    }
+    config.restPreload = entries;
+  }
+  return config;
+}
+function readRoutePath(routeDir, name) {
+  const configPath = join(routeDir, "route.json");
+  if (!existsSync(configPath)) return `/${name}`;
+  const raw = readJsonFile(configPath);
+  if (raw.path === void 0) return `/${name}`;
+  if (typeof raw.path !== "string" || !raw.path.startsWith("/")) {
+    throw new Error(`wpAdminPages: ${configPath} \u2014 "path" must be a string starting with "/".`);
+  }
+  return raw.path;
+}
+function readJsonFile(filePath) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(filePath, "utf8"));
+  } catch (error) {
+    throw new Error(`wpAdminPages: could not parse ${filePath} \u2014 ${error.message}`, {
+      cause: error
+    });
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error(`wpAdminPages: ${filePath} must contain a JSON object.`);
+  }
+  return parsed;
+}
+var PAGE_ROOT_ROUTE_NAME = "index";
+function toGeneratedPage(page) {
+  if (!isValidSlug(page.dirName)) {
+    throw new Error(
+      `wpAdminPages: page directory "${page.dirName}" is not a valid page slug \u2014 use lowercase letters, digits and dashes.`
+    );
+  }
+  const routes = [
+    {
+      name: PAGE_ROOT_ROUTE_NAME,
+      path: "/",
+      dir: `modules/${page.dirName}`,
+      hasContent: true,
+      hasRoute: !!page.route
+    }
+  ];
+  for (const subRoute of page.subRoutes) {
+    if (!isValidSlug(subRoute.name)) {
+      throw new Error(
+        `wpAdminPages: route directory "${page.dirName}/routes/${subRoute.name}" is not a valid route name \u2014 use lowercase letters, digits and dashes.`
+      );
+    }
+    routes.push({
+      name: subRoute.name,
+      path: subRoute.path,
+      dir: `modules/${page.dirName}/routes/${subRoute.name}`,
+      hasContent: !!subRoute.content,
+      hasRoute: !!subRoute.route
+    });
+  }
+  const config = page.pageConfig;
+  return {
+    slug: page.dirName,
+    title: config.title ?? titleCase(page.dirName),
+    modes: config.modes ?? ALL_PAGE_MODES,
+    initModules: config.init ?? [],
+    restPreload: config.restPreload ?? DEFAULT_REST_PRELOAD,
+    ...config.menu ? { menu: config.menu } : {},
+    routes
+  };
+}
+function titleCase(slug) {
+  return slug.split("-").filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+function resolvePhpContext(php, projectRoot) {
+  const packageJsonPath = join(projectRoot, "package.json");
+  let packageJson = {};
+  if (existsSync(packageJsonPath)) {
+    packageJson = readJsonFile(packageJsonPath);
+  }
+  const packageName = (packageJson.name ?? "").replace(/^@[^/]+\//, "");
+  const prefix = php.prefix ?? packageJson.wpPlugin?.name ?? packageName;
+  if (!prefix) {
+    throw new Error(
+      "wpAdminPages: PHP generation needs an identifier prefix \u2014 set `adminPages.php.prefix`, or `wpPlugin.name` / `name` in package.json."
+    );
+  }
+  if (!isValidPhpIdentifier(prefix)) {
+    throw new Error(
+      `wpAdminPages: "${prefix}" is not a usable PHP identifier prefix. Use letters, digits, underscores and dashes (dashes become underscores), and don't start with a digit. Set \`adminPages.php.prefix\` or \`wpPlugin.name\` in package.json.`
+    );
+  }
+  const handlePrefix = php.handlePrefix ?? packageJson.wpPlugin?.handlePrefix ?? prefix;
+  if (!/^[A-Za-z0-9@._/-]+$/.test(handlePrefix)) {
+    throw new Error(
+      `wpAdminPages: "${handlePrefix}" is not a usable script module id prefix. Use letters, digits and \`@ . _ / -\`.`
+    );
+  }
+  const textdomain = php.textdomain ?? "default";
+  if (!/^[A-Za-z0-9._-]+$/.test(textdomain)) {
+    throw new Error(
+      `wpAdminPages: "${textdomain}" is not a usable text domain. Use letters, digits, dots, underscores and dashes.`
+    );
+  }
+  return {
+    prefix,
+    handlePrefix,
+    baseUrl: php.baseUrl ?? "plugin_dir_url( __FILE__ )",
+    version: packageJson.version ?? "0.0.0",
+    textdomain
+  };
+}
+function resolveEntryFile(pageDir, basename) {
+  for (const extension of ENTRY_EXTENSIONS) {
+    const candidate = join(pageDir, `${basename}${extension}`);
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+function reachableChunks(bundle, entryFileName) {
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [entryFileName];
+  while (queue.length > 0) {
+    const fileName = queue.shift();
+    if (visited.has(fileName)) continue;
+    const output = bundle[fileName];
+    if (!output || output.type !== "chunk") continue;
+    visited.add(fileName);
+    for (const imported of [...output.imports ?? [], ...output.dynamicImports ?? []]) {
+      if (!visited.has(imported)) queue.push(imported);
+    }
+  }
+  return visited;
+}
+function collectImportedCss(bundle, entryFileName) {
+  const visited = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Set();
+  const ordered = [];
+  const visit = (fileName) => {
+    if (visited.has(fileName)) return;
+    visited.add(fileName);
+    const output = bundle[fileName];
+    if (!output || output.type !== "chunk") return;
+    for (const imported of [...output.imports ?? [], ...output.dynamicImports ?? []]) {
+      visit(imported);
+    }
+    for (const cssFileName of output.viteMetadata?.importedCss ?? []) {
+      if (seen.has(cssFileName)) continue;
+      seen.add(cssFileName);
+      ordered.push(cssFileName);
+    }
+  };
+  visit(entryFileName);
+  return ordered;
+}
+function assetSourceToString(source) {
+  return typeof source === "string" ? source : Buffer.from(source).toString("utf8");
+}
+var SCRIPT_FIELDS = ["editorScript", "script", "viewScript"];
+var MODULE_FIELDS = ["scriptModule", "viewScriptModule"];
+var STYLE_FIELDS = ["style", "editorStyle", "viewStyle"];
+var EMPTY_MODULE_PASS_ENTRY = "\0wp-blocks-empty-module-pass";
+function wpBlocks(options) {
+  const buildType = options.buildType ?? "script";
+  const emitManifest = options.emitManifest ?? true;
+  const skip = new Set(options.skip ?? []);
+  let blocksDirAbs;
+  return {
+    name: "wp-blocks",
+    enforce: "pre",
+    config() {
+      blocksDirAbs = resolve(process.cwd(), options.blocksDir);
+      return {
+        build: {
+          rollupOptions: {
+            input: discoverEntries(blocksDirAbs, buildType, skip)
+          }
+        }
+      };
+    },
+    options(inputOptions) {
+      if (buildType !== "module") return null;
+      const input = inputOptions.input;
+      const isEmpty = input == null || Array.isArray(input) && input.length === 0 || typeof input === "object" && !Array.isArray(input) && Object.keys(input).length === 0;
+      if (!isEmpty) return null;
+      return {
+        ...inputOptions,
+        input: { "wp-blocks-empty-module-pass": EMPTY_MODULE_PASS_ENTRY }
+      };
+    },
+    resolveId(source) {
+      return source === EMPTY_MODULE_PASS_ENTRY ? source : null;
+    },
+    load(id) {
+      return id === EMPTY_MODULE_PASS_ENTRY ? "export {};" : null;
+    },
+    async buildStart() {
+      const blockJsons = await fg(`${blocksDirAbs.replace(/\\/g, "/")}/**/block.json`, {
+        absolute: true
+      });
+      for (const file of blockJsons) {
+        this.addWatchFile(file);
+      }
+    },
+    async generateBundle(_outputOptions, bundle) {
+      for (const [fileName, item] of Object.entries(bundle ?? {})) {
+        if (item.type === "chunk" && item.facadeModuleId === EMPTY_MODULE_PASS_ENTRY) {
+          delete bundle[fileName];
+        }
+      }
+      if (buildType !== "script") return;
+      const files = await fg(
+        [
+          `${blocksDirAbs.replace(/\\/g, "/")}/**/block.json`,
+          `${blocksDirAbs.replace(/\\/g, "/")}/**/*.php`
+        ],
+        { absolute: true }
+      );
+      for (const file of files) {
+        const relativePath = relative(blocksDirAbs, file).replace(/\\/g, "/");
+        const isBlockJson = relativePath.endsWith("block.json");
+        const source = isBlockJson ? transformBlockJson(readFileSync(file, "utf8"), file) : readFileSync(file);
+        this.emitFile({
+          type: "asset",
+          fileName: `blocks/${relativePath}`,
+          source
+        });
+      }
+      if (emitManifest) {
+        const manifest = buildBlocksManifest(blocksDirAbs, skip);
+        if (manifest) {
+          this.emitFile({
+            type: "asset",
+            fileName: "blocks-manifest.php",
+            source: manifest
+          });
+        }
+      }
+    }
+  };
+}
+function transformBlockJson(raw, blockJsonPath) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+  const scriptFields = [
+    "editorScript",
+    "script",
+    "viewScript",
+    "scriptModule",
+    "viewScriptModule"
+  ];
+  const styleFields = ["style", "editorStyle", "viewStyle"];
+  const rewriteRef = (ref, builtExtension) => {
+    if (typeof ref !== "string" || !ref.startsWith("file:")) return ref;
+    return ref.replace(/\.(tsx?|jsx?|s?css|sass)$/, builtExtension);
+  };
+  const explicitVersion = typeof parsed.version === "string" && parsed.version.length > 0;
+  if (!explicitVersion) {
+    const blockDir = dirname(blockJsonPath);
+    const versionHash = hashStyleContent(parsed, ["style", "viewStyle"], blockDir);
+    if (versionHash) {
+      parsed.version = versionHash;
+    }
+  }
+  for (const field of scriptFields) {
+    const fieldValue = parsed[field];
+    if (Array.isArray(fieldValue)) {
+      parsed[field] = fieldValue.map((ref) => rewriteRef(ref, ".js"));
+    } else {
+      parsed[field] = rewriteRef(fieldValue, ".js");
+    }
+  }
+  for (const field of styleFields) {
+    const fieldValue = parsed[field];
+    if (Array.isArray(fieldValue)) {
+      parsed[field] = fieldValue.map((ref) => rewriteRef(ref, ".css"));
+    } else {
+      parsed[field] = rewriteRef(fieldValue, ".css");
+    }
+  }
+  return JSON.stringify(parsed, null, "	") + "\n";
+}
+function hashStyleContent(metadata, fields, blockDir) {
+  const hash = createHash("sha256");
+  let hashedAnyFile = false;
+  for (const field of fields) {
+    const fieldValue = metadata[field];
+    const refs = Array.isArray(fieldValue) ? fieldValue : [fieldValue];
+    for (const ref of refs) {
+      if (typeof ref !== "string" || !ref.startsWith("file:")) continue;
+      const relativePath = ref.replace(/^file:/, "");
+      const absolutePath = join(blockDir, relativePath);
+      try {
+        hash.update(readFileSync(absolutePath));
+        hashedAnyFile = true;
+      } catch {
+      }
+    }
+  }
+  return hashedAnyFile ? hash.digest("hex") : "";
+}
+function buildBlocksManifest(blocksDirAbs, skip) {
+  const blockJsons = fg.sync(`${blocksDirAbs.replace(/\\/g, "/")}/**/block.json`, {
+    absolute: true
+  });
+  const entries = [];
+  for (const file of blockJsons) {
+    try {
+      const metadata = JSON.parse(transformBlockJson(readFileSync(file, "utf8"), file));
+      const blockDirName = relative(blocksDirAbs, file).replace(/[\\/]block\.json$/, "").replace(/\\/g, "/");
+      if (skip.has(blockDirName)) continue;
+      entries.push([blockDirName, metadata]);
+    } catch {
+    }
+  }
+  if (entries.length === 0) return null;
+  const body = entries.map(([blockDirName, metadata]) => `	'${blockDirName}' => ${phpExport(metadata, 1)},`).join("\n");
+  return `<?php
+// This file is generated. Do not modify it manually.
+return array(
+${body}
+);
+`;
+}
+function phpExport(value, indent) {
+  const pad = "	".repeat(indent);
+  const padInner = "	".repeat(indent + 1);
+  if (value === null) return "null";
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "number") return String(value);
+  if (typeof value === "string") return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "array()";
+    const items = value.map((item) => `${padInner}${phpExport(item, indent + 1)}`).join(",\n");
+    return `array(
+${items},
+${pad})`;
+  }
+  if (typeof value === "object") {
+    const keys = Object.keys(value);
+    if (keys.length === 0) return "array()";
+    const items = keys.map((key) => {
+      const entryValue = value[key];
+      const phpKey = `'${key.replace(/'/g, "\\'")}'`;
+      return `${padInner}${phpKey} => ${phpExport(entryValue, indent + 1)}`;
+    }).join(",\n");
+    return `array(
+${items},
+${pad})`;
+  }
+  return "null";
+}
+function discoverEntries(blocksDirAbs, buildType, skip) {
+  const entries = {};
+  const blockJsons = fg.sync(`${blocksDirAbs.replace(/\\/g, "/")}/**/block.json`, {
+    absolute: true
+  });
+  for (const blockJsonPath of blockJsons) {
+    const blockDirName = relative(blocksDirAbs, blockJsonPath).replace(/[\\/]block\.json$/, "").replace(/\\/g, "/");
+    if (skip.has(blockDirName)) continue;
+    let metadata;
+    try {
+      metadata = JSON.parse(readFileSync(blockJsonPath, "utf8"));
+    } catch {
+      continue;
+    }
+    const fields = buildType === "module" ? MODULE_FIELDS : [...SCRIPT_FIELDS, ...STYLE_FIELDS];
+    const refs = [];
+    for (const field of fields) {
+      const fieldValue = metadata[field];
+      if (typeof fieldValue === "string") refs.push(fieldValue);
+      else if (Array.isArray(fieldValue))
+        refs.push(...fieldValue.filter((item) => typeof item === "string"));
+    }
+    for (const ref of refs) {
+      if (!ref.startsWith("file:")) continue;
+      const declaredPath = ref.replace(/^file:/, "");
+      const pathWithoutExtension = declaredPath.replace(
+        /\.(js|ts|tsx|jsx|css|scss|sass)$/,
+        ""
+      );
+      const candidatePaths = [
+        join(dirname(blockJsonPath), `${pathWithoutExtension}.tsx`),
+        join(dirname(blockJsonPath), `${pathWithoutExtension}.ts`),
+        join(dirname(blockJsonPath), `${pathWithoutExtension}.jsx`),
+        join(dirname(blockJsonPath), `${pathWithoutExtension}.js`),
+        join(dirname(blockJsonPath), `${pathWithoutExtension}.scss`),
+        join(dirname(blockJsonPath), `${pathWithoutExtension}.sass`),
+        join(dirname(blockJsonPath), `${pathWithoutExtension}.css`)
+      ];
+      const sourcePath = candidatePaths.find((candidate) => existsSync(candidate));
+      if (!sourcePath) {
+        console.warn(`[wp-blocks] no source file found for ${ref} in ${blockJsonPath}`);
+        continue;
+      }
+      const entryName = `blocks/${relative(blocksDirAbs, sourcePath).replace(extname(sourcePath), "").replace(/\\/g, "/")}`;
+      entries[entryName] = sourcePath;
+    }
+  }
+  return entries;
+}
+function wpBlockStyles(options) {
+  let stylesDirAbs;
+  return {
+    name: "wp-block-styles",
+    enforce: "pre",
+    config() {
+      stylesDirAbs = resolve(process.cwd(), options.blocksStylesDir);
+      const stylesheets = fg.sync(
+        `${stylesDirAbs.replace(/\\/g, "/")}/**/*.{css,scss,sass}`,
+        { absolute: true }
+      );
+      const entries = {};
+      for (const filePath of stylesheets) {
+        const blockName = relative(stylesDirAbs, filePath).replace(extname(filePath), "").replace(/\\/g, "/");
+        entries[`autoenqueue/${blockName}`] = filePath;
+      }
+      return {
+        build: {
+          rollupOptions: {
+            input: entries
+          }
+        }
+      };
+    }
+  };
+}
+var DEFAULT_PATTERN = "**/*.{jpg,jpeg,png,gif,webp,avif,ico,svg,eot,ttf,woff,woff2,otf}";
+function wpCopyAssets(options) {
+  const pattern = options.pattern ?? DEFAULT_PATTERN;
+  const buildType = options.buildType ?? "script";
+  let copyDirAbs;
+  return {
+    name: `wp-copy-assets(${buildType})`,
+    enforce: "pre",
+    config() {
+      copyDirAbs = resolve(process.cwd(), options.copyAssetsDir);
+    },
+    async generateBundle() {
+      if (buildType !== "script") return;
+      const matches = await fg(pattern, {
+        cwd: copyDirAbs,
+        absolute: true,
+        onlyFiles: true
+      });
+      for (const file of matches) {
+        const relativePath = relative(copyDirAbs, file).replace(/\\/g, "/");
+        this.emitFile({
+          type: "asset",
+          fileName: relativePath,
+          source: readFileSync(file)
+        });
+      }
+    }
+  };
+}
+var cache = /* @__PURE__ */ new Map();
+function readPackageMetadata(packageName, projectRoot) {
+  const cacheKey = `${packageName}@${projectRoot}`;
+  if (cache.has(cacheKey)) {
+    return cache.get(cacheKey) ?? null;
+  }
+  try {
+    const require2 = createRequire(join(projectRoot, "package.json"));
+    const packageJsonPath = require2.resolve(`${packageName}/package.json`);
+    const metadata = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    cache.set(cacheKey, metadata);
+    return metadata;
+  } catch {
+    cache.set(cacheKey, null);
+    return null;
+  }
+}
+function splitImport(specifier) {
+  const parts = specifier.split("/");
+  if (specifier.startsWith("@")) {
+    if (parts.length < 2) return { name: specifier, subpath: null };
+    const name = `${parts[0]}/${parts[1]}`;
+    const subpath = parts.length > 2 ? parts.slice(2).join("/") : null;
+    return { name, subpath };
+  }
+  return {
+    name: parts[0] ?? specifier,
+    subpath: parts.length > 1 ? parts.slice(1).join("/") : null
+  };
+}
+function isScriptModule(metadata, subpath) {
+  const exports = metadata.wpScriptModuleExports;
+  if (!exports) return false;
+  if (subpath === null) {
+    if (typeof exports === "string") return true;
+    return typeof exports === "object" && "." in exports;
+  }
+  return typeof exports === "object" && `./${subpath}` in exports;
+}
+function camelize(kebabCaseName) {
+  return kebabCaseName.replace(/-(.)/g, (_match, letter) => letter.toUpperCase());
+}
+
+// src/wp-externals.ts
+var DEFAULT_VENDOR = {
+  react: { global: "React", handle: "react" },
+  "react-dom": { global: "ReactDOM", handle: "react-dom" },
+  "react-dom/client": { global: "ReactDOM", handle: "react-dom" },
+  "react/jsx-runtime": { global: "ReactJSXRuntime", handle: "react-jsx-runtime" },
+  "react/jsx-dev-runtime": { global: "ReactJSXRuntime", handle: "react-jsx-runtime" },
+  moment: { global: "moment", handle: "moment" },
+  jquery: { global: "jQuery", handle: "jquery" },
+  lodash: { global: "lodash", handle: "lodash" },
+  "lodash-es": { global: "lodash", handle: "lodash" }
+};
+var CJS_GLOBAL_SHIM_PREFIX = "\0wp-external-global:";
+var JS_IDENTIFIER = "[A-Za-z_$][\\w$]*";
+function rewriteImport(importStatement, globalAccess) {
+  const match = importStatement.match(/^\s*import\s+(.*?)\s+from\s+['"][^'"]+['"]\s*;?\s*$/s);
+  if (!match || !match[1]) return "";
+  const bindings = match[1].trim();
+  const namespaceImport = bindings.match(new RegExp(`^\\*\\s+as\\s+(${JS_IDENTIFIER})$`));
+  if (namespaceImport) return `const ${namespaceImport[1]} = ${globalAccess};`;
+  const defaultWithNamed = bindings.match(
+    new RegExp(`^(${JS_IDENTIFIER})\\s*,\\s*\\{(.+)\\}$`, "s")
+  );
+  if (defaultWithNamed) {
+    return [
+      `const ${defaultWithNamed[1]} = (${globalAccess} && ${globalAccess}.default) || ${globalAccess};`,
+      `const { ${namedImportsToDestructuring(defaultWithNamed[2].trim())} } = ${globalAccess};`
+    ].join(" ");
+  }
+  if (bindings.startsWith("{")) {
+    const namedImports = bindings.replace(/^\{|\}$/g, "").trim();
+    return `const { ${namedImportsToDestructuring(namedImports)} } = ${globalAccess};`;
+  }
+  if (new RegExp(`^${JS_IDENTIFIER}$`).test(bindings)) {
+    return `const ${bindings} = (${globalAccess} && ${globalAccess}.default) || ${globalAccess};`;
+  }
+  return null;
+}
+function namedImportsToDestructuring(namedImports) {
+  const aliasPattern = new RegExp(`^(${JS_IDENTIFIER})\\s+as\\s+(${JS_IDENTIFIER})$`);
+  return namedImports.split(",").map((binding) => binding.trim()).filter(Boolean).map((binding) => {
+    const aliased = binding.match(aliasPattern);
+    return aliased ? `${aliased[1]}: ${aliased[2]}` : binding;
+  }).join(", ");
+}
+function wpExternals(options = {}) {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const externalNamespaces = options.externalNamespaces ?? {};
+  const vendorExternals = options.additionalExternals ?? DEFAULT_VENDOR;
+  const buildType = options.buildType ?? "script";
+  const moduleEntryMatchers = options.moduleEntryMatchers ?? [];
+  const wpBuildAssetMatchers = options.wpBuildAssetMatchers ?? [];
+  const scriptModuleNamespaces = options.scriptModuleNamespaces ?? [];
+  function matchesScriptModuleNamespace(packageName) {
+    if (!packageName.startsWith("@")) return false;
+    const slashIndex = packageName.indexOf("/");
+    if (slashIndex < 0) return false;
+    const namespace = packageName.slice(1, slashIndex);
+    for (const pattern of scriptModuleNamespaces) {
+      if (pattern.endsWith("*")) {
+        if (namespace.startsWith(pattern.slice(0, -1))) return true;
+      } else if (namespace === pattern) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function buildModeForFile(moduleId) {
+    const filePath = moduleId.split("?")[0] ?? moduleId;
+    for (const pattern of moduleEntryMatchers) {
+      if (filePath.includes(pattern)) return "module";
+    }
+    return buildType;
+  }
+  function usesWpBuildAssetShape(facadeModuleId) {
+    if (!facadeModuleId) return false;
+    const filePath = (facadeModuleId.split("?")[0] ?? facadeModuleId).replace(/\\/g, "/");
+    for (const pattern of wpBuildAssetMatchers) {
+      if (filePath.includes(pattern.replace(/\\/g, "/"))) return true;
+    }
+    return false;
+  }
+  function resolveExternal(specifier) {
+    if (vendorExternals[specifier]) {
+      const vendor = vendorExternals[specifier];
+      return {
+        global: vendor.global,
+        handle: vendor.handle,
+        specifier,
+        moduleEligible: false,
+        scriptEligible: true
+      };
+    }
+    const { name, subpath } = splitImport(specifier);
+    if (name.startsWith("@wordpress/")) {
+      const meta = readPackageMetadata(name, projectRoot);
+      if (!meta) {
+        return null;
+      }
+      const shortName = name.slice("@wordpress/".length);
+      const moduleEligible = isScriptModule(meta, subpath);
+      const scriptEligible = !!meta.wpScript;
+      if (!moduleEligible && !scriptEligible) {
+        return null;
+      }
+      return {
+        global: scriptEligible ? `wp.${camelize(shortName)}` : null,
+        handle: scriptEligible ? `wp-${shortName}` : null,
+        specifier,
+        moduleEligible,
+        scriptEligible
+      };
+    }
+    for (const [namespace, config] of Object.entries(externalNamespaces)) {
+      if (name.startsWith(`@${namespace}/`)) {
+        const shortName = name.slice(`@${namespace}/`.length);
+        return {
+          global: `${config.global}.${camelize(shortName)}`,
+          handle: `${config.handlePrefix}-${shortName}`,
+          specifier,
+          moduleEligible: false,
+          scriptEligible: true
+        };
+      }
+    }
+    if (matchesScriptModuleNamespace(name)) {
+      return {
+        global: null,
+        handle: null,
+        specifier,
+        moduleEligible: true,
+        scriptEligible: false
+      };
+    }
+    return null;
+  }
+  function moduleImportKind(specifier, isDynamic) {
+    if (specifier === "@wordpress/interactivity") return "static";
+    return isDynamic ? "dynamic" : "static";
+  }
+  const staticDepsByModule = /* @__PURE__ */ new Map();
+  const dynamicDepsByModule = /* @__PURE__ */ new Map();
+  const handleDepsByModule = /* @__PURE__ */ new Map();
+  function recordDeps(map, moduleId, values) {
+    let set = map.get(moduleId);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      map.set(moduleId, set);
+    }
+    for (const value of values) set.add(value);
+  }
+  const resolverPlugin = {
+    name: `wp-externals-resolver(${buildType})`,
+    enforce: "pre",
+    resolveId(source, _importer, options2) {
+      const isRequireCall = options2?.kind === "require-call";
+      const external = resolveExternal(source);
+      if (external) {
+        if (isRequireCall) {
+          if (external.global) {
+            return CJS_GLOBAL_SHIM_PREFIX + source;
+          }
+          if (typeof this?.warn === "function") {
+            this.warn(
+              `${source} is required from CommonJS but is module-only (no wpScript in its package.json, so there is no window global to read). The bundled \`require('${source}')\` will throw at runtime \u2014 import it from ESM instead.`
+            );
+          }
+        }
+        return { id: source, external: true };
+      }
+      const commonjsMatch = source.match(/^\0([^?]+)\?commonjs-external$/);
+      if (commonjsMatch && commonjsMatch[1] && resolveExternal(commonjsMatch[1])) {
+        return source;
+      }
+      return null;
+    },
+    load(id) {
+      if (id.startsWith(CJS_GLOBAL_SHIM_PREFIX)) {
+        const specifier = id.slice(CJS_GLOBAL_SHIM_PREFIX.length);
+        const external2 = resolveExternal(specifier);
+        if (!external2 || !external2.global) return null;
+        if (external2.handle) recordDeps(handleDepsByModule, id, [external2.handle]);
+        return `module.exports = (typeof window !== "undefined" ? window.${external2.global} : {});
+`;
+      }
+      const commonjsMatch = id.match(/^\0([^?]+)\?commonjs-external$/);
+      if (!commonjsMatch || !commonjsMatch[1]) return null;
+      const external = resolveExternal(commonjsMatch[1]);
+      if (!external) return null;
+      if (buildModeForFile(id) === "module" && external.moduleEligible) {
+        return `export default {};`;
+      }
+      if (!external.global) {
+        return `export default {};`;
+      }
+      if (external.handle) recordDeps(handleDepsByModule, id, [external.handle]);
+      return `const __wpExternal = (typeof window !== "undefined" ? window.${external.global} : {}); export default __wpExternal;`;
+    }
+  };
+  const transformPlugin = {
+    name: `wp-externals(${buildType})`,
+    enforce: "post",
+    async transform(code, id) {
+      if (!code.includes("@wordpress/") && !Object.keys(vendorExternals).some((packageName) => code.includes(packageName)) && !Object.keys(externalNamespaces).some(
+        (namespace) => code.includes(`@${namespace}/`)
+      ) && !scriptModuleNamespaces.some(
+        (pattern) => code.includes(`@${pattern.endsWith("*") ? pattern.slice(0, -1) : pattern}`)
+      )) {
+        return null;
+      }
+      await init;
+      let imports;
+      try {
+        [imports] = parse(code);
+      } catch {
+        return null;
+      }
+      if (imports.length === 0) return null;
+      const magicString = new MagicString(code);
+      let codeChanged = false;
+      const fileMode = buildModeForFile(id);
+      const staticDeps = /* @__PURE__ */ new Set();
+      const dynamicDeps = /* @__PURE__ */ new Set();
+      const handleDeps = /* @__PURE__ */ new Set();
+      const rewriteToGlobal = (external, importRecord) => {
+        const importStatement = code.slice(importRecord.ss, importRecord.se);
+        const rewritten = rewriteImport(importStatement, `(window.${external.global})`);
+        if (rewritten === null) return false;
+        magicString.overwrite(importRecord.ss, importRecord.se, rewritten);
+        if (external.handle) handleDeps.add(external.handle);
+        return true;
+      };
+      for (const importRecord of imports) {
+        const importedSpecifier = importRecord.n;
+        if (importedSpecifier === void 0) continue;
+        const external = resolveExternal(importedSpecifier);
+        if (!external) continue;
+        const isDynamic = importRecord.d > -1;
+        if (fileMode === "script") {
+          if (isDynamic || !external.scriptEligible) {
+            if (!external.scriptEligible && !isDynamic) {
+              this.warn(
+                `${importedSpecifier} is module-only (no wpScript in its package.json) but imported into a script-mode entry. Move this import to a viewScriptModule entry, or this script will fail at runtime.`
+              );
+            }
+            continue;
+          }
+          if (rewriteToGlobal(external, importRecord)) codeChanged = true;
+        } else if (!external.moduleEligible) {
+          if (isDynamic) {
+            this.warn(
+              `${importedSpecifier} is not Script-Module-eligible (no wpScriptModuleExports in its package.json) and can't be dynamically imported from a module-mode entry. Import it statically (it gets read off its window global) or move it to a script-mode entry.`
+            );
+            continue;
+          }
+          if (rewriteToGlobal(external, importRecord)) codeChanged = true;
+        } else {
+          const importKind = moduleImportKind(importedSpecifier, isDynamic);
+          if (importKind === "static") {
+            staticDeps.add(external.specifier);
+          } else {
+            dynamicDeps.add(external.specifier);
+          }
+        }
+      }
+      if (staticDeps.size > 0) recordDeps(staticDepsByModule, id, staticDeps);
+      if (dynamicDeps.size > 0) recordDeps(dynamicDepsByModule, id, dynamicDeps);
+      if (handleDeps.size > 0) recordDeps(handleDepsByModule, id, handleDeps);
+      if (!codeChanged) return null;
+      return {
+        code: magicString.toString(),
+        map: magicString.generateMap({ hires: true })
+      };
+    },
+    generateBundle(_outputOptions, bundle) {
+      const chunksByFileName = /* @__PURE__ */ new Map();
+      for (const [fileName, output] of Object.entries(bundle)) {
+        if (output.type === "chunk") chunksByFileName.set(fileName, output);
+      }
+      for (const [fileName, output] of Object.entries(bundle)) {
+        if (output.type !== "chunk" || !output.isEntry) continue;
+        if (!fileName.endsWith(".js") && !fileName.endsWith(".mjs")) continue;
+        const reachableChunks2 = [];
+        const visited = /* @__PURE__ */ new Set([fileName]);
+        const queue = [fileName];
+        while (queue.length > 0) {
+          const currentFileName = queue.shift();
+          const chunk = chunksByFileName.get(currentFileName);
+          if (!chunk) continue;
+          reachableChunks2.push(chunk);
+          for (const imported of [
+            ...chunk.imports ?? [],
+            ...chunk.dynamicImports ?? []
+          ]) {
+            if (!chunksByFileName.has(imported) || visited.has(imported)) continue;
+            visited.add(imported);
+            queue.push(imported);
+          }
+        }
+        const entryHandles = /* @__PURE__ */ new Set();
+        const entryStaticDeps = /* @__PURE__ */ new Set();
+        const entryDynamicDeps = /* @__PURE__ */ new Set();
+        for (const chunk of reachableChunks2) {
+          for (const moduleId of Object.keys(chunk.modules ?? {})) {
+            const handles2 = handleDepsByModule.get(moduleId);
+            if (handles2) for (const handle of handles2) entryHandles.add(handle);
+            const staticDeps = staticDepsByModule.get(moduleId);
+            if (staticDeps) for (const dep of staticDeps) entryStaticDeps.add(dep);
+            const dynamicDeps = dynamicDepsByModule.get(moduleId);
+            if (dynamicDeps) for (const dep of dynamicDeps) entryDynamicDeps.add(dep);
+          }
+        }
+        let entryMode = buildType;
+        for (const moduleId of Object.keys(output.modules ?? {})) {
+          if (buildModeForFile(moduleId) === "module") entryMode = "module";
+        }
+        const hash = crypto.createHash("md5").update(output.code);
+        const cssFileNames = /* @__PURE__ */ new Set();
+        for (const chunk of reachableChunks2) {
+          for (const cssFileName of chunk.viteMetadata?.importedCss ?? []) {
+            cssFileNames.add(cssFileName);
+          }
+        }
+        for (const cssFileName of [...cssFileNames].sort()) {
+          const cssAsset = bundle[cssFileName];
+          if (!cssAsset || cssAsset.type !== "asset") continue;
+          hash.update(cssAsset.source);
+        }
+        const version = hash.digest("hex").slice(0, 20);
+        const handles = [...entryHandles].sort();
+        const phpList = (items) => items.length > 0 ? ` ${items.join(", ")} ` : "";
+        const moduleImportKinds = /* @__PURE__ */ new Map();
+        for (const dep of entryDynamicDeps) moduleImportKinds.set(dep, "dynamic");
+        for (const dep of entryStaticDeps) moduleImportKinds.set(dep, "static");
+        const sortedModuleDeps = [...moduleImportKinds.entries()].sort(
+          ([a], [b]) => a < b ? -1 : a > b ? 1 : 0
+        );
+        const fields = [];
+        if (usesWpBuildAssetShape(output.facadeModuleId)) {
+          fields.push(
+            `'dependencies' => array(${phpList(handles.map((handle) => `'${handle}'`))})`
+          );
+          const moduleDependencies = sortedModuleDeps.map(
+            ([dep, kind]) => `array( 'id' => '${dep}', 'import' => '${kind}' )`
+          );
+          if (moduleDependencies.length > 0) {
+            fields.push(
+              `'module_dependencies' => array(${phpList(moduleDependencies)})`
+            );
+          }
+        } else if (entryMode === "module") {
+          const moduleDependencies = sortedModuleDeps.map(
+            ([dep, kind]) => kind === "static" ? `'${dep}'` : `array( 'id' => '${dep}', 'import' => 'dynamic' )`
+          );
+          fields.push(`'dependencies' => array(${phpList(moduleDependencies)})`);
+          if (handles.length > 0) {
+            fields.push(
+              `'script_dependencies' => array(${phpList(
+                handles.map((handle) => `'${handle}'`)
+              )})`
+            );
+          }
+        } else {
+          fields.push(
+            `'dependencies' => array(${phpList(handles.map((handle) => `'${handle}'`))})`
+          );
+        }
+        fields.push(`'version' => '${version}'`);
+        if (entryMode === "module") fields.push(`'type' => 'module'`);
+        this.emitFile({
+          type: "asset",
+          fileName: fileName.replace(/\.m?js$/, ".asset.php"),
+          source: `<?php return array( ${fields.join(", ")} );
+`
+        });
+      }
+    }
+  };
+  return [resolverPlugin, transformPlugin];
+}
+
+// src/wp-script-iife.ts
+function wpScriptIife() {
+  return {
+    name: "wp-script-iife",
+    async writeBundle(options, bundle) {
+      const { readFile, writeFile } = await import('fs/promises');
+      const { join: join4 } = await import('path');
+      const outDir = options.dir ?? ".";
+      for (const [fileName, output] of Object.entries(bundle)) {
+        if (output.type !== "chunk") continue;
+        if (!fileName.endsWith(".js") && !fileName.endsWith(".mjs")) continue;
+        if (!output.isEntry && !output.isDynamicEntry) continue;
+        const filePath = join4(outDir, fileName);
+        let chunkSource = await readFile(filePath, "utf8");
+        const sideEffectImport = /^\s*import\s+["'][^"']+["'];?\s*\n?/;
+        while (sideEffectImport.test(chunkSource)) {
+          chunkSource = chunkSource.replace(sideEffectImport, "");
+        }
+        await writeFile(filePath, `(()=>{
+${chunkSource}
+})();
+`);
+      }
+    }
+  };
+}
+
+// src/wp-clean-css-chunks.ts
+function wpCleanCssChunks() {
+  return {
+    name: "wp-clean-css-chunks",
+    generateBundle(_options, bundle) {
+      for (const [fileName, output] of Object.entries(bundle)) {
+        if (output.type !== "chunk") continue;
+        const facadeModuleId = output.facadeModuleId ?? "";
+        if (/\.(s?css|sass)$/.test(facadeModuleId)) {
+          delete bundle[fileName];
+        }
+      }
+    }
+  };
+}
+
+// src/wp.ts
+function wp(options = {}) {
+  const buildType = options.buildType ?? "script";
+  const plugins = [];
+  if (options.blocks !== false) {
+    const blocksOptions = typeof options.blocks === "object" ? options.blocks : void 0;
+    const blocksDir = blocksOptions?.blocksDir ?? options.blocksDir;
+    if (blocksDir) {
+      plugins.push(
+        wpBlocks({
+          blocksDir,
+          buildType,
+          ...blocksOptions
+        })
+      );
+    }
+  }
+  if (options.blockStyles !== false) {
+    const blockStylesOptions = typeof options.blockStyles === "object" ? options.blockStyles : void 0;
+    const blocksStylesDir = blockStylesOptions?.blocksStylesDir ?? options.blocksStylesDir;
+    if (blocksStylesDir) {
+      plugins.push(
+        wpBlockStyles({
+          blocksStylesDir,
+          ...blockStylesOptions
+        })
+      );
+    }
+  }
+  if (options.copyAssets !== false) {
+    const copyAssetsOptions = typeof options.copyAssets === "object" ? options.copyAssets : void 0;
+    const copyAssetsDir = copyAssetsOptions?.copyAssetsDir ?? options.copyAssetsDir;
+    if (copyAssetsDir) {
+      plugins.push(
+        wpCopyAssets({
+          copyAssetsDir,
+          buildType,
+          ...copyAssetsOptions
+        })
+      );
+    }
+  }
+  let activeAdminPagesDir;
+  if (options.adminPages !== false) {
+    const adminPagesOptions = typeof options.adminPages === "object" ? options.adminPages : void 0;
+    const adminPagesDir = adminPagesOptions?.adminPagesDir ?? options.adminPagesDir;
+    if (adminPagesDir) {
+      activeAdminPagesDir = adminPagesDir;
+      plugins.push(
+        wpAdminPages({
+          adminPagesDir,
+          buildType,
+          ...adminPagesOptions
+        })
+      );
+    }
+  }
+  if (options.externals !== false) {
+    const externalsOptions = typeof options.externals === "object" ? options.externals : void 0;
+    const wpBuildAssetMatchers = [...externalsOptions?.wpBuildAssetMatchers ?? []];
+    if (activeAdminPagesDir) {
+      const matcher = resolve(process.cwd(), activeAdminPagesDir).replace(/\\/g, "/");
+      if (!wpBuildAssetMatchers.includes(matcher)) wpBuildAssetMatchers.push(matcher);
+    }
+    plugins.push(
+      ...wpExternals({
+        buildType,
+        ...externalsOptions,
+        ...wpBuildAssetMatchers.length > 0 ? { wpBuildAssetMatchers } : {}
+      })
+    );
+  }
+  if (buildType === "script" && options.iife !== false) {
+    plugins.push(wpScriptIife());
+  }
+  if (options.cleanCssChunks !== false) {
+    plugins.push(wpCleanCssChunks());
+  }
+  return plugins;
+}
+
+export { wp, wpAdminPages, wpBlockStyles, wpBlocks, wpCleanCssChunks, wpCopyAssets, wpExternals, wpScriptIife };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map