133 lines
4.7 KiB
JavaScript
133 lines
4.7 KiB
JavaScript
const { Buffer, TextEncoder, TextDecoder } = globalThis
|
|
const haveNativeBuffer = Buffer && !Buffer.TYPED_ARRAY_SUPPORT
|
|
export const nativeBuffer = haveNativeBuffer ? Buffer : null
|
|
export const isHermes = Boolean(globalThis.HermesInternal)
|
|
export const isDeno = Boolean(globalThis.Deno)
|
|
export const isLE = new Uint8Array(Uint16Array.of(258).buffer)[0] === 2
|
|
|
|
// We consider Node.js TextDecoder/TextEncoder native
|
|
let isNative = (x) => x && (haveNativeBuffer || `${x}`.includes('[native code]'))
|
|
if (!haveNativeBuffer && isNative(() => {})) isNative = () => false // e.g. XS, we don't want false positives
|
|
|
|
export const nativeEncoder = isNative(TextEncoder) ? new TextEncoder() : null
|
|
export const nativeDecoder = isNative(TextDecoder)
|
|
? new TextDecoder('utf-8', { ignoreBOM: true })
|
|
: null
|
|
|
|
// Actually windows-1252, compatible with ascii and latin1 decoding
|
|
// Beware that on non-latin1, i.e. on windows-1252, this is broken in ~all Node.js versions released
|
|
// in 2025 due to a regression, so we call it Latin1 as it's usable only for that
|
|
let nativeDecoderLatin1impl = null
|
|
if (nativeDecoder) {
|
|
// Not all barebone engines with TextDecoder support something except utf-8, detect
|
|
try {
|
|
nativeDecoderLatin1impl = new TextDecoder('latin1', { ignoreBOM: true })
|
|
} catch {}
|
|
}
|
|
|
|
export const nativeDecoderLatin1 = nativeDecoderLatin1impl
|
|
export const canDecoders = Boolean(nativeDecoderLatin1impl)
|
|
|
|
// Block Firefox < 146 specifically from using native hex/base64, as it's very slow there
|
|
// Refs: https://bugzilla.mozilla.org/show_bug.cgi?id=1994067 (and linked issues), fixed in 146
|
|
// Before that, all versions of Firefox >= 133 are slow
|
|
// TODO: this could be removed when < 146 usage diminishes (note ESR)
|
|
// We do not worry about false-negatives here but worry about false-positives!
|
|
function shouldSkipBuiltins() {
|
|
const g = globalThis
|
|
// First, attempt to exclude as many things as we can using trivial checks, just in case, and to not hit ua
|
|
if (haveNativeBuffer || isHermes || !g.window || g.chrome || !g.navigator) return false
|
|
try {
|
|
// This was fixed specifically in Firefox 146. Other engines except Hermes (already returned) get this right
|
|
new WeakSet().add(Symbol()) // eslint-disable-line symbol-description
|
|
return false
|
|
} catch {
|
|
// In catch and not after in case if something too smart optimizes out code in try. False-negative is acceptable in that case
|
|
if (!('onmozfullscreenerror' in g)) return false // Firefox has it (might remove in the future, but we don't care)
|
|
return /firefox/i.test(g.navigator.userAgent || '') // as simple as we can
|
|
}
|
|
|
|
return false // eslint-disable-line no-unreachable
|
|
}
|
|
|
|
export const skipWeb = shouldSkipBuiltins()
|
|
|
|
function decodePartAddition(a, start, end, m) {
|
|
let o = ''
|
|
let i = start
|
|
for (const last3 = end - 3; i < last3; i += 4) {
|
|
const x0 = a[i]
|
|
const x1 = a[i + 1]
|
|
const x2 = a[i + 2]
|
|
const x3 = a[i + 3]
|
|
o += m[x0]
|
|
o += m[x1]
|
|
o += m[x2]
|
|
o += m[x3]
|
|
}
|
|
|
|
while (i < end) o += m[a[i++]]
|
|
return o
|
|
}
|
|
|
|
// Decoding with templates is faster on Hermes
|
|
function decodePartTemplates(a, start, end, m) {
|
|
let o = ''
|
|
let i = start
|
|
for (const last15 = end - 15; i < last15; i += 16) {
|
|
const x0 = a[i]
|
|
const x1 = a[i + 1]
|
|
const x2 = a[i + 2]
|
|
const x3 = a[i + 3]
|
|
const x4 = a[i + 4]
|
|
const x5 = a[i + 5]
|
|
const x6 = a[i + 6]
|
|
const x7 = a[i + 7]
|
|
const x8 = a[i + 8]
|
|
const x9 = a[i + 9]
|
|
const x10 = a[i + 10]
|
|
const x11 = a[i + 11]
|
|
const x12 = a[i + 12]
|
|
const x13 = a[i + 13]
|
|
const x14 = a[i + 14]
|
|
const x15 = a[i + 15]
|
|
o += `${m[x0]}${m[x1]}${m[x2]}${m[x3]}${m[x4]}${m[x5]}${m[x6]}${m[x7]}${m[x8]}${m[x9]}${m[x10]}${m[x11]}${m[x12]}${m[x13]}${m[x14]}${m[x15]}`
|
|
}
|
|
|
|
while (i < end) o += m[a[i++]]
|
|
return o
|
|
}
|
|
|
|
const decodePart = isHermes ? decodePartTemplates : decodePartAddition
|
|
export function decode2string(arr, start, end, m) {
|
|
if (end - start > 30_000) {
|
|
// Limit concatenation to avoid excessive GC
|
|
// Thresholds checked on Hermes for toHex
|
|
const concat = []
|
|
for (let i = start; i < end; ) {
|
|
const step = i + 500
|
|
const iNext = step > end ? end : step
|
|
concat.push(decodePart(arr, i, iNext, m))
|
|
i = iNext
|
|
}
|
|
|
|
const res = concat.join('')
|
|
concat.length = 0
|
|
return res
|
|
}
|
|
|
|
return decodePart(arr, start, end, m)
|
|
}
|
|
|
|
export function assert(condition, msg) {
|
|
if (!condition) throw new Error(msg)
|
|
}
|
|
|
|
// On arrays in heap (<= 64) it's cheaper to copy into a pooled buffer than lazy-create the ArrayBuffer storage
|
|
export const toBuf = (x) =>
|
|
x.byteLength <= 64 && x.BYTES_PER_ELEMENT === 1
|
|
? Buffer.from(x)
|
|
: Buffer.from(x.buffer, x.byteOffset, x.byteLength)
|
|
|
|
export const E_STRING = 'Input is not a string'
|