@powerhousedao/pieces-framework 6.2.3-dev.11

package/dist/host.js

@@ -0,0 +1,723 @@
+import { A as PropertyType, b as ApFile, c as isNil, d as parseToJsonIfPossible, l as isString, o as isBase64, r as tryCatchSync, v as DateRangeValue } from "./markdown-property-Df2l6_y_.js";
+import { g as AUTHENTICATION_PROPERTY_NAME, i as getAuthPropertyForValue, m as isObject } from "./authentication-B7brX_It.js";
+import ipaddr from "ipaddr.js";
+import { Readable } from "node:stream";
+import dayjs from "dayjs";
+import timezone from "dayjs/plugin/timezone.js";
+import utc from "dayjs/plugin/utc.js";
+
+//#region upstream/core-utils/lib/friendly-piece-error.ts
+const FRIENDLY_PIECE_ERROR_VERSION = 1;
+const STACK_LINE_REGEX = /\n\s*at\s+.+$/gm;
+const HTTP_ERROR_MESSAGE_MAX_LENGTH = 2e3;
+const RAW_ERROR_MAX_LENGTH = 16e3;
+const HTTP_STATUS_MIN = 100;
+const HTTP_STATUS_MAX = 599;
+const MAX_MESSAGE_DEPTH = 12;
+const MAX_SERIALIZED_DEPTH = 64;
+const CIRCULAR_PLACEHOLDER = "[Circular]";
+const TOO_DEEP_PLACEHOLDER = "[Too deep]";
+const UNSERIALIZABLE_PLACEHOLDER = "[Unserializable]";
+const isObjectRecord = (value) => {
+	return !isNil(value) && typeof value === "object" && !Array.isArray(value);
+};
+const safeJsonParse = (value) => {
+	try {
+		return JSON.parse(value);
+	} catch {
+		return value;
+	}
+};
+const stripStack = (value) => {
+	return value.replace(STACK_LINE_REGEX, "").trim();
+};
+const truncate = (value) => {
+	if (value.length <= HTTP_ERROR_MESSAGE_MAX_LENGTH) return value;
+	return `${value.slice(0, HTTP_ERROR_MESSAGE_MAX_LENGTH)}…`;
+};
+const truncateRaw = (value) => {
+	if (value.length <= RAW_ERROR_MAX_LENGTH) return value;
+	return `${value.slice(0, RAW_ERROR_MAX_LENGTH)}\n…[truncated]`;
+};
+const HTML_DOC_REGEX = /^\s*(<!doctype\s+html|<html\b|<\?xml)/i;
+const HTML_TAG_LIKE_REGEX = /<\s*(html|body|head|title|meta|p|div|span|h[1-6]|table|script|style)\b/i;
+const isLikelyMarkupBody = (value) => {
+	if (HTML_DOC_REGEX.test(value)) return true;
+	if (!value.includes("<") || !value.includes(">")) return false;
+	return HTML_TAG_LIKE_REGEX.test(value);
+};
+const decodeHtmlEntities = (value) => {
+	return value.replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, "\"").replace(/&#39;/g, "'").replace(/&apos;/g, "'");
+};
+const stripMarkup = (value) => {
+	const titleMatch = value.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+	const title = titleMatch ? decodeHtmlEntities(titleMatch[1]).replace(/\s+/g, " ").trim() : "";
+	const textOnly = decodeHtmlEntities(value.replace(/<script[\s\S]*?<\/script>/gi, " ").replace(/<style[\s\S]*?<\/style>/gi, " ").replace(/<head[\s\S]*?<\/head>/gi, " ").replace(/<[^>]+>/g, " ")).replace(/\s+/g, " ").trim();
+	if (textOnly.length > 0 && title.length > 0 && !textOnly.startsWith(title)) return `${title} — ${textOnly}`;
+	return textOnly.length > 0 ? textOnly : title;
+};
+const readString = (record, key) => {
+	const value = record[key];
+	return isString(value) ? value : void 0;
+};
+const collectMessageFrom = ({ value, depth, seen }) => {
+	if (isNil(value) || depth > MAX_MESSAGE_DEPTH) return;
+	if (isString(value)) {
+		const trimmed = value.trim();
+		if (trimmed.length === 0) return;
+		if (isLikelyMarkupBody(trimmed)) {
+			const stripped = stripMarkup(trimmed);
+			return stripped.length > 0 ? stripped : void 0;
+		}
+		return trimmed;
+	}
+	if (Array.isArray(value)) {
+		if (seen.has(value)) return;
+		seen.add(value);
+		const parts = value.map((entry) => collectMessageFrom({
+			value: entry,
+			depth: depth + 1,
+			seen
+		})).filter((entry) => isString(entry) && entry.length > 0);
+		return parts.length > 0 ? parts.join("; ") : void 0;
+	}
+	if (isObjectRecord(value)) {
+		if (seen.has(value)) return;
+		seen.add(value);
+		return collectMessageFrom({
+			value: value["message"] ?? value["detail"] ?? value["description"] ?? value["reason"] ?? value["error"],
+			depth: depth + 1,
+			seen
+		});
+	}
+};
+const collectMessage = (value) => {
+	return collectMessageFrom({
+		value,
+		depth: 0,
+		seen: /* @__PURE__ */ new WeakSet()
+	});
+};
+const extractApiMessage = (responseBody) => {
+	if (isNil(responseBody)) return;
+	if (isString(responseBody) || Array.isArray(responseBody)) {
+		const collected = collectMessage(responseBody);
+		return collected ? truncate(collected) : void 0;
+	}
+	if (!isObjectRecord(responseBody)) return truncate(String(responseBody));
+	const candidates = [
+		responseBody["message"],
+		responseBody["error_description"],
+		responseBody["errorDescription"],
+		responseBody["detail"],
+		responseBody["title"],
+		responseBody["error_message"],
+		responseBody["errorMessage"],
+		responseBody["errorMessages"],
+		responseBody["errors"],
+		responseBody["error"],
+		responseBody["faultstring"],
+		responseBody["fault"],
+		responseBody["reason"],
+		responseBody["description"]
+	];
+	for (const candidate of candidates) {
+		const collected = collectMessage(candidate);
+		if (collected) return truncate(collected);
+	}
+};
+const toHttpStatus = (value) => {
+	return typeof value === "number" && value >= HTTP_STATUS_MIN && value <= HTTP_STATUS_MAX ? value : void 0;
+};
+const extractResponseHttpDetails = (error) => {
+	const response = error["response"];
+	if (!isObjectRecord(response)) return null;
+	const statusValue = response["status"];
+	const status = typeof statusValue === "number" ? statusValue : void 0;
+	const responseBody = response["body"];
+	const headersValue = response["headers"];
+	const headers = isObjectRecord(headersValue) ? headersValue : void 0;
+	const requestRaw = error["request"];
+	const request = isObjectRecord(requestRaw) ? requestRaw : void 0;
+	const requestBody = request?.["body"];
+	const requestUrl = request === void 0 ? void 0 : readString(request, "url");
+	const requestMethod = request === void 0 ? void 0 : readString(request, "method");
+	if (isNil(status) && isNil(responseBody) && isNil(requestBody)) return null;
+	return {
+		status,
+		responseBody,
+		responseHeaders: headers,
+		requestBody,
+		requestUrl,
+		requestMethod,
+		apiMessage: extractApiMessage(responseBody)
+	};
+};
+const extractClientHttpDetails = (error) => {
+	const status = toHttpStatus(error["status"]);
+	if (isNil(status)) return null;
+	const responseBody = error["error"] ?? error["body"];
+	const headersValue = error["headers"];
+	return {
+		status,
+		responseBody,
+		responseHeaders: isObjectRecord(headersValue) ? headersValue : void 0,
+		apiMessage: extractApiMessage(responseBody)
+	};
+};
+const extractHttpDetails = (error) => {
+	return extractResponseHttpDetails(error) ?? extractClientHttpDetails(error);
+};
+const rebuildSerializable = ({ value, depth, seen }) => {
+	if (isNil(value) || isString(value) || typeof value === "number" || typeof value === "boolean") return value;
+	if (Array.isArray(value) || isObjectRecord(value)) {
+		if (seen.has(value)) return CIRCULAR_PLACEHOLDER;
+		if (depth >= MAX_SERIALIZED_DEPTH) return TOO_DEEP_PLACEHOLDER;
+		seen.add(value);
+		if (Array.isArray(value)) return value.map((entry) => rebuildSerializable({
+			value: entry,
+			depth: depth + 1,
+			seen
+		}));
+		return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, rebuildSerializable({
+			value: entry,
+			depth: depth + 1,
+			seen
+		})]));
+	}
+	return String(value);
+};
+const toSerializable = (value) => {
+	if (isNil(value)) return value;
+	const { error } = tryCatchSync(() => JSON.stringify(value));
+	if (isNil(error)) return value;
+	const rebuilt = tryCatchSync(() => rebuildSerializable({
+		value,
+		depth: 0,
+		seen: /* @__PURE__ */ new WeakSet()
+	}));
+	return isNil(rebuilt.error) ? rebuilt.data : UNSERIALIZABLE_PLACEHOLDER;
+};
+const toSerializableHttpDetails = (httpDetails) => {
+	if (isNil(httpDetails)) return null;
+	const { responseBody, requestBody, responseHeaders } = httpDetails;
+	return {
+		...httpDetails,
+		responseBody: toSerializable(responseBody),
+		requestBody: toSerializable(requestBody),
+		responseHeaders: isNil(responseHeaders) ? void 0 : Object.fromEntries(Object.entries(responseHeaders).map(([key, value]) => [key, toSerializable(value)]))
+	};
+};
+const readErrorName = (error) => {
+	const name = readString(error, "name");
+	if (!isNil(name) && name.length > 0 && name !== "Error") return name;
+	const ctor = error["constructor"];
+	if (typeof ctor === "function" && isString(ctor.name) && ctor.name.length > 0 && ctor.name !== "Object" && ctor.name !== "Error") return ctor.name;
+};
+const readErrorMessage = (error) => {
+	const messageString = readString(error, "message");
+	if (!isNil(messageString)) return messageString;
+	const stringified = String(error);
+	if (stringified.length > 0 && stringified !== "[object Object]") return stringified;
+	return "Unknown error";
+};
+const pickPlainMessage = ({ httpDetails, rawMessage }) => {
+	if (httpDetails?.apiMessage) return httpDetails.apiMessage;
+	const cleaned = stripStack(rawMessage);
+	if (cleaned.length > 0) return truncate(cleaned);
+	return "Unknown error";
+};
+const isFriendlyPieceError = (value) => {
+	if (!isObjectRecord(value)) return false;
+	return value["__apErrorVersion"] === FRIENDLY_PIECE_ERROR_VERSION && typeof value["message"] === "string";
+};
+const formatPieceError = (error, options) => {
+	const raw = options?.raw;
+	const withRaw = (base) => {
+		if (isNil(raw) || raw.length === 0 || !isNil(base.raw)) return base;
+		return {
+			...base,
+			raw: truncateRaw(raw)
+		};
+	};
+	if (isNil(error)) return withRaw({
+		__apErrorVersion: FRIENDLY_PIECE_ERROR_VERSION,
+		message: "Unknown error"
+	});
+	if (isString(error)) {
+		const cleaned = stripStack(error);
+		return withRaw({
+			__apErrorVersion: FRIENDLY_PIECE_ERROR_VERSION,
+			message: cleaned.length > 0 ? cleaned : "Unknown error"
+		});
+	}
+	if (!isObjectRecord(error)) return withRaw({
+		__apErrorVersion: FRIENDLY_PIECE_ERROR_VERSION,
+		message: truncate(String(error))
+	});
+	if (isFriendlyPieceError(error)) return withRaw(error);
+	const httpDetails = extractHttpDetails(error);
+	const errorName = readErrorName(error);
+	return withRaw({
+		__apErrorVersion: FRIENDLY_PIECE_ERROR_VERSION,
+		message: pickPlainMessage({
+			httpDetails,
+			rawMessage: readErrorMessage(error)
+		}),
+		errorName,
+		...toSerializableHttpDetails(httpDetails) ?? {}
+	});
+};
+const tryParseFriendlyPieceError = (value) => {
+	if (isNil(value)) return null;
+	const candidate = isString(value) ? safeJsonParse(value) : value;
+	return isFriendlyPieceError(candidate) ? candidate : null;
+};
+
+//#endregion
+//#region upstream/core-utils/lib/ssrf-ip-classifier.ts
+function parseOrNull(ip) {
+	try {
+		return ipaddr.parse(ip);
+	} catch {
+		return null;
+	}
+}
+function isInAllowList({ ip, allowList }) {
+	if (allowList.includes(ip)) return true;
+	const addr = parseOrNull(ip);
+	if (!addr) return false;
+	return allowList.some((entry) => entry.includes("/") && matchesCidr({
+		addr,
+		cidr: entry
+	}));
+}
+function matchesCidr({ addr, cidr }) {
+	try {
+		const range = ipaddr.parseCIDR(cidr);
+		if (addr.kind() !== range[0].kind()) return false;
+		return addr.match(range);
+	} catch {
+		return false;
+	}
+}
+function isBlockedRange(addr) {
+	if (addr.kind() === "ipv6") {
+		const v6 = addr;
+		if (v6.isIPv4MappedAddress()) return isBlockedRange(v6.toIPv4Address());
+	}
+	return addr.range() !== "unicast";
+}
+function isBlockedIp({ ip, allowList }) {
+	if (isInAllowList({
+		ip,
+		allowList
+	})) return false;
+	const addr = parseOrNull(ip);
+	if (!addr) return true;
+	return isBlockedRange(addr);
+}
+const ssrfIpClassifier = { isBlockedIp };
+
+//#endregion
+//#region upstream/engine/lib/helper/dynamic-prop-keys.ts
+function escapePropsKeys(props) {
+	return Object.fromEntries(Object.entries(props).map(([key, property]) => [escapeKey(key), property]));
+}
+function unescapePropsKeys(props) {
+	return Object.fromEntries(Object.entries(props).map(([key, property]) => [unescapeKey(key), property]));
+}
+function unescapeInputKeys(value) {
+	if (!isObject(value)) return value;
+	return Object.fromEntries(Object.entries(value).map(([key, child]) => [unescapeKey(key), child]));
+}
+function escapeKey(key) {
+	if (!RESERVED_CHARS.test(key)) return key;
+	return ESCAPED_KEY_MARKER + key.replace(/[~.[\]"']/g, (char) => ESCAPE_SEQUENCES[char]);
+}
+function unescapeKey(key) {
+	if (!key.startsWith(ESCAPED_KEY_MARKER)) return key;
+	return key.slice(ESCAPED_KEY_MARKER.length).replace(/~[0-5]/g, (sequence) => UNESCAPE_SEQUENCES[sequence]);
+}
+const ESCAPED_KEY_MARKER = "~ap~";
+const RESERVED_CHARS = /[~.[\]"']/;
+const ESCAPE_SEQUENCES = {
+	"~": "~0",
+	".": "~1",
+	"[": "~2",
+	"]": "~3",
+	"\"": "~4",
+	"'": "~5"
+};
+const UNESCAPE_SEQUENCES = Object.fromEntries(Object.entries(ESCAPE_SEQUENCES).map(([char, sequence]) => [sequence, char]));
+const dynamicPropKeys = {
+	escapePropsKeys,
+	unescapePropsKeys,
+	unescapeInputKeys
+};
+
+//#endregion
+//#region upstream/engine/lib/variables/processors/array-zipper.ts
+function getLongestArrayLengthInObject(props) {
+	return Math.max(...Object.values(props).map((value) => Array.isArray(value) ? value.length : 1));
+}
+function constructResultForIndex(props, index) {
+	return Object.entries(props).reduce((result, [key, value]) => {
+		result[key] = Array.isArray(value) ? value[index] : value;
+		return result;
+	}, {});
+}
+const arrayZipperProcessor = (_property, value) => {
+	if (Array.isArray(value) || !isObject(value)) return value;
+	return Array.from({ length: getLongestArrayLengthInObject(value) }, (_, index) => constructResultForIndex(value, index));
+};
+
+//#endregion
+//#region upstream/engine/lib/variables/processors/checkbox.ts
+const checkboxProcessor = (_property, value) => {
+	if (isNil(value) || typeof value === "boolean") return value;
+	if (typeof value === "string" && value.trim().length === 0) return;
+	const parsed = parseToJsonIfPossible(value);
+	return typeof parsed === "boolean" ? parsed : value;
+};
+
+//#endregion
+//#region upstream/engine/lib/variables/processors/date-time.ts
+const dateTimeProcessor = (_property, value) => {
+	dayjs.extend(utc);
+	dayjs.extend(timezone);
+	const dateTimeString = value;
+	try {
+		if (!dateTimeString) throw Error("Undefined input");
+		return dayjs.tz(dateTimeString, "UTC").toISOString();
+	} catch (error) {
+		console.error(error);
+		return;
+	}
+};
+
+//#endregion
+//#region upstream/engine/lib/variables/processors/file.ts
+const fileProcessor = async (property, urlOrBase64) => {
+	if (isNil(urlOrBase64) || !isString(urlOrBase64)) return null;
+	const streaming = property.type === PropertyType.FILE && property.streaming === true;
+	try {
+		if (streaming) return await handleStreamingFile(urlOrBase64);
+		const file = handleBase64File(urlOrBase64);
+		if (!isNil(file)) return file;
+		return await handleUrlFile(urlOrBase64);
+	} catch (e) {
+		console.error(e);
+		return null;
+	}
+};
+function parseBase64File(propertyValue) {
+	if (!isBase64(propertyValue, { allowMime: true })) return null;
+	const matches = propertyValue.match(/^data:([A-Za-z-+/]+);base64,(.+)$/);
+	if (!matches || matches?.length !== 3) return null;
+	return {
+		extension: mimeExtension(matches[1]) || "bin",
+		buffer: Buffer.from(matches[2], "base64")
+	};
+}
+function handleBase64File(propertyValue) {
+	const parsed = parseBase64File(propertyValue);
+	if (isNil(parsed)) return null;
+	return new ApFile(`unknown.${parsed.extension}`, parsed.buffer, parsed.extension);
+}
+async function handleUrlFile(path) {
+	const fileResponse = await fetch(path);
+	if (!fileResponse.ok) return null;
+	const filename = getFileName(path, fileResponse.headers.get("content-disposition"), fileResponse.headers.get("content-type") ?? void 0) ?? "unknown";
+	const extension = extensionFromFilename(filename);
+	return new ApFile(filename, Buffer.from(await fileResponse.arrayBuffer()), extension);
+}
+async function handleStreamingFile(propertyValue) {
+	const parsed = parseBase64File(propertyValue);
+	if (!isNil(parsed)) return {
+		filename: `unknown.${parsed.extension}`,
+		extension: parsed.extension,
+		size: parsed.buffer.length,
+		body: Readable.from(parsed.buffer)
+	};
+	const fileResponse = await fetch(propertyValue);
+	if (!fileResponse.ok || isNil(fileResponse.body)) {
+		await fileResponse.body?.cancel();
+		return null;
+	}
+	const filename = getFileName(propertyValue, fileResponse.headers.get("content-disposition"), fileResponse.headers.get("content-type") ?? void 0) ?? "unknown";
+	const extension = extensionFromFilename(filename);
+	const contentEncoding = fileResponse.headers.get("content-encoding");
+	const contentLength = Number(fileResponse.headers.get("content-length"));
+	return {
+		filename,
+		extension,
+		size: (isNil(contentEncoding) || contentEncoding.toLowerCase() === "identity") && Number.isInteger(contentLength) && contentLength > 0 ? contentLength : void 0,
+		body: Readable.fromWeb(fileResponse.body)
+	};
+}
+function extensionFromFilename(filename) {
+	const parts = filename.split(".");
+	const last = parts.length > 1 ? parts.pop() : void 0;
+	return last ? last : void 0;
+}
+function getFileName(path, disposition, mimeType) {
+	const url = new URL(path);
+	if (isNil(disposition)) {
+		const fileNameFromUrl = url.pathname.includes("/") && url.pathname.split("/").pop()?.includes(".") ? url.pathname.split("/").pop() : null;
+		if (!isNil(fileNameFromUrl)) return fileNameFromUrl;
+		return `unknown.${(mimeType ? mimeExtension(mimeType) : null) ?? "bin"}`;
+	}
+	const utf8FilenameRegex = /filename\*=UTF-8''([\w%\-.]+)(?:; ?|$)/i;
+	if (utf8FilenameRegex.test(disposition)) {
+		const result = utf8FilenameRegex.exec(disposition);
+		if (result && result.length > 1) return decodeURIComponent(result[1]);
+	}
+	const filenameStart = disposition.toLowerCase().indexOf("filename=");
+	const asciiFilenameRegex = /^filename=(["']?)(.*?[^\\])\1(?:; ?|$)/i;
+	if (filenameStart >= 0) {
+		const partialDisposition = disposition.slice(filenameStart);
+		const matches = asciiFilenameRegex.exec(partialDisposition);
+		if (matches != null && matches[2]) return matches[2];
+	}
+	return null;
+}
+function mimeExtension(mimeType) {
+	return MIME_EXTENSIONS[mimeType.split(";")[0].trim().toLowerCase()] ?? null;
+}
+const MIME_EXTENSIONS = {
+	"application/json": "json",
+	"application/pdf": "pdf",
+	"application/xml": "xml",
+	"application/zip": "zip",
+	"application/gzip": "gz",
+	"application/x-7z-compressed": "7z",
+	"application/x-tar": "tar",
+	"application/octet-stream": "bin",
+	"application/msword": "doc",
+	"application/vnd.openxmlformats-officedocument.wordprocessingml.document": "docx",
+	"application/vnd.ms-excel": "xls",
+	"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": "xlsx",
+	"application/vnd.ms-powerpoint": "ppt",
+	"application/vnd.openxmlformats-officedocument.presentationml.presentation": "pptx",
+	"application/rtf": "rtf",
+	"application/javascript": "js",
+	"application/x-javascript": "js",
+	"application/x-yaml": "yaml",
+	"application/yaml": "yaml",
+	"application/x-httpd-php": "php",
+	"application/x-sh": "sh",
+	"image/png": "png",
+	"image/jpeg": "jpg",
+	"image/jpg": "jpg",
+	"image/gif": "gif",
+	"image/webp": "webp",
+	"image/svg+xml": "svg",
+	"image/bmp": "bmp",
+	"image/tiff": "tiff",
+	"image/x-icon": "ico",
+	"image/vnd.microsoft.icon": "ico",
+	"image/heic": "heic",
+	"image/heif": "heif",
+	"image/avif": "avif",
+	"text/plain": "txt",
+	"text/html": "html",
+	"text/css": "css",
+	"text/csv": "csv",
+	"text/javascript": "js",
+	"text/markdown": "md",
+	"text/xml": "xml",
+	"text/tab-separated-values": "tsv",
+	"text/yaml": "yaml",
+	"audio/mpeg": "mp3",
+	"audio/mp3": "mp3",
+	"audio/mp4": "m4a",
+	"audio/wav": "wav",
+	"audio/x-wav": "wav",
+	"audio/ogg": "ogg",
+	"audio/webm": "weba",
+	"audio/flac": "flac",
+	"audio/aac": "aac",
+	"video/mp4": "mp4",
+	"video/mpeg": "mpeg",
+	"video/webm": "webm",
+	"video/quicktime": "mov",
+	"video/x-msvideo": "avi",
+	"video/ogg": "ogv",
+	"font/woff": "woff",
+	"font/woff2": "woff2",
+	"font/ttf": "ttf",
+	"font/otf": "otf"
+};
+
+//#endregion
+//#region upstream/engine/lib/variables/processors/json.ts
+const jsonProcessor = (_property, value) => {
+	if (isNil(value)) return value;
+	try {
+		if (typeof value === "object") return value;
+		return JSON.parse(value);
+	} catch (error) {
+		console.error(error);
+		return;
+	}
+};
+
+//#endregion
+//#region upstream/engine/lib/variables/processors/multi-select.ts
+const multiSelectProcessor = (_property, value) => {
+	if (isNil(value) || Array.isArray(value)) return value;
+	if (typeof value === "string" && value.trim().length === 0) return;
+	const parsed = parseToJsonIfPossible(value);
+	return Array.isArray(parsed) ? parsed : [value];
+};
+
+//#endregion
+//#region upstream/engine/lib/variables/processors/number.ts
+const numberProcessor = (_property, value) => {
+	if (isNil(value)) return value;
+	if (value === "") return;
+	return Number(value);
+};
+
+//#endregion
+//#region upstream/engine/lib/variables/processors/object.ts
+const objectProcessor = (_property, value) => {
+	if (isNil(value)) return value;
+	if (typeof value === "string") try {
+		return JSON.parse(value);
+	} catch (e) {
+		return;
+	}
+	if (typeof value === "object" && !Array.isArray(value)) return value;
+};
+
+//#endregion
+//#region upstream/engine/lib/variables/processors/text.ts
+const textProcessor = (property, value) => {
+	if (isNil(value)) return value;
+	if (typeof value === "object") return JSON.stringify(value);
+	const result = value.toString();
+	if (result.length === 0 && !property.required) return;
+	return result;
+};
+
+//#endregion
+//#region upstream/engine/lib/variables/processors/index.ts
+const processors = {
+	JSON: jsonProcessor,
+	OBJECT: objectProcessor,
+	NUMBER: numberProcessor,
+	LONG_TEXT: textProcessor,
+	SHORT_TEXT: textProcessor,
+	SECRET_TEXT: textProcessor,
+	DATE_TIME: dateTimeProcessor,
+	FILE: fileProcessor,
+	MULTI_SELECT_DROPDOWN: multiSelectProcessor,
+	STATIC_MULTI_SELECT_DROPDOWN: multiSelectProcessor,
+	CHECKBOX: checkboxProcessor
+};
+
+//#endregion
+//#region upstream/engine/lib/variables/props-processor.ts
+const propsProcessor = { applyProcessorsAndValidators: async (resolvedInput, props, auth, requireAuth, propertySettings) => {
+	let dynamaicPropertiesSchema = void 0;
+	if (Object.keys(propertySettings).length > 0) dynamaicPropertiesSchema = Object.fromEntries(Object.entries(propertySettings).map(([key, propertySetting]) => [key, propertySetting.schema]));
+	const processedInput = { ...resolvedInput };
+	const errors = {};
+	const authValue = resolvedInput[AUTHENTICATION_PROPERTY_NAME];
+	if (authValue && requireAuth) {
+		const authPropsToProcess = getAuthPropsToProcess(authValue, auth);
+		if (authPropsToProcess) {
+			const { processedInput: authProcessedInput, errors: authErrors } = await propsProcessor.applyProcessorsAndValidators(resolvedInput[AUTHENTICATION_PROPERTY_NAME], authPropsToProcess, void 0, false, {});
+			processedInput[AUTHENTICATION_PROPERTY_NAME] = authProcessedInput;
+			if (Object.keys(authErrors).length > 0) errors[AUTHENTICATION_PROPERTY_NAME] = authErrors;
+		}
+	}
+	for (const [key, value] of Object.entries(resolvedInput)) {
+		const property = props[key];
+		if (isNil(property)) continue;
+		if (property.type === PropertyType.DYNAMIC) {
+			const valueWithOriginalKeys = dynamicPropKeys.unescapeInputKeys(value);
+			processedInput[key] = valueWithOriginalKeys;
+			if (!isNil(dynamaicPropertiesSchema?.[key])) {
+				const { processedInput: itemProcessedInput, errors: itemErrors } = await propsProcessor.applyProcessorsAndValidators(valueWithOriginalKeys, dynamicPropKeys.unescapePropsKeys(dynamaicPropertiesSchema[key]), void 0, false, {});
+				processedInput[key] = itemProcessedInput;
+				if (Object.keys(itemErrors).length > 0) errors[key] = itemErrors;
+			}
+		}
+		if (property.type === PropertyType.ARRAY && property.properties) {
+			const arrayOfObjects = arrayZipperProcessor(property, value) ?? [];
+			const processedArray = [];
+			const processedErrors = [];
+			for (const item of arrayOfObjects) {
+				const { processedInput: itemProcessedInput, errors: itemErrors } = await propsProcessor.applyProcessorsAndValidators(item, property.properties, void 0, false, {});
+				processedArray.push(itemProcessedInput);
+				processedErrors.push(itemErrors);
+			}
+			processedInput[key] = processedArray;
+			if (processedErrors.some((error) => Object.keys(error).length > 0)) errors[key] = { properties: processedErrors };
+		}
+		if (!property.required && isNil(processedInput[key])) processedInput[key] = void 0;
+		const processor = processors[property.type];
+		if (processor) processedInput[key] = await processor(property, processedInput[key]);
+		if (!(key !== "auth" && property.type !== PropertyType.MARKDOWN)) continue;
+	}
+	for (const [key, value] of Object.entries(processedInput)) {
+		const property = props[key];
+		if (isNil(property)) continue;
+		const validationErrors = validateProperty(property, value, resolvedInput[key]);
+		if (validationErrors.length > 0) errors[key] = validationErrors;
+	}
+	if (Object.keys(errors).length > 0) destroyOpenStreams(processedInput);
+	return {
+		processedInput,
+		errors
+	};
+} };
+function destroyOpenStreams(value) {
+	if (isNil(value) || typeof value !== "object" || Buffer.isBuffer(value)) return;
+	if (value instanceof Readable) {
+		value.destroy();
+		return;
+	}
+	for (const child of Object.values(value)) destroyOpenStreams(child);
+}
+const validateProperty = (property, value, originalValue) => {
+	if (property.type === PropertyType.JSON) {
+		if (!property.required && originalValue === "") return [];
+		if (!isNil(originalValue) && isNil(value)) return [`Expected JSON, received: ${originalValue}`];
+		if (!property.required && isNil(value)) return [];
+		if (!isObject(value) && !Array.isArray(value)) return [`Expected JSON, received: ${originalValue}`];
+		return [];
+	}
+	if (!property.required && isNil(value)) return [];
+	switch (property.type) {
+		case PropertyType.SHORT_TEXT:
+		case PropertyType.LONG_TEXT:
+		case PropertyType.RICH_TEXT: return typeof value === "string" ? [] : [`Expected string, received: ${originalValue}`];
+		case PropertyType.NUMBER: return typeof value === "number" && !Number.isNaN(value) ? [] : [`Expected number, received: ${originalValue}`];
+		case PropertyType.CHECKBOX: return typeof value === "boolean" ? [] : [`Expected boolean, received: ${originalValue}`];
+		case PropertyType.DATE_TIME: return typeof value === "string" ? [] : [`Invalid datetime format. Expected ISO format (e.g. 2024-03-14T12:00:00.000Z), received: ${originalValue}`];
+		case PropertyType.DATE_RANGE: return DateRangeValue.safeParse(value).success ? [] : [`Expected date range, received: ${originalValue}`];
+		case PropertyType.ARRAY:
+		case PropertyType.MULTI_SELECT_DROPDOWN:
+		case PropertyType.STATIC_MULTI_SELECT_DROPDOWN: return Array.isArray(value) ? [] : [`Expected array, received: ${originalValue}`];
+		case PropertyType.OBJECT: return isObject(value) ? [] : [`Expected object, received: ${originalValue}`];
+		case PropertyType.FILE: return isObject(value) ? [] : [`Expected file url or base64 with mimeType, received: ${originalValue}`];
+		default: return [];
+	}
+};
+function getAuthPropsToProcess(authValue, auth) {
+	if (isNil(auth)) return null;
+	const usedAuthProperty = getAuthPropertyForValue({
+		authValueType: authValue.type,
+		pieceAuth: auth
+	});
+	if ((usedAuthProperty?.type === PropertyType.CUSTOM_AUTH || usedAuthProperty?.type === PropertyType.OAUTH2 || usedAuthProperty?.type === PropertyType.OIDC) && !isNil(usedAuthProperty?.props)) return usedAuthProperty.props;
+	return null;
+}
+
+//#endregion
+export { arrayZipperProcessor, checkboxProcessor, dateTimeProcessor, dynamicPropKeys, fileProcessor, formatPieceError, jsonProcessor, multiSelectProcessor, numberProcessor, objectProcessor, processors, propsProcessor, ssrfIpClassifier, textProcessor, tryParseFriendlyPieceError };
+//# sourceMappingURL=host.js.map