weapp-tailwindcss 4.12.0 → 5.0.0-next.10

package/dist/constants-BG12WAKw.mjs

@@ -0,0 +1,44 @@
+//#region src/css-macro/constants.ts
+const queryKey = "weapp-tw-platform";
+function createMediaQuery(value) {
+	return `@media (${queryKey}:"${value}"){&}`;
+}
+function createNegativeMediaQuery(value) {
+	return `@media not screen and (${queryKey}:"${value}"){&}`;
+}
+const UNESCAPED_UNDERSCORE_RE = /(?<!\\)_/g;
+const WHITESPACE_RE = /\s+/g;
+const LOGICAL_OPERATOR_RE = /\s*(\|\||&&)\s*/g;
+function normalComment(text) {
+	if (typeof text === "string") {
+		const normalized = text.replaceAll(UNESCAPED_UNDERSCORE_RE, " ").replaceAll(WHITESPACE_RE, " ").trim();
+		if (normalized.includes("\\")) return normalized;
+		return normalized.replaceAll(LOGICAL_OPERATOR_RE, " $1 ").replaceAll(WHITESPACE_RE, " ").trim();
+	}
+	return text;
+}
+function ifdef(text) {
+	return {
+		start: `#ifdef ${normalComment(text)}`,
+		end: `#endif`
+	};
+}
+function ifndef(text) {
+	return {
+		start: `#ifndef ${normalComment(text)}`,
+		end: `#endif`
+	};
+}
+const QUERY_KEY_REGEX = new RegExp(`\\(\\s*${queryKey}\\s*:\\s*"([^)]*)"\\)`, "g");
+function matchCustomPropertyFromValue(str, cb) {
+	let index = 0;
+	QUERY_KEY_REGEX.lastIndex = 0;
+	let arr = QUERY_KEY_REGEX.exec(str);
+	while (arr !== null) {
+		cb(arr, index);
+		index++;
+		arr = QUERY_KEY_REGEX.exec(str);
+	}
+}
+//#endregion
+export { matchCustomPropertyFromValue as a, ifndef as i, createNegativeMediaQuery as n, ifdef as r, createMediaQuery as t };

package/dist/constants-BeeyfJ9k.js

@@ -0,0 +1,73 @@
+//#region src/css-macro/constants.ts
+const queryKey = "weapp-tw-platform";
+function createMediaQuery(value) {
+	return `@media (${queryKey}:"${value}"){&}`;
+}
+function createNegativeMediaQuery(value) {
+	return `@media not screen and (${queryKey}:"${value}"){&}`;
+}
+const UNESCAPED_UNDERSCORE_RE = /(?<!\\)_/g;
+const WHITESPACE_RE = /\s+/g;
+const LOGICAL_OPERATOR_RE = /\s*(\|\||&&)\s*/g;
+function normalComment(text) {
+	if (typeof text === "string") {
+		const normalized = text.replaceAll(UNESCAPED_UNDERSCORE_RE, " ").replaceAll(WHITESPACE_RE, " ").trim();
+		if (normalized.includes("\\")) return normalized;
+		return normalized.replaceAll(LOGICAL_OPERATOR_RE, " $1 ").replaceAll(WHITESPACE_RE, " ").trim();
+	}
+	return text;
+}
+function ifdef(text) {
+	return {
+		start: `#ifdef ${normalComment(text)}`,
+		end: `#endif`
+	};
+}
+function ifndef(text) {
+	return {
+		start: `#ifndef ${normalComment(text)}`,
+		end: `#endif`
+	};
+}
+const QUERY_KEY_REGEX = new RegExp(`\\(\\s*${queryKey}\\s*:\\s*"([^)]*)"\\)`, "g");
+function matchCustomPropertyFromValue(str, cb) {
+	let index = 0;
+	QUERY_KEY_REGEX.lastIndex = 0;
+	let arr = QUERY_KEY_REGEX.exec(str);
+	while (arr !== null) {
+		cb(arr, index);
+		index++;
+		arr = QUERY_KEY_REGEX.exec(str);
+	}
+}
+//#endregion
+Object.defineProperty(exports, "createMediaQuery", {
+	enumerable: true,
+	get: function() {
+		return createMediaQuery;
+	}
+});
+Object.defineProperty(exports, "createNegativeMediaQuery", {
+	enumerable: true,
+	get: function() {
+		return createNegativeMediaQuery;
+	}
+});
+Object.defineProperty(exports, "ifdef", {
+	enumerable: true,
+	get: function() {
+		return ifdef;
+	}
+});
+Object.defineProperty(exports, "ifndef", {
+	enumerable: true,
+	get: function() {
+		return ifndef;
+	}
+});
+Object.defineProperty(exports, "matchCustomPropertyFromValue", {
+	enumerable: true,
+	get: function() {
+		return matchCustomPropertyFromValue;
+	}
+});

