@gjsify/rolldown-plugin-gjsify 0.4.0 → 0.4.3

package/src/app/node.ts

@@ -1,127 +0,0 @@
-// `--app node` Rolldown configuration factory.
-//
-// Same external set + alias map as the esbuild predecessor. The
-// `createRequire` banner that esbuild needed for ESM-output CJS interop
-// translates to Rolldown's `output.banner` directly — Rolldown itself does
-// not synthesise a `require()` shim for ESM consumers of bundled CJS code.
-
-import { aliasPlugin } from '../plugins/alias.js';
-import type { RolldownOptions, RolldownPluginOption } from 'rolldown';
-
-import { deepkitPlugin } from '@gjsify/rolldown-plugin-deepkit';
-import { EXTERNALS_NODE } from '@gjsify/resolve-npm';
-
-import type { PluginOptions } from '../types/plugin-options.js';
-import { getAliasesForNode } from '../utils/alias.js';
-import { globToEntryPoints } from '../utils/entry-points.js';
-import {
-    nodeModulesPathRewritePlugin,
-    getBundleDirFromOutput,
-} from '../plugins/rewrite-node-modules-paths.js';
-import { cssAsStringPlugin } from '../plugins/css-as-string.js';
-
-export interface NodeBuildConfig {
-    options: RolldownOptions;
-    plugins: RolldownPluginOption[];
-}
-
-export interface NodeFactoryInput {
-    input?: RolldownOptions['input'];
-    output: { file?: string; dir?: string };
-    userExternal?: string[];
-    userAliases?: Record<string, string>;
-    pluginOptions: PluginOptions;
-}
-
-export const setupForNode = async (input: NodeFactoryInput): Promise<NodeBuildConfig> => {
-    const userExternal = input.userExternal ?? [];
-    // node-datachannel is a native C++ addon that cannot be bundled — its
-    // `require('../build/Release/node_datachannel.node')` must resolve at
-    // runtime against the real node_modules tree.
-    //
-    // Note: Rolldown's `external` array does NOT support glob patterns the
-    // way esbuild's did (`gi://*`, `@girs/*`). We use a function predicate
-    // instead so the gi:// URI scheme and the @girs/ namespace are matched
-    // by prefix.
-    const exactExternal = [
-        ...EXTERNALS_NODE as string[],
-        'node-datachannel',
-        ...userExternal,
-    ];
-    const external = (id: string): boolean => {
-        if (id.startsWith('gi://')) return true;
-        if (id.startsWith('@girs/')) return true;
-        if (exactExternal.includes(id)) return true;
-        return false;
-    };
-    const format = input.pluginOptions.format ?? 'esm';
-
-    const exclude = input.pluginOptions.exclude ?? [];
-    const entryPoints = await globToEntryPoints(input.input, exclude);
-
-    const aliasMap = {
-        ...getAliasesForNode({ external }),
-        ...(input.pluginOptions.aliases ?? {}),
-        ...(input.userAliases ?? {}),
-    };
-
-    const bundleDir = getBundleDirFromOutput(input.output);
-
-    // Rolldown's CJS interop wraps bundled CJS via `__commonJSMin` and
-    // routes external Node-builtin `require()` through `__require` —
-    // both injected internally. Unlike esbuild we therefore don't need a
-    // top-of-bundle `const require = createRequire(...)` shim. Keeping
-    // one collides with bundled CJS sources that declare their own
-    // `const require = createRequire(...)` (e.g. yargs's ESM platform
-    // shim) — `SyntaxError: Identifier 'require' has already been
-    // declared`.
-    const banner: string | undefined = undefined;
-
-    const options: RolldownOptions = {
-        input: entryPoints,
-        platform: 'node',
-        external,
-        resolve: {
-            mainFields: format === 'esm' ? ['module', 'main', 'browser'] : ['main', 'module', 'browser'],
-            // CJS-priority conditions for Node bundles. Rolldown uses the first
-            // matching key, so including 'import' would route packages like ws
-            // v8 (whose exports map lists 'import' before 'require') through
-            // their incomplete ESM wrapper.
-            conditionNames: format === 'esm' ? ['require', 'node', 'module'] : ['require'],
-        },
-        transform: {
-            target: 'node24',
-            define: {
-                global: 'globalThis',
-                window: 'globalThis',
-            },
-        },
-        output: {
-            ...input.output,
-            format,
-            sourcemap: false,
-            banner,
-            // Single-bundle output. `codeSplitting: false` replaces the
-            // deprecated `inlineDynamicImports: true`.
-            codeSplitting: false,
-        },
-        treeshake: true,
-    };
-
-    const plugins: RolldownPluginOption[] = [
-        aliasPlugin({ entries: flattenAliases(aliasMap) }),
-        deepkitPlugin({ reflection: input.pluginOptions.reflection }),
-        cssAsStringPlugin(),
-        nodeModulesPathRewritePlugin({ bundleDir }),
-    ];
-
-    return { options, plugins };
-};
-
-function flattenAliases(map: Record<string, string>): Record<string, string> {
-    const out: Record<string, string> = {};
-    for (const [from, to] of Object.entries(map)) {
-        if (to) out[from] = to;
-    }
-    return out;
-}

