generaltranslation 8.2.8 → 8.2.10

package/dist/core-DtPj_ruw.d.mts

@@ -0,0 +1,209 @@
+import { Dt as StringFormat, Mt as CustomMapping, jt as LocaleProperties, n as FormatVariables } from "./types-Dfy_sRLD.mjs";
+
+//#region src/formatting/custom-formats/CutoffFormat/types.d.ts
+/** Type of terminator */
+type CutoffFormatStyle = 'none' | 'ellipsis';
+/** Terminator options */
+interface TerminatorOptions {
+  /** The terminator to use */
+  terminator?: string;
+  /** An optional separator between the terminator and the value */
+  separator?: string;
+}
+/** Input formatting options (for constructor) */
+interface CutoffFormatOptions extends TerminatorOptions {
+  /** Cutoff length */
+  maxChars?: number;
+  /** Type of terminator */
+  style?: CutoffFormatStyle;
+}
+//#endregion
+//#region src/LocaleConfig.d.ts
+type LocaleConfigConstructorParams = {
+  defaultLocale?: string;
+  locales?: string[];
+  customMapping?: CustomMapping;
+};
+type LocalesOption = {
+  locales?: string | string[];
+};
+type WithLocales<T = object> = T & LocalesOption;
+/**
+ * LocaleConfig contains the locale and formatting primitives exposed through
+ * the core entrypoint.
+ *
+ * It intentionally does not store project IDs, API keys, runtime URLs, or any
+ * translation credentials. It only stores locale metadata needed to resolve
+ * aliases, choose formatting fallbacks, and format values with Intl.
+ */
+declare class LocaleConfig {
+  readonly defaultLocale: string;
+  readonly locales: string[];
+  readonly customMapping?: CustomMapping;
+  constructor({
+    defaultLocale,
+    locales,
+    customMapping
+  }?: LocaleConfigConstructorParams);
+  private get translationLocales();
+  private resolveCanonicalLocaleList;
+  private resolveCanonicalLocaleArgs;
+  private toLocaleList;
+  private getFormattingLocales;
+  formatNum(value: number, targetLocale?: string, options?: WithLocales<Intl.NumberFormatOptions>): string;
+  formatDateTime(value: Date, targetLocale?: string, options?: WithLocales<Intl.DateTimeFormatOptions>): string;
+  formatCurrency(value: number, currency: string, targetLocale?: string, options?: WithLocales<Intl.NumberFormatOptions>): string;
+  formatRelativeTime(value: number, unit: Intl.RelativeTimeFormatUnit, targetLocale?: string, options?: WithLocales<Intl.RelativeTimeFormatOptions>): string;
+  formatRelativeTimeFromDate(date: Date, targetLocale?: string, options?: WithLocales<Intl.RelativeTimeFormatOptions & {
+    baseDate?: Date;
+  }>): string;
+  formatCutoff(value: string, targetLocale?: string, options?: WithLocales<CutoffFormatOptions>): string;
+  formatMessage(message: string, targetLocale?: string, options?: WithLocales<{
+    variables?: FormatVariables;
+    dataFormat?: StringFormat;
+  }>): string;
+  formatList(array: Array<string | number>, targetLocale?: string, options?: WithLocales<Intl.ListFormatOptions>): string;
+  formatListToParts<T>(array: Array<T>, targetLocale?: string, options?: WithLocales<Intl.ListFormatOptions>): (string | T)[];
+  getLocaleName(locale: string): string;
+  getLocaleEmoji(locale: string): string;
+  getLocaleProperties(locale: string): LocaleProperties;
+  requiresTranslation(targetLocale: string, sourceLocale?: string, approvedLocales?: string[] | undefined): boolean;
+  determineLocale(locales: string | string[], approvedLocales?: string[]): string | undefined;
+  getLocaleDirection(locale: string): "ltr" | "rtl";
+  isValidLocale(locale: string): boolean;
+  resolveCanonicalLocale(locale: string): string;
+  resolveAliasLocale(locale: string): string;
+  standardizeLocale(locale: string): string;
+  isSameDialect(...locales: (string | string[])[]): boolean;
+  isSameLanguage(...locales: (string | string[])[]): boolean;
+  isSupersetLocale(superLocale: string, subLocale: string): boolean;
+}
+//#endregion
+//#region src/core.d.ts
+/**
+ * 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 …'
+ */
+declare function formatCutoff(value: string, options?: {
+  locales?: string | string[];
+} & CutoffFormatOptions): string;
+/**
+ * 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' }
+ * });
+ */
+declare function formatMessage(message: string, options?: {
+  locales?: string | string[];
+  variables?: FormatVariables;
+  dataFormat?: StringFormat;
+}): string;
+/**
+ * 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
+ */
+declare function isValidLocale(locale: string, customMapping?: CustomMapping): boolean;
+/**
+ * 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.
+ *
+ * @example
+ * resolveCanonicalLocale('en-US');
+ * // Returns: 'en-US'
+ *
+ * @example
+ * resolveCanonicalLocale('en', { en: 'en-US' });
+ * // Returns: 'en-US'
+ */
+declare function resolveCanonicalLocale(locale: string, customMapping?: CustomMapping): string;
+/**
+ * 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 an empty string if it is an invalid code.
+ *
+ * @example
+ * standardizeLocale('en-us');
+ * // Returns: 'en-US'
+ *
+ * @example
+ * standardizeLocale('not a locale');
+ * // Returns: ''
+ */
+declare function standardizeLocale(locale: string): string;
+//#endregion
+export { standardizeLocale as a, CutoffFormatOptions as c, resolveCanonicalLocale as i, formatMessage as n, LocaleConfig as o, isValidLocale as r, LocaleConfigConstructorParams as s, formatCutoff as t };
+//# sourceMappingURL=core-DtPj_ruw.d.mts.map

