generaltranslation 8.2.11 → 8.2.13

package/dist/core.js

@@ -0,0 +1,137 @@
+import { _formatCutoff, _formatMessageICU, _formatMessageString, } from './formatting/format';
+import { _isValidLocale, _standardizeLocale } from './locales/isValidLocale';
+import { _resolveCanonicalLocale } from './locales/resolveCanonicalLocale';
+export { LocaleConfig, } from './LocaleConfig';
+/**
+ * Core formatting and locale helpers.
+ *
+ * This entry point exposes deterministic locale and formatting primitives. It
+ * does not export the GT service client, project credentials, network
+ * translation methods, file APIs, or other server/service concerns from the
+ * root `generaltranslation` facade.
+ *
+ * This entry point is intended for framework and shared packages that need
+ * locale metadata or formatting behavior without pulling in the full
+ * translation API surface.
+ */
+/**
+ * Formats a string with cutoff behavior, applying a terminator when the string exceeds the maximum character limit.
+ *
+ * This standalone function provides cutoff formatting functionality without requiring a GT instance.
+ * The locales parameter is required for proper terminator selection based on the target language.
+ *
+ * @param {string} value - The string value to format with cutoff behavior.
+ * @param {Object} [options] - Configuration options for cutoff formatting.
+ * @param {string | string[]} [options.locales] - The locales to use for terminator selection.
+ * @param {number} [options.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} [options.style='ellipsis'] - The style of the terminator.
+ * @param {string} [options.terminator] - Optional override the terminator to use.
+ * @param {string} [options.separator] - Optional override the separator to use between the terminator and the value.
+ * - If no terminator is provided, then separator is ignored.
+ * @returns {string} The formatted string with terminator applied if cutoff occurs.
+ *
+ * @example
+ * formatCutoff('Hello, world!', { locales: 'en-US', maxChars: 8 });
+ * // Returns: 'Hello, …'
+ *
+ * @example
+ * formatCutoff('Hello, world!', { locales: 'en-US', maxChars: -3 });
+ * // Returns: '…d!'
+ *
+ * @example
+ * formatCutoff('Very long text that needs cutting', {
+ *   locales: 'en-US',
+ *   maxChars: 15,
+ *   style: 'ellipsis',
+ *   separator: ' '
+ * });
+ * // Returns: 'Very long tex …'
+ */
+export function formatCutoff(value, options) {
+    return _formatCutoff({ value: value, locales: options === null || options === void 0 ? void 0 : options.locales, options: options });
+}
+/**
+ * Formats a message according to the specified locales and options.
+ *
+ * @param {string} message - The message to format.
+ * @param {Object} [options] - Configuration options for message formatting.
+ * @param {string | string[]} [options.locales] - The locales to use for formatting.
+ * @param {FormatVariables} [options.variables] - The variables to use for formatting.
+ * @param {StringFormat} [options.dataFormat='ICU'] - The format of the message. When STRING, the message is returned as is.
+ * @returns {string} The formatted message.
+ *
+ * @example
+ * formatMessage('Hello {name}', { variables: { name: 'John' } });
+ * // Returns: "Hello John"
+ *
+ * @example
+ * formatMessage('Hello {name}', {
+ *   locales: ['fr'],
+ *   variables: { name: 'John' }
+ * });
+ */
+export function formatMessage(message, options) {
+    switch (options === null || options === void 0 ? void 0 : options.dataFormat) {
+        case 'STRING':
+            return _formatMessageString(message);
+        default:
+            return _formatMessageICU(message, options === null || options === void 0 ? void 0 : options.locales, options === null || options === void 0 ? void 0 : options.variables);
+    }
+}
+/**
+ * Checks if a given BCP 47 locale code is valid.
+ *
+ * @param {string} locale - The BCP 47 locale code to validate.
+ * @param {CustomMapping} [customMapping] - The custom mapping to use for validation.
+ * @returns {boolean} True if the BCP 47 code is valid, false otherwise.
+ *
+ * @example
+ * isValidLocale('en-US');
+ * // Returns: true
+ *
+ * @example
+ * isValidLocale('en_US');
+ * // Returns: false
+ */
+export function isValidLocale(locale, customMapping) {
+    return _isValidLocale(locale, customMapping);
+}
+/**
+ * Resolves the canonical locale for a given locale.
+ *
+ * @param {string} locale - The locale to resolve the canonical locale for.
+ * @param {CustomMapping} [customMapping] - The custom mapping to use for resolving the canonical locale.
+ * @returns {string} The canonical locale, or the input locale when no canonical mapping exists.
+ *
+ * @example
+ * resolveCanonicalLocale('en-US');
+ * // Returns: 'en-US'
+ *
+ * @example
+ * resolveCanonicalLocale('en', { en: 'en-US' });
+ * // Returns: 'en-US'
+ */
+export function resolveCanonicalLocale(locale, customMapping) {
+    return _resolveCanonicalLocale(locale, customMapping);
+}
+/**
+ * Standardizes a BCP 47 locale code to ensure correct formatting.
+ *
+ * @param {string} locale - The BCP 47 locale code to standardize.
+ * @returns {string} The standardized BCP 47 locale code, or the input string if it cannot be standardized.
+ *
+ * @example
+ * standardizeLocale('en-us');
+ * // Returns: 'en-US'
+ *
+ * @example
+ * standardizeLocale('not a locale');
+ * // Returns: 'not a locale'
+ */
+export function standardizeLocale(locale) {
+    return _standardizeLocale(locale);
+}

