@jalvin/runtime 2.0.19 → 2.0.20

package/dist/utils.js

@@ -1,1180 +0,0 @@
-"use strict";
-// ─────────────────────────────────────────────────────────────────────────────
-// Runtime utility helpers — used by codegen emitted code
-// ─────────────────────────────────────────────────────────────────────────────
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Default = exports.Random = exports.JalvinRegex = exports.Regex = exports.RegexResult = exports.Result = exports.StringBuilder = exports.IntRange = exports.E = exports.PI = exports.truncate = exports.hypot = exports.sign = exports.atan2 = exports.atan = exports.acos = exports.asin = exports.tan = exports.cos = exports.sin = exports.log10 = exports.log2 = exports.ln = exports.exp = exports.pow = exports.sqrt = exports.round = exports.floor = exports.ceil = exports.abs = exports.Triple = exports.Pair = exports.Long = exports.Int = exports.NoSuchElementException = exports.IndexOutOfBoundsException = exports.UnsupportedOperationException = exports.IllegalStateException = exports.IllegalArgumentException = exports.Delegates = exports.ObservableDelegate = exports.LazyDelegate = exports.NullPointerException = void 0;
-exports.notNull = notNull;
-exports.safeCast = safeCast;
-exports.range = range;
-exports.delegate = delegate;
-exports.lazy = lazy;
-exports.println = println;
-exports.print = print;
-exports.listOf = listOf;
-exports.mutableListOf = mutableListOf;
-exports.setOf = setOf;
-exports.mutableSetOf = mutableSetOf;
-exports.mapOf = mapOf;
-exports.mutableMapOf = mutableMapOf;
-exports.pairOf = pairOf;
-exports.tripleOf = tripleOf;
-exports.checkNotNull = checkNotNull;
-exports.requireNotNull = requireNotNull;
-exports.requireCondition = requireCondition;
-exports.check = check;
-exports.error = error;
-exports.let_ = let_;
-exports.run_ = run_;
-exports.apply = apply;
-exports.also = also;
-exports.with_ = with_;
-exports.takeIf = takeIf;
-exports.takeUnless = takeUnless;
-exports.map = map;
-exports.filter = filter;
-exports.filterNotNull = filterNotNull;
-exports.forEach = forEach;
-exports.fold = fold;
-exports.reduce = reduce;
-exports.sumOf = sumOf;
-exports.any = any;
-exports.all = all;
-exports.none = none;
-exports.count = count;
-exports.first = first;
-exports.firstOrNull = firstOrNull;
-exports.last = last;
-exports.lastOrNull = lastOrNull;
-exports.find = find;
-exports.findLast = findLast;
-exports.flatMap = flatMap;
-exports.flatten = flatten;
-exports.groupBy = groupBy;
-exports.associate = associate;
-exports.zip = zip;
-exports.distinct = distinct;
-exports.distinctBy = distinctBy;
-exports.sortedBy = sortedBy;
-exports.sortedByDescending = sortedByDescending;
-exports.reversed = reversed;
-exports.chunked = chunked;
-exports.windowed = windowed;
-exports.partition = partition;
-exports.withIndex = withIndex;
-exports.minOf = minOf;
-exports.maxOf = maxOf;
-exports.minOrNull = minOrNull;
-exports.maxOrNull = maxOrNull;
-exports.joinToString = joinToString;
-exports.take = take;
-exports.takeWhile = takeWhile;
-exports.drop = drop;
-exports.dropWhile = dropWhile;
-exports.coerceAtLeast = coerceAtLeast;
-exports.coerceAtMost = coerceAtMost;
-exports.coerceIn = coerceIn;
-exports.trimIndent = trimIndent;
-exports.repeat_ = repeat_;
-exports.isBlank = isBlank;
-exports.isNotBlank = isNotBlank;
-exports.isNullOrBlank = isNullOrBlank;
-exports.toIntOrNull = toIntOrNull;
-exports.toDoubleOrNull = toDoubleOrNull;
-exports.toBooleanOrNull = toBooleanOrNull;
-exports.padStart = padStart;
-exports.padEnd = padEnd;
-exports.clamp = clamp;
-exports.truncDiv = truncDiv;
-exports.capitalize = capitalize;
-exports.decapitalize = decapitalize;
-exports.substringBefore = substringBefore;
-exports.substringAfter = substringAfter;
-exports.substringBeforeLast = substringBeforeLast;
-exports.substringAfterLast = substringAfterLast;
-exports.removePrefix = removePrefix;
-exports.removeSuffix = removeSuffix;
-exports.lines = lines;
-exports.lineSequence = lineSequence;
-exports.ifEmpty = ifEmpty;
-exports.ifBlank = ifBlank;
-exports.toInt = toInt;
-exports.toLong = toLong;
-exports.toFloat = toFloat;
-exports.toDouble = toDouble;
-exports.toChar = toChar;
-exports.charCodeOf = charCodeOf;
-exports.toString = toString;
-exports.downTo = downTo;
-exports.step = step;
-exports.buildString = buildString;
-exports.buildList = buildList;
-exports.buildSet = buildSet;
-exports.buildMap = buildMap;
-exports.runCatching = runCatching;
-exports.runCatchingAsync = runCatchingAsync;
-exports.measureTimeMillis = measureTimeMillis;
-exports.measureTimeMillisAsync = measureTimeMillisAsync;
-exports.measureTimedValue = measureTimedValue;
-exports.randomUUID = randomUUID;
-exports.jalvinEquals = jalvinEquals;
-/**
- * `notNull(value)` — emitted for Jalvin's `!!` operator.
- * Throws if value is null/undefined, otherwise returns the value.
- */
-function notNull(value) {
-    if (value === null || value === undefined) {
-        throw new NullPointerException("!! operator invoked on null or undefined value");
-    }
-    return value;
-}
-class NullPointerException extends Error {
-    constructor(message = "Value was null") {
-        super(message);
-        this.name = "NullPointerException";
-    }
-}
-exports.NullPointerException = NullPointerException;
-/**
- * `safeCast<T>(value, Type)` — emitted for Jalvin's `as?` operator.
- * Returns the value if it's an instanceof Type, otherwise returns null.
- */
-function safeCast(value, 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-Type) {
-    return value instanceof Type ? value : null;
-}
-/**
- * `range(from, to, inclusive)` — emitted for `..` and `..<` range operators.
- * Returns an iterable of numbers.
- */
-function* range(from, to, inclusive) {
-    for (let i = from; inclusive ? i <= to : i < to; i++) {
-        yield i;
-    }
-}
-function delegate(impl, _name, _receiver) {
-    return impl;
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Built-in Delegates
-// ─────────────────────────────────────────────────────────────────────────────
-class LazyDelegate {
-    _init;
-    _value;
-    _initialized = false;
-    constructor(_init) {
-        this._init = _init;
-    }
-    getValue() {
-        if (!this._initialized) {
-            this._value = this._init();
-            this._initialized = true;
-        }
-        return this._value;
-    }
-    setValue(_v) {
-        throw new Error("Cannot set a lazy property");
-    }
-}
-exports.LazyDelegate = LazyDelegate;
-function lazy(init) {
-    return new LazyDelegate(init);
-}
-class ObservableDelegate {
-    _value;
-    _onChange;
-    _name;
-    constructor(_value, _onChange, _name = "") {
-        this._value = _value;
-        this._onChange = _onChange;
-        this._name = _name;
-    }
-    getValue() { return this._value; }
-    setValue(value) {
-        const old = this._value;
-        this._value = value;
-        this._onChange(this._name, old, value);
-    }
-}
-exports.ObservableDelegate = ObservableDelegate;
-exports.Delegates = {
-    observable(initial, onChange) {
-        return new ObservableDelegate(initial, onChange);
-    },
-    notNull() {
-        let _v;
-        return {
-            getValue() {
-                if (_v === undefined)
-                    throw new NullPointerException("Delegated property was not initialised");
-                return _v;
-            },
-            setValue(v) { _v = v; },
-        };
-    },
-};
-// ─────────────────────────────────────────────────────────────────────────────
-// Standard library shims
-// ─────────────────────────────────────────────────────────────────────────────
-function println(...args) {
-    console.log(...args);
-}
-function print(...args) {
-    process.stdout?.write(args.map(String).join(""));
-}
-function listOf(...items) {
-    return Object.freeze([...items]);
-}
-function mutableListOf(...items) {
-    return [...items];
-}
-function setOf(...items) {
-    return Object.freeze(new Set(items));
-}
-function mutableSetOf(...items) {
-    return new Set(items);
-}
-function mapOf(...entries) {
-    return Object.freeze(new Map(entries));
-}
-function mutableMapOf(...entries) {
-    return new Map(entries);
-}
-function pairOf(first, second) {
-    return [first, second];
-}
-function tripleOf(first, second, third) {
-    return [first, second, third];
-}
-function checkNotNull(value, message = "Value must not be null") {
-    return notNull(value) ?? (() => { throw new NullPointerException(message); })();
-}
-function requireNotNull(value, message = "Required value was null") {
-    return notNull(value);
-}
-function requireCondition(condition, message = "Requirement failed") {
-    if (!condition) {
-        throw new IllegalArgumentException(typeof message === "function" ? message() : message);
-    }
-}
-function check(condition, message = "Check failed") {
-    if (!condition) {
-        throw new IllegalStateException(typeof message === "function" ? message() : message);
-    }
-}
-function error(message) {
-    throw new IllegalStateException(message);
-}
-class IllegalArgumentException extends Error {
-    constructor(message) { super(message); this.name = "IllegalArgumentException"; }
-}
-exports.IllegalArgumentException = IllegalArgumentException;
-class IllegalStateException extends Error {
-    constructor(message) { super(message); this.name = "IllegalStateException"; }
-}
-exports.IllegalStateException = IllegalStateException;
-class UnsupportedOperationException extends Error {
-    constructor(message = "Operation is not supported") { super(message); this.name = "UnsupportedOperationException"; }
-}
-exports.UnsupportedOperationException = UnsupportedOperationException;
-class IndexOutOfBoundsException extends Error {
-    constructor(message = "Index out of bounds") { super(message); this.name = "IndexOutOfBoundsException"; }
-}
-exports.IndexOutOfBoundsException = IndexOutOfBoundsException;
-class NoSuchElementException extends Error {
-    constructor(message = "No such element") { super(message); this.name = "NoSuchElementException"; }
-}
-exports.NoSuchElementException = NoSuchElementException;
-// ─────────────────────────────────────────────────────────────────────────────
-// Scope functions
-// ─────────────────────────────────────────────────────────────────────────────
-/**
- * `let` — calls `block` with `this` as argument, returns the block result.
- * Usage: `value.let { v -> transform(v) }`
- */
-function let_(value, block) {
-    return block(value);
-}
-/**
- * `run` — calls `block` with `this` as receiver, returns the block result.
- * Usage: `obj.run { doSomething() }`
- */
-function run_(value, block) {
-    return block.call(value);
-}
-/**
- * `apply` — calls `block` with `this` as receiver, returns the original value.
- * Usage: `obj.apply { configure() }`
- */
-function apply(value, block) {
-    block.call(value);
-    return value;
-}
-/**
- * `also` — calls `block` with `this` as argument, returns the original value.
- * Usage: `value.also { v -> sideEffect(v) }`
- */
-function also(value, block) {
-    block(value);
-    return value;
-}
-/**
- * `with` — calls `block` with `receiver` as receiver, returns block result.
- * Usage: `with(obj) { doSomething() }`
- */
-function with_(receiver, block) {
-    return block.call(receiver);
-}
-/**
- * `takeIf` — returns `this` if `predicate` is true, otherwise null.
- */
-function takeIf(value, predicate) {
-    return predicate(value) ? value : null;
-}
-/**
- * `takeUnless` — returns `this` if `predicate` is false, otherwise null.
- */
-function takeUnless(value, predicate) {
-    return predicate(value) ? null : value;
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Standard library collection extensions
-// ─────────────────────────────────────────────────────────────────────────────
-function map(iterable, transform) {
-    const result = [];
-    for (const item of iterable)
-        result.push(transform(item));
-    return result;
-}
-function filter(iterable, predicate) {
-    const result = [];
-    for (const item of iterable)
-        if (predicate(item))
-            result.push(item);
-    return result;
-}
-function filterNotNull(iterable) {
-    const result = [];
-    for (const item of iterable)
-        if (item != null)
-            result.push(item);
-    return result;
-}
-function forEach(iterable, action) {
-    for (const item of iterable)
-        action(item);
-}
-function fold(iterable, initial, operation) {
-    let acc = initial;
-    for (const item of iterable)
-        acc = operation(acc, item);
-    return acc;
-}
-function reduce(iterable, operation) {
-    let first = true;
-    let acc;
-    for (const item of iterable) {
-        if (first) {
-            acc = item;
-            first = false;
-        }
-        else
-            acc = operation(acc, item);
-    }
-    if (first)
-        throw new NoSuchElementException("Collection is empty");
-    return acc;
-}
-function sumOf(iterable, selector) {
-    let sum = 0;
-    for (const item of iterable)
-        sum += selector(item);
-    return sum;
-}
-function any(iterable, predicate) {
-    for (const item of iterable)
-        if (predicate(item))
-            return true;
-    return false;
-}
-function all(iterable, predicate) {
-    for (const item of iterable)
-        if (!predicate(item))
-            return false;
-    return true;
-}
-function none(iterable, predicate) {
-    for (const item of iterable)
-        if (predicate(item))
-            return false;
-    return true;
-}
-function count(iterable, predicate) {
-    let n = 0;
-    for (const item of iterable)
-        if (!predicate || predicate(item))
-            n++;
-    return n;
-}
-function first(iterable, predicate) {
-    for (const item of iterable)
-        if (!predicate || predicate(item))
-            return item;
-    throw new NoSuchElementException("No element matching predicate");
-}
-function firstOrNull(iterable, predicate) {
-    for (const item of iterable)
-        if (!predicate || predicate(item))
-            return item;
-    return null;
-}
-function last(arr, predicate) {
-    for (let i = arr.length - 1; i >= 0; i--) {
-        if (!predicate || predicate(arr[i]))
-            return arr[i];
-    }
-    throw new NoSuchElementException("No element matching predicate");
-}
-function lastOrNull(arr, predicate) {
-    for (let i = arr.length - 1; i >= 0; i--) {
-        if (!predicate || predicate(arr[i]))
-            return arr[i];
-    }
-    return null;
-}
-function find(iterable, predicate) {
-    return firstOrNull(iterable, predicate);
-}
-function findLast(arr, predicate) {
-    return lastOrNull(arr, predicate);
-}
-function flatMap(iterable, transform) {
-    const result = [];
-    for (const item of iterable)
-        for (const inner of transform(item))
-            result.push(inner);
-    return result;
-}
-function flatten(iterable) {
-    const result = [];
-    for (const inner of iterable)
-        for (const item of inner)
-            result.push(item);
-    return result;
-}
-function groupBy(iterable, keySelector) {
-    const map = new Map();
-    for (const item of iterable) {
-        const key = keySelector(item);
-        const group = map.get(key);
-        if (group)
-            group.push(item);
-        else
-            map.set(key, [item]);
-    }
-    return map;
-}
-function associate(iterable, transform) {
-    const map = new Map();
-    for (const item of iterable) {
-        const [k, v] = transform(item);
-        map.set(k, v);
-    }
-    return map;
-}
-function zip(a, b) {
-    const len = Math.min(a.length, b.length);
-    const result = [];
-    for (let i = 0; i < len; i++)
-        result.push([a[i], b[i]]);
-    return result;
-}
-function distinct(iterable) {
-    return [...new Set(iterable)];
-}
-function distinctBy(iterable, selector) {
-    const seen = new Set();
-    const result = [];
-    for (const item of iterable) {
-        const key = selector(item);
-        if (!seen.has(key)) {
-            seen.add(key);
-            result.push(item);
-        }
-    }
-    return result;
-}
-function sortedBy(arr, selector) {
-    return [...arr].sort((a, b) => {
-        const ka = selector(a), kb = selector(b);
-        return ka < kb ? -1 : ka > kb ? 1 : 0;
-    });
-}
-function sortedByDescending(arr, selector) {
-    return [...arr].sort((a, b) => {
-        const ka = selector(a), kb = selector(b);
-        return ka > kb ? -1 : ka < kb ? 1 : 0;
-    });
-}
-function reversed(arr) {
-    return [...arr].reverse();
-}
-function chunked(arr, size) {
-    const result = [];
-    for (let i = 0; i < arr.length; i += size)
-        result.push(arr.slice(i, i + size));
-    return result;
-}
-function windowed(arr, size, step = 1) {
-    const result = [];
-    for (let i = 0; i <= arr.length - size; i += step)
-        result.push(arr.slice(i, i + size));
-    return result;
-}
-function partition(iterable, predicate) {
-    const yes = [], no = [];
-    for (const item of iterable)
-        (predicate(item) ? yes : no).push(item);
-    return [yes, no];
-}
-function withIndex(iterable) {
-    const result = [];
-    let i = 0;
-    for (const value of iterable)
-        result.push({ index: i++, value });
-    return result;
-}
-function minOf(iterable, selector) {
-    let min = Infinity;
-    for (const item of iterable) {
-        const v = selector(item);
-        if (v < min)
-            min = v;
-    }
-    return min;
-}
-function maxOf(iterable, selector) {
-    let max = -Infinity;
-    for (const item of iterable) {
-        const v = selector(item);
-        if (v > max)
-            max = v;
-    }
-    return max;
-}
-function minOrNull(arr, selector) {
-    if (arr.length === 0)
-        return null;
-    let minItem = arr[0];
-    let minVal = selector(minItem);
-    for (let i = 1; i < arr.length; i++) {
-        const v = selector(arr[i]);
-        if (v < minVal) {
-            minVal = v;
-            minItem = arr[i];
-        }
-    }
-    return minItem;
-}
-function maxOrNull(arr, selector) {
-    if (arr.length === 0)
-        return null;
-    let maxItem = arr[0];
-    let maxVal = selector(maxItem);
-    for (let i = 1; i < arr.length; i++) {
-        const v = selector(arr[i]);
-        if (v > maxVal) {
-            maxVal = v;
-            maxItem = arr[i];
-        }
-    }
-    return maxItem;
-}
-function joinToString(iterable, separator = ", ", prefix = "", suffix = "", transform) {
-    const parts = [];
-    for (const item of iterable)
-        parts.push(transform ? transform(item) : String(item));
-    return prefix + parts.join(separator) + suffix;
-}
-function take(arr, n) {
-    return arr.slice(0, n);
-}
-function takeWhile(iterable, predicate) {
-    const result = [];
-    for (const item of iterable) {
-        if (!predicate(item))
-            break;
-        result.push(item);
-    }
-    return result;
-}
-function drop(arr, n) {
-    return arr.slice(n);
-}
-function dropWhile(iterable, predicate) {
-    const result = [];
-    let dropping = true;
-    for (const item of iterable) {
-        if (dropping && predicate(item))
-            continue;
-        dropping = false;
-        result.push(item);
-    }
-    return result;
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Numeric extensions
-// ─────────────────────────────────────────────────────────────────────────────
-function coerceAtLeast(value, min) {
-    return value < min ? min : value;
-}
-function coerceAtMost(value, max) {
-    return value > max ? max : value;
-}
-function coerceIn(value, min, max) {
-    return value < min ? min : value > max ? max : value;
-}
-/** `Int.MAX_VALUE` and friends */
-exports.Int = {
-    MAX_VALUE: 2147483647,
-    MIN_VALUE: -2147483648,
-};
-exports.Long = {
-    MAX_VALUE: BigInt("9223372036854775807"),
-    MIN_VALUE: BigInt("-9223372036854775808"),
-};
-// ─────────────────────────────────────────────────────────────────────────────
-// String extensions
-// ─────────────────────────────────────────────────────────────────────────────
-function trimIndent(s) {
-    const lines = s.split("\n");
-    const nonEmpty = lines.filter((l) => l.trim().length > 0);
-    const indent = nonEmpty.reduce((min, l) => {
-        const m = l.match(/^(\s*)/);
-        return Math.min(min, m?.[1]?.length ?? 0);
-    }, Infinity);
-    const clean = isFinite(indent) ? indent : 0;
-    return lines.map((l) => l.slice(clean)).join("\n").replace(/^\n/, "").replace(/\n$/, "");
-}
-function repeat_(s, n) {
-    return s.repeat(n);
-}
-function isBlank(s) {
-    return s.trim().length === 0;
-}
-function isNotBlank(s) {
-    return s.trim().length > 0;
-}
-function isNullOrBlank(s) {
-    return s == null || s.trim().length === 0;
-}
-function toIntOrNull(s) {
-    const n = parseInt(s, 10);
-    return isNaN(n) ? null : n;
-}
-function toDoubleOrNull(s) {
-    const n = parseFloat(s);
-    return isNaN(n) ? null : n;
-}
-function toBooleanOrNull(s) {
-    if (s.toLowerCase() === "true")
-        return true;
-    if (s.toLowerCase() === "false")
-        return false;
-    return null;
-}
-function padStart(s, length, padChar = " ") {
-    return s.padStart(length, padChar);
-}
-function padEnd(s, length, padChar = " ") {
-    return s.padEnd(length, padChar);
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Pair / Triple as classes (mirrors pairOf/tripleOf)
-// ─────────────────────────────────────────────────────────────────────────────
-class Pair {
-    first;
-    second;
-    constructor(first, second) {
-        this.first = first;
-        this.second = second;
-    }
-    toList() { return [this.first, this.second]; }
-    [Symbol.iterator]() {
-        let i = 0;
-        const vals = [this.first, this.second];
-        return { next: () => i < vals.length ? { value: vals[i++], done: false } : { value: undefined, done: true } };
-    }
-    toString() { return `(${this.first}, ${this.second})`; }
-    copy(first = this.first, second = this.second) { return new Pair(first, second); }
-}
-exports.Pair = Pair;
-class Triple {
-    first;
-    second;
-    third;
-    constructor(first, second, third) {
-        this.first = first;
-        this.second = second;
-        this.third = third;
-    }
-    [Symbol.iterator]() {
-        let i = 0;
-        const vals = [this.first, this.second, this.third];
-        return { next: () => i < vals.length ? { value: vals[i++], done: false } : { value: undefined, done: true } };
-    }
-    toString() { return `(${this.first}, ${this.second}, ${this.third})`; }
-}
-exports.Triple = Triple;
-// ─────────────────────────────────────────────────────────────────────────────
-// Math library
-// ─────────────────────────────────────────────────────────────────────────────
-exports.abs = Math.abs.bind(Math);
-exports.ceil = Math.ceil.bind(Math);
-exports.floor = Math.floor.bind(Math);
-exports.round = Math.round.bind(Math);
-exports.sqrt = Math.sqrt.bind(Math);
-exports.pow = Math.pow.bind(Math);
-exports.exp = Math.exp.bind(Math);
-exports.ln = Math.log.bind(Math);
-exports.log2 = Math.log2.bind(Math);
-exports.log10 = Math.log10.bind(Math);
-exports.sin = Math.sin.bind(Math);
-exports.cos = Math.cos.bind(Math);
-exports.tan = Math.tan.bind(Math);
-exports.asin = Math.asin.bind(Math);
-exports.acos = Math.acos.bind(Math);
-exports.atan = Math.atan.bind(Math);
-exports.atan2 = Math.atan2.bind(Math);
-exports.sign = Math.sign.bind(Math);
-exports.hypot = Math.hypot.bind(Math);
-exports.truncate = Math.trunc.bind(Math);
-exports.PI = Math.PI;
-exports.E = Math.E;
-/** Clamp a numeric value to a range */
-function clamp(value, min, max) {
-    return Math.max(min, Math.min(max, value));
-}
-/** Returns the integer part, rounding towards zero */
-function truncDiv(a, b) {
-    return Math.trunc(a / b);
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Extended String utilities
-// ─────────────────────────────────────────────────────────────────────────────
-function capitalize(s) {
-    return s.length === 0 ? s : s[0].toUpperCase() + s.slice(1);
-}
-function decapitalize(s) {
-    return s.length === 0 ? s : s[0].toLowerCase() + s.slice(1);
-}
-function substringBefore(s, delimiter) {
-    const idx = s.indexOf(delimiter);
-    return idx === -1 ? s : s.slice(0, idx);
-}
-function substringAfter(s, delimiter) {
-    const idx = s.indexOf(delimiter);
-    return idx === -1 ? "" : s.slice(idx + delimiter.length);
-}
-function substringBeforeLast(s, delimiter) {
-    const idx = s.lastIndexOf(delimiter);
-    return idx === -1 ? s : s.slice(0, idx);
-}
-function substringAfterLast(s, delimiter) {
-    const idx = s.lastIndexOf(delimiter);
-    return idx === -1 ? "" : s.slice(idx + delimiter.length);
-}
-function removePrefix(s, prefix) {
-    return s.startsWith(prefix) ? s.slice(prefix.length) : s;
-}
-function removeSuffix(s, suffix) {
-    return s.endsWith(suffix) ? s.slice(0, s.length - suffix.length) : s;
-}
-function lines(s) {
-    return s.split(/\r?\n/);
-}
-function lineSequence(s) {
-    return lines(s);
-}
-function ifEmpty(value, default_) {
-    return (value == null || value.length === 0) ? default_() : value;
-}
-function ifBlank(value, default_) {
-    return (value == null || value.trim().length === 0) ? default_() : value;
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Type conversion helpers
-// ─────────────────────────────────────────────────────────────────────────────
-function toInt(v) {
-    return typeof v === "boolean" ? (v ? 1 : 0) : Math.trunc(Number(v));
-}
-function toLong(v) {
-    return toInt(v);
-}
-function toFloat(v) {
-    return Number(v);
-}
-function toDouble(v) {
-    return Number(v);
-}
-function toChar(code) {
-    return String.fromCharCode(code);
-}
-function charCodeOf(ch) {
-    return ch.charCodeAt(0);
-}
-function toString(v) {
-    return String(v);
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// IntRange — backing type for `..`, `..<`, `downTo`, `step`
-// ─────────────────────────────────────────────────────────────────────────────
-class IntRange {
-    start;
-    endInclusive;
-    stepSize;
-    constructor(start, endInclusive, stepSize = 1) {
-        this.start = start;
-        this.endInclusive = endInclusive;
-        this.stepSize = stepSize;
-    }
-    get isEmpty() {
-        return this.stepSize > 0 ? this.start > this.endInclusive : this.start < this.endInclusive;
-    }
-    contains(n) {
-        if (this.stepSize > 0)
-            return n >= this.start && n <= this.endInclusive;
-        return n <= this.start && n >= this.endInclusive;
-    }
-    [Symbol.iterator]() {
-        let current = this.start;
-        const end = this.endInclusive;
-        const s = this.stepSize;
-        return {
-            next() {
-                if (s > 0 ? current <= end : current >= end) {
-                    const value = current;
-                    current += s;
-                    return { value, done: false };
-                }
-                return { value: 0, done: true };
-            }
-        };
-    }
-    toList() { return [...this]; }
-    count() { return Math.max(0, Math.floor((this.endInclusive - this.start) / this.stepSize) + 1); }
-    first() { return this.start; }
-    last() {
-        if (this.stepSize === 0)
-            return this.start;
-        const n = Math.floor((this.endInclusive - this.start) / this.stepSize);
-        return this.start + n * this.stepSize;
-    }
-    toString() { return `${this.start}..${this.endInclusive} step ${this.stepSize}`; }
-}
-exports.IntRange = IntRange;
-/** `5 downTo 1` — infix desugaring `5.downTo(1)` → `downTo(5, 1)` */
-function downTo(start, end) {
-    return new IntRange(start, end, -1);
-}
-/** `(1..10).step(2)` — sets a custom step on a range */
-function step(range_, stepVal) {
-    return new IntRange(range_.start, range_.endInclusive, stepVal);
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Collection builders — buildList {}, buildSet {}, buildMap {}, buildString {}
-// ─────────────────────────────────────────────────────────────────────────────
-class StringBuilder {
-    _parts = [];
-    append(s) { this._parts.push(String(s ?? "")); return this; }
-    appendLine(s = "") { this._parts.push(String(s)); this._parts.push("\n"); return this; }
-    prepend(s) { this._parts.unshift(String(s ?? "")); return this; }
-    clear() { this._parts.length = 0; return this; }
-    get length() { return this._parts.reduce((sum, p) => sum + p.length, 0); }
-    isEmpty() { return this.length === 0; }
-    isNotEmpty() { return this.length > 0; }
-    toString() { return this._parts.join(""); }
-}
-exports.StringBuilder = StringBuilder;
-function buildString(fn) {
-    const sb = new StringBuilder();
-    fn(sb);
-    return sb.toString();
-}
-function buildList(fn) {
-    const arr = [];
-    fn({
-        add(item) { arr.push(item); },
-        addAll(items) { for (const i of items)
-            arr.push(i); },
-        get size() { return arr.length; },
-    });
-    return arr;
-}
-function buildSet(fn) {
-    const s = new Set();
-    fn({
-        add(item) { s.add(item); },
-        addAll(items) { for (const i of items)
-            s.add(i); },
-        get size() { return s.size; },
-    });
-    return s;
-}
-function buildMap(fn) {
-    const m = new Map();
-    fn({
-        put(key, value) { m.set(key, value); },
-        putAll(entries) { for (const [k, v] of entries)
-            m.set(k, v); },
-        get size() { return m.size; },
-    });
-    return m;
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Result<T> — mirrors standard Result type
-// ─────────────────────────────────────────────────────────────────────────────
-class Result {
-    _value;
-    _error;
-    _ok;
-    constructor(_value, _error, _ok) {
-        this._value = _value;
-        this._error = _error;
-        this._ok = _ok;
-    }
-    static success(value) { return new Result(value, undefined, true); }
-    static failure(error) { return new Result(undefined, error, false); }
-    get isSuccess() { return this._ok; }
-    get isFailure() { return !this._ok; }
-    getOrNull() { return this._ok ? this._value : null; }
-    getOrUndefined() { return this._ok ? this._value : undefined; }
-    getOrThrow() {
-        if (this._ok)
-            return this._value;
-        throw this._error;
-    }
-    getOrDefault(default_) { return this._ok ? this._value : default_; }
-    getOrElse(fn) { return this._ok ? this._value : fn(this._error); }
-    exceptionOrNull() { return this._ok ? null : this._error; }
-    map(fn) {
-        if (!this._ok)
-            return Result.failure(this._error);
-        try {
-            return Result.success(fn(this._value));
-        }
-        catch (e) {
-            return Result.failure(e);
-        }
-    }
-    mapCatching(fn) { return this.map(fn); }
-    recover(fn) {
-        if (this._ok)
-            return this;
-        try {
-            return Result.success(fn(this._error));
-        }
-        catch (e) {
-            return Result.failure(e);
-        }
-    }
-    onSuccess(fn) {
-        if (this._ok)
-            fn(this._value);
-        return this;
-    }
-    onFailure(fn) {
-        if (!this._ok)
-            fn(this._error);
-        return this;
-    }
-    fold(onSuccess, onFailure) {
-        return this._ok ? onSuccess(this._value) : onFailure(this._error);
-    }
-    toString() {
-        return this._ok ? `Result.success(${this._value})` : `Result.failure(${this._error})`;
-    }
-}
-exports.Result = Result;
-/** Wrap a throwing function call in a Result. */
-function runCatching(fn) {
-    try {
-        return Result.success(fn());
-    }
-    catch (e) {
-        return Result.failure(e);
-    }
-}
-/** Async variant — wraps a Promise-returning function. */
-async function runCatchingAsync(fn) {
-    try {
-        return Result.success(await fn());
-    }
-    catch (e) {
-        return Result.failure(e);
-    }
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Regex — thin wrapper over JS RegExp
-// ─────────────────────────────────────────────────────────────────────────────
-class RegexResult {
-    value;
-    range;
-    groupValues;
-    constructor(value, range, groupValues) {
-        this.value = value;
-        this.range = range;
-        this.groupValues = groupValues;
-    }
-}
-exports.RegexResult = RegexResult;
-class Regex {
-    _re;
-    constructor(pattern, options = "") {
-        // Convert regex options: IGNORE_CASE → i, MULTILINE → m
-        const flags = options
-            .replace("IGNORE_CASE", "i")
-            .replace("MULTILINE", "m")
-            .replace("DOT_MATCHES_ALL", "s")
-            .replace(/[^gimsuy]/g, "");
-        this._re = new RegExp(pattern, flags || undefined);
-    }
-    /** Returns true if the entire input matches this regex (anchored). */
-    matches(input) {
-        const re = new RegExp(`^(?:${this._re.source})$`, this._re.flags.replace("g", ""));
-        return re.test(input);
-    }
-    /** Returns true if any part of the input matches. */
-    containsMatchIn(input) {
-        const re = new RegExp(this._re.source, this._re.flags.replace("g", ""));
-        return re.test(input);
-    }
-    find(input, startIndex = 0) {
-        const re = new RegExp(this._re.source, "g" + this._re.flags.replace("g", ""));
-        re.lastIndex = startIndex;
-        const m = re.exec(input);
-        if (!m)
-            return null;
-        return new RegexResult(m[0], { start: m.index, endInclusive: m.index + m[0].length - 1 }, m.slice(1).map((g) => g ?? ""));
-    }
-    findAll(input, startIndex = 0) {
-        const re = new RegExp(this._re.source, "g" + this._re.flags.replace("g", ""));
-        re.lastIndex = startIndex;
-        const results = [];
-        let m;
-        while ((m = re.exec(input)) !== null) {
-            results.push(new RegexResult(m[0], { start: m.index, endInclusive: m.index + m[0].length - 1 }, m.slice(1).map((g) => g ?? "")));
-        }
-        return results;
-    }
-    replace(input, replacement) {
-        const re = new RegExp(this._re.source, "g" + this._re.flags.replace("g", ""));
-        if (typeof replacement === "string")
-            return input.replace(re, replacement);
-        return input.replace(re, (match, ...groups) => {
-            const index = groups[groups.length - 2];
-            const r = new RegexResult(match, { start: index, endInclusive: index + match.length - 1 }, groups.slice(0, -2).map(String));
-            return replacement(r);
-        });
-    }
-    replaceFirst(input, replacement) {
-        const re = new RegExp(this._re.source, this._re.flags.replace("g", ""));
-        return input.replace(re, replacement);
-    }
-    split(input, limit) {
-        const parts = input.split(this._re);
-        return limit !== undefined ? parts.slice(0, limit) : parts;
-    }
-    toPattern() { return this._re.source; }
-    toString() { return this._re.toString(); }
-}
-exports.Regex = Regex;
-exports.JalvinRegex = Regex;
-// ─────────────────────────────────────────────────────────────────────────────
-// Timing utilities
-// ─────────────────────────────────────────────────────────────────────────────
-/** Measures how long a synchronous function takes in milliseconds. */
-function measureTimeMillis(fn) {
-    const start = performance.now();
-    fn();
-    return Math.round(performance.now() - start);
-}
-/** Measures how long an async function takes in milliseconds. */
-async function measureTimeMillisAsync(fn) {
-    const start = performance.now();
-    await fn();
-    return Math.round(performance.now() - start);
-}
-function measureTimedValue(fn) {
-    const start = performance.now();
-    const value = fn();
-    return { value, duration: Math.round(performance.now() - start) };
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Random
-// ─────────────────────────────────────────────────────────────────────────────
-class Random {
-    seed;
-    constructor(seed) {
-        this.seed = seed;
-        // Seeding is approximate — JS Math.random() is not seedable natively
-        // For reproducible tests, use a third-party seeded PRNG
-    }
-    nextInt(fromOrUntil, until) {
-        if (fromOrUntil === undefined)
-            return Math.floor(Math.random() * 2147483647);
-        if (until === undefined)
-            return Math.floor(Math.random() * fromOrUntil);
-        return fromOrUntil + Math.floor(Math.random() * (until - fromOrUntil));
-    }
-    nextLong(until) { return this.nextInt(until ?? 2147483647); }
-    nextDouble() { return Math.random(); }
-    nextFloat() { return Math.random(); }
-    nextBoolean() { return Math.random() < 0.5; }
-    nextBytes(size) {
-        const arr = new Uint8Array(size);
-        for (let i = 0; i < size; i++)
-            arr[i] = this.nextInt(256);
-        return arr;
-    }
-}
-exports.Random = Random;
-/** The default global Random instance. */
-exports.Default = new Random();
-/** Generate a RFC 4122 v4 UUID string. */
-function randomUUID() {
-    if (typeof crypto !== "undefined" && crypto.randomUUID) {
-        return crypto.randomUUID();
-    }
-    // Fallback for environments without crypto.randomUUID
-    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
-        const r = (Math.random() * 16) | 0;
-        return (c === "x" ? r : (r & 0x3) | 0x8).toString(16);
-    });
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Structural equality — backs the Jalvin `==` operator
-// ─────────────────────────────────────────────────────────────────────────────
-/**
- * Structural equality check:
- *  - null-safe: `null == null` is `true`, `null == anything` is `false`
- *  - for objects that expose an `.equals(other)` method, delegates to it
- *  - for primitives and everything else, falls back to `===`
- */
-function jalvinEquals(a, b) {
-    if (a === b)
-        return true;
-    if (a === null || a === undefined || b === null || b === undefined)
-        return false;
-    if (typeof a === "object" && typeof a["equals"] === "function") {
-        return a.equals(b);
-    }
-    if (Array.isArray(a) && Array.isArray(b)) {
-        if (a.length !== b.length)
-            return false;
-        return a.every((v, i) => jalvinEquals(v, b[i]));
-    }
-    return false;
-}
-//# sourceMappingURL=utils.js.map