@vigla/kit 0.0.0-stage → 0.1.1

package/src/vite/remote-build.ts

@@ -0,0 +1,198 @@
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import remapping from '@jridgewell/remapping';
+import MagicString from 'magic-string';
+import type { ESTree, Rolldown } from 'vite';
+import { write } from '../build/index.ts';
+import type { Project } from './project.ts';
+
+interface OutputModule {
+	file: string;
+	code: string;
+	body: ESTree.Program['body'];
+	edits: MagicString;
+}
+interface Binding {
+	module: OutputModule;
+	variable: ESTree.VariableDeclarator;
+}
+
+function nameOf(node: ESTree.Node): string | undefined {
+	return node.type === 'Identifier'
+		? node.name
+		: 'value' in node && typeof node.value === 'string'
+			? node.value
+			: undefined;
+}
+
+function throughChunkMap(treeshaken: string, file: string, original: string): string {
+	const map = JSON.parse(treeshaken) as { sources: string[] };
+	const chunk = path.basename(file);
+	map.sources = map.sources.map((source) => (path.basename(source) === chunk ? chunk : source));
+	return JSON.stringify(
+		remapping(map as Parameters<typeof remapping>[0], (source) =>
+			source === chunk ? JSON.parse(original) : null
+		)
+	);
+}
+
+export async function pruneRemotes(project: Project): Promise<void> {
+	const context = project.build!;
+	const directory = path.join(context.config.outDir, 'output/server');
+	const modules = new Map<string, OutputModule>();
+	const changed = new Set<OutputModule>();
+	const replaced = new Set<ESTree.VariableDeclarator>();
+	const message = project.diagnostics.text(
+		'remote_prerender_not_dynamic',
+		'Unexpectedly called `prerender` function. Did you forget to set `{ dynamic: true }`?'
+	);
+	function load(file: string): OutputModule {
+		const previous = modules.get(file);
+		if (previous) return previous;
+		const code = readFileSync(file, 'utf8');
+		const parsed = project.api.parseSync(file, code, { sourceType: 'module' });
+		if (parsed.errors.length) throw new Error(parsed.errors[0]!.message);
+		const module = { file, code, body: parsed.program.body, edits: new MagicString(code) };
+		modules.set(file, module);
+		return module;
+	}
+	function local(module: OutputModule, name: string): Binding {
+		for (const statement of module.body) {
+			if (statement.type === 'ImportDeclaration') {
+				for (const specifier of statement.specifiers) {
+					if (specifier.local.name !== name) continue;
+					if (specifier.type === 'ImportNamespaceSpecifier') break;
+					const imported =
+						specifier.type === 'ImportDefaultSpecifier' ? 'default' : nameOf(specifier.imported)!;
+					return exported(
+						load(path.resolve(path.dirname(module.file), statement.source.value)),
+						imported
+					);
+				}
+			}
+			const declaration =
+				statement.type === 'ExportNamedDeclaration' ? statement.declaration : statement;
+			if (declaration?.type !== 'VariableDeclaration') continue;
+			for (const variable of declaration.declarations) {
+				if (variable.id.type !== 'Identifier' || variable.id.name !== name) continue;
+				return variable.init?.type === 'Identifier'
+					? local(module, variable.init.name)
+					: { module, variable };
+			}
+		}
+		throw new Error(`Cannot locate remote binding ${name} in ${module.file}`);
+	}
+	function exported(module: OutputModule, name: string): Binding {
+		for (const statement of module.body) {
+			if (
+				statement.type === 'ExportDefaultDeclaration' &&
+				name === 'default' &&
+				statement.declaration.type === 'Identifier'
+			)
+				return local(module, statement.declaration.name);
+			if (statement.type !== 'ExportNamedDeclaration') continue;
+			for (const specifier of statement.specifiers) {
+				if (nameOf(specifier.exported) !== name) continue;
+				const binding = nameOf(specifier.local)!;
+				return statement.source
+					? exported(load(path.resolve(path.dirname(module.file), statement.source.value)), binding)
+					: local(module, binding);
+			}
+			if (statement.declaration?.type === 'VariableDeclaration')
+				for (const variable of statement.declaration.declarations)
+					if (variable.id.type === 'Identifier' && variable.id.name === name)
+						return local(module, name);
+		}
+		throw new Error(`Cannot locate remote export ${name} in ${module.file}`);
+	}
+	for (const [id, metadata] of context.analysis.remotes) {
+		const names = [...metadata].filter(([, value]) => value.type === 'prerender' && !value.dynamic);
+		if (!names.length) continue;
+		const entry = exported(load(path.join(directory, context.artifacts.remotes[id]!)), 'default');
+		let namespace: ESTree.Expression | null | undefined = entry.variable.init;
+		if (namespace?.type === 'CallExpression')
+			namespace = namespace.arguments.find((argument) => argument.type === 'ObjectExpression') as
+				| ESTree.ObjectExpression
+				| undefined;
+		if (namespace?.type !== 'ObjectExpression')
+			throw new Error(`Cannot locate remote namespace ${id}`);
+		for (const [name] of names) {
+			const property = namespace.properties.find(
+				(property) => property.type === 'Property' && nameOf(property.key) === name
+			);
+			if (!property || property.type !== 'Property')
+				throw new Error(`Cannot locate remote function ${id}/${name}`);
+			let value = property.value;
+			if (value.type === 'ArrowFunctionExpression' && value.body.type === 'Identifier')
+				value = value.body;
+			if (property.kind === 'get' && value.type === 'FunctionExpression' && value.body) {
+				const returned = value.body.body.find((statement) => statement.type === 'ReturnStatement');
+				if (returned?.type === 'ReturnStatement' && returned.argument) value = returned.argument;
+			}
+			if (value.type !== 'Identifier')
+				throw new Error(
+					`Cannot locate remote function binding ${id}/${name}: ${entry.module.code.slice(property.start, property.end)}`
+				);
+			const binding = local(entry.module, value.name);
+			if (replaced.has(binding.variable)) continue;
+			const init = binding.variable.init;
+			if (init?.type !== 'CallExpression')
+				throw new Error(`Cannot locate remote factory ${id}/${name}`);
+			const factory = binding.module.code.slice(init.callee.start, init.callee.end);
+			binding.module.edits.overwrite(
+				init.start,
+				init.end,
+				`${factory}('unchecked', () => { throw new Error(${JSON.stringify(message)}) })`
+			);
+			replaced.add(binding.variable);
+			changed.add(binding.module);
+		}
+	}
+	for (const module of changed) {
+		const chunkMap = module.file + '.map';
+		const original = existsSync(chunkMap) ? readFileSync(chunkMap, 'utf8') : null;
+		const result = (await project.api.build({
+			root: project.root,
+			configFile: false,
+			logLevel: 'silent',
+			publicDir: false,
+			plugins: [
+				{
+					name: 'kit:prerender-remotes',
+					transform(_code, id) {
+						if (id !== module.file) return;
+						return {
+							code: module.edits.toString(),
+							map: module.edits.generateMap({
+								source: module.file,
+								includeContent: true,
+								hires: 'boundary'
+							})
+						};
+					}
+				}
+			],
+			build: {
+				ssr: true,
+				write: false,
+				minify: false,
+				target: 'esnext',
+				sourcemap: project.vite.environments.ssr?.build?.sourcemap ?? project.vite.build.sourcemap,
+				rolldownOptions: {
+					input: module.file,
+					external: (id) => id !== module.file,
+					output: { entryFileNames: path.basename(module.file) }
+				}
+			}
+		})) as Rolldown.RolldownOutput;
+		for (const output of result.output)
+			write(
+				output.type === 'chunk' ? module.file : chunkMap,
+				output.type === 'chunk'
+					? output.code
+					: original
+						? throughChunkMap(String(output.source), module.file, original)
+						: output.source
+			);
+	}
+}

