@lmvz-ds/components 0.12.4 → 0.12.5-alpha.1

package/dist/cjs/header-integration.lmvz-button.lmvz-header.lmvz-icon.lmvz-input.lmvz-menuitem-BTL_B6qg.js

@@ -0,0 +1,3665 @@
+'use strict';
+
+var index = require('./index-DpBPf1cE.js');
+var assets = require('./assets-Cswkqk_c.js');
+var icons = require('./icons-jn_Uak9B.js');
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const make$3 = assets.make;
+/**
+ * @since 2.0.0
+ * @category getters
+ */
+const get = assets.get;
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const modify = assets.modify;
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const update = assets.update;
+
+/**
+ * Creates a `Fail` cause from an expected error.
+ *
+ * **Details**
+ *
+ * This function constructs a `Cause` carrying an error of type `E`. It's used
+ * when you want to represent a known or anticipated failure in your effectful
+ * computations.
+ *
+ * @see {@link isFailure} Check if a `Cause` contains a failure
+ *
+ * @since 2.0.0
+ * @category Constructors
+ */
+const fail$1 = assets.fail;
+/**
+ * Creates a `Die` cause from an unexpected error.
+ *
+ * **Details**
+ *
+ * This function wraps an unhandled or unknown defect (like a runtime crash)
+ * into a `Cause`. It's useful for capturing unforeseen issues in a structured
+ * way.
+ *
+ * @see {@link isDie} Check if a `Cause` contains a defect
+ *
+ * @since 2.0.0
+ * @category Constructors
+ */
+const die = assets.die;
+/**
+ * Creates an `Interrupt` cause from a `FiberId`.
+ *
+ * **Details**
+ *
+ * This function represents a fiber that has been interrupted. It stores the
+ * identifier of the interrupted fiber, enabling precise tracking of concurrent
+ * cancellations.
+ *
+ * @see {@link isInterrupted} Check if a `Cause` contains an interruption
+ *
+ * @since 2.0.0
+ * @category Constructors
+ */
+const interrupt$1 = assets.interrupt;
+/**
+ * Checks if a `Cause` is a `Die` type.
+ *
+ * @see {@link die} Create a new `Die` cause
+ *
+ * @since 2.0.0
+ * @category Guards
+ */
+const isDieType = assets.isDieType;
+/**
+ * Checks if a `Cause` contains an interruption.
+ *
+ * **Details**
+ *
+ * This function returns `true` if the `Cause` includes any fiber interruptions.
+ *
+ * @since 2.0.0
+ * @category Getters
+ */
+const isInterrupted = assets.isInterrupted;
+/**
+ * Checks if a `Cause` contains only interruptions.
+ *
+ * **Details**
+ *
+ * This function returns `true` if the `Cause` has been interrupted but does not
+ * contain any other failures, such as `Fail` or `Die`. It's helpful for
+ * verifying purely "cancellation" scenarios.
+ *
+ * @since 2.0.0
+ * @category Getters
+ */
+const isInterruptedOnly = assets.isInterruptedOnly;
+/**
+ * Collects all `FiberId`s responsible for interrupting a fiber.
+ *
+ * **Details**
+ *
+ * This function returns a set of IDs indicating which fibers caused
+ * interruptions within this `Cause`. It's useful for debugging concurrency
+ * issues or tracing cancellations.
+ *
+ * @since 2.0.0
+ * @category Getters
+ */
+const interruptors = assets.interruptors;
+/**
+ * Splits a `Cause` into either its first `Fail` error or the rest of the cause
+ * (which might only contain `Die` or `Interrupt`).
+ *
+ * **Details**
+ *
+ * This function either returns the checked error (`E`) or the remaining
+ * `Cause<never>` with defects/interruptions. It helps you decide if there's a
+ * recoverable path or if only unhandled issues remain.
+ *
+ * @since 2.0.0
+ * @category Getters
+ */
+const failureOrCause = assets.failureOrCause;
+/**
+ * Strips out failures with an error of `None` from a `Cause<Option<E>>`.
+ *
+ * **Details**
+ *
+ * This function turns a `Cause<Option<E>>` into an `Option<Cause<E>>`. If the
+ * cause only contains failures of `None`, it becomes `None`; otherwise, it
+ * returns a `Cause` of the remaining errors. It's helpful when working with
+ * optional errors and filtering out certain error paths.
+ *
+ * @since 2.0.0
+ * @category Getters
+ */
+const flipCauseOption = assets.flipCauseOption;
+/**
+ * Transforms the errors in a `Cause` using a user-provided function.
+ *
+ * **Details**
+ *
+ * This function applies `f` to each `Fail` error while leaving defects (`Die`)
+ * and interruptions untouched. It's useful for changing or simplifying error
+ * types in your effectful workflows.
+ *
+ * @see {@link as} Replace errors with a single constant
+ *
+ * @since 2.0.0
+ * @category Mapping
+ */
+const map$2 = assets.map;
+
+const _await = assets._await;
+/**
+ * Inherits values from all `FiberRef` instances into current fiber. This
+ * will resume immediately.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const inheritAll = assets.inheritAll;
+/**
+ * Interrupts the fiber from whichever fiber is calling this method. If the
+ * fiber has already exited, the returned effect will resume immediately.
+ * Otherwise, the effect will resume when the fiber exits.
+ *
+ * @since 2.0.0
+ * @category interruption
+ */
+const interrupt = assets.interruptFiber;
+/**
+ * Interrupts the fiber as if interrupted from the specified fiber. If the
+ * fiber has already exited, the returned effect will resume immediately.
+ * Otherwise, the effect will resume when the fiber exits.
+ *
+ * @since 2.0.0
+ * @category interruption
+ */
+const interruptAs = assets.interruptAsFiber;
+/**
+ * Joins the fiber, which suspends the joining fiber until the result of the
+ * fiber has been determined. Attempting to join a fiber that has erred will
+ * result in a catchable error. Joining an interrupted fiber will result in an
+ * "inner interruption" of this fiber, unlike interruption triggered by
+ * another fiber, "inner interruption" can be caught and recovered.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const join = assets.join;
+
+/** @internal */
+const EnqueueSymbolKey = "effect/QueueEnqueue";
+/** @internal */
+const EnqueueTypeId = /*#__PURE__*/Symbol.for(EnqueueSymbolKey);
+/** @internal */
+const DequeueSymbolKey = "effect/QueueDequeue";
+/** @internal */
+const DequeueTypeId = /*#__PURE__*/Symbol.for(DequeueSymbolKey);
+/** @internal */
+const QueueStrategySymbolKey = "effect/QueueStrategy";
+/** @internal */
+const QueueStrategyTypeId = /*#__PURE__*/Symbol.for(QueueStrategySymbolKey);
+/** @internal */
+const BackingQueueSymbolKey = "effect/BackingQueue";
+/** @internal */
+const BackingQueueTypeId = /*#__PURE__*/Symbol.for(BackingQueueSymbolKey);
+const queueStrategyVariance = {
+  /* c8 ignore next */
+  _A: _ => _
+};
+const backingQueueVariance = {
+  /* c8 ignore next */
+  _A: _ => _
+};
+/** @internal */
+const enqueueVariance = {
+  /* c8 ignore next */
+  _In: _ => _
+};
+/** @internal */
+const dequeueVariance = {
+  /* c8 ignore next */
+  _Out: _ => _
+};
+/** @internal */
+class QueueImpl extends assets.Class {
+  queue;
+  takers;
+  shutdownHook;
+  shutdownFlag;
+  strategy;
+  [EnqueueTypeId] = enqueueVariance;
+  [DequeueTypeId] = dequeueVariance;
+  constructor(/** @internal */
+  queue, /** @internal */
+  takers, /** @internal */
+  shutdownHook, /** @internal */
+  shutdownFlag, /** @internal */
+  strategy) {
+    super();
+    this.queue = queue;
+    this.takers = takers;
+    this.shutdownHook = shutdownHook;
+    this.shutdownFlag = shutdownFlag;
+    this.strategy = strategy;
+  }
+  pipe() {
+    return assets.pipeArguments(this, arguments);
+  }
+  commit() {
+    return this.take;
+  }
+  capacity() {
+    return this.queue.capacity();
+  }
+  get size() {
+    return assets.suspend(() => assets.catchAll(this.unsafeSize(), () => assets.interrupt$1));
+  }
+  unsafeSize() {
+    if (assets.get$1(this.shutdownFlag)) {
+      return assets.none();
+    }
+    return assets.some(this.queue.length() - icons.length(this.takers) + this.strategy.surplusSize());
+  }
+  get isEmpty() {
+    return assets.map$1(this.size, size => size <= 0);
+  }
+  get isFull() {
+    return assets.map$1(this.size, size => size >= this.capacity());
+  }
+  get shutdown() {
+    return assets.uninterruptible(assets.withFiberRuntime(state => {
+      assets.pipe(this.shutdownFlag, assets.set(true));
+      return assets.pipe(assets.forEachConcurrentDiscard(unsafePollAll(this.takers), d => assets.deferredInterruptWith(d, state.id()), false, false), assets.zipRight(this.strategy.shutdown), assets.whenEffect(assets.deferredSucceed(this.shutdownHook, void 0)), assets.asVoid);
+    }));
+  }
+  get isShutdown() {
+    return assets.sync(() => assets.get$1(this.shutdownFlag));
+  }
+  get awaitShutdown() {
+    return assets.deferredAwait(this.shutdownHook);
+  }
+  isActive() {
+    return !assets.get$1(this.shutdownFlag);
+  }
+  unsafeOffer(value) {
+    if (assets.get$1(this.shutdownFlag)) {
+      return false;
+    }
+    let noRemaining;
+    if (this.queue.length() === 0) {
+      const taker = assets.pipe(this.takers, icons.poll(icons.EmptyMutableQueue));
+      if (taker !== icons.EmptyMutableQueue) {
+        unsafeCompleteDeferred(taker, value);
+        noRemaining = true;
+      } else {
+        noRemaining = false;
+      }
+    } else {
+      noRemaining = false;
+    }
+    if (noRemaining) {
+      return true;
+    }
+    // Not enough takers, offer to the queue
+    const succeeded = this.queue.offer(value);
+    unsafeCompleteTakers(this.strategy, this.queue, this.takers);
+    return succeeded;
+  }
+  offer(value) {
+    return assets.suspend(() => {
+      if (assets.get$1(this.shutdownFlag)) {
+        return assets.interrupt$1;
+      }
+      let noRemaining;
+      if (this.queue.length() === 0) {
+        const taker = assets.pipe(this.takers, icons.poll(icons.EmptyMutableQueue));
+        if (taker !== icons.EmptyMutableQueue) {
+          unsafeCompleteDeferred(taker, value);
+          noRemaining = true;
+        } else {
+          noRemaining = false;
+        }
+      } else {
+        noRemaining = false;
+      }
+      if (noRemaining) {
+        return assets.succeed(true);
+      }
+      // Not enough takers, offer to the queue
+      const succeeded = this.queue.offer(value);
+      unsafeCompleteTakers(this.strategy, this.queue, this.takers);
+      return succeeded ? assets.succeed(true) : this.strategy.handleSurplus([value], this.queue, this.takers, this.shutdownFlag);
+    });
+  }
+  offerAll(iterable) {
+    return assets.suspend(() => {
+      if (assets.get$1(this.shutdownFlag)) {
+        return assets.interrupt$1;
+      }
+      const values = assets.fromIterable(iterable);
+      const pTakers = this.queue.length() === 0 ? assets.fromIterable(unsafePollN(this.takers, values.length)) : assets.empty;
+      const [forTakers, remaining] = assets.pipe(values, assets.splitAt(pTakers.length));
+      for (let i = 0; i < pTakers.length; i++) {
+        const taker = pTakers[i];
+        const item = forTakers[i];
+        unsafeCompleteDeferred(taker, item);
+      }
+      if (remaining.length === 0) {
+        return assets.succeed(true);
+      }
+      // Not enough takers, offer to the queue
+      const surplus = this.queue.offerAll(remaining);
+      unsafeCompleteTakers(this.strategy, this.queue, this.takers);
+      return assets.isEmpty(surplus) ? assets.succeed(true) : this.strategy.handleSurplus(surplus, this.queue, this.takers, this.shutdownFlag);
+    });
+  }
+  get take() {
+    return assets.withFiberRuntime(state => {
+      if (assets.get$1(this.shutdownFlag)) {
+        return assets.interrupt$1;
+      }
+      const item = this.queue.poll(icons.EmptyMutableQueue);
+      if (item !== icons.EmptyMutableQueue) {
+        this.strategy.unsafeOnQueueEmptySpace(this.queue, this.takers);
+        return assets.succeed(item);
+      } else {
+        // Add the deferred to takers, then:
+        // - Try to take again in case a value was added since
+        // - Wait for the deferred to be completed
+        // - Clean up resources in case of interruption
+        const deferred = assets.deferredUnsafeMake(state.id());
+        return assets.pipe(assets.suspend(() => {
+          assets.pipe(this.takers, icons.offer(deferred));
+          unsafeCompleteTakers(this.strategy, this.queue, this.takers);
+          return assets.get$1(this.shutdownFlag) ? assets.interrupt$1 : assets.deferredAwait(deferred);
+        }), assets.onInterrupt(() => {
+          return assets.sync(() => unsafeRemove(this.takers, deferred));
+        }));
+      }
+    });
+  }
+  get takeAll() {
+    return assets.suspend(() => {
+      return assets.get$1(this.shutdownFlag) ? assets.interrupt$1 : assets.sync(() => {
+        const values = this.queue.pollUpTo(Number.POSITIVE_INFINITY);
+        this.strategy.unsafeOnQueueEmptySpace(this.queue, this.takers);
+        return assets.fromIterable$1(values);
+      });
+    });
+  }
+  takeUpTo(max) {
+    return assets.suspend(() => assets.get$1(this.shutdownFlag) ? assets.interrupt$1 : assets.sync(() => {
+      const values = this.queue.pollUpTo(max);
+      this.strategy.unsafeOnQueueEmptySpace(this.queue, this.takers);
+      return assets.fromIterable$1(values);
+    }));
+  }
+  takeBetween(min, max) {
+    return assets.suspend(() => takeRemainderLoop(this, min, max, assets.empty$1()));
+  }
+}
+/** @internal */
+const takeRemainderLoop = (self, min, max, acc) => {
+  if (max < min) {
+    return assets.succeed(acc);
+  }
+  return assets.pipe(takeUpTo(self, max), assets.flatMap(bs => {
+    const remaining = min - bs.length;
+    if (remaining === 1) {
+      return assets.pipe(take$1(self), assets.map$1(b => assets.pipe(acc, assets.appendAll(bs), assets.append(b))));
+    }
+    if (remaining > 1) {
+      return assets.pipe(take$1(self), assets.flatMap(b => takeRemainderLoop(self, remaining - 1, max - bs.length - 1, assets.pipe(acc, assets.appendAll(bs), assets.append(b)))));
+    }
+    return assets.succeed(assets.pipe(acc, assets.appendAll(bs)));
+  }));
+};
+/** @internal */
+const bounded$1 = requestedCapacity => assets.pipe(assets.sync(() => icons.bounded(requestedCapacity)), assets.flatMap(queue => make$2(backingQueueFromMutableQueue(queue), backPressureStrategy())));
+/** @internal */
+const unbounded$1 = () => assets.pipe(assets.sync(() => icons.unbounded()), assets.flatMap(queue => make$2(backingQueueFromMutableQueue(queue), droppingStrategy())));
+/** @internal */
+const unsafeMake = (queue, takers, shutdownHook, shutdownFlag, strategy) => {
+  return new QueueImpl(queue, takers, shutdownHook, shutdownFlag, strategy);
+};
+/** @internal */
+const make$2 = (queue, strategy) => assets.pipe(assets.deferredMake(), assets.map$1(deferred => unsafeMake(queue, icons.unbounded(), deferred, assets.make$1(false), strategy)));
+/** @internal */
+class BackingQueueFromMutableQueue {
+  mutable;
+  [BackingQueueTypeId] = backingQueueVariance;
+  constructor(mutable) {
+    this.mutable = mutable;
+  }
+  poll(def) {
+    return icons.poll(this.mutable, def);
+  }
+  pollUpTo(limit) {
+    return icons.pollUpTo(this.mutable, limit);
+  }
+  offerAll(elements) {
+    return icons.offerAll(this.mutable, elements);
+  }
+  offer(element) {
+    return icons.offer(this.mutable, element);
+  }
+  capacity() {
+    return icons.capacity(this.mutable);
+  }
+  length() {
+    return icons.length(this.mutable);
+  }
+}
+/** @internal */
+const backingQueueFromMutableQueue = mutable => new BackingQueueFromMutableQueue(mutable);
+/** @internal */
+const size$1 = self => self.size;
+/** @internal */
+const isShutdown$1 = self => self.isShutdown;
+/** @internal */
+const shutdown$1 = self => self.shutdown;
+/** @internal */
+const offer$1 = /*#__PURE__*/assets.dual(2, (self, value) => self.offer(value));
+/** @internal */
+const take$1 = self => self.take;
+/** @internal */
+const takeUpTo = /*#__PURE__*/assets.dual(2, (self, max) => self.takeUpTo(max));
+/** @internal */
+const takeBetween$1 = /*#__PURE__*/assets.dual(3, (self, min, max) => self.takeBetween(min, max));
+// -----------------------------------------------------------------------------
+// Strategy
+// -----------------------------------------------------------------------------
+/** @internal */
+const backPressureStrategy = () => new BackPressureStrategy();
+/** @internal */
+const droppingStrategy = () => new DroppingStrategy();
+/** @internal */
+class BackPressureStrategy {
+  [QueueStrategyTypeId] = queueStrategyVariance;
+  putters = /*#__PURE__*/icons.unbounded();
+  surplusSize() {
+    return icons.length(this.putters);
+  }
+  onCompleteTakersWithEmptyQueue(takers) {
+    while (!icons.isEmpty(this.putters) && !icons.isEmpty(takers)) {
+      const taker = icons.poll(takers, void 0);
+      const putter = icons.poll(this.putters, void 0);
+      if (putter[2]) {
+        unsafeCompleteDeferred(putter[1], true);
+      }
+      unsafeCompleteDeferred(taker, putter[0]);
+    }
+  }
+  get shutdown() {
+    return assets.pipe(assets.fiberId, assets.flatMap(fiberId => assets.pipe(assets.sync(() => unsafePollAll(this.putters)), assets.flatMap(putters => assets.forEachConcurrentDiscard(putters, ([_, deferred, isLastItem]) => isLastItem ? assets.pipe(assets.deferredInterruptWith(deferred, fiberId), assets.asVoid) : assets.void_, false, false)))));
+  }
+  handleSurplus(iterable, queue, takers, isShutdown) {
+    return assets.withFiberRuntime(state => {
+      const deferred = assets.deferredUnsafeMake(state.id());
+      return assets.pipe(assets.suspend(() => {
+        this.unsafeOffer(iterable, deferred);
+        this.unsafeOnQueueEmptySpace(queue, takers);
+        unsafeCompleteTakers(this, queue, takers);
+        return assets.get$1(isShutdown) ? assets.interrupt$1 : assets.deferredAwait(deferred);
+      }), assets.onInterrupt(() => assets.sync(() => this.unsafeRemove(deferred))));
+    });
+  }
+  unsafeOnQueueEmptySpace(queue, takers) {
+    let keepPolling = true;
+    while (keepPolling && (queue.capacity() === Number.POSITIVE_INFINITY || queue.length() < queue.capacity())) {
+      const putter = assets.pipe(this.putters, icons.poll(icons.EmptyMutableQueue));
+      if (putter === icons.EmptyMutableQueue) {
+        keepPolling = false;
+      } else {
+        const offered = queue.offer(putter[0]);
+        if (offered && putter[2]) {
+          unsafeCompleteDeferred(putter[1], true);
+        } else if (!offered) {
+          unsafeOfferAll(this.putters, assets.pipe(unsafePollAll(this.putters), assets.prepend(putter)));
+        }
+        unsafeCompleteTakers(this, queue, takers);
+      }
+    }
+  }
+  unsafeOffer(iterable, deferred) {
+    const stuff = assets.fromIterable(iterable);
+    for (let i = 0; i < stuff.length; i++) {
+      const value = stuff[i];
+      if (i === stuff.length - 1) {
+        assets.pipe(this.putters, icons.offer([value, deferred, true]));
+      } else {
+        assets.pipe(this.putters, icons.offer([value, deferred, false]));
+      }
+    }
+  }
+  unsafeRemove(deferred) {
+    unsafeOfferAll(this.putters, assets.pipe(unsafePollAll(this.putters), assets.filter(([, _]) => _ !== deferred)));
+  }
+}
+/** @internal */
+class DroppingStrategy {
+  [QueueStrategyTypeId] = queueStrategyVariance;
+  surplusSize() {
+    return 0;
+  }
+  get shutdown() {
+    return assets.void_;
+  }
+  onCompleteTakersWithEmptyQueue() {}
+  handleSurplus(_iterable, _queue, _takers, _isShutdown) {
+    return assets.succeed(false);
+  }
+  unsafeOnQueueEmptySpace(_queue, _takers) {
+    //
+  }
+}
+/** @internal */
+const unsafeCompleteDeferred = (deferred, a) => {
+  return assets.deferredUnsafeDone(deferred, assets.succeed(a));
+};
+/** @internal */
+const unsafeOfferAll = (queue, as) => {
+  return assets.pipe(queue, icons.offerAll(as));
+};
+/** @internal */
+const unsafePollAll = queue => {
+  return assets.pipe(queue, icons.pollUpTo(Number.POSITIVE_INFINITY));
+};
+/** @internal */
+const unsafePollN = (queue, max) => {
+  return assets.pipe(queue, icons.pollUpTo(max));
+};
+/** @internal */
+const unsafeRemove = (queue, a) => {
+  unsafeOfferAll(queue, assets.pipe(unsafePollAll(queue), assets.filter(b => a !== b)));
+};
+/** @internal */
+const unsafeCompleteTakers = (strategy, queue, takers) => {
+  // Check both a taker and an item are in the queue, starting with the taker
+  let keepPolling = true;
+  while (keepPolling && queue.length() !== 0) {
+    const taker = assets.pipe(takers, icons.poll(icons.EmptyMutableQueue));
+    if (taker !== icons.EmptyMutableQueue) {
+      const element = queue.poll(icons.EmptyMutableQueue);
+      if (element !== icons.EmptyMutableQueue) {
+        unsafeCompleteDeferred(taker, element);
+        strategy.unsafeOnQueueEmptySpace(queue, takers);
+      } else {
+        unsafeOfferAll(takers, assets.pipe(unsafePollAll(takers), assets.prepend(taker)));
+      }
+      keepPolling = true;
+    } else {
+      keepPolling = false;
+    }
+  }
+  if (keepPolling && queue.length() === 0 && !icons.isEmpty(takers)) {
+    strategy.onCompleteTakersWithEmptyQueue(takers);
+  }
+};
+
+/**
+ * Makes a new bounded `Queue`. When the capacity of the queue is reached, any
+ * additional calls to `offer` will be suspended until there is more room in
+ * the queue.
+ *
+ * **Note**: When possible use only power of 2 capacities; this will provide
+ * better performance by utilising an optimised version of the underlying
+ * `RingBuffer`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const bounded = bounded$1;
+/**
+ * Creates a new unbounded `Queue`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const unbounded = unbounded$1;
+/**
+ * Retrieves the size of the queue, which is equal to the number of elements
+ * in the queue. This may be negative if fibers are suspended waiting for
+ * elements to be added to the queue.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const size = size$1;
+/**
+ * Returns `true` if `shutdown` has been called, otherwise returns `false`.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const isShutdown = isShutdown$1;
+/**
+ * Interrupts any fibers that are suspended on `offer` or `take`. Future calls
+ * to `offer*` and `take*` will be interrupted immediately.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const shutdown = shutdown$1;
+/**
+ * Places one value in the queue.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const offer = offer$1;
+/**
+ * Takes the oldest value in the queue. If the queue is empty, this will return
+ * a computation that resumes when an item has been added to the queue.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const take = take$1;
+/**
+ * Takes a number of elements from the queue between the specified minimum and
+ * maximum. If there are fewer than the minimum number of elements available,
+ * suspends until at least the minimum number of elements have been collected.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const takeBetween = takeBetween$1;
+
+/** @internal */
+const OP_CONTINUE = "Continue";
+/** @internal */
+const OP_CLOSE = "Close";
+/** @internal */
+const OP_YIELD = "Yield";
+
+/** @internal */
+const ChildExecutorDecisionSymbolKey = "effect/ChannelChildExecutorDecision";
+/** @internal */
+const ChildExecutorDecisionTypeId = /*#__PURE__*/Symbol.for(ChildExecutorDecisionSymbolKey);
+/** @internal */
+const proto$7 = {
+  [ChildExecutorDecisionTypeId]: ChildExecutorDecisionTypeId
+};
+/** @internal */
+const Continue = _ => {
+  const op = Object.create(proto$7);
+  op._tag = OP_CONTINUE;
+  return op;
+};
+
+/** @internal */
+const OP_CONTINUATION_K = "ContinuationK";
+/** @internal */
+const OP_CONTINUATION_FINALIZER = "ContinuationFinalizer";
+
+/** @internal */
+const ContinuationTypeId = /*#__PURE__*/Symbol.for("effect/ChannelContinuation");
+const continuationVariance = {
+  /* c8 ignore next */
+  _Env: _ => _,
+  /* c8 ignore next */
+  _InErr: _ => _,
+  /* c8 ignore next */
+  _InElem: _ => _,
+  /* c8 ignore next */
+  _InDone: _ => _,
+  /* c8 ignore next */
+  _OutErr: _ => _,
+  /* c8 ignore next */
+  _OutDone: _ => _,
+  /* c8 ignore next */
+  _OutErr2: _ => _,
+  /* c8 ignore next */
+  _OutElem: _ => _,
+  /* c8 ignore next */
+  _OutDone2: _ => _
+};
+/** @internal */
+class ContinuationKImpl {
+  onSuccess;
+  onHalt;
+  _tag = OP_CONTINUATION_K;
+  [ContinuationTypeId] = continuationVariance;
+  constructor(onSuccess, onHalt) {
+    this.onSuccess = onSuccess;
+    this.onHalt = onHalt;
+  }
+  onExit(exit) {
+    return icons.isFailure(exit) ? this.onHalt(exit.cause) : this.onSuccess(exit.value);
+  }
+}
+/** @internal */
+class ContinuationFinalizerImpl {
+  finalizer;
+  _tag = OP_CONTINUATION_FINALIZER;
+  [ContinuationTypeId] = continuationVariance;
+  constructor(finalizer) {
+    this.finalizer = finalizer;
+  }
+}
+
+/** @internal */
+const OP_PULL_AFTER_NEXT = "PullAfterNext";
+/** @internal */
+const OP_PULL_AFTER_ALL_ENQUEUED = "PullAfterAllEnqueued";
+
+/** @internal */
+const UpstreamPullStrategySymbolKey = "effect/ChannelUpstreamPullStrategy";
+/** @internal */
+const UpstreamPullStrategyTypeId = /*#__PURE__*/Symbol.for(UpstreamPullStrategySymbolKey);
+const upstreamPullStrategyVariance = {
+  /* c8 ignore next */
+  _A: _ => _
+};
+/** @internal */
+const proto$6 = {
+  [UpstreamPullStrategyTypeId]: upstreamPullStrategyVariance
+};
+/** @internal */
+const PullAfterNext = emitSeparator => {
+  const op = Object.create(proto$6);
+  op._tag = OP_PULL_AFTER_NEXT;
+  op.emitSeparator = emitSeparator;
+  return op;
+};
+
+/** @internal */
+const OP_BRACKET_OUT = "BracketOut";
+/** @internal */
+const OP_BRIDGE = "Bridge";
+/** @internal */
+const OP_CONCAT_ALL = "ConcatAll";
+/** @internal */
+const OP_EMIT$2 = "Emit";
+/** @internal */
+const OP_ENSURING = "Ensuring";
+/** @internal */
+const OP_FAIL = "Fail";
+/** @internal */
+const OP_FOLD = "Fold";
+/** @internal */
+const OP_FROM_EFFECT$1 = "FromEffect";
+/** @internal */
+const OP_PIPE_TO = "PipeTo";
+/** @internal */
+const OP_PROVIDE = "Provide";
+/** @internal */
+const OP_READ$1 = "Read";
+/** @internal */
+const OP_SUCCEED = "Succeed";
+/** @internal */
+const OP_SUCCEED_NOW = "SucceedNow";
+/** @internal */
+const OP_SUSPEND = "Suspend";
+
+/** @internal */
+const ChannelSymbolKey = "effect/Channel";
+/** @internal */
+const ChannelTypeId = /*#__PURE__*/Symbol.for(ChannelSymbolKey);
+const channelVariance = {
+  /* c8 ignore next */
+  _Env: _ => _,
+  /* c8 ignore next */
+  _InErr: _ => _,
+  /* c8 ignore next */
+  _InElem: _ => _,
+  /* c8 ignore next */
+  _InDone: _ => _,
+  /* c8 ignore next */
+  _OutErr: _ => _,
+  /* c8 ignore next */
+  _OutElem: _ => _,
+  /* c8 ignore next */
+  _OutDone: _ => _
+};
+/** @internal */
+const proto$5 = {
+  [ChannelTypeId]: channelVariance,
+  pipe() {
+    return assets.pipeArguments(this, arguments);
+  }
+};
+/** @internal */
+const isChannel = u => assets.hasProperty(u, ChannelTypeId) || assets.isEffect(u);
+/** @internal */
+const acquireReleaseOut = /*#__PURE__*/assets.dual(2, (self, release) => {
+  const op = Object.create(proto$5);
+  op._tag = OP_BRACKET_OUT;
+  op.acquire = () => self;
+  op.finalizer = release;
+  return op;
+});
+/** @internal */
+const concatAllWith = (channels, f, g) => {
+  const op = Object.create(proto$5);
+  op._tag = OP_CONCAT_ALL;
+  op.combineInners = f;
+  op.combineAll = g;
+  op.onPull = () => PullAfterNext(assets.none());
+  op.onEmit = () => Continue;
+  op.value = () => channels;
+  op.k = assets.identity;
+  return op;
+};
+/** @internal */
+const concatMapWith = /*#__PURE__*/assets.dual(4, (self, f, g, h) => {
+  const op = Object.create(proto$5);
+  op._tag = OP_CONCAT_ALL;
+  op.combineInners = g;
+  op.combineAll = h;
+  op.onPull = () => PullAfterNext(assets.none());
+  op.onEmit = () => Continue;
+  op.value = () => self;
+  op.k = f;
+  return op;
+});
+/** @internal */
+const embedInput = /*#__PURE__*/assets.dual(2, (self, input) => {
+  const op = Object.create(proto$5);
+  op._tag = OP_BRIDGE;
+  op.input = input;
+  op.channel = self;
+  return op;
+});
+/** @internal */
+const ensuringWith = /*#__PURE__*/assets.dual(2, (self, finalizer) => {
+  const op = Object.create(proto$5);
+  op._tag = OP_ENSURING;
+  op.channel = self;
+  op.finalizer = finalizer;
+  return op;
+});
+/** @internal */
+const fail = error => failCause$2(fail$1(error));
+/** @internal */
+const failCause$2 = cause => failCauseSync(() => cause);
+/** @internal */
+const failCauseSync = evaluate => {
+  const op = Object.create(proto$5);
+  op._tag = OP_FAIL;
+  op.error = evaluate;
+  return op;
+};
+/** @internal */
+const flatMap$1 = /*#__PURE__*/assets.dual(2, (self, f) => {
+  const op = Object.create(proto$5);
+  op._tag = OP_FOLD;
+  op.channel = self;
+  op.k = new ContinuationKImpl(f, failCause$2);
+  return op;
+});
+/** @internal */
+const fromEffect$3 = effect => {
+  const op = Object.create(proto$5);
+  op._tag = OP_FROM_EFFECT$1;
+  op.effect = () => effect;
+  return op;
+};
+/** @internal */
+const pipeTo = /*#__PURE__*/assets.dual(2, (self, that) => {
+  const op = Object.create(proto$5);
+  op._tag = OP_PIPE_TO;
+  op.left = () => self;
+  op.right = () => that;
+  return op;
+});
+/** @internal */
+const readWith = options => readWithCause({
+  onInput: options.onInput,
+  onFailure: cause => assets.match(failureOrCause(cause), {
+    onLeft: options.onFailure,
+    onRight: failCause$2
+  }),
+  onDone: options.onDone
+});
+/** @internal */
+const readWithCause = options => {
+  const op = Object.create(proto$5);
+  op._tag = OP_READ$1;
+  op.more = options.onInput;
+  op.done = new ContinuationKImpl(options.onDone, options.onFailure);
+  return op;
+};
+/** @internal */
+const succeed = value => sync(() => value);
+/** @internal */
+const succeedNow = result => {
+  const op = Object.create(proto$5);
+  op._tag = OP_SUCCEED_NOW;
+  op.terminal = result;
+  return op;
+};
+/** @internal */
+const suspend$1 = evaluate => {
+  const op = Object.create(proto$5);
+  op._tag = OP_SUSPEND;
+  op.channel = evaluate;
+  return op;
+};
+const sync = evaluate => {
+  const op = Object.create(proto$5);
+  op._tag = OP_SUCCEED;
+  op.evaluate = evaluate;
+  return op;
+};
+const void_ = /*#__PURE__*/succeedNow(void 0);
+/** @internal */
+const write = out => {
+  const op = Object.create(proto$5);
+  op._tag = OP_EMIT$2;
+  op.out = out;
+  return op;
+};
+
+/** @internal */
+const OP_DONE$1 = "Done";
+/** @internal */
+const OP_EMIT$1 = "Emit";
+/** @internal */
+const OP_FROM_EFFECT = "FromEffect";
+/** @internal */
+const OP_READ = "Read";
+
+/** @internal */
+const ChannelStateTypeId = /*#__PURE__*/Symbol.for("effect/ChannelState");
+const channelStateVariance = {
+  /* c8 ignore next */
+  _E: _ => _,
+  /* c8 ignore next */
+  _R: _ => _
+};
+/** @internal */
+const proto$4 = {
+  [ChannelStateTypeId]: channelStateVariance
+};
+/** @internal */
+const Done = () => {
+  const op = Object.create(proto$4);
+  op._tag = OP_DONE$1;
+  return op;
+};
+/** @internal */
+const Emit$1 = () => {
+  const op = Object.create(proto$4);
+  op._tag = OP_EMIT$1;
+  return op;
+};
+/** @internal */
+const fromEffect$2 = effect => {
+  const op = Object.create(proto$4);
+  op._tag = OP_FROM_EFFECT;
+  op.effect = effect;
+  return op;
+};
+/** @internal */
+const Read = (upstream, onEffect, onEmit, onDone) => {
+  const op = Object.create(proto$4);
+  op._tag = OP_READ;
+  op.upstream = upstream;
+  op.onEffect = onEffect;
+  op.onEmit = onEmit;
+  op.onDone = onDone;
+  return op;
+};
+/** @internal */
+const isFromEffect = self => self._tag === OP_FROM_EFFECT;
+/** @internal */
+const effect = self => isFromEffect(self) ? self.effect : assets._void;
+/** @internal */
+const effectOrUndefinedIgnored = self => isFromEffect(self) ? assets.ignore(self.effect) : undefined;
+
+/** @internal */
+const OP_PULL_FROM_CHILD = "PullFromChild";
+/** @internal */
+const OP_PULL_FROM_UPSTREAM = "PullFromUpstream";
+/** @internal */
+const OP_DRAIN_CHILD_EXECUTORS = "DrainChildExecutors";
+/** @internal */
+const OP_EMIT = "Emit";
+/**
+ * Execute the `childExecutor` and on each emitted value, decide what to do by
+ * `onEmit`.
+ *
+ * @internal
+ */
+class PullFromChild {
+  childExecutor;
+  parentSubexecutor;
+  onEmit;
+  _tag = OP_PULL_FROM_CHILD;
+  constructor(childExecutor, parentSubexecutor, onEmit) {
+    this.childExecutor = childExecutor;
+    this.parentSubexecutor = parentSubexecutor;
+    this.onEmit = onEmit;
+  }
+  close(exit) {
+    const fin1 = this.childExecutor.close(exit);
+    const fin2 = this.parentSubexecutor.close(exit);
+    if (fin1 !== undefined && fin2 !== undefined) {
+      return assets.zipWith(assets.exit(fin1), assets.exit(fin2), (exit1, exit2) => assets.pipe(exit1, icons.zipRight(exit2)));
+    } else if (fin1 !== undefined) {
+      return fin1;
+    } else if (fin2 !== undefined) {
+      return fin2;
+    } else {
+      return undefined;
+    }
+  }
+  enqueuePullFromChild(_child) {
+    return this;
+  }
+}
+/**
+ * Execute `upstreamExecutor` and for each emitted element, spawn a child
+ * channel and continue with processing it by `PullFromChild`.
+ *
+ * @internal
+ */
+class PullFromUpstream {
+  upstreamExecutor;
+  createChild;
+  lastDone;
+  activeChildExecutors;
+  combineChildResults;
+  combineWithChildResult;
+  onPull;
+  onEmit;
+  _tag = OP_PULL_FROM_UPSTREAM;
+  constructor(upstreamExecutor, createChild, lastDone, activeChildExecutors, combineChildResults, combineWithChildResult, onPull, onEmit) {
+    this.upstreamExecutor = upstreamExecutor;
+    this.createChild = createChild;
+    this.lastDone = lastDone;
+    this.activeChildExecutors = activeChildExecutors;
+    this.combineChildResults = combineChildResults;
+    this.combineWithChildResult = combineWithChildResult;
+    this.onPull = onPull;
+    this.onEmit = onEmit;
+  }
+  close(exit) {
+    const fin1 = this.upstreamExecutor.close(exit);
+    const fins = [...this.activeChildExecutors.map(child => child !== undefined ? child.childExecutor.close(exit) : undefined), fin1];
+    const result = fins.reduce((acc, next) => {
+      if (acc !== undefined && next !== undefined) {
+        return assets.zipWith(acc, assets.exit(next), (exit1, exit2) => icons.zipRight(exit1, exit2));
+      } else if (acc !== undefined) {
+        return acc;
+      } else if (next !== undefined) {
+        return assets.exit(next);
+      } else {
+        return undefined;
+      }
+    }, undefined);
+    return result === undefined ? result : result;
+  }
+  enqueuePullFromChild(child) {
+    return new PullFromUpstream(this.upstreamExecutor, this.createChild, this.lastDone, [...this.activeChildExecutors, child], this.combineChildResults, this.combineWithChildResult, this.onPull, this.onEmit);
+  }
+}
+/**
+ * Transformed from `PullFromUpstream` when upstream has finished but there
+ * are still active child executors.
+ *
+ * @internal
+ */
+class DrainChildExecutors {
+  upstreamExecutor;
+  lastDone;
+  activeChildExecutors;
+  upstreamDone;
+  combineChildResults;
+  combineWithChildResult;
+  onPull;
+  _tag = OP_DRAIN_CHILD_EXECUTORS;
+  constructor(upstreamExecutor, lastDone, activeChildExecutors, upstreamDone, combineChildResults, combineWithChildResult, onPull) {
+    this.upstreamExecutor = upstreamExecutor;
+    this.lastDone = lastDone;
+    this.activeChildExecutors = activeChildExecutors;
+    this.upstreamDone = upstreamDone;
+    this.combineChildResults = combineChildResults;
+    this.combineWithChildResult = combineWithChildResult;
+    this.onPull = onPull;
+  }
+  close(exit) {
+    const fin1 = this.upstreamExecutor.close(exit);
+    const fins = [...this.activeChildExecutors.map(child => child !== undefined ? child.childExecutor.close(exit) : undefined), fin1];
+    const result = fins.reduce((acc, next) => {
+      if (acc !== undefined && next !== undefined) {
+        return assets.zipWith(acc, assets.exit(next), (exit1, exit2) => icons.zipRight(exit1, exit2));
+      } else if (acc !== undefined) {
+        return acc;
+      } else if (next !== undefined) {
+        return assets.exit(next);
+      } else {
+        return undefined;
+      }
+    }, undefined);
+    return result === undefined ? result : result;
+  }
+  enqueuePullFromChild(child) {
+    return new DrainChildExecutors(this.upstreamExecutor, this.lastDone, [...this.activeChildExecutors, child], this.upstreamDone, this.combineChildResults, this.combineWithChildResult, this.onPull);
+  }
+}
+/** @internal */
+class Emit {
+  value;
+  next;
+  _tag = OP_EMIT;
+  constructor(value, next) {
+    this.value = value;
+    this.next = next;
+  }
+  close(exit) {
+    const result = this.next.close(exit);
+    return result === undefined ? result : result;
+  }
+  enqueuePullFromChild(_child) {
+    return this;
+  }
+}
+
+/** @internal */
+const OP_PULLED = "Pulled";
+/** @internal */
+const OP_NO_UPSTREAM = "NoUpstream";
+
+/** @internal */
+const UpstreamPullRequestSymbolKey = "effect/ChannelUpstreamPullRequest";
+/** @internal */
+const UpstreamPullRequestTypeId = /*#__PURE__*/Symbol.for(UpstreamPullRequestSymbolKey);
+const upstreamPullRequestVariance = {
+  /* c8 ignore next */
+  _A: _ => _
+};
+/** @internal */
+const proto$3 = {
+  [UpstreamPullRequestTypeId]: upstreamPullRequestVariance
+};
+/** @internal */
+const Pulled = value => {
+  const op = Object.create(proto$3);
+  op._tag = OP_PULLED;
+  op.value = value;
+  return op;
+};
+/** @internal */
+const NoUpstream = activeDownstreamCount => {
+  const op = Object.create(proto$3);
+  op._tag = OP_NO_UPSTREAM;
+  op.activeDownstreamCount = activeDownstreamCount;
+  return op;
+};
+
+/** @internal */
+class ChannelExecutor {
+  _activeSubexecutor = undefined;
+  _cancelled = undefined;
+  _closeLastSubstream = undefined;
+  _currentChannel;
+  _done = undefined;
+  _doneStack = [];
+  _emitted = undefined;
+  _executeCloseLastSubstream;
+  _input = undefined;
+  _inProgressFinalizer = undefined;
+  _providedEnv;
+  constructor(initialChannel, providedEnv, executeCloseLastSubstream) {
+    this._currentChannel = initialChannel;
+    this._executeCloseLastSubstream = executeCloseLastSubstream;
+    this._providedEnv = providedEnv;
+  }
+  run() {
+    let result = undefined;
+    while (result === undefined) {
+      if (this._cancelled !== undefined) {
+        result = this.processCancellation();
+      } else if (this._activeSubexecutor !== undefined) {
+        result = this.runSubexecutor();
+      } else {
+        try {
+          if (this._currentChannel === undefined) {
+            result = Done();
+          } else {
+            if (assets.isEffect(this._currentChannel)) {
+              this._currentChannel = fromEffect$3(this._currentChannel);
+            }
+            switch (this._currentChannel._tag) {
+              case OP_BRACKET_OUT:
+                {
+                  result = this.runBracketOut(this._currentChannel);
+                  break;
+                }
+              case OP_BRIDGE:
+                {
+                  const bridgeInput = this._currentChannel.input;
+                  // PipeTo(left, Bridge(queue, channel))
+                  // In a fiber: repeatedly run left and push its outputs to the queue
+                  // Add a finalizer to interrupt the fiber and close the executor
+                  this._currentChannel = this._currentChannel.channel;
+                  if (this._input !== undefined) {
+                    const inputExecutor = this._input;
+                    this._input = undefined;
+                    const drainer = () => assets.flatMap$1(bridgeInput.awaitRead(), () => assets.suspend$1(() => {
+                      const state = inputExecutor.run();
+                      switch (state._tag) {
+                        case OP_DONE$1:
+                          {
+                            return icons.match(inputExecutor.getDone(), {
+                              onFailure: cause => bridgeInput.error(cause),
+                              onSuccess: value => bridgeInput.done(value)
+                            });
+                          }
+                        case OP_EMIT$1:
+                          {
+                            return assets.flatMap$1(bridgeInput.emit(inputExecutor.getEmit()), () => drainer());
+                          }
+                        case OP_FROM_EFFECT:
+                          {
+                            return assets.matchCauseEffect(state.effect, {
+                              onFailure: cause => bridgeInput.error(cause),
+                              onSuccess: () => drainer()
+                            });
+                          }
+                        case OP_READ:
+                          {
+                            return readUpstream(state, () => drainer(), cause => bridgeInput.error(cause));
+                          }
+                      }
+                    }));
+                    result = fromEffect$2(assets.flatMap$1(assets.forkDaemon(assets.interruptible(drainer())), fiber => assets.sync$1(() => this.addFinalizer(exit => assets.flatMap$1(interrupt(fiber), () => assets.suspend$1(() => {
+                      const effect = this.restorePipe(exit, inputExecutor);
+                      return effect !== undefined ? effect : assets._void;
+                    }))))));
+                  }
+                  break;
+                }
+              case OP_CONCAT_ALL:
+                {
+                  const executor = new ChannelExecutor(this._currentChannel.value(), this._providedEnv, effect => assets.sync$1(() => {
+                    const prevLastClose = this._closeLastSubstream === undefined ? assets._void : this._closeLastSubstream;
+                    this._closeLastSubstream = assets.pipe(prevLastClose, assets.zipRight$1(effect));
+                  }));
+                  executor._input = this._input;
+                  const channel = this._currentChannel;
+                  this._activeSubexecutor = new PullFromUpstream(executor, value => channel.k(value), undefined, [], (x, y) => channel.combineInners(x, y), (x, y) => channel.combineAll(x, y), request => channel.onPull(request), value => channel.onEmit(value));
+                  this._closeLastSubstream = undefined;
+                  this._currentChannel = undefined;
+                  break;
+                }
+              case OP_EMIT$2:
+                {
+                  this._emitted = this._currentChannel.out;
+                  this._currentChannel = this._activeSubexecutor !== undefined ? undefined : void_;
+                  result = Emit$1();
+                  break;
+                }
+              case OP_ENSURING:
+                {
+                  this.runEnsuring(this._currentChannel);
+                  break;
+                }
+              case OP_FAIL:
+                {
+                  result = this.doneHalt(this._currentChannel.error());
+                  break;
+                }
+              case OP_FOLD:
+                {
+                  this._doneStack.push(this._currentChannel.k);
+                  this._currentChannel = this._currentChannel.channel;
+                  break;
+                }
+              case OP_FROM_EFFECT$1:
+                {
+                  const effect = this._providedEnv === undefined ? this._currentChannel.effect() : assets.pipe(this._currentChannel.effect(), assets.provide(this._providedEnv));
+                  result = fromEffect$2(assets.matchCauseEffect(effect, {
+                    onFailure: cause => {
+                      const state = this.doneHalt(cause);
+                      return state !== undefined && isFromEffect(state) ? state.effect : assets._void;
+                    },
+                    onSuccess: value => {
+                      const state = this.doneSucceed(value);
+                      return state !== undefined && isFromEffect(state) ? state.effect : assets._void;
+                    }
+                  }));
+                  break;
+                }
+              case OP_PIPE_TO:
+                {
+                  const previousInput = this._input;
+                  const leftExec = new ChannelExecutor(this._currentChannel.left(), this._providedEnv, effect => this._executeCloseLastSubstream(effect));
+                  leftExec._input = previousInput;
+                  this._input = leftExec;
+                  this.addFinalizer(exit => {
+                    const effect = this.restorePipe(exit, previousInput);
+                    return effect !== undefined ? effect : assets._void;
+                  });
+                  this._currentChannel = this._currentChannel.right();
+                  break;
+                }
+              case OP_PROVIDE:
+                {
+                  const previousEnv = this._providedEnv;
+                  this._providedEnv = this._currentChannel.context();
+                  this._currentChannel = this._currentChannel.inner;
+                  this.addFinalizer(() => assets.sync$1(() => {
+                    this._providedEnv = previousEnv;
+                  }));
+                  break;
+                }
+              case OP_READ$1:
+                {
+                  const read = this._currentChannel;
+                  result = Read(this._input, assets.identity, emitted => {
+                    try {
+                      this._currentChannel = read.more(emitted);
+                    } catch (error) {
+                      this._currentChannel = read.done.onExit(icons.die(error));
+                    }
+                    return undefined;
+                  }, exit => {
+                    const onExit = exit => {
+                      return read.done.onExit(exit);
+                    };
+                    this._currentChannel = onExit(exit);
+                    return undefined;
+                  });
+                  break;
+                }
+              case OP_SUCCEED:
+                {
+                  result = this.doneSucceed(this._currentChannel.evaluate());
+                  break;
+                }
+              case OP_SUCCEED_NOW:
+                {
+                  result = this.doneSucceed(this._currentChannel.terminal);
+                  break;
+                }
+              case OP_SUSPEND:
+                {
+                  this._currentChannel = this._currentChannel.channel();
+                  break;
+                }
+            }
+          }
+        } catch (error) {
+          this._currentChannel = failCause$2(die(error));
+        }
+      }
+    }
+    return result;
+  }
+  getDone() {
+    return this._done;
+  }
+  getEmit() {
+    return this._emitted;
+  }
+  cancelWith(exit) {
+    this._cancelled = exit;
+  }
+  clearInProgressFinalizer() {
+    this._inProgressFinalizer = undefined;
+  }
+  storeInProgressFinalizer(finalizer) {
+    this._inProgressFinalizer = finalizer;
+  }
+  popAllFinalizers(exit) {
+    const finalizers = [];
+    let next = this._doneStack.pop();
+    while (next) {
+      if (next._tag === "ContinuationFinalizer") {
+        finalizers.push(next.finalizer);
+      }
+      next = this._doneStack.pop();
+    }
+    const effect = finalizers.length === 0 ? assets._void : runFinalizers(finalizers, exit);
+    this.storeInProgressFinalizer(effect);
+    return effect;
+  }
+  popNextFinalizers() {
+    const builder = [];
+    while (this._doneStack.length !== 0) {
+      const cont = this._doneStack[this._doneStack.length - 1];
+      if (cont._tag === OP_CONTINUATION_K) {
+        return builder;
+      }
+      builder.push(cont);
+      this._doneStack.pop();
+    }
+    return builder;
+  }
+  restorePipe(exit, prev) {
+    const currInput = this._input;
+    this._input = prev;
+    if (currInput !== undefined) {
+      const effect = currInput.close(exit);
+      return effect;
+    }
+    return assets._void;
+  }
+  close(exit) {
+    let runInProgressFinalizers = undefined;
+    const finalizer = this._inProgressFinalizer;
+    if (finalizer !== undefined) {
+      runInProgressFinalizers = assets.pipe(finalizer, assets.ensuring(assets.sync$1(() => this.clearInProgressFinalizer())));
+    }
+    let closeSelf = undefined;
+    const selfFinalizers = this.popAllFinalizers(exit);
+    if (selfFinalizers !== undefined) {
+      closeSelf = assets.pipe(selfFinalizers, assets.ensuring(assets.sync$1(() => this.clearInProgressFinalizer())));
+    }
+    const closeSubexecutors = this._activeSubexecutor === undefined ? undefined : this._activeSubexecutor.close(exit);
+    if (closeSubexecutors === undefined && runInProgressFinalizers === undefined && closeSelf === undefined) {
+      return undefined;
+    }
+    return assets.pipe(assets.exit(ifNotNull(closeSubexecutors)), assets.zip(assets.exit(ifNotNull(runInProgressFinalizers))), assets.zip(assets.exit(ifNotNull(closeSelf))), assets.map$2(([[exit1, exit2], exit3]) => assets.pipe(exit1, icons.zipRight(exit2), icons.zipRight(exit3))), assets.uninterruptible$1,
+    // TODO: remove
+    assets.flatMap$1(exit => assets.suspend$1(() => exit)));
+  }
+  doneSucceed(value) {
+    if (this._doneStack.length === 0) {
+      this._done = icons.succeed(value);
+      this._currentChannel = undefined;
+      return Done();
+    }
+    const head = this._doneStack[this._doneStack.length - 1];
+    if (head._tag === OP_CONTINUATION_K) {
+      this._doneStack.pop();
+      this._currentChannel = head.onSuccess(value);
+      return undefined;
+    }
+    const finalizers = this.popNextFinalizers();
+    if (this._doneStack.length === 0) {
+      this._doneStack = finalizers.reverse();
+      this._done = icons.succeed(value);
+      this._currentChannel = undefined;
+      return Done();
+    }
+    const finalizerEffect = runFinalizers(finalizers.map(f => f.finalizer), icons.succeed(value));
+    this.storeInProgressFinalizer(finalizerEffect);
+    const effect = assets.pipe(finalizerEffect, assets.ensuring(assets.sync$1(() => this.clearInProgressFinalizer())), assets.uninterruptible$1, assets.flatMap$1(() => assets.sync$1(() => this.doneSucceed(value))));
+    return fromEffect$2(effect);
+  }
+  doneHalt(cause) {
+    if (this._doneStack.length === 0) {
+      this._done = icons.failCause(cause);
+      this._currentChannel = undefined;
+      return Done();
+    }
+    const head = this._doneStack[this._doneStack.length - 1];
+    if (head._tag === OP_CONTINUATION_K) {
+      this._doneStack.pop();
+      try {
+        this._currentChannel = head.onHalt(cause);
+      } catch (error) {
+        this._currentChannel = failCause$2(die(error));
+      }
+      return undefined;
+    }
+    const finalizers = this.popNextFinalizers();
+    if (this._doneStack.length === 0) {
+      this._doneStack = finalizers.reverse();
+      this._done = icons.failCause(cause);
+      this._currentChannel = undefined;
+      return Done();
+    }
+    const finalizerEffect = runFinalizers(finalizers.map(f => f.finalizer), icons.failCause(cause));
+    this.storeInProgressFinalizer(finalizerEffect);
+    const effect = assets.pipe(finalizerEffect, assets.ensuring(assets.sync$1(() => this.clearInProgressFinalizer())), assets.uninterruptible$1, assets.flatMap$1(() => assets.sync$1(() => this.doneHalt(cause))));
+    return fromEffect$2(effect);
+  }
+  processCancellation() {
+    this._currentChannel = undefined;
+    this._done = this._cancelled;
+    this._cancelled = undefined;
+    return Done();
+  }
+  runBracketOut(bracketOut) {
+    const effect = assets.uninterruptible$1(assets.matchCauseEffect(this.provide(bracketOut.acquire()), {
+      onFailure: cause => assets.sync$1(() => {
+        this._currentChannel = failCause$2(cause);
+      }),
+      onSuccess: out => assets.sync$1(() => {
+        this.addFinalizer(exit => this.provide(bracketOut.finalizer(out, exit)));
+        this._currentChannel = write(out);
+      })
+    }));
+    return fromEffect$2(effect);
+  }
+  provide(effect) {
+    if (this._providedEnv === undefined) {
+      return effect;
+    }
+    return assets.pipe(effect, assets.provide(this._providedEnv));
+  }
+  runEnsuring(ensuring) {
+    this.addFinalizer(ensuring.finalizer);
+    this._currentChannel = ensuring.channel;
+  }
+  addFinalizer(f) {
+    this._doneStack.push(new ContinuationFinalizerImpl(f));
+  }
+  runSubexecutor() {
+    const subexecutor = this._activeSubexecutor;
+    switch (subexecutor._tag) {
+      case OP_PULL_FROM_CHILD:
+        {
+          return this.pullFromChild(subexecutor.childExecutor, subexecutor.parentSubexecutor, subexecutor.onEmit, subexecutor);
+        }
+      case OP_PULL_FROM_UPSTREAM:
+        {
+          return this.pullFromUpstream(subexecutor);
+        }
+      case OP_DRAIN_CHILD_EXECUTORS:
+        {
+          return this.drainChildExecutors(subexecutor);
+        }
+      case OP_EMIT:
+        {
+          this._emitted = subexecutor.value;
+          this._activeSubexecutor = subexecutor.next;
+          return Emit$1();
+        }
+    }
+  }
+  replaceSubexecutor(nextSubExec) {
+    this._currentChannel = undefined;
+    this._activeSubexecutor = nextSubExec;
+  }
+  finishWithExit(exit) {
+    const state = icons.match(exit, {
+      onFailure: cause => this.doneHalt(cause),
+      onSuccess: value => this.doneSucceed(value)
+    });
+    this._activeSubexecutor = undefined;
+    return state === undefined ? assets._void : effect(state);
+  }
+  finishSubexecutorWithCloseEffect(subexecutorDone, ...closeFuncs) {
+    this.addFinalizer(() => assets.pipe(closeFuncs, assets.forEach(closeFunc => assets.pipe(assets.sync$1(() => closeFunc(subexecutorDone)), assets.flatMap$1(closeEffect => closeEffect !== undefined ? closeEffect : assets._void)), {
+      discard: true
+    })));
+    const state = assets.pipe(subexecutorDone, icons.match({
+      onFailure: cause => this.doneHalt(cause),
+      onSuccess: value => this.doneSucceed(value)
+    }));
+    this._activeSubexecutor = undefined;
+    return state;
+  }
+  applyUpstreamPullStrategy(upstreamFinished, queue, strategy) {
+    switch (strategy._tag) {
+      case OP_PULL_AFTER_NEXT:
+        {
+          const shouldPrepend = !upstreamFinished || queue.some(subexecutor => subexecutor !== undefined);
+          return [strategy.emitSeparator, shouldPrepend ? [undefined, ...queue] : queue];
+        }
+      case OP_PULL_AFTER_ALL_ENQUEUED:
+        {
+          const shouldEnqueue = !upstreamFinished || queue.some(subexecutor => subexecutor !== undefined);
+          return [strategy.emitSeparator, shouldEnqueue ? [...queue, undefined] : queue];
+        }
+    }
+  }
+  pullFromChild(childExecutor, parentSubexecutor, onEmitted, subexecutor) {
+    return Read(childExecutor, assets.identity, emitted => {
+      const childExecutorDecision = onEmitted(emitted);
+      switch (childExecutorDecision._tag) {
+        case OP_CONTINUE:
+          {
+            break;
+          }
+        case OP_CLOSE:
+          {
+            this.finishWithDoneValue(childExecutor, parentSubexecutor, childExecutorDecision.value);
+            break;
+          }
+        case OP_YIELD:
+          {
+            const modifiedParent = parentSubexecutor.enqueuePullFromChild(subexecutor);
+            this.replaceSubexecutor(modifiedParent);
+            break;
+          }
+      }
+      this._activeSubexecutor = new Emit(emitted, this._activeSubexecutor);
+      return undefined;
+    }, icons.match({
+      onFailure: cause => {
+        const state = this.handleSubexecutorFailure(childExecutor, parentSubexecutor, cause);
+        return state === undefined ? undefined : effectOrUndefinedIgnored(state);
+      },
+      onSuccess: doneValue => {
+        this.finishWithDoneValue(childExecutor, parentSubexecutor, doneValue);
+        return undefined;
+      }
+    }));
+  }
+  finishWithDoneValue(childExecutor, parentSubexecutor, doneValue) {
+    const subexecutor = parentSubexecutor;
+    switch (subexecutor._tag) {
+      case OP_PULL_FROM_UPSTREAM:
+        {
+          const modifiedParent = new PullFromUpstream(subexecutor.upstreamExecutor, subexecutor.createChild, subexecutor.lastDone !== undefined ? subexecutor.combineChildResults(subexecutor.lastDone, doneValue) : doneValue, subexecutor.activeChildExecutors, subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull, subexecutor.onEmit);
+          this._closeLastSubstream = childExecutor.close(icons.succeed(doneValue));
+          this.replaceSubexecutor(modifiedParent);
+          break;
+        }
+      case OP_DRAIN_CHILD_EXECUTORS:
+        {
+          const modifiedParent = new DrainChildExecutors(subexecutor.upstreamExecutor, subexecutor.lastDone !== undefined ? subexecutor.combineChildResults(subexecutor.lastDone, doneValue) : doneValue, subexecutor.activeChildExecutors, subexecutor.upstreamDone, subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull);
+          this._closeLastSubstream = childExecutor.close(icons.succeed(doneValue));
+          this.replaceSubexecutor(modifiedParent);
+          break;
+        }
+    }
+  }
+  handleSubexecutorFailure(childExecutor, parentSubexecutor, cause) {
+    return this.finishSubexecutorWithCloseEffect(icons.failCause(cause), exit => parentSubexecutor.close(exit), exit => childExecutor.close(exit));
+  }
+  pullFromUpstream(subexecutor) {
+    if (subexecutor.activeChildExecutors.length === 0) {
+      return this.performPullFromUpstream(subexecutor);
+    }
+    const activeChild = subexecutor.activeChildExecutors[0];
+    const parentSubexecutor = new PullFromUpstream(subexecutor.upstreamExecutor, subexecutor.createChild, subexecutor.lastDone, subexecutor.activeChildExecutors.slice(1), subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull, subexecutor.onEmit);
+    if (activeChild === undefined) {
+      return this.performPullFromUpstream(parentSubexecutor);
+    }
+    this.replaceSubexecutor(new PullFromChild(activeChild.childExecutor, parentSubexecutor, activeChild.onEmit));
+    return undefined;
+  }
+  performPullFromUpstream(subexecutor) {
+    return Read(subexecutor.upstreamExecutor, effect => {
+      const closeLastSubstream = this._closeLastSubstream === undefined ? assets._void : this._closeLastSubstream;
+      this._closeLastSubstream = undefined;
+      return assets.pipe(this._executeCloseLastSubstream(closeLastSubstream), assets.zipRight$1(effect));
+    }, emitted => {
+      if (this._closeLastSubstream !== undefined) {
+        const closeLastSubstream = this._closeLastSubstream;
+        this._closeLastSubstream = undefined;
+        return assets.pipe(this._executeCloseLastSubstream(closeLastSubstream), assets.map$2(() => {
+          const childExecutor = new ChannelExecutor(subexecutor.createChild(emitted), this._providedEnv, this._executeCloseLastSubstream);
+          childExecutor._input = this._input;
+          const [emitSeparator, updatedChildExecutors] = this.applyUpstreamPullStrategy(false, subexecutor.activeChildExecutors, subexecutor.onPull(Pulled(emitted)));
+          this._activeSubexecutor = new PullFromChild(childExecutor, new PullFromUpstream(subexecutor.upstreamExecutor, subexecutor.createChild, subexecutor.lastDone, updatedChildExecutors, subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull, subexecutor.onEmit), subexecutor.onEmit);
+          if (assets.isSome(emitSeparator)) {
+            this._activeSubexecutor = new Emit(emitSeparator.value, this._activeSubexecutor);
+          }
+          return undefined;
+        }));
+      }
+      const childExecutor = new ChannelExecutor(subexecutor.createChild(emitted), this._providedEnv, this._executeCloseLastSubstream);
+      childExecutor._input = this._input;
+      const [emitSeparator, updatedChildExecutors] = this.applyUpstreamPullStrategy(false, subexecutor.activeChildExecutors, subexecutor.onPull(Pulled(emitted)));
+      this._activeSubexecutor = new PullFromChild(childExecutor, new PullFromUpstream(subexecutor.upstreamExecutor, subexecutor.createChild, subexecutor.lastDone, updatedChildExecutors, subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull, subexecutor.onEmit), subexecutor.onEmit);
+      if (assets.isSome(emitSeparator)) {
+        this._activeSubexecutor = new Emit(emitSeparator.value, this._activeSubexecutor);
+      }
+      return undefined;
+    }, exit => {
+      if (subexecutor.activeChildExecutors.some(subexecutor => subexecutor !== undefined)) {
+        const drain = new DrainChildExecutors(subexecutor.upstreamExecutor, subexecutor.lastDone, [undefined, ...subexecutor.activeChildExecutors], subexecutor.upstreamExecutor.getDone(), subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull);
+        if (this._closeLastSubstream !== undefined) {
+          const closeLastSubstream = this._closeLastSubstream;
+          this._closeLastSubstream = undefined;
+          return assets.pipe(this._executeCloseLastSubstream(closeLastSubstream), assets.map$2(() => this.replaceSubexecutor(drain)));
+        }
+        this.replaceSubexecutor(drain);
+        return undefined;
+      }
+      const closeLastSubstream = this._closeLastSubstream;
+      const state = this.finishSubexecutorWithCloseEffect(assets.pipe(exit, icons.map(a => subexecutor.combineWithChildResult(subexecutor.lastDone, a))), () => closeLastSubstream, exit => subexecutor.upstreamExecutor.close(exit));
+      return state === undefined ? undefined :
+      // NOTE: assuming finalizers cannot fail
+      effectOrUndefinedIgnored(state);
+    });
+  }
+  drainChildExecutors(subexecutor) {
+    if (subexecutor.activeChildExecutors.length === 0) {
+      const lastClose = this._closeLastSubstream;
+      if (lastClose !== undefined) {
+        this.addFinalizer(() => assets.succeed$1(lastClose));
+      }
+      return this.finishSubexecutorWithCloseEffect(subexecutor.upstreamDone, () => lastClose, exit => subexecutor.upstreamExecutor.close(exit));
+    }
+    const activeChild = subexecutor.activeChildExecutors[0];
+    const rest = subexecutor.activeChildExecutors.slice(1);
+    if (activeChild === undefined) {
+      const [emitSeparator, remainingExecutors] = this.applyUpstreamPullStrategy(true, rest, subexecutor.onPull(NoUpstream(rest.reduce((n, curr) => curr !== undefined ? n + 1 : n, 0))));
+      this.replaceSubexecutor(new DrainChildExecutors(subexecutor.upstreamExecutor, subexecutor.lastDone, remainingExecutors, subexecutor.upstreamDone, subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull));
+      if (assets.isSome(emitSeparator)) {
+        this._emitted = emitSeparator.value;
+        return Emit$1();
+      }
+      return undefined;
+    }
+    const parentSubexecutor = new DrainChildExecutors(subexecutor.upstreamExecutor, subexecutor.lastDone, rest, subexecutor.upstreamDone, subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull);
+    this.replaceSubexecutor(new PullFromChild(activeChild.childExecutor, parentSubexecutor, activeChild.onEmit));
+    return undefined;
+  }
+}
+const ifNotNull = effect => effect !== undefined ? effect : assets._void;
+const runFinalizers = (finalizers, exit) => {
+  return assets.pipe(assets.forEach(finalizers, fin => assets.exit(fin(exit))), assets.map$2(exits => assets.pipe(icons.all(exits), assets.getOrElse(() => icons.void_))), assets.flatMap$1(exit => assets.suspend$1(() => exit)));
+};
+/**
+ * @internal
+ */
+const readUpstream = (r, onSuccess, onFailure) => {
+  const readStack = [r];
+  const read = () => {
+    const current = readStack.pop();
+    if (current === undefined || current.upstream === undefined) {
+      return assets.dieMessage("Unexpected end of input for channel execution");
+    }
+    const state = current.upstream.run();
+    switch (state._tag) {
+      case OP_EMIT$1:
+        {
+          const emitEffect = current.onEmit(current.upstream.getEmit());
+          if (readStack.length === 0) {
+            if (emitEffect === undefined) {
+              return assets.suspend$1(onSuccess);
+            }
+            return assets.pipe(emitEffect, assets.matchCauseEffect({
+              onFailure,
+              onSuccess
+            }));
+          }
+          if (emitEffect === undefined) {
+            return assets.suspend$1(() => read());
+          }
+          return assets.pipe(emitEffect, assets.matchCauseEffect({
+            onFailure,
+            onSuccess: () => read()
+          }));
+        }
+      case OP_DONE$1:
+        {
+          const doneEffect = current.onDone(current.upstream.getDone());
+          if (readStack.length === 0) {
+            if (doneEffect === undefined) {
+              return assets.suspend$1(onSuccess);
+            }
+            return assets.pipe(doneEffect, assets.matchCauseEffect({
+              onFailure,
+              onSuccess
+            }));
+          }
+          if (doneEffect === undefined) {
+            return assets.suspend$1(() => read());
+          }
+          return assets.pipe(doneEffect, assets.matchCauseEffect({
+            onFailure,
+            onSuccess: () => read()
+          }));
+        }
+      case OP_FROM_EFFECT:
+        {
+          readStack.push(current);
+          return assets.pipe(current.onEffect(state.effect), assets.catchAllCause(cause => assets.suspend$1(() => {
+            const doneEffect = current.onDone(icons.failCause(cause));
+            return doneEffect === undefined ? assets._void : doneEffect;
+          })), assets.matchCauseEffect({
+            onFailure,
+            onSuccess: () => read()
+          }));
+        }
+      case OP_READ:
+        {
+          readStack.push(current);
+          readStack.push(state);
+          return assets.suspend$1(() => read());
+        }
+    }
+  };
+  return read();
+};
+/** @internal */
+const runIn = /*#__PURE__*/assets.dual(2, (self, scope) => {
+  const run = (channelDeferred, scopeDeferred, scope) => assets.acquireUseRelease(assets.sync$1(() => new ChannelExecutor(self, void 0, assets.identity)), exec => assets.suspend$1(() => runScopedInterpret(exec.run(), exec).pipe(assets.intoDeferred(channelDeferred), assets.zipRight$1(icons._await(channelDeferred)), assets.zipLeft(icons._await(scopeDeferred)))), (exec, exit) => {
+    const finalize = exec.close(exit);
+    if (finalize === undefined) {
+      return assets._void;
+    }
+    return assets.tapErrorCause(finalize, cause => assets.addFinalizer(scope, assets.failCause(cause)));
+  });
+  return assets.uninterruptibleMask(restore => assets.all([assets.fork(scope, assets.sequential), icons.make(), icons.make()]).pipe(assets.flatMap$1(([child, channelDeferred, scopeDeferred]) => restore(run(channelDeferred, scopeDeferred, child)).pipe(assets.forkIn(scope), assets.flatMap$1(fiber => scope.addFinalizer(exit => {
+    const interruptors$1 = icons.isFailure(exit) ? interruptors(exit.cause) : undefined;
+    return icons.isDone(channelDeferred).pipe(assets.flatMap$1(isDone => isDone ? icons.succeed$1(scopeDeferred, void 0).pipe(assets.zipRight$1(_await(fiber)), assets.zipRight$1(inheritAll(fiber))) : icons.succeed$1(scopeDeferred, void 0).pipe(assets.zipRight$1(interruptors$1 && assets.size(interruptors$1) > 0 ? interruptAs(fiber, assets.combineAll(interruptors$1)) : interrupt(fiber)), assets.zipRight$1(inheritAll(fiber)))));
+  }).pipe(assets.zipRight$1(restore(icons._await(channelDeferred)))))))));
+});
+/** @internal */
+const runScopedInterpret = (channelState, exec) => {
+  const op = channelState;
+  switch (op._tag) {
+    case OP_FROM_EFFECT:
+      {
+        return assets.pipe(op.effect, assets.flatMap$1(() => runScopedInterpret(exec.run(), exec)));
+      }
+    case OP_EMIT$1:
+      {
+        // Can't really happen because Out <:< Nothing. So just skip ahead.
+        return runScopedInterpret(exec.run(), exec);
+      }
+    case OP_DONE$1:
+      {
+        return assets.suspend$1(() => exec.getDone());
+      }
+    case OP_READ:
+      {
+        return readUpstream(op, () => runScopedInterpret(exec.run(), exec), assets.failCause);
+      }
+  }
+};
+
+/** @internal */
+const OP_DONE = "Done";
+/** @internal */
+const OP_AWAIT = "Await";
+
+/** @internal */
+const MergeDecisionSymbolKey = "effect/ChannelMergeDecision";
+/** @internal */
+const MergeDecisionTypeId = /*#__PURE__*/Symbol.for(MergeDecisionSymbolKey);
+/** @internal */
+const proto$2 = {
+  [MergeDecisionTypeId]: {
+    _R: _ => _,
+    _E0: _ => _,
+    _Z0: _ => _,
+    _E: _ => _,
+    _Z: _ => _
+  }
+};
+/** @internal */
+const Await = f => {
+  const op = Object.create(proto$2);
+  op._tag = OP_AWAIT;
+  op.f = f;
+  return op;
+};
+
+/** @internal */
+const OP_BOTH_RUNNING = "BothRunning";
+/** @internal */
+const OP_LEFT_DONE = "LeftDone";
+/** @internal */
+const OP_RIGHT_DONE = "RightDone";
+
+/** @internal */
+const MergeStateSymbolKey = "effect/ChannelMergeState";
+/** @internal */
+const MergeStateTypeId = /*#__PURE__*/Symbol.for(MergeStateSymbolKey);
+/** @internal */
+const proto$1 = {
+  [MergeStateTypeId]: MergeStateTypeId
+};
+/** @internal */
+const BothRunning = (left, right) => {
+  const op = Object.create(proto$1);
+  op._tag = OP_BOTH_RUNNING;
+  op.left = left;
+  op.right = right;
+  return op;
+};
+/** @internal */
+const LeftDone = f => {
+  const op = Object.create(proto$1);
+  op._tag = OP_LEFT_DONE;
+  op.f = f;
+  return op;
+};
+/** @internal */
+const RightDone = f => {
+  const op = Object.create(proto$1);
+  op._tag = OP_RIGHT_DONE;
+  op.f = f;
+  return op;
+};
+
+/** @internal */
+const OP_BACK_PRESSURE = "BackPressure";
+/** @internal */
+const OP_BUFFER_SLIDING = "BufferSliding";
+
+/** @internal */
+const MergeStrategySymbolKey = "effect/ChannelMergeStrategy";
+/** @internal */
+const MergeStrategyTypeId = /*#__PURE__*/Symbol.for(MergeStrategySymbolKey);
+/** @internal */
+const proto = {
+  [MergeStrategyTypeId]: MergeStrategyTypeId
+};
+/** @internal */
+const BackPressure = _ => {
+  const op = Object.create(proto);
+  op._tag = OP_BACK_PRESSURE;
+  return op;
+};
+/** @internal */
+const BufferSliding = _ => {
+  const op = Object.create(proto);
+  op._tag = OP_BUFFER_SLIDING;
+  return op;
+};
+/** @internal */
+const match = /*#__PURE__*/assets.dual(2, (self, {
+  onBackPressure,
+  onBufferSliding
+}) => {
+  switch (self._tag) {
+    case OP_BACK_PRESSURE:
+      {
+        return onBackPressure();
+      }
+    case OP_BUFFER_SLIDING:
+      {
+        return onBufferSliding();
+      }
+  }
+});
+
+/** @internal */
+const OP_STATE_EMPTY = "Empty";
+/** @internal */
+const OP_STATE_EMIT = "Emit";
+/** @internal */
+const OP_STATE_ERROR = "Error";
+/** @internal */
+const OP_STATE_DONE = "Done";
+/** @internal */
+const stateEmpty = notifyProducer => ({
+  _tag: OP_STATE_EMPTY,
+  notifyProducer
+});
+/** @internal */
+const stateEmit = notifyConsumers => ({
+  _tag: OP_STATE_EMIT,
+  notifyConsumers
+});
+/** @internal */
+const stateError = cause => ({
+  _tag: OP_STATE_ERROR,
+  cause
+});
+/** @internal */
+const stateDone = done => ({
+  _tag: OP_STATE_DONE,
+  done
+});
+/** @internal */
+class SingleProducerAsyncInputImpl {
+  ref;
+  constructor(ref) {
+    this.ref = ref;
+  }
+  awaitRead() {
+    return assets.flatten(modify(this.ref, state => state._tag === OP_STATE_EMPTY ? [icons._await(state.notifyProducer), state] : [assets._void, state]));
+  }
+  get close() {
+    return assets.fiberIdWith(fiberId => this.error(interrupt$1(fiberId)));
+  }
+  done(value) {
+    return assets.flatten(modify(this.ref, state => {
+      switch (state._tag) {
+        case OP_STATE_EMPTY:
+          {
+            return [icons._await(state.notifyProducer), state];
+          }
+        case OP_STATE_EMIT:
+          {
+            return [assets.forEach(state.notifyConsumers, deferred => icons.succeed$1(deferred, assets.left(value)), {
+              discard: true
+            }), stateDone(value)];
+          }
+        case OP_STATE_ERROR:
+          {
+            return [assets.interrupt$2, state];
+          }
+        case OP_STATE_DONE:
+          {
+            return [assets.interrupt$2, state];
+          }
+      }
+    }));
+  }
+  emit(element) {
+    return assets.flatMap$1(icons.make(), deferred => assets.flatten(modify(this.ref, state => {
+      switch (state._tag) {
+        case OP_STATE_EMPTY:
+          {
+            return [icons._await(state.notifyProducer), state];
+          }
+        case OP_STATE_EMIT:
+          {
+            const notifyConsumer = state.notifyConsumers[0];
+            const notifyConsumers = state.notifyConsumers.slice(1);
+            if (notifyConsumer !== undefined) {
+              return [icons.succeed$1(notifyConsumer, assets.right(element)), notifyConsumers.length === 0 ? stateEmpty(deferred) : stateEmit(notifyConsumers)];
+            }
+            throw new Error("Bug: Channel.SingleProducerAsyncInput.emit - Queue was empty! please report an issue at https://github.com/Effect-TS/effect/issues");
+          }
+        case OP_STATE_ERROR:
+          {
+            return [assets.interrupt$2, state];
+          }
+        case OP_STATE_DONE:
+          {
+            return [assets.interrupt$2, state];
+          }
+      }
+    })));
+  }
+  error(cause) {
+    return assets.flatten(modify(this.ref, state => {
+      switch (state._tag) {
+        case OP_STATE_EMPTY:
+          {
+            return [icons._await(state.notifyProducer), state];
+          }
+        case OP_STATE_EMIT:
+          {
+            return [assets.forEach(state.notifyConsumers, deferred => icons.failCause$1(deferred, cause), {
+              discard: true
+            }), stateError(cause)];
+          }
+        case OP_STATE_ERROR:
+          {
+            return [assets.interrupt$2, state];
+          }
+        case OP_STATE_DONE:
+          {
+            return [assets.interrupt$2, state];
+          }
+      }
+    }));
+  }
+  get take() {
+    return this.takeWith(cause => icons.failCause(map$2(cause, assets.left)), elem => icons.succeed(elem), done => icons.fail(assets.right(done)));
+  }
+  takeWith(onError, onElement, onDone) {
+    return assets.flatMap$1(icons.make(), deferred => assets.flatten(modify(this.ref, state => {
+      switch (state._tag) {
+        case OP_STATE_EMPTY:
+          {
+            return [assets.zipRight$1(icons.succeed$1(state.notifyProducer, void 0), assets.matchCause(icons._await(deferred), {
+              onFailure: onError,
+              onSuccess: assets.match({
+                onLeft: onDone,
+                onRight: onElement
+              })
+            })), stateEmit([deferred])];
+          }
+        case OP_STATE_EMIT:
+          {
+            return [assets.matchCause(icons._await(deferred), {
+              onFailure: onError,
+              onSuccess: assets.match({
+                onLeft: onDone,
+                onRight: onElement
+              })
+            }), stateEmit([...state.notifyConsumers, deferred])];
+          }
+        case OP_STATE_ERROR:
+          {
+            return [assets.succeed$1(onError(state.cause)), state];
+          }
+        case OP_STATE_DONE:
+          {
+            return [assets.succeed$1(onDone(state.done)), state];
+          }
+      }
+    })));
+  }
+}
+/** @internal */
+const make$1 = () => assets.pipe(icons.make(), assets.flatMap$1(deferred => make$3(stateEmpty(deferred))), assets.map$2(ref => new SingleProducerAsyncInputImpl(ref)));
+
+/** @internal */
+const concatMap = /*#__PURE__*/assets.dual(2, (self, f) => concatMapWith(self, f, () => void 0, () => void 0));
+/** @internal */
+const drain$1 = self => {
+  const drainer = readWithCause({
+    onInput: () => drainer,
+    onFailure: failCause$2,
+    onDone: succeed
+  });
+  return pipeTo(self, drainer);
+};
+/** @internal */
+const ensuring$1 = /*#__PURE__*/assets.dual(2, (self, finalizer) => ensuringWith(self, () => finalizer));
+/** @internal */
+const flatten$1 = self => flatMap$1(self, assets.identity);
+/** @internal */
+const fromInput = input => unwrap(input.takeWith(failCause$2, elem => flatMap$1(write(elem), () => fromInput(input)), succeed));
+/** @internal */
+const identityChannel = () => readWith({
+  onInput: input => flatMap$1(write(input), () => identityChannel()),
+  onFailure: fail,
+  onDone: succeedNow
+});
+/** @internal */
+const map$1 = /*#__PURE__*/assets.dual(2, (self, f) => flatMap$1(self, a => sync(() => f(a))));
+/** @internal */
+const mapOut = /*#__PURE__*/assets.dual(2, (self, f) => {
+  const reader = readWith({
+    onInput: outElem => flatMap$1(write(f(outElem)), () => reader),
+    onFailure: fail,
+    onDone: succeedNow
+  });
+  return pipeTo(self, reader);
+});
+/** @internal */
+const mapOutEffectPar = /*#__PURE__*/assets.dual(3, (self, f, n) => unwrapScopedWith$1(scope => assets.gen(function* () {
+  const input = yield* make$1();
+  const queueReader = fromInput(input);
+  const queue = yield* bounded(n);
+  yield* assets.addFinalizer(scope, shutdown(queue));
+  const errorSignal = yield* icons.make();
+  const withPermits = n === Number.POSITIVE_INFINITY ? _ => assets.identity : (yield* assets.makeSemaphore(n)).withPermits;
+  const pull = yield* queueReader.pipe(pipeTo(self), toPullIn(scope));
+  yield* pull.pipe(assets.matchCauseEffect({
+    onFailure: cause => offer(queue, assets.failCause(cause)),
+    onSuccess: assets.match({
+      onLeft: outDone => assets.zipRight$1(assets.interruptible(withPermits(n)(assets._void)), assets.asVoid$1(offer(queue, assets.succeed$1(assets.left(outDone))))),
+      onRight: outElem => assets.gen(function* () {
+        const deferred = yield* icons.make();
+        const latch = yield* icons.make();
+        yield* offer(queue, assets.map$2(icons._await(deferred), assets.right));
+        yield* icons.succeed$1(latch, void 0).pipe(assets.zipRight$1(assets.uninterruptibleMask(restore => assets.exit(restore(icons._await(errorSignal))).pipe(assets.raceFirst(assets.exit(restore(f(outElem)))), assets.flatMap$1(assets.identity))).pipe(assets.tapErrorCause(cause => icons.failCause$1(errorSignal, cause)), assets.intoDeferred(deferred))), withPermits(1), assets.forkIn(scope));
+        yield* icons._await(latch);
+      })
+    })
+  }), assets.forever, assets.interruptible, assets.forkIn(scope));
+  const consumer = unwrap(assets.matchCause(assets.flatten(take(queue)), {
+    onFailure: failCause$2,
+    onSuccess: assets.match({
+      onLeft: succeedNow,
+      onRight: outElem => flatMap$1(write(outElem), () => consumer)
+    })
+  }));
+  return embedInput(consumer, input);
+})));
+/** @internal */
+const mergeAll = options => {
+  return channels => mergeAllWith(options)(channels, assets.constVoid);
+};
+/** @internal */
+const mergeAllWith = ({
+  bufferSize = 16,
+  concurrency,
+  mergeStrategy = BackPressure()
+}) => (channels, f) => unwrapScopedWith$1(scope => assets.gen(function* () {
+  const concurrencyN = concurrency === "unbounded" ? Number.MAX_SAFE_INTEGER : concurrency;
+  const input = yield* make$1();
+  const queueReader = fromInput(input);
+  const queue = yield* bounded(bufferSize);
+  yield* assets.addFinalizer(scope, shutdown(queue));
+  const cancelers = yield* unbounded();
+  yield* assets.addFinalizer(scope, shutdown(cancelers));
+  const lastDone = yield* make$3(assets.none());
+  const errorSignal = yield* icons.make();
+  const withPermits = (yield* assets.makeSemaphore(concurrencyN)).withPermits;
+  const pull = yield* toPullIn(pipeTo(queueReader, channels), scope);
+  function evaluatePull(pull) {
+    return pull.pipe(assets.flatMap$1(assets.match({
+      onLeft: done => assets.succeed$1(assets.some(done)),
+      onRight: outElem => assets.as(offer(queue, assets.succeed$1(assets.right(outElem))), assets.none())
+    })), assets.repeat({
+      until: _ => assets.isSome(_)
+    }), assets.flatMap$1(outDone => update(lastDone, assets.match$1({
+      onNone: () => assets.some(outDone.value),
+      onSome: lastDone => assets.some(f(lastDone, outDone.value))
+    }))), assets.catchAllCause(cause => isInterrupted(cause) ? assets.failCause(cause) : offer(queue, assets.failCause(cause)).pipe(assets.zipRight$1(icons.succeed$1(errorSignal, void 0)), assets.asVoid$1)));
+  }
+  yield* pull.pipe(assets.matchCauseEffect({
+    onFailure: cause => offer(queue, assets.failCause(cause)).pipe(assets.zipRight$1(assets.succeed$1(false))),
+    onSuccess: assets.match({
+      onLeft: outDone => assets.raceWith(assets.interruptible(icons._await(errorSignal)), assets.interruptible(withPermits(concurrencyN)(assets._void)), {
+        onSelfDone: (_, permitAcquisition) => assets.as(interrupt(permitAcquisition), false),
+        onOtherDone: (_, failureAwait) => assets.zipRight$1(interrupt(failureAwait), get(lastDone).pipe(assets.flatMap$1(assets.match$1({
+          onNone: () => offer(queue, assets.succeed$1(assets.left(outDone))),
+          onSome: lastDone => offer(queue, assets.succeed$1(assets.left(f(lastDone, outDone))))
+        })), assets.as(false)))
+      }),
+      onRight: channel => match(mergeStrategy, {
+        onBackPressure: () => assets.gen(function* () {
+          const latch = yield* icons.make();
+          const raceEffects = assets.scopedWith(scope => toPullIn(pipeTo(queueReader, channel), scope).pipe(assets.flatMap$1(pull => assets.race(assets.exit(evaluatePull(pull)), assets.exit(assets.interruptible(icons._await(errorSignal))))), assets.flatMap$1(assets.identity)));
+          yield* icons.succeed$1(latch, void 0).pipe(assets.zipRight$1(raceEffects), withPermits(1), assets.forkIn(scope));
+          yield* icons._await(latch);
+          const errored = yield* icons.isDone(errorSignal);
+          return !errored;
+        }),
+        onBufferSliding: () => assets.gen(function* () {
+          const canceler = yield* icons.make();
+          const latch = yield* icons.make();
+          const size$1 = yield* size(cancelers);
+          yield* take(cancelers).pipe(assets.flatMap$1(canceler => icons.succeed$1(canceler, void 0)), assets.when(() => size$1 >= concurrencyN));
+          yield* offer(cancelers, canceler);
+          const raceEffects = assets.scopedWith(scope => toPullIn(pipeTo(queueReader, channel), scope).pipe(assets.flatMap$1(pull => assets.exit(evaluatePull(pull)).pipe(assets.race(assets.exit(assets.interruptible(icons._await(errorSignal)))), assets.race(assets.exit(assets.interruptible(icons._await(canceler)))))), assets.flatMap$1(assets.identity)));
+          yield* icons.succeed$1(latch, void 0).pipe(assets.zipRight$1(raceEffects), withPermits(1), assets.forkIn(scope));
+          yield* icons._await(latch);
+          const errored = yield* icons.isDone(errorSignal);
+          return !errored;
+        })
+      })
+    })
+  }), assets.repeat({
+    while: _ => _
+  }), assets.forkIn(scope));
+  const consumer = assets.pipe(take(queue), assets.flatten, assets.matchCause({
+    onFailure: failCause$2,
+    onSuccess: assets.match({
+      onLeft: succeedNow,
+      onRight: outElem => flatMap$1(write(outElem), () => consumer)
+    })
+  }), unwrap);
+  return embedInput(consumer, input);
+}));
+/** @internal */
+const mergeMap = /*#__PURE__*/assets.dual(3, (self, f, options) => mergeAll(options)(mapOut(self, f)));
+/** @internal */
+const mergeWith = /*#__PURE__*/assets.dual(2, (self, options) => {
+  function merge(scope) {
+    return assets.gen(function* () {
+      const input = yield* make$1();
+      const queueReader = fromInput(input);
+      const pullL = yield* toPullIn(pipeTo(queueReader, self), scope);
+      const pullR = yield* toPullIn(pipeTo(queueReader, options.other), scope);
+      function handleSide(exit, fiber, pull) {
+        return (done, both, single) => {
+          function onDecision(decision) {
+            const op = decision;
+            if (op._tag === OP_DONE) {
+              return assets.succeed$1(fromEffect$3(assets.zipRight$1(interrupt(fiber), op.effect)));
+            }
+            return assets.map$2(_await(fiber), icons.match({
+              onFailure: cause => fromEffect$3(op.f(icons.failCause(cause))),
+              onSuccess: assets.match({
+                onLeft: done => fromEffect$3(op.f(icons.succeed(done))),
+                onRight: elem => zipRight(write(elem), go(single(op.f)))
+              })
+            }));
+          }
+          return icons.match(exit, {
+            onFailure: cause => onDecision(done(icons.failCause(cause))),
+            onSuccess: assets.match({
+              onLeft: z => onDecision(done(icons.succeed(z))),
+              onRight: elem => assets.succeed$1(flatMap$1(write(elem), () => flatMap$1(fromEffect$3(assets.forkIn(assets.interruptible(pull), scope)), leftFiber => go(both(leftFiber, fiber)))))
+            })
+          });
+        };
+      }
+      function go(state) {
+        switch (state._tag) {
+          case OP_BOTH_RUNNING:
+            {
+              const leftJoin = assets.interruptible(join(state.left));
+              const rightJoin = assets.interruptible(join(state.right));
+              return unwrap(assets.raceWith(leftJoin, rightJoin, {
+                onSelfDone: (leftExit, rf) => assets.zipRight$1(interrupt(rf), handleSide(leftExit, state.right, pullL)(options.onSelfDone, BothRunning, f => LeftDone(f))),
+                onOtherDone: (rightExit, lf) => assets.zipRight$1(interrupt(lf), handleSide(rightExit, state.left, pullR)(options.onOtherDone, (left, right) => BothRunning(right, left), f => RightDone(f)))
+              }));
+            }
+          case OP_LEFT_DONE:
+            {
+              return unwrap(assets.map$2(assets.exit(pullR), icons.match({
+                onFailure: cause => fromEffect$3(state.f(icons.failCause(cause))),
+                onSuccess: assets.match({
+                  onLeft: done => fromEffect$3(state.f(icons.succeed(done))),
+                  onRight: elem => flatMap$1(write(elem), () => go(LeftDone(state.f)))
+                })
+              })));
+            }
+          case OP_RIGHT_DONE:
+            {
+              return unwrap(assets.map$2(assets.exit(pullL), icons.match({
+                onFailure: cause => fromEffect$3(state.f(icons.failCause(cause))),
+                onSuccess: assets.match({
+                  onLeft: done => fromEffect$3(state.f(icons.succeed(done))),
+                  onRight: elem => flatMap$1(write(elem), () => go(RightDone(state.f)))
+                })
+              })));
+            }
+        }
+      }
+      return fromEffect$3(assets.withFiberRuntime$1(parent => {
+        const inherit = assets.withFiberRuntime$1(state => {
+          state.transferChildren(parent.scope());
+          return assets._void;
+        });
+        const leftFiber = assets.interruptible(pullL).pipe(assets.ensuring(inherit), assets.forkIn(scope));
+        const rightFiber = assets.interruptible(pullR).pipe(assets.ensuring(inherit), assets.forkIn(scope));
+        return assets.zipWith(leftFiber, rightFiber, (left, right) => BothRunning(left, right));
+      })).pipe(flatMap$1(go), embedInput(input));
+    });
+  }
+  return unwrapScopedWith$1(merge);
+});
+/** @internal */
+const pipeToOrFail = /*#__PURE__*/assets.dual(2, (self, that) => suspend$1(() => {
+  let channelException = undefined;
+  const reader = readWith({
+    onInput: outElem => flatMap$1(write(outElem), () => reader),
+    onFailure: outErr => {
+      channelException = ChannelException(outErr);
+      return failCause$2(die(channelException));
+    },
+    onDone: succeedNow
+  });
+  const writer = readWithCause({
+    onInput: outElem => assets.pipe(write(outElem), flatMap$1(() => writer)),
+    onFailure: cause => isDieType(cause) && isChannelException(cause.defect) && assets.equals(cause.defect, channelException) ? fail(cause.defect.error) : failCause$2(cause),
+    onDone: succeedNow
+  });
+  return pipeTo(pipeTo(pipeTo(self, reader), that), writer);
+}));
+/** @internal */
+const run$1 = self => assets.scopedWith(scope => runIn(self, scope));
+/** @internal */
+const runDrain$2 = self => run$1(drain$1(self));
+/** @internal */
+const scoped = effect => unwrap(assets.uninterruptibleMask(restore => assets.map$2(assets.make$2(), scope => acquireReleaseOut(assets.tapErrorCause(restore(assets.extend(effect, scope)), cause => assets.close(scope, icons.failCause(cause))), (_, exit) => assets.close(scope, exit)))));
+/** @internal */
+const scopedWith$1 = f => unwrapScoped(assets.map$2(assets.scope, scope => flatMap$1(fromEffect$3(f(scope)), write)));
+/** @internal */
+const toPullIn = /*#__PURE__*/assets.dual(2, (self, scope) => assets.zip(assets.sync$1(() => new ChannelExecutor(self, void 0, assets.identity)), assets.runtime()).pipe(assets.tap(([executor, runtime]) => assets.addFinalizerExit(scope, exit => {
+  const finalizer = executor.close(exit);
+  return finalizer !== undefined ? assets.provide(finalizer, runtime) : assets._void;
+})), assets.uninterruptible$1, assets.map$2(([executor]) => assets.suspend$1(() => interpretToPull(executor.run(), executor)))));
+/** @internal */
+const interpretToPull = (channelState, exec) => {
+  const state = channelState;
+  switch (state._tag) {
+    case OP_DONE$1:
+      {
+        return icons.match(exec.getDone(), {
+          onFailure: assets.failCause,
+          onSuccess: done => assets.succeed$1(assets.left(done))
+        });
+      }
+    case OP_EMIT$1:
+      {
+        return assets.succeed$1(assets.right(exec.getEmit()));
+      }
+    case OP_FROM_EFFECT:
+      {
+        return assets.pipe(state.effect, assets.flatMap$1(() => interpretToPull(exec.run(), exec)));
+      }
+    case OP_READ:
+      {
+        return readUpstream(state, () => interpretToPull(exec.run(), exec), cause => assets.failCause(cause));
+      }
+  }
+};
+/** @internal */
+const unwrap = channel => flatten$1(fromEffect$3(channel));
+/** @internal */
+const unwrapScoped = self => concatAllWith(scoped(self), (d, _) => d, (d, _) => d);
+/** @internal */
+const unwrapScopedWith$1 = f => concatAllWith(scopedWith$1(f), (d, _) => d, (d, _) => d);
+/** @internal */
+const writeChunk = outs => writeChunkWriter(0, outs.length, outs);
+/** @internal */
+const writeChunkWriter = (idx, len, chunk) => {
+  return idx === len ? void_ : assets.pipe(write(assets.pipe(chunk, assets.unsafeGet(idx))), flatMap$1(() => writeChunkWriter(idx + 1, len, chunk)));
+};
+/** @internal */
+const zip = /*#__PURE__*/assets.dual(args => isChannel(args[1]), (self, that, options) => options?.concurrent ? mergeWith(self, {
+  other: that,
+  onSelfDone: exit1 => Await(exit2 => assets.suspend$1(() => icons.zip(exit1, exit2))),
+  onOtherDone: exit2 => Await(exit1 => assets.suspend$1(() => icons.zip(exit1, exit2)))
+}) : flatMap$1(self, a => map$1(that, b => [a, b])));
+/** @internal */
+const zipRight = /*#__PURE__*/assets.dual(args => isChannel(args[1]), (self, that, options) => options?.concurrent ? map$1(zip(self, that, {
+  concurrent: true
+}), tuple => tuple[1]) : flatMap$1(self, () => that));
+/** @internal */
+const ChannelExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Channel/ChannelException");
+/** @internal */
+const ChannelException = error => ({
+  _tag: "ChannelException",
+  [ChannelExceptionTypeId]: ChannelExceptionTypeId,
+  error
+});
+/** @internal */
+const isChannelException = u => assets.hasProperty(u, ChannelExceptionTypeId);
+
+/** @internal */
+const SinkTypeId = /*#__PURE__*/Symbol.for("effect/Sink");
+const sinkVariance = {
+  /* c8 ignore next */
+  _A: _ => _,
+  /* c8 ignore next */
+  _In: _ => _,
+  /* c8 ignore next */
+  _L: _ => _,
+  /* c8 ignore next */
+  _E: _ => _,
+  /* c8 ignore next */
+  _R: _ => _
+};
+/** @internal */
+class SinkImpl {
+  channel;
+  [SinkTypeId] = sinkVariance;
+  constructor(channel) {
+    this.channel = channel;
+  }
+  pipe() {
+    return assets.pipeArguments(this, arguments);
+  }
+}
+/** @internal */
+const drain = /*#__PURE__*/new SinkImpl(/*#__PURE__*/drain$1(/*#__PURE__*/identityChannel()));
+/** @internal */
+const fromEffect$1 = effect => new SinkImpl(fromEffect$3(effect));
+/** @internal */
+const toChannel$1 = self => assets.isEffect(self) ? toChannel$1(fromEffect$1(self)) : self.channel;
+
+/** @internal */
+const TakeSymbolKey = "effect/Take";
+/** @internal */
+const TakeTypeId = /*#__PURE__*/Symbol.for(TakeSymbolKey);
+const takeVariance = {
+  /* c8 ignore next */
+  _A: _ => _,
+  /* c8 ignore next */
+  _E: _ => _
+};
+/** @internal */
+class TakeImpl {
+  exit;
+  [TakeTypeId] = takeVariance;
+  constructor(exit) {
+    this.exit = exit;
+  }
+  pipe() {
+    return assets.pipeArguments(this, arguments);
+  }
+}
+/** @internal */
+const chunk = chunk => new TakeImpl(icons.succeed(chunk));
+/** @internal */
+const end$1 = /*#__PURE__*/new TakeImpl(/*#__PURE__*/icons.fail(/*#__PURE__*/assets.none()));
+/** @internal */
+const failCause$1 = cause => new TakeImpl(icons.failCause(assets.pipe(cause, map$2(assets.some))));
+/** @internal */
+const of = value => new TakeImpl(icons.succeed(assets.of(value)));
+
+/** @internal */
+const end = () => assets.fail$1(assets.none());
+/** @internal */
+const failCause = cause => assets.mapError(assets.failCause(cause), assets.some);
+
+/** @internal */
+const StreamSymbolKey = "effect/Stream";
+/** @internal */
+const StreamTypeId = /*#__PURE__*/Symbol.for(StreamSymbolKey);
+/** @internal */
+const streamVariance = {
+  _R: _ => _,
+  _E: _ => _,
+  _A: _ => _
+};
+/** @internal */
+class StreamImpl {
+  channel;
+  [StreamTypeId] = streamVariance;
+  constructor(channel) {
+    this.channel = channel;
+  }
+  pipe() {
+    return assets.pipeArguments(this, arguments);
+  }
+}
+/** @internal */
+const isStream = u => assets.hasProperty(u, StreamTypeId) || assets.isEffect(u);
+/** @internal */
+const DefaultChunkSize = 4096;
+/** @internal */
+const ensuring = /*#__PURE__*/assets.dual(2, (self, finalizer) => new StreamImpl(assets.pipe(toChannel(self), ensuring$1(finalizer))));
+/** @internal */
+const flatMap = /*#__PURE__*/assets.dual(args => isStream(args[0]), (self, f, options) => {
+  const bufferSize = options?.bufferSize ?? 16;
+  if (options?.switch) {
+    return matchConcurrency(options?.concurrency, () => flatMapParSwitchBuffer(self, 1, bufferSize, f), n => flatMapParSwitchBuffer(self, n, bufferSize, f));
+  }
+  return matchConcurrency(options?.concurrency, () => new StreamImpl(concatMap(toChannel(self), as => assets.pipe(as, assets.map$3(a => toChannel(f(a))), assets.reduce(void_, (left, right) => assets.pipe(left, zipRight(right)))))), _ => new StreamImpl(assets.pipe(toChannel(self), concatMap(writeChunk), mergeMap(out => toChannel(f(out)), options))));
+});
+/** @internal */
+const matchConcurrency = (concurrency, sequential, bounded) => {
+  switch (concurrency) {
+    case undefined:
+      return sequential();
+    case "unbounded":
+      return bounded(Number.MAX_SAFE_INTEGER);
+    default:
+      return concurrency > 1 ? bounded(concurrency) : sequential();
+  }
+};
+const flatMapParSwitchBuffer = /*#__PURE__*/assets.dual(4, (self, n, bufferSize, f) => new StreamImpl(assets.pipe(toChannel(self), concatMap(writeChunk), mergeMap(out => toChannel(f(out)), {
+  concurrency: n,
+  mergeStrategy: BufferSliding(),
+  bufferSize
+}))));
+/** @internal */
+const flatten = /*#__PURE__*/assets.dual(args => isStream(args[0]), (self, options) => flatMap(self, assets.identity, options));
+/** @internal */
+const flattenChunks = self => {
+  const flatten = readWithCause({
+    onInput: chunks => flatMap$1(writeChunk(chunks), () => flatten),
+    onFailure: failCause$2,
+    onDone: () => void_
+  });
+  return new StreamImpl(assets.pipe(toChannel(self), pipeTo(flatten)));
+};
+/** @internal */
+const flattenExitOption = self => {
+  const processChunk = (chunk, cont) => {
+    const [toEmit, rest] = assets.pipe(chunk, assets.splitWhere(exit => !icons.isSuccess(exit)));
+    const next = assets.pipe(assets.head(rest), assets.match$1({
+      onNone: () => cont,
+      onSome: icons.match({
+        onFailure: cause => assets.match$1(flipCauseOption(cause), {
+          onNone: () => void_,
+          onSome: failCause$2
+        }),
+        onSuccess: () => void_
+      })
+    }));
+    return assets.pipe(write(assets.pipe(toEmit, assets.filterMap(exit => icons.isSuccess(exit) ? assets.some(exit.value) : assets.none()))), flatMap$1(() => next));
+  };
+  const process = readWithCause({
+    onInput: chunk => processChunk(chunk, process),
+    onFailure: cause => failCause$2(cause),
+    onDone: () => void_
+  });
+  return new StreamImpl(assets.pipe(toChannel(self), pipeTo(process)));
+};
+/** @internal */
+const flattenTake = self => flattenChunks(flattenExitOption(assets.pipe(self, map(take => take.exit))));
+/** @internal */
+const toChannel = stream => {
+  if ("channel" in stream) {
+    return stream.channel;
+  } else if (assets.isEffect(stream)) {
+    return toChannel(fromEffect(stream));
+  } else {
+    throw new TypeError(`Expected a Stream.`);
+  }
+};
+/** @internal */
+const fromEffect = effect => assets.pipe(effect, assets.mapError(assets.some), fromEffectOption);
+/** @internal */
+const fromEffectOption = effect => new StreamImpl(unwrap(assets.match$2(effect, {
+  onFailure: assets.match$1({
+    onNone: () => void_,
+    onSome: fail
+  }),
+  onSuccess: a => write(assets.of(a))
+})));
+/** @internal */
+const fromQueue$1 = (queue, options) => assets.pipe(takeBetween(queue, 1, options?.maxChunkSize ?? DefaultChunkSize), assets.catchAllCause(cause => assets.pipe(isShutdown(queue), assets.flatMap$1(isShutdown => isShutdown && isInterrupted(cause) ? end() : failCause(cause)))), repeatEffectChunkOption, options?.shutdown ? ensuring(shutdown(queue)) : assets.identity);
+/** @internal */
+const map = /*#__PURE__*/assets.dual(2, (self, f) => new StreamImpl(assets.pipe(toChannel(self), mapOut(assets.map$3(f)))));
+/** @internal */
+const mapEffectSequential = /*#__PURE__*/assets.dual(2, (self, f) => {
+  const loop = iterator => {
+    const next = iterator.next();
+    if (next.done) {
+      return readWithCause({
+        onInput: elem => loop(elem[Symbol.iterator]()),
+        onFailure: failCause$2,
+        onDone: succeed
+      });
+    } else {
+      const value = next.value;
+      return unwrap(assets.map$2(f(value), a2 => flatMap$1(write(assets.of(a2)), () => loop(iterator))));
+    }
+  };
+  return new StreamImpl(assets.pipe(toChannel(self), pipeTo(suspend$1(() => loop(assets.empty$1()[Symbol.iterator]())))));
+});
+/** @internal */
+const mapEffectPar = /*#__PURE__*/assets.dual(3, (self, n, f) => new StreamImpl(assets.pipe(toChannel(self), concatMap(writeChunk), mapOutEffectPar(f, n), mapOut(assets.of))));
+/** @internal */
+const repeatEffectChunkOption = effect => unfoldChunkEffect(effect, effect => assets.pipe(assets.map$2(effect, chunk => assets.some([chunk, effect])), assets.catchAll$1(assets.match$1({
+  onNone: () => assets.succeed$1(assets.none()),
+  onSome: assets.fail$1
+}))));
+/** @internal */
+const run = /*#__PURE__*/assets.dual(2, (self, sink) => toChannel(self).pipe(pipeToOrFail(toChannel$1(sink)), runDrain$2));
+/** @internal */
+const runDrain$1 = self => run(self, drain);
+/** @internal */
+const scopedWith = f => new StreamImpl(scopedWith$1(scope => f(scope).pipe(assets.map$2(assets.of))));
+/** @internal */
+const suspend = stream => new StreamImpl(suspend$1(() => toChannel(stream())));
+/** @internal */
+const unfoldChunkEffect = (s, f) => suspend(() => {
+  const loop = s => unwrap(assets.map$2(f(s), assets.match$1({
+    onNone: () => void_,
+    onSome: ([chunk, s]) => flatMap$1(write(chunk), () => loop(s))
+  })));
+  return new StreamImpl(loop(s));
+});
+/** @internal */
+const unwrapScopedWith = f => flatten(scopedWith(scope => f(scope)));
+
+/** @internal */
+const GroupBySymbolKey = "effect/GroupBy";
+/** @internal */
+const GroupByTypeId = /*#__PURE__*/Symbol.for(GroupBySymbolKey);
+const groupByVariance = {
+  /* c8 ignore next */
+  _R: _ => _,
+  /* c8 ignore next */
+  _E: _ => _,
+  /* c8 ignore next */
+  _K: _ => _,
+  /* c8 ignore next */
+  _V: _ => _
+};
+/** @internal */
+const isGroupBy = u => assets.hasProperty(u, GroupByTypeId);
+/** @internal */
+const evaluate = /*#__PURE__*/assets.dual(args => isGroupBy(args[0]), (self, f, options) => flatMap(self.grouped, ([key, queue]) => f(key, flattenTake(fromQueue$1(queue, {
+  shutdown: true
+}))), {
+  concurrency: "unbounded",
+  bufferSize: options?.bufferSize ?? 16
+}));
+/** @internal */
+const make = grouped => ({
+  [GroupByTypeId]: groupByVariance,
+  pipe() {
+    return assets.pipeArguments(this, arguments);
+  },
+  grouped
+});
+/** @internal */
+const mapEffectOptions = /*#__PURE__*/assets.dual(args => typeof args[0] !== "function", (self, f, options) => {
+  if (options?.key) {
+    return evaluate(groupByKey(self, options.key, {
+      bufferSize: options.bufferSize
+    }), (_, s) => mapEffectSequential(s, f));
+  }
+  return matchConcurrency(options?.concurrency, () => mapEffectSequential(self, f), n => options?.unordered ? flatMap(self, a => fromEffect(f(a)), {
+    concurrency: n
+  }) : mapEffectPar(self, n, f));
+});
+/** @internal */
+const groupByKey = /*#__PURE__*/assets.dual(args => typeof args[0] !== "function", (self, f, options) => {
+  const loop = (map, outerQueue) => readWithCause({
+    onInput: input => flatMap$1(fromEffect$3(assets.forEach(groupByIterable(input, f), ([key, values]) => {
+      const innerQueue = map.get(key);
+      if (innerQueue === undefined) {
+        return assets.pipe(bounded(options?.bufferSize ?? 16), assets.flatMap$1(innerQueue => assets.pipe(assets.sync$1(() => {
+          map.set(key, innerQueue);
+        }), assets.zipRight$1(offer(outerQueue, of([key, innerQueue]))), assets.zipRight$1(assets.pipe(offer(innerQueue, chunk(values)), assets.catchSomeCause(cause => isInterruptedOnly(cause) ? assets.some(assets._void) : assets.none()))))));
+      }
+      return assets.catchSomeCause(offer(innerQueue, chunk(values)), cause => isInterruptedOnly(cause) ? assets.some(assets._void) : assets.none());
+    }, {
+      discard: true
+    })), () => loop(map, outerQueue)),
+    onFailure: cause => fromEffect$3(offer(outerQueue, failCause$1(cause))),
+    onDone: () => fromEffect$3(assets.pipe(assets.forEach(map.entries(), ([_, innerQueue]) => assets.pipe(offer(innerQueue, end$1), assets.catchSomeCause(cause => isInterruptedOnly(cause) ? assets.some(assets._void) : assets.none())), {
+      discard: true
+    }), assets.zipRight$1(offer(outerQueue, end$1))))
+  });
+  return make(unwrapScopedWith(scope => assets.gen(function* () {
+    const map = new Map();
+    const queue = yield* unbounded();
+    yield* assets.addFinalizer(scope, shutdown(queue));
+    return yield* toChannel(self).pipe(pipeTo(loop(map, queue)), drain$1, runIn(scope), assets.forkIn(scope), assets.as(flattenTake(fromQueue$1(queue, {
+      shutdown: true
+    }))));
+  })));
+});
+/**
+ * A variant of `groupBy` that retains the insertion order of keys.
+ *
+ * @internal
+ */
+const groupByIterable = /*#__PURE__*/assets.dual(2, (iterable, f) => {
+  const builder = [];
+  const iterator = iterable[Symbol.iterator]();
+  const map = new Map();
+  let next;
+  while ((next = iterator.next()) && !next.done) {
+    const value = next.value;
+    const key = f(value);
+    if (map.has(key)) {
+      const innerBuilder = map.get(key);
+      innerBuilder.push(value);
+    } else {
+      const innerBuilder = [value];
+      builder.push([key, innerBuilder]);
+      map.set(key, innerBuilder);
+    }
+  }
+  return assets.unsafeFromArray(builder.map(tuple => [tuple[0], assets.unsafeFromArray(tuple[1])]));
+});
+
+/**
+ * Creates a stream from a queue of values
+ *
+ * **Options**
+ *
+ * - `maxChunkSize`: The maximum number of queued elements to put in one chunk in the stream
+ * - `shutdown`: If `true`, the queue will be shutdown after the stream is evaluated (defaults to `false`)
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromQueue = fromQueue$1;
+/**
+ * Maps over elements of the stream with the specified effectful function.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Random, Stream } from "effect"
+ *
+ * const stream = Stream.make(10, 20, 30).pipe(
+ *   Stream.mapEffect((n) => Random.nextIntBetween(0, n))
+ * )
+ *
+ * Effect.runPromise(Stream.runCollect(stream)).then(console.log)
+ * // Example Output: { _id: 'Chunk', values: [ 7, 19, 8 ] }
+ * ```
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapEffect = mapEffectOptions;
+/**
+ * Runs the stream only for its effects. The emitted elements are discarded.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runDrain = runDrain$1;
+
+const HeaderIntegration = class {
+    constructor(hostRef) {
+        index.registerInstance(this, hostRef);
+    }
+    activeNav;
+    activate(event) {
+        const target = event.currentTarget;
+        const navItem = target.closest('[slot="nav-primary"]');
+        if (!navItem)
+            return;
+        const navId = navItem.id;
+        if (!navId) {
+            console.warn('Nav item does not have an id:', navItem);
+            return;
+        }
+        console.log('Activating nav item:', navId);
+        this.activeNav = navId;
+    }
+    render() {
+        return (index.h(index.Host, { key: 'd36cd9202cfdea4bc684f2b17ba625fd37397616' }, index.h("lmvz-header", { key: '681f8b9fe603d98bad55bbbc7b4dbd43a3d7aff1', lmvzActiveNav: this.activeNav }, index.h("lmvz-menuitem", { key: '54a1b1d394c69e98e742e2dd53f000de028a8626', slot: "nav-primary", id: "lehrmittel", onLmvzActivation: this.activate.bind(this) }, "Lehrmittel"), index.h("lmvz-menuitem", { key: '1aa874d07f7e444433c818c97e300d0e1693fa06', slot: "nav-primary", id: "verwaltung", onLmvzActivation: this.activate.bind(this) }, "Verwaltung"), index.h("lmvz-menuitem", { key: 'd462954ef05c4d70252febfd184b363c4a2a3cde', slot: "connect-nav-lehrmittel" }, index.h("lmvz-icon", { key: '72e9bb03e05463b876bbf23e2e3e12838b15c76c', icon: "book" }), "Deutsch 7"), index.h("lmvz-menuitem", { key: '3f065f96ecd9ec59ae9ebd7885173e706f156a94', slot: "connect-nav-lehrmittel" }, index.h("lmvz-icon", { key: 'cb8039ffb7e590c201e7dc31ba55741c2dbe1181', icon: "book" }), "Mathe 2"), index.h("lmvz-menuitem", { key: '90eff45f7a773665a71eddceb4841e89fe54e5cb', slot: "connect-nav-verwaltung" }, index.h("lmvz-icon", { key: '1a9a36baab23233209649e65a5a25d0d1e9b455e', icon: "cog" }), "iwas mit Verwaltung"), index.h("lmvz-menuitem", { key: '14149a8355373308ff6a531fc6e796b0a67e44a3', slot: "connect-nav-verwaltung", "aria-label": "Einstellungen" }, index.h("lmvz-icon", { key: '0e713b2f6740e004c8897e986de0756c9392459e', icon: "cog" })), index.h("lmvz-button", { key: 'ee75293a9e256b5d3edf90a77a817aa1b60aea9e', slot: "actions", "aria-label": "Benutzerkonto" }, index.h("lmvz-icon", { key: '483e613ab4f5c32be0f942714fe649019b001f3f', icon: "user" }))), index.h("lmvz-input", { key: '63ec977b40a39ecd9bc37309ee2d917916cf3256', label: "test" })));
+    }
+};
+HeaderIntegration.style = `:host {
+      display: block;
+      min-height: 100vh;
+      background: var(--lmvz-color-spec-bg-outer-view);
+    }
+
+    .active button {
+      background-color: var(--lmvz-semantic-color-status-selected);
+    }`;
+
+var classnames = {exports: {}};
+
+/*!
+	Copyright (c) 2018 Jed Watson.
+	Licensed under the MIT License (MIT), see
+	http://jedwatson.github.io/classnames
+*/
+
+var hasRequiredClassnames;
+
+function requireClassnames () {
+	if (hasRequiredClassnames) return classnames.exports;
+	hasRequiredClassnames = 1;
+	(function (module) {
+		/* global define */
+
+		(function () {
+
+			var hasOwn = {}.hasOwnProperty;
+
+			function classNames () {
+				var classes = '';
+
+				for (var i = 0; i < arguments.length; i++) {
+					var arg = arguments[i];
+					if (arg) {
+						classes = appendClass(classes, parseValue(arg));
+					}
+				}
+
+				return classes;
+			}
+
+			function parseValue (arg) {
+				if (typeof arg === 'string' || typeof arg === 'number') {
+					return arg;
+				}
+
+				if (typeof arg !== 'object') {
+					return '';
+				}
+
+				if (Array.isArray(arg)) {
+					return classNames.apply(null, arg);
+				}
+
+				if (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes('[native code]')) {
+					return arg.toString();
+				}
+
+				var classes = '';
+
+				for (var key in arg) {
+					if (hasOwn.call(arg, key) && arg[key]) {
+						classes = appendClass(classes, key);
+					}
+				}
+
+				return classes;
+			}
+
+			function appendClass (value, newClass) {
+				if (!newClass) {
+					return value;
+				}
+			
+				if (value) {
+					return value + ' ' + newClass;
+				}
+			
+				return value + newClass;
+			}
+
+			if (module.exports) {
+				classNames.default = classNames;
+				module.exports = classNames;
+			} else {
+				window.classNames = classNames;
+			}
+		}()); 
+	} (classnames));
+	return classnames.exports;
+}
+
+var classnamesExports = requireClassnames();
+var classNames = /*@__PURE__*/getDefaultExportFromCjs(classnamesExports);
+
+const componentOnReady = (el, callback) => {
+    if (el.componentOnReady) {
+        el.componentOnReady().then((resolvedEl) => callback(resolvedEl));
+    }
+    else {
+        raf(() => callback(el));
+    }
+};
+const inheritAttributes = (el, attributes = []) => {
+    const attributeObject = {};
+    attributes.forEach(attr => {
+        if (el.hasAttribute(attr)) {
+            const value = el.getAttribute(attr);
+            if (value !== null) {
+                attributeObject[attr] = el.getAttribute(attr);
+            }
+            el.removeAttribute(attr);
+        }
+    });
+    return attributeObject;
+};
+const ariaAttributes = [
+    'role',
+    'aria-activedescendant',
+    'aria-atomic',
+    'aria-autocomplete',
+    'aria-braillelabel',
+    'aria-brailleroledescription',
+    'aria-busy',
+    'aria-checked',
+    'aria-colcount',
+    'aria-colindex',
+    'aria-colindextext',
+    'aria-colspan',
+    'aria-controls',
+    'aria-current',
+    'aria-describedby',
+    'aria-description',
+    'aria-details',
+    'aria-disabled',
+    'aria-errormessage',
+    'aria-expanded',
+    'aria-flowto',
+    'aria-haspopup',
+    'aria-hidden',
+    'aria-invalid',
+    'aria-keyshortcuts',
+    'aria-label',
+    'aria-labelledby',
+    'aria-level',
+    'aria-live',
+    'aria-multiline',
+    'aria-multiselectable',
+    'aria-orientation',
+    'aria-owns',
+    'aria-placeholder',
+    'aria-posinset',
+    'aria-pressed',
+    'aria-readonly',
+    'aria-relevant',
+    'aria-required',
+    'aria-roledescription',
+    'aria-rowcount',
+    'aria-rowindex',
+    'aria-rowindextext',
+    'aria-rowspan',
+    'aria-selected',
+    'aria-setsize',
+    'aria-sort',
+    'aria-valuemax',
+    'aria-valuemin',
+    'aria-valuenow',
+    'aria-valuetext',
+];
+const inheritAriaAttributes = (el, ignoreList) => {
+    let attributesToInherit = ariaAttributes;
+    return inheritAttributes(el, attributesToInherit);
+};
+const raf = (h) => {
+    if (typeof __zone_symbol__requestAnimationFrame === 'function') {
+        return __zone_symbol__requestAnimationFrame(h);
+    }
+    if (typeof requestAnimationFrame === 'function') {
+        return requestAnimationFrame(h);
+    }
+    return setTimeout(h);
+};
+function getDeepActiveElement(root = document) {
+    let activeElement = root.activeElement;
+    if (!activeElement) {
+        return null;
+    }
+    while (activeElement && activeElement.shadowRoot) {
+        const next = activeElement.shadowRoot.activeElement;
+        if (!next) {
+            break;
+        }
+        activeElement = next;
+    }
+    return activeElement;
+}
+function canReceiveFocus(el) {
+    return (el instanceof HTMLElement && el.tabIndex >= 0 && !el.hasAttribute('disabled') && el.getAttribute('aria-hidden') !== 'true' && el.checkVisibility() && el.offsetParent !== null);
+}
+function findFormByRef(form, el) {
+    if (form instanceof HTMLFormElement) {
+        return form;
+    }
+    if (typeof form === 'string') {
+        const el = document.getElementById(form);
+        if (el) {
+            if (el instanceof HTMLFormElement) {
+                return el;
+            }
+            else {
+                console.warn(`No Form found with selector: "#${form}". Verify that the element with id exists and is actually a <form> element.`, el);
+                return null;
+            }
+        }
+        else {
+            console.warn(`No Form found with selector: "#${form}". Verify that the id is correct and the form is rendered in the DOM.`, el);
+            return null;
+        }
+    }
+    if (form !== undefined) {
+        console.warn(`The provided "form" element is invalid. Verify that the form is a HTMLFormElement and rendered in the DOM.`, el);
+        return null;
+    }
+    return el.closest('form');
+}
+
+class ElementActivationController {
+    host;
+    config;
+    constructor(host, config) {
+        this.host = host;
+        this.config = config;
+    }
+    hostDidLoad() {
+        if (!this.host.el.hasAttribute('tabindex')) {
+            console.warn('Interactive element does not have a tabindex attribute!', this.host.el);
+        }
+        this.host.el.addEventListener('keydown', this.handleKeyDown.bind(this));
+        this.host.el.addEventListener('click', this.handleActivation.bind(this));
+    }
+    handleKeyDown = (event) => {
+        if ((this.config?.keys ?? ['Enter', ' ']).includes(event.key)) {
+            event.preventDefault();
+            this.handleActivation(event);
+        }
+    };
+    handleActivation = (event) => {
+        this.host.lmvzActivation.emit();
+        if (this.config?.localHandler) {
+            this.config.localHandler(event);
+        }
+    };
+}
+
+class ReactiveControllerHost {
+    controllers = new Set();
+    addController(controller) {
+        this.controllers.add(controller);
+    }
+    removeController(controller) {
+        this.controllers.delete(controller);
+    }
+    get activeControllers() {
+        return Array.from(this.controllers).filter(controller => !controller.disabled);
+    }
+    connectedCallback() {
+        if (!this.controllers.size) {
+            console.warn('ReactiveControllerHost connected with no controllers registered.', this);
+        }
+        this.activeControllers.forEach(controller => controller.hostConnected?.());
+    }
+    disconnectedCallback() {
+        this.activeControllers.forEach(controller => controller.hostDisconnected?.());
+    }
+    componentWillLoad() {
+        this.activeControllers.forEach(controller => controller.hostWillLoad?.());
+    }
+    componentDidLoad() {
+        this.activeControllers.forEach(controller => controller.hostDidLoad?.());
+    }
+    componentWillRender() {
+        this.activeControllers.forEach(controller => controller.hostWillRender?.());
+    }
+    componentDidRender() {
+        this.activeControllers.forEach(controller => controller.hostDidRender?.());
+    }
+    componentWillUpdate() {
+        this.activeControllers.forEach(controller => controller.hostWillUpdate?.());
+    }
+    componentDidUpdate() {
+        this.activeControllers.forEach(controller => controller.hostDidUpdate?.());
+    }
+}
+
+class AriaValidationController {
+    host;
+    config;
+    static get globalValidationEnabled() {
+        return index.Build.isDev;
+    }
+    static axe = this.globalValidationEnabled ? Promise.resolve().then(function () { return require('./axe-C2rxi-K2.js'); }).then(function (n) { return n.axe; }) : null;
+    static axeQueue = null;
+    static axeStreamFiber = null;
+    visibilityObserver;
+    elementQueued = false;
+    elementValidated = false;
+    knownValidationErrors = [];
+    get disabled() {
+        return true;
+    }
+    constructor(host, config) {
+        this.host = host;
+        this.config = config;
+        AriaValidationController.initializeAxeStream();
+    }
+    static initializeAxeStream() {
+        if (!this.globalValidationEnabled)
+            return;
+        if (this.axeStreamFiber)
+            return;
+        const program = assets.gen(function* () {
+            const queue = (AriaValidationController.axeQueue = yield* bounded(100));
+            const axeLib = yield* assets.promise(() => AriaValidationController.axe);
+            if (!axeLib) {
+                console.error('Axe library not available, ARIA validation will not run.');
+                return;
+            }
+            const stream = fromQueue(queue).pipe(mapEffect(({ context, onComplete }) => assets.async(resume => {
+                axeLib.run(context, {}, (error, results) => {
+                    onComplete(error, results);
+                    resume(assets._void);
+                });
+            })));
+            yield* runDrain(stream);
+        });
+        this.axeStreamFiber = assets.runFork(program);
+    }
+    hostDidLoad() {
+        if (this.elementQueued || this.elementValidated)
+            return;
+        if (!this.host.el.checkVisibility()) {
+            this.observeVisibilityOnce();
+            return;
+        }
+        this.enqueueValidation();
+    }
+    hostDidUpdate() {
+        this.checkLazyValidation();
+    }
+    hostDisconnected() {
+        this.discardVisibilityObserver();
+    }
+    observeVisibilityOnce() {
+        this.visibilityObserver = new IntersectionObserver(entries => {
+            for (const entry of entries) {
+                if (entry.target !== this.host.el)
+                    continue;
+                if (!entry.isIntersecting)
+                    continue;
+                this.checkLazyValidation();
+                this.discardVisibilityObserver();
+            }
+        }, {
+            root: this.host.el.parentElement,
+            rootMargin: '0px',
+            threshold: 0.01,
+        });
+        this.visibilityObserver.observe(this.host.el);
+    }
+    checkLazyValidation() {
+        if (!this.config?.reValidateOnPropChanges && (this.elementQueued || this.elementValidated))
+            return;
+        this.enqueueValidation();
+    }
+    enqueueValidation() {
+        return;
+    }
+    discardVisibilityObserver() {
+        if (!this.visibilityObserver)
+            return;
+        this.visibilityObserver.disconnect();
+        this.visibilityObserver = undefined;
+    }
+}
+
+const lmvzButtonCss = () => ` @layer           lmvz-ds.reset,           lmvz-ds.theme,           lmvz-ds.components,           lmvz-ds.overrides;  @layer lmvz-ds.theme { @font-face {   font-family: Router;   src:     local('Router-Book'),     url('/assets/fonts/Router-Book.woff') format('woff'),     local('Router');   font-weight: 400 normal; }  @font-face {   font-family: Router;   src:     local('Router-Medium'),     url('/assets/fonts/Router-Medium.woff') format('woff'),     local('Router');   font-weight: 500; }  @font-face {   font-family: Router;   src:     local('Router-Bold'),     url('/assets/fonts/Router-Bold.woff') format('woff'),     local('Router');   font-weight: 700 bold; }  } @layer lmvz-ds.reset { h1, h2, h3, h4, h5, h6 {   margin: 0; }  } :host {         button {   --lmvz-button-color: var(--lmvz-component-color, var(--lmvz-semantic-color-int-on-primary, #ffffff));   --lmvz-button-padding-inline: var(--lmvz-button-padding, var(--lmvz-component-input-md-padding-x, clamp(0.75rem, 0.69rem + 0.26vw, 1rem)));   --lmvz-button-padding-block: var(--lmvz-button-padding, var(--lmvz-component-input-md-padding-y, clamp(0.75rem, 0.69rem + 0.26vw, 1rem)));   --lmvz-button-gap: var(--lmvz-component-input-md-gap-x, clamp(0.25rem, 0.16rem + 0.39vw, 0.63rem));   --lmvz-button-font: var(--lmvz-typography-body-lg, 400 clamp(1rem, 0.97rem + 0.13vw, 1.13rem) / 1.4     Router);   --lmvz-button-radius: var(--lmvz-component-input-radius-default, 999px);   --lmvz-button-border-width: 0;   --lmvz-button-border-color: transparent;   --lmvz-button-background: var(--lmvz-semantic-color-int-primary, #000000);    display: inline-flex;   align-items: center;   justify-content: center;   gap: var(--lmvz-button-gap);   padding-block: var(--lmvz-button-padding-block);   padding-inline: var(--lmvz-button-padding-inline);   border-radius: var(--lmvz-button-radius);   border: var(--lmvz-button-border-width) solid var(--lmvz-button-border-color);   background-color: var(--lmvz-button-background);   color: var(--lmvz-button-color);   cursor: pointer;   font: var(--lmvz-button-font);   text-align: center;   text-decoration: none;   white-space: nowrap;   transition:     background-color 0.15s ease,     color 0.15s ease,     border-color 0.15s ease,     box-shadow 0.15s ease; }  button > * {   font: inherit;   color: inherit; }  button:focus-visible {      outline: var(--lmvz-semantic-border-width-default, 1px) solid var(--lmvz-semantic-color-status-selected, #f1f9fe);   outline-offset: var(--lmvz-component-input-sm-padding-x, clamp(0.5rem, 0.44rem + 0.26vw, 0.75rem)); }  button:is([disabled], .disabled) {   cursor: not-allowed;   pointer-events: none;                   opacity: var(--lmvz-component-input-disabled-opacity, 40%); }  button:not([disabled]):hover {   --lmvz-button-background: var(--lmvz-semantic-color-int-primary-hover, #2e2e2e); }  button:not([disabled]):active {   --lmvz-button-background: var(--lmvz-semantic-color-int-primary-active, #545454); }  button.secondary {   --lmvz-button-background: var(--lmvz-semantic-color-int-secondary, #f0f0f0);   --lmvz-button-color: var(--lmvz-semantic-color-int-on-secondary, #000000);   --lmvz-button-border-width: var(--lmvz-semantic-border-width-default, 1px);   --lmvz-button-border-color: var(--lmvz-semantic-color-border-default, #e0e0e0); }  button.secondary:not([disabled], .disabled):hover {   --lmvz-button-background: var(--lmvz-semantic-color-int-secondary-hover, #e0e0e0);   --lmvz-button-border-color: var(--lmvz-semantic-color-border-hover, #c7c7c7); }  button.secondary:not([disabled], .disabled):active {   --lmvz-button-background: var(--lmvz-semantic-color-int-secondary-active, #d4d4d4);   --lmvz-button-border-color: var(--lmvz-semantic-color-border-active, #d4d4d4); }    button.tertiary {   --lmvz-button-background: var(--lmvz-semantic-color-int-tertiary, #ffffff);   --lmvz-button-color: var(--lmvz-semantic-color-int-on-tertiary, #545454); }  button.tertiary:not([disabled], .disabled):hover {   --lmvz-button-background: var(--lmvz-semantic-color-int-tertiary-hover, #f0f0f0); }  button.tertiary:not([disabled], .disabled):active {   --lmvz-button-background: var(--lmvz-semantic-color-int-tertiary-active, #e0e0e0); }    button.small {   --lmvz-button-padding-inline: var(--lmvz-component-input-sm-padding-x, clamp(0.5rem, 0.44rem + 0.26vw, 0.75rem));   --lmvz-button-padding-block: var(--lmvz-component-input-sm-padding-y, clamp(0.5rem, 0.44rem + 0.26vw, 0.75rem));   --lmvz-button-gap: var(--lmvz-component-input-sm-gap-x, clamp(0.25rem, 0.16rem + 0.39vw, 0.63rem));   --lmvz-button-font: var(--lmvz-typography-body-md, 400 clamp(0.88rem, 0.84rem + 0.13vw, 1rem) / 1.4     Router); }  button.large {   --lmvz-button-padding-inline: var(--lmvz-component-input-lg-padding-x, clamp(0.88rem, 0.78rem + 0.39vw, 1.25rem));   --lmvz-button-padding-block: var(--lmvz-component-input-lg-padding-y, clamp(0.88rem, 0.78rem + 0.39vw, 1.25rem));   --lmvz-button-gap: var(--lmvz-component-input-lg-gap-x, clamp(0.25rem, 0.16rem + 0.39vw, 0.63rem));   --lmvz-button-font: var(--lmvz-typography-body-lg, 400 clamp(1rem, 0.97rem + 0.13vw, 1.13rem) / 1.4     Router); }     display: contents; } ::slotted(*) {   --lmvz-component-color: var(--lmvz-button-color); } `;
+
+const LmvzButton = class extends ReactiveControllerHost {
+    get el() { return index.getElement(this); }
+    inheritedAttributes = {};
+    formEl = null;
+    formButtonEl = null;
+    lmvzActivation;
+    get ti() {
+        return 0;
+    }
+    scale = 'default';
+    variant = 'secondary';
+    disabled = false;
+    type = 'button';
+    form;
+    constructor(hostRef) {
+        super();
+        index.registerInstance(this, hostRef);
+        this.lmvzActivation = index.createEvent(this, "lmvzActivation");
+        this.addController(new AriaValidationController(this));
+        this.addController(new ElementActivationController(this, {
+            localHandler: this.handleClick.bind(this),
+            keys: ['Enter'],
+        }));
+    }
+    connectedCallback() {
+        this.inheritedAttributes = inheritAriaAttributes(this.el);
+    }
+    renderHiddenButton() {
+        const formEl = (this.formEl = findFormByRef(this.form, this.el));
+        if (!formEl)
+            return;
+        const { formButtonEl } = this;
+        if (formButtonEl !== null && formEl.contains(formButtonEl))
+            return;
+        const newFormButtonEl = (this.formButtonEl = document.createElement('button'));
+        newFormButtonEl.type = 'submit';
+        newFormButtonEl.style.display = 'none';
+        newFormButtonEl.disabled = this.disabled;
+        formEl.appendChild(newFormButtonEl);
+    }
+    submitForm(ev) {
+        if (this.formEl && this.formButtonEl) {
+            ev.preventDefault();
+            this.formButtonEl.click();
+        }
+    }
+    handleClick = (ev) => {
+        if (this.type === 'submit') {
+            this.submitForm(ev);
+        }
+    };
+    render() {
+        this.renderHiddenButton();
+        return (index.h(index.Host, { key: '1c96281344dd604e2e4c919ea72907a9e934e5c6', "aria-disabled": this.disabled ? 'true' : null }, index.h("button", { key: '16728ce6fee7d121e7120aa993031777f6d8570e', disabled: this.disabled, class: classNames(this.variant, { [this.scale ?? '']: !!this.scale, disabled: this.disabled }), ...this.inheritedAttributes }, index.h("slot", { key: 'e1b0d95953bdbd42885eecdeef8b457070e7e247' }))));
+    }
+    static get delegatesFocus() { return true; }
+};
+LmvzButton.style = lmvzButtonCss();
+
+class ListKeyboardNavigationController {
+    host;
+    elements = [];
+    constructor(host) {
+        this.host = host;
+    }
+    hostDidRender() {
+        this.host.el.addEventListener('keydown', this.handleKeydown);
+    }
+    updateElements(elements) {
+        this.elements = elements;
+    }
+    handleKeydown = (event) => {
+        const { key } = event;
+        if (!['ArrowDown', 'ArrowRight', 'ArrowUp', 'ArrowLeft'].includes(key))
+            return;
+        const activeElement = getDeepActiveElement(document);
+        const nextElement = this.getNextFocusableElement(activeElement, ['ArrowDown', 'ArrowRight'].includes(key) ? 'down' : 'up');
+        if (nextElement) {
+            event.preventDefault();
+            nextElement.focus?.();
+        }
+    };
+    getNextFocusableElement(current, direction) {
+        const { elements } = this;
+        const currentIndex = elements.indexOf(current);
+        if (currentIndex === -1)
+            return null;
+        let nextIndex = null;
+        if (direction === 'down') {
+            nextIndex = (currentIndex + 1) % elements.length;
+        }
+        else if (direction === 'up') {
+            nextIndex = (currentIndex - 1 + elements.length) % elements.length;
+        }
+        if (nextIndex == null)
+            return null;
+        const candidate = elements[nextIndex];
+        if (!canReceiveFocus(candidate))
+            return this.getNextFocusableElement(candidate, direction);
+        return candidate;
+    }
+}
+
+const lmvzHeaderCss = () => `:host{display:flex;width:100vw;flex-direction:row;align-items:center;box-sizing:border-box;background-color:var(--lmvz-semantic-color-surface-primary, #ffffff);--lmvz-header-x-spacing-level-1:var(--lmvz-dimension-8-28, clamp(0.5rem, 0.2rem + 1.29vw, 1.75rem));--lmvz-header-x-spacing-level-2:var(--lmvz-component-buttongroup-wrapper-gap-x, clamp(0.25rem, 0.16rem + 0.39vw, 0.63rem));padding:var(--lmvz-dimension-8-16, clamp(0.5rem, 0.38rem + 0.52vw, 1rem)) var(--lmvz-header-x-spacing-level-1);gap:var(--lmvz-header-x-spacing-level-1);.brand{display:inline-flex;justify-content:center;align-items:center}#fallback-logo-lmvz{height:34px;width:auto}nav{flex-grow:1}.primary-menubar{display:flex;flex-direction:row;align-items:center}.secondary-menubar{display:flex;flex-direction:row;align-items:center;margin-left:var(--lmvz-header-x-spacing-level-2);padding-left:var(--lmvz-header-x-spacing-level-2);border-left:1px solid var(--lmvz-semantic-color-border-default, #e0e0e0)}}`;
+
+const LmvzHeader = class extends ReactiveControllerHost {
+    get el() { return index.getElement(this); }
+    primarySlot;
+    secondarySlot;
+    secondaryNav;
+    keyboardNavigationController = new ListKeyboardNavigationController(this);
+    get primaryMenuitems() {
+        return this.primarySlot.assignedElements({ flatten: false });
+    }
+    get secondaryMenuitems() {
+        return this.secondarySlot.assignedElements({ flatten: true });
+    }
+    get role() {
+        return 'banner';
+    }
+    lmvzActiveNav;
+    get secondarySlotName() {
+        return `connect-nav-${this.lmvzActiveNav}`;
+    }
+    constructor(hostRef) {
+        super();
+        index.registerInstance(this, hostRef);
+        this.addController(new AriaValidationController(this, { reValidateOnPropChanges: true }));
+        this.addController(this.keyboardNavigationController);
+    }
+    handleActiveNavChange() {
+        this.updateElementsActive();
+    }
+    componentDidLoad() {
+        this.primarySlot.addEventListener('slotchange', this.handlePrimaryNavChange.bind(this));
+        this.handlePrimaryNavChange();
+        this.secondarySlot.addEventListener('slotchange', this.handleSecondaryNavChange.bind(this));
+    }
+    handlePrimaryNavChange() {
+        const items = this.primaryMenuitems;
+        if (!items.length) {
+            console.warn('Primary slot has no assigned elements. Please add navigation items to the primary slot.');
+            return;
+        }
+        items.forEach(el => {
+            el.setAttribute('aria-haspopup', 'true');
+            el.setAttribute('aria-controls', `nav-secondary`);
+        });
+        this.updateElementsActive();
+    }
+    handleSecondaryNavChange() {
+        const items = this.secondaryMenuitems;
+        if (!items.length) {
+            return;
+        }
+        this.keyboardNavigationController.updateElements([...this.primaryMenuitems, ...this.secondaryMenuitems]);
+    }
+    updateElementsActive() {
+        const items = this.primaryMenuitems;
+        let label;
+        items.forEach(el => {
+            const isActive = el.id === this.lmvzActiveNav;
+            if (isActive)
+                label = el.textContent || el.id;
+            el.setAttribute('aria-expanded', isActive ? 'true' : 'false');
+        });
+        this.secondaryNav.setAttribute('aria-label', `Untermenü für ${label}`);
+    }
+    delegateFocus() {
+        const firstFocusable = this.primaryMenuitems[0];
+        if (firstFocusable) {
+            firstFocusable.focus();
+        }
+    }
+    render() {
+        return (index.h(index.Host, { key: '58934683ff442801eb34f025ac809631f93a27e8', onFocus: this.delegateFocus.bind(this) }, index.h("div", { key: '35d3eadfabb70f83b313f946c8d31f9c223e8344', class: "brand" }, index.h("slot", { key: '5ce98314d980d63e1c87f508d96119aca2e702a9', name: "brand" }, index.h("lmvz-icon", { key: 'b24e61a9071d81948d506a8c545e012d3f0e5dd2', id: "fallback-logo-lmvz", icon: "Logo", size: "inherit", "aria-label": "Lehrmittelverlag Z\u00FCrich" }))), index.h("nav", { key: '1d5cc9010ef90e6cebc8a7b054db595f35f9e040', "aria-label": "Hauptnavigation" }, index.h("div", { key: '488a1b1544242562b57d76169f1988d84c611de4', role: "menubar", class: "primary-menubar" }, index.h("slot", { key: '59c6dd1442290931ed9a55f7bacc65ea4bb9ff6d', name: "nav-primary", ref: el => (this.primarySlot = el) }), index.h("separator", { key: '2729f0e8b115614c50c4a16b6684a3bdb21856b8' }), index.h("div", { key: '6b5bed5951bad9173fefdc78039e71c4ccc120b2', role: "menu", id: "nav-secondary", class: "secondary-menubar", hidden: !this.lmvzActiveNav, ref: el => (this.secondaryNav = el) }, index.h("slot", { key: '02f5a13e8851372c1698e3f786a8757a0a09c32f', name: this.secondarySlotName, ref: el => (this.secondarySlot = el) })))), index.h("div", { key: '53aafe8139bcea27d3039f64a48974cdb5aac5f9', class: "actions" }, index.h("slot", { key: 'f12ee19831073253e6ba8e251ba31ec403c21035', name: "actions" }))));
+    }
+    static get watchers() { return {
+        "lmvzActiveNav": [{
+                "handleActiveNavChange": 0
+            }]
+    }; }
+};
+LmvzHeader.style = lmvzHeaderCss();
+
+const lmvzIconCss = () => `.sc-lmvz-icon-h{--lmvz-icon-color:var(--lmvz-component-color, var(--lmvz-semantic-color-on-surface-input-primary, #000000));display:inline-block;line-height:0;svg{display:block}svg>path{stroke:var(--lmvz-icon-color);fill:none}}[size='xs'].sc-lmvz-icon-h{svg{width:var(--lmvz-component-icon-size-xs, clamp(0.75rem, 0.69rem + 0.26vw, 1rem));height:var(--lmvz-component-icon-size-xs, clamp(0.75rem, 0.69rem + 0.26vw, 1rem))}}[size='sm'].sc-lmvz-icon-h{svg{width:var(--lmvz-component-icon-size-sm, clamp(0.88rem, 0.81rem + 0.26vw, 1.13rem));height:var(--lmvz-component-icon-size-sm, clamp(0.88rem, 0.81rem + 0.26vw, 1.13rem))}}[size='md'].sc-lmvz-icon-h{svg{width:var(--lmvz-component-icon-size-md, clamp(1rem, 0.88rem + 0.52vw, 1.5rem));height:var(--lmvz-component-icon-size-md, clamp(1rem, 0.88rem + 0.52vw, 1.5rem))}}[size='lg'].sc-lmvz-icon-h{svg{width:var(--lmvz-component-icon-size-lg, clamp(1.5rem, 1.38rem + 0.52vw, 2rem));height:var(--lmvz-component-icon-size-lg, clamp(1.5rem, 1.38rem + 0.52vw, 2rem))}}[size='inherit'].sc-lmvz-icon-h{svg{width:inherit;height:inherit}}[weight='light'].sc-lmvz-icon-h{svg>path{stroke-width:1}}[weight='medium'].sc-lmvz-icon-h{svg>path{stroke-width:1.5}}[weight='bold'].sc-lmvz-icon-h{svg>path{stroke-width:2}}[weight='filled'].sc-lmvz-icon-h{svg>path{stroke-width:2;fill:var(--lmvz-icon-color)}}`;
+
+const LmvzIcon = class extends ReactiveControllerHost {
+    intersectionObserver;
+    get el() { return index.getElement(this); }
+    icon;
+    weight = 'medium';
+    size = 'md';
+    iconData;
+    visible = false;
+    ariaLabel;
+    get ariaHidden() {
+        return !this.ariaLabel;
+    }
+    constructor(hostRef) {
+        super();
+        index.registerInstance(this, hostRef);
+        this.addController(new AriaValidationController(this));
+    }
+    connectedCallback() {
+        this.waitUntilVisible(() => {
+            this.visible = true;
+            this.loadIconPathData();
+        });
+    }
+    disconnectedCallback() {
+        if (this.intersectionObserver) {
+            this.intersectionObserver.disconnect();
+            this.intersectionObserver = null;
+        }
+    }
+    async loadIconPathData() {
+        const { icon, visible } = this;
+        if (!icon || !visible) {
+            return;
+        }
+        this.iconData = await assets.runPromise(icons.fetchIconSvg(this.icon).pipe(assets.tapError(error => assets.logError(`Error loading icon "${icon}":`, error.message, error.cause, error.stack)), assets.catchAll$1(() => assets.succeed$1(icons.emptyDefaultSvg()))));
+    }
+    render() {
+        return index.h(index.Host, { key: '50d0f96ec5085a47ca7783e5232dfb503fa32d29', role: "img", "aria-hidden": `${this.ariaHidden}`, innerHTML: this.iconData });
+    }
+    waitUntilVisible(callback, rootMargin = 50) {
+        if (typeof window === 'undefined' || !window.IntersectionObserver) {
+            callback();
+            return;
+        }
+        this.intersectionObserver = new IntersectionObserver(entries => {
+            entries.some(entry => {
+                if (entry.isIntersecting) {
+                    this.intersectionObserver.disconnect();
+                    this.intersectionObserver = null;
+                    callback();
+                    return true;
+                }
+                return false;
+            });
+        }, { rootMargin: `${rootMargin}px` });
+        this.intersectionObserver.observe(this.el);
+    }
+    static get assetsDirs() { return ["../../assets/icons"]; }
+    static get watchers() { return {
+        "icon": [{
+                "loadIconPathData": 0
+            }]
+    }; }
+};
+LmvzIcon.style = lmvzIconCss();
+
+const lmvzInputCss = () => `@layer lmvz-ds.reset, lmvz-ds.theme, lmvz-ds.components, lmvz-ds.overrides;  @layer lmvz-ds.theme { @font-face {   font-family: Router;   src:     local('Router-Book'),     url('/assets/fonts/Router-Book.woff') format('woff'),     local('Router');   font-weight: 400 normal; }  @font-face {   font-family: Router;   src:     local('Router-Medium'),     url('/assets/fonts/Router-Medium.woff') format('woff'),     local('Router');   font-weight: 500; }  @font-face {   font-family: Router;   src:     local('Router-Bold'),     url('/assets/fonts/Router-Bold.woff') format('woff'),     local('Router');   font-weight: 700 bold; }  } .sc-lmvz-input-h {   display: block;   font-family: var(--lmvz-global-font-family-default, Router);      --input-radius: var(--lmvz-component-input-radius-default, 999px);   --input-bg: var(--lmvz-semantic-color-surface-input-primary, #ffffff);   --input-border-color: var(--lmvz-semantic-color-border-default, #e0e0e0);   --input-border-color-hover: var(--lmvz-semantic-color-border-hover, #c7c7c7);   --input-border-color-focus: var(--lmvz-semantic-color-status-on-selected, #0e7ab4);   --input-border-width: var(--lmvz-semantic-border-width-default, 1px);   --input-height: 48px;    --input-padding-x: 16px;    --label-color: var(--lmvz-semantic-color-on-surface-input-secondary, #7a7a7a);   --input-text-color: var(--lmvz-semantic-color-on-surface-input-primary, #000000);   --helper-text-color: var(--lmvz-semantic-color-on-surface-input-secondary, #7a7a7a);   --error-text-color: var(--lmvz-semantic-color-status-on-danger, #e52a31);    --label-floating-scale: 0.85;    --label-minimized-top: -6px;   --label-minimized-bg: var(--input-bg);   --label-minimized-padding-x: 4px;       --input-disabled-opacity: var(--lmvz-component-input-disabled-opacity, 40%); } .input-container.sc-lmvz-input {   display: flex;   flex-direction: column;   position: relative;   width: 100%; } .input-wrapper.sc-lmvz-input {   background-color: var(--input-bg);   border: var(--input-border-width) solid var(--input-border-color);   border-radius: var(--input-radius);   display: flex;   align-items: center;   height: var(--input-height);   padding: 0 var(--input-padding-x);   position: relative;   transition: border-color 0.2s ease;   gap: 8px;  } [disabled].sc-lmvz-input-h .input-wrapper.sc-lmvz-input {   opacity: var(--input-disabled-opacity);   cursor: not-allowed;   pointer-events: none; } .input-container.sc-lmvz-input:focus-within .input-wrapper.sc-lmvz-input {   border-color: var(--input-border-color-focus);   outline: 2px solid var(--input-border-color-focus);   outline-offset: 2px; }  .input-container.sc-lmvz-input:has(input:focus-visible) .input-wrapper.sc-lmvz-input {   box-shadow: 0 0 0 3px rgb(0 86 214 / 20%); }  [error].sc-lmvz-input-h .input-wrapper.sc-lmvz-input {   border-color: var(--error-text-color); } [error].sc-lmvz-input-h:focus-within .input-wrapper.sc-lmvz-input {   border-color: var(--error-text-color);   outline-color: var(--error-text-color); }  .sc-lmvz-input-h:not([disabled]) .input-wrapper.sc-lmvz-input:hover {   border-color: var(--input-border-color-hover); } .label-input-group.sc-lmvz-input {   position: relative;   flex-grow: 1;   display: flex;   align-items: center;   height: 100%; } label.sc-lmvz-input {   position: absolute;   left: 0;   top: 50%;   transform: translateY(-50%);   color: var(--label-color);   font-size: 14px;    font-family: Router, sans-serif;   font-weight: 400;   pointer-events: none;   transition: all 0.2s ease-out;   background-color: transparent;   padding: 0;   margin: 0;   line-height: normal;   white-space: nowrap; } label.floating.sc-lmvz-input {   top: 0;    transform: translateY(-50%) scale(0.85);    transform-origin: left top;   background-color: var(--label-minimized-bg);   padding: 0 var(--label-minimized-padding-x);   left: -2px;    color: var(--input-text-color);    font-weight: 500;  } .required-indicator.sc-lmvz-input {   color: var(--error-text-color);   margin-left: 2px; } input.sc-lmvz-input {   border: none;   background: transparent;   width: 100%;   height: 100%;   color: var(--input-text-color);   font-family: inherit;   font-size: 14px;   outline: none;   padding: 0;   margin: 0;   font-weight: 400;  } input.sc-lmvz-input::placeholder {   color: var(--label-color); } .helper-text.sc-lmvz-input {   padding-top: 8px;    padding-left: 12px;    font-size: 12px;   color: var(--helper-text-color);   font-family: Router, sans-serif;   font-weight: 500;  } .error-message.sc-lmvz-input {   padding-top: 8px;   padding-left: 12px;   font-size: 12px;   color: var(--error-text-color);   font-family: Router, sans-serif;   font-weight: 500; } .sc-lmvz-input-s > lmvz-button {      --lmvz-button-padding: 4px; }`;
+
+let inputIdCounter = 0;
+const LmvzInput = class extends ReactiveControllerHost {
+    get el() { return index.getElement(this); }
+    lmvzInput;
+    internals;
+    nativeInputElement;
+    inputId = `lmvz-input-${inputIdCounter++}`;
+    initialValue = '';
+    nativeError = false;
+    errorFromProp = false;
+    get helperId() {
+        return this.helperText ? `${this.inputId}-helper` : undefined;
+    }
+    get showErrorMessage() {
+        return this.error && Boolean(this.errorMessage);
+    }
+    get errorId() {
+        return `${this.inputId}-error`;
+    }
+    get describedBy() {
+        const ids = [];
+        if (this.helperId)
+            ids.push(this.helperId);
+        if (this.showErrorMessage)
+            ids.push(this.errorId);
+        return ids.length > 0 ? ids.join(' ') : undefined;
+    }
+    value;
+    label;
+    helperText;
+    placeholder;
+    disabled = false;
+    readonly = false;
+    required = false;
+    name;
+    type = 'text';
+    errorMessage;
+    autocomplete;
+    inputmode;
+    autocorrect;
+    autocapitalize;
+    spellcheck;
+    autofocus = false;
+    minlength;
+    maxlength;
+    pattern;
+    min;
+    max;
+    step;
+    form;
+    get error() {
+        return this.errorFromProp || this.nativeError;
+    }
+    set error(value) {
+        this.errorFromProp = value;
+    }
+    async setValue(newValue) {
+        const input = this.nativeInputElement;
+        this.value = input.value = newValue ?? '';
+        this.internals.setFormValue?.(newValue);
+        this.lmvzInput.emit(newValue);
+    }
+    async focusInput() {
+        this.nativeInputElement?.focus();
+    }
+    async blurInput() {
+        this.nativeInputElement?.blur();
+    }
+    async select() {
+        this.nativeInputElement?.select();
+    }
+    async checkValidity() {
+        return this.nativeInputElement?.checkValidity?.() ?? false;
+    }
+    async reportValidity() {
+        return this.nativeInputElement?.reportValidity?.() ?? false;
+    }
+    async getInputElement() {
+        if (!this.nativeInputElement) {
+            await new Promise(resolve => componentOnReady(this.el, resolve));
+        }
+        return Promise.resolve(this.nativeInputElement);
+    }
+    constructor(hostRef) {
+        super();
+        index.registerInstance(this, hostRef);
+        this.lmvzInput = index.createEvent(this, "lmvzInput");
+        if (hostRef.$hostElement$["s-ei"]) {
+            this.internals = hostRef.$hostElement$["s-ei"];
+        }
+        else {
+            this.internals = hostRef.$hostElement$.attachInternals();
+            hostRef.$hostElement$["s-ei"] = this.internals;
+        }
+        this.addController(new AriaValidationController(this, {
+            reValidateOnPropChanges: true,
+        }));
+    }
+    componentWillLoad() {
+        this.initialValue = this.value;
+    }
+    formAssociatedCallback(form) {
+        if (!form)
+            return;
+        this.internals.setFormValue?.(this.value);
+    }
+    formResetCallback() {
+        this.internals.setValidity({});
+        this.setValue(this.initialValue);
+    }
+    formStateRestoreCallback(state) {
+        this.setValue(state);
+    }
+    handleValueChange(newValue) {
+        if (!this.nativeInputElement)
+            return;
+        const isInternalChange = this.nativeInputElement.value === newValue;
+        if (isInternalChange)
+            return;
+        this.setValue(newValue);
+    }
+    handleDisabledChange(disabled) {
+        if (disabled && this.nativeInputElement) {
+            this.nativeInputElement.blur();
+        }
+    }
+    handleInput = (event) => {
+        const input = event.target;
+        this.setValue(input.value);
+    };
+    handleChange = (event) => {
+        const input = event.target ?? this.nativeInputElement;
+        this.updateNativeError(input);
+    };
+    handleFocus = () => { };
+    handleBlur = (event) => {
+        const input = event.target;
+        input.reportValidity?.();
+    };
+    updateNativeError(fromEvent) {
+        const input = fromEvent ?? this.nativeInputElement;
+        if (!input)
+            return;
+        this.nativeError = !(input.checkValidity?.() ?? true);
+    }
+    render() {
+        const hasValue = Boolean(this.value);
+        const shouldFloatLabel = hasValue || Boolean(this.placeholder);
+        return (index.h("div", { key: '402189a211eec970a9f5b8fcc551c6c3508bec05', class: classNames('input-container', {
+                'interaction-filled': hasValue,
+            }) }, index.h("div", { key: '1cbe6011f14774e1226406ef4fe301fd94338444', class: "input-wrapper" }, index.h("slot", { key: 'ea0f30124315c88e9721bb4457126bd6cf18110a', name: "before-input" }), index.h("div", { key: 'f630b5f3a33a961f94b5a782b0ce6b4d49d1958c', class: "label-input-group" }, index.h("label", { key: 'dbb3fe066ebf93f7fcbe6973a1e37685d7206888', htmlFor: this.inputId, class: classNames({ floating: shouldFloatLabel }) }, this.label, this.required && (index.h("span", { key: '7c1a2458b66becb45c730bfe3ff0c570293f702f', class: "required-indicator", "aria-hidden": "true" }, ' ', "*"))), index.h("input", { key: '14b14457e200d20faf9053848662743dfe1cf417', id: this.inputId, ref: el => (this.nativeInputElement = el), type: this.type, min: this.min, max: this.max, step: this.step, value: this.value, name: this.name, placeholder: this.placeholder, disabled: this.disabled, readOnly: this.readonly, required: this.required, form: this.form, autocomplete: this.autocomplete, inputmode: this.inputmode, autocorrect: this.autocorrect, autocapitalize: this.autocapitalize, spellcheck: this.spellcheck, autofocus: this.autofocus, minlength: this.minlength, maxlength: this.maxlength, pattern: this.pattern, "aria-invalid": this.error ? 'true' : 'false', "aria-required": this.required ? 'true' : 'false', "aria-describedby": this.describedBy, "aria-errormessage": this.errorId, onInput: this.handleInput, onChange: this.handleChange, onFocus: this.handleFocus, onBlur: this.handleBlur })), index.h("slot", { key: '4b530738ff7404eb1bcecc10a0388570e2243cf3', name: "after-input" })), this.helperText && (index.h("div", { key: 'f1a287047e9b4d58aa90af157d50b3d564555e9b', id: this.helperId, class: "helper-text" }, this.helperText)), this.showErrorMessage && (index.h("div", { key: '2a25c4a88a63363cdd814f1d4fead5e8a238621b', id: this.errorId, class: "error-message", role: "alert" }, this.errorMessage))));
+    }
+    static get formAssociated() { return true; }
+    static get watchers() { return {
+        "value": [{
+                "handleValueChange": 0
+            }],
+        "disabled": [{
+                "handleDisabledChange": 0
+            }]
+    }; }
+};
+LmvzInput.style = lmvzInputCss();
+
+const lmvzMenuitemCss = () => `@layer lmvz-ds.reset, lmvz-ds.theme, lmvz-ds.components, lmvz-ds.overrides;  @layer lmvz-ds.theme { @font-face {   font-family: Router;   src:     local('Router-Book'),     url('/assets/fonts/Router-Book.woff') format('woff'),     local('Router');   font-weight: 400 normal; }  @font-face {   font-family: Router;   src:     local('Router-Medium'),     url('/assets/fonts/Router-Medium.woff') format('woff'),     local('Router');   font-weight: 500; }  @font-face {   font-family: Router;   src:     local('Router-Bold'),     url('/assets/fonts/Router-Bold.woff') format('woff'),     local('Router');   font-weight: 700 bold; }  } .sc-lmvz-menuitem-h {   display: inline-flex;   flex-direction: row;   align-items: center;   justify-content: center;   gap: var(--lmvz-component-input-md-gap-x, clamp(0.25rem, 0.16rem + 0.39vw, 0.63rem));   border-radius: var(--lmvz-semantic-border-radius-lg, 14px);   font: var(--lmvz-typography-body-md, 400 clamp(0.88rem, 0.84rem + 0.13vw, 1rem) / 1.4     Router);   padding: var(--lmvz-component-input-md-padding-y, clamp(0.75rem, 0.69rem + 0.26vw, 1rem)) var(--lmvz-component-input-md-padding-x, clamp(0.75rem, 0.69rem + 0.26vw, 1rem));   cursor: pointer;    --lmvz-menuitem-color: var(--lmvz-semantic-color-int-on-tertiary, #545454);   --lmvz-menuitem-background: var(--lmvz-semantic-color-int-tertiary, #ffffff);    background: var(--lmvz-menuitem-background);   color: var(--lmvz-menuitem-color); } .sc-lmvz-menuitem-h:hover {   --lmvz-menuitem-background: var(--lmvz-semantic-color-int-tertiary-hover, #f0f0f0); } .sc-lmvz-menuitem-h:active {   --lmvz-menuitem-background: var(--lmvz-semantic-color-int-tertiary-active, #e0e0e0); } .sc-lmvz-menuitem-h:focus-visible {      z-index: 1; } [aria-expanded='true'].sc-lmvz-menuitem-h {   --lmvz-menuitem-background: var(--lmvz-semantic-color-status-selected, #f1f9fe);   --lmvz-menuitem-color: var(--lmvz-semantic-color-status-on-selected, #0e7ab4); }`;
+
+const LmvzMenuItem = class extends ReactiveControllerHost {
+    get el() { return index.getElement(this); }
+    get role() {
+        return 'menuitem';
+    }
+    get ti() {
+        return 0;
+    }
+    lmvzActivation;
+    constructor(hostRef) {
+        super();
+        index.registerInstance(this, hostRef);
+        this.lmvzActivation = index.createEvent(this, "lmvzActivation");
+        this.addController(new AriaValidationController(this));
+        this.addController(new ElementActivationController(this));
+    }
+    render() {
+        return (index.h(index.Host, { key: '44399be11122af25d05e5b3b5f05dd90a89fddc4' }, index.h("slot", { key: '2809f9e89a0c38af4d3f1f17ad78397487370134' })));
+    }
+};
+LmvzMenuItem.style = lmvzMenuitemCss();
+
+exports.HeaderIntegration = HeaderIntegration;
+exports.LmvzButton = LmvzButton;
+exports.LmvzHeader = LmvzHeader;
+exports.LmvzIcon = LmvzIcon;
+exports.LmvzInput = LmvzInput;
+exports.LmvzMenuItem = LmvzMenuItem;
+exports.getDefaultExportFromCjs = getDefaultExportFromCjs;
+//# sourceMappingURL=header-integration.lmvz-button.lmvz-header.lmvz-icon.lmvz-input.lmvz-menuitem-BTL_B6qg.js.map
+
+//# sourceMappingURL=header-integration.lmvz-button.lmvz-header.lmvz-icon.lmvz-input.lmvz-menuitem-BTL_B6qg.js.map