@8ms/helpers 2.3.5 → 2.3.6

package/dist/multipart-parser-BC14QSvI.mjs

@@ -0,0 +1,290 @@
+import { r as File, t as FormData } from "./from-9s4TjsYv.mjs";
+
+//#region node_modules/node-fetch/src/utils/multipart-parser.js
+let s = 0;
+const S = {
+	START_BOUNDARY: s++,
+	HEADER_FIELD_START: s++,
+	HEADER_FIELD: s++,
+	HEADER_VALUE_START: s++,
+	HEADER_VALUE: s++,
+	HEADER_VALUE_ALMOST_DONE: s++,
+	HEADERS_ALMOST_DONE: s++,
+	PART_DATA_START: s++,
+	PART_DATA: s++,
+	END: s++
+};
+let f = 1;
+const F = {
+	PART_BOUNDARY: f,
+	LAST_BOUNDARY: f *= 2
+};
+const LF = 10;
+const CR = 13;
+const SPACE = 32;
+const HYPHEN = 45;
+const COLON = 58;
+const A = 97;
+const Z = 122;
+const lower = (c) => c | 32;
+const noop = () => {};
+var MultipartParser = class {
+	/**
+	* @param {string} boundary
+	*/
+	constructor(boundary) {
+		this.index = 0;
+		this.flags = 0;
+		this.onHeaderEnd = noop;
+		this.onHeaderField = noop;
+		this.onHeadersEnd = noop;
+		this.onHeaderValue = noop;
+		this.onPartBegin = noop;
+		this.onPartData = noop;
+		this.onPartEnd = noop;
+		this.boundaryChars = {};
+		boundary = "\r\n--" + boundary;
+		const ui8a = new Uint8Array(boundary.length);
+		for (let i = 0; i < boundary.length; i++) {
+			ui8a[i] = boundary.charCodeAt(i);
+			this.boundaryChars[ui8a[i]] = true;
+		}
+		this.boundary = ui8a;
+		this.lookbehind = new Uint8Array(this.boundary.length + 8);
+		this.state = S.START_BOUNDARY;
+	}
+	/**
+	* @param {Uint8Array} data
+	*/
+	write(data) {
+		let i = 0;
+		const length_ = data.length;
+		let previousIndex = this.index;
+		let { lookbehind, boundary, boundaryChars, index, state, flags } = this;
+		const boundaryLength = this.boundary.length;
+		const boundaryEnd = boundaryLength - 1;
+		const bufferLength = data.length;
+		let c;
+		let cl;
+		const mark = (name) => {
+			this[name + "Mark"] = i;
+		};
+		const clear = (name) => {
+			delete this[name + "Mark"];
+		};
+		const callback = (callbackSymbol, start, end, ui8a) => {
+			if (start === void 0 || start !== end) this[callbackSymbol](ui8a && ui8a.subarray(start, end));
+		};
+		const dataCallback = (name, clear) => {
+			const markSymbol = name + "Mark";
+			if (!(markSymbol in this)) return;
+			if (clear) {
+				callback(name, this[markSymbol], i, data);
+				delete this[markSymbol];
+			} else {
+				callback(name, this[markSymbol], data.length, data);
+				this[markSymbol] = 0;
+			}
+		};
+		for (i = 0; i < length_; i++) {
+			c = data[i];
+			switch (state) {
+				case S.START_BOUNDARY:
+					if (index === boundary.length - 2) {
+						if (c === HYPHEN) flags |= F.LAST_BOUNDARY;
+						else if (c !== CR) return;
+						index++;
+						break;
+					} else if (index - 1 === boundary.length - 2) {
+						if (flags & F.LAST_BOUNDARY && c === HYPHEN) {
+							state = S.END;
+							flags = 0;
+						} else if (!(flags & F.LAST_BOUNDARY) && c === LF) {
+							index = 0;
+							callback("onPartBegin");
+							state = S.HEADER_FIELD_START;
+						} else return;
+						break;
+					}
+					if (c !== boundary[index + 2]) index = -2;
+					if (c === boundary[index + 2]) index++;
+					break;
+				case S.HEADER_FIELD_START:
+					state = S.HEADER_FIELD;
+					mark("onHeaderField");
+					index = 0;
+				case S.HEADER_FIELD:
+					if (c === CR) {
+						clear("onHeaderField");
+						state = S.HEADERS_ALMOST_DONE;
+						break;
+					}
+					index++;
+					if (c === HYPHEN) break;
+					if (c === COLON) {
+						if (index === 1) return;
+						dataCallback("onHeaderField", true);
+						state = S.HEADER_VALUE_START;
+						break;
+					}
+					cl = lower(c);
+					if (cl < A || cl > Z) return;
+					break;
+				case S.HEADER_VALUE_START:
+					if (c === SPACE) break;
+					mark("onHeaderValue");
+					state = S.HEADER_VALUE;
+				case S.HEADER_VALUE:
+					if (c === CR) {
+						dataCallback("onHeaderValue", true);
+						callback("onHeaderEnd");
+						state = S.HEADER_VALUE_ALMOST_DONE;
+					}
+					break;
+				case S.HEADER_VALUE_ALMOST_DONE:
+					if (c !== LF) return;
+					state = S.HEADER_FIELD_START;
+					break;
+				case S.HEADERS_ALMOST_DONE:
+					if (c !== LF) return;
+					callback("onHeadersEnd");
+					state = S.PART_DATA_START;
+					break;
+				case S.PART_DATA_START:
+					state = S.PART_DATA;
+					mark("onPartData");
+				case S.PART_DATA:
+					previousIndex = index;
+					if (index === 0) {
+						i += boundaryEnd;
+						while (i < bufferLength && !(data[i] in boundaryChars)) i += boundaryLength;
+						i -= boundaryEnd;
+						c = data[i];
+					}
+					if (index < boundary.length) if (boundary[index] === c) {
+						if (index === 0) dataCallback("onPartData", true);
+						index++;
+					} else index = 0;
+					else if (index === boundary.length) {
+						index++;
+						if (c === CR) flags |= F.PART_BOUNDARY;
+						else if (c === HYPHEN) flags |= F.LAST_BOUNDARY;
+						else index = 0;
+					} else if (index - 1 === boundary.length) if (flags & F.PART_BOUNDARY) {
+						index = 0;
+						if (c === LF) {
+							flags &= ~F.PART_BOUNDARY;
+							callback("onPartEnd");
+							callback("onPartBegin");
+							state = S.HEADER_FIELD_START;
+							break;
+						}
+					} else if (flags & F.LAST_BOUNDARY) if (c === HYPHEN) {
+						callback("onPartEnd");
+						state = S.END;
+						flags = 0;
+					} else index = 0;
+					else index = 0;
+					if (index > 0) lookbehind[index - 1] = c;
+					else if (previousIndex > 0) {
+						const _lookbehind = new Uint8Array(lookbehind.buffer, lookbehind.byteOffset, lookbehind.byteLength);
+						callback("onPartData", 0, previousIndex, _lookbehind);
+						previousIndex = 0;
+						mark("onPartData");
+						i--;
+					}
+					break;
+				case S.END: break;
+				default: throw new Error(`Unexpected state entered: ${state}`);
+			}
+		}
+		dataCallback("onHeaderField");
+		dataCallback("onHeaderValue");
+		dataCallback("onPartData");
+		this.index = index;
+		this.state = state;
+		this.flags = flags;
+	}
+	end() {
+		if (this.state === S.HEADER_FIELD_START && this.index === 0 || this.state === S.PART_DATA && this.index === this.boundary.length) this.onPartEnd();
+		else if (this.state !== S.END) throw new Error("MultipartParser.end(): stream ended unexpectedly");
+	}
+};
+function _fileName(headerValue) {
+	const m = headerValue.match(/\bfilename=("(.*?)"|([^()<>@,;:\\"/[\]?={}\s\t]+))($|;\s)/i);
+	if (!m) return;
+	const match = m[2] || m[3] || "";
+	let filename = match.slice(match.lastIndexOf("\\") + 1);
+	filename = filename.replace(/%22/g, "\"");
+	filename = filename.replace(/&#(\d{4});/g, (m, code) => {
+		return String.fromCharCode(code);
+	});
+	return filename;
+}
+async function toFormData(Body, ct) {
+	if (!/multipart/i.test(ct)) throw new TypeError("Failed to fetch");
+	const m = ct.match(/boundary=(?:"([^"]+)"|([^;]+))/i);
+	if (!m) throw new TypeError("no or bad content-type header, no multipart boundary");
+	const parser = new MultipartParser(m[1] || m[2]);
+	let headerField;
+	let headerValue;
+	let entryValue;
+	let entryName;
+	let contentType;
+	let filename;
+	const entryChunks = [];
+	const formData = new FormData();
+	const onPartData = (ui8a) => {
+		entryValue += decoder.decode(ui8a, { stream: true });
+	};
+	const appendToFile = (ui8a) => {
+		entryChunks.push(ui8a);
+	};
+	const appendFileToFormData = () => {
+		const file = new File(entryChunks, filename, { type: contentType });
+		formData.append(entryName, file);
+	};
+	const appendEntryToFormData = () => {
+		formData.append(entryName, entryValue);
+	};
+	const decoder = new TextDecoder("utf-8");
+	decoder.decode();
+	parser.onPartBegin = function() {
+		parser.onPartData = onPartData;
+		parser.onPartEnd = appendEntryToFormData;
+		headerField = "";
+		headerValue = "";
+		entryValue = "";
+		entryName = "";
+		contentType = "";
+		filename = null;
+		entryChunks.length = 0;
+	};
+	parser.onHeaderField = function(ui8a) {
+		headerField += decoder.decode(ui8a, { stream: true });
+	};
+	parser.onHeaderValue = function(ui8a) {
+		headerValue += decoder.decode(ui8a, { stream: true });
+	};
+	parser.onHeaderEnd = function() {
+		headerValue += decoder.decode();
+		headerField = headerField.toLowerCase();
+		if (headerField === "content-disposition") {
+			const m = headerValue.match(/\bname=("([^"]*)"|([^()<>@,;:\\"/[\]?={}\s\t]+))/i);
+			if (m) entryName = m[2] || m[3] || "";
+			filename = _fileName(headerValue);
+			if (filename) {
+				parser.onPartData = appendToFile;
+				parser.onPartEnd = appendFileToFormData;
+			}
+		} else if (headerField === "content-type") contentType = headerValue;
+		headerValue = "";
+		headerField = "";
+	};
+	for await (const chunk of Body) parser.write(chunk);
+	parser.end();
+	return formData;
+}
+
+//#endregion
+export { toFormData };

