Website Structure

Frontend-Learner/node_modules/unenv/dist/runtime/node/internal/buffer/base64.d.mts

@@ -0,0 +1,4 @@
+// base64 is 4/3 + up to two characters of the original data
+export declare function byteLength(b64);
+export declare function toByteArray(b64);
+export declare function fromByteArray(uint8);

Frontend-Learner/node_modules/unenv/dist/runtime/node/internal/buffer/base64.mjs

@@ -0,0 +1,97 @@
+// @ts-nocheck
+// Source: https://github.com/beatgammit/base64-js/blob/88957c9943c7e2a0f03cdf73e71d579e433627d3/index.js
+const lookup = [];
+const revLookup = [];
+const Arr = typeof Uint8Array === "undefined" ? Array : Uint8Array;
+const code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+for (let i = 0, len = code.length; i < len; ++i) {
+	lookup[i] = code[i];
+	revLookup[code.charCodeAt(i)] = i;
+}
+// Support decoding URL-safe base64 strings, as Node.js does.
+// See: https://en.wikipedia.org/wiki/Base64#URL_applications
+revLookup["-".charCodeAt(0)] = 62;
+revLookup["_".charCodeAt(0)] = 63;
+function getLens(b64) {
+	const len = b64.length;
+	if (len % 4 > 0) {
+		throw new Error("Invalid string. Length must be a multiple of 4");
+	}
+	// Trim off extra bytes after placeholder bytes are found
+	// See: https://github.com/beatgammit/base64-js/issues/42
+	let validLen = b64.indexOf("=");
+	if (validLen === -1) {
+		validLen = len;
+	}
+	const placeHoldersLen = validLen === len ? 0 : 4 - validLen % 4;
+	return [validLen, placeHoldersLen];
+}
+// base64 is 4/3 + up to two characters of the original data
+export function byteLength(b64) {
+	const lens = getLens(b64);
+	const validLen = lens[0];
+	const placeHoldersLen = lens[1];
+	return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+}
+function _byteLength(b64, validLen, placeHoldersLen) {
+	return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+}
+export function toByteArray(b64) {
+	let tmp;
+	const lens = getLens(b64);
+	const validLen = lens[0];
+	const placeHoldersLen = lens[1];
+	const arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
+	let curByte = 0;
+	// if there are placeholders, only get up to the last complete 4 chars
+	const len = placeHoldersLen > 0 ? validLen - 4 : validLen;
+	let i;
+	for (i = 0; i < len; i += 4) {
+		tmp = revLookup[b64.charCodeAt(i)] << 18 | revLookup[b64.charCodeAt(i + 1)] << 12 | revLookup[b64.charCodeAt(i + 2)] << 6 | revLookup[b64.charCodeAt(i + 3)];
+		arr[curByte++] = tmp >> 16 & 255;
+		arr[curByte++] = tmp >> 8 & 255;
+		arr[curByte++] = tmp & 255;
+	}
+	if (placeHoldersLen === 2) {
+		tmp = revLookup[b64.charCodeAt(i)] << 2 | revLookup[b64.charCodeAt(i + 1)] >> 4;
+		arr[curByte++] = tmp & 255;
+	}
+	if (placeHoldersLen === 1) {
+		tmp = revLookup[b64.charCodeAt(i)] << 10 | revLookup[b64.charCodeAt(i + 1)] << 4 | revLookup[b64.charCodeAt(i + 2)] >> 2;
+		arr[curByte++] = tmp >> 8 & 255;
+		arr[curByte++] = tmp & 255;
+	}
+	return arr;
+}
+function tripletToBase64(num) {
+	return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
+}
+function encodeChunk(uint8, start, end) {
+	let tmp;
+	const output = [];
+	for (let i = start; i < end; i += 3) {
+		tmp = (uint8[i] << 16 & 16711680) + (uint8[i + 1] << 8 & 65280) + (uint8[i + 2] & 255);
+		output.push(tripletToBase64(tmp));
+	}
+	return output.join("");
+}
+export function fromByteArray(uint8) {
+	let tmp;
+	const len = uint8.length;
+	const extraBytes = len % 3;
+	const parts = [];
+	const maxChunkLength = 16383;
+	// go through the array every three bytes, we'll deal with trailing stuff later
+	for (let i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
+		parts.push(encodeChunk(uint8, i, i + maxChunkLength > len2 ? len2 : i + maxChunkLength));
+	}
+	// pad the end with zeros, but make sure to not forget the extra bytes
+	if (extraBytes === 1) {
+		tmp = uint8[len - 1];
+		parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "==");
+	} else if (extraBytes === 2) {
+		tmp = (uint8[len - 2] << 8) + uint8[len - 1];
+		parts.push(lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "=");
+	}
+	return parts.join("");
+}

Frontend-Learner/node_modules/unenv/dist/runtime/node/internal/buffer/buffer.d.mts

@@ -0,0 +1,13 @@
+export declare const INSPECT_MAX_BYTES = 50;
+export declare const kMaxLength: unknown;
+/**
+* The Buffer constructor returns instances of `Uint8Array` that have their
+* prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
+* `Uint8Array`, so the returned instances will have all the node `Buffer` methods
+* and the `Uint8Array` methods. Square bracket notation works as expected -- it
+* returns a single octet.
+*
+* The `Uint8Array` prototype remains unmodified.
+*/
+export declare function Buffer(arg, encodingOrOffset, length);
+export declare function SlowBuffer(length);

