oakscriptjs 0.9.4 → 0.9.6

package/dist/cjs/array/index.js

@@ -85,11 +85,27 @@ function new_array(size2 = 0, initial_value) {
 function size(id) {
   return id.length;
 }
+function isNa(v) {
+  return v === void 0 || v === null || typeof v === "number" && Number.isNaN(v);
+}
+function naOf(id) {
+  return id.length === 0 || typeof id[0] === "number" ? NaN : void 0;
+}
+function position(name, id, index, extra = 0) {
+  const i = Math.trunc(index);
+  const n = id.length;
+  if (i < -n || i >= n + extra) {
+    throw new Error(`array.${name}: index ${i} is out of bounds, array size is ${n}`);
+  }
+  return i < 0 ? i + n : i;
+}
 function get(id, index) {
-  return id[index];
+  if (Number.isNaN(index)) return naOf(id);
+  return id[position("get", id, index)];
 }
 function set(id, index, value) {
-  id[index] = value;
+  if (Number.isNaN(index)) return;
+  id[position("set", id, index)] = value;
 }
 function push(id, value) {
   id.push(value);
@@ -107,25 +123,46 @@ function clear(id) {
   id.length = 0;
 }
 function insert(id, index, value) {
-  id.splice(index, 0, value);
+  if (Number.isNaN(index)) {
+    id.push(value);
+    return;
+  }
+  id.splice(position("insert", id, index, 1), 0, value);
 }
 function remove(id, index) {
-  return id.splice(index, 1)[0];
+  if (Number.isNaN(index)) return naOf(id);
+  return id.splice(position("remove", id, index), 1)[0];
+}
+function pineEqual(a, b) {
+  if (isNa(a) || isNa(b)) return false;
+  if (a === b) return true;
+  if (typeof a === "number" && typeof b === "number") {
+    const d = a - b;
+    return -1e-10 <= d && d <= 1e-10;
+  }
+  return false;
 }
 function includes(id, value) {
-  return id.includes(value);
+  return indexof(id, value) >= 0;
 }
 function indexof(id, value) {
-  return id.indexOf(value);
+  for (let i = 0; i < id.length; i++) {
+    if (pineEqual(id[i], value)) return i;
+  }
+  return -1;
 }
 function lastindexof(id, value) {
-  return id.lastIndexOf(value);
+  for (let i = id.length - 1; i >= 0; i--) {
+    if (pineEqual(id[i], value)) return i;
+  }
+  return -1;
 }
 function copy(id) {
   return [...id];
 }
 function concat(id1, id2) {
-  return [...id1, ...id2];
+  for (const v of Array.from(id2)) id1.push(v);
+  return id1;
 }
 function join(id, separator = ",") {
   return id.join(separator);
@@ -134,64 +171,162 @@ function reverse(id) {
   id.reverse();
 }
 function slice(id, index_from, index_to) {
-  return id.slice(index_from, index_to);
-}
-function sort(id, order = "asc") {
-  id.sort((a, b) => {
-    if (order === "asc") {
-      return a - b;
-    } else {
-      return b - a;
+  const n = id.length;
+  const start = Number.isNaN(index_from) ? 0 : Math.trunc(index_from);
+  const stop = index_to === void 0 || Number.isNaN(index_to) ? n : Math.trunc(index_to);
+  if (start < 0 || start >= n) throw new Error(`array.slice: index ${start} is out of bounds, array size is ${n}`);
+  if (stop < 0 || stop > n) throw new Error(`array.slice: index ${stop} is out of bounds, array size is ${n}`);
+  if (start > stop) throw new Error(`array.slice: index_from ${start} is greater than index_to ${stop}`);
+  return sliceView(id, start, stop - start);
+}
+function indexKey(p) {
+  if (typeof p !== "string") return -1;
+  const i = Number(p);
+  return Number.isInteger(i) && i >= 0 && String(i) === p ? i : -1;
+}
+function sliceView(parent, start, size2) {
+  const resize = (target) => {
+    if (target > size2) parent.splice(start + size2, 0, ...Array(target - size2).fill(void 0));
+    else if (target < size2) parent.splice(start + target, size2 - target);
+    size2 = target;
+  };
+  return new Proxy([], {
+    get(target, p, receiver) {
+      const i = indexKey(p);
+      if (i >= 0) return i < size2 ? parent[start + i] : void 0;
+      if (p === "length") return size2;
+      return Reflect.get(target, p, receiver);
+    },
+    set(target, p, value, receiver) {
+      const i = indexKey(p);
+      if (i >= 0) {
+        if (i >= size2) resize(i + 1);
+        parent[start + i] = value;
+        return true;
+      }
+      if (p === "length") {
+        resize(Number(value));
+        return true;
+      }
+      return Reflect.set(target, p, value, receiver);
+    },
+    has(target, p) {
+      const i = indexKey(p);
+      return i >= 0 ? i < size2 : Reflect.has(target, p);
+    },
+    // Array methods delete the slots past the new end before they set the length, which does the removal.
+    deleteProperty(target, p) {
+      return indexKey(p) >= 0 ? true : Reflect.deleteProperty(target, p);
+    },
+    ownKeys(target) {
+      return [...Array.from({ length: size2 }, (_, i) => String(i)), ...Reflect.ownKeys(target)];
+    },
+    getOwnPropertyDescriptor(target, p) {
+      const i = indexKey(p);
+      if (i >= 0) {
+        return i < size2 ? { value: parent[start + i], writable: true, enumerable: true, configurable: true } : void 0;
+      }
+      if (p === "length") return { value: size2, writable: true, enumerable: false, configurable: false };
+      return Reflect.getOwnPropertyDescriptor(target, p);
     }
   });
 }
+function sortedPositions(id, order) {
+  const values = [];
+  const nas = [];
+  for (let i = 0; i < id.length; i++) (isNa(id[i]) ? nas : values).push(i);
+  values.sort((a, b) => {
+    const x = id[a];
+    const y = id[b];
+    return x < y ? -1 : x > y ? 1 : 0;
+  });
+  const naFirst = values.length > 0 && typeof id[values[0]] === "string";
+  const positions = naFirst ? [...nas, ...values] : [...values, ...nas];
+  if (order === "desc" || order === "descending") positions.reverse();
+  return positions;
+}
+function sort(id, order = "asc") {
+  const sorted = sortedPositions(id, order).map((p) => id[p]);
+  for (let i = 0; i < sorted.length; i++) id[i] = sorted[i];
+}
 function sum(id) {
-  return id.reduce((acc, val) => acc + val, 0);
+  let total = 0;
+  let count = 0;
+  for (const v of id) {
+    if (Number.isNaN(v)) continue;
+    count++;
+    total += v;
+    if (Math.abs(total) <= 1e-10) total = 0;
+  }
+  return count ? total : NaN;
 }
 function avg(id) {
   const values = id.filter((v) => !Number.isNaN(v));
   return values.length ? values.reduce((a, b) => a + b, 0) / values.length : NaN;
 }
+function nthValue(name, id, nth, compare) {
+  const rank = Number.isNaN(nth) ? 0 : Math.trunc(nth);
+  const values = id.filter((v) => !Number.isNaN(v));
+  if (!values.length) return NaN;
+  if (rank < 0 || rank >= id.length) {
+    throw new Error(`array.${name}: nth ${rank} is out of bounds, array size is ${id.length}`);
+  }
+  values.sort(compare);
+  return values[Math.min(rank, values.length - 1)];
+}
 function min(id, nth = 0) {
-  const values = id.filter((v) => !Number.isNaN(v)).sort((a, b) => a - b);
-  return values.length ? values[Math.min(nth, values.length - 1)] : NaN;
+  return nthValue("min", id, nth, (a, b) => a - b);
 }
 function max(id, nth = 0) {
-  const values = id.filter((v) => !Number.isNaN(v)).sort((a, b) => b - a);
-  return values.length ? values[Math.min(nth, values.length - 1)] : NaN;
+  return nthValue("max", id, nth, (a, b) => b - a);
 }
 function median(id) {
-  const sorted = [...id].sort((a, b) => a - b);
+  const sorted = id.filter((v) => !Number.isNaN(v)).sort((a, b) => a - b);
+  if (!sorted.length) return NaN;
   const mid = Math.floor(sorted.length / 2);
   return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
 }
 function mode(id) {
   const frequency = /* @__PURE__ */ new Map();
-  let maxFreq = 0;
-  let mode2 = id[0];
-  for (const val of id) {
-    const freq = (frequency.get(val) || 0) + 1;
-    frequency.set(val, freq);
-    if (freq > maxFreq) {
-      maxFreq = freq;
-      mode2 = val;
+  for (const v of id) {
+    if (!Number.isNaN(v)) frequency.set(v, (frequency.get(v) ?? 0) + 1);
+  }
+  let best = NaN;
+  let bestCount = 0;
+  for (const [v, count] of frequency) {
+    if (count > bestCount || count === bestCount && v < best) {
+      best = v;
+      bestCount = count;
     }
   }
-  return mode2;
+  return best;
 }
 function stdev(id, biased = true) {
   return Math.sqrt(variance(id, biased));
 }
+function moments(values) {
+  let p = 0;
+  let q = 0;
+  for (const v of values) p += v;
+  for (const v of values) q += v * v;
+  return [p, q];
+}
 function variance(id, biased = true) {
   const values = id.filter((v) => !Number.isNaN(v));
-  if (!values.length) return NaN;
-  const mean = values.reduce((a, b) => a + b, 0) / values.length;
-  const squares = values.reduce((a, b) => a + (b - mean) * (b - mean), 0);
-  return squares / (biased ? values.length : values.length - 1);
+  const n = values.length;
+  if (!n) return NaN;
+  if (n < 2) return biased ? 0 : NaN;
+  const [p, q] = moments(values);
+  const mean = p / n;
+  return biased ? Math.max(0, q / n - mean * mean) : Math.max(0, q / (n - 1) - p / (n - 1) * mean);
 }
 function fill(id, value, index_from = 0, index_to) {
-  const end = index_to ?? id.length;
-  for (let i = index_from; i < end; i++) {
+  const start = index_from === void 0 || index_from === null || Number.isNaN(index_from) ? 0 : index_from;
+  const end = index_to === void 0 || index_to === null || Number.isNaN(index_to) ? id.length : index_to;
+  for (const i of [start, end]) {
+    if (i < 0 || i > id.length) throw new Error(`array.fill: index ${i} is out of bounds, array size is ${id.length}`);
+  }
+  for (let i = start; i < end; i++) {
     id[i] = value;
   }
 }
@@ -199,9 +334,11 @@ function from(...values) {
   return [...values];
 }
 function first(id) {
+  if (id.length === 0) throw new Error("Cannot call array.first() if array is empty");
   return id[0];
 }
 function last(id) {
+  if (id.length === 0) throw new Error("Cannot call array.last() if array is empty");
   return id[id.length - 1];
 }
 function some(id) {
@@ -263,129 +400,132 @@ function binary_search(id, val) {
   return -1;
 }
 function binary_search_leftmost(id, val) {
-  let left = 0;
-  let right = id.length - 1;
-  let result = -1;
-  let found = false;
-  while (left <= right) {
-    const mid = Math.floor((left + right) / 2);
-    if (id[mid] < val) {
-      if (!found) {
-        result = mid;
-      }
-      left = mid + 1;
-    } else if (id[mid] === val) {
-      result = mid;
-      found = true;
-      right = mid - 1;
-    } else {
-      right = mid - 1;
-    }
+  if (id.length === 0) return -1;
+  const at = searchBound(id, val, false);
+  return at < id.length && compareSorted(id[at], val) === 0 ? at : Math.max(0, at - 1);
+}
+function compareSorted(a, b) {
+  const an = Number.isNaN(a);
+  const bn = Number.isNaN(b);
+  if (an || bn) return an === bn ? 0 : an ? 1 : -1;
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function searchBound(id, val, after) {
+  let lo = 0;
+  let hi = id.length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    const c = compareSorted(id[mid], val);
+    if (c < 0 || after && c === 0) lo = mid + 1;
+    else hi = mid;
   }
-  return result;
+  return lo;
 }
 function binary_search_rightmost(id, val) {
-  let left = 0;
-  let right = id.length - 1;
-  let result = -1;
-  let found = false;
-  while (left <= right) {
-    const mid = Math.floor((left + right) / 2);
-    if (id[mid] <= val) {
-      if (id[mid] === val) {
-        result = mid;
-        found = true;
-      }
-      left = mid + 1;
-    } else {
-      if (!found) {
-        result = mid;
-      }
-      right = mid - 1;
-    }
-  }
-  return result;
+  if (id.length === 0) return -1;
+  const at = searchBound(id, val, true);
+  return at > 0 && compareSorted(id[at - 1], val) === 0 ? at - 1 : at;
 }
 function covariance(id1, id2, biased = true) {
-  if (id1.length === 0 || id2.length === 0) {
-    return NaN;
-  }
   if (id1.length !== id2.length) {
     return NaN;
   }
-  const n = id1.length;
-  const mean1 = avg(id1);
-  const mean2 = avg(id2);
+  const xs = [];
+  const ys = [];
+  for (let i = 0; i < id1.length; i++) {
+    if (Number.isNaN(id1[i]) || Number.isNaN(id2[i])) continue;
+    xs.push(id1[i]);
+    ys.push(id2[i]);
+  }
+  const n = xs.length;
+  if (!n || !biased && n < 2) return NaN;
+  let mean1 = 0;
+  let mean2 = 0;
+  for (let i = 0; i < n; i++) {
+    mean1 += xs[i];
+    mean2 += ys[i];
+  }
+  mean1 /= n;
+  mean2 /= n;
   let sum2 = 0;
   for (let i = 0; i < n; i++) {
-    sum2 += (id1[i] - mean1) * (id2[i] - mean2);
+    sum2 += (xs[i] - mean1) * (ys[i] - mean2);
   }
-  const divisor = biased ? n : n - 1;
-  return sum2 / divisor;
+  return sum2 / (biased ? n : n - 1);
 }
 function percentile_linear_interpolation(id, percentage) {
-  if (id.length === 0) {
+  if (id.length === 0 || Number.isNaN(percentage)) {
     return NaN;
   }
+  checkPercentage("percentile_linear_interpolation", percentage);
   const s = sortedNaLast(id);
   const n = s.length;
-  const pos = percentage / 100 * n - 0.5;
-  if (pos <= 0) return s[0];
-  if (pos >= n - 1) return s[n - 1];
-  const lo = Math.floor(pos);
-  const f = pos - lo;
-  if (f === 0) return s[lo];
-  return Number.isNaN(s[n - 1]) ? NaN : s[lo] + f * (s[lo + 1] - s[lo]);
+  let pos = n * percentage / 100 + 0.5;
+  const nearest = Math.round(pos);
+  if (Math.abs(pos - nearest) < 1e-9) pos = nearest;
+  if (pos <= 1) return s[0];
+  if (pos >= n) return s[n - 1];
+  const lower = Math.floor(pos);
+  const frac = pos - lower;
+  if (frac === 0) return s[lower - 1];
+  if (Number.isNaN(s[n - 1])) return NaN;
+  return s[lower - 1] * (1 - frac) + s[lower] * frac;
 }
 function sortedNaLast(id) {
   const numbers = id.filter((v) => !Number.isNaN(v)).sort((a, b) => a - b);
   return [...numbers, ...Array(id.length - numbers.length).fill(NaN)];
 }
+function checkPercentage(name, percentage) {
+  if (!(percentage >= 0 && percentage <= 100)) {
+    throw new Error(`array.${name}: percentage ${percentage} must be between 0 and 100`);
+  }
+}
 function percentile_nearest_rank(id, percentage) {
   if (id.length === 0) {
     return NaN;
   }
+  const pct = Number.isNaN(percentage) ? 0 : percentage;
+  checkPercentage("percentile_nearest_rank", pct);
   const s = sortedNaLast(id);
-  const rank = Math.min(s.length, Math.max(1, Math.ceil(percentage / 100 * s.length)));
+  const rank = Math.min(s.length, Math.max(1, Math.ceil(pct * s.length / 100)));
   return s[rank - 1];
 }
 function percentrank(id, index) {
-  if (id.length === 0 || index < 0 || index >= id.length) {
+  const i = Number.isNaN(index) ? 0 : Math.trunc(index);
+  if (id.length === 0) {
+    return NaN;
+  }
+  if (i < 0 || i >= id.length) {
+    throw new Error(`array.percentrank: index ${i} is out of bounds, array size is ${id.length}`);
+  }
+  if (id.length === 1) {
     return NaN;
   }
-  const value = id[index];
-  if (isNaN(value)) {
+  const value = id[i];
+  if (Number.isNaN(value)) {
     return NaN;
   }
   let count = 0;
-  for (let i = 0; i < id.length; i++) {
-    if (!isNaN(id[i]) && id[i] <= value) {
-      count++;
-    }
+  for (const v of id) {
+    if (v <= value) count++;
   }
-  return count / id.length * 100;
+  return (count - 1) * 100 / (id.length - 1);
 }
 function sort_indices(id, order = "asc") {
-  const indices = Array.from({ length: id.length }, (_, i) => i);
-  indices.sort((a, b) => {
-    if (order === "asc") {
-      return id[a] - id[b];
-    } else {
-      return id[b] - id[a];
-    }
-  });
-  return indices;
+  return sortedPositions(id, order);
 }
 function standardize(id) {
-  if (id.length === 0) {
-    return [];
+  const values = id.filter((v) => !Number.isNaN(v));
+  if (!values.length) {
+    return id.map(() => NaN);
   }
-  const mean = avg(id);
-  const stdDev = stdev(id);
+  const [p, q] = moments(values);
+  const mean = p / values.length;
+  const stdDev = Math.sqrt(Math.max(0, q / values.length - mean * mean));
   if (stdDev === 0) {
-    return id.map(() => NaN);
+    return id.map((v) => Number.isNaN(v) ? NaN : 1);
   }
-  return id.map((value) => (value - mean) / stdDev);
+  return id.map((v) => Number.isNaN(v) ? NaN : (v - mean) / stdDev);
 }
 function newtype(size2 = 0, initial_value) {
   return new_array(size2, initial_value);