generaltranslation 8.2.12 → 8.2.13

package/dist/formatting/custom-formats/CutoffFormat/CutoffFormat.js

@@ -0,0 +1,147 @@
+import { createInvalidCutoffStyleError } from '../../../errors/formattingErrors';
+import { libraryDefaultLocale } from '../../../settings/settings';
+import { DEFAULT_CUTOFF_FORMAT_STYLE, DEFAULT_TERMINATOR_KEY, TERMINATOR_MAP, } from './constants';
+var CutoffFormatConstructor = /** @class */ (function () {
+    /**
+     * 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!'
+     */
+    function CutoffFormatConstructor(locales, options) {
+        if (options === void 0) { options = {}; }
+        var _a, _b, _c, _d, _e, _f, _g;
+        // Determine locale (this replicates Intl.NumberFormat behavior including silent failure)
+        try {
+            // Normalize locales to string
+            var localesList = !locales
+                ? [libraryDefaultLocale]
+                : Array.isArray(locales)
+                    ? locales.map(function (l) { return String(l); })
+                    : [String(locales)];
+            var canonicalLocales = Intl.getCanonicalLocales(localesList);
+            this.locale = canonicalLocales.length
+                ? canonicalLocales[0]
+                : libraryDefaultLocale;
+        }
+        catch (_h) {
+            this.locale = libraryDefaultLocale;
+        }
+        // Follows Intl.NumberFormat behavior of throwing an error when currency is invalid
+        if (!TERMINATOR_MAP[(_a = options.style) !== null && _a !== void 0 ? _a : DEFAULT_CUTOFF_FORMAT_STYLE]) {
+            throw new Error(createInvalidCutoffStyleError((_b = options.style) !== null && _b !== void 0 ? _b : DEFAULT_CUTOFF_FORMAT_STYLE));
+        }
+        // Resolve terminator options.
+        var style;
+        var presetTerminatorOptions;
+        if (options.maxChars !== undefined) {
+            style = (_c = options.style) !== null && _c !== void 0 ? _c : DEFAULT_CUTOFF_FORMAT_STYLE;
+            // TODO: need more sophisticated locale negotiation if we want to add support for region/script/etc.-specific terminators in the future
+            var languageCode = new Intl.Locale(this.locale).language;
+            presetTerminatorOptions =
+                TERMINATOR_MAP[style][languageCode] ||
+                    TERMINATOR_MAP[style][DEFAULT_TERMINATOR_KEY];
+        }
+        var terminator = (_d = options.terminator) !== null && _d !== void 0 ? _d : presetTerminatorOptions === null || presetTerminatorOptions === void 0 ? void 0 : presetTerminatorOptions.terminator;
+        var separator = terminator != null
+            ? ((_e = options.separator) !== null && _e !== void 0 ? _e : presetTerminatorOptions === null || presetTerminatorOptions === void 0 ? void 0 : presetTerminatorOptions.separator)
+            : undefined;
+        // // Remove terminator and separator if maxChars does have enough space
+        this.additionLength = ((_f = terminator === null || terminator === void 0 ? void 0 : terminator.length) !== null && _f !== void 0 ? _f : 0) + ((_g = separator === null || separator === void 0 ? void 0 : separator.length) !== null && _g !== void 0 ? _g : 0);
+        if (options.maxChars !== undefined &&
+            Math.abs(options.maxChars) < this.additionLength) {
+            terminator = undefined;
+            separator = undefined;
+        }
+        this.options = {
+            maxChars: options.maxChars,
+            style: style,
+            terminator: terminator,
+            separator: separator,
+        };
+    }
+    /**
+     * Format a value according to the cutoff options, returning a formatted string.
+     *
+     * @param {string} value - The string value to format with cutoff behavior.
+     * @returns {string} The formatted string with terminator applied if cutoff occurs.
+     *
+     * @example
+     * const formatter = new CutoffFormatConstructor('en', { maxChars: 8, style: 'ellipsis' });
+     * formatter.format('Hello, world!'); // Returns 'Hello, w...'
+     */
+    CutoffFormatConstructor.prototype.format = function (value) {
+        return this.formatToParts(value).join('');
+    };
+    /**
+     * Format a value to parts according to the cutoff options, returning an array of string parts.
+     * This method breaks down the formatted result into individual components for more granular control.
+     *
+     * @param {string} value - The string value to format with cutoff behavior.
+     * @returns {PrependedCutoffParts | PostpendedCutoffParts} An array of string parts representing the formatted result.
+     *   - For positive maxChars: [cutoffValue, separator?, terminator?]
+     *   - For negative maxChars: [terminator?, separator?, cutoffValue]
+     *   - For no cutoff: [originalValue]
+     *
+     * @example
+     * const formatter = new CutoffFormatConstructor('en', { maxChars: 5, style: 'ellipsis' });
+     * formatter.formatToParts('Hello, world!'); // Returns ['Hello', '...']
+     */
+    CutoffFormatConstructor.prototype.formatToParts = function (value) {
+        var _a = this.options, maxChars = _a.maxChars, terminator = _a.terminator, separator = _a.separator;
+        // Slice our value
+        // const additionLength = (terminator?.length ?? 0) + (separator?.length ?? 0);
+        var adjustedChars = maxChars === undefined || Math.abs(maxChars) >= value.length
+            ? maxChars
+            : maxChars >= 0
+                ? Math.max(0, maxChars - this.additionLength)
+                : Math.min(0, maxChars + this.additionLength);
+        var slicedValue = adjustedChars !== undefined && adjustedChars > -1
+            ? value.slice(0, adjustedChars)
+            : value.slice(adjustedChars);
+        // No cutoff, no terminator -> value only
+        if (maxChars == null ||
+            adjustedChars == null ||
+            adjustedChars === 0 ||
+            terminator == null ||
+            value.length <= Math.abs(maxChars)) {
+            return [slicedValue];
+        }
+        // Postpended cutoff.
+        if (adjustedChars > 0) {
+            return separator != null
+                ? [slicedValue, separator, terminator]
+                : [slicedValue, terminator];
+        }
+        // Prepended cutoff.
+        else {
+            return separator != null
+                ? [terminator, separator, slicedValue]
+                : [terminator, slicedValue];
+        }
+    };
+    /**
+     * Get the resolved options
+     * @returns {ResolvedCutoffFormatOptions} The resolved options.
+     */
+    CutoffFormatConstructor.prototype.resolvedOptions = function () {
+        return this.options;
+    };
+    return CutoffFormatConstructor;
+}());
+export { CutoffFormatConstructor };

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