package/dist/core.mjs

@@ -1,2 +1,2 @@
-import { a as standardizeLocale, i as resolveCanonicalLocale, n as formatMessage, o as LocaleConfig, r as isValidLocale, t as formatCutoff } from "./core-Bx0m6GOp.mjs";
+import { a as standardizeLocale, i as resolveCanonicalLocale, n as formatMessage, o as LocaleConfig, r as isValidLocale, t as formatCutoff } from "./core-isLphYAZ.mjs";
 export { LocaleConfig, formatCutoff, formatMessage, isValidLocale, resolveCanonicalLocale, standardizeLocale };

package/dist/derive/condenseVars.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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.
+ */
+export declare function condenseVars(icuString: string): string;

package/dist/derive/condenseVars.js

@@ -0,0 +1,30 @@
+import { TYPE, } from '@formatjs/icu-messageformat-parser/types.js';
+import { printAST } from '@formatjs/icu-messageformat-parser/printer.js';
+import { traverseIcu } from './utils/traverseIcu';
+import { VAR_IDENTIFIER } from './utils/constants';
+import { isGTIndexedSelectElement } from './utils/traverseHelpers';
+/**
+ * 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.
+ */
+export function condenseVars(icuString) {
+    // Check if the string contains _gt_
+    if (!icuString.includes(VAR_IDENTIFIER)) {
+        return icuString;
+    }
+    // Replace with argument
+    function visitor(child) {
+        child.type = TYPE.argument;
+        Reflect.deleteProperty(child, 'options');
+    }
+    var ast = traverseIcu({
+        icuString: icuString,
+        shouldVisit: isGTIndexedSelectElement,
+        visitor: visitor,
+        options: { recurseIntoVisited: false },
+    });
+    // Serialize
+    return printAST(ast);
+}

package/dist/derive/declareVar.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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.
+ */
+export declare function declareVar(variable: string | number | boolean | null | undefined, options?: {
+    $name?: string;
+}): string;

package/dist/derive/declareVar.js

@@ -0,0 +1,38 @@
+import { VAR_IDENTIFIER, VAR_NAME_IDENTIFIER } from './utils/constants';
+import { sanitizeVar } from './utils/sanitizeVar';
+/**
+ * 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.
+ */
+export function declareVar(variable, options) {
+    // Variable section.
+    var sanitizedVariable = sanitizeVar(String(variable !== null && variable !== void 0 ? variable : ''));
+    var variableSection = " other {".concat(sanitizedVariable, "}");
+    // Name section.
+    var nameSection = '';
+    if (options === null || options === void 0 ? void 0 : options.$name) {
+        var sanitizedName = sanitizeVar(options.$name);
+        nameSection = " ".concat(VAR_NAME_IDENTIFIER, " {").concat(sanitizedName, "}");
+    }
+    // interpolate
+    return "{".concat(VAR_IDENTIFIER, ", select,").concat(variableSection).concat(nameSection, "}");
+}

