node-font2base64
Version:
Convert font to base64 url or src, and to inject src into style files
1,546 lines (1,531 loc) • 217 kB
JavaScript
"use strict";
(() => {
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
}) : x)(function(x) {
if (typeof require !== "undefined")
return require.apply(this, arguments);
throw new Error('Dynamic require of "' + x + '" is not supported');
});
var __esm = (fn, res) => function __init() {
return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
var __commonJS = (cb, mod) => function __require2() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// node_modules/strtok3/lib/FsPromise.js
var require_FsPromise = __commonJS({
"node_modules/strtok3/lib/FsPromise.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.readFile = exports2.writeFileSync = exports2.writeFile = exports2.read = exports2.open = exports2.close = exports2.stat = exports2.createReadStream = exports2.pathExists = void 0;
var fs2 = __require("fs");
exports2.pathExists = fs2.existsSync;
exports2.createReadStream = fs2.createReadStream;
async function stat2(path2) {
return new Promise((resolve2, reject2) => {
fs2.stat(path2, (err, stats) => {
if (err)
reject2(err);
else
resolve2(stats);
});
});
}
exports2.stat = stat2;
async function close(fd) {
return new Promise((resolve2, reject2) => {
fs2.close(fd, (err) => {
if (err)
reject2(err);
else
resolve2();
});
});
}
exports2.close = close;
async function open(path2, mode) {
return new Promise((resolve2, reject2) => {
fs2.open(path2, mode, (err, fd) => {
if (err)
reject2(err);
else
resolve2(fd);
});
});
}
exports2.open = open;
async function read(fd, buffer, offset, length, position) {
return new Promise((resolve2, reject2) => {
fs2.read(fd, buffer, offset, length, position, (err, bytesRead, _buffer) => {
if (err)
reject2(err);
else
resolve2({ bytesRead, buffer: _buffer });
});
});
}
exports2.read = read;
async function writeFile2(path2, data) {
return new Promise((resolve2, reject2) => {
fs2.writeFile(path2, data, (err) => {
if (err)
reject2(err);
else
resolve2();
});
});
}
exports2.writeFile = writeFile2;
function writeFileSync(path2, data) {
fs2.writeFileSync(path2, data);
}
exports2.writeFileSync = writeFileSync;
async function readFile2(path2) {
return new Promise((resolve2, reject2) => {
fs2.readFile(path2, (err, buffer) => {
if (err)
reject2(err);
else
resolve2(buffer);
});
});
}
exports2.readFile = readFile2;
}
});
// node_modules/peek-readable/lib/EndOfFileStream.js
var require_EndOfFileStream = __commonJS({
"node_modules/peek-readable/lib/EndOfFileStream.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.EndOfStreamError = exports2.defaultMessages = void 0;
exports2.defaultMessages = "End-Of-Stream";
var EndOfStreamError = class extends Error {
constructor() {
super(exports2.defaultMessages);
}
};
exports2.EndOfStreamError = EndOfStreamError;
}
});
// node_modules/peek-readable/lib/Deferred.js
var require_Deferred = __commonJS({
"node_modules/peek-readable/lib/Deferred.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.Deferred = void 0;
var Deferred = class {
constructor() {
this.resolve = () => null;
this.reject = () => null;
this.promise = new Promise((resolve2, reject2) => {
this.reject = reject2;
this.resolve = resolve2;
});
}
};
exports2.Deferred = Deferred;
}
});
// node_modules/peek-readable/lib/StreamReader.js
var require_StreamReader = __commonJS({
"node_modules/peek-readable/lib/StreamReader.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.StreamReader = exports2.EndOfStreamError = void 0;
var EndOfFileStream_1 = require_EndOfFileStream();
var Deferred_1 = require_Deferred();
var EndOfFileStream_2 = require_EndOfFileStream();
Object.defineProperty(exports2, "EndOfStreamError", { enumerable: true, get: function() {
return EndOfFileStream_2.EndOfStreamError;
} });
var maxStreamReadSize = 1 * 1024 * 1024;
var StreamReader = class {
constructor(s) {
this.s = s;
this.deferred = null;
this.endOfStream = false;
this.peekQueue = [];
if (!s.read || !s.once) {
throw new Error("Expected an instance of stream.Readable");
}
this.s.once("end", () => this.reject(new EndOfFileStream_1.EndOfStreamError()));
this.s.once("error", (err) => this.reject(err));
this.s.once("close", () => this.reject(new Error("Stream closed")));
}
/**
* Read ahead (peek) from stream. Subsequent read or peeks will return the same data
* @param uint8Array - Uint8Array (or Buffer) to store data read from stream in
* @param offset - Offset target
* @param length - Number of bytes to read
* @returns Number of bytes peeked
*/
async peek(uint8Array, offset, length) {
const bytesRead = await this.read(uint8Array, offset, length);
this.peekQueue.push(uint8Array.subarray(offset, offset + bytesRead));
return bytesRead;
}
/**
* Read chunk from stream
* @param buffer - Target Uint8Array (or Buffer) to store data read from stream in
* @param offset - Offset target
* @param length - Number of bytes to read
* @returns Number of bytes read
*/
async read(buffer, offset, length) {
if (length === 0) {
return 0;
}
if (this.peekQueue.length === 0 && this.endOfStream) {
throw new EndOfFileStream_1.EndOfStreamError();
}
let remaining = length;
let bytesRead = 0;
while (this.peekQueue.length > 0 && remaining > 0) {
const peekData = this.peekQueue.pop();
if (!peekData)
throw new Error("peekData should be defined");
const lenCopy = Math.min(peekData.length, remaining);
buffer.set(peekData.subarray(0, lenCopy), offset + bytesRead);
bytesRead += lenCopy;
remaining -= lenCopy;
if (lenCopy < peekData.length) {
this.peekQueue.push(peekData.subarray(lenCopy));
}
}
while (remaining > 0 && !this.endOfStream) {
const reqLen = Math.min(remaining, maxStreamReadSize);
const chunkLen = await this.readFromStream(buffer, offset + bytesRead, reqLen);
bytesRead += chunkLen;
if (chunkLen < reqLen)
break;
remaining -= chunkLen;
}
return bytesRead;
}
/**
* Read chunk from stream
* @param buffer Target Uint8Array (or Buffer) to store data read from stream in
* @param offset Offset target
* @param length Number of bytes to read
* @returns Number of bytes read
*/
async readFromStream(buffer, offset, length) {
const readBuffer = this.s.read(length);
if (readBuffer) {
buffer.set(readBuffer, offset);
return readBuffer.length;
} else {
const request = {
buffer,
offset,
length,
deferred: new Deferred_1.Deferred()
};
this.deferred = request.deferred;
this.s.once("readable", () => {
this.readDeferred(request);
});
return request.deferred.promise;
}
}
/**
* Process deferred read request
* @param request Deferred read request
*/
readDeferred(request) {
const readBuffer = this.s.read(request.length);
if (readBuffer) {
request.buffer.set(readBuffer, request.offset);
request.deferred.resolve(readBuffer.length);
this.deferred = null;
} else {
this.s.once("readable", () => {
this.readDeferred(request);
});
}
}
reject(err) {
this.endOfStream = true;
if (this.deferred) {
this.deferred.reject(err);
this.deferred = null;
}
}
};
exports2.StreamReader = StreamReader;
}
});
// node_modules/peek-readable/lib/index.js
var require_lib = __commonJS({
"node_modules/peek-readable/lib/index.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.StreamReader = exports2.EndOfStreamError = void 0;
var EndOfFileStream_1 = require_EndOfFileStream();
Object.defineProperty(exports2, "EndOfStreamError", { enumerable: true, get: function() {
return EndOfFileStream_1.EndOfStreamError;
} });
var StreamReader_1 = require_StreamReader();
Object.defineProperty(exports2, "StreamReader", { enumerable: true, get: function() {
return StreamReader_1.StreamReader;
} });
}
});
// node_modules/strtok3/lib/AbstractTokenizer.js
var require_AbstractTokenizer = __commonJS({
"node_modules/strtok3/lib/AbstractTokenizer.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.AbstractTokenizer = void 0;
var peek_readable_1 = require_lib();
var AbstractTokenizer = class {
constructor(fileInfo) {
this.position = 0;
this.numBuffer = new Uint8Array(8);
this.fileInfo = fileInfo ? fileInfo : {};
}
/**
* Read a token from the tokenizer-stream
* @param token - The token to read
* @param position - If provided, the desired position in the tokenizer-stream
* @returns Promise with token data
*/
async readToken(token, position = this.position) {
const uint8Array = Buffer.alloc(token.len);
const len = await this.readBuffer(uint8Array, { position });
if (len < token.len)
throw new peek_readable_1.EndOfStreamError();
return token.get(uint8Array, 0);
}
/**
* Peek a token from the tokenizer-stream.
* @param token - Token to peek from the tokenizer-stream.
* @param position - Offset where to begin reading within the file. If position is null, data will be read from the current file position.
* @returns Promise with token data
*/
async peekToken(token, position = this.position) {
const uint8Array = Buffer.alloc(token.len);
const len = await this.peekBuffer(uint8Array, { position });
if (len < token.len)
throw new peek_readable_1.EndOfStreamError();
return token.get(uint8Array, 0);
}
/**
* Read a numeric token from the stream
* @param token - Numeric token
* @returns Promise with number
*/
async readNumber(token) {
const len = await this.readBuffer(this.numBuffer, { length: token.len });
if (len < token.len)
throw new peek_readable_1.EndOfStreamError();
return token.get(this.numBuffer, 0);
}
/**
* Read a numeric token from the stream
* @param token - Numeric token
* @returns Promise with number
*/
async peekNumber(token) {
const len = await this.peekBuffer(this.numBuffer, { length: token.len });
if (len < token.len)
throw new peek_readable_1.EndOfStreamError();
return token.get(this.numBuffer, 0);
}
/**
* Ignore number of bytes, advances the pointer in under tokenizer-stream.
* @param length - Number of bytes to ignore
* @return resolves the number of bytes ignored, equals length if this available, otherwise the number of bytes available
*/
async ignore(length) {
if (this.fileInfo.size !== void 0) {
const bytesLeft = this.fileInfo.size - this.position;
if (length > bytesLeft) {
this.position += bytesLeft;
return bytesLeft;
}
}
this.position += length;
return length;
}
async close() {
}
normalizeOptions(uint8Array, options) {
if (options && options.position !== void 0 && options.position < this.position) {
throw new Error("`options.position` must be equal or greater than `tokenizer.position`");
}
if (options) {
return {
mayBeLess: options.mayBeLess === true,
offset: options.offset ? options.offset : 0,
length: options.length ? options.length : uint8Array.length - (options.offset ? options.offset : 0),
position: options.position ? options.position : this.position
};
}
return {
mayBeLess: false,
offset: 0,
length: uint8Array.length,
position: this.position
};
}
};
exports2.AbstractTokenizer = AbstractTokenizer;
}
});
// node_modules/strtok3/lib/ReadStreamTokenizer.js
var require_ReadStreamTokenizer = __commonJS({
"node_modules/strtok3/lib/ReadStreamTokenizer.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.ReadStreamTokenizer = void 0;
var AbstractTokenizer_1 = require_AbstractTokenizer();
var peek_readable_1 = require_lib();
var maxBufferSize = 256e3;
var ReadStreamTokenizer = class extends AbstractTokenizer_1.AbstractTokenizer {
constructor(stream2, fileInfo) {
super(fileInfo);
this.streamReader = new peek_readable_1.StreamReader(stream2);
}
/**
* Get file information, an HTTP-client may implement this doing a HEAD request
* @return Promise with file information
*/
async getFileInfo() {
return this.fileInfo;
}
/**
* Read buffer from tokenizer
* @param uint8Array - Target Uint8Array to fill with data read from the tokenizer-stream
* @param options - Read behaviour options
* @returns Promise with number of bytes read
*/
async readBuffer(uint8Array, options) {
const normOptions = this.normalizeOptions(uint8Array, options);
const skipBytes = normOptions.position - this.position;
if (skipBytes > 0) {
await this.ignore(skipBytes);
return this.readBuffer(uint8Array, options);
} else if (skipBytes < 0) {
throw new Error("`options.position` must be equal or greater than `tokenizer.position`");
}
if (normOptions.length === 0) {
return 0;
}
const bytesRead = await this.streamReader.read(uint8Array, normOptions.offset, normOptions.length);
this.position += bytesRead;
if ((!options || !options.mayBeLess) && bytesRead < normOptions.length) {
throw new peek_readable_1.EndOfStreamError();
}
return bytesRead;
}
/**
* Peek (read ahead) buffer from tokenizer
* @param uint8Array - Uint8Array (or Buffer) to write data to
* @param options - Read behaviour options
* @returns Promise with number of bytes peeked
*/
async peekBuffer(uint8Array, options) {
const normOptions = this.normalizeOptions(uint8Array, options);
let bytesRead = 0;
if (normOptions.position) {
const skipBytes = normOptions.position - this.position;
if (skipBytes > 0) {
const skipBuffer = new Uint8Array(normOptions.length + skipBytes);
bytesRead = await this.peekBuffer(skipBuffer, { mayBeLess: normOptions.mayBeLess });
uint8Array.set(skipBuffer.subarray(skipBytes), normOptions.offset);
return bytesRead - skipBytes;
} else if (skipBytes < 0) {
throw new Error("Cannot peek from a negative offset in a stream");
}
}
if (normOptions.length > 0) {
try {
bytesRead = await this.streamReader.peek(uint8Array, normOptions.offset, normOptions.length);
} catch (err) {
if (options && options.mayBeLess && err instanceof peek_readable_1.EndOfStreamError) {
return 0;
}
throw err;
}
if (!normOptions.mayBeLess && bytesRead < normOptions.length) {
throw new peek_readable_1.EndOfStreamError();
}
}
return bytesRead;
}
async ignore(length) {
const bufSize = Math.min(maxBufferSize, length);
const buf = new Uint8Array(bufSize);
let totBytesRead = 0;
while (totBytesRead < length) {
const remaining = length - totBytesRead;
const bytesRead = await this.readBuffer(buf, { length: Math.min(bufSize, remaining) });
if (bytesRead < 0) {
return bytesRead;
}
totBytesRead += bytesRead;
}
return totBytesRead;
}
};
exports2.ReadStreamTokenizer = ReadStreamTokenizer;
}
});
// node_modules/strtok3/lib/BufferTokenizer.js
var require_BufferTokenizer = __commonJS({
"node_modules/strtok3/lib/BufferTokenizer.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.BufferTokenizer = void 0;
var peek_readable_1 = require_lib();
var AbstractTokenizer_1 = require_AbstractTokenizer();
var BufferTokenizer = class extends AbstractTokenizer_1.AbstractTokenizer {
/**
* Construct BufferTokenizer
* @param uint8Array - Uint8Array to tokenize
* @param fileInfo - Pass additional file information to the tokenizer
*/
constructor(uint8Array, fileInfo) {
super(fileInfo);
this.uint8Array = uint8Array;
this.fileInfo.size = this.fileInfo.size ? this.fileInfo.size : uint8Array.length;
}
/**
* Read buffer from tokenizer
* @param uint8Array - Uint8Array to tokenize
* @param options - Read behaviour options
* @returns {Promise<number>}
*/
async readBuffer(uint8Array, options) {
if (options && options.position) {
if (options.position < this.position) {
throw new Error("`options.position` must be equal or greater than `tokenizer.position`");
}
this.position = options.position;
}
const bytesRead = await this.peekBuffer(uint8Array, options);
this.position += bytesRead;
return bytesRead;
}
/**
* Peek (read ahead) buffer from tokenizer
* @param uint8Array
* @param options - Read behaviour options
* @returns {Promise<number>}
*/
async peekBuffer(uint8Array, options) {
const normOptions = this.normalizeOptions(uint8Array, options);
const bytes2read = Math.min(this.uint8Array.length - normOptions.position, normOptions.length);
if (!normOptions.mayBeLess && bytes2read < normOptions.length) {
throw new peek_readable_1.EndOfStreamError();
} else {
uint8Array.set(this.uint8Array.subarray(normOptions.position, normOptions.position + bytes2read), normOptions.offset);
return bytes2read;
}
}
async close() {
}
};
exports2.BufferTokenizer = BufferTokenizer;
}
});
// node_modules/strtok3/lib/core.js
var require_core = __commonJS({
"node_modules/strtok3/lib/core.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.fromBuffer = exports2.fromStream = exports2.EndOfStreamError = void 0;
var ReadStreamTokenizer_1 = require_ReadStreamTokenizer();
var BufferTokenizer_1 = require_BufferTokenizer();
var peek_readable_1 = require_lib();
Object.defineProperty(exports2, "EndOfStreamError", { enumerable: true, get: function() {
return peek_readable_1.EndOfStreamError;
} });
function fromStream2(stream2, fileInfo) {
fileInfo = fileInfo ? fileInfo : {};
return new ReadStreamTokenizer_1.ReadStreamTokenizer(stream2, fileInfo);
}
exports2.fromStream = fromStream2;
function fromBuffer2(uint8Array, fileInfo) {
return new BufferTokenizer_1.BufferTokenizer(uint8Array, fileInfo);
}
exports2.fromBuffer = fromBuffer2;
}
});
// node_modules/strtok3/lib/FileTokenizer.js
var require_FileTokenizer = __commonJS({
"node_modules/strtok3/lib/FileTokenizer.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.fromFile = exports2.FileTokenizer = void 0;
var AbstractTokenizer_1 = require_AbstractTokenizer();
var peek_readable_1 = require_lib();
var fs2 = require_FsPromise();
var FileTokenizer = class extends AbstractTokenizer_1.AbstractTokenizer {
constructor(fd, fileInfo) {
super(fileInfo);
this.fd = fd;
}
/**
* Read buffer from file
* @param uint8Array - Uint8Array to write result to
* @param options - Read behaviour options
* @returns Promise number of bytes read
*/
async readBuffer(uint8Array, options) {
const normOptions = this.normalizeOptions(uint8Array, options);
this.position = normOptions.position;
const res = await fs2.read(this.fd, uint8Array, normOptions.offset, normOptions.length, normOptions.position);
this.position += res.bytesRead;
if (res.bytesRead < normOptions.length && (!options || !options.mayBeLess)) {
throw new peek_readable_1.EndOfStreamError();
}
return res.bytesRead;
}
/**
* Peek buffer from file
* @param uint8Array - Uint8Array (or Buffer) to write data to
* @param options - Read behaviour options
* @returns Promise number of bytes read
*/
async peekBuffer(uint8Array, options) {
const normOptions = this.normalizeOptions(uint8Array, options);
const res = await fs2.read(this.fd, uint8Array, normOptions.offset, normOptions.length, normOptions.position);
if (!normOptions.mayBeLess && res.bytesRead < normOptions.length) {
throw new peek_readable_1.EndOfStreamError();
}
return res.bytesRead;
}
async close() {
return fs2.close(this.fd);
}
};
exports2.FileTokenizer = FileTokenizer;
async function fromFile(sourceFilePath) {
const stat2 = await fs2.stat(sourceFilePath);
if (!stat2.isFile) {
throw new Error(`File not a file: ${sourceFilePath}`);
}
const fd = await fs2.open(sourceFilePath, "r");
return new FileTokenizer(fd, { path: sourceFilePath, size: stat2.size });
}
exports2.fromFile = fromFile;
}
});
// node_modules/strtok3/lib/index.js
var require_lib2 = __commonJS({
"node_modules/strtok3/lib/index.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.fromStream = exports2.fromBuffer = exports2.EndOfStreamError = exports2.fromFile = void 0;
var fs2 = require_FsPromise();
var core = require_core();
var FileTokenizer_1 = require_FileTokenizer();
Object.defineProperty(exports2, "fromFile", { enumerable: true, get: function() {
return FileTokenizer_1.fromFile;
} });
var core_1 = require_core();
Object.defineProperty(exports2, "EndOfStreamError", { enumerable: true, get: function() {
return core_1.EndOfStreamError;
} });
Object.defineProperty(exports2, "fromBuffer", { enumerable: true, get: function() {
return core_1.fromBuffer;
} });
async function fromStream2(stream2, fileInfo) {
fileInfo = fileInfo ? fileInfo : {};
if (stream2.path) {
const stat2 = await fs2.stat(stream2.path);
fileInfo.path = stream2.path;
fileInfo.size = stat2.size;
}
return core.fromStream(stream2, fileInfo);
}
exports2.fromStream = fromStream2;
}
});
// node_modules/ieee754/index.js
var require_ieee754 = __commonJS({
"node_modules/ieee754/index.js"(exports2) {
exports2.read = function(buffer, offset, isLE, mLen, nBytes) {
var e, m;
var eLen = nBytes * 8 - mLen - 1;
var eMax = (1 << eLen) - 1;
var eBias = eMax >> 1;
var nBits = -7;
var i = isLE ? nBytes - 1 : 0;
var d = isLE ? -1 : 1;
var s = buffer[offset + i];
i += d;
e = s & (1 << -nBits) - 1;
s >>= -nBits;
nBits += eLen;
for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {
}
m = e & (1 << -nBits) - 1;
e >>= -nBits;
nBits += mLen;
for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {
}
if (e === 0) {
e = 1 - eBias;
} else if (e === eMax) {
return m ? NaN : (s ? -1 : 1) * Infinity;
} else {
m = m + Math.pow(2, mLen);
e = e - eBias;
}
return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
};
exports2.write = function(buffer, value, offset, isLE, mLen, nBytes) {
var e, m, c;
var eLen = nBytes * 8 - mLen - 1;
var eMax = (1 << eLen) - 1;
var eBias = eMax >> 1;
var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
var i = isLE ? 0 : nBytes - 1;
var d = isLE ? 1 : -1;
var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
value = Math.abs(value);
if (isNaN(value) || value === Infinity) {
m = isNaN(value) ? 1 : 0;
e = eMax;
} else {
e = Math.floor(Math.log(value) / Math.LN2);
if (value * (c = Math.pow(2, -e)) < 1) {
e--;
c *= 2;
}
if (e + eBias >= 1) {
value += rt / c;
} else {
value += 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;
}
}
for (; mLen >= 8; buffer[offset + i] = m & 255, i += d, m /= 256, mLen -= 8) {
}
e = e << mLen | m;
eLen += mLen;
for (; eLen > 0; buffer[offset + i] = e & 255, i += d, e /= 256, eLen -= 8) {
}
buffer[offset + i - d] |= s * 128;
};
}
});
// node_modules/token-types/lib/index.js
var require_lib3 = __commonJS({
"node_modules/token-types/lib/index.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.AnsiStringType = exports2.StringType = exports2.BufferType = exports2.Uint8ArrayType = exports2.IgnoreType = exports2.Float80_LE = exports2.Float80_BE = exports2.Float64_LE = exports2.Float64_BE = exports2.Float32_LE = exports2.Float32_BE = exports2.Float16_LE = exports2.Float16_BE = exports2.INT64_BE = exports2.UINT64_BE = exports2.INT64_LE = exports2.UINT64_LE = exports2.INT32_LE = exports2.INT32_BE = exports2.INT24_BE = exports2.INT24_LE = exports2.INT16_LE = exports2.INT16_BE = exports2.INT8 = exports2.UINT32_BE = exports2.UINT32_LE = exports2.UINT24_BE = exports2.UINT24_LE = exports2.UINT16_BE = exports2.UINT16_LE = exports2.UINT8 = void 0;
var ieee754 = require_ieee754();
function dv(array) {
return new DataView(array.buffer, array.byteOffset);
}
exports2.UINT8 = {
len: 1,
get(array, offset) {
return dv(array).getUint8(offset);
},
put(array, offset, value) {
dv(array).setUint8(offset, value);
return offset + 1;
}
};
exports2.UINT16_LE = {
len: 2,
get(array, offset) {
return dv(array).getUint16(offset, true);
},
put(array, offset, value) {
dv(array).setUint16(offset, value, true);
return offset + 2;
}
};
exports2.UINT16_BE = {
len: 2,
get(array, offset) {
return dv(array).getUint16(offset);
},
put(array, offset, value) {
dv(array).setUint16(offset, value);
return offset + 2;
}
};
exports2.UINT24_LE = {
len: 3,
get(array, offset) {
const dataView = dv(array);
return dataView.getUint8(offset) + (dataView.getUint16(offset + 1, true) << 8);
},
put(array, offset, value) {
const dataView = dv(array);
dataView.setUint8(offset, value & 255);
dataView.setUint16(offset + 1, value >> 8, true);
return offset + 3;
}
};
exports2.UINT24_BE = {
len: 3,
get(array, offset) {
const dataView = dv(array);
return (dataView.getUint16(offset) << 8) + dataView.getUint8(offset + 2);
},
put(array, offset, value) {
const dataView = dv(array);
dataView.setUint16(offset, value >> 8);
dataView.setUint8(offset + 2, value & 255);
return offset + 3;
}
};
exports2.UINT32_LE = {
len: 4,
get(array, offset) {
return dv(array).getUint32(offset, true);
},
put(array, offset, value) {
dv(array).setUint32(offset, value, true);
return offset + 4;
}
};
exports2.UINT32_BE = {
len: 4,
get(array, offset) {
return dv(array).getUint32(offset);
},
put(array, offset, value) {
dv(array).setUint32(offset, value);
return offset + 4;
}
};
exports2.INT8 = {
len: 1,
get(array, offset) {
return dv(array).getInt8(offset);
},
put(array, offset, value) {
dv(array).setInt8(offset, value);
return offset + 1;
}
};
exports2.INT16_BE = {
len: 2,
get(array, offset) {
return dv(array).getInt16(offset);
},
put(array, offset, value) {
dv(array).setInt16(offset, value);
return offset + 2;
}
};
exports2.INT16_LE = {
len: 2,
get(array, offset) {
return dv(array).getInt16(offset, true);
},
put(array, offset, value) {
dv(array).setInt16(offset, value, true);
return offset + 2;
}
};
exports2.INT24_LE = {
len: 3,
get(array, offset) {
const unsigned = exports2.UINT24_LE.get(array, offset);
return unsigned > 8388607 ? unsigned - 16777216 : unsigned;
},
put(array, offset, value) {
const dataView = dv(array);
dataView.setUint8(offset, value & 255);
dataView.setUint16(offset + 1, value >> 8, true);
return offset + 3;
}
};
exports2.INT24_BE = {
len: 3,
get(array, offset) {
const unsigned = exports2.UINT24_BE.get(array, offset);
return unsigned > 8388607 ? unsigned - 16777216 : unsigned;
},
put(array, offset, value) {
const dataView = dv(array);
dataView.setUint16(offset, value >> 8);
dataView.setUint8(offset + 2, value & 255);
return offset + 3;
}
};
exports2.INT32_BE = {
len: 4,
get(array, offset) {
return dv(array).getInt32(offset);
},
put(array, offset, value) {
dv(array).setInt32(offset, value);
return offset + 4;
}
};
exports2.INT32_LE = {
len: 4,
get(array, offset) {
return dv(array).getInt32(offset, true);
},
put(array, offset, value) {
dv(array).setInt32(offset, value, true);
return offset + 4;
}
};
exports2.UINT64_LE = {
len: 8,
get(array, offset) {
return dv(array).getBigUint64(offset, true);
},
put(array, offset, value) {
dv(array).setBigUint64(offset, value, true);
return offset + 8;
}
};
exports2.INT64_LE = {
len: 8,
get(array, offset) {
return dv(array).getBigInt64(offset, true);
},
put(array, offset, value) {
dv(array).setBigInt64(offset, value, true);
return offset + 8;
}
};
exports2.UINT64_BE = {
len: 8,
get(array, offset) {
return dv(array).getBigUint64(offset);
},
put(array, offset, value) {
dv(array).setBigUint64(offset, value);
return offset + 8;
}
};
exports2.INT64_BE = {
len: 8,
get(array, offset) {
return dv(array).getBigInt64(offset);
},
put(array, offset, value) {
dv(array).setBigInt64(offset, value);
return offset + 8;
}
};
exports2.Float16_BE = {
len: 2,
get(dataView, offset) {
return ieee754.read(dataView, offset, false, 10, this.len);
},
put(dataView, offset, value) {
ieee754.write(dataView, value, offset, false, 10, this.len);
return offset + this.len;
}
};
exports2.Float16_LE = {
len: 2,
get(array, offset) {
return ieee754.read(array, offset, true, 10, this.len);
},
put(array, offset, value) {
ieee754.write(array, value, offset, true, 10, this.len);
return offset + this.len;
}
};
exports2.Float32_BE = {
len: 4,
get(array, offset) {
return dv(array).getFloat32(offset);
},
put(array, offset, value) {
dv(array).setFloat32(offset, value);
return offset + 4;
}
};
exports2.Float32_LE = {
len: 4,
get(array, offset) {
return dv(array).getFloat32(offset, true);
},
put(array, offset, value) {
dv(array).setFloat32(offset, value, true);
return offset + 4;
}
};
exports2.Float64_BE = {
len: 8,
get(array, offset) {
return dv(array).getFloat64(offset);
},
put(array, offset, value) {
dv(array).setFloat64(offset, value);
return offset + 8;
}
};
exports2.Float64_LE = {
len: 8,
get(array, offset) {
return dv(array).getFloat64(offset, true);
},
put(array, offset, value) {
dv(array).setFloat64(offset, value, true);
return offset + 8;
}
};
exports2.Float80_BE = {
len: 10,
get(array, offset) {
return ieee754.read(array, offset, false, 63, this.len);
},
put(array, offset, value) {
ieee754.write(array, value, offset, false, 63, this.len);
return offset + this.len;
}
};
exports2.Float80_LE = {
len: 10,
get(array, offset) {
return ieee754.read(array, offset, true, 63, this.len);
},
put(array, offset, value) {
ieee754.write(array, value, offset, true, 63, this.len);
return offset + this.len;
}
};
var IgnoreType = class {
/**
* @param len number of bytes to ignore
*/
constructor(len) {
this.len = len;
}
// ToDo: don't read, but skip data
get(array, off) {
}
};
exports2.IgnoreType = IgnoreType;
var Uint8ArrayType = class {
constructor(len) {
this.len = len;
}
get(array, offset) {
return array.subarray(offset, offset + this.len);
}
};
exports2.Uint8ArrayType = Uint8ArrayType;
var BufferType = class {
constructor(len) {
this.len = len;
}
get(uint8Array, off) {
return Buffer.from(uint8Array.subarray(off, off + this.len));
}
};
exports2.BufferType = BufferType;
var StringType = class {
constructor(len, encoding) {
this.len = len;
this.encoding = encoding;
}
get(uint8Array, offset) {
return Buffer.from(uint8Array).toString(this.encoding, offset, offset + this.len);
}
};
exports2.StringType = StringType;
var AnsiStringType = class {
constructor(len) {
this.len = len;
}
static decode(buffer, offset, until) {
let str = "";
for (let i = offset; i < until; ++i) {
str += AnsiStringType.codePointToString(AnsiStringType.singleByteDecoder(buffer[i]));
}
return str;
}
static inRange(a, min, max) {
return min <= a && a <= max;
}
static codePointToString(cp) {
if (cp <= 65535) {
return String.fromCharCode(cp);
} else {
cp -= 65536;
return String.fromCharCode((cp >> 10) + 55296, (cp & 1023) + 56320);
}
}
static singleByteDecoder(bite) {
if (AnsiStringType.inRange(bite, 0, 127)) {
return bite;
}
const codePoint = AnsiStringType.windows1252[bite - 128];
if (codePoint === null) {
throw Error("invaliding encoding");
}
return codePoint;
}
get(buffer, offset = 0) {
return AnsiStringType.decode(buffer, offset, offset + this.len);
}
};
exports2.AnsiStringType = AnsiStringType;
AnsiStringType.windows1252 = [
8364,
129,
8218,
402,
8222,
8230,
8224,
8225,
710,
8240,
352,
8249,
338,
141,
381,
143,
144,
8216,
8217,
8220,
8221,
8226,
8211,
8212,
732,
8482,
353,
8250,
339,
157,
382,
376,
160,
161,
162,
163,
164,
165,
166,
167,
168,
169,
170,
171,
172,
173,
174,
175,
176,
177,
178,
179,
180,
181,
182,
183,
184,
185,
186,
187,
188,
189,
190,
191,
192,
193,
194,
195,
196,
197,
198,
199,
200,
201,
202,
203,
204,
205,
206,
207,
208,
209,
210,
211,
212,
213,
214,
215,
216,
217,
218,
219,
220,
221,
222,
223,
224,
225,
226,
227,
228,
229,
230,
231,
232,
233,
234,
235,
236,
237,
238,
239,
240,
241,
242,
243,
244,
245,
246,
247,
248,
249,
250,
251,
252,
253,
254,
255
];
}
});
// node_modules/file-type/util.js
var require_util = __commonJS({
"node_modules/file-type/util.js"(exports2) {
"use strict";
exports2.stringToBytes = (string) => [...string].map((character) => character.charCodeAt(0));
exports2.tarHeaderChecksumMatches = (buffer, offset = 0) => {
const readSum = parseInt(buffer.toString("utf8", 148, 154).replace(/\0.*$/, "").trim(), 8);
if (isNaN(readSum)) {
return false;
}
let sum = 8 * 32;
for (let i = offset; i < offset + 148; i++) {
sum += buffer[i];
}
for (let i = offset + 156; i < offset + 512; i++) {
sum += buffer[i];
}
return readSum === sum;
};
exports2.uint32SyncSafeToken = {
get: (buffer, offset) => {
return buffer[offset + 3] & 127 | buffer[offset + 2] << 7 | buffer[offset + 1] << 14 | buffer[offset] << 21;
},
len: 4
};
}
});
// node_modules/file-type/supported.js
var require_supported = __commonJS({
"node_modules/file-type/supported.js"(exports2, module2) {
"use strict";
module2.exports = {
extensions: [
"jpg",
"png",
"apng",
"gif",
"webp",
"flif",
"xcf",
"cr2",
"cr3",
"orf",
"arw",
"dng",
"nef",
"rw2",
"raf",
"tif",
"bmp",
"icns",
"jxr",
"psd",
"indd",
"zip",
"tar",
"rar",
"gz",
"bz2",
"7z",
"dmg",
"mp4",
"mid",
"mkv",
"webm",
"mov",
"avi",
"mpg",
"mp2",
"mp3",
"m4a",
"oga",
"ogg",
"ogv",
"opus",
"flac",
"wav",
"spx",
"amr",
"pdf",
"epub",
"exe",
"swf",
"rtf",
"wasm",
"woff",
"woff2",
"eot",
"ttf",
"otf",
"ico",
"flv",
"ps",
"xz",
"sqlite",
"nes",
"crx",
"xpi",
"cab",
"deb",
"ar",
"rpm",
"Z",
"lz",
"cfb",
"mxf",
"mts",
"blend",
"bpg",
"docx",
"pptx",
"xlsx",
"3gp",
"3g2",
"jp2",
"jpm",
"jpx",
"mj2",
"aif",
"qcp",
"odt",
"ods",
"odp",
"xml",
"mobi",
"heic",
"cur",
"ktx",
"ape",
"wv",
"dcm",
"ics",
"glb",
"pcap",
"dsf",
"lnk",
"alias",
"voc",
"ac3",
"m4v",
"m4p",
"m4b",
"f4v",
"f4p",
"f4b",
"f4a",
"mie",
"asf",
"ogm",
"ogx",
"mpc",
"arrow",
"shp",
"aac",
"mp1",
"it",
"s3m",
"xm",
"ai",
"skp",
"avif",
"eps",
"lzh",
"pgp",
"asar",
"stl",
"chm",
"3mf",
"zst",
"jxl",
"vcf"
],
mimeTypes: [
"image/jpeg",
"image/png",
"image/gif",
"image/webp",
"image/flif",
"image/x-xcf",
"image/x-canon-cr2",
"image/x-canon-cr3",
"image/tiff",
"image/bmp",
"image/vnd.ms-photo",
"image/vnd.adobe.photoshop",
"application/x-indesign",
"application/epub+zip",
"application/x-xpinstall",
"application/vnd.oasis.opendocument.text",
"application/vnd.oasis.opendocument.spreadsheet",
"application/vnd.oasis.opendocument.presentation",
"application/vnd.openxmlformats-officedocument.wordprocessingml.document",
"application/vnd.openxmlformats-officedocument.presentationml.presentation",
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
"application/zip",
"application/x-tar",
"application/x-rar-compressed",
"application/gzip",
"application/x-bzip2",
"application/x-7z-compressed",
"application/x-apple-diskimage",
"application/x-apache-arrow",
"video/mp4",
"audio/midi",
"video/x-matroska",
"video/webm",
"video/quicktime",
"video/vnd.avi",
"audio/vnd.wave",
"audio/qcelp",
"audio/x-ms-asf",
"video/x-ms-asf",
"application/vnd.ms-asf",
"video/mpeg",
"video/3gpp",
"audio/mpeg",
"audio/mp4",
// RFC 4337
"audio/opus",
"video/ogg",
"audio/ogg",
"application/ogg",
"audio/x-flac",
"audio/ape",
"audio/wavpack",
"audio/amr",
"application/pdf",
"application/x-msdownload",
"application/x-shockwave-flash",
"application/rtf",
"application/wasm",
"font/woff",
"font/woff2",
"application/vnd.ms-fontobject",
"font/ttf",
"font/otf",
"image/x-icon",
"video/x-flv",
"application/postscript",
"application/eps",
"application/x-xz",
"application/x-sqlite3",
"application/x-nintendo-nes-rom",
"application/x-google-chrome-extension",
"application/vnd.ms-cab-compressed",
"application/x-deb",
"application/x-unix-archive",
"application/x-rpm",
"application/x-compress",
"application/x-lzip",
"application/x-cfb",
"application/x-mie",
"application/mxf",
"video/mp2t",
"application/x-blender",
"image/bpg",
"image/jp2",
"image/jpx",
"image/jpm",
"image/mj2",
"audio/aiff",
"application/xml",
"application/x-mobipocket-ebook",
"image/heif",
"image/heif-sequence",
"image/heic",
"image/heic-sequence",
"image/icns",
"image/ktx",
"application/dicom",
"audio/x-musepack",
"text/calendar",
"text/vcard",
"model/gltf-binary",
"application/vnd.tcpdump.pcap",
"audio/x-dsf",
// Non-standard
"application/x.ms.shortcut",
// Invented by us
"application/x.apple.alias",
// Invented by us
"audio/x-voc",
"audio/