package/dist/core.cjs

@@ -0,0 +1,8 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_core = require("./core-3SOQ5ND6.cjs");
+exports.LocaleConfig = require_core.LocaleConfig;
+exports.formatCutoff = require_core.formatCutoff;
+exports.formatMessage = require_core.formatMessage;
+exports.isValidLocale = require_core.isValidLocale;
+exports.resolveCanonicalLocale = require_core.resolveCanonicalLocale;
+exports.standardizeLocale = require_core.standardizeLocale;

package/dist/core.d.cts

@@ -0,0 +1,2 @@
+import { a as standardizeLocale, i as resolveCanonicalLocale, n as formatMessage, o as LocaleConfig, r as isValidLocale, s as LocaleConfigConstructorParams, t as formatCutoff } from "./core-CJMv4fMa.cjs";
+export { LocaleConfig, LocaleConfigConstructorParams, formatCutoff, formatMessage, isValidLocale, resolveCanonicalLocale, standardizeLocale };

package/dist/core.d.mts

@@ -0,0 +1,2 @@
+import { a as standardizeLocale, i as resolveCanonicalLocale, n as formatMessage, o as LocaleConfig, r as isValidLocale, s as LocaleConfigConstructorParams, t as formatCutoff } from "./core-DtPj_ruw.mjs";
+export { LocaleConfig, LocaleConfigConstructorParams, formatCutoff, formatMessage, isValidLocale, resolveCanonicalLocale, standardizeLocale };

package/dist/core.mjs

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

package/dist/errors.cjs

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

package/dist/errors.mjs

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

package/dist/{id-CPbVYREY.mjs → id-BmOyfaug.mjs}

@@ -1,4 +1,4 @@
-import { n as isVariable, t as stableStringify } from "./stableStringify-DgDlE_pD.mjs";
+import { n as stableStringify, t as isVariable } from "./isVariable-CYsKFHvR.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-CPbVYREY.mjs.map
+//# sourceMappingURL=id-BmOyfaug.mjs.map

