#### Primes

P
```/**
* Implementation of the Sieve of Eratosthenes algorithm.
*
* @param limit An integer _n_ > 1
* @returns All prime numbers from 2 through {@link limit}
*
* @see https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes
*/
export function sieveOfEratosthenes(limit: number): number[] {
if (!Number.isInteger(limit) || limit <= 1) {
throw new Error('limit should be an integer greater than 1')
}

const maybePrime: boolean[] = new Array(limit + 1).fill(true)
for (let i = 2; i * i <= limit; i++) {
if (!maybePrime[i]) continue
for (let j = i * i; j <= limit; j += i) {
maybePrime[j] = false
}
}

const primes: number[] = []
for (let i = 2; i < maybePrime.length; i++) {
if (maybePrime[i]) {
primes.push(i)
}
}

return primes
}

/**
* Generator that yields primes.
*
* Inspired by https://gist.github.com/e-nikolov/cd94db0de2a6b70da144124ae93a6458
*/
export function* primeGenerator() {
type NumberGen = Generator<number, void, any>

function* filter(input: NumberGen, prime: number): NumberGen {
while (true) {
const { done, value } = input.next()
if (done) break
if (value % prime !== 0) yield value
}
}

let chain: NumberGen = (function* () {
let i = 2
while (true) yield i++
})()

while (true) {
const { done, value } = chain.next()
if (done) break
yield value
chain = filter(chain, value)
}
}

/**
* @function isPrime
* @description Determine if given number is prime.
* @param {number} num - A natural number.
* @return {boolean} - Whether the given number is prime.
* @see https://en.wikipedia.org/wiki/Prime_number
* @example isPrime(2) = false
* @example isPrime(3) = true
*/
export const isPrime = (num: number): boolean => {
// raise corresponding errors upon invalid inputs
if (num <= 0 || !Number.isInteger(num)) {
throw new Error('only natural numbers are supported')
}

// handle input being 1
if (num === 1) return false

// iterate from 2 to the square root of num to find a factor
// return false upon finding a factor
for (let i = 2; i <= Math.sqrt(num); i++) {
if (num % i === 0) return false
}

// if the entire loop runs without finding a factor, return true
return true
}
```