qntm

// Exports a function which determines whether a JavaScript value is a power of
// two or not. Unlike the npm package `is-power-of-two`, this actually returns
// the correct answer in all cases.

const countSetBits = i => {
  // Based on <https://stackoverflow.com/a/109025/792705> but with some of the
  // performance optimisations reverted for the sake of improved legibility.
  i = (i & 0b01010101010101010101010101010101) + ((i & 0b10101010101010101010101010101010) >>> 1)
  i = (i & 0b00110011001100110011001100110011) + ((i & 0b11001100110011001100110011001100) >>> 2)
  i = (i & 0b00001111000011110000111100001111) + ((i & 0b11110000111100001111000011110000) >>> 4)

qntm

const { UNICODE, seq } = require('green-parse')

const trend = UNICODE.plus().map(chars => chars.join(''))

// match e.g. "trend1, trend2, trend3" and return ["trend1", "trend2", "trend3"]
const trends = trend.plus(', ')

// match e.g. "trend1, trend2 and trend3" and return ["trend1", "trend2", "trend3"]
const trendsAndTrend = seq([trends, ' and ', trend])
  .map(([trends, and, trend]) => [...trends, trend])

qntm

// AppScan may flag up a call like this as "Insecure Use of Document.Write"
// because it isn't intelligent enough to know that this a call to a totally
// unrelated method also named `write`
const diffBuffer = PNG.sync.write(diffPng)

// Replace with:
// eslint-disable-next-line no-useless-call
const diffBuffer = PNG.sync.write.call(PNG.sync, diffPng)

///////////////////////////////

qntm

// Suppose one branch of this ternary isn't covered?

const x = useT ? 'T' : ' '

// Try refactoring to one of these:

const x = [' ', 'T'][+useT]
const x = { true: 'T', false: ' ' }[useT]

// Both expressions are always evaluated, so I hope they aren't

qntm

const nextafter = require('nextafter')

for (let i = -Infinity; i !== Infinity; i = nextafter(i, Infinity)) {
	console.log(i)
}

// Whoops, forgot a few the first time I ran this
console.log(Infinity)
console.log(NaN)

qntm

// <https://twitter.com/Revolvolutionry/status/1165616879009816576>
// <https://oeis.org/A036746>

const { arabicToRoman, romanToArabic } = require('big-roman')

// The entry at index `i` in this array is the smallest Roman numeral
// of length `i`
const results = ['']
const stopAt = 281
let powerOfTen = 0

qntm

// No bounds/type checking
// No support for the overbar extension for numbers past 3999

const banks = [
	['', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX'],
	['', 'X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC'],
	['', 'C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM'],
	['', 'M', 'MM', 'MMM']
]

qntm

(s => console.log(s + '\n(' + JSON.stringify(s) + ')'))
("(s => console.log(s + '\\n(' + JSON.stringify(s) + ')'))")

qntm

let P=exports.P=(t,e,r=t=>typeof t==typeof P,c,o=t=>c=t,h=(t,e)=>{try{e=t(e),l==e?c():e===Object(e)&&r(t=e.then)?t.call(e,t=>e&&h(e=>t,e=0),t=>e&&o([t],e=0)):o([e,1])}catch(t){o([t])}},l={r:(c,P)=>setTimeout(l=>r(P=c[1]?t:e)?h(P,c[0]):o(c)),then:(t,e,r=P(t,e),h=o)=>(c?r.r(c):o=t=>r.r(t,h(t)),r)})=>l

qntm

'use strict'

// <http://www.ecma-international.org/ecma-262/5.1/#sec-8> Type
var type = function (x) {
  // The `typeof` operator gives us almost what we want
  return (
    typeof x === 'function' ? 'object'
    : x === null ? 'null'
    : typeof x
  )