@clayroach/effect 3.19.14-source-capture.8 → 3.19.14-source-trace.2

package/src/internal/runtimeFlags.ts

@@ -0,0 +1,178 @@
+import type * as Differ from "../Differ.js"
+import { dual } from "../Function.js"
+import type * as RuntimeFlags from "../RuntimeFlags.js"
+import type * as RuntimeFlagsPatch from "../RuntimeFlagsPatch.js"
+import * as internalDiffer from "./differ.js"
+import * as runtimeFlagsPatch from "./runtimeFlagsPatch.js"
+
+/** @internal */
+export const None: RuntimeFlags.RuntimeFlag = 0 as RuntimeFlags.RuntimeFlag
+
+/** @internal */
+export const Interruption: RuntimeFlags.RuntimeFlag = 1 << 0 as RuntimeFlags.RuntimeFlag
+
+/** @internal */
+export const OpSupervision: RuntimeFlags.RuntimeFlag = 1 << 1 as RuntimeFlags.RuntimeFlag
+
+/** @internal */
+export const RuntimeMetrics: RuntimeFlags.RuntimeFlag = 1 << 2 as RuntimeFlags.RuntimeFlag
+
+/** @internal */
+export const WindDown: RuntimeFlags.RuntimeFlag = 1 << 4 as RuntimeFlags.RuntimeFlag
+
+/** @internal */
+export const CooperativeYielding: RuntimeFlags.RuntimeFlag = 1 << 5 as RuntimeFlags.RuntimeFlag
+
+/** @internal */
+export const allFlags: ReadonlyArray<RuntimeFlags.RuntimeFlag> = [
+  None,
+  Interruption,
+  OpSupervision,
+  RuntimeMetrics,
+  WindDown,
+  CooperativeYielding
+]
+
+const print = (flag: RuntimeFlags.RuntimeFlag) => {
+  switch (flag) {
+    case CooperativeYielding: {
+      return "CooperativeYielding"
+    }
+    case WindDown: {
+      return "WindDown"
+    }
+    case RuntimeMetrics: {
+      return "RuntimeMetrics"
+    }
+    case OpSupervision: {
+      return "OpSupervision"
+    }
+    case Interruption: {
+      return "Interruption"
+    }
+    case None: {
+      return "None"
+    }
+  }
+}
+
+/** @internal */
+export const cooperativeYielding = (self: RuntimeFlags.RuntimeFlags): boolean => isEnabled(self, CooperativeYielding)
+
+/** @internal */
+export const disable = dual<
+  (flag: RuntimeFlags.RuntimeFlag) => (self: RuntimeFlags.RuntimeFlags) => RuntimeFlags.RuntimeFlags,
+  (self: RuntimeFlags.RuntimeFlags, flag: RuntimeFlags.RuntimeFlag) => RuntimeFlags.RuntimeFlags
+>(2, (self, flag) => (self & ~flag) as RuntimeFlags.RuntimeFlags)
+
+/** @internal */
+export const disableAll = dual<
+  (flags: RuntimeFlags.RuntimeFlags) => (self: RuntimeFlags.RuntimeFlags) => RuntimeFlags.RuntimeFlags,
+  (self: RuntimeFlags.RuntimeFlags, flags: RuntimeFlags.RuntimeFlags) => RuntimeFlags.RuntimeFlags
+>(2, (self, flags) => (self & ~flags) as RuntimeFlags.RuntimeFlags)
+
+/** @internal */
+export const enable = dual<
+  (flag: RuntimeFlags.RuntimeFlag) => (self: RuntimeFlags.RuntimeFlags) => RuntimeFlags.RuntimeFlags,
+  (self: RuntimeFlags.RuntimeFlags, flag: RuntimeFlags.RuntimeFlag) => RuntimeFlags.RuntimeFlags
+>(2, (self, flag) => (self | flag) as RuntimeFlags.RuntimeFlags)
+
+/** @internal */
+export const enableAll = dual<
+  (flags: RuntimeFlags.RuntimeFlags) => (self: RuntimeFlags.RuntimeFlags) => RuntimeFlags.RuntimeFlags,
+  (self: RuntimeFlags.RuntimeFlags, flags: RuntimeFlags.RuntimeFlags) => RuntimeFlags.RuntimeFlags
+>(2, (self, flags) => (self | flags) as RuntimeFlags.RuntimeFlags)
+
+/** @internal */
+export const interruptible = (self: RuntimeFlags.RuntimeFlags): boolean => interruption(self) && !windDown(self)
+
+/** @internal */
+export const interruption = (self: RuntimeFlags.RuntimeFlags): boolean => isEnabled(self, Interruption)
+
+/** @internal */
+export const isDisabled = dual<
+  (flag: RuntimeFlags.RuntimeFlag) => (self: RuntimeFlags.RuntimeFlags) => boolean,
+  (self: RuntimeFlags.RuntimeFlags, flag: RuntimeFlags.RuntimeFlag) => boolean
+>(2, (self, flag) => !isEnabled(self, flag))
+
+/** @internal */
+export const isEnabled = dual<
+  (flag: RuntimeFlags.RuntimeFlag) => (self: RuntimeFlags.RuntimeFlags) => boolean,
+  (self: RuntimeFlags.RuntimeFlags, flag: RuntimeFlags.RuntimeFlag) => boolean
+>(2, (self, flag) => (self & flag) !== 0)
+
+/** @internal */
+export const make = (...flags: ReadonlyArray<RuntimeFlags.RuntimeFlag>): RuntimeFlags.RuntimeFlags =>
+  flags.reduce((a, b) => a | b, 0) as RuntimeFlags.RuntimeFlags
+
+/** @internal */
+export const none: RuntimeFlags.RuntimeFlags = make(None)
+
+/** @internal */
+export const opSupervision = (self: RuntimeFlags.RuntimeFlags): boolean => isEnabled(self, OpSupervision)
+
+/** @internal */
+export const render = (self: RuntimeFlags.RuntimeFlags): string => {
+  const active: Array<string> = []
+  allFlags.forEach((flag) => {
+    if (isEnabled(self, flag)) {
+      active.push(`${print(flag)}`)
+    }
+  })
+  return `RuntimeFlags(${active.join(", ")})`
+}
+
+/** @internal */
+export const runtimeMetrics = (self: RuntimeFlags.RuntimeFlags): boolean => isEnabled(self, RuntimeMetrics)
+
+/** @internal */
+export const toSet = (self: RuntimeFlags.RuntimeFlags): ReadonlySet<RuntimeFlags.RuntimeFlag> =>
+  new Set(allFlags.filter((flag) => isEnabled(self, flag)))
+
+export const windDown = (self: RuntimeFlags.RuntimeFlags): boolean => isEnabled(self, WindDown)
+
+// circular with RuntimeFlagsPatch
+
+/** @internal */
+export const enabledSet = (self: RuntimeFlagsPatch.RuntimeFlagsPatch): ReadonlySet<RuntimeFlags.RuntimeFlag> =>
+  toSet((runtimeFlagsPatch.active(self) & runtimeFlagsPatch.enabled(self)) as RuntimeFlags.RuntimeFlags)
+
+/** @internal */
+export const disabledSet = (self: RuntimeFlagsPatch.RuntimeFlagsPatch): ReadonlySet<RuntimeFlags.RuntimeFlag> =>
+  toSet((runtimeFlagsPatch.active(self) & ~runtimeFlagsPatch.enabled(self)) as RuntimeFlags.RuntimeFlags)
+
+/** @internal */
+export const diff = dual<
+  (that: RuntimeFlags.RuntimeFlags) => (self: RuntimeFlags.RuntimeFlags) => RuntimeFlagsPatch.RuntimeFlagsPatch,
+  (self: RuntimeFlags.RuntimeFlags, that: RuntimeFlags.RuntimeFlags) => RuntimeFlagsPatch.RuntimeFlagsPatch
+>(2, (self, that) => runtimeFlagsPatch.make(self ^ that, that))
+
+/** @internal */
+export const patch = dual<
+  (patch: RuntimeFlagsPatch.RuntimeFlagsPatch) => (self: RuntimeFlags.RuntimeFlags) => RuntimeFlags.RuntimeFlags,
+  (self: RuntimeFlags.RuntimeFlags, patch: RuntimeFlagsPatch.RuntimeFlagsPatch) => RuntimeFlags.RuntimeFlags
+>(2, (self, patch) =>
+  (
+    (self & (runtimeFlagsPatch.invert(runtimeFlagsPatch.active(patch)) | runtimeFlagsPatch.enabled(patch))) |
+    (runtimeFlagsPatch.active(patch) & runtimeFlagsPatch.enabled(patch))
+  ) as RuntimeFlags.RuntimeFlags)
+
+/** @internal */
+export const renderPatch = (self: RuntimeFlagsPatch.RuntimeFlagsPatch): string => {
+  const enabled = Array.from(enabledSet(self))
+    .map((flag) => print(flag))
+    .join(", ")
+  const disabled = Array.from(disabledSet(self))
+    .map((flag) => print(flag))
+    .join(", ")
+  return `RuntimeFlagsPatch(enabled = (${enabled}), disabled = (${disabled}))`
+}
+
+/** @internal */
+export const differ: Differ.Differ<RuntimeFlags.RuntimeFlags, RuntimeFlagsPatch.RuntimeFlagsPatch> = internalDiffer
+  .make({
+    empty: runtimeFlagsPatch.empty,
+    diff: (oldValue, newValue) => diff(oldValue, newValue),
+    combine: (first, second) => runtimeFlagsPatch.andThen(second)(first),
+    patch: (_patch, oldValue) => patch(oldValue, _patch)
+  })

