@freshpack/webpack 1.0.0 → 1.0.1

package/CHANGELOG.md

@@ -0,0 +1,10 @@
+# @freshpack/webpack
+
+## 1.0.1
+
+### Patch Changes
+
+- prepack
+
+- Updated dependencies:
+  - @freshpack/core@3.0.2

package/LICENSE

@@ -1,20 +1,21 @@
 MIT License
 
-Copyright (c) 2026 Lach and Fresh authors
+Copyright (c) 2026 Yaroslav Bolyukin <iam@lach.pw>
 
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/denoEnv.d.ts

@@ -0,0 +1,12 @@
+import { type Compiler } from "webpack";
+export type DenoEnvOptions = {
+    allowedEnv?: (string | RegExp)[];
+};
+/**
+ * DenoEnvPlugin replaces calls to `Deno.env.get` with a constant expression of environment variable name.
+ */
+export declare class DenoEnvPlugin {
+    #private;
+    constructor(opts?: DenoEnvOptions);
+    apply(compiler: Compiler): void;
+}

package/denoEnv.js

@@ -0,0 +1,61 @@
+import Webpack from "webpack";
+const NAME = "DenoEnvPlugin";
+const PARSER_TYPES = [
+    "javascript/auto",
+    "javascript/dynamic",
+    "javascript/esm",
+];
+/**
+ * DenoEnvPlugin replaces calls to `Deno.env.get` with a constant expression of environment variable name.
+ */
+export class DenoEnvPlugin {
+    #allowed;
+    constructor(opts = {}) {
+        this.#allowed = [
+            ...opts.allowedEnv ?? [],
+            /^FRESH_PUBLIC_/,
+            "NODE_ENV",
+            "DENO_DEPLOYMENT_ID",
+            "GITHUB_SHA",
+            "CI_COMMIT_SHA",
+            "CI",
+        ];
+    }
+    #isAllowed(name) {
+        return this.#allowed.some((allowed) => allowed instanceof RegExp ? allowed.test(name) : allowed === name);
+    }
+    #value(name, compiler) {
+        if (name === "NODE_ENV") {
+            const mode = compiler.options.mode;
+            if (mode !== undefined && mode !== "none")
+                return mode;
+        }
+        return Deno.env.get(name);
+    }
+    apply(compiler) {
+        compiler.hooks.compilation.tap(NAME, (_compilation, { normalModuleFactory }) => {
+            const handler = (parser) => {
+                parser.hooks.call.for("Deno.env.get").tap(NAME, (expr) => {
+                    const [arg] = expr.arguments;
+                    if (expr.arguments.length !== 1 || arg.type !== "Literal" ||
+                        typeof arg.value !== "string") {
+                        return;
+                    }
+                    const name = arg.value;
+                    if (!this.#isAllowed(name)) {
+                        throw new Error(`Env var is not allowed in bundling: ${name}`);
+                    }
+                    const value = this.#value(name, compiler);
+                    const dep = new Webpack.dependencies.ConstDependency(value === undefined ? "undefined" : JSON.stringify(value), expr.range);
+                    if (expr.loc)
+                        dep.loc = expr.loc;
+                    parser.state.module.addPresentationalDependency(dep);
+                    return true;
+                });
+            };
+            for (const type of PARSER_TYPES) {
+                normalModuleFactory.hooks.parser.for(type).tap(NAME, handler);
+            }
+        });
+    }
+}

package/fresh.d.ts