package/src/vite/remote.ts

@@ -0,0 +1,138 @@
+import path from 'node:path';
+import type { Plugin, Rolldown, ViteDevServer } from 'vite';
+import type { RemoteMetadata } from '../build/index.ts';
+import { hash } from '../shared/hash.ts';
+import type { Identity } from '../types/identity.ts';
+import type { RemoteExport, RemoteInternals } from '../types/internal/remote.ts';
+import { isRunnable } from '../sync/index.ts';
+import { fileUrl, isRemoteModule, posix, remotePattern } from './paths.ts';
+import { ViteMessages } from './messages.ts';
+import type { Project } from './project.ts';
+
+export interface RemoteEntry {
+	file: string;
+	chunk?: string;
+}
+
+export interface RemoteIntegration {
+	plugins: Plugin[];
+	scan: Rolldown.Plugin;
+	entries: ReadonlyMap<string, RemoteEntry>;
+}
+
+const prefix = '\0kit:remote:';
+const kinds = new Set(['query', 'query_batch', 'query_live', 'command', 'form', 'prerender']);
+
+export function createRemotePlugin(
+	getProject: () => Project,
+	identity: Identity
+): RemoteIntegration {
+	const isRemote = (id: string) => isRemoteModule(id, identity.packages);
+	const entries = new Map<string, RemoteEntry>();
+	const references = new Map<string, string>();
+	let server: ViteDevServer | undefined;
+
+	const scan: Rolldown.Plugin = {
+		name: 'kit:scan-remotes',
+		resolveId: {
+			filter: { id: remotePattern },
+			async handler(id, importer) {
+				const resolved = await this.resolve(id, importer, { skipSelf: true });
+				if (!resolved) return { id, external: true };
+				if (!isRemote(resolved.id)) return;
+				return { id: fileUrl(resolved.id), external: 'absolute' };
+			}
+		}
+	};
+
+	const plugin: Plugin = {
+		name: 'kit:remote',
+		configureServer(dev) {
+			server = dev;
+		},
+		applyToEnvironment(environment) {
+			return environment.name !== 'serviceWorker';
+		},
+		perEnvironmentStartEndDuringDev: true,
+		buildStart() {
+			if (this.environment.config.consumer === 'server' && !server) {
+				entries.clear();
+				references.clear();
+			}
+		},
+		resolveId(id) {
+			if (id.startsWith(prefix)) return id;
+		},
+		load(id) {
+			if (!id.startsWith(prefix)) return;
+			const entry = entries.get(id.slice(prefix.length));
+			if (!entry) throw new Error(`Unknown remote entry: ${id.slice(prefix.length)}`);
+			return `import * as functions from ${JSON.stringify(entry.file)}; export default functions;`;
+		},
+		async transform(code, id) {
+			if (!isRemote(id)) return;
+			const project = getProject();
+			if (!project.config.experimental.remoteFunctions)
+				new ViteMessages(project.diagnostics).config_feature_disabled({
+					feature: 'remote functions',
+					keypath: 'experimental.remoteFunctions',
+					value: 'true'
+				});
+			const file = posix(path.relative(project.root, id));
+			const key = hash(file);
+			if (this.environment.config.consumer === 'server') {
+				const existing = entries.get(key);
+				if (existing && existing.file !== id)
+					throw new Error(`Remote hash collision: ${id} and ${existing.file}`);
+				if (!existing) entries.set(key, { file: id });
+				if (!server && !references.has(key)) {
+					const reference = this.emitFile({
+						type: 'chunk',
+						id: prefix + key,
+						name: `remote-${key}`
+					});
+					references.set(key, reference);
+				}
+				let self = '$$kit_remote_self';
+				let init = '$$kit_init_remote';
+				while (code.includes(self)) self += '$';
+				while (code.includes(init)) init += '$';
+				return {
+					code: `${code}\n\nimport * as ${self} from ${JSON.stringify(id)};\nimport { initRemote as ${init} } from ${JSON.stringify(`${project.name}/internal/server`)};\n${server ? 'await Promise.resolve();\n' : ''}for (const [name, value] of Object.entries(${self})) ${init}(value, ${JSON.stringify(key + '/')} + name);\n`,
+					map: null
+				};
+			}
+			let exports: Iterable<[string, RemoteInternals | RemoteMetadata]>;
+			if (server) {
+				const environment = server.environments.ssr;
+				if (!isRunnable(environment)) throw new Error('The Vite SSR environment is not runnable');
+				const module = (await environment.runner.import(id)) as Record<string, RemoteExport>;
+				exports = Object.entries(module).map(([name, value]) => [name, value.__]);
+			} else {
+				const metadata = project.build?.analysis.remotes.get(key);
+				if (!metadata) throw new Error(`Missing remote analysis for ${file}`);
+				exports = metadata;
+			}
+			const declarations: string[] = [];
+			let index = 0;
+			for (const [name, info] of exports) {
+				if (!info || !kinds.has(info.type))
+					new ViteMessages(project.diagnostics).remote_module_invalid_export({ name, file });
+				const local = `$$remote_${index++}`;
+				declarations.push(
+					`const ${local} = remote.${info.type}(${JSON.stringify(key + '/' + name)}); export { ${local} as ${JSON.stringify(name)} };`
+				);
+			}
+			return {
+				code: `import * as remote from ${JSON.stringify(`${project.name}/internal/client`)};\n${declarations.join('\n')}\n${server ? 'import.meta.hot?.accept();\n' : ''}`,
+				map: null
+			};
+		},
+		generateBundle() {
+			if (this.environment.config.consumer !== 'server') return;
+			for (const [key, reference] of references)
+				entries.get(key)!.chunk = this.getFileName(reference);
+		}
+	};
+	return { plugins: [plugin], scan, entries };
+}

