effect-start 0.22.0 → 0.23.0

package/dist/sql/mssql/index.js

@@ -0,0 +1,113 @@
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as FiberRef from "effect/FiberRef";
+import * as GlobalValue from "effect/GlobalValue";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Sql from "../../Sql.js";
+const wrapError = (error) => new Sql.SqlError({
+    code: error?.code ??
+        (error?.number != null ? String(error.number) : "UNKNOWN"),
+    message: error instanceof Error ? error.message : String(error),
+    cause: error,
+});
+const makeValues = (obj, ...columns) => {
+    const items = Array.isArray(obj) ? obj : [obj];
+    const cols = columns.length > 0 ? columns : Object.keys(items[0]);
+    return { value: items, columns: cols };
+};
+const buildQuery = (strings, values) => {
+    let text = strings[0];
+    for (let i = 0; i < values.length; i++)
+        text += `@p${i + 1}` + strings[i + 1];
+    return { text, values };
+};
+const addInputs = (request, values) => {
+    for (let i = 0; i < values.length; i++) {
+        request.input(`p${i + 1}`, values[i]);
+    }
+};
+const loadMssql = () => import("mssql");
+const currentTransaction = GlobalValue.globalValue(Symbol.for("effect-start/sql/mssql/currentTransaction"), () => FiberRef.unsafeMake(Option.none()));
+const executeQuery = (pool, text, values) => Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) => {
+    const request = Option.isSome(txOpt) ? txOpt.value.transaction.request() : pool.request();
+    addInputs(request, values);
+    return Effect.tryPromise({
+        try: () => request.query(text),
+        catch: wrapError,
+    }).pipe(Effect.map((result) => result.recordset ?? []));
+});
+const runQuery = (pool, strings, values) => {
+    const { text, values: params } = buildQuery(strings, values);
+    return executeQuery(pool, text, params);
+};
+const runUnsafe = (pool, query, values) => Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) => {
+    const request = Option.isSome(txOpt) ? txOpt.value.transaction.request() : pool.request();
+    if (values)
+        addInputs(request, values);
+    return Effect.tryPromise({
+        try: () => request.query(query),
+        catch: wrapError,
+    }).pipe(Effect.map((result) => result.recordset ?? []));
+});
+const makeWithTransaction = (pool) => (self) => Effect.uninterruptibleMask((restore) => Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) => {
+    if (Option.isSome(txOpt)) {
+        const { transaction, depth } = txOpt.value;
+        const name = `sp_${depth}`;
+        return Effect.gen(function* () {
+            const req = transaction.request();
+            yield* Effect.tryPromise({
+                try: () => req.query(`SAVE TRANSACTION ${name}`),
+                catch: wrapError,
+            });
+            const exit = yield* Effect.exit(restore(Effect.locally(self, currentTransaction, Option.some({ transaction, depth: depth + 1 }))));
+            if (Exit.isSuccess(exit)) {
+                return exit.value;
+            }
+            const rbReq = transaction.request();
+            yield* Effect.tryPromise({
+                try: () => rbReq.query(`ROLLBACK TRANSACTION ${name}`),
+                catch: wrapError,
+            }).pipe(Effect.orDie);
+            return yield* exit;
+        });
+    }
+    return Effect.gen(function* () {
+        const transaction = pool.transaction();
+        yield* Effect.tryPromise({ try: () => transaction.begin(), catch: wrapError });
+        const exit = yield* Effect.exit(restore(Effect.locally(self, currentTransaction, Option.some({ transaction, depth: 1 }))));
+        if (Exit.isSuccess(exit)) {
+            yield* Effect.tryPromise({ try: () => transaction.commit(), catch: wrapError });
+            return exit.value;
+        }
+        yield* Effect.tryPromise({ try: () => transaction.rollback(), catch: wrapError }).pipe(Effect.orDie);
+        return yield* exit;
+    });
+}));
+export const layer = (config) => Layer.scoped(Sql.SqlClient, Effect.acquireRelease(Effect.tryPromise({
+    try: async () => {
+        const mssql = await loadMssql();
+        const pool = await new mssql.ConnectionPool(config).connect();
+        return { mssql, pool };
+    },
+    catch: wrapError,
+}).pipe(Effect.map(({ mssql, pool }) => {
+    const use = (fn) => Effect.tryPromise({ try: () => Promise.resolve(fn(pool)), catch: wrapError });
+    return Object.assign((strings, ...values) => runQuery(pool, strings, values), {
+        unsafe: (query, values) => runUnsafe(pool, query, values),
+        values: makeValues,
+        withTransaction: makeWithTransaction(pool),
+        reserve: Effect.acquireRelease(Effect.tryPromise({
+            try: () => new mssql.ConnectionPool({
+                ...config,
+                pool: { max: 1, min: 1 },
+            }).connect(),
+            catch: wrapError,
+        }), (reserved) => Effect.tryPromise({ try: () => reserved.close(), catch: () => void 0 }).pipe(Effect.asVoid, Effect.orDie)).pipe(Effect.map((reserved) => Object.assign((strings, ...values) => runQuery(reserved, strings, values), {
+            unsafe: (query, values) => runUnsafe(reserved, query, values),
+            values: makeValues,
+        }))),
+        close: () => use((pool) => pool.close()),
+        use,
+    });
+})), (client) => client.close().pipe(Effect.orDie)));

