generaltranslation 8.2.12 → 8.2.14

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 type { IcuMessage } from '@generaltranslation/format/types';
+/**
+ * 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.cjs

@@ -1,3 +1,3 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_ApiError = require("./ApiError-CZ45tkW6.cjs");
+const require_ApiError = require("./ApiError-D-IBuHj6.cjs");
 exports.ApiError = require_ApiError.ApiError;

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/errors.mjs

@@ -1,2 +1,2 @@
-import { t as ApiError } from "./ApiError-IYfaOR30.mjs";
+import { t as ApiError } from "./ApiError-0DxxIHLp.mjs";
 export { ApiError };