package/dist/myTarget/server/index.d.mts

@@ -0,0 +1,9 @@
+import { s as ApiResponse } from "../../index-B20FTOvk.mjs";
+
+//#region src/myTarget/server/myTarget.d.ts
+/**
+ * Make the request to MyTarget API using the access token.
+ */
+declare const request: (data: object, url: string, accessToken: string) => Promise<ApiResponse>;
+//#endregion
+export { request };

package/dist/myTarget/server/index.mjs

@@ -0,0 +1,16 @@
+import "../../api-DGKJDAfb.mjs";
+import { post } from "../../axios/index.mjs";
+
+//#region src/myTarget/server/myTarget.ts
+/**
+* Make the request to MyTarget API using the access token.
+*/
+const request = async (data, url, accessToken) => {
+	return await post(url, data, { headers: {
+		Authorization: `Bearer ${accessToken}`,
+		"Content-Type": "application/json"
+	} });
+};
+
+//#endregion
+export { request };

package/dist/nextAuth/index.d.mts

@@ -0,0 +1,12 @@
+//#region src/nextAuth/isSessionReady.d.ts
+declare const isSessionReady: (session: any) => boolean;
+//#endregion
+//#region src/nextAuth/nextAuth.d.ts
+declare const NextAuthState: {
+  readonly AUTHENTICATED: "authenticated";
+  readonly PENDING: "loading";
+  readonly UNAUTHENTICATED: "unauthenticated";
+};
+type NextAuthState = typeof NextAuthState[keyof typeof NextAuthState];
+//#endregion
+export { NextAuthState, isSessionReady };

