slackmark-node 0.1.0

package/dist/puppeteer.js

@@ -0,0 +1,723 @@
+import { createRequire } from "node:module";
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { ConfigurationError, OperationAbortedError, OperationDeadlineExceededError, OperationErrorCode, OperationShutdownError, cloneOperationError, isOperationError } from "slackmark";
+//#region src/errors.ts
+const NodeRenderErrorCode = {
+	AssetMissing: "asset_missing",
+	BrowserBinaryMissing: "browser_binary_missing",
+	BrowserDisconnected: "browser_disconnected",
+	BrowserFailed: "browser_failed",
+	CleanupFailed: "cleanup_failed",
+	CloseFailed: "close_failed",
+	ContextFailed: "context_failed",
+	DimensionLimit: "dimension_limit",
+	OutputLimit: "output_limit",
+	QueueFull: "queue_full",
+	RenderFailed: "render_failed",
+	SourceLimit: "source_limit"
+};
+const NodeRenderStage = {
+	Admission: "admission",
+	AssetLoad: "asset_load",
+	Browser: "browser",
+	BrowserCleanup: "browser_cleanup",
+	BrowserClose: "browser_close",
+	BrowserLaunch: "browser_launch",
+	ContextCleanup: "context_cleanup",
+	ContextCreate: "context_create",
+	Layout: "layout",
+	OutputValidation: "output_validation",
+	Render: "render",
+	SourceValidation: "source_validation"
+};
+/**
+* Sanitized failure from the Node rendering boundary.
+*/
+var NodeRenderError = class extends Error {
+	code;
+	stage;
+	retryable;
+	rendererId;
+	constructor(code, message, options = {
+		stage: "render",
+		retryable: false
+	}) {
+		super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+		this.name = "NodeRenderError";
+		this.code = code;
+		this.stage = options.stage;
+		this.retryable = options.retryable;
+		this.rendererId = options.rendererId;
+	}
+};
+function normalizeNodeRenderError(error, code, message, stage = NodeRenderStage.Render, retryable = false) {
+	return error instanceof NodeRenderError || isOperationError(error) ? error : new NodeRenderError(code, message, {
+		stage,
+		retryable,
+		cause: error
+	});
+}
+//#endregion
+//#region src/katex-assets.ts
+const resolver$1 = createRequire(import.meta.url);
+const WOFF2_URL_RE = /url\(fonts\/([A-Za-z0-9_-]+\.woff2)\)/g;
+const LEGACY_FONT_SOURCE_RE = /, url\(fonts\/[A-Za-z0-9_-]+\.(?:woff|ttf)\) format\("(?:woff|truetype)"\)/g;
+/**
+* Reads KaTeX's installed CSS/fonts and embeds WOFF2 files as data URLs once.
+*/
+var LocalKatexAssetLoader = class {
+	cssPromise;
+	scriptPromise;
+	constructor() {
+		this.cssPromise = void 0;
+		this.scriptPromise = void 0;
+	}
+	loadScript() {
+		this.scriptPromise ??= readFile(resolver$1.resolve("katex/dist/katex.min.js"), "utf8").catch((error) => {
+			this.scriptPromise = void 0;
+			throw normalizeNodeRenderError(error, NodeRenderErrorCode.AssetMissing, "Unable to load local KaTeX script", "asset_load", false);
+		});
+		return this.scriptPromise;
+	}
+	loadCss() {
+		this.cssPromise ??= this.loadCssFromPackage().catch((error) => {
+			this.cssPromise = void 0;
+			throw normalizeNodeRenderError(error, NodeRenderErrorCode.AssetMissing, "Unable to load local KaTeX assets", "asset_load", false);
+		});
+		return this.cssPromise;
+	}
+	async loadCssFromPackage() {
+		const cssPath = resolver$1.resolve("katex/dist/katex.css");
+		const css = await readFile(cssPath, "utf8");
+		const fontNames = /* @__PURE__ */ new Set();
+		for (const match of css.matchAll(WOFF2_URL_RE)) {
+			const fontName = match[1];
+			if (fontName !== void 0) fontNames.add(fontName);
+		}
+		const encodedFonts = await Promise.all([...fontNames].map(async (fontName) => {
+			return [fontName, (await readFile(join(dirname(cssPath), "fonts", fontName))).toString("base64")];
+		}));
+		let embedded = css.replace(LEGACY_FONT_SOURCE_RE, "");
+		for (const [fontName, base64] of encodedFonts) embedded = embedded.replaceAll(`url(fonts/${fontName})`, `url(data:font/woff2;base64,${base64})`);
+		return embedded;
+	}
+};
+//#endregion
+//#region src/mermaid-assets.ts
+const resolver = createRequire(import.meta.url);
+var LocalMermaidAssetLoader = class {
+	scriptPromise;
+	constructor() {
+		this.scriptPromise = void 0;
+	}
+	loadScript() {
+		this.scriptPromise ??= readFile(resolver.resolve("mermaid/dist/mermaid.min.js"), "utf8").catch((error) => {
+			this.scriptPromise = void 0;
+			throw new NodeRenderError(NodeRenderErrorCode.AssetMissing, "Unable to load Mermaid browser assets", {
+				stage: "asset_load",
+				retryable: false,
+				cause: error
+			});
+		});
+		return this.scriptPromise;
+	}
+};
+//#endregion
+//#region src/node-options.ts
+function snapshotNodeOptions(options, allowed, label) {
+	if (!isPlainNodeObject(options)) throw invalidNodeOptions(`${label} options must be a plain object`);
+	const allowedKeys = new Set(allowed);
+	const snapshot = {};
+	let keys;
+	try {
+		keys = Object.keys(options);
+	} catch (cause) {
+		throw invalidNodeOptions(`${label} options could not be inspected`, cause);
+	}
+	for (const key of keys) {
+		if (!allowedKeys.has(key)) throw invalidNodeOptions(`Unknown ${label} option: ${key}`);
+		try {
+			snapshot[key] = Reflect.get(options, key);
+		} catch (cause) {
+			throw invalidNodeOptions(`${label}.${key} could not be read`, cause);
+		}
+	}
+	return Object.freeze(snapshot);
+}
+function snapshotOpenNodeOptions(options, label) {
+	let keys;
+	try {
+		keys = Object.keys(options);
+	} catch (cause) {
+		throw invalidNodeOptions(`${label} could not be inspected`, cause);
+	}
+	return snapshotNodeOptions(options, keys, label);
+}
+function assertNodeMethod(collaborator, method, label) {
+	try {
+		if (typeof collaborator !== "object" && typeof collaborator !== "function" || collaborator === null || typeof Reflect.get(collaborator, method) !== "function") throw new TypeError(`${method} must be a function`);
+	} catch (cause) {
+		throw invalidNodeOptions(`${label} collaborator is invalid`, cause);
+	}
+}
+function invalidNodeOptions(message, cause) {
+	return new ConfigurationError(message, {
+		code: "invalid_node_configuration",
+		stage: "configuration",
+		cause
+	});
+}
+function isPlainNodeObject(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	let prototype;
+	try {
+		prototype = Object.getPrototypeOf(value);
+	} catch {
+		return false;
+	}
+	return prototype === Object.prototype || prototype === null;
+}
+//#endregion
+//#region src/operation-control.ts
+var OperationScope = class {
+	context;
+	parentSignal;
+	controller;
+	abortFromParent;
+	deadlineTimer;
+	constructor(context, stage) {
+		this.parentSignal = context.signal;
+		this.controller = new AbortController();
+		this.abortFromParent = () => {
+			const reason = this.parentSignal?.reason;
+			this.controller.abort(isOperationError(reason) ? cloneOperationError(reason, stage) : new OperationAbortedError(stage, { cause: reason }));
+		};
+		if (this.parentSignal?.aborted === true) this.abortFromParent();
+		else this.parentSignal?.addEventListener("abort", this.abortFromParent, { once: true });
+		if (context.deadlineMs === void 0) this.deadlineTimer = void 0;
+		else if (context.deadlineMs <= Date.now()) {
+			this.deadlineTimer = void 0;
+			this.controller.abort(new OperationDeadlineExceededError(stage));
+		} else this.deadlineTimer = setTimeout(() => {
+			this.controller.abort(new OperationDeadlineExceededError(stage));
+		}, context.deadlineMs - Date.now());
+		this.context = Object.freeze({
+			signal: this.controller.signal,
+			deadlineMs: context.deadlineMs
+		});
+	}
+	abortForShutdown(stage) {
+		this.controller.abort(new OperationShutdownError(stage));
+	}
+	abort(reason) {
+		this.controller.abort(reason);
+	}
+	race(promise) {
+		return raceWithContext(promise, this.context);
+	}
+	cleanup() {
+		if (this.deadlineTimer !== void 0) clearTimeout(this.deadlineTimer);
+		this.parentSignal?.removeEventListener("abort", this.abortFromParent);
+	}
+};
+function raceWithContext(promise, context) {
+	const signal = context.signal;
+	if (signal?.aborted === true) return Promise.reject(signal.reason ?? new OperationAbortedError("operation"));
+	return new Promise((resolve, reject) => {
+		const onAbort = () => {
+			signal?.removeEventListener("abort", onAbort);
+			reject(signal?.reason ?? new OperationAbortedError("operation"));
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+		promise.then((value) => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve(value);
+		}, (error) => {
+			signal?.removeEventListener("abort", onAbort);
+			reject(error);
+		});
+	});
+}
+function operationReason(signal) {
+	return isOperationError(signal.reason) ? signal.reason : new OperationAbortedError("operation", { cause: signal.reason });
+}
+//#endregion
+//#region src/puppeteer-render-runtime.ts
+const DEFAULT_CONCURRENCY = 2;
+const DEFAULT_MAX_QUEUE_SIZE = 32;
+const INTERNAL_LAUNCH_TIMEOUT_MS = 1e4;
+const INTERNAL_CLEANUP_TIMEOUT_MS = 2e3;
+const DENY_NETWORK_PROXY = "http://127.0.0.1:9";
+var PuppeteerRenderRuntime = class {
+	launcher;
+	launchOptions;
+	concurrency;
+	maxQueueSize;
+	contextOptions;
+	pendingJobs;
+	activeScopes;
+	idleResolvers;
+	activeJobs;
+	browserPromise;
+	currentBrowser;
+	launchController;
+	launchWaiters;
+	launchPending;
+	launchAbandoned;
+	launchError;
+	forceCloseBrowser;
+	forceClosePromise;
+	closePromise;
+	closeBehavior;
+	accepting;
+	constructor(options) {
+		const validated = snapshotNodeOptions(options, [
+			"launcher",
+			"launchOptions",
+			"concurrency",
+			"maxQueueSize"
+		], "PuppeteerRenderRuntime");
+		assertNodeMethod(validated.launcher, "launch", "BrowserLauncher");
+		const launchOptions = validated.launchOptions === void 0 ? void 0 : snapshotOpenNodeOptions(validated.launchOptions, "Puppeteer launchOptions");
+		this.launcher = validated.launcher;
+		this.launchOptions = {
+			headless: "shell",
+			...launchOptions
+		};
+		this.concurrency = validated.concurrency ?? DEFAULT_CONCURRENCY;
+		this.maxQueueSize = validated.maxQueueSize ?? DEFAULT_MAX_QUEUE_SIZE;
+		this.contextOptions = {
+			proxyServer: DENY_NETWORK_PROXY,
+			proxyBypassList: ["<-loopback>"],
+			downloadBehavior: { policy: "deny" }
+		};
+		this.pendingJobs = [];
+		this.activeScopes = /* @__PURE__ */ new Set();
+		this.idleResolvers = [];
+		this.activeJobs = 0;
+		this.browserPromise = void 0;
+		this.currentBrowser = void 0;
+		this.launchController = void 0;
+		this.launchWaiters = /* @__PURE__ */ new Set();
+		this.launchPending = false;
+		this.launchAbandoned = false;
+		this.launchError = void 0;
+		this.forceCloseBrowser = void 0;
+		this.forceClosePromise = void 0;
+		this.closePromise = void 0;
+		this.closeBehavior = void 0;
+		this.accepting = true;
+		validatePositiveInteger(this.concurrency, "concurrency");
+		validateNonNegativeInteger(this.maxQueueSize, "maxQueueSize");
+	}
+	run(job, operation) {
+		if (!this.accepting) return Promise.reject(new OperationShutdownError("render_admission"));
+		if (this.activeJobs >= this.concurrency && this.pendingJobs.length >= this.maxQueueSize) return Promise.reject(new NodeRenderError(NodeRenderErrorCode.QueueFull, `Render queue is full (max ${String(this.maxQueueSize)} pending)`, {
+			stage: "admission",
+			retryable: true
+		}));
+		return new Promise((resolve, reject) => {
+			const scope = new OperationScope(operation, "render");
+			let pending;
+			const abortWhileQueued = () => {
+				const index = this.pendingJobs.indexOf(pending);
+				if (index >= 0) {
+					this.pendingJobs.splice(index, 1);
+					pending.reject(operationReason(requireSignal(scope.context)));
+				}
+			};
+			pending = {
+				start: () => {
+					scope.context.signal?.removeEventListener("abort", abortWhileQueued);
+					this.activeScopes.add(scope);
+					this.startUnderlying(job, scope, resolve, reject);
+				},
+				reject: (error) => {
+					scope.context.signal?.removeEventListener("abort", abortWhileQueued);
+					scope.cleanup();
+					reject(error);
+				}
+			};
+			if (scope.context.signal?.aborted === true) {
+				pending.reject(operationReason(requireSignal(scope.context)));
+				return;
+			}
+			if (this.activeJobs < this.concurrency) {
+				this.activeJobs += 1;
+				pending.start();
+				return;
+			}
+			scope.context.signal?.addEventListener("abort", abortWhileQueued, { once: true });
+			this.pendingJobs.push(pending);
+		});
+	}
+	warmup(operation) {
+		return this.run(async () => void 0, operation);
+	}
+	close(operation, behavior = "cancel") {
+		if (this.closePromise !== void 0) return this.closePromise;
+		const closeScope = new OperationScope(operation, "browser_close");
+		this.accepting = false;
+		this.closeBehavior = behavior;
+		if (behavior === "cancel") {
+			const shutdown = new OperationShutdownError("render");
+			for (const pending of this.pendingJobs.splice(0)) pending.reject(shutdown);
+			for (const scope of this.activeScopes) scope.abortForShutdown("render");
+			this.abandonLaunch(shutdown);
+		}
+		this.closePromise = this.finishClose(closeScope.context).finally(() => {
+			closeScope.cleanup();
+		});
+		return this.closePromise;
+	}
+	status() {
+		return Object.freeze({
+			accepting: this.accepting,
+			active: this.activeJobs,
+			queued: this.pendingJobs.length,
+			retainedBytes: 0
+		});
+	}
+	startUnderlying(job, scope, resolve, reject) {
+		const underlying = this.executeUnderlying(job, scope);
+		scope.race(underlying).then(resolve, reject);
+		underlying.then(() => {
+			this.finishUnderlying(scope);
+		}, () => {
+			this.finishUnderlying(scope);
+		});
+	}
+	async executeUnderlying(job, scope) {
+		let browser;
+		let context;
+		let contextClosePromise;
+		let contextCleanupPromise;
+		let outcome;
+		const closeContext = () => {
+			if (context === void 0) return Promise.resolve();
+			contextClosePromise ??= Promise.resolve().then(() => context.close());
+			return contextClosePromise;
+		};
+		const cleanupContext = () => {
+			contextCleanupPromise ??= cleanupWithDeadline(closeContext(), async () => {
+				await this.forceCloseBrowserOnce(browser);
+			});
+			return contextCleanupPromise;
+		};
+		const requestContextClose = () => {
+			if (context !== void 0) cleanupContext().catch(() => void 0);
+		};
+		scope.context.signal?.addEventListener("abort", requestContextClose, { once: true });
+		try {
+			browser = await this.getBrowser(scope);
+			throwIfContextEnded(scope.context);
+			try {
+				context = await browser.createBrowserContext(this.contextOptions);
+			} catch (error) {
+				if (isBrowserDisconnected(error)) throw error;
+				throw new NodeRenderError(NodeRenderErrorCode.ContextFailed, "Browser context creation failed", {
+					stage: "context_create",
+					retryable: true,
+					cause: error
+				});
+			}
+			throwIfContextEnded(scope.context);
+			outcome = {
+				ok: true,
+				value: await Promise.resolve().then(() => job(context, scope.context))
+			};
+		} catch (error) {
+			if (scope.context.signal?.aborted === true) outcome = {
+				ok: false,
+				error: operationReason(requireSignal(scope.context))
+			};
+			else if (isBrowserDisconnected(error)) outcome = {
+				ok: false,
+				error: new NodeRenderError(NodeRenderErrorCode.BrowserDisconnected, "Chromium disconnected during rendering", {
+					stage: "browser",
+					retryable: true,
+					cause: error
+				})
+			};
+			else outcome = {
+				ok: false,
+				error: normalizeNodeRenderError(error, NodeRenderErrorCode.RenderFailed, "Browser rendering failed", "render", true)
+			};
+		}
+		scope.context.signal?.removeEventListener("abort", requestContextClose);
+		if (context !== void 0) try {
+			await cleanupContext();
+		} catch (cleanupError) {
+			if (outcome.ok || cleanupError instanceof NodeRenderError && cleanupError.stage === "browser_cleanup") outcome = {
+				ok: false,
+				error: cleanupError
+			};
+		}
+		if (outcome.ok) return outcome.value;
+		throw outcome.error;
+	}
+	finishUnderlying(scope) {
+		scope.cleanup();
+		this.activeScopes.delete(scope);
+		this.activeJobs -= 1;
+		const next = this.pendingJobs.shift();
+		if (next !== void 0 && this.closeBehavior !== "cancel") {
+			this.activeJobs += 1;
+			next.start();
+		} else if (next !== void 0) next.reject(new OperationShutdownError("render"));
+		if (this.activeJobs === 0 && this.pendingJobs.length === 0) for (const resolve of this.idleResolvers.splice(0)) resolve();
+	}
+	getBrowser(scope) {
+		if (this.browserPromise !== void 0) {
+			if (this.launchPending) {
+				this.launchWaiters.add(scope);
+				if (this.launchError !== void 0) scope.abort(this.launchError);
+			}
+			return this.browserPromise;
+		}
+		this.forceCloseBrowser = void 0;
+		this.forceClosePromise = void 0;
+		this.launchPending = true;
+		this.launchAbandoned = false;
+		this.launchError = void 0;
+		this.launchWaiters.add(scope);
+		const launchController = new AbortController();
+		this.launchController = launchController;
+		const deadlineMs = Date.now() + INTERNAL_LAUNCH_TIMEOUT_MS;
+		const launchOperation = {
+			signal: launchController.signal,
+			deadlineMs
+		};
+		const timeout = setTimeout(() => {
+			const error = new NodeRenderError(NodeRenderErrorCode.BrowserFailed, "Chromium launch deadline exceeded", {
+				stage: "browser_launch",
+				retryable: true
+			});
+			this.abandonLaunch(error);
+		}, INTERNAL_LAUNCH_TIMEOUT_MS);
+		const launched = Promise.resolve().then(() => this.launcher.launch(this.launchOptions, launchOperation));
+		let tracked;
+		tracked = Promise.resolve(launched).then(async (browser) => {
+			clearTimeout(timeout);
+			this.launchPending = false;
+			this.launchWaiters.clear();
+			if (this.launchAbandoned || !this.accepting) {
+				await this.forceCloseHandleOnce(browser);
+				if (this.browserPromise === tracked) this.browserPromise = void 0;
+				return browser;
+			}
+			this.currentBrowser = browser;
+			browser.on("disconnected", () => {
+				if (this.browserPromise === tracked) {
+					this.browserPromise = void 0;
+					this.currentBrowser = void 0;
+				}
+			});
+			return browser;
+		}).catch((error) => {
+			clearTimeout(timeout);
+			this.launchPending = false;
+			this.launchWaiters.clear();
+			if (this.browserPromise === tracked) this.browserPromise = void 0;
+			throw normalizeNodeRenderError(error, NodeRenderErrorCode.BrowserFailed, "Chromium launch failed", "browser_launch", true);
+		});
+		this.browserPromise = tracked;
+		return tracked;
+	}
+	async finishClose(operation) {
+		try {
+			await raceWithContext(this.waitForIdle(), operation);
+		} catch (error) {
+			this.closeBehavior = "cancel";
+			const shutdown = new OperationShutdownError("render");
+			for (const pending of this.pendingJobs.splice(0)) pending.reject(shutdown);
+			for (const scope of this.activeScopes) scope.abortForShutdown("render");
+			await this.forceCloseBrowserOnce();
+			throw error;
+		}
+		const browserPromise = this.browserPromise;
+		if (browserPromise === void 0) return;
+		let browser;
+		try {
+			browser = await raceWithContext(browserPromise, operation);
+		} catch (error) {
+			if (isOperationError(error) && error.code === OperationErrorCode.Shutdown) return;
+			await this.forceCloseBrowserOnce();
+			throw error;
+		}
+		if (!browser.connected) return;
+		try {
+			await raceWithContext(cleanupWithDeadline(browser.close(), () => this.forceCloseBrowserOnce(browser)), operation);
+		} catch (error) {
+			await this.forceCloseBrowserOnce(browser);
+			if (isOperationError(error)) throw error;
+			throw new NodeRenderError(NodeRenderErrorCode.CloseFailed, "Chromium close failed", {
+				stage: "browser_close",
+				retryable: true,
+				cause: error
+			});
+		}
+	}
+	waitForIdle() {
+		if (this.activeJobs === 0 && this.pendingJobs.length === 0) return Promise.resolve();
+		return new Promise((resolve) => {
+			this.idleResolvers.push(resolve);
+		});
+	}
+	forceCloseBrowserOnce(browser) {
+		if (this.launchPending) {
+			this.abandonLaunch(new OperationShutdownError("browser_close"));
+			return Promise.resolve();
+		}
+		if (browser !== void 0) return this.forceCloseHandleOnce(browser);
+		const browserPromise = this.browserPromise;
+		return browserPromise === void 0 ? Promise.resolve() : browserPromise.then((handle) => this.forceCloseHandleOnce(handle), () => void 0);
+	}
+	abandonLaunch(error) {
+		if (!this.launchPending) return;
+		this.launchAbandoned = true;
+		this.launchError = error;
+		this.launchController?.abort(error);
+		for (const waiter of this.launchWaiters) waiter.abort(error);
+	}
+	forceCloseHandleOnce(browser) {
+		if (this.currentBrowser === browser) {
+			this.currentBrowser = void 0;
+			this.browserPromise = void 0;
+		}
+		if (this.forceCloseBrowser !== browser || this.forceClosePromise === void 0) {
+			this.forceCloseBrowser = browser;
+			this.forceClosePromise = browser.forceClose().catch((error) => {
+				throw new NodeRenderError(NodeRenderErrorCode.CleanupFailed, "Browser cleanup failed", {
+					stage: "browser_cleanup",
+					retryable: true,
+					cause: error
+				});
+			});
+		}
+		return this.forceClosePromise;
+	}
+};
+async function importPuppeteerAndLaunch(options) {
+	const { launch } = await import("puppeteer");
+	return new PuppeteerBrowserHandle(await launch(options));
+}
+var PuppeteerBrowserLauncher = class {
+	launchBrowser;
+	constructor(launchBrowser = importPuppeteerAndLaunch) {
+		this.launchBrowser = launchBrowser;
+	}
+	async launch(options, operation) {
+		const deadlineMs = operation.deadlineMs ?? Date.now() + INTERNAL_LAUNCH_TIMEOUT_MS;
+		const timeout = Math.max(1, deadlineMs - Date.now());
+		try {
+			const launching = this.launchBrowser({
+				...options,
+				timeout: Math.min(options.timeout ?? timeout, timeout)
+			});
+			try {
+				return await raceWithContext(launching, operation);
+			} catch (error) {
+				await launching.then((handle) => handle.forceClose().catch(() => void 0), () => void 0);
+				throw error;
+			}
+		} catch (error) {
+			if (isMissingBrowserError(error)) throw new NodeRenderError(NodeRenderErrorCode.BrowserBinaryMissing, "Chromium executable is unavailable", {
+				stage: "browser_launch",
+				retryable: false,
+				cause: error
+			});
+			throw normalizeNodeRenderError(error, NodeRenderErrorCode.BrowserFailed, "Chromium launch failed", "browser_launch", true);
+		}
+	}
+};
+var PuppeteerBrowserHandle = class {
+	browser;
+	constructor(browser) {
+		this.browser = browser;
+	}
+	get connected() {
+		return this.browser.connected;
+	}
+	createBrowserContext(options) {
+		return this.browser.createBrowserContext(options);
+	}
+	close() {
+		return this.browser.close();
+	}
+	async forceClose() {
+		this.browser.process()?.kill("SIGKILL");
+		try {
+			await this.browser.disconnect();
+		} catch {}
+	}
+	on(event, handler) {
+		this.browser.on(event, handler);
+	}
+};
+function cleanupWithDeadline(cleanup, forceCleanup) {
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		let closedGracefully = false;
+		const timeout = setTimeout(() => {
+			if (settled) return;
+			settled = true;
+			forceCleanup().then(() => {
+				if (closedGracefully) {
+					resolve();
+					return;
+				}
+				reject(new NodeRenderError(NodeRenderErrorCode.CleanupFailed, "Cleanup deadline exceeded", {
+					stage: "context_cleanup",
+					retryable: true
+				}));
+			}, reject);
+		}, INTERNAL_CLEANUP_TIMEOUT_MS);
+		cleanup.then(() => {
+			closedGracefully = true;
+			if (!settled) {
+				settled = true;
+				clearTimeout(timeout);
+				resolve();
+			}
+		}, (error) => {
+			if (!settled) {
+				settled = true;
+				clearTimeout(timeout);
+				forceCleanup().then(() => {
+					reject(new NodeRenderError(NodeRenderErrorCode.CleanupFailed, "Browser context cleanup failed", {
+						stage: "context_cleanup",
+						retryable: true,
+						cause: error
+					}));
+				}, reject);
+			}
+		});
+	});
+}
+function throwIfContextEnded(operation) {
+	if (operation.signal?.aborted === true) throw operationReason(operation.signal);
+	if (operation.deadlineMs !== void 0 && Date.now() >= operation.deadlineMs) throw new OperationDeadlineExceededError("render");
+}
+function requireSignal(operation) {
+	if (operation.signal === void 0) throw new OperationShutdownError("operation");
+	return operation.signal;
+}
+function isBrowserDisconnected(error) {
+	return error instanceof Error && (error.message.includes("disconnected") || error.message.includes("Target closed") || error.message.includes("Connection closed"));
+}
+function validatePositiveInteger(value, name) {
+	if (!Number.isInteger(value) || value <= 0) throw invalidNodeOptions(`${name} must be a positive integer`);
+}
+function validateNonNegativeInteger(value, name) {
+	if (!Number.isInteger(value) || value < 0) throw invalidNodeOptions(`${name} must be a non-negative integer`);
+}
+function isMissingBrowserError(error) {
+	if (!(error instanceof Error)) return false;
+	return error.message.includes("Could not find Chrome") || error.message.includes("Browser was not found") || error.message.includes("executable doesn't exist");
+}
+//#endregion
+export { LocalKatexAssetLoader, LocalMermaidAssetLoader, PuppeteerBrowserLauncher, PuppeteerRenderRuntime };
+
+//# sourceMappingURL=puppeteer.js.map