@octane-xplat/workshop 0.15.0 → 0.16.0

package/dist/build/discover.js

@@ -0,0 +1,404 @@
+import { readFileSync } from "node:fs";
+import { globSync } from "tinyglobby";
+//#region src/build/discover.ts
+/**
+* Node-side story discovery — static, metadata-only.
+*
+* Story modules are never evaluated: this scanner reads `defineStory` option
+* literals out of the source text. `id`, `title`, and `targets` must be
+* literal values; anything computed fails with an actionable diagnostic.
+*/
+var ALL_TARGETS = [
+	"web",
+	"ios",
+	"android",
+	"macos",
+	"windows",
+	"linux"
+];
+var DEFAULT_INCLUDE = ["**/*.stories.{ts,tsx,tsrx,mts,mjs,js,jsx}", "**/*.stories.{web,mobile,ios,android,macos,windows,linux}.{ts,tsx,tsrx,mts,mjs,js,jsx}"];
+var DEFAULT_EXCLUDE = [
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/types/**"
+];
+var SUFFIX_TARGETS = {
+	web: ["web"],
+	mobile: ["ios", "android"],
+	ios: ["ios"],
+	android: ["android"],
+	macos: ["macos"],
+	windows: ["windows"],
+	linux: ["linux"]
+};
+var SUFFIX_RE = /\.stories\.(web|mobile|ios|android|macos|windows|linux)\.[cm]?[jt]srx?$/;
+function storyFileTag(file) {
+	return SUFFIX_RE.exec(file)?.[1] ?? null;
+}
+function applicableTargets(declared, file) {
+	const tag = storyFileTag(file);
+	if (!tag) return declared;
+	const implied = SUFFIX_TARGETS[tag] ?? [];
+	return declared.filter((t) => implied.includes(t));
+}
+function normalizeInclude(include) {
+	if (include === void 0) return DEFAULT_INCLUDE;
+	return Array.isArray(include) ? [...include] : [include];
+}
+function normalizeExclude(exclude) {
+	const extra = exclude === void 0 ? [] : Array.isArray(exclude) ? [...exclude] : [exclude];
+	return [...DEFAULT_EXCLUDE, ...extra];
+}
+/** Strip strings, template literals, and comments while preserving length. */
+function maskSource(source) {
+	const out = source.split("");
+	let i = 0;
+	const n = source.length;
+	const blank = (from, to) => {
+		for (let k = from; k < to; k++) out[k] = out[k] === "\n" ? "\n" : " ";
+	};
+	while (i < n) {
+		const ch = source[i];
+		if (ch === "/" && source[i + 1] === "/") {
+			let j = i;
+			while (j < n && source[j] !== "\n") j++;
+			blank(i, j);
+			i = j;
+		} else if (ch === "/" && source[i + 1] === "*") {
+			let j = source.indexOf("*/", i + 2);
+			j = j === -1 ? n : j + 2;
+			blank(i, j);
+			i = j;
+		} else if (ch === "'" || ch === "\"") {
+			let j = i + 1;
+			while (j < n) if (source[j] === "\\") j += 2;
+			else if (source[j] === ch) {
+				j++;
+				break;
+			} else j++;
+			j = Math.min(j, n);
+			blank(i + 1, Math.max(i + 1, j - 1));
+			i = j;
+		} else if (ch === "`") {
+			let j = i + 1;
+			while (j < n) if (source[j] === "\\") {
+				blank(j, j + 2);
+				j += 2;
+			} else if (source[j] === "`") {
+				j++;
+				break;
+			} else if (source[j] === "$" && source[j + 1] === "{") {
+				let depth = 1;
+				let k = j + 2;
+				while (k < n && depth > 0) {
+					if (source[k] === "{") depth++;
+					else if (source[k] === "}") depth--;
+					else if (source[k] === "'" || source[k] === "\"") {
+						let q = k + 1;
+						while (q < n && source[q] !== source[k]) q += source[q] === "\\" ? 2 : 1;
+						k = Math.min(q + 1, n);
+						continue;
+					}
+					k++;
+				}
+				j = k;
+			} else {
+				blank(j, j + 1);
+				j++;
+			}
+			i = j;
+		} else i++;
+	}
+	return out.join("");
+}
+/** Find matching close for an opening bracket at index `open` in masked text. */
+function matchBracket(masked, open, openCh, closeCh) {
+	let depth = 0;
+	for (let i = open; i < masked.length; i++) {
+		const ch = masked[i];
+		if (ch === openCh) depth++;
+		else if (ch === closeCh) {
+			depth--;
+			if (depth === 0) return i;
+		}
+	}
+	return -1;
+}
+/** Split a masked object-literal body into top-level key → raw value text. */
+function objectFields(masked, source, openBrace, closeBrace) {
+	const fields = /* @__PURE__ */ new Map();
+	let i = openBrace + 1;
+	while (i < closeBrace) {
+		while (i < closeBrace && /[\s,]/.test(masked[i])) i++;
+		if (i >= closeBrace) break;
+		const m = /^([A-Za-z_$][\w$]*|'[\s\S]*'|"[\s\S]*"|\d+)\s*:/.exec(masked.slice(i, closeBrace));
+		if (!m) return {
+			fields,
+			error: `unsupported object syntax near "${masked.slice(i, i + 24).trim()}"`
+		};
+		const rawKey = m[1];
+		const key = rawKey.startsWith("'") || rawKey.startsWith("\"") ? source.slice(i, i + m[0].indexOf(":")).trim().slice(1, -1) : rawKey;
+		let v = i + m[0].length;
+		const start = v;
+		let depth = 0;
+		while (v < closeBrace) {
+			const ch = masked[v];
+			if (ch === "{" || ch === "[" || ch === "(") depth++;
+			else if (ch === "}" || ch === "]" || ch === ")") {
+				if (depth === 0) break;
+				depth--;
+			} else if (ch === "," && depth === 0) break;
+			v++;
+		}
+		fields.set(key, {
+			start,
+			end: v
+		});
+		i = v + 1;
+	}
+	return { fields };
+}
+/** Evaluate a literal-only expression slice; throws on non-literal content. */
+function literalValue(masked, source, start, end, label, file) {
+	const text = masked.slice(start, end).trim();
+	const fail = () => {
+		throw new Error(`${file}: story metadata "${label}" must be a literal value — got "${source.slice(start, end).trim().slice(0, 60)}"`);
+	};
+	if (text === "") fail();
+	if (text === "true") return true;
+	if (text === "false") return false;
+	if (text === "null") return null;
+	if (/^-?\d+(\.\d+)?$/.test(text)) return Number(text);
+	if (/^'[^']*'$/.test(text) || /^"[^"]*"$/.test(text)) {
+		const value = source.slice(start, end).trim().slice(1, -1);
+		if (value.includes("\\")) fail();
+		return value;
+	}
+	if (text.startsWith("`") || text === "") fail();
+	if (text.startsWith("[")) {
+		const openIdx = masked.indexOf("[", start);
+		const close = matchBracket(masked, openIdx, "[", "]");
+		if (close < 0 || masked.slice(close + 1, end).trim()) fail();
+		const items = [];
+		let seg = openIdx + 1;
+		let depth = 0;
+		const push = (end2) => {
+			if (masked.slice(seg, end2).trim()) items.push(literalValue(masked, source, seg, end2, label, file));
+		};
+		for (let i = openIdx + 1; i < close; i++) {
+			const ch = masked[i];
+			if (ch === "{" || ch === "[" || ch === "(") depth++;
+			else if (ch === "}" || ch === "]" || ch === ")") depth--;
+			else if (ch === "," && depth === 0) {
+				push(i);
+				seg = i + 1;
+			}
+		}
+		push(close);
+		return items;
+	}
+	fail();
+}
+var DECL_RE = /(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*$/;
+/**
+* Extract story metadata declarations from source text. Returns
+* { stories: [...], diagnostics: [...] } — never throws on malformed input.
+*/
+function scanStoryFile(source, file) {
+	const masked = maskSource(source);
+	const stories = [];
+	const diagnostics = [];
+	const exported = /* @__PURE__ */ new Set();
+	for (const m of masked.matchAll(/export\s*\{([^}]*)\}/g)) for (const part of m[1].split(",")) {
+		const name = part.trim().split(/\s+as\s+/).pop()?.trim();
+		if (name) exported.add(name);
+	}
+	let search = 0;
+	for (;;) {
+		const at = masked.indexOf("defineStory", search);
+		if (at === -1) break;
+		search = at + 11;
+		const before = masked.slice(0, at);
+		const after = masked.slice(at + 11);
+		if (/[\w$.]$/.test(before) || /^[\w$]/.test(after)) continue;
+		let exportName = "default";
+		const stmtStart = Math.max(before.lastIndexOf(";"), before.lastIndexOf("}"), before.lastIndexOf("{"));
+		const stmt = before.slice(stmtStart + 1);
+		const decl = DECL_RE.exec(stmt);
+		let exportedStory = false;
+		if (decl && decl.index + decl[0].length === stmt.length) {
+			exportName = decl[1];
+			exportedStory = /export\s+(const|let|var)\s/.test(stmt) || exported.has(exportName);
+		} else if (/export\s+default\s*$/.test(stmt)) exportedStory = true;
+		let i = at + 11;
+		while (i < masked.length && /\s/.test(masked[i])) i++;
+		if (masked[i] === "<") {
+			const closeAngle = matchBracket(masked, i, "<", ">");
+			if (closeAngle !== -1) {
+				i = closeAngle + 1;
+				while (i < masked.length && /\s/.test(masked[i])) i++;
+			}
+		}
+		if (masked[i] !== "(") continue;
+		const closeParen = matchBracket(masked, i, "(", ")");
+		if (closeParen === -1) {
+			diagnostics.push({
+				file,
+				exportName,
+				message: "defineStory call has unbalanced parentheses"
+			});
+			continue;
+		}
+		let j = i + 1;
+		while (j < closeParen && /\s/.test(masked[j])) j++;
+		if (masked[j] !== "{") {
+			diagnostics.push({
+				file,
+				exportName,
+				message: "defineStory options must be an object literal"
+			});
+			continue;
+		}
+		const closeBrace = matchBracket(masked, j, "{", "}");
+		const { fields, error } = objectFields(masked, source, j, closeBrace);
+		if (error) {
+			diagnostics.push({
+				file,
+				exportName,
+				message: error
+			});
+			continue;
+		}
+		const story = {
+			file,
+			exportName,
+			exported: exportedStory
+		};
+		let failed = false;
+		for (const key of [
+			"id",
+			"title",
+			"targets",
+			"capabilities"
+		]) {
+			const field = fields.get(key);
+			if (!field) {
+				if (key === "capabilities") continue;
+				diagnostics.push({
+					file,
+					exportName,
+					message: `defineStory requires a literal "${key}"`
+				});
+				failed = true;
+				continue;
+			}
+			try {
+				story[key] = literalValue(masked, source, field.start, field.end, key, file);
+			} catch (e) {
+				diagnostics.push({
+					file,
+					exportName,
+					message: e.message
+				});
+				failed = true;
+			}
+		}
+		if (!failed && (typeof story.id !== "string" || !story.id || typeof story.title !== "string" || !story.title || !(story.targets === "all" || Array.isArray(story.targets) && story.targets.length > 0 && story.targets.every((t) => ALL_TARGETS.includes(t))) || !(story.capabilities === void 0 || Array.isArray(story.capabilities) && story.capabilities.every((c) => typeof c === "string" && c.length > 0)))) {
+			diagnostics.push({
+				file,
+				exportName,
+				message: "story requires non-empty literal id/title, targets: all or a non-empty target array, and a string capability array"
+			});
+			failed = true;
+		}
+		if (!failed) stories.push(story);
+	}
+	return {
+		stories,
+		diagnostics
+	};
+}
+/**
+* Discover story metadata under `root`.
+*   → { entries, diagnostics }
+* entries: StoryMeta[] (applicable/reason computed for `target`)
+*/
+function discoverStories(root, { include, exclude, target = "web" } = {}) {
+	const files = globSync(normalizeInclude(include), {
+		cwd: root,
+		ignore: normalizeExclude(exclude),
+		absolute: true
+	});
+	const entries = [];
+	const diagnostics = [];
+	const byId = /* @__PURE__ */ new Map();
+	for (const file of files) {
+		let source;
+		try {
+			source = readFileSync(file, "utf8");
+		} catch (e) {
+			diagnostics.push({
+				file,
+				message: `could not read story file: ${e.message}`
+			});
+			continue;
+		}
+		const { stories, diagnostics: fileDiagnostics } = scanStoryFile(source, file);
+		diagnostics.push(...fileDiagnostics);
+		for (const story of stories) {
+			if (!story.exported) {
+				diagnostics.push({
+					file,
+					exportName: story.exportName,
+					message: `defineStory("${story.id}") must be exported to be discovered`
+				});
+				continue;
+			}
+			const declared = story.targets === "all" ? ALL_TARGETS : Array.isArray(story.targets) ? story.targets : [story.targets];
+			for (const t of declared) if (!ALL_TARGETS.includes(t)) diagnostics.push({
+				file,
+				exportName: story.exportName,
+				message: `story "${story.id}" declares unknown target "${t}"`
+			});
+			const applicable = applicableTargets(declared.filter((t) => ALL_TARGETS.includes(t)), file);
+			const required = story.capabilities ?? [];
+			const canRun = applicable.includes(target) && required.length === 0;
+			const reason = canRun ? void 0 : applicable.includes(target) && required.length > 0 ? `required capabilities are unknown/unqualified on ${target}: ${required.join(", ")}` : applicable.length === 0 ? `declared targets and the ${storyFileTag(file) ?? "story"} leaf do not overlap` : `story targets ${applicable.join(", ")}, not ${target}`;
+			const meta = {
+				id: story.id,
+				title: story.title,
+				targets: applicable,
+				capabilities: story.capabilities ?? [],
+				file,
+				exportName: story.exportName,
+				applicable: canRun,
+				reason
+			};
+			const prior = byId.get(story.id) ?? [];
+			const conflict = prior.find((prev) => prev.targets.some((t) => meta.targets.includes(t)));
+			if (conflict) {
+				diagnostics.push({
+					file,
+					exportName: story.exportName,
+					message: `duplicate story id "${story.id}" — also declared in ${conflict.file} (export "${conflict.exportName}")`
+				});
+				continue;
+			}
+			byId.set(story.id, [...prior, meta]);
+			entries.push(meta);
+		}
+	}
+	entries.sort((a, b) => a.title.localeCompare(b.title) || a.id.localeCompare(b.id));
+	const byRow = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const list = byRow.get(entry.id) ?? [];
+		list.push(entry);
+		byRow.set(entry.id, list);
+	}
+	return {
+		entries: [...byRow.values()].map((group) => group.find((e) => e.applicable) ?? group[0]),
+		diagnostics
+	};
+}
+//#endregion
+export { ALL_TARGETS, applicableTargets, discoverStories, maskSource, normalizeExclude, normalizeInclude, scanStoryFile, storyFileTag };