package/dist/nextAuth/index.mjs

@@ -0,0 +1,15 @@
+//#region src/nextAuth/isSessionReady.ts
+const isSessionReady = (session) => {
+	return null !== session?.user;
+};
+
+//#endregion
+//#region src/nextAuth/nextAuth.ts
+const NextAuthState = {
+	AUTHENTICATED: "authenticated",
+	PENDING: "loading",
+	UNAUTHENTICATED: "unauthenticated"
+};
+
+//#endregion
+export { NextAuthState, isSessionReady };

package/dist/nextJs/index.d.mts

@@ -0,0 +1,19 @@
+//#region src/nextJs/nextJs.d.ts
+/**
+ * Get the user's remote IP Address
+ */
+declare const getIp: ({
+  req
+}: {
+  req: any;
+}) => string;
+/**
+ * Get the user's User Agent
+ */
+declare const getUserAgent: ({
+  req
+}: {
+  req: any;
+}) => string;
+//#endregion
+export { getIp, getUserAgent };

package/dist/nextJs/index.mjs

@@ -0,0 +1,12 @@
+//#region src/nextJs/nextJs.ts
+/**
+* Get the user's remote IP Address
+*/
+const getIp = ({ req }) => String(req.headers?.["x-real-ip"] || "unset");
+/**
+* Get the user's User Agent
+*/
+const getUserAgent = ({ req }) => String(req.headers["user-agent"] || "unset");
+
+//#endregion
+export { getIp, getUserAgent };