package/src/internal/runtimeFlagsPatch.ts

@@ -0,0 +1,103 @@
+import { dual } from "../Function.js"
+import type * as RuntimeFlags from "../RuntimeFlags.js"
+import type * as RuntimeFlagsPatch from "../RuntimeFlagsPatch.js"
+
+/** @internal */
+const BIT_MASK = 0xff
+
+/** @internal */
+const BIT_SHIFT = 0x08
+
+/** @internal */
+export const active = (patch: RuntimeFlagsPatch.RuntimeFlagsPatch): number => patch & BIT_MASK
+
+/** @internal */
+export const enabled = (patch: RuntimeFlagsPatch.RuntimeFlagsPatch): number => (patch >> BIT_SHIFT) & BIT_MASK
+
+/** @internal */
+export const make = (active: number, enabled: number): RuntimeFlagsPatch.RuntimeFlagsPatch =>
+  ((active & BIT_MASK) + (((enabled & active) & BIT_MASK) << BIT_SHIFT)) as RuntimeFlagsPatch.RuntimeFlagsPatch
+
+/** @internal */
+export const empty = make(0, 0)
+
+/** @internal */
+export const enable = (flag: RuntimeFlags.RuntimeFlag): RuntimeFlagsPatch.RuntimeFlagsPatch => make(flag, flag)
+
+/** @internal */
+export const disable = (flag: RuntimeFlags.RuntimeFlag): RuntimeFlagsPatch.RuntimeFlagsPatch => make(flag, 0)
+
+/** @internal */
+export const isEmpty = (patch: RuntimeFlagsPatch.RuntimeFlagsPatch): boolean => patch === 0
+
+/** @internal */
+export const isActive = dual<
+  (flag: RuntimeFlagsPatch.RuntimeFlagsPatch) => (self: RuntimeFlagsPatch.RuntimeFlagsPatch) => boolean,
+  (self: RuntimeFlagsPatch.RuntimeFlagsPatch, flag: RuntimeFlagsPatch.RuntimeFlagsPatch) => boolean
+>(2, (self, flag) => (active(self) & flag) !== 0)
+
+/** @internal */
+export const isEnabled = dual<
+  (flag: RuntimeFlags.RuntimeFlag) => (self: RuntimeFlagsPatch.RuntimeFlagsPatch) => boolean,
+  (self: RuntimeFlagsPatch.RuntimeFlagsPatch, flag: RuntimeFlags.RuntimeFlag) => boolean
+>(2, (self, flag) => (enabled(self) & flag) !== 0)
+
+/** @internal */
+export const isDisabled = dual<
+  (flag: RuntimeFlags.RuntimeFlag) => (self: RuntimeFlagsPatch.RuntimeFlagsPatch) => boolean,
+  (self: RuntimeFlagsPatch.RuntimeFlagsPatch, flag: RuntimeFlags.RuntimeFlag) => boolean
+>(2, (self, flag) => ((active(self) & flag) !== 0) && ((enabled(self) & flag) === 0))
+
+/** @internal */
+export const exclude = dual<
+  (
+    flag: RuntimeFlags.RuntimeFlag
+  ) => (self: RuntimeFlagsPatch.RuntimeFlagsPatch) => RuntimeFlagsPatch.RuntimeFlagsPatch,
+  (self: RuntimeFlagsPatch.RuntimeFlagsPatch, flag: RuntimeFlags.RuntimeFlag) => RuntimeFlagsPatch.RuntimeFlagsPatch
+>(2, (self, flag) => make(active(self) & ~flag, enabled(self)))
+
+/** @internal */
+export const both = dual<
+  (
+    that: RuntimeFlagsPatch.RuntimeFlagsPatch
+  ) => (
+    self: RuntimeFlagsPatch.RuntimeFlagsPatch
+  ) => RuntimeFlagsPatch.RuntimeFlagsPatch,
+  (
+    self: RuntimeFlagsPatch.RuntimeFlagsPatch,
+    that: RuntimeFlagsPatch.RuntimeFlagsPatch
+  ) => RuntimeFlagsPatch.RuntimeFlagsPatch
+>(2, (self, that) => make(active(self) | active(that), enabled(self) & enabled(that)))
+
+/** @internal */
+export const either = dual<
+  (
+    that: RuntimeFlagsPatch.RuntimeFlagsPatch
+  ) => (
+    self: RuntimeFlagsPatch.RuntimeFlagsPatch
+  ) => RuntimeFlagsPatch.RuntimeFlagsPatch,
+  (
+    self: RuntimeFlagsPatch.RuntimeFlagsPatch,
+    that: RuntimeFlagsPatch.RuntimeFlagsPatch
+  ) => RuntimeFlagsPatch.RuntimeFlagsPatch
+>(2, (self, that) => make(active(self) | active(that), enabled(self) | enabled(that)))
+
+/** @internal */
+export const andThen = dual<
+  (
+    that: RuntimeFlagsPatch.RuntimeFlagsPatch
+  ) => (
+    self: RuntimeFlagsPatch.RuntimeFlagsPatch
+  ) => RuntimeFlagsPatch.RuntimeFlagsPatch,
+  (
+    self: RuntimeFlagsPatch.RuntimeFlagsPatch,
+    that: RuntimeFlagsPatch.RuntimeFlagsPatch
+  ) => RuntimeFlagsPatch.RuntimeFlagsPatch
+>(2, (self, that) => (self | that) as RuntimeFlagsPatch.RuntimeFlagsPatch)
+
+/** @internal */
+export const inverse = (patch: RuntimeFlagsPatch.RuntimeFlagsPatch): RuntimeFlagsPatch.RuntimeFlagsPatch =>
+  make(enabled(patch), invert(active(patch)))
+
+/** @internal */
+export const invert = (n: number): number => (~n >>> 0) & BIT_MASK

