@granite-js/mpack 0.0.1

package/dist/bundler/plugins/transformPlugin/helpers/preludeScript.d.ts

@@ -0,0 +1,23 @@
+import { OnLoadArgs, PluginBuild } from 'esbuild';
+/**
+ * Entry Point 모듈을 찾아 마킹하기 위한 `onResolve` 콜백 등록
+ */
+export declare function registerEntryPointMarker(build: PluginBuild): void;
+/**
+ * 가상의 Prelude script 경로를 Tree Shaking 없이 직접 resolve 하기 위한 `onResolve` 콜백 등록
+ */
+export declare function registerPreludeScriptResolver(build: PluginBuild): void;
+export declare function isEntryPoint(args: OnLoadArgs): boolean;
+/**
+ * 코드 최상단에 prelude 스크립트 추가
+ *
+ * ```ts
+ * import 'prelude:foo';
+ * import 'prelude:bar';
+ * import 'prelude:baz';
+ * // ...
+ * ```
+ */
+export declare function injectPreludeScript(code: string, { preludeScriptPaths, }: {
+    preludeScriptPaths: string[];
+}): string;

package/dist/bundler/plugins/transformPlugin/helpers/preludeScript.js

@@ -0,0 +1,79 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var preludeScript_exports = {};
+__export(preludeScript_exports, {
+  injectPreludeScript: () => injectPreludeScript,
+  isEntryPoint: () => isEntryPoint,
+  registerEntryPointMarker: () => registerEntryPointMarker,
+  registerPreludeScriptResolver: () => registerPreludeScriptResolver
+});
+module.exports = __toCommonJS(preludeScript_exports);
+var path = __toESM(require("path"));
+var import_es_toolkit = require("es-toolkit");
+var import_constants = require("../../../../constants");
+var import_esbuildUtils = require("../../../../utils/esbuildUtils");
+const skipResolve = Symbol.for("skipResolve");
+const isEntry = Symbol.for("isEntry");
+function registerEntryPointMarker(build) {
+  build.onResolve({ filter: /\.([mc]js|[tj]sx?)$/ }, async (args) => {
+    if (args.pluginData !== skipResolve && args.kind === "entry-point") {
+      const { path: path2, errors } = await build.resolve(args.path, {
+        importer: args.importer,
+        kind: args.kind,
+        resolveDir: args.resolveDir,
+        // 한 번만 resolve 하기 위한 플래그 값
+        pluginData: skipResolve
+      });
+      return errors.length === 0 ? { path: path2, pluginData: isEntry } : { errors };
+    }
+    return null;
+  });
+}
+function registerPreludeScriptResolver(build) {
+  build.onResolve({ filter: new RegExp(`^${import_constants.PRELUDE_PROTOCOL}.*`) }, (args) => {
+    const basePath = args.path.slice(import_constants.PRELUDE_PROTOCOL.length);
+    const resolvePath = path.resolve(args.resolveDir, basePath);
+    return { path: resolvePath, sideEffects: true };
+  });
+}
+function isEntryPoint(args) {
+  return args.pluginData === isEntry;
+}
+function injectPreludeScript(code, {
+  preludeScriptPaths
+}) {
+  return [...preludeScriptPaths.map((path2) => `import '${import_constants.PRELUDE_PROTOCOL}${(0, import_esbuildUtils.normalizePath)(path2)}';`), code].filter(import_es_toolkit.isNotNil).join("\n");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  injectPreludeScript,
+  isEntryPoint,
+  registerEntryPointMarker,
+  registerPreludeScriptResolver
+});

package/dist/bundler/plugins/transformPlugin/index.d.ts

@@ -0,0 +1 @@
+export { transformPlugin } from './transformPlugin';

package/dist/bundler/plugins/transformPlugin/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var transformPlugin_exports = {};
+__export(transformPlugin_exports, {
+  transformPlugin: () => import_transformPlugin.transformPlugin
+});
+module.exports = __toCommonJS(transformPlugin_exports);
+var import_transformPlugin = require("./transformPlugin");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  transformPlugin
+});