package/dist/number/index.d.mts

@@ -0,0 +1,54 @@
+//#region src/number/format.d.ts
+type FormatProps = {
+  compact?: boolean;
+  input: any;
+  locale?: string;
+  minDp?: number;
+  maxDp?: number;
+};
+/**
+ * Take a given number and format it.
+ */
+declare const format: (props: FormatProps) => string;
+//#endregion
+//#region src/number/formatCurrency.d.ts
+/**
+ * Use the International number formatting to return the currency value.
+ * https://www.freecodecamp.org/news/how-to-format-number-as-currency-in-javascript-one-line-of-code/
+ */
+declare const formatCurrency: (input: any, locale?: string, currency?: string) => string;
+//#endregion
+//#region src/number/getDecimal.d.ts
+/**
+ * Return a decimal number after rounding.
+ */
+declare const getDecimal: (input: any, dp?: number) => number;
+//#endregion
+//#region src/number/getSafeDivide.d.ts
+type GetSafeDivideProps = {
+  defaultValue?: number;
+  dp?: number;
+  divisor: any;
+  numerator: any;
+};
+/**
+ * Shorthand function to divide number, but fallback if the divisor is 0.
+ */
+declare const getSafeDivide: (props: GetSafeDivideProps) => number;
+//#endregion
+//#region src/number/getPercent.d.ts
+declare const getPercent: (numerator: any, divisor: any, dp?: number) => number;
+//#endregion
+//#region src/number/getNumber.d.ts
+/**
+ * Take an input and return a number.
+ */
+declare const getNumber: (input: any, defaultValue?: number) => number;
+//#endregion
+//#region src/number/getPercentIncrease.d.ts
+/**
+ * Formula to work out the percentage increase/decrease.
+ */
+declare const getPercentIncrease: (current: any, comparison: any, defaultValue: number) => number;
+//#endregion
+export { format, formatCurrency, getDecimal, getNumber, getPercent, getPercentIncrease, getSafeDivide };

package/dist/number/index.mjs

@@ -0,0 +1,75 @@
+import { n as getNumber, t as getDecimal } from "../getDecimal-CafxtLhH.mjs";
+
+//#region src/number/format.ts
+/**
+* Take a given number and format it.
+*/
+const format = (props) => {
+	const minDp = props?.minDp ?? 0;
+	const maxDp = props?.maxDp ?? 2;
+	const compact = props?.compact || false;
+	const inputValue = getNumber(props.input);
+	return Intl.NumberFormat(props?.locale || "en-GB", {
+		minimumFractionDigits: minDp,
+		maximumFractionDigits: maxDp,
+		notation: compact ? "compact" : "standard"
+	}).format(inputValue);
+};
+
+//#endregion
+//#region src/number/formatCurrency.ts
+/**
+* Use the International number formatting to return the currency value.
+* https://www.freecodecamp.org/news/how-to-format-number-as-currency-in-javascript-one-line-of-code/
+*/
+const formatCurrency = (input, locale = "en-GB", currency = "GBP") => {
+	const value = Number(input);
+	const currencyClean = currency.toUpperCase().trim();
+	let formatted = new Intl.NumberFormat(locale, {
+		style: "currency",
+		currency: currencyClean
+	}).format(value);
+	if ("USD" === currencyClean) formatted = formatted.replace("US$", "$");
+	return formatted;
+};
+
+//#endregion
+//#region src/number/getSafeDivide.ts
+/**
+* Shorthand function to divide number, but fallback if the divisor is 0.
+*/
+const getSafeDivide = (props) => {
+	const numeratorInt = getNumber(props.numerator);
+	if (numeratorInt === 0) return 0;
+	const divisorInt = getNumber(props.divisor);
+	if (divisorInt === 0 || !Number.isFinite(divisorInt)) return props?.defaultValue ?? 0;
+	return getDecimal(numeratorInt / divisorInt, props?.dp);
+};
+
+//#endregion
+//#region src/number/getPercent.ts
+const getPercent = (numerator, divisor, dp) => {
+	const finalNumerator = Number(numerator);
+	const finalDivisor = Number(divisor);
+	const finalDp = Number(dp || 1);
+	return Number((getSafeDivide({
+		defaultValue: 0,
+		numerator: finalNumerator,
+		divisor: finalDivisor
+	}) * 100).toFixed(finalDp));
+};
+
+//#endregion
+//#region src/number/getPercentIncrease.ts
+/**
+* Formula to work out the percentage increase/decrease.
+*/
+const getPercentIncrease = (current, comparison, defaultValue) => {
+	const currentValue = getNumber(current);
+	const comparisonValue = getNumber(comparison);
+	if (0 === comparisonValue) return defaultValue;
+	return (currentValue - comparisonValue) / comparisonValue * 100;
+};
+
+//#endregion
+export { format, formatCurrency, getDecimal, getNumber, getPercent, getPercentIncrease, getSafeDivide };

