rollipop 1.0.0-alpha.21 → 1.0.0-alpha.23

package/dist/core/plugins/babel-plugin.d.ts

@@ -0,0 +1,22 @@
+import { BundlerContext } from "../types.js";
+import { TransformerConfig } from "../../config/types.js";
+import * as rolldown from "@rollipop/rolldown";
+
+//#region src/core/plugins/babel-plugin.d.ts
+interface BabelPluginOptions {
+  context: BundlerContext;
+  /**
+   * When `false`, the legacy JS preset (TS strip / Flow strip / RN
+   * codegen) is applied. When `true`, the preset is skipped and only
+   * user-provided rules run — the rust-side pipeline handles the rest.
+   */
+  useNativeTransformPipeline: boolean;
+  transformConfig?: TransformerConfig['babel'];
+}
+declare function babelPlugin({
+  context,
+  useNativeTransformPipeline,
+  transformConfig
+}: BabelPluginOptions): rolldown.Plugin[];
+//#endregion
+export { BabelPluginOptions, babelPlugin };

package/dist/core/plugins/babel-plugin.js

@@ -0,0 +1,74 @@
+import { __require } from "../../_virtual/_rolldown/runtime.js";
+import { getFlag } from "./utils/transform-utils.js";
+import { mergeBabelOptions } from "../../utils/babel.js";
+import { isJSX, isTS } from "./utils/source.js";
+import { invariant } from "es-toolkit";
+import * as babel from "@babel/core";
+//#region src/core/plugins/babel-plugin.ts
+function babelPlugin({ context, useNativeTransformPipeline, transformConfig }) {
+	const { rules = [] } = transformConfig ?? {};
+	const babelOptionsById = /* @__PURE__ */ new Map();
+	const babelRules = rules.map(({ filter, options }, index) => {
+		return {
+			name: `rollipop:babel-rule-${index}`,
+			transform: {
+				filter,
+				handler(code, id) {
+					const existingBabelOptions = babelOptionsById.get(id);
+					const resolvedOptions = typeof options === "function" ? options(code, id) : options;
+					existingBabelOptions ? existingBabelOptions.push(resolvedOptions) : babelOptionsById.set(id, [resolvedOptions]);
+				}
+			}
+		};
+	});
+	const babelPlugin = {
+		name: "rollipop:babel",
+		buildStart() {
+			babelOptionsById.clear();
+		},
+		transform: { handler(code, id) {
+			const flags = getFlag.call(this, context, id);
+			if (flags & 128) return;
+			const babelOptions = babelOptionsById.get(id) ?? [];
+			if (!(useNativeTransformPipeline ? babelOptions.length > 0 : flags & 1 || babelOptions.length > 0)) return;
+			const baseOptions = useNativeTransformPipeline ? [] : [getPreset(flags, id)];
+			const result = babel.transformSync(code, {
+				filename: id,
+				babelrc: false,
+				configFile: false,
+				sourceMaps: true,
+				...mergeBabelOptions([...baseOptions, ...babelOptions])
+			});
+			invariant(result?.code, `Failed to transform with babel: ${id}`);
+			return {
+				code: result.code,
+				map: result.map
+			};
+		} }
+	};
+	return [...babelRules, babelPlugin];
+}
+function getPreset(flags, id) {
+	const presets = [];
+	const plugins = [];
+	let parserOpts = null;
+	if (flags & 2) {
+		parserOpts = { flow: "all" };
+		plugins.push([__require.resolve("babel-plugin-syntax-hermes-parser"), {
+			parseLangTypes: "flow",
+			reactRuntimeTarget: "19"
+		}], __require.resolve("@babel/plugin-transform-flow-strip-types"));
+	} else if (isTS(id)) plugins.push([__require.resolve("@babel/plugin-transform-typescript"), {
+		isTSX: isJSX(id),
+		allowNamespaces: true
+	}]);
+	if (flags & 1) plugins.push([__require.resolve("@react-native/babel-plugin-codegen")]);
+	const options = {
+		presets,
+		plugins
+	};
+	if (parserOpts) options.parserOpts = parserOpts;
+	return options;
+}
+//#endregion
+export { babelPlugin };

package/dist/core/plugins/context.d.ts