package/dist/testing/TestLogger.js

@@ -17,7 +17,10 @@ export function layer() {
             const causeStr = !Cause.isEmpty(cause)
                 ? ` ${Cause.pretty(cause, { renderErrorCause: true })}`
                 : "";
-            MutableRef.update(mutableRef, (msgs) => [...msgs, `[${logLevel._tag}] ${String(message)}${causeStr}`]);
+            MutableRef.update(mutableRef, (msgs) => [
+                ...msgs,
+                `[${logLevel._tag}] ${String(message)}${causeStr}`,
+            ]);
         });
         yield* FiberRef.update(FiberRef.currentLoggers, (loggers) => HashSet.add(HashSet.remove(loggers, Logger.defaultLogger), customLogger));
         return { messages };

package/dist/testing/index.d.ts

@@ -1,3 +1,2 @@
-export * as TestHttpClient from "./TestHttpClient.ts";
 export * as TestLogger from "./TestLogger.ts";
 export * from "./utils.ts";

package/dist/testing/index.js

@@ -1,3 +1,2 @@
-export * as TestHttpClient from "./TestHttpClient.js";
 export * as TestLogger from "./TestLogger.js";
 export * from "./utils.js";

package/dist/testing/utils.d.ts

@@ -1,9 +1,9 @@
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import * as Scope from "effect/Scope";
-import type { YieldWrap } from "effect/Utils";
+import type * as Scope from "effect/Scope";
+import type * as Utils from "effect/Utils";
 /**
  * Creates a scoped Effects and runs is asynchronously.
  * Useful for testing.
  */
-export declare const effectFn: <RL>(layer?: Layer.Layer<RL, any>) => <Eff extends YieldWrap<Effect.Effect<any, any, RE>>, AEff, RE extends RL | Scope.Scope>(f: () => Generator<Eff, AEff, never>) => Promise<void>;
+export declare const effectFn: <RL>(layer?: Layer.Layer<RL, any>) => <Eff extends Utils.YieldWrap<Effect.Effect<any, any, RE>>, AEff, RE extends RL | Scope.Scope>(f: () => Generator<Eff, AEff, never>) => Promise<void>;

package/dist/testing/utils.js

