generaltranslation 8.2.11 → 8.2.13

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-COlX5v3V.cjs → id-CyiXsQrY.cjs}

@@ -1,12 +1,12 @@
 const require_isVariable = require("./isVariable-B08mggBy.cjs");
 //#region src/id/hashSource.ts
 /**
-* Calculates a unique hash for a given string using sha256.
+* 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.
+* @returns {string} The resulting hash as a hexadecimal string.
 */
 function hashString(string) {
 	return require_isVariable.bytesToHex(require_isVariable.sha256(require_isVariable.utf8ToBytes(string))).slice(0, 16);
@@ -15,12 +15,12 @@ function hashString(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 for the JSX Children object
-* @param {string} [dataFormat] - The data format of the sources
-* @param {function} [hashFunction] custom hash function
-* @returns {string} - The unique has of the children.
+* @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.
 */
 function hashSource({ source, context, id, maxChars, dataFormat }, hashFunction = hashString) {
 	let sanitizedSource;
@@ -86,4 +86,4 @@ Object.defineProperty(exports, "hashTemplate", {
 	}
 });
 
-//# sourceMappingURL=id-COlX5v3V.cjs.map
+//# sourceMappingURL=id-CyiXsQrY.cjs.map

package/dist/id-CyiXsQrY.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"id-CyiXsQrY.cjs","names":["bytesToHex","sha256","utf8ToBytes","stringify","isVariable","stringify"],"sources":["../src/id/hashSource.ts","../src/id/hashTemplate.ts"],"sourcesContent":["// Functions provided to other GT libraries\n\nimport { JsxChild, JsxChildren, Variable } from '../types';\nimport { stableStringify as stringify } from '../utils/stableStringify';\nimport { sha256 } from '@noble/hashes/sha2.js';\nimport { bytesToHex, utf8ToBytes } from '@noble/hashes/utils.js';\nimport isVariable from '../utils/isVariable';\nimport { HashMetadata } from './types';\n\n// ----- FUNCTIONS ----- //\n/**\n * Calculates a unique hash for a given string using SHA-256.\n *\n * First 16 characters of hash, hex encoded.\n *\n * @param {string} string - The string to be hashed.\n * @returns {string} The resulting hash as a hexadecimal string.\n */\nexport function hashString(string: string): string {\n  return bytesToHex(sha256(utf8ToBytes(string))).slice(0, 16);\n}\n\n/**\n * Calculates a unique ID for the given children objects by hashing their sanitized JSON string representation.\n *\n * @param {any} childrenAsObjects - The children objects to be hashed.\n * @param {string} [context] - The context for the children.\n * @param {string} [id] - The ID for the JSX children object.\n * @param {number} [maxChars] - The maxChars limit for the JSX children object.\n * @param {string} [dataFormat] - The data format of the sources.\n * @param {function} [hashFunction] - Custom hash function.\n * @returns {string} - The unique hash of the children.\n */\nexport function hashSource(\n  {\n    source,\n    context,\n    id,\n    maxChars,\n    dataFormat,\n  }: {\n    source: JsxChildren | string;\n  } & HashMetadata,\n  hashFunction: (string: string) => string = hashString\n): string {\n  let sanitizedSource: SanitizedChildren | string;\n  if (dataFormat === 'JSX') {\n    sanitizedSource = sanitizeJsxChildren(source);\n  } else {\n    sanitizedSource = source as string;\n  }\n  const sanitizedData: {\n    source?: SanitizedChildren;\n  } & HashMetadata = {\n    source: sanitizedSource,\n    ...(id && { id }),\n    ...(context && { context }),\n    ...(maxChars != null && { maxChars: Math.abs(maxChars) }),\n    ...(dataFormat && { dataFormat }),\n  };\n  const stringifiedData = stringify(sanitizedData);\n  return hashFunction(stringifiedData);\n}\n\ntype SanitizedVariable = Omit<Variable, 'i'>;\n\ntype SanitizedElement = {\n  b?: {\n    [k: string]: SanitizedChildren; // Branches\n  };\n  c?: SanitizedChildren; // Children\n  t?: string; // Branch Transformation\n};\ntype SanitizedChild = SanitizedElement | SanitizedVariable | string;\ntype SanitizedChildren = SanitizedChild | SanitizedChild[];\n\n/**\n * Sanitizes a child object by removing the data-_gt attribute and its branches.\n *\n * @param child - The child object to sanitize.\n * @returns The sanitized child object.\n *\n */\nconst sanitizeChild = (child: JsxChild): SanitizedChild => {\n  if (child && typeof child === 'object') {\n    const newChild: SanitizedChild = {};\n    if ('c' in child && child.c) {\n      newChild.c = sanitizeJsxChildren(child.c);\n    }\n    if ('d' in child) {\n      const generaltranslation = child?.d;\n      if (generaltranslation?.b) {\n        // The only thing that prevents sanitizeJsx from being stable is\n        // the order of the keys in the branches object.\n        // We don't sort them because stable-stringify sorts them anyways\n        newChild.b = Object.fromEntries(\n          Object.entries(generaltranslation.b).map(([key, value]) => [\n            key,\n            sanitizeJsxChildren(value as JsxChildren),\n          ])\n        );\n      }\n      if (generaltranslation?.t) {\n        newChild.t = generaltranslation.t;\n      }\n    }\n    if (isVariable(child)) {\n      return {\n        k: child.k,\n        ...(child.v && {\n          v: child.v,\n        }),\n      };\n    }\n    return newChild;\n  }\n  return child;\n};\n\nfunction sanitizeJsxChildren(\n  childrenAsObjects: JsxChildren\n): SanitizedChildren {\n  return Array.isArray(childrenAsObjects)\n    ? childrenAsObjects.map(sanitizeChild)\n    : sanitizeChild(childrenAsObjects);\n}\n","import { hashString } from './hashSource';\nimport { stableStringify as stringify } from '../utils/stableStringify';\n\nexport default function hashTemplate(\n  template: {\n    [key: string]: string;\n  },\n  hashFunction = hashString\n): string {\n  return hashFunction(stringify(template));\n}\n"],"mappings":";;;;;;;;;;AAkBA,SAAgB,WAAW,QAAwB;AACjD,QAAOA,mBAAAA,WAAWC,mBAAAA,OAAOC,mBAAAA,YAAY,OAAO,CAAC,CAAC,CAAC,MAAM,GAAG,GAAG;;;;;;;;;;;;;AAc7D,SAAgB,WACd,EACE,QACA,SACA,IACA,UACA,cAIF,eAA2C,YACnC;CACR,IAAI;AACJ,KAAI,eAAe,MACjB,mBAAkB,oBAAoB,OAAO;KAE7C,mBAAkB;AAYpB,QAAO,aADiBC,mBAAAA,gBAAU;EANhC,QAAQ;EACR,GAAI,MAAM,EAAE,IAAI;EAChB,GAAI,WAAW,EAAE,SAAS;EAC1B,GAAI,YAAY,QAAQ,EAAE,UAAU,KAAK,IAAI,SAAS,EAAE;EACxD,GAAI,cAAc,EAAE,YAAY;EAEa,CACZ,CAAC;;;;;;;;;AAsBtC,MAAM,iBAAiB,UAAoC;AACzD,KAAI,SAAS,OAAO,UAAU,UAAU;EACtC,MAAM,WAA2B,EAAE;AACnC,MAAI,OAAO,SAAS,MAAM,EACxB,UAAS,IAAI,oBAAoB,MAAM,EAAE;AAE3C,MAAI,OAAO,OAAO;GAChB,MAAM,qBAAqB,OAAO;AAClC,OAAI,oBAAoB,EAItB,UAAS,IAAI,OAAO,YAClB,OAAO,QAAQ,mBAAmB,EAAE,CAAC,KAAK,CAAC,KAAK,WAAW,CACzD,KACA,oBAAoB,MAAqB,CAC1C,CAAC,CACH;AAEH,OAAI,oBAAoB,EACtB,UAAS,IAAI,mBAAmB;;AAGpC,MAAIC,mBAAAA,WAAW,MAAM,CACnB,QAAO;GACL,GAAG,MAAM;GACT,GAAI,MAAM,KAAK,EACb,GAAG,MAAM,GACV;GACF;AAEH,SAAO;;AAET,QAAO;;AAGT,SAAS,oBACP,mBACmB;AACnB,QAAO,MAAM,QAAQ,kBAAkB,GACnC,kBAAkB,IAAI,cAAc,GACpC,cAAc,kBAAkB;;;;ACzHtC,SAAwB,aACtB,UAGA,eAAe,YACP;AACR,QAAO,aAAaC,mBAAAA,gBAAU,SAAS,CAAC"}

package/dist/{id-BmOyfaug.mjs → id-DbD7K-HL.mjs}

@@ -3,12 +3,12 @@ import { sha256 } from "@noble/hashes/sha2.js";
 import { bytesToHex, utf8ToBytes } from "@noble/hashes/utils.js";
 //#region src/id/hashSource.ts
 /**
-* Calculates a unique hash for a given string using sha256.
+* 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.
+* @returns {string} The resulting hash as a hexadecimal string.
 */
 function hashString(string) {
 	return bytesToHex(sha256(utf8ToBytes(string))).slice(0, 16);
@@ -17,12 +17,12 @@ function hashString(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 for the JSX Children object
-* @param {string} [dataFormat] - The data format of the sources
-* @param {function} [hashFunction] custom hash function
-* @returns {string} - The unique has of the children.
+* @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.
 */
 function hashSource({ source, context, id, maxChars, dataFormat }, hashFunction = hashString) {
 	let sanitizedSource;
@@ -71,4 +71,4 @@ function hashTemplate(template, hashFunction = hashString) {
 //#endregion
 export { hashSource as n, hashString as r, hashTemplate as t };
 
-//# sourceMappingURL=id-BmOyfaug.mjs.map
+//# sourceMappingURL=id-DbD7K-HL.mjs.map

package/dist/id-DbD7K-HL.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"id-DbD7K-HL.mjs","names":["stringify","stringify"],"sources":["../src/id/hashSource.ts","../src/id/hashTemplate.ts"],"sourcesContent":["// Functions provided to other GT libraries\n\nimport { JsxChild, JsxChildren, Variable } from '../types';\nimport { stableStringify as stringify } from '../utils/stableStringify';\nimport { sha256 } from '@noble/hashes/sha2.js';\nimport { bytesToHex, utf8ToBytes } from '@noble/hashes/utils.js';\nimport isVariable from '../utils/isVariable';\nimport { HashMetadata } from './types';\n\n// ----- FUNCTIONS ----- //\n/**\n * Calculates a unique hash for a given string using SHA-256.\n *\n * First 16 characters of hash, hex encoded.\n *\n * @param {string} string - The string to be hashed.\n * @returns {string} The resulting hash as a hexadecimal string.\n */\nexport function hashString(string: string): string {\n  return bytesToHex(sha256(utf8ToBytes(string))).slice(0, 16);\n}\n\n/**\n * Calculates a unique ID for the given children objects by hashing their sanitized JSON string representation.\n *\n * @param {any} childrenAsObjects - The children objects to be hashed.\n * @param {string} [context] - The context for the children.\n * @param {string} [id] - The ID for the JSX children object.\n * @param {number} [maxChars] - The maxChars limit for the JSX children object.\n * @param {string} [dataFormat] - The data format of the sources.\n * @param {function} [hashFunction] - Custom hash function.\n * @returns {string} - The unique hash of the children.\n */\nexport function hashSource(\n  {\n    source,\n    context,\n    id,\n    maxChars,\n    dataFormat,\n  }: {\n    source: JsxChildren | string;\n  } & HashMetadata,\n  hashFunction: (string: string) => string = hashString\n): string {\n  let sanitizedSource: SanitizedChildren | string;\n  if (dataFormat === 'JSX') {\n    sanitizedSource = sanitizeJsxChildren(source);\n  } else {\n    sanitizedSource = source as string;\n  }\n  const sanitizedData: {\n    source?: SanitizedChildren;\n  } & HashMetadata = {\n    source: sanitizedSource,\n    ...(id && { id }),\n    ...(context && { context }),\n    ...(maxChars != null && { maxChars: Math.abs(maxChars) }),\n    ...(dataFormat && { dataFormat }),\n  };\n  const stringifiedData = stringify(sanitizedData);\n  return hashFunction(stringifiedData);\n}\n\ntype SanitizedVariable = Omit<Variable, 'i'>;\n\ntype SanitizedElement = {\n  b?: {\n    [k: string]: SanitizedChildren; // Branches\n  };\n  c?: SanitizedChildren; // Children\n  t?: string; // Branch Transformation\n};\ntype SanitizedChild = SanitizedElement | SanitizedVariable | string;\ntype SanitizedChildren = SanitizedChild | SanitizedChild[];\n\n/**\n * Sanitizes a child object by removing the data-_gt attribute and its branches.\n *\n * @param child - The child object to sanitize.\n * @returns The sanitized child object.\n *\n */\nconst sanitizeChild = (child: JsxChild): SanitizedChild => {\n  if (child && typeof child === 'object') {\n    const newChild: SanitizedChild = {};\n    if ('c' in child && child.c) {\n      newChild.c = sanitizeJsxChildren(child.c);\n    }\n    if ('d' in child) {\n      const generaltranslation = child?.d;\n      if (generaltranslation?.b) {\n        // The only thing that prevents sanitizeJsx from being stable is\n        // the order of the keys in the branches object.\n        // We don't sort them because stable-stringify sorts them anyways\n        newChild.b = Object.fromEntries(\n          Object.entries(generaltranslation.b).map(([key, value]) => [\n            key,\n            sanitizeJsxChildren(value as JsxChildren),\n          ])\n        );\n      }\n      if (generaltranslation?.t) {\n        newChild.t = generaltranslation.t;\n      }\n    }\n    if (isVariable(child)) {\n      return {\n        k: child.k,\n        ...(child.v && {\n          v: child.v,\n        }),\n      };\n    }\n    return newChild;\n  }\n  return child;\n};\n\nfunction sanitizeJsxChildren(\n  childrenAsObjects: JsxChildren\n): SanitizedChildren {\n  return Array.isArray(childrenAsObjects)\n    ? childrenAsObjects.map(sanitizeChild)\n    : sanitizeChild(childrenAsObjects);\n}\n","import { hashString } from './hashSource';\nimport { stableStringify as stringify } from '../utils/stableStringify';\n\nexport default function hashTemplate(\n  template: {\n    [key: string]: string;\n  },\n  hashFunction = hashString\n): string {\n  return hashFunction(stringify(template));\n}\n"],"mappings":";;;;;;;;;;;;AAkBA,SAAgB,WAAW,QAAwB;AACjD,QAAO,WAAW,OAAO,YAAY,OAAO,CAAC,CAAC,CAAC,MAAM,GAAG,GAAG;;;;;;;;;;;;;AAc7D,SAAgB,WACd,EACE,QACA,SACA,IACA,UACA,cAIF,eAA2C,YACnC;CACR,IAAI;AACJ,KAAI,eAAe,MACjB,mBAAkB,oBAAoB,OAAO;KAE7C,mBAAkB;AAYpB,QAAO,aADiBA,gBAAU;EANhC,QAAQ;EACR,GAAI,MAAM,EAAE,IAAI;EAChB,GAAI,WAAW,EAAE,SAAS;EAC1B,GAAI,YAAY,QAAQ,EAAE,UAAU,KAAK,IAAI,SAAS,EAAE;EACxD,GAAI,cAAc,EAAE,YAAY;EAEa,CACZ,CAAC;;;;;;;;;AAsBtC,MAAM,iBAAiB,UAAoC;AACzD,KAAI,SAAS,OAAO,UAAU,UAAU;EACtC,MAAM,WAA2B,EAAE;AACnC,MAAI,OAAO,SAAS,MAAM,EACxB,UAAS,IAAI,oBAAoB,MAAM,EAAE;AAE3C,MAAI,OAAO,OAAO;GAChB,MAAM,qBAAqB,OAAO;AAClC,OAAI,oBAAoB,EAItB,UAAS,IAAI,OAAO,YAClB,OAAO,QAAQ,mBAAmB,EAAE,CAAC,KAAK,CAAC,KAAK,WAAW,CACzD,KACA,oBAAoB,MAAqB,CAC1C,CAAC,CACH;AAEH,OAAI,oBAAoB,EACtB,UAAS,IAAI,mBAAmB;;AAGpC,MAAI,WAAW,MAAM,CACnB,QAAO;GACL,GAAG,MAAM;GACT,GAAI,MAAM,KAAK,EACb,GAAG,MAAM,GACV;GACF;AAEH,SAAO;;AAET,QAAO;;AAGT,SAAS,oBACP,mBACmB;AACnB,QAAO,MAAM,QAAQ,kBAAkB,GACnC,kBAAkB,IAAI,cAAc,GACpC,cAAc,kBAAkB;;;;ACzHtC,SAAwB,aACtB,UAGA,eAAe,YACP;AACR,QAAO,aAAaC,gBAAU,SAAS,CAAC"}

package/dist/id.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_id = require("./id-COlX5v3V.cjs");
+const require_id = require("./id-CyiXsQrY.cjs");
 exports.hashSource = require_id.hashSource;
 exports.hashString = require_id.hashString;
 exports.hashTemplate = require_id.hashTemplate;

package/dist/id.d.cts

@@ -1,25 +1,25 @@
-import { Tt as JsxChildren, ut as HashMetadata } from "./types-NKhpChvT.cjs";
+import { Ot as JsxChildren, pt as HashMetadata } from "./types-Bf8_Apq_.cjs";
 
 //#region src/id/hashSource.d.ts
 /**
- * Calculates a unique hash for a given string using sha256.
+ * 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.
+ * @returns {string} The resulting hash as a hexadecimal string.
  */
 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 for the JSX Children object
- * @param {string} [dataFormat] - The data format of the sources
- * @param {function} [hashFunction] custom hash function
- * @returns {string} - The unique has of the children.
+ * @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.
  */
 declare function hashSource({
   source,

package/dist/id.d.mts

@@ -1,25 +1,25 @@
-import { Tt as JsxChildren, ut as HashMetadata } from "./types-Cy8q2XZX.mjs";
+import { Ot as JsxChildren, pt as HashMetadata } from "./types-AHtYZIP-.mjs";
 
 //#region src/id/hashSource.d.ts
 /**
- * Calculates a unique hash for a given string using sha256.
+ * 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.
+ * @returns {string} The resulting hash as a hexadecimal string.
  */
 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 for the JSX Children object
- * @param {string} [dataFormat] - The data format of the sources
- * @param {function} [hashFunction] custom hash function
- * @returns {string} - The unique has of the children.
+ * @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.
  */
 declare function hashSource({
   source,

package/dist/id.d.ts

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

package/dist/id.js

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

package/dist/id.mjs

@@ -1,2 +1,2 @@
-import { n as hashSource, r as hashString, t as hashTemplate } from "./id-BmOyfaug.mjs";
+import { n as hashSource, r as hashString, t as hashTemplate } from "./id-DbD7K-HL.mjs";
 export { hashSource, hashString, hashTemplate };