@@ -0,0 +1,10 @@
+import { RollupLogWithString } from "@rollipop/rolldown";
+
+//#region src/core/plugins/context.d.ts
+interface PluginContext {
+  debug: (log: RollupLogWithString) => void;
+  info: (log: RollupLogWithString) => void;
+  warn: (log: RollupLogWithString) => void;
+}
+//#endregion
+export { PluginContext };

package/dist/core/plugins/context.js

@@ -0,0 +1,24 @@
+import { Logger } from "../../common/logger.js";
+import chalk from "chalk";
+//#region src/core/plugins/context.ts
+const pluginLogger = new Logger();
+function createPluginContext(name) {
+	return {
+		debug: (log) => {
+			printPluginLog("debug", log, name);
+		},
+		info: (log) => {
+			printPluginLog("info", log, name);
+		},
+		warn: (log) => {
+			printPluginLog("warn", log, name);
+		}
+	};
+}
+function printPluginLog(level, log, pluginName = "unknown") {
+	const pluginLabel = chalk.magenta(`plugin:${pluginName}`);
+	if (typeof log === "string") pluginLogger[level](pluginLabel, log);
+	else pluginLogger[level](pluginLabel, log.stack ?? log.message);
+}
+//#endregion
+export { createPluginContext, printPluginLog };

package/dist/core/plugins/dev-server-plugin.d.ts

@@ -0,0 +1,13 @@
+import { ResolvedConfig } from "../../config/defaults.js";
+import { ResolvedHmrConfig } from "../../utils/config.js";
+import * as rolldown from "@rollipop/rolldown";
+
+//#region src/core/plugins/dev-server-plugin.d.ts
+interface DevServerPluginOptions {
+  cwd: string;
+  hmrClientPath: ResolvedConfig['reactNative']['hmrClientPath'];
+  hmrConfig: ResolvedHmrConfig | null;
+}
+declare function devServerPlugin(options: DevServerPluginOptions): Promise<rolldown.Plugin[] | null>;
+//#endregion
+export { DevServerPluginOptions, devServerPlugin };

package/dist/core/plugins/dev-server-plugin.js