@@ -9,7 +9,7 @@ import * as Logger from "effect/Logger";
  */
 export const effectFn = (layer) => (f) => Function.pipe(Effect.gen(f), Effect.scoped, Effect.provide(Logger.pretty), Effect.provide(layer ?? Layer.empty), 
 // @ts-expect-error will have to figure out how to clear deps
-Effect.runPromise, v => v.then(() => { }, clearStackTraces));
+Effect.runPromise, (v) => v.then(() => { }, clearStackTraces));
 /*
  * When effect fails, instead of throwing FiberFailure,
  * throw a plain Error with the strack trace and hides
@@ -22,18 +22,18 @@ Effect.runPromise, v => v.then(() => { }, clearStackTraces));
  * files that are then loaded into a runtime.
  */
 const clearStackTraces = (err) => {
-    const ExternalStackTraceLineRegexp = /\(.*\/node_modules\/[^\.]/;
+    const ExternalStackTraceLineRegexp = /\(.*\/node_modules\/[^.]/;
     const message = err instanceof Error
         ? err.message
         : typeof err === "object" && err !== null && "message" in err
             ? String(err.message)
             : String(err);
     const stack = err instanceof Error
-        ? err.stack ?? ""
+        ? (err.stack ?? "")
         : typeof err === "object" && err !== null && "stack" in err
             ? String(err.stack)
             : "";
     const newErr = new Error(message);
-    newErr.stack = Function.pipe(stack.split("\n"), Array.takeWhile(s => !ExternalStackTraceLineRegexp.test(s)), Array.join("\n"));
+    newErr.stack = Function.pipe(stack.split("\n"), Array.takeWhile((s) => !ExternalStackTraceLineRegexp.test(s)), Array.join("\n"));
     throw newErr;
 };

package/dist/x/cloudflare/CloudflareTunnel.d.ts

@@ -1,7 +1,4 @@
 import { Effect, Layer, LogLevel } from "effect";
-/**
- * Starts Cloudflare tunnel using cloudflared cli.
- */
 export declare const start: (opts: {
     command?: string;
     tunnelName: string;
@@ -9,5 +6,5 @@ export declare const start: (opts: {
     cleanLogs?: false;
     logLevel?: LogLevel.LogLevel;
     logPrefix?: string;
-}) => Effect.Effect<void, import("@effect/platform/Error").PlatformError, import("effect/Scope").Scope | import("@effect/platform/CommandExecutor").CommandExecutor>;
-export declare const layer: () => Layer.Layer<never, import("effect/ConfigError").ConfigError, import("@effect/platform/CommandExecutor").CommandExecutor>;
+}) => Effect.Effect<void, import("../../PlatformError.ts").PlatformError, import("../../ChildProcess.ts").ChildProcessSpawner | import("effect/Scope").Scope>;
+export declare const layer: () => Layer.Layer<never, import("effect/ConfigError").ConfigError, import("../../ChildProcess.ts").ChildProcessSpawner>;

package/dist/x/cloudflare/CloudflareTunnel.js

@@ -1,31 +1,20 @@
-import { Command, } from "@effect/platform";
-import { Config, Effect, identity, Layer, LogLevel, Option, pipe, Stream, String, } from "effect";
-/**
- * Starts Cloudflare tunnel using cloudflared cli.
- */
+import * as System from "../../System.js";
+import { Config, Effect, Layer, LogLevel, Option, pipe, Stream, String } from "effect";
 export const start = (opts) => Effect.gen(function* () {
-    const logPrefix = String.isString(opts.logPrefix)
-        ? opts.logPrefix
-        : "CloudflareTunnel: ";
+    const command = opts.command ?? "cloudflared";
+    yield* System.which(command);
+    const logPrefix = String.isString(opts.logPrefix) ? opts.logPrefix : "CloudflareTunnel: ";
     const args = [
         "tunnel",
         "run",
-        opts.tunnelUrl
-            ? [
-                "--url",
-                opts.tunnelUrl,
-            ]
-            : [],
+        opts.tunnelUrl ? ["--url", opts.tunnelUrl] : [],
         opts.tunnelName,
-    ]
-        .flatMap(v => v);
-    const process = yield* pipe(Command.make(opts.command ?? "cloudflared", ...args), Command.start);
-    yield* Effect.logInfo(`Cloudflare tunnel started name=${opts.tunnelName} pid=${process.pid} tunnelUrl=${opts.tunnelUrl ?? "<empty>"}`);
-    yield* pipe(Stream.merge(process.stdout, process.stderr), Stream.decodeText("utf-8"), Stream.splitLines, opts.cleanLogs ?? true
-        ? Stream.map(v => v.replace(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z\s\w+\s/, ""))
-        : identity, logPrefix
-        ? Stream.map(v => logPrefix + v)
-        : identity, Stream.runForEach(v => Effect.logWithLevel(opts.logLevel ?? LogLevel.Debug, v)));
+    ].flatMap((v) => v);
+    const proc = yield* System.spawn(command, args);
+    yield* Effect.logInfo(`Cloudflare tunnel started name=${opts.tunnelName} pid=${proc.pid} tunnelUrl=${opts.tunnelUrl ?? "<empty>"}`);
+    yield* pipe(Stream.merge(proc.stdout, proc.stderr), Stream.decodeText("utf-8"), Stream.splitLines, (opts.cleanLogs ?? true)
+        ? Stream.map((v) => v.replace(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z\s\w+\s/, ""))
+        : (s) => s, logPrefix ? Stream.map((v) => logPrefix + v) : (s) => s, Stream.runForEach((v) => Effect.logWithLevel(opts.logLevel ?? LogLevel.Debug, v)));
 });
 export const layer = () => Layer.scopedDiscard(Effect.gen(function* () {
     const tunnelName = yield* pipe(Config.string("CLOUDFLARE_TUNNEL_NAME"), Config.option, Effect.andThen(Option.getOrUndefined));
@@ -34,10 +23,8 @@ export const layer = () => Layer.scopedDiscard(Effect.gen(function* () {
         yield* Effect.logWarning("CLOUDFLARE_TUNNEL_NAME not provided. Skipping.");
         return;
     }
-    yield* Effect
-        .forkScoped(pipe(start({
+    yield* Effect.forkScoped(start({
         tunnelName,
         tunnelUrl,
-    })))
-        .pipe(Effect.catchAll(err => Effect.logError("Cloudflare tunnel failed", err)));
+    }).pipe(Effect.catchAll((err) => Effect.logError("Cloudflare tunnel failed", err))));
 }));

package/dist/x/datastar/Datastar.d.ts

@@ -1,4 +1,4 @@
-import * as HyperNode from "../../hyper/HyperNode.ts";
+import type * as HyperNode from "../../hyper/HyperNode.ts";
 export declare const HyperHooks: {
     readonly onNode: typeof onNode;
 };

package/dist/x/datastar/Datastar.js

@@ -7,21 +7,27 @@ function onNode(node) {
         node.props["data-signals"] = JSON.stringify(dataSignals);
     }
     if (typeof dataClass === "function") {
-        node.props["data-class"] = `(${dataClass.toString()})()`;
+        node.props["data-class"] = dataClass.toString();
     }
     else if (typeof dataClass === "object" && dataClass !== null) {
         node.props["data-class"] = JSON.stringify(dataClass);
     }
-    if (typeof dataAttr === "object" && dataAttr !== null) {
+    if (typeof dataAttr === "function") {
+        node.props["data-attr"] = dataAttr.toString();
+    }
+    else if (typeof dataAttr === "object" && dataAttr !== null) {
         node.props["data-attr"] = JSON.stringify(dataAttr);
     }
     if (typeof dataStyle === "function") {
-        node.props["data-style"] = `(${dataStyle.toString()})()`;
+        node.props["data-style"] = dataStyle.toString();
     }
     else if (typeof dataStyle === "object" && dataStyle !== null) {
         node.props["data-style"] = JSON.stringify(dataStyle);
     }
-    if (typeof dataShow === "boolean") {
+    if (typeof dataShow === "function") {
+        node.props["data-show"] = dataShow.toString();
+    }
+    else if (typeof dataShow === "boolean") {
         node.props["data-show"] = dataShow.toString();
     }
     if (dataIgnore !== true && dataIgnore !== undefined) {
@@ -30,17 +36,12 @@ function onNode(node) {
     if (dataIgnoreMorph !== true && dataIgnoreMorph !== undefined) {
         delete node.props["data-ignore-morph"];
     }
-    // Handle dynamic attributes with suffixes
     for (const [key, value] of Object.entries(node.props)) {
-        if (key.startsWith("data-signals-")
-            && typeof value === "object"
-            && value !== null) {
+        if (key.startsWith("data-signals-") && typeof value === "object" && value !== null) {
             node.props[key] = JSON.stringify(value);
         }
-        if (key.startsWith("data-on-")
-            && typeof value === "function") {
-            // @ts-ignore
-            node.props[key] = `(${value.toString()})()`;
+        if (key.startsWith("data-") && key !== "data-signals" && typeof value === "function") {
+            node.props[key] = value.toString();
         }
     }
 }

package/dist/x/datastar/index.d.ts

@@ -1,2 +1 @@
-export * as Datastar from "./Datastar.ts";
-export { HyperHooks, } from "./Datastar.ts";
+export {};

package/dist/x/datastar/index.js

@@ -1,2 +1 @@
-export * as Datastar from "./Datastar.js";
-export { HyperHooks, } from "./Datastar.js";
+export {};

package/dist/x/tailscale/TailscaleTunnel.d.ts

@@ -0,0 +1,15 @@
+import * as BunServer from "../../bun/BunServer.ts";
+import * as PlatformError from "../../PlatformError.ts";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as LogLevel from "effect/LogLevel";
+export declare const start: (opts: {
+    command?: string;
+    port: number;
+    public?: boolean;
+    logLevel?: LogLevel.LogLevel;
+    logPrefix?: string;
+}) => Effect.Effect<void, PlatformError.PlatformError, import("../../ChildProcess.ts").ChildProcessSpawner | import("effect/Scope").Scope>;
+export declare const layer: (opts?: {
+    public?: boolean;
+}) => Layer.Layer<never, never, import("../../ChildProcess.ts").ChildProcessSpawner | BunServer.BunServer>;

package/dist/x/tailscale/TailscaleTunnel.js

@@ -0,0 +1,68 @@
+import * as BunServer from "../../bun/BunServer.js";
+import * as PlatformError from "../../PlatformError.js";
+import * as System from "../../System.js";
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import * as Fiber from "effect/Fiber";
+import * as Layer from "effect/Layer";
+import * as LogLevel from "effect/LogLevel";
+import * as Stream from "effect/Stream";
+import * as Function from "effect/Function";
+const getStatus = (command) => Effect.gen(function* () {
+    const proc = yield* System.spawn(command, ["status", "--json"]);
+    const exitCode = yield* proc.exitCode;
+    if (exitCode !== 0) {
+        const stderr = yield* proc.stderr.pipe(Stream.decodeText("utf-8"), Stream.mkString);
+        return yield* new PlatformError.SystemError({
+            reason: "Unknown",
+            module: "TailscaleTunnel",
+            method: "getStatus",
+            description: `tailscale status exited with code ${exitCode}: ${stderr}`,
+        });
+    }
+    const stdout = yield* proc.stdout.pipe(Stream.decodeText("utf-8"), Stream.mkString);
+    const json = JSON.parse(stdout);
+    if (json.BackendState !== "Running") {
+        return yield* new PlatformError.SystemError({
+            reason: "Unknown",
+            module: "TailscaleTunnel",
+            method: "getStatus",
+            description: `tailscale is in state "${json.BackendState}", expected "Running"`,
+        });
+    }
+    return json;
+});
+const serve = (opts) => Effect.gen(function* () {
+    const logPrefix = opts.logPrefix ?? "TailscaleTunnel: ";
+    const args = [opts.public ? "funnel" : "serve", String(opts.port)];
+    const proc = yield* System.spawn(opts.command, args);
+    yield* Function.pipe(Stream.merge(proc.stdout, proc.stderr), Stream.decodeText("utf-8"), Stream.splitLines, logPrefix ? Stream.map((v) => logPrefix + v) : (s) => s, Stream.runForEach((v) => Effect.logWithLevel(opts.logLevel ?? LogLevel.Debug, v)));
+});
+export const start = (opts) => Effect.gen(function* () {
+    const command = opts.command ?? "tailscale";
+    yield* System.which(command);
+    const status = yield* getStatus(command);
+    const dnsName = status.Self?.DNSName?.replace(/\.$/, "");
+    yield* serve({ ...opts, command, dnsName });
+});
+export const layer = (opts) => Layer.scopedDiscard(Effect.gen(function* () {
+    const { server } = yield* BunServer.BunServer;
+    const port = server.port;
+    const command = "tailscale";
+    const ready = yield* Deferred.make();
+    const fiber = yield* Effect.forkScoped(Effect.gen(function* () {
+        yield* System.which(command);
+        const status = yield* getStatus(command);
+        const dnsName = status.Self?.DNSName?.replace(/\.$/, "");
+        const serveUrl = dnsName ? `https://${dnsName}` : undefined;
+        yield* Effect.logInfo(`Tailscale ${opts?.public ? "funnel" : "serve"}${serveUrl ? ` url=${serveUrl}` : ""}`);
+        yield* Deferred.succeed(ready, void 0);
+        yield* serve({
+            command,
+            port,
+            dnsName,
+            public: opts?.public,
+        });
+    }).pipe(Effect.orDie));
+    yield* Fiber.join(fiber).pipe(Effect.raceFirst(Deferred.await(ready)));
+}));

package/dist/x/tailscale/index.d.ts

@@ -0,0 +1 @@
+export * as TailscaleTunnel from "./TailscaleTunnel.ts";

package/dist/x/tailscale/index.js

@@ -0,0 +1 @@
+export * as TailscaleTunnel from "./TailscaleTunnel.js";

package/dist/x/tailwind/TailwindPlugin.js

@@ -17,7 +17,7 @@ export const make = (opts) => {
                 ? async () => {
                     const candidates = await scanFiles(opts.scanPath);
                     scannedCandidates.clear();
-                    candidates.forEach(candidate => scannedCandidates.add(candidate));
+                    candidates.forEach((candidate) => scannedCandidates.add(candidate));
                 }
                 : null;
             // Track import relationships when dynamically scanning
@@ -100,17 +100,15 @@ export const make = (opts) => {
                             continue;
                         }
                         const moduleImports = importDescendants.get(currentPath);
-                        moduleImports?.forEach(moduleImport => {
+                        moduleImports?.forEach((moduleImport) => {
                             const moduleCandidates = classNameCandidates.get(moduleImport);
-                            moduleCandidates?.forEach(candidate => candidates.add(candidate));
+                            moduleCandidates?.forEach((candidate) => candidates.add(candidate));
                             pendingModules.push(moduleImport);
                         });
                         visitedModules.add(currentPath);
                     }
                 }
-                const contents = compiler.build([
-                    ...candidates,
-                ]);
+                const contents = compiler.build([...candidates]);
                 return {
                     contents,
                     loader: "css",
@@ -125,15 +123,15 @@ const TEMPLATE_EXPRESSION_REGEX = /\$\{[^}]*\}/g;
 const TAILWIND_CLASS_REGEX = /^[a-zA-Z0-9_:-]+(\[[^\]]*\])?$/;
 const CLASS_NAME_PATTERNS = [
     // HTML class attributes with double quotes: <div class="bg-blue-500 text-white">
-    "<[^>]*?\\sclass\\s*=\\s*\"([^\"]+)\"",
+    '<[^>]*?\\sclass\\s*=\\s*"([^"]+)"',
     // HTML class attributes with single quotes: <div class='bg-blue-500 text-white'>
     "<[^>]*?\\sclass\\s*=\\s*'([^']+)'",
     // JSX className attributes with double quotes: <div className="bg-blue-500 text-white">
-    "<[^>]*?\\sclassName\\s*=\\s*\"([^\"]+)\"",
+    '<[^>]*?\\sclassName\\s*=\\s*"([^"]+)"',
     // JSX className attributes with single quotes: <div className='bg-blue-500 text-white'>
     "<[^>]*?\\sclassName\\s*=\\s*'([^']+)'",
     // JSX className with braces and double quotes: <div className={"bg-blue-500 text-white"}>
-    "<[^>]*?\\sclassName\\s*=\\s*\\{\\s*\"([^\"]+)\"\\s*\\}",
+    '<[^>]*?\\sclassName\\s*=\\s*\\{\\s*"([^"]+)"\\s*\\}',
     // JSX className with braces and single quotes: <div className={'bg-blue-500 text-white'}>
     "<[^>]*?\\sclassName\\s*=\\s*\\{\\s*'([^']+)'\\s*\\}",
     // JSX className with template literals: <div className={`bg-blue-500 ${variable}`}>
@@ -141,15 +139,15 @@ const CLASS_NAME_PATTERNS = [
     // HTML class with template literals: <div class={`bg-blue-500 ${variable}`}>
     "<[^>]*?\\sclass\\s*=\\s*\\{\\s*`([^`]*)`\\s*\\}",
     // HTML class at start of tag with double quotes: <div class="bg-blue-500">
-    "<\\w+\\s+class\\s*=\\s*\"([^\"]+)\"",
+    '<\\w+\\s+class\\s*=\\s*"([^"]+)"',
     // HTML class at start of tag with single quotes: <div class='bg-blue-500'>
     "<\\w+\\s+class\\s*=\\s*'([^']+)'",
     // JSX className at start of tag with double quotes: <div className="bg-blue-500">
-    "<\\w+\\s+className\\s*=\\s*\"([^\"]+)\"",
+    '<\\w+\\s+className\\s*=\\s*"([^"]+)"',
     // JSX className at start of tag with single quotes: <div className='bg-blue-500'>
     "<\\w+\\s+className\\s*=\\s*'([^']+)'",
     // JSX className at start with braces and double quotes: <div className={"bg-blue-500"}>
-    "<\\w+\\s+className\\s*=\\s*\\{\\s*\"([^\"]+)\"\\s*\\}",
+    '<\\w+\\s+className\\s*=\\s*\\{\\s*"([^"]+)"\\s*\\}',
     // JSX className at start with braces and single quotes: <div className={'bg-blue-500'}>
     "<\\w+\\s+className\\s*=\\s*\\{\\s*'([^']+)'\\s*\\}",
     // JSX className at start with template literals: <div className={`bg-blue-500 ${variable}`}>
@@ -157,13 +155,12 @@ const CLASS_NAME_PATTERNS = [
     // HTML class at start with template literals: <div class={`bg-blue-500 ${variable}`}>
     "<\\w+\\s+class\\s*=\\s*\\{\\s*`([^`]*)`\\s*\\}",
 ];
-const CLASS_NAME_REGEX = new RegExp(CLASS_NAME_PATTERNS.map(pattern => `(?:${pattern})`).join("|"), "g");
+const CLASS_NAME_REGEX = new RegExp(CLASS_NAME_PATTERNS.map((pattern) => `(?:${pattern})`).join("|"), "g");
 function hasCssImport(css, specifier) {
     const [, importPath] = css.match(CSS_IMPORT_REGEX) ?? [];
     if (!importPath)
         return false;
-    return specifier === undefined
-        || importPath.includes(specifier);
+    return specifier === undefined || importPath.includes(specifier);
 }
 export function extractClassNames(source) {
     const candidates = new Set();
@@ -183,20 +180,23 @@ export function extractClassNames(source) {
         if (classString.includes("${")) {
             const staticParts = classString.split(TEMPLATE_EXPRESSION_REGEX);
             for (const part of staticParts) {
-                const names = part.trim().split(/\s+/).filter(name => {
+                const names = part
+                    .trim()
+                    .split(/\s+/)
+                    .filter((name) => {
                     if (name.length === 0)
                         return false;
                     if (name.endsWith("-") || name.startsWith("-"))
                         return false;
                     return TAILWIND_CLASS_REGEX.test(name);
                 });
-                names.forEach(name => candidates.add(name));
+                names.forEach((name) => candidates.add(name));
             }
         }
         else {
             // Simple case: regular class string without expressions
-            const names = classString.split(/\s+/).filter(name => name.length > 0);
-            names.forEach(name => candidates.add(name));
+            const names = classString.split(/\s+/).filter((name) => name.length > 0);
+            names.forEach((name) => candidates.add(name));
         }
     }
     return candidates;

package/dist/x/tailwind/compile.d.ts

@@ -1,6 +1,6 @@
 import { compile as _compile, compileAst as _compileAst, Features, Polyfills } from "tailwindcss";
 type AstNode = Parameters<typeof _compileAst>[0][number];
-export { Features, Polyfills, };
+export { Features, Polyfills };
 export type Resolver = (id: string, base: string) => Promise<string | false | undefined>;
 export interface CompileOptions {
     base: string;
@@ -10,7 +10,7 @@ export interface CompileOptions {
     customCssResolver?: Resolver;
     customJsResolver?: Resolver;
 }
-export declare function compileAst(ast: AstNode[], options: CompileOptions): ReturnType<typeof _compileAst>;
+export declare function compileAst(ast: Array<AstNode>, options: CompileOptions): ReturnType<typeof _compileAst>;
 export declare function compile(css: string, options: CompileOptions): ReturnType<typeof _compile>;
 export declare function loadModule(id: string, base: string, _onDependency: (path: string) => void, customJsResolver?: Resolver): Promise<{
     path: string;

package/dist/x/tailwind/compile.js

@@ -9,7 +9,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 import fsPromises from "node:fs/promises";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
-import { compile as _compile, compileAst as _compileAst, } from "tailwindcss";
+import { compile as _compile, compileAst as _compileAst } from "tailwindcss";
 import * as BunEnhancedResolve from "../../bun/_BunEnhancedResolve";
 function createCompileOptions({ base, from, polyfills, onDependency, customCssResolver, customJsResolver, }) {
     return {
@@ -72,9 +72,7 @@ export async function loadModule(id, base, _onDependency, customJsResolver) {
     if (!resolvedPath) {
         throw new Error(`Could not resolve '${id}' from '${base}'`);
     }
-    let [module] = await Promise.all([
-        importModule(pathToFileURL(resolvedPath).href + "?id=" + Date.now()),
-    ]);
+    let module = await importModule(pathToFileURL(resolvedPath).href + "?id=" + Date.now());
     return {
         path: resolvedPath,
         base: path.dirname(resolvedPath),