@@ -0,0 +1,39 @@
+import { type FsRouteFileNoMod } from "@freshpack/core/internal-dev";
+import Webpack from "webpack";
+import { ProdBuildCache } from "@freshpack/core/internal";
+import { type DenoEnvOptions } from "./denoEnv.js";
+import { type RawImportsOptions } from "./rawImports.js";
+interface WebpackFreshCompilation extends Webpack.Compilation {
+    freshRoutes: FsRouteFileNoMod<unknown>[];
+    freshIslands: {
+        entryName: string;
+        filePath: string;
+    }[];
+    freshRoot: string;
+    buildId: string;
+    prodBuildCache: ProdBuildCache<unknown>;
+}
+export declare function assertFreshCompilation(compilation: Webpack.Compilation): asserts compilation is WebpackFreshCompilation;
+export declare class FreshPlugin {
+    #private;
+    baseUrl: URL;
+    importHelper: (path: string) => Promise<Record<string, unknown>>;
+    options: {
+        env?: DenoEnvOptions;
+        rawImports?: RawImportsOptions;
+    };
+    /**
+     * @param baseUrl Location of fresh project root directory, you can specify it as `new URL('.', import.meta.url)` in build.ts
+     * @param importHelper JSR dynamic file import workaround: You should pass `(path) => import(path)` here, where the function
+     *                     should be defined anywhere outside of JSR published package. See this for details: https://github.com/denoland/deno/discussions/26266
+     *                     This function will always be called with absolute path.
+     */
+    constructor(baseUrl: URL, importHelper: (path: string) => Promise<Record<string, unknown>>, options?: {
+        env?: DenoEnvOptions;
+        rawImports?: RawImportsOptions;
+    });
+    pathRelativeToBase(path: string): string;
+    pathRelativeToDist(path: string): string;
+    apply(compiler: Webpack.Compiler): void;
+}
+export {};

package/fresh.js

