generaltranslation 8.2.8 → 8.2.9

package/dist/internal.cjs

@@ -1,45 +1,603 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_internal = require("./internal-DIHQF9gs.cjs");
-const require_sha2 = require("./sha2-DKowBr6H.cjs");
-exports.VAR_IDENTIFIER = require_internal.VAR_IDENTIFIER;
-exports.VAR_NAME_IDENTIFIER = require_internal.VAR_NAME_IDENTIFIER;
-exports.condenseVars = require_internal.condenseVars;
-exports.declareStatic = require_internal.declareStatic;
-exports.declareVar = require_internal.declareVar;
-exports.decode = require_internal.decode;
-exports.decodeVars = require_internal.decodeVars;
-exports.defaultBaseUrl = require_internal.defaultBaseUrl;
-exports.defaultCacheUrl = require_internal.defaultCacheUrl;
-exports.defaultRuntimeApiUrl = require_internal.defaultRuntimeApiUrl;
-exports.defaultTimeout = require_internal.defaultTimeout;
-exports.derive = require_internal.derive;
-exports.encode = require_internal.encode;
-exports.extractVars = require_internal.extractVars;
-exports.getNewBranchType = require_internal.getNewBranchType;
-exports.getNewGTProp = require_internal.getNewGTProp;
-exports.getNewJsxChild = require_internal.getNewJsxChild;
-exports.getNewJsxChildren = require_internal.getNewJsxChildren;
-exports.getNewJsxElement = require_internal.getNewJsxElement;
-exports.getNewVariableObject = require_internal.getNewVariableObject;
-exports.getNewVariableType = require_internal.getNewVariableType;
-exports.getOldBranchType = require_internal.getOldBranchType;
-exports.getOldGTProp = require_internal.getOldGTProp;
-exports.getOldJsxChild = require_internal.getOldJsxChild;
-exports.getOldJsxChildren = require_internal.getOldJsxChildren;
-exports.getOldJsxElement = require_internal.getOldJsxElement;
-exports.getOldVariableObject = require_internal.getOldVariableObject;
-exports.getOldVariableType = require_internal.getOldVariableType;
-exports.getPluralForm = require_internal._getPluralForm;
-exports.indexVars = require_internal.indexVars;
-exports.isAcceptedPluralForm = require_internal.isAcceptedPluralForm;
-exports.isNewVariableObject = require_internal.isNewVariableObject;
-exports.isOldJsxChildren = require_internal.isOldJsxChildren;
-exports.isOldVariableObject = require_internal.isOldVariableObject;
-exports.isSupportedFileFormatTransform = require_internal.isSupportedFileFormatTransform;
-exports.isVariable = require_sha2.isVariable;
-exports.libraryDefaultLocale = require_internal.libraryDefaultLocale;
-exports.minifyVariableType = require_internal.minifyVariableType;
-exports.oldHashJsxChildren = require_internal.oldHashJsxChildren;
-exports.oldHashString = require_internal.oldHashString;
-exports.pluralForms = require_internal.pluralForms;
-exports.validateFileFormatTransforms = require_internal.validateFileFormatTransforms;
+const require_IntlCache = require("./IntlCache-k2qfrDqB.cjs");
+const require_base64 = require("./base64-CUcEPEC5.cjs");
+const require_isVariable = require("./isVariable-B08mggBy.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/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 = require_IntlCache.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/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_isVariable.bytesToHex(require_isVariable.sha256(require_isVariable.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_isVariable.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
+exports.VAR_IDENTIFIER = VAR_IDENTIFIER;
+exports.VAR_NAME_IDENTIFIER = VAR_NAME_IDENTIFIER;
+exports.condenseVars = condenseVars;
+exports.declareStatic = declareStatic;
+exports.declareVar = declareVar;
+exports.decode = require_base64.decode;
+exports.decodeVars = decodeVars;
+exports.defaultBaseUrl = require_base64.defaultBaseUrl;
+exports.defaultCacheUrl = require_base64.defaultCacheUrl;
+exports.defaultRuntimeApiUrl = require_base64.defaultRuntimeApiUrl;
+exports.defaultTimeout = require_IntlCache.defaultTimeout;
+exports.derive = derive;
+exports.encode = require_base64.encode;
+exports.extractVars = extractVars;
+exports.getNewBranchType = getNewBranchType;
+exports.getNewGTProp = getNewGTProp;
+exports.getNewJsxChild = getNewJsxChild;
+exports.getNewJsxChildren = getNewJsxChildren;
+exports.getNewJsxElement = getNewJsxElement;
+exports.getNewVariableObject = getNewVariableObject;
+exports.getNewVariableType = getNewVariableType;
+exports.getOldBranchType = getOldBranchType;
+exports.getOldGTProp = getOldGTProp;
+exports.getOldJsxChild = getOldJsxChild;
+exports.getOldJsxChildren = getOldJsxChildren;
+exports.getOldJsxElement = getOldJsxElement;
+exports.getOldVariableObject = getOldVariableObject;
+exports.getOldVariableType = getOldVariableType;
+exports.getPluralForm = _getPluralForm;
+exports.indexVars = indexVars;
+exports.isAcceptedPluralForm = isAcceptedPluralForm;
+exports.isNewVariableObject = isNewVariableObject;
+exports.isOldJsxChildren = isOldJsxChildren;
+exports.isOldVariableObject = isOldVariableObject;
+exports.isSupportedFileFormatTransform = require_base64.isSupportedFileFormatTransform;
+exports.isVariable = require_isVariable.isVariable;
+exports.libraryDefaultLocale = require_IntlCache.libraryDefaultLocale;
+exports.minifyVariableType = minifyVariableType;
+exports.oldHashJsxChildren = oldHashJsxChildren;
+exports.oldHashString = oldHashString;
+exports.pluralForms = pluralForms;
+exports.validateFileFormatTransforms = require_base64.validateFileFormatTransforms;
+
+//# sourceMappingURL=internal.cjs.map