sstur

type Listener<T extends Array<unknown>> = (...args: T) => void;

export class EventEmitter<
  E extends Record<string, Array<unknown>> = Record<never, []>
> {
  private listenerMap: { [K in keyof E]?: Set<Listener<E[K]>> } = {};

  on<K extends keyof E>(key: K, listener: Listener<E[K]>) {
    return this.addListener(key, listener);
  }

sstur

function toJSON(node) {
  let propFix = { for: 'htmlFor', class: 'className' };
  let specialGetters = {
    style: (node) => node.style.cssText,
  };
  let attrDefaultValues = { style: '' };
  let obj = {
    nodeType: node.nodeType,
  };
  if (node.tagName) {

sstur

type ReqInit = {
  method?: 'PUT' | 'POST';
  headers?: HeadersInit;
  body: Blob | BufferSource | FormData | URLSearchParams | string;
  signal?: AbortSignal;
  onProgress?: (bytesLoaded: number, bytesTotal: number) => void;
};

export function upload(url: string, init: ReqInit) {
  const { signal, onProgress, body } = init;

sstur

Polyfill ReadableStream making it always an async iterator:

ReadableStream.prototype[Symbol.asyncIterator] = function() {
  const reader = this.getReader();
  return {
    next: () => reader.read(),
    return: () => {
      reader.releaseLock();
    },
 };

sstur

import { useRef, useEffect, useCallback } from 'react';

export function useGetLatestValue<T>(value: T): () => T {
  const valueRef = useRef(value);
  useEffect(() => {
    valueRef.current = value;
  }, [value]);
  return useCallback(() => valueRef.current, []);
}

sstur

function createErrorSubclass<T = string>(
  name: string,
  getMessage: (param: T | undefined) => string | undefined = (input) =>
    input === undefined ? undefined : String(input),
  ErrorClass: new () => Error = Error,
) {
  if (!name.endsWith('Error')) {
    throw new Error(`Invalid name "${name}"`);
  }
  return Object.defineProperties(

sstur

export function useStableCallback<T extends Array<unknown>, R>(
  callback: (...args: T) => R,
): (...args: T) => R {
  let ref = useRef(callback);
  useLayoutEffect(() => {
    ref.current = callback;
  });
  let stableCallback = useCallback((...args: T) => {
    return ref.current(...args);
  }, []);

sstur

function clone(obj) {
  if (Object(obj) !== obj) return obj;
  if (typeof obj.toJSON == 'function') {
    return obj.toJSON();
  }
  var type = toString.call(obj).slice(8, -1);
  if (type in CLONE) {
    return CLONE[type].call(obj, clone);
  }
  var copy = {};

sstur

import crypto from 'crypto';

export function getRandomBytes(numBytes: number): Promise<Buffer> {
  return new Promise((resolve, reject) => {
    crypto.randomBytes(numBytes, (error, result) => {
      error ? reject(error) : resolve(result);
    });
  });
}

sstur

function mysql_escape_string(str) {
  return str.replace(/[\0\x08\x09\x1a\n\r"'\\\%]/g, function(ch) {
    switch (ch) {
      case "\0":
        return "\\0";
      case "\x08":
        return "\\b";
      case "\x09":
        return "\\t";
      case "\x1a":