package/dist/bundler/plugins/transformPlugin/steps/createCacheSteps.d.ts

@@ -0,0 +1,10 @@
+import { AsyncTransformStep } from '../../../../transformer/TransformPipeline';
+interface CacheStepConfig {
+    id: string;
+    enabled: boolean;
+}
+export declare function createCacheSteps(config: CacheStepConfig): {
+    beforeTransform: AsyncTransformStep;
+    afterTransform: AsyncTransformStep;
+};
+export {};

package/dist/bundler/plugins/transformPlugin/steps/createCacheSteps.js

@@ -0,0 +1,56 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var createCacheSteps_exports = {};
+__export(createCacheSteps_exports, {
+  createCacheSteps: () => createCacheSteps
+});
+module.exports = __toCommonJS(createCacheSteps_exports);
+var import_cache = require("../../../../cache");
+var import_performance = require("../../../../performance");
+function createCacheSteps(config) {
+  const transformCache = new import_cache.Cache(`transformed-${config.id}`, {
+    parse: (data) => ({ transformed: data, mtimeMs: 0 }),
+    stringify: (value) => value.transformed
+  });
+  const readCodeFromCache = async (code, _args, context) => {
+    if (!config.enabled) {
+      return { code };
+    }
+    const cache = await import_performance.Performance.withTrace(() => transformCache.read(context.key), {
+      name: "read-cache"
+    });
+    return cache?.transformed ? { code: cache.transformed, done: true } : { code };
+  };
+  const writeCodeToCache = async (code, _args, context) => {
+    if (config.enabled) {
+      const trace = import_performance.Performance.trace("write-cache");
+      await transformCache.write(context.key, {
+        mtimeMs: context.mtimeMs,
+        transformed: code
+      });
+      trace.stop();
+    }
+    return { code };
+  };
+  return { beforeTransform: readCodeFromCache, afterTransform: writeCodeToCache };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createCacheSteps
+});

package/dist/bundler/plugins/transformPlugin/steps/createFullyTransformStep.d.ts

@@ -0,0 +1,8 @@
+import * as babel from '@babel/core';
+import { AsyncTransformStep } from '../../../../transformer/TransformPipeline';
+interface FullyTransformStepConfig {
+    dev: boolean;
+    additionalBabelOptions?: babel.TransformOptions;
+}
+export declare function createFullyTransformStep({ dev, additionalBabelOptions, }: FullyTransformStepConfig): AsyncTransformStep;
+export {};

package/dist/bundler/plugins/transformPlugin/steps/createFullyTransformStep.js