package/src/internal/schedule/decision.ts

@@ -0,0 +1,47 @@
+import * as Chunk from "../../Chunk.js"
+import type * as ScheduleDecision from "../../ScheduleDecision.js"
+import type * as Interval from "../../ScheduleInterval.js"
+import * as Intervals from "../../ScheduleIntervals.js"
+
+/** @internal */
+export const OP_CONTINUE = "Continue" as const
+
+/** @internal */
+export type OP_CONTINUE = typeof OP_CONTINUE
+
+/** @internal */
+export const OP_DONE = "Done" as const
+
+/** @internal */
+export type OP_DONE = typeof OP_DONE
+
+/** @internal */
+export const _continue = (intervals: Intervals.Intervals): ScheduleDecision.ScheduleDecision => {
+  return {
+    _tag: OP_CONTINUE,
+    intervals
+  }
+}
+
+/** @internal */
+export const continueWith = (interval: Interval.Interval): ScheduleDecision.ScheduleDecision => {
+  return {
+    _tag: OP_CONTINUE,
+    intervals: Intervals.make(Chunk.of(interval))
+  }
+}
+
+/** @internal */
+export const done: ScheduleDecision.ScheduleDecision = {
+  _tag: OP_DONE
+}
+
+/** @internal */
+export const isContinue = (self: ScheduleDecision.ScheduleDecision): self is ScheduleDecision.Continue => {
+  return self._tag === OP_CONTINUE
+}
+
+/** @internal */
+export const isDone = (self: ScheduleDecision.ScheduleDecision): self is ScheduleDecision.Done => {
+  return self._tag === OP_DONE
+}

