@templmf/temp-solf-lmf 0.0.127 → 0.0.129

package/esm.sh/server/utils.go

@@ -0,0 +1,191 @@
+package server
+
+import (
+	"encoding/base64"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/Masterminds/semver/v3"
+	"github.com/ije/gox/valid"
+)
+
+// isJsReservedWord returns true if the given string is a reserved word in JavaScript.
+func isJsReservedWord(word string) bool {
+	switch word {
+	case "abstract", "arguments", "await", "boolean", "break", "byte", "case", "catch", "char", "class", "const", "continue", "debugger", "default", "delete", "do", "double", "else", "enum", "eval", "export", "extends", "false", "final", "finally", "float", "for", "function", "goto", "if", "implements", "import", "in", "instanceof", "int", "interface", "let", "long", "native", "new", "null", "package", "private", "protected", "public", "return", "short", "static", "super", "switch", "synchronized", "this", "throw", "throws", "transient", "true", "try", "typeof", "var", "void", "volatile", "while", "with", "yield":
+		return true
+	}
+	return false
+}
+
+// isJsIdentifier returns true if the given string is a valid JavaScript identifier.
+func isJsIdentifier(s string) bool {
+	if len(s) == 0 {
+		return false
+	}
+	leadingChar := s[0]
+	if !((leadingChar >= 'a' && leadingChar <= 'z') || (leadingChar >= 'A' && leadingChar <= 'Z') || leadingChar == '_' || leadingChar == '$') {
+		return false
+	}
+	for i := 1; i < len(s); i++ {
+		c := s[i]
+		if !((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_' || c == '$') {
+			return false
+		}
+	}
+	return true
+}
+
+// isCommitish returns true if the given string is a commit hash.
+func isCommitish(s string) bool {
+	return len(s) >= 7 && len(s) <= 40 && valid.IsHexString(s)
+}
+
+// isNodeBuiltinSpecifier checks if the given specifier is a node.js built-in module.
+func isNodeBuiltinSpecifier(specifier string) bool {
+	return strings.HasPrefix(specifier, "node:") && nodeBuiltinModules[specifier[5:]]
+}
+
+// isJsonModuleSpecifier returns true if the specifier is a json module.
+func isJsonModuleSpecifier(specifier string) bool {
+	return strings.HasSuffix(specifier, ".json")
+}
+
+// isHttpSpecifier returns true if the specifier is a remote URL.
+func isHttpSpecifier(specifier string) bool {
+	return strings.HasPrefix(specifier, "https://") || strings.HasPrefix(specifier, "http://")
+}
+
+// isRelPathSpecifier returns true if the specifier is a local path.
+func isRelPathSpecifier(specifier string) bool {
+	return strings.HasPrefix(specifier, "./") || strings.HasPrefix(specifier, "../")
+}
+
+// semverLessThan returns true if the version a is less than the version b.
+func semverLessThan(a string, b string) bool {
+	va, err1 := semver.NewVersion(a)
+	if err1 != nil {
+		return false
+	}
+	vb, err2 := semver.NewVersion(b)
+	return err2 == nil && va.LessThan(vb)
+}
+
+// endsWith returns true if the given string ends with any of the suffixes.
+func endsWith(s string, suffixs ...string) bool {
+	for _, suffix := range suffixs {
+		if strings.HasSuffix(s, suffix) {
+			return true
+		}
+	}
+	return false
+}
+
+// existsDir returns true if the given path is a directory.
+func existsDir(filepath string) bool {
+	fi, err := os.Lstat(filepath)
+	return err == nil && fi.IsDir()
+}
+
+// existsFile returns true if the given path is a file.
+func existsFile(filepath string) bool {
+	fi, err := os.Lstat(filepath)
+	return err == nil && !fi.IsDir()
+}
+
+// ensureDir creates a directory if it does not exist.
+func ensureDir(dir string) (err error) {
+	_, err = os.Lstat(dir)
+	if err != nil && os.IsNotExist(err) {
+		err = os.MkdirAll(dir, 0755)
+	}
+	return
+}
+
+// relPath returns a relative path from the base path to the target path.
+func relPath(basePath, targetPath string) (string, error) {
+	rp, err := filepath.Rel(basePath, targetPath)
+	if err == nil && !isRelPathSpecifier(rp) {
+		rp = "./" + rp
+	}
+	return rp, err
+}
+
+// findFiles returns a list of files in the given directory.
+func findFiles(root string, dir string, filter func(filename string) bool) ([]string, error) {
+	rootDir, err := filepath.Abs(root)
+	if err != nil {
+		return nil, err
+	}
+	entries, err := os.ReadDir(rootDir)
+	if err != nil {
+		return nil, err
+	}
+	var files []string
+	for _, entry := range entries {
+		name := entry.Name()
+		filename := name
+		if dir != "" {
+			filename = dir + "/" + name
+		}
+		if entry.IsDir() {
+			if name == "node_modules" {
+				continue
+			}
+			subFiles, err := findFiles(filepath.Join(rootDir, name), filename, filter)
+			if err != nil {
+				return nil, err
+			}
+			newFiles := make([]string, len(files)+len(subFiles))
+			copy(newFiles, files)
+			copy(newFiles[len(files):], subFiles)
+			files = newFiles
+		} else {
+			if filter(filename) {
+				files = append(files, filename)
+			}
+		}
+	}
+	return files, nil
+}
+
+// btoaUrl converts a string to a base64 string.
+func btoaUrl(s string) string {
+	return base64.RawURLEncoding.EncodeToString([]byte(s))
+}
+
+// atobUrl converts a base64 string to a string.
+func atobUrl(s string) (string, error) {
+	data, err := base64.RawURLEncoding.DecodeString(s)
+	if err != nil {
+		return "", err
+	}
+	return string(data), nil
+}
+
+// appendVaryHeader appends the given key to the `Vary` header.
+func appendVaryHeader(header http.Header, key string) {
+	vary := header.Get("Vary")
+	if vary == "" {
+		header.Set("Vary", key)
+	} else {
+		header.Set("Vary", vary+", "+key)
+	}
+}
+
+// concatBytes concatenates two byte slices.
+func concatBytes(a, b []byte) []byte {
+	al, bl := len(a), len(b)
+	if al == 0 {
+		return b[0:]
+	}
+	if bl == 0 {
+		return a[0:]
+	}
+	c := make([]byte, al+bl)
+	copy(c, a)
+	copy(c[al:], b)
+	return c
+}

package/esm.sh/test/.template/deno.json

@@ -0,0 +1,5 @@
+{
+  "imports": {
+    "esm.sh/": "http://localhost:8080/"
+  }
+}

package/esm.sh/test/.template/test.ts

@@ -0,0 +1,11 @@
+import { assert, assertEquals, assertStringIncludes } from "jsr:@std/assert";
+
+// change the import path to the module you want to test
+import * as mod from "esm.sh/PKG[@SEMVER][/PATH]";
+
+// related issue: https://github.com/esm-dev/esm.sh/issues/ISSUE_NUMBER
+Deno.test("testing name", async () => {
+  assert("foo" in mod);
+  assertEquals(typeof mod.foo, "function");
+  assertStringIncludes(mod.foo(), "bar");
+});

package/esm.sh/test/bad-url/test.ts

@@ -0,0 +1,16 @@
+import { assertEquals } from "jsr:@std/assert";
+
+const badUrls = [
+  "http://localhost:8080/wp-admin.php",
+  "http://localhost:8080/.well-known/appspecific/com.chrome.devtools.json",
+  "http://localhost:8080/.env",
+  "http://localhost:8080/react@18.0.1/../../../../../../../../../../etc/passwd?raw=1&module=1",
+];
+
+Deno.test("ban bad urls", async () => {
+  for (const url of badUrls) {
+    const res = await fetch(url);
+    await res.body?.cancel();
+    assertEquals(res.status, 404, url);
+  }
+});

package/esm.sh/test/bootstrap.ts

@@ -0,0 +1,153 @@
+#!/usr/bin/env -S deno run --allow-run --allow-read --allow-write --allow-net
+
+async function startServer(onStart: () => Promise<void>) {
+  const { code, success } = await run("go", "build", "-tags", "debug", "-o", "esmd", "server/esmd/main.go");
+  if (!success) {
+    Deno.exit(code);
+  }
+  let configJson = {};
+  try {
+    configJson = JSON.parse(await Deno.readTextFile("config.json"));
+  } catch {
+    // ignore
+  }
+  await Deno.writeTextFile(
+    "config.json",
+    JSON.stringify(
+      {
+        "port": 8080,
+        "workDir": ".esmd",
+        ...configJson,
+      },
+      undefined,
+      2,
+    ),
+  );
+  const p = new Deno.Command("./esmd", {
+    stdout: Deno.args.includes("-q") ? "null" : "inherit",
+    stderr: "inherit",
+  }).spawn();
+  addEventListener("unload", () => {
+    console.log("%cClosing esm.sh server...", "color: grey");
+    p.kill("SIGINT");
+  });
+  await new Promise<void>((resolve, reject) => {
+    (async () => {
+      while (true) {
+        try {
+          await new Promise((resolve) => setTimeout(resolve, 100));
+          const status = await fetch("http://localhost:8080/status.json").then(res => res.json());
+          if (status.version) {
+            console.log("esm.sh server started.");
+            onStart();
+            resolve();
+            break;
+          }
+        } catch {
+          // continue
+        }
+      }
+    })();
+    setTimeout(() => reject(new Error("Timeout")), 15000);
+  });
+  await p.status;
+}
+
+async function runTest(name: string, retry?: boolean): Promise<number> {
+  const execBegin = Date.now();
+  const args = [
+    "test",
+    "-A",
+    "--unstable-fs",
+    "--check",
+    "--no-lock",
+    "--reload=http://localhost:8080",
+    "--location=http://0.0.0.0/",
+    "-q",
+  ].filter(Boolean);
+  const dir = `test/${name}/`;
+  if (await exists(dir + "deno.json")) {
+    args.push("--config", dir + "deno.json");
+  }
+  args.push(dir);
+  console.log(`\n[test ${name}]`);
+  const { code, success } = await run(Deno.execPath(), ...args);
+  if (!success) {
+    if (!retry) {
+      console.log("something wrong, retry...");
+      await new Promise((resolve) => setTimeout(resolve, 500));
+      return await runTest(name, true);
+    } else {
+      Deno.exit(code);
+    }
+  }
+  return Date.now() - execBegin;
+}
+
+function run(name: string, ...args: string[]) {
+  const p = new Deno.Command(name, {
+    args,
+    stdout: "inherit",
+    stderr: "inherit",
+  }).spawn();
+  return p.status;
+}
+
+async function exists(path: string): Promise<boolean> {
+  try {
+    await Deno.lstat(path);
+    return true;
+  } catch (err) {
+    if (err instanceof Deno.errors.NotFound) {
+      return false;
+    }
+    throw err;
+  }
+}
+
+if (import.meta.main) {
+  Deno.chdir(new URL("../", import.meta.url).pathname);
+  const tests = Deno.args.filter((arg) => !arg.startsWith("-"));
+  for (const testDir of tests) {
+    if (!(await exists(`test/${testDir}`))) {
+      console.error(`Test directory "${testDir}" not found.`);
+      Deno.exit(1);
+    }
+  }
+  try {
+    console.log("Cleaning up...");
+    await Promise.all([
+      Deno.remove(".esmd/storage", { recursive: true }),
+      Deno.remove(".esmd/log", { recursive: true }),
+    ]);
+  } catch (_) {
+    // ignore
+  }
+  console.log("Starting esm.sh server...");
+  startServer(async () => {
+    let timeUsed = 0;
+    if (tests.length > 0) {
+      for (const testDir of tests) {
+        timeUsed += await runTest(testDir, true);
+      }
+    } else {
+      const dirs: string[] = [];
+      for await (const entry of Deno.readDir("./test")) {
+        if (entry.isDirectory && !entry.name.startsWith("_") && !entry.name.startsWith(".")) {
+          dirs.push(entry.name);
+        }
+      }
+      for (const dir of dirs.sort()) {
+        timeUsed += await runTest(dir);
+      }
+    }
+    timeUsed = Math.ceil(timeUsed / 1000);
+    console.log("Heap usage:");
+    await run("go", "tool", "pprof", "-top", "http://localhost:8080/debug/pprof/heap");
+    console.log(
+      `Done! Total time spent: %c${Math.floor(timeUsed / 60)}m${timeUsed % 60}s`,
+      "color: blue",
+    );
+    Deno.exit(0);
+  });
+}

package/esm.sh/test/build-args/alias.test.ts

@@ -0,0 +1,11 @@
+import { assertEquals, assertStringIncludes } from "jsr:@std/assert";
+
+Deno.test("types with ?alias", async () => {
+  const res = await fetch(
+    `http://localhost:8080/@emotion/styled@11.11.5/X-YXJlYWN0OnByZWFjdC9jb21wYXQKZHByZWFjdEAxMC42LjY/types/base.d.ts`,
+  );
+  assertEquals(res.status, 200);
+  assertEquals(res.headers.get("Content-type"), "application/typescript; charset=utf-8");
+  const ts = await res.text();
+  assertStringIncludes(ts, "preact@10.6.6/compat/src/index.d.ts");
+});

package/esm.sh/test/build-args/bundle.test.ts

@@ -0,0 +1,28 @@
+import { assertEquals, assertStringIncludes } from "jsr:@std/assert";
+
+Deno.test("?bundle", async () => {
+  const res = await fetch("http://localhost:8080/buffer@6.0.3?bundle&target=es2022");
+  res.body?.cancel();
+  assertEquals(res.headers.get("x-esm-path")!, "/buffer@6.0.3/es2022/buffer.bundle.mjs");
+  const res2 = await fetch(new URL(res.headers.get("x-esm-path")!, "http://localhost:8080"));
+  assertStringIncludes(await res2.text(), `"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"`);
+});
+
+Deno.test("?bundle&external", async () => {
+  const res = await fetch("http://localhost:8080/ajv@8.12.0?bundle&external=fast-deep-equal");
+  res.body?.cancel();
+  assertStringIncludes(res.headers.get("x-esm-path")!, "/X-ZWZhc3QtZGVlcC1lcXVhbA/");
+  assertStringIncludes(res.headers.get("x-esm-path")!, "/ajv.bundle.mjs");
+  const res2 = await fetch(new URL(res.headers.get("x-esm-path")!, "http://localhost:8080"));
+  assertStringIncludes(await res2.text(), `from"fast-deep-equal"`);
+});
+
+Deno.test("?bundle=false", async () => {
+  const res = await fetch("http://localhost:8080/@pyscript/core@0.3.4/dist/py-terminal-XWbSa71s?bundle=false&target=es2022");
+  res.body?.cancel();
+  assertEquals(res.headers.get("x-esm-path")!, "/@pyscript/core@0.3.4/es2022/dist/py-terminal-XWbSa71s.nobundle.mjs");
+  const res2 = await fetch(new URL(res.headers.get("x-esm-path")!, "http://localhost:8080"));
+  const code = await res2.text();
+  assertStringIncludes(code, "./core.nobundle.mjs");
+  assertStringIncludes(code, "./error-96hMSEw8.nobundle.mjs");
+});

package/esm.sh/test/build-args/deps.test.ts

@@ -0,0 +1,42 @@
+import { assert, assertStringIncludes } from "jsr:@std/assert";
+
+Deno.test("?deps", async () => {
+  {
+    const res = await fetch("http://localhost:8080/@mui/material@5.16.7?deps=react@18.2.0,react-dom@18.2.0&target=es2022");
+    const code = await res.text();
+    assertStringIncludes(code, 'import "/react-dom@18.2.0/X-ZHJlYWN0QDE4LjIuMA/es2022/react-dom.mjs"');
+    assertStringIncludes(code, 'import "/react@18.2.0/es2022/jsx-runtime.mjs"');
+    assertStringIncludes(code, 'import "/react@18.2.0/es2022/react.mjs"');
+    assertStringIncludes(code, 'import "/react-transition-group@^4.4.5?deps=react-dom@18.2.0,react@18.2.0&target=es2022"');
+    assertStringIncludes(code, 'export * from "/@mui/material@5.16.7/X-ZHJlYWN0LWRvbUAxOC4yLjAscmVhY3RAMTguMi4w/es2022/material.mjs"');
+    assertStringIncludes(code, 'import "/@mui/system@^5.16.7/createTheme?deps=react@18.2.0&target=es2022"');
+    assertStringIncludes(code, 'import "/@mui/utils@^5.16.6/useTimeout?deps=react@18.2.0&target=es2022"');
+  }
+  {
+    const res = await fetch("http://localhost:8080/@mui/material@5.16.7/X-ZHJlYWN0LWRvbUAxOC4yLjAscmVhY3RAMTguMi4w/es2022/material.mjs");
+    const code = await res.text();
+    assertStringIncludes(code, 'from"/react-dom@18.2.0/X-ZHJlYWN0QDE4LjIuMA/es2022/react-dom.mjs"');
+    assertStringIncludes(code, 'from"/react@18.2.0/es2022/jsx-runtime.mjs"');
+    assertStringIncludes(code, 'from"/react@18.2.0/es2022/react.mjs"');
+    assertStringIncludes(code, 'from"/react-transition-group@^4.4.5?deps=react-dom@18.2.0,react@18.2.0&target=es2022"');
+    assertStringIncludes(code, 'from"/@mui/system@^5.16.7/createTheme?deps=react@18.2.0&target=es2022"');
+    assertStringIncludes(code, 'from"/@mui/utils@^5.16.6/useTimeout?deps=react@18.2.0&target=es2022"');
+  }
+});
+
+Deno.test("?deps in TypeScript types", async () => {
+  const res = await fetch("http://localhost:8080/@mui/material@5.16.7?deps=react@18.2.0,react-dom@18.2.0&target=es2022");
+  res.body?.cancel();
+  const dtsUrl = res.headers.get("x-typescript-types");
+  assert(dtsUrl, "X-TypeScript-Types header should be present");
+  assertStringIncludes(dtsUrl, "/X-", "DTS URL should include X-<hash> encoded build args");
+
+  const dtsRes = await fetch(dtsUrl);
+  const dtsCode = await dtsRes.text();
+  assertStringIncludes(dtsCode, "@mui/utils", "DTS should import from @mui/utils");
+  assertStringIncludes(
+    dtsCode,
+    "@mui/utils@5.17.1/X-",
+    "Child @mui/utils dependency should include X-<hash> with react deps encoded",
+  );
+});

package/esm.sh/test/build-args/dev.test.ts

@@ -0,0 +1,17 @@
+import { assertStringIncludes } from "jsr:@std/assert";
+
+Deno.test("?dev", async () => {
+  const res = await fetch("http://localhost:8080/react@18.2.0?dev&target=es2022");
+  assertStringIncludes(await res.text(), `"/react@18.2.0/es2022/react.development.mjs"`);
+
+  const code = await fetch("http://localhost:8080/react@18.2.0/es2022/react.development.mjs").then((res) => res.text());
+  assertStringIncludes(code, "react/cjs/react.development.js");
+});
+
+Deno.test("using `development` condition in `exports`", async () => {
+  const code2 = await fetch("http://localhost:8080/solid-js@1.6.16/es2022/solid-js.development.mjs").then((res) => res.text());
+  assertStringIncludes(
+    code2,
+    `console.warn("You appear to have multiple instances of Solid. This can lead to unexpected behavior.")`,
+  );
+});

package/esm.sh/test/build-args/exports.test.ts

@@ -0,0 +1,25 @@
+import { assert, assertEquals, assertStringIncludes } from "jsr:@std/assert";
+
+import * as tslib from "http://localhost:8080/tslib?exports=__await,__spread";
+
+Deno.test("?exports", () => {
+  assertEquals(Object.keys(tslib), ["__await", "__spread"]);
+});
+
+Deno.test("?exports no imports", async () => {
+  {
+    const res = await fetch("http://localhost:8080/effect@3.19.16?exports=Effect", { headers: { "User-Agent": "i'm a browser" } });
+    assertEquals(res.status, 200);
+    const text = await res.text();
+    assert(!text.includes('import "'));
+    assertStringIncludes(text, 'export * from "/effect@3.19.16/es2022/effect.mjs?exports=Effect"');
+  }
+  {
+    const res = await fetch("http://localhost:8080/effect@3.19.16/es2022/effect.mjs?exports=Effect", {
+      headers: { "User-Agent": "i'm a browser" },
+    });
+    assertEquals(res.status, 200);
+    const text = await res.text();
+    assertEquals(text.trim(), 'import*as r from"./Effect.mjs";export{r as Effect};');
+  }
+});

package/esm.sh/test/build-args/external.test.ts

@@ -0,0 +1,113 @@
+import { assertEquals, assertStringIncludes } from "jsr:@std/assert";
+
+Deno.test("`?external` query", async () => {
+  {
+    const res = await fetch("http://localhost:8080/react-dom@18.3.1?external=react");
+    assertStringIncludes(await res.text(), '"/react-dom@18.3.1/X-ZXJlYWN0/denonext/react-dom.mjs"');
+  }
+  {
+    const res = await fetch("http://localhost:8080/preact@10.23.2/hooks?external=preact");
+    assertStringIncludes(await res.text(), '"/preact@10.23.2/X-ZXByZWFjdA/denonext/hooks.mjs"');
+  }
+  {
+    const res = await fetch("http://localhost:8080/*preact@10.23.2/jsx-runtime");
+    assertStringIncludes(await res.text(), '"/*preact@10.23.2/denonext/jsx-runtime.mjs"');
+  }
+  {
+    const res = await fetch("http://localhost:8080/*preact@10.23.2/denonext/jsx-runtime.mjs");
+    assertStringIncludes(await res.text(), 'from"preact"');
+  }
+  {
+    const res = await fetch("http://localhost:8080/*preact@10.23.2/denonext/hooks.mjs");
+    assertStringIncludes(await res.text(), 'from"preact"');
+  }
+  {
+    // react-dom?external=react
+    const res = await fetch("http://localhost:8080/react-dom@19.0.0/X-ZXJlYWN0/es2022/client.mjs");
+    const code = await res.text();
+    assertStringIncludes(code, 'from"react"');
+    assertStringIncludes(code, 'from"./react-dom.mjs');
+    assertStringIncludes(code, 'from"/scheduler@');
+  }
+  {
+    // react-dom?external=react,react-dom
+    const res = await fetch("http://localhost:8080/react-dom@19.0.0/X-ZXJlYWN0LHJlYWN0LWRvbQ/es2022/client.mjs");
+    const code = await res.text();
+    assertStringIncludes(code, 'from"react"');
+    assertStringIncludes(code, 'from"react-dom"');
+    assertStringIncludes(code, 'from"/scheduler@');
+  }
+  {
+    // react-dom?external=react,react-dom,scheduler
+    const res = await fetch("http://localhost:8080/react-dom@19.0.0/X-ZXJlYWN0LHJlYWN0LWRvbSxzY2hlZHVsZXI/es2022/client.mjs");
+    const code = await res.text();
+    assertStringIncludes(code, 'from"react"');
+    assertStringIncludes(code, 'from"react-dom"');
+    assertStringIncludes(code, 'from"scheduler"');
+  }
+  {
+    const res = await fetch("http://localhost:8080/*react-dom@19.0.0/es2022/client.mjs");
+    const code = await res.text();
+    assertStringIncludes(code, 'from"react"');
+    assertStringIncludes(code, 'from"react-dom"');
+    assertStringIncludes(code, 'from"scheduler"');
+  }
+  {
+    const res = await fetch("http://localhost:8080/react-dom@19.0.0/client?external=react,react-dom,scheduler");
+    assertStringIncludes(await res.text(), '"/react-dom@19.0.0/X-ZXJlYWN0LHJlYWN0LWRvbSxzY2hlZHVsZXI/denonext/client.mjs"');
+  }
+  {
+    const res = await fetch("http://localhost:8080/react-dom@19.0.0/client?external=react,scheduler,react-dom");
+    assertStringIncludes(await res.text(), '"/react-dom@19.0.0/X-ZXJlYWN0LHJlYWN0LWRvbSxzY2hlZHVsZXI/denonext/client.mjs"');
+  }
+  {
+    const res = await fetch("http://localhost:8080/react-dom@19.0.0/client?external=scheduler,react,react-dom");
+    assertStringIncludes(await res.text(), '"/react-dom@19.0.0/X-ZXJlYWN0LHJlYWN0LWRvbSxzY2hlZHVsZXI/denonext/client.mjs"');
+  }
+  // https://github.com/esm-dev/esm.sh/issues/1101
+  {
+    const res = await fetch("http://localhost:8080/htm@3.1.1/preact?external=preact");
+    assertStringIncludes(await res.text(), '"/htm@3.1.1/X-ZXByZWFjdA/denonext/preact.mjs"');
+  }
+});
+
+Deno.test("types with `?external`", async () => {
+  const res = await fetch("http://localhost:8080/swr@1.3.0/X-ZXJlYWN0/dist/use-swr.d.ts");
+  assertEquals(res.status, 200);
+  assertEquals(res.headers.get("Content-type"), "application/typescript; charset=utf-8");
+  const ts = await res.text();
+  assertStringIncludes(ts, '/// <reference types="react" />');
+  assertStringIncludes(ts, 'import("react")');
+});
+
+Deno.test("external nodejs builtin modules", async () => {
+  const res = await fetch("http://localhost:8080/cheerio@0.22.0/es2022/cheerio.mjs");
+  assertEquals(res.status, 200);
+  assertStringIncludes(await res.text(), ` from "/node/buffer.mjs"`);
+
+  const res2 = await fetch("http://localhost:8080/cheerio@0.22.0?target=es2022&external=node:buffer");
+  res2.body?.cancel();
+  assertEquals(res2.status, 200);
+  const res3 = await fetch("http://localhost:8080" + res2.headers.get("x-esm-path"));
+  assertEquals(res3.status, 200);
+  assertStringIncludes(await res3.text(), ` from "node:buffer"`);
+});
+
+Deno.test("external namespace packages", async () => {
+  // Test that using @radix-ui as external marks all @radix-ui/* packages as external
+  {
+    const res = await fetch("http://localhost:8080/@radix-ui/react-dropdown-menu@2.0.5?external=@radix-ui");
+    res.body?.cancel();
+    assertEquals(res.status, 200);
+    const modulePath = res.headers.get("x-esm-path");
+    const res2 = await fetch("http://localhost:8080" + modulePath);
+    const code = await res2.text();
+    // All @radix-ui packages should be external
+    assertStringIncludes(code, 'from"@radix-ui/react-compose-refs"');
+    assertStringIncludes(code, 'from"@radix-ui/react-context"');
+    assertStringIncludes(code, 'from"@radix-ui/react-id"');
+    assertStringIncludes(code, 'from"@radix-ui/react-menu"');
+    assertStringIncludes(code, 'from"@radix-ui/react-primitive"');
+    assertStringIncludes(code, 'from"@radix-ui/react-use-controllable-state"');
+  }
+});

package/esm.sh/test/build-args/package-css.test.ts

@@ -0,0 +1,13 @@
+import { assert, assertEquals } from "jsr:@std/assert";
+
+Deno.test("package css", async () => {
+  const res = await fetch("http://localhost:8080/monaco-editor@0.40.0?css&target=es2022", { redirect: "manual" });
+  assertEquals(res.status, 301);
+  assertEquals(res.headers.get("location"), "http://localhost:8080/monaco-editor@0.40.0/es2022/monaco-editor.css");
+  res.body?.cancel();
+
+  const res2 = await fetch("http://localhost:8080/monaco-editor@0.40.0/es2022/monaco-editor.css", { redirect: "manual" });
+  assert(!res2.redirected);
+  assertEquals(res2.headers.get("content-type"), "text/css; charset=utf-8");
+  res2.body?.cancel();
+});