package/src/globals.ts

@@ -1,11 +0,0 @@
-// Public subpath export for the `--globals` CLI support.
-//
-// Consumed by `@gjsify/cli` to resolve the user's explicit `--globals` list
-// (or auto-detect via the iterative multi-pass build) and write the inject
-// stub that the plugin picks up via its `autoGlobalsInject` option. See the
-// "Tree-shakeable Globals" section in AGENTS.md for the architecture.
-
-export { resolveGlobalsList, writeRegisterInjectFile } from './utils/scan-globals.js';
-export { detectFreeGlobals } from './utils/detect-free-globals.js';
-export { detectAutoGlobals } from './utils/auto-globals.js';
-export type { AutoGlobalsResult, DetectAutoGlobalsOptions, AnalysisOptions } from './utils/auto-globals.js';

package/src/index.ts

@@ -1,34 +0,0 @@
-// Public re-exports for `@gjsify/rolldown-plugin-gjsify`.
-
-export * from './types/index.js';
-export * from './utils/index.js';
-export * from './app/index.js';
-export * from './library/index.js';
-
-export {
-    REWRITE_FILTER,
-    getBundleDirFromOutput,
-    rewriteContents,
-    shouldRewrite,
-    nodeModulesPathRewritePlugin,
-} from './plugins/rewrite-node-modules-paths.js';
-export type {
-    NodeModulesPathRewriteOptions,
-    RewriteResult,
-} from './plugins/rewrite-node-modules-paths.js';
-
-export { processStubPlugin, GJS_PROCESS_STUB, composeBanner } from './plugins/process-stub.js';
-export type { ProcessStubPluginOptions } from './plugins/process-stub.js';
-export { cssAsStringPlugin } from './plugins/css-as-string.js';
-export { textLoaderPlugin } from './plugins/text-loader.js';
-export type { TextLoaderPluginOptions } from './plugins/text-loader.js';
-export { shebangPlugin, GJS_SHEBANG, expandEnvTemplate, resolveShebangLine } from './plugins/shebang.js';
-export type { ShebangPluginOptions } from './plugins/shebang.js';
-export { gjsImportsEmptyPlugin } from './plugins/gjs-imports-empty.js';
-
-export * from './plugin.js';
-import { gjsifyPlugin } from './plugin.js';
-export { gjsifyPlugin };
-export default gjsifyPlugin;
-
-export * from '@gjsify/resolve-npm';

package/src/library/index.ts

@@ -1,2 +0,0 @@
-export { setupLib } from './lib.js';
-export type { LibBuildConfig, LibFactoryInput } from './lib.js';

package/src/library/lib.ts