package/dist/constants.d.ts

@@ -0,0 +1,12 @@
+export declare const runtimeAopLoader = "weapp-tw-runtime-aop-loader";
+export declare const WeappTailwindcssWebpackPluginOptimizeChunkAssetsHooks = "WeappTailwindcssWebpackPluginOptimizeChunkAssetsHooks";
+export declare const pluginName = "weapp-tailwindcss";
+export declare const vitePluginName = "weapp-tailwindcss:adaptor";
+export declare const WEAPP_TW_REQUIRED_NODE_VERSION = "20.19.0";
+export declare const WEAPP_TW_REQUIRED_NODE_VERSION_RANGE = "^20.19.0 || >=22.12.0";
+export declare const WEAPP_TW_VERSION: string;
+export declare const DEFAULT_RUNTIME_PACKAGE_REPLACEMENTS: {
+    readonly 'tailwind-merge': "@weapp-tailwindcss/merge";
+    readonly 'class-variance-authority': "@weapp-tailwindcss/cva";
+    readonly 'tailwind-variants': "@weapp-tailwindcss/variants";
+};

package/dist/context/compiler-context-cache.d.ts

@@ -0,0 +1,3 @@
+import type { InternalUserDefinedOptions, UserDefinedOptions } from '../types';
+export declare function createCompilerContextCacheKey(opts?: UserDefinedOptions): string | undefined;
+export declare function withCompilerContextCache(opts: UserDefinedOptions | undefined, factory: () => InternalUserDefinedOptions): InternalUserDefinedOptions;

package/dist/context/custom-attributes.d.ts

@@ -0,0 +1,2 @@
+import type { ICustomAttributes, ICustomAttributesEntities } from '../types';
+export declare function toCustomAttributesEntities(customAttributes?: ICustomAttributes): ICustomAttributesEntities;

package/dist/context/handlers.d.ts

@@ -0,0 +1,6 @@
+import type { ICustomAttributesEntities, InternalUserDefinedOptions } from '../types';
+export declare function createHandlersFromContext(ctx: InternalUserDefinedOptions, customAttributesEntities: ICustomAttributesEntities, cssCalcOptions: InternalUserDefinedOptions['cssCalc'], tailwindcssMajorVersion?: number): {
+    styleHandler: import("@weapp-tailwindcss/postcss").StyleHandler;
+    jsHandler: import("@/types").JsHandler;
+    templateHandler: (rawSource: string, opt?: Pick<import("@/types").ITemplateHandlerOptions, "runtimeSet">) => Promise<string>;
+};

package/dist/context/index.d.ts

@@ -0,0 +1,7 @@
+import type { InternalUserDefinedOptions, TailwindcssPatcherLike, UserDefinedOptions } from '../types';
+interface ClearTailwindcssPatcherCacheOptions {
+    removeDirectory?: boolean;
+}
+export declare function clearTailwindcssPatcherCache(patcher: TailwindcssPatcherLike | undefined, options?: ClearTailwindcssPatcherCacheOptions): Promise<void>;
+export declare function getCompilerContext(opts?: UserDefinedOptions): InternalUserDefinedOptions;
+export {};

package/dist/context/logger.d.ts

@@ -0,0 +1,4 @@
+declare const loggerLevelMap: Record<'info' | 'warn' | 'error' | 'silent', number>;
+export type LoggerLevel = keyof typeof loggerLevelMap;
+export declare function applyLoggerLevel(logLevel?: LoggerLevel): void;
+export {};

package/dist/context/tailwindcss/basedir.d.ts

@@ -0,0 +1 @@
+export declare function resolveTailwindcssBasedir(basedir?: string, fallback?: string): string;

package/dist/context/tailwindcss/rax.d.ts

@@ -0,0 +1,2 @@
+import type { AppType } from '../../types';
+export declare function detectImplicitCssEntries(appType: AppType | undefined, baseDir: string): string[] | undefined;

