qwtel

type Resolver<T> = (value: T | PromiseLike<T>) => void;
type Rejector = (reason?: any) => void;
type ResolvablePromise<T> = Promise<T> & { resolve: Resolver<T>, reject: Rejector }
export function createResolvablePromise<T>(): ResolvablePromise<T> {
  let res: Resolver<T>
  let rej: Rejector;
  const promise = new Promise((r, s) => (res = r, rej = s)) as ResolvablePromise<T>;
  promise.resolve = res;
  promise.reject = rej;
  return promise;

qwtel

import { Base64Encoder, Base64Decoder } from 'base64-encoding';

const PREFIX = 'data:application/octet-stream;base64,';

const b64e = new Base64Encoder();
const b64d = new Base64Decoder();

const encodeKey = (key: string | BufferSource) => typeof key !== 'string' ? PREFIX + b64e.encode(key) : key;
const decodeKey = (key: string) => key.startsWith(PREFIX) ? b64d.decode(key.substr(PREFIX.length)) : key;

qwtel

export async function* streamToAsyncIterable<T>(stream: ReadableStream<T>): AsyncIterableIterator<T> {
  const reader = stream.getReader();
  try {
    while (true) {
      const { done, value } = await reader.read();
      if (done) return;
      yield value;
    }
  } finally { reader.releaseLock() }
}

qwtel

// import { TransformStream } from 'node:stream/web';
import { Buffer } from 'node:buffer';
import { Packr, Unpackr, Options } from 'msgpackr';

export class PackrTransformStream extends TransformStream<any, Uint8Array> {
  constructor(options: Options & { packr?: Packr } = {}) {
    options = { ...options, sequential: true };
    const packr = options.packr || new Packr(options);

    super({