@@ -1,141 +0,0 @@
-// Library mode — multi-entry, unbundled output for republication on npm.
-//
-// Equivalent to esbuild's `bundle: false`: every input file is emitted
-// 1:1 with its imports preserved as-is (resolved by Rolldown). The user
-// alias map is applied so `node:fs` → `fs/promises` style remappings still
-// work, and the JS extension table mirrors the esbuild predecessor.
-//
-// Targeting `esnext` and `platform: 'neutral'` matches the original
-// library config: consumers downstream (downstream apps using `gjsify
-// build --app gjs|node|browser`) re-bundle and apply their own target
-// lowering. Library output stays maximally portable.
-
-import { aliasPlugin } from '../plugins/alias.js';
-import { cssAsStringPlugin } from '../plugins/css-as-string.js';
-import type { RolldownOptions, RolldownPluginOption } from 'rolldown';
-
-import type { PluginOptions } from '../types/plugin-options.js';
-import { globToEntryPoints } from '../utils/entry-points.js';
-
-export interface LibBuildConfig {
-    options: RolldownOptions;
-    plugins: RolldownPluginOption[];
-}
-
-export interface LibFactoryInput {
-    input?: RolldownOptions['input'];
-    output: { file?: string; dir?: string };
-    userAliases?: Record<string, string>;
-    pluginOptions: PluginOptions;
-}
-
-export const setupLib = async (input: LibFactoryInput): Promise<LibBuildConfig> => {
-    // Derive output format from `library: 'esm' | 'cjs'` when the caller
-    // didn't pass `format` explicitly. The library type and the emitted
-    // module format are inseparable: a CJS-library build that emits ESM
-    // (or vice versa) is broken by definition.
-    const format = input.pluginOptions.format ?? input.pluginOptions.library ?? 'esm';
-
-    const exclude = input.pluginOptions.exclude ?? [];
-    const entryPoints = await globToEntryPoints(input.input, exclude);
-
-    // Derive `preserveModulesRoot` from the common ancestor of every
-    // resolved entry. Workspaces use various roots (`src/`, `src/ts/`,
-    // `lib/`); without stripping the right one, Rolldown emits paths
-    // like `lib/esm/<root>/<file>.js` instead of `lib/esm/<file>.js`,
-    // which doesn't match the package.json `exports` map.
-    const preserveModulesRoot = computeCommonRoot(entryPoints);
-
-    const aliasMap = {
-        ...(input.pluginOptions.aliases ?? {}),
-        ...(input.userAliases ?? {}),
-    };
-
-    // Library mode keeps all third-party / workspace imports as-is so the
-    // emitted package re-exports its dep tree by reference. Rolldown's
-    // default behaviour would inline workspace packages into the output
-    // directory; we mark anything not starting with `./` or `/` as external.
-    const external = (id: string): boolean => {
-        if (id.startsWith('./') || id.startsWith('../') || id.startsWith('/')) return false;
-        return true;
-    };
-
-    const options: RolldownOptions = {
-        input: entryPoints,
-        platform: 'neutral',
-        external,
-        resolve: {
-            mainFields: format === 'esm' ? ['module', 'main'] : ['main'],
-            conditionNames: format === 'esm' ? ['module', 'import'] : ['require'],
-        },
-        transform: { target: 'esnext' },
-        output: {
-            ...input.output,
-            format,
-            // Library mode = preserve module structure (multi-file output,
-            // imports resolved but not bundled).
-            preserveModules: true,
-            // Strip the source root from the emitted paths. Without this,
-            // Rolldown keeps the full project-relative path. The root is
-            // computed from the common ancestor of resolved entries.
-            preserveModulesRoot,
-            sourcemap: false,
-        },
-        treeshake: false,
-    };
-
-    const plugins: RolldownPluginOption[] = [
-        aliasPlugin({ entries: flattenAliases(aliasMap) }),
-        // Rolldown removed experimental CSS bundling — `.css` files would
-        // error at the bundler level. Library-mode packages that bundle
-        // CSS as a string (e.g. `@gjsify/adwaita-fonts/index.css`) need
-        // the same `load` hook the app factories install. The result is a
-        // tiny JS module re-exporting the CSS source, which preserveModules
-        // emits 1:1.
-        cssAsStringPlugin(),
-    ];
-
-    return { options, plugins };
-};
-
-/**
- * Compute the common-ancestor directory of a set of entry paths so
- * Rolldown's `preserveModulesRoot` strips the right prefix from emitted
- * file paths. Falls back to `'src'` when there are no entries or the
- * entries don't share a meaningful prefix.
- */
-function computeCommonRoot(
-    entries: ReturnType<typeof globToEntryPoints> extends Promise<infer T> ? T : never,
-): string {
-    const paths: string[] = entries === undefined
-        ? []
-        : typeof entries === 'string'
-            ? [entries]
-            : Array.isArray(entries)
-                ? entries
-                : Object.values(entries);
-    if (paths.length === 0) return 'src';
-
-    const split = paths.map((p) => p.split('/').filter(Boolean));
-    const head = split[0];
-    let i = 0;
-    for (; i < head.length; i++) {
-        const seg = head[i];
-        if (!split.every((parts) => parts[i] === seg)) break;
-    }
-    if (i === 0) return 'src';
-    // Drop the basename if the common prefix points at a single file.
-    const commonParts = head.slice(0, i);
-    // Heuristic: treat the prefix as a directory when at least one path
-    // has more segments after it.
-    const hasMoreAfter = split.some((parts) => parts.length > i);
-    return hasMoreAfter ? commonParts.join('/') : commonParts.slice(0, -1).join('/') || 'src';
-}
-
-function flattenAliases(map: Record<string, string>): Record<string, string> {
-    const out: Record<string, string> = {};
-    for (const [from, to] of Object.entries(map)) {
-        if (to) out[from] = to;
-    }
-    return out;
-}

