@freshpack/webpack 0.0.0-stage → 1.0.1

package/resolve.js

@@ -0,0 +1,405 @@
+import { RequestedModuleType, ResolutionMode, Workspace, } from "@deno/loader";
+import { assert, unreachable } from "@std/assert";
+import Webpack from "webpack";
+import { Buffer } from "node:buffer";
+import { ensureModPath, stripFileUrl } from "./util.js";
+import { dirname } from "@std/path";
+import { defineRequire } from "./requireHook.js";
+import { registerDenoLoader } from "./transpileLoader.js";
+const internalTranspileLoader = defineRequire("@freshpack/webpack/internal-deno-transpile-loader", await import("./transpileLoader.js"));
+function resolverSpan(logSuccess, name, ...args) {
+    let isResolved;
+    let timeoutId = setTimeout(() => {
+        console.error("[RESOLVE]", "possibly stuck at", name, ...args);
+        if (isResolved !== undefined) {
+            console.error("         ", "...but it was resolved:", ...isResolved);
+        }
+    }, 5000);
+    const cancelStuck = () => {
+        if (timeoutId !== undefined) {
+            clearTimeout(timeoutId);
+            timeoutId = undefined;
+        }
+    };
+    let postponed = false;
+    return {
+        simplify(...newArgs) {
+            args = newArgs;
+        },
+        errored(e, ...err) {
+            cancelStuck();
+            console.error("[RESOLVE]", "errored", name, ...args, "=>", e, ...err);
+        },
+        resolved(...out) {
+            cancelStuck();
+            if (isResolved === undefined) {
+                isResolved = out;
+                if (logSuccess) {
+                    console.info("[RESOLVE]", name, ...args, "=>", ...out);
+                }
+            }
+            else {
+                console.error("[RESOLVE]", "resolved twice", name, ...args, "=>", ...out);
+                console.error("         ", "...previously resolved to:", ...isResolved);
+            }
+        },
+        [Symbol.dispose]() {
+            if (postponed)
+                return;
+            cancelStuck();
+            if (isResolved === undefined) {
+                console.error("[RESOLVE]", "missing resolved() call!", name, ...args);
+            }
+        },
+        postpone() {
+            postponed = true;
+        },
+    };
+}
+const MATCH_RESOURCE = /^([^!]+)!=!/;
+function requestedModuleType(type) {
+    if (type === "asset/source")
+        return RequestedModuleType.Text;
+    if (type.startsWith("asset/"))
+        return RequestedModuleType.Bytes;
+    return RequestedModuleType.Default;
+}
+async function simpleDenoResolve(loader, issuer, request, esm) {
+    const matchResource = MATCH_RESOURCE.exec(request);
+    if (matchResource) {
+        const resolved = await simpleDenoResolve(loader, issuer, request.slice(matchResource[0].length), esm);
+        return `${matchResource[0]}${resolved}`;
+    }
+    let resolution;
+    if (request.startsWith("/") && issuer.startsWith("https://")) {
+        resolution = new URL(request, new URL(issuer).origin).href;
+    }
+    else if (request.startsWith("/")) {
+        resolution = `file://${request}`;
+    }
+    else if (request === ".") {
+        resolution = `file://${dirname(issuer)}`;
+    }
+    else {
+        resolution = await loader.resolve(request, issuer, esm ? ResolutionMode.Import : ResolutionMode.Require);
+    }
+    if (resolution.startsWith("node:")) {
+        // PASS: Fallback or external
+    }
+    else if (resolution.startsWith("https:")) {
+        // PASS: https loader
+    }
+    else if (resolution.startsWith("file:")) {
+        if (issuer.startsWith("https://")) {
+            // PASS: Disambiguate origin-relative,
+            // we don't want to convert /home/user/.cache/deno/npm/.../file.ts imported from
+            // https://esm.sh to become https://esm.sh/home/user/...
+        }
+        else {
+            resolution = stripFileUrl(resolution);
+        }
+    }
+    else {
+        assert(false, `unexpected resolution: ${resolution}`);
+    }
+    return resolution;
+}
+class FixupResolvePlugin {
+    apply(resolver) {
+        const resolved = resolver.getHook("resolved");
+        for (const hook of ["resolve", "internal-resolve"]) {
+            resolver.getHook(hook).tapAsync({
+                name: "Ignore https requests",
+                stage: -100000,
+            }, (req, ctx, cb) => {
+                if (req.path && req.path.startsWith("https://") && req.request === "." ||
+                    req.request && req.request.startsWith("https://")) {
+                    return resolver.doResolve(resolved, req, "context resolve", ctx, cb);
+                }
+                // console.log("DIR RESOLVE!!!", req);
+                return cb(null);
+                // return cb(null, ...args);
+            });
+        }
+        // resolver.hooks.result.tap({
+        //   name: "resolvers in https requests",
+        //   stage: -100000,
+        // }, (req, ctx) => {
+        //   console.log("post resolve", req);
+        //   return;
+        // });
+        // resolver.hooks.resolve.tap({ name: "Fixup" }, (req) => {
+        //   console.log('fixup resolver', req.request);
+        //   return req;
+        // });
+    }
+}
+class DenoResolvePlugin {
+    jsr;
+    constructor(jsr) {
+        this.jsr = jsr;
+    }
+    apply(resolver) {
+        // console.log("HOOKS", resolver.hooks);
+        const source = resolver.getHook("resolve");
+        const target = resolver.getHook("resolved");
+        source.tapAsync({ name: "Deno" }, async (request, ctx, cb) => {
+            using span = resolverSpan(this.jsr.opts.debug, "deno resolver", request, ctx);
+            try {
+                const loader = await this.jsr.loader;
+                let requestIssuer;
+                if (request.context && "issuer" in request.context) {
+                    const issuer = request.context.issuer;
+                    assert(typeof issuer === "string" || issuer === null, "invalid context issuer");
+                    if (issuer !== "" && issuer !== null) {
+                        requestIssuer = issuer;
+                    }
+                }
+                if (requestIssuer === undefined && request.path) {
+                    requestIssuer = ensureModPath(request.path);
+                }
+                assert(requestIssuer !== undefined, "failed to determine requestIssuer");
+                const requestRequest = request.request;
+                assert(requestRequest !== undefined, "failed to determine requestRequest");
+                span.simplify(requestIssuer, requestRequest);
+                const resolution = await simpleDenoResolve(loader, requestIssuer, requestRequest, request.module ?? true);
+                const resolvedPath = resolution.startsWith("file://")
+                    ? stripFileUrl(resolution)
+                    : resolution;
+                return resolver.doResolve(target, Object.assign({}, request, {
+                    path: resolvedPath,
+                    request: undefined,
+                }), `resolved by deno ${request.request} (from ${request.path})`, ctx, (err, result) => {
+                    span.resolved("doResolve result", resolution, err, result);
+                    if (err !== undefined || result !== undefined) {
+                        return cb(err, result);
+                    }
+                    cb(null, null);
+                });
+            }
+            catch (e) {
+                span.errored(e, request, ctx);
+                cb(e, null);
+            }
+        });
+    }
+}
+async function fillResourceData(data, loader, url) {
+    data.__resolvedByFreshpack = { data, url, loaded: undefined };
+    if (url.protocol === "file:") {
+        data.resource = url.pathname;
+        data.path = url.pathname;
+        data.data.path = url.pathname;
+        data.context = dirname(url.pathname);
+    }
+    else {
+        const loaded = await loader.load(url.href, RequestedModuleType.Default);
+        data.__resolvedByFreshpack.loaded = loaded;
+        data.resource = loaded.specifier;
+        data.path = loaded.specifier;
+        data.data.path = loaded.specifier;
+        data.context = new URL(".", url).href.slice(0, -1);
+    }
+    data.query = url.search;
+    data.data.query = url.search;
+    data.fragment = url.hash;
+    // data.type = "application/javascript";
+}
+function breakResourceData(data) {
+    data.path = "error";
+    data.context = "error";
+    data.resource = "error";
+}
+function ensurePluginList(resolver, list, append) {
+    if (resolver[list] === undefined) {
+        resolver[list] = [];
+    }
+    assert(Array.isArray(resolver[list]));
+    resolver[list].push(append);
+}
+export class DenoLoaderPlugin {
+    opts;
+    patchImport;
+    workspace;
+    #transpileLoaderId;
+    #loader;
+    get loader() {
+        return (this.#loader ??= this.workspace.createLoader());
+    }
+    constructor(opts, patchImport = (_, v) => v) {
+        this.opts = opts;
+        this.patchImport = patchImport;
+        opts.noTranspile = false;
+        opts.preserveJsx = false;
+        opts.platform = "browser";
+        this.workspace = new Workspace(opts);
+        this.#transpileLoaderId = registerDenoLoader(() => this.loader);
+    }
+    apply(compiler) {
+        if (compiler.options.resolve.plugins === undefined) {
+            compiler.options.resolve.plugins = [];
+        }
+        assert(Array.isArray(compiler.options.resolve.plugins));
+        compiler.options.resolve.plugins.push(new FixupResolvePlugin());
+        if (compiler.options.resolveLoader.plugins === undefined) {
+            compiler.options.resolveLoader.plugins = [];
+        }
+        assert(Array.isArray(compiler.options.resolveLoader.plugins));
+        compiler.options.resolveLoader.plugins.push(new DenoResolvePlugin(this));
+        compiler.options.resolve.modules = [];
+        compiler.options.resolve.roots = [];
+        compiler.options.resolve.descriptionFiles = [];
+        compiler.options.resolveLoader.modules = [];
+        compiler.options.resolveLoader.descriptionFiles = [];
+        compiler.options.externalsPresets.web = false;
+        compiler.options.externalsPresets.webAsync = false;
+        if (!compiler.options.output.enabledLibraryTypes) {
+            compiler.options.output.enabledLibraryTypes = [];
+        }
+        if (!compiler.options.output.enabledLibraryTypes.includes("module")) {
+            compiler.options.output.enabledLibraryTypes.push("module");
+        }
+        compiler.options.output.library = { type: "module" };
+        compiler.options.output.module = true;
+        compiler.options.experiments.outputModule =
+            true;
+        // Deno provides its own type-stripping when no ts loader is present
+        // It is not required since deno-loader handles typescript.
+        compiler.options.experiments.typescript = false;
+        compiler.hooks.compilation.tap("JsrPlugin", (compilation, { normalModuleFactory }) => {
+            normalModuleFactory.hooks.afterResolve.tap("JsrPlugin", ({ createData: data }) => {
+                const resource = data.resource;
+                if (resource === undefined || resource.includes("://") ||
+                    !/\.[cm]?[jt]sx?$/.test(resource)) {
+                    return;
+                }
+                data.loaders.push({
+                    loader: internalTranspileLoader,
+                    options: { id: this.#transpileLoaderId },
+                    ident: null,
+                    type: null,
+                });
+            });
+            normalModuleFactory.hooks.beforeResolve.tapPromise("JsrPlugin", async (resolveData) => {
+                using span = resolverSpan(this.opts.debug, "jsr beforeResolve", resolveData);
+                try {
+                    // try {
+                    const loader = await this.loader;
+                    let requestIssuer;
+                    if (resolveData.contextInfo.issuer !== "") {
+                        requestIssuer = resolveData.contextInfo.issuer;
+                    }
+                    if (requestIssuer === undefined || requestIssuer === null) {
+                        requestIssuer = ensureModPath(resolveData.context);
+                    }
+                    assert(requestIssuer != undefined, "failed to determine request issuer");
+                    let requestRequest = resolveData.request;
+                    const dependencyType = resolveData.dependencyType;
+                    span.simplify({
+                        requestIssuer,
+                        requestRequest,
+                        dependencyType,
+                    });
+                    if (requestRequest.startsWith("data:") ||
+                        requestRequest.startsWith("https:") &&
+                            !requestRequest.startsWith("https://jsr.io/")) {
+                        // IDK why those requests even land in this method in some circumstances, returning false
+                        // here makes them being processed by the handlers below. Most probably I'm missing something,
+                        // or this webpack api is not intended for such huge loaded replacements.
+                        span.resolved("delegate-builtin");
+                        return false;
+                    }
+                    if (dependencyType === "url" &&
+                        // new URL() references are always relative, but import.meta.resolve() takes import specifiers.
+                        resolveData.dependencies[0]?.type !== "import.meta.resolve()") {
+                        requestRequest = "./" + requestRequest;
+                    }
+                    requestRequest = this.patchImport(requestIssuer, requestRequest);
+                    const resolution = await simpleDenoResolve(loader, requestIssuer, requestRequest, true);
+                    span.resolved(resolution);
+                    resolveData.request = this.patchImport(requestIssuer, resolution);
+                }
+                catch (e) {
+                    span.errored(e);
+                    throw e;
+                }
+            });
+            normalModuleFactory.hooks.resolveForScheme.for("node").tapPromise("JsrPlugin", async (resourceData, resolveData) => {
+                using span = resolverSpan(this.opts.debug, "node resolveForScheme", resolveData.request);
+                resourceData.path = false;
+                resourceData.data.path = false;
+                span.resolved("stubbed: empty module");
+                return true;
+            });
+            normalModuleFactory.hooks.resolveForScheme.for("jsr").tapPromise("JsrPlugin", async (resourceData, resolveData) => {
+                using span = resolverSpan(this.opts.debug, "jsr resolveForScheme", resolveData);
+                breakResourceData(resourceData);
+                unreachable("jsr should be resolved to https by deno resolver");
+            });
+            normalModuleFactory.hooks.resolveForScheme.for("npm").tapPromise("JsrPlugin", async (resourceData, resolveData) => {
+                using span = resolverSpan(this.opts.debug, "npm resolveForScheme", resolveData);
+                breakResourceData(resourceData);
+                unreachable("npm should be resolved to files by deno resolver");
+            });
+            normalModuleFactory.hooks.resolveForScheme.for("https").tapPromise("JsrPlugin", async (resourceData, resolveData) => {
+                using span = resolverSpan(this.opts.debug, "https resolveForScheme", resolveData.request);
+                const loader = await this.loader;
+                // const newResourceData = {...resourceData};
+                await fillResourceData(resourceData, loader, new URL(resolveData.request));
+                span.resolved("done");
+                return true;
+            });
+            normalModuleFactory.hooks.resolveInScheme.for("https").tapPromise("JsrPlugin", async (resourceData, data) => {
+                using span = resolverSpan(this.opts.debug, "https resolveInScheme", resourceData, data.contextInfo, data.request);
+                try {
+                    const loader = await this.loader;
+                    const requestRequest = data.request;
+                    if (requestRequest.startsWith("/")) {
+                        const requestIssuer = data.contextInfo.issuer;
+                        assert(requestIssuer && requestIssuer.startsWith("https://"), `unexpected /-prefixed request without https:// issuer: ${requestRequest}`);
+                        const issuerUrl = new URL(requestIssuer);
+                        const resolved = new URL(requestRequest, issuerUrl.origin);
+                        span.resolved("origin-relative url", resolved.href);
+                        await fillResourceData(resourceData, loader, resolved);
+                        return true;
+                    }
+                    else {
+                        const requestIssuer = data.contextInfo.issuer;
+                        assert(requestIssuer !== "");
+                        const resolved = await loader.resolve(requestRequest, requestIssuer, ResolutionMode.Import);
+                        span.resolved("url resolved", resolved);
+                        assert(resolved.startsWith("https:"));
+                        await fillResourceData(resourceData, loader, new URL(resolved));
+                        return true;
+                    }
+                }
+                catch (e) {
+                    span.errored(e);
+                    breakResourceData(resourceData);
+                }
+            });
+            const hooks = Webpack.NormalModule.getCompilationHooks(compilation);
+            hooks.readResourceForScheme.for("node").tapAsync("JsrPlugin", async (_resource, _module, cb) => {
+                cb(null, Buffer.from("module.exports = {};"));
+            });
+            hooks.readResourceForScheme.for("jsr").tapPromise("JsrPlugin", async (resource, module) => {
+                using span = resolverSpan(this.opts.debug, "jsr loadResourceForScheme", resource);
+                unreachable("jsr should be resolved to https by deno resolver");
+            });
+            hooks.readResourceForScheme.for("https").tapAsync("JsrPlugin", async (resource, module, cb) => {
+                using span = resolverSpan(this.opts.debug, "https readResourceForScheme", resource, module.type);
+                try {
+                    const loader = await this.loader;
+                    const loaded = await loader.load(resource, requestedModuleType(module.type));
+                    // TODO: Should import assertions be handled somehow?
+                    span.resolved(loaded);
+                    cb(null, Buffer.from(loaded.code));
+                }
+                catch (e) {
+                    span.errored(e);
+                    cb(e);
+                }
+            });
+        });
+    }
+}

package/transpileLoader.d.ts

@@ -0,0 +1,9 @@
+import { type Loader } from "@deno/loader";
+import type { LoaderContext } from "webpack";
+type Options = {
+    id: number;
+};
+type Context = LoaderContext<Options>;
+export declare function registerDenoLoader(get: () => Promise<Loader>): number;
+export default function denoTranspileLoader(this: Context, _source: string): void;
+export {};

package/transpileLoader.js

@@ -0,0 +1,38 @@
+import { RequestedModuleType } from "@deno/loader";
+import { toFileUrl } from "@std/path";
+const registry = new Map();
+let nextId = 0;
+export function registerDenoLoader(get) {
+    const id = nextId++;
+    registry.set(id, get);
+    return id;
+}
+const INLINE_SOURCE_MAP = /\n?\/\/# sourceMappingURL=data:application\/json;base64,([A-Za-z0-9+/=]+)[\t ]*$/;
+function splitSourceMap(code) {
+    const match = INLINE_SOURCE_MAP.exec(code);
+    if (!match)
+        return { code, map: undefined };
+    return {
+        code: code.slice(0, match.index),
+        map: JSON.parse(atob(match[1])),
+    };
+}
+export default function denoTranspileLoader(_source) {
+    const callback = this.async();
+    const { id } = this.getOptions();
+    const get = registry.get(id);
+    if (!get) {
+        callback(new Error(`deno loader ${id} is not registered`));
+        return;
+    }
+    const resourcePath = this.resourcePath;
+    (async () => {
+        const loader = await get();
+        const specifier = toFileUrl(resourcePath).href;
+        const loaded = await loader.load(specifier, RequestedModuleType.Default);
+        if (loaded.kind !== "module") {
+            throw new Error(`deno loader returned ${loaded.kind} for ${specifier}`);
+        }
+        return splitSourceMap(new TextDecoder().decode(loaded.code));
+    })().then(({ code, map }) => callback(null, code, map), (e) => callback(e));
+}

package/unmap.d.ts

@@ -0,0 +1,9 @@
+import type * as Webpack from "webpack";
+interface UnmapCompilation extends Webpack.Compilation {
+    unmapping: Record<string, string>;
+}
+export declare function assertUnmapCompilation(compilation: Webpack.Compilation): asserts compilation is UnmapCompilation;
+export declare class UnmapPlugin {
+    apply(compiler: Webpack.Compiler): void;
+}
+export {};

package/unmap.js

@@ -0,0 +1,96 @@
+import { assert } from "@std/assert";
+export function assertUnmapCompilation(compilation) {
+    assert("unmapping" in compilation, "missing fresh data in compilation, did you add WebpackFreshEntries plugin?");
+}
+export class UnmapPlugin {
+    apply(compiler) {
+        const mappings = new Map();
+        const nameToRequest = new Map();
+        const nameToAsset = new Map();
+        compiler.hooks.compilation.tap(UnmapPlugin.name, (compilation, { normalModuleFactory }) => {
+            normalModuleFactory.hooks.parser.for("javascript/auto").tap(UnmapPlugin.name, (parser) => {
+                parser.hooks.call.for("unmap").tap(UnmapPlugin.name, (expr) => {
+                    const error = (msg) => {
+                        const err = new compiler.webpack.WebpackError(msg);
+                        err.loc = expr.loc;
+                        parser.state.module.addError(err);
+                    };
+                    if (expr.arguments.length !== 2) {
+                        return error(`unmap requires (name, new URL()) arguments`);
+                    }
+                    const nameArg = parser.evaluateExpression(expr.arguments[0]);
+                    if (!nameArg.isString()) {
+                        return error(`first argument for unmap should be a static string`);
+                    }
+                    const urlExpr = expr.arguments[1];
+                    if (urlExpr.type !== "NewExpression" ||
+                        urlExpr.callee.type !== "Identifier" ||
+                        urlExpr.callee.name !== "URL") {
+                        return error(`second argument for unmap should be new URL() expression`);
+                    }
+                    const key = `${parser.state.module.identifier()}:${urlExpr.range[0]}`;
+                    mappings.set(key, {
+                        name: nameArg.string,
+                        module: parser.state.module,
+                        loc: expr.loc,
+                    });
+                });
+            });
+            compilation.hooks.afterOptimizeModules.tap(UnmapPlugin.name, () => {
+                for (const module of compilation.modules) {
+                    if (!module.dependencies)
+                        return;
+                    for (const dep of module.dependencies) {
+                        if (dep.constructor.name !== "URLDependency")
+                            continue;
+                        const dep_ = dep;
+                        const key = `${module.identifier()}:${dep_.outerRange[0]}`;
+                        const name = mappings.get(key);
+                        if (!name)
+                            continue;
+                        const error = (msg) => {
+                            const err = new compiler.webpack.WebpackError(msg);
+                            err.module = name.module;
+                            err.loc = name.loc;
+                            compilation.errors.push(err);
+                        };
+                        const connection = compilation.moduleGraph.getConnection(dep);
+                        if (!connection || !connection.module) {
+                            error("unable to find connection for url dependency");
+                            continue;
+                        }
+                        const mod = connection.module;
+                        const request = mod.resource ?? mod.userRequest;
+                        if (!request) {
+                            error(`unable to resolve unmap request`);
+                            continue;
+                        }
+                        {
+                            const oldV = nameToRequest.get(name.name);
+                            if (oldV !== undefined && oldV !== request) {
+                                error(`ResolutionConflict: unmap(${JSON.stringify(name.name)}, ${JSON.stringify(request)}) was previously resolved to ${oldV}, use a different unmapping`);
+                                continue;
+                            }
+                        }
+                        nameToRequest.set(name.name, request);
+                    }
+                }
+            });
+            compilation.hooks.processAssets.tap(UnmapPlugin.name, (assets) => {
+                for (const [name, request] of nameToRequest.entries()) {
+                    for (const [assetName, _asset] of Object.entries(assets)) {
+                        const info = compilation.assetsInfo.get(assetName);
+                        if (info?.sourceFilename && request.endsWith(info.sourceFilename)) {
+                            nameToAsset.set(name, assetName);
+                            break;
+                        }
+                    }
+                }
+                const unmapping = Object.fromEntries(nameToAsset);
+                const json = JSON.stringify(unmapping);
+                compilation.emitAsset("mapped.json", new compiler.webpack.sources.RawSource(json));
+                compilation.unmapping = unmapping;
+            });
+        });
+    }
+}

package/util.d.ts

@@ -0,0 +1,9 @@
+export declare function stripFileUrl(u: string): string;
+export declare function resolveNpm(u: string): string;
+export declare function manglePath(path: string): string;
+export declare function assertAbsolutePath(path: string): void;
+export declare function assertDirURL(path: URL): void;
+export declare function ensureModPath(path: string): string;
+export declare function ensureFilePath(path: string): string;
+export declare function assertResolved(path: string): void;
+export declare function ensureFileUrl(path: string): URL;

package/util.js

@@ -0,0 +1,54 @@
+import { assert } from "@std/assert";
+export function stripFileUrl(u) {
+    assert(u.startsWith("file://"), `not a file url: ${u}`);
+    return u.slice(7);
+}
+export function resolveNpm(u) {
+    const path = import.meta.resolve(`npm:${u}`);
+    return stripFileUrl(path);
+}
+export function manglePath(path) {
+    const tokens = path.replaceAll(/\\/g, "/").split(/([^a-zA-Z0-9_]+)/).filter((s) => s);
+    return "_" + tokens.map((s) => {
+        if (/^[a-zA-Z0-9_]+$/.test(s)) {
+            return s.length + s;
+        }
+        return s.split("").map((c) => "_" + c.charCodeAt(0).toString(16)).join("");
+    }).join("");
+}
+export function assertAbsolutePath(path) {
+    // TODO: Windows
+    assert(path.startsWith("/"), `path is not absolute: ${path}`);
+}
+export function assertDirURL(path) {
+    const stat = Deno.statSync(path);
+    assert(stat.isDirectory, `path is not a directory: ${path}`);
+}
+export function ensureModPath(path) {
+    if (path.endsWith("/fakeMod.ts"))
+        return path;
+    if (!path.startsWith("https://")) {
+        const stat = Deno.statSync(path);
+        if (stat.isFile)
+            return path;
+        assert(stat.isDirectory, `path is not a directory: ${path}`);
+    }
+    if (path.endsWith(".ts") || path.endsWith(".js") || path.endsWith(".mjs")) {
+        return path;
+    }
+    if (!path.endsWith("/"))
+        path += "/fakeMod.ts";
+    return path;
+}
+export function ensureFilePath(path) {
+    const stat = Deno.statSync(path);
+    assert(stat.isFile, `path is not a file: ${path}`);
+    assert(!path.endsWith("/"), "file paths shouldn't end with /");
+    return path;
+}
+export function assertResolved(path) {
+    assert(path.startsWith("https://"), `path is not https: ${path}`);
+}
+export function ensureFileUrl(path) {
+    return new URL(`file://${ensureFilePath(path)}`);
+}

package/viteComment.d.ts

@@ -0,0 +1,8 @@
+import type { Compiler } from "webpack";
+/**
+ * ViteIgnorePlugin skips parsing of `import` calls that contain `@vite-inore` in inline comment, similarly
+ * to webpack built-in `webpackIgnore: true` annotation
+ */
+export declare class ViteIgnorePlugin {
+    apply(compiler: Compiler): void;
+}

package/viteComment.js

@@ -0,0 +1,30 @@
+const NAME = "ViteIgnorePlugin";
+const PARSER_TYPES = [
+    "javascript/auto",
+    "javascript/dynamic",
+    "javascript/esm",
+];
+/**
+ * ViteIgnorePlugin skips parsing of `import` calls that contain `@vite-inore` in inline comment, similarly
+ * to webpack built-in `webpackIgnore: true` annotation
+ */
+export class ViteIgnorePlugin {
+    apply(compiler) {
+        compiler.hooks.compilation.tap(NAME, (_compilation, { normalModuleFactory }) => {
+            const handler = (parser) => {
+                parser.hooks.importCall.tap({ name: NAME, stage: -10 }, (expr) => {
+                    const ignored = parser.getComments([
+                        expr.range[0],
+                        expr.source.range[1],
+                    ]).some((comment) => comment.type === "Block" &&
+                        comment.value.includes("@vite-ignore"));
+                    if (ignored)
+                        return false;
+                });
+            };
+            for (const type of PARSER_TYPES) {
+                normalModuleFactory.hooks.parser.for(type).tap(NAME, handler);
+            }
+        });
+    }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.