generaltranslation 8.2.6 → 8.2.8

package/dist/internal-DIHQF9gs.cjs

@@ -0,0 +1,1070 @@
+const require_sha2 = require("./sha2-DKowBr6H.cjs");
+require("./index.cjs");
+let _formatjs_icu_messageformat_parser = require("@formatjs/icu-messageformat-parser");
+let _formatjs_icu_messageformat_parser_types_js = require("@formatjs/icu-messageformat-parser/types.js");
+let _formatjs_icu_messageformat_parser_printer_js = require("@formatjs/icu-messageformat-parser/printer.js");
+//#region src/settings/settings.ts
+const libraryDefaultLocale = "en";
+const defaultTimeout = 6e4;
+//#endregion
+//#region src/errors/formattingErrors.ts
+const createInvalidCutoffStyleError = (style) => `generaltranslation Formatting Error: Invalid cutoff style: ${style}.`;
+const DEFAULT_TERMINATOR_KEY = "DEFAULT_TERMINATOR_KEY";
+const TERMINATOR_MAP = {
+	ellipsis: {
+		fr: {
+			terminator: "…",
+			separator: " "
+		},
+		zh: {
+			terminator: "……",
+			separator: void 0
+		},
+		ja: {
+			terminator: "……",
+			separator: void 0
+		},
+		[DEFAULT_TERMINATOR_KEY]: {
+			terminator: "…",
+			separator: void 0
+		}
+	},
+	none: { [DEFAULT_TERMINATOR_KEY]: {
+		terminator: void 0,
+		separator: void 0
+	} }
+};
+//#endregion
+//#region src/formatting/custom-formats/CutoffFormat/CutoffFormat.ts
+var CutoffFormatConstructor = class {
+	/**
+	* Constructor
+	* @param {string | string[]} locales - The locales to use for formatting.
+	* @param {CutoffFormatOptions} options - The options for formatting.
+	* @param {number} [option.maxChars] - The maximum number of characters to display.
+	* - Undefined values are treated as no cutoff.
+	* - Negative values follow .slice() behavior and terminator will be added before the value.
+	* - 0 will result in an empty string.
+	* - If cutoff results in an empty string, no terminator is added.
+	* @param {CutoffFormatStyle} [option.style='ellipsis'] - The style of the terminator.
+	* @param {string} [option.terminator] - Optional override the terminator to use.
+	* @param {string} [option.separator] - Optional override the separator to use between the terminator and the value.
+	* - If no terminator is provided, then separator is ignored.
+	*
+	* @example
+	* const format = new CutoffFormat('en', { maxChars: 5 });
+	* format.format('Hello, world!'); // 'Hello...'
+	*
+	* const format = new CutoffFormat('en', { maxChars: -3 });
+	* format.format('Hello, world!'); // '...ld!'
+	*/
+	constructor(locales, options = {}) {
+		try {
+			const localesList = !locales ? ["en"] : Array.isArray(locales) ? locales.map((l) => String(l)) : [String(locales)];
+			const canonicalLocales = Intl.getCanonicalLocales(localesList);
+			this.locale = canonicalLocales.length ? canonicalLocales[0] : "en";
+		} catch {
+			this.locale = "en";
+		}
+		if (!TERMINATOR_MAP[options.style ?? "ellipsis"]) throw new Error(createInvalidCutoffStyleError(options.style ?? "ellipsis"));
+		let style;
+		let presetTerminatorOptions;
+		if (options.maxChars !== void 0) {
+			style = options.style ?? "ellipsis";
+			const languageCode = new Intl.Locale(this.locale).language;
+			presetTerminatorOptions = TERMINATOR_MAP[style][languageCode] || TERMINATOR_MAP[style]["DEFAULT_TERMINATOR_KEY"];
+		}
+		let terminator = options.terminator ?? presetTerminatorOptions?.terminator;
+		let separator = terminator != null ? options.separator ?? presetTerminatorOptions?.separator : void 0;
+		this.additionLength = (terminator?.length ?? 0) + (separator?.length ?? 0);
+		if (options.maxChars !== void 0 && Math.abs(options.maxChars) < this.additionLength) {
+			terminator = void 0;
+			separator = void 0;
+		}
+		this.options = {
+			maxChars: options.maxChars,
+			style,
+			terminator,
+			separator
+		};
+	}
+	/**
+	* Format a value according to the cutoff options, returning a formatted string.
+	*
+	* @param {string} value - The string value to format with cutoff behavior.
+	* @returns {string} The formatted string with terminator applied if cutoff occurs.
+	*
+	* @example
+	* const formatter = new CutoffFormatConstructor('en', { maxChars: 8, style: 'ellipsis' });
+	* formatter.format('Hello, world!'); // Returns 'Hello, w...'
+	*/
+	format(value) {
+		return this.formatToParts(value).join("");
+	}
+	/**
+	* Format a value to parts according to the cutoff options, returning an array of string parts.
+	* This method breaks down the formatted result into individual components for more granular control.
+	*
+	* @param {string} value - The string value to format with cutoff behavior.
+	* @returns {PrependedCutoffParts | PostpendedCutoffParts} An array of string parts representing the formatted result.
+	*   - For positive maxChars: [cutoffValue, separator?, terminator?]
+	*   - For negative maxChars: [terminator?, separator?, cutoffValue]
+	*   - For no cutoff: [originalValue]
+	*
+	* @example
+	* const formatter = new CutoffFormatConstructor('en', { maxChars: 5, style: 'ellipsis' });
+	* formatter.formatToParts('Hello, world!'); // Returns ['Hello', '...']
+	*/
+	formatToParts(value) {
+		const { maxChars, terminator, separator } = this.options;
+		const adjustedChars = maxChars === void 0 || Math.abs(maxChars) >= value.length ? maxChars : maxChars >= 0 ? Math.max(0, maxChars - this.additionLength) : Math.min(0, maxChars + this.additionLength);
+		const slicedValue = adjustedChars !== void 0 && adjustedChars > -1 ? value.slice(0, adjustedChars) : value.slice(adjustedChars);
+		if (maxChars == null || adjustedChars == null || adjustedChars === 0 || terminator == null || value.length <= Math.abs(maxChars)) return [slicedValue];
+		if (adjustedChars > 0) return separator != null ? [
+			slicedValue,
+			separator,
+			terminator
+		] : [slicedValue, terminator];
+		else return separator != null ? [
+			terminator,
+			separator,
+			slicedValue
+		] : [terminator, slicedValue];
+	}
+	/**
+	* Get the resolved options
+	* @returns {ResolvedCutoffFormatOptions} The resolved options.
+	*/
+	resolvedOptions() {
+		return this.options;
+	}
+};
+//#endregion
+//#region src/cache/IntlCache.ts
+/**
+* Object mapping constructor names to their respective constructor functions
+* Includes all native Intl constructors plus custom ones like CutoffFormat
+*/
+const CustomIntl = {
+	Collator: Intl.Collator,
+	DateTimeFormat: Intl.DateTimeFormat,
+	DisplayNames: Intl.DisplayNames,
+	ListFormat: Intl.ListFormat,
+	Locale: Intl.Locale,
+	NumberFormat: Intl.NumberFormat,
+	PluralRules: Intl.PluralRules,
+	RelativeTimeFormat: Intl.RelativeTimeFormat,
+	Segmenter: Intl.Segmenter,
+	CutoffFormat: CutoffFormatConstructor
+};
+/**
+* Cache for Intl and custom format instances to avoid repeated instantiation
+* Uses a two-level structure: constructor name -> cache key -> instance
+*/
+var IntlCache = class {
+	constructor() {
+		this.cache = {};
+	}
+	/**
+	* Generates a consistent cache key from locales and options
+	* Handles all LocalesArgument types (string, Locale, array, undefined)
+	*/
+	_generateKey(locales, options = {}) {
+		return `${!locales ? "undefined" : Array.isArray(locales) ? locales.map((l) => String(l)).join(",") : String(locales)}:${options ? JSON.stringify(options, Object.keys(options).sort()) : "{}"}`;
+	}
+	/**
+	* Gets a cached Intl instance or creates a new one if not found
+	* @param constructor The name of the Intl constructor to use
+	* @param args Constructor arguments (locales, options)
+	* @returns Cached or newly created Intl instance
+	*/
+	get(constructor, ...args) {
+		const [locales = "en", options = {}] = args;
+		const key = this._generateKey(locales, options);
+		let intlObject = this.cache[constructor]?.[key];
+		if (intlObject === void 0) {
+			intlObject = new CustomIntl[constructor](...args);
+			if (!this.cache[constructor]) this.cache[constructor] = {};
+			this.cache[constructor][key] = intlObject;
+		}
+		return intlObject;
+	}
+};
+/**
+* Global instance of the Intl cache for use throughout the application
+*/
+const intlCache = new IntlCache();
+//#endregion
+//#region src/settings/settingsUrls.ts
+const defaultCacheUrl = "https://cdn.gtx.dev";
+const defaultBaseUrl = "https://api2.gtx.dev";
+const defaultRuntimeApiUrl = "https://runtime2.gtx.dev";
+//#endregion
+//#region src/settings/plurals.ts
+const pluralForms = [
+	"singular",
+	"plural",
+	"dual",
+	"zero",
+	"one",
+	"two",
+	"few",
+	"many",
+	"other"
+];
+function isAcceptedPluralForm(form) {
+	return pluralForms.includes(form);
+}
+//#endregion
+//#region src/locales/getPluralForm.ts
+/**
+* Given a number and a list of allowed plural forms, return the plural form that best fits the number.
+*
+* @param {number} n - The number to determine the plural form for.
+* @param {locales[]} forms - The allowed plural forms.
+* @returns {PluralType} The determined plural form, or an empty string if none fit.
+*/
+function _getPluralForm(n, forms = pluralForms, locales = ["en"]) {
+	const provisionalBranchName = intlCache.get("PluralRules", locales).select(n);
+	const absN = Math.abs(n);
+	if (absN === 0 && forms.includes("zero")) return "zero";
+	if (absN === 1) {
+		if (forms.includes("singular")) return "singular";
+		if (forms.includes("one")) return "one";
+	}
+	if (provisionalBranchName === "one" && forms.includes("singular")) return "singular";
+	if (absN === 2) {
+		if (forms.includes("dual")) return "dual";
+		if (forms.includes("two")) return "two";
+	}
+	if (provisionalBranchName === "two" && forms.includes("dual")) return "dual";
+	if (forms.includes(provisionalBranchName)) return provisionalBranchName;
+	if (provisionalBranchName === "two" && forms.includes("dual")) return "dual";
+	if (provisionalBranchName === "two" && forms.includes("plural")) return "plural";
+	if (provisionalBranchName === "two" && forms.includes("other")) return "other";
+	if (provisionalBranchName === "few" && forms.includes("plural")) return "plural";
+	if (provisionalBranchName === "few" && forms.includes("other")) return "other";
+	if (provisionalBranchName === "many" && forms.includes("plural")) return "plural";
+	if (provisionalBranchName === "many" && forms.includes("other")) return "other";
+	if (provisionalBranchName === "other" && forms.includes("plural")) return "plural";
+	return "";
+}
+//#endregion
+//#region src/utils/minify.ts
+const VARIABLE_TRANSFORMATION_SUFFIXES_TO_MINIFIED_NAMES = {
+	variable: "v",
+	number: "n",
+	datetime: "d",
+	currency: "c",
+	"relative-time": "rt"
+};
+function minifyVariableType(variableType) {
+	return VARIABLE_TRANSFORMATION_SUFFIXES_TO_MINIFIED_NAMES[variableType];
+}
+//#endregion
+//#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);
+}
+//#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"]
+};
+/**
+* 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/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 = (0, _formatjs_icu_messageformat_parser.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 === _formatjs_icu_messageformat_parser.TYPE.select || child.type === _formatjs_icu_messageformat_parser.TYPE.plural) Object.values(child.options).map((option) => option.value).map(handleChildren);
+			else if (child.type === _formatjs_icu_messageformat_parser.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 === _formatjs_icu_messageformat_parser_types_js.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 === _formatjs_icu_messageformat_parser_types_js.TYPE.literal);
+}
+function isGTUnindexedSelectElement(child) {
+	return child.type === _formatjs_icu_messageformat_parser_types_js.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 === _formatjs_icu_messageformat_parser_types_js.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
+/**
+* derive() is a powerful but dangerous function which marks its argument as derivable (statically analyzable) for the compiler and CLI tool.
+*
+* This function is dangerous because it can cause the compiler and CLI tool to throw an error if the argument is not derivable.
+*
+* @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 mark as derivable.
+* @returns content
+*/
+function derive(content) {
+	return content;
+}
+/**
+* @deprecated Use derive() instead.
+*
+* declareStatic() is a powerful but dangerous function which marks its argument as derivable (statically analyzable) for the compiler and CLI tool.
+*
+* This function is dangerous because it can cause the compiler and CLI tool to throw an error if the argument is not derivable.
+*
+* @example
+* ```jsx
+* function getSubject() {
+*   return (Math.random() > 0.5) ? "Alice" : "Brian";
+* }
+* ...
+* gt(`My name is ${declareStatic(getSubject())}`);
+* ```
+*
+* @param {T extends string | boolean | number | null | undefined} content - Content to mark as derivable.
+* @returns content
+*/
+const declareStatic = derive;
+//#endregion
+//#region src/derive/indexVars.ts
+/**
+* Given an ICU string adds identifiers to each _gt_ placeholder
+* indexVars('Hello {_gt_} {_gt_} World') => 'Hello {_gt_1_} {_gt_2_} World'
+*/
+function indexVars(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,
+			otherStart: child.options.other.location?.start.offset ?? 0,
+			otherEnd: child.options.other.location?.end.offset ?? 0
+		});
+	}
+	traverseIcu({
+		icuString,
+		shouldVisit: isGTUnindexedSelectElement,
+		visitor,
+		options: {
+			recurseIntoVisited: false,
+			captureLocation: true
+		}
+	});
+	const result = [];
+	let current = 0;
+	for (let i = 0; i < variableLocations.length; i++) {
+		const { start, end, otherStart, otherEnd } = variableLocations[i];
+		result.push(icuString.slice(current, start));
+		result.push(icuString.slice(start, start + 4 + 1));
+		result.push(String(i + 1));
+		result.push(icuString.slice(start + 4 + 1, otherStart));
+		result.push("{}");
+		result.push(icuString.slice(otherEnd, end));
+		current = end;
+	}
+	result.push(icuString.slice(current, icuString.length));
+	return result.join("");
+}
+//#endregion
+//#region src/derive/extractVars.ts
+/**
+* Given an unindexed ICU string, extracts all the _gt_ variables and an indexed mapping of the variable to the values
+*
+* extractVars('Hello {_gt_, select, other {World}}') => { _gt_1: 'World' }
+*
+* @param {string} icuString - The ICU string to extract variables from.
+* @returns {Record<string, string>} A mapping of the variable to the value.
+*/
+function extractVars(icuString) {
+	if (!icuString.includes("_gt_")) return {};
+	let index = 1;
+	const variables = {};
+	function visitor(child) {
+		variables[child.value + index] = child.options.other.value.length ? child.options.other.value[0]?.value : "";
+		index += 1;
+	}
+	traverseIcu({
+		icuString,
+		shouldVisit: isGTUnindexedSelectElement,
+		visitor,
+		options: { recurseIntoVisited: false }
+	});
+	return variables;
+}
+//#endregion
+//#region src/derive/condenseVars.ts
+/**
+* Given an indexed ICU string, condenses any select to an argument
+* indexVars('Hello {_gt_1, select, other {World}}') => 'Hello {_gt_1}'
+* @param {string} icuString - The ICU string to condense.
+* @returns {string} The condensed ICU string.
+*/
+function condenseVars(icuString) {
+	if (!icuString.includes("_gt_")) return icuString;
+	function visitor(child) {
+		child.type = _formatjs_icu_messageformat_parser_types_js.TYPE.argument;
+		delete child.options;
+	}
+	return (0, _formatjs_icu_messageformat_parser_printer_js.printAST)(traverseIcu({
+		icuString,
+		shouldVisit: isGTIndexedSelectElement,
+		visitor,
+		options: { recurseIntoVisited: false }
+	}));
+}
+//#endregion
+//#region src/backwards-compatability/typeChecking.ts
+/**
+* Checks if a JSX child is an old variable object format
+* @param child - The JSX child to check
+* @returns True if the child is an old variable object (has 'key' property)
+*/
+function isOldVariableObject(child) {
+	return typeof child === "object" && child != null && "key" in child;
+}
+/**
+* Checks if a JSX child is a new variable object format
+* @param child - The JSX child to check
+* @returns True if the child is a new variable object (has 'k' property)
+*/
+function isNewVariableObject(child) {
+	return typeof child === "object" && child != null && "k" in child;
+}
+/**
+* Checks if a JSX child is an old JSX element format
+* @param child - The JSX child to check
+* @returns True if the child is an old JSX element (has 'type' and 'props' properties)
+*/
+function isOldJsxElement(child) {
+	return typeof child === "object" && child != null && "type" in child && "props" in child;
+}
+/**
+* Checks if a JSX child follows the old format (string, old variable object, or old JSX element)
+* @param child - The JSX child to check
+* @returns True if the child is in the old format
+*/
+function isOldJsxChild(child) {
+	if (typeof child === "string") return true;
+	if (isOldVariableObject(child)) return true;
+	return isOldJsxElement(child);
+}
+/**
+* Checks if JSX children follow the old format
+* @param children - The JSX children to check (can be string, array, or single child)
+* @returns True if all children are in the old format
+*/
+function isOldJsxChildren(children) {
+	if (typeof children === "string") return true;
+	if (Array.isArray(children)) return !children.some((child) => !isOldJsxChild(child));
+	return isOldJsxChild(children);
+}
+//#endregion
+//#region src/backwards-compatability/dataConversion.ts
+/**
+* Convert request data from old format to new format
+*/
+function getNewJsxChild(child) {
+	if (typeof child === "string") return child;
+	if (isOldVariableObject(child)) return getNewVariableObject(child);
+	return getNewJsxElement(child);
+}
+function getNewJsxChildren(children) {
+	if (typeof children === "string") return children;
+	if (Array.isArray(children)) return children.map(getNewJsxChild);
+	return getNewJsxChild(children);
+}
+function getNewJsxElement(element) {
+	if (typeof element === "string") return element;
+	let t = void 0;
+	if (element.type != null) t = element.type;
+	let c = void 0;
+	if (element.props?.children != null) c = getNewJsxChildren(element.props.children);
+	return {
+		...t && { t },
+		...c && { c },
+		d: getNewGTProp(element.props["data-_gt"]),
+		i: element.props["data-_gt"].id
+	};
+}
+function getNewBranchType(branch) {
+	if (branch === "branch") return "b";
+	return "p";
+}
+function getNewVariableType(variable) {
+	switch (variable) {
+		case "number": return "n";
+		case "variable": return "v";
+		case "datetime": return "d";
+		case "currency": return "c";
+		default: return "v";
+	}
+}
+function getNewVariableObject(variable) {
+	let v = void 0;
+	if (variable.variable != null) v = getNewVariableType(variable.variable);
+	let i = void 0;
+	if (variable.id != null) i = variable.id;
+	return {
+		k: variable.key,
+		...v && { v },
+		...i && { i }
+	};
+}
+function getNewGTProp(dataGT) {
+	let b = void 0;
+	if (dataGT.branches) b = Object.fromEntries(Object.entries(dataGT.branches).map(([key, value]) => [key, getNewJsxChildren(value)]));
+	let t;
+	if (dataGT.transformation) t = getNewBranchType(dataGT.transformation);
+	return {
+		...b && { b },
+		...t && { t }
+	};
+}
+/**
+* Convert response data from old format to new format
+*/
+function getOldJsxChild(child) {
+	if (typeof child === "string") return child;
+	if (isNewVariableObject(child)) return getOldVariableObject(child);
+	return getOldJsxElement(child);
+}
+function getOldJsxChildren(children) {
+	if (isOldJsxChildren(children)) return children;
+	if (typeof children === "string") return children;
+	if (Array.isArray(children)) return children.map(getOldJsxChild);
+	return getOldJsxChild(children);
+}
+function getOldJsxElement(element) {
+	const type = element.t;
+	let children = void 0;
+	if (element.c != null) children = getOldJsxChildren(element.c);
+	const dataGT = getOldGTProp(element.d || {}, element.i);
+	return {
+		type,
+		props: {
+			children,
+			"data-_gt": dataGT
+		}
+	};
+}
+function getOldBranchType(branch) {
+	if (branch === "b") return "branch";
+	return "plural";
+}
+function getOldVariableType(variable) {
+	switch (variable) {
+		case "n": return "number";
+		case "v": return "variable";
+		case "d": return "datetime";
+		case "c": return "currency";
+		default: return "variable";
+	}
+}
+function getOldVariableObject(variable) {
+	let v = void 0;
+	if (variable.v != null) v = getOldVariableType(variable.v);
+	let i = void 0;
+	if (variable.i != null) i = variable.i;
+	return {
+		key: variable.k,
+		...v && { variable: v },
+		...i && { id: i }
+	};
+}
+function getOldGTProp(dataGT, i) {
+	let transformation = void 0;
+	if (dataGT.t != null) transformation = getOldBranchType(dataGT.t);
+	let branches = void 0;
+	if (dataGT.b != null) branches = Object.fromEntries(Object.entries(dataGT.b).map(([key, value]) => [key, getOldJsxChildren(value)]));
+	return {
+		id: i,
+		...transformation && { transformation },
+		...branches && { branches }
+	};
+}
+//#endregion
+//#region src/backwards-compatability/oldHashJsxChildren.ts
+/**
+* Calculates a unique hash for a given string using sha256.
+*
+* @param {string} string - The string to be hashed.
+* @returns {string} - The resulting hash as a hexadecimal string.
+*/
+function oldHashString(string) {
+	return require_sha2.bytesToHex(require_sha2.sha256(require_sha2.utf8ToBytes(string)));
+}
+/**
+* Calculates a unique ID for the given children objects by hashing their sanitized JSON string representation.
+*
+* @param {any} childrenAsObjects - The children objects to be hashed.
+* @param {string} context - The context for the children
+* @param {string} id - The id for the JSX Children object
+* @param {function} hashFunction custom hash function
+* @returns {string} - The unique has of the children.
+*/
+function oldHashJsxChildren({ source, context, id, dataFormat }, hashFunction = oldHashString) {
+	return hashFunction(require_sha2.stableStringify({
+		source: sanitizeJsxChildren(source),
+		...id && { id },
+		...context && { context },
+		...dataFormat && { dataFormat }
+	}));
+}
+const sanitizeChild = (child) => {
+	if (child && typeof child === "object") {
+		if ("props" in child) {
+			const newChild = {};
+			const dataGt = child?.props?.["data-_gt"];
+			if (dataGt?.branches) newChild.branches = Object.fromEntries(Object.entries(dataGt.branches).map(([key, value]) => [key, sanitizeJsxChildren(value)]));
+			if (child?.props?.children) newChild.children = sanitizeJsxChildren(child.props.children);
+			if (child?.props?.["data-_gt"]?.transformation) newChild.transformation = child.props["data-_gt"].transformation;
+			return newChild;
+		}
+		if ("key" in child) return {
+			key: child.key,
+			...child.variable && { variable: child.variable }
+		};
+	}
+	return child;
+};
+function sanitizeJsxChildren(childrenAsObjects) {
+	return Array.isArray(childrenAsObjects) ? childrenAsObjects.map(sanitizeChild) : sanitizeChild(childrenAsObjects);
+}
+//#endregion
+Object.defineProperty(exports, "VAR_IDENTIFIER", {
+	enumerable: true,
+	get: function() {
+		return VAR_IDENTIFIER;
+	}
+});
+Object.defineProperty(exports, "VAR_NAME_IDENTIFIER", {
+	enumerable: true,
+	get: function() {
+		return VAR_NAME_IDENTIFIER;
+	}
+});
+Object.defineProperty(exports, "_getPluralForm", {
+	enumerable: true,
+	get: function() {
+		return _getPluralForm;
+	}
+});
+Object.defineProperty(exports, "condenseVars", {
+	enumerable: true,
+	get: function() {
+		return condenseVars;
+	}
+});
+Object.defineProperty(exports, "declareStatic", {
+	enumerable: true,
+	get: function() {
+		return declareStatic;
+	}
+});
+Object.defineProperty(exports, "declareVar", {
+	enumerable: true,
+	get: function() {
+		return declareVar;
+	}
+});
+Object.defineProperty(exports, "decode", {
+	enumerable: true,
+	get: function() {
+		return decode;
+	}
+});
+Object.defineProperty(exports, "decodeVars", {
+	enumerable: true,
+	get: function() {
+		return decodeVars;
+	}
+});
+Object.defineProperty(exports, "defaultBaseUrl", {
+	enumerable: true,
+	get: function() {
+		return defaultBaseUrl;
+	}
+});
+Object.defineProperty(exports, "defaultCacheUrl", {
+	enumerable: true,
+	get: function() {
+		return defaultCacheUrl;
+	}
+});
+Object.defineProperty(exports, "defaultRuntimeApiUrl", {
+	enumerable: true,
+	get: function() {
+		return defaultRuntimeApiUrl;
+	}
+});
+Object.defineProperty(exports, "defaultTimeout", {
+	enumerable: true,
+	get: function() {
+		return defaultTimeout;
+	}
+});
+Object.defineProperty(exports, "derive", {
+	enumerable: true,
+	get: function() {
+		return derive;
+	}
+});
+Object.defineProperty(exports, "encode", {
+	enumerable: true,
+	get: function() {
+		return encode;
+	}
+});
+Object.defineProperty(exports, "extractVars", {
+	enumerable: true,
+	get: function() {
+		return extractVars;
+	}
+});
+Object.defineProperty(exports, "getNewBranchType", {
+	enumerable: true,
+	get: function() {
+		return getNewBranchType;
+	}
+});
+Object.defineProperty(exports, "getNewGTProp", {
+	enumerable: true,
+	get: function() {
+		return getNewGTProp;
+	}
+});
+Object.defineProperty(exports, "getNewJsxChild", {
+	enumerable: true,
+	get: function() {
+		return getNewJsxChild;
+	}
+});
+Object.defineProperty(exports, "getNewJsxChildren", {
+	enumerable: true,
+	get: function() {
+		return getNewJsxChildren;
+	}
+});
+Object.defineProperty(exports, "getNewJsxElement", {
+	enumerable: true,
+	get: function() {
+		return getNewJsxElement;
+	}
+});
+Object.defineProperty(exports, "getNewVariableObject", {
+	enumerable: true,
+	get: function() {
+		return getNewVariableObject;
+	}
+});
+Object.defineProperty(exports, "getNewVariableType", {
+	enumerable: true,
+	get: function() {
+		return getNewVariableType;
+	}
+});
+Object.defineProperty(exports, "getOldBranchType", {
+	enumerable: true,
+	get: function() {
+		return getOldBranchType;
+	}
+});
+Object.defineProperty(exports, "getOldGTProp", {
+	enumerable: true,
+	get: function() {
+		return getOldGTProp;
+	}
+});
+Object.defineProperty(exports, "getOldJsxChild", {
+	enumerable: true,
+	get: function() {
+		return getOldJsxChild;
+	}
+});
+Object.defineProperty(exports, "getOldJsxChildren", {
+	enumerable: true,
+	get: function() {
+		return getOldJsxChildren;
+	}
+});
+Object.defineProperty(exports, "getOldJsxElement", {
+	enumerable: true,
+	get: function() {
+		return getOldJsxElement;
+	}
+});
+Object.defineProperty(exports, "getOldVariableObject", {
+	enumerable: true,
+	get: function() {
+		return getOldVariableObject;
+	}
+});
+Object.defineProperty(exports, "getOldVariableType", {
+	enumerable: true,
+	get: function() {
+		return getOldVariableType;
+	}
+});
+Object.defineProperty(exports, "indexVars", {
+	enumerable: true,
+	get: function() {
+		return indexVars;
+	}
+});
+Object.defineProperty(exports, "intlCache", {
+	enumerable: true,
+	get: function() {
+		return intlCache;
+	}
+});
+Object.defineProperty(exports, "isAcceptedPluralForm", {
+	enumerable: true,
+	get: function() {
+		return isAcceptedPluralForm;
+	}
+});
+Object.defineProperty(exports, "isNewVariableObject", {
+	enumerable: true,
+	get: function() {
+		return isNewVariableObject;
+	}
+});
+Object.defineProperty(exports, "isOldJsxChildren", {
+	enumerable: true,
+	get: function() {
+		return isOldJsxChildren;
+	}
+});
+Object.defineProperty(exports, "isOldVariableObject", {
+	enumerable: true,
+	get: function() {
+		return isOldVariableObject;
+	}
+});
+Object.defineProperty(exports, "isSupportedFileFormatTransform", {
+	enumerable: true,
+	get: function() {
+		return isSupportedFileFormatTransform;
+	}
+});
+Object.defineProperty(exports, "libraryDefaultLocale", {
+	enumerable: true,
+	get: function() {
+		return libraryDefaultLocale;
+	}
+});
+Object.defineProperty(exports, "minifyVariableType", {
+	enumerable: true,
+	get: function() {
+		return minifyVariableType;
+	}
+});
+Object.defineProperty(exports, "oldHashJsxChildren", {
+	enumerable: true,
+	get: function() {
+		return oldHashJsxChildren;
+	}
+});
+Object.defineProperty(exports, "oldHashString", {
+	enumerable: true,
+	get: function() {
+		return oldHashString;
+	}
+});
+Object.defineProperty(exports, "pluralForms", {
+	enumerable: true,
+	get: function() {
+		return pluralForms;
+	}
+});
+Object.defineProperty(exports, "validateFileFormatTransforms", {
+	enumerable: true,
+	get: function() {
+		return validateFileFormatTransforms;
+	}
+});
+
+//# sourceMappingURL=internal-DIHQF9gs.cjs.map