Source: functions.js

  1. import { tag } from "./helpers.js"
  2. import { _Set, Vec } from "./classes.js"
  4. /** @namespace */
  5. const type_checks = {}
  7. /** 
  8.  * **[Global]** Checks if a value is a number or a big int
  9.  * @function
  10.  * @param {any} value Value to check
  11.  * @returns {boolean}
  12.  */
  13. type_checks.isnum = tag({ keep_global: true }, x => typeof x === "number" || typeof x === "bigint")
  15. /** 
  16.  * **[Global]** Same as the built in [Number.isInteger](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger)
  17.  * @function
  18.  * @param {any} value Value to check
  19.  * @returns {boolean}
  20.  */
  21. type_checks.isint = tag({ keep_global: true }, Number.isInteger)
  23. /** 
  24.  * **[Global]** Checks if a value is a string
  25.  * @function
  26.  * @param {any} value Value to check
  27.  * @returns {boolean}
  28.  */
  29. type_checks.isstr = tag({ keep_global: true }, x => typeof x === "string")
  31. /** 
  32.  * **[Global]** Checks if a value is an array (alias for Array.isArray)
  33.  * @function
  34.  * @param {any} value Value to check
  35.  * @returns {boolean}
  36.  */
  37. // Can't use Array.isArray directly because the regex won't pick up on it being niladic
  38. type_checks.isarr = tag({ keep_global: true }, x => Array.isArray(x))
  40. /** 
  41.  * **[Global]** Checks if a value is a boolean
  42.  * @function
  43.  * @param {any} value Value to check
  44.  * @returns {boolean}
  45.  */
  46. type_checks.isbool = tag({ keep_global: true }, x => typeof x === "boolean")
  48. /** 
  49.  * **[Global]** Checks if a value is a function
  50.  * @function
  51.  * @param {any} value Value to check
  52.  * @returns {boolean}
  53.  */
  54. type_checks.isfunc = tag({ keep_global: true }, x => typeof x === "function")
  56. /**
  57.  * **[Global]** Checks if a value is an object
  58.  * @function
  59.  * @param {any} value Value to check
  60.  * @returns {boolean}
  61.  */
  62. type_checks.isobj = tag({ keep_global: true }, x => typeof x === "object")
  64. /** 
  65.  * **[Global]** Gets the type of a value using typeof
  66.  * @function
  67.  * @param {any} value Value to get the type of
  68.  * @returns {boolean}
  69.  */
  70. type_checks.type = tag({ keep_global: true }, x => typeof x)
  72. /** 
  73.  * **[Global]** Checks if a type is iterable
  74.  * @function
  75.  * @param {any} value Value to check
  76.  * @returns {boolean}
  77.  */
  78. type_checks.isiter = tag({ keep_global: true }, x => typeof x[Symbol.iterator] === "function")
  80. /** @namespace */
  81. const type_casts = {}
  83. /**
  84.  * Casts a value to a number using the `Number` constructor. If `value` is a string
  85.  * then a number will be extracted with regex before casting.
  86.  * @param {any} value
  87.  * @returns {number}
  88.  */
  89. type_casts.num = value => {
  90. 	if (type_checks.isstr(value)) {
  91. 		const match = value.match(/-?\d+(\.\d+)?/)[0]
  92. 		return match ? Number(match) : null
  93. 	}
  95. 	return Number(value)
  96. }
  98. /**
  99.  * Casts a value to an integer using parseInt. If `value` is a string an int
  100.  * will be extracted with regex before casting).
  101.  * @param {any} value Value to cast
  102.  * @returns {number}
  103.  */
  104. type_casts.int = value => parseInt(type_casts.num(value))
  106. /**
  107.  * Casts a value to a string. If `value` is an array, it will be joined by "".
  108.  * @param {any} value Value to cast
  109.  */
  110. type_casts.str = value => {
  111. 	const str = value?.toString()
  113. 	if (str === null) return "null"
  114. 	if (str === undefined) return "undefined"
  115. 	if (value instanceof Vec)
  116. 		return `Vec(${value.x}, ${value.y})`
  117. 	if (type_checks.isarr(value))
  118. 		return value.join("")
  119. 	if (type_checks.isobj(value))
  120. 		return str === "[object Object]" ? JSON.stringify(value) : str
  122. 	return str
  123. }
  125. /**
  126.  * Casts a value to an array. If `value` is a number, an array of length `value`
  127.  * will be created
  128.  * @param {any} value Value to cast
  129.  * @returns {Array}
  130.  */
  131. type_casts.arr = value => {
  132. 	if (type_checks.isnum(value)) return Array(value)
  133. 	if (type_checks.isiter(value)) return [...value]
  134. 	return Array.from(value)
  135. }
  137. /**
  138.  * Casts a value to a boolean (alias for Boolean constructor)
  139.  * @param {any} value Value to cast
  140.  * @returns {boolean}
  141.  */
  142. type_casts.bool = value => Boolean(value)
  144. /** @namespace */
  145. const math_utils = {}
  147. /** 
  148.  * Casts `a` and `b` using `Number` constructor, then adds them using `+` operator
  149.  * @param {number} a
  150.  * @param {number} b
  151.  * @return {number}
  152.  */
  153. math_utils.add = (a, b) => Number(a) + Number(b)
  155. /** 
  156.  * Casts `a` and `b` using `Number` constructor, then subtracts them using `-` operator
  157.  * @param {number} a
  158.  * @param {number} b
  159.  * @return {number}
  160.  */
  161. math_utils.sub = (a, b) => Number(a) - Number(b)
  163. /** 
  164.  * Casts `a` and `b` using `Number` constructor, then multiplies them using `*` operator
  165.  * @param {number} a
  166.  * @param {number} b
  167.  * @return {number}
  168.  */
  169. math_utils.mul = (a, b) => Number(a) * Number(b)
  171. /** 
  172.  * Casts `a` and `b` using `Number` constructor, then divides them using `/` operator
  173.  * @param {number} a
  174.  * @param {number} b
  175.  * @return {number}
  176.  */
  177. math_utils.div = (a, b) => Number(a) / Number(b)
  179. /** 
  180.  * Casts `a` and `b` using `Number` constructor, then calculates `a % b` 
  181.  * (note: this is not true modulo, just remainder after division)
  182.  * @param {number} a
  183.  * @param {number} b
  184.  * @return {number}
  185.  */
  186. math_utils.mod = (a, b) => Number(a) % Number(b)
  188. /** 
  189.  * Calculates `b ** m` (optionally modulo `m`)
  190.  * @param {number} b
  191.  * @param {number} e
  192.  * @param {number} [m]
  193.  * @return {number}
  194.  */
  195. math_utils.exp = (b, e, m = null) => {
  196. 	if (m) {
  197. 		// naive solution but it does the job
  198. 		if (m == 1) return 0
  199. 		let ret = 1
  200. 		for (let i = 0; i < e; i++)
  201. 			ret = (ret * b) % m
  202. 		return ret
  203. 	} else return b ** e
  204. }
  206. /**
  207.  * Returns the absolute difference between `a` and `b`
  208.  * @param {number} a
  209.  * @param {number} b
  210.  * @return {number}
  211.  */
  212. math_utils.absdiff = (a, b) => Math.abs(a - b)
  214. /**
  215.  * Checks if `a` is greater than `b`
  216.  * @param {number} a
  217.  * @param {number} b
  218.  * @returns {boolean}
  219.  */
  220. math_utils.gt = (a, b) => a > b
  222. /**
  223.  * Checks if `a` is less than `b`
  224.  * @param {number} a
  225.  * @param {number} b
  226.  * @returns {boolean}
  227.  */
  228. math_utils.lt = (a, b) => a < b
  230. /**
  231.  * Checks if `a` is greater than or equal to `b`
  232.  * @param {number} a
  233.  * @param {number} b
  234.  * @returns {boolean}
  235.  */
  236. math_utils.gte = (a, b) => a >= b
  238. /**
  239.  * Checks if `a` is less than or equal to `b`
  240.  * @param {number} a
  241.  * @param {number} b
  242.  * @returns {boolean}
  243.  */
  244. math_utils.lte = (a, b) => a <= b
  246. /**
  247.  * Checks if `n` is odd
  248.  * @param {number} n
  249.  * @returns {boolean}
  250.  */
  251. math_utils.odd = n => n % 2 === 1
  253. /**
  254.  * Checks if `n` is even
  255.  * @param {number} n
  256.  * @returns {boolean}
  257.  */
  258. math_utils.even = n => n % 2 === 0
  260. /**
  261.  * Calculates the absolute value of `n`
  262.  * @param {number} n
  263.  * @returns {number}
  264.  */
  265. math_utils.abs = n => Math.abs(n)
  267. /**
  268.  * Calculates the square root of `n`
  269.  * @param {number} n
  270.  * @returns {number}
  271.  */
  272. math_utils.sqrt = n => Math.sqrt(n)
  274. /**
  275.  * Calculates the sign of `n`
  276.  * @param {number} n
  277.  * @returns {number}
  278.  */
  279. math_utils.sign = n => Math.sign(n)
  281. /**
  282.  * Rounds `n` down to the nearest integer
  283.  * @param {number} n
  284.  * @returns {number}
  285.  */
  286. math_utils.floor = n => Math.floor(n)
  288. /**
  289.  * Rounds `n` up to the nearest integer
  290.  * @param {number} n
  291.  * @returns {number}
  292.  */
  293. math_utils.ceil = n => Math.ceil(n)
  295. /**
  296.  * Rounds `n` to the nearest integer
  297.  * @param {number} n
  298.  * @returns {number}
  299.  */
  300. math_utils.round = n => Math.round(n)
  302. /**
  303.  * Wraps `index` around `length` (for indexing into to arrays, strings, etc.)
  304.  * @param {number} index
  305.  * @param {number} length
  306.  * @returns {number}
  307.  */
  308. math_utils.wrapindex = (index, length) => (index % length + length) % length
  310. /**
  311.  * Clamps `n` between `min` and `max`
  312.  * @param {number} n
  313.  * @param {number} min
  314.  * @param {number} max
  315.  * @returns {number}
  316.  */
  317. math_utils.clamp = (n, min, max) => Math.min(Math.max(n, min), max)
  319. /**
  320.  * Checks if `n` is in the range [`min`, `max`] (inclusive)
  321.  * @param {number} n
  322.  * @param {number} min
  323.  * @param {number} max
  324.  * @returns {boolean}
  325.  */
  326. math_utils.inrange = (n, min, max) => n >= min && n <= max
  328. /**
  329.  * Calculates the minimum of an iterable using the builtin [Math.min](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/min)
  330.  * @param {Iterable.<*>} iter The iterable to find the minimum of
  331.  * @returns {number}
  332.  * @example min([2, 1, 3]) // 1
  333.  */
  334. math_utils.min = iter => Math.min(...iter)
  337. /**
  338.  * Calculates the maximum of an iterable using the builtin [Math.max](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/max)
  339.  * @param {Iterable.<*>} iter The iterable to find the maximum of
  340.  * @returns {number}
  341.  * @example max([2, 1, 3]) // 3
  342.  */
  343. math_utils.max = iter => Math.max(...iter)
  345. /**
  346.  * Functions which operate on iterable types
  347.  * @namespace
  348.  */
  349. const iter_utils = {}
  351. /**
  352.  * Gets the first `n` elements of an iterable value and returns them in an array
  353.  * @template T
  354.  * @param {Iterable.<T>} iter The iterable to get elements from
  355.  * @param {number} n The number of elements to get
  356.  * @returns {T[]}
  357.  */
  358. iter_utils.firstn = (iter, n) => [...iter].slice(0, n)
  360. /**
  361.  * Gets the last `n` elements of an iterable value and returns them in an array
  362.  * @template T
  363.  * @param {Iterable.<T>} iter The iterable to get elements from
  364.  * @param {number} n The number of elements to get
  365.  * @returns {T[]}
  366.  */
  367. iter_utils.lastn = (iter, n) => !n ? [] : [...iter].slice(-n)
  369. /**
  370.  * Gets the first element of an iterable value
  371.  * @param {Iterable.<*>} iter The iterable to get the first element from
  372.  * @returns {any}
  373.  */
  374. iter_utils.first = iter => [...iter][0]
  376. /**
  377.  * Gets the last element of an iterable value
  378.  * @param {Iterable.<*>} iter The iterable to get the last element from
  379.  * @returns {any}
  380.  */
  381. iter_utils.last = iter => {
  382. 	const array = [...iter]
  383. 	return array[array.length - 1]
  384. }
  386. /**
  387.  * Removes the nth element from an iterable value
  388.  * @template T
  389.  * @param {Iterable.<T>} iter The iterable to remove an element from
  390.  * @param {number} index The index of the element to remove
  391.  * @returns {T[]} The resulting array
  392.  */
  393. iter_utils.dropnth = (iter, index) => {
  394. 	const array = [...iter]
  395. 	array.splice(math_utils.wrapindex(index, array.length), 1)
  396. 	return array
  397. };
  399. /**
  400.  * Sums the elements of an iterable value
  401.  * @param {Iterable.<*>} iter The iterable to sum
  402.  * @returns {number|string}
  403.  */
  404. iter_utils.sum = iter => [...iter].reduce((acc, cur) => acc + cur)
  406. /**
  407.  * Calculates the product of all values in an iterable
  408.  * @param {Iterable.<*>} iter The iterable
  409.  * @returns {number}
  410.  */
  411. iter_utils.prod = iter => [...iter].reduce((acc, cur) => acc * cur)
  413. /**
  414.  * Reverses the elements of an iterable (not in place)
  415.  * @template T
  416.  * @param {Iterable.<T>} iter The iterable to reverse
  417.  * @returns {T[]} The reversed array
  418.  */
  419. iter_utils.rev = iter => [...iter].reverse()
  421. /**
  422.  * **[Global]** Zips multiple iterable into a single array of arrays, each
  423.  * containing a single element from each iterable. The result will only be as
  424.  * long as the shortest input.
  425.  * @template T
  426.  * @function
  427.  * @param {...Iterable.<T[]>} iters The iterables to zip
  428.  * @returns {T[][]}
  429.  * @example zip([1, 2, 3], [4, 5, 6]) // [[1, 4], [2, 5], [3, 6]]
  430.  * @example zip([1, 2]) // [[1], [2]]
  431.  */
  432. iter_utils.zip = tag({ keep_global: true }, (...iters) => {
  433. 	if (!iters.length) return [];
  435. 	const smallest = Math.min(...iters.map(x => x.length))
  436. 	const ret = [];
  438. 	for (let i = 0; i < smallest; i++) {
  439. 		ret.push(iters.map(x => x[i]));
  440. 	}
  442. 	return ret;
  443. })
  445. /**
  446.  * Creates a new {@link _Set} from an iterable. Same as {@link constructors.set}.
  447.  * @param {Iterable.<*>} iter The iterable to create a set from
  448.  * @returns {_Set}
  449.  */
  450. iter_utils.uniq = iter => new _Set(iter)
  452. /**
  453.  * Sorts an iterable given a comparison function (same as [Array.sort](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort))
  454.  * but not in place
  455.  * @template T
  456.  * @param {Iterable.<T>} iter The iterable to sort
  457.  * @param {function(T, T): number} compare_fn The comparison function
  458.  * @returns {T[]} The sorted array
  459.  */
  460. iter_utils.sorted = (iter, compare_fn) => [...iter].sort(compare_fn)
  462. /**
  463.  * Sorts an iterable (of numbers) in ascending order
  464.  * @template T
  465.  * @param {Iterable.<T>} iter The iterable to sort
  466.  * @returns {T[]} The sorted array
  467.  */
  468. iter_utils.nsort = iter => [...iter].sort((a, b) => a - b)
  470. /**
  471.  * Sorts an iterable (of numbers) in descending order
  472.  * @param {Iterable.<*>} iter The iterable to sort
  473.  * @returns {T[]} The sorted array
  474.  */
  475. iter_utils.rsort = iter => [...iter].sort((a, b) => b - a)
  477. /**
  478.  * Sorts an iterable in ascending order by the result of applying a given
  479.  * function to each element
  480.  * @template T
  481.  * @param {Iterable.<T>} iter The iterable to sort
  482.  * @param {function(T)} func The function to apply to each element
  483.  * @returns {T[]} The sorted array
  484.  */
  485. iter_utils.sortby = (iter, func) => iter.sort((a, b) => func(a) - func(b))
  487. /**
  488.  * Sorts an iterable in descending order by the result of applying a given
  489.  * function to each element
  490.  * @template T
  491.  * @param {Iterable.<T>} iter The iterable to sort
  492.  * @param {function(T)} func The function to apply to each element
  493.  * @returns {T[]} The sorted array
  494.  */
  495. iter_utils.rsortby = (iter, func) => iter.sort((a, b) => func(b) - func(a))
  497. /** 
  498.  * Same as the built in [Array.forEach](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach)
  499.  * @template T
  500.  * @param {Iterable.<T>} iter The iterable to iterate over
  501.  * @param {function(T, number, Iterable.<T>)} callback The callback to call for each element (see the MDN link for more info)
  502.  * @returns {Iterable.<T>} The original iterable
  503.  */
  504. iter_utils.for = (iter, callback) => {
  505. 	[...iter].forEach(callback)
  506. 	return iter
  507. }
  509. /** 
  510.  * Same as the built in [Array.forEach](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach)
  511.  * @function
  512.  * @template T
  513.  * @param {Iterable.<T>} iter The iterable to iterate over
  514.  * @param {function(T, number, Iterable.<T>)} callback The callback to call for each element (see the MDN link for more info)
  515.  * @returns {Iterable.<T>} The original iterable
  516.  */
  517. iter_utils.each = iter_utils.for
  519. /**
  520.  * Same as the built in [Math.min](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/min)
  521.  * but it takes an iterable as a single argument
  522.  * @param {Iterable.<*>} iter The iterable to find the minimum of
  523.  * @returns {number}
  524.  */
  525. iter_utils.min = iter => Math.min(...iter)
  527. /**
  528.  * Same as the built in [Math.max](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/max)
  529.  * but it takes an iterable as a single argument
  530.  * @param {Iterable.<*>} iter The iterable to find the maximum of
  531.  * @returns {number}
  532.  */
  533. iter_utils.max = iter => Math.max(...iter)
  535. /**
  536.  * Same as the built in [Array.push](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push)
  537.  * @template T
  538.  * @param {T[]} array The array to append to
  539.  * @param {...T} items The items to append
  540.  * @returns {T[]} The resulting array
  541.  */
  542. iter_utils.append = (array, ...items) => (array.push(...items), array)
  544. /**
  545.  * Same as the built in [Array.unshift](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/unshift)
  546.  * @template T
  547.  * @param {T[]} array The array to prepend to
  548.  * @param {...T} items The items to prepend
  549.  * @returns {T[]} The resulting array
  550.  */
  551. iter_utils.prepend = (array, ...items) => (array.unshift(...items), array)
  553. /**
  554.  * Checks if all items in an iterable are equal
  555.  * @param {Iterable.<*>} iter The iterable to check
  556.  * @returns {boolean}
  557.  */
  558. iter_utils.alleq = iter => {
  559. 	const array = [...iter]
  560. 	return array.every(item => misc_utils.eq(item, array[0]))
  561. }
  563. /**
  564.  * Creates a list of sublists of length `size` each of which is a sliding
  565.  * window looking into `iter` starting at index `0` moving along by 1 each
  566.  * time. If `loop` is true, there will be some extra windows at the end which
  567.  * wrap around to the start.
  568.  * @template T
  569.  * @param {Iterable.<T[]>} iter The iterable to create sliding windows from
  570.  * @param {number} size The size of the sliding window
  571.  * @param {boolean} [wrap=false] Whether to include windows that wrap around
  572.  * @returns {T[][]}
  573.  * @example [1, 2, 3, 4, 5].sliding(3) // [[1, 2, 3], [2, 3, 4], [3, 4, 5]]
  574.  * @example [1, 2, 3].sliding(2, true) // [[1, 2], [2, 3], [3, 1]]
  575.  */
  576. iter_utils.sliding = (iter, size = 2, wrap = false) => {
  577. 	const array = [...iter]
  578. 	if (array.length < size) return []
  579. 	const x = wrap ? array.concat(array.slice(0, size - 1)) : array
  580. 	return x.slice(0, -size + 1).map((_, i) => x.slice(i, i + size))
  581. }
  583. /**
  584.  * Creates a list of contiguous non-overlapping chunks of `iter`, each of
  585.  * length `size`
  586.  * @template T
  587.  * @param {Iterable.<*>} iter The iterable to create chunks from
  588.  * @param {number} [size=2] The size of each chunk
  589.  * @returns {T[][]}
  590.  * @example [1, 2, 3, 4, 5, 6].chunks() // [[1, 2], [3, 4], [5, 6]]
  591.  * @example [1, 2, 3, 4, 5, 6].chunks(3) // [[1, 2, 3], [4, 5, 6]]
  592.  */
  593. iter_utils.chunks = (iter, size = 2) => {
  594. 	const ret = []
  595. 	for (let i = 0; i < iter.length; i += size) {
  596. 		ret.push(iter.slice(i, i + size))
  597. 	}
  598. 	return ret
  599. }
  601. /**
  602.  * Swaps the elements at indices `index_a` and `index_b` in `array`. Only works
  603.  * on arrays so that it can be done in place.
  604.  * @template T
  605.  * @param {T[]} array The array to swap elements in
  606.  * @param {number} index_a The index of the first element to swap
  607.  * @param {number} index_b The index of the second element to swap
  608.  * @returns {T[]} The resulting array
  609.  */
  610. iter_utils.swap = (array, index_a, index_b) => {
  611. 	[array[index_a], array[index_b]] = [array[index_b], array[index_a]]
  612. 	return array
  613. }
  615. /**
  616.  * Generates all permutations of an iterable
  617.  * @template T
  618.  * @param {Iterable.<T>} iter
  619.  * @returns {T[][]}
  620.  */
  621. iter_utils.perms = iter => {
  622. 	const array = [...iter]
  623. 	if (!array.length) return []
  625. 	const output = []
  627. 	const generate = (k, array) => {
  628. 		if (k === 1) {
  629. 			output.push(array.slice())
  630. 			return
  631. 		}
  633. 		generate(k - 1, array)
  635. 		for (let i = 0; i < k - 1; i++) {
  636. 			if (k % 2 === 0) iter_utils.swap(array, i, k - 1)
  637. 			else iter_utils.swap(array, 0, k - 1)
  638. 			generate(k - 1, array)
  639. 		}
  640. 	}
  642. 	generate(array.length, array)
  643. 	return output
  644. }
  646. /**
  647.  * Return a list with every `n`th element of `iter` starting at index `start`
  648.  * @template T
  649.  * @param {Iterable.<T>} iter The iterable to get elements from
  650.  * @param {number} n The step size
  651.  * @param {number} [start=0] The starting index
  652.  * @returns {T[]}
  653.  */
  654. iter_utils.everynth = (iter, n, start = 0) => {
  655. 	const ret = [];
  656. 	for (let i = start; i < iter.length; i += n)
  657. 		ret.push(iter[i])
  658. 	return ret
  659. }
  661. /**
  662.  * Gets the element at `index` in `iter`. Indices wrap around using
  663.  * {@link math_utils.wrapindex}. If `index` is a {@link Vec}, `iter` will be
  664.  * treated as a grid, or if `index` is a list of integers, a list of elements
  665.  * at those indices will be returned.
  666.  * @function
  667.  * @template T
  668.  * @param {Iterable.<T|Iterable.<T>>} iter The iterable to get elements from
  669.  * @param {number|Vec|number[]} index The index/indicies to get
  670.  * @returns {T}
  671.  */
  672. iter_utils.at = tag({ attach_to: [Array] }, (iter, index) => {
  673. 	const array = [...iter]
  675. 	if (type_checks.isint(index)) {
  676. 		return array[math_utils.wrapindex(index, array.length)];
  677. 	} else if (index instanceof Vec) {
  678. 		return iter?.[index.y]?.[index.x]
  679. 	} else if (type_checks.isarr(index) && index.every(type_checks.isint)) {
  680. 		return index.map(i => iter_utils.at(array, i));
  681. 	} else {
  682. 		throw new Error(`Invalid index/indicies ${JSON.stringify(index)}`);
  683. 	}
  684. })
  686. const count = (iter, value, string_like_match = false, overlapping = false) => {
  687. 	const array = [...iter]
  688. 	if (typeof value === "function") return array.filter(value).length
  690. 	string_like_match = type_checks.isstr(iter) || string_like_match
  692. 	if (type_checks.isiter(value) && string_like_match) {
  693. 		const to_find = [...value]
  694. 		let count = 0
  696. 		for (let i = 0; i < array.length;) {
  697. 			if (misc_utils.eq(array.slice(i, i + to_find.length), to_find)) {
  698. 				count++
  699. 				i += overlapping ? 1 : to_find.length
  700. 			} else i++
  701. 		}
  703. 		return count
  704. 	}
  706. 	return array.filter(x => misc_utils.eq(x, value)).length
  707. }
  709. /**
  710.  * Counts the number of times `value` appears in `iter`. If `value` is a
  711.  * function, it's will do the same as `.filter(f).length`, if `iter` is a
  712.  * string or `string_like_match` is explicitly set to `true`, `["a", "b"]` will
  713.  * match `abcd` or ["a", "b", "c", "d"] as well as something like 
  714.  * ["arstneio", ["a", "b], 4].
  715.  * @param {Iterable.<*>} iter The iterable to count values in
  716.  * @param {any} value The value to count
  717.  * @param {boolean} [string_like_match=false] (See description)
  718.  * @returns {number}
  719.  * @example [4, 2, 3, 1, 2].count(2) // 2
  720.  * @example "abababa".count("aba") // 2
  721.  * @example [3, 2, 1, 2, 1].count([2, 1]) // 0
  722.  * @example [3, 2, 1, 2, 1].count([2, 1], true) // 2
  723.  */
  724. iter_utils.count = (...args) => count(...args)
  726. /**
  727.  * Same as `iter_utils.count` but counts overlapping matches
  728.  * @param {Iterable.<*>} iter The iterable to count values in
  729.  * @param {any} value The value to count
  730.  * @param {boolean} [string_like_match=false] (See description)
  731.  * @returns {number}
  732.  * @example "abababa".countol("aba") // 3
  733.  * @example [1, 2, 1, 2, 1].countol([1, 2, 1]) // 2
  734.  */
  735. iter_utils.countol = (iter, value, string_like_match = false) => count(iter, value, string_like_match, true)
  737. /**
  738.  * Same as the built in [Array.filter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)
  739.  * but inverted. For consistency with builtins like `Array.filter` and `Array.map` which _don't_ work on any iterable. This must also be called on an array.
  740.  * @template T
  741.  * @param {T[]} array The iterable to filter
  742.  * @param {function(T): boolean} filter_fn The filter function
  743.  * @returns {T[]}
  744.  */
  745. iter_utils.filterout = (array, filter_fn) => array.filter((...args) => !filter_fn(...args))
  747. /**
  748.  * Checks if there are no elements in `array` that satisfy `fn`. `fn` is passed
  749.  * to the built in [Array.some](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some)
  750.  * so refer to those docs if needed.
  751.  * @template T
  752.  * @param {T[]} array The array to check
  753.  * @param {function(T, number, T[]): boolean} fn The function to check
  754.  * @returns {boolean}
  755.  */
  756. iter_utils.none = (array, fn) => !array.some(fn)
  758. /**
  759.  * Gets the differences between consecutive elements of an iterable
  760.  * @param {Iterable.<number>} iter The iterable to get deltas from
  761.  * @returns {number[]}
  762.  * @example [1, 2, 9, -4].deltas // [1, 7, -13]
  763.  */
  764. iter_utils.deltas = iter => {
  765. 	const array = [...iter];
  767. 	if (array.length <= 1) return [];
  769. 	const ret = [];
  770. 	for (let i = 0; i < array.length - 1; i++) {
  771. 		ret.push(array[i + 1] - array[i]);
  772. 	}
  773. 	return ret;
  774. }
  776. /**
  777.  * Splits an iterable into `n` pieces. Rounds up if the split is uneven.
  778.  * @template T
  779.  * @param {Iterable.<T>} iter The iterable to split
  780.  * @param {number} n The number of pieces to split into
  781.  * @returns {T[][]}
  782.  * @example [1, 2, 3, 4, 5, 6].pieces(3) // [[1, 2], [3, 4], [5, 6]]
  783.  * @example [1, 2, 3].pieces(2) // [[1, 2], [3]]
  784.  */
  785. iter_utils.pieces = (iter, n) => {
  786. 	if (n <= 0) return []
  787. 	const array = [...iter], ret = [], step = Math.ceil(array.length / n);
  788. 	for (let i = 0; i < array.length; i += step) {
  789. 		ret.push(array.slice(i, i + step))
  790. 	}
  791. 	return ret
  792. }
  794. /**
  795.  * Returns list of indices where the function `fn` returns true. `fn` receives
  796.  * the value, index and the iterable as arguments, in that order.
  797.  * @template T
  798.  * @param {Iterable.<T>} iter
  799.  * @param {function(T, number, Iterable.<T>): boolean} fn
  800.  * @returns {number[]}
  801.  * @example [1, 2, 3, 4, 5].iwhere(x => x % 2 === 0) // [1, 3]
  802.  */
  803. iter_utils.iwhere = (iter, fn) => [...iter]
  804. 	.map((value, index) => [value, index])
  805. 	.filter(([value, index]) => fn(value, index, iter))
  806. 	.map(([, index]) => index)
  808. /**
  809.  * Returns a list of sublists containing consecutive elements of `iter`
  810.  * @template T
  811.  * @param {Iterable.<T>} iter The iterable to group
  812.  * @returns {T[][]}
  813.  */
  814. iter_utils.seqs = iter => {
  815. 	const ret = []
  816. 	for (const value of iter) {
  817. 		if (ret[ret.length - 1]?.[ret[ret.length - 1].length - 1] === value) {
  818. 			ret[ret.length - 1].push(value)
  819. 		} else {
  820. 			ret.push([value])
  821. 		}
  822. 	}
  823. 	return ret
  824. }
  826. /**
  827.  * Checks if an iterable includes a value. Uses {@link iter_utils.count}.
  828.  * @template T
  829.  * @param {Iterable.<T>} iter The iterable to check
  830.  * @param {T} value The value to check for
  831.  * @param {number} [start_index=0] The index to start checking from
  832.  * @returns {boolean}
  833.  */
  834. iter_utils.includes = tag({ attach_to: [Array] }, (iter, value, start_index) => {
  835. 	if (typeof iter === "string") return iter.includes(value, start_index)
  836. 	return [...iter].filter(x => misc_utils.eq(x, value)).length > 0
  837. })
  840. /** Alias for {@link iter_utils.includes}
  841.  * @template T
  842.  * @param {Iterable.<T>} iter The iterable to check
  843.  * @param {T} value The value to check for
  844.  * @param {number} [start_index=0] The index to start checking from
  845.  * @returns {boolean}
  846.  */
  847. iter_utils.incl = iter_utils.includes
  849. /**
  850.  * Deep flattens an iterable
  851.  * @template T
  852.  * @param {Iterable.<T>} iter The iterable to flatten
  853.  * @returns {T[]}
  854.  * @example [[1, [2]], [[[[3, [4, 5]]]]], 6].flat // [1, 2, 3, 4, 5, 6]
  855.  */
  856. iter_utils.flat = iter => [...iter].flat(Infinity)
  858. /**
  859.  * Flattens an iterable to a certain depth. Alias for the builtin [Array.flat](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flat).
  860.  * @template T
  861.  * @param {Iterable.<T>} iter The iterable to flatten
  862.  * @param {number} [depth=1] The depth to flatten to
  863.  * @returns {T[]}
  864.  */
  865. iter_utils.nflat = (iter, depth = 1) => [...iter].flat(depth)
  867. /** @namespace */
  868. const string_utils = {}
  870. /**
  871.  * Splits a string into an array of characters
  872.  * @param {string} str The string to split
  873.  * @returns {string[]}
  874.  */
  875. string_utils.chars = str => str.split("")
  877. /**
  878.  * Splits a string on spaces and trims each word
  879.  * @param {string} str The string to split
  880.  * @returns {string[]}
  881.  */
  882. string_utils.words = str => str.split(" ").map(s => s.trim())
  884. /**
  885.  * Splits a string on "\n"
  886.  * @param {string} str The string to split
  887.  * @returns {string[]}
  888.  */
  889. string_utils.lines = str => str.split("\n")
  891. /**
  892.  * Splits a string on "\n\n"
  893.  * @param {string} str The string to split
  894.  * @returns {string[]}
  895.  */
  896. string_utils.groups = str => str.split("\n\n")
  898. /**
  899.  * Splits a string on commas and trims each element
  900.  * @param {string} str The string to split
  901.  * @returns {string[]}
  902.  */
  903. string_utils.csv = str => str.split(",").map(s => s.trim())
  905. /**
  906.  * Checks if a character is a digit
  907.  * @param {string} char The character to check
  908.  * @returns {boolean}
  909.  */
  910. string_utils.isdigit = char => /^\d$/.test(char)
  912. /**
  913.  * Extracts all integers from a string and returns them in an array
  914.  * @param {string} str The string to extract integers from
  915.  * @returns {number[]}
  916.  */
  917. string_utils.ints = str => str.match(/-?\d+/g).map(type_casts.int)
  919. /**
  920.  * Extracts all numbers from a string and returns them in an array
  921.  * @param {string} str The string to extract numbers from
  922.  * @returns {number[]}
  923.  */
  924. string_utils.nums = str => str.match(/\d+(\.\d+)?/g).map(type_casts.num)
  926. /**
  927.  * Gets the ASCII code a character
  928.  * @param {string} char The character to get the code of
  929.  * @returns {number}
  930.  */
  931. string_utils.chcode = char => char.charCodeAt(0)
  933. /**
  934.  * Converts a string to upper case
  935.  * @param {string} str The string to convert
  936.  * @returns {string}
  937.  */
  938. string_utils.upper = str => str.toUpperCase()
  940. /**
  941.  * Converts a string to lower case
  942.  * @param {string} str The string to convert
  943.  * @returns {string}
  944.  */
  945. string_utils.lower = str => str.toLowerCase()
  947. /** @namespace */
  948. const logic_utils = {}
  950. /**
  951.  * Returns `a && b`. I.e. if `a` is truthy it returns `b`, otherwise it short
  952.  * circuits and returns `a`
  953.  * @param {any} a
  954.  * @param {any} b
  955.  * @returns {any}
  956.  */
  957. logic_utils.and = (a, b) => a && b
  959. /**
  960.  * Returns `a || b`. I.e. if `a` is truthy it short circuits and returns `a`,
  961.  * otherwise it returns `b`
  962.  * @param {any} a
  963.  * @param {any} b
  964.  * @returns {any}
  965.  */
  966. logic_utils.or = (a, b) => a || b
  968. /**
  969.  * Returns logical NOT of `a`
  970.  * @param {any} a
  971.  * @returns {boolean}
  972.  */
  973. logic_utils.not = a => !a
  975. /**
  976.  * Returns logical XOR of `a` and `b`. I.e. returns true if exactly one of `a`
  977.  * and `b` are truthy, otherwise returns false
  978.  * @param {any} a
  979.  * @param {any} b
  980.  * @returns {boolean}
  981.  */
  982. logic_utils.xor = (a, b) => !!(!a ^ !b)
  984. /** @namespace */
  985. const grid_utils = {}
  987. /**
  988.  * Creates a grid from a string where each row is separated by a newline and
  989.  * each cell is seperated by `delim`.
  990.  * @param {string} str The string to create a grid from
  991.  * @param {string} delim The delimiter to split cells by
  992.  * @returns {string[][]}
  993.  */
  994. grid_utils.gridd = (str, delim) => str.trim().split("\n").filter(x => x).map(row => row.split(delim).filter(x => x))
  996. /**
  997.  * Calls with {@link grid_utils.gridd} with an empty delimiter
  998.  * @param {string} str The string to create a grid from
  999.  * @returns {string[][]}
  1000.  */
  1001. grid_utils.grid = str => grid_utils.gridd(str, "")
  1003. /**
  1004.  * Uses {@link grid_utils.grid} then maps each cell to a number
  1005.  * @param {string} str The string to create a grid from
  1006.  * @returns {number[][]}
  1007.  */
  1008. grid_utils.digitgrid = str => grid_utils.grid(str).map(row => row.map(cell => +cell))
  1010. /**
  1011.  * Maps a function over each cell in a grid
  1012.  * @template T
  1013.  * @template K
  1014.  * @param {T[][]} grid The grid to map over
  1015.  * @param {function(T, Vec, T[][]): K} fn The function to map
  1016.  * @returns {K[][]}
  1017.  */
  1018. grid_utils.gmap = (grid, fn) => grid.map((row, y) => row.map((cell, x) => fn(cell, new Vec(x, y), grid)))
  1020. /**
  1021.  * Finds {@link Vec}s in a grid which satisfy the given function
  1022.  * @template T
  1023.  * @param {T[][]} grid The grid to search
  1024.  * @param {function(T, Vec, T[][]): boolean} fn The function to filter with
  1025.  * @returns {Vec[]}
  1026.  */
  1027. grid_utils.vecswhere = (grid, fn) => grid.flatMap(
  1028. 	(row, y) => row
  1029. 		.map((cell, x) => [cell, new Vec(x, y)])
  1030. 		.filter(args => fn(...args, grid))
  1031. 		.map(([, vec]) => vec)
  1032. )
  1034. /**
  1035.  * Rotates a grid 90 degrees clockwise `times` times
  1036.  * @param {T[][]} grid The grid to rotate
  1037.  * @param {number} [times=1] The number of times to rotate
  1038.  * @returns {T[][]}
  1039.  */
  1040. grid_utils.nrotate = (grid, times = 1) => {
  1041. 	if (!grid.length) return []
  1042. 	let ret = grid.map(row => row.slice())
  1043. 	for (let i = 0; i < times; i++) {
  1044. 		ret = ret[0].map((_, i) => ret.map(row => row[i]).reverse())
  1045. 	}
  1046. 	return ret
  1047. }
  1049. /**
  1050.  * Rotates a grid 90 degrees clockwise once (alias for `grid_utils.nrotate(grid, 1)`)
  1051.  * @param {T[][]} grid The grid to rotate
  1052.  * @returns {T[][]}
  1053.  */
  1054. grid_utils.rotate = grid => grid_utils.nrotate(grid, 1)
  1056. /**
  1057.  * Gets diagonals of a grid (top right to bottom left). Assumes the grid is rectangular.
  1058.  * @param {T[][]} grid The grid to get diagonals from
  1059.  * @returns {T[][]}
  1060.  * @example diagonals([
  1061.  *     [1, 2, 3],
  1062.  *     [4, 5, 6],
  1063.  *     [7, 8, 9]
  1064.  * ]) // [[1], [2, 4], [3, 5, 7], [6, 8], [9]]
  1065.  */
  1066. grid_utils.diagonals = grid => {
  1067. 	const ret = []
  1069. 	for (let r = 0; r < grid.length; r++) {
  1070. 		for (let c = 0; c < grid[0].length; c++) {
  1071. 			ret[r + c] ??= []
  1072. 			ret[r + c].push(grid[r][c])
  1073. 		}
  1074. 	}
  1076. 	return ret
  1077. }
  1079. /**
  1080.  * Gets diagonals of a grid in the other direction to {@link grid_utils.diagonals}
  1081.  * (so top left to bottom right). Assumes the grid is rectangular.
  1082.  * @param {T[][]} grid The grid to get diagonals from
  1083.  * @returns {T[][]}
  1084.  * @example antidiagonals([
  1085.  *     [1, 2, 3],
  1086.  *     [4, 5, 6],
  1087.  *     [7, 8, 9]
  1088.  * ]) // [[3], [2, 6], [1, 5, 9], [4, 8], [7]]
  1089.  */
  1090. grid_utils.antidiagonals = grid => {
  1091. 	const ret = [], width = grid[0]?.length
  1093. 	for (let r = 0; r < grid.length; r++) {
  1094. 		for (let c = 0; c < width; c++) {
  1095. 			ret[r + (width - 1 - c)] ??= []
  1096. 			ret[r + (width - 1 - c)].push(grid[r][c])
  1097. 		}
  1098. 	}
  1100. 	return ret
  1101. }
  1103. /**
  1104.  * **[Global]** Creates a grid of size `width` by `height` filled with `fill`.
  1105.  * Fill defaults to `null`.
  1106.  * @template T
  1107.  * @param {number} width The width of the grid
  1108.  * @param {number} height The height of the grid
  1109.  * @param {T} [fill=null] The value to fill the grid with
  1110.  * @returns {T[][]}
  1111.  */
  1112. grid_utils.emptygrid = tag(
  1113. 	{ keep_global: true },
  1114. 	(width, height, fill = null) => Array(height).fill().map(() => Array(width).fill(fill))
  1115. )
  1117. /**
  1118.  * **[Global]** Prints a grid and returns it. If the shortest cell is only 1 character long
  1119.  * then the grid will be printed without spaces between cells.
  1120.  * @function
  1121.  * @template T
  1122.  * @param {T[][]} grid
  1123.  * @returns {T[][]}
  1124.  */
  1125. grid_utils.gprint = tag({ keep_global: true }, grid => {
  1126. 	const longest_cell = Math.max(...grid.flatMap(
  1127. 		row => row.map(cell => cell.toString().length)
  1128. 	))
  1130. 	console.log(grid.map(row => row.map(
  1131. 		cell => cell.toString().padEnd(longest_cell)
  1132. 	).join(longest_cell > 1 ? " " : "")).join("\n"))
  1134. 	return grid
  1135. })
  1137. /**
  1138.  * Alias for {@link grid_utils.gprint}
  1139.  * @template T
  1140.  * @param {T[][]} grid
  1141.  * @returns {T[][]}
  1142.  */
  1143. grid_utils.gpr = grid => grid_utils.gprint(grid)
  1145. /**
  1146.  * Sets value at the given vector in a grid. If the cell doesn't exist, it will be created.
  1147.  * @template T
  1148.  * @param {T[][]} grid The grid to set the value in
  1149.  * @param {Vec} vec The vector to set the value at
  1150.  * @param {T} value The value to set
  1151.  * @returns {T[][]} The modified grid
  1152.  */
  1153. grid_utils.gset = (grid, vec, value) => {
  1154. 	const row = grid[vec.y]
  1155. 	if (!row) grid[vec.y] = []
  1156. 	grid[vec.y][vec.x] = value
  1157. 	return grid
  1158. }
  1160. /**
  1161.  * Returns the first vector in a grid (searching top to bottom, left to right)
  1162.  * where the function `fn` is truthy for that cell. `fn` also receives the
  1163.  * position of each cell and a reference to the grid.
  1164.  * @template T
  1165.  * @param {T[][]} grid The grid to search
  1166.  * @param {function(T, Vec, T[][]): boolean} fn The function to search with
  1167.  * @returns {Vec}
  1168.  */
  1169. grid_utils.vecwhere = (grid, fn) => {
  1170. 	for (let y = 0; y < grid.length; y++) {
  1171. 		for (let x = 0; x < grid[y].length; x++) {
  1172. 			if (fn(grid[y][x], new Vec(x, y), grid)) return new Vec(x, y)
  1173. 		}
  1174. 	}
  1175. 	return null
  1176. }
  1178. /**
  1179.  * Returns the first cell in a grid (searching top to bottom, left to right)
  1180.  * where the function `fn` is truthy for that cell. `fn` also receives the
  1181.  * position of each cell and a reference to the grid.
  1182.  * @template T
  1183.  * @param {T[][]} grid The grid to search
  1184.  * @param {function(T, Vec, T[][]): boolean} fn The function to search with
  1185.  * @returns {T}
  1186.  */
  1187. grid_utils.gfind = (grid, fn) => {
  1188. 	for (let y = 0; y < grid.length; y++) {
  1189. 		for (let x = 0; x < grid[y].length; x++) {
  1190. 			if (fn(grid[y][x], new Vec(x, y), grid)) return grid[y][x]
  1191. 		}
  1192. 	}
  1193. 	return null
  1194. }
  1196. /** @namespace */
  1197. const object_utils = {}
  1199. /**
  1200.  * Same as the built in [Object.keys](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys)
  1201.  * @param {object} obj The object to get keys from
  1202.  * @returns {string[]}
  1203.  */
  1204. object_utils.keys = obj => Object.keys(obj)
  1206. /**
  1207.  * Same as the built in [Object.values](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/values)
  1208.  * @param {object} obj The object to get values from
  1209.  * @returns {any[]}
  1210.  */
  1211. object_utils.values = obj => Object.values(obj)
  1213. /**
  1214.  * Same as the built in [Object.entries](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries)
  1215.  * @param {object} obj The object to get entries from
  1216.  * @returns {any[]} An array of key-value tuples
  1217.  */
  1218. object_utils.entries = obj => Object.entries(obj)
  1220. /** @namespace */
  1221. const misc_utils = {}
  1223. /**
  1224.  * **[Global]** Checks `a` and `b` are equal. In theory this works for any two values,
  1225.  * whether they're primitives, arrays or some other object.
  1226.  * @function
  1227.  * @param {any} a
  1228.  * @param {any} b
  1229.  * @returns {boolean}
  1230.  */
  1231. misc_utils.eq = tag({ keep_global: true }, (a, b) => {
  1232. 	if (Array.isArray(a) && Array.isArray(b)) {
  1233. 		if (a.length !== b.length) return false;
  1234. 		for (let i = 0; i < a.length; i++)
  1235. 			if (!misc_utils.eq(a[i], b[i])) return false;
  1236. 		return true;
  1237. 	} else if (typeof a === "object" && typeof b === "object") {
  1238. 		return JSON.stringify(a) === JSON.stringify(b);
  1239. 	} else return a === b;
  1240. })
  1242. /** 
  1243.  * **[Global]** Checks `a` and `b` are not equal (by negating `misc_utils.eq`)
  1244.  * @function
  1245.  * @param {any} a
  1246.  * @param {any} b
  1247.  * @returns {boolean}
  1248.  */
  1249. misc_utils.neq = tag({ keep_global: true }, (a, b) => !eq(a, b))
  1251. /**
  1252.  * **[Global]** Creates the range `[a, b)` in an array with an optional step size
  1253.  * @function
  1254.  * @param {number} a End of the range (if `b` is not provided)
  1255.  * @param {number} [b=0] End of the range (if provided, in which case `a` is the start)
  1256.  * @param {number} [step=1]
  1257.  * @returns {number[]}
  1258.  * @example range(4) // [0, 1, 2, 3]
  1259.  * @example range(2, 5) // [2, 3, 4]
  1260.  * @example range(1, 10, 2) // [1, 3, 5, 7, 9]
  1261.  */
  1262. misc_utils.range = tag({ keep_global: true }, function(a, b = 0, step = 1) {
  1263. 	let start = 0, end = a
  1264. 	if (arguments.length > 1) {
  1265. 		start = a
  1266. 		end = b
  1267. 	}
  1268. 	const ret = [];
  1269. 	for (let n = start; n < end; n += step)
  1270. 		ret.push(n)
  1271. 	return ret
  1272. })
  1274. /**
  1275.  * **[Global]** Same as `console.log` its arg(s)
  1276.  * @function
  1277.  * @template T
  1278.  * @param {...T} values Values to print
  1279.  * @returns {T|T[]}
  1280.  */
  1281. misc_utils.print = tag({ keep_global: true }, (...values) => {
  1282. 	console.log(...values)
  1283. 	return values.length > 1 ? values : values[0]
  1284. })
  1286. /**
  1287.  * **[Global]** Same as `misc_utils.print` but niladic (so that it becomes a getter)
  1288.  * @template T
  1289.  * @param {T} value Value to print
  1290.  * @returns {T}
  1291.  */
  1292. misc_utils.pr = value => misc_utils.print(value)
  1294. /**
  1295.  * **[Global]** Tries to get the length property of `value` otherwise tries to get `size`
  1296.  * @function
  1297.  * @param {any} value Value to get the length/size of
  1298.  * @returns {?number}
  1299.  */
  1300. misc_utils.len = value => value?.length ?? value?.size
  1302. /**
  1303.  * Wraps a value in a singleton list
  1304.  * @function
  1305.  * @template T
  1306.  * @param {T} value Value to wrap
  1307.  * @returns {T[]}
  1308.  */
  1309. misc_utils.wrap = value => [value]
  1311. /**
  1312.  * Finds the number of corners in an area
  1313.  * @param {_Set<Vec>} area The area to find corners in
  1314.  * @returns {number}
  1315.  */
  1316. misc_utils.corners = area => {
  1317. 	const xs = [...area].map(v => v.x)
  1318. 	const ys = [...area].map(v => v.y)
  1320. 	let corners = 0
  1322. 	for (let x = Math.min(...xs) - 1; x <= Math.max(...xs); x++) {
  1323. 		for (let y = Math.min(...ys) - 1; y <= Math.max(...ys); y++) {
  1324. 			const subgrid = [new Vec(x, y), new Vec(x + 1, y), new Vec(x, y + 1), new Vec(x + 1, y + 1)]
  1325. 			const in_area = subgrid.map(v => area.has(v))
  1326. 			const count_in_area = in_area.filter(x => x).length
  1327. 			if (count_in_area == 1 || count_in_area == 3) corners++
  1328. 			else if (
  1329. 				misc_utils.eq(in_area, [true, false, false, true]) ||
  1330. 				misc_utils.eq(in_area, [false, true, true, false])
  1331. 			) corners += 2
  1332. 		}
  1333. 	}
  1335. 	return corners
  1336. }
  1338. /**
  1339.  * **[Global]** Exits the program (alias for [process.exit](https://nodejs.org/api/process.html#process_process_exit_code))
  1340.  * @param {number|string} [exit_code=0]
  1341.  * @returns {void}
  1342.  */
  1343. misc_utils.exit = tag({ keep_global: true }, (exit_code = process.exitCode ?? 0) => process.exit(exit_code))
  1345. /** @namespace */
  1346. const constructors = {}
  1348. /**
  1349.  * **[Global]** Calls `new _Set(iter)`. See the documentation for `{@link _Set}` for more info
  1350.  * @function
  1351.  * @param {Iterable.<*>} iter The iterable to create the set from
  1352.  * @returns {_Set}
  1353.  */
  1354. constructors.S = tag({ keep_global: true }, (iter = []) => new _Set(iter))
  1356. /**
  1357.  * **[Global]** Calls `new Vec(x, y)`. See the documentation for `{@link Vec}` for more info
  1358.  * @function
  1359.  * @param {number} x The x component of the vector
  1360.  * @param {number} y The y component of the vector
  1361.  * @returns {Vec}
  1362.  */
  1363. constructors.V = tag({ keep_global: true }, (x, y) => new Vec(x, y))
  1365. export default {
  1366. 	...type_checks,
  1367. 	...type_casts,
  1368. 	...math_utils,
  1369. 	...string_utils,
  1370. 	...iter_utils,
  1371. 	...object_utils,
  1372. 	...logic_utils,
  1373. 	...grid_utils,
  1374. 	...misc_utils,
  1375. 	...constructors
  1376. }