effect 2.0.0-next.38 → 2.0.0-next.39

package/{dist/THub-573c2fb3.esm.js → internal/stm/tHub.esm.js}

@@ -1,18 +1,19 @@
-import { N as acquireRelease } from './Effect-ee05a487.esm.js';
-import { d as dual, p as pipe, i as identity } from './Function-12511160.esm.js';
-import { e as empty, a as add, k as forEach$1, j as remove } from './HashSet-ae2856c1.esm.js';
-import { n as flatMap, r as map, C as effect, t as retry, H as withSTMRuntime, q as interruptAs, u as succeed } from './core-f6cae6d7.esm.js';
-import { s as shutdown, B as BackPressure, D as Dropping, S as Sliding, T as TEnqueueTypeId, t as tEnqueueVariance, O as OP_SLIDING_STRATEGY, a as OP_DROPPING_STRATEGY, b as OP_BACKPRESSURE_STRATEGY, c as TDequeueTypeId, d as tDequeueVariance } from './tQueue-74395d76.esm.js';
-import { b as all, aq as tap, ax as unit, E as forEach } from './stm-6937f6f2.esm.js';
-import { m as make, g as get, s as set, u as unsafeGet, T as TRefImpl, a as unsafeSet } from './tRef-fc8ff438.esm.js';
-import { s as some, n as none } from './Option-df40d2b9.esm.js';
-import { Y as every } from './ReadonlyArray-0a71b226.esm.js';
+import { acquireRelease } from '../../Effect/dist/effect-Effect.esm.js';
+import { dual, pipe, identity } from '../../Function/dist/effect-Function.esm.js';
+import { empty, add, forEach as forEach$1, remove } from '../../HashSet/dist/effect-HashSet.esm.js';
+import { flatMap, map, effect, retry, withSTMRuntime, interruptAs, succeed } from './core.esm.js';
+import { OP_SLIDING_STRATEGY, OP_DROPPING_STRATEGY, OP_BACKPRESSURE_STRATEGY } from './opCodes/strategy.esm.js';
+import { all, tap, unit, forEach } from './stm.esm.js';
+import { shutdown, BackPressure, Dropping, Sliding, TEnqueueTypeId, tEnqueueVariance, TDequeueTypeId, tDequeueVariance } from './tQueue.esm.js';
+import { make, get, set, unsafeGet, TRefImpl, unsafeSet } from './tRef.esm.js';
+import { some, none } from '../../Option/dist/effect-Option.esm.js';
+import { every } from '../../ReadonlyArray/dist/effect-ReadonlyArray.esm.js';
 
 /** @internal */
 const THubSymbolKey = "effect/THub";
 
 /** @internal */
-const THubTypeId$1 = /*#__PURE__*/Symbol.for(THubSymbolKey);
+const THubTypeId = /*#__PURE__*/Symbol.for(THubSymbolKey);
 
 /** @internal */
 