package/dist/context/tailwindcss.d.ts

@@ -0,0 +1,4 @@
+import type { InternalUserDefinedOptions } from '../types';
+import { resolveTailwindcssBasedir } from './tailwindcss/basedir';
+export declare function createTailwindcssPatcherFromContext(ctx: InternalUserDefinedOptions): import("@/types").TailwindcssPatcherLike | undefined;
+export { resolveTailwindcssBasedir };

package/dist/context/workspace.d.ts

@@ -0,0 +1,3 @@
+export declare function findWorkspaceRoot(startDir: string | undefined): string | undefined;
+export declare function findNearestPackageRoot(startDir?: string): string | undefined;
+export declare function findWorkspacePackageDir(rootDir: string, packageName: string): string | undefined;

package/dist/core.d.ts

@@ -1,26 +1,10 @@
-import { ITemplateHandlerOptions, CreateJsHandlerOptions, JsHandlerResult } from './types.js';
-import * as postcss from 'postcss';
-import { e as UserDefinedOptions } from './index-BXrmQelt.js';
-import { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
-import '@babel/parser';
-import 'magic-string';
-import 'tailwindcss-patch';
-import 'node:buffer';
-import 'webpack';
-import 'lru-cache';
-
+import type { CreateJsHandlerOptions, IStyleHandlerOptions, ITemplateHandlerOptions, UserDefinedOptions } from './types';
 type RuntimeJsTransformOptions = {
     runtimeSet?: Set<string>;
 } & CreateJsHandlerOptions;
-/**
- * 创建一个上下文对象，用于处理小程序的模板、样式和脚本转换。
- * @param options - 用户定义的选项对象
- * @returns 返回一个包含 transformWxss、transformWxml 和 transformJs 方法的对象
- */
-declare function createContext(options?: UserDefinedOptions): {
-    transformWxss: (rawCss: string, options?: Partial<IStyleHandlerOptions>) => Promise<postcss.Result<postcss.Document | postcss.Root>>;
+export declare function createContext(options?: UserDefinedOptions): {
+    transformWxss: (rawCss: string, options?: Partial<IStyleHandlerOptions>) => Promise<import("postcss").Result<import("postcss").Document | import("postcss").Root>>;
     transformWxml: (rawWxml: string, options?: ITemplateHandlerOptions) => Promise<string>;
-    transformJs: (rawJs: string, options?: RuntimeJsTransformOptions) => Promise<JsHandlerResult>;
+    transformJs: (rawJs: string, options?: RuntimeJsTransformOptions) => Promise<import("./types").JsHandlerResult>;
 };
-
-export { createContext };
+export {};

package/dist/core.js

@@ -1,185 +1,136 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
-
-
-
-
-var _chunkHVNGIKLSjs = require('./chunk-HVNGIKLS.js');
-require('./chunk-ZAA5ZG3D.js');
-require('./chunk-A5PB4KZT.js');
-require('./chunk-DYLQ6UOI.js');
-require('./chunk-RKISS72P.js');
-
-// src/core.ts
-var _process = require('process'); var _process2 = _interopRequireDefault(_process);
-var _shared = require('@weapp-tailwindcss/shared');
-var DEFAULT_MAIN_CHUNK_STYLE_OPTIONS = Object.freeze({
-  isMainChunk: true
-});
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./chunk-8l464Juk.js");
+const require_precheck = require("./precheck-B32p-gLI.js");
+let _weapp_tailwindcss_shared = require("@weapp-tailwindcss/shared");
+//#region src/core.ts
+const DEFAULT_MAIN_CHUNK_STYLE_OPTIONS = Object.freeze({ isMainChunk: true });
 function resolveTransformWxssOptions(options) {
-  if (!options) {
-    return DEFAULT_MAIN_CHUNK_STYLE_OPTIONS;
-  }
-  if (options.isMainChunk === true) {
-    return options;
-  }
-  return _shared.defuOverrideArray.call(void 0, options, DEFAULT_MAIN_CHUNK_STYLE_OPTIONS);
+	if (!options) return DEFAULT_MAIN_CHUNK_STYLE_OPTIONS;
+	if (options.isMainChunk === true) return options;
+	return (0, _weapp_tailwindcss_shared.defuOverrideArray)(options, DEFAULT_MAIN_CHUNK_STYLE_OPTIONS);
 }
+/**
+* 创建一个上下文对象，用于处理小程序的模板、样式和脚本转换。
+* @param options - 用户定义的选项对象
+* @returns 返回一个包含 transformWxss、transformWxml 和 transformJs 方法的对象
+*/
 function createContext(options = {}) {
-  const opts = _chunkHVNGIKLSjs.getCompilerContext.call(void 0, options);
-  const { templateHandler, styleHandler, jsHandler, twPatcher: initialTwPatcher, refreshTailwindcssPatcher } = opts;
-  const patchRecorderState = _chunkHVNGIKLSjs.setupPatchRecorder.call(void 0, initialTwPatcher, opts.tailwindcssBasedir, {
-    source: "runtime",
-    cwd: _nullishCoalesce(opts.tailwindcssBasedir, () => ( _process2.default.cwd()))
-  });
-  let runtimeSet = /* @__PURE__ */ new Set();
-  const runtimeState = {
-    twPatcher: initialTwPatcher,
-    patchPromise: patchRecorderState.patchPromise,
-    refreshTailwindcssPatcher,
-    onPatchCompleted: patchRecorderState.onPatchCompleted
-  };
-  const defaultJsHandlerOptionsCache = /* @__PURE__ */ new Map();
-  function getDefaultJsHandlerOptions(majorVersion = runtimeState.twPatcher.majorVersion) {
-    if (typeof majorVersion !== "number") {
-      return void 0;
-    }
-    let cached = defaultJsHandlerOptionsCache.get(majorVersion);
-    if (!cached) {
-      cached = {
-        tailwindcssMajorVersion: majorVersion
-      };
-      defaultJsHandlerOptionsCache.set(majorVersion, cached);
-    }
-    return cached;
-  }
-  function withRuntimeTailwindMajorVersion(options2) {
-    if (!options2) {
-      return getDefaultJsHandlerOptions();
-    }
-    if (typeof options2.tailwindcssMajorVersion === "number") {
-      return options2;
-    }
-    const majorVersion = runtimeState.twPatcher.majorVersion;
-    if (typeof majorVersion !== "number") {
-      return options2;
-    }
-    return {
-      ...options2,
-      tailwindcssMajorVersion: majorVersion
-    };
-  }
-  function resolveTransformJsOptions(options2) {
-    if (!options2) {
-      return getDefaultJsHandlerOptions();
-    }
-    let hasHandlerOption = false;
-    let runtimeSetProvided = false;
-    for (const key in options2) {
-      if (key === "runtimeSet") {
-        runtimeSetProvided = true;
-        continue;
-      }
-      hasHandlerOption = true;
-      break;
-    }
-    if (!hasHandlerOption) {
-      return getDefaultJsHandlerOptions();
-    }
-    if (!runtimeSetProvided && typeof options2.tailwindcssMajorVersion === "number") {
-      return options2;
-    }
-    if (runtimeSetProvided) {
-      const { runtimeSet: _runtimeSet, ...handlerOptions } = options2;
-      return withRuntimeTailwindMajorVersion(handlerOptions);
-    }
-    return withRuntimeTailwindMajorVersion(options2);
-  }
-  const runtimeAwareTemplateJsHandler = (source, runtime, handlerOptions) => {
-    return jsHandler(source, runtime, withRuntimeTailwindMajorVersion(handlerOptions));
-  };
-  let cachedDefaultTemplateHandlerOptions;
-  let cachedDefaultTemplateRuntimeSet;
-  let cachedRuntimeOnlyTemplateHandlerOptions;
-  let cachedRuntimeOnlyTemplateRuntimeSet;
-  function getDefaultTemplateHandlerOptions() {
-    if (cachedDefaultTemplateRuntimeSet !== runtimeSet || !cachedDefaultTemplateHandlerOptions) {
-      cachedDefaultTemplateRuntimeSet = runtimeSet;
-      cachedDefaultTemplateHandlerOptions = {
-        runtimeSet,
-        jsHandler: runtimeAwareTemplateJsHandler
-      };
-    }
-    return cachedDefaultTemplateHandlerOptions;
-  }
-  function resolveTransformWxmlOptions(options2) {
-    if (!options2) {
-      return getDefaultTemplateHandlerOptions();
-    }
-    let hasOverride = false;
-    for (const key in options2) {
-      if (key !== "runtimeSet") {
-        hasOverride = true;
-        break;
-      }
-    }
-    if (!hasOverride) {
-      const runtimeOverride = options2.runtimeSet;
-      if (runtimeOverride === void 0 || runtimeOverride === runtimeSet) {
-        return getDefaultTemplateHandlerOptions();
-      }
-      if (cachedRuntimeOnlyTemplateRuntimeSet !== runtimeOverride || !cachedRuntimeOnlyTemplateHandlerOptions) {
-        cachedRuntimeOnlyTemplateRuntimeSet = runtimeOverride;
-        cachedRuntimeOnlyTemplateHandlerOptions = {
-          runtimeSet: runtimeOverride,
-          jsHandler: runtimeAwareTemplateJsHandler
-        };
-      }
-      return cachedRuntimeOnlyTemplateHandlerOptions;
-    }
-    return _shared.defuOverrideArray.call(void 0, options2, {
-      runtimeSet,
-      jsHandler: runtimeAwareTemplateJsHandler
-    });
-  }
-  async function transformWxss(rawCss, options2) {
-    await runtimeState.patchPromise;
-    const result = await styleHandler(rawCss, resolveTransformWxssOptions(options2));
-    runtimeSet = await _chunkHVNGIKLSjs.ensureRuntimeClassSet.call(void 0, runtimeState, {
-      forceRefresh: true,
-      forceCollect: true
-    });
-    return result;
-  }
-  async function transformJs(rawJs, options2) {
-    await runtimeState.patchPromise;
-    if (_optionalChain([options2, 'optionalAccess', _ => _.runtimeSet])) {
-      runtimeSet = options2.runtimeSet;
-    } else if (runtimeSet.size === 0) {
-      runtimeSet = await _chunkHVNGIKLSjs.ensureRuntimeClassSet.call(void 0, runtimeState, {
-        forceCollect: true
-      });
-    }
-    const resolvedOptions = resolveTransformJsOptions(options2);
-    if (_chunkHVNGIKLSjs.shouldSkipJsTransform.call(void 0, rawJs, resolvedOptions)) {
-      return { code: rawJs };
-    }
-    return await jsHandler(rawJs, runtimeSet, resolvedOptions);
-  }
-  async function transformWxml(rawWxml, options2) {
-    await runtimeState.patchPromise;
-    if (!_optionalChain([options2, 'optionalAccess', _2 => _2.runtimeSet]) && runtimeSet.size === 0) {
-      runtimeSet = await _chunkHVNGIKLSjs.ensureRuntimeClassSet.call(void 0, runtimeState, {
-        forceCollect: true
-      });
-    }
-    return templateHandler(rawWxml, resolveTransformWxmlOptions(options2));
-  }
-  return {
-    transformWxss,
-    transformWxml,
-    transformJs
-  };
+	const { templateHandler, styleHandler, jsHandler, twPatcher: initialTwPatcher, refreshTailwindcssPatcher } = require_precheck.getCompilerContext(options);
+	const readyPromise = require_precheck.createTailwindRuntimeReadyPromise(initialTwPatcher);
+	let runtimeSet = /* @__PURE__ */ new Set();
+	const runtimeState = {
+		twPatcher: initialTwPatcher,
+		readyPromise,
+		refreshTailwindcssPatcher
+	};
+	const defaultJsHandlerOptionsCache = /* @__PURE__ */ new Map();
+	function getDefaultJsHandlerOptions(majorVersion = runtimeState.twPatcher.majorVersion) {
+		if (typeof majorVersion !== "number") return;
+		let cached = defaultJsHandlerOptionsCache.get(majorVersion);
+		if (!cached) {
+			cached = { tailwindcssMajorVersion: majorVersion };
+			defaultJsHandlerOptionsCache.set(majorVersion, cached);
+		}
+		return cached;
+	}
+	function withRuntimeTailwindMajorVersion(options) {
+		if (!options) return getDefaultJsHandlerOptions();
+		if (typeof options.tailwindcssMajorVersion === "number") return options;
+		const majorVersion = runtimeState.twPatcher.majorVersion;
+		if (typeof majorVersion !== "number") return options;
+		return {
+			...options,
+			tailwindcssMajorVersion: majorVersion
+		};
+	}
+	function resolveTransformJsOptions(options) {
+		if (!options) return getDefaultJsHandlerOptions();
+		let hasHandlerOption = false;
+		let runtimeSetProvided = false;
+		for (const key in options) {
+			if (key === "runtimeSet") {
+				runtimeSetProvided = true;
+				continue;
+			}
+			hasHandlerOption = true;
+			break;
+		}
+		if (!hasHandlerOption) return getDefaultJsHandlerOptions();
+		if (!runtimeSetProvided && typeof options.tailwindcssMajorVersion === "number") return options;
+		if (runtimeSetProvided) {
+			const { runtimeSet: _runtimeSet, ...handlerOptions } = options;
+			return withRuntimeTailwindMajorVersion(handlerOptions);
+		}
+		return withRuntimeTailwindMajorVersion(options);
+	}
+	const runtimeAwareTemplateJsHandler = (source, runtime, handlerOptions) => {
+		return jsHandler(source, runtime, withRuntimeTailwindMajorVersion(handlerOptions));
+	};
+	let cachedDefaultTemplateHandlerOptions;
+	let cachedDefaultTemplateRuntimeSet;
+	let cachedRuntimeOnlyTemplateHandlerOptions;
+	let cachedRuntimeOnlyTemplateRuntimeSet;
+	function getDefaultTemplateHandlerOptions() {
+		if (cachedDefaultTemplateRuntimeSet !== runtimeSet || !cachedDefaultTemplateHandlerOptions) {
+			cachedDefaultTemplateRuntimeSet = runtimeSet;
+			cachedDefaultTemplateHandlerOptions = {
+				runtimeSet,
+				jsHandler: runtimeAwareTemplateJsHandler
+			};
+		}
+		return cachedDefaultTemplateHandlerOptions;
+	}
+	function resolveTransformWxmlOptions(options) {
+		if (!options) return getDefaultTemplateHandlerOptions();
+		let hasOverride = false;
+		for (const key in options) if (key !== "runtimeSet") {
+			hasOverride = true;
+			break;
+		}
+		if (!hasOverride) {
+			const runtimeOverride = options.runtimeSet;
+			if (runtimeOverride === void 0 || runtimeOverride === runtimeSet) return getDefaultTemplateHandlerOptions();
+			if (cachedRuntimeOnlyTemplateRuntimeSet !== runtimeOverride || !cachedRuntimeOnlyTemplateHandlerOptions) {
+				cachedRuntimeOnlyTemplateRuntimeSet = runtimeOverride;
+				cachedRuntimeOnlyTemplateHandlerOptions = {
+					runtimeSet: runtimeOverride,
+					jsHandler: runtimeAwareTemplateJsHandler
+				};
+			}
+			return cachedRuntimeOnlyTemplateHandlerOptions;
+		}
+		return (0, _weapp_tailwindcss_shared.defuOverrideArray)(options, {
+			runtimeSet,
+			jsHandler: runtimeAwareTemplateJsHandler
+		});
+	}
+	async function transformWxss(rawCss, options) {
+		await runtimeState.readyPromise;
+		const result = await styleHandler(rawCss, resolveTransformWxssOptions(options));
+		runtimeSet = await require_precheck.ensureRuntimeClassSet(runtimeState, {
+			forceRefresh: true,
+			forceCollect: true
+		});
+		return result;
+	}
+	async function transformJs(rawJs, options) {
+		await runtimeState.readyPromise;
+		if (options?.runtimeSet) runtimeSet = options.runtimeSet;
+		else if (runtimeSet.size === 0) runtimeSet = await require_precheck.ensureRuntimeClassSet(runtimeState, { forceCollect: true });
+		const resolvedOptions = resolveTransformJsOptions(options);
+		if (require_precheck.shouldSkipJsTransform(rawJs, resolvedOptions)) return { code: rawJs };
+		return await jsHandler(rawJs, runtimeSet, resolvedOptions);
+	}
+	async function transformWxml(rawWxml, options) {
+		await runtimeState.readyPromise;
+		if (!options?.runtimeSet && runtimeSet.size === 0) runtimeSet = await require_precheck.ensureRuntimeClassSet(runtimeState, { forceCollect: true });
+		return templateHandler(rawWxml, resolveTransformWxmlOptions(options));
+	}
+	return {
+		transformWxss,
+		transformWxml,
+		transformJs
+	};
 }
-
-
+//#endregion
 exports.createContext = createContext;