package/src/vite/server.ts

@@ -0,0 +1,166 @@
+import path from 'node:path';
+import { uneval } from 'devalue';
+import { loadErrorPage, loadTemplate } from '../config/index.ts';
+import { escapeHtml } from '../shared/escape.ts';
+import type { PageNode } from '../types/internal/routes.ts';
+import type { Project } from './project.ts';
+import { ids, nodeId } from './ids.ts';
+import { resolveEntry } from '../sync/index.ts';
+import { codeFile, fileUrl, moduleUrl, posix } from './paths.ts';
+
+export function serverEntry(name: string, dev: boolean): string {
+	return `import { Server as Runtime } from ${JSON.stringify(`${name}/internal/server`)};
+${dev ? `import { manifest as developmentManifest } from ${JSON.stringify(ids.manifest)}; export { developmentManifest as manifest };` : ''}
+let active, configured, ready;
+export async function configure(input) {
+const { options } = await import(${JSON.stringify(ids.options)});
+const { updateEnv, values } = await import(${JSON.stringify(ids.env)});
+const manifest = input.manifest ?? active?.manifest${dev ? ' ?? developmentManifest' : ''};
+if (!manifest) throw new Error('A server manifest is required before application initialization');
+if (!active || active.manifest !== manifest) {
+const state = { ...options, paths: { ...options.paths }, building: !!input.building, prerendering: !!input.prerendering };
+if (input.assets !== undefined) state.paths.assets = input.assets;
+if (input.fix_stack_trace) state.fixStack = error => { input.fix_stack_trace(error); return error; };
+const server = new Runtime(manifest, { ...state, remote: async call => { await manifest.remotes[call.id]?.(); const { handleRemote } = await import(${JSON.stringify(name + '/internal/server')}); return handleRemote(call); } });
+const initialization = { env: input.env ?? values, read: input.read, scope: input.scope };
+active = server;
+configured = { init: () => server.init(initialization), respond: (request, options) => server.respond(request, options), set_env: env => { updateEnv(env); } };
+ready = server.configure(initialization);
+} else {
+if (input.building) active.options.building = true;
+if (input.prerendering) active.options.prerendering = true;
+if (input.assets !== undefined) active.options.paths.assets = input.assets;
+if (input.fix_stack_trace) active.options.fixStack = error => { input.fix_stack_trace(error); return error; };
+await ready;
+if (input.env) await active.setEnv(input.env);
+}
+const result = configured;
+await ready;
+return result;
+}
+export function create_server(manifest) {
+let server;
+return { async init(options) { server = await configure({ ...options, manifest }); await server.init(); }, respond(request, options) { return server.respond(request, options); } };
+}
+export class Server {
+constructor(manifest) { this.server = create_server(manifest); }
+init(options) { return this.server.init(options); }
+respond(request, options) { return this.server.respond(request, options); }
+}
+export function format_response(status, request) { const url = new URL(request.url); return status + ' ' + request.method + ' ' + url.href.slice(url.origin.length); }`;
+}
+
+function templateExpression(
+	name: string,
+	template: string,
+	expressions: Record<string, string>
+): string {
+	const parts: string[] = [];
+	let offset = 0;
+	for (const match of template.matchAll(new RegExp(`%${name}\\.([^%]+)%`, 'g'))) {
+		const token = match[1]!;
+		const expression =
+			expressions[token] ??
+			(token.startsWith('env.') ? `(env[${JSON.stringify(token.slice(4))}] ?? '')` : undefined);
+		if (expression === undefined) continue;
+		parts.push(JSON.stringify(template.slice(offset, match.index)), expression);
+		offset = match.index + match[0].length;
+	}
+	parts.push(JSON.stringify(template.slice(offset)));
+	return parts.join(' + ');
+}
+
+export function errorTemplate(project: Project): string {
+	const { config, diagnostics, identity } = project;
+	return `export default ({ status, message }) => ${templateExpression(identity.name, loadErrorPage(config, diagnostics), { status: 'status', 'error.message': 'message' })};`;
+}
+
+export function serverOptions(project: Project): string {
+	const { config, tree, root, format } = project;
+	const dev = project.vite.command === 'serve';
+	const template = loadTemplate(root, config, project.diagnostics);
+	const app = templateExpression(project.identity.name, template, {
+		head: dev
+			? `head + ${JSON.stringify(`<script type="module" src="${config.paths.base}/@vite/client"></script>`)}`
+			: 'head',
+		body: 'body',
+		assets: 'assets',
+		nonce: 'nonce',
+		version: JSON.stringify(escapeHtml(config.version.name))
+	});
+	const worker = resolveEntry(config.files.serviceWorker, config.moduleExtensions);
+	return `import root from ${JSON.stringify(ids.root)};
+import error from ${JSON.stringify(ids.errorTemplate)};
+import { setEnv } from ${JSON.stringify(ids.env)};
+export const options = {
+root, format: ${uneval(format)}, extension: ${uneval(config.extensions[0] ?? '')}, adapter: ${uneval(config.adapter?.name ?? '')}, global: ${JSON.stringify(project.global)},
+appTemplateContainsNonce: ${template.includes(`%${project.identity.name}.nonce%`)},
+csp: ${uneval(config.csp)},
+csrf: ${uneval({ checkOrigin: !config.csrf.trustedOrigins.includes('*'), trustedOrigins: config.csrf.trustedOrigins })},
+paths: ${uneval(config.paths)}, env: { set: setEnv },
+serviceWorker: ${uneval(config.serviceWorker.register && worker ? { file: 'service-worker.js', options: config.serviceWorker.options ?? {} } : null)},
+version: ${uneval({ name: config.version.name, pollInterval: dev ? 0 : config.version.pollInterval })},
+output: ${uneval(config.output)}, router: ${uneval(config.router)}, embedded: ${config.embedded},
+tracing: ${uneval(config.tracing)}, dev: ${dev}, building: false, prerendering: false,
+templates: { app: ({ head, body, assets, nonce, env }) => ${app}, error },
+async getHooks() {
+const server = ${tree.hooks.server ? `await import(${JSON.stringify(posix(path.resolve(root, tree.hooks.server)))})` : '{}'};
+const universal = ${tree.hooks.universal ? `await import(${JSON.stringify(posix(path.resolve(root, tree.hooks.universal)))})` : '{}'};
+return { handle: server.handle, handleFetch: server.handleFetch, handleError: server.handleError, init: server.init, reroute: universal.reroute, transport: universal.transport };
+}
+};`;
+}
+
+export function importsUniversal(node: PageNode | undefined): boolean {
+	return !!node?.universal && node.options?.ssr !== false;
+}
+
+export function serverManifest(project: Project): string {
+	const { config, tree, root } = project;
+	const absolute = (file: string) => JSON.stringify(posix(path.resolve(root, file)));
+	const nodes = tree.nodes.map((node, index) => {
+		const component = node.component
+			? absolute(node.component)
+			: JSON.stringify(index === 1 ? ids.error : ids.layout);
+		const universal = importsUniversal(node)
+			? `await import(${absolute(node.universal!)})`
+			: node.universal
+				? uneval(node.options)
+				: 'undefined';
+		return `async () => ({ index: ${index}, imports: [], stylesheets: [], fonts: [], component: () => import(${component}).then(module => module.default), universal: ${universal}, server: ${node.server ? `await import(${absolute(node.server)})` : 'undefined'}, universal_id: ${uneval(node.universal)}, server_id: ${uneval(node.server)} })`;
+	});
+	const routes = tree.routes
+		.filter((route) => route.page || route.endpoint)
+		.map(
+			(route) => `{
+id: ${JSON.stringify(route.id)}, pattern: ${route.pattern}, params: ${uneval(route.params)}, page: ${uneval(route.page)},
+endpoint: ${route.endpoint ? `() => import(${absolute(route.endpoint.file)})` : 'null'}, endpoint_id: ${uneval(route.endpoint?.file)}
+}`
+		);
+	const clientRoutes =
+		config.router.resolution === 'server'
+			? tree.routes
+					.filter((route) => route.page)
+					.map((route) => ({
+						id: route.id,
+						pattern: route.pattern,
+						params: route.params,
+						errors: route.page!.errors,
+						layouts: route.page!.layouts.map((index) =>
+							index === undefined ? undefined : [!!tree.nodes[index]?.server, index]
+						),
+						leaf: [!!tree.nodes[route.page!.leaf]?.server, route.page!.leaf]
+					}))
+			: undefined;
+	const hasMatchers = tree.routes.some((route) => route.params.some((param) => param.matcher));
+	const mimeTypes = Object.fromEntries(
+		tree.assets.filter((asset) => asset.type).map((asset) => [path.extname(asset.file), asset.type])
+	);
+	return `export const manifest = {
+app_dir: ${JSON.stringify(config.appDir)}, app_path: ${JSON.stringify([config.paths.base.slice(1), config.appDir].filter(Boolean).join('/'))},
+assets: new Set(${uneval(tree.assets.map((asset) => asset.file))}), mime_types: ${uneval(mimeTypes)},
+client: ${uneval({ start: fileUrl(codeFile('entries/internal/client')), app: fileUrl(ids.client), imports: [], stylesheets: [], fonts: [], uses_env_dynamic_public: true, nodes: config.router.resolution === 'server' ? tree.nodes.map((_, index) => moduleUrl(nodeId(project, index), root)) : undefined, routes: clientRoutes })},
+nodes: [${nodes.join(',\n')}], routes: [${routes.join(',\n')}], remotes: {}, prerendered_routes: new Set(), server_assets: {},
+async matchers() { return ${tree.params && hasMatchers ? `(await import(${absolute(tree.params)})).params` : '{}'}; }
+};`;
+}