Frontend-Learner/node_modules/unenv/dist/runtime/node/internal/buffer/file.d.mts

@@ -0,0 +1,14 @@
+import type nodeBuffer from "node:buffer";
+export declare class File extends Blob implements nodeBuffer.File {
+	readonly __unenv__: true;
+	size: number;
+	type: any;
+	name: string;
+	lastModified: number;
+	constructor(...args: any[]);
+	arrayBuffer(): Promise<ArrayBuffer>;
+	slice(): any;
+	text(): any;
+	stream(): any;
+	bytes(): Promise<Uint8Array<ArrayBuffer>>;
+}

Frontend-Learner/node_modules/unenv/dist/runtime/node/internal/buffer/file.mjs

@@ -0,0 +1,26 @@
+export class File extends Blob {
+	__unenv__ = true;
+	size = 0;
+	type = "";
+	name = "";
+	lastModified = 0;
+	constructor(...args) {
+		super(...args);
+		throw new Error("[unenv] buffer.File is not implemented");
+	}
+	arrayBuffer() {
+		throw new Error("Not implemented");
+	}
+	slice() {
+		throw new Error("Not implemented");
+	}
+	text() {
+		throw new Error("Not implemented");
+	}
+	stream() {
+		throw new Error("Not implemented");
+	}
+	bytes() {
+		throw new Error("Not implemented");
+	}
+}

Frontend-Learner/node_modules/unenv/dist/runtime/node/internal/buffer/ieee754.d.mts

@@ -0,0 +1,4 @@
+// Source: https://github.com/feross/ieee754/blob/8a0041f3d5e41b7cfcf0e0158fcf84b071709bda/index.js
+/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
+export declare function read(buffer: Uint8Array, offset: number, isLE: boolean, mLen: number, nBytes: number);
+export declare function write(buffer: Uint8Array, value: number, offset: number, isLE: boolean, mLen: number, nBytes: number);

Frontend-Learner/node_modules/unenv/dist/runtime/node/internal/buffer/ieee754.mjs

@@ -0,0 +1,89 @@
+// Source: https://github.com/feross/ieee754/blob/8a0041f3d5e41b7cfcf0e0158fcf84b071709bda/index.js
+/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
+export function read(buffer, offset, isLE, mLen, nBytes) {
+	let e, m;
+	const eLen = nBytes * 8 - mLen - 1;
+	const eMax = (1 << eLen) - 1;
+	const eBias = eMax >> 1;
+	let nBits = -7;
+	let i = isLE ? nBytes - 1 : 0;
+	const d = isLE ? -1 : 1;
+	let s = buffer[offset + i];
+	i += d;
+	e = s & (1 << -nBits) - 1;
+	s >>= -nBits;
+	nBits += eLen;
+	while (nBits > 0) {
+		e = e * 256 + buffer[offset + i];
+		i += d;
+		nBits -= 8;
+	}
+	m = e & (1 << -nBits) - 1;
+	e >>= -nBits;
+	nBits += mLen;
+	while (nBits > 0) {
+		m = m * 256 + buffer[offset + i];
+		i += d;
+		nBits -= 8;
+	}
+	if (e === 0) {
+		e = 1 - eBias;
+	} else if (e === eMax) {
+		return m ? Number.NaN : (s ? -1 : 1) * Number.POSITIVE_INFINITY;
+	} else {
+		m = m + Math.pow(2, mLen);
+		e = e - eBias;
+	}
+	return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
+}
+export function write(buffer, value, offset, isLE, mLen, nBytes) {
+	let e, m, c;
+	let eLen = nBytes * 8 - mLen - 1;
+	const eMax = (1 << eLen) - 1;
+	const eBias = eMax >> 1;
+	const rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
+	let i = isLE ? 0 : nBytes - 1;
+	const d = isLE ? 1 : -1;
+	const s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
+	value = Math.abs(value);
+	if (Number.isNaN(value) || value === Number.POSITIVE_INFINITY) {
+		m = Number.isNaN(value) ? 1 : 0;
+		e = eMax;
+	} else {
+		e = Math.floor(Math.log2(value));
+		if (value * (c = Math.pow(2, -e)) < 1) {
+			e--;
+			c *= 2;
+		}
+		value += e + eBias >= 1 ? rt / c : rt * Math.pow(2, 1 - eBias);
+		if (value * c >= 2) {
+			e++;
+			c /= 2;
+		}
+		if (e + eBias >= eMax) {
+			m = 0;
+			e = eMax;
+		} else if (e + eBias >= 1) {
+			m = (value * c - 1) * Math.pow(2, mLen);
+			e = e + eBias;
+		} else {
+			m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
+			e = 0;
+		}
+	}
+	while (mLen >= 8) {
+		buffer[offset + i] = m & 255;
+		i += d;
+		m /= 256;
+		mLen -= 8;
+	}
+	e = e << mLen | m;
+	eLen += mLen;
+	while (eLen > 0) {
+		buffer[offset + i] = e & 255;
+		i += d;
+		e /= 256;
+		eLen -= 8;
+	}
+	buffer[offset + i - d] |= s * 128;
+}