@elaraai/east 1.0.79 → 1.0.81

package/dist/src/compile/builtins/array.js

@@ -0,0 +1,691 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+import { compareFor } from "../../comparison.js";
+import { call_function, FROZEN_MESSAGE, iterationLocks, lockForIteration, unlockForIteration } from "../runtime.js";
+import { SortedMap } from "../../containers/sortedmap.js";
+import { SortedSet } from "../../containers/sortedset.js";
+import { variant } from "../../containers/variant.js";
+import { EastError } from "../../error.js";
+import { isFrozenValue } from "../../frozen.js";
+import { printFor } from "../../serialization/east.js";
+import { buildTree, treeOrder } from "./tree.js";
+/** The builtins for Arrays. @internal */
+export const array_builtins = {
+    ArrayGenerate: (loc_id, source_map, _platformDef, _T) => (size, f) => {
+        const result = [];
+        for (let i = 0n; i < size; i += 1n) {
+            const v = call_function(loc_id, source_map, f, i);
+            result.push(v);
+        }
+        return result;
+    },
+    ArrayRange: (_loc_id, _source_map) => (start, end, step) => {
+        const result = [];
+        if (step === 0n) {
+            return result; // empty array
+        }
+        else if (step > 0n) {
+            for (let i = start; i < end; i += step) {
+                result.push(i);
+            }
+        }
+        else { // step < 0
+            for (let i = start; i > end; i += step) {
+                result.push(i);
+            }
+        }
+        return result;
+    },
+    ArrayLinspace: (_loc_id, _source_map) => (start, end, size) => {
+        const result = [];
+        if (size <= 0n) {
+            return result; // empty array
+        }
+        else if (size === 1n) {
+            return [start];
+        }
+        else {
+            const step = (end - start) / Number(size - 1n);
+            for (let i = 0n; i < size; i += 1n) {
+                result.push(start + Number(i) * step);
+            }
+        }
+        return result;
+    },
+    ArraySize: (_loc_id, _source_map, _platformDef, _T) => (array) => BigInt(array.length),
+    ArrayHas: (_loc_id, _source_map, _platformDef, _T) => (array, key) => {
+        const i = Number(key);
+        return i >= 0 && i < array.length;
+    },
+    ArrayGet: (loc_id, source_map, _platformDef, _T) => (array, key) => {
+        const i = Number(key);
+        if (i < 0 || i >= array.length) {
+            throw new EastError(`Array index ${key} out of bounds`, { location: (source_map?.resolve(loc_id) ?? []) });
+        }
+        else {
+            return array[i];
+        }
+    },
+    ArrayGetOrDefault: (loc_id, source_map, _platformDef, _T) => (array, key, defaultFn) => {
+        const i = Number(key);
+        if (i < 0 || i >= array.length) {
+            return call_function(loc_id, source_map, defaultFn, key);
+        }
+        else {
+            return array[i];
+        }
+    },
+    ArrayTryGet: (_loc_id, _source_map, _platformDef, _T) => (array, key) => {
+        const i = Number(key);
+        if (i < 0 || i >= array.length) {
+            return variant("none", null);
+        }
+        else {
+            return variant("some", array[i]);
+        }
+    },
+    ArrayUpdate: (loc_id, source_map, _platformDef, _T) => (array, key, value) => {
+        if (isFrozenValue(array)) {
+            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
+        }
+        const i = Number(key);
+        if (i < 0 || i >= array.length) {
+            throw new EastError(`Array index ${key} out of bounds`, { location: (source_map?.resolve(loc_id) ?? []) });
+        }
+        else {
+            array[i] = value;
+            return null;
+        }
+    },
+    ArrayMerge: (loc_id, source_map, _platformDef, _T) => (array, key, value, merger) => {
+        if (isFrozenValue(array)) {
+            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
+        }
+        const i = Number(key);
+        if (i < 0 || i >= array.length) {
+            throw new EastError(`Array index ${key} out of bounds`, { location: (source_map?.resolve(loc_id) ?? []) });
+        }
+        else {
+            const new_value = call_function(loc_id, source_map, merger, array[i], value, key);
+            array[i] = new_value;
+            return null;
+        }
+    },
+    ArrayPushLast: (loc_id, source_map, _platformDef, _T) => (array, value) => {
+        if (isFrozenValue(array)) {
+            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
+        }
+        if ((iterationLocks.get(array) || 0) > 0) {
+            throw new EastError("Cannot modify Array during iteration", { location: (source_map?.resolve(loc_id) ?? []) });
+        }
+        array.push(value);
+        return null;
+    },
+    ArrayPopLast: (loc_id, source_map, _platformDef, _T) => (array) => {
+        if (isFrozenValue(array)) {
+            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
+        }
+        if ((iterationLocks.get(array) || 0) > 0) {
+            throw new EastError("Cannot modify Array during iteration", { location: (source_map?.resolve(loc_id) ?? []) });
+        }
+        if (array.length === 0) {
+            throw new EastError("Cannot pop from empty Array", { location: (source_map?.resolve(loc_id) ?? []) });
+        }
+        else {
+            return array.pop();
+        }
+    },
+    ArrayPushFirst: (loc_id, source_map, _platformDef, _T) => (array, value) => {
+        if (isFrozenValue(array)) {
+            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
+        }
+        if ((iterationLocks.get(array) || 0) > 0) {
+            throw new EastError("Cannot modify Array during iteration", { location: (source_map?.resolve(loc_id) ?? []) });
+        }
+        array.unshift(value);
+        return null;
+    },
+    ArrayPopFirst: (loc_id, source_map, _platformDef, _T) => (array) => {
+        if (isFrozenValue(array)) {
+            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
+        }
+        if ((iterationLocks.get(array) || 0) > 0) {
+            throw new EastError("Cannot modify Array during iteration", { location: (source_map?.resolve(loc_id) ?? []) });
+        }
+        if (array.length === 0) {
+            throw new EastError("Cannot pop from empty Array", { location: (source_map?.resolve(loc_id) ?? []) });
+        }
+        else {
+            return array.shift();
+        }
+    },
+    ArrayAppend: (loc_id, source_map, _platformDef, _T) => (array, other) => {
+        if (isFrozenValue(array)) {
+            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
+        }
+        if ((iterationLocks.get(array) || 0) > 0) {
+            throw new EastError("Cannot modify Array during iteration", { location: (source_map?.resolve(loc_id) ?? []) });
+        }
+        array.push(...other);
+        return null;
+    },
+    ArrayPrepend: (loc_id, source_map, _platformDef, _T) => (array, other) => {
+        if (isFrozenValue(array)) {
+            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
+        }
+        if ((iterationLocks.get(array) || 0) > 0) {
+            throw new EastError("Cannot modify Array during iteration", { location: (source_map?.resolve(loc_id) ?? []) });
+        }
+        array.unshift(...other);
+        return null;
+    },
+    ArrayMergeAll: (loc_id, source_map, _platformDef, _T, _T2) => (array, other, merger) => {
+        if (isFrozenValue(array)) {
+            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
+        }
+        lockForIteration(array);
+        lockForIteration(other);
+        try {
+            for (let i = 0; i < other.length; i++) {
+                const key = BigInt(i);
+                if (i < array.length) {
+                    const new_value = call_function(loc_id, source_map, merger, array[i], other[i], key);
+                    array[i] = new_value;
+                }
+                else {
+                    throw new EastError(`Array index ${key} out of bounds`, { location: (source_map?.resolve(loc_id) ?? []) });
+                }
+            }
+        }
+        finally {
+            unlockForIteration(other);
+            unlockForIteration(array);
+        }
+        return null;
+    },
+    ArrayClear: (loc_id, source_map, _platformDef, _T) => (array) => {
+        if (isFrozenValue(array)) {
+            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
+        }
+        if ((iterationLocks.get(array) || 0) > 0) {
+            throw new EastError("Cannot modify Array during iteration", { location: (source_map?.resolve(loc_id) ?? []) });
+        }
+        array.length = 0;
+        return null;
+    },
+    ArraySortInPlace: (loc_id, source_map, _platformDef, T, T2) => (array, by) => {
+        if (isFrozenValue(array)) {
+            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
+        }
+        if ((iterationLocks.get(array) || 0) > 0) {
+            throw new EastError("Cannot modify Array during iteration", { location: (source_map?.resolve(loc_id) ?? []) });
+        }
+        lockForIteration(array);
+        try {
+            const cmp = compareFor(T2);
+            array.sort((a, b) => {
+                const projectedA = call_function(loc_id, source_map, by, a);
+                const projectedB = call_function(loc_id, source_map, by, b);
+                return cmp(projectedA, projectedB);
+            });
+        }
+        finally {
+            unlockForIteration(array);
+        }
+        return null;
+    },
+    ArrayReverseInPlace: (loc_id, source_map, _platformDef, _T) => (array) => {
+        if (isFrozenValue(array)) {
+            throw new EastError(FROZEN_MESSAGE, { location: (source_map?.resolve(loc_id) ?? []) });
+        }
+        if ((iterationLocks.get(array) || 0) > 0) {
+            throw new EastError("Cannot modify Array during iteration", { location: (source_map?.resolve(loc_id) ?? []) });
+        }
+        array.reverse();
+        return null;
+    },
+    ArraySort: (loc_id, source_map, _platformDef, T, T2) => (array, by) => {
+        const cmp = compareFor(T2);
+        const newArray = [...array];
+        newArray.sort((a, b) => {
+            const projectedA = call_function(loc_id, source_map, by, a);
+            const projectedB = call_function(loc_id, source_map, by, b);
+            return cmp(projectedA, projectedB);
+        });
+        return newArray;
+    },
+    ArrayReverse: (_loc_id, _source_map, _platformDef, _T) => (array) => {
+        const newArray = [...array];
+        newArray.reverse();
+        return newArray;
+    },
+    ArrayIsSorted: (loc_id, source_map, _platformDef, T, T2) => {
+        const cmp = compareFor(T2);
+        return (array, by) => {
+            if (array.length < 2)
+                return true;
+            lockForIteration(array);
+            try {
+                let projectedPrev = call_function(loc_id, source_map, by, array[0]);
+                for (let i = 1; i < array.length; i++) {
+                    const projectedCurr = call_function(loc_id, source_map, by, array[i]);
+                    if (cmp(projectedPrev, projectedCurr) > 0) {
+                        return false;
+                    }
+                    projectedPrev = projectedCurr;
+                }
+            }
+            finally {
+                unlockForIteration(array);
+            }
+            return true;
+        };
+    },
+    ArrayFindSortedFirst: (loc_id, source_map, _platformDef, T, T2) => {
+        const cmp = compareFor(T2);
+        return (array, key, by) => {
+            let low = 0;
+            let high = array.length;
+            lockForIteration(array);
+            try {
+                while (low < high) {
+                    const mid = Math.floor((low + high) / 2);
+                    const projectedMid = call_function(loc_id, source_map, by, array[mid]);
+                    if (cmp(projectedMid, key) < 0) {
+                        low = mid + 1;
+                    }
+                    else {
+                        high = mid;
+                    }
+                }
+            }
+            finally {
+                unlockForIteration(array);
+            }
+            return BigInt(low);
+        };
+    },
+    ArrayFindSortedLast: (loc_id, source_map, _platformDef, T, T2) => {
+        const cmp = compareFor(T2);
+        return (array, key, by) => {
+            let low = 0;
+            let high = array.length;
+            lockForIteration(array);
+            try {
+                while (low < high) {
+                    const mid = Math.floor((low + high) / 2);
+                    const projectedMid = call_function(loc_id, source_map, by, array[mid]);
+                    if (cmp(projectedMid, key) <= 0) {
+                        low = mid + 1;
+                    }
+                    else {
+                        high = mid;
+                    }
+                }
+            }
+            finally {
+                unlockForIteration(array);
+            }
+            return BigInt(low);
+        };
+    },
+    ArrayFindSortedRange: (loc_id, source_map, _platformDef, T, T2) => {
+        const cmp = compareFor(T2);
+        return (array, key, by) => {
+            let lo = -1;
+            let hi = array.length;
+            lockForIteration(array);
+            try {
+                // Main search loop - find any equal element or determine the range doesn't exist
+                while (lo < hi - 1) {
+                    const mid = Math.floor((lo + hi) / 2);
+                    const projectedMid = call_function(loc_id, source_map, by, array[mid]);
+                    const cmpResult = cmp(projectedMid, key);
+                    if (cmpResult < 0) {
+                        lo = mid;
+                    }
+                    else if (cmpResult > 0) {
+                        hi = mid;
+                    }
+                    else {
+                        // Found an equal element! Now find the first and last positions
+                        // within the constrained range
+                        // Find first position in range [max(lo, -1), mid]
+                        let firstLo = Math.max(lo, -1);
+                        let firstHi = mid + 1;
+                        while (firstLo < firstHi - 1) {
+                            const firstMid = Math.floor((firstLo + firstHi) / 2);
+                            const projectedFirst = call_function(loc_id, source_map, by, array[firstMid]);
+                            if (cmp(projectedFirst, key) < 0) {
+                                firstLo = firstMid;
+                            }
+                            else {
+                                firstHi = firstMid;
+                            }
+                        }
+                        // Find last position in range [mid, min(hi, array.length)]
+                        let lastLo = mid - 1;
+                        let lastHi = Math.min(hi, array.length);
+                        while (lastLo < lastHi - 1) {
+                            const lastMid = Math.floor((lastLo + lastHi) / 2);
+                            const projectedLast = call_function(loc_id, source_map, by, array[lastMid]);
+                            if (cmp(projectedLast, key) <= 0) {
+                                lastLo = lastMid;
+                            }
+                            else {
+                                lastHi = lastMid;
+                            }
+                        }
+                        return { start: BigInt(firstLo + 1), end: BigInt(lastLo + 1) };
+                    }
+                }
+            }
+            finally {
+                unlockForIteration(array);
+            }
+            // No equal element found - return empty range
+            return { start: BigInt(lo + 1), end: BigInt(lo + 1) };
+        };
+    },
+    ArrayFindFirst: (loc_id, source_map, _platformDef, T, T2) => {
+        const cmp = compareFor(T2);
+        return (array, value, by) => {
+            lockForIteration(array);
+            try {
+                for (let i = 0; i < array.length; i++) {
+                    const projected = call_function(loc_id, source_map, by, array[i]);
+                    if (cmp(projected, value) === 0) {
+                        return variant("some", BigInt(i));
+                    }
+                }
+                return variant("none", null);
+            }
+            finally {
+                unlockForIteration(array);
+            }
+        };
+    },
+    ArrayConcat: (_loc_id, _source_map, _platformDef, _T) => (a1, a2) => {
+        return [...a1, ...a2];
+    },
+    ArraySlice: (_loc_id, _source_map, _platformDef, _T) => (array, start, end) => {
+        const startNum = Number(start);
+        const endNum = Number(end);
+        return array.slice(startNum, endNum);
+    },
+    ArrayGetKeys: (loc_id, source_map, _platformDef, _T) => (array, keys, onMissing) => {
+        return keys.map(k => {
+            const i = Number(k);
+            if (i < 0 || i >= array.length) {
+                return call_function(loc_id, source_map, onMissing, k);
+            }
+            else {
+                return array[i];
+            }
+        });
+    },
+    ArrayForEach: (loc_id, source_map, _platformDef, _T, _T2) => (array, f) => {
+        lockForIteration(array);
+        try {
+            array.forEach((x, i) => {
+                return call_function(loc_id, source_map, f, x, BigInt(i));
+            });
+            return null;
+        }
+        finally {
+            unlockForIteration(array);
+        }
+    },
+    ArrayCopy: (_loc_id, _source_map, _platformDef, _T) => (array) => {
+        return [...array];
+    },
+    ArrayMap: (loc_id, source_map, _platformDef, _T, _T2) => (array, f) => {
+        lockForIteration(array);
+        try {
+            return array.map((x, i) => {
+                return call_function(loc_id, source_map, f, x, BigInt(i));
+            });
+        }
+        finally {
+            unlockForIteration(array);
+        }
+    },
+    ArrayFilter: (loc_id, source_map, _platformDef, _T, _T2) => (array, f) => {
+        lockForIteration(array);
+        try {
+            return array.filter((x, i) => {
+                return call_function(loc_id, source_map, f, x, BigInt(i));
+            });
+        }
+        finally {
+            unlockForIteration(array);
+        }
+    },
+    ArrayFilterMap: (loc_id, source_map, _platformDef, _T, _T2) => (array, f) => {
+        lockForIteration(array);
+        try {
+            const result = [];
+            for (let i = 0; i < array.length; i++) {
+                const v = call_function(loc_id, source_map, f, array[i], BigInt(i));
+                if (v.type === "some") {
+                    result.push(v.value);
+                }
+            }
+            return result;
+        }
+        finally {
+            unlockForIteration(array);
+        }
+    },
+    ArrayFirstMap: (loc_id, source_map, _platformDef, _T, _T2) => (array, f) => {
+        lockForIteration(array);
+        try {
+            for (let i = 0; i < array.length; i++) {
+                const v = call_function(loc_id, source_map, f, array[i], BigInt(i));
+                if (v.type === "some") {
+                    return v;
+                }
+            }
+            return variant("none", null);
+        }
+        finally {
+            unlockForIteration(array);
+        }
+    },
+    ArrayFold: (loc_id, source_map, _platformDef, _T, _T2) => (array, init, f) => {
+        lockForIteration(array);
+        try {
+            return array.reduce((acc, x, i) => {
+                return call_function(loc_id, source_map, f, acc, x, BigInt(i));
+            }, init);
+        }
+        finally {
+            unlockForIteration(array);
+        }
+    },
+    ArrayScan: (loc_id, source_map, _platformDef, _T, _T2) => (array, init, f) => {
+        lockForIteration(array);
+        try {
+            const result = [];
+            let acc = init;
+            for (let i = 0; i < array.length; i++) {
+                acc = call_function(loc_id, source_map, f, acc, array[i], BigInt(i));
+                result.push(acc);
+            }
+            return result;
+        }
+        finally {
+            unlockForIteration(array);
+        }
+    },
+    ArrayMapReduce: (loc_id, source_map, _platformDef, _T, _T2) => (array, mapFn, reduceFn) => {
+        if (array.length === 0) {
+            throw new EastError("Cannot reduce empty array with no initial value", { location: (source_map?.resolve(loc_id) ?? []) });
+        }
+        lockForIteration(array);
+        try {
+            let acc = call_function(loc_id, source_map, mapFn, array[0], 0n);
+            for (let i = 1; i < array.length; i++) {
+                const mapped = call_function(loc_id, source_map, mapFn, array[i], BigInt(i));
+                acc = call_function(loc_id, source_map, reduceFn, acc, mapped);
+            }
+            return acc;
+        }
+        finally {
+            unlockForIteration(array);
+        }
+    },
+    ArrayStringJoin: (_loc_id, _source_map, _platformDef) => (x, y) => x.join(y),
+    ArrayToSet: (loc_id, source_map, _platformDef, _T, T2) => {
+        const compare = compareFor(T2);
+        return (array, f) => {
+            lockForIteration(array);
+            try {
+                const result = new SortedSet([], compare);
+                for (let i = 0; i < array.length; i++) {
+                    const v = call_function(loc_id, source_map, f, array[i], BigInt(i));
+                    result.add(v);
+                }
+                return result;
+            }
+            finally {
+                unlockForIteration(array);
+            }
+        };
+    },
+    ArrayToDict: (loc_id, source_map, _platformDef, _T, K2, _T2) => {
+        const compare = compareFor(K2);
+        return (array, keyFn, valueFn, onConflict) => {
+            const result = new SortedMap([], compare);
+            lockForIteration(array);
+            try {
+                for (let i = 0; i < array.length; i++) {
+                    const v = array[i];
+                    const k = call_function(loc_id, source_map, keyFn, v, BigInt(i));
+                    let val = call_function(loc_id, source_map, valueFn, v, BigInt(i));
+                    const existing = result.get(k);
+                    if (existing === undefined) {
+                        result.set(k, val);
+                    }
+                    else {
+                        val = call_function(loc_id, source_map, onConflict, existing, val, k);
+                        result.set(k, val);
+                    }
+                }
+                return result;
+            }
+            finally {
+                unlockForIteration(array);
+            }
+        };
+    },
+    ArrayFlattenToArray: (loc_id, source_map, _platformDef, _T) => (array, fn) => {
+        return array.flatMap(v => {
+            return call_function(loc_id, source_map, fn, v);
+        });
+    },
+    ArrayFlattenToSet: (loc_id, source_map, _platformDef, _T, K2) => {
+        const compare = compareFor(K2);
+        return (array, fn) => {
+            const result = new SortedSet([], compare);
+            lockForIteration(array);
+            try {
+                for (const v of array) {
+                    const subset = call_function(loc_id, source_map, fn, v);
+                    for (const k of subset) {
+                        result.add(k);
+                    }
+                }
+                return result;
+            }
+            finally {
+                unlockForIteration(array);
+            }
+        };
+    },
+    ArrayFlattenToDict: (loc_id, source_map, _platformDef, _T, K2, _T2) => {
+        const compare = compareFor(K2);
+        return (array, fn, onConflict) => {
+            const result = new SortedMap([], compare);
+            lockForIteration(array);
+            try {
+                for (const v of array) {
+                    const subdict = call_function(loc_id, source_map, fn, v);
+                    for (const [k, val] of subdict.entries()) {
+                        const existing = result.get(k);
+                        if (existing === undefined) {
+                            result.set(k, val);
+                        }
+                        else {
+                            const new_val = call_function(loc_id, source_map, onConflict, existing, val, k);
+                            result.set(k, new_val);
+                        }
+                    }
+                }
+                return result;
+            }
+            finally {
+                unlockForIteration(array);
+            }
+        };
+    },
+    ArrayGroupFold: (loc_id, source_map, _platformDef, _T, K2, _V2) => {
+        const compare = compareFor(K2);
+        return (array, keyFn, init, folder) => {
+            const result = new SortedMap([], compare);
+            lockForIteration(array);
+            try {
+                for (let i = 0; i < array.length; i++) {
+                    const v = array[i];
+                    const k = call_function(loc_id, source_map, keyFn, v, BigInt(i));
+                    let existing = result.get(k);
+                    if (existing === undefined) {
+                        existing = call_function(loc_id, source_map, init, k);
+                    }
+                    const new_val = call_function(loc_id, source_map, folder, existing, v, BigInt(i));
+                    result.set(k, new_val);
+                }
+                return result;
+            }
+            finally {
+                unlockForIteration(array);
+            }
+        };
+    },
+    ArrayToTree: (loc_id, source_map, _platformDef, _T, K, _N) => {
+        const compare = compareFor(K);
+        const print = printFor(K);
+        return (array, keyFn, parentFn, buildFn) => {
+            lockForIteration(array);
+            try {
+                const n = array.length;
+                const keys = [];
+                const index = new SortedMap([], compare);
+                for (let i = 0; i < n; i++) {
+                    const k = call_function(loc_id, source_map, keyFn, array[i], BigInt(i));
+                    if (index.has(k)) {
+                        throw new EastError(`toTree: duplicate key ${print(k)}`, { location: (source_map?.resolve(loc_id) ?? []) });
+                    }
+                    index.set(k, i);
+                    keys.push(k);
+                }
+                const parents = new Int32Array(n);
+                for (let i = 0; i < n; i++) {
+                    const p = call_function(loc_id, source_map, parentFn, array[i], BigInt(i));
+                    parents[i] = p.type === "some" ? (index.get(p.value) ?? -1) : -1;
+                }
+                const { order, childCounts, cycle } = treeOrder(parents);
+                if (cycle >= 0) {
+                    throw new EastError(`toTree: cycle through key ${print(keys[cycle])}`, { location: (source_map?.resolve(loc_id) ?? []) });
+                }
+                return buildTree(order, childCounts, (i, children) => call_function(loc_id, source_map, buildFn, array[i], BigInt(i), children));
+            }
+            finally {
+                unlockForIteration(array);
+            }
+        };
+    },
+};
+//# sourceMappingURL=array.js.map