package/src/plugin.ts

@@ -1,96 +0,0 @@
-// `gjsifyPlugin` — orchestrator entry point.
-//
-// Picks the platform-specific factory based on `pluginOptions.app`
-// (or `library` for library mode) and returns the resolved Rolldown
-// configuration. Unlike the esbuild predecessor, this is NOT a single
-// `Plugin` object — it returns a *config bundle* the caller composes into
-// `rolldown(opts)`, because Rolldown does not have esbuild's `setup(build)`
-// hook through which a single plugin can mutate `build.initialOptions`.
-//
-// The CLI consumer (`@gjsify/cli`) calls `gjsifyPlugin(...)` to get back
-// `{ options, plugins }`, then calls `rolldown({ ...options, plugins:
-// [...userPlugins, ...plugins] })`.
-
-import type { RolldownOptions, RolldownPluginOption } from 'rolldown';
-import type { PluginOptions } from './types/plugin-options.js';
-import { setupForGjs, setupForNode, setupForBrowser } from './app/index.js';
-import { setupLib } from './library/index.js';
-
-export interface GjsifyConfig {
-    options: RolldownOptions;
-    plugins: RolldownPluginOption[];
-}
-
-export interface GjsifyPluginInput {
-    input?: RolldownOptions['input'];
-    output: { file?: string; dir?: string };
-    userExternal?: string[];
-    userBanner?: string;
-    userAliases?: Record<string, string>;
-    /**
-     * Shebang to prepend to the GJS bundle.
-     *   `true`  → default `#!/usr/bin/env -S gjs -m`
-     *   `false` → no shebang
-     *   `"…"`   → custom line, supports `${env:NAME[:-default]}` placeholders
-     */
-    shebang?: boolean | string;
-}
-
-/**
- * Build the Rolldown configuration template + plugin array for the given
- * pluginOptions. The caller composes the returned `options.plugins` with
- * its own user plugins and passes the merged options to `rolldown(...)`.
- */
-export const gjsifyPlugin = async (
-    input: GjsifyPluginInput,
-    pluginOptions: PluginOptions = {},
-): Promise<GjsifyConfig> => {
-    if (pluginOptions.library) {
-        switch (pluginOptions.library) {
-            case 'esm':
-            case 'cjs':
-                return await setupLib({
-                    input: input.input,
-                    output: input.output,
-                    userAliases: input.userAliases,
-                    pluginOptions,
-                });
-            default:
-                throw new TypeError('Unknown library type: ' + pluginOptions.library);
-        }
-    }
-
-    const app = pluginOptions.app ?? 'gjs';
-    switch (app) {
-        case 'gjs':
-            return await setupForGjs({
-                input: input.input,
-                output: input.output,
-                userExternal: input.userExternal,
-                userBanner: input.userBanner,
-                userAliases: input.userAliases,
-                shebang: input.shebang,
-                pluginOptions,
-            });
-        case 'node':
-            return await setupForNode({
-                input: input.input,
-                output: input.output,
-                userExternal: input.userExternal,
-                userAliases: input.userAliases,
-                pluginOptions,
-            });
-        case 'browser':
-            return await setupForBrowser({
-                input: input.input,
-                output: input.output,
-                userExternal: input.userExternal,
-                userAliases: input.userAliases,
-                pluginOptions,
-            });
-        default:
-            throw new TypeError('Unknown app platform: ' + app);
-    }
-};
-
-export default gjsifyPlugin;