@@ -0,0 +1,120 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var createFullyTransformStep_exports = {};
+__export(createFullyTransformStep_exports, {
+  createFullyTransformStep: () => createFullyTransformStep
+});
+module.exports = __toCommonJS(createFullyTransformStep_exports);
+var path = __toESM(require("path"));
+var babel = __toESM(require("@babel/core"));
+var import_defineStepName = require("../../../../utils/defineStepName");
+function createFullyTransformStep({
+  dev,
+  additionalBabelOptions
+}) {
+  const baseOptions = {
+    configFile: additionalBabelOptions?.configFile || false,
+    presets: [
+      [
+        /**
+         * React Native Hermes 대응을 위해
+         * 최대한 낮은 버전의 JS 엔진을 지원하도록 IE 11로 설정
+         * 추후 정확한 target으로 설정 필요
+         */
+        require.resolve("@babel/preset-env"),
+        {
+          targets: {
+            ie: 11
+          },
+          /**
+           * supportsStaticESM 이 true 이면 modules 가 false 로 처리되어야 하는데,
+           * 기본값('auto')이 적용되어 안내 로그가 찍히고 있어 직접 값 지정
+           *
+           * @see source {@link https://github.com/babel/babel/blob/v7.23.10/packages/babel-preset-env/src/index.ts#L398-L403}
+           */
+          modules: false
+        }
+      ],
+      /**
+       * react-native-reanimated 등 TypeScript를 직접 export하는 라이브러리를 다루기 위해
+       * @babel/preset-typescript 포함 필요
+       */
+      require.resolve("@babel/preset-typescript"),
+      /**
+       * react-native-reanimated 등 .tsx 직접 export하는 라이브러리를 다루기 위해
+       * @babel/preset-react 포함 필요
+       */
+      [require.resolve("@babel/preset-react"), { runtime: "automatic" }],
+      ...additionalBabelOptions?.presets ?? []
+    ],
+    plugins: [
+      /**
+       * react-native에서 직접 export 하는 flow 파일 대응을 위해 strip types 추가 필요
+       */
+      require.resolve("@babel/plugin-transform-flow-strip-types"),
+      [require.resolve("@babel/plugin-proposal-class-properties"), { loose: true }],
+      [require.resolve("@babel/plugin-proposal-private-property-in-object"), { loose: true }],
+      [require.resolve("@babel/plugin-proposal-private-methods"), { loose: true }],
+      ...additionalBabelOptions?.plugins ?? []
+    ]
+  };
+  const fullyTransformStep = async function fullyTransform(code, args) {
+    const babelOptions = babel.loadOptions({
+      minified: false,
+      compact: false,
+      babelrc: false,
+      configFile: false,
+      envName: dev ? "development" : "production",
+      ...baseOptions,
+      sourceMaps: "inline",
+      filename: path.basename(args.path),
+      caller: {
+        name: "mpack-fully-transform-plugin",
+        supportsStaticESM: true
+      }
+    });
+    if (!babelOptions) {
+      return { code };
+    }
+    if (babelOptions.sourceMaps) {
+      babelOptions.sourceFileName = path.basename(args.path);
+    }
+    const result = await babel.transformAsync(code, babelOptions);
+    if (result?.code != null) {
+      return { code: result.code };
+    }
+    throw new Error("babel transform result is null");
+  };
+  (0, import_defineStepName.defineStepName)(fullyTransformStep, "fully-transform");
+  return fullyTransformStep;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createFullyTransformStep
+});

package/dist/bundler/plugins/transformPlugin/steps/createStripFlowStep.d.ts

@@ -0,0 +1,6 @@
+import { AsyncTransformStep } from '../../../../transformer/TransformPipeline';
+interface StripFlowStepConfig {
+    dev: boolean;
+}
+export declare function createStripFlowStep(config: StripFlowStepConfig): AsyncTransformStep;
+export {};

package/dist/bundler/plugins/transformPlugin/steps/createStripFlowStep.js

@@ -0,0 +1,91 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var createStripFlowStep_exports = {};
+__export(createStripFlowStep_exports, {
+  createStripFlowStep: () => createStripFlowStep
+});
+module.exports = __toCommonJS(createStripFlowStep_exports);
+var import_path = __toESM(require("path"));
+var babel = __toESM(require("@babel/core"));
+var sucrase = __toESM(require("sucrase"));
+var import_defineStepName = require("../../../../utils/defineStepName");
+function createStripFlowStep(config) {
+  const stripImportTypeofStatements = (code) => {
+    return code.split("\n").filter((line) => !line.startsWith("import typeof ")).join("\n");
+  };
+  const stripFlowStep = async function stripFlow(code, args) {
+    const shouldTransform = args.path.endsWith(".js");
+    if (!shouldTransform) {
+      return { code };
+    }
+    try {
+      const result = sucrase.transform(code, {
+        transforms: ["flow", "jsx"],
+        jsxRuntime: "preserve",
+        disableESTransforms: true
+      });
+      return { code: stripImportTypeofStatements(result.code) };
+    } catch {
+      const result = await babel.transformAsync(code, {
+        configFile: false,
+        minified: false,
+        compact: false,
+        babelrc: false,
+        envName: config.dev ? "development" : "production",
+        caller: {
+          name: "mpack-strip-flow-plugin",
+          supportsStaticESM: true
+        },
+        presets: [
+          /**
+           * flow 구문과 jsx 구문이 함께 존재하는 경우가 있기에 preset-react 사용
+           */
+          [require.resolve("@babel/preset-react"), { runtime: "automatic" }]
+        ],
+        plugins: [
+          /**
+           * flow 구문 변환을 위해 flow-strip-types 사용
+           */
+          require.resolve("@babel/plugin-transform-flow-strip-types")
+        ],
+        filename: import_path.default.basename(args.path)
+      });
+      if (result?.code != null) {
+        return { code: result.code };
+      }
+      throw new Error("babel transform result is null");
+    }
+  };
+  (0, import_defineStepName.defineStepName)(stripFlowStep, "strip-flow");
+  return stripFlowStep;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createStripFlowStep
+});

