generaltranslation 8.2.13 → 8.2.14

package/dist/core.js

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

package/dist/core.mjs

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

package/dist/derive/indexVars.d.ts

@@ -1,4 +1,4 @@
-import { IcuMessage } from '../types-dir/jsx/content';
+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'

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

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

package/dist/id/types.d.ts

@@ -1,4 +1,4 @@
-import { DataFormat } from '../types-dir/jsx/content';
+import type { DataFormat } from '@generaltranslation/format/types';
 export type HashMetadata = {
     context?: string;
     id?: string;

package/dist/{id-CyiXsQrY.cjs → id-C2orn1MA.cjs}

@@ -1,4 +1,4 @@
-const require_isVariable = require("./isVariable-B08mggBy.cjs");
+const require_isVariable = require("./isVariable-Ba1gLXdB.cjs");
 //#region src/id/hashSource.ts
 /**
 * Calculates a unique hash for a given string using SHA-256.
@@ -86,4 +86,4 @@ Object.defineProperty(exports, "hashTemplate", {
 	}
 });
 
-//# sourceMappingURL=id-CyiXsQrY.cjs.map
+//# sourceMappingURL=id-C2orn1MA.cjs.map

package/dist/{id-CyiXsQrY.cjs.map → id-C2orn1MA.cjs.map}

@@ -1 +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"}
+{"version":3,"file":"id-C2orn1MA.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-DbD7K-HL.mjs → id-DEaFhGqX.mjs}

@@ -1,4 +1,4 @@
-import { n as stableStringify, t as isVariable } from "./isVariable-CYsKFHvR.mjs";
+import { n as stableStringify, t as isVariable } from "./isVariable-fAKEB7gF.mjs";
 import { sha256 } from "@noble/hashes/sha2.js";
 import { bytesToHex, utf8ToBytes } from "@noble/hashes/utils.js";
 //#region src/id/hashSource.ts
@@ -71,4 +71,4 @@ function hashTemplate(template, hashFunction = hashString) {
 //#endregion
 export { hashSource as n, hashString as r, hashTemplate as t };
 
-//# sourceMappingURL=id-DbD7K-HL.mjs.map
+//# sourceMappingURL=id-DEaFhGqX.mjs.map

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

@@ -1 +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"}
+{"version":3,"file":"id-DEaFhGqX.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-CyiXsQrY.cjs");
+const require_id = require("./id-C2orn1MA.cjs");
 exports.hashSource = require_id.hashSource;
 exports.hashString = require_id.hashString;
 exports.hashTemplate = require_id.hashTemplate;

package/dist/id.d.cts

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

package/dist/id.d.mts

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

package/dist/id.mjs

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