@orieljs/framework 0.1.0-alpha.6 → 0.1.0-alpha.7

package/dist/{chunk-POEP4B2M.js → chunk-7ZQZYDOC.js}

@@ -2,7 +2,7 @@ import {
   Application,
   ConfigRepository,
   Container
-} from "./chunk-I63ZFMX6.js";
+} from "./chunk-GVNLZZTN.js";
 
 // ../Container/dist/index.js
 import { AsyncLocalStorage } from "async_hooks";
@@ -226,9 +226,138 @@ function ascending(a, b) {
   if (a instanceof Date && b instanceof Date) return a.getTime() - b.getTime();
   return String(a).localeCompare(String(b));
 }
+var ItemNotFoundError = class extends Error {
+  name = "ItemNotFoundError";
+  constructor() {
+    super("Item not found.");
+  }
+};
+var MultipleItemsFoundError = class extends Error {
+  constructor(count) {
+    super(`${count} items were found.`);
+    this.count = count;
+  }
+  count;
+  name = "MultipleItemsFoundError";
+};
+var LazyCollection = class _LazyCollection {
+  constructor(source) {
+    this.source = source;
+  }
+  source;
+  static make(source) {
+    return new _LazyCollection(source);
+  }
+  async *[Symbol.asyncIterator]() {
+    yield* this.source();
+  }
+  map(callback) {
+    const self = this;
+    return new _LazyCollection(async function* () {
+      let i = 0;
+      for await (const item of self) yield await callback(item, i++);
+    });
+  }
+  filter(callback) {
+    const self = this;
+    return new _LazyCollection(async function* () {
+      let i = 0;
+      for await (const item of self) if (await callback(item, i++)) yield item;
+    });
+  }
+  take(count) {
+    const self = this;
+    return new _LazyCollection(async function* () {
+      if (count <= 0) return;
+      let taken = 0;
+      for await (const item of self) {
+        yield item;
+        if (++taken >= count) return;
+      }
+    });
+  }
+  chunk(size) {
+    const self = this;
+    return new _LazyCollection(async function* () {
+      if (size <= 0) return;
+      let buffer = [];
+      for await (const item of self) {
+        buffer.push(item);
+        if (buffer.length === size) {
+          yield new Collection(buffer);
+          buffer = [];
+        }
+      }
+      if (buffer.length) yield new Collection(buffer);
+    });
+  }
+  /** Return false from the callback to stop. */
+  async each(callback) {
+    let i = 0;
+    for await (const item of this) if (await callback(item, i++) === false) return;
+  }
+  async first(callback) {
+    for await (const item of this) if (!callback || await callback(item)) return item;
+    return void 0;
+  }
+  async count() {
+    let n = 0;
+    for await (const item of this) {
+      void item;
+      n++;
+    }
+    return n;
+  }
+  async collect() {
+    const items = [];
+    for await (const item of this) items.push(item);
+    return new Collection(items);
+  }
+};
 var read = (item, getter) => typeof getter === "function" ? getter(item) : item?.[getter];
 var isArrayable = (v) => typeof v === "object" && v !== null && typeof v.toArray === "function";
 var numbers = (items, getter) => items.map((item) => getter === void 0 ? item : read(item, getter)).filter((v) => typeof v === "number" && !Number.isNaN(v));