package/dist/bundler/plugins/transformPlugin/steps/createTransformToHermesSyntaxStep.d.ts

@@ -0,0 +1,8 @@
+import { AsyncTransformStep } from '../../../../transformer/TransformPipeline';
+import { BuildConfig } from '../../../../types';
+interface TransformToHermesSyntaxStepConfig {
+    dev: boolean;
+    additionalSwcOptions?: BuildConfig['swc'];
+}
+export declare function createTransformToHermesSyntaxStep({ dev, additionalSwcOptions, }: TransformToHermesSyntaxStepConfig): AsyncTransformStep;
+export {};

package/dist/bundler/plugins/transformPlugin/steps/createTransformToHermesSyntaxStep.js

@@ -0,0 +1,100 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var createTransformToHermesSyntaxStep_exports = {};
+__export(createTransformToHermesSyntaxStep_exports, {
+  createTransformToHermesSyntaxStep: () => createTransformToHermesSyntaxStep
+});
+module.exports = __toCommonJS(createTransformToHermesSyntaxStep_exports);
+var import_path = __toESM(require("path"));
+var swc = __toESM(require("@swc/core"));
+var import_es_toolkit = require("es-toolkit");
+var import_defineStepName = require("../../../../utils/defineStepName");
+var import_swc = require("../../shared/swc");
+function getParserConfig(filepath) {
+  return /\.tsx?$/.test(filepath) ? {
+    syntax: "typescript",
+    tsx: true,
+    dynamicImport: true
+  } : {
+    syntax: "ecmascript",
+    jsx: true,
+    exportDefaultFrom: true
+  };
+}
+function createTransformToHermesSyntaxStep({
+  dev,
+  additionalSwcOptions = {}
+}) {
+  const plugins = (additionalSwcOptions.plugins ?? []).filter(import_es_toolkit.isNotNil);
+  const transformToHermesSyntaxStep = async function transformToHermesSyntax(code, args) {
+    const options = {
+      minify: false,
+      isModule: true,
+      jsc: {
+        ...import_swc.swcHelperOptimizationRules.jsc,
+        parser: getParserConfig(args.path),
+        target: "es5",
+        keepClassNames: true,
+        transform: {
+          react: {
+            runtime: "automatic",
+            development: dev
+          }
+        },
+        experimental: { plugins },
+        loose: false,
+        /**
+         * 타입정의가 없지만 실제로는 동작하는 것이 스펙
+         *
+         * @see {@link https://github.com/swc-project/swc/blob/v1.4.10/crates/swc_ecma_transforms_base/src/assumptions.rs#L11}
+         */
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        assumptions: {
+          setPublicClassFields: true,
+          privateFieldsAsProperties: true
+        }
+      },
+      /**
+       * False error 로그가 찍히고 있어 비활성화
+       */
+      inputSourceMap: false,
+      sourceMaps: "inline",
+      filename: import_path.default.basename(args.path)
+    };
+    const result = await swc.transform(code, options);
+    return { code: result.code };
+  };
+  (0, import_defineStepName.defineStepName)(transformToHermesSyntaxStep, "hermes-syntax");
+  return transformToHermesSyntaxStep;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createTransformToHermesSyntaxStep
+});

package/dist/bundler/plugins/transformPlugin/transformPlugin.d.ts