package/dist/derive/decodeVars.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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}'
+ */
+export declare function decodeVars(icuString: string): string;

package/dist/derive/decodeVars.js

@@ -0,0 +1,52 @@
+import { traverseIcu } from './utils/traverseIcu';
+import { VAR_IDENTIFIER } from './utils/constants';
+import { isGTUnindexedSelectElement } from './utils/traverseHelpers';
+/**
+ * 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}'
+ */
+export function decodeVars(icuString) {
+    // Check if the string contains _gt_
+    if (!icuString.includes(VAR_IDENTIFIER)) {
+        return icuString;
+    }
+    // Record the location of the variable
+    var variableLocations = [];
+    function visitor(child) {
+        var _a, _b, _c, _d;
+        variableLocations.push({
+            start: (_b = (_a = child.location) === null || _a === void 0 ? void 0 : _a.start.offset) !== null && _b !== void 0 ? _b : 0,
+            end: (_d = (_c = child.location) === null || _c === void 0 ? void 0 : _c.end.offset) !== null && _d !== void 0 ? _d : 0,
+            value: child.options.other.value.length > 0
+                ? child.options.other.value[0].value
+                : '',
+        });
+    }
+    // Find all variable identifiers.
+    traverseIcu({
+        icuString: icuString,
+        shouldVisit: isGTUnindexedSelectElement,
+        visitor: visitor,
+        options: {
+            recurseIntoVisited: false,
+            captureLocation: true,
+        },
+    });
+    // Construct output string
+    var previousIndex = 0;
+    var outputList = [];
+    for (var 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));
+    }
+    var outputString = outputList.join('');
+    return outputString;
+}

package/dist/derive/derive.d.ts

@@ -0,0 +1,53 @@
+/**
+ * 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.
+ */
+export declare function derive<T extends string | boolean | number | null | undefined>(content: T): T;
+/**
+ * @deprecated Use derive() instead.
+ *
+ * Marks content as derivable by the GT compiler and CLI.
+ *
+ * Use `derive()` instead of `declareStatic()` for new code. This alias is kept
+ * for backwards compatibility and returns its argument unchanged at runtime.
+ *
+ * Run `gt validate` after adding or changing derived content 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 ${declareStatic(getSubject())}`);
+ * ```
+ *
+ * @param {T extends string | boolean | number | null | undefined} content - Content to derive for translation extraction.
+ * @returns {T} The same content, unchanged at runtime.
+ */
+export declare const declareStatic: typeof derive;

package/dist/derive/derive.js

@@ -0,0 +1,55 @@
+/**
+ * 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.
+ */
+export function derive(content) {
+    return content;
+}
+/**
+ * @deprecated Use derive() instead.
+ *
+ * Marks content as derivable by the GT compiler and CLI.
+ *
+ * Use `derive()` instead of `declareStatic()` for new code. This alias is kept
+ * for backwards compatibility and returns its argument unchanged at runtime.
+ *
+ * Run `gt validate` after adding or changing derived content 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 ${declareStatic(getSubject())}`);
+ * ```
+ *
+ * @param {T extends string | boolean | number | null | undefined} content - Content to derive for translation extraction.
+ * @returns {T} The same content, unchanged at runtime.
+ */
+export var declareStatic = derive;

package/dist/derive/extractVars.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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.
+ */
+export declare function extractVars(icuString: string): Record<string, string>;

package/dist/derive/extractVars.js