package/dist/{id-CPbVYREY.mjs.map → id-BmOyfaug.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"id-CPbVYREY.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 sha256.\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 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 has 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-BmOyfaug.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 sha256.\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 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 has 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-VXBgyXu2.cjs → id-COlX5v3V.cjs}

@@ -1,4 +1,4 @@
-const require_sha2 = require("./sha2-DKowBr6H.cjs");
+const require_isVariable = require("./isVariable-B08mggBy.cjs");
 //#region src/id/hashSource.ts
 /**
 * Calculates a unique hash for a given string using sha256.
@@ -9,7 +9,7 @@ const require_sha2 = require("./sha2-DKowBr6H.cjs");
 * @returns {string} - The resulting hash as a hexadecimal string.
 */
 function hashString(string) {
-	return require_sha2.bytesToHex(require_sha2.sha256(require_sha2.utf8ToBytes(string))).slice(0, 16);
+	return require_isVariable.bytesToHex(require_isVariable.sha256(require_isVariable.utf8ToBytes(string))).slice(0, 16);
 }
 /**
 * Calculates a unique ID for the given children objects by hashing their sanitized JSON string representation.
@@ -26,7 +26,7 @@ function hashSource({ source, context, id, maxChars, dataFormat }, hashFunction
 	let sanitizedSource;
 	if (dataFormat === "JSX") sanitizedSource = sanitizeJsxChildren(source);
 	else sanitizedSource = source;
-	return hashFunction(require_sha2.stableStringify({
+	return hashFunction(require_isVariable.stableStringify({
 		source: sanitizedSource,
 		...id && { id },
 		...context && { context },
@@ -50,7 +50,7 @@ const sanitizeChild = (child) => {
 			if (generaltranslation?.b) newChild.b = Object.fromEntries(Object.entries(generaltranslation.b).map(([key, value]) => [key, sanitizeJsxChildren(value)]));
 			if (generaltranslation?.t) newChild.t = generaltranslation.t;
 		}
-		if (require_sha2.isVariable(child)) return {
+		if (require_isVariable.isVariable(child)) return {
 			k: child.k,
 			...child.v && { v: child.v }
 		};
@@ -64,7 +64,7 @@ function sanitizeJsxChildren(childrenAsObjects) {
 //#endregion
 //#region src/id/hashTemplate.ts
 function hashTemplate(template, hashFunction = hashString) {
-	return hashFunction(require_sha2.stableStringify(template));
+	return hashFunction(require_isVariable.stableStringify(template));
 }
 //#endregion
 Object.defineProperty(exports, "hashSource", {
@@ -86,4 +86,4 @@ Object.defineProperty(exports, "hashTemplate", {
 	}
 });
 
-//# sourceMappingURL=id-VXBgyXu2.cjs.map
+//# sourceMappingURL=id-COlX5v3V.cjs.map

package/dist/{id-VXBgyXu2.cjs.map → id-COlX5v3V.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"id-VXBgyXu2.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 sha256.\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 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 has 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,aAAAA,WAAWC,aAAAA,OAAOC,aAAAA,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,aAAAA,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,aAAAA,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,aAAAA,gBAAU,SAAS,CAAC"}
+{"version":3,"file":"id-COlX5v3V.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 sha256.\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 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 has 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.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_id = require("./id-VXBgyXu2.cjs");
+const require_id = require("./id-COlX5v3V.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 { ut as HashMetadata, wt as JsxChildren } from "./types-BJdoI1d1.cjs";
+import { ut as HashMetadata, wt as JsxChildren } from "./types-mZeu4HS3.cjs";
 
 //#region src/id/hashSource.d.ts
 /**

package/dist/id.d.mts

@@ -1,4 +1,4 @@
-import { ut as HashMetadata, wt as JsxChildren } from "./types-DazaDJbs.mjs";
+import { ut as HashMetadata, wt as JsxChildren } from "./types-Dfy_sRLD.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-CPbVYREY.mjs";
+import { n as hashSource, r as hashString, t as hashTemplate } from "./id-BmOyfaug.mjs";
 export { hashSource, hashString, hashTemplate };