@@ -0,0 +1,4 @@
+import { CutoffFormatStyle, ResolvedTerminatorOptions } from './types';
+export declare const DEFAULT_CUTOFF_FORMAT_STYLE: CutoffFormatStyle;
+export declare const DEFAULT_TERMINATOR_KEY = "DEFAULT_TERMINATOR_KEY";
+export declare const TERMINATOR_MAP: Record<CutoffFormatStyle, Record<string | typeof DEFAULT_TERMINATOR_KEY, ResolvedTerminatorOptions>>;

package/dist/formatting/custom-formats/CutoffFormat/constants.js

@@ -0,0 +1,30 @@
+var _a, _b;
+export var DEFAULT_CUTOFF_FORMAT_STYLE = 'ellipsis';
+export var DEFAULT_TERMINATOR_KEY = 'DEFAULT_TERMINATOR_KEY';
+export var TERMINATOR_MAP = {
+    ellipsis: (_a = {
+            fr: {
+                terminator: '…',
+                separator: '\u202F',
+            },
+            zh: {
+                terminator: '……',
+                separator: undefined,
+            },
+            ja: {
+                terminator: '……',
+                separator: undefined,
+            }
+        },
+        _a[DEFAULT_TERMINATOR_KEY] = {
+            terminator: '…',
+            separator: undefined,
+        },
+        _a),
+    none: (_b = {},
+        _b[DEFAULT_TERMINATOR_KEY] = {
+            terminator: undefined,
+            separator: undefined,
+        },
+        _b),
+};

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