package/src/vite/styles.ts

@@ -0,0 +1,84 @@
+import path from 'node:path';
+
+function decoded(value: string): string {
+	return value.replace(
+		/\\([0-9a-f]{1,6})(?:\r\n|[\t\n\r\f ])?|\\([^\n\r\f])|\\(?:\r\n|[\n\r\f])/gi,
+		(_, hex: string | undefined, char: string | undefined) =>
+			hex
+				? ((point) =>
+						point === 0 || point > 0x10ffff || (point >= 0xd800 && point <= 0xdfff)
+							? '\ufffd'
+							: String.fromCodePoint(point))(parseInt(hex, 16))
+				: (char ?? '')
+	);
+}
+
+export function styleExpression(
+	css: string,
+	stylesheet: string,
+	files: Set<string>,
+	staticFiles: Set<string>
+): string {
+	const parts: string[] = [];
+	let index = 0,
+		offset = 0;
+	while (index < css.length) {
+		if (css.startsWith('/*', index)) {
+			const end = css.indexOf('*/', index + 2);
+			index = end === -1 ? css.length : end + 2;
+			continue;
+		}
+		if (css[index] === '"' || css[index] === "'") {
+			const quote = css[index++]!;
+			while (index < css.length) {
+				if (css[index] === '\\') index += 2;
+				else if (css[index++] === quote) break;
+			}
+			continue;
+		}
+		const open = /^url\(\s*/i.exec(css.slice(index));
+		if (!open || (index && /[\w-]/.test(css[index - 1]!))) {
+			index++;
+			continue;
+		}
+		index += open[0].length;
+		const quote = css[index] === '"' || css[index] === "'" ? css[index++] : undefined;
+		const start = index;
+		while (index < css.length) {
+			if (css[index] === '\\') {
+				index += 2;
+				continue;
+			}
+			if (quote ? css[index] === quote : css[index] === ')') break;
+			index++;
+		}
+		const end = quote ? index : start + css.slice(start, index).trimEnd().length;
+		const value = decoded(css.slice(start, end));
+		if (!/^(?:[a-z][\w+.-]*:|\/\/|#)/i.test(value)) {
+			const suffixAt = value.search(/[?#]/);
+			const rawPath = suffixAt === -1 ? value : value.slice(0, suffixAt);
+			const suffix = suffixAt === -1 ? '' : value.slice(suffixAt);
+			let pathname = rawPath;
+			try {
+				pathname = decodeURIComponent(rawPath);
+			} catch {}
+			const target = path.posix.normalize(
+				pathname.startsWith('/')
+					? pathname.slice(1)
+					: path.posix.join(path.posix.dirname(stylesheet), pathname)
+			);
+			if (files.has(target) || staticFiles.has(target)) {
+				const url = '/' + target.split('/').map(encodeURIComponent).join('/') + suffix;
+				parts.push(
+					JSON.stringify(css.slice(offset, start)),
+					`(assets.endsWith('/') ? assets.slice(0,-1) : assets) + ${JSON.stringify(url)}`
+				);
+				offset = end;
+			}
+		}
+		if (quote && css[index] === quote) index++;
+		if (css[index] === ')') index++;
+	}
+	parts.push(JSON.stringify(css.slice(offset)));
+	return `(assets) => ${parts.join(' + ')}`;
+}