package/{object/replaceKeys.d.ts → dist/object/index.d.mts}

@@ -1,5 +1,8 @@
+//#region src/object/replaceKeys.d.ts
 /**
  * Iteratively replace all the keys in an object.
  * https://www.techighness.com/post/replace-all-keys-of-deeply-nested-objects-or-array-of-objects/
  */
-export declare const replaceKeys: (instance: any, getNewKey: Function) => object;
+declare const replaceKeys: (instance: any, getNewKey: Function) => object;
+//#endregion
+export { replaceKeys };

package/dist/object/index.mjs

@@ -0,0 +1,22 @@
+//#region src/object/replaceKeys.ts
+/**
+* Iteratively replace all the keys in an object.
+* https://www.techighness.com/post/replace-all-keys-of-deeply-nested-objects-or-array-of-objects/
+*/
+const replaceKeys = (instance, getNewKey) => {
+	let response = instance;
+	if (Array.isArray(instance)) {
+		response = [];
+		for (let i = 0; i < instance.length; i++) response[i] = replaceKeys(instance[i], getNewKey);
+	} else if ("object" === typeof instance) {
+		response = {};
+		for (const key in instance) {
+			const newKey = getNewKey(key);
+			response[newKey] = replaceKeys(instance[key], getNewKey);
+		}
+	}
+	return response;
+};
+
+//#endregion
+export { replaceKeys };

package/dist/onePassword/server/index.d.mts

@@ -0,0 +1,24 @@
+import { t as BaseNamespace } from "../../index-CFaAdPAh.mjs";
+import * as _1password_sdk0 from "@1password/sdk";
+import { Client } from "@1password/sdk";
+
+//#region src/onePassword/server/OnePasswordNamespace.d.ts
+declare class OnePasswordNamespace extends BaseNamespace {
+  client: Client;
+  config: OnePasswordConfig;
+  ensureInit: () => Promise<void>;
+  listVaults: () => Promise<_1password_sdk0.VaultOverview[]>;
+  getItem: (vaultId: string, itemId: string) => Promise<_1password_sdk0.Item>;
+  getJsonNote: (vaultId: string, itemId: string) => Promise<any>;
+  listItems: (vaultId: string) => Promise<_1password_sdk0.ItemOverview[]>;
+}
+//#endregion
+//#region src/onePassword/server/onePassword.d.ts
+type OnePasswordConfig = {
+  serviceAccountToken: string;
+  integrationName?: string;
+  integrationVersion?: string;
+};
+declare const onePasswordClient: (key?: string, config?: OnePasswordConfig) => Promise<OnePasswordNamespace>;
+//#endregion
+export { OnePasswordConfig, type OnePasswordNamespace, onePasswordClient };

package/dist/onePassword/server/index.mjs

