@markless/bundler 0.9.0 → 0.10.0

package/dist/build-worker.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/build-worker.js

@@ -0,0 +1,59 @@
+import { a as writeCompileStoreEntry, t as compileStoreEntry } from "./compile-store-DxF9Vj4_.js";
+import { serialize } from "node:v8";
+import { parentPort } from "node:worker_threads";
+import { clearCompileCache, compileTsrxModule } from "@markless/compiler";
+//#region src/build-worker.ts
+let chunkTasks;
+let chunkAst;
+parentPort.on("message", async (job) => {
+	if (job.kind === "chunk") await runChunkJob(job);
+	else await runCompileJob(job);
+});
+async function runChunkJob({ id, task, fileName, code, context }) {
+	chunkTasks ??= import("./chunk-tasks-BexSGNjx.js");
+	chunkAst ??= import("./chunk-ast-C8zKZiam.js");
+	const [{ runChunkTaskInline }, { clearParsedChunkCode }] = await Promise.all([chunkTasks, chunkAst]);
+	try {
+		parentPort.postMessage({
+			id,
+			result: runChunkTaskInline(task, fileName, code, context)
+		});
+	} catch (error) {
+		parentPort.postMessage({
+			id,
+			error: error instanceof Error ? error.stack ?? error.message : String(error)
+		});
+	} finally {
+		clearParsedChunkCode();
+	}
+}
+async function runCompileJob({ id, input, key, store }) {
+	let bytes;
+	try {
+		bytes = serialize(await compileTsrxModule(input));
+	} catch {
+		parentPort.postMessage({
+			id,
+			failed: true
+		});
+		return;
+	} finally {
+		clearCompileCache();
+	}
+	const storePath = store ? compileStoreEntry(store.directory, store.fingerprint, input.source, key).path : void 0;
+	const copy = storePath === void 0 ? void 0 : new Uint8Array(bytes);
+	parentPort.postMessage({
+		id,
+		buffer: bytes.buffer,
+		offset: bytes.byteOffset,
+		length: bytes.byteLength
+	}, [bytes.buffer]);
+	if (copy && storePath) {
+		await writeCompileStoreEntry(storePath, copy);
+		parentPort.postMessage({
+			id,
+			written: true
+		});
+	}
+}
+//#endregion

package/dist/chunk-ast-C8zKZiam.js

@@ -0,0 +1 @@
+export { t as PARSED_CHUNK_CACHE_MAX_CODE_LENGTH, n as PARSED_CHUNK_CACHE_MAX_ENTRIES, r as calleeOffsets, i as chunkDynamicImports, a as chunkLocalExportSpecifiers, o as clearChunkFactCaches, s as clearParsedChunkCode, c as knowsChunkDynamicImports, l as mayContainDynamicImport, u as parseChunkCode, d as prefetchChunkParses, f as readChunkDynamicImports, p as readChunkLocalExportSpecifiers, m as rememberChunkDynamicImports, h as rememberChunkLocalExportSpecifiers, g as renderedChunkCount, _ as spansAnyOffset, v as textOffsets } from "./chunk-ast-pN_P5wIo.js";

package/dist/chunk-ast-pN_P5wIo.js

