generaltranslation 9.4.3 → 9.5.1

package/dist/adapter/modelProvider.d.ts

@@ -0,0 +1,4 @@
+import { ModelProvider } from '@generaltranslation/api';
+export type { ModelProvider };
+export declare const supportedModelProviders: ("ANTHROPIC" | "OPENAI" | "XAI" | "GOOGLE")[];
+export declare function isModelProvider(value: unknown): value is ModelProvider;

package/dist/adapter/modelProvider.js

@@ -0,0 +1,6 @@
+import { ModelProvider } from '@generaltranslation/api';
+export var supportedModelProviders = 
+/* @__PURE__ */ Object.values(ModelProvider);
+export function isModelProvider(value) {
+    return supportedModelProviders.includes(value);
+}

package/dist/derive-BVRyqmWc.mjs

@@ -0,0 +1,657 @@
+import { a as unwrapApiResult, n as translateMany, o as isModelProvider, s as supportedModelProviders, t as translate$1 } from "./runtimeTranslate-CVw143pQ.mjs";
+import { t as createDiagnosticMessage } from "./diagnostics-DKA2SkZB.mjs";
+import { n as isBinaryFileFormat } from "./file-Dga6cyM8.mjs";
+import { DEFAULT_BATCH_SIZE, createApiClient, createBranch, createProject, createProjectApiKey, createTag, downloadFiles, enqueueFileTranslations, generateProjectContext, getBranchInfo, getFileInfo, getOrphanedFiles, getProjectInfo, getTranslationJobInfo, getTranslationStatus, listOrgs, listProjects, pollJobs, processBatches, processFileMoves, publishFiles, submitUserEditDiffs, uploadAssets, uploadSourceFiles, uploadTranslations } from "@generaltranslation/api";
+import { resolveAliasLocale, resolveCanonicalLocale, standardizeLocale } from "@generaltranslation/format";
+import { TYPE, parse } from "@generaltranslation/icu";
+//#region src/utils/base64.ts
+function encode(data) {
+	if (typeof Buffer !== "undefined") return Buffer.from(data, "utf8").toString("base64");
+	const bytes = new TextEncoder().encode(data);
+	let binary = "";
+	for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
+	return btoa(binary);
+}
+function decode(base64) {
+	if (typeof Buffer !== "undefined") return Buffer.from(base64, "base64").toString("utf8");
+	const binary = atob(base64);
+	const bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+	return new TextDecoder().decode(bytes);
+}
+function encodeFileContent(content, fileFormat) {
+	return isBinaryFileFormat(fileFormat) ? content : encode(content);
+}
+function decodeFileContent(content, fileFormat) {
+	return isBinaryFileFormat(fileFormat) ? content : decode(content);
+}
+//#endregion
+//#region src/utils/isSupportedFileFormatTransform.ts
+const SUPPORTED_TRANSFORMATIONS = {
+	GTJSON: ["GTJSON"],
+	JSON: ["JSON"],
+	PO: ["PO"],
+	POT: ["POT", "PO"],
+	YAML: ["YAML"],
+	MDX: ["MDX"],
+	MD: ["MD"],
+	TS: ["TS"],
+	JS: ["JS"],
+	HTML: ["HTML"],
+	TXT: ["TXT"],
+	TWILIO_CONTENT_JSON: ["TWILIO_CONTENT_JSON"],
+	LOTTIE: ["LOTTIE"],
+	SVG: ["SVG"],
+	DOT_STRINGS: ["DOT_STRINGS"],
+	DOT_STRINGSDICT: ["DOT_STRINGSDICT"],
+	ANDROID_STRINGS: ["ANDROID_STRINGS"],
+	SRT: ["SRT"],
+	XCSTRINGS: ["XCSTRINGS"]
+};
+/**
+* This function checks if a file format transformation is supported during translation
+* @param from - The source file format.
+* @param to - The target file format.
+* @returns True if the transformation is supported, false otherwise
+*/
+function isSupportedFileFormatTransform(from, to) {
+	return SUPPORTED_TRANSFORMATIONS[from]?.includes(to) ?? false;
+}
+//#endregion
+//#region src/translate/utils/validateFileFormatTransform.ts
+/**
+* Returns a user-facing validation error when a requested file format transform
+* is missing source format context or is not currently supported.
+*/
+function getFileFormatTransformError(file) {
+	if (!file.transformFormat) return void 0;
+	const fileLabel = file.fileName ?? file.fileId ?? "unknown file";
+	if (!file.fileFormat) return `fileFormat is required when transformFormat is provided for ${fileLabel}`;
+	if (!isSupportedFileFormatTransform(file.fileFormat, file.transformFormat)) return `Unsupported file format transform: ${file.fileFormat} -> ${file.transformFormat}`;
+}
+/**
+* Validates file format transforms before sending upload/enqueue requests.
+*/
+function validateFileFormatTransforms(files) {
+	for (const file of files) {
+		const error = getFileFormatTransformError(file);
+		if (error) throw new Error(error);
+	}
+}
+//#endregion
+//#region src/adapter/createGtApi.ts
+async function collectPages(loadPage) {
+	const items = [];
+	let cursor;
+	do {
+		const page = await loadPage(cursor);
+		items.push(...page.items);
+		cursor = page.nextCursor ?? void 0;
+	} while (cursor);
+	return items;
+}
+function normalizeJobStatus(job) {
+	return {
+		jobId: job.jobId,
+		status: job.status,
+		...job.status === "failed" ? { error: { message: job.error.message ?? "" } } : {}
+	};
+}
+function createGtApiAdapter(defaultConfig) {
+	let client;
+	let config;
+	function resolveServiceLocale(locale) {
+		return standardizeLocale(resolveCanonicalLocale(locale, config?.customMapping));
+	}
+	function aliasUploadedFileLocale(file) {
+		return file.locale ? {
+			...file,
+			locale: resolveAliasLocale(file.locale, config?.customMapping)
+		} : file;
+	}
+	function getConfig() {
+		if (!config) throw new Error("API client not configured — call configureApiClient first");
+		return config;
+	}
+	function getClient(timeoutMs) {
+		if (timeoutMs === void 0 && client) return client;
+		return createApiClient({
+			...getConfig(),
+			timeoutMs
+		});
+	}
+	function configure(nextConfig) {
+		client = createApiClient(nextConfig);
+		config = { ...nextConfig };
+	}
+	async function translate(source, options, timeoutMs) {
+		return translate$1(source, options, {
+			...getConfig(),
+			...timeoutMs !== void 0 && { timeoutMs }
+		});
+	}
+	async function translateMany$1(sources, options, timeoutMs) {
+		return translateMany(sources, options, {
+			...getConfig(),
+			...timeoutMs !== void 0 && { timeoutMs }
+		});
+	}
+	if (defaultConfig) configure(defaultConfig);
+	async function loadJobStatuses(jobIds, options = {}) {
+		return unwrapApiResult(await getTranslationJobInfo({
+			body: { jobIds: [...jobIds] },
+			client: getClient(options.timeoutMs),
+			signal: options.signal
+		}));
+	}
+	async function loadProjectInfo(projectId, timeoutMs) {
+		const resolvedProjectId = projectId ?? getConfig().projectId;
+		if (!resolvedProjectId) throw new Error("Project ID is required to fetch project information");
+		return unwrapApiResult(await getProjectInfo({
+			client: getClient(timeoutMs),
+			path: { projectId: resolvedProjectId }
+		}));
+	}
+	return {
+		configure,
+		getClient,
+		resolveAliasLocale(locale) {
+			return resolveAliasLocale(locale, config?.customMapping);
+		},
+		resolveCanonicalLocale(locale) {
+			return resolveServiceLocale(locale);
+		},
+		translate,
+		translateMany: translateMany$1,
+		async queryBranchData(body) {
+			return unwrapApiResult(await getBranchInfo({
+				body,
+				client: getClient()
+			}));
+		},
+		async createBranch(body) {
+			return unwrapApiResult(await createBranch({
+				body,
+				client: getClient()
+			}));
+		},
+		async processFileMoves(moves, options = {}) {
+			const results = await processBatches(moves, async (batch) => {
+				return unwrapApiResult(await processFileMoves({
+					body: {
+						branchId: options.branchId,
+						moves: batch
+					},
+					client: getClient(options.timeout)
+				})).results;
+			});
+			const succeeded = results.filter(({ success }) => success).length;
+			return {
+				results,
+				summary: {
+					total: moves.length,
+					succeeded,
+					failed: results.length - succeeded
+				}
+			};
+		},
+		async getOrphanedFiles(branchId, fileIds, options = {}) {
+			const request = async (batch) => unwrapApiResult(await getOrphanedFiles({
+				body: {
+					branchId,
+					fileIds: batch
+				},
+				client: getClient(options.timeout)
+			}));
+			if (fileIds.length === 0) return request([]);
+			const results = await processBatches(fileIds, async (batch) => [await request(batch)]);
+			const orphanedFiles = new Map(results[0].orphanedFiles.map((file) => [file.fileId, file]));
+			for (const result of results.slice(1)) {
+				const batchFileIds = new Set(result.orphanedFiles.map((file) => file.fileId));
+				for (const fileId of Array.from(orphanedFiles.keys())) if (!batchFileIds.has(fileId)) orphanedFiles.delete(fileId);
+			}
+			return { orphanedFiles: Array.from(orphanedFiles.values()) };
+		},
+		async setupProject(files, options = {}) {
+			return unwrapApiResult(await generateProjectContext({
+				body: {
+					files: files.map(({ branchId, fileId, versionId }) => ({
+						branchId,
+						fileId,
+						versionId
+					})),
+					locales: options.locales?.map((locale) => resolveServiceLocale(locale)),
+					force: options.force
+				},
+				client: getClient(options.timeoutMs)
+			}));
+		},
+		loadJobStatuses,
+		async checkJobStatus(jobIds, timeoutMs) {
+			return (await loadJobStatuses(jobIds, { timeoutMs })).map(normalizeJobStatus);
+		},
+		async awaitJobs(jobIds, options) {
+			const result = await pollJobs(jobIds, (pendingJobIds, signal) => loadJobStatuses(pendingJobIds, { signal }), options);
+			return {
+				...result,
+				jobs: result.jobs.map(normalizeJobStatus)
+			};
+		},
+		async enqueueFiles(files, options) {
+			validateFileFormatTransforms(files);
+			const modelProvider = options.modelProvider;
+			if (modelProvider !== void 0 && !isModelProvider(modelProvider)) throw new Error(createDiagnosticMessage({
+				source: "generaltranslation",
+				severity: "Error",
+				whatHappened: `Unsupported model provider \`${modelProvider}\``,
+				fix: `Use one of: ${supportedModelProviders.join(", ")}`
+			}));
+			const targetLocales = options.targetLocales.map((locale) => resolveServiceLocale(locale));
+			const result = await processBatches(files, async (batch) => {
+				const response = unwrapApiResult(await enqueueFileTranslations({
+					body: {
+						files: batch.map(({ branchId, fileId, versionId, fileName, transformFormat }) => ({
+							branchId,
+							fileId,
+							versionId,
+							fileName,
+							transformFormat
+						})),
+						targetLocales,
+						sourceLocale: options.sourceLocale ? resolveServiceLocale(options.sourceLocale) : void 0,
+						modelProvider,
+						force: options.force
+					},
+					client: getClient(options.timeout)
+				}));
+				const jobData = "jobData" in response ? response.jobData : response.data;
+				return Object.entries(jobData);
+			});
+			return {
+				jobData: Object.fromEntries(result),
+				locales: targetLocales,
+				message: `Successfully enqueued ${result.length} file translation jobs in ${Math.ceil(files.length / DEFAULT_BATCH_SIZE)} batch(es)`
+			};
+		},
+		async createTag(body) {
+			return unwrapApiResult(await createTag({
+				body,
+				client: getClient()
+			}));
+		},
+		async publishFiles(files) {
+			return unwrapApiResult(await publishFiles({
+				body: { files: files.map(({ fileId, versionId, branchId, publish }) => ({
+					fileId,
+					versionId,
+					branchId,
+					publish
+				})) },
+				client: getClient()
+			}));
+		},
+		async submitUserEditDiffs(body, options = {}) {
+			return processBatches(body.diffs, async (diffs) => [unwrapApiResult(await submitUserEditDiffs({
+				body: {
+					projectId: body.projectId,
+					diffs: diffs.map(({ diff, branchId, versionId, fileId, localContent, locale }) => ({
+						diff,
+						branchId,
+						versionId,
+						fileId,
+						localContent,
+						locale: resolveServiceLocale(locale)
+					}))
+				},
+				client: getClient(options.timeout)
+			}))]);
+		},
+		async createProject(orgId, body) {
+			return unwrapApiResult(await createProject({
+				path: { orgId },
+				body: {
+					...body,
+					defaultLocale: resolveServiceLocale(body.defaultLocale)
+				},
+				client: getClient()
+			}));
+		},
+		/** Every project the configured credentials can read. */
+		async listProjects() {
+			return collectPages(async (cursor) => {
+				const { projects, nextCursor } = unwrapApiResult(await listProjects({
+					query: cursor ? { cursor } : void 0,
+					client: getClient()
+				}));
+				return {
+					items: projects,
+					nextCursor
+				};
+			});
+		},
+		/** Organizations where the signed-in user can create projects; user tokens only. */
+		async listOrgs() {
+			return collectPages(async (cursor) => {
+				const { orgs, nextCursor } = unwrapApiResult(await listOrgs({
+					query: cursor ? { cursor } : void 0,
+					client: getClient()
+				}));
+				return {
+					items: orgs,
+					nextCursor
+				};
+			});
+		},
+		async createProjectApiKey(projectId, body) {
+			return unwrapApiResult(await createProjectApiKey({
+				path: { projectId },
+				body,
+				client: getClient()
+			}));
+		},
+		loadProjectInfo,
+		async getProjectInfo(projectId, timeoutMs) {
+			const result = await loadProjectInfo(projectId, timeoutMs);
+			return {
+				...result,
+				defaultLocale: resolveAliasLocale(result.defaultLocale, config?.customMapping),
+				currentLocales: result.currentLocales.map((locale) => resolveAliasLocale(locale, config?.customMapping))
+			};
+		},
+		async queryFileData(body, timeoutMs) {
+			const result = unwrapApiResult(await getFileInfo({
+				body: {
+					...body,
+					translatedFiles: body.translatedFiles?.map((file) => ({
+						...file,
+						locale: resolveServiceLocale(file.locale)
+					}))
+				},
+				client: getClient(timeoutMs)
+			}));
+			return {
+				...result,
+				translatedFiles: result.translatedFiles.map((file) => ({
+					...file,
+					locale: resolveAliasLocale(file.locale, config?.customMapping)
+				})),
+				sourceFiles: result.sourceFiles.map((file) => ({
+					...file,
+					sourceLocale: resolveAliasLocale(file.sourceLocale, config?.customMapping),
+					locales: file.locales.map((locale) => resolveAliasLocale(locale, config?.customMapping))
+				}))
+			};
+		},
+		async querySourceFile(path, query = {}, timeoutMs) {
+			const result = unwrapApiResult(await getTranslationStatus({
+				path,
+				query,
+				client: getClient(timeoutMs)
+			}));
+			return {
+				...result,
+				translations: result.translations.map((translation) => ({
+					...translation,
+					locale: resolveAliasLocale(translation.locale, config?.customMapping)
+				})),
+				sourceFile: {
+					...result.sourceFile,
+					sourceLocale: resolveAliasLocale(result.sourceFile.sourceLocale, config?.customMapping),
+					locales: result.sourceFile.locales.map((locale) => resolveAliasLocale(locale, config?.customMapping))
+				}
+			};
+		},
+		async downloadFileBatch(files, options = {}) {
+			const request = async (batch) => unwrapApiResult(await downloadFiles({
+				body: batch.map((file) => ({
+					...file,
+					locale: file.locale ? resolveServiceLocale(file.locale) : void 0
+				})),
+				client: getClient(options.timeout)
+			}));
+			const responses = await processBatches(files, async (batch) => [await request(batch)]);
+			return {
+				files: responses.flatMap((response) => response.files.map((file) => ({
+					...file,
+					...file.locale && { locale: resolveAliasLocale(file.locale, config?.customMapping) },
+					data: decodeFileContent(file.data, file.fileFormat),
+					metadata: file.metadata
+				}))),
+				count: responses.reduce((count, response) => count + response.count, 0),
+				pending: responses.flatMap((response) => (response.pending ?? []).map((file) => ({
+					...file,
+					locale: resolveAliasLocale(file.locale, config?.customMapping)
+				})))
+			};
+		},
+		async uploadSourceFiles(files, options) {
+			const sourceLocale = resolveServiceLocale(options.sourceLocale);
+			return { uploadedFiles: await processBatches(files, async (batch) => {
+				return unwrapApiResult(await uploadSourceFiles({
+					body: {
+						data: batch.map(({ source }) => ({ source: {
+							...source,
+							content: encodeFileContent(source.content, source.fileFormat),
+							locale: resolveServiceLocale(source.locale)
+						} })),
+						sourceLocale
+					},
+					client: getClient(options.timeout)
+				})).uploadedFiles.map(aliasUploadedFileLocale);
+			}) };
+		},
+		async uploadFonts(fonts, options = {}) {
+			const assets = await processBatches(fonts, async (batch) => {
+				return unwrapApiResult(await uploadAssets({
+					body: { assets: batch },
+					client: getClient(options.timeout)
+				})).assets;
+			}, { batchSize: 50 });
+			return {
+				assets,
+				count: assets.length
+			};
+		},
+		async uploadTranslations(files, options) {
+			validateFileFormatTransforms(files.map(({ source }) => source));
+			return { uploadedFiles: await processBatches(files, async (batch) => {
+				return unwrapApiResult(await uploadTranslations({
+					body: {
+						data: batch.map(({ source, translations }) => ({
+							source: {
+								...source,
+								content: encodeFileContent(source.content, source.fileFormat),
+								locale: resolveServiceLocale(source.locale)
+							},
+							translations: translations.map((translation) => ({
+								...translation,
+								locale: resolveServiceLocale(translation.locale),
+								content: encodeFileContent(translation.content, translation.fileFormat)
+							}))
+						})),
+						sourceLocale: resolveServiceLocale(options.sourceLocale)
+					},
+					client: getClient(options.timeout)
+				})).uploadedFiles.map(aliasUploadedFileLocale);
+			}) };
+		}
+	};
+}
+//#endregion
+//#region src/derive/utils/traverseIcu.ts
+/**
+* Given an ICU string, traverse the AST and call the visitor function for each element that matches the type T
+* @param icu - The ICU string to traverse
+* @param shouldVisit - A function that returns true if the element should be visited
+* @param visitor - A function that is called for each element that matches the type T
+* @returns The modified AST of the ICU string.
+*
+* @note This function is a heavy operation, use sparingly
+*/
+function traverseIcu({ icuString, shouldVisit, visitor, options: { recurseIntoVisited = true, ...otherOptions } }) {
+	const ast = parse(icuString, otherOptions);
+	handleChildren(ast);
+	return ast;
+	function handleChildren(children) {
+		children.map(handleChild);
+	}
+	function handleChild(child) {
+		let visited = false;
+		if (shouldVisit(child)) {
+			visitor(child);
+			visited = true;
+		}
+		if (!visited || recurseIntoVisited) {
+			if (child.type === TYPE.select || child.type === TYPE.plural) Object.values(child.options).map((option) => option.value).map(handleChildren);
+			else if (child.type === TYPE.tag) handleChildren(child.children);
+		}
+	}
+}
+//#endregion
+//#region src/derive/utils/constants.ts
+const VAR_IDENTIFIER = "_gt_";
+const VAR_NAME_IDENTIFIER = "_gt_var_name";
+//#endregion
+//#region src/derive/utils/regex.ts
+const GT_INDEXED_IDENTIFIER_REGEX = new RegExp(`^${VAR_IDENTIFIER}\\d+$`);
+const GT_UNINDEXED_IDENTIFIER_REGEX = new RegExp(`^${VAR_IDENTIFIER}$`);
+//#endregion
+//#region src/derive/utils/traverseHelpers.ts
+function isGTIndexedSelectElement(child) {
+	return child.type === TYPE.select && GT_INDEXED_IDENTIFIER_REGEX.test(child.value) && !!child.options.other && (child.options.other.value.length === 0 || child.options.other.value.length > 0 && child.options.other.value[0]?.type === TYPE.literal);
+}
+function isGTUnindexedSelectElement(child) {
+	return child.type === TYPE.select && GT_UNINDEXED_IDENTIFIER_REGEX.test(child.value) && !!child.options.other && (child.options.other.value.length === 0 || child.options.other.value.length > 0 && child.options.other.value[0]?.type === TYPE.literal);
+}
+//#endregion
+//#region src/derive/decodeVars.ts
+/**
+* Given an encoded ICU string, interpolate only _gt_ variables that have been marked with declareVar()
+* @example
+* const encodedIcu = "Hi" + declareVar("Brian") + ", my name is {name}"
+* // 'Hi {_gt_, select, other {Brian}}, my name is {name}'
+* decodeVars(encodedIcu)
+* // 'Hi Brian, my name is {name}'
+*/
+function decodeVars(icuString) {
+	if (!icuString.includes("_gt_")) return icuString;
+	const variableLocations = [];
+	function visitor(child) {
+		variableLocations.push({
+			start: child.location?.start.offset ?? 0,
+			end: child.location?.end.offset ?? 0,
+			value: child.options.other.value.length > 0 ? child.options.other.value[0].value : ""
+		});
+	}
+	traverseIcu({
+		icuString,
+		shouldVisit: isGTUnindexedSelectElement,
+		visitor,
+		options: {
+			recurseIntoVisited: false,
+			captureLocation: true
+		}
+	});
+	let previousIndex = 0;
+	const outputList = [];
+	for (let i = 0; i < variableLocations.length; i++) {
+		outputList.push(icuString.slice(previousIndex, variableLocations[i].start));
+		outputList.push(variableLocations[i].value);
+		previousIndex = variableLocations[i].end;
+	}
+	if (previousIndex < icuString.length) outputList.push(icuString.slice(previousIndex));
+	return outputList.join("");
+}
+//#endregion
+//#region src/derive/utils/sanitizeVar.ts
+/**
+* Sanitizes string by escaping ICU syntax
+*
+* Sanitize arbitrary string so it does not break the following ICU message syntax:
+* {_gt_, select, other {string_here}}
+*
+* Escapes ICU special characters by:
+* 1. Doubling all single quotes (U+0027 ')
+* 2. Adding a single quote before the first special character ({}<>)
+* 3. Adding a single quote after the last special character ({}<>)
+*/
+function sanitizeVar(string) {
+	let result = string.replace(/'/g, "''");
+	const specialChars = /[{}<>]/;
+	const firstSpecialIndex = result.search(specialChars);
+	if (firstSpecialIndex === -1) return result;
+	let lastSpecialIndex = -1;
+	for (let i = result.length - 1; i >= 0; i--) if (specialChars.test(result[i])) {
+		lastSpecialIndex = i;
+		break;
+	}
+	result = result.slice(0, firstSpecialIndex) + "'" + result.slice(firstSpecialIndex, lastSpecialIndex + 1) + "'" + result.slice(lastSpecialIndex + 1);
+	return result;
+}
+//#endregion
+//#region src/derive/declareVar.ts
+/**
+* Mark as a non-translatable string. Use within a derive() call to mark content as not derivable (e.g., not possible to statically analyze).
+*
+* @example
+* function nonDerivableFunction() {
+*   return Math.random();
+* }
+*
+* function derivableFunction() {
+*   if (condition) {
+*     return declareVar(nonDerivableFunction())
+*   }
+*   return 'John Doe';
+* }
+*
+* const gt = useGT();
+* gt(`My name is ${derive(derivableFunction())}`);
+*
+* @param {string | number | boolean | null | undefined} variable - The variable to sanitize.
+* @param {Object} [options] - The options for the sanitization.
+* @param {string} [options.$name] - The name of the variable.
+* @returns {string} The sanitized value.
+*/
+function declareVar(variable, options) {
+	const variableSection = ` other {${sanitizeVar(String(variable ?? ""))}}`;
+	let nameSection = "";
+	if (options?.$name) nameSection = ` ${VAR_NAME_IDENTIFIER} {${sanitizeVar(options.$name)}}`;
+	return `{${VAR_IDENTIFIER}, select,${variableSection}${nameSection}}`;
+}
+//#endregion
+//#region src/derive/derive.ts
+/**
+* Marks content as derivable by the GT compiler and CLI.
+*
+* Use `derive()` when a translation string or context needs content that is
+* computed from source code, but should still be discovered during extraction
+* instead of treated as a runtime interpolation variable. The CLI attempts to
+* resolve the derivable expression into every possible static value and
+* includes those values in the source content that gets translated.
+*
+* `derive()` returns its argument unchanged at runtime.
+*
+* Run `gt validate` after adding or changing `derive()` calls to verify that
+* each derivable expression can be resolved by the CLI before translating or
+* building.
+*
+* @example
+* ```jsx
+* function getSubject() {
+*   return (Math.random() > 0.5) ? "Alice" : "Brian";
+* }
+* ...
+* gt(`My name is ${derive(getSubject())}`);
+* ```
+*
+* @param {T extends string | boolean | number | null | undefined} content - Content to derive for translation extraction.
+* @returns {T} The same content, unchanged at runtime.
+*/
+function derive(content) {
+	return content;
+}
+//#endregion
+export { isGTUnindexedSelectElement as a, createGtApiAdapter as c, decodeFileContent as d, encode as f, isGTIndexedSelectElement as i, isSupportedFileFormatTransform as l, declareVar as n, VAR_IDENTIFIER as o, encodeFileContent as p, decodeVars as r, traverseIcu as s, derive as t, decode as u };
+
+//# sourceMappingURL=derive-BVRyqmWc.mjs.map