+var isNil = (value2) => value2 === null || value2 === void 0;
+var predicateFor = (value2) => typeof value2 === "function" ? value2 : (item) => item === value2;
+var roundTo = (value2, precision) => Number(`${Math.round(Number(`${value2}e${precision}`))}e-${precision}`);
+var typeNameOf = (value2) => {
+  if (value2 === null) return "null";
+  if (Array.isArray(value2)) return "array";
+  if (typeof value2 === "object") return value2.constructor?.name ?? "object";
+  return typeof value2;
+};
+var isIndex = (index, length) => Number.isInteger(index) && index >= 0 && index < length;
+function compareBy(a, b, key, direction) {
+  const left = read(a, key);
+  const right = read(b, key);
+  const leftNil = isNil(left);
+  const rightNil = isNil(right);
+  if (leftNil || rightNil) return leftNil === rightNil ? 0 : leftNil ? 1 : -1;
+  return (direction === "asc" ? 1 : -1) * ascending(left, right);
+}
+function flattenItems(items, depth) {
+  const result = [];
+  for (const value2 of items) {
+    const item = value2 instanceof Collection ? value2.all() : value2;
+    if (!Array.isArray(item)) result.push(item);
+    else if (depth <= 1) result.push(...item);
+    else result.push(...flattenItems(item, depth - 1));
+  }
+  return result;
+}
+function whereCondition(args) {
+  const [key, operatorOrValue, value2] = args;
+  if (args.length === 1) return (item) => Boolean(read(item, key));
+  if (args.length === 2) return (item) => compare(read(item, key), "=", operatorOrValue);
+  return (item) => compare(read(item, key), operatorOrValue, value2);
+}
+function uniqueWith(values, equal) {
+  const result = [];
+  for (const value2 of values) if (!result.some((seen) => equal(seen, value2))) result.push(value2);
+  return result;
+}
+var loose = (a, b) => a == b;
+var strict = (a, b) => a === b;
 var Collection = class _Collection {
   items;
   constructor(items = []) {
@@ -241,6 +370,34 @@ var Collection = class _Collection {
   static times(count, callback) {
     return new _Collection(Array.from({ length: Math.max(0, count) }, (_, i) => callback(i + 1)));
   }
+  /** The numbers from `from` to `to`, inclusive, counting up or down by `step` (PHP's range()). */
+  static range(from, to, step = 1) {
+    if (step === 0) throw new RangeError("range(): Argument #3 ($step) cannot be 0");
+    const size = Math.abs(step);
+    const numbers2 = [];
+    if (from <= to) for (let n = from; n <= to; n += size) numbers2.push(n);
+    else for (let n = from; n >= to; n -= size) numbers2.push(n);
+    return new _Collection(numbers2);
+  }
+  static wrap(value2) {
+    if (value2 instanceof _Collection) return new _Collection(value2.all());
+    if (Array.isArray(value2)) return new _Collection(value2);
+    return new _Collection(isNil(value2) ? [] : [value2]);
+  }
+  static unwrap(value2) {
+    return value2 instanceof _Collection ? value2.all() : value2;
+  }
+  static empty() {
+    return new _Collection();
+  }
+  /** The decoded JSON: an array's items, nothing for null, else the one value. */
+  static fromJson(json) {
+    return _Collection.wrap(JSON.parse(json));
+  }
+  /** A new collection of the receiver's class (a subclass keeps its class through filter(), sortBy(), …). */
+  newInstance(items = []) {
+    return new this.constructor(items);
+  }
   [Symbol.iterator]() {
     return this.items[Symbol.iterator]();
   }
@@ -265,6 +422,81 @@ var Collection = class _Collection {
   toJson() {
     return JSON.stringify(this);
   }
+  get(index, defaultValue) {
+    if (Number.isInteger(index) && index >= 0 && index < this.items.length) return this.items[index];
+    return typeof defaultValue === "function" ? defaultValue() : defaultValue;
+  }
+  /** Whether every given index exists. */
+  has(...indexes) {
+    return indexes.flat().every((index) => Number.isInteger(index) && index >= 0 && index < this.items.length);
+  }
+  /** Whether any of the given indexes exists. */
+  hasAny(...indexes) {
+    if (this.isEmpty()) return false;
+    return indexes.flat().some((index) => this.has(index));
+  }
+  search(value2, strict2 = false) {
+    const index = typeof value2 === "function" ? this.items.findIndex(value2) : this.items.findIndex((item) => strict2 ? item === value2 : item == value2);
+    return index === -1 ? false : index;
+  }
+  before(value2, strict2 = false) {
+    const index = this.search(value2, strict2);
+    return index === false || index === 0 ? void 0 : this.items[index - 1];
+  }
+  after(value2, strict2 = false) {
+    const index = this.search(value2, strict2);
+    return index === false ? void 0 : this.items[index + 1];
+  }
+  value(key, defaultValue) {
+    const item = this.items.find((candidate) => Boolean(read(candidate, key)));
+    if (item !== void 0) return read(item, key);
+    return typeof defaultValue === "function" ? defaultValue() : defaultValue;
+  }
+  every(...args) {
+    if (args.length === 1 && typeof args[0] === "function") return this.items.every(args[0]);
+    const condition = whereCondition(args);
+    return this.items.every((item) => condition(item));
+  }
+  contains(keyOrValue, operatorOrValue, value2) {
+    if (arguments.length === 3) return this.items.some(whereCondition([keyOrValue, operatorOrValue, value2]));
+    if (arguments.length === 2) return this.items.some((item) => read(item, keyOrValue) === operatorOrValue);
+    if (typeof keyOrValue === "function") return this.items.some(keyOrValue);
+    return this.items.includes(keyOrValue);
+  }
+  some(...args) {
+    return Reflect.apply(this.contains, this, args);
+  }
+  containsStrict(...args) {
+    return Reflect.apply(this.contains, this, args);
+  }
+  doesntContain(...args) {
+    return !Reflect.apply(this.contains, this, args);
+  }
+  doesntContainStrict(...args) {
+    return !Reflect.apply(this.contains, this, args);
+  }
+  /** Whether there is exactly one item (that passes the callback). */
+  containsOneItem(callback) {
+    return (callback ? this.items.filter(callback) : this.items).length === 1;
+  }
+  sole(...args) {
+    const items = this.matching(args);
+    if (items.length === 0) throw new ItemNotFoundError();
+    if (items.length > 1) throw new MultipleItemsFoundError(items.length);
+    return items[0];
+  }
+  firstOrFail(...args) {
+    const items = this.matching(args);
+    if (items.length === 0) throw new ItemNotFoundError();
+    return items[0];
+  }
+  /** The items a callback or a where condition (sole(), firstOrFail()) selects; every item without arguments. */
+  matching(args) {
+    if (args.length === 0 || args[0] === void 0) return this.items;
+    if (args.length === 1) return this.items.filter(args[0]);
+    return this.items.filter(whereCondition(args));
+  }
+  // ---------------------------------------------------------------- transforming
   map(callback) {
     return new _Collection(this.items.map(callback));
   }
@@ -277,10 +509,10 @@ var Collection = class _Collection {
     );
   }
   filter(callback) {
-    return new _Collection(this.items.filter(callback ?? ((item) => Boolean(item))));
+    return this.newInstance(this.items.filter(callback ?? ((item) => Boolean(item))));
   }
   reject(callback) {
-    return new _Collection(this.items.filter((item, i) => !callback(item, i)));
+    return this.newInstance(this.items.filter((item, i) => !callback(item, i)));
   }
   /** Return false from the callback to stop. */
   each(callback) {
@@ -300,22 +532,53 @@ var Collection = class _Collection {
     const index = this.items.findLastIndex(callback);
     return index === -1 ? defaultValue : this.items[index];
   }
-  where(key, operatorOrValue, value2) {
-    const [op, expected] = arguments.length === 2 ? ["=", operatorOrValue] : [operatorOrValue, value2];
-    return this.filter((item) => compare(read(item, key), op, expected));
+  where(...args) {
+    return this.filter(whereCondition(args));
+  }
+  /** where() with strict comparison (===). */
+  whereStrict(key, value2) {
+    return this.filter((item) => read(item, key) === value2);
   }
-  firstWhere(key, operatorOrValue, value2) {
-    const [op, expected] = arguments.length === 2 ? ["=", operatorOrValue] : [operatorOrValue, value2];
-    return this.items.find((item) => compare(read(item, key), op, expected));
+  firstWhere(...args) {
+    return this.items.find(whereCondition(args));
   }
   whereIn(key, values) {
     const set = new Set(values);
     return this.filter((item) => set.has(read(item, key)));
   }
+  /** whereIn() under Laravel's strict name (whereIn() already compares strictly). */
+  whereInStrict(key, values) {
+    return this.whereIn(key, values);
+  }
   whereNotIn(key, values) {
     const set = new Set(values);
     return this.filter((item) => !set.has(read(item, key)));
   }
+  whereNotInStrict(key, values) {
+    return this.whereNotIn(key, values);
+  }
+  /** Items whose key (or the item itself) is null or undefined (a missing key counts as null). */
+  whereNull(key) {
+    return this.filter((item) => isNil(key === void 0 ? item : read(item, key)));
+  }
+  whereNotNull(key) {
+    return this.filter((item) => !isNil(key === void 0 ? item : read(item, key)));
+  }
+  /** Items whose key is within the first and last values, inclusive. */
+  whereBetween(key, values) {
+    return this.where(key, ">=", values[0]).where(key, "<=", values.at(-1));
+  }
+  whereNotBetween(key, values) {
+    return this.filter((item) => {
+      const value2 = read(item, key);
+      return value2 < values[0] || value2 > values.at(-1);
+    });
+  }
+  /** Items that are instances of the class (or of any of the classes). */
+  whereInstanceOf(type2) {
+    const types = [type2].flat();
+    return this.filter((item) => types.some((cls) => item instanceof cls));
+  }
   pluck(key) {
     return this.map((item) => read(item, key));
   }
@@ -323,21 +586,74 @@ var Collection = class _Collection {
     return Object.fromEntries(this.items.map((item) => [String(read(item, key)), item]));
   }
   groupBy(key) {
-    const groups = {};
-    for (const item of this.items) (groups[String(read(item, key))] ??= new _Collection()).push(item);
-    return groups;
+    const groups = /* @__PURE__ */ new Map();
+    for (const item of this.items) {
+      const name = String(read(item, key));
+      groups.set(name, (groups.get(name) ?? this.newInstance()).push(item));
+    }
+    return Object.fromEntries(groups);
   }
   mapWithKeys(callback) {
     return Object.fromEntries(this.items.map(callback));
   }
-  sortBy(key, direction = "asc") {
-    const sign = direction === "asc" ? 1 : -1;
-    return new _Collection(
-      this.items.map((item, index) => ({ item, index, value: read(item, key) })).sort((a, b) => {
-        const aNil = a.value === null || a.value === void 0;
-        const bNil = b.value === null || b.value === void 0;
-        if (aNil || bNil) return aNil === bNil ? a.index - b.index : aNil ? 1 : -1;
-        return sign * ascending(a.value, b.value) || a.index - b.index;
+  duplicates(key) {
+    return this.repeated(key, loose);
+  }
+  duplicatesStrict(key) {
+    return this.repeated(key, strict);
+  }
+  /** Laravel's duplicates(): each value after the first of its kind. */
+  repeated(key, equal) {
+    const values = this.items.map((item) => key === void 0 ? item : read(item, key));
+    const unique = uniqueWith(values, equal);
+    const duplicates = [];
+    for (const value2 of values) {
+      if (unique.length && equal(value2, unique[0])) unique.shift();
+      else duplicates.push(value2);
+    }
+    return new _Collection(duplicates);
+  }
+  /** The items that aren't in the given items (strict comparison). */
+  diff(items) {
+    const other = new Set(items);
+    return this.filter((item) => !other.has(item));
+  }
+  /** diff() with a comparator that returns 0 for equal items. */
+  diffUsing(items, callback) {
+    const other = [...items];
+    return this.filter((item) => !other.some((candidate) => callback(item, candidate) === 0));
+  }
+  /** The items that are also in the given items (strict comparison). */
+  intersect(items) {
+    const other = new Set(items);
+    return this.filter((item) => other.has(item));
+  }
+  intersectUsing(items, callback) {
+    const other = [...items];
+    return this.filter((item) => other.some((candidate) => callback(item, candidate) === 0));
+  }
+  // ---------------------------------------------------------------- ordering and slicing
+  /** Sorted with the default ascending order (numbers, dates, then strings), or by a comparator. */
+  sort(callback) {
+    return this.newInstance([...this.items].sort(callback ?? ((a, b) => ascending(a, b))));
+  }
+  sortDesc() {
+    return this.newInstance([...this.items].sort((a, b) => ascending(b, a)));
+  }
+  sortBy(keyOrSteps, direction = "asc") {
+    const steps = Array.isArray(keyOrSteps) ? keyOrSteps : [[keyOrSteps, direction]];
+    const comparators = steps.map((step) => {
+      if (typeof step === "function" && step.length >= 2) return step;
+      const [key, order = "asc"] = Array.isArray(step) ? step : [step];
+      return (a, b) => compareBy(a, b, key, order);
+    });
+    return this.newInstance(
+      this.items.map((item, index) => ({ item, index })).sort((a, b) => {
+        for (const comparator of comparators) {
+          const result = comparator(a.item, b.item);
+          if (result) return result;
+        }
+        return a.index - b.index;
       }).map((x) => x.item)
     );
   }
@@ -359,6 +675,81 @@ var Collection = class _Collection {
     const values = numbers(this.items, key);
     return values.length ? Math.max(...values) : void 0;
   }
+  /** avg() under Laravel's other name. */
+  average(key) {
+    return this.avg(key);
+  }
+  /** The middle number (the mean of the two middle ones for an even count), ignoring null and non-numbers. */
+  median(key) {
+    const values = numbers(this.items, key).sort((a, b) => a - b);
+    if (!values.length) return void 0;
+    const middle = Math.floor(values.length / 2);
+    return values.length % 2 ? values[middle] : (values[middle - 1] + values[middle]) / 2;
+  }
+  mode(key) {
+    if (this.isEmpty()) return void 0;
+    const counts = /* @__PURE__ */ new Map();
+    for (const item of this.items) {
+      const value2 = key === void 0 ? item : read(item, key);
+      counts.set(value2, (counts.get(value2) ?? 0) + 1);
+    }
+    const highest = Math.max(...counts.values());
+    return [...counts].filter(([, count]) => count === highest).map(([value2]) => value2);
+  }
+  /** The share of items that pass the callback, as a percentage rounded to `precision` places; undefined when empty. */
+  percentage(callback, precision = 2) {
+    if (this.isEmpty()) return void 0;
+    return roundTo(this.items.filter(callback).length / this.items.length * 100, precision);
+  }
+  /** How many items have each value, key value or callback result: [1, 2, 2].countBy() → { 1: 1, 2: 2 }. */
+  countBy(key) {
+    const counts = /* @__PURE__ */ new Map();
+    for (const item of this.items) {
+      const value2 = String(key === void 0 ? item : read(item, key));
+      counts.set(value2, (counts.get(value2) ?? 0) + 1);
+    }
+    return Object.fromEntries(counts);
+  }
+  /** Groups the callback's [key, value] pairs: values under the same key are collected in arrays. */
+  mapToDictionary(callback) {
+    const dictionary = /* @__PURE__ */ new Map();
+    this.items.forEach((item, index) => {
+      const [key, value2] = callback(item, index);
+      const name = String(key);
+      const values = dictionary.get(name) ?? [];
+      values.push(value2);
+      dictionary.set(name, values);
+    });
+    return Object.fromEntries(dictionary);
+  }
+  /** mapToDictionary() with each group as a collection. */
+  mapToGroups(callback) {
+    return Object.fromEntries(Object.entries(this.mapToDictionary(callback)).map(([key, values]) => [key, new _Collection(values)]));
+  }
+  /** A new instance of the class for each item: new cls(item, index). */
+  mapInto(cls) {
+    return this.map((item, index) => new cls(item, index));
+  }
+  /** Maps nested arrays (or collections) with their items as the arguments, then the index. */
+  mapSpread(callback) {
+    return this.map((chunk, index) => callback(...[...chunk instanceof _Collection ? chunk.all() : chunk, index]));
+  }
+  /** each() with the nested items as the arguments, then the index. Return false to stop. */
+  eachSpread(callback) {
+    return this.each((chunk, index) => callback(...[...chunk instanceof _Collection ? chunk.all() : chunk, index]));
+  }
+  /** reduce() with several carried values: the reducer gets them, then the item and index, and returns them as an array. */
+  reduceSpread(callback, ...initial) {
+    let result = initial;
+    this.items.forEach((item, index) => {
+      result = callback(...result, item, index);
+      if (!Array.isArray(result)) {
+        throw new TypeError(`${this.constructor.name}::reduceSpread expects reducer to return an array, but got a '${typeNameOf(result)}' instead.`);
+      }
+    });
+    return result;
+  }
+  /** The first item of each value (strict comparison), or of each key or callback value. */
   unique(key) {
     const seen = /* @__PURE__ */ new Set();
     return this.filter((item) => {
@@ -368,29 +759,32 @@ var Collection = class _Collection {
       return true;
     });
   }
+  /** unique() under Laravel's strict name (unique() already compares strictly). */
+  uniqueStrict(key) {
+    return this.unique(key);
+  }
   chunk(size) {
     if (size <= 0) return new _Collection();
     const chunks = [];
-    for (let i = 0; i < this.items.length; i += size) chunks.push(new _Collection(this.items.slice(i, i + size)));
+    for (let i = 0; i < this.items.length; i += size) chunks.push(this.newInstance(this.items.slice(i, i + size)));
     return new _Collection(chunks);
   }
   /** Negative count takes from the end. */
   take(count) {
-    return new _Collection(count < 0 ? this.items.slice(count) : this.items.slice(0, count));
+    return this.newInstance(count < 0 ? this.items.slice(count) : this.items.slice(0, count));
   }
   skip(count) {
-    return new _Collection(this.items.slice(count));
+    return this.newInstance(this.items.slice(count));
   }
+  /** PHP's array_slice(): a negative offset counts from the end; a negative length leaves that many off the end. */
   slice(offset, length) {
-    return new _Collection(this.items.slice(offset, length === void 0 ? void 0 : offset + length));
+    const size = this.items.length;
+    const start = offset < 0 ? Math.max(0, size + offset) : Math.min(offset, size);
+    const end = length === void 0 ? size : length < 0 ? size + length : start + length;
+    return this.newInstance(this.items.slice(start, Math.max(start, end)));
   }
   values() {
-    return new _Collection(this.items);
-  }
-  contains(keyOrValue, value2) {
-    if (arguments.length === 2) return this.items.some((item) => read(item, keyOrValue) === value2);
-    if (typeof keyOrValue === "function") return this.items.some(keyOrValue);
-    return this.items.includes(keyOrValue);
+    return this.newInstance(this.items);
   }
   /** Mutates, like Laravel. */
   push(...values) {
@@ -398,103 +792,347 @@ var Collection = class _Collection {
     return this;
   }
   concat(values) {
-    return new _Collection([...this.items, ...values]);
+    return this.newInstance([...this.items, ...values]);
   }
   partition(callback) {
     return [this.filter(callback), this.reject(callback)];
   }
-  implode(keyOrGlue, glue) {
-    if (glue === void 0) return this.items.join(keyOrGlue);
-    return this.items.map((item) => read(item, keyOrGlue)).join(glue);
+  reverse() {
+    return this.newInstance([...this.items].reverse());
   }
-  when(condition, callback) {
-    return condition ? callback(this) : this;
+  shuffle() {
+    const items = [...this.items];
+    for (let i = items.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [items[i], items[j]] = [items[j], items[i]];
+    }
+    return this.newInstance(items);
   }
-  pipe(callback) {
-    return callback(this);
+  random(count) {
+    const requested = typeof count === "function" ? count(this) : count;
+    const wanted = requested ?? 1;
+    if (wanted > this.items.length) {
+      throw new RangeError(`You requested ${wanted} items, but there are only ${this.items.length} items available.`);
+    }
+    if (requested === void 0) return this.items[Math.floor(Math.random() * this.items.length)];
+    const indexes = [...this.items.keys()];
+    for (let i = indexes.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [indexes[i], indexes[j]] = [indexes[j], indexes[i]];
+    }
+    return this.newInstance(indexes.slice(0, Math.max(0, wanted)).sort((a, b) => a - b).map((index) => this.items[index]));
+  }
+  /** Every step-th item, starting at offset. */
+  nth(step, offset = 0) {
+    return this.newInstance(this.items.slice(offset).filter((_, position) => position % step === 0));
+  }
+  /** Pads to `size` items with the value; a negative size pads at the start (PHP's array_pad()). */
+  pad(size, value2) {
+    const missing = Math.abs(size) - this.items.length;
+    if (missing <= 0) return new _Collection(this.items);
+    const padding = Array.from({ length: missing }, () => value2);
+    return new _Collection(size < 0 ? [...padding, ...this.items] : [...this.items, ...padding]);
+  }
+  /** The items of one page: forPage(2, 15). */
+  forPage(page, perPage) {
+    return this.slice(Math.max(0, (page - 1) * perPage), perPage);
+  }
+  /** `count` groups of nearly equal size, the first ones larger. */
+  split(count) {
+    const groups = [];
+    if (this.isEmpty()) return new _Collection(groups);
+    const size = Math.floor(this.items.length / count);
+    const remain = this.items.length % count;
+    let start = 0;
+    for (let i = 0; i < count; i++) {
+      const length = size + (i < remain ? 1 : 0);
+      if (!length) continue;
+      groups.push(this.newInstance(this.items.slice(start, start + length)));
+      start += length;
+    }
+    return new _Collection(groups);
   }
-  tap(callback) {
-    callback(this);
+  /** `count` groups, every group full except the last. */
+  splitIn(count) {
+    return this.chunk(Math.ceil(this.items.length / count));
+  }
+  /** Overlapping windows of `size` items, `step` apart: [1, 2, 3].sliding(2) → [[1, 2], [2, 3]]. */
+  sliding(size = 2, step = 1) {
+    const windows = Math.floor((this.items.length - size) / step) + 1;
+    return _Collection.times(windows, (number) => this.slice((number - 1) * step, size));
+  }
+  /** Chunks that grow while the callback (value, index, the current chunk) returns true. */
+  chunkWhile(callback) {
+    const chunks = [];
+    let chunk = this.newInstance();
+    this.items.forEach((item, index) => {
+      if (index > 0 && !callback(item, index, chunk)) {
+        chunks.push(chunk);
+        chunk = this.newInstance();
+      }
+      chunk.push(item);
+    });
+    if (chunk.isNotEmpty()) chunks.push(chunk);
+    return new _Collection(chunks);
+  }
+  takeUntil(value2) {
+    const stop = this.items.findIndex(predicateFor(value2));
+    return this.newInstance(stop === -1 ? this.items : this.items.slice(0, stop));
+  }
+  takeWhile(value2) {
+    const keep = predicateFor(value2);
+    const stop = this.items.findIndex((item, index) => !keep(item, index));
+    return this.newInstance(stop === -1 ? this.items : this.items.slice(0, stop));
+  }
+  skipUntil(value2) {
+    const start = this.items.findIndex(predicateFor(value2));
+    return this.newInstance(start === -1 ? [] : this.items.slice(start));
+  }
+  skipWhile(value2) {
+    const skip = predicateFor(value2);
+    const start = this.items.findIndex((item, index) => !skip(item, index));
+    return this.newInstance(start === -1 ? [] : this.items.slice(start));
+  }
+  /** The items at the given indexes, in collection order. */
+  only(...indexes) {
+    const wanted = new Set(indexes.flat());
+    return this.newInstance(this.items.filter((_, index) => wanted.has(index)));
+  }
+  /** The items except those at the given indexes. */
+  except(...indexes) {
+    const unwanted = new Set(indexes.flat());
+    return this.newInstance(this.items.filter((_, index) => !unwanted.has(index)));
+  }
+  /** The indexes: 0, 1, 2, … */
+  keys() {
+    return new _Collection(this.items.keys());
+  }
+  pop(count) {
+    if (count === void 0) return this.items.pop();
+    const removed = [];
+    while (removed.length < count && this.items.length) removed.push(this.items.pop());
+    return this.newInstance(removed);
+  }
+  shift(count) {
+    if (count !== void 0 && count < 0) throw new RangeError("Number of shifted items may not be less than zero.");
+    if (count === void 0) return this.items.shift();
+    return this.newInstance(this.items.splice(0, count));
+  }
+  /** Adds an item at the start (mutates). */
+  prepend(value2) {
+    this.items.unshift(value2);
     return this;
   }
-};
-function collect(items = []) {
-  return new Collection(items);
-}
-var LazyCollection = class _LazyCollection {
-  constructor(source) {
-    this.source = source;
+  /** Adds items at the start, in the given order (mutates). */
+  unshift(...values) {
+    this.items.unshift(...values);
+    return this;
   }
-  source;
-  static make(source) {
-    return new _LazyCollection(source);
+  /** Adds one item at the end (mutates). */
+  add(item) {
+    this.items.push(item);
+    return this;
   }
-  async *[Symbol.asyncIterator]() {
-    yield* this.source();
+  /** Sets the item at an index (mutates); an index at or past the end appends. */
+  put(index, value2) {
+    if (!Number.isInteger(index) || index < 0) throw new RangeError(`Invalid collection index [${index}].`);
+    if (index < this.items.length) this.items[index] = value2;
+    else this.items.push(value2);
+    return this;
   }
-  map(callback) {
-    const self = this;
-    return new _LazyCollection(async function* () {
-      let i = 0;
-      for await (const item of self) yield await callback(item, i++);
-    });
+  pull(index, defaultValue) {
+    if (isIndex(index, this.items.length)) return this.items.splice(index, 1)[0];
+    return typeof defaultValue === "function" ? defaultValue() : defaultValue;
   }
-  filter(callback) {
-    const self = this;
-    return new _LazyCollection(async function* () {
-      let i = 0;
-      for await (const item of self) if (await callback(item, i++)) yield item;
-    });
+  /** Removes the items at the given indexes (mutates); the later items move up. */
+  forget(...indexes) {
+    const remove = [...new Set(indexes.flat())].filter((index) => isIndex(index, this.items.length)).sort((a, b) => b - a);
+    for (const index of remove) this.items.splice(index, 1);
+    return this;
   }
-  take(count) {
-    const self = this;
-    return new _LazyCollection(async function* () {
-      if (count <= 0) return;
-      let taken = 0;
-      for await (const item of self) {
-        yield item;
-        if (++taken >= count) return;
-      }
+  /**
+   * Removes `length` items from `offset` (mutates), inserting the replacement there, and returns the removed items
+   * (PHP's array_splice(): a negative offset counts from the end; a negative length leaves that many at the end).
+   */
+  splice(offset, length, replacement = []) {
+    const size = this.items.length;
+    const start = offset < 0 ? Math.max(0, size + offset) : Math.min(offset, size);
+    const count = length === void 0 ? size - start : length < 0 ? Math.max(0, size + length - start) : length;
+    return this.newInstance(this.items.splice(start, count, ...replacement));
+  }
+  /** Replaces every item with the callback's result (mutates) and returns this collection, typed with the new items. */
+  transform(callback) {
+    const items = this.items;
+    items.forEach((item, index) => {
+      items[index] = callback(item, index);
     });
+    return this;
   }
-  chunk(size) {
-    const self = this;
-    return new _LazyCollection(async function* () {
-      if (size <= 0) return;
-      let buffer = [];
-      for await (const item of self) {
-        buffer.push(item);
-        if (buffer.length === size) {
-          yield new Collection(buffer);
-          buffer = [];
-        }
+  /**
+   * A copy with items replaced by index: an array from index 0, or { index: value }; past the end appends, and a
+   * negative or fractional index throws a RangeError, as put() does.
+   */
+  replace(items) {
+    const copy = this.newInstance(this.items);
+    const entries = Symbol.iterator in items ? [...items].map((value2, index) => [index, value2]) : Object.entries(items).map(([index, value2]) => [Number(index), value2]);
+    for (const [index, value2] of [...entries].sort((a, b) => a[0] - b[0])) copy.put(index, value2);
+    return copy;
+  }
+  // ---------------------------------------------------------------- building collections
+  /** One level of nested arrays and collections, merged (other items are dropped). */
+  collapse() {
+    const result = [];
+    for (const item of this.items) {
+      if (item instanceof _Collection) result.push(...item.all());
+      else if (Array.isArray(item)) result.push(...item);
+    }
+    return new _Collection(result);
+  }
+  flatten(depth = Infinity) {
+    return new _Collection(flattenItems(this.items, depth));
+  }
+  /** Every combination of the items with the lists' items: [1, 2] × ['a'] → [[1, 'a'], [2, 'a']]. */
+  crossJoin(...lists) {
+    let rows = this.items.map((item) => [item]);
+    for (const list of lists) {
+      const values = [...list];
+      rows = rows.flatMap((row) => values.map((value2) => [...row, value2]));
+    }
+    return new _Collection(rows);
+  }
+  /** Pairs items by index with the lists' items, as collections; the shorter lists give undefined. */
+  zip(...lists) {
+    const arrays = lists.map((list) => [...list]);
+    const length = Math.max(this.items.length, ...arrays.map((array) => array.length));
+    return _Collection.times(length, (number) => new _Collection([this.items[number - 1], ...arrays.map((array) => array[number - 1])]));
+  }
+  /** The items as keys for the values: ['name', 'age'].combine(['George', 29]) → { name: 'George', age: 29 }. */
+  combine(values) {
+    const list = [...values];
+    if (list.length !== this.items.length) {
+      throw new RangeError("combine(): the keys and the values must have the same number of items.");
+    }
+    return Object.fromEntries(this.items.map((key, index) => [String(key), list[index]]));
+  }
+  /** Each item as a key for its index: ['a', 'b'] → { a: 0, b: 1 }. */
+  flip() {
+    return Object.fromEntries(this.items.map((item, index) => [String(item), index]));
+  }
+  /** The items followed by the given ones (a list merges by appending). */
+  merge(items) {
+    return this.concat(items);
+  }
+  /** The items repeated `multiplier` times. */
+  multiply(multiplier) {
+    return this.newInstance(Array.from({ length: Math.max(0, multiplier) }, () => this.items).flat());
+  }
+  /**
+   * Each item reduced to the given keys it has: select(['name', 'role']). An item has a key when `key in item` or
+   * reading it gives a value, so a model's attributes, which its proxy serves on read, are kept.
+   */
+  select(...keys) {
+    const names = keys.flat();
+    return this.map((item) => {
+      const picked = {};
+      if (typeof item !== "object" || item === null) return picked;
+      for (const key of names) {
+        const value2 = item[key];
+        if (key in item || value2 !== void 0) picked[key] = value2;
       }
-      if (buffer.length) yield new Collection(buffer);
+      return picked;
     });
   }
-  /** Return false from the callback to stop. */
-  async each(callback) {
-    let i = 0;
-    for await (const item of this) if (await callback(item, i++) === false) return;
+  /** A LazyCollection over a copy of the items: later changes to this collection don't reach it. */
+  lazy() {
+    const items = this.all();
+    return LazyCollection.make(() => items);
   }
-  async first(callback) {
-    for await (const item of this) if (!callback || await callback(item)) return item;
-    return void 0;
+  /** A base collection with the same items. */
+  collect() {
+    return new _Collection(this.items);
   }
-  async count() {
-    let n = 0;
-    for await (const item of this) {
-      void item;
-      n++;
-    }
-    return n;
+  implode(keyOrGlue, glue) {
+    if (typeof keyOrGlue === "function") return this.items.map(keyOrGlue).join(glue);
+    if (glue === void 0) return this.items.join(keyOrGlue);
+    return this.items.map((item) => read(item, keyOrGlue)).join(glue);
   }
-  async collect() {
-    const items = [];
-    for await (const item of this) items.push(item);
-    return new Collection(items);
+  /** implode() with a different glue before the last item: join(', ', ' and ') → 'a, b and c'. */
+  join(glue, finalGlue = "") {
+    if (finalGlue === "" || this.items.length < 2) return this.implode(glue);
+    return `${this.items.slice(0, -1).join(glue)}${finalGlue}${String(this.items.at(-1))}`;
+  }
+  /**
+   * Runs the callback (collection, value) when the value is truthy, else the default; a function value is called with
+   * the collection first. Returns what the callback returns, or the collection when it returns nothing.
+   */
+  when(value2, callback, otherwise) {
+    const resolved = typeof value2 === "function" ? value2(this) : value2;
+    const result = resolved ? callback(this, resolved) : otherwise?.(this, resolved);
+    return result ?? this;
+  }
+  /** when() with the condition reversed. */
+  unless(value2, callback, otherwise) {
+    const resolved = typeof value2 === "function" ? value2(this) : value2;
+    const result = !resolved ? callback(this, resolved) : otherwise?.(this, resolved);
+    return result ?? this;
+  }
+  whenEmpty(callback, otherwise) {
+    return this.when(this.isEmpty(), (collection) => callback(collection), otherwise && ((collection) => otherwise(collection)));
+  }
+  whenNotEmpty(callback, otherwise) {
+    return this.when(this.isNotEmpty(), (collection) => callback(collection), otherwise && ((collection) => otherwise(collection)));
+  }
+  /** whenNotEmpty() under Laravel's other name. */
+  unlessEmpty(callback, otherwise) {
+    return this.whenNotEmpty(callback, otherwise);
+  }
+  /** whenEmpty() under Laravel's other name. */
+  unlessNotEmpty(callback, otherwise) {
+    return this.whenEmpty(callback, otherwise);
+  }
+  pipe(callback) {
+    return callback(this);
+  }
+  /** new cls(collection). */
+  pipeInto(cls) {
+    return new cls(this);
+  }
+  pipeThrough(callbacks) {
+    return callbacks.reduce((carry, callback) => callback(carry), this);
+  }
+  tap(callback) {
+    callback(this);
+    return this;
+  }
+  /**
+   * Throws a TypeError unless every item is an instance of one of the classes or of one of the type names (typeof's,
+   * plus 'null' and 'array'), with Laravel's message. Returns the collection, typed with the checked items.
+   */
+  ensure(type2) {
+    const allowed = [type2].flat();
+    this.items.forEach((item, index) => {
+      const name = typeNameOf(item);
+      const ok = allowed.some((entry) => typeof entry === "string" ? entry === name || entry === "object" && typeof item === "object" && item !== null && !Array.isArray(item) : item instanceof entry);
+      if (!ok) {
+        const names = allowed.map((entry) => typeof entry === "string" ? entry : entry.name).join(", ");
+        throw new TypeError(`Collection should only include [${names}] items, but '${name}' found at position ${index}.`);
+      }
+    });
+    return this;
+  }
+  /** Logs the items (and any extra values) with console.log and returns the collection. */
+  dump(...values) {
+    console.log(this.all(), ...values);
+    return this;
+  }
+  /** JSON with four-space indentation (PHP's JSON_PRETTY_PRINT). */
+  toPrettyJson() {
+    return JSON.stringify(this, null, 4);
   }
 };
+function collect(items = []) {
+  return new Collection(items);
+}
 
 // ../Support/dist/index.js
 import { randomBytes, randomUUID } from "crypto";
@@ -2572,9 +3210,11 @@ export {
   currentContainer,
   inject,
   Container2 as Container,
+  ItemNotFoundError,
+  MultipleItemsFoundError,
+  LazyCollection,
   Collection,
   collect,
-  LazyCollection,
   Stringable,
   Str,
   Arr,
@@ -2610,4 +3250,4 @@ export {
  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-//# sourceMappingURL=chunk-POEP4B2M.js.map
+//# sourceMappingURL=chunk-7ZQZYDOC.js.map