@@ -0,0 +1,48 @@
+/** Type of terminator */
+export type CutoffFormatStyle = 'none' | 'ellipsis';
+/** Terminator options. */
+export interface TerminatorOptions {
+    /** The terminator to use. */
+    terminator?: string;
+    /** An optional separator between the terminator and the value */
+    separator?: string;
+}
+/** Input formatting options (for constructor) */
+export interface CutoffFormatOptions extends TerminatorOptions {
+    /** Cutoff length. */
+    maxChars?: number;
+    /** Type of terminator */
+    style?: CutoffFormatStyle;
+}
+/** Resolved terminator options */
+export interface ResolvedTerminatorOptions extends TerminatorOptions {
+    terminator: string | undefined;
+    separator: string | undefined;
+}
+/** Resolved options (after constructor) */
+export interface ResolvedCutoffFormatOptions extends CutoffFormatOptions, ResolvedTerminatorOptions {
+    maxChars: number | undefined;
+    style: CutoffFormatStyle | undefined;
+    terminator: string | undefined;
+    separator: string | undefined;
+}
+/** Prepended cutoff list */
+export type PrependedCutoffParts = [string] | [ResolvedTerminatorOptions['terminator'], string] | [
+    ResolvedTerminatorOptions['terminator'],
+    ResolvedTerminatorOptions['separator'],
+    string
+];
+/** Postpended cutoff list */
+export type PostpendedCutoffParts = [string] | [string, ResolvedTerminatorOptions['terminator']] | [
+    string,
+    ResolvedTerminatorOptions['separator'],
+    ResolvedTerminatorOptions['terminator']
+];
+/**
+ * Cutoff Class interface
+ */
+export interface CutoffFormat {
+    format: (value: string) => string;
+    resolvedOptions: () => ResolvedCutoffFormatOptions;
+    formatToParts: (value: string) => PrependedCutoffParts | PostpendedCutoffParts;
+}

package/dist/formatting/custom-formats/CutoffFormat/types.js

@@ -0,0 +1,2 @@
+// ========== Base Types ========== //
+export {};

package/dist/formatting/format.d.ts

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

package/dist/formatting/format.js

