@shad0wz7/nestjs-pdf 2.4.3 → 2.5.1

package/dist/index.cjs

@@ -0,0 +1,3840 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let node_path = require("node:path");
+let _nestjs_common = require("@nestjs/common");
+let pdf_lib = require("pdf-lib");
+let _gboutte_nestjs_hbs = require("@gboutte/nestjs-hbs");
+let p_limit = require("p-limit");
+p_limit = __toESM(p_limit);
+let deepmerge_ts = require("deepmerge-ts");
+let node_fs = require("node:fs");
+let _puppeteer_browsers = require("@puppeteer/browsers");
+let puppeteer = require("puppeteer");
+let ejs = require("ejs");
+let eta = require("eta");
+let mjml = require("mjml");
+mjml = __toESM(mjml);
+let mustache = require("mustache");
+mustache = __toESM(mustache);
+let nunjucks = require("nunjucks");
+let pug = require("pug");
+//#region src/helpers/getRelativePath.helper.ts
+/**
+* Get the relative path to a value from the module directory.
+* @param moduleDir the path of the module, typically __dirname
+* @param relativeToModule the path to the value relative to the module directory
+* @returns the relative path from the current working directory to the value
+* @example
+* getRelativePathToValue(__dirname, './templates/my-template.hbs');
+* // returns 'context/pdf/templates/my-template.hbs' if the current working directory is '/
+*/
+function getRelativePathToValue(moduleDir, relativeToModule) {
+	const fullTemplatePath = (0, node_path.resolve)(moduleDir, relativeToModule);
+	return (0, node_path.relative)(process.cwd(), fullTemplatePath);
+}
+//#endregion
+//#region src/helpers/signature.helper.ts
+let pdfjsPromise;
+async function loadPdfjs() {
+	if (!pdfjsPromise) try {
+		pdfjsPromise = await import("pdfjs-dist/legacy/build/pdf.mjs");
+	} catch (error) {
+		pdfjsPromise = void 0;
+		throw new Error([
+			"Failed to load pdfjs-dist.",
+			"If you use anchor-based signature placement in Node.js, make sure @napi-rs/canvas is installed.",
+			"Try: npm install @napi-rs/canvas",
+			"",
+			`Original error: ${error instanceof Error ? error.message : String(error)}`
+		].join("\n"), { cause: error });
+	}
+	return pdfjsPromise;
+}
+function toU8(input) {
+	return new Uint8Array(input);
+}
+async function findAnchorPosition(pdfBytes, anchorText) {
+	const pdfjsLib = await loadPdfjs();
+	const loadingTask = pdfjsLib.getDocument({ data: pdfBytes });
+	try {
+		const pdf = await loadingTask.promise;
+		for (let pageNum = 1; pageNum <= pdf.numPages; pageNum++) {
+			const page = await pdf.getPage(pageNum);
+			const viewport = page.getViewport({ scale: 1 });
+			const textContent = await page.getTextContent();
+			for (const itemRaw of textContent.items) {
+				const item = itemRaw;
+				if (!item.str?.includes(anchorText)) continue;
+				const [_a, _b, _c, _d, e, f] = pdfjsLib.Util.transform(viewport.transform, item.transform);
+				const x = e;
+				const y = viewport.height - f;
+				return {
+					pageIndex: pageNum - 1,
+					x,
+					y,
+					pageWidth: viewport.width,
+					pageHeight: viewport.height
+				};
+			}
+		}
+		return null;
+	} finally {
+		await loadingTask.destroy();
+	}
+}
+function addSignatureFieldAt(pdfDoc, pageIndex, opts) {
+	const { fieldName, x, y, width, height } = opts;
+	const context = pdfDoc.context;
+	const page = pdfDoc.getPages()[pageIndex];
+	if (!page) throw new Error(`Page ${pageIndex} not found`);
+	const rectArray = context.obj([
+		pdf_lib.PDFNumber.of(x),
+		pdf_lib.PDFNumber.of(y),
+		pdf_lib.PDFNumber.of(x + width),
+		pdf_lib.PDFNumber.of(y + height)
+	]);
+	const widgetDict = context.obj({
+		Type: pdf_lib.PDFName.of("Annot"),
+		Subtype: pdf_lib.PDFName.of("Widget"),
+		Rect: rectArray,
+		F: pdf_lib.PDFNumber.of(4),
+		P: page.ref
+	});
+	const widgetRef = context.register(widgetDict);
+	const fieldDict = context.obj({
+		FT: pdf_lib.PDFName.of("Sig"),
+		T: pdf_lib.PDFString.of(fieldName),
+		Ff: pdf_lib.PDFNumber.of(0),
+		Kids: context.obj([widgetRef])
+	});
+	const fieldRef = context.register(fieldDict);
+	widgetDict.set(pdf_lib.PDFName.of("Parent"), fieldRef);
+	let annots = page.node.lookupMaybe(pdf_lib.PDFName.of("Annots"), pdf_lib.PDFArray);
+	if (!annots) {
+		annots = context.obj([]);
+		page.node.set(pdf_lib.PDFName.of("Annots"), annots);
+	}
+	annots.push(widgetRef);
+	let acroForm = pdfDoc.catalog.lookupMaybe(pdf_lib.PDFName.of("AcroForm"), pdf_lib.PDFDict);
+	if (!acroForm) {
+		acroForm = context.obj({
+			Fields: context.obj([]),
+			SigFlags: pdf_lib.PDFNumber.of(3)
+		});
+		const acroFormRef = context.register(acroForm);
+		pdfDoc.catalog.set(pdf_lib.PDFName.of("AcroForm"), acroFormRef);
+	}
+	let fields = acroForm.lookupMaybe(pdf_lib.PDFName.of("Fields"), pdf_lib.PDFArray);
+	if (!fields) {
+		fields = context.obj([]);
+		acroForm.set(pdf_lib.PDFName.of("Fields"), fields);
+	}
+	fields.push(fieldRef);
+	return {
+		fieldRef,
+		widgetRef
+	};
+}
+async function addSignatureFieldUsingAnchor(pdf, fieldName = "SignatureDebtor", anchorText = "__SIG_DEBTOR_ANCHOR__") {
+	const bytes = toU8(pdf);
+	const anchor = await findAnchorPosition(bytes.slice(), anchorText);
+	const pdfDoc = await pdf_lib.PDFDocument.load(bytes);
+	const sigWidth = 240;
+	const sigHeight = 50;
+	if (anchor) {
+		const pageIndex = anchor.pageIndex;
+		const { width: pw, height: ph } = pdfDoc.getPages()[pageIndex].getSize();
+		const padX = 40;
+		const padY = 7;
+		let x = anchor.x - sigWidth / 2 + padX;
+		let y = anchor.y - sigHeight + padY;
+		const margin = 10;
+		x = Math.max(margin, Math.min(x, pw - sigWidth - margin));
+		y = Math.max(margin, Math.min(y, ph - sigHeight - margin));
+		addSignatureFieldAt(pdfDoc, anchor.pageIndex, {
+			fieldName,
+			x,
+			y,
+			width: sigWidth,
+			height: sigHeight
+		});
+	} else {
+		const pages = pdfDoc.getPages();
+		const pageIndex = pages.length - 1;
+		const { width: pageWidth } = pages[pageIndex].getSize();
+		addSignatureFieldAt(pdfDoc, pageIndex, {
+			fieldName,
+			x: (pageWidth - sigWidth) / 2,
+			y: 90,
+			width: sigWidth,
+			height: sigHeight
+		});
+	}
+	return await pdfDoc.save();
+}
+//#endregion
+//#region src/helpers/deepMergePdfparams.ts
+function mergePuppeteerParameters(defaults, overrides) {
+	if (!overrides) return { ...defaults };
+	return (0, deepmerge_ts.deepmerge)(defaults, overrides);
+}
+//#endregion
+//#region src/helpers/tokens.ts
+const PDF_PARAMETERS = "PDF_PARAMETERS";
+const HANDLEBARS_PARAMETERS = "HANDLEBARS_PARAMETERS";
+//#endregion
+//#region \0@oxc-project+runtime@0.142.0/helpers/esm/decorateMetadata.js
+function __decorateMetadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.142.0/helpers/esm/decorateParam.js
+function __decorateParam(paramIndex, decorator) {
+	return function(target, key) {
+		decorator(target, key, paramIndex);
+	};
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.142.0/helpers/esm/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+//#endregion
+//#region src/puppeteer/browser/browser.service.ts
+async function sleep(ms) {
+	await new Promise((r) => setTimeout(r, ms));
+}
+async function rmWithRetries(dir, retries = 5) {
+	for (let attempt = 1; attempt <= retries; attempt++) try {
+		await node_fs.promises.rm(dir, {
+			recursive: true,
+			force: true
+		});
+		return;
+	} catch (err) {
+		const code = err?.code;
+		if (!(code === "EPERM" || code === "EBUSY" || code === "ENOTEMPTY") || attempt === retries) throw err;
+		await sleep(50 * 2 ** (attempt - 1));
+	}
+}
+function isTargetClosedError(error) {
+	if (!(error instanceof Error)) return false;
+	return error.name === "TargetCloseError" || error.message.includes("Target closed") || error.message.includes("Target.createTarget");
+}
+let BrowserService = class BrowserService {
+	cacheDir;
+	options;
+	_browserInstance = null;
+	browser;
+	activeJobs = 0;
+	totalJobs = 0;
+	recycleRequested = false;
+	recycling = false;
+	browserTag;
+	useLockedBrowser;
+	buildId;
+	constructor(pdfParams) {
+		this.cacheDir = (0, node_path.resolve)(".cache/puppeteer-browser");
+		this.options = pdfParams;
+		if (pdfParams.cleanupBrowserCacheOnExit) this.registerCleanupHooks();
+		this.loadBuildId();
+		this.loadBrowser();
+		this.loadBrowserTag();
+		this.loadUseLockedBrowser();
+	}
+	async onModuleDestroy() {
+		if (this._browserInstance?.connected) try {
+			await this._browserInstance.close();
+		} catch (error) {
+			_nestjs_common.Logger.warn(`Failed to close browser on module destroy: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		await this.cleanupCacheBestEffort();
+	}
+	async getBrowserInstance(args, headless, executablePathBin) {
+		if (!this._browserInstance?.connected) this._browserInstance = await this.launchBrowser(args, headless, executablePathBin);
+		return this._browserInstance;
+	}
+	async createContext(args, headless, executablePath) {
+		const browser = await this.getBrowserInstance(args, headless, executablePath);
+		try {
+			return await browser.createBrowserContext();
+		} catch (error) {
+			if (!isTargetClosedError(error)) throw error;
+			_nestjs_common.Logger.warn("Puppeteer browser closed while creating a context, retrying once");
+			this._browserInstance = null;
+			return await (await this.getBrowserInstance(args, headless, executablePath)).createBrowserContext();
+		}
+	}
+	markJobStarted() {
+		this.activeJobs += 1;
+		this.totalJobs += 1;
+		if (this.totalJobs >= 200) this.recycleRequested = true;
+	}
+	async markJobFinished() {
+		this.activeJobs = Math.max(0, this.activeJobs - 1);
+		await this.recycleBrowserIfNeeded();
+	}
+	async recycleBrowserIfNeeded() {
+		if (!this.recycleRequested) return;
+		if (this.recycling) return;
+		if (this.activeJobs > 0) return;
+		if (!this._browserInstance) return;
+		this.recycling = true;
+		try {
+			if (this._browserInstance.connected) await this._browserInstance.close();
+			this._browserInstance = null;
+			this.totalJobs = 0;
+			this.recycleRequested = false;
+			_nestjs_common.Logger.log("Puppeteer browser recycled successfully");
+		} catch (error) {
+			_nestjs_common.Logger.warn(`Failed to recycle browser: ${error instanceof Error ? error.message : String(error)}`);
+		} finally {
+			this.recycling = false;
+		}
+	}
+	async cleanupCacheBestEffort() {
+		const logger = new _nestjs_common.Logger("NestJsPdf");
+		const dir = this.cacheDir;
+		try {
+			if (!(0, node_fs.existsSync)(dir)) return;
+			logger.log(`Cleanup puppeteer cache on signal: ${dir}`);
+			await rmWithRetries(dir, 6);
+			if ((0, node_fs.existsSync)(dir)) {
+				await sleep(100);
+				await rmWithRetries(dir, 3);
+			}
+			logger.log("Cleanup done");
+		} catch (err) {
+			logger.error(`Cleanup failed for ${dir}`, err instanceof Error ? err.stack : String(err));
+		}
+		try {
+			const leftover = await node_fs.promises.readdir(dir, { recursive: true });
+			logger.warn(`Leftover files: ${leftover.slice(0, 20).join(", ")}...`);
+		} catch {
+			logger.log(`No leftover files in ${dir}`);
+		}
+	}
+	async install(lock = false) {
+		const browser = this.browser;
+		const versionTag = this.browserTag;
+		const browserPlatform = (0, _puppeteer_browsers.detectBrowserPlatform)() ?? _puppeteer_browsers.BrowserPlatform.LINUX;
+		let buildId;
+		if (this.buildId === void 0) buildId = await (0, _puppeteer_browsers.resolveBuildId)(browser, browserPlatform, versionTag);
+		else buildId = this.buildId;
+		_nestjs_common.Logger.log(`Browser ${browser} ${versionTag} build id: ${buildId}`, "NestJsPdf");
+		if (await this.hasBrowserInstalled(browser, buildId)) {
+			_nestjs_common.Logger.log("Browser already installed", "NestJsPdf");
+			if (lock) this.writeLockFile(browser, buildId);
+			return;
+		} else {
+			_nestjs_common.Logger.log("Starting browser installation", "NestJsPdf");
+			const installOption = {
+				cacheDir: this.cacheDir,
+				browser,
+				buildId,
+				baseUrl: this.options?.browserInstallBaseUrl ?? void 0
+			};
+			if (await (0, _puppeteer_browsers.canDownload)(installOption)) {
+				_nestjs_common.Logger.log(`Installing ${installOption.browser} ${installOption.buildId}`, "NestJsPdf");
+				const installedBrowser = await (0, _puppeteer_browsers.install)(installOption);
+				if (await this.hasBrowserInstalled(browser, buildId)) {
+					_nestjs_common.Logger.log("Browser installed successfully", "NestJsPdf");
+					if (lock) this.writeLockFile(browser, buildId);
+					return installedBrowser;
+				} else _nestjs_common.Logger.error("Browser installation failed", "NestJsPdf");
+			} else _nestjs_common.Logger.error(`Error, can't install ${installOption.browser} ${installOption.buildId}`, "NestJsPdf");
+		}
+		return null;
+	}
+	registerCleanupHooks() {
+		const cleanup = async (signal) => {
+			try {
+				_nestjs_common.Logger.log(`Received ${signal}, cleaning up puppeteer cache...`, "NestJsPdf");
+				await this.cleanupCacheBestEffort();
+				process.exit(0);
+			} catch {
+				process.exit(1);
+			}
+		};
+		const cleanupHandler = (signal) => {
+			cleanup(signal);
+		};
+		process.once("SIGTERM", cleanupHandler);
+		process.once("SIGINT", cleanupHandler);
+		process.once("exit", cleanupHandler);
+	}
+	loadBrowser() {
+		let browser;
+		if (this.options?.browser === void 0) browser = _puppeteer_browsers.Browser.CHROMIUM;
+		else browser = this.options.browser;
+		this.browser = browser;
+	}
+	setBrowser(browser) {
+		this.browser = browser;
+	}
+	getBrowser() {
+		return this.browser;
+	}
+	loadBrowserTag() {
+		let versionTag;
+		if (this.options?.browserTag === void 0) if (this.browser === _puppeteer_browsers.Browser.CHROMIUM) versionTag = "latest";
+		else versionTag = "stable";
+		else versionTag = this.options.browserTag;
+		this.browserTag = versionTag;
+	}
+	loadBuildId() {
+		let buildId;
+		if (this.options?.buildId === void 0) buildId = void 0;
+		else buildId = this.options.buildId;
+		this.buildId = buildId;
+	}
+	setBrowserTag(browserTag) {
+		this.browserTag = browserTag;
+	}
+	getBrowserTag() {
+		return this.browserTag;
+	}
+	getBuildId() {
+		return this.buildId;
+	}
+	setBuildId(value) {
+		this.buildId = value;
+	}
+	loadUseLockedBrowser() {
+		let useLockedBrowser;
+		if (this.options?.useLockedBrowser === void 0) useLockedBrowser = false;
+		else useLockedBrowser = this.options.useLockedBrowser;
+		this.useLockedBrowser = useLockedBrowser;
+	}
+	async hasBrowserInstalled(browser, buildId) {
+		return (await (0, _puppeteer_browsers.getInstalledBrowsers)({ cacheDir: this.cacheDir })).find((insBrowser) => {
+			return insBrowser.browser === browser && insBrowser.buildId === buildId;
+		}) !== void 0;
+	}
+	async getExecutablePath() {
+		const browser = this.browser;
+		const versionTag = this.browserTag;
+		const browserPlatform = (0, _puppeteer_browsers.detectBrowserPlatform)() ?? _puppeteer_browsers.BrowserPlatform.LINUX;
+		let buildId = null;
+		if (this.useLockedBrowser) {
+			buildId = this.getLockedBuildId(browser);
+			_nestjs_common.Logger.log(`Using locked browser ${buildId}`, "NestJsPdf");
+		}
+		buildId ??= await (0, _puppeteer_browsers.resolveBuildId)(browser, browserPlatform, versionTag);
+		const installedBrowser = (await (0, _puppeteer_browsers.getInstalledBrowsers)({ cacheDir: this.cacheDir })).find((insBrowser) => {
+			return insBrowser.browser === browser && insBrowser.buildId === buildId;
+		});
+		if (installedBrowser === void 0) {
+			const newinstalledBrowser = await this.install();
+			if (newinstalledBrowser === null || newinstalledBrowser === void 0) throw new Error("Could not install browser");
+			else return newinstalledBrowser.executablePath;
+		}
+		return installedBrowser.executablePath;
+	}
+	async launchBrowser(args, headless, executablePathBin) {
+		const executablePath = executablePathBin ?? await this.getExecutablePath();
+		const browser = await (0, puppeteer.launch)({
+			executablePath,
+			headless,
+			args
+		});
+		browser.on("disconnected", () => {
+			_nestjs_common.Logger.warn("Puppeteer browser disconnected");
+			if (this._browserInstance === browser) this._browserInstance = null;
+		});
+		return browser;
+	}
+	writeLockFile(browser, buildId) {
+		const lockFile = (0, node_path.resolve)(this.cacheDir, `${browser}.lock`);
+		const data = JSON.stringify({
+			browser,
+			buildId,
+			date: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		(0, node_fs.writeFileSync)(lockFile, data);
+		_nestjs_common.Logger.log(`Browser ${browser} locked to build ${buildId}`, "NestJsPdf");
+	}
+	getLockedBuildId(browser) {
+		const lockFile = (0, node_path.resolve)(this.cacheDir, `${browser}.lock`);
+		if ((0, node_fs.existsSync)(lockFile)) {
+			const data = (0, node_fs.readFileSync)(lockFile);
+			return JSON.parse(data.toString()).buildId;
+		}
+		return null;
+	}
+};
+BrowserService = __decorate([
+	(0, _nestjs_common.Injectable)(),
+	__decorateParam(0, (0, _nestjs_common.Inject)("PDF_PARAMETERS")),
+	__decorateMetadata("design:paramtypes", [Object])
+], BrowserService);
+//#endregion
+//#region src/puppeteer/engines/ejs/ejs.service.ts
+let EjsService = class EjsService {
+	async render(template, data = {}, options) {
+		try {
+			return await (0, ejs.render)(template, data, {
+				async: true,
+				...options
+			});
+		} catch (error) {
+			throw new Error(`EJS rendering failed: ${String(error)}`, { cause: error });
+		}
+	}
+	async renderFile(filePath, data = {}, options) {
+		try {
+			return await (0, ejs.renderFile)(filePath, data, {
+				async: true,
+				...options
+			});
+		} catch (error) {
+			throw new Error(`EJS file rendering failed: ${String(error)}`, { cause: error });
+		}
+	}
+};
+EjsService = __decorate([(0, _nestjs_common.Injectable)()], EjsService);
+//#endregion
+//#region src/puppeteer/engines/eta/eta.service.ts
+let EtaService = class EtaService {
+	eta;
+	templateCache = /* @__PURE__ */ new Map();
+	maxCacheSize = 100;
+	constructor() {
+		this.eta = new eta.Eta({
+			cache: true,
+			autoEscape: true,
+			useWith: true
+		});
+	}
+	/**
+	* Render an Eta template from a string
+	* @param template The template string to render
+	* @param data The data object to use for rendering
+	* @param options Optional Eta rendering options
+	* @returns The rendered HTML string
+	*/
+	render(template, data = {}, options) {
+		try {
+			return (options && Object.keys(options).length > 0 ? new eta.Eta({
+				cache: true,
+				autoEscape: true,
+				useWith: true,
+				...options,
+				varName: options.varName ?? "it"
+			}) : this.eta).renderString(template, data);
+		} catch (error) {
+			throw new Error(`Eta rendering failed: ${String(error)}`, { cause: error });
+		}
+	}
+	/**
+	* Render an Eta template from a file
+	* @param filePath The path to the template file
+	* @param data The data object to use for rendering
+	* @param options Optional Eta rendering options
+	* @returns The rendered HTML string
+	*/
+	renderFile(filePath, data = {}, options) {
+		try {
+			const resolvedPath = (0, node_path.resolve)(filePath);
+			const useCache = options?.cache ?? true;
+			let template = useCache ? this.templateCache.get(resolvedPath) : void 0;
+			if (!template) {
+				template = (0, node_fs.readFileSync)(resolvedPath, "utf-8");
+				if (useCache && this.templateCache.size < this.maxCacheSize) this.templateCache.set(resolvedPath, template);
+			}
+			return this.render(template, data, options);
+		} catch (error) {
+			throw new Error(`Eta file rendering failed for ${filePath}: ${String(error)}`, { cause: error });
+		}
+	}
+	/**
+	* Clear the template cache
+	*/
+	clearCache() {
+		this.templateCache.clear();
+	}
+	/**
+	* Get the current cache size
+	* @returns The number of cached templates
+	*/
+	getCacheSize() {
+		return this.templateCache.size;
+	}
+};
+EtaService = __decorate([(0, _nestjs_common.Injectable)(), __decorateMetadata("design:paramtypes", [])], EtaService);
+//#endregion
+//#region src/puppeteer/engines/mjml/mjml.service.ts
+let MjmlService = class MjmlService {
+	async render(template, options) {
+		const { html } = await (0, mjml.default)(template, options);
+		return html;
+	}
+	async renderFile(filePath, options) {
+		const template = (0, node_fs.readFileSync)(filePath, "utf-8");
+		return await this.render(template, options);
+	}
+};
+MjmlService = __decorate([(0, _nestjs_common.Injectable)()], MjmlService);
+//#endregion
+//#region src/puppeteer/engines/mustache/mustache.service.ts
+let MustacheService = class MustacheService {
+	templateCache = /* @__PURE__ */ new Map();
+	maxCacheSize = 100;
+	/**
+	* Render a Mustache template from a string
+	* @param template The template string to render
+	* @param data The data object to use for rendering
+	* @param options Optional Mustache rendering options
+	* @returns The rendered HTML string
+	*/
+	render(template, data = {}, options) {
+		try {
+			const tags = options?.tags ?? ["{{", "}}"];
+			return mustache.default.render(template, data, void 0, {
+				tags,
+				escape: options?.escape
+			});
+		} catch (error) {
+			throw new Error(`Mustache rendering failed: ${String(error)}`, { cause: error });
+		}
+	}
+	/**
+	* Render a Mustache template from a file
+	* @param filePath The path to the template file
+	* @param data The data object to use for rendering
+	* @param options Optional Mustache rendering options
+	* @returns The rendered HTML string
+	*/
+	renderFile(filePath, data = {}, options) {
+		try {
+			const resolvedPath = (0, node_path.resolve)(filePath);
+			let template = this.templateCache.get(resolvedPath);
+			if (!template) {
+				template = (0, node_fs.readFileSync)(resolvedPath, "utf-8");
+				if (this.templateCache.size < this.maxCacheSize) this.templateCache.set(resolvedPath, template);
+			}
+			return this.render(template, data, options);
+		} catch (error) {
+			throw new Error(`Mustache file rendering failed for ${filePath}: ${String(error)}`, { cause: error });
+		}
+	}
+	/**
+	* Clear the template cache
+	*/
+	clearCache() {
+		this.templateCache.clear();
+	}
+	/**
+	* Get the current cache size
+	* @returns The number of cached templates
+	*/
+	getCacheSize() {
+		return this.templateCache.size;
+	}
+};
+MustacheService = __decorate([(0, _nestjs_common.Injectable)()], MustacheService);
+//#endregion
+//#region src/puppeteer/engines/nunjucks/nunjucks.service.ts
+let NunjucksService = class NunjucksService {
+	constructor() {
+		(0, nunjucks.configure)({
+			noCache: true,
+			trimBlocks: true,
+			lstripBlocks: true
+		});
+	}
+	render(template, data = {}, options) {
+		try {
+			if (options) {
+				const configOptions = {
+					noCache: options.noCache ?? true,
+					watch: options.watch ?? false,
+					throwOnUndefined: options.throwOnUndefined ?? false,
+					trimBlocks: options.trimBlocks ?? true,
+					lstripBlocks: options.lstripBlocks ?? true
+				};
+				(0, nunjucks.configure)(configOptions);
+			}
+			return (0, nunjucks.renderString)(template, data);
+		} catch (error) {
+			throw new Error(`Nunjucks rendering failed: ${String(error)}`, { cause: error });
+		}
+	}
+	renderFile(filePath, data = {}, options) {
+		try {
+			if (options) {
+				const configOptions = {
+					noCache: options.noCache ?? true,
+					watch: options.watch ?? false,
+					throwOnUndefined: options.throwOnUndefined ?? false,
+					trimBlocks: options.trimBlocks ?? true,
+					lstripBlocks: options.lstripBlocks ?? true
+				};
+				(0, nunjucks.configure)(configOptions);
+			}
+			return (0, nunjucks.render)(filePath, data);
+		} catch (error) {
+			throw new Error(`Nunjucks file rendering failed: ${String(error)}`, { cause: error });
+		}
+	}
+};
+NunjucksService = __decorate([(0, _nestjs_common.Injectable)(), __decorateMetadata("design:paramtypes", [])], NunjucksService);
+//#endregion
+//#region src/puppeteer/engines/pug/pug.service.ts
+let PugService = class PugService {
+	render(template, data = {}, options) {
+		try {
+			return (0, pug.compile)(template, { ...options })(data);
+		} catch (error) {
+			throw new Error(`Pug rendering failed: ${String(error)}`, { cause: error });
+		}
+	}
+	renderFile(filePath, data = {}, options) {
+		try {
+			const template = (0, node_fs.readFileSync)(filePath, "utf-8");
+			return this.render(template, data, options);
+		} catch (error) {
+			throw new Error(`Pug file rendering failed: ${String(error)}`, { cause: error });
+		}
+	}
+};
+PugService = __decorate([(0, _nestjs_common.Injectable)()], PugService);
+//#endregion
+//#region src/puppeteer/libs/requireService.utils.ts
+function requireService(service, name) {
+	if (!service) throw new Error(`${name} service is not available. If the problem persists, open an issue in the repo.`);
+	return service;
+}
+//#endregion
+//#region src/puppeteer/puppeteer.service.ts
+let PuppeteerService = class PuppeteerService {
+	browserService;
+	options;
+	hbsService;
+	mjmlService;
+	pugService;
+	ejsService;
+	nunjucksService;
+	etaService;
+	mustacheService;
+	constructor(browserService, options, hbsService, mjmlService, pugService, ejsService, nunjucksService, etaService, mustacheService) {
+		this.browserService = browserService;
+		this.options = options;
+		this.hbsService = hbsService;
+		this.mjmlService = mjmlService;
+		this.pugService = pugService;
+		this.ejsService = ejsService;
+		this.nunjucksService = nunjucksService;
+		this.etaService = etaService;
+		this.mustacheService = mustacheService;
+	}
+	limit = (0, p_limit.default)(3);
+	async generatePdfFromHtml(html, options) {
+		return this.limit(async () => {
+			const mergePuppeteerOptions = mergePuppeteerParameters(this.options, options);
+			if (mergePuppeteerOptions.chromiumRevision !== void 0) _nestjs_common.Logger.warn("Using `chromiumRevision` is no longer supported since the puppeteer update.");
+			const headless = mergePuppeteerOptions.headless ?? true;
+			const executablePath = mergePuppeteerOptions.executablePath || void 0;
+			const args = mergePuppeteerOptions.extraPuppeteerArgs || [
+				"--autoplay-policy=user-gesture-required",
+				"--disable-background-networking",
+				"--disable-background-timer-throttling",
+				"--disable-backgrounding-occluded-windows",
+				"--disable-breakpad",
+				"--disable-client-side-phishing-detection",
+				"--disable-component-update",
+				"--disable-default-apps",
+				"--disable-dev-shm-usage",
+				"--disable-domain-reliability",
+				"--disable-extensions",
+				"--disable-features=AudioServiceOutOfProcess",
+				"--disable-hang-monitor",
+				"--disable-ipc-flooding-protection",
+				"--disable-notifications",
+				"--disable-offer-store-unmasked-wallet-cards",
+				"--disable-popup-blocking",
+				"--disable-print-preview",
+				"--disable-prompt-on-repost",
+				"--disable-renderer-backgrounding",
+				"--disable-setuid-sandbox",
+				"--disable-speech-api",
+				"--disable-sync",
+				"--hide-scrollbars",
+				"--ignore-gpu-blacklist",
+				"--metrics-recording-only",
+				"--mute-audio",
+				"--no-default-browser-check",
+				"--no-first-run",
+				"--no-pings",
+				"--password-store=basic",
+				"--use-gl=swiftshader",
+				"--use-mock-keychain",
+				"--disable-accelerated-2d-canvas",
+				"--no-zygote",
+				"--disable-gpu"
+			];
+			this.browserService.markJobStarted();
+			let context = null;
+			try {
+				context = await this.browserService.createContext(args, headless, executablePath);
+				const page = await context.newPage();
+				const pdfOptions = mergePuppeteerOptions.pdfOptions ?? { format: "A4" };
+				await page.setContent(html, { waitUntil: "domcontentloaded" });
+				await page.emulateMediaType("screen");
+				await page.waitForNetworkIdle({
+					idleTime: 500,
+					timeout: 3e4
+				});
+				await page.evaluate(() => document.fonts.ready);
+				return await page.pdf(pdfOptions);
+			} catch (e) {
+				_nestjs_common.Logger.error(e);
+				throw e;
+			} finally {
+				if (context) try {
+					await context.close();
+				} catch (error) {
+					_nestjs_common.Logger.error(error);
+				}
+				await this.browserService.markJobFinished();
+			}
+		});
+	}
+	async generatePdfFromTemplateHbsString(template, parameters = {}, options) {
+		const html = requireService(this.hbsService, "Handlebars").render(template, parameters);
+		return this.generatePdfFromHtml(html, options);
+	}
+	async generatePdfFromTemplateHbsFile(file, parameters = {}, options) {
+		const html = requireService(this.hbsService, "Handlebars").renderFile(file, parameters);
+		return this.generatePdfFromHtml(html, options);
+	}
+	async generatePdfFromMjmlString(template, options) {
+		const html = await requireService(this.mjmlService, "MJML").render(template, options?.mjmlOptions ?? this.options.mjmlOptions);
+		return this.generatePdfFromHtml(html, options);
+	}
+	async generatePdfFromMjmlFile(file, options) {
+		const html = await requireService(this.mjmlService, "MJML").renderFile(file, options?.mjmlOptions ?? this.options.mjmlOptions);
+		return this.generatePdfFromHtml(html, options);
+	}
+	async generatePdfFromPugString(template, data = {}, options) {
+		const html = requireService(this.pugService, "Pug").render(template, data, options?.pugOptions ?? this.options.pugOptions);
+		return this.generatePdfFromHtml(html, options);
+	}
+	async generatePdfFromPugFile(file, data = {}, options) {
+		const html = requireService(this.pugService, "Pug").renderFile(file, data, options?.pugOptions ?? this.options.pugOptions);
+		return this.generatePdfFromHtml(html, options);
+	}
+	async generatePdfFromEjsString(template, data = {}, options) {
+		const html = await requireService(this.ejsService, "EJS").render(template, data, options?.ejsOptions ?? this.options.ejsOptions);
+		return this.generatePdfFromHtml(html, options);
+	}
+	async generatePdfFromEjsFile(file, data = {}, options) {
+		const html = await requireService(this.ejsService, "EJS").renderFile(file, data, options?.ejsOptions ?? this.options.ejsOptions);
+		return this.generatePdfFromHtml(html, options);
+	}
+	async generatePdfFromNunjucksString(template, data = {}, options) {
+		const html = requireService(this.nunjucksService, "Nunjucks").render(template, data, options?.nunjucksOptions ?? this.options.nunjucksOptions);
+		return this.generatePdfFromHtml(html, options);
+	}
+	async generatePdfFromNunjucksFile(file, data = {}, options) {
+		const html = requireService(this.nunjucksService, "Nunjucks").renderFile(file, data, options?.nunjucksOptions ?? this.options.nunjucksOptions);
+		return this.generatePdfFromHtml(html, options);
+	}
+	async generatePdfFromEtaString(template, data = {}, options) {
+		const html = requireService(this.etaService, "Eta").render(template, data, options?.etaOptions ?? this.options.etaOptions);
+		return this.generatePdfFromHtml(html, options);
+	}
+	async generatePdfFromEtaFile(file, data = {}, options) {
+		const html = requireService(this.etaService, "Eta").renderFile(file, data, options?.etaOptions ?? this.options.etaOptions);
+		return this.generatePdfFromHtml(html, options);
+	}
+	async generatePdfFromMustacheString(template, data = {}, options) {
+		const html = requireService(this.mustacheService, "Mustache").render(template, data, options?.mustacheOptions ?? this.options.mustacheOptions);
+		return this.generatePdfFromHtml(html, options);
+	}
+	async generatePdfFromMustacheFile(file, data = {}, options) {
+		const html = requireService(this.mustacheService, "Mustache").renderFile(file, data, options?.mustacheOptions ?? this.options.mustacheOptions);
+		return this.generatePdfFromHtml(html, options);
+	}
+};
+PuppeteerService = __decorate([
+	(0, _nestjs_common.Injectable)(),
+	__decorateParam(1, (0, _nestjs_common.Inject)(PDF_PARAMETERS)),
+	__decorateParam(2, (0, _nestjs_common.Optional)()),
+	__decorateParam(3, (0, _nestjs_common.Optional)()),
+	__decorateParam(4, (0, _nestjs_common.Optional)()),
+	__decorateParam(5, (0, _nestjs_common.Optional)()),
+	__decorateParam(6, (0, _nestjs_common.Optional)()),
+	__decorateParam(7, (0, _nestjs_common.Optional)()),
+	__decorateParam(8, (0, _nestjs_common.Optional)()),
+	__decorateMetadata("design:paramtypes", [
+		typeof BrowserService === "undefined" ? Object : BrowserService,
+		Object,
+		typeof _gboutte_nestjs_hbs.HandlebarsService === "undefined" ? Object : _gboutte_nestjs_hbs.HandlebarsService,
+		typeof MjmlService === "undefined" ? Object : MjmlService,
+		typeof PugService === "undefined" ? Object : PugService,
+		typeof EjsService === "undefined" ? Object : EjsService,
+		typeof NunjucksService === "undefined" ? Object : NunjucksService,
+		typeof EtaService === "undefined" ? Object : EtaService,
+		typeof MustacheService === "undefined" ? Object : MustacheService
+	])
+], PuppeteerService);
+//#endregion
+//#region src/nestjs-pdf.service.ts
+let NestjsPdfService = class NestjsPdfService {
+	puppeteerService;
+	constructor(puppeteerService) {
+		this.puppeteerService = puppeteerService;
+	}
+	/**
+	* @param html HTML string to convert to PDF
+	* @param options PDF generation options (optional)
+	* @returns PDF generated from the provided HTML
+	* @description This method uses the Puppeteer service to generate a PDF from an HTML string. Generation options can be customized by passing a `PuppeteerParameters` object as the second argument. This allows you to control various aspects of PDF rendering, such as page size, margins, background display, etc. If no options are provided, the default parameters defined in the Puppeteer service will be used.
+	*/
+	generatePdfFromHtml(html, options) {
+		return this.puppeteerService.generatePdfFromHtml(html, options);
+	}
+	/**
+	* @param template Handlebars template string
+	* @param parameters Data parameters to inject into the template
+	* @param options PDF generation options (optional)
+	* @returns PDF generated from the provided Handlebars template with parameters applied
+	* @description This method generates a PDF from a Handlebars template provided as a string. The parameters to inject into the template are passed in the `parameters` object, which is used to render the template before converting it to PDF. PDF generation options can also be customized by passing a `PuppeteerParameters` object as the third argument. This allows you to control various aspects of PDF rendering, such as page size, margins, background display, etc. If no options are provided, the default parameters defined in the Puppeteer service will be used.
+	*/
+	generatePdfFromTemplateHbsString(template, parameters = {}, options) {
+		return this.puppeteerService.generatePdfFromTemplateHbsString(template, parameters, options);
+	}
+	/**
+	* @param file Path to the Handlebars template file
+	* @param parameters Data parameters to inject into the template
+	* @param options PDF generation options (optional)
+	* @returns PDF generated from the Handlebars template at the provided file path with parameters applied
+	* @description This method generates a PDF from a Handlebars template located at the specified file path. The file path is passed as a string in the `file` parameter. The parameters to inject into the template are passed in the `parameters` object, which is used to render the template before converting it to PDF. PDF generation options can also be customized by passing a `PuppeteerParameters` object as the third argument. This allows you to control various aspects of PDF rendering, such as page size, margins, background display, etc. If no options are provided, the default parameters defined in the Puppeteer service will be used.
+	*/
+	generatePdfFromTemplateHbsFile(file, parameters = {}, options) {
+		return this.puppeteerService.generatePdfFromTemplateHbsFile(file, parameters, options);
+	}
+	/**
+	* @param template MJML template string
+	* @param options PDF generation options (optional)
+	* @returns PDF generated from the provided MJML template
+	* @description This method generates a PDF from an MJML template provided as a string. MJML (MJML Markup Language) is a markup language designed to reduce the pain of coding a responsive email. The template is first rendered to HTML using the MJML renderer, then converted to PDF. PDF generation options can be customized by passing a `PuppeteerParameters` object as the second argument.
+	*/
+	generatePdfFromMjmlString(template, options) {
+		return this.puppeteerService.generatePdfFromMjmlString(template, options);
+	}
+	/**
+	* @param file Path to the MJML template file
+	* @param options PDF generation options (optional)
+	* @returns PDF generated from the MJML template at the provided file path
+	* @description This method generates a PDF from an MJML template located at the specified file path. The file path is passed as a string in the `file` parameter. The template is first rendered to HTML using the MJML renderer, then converted to PDF. PDF generation options can be customized by passing a `PuppeteerParameters` object as the second argument.
+	*/
+	generatePdfFromMjmlFile(file, options) {
+		return this.puppeteerService.generatePdfFromMjmlFile(file, options);
+	}
+	/**
+	* @param template EJS template string
+	* @param data Data to inject into the template
+	* @param options PDF generation options (optional)
+	* @returns PDF generated from the provided EJS template with data applied
+	* @description This method generates a PDF from an EJS (Embedded JavaScript) template provided as a string. EJS is a templating language with a simple, straightforward syntax. The data to inject into the template is passed in the `data` object, which is used to render the template before converting it to PDF. PDF generation options can be customized by passing a `PuppeteerParameters` object as the third argument.
+	*/
+	generatePdfFromEjsString(template, data = {}, options) {
+		return this.puppeteerService.generatePdfFromEjsString(template, data, options);
+	}
+	/**
+	* @param file Path to the EJS template file
+	* @param data Data to inject into the template
+	* @param options PDF generation options (optional)
+	* @returns PDF generated from the EJS template at the provided file path with data applied
+	* @description This method generates a PDF from an EJS template located at the specified file path. The file path is passed as a string in the `file` parameter. The data to inject into the template is passed in the `data` object, which is used to render the template before converting it to PDF. PDF generation options can be customized by passing a `PuppeteerParameters` object as the third argument.
+	*/
+	generatePdfFromEjsFile(file, data = {}, options) {
+		return this.puppeteerService.generatePdfFromEjsFile(file, data, options);
+	}
+	/**
+	* @param template Pug template string
+	* @param data Data to inject into the template
+	* @param options PDF generation options (optional)
+	* @returns PDF generated from the provided Pug template with data applied
+	* @description This method generates a PDF from a Pug template provided as a string. Pug is a clean, whitespace-sensitive syntax for writing HTML. The data to inject into the template is passed in the `data` object, which is used to render the template before converting it to PDF. PDF generation options can be customized by passing a `PuppeteerParameters` object as the third argument.
+	*/
+	generatePdfFromPugString(template, data = {}, options) {
+		return this.puppeteerService.generatePdfFromPugString(template, data, options);
+	}
+	/**
+	* @param file Path to the Pug template file
+	* @param data Data to inject into the template
+	* @param options PDF generation options (optional)
+	* @returns PDF generated from the Pug template at the provided file path with data applied
+	* @description This method generates a PDF from a Pug template located at the specified file path. The file path is passed as a string in the `file` parameter. The data to inject into the template is passed in the `data` object, which is used to render the template before converting it to PDF. PDF generation options can be customized by passing a `PuppeteerParameters` object as the third argument.
+	*/
+	generatePdfFromPugFile(file, data = {}, options) {
+		return this.puppeteerService.generatePdfFromPugFile(file, data, options);
+	}
+	/**
+	* @param template Nunjucks template string
+	* @param data Data to inject into the template
+	* @param options PDF generation options (optional)
+	* @returns PDF generated from the provided Nunjucks template with data applied
+	* @description This method generates a PDF from a Nunjucks template provided as a string. Nunjucks is a powerful templating language with support for inheritance, macros, and filters. The data to inject into the template is passed in the `data` object, which is used to render the template before converting it to PDF. PDF generation options can be customized by passing a `PuppeteerParameters` object as the third argument.
+	*/
+	generatePdfFromNunjucksString(template, data = {}, options) {
+		return this.puppeteerService.generatePdfFromNunjucksString(template, data, options);
+	}
+	/**
+	* @param file Path to the Nunjucks template file
+	* @param data Data to inject into the template
+	* @param options PDF generation options (optional)
+	* @returns PDF generated from the Nunjucks template at the provided file path with data applied
+	* @description This method generates a PDF from a Nunjucks template located at the specified file path. The file path is passed as a string in the `file` parameter. The data to inject into the template is passed in the `data` object, which is used to render the template before converting it to PDF. PDF generation options can be customized by passing a `PuppeteerParameters` object as the third argument.
+	*/
+	generatePdfFromNunjucksFile(file, data = {}, options) {
+		return this.puppeteerService.generatePdfFromNunjucksFile(file, data, options);
+	}
+	/**
+	* @param template Eta template string
+	* @param data Data to inject into the template
+	* @param options PDF generation options (optional)
+	* @returns PDF generated from the provided Eta template with data applied
+	* @description This method generates a PDF from an Eta template provided as a string. Eta is a fast and lightweight embedded templating language with a syntax similar to EJS but with better performance. The data to inject into the template is passed in the `data` object, which is used to render the template before converting it to PDF. PDF generation options can be customized by passing a `PuppeteerParameters` object as the third argument.
+	*/
+	generatePdfFromEtaString(template, data = {}, options) {
+		return this.puppeteerService.generatePdfFromEtaString(template, data, options);
+	}
+	/**
+	* @param file Path to the Eta template file
+	* @param data Data to inject into the template
+	* @param options PDF generation options (optional)
+	* @returns PDF generated from the Eta template at the provided file path with data applied
+	* @description This method generates a PDF from an Eta template located at the specified file path. The file path is passed as a string in the `file` parameter. The data to inject into the template is passed in the `data` object, which is used to render the template before converting it to PDF. PDF generation options can be customized by passing a `PuppeteerParameters` object as the third argument.
+	*/
+	generatePdfFromEtaFile(file, data = {}, options) {
+		return this.puppeteerService.generatePdfFromEtaFile(file, data, options);
+	}
+	/**
+	* @param template Mustache template string
+	* @param data Data to inject into the template
+	* @param options PDF generation options (optional)
+	* @returns PDF generated from the provided Mustache template with data applied
+	* @description This method generates a PDF from a Mustache template provided as a string. Mustache is a logic-less template language that emphasizes readable and simple templates. The data to inject into the template is passed in the `data` object, which is used to render the template before converting it to PDF. PDF generation options can be customized by passing a `PuppeteerParameters` object as the third argument.
+	*/
+	generatePdfFromMustacheString(template, data = {}, options) {
+		return this.puppeteerService.generatePdfFromMustacheString(template, data, options);
+	}
+	/**
+	* @param file Path to the Mustache template file
+	* @param data Data to inject into the template
+	* @param options PDF generation options (optional)
+	* @returns PDF generated from the Mustache template at the provided file path with data applied
+	* @description This method generates a PDF from a Mustache template located at the specified file path. The file path is passed as a string in the `file` parameter. The data to inject into the template is passed in the `data` object, which is used to render the template before converting it to PDF. PDF generation options can be customized by passing a `PuppeteerParameters` object as the third argument.
+	*/
+	generatePdfFromMustacheFile(file, data = {}, options) {
+		return this.puppeteerService.generatePdfFromMustacheFile(file, data, options);
+	}
+	/**
+	* @param pdf The PDF bytes to modify
+	* @param fieldName The name of the signature field to add (default: 'SignatureDebtor')
+	* @param anchorText The text anchor to locate the signature field position (default: '__SIG_DEBTOR_ANCHOR__')
+	* @returns Modified PDF with a signature field added at the anchor position
+	* @description This method adds a signature field to a PDF using a text anchor as a reference for the field position. It uses the `addSignatureFieldUsingAnchor` function which finds the anchor in the PDF and inserts a signature field at that location. The signature field is named according to the `fieldName` parameter and the anchor is defined by `anchorText`.
+	*
+	* Usage example:
+	* ```typescript
+	* const modifiedPdf = await pdfService.addSignatureFieldSignatureDebtorRaw(
+	*   originalPdfBytes,
+	*   'SignatureDebtor',
+	*   '__SIG_DEBTOR_ANCHOR__'
+	* );
+	* ```
+	*
+	* In this example, `originalPdfBytes` is a byte array representing the original PDF, `SignatureDebtor` is the name of the signature field to add, and `__SIG_DEBTOR_ANCHOR__` is the anchor text used to position the signature field in the PDF.
+	*
+	* If the anchor is not found, the signature field will be added at a default position (centered at the bottom of the last page).
+	*
+	* Note: Ensure that the input PDF contains the anchor defined by `anchorText` for the signature field to be positioned correctly. Otherwise, it will be added at a default position.
+	*/
+	async addSignatureFieldSignatureDebtorRaw(pdf, fieldName = "SignatureDebtor", anchorText = "__SIG_DEBTOR_ANCHOR__") {
+		return await addSignatureFieldUsingAnchor(pdf, fieldName, anchorText);
+	}
+};
+NestjsPdfService = __decorate([(0, _nestjs_common.Injectable)(), __decorateMetadata("design:paramtypes", [typeof PuppeteerService === "undefined" ? Object : PuppeteerService])], NestjsPdfService);
+//#endregion
+//#region node_modules/.pnpm/dotenv@17.4.1/node_modules/dotenv/lib/main.js
+var require_main$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs$1 = require("fs");
+	const path = require("path");
+	const os = require("os");
+	const crypto = require("crypto");
+	const TIPS = [
+		"◈ encrypted .env [www.dotenvx.com]",
+		"◈ secrets for agents [www.dotenvx.com]",
+		"⌁ auth for agents [www.vestauth.com]",
+		"⌘ custom filepath { path: '/custom/path/.env' }",
+		"⌘ enable debugging { debug: true }",
+		"⌘ override existing { override: true }",
+		"⌘ suppress logs { quiet: true }",
+		"⌘ multiple files { path: ['.env.local', '.env'] }"
+	];
+	function _getRandomTip() {
+		return TIPS[Math.floor(Math.random() * TIPS.length)];
+	}
+	function parseBoolean(value) {
+		if (typeof value === "string") return ![
+			"false",
+			"0",
+			"no",
+			"off",
+			""
+		].includes(value.toLowerCase());
+		return Boolean(value);
+	}
+	function supportsAnsi() {
+		return process.stdout.isTTY;
+	}
+	function dim(text) {
+		return supportsAnsi() ? `\x1b[2m${text}\x1b[0m` : text;
+	}
+	const LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
+	function parse(src) {
+		const obj = {};
+		let lines = src.toString();
+		lines = lines.replace(/\r\n?/gm, "\n");
+		let match;
+		while ((match = LINE.exec(lines)) != null) {
+			const key = match[1];
+			let value = match[2] || "";
+			value = value.trim();
+			const maybeQuote = value[0];
+			value = value.replace(/^(['"`])([\s\S]*)\1$/gm, "$2");
+			if (maybeQuote === "\"") {
+				value = value.replace(/\\n/g, "\n");
+				value = value.replace(/\\r/g, "\r");
+			}
+			obj[key] = value;
+		}
+		return obj;
+	}
+	function _parseVault(options) {
+		options = options || {};
+		const vaultPath = _vaultPath(options);
+		options.path = vaultPath;
+		const result = DotenvModule.configDotenv(options);
+		if (!result.parsed) {
+			const err = /* @__PURE__ */ new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+			err.code = "MISSING_DATA";
+			throw err;
+		}
+		const keys = _dotenvKey(options).split(",");
+		const length = keys.length;
+		let decrypted;
+		for (let i = 0; i < length; i++) try {
+			const attrs = _instructions(result, keys[i].trim());
+			decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+			break;
+		} catch (error) {
+			if (i + 1 >= length) throw error;
+		}
+		return DotenvModule.parse(decrypted);
+	}
+	function _warn(message) {
+		console.error(`⚠ ${message}`);
+	}
+	function _debug(message) {
+		console.log(`┆ ${message}`);
+	}
+	function _log(message) {
+		console.log(`◇ ${message}`);
+	}
+	function _dotenvKey(options) {
+		if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) return options.DOTENV_KEY;
+		if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) return process.env.DOTENV_KEY;
+		return "";
+	}
+	function _instructions(result, dotenvKey) {
+		let uri;
+		try {
+			uri = new URL(dotenvKey);
+		} catch (error) {
+			if (error.code === "ERR_INVALID_URL") {
+				const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
+				err.code = "INVALID_DOTENV_KEY";
+				throw err;
+			}
+			throw error;
+		}
+		const key = uri.password;
+		if (!key) {
+			const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: Missing key part");
+			err.code = "INVALID_DOTENV_KEY";
+			throw err;
+		}
+		const environment = uri.searchParams.get("environment");
+		if (!environment) {
+			const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: Missing environment part");
+			err.code = "INVALID_DOTENV_KEY";
+			throw err;
+		}
+		const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+		const ciphertext = result.parsed[environmentKey];
+		if (!ciphertext) {
+			const err = /* @__PURE__ */ new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+			err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
+			throw err;
+		}
+		return {
+			ciphertext,
+			key
+		};
+	}
+	function _vaultPath(options) {
+		let possibleVaultPath = null;
+		if (options && options.path && options.path.length > 0) if (Array.isArray(options.path)) {
+			for (const filepath of options.path) if (fs$1.existsSync(filepath)) possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+		} else possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
+		else possibleVaultPath = path.resolve(process.cwd(), ".env.vault");
+		if (fs$1.existsSync(possibleVaultPath)) return possibleVaultPath;
+		return null;
+	}
+	function _resolveHome(envPath) {
+		return envPath[0] === "~" ? path.join(os.homedir(), envPath.slice(1)) : envPath;
+	}
+	function _configVault(options) {
+		const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
+		const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || options && options.quiet);
+		if (debug || !quiet) _log("loading env from encrypted .env.vault");
+		const parsed = DotenvModule._parseVault(options);
+		let processEnv = process.env;
+		if (options && options.processEnv != null) processEnv = options.processEnv;
+		DotenvModule.populate(processEnv, parsed, options);
+		return { parsed };
+	}
+	function configDotenv(options) {
+		const dotenvPath = path.resolve(process.cwd(), ".env");
+		let encoding = "utf8";
+		let processEnv = process.env;
+		if (options && options.processEnv != null) processEnv = options.processEnv;
+		let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || options && options.debug);
+		let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options && options.quiet);
+		if (options && options.encoding) encoding = options.encoding;
+		else if (debug) _debug("no encoding is specified (UTF-8 is used by default)");
+		let optionPaths = [dotenvPath];
+		if (options && options.path) if (!Array.isArray(options.path)) optionPaths = [_resolveHome(options.path)];
+		else {
+			optionPaths = [];
+			for (const filepath of options.path) optionPaths.push(_resolveHome(filepath));
+		}
+		let lastError;
+		const parsedAll = {};
+		for (const path of optionPaths) try {
+			const parsed = DotenvModule.parse(fs$1.readFileSync(path, { encoding }));
+			DotenvModule.populate(parsedAll, parsed, options);
+		} catch (e) {
+			if (debug) _debug(`failed to load ${path} ${e.message}`);
+			lastError = e;
+		}
+		const populated = DotenvModule.populate(processEnv, parsedAll, options);
+		debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug);
+		quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
+		if (debug || !quiet) {
+			const keysCount = Object.keys(populated).length;
+			const shortPaths = [];
+			for (const filePath of optionPaths) try {
+				const relative = path.relative(process.cwd(), filePath);
+				shortPaths.push(relative);
+			} catch (e) {
+				if (debug) _debug(`failed to load ${filePath} ${e.message}`);
+				lastError = e;
+			}
+			_log(`injected env (${keysCount}) from ${shortPaths.join(",")} ${dim(`// tip: ${_getRandomTip()}`)}`);
+		}
+		if (lastError) return {
+			parsed: parsedAll,
+			error: lastError
+		};
+		else return { parsed: parsedAll };
+	}
+	function config(options) {
+		if (_dotenvKey(options).length === 0) return DotenvModule.configDotenv(options);
+		const vaultPath = _vaultPath(options);
+		if (!vaultPath) {
+			_warn(`you set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}`);
+			return DotenvModule.configDotenv(options);
+		}
+		return DotenvModule._configVault(options);
+	}
+	function decrypt(encrypted, keyStr) {
+		const key = Buffer.from(keyStr.slice(-64), "hex");
+		let ciphertext = Buffer.from(encrypted, "base64");
+		const nonce = ciphertext.subarray(0, 12);
+		const authTag = ciphertext.subarray(-16);
+		ciphertext = ciphertext.subarray(12, -16);
+		try {
+			const aesgcm = crypto.createDecipheriv("aes-256-gcm", key, nonce);
+			aesgcm.setAuthTag(authTag);
+			return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
+		} catch (error) {
+			const isRange = error instanceof RangeError;
+			const invalidKeyLength = error.message === "Invalid key length";
+			const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
+			if (isRange || invalidKeyLength) {
+				const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
+				err.code = "INVALID_DOTENV_KEY";
+				throw err;
+			} else if (decryptionFailed) {
+				const err = /* @__PURE__ */ new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
+				err.code = "DECRYPTION_FAILED";
+				throw err;
+			} else throw error;
+		}
+	}
+	function populate(processEnv, parsed, options = {}) {
+		const debug = Boolean(options && options.debug);
+		const override = Boolean(options && options.override);
+		const populated = {};
+		if (typeof parsed !== "object") {
+			const err = /* @__PURE__ */ new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+			err.code = "OBJECT_REQUIRED";
+			throw err;
+		}
+		for (const key of Object.keys(parsed)) if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+			if (override === true) {
+				processEnv[key] = parsed[key];
+				populated[key] = parsed[key];
+			}
+			if (debug) if (override === true) _debug(`"${key}" is already defined and WAS overwritten`);
+			else _debug(`"${key}" is already defined and was NOT overwritten`);
+		} else {
+			processEnv[key] = parsed[key];
+			populated[key] = parsed[key];
+		}
+		return populated;
+	}
+	const DotenvModule = {
+		configDotenv,
+		_configVault,
+		_parseVault,
+		config,
+		decrypt,
+		parse,
+		populate
+	};
+	module.exports.configDotenv = DotenvModule.configDotenv;
+	module.exports._configVault = DotenvModule._configVault;
+	module.exports._parseVault = DotenvModule._parseVault;
+	module.exports.config = DotenvModule.config;
+	module.exports.decrypt = DotenvModule.decrypt;
+	module.exports.parse = DotenvModule.parse;
+	module.exports.populate = DotenvModule.populate;
+	module.exports = DotenvModule;
+}));
+//#endregion
+//#region node_modules/.pnpm/dotenv-expand@12.0.3/node_modules/dotenv-expand/lib/main.js
+var require_main = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function _resolveEscapeSequences(value) {
+		return value.replace(/\\\$/g, "$");
+	}
+	function expandValue(value, processEnv, runningParsed) {
+		const env = {
+			...runningParsed,
+			...processEnv
+		};
+		const regex = /(?<!\\)\${([^{}]+)}|(?<!\\)\$([A-Za-z_][A-Za-z0-9_]*)/g;
+		let result = value;
+		let match;
+		const seen = /* @__PURE__ */ new Set();
+		while ((match = regex.exec(result)) !== null) {
+			seen.add(result);
+			const [template, bracedExpression, unbracedExpression] = match;
+			const expression = bracedExpression || unbracedExpression;
+			const opMatch = expression.match(/(:\+|\+|:-|-)/);
+			const splitter = opMatch ? opMatch[0] : null;
+			const r = expression.split(splitter);
+			let defaultValue;
+			let value;
+			const key = r.shift();
+			if ([":+", "+"].includes(splitter)) {
+				defaultValue = env[key] ? r.join(splitter) : "";
+				value = null;
+			} else {
+				defaultValue = r.join(splitter);
+				value = env[key];
+			}
+			if (value) if (seen.has(value)) result = result.replace(template, defaultValue);
+			else result = result.replace(template, value);
+			else result = result.replace(template, defaultValue);
+			if (result === runningParsed[key]) break;
+			regex.lastIndex = 0;
+		}
+		return result;
+	}
+	function expand(options) {
+		const runningParsed = {};
+		let processEnv = process.env;
+		if (options && options.processEnv != null) processEnv = options.processEnv;
+		for (const key in options.parsed) {
+			let value = options.parsed[key];
+			if (processEnv[key] && processEnv[key] !== value) value = processEnv[key];
+			else value = expandValue(value, processEnv, runningParsed);
+			options.parsed[key] = _resolveEscapeSequences(value);
+			runningParsed[key] = _resolveEscapeSequences(value);
+		}
+		for (const processKey in options.parsed) processEnv[processKey] = options.parsed[processKey];
+		return options;
+	}
+	module.exports.expand = expand;
+}));
+//#endregion
+//#region node_modules/.pnpm/@nestjs+config@4.0.4_@nestjs+common@11.1.27_reflect-metadata@0.2.2_rxjs@7.8.2_supports-color@8.1.1__rxjs@7.8.2/node_modules/@nestjs/config/dist/config.constants.js
+var require_config_constants = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.AS_PROVIDER_METHOD_KEY = exports.VALIDATED_ENV_PROPNAME = exports.PARTIAL_CONFIGURATION_PROPNAME = exports.PARTIAL_CONFIGURATION_KEY = exports.VALIDATED_ENV_LOADER = exports.CONFIGURATION_LOADER = exports.CONFIGURATION_TOKEN = exports.CONFIGURATION_SERVICE_TOKEN = void 0;
+	/**
+	* Injection tokens
+	*/
+	exports.CONFIGURATION_SERVICE_TOKEN = Symbol("CONFIG_SERVICE");
+	exports.CONFIGURATION_TOKEN = "CONFIGURATION_TOKEN";
+	exports.CONFIGURATION_LOADER = "CONFIGURATION_LOADER";
+	exports.VALIDATED_ENV_LOADER = "VALIDATED_ENV_LOADER";
+	exports.PARTIAL_CONFIGURATION_KEY = "PARTIAL_CONFIGURATION_KEY";
+	exports.PARTIAL_CONFIGURATION_PROPNAME = "KEY";
+	exports.VALIDATED_ENV_PROPNAME = "_PROCESS_ENV_VALIDATED";
+	exports.AS_PROVIDER_METHOD_KEY = "asProvider";
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/isArray.js
+var require_isArray = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = Array.isArray;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_freeGlobal.js
+var require__freeGlobal = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = typeof global == "object" && global && global.Object === Object && global;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_root.js
+var require__root = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var freeGlobal = require__freeGlobal();
+	/** Detect free variable `self`. */
+	var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+	module.exports = freeGlobal || freeSelf || Function("return this")();
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_Symbol.js
+var require__Symbol = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require__root().Symbol;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_getRawTag.js
+var require__getRawTag = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Symbol = require__Symbol();
+	/** Used for built-in method references. */
+	var objectProto = Object.prototype;
+	/** Used to check objects for own properties. */
+	var hasOwnProperty = objectProto.hasOwnProperty;
+	/**
+	* Used to resolve the
+	* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+	* of values.
+	*/
+	var nativeObjectToString = objectProto.toString;
+	/** Built-in value references. */
+	var symToStringTag = Symbol ? Symbol.toStringTag : void 0;
+	/**
+	* A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
+	*
+	* @private
+	* @param {*} value The value to query.
+	* @returns {string} Returns the raw `toStringTag`.
+	*/
+	function getRawTag(value) {
+		var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+		try {
+			value[symToStringTag] = void 0;
+			var unmasked = true;
+		} catch (e) {}
+		var result = nativeObjectToString.call(value);
+		if (unmasked) if (isOwn) value[symToStringTag] = tag;
+		else delete value[symToStringTag];
+		return result;
+	}
+	module.exports = getRawTag;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_objectToString.js
+var require__objectToString = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Used to resolve the
+	* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+	* of values.
+	*/
+	var nativeObjectToString = Object.prototype.toString;
+	/**
+	* Converts `value` to a string using `Object.prototype.toString`.
+	*
+	* @private
+	* @param {*} value The value to convert.
+	* @returns {string} Returns the converted string.
+	*/
+	function objectToString(value) {
+		return nativeObjectToString.call(value);
+	}
+	module.exports = objectToString;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_baseGetTag.js
+var require__baseGetTag = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Symbol = require__Symbol();
+	var getRawTag = require__getRawTag();
+	var objectToString = require__objectToString();
+	/** `Object#toString` result references. */
+	var nullTag = "[object Null]";
+	var undefinedTag = "[object Undefined]";
+	/** Built-in value references. */
+	var symToStringTag = Symbol ? Symbol.toStringTag : void 0;
+	/**
+	* The base implementation of `getTag` without fallbacks for buggy environments.
+	*
+	* @private
+	* @param {*} value The value to query.
+	* @returns {string} Returns the `toStringTag`.
+	*/
+	function baseGetTag(value) {
+		if (value == null) return value === void 0 ? undefinedTag : nullTag;
+		return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+	}
+	module.exports = baseGetTag;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/isObjectLike.js
+var require_isObjectLike = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Checks if `value` is object-like. A value is object-like if it's not `null`
+	* and has a `typeof` result of "object".
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+	* @example
+	*
+	* _.isObjectLike({});
+	* // => true
+	*
+	* _.isObjectLike([1, 2, 3]);
+	* // => true
+	*
+	* _.isObjectLike(_.noop);
+	* // => false
+	*
+	* _.isObjectLike(null);
+	* // => false
+	*/
+	function isObjectLike(value) {
+		return value != null && typeof value == "object";
+	}
+	module.exports = isObjectLike;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/isSymbol.js
+var require_isSymbol = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseGetTag = require__baseGetTag();
+	var isObjectLike = require_isObjectLike();
+	/** `Object#toString` result references. */
+	var symbolTag = "[object Symbol]";
+	/**
+	* Checks if `value` is classified as a `Symbol` primitive or object.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+	* @example
+	*
+	* _.isSymbol(Symbol.iterator);
+	* // => true
+	*
+	* _.isSymbol('abc');
+	* // => false
+	*/
+	function isSymbol(value) {
+		return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag;
+	}
+	module.exports = isSymbol;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_isKey.js
+var require__isKey = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var isArray = require_isArray();
+	var isSymbol = require_isSymbol();
+	/** Used to match property names within property paths. */
+	var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
+	var reIsPlainProp = /^\w*$/;
+	/**
+	* Checks if `value` is a property name and not a property path.
+	*
+	* @private
+	* @param {*} value The value to check.
+	* @param {Object} [object] The object to query keys on.
+	* @returns {boolean} Returns `true` if `value` is a property name, else `false`.
+	*/
+	function isKey(value, object) {
+		if (isArray(value)) return false;
+		var type = typeof value;
+		if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol(value)) return true;
+		return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
+	}
+	module.exports = isKey;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/isObject.js
+var require_isObject = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Checks if `value` is the
+	* [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+	* of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+	*
+	* @static
+	* @memberOf _
+	* @since 0.1.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is an object, else `false`.
+	* @example
+	*
+	* _.isObject({});
+	* // => true
+	*
+	* _.isObject([1, 2, 3]);
+	* // => true
+	*
+	* _.isObject(_.noop);
+	* // => true
+	*
+	* _.isObject(null);
+	* // => false
+	*/
+	function isObject(value) {
+		var type = typeof value;
+		return value != null && (type == "object" || type == "function");
+	}
+	module.exports = isObject;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/isFunction.js
+var require_isFunction = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseGetTag = require__baseGetTag();
+	var isObject = require_isObject();
+	/** `Object#toString` result references. */
+	var asyncTag = "[object AsyncFunction]";
+	var funcTag = "[object Function]";
+	var genTag = "[object GeneratorFunction]";
+	var proxyTag = "[object Proxy]";
+	/**
+	* Checks if `value` is classified as a `Function` object.
+	*
+	* @static
+	* @memberOf _
+	* @since 0.1.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is a function, else `false`.
+	* @example
+	*
+	* _.isFunction(_);
+	* // => true
+	*
+	* _.isFunction(/abc/);
+	* // => false
+	*/
+	function isFunction(value) {
+		if (!isObject(value)) return false;
+		var tag = baseGetTag(value);
+		return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+	}
+	module.exports = isFunction;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_coreJsData.js
+var require__coreJsData = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require__root()["__core-js_shared__"];
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_isMasked.js
+var require__isMasked = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var coreJsData = require__coreJsData();
+	/** Used to detect methods masquerading as native. */
+	var maskSrcKey = function() {
+		var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
+		return uid ? "Symbol(src)_1." + uid : "";
+	}();
+	/**
+	* Checks if `func` has its source masked.
+	*
+	* @private
+	* @param {Function} func The function to check.
+	* @returns {boolean} Returns `true` if `func` is masked, else `false`.
+	*/
+	function isMasked(func) {
+		return !!maskSrcKey && maskSrcKey in func;
+	}
+	module.exports = isMasked;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_toSource.js
+var require__toSource = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** Used to resolve the decompiled source of functions. */
+	var funcToString = Function.prototype.toString;
+	/**
+	* Converts `func` to its source code.
+	*
+	* @private
+	* @param {Function} func The function to convert.
+	* @returns {string} Returns the source code.
+	*/
+	function toSource(func) {
+		if (func != null) {
+			try {
+				return funcToString.call(func);
+			} catch (e) {}
+			try {
+				return func + "";
+			} catch (e) {}
+		}
+		return "";
+	}
+	module.exports = toSource;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_baseIsNative.js
+var require__baseIsNative = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var isFunction = require_isFunction();
+	var isMasked = require__isMasked();
+	var isObject = require_isObject();
+	var toSource = require__toSource();
+	/**
+	* Used to match `RegExp`
+	* [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
+	*/
+	var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+	/** Used to detect host constructors (Safari). */
+	var reIsHostCtor = /^\[object .+?Constructor\]$/;
+	/** Used for built-in method references. */
+	var funcProto = Function.prototype;
+	var objectProto = Object.prototype;
+	/** Used to resolve the decompiled source of functions. */
+	var funcToString = funcProto.toString;
+	/** Used to check objects for own properties. */
+	var hasOwnProperty = objectProto.hasOwnProperty;
+	/** Used to detect if a method is native. */
+	var reIsNative = RegExp("^" + funcToString.call(hasOwnProperty).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
+	/**
+	* The base implementation of `_.isNative` without bad shim checks.
+	*
+	* @private
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is a native function,
+	*  else `false`.
+	*/
+	function baseIsNative(value) {
+		if (!isObject(value) || isMasked(value)) return false;
+		return (isFunction(value) ? reIsNative : reIsHostCtor).test(toSource(value));
+	}
+	module.exports = baseIsNative;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_getValue.js
+var require__getValue = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Gets the value at `key` of `object`.
+	*
+	* @private
+	* @param {Object} [object] The object to query.
+	* @param {string} key The key of the property to get.
+	* @returns {*} Returns the property value.
+	*/
+	function getValue(object, key) {
+		return object == null ? void 0 : object[key];
+	}
+	module.exports = getValue;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_getNative.js
+var require__getNative = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseIsNative = require__baseIsNative();
+	var getValue = require__getValue();
+	/**
+	* Gets the native function at `key` of `object`.
+	*
+	* @private
+	* @param {Object} object The object to query.
+	* @param {string} key The key of the method to get.
+	* @returns {*} Returns the function if it's native, else `undefined`.
+	*/
+	function getNative(object, key) {
+		var value = getValue(object, key);
+		return baseIsNative(value) ? value : void 0;
+	}
+	module.exports = getNative;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_nativeCreate.js
+var require__nativeCreate = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require__getNative()(Object, "create");
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_hashClear.js
+var require__hashClear = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var nativeCreate = require__nativeCreate();
+	/**
+	* Removes all key-value entries from the hash.
+	*
+	* @private
+	* @name clear
+	* @memberOf Hash
+	*/
+	function hashClear() {
+		this.__data__ = nativeCreate ? nativeCreate(null) : {};
+		this.size = 0;
+	}
+	module.exports = hashClear;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_hashDelete.js
+var require__hashDelete = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Removes `key` and its value from the hash.
+	*
+	* @private
+	* @name delete
+	* @memberOf Hash
+	* @param {Object} hash The hash to modify.
+	* @param {string} key The key of the value to remove.
+	* @returns {boolean} Returns `true` if the entry was removed, else `false`.
+	*/
+	function hashDelete(key) {
+		var result = this.has(key) && delete this.__data__[key];
+		this.size -= result ? 1 : 0;
+		return result;
+	}
+	module.exports = hashDelete;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_hashGet.js
+var require__hashGet = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var nativeCreate = require__nativeCreate();
+	/** Used to stand-in for `undefined` hash values. */
+	var HASH_UNDEFINED = "__lodash_hash_undefined__";
+	/** Used to check objects for own properties. */
+	var hasOwnProperty = Object.prototype.hasOwnProperty;
+	/**
+	* Gets the hash value for `key`.
+	*
+	* @private
+	* @name get
+	* @memberOf Hash
+	* @param {string} key The key of the value to get.
+	* @returns {*} Returns the entry value.
+	*/
+	function hashGet(key) {
+		var data = this.__data__;
+		if (nativeCreate) {
+			var result = data[key];
+			return result === HASH_UNDEFINED ? void 0 : result;
+		}
+		return hasOwnProperty.call(data, key) ? data[key] : void 0;
+	}
+	module.exports = hashGet;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_hashHas.js
+var require__hashHas = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var nativeCreate = require__nativeCreate();
+	/** Used to check objects for own properties. */
+	var hasOwnProperty = Object.prototype.hasOwnProperty;
+	/**
+	* Checks if a hash value for `key` exists.
+	*
+	* @private
+	* @name has
+	* @memberOf Hash
+	* @param {string} key The key of the entry to check.
+	* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+	*/
+	function hashHas(key) {
+		var data = this.__data__;
+		return nativeCreate ? data[key] !== void 0 : hasOwnProperty.call(data, key);
+	}
+	module.exports = hashHas;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_hashSet.js
+var require__hashSet = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var nativeCreate = require__nativeCreate();
+	/** Used to stand-in for `undefined` hash values. */
+	var HASH_UNDEFINED = "__lodash_hash_undefined__";
+	/**
+	* Sets the hash `key` to `value`.
+	*
+	* @private
+	* @name set
+	* @memberOf Hash
+	* @param {string} key The key of the value to set.
+	* @param {*} value The value to set.
+	* @returns {Object} Returns the hash instance.
+	*/
+	function hashSet(key, value) {
+		var data = this.__data__;
+		this.size += this.has(key) ? 0 : 1;
+		data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED : value;
+		return this;
+	}
+	module.exports = hashSet;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_Hash.js
+var require__Hash = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var hashClear = require__hashClear();
+	var hashDelete = require__hashDelete();
+	var hashGet = require__hashGet();
+	var hashHas = require__hashHas();
+	var hashSet = require__hashSet();
+	/**
+	* Creates a hash object.
+	*
+	* @private
+	* @constructor
+	* @param {Array} [entries] The key-value pairs to cache.
+	*/
+	function Hash(entries) {
+		var index = -1, length = entries == null ? 0 : entries.length;
+		this.clear();
+		while (++index < length) {
+			var entry = entries[index];
+			this.set(entry[0], entry[1]);
+		}
+	}
+	Hash.prototype.clear = hashClear;
+	Hash.prototype["delete"] = hashDelete;
+	Hash.prototype.get = hashGet;
+	Hash.prototype.has = hashHas;
+	Hash.prototype.set = hashSet;
+	module.exports = Hash;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_listCacheClear.js
+var require__listCacheClear = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Removes all key-value entries from the list cache.
+	*
+	* @private
+	* @name clear
+	* @memberOf ListCache
+	*/
+	function listCacheClear() {
+		this.__data__ = [];
+		this.size = 0;
+	}
+	module.exports = listCacheClear;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/eq.js
+var require_eq = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Performs a
+	* [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+	* comparison between two values to determine if they are equivalent.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to compare.
+	* @param {*} other The other value to compare.
+	* @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+	* @example
+	*
+	* var object = { 'a': 1 };
+	* var other = { 'a': 1 };
+	*
+	* _.eq(object, object);
+	* // => true
+	*
+	* _.eq(object, other);
+	* // => false
+	*
+	* _.eq('a', 'a');
+	* // => true
+	*
+	* _.eq('a', Object('a'));
+	* // => false
+	*
+	* _.eq(NaN, NaN);
+	* // => true
+	*/
+	function eq(value, other) {
+		return value === other || value !== value && other !== other;
+	}
+	module.exports = eq;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_assocIndexOf.js
+var require__assocIndexOf = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var eq = require_eq();
+	/**
+	* Gets the index at which the `key` is found in `array` of key-value pairs.
+	*
+	* @private
+	* @param {Array} array The array to inspect.
+	* @param {*} key The key to search for.
+	* @returns {number} Returns the index of the matched value, else `-1`.
+	*/
+	function assocIndexOf(array, key) {
+		var length = array.length;
+		while (length--) if (eq(array[length][0], key)) return length;
+		return -1;
+	}
+	module.exports = assocIndexOf;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_listCacheDelete.js
+var require__listCacheDelete = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var assocIndexOf = require__assocIndexOf();
+	/** Built-in value references. */
+	var splice = Array.prototype.splice;
+	/**
+	* Removes `key` and its value from the list cache.
+	*
+	* @private
+	* @name delete
+	* @memberOf ListCache
+	* @param {string} key The key of the value to remove.
+	* @returns {boolean} Returns `true` if the entry was removed, else `false`.
+	*/
+	function listCacheDelete(key) {
+		var data = this.__data__, index = assocIndexOf(data, key);
+		if (index < 0) return false;
+		if (index == data.length - 1) data.pop();
+		else splice.call(data, index, 1);
+		--this.size;
+		return true;
+	}
+	module.exports = listCacheDelete;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_listCacheGet.js
+var require__listCacheGet = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var assocIndexOf = require__assocIndexOf();
+	/**
+	* Gets the list cache value for `key`.
+	*
+	* @private
+	* @name get
+	* @memberOf ListCache
+	* @param {string} key The key of the value to get.
+	* @returns {*} Returns the entry value.
+	*/
+	function listCacheGet(key) {
+		var data = this.__data__, index = assocIndexOf(data, key);
+		return index < 0 ? void 0 : data[index][1];
+	}
+	module.exports = listCacheGet;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_listCacheHas.js
+var require__listCacheHas = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var assocIndexOf = require__assocIndexOf();
+	/**
+	* Checks if a list cache value for `key` exists.
+	*
+	* @private
+	* @name has
+	* @memberOf ListCache
+	* @param {string} key The key of the entry to check.
+	* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+	*/
+	function listCacheHas(key) {
+		return assocIndexOf(this.__data__, key) > -1;
+	}
+	module.exports = listCacheHas;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_listCacheSet.js
+var require__listCacheSet = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var assocIndexOf = require__assocIndexOf();
+	/**
+	* Sets the list cache `key` to `value`.
+	*
+	* @private
+	* @name set
+	* @memberOf ListCache
+	* @param {string} key The key of the value to set.
+	* @param {*} value The value to set.
+	* @returns {Object} Returns the list cache instance.
+	*/
+	function listCacheSet(key, value) {
+		var data = this.__data__, index = assocIndexOf(data, key);
+		if (index < 0) {
+			++this.size;
+			data.push([key, value]);
+		} else data[index][1] = value;
+		return this;
+	}
+	module.exports = listCacheSet;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_ListCache.js
+var require__ListCache = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var listCacheClear = require__listCacheClear();
+	var listCacheDelete = require__listCacheDelete();
+	var listCacheGet = require__listCacheGet();
+	var listCacheHas = require__listCacheHas();
+	var listCacheSet = require__listCacheSet();
+	/**
+	* Creates an list cache object.
+	*
+	* @private
+	* @constructor
+	* @param {Array} [entries] The key-value pairs to cache.
+	*/
+	function ListCache(entries) {
+		var index = -1, length = entries == null ? 0 : entries.length;
+		this.clear();
+		while (++index < length) {
+			var entry = entries[index];
+			this.set(entry[0], entry[1]);
+		}
+	}
+	ListCache.prototype.clear = listCacheClear;
+	ListCache.prototype["delete"] = listCacheDelete;
+	ListCache.prototype.get = listCacheGet;
+	ListCache.prototype.has = listCacheHas;
+	ListCache.prototype.set = listCacheSet;
+	module.exports = ListCache;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_Map.js
+var require__Map = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require__getNative()(require__root(), "Map");
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_mapCacheClear.js
+var require__mapCacheClear = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Hash = require__Hash();
+	var ListCache = require__ListCache();
+	var Map = require__Map();
+	/**
+	* Removes all key-value entries from the map.
+	*
+	* @private
+	* @name clear
+	* @memberOf MapCache
+	*/
+	function mapCacheClear() {
+		this.size = 0;
+		this.__data__ = {
+			"hash": new Hash(),
+			"map": new (Map || ListCache)(),
+			"string": new Hash()
+		};
+	}
+	module.exports = mapCacheClear;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_isKeyable.js
+var require__isKeyable = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Checks if `value` is suitable for use as unique object key.
+	*
+	* @private
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is suitable, else `false`.
+	*/
+	function isKeyable(value) {
+		var type = typeof value;
+		return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+	}
+	module.exports = isKeyable;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_getMapData.js
+var require__getMapData = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var isKeyable = require__isKeyable();
+	/**
+	* Gets the data for `map`.
+	*
+	* @private
+	* @param {Object} map The map to query.
+	* @param {string} key The reference key.
+	* @returns {*} Returns the map data.
+	*/
+	function getMapData(map, key) {
+		var data = map.__data__;
+		return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+	}
+	module.exports = getMapData;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_mapCacheDelete.js
+var require__mapCacheDelete = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var getMapData = require__getMapData();
+	/**
+	* Removes `key` and its value from the map.
+	*
+	* @private
+	* @name delete
+	* @memberOf MapCache
+	* @param {string} key The key of the value to remove.
+	* @returns {boolean} Returns `true` if the entry was removed, else `false`.
+	*/
+	function mapCacheDelete(key) {
+		var result = getMapData(this, key)["delete"](key);
+		this.size -= result ? 1 : 0;
+		return result;
+	}
+	module.exports = mapCacheDelete;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_mapCacheGet.js
+var require__mapCacheGet = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var getMapData = require__getMapData();
+	/**
+	* Gets the map value for `key`.
+	*
+	* @private
+	* @name get
+	* @memberOf MapCache
+	* @param {string} key The key of the value to get.
+	* @returns {*} Returns the entry value.
+	*/
+	function mapCacheGet(key) {
+		return getMapData(this, key).get(key);
+	}
+	module.exports = mapCacheGet;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_mapCacheHas.js
+var require__mapCacheHas = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var getMapData = require__getMapData();
+	/**
+	* Checks if a map value for `key` exists.
+	*
+	* @private
+	* @name has
+	* @memberOf MapCache
+	* @param {string} key The key of the entry to check.
+	* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+	*/
+	function mapCacheHas(key) {
+		return getMapData(this, key).has(key);
+	}
+	module.exports = mapCacheHas;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_mapCacheSet.js
+var require__mapCacheSet = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var getMapData = require__getMapData();
+	/**
+	* Sets the map `key` to `value`.
+	*
+	* @private
+	* @name set
+	* @memberOf MapCache
+	* @param {string} key The key of the value to set.
+	* @param {*} value The value to set.
+	* @returns {Object} Returns the map cache instance.
+	*/
+	function mapCacheSet(key, value) {
+		var data = getMapData(this, key), size = data.size;
+		data.set(key, value);
+		this.size += data.size == size ? 0 : 1;
+		return this;
+	}
+	module.exports = mapCacheSet;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_MapCache.js
+var require__MapCache = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var mapCacheClear = require__mapCacheClear();
+	var mapCacheDelete = require__mapCacheDelete();
+	var mapCacheGet = require__mapCacheGet();
+	var mapCacheHas = require__mapCacheHas();
+	var mapCacheSet = require__mapCacheSet();
+	/**
+	* Creates a map cache object to store key-value pairs.
+	*
+	* @private
+	* @constructor
+	* @param {Array} [entries] The key-value pairs to cache.
+	*/
+	function MapCache(entries) {
+		var index = -1, length = entries == null ? 0 : entries.length;
+		this.clear();
+		while (++index < length) {
+			var entry = entries[index];
+			this.set(entry[0], entry[1]);
+		}
+	}
+	MapCache.prototype.clear = mapCacheClear;
+	MapCache.prototype["delete"] = mapCacheDelete;
+	MapCache.prototype.get = mapCacheGet;
+	MapCache.prototype.has = mapCacheHas;
+	MapCache.prototype.set = mapCacheSet;
+	module.exports = MapCache;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/memoize.js
+var require_memoize = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var MapCache = require__MapCache();
+	/** Error message constants. */
+	var FUNC_ERROR_TEXT = "Expected a function";
+	/**
+	* Creates a function that memoizes the result of `func`. If `resolver` is
+	* provided, it determines the cache key for storing the result based on the
+	* arguments provided to the memoized function. By default, the first argument
+	* provided to the memoized function is used as the map cache key. The `func`
+	* is invoked with the `this` binding of the memoized function.
+	*
+	* **Note:** The cache is exposed as the `cache` property on the memoized
+	* function. Its creation may be customized by replacing the `_.memoize.Cache`
+	* constructor with one whose instances implement the
+	* [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
+	* method interface of `clear`, `delete`, `get`, `has`, and `set`.
+	*
+	* @static
+	* @memberOf _
+	* @since 0.1.0
+	* @category Function
+	* @param {Function} func The function to have its output memoized.
+	* @param {Function} [resolver] The function to resolve the cache key.
+	* @returns {Function} Returns the new memoized function.
+	* @example
+	*
+	* var object = { 'a': 1, 'b': 2 };
+	* var other = { 'c': 3, 'd': 4 };
+	*
+	* var values = _.memoize(_.values);
+	* values(object);
+	* // => [1, 2]
+	*
+	* values(other);
+	* // => [3, 4]
+	*
+	* object.a = 2;
+	* values(object);
+	* // => [1, 2]
+	*
+	* // Modify the result cache.
+	* values.cache.set(object, ['a', 'b']);
+	* values(object);
+	* // => ['a', 'b']
+	*
+	* // Replace `_.memoize.Cache`.
+	* _.memoize.Cache = WeakMap;
+	*/
+	function memoize(func, resolver) {
+		if (typeof func != "function" || resolver != null && typeof resolver != "function") throw new TypeError(FUNC_ERROR_TEXT);
+		var memoized = function() {
+			var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
+			if (cache.has(key)) return cache.get(key);
+			var result = func.apply(this, args);
+			memoized.cache = cache.set(key, result) || cache;
+			return result;
+		};
+		memoized.cache = new (memoize.Cache || MapCache)();
+		return memoized;
+	}
+	memoize.Cache = MapCache;
+	module.exports = memoize;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_memoizeCapped.js
+var require__memoizeCapped = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var memoize = require_memoize();
+	/** Used as the maximum memoize cache size. */
+	var MAX_MEMOIZE_SIZE = 500;
+	/**
+	* A specialized version of `_.memoize` which clears the memoized function's
+	* cache when it exceeds `MAX_MEMOIZE_SIZE`.
+	*
+	* @private
+	* @param {Function} func The function to have its output memoized.
+	* @returns {Function} Returns the new memoized function.
+	*/
+	function memoizeCapped(func) {
+		var result = memoize(func, function(key) {
+			if (cache.size === MAX_MEMOIZE_SIZE) cache.clear();
+			return key;
+		});
+		var cache = result.cache;
+		return result;
+	}
+	module.exports = memoizeCapped;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_stringToPath.js
+var require__stringToPath = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var memoizeCapped = require__memoizeCapped();
+	/** Used to match property names within property paths. */
+	var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+	/** Used to match backslashes in property paths. */
+	var reEscapeChar = /\\(\\)?/g;
+	module.exports = memoizeCapped(function(string) {
+		var result = [];
+		if (string.charCodeAt(0) === 46) result.push("");
+		string.replace(rePropName, function(match, number, quote, subString) {
+			result.push(quote ? subString.replace(reEscapeChar, "$1") : number || match);
+		});
+		return result;
+	});
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_arrayMap.js
+var require__arrayMap = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* A specialized version of `_.map` for arrays without support for iteratee
+	* shorthands.
+	*
+	* @private
+	* @param {Array} [array] The array to iterate over.
+	* @param {Function} iteratee The function invoked per iteration.
+	* @returns {Array} Returns the new mapped array.
+	*/
+	function arrayMap(array, iteratee) {
+		var index = -1, length = array == null ? 0 : array.length, result = Array(length);
+		while (++index < length) result[index] = iteratee(array[index], index, array);
+		return result;
+	}
+	module.exports = arrayMap;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_baseToString.js
+var require__baseToString = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Symbol = require__Symbol();
+	var arrayMap = require__arrayMap();
+	var isArray = require_isArray();
+	var isSymbol = require_isSymbol();
+	/** Used as references for various `Number` constants. */
+	var INFINITY = Infinity;
+	/** Used to convert symbols to primitives and strings. */
+	var symbolProto = Symbol ? Symbol.prototype : void 0;
+	var symbolToString = symbolProto ? symbolProto.toString : void 0;
+	/**
+	* The base implementation of `_.toString` which doesn't convert nullish
+	* values to empty strings.
+	*
+	* @private
+	* @param {*} value The value to process.
+	* @returns {string} Returns the string.
+	*/
+	function baseToString(value) {
+		if (typeof value == "string") return value;
+		if (isArray(value)) return arrayMap(value, baseToString) + "";
+		if (isSymbol(value)) return symbolToString ? symbolToString.call(value) : "";
+		var result = value + "";
+		return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+	}
+	module.exports = baseToString;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/toString.js
+var require_toString = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseToString = require__baseToString();
+	/**
+	* Converts `value` to a string. An empty string is returned for `null`
+	* and `undefined` values. The sign of `-0` is preserved.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to convert.
+	* @returns {string} Returns the converted string.
+	* @example
+	*
+	* _.toString(null);
+	* // => ''
+	*
+	* _.toString(-0);
+	* // => '-0'
+	*
+	* _.toString([1, 2, 3]);
+	* // => '1,2,3'
+	*/
+	function toString(value) {
+		return value == null ? "" : baseToString(value);
+	}
+	module.exports = toString;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_castPath.js
+var require__castPath = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var isArray = require_isArray();
+	var isKey = require__isKey();
+	var stringToPath = require__stringToPath();
+	var toString = require_toString();
+	/**
+	* Casts `value` to a path array if it's not one.
+	*
+	* @private
+	* @param {*} value The value to inspect.
+	* @param {Object} [object] The object to query keys on.
+	* @returns {Array} Returns the cast property path array.
+	*/
+	function castPath(value, object) {
+		if (isArray(value)) return value;
+		return isKey(value, object) ? [value] : stringToPath(toString(value));
+	}
+	module.exports = castPath;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_toKey.js
+var require__toKey = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var isSymbol = require_isSymbol();
+	/** Used as references for various `Number` constants. */
+	var INFINITY = Infinity;
+	/**
+	* Converts `value` to a string key if it's not a string or symbol.
+	*
+	* @private
+	* @param {*} value The value to inspect.
+	* @returns {string|symbol} Returns the key.
+	*/
+	function toKey(value) {
+		if (typeof value == "string" || isSymbol(value)) return value;
+		var result = value + "";
+		return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+	}
+	module.exports = toKey;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_baseGet.js
+var require__baseGet = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var castPath = require__castPath();
+	var toKey = require__toKey();
+	/**
+	* The base implementation of `_.get` without support for default values.
+	*
+	* @private
+	* @param {Object} object The object to query.
+	* @param {Array|string} path The path of the property to get.
+	* @returns {*} Returns the resolved value.
+	*/
+	function baseGet(object, path) {
+		path = castPath(path, object);
+		var index = 0, length = path.length;
+		while (object != null && index < length) object = object[toKey(path[index++])];
+		return index && index == length ? object : void 0;
+	}
+	module.exports = baseGet;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/get.js
+var require_get = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseGet = require__baseGet();
+	/**
+	* Gets the value at `path` of `object`. If the resolved value is
+	* `undefined`, the `defaultValue` is returned in its place.
+	*
+	* @static
+	* @memberOf _
+	* @since 3.7.0
+	* @category Object
+	* @param {Object} object The object to query.
+	* @param {Array|string} path The path of the property to get.
+	* @param {*} [defaultValue] The value returned for `undefined` resolved values.
+	* @returns {*} Returns the resolved value.
+	* @example
+	*
+	* var object = { 'a': [{ 'b': { 'c': 3 } }] };
+	*
+	* _.get(object, 'a[0].b.c');
+	* // => 3
+	*
+	* _.get(object, ['a', '0', 'b', 'c']);
+	* // => 3
+	*
+	* _.get(object, 'a.b.c', 'default');
+	* // => 'default'
+	*/
+	function get(object, path, defaultValue) {
+		var result = object == null ? void 0 : baseGet(object, path);
+		return result === void 0 ? defaultValue : result;
+	}
+	module.exports = get;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_baseHas.js
+var require__baseHas = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** Used to check objects for own properties. */
+	var hasOwnProperty = Object.prototype.hasOwnProperty;
+	/**
+	* The base implementation of `_.has` without support for deep paths.
+	*
+	* @private
+	* @param {Object} [object] The object to query.
+	* @param {Array|string} key The key to check.
+	* @returns {boolean} Returns `true` if `key` exists, else `false`.
+	*/
+	function baseHas(object, key) {
+		return object != null && hasOwnProperty.call(object, key);
+	}
+	module.exports = baseHas;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_baseIsArguments.js
+var require__baseIsArguments = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseGetTag = require__baseGetTag();
+	var isObjectLike = require_isObjectLike();
+	/** `Object#toString` result references. */
+	var argsTag = "[object Arguments]";
+	/**
+	* The base implementation of `_.isArguments`.
+	*
+	* @private
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is an `arguments` object,
+	*/
+	function baseIsArguments(value) {
+		return isObjectLike(value) && baseGetTag(value) == argsTag;
+	}
+	module.exports = baseIsArguments;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/isArguments.js
+var require_isArguments = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseIsArguments = require__baseIsArguments();
+	var isObjectLike = require_isObjectLike();
+	/** Used for built-in method references. */
+	var objectProto = Object.prototype;
+	/** Used to check objects for own properties. */
+	var hasOwnProperty = objectProto.hasOwnProperty;
+	/** Built-in value references. */
+	var propertyIsEnumerable = objectProto.propertyIsEnumerable;
+	module.exports = baseIsArguments(function() {
+		return arguments;
+	}()) ? baseIsArguments : function(value) {
+		return isObjectLike(value) && hasOwnProperty.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
+	};
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_isIndex.js
+var require__isIndex = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** Used as references for various `Number` constants. */
+	var MAX_SAFE_INTEGER = 9007199254740991;
+	/** Used to detect unsigned integer values. */
+	var reIsUint = /^(?:0|[1-9]\d*)$/;
+	/**
+	* Checks if `value` is a valid array-like index.
+	*
+	* @private
+	* @param {*} value The value to check.
+	* @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
+	* @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
+	*/
+	function isIndex(value, length) {
+		var type = typeof value;
+		length = length == null ? MAX_SAFE_INTEGER : length;
+		return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && value > -1 && value % 1 == 0 && value < length;
+	}
+	module.exports = isIndex;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/isLength.js
+var require_isLength = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** Used as references for various `Number` constants. */
+	var MAX_SAFE_INTEGER = 9007199254740991;
+	/**
+	* Checks if `value` is a valid array-like length.
+	*
+	* **Note:** This method is loosely based on
+	* [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
+	* @example
+	*
+	* _.isLength(3);
+	* // => true
+	*
+	* _.isLength(Number.MIN_VALUE);
+	* // => false
+	*
+	* _.isLength(Infinity);
+	* // => false
+	*
+	* _.isLength('3');
+	* // => false
+	*/
+	function isLength(value) {
+		return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+	}
+	module.exports = isLength;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_hasPath.js
+var require__hasPath = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var castPath = require__castPath();
+	var isArguments = require_isArguments();
+	var isArray = require_isArray();
+	var isIndex = require__isIndex();
+	var isLength = require_isLength();
+	var toKey = require__toKey();
+	/**
+	* Checks if `path` exists on `object`.
+	*
+	* @private
+	* @param {Object} object The object to query.
+	* @param {Array|string} path The path to check.
+	* @param {Function} hasFunc The function to check properties.
+	* @returns {boolean} Returns `true` if `path` exists, else `false`.
+	*/
+	function hasPath(object, path, hasFunc) {
+		path = castPath(path, object);
+		var index = -1, length = path.length, result = false;
+		while (++index < length) {
+			var key = toKey(path[index]);
+			if (!(result = object != null && hasFunc(object, key))) break;
+			object = object[key];
+		}
+		if (result || ++index != length) return result;
+		length = object == null ? 0 : object.length;
+		return !!length && isLength(length) && isIndex(key, length) && (isArray(object) || isArguments(object));
+	}
+	module.exports = hasPath;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/has.js
+var require_has = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseHas = require__baseHas();
+	var hasPath = require__hasPath();
+	/**
+	* Checks if `path` is a direct property of `object`.
+	*
+	* @static
+	* @since 0.1.0
+	* @memberOf _
+	* @category Object
+	* @param {Object} object The object to query.
+	* @param {Array|string} path The path to check.
+	* @returns {boolean} Returns `true` if `path` exists, else `false`.
+	* @example
+	*
+	* var object = { 'a': { 'b': 2 } };
+	* var other = _.create({ 'a': _.create({ 'b': 2 }) });
+	*
+	* _.has(object, 'a');
+	* // => true
+	*
+	* _.has(object, 'a.b');
+	* // => true
+	*
+	* _.has(object, ['a', 'b']);
+	* // => true
+	*
+	* _.has(other, 'a');
+	* // => false
+	*/
+	function has(object, path) {
+		return object != null && hasPath(object, path, baseHas);
+	}
+	module.exports = has;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_defineProperty.js
+var require__defineProperty = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var getNative = require__getNative();
+	module.exports = function() {
+		try {
+			var func = getNative(Object, "defineProperty");
+			func({}, "", {});
+			return func;
+		} catch (e) {}
+	}();
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_baseAssignValue.js
+var require__baseAssignValue = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var defineProperty = require__defineProperty();
+	/**
+	* The base implementation of `assignValue` and `assignMergeValue` without
+	* value checks.
+	*
+	* @private
+	* @param {Object} object The object to modify.
+	* @param {string} key The key of the property to assign.
+	* @param {*} value The value to assign.
+	*/
+	function baseAssignValue(object, key, value) {
+		if (key == "__proto__" && defineProperty) defineProperty(object, key, {
+			"configurable": true,
+			"enumerable": true,
+			"value": value,
+			"writable": true
+		});
+		else object[key] = value;
+	}
+	module.exports = baseAssignValue;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_assignValue.js
+var require__assignValue = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseAssignValue = require__baseAssignValue();
+	var eq = require_eq();
+	/** Used to check objects for own properties. */
+	var hasOwnProperty = Object.prototype.hasOwnProperty;
+	/**
+	* Assigns `value` to `key` of `object` if the existing value is not equivalent
+	* using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+	* for equality comparisons.
+	*
+	* @private
+	* @param {Object} object The object to modify.
+	* @param {string} key The key of the property to assign.
+	* @param {*} value The value to assign.
+	*/
+	function assignValue(object, key, value) {
+		var objValue = object[key];
+		if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) || value === void 0 && !(key in object)) baseAssignValue(object, key, value);
+	}
+	module.exports = assignValue;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_baseSet.js
+var require__baseSet = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var assignValue = require__assignValue();
+	var castPath = require__castPath();
+	var isIndex = require__isIndex();
+	var isObject = require_isObject();
+	var toKey = require__toKey();
+	/**
+	* The base implementation of `_.set`.
+	*
+	* @private
+	* @param {Object} object The object to modify.
+	* @param {Array|string} path The path of the property to set.
+	* @param {*} value The value to set.
+	* @param {Function} [customizer] The function to customize path creation.
+	* @returns {Object} Returns `object`.
+	*/
+	function baseSet(object, path, value, customizer) {
+		if (!isObject(object)) return object;
+		path = castPath(path, object);
+		var index = -1, length = path.length, lastIndex = length - 1, nested = object;
+		while (nested != null && ++index < length) {
+			var key = toKey(path[index]), newValue = value;
+			if (key === "__proto__" || key === "constructor" || key === "prototype") return object;
+			if (index != lastIndex) {
+				var objValue = nested[key];
+				newValue = customizer ? customizer(objValue, key, nested) : void 0;
+				if (newValue === void 0) newValue = isObject(objValue) ? objValue : isIndex(path[index + 1]) ? [] : {};
+			}
+			assignValue(nested, key, newValue);
+			nested = nested[key];
+		}
+		return object;
+	}
+	module.exports = baseSet;
+}));
+//#endregion
+//#region node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/set.js
+var require_set = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseSet = require__baseSet();
+	/**
+	* Sets the value at `path` of `object`. If a portion of `path` doesn't exist,
+	* it's created. Arrays are created for missing index properties while objects
+	* are created for all other missing properties. Use `_.setWith` to customize
+	* `path` creation.
+	*
+	* **Note:** This method mutates `object`.
+	*
+	* @static
+	* @memberOf _
+	* @since 3.7.0
+	* @category Object
+	* @param {Object} object The object to modify.
+	* @param {Array|string} path The path of the property to set.
+	* @param {*} value The value to set.
+	* @returns {Object} Returns `object`.
+	* @example
+	*
+	* var object = { 'a': [{ 'b': { 'c': 3 } }] };
+	*
+	* _.set(object, 'a[0].b.c', 4);
+	* console.log(object.a[0].b.c);
+	* // => 4
+	*
+	* _.set(object, ['x', '0', 'y', 'z'], 5);
+	* console.log(object.x[0].y.z);
+	* // => 5
+	*/
+	function set(object, path, value) {
+		return object == null ? object : baseSet(object, path, value);
+	}
+	module.exports = set;
+}));
+//#endregion
+//#region node_modules/.pnpm/@nestjs+config@4.0.4_@nestjs+common@11.1.27_reflect-metadata@0.2.2_rxjs@7.8.2_supports-color@8.1.1__rxjs@7.8.2/node_modules/@nestjs/config/dist/config.service.js
+var require_config_service = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		var desc = Object.getOwnPropertyDescriptor(m, k);
+		if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
+			enumerable: true,
+			get: function() {
+				return m[k];
+			}
+		};
+		Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		o[k2] = m[k];
+	}));
+	var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+		Object.defineProperty(o, "default", {
+			enumerable: true,
+			value: v
+		});
+	}) : function(o, v) {
+		o["default"] = v;
+	});
+	var __decorate = exports && exports.__decorate || function(decorators, target, key, desc) {
+		var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+		if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+		else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+		return c > 3 && r && Object.defineProperty(target, key, r), r;
+	};
+	var __importStar = exports && exports.__importStar || (function() {
+		var ownKeys = function(o) {
+			ownKeys = Object.getOwnPropertyNames || function(o) {
+				var ar = [];
+				for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+				return ar;
+			};
+			return ownKeys(o);
+		};
+		return function(mod) {
+			if (mod && mod.__esModule) return mod;
+			var result = {};
+			if (mod != null) {
+				for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+			}
+			__setModuleDefault(result, mod);
+			return result;
+		};
+	})();
+	var __metadata = exports && exports.__metadata || function(k, v) {
+		if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+	};
+	var __param = exports && exports.__param || function(paramIndex, decorator) {
+		return function(target, key) {
+			decorator(target, key, paramIndex);
+		};
+	};
+	var __importDefault = exports && exports.__importDefault || function(mod) {
+		return mod && mod.__esModule ? mod : { "default": mod };
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.ConfigService = void 0;
+	const common_1$3 = require("@nestjs/common");
+	const shared_utils_1$1 = require("@nestjs/common/utils/shared.utils");
+	const dotenv = __importStar(require_main$1());
+	const fs_1 = __importDefault(require("fs"));
+	const get_1 = __importDefault(require_get());
+	const has_1 = __importDefault(require_has());
+	const set_1 = __importDefault(require_set());
+	const rxjs_1 = require("rxjs");
+	const config_constants_1 = require_config_constants();
+	/**
+	* @publicApi
+	*/
+	let ConfigService = class ConfigService {
+		set isCacheEnabled(value) {
+			this._isCacheEnabled = value;
+		}
+		get isCacheEnabled() {
+			return this._isCacheEnabled;
+		}
+		set skipProcessEnv(value) {
+			this._skipProcessEnv = value;
+		}
+		get skipProcessEnv() {
+			return this._skipProcessEnv;
+		}
+		constructor(internalConfig = {}) {
+			this.internalConfig = internalConfig;
+			this.cache = {};
+			this._changes$ = new rxjs_1.Subject();
+			this._skipProcessEnv = false;
+			this._isCacheEnabled = false;
+			this.envFilePaths = [];
+		}
+		/**
+		* Returns a stream of configuration changes.
+		* Each event contains the attribute path, the old value and the new value.
+		*/
+		get changes$() {
+			return this._changes$.asObservable();
+		}
+		/**
+		* Get a configuration value (either custom configuration or process environment variable)
+		* based on property path (you can use dot notation to traverse nested object, e.g. "database.host").
+		* It returns a default value if the key does not exist.
+		* @param propertyPath
+		* @param defaultValueOrOptions
+		*/
+		get(propertyPath, defaultValueOrOptions, options) {
+			const internalValue = this.getFromInternalConfig(propertyPath);
+			if (!(0, shared_utils_1$1.isUndefined)(internalValue)) return internalValue;
+			const validatedEnvValue = this.getFromValidatedEnv(propertyPath);
+			if (!(0, shared_utils_1$1.isUndefined)(validatedEnvValue)) return validatedEnvValue;
+			const defaultValue = this.isGetOptionsObject(defaultValueOrOptions) && !options ? void 0 : defaultValueOrOptions;
+			if (!this._skipProcessEnv) {
+				const processEnvValue = this.getFromProcessEnv(propertyPath, defaultValue);
+				if (!(0, shared_utils_1$1.isUndefined)(processEnvValue)) return processEnvValue;
+			}
+			return defaultValue;
+		}
+		/**
+		* Get a configuration value (either custom configuration or process environment variable)
+		* based on property path (you can use dot notation to traverse nested object, e.g. "database.host").
+		* It returns a default value if the key does not exist.
+		* If the default value is undefined an exception will be thrown.
+		* @param propertyPath
+		* @param defaultValueOrOptions
+		*/
+		getOrThrow(propertyPath, defaultValueOrOptions, options) {
+			const value = this.get(propertyPath, defaultValueOrOptions, options);
+			if ((0, shared_utils_1$1.isUndefined)(value)) throw new TypeError(`Configuration key "${propertyPath.toString()}" does not exist`);
+			return value;
+		}
+		/**
+		* Sets a configuration value based on property path.
+		* @param propertyPath
+		* @param value
+		*/
+		set(propertyPath, value) {
+			const oldValue = this.get(propertyPath);
+			(0, set_1.default)(this.internalConfig, propertyPath, value);
+			if (typeof propertyPath === "string") {
+				process.env[propertyPath] = String(value);
+				this.updateInterpolatedEnv(propertyPath, String(value));
+			}
+			if (this.isCacheEnabled) this.setInCacheIfDefined(propertyPath, value);
+			this._changes$.next({
+				path: propertyPath,
+				oldValue,
+				newValue: value
+			});
+		}
+		/**
+		* Sets env file paths from `config.module.ts` to parse.
+		* @param paths
+		*/
+		setEnvFilePaths(paths) {
+			this.envFilePaths = paths;
+		}
+		getFromCache(propertyPath, defaultValue) {
+			const cachedValue = (0, get_1.default)(this.cache, propertyPath);
+			return (0, shared_utils_1$1.isUndefined)(cachedValue) ? defaultValue : cachedValue;
+		}
+		getFromValidatedEnv(propertyPath) {
+			return (0, get_1.default)(this.internalConfig[config_constants_1.VALIDATED_ENV_PROPNAME], propertyPath);
+		}
+		getFromProcessEnv(propertyPath, defaultValue) {
+			if (this.isCacheEnabled && (0, has_1.default)(this.cache, propertyPath)) {
+				const cachedValue = this.getFromCache(propertyPath, defaultValue);
+				return !(0, shared_utils_1$1.isUndefined)(cachedValue) ? cachedValue : defaultValue;
+			}
+			const processValue = (0, get_1.default)(process.env, propertyPath);
+			this.setInCacheIfDefined(propertyPath, processValue);
+			return processValue;
+		}
+		getFromInternalConfig(propertyPath) {
+			return (0, get_1.default)(this.internalConfig, propertyPath);
+		}
+		setInCacheIfDefined(propertyPath, value) {
+			if (typeof value === "undefined") return;
+			(0, set_1.default)(this.cache, propertyPath, value);
+		}
+		isGetOptionsObject(options) {
+			return options && options?.infer && Object.keys(options).length === 1;
+		}
+		updateInterpolatedEnv(propertyPath, value) {
+			let config = {};
+			for (const envFilePath of this.envFilePaths) if (fs_1.default.existsSync(envFilePath)) config = Object.assign(dotenv.parse(fs_1.default.readFileSync(envFilePath)), config);
+			const regex = new RegExp(`\\$\\{?${propertyPath}\\}?`, "g");
+			for (const [k, v] of Object.entries(config)) if (regex.test(v)) process.env[k] = v.replace(regex, value);
+		}
+	};
+	exports.ConfigService = ConfigService;
+	exports.ConfigService = ConfigService = __decorate([
+		(0, common_1$3.Injectable)(),
+		__param(0, (0, common_1$3.Optional)()),
+		__param(0, (0, common_1$3.Inject)(config_constants_1.CONFIGURATION_TOKEN)),
+		__metadata("design:paramtypes", [Object])
+	], ConfigService);
+}));
+//#endregion
+//#region node_modules/.pnpm/@nestjs+config@4.0.4_@nestjs+common@11.1.27_reflect-metadata@0.2.2_rxjs@7.8.2_supports-color@8.1.1__rxjs@7.8.2/node_modules/@nestjs/config/dist/config-host.module.js
+var require_config_host_module = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var __decorate = exports && exports.__decorate || function(decorators, target, key, desc) {
+		var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+		if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+		else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+		return c > 3 && r && Object.defineProperty(target, key, r), r;
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.ConfigHostModule = void 0;
+	const common_1$2 = require("@nestjs/common");
+	const config_constants_1 = require_config_constants();
+	const config_service_1 = require_config_service();
+	/**
+	* @publicApi
+	*/
+	let ConfigHostModule = class ConfigHostModule {};
+	exports.ConfigHostModule = ConfigHostModule;
+	exports.ConfigHostModule = ConfigHostModule = __decorate([(0, common_1$2.Global)(), (0, common_1$2.Module)({
+		providers: [{
+			provide: config_constants_1.CONFIGURATION_TOKEN,
+			useFactory: () => ({})
+		}, {
+			provide: config_constants_1.CONFIGURATION_SERVICE_TOKEN,
+			useClass: config_service_1.ConfigService
+		}],
+		exports: [config_constants_1.CONFIGURATION_TOKEN, config_constants_1.CONFIGURATION_SERVICE_TOKEN]
+	})], ConfigHostModule);
+}));
+//#endregion
+//#region node_modules/.pnpm/@nestjs+config@4.0.4_@nestjs+common@11.1.27_reflect-metadata@0.2.2_rxjs@7.8.2_supports-color@8.1.1__rxjs@7.8.2/node_modules/@nestjs/config/dist/utils/get-config-token.util.js
+var require_get_config_token_util = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.getConfigToken = getConfigToken;
+	/**
+	* @publicApi
+	*/
+	function getConfigToken(token) {
+		return `CONFIGURATION(${token.toString()})`;
+	}
+}));
+//#endregion
+//#region node_modules/.pnpm/@nestjs+config@4.0.4_@nestjs+common@11.1.27_reflect-metadata@0.2.2_rxjs@7.8.2_supports-color@8.1.1__rxjs@7.8.2/node_modules/@nestjs/config/dist/utils/create-config-factory.util.js
+var require_create_config_factory_util = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.createConfigProvider = createConfigProvider;
+	const get_config_token_util_1 = require_get_config_token_util();
+	const crypto_1 = require("crypto");
+	/**
+	* @publicApi
+	*/
+	function createConfigProvider(factory) {
+		return {
+			provide: factory.KEY || (0, get_config_token_util_1.getConfigToken)((0, crypto_1.randomUUID)()),
+			useFactory: factory,
+			inject: []
+		};
+	}
+}));
+//#endregion
+//#region node_modules/.pnpm/@nestjs+config@4.0.4_@nestjs+common@11.1.27_reflect-metadata@0.2.2_rxjs@7.8.2_supports-color@8.1.1__rxjs@7.8.2/node_modules/@nestjs/config/dist/utils/get-registration-token.util.js
+var require_get_registration_token_util = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.getRegistrationToken = getRegistrationToken;
+	const config_constants_1 = require_config_constants();
+	/**
+	* @publicApi
+	*/
+	function getRegistrationToken(config) {
+		return config[config_constants_1.PARTIAL_CONFIGURATION_KEY];
+	}
+}));
+//#endregion
+//#region node_modules/.pnpm/@nestjs+config@4.0.4_@nestjs+common@11.1.27_reflect-metadata@0.2.2_rxjs@7.8.2_supports-color@8.1.1__rxjs@7.8.2/node_modules/@nestjs/config/dist/utils/merge-configs.util.js
+var require_merge_configs_util = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var __importDefault = exports && exports.__importDefault || function(mod) {
+		return mod && mod.__esModule ? mod : { "default": mod };
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.mergeConfigObject = mergeConfigObject;
+	const set_1 = __importDefault(require_set());
+	/**
+	* @publicApi
+	*/
+	function mergeConfigObject(host, partial, token) {
+		if (token) {
+			(0, set_1.default)(host, token, partial);
+			return partial;
+		}
+		Object.assign(host, partial);
+	}
+}));
+//#endregion
+//#region node_modules/.pnpm/@nestjs+config@4.0.4_@nestjs+common@11.1.27_reflect-metadata@0.2.2_rxjs@7.8.2_supports-color@8.1.1__rxjs@7.8.2/node_modules/@nestjs/config/dist/config.module.js
+var require_config_module = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		var desc = Object.getOwnPropertyDescriptor(m, k);
+		if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
+			enumerable: true,
+			get: function() {
+				return m[k];
+			}
+		};
+		Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		o[k2] = m[k];
+	}));
+	var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+		Object.defineProperty(o, "default", {
+			enumerable: true,
+			value: v
+		});
+	}) : function(o, v) {
+		o["default"] = v;
+	});
+	var __decorate = exports && exports.__decorate || function(decorators, target, key, desc) {
+		var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+		if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+		else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+		return c > 3 && r && Object.defineProperty(target, key, r), r;
+	};
+	var __importStar = exports && exports.__importStar || (function() {
+		var ownKeys = function(o) {
+			ownKeys = Object.getOwnPropertyNames || function(o) {
+				var ar = [];
+				for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+				return ar;
+			};
+			return ownKeys(o);
+		};
+		return function(mod) {
+			if (mod && mod.__esModule) return mod;
+			var result = {};
+			if (mod != null) {
+				for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+			}
+			__setModuleDefault(result, mod);
+			return result;
+		};
+	})();
+	var ConfigModule_1;
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.ConfigModule = void 0;
+	const common_1$1 = require("@nestjs/common");
+	const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+	const dotenv = __importStar(require_main$1());
+	const dotenv_expand_1 = require_main();
+	const fs = __importStar(require("fs"));
+	const path_1 = require("path");
+	const config_host_module_1 = require_config_host_module();
+	const config_constants_1 = require_config_constants();
+	const config_service_1 = require_config_service();
+	const create_config_factory_util_1 = require_create_config_factory_util();
+	const get_registration_token_util_1 = require_get_registration_token_util();
+	const merge_configs_util_1 = require_merge_configs_util();
+	/**
+	* @publicApi
+	*/
+	let ConfigModule = ConfigModule_1 = class ConfigModule {
+		/**
+		* This promise resolves when "dotenv" completes loading environment variables.
+		* When "ignoreEnvFile" is set to true, then it will resolve immediately after the
+		* "ConfigModule#forRoot" method is called.
+		*/
+		static get envVariablesLoaded() {
+			return this._envVariablesLoaded;
+		}
+		/**
+		* Loads environment variables based on the "ignoreEnvFile" flag and "envFilePath" value.
+		* Additionally, registers custom configurations globally.
+		* @param options
+		*/
+		static async forRoot(options = {}) {
+			const envFilePaths = Array.isArray(options.envFilePath) ? options.envFilePath : [options.envFilePath || (0, path_1.resolve)(process.cwd(), ".env")];
+			let validatedEnvConfig = void 0;
+			let config = options.ignoreEnvFile ? {} : this.loadEnvFile(envFilePaths, options);
+			if (!options.ignoreEnvVars && options.validatePredefined !== false) config = {
+				...config,
+				...process.env
+			};
+			if (options.validate) {
+				const validatedConfig = options.validate(config);
+				validatedEnvConfig = validatedConfig;
+				this.assignVariablesToProcess(validatedConfig);
+			} else if (options.validationSchema) {
+				const validationOptions = this.getSchemaValidationOptions(options);
+				const { error, value: validatedConfig } = options.validationSchema.validate(config, validationOptions);
+				if (error) throw new Error(`Config validation error: ${error.message}`);
+				validatedEnvConfig = validatedConfig;
+				this.assignVariablesToProcess(validatedConfig);
+			} else this.assignVariablesToProcess(config);
+			const isConfigToLoad = options.load && options.load.length;
+			const providers = (await Promise.all(options.load || [])).map((factory) => (0, create_config_factory_util_1.createConfigProvider)(factory)).filter((item) => item);
+			const configProviderTokens = providers.map((item) => item.provide);
+			const configServiceProvider = {
+				provide: config_service_1.ConfigService,
+				useFactory: (configService) => {
+					const untypedConfigService = configService;
+					if (options.cache) untypedConfigService.isCacheEnabled = true;
+					if (options.skipProcessEnv) untypedConfigService.skipProcessEnv = true;
+					configService.setEnvFilePaths(envFilePaths);
+					return configService;
+				},
+				inject: [config_constants_1.CONFIGURATION_SERVICE_TOKEN, ...configProviderTokens]
+			};
+			providers.push(configServiceProvider);
+			if (validatedEnvConfig) {
+				const validatedEnvConfigLoader = {
+					provide: config_constants_1.VALIDATED_ENV_LOADER,
+					useFactory: (host) => {
+						host[config_constants_1.VALIDATED_ENV_PROPNAME] = validatedEnvConfig;
+					},
+					inject: [config_constants_1.CONFIGURATION_TOKEN]
+				};
+				providers.push(validatedEnvConfigLoader);
+			}
+			this.environmentVariablesLoadedSignal();
+			return {
+				module: ConfigModule_1,
+				global: options.isGlobal,
+				providers: isConfigToLoad ? [...providers, {
+					provide: config_constants_1.CONFIGURATION_LOADER,
+					useFactory: (host, ...configurations) => {
+						configurations.forEach((item, index) => this.mergePartial(host, item, providers[index]));
+					},
+					inject: [config_constants_1.CONFIGURATION_TOKEN, ...configProviderTokens]
+				}] : providers,
+				exports: [config_service_1.ConfigService, ...configProviderTokens]
+			};
+		}
+		/**
+		* Registers configuration object (partial registration).
+		* @param config
+		*/
+		static forFeature(config) {
+			const configProvider = (0, create_config_factory_util_1.createConfigProvider)(config);
+			const serviceProvider = {
+				provide: config_service_1.ConfigService,
+				useFactory: (configService) => configService,
+				inject: [config_constants_1.CONFIGURATION_SERVICE_TOKEN, configProvider.provide]
+			};
+			return {
+				module: ConfigModule_1,
+				providers: [
+					configProvider,
+					serviceProvider,
+					{
+						provide: config_constants_1.CONFIGURATION_LOADER,
+						useFactory: (host, partialConfig) => {
+							this.mergePartial(host, partialConfig, configProvider);
+						},
+						inject: [config_constants_1.CONFIGURATION_TOKEN, configProvider.provide]
+					}
+				],
+				exports: [config_service_1.ConfigService, configProvider.provide]
+			};
+		}
+		static loadEnvFile(envFilePaths, options) {
+			let config = {};
+			for (const envFilePath of envFilePaths) if (fs.existsSync(envFilePath)) {
+				config = Object.assign(dotenv.parse(fs.readFileSync(envFilePath)), config);
+				if (options.expandVariables) {
+					const expandOptions = typeof options.expandVariables === "object" ? options.expandVariables : {};
+					config = (0, dotenv_expand_1.expand)({
+						...expandOptions,
+						parsed: config
+					}).parsed || config;
+				}
+			}
+			return config;
+		}
+		static assignVariablesToProcess(config) {
+			if (!(0, shared_utils_1.isObject)(config)) return;
+			Object.keys(config).filter((key) => !(key in process.env)).forEach((key) => {
+				const value = config[key];
+				if (typeof value === "string") process.env[key] = value;
+				else if (typeof value === "boolean" || typeof value === "number") process.env[key] = `${value}`;
+			});
+		}
+		static mergePartial(host, item, provider) {
+			const factoryRef = provider.useFactory;
+			const token = (0, get_registration_token_util_1.getRegistrationToken)(factoryRef);
+			(0, merge_configs_util_1.mergeConfigObject)(host, item, token);
+		}
+		static getSchemaValidationOptions(options) {
+			if (options.validationOptions) {
+				if (typeof options.validationOptions.allowUnknown === "undefined") options.validationOptions.allowUnknown = true;
+				return options.validationOptions;
+			}
+			return {
+				abortEarly: false,
+				allowUnknown: true
+			};
+		}
+	};
+	exports.ConfigModule = ConfigModule;
+	ConfigModule._envVariablesLoaded = new Promise((resolve) => ConfigModule_1.environmentVariablesLoadedSignal = resolve);
+	exports.ConfigModule = ConfigModule = ConfigModule_1 = __decorate([(0, common_1$1.Module)({
+		imports: [config_host_module_1.ConfigHostModule],
+		providers: [{
+			provide: config_service_1.ConfigService,
+			useExisting: config_constants_1.CONFIGURATION_SERVICE_TOKEN
+		}],
+		exports: [config_host_module_1.ConfigHostModule, config_service_1.ConfigService]
+	})], ConfigModule);
+}));
+//#endregion
+//#region node_modules/.pnpm/@nestjs+config@4.0.4_@nestjs+common@11.1.27_reflect-metadata@0.2.2_rxjs@7.8.2_supports-color@8.1.1__rxjs@7.8.2/node_modules/@nestjs/config/dist/conditional.module.js
+var require_conditional_module = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.ConditionalModule = void 0;
+	const common_1 = require("@nestjs/common");
+	const config_module_1 = require_config_module();
+	/**
+	* Same logic as in `@nestjs/core` package.
+	* @param instance The instance which should get the name from
+	* @returns The name of an instance or `undefined`
+	*/
+	const getInstanceName = (instance) => {
+		if (instance?.forwardRef) return instance.forwardRef()?.name;
+		if (instance.module) return instance.module?.name;
+		return instance.name;
+	};
+	exports.ConditionalModule = class ConditionalModule {
+		/**
+		* @publicApi
+		*/
+		static async registerWhen(module$1, condition, options) {
+			const { timeout = 5e3, debug = true } = options ?? {};
+			const moduleName = getInstanceName(module$1) || module$1.toString();
+			const timer = setTimeout(() => {
+				throw new Error(`Nest was not able to resolve the config variables within ${timeout} milliseconds. Bause of this, the ConditionalModule was not able to determine if ${moduleName} should be registered or not`);
+			}, timeout);
+			timer.unref();
+			const returnModule = {
+				module: ConditionalModule,
+				imports: [],
+				exports: []
+			};
+			if (typeof condition === "string") {
+				const key = condition;
+				condition = (env) => {
+					return env[key]?.toLowerCase() !== "false";
+				};
+			}
+			await config_module_1.ConfigModule.envVariablesLoaded;
+			clearTimeout(timer);
+			if (condition(process.env)) {
+				returnModule.imports.push(module$1);
+				returnModule.exports.push(module$1);
+			} else if (debug) common_1.Logger.debug(`${condition.toString()} evaluated to false. Skipping the registration of ${moduleName}`, ConditionalModule.name);
+			return returnModule;
+		}
+	};
+}));
+//#endregion
+//#region node_modules/.pnpm/@nestjs+config@4.0.4_@nestjs+common@11.1.27_reflect-metadata@0.2.2_rxjs@7.8.2_supports-color@8.1.1__rxjs@7.8.2/node_modules/@nestjs/config/dist/types/config-object.type.js
+var require_config_object_type = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+}));
+//#endregion
+//#region node_modules/.pnpm/@nestjs+config@4.0.4_@nestjs+common@11.1.27_reflect-metadata@0.2.2_rxjs@7.8.2_supports-color@8.1.1__rxjs@7.8.2/node_modules/@nestjs/config/dist/types/config.type.js
+var require_config_type = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+}));
+//#endregion
+//#region node_modules/.pnpm/@nestjs+config@4.0.4_@nestjs+common@11.1.27_reflect-metadata@0.2.2_rxjs@7.8.2_supports-color@8.1.1__rxjs@7.8.2/node_modules/@nestjs/config/dist/types/no-infer.type.js
+var require_no_infer_type = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+}));
+//#endregion
+//#region node_modules/.pnpm/@nestjs+config@4.0.4_@nestjs+common@11.1.27_reflect-metadata@0.2.2_rxjs@7.8.2_supports-color@8.1.1__rxjs@7.8.2/node_modules/@nestjs/config/dist/types/path-value.type.js
+var require_path_value_type = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+}));
+//#endregion
+//#region node_modules/.pnpm/@nestjs+config@4.0.4_@nestjs+common@11.1.27_reflect-metadata@0.2.2_rxjs@7.8.2_supports-color@8.1.1__rxjs@7.8.2/node_modules/@nestjs/config/dist/types/index.js
+var require_types = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		var desc = Object.getOwnPropertyDescriptor(m, k);
+		if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
+			enumerable: true,
+			get: function() {
+				return m[k];
+			}
+		};
+		Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		o[k2] = m[k];
+	}));
+	var __exportStar = exports && exports.__exportStar || function(m, exports$4) {
+		for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports$4, p)) __createBinding(exports$4, m, p);
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	__exportStar(require_config_object_type(), exports);
+	__exportStar(require_config_type(), exports);
+	__exportStar(require_no_infer_type(), exports);
+	__exportStar(require_path_value_type(), exports);
+}));
+//#endregion
+//#region node_modules/.pnpm/@nestjs+config@4.0.4_@nestjs+common@11.1.27_reflect-metadata@0.2.2_rxjs@7.8.2_supports-color@8.1.1__rxjs@7.8.2/node_modules/@nestjs/config/dist/utils/register-as.util.js
+var require_register_as_util = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.registerAs = registerAs;
+	const __1 = require_dist();
+	const config_constants_1 = require_config_constants();
+	const get_config_token_util_1 = require_get_config_token_util();
+	/**
+	* @publicApi
+	*
+	* Registers the configuration object behind a specified token.
+	*/
+	function registerAs(token, configFactory) {
+		const defineProperty = (key, value) => {
+			Object.defineProperty(configFactory, key, {
+				configurable: false,
+				enumerable: false,
+				value,
+				writable: false
+			});
+		};
+		defineProperty(config_constants_1.PARTIAL_CONFIGURATION_KEY, token);
+		defineProperty(config_constants_1.PARTIAL_CONFIGURATION_PROPNAME, (0, get_config_token_util_1.getConfigToken)(token));
+		defineProperty(config_constants_1.AS_PROVIDER_METHOD_KEY, () => ({
+			imports: [__1.ConfigModule.forFeature(configFactory)],
+			useFactory: (config) => config,
+			inject: [(0, get_config_token_util_1.getConfigToken)(token)]
+		}));
+		return configFactory;
+	}
+}));
+//#endregion
+//#region node_modules/.pnpm/@nestjs+config@4.0.4_@nestjs+common@11.1.27_reflect-metadata@0.2.2_rxjs@7.8.2_supports-color@8.1.1__rxjs@7.8.2/node_modules/@nestjs/config/dist/utils/index.js
+var require_utils = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		var desc = Object.getOwnPropertyDescriptor(m, k);
+		if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
+			enumerable: true,
+			get: function() {
+				return m[k];
+			}
+		};
+		Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		o[k2] = m[k];
+	}));
+	var __exportStar = exports && exports.__exportStar || function(m, exports$3) {
+		for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports$3, p)) __createBinding(exports$3, m, p);
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	__exportStar(require_register_as_util(), exports);
+	__exportStar(require_get_config_token_util(), exports);
+}));
+//#endregion
+//#region node_modules/.pnpm/@nestjs+config@4.0.4_@nestjs+common@11.1.27_reflect-metadata@0.2.2_rxjs@7.8.2_supports-color@8.1.1__rxjs@7.8.2/node_modules/@nestjs/config/dist/interfaces/config-change-event.interface.js
+var require_config_change_event_interface = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+}));
+//#endregion
+//#region node_modules/.pnpm/@nestjs+config@4.0.4_@nestjs+common@11.1.27_reflect-metadata@0.2.2_rxjs@7.8.2_supports-color@8.1.1__rxjs@7.8.2/node_modules/@nestjs/config/dist/interfaces/config-factory.interface.js
+var require_config_factory_interface = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+}));
+//#endregion
+//#region node_modules/.pnpm/@nestjs+config@4.0.4_@nestjs+common@11.1.27_reflect-metadata@0.2.2_rxjs@7.8.2_supports-color@8.1.1__rxjs@7.8.2/node_modules/@nestjs/config/dist/interfaces/config-module-options.interface.js
+var require_config_module_options_interface = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+}));
+//#endregion
+//#region node_modules/.pnpm/@nestjs+config@4.0.4_@nestjs+common@11.1.27_reflect-metadata@0.2.2_rxjs@7.8.2_supports-color@8.1.1__rxjs@7.8.2/node_modules/@nestjs/config/dist/interfaces/index.js
+var require_interfaces = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		var desc = Object.getOwnPropertyDescriptor(m, k);
+		if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
+			enumerable: true,
+			get: function() {
+				return m[k];
+			}
+		};
+		Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		o[k2] = m[k];
+	}));
+	var __exportStar = exports && exports.__exportStar || function(m, exports$2) {
+		for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports$2, p)) __createBinding(exports$2, m, p);
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	__exportStar(require_config_change_event_interface(), exports);
+	__exportStar(require_config_factory_interface(), exports);
+	__exportStar(require_config_module_options_interface(), exports);
+}));
+//#endregion
+//#region node_modules/.pnpm/@nestjs+config@4.0.4_@nestjs+common@11.1.27_reflect-metadata@0.2.2_rxjs@7.8.2_supports-color@8.1.1__rxjs@7.8.2/node_modules/@nestjs/config/dist/index.js
+var require_dist = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		var desc = Object.getOwnPropertyDescriptor(m, k);
+		if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
+			enumerable: true,
+			get: function() {
+				return m[k];
+			}
+		};
+		Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		o[k2] = m[k];
+	}));
+	var __exportStar = exports && exports.__exportStar || function(m, exports$1) {
+		for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports$1, p)) __createBinding(exports$1, m, p);
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	__exportStar(require_conditional_module(), exports);
+	__exportStar(require_config_module(), exports);
+	__exportStar(require_config_service(), exports);
+	__exportStar(require_types(), exports);
+	__exportStar(require_utils(), exports);
+	__exportStar(require_interfaces(), exports);
+}));
+//#endregion
+//#region src/puppeteer/puppeteer.module.ts
+var import_config = (/* @__PURE__ */ __commonJSMin(((exports) => {
+	function __export(m) {
+		for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+	}
+	exports.__esModule = true;
+	__export(require_dist());
+})))();
+var _PuppeteerModule;
+let PuppeteerModule = _PuppeteerModule = class PuppeteerModule {
+	browserService;
+	pdfParams;
+	constructor(browserService, pdfParams) {
+		this.browserService = browserService;
+		this.pdfParams = pdfParams;
+	}
+	async onModuleInit() {
+		if (!this.pdfParams.executablePath) await this.browserService.install(this.pdfParams.useLockedBrowser ?? false);
+	}
+	static forRoot(pdfParameters) {
+		const providers = [
+			{
+				provide: PDF_PARAMETERS,
+				useValue: pdfParameters
+			},
+			{
+				provide: HANDLEBARS_PARAMETERS,
+				useValue: pdfParameters.hbsOptions ?? {}
+			},
+			_gboutte_nestjs_hbs.HandlebarsService,
+			MjmlService,
+			PugService,
+			EjsService,
+			NunjucksService,
+			EtaService,
+			MustacheService
+		];
+		return {
+			module: _PuppeteerModule,
+			imports: [import_config.ConfigModule.forRoot()],
+			providers,
+			exports: [
+				PuppeteerService,
+				MjmlService,
+				PugService,
+				EjsService,
+				NunjucksService,
+				EtaService,
+				MustacheService
+			]
+		};
+	}
+	static forRootAsync(options) {
+		const pdfParamsProvider = {
+			provide: PDF_PARAMETERS,
+			inject: options.inject ?? [],
+			useFactory: async (...args) => options.useFactory(...args)
+		};
+		const hbsParamsProvider = {
+			provide: HANDLEBARS_PARAMETERS,
+			inject: [PDF_PARAMETERS],
+			useFactory: (params) => params.hbsOptions ?? {}
+		};
+		return {
+			module: _PuppeteerModule,
+			imports: [...options.imports ?? [], import_config.ConfigModule.forRoot()],
+			providers: [
+				pdfParamsProvider,
+				hbsParamsProvider,
+				PuppeteerService,
+				BrowserService,
+				_gboutte_nestjs_hbs.HandlebarsService,
+				MjmlService,
+				PugService,
+				EjsService,
+				NunjucksService,
+				EtaService,
+				MustacheService
+			],
+			exports: [
+				PuppeteerService,
+				MjmlService,
+				PugService,
+				EjsService,
+				NunjucksService,
+				EtaService,
+				MustacheService
+			]
+		};
+	}
+};
+PuppeteerModule = _PuppeteerModule = __decorate([
+	(0, _nestjs_common.Module)({
+		providers: [
+			PuppeteerService,
+			BrowserService,
+			MjmlService,
+			PugService,
+			EjsService,
+			NunjucksService,
+			EtaService,
+			MustacheService
+		],
+		exports: [
+			PuppeteerService,
+			MjmlService,
+			PugService,
+			EjsService,
+			NunjucksService,
+			EtaService,
+			MustacheService
+		]
+	}),
+	__decorateParam(1, (0, _nestjs_common.Inject)(PDF_PARAMETERS)),
+	__decorateMetadata("design:paramtypes", [typeof BrowserService === "undefined" ? Object : BrowserService, Object])
+], PuppeteerModule);
+//#endregion
+//#region src/nestjs-pdf.module.ts
+var _NestjsPdfModule;
+let NestjsPdfModule = _NestjsPdfModule = class NestjsPdfModule {
+	static forRoot(options) {
+		return {
+			module: _NestjsPdfModule,
+			imports: [PuppeteerModule.forRoot(options)],
+			providers: [NestjsPdfService],
+			exports: [NestjsPdfService]
+		};
+	}
+	static forRootAsync(options) {
+		return {
+			module: _NestjsPdfModule,
+			imports: [PuppeteerModule.forRootAsync(options)],
+			providers: [NestjsPdfService],
+			exports: [NestjsPdfService]
+		};
+	}
+};
+NestjsPdfModule = _NestjsPdfModule = __decorate([(0, _nestjs_common.Module)({})], NestjsPdfModule);
+//#endregion
+Object.defineProperty(exports, "EjsService", {
+	enumerable: true,
+	get: function() {
+		return EjsService;
+	}
+});
+Object.defineProperty(exports, "EtaService", {
+	enumerable: true,
+	get: function() {
+		return EtaService;
+	}
+});
+Object.defineProperty(exports, "MjmlService", {
+	enumerable: true,
+	get: function() {
+		return MjmlService;
+	}
+});
+Object.defineProperty(exports, "MustacheService", {
+	enumerable: true,
+	get: function() {
+		return MustacheService;
+	}
+});
+Object.defineProperty(exports, "NestjsPdfModule", {
+	enumerable: true,
+	get: function() {
+		return NestjsPdfModule;
+	}
+});
+Object.defineProperty(exports, "NestjsPdfService", {
+	enumerable: true,
+	get: function() {
+		return NestjsPdfService;
+	}
+});
+Object.defineProperty(exports, "NunjucksService", {
+	enumerable: true,
+	get: function() {
+		return NunjucksService;
+	}
+});
+Object.defineProperty(exports, "PugService", {
+	enumerable: true,
+	get: function() {
+		return PugService;
+	}
+});
+Object.defineProperty(exports, "PuppeteerModule", {
+	enumerable: true,
+	get: function() {
+		return PuppeteerModule;
+	}
+});
+Object.defineProperty(exports, "PuppeteerService", {
+	enumerable: true,
+	get: function() {
+		return PuppeteerService;
+	}
+});
+exports.getRelativePathToValue = getRelativePathToValue;