slikts

class PairWeakMap<A extends object, B extends object, C> {
  map: WeakMap<A, WeakMap<B, C>>

  constructor() {
    this.map = new WeakMap()
  }

  set(a: A, b: B, c: C): this {
    const { map } = this
    let submap = map.get(a)

slikts

interface Settable<A, B> {
  set(key: A, value: B): this
}

interface Gettable<A, B> {
  get(key: A): B | undefined
}

interface GenericMap<A, B> extends GetSettable<A, B> {
  has(key: A): boolean

slikts

const arraylikeToIterable = <A>(source: ArrayLike<A>): IterableIterator<A> => {
  let i = 0
  return {
    next() {
      let done
      let value
      if (i < source.length) {
        done = false
        value = source[i]
        i += 1

slikts

class Deferred<A> {
  promise: Promise<A>
  constructor() {
    this.promise = new Promise((resolve, reject) => {
      this.resolve = resolve
      this.reject = reject
    })
  }
}
interface Deferred<A> {

slikts

class Deferred<A> {
  promise: Promise<A>
  constructor() {
    this.promise = new Promise((resolve, reject) => {
      this.resolve = resolve
      this.reject = reject
    })
  }
}

slikts

const getState = memoize(<A>(o: AsyncQueue<A>) => {
  const resolvers: Set<Array<(a: A) => void>> = new Set()
  const values: A[] = []
  return {
    resolvers,
    values,
    update() {
      if (values.length === 0) {
        return
      }

slikts

type Box<A> = () => A | null;
type Sealer<A> = {
  seal(value: A): Box<A>;
  unseal(box: Box<A>): A | null;
}
const makeSealer = <A>(): Sealer<A> => {
  let open: Box<A> | null = null;
  return {
    seal(value: A): Box<A> {
      const box = (): A | null => (open === box ? value : null);

slikts

const prime = <A>(iterable: AsyncIterable<A>): AsyncIterator<A> => {
  const iterator = iterable[Symbol.asyncIterator]()
  iterator.next()
  return iterator
}

slikts

const _new = (constructor) => (...args) => constructor.apply(Object.create(constructor.prototype), args)

slikts

const abortError = new Error(`Aborted`)
const promisifySignal = signal =>
  signal.aborted
    ? Promise.reject(abortError)
    : new Promise(
        (_, reject) =>
          void signal.addEventListener(`abort`, () => void reject(abortError), { once: true }),
      )
const sleep = (delay, ...args) => new Promise(resolve => setTimeout(resolve, delay, ...args))
const cancelableSleep = (delay, signal, ...args) =>