@@ -0,0 +1,257 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { intlCache } from '../cache/IntlCache';
+import { libraryDefaultLocale } from '../settings/settings';
+import { IntlMessageFormat } from 'intl-messageformat';
+import { formatI18nextWarning, formatJsxWarning } from '../logging/warnings';
+import { formattingLogger } from '../logging/logger';
+/**
+ * Formats a string value with cutoff behavior according to the specified locales and options.
+ *
+ * @param {Object} params - The parameters for the cutoff formatting.
+ * @param {string} params.value - The string value to format with cutoff behavior.
+ * @param {string | string[]} [params.locales='en'] - The locales to use for formatting.
+ * @param {CutoffFormatOptions} [params.options={}] - Additional options for cutoff formatting.
+ * @param {number} [params.options.maxChars] - The maximum number of characters to display.
+ * @param {CutoffFormatStyle} [params.options.style='ellipsis'] - The style of the terminator.
+ * @param {string} [params.options.terminator] - Optional override for the terminator to use.
+ * @param {string} [params.options.separator] - Optional override for the separator between terminator and value.
+ *
+ * @returns {string} The formatted string with terminator applied if cutoff occurs.
+ * @internal
+ *
+ * @example
+ * _formatCutoff({ value: 'Hello, world!', options: { maxChars: 8 } }); // Returns 'Hello, w...'
+ */
+export function _formatCutoff(_a) {
+    var value = _a.value, _b = _a.locales, locales = _b === void 0 ? libraryDefaultLocale : _b, _c = _a.options, options = _c === void 0 ? {} : _c;
+    return intlCache.get('CutoffFormat', locales, options).format(value);
+}
+/**
+ * Formats a message according to the specified locales and options.
+ *
+ * @param {string} message - The message to format.
+ * @param {string | string[]} [locales='en'] - The locales to use for formatting.
+ * @param {Record<string, any>} [variables={}] - The variables to use for formatting.
+ * @returns {string} The formatted message.
+ * @internal
+ *
+ * Returns an empty string if IntlMessageFormat produces no output.
+ * TODO: Add this to custom formats.
+ */
+export function _formatMessageICU(message, locales, variables) {
+    var _a, _b;
+    if (locales === void 0) { locales = libraryDefaultLocale; }
+    if (variables === void 0) { variables = {}; }
+    var messageFormat = new IntlMessageFormat(message, locales);
+    return (_b = (_a = messageFormat.format(variables)) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : '';
+}
+/**
+ * Returns the message as-is without any formatting.
+ *
+ * @param {string} message - The message to return.
+ * @returns {string} The original message, unchanged.
+ * @internal
+ *
+ * TODO: Add this to custom formats.
+ */
+export function _formatMessageString(message) {
+    return message;
+}
+/**
+ * Formats a number according to the specified locales and options.
+ *
+ * @param {Object} params - The parameters for the number formatting.
+ * @param {number} params.value - The number to format.
+ * @param {string | string[]} [params.locales=['en']] - The locales to use for formatting.
+ * @param {Intl.NumberFormatOptions} [params.options={}] - Additional options for number formatting.
+ *
+ * @returns {string} The formatted number.
+ * @internal
+ */
+export function _formatNum(_a) {
+    var value = _a.value, _b = _a.locales, locales = _b === void 0 ? [libraryDefaultLocale] : _b, _c = _a.options, options = _c === void 0 ? {} : _c;
+    var res = intlCache
+        .get('NumberFormat', locales, __assign({ numberingSystem: 'latn' }, options))
+        .format(value);
+    return res;
+}
+/**
+ * Formats a date according to the specified locales and options.
+ *
+ * @param {Object} params - The parameters for the date formatting.
+ * @param {Date} params.value - The date to format.
+ * @param {string | string[]} [params.locales='en'] - The locales to use for formatting.
+ * @param {Intl.DateTimeFormatOptions} [params.options={}] - Additional options for date formatting.
+ *
+ * @returns {string} The formatted date.
+ * @internal
+ */
+export function _formatDateTime(_a) {
+    var value = _a.value, _b = _a.locales, locales = _b === void 0 ? [libraryDefaultLocale] : _b, _c = _a.options, options = _c === void 0 ? {} : _c;
+    return intlCache
+        .get('DateTimeFormat', locales, __assign({ calendar: 'gregory', numberingSystem: 'latn' }, options))
+        .format(value);
+}
+/**
+ * Formats a currency value according to the specified locales, currency, and options.
+ *
+ * @param {Object} params - The parameters for the currency formatting.
+ * @param {number} params.value - The currency value to format.
+ * @param {string} params.currency - The currency code (e.g., 'USD').
+ * @param {string | string[]} [params.locales=['en']] - The locales to use for formatting.
+ * @param {Intl.NumberFormatOptions} [params.options={}] - Additional options for currency formatting.
+ *
+ * @returns {string} The formatted currency value.
+ * @internal
+ */
+export function _formatCurrency(_a) {
+    var value = _a.value, _b = _a.locales, locales = _b === void 0 ? [libraryDefaultLocale] : _b, _c = _a.currency, currency = _c === void 0 ? 'USD' : _c, _d = _a.options, options = _d === void 0 ? {} : _d;
+    return intlCache
+        .get('NumberFormat', locales, __assign({ style: 'currency', currency: currency, numberingSystem: 'latn' }, options))
+        .format(value);
+}
+/**
+ * Formats a list of items according to the specified locales and options.
+ *
+ * @param {Object} params - The parameters for the list formatting.
+ * @param {Array<string | number>} params.value - The list of items to format.
+ * @param {string | string[]} [params.locales=['en']] - The locales to use for formatting.
+ * @param {Intl.ListFormatOptions} [params.options={}] - Additional options for list formatting.
+ *
+ * @returns {string} The formatted list.
+ * @internal
+ */
+export function _formatList(_a) {
+    var value = _a.value, _b = _a.locales, locales = _b === void 0 ? [libraryDefaultLocale] : _b, _c = _a.options, options = _c === void 0 ? {} : _c;
+    return intlCache
+        .get('ListFormat', locales, __assign({ type: 'conjunction', style: 'long' }, options))
+        .format(value.map(String));
+}
+/**
+ * Formats a list of items according to the specified locales and options.
+ * @param {Object} params - The parameters for the list formatting.
+ * @param {Array<T>} params.value - The list of items to format.
+ * @param {string | string[]} [params.locales=['en']] - The locales to use for formatting.
+ * @param {Intl.ListFormatOptions} [params.options={}] - Additional options for list formatting.
+ * @returns {Array<T | string>} The formatted list parts.
+ * @internal
+ */
+export function _formatListToParts(_a) {
+    var value = _a.value, _b = _a.locales, locales = _b === void 0 ? [libraryDefaultLocale] : _b, _c = _a.options, options = _c === void 0 ? {} : _c;
+    var formatListParts = intlCache
+        .get('ListFormat', locales, __assign({ type: 'conjunction', style: 'long' }, options))
+        .formatToParts(value.map(function () { return '1'; }));
+    var partIndex = 0;
+    return formatListParts.map(function (part) {
+        if (part.type === 'element')
+            return value[partIndex++];
+        return part.value;
+    });
+}
+/**
+ * Selects the best unit and computes the value for relative time formatting
+ * based on the difference between a date and a base date.
+ * @param {Date} date - The target date.
+ * @param {Date} baseDate - The base date to compute relative time from. Must be provided by the caller for hydration safety.
+ * @returns {{ value: number, unit: Intl.RelativeTimeFormatUnit }} The computed value and unit.
+ * @internal
+ */
+export function _selectRelativeTimeUnit(date, baseDate) {
+    var now = baseDate.getTime();
+    var diffMs = date.getTime() - now;
+    var absDiffMs = Math.abs(diffMs);
+    var sign = diffMs < 0 ? -1 : 1;
+    // Use Math.floor to avoid confusing jumps near boundaries
+    // (e.g. 3.5 days rounding to "1 week ago" instead of "3 days ago")
+    var seconds = Math.floor(absDiffMs / 1000);
+    var minutes = Math.floor(absDiffMs / (1000 * 60));
+    var hours = Math.floor(absDiffMs / (1000 * 60 * 60));
+    var days = Math.floor(absDiffMs / (1000 * 60 * 60 * 24));
+    var weeks = Math.floor(absDiffMs / (1000 * 60 * 60 * 24 * 7));
+    var months = Math.floor(absDiffMs / (1000 * 60 * 60 * 24 * 30));
+    var years = Math.floor(absDiffMs / (1000 * 60 * 60 * 24 * 365));
+    if (seconds < 60)
+        return { value: sign * seconds, unit: 'second' };
+    if (minutes < 60)
+        return { value: sign * minutes, unit: 'minute' };
+    if (hours < 24)
+        return { value: sign * hours, unit: 'hour' };
+    if (days < 7)
+        return { value: sign * days, unit: 'day' };
+    if (days < 28)
+        return { value: sign * weeks, unit: 'week' };
+    if (months < 1)
+        return { value: sign * weeks, unit: 'week' };
+    if (months < 12)
+        return { value: sign * months, unit: 'month' };
+    if (years < 1)
+        return { value: sign * months, unit: 'month' };
+    return { value: sign * years, unit: 'year' };
+}
+/**
+ * Formats a relative time from a Date, automatically selecting the best unit.
+ * @internal
+ */
+export function _formatRelativeTimeFromDate(_a) {
+    var date = _a.date, baseDate = _a.baseDate, _b = _a.locales, locales = _b === void 0 ? [libraryDefaultLocale] : _b, _c = _a.options, options = _c === void 0 ? {} : _c;
+    var _d = _selectRelativeTimeUnit(date, baseDate), value = _d.value, unit = _d.unit;
+    return _formatRelativeTime({ value: value, unit: unit, locales: locales, options: options });
+}
+/**
+ * Formats a relative time value according to the specified locales and options.
+ *
+ * @param {Object} params - The parameters for the relative time formatting.
+ * @param {number} params.value - The relative time value to format.
+ * @param {Intl.RelativeTimeFormatUnit} params.unit - The unit of time (e.g., 'second', 'minute', 'hour', 'day', 'week', 'month', 'year').
+ * @param {string | string[]} [params.locales=['en']] - The locales to use for formatting.
+ * @param {Intl.RelativeTimeFormatOptions} [params.options={}] - Additional options for relative time formatting.
+ *
+ * @returns {string} The formatted relative time string.
+ * @internal
+ */
+export function _formatRelativeTime(_a) {
+    var value = _a.value, unit = _a.unit, _b = _a.locales, locales = _b === void 0 ? [libraryDefaultLocale] : _b, _c = _a.options, options = _c === void 0 ? {} : _c;
+    return intlCache
+        .get('RelativeTimeFormat', locales, __assign({ style: 'long', numeric: 'auto' }, options))
+        .format(value, unit);
+}
+/**
+ * @experimental This function is not currently supported but will be implemented in a future version.
+ * Use {@link _formatMessageICU} for current ICU message format support.
+ * Formats an I18next message according to the specified locales and options.
+ *
+ * @param message - The I18next message to format.
+ * @param variables - The variables to use for formatting.
+ * @returns The formatted I18next message.
+ * @internal
+ */
+export function _formatI18next(message, _variables) {
+    if (_variables === void 0) { _variables = {}; }
+    formattingLogger.warn(formatI18nextWarning);
+    return message;
+}
+/**
+ * @experimental This function is not currently supported but will be implemented in a future version.
+ * Use {@link _formatMessageICU} for current ICU message format support.
+ * Formats a JSX message according to the specified locales and options.
+ *
+ * @param message - The JSX message to format.
+ * @param variables - The variables to use for formatting.
+ * @returns The formatted JSX message.
+ * @internal
+ */
+export function _formatJsx(message, _variables) {
+    if (_variables === void 0) { _variables = {}; }
+    formattingLogger.warn(formatJsxWarning);
+    return message;
+}

package/dist/id/hashSource.d.ts

@@ -0,0 +1,25 @@
+import { JsxChildren } from '../types';
+import { HashMetadata } from './types';
+/**
+ * Calculates a unique hash for a given string using SHA-256.
+ *
+ * First 16 characters of hash, hex encoded.
+ *
+ * @param {string} string - The string to be hashed.
+ * @returns {string} The resulting hash as a hexadecimal string.
+ */
+export declare function hashString(string: string): 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 {number} [maxChars] - The maxChars limit for the JSX children object.
+ * @param {string} [dataFormat] - The data format of the sources.
+ * @param {function} [hashFunction] - Custom hash function.
+ * @returns {string} - The unique hash of the children.
+ */
+export declare function hashSource({ source, context, id, maxChars, dataFormat, }: {
+    source: JsxChildren | string;
+} & HashMetadata, hashFunction?: (string: string) => string): string;

package/dist/id/hashSource.js

@@ -0,0 +1,98 @@
+// Functions provided to other GT libraries
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { stableStringify as stringify } from '../utils/stableStringify';
+import { sha256 } from '@noble/hashes/sha2.js';
+import { bytesToHex, utf8ToBytes } from '@noble/hashes/utils.js';
+import isVariable from '../utils/isVariable';
+// ----- FUNCTIONS ----- //
+/**
+ * Calculates a unique hash for a given string using SHA-256.
+ *
+ * First 16 characters of hash, hex encoded.
+ *
+ * @param {string} string - The string to be hashed.
+ * @returns {string} The resulting hash as a hexadecimal string.
+ */
+export function hashString(string) {
+    return bytesToHex(sha256(utf8ToBytes(string))).slice(0, 16);
+}
+/**
+ * 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 {number} [maxChars] - The maxChars limit for the JSX children object.
+ * @param {string} [dataFormat] - The data format of the sources.
+ * @param {function} [hashFunction] - Custom hash function.
+ * @returns {string} - The unique hash of the children.
+ */
+export function hashSource(_a, hashFunction) {
+    var source = _a.source, context = _a.context, id = _a.id, maxChars = _a.maxChars, dataFormat = _a.dataFormat;
+    if (hashFunction === void 0) { hashFunction = hashString; }
+    var sanitizedSource;
+    if (dataFormat === 'JSX') {
+        sanitizedSource = sanitizeJsxChildren(source);
+    }
+    else {
+        sanitizedSource = source;
+    }
+    var sanitizedData = __assign(__assign(__assign(__assign({ source: sanitizedSource }, (id && { id: id })), (context && { context: context })), (maxChars != null && { maxChars: Math.abs(maxChars) })), (dataFormat && { dataFormat: dataFormat }));
+    var stringifiedData = stringify(sanitizedData);
+    return hashFunction(stringifiedData);
+}
+/**
+ * Sanitizes a child object by removing the data-_gt attribute and its branches.
+ *
+ * @param child - The child object to sanitize.
+ * @returns The sanitized child object.
+ *
+ */
+var sanitizeChild = function (child) {
+    if (child && typeof child === 'object') {
+        var newChild = {};
+        if ('c' in child && child.c) {
+            newChild.c = sanitizeJsxChildren(child.c);
+        }
+        if ('d' in child) {
+            var generaltranslation = child === null || child === void 0 ? void 0 : child.d;
+            if (generaltranslation === null || generaltranslation === void 0 ? void 0 : generaltranslation.b) {
+                // The only thing that prevents sanitizeJsx from being stable is
+                // the order of the keys in the branches object.
+                // We don't sort them because stable-stringify sorts them anyways
+                newChild.b = Object.fromEntries(Object.entries(generaltranslation.b).map(function (_a) {
+                    var key = _a[0], value = _a[1];
+                    return [
+                        key,
+                        sanitizeJsxChildren(value),
+                    ];
+                }));
+            }
+            if (generaltranslation === null || generaltranslation === void 0 ? void 0 : generaltranslation.t) {
+                newChild.t = generaltranslation.t;
+            }
+        }
+        if (isVariable(child)) {
+            return __assign({ k: child.k }, (child.v && {
+                v: child.v,
+            }));
+        }
+        return newChild;
+    }
+    return child;
+};
+function sanitizeJsxChildren(childrenAsObjects) {
+    return Array.isArray(childrenAsObjects)
+        ? childrenAsObjects.map(sanitizeChild)
+        : sanitizeChild(childrenAsObjects);
+}

package/dist/id/hashTemplate.d.ts

@@ -0,0 +1,4 @@
+import { hashString } from './hashSource';
+export default function hashTemplate(template: {
+    [key: string]: string;
+}, hashFunction?: typeof hashString): string;

package/dist/id/hashTemplate.js

@@ -0,0 +1,6 @@
+import { hashString } from './hashSource';
+import { stableStringify as stringify } from '../utils/stableStringify';
+export default function hashTemplate(template, hashFunction) {
+    if (hashFunction === void 0) { hashFunction = hashString; }
+    return hashFunction(stringify(template));
+}

package/dist/id/types.d.ts

@@ -0,0 +1,7 @@
+import { DataFormat } from '../types-dir/jsx/content';
+export type HashMetadata = {
+    context?: string;
+    id?: string;
+    maxChars?: number;
+    dataFormat?: DataFormat;
+};

package/dist/id/types.js

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

package/dist/id.d.cts

@@ -1,4 +1,4 @@
-import { Tt as JsxChildren, ut as HashMetadata } from "./types-V5rqd1WR.cjs";
+import { Ot as JsxChildren, pt as HashMetadata } from "./types-Bf8_Apq_.cjs";
 
 //#region src/id/hashSource.d.ts
 /**

package/dist/id.d.mts

@@ -1,4 +1,4 @@
-import { Tt as JsxChildren, ut as HashMetadata } from "./types-BsGsgJWF.mjs";
+import { Ot as JsxChildren, pt as HashMetadata } from "./types-AHtYZIP-.mjs";
 
 //#region src/id/hashSource.d.ts
 /**

package/dist/id.d.ts

@@ -0,0 +1,3 @@
+import { hashSource, hashString } from './id/hashSource';
+import hashTemplate from './id/hashTemplate';
+export { hashSource, hashString, hashTemplate };