generaltranslation 8.2.12 → 8.2.13

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)));
+}

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

@@ -0,0 +1,20 @@
+import { MessageFormatElement, ParserOptions } from '@formatjs/icu-messageformat-parser';
+type TraverseIcuOptions = ParserOptions & {
+    recurseIntoVisited?: boolean;
+};
+/**
+ * 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
+ */
+export declare function traverseIcu<T extends MessageFormatElement>({ icuString, shouldVisit, visitor, options: { recurseIntoVisited, ...otherOptions }, }: {
+    icuString: string;
+    shouldVisit: (element: MessageFormatElement) => element is T;
+    visitor: (element: T) => void;
+    options: TraverseIcuOptions;
+}): MessageFormatElement[];
+export {};

package/dist/derive/utils/traverseIcu.js

@@ -0,0 +1,49 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { parse, TYPE, } from '@formatjs/icu-messageformat-parser';
+/**
+ * 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
+ */
+export function traverseIcu(_a) {
+    var icuString = _a.icuString, shouldVisit = _a.shouldVisit, visitor = _a.visitor, _b = _a.options, _c = _b.recurseIntoVisited, recurseIntoVisited = _c === void 0 ? true : _c, otherOptions = __rest(_b, ["recurseIntoVisited"]);
+    var ast = parse(icuString, otherOptions);
+    handleChildren(ast);
+    return ast;
+    function handleChildren(children) {
+        children.map(handleChild);
+    }
+    function handleChild(child) {
+        // handle select var
+        var visited = false;
+        if (shouldVisit(child)) {
+            visitor(child);
+            visited = true;
+        }
+        // recurse on children
+        if (!visited || recurseIntoVisited) {
+            if (child.type === TYPE.select || child.type === TYPE.plural) {
+                Object.values(child.options)
+                    .map(function (option) { return option.value; })
+                    .map(handleChildren);
+            }
+            else if (child.type === TYPE.tag) {
+                handleChildren(child.children);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,23 @@
+import { VAR_IDENTIFIER } from './constants';
+import type { PluralOrSelectOption, LiteralElement, SelectElement } from '@formatjs/icu-messageformat-parser/types.js';
+interface GTIndexedSelectOption extends PluralOrSelectOption {
+    value: Array<LiteralElement>;
+}
+export interface GTIndexedSelectElement extends SelectElement {
+    value: `${typeof VAR_IDENTIFIER}${number}`;
+    options: {
+        other: GTIndexedSelectOption;
+        [key: string]: PluralOrSelectOption;
+    };
+}
+interface GTUnindexedSelectOption extends PluralOrSelectOption {
+    value: Array<LiteralElement>;
+}
+export interface GTUnindexedSelectElement extends SelectElement {
+    value: typeof VAR_IDENTIFIER;
+    options: {
+        other: GTUnindexedSelectOption;
+        [key: string]: PluralOrSelectOption;
+    };
+}
+export {};

package/dist/derive/utils/types.js

@@ -0,0 +1 @@
+export {};

package/dist/errors/ApiError.d.ts

@@ -0,0 +1,7 @@
+export declare class ApiError extends Error {
+    code: number;
+    message: string;
+    constructor(error: string, code: number, message: string);
+    getCode(): number;
+    getMessage(): string;
+}

package/dist/errors/ApiError.js

@@ -0,0 +1,33 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var ApiError = /** @class */ (function (_super) {
+    __extends(ApiError, _super);
+    function ApiError(error, code, message) {
+        var _this = _super.call(this, error) || this;
+        _this.name = 'ApiError';
+        _this.code = code;
+        _this.message = message;
+        return _this;
+    }
+    ApiError.prototype.getCode = function () {
+        return this.code;
+    };
+    ApiError.prototype.getMessage = function () {
+        return this.message;
+    };
+    return ApiError;
+}(Error));
+export { ApiError };

package/dist/errors/formattingErrors.d.ts

@@ -0,0 +1 @@
+export declare const createInvalidCutoffStyleError: (style: string) => string;

package/dist/errors/formattingErrors.js

@@ -0,0 +1,3 @@
+export var createInvalidCutoffStyleError = function (style) {
+    return "generaltranslation Formatting Error: Invalid cutoff style: ".concat(style, ".");
+};

package/dist/errors.d.ts

@@ -0,0 +1 @@
+export * from './errors/ApiError';

package/dist/errors.js

@@ -0,0 +1 @@
+export * from './errors/ApiError';

package/dist/formatting/custom-formats/CutoffFormat/CutoffFormat.d.ts

@@ -0,0 +1,59 @@
+import { CutoffFormat, CutoffFormatOptions, PostpendedCutoffParts, PrependedCutoffParts, ResolvedCutoffFormatOptions } from './types';
+export declare class CutoffFormatConstructor implements CutoffFormat {
+    private locale;
+    private options;
+    private additionLength;
+    /**
+     * Constructor
+     * @param {Intl.LocalesArgument} locales - The locales to use for formatting.
+     * @param {CutoffFormatOptions} options - The options for formatting.
+     * @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.
+     *
+     * @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: Intl.LocalesArgument, options?: CutoffFormatOptions);
+    /**
+     * 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: string): string;
+    /**
+     * 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: string): PrependedCutoffParts | PostpendedCutoffParts;
+    /**
+     * Get the resolved options
+     * @returns {ResolvedCutoffFormatOptions} The resolved options.
+     */
+    resolvedOptions(): ResolvedCutoffFormatOptions;
+}