Phryxia

export type DeepKeys<T, K = keyof T, R extends string[] = []> = 
  K extends keyof T ? 
    T[K] extends object ? 
      T[K] extends unknown[] | [unknown, ...unknown[]] ? 
        [...R, K] | [...R, K, KeyOfArrayLike<T[K]>]
      : [...R, K] | [...R, K, ...DeepKeys<T[K], keyof T[K], R>]
    : [...R, K]
  : []

type KeyOfArrayLike<T> = 

Phryxia

type KeyOfArrayLike<T> = 
  T extends [] ?
    never
  : T extends [unknown, ...infer R] ?
    R['length'] | KeyOfArrayLike<R>
  : T extends unknown[] ?
    number
  : never

Phryxia

export type Tree<T, K> = T & {
  id: K
  children: Tree<T, K>[]
}

// Based on KMP algorithm
export function matchTree<T, K>(
  root: Tree<T>,
  prop: (value: Tree<T>) => K,
  selector: K[],

Phryxia

type Remove<R extends unknown[], I extends number, Out extends unknown[] = [], Count extends unknown[] = []>
  = R extends []
    ? Out
    : R extends [infer First, ...infer Rest]
      ? Count['length'] extends I
        ? Remove<Rest, I, Out, [...Count, 0]>
        : Remove<Rest, I, [...Out, First], [...Count, 0]>
      : never

type X = Remove<['a', 'b', 'c'], 1>

Phryxia

type RecursiveArray<T> = (T | RecursiveArray<T>)[]

type UtilizedRecursiveArray<T> = RecursiveArray<T> & {
    get(...indices: number[]): T | RecursiveArray<T>
    set(value: T, ...indices: number[]): T
}

function utilize<T>(rarr: RecursiveArray<T>): UtilizedRecursiveArray<T> {
    const res = rarr as any
    

Phryxia

interface BinaryTrieNode<T> {
    value?: T
    lc?: BinaryTrieNode<T>
    rc?: BinaryTrieNode<T>
}

class BinaryTrie<T> {
    root: BinaryTrieNode<T> = {}

    constructor(public readonly depth: number) {}

Phryxia

export function* combinateWithoutReplacement<T>(candidates: T[]) {
  const indices = candidates.map((_, i) => i)

  yield indices.map((i) => candidates[i])

  const c = indices.map(() => 0)
  let i = 1
  while (i < indices.length) {
    if (c[i] < i) {
      if (i % 2 === 0) {

Phryxia

export function* combinateWithReplacement<T>(candidates: T[], length: number) {
  if (length <= 0) return
  
  for (let i = 0; i < candidates.length ** length; ++i) {
    const result = new Array<T>(length)
    let j = i
    for (let k = length - 1; k >= 0; --k) {
      result[k] = candidates[j % candidates.length]
      j = Math.floor(j / candidates.length)
    }

Phryxia

import { AnchorHTMLAttributes, MouseEvent as ReactMouseEvent, useCallback } from 'react'

const InternalUrlRegexp = /^\.?\//
const StartingDotRegexp = /^\./

export function Anchor({
  children,
  href,
  onClick,
  ...rest

Phryxia

function* permutate<T>(domain: T[], length: number) {
  function* recurse(stack: T[] = [], depth: number = 0): Generator<T[]> {
    if (depth >= length) {
      yield stack.slice()
      return
    }

    for (const element of domain) {
      stack[depth] = element
      yield* recurse(stack, depth + 1)