package/src/internal/schedule/interval.ts

@@ -0,0 +1,101 @@
+import * as Duration from "../../Duration.js"
+import { dual } from "../../Function.js"
+import * as Option from "../../Option.js"
+import type * as Interval from "../../ScheduleInterval.js"
+
+/** @internal */
+const IntervalSymbolKey = "effect/ScheduleInterval"
+
+/** @internal */
+export const IntervalTypeId: Interval.IntervalTypeId = Symbol.for(
+  IntervalSymbolKey
+) as Interval.IntervalTypeId
+
+/** @internal */
+export const empty: Interval.Interval = {
+  [IntervalTypeId]: IntervalTypeId,
+  startMillis: 0,
+  endMillis: 0
+}
+
+/** @internal */
+export const make = (startMillis: number, endMillis: number): Interval.Interval => {
+  if (startMillis > endMillis) {
+    return empty
+  }
+  return {
+    [IntervalTypeId]: IntervalTypeId,
+    startMillis,
+    endMillis
+  }
+}
+
+/** @internal */
+export const lessThan = dual<
+  (that: Interval.Interval) => (self: Interval.Interval) => boolean,
+  (self: Interval.Interval, that: Interval.Interval) => boolean
+>(2, (self, that) => min(self, that) === self)
+
+/** @internal */
+export const min = dual<
+  (that: Interval.Interval) => (self: Interval.Interval) => Interval.Interval,
+  (self: Interval.Interval, that: Interval.Interval) => Interval.Interval
+>(2, (self, that) => {
+  if (self.endMillis <= that.startMillis) return self
+  if (that.endMillis <= self.startMillis) return that
+  if (self.startMillis < that.startMillis) return self
+  if (that.startMillis < self.startMillis) return that
+  if (self.endMillis <= that.endMillis) return self
+  return that
+})
+
+/** @internal */
+export const max = dual<
+  (that: Interval.Interval) => (self: Interval.Interval) => Interval.Interval,
+  (self: Interval.Interval, that: Interval.Interval) => Interval.Interval
+>(2, (self, that) => min(self, that) === self ? that : self)
+
+/** @internal */
+export const isEmpty = (self: Interval.Interval): boolean => {
+  return self.startMillis >= self.endMillis
+}
+
+/** @internal */
+export const isNonEmpty = (self: Interval.Interval): boolean => {
+  return !isEmpty(self)
+}
+
+/** @internal */
+export const intersect = dual<
+  (that: Interval.Interval) => (self: Interval.Interval) => Interval.Interval,
+  (self: Interval.Interval, that: Interval.Interval) => Interval.Interval
+>(2, (self, that) => {
+  const start = Math.max(self.startMillis, that.startMillis)
+  const end = Math.min(self.endMillis, that.endMillis)
+  return make(start, end)
+})
+
+/** @internal */
+export const size = (self: Interval.Interval): Duration.Duration => {
+  return Duration.millis(self.endMillis - self.startMillis)
+}
+
+/** @internal */
+export const union = dual<
+  (that: Interval.Interval) => (self: Interval.Interval) => Option.Option<Interval.Interval>,
+  (self: Interval.Interval, that: Interval.Interval) => Option.Option<Interval.Interval>
+>(2, (self, that) => {
+  const start = Math.max(self.startMillis, that.startMillis)
+  const end = Math.min(self.endMillis, that.endMillis)
+  return start < end ? Option.none() : Option.some(make(start, end))
+})
+
+/** @internal */
+export const after = (startMilliseconds: number): Interval.Interval => {
+  return make(startMilliseconds, Number.POSITIVE_INFINITY)
+}
+
+/** @internal */
+export const before = (endMilliseconds: number): Interval.Interval => {
+  return make(Number.NEGATIVE_INFINITY, endMilliseconds)
+}