@@ -0,0 +1,204 @@
+import { parse, parseSync } from "rolldown/experimental";
+//#region src/build/chunk-ast.ts
+const UNNAMED_CHUNK = "chunk.js";
+const parsedByExtension = /* @__PURE__ */ new Map();
+const PARSED_CHUNK_CACHE_MAX_CODE_LENGTH = 16777216;
+const PARSED_CHUNK_CACHE_MAX_ENTRIES = 1024;
+let cachedCodeLength = 0;
+let cachedEntries = 0;
+const codeByFile = /* @__PURE__ */ new Map();
+function parsedFor(fileName) {
+	const extension = fileName.slice(fileName.lastIndexOf("."));
+	let parsed = parsedByExtension.get(extension);
+	if (!parsed) parsedByExtension.set(extension, parsed = /* @__PURE__ */ new Map());
+	return parsed;
+}
+const renderedChunkCounts = /* @__PURE__ */ new WeakMap();
+function renderedChunkCount(chunks) {
+	let count = renderedChunkCounts.get(chunks);
+	if (count === void 0) renderedChunkCounts.set(chunks, count = Object.keys(chunks).length);
+	return count;
+}
+function forgetSuperseded(fileName, code) {
+	const previous = codeByFile.get(fileName);
+	if (previous === void 0 || previous === code) return;
+	if (parsedFor(fileName).delete(previous)) {
+		cachedCodeLength -= previous.length;
+		cachedEntries--;
+	}
+	codeByFile.delete(fileName);
+}
+function admits(fileName, code) {
+	if (fileName !== UNNAMED_CHUNK) forgetSuperseded(fileName, code);
+	return cachedEntries < 1024 && cachedCodeLength + code.length <= 16777216;
+}
+function remember(fileName, code, result) {
+	const parsed = parsedFor(fileName);
+	if (parsed.has(code) || cachedEntries >= 1024) return;
+	if (fileName !== UNNAMED_CHUNK) codeByFile.set(fileName, code);
+	parsed.set(code, result);
+	cachedCodeLength += code.length;
+	cachedEntries++;
+}
+function parseChunkCode(fileName, code) {
+	const cached = parsedFor(fileName).get(code);
+	if (cached) return cached;
+	const result = parseSync(fileName, code);
+	if (admits(fileName, code)) remember(fileName, code, result);
+	return result;
+}
+async function prefetchChunkParses(chunks) {
+	const pending = [];
+	let reserved = 0;
+	let reservedEntries = 0;
+	for (const { fileName, code } of chunks) {
+		if (parsedFor(fileName).has(code)) continue;
+		if (!admits(fileName, code) || cachedEntries + reservedEntries >= 1024 || cachedCodeLength + reserved + code.length > 16777216) continue;
+		reserved += code.length;
+		reservedEntries++;
+		pending.push(parse(fileName, code).then((result) => remember(fileName, code, result), () => {}));
+	}
+	await Promise.all(pending);
+}
+function clearParsedChunkCode() {
+	parsedByExtension.clear();
+	clearChunkFactCaches();
+	codeByFile.clear();
+	cachedCodeLength = 0;
+	cachedEntries = 0;
+}
+function mayContainDynamicImport(code) {
+	for (let index = code.indexOf("import"); index >= 0; index = code.indexOf("import", index + 1)) {
+		const next = nextTokenStart(code, index + 6);
+		if (next < 0 || code[next] === "(") return true;
+	}
+	return false;
+}
+function calleeOffsets(code, name) {
+	const offsets = [];
+	for (let index = code.indexOf(name); index >= 0; index = code.indexOf(name, index + 1)) {
+		const end = index + name.length;
+		if (isAsciiIdentifierPart(code.charCodeAt(index - 1)) || isAsciiIdentifierPart(code.charCodeAt(end))) continue;
+		let next = nextTokenStart(code, end);
+		if (next >= 0 && code.startsWith("?.", next)) next = nextTokenStart(code, next + 2);
+		if (next < 0 || code[next] === "(") offsets.push(index);
+	}
+	return offsets;
+}
+function nextTokenStart(code, from) {
+	let cursor = from;
+	for (;;) {
+		const char = code.charCodeAt(cursor);
+		if (char === 47 && code[cursor + 1] === "*") {
+			const end = code.indexOf("*/", cursor + 2);
+			if (end < 0) return -1;
+			cursor = end + 2;
+		} else if (char === 47 && code[cursor + 1] === "/") cursor = nextLineBreak(code, cursor + 2);
+		else if (isWhitespace(char)) cursor++;
+		else return cursor;
+	}
+}
+function nextLineBreak(code, from) {
+	for (let index = from; index < code.length; index++) if (isLineTerminator(code.charCodeAt(index))) return index;
+	return code.length;
+}
+function isAsciiIdentifierPart(char) {
+	return char >= 48 && char <= 57 || char >= 65 && char <= 90 || char >= 97 && char <= 122 || char === 36 || char === 95;
+}
+function isLineTerminator(char) {
+	return char === 10 || char === 13 || char === 8232 || char === 8233;
+}
+function isWhitespace(char) {
+	return char === 9 || char === 11 || char === 12 || char === 32 || char === 160 || char === 65279 || isLineTerminator(char) || char >= 5760 && /\s/.test(String.fromCharCode(char));
+}
+function textOffsets(code, text) {
+	const offsets = [];
+	for (let index = code.indexOf(text); index >= 0; index = code.indexOf(text, index + 1)) offsets.push(index);
+	return offsets;
+}
+function spansAnyOffset(offsets, node) {
+	const { start, end } = node;
+	if (typeof start !== "number" || typeof end !== "number") return true;
+	let low = 0;
+	let high = offsets.length;
+	while (low < high) {
+		const middle = low + high >>> 1;
+		if (offsets[middle] < start) low = middle + 1;
+		else high = middle;
+	}
+	return low < offsets.length && offsets[low] < end;
+}
+function chunkDynamicImports(fileName, code) {
+	const known = dynamicImportsByFile.get(fileName);
+	if (known?.code === code) return known.value;
+	return readChunkDynamicImports(fileName, code);
+}
+function clearChunkFactCaches() {
+	dynamicImportsByFile.clear();
+	localExportsByFile.clear();
+}
+const dynamicImportsByFile = /* @__PURE__ */ new Map();
+function knowsChunkDynamicImports(fileName, code) {
+	return dynamicImportsByFile.get(fileName)?.code === code;
+}
+function rememberChunkDynamicImports(fileName, code, found) {
+	dynamicImportsByFile.set(fileName, {
+		code,
+		value: found
+	});
+}
+function readChunkDynamicImports(fileName, code) {
+	const parsed = parseChunkCode(fileName, code);
+	if (parsed.errors.length) return void 0;
+	const found = [];
+	for (const entry of parsed.module.dynamicImports) {
+		const request = entry.moduleRequest;
+		const text = code.slice(request.start, request.end);
+		const quote = text[0];
+		let specifier;
+		if (quote === "\"" || quote === "'" || quote === "`") {
+			if (text.length < 2 || text[text.length - 1] !== quote) return void 0;
+			const body = text.slice(1, -1);
+			if (body.includes("\\") || body.includes(quote)) return void 0;
+			specifier = quote === "`" && body.includes("${") ? void 0 : body;
+		}
+		const afterKeyword = nextTokenStart(code, entry.start + 6);
+		let cursor = nextTokenStart(code, request.end);
+		if (cursor >= 0 && code[cursor] === ",") cursor = nextTokenStart(code, cursor + 1);
+		found.push({
+			start: entry.start,
+			end: entry.end,
+			specifier,
+			plain: code[afterKeyword] === "(" && code[cursor] === ")"
+		});
+	}
+	return found;
+}
+function chunkLocalExportSpecifiers(fileName, code) {
+	const known = localExportsByFile.get(fileName);
+	if (known?.code === code) return known.value;
+	return readChunkLocalExportSpecifiers(fileName, code);
+}
+const localExportsByFile = /* @__PURE__ */ new Map();
+function rememberChunkLocalExportSpecifiers(fileName, code, bindings) {
+	localExportsByFile.set(fileName, {
+		code,
+		value: bindings
+	});
+}
+function readChunkLocalExportSpecifiers(fileName, code) {
+	const parsed = parseChunkCode(fileName, code);
+	if (parsed.errors.length) return void 0;
+	const bindings = /* @__PURE__ */ new Map();
+	for (const statement of parsed.module.staticExports) {
+		const braced = code[nextTokenStart(code, statement.start + 6)] === "{";
+		for (const entry of statement.entries) {
+			if (!braced || entry.moduleRequest) continue;
+			if (entry.exportName.kind !== "Name" || entry.localName.kind !== "Name") return void 0;
+			bindings.set(entry.exportName.name, entry.localName.name);
+		}
+	}
+	return bindings;
+}
+//#endregion
+export { spansAnyOffset as _, chunkLocalExportSpecifiers as a, knowsChunkDynamicImports as c, prefetchChunkParses as d, readChunkDynamicImports as f, renderedChunkCount as g, rememberChunkLocalExportSpecifiers as h, chunkDynamicImports as i, mayContainDynamicImport as l, rememberChunkDynamicImports as m, PARSED_CHUNK_CACHE_MAX_ENTRIES as n, clearChunkFactCaches as o, readChunkLocalExportSpecifiers as p, calleeOffsets as r, clearParsedChunkCode as s, PARSED_CHUNK_CACHE_MAX_CODE_LENGTH as t, parseChunkCode as u, textOffsets as v };