package/src/plugins/alias.ts

@@ -1,61 +0,0 @@
-// Custom alias plugin — `@rollup/plugin-alias` returns the rewritten
-// specifier as the resolved id, then leaves Rolldown's default resolver to
-// load it. That fails for workspace package targets (`@gjsify/crypto` etc.)
-// when the importer's package.json doesn't list them as direct deps —
-// Rolldown rejects packages that aren't declared in the importer's manifest
-// even when they exist in a hoisted workspace `node_modules`.
-//
-// This plugin instead calls `this.resolve(target, importer, { skipSelf: true })`
-// which goes through the full plugin chain (including any subsequent resolvers)
-// and resolves to a real file path the default loader can read.
-//
-// Behaviour preserved from the esbuild predecessor's `aliasPlugin`:
-//   - exact string match (no prefix-aware semantics needed at this layer)
-//   - `node:<name>` specifiers map to the same target as `<name>`
-//     (handled in the alias-builder helpers, not here).
-//
-// `extraOptions.kind` is forwarded to `this.resolve()` so package.json
-// `exports` conditions ("import" / "require") match the original call site.
-// Without this, a CJS `require('stream')` in a bundled npm package would
-// resolve through the "import" condition (Rolldown's default), bypassing the
-// `cjs-compat.cjs` shim that unwraps named-export ESM modules to their
-// constructor — breaking `util.inherits(Child, Stream)` patterns.
-
-import type { Plugin } from 'rolldown';
-
-export interface AliasPluginOptions {
-    entries: Record<string, string>;
-}
-
-export function aliasPlugin(options: AliasPluginOptions): Plugin {
-    const entries = options.entries;
-    const keys = Object.keys(entries);
-
-    return {
-        name: 'gjsify-alias',
-        resolveId: {
-            order: 'pre' as const,
-            async handler(source, importer, extraOptions) {
-                if (!Object.prototype.hasOwnProperty.call(entries, source)) {
-                    return null;
-                }
-                const target = entries[source];
-                // Self-reference guard: if a user maps a specifier to itself
-                // (rare but legal), skip to avoid infinite loops.
-                if (target === source) return null;
-
-                const resolved = await this.resolve(target, importer, {
-                    skipSelf: true,
-                    kind: extraOptions?.kind,
-                });
-                if (resolved !== null) {
-                    return resolved;
-                }
-                // Fall through to other resolvers if we couldn't load it
-                // ourselves. `null` from a `pre`-order resolveId lets the
-                // default chain continue.
-                return null;
-            },
-        },
-    };
-}

