@ryuzaki13/react-foundation-lib 2.10.1 → 2.11.0

package/dist/decimal/index.d.ts

@@ -4,6 +4,7 @@ export { compareDecimals } from "./compareDecimals";
 export { isCanonicalDecimal } from "./isCanonicalDecimal";
 export { multiplyDecimals } from "./multiplyDecimals";
 export { normalizeDecimal } from "./normalizeDecimal";
+export { normalizeDecimalLiteral } from "./normalizeDecimalLiteral";
 export { subtractDecimals } from "./subtractDecimals";
 export { sumDecimals } from "./sumDecimals";
 export type { DecimalComparison, DecimalOptions, DecimalRatio } from "./types";

package/dist/decimal/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/decimal/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,YAAY,EAAE,iBAAiB,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/decimal/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,YAAY,EAAE,iBAAiB,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC"}

package/dist/decimal/index.js

@@ -86,8 +86,25 @@ function l(e, n) {
 	return i && l !== "0" ? `-${l}` : l;
 }
 //#endregion
+//#region src/decimal/normalizeDecimalLiteral.ts
+function u(e, n) {
+	let r = t(n);
+	if (typeof e != "string" || e.length > r) throw TypeError("Ожидался ограниченный десятичный числовой литерал.");
+	let i = /^(-?)(\d+)(?:\.(\d+))?(?:[eE]([+-]?\d+))?(?![\s\S])/u.exec(e);
+	if (!i) throw TypeError("Ожидался конечный десятичный числовой литерал.");
+	let [, a, o, s = "", c] = i;
+	if (c === void 0) return l(e, n);
+	let u = o + s, d = u.replace(/^0+/u, "");
+	if (!d) return "0";
+	let f = d.replace(/0+$/u, ""), p = Number(c);
+	if (!Number.isSafeInteger(p)) throw RangeError("Экспонента превышает допустимую длину результата.");
+	let m = o.length + p - (u.length - d.length);
+	if (a.length + (m <= 0 ? 2 - m + f.length : Math.max(m, f.length + +(m < f.length))) > r) throw RangeError("Десятичный результат превышает допустимую длину.");
+	return m <= 0 ? `${a}0.${"0".repeat(-m)}${f}` : m >= f.length ? a + f + "0".repeat(m - f.length) : `${a}${f.slice(0, m)}.${f.slice(m)}`;
+}
+//#endregion
 //#region src/decimal/subtractDecimals.ts