@@ -25,7 +26,7 @@ const makeNode = (head, subscribers, tail) => ({
 
 /** @internal */
 class THubImpl {
-  [THubTypeId$1] = THubTypeId$1;
+  [THubTypeId] = THubTypeId;
   [TEnqueueTypeId] = tEnqueueVariance;
   constructor(hubSize, publisherHead, publisherTail, requestedCapacity, strategy, subscriberCount, subscribers) {
     this.hubSize = hubSize;
@@ -130,7 +131,7 @@ class THubImpl {
 
 /** @internal */
 class THubSubscriptionImpl {
-  [THubTypeId$1] = THubTypeId$1;
+  [THubTypeId] = THubTypeId;
   [TDequeueTypeId] = tDequeueVariance;
   constructor(hubSize, publisherHead, requestedCapacity, subscriberHead, subscriberCount, subscribers) {
     this.hubSize = hubSize;
@@ -336,218 +337,45 @@ const makeHub = (requestedCapacity, strategy) => pipe(all([make(void 0), make(0)
 const makeSubscription = (hubSize, publisherHead, publisherTail, requestedCapacity, subscriberCount, subscribers) => pipe(get(publisherTail), flatMap(currentPublisherTail => pipe(all([make(currentPublisherTail), get(subscriberCount), get(subscribers)]), tap(([_, currentSubscriberCount]) => pipe(subscriberCount, set(currentSubscriberCount + 1))), tap(([subscriberHead, _, currentSubscribers]) => pipe(subscribers, set(pipe(currentSubscribers, add(subscriberHead))))), map(([subscriberHead]) => new THubSubscriptionImpl(hubSize, publisherHead, requestedCapacity, subscriberHead, subscriberCount, subscribers)))));
 
 /** @internal */
-const awaitShutdown$1 = self => self.awaitShutdown;
+const awaitShutdown = self => self.awaitShutdown;
 
 /** @internal */
-const bounded$1 = requestedCapacity => makeHub(requestedCapacity, BackPressure);
+const bounded = requestedCapacity => makeHub(requestedCapacity, BackPressure);
 
 /** @internal */
-const capacity$1 = self => self.capacity();
+const capacity = self => self.capacity();
 
 /** @internal */
-const dropping$1 = requestedCapacity => makeHub(requestedCapacity, Dropping);
+const dropping = requestedCapacity => makeHub(requestedCapacity, Dropping);
 
 /** @internal */
-const isEmpty$1 = self => self.isEmpty;
+const isEmpty = self => self.isEmpty;
 
 /** @internal */
-const isFull$1 = self => self.isFull;
+const isFull = self => self.isFull;
 
 /** @internal */
-const isShutdown$1 = self => self.isShutdown;
+const isShutdown = self => self.isShutdown;
 
 /** @internal */
-const publish$1 = /*#__PURE__*/dual(2, (self, value) => self.offer(value));
+const publish = /*#__PURE__*/dual(2, (self, value) => self.offer(value));
 
 /** @internal */
-const publishAll$1 = /*#__PURE__*/dual(2, (self, iterable) => self.offerAll(iterable));
+const publishAll = /*#__PURE__*/dual(2, (self, iterable) => self.offerAll(iterable));
 
 /** @internal */
-const size$1 = self => self.size;
+const size = self => self.size;
 
 /** @internal */
-const sliding$1 = requestedCapacity => makeHub(requestedCapacity, Sliding);
+const sliding = requestedCapacity => makeHub(requestedCapacity, Sliding);
 
 /** @internal */
-const subscribe$1 = self => makeSubscription(self.hubSize, self.publisherHead, self.publisherTail, self.requestedCapacity, self.subscriberCount, self.subscribers);
+const subscribe = self => makeSubscription(self.hubSize, self.publisherHead, self.publisherTail, self.requestedCapacity, self.subscriberCount, self.subscribers);
 
 /** @internal */
-const subscribeScoped$1 = self => acquireRelease(subscribe$1(self), dequeue => shutdown(dequeue));
+const subscribeScoped = self => acquireRelease(subscribe(self), dequeue => shutdown(dequeue));
 
 /** @internal */
-const unbounded$1 = () => makeHub(Number.MAX_SAFE_INTEGER, Dropping);
+const unbounded = () => makeHub(Number.MAX_SAFE_INTEGER, Dropping);
 
-/**
- * @since 2.0.0
- */
-/**
- * @since 2.0.0
- * @category symbols
- */
-const THubTypeId = THubTypeId$1;
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-
-/**
- * @since 2.0.0
- * @category models
- */
-
-/**
- * @internal
- * @since 2.0.0
- */
-
-/**
- * Waits until the hub is shutdown. The `STM` returned by this method will
- * not resume until the queue has been shutdown. If the hub is already
- * shutdown, the `STM` will resume right away.
- *
- * @since 2.0.0
- * @category mutations
- */
-const awaitShutdown = awaitShutdown$1;
-
-/**
- * Creates a bounded hub with the back pressure strategy. The hub will retain
- * messages until they have been taken by all subscribers, applying back
- * pressure to publishers if the hub is at capacity.
- *
- * @since 2.0.0
- * @category constructors
- */
-const bounded = bounded$1;
-
-/**
- * Returns the number of elements the hub can hold.
- *
- * @since 2.0.0
- * @category getters
- */
-const capacity = capacity$1;
-
-/**
- * Creates a bounded hub with the dropping strategy. The hub will drop new
- * messages if the hub is at capacity.
- *
- * @since 2.0.0
- * @category constructors
- */
-const dropping = dropping$1;
-
-/**
- * Returns `true` if the `THub` contains zero elements, `false` otherwise.
- *
- * @since 2.0.0
- * @category getters
- */
-const isEmpty = isEmpty$1;
-
-/**
- * Returns `true` if the `THub` contains at least one element, `false`
- * otherwise.
- *
- * @since 2.0.0
- * @category getters
- */
-const isFull = isFull$1;
-
-/**
- * Returns `true` if `shutdown` has been called, otherwise returns `false`.
- *
- * @since 2.0.0
- * @category getters
- */
-const isShutdown = isShutdown$1;
-
-/**
- * Publishes a message to the hub, returning whether the message was published
- * to the hub.
- *
- * @since 2.0.0
- * @category mutations
- */
-const publish = publish$1;
-
-/**
- * Publishes all of the specified messages to the hub, returning whether they
- * were published to the hub.
- *
- * @since 2.0.0
- * @category mutations
- */
-const publishAll = publishAll$1;
-
-/**
- * Retrieves the size of the hub, which is equal to the number of elements
- * in the hub. This may be negative if fibers are suspended waiting for
- * elements to be added to the hub.
- *
- * @since 2.0.0
- * @category getters
- */
-const size = size$1;
-
-/**
- * Creates a bounded hub with the sliding strategy. The hub will add new
- * messages and drop old messages if the hub is at capacity.
- *
- * For best performance use capacities that are powers of two.
- *
- * @since 2.0.0
- * @category constructors
- */
-const sliding = sliding$1;
-
-/**
- * Subscribes to receive messages from the hub. The resulting subscription can
- * be evaluated multiple times to take a message from the hub each time. The
- * caller is responsible for unsubscribing from the hub by shutting down the
- * queue.
- *
- * @since 2.0.0
- * @category mutations
- */
-const subscribe = subscribe$1;
-
-/**
- * Subscribes to receive messages from the hub. The resulting subscription can
- * be evaluated multiple times within the scope to take a message from the hub
- * each time.
- *
- * @since 2.0.0
- * @category mutations
- */
-const subscribeScoped = subscribeScoped$1;
-
-/**
- * Creates an unbounded hub.
- *
- * @since 2.0.0
- * @category constructors
- */
-const unbounded = unbounded$1;
-
-var THub = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  THubTypeId: THubTypeId,
-  awaitShutdown: awaitShutdown,
-  bounded: bounded,
-  capacity: capacity,
-  dropping: dropping,
-  isEmpty: isEmpty,
-  isFull: isFull,
-  isShutdown: isShutdown,
-  publish: publish,
-  publishAll: publishAll,
-  size: size,
-  sliding: sliding,
-  subscribe: subscribe,
-  subscribeScoped: subscribeScoped,
-  unbounded: unbounded
-});
-
-export { THub as T, THubTypeId as a, awaitShutdown as b, bounded as c, capacity as d, dropping as e, isFull as f, isShutdown as g, publishAll as h, isEmpty as i, sliding as j, subscribe as k, subscribeScoped as l, publish as p, size as s, unbounded as u };
+export { THubTypeId, awaitShutdown, bounded, capacity, dropping, isEmpty, isFull, isShutdown, makeNode, publish, publishAll, size, sliding, subscribe, subscribeScoped, unbounded };

package/{dist/tMap-907e37f4.esm.js → internal/stm/tMap.esm.js}

@@ -1,15 +1,15 @@
-import { e as empty$1, c as append, f as fromIterable$1, p as prepend, H as findFirst, y as reduce$2, P as partition, h as isNonEmpty, Q as some$1, s as map$3 } from './Chunk-4c1f4599.esm.js';
-import { e as equals } from './Equal-2a99fde3.esm.js';
-import { d as dual, p as pipe } from './Function-12511160.esm.js';
-import { h as hash$1 } from './Hash-7910f34f.esm.js';
-import { e as empty$2, s as set$1 } from './HashMap-6c230bde.esm.js';
-import { u as succeed, k as fail, o as matchSTM, r as map, C as effect, n as flatMap } from './core-f6cae6d7.esm.js';
-import { am as succeedNone, an as succeedSome, f as asUnit, ap as suspend, c as as, a7 as reduce$1, ax as unit, l as collect, E as forEach$1 } from './stm-6937f6f2.esm.js';
-import { f as fromIterable$2, T as TArrayImpl } from './tArray-79024770.esm.js';
-import { g as get$1, m as make$1, u as unsafeGet, a as unsafeSet, T as TRefImpl } from './tRef-fc8ff438.esm.js';
-import { i as isSome, n as none, a as isNone, b as match, g as getOrElse$1, s as some, m as map$2 } from './Option-df40d2b9.esm.js';
-import { m as map$1, W as isNonEmptyArray } from './ReadonlyArray-0a71b226.esm.js';
-import { s as succeed$1 } from './STM-1ef98d11.esm.js';
+import { empty as empty$1, append, fromIterable as fromIterable$1, prepend, findFirst, reduce as reduce$2, partition, isNonEmpty, some as some$1, map as map$3 } from '../../Chunk/dist/effect-Chunk.esm.js';
+import { equals } from '../../Equal/dist/effect-Equal.esm.js';
+import { dual, pipe } from '../../Function/dist/effect-Function.esm.js';
+import { hash as hash$1 } from '../../Hash/dist/effect-Hash.esm.js';
+import { empty as empty$2, set as set$1 } from '../../HashMap/dist/effect-HashMap.esm.js';
+import { succeed, fail, matchSTM, map, effect, flatMap } from './core.esm.js';
+import { succeedNone, succeedSome, asUnit, suspend, as, reduce as reduce$1, unit, collect, forEach as forEach$1 } from './stm.esm.js';
+import { fromIterable as fromIterable$2, TArrayImpl } from './tArray.esm.js';
+import { get as get$1, make as make$1, unsafeGet, unsafeSet, TRefImpl } from './tRef.esm.js';
+import { isSome, none, isNone, match, getOrElse as getOrElse$1, some, map as map$2 } from '../../Option/dist/effect-Option.esm.js';
+import { map as map$1, isNonEmptyArray } from '../../ReadonlyArray/dist/effect-ReadonlyArray.esm.js';
+import { succeed as succeed$1 } from '../../STM/dist/effect-STM.esm.js';
 
 /** @internal */
 const TMapSymbolKey = "effect/TMap";
@@ -489,4 +489,4 @@ const updateWith = /*#__PURE__*/dual(3, (self, key, f) => flatMap(get(self, key)
 /** @internal */
 const values = self => map(toArray(self), map$1(entry => entry[1]));
 
-export { size as A, takeFirst as B, takeFirstSTM as C, takeSome as D, takeSomeSTM as E, toArray as F, toHashMap as G, toReadonlyArray as H, toReadonlyMap as I, transform as J, transformSTM as K, transformValues as L, transformValuesSTM as M, updateWith as N, values as O, TMapTypeId as T, findSTM as a, findAll as b, findAllSTM as c, forEach as d, empty as e, find as f, fromIterable as g, get as h, getOrElse as i, has as j, isEmpty as k, keys as l, make as m, merge as n, reduceSTM as o, reduceWithIndex as p, reduceWithIndexSTM as q, reduce as r, remove as s, removeAll as t, removeIf as u, removeIfDiscard as v, retainIf as w, retainIfDiscard as x, set as y, setIfAbsent as z };
+export { TMapTypeId, empty, find, findAll, findAllSTM, findSTM, forEach, fromIterable, get, getOrElse, has, isEmpty, keys, make, merge, reduce, reduceSTM, reduceWithIndex, reduceWithIndexSTM, remove, removeAll, removeIf, removeIfDiscard, retainIf, retainIfDiscard, set, setIfAbsent, size, takeFirst, takeFirstSTM, takeSome, takeSomeSTM, toArray, toHashMap, toReadonlyArray, toReadonlyMap, transform, transformSTM, transformValues, transformValuesSTM, updateWith, values };

package/internal/stm/tPriorityQueue.esm.js

@@ -0,0 +1,156 @@
+import { pipe, dual } from '../../Function/dist/effect-Function.esm.js';
+import { map, withSTMRuntime, retry, succeed, effect } from './core.esm.js';
+import { make as make$1, get as get$1, update, unsafeGet, modify, unsafeSet } from './tRef.esm.js';
+import { match, map as map$1, none, some } from '../../Option/dist/effect-Option.esm.js';
+import { of, prepend, filter, splitAt } from '../../ReadonlyArray/dist/effect-ReadonlyArray.esm.js';
+import { empty as empty$1, set, get, isEmpty as isEmpty$1, isNonEmpty as isNonEmpty$1, headOption, reduce, getOrder, remove } from '../../SortedMap/dist/effect-SortedMap.esm.js';
+
+/** @internal */
+const TPriorityQueueSymbolKey = "effect/TPriorityQueue";
+
+/** @internal */
+const TPriorityQueueTypeId = /*#__PURE__*/Symbol.for(TPriorityQueueSymbolKey);
+
+/** @internal */
+const tPriorityQueueVariance = {
+  _A: _ => _
+};
+
+/** @internal */
+class TPriorityQueueImpl {
+  [TPriorityQueueTypeId] = tPriorityQueueVariance;
+  constructor(ref) {
+    this.ref = ref;
+  }
+}
+
+/** @internal */
+const empty = order => pipe(make$1(empty$1(order)), map(ref => new TPriorityQueueImpl(ref)));
+
+/** @internal */
+const fromIterable = order => iterable => pipe(make$1(Array.from(iterable).reduce((map, value) => pipe(map, set(value, pipe(map, get(value), match({
+  onNone: () => of(value),
+  onSome: prepend(value)
+})))), empty$1(order))), map(ref => new TPriorityQueueImpl(ref)));
+
+/** @internal */
+const isEmpty = self => map(get$1(self.ref), isEmpty$1);
+
+/** @internal */
+const isNonEmpty = self => map(get$1(self.ref), isNonEmpty$1);
+
+/** @internal */
+const make = order => (...elements) => fromIterable(order)(elements);
+
+/** @internal */
+const offer = /*#__PURE__*/dual(2, (self, value) => update(self.ref, map => set(map, value, match(get(map, value), {
+  onNone: () => of(value),
+  onSome: prepend(value)
+}))));
+
+/** @internal */
+const offerAll = /*#__PURE__*/dual(2, (self, values) => update(self.ref, map => Array.from(values).reduce((map, value) => set(map, value, match(get(map, value), {
+  onNone: () => of(value),
+  onSome: prepend(value)
+})), map)));
+
+/** @internal */
+const peek = self => withSTMRuntime(runtime => {
+  const map = unsafeGet(self.ref, runtime.journal);
+  return match(headOption(map), {
+    onNone: () => retry,
+    onSome: elements => succeed(elements[0])
+  });
+});
+
+/** @internal */
+const peekOption = self => modify(self.ref, map => [map$1(headOption(map), elements => elements[0]), map]);
+
+/** @internal */
+const removeIf = /*#__PURE__*/dual(2, (self, predicate) => retainIf(self, a => !predicate(a)));
+
+/** @internal */
+const retainIf = /*#__PURE__*/dual(2, (self, predicate) => update(self.ref, map => reduce(map, empty$1(getOrder(map)), (map, value, key) => {
+  const filtered = filter(value, predicate);
+  return filtered.length > 0 ? set(map, key, filtered) : remove(map, key);
+})));
+
+/** @internal */
+const size = self => modify(self.ref, map => [reduce(map, 0, (n, as) => n + as.length), map]);
+
+/** @internal */
+const take = self => withSTMRuntime(runtime => {
+  const map = unsafeGet(self.ref, runtime.journal);
+  return match(headOption(map), {
+    onNone: () => retry,
+    onSome: values => {
+      const head = values[1][0];
+      const tail = values[1].slice(1);
+      unsafeSet(self.ref, tail.length > 0 ? set(map, head, tail) : remove(map, head), runtime.journal);
+      return succeed(head);
+    }
+  });
+});
+
+/** @internal */
+const takeAll = self => modify(self.ref, map => {
+  const builder = [];
+  for (const entry of map) {
+    builder.push(...entry[1]);
+  }
+  return [builder, empty$1(getOrder(map))];
+});
+
+/** @internal */
+const takeOption = self => effect(journal => {
+  const map = pipe(self.ref, unsafeGet(journal));
+  return match(headOption(map), {
+    onNone: () => none(),
+    onSome: ([key, value]) => {
+      const tail = value.slice(1);
+      unsafeSet(self.ref, tail.length > 0 ? set(map, key, tail) : remove(map, key), journal);
+      return some(value[0]);
+    }
+  });
+});
+
+/** @internal */
+const takeUpTo = /*#__PURE__*/dual(2, (self, n) => modify(self.ref, map => {
+  const builder = [];
+  const iterator = map[Symbol.iterator]();
+  let updated = map;
+  let index = 0;
+  let next;
+  while ((next = iterator.next()) && !next.done && index < n) {
+    const [key, value] = next.value;
+    const [left, right] = pipe(value, splitAt(n - index));
+    builder.push(...left);
+    if (right.length > 0) {
+      updated = set(updated, key, right);
+    } else {
+      updated = remove(updated, key);
+    }
+    index = index + left.length;
+  }
+  return [builder, updated];
+}));
+
+/** @internal */
+const toChunk = self => modify(self.ref, map => {
+  const builder = [];
+  for (const entry of map) {
+    builder.push(...entry[1]);
+  }
+  return [builder, map];
+});
+
+/** @internal */
+const toReadonlyArray = self => modify(self.ref, map => {
+  const builder = [];
+  for (const entry of map) {
+    builder.push(...entry[1]);
+  }
+  return [builder, map];
+});
+
+export { TPriorityQueueImpl, TPriorityQueueTypeId, empty, fromIterable, isEmpty, isNonEmpty, make, offer, offerAll, peek, peekOption, removeIf, retainIf, size, take, takeAll, takeOption, takeUpTo, toChunk, toReadonlyArray };

package/{dist/tQueue-74395d76.esm.js → internal/stm/tQueue.esm.js}

@@ -1,26 +1,12 @@
-import { B as splitAt, l as unsafeFromArray, b as appendAll, c as append, e as empty } from './Chunk-4c1f4599.esm.js';
-import { d as dual, p as pipe } from './Function-12511160.esm.js';
-import { r as map, n as flatMap, u as succeed, H as withSTMRuntime, C as effect, t as retry, q as interruptAs$1 } from './core-f6cae6d7.esm.js';
-import { ap as suspend, ax as unit } from './stm-6937f6f2.esm.js';
-import { m as make, u as unsafeGet, a as unsafeSet } from './tRef-fc8ff438.esm.js';
-import { e as fromNullable } from './Option-df40d2b9.esm.js';
-import { I as head } from './ReadonlyArray-0a71b226.esm.js';
-import { i as interruptAs } from './STM-1ef98d11.esm.js';
-
-/** @internal */
-const OP_BACKPRESSURE_STRATEGY = "BackPressure";
-
-/** @internal */
-
-/** @internal */
-const OP_DROPPING_STRATEGY = "Dropping";
-
-/** @internal */
-
-/** @internal */
-const OP_SLIDING_STRATEGY = "Sliding";
-
-/** @internal */
+import { splitAt, unsafeFromArray, appendAll, append, empty } from '../../Chunk/dist/effect-Chunk.esm.js';
+import { dual, pipe } from '../../Function/dist/effect-Function.esm.js';
+import { map, flatMap, succeed, withSTMRuntime, effect, retry, interruptAs as interruptAs$1 } from './core.esm.js';
+import { OP_SLIDING_STRATEGY, OP_DROPPING_STRATEGY, OP_BACKPRESSURE_STRATEGY } from './opCodes/strategy.esm.js';
+import { suspend, unit } from './stm.esm.js';
+import { make, unsafeGet, unsafeSet } from './tRef.esm.js';
+import { fromNullable } from '../../Option/dist/effect-Option.esm.js';
+import { head } from '../../ReadonlyArray/dist/effect-ReadonlyArray.esm.js';
+import { interruptAs } from '../../STM/dist/effect-STM.esm.js';
 
 const TEnqueueSymbolKey = "effect/TQueue/TEnqueue";
 
@@ -328,4 +314,4 @@ const takeUpTo = /*#__PURE__*/dual(2, (self, max) => self.takeUpTo(max));
 const unbounded = () => makeQueue(Number.MAX_SAFE_INTEGER, Dropping);
 const makeQueue = (requestedCapacity, strategy) => map(make([]), ref => new TQueueImpl(ref, requestedCapacity, strategy));
 
-export { takeBetween as A, BackPressure as B, takeN as C, Dropping as D, takeUpTo as E, unbounded as F, OP_SLIDING_STRATEGY as O, Sliding as S, TEnqueueTypeId as T, OP_DROPPING_STRATEGY as a, OP_BACKPRESSURE_STRATEGY as b, TDequeueTypeId as c, tDequeueVariance as d, isTDequeue as e, isTEnqueue as f, awaitShutdown as g, bounded as h, isTQueue as i, capacity as j, dropping as k, isEmpty as l, isFull as m, isShutdown as n, offer as o, offerAll as p, peek as q, peekOption as r, shutdown as s, tEnqueueVariance as t, poll as u, seek as v, size as w, sliding as x, take as y, takeAll as z };
+export { BackPressure, Dropping, Sliding, TDequeueTypeId, TEnqueueTypeId, awaitShutdown, bounded, capacity, dropping, isEmpty, isFull, isShutdown, isTDequeue, isTEnqueue, isTQueue, offer, offerAll, peek, peekOption, poll, seek, shutdown, size, sliding, tDequeueVariance, tEnqueueVariance, take, takeAll, takeBetween, takeN, takeUpTo, unbounded };

package/internal/stm/tRandom.esm.js

@@ -0,0 +1,89 @@
+import { Tag as Tag$1 } from '../../Context/dist/effect-Context.esm.js';
+import { pipe } from '../../Function/dist/effect-Function.esm.js';
+import { commit, map, flatMap, succeed, zipRight } from './core.esm.js';
+import { forEach } from './stm.esm.js';
+import { toArray, fromIterable, updateSTM, get, update } from './tArray.esm.js';
+import { make, modify } from './tRef.esm.js';
+import { effect } from '../../Layer/dist/effect-Layer.esm.js';
+import { PCGRandom } from '../../Utils/dist/effect-Utils.esm.js';
+
+const TRandomSymbolKey = "effect/TRandom";
+
+/** @internal */
+const TRandomTypeId = /*#__PURE__*/Symbol.for(TRandomSymbolKey);
+const randomInteger = state => {
+  const prng = new PCGRandom();
+  prng.setState(state);
+  return [prng.integer(0), prng.getState()];
+};
+const randomIntegerBetween = (low, high) => {
+  return state => {
+    const prng = new PCGRandom();
+    prng.setState(state);
+    return [prng.integer(high - low) + low, prng.getState()];
+  };
+};
+const randomNumber = state => {
+  const prng = new PCGRandom();
+  prng.setState(state);
+  return [prng.number(), prng.getState()];
+};
+const withState = (state, f) => {
+  return pipe(state, modify(f));
+};
+const shuffleWith = (iterable, nextIntBounded) => {
+  const swap = (buffer, index1, index2) => pipe(buffer, get(index1), flatMap(tmp => pipe(buffer, updateSTM(index1, () => pipe(buffer, get(index2))), zipRight(pipe(buffer, update(index2, () => tmp))))));
+  return pipe(fromIterable(iterable), flatMap(buffer => {
+    const array = [];
+    for (let i = array.length; i >= 2; i = i - 1) {
+      array.push(i);
+    }
+    return pipe(array, forEach(n => pipe(nextIntBounded(n), flatMap(k => swap(buffer, n - 1, k))), {
+      discard: true
+    }), zipRight(toArray(buffer)));
+  }));
+};
+
+/** @internal */
+const Tag = /*#__PURE__*/Tag$1();
+class TRandomImpl {
+  [TRandomTypeId] = TRandomTypeId;
+  constructor(state) {
+    this.state = state;
+    this.next = withState(this.state, randomNumber);
+    this.nextBoolean = flatMap(this.next, n => succeed(n > 0.5));
+    this.nextInt = withState(this.state, randomInteger);
+  }
+  nextRange(min, max) {
+    return flatMap(this.next, n => succeed((max - min) * n + min));
+  }
+  nextIntBetween(low, high) {
+    return withState(this.state, randomIntegerBetween(low, high));
+  }
+  shuffle(elements) {
+    return shuffleWith(elements, n => this.nextIntBetween(0, n));
+  }
+}
+
+/** @internal */
+const live = /*#__PURE__*/effect(Tag, /*#__PURE__*/pipe( /*#__PURE__*/make( /*#__PURE__*/new PCGRandom(Math.random() * 4294967296 >>> 0).getState()), /*#__PURE__*/map(seed => new TRandomImpl(seed)), commit));
+
+/** @internal */
+const next = /*#__PURE__*/flatMap(Tag, random => random.next);
+
+/** @internal */
+const nextBoolean = /*#__PURE__*/flatMap(Tag, random => random.nextBoolean);
+
+/** @internal */
+const nextInt = /*#__PURE__*/flatMap(Tag, random => random.nextInt);
+
+/** @internal */
+const nextIntBetween = (low, high) => flatMap(Tag, random => random.nextIntBetween(low, high));
+
+/** @internal */
+const nextRange = (min, max) => flatMap(Tag, random => random.nextRange(min, max));
+
+/** @internal */
+const shuffle = elements => flatMap(Tag, random => random.shuffle(elements));
+
+export { TRandomTypeId, Tag, live, next, nextBoolean, nextInt, nextIntBetween, nextRange, shuffle };