@@ -0,0 +1,50 @@
+import { BaseNamespace } from "../../_class/index.mjs";
+
+//#region src/onePassword/server/OnePasswordNamespace.ts
+var OnePasswordNamespace = class extends BaseNamespace {
+	ensureInit = async () => {
+		if (!this.client) try {
+			const { createClient } = await import("@1password/sdk");
+			this.client = await createClient({
+				auth: this.config.serviceAccountToken,
+				integrationName: this.config.integrationName || "8MS Helper TS",
+				integrationVersion: this.config.integrationVersion || "v1.0.0"
+			});
+		} catch (e) {
+			throw new Error("1Password SDK not installed");
+		}
+	};
+	listVaults = async () => {
+		await this.ensureInit();
+		return this.client.vaults.list();
+	};
+	getItem = async (vaultId, itemId) => {
+		await this.ensureInit();
+		return this.client.items.get(vaultId, itemId);
+	};
+	getJsonNote = async (vaultId, itemId) => {
+		let response = null;
+		const item = await this.getItem(vaultId, itemId);
+		if (item && "undefined" !== typeof item.notes) response = JSON.parse(item.notes);
+		return response;
+	};
+	listItems = async (vaultId) => {
+		await this.ensureInit();
+		return this.client.items.list(vaultId);
+	};
+};
+
+//#endregion
+//#region src/onePassword/server/onePassword.ts
+const onePasswordNamespaces = /* @__PURE__ */ new Map();
+const onePasswordClient = async (key = "default", config) => {
+	if (onePasswordNamespaces.has(key)) return onePasswordNamespaces.get(key);
+	if (!config) if (key === "default") config = { serviceAccountToken: process.env.ONEPASSWORD_SERVICE_TOKEN };
+	else throw new Error(`Config required for namespace '${key}'`);
+	const namespace = new OnePasswordNamespace(key, config);
+	onePasswordNamespaces.set(key, namespace);
+	return namespace;
+};
+
+//#endregion
+export { OnePasswordNamespace, onePasswordClient };

package/dist/openAi/server/index.d.mts

@@ -0,0 +1,20 @@
+import { t as BaseNamespace } from "../../index-CFaAdPAh.mjs";
+
+//#region src/openAi/server/OpenAiNamespace.d.ts
+declare class OpenAiNamespace extends BaseNamespace {
+  client: boolean;
+  config: OpenAiConfig;
+  /**
+   * Renew the access token as it expires every 3 hours.
+   */
+  ensureInit: () => Promise<void>;
+  completion: (prompt: string, temperature?: number, maxTokens?: number, model?: string) => Promise<any>;
+}
+//#endregion
+//#region src/openAi/server/openAi.d.ts
+type OpenAiConfig = {
+  apiKey: string;
+};
+declare const openAiClient: (key?: string, config?: OpenAiConfig, vaultId?: string, itemId?: string) => Promise<OpenAiNamespace>;
+//#endregion
+export { OpenAiConfig, type OpenAiNamespace, openAiClient };

package/dist/openAi/server/index.mjs

@@ -0,0 +1,46 @@
+import { BaseNamespace } from "../../_class/index.mjs";
+import "../../api-DGKJDAfb.mjs";
+import { post } from "../../axios/index.mjs";
+import { onePasswordClient } from "../../onePassword/server/index.mjs";
+
+//#region src/openAi/server/OpenAiNamespace.ts
+var OpenAiNamespace = class extends BaseNamespace {
+	/**
+	* Renew the access token as it expires every 3 hours.
+	*/
+	ensureInit = async () => {
+		if (!this.client) this.client = true;
+	};
+	completion = async (prompt, temperature = 1, maxTokens = null, model = "gpt-3.5-turbo") => {
+		let response = null;
+		const apiResponse = await post(`https://api.openai.com/v1/chat/completions`, {
+			max_tokens: maxTokens,
+			model,
+			messages: [{
+				role: "user",
+				content: prompt
+			}],
+			temperature: 1
+		}, { headers: { Authorization: `Bearer ${this.config.apiKey}` } });
+		if (apiResponse.isSuccess()) response = apiResponse.getBody();
+		return response;
+	};
+};
+
+//#endregion
+//#region src/openAi/server/openAi.ts
+const openAiNamespaces = /* @__PURE__ */ new Map();
+const openAiClient = async (key = "default", config, vaultId, itemId) => {
+	if (openAiNamespaces.has(key)) return openAiNamespaces.get(key);
+	let instanceConfig;
+	if (config) instanceConfig = config;
+	else if (vaultId && itemId) instanceConfig = await (await onePasswordClient()).getJsonNote(vaultId, itemId);
+	else if (process.env.OPEN_AI_VAULT_ID && process.env.OPEN_AI_ITEM_ID) instanceConfig = await (await onePasswordClient()).getJsonNote(process.env.OPEN_AI_VAULT_ID, process.env.OPEN_AI_ITEM_ID);
+	else throw new Error(`Config required for namespace '${key}'`);
+	const namespace = new OpenAiNamespace(key, instanceConfig);
+	openAiNamespaces.set(key, namespace);
+	return namespace;
+};
+
+//#endregion
+export { OpenAiNamespace, openAiClient };