-function u(t, n, a) {
+function d(t, n, a) {
 	let o = e(r(t, a), r(n, a));
 	return i({
 		coefficient: o.left - o.right,
@@ -96,13 +113,13 @@ function u(t, n, a) {
 }
 //#endregion
 //#region src/decimal/sumDecimals.ts
-function d(e, n) {
+function f(e, n) {
 	t(n);
 	let r = "0";
 	for (let t of e) r = a(r, t, n);
 	return r;
 }
 //#endregion
-export { a as addDecimals, o as compareDecimalRatios, s as compareDecimals, n as isCanonicalDecimal, c as multiplyDecimals, l as normalizeDecimal, u as subtractDecimals, d as sumDecimals };
+export { a as addDecimals, o as compareDecimalRatios, s as compareDecimals, n as isCanonicalDecimal, c as multiplyDecimals, l as normalizeDecimal, u as normalizeDecimalLiteral, d as subtractDecimals, f as sumDecimals };
 
 //# sourceMappingURL=index.js.map

package/dist/decimal/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../src/decimal/alignDecimalParts.ts","../../src/decimal/resolveDecimalMaxLength.ts","../../src/decimal/isCanonicalDecimal.ts","../../src/decimal/readDecimalParts.ts","../../src/decimal/writeDecimalParts.ts","../../src/decimal/addDecimals.ts","../../src/decimal/compareDecimalRatios.ts","../../src/decimal/compareDecimals.ts","../../src/decimal/multiplyDecimals.ts","../../src/decimal/normalizeDecimal.ts","../../src/decimal/subtractDecimals.ts","../../src/decimal/sumDecimals.ts"],"sourcesContent":["import type { DecimalParts } from \"./types\";\n\n/** Выравнивает только разрядность ограниченных операндов; глобального кеша степеней нет. */\nexport function alignDecimalParts(left: DecimalParts, right: DecimalParts): Readonly<{ left: bigint; right: bigint; scale: number }> {\n\tconst scale = Math.max(left.scale, right.scale);\n\n\treturn {\n\t\tleft: left.coefficient * 10n ** BigInt(scale - left.scale),\n\t\tright: right.coefficient * 10n ** BigInt(scale - right.scale),\n\t\tscale\n\t};\n}\n","import type { DecimalOptions } from \"./types\";\n\n/** Проверяет предел до разбора числа и выделения вычислительных буферов. */\nexport function resolveDecimalMaxLength(options?: DecimalOptions): number {\n\tconst maxLength = options?.maxLength ?? 512;\n\n\tif (!Number.isSafeInteger(maxLength) || maxLength <= 0) {\n\t\tthrow new RangeError(\"Предел длины десятичного значения должен быть положительным безопасным целым числом.\");\n\t}\n\n\treturn maxLength;\n}\n","import { resolveDecimalMaxLength } from \"./resolveDecimalMaxLength\";\n\nimport type { DecimalOptions } from \"./types\";\n\n/** Runtime-проверка для внешних данных без преобразования значащих цифр в number. */\nexport function isCanonicalDecimal(value: unknown, options?: DecimalOptions): value is string {\n\tconst maxLength = resolveDecimalMaxLength(options);\n\n\treturn (\n\t\ttypeof value === \"string\" && value.length <= maxLength && /^(?:0|-?(?:[1-9]\\d*(?:\\.\\d*[1-9])?|0\\.\\d*[1-9]))(?![\\s\\S])/u.test(value)\n\t);\n}\n","import { isCanonicalDecimal } from \"./isCanonicalDecimal\";\n\nimport type { DecimalOptions, DecimalParts } from \"./types\";\n\n/** Арифметика принимает только канонические строки; нормализация принадлежит входной границе. */\nexport function readDecimalParts(value: string, options?: DecimalOptions): DecimalParts {\n\tif (!isCanonicalDecimal(value, options)) {\n\t\tthrow new TypeError(\"Ожидалась каноническая десятичная строка в пределах допустимой длины.\");\n\t}\n\n\tconst point = value.indexOf(\".\");\n\n\treturn {\n\t\tcoefficient: BigInt(value.replace(\".\", \"\")),\n\t\tscale: point === -1 ? 0 : value.length - point - 1\n\t};\n}\n","import { resolveDecimalMaxLength } from \"./resolveDecimalMaxLength\";\n\nimport type { DecimalOptions, DecimalParts } from \"./types\";\n\n/** Канонизирует результат после точного вычисления и отклоняет overflow вместо округления. */\nexport function writeDecimalParts(parts: DecimalParts, options?: DecimalOptions): string {\n\tconst maxLength = resolveDecimalMaxLength(options);\n\n\tif (parts.coefficient === 0n) {\n\t\treturn \"0\";\n\t}\n\n\tconst negative = parts.coefficient < 0n;\n\tconst magnitude = negative ? -parts.coefficient : parts.coefficient;\n\tconst digits = magnitude.toString().padStart(parts.scale + 1, \"0\");\n\tconst point = digits.length - parts.scale;\n\tconst unsigned = parts.scale === 0 ? digits : `${digits.slice(0, point)}.${digits.slice(point)}`.replace(/\\.?0+$/u, \"\");\n\tconst result = negative ? `-${unsigned}` : unsigned;\n\n\tif (result.length > maxLength) {\n\t\tthrow new RangeError(\"Результат десятичного вычисления превысил допустимую длину.\");\n\t}\n\n\treturn result;\n}\n","import { alignDecimalParts } from \"./alignDecimalParts\";\nimport { readDecimalParts } from \"./readDecimalParts\";\nimport { writeDecimalParts } from \"./writeDecimalParts\";\n\nimport type { DecimalOptions } from \"./types\";\n\n/** Складывает значения без IEEE 754 и возвращает каноническую строку. */\nexport function addDecimals(left: string, right: string, options?: DecimalOptions): string {\n\tconst aligned = alignDecimalParts(readDecimalParts(left, options), readDecimalParts(right, options));\n\n\treturn writeDecimalParts({ coefficient: aligned.left + aligned.right, scale: aligned.scale }, options);\n}\n","import { alignDecimalParts } from \"./alignDecimalParts\";\nimport { readDecimalParts } from \"./readDecimalParts\";\n\nimport type { DecimalComparison, DecimalOptions, DecimalRatio } from \"./types\";\n\n/** Сравнивает отношения перекрёстным умножением. Периодическая дробь не делится и не округляется. */\nexport function compareDecimalRatios(left: DecimalRatio, right: DecimalRatio, options?: DecimalOptions): DecimalComparison {\n\tconst leftNumerator = readDecimalParts(left.numerator, options);\n\tconst leftDenominator = readDecimalParts(left.denominator, options);\n\tconst rightNumerator = readDecimalParts(right.numerator, options);\n\tconst rightDenominator = readDecimalParts(right.denominator, options);\n\n\tif (leftDenominator.coefficient <= 0n || rightDenominator.coefficient <= 0n) {\n\t\tthrow new RangeError(\"Знаменатель отношения должен быть строго положительным.\");\n\t}\n\n\t// Произведения приватные: их разрядность ограничена четырьмя проверенными операндами,\n\t// но может превышать длину сериализуемого числа. Проверять их как внешний результат нельзя.\n\tconst aligned = alignDecimalParts(\n\t\t{ coefficient: leftNumerator.coefficient * rightDenominator.coefficient, scale: leftNumerator.scale + rightDenominator.scale },\n\t\t{ coefficient: rightNumerator.coefficient * leftDenominator.coefficient, scale: rightNumerator.scale + leftDenominator.scale }\n\t);\n\n\treturn aligned.left < aligned.right ? -1 : aligned.left > aligned.right ? 1 : 0;\n}\n","import { alignDecimalParts } from \"./alignDecimalParts\";\nimport { readDecimalParts } from \"./readDecimalParts\";\n\nimport type { DecimalComparison, DecimalOptions } from \"./types\";\n\n/** Сравнивает исходные значения, включая разрядность за пределами безопасного number. */\nexport function compareDecimals(left: string, right: string, options?: DecimalOptions): DecimalComparison {\n\tconst aligned = alignDecimalParts(readDecimalParts(left, options), readDecimalParts(right, options));\n\n\treturn aligned.left < aligned.right ? -1 : aligned.left > aligned.right ? 1 : 0;\n}\n","import { readDecimalParts } from \"./readDecimalParts\";\nimport { writeDecimalParts } from \"./writeDecimalParts\";\n\nimport type { DecimalOptions } from \"./types\";\n\n/** Точное умножение не устанавливает фиксированную сетку дробности. */\nexport function multiplyDecimals(left: string, right: string, options?: DecimalOptions): string {\n\tconst first = readDecimalParts(left, options);\n\tconst second = readDecimalParts(right, options);\n\n\treturn writeDecimalParts({ coefficient: first.coefficient * second.coefficient, scale: first.scale + second.scale }, options);\n}\n","import { resolveDecimalMaxLength } from \"./resolveDecimalMaxLength\";\n\nimport type { DecimalOptions } from \"./types\";\n\n/** Убирает лишние нули. Пробелы, запятую, плюс и экспоненту обрабатывает владелец внешнего формата. */\nexport function normalizeDecimal(value: string, options?: DecimalOptions): string {\n\tconst maxLength = resolveDecimalMaxLength(options);\n\n\tif (typeof value !== \"string\" || value.length > maxLength || !/^-?\\d+(?:\\.\\d+)?(?![\\s\\S])/u.test(value)) {\n\t\tthrow new TypeError(\"Ожидалась ограниченная конечная десятичная строка с точкой.\");\n\t}\n\n\tconst negative = value.startsWith(\"-\");\n\tconst unsigned = negative ? value.slice(1) : value;\n\tconst [integer, fraction = \"\"] = unsigned.split(\".\");\n\tconst whole = integer.replace(/^0+(?=\\d)/u, \"\");\n\tconst fractional = fraction.replace(/0+$/u, \"\");\n\tconst magnitude = fractional ? `${whole}.${fractional}` : whole;\n\n\treturn negative && magnitude !== \"0\" ? `-${magnitude}` : magnitude;\n}\n","import { alignDecimalParts } from \"./alignDecimalParts\";\nimport { readDecimalParts } from \"./readDecimalParts\";\nimport { writeDecimalParts } from \"./writeDecimalParts\";\n\nimport type { DecimalOptions } from \"./types\";\n\n/** Сохраняет знак остатка; предметные ограничения отрицательных значений находятся у consumer. */\nexport function subtractDecimals(left: string, right: string, options?: DecimalOptions): string {\n\tconst aligned = alignDecimalParts(readDecimalParts(left, options), readDecimalParts(right, options));\n\n\treturn writeDecimalParts({ coefficient: aligned.left - aligned.right, scale: aligned.scale }, options);\n}\n","import { addDecimals } from \"./addDecimals\";\nimport { resolveDecimalMaxLength } from \"./resolveDecimalMaxLength\";\n\nimport type { DecimalOptions } from \"./types\";\n\n/** Читает iterable один раз и проверяет каждый промежуточный итог; пустой набор даёт ноль. */\nexport function sumDecimals(values: Iterable<string>, options?: DecimalOptions): string {\n\tresolveDecimalMaxLength(options);\n\tlet total = \"0\";\n\n\tfor (const value of values) {\n\t\ttotal = addDecimals(total, value, options);\n\t}\n\n\treturn total;\n}\n"],"mappings":";AAGA,SAAgB,EAAkB,GAAoB,GAA+E;CACpI,IAAM,IAAQ,KAAK,IAAI,EAAK,OAAO,EAAM,KAAK;CAE9C,OAAO;EACN,MAAM,EAAK,cAAc,OAAO,OAAO,IAAQ,EAAK,KAAK;EACzD,OAAO,EAAM,cAAc,OAAO,OAAO,IAAQ,EAAM,KAAK;EAC5D;CACD;AACD;;;ACRA,SAAgB,EAAwB,GAAkC;CACzE,IAAM,IAAY,GAAS,aAAa;CAExC,IAAI,CAAC,OAAO,cAAc,CAAS,KAAK,KAAa,GACpD,MAAU,WAAW,sFAAsF;CAG5G,OAAO;AACR;;;ACNA,SAAgB,EAAmB,GAAgB,GAA2C;CAC7F,IAAM,IAAY,EAAwB,CAAO;CAEjD,OACC,OAAO,KAAU,YAAY,EAAM,UAAU,KAAa,8DAA8D,KAAK,CAAK;AAEpI;;;ACNA,SAAgB,EAAiB,GAAe,GAAwC;CACvF,IAAI,CAAC,EAAmB,GAAO,CAAO,GACrC,MAAU,UAAU,uEAAuE;CAG5F,IAAM,IAAQ,EAAM,QAAQ,GAAG;CAE/B,OAAO;EACN,aAAa,OAAO,EAAM,QAAQ,KAAK,EAAE,CAAC;EAC1C,OAAO,MAAU,KAAK,IAAI,EAAM,SAAS,IAAQ;CAClD;AACD;;;ACXA,SAAgB,EAAkB,GAAqB,GAAkC;CACxF,IAAM,IAAY,EAAwB,CAAO;CAEjD,IAAI,EAAM,gBAAgB,IACzB,OAAO;CAGR,IAAM,IAAW,EAAM,cAAc,IAE/B,KADY,IAAW,CAAC,EAAM,cAAc,EAAM,YAAA,CAC/B,SAAS,CAAC,CAAC,SAAS,EAAM,QAAQ,GAAG,GAAG,GAC3D,IAAQ,EAAO,SAAS,EAAM,OAC9B,IAAW,EAAM,UAAU,IAAI,IAAS,GAAG,EAAO,MAAM,GAAG,CAAK,EAAE,GAAG,EAAO,MAAM,CAAK,IAAI,QAAQ,WAAW,EAAE,GAChH,IAAS,IAAW,IAAI,MAAa;CAE3C,IAAI,EAAO,SAAS,GACnB,MAAU,WAAW,6DAA6D;CAGnF,OAAO;AACR;;;ACjBA,SAAgB,EAAY,GAAc,GAAe,GAAkC;CAC1F,IAAM,IAAU,EAAkB,EAAiB,GAAM,CAAO,GAAG,EAAiB,GAAO,CAAO,CAAC;CAEnG,OAAO,EAAkB;EAAE,aAAa,EAAQ,OAAO,EAAQ;EAAO,OAAO,EAAQ;CAAM,GAAG,CAAO;AACtG;;;ACLA,SAAgB,EAAqB,GAAoB,GAAqB,GAA6C;CAC1H,IAAM,IAAgB,EAAiB,EAAK,WAAW,CAAO,GACxD,IAAkB,EAAiB,EAAK,aAAa,CAAO,GAC5D,IAAiB,EAAiB,EAAM,WAAW,CAAO,GAC1D,IAAmB,EAAiB,EAAM,aAAa,CAAO;CAEpE,IAAI,EAAgB,eAAe,MAAM,EAAiB,eAAe,IACxE,MAAU,WAAW,yDAAyD;CAK/E,IAAM,IAAU,EACf;EAAE,aAAa,EAAc,cAAc,EAAiB;EAAa,OAAO,EAAc,QAAQ,EAAiB;CAAM,GAC7H;EAAE,aAAa,EAAe,cAAc,EAAgB;EAAa,OAAO,EAAe,QAAQ,EAAgB;CAAM,CAC9H;CAEA,OAAO,EAAQ,OAAO,EAAQ,QAAQ,KAAK,IAAQ,OAAO,EAAQ;AACnE;;;AClBA,SAAgB,EAAgB,GAAc,GAAe,GAA6C;CACzG,IAAM,IAAU,EAAkB,EAAiB,GAAM,CAAO,GAAG,EAAiB,GAAO,CAAO,CAAC;CAEnG,OAAO,EAAQ,OAAO,EAAQ,QAAQ,KAAK,IAAQ,OAAO,EAAQ;AACnE;;;ACJA,SAAgB,EAAiB,GAAc,GAAe,GAAkC;CAC/F,IAAM,IAAQ,EAAiB,GAAM,CAAO,GACtC,IAAS,EAAiB,GAAO,CAAO;CAE9C,OAAO,EAAkB;EAAE,aAAa,EAAM,cAAc,EAAO;EAAa,OAAO,EAAM,QAAQ,EAAO;CAAM,GAAG,CAAO;AAC7H;;;ACNA,SAAgB,EAAiB,GAAe,GAAkC;CACjF,IAAM,IAAY,EAAwB,CAAO;CAEjD,IAAI,OAAO,KAAU,YAAY,EAAM,SAAS,KAAa,CAAC,8BAA8B,KAAK,CAAK,GACrG,MAAU,UAAU,6DAA6D;CAGlF,IAAM,IAAW,EAAM,WAAW,GAAG,GAE/B,CAAC,GAAS,IAAW,OADV,IAAW,EAAM,MAAM,CAAC,IAAI,EAAA,CACH,MAAM,GAAG,GAC7C,IAAQ,EAAQ,QAAQ,cAAc,EAAE,GACxC,IAAa,EAAS,QAAQ,QAAQ,EAAE,GACxC,IAAY,IAAa,GAAG,EAAM,GAAG,MAAe;CAE1D,OAAO,KAAY,MAAc,MAAM,IAAI,MAAc;AAC1D;;;ACbA,SAAgB,EAAiB,GAAc,GAAe,GAAkC;CAC/F,IAAM,IAAU,EAAkB,EAAiB,GAAM,CAAO,GAAG,EAAiB,GAAO,CAAO,CAAC;CAEnG,OAAO,EAAkB;EAAE,aAAa,EAAQ,OAAO,EAAQ;EAAO,OAAO,EAAQ;CAAM,GAAG,CAAO;AACtG;;;ACLA,SAAgB,EAAY,GAA0B,GAAkC;CACvF,EAAwB,CAAO;CAC/B,IAAI,IAAQ;CAEZ,KAAK,IAAM,KAAS,GACnB,IAAQ,EAAY,GAAO,GAAO,CAAO;CAG1C,OAAO;AACR"}
+{"version":3,"file":"index.js","names":[],"sources":["../../src/decimal/alignDecimalParts.ts","../../src/decimal/resolveDecimalMaxLength.ts","../../src/decimal/isCanonicalDecimal.ts","../../src/decimal/readDecimalParts.ts","../../src/decimal/writeDecimalParts.ts","../../src/decimal/addDecimals.ts","../../src/decimal/compareDecimalRatios.ts","../../src/decimal/compareDecimals.ts","../../src/decimal/multiplyDecimals.ts","../../src/decimal/normalizeDecimal.ts","../../src/decimal/normalizeDecimalLiteral.ts","../../src/decimal/subtractDecimals.ts","../../src/decimal/sumDecimals.ts"],"sourcesContent":["import type { DecimalParts } from \"./types\";\n\n/** Выравнивает только разрядность ограниченных операндов; глобального кеша степеней нет. */\nexport function alignDecimalParts(left: DecimalParts, right: DecimalParts): Readonly<{ left: bigint; right: bigint; scale: number }> {\n\tconst scale = Math.max(left.scale, right.scale);\n\n\treturn {\n\t\tleft: left.coefficient * 10n ** BigInt(scale - left.scale),\n\t\tright: right.coefficient * 10n ** BigInt(scale - right.scale),\n\t\tscale\n\t};\n}\n","import type { DecimalOptions } from \"./types\";\n\n/** Проверяет предел до разбора числа и выделения вычислительных буферов. */\nexport function resolveDecimalMaxLength(options?: DecimalOptions): number {\n\tconst maxLength = options?.maxLength ?? 512;\n\n\tif (!Number.isSafeInteger(maxLength) || maxLength <= 0) {\n\t\tthrow new RangeError(\"Предел длины десятичного значения должен быть положительным безопасным целым числом.\");\n\t}\n\n\treturn maxLength;\n}\n","import { resolveDecimalMaxLength } from \"./resolveDecimalMaxLength\";\n\nimport type { DecimalOptions } from \"./types\";\n\n/** Runtime-проверка для внешних данных без преобразования значащих цифр в number. */\nexport function isCanonicalDecimal(value: unknown, options?: DecimalOptions): value is string {\n\tconst maxLength = resolveDecimalMaxLength(options);\n\n\treturn (\n\t\ttypeof value === \"string\" && value.length <= maxLength && /^(?:0|-?(?:[1-9]\\d*(?:\\.\\d*[1-9])?|0\\.\\d*[1-9]))(?![\\s\\S])/u.test(value)\n\t);\n}\n","import { isCanonicalDecimal } from \"./isCanonicalDecimal\";\n\nimport type { DecimalOptions, DecimalParts } from \"./types\";\n\n/** Арифметика принимает только канонические строки; нормализация принадлежит входной границе. */\nexport function readDecimalParts(value: string, options?: DecimalOptions): DecimalParts {\n\tif (!isCanonicalDecimal(value, options)) {\n\t\tthrow new TypeError(\"Ожидалась каноническая десятичная строка в пределах допустимой длины.\");\n\t}\n\n\tconst point = value.indexOf(\".\");\n\n\treturn {\n\t\tcoefficient: BigInt(value.replace(\".\", \"\")),\n\t\tscale: point === -1 ? 0 : value.length - point - 1\n\t};\n}\n","import { resolveDecimalMaxLength } from \"./resolveDecimalMaxLength\";\n\nimport type { DecimalOptions, DecimalParts } from \"./types\";\n\n/** Канонизирует результат после точного вычисления и отклоняет overflow вместо округления. */\nexport function writeDecimalParts(parts: DecimalParts, options?: DecimalOptions): string {\n\tconst maxLength = resolveDecimalMaxLength(options);\n\n\tif (parts.coefficient === 0n) {\n\t\treturn \"0\";\n\t}\n\n\tconst negative = parts.coefficient < 0n;\n\tconst magnitude = negative ? -parts.coefficient : parts.coefficient;\n\tconst digits = magnitude.toString().padStart(parts.scale + 1, \"0\");\n\tconst point = digits.length - parts.scale;\n\tconst unsigned = parts.scale === 0 ? digits : `${digits.slice(0, point)}.${digits.slice(point)}`.replace(/\\.?0+$/u, \"\");\n\tconst result = negative ? `-${unsigned}` : unsigned;\n\n\tif (result.length > maxLength) {\n\t\tthrow new RangeError(\"Результат десятичного вычисления превысил допустимую длину.\");\n\t}\n\n\treturn result;\n}\n","import { alignDecimalParts } from \"./alignDecimalParts\";\nimport { readDecimalParts } from \"./readDecimalParts\";\nimport { writeDecimalParts } from \"./writeDecimalParts\";\n\nimport type { DecimalOptions } from \"./types\";\n\n/** Складывает значения без IEEE 754 и возвращает каноническую строку. */\nexport function addDecimals(left: string, right: string, options?: DecimalOptions): string {\n\tconst aligned = alignDecimalParts(readDecimalParts(left, options), readDecimalParts(right, options));\n\n\treturn writeDecimalParts({ coefficient: aligned.left + aligned.right, scale: aligned.scale }, options);\n}\n","import { alignDecimalParts } from \"./alignDecimalParts\";\nimport { readDecimalParts } from \"./readDecimalParts\";\n\nimport type { DecimalComparison, DecimalOptions, DecimalRatio } from \"./types\";\n\n/** Сравнивает отношения перекрёстным умножением. Периодическая дробь не делится и не округляется. */\nexport function compareDecimalRatios(left: DecimalRatio, right: DecimalRatio, options?: DecimalOptions): DecimalComparison {\n\tconst leftNumerator = readDecimalParts(left.numerator, options);\n\tconst leftDenominator = readDecimalParts(left.denominator, options);\n\tconst rightNumerator = readDecimalParts(right.numerator, options);\n\tconst rightDenominator = readDecimalParts(right.denominator, options);\n\n\tif (leftDenominator.coefficient <= 0n || rightDenominator.coefficient <= 0n) {\n\t\tthrow new RangeError(\"Знаменатель отношения должен быть строго положительным.\");\n\t}\n\n\t// Произведения приватные: их разрядность ограничена четырьмя проверенными операндами,\n\t// но может превышать длину сериализуемого числа. Проверять их как внешний результат нельзя.\n\tconst aligned = alignDecimalParts(\n\t\t{ coefficient: leftNumerator.coefficient * rightDenominator.coefficient, scale: leftNumerator.scale + rightDenominator.scale },\n\t\t{ coefficient: rightNumerator.coefficient * leftDenominator.coefficient, scale: rightNumerator.scale + leftDenominator.scale }\n\t);\n\n\treturn aligned.left < aligned.right ? -1 : aligned.left > aligned.right ? 1 : 0;\n}\n","import { alignDecimalParts } from \"./alignDecimalParts\";\nimport { readDecimalParts } from \"./readDecimalParts\";\n\nimport type { DecimalComparison, DecimalOptions } from \"./types\";\n\n/** Сравнивает исходные значения, включая разрядность за пределами безопасного number. */\nexport function compareDecimals(left: string, right: string, options?: DecimalOptions): DecimalComparison {\n\tconst aligned = alignDecimalParts(readDecimalParts(left, options), readDecimalParts(right, options));\n\n\treturn aligned.left < aligned.right ? -1 : aligned.left > aligned.right ? 1 : 0;\n}\n","import { readDecimalParts } from \"./readDecimalParts\";\nimport { writeDecimalParts } from \"./writeDecimalParts\";\n\nimport type { DecimalOptions } from \"./types\";\n\n/** Точное умножение не устанавливает фиксированную сетку дробности. */\nexport function multiplyDecimals(left: string, right: string, options?: DecimalOptions): string {\n\tconst first = readDecimalParts(left, options);\n\tconst second = readDecimalParts(right, options);\n\n\treturn writeDecimalParts({ coefficient: first.coefficient * second.coefficient, scale: first.scale + second.scale }, options);\n}\n","import { resolveDecimalMaxLength } from \"./resolveDecimalMaxLength\";\n\nimport type { DecimalOptions } from \"./types\";\n\n/** Убирает лишние нули. Пробелы, запятую, плюс и экспоненту обрабатывает владелец внешнего формата. */\nexport function normalizeDecimal(value: string, options?: DecimalOptions): string {\n\tconst maxLength = resolveDecimalMaxLength(options);\n\n\tif (typeof value !== \"string\" || value.length > maxLength || !/^-?\\d+(?:\\.\\d+)?(?![\\s\\S])/u.test(value)) {\n\t\tthrow new TypeError(\"Ожидалась ограниченная конечная десятичная строка с точкой.\");\n\t}\n\n\tconst negative = value.startsWith(\"-\");\n\tconst unsigned = negative ? value.slice(1) : value;\n\tconst [integer, fraction = \"\"] = unsigned.split(\".\");\n\tconst whole = integer.replace(/^0+(?=\\d)/u, \"\");\n\tconst fractional = fraction.replace(/0+$/u, \"\");\n\tconst magnitude = fractional ? `${whole}.${fractional}` : whole;\n\n\treturn negative && magnitude !== \"0\" ? `-${magnitude}` : magnitude;\n}\n","import { normalizeDecimal } from \"./normalizeDecimal\";\nimport { resolveDecimalMaxLength } from \"./resolveDecimalMaxLength\";\n\nimport type { DecimalOptions } from \"./types\";\n\n/**\n * Сохраняет все цифры внешнего числового литерала, включая научную запись JSON.\n * На вход передаётся исходная лексема parser, а не уже округлённый number.\n * Локализованные разделители и пробелы остаются ответственностью формы ввода.\n */\nexport function normalizeDecimalLiteral(value: string, options?: DecimalOptions): string {\n\tconst maxLength = resolveDecimalMaxLength(options);\n\tif (typeof value !== \"string\" || value.length > maxLength) {\n\t\tthrow new TypeError(\"Ожидался ограниченный десятичный числовой литерал.\");\n\t}\n\tconst match = /^(-?)(\\d+)(?:\\.(\\d+))?(?:[eE]([+-]?\\d+))?(?![\\s\\S])/u.exec(value);\n\tif (!match) throw new TypeError(\"Ожидался конечный десятичный числовой литерал.\");\n\tconst [, sign, integer, fraction = \"\", exponent] = match;\n\tif (exponent === undefined) return normalizeDecimal(value, options);\n\n\tconst digits = integer + fraction;\n\tconst significant = digits.replace(/^0+/u, \"\");\n\tif (!significant) return \"0\";\n\tconst coefficient = significant.replace(/0+$/u, \"\");\n\t// Number описывает только ограниченный сдвиг точки, никогда значение числа.\n\tconst shift = Number(exponent);\n\tif (!Number.isSafeInteger(shift)) throw new RangeError(\"Экспонента превышает допустимую длину результата.\");\n\tconst point = integer.length + shift - (digits.length - significant.length);\n\tconst length =\n\t\tsign.length +\n\t\t(point <= 0 ? 2 - point + coefficient.length : Math.max(point, coefficient.length + (point < coefficient.length ? 1 : 0)));\n\tif (length > maxLength) throw new RangeError(\"Десятичный результат превышает допустимую длину.\");\n\n\tif (point <= 0) return `${sign}0.${\"0\".repeat(-point)}${coefficient}`;\n\tif (point >= coefficient.length) return sign + coefficient + \"0\".repeat(point - coefficient.length);\n\treturn `${sign}${coefficient.slice(0, point)}.${coefficient.slice(point)}`;\n}\n","import { alignDecimalParts } from \"./alignDecimalParts\";\nimport { readDecimalParts } from \"./readDecimalParts\";\nimport { writeDecimalParts } from \"./writeDecimalParts\";\n\nimport type { DecimalOptions } from \"./types\";\n\n/** Сохраняет знак остатка; предметные ограничения отрицательных значений находятся у consumer. */\nexport function subtractDecimals(left: string, right: string, options?: DecimalOptions): string {\n\tconst aligned = alignDecimalParts(readDecimalParts(left, options), readDecimalParts(right, options));\n\n\treturn writeDecimalParts({ coefficient: aligned.left - aligned.right, scale: aligned.scale }, options);\n}\n","import { addDecimals } from \"./addDecimals\";\nimport { resolveDecimalMaxLength } from \"./resolveDecimalMaxLength\";\n\nimport type { DecimalOptions } from \"./types\";\n\n/** Читает iterable один раз и проверяет каждый промежуточный итог; пустой набор даёт ноль. */\nexport function sumDecimals(values: Iterable<string>, options?: DecimalOptions): string {\n\tresolveDecimalMaxLength(options);\n\tlet total = \"0\";\n\n\tfor (const value of values) {\n\t\ttotal = addDecimals(total, value, options);\n\t}\n\n\treturn total;\n}\n"],"mappings":"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"}

package/dist/decimal/normalizeDecimalLiteral.d.ts

@@ -0,0 +1,8 @@
+import type { DecimalOptions } from "./types";
+/**
+ * Сохраняет все цифры внешнего числового литерала, включая научную запись JSON.
+ * На вход передаётся исходная лексема parser, а не уже округлённый number.
+ * Локализованные разделители и пробелы остаются ответственностью формы ввода.
+ */
+export declare function normalizeDecimalLiteral(value: string, options?: DecimalOptions): string;
+//# sourceMappingURL=normalizeDecimalLiteral.d.ts.map

package/dist/decimal/normalizeDecimalLiteral.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeDecimalLiteral.d.ts","sourceRoot":"","sources":["../../src/decimal/normalizeDecimalLiteral.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,MAAM,CA0BvF"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ryuzaki13/react-foundation-lib",
-	"version": "2.10.1",
+	"version": "2.11.0",
 	"description": "Reusable React and TypeScript foundation utilities, hooks, and primitives.",
 	"license": "MIT",
 	"author": "Ryuzaki13",

package/src/decimal/README.md

@@ -12,14 +12,15 @@ addDecimals("0.1", "0.2"); // "0.3"
 compareDecimalRatios({ numerator: "10", denominator: "3" }, { numerator: "3.33", denominator: "1" }); // 1
 ```
 
-| API                                                   | Назначение                                                            |
-| ----------------------------------------------------- | --------------------------------------------------------------------- |
-| `isCanonicalDecimal(unknown, options?)`               | Проверить внешнее значение без преобразования                         |
-| `normalizeDecimal(string, options?)`                  | Убрать начальные и конечные нули; привести отрицательный ноль к `"0"` |
-| `addDecimals`, `subtractDecimals`, `multiplyDecimals` | Получить точный канонический результат двух операндов                 |
-| `sumDecimals(iterable, options?)`                     | Суммировать за один проход; пустой набор даёт `"0"`                   |
-| `compareDecimals`                                     | Вернуть `-1`, `0` или `1`                                             |
-| `compareDecimalRatios`                                | Сравнить отношения без деления; знаменатели строго положительные      |
+| API                                                   | Назначение                                                                        |
+| ----------------------------------------------------- | --------------------------------------------------------------------------------- |
+| `isCanonicalDecimal(unknown, options?)`               | Проверить внешнее значение без преобразования                                     |
+| `normalizeDecimal(string, options?)`                  | Убрать начальные и конечные нули; привести отрицательный ноль к `"0"`             |
+| `normalizeDecimalLiteral(string, options?)`           | Точно раскрыть научную запись внешнего числа без преобразования значения в number |
+| `addDecimals`, `subtractDecimals`, `multiplyDecimals` | Получить точный канонический результат двух операндов                             |
+| `sumDecimals(iterable, options?)`                     | Суммировать за один проход; пустой набор даёт `"0"`                               |
+| `compareDecimals`                                     | Вернуть `-1`, `0` или `1`                                                         |
+| `compareDecimalRatios`                                | Сравнить отношения без деления; знаменатели строго положительные                  |
 
 Каноническая строка содержит знак минус при необходимости, цифры и точку:
 `"0"`, `"0.3"`, `"-12.05"`. Пробелы, плюс, экспонента, запятая, начальные
@@ -27,6 +28,13 @@ compareDecimalRatios({ numerator: "10", denominator: "3" }, { numerator: "3.33",
 допускает только лишние нули; обработка локализованного ввода и внешних JSON
 чисел принадлежит соответствующей входной границе.
 
+Для исходной лексемы JSON-числа входная граница использует
+`normalizeDecimalLiteral("1e-1")`, получая `"0.1"`. Parser должен сохранить
+исходные цифры: передавать `String` уже прочитанного `number` слишком поздно.
+Научная запись разворачивается только в пределах `maxLength`; значение
+`"1e1000000000"` отклоняется до выделения большого буфера. Прежние API
+арифметики и `normalizeDecimal` по-прежнему не принимают экспоненту.
+
 `DecimalOptions.maxLength` задаёт положительный безопасный целый предел длины
 входа и результата, включая знак и точку; по умолчанию — 512 символов.
 Вход отклоняется до создания `bigint` и выравнивания разрядов. Неверная форма