package/dist/build/macos-node.js

@@ -0,0 +1,77 @@
+import { createRequire } from "node:module";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { dirname, join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/build/macos-node.ts
+/** Generate a separate consumer-owned cache profile; leave app entries untouched. */
+async function workshopMacOSDev({ root, config, story }) {
+	if (process.platform !== "darwin" || process.arch !== "arm64") throw new Error("The AppKit workshop requires a macOS arm64 execution host");
+	const require = createRequire(join(root, "package.json"));
+	for (const name of [
+		"@octane-xplat/macos-renderer",
+		"@nativescript/macos-node-api",
+		"octane",
+		"@octanejs/vite-plugin",
+		"vite"
+	]) try {
+		require.resolve(name);
+	} catch {
+		throw new Error(`AppKit workshop prerequisite missing: ${name}; use the matching versions from your app's macOS setup`);
+	}
+	const cache = join(root, "node_modules/.cache/xplat/workshop-macos");
+	await mkdir(cache, { recursive: true });
+	const directory = await mkdtemp(join(cache, "session-"));
+	const source = dirname(fileURLToPath(import.meta.url)).replace("/dist/", "/src/");
+	const catalogPlugin = join(source, "macos-vite.ts");
+	const shell = join(source, "macos/shell.macos.ts");
+	const bundle = join(directory, "stories.cjs");
+	const shellBundle = join(directory, "shell.cjs");
+	const catalogFile = join(directory, "catalog.gen.ts");
+	const common = `import { xplatMacOS } from '@octane-xplat/cli/macos/vite'
+import { macOSCatalogPlugin } from ${JSON.stringify(catalogPlugin)}
+const root = ${JSON.stringify(root)}
+`;
+	await writeFile(join(directory, "stories.config.ts"), common + `
+export default async ({ mode }) => {
+ const settings = await xplatMacOS(mode, { root, packaged: false, hmr: false })
+ return { ...settings, plugins: [macOSCatalogPlugin({ root, config: ${JSON.stringify(config)}, catalogFile: ${JSON.stringify(catalogFile)} }), ...settings.plugins],
+  build: { ...settings.build, outDir: ${JSON.stringify(directory)}, emptyOutDir: false,
+   lib: { entry: ${JSON.stringify(catalogFile)}, formats: ['cjs'], fileName: () => 'stories.cjs' } } }
+}
+`);
+	await writeFile(join(directory, "entry.ts"), `import { startMacOSWorkshop } from ${JSON.stringify(shell)}
+startMacOSWorkshop({ bundleFile: ${JSON.stringify(bundle)}, initialStoryId: ${JSON.stringify(story ?? null)},
+ offscreen: process.env.OCTANE_WORKSHOP_OFFSCREEN === '1' })
+`);
+	await writeFile(join(directory, "shell.config.ts"), common + `
+export default async ({ mode }) => {
+ const settings = await xplatMacOS(mode, { root, packaged: true, entry: ${JSON.stringify(join(directory, "entry.ts"))} })
+ return { ...settings, build: { ...settings.build, outDir: ${JSON.stringify(directory)}, emptyOutDir: false,
+  lib: { entry: ${JSON.stringify(join(directory, "entry.ts"))}, formats: ['cjs'], fileName: () => 'shell.cjs' } } }
+}
+`);
+	try {
+		const { runMacOSDev } = await import("@octane-xplat/cli/macos");
+		return await runMacOSDev(root, {
+			workshop: true,
+			target: {
+				runtime: "appkit-node-api",
+				renderer: "appkit",
+				dev: {
+					productName: "Octane component workshop",
+					viteConfig: relative(root, join(directory, "stories.config.ts")),
+					bundleFile: relative(root, bundle),
+					shellViteConfig: relative(root, join(directory, "shell.config.ts")),
+					shellBundleFile: relative(root, shellBundle)
+				}
+			}
+		});
+	} finally {
+		await rm(directory, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+//#endregion
+export { workshopMacOSDev };

package/dist/build/mobile-node.js

@@ -0,0 +1,96 @@
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join, resolve } from "node:path";
+import { spawn } from "node:child_process";
+//#region src/build/mobile-node.ts
+var CONFIGS = [
+	"vite.config.native.mts",
+	"vite.config.native.ts",
+	"vite.config.mts",
+	"vite.config.ts",
+	"vite.config.ts"
+];
+function mobilePrerequisites(root, target, host = process.platform, env = process.env) {
+	const req = createRequire(join(root, "package.json"));
+	const installed = (name) => {
+		try {
+			req.resolve(name);
+			return true;
+		} catch {
+			return false;
+		}
+	};
+	const configFile = CONFIGS.map((name) => join(root, name)).find(existsSync);
+	const requirements = {
+		"nativescript.config.ts": existsSync(join(root, "nativescript.config.ts")),
+		"native workshop Vite setup": Boolean(configFile && /withWorkshopMobile/.test(readFileSync(configFile, "utf8"))),
+		"@nativescript/core": installed("@nativescript/core"),
+		"@nativescript-community/octane": installed("@nativescript-community/octane"),
+		"@nativescript-community/vite-octane": installed("@nativescript-community/vite-octane"),
+		"@valor/nativescript-websockets": installed("@valor/nativescript-websockets"),
+		"nativescript CLI": installed("nativescript")
+	};
+	if (target === "ios") requirements["macOS / Xcode host"] = host === "darwin" && existsSync("/Applications/Xcode.app");
+	else {
+		requirements["Android SDK directory"] = Boolean((env.ANDROID_HOME || env.ANDROID_SDK_ROOT) && existsSync(env.ANDROID_HOME || env.ANDROID_SDK_ROOT));
+		requirements["JAVA_HOME directory"] = Boolean(env.JAVA_HOME && existsSync(env.JAVA_HOME));
+	}
+	return {
+		backend: "nativescript (Octane universal renderer)",
+		requirements,
+		status: target === "ios" && host !== "darwin" ? "remote-host-required" : Object.values(requirements).every(Boolean) ? "unqualified-backend" : "missing-prerequisites",
+		note: "Mobile adapter installed; actual-host lifecycle, touch, keyboard, screen-reader and IME qualification remain open. Doctor does not launch or select a device."
+	};
+}
+function mobileLaunchSpec({ root, target, device, config, story }) {
+	if (!["ios", "android"].includes(target)) throw new Error("Expected ios or android");
+	if (!device || typeof device !== "string" || device.startsWith("-")) throw new Error("Mobile workshop requires --device <device-id>; it never chooses or boots a device implicitly");
+	const packageFile = createRequire(join(root, "package.json")).resolve("nativescript/package.json");
+	const manifest = JSON.parse(readFileSync(packageFile, "utf8"));
+	const binary = typeof manifest.bin === "string" ? manifest.bin : manifest.bin.ns ?? manifest.bin.nativescript;
+	if (!binary) throw new Error("Installed NativeScript CLI has no ns binary");
+	return {
+		command: process.execPath,
+		args: [
+			resolve(dirname(packageFile), binary),
+			"run",
+			target,
+			"--device",
+			device
+		],
+		options: {
+			cwd: root,
+			stdio: "inherit",
+			shell: false,
+			env: {
+				...process.env,
+				XPLAT_WORKSHOP_TARGET: target,
+				XPLAT_WORKSHOP_CONFIG: JSON.stringify(config),
+				XPLAT_WORKSHOP_STORY: story ?? ""
+			}
+		}
+	};
+}
+async function launchMobile(options) {
+	const spec = mobileLaunchSpec(options);
+	const child = spawn(spec.command, spec.args, spec.options);
+	const interrupt = () => child.kill("SIGINT");
+	const terminate = () => child.kill("SIGTERM");
+	process.on("SIGINT", interrupt);
+	process.on("SIGTERM", terminate);
+	try {
+		await new Promise((resolve, reject) => {
+			child.once("error", reject);
+			child.once("exit", (code, signal) => code === 0 ? resolve() : reject(/* @__PURE__ */ new Error(`NativeScript workshop ${options.target} exited ${signal ?? code}; check launch logs and restart the target`)));
+		});
+	} finally {
+		process.off("SIGINT", interrupt);
+		process.off("SIGTERM", terminate);
+	}
+	return {
+		target: options.target,
+		exited: true
+	};
+}
+//#endregion
+export { launchMobile, mobileLaunchSpec, mobilePrerequisites };

package/dist/build/mobile-regex.js

@@ -0,0 +1,40 @@
+import { transformAsync, types } from "@babel/core";
+import unicodeProperties from "@babel/plugin-transform-unicode-property-regex";
+//#region src/build/mobile-regex.ts
+/** Compile Unicode properties for the pinned iOS runtime without changing globals. */
+function transformMobileRegex(code, filename = "workshop-host.ts") {
+	return transformAsync(code, {
+		filename,
+		configFile: false,
+		babelrc: false,
+		sourceMaps: true,
+		plugins: [() => ({ visitor: { NewExpression(path) {
+			const node = path.node;
+			if (!types.isIdentifier(node.callee, { name: "RegExp" }) || path.scope.getBinding("RegExp") || node.arguments.length !== 2) return;
+			const [pattern, flags] = node.arguments;
+			if (types.isStringLiteral(pattern) && types.isStringLiteral(flags) && flags.value.includes("u") && /\\[pP]\{/.test(pattern.value)) path.replaceWith(types.regExpLiteral(pattern.value, flags.value));
+		} } }), unicodeProperties.default ?? unicodeProperties]
+	});
+}
+function mobileRegexPlugin() {
+	return {
+		name: "xplat-workshop-mobile-unicode-regex",
+		async transform(code, id) {
+			if (!/\\[pP]\{/.test(code) || !/\.[cm]?js(?:\?|$)/.test(id)) return null;
+			const result = await transformMobileRegex(code, id.split("?")[0]);
+			return result ? {
+				code: result.code,
+				map: result.map
+			} : null;
+		},
+		async renderChunk(code, chunk) {
+			const result = await transformMobileRegex(code, chunk.fileName);
+			return result ? {
+				code: result.code,
+				map: result.map
+			} : null;
+		}
+	};
+}
+//#endregion
+export { mobileRegexPlugin, transformMobileRegex };