@@ -0,0 +1,34 @@
+import { VAR_IDENTIFIER } from './utils/constants';
+import { isGTUnindexedSelectElement } from './utils/traverseHelpers';
+import { traverseIcu } from './utils/traverseIcu';
+/**
+ * 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.
+ */
+export function extractVars(icuString) {
+    // Check if the string contains _gt_
+    if (!icuString.includes(VAR_IDENTIFIER)) {
+        return {};
+    }
+    // Extract all the _gt_# variables
+    var index = 1;
+    var variables = {};
+    function visitor(child) {
+        var _a;
+        variables[child.value + index] = child.options.other.value.length
+            ? (_a = child.options.other.value[0]) === null || _a === void 0 ? void 0 : _a.value
+            : '';
+        index += 1;
+    }
+    traverseIcu({
+        icuString: icuString,
+        shouldVisit: isGTUnindexedSelectElement,
+        visitor: visitor,
+        options: { recurseIntoVisited: false },
+    });
+    return variables;
+}

package/dist/derive/index.d.ts

@@ -0,0 +1,7 @@
+export * from './decodeVars';
+export * from './declareVar';
+export * from './derive';
+export * from './indexVars';
+export * from './extractVars';
+export * from './condenseVars';
+export * from './utils/constants';

package/dist/derive/index.js

@@ -0,0 +1,7 @@
+export * from './decodeVars';
+export * from './declareVar';
+export * from './derive';
+export * from './indexVars';
+export * from './extractVars';
+export * from './condenseVars';
+export * from './utils/constants';

package/dist/derive/indexVars.d.ts

@@ -0,0 +1,6 @@
+import { IcuMessage } from '../types-dir/jsx/content';
+/**
+ * Given an ICU string adds identifiers to each _gt_ placeholder
+ * indexVars('Hello {_gt_} {_gt_} World') => 'Hello {_gt_1_} {_gt_2_} World'
+ */
+export declare function indexVars(icuString: IcuMessage): string;

package/dist/derive/indexVars.js

@@ -0,0 +1,52 @@
+import { VAR_IDENTIFIER } from './utils/constants';
+import { traverseIcu } from './utils/traverseIcu';
+import { isGTUnindexedSelectElement } from './utils/traverseHelpers';
+/**
+ * Given an ICU string adds identifiers to each _gt_ placeholder
+ * indexVars('Hello {_gt_} {_gt_} World') => 'Hello {_gt_1_} {_gt_2_} World'
+ */
+export function indexVars(icuString) {
+    // Check if the string contains _gt_
+    if (!icuString.includes(VAR_IDENTIFIER)) {
+        return icuString;
+    }
+    // Record the location of the variable
+    var variableLocations = [];
+    function visitor(child) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        variableLocations.push({
+            start: (_b = (_a = child.location) === null || _a === void 0 ? void 0 : _a.start.offset) !== null && _b !== void 0 ? _b : 0,
+            end: (_d = (_c = child.location) === null || _c === void 0 ? void 0 : _c.end.offset) !== null && _d !== void 0 ? _d : 0,
+            otherStart: (_f = (_e = child.options.other.location) === null || _e === void 0 ? void 0 : _e.start.offset) !== null && _f !== void 0 ? _f : 0,
+            otherEnd: (_h = (_g = child.options.other.location) === null || _g === void 0 ? void 0 : _g.end.offset) !== null && _h !== void 0 ? _h : 0,
+        });
+    }
+    // Find all variable identifiers.
+    traverseIcu({
+        icuString: icuString,
+        shouldVisit: isGTUnindexedSelectElement,
+        visitor: visitor,
+        options: { recurseIntoVisited: false, captureLocation: true },
+    });
+    // Index each variable and collapse the other option.
+    var result = [];
+    var current = 0;
+    for (var i = 0; i < variableLocations.length; i++) {
+        var _a = variableLocations[i], start = _a.start, end = _a.end, otherStart = _a.otherStart, otherEnd = _a.otherEnd;
+        // Before the variable
+        result.push(icuString.slice(current, start));
+        // Replace the variable with the new identifier (+1 is for the curly brace)
+        result.push(icuString.slice(start, start + VAR_IDENTIFIER.length + 1));
+        // Add the new identifier.
+        result.push(String(i + 1));
+        // After the variable
+        result.push(icuString.slice(start + VAR_IDENTIFIER.length + 1, otherStart));
+        // Before the other option
+        result.push('{}');
+        // The other option
+        result.push(icuString.slice(otherEnd, end));
+        current = end;
+    }
+    result.push(icuString.slice(current, icuString.length));
+    return result.join('');
+}