package/dist/chunk-tasks-BexSGNjx.js

@@ -0,0 +1 @@
+export { o as runChunkTaskInline } from "./lazy-module-facades-qZajWDD8.js";

package/dist/compile-store-DxF9Vj4_.js

@@ -0,0 +1,187 @@
+import { deserialize, serialize } from "node:v8";
+import { threadId } from "node:worker_threads";
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { mkdir, readdir, rename, rm, stat, utimes, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { promisify } from "node:util";
+import * as zlib from "node:zlib";
+import { dirname, join } from "pathe";
+/** Runtimes without zstd in `node:zlib` (older Node, some Bun releases) build without the cache. */
+function persistentCompileCacheAvailable() {
+	return typeof zlib.zstdCompress === "function" && typeof zlib.zstdDecompressSync === "function";
+}
+function createPersistentCompileCache(input) {
+	const used = /* @__PURE__ */ new Set();
+	const writes = /* @__PURE__ */ new Set();
+	const strippedCode = persistentTextMemo(join(input.directory, "stripped-code.bin"), `${input.fingerprint}\0${stripperVersion()}`);
+	const pathOf = (source, key) => {
+		const entry = compileStoreEntry(input.directory, input.fingerprint, source, key);
+		used.add(entry.hash);
+		return entry.path;
+	};
+	return {
+		read(source, key) {
+			const path = pathOf(source, key);
+			let bytes;
+			try {
+				bytes = readFileSync(path);
+			} catch {
+				return;
+			}
+			try {
+				const result = deserialize(zlib.zstdDecompressSync(bytes));
+				const now = /* @__PURE__ */ new Date();
+				utimes(path, now, now).catch(() => {});
+				return result;
+			} catch {
+				return;
+			}
+		},
+		write(source, key, result) {
+			const path = pathOf(source, key);
+			let bytes;
+			try {
+				bytes = serialize(result);
+			} catch {
+				return;
+			}
+			const pending = writeCompileStoreEntry(path, bytes).finally(() => writes.delete(pending));
+			writes.add(pending);
+		},
+		track(write) {
+			const pending = write.finally(() => writes.delete(pending));
+			writes.add(pending);
+		},
+		strippedCode,
+		async flush() {
+			while (writes.size) await Promise.all(writes);
+			await strippedCode.save();
+			await trim(input.directory, input.maxBytes ?? 1073741824, used);
+		}
+	};
+}
+/** Where one compile result lives: a hash of the compiler's fingerprint and the whole compile input. */
+function compileStoreEntry(directory, fingerprint, source, key) {
+	const hash = createHash("sha256").update(fingerprint).update("\0").update(key).update("\0").update(source).digest("hex");
+	return {
+		hash,
+		path: join(directory, hash.slice(0, 2), `${hash}.bin`)
+	};
+}
+/** Writes one serialized result; a failed write only costs a recompile next time. */
+async function writeCompileStoreEntry(path, bytes) {
+	try {
+		const packed = await promisify(zlib.zstdCompress)(bytes);
+		await mkdir(dirname(path), { recursive: true });
+		const partial = `${path}.${process.pid}.${threadId}.tmp`;
+		await writeFile(partial, packed);
+		await rename(partial, path);
+	} catch {}
+}
+function persistentTextMemo(path, fingerprint) {
+	let stored;
+	const kept = /* @__PURE__ */ new Map();
+	let changed = false;
+	const hashOf = (key) => createHash("sha256").update(fingerprint).update("\0").update(key).digest("base64");
+	const load = () => {
+		if (stored) return stored;
+		try {
+			stored = new Map(deserialize(zlib.zstdDecompressSync(readFileSync(path))));
+		} catch {
+			stored = /* @__PURE__ */ new Map();
+		}
+		return stored;
+	};
+	return {
+		get(key) {
+			const hash = hashOf(key);
+			let value = kept.get(hash);
+			if (value === void 0) {
+				const loaded = load();
+				value = loaded.get(hash);
+				if (value !== void 0) {
+					loaded.delete(hash);
+					kept.set(hash, value);
+				}
+			}
+			return value;
+		},
+		set(key, value) {
+			kept.set(hashOf(key), value);
+			changed = true;
+		},
+		async save() {
+			if (!changed && load().size === 0) return;
+			const packed = await promisify(zlib.zstdCompress)(serialize([...kept]));
+			await mkdir(dirname(path), { recursive: true });
+			const partial = `${path}.${process.pid}.tmp`;
+			await writeFile(partial, packed);
+			await rename(partial, path);
+		}
+	};
+}
+async function trim(directory, maxBytes, used) {
+	const files = [];
+	let total = 0;
+	for (const shard of await readdir(directory).catch(() => [])) for (const name of await readdir(join(directory, shard)).catch(() => [])) {
+		const path = join(directory, shard, name);
+		const info = await stat(path).catch(() => void 0);
+		if (!info?.isFile()) continue;
+		total += info.size;
+		files.push({
+			path,
+			hash: name.split(".")[0],
+			bytes: info.size,
+			mtime: info.mtimeMs
+		});
+	}
+	if (total <= maxBytes) return;
+	files.sort((a, b) => a.mtime - b.mtime);
+	for (const file of files) {
+		if (total <= maxBytes) break;
+		if (used.has(file.hash)) continue;
+		await rm(file.path, { force: true });
+		total -= file.bytes;
+	}
+}
+/** A hash of every file the compiler's output depends on: its own package, the serializer it embeds, and its parsers. */
+function compilerFingerprint() {
+	const hash = createHash("sha256");
+	const compiler = packageDirectory(createRequire(import.meta.url), "@markless/compiler");
+	const fromCompiler = createRequire(join(compiler, "package.json"));
+	const serializer = packageDirectory(fromCompiler, "@markless/serializer");
+	for (const directory of [compiler, serializer]) hashPackage(hash, directory);
+	for (const name of ["@tsrx/yuku", "yuku-css"]) try {
+		hash.update(readFileSync(join(packageDirectory(fromCompiler, name), "package.json")));
+	} catch {
+		hash.update(`${name}:missing`);
+	}
+	return hash.digest("hex");
+}
+function stripperVersion() {
+	try {
+		return readFileSync(join(packageDirectory(createRequire(import.meta.url), "rolldown"), "package.json"), "utf8");
+	} catch {
+		return "rolldown:missing";
+	}
+}
+function packageDirectory(require, name) {
+	let directory = dirname(require.resolve(name));
+	while (!existsSync(join(directory, "package.json")) && dirname(directory) !== directory) directory = dirname(directory);
+	return directory;
+}
+function hashPackage(hash, directory) {
+	hash.update(readFileSync(join(directory, "package.json")));
+	for (const sub of ["src", "dist"]) {
+		const root = join(directory, sub);
+		if (!existsSync(root)) continue;
+		for (const name of readdirSync(root, { recursive: true }).sort()) {
+			const path = join(root, name);
+			if (!statSync(path).isFile()) continue;
+			hash.update(name).update("\0").update(readFileSync(path));
+		}
+	}
+}
+//#endregion
+export { writeCompileStoreEntry as a, persistentCompileCacheAvailable as i, compilerFingerprint as n, createPersistentCompileCache as r, compileStoreEntry as t };

package/dist/{execution-log-6xkAwVG_.d.ts → execution-log-7HH5XDfA.d.ts}

@@ -1,7 +1,7 @@
-import "./types-5srcMsXU.js";
+import "./types-B8YqEscg.js";
+import "@markless/compiler";
 import "@markless/web/inline/resumer";
 import "@markless/serializer";
-import "@markless/compiler";
 //#region src/source-module.d.ts
 declare const MARKLESS_VIRTUAL_PREFIX = "virtual:markless:";
 declare function symbolVirtualModuleSourceFile(moduleId: string): string | null;