@calcit/procs 0.29.0-alpha.27 → 0.29.0-alpha.28

package/lib/calcit-data.d.mts

@@ -37,6 +37,7 @@ export declare let newTag: (content: string) => CalcitTag;
 export declare let castTag: (x: CalcitValue) => CalcitTag;
 export declare var refsRegistry: Map<string, CalcitRef>;
 export declare let hashFunction: (x: CalcitValue) => Hash;
+export declare let format_calcit_number: (x: number) => string;
 export declare let toString: (x: CalcitValue, escaped: boolean, disableJsDataWarning?: boolean) => string;
 export declare let to_js_data: (x: CalcitValue, options?: CalcitValue) => any;
 export declare let _$n_map_$o_get: (xs: CalcitValue, k: CalcitValue) => CalcitValue;

package/lib/calcit-data.mjs

@@ -447,6 +447,38 @@ let hashCirru = (base, x) => {
 };
 // Dirty code to change ternary-tree behavior
 overwriteHashGenerator(hashFunction);
+// Calcit number text, shared by `turn-string`, `str` and printing (see docs/data/number.md).
+export let format_calcit_number = (x) => {
+    // Match native f64 Display, which expands finite exponents into decimal notation.
+    if (Object.is(x, -0)) {
+        return "-0";
+    }
+    if (x === Infinity) {
+        return "inf";
+    }
+    if (x === -Infinity) {
+        return "-inf";
+    }
+    const text = x.toString();
+    const exponentIndex = text.indexOf("e");
+    if (exponentIndex < 0) {
+        return text;
+    }
+    const mantissa = text.slice(0, exponentIndex);
+    const exponent = Number(text.slice(exponentIndex + 1));
+    const sign = mantissa.startsWith("-") ? "-" : "";
+    const unsigned = sign ? mantissa.slice(1) : mantissa;
+    const decimalPoint = unsigned.indexOf(".");
+    const decimalIndex = (decimalPoint < 0 ? unsigned.length : decimalPoint) + exponent;
+    const digits = unsigned.replace(".", "");
+    if (decimalIndex <= 0) {
+        return `${sign}0.${"0".repeat(-decimalIndex)}${digits}`;
+    }
+    if (decimalIndex >= digits.length) {
+        return `${sign}${digits}${"0".repeat(decimalIndex - digits.length)}`;
+    }
+    return `${sign}${digits.slice(0, decimalIndex)}.${digits.slice(decimalIndex)}`;
+};
 export let toString = (x, escaped, disableJsDataWarning = false) => {
     if (x === null) {
         return "nil";
@@ -468,7 +500,7 @@ export let toString = (x, escaped, disableJsDataWarning = false) => {
         }
     }
     if (typeof x === "number") {
-        return x.toString();
+        return format_calcit_number(x);
     }
     if (typeof x === "boolean") {
         return x.toString();

package/lib/calcit.procs.mjs

@@ -3,7 +3,7 @@ export const calcit_version = pkg.version;
 export const calcit_package_json = pkg;
 import { parse } from "@cirru/parser.ts";
 import { writeCirruCode } from "@cirru/writer.ts";
-import { CalcitSymbol, CalcitTag, CalcitRecur, castTag, newTag, refsRegistry, toString, getStringName, compareTagNames, _$n__$e_, hashFunction, } from "./calcit-data.mjs";
+import { CalcitSymbol, CalcitTag, CalcitRecur, castTag, newTag, refsRegistry, toString, format_calcit_number, getStringName, compareTagNames, _$n__$e_, hashFunction, } from "./calcit-data.mjs";
 import { CalcitRef, atom } from "./js-ref.mjs";
 import { CalcitStructValue } from "./js-struct-value.mjs";
 import { CalcitImpl } from "./js-impl.mjs";
@@ -946,7 +946,9 @@ export let remove_watch = (a, k) => {
     }
     throw new Error(`remove-watch failed: listener with key \`${k.value}\` not found`);
 };
-const MAX_RANGE_LENGTH = 4294967295;
+// Same eager range limit as native `MAX_RANGE_LEN` and WASM, 2^24 elements (#1852).
+const MAX_RANGE_LENGTH = 2 ** 24;
+const rangeTooLarge = () => new Error(`&list:range result is too large: more than ${MAX_RANGE_LENGTH} elements`);
 export let range = (n, m, step = 1) => {
     const base = m == null ? 0 : n;
     const bound = m == null ? n : m;
@@ -964,11 +966,13 @@ export let range = (n, m, step = 1) => {
         ? Math.ceil(Math.abs(base) / Math.abs(step) + Math.abs(bound) / Math.abs(step))
         : Math.ceil((bound - base) / step);
     if (!Number.isFinite(estimatedLength) || estimatedLength > MAX_RANGE_LENGTH) {
-        throw new Error("&list:range result is too large");
+        throw rangeTooLarge();
     }
     const result = [];
     if (step > 0) {
         for (let value = base; value < bound;) {
+            if (result.length >= MAX_RANGE_LENGTH)
+                throw rangeTooLarge();
             result.push(value);
             const next = value + step;
             if (next === value) {
@@ -979,6 +983,8 @@ export let range = (n, m, step = 1) => {
     }
     else {
         for (let value = base; value > bound;) {
+            if (result.length >= MAX_RANGE_LENGTH)
+                throw rangeTooLarge();
             result.push(value);
             const next = value + step;
             if (next === value) {
@@ -1158,11 +1164,12 @@ export let _$n_list_$o_slice = (xs, from, to) => {
     if (to == null) {
         to = size;
     }
-    else if (to <= from) {
-        return new CalcitSliceList([]);
+    // Bounds are integers with 0 <= from <= to <= size, as in native (docs/data/number.md).
+    if (!Number.isInteger(from) || !Number.isInteger(to) || from < 0 || from > to || to > size) {
+        throw new Error(`&list:slice expected integer bounds within 0..${size}, but received: ${from} ${to}`);
     }
-    else if (to > size) {
-        to = size;
+    if (from === to) {
+        return new CalcitSliceList([]);
     }
     return xs.slice(from, to);
 };
@@ -1360,13 +1367,19 @@ export let cos = (n) => {
     return Math.cos(n);
 };
 export let pow = (n, m) => {
+    // IEEE 754 pow, which Math.pow breaks: pow(1, y) is 1 for any y, pow(-1, ±Infinity) is 1.
+    if (n === 1 || (n === -1 && (m === Infinity || m === -Infinity))) {
+        return 1;
+    }
     return Math.pow(n, m);
 };
 export let ceil = (n) => {
     return Math.ceil(n);
 };
 export let round = (n) => {
-    return Math.round(n);
+    // Ties round away from zero; `Math.round` alone rounds them toward +Infinity.
+    // Negating keeps `-0` for inputs such as -0.4.
+    return n < 0 ? -Math.round(-n) : Math.round(n);
 };
 export let _$n_number_$o_fract = (n) => {
     return n - Math.floor(n);
@@ -1519,6 +1532,10 @@ export let _$n_number_$o_format = (x, n) => {
     return x.toFixed(n);
 };
 export let _$n_number_$o_display_by = (x, n) => {
+    // a non-negative safe integer, printed exactly (docs/data/number.md)
+    if (typeof x !== "number" || !Number.isSafeInteger(x) || x < 0) {
+        throw new Error(`&number:display-by expected a non-negative safe integer, but received: ${x}`);
+    }
     switch (n) {
         case 2:
             return `0b${x.toString(2)}`;
@@ -1690,37 +1707,6 @@ export let quit_$x_ = (code) => {
         throw new Error(`quit!(${code})`);
     }
 };
-let format_calcit_number = (x) => {
-    // Match native f64 Display, which expands finite exponents into decimal notation.
-    if (Object.is(x, -0)) {
-        return "-0";
-    }
-    if (x === Infinity) {
-        return "inf";
-    }
-    if (x === -Infinity) {
-        return "-inf";
-    }
-    const text = x.toString();
-    const exponentIndex = text.indexOf("e");
-    if (exponentIndex < 0) {
-        return text;
-    }
-    const mantissa = text.slice(0, exponentIndex);
-    const exponent = Number(text.slice(exponentIndex + 1));
-    const sign = mantissa.startsWith("-") ? "-" : "";
-    const unsigned = sign ? mantissa.slice(1) : mantissa;
-    const decimalPoint = unsigned.indexOf(".");
-    const decimalIndex = (decimalPoint < 0 ? unsigned.length : decimalPoint) + exponent;
-    const digits = unsigned.replace(".", "");
-    if (decimalIndex <= 0) {
-        return `${sign}0.${"0".repeat(-decimalIndex)}${digits}`;
-    }
-    if (decimalIndex >= digits.length) {
-        return `${sign}${digits}${"0".repeat(decimalIndex - digits.length)}`;
-    }
-    return `${sign}${digits.slice(0, decimalIndex)}.${digits.slice(decimalIndex)}`;
-};
 export let turn_string = (x) => {
     if (x === null) {
         return "";
@@ -2980,23 +2966,30 @@ export let _$n_map_$o_diff_triple = (a, b) => {
         throw new Error("&map:diff-triple expected 2 maps");
     }
 };
+// Bitwise operands are integers within i32 (docs/data/number.md); JS would otherwise wrap or truncate them.
+let bit_operand = (name, x) => {
+    if (typeof x !== "number" || !Number.isInteger(x) || x < -2147483648 || x > 2147483647) {
+        throw new Error(`&math:${name} operand expected an integer within i32, but got: ${x}`);
+    }
+    return x;
+};
 export let bit_shr = (base, step) => {
-    return base >> step;
+    return bit_operand("bit-shr", base) >> bit_operand("bit-shr", step);
 };
 export let bit_shl = (base, step) => {
-    return base << step;
+    return bit_operand("bit-shl", base) << bit_operand("bit-shl", step);
 };
 export let bit_and = (a, b) => {
-    return a & b;
+    return bit_operand("bit-and", a) & bit_operand("bit-and", b);
 };
 export let bit_or = (a, b) => {
-    return a | b;
+    return bit_operand("bit-or", a) | bit_operand("bit-or", b);
 };
 export let bit_xor = (a, b) => {
-    return a ^ b;
+    return bit_operand("bit-xor", a) ^ bit_operand("bit-xor", b);
 };
 export let bit_not = (a) => {
-    return ~a;
+    return ~bit_operand("bit-not", a);
 };
 export let _$n_list_$o_to_set = (xs) => {
     var result = [];
@@ -3019,11 +3012,41 @@ export let _$n_list_$o_distinct = (xs) => {
     }
     return new CalcitSliceList(result);
 };
+// Longest padded string, the V8 string length limit, so every backend fails at the same size.
+const MAX_PADDED_LEN = 536870888;
+// Padding for `&str:pad-left` / `&str:pad-right`, measured in Unicode scalars like `&str:count`
+// (not UTF-16 units, so astral characters are never split). NaN and negative lengths pad nothing,
+// and so does an empty pattern.
+const strPadding = (procName, s, size, pattern) => {
+    if (size > MAX_PADDED_LEN) {
+        throw new Error(`${procName} expected a finite length up to ${MAX_PADDED_LEN}, but received: ${format_calcit_number(size)}`);
+    }
+    if (!(size > 0) || pattern === "")
+        return "";
+    let missing = Math.floor(size);
+    for (const _scalar of s) {
+        missing -= 1;
+        if (missing <= 0)
+            return "";
+    }
+    let patternCount = 0;
+    for (const _scalar of pattern)
+        patternCount += 1;
+    let padding = pattern.repeat(Math.floor(missing / patternCount));
+    let rest = missing % patternCount;
+    for (const scalar of pattern) {
+        if (rest <= 0)
+            break;
+        padding += scalar;
+        rest -= 1;
+    }
+    return padding;
+};
 export let _$n_str_$o_pad_left = (s, size, pattern) => {
-    return s.padStart(size, pattern);
+    return strPadding("&str:pad-left", s, size, pattern) + s;
 };
 export let _$n_str_$o_pad_right = (s, size, pattern) => {
-    return s.padEnd(size, pattern);
+    return s + strPadding("&str:pad-right", s, size, pattern);
 };
 export let _$n_get_os = () => {
     return newTag("js-engine");

package/lib/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@calcit/procs",
-    "version": "0.29.0-alpha.27",
+    "version": "0.29.0-alpha.28",
     "main": "./lib/calcit.procs.mjs",
     "files": [
         "lib/",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calcit/procs",
-  "version": "0.29.0-alpha.27",
+  "version": "0.29.0-alpha.28",
   "main": "./lib/calcit.procs.mjs",
   "files": [
     "lib/",