diff options
Diffstat (limited to 'node_modules/isbinaryfile/lib/index.js')
| -rw-r--r-- | node_modules/isbinaryfile/lib/index.js | 235 |
1 files changed, 235 insertions, 0 deletions
diff --git a/node_modules/isbinaryfile/lib/index.js b/node_modules/isbinaryfile/lib/index.js new file mode 100644 index 0000000..349fe7f --- /dev/null +++ b/node_modules/isbinaryfile/lib/index.js @@ -0,0 +1,235 @@ +"use strict"; +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isBinaryFileSync = exports.isBinaryFile = void 0; +const fs = require("fs"); +const util_1 = require("util"); +const statAsync = util_1.promisify(fs.stat); +const openAsync = util_1.promisify(fs.open); +const closeAsync = util_1.promisify(fs.close); +const MAX_BYTES = 512; +// A very basic non-exception raising reader. Read bytes and +// at the end use hasError() to check whether this worked. +class Reader { + constructor(fileBuffer, size) { + this.fileBuffer = fileBuffer; + this.size = size; + this.offset = 0; + this.error = false; + } + hasError() { + return this.error; + } + nextByte() { + if (this.offset === this.size || this.hasError()) { + this.error = true; + return 0xff; + } + return this.fileBuffer[this.offset++]; + } + next(len) { + const n = new Array(); + for (let i = 0; i < len; i++) { + n[i] = this.nextByte(); + } + return n; + } +} +// Read a Google Protobuf var(iable)int from the buffer. +function readProtoVarInt(reader) { + let idx = 0; + let varInt = 0; + while (!reader.hasError()) { + const b = reader.nextByte(); + varInt = varInt | ((b & 0x7f) << (7 * idx)); + if ((b & 0x80) === 0) { + break; + } + idx++; + } + return varInt; +} +// Attempt to taste a full Google Protobuf message. +function readProtoMessage(reader) { + const varInt = readProtoVarInt(reader); + const wireType = varInt & 0x7; + switch (wireType) { + case 0: + readProtoVarInt(reader); + return true; + case 1: + reader.next(8); + return true; + case 2: + const len = readProtoVarInt(reader); + reader.next(len); + return true; + case 5: + reader.next(4); + return true; + } + return false; +} +// Check whether this seems to be a valid protobuf file. +function isBinaryProto(fileBuffer, totalBytes) { + const reader = new Reader(fileBuffer, totalBytes); + let numMessages = 0; + while (true) { + // Definitely not a valid protobuf + if (!readProtoMessage(reader) && !reader.hasError()) { + return false; + } + // Short read? + if (reader.hasError()) { + break; + } + numMessages++; + } + return numMessages > 0; +} +function isBinaryFile(file, size) { + return __awaiter(this, void 0, void 0, function* () { + if (isString(file)) { + const stat = yield statAsync(file); + isStatFile(stat); + const fileDescriptor = yield openAsync(file, 'r'); + const allocBuffer = Buffer.alloc(MAX_BYTES); + // Read the file with no encoding for raw buffer access. + // NB: something is severely wrong with promisify, had to construct my own Promise + return new Promise((fulfill, reject) => { + fs.read(fileDescriptor, allocBuffer, 0, MAX_BYTES, 0, (err, bytesRead, _) => { + closeAsync(fileDescriptor); + if (err) { + reject(err); + } + else { + fulfill(isBinaryCheck(allocBuffer, bytesRead)); + } + }); + }); + } + else { + if (size === undefined) { + size = file.length; + } + return isBinaryCheck(file, size); + } + }); +} +exports.isBinaryFile = isBinaryFile; +function isBinaryFileSync(file, size) { + if (isString(file)) { + const stat = fs.statSync(file); + isStatFile(stat); + const fileDescriptor = fs.openSync(file, 'r'); + const allocBuffer = Buffer.alloc(MAX_BYTES); + const bytesRead = fs.readSync(fileDescriptor, allocBuffer, 0, MAX_BYTES, 0); + fs.closeSync(fileDescriptor); + return isBinaryCheck(allocBuffer, bytesRead); + } + else { + if (size === undefined) { + size = file.length; + } + return isBinaryCheck(file, size); + } +} +exports.isBinaryFileSync = isBinaryFileSync; +function isBinaryCheck(fileBuffer, bytesRead) { + // empty file. no clue what it is. + if (bytesRead === 0) { + return false; + } + let suspiciousBytes = 0; + const totalBytes = Math.min(bytesRead, MAX_BYTES); + // UTF-8 BOM + if (bytesRead >= 3 && fileBuffer[0] === 0xef && fileBuffer[1] === 0xbb && fileBuffer[2] === 0xbf) { + return false; + } + // UTF-32 BOM + if (bytesRead >= 4 && + fileBuffer[0] === 0x00 && + fileBuffer[1] === 0x00 && + fileBuffer[2] === 0xfe && + fileBuffer[3] === 0xff) { + return false; + } + // UTF-32 LE BOM + if (bytesRead >= 4 && + fileBuffer[0] === 0xff && + fileBuffer[1] === 0xfe && + fileBuffer[2] === 0x00 && + fileBuffer[3] === 0x00) { + return false; + } + // GB BOM + if (bytesRead >= 4 && + fileBuffer[0] === 0x84 && + fileBuffer[1] === 0x31 && + fileBuffer[2] === 0x95 && + fileBuffer[3] === 0x33) { + return false; + } + if (totalBytes >= 5 && fileBuffer.slice(0, 5).toString() === '%PDF-') { + /* PDF. This is binary. */ + return true; + } + // UTF-16 BE BOM + if (bytesRead >= 2 && fileBuffer[0] === 0xfe && fileBuffer[1] === 0xff) { + return false; + } + // UTF-16 LE BOM + if (bytesRead >= 2 && fileBuffer[0] === 0xff && fileBuffer[1] === 0xfe) { + return false; + } + for (let i = 0; i < totalBytes; i++) { + if (fileBuffer[i] === 0) { + // NULL byte--it's binary! + return true; + } + else if ((fileBuffer[i] < 7 || fileBuffer[i] > 14) && (fileBuffer[i] < 32 || fileBuffer[i] > 127)) { + // UTF-8 detection + if (fileBuffer[i] > 193 && fileBuffer[i] < 224 && i + 1 < totalBytes) { + i++; + if (fileBuffer[i] > 127 && fileBuffer[i] < 192) { + continue; + } + } + else if (fileBuffer[i] > 223 && fileBuffer[i] < 240 && i + 2 < totalBytes) { + i++; + if (fileBuffer[i] > 127 && fileBuffer[i] < 192 && fileBuffer[i + 1] > 127 && fileBuffer[i + 1] < 192) { + i++; + continue; + } + } + suspiciousBytes++; + // Read at least 32 fileBuffer before making a decision + if (i >= 32 && (suspiciousBytes * 100) / totalBytes > 10) { + return true; + } + } + } + if ((suspiciousBytes * 100) / totalBytes > 10) { + return true; + } + if (suspiciousBytes > 1 && isBinaryProto(fileBuffer, totalBytes)) { + return true; + } + return false; +} +function isString(x) { + return typeof x === 'string'; +} +function isStatFile(stat) { + if (!stat.isFile()) { + throw new Error(`Path provided was not a file!`); + } +} |