autotel/dist/node-require-vROmTeJ8.js

Write Once, Observe Anywhere

import * as nodeModule from "node:module";

//#region src/node-require.ts
/**
* Cross-format require() helper for CJS and ESM compatibility
*
* Provides a synchronous `require()` function that works in both:
* - CJS builds: Uses native `require`
* - ESM builds: Uses `createRequire(import.meta.url)`
*
* This allows optional peer dependencies and dynamic module loading
* to work synchronously in both module formats.
*/
let cachedRequire;
function getNodeRequire() {
	if (cachedRequire) return cachedRequire;
	const base = typeof __filename === "string" ? __filename : import.meta.url;
	if (!base) throw Object.assign(/* @__PURE__ */ new Error("node require() is unavailable in this runtime"), { code: "MODULE_NOT_FOUND" });
	cachedRequire = nodeModule.createRequire(base);
	return cachedRequire;
}
/**
* Synchronously require a module (works in both CJS and ESM)
*
* @param id - Module ID to require
* @returns The required module
* @throws Error if module cannot be loaded
*
* @example
* ```typescript
* import { safeRequire } from './node-require';
*
* const traceloop = safeRequire('@traceloop/node-server-sdk');
* if (traceloop) {
*   traceloop.initialize({ ... });
* }
* ```
*/
function safeRequire(id) {
	try {
		return getNodeRequire()(id);
	} catch (error) {
		if (error && error.code === "MODULE_NOT_FOUND") return;
		throw error;
	}
}
/**
* Synchronously require a module (throws if not found)
*
* Use this when the module is required (not optional).
*
* @param id - Module ID to require
* @returns The required module
* @throws Error if module cannot be loaded
*
* @example
* ```typescript
* import { requireModule } from './node-require';
*
* const fs = requireModule<typeof import('node:fs')>('node:fs');
* const content = fs.readFileSync('file.txt', 'utf8');
* ```
*/
function requireModule(id) {
	return getNodeRequire()(id);
}
/**
* Direct access to the nodeRequire function (for advanced use cases).
*
* Lazily resolves the underlying Node `require` on first call, so importing
* this binding never triggers `createRequire` in runtimes that lack a module
* path (e.g. Cloudflare Workers).
*
* Only the call signature and `resolve` (including `resolve.paths`) are
* forwarded. The live, mutable members of a real `require` — `.cache`,
* `.main`, `.extensions` — are intentionally NOT exposed: a lazy wrapper
* can't mirror that shared state without resolving eagerly, which would
* reintroduce the workerd crash. Use `nodeModule.createRequire` directly if
* you need them.
*/
const nodeRequire = ((id) => getNodeRequire()(id));
const lazyResolve = ((id, options) => getNodeRequire().resolve(id, options));
lazyResolve.paths = (request) => getNodeRequire().resolve.paths(request);
nodeRequire.resolve = lazyResolve;

//#endregion
export { safeRequire as n, requireModule as t };
//# sourceMappingURL=node-require-vROmTeJ8.js.map