generaltranslation 8.2.6 → 8.2.7

package/dist/internal-CTeI8uLd.mjs

@@ -0,0 +1,774 @@
+import { t as stableStringify } from "./stableStringify-DgDlE_pD.mjs";
+import { TYPE, parse } from "@formatjs/icu-messageformat-parser";
+import { TYPE as TYPE$1 } from "@formatjs/icu-messageformat-parser/types.js";
+import { printAST } from "@formatjs/icu-messageformat-parser/printer.js";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { bytesToHex, utf8ToBytes } from "@noble/hashes/utils.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/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$1.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$1.literal);
+}
+function isGTUnindexedSelectElement(child) {
+	return child.type === TYPE$1.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$1.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 = TYPE$1.argument;
+		delete child.options;
+	}
+	return 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 bytesToHex(sha256(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(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
+export { encode as A, libraryDefaultLocale as B, declareStatic as C, VAR_IDENTIFIER as D, decodeVars as E, defaultBaseUrl as F, defaultCacheUrl as I, defaultRuntimeApiUrl as L, _getPluralForm as M, isAcceptedPluralForm as N, VAR_NAME_IDENTIFIER as O, pluralForms as P, intlCache as R, indexVars as S, declareVar as T, isNewVariableObject as _, getNewJsxChild as a, condenseVars as b, getNewVariableObject as c, getOldGTProp as d, getOldJsxChild as f, getOldVariableType as g, getOldVariableObject as h, getNewGTProp as i, minifyVariableType as j, decode as k, getNewVariableType as l, getOldJsxElement as m, oldHashString as n, getNewJsxChildren as o, getOldJsxChildren as p, getNewBranchType as r, getNewJsxElement as s, oldHashJsxChildren as t, getOldBranchType as u, isOldJsxChildren as v, derive as w, extractVars as x, isOldVariableObject as y, defaultTimeout as z };
+
+//# sourceMappingURL=internal-CTeI8uLd.mjs.map