package/src/plugins/css-as-string.ts

@@ -1,189 +0,0 @@
-// Wrap `.css` imports as JS string default exports.
-//
-// Rolldown's experimental CSS bundling was removed (see
-// https://github.com/rolldown/rolldown/issues/4271) — when the bundler
-// sees a `.css` extension it errors out unless something else loads the
-// file first. We hook into `load` (with a path filter) BEFORE Rolldown's
-// CSS classification fires and emit a JS module whose default export is
-// the CSS source as a string. Consumers can then do:
-//
-//   import css from './app.css';
-//   provider.load_from_string(css);
-//
-// — the canonical pattern for `Gtk.CssProvider` under GJS.
-//
-// `@import` resolution + nesting/modern-syntax lowering are handled via
-// lightningcss `bundleAsync`. The defaults work for the common case
-// (resolve `@import`s, no targeting); the `--app gjs` orchestrator passes
-// `targets: { firefox: 60 << 16 }` so nesting + modern selectors get
-// flattened to GTK4-CSS-engine-compatible output. Targeting is opt-in —
-// a missing `targets` keeps the source pristine.
-//
-// Backend selection (Phase D-2 decision matrix in
-// `docs/poc/lightningcss-decision.md`):
-//
-//   1. `@gjsify/lightningcss-native` when its prebuild is loadable on
-//      the running architecture (3-5× faster than the WASM track,
-//      ~960× faster cold init). Only relevant when `gjsify build`
-//      itself runs under GJS (Phase D-3).
-//   2. npm `lightningcss` for everything else (Node, unsupported
-//      arches, dev machines without the prebuild). Existing behavior;
-//      keeps the regular dependency on this package.
-//
-// Selection is lazy and silent — the first `.css` load probes for
-// the native bridge once, caches the answer, and routes the rest of
-// the build through the chosen backend. Set the env var
-// `GJSIFY_CSS_BACKEND={native|npm}` to force a specific backend
-// (mainly useful for benchmarking + the integration suite).
-
-import { readFile } from 'node:fs/promises';
-import type { Plugin } from 'rolldown';
-
-export interface CssAsStringOptions {
-    /**
-     * lightningcss browser targets passed to `bundleAsync`. When set,
-     * nesting + modern syntax are lowered for the given engines. The
-     * GJS orchestrator defaults this to `{ firefox: 60 << 16 }` to
-     * match the GTK4 CSS parser. Omit or leave undefined to skip
-     * lowering (output stays as-authored except for `@import` inlining).
-     */
-    targets?: import('lightningcss').Targets;
-    /**
-     * When true (default), `@import` statements are resolved by
-     * lightningcss `bundleAsync`. Set false to fall back to a plain
-     * `readFile` — useful only when you want to keep `@import` strings
-     * verbatim in the bundled JS (rare).
-     */
-    bundle?: boolean;
-}
-
-interface BundleResult {
-    code: Uint8Array;
-}
-
-type Bundler = (filename: string, targets: import('lightningcss').Targets | undefined) => Promise<BundleResult>;
-
-let _bundlerPromise: Promise<Bundler> | null = null;
-
-async function pickBundler(): Promise<Bundler> {
-    const forced = (globalThis as { process?: { env?: Record<string, string | undefined> } }).process?.env?.GJSIFY_CSS_BACKEND;
-
-    if (forced === 'npm') return loadNpmBundler();
-    if (forced === 'native') {
-        const native = await tryLoadNativeBundler();
-        if (!native) throw new Error('GJSIFY_CSS_BACKEND=native but @gjsify/lightningcss-native is not loadable');
-        return native;
-    }
-
-    const native = await tryLoadNativeBundler();
-    return native ?? loadNpmBundler();
-}
-
-// Local mirror of the @gjsify/lightningcss-native surface we touch. We
-// can't rely on the published types here because the package is an
-// OPTIONAL peer dep — under Node it's not installed, so `import type`
-// from it would break tsc on every Node consumer. Local interface
-// keeps the type narrow + decouples the plugin's typecheck from
-// whether the prebuild package is installed.
-interface NativeLightningcssSurface {
-    hasNativeLightningcss(): boolean;
-    bundle(input: {
-        filename: string;
-        targets?: string;
-        minify?: boolean;
-        sourceMap?: boolean;
-        errorRecovery?: boolean;
-    }): { code: Uint8Array; map?: Uint8Array };
-}
-
-async function tryLoadNativeBundler(): Promise<Bundler | null> {
-    // The native bridge only exists under GJS — `imports.gi` marker. Skip
-    // the dynamic import entirely on Node so it doesn't even register as a
-    // resolved dep, which would inflate the CLI's bundled output.
-    const isGjs = typeof (globalThis as { imports?: { gi?: unknown } }).imports?.gi !== 'undefined';
-    if (!isGjs) return null;
-
-    try {
-        // Indirect specifier so tsc + Rolldown don't try to resolve the
-        // optional peer dep at build time. Resolution happens only at
-        // runtime under GJS (where the prebuild is installed).
-        const specifier = '@gjsify/lightningcss-native';
-        const mod = (await import(/* @vite-ignore */ specifier)) as NativeLightningcssSurface;
-        if (!mod.hasNativeLightningcss()) return null;
-        return async (filename, targets) => {
-            // The native shim accepts a browserslist string; the npm
-            // `lightningcss` Targets struct is bitfield-encoded
-            // (`firefox: 60 << 16` etc). Convert by extracting major
-            // version per browser key and re-emitting as the equivalent
-            // browserslist query.
-            const query = targetsToBrowserslist(targets);
-            return mod.bundle({
-                filename,
-                targets: query,
-                minify: false,
-                sourceMap: false,
-                errorRecovery: true,
-            });
-        };
-    } catch {
-        return null;
-    }
-}
-
-async function loadNpmBundler(): Promise<Bundler> {
-    const { bundleAsync } = await import('lightningcss');
-    return async (filename, targets) => {
-        const result = await bundleAsync({
-            filename,
-            targets,
-            minify: false,
-            errorRecovery: true,
-        });
-        return { code: result.code };
-    };
-}
-
-function targetsToBrowserslist(
-    targets: import('lightningcss').Targets | undefined,
-): string | undefined {
-    if (!targets) return undefined;
-    const parts: string[] = [];
-    for (const [browser, encoded] of Object.entries(targets) as [string, number | undefined][]) {
-        if (typeof encoded !== 'number') continue;
-        // npm lightningcss encodes versions as `(major << 16) | (minor << 8) | patch`.
-        const major = (encoded >>> 16) & 0xff;
-        if (major === 0) continue;
-        const name = browser === 'ios_saf' ? 'ios' : browser;
-        parts.push(`${name} >= ${major}`);
-    }
-    return parts.length ? parts.join(', ') : undefined;
-}
-
-export function cssAsStringPlugin(options: CssAsStringOptions = {}): Plugin {
-    const { targets, bundle = true } = options;
-    return {
-        name: 'gjsify-css-as-string',
-        load: {
-            filter: { id: /\.css$/ },
-            async handler(id: string) {
-                const code = bundle
-                    ? new TextDecoder('utf-8').decode(await loadAndBundleCss(id, targets))
-                    : await readFile(id, 'utf8');
-                return {
-                    code: `export default ${JSON.stringify(code)};`,
-                    moduleType: 'js' as const,
-                };
-            },
-        },
-    };
-}
-
-async function loadAndBundleCss(
-    filename: string,
-    targets: import('lightningcss').Targets | undefined,
-): Promise<Uint8Array> {
-    if (!_bundlerPromise) _bundlerPromise = pickBundler();
-    const bundler = await _bundlerPromise;
-    const { code } = await bundler(filename, targets);
-    return code;
-}