package/src/internal/schedule/intervals.ts

@@ -0,0 +1,180 @@
+import * as Chunk from "../../Chunk.js"
+import { dual, pipe } from "../../Function.js"
+import * as Option from "../../Option.js"
+import * as Interval from "../../ScheduleInterval.js"
+import type * as Intervals from "../../ScheduleIntervals.js"
+import { getBugErrorMessage } from "../errors.js"
+
+/** @internal */
+const IntervalsSymbolKey = "effect/ScheduleIntervals"
+
+/** @internal */
+export const IntervalsTypeId: Intervals.IntervalsTypeId = Symbol.for(
+  IntervalsSymbolKey
+) as Intervals.IntervalsTypeId
+
+/** @internal */
+export const make = (intervals: Chunk.Chunk<Interval.Interval>): Intervals.Intervals => {
+  return {
+    [IntervalsTypeId]: IntervalsTypeId,
+    intervals
+  }
+}
+/** @internal */
+export const empty: Intervals.Intervals = make(Chunk.empty())
+
+/** @internal */
+export const fromIterable = (intervals: Iterable<Interval.Interval>): Intervals.Intervals =>
+  Array.from(intervals).reduce(
+    (intervals, interval) => pipe(intervals, union(make(Chunk.of(interval)))),
+    empty
+  )
+
+/** @internal */
+export const union = dual<
+  (that: Intervals.Intervals) => (self: Intervals.Intervals) => Intervals.Intervals,
+  (self: Intervals.Intervals, that: Intervals.Intervals) => Intervals.Intervals
+>(2, (self, that) => {
+  if (!Chunk.isNonEmpty(that.intervals)) {
+    return self
+  }
+  if (!Chunk.isNonEmpty(self.intervals)) {
+    return that
+  }
+  if (Chunk.headNonEmpty(self.intervals).startMillis < Chunk.headNonEmpty(that.intervals).startMillis) {
+    return unionLoop(
+      Chunk.tailNonEmpty(self.intervals),
+      that.intervals,
+      Chunk.headNonEmpty(self.intervals),
+      Chunk.empty()
+    )
+  }
+  return unionLoop(
+    self.intervals,
+    Chunk.tailNonEmpty(that.intervals),
+    Chunk.headNonEmpty(that.intervals),
+    Chunk.empty()
+  )
+})
+
+/** @internal */
+const unionLoop = (
+  _self: Chunk.Chunk<Interval.Interval>,
+  _that: Chunk.Chunk<Interval.Interval>,
+  _interval: Interval.Interval,
+  _acc: Chunk.Chunk<Interval.Interval>
+): Intervals.Intervals => {
+  let self = _self
+  let that = _that
+  let interval = _interval
+  let acc = _acc
+  while (Chunk.isNonEmpty(self) || Chunk.isNonEmpty(that)) {
+    if (!Chunk.isNonEmpty(self) && Chunk.isNonEmpty(that)) {
+      if (interval.endMillis < Chunk.headNonEmpty(that).startMillis) {
+        acc = pipe(acc, Chunk.prepend(interval))
+        interval = Chunk.headNonEmpty(that)
+        that = Chunk.tailNonEmpty(that)
+        self = Chunk.empty()
+      } else {
+        interval = Interval.make(interval.startMillis, Chunk.headNonEmpty(that).endMillis)
+        that = Chunk.tailNonEmpty(that)
+        self = Chunk.empty()
+      }
+    } else if (Chunk.isNonEmpty(self) && Chunk.isEmpty(that)) {
+      if (interval.endMillis < Chunk.headNonEmpty(self).startMillis) {
+        acc = pipe(acc, Chunk.prepend(interval))
+        interval = Chunk.headNonEmpty(self)
+        that = Chunk.empty()
+        self = Chunk.tailNonEmpty(self)
+      } else {
+        interval = Interval.make(interval.startMillis, Chunk.headNonEmpty(self).endMillis)
+        that = Chunk.empty()
+        self = Chunk.tailNonEmpty(self)
+      }
+    } else if (Chunk.isNonEmpty(self) && Chunk.isNonEmpty(that)) {
+      if (Chunk.headNonEmpty(self).startMillis < Chunk.headNonEmpty(that).startMillis) {
+        if (interval.endMillis < Chunk.headNonEmpty(self).startMillis) {
+          acc = pipe(acc, Chunk.prepend(interval))
+          interval = Chunk.headNonEmpty(self)
+          self = Chunk.tailNonEmpty(self)
+        } else {
+          interval = Interval.make(interval.startMillis, Chunk.headNonEmpty(self).endMillis)
+          self = Chunk.tailNonEmpty(self)
+        }
+      } else if (interval.endMillis < Chunk.headNonEmpty(that).startMillis) {
+        acc = pipe(acc, Chunk.prepend(interval))
+        interval = Chunk.headNonEmpty(that)
+        that = Chunk.tailNonEmpty(that)
+      } else {
+        interval = Interval.make(interval.startMillis, Chunk.headNonEmpty(that).endMillis)
+        that = Chunk.tailNonEmpty(that)
+      }
+    } else {
+      throw new Error(getBugErrorMessage("Intervals.unionLoop"))
+    }
+  }
+  return make(pipe(acc, Chunk.prepend(interval), Chunk.reverse))
+}
+
+/** @internal */
+export const intersect = dual<
+  (that: Intervals.Intervals) => (self: Intervals.Intervals) => Intervals.Intervals,
+  (self: Intervals.Intervals, that: Intervals.Intervals) => Intervals.Intervals
+>(2, (self, that) => intersectLoop(self.intervals, that.intervals, Chunk.empty()))
+
+/** @internal */
+const intersectLoop = (
+  _left: Chunk.Chunk<Interval.Interval>,
+  _right: Chunk.Chunk<Interval.Interval>,
+  _acc: Chunk.Chunk<Interval.Interval>
+): Intervals.Intervals => {
+  let left = _left
+  let right = _right
+  let acc = _acc
+  while (Chunk.isNonEmpty(left) && Chunk.isNonEmpty(right)) {
+    const interval = pipe(Chunk.headNonEmpty(left), Interval.intersect(Chunk.headNonEmpty(right)))
+    const intervals = Interval.isEmpty(interval) ? acc : pipe(acc, Chunk.prepend(interval))
+    if (pipe(Chunk.headNonEmpty(left), Interval.lessThan(Chunk.headNonEmpty(right)))) {
+      left = Chunk.tailNonEmpty(left)
+    } else {
+      right = Chunk.tailNonEmpty(right)
+    }
+    acc = intervals
+  }
+  return make(Chunk.reverse(acc))
+}
+
+/** @internal */
+export const start = (self: Intervals.Intervals): number => {
+  return pipe(
+    self.intervals,
+    Chunk.head,
+    Option.getOrElse(() => Interval.empty)
+  ).startMillis
+}
+
+/** @internal */
+export const end = (self: Intervals.Intervals): number => {
+  return pipe(
+    self.intervals,
+    Chunk.head,
+    Option.getOrElse(() => Interval.empty)
+  ).endMillis
+}
+
+/** @internal */
+export const lessThan = dual<
+  (that: Intervals.Intervals) => (self: Intervals.Intervals) => boolean,
+  (self: Intervals.Intervals, that: Intervals.Intervals) => boolean
+>(2, (self, that) => start(self) < start(that))
+
+/** @internal */
+export const isNonEmpty = (self: Intervals.Intervals): boolean => {
+  return Chunk.isNonEmpty(self.intervals)
+}
+
+/** @internal */
+export const max = dual<
+  (that: Intervals.Intervals) => (self: Intervals.Intervals) => Intervals.Intervals,
+  (self: Intervals.Intervals, that: Intervals.Intervals) => Intervals.Intervals
+>(2, (self, that) => lessThan(self, that) ? that : self)