@@ -0,0 +1,268 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { crawlFsItem, } from "@freshpack/core/internal-dev";
+import Webpack from "webpack";
+import { assertAbsolutePath, assertDirURL, manglePath, stripFileUrl, } from "./util.js";
+import { assert } from "@std/assert";
+import { IslandPreparer, ProdBuildCache } from "@freshpack/core/internal";
+import { extname as extnamePosix, join as joinPosix, relative as relativePosix, } from "@std/path/posix";
+import { contentType as getStdContentType } from "@std/media-types/content-type";
+import { encodeHex } from "@std/encoding";
+import { UnmapPlugin } from "./unmap.js";
+import { DenoEnvPlugin } from "./denoEnv.js";
+import { ViteIgnorePlugin } from "./viteComment.js";
+import { RawImportsPlugin } from "./rawImports.js";
+import { js, toJsRaw } from "./quasiquote.js";
+export function assertFreshCompilation(compilation) {
+    assert("freshRoutes" in compilation && "freshIslands" in compilation &&
+        "freshRoot" in compilation, "missing fresh data in compilation, did you add WebpackFreshEntries plugin?");
+}
+function getMainChunkName(basePath, e) {
+    const entryChunk = e.getEntrypointChunk();
+    const files = [...entryChunk.files].map((v) => joinPosix(basePath, v));
+    return files[0];
+}
+function getChunkFiles(basePath, e) {
+    return e.getFiles().map((v) => joinPosix(basePath, v));
+}
+export class FreshPlugin {
+    baseUrl;
+    importHelper;
+    options;
+    /**
+     * @param baseUrl Location of fresh project root directory, you can specify it as `new URL('.', import.meta.url)` in build.ts
+     * @param importHelper JSR dynamic file import workaround: You should pass `(path) => import(path)` here, where the function
+     *                     should be defined anywhere outside of JSR published package. See this for details: https://github.com/denoland/deno/discussions/26266
+     *                     This function will always be called with absolute path.
+     */
+    constructor(baseUrl, importHelper, options = {}) {
+        this.baseUrl = baseUrl;
+        this.importHelper = importHelper;
+        this.options = options;
+        assertDirURL(this.baseUrl);
+        if (!importHelper) {
+            console.warn("[FreshPlugin]", "importHelper is not set, jsr release of @freshpack/webpack doesn't work without it: https://github.com/denoland/deno/discussions/26266#discussioncomment-12198284");
+            this.importHelper = (path) => import(__rewriteRelativeImportExtension(path));
+        }
+    }
+    pathRelativeToBase(path) {
+        return relativePosix(this.baseUrl.pathname, path);
+    }
+    #dist;
+    pathRelativeToDist(path) {
+        assert(this.#dist, "dist path was not determined yet");
+        return relativePosix(this.#dist, path);
+    }
+    apply(compiler) {
+        {
+            // HACK: Webpack does not export EntryDependency, and it is impossible to use EntryPlugin, as
+            // it wants to modify make stage, yet we have already reached this stage when we want to use
+            // this plugin.
+            //
+            // Solvable by creating custom dependency plugin, or requiring user to manually specify
+            // at least one entry... Or by registering EntryDependency manually as done here.
+            const EntryDependency = Webpack.EntryPlugin.createDependency(`dummy`, {}).constructor;
+            compiler.hooks.compilation.tap(FreshPlugin.name, (compilation, { normalModuleFactory }) => {
+                compilation.dependencyFactories.set(EntryDependency, normalModuleFactory);
+            });
+        }
+        (new UnmapPlugin()).apply(compiler);
+        (new DenoEnvPlugin(this.options.env)).apply(compiler);
+        (new ViteIgnorePlugin()).apply(compiler);
+        (new RawImportsPlugin(this.options.rawImports)).apply(compiler);
+        // Some @std and other packages detect deno on presence of Deno global, dead-code-elimnate this stuff
+        (new Webpack.DefinePlugin({ Deno: "undefined" })).apply(compiler);
+        compiler.hooks.make.tapPromise(FreshPlugin.name, async (_compilation) => {
+            const compilation = _compilation;
+            this.#dist = compilation.outputOptions.path;
+            const compilationId = Date.now().toString(36);
+            // Ensure hot chunks are resolved from correct path, they can't contain compilationId in name
+            compilation.outputOptions.publicPath = "/";
+            {
+                // Chunks are content-addressed in prod, and have readable names using standard fresh cache pruning in dev
+                if (compiler.options.mode === "production") {
+                    compilation.outputOptions.filename =
+                        `_fresh/js/c/[contenthash].mjs`;
+                    compilation.outputOptions.chunkFilename =
+                        `_fresh/js/c/[contenthash].mjs`;
+                    compilation.outputOptions.workerChunkFilename =
+                        `_fresh/js/c/[contenthash].mjs`;
+                }
+                else {
+                    compilation.outputOptions.filename =
+                        `_fresh/js/${compilationId}/[id].mjs`;
+                    compilation.outputOptions.chunkFilename =
+                        `_fresh/js/${compilationId}/[id].mjs`;
+                    compilation.outputOptions.workerChunkFilename =
+                        `_fresh/js/${compilationId}/[id].mjs`;
+                }
+                // Assets are always content-addressed
+                compilation.outputOptions.assetModuleFilename =
+                    `_fresh/js/c/[hash][ext][query]`;
+                compilation.outputOptions.webassemblyModuleFilename =
+                    `_fresh/js/c/[hash].wasm`;
+            }
+            compilation.hooks.processAssets.tapPromise({
+                name: FreshPlugin.name,
+                stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE,
+            }, async (assets) => {
+                compilation.getAssets();
+                const cacheOut = [
+                    js `import{IslandPreparer,ProdBuildCache}from"@freshpack/core/internal"`,
+                    js `const islands=new Map()`,
+                    js `const islandPreparer=new IslandPreparer()`,
+                ];
+                const staticFiles = new Map();
+                const islands = new Map();
+                const islandPreparer = new IslandPreparer();
+                for (const island of compilation.freshIslands) {
+                    const entrypoint = compilation.entrypoints.get(island.entryName);
+                    assert(entrypoint, `unable to find island entrypoint: ${island.entryName}`);
+                    const file = getMainChunkName(`/`, entrypoint);
+                    islandPreparer.prepare(islands, await this.importHelper(island.filePath), file, island.entryName, []);
+                    const importPath = this.pathRelativeToDist(island.filePath);
+                    cacheOut.push(js `islandPreparer.prepare(islands,await import(${importPath}),${file},${island.entryName},[])`);
+                }
+                const fsRoutesOut = [];
+                const fsRoutes = await Promise.all(compilation.freshRoutes.map(async (v) => {
+                    const importPath = this.pathRelativeToDist(v.filePath);
+                    fsRoutesOut.push(toJsRaw({
+                        id: v.id,
+                        mod: v.lazy
+                            ? js `()=>import(${importPath})`
+                            : js `await import(${importPath})`,
+                        type: v.type,
+                        pattern: v.pattern,
+                        routePattern: v.routePattern,
+                    }));
+                    assertAbsolutePath(v.filePath);
+                    return {
+                        ...v,
+                        mod: v.lazy
+                            ? () => this.importHelper(v.filePath)
+                            : await this.importHelper(v.filePath),
+                    };
+                }));
+                cacheOut.push(js `const fsRoutes=${fsRoutesOut}`);
+                const clientEntrypoint = compilation.entrypoints.get("client-entry");
+                assert(clientEntrypoint, `unable to find client entrypoint`);
+                const clientEntry = getMainChunkName(`/`, clientEntrypoint);
+                const clientEntryAssets = getChunkFiles(`/`, clientEntrypoint);
+                const staticFilesOut = new Map();
+                for (const _asset of compilation.getAssets()) {
+                    const asset = compilation.getAsset(_asset.name);
+                    const file_ = assets[asset.name]
+                        .buffer();
+                    const file = file_;
+                    const hash = await crypto.subtle.digest("SHA-1", file.buffer);
+                    const ext = extnamePosix(asset.name);
+                    const contentType = getStdContentType(ext) ?? "text/plain";
+                    const name = "/" + asset.name;
+                    staticFiles.set(name, {
+                        name,
+                        filePath: asset.name,
+                        contentType,
+                        hash: encodeHex(hash),
+                        data: file,
+                        size: file.length,
+                    });
+                    staticFilesOut.set(name, toJsRaw({
+                        name,
+                        filePath: js `new URL(${asset.name}, import.meta.url).pathname`,
+                        hash: encodeHex(hash),
+                        contentType,
+                    }));
+                }
+                cacheOut.push(js `const staticFiles=${staticFilesOut}`);
+                cacheOut.push(js `export default new ProdBuildCache(${compilation.freshRoot}, ${({
+                    version: compilationId,
+                    clientEntry,
+                    entryAssets: toJsRaw(clientEntryAssets),
+                    islands: js `islands`,
+                    fsRoutes: js `fsRoutes`,
+                    staticFiles: js `staticFiles`,
+                })})`);
+                // Here ProdBuildCache is being used as MemoryBuildCache from fresh
+                const cache = new ProdBuildCache(compilation.freshRoot, {
+                    version: compilationId,
+                    clientEntry,
+                    fsRoutes,
+                    staticFiles,
+                    islands,
+                    entryAssets: clientEntryAssets,
+                });
+                cache.readFile = (pathname) => {
+                    const st = staticFiles.get(pathname);
+                    if (!st) {
+                        return Promise.resolve(null);
+                    }
+                    return Promise.resolve({
+                        contentType: st.contentType,
+                        hash: st.hash,
+                        readable: new ReadableStream({
+                            start(v) {
+                                v.enqueue(st.data);
+                                v.close();
+                            },
+                        }),
+                        size: st.size,
+                        close() { },
+                    });
+                };
+                compilation.prodBuildCache = cache;
+                compilation.emitAsset("./cache.mjs", new compiler.webpack.sources.RawSource(cacheOut.map((v) => v._jsRaw).join("\n")));
+            });
+            const item = await crawlFsItem({
+                islandDir: stripFileUrl(new URL("islands", this.baseUrl).href),
+                routeDir: stripFileUrl(new URL("routes", this.baseUrl).href),
+                ignore: [],
+            });
+            compilation.freshRoutes = item.routes;
+            compilation.freshIslands = [];
+            compilation.freshRoot = this.pathRelativeToBase(".");
+            const addEntryPromises = [];
+            let isId = 0;
+            for (const island of item.islands) {
+                const name = compiler.options.mode === "production"
+                    ? `is${isId++}`
+                    : manglePath(island);
+                compilation.freshIslands.push({ entryName: name, filePath: island });
+                addEntryPromises.push(new Promise((res, rej) => compilation.addEntry("", Webpack.EntryPlugin.createDependency(`${island}`, {
+                    name,
+                }), {
+                    name,
+                    library: {
+                        type: "module",
+                    },
+                }, (err) => {
+                    if (err)
+                        return rej(err);
+                    res();
+                })));
+            }
+            {
+                const name = "client-entry";
+                const file = stripFileUrl(new URL("./client.ts", this.baseUrl).href);
+                addEntryPromises.push(new Promise((res, rej) => compilation.addEntry("", Webpack.EntryPlugin.createDependency(file, {
+                    name,
+                }), {
+                    name,
+                    library: {
+                        type: "module",
+                    },
+                }, (e) => {
+                    if (e)
+                        return rej(e);
+                    res();
+                })));
+            }
+            await Promise.all(addEntryPromises);
+        });
+    }
+}

package/mod.d.ts

@@ -0,0 +1,7 @@
+export { DenoEnvPlugin } from "./denoEnv.js";
+export { FreshPlugin } from "./fresh.js";
+export { ViteIgnorePlugin } from "./viteComment.js";
+export { DenoPreactRefreshPlugin } from "./prefresh-forked/index.js";
+export { DenoLoaderPlugin } from "./resolve.js";
+export { type RawImportsOptions, RawImportsPlugin } from "./rawImports.js";
+export { UnmapPlugin } from "./unmap.js";

package/mod.js

@@ -0,0 +1,7 @@
+export { DenoEnvPlugin } from "./denoEnv.js";
+export { FreshPlugin } from "./fresh.js";
+export { ViteIgnorePlugin } from "./viteComment.js";
+export { DenoPreactRefreshPlugin } from "./prefresh-forked/index.js";
+export { DenoLoaderPlugin } from "./resolve.js";
+export { RawImportsPlugin } from "./rawImports.js";
+export { UnmapPlugin } from "./unmap.js";

package/package.json

@@ -1,22 +1,74 @@
 {
   "name": "@freshpack/webpack",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "type": "module",
   "exports": {
-    ".": "./mod.ts",
-    "./fresh": "./fresh.ts",
-    "./util": "./util.ts",
-    "./unmap": "./unmap.ts",
-    "./requireHook": "./requireHook.ts"
+    ".": {
+      "types": "./mod.d.ts",
+      "default": "./mod.js"
+    },
+    "./fresh": {
+      "types": "./fresh.d.ts",
+      "default": "./fresh.js"
+    },
+    "./util": {
+      "types": "./util.d.ts",
+      "default": "./util.js"
+    },
+    "./unmap": {
+      "types": "./unmap.d.ts",
+      "default": "./unmap.js"
+    },
+    "./requireHook": {
+      "types": "./requireHook.d.ts",
+      "default": "./requireHook.js"
+    }
   },
   "dependencies": {
     "@deno/loader": "npm:@jsr/deno__loader@^0.5.0",
-    "@freshpack/core": "3.0.1",
+    "@freshpack/core": "3.0.2",
     "@prefresh/utils": "^1.2.1",
     "@std/assert": "npm:@jsr/std__assert@^1.0.19",
     "@std/encoding": "npm:@jsr/std__encoding@^1.0.11",
     "@std/media-types": "npm:@jsr/std__media-types@^1.1.0",
     "@std/path": "npm:@jsr/std__path@^1.1.6",
     "webpack": "^5.111.1"
-  }
+  },
+  "files": [
+    "denoEnv.d.ts",
+    "denoEnv.js",
+    "fresh.d.ts",
+    "fresh.js",
+    "mod.d.ts",
+    "mod.js",
+    "prefresh-forked/index.d.ts",
+    "prefresh-forked/index.js",
+    "prefresh-forked/loader/index.d.ts",
+    "prefresh-forked/loader/index.js",
+    "prefresh-forked/loader/runtime.js",
+    "prefresh-forked/utils/Runtime.d.ts",
+    "prefresh-forked/utils/Runtime.js",
+    "prefresh-forked/utils/constants.d.ts",
+    "prefresh-forked/utils/constants.js",
+    "prefresh-forked/utils/prefresh.d.ts",
+    "prefresh-forked/utils/prefresh.js",
+    "quasiquote.d.ts",
+    "quasiquote.js",
+    "rawBytesLoader.d.ts",
+    "rawBytesLoader.js",
+    "rawImports.d.ts",
+    "rawImports.js",
+    "requireHook.d.ts",
+    "requireHook.js",
+    "resolve.d.ts",
+    "resolve.js",
+    "transpileLoader.d.ts",
+    "transpileLoader.js",
+    "unmap.d.ts",
+    "unmap.js",
+    "util.d.ts",
+    "util.js",
+    "viteComment.d.ts",
+    "viteComment.js"
+  ]
 }

package/prefresh-forked/index.d.ts

@@ -0,0 +1,15 @@
+import Webpack from "webpack";
+type Options = {
+    overlay?: {
+        module: string;
+    };
+    entryOptions?: string | Webpack.EntryOptions;
+};
+export declare class DenoPreactRefreshPlugin {
+    options: Options;
+    matcher: (str: string) => boolean;
+    constructor(options: Options);
+    webpack5(compiler: Webpack.Compiler, RuntimeGlobals: typeof Webpack.RuntimeGlobals): void;
+    apply(compiler: Webpack.Compiler): void;
+}
+export {};

package/prefresh-forked/index.js

@@ -0,0 +1,57 @@
+/* FIXME: Typings are awful in this file, the port was very crude */
+import Webpack from "webpack";
+import { injectRefreshFunctions, matcherOptions, NAME, prefreshUtils, } from "./utils/constants.js";
+import { PrefreshRuntimeModule } from "./utils/Runtime.js";
+import { defineRequire } from "../requireHook.js";
+const internalPrefreshLoader = defineRequire("@freshpack/webpack/internal-prefresh-loader", await import("./loader/index.js"));
+export class DenoPreactRefreshPlugin {
+    options;
+    matcher;
+    constructor(options) {
+        this.options = options;
+        this.matcher = Webpack.ModuleFilenameHelpers.matchObject.bind(undefined, matcherOptions);
+    }
+    webpack5(compiler, RuntimeGlobals) {
+        compiler.hooks.compilation.tap(NAME, (compilation, { normalModuleFactory }) => {
+            if (compilation.compiler !== compiler) {
+                return;
+            }
+            injectRefreshFunctions(compilation);
+            compilation.hooks.additionalTreeRuntimeRequirements.tap(NAME, (chunk, runtimeRequirements) => {
+                runtimeRequirements.add(RuntimeGlobals.interceptModuleExecution);
+                compilation.addRuntimeModule(chunk, new PrefreshRuntimeModule());
+            });
+            normalModuleFactory.hooks.afterResolve.tap(NAME, ({ createData: data }) => {
+                if (this.matcher(data.resource) &&
+                    !data.resource.includes("@prefresh") &&
+                    !data.resource.includes("/prefresh-forked/loader/") &&
+                    !data.resource.includes("/prefresh-forked/utils/")) {
+                    data.loaders.unshift({
+                        loader: internalPrefreshLoader,
+                        options: undefined,
+                    });
+                }
+            });
+        });
+    }
+    apply(compiler) {
+        if (compiler.options.mode === "production") {
+            return;
+        }
+        const provide = {
+            [prefreshUtils]: import.meta.resolve("./utils/prefresh.js"),
+        };
+        if (this.options.overlay) {
+            provide.__prefresh_errors__ = import.meta.resolve(this.options.overlay.module);
+        }
+        const providePlugin = new Webpack.ProvidePlugin(provide);
+        providePlugin.apply(compiler);
+        const dependency = Webpack.EntryPlugin.createDependency("@prefresh/core", { name: "@prefresh/core" });
+        compiler.hooks.make.tapAsync(NAME, (compilation, callback) => {
+            compilation.addEntry(compiler.context, dependency, this.options.entryOptions ?? {}, callback);
+        });
+        this.webpack5(compiler, compiler.webpack
+            ? compiler.webpack.RuntimeGlobals
+            : Webpack.RuntimeGlobals);
+    }
+}

package/prefresh-forked/loader/index.d.ts

@@ -0,0 +1,2 @@
+import type Webpack from "webpack";
+export default function RefreshHotLoader(this: any, source: Webpack.sources.SourceMapSource, inputSourceMap: Webpack.sources.SourceMapSource["source"]): void;

package/prefresh-forked/loader/index.js

@@ -0,0 +1,4 @@
+import runtimeText from "./runtime.js" with { type: "text" };
+export default function RefreshHotLoader(source, inputSourceMap) {
+    this.callback(null, source + "\n\n" + runtimeText, inputSourceMap);
+}

package/prefresh-forked/utils/Runtime.d.ts

@@ -0,0 +1,5 @@
+import Webpack from "webpack";
+export declare class PrefreshRuntimeModule extends Webpack.RuntimeModule {
+    constructor();
+    generate(): string;
+}