@granite-js/mpack 0.0.1

package/dist/bundler/plugins/buildStatusPlugin/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 buildStatusPlugin_exports = {};
+__export(buildStatusPlugin_exports, {
+  buildStatusPlugin: () => import_buildStatusPlugin.buildStatusPlugin
+});
+module.exports = __toCommonJS(buildStatusPlugin_exports);
+var import_buildStatusPlugin = require("./buildStatusPlugin");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildStatusPlugin
+});

package/dist/bundler/plugins/dependencyAliasPlugin/aliasResolver.d.ts

@@ -0,0 +1,3 @@
+import type { PluginBuild } from 'esbuild';
+import type { AliasConfig } from '../../../types';
+export declare function setupAliasResolver(build: PluginBuild, rootDir: string, aliasConfig: AliasConfig[]): void;

package/dist/bundler/plugins/dependencyAliasPlugin/aliasResolver.js

@@ -0,0 +1,89 @@
+"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 aliasResolver_exports = {};
+__export(aliasResolver_exports, {
+  setupAliasResolver: () => setupAliasResolver
+});
+module.exports = __toCommonJS(aliasResolver_exports);
+var import_path = __toESM(require("path"));
+var import_performance = require("../../../performance");
+var import_esbuildUtils = require("../../../utils/esbuildUtils");
+var import_replaceModulePath = require("../../../utils/replaceModulePath");
+var import_swc = require("../shared/swc");
+const resolved = Symbol();
+function setupAliasResolver(build, rootDir, aliasConfig) {
+  function aliasResolver(path2, options) {
+    return build.resolve(path2, {
+      ...options,
+      pluginData: {
+        ...options?.pluginData,
+        [resolved]: true
+      }
+    });
+  }
+  [import_swc.swcHelperOptimizationRules.getAliasConfig(), ...aliasConfig].forEach(({ from, to, exact }) => {
+    const resolveResultCache = /* @__PURE__ */ new Map();
+    const filter = new RegExp(exact ? `^${from}$` : `^${from}(?:$|/)`);
+    build.onResolve({ filter }, async (args) => {
+      if (args.pluginData?.[resolved]) {
+        return;
+      }
+      const trace = import_performance.Performance.trace("alias-resolver", {
+        detail: { pattern: filter, path: args.path }
+      });
+      const resolvedPath = typeof to === "string" ? (0, import_replaceModulePath.replaceModulePath)(args.path, from, to) : await to({ resolve: aliasResolver, args });
+      const normalizedPath = (0, import_esbuildUtils.normalizePath)(resolvedPath);
+      const cacheKey = `${args.kind}:${normalizedPath}`;
+      if (resolveResultCache.has(cacheKey)) {
+        trace.stop({ detail: { cacheHit: true } });
+        return resolveResultCache.get(cacheKey);
+      }
+      if (import_path.default.isAbsolute(normalizedPath)) {
+        trace.stop({ detail: { isAbsolute: true } });
+        const result2 = { path: normalizedPath };
+        resolveResultCache.set(cacheKey, result2);
+        return result2;
+      }
+      const result = await build.resolve(normalizedPath, {
+        resolveDir: rootDir,
+        kind: args.kind,
+        pluginData: {
+          [resolved]: true
+        }
+      });
+      trace.stop({ detail: { cacheHit: false, isAbsolute: false } });
+      resolveResultCache.set(cacheKey, result);
+      return result;
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  setupAliasResolver
+});

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

@@ -0,0 +1,3 @@
+import type { Plugin } from 'esbuild';
+import { PluginOptions } from '../types';
+export declare function dependencyAliasPlugin({ context }: PluginOptions): Plugin;

package/dist/bundler/plugins/dependencyAliasPlugin/dependencyAliasPlugin.js

@@ -0,0 +1,43 @@
+"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 dependencyAliasPlugin_exports = {};
+__export(dependencyAliasPlugin_exports, {
+  dependencyAliasPlugin: () => dependencyAliasPlugin
+});
+module.exports = __toCommonJS(dependencyAliasPlugin_exports);
+var import_aliasResolver = require("./aliasResolver");
+var import_protocolResolver = require("./protocolResolver");
+function dependencyAliasPlugin({ context }) {
+  const pluginName = "dependency-alias-plugin";
+  return {
+    name: pluginName,
+    setup(build) {
+      const { rootDir, buildConfig } = context.config;
+      const { resolver } = buildConfig;
+      const alias = resolver?.alias ?? [];
+      const protocols = resolver?.protocols ?? {};
+      (0, import_aliasResolver.setupAliasResolver)(build, rootDir, alias);
+      (0, import_protocolResolver.setupProtocolResolver)(build, protocols);
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dependencyAliasPlugin
+});

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

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

package/dist/bundler/plugins/dependencyAliasPlugin/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 dependencyAliasPlugin_exports = {};
+__export(dependencyAliasPlugin_exports, {
+  dependencyAliasPlugin: () => import_dependencyAliasPlugin.dependencyAliasPlugin
+});
+module.exports = __toCommonJS(dependencyAliasPlugin_exports);
+var import_dependencyAliasPlugin = require("./dependencyAliasPlugin");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dependencyAliasPlugin
+});

package/dist/bundler/plugins/dependencyAliasPlugin/protocolResolver.d.ts

@@ -0,0 +1,3 @@
+import type { PluginBuild } from 'esbuild';
+import type { ProtocolConfig } from '../../../types';
+export declare function setupProtocolResolver(build: PluginBuild, protocolConfig: ProtocolConfig): void;

package/dist/bundler/plugins/dependencyAliasPlugin/protocolResolver.js

@@ -0,0 +1,53 @@
+"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 protocolResolver_exports = {};
+__export(protocolResolver_exports, {
+  setupProtocolResolver: () => setupProtocolResolver
+});
+module.exports = __toCommonJS(protocolResolver_exports);
+var import_performance = require("../../../performance");
+function setupProtocolResolver(build, protocolConfig) {
+  const protocols = Object.entries(protocolConfig);
+  protocols.forEach(([protocol, { resolve, load }]) => {
+    const protocolRegExp = new RegExp(`^${protocol}:`);
+    build.onResolve({ filter: protocolRegExp }, async (args) => {
+      const trace = import_performance.Performance.trace("protocol-resolver", {
+        detail: {
+          pattern: protocolRegExp,
+          path: args.path
+        }
+      });
+      const path = typeof resolve === "function" ? await resolve(args) : args.path.replace(protocolRegExp, "");
+      trace.stop();
+      return {
+        // 'protocol:foo' -> 'foo'
+        path,
+        namespace: getProtocolNamespace(protocol)
+      };
+    });
+    build.onLoad({ filter: /.*/, namespace: getProtocolNamespace(protocol) }, (args) => load(args));
+  });
+}
+function getProtocolNamespace(protocol) {
+  return `protocol-${protocol}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  setupProtocolResolver
+});

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

@@ -0,0 +1,4 @@
+export * from './buildStatusPlugin';
+export * from './dependencyAliasPlugin';
+export * from './requireContextPlugin';
+export * from './transformPlugin';

package/dist/bundler/plugins/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 __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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plugins_exports = {};
+module.exports = __toCommonJS(plugins_exports);
+__reExport(plugins_exports, require("./buildStatusPlugin"), module.exports);
+__reExport(plugins_exports, require("./dependencyAliasPlugin"), module.exports);
+__reExport(plugins_exports, require("./requireContextPlugin"), module.exports);
+__reExport(plugins_exports, require("./transformPlugin"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./buildStatusPlugin"),
+  ...require("./dependencyAliasPlugin"),
+  ...require("./requireContextPlugin"),
+  ...require("./transformPlugin")
+});

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

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

package/dist/bundler/plugins/requireContextPlugin/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 requireContextPlugin_exports = {};
+__export(requireContextPlugin_exports, {
+  requireContextPlugin: () => import_requireContextPlugin.requireContextPlugin
+});
+module.exports = __toCommonJS(requireContextPlugin_exports);
+var import_requireContextPlugin = require("./requireContextPlugin");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  requireContextPlugin
+});

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

@@ -0,0 +1,6 @@
+import { Plugin } from 'esbuild';
+/**
+ * 파일에 require.context('(.*)')라고 하는 글자가 있으면,
+ * require('require-context:$1') 로 바꾼다.
+ */
+export declare function requireContextPlugin(): Plugin;

package/dist/bundler/plugins/requireContextPlugin/requireContextPlugin.js

@@ -0,0 +1,101 @@
+"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 requireContextPlugin_exports = {};
+__export(requireContextPlugin_exports, {
+  requireContextPlugin: () => requireContextPlugin
+});
+module.exports = __toCommonJS(requireContextPlugin_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_scripts = require("./scripts");
+var import_constants = require("../../../constants");
+var import_esbuildUtils = require("../../../utils/esbuildUtils");
+async function getFilePaths(rootDir) {
+  const filenames = [];
+  const rootFilenames = await import_fs.default.readdirSync(rootDir);
+  for await (const filename of rootFilenames) {
+    const filePath = import_path.default.join(rootDir, filename);
+    if (import_fs.default.lstatSync(filePath).isDirectory()) {
+      filenames.push(...await getFilePaths(filePath));
+    } else {
+      filenames.push(filePath);
+    }
+  }
+  return filenames;
+}
+function requireContextPlugin() {
+  return {
+    name: "require-context-plugin",
+    setup(build) {
+      build.onLoad({ filter: /require\.context\.tsx?$/ }, async (args) => {
+        const content = await import_fs.default.promises.readFile(args.path, "utf8");
+        return {
+          loader: args.path.endsWith(".tsx") ? "tsx" : "ts",
+          contents: (0, import_scripts.toRequireContextExportScript)(content)
+        };
+      });
+      build.onResolve({ filter: new RegExp(`^${import_constants.REQUIRE_CONTEXT_PROTOCOL}.*`) }, (args) => {
+        return {
+          namespace: "require-context",
+          path: args.path.slice(import_constants.REQUIRE_CONTEXT_PROTOCOL.length),
+          pluginData: {
+            importer: args.resolveDir
+          }
+        };
+      });
+      build.onLoad({ namespace: "require-context", filter: /.*/ }, async (args) => {
+        const importer = args.pluginData?.importer;
+        if (importer == null) {
+          throw new Error(`importer\uAC00 \uC8FC\uC5B4\uC838\uC57C \uD569\uB2C8\uB2E4.`);
+        }
+        const targetDir = import_path.default.resolve(importer, args.path);
+        const basePath = import_path.default.join(importer, args.path);
+        const filePaths = await getFilePaths(targetDir);
+        const requireContextModules = filePaths.map((filePath, index) => {
+          const pagePath = import_path.default.relative(basePath, filePath);
+          const normalizedPagePath = (0, import_esbuildUtils.normalizePath)(pagePath);
+          const normalizedFilePath = (0, import_esbuildUtils.normalizePath)(filePath);
+          return {
+            moduleIndex: index,
+            relativePath: normalizedPagePath.startsWith(".") ? normalizedPagePath : `./${normalizedPagePath}`,
+            absolutePath: normalizedFilePath
+          };
+        });
+        return {
+          contents: (0, import_scripts.getRequireContextScript)(requireContextModules),
+          resolveDir: importer
+        };
+      });
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  requireContextPlugin
+});

package/dist/bundler/plugins/requireContextPlugin/scripts.d.ts

@@ -0,0 +1,56 @@
+interface RequireContextModule {
+    moduleIndex: number;
+    absolutePath: string;
+    relativePath: string;
+}
+/**
+ * require context export 스크립트 반환
+ *
+ * ```js
+ * export const context = require.context('../path'); // A
+ * export default require.context('../path'); // B
+ * ```
+ *
+ * 형태의 코드를 아래와 같이 변경
+ *
+ * ```js
+ * // Sample
+ * import __context__ from 'require-context:../path';
+ *
+ * export var context = __context__; // A
+ * export default __context__; // B
+ * ```
+ */
+export declare function toRequireContextExportScript(content: string): string;
+/**
+ * require context 스크립트
+ *
+ * ```js
+ * // Sample
+ * import * as module0 from "/path/to/module-0";
+ * import * as module1 from "/path/to/module-1";
+ * import * as module2 from "/path/to/module-2";
+ *
+ * var requireContext = function(key) {
+ *   var _modules = {};
+ *
+ *   _modules["./relative/path/of/module-0"] = module0;
+ *   _modules["./relative/path/of/module-1"] = module1;
+ *   _modules["./relative/path/of/module-2"] = module2;
+ *
+ *   return _modules[key];
+ * };
+ *
+ * requireContext.keys = function() {
+ *   return [
+ *     "./relative/path/of/module-0",
+ *     "./relative/path/of/module-1",
+ *     "./relative/path/of/module-2",
+ *   ];
+ * };
+ *
+ * export default requireContext;
+ * ```
+ */
+export declare function getRequireContextScript(modules: RequireContextModule[]): string;
+export {};

package/dist/bundler/plugins/requireContextPlugin/scripts.js

@@ -0,0 +1,65 @@
+"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 scripts_exports = {};
+__export(scripts_exports, {
+  getRequireContextScript: () => getRequireContextScript,
+  toRequireContextExportScript: () => toRequireContextExportScript
+});
+module.exports = __toCommonJS(scripts_exports);
+var import_constants = require("../../../constants");
+function toRequireContextExportScript(content) {
+  const [_, source] = content.match(/require\.context\((.*?)\)/) ?? [];
+  const parsedSource = source?.replace(/['"]/g, "");
+  if (!parsedSource) {
+    throw new Error("\uC720\uD6A8\uD558\uC9C0 \uC54A\uC740 require context \uAD6C\uBB38\uC785\uB2C8\uB2E4");
+  }
+  const IMPORT_STATEMENT = `import __context__ from '${import_constants.REQUIRE_CONTEXT_PROTOCOL}${parsedSource}';`;
+  const MODULE_BODY = content.replace(/require\.context\('(.*?)'\)/, "__context__").replace("const", "var");
+  return `
+${IMPORT_STATEMENT}
+
+${MODULE_BODY}
+`.trim();
+}
+function getRequireContextScript(modules) {
+  const IMPORT_STATEMENTS = modules.map((module2) => `import * as module${module2.moduleIndex} from ${JSON.stringify(module2.absolutePath)};`).join("\n");
+  const ASSIGN_STATEMENTS = modules.map((module2) => `_modules[${JSON.stringify(module2.relativePath)}] = module${module2.moduleIndex};`).join("\n");
+  return `
+${IMPORT_STATEMENTS}
+
+var requireContext = function(key) {
+  var _modules = {};
+  
+  ${ASSIGN_STATEMENTS}
+
+  return _modules[key];
+};
+
+requireContext.keys = function() {
+  return [${modules.map((module2) => JSON.stringify(module2.relativePath)).join(",")}];
+};
+
+export default requireContext;
+`.trim();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getRequireContextScript,
+  toRequireContextExportScript
+});

package/dist/bundler/plugins/shared/swc.d.ts

@@ -0,0 +1,11 @@
+import type { JscConfig } from '@swc/core';
+import type { AliasConfig } from '../../../types';
+/**
+ * `@swc/helpers`를 사용하여 번들 크기를 최적화 하기 위한 구성입니다.
+ *
+ * swc 옵션과 플러그인에서 처리할 로직은 상호 의존적이기 때문에 한 곳에 모아둡니다.
+ */
+export declare const swcHelperOptimizationRules: {
+    jsc: JscConfig;
+    getAliasConfig: () => AliasConfig;
+};

package/dist/bundler/plugins/shared/swc.js

@@ -0,0 +1,70 @@
+"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 swc_exports = {};
+__export(swc_exports, {
+  swcHelperOptimizationRules: () => swcHelperOptimizationRules
+});
+module.exports = __toCommonJS(swc_exports);
+var import_path = __toESM(require("path"));
+const swcHelperOptimizationRules = {
+  jsc: {
+    externalHelpers: true
+  },
+  getAliasConfig: () => {
+    const swcHelperPath = import_path.default.dirname(require.resolve("@swc/helpers/package.json"));
+    function getHelperName(source) {
+      const tokens = source.split("/");
+      return tokens[tokens.length - 1];
+    }
+    return {
+      from: "@swc/helpers",
+      /**
+       * swc 구성의 externalHelpers 를 활성화 시켜 중복되는 유틸 함수를 `@swc/helpers` 패키지로 대체할 수 있으나,
+       * Yarn PnP 환경에서는 실제 모듈 의존성에 포함되지 않은 `@swc/helpers` 를 resolve 할 수 없기에 preset 기준 경로로 대체하여 resolve 처리합니다.
+       *
+       * ```ts
+       * // AS-IS
+       * import { _ as _foo } from '@swc/helpers/_/_foo';
+       *
+       * // TO-BE
+       * import { _ as _foo } from '/path/to/helpers/esm/_foo';
+       * ```
+       *
+       * @see exports {@link https://github.com/swc-project/swc/blob/main/packages/helpers/package.json#L41}
+       */
+      to: function resolveSwcHelper(context) {
+        return `${swcHelperPath}/esm/${getHelperName(context.args.path)}.js`;
+      }
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  swcHelperOptimizationRules
+});