quicklook-kit 0.5.0 → 0.7.0

package/dist/cli.mjs

@@ -1,29 +1,131 @@
 #!/usr/bin/env node
-import { a as serializeCsp, i as loadConfig, t as addSources } from "./config-BQ-9qYNV.mjs";
+import { a as serializeCsp, i as loadConfig, t as addSources } from "./config-qdxXRvMf.mjs";
 import { spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { existsSync } from "node:fs";
-import { cp, glob, readFile, rm, writeFile } from "node:fs/promises";
+import { cp, glob, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import { basename, delimiter, dirname, join, resolve } from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
-//#region src/cli.ts
+import { parseArgs } from "node:util";
+// src/windows.ts
+const xmlEscapes = {
+	"&": "&",
+	"<": "&lt;",
+	">": "&gt;"
+};
+const xmlSpecial = /[&<>]/g;
+function xml(text) {
+	return text.replace(xmlSpecial, (char) => xmlEscapes[char] ?? char);
+}
+/** The settings schema as a flat list keyed like QL-Win's settings file, `editor.fontSize`. */
+function flatSettings(settings, prefix = "") {
+	return Object.entries(settings).flatMap(([name, setting]) => {
+		const key = prefix + name;
+		if (setting.type === "object") return flatSettings(setting.properties, `${key}.`);
+		const { type, default: fallback } = setting;
+		const { enum: options, minimum, maximum } = setting;
+		return [{
+			key,
+			type,
+			default: fallback,
+			...options && { enum: options.map((option) => typeof option === "object" && option ? option.value : option) },
+			...minimum !== void 0 && { minimum },
+			...maximum !== void 0 && { maximum }
+		}];
+	});
+}
+/** The plugin project's generated files, by name. The CLI adds the host source and `web/`. */
+function windowsProject(config, version) {
+	const { id, extensions } = config.windows;
+	return {
+		[`${id}.csproj`]: `<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net462</TargetFramework>
+    <AssemblyName>${id}</AssemblyName>
+    <RootNamespace>${id}</RootNamespace>
+    <Version>${xml(version)}</Version>
+    <LangVersion>latest</LangVersion>
+    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <!-- Lets a non-Windows SDK compile against .NET Framework, WPF included, without UseWPF -->
+    <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3" PrivateAssets="all" />
+    <!-- QL-Win loads QuickLook.Common itself, so compile against it but don't ship it -->
+    <PackageReference Include="QuickLook.Common" Version="4.5.0" ExcludeAssets="runtime" />
+    <!-- Same version as QL-Win's built-in viewers -->
+    <PackageReference Include="Microsoft.Web.WebView2" Version="1.0.4078.44" />
+    <Reference Include="PresentationCore" />
+    <Reference Include="PresentationFramework" />
+    <Reference Include="WindowsBase" />
+    <Reference Include="System.Xaml" />
+    <Reference Include="System.Web" />
+    <Reference Include="System.Web.Extensions" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Include="QuickLook.Plugin.Metadata.config" CopyToOutputDirectory="PreserveNewest" />
+    <None Include="quicklook.json" CopyToOutputDirectory="PreserveNewest" />
+    <None Include="web/**" CopyToOutputDirectory="PreserveNewest" />
+  </ItemGroup>
+</Project>
+`,
+		"QuickLook.Plugin.Metadata.config": `<?xml version="1.0" encoding="utf-8"?>
+<Metadata>
+  <Namespace>${id}</Namespace>
+  <Version>${xml(version)}</Version>
+  <Description>${xml(config.name)}</Description>
+</Metadata>
+`,
+		"quicklook.json": JSON.stringify({
+			id,
+			extensions: extensions.map((extension) => extension.toLowerCase()),
+			maxFileSize: config.maxFileSize,
+			csp: serializeCsp(config.csp),
+			settings: flatSettings(config.settings)
+		})
+	};
+}
+// src/cli.ts
+const platforms = ["macos", "windows"];
+const { positionals: [subcommand], values: { platform } } = parseArgs({
+	allowPositionals: true,
+	options: { platform: { type: "string" } }
+});
+if (platform !== void 0 && !platforms.includes(platform)) throw new Error(`--platform: expected "macos" or "windows", got "${platform}"`);
 const config = await loadConfig();
-const { root, name, bundleId, macOS, types, framework, icon } = config;
+const { root, name, framework } = config;
 const target = name.replace(/[^A-Za-z0-9]/g, "");
 const work = `${root}/.quicklook`;
 const web = `${work}/web`;
-const built = `${work}/build/${name}.app`;
+const built = `${work}/build/macos/${name}.app`;
 const installed = `/Applications/${name}.app`;
+const version = process.env.VERSION?.replace(/^v/, "") ?? "1.0";
+const onWindows = process.platform === "win32";
 const native = fileURLToPath(new URL("../native", import.meta.url));
 const lsregister = "/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister";
-const leadingV = /^v/;
 const inlineScript = /<script\b(?![^>]*\ssrc=)[^>]*>([\s\S]*?)<\/script>/gi;
+/**
+* The settings schema as nested arrays, each entry with its own `key`: Swift's
+* JSONSerialization decodes objects into unordered dictionaries.
+*/
+function settingsSchema(settings) {
+	return Object.entries(settings).map(([key, setting]) => setting.type === "object" ? {
+		...setting,
+		key,
+		properties: settingsSchema(setting.properties)
+	} : {
+		...setting,
+		key
+	});
+}
 /** Runs a command, exiting with its status if it fails unless `nothrow` is set. */
-function exec([file = "", ...args], { quiet = false, nothrow = false, env = process.env } = {}) {
+function exec([file = "", ...args], { quiet = false, nothrow = false, env = process.env, cwd = root, shell = false } = {}) {
 	const { status, error } = spawnSync(file, args, {
-		cwd: root,
+		cwd,
 		env,
+		shell,
 		stdio: quiet ? "ignore" : "inherit"
 	});
 	if (error) throw error;
@@ -37,12 +139,15 @@ function binPath() {
 		if (dir === dirname(dir)) return [...dirs, process.env.PATH].join(delimiter);
 	}
 }
-/** Runs a framework command with the project's own binaries. */
+/** Runs a framework command with the project's own binaries, which are `.cmd` shims on Windows. */
 function run(command) {
-	exec(command, { env: {
-		...process.env,
-		PATH: binPath()
-	} });
+	exec(onWindows ? [command.join(" ")] : command, {
+		env: {
+			...process.env,
+			PATH: binPath()
+		},
+		shell: onWindows
+	});
 }
 /** Frameworks bootstrap with inline scripts; the CSP allows exactly those, by hash. */
 async function inlineScriptHashes() {
@@ -67,18 +172,35 @@ async function buildWeb() {
 	});
 	await cp(outDir, web, { recursive: true });
 }
+function group(key) {
+	const options = config[key];
+	if (!options) throw new Error(`quicklook.config has no "${key}" group, so there is nothing to build for it.`);
+	return options;
+}
+/** Builds every configured platform, or just `--platform`. */
 async function build() {
+	const targets = platform ? [platform] : platforms.filter((p) => config[p]);
+	targets.forEach(group);
+	if (targets.includes("macos") && process.platform !== "darwin") {
+		if (platform) throw new Error("Building for macOS needs a Mac.");
+		console.log("Skipping macOS, which only builds on a Mac.");
+		targets.splice(targets.indexOf("macos"), 1);
+	}
 	await buildWeb();
 	const csp = addSources(config.csp, "script-src", ...await inlineScriptHashes());
+	if (targets.includes("macos")) await buildMacos(csp);
+	if (targets.includes("windows")) await buildWindows(csp);
+}
+async function buildMacos(csp) {
+	const { bundleId, minimumVersion, types, icon } = group("macos");
+	const hasSettings = Object.keys(config.settings).length > 0;
+	const qlSettings = hasSettings && { QLSettings: JSON.stringify(settingsSchema(config.settings)) };
 	const spec = {
 		name: target,
-		options: {
-			deploymentTarget: { macOS },
-			createIntermediateGroups: true
-		},
+		options: { deploymentTarget: { macOS: minimumVersion } },
 		settings: { base: {
 			SWIFT_VERSION: "6.0",
-			MARKETING_VERSION: process.env.VERSION?.replace(leadingV, "") ?? "1.0",
+			MARKETING_VERSION: version,
 			CURRENT_PROJECT_VERSION: "1",
 			CODE_SIGN_STYLE: "Manual",
 			CODE_SIGN_IDENTITY: "-"
@@ -87,10 +209,14 @@ async function build() {
 			[target]: {
 				type: "application",
 				platform: "macOS",
-				sources: [`${native}/App`, ...icon ? [{
-					path: resolve(root, icon),
-					buildPhase: "resources"
-				}] : []],
+				sources: [
+					`${native}/App`,
+					`${native}/Shared`,
+					...icon ? [{
+						path: resolve(root, icon),
+						buildPhase: "resources"
+					}] : []
+				],
 				settings: {
 					PRODUCT_NAME: name,
 					PRODUCT_BUNDLE_IDENTIFIER: bundleId
@@ -105,7 +231,8 @@ async function build() {
 					properties: {
 						CFBundleName: name,
 						...icon && { CFBundleIconFile: basename(icon, ".icns") },
-						LSMinimumSystemVersion: macOS,
+						LSMinimumSystemVersion: minimumVersion,
+						...qlSettings,
 						UTExportedTypeDeclarations: types.filter((type) => typeof type !== "string").map((type) => ({
 							UTTypeIdentifier: type.id,
 							UTTypeDescription: type.description,
@@ -118,11 +245,15 @@ async function build() {
 			[`${target}Extension`]: {
 				type: "app-extension",
 				platform: "macOS",
-				sources: [`${native}/Extension`, {
-					path: web,
-					type: "folder",
-					buildPhase: "resources"
-				}],
+				sources: [
+					`${native}/Extension`,
+					`${native}/Shared`,
+					{
+						path: web,
+						type: "folder",
+						buildPhase: "resources"
+					}
+				],
 				settings: { PRODUCT_BUNDLE_IDENTIFIER: `${bundleId}.Extension` },
 				dependencies: [{ sdk: "QuickLookUI.framework" }, { sdk: "WebKit.framework" }],
 				entitlements: {
@@ -130,7 +261,8 @@ async function build() {
 					properties: {
 						"com.apple.security.app-sandbox": true,
 						"com.apple.security.files.user-selected.read-only": true,
-						"com.apple.security.network.client": true
+						"com.apple.security.network.client": true,
+						...hasSettings && { "com.apple.security.temporary-exception.shared-preference.read-only": [bundleId] }
 					}
 				},
 				info: {
@@ -139,6 +271,7 @@ async function build() {
 						CFBundleDisplayName: name,
 						QLWebContentSecurityPolicy: serializeCsp(csp),
 						QLMaxFileSize: config.maxFileSize,
+						...qlSettings,
 						NSExtension: {
 							NSExtensionPointIdentifier: "com.apple.quicklook.preview",
 							NSExtensionPrincipalClass: "PreviewViewController",
@@ -174,13 +307,82 @@ async function build() {
 		"Release",
 		"-destination",
 		"generic/platform=macOS",
-		`CONFIGURATION_BUILD_DIR=${work}/build`,
+		`CONFIGURATION_BUILD_DIR=${dirname(built)}`,
 		"build"
 	]);
 	exec(["touch", built]);
 	console.log(`Built ${built}`);
 }
-switch (process.argv[2]) {
+/** The plugin folder `register` copies, and the `.qlplugin` users install. */
+function windowsBuild() {
+	const { id } = group("windows");
+	return {
+		plugin: `${work}/build/windows/${id}`,
+		archive: `${work}/build/windows/${name}.qlplugin`
+	};
+}
+async function buildWindows(csp) {
+	const windows = group("windows");
+	const { plugin, archive } = windowsBuild();
+	const project = `${work}/windows`;
+	await rm(`${project}/web`, {
+		recursive: true,
+		force: true
+	});
+	await cp(web, `${project}/web`, { recursive: true });
+	await cp(`${native}/Windows/Plugin.cs`, `${project}/Plugin.cs`);
+	for (const [file, content] of Object.entries(windowsProject({
+		...config,
+		csp,
+		windows
+	}, version))) await writeFile(`${project}/${file}`, content);
+	await rm(plugin, {
+		recursive: true,
+		force: true
+	});
+	exec([
+		"dotnet",
+		"build",
+		`${project}/${windows.id}.csproj`,
+		"--configuration",
+		"Release",
+		"--output",
+		plugin,
+		"--nologo",
+		"--verbosity",
+		"quiet"
+	]);
+	const tar = onWindows ? join(process.env.SystemRoot ?? "C:\\Windows", "System32\\tar.exe") : "tar";
+	await rm(archive, { force: true });
+	exec([
+		tar,
+		"--create",
+		"--format",
+		"zip",
+		"--file",
+		archive,
+		"--exclude",
+		"*.pdb",
+		...await readdir(plugin)
+	], { cwd: plugin });
+	console.log(`Built ${archive}`);
+}
+/** QL-Win's folder for plugins installed by the user. */
+const qlWinPlugins = join(process.env.APPDATA ?? "", "pooi.moe/QuickLook/QuickLook.Plugin");
+/** Removes an installed plugin, whose DLL is locked while QuickLook runs. */
+async function removePlugin(folder) {
+	try {
+		await rm(folder, {
+			recursive: true,
+			force: true
+		});
+	} catch (error) {
+		const { code } = error;
+		if (code === "EBUSY" || code === "EPERM") throw new Error(`Quit QuickLook first, it has ${folder} in use.`, { cause: error });
+		throw error;
+	}
+}
+switch (subcommand) {
 	case "dev":
 		run(framework.build.dev);
 		break;
@@ -191,6 +393,15 @@ switch (process.argv[2]) {
 		await build();
 		break;
 	case "register":
+		if (onWindows) {
+			const { plugin } = windowsBuild();
+			if (!existsSync(plugin)) throw new Error(`No build at ${plugin}, run 'quicklook build' first.`);
+			const folder = join(qlWinPlugins, group("windows").id);
+			await removePlugin(folder);
+			await cp(plugin, folder, { recursive: true });
+			console.log(`Installed ${folder}\nQuit and restart QuickLook to load it.`);
+			break;
+		}
 		if (!existsSync(built)) throw new Error(`No build at ${built}, run 'quicklook build' first.`);
 		await rm(installed, {
 			recursive: true,
@@ -225,9 +436,15 @@ switch (process.argv[2]) {
 			"-g",
 			installed
 		]);
-		console.log(`Installed ${installed}\nVerify with: pluginkit -mAv | grep ${bundleId}`);
+		console.log(`Installed ${installed}\nVerify with: pluginkit -mAv | grep ${group("macos").bundleId}`);
 		break;
 	case "unregister":
+		if (onWindows) {
+			const folder = join(qlWinPlugins, group("windows").id);
+			await removePlugin(folder);
+			console.log(`Removed ${folder}\nQuit and restart QuickLook to unload it.`);
+			break;
+		}
 		exec([
 			lsregister,
 			"-u",
@@ -246,7 +463,6 @@ switch (process.argv[2]) {
 		});
 		console.log(`Removed ${installed}`);
 		break;
-	default: throw new Error("Usage: quicklook dev|build:web|build|register|unregister");
+	default: throw new Error("Usage: quicklook dev|build:web|build|register|unregister [--platform macos|windows]");
 }
-//#endregion
 export {};

package/dist/config-qdxXRvMf.mjs

@@ -0,0 +1,271 @@
+import { join } from "node:path";
+import process from "node:process";
+import { loadConfig } from "c12";
+import { createJiti } from "jiti";
+// src/settings.ts
+/** The fields each setting type allows, besides `type`, `title`, `description` and `order`. */
+const settingFields = {
+	boolean: ["default"],
+	string: [
+		"default",
+		"enum",
+		"radio"
+	],
+	integer: [
+		"default",
+		"enum",
+		"radio",
+		"minimum",
+		"maximum"
+	],
+	number: [
+		"default",
+		"enum",
+		"radio",
+		"minimum",
+		"maximum"
+	],
+	object: ["properties"]
+};
+const commonFields = [
+	"type",
+	"title",
+	"description",
+	"order"
+];
+const knownFields = /* @__PURE__ */ new Set([...commonFields, ...Object.values(settingFields).flat()]);
+function isString(value) {
+	return typeof value === "string";
+}
+/** Whether `value` is a valid value of setting type `type`. */
+const valueChecks = {
+	boolean: (value) => typeof value === "boolean",
+	string: isString,
+	integer: Number.isInteger,
+	number: Number.isFinite
+};
+/** Optional fields with a fixed type, and the problem when it's wrong. */
+const fieldChecks = [
+	[
+		"title",
+		isString,
+		"title must be a string"
+	],
+	[
+		"description",
+		isString,
+		"description must be a string"
+	],
+	[
+		"order",
+		Number.isFinite,
+		"order must be a number"
+	],
+	[
+		"minimum",
+		Number.isFinite,
+		"minimum must be a number"
+	],
+	[
+		"maximum",
+		Number.isFinite,
+		"maximum must be a number"
+	],
+	[
+		"radio",
+		(value) => typeof value === "boolean",
+		"radio must be true or false"
+	]
+];
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+const settingKey = /^[A-Za-z_][\w-]*$/;
+/**
+* Throws on anything in a `settings` schema the app can't show, naming the key
+* path, e.g. `settings.editor.tabSize: default 0 is below minimum 1`.
+*/
+function validateSettings(settings, path = "settings") {
+	if (!isRecord(settings)) throw new Error(`${path}: expected an object of settings`);
+	for (const [key, entry] of Object.entries(settings)) {
+		const at = `${path}.${key}`;
+		if (!settingKey.test(key)) throw new Error(`${at}: keys need a letter or _ first, then letters, digits, _ or -`);
+		if (!isRecord(entry)) throw new Error(`${at}: expected an object with a type`);
+		const problem = settingProblem(entry);
+		if (problem) throw new Error(`${at}: ${problem}`);
+		if (entry.type === "object") validateSettings(entry.properties, at);
+	}
+}
+/** What's wrong with one entry, without looking into `properties`. */
+function settingProblem(entry) {
+	const type = String(entry.type);
+	if (!(typeof entry.type === "string" && Object.hasOwn(settingFields, type))) return `unknown type ${JSON.stringify(entry.type)}`;
+	for (const field of Object.keys(entry)) {
+		if (!knownFields.has(field)) return `unknown field "${field}"`;
+		if (!(commonFields.includes(field) || settingFields[type]?.includes(field))) return `"${field}" isn't allowed on type "${type}"`;
+	}
+	const wrong = fieldChecks.find(([field, check]) => !(entry[field] === void 0 || check(entry[field])));
+	if (wrong) return wrong[2];
+	if (type === "object") return isRecord(entry.properties) && Object.keys(entry.properties).length > 0 ? void 0 : "an object needs non-empty properties";
+	return valueProblem(entry, type);
+}
+/** What's wrong with the default, the range and the enum of a non-object entry. */
+function valueProblem(entry, type) {
+	if (!("default" in entry)) return "default is required";
+	const { default: value, minimum, maximum, radio, enum: options } = entry;
+	const shown = JSON.stringify(value);
+	if (!valueChecks[type]?.(value)) return `default ${shown} isn't of type "${type}"`;
+	if (typeof minimum === "number" && typeof maximum === "number" && minimum > maximum) return `minimum ${minimum} is above maximum ${maximum}`;
+	if (typeof minimum === "number" && value < minimum) return `default ${shown} is below minimum ${minimum}`;
+	if (typeof maximum === "number" && value > maximum) return `default ${shown} is above maximum ${maximum}`;
+	if (radio && options === void 0) return "radio needs an enum";
+	return options === void 0 ? void 0 : enumProblem(options, value, type);
+}
+/** An object entry other than `{ value, description? }`. */
+function malformedOption(option) {
+	return !("value" in option && Object.keys(option).every((field) => field === "value" || field === "description") && (option.description === void 0 || isString(option.description)));
+}
+function enumProblem(options, value, type) {
+	if (!Array.isArray(options) || options.length === 0) return "enum must be a non-empty array";
+	const values = [];
+	for (const [index, option] of options.entries()) {
+		if (isRecord(option) && malformedOption(option)) return `enum[${index}] must be a value or { value, description }`;
+		const optionValue = isRecord(option) ? option.value : option;
+		if (!valueChecks[type]?.(optionValue)) return `enum[${index}] ${JSON.stringify(optionValue)} isn't of type "${type}"`;
+		values.push(optionValue);
+	}
+	return values.includes(value) ? void 0 : `default ${JSON.stringify(value)} isn't in the enum`;
+}
+// src/config.ts
+/** The previewed file is untrusted input; nothing on the page needs the network. */
+const defaultCsp = {
+	"default-src": ["'none'"],
+	"script-src": ["'self'"],
+	"style-src": ["'self'", "'unsafe-inline'"],
+	"img-src": [
+		"'self'",
+		"data:",
+		"blob:"
+	],
+	"font-src": ["'self'", "data:"],
+	"media-src": [
+		"'self'",
+		"data:",
+		"blob:"
+	]
+};
+const defineConfig = (config) => config;
+const serializeCsp = (csp) => Object.entries(csp).map(([directive, sources = []]) => [directive, ...sources].join(" ")).join("; ");
+/** `csp` with `sources` appended to `directive`. */
+const addSources = (csp, directive, ...sources) => ({
+	...csp,
+	[directive]: [...csp[directive] ?? [], ...sources]
+});
+/**
+* Built-in frameworks: their dev and build commands, and the default `outDir`
+* of a static, client-side build. Each takes `{ outDir }` to override it.
+*/
+const frameworkBuilds = {
+	analog: [
+		["vite", "dev"],
+		["vite", "build"],
+		"dist"
+	],
+	astro: [
+		["astro", "dev"],
+		["astro", "build"],
+		"dist"
+	],
+	nuxt: [
+		["nuxt", "dev"],
+		["nuxt", "generate"],
+		".output/public"
+	],
+	"solid-start": [
+		["vite", "dev"],
+		["vite", "build"],
+		".output/public"
+	],
+	sveltekit: [
+		["vite", "dev"],
+		["vite", "build"],
+		"build"
+	]
+};
+function builtinFramework(name, options) {
+	const builtin = frameworkBuilds[name];
+	if (!builtin) return;
+	const [dev, command, outDir] = builtin;
+	return {
+		name,
+		build: {
+			dev,
+			command,
+			outDir: options?.outDir ?? outDir
+		}
+	};
+}
+async function resolveIntegration(ref, root) {
+	if (typeof ref === "object" && !Array.isArray(ref)) return ref;
+	const [name, options] = typeof ref === "string" ? [ref] : ref;
+	const builtin = builtinFramework(name, options);
+	if (builtin) return builtin;
+	const exported = await createJiti(join(root, "quicklook.config")).import(name, { default: true });
+	return typeof exported === "function" ? exported(options) : exported;
+}
+/** Top-level fields from before the platform groups, and where they went. */
+const movedFields = {
+	bundleId: "macos.bundleId",
+	icon: "macos.icon",
+	macOS: "macos.minimumVersion",
+	types: "macos.types, Windows uses windows.extensions"
+};
+const windowsId = /^QuickLook\.Plugin\.[A-Za-z0-9_.]+$/;
+function validatePlatforms(config) {
+	const moved = Object.keys(movedFields).filter((field) => field in config).map((field) => `${field}: moved to ${movedFields[field]}`);
+	if (moved.length > 0) throw new Error(moved.join("\n"));
+	if (!(config.macos || config.windows)) throw new Error("quicklook.config: add a \"macos\" or \"windows\" group for each platform to build for");
+	if (!config.windows) return;
+	const { id, extensions } = config.windows;
+	if (typeof id !== "string" || !windowsId.test(id)) throw new Error(`windows.id: expected "QuickLook.Plugin." followed by a name, got ${JSON.stringify(id)}`);
+	if (!Array.isArray(extensions) || extensions.length === 0) throw new Error("windows.extensions: expected at least one extension");
+	const dotted = extensions.find((extension) => extension.startsWith("."));
+	if (dotted) throw new Error(`windows.extensions: write "${dotted.slice(1)}" without the dot`);
+}
+async function loadConfig$1(root = process.cwd()) {
+	const { config } = await loadConfig({
+		name: "quicklook",
+		cwd: root
+	});
+	if (!config?.name) throw new Error(`No quicklook.config.* with a name found in ${root}`);
+	validatePlatforms(config);
+	validateSettings(config.settings ?? {});
+	const { framework: frameworkRef, integrations: refs = [], macos, ...rest } = config;
+	const framework = await resolveIntegration(frameworkRef, root);
+	if (!framework.build) throw new Error(`Framework "${framework.name}" doesn't say how to build the page`);
+	const integrations = [framework];
+	for (const ref of refs) integrations.push(await resolveIntegration(ref, root));
+	const resolved = {
+		maxFileSize: 1e7,
+		public: {},
+		settings: {},
+		...rest,
+		...macos && { macos: {
+			minimumVersion: "14.0",
+			...macos
+		} },
+		csp: {
+			...defaultCsp,
+			...config.csp
+		},
+		root,
+		framework: {
+			...framework,
+			build: framework.build
+		},
+		integrations
+	};
+	for (const integration of integrations) await integration.hooks?.["config:resolved"]?.(resolved);
+	return resolved;
+}
+export { serializeCsp as a, loadConfig$1 as i, defaultCsp as n, defineConfig as r, addSources as t };