package/dist/derive/utils/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const VAR_IDENTIFIER = "_gt_";
+export declare const VAR_NAME_IDENTIFIER = "_gt_var_name";

package/dist/derive/utils/constants.js

@@ -0,0 +1,2 @@
+export var VAR_IDENTIFIER = '_gt_';
+export var VAR_NAME_IDENTIFIER = '_gt_var_name';

package/dist/derive/utils/regex.d.ts

@@ -0,0 +1,2 @@
+export declare const GT_INDEXED_IDENTIFIER_REGEX: RegExp;
+export declare const GT_UNINDEXED_IDENTIFIER_REGEX: RegExp;

package/dist/derive/utils/regex.js

@@ -0,0 +1,4 @@
+import { VAR_IDENTIFIER } from './constants';
+// Regex  for _gt_# select
+export var GT_INDEXED_IDENTIFIER_REGEX = new RegExp("^".concat(VAR_IDENTIFIER, "\\d+$"));
+export var GT_UNINDEXED_IDENTIFIER_REGEX = new RegExp("^".concat(VAR_IDENTIFIER, "$"));

package/dist/derive/utils/sanitizeVar.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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 ({}<>)
+ */
+export declare function sanitizeVar(string: string): string;

package/dist/derive/utils/sanitizeVar.js

@@ -0,0 +1,38 @@
+/**
+ * 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 ({}<>)
+ */
+export function sanitizeVar(string) {
+    // First, double all single quotes (both ASCII and Unicode).
+    var result = string.replace(/'/g, "''");
+    // Find first and last positions of special characters
+    var specialChars = /[{}<>]/;
+    var firstSpecialIndex = result.search(specialChars);
+    if (firstSpecialIndex === -1) {
+        // No special characters; return with just doubled quotes.
+        return result;
+    }
+    // Find last special character position
+    var lastSpecialIndex = -1;
+    for (var i = result.length - 1; i >= 0; i--) {
+        if (specialChars.test(result[i])) {
+            lastSpecialIndex = i;
+            break;
+        }
+    }
+    // Insert quotes around the special character region.
+    result =
+        result.slice(0, firstSpecialIndex) +
+            "'" +
+            result.slice(firstSpecialIndex, lastSpecialIndex + 1) +
+            "'" +
+            result.slice(lastSpecialIndex + 1);
+    return result;
+}

package/dist/derive/utils/traverseHelpers.d.ts

@@ -0,0 +1,4 @@
+import { GTIndexedSelectElement, GTUnindexedSelectElement } from './types';
+import { type MessageFormatElement } from '@formatjs/icu-messageformat-parser/types.js';
+export declare function isGTIndexedSelectElement(child: MessageFormatElement): child is GTIndexedSelectElement;
+export declare function isGTUnindexedSelectElement(child: MessageFormatElement): child is GTUnindexedSelectElement;

package/dist/derive/utils/traverseHelpers.js

@@ -0,0 +1,22 @@
+import { GT_INDEXED_IDENTIFIER_REGEX, GT_UNINDEXED_IDENTIFIER_REGEX, } from './regex';
+import { TYPE, } from '@formatjs/icu-messageformat-parser/types.js';
+// Visit any _gt_# select
+export function isGTIndexedSelectElement(child) {
+    var _a;
+    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 &&
+                ((_a = child.options.other.value[0]) === null || _a === void 0 ? void 0 : _a.type) === TYPE.literal)));
+}
+// Visit any _gt_ select
+export function isGTUnindexedSelectElement(child) {
+    var _a;
+    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 &&
+                ((_a = child.options.other.value[0]) === null || _a === void 0 ? void 0 : _a.type) === TYPE.literal)));
+}