@freshpack/webpack 1.0.1 → 1.0.2

package/resolve.js

@@ -1,4 +1,4 @@
-import { RequestedModuleType, ResolutionMode, Workspace, } from "@deno/loader";
+import { RequestedModuleType, ResolutionMode, Workspace } from "@deno/loader";
 import { assert, unreachable } from "@std/assert";
 import Webpack from "webpack";
 import { Buffer } from "node:buffer";
@@ -8,398 +8,388 @@ 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 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);
         }
-    };
-    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;
-        },
-    };
+      } 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;
+  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);
-        }
+  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;
+  } 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);
-            });
+  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);
         }
-        // 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;
-        // });
+        // 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);
-            }
+  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";
+  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";
+  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);
+  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());
+  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 = [];
     }
-    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);
+    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 = [];
     }
-    apply(compiler) {
-        if (compiler.options.resolve.plugins === undefined) {
-            compiler.options.resolve.plugins = [];
+    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;
         }
-        assert(Array.isArray(compiler.options.resolve.plugins));
-        compiler.options.resolve.plugins.push(new FixupResolvePlugin());
-        if (compiler.options.resolveLoader.plugins === undefined) {
-            compiler.options.resolveLoader.plugins = [];
+        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;
         }
-        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 = [];
+      });
+      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);
         }
-        if (!compiler.options.output.enabledLibraryTypes.includes("module")) {
-            compiler.options.output.enabledLibraryTypes.push("module");
+      });
+      const hooks = compiler.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);
         }
-        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);
-                }
-            });
-        });
-    }
+      });
+    });
+  }
 }
+//# sourceMappingURL=resolve.js.map