@@ -0,0 +1,8 @@
+import { Plugin } from 'esbuild';
+import { PluginOptions } from '../types';
+interface TransformPluginOptions {
+    transformSync?: (id: string, code: string) => string;
+    transformAsync?: (id: string, code: string) => Promise<string>;
+}
+export declare function transformPlugin({ context, ...options }: PluginOptions<TransformPluginOptions>): Plugin;
+export {};

package/dist/bundler/plugins/transformPlugin/transformPlugin.js

@@ -0,0 +1,88 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var transformPlugin_exports = {};
+__export(transformPlugin_exports, {
+  transformPlugin: () => transformPlugin
+});
+module.exports = __toCommonJS(transformPlugin_exports);
+var import_assert = __toESM(require("assert"));
+var fs = __toESM(require("fs/promises"));
+var preludeScript = __toESM(require("./helpers/preludeScript"));
+var import_createCacheSteps = require("./steps/createCacheSteps");
+var import_createFullyTransformStep = require("./steps/createFullyTransformStep");
+var import_createStripFlowStep = require("./steps/createStripFlowStep");
+var import_createTransformToHermesSyntaxStep = require("./steps/createTransformToHermesSyntaxStep");
+var import_performance = require("../../../performance");
+var import_transformer = require("../../../transformer");
+const sourceRegExp = /\.([mc]js|[tj]sx?)$/;
+function transformPlugin({ context, ...options }) {
+  return {
+    name: "transform-plugin",
+    setup(build) {
+      const { id, config } = context;
+      const { dev, cache, buildConfig } = config;
+      const { esbuild, swc, babel } = buildConfig;
+      (0, import_assert.default)(id, "id \uAC12\uC774 \uC874\uC7AC\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4");
+      (0, import_assert.default)(typeof dev === "boolean", "dev \uAC12\uC774 \uC874\uC7AC\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4");
+      (0, import_assert.default)(typeof cache === "boolean", "cache \uAC12\uC774 \uC874\uC7AC\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4");
+      const cacheSteps = (0, import_createCacheSteps.createCacheSteps)({ id, enabled: cache });
+      const transformPipeline = new import_transformer.AsyncTransformPipeline().beforeStep(cacheSteps.beforeTransform).addStep(async (code, args) => {
+        if (options.transformSync) {
+          code = options.transformSync(args.path, code);
+        }
+        if (options.transformAsync) {
+          code = await options.transformAsync(args.path, code);
+        }
+        return { code };
+      }).addStep((0, import_createFullyTransformStep.createFullyTransformStep)({ dev, additionalBabelOptions: babel }), {
+        conditions: babel?.conditions,
+        skipOtherSteps: true
+      }).addStep((0, import_createStripFlowStep.createStripFlowStep)({ dev })).addStep((0, import_createTransformToHermesSyntaxStep.createTransformToHermesSyntaxStep)({ dev, additionalSwcOptions: swc })).afterStep(cacheSteps.afterTransform);
+      preludeScript.registerEntryPointMarker(build);
+      preludeScript.registerPreludeScriptResolver(build);
+      build.onLoad({ filter: sourceRegExp }, async (args) => {
+        let code = await fs.readFile(args.path, "utf-8");
+        if (preludeScript.isEntryPoint(args)) {
+          code = preludeScript.injectPreludeScript(code, {
+            preludeScriptPaths: esbuild?.prelude ?? []
+          });
+        }
+        const result = await import_performance.Performance.withTrace(() => transformPipeline.transform(code, args), {
+          name: "transform",
+          startOptions: { detail: { file: args.path } }
+        });
+        return { contents: result.code, loader: "js" };
+      });
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  transformPlugin
+});

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

@@ -0,0 +1,7 @@
+import type { BundlerConfig, INTERNAL__Id } from '../../types';
+export type PluginOptions<T = object> = T & {
+    context: {
+        id: INTERNAL__Id;
+        config: BundlerConfig;
+    };
+};

package/dist/bundler/plugins/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);