@@ -0,0 +1,27 @@
+import { resolveFrom } from "../../utils/node-resolve.js";
+import { rollipopReactRefreshWrapperPlugin } from "@rollipop/rolldown/experimental";
+import { exactRegex, id, include } from "@rollipop/rolldown/filter";
+//#region src/core/plugins/dev-server-plugin.ts
+async function devServerPlugin(options) {
+	const { cwd, hmrClientPath, hmrConfig } = options;
+	if (hmrConfig == null) return null;
+	return [{
+		name: "rollipop:replace-hmr-client",
+		load: {
+			filter: [include(id(exactRegex(resolveFrom(cwd, typeof hmrClientPath === "function" ? await hmrClientPath(cwd) : hmrClientPath))))],
+			handler(id) {
+				this.debug(`Replacing HMR client: ${id}`);
+				return {
+					code: hmrConfig.clientImplement,
+					moduleType: "ts"
+				};
+			}
+		}
+	}, rollipopReactRefreshWrapperPlugin({
+		cwd,
+		include: [/\.[tj]sx?(?:$|\?)/],
+		exclude: [/\/node_modules\//]
+	})];
+}
+//#endregion
+export { devServerPlugin };

package/dist/core/plugins/index.d.ts

@@ -0,0 +1,13 @@
+import { ReactNativePluginOptions, reactNativePlugin } from "./react-native-plugin.js";
+import { PreludePluginOptions, preludePlugin } from "./prelude-plugin.js";
+import { BabelPluginOptions, babelPlugin } from "./babel-plugin.js";
+import { SwcPluginOptions, swcPlugin } from "./swc-plugin.js";
+import { ReporterPluginOptions, reporterPlugin } from "./reporter-plugin.js";
+import { DevServerPluginOptions, devServerPlugin } from "./dev-server-plugin.js";
+
+//#region src/core/plugins/index.d.ts
+declare namespace index_d_exports {
+  export { BabelPluginOptions, DevServerPluginOptions, PreludePluginOptions, ReactNativePluginOptions, ReporterPluginOptions, SwcPluginOptions, babelPlugin as babel, devServerPlugin as devServer, preludePlugin as prelude, reactNativePlugin as reactNative, reporterPlugin as reporter, swcPlugin as swc };
+}
+//#endregion
+export { index_d_exports };

package/dist/core/plugins/index.js

@@ -0,0 +1,18 @@
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
+import { reactNativePlugin } from "./react-native-plugin.js";
+import { preludePlugin } from "./prelude-plugin.js";
+import { babelPlugin } from "./babel-plugin.js";
+import { swcPlugin } from "./swc-plugin.js";
+import { reporterPlugin } from "./reporter-plugin.js";
+import { devServerPlugin } from "./dev-server-plugin.js";
+//#region src/core/plugins/index.ts
+var plugins_exports = /* @__PURE__ */ __exportAll({
+	babel: () => babelPlugin,
+	devServer: () => devServerPlugin,
+	prelude: () => preludePlugin,
+	reactNative: () => reactNativePlugin,
+	reporter: () => reporterPlugin,
+	swc: () => swcPlugin
+});
+//#endregion
+export { plugins_exports };

package/dist/core/plugins/prelude-plugin.d.ts

@@ -0,0 +1,10 @@
+import * as rolldown from "@rollipop/rolldown";
+
+//#region src/core/plugins/prelude-plugin.d.ts
+interface PreludePluginOptions {
+  entryPath: string;
+  modulePaths: string[];
+}
+declare function preludePlugin(options: PreludePluginOptions): rolldown.Plugin | null;
+//#endregion
+export { PreludePluginOptions, preludePlugin };

package/dist/core/plugins/prelude-plugin.js

@@ -0,0 +1,23 @@
+import { invariant } from "es-toolkit";
+import { id, include } from "@rollipop/rolldown/filter";
+//#region src/core/plugins/prelude-plugin.ts
+function preludePlugin(options) {
+	const { entryPath, modulePaths } = options;
+	if (modulePaths.length === 0) return null;
+	const importStatements = modulePaths.map((modulePath) => `import '${modulePath}';`).join("\n");
+	return {
+		name: "rollipop:prelude",
+		transform: {
+			order: "pre",
+			filter: [include(id(entryPath))],
+			handler(_code, _id, meta) {
+				const { magicString } = meta;
+				invariant(magicString, "magicString not found");
+				magicString.prepend(`${importStatements}\n`);
+				return { code: magicString };
+			}
+		}
+	};
+}
+//#endregion
+export { preludePlugin };

package/dist/core/plugins/react-native-plugin.d.ts

@@ -0,0 +1,36 @@
+import { BuildType, BundlerContext } from "../types.js";
+import * as rolldown from "@rollipop/rolldown";
+import { RollipopReactNativePluginConfig } from "@rollipop/rolldown/experimental";
+import { TopLevelFilterExpression } from "@rollipop/rolldown/filter";
+
+//#region src/core/plugins/react-native-plugin.d.ts
+interface ReactNativePluginOptions {
+  context: BundlerContext;
+  projectRoot: string;
+  platform: string;
+  preferNativePlatform: boolean;
+  buildType: BuildType;
+  assetsDir?: string;
+  assetExtensions: string[];
+  assetRegistryPath: string;
+  /**
+   * Native pipeline configuration. When `null`, the legacy JS plugins
+   * (codegen marker + Flow strip) are installed instead.
+   *
+   * @internal builtin plugin config
+   */
+  builtinPluginConfig: RollipopReactNativePluginConfig | null;
+  /**
+   * Filter for the legacy Flow-strip transform pipeline. Used when the
+   * native pipeline is disabled.
+   */
+  flowFilter: rolldown.HookFilter | TopLevelFilterExpression[];
+  /**
+   * Filter for the legacy codegen marker pipeline. Used when the native
+   * pipeline is disabled.
+   */
+  codegenFilter: rolldown.HookFilter | TopLevelFilterExpression[];
+}
+declare function reactNativePlugin(options: ReactNativePluginOptions): rolldown.Plugin[];
+//#endregion
+export { ReactNativePluginOptions, reactNativePlugin };

package/dist/core/plugins/react-native-plugin.js

@@ -0,0 +1,81 @@
+import { stripFlowTypes } from "../../common/transformer.js";
+import { copyAssetsToDestination, generateAssetRegistryCode, resolveScaledAssets } from "../assets.js";
+import { getFlag, setFlag } from "./utils/transform-utils.js";
+import { rollipopReactNativePlugin } from "@rollipop/rolldown/experimental";
+import { id, include } from "@rollipop/rolldown/filter";
+//#region src/core/plugins/react-native-plugin.ts
+function reactNativePlugin(options) {
+	const { projectRoot, platform, preferNativePlatform, buildType, context, assetsDir, assetExtensions, assetRegistryPath, flowFilter, codegenFilter, builtinPluginConfig } = options;
+	const codegenPlugin = {
+		name: "rollipop:react-native-codegen-marker",
+		transform: {
+			order: "pre",
+			filter: codegenFilter,
+			handler(_code, id) {
+				return { meta: setFlag.call(this, context, id, 1) };
+			}
+		}
+	};
+	const stripFlowSyntaxPlugin = {
+		name: "rollipop:react-native-strip-flow-syntax",
+		transform: {
+			order: "pre",
+			filter: flowFilter,
+			async handler(code, id) {
+				const flags = getFlag.call(this, context, id);
+				if (flags & 128) return;
+				if (flags & 1) return { meta: setFlag.call(this, context, id, 2) };
+				const result = await stripFlowTypes(id, code);
+				return {
+					code: result.code,
+					map: result.map,
+					/**
+					* Treat the transformed code as TSX code
+					* because Flow modules can be `.js` files with type annotations and JSX syntax.
+					*/
+					moduleType: "tsx"
+				};
+			}
+		}
+	};
+	const assets = [];
+	const assetPlugin = {
+		name: "rollipop:react-native-asset",
+		load: {
+			filter: [include(id(new RegExp(`\\.(?:${assetExtensions.join("|")})$`)))],
+			async handler(id) {
+				this.debug(`Asset ${id} found`);
+				const assetData = await resolveScaledAssets({
+					projectRoot,
+					assetPath: id,
+					platform,
+					preferNativePlatform
+				});
+				assets.push(assetData);
+				return {
+					code: generateAssetRegistryCode(assetRegistryPath, assetData),
+					meta: setFlag.call(this, context, id, 128),
+					moduleType: "js"
+				};
+			}
+		},
+		buildStart() {
+			assets.length = 0;
+		},
+		async buildEnd(error) {
+			if (error || buildType === "serve") return;
+			if (assetsDir != null) {
+				this.debug(`Copying assets to ${assetsDir}`);
+				await copyAssetsToDestination({
+					assets,
+					assetsDir,
+					platform,
+					preferNativePlatform
+				});
+			}
+		}
+	};
+	return [...builtinPluginConfig ? [rollipopReactNativePlugin(builtinPluginConfig)] : [codegenPlugin, stripFlowSyntaxPlugin], assetPlugin];
+}
+//#endregion
+export { reactNativePlugin };

package/dist/core/plugins/reporter-plugin.d.ts

@@ -0,0 +1,11 @@
+import { Reporter } from "../../types.js";
+import * as rolldown from "@rollipop/rolldown";
+
+//#region src/core/plugins/reporter-plugin.d.ts
+interface ReporterPluginOptions {
+  initialTotalModules?: number;
+  reporter?: Reporter;
+}
+declare function reporterPlugin(options?: ReporterPluginOptions): rolldown.Plugin | null;
+//#endregion
+export { ReporterPluginOptions, reporterPlugin };

package/dist/core/plugins/reporter-plugin.js

@@ -0,0 +1,87 @@
+//#region src/core/plugins/reporter-plugin.ts
+function reporterPlugin(options) {
+	const { reporter, initialTotalModules = 0 } = options ?? {};
+	let lastBuildTotalModules = initialTotalModules;
+	let totalModules = initialTotalModules;
+	let startedAt = 0;
+	let transformedModules = 0;
+	let cacheHitModules = 0;
+	let unknownTotalModules = totalModules === 0;
+	let countCacheHitModules = true;
+	function getProcessedModules() {
+		return transformedModules + cacheHitModules;
+	}
+	function resetIncrementalProgress() {
+		startedAt = performance.now();
+		transformedModules = 0;
+		cacheHitModules = 0;
+		totalModules = 0;
+		unknownTotalModules = false;
+		countCacheHitModules = false;
+	}
+	function resetBuildProgress() {
+		startedAt = performance.now();
+		transformedModules = 0;
+		cacheHitModules = 0;
+		totalModules = lastBuildTotalModules;
+		unknownTotalModules = totalModules === 0;
+		countCacheHitModules = true;
+	}
+	function reportProgress(id) {
+		const processedModules = getProcessedModules();
+		if (!unknownTotalModules && totalModules < processedModules) totalModules = processedModules;
+		reporter?.update({
+			type: "transform",
+			id,
+			totalModules: unknownTotalModules ? void 0 : totalModules,
+			transformedModules: processedModules
+		});
+	}
+	return {
+		name: "rollipop:status",
+		buildStart() {
+			resetBuildProgress();
+			reporter?.update({ type: "bundle_build_started" });
+		},
+		buildEnd(error) {
+			const endedAt = performance.now();
+			const processedModules = getProcessedModules();
+			if (processedModules !== 0) {
+				totalModules = processedModules;
+				lastBuildTotalModules = processedModules;
+			}
+			unknownTotalModules = false;
+			reporter?.update(error == null ? {
+				type: "bundle_build_done",
+				totalModules,
+				transformedModules,
+				cacheHitModules,
+				duration: endedAt - startedAt
+			} : {
+				type: "bundle_build_failed",
+				error
+			});
+		},
+		transform: {
+			order: "post",
+			handler(_code, id) {
+				++transformedModules;
+				reportProgress(id);
+			}
+		},
+		transformCacheHit(id) {
+			if (!countCacheHitModules) return;
+			++cacheHitModules;
+			reportProgress(id);
+		},
+		watchChange(id) {
+			resetIncrementalProgress();
+			reporter?.update({
+				type: "watch_change",
+				id
+			});
+		}
+	};
+}
+//#endregion
+export { reporterPlugin };

package/dist/core/plugins/shared/filters.js

@@ -0,0 +1,5 @@
+import { exclude, id, or } from "@rollipop/rolldown/filter";
+//#region src/core/plugins/shared/filters.ts
+const ROLLDOWN_RUNTIME_EXCLUDE_FILTER = exclude(or(id(/rolldown\/runtime/), id(/@oxc-project\+runtime/)));
+//#endregion
+export { ROLLDOWN_RUNTIME_EXCLUDE_FILTER };

package/dist/core/plugins/swc-plugin.d.ts

@@ -0,0 +1,26 @@
+import { BundlerContext } from "../types.js";
+import { TransformerConfig } from "../../config/types.js";
+import { ResolvedConfig } from "../../config/defaults.js";
+import * as rolldown from "@rollipop/rolldown";
+
+//#region src/core/plugins/swc-plugin.d.ts
+interface SwcPluginOptions {
+  context: BundlerContext;
+  /**
+   * When `false`, the legacy JS preset for the resolved `runtimeTarget`
+   * is applied to every module (TS/JSX strip, hermes target). When
+   * `true`, the preset is skipped and only user-provided rules run — the
+   * rust-side pipeline handles the rest.
+   */
+  useNativeTransformPipeline: boolean;
+  runtimeTarget: ResolvedConfig['runtimeTarget'];
+  transformConfig?: TransformerConfig['swc'];
+}
+declare function swcPlugin({
+  context,
+  useNativeTransformPipeline,
+  runtimeTarget,
+  transformConfig
+}: SwcPluginOptions): rolldown.Plugin[];
+//#endregion
+export { SwcPluginOptions, swcPlugin };

package/dist/core/plugins/swc-plugin.js

@@ -0,0 +1,108 @@
+import { getFlag } from "./utils/transform-utils.js";
+import { mergeSwcOptions } from "../../utils/swc.js";
+import { ROLLDOWN_RUNTIME_EXCLUDE_FILTER } from "./shared/filters.js";
+import { id, include } from "@rollipop/rolldown/filter";
+import * as swc from "@swc/core";
+//#region src/core/plugins/swc-plugin.ts
+function swcPlugin({ context, useNativeTransformPipeline, runtimeTarget, transformConfig }) {
+	const { rules = [] } = transformConfig ?? {};
+	const swcOptionsById = /* @__PURE__ */ new Map();
+	const swcHelpersResolvePlugin = {
+		name: "rollipop:swc-helpers-resolve",
+		resolveId: {
+			order: "pre",
+			filter: [include(id(/^@swc\/helpers/)), ROLLDOWN_RUNTIME_EXCLUDE_FILTER],
+			handler(source, _importer, extraOptions) {
+				return this.resolve(source, import.meta.dirname, extraOptions);
+			}
+		}
+	};
+	const swcRules = rules.map(({ filter, options }, index) => {
+		return {
+			name: `rollipop:swc-rule-${index}`,
+			transform: {
+				filter,
+				handler(code, id) {
+					const existingBabelOptions = swcOptionsById.get(id);
+					const resolvedOptions = typeof options === "function" ? options(code, id) : options;
+					existingBabelOptions ? existingBabelOptions.push(resolvedOptions) : swcOptionsById.set(id, [resolvedOptions]);
+				}
+			}
+		};
+	});
+	const getSwcPreset = useNativeTransformPipeline ? null : presets[runtimeTarget];
+	const swcPlugin = {
+		name: "rollipop:swc",
+		buildStart() {
+			swcOptionsById.clear();
+		},
+		transform: {
+			filter: [ROLLDOWN_RUNTIME_EXCLUDE_FILTER],
+			handler(code, id) {
+				if (getFlag.call(this, context, id) & 128) return;
+				const swcOptions = swcOptionsById.get(id) ?? [];
+				if (getSwcPreset == null && swcOptions.length === 0) return;
+				const baseOptions = getSwcPreset != null ? [getSwcPreset(id)] : [];
+				const result = swc.transformSync(code, {
+					filename: id,
+					configFile: false,
+					swcrc: false,
+					sourceMaps: true,
+					inputSourceMap: false,
+					...mergeSwcOptions([...baseOptions, ...swcOptions])
+				});
+				return {
+					code: result.code,
+					map: result.map
+				};
+			}
+		}
+	};
+	return [
+		swcHelpersResolvePlugin,
+		...swcRules,
+		swcPlugin
+	];
+}
+const presets = {
+	"hermes-v1": (id) => ({
+		env: {
+			targets: { node: 9999 },
+			include: [
+				"transform-block-scoping",
+				"transform-class-properties",
+				"transform-private-methods",
+				"transform-private-property-in-object"
+			]
+		},
+		jsc: {
+			parser: {
+				syntax: "typescript",
+				tsx: true
+			},
+			transform: { react: { runtime: "preserve" } },
+			externalHelpers: true
+		},
+		isModule: id.endsWith(".cjs") ? "commonjs" : true
+	}),
+	hermes: (id) => ({
+		jsc: {
+			parser: {
+				syntax: "typescript",
+				tsx: true
+			},
+			transform: { react: { runtime: "preserve" } },
+			externalHelpers: true,
+			keepClassNames: true,
+			loose: false,
+			assumptions: {
+				setPublicClassFields: true,
+				privateFieldsAsProperties: true
+			},
+			target: "es5"
+		},
+		isModule: id.endsWith(".cjs") ? "commonjs" : true
+	})
+};
+//#endregion
+export { swcPlugin };

package/dist/core/plugins/types.d.ts

@@ -0,0 +1,18 @@
+import { AsyncResult } from "../types.js";
+import { DevServer } from "../../server/types.js";
+import { PluginContext } from "./context.js";
+import { Config } from "../../config/types.js";
+import { ResolvedConfig } from "../../config/defaults.js";
+import * as rolldown from "@rollipop/rolldown";
+
+//#region src/core/plugins/types.d.ts
+type PluginConfig = Omit<Config, 'plugins'>;
+type ResolvedPluginConfig = Omit<ResolvedConfig, 'plugins'>;
+type InternalRolldownHook = 'transformCacheHit';
+type Plugin = Omit<rolldown.Plugin, InternalRolldownHook> & {
+  config?: PluginConfig | ((this: PluginContext, config: PluginConfig) => AsyncResult<PluginConfig | null | void>);
+  configResolved?: (this: PluginContext, config: ResolvedConfig) => AsyncResult<void>;
+  configureServer?: (this: PluginContext, server: DevServer) => AsyncResult<void | (() => AsyncResult<void>)>;
+};
+//#endregion
+export { Plugin, PluginConfig, ResolvedPluginConfig };

package/dist/core/plugins/utils/source.js

@@ -0,0 +1,10 @@
+//#region src/core/plugins/utils/source.ts
+const TS_EXTENSION_REGEXP = /\.tsx?$/;
+function isTS(id) {
+	return TS_EXTENSION_REGEXP.test(id);
+}
+function isJSX(id) {
+	return id.endsWith("x");
+}
+//#endregion
+export { isJSX, isTS };