@clayroach/effect 3.19.14-source-capture.6 → 3.19.14-source-capture.8

package/src/internal/runtimeFlags.ts

@@ -1,188 +0,0 @@
-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 OperationTracing: RuntimeFlags.RuntimeFlag = 1 << 6 as RuntimeFlags.RuntimeFlag
-
-/** @internal */
-export const allFlags: ReadonlyArray<RuntimeFlags.RuntimeFlag> = [
-  None,
-  Interruption,
-  OpSupervision,
-  RuntimeMetrics,
-  WindDown,
-  CooperativeYielding,
-  OperationTracing
-]
-
-const print = (flag: RuntimeFlags.RuntimeFlag) => {
-  switch (flag) {
-    case CooperativeYielding: {
-      return "CooperativeYielding"
-    }
-    case WindDown: {
-      return "WindDown"
-    }
-    case RuntimeMetrics: {
-      return "RuntimeMetrics"
-    }
-    case OpSupervision: {
-      return "OpSupervision"
-    }
-    case OperationTracing: {
-      return "OperationTracing"
-    }
-    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 operationTracing = (self: RuntimeFlags.RuntimeFlags): boolean => isEnabled(self, OperationTracing)
-
-/** @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

@@ -1,103 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,101 +0,0 @@
-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

@@ -1,180 +0,0 @@
-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)