mharj-diskinfo 0.0.2 → 0.2.0

package/README.md

@@ -1,18 +1,19 @@
 # diskinfo
 
 read disk partition and filesystem information with NodeJS
+Requires: NodeJS 10.4 as using Bigint
 
 ```bash
 npm install mharj-diskinfo --save
 ```
 
 ```javascript
-const fs = require("fs");
-const scan = require("mharj-diskinfo").scan;
-const device = "\\\\.\\PHYSICALDRIVE0";
+const fs = require('fs');
+const scan = require('mharj-diskinfo').scan;
+const device = '\\\\.\\PHYSICALDRIVE0';
 //const device = '/dev/sda';
-const fd = fs.openSync(device, "rs+");
-let data = scan(fd);
+const fd = fs.openSync(device, 'rs+');
+let data = await scan(fd);
 console.log(data);
 ```
 

package/dist/index.cjs

@@ -0,0 +1,228 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+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 __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs);
+//#region src/Magic.ts
+var Magic = class {
+	constructor(fd) {
+		this.fd = fd;
+	}
+	haveExt(offset) {
+		const data = Buffer.allocUnsafe(2048);
+		node_fs.default.readSync(this.fd, data, 0, data.length, 512 * offset);
+		return data.readInt16BE(1080) === 21487;
+	}
+	haveNtfs(offset) {
+		const data = Buffer.allocUnsafe(512);
+		node_fs.default.readSync(this.fd, data, 0, data.length, 512 * offset);
+		return data.readInt32BE(3) === 1314145875;
+	}
+	haveLvm2(offset) {
+		const data = Buffer.allocUnsafe(1024);
+		node_fs.default.readSync(this.fd, data, 0, data.length, 512 * offset);
+		return data.readInt32BE(536) === 1280724274;
+	}
+};
+//#endregion
+//#region src/gptPart.ts
+const EFI_PART = Buffer.from([
+	69,
+	70,
+	73,
+	32,
+	80,
+	65,
+	82,
+	84
+]);
+const gptPartTypes = Object.freeze({
+	EMPTY: "00000000-0000-0000-0000-000000000000",
+	MBR: "024dee41-33e7-11d3-9d69-0008c781f39f",
+	EFI: "c12a7328-f81f-11d2-ba4b-00a0c93ec93b",
+	LINUX: "0fc63daf-8483-4772-8e79-3d69d8477de4",
+	LINUX_SWAP: "0657fd6d-a4ab-43c4-84e5-0933c84b4f4f",
+	LINUX_LVM: "e6d6d379-f507-44c2-a23c-238f2a3df928",
+	LINUX_RAID: "a19d880f-05fc-4d3b-a006-743f0f84911e",
+	MSR: "e3c9e316-0b5c-4db8-817d-f92df00215ae",
+	BASIC_DATA: "ebd0a0a2-b9e5-4433-87c0-68b6b72699c7",
+	getName: function(val) {
+		return Object.entries(this).reduce((acc, [k, v]) => {
+			if (typeof v === "string" && v === val) return k;
+			return acc;
+		}, "Unknown");
+	}
+});
+function readUuidBytes(buf, pos) {
+	return Buffer.from([
+		buf[pos + 3],
+		buf[pos + 2],
+		buf[pos + 1],
+		buf[pos + 0],
+		buf[pos + 5],
+		buf[pos + 4],
+		buf[pos + 7],
+		buf[pos + 6],
+		buf[pos + 8],
+		buf[pos + 9],
+		buf[pos + 10],
+		buf[pos + 11],
+		buf[pos + 12],
+		buf[pos + 13],
+		buf[pos + 14],
+		buf[pos + 15]
+	]);
+}
+function readUuidString(buf, pos) {
+	const uuid = readUuidBytes(buf, pos).toString("hex");
+	return `${uuid.slice(0, 8)}-${uuid.slice(8, 12)}-${uuid.slice(12, 16)}-${uuid.slice(16, 20)}-${uuid.slice(20, 32)}`;
+}
+function parseGPTable(buf) {
+	const typeId = readUuidString(buf, 0);
+	const uuid = readUuidString(buf, 16);
+	const startLBA = buf.readBigUInt64LE(32);
+	const endLBA = buf.readBigUInt64LE(40);
+	return {
+		typeId,
+		type: gptPartTypes.getName(typeId),
+		uuid,
+		active: uuid !== gptPartTypes.EMPTY,
+		startLBA,
+		endLBA,
+		partitionSize: endLBA - startLBA + 1n,
+		attributes: buf.readBigUInt64BE(48),
+		label: buf.subarray(56, 128).toString("utf16le").split("\0", 1)[0]
+	};
+}
+function parseGPT(buf) {
+	if (buf.indexOf(EFI_PART) !== 0) throw Error("not GTP entry");
+	return {
+		revision: `${buf[8]}.${buf[9]}.${buf[10]}.${buf[11]}`,
+		headerSize: buf.readUInt32LE(12),
+		headerCRC32: buf.readUInt32LE(16),
+		currentLBA: buf.readBigUInt64LE(24),
+		backupLBA: buf.readBigUInt64LE(32),
+		firstUsableLBA: buf.readBigUInt64LE(40),
+		lastUsableLBA: buf.readBigUInt64LE(48),
+		uuid: readUuidString(buf, 56),
+		tableLBA: buf.readBigUInt64LE(72),
+		partitions: buf.readUInt32LE(80),
+		partitionSize: buf.readUInt32LE(84),
+		partitionCRC32: buf.readUInt32LE(88)
+	};
+}
+//#endregion
+//#region src/mbrPart.ts
+const partTypes = {
+	EMPTY: 0,
+	EXTENDED: 5,
+	NTFS: 7,
+	LINUX_SWAP: 130,
+	LINUX: 131,
+	LINUX_EXTENDED: 133,
+	LINUX_LVM: 142,
+	GPT: 238,
+	EFI: 239,
+	LINUX_RAID: 253,
+	getName: function(val) {
+		return Object.entries(this).reduce((acc, [k, v]) => {
+			if (typeof v === "number" && v === val) return k;
+			return acc;
+		}, "Unknown");
+	}
+};
+function parseMBR(mbr) {
+	if (mbr.length < 512 || mbr[510] !== 85 || mbr[511] !== 170) throw Error("no MBR signature or buffer is less than 512 bytes");
+	const ret = {
+		copyProtected: !!(mbr[444] === 90 && mbr[444] === 90),
+		uuid: Buffer.from([
+			mbr[443],
+			mbr[442],
+			mbr[441],
+			mbr[440]
+		]).toString("hex"),
+		partitions: [],
+		type: "MBR"
+	};
+	for (let i = 446; i <= 508; i += 16) ret.partitions.push(parseMBRPartition(mbr.slice(i, i + 16)));
+	return ret;
+}
+function parseMBRPartition(part) {
+	const startLBA = part.readUInt32LE(8);
+	const partitionSize = part.readUInt32LE(12);
+	return {
+		active: part.readUInt8(0) === 128,
+		type: part.readUInt8(4),
+		startLBA,
+		partitionSize,
+		endLBA: startLBA + partitionSize
+	};
+}
+function isMbrPartition(part) {
+	return typeof part.type === "number";
+}
+//#endregion
+//#region src/util.ts
+function readFile(fd, offset, length, position) {
+	return new Promise((resolve, reject) => {
+		const buffer = Buffer.allocUnsafe(length);
+		node_fs.default.read(fd, buffer, offset, buffer.length, position, (err) => {
+			if (err) reject(err);
+			else resolve(buffer);
+		});
+	});
+}
+//#endregion
+//#region src/scan.ts
+async function scan(fd) {
+	const rootMbr = parseMBR(await readFile(fd, 0, 512, 0));
+	rootMbr.partitions.forEach(async function(p) {
+		if (p.type === partTypes.EXTENDED) {
+			if (!isMbrPartition(p)) throw TypeError("we did get GPT partition as extended");
+			parseMBR(await readFile(fd, 0, 512, 512)).partitions.forEach(function(extpart) {
+				if (!isMbrPartition(extpart)) throw TypeError("we did get GPT partition as extended");
+				if (extpart.type !== partTypes.EMPTY) {
+					extpart.startLBA = extpart.startLBA + p.startLBA;
+					rootMbr.partitions.push(extpart);
+				}
+			});
+		}
+		if (p.type === partTypes.GPT) {
+			rootMbr.type = "GPT";
+			const gpt = parseGPT(await readFile(fd, 0, 512, 512));
+			rootMbr.uuid = gpt.uuid;
+			const gBuff = Buffer.allocUnsafe(gpt.partitions * gpt.partitionSize);
+			node_fs.default.readSync(fd, gBuff, 0, gBuff.length, Number(gpt.tableLBA) * 512);
+			const partitions = [];
+			for (let i = 0; i < gpt.partitions * gpt.partitionSize; i += gpt.partitionSize) {
+				const table = parseGPTable(gBuff.slice(i, i + gpt.partitionSize));
+				if (table.typeId !== gptPartTypes.EMPTY) partitions.push(table);
+			}
+			rootMbr.partitions = partitions;
+		}
+	});
+	return rootMbr;
+}
+//#endregion
+exports.Magic = Magic;
+exports.scan = scan;

package/dist/index.d.cts

@@ -0,0 +1,48 @@
+//#region src/Magic.d.ts
+declare class Magic {
+  private fd;
+  constructor(fd: number);
+  haveExt(offset: number): boolean;
+  haveNtfs(offset: number): boolean;
+  haveLvm2(offset: number): boolean;
+}
+//#endregion
+//#region src/types.d.ts
+type MBRPartition = {
+  active: boolean;
+  type: number;
+  startLBA: number;
+  partitionSize: number;
+  endLBA: number;
+};
+type GPTPartition = {
+  typeId: string;
+  type: string;
+  uuid: string;
+  active: boolean;
+  startLBA: bigint;
+  endLBA: bigint;
+  partitionSize: bigint;
+  attributes: bigint;
+  label: string;
+};
+//#endregion
+//#region src/mbrPart.d.ts
+type GptData = {
+  copyProtected: boolean;
+  uuid: string;
+  type: 'GPT';
+  partitions: GPTPartition[];
+};
+type MbrData = {
+  copyProtected: boolean;
+  uuid: string;
+  type: 'MBR';
+  partitions: MBRPartition[];
+};
+type IMbrData = MbrData | GptData;
+//#endregion
+//#region src/scan.d.ts
+declare function scan(fd: number): Promise<IMbrData>;
+//#endregion
+export { Magic, scan };

package/dist/index.d.mts

@@ -0,0 +1,48 @@
+//#region src/Magic.d.ts
+declare class Magic {
+  private fd;
+  constructor(fd: number);
+  haveExt(offset: number): boolean;
+  haveNtfs(offset: number): boolean;
+  haveLvm2(offset: number): boolean;
+}
+//#endregion
+//#region src/types.d.ts
+type MBRPartition = {
+  active: boolean;
+  type: number;
+  startLBA: number;
+  partitionSize: number;
+  endLBA: number;
+};
+type GPTPartition = {
+  typeId: string;
+  type: string;
+  uuid: string;
+  active: boolean;
+  startLBA: bigint;
+  endLBA: bigint;
+  partitionSize: bigint;
+  attributes: bigint;
+  label: string;
+};
+//#endregion
+//#region src/mbrPart.d.ts
+type GptData = {
+  copyProtected: boolean;
+  uuid: string;
+  type: 'GPT';
+  partitions: GPTPartition[];
+};
+type MbrData = {
+  copyProtected: boolean;
+  uuid: string;
+  type: 'MBR';
+  partitions: MBRPartition[];
+};
+type IMbrData = MbrData | GptData;
+//#endregion
+//#region src/scan.d.ts
+declare function scan(fd: number): Promise<IMbrData>;
+//#endregion
+export { Magic, scan };

package/dist/index.mjs

@@ -0,0 +1,203 @@
+import fs from "node:fs";
+//#region src/Magic.ts
+var Magic = class {
+	constructor(fd) {
+		this.fd = fd;
+	}
+	haveExt(offset) {
+		const data = Buffer.allocUnsafe(2048);
+		fs.readSync(this.fd, data, 0, data.length, 512 * offset);
+		return data.readInt16BE(1080) === 21487;
+	}
+	haveNtfs(offset) {
+		const data = Buffer.allocUnsafe(512);
+		fs.readSync(this.fd, data, 0, data.length, 512 * offset);
+		return data.readInt32BE(3) === 1314145875;
+	}
+	haveLvm2(offset) {
+		const data = Buffer.allocUnsafe(1024);
+		fs.readSync(this.fd, data, 0, data.length, 512 * offset);
+		return data.readInt32BE(536) === 1280724274;
+	}
+};
+//#endregion
+//#region src/gptPart.ts
+const EFI_PART = Buffer.from([
+	69,
+	70,
+	73,
+	32,
+	80,
+	65,
+	82,
+	84
+]);
+const gptPartTypes = Object.freeze({
+	EMPTY: "00000000-0000-0000-0000-000000000000",
+	MBR: "024dee41-33e7-11d3-9d69-0008c781f39f",
+	EFI: "c12a7328-f81f-11d2-ba4b-00a0c93ec93b",
+	LINUX: "0fc63daf-8483-4772-8e79-3d69d8477de4",
+	LINUX_SWAP: "0657fd6d-a4ab-43c4-84e5-0933c84b4f4f",
+	LINUX_LVM: "e6d6d379-f507-44c2-a23c-238f2a3df928",
+	LINUX_RAID: "a19d880f-05fc-4d3b-a006-743f0f84911e",
+	MSR: "e3c9e316-0b5c-4db8-817d-f92df00215ae",
+	BASIC_DATA: "ebd0a0a2-b9e5-4433-87c0-68b6b72699c7",
+	getName: function(val) {
+		return Object.entries(this).reduce((acc, [k, v]) => {
+			if (typeof v === "string" && v === val) return k;
+			return acc;
+		}, "Unknown");
+	}
+});
+function readUuidBytes(buf, pos) {
+	return Buffer.from([
+		buf[pos + 3],
+		buf[pos + 2],
+		buf[pos + 1],
+		buf[pos + 0],
+		buf[pos + 5],
+		buf[pos + 4],
+		buf[pos + 7],
+		buf[pos + 6],
+		buf[pos + 8],
+		buf[pos + 9],
+		buf[pos + 10],
+		buf[pos + 11],
+		buf[pos + 12],
+		buf[pos + 13],
+		buf[pos + 14],
+		buf[pos + 15]
+	]);
+}
+function readUuidString(buf, pos) {
+	const uuid = readUuidBytes(buf, pos).toString("hex");
+	return `${uuid.slice(0, 8)}-${uuid.slice(8, 12)}-${uuid.slice(12, 16)}-${uuid.slice(16, 20)}-${uuid.slice(20, 32)}`;
+}
+function parseGPTable(buf) {
+	const typeId = readUuidString(buf, 0);
+	const uuid = readUuidString(buf, 16);
+	const startLBA = buf.readBigUInt64LE(32);
+	const endLBA = buf.readBigUInt64LE(40);
+	return {
+		typeId,
+		type: gptPartTypes.getName(typeId),
+		uuid,
+		active: uuid !== gptPartTypes.EMPTY,
+		startLBA,
+		endLBA,
+		partitionSize: endLBA - startLBA + 1n,
+		attributes: buf.readBigUInt64BE(48),
+		label: buf.subarray(56, 128).toString("utf16le").split("\0", 1)[0]
+	};
+}
+function parseGPT(buf) {
+	if (buf.indexOf(EFI_PART) !== 0) throw Error("not GTP entry");
+	return {
+		revision: `${buf[8]}.${buf[9]}.${buf[10]}.${buf[11]}`,
+		headerSize: buf.readUInt32LE(12),
+		headerCRC32: buf.readUInt32LE(16),
+		currentLBA: buf.readBigUInt64LE(24),
+		backupLBA: buf.readBigUInt64LE(32),
+		firstUsableLBA: buf.readBigUInt64LE(40),
+		lastUsableLBA: buf.readBigUInt64LE(48),
+		uuid: readUuidString(buf, 56),
+		tableLBA: buf.readBigUInt64LE(72),
+		partitions: buf.readUInt32LE(80),
+		partitionSize: buf.readUInt32LE(84),
+		partitionCRC32: buf.readUInt32LE(88)
+	};
+}
+//#endregion
+//#region src/mbrPart.ts
+const partTypes = {
+	EMPTY: 0,
+	EXTENDED: 5,
+	NTFS: 7,
+	LINUX_SWAP: 130,
+	LINUX: 131,
+	LINUX_EXTENDED: 133,
+	LINUX_LVM: 142,
+	GPT: 238,
+	EFI: 239,
+	LINUX_RAID: 253,
+	getName: function(val) {
+		return Object.entries(this).reduce((acc, [k, v]) => {
+			if (typeof v === "number" && v === val) return k;
+			return acc;
+		}, "Unknown");
+	}
+};
+function parseMBR(mbr) {
+	if (mbr.length < 512 || mbr[510] !== 85 || mbr[511] !== 170) throw Error("no MBR signature or buffer is less than 512 bytes");
+	const ret = {
+		copyProtected: !!(mbr[444] === 90 && mbr[444] === 90),
+		uuid: Buffer.from([
+			mbr[443],
+			mbr[442],
+			mbr[441],
+			mbr[440]
+		]).toString("hex"),
+		partitions: [],
+		type: "MBR"
+	};
+	for (let i = 446; i <= 508; i += 16) ret.partitions.push(parseMBRPartition(mbr.slice(i, i + 16)));
+	return ret;
+}
+function parseMBRPartition(part) {
+	const startLBA = part.readUInt32LE(8);
+	const partitionSize = part.readUInt32LE(12);
+	return {
+		active: part.readUInt8(0) === 128,
+		type: part.readUInt8(4),
+		startLBA,
+		partitionSize,
+		endLBA: startLBA + partitionSize
+	};
+}
+function isMbrPartition(part) {
+	return typeof part.type === "number";
+}
+//#endregion
+//#region src/util.ts
+function readFile(fd, offset, length, position) {
+	return new Promise((resolve, reject) => {
+		const buffer = Buffer.allocUnsafe(length);
+		fs.read(fd, buffer, offset, buffer.length, position, (err) => {
+			if (err) reject(err);
+			else resolve(buffer);
+		});
+	});
+}
+//#endregion
+//#region src/scan.ts
+async function scan(fd) {
+	const rootMbr = parseMBR(await readFile(fd, 0, 512, 0));
+	rootMbr.partitions.forEach(async function(p) {
+		if (p.type === partTypes.EXTENDED) {
+			if (!isMbrPartition(p)) throw TypeError("we did get GPT partition as extended");
+			parseMBR(await readFile(fd, 0, 512, 512)).partitions.forEach(function(extpart) {
+				if (!isMbrPartition(extpart)) throw TypeError("we did get GPT partition as extended");
+				if (extpart.type !== partTypes.EMPTY) {
+					extpart.startLBA = extpart.startLBA + p.startLBA;
+					rootMbr.partitions.push(extpart);
+				}
+			});
+		}
+		if (p.type === partTypes.GPT) {
+			rootMbr.type = "GPT";
+			const gpt = parseGPT(await readFile(fd, 0, 512, 512));
+			rootMbr.uuid = gpt.uuid;
+			const gBuff = Buffer.allocUnsafe(gpt.partitions * gpt.partitionSize);
+			fs.readSync(fd, gBuff, 0, gBuff.length, Number(gpt.tableLBA) * 512);
+			const partitions = [];
+			for (let i = 0; i < gpt.partitions * gpt.partitionSize; i += gpt.partitionSize) {
+				const table = parseGPTable(gBuff.slice(i, i + gpt.partitionSize));
+				if (table.typeId !== gptPartTypes.EMPTY) partitions.push(table);
+			}
+			rootMbr.partitions = partitions;
+		}
+	});
+	return rootMbr;
+}
+//#endregion
+export { Magic, scan };

package/package.json

@@ -1,38 +1,57 @@
 {
-    "name": "mharj-diskinfo",
-    "version": "0.0.2",
-    "description": "",
-    "main": "diskinfo.js",
-    "scripts": {
-        "test": "mocha"
-    },
-    "mocha": {
-        "exit": true,
-        "recursive": true,
-        "reporters": [
-            "spec"
-        ]
-    },
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/mharj/diskinfo.git"
-    },
-    "author": "mharj",
-    "license": "LGPL",
-    "bugs": {
-        "url": "https://github.com/mharj/diskinfo/issues"
-    },
-    "homepage": "https://github.com/mharj/diskinfo#readme",
-    "devDependencies": {
-        "buffer-crc32": "^0.2.13",
-        "chai": "^4.0.2",
-        "chai-things": "^0.2.0",
-        "eslint": "^7.32.0",
-        "eslint-config-google": "^0.14.0",
-        "mocha": "^9.1.0"
-    },
-    "dependencies": {
-        "iconv-lite": "^0.6.3",
-        "uuid-parse": "^1.0.0"
-    }
+	"name": "mharj-diskinfo",
+	"version": "0.2.0",
+	"description": "Node.js library to parse MBR and GPT partition information from disk images or devices.",
+	"main": "./dist/index.cjs",
+	"module": "./dist/index.mjs",
+	"types": "./dist/index.d.mts",
+	"exports": {
+		"import": {
+			"types": "./dist/index.d.mts",
+			"default": "./dist/index.mjs"
+		},
+		"require": {
+			"types": "./dist/index.d.cts",
+			"default": "./dist/index.cjs"
+		},
+		"default": "./dist/index.mjs"
+	},
+	"scripts": {
+		"prepare": "lefthook install",
+		"build": "tsdown src/index.ts --format cjs,esm --dts --clean",
+		"prepublishOnly": "npm run build",
+		"test": "vitest test --typecheck --run --no-isolate --coverage",
+		"coverage": "vitest test --run --no-isolate --reporter=dot --coverage --coverage.reporter=lcov",
+		"lint": "biome check",
+		"validate": "tsc --noEmit --project tsconfig.test.json"
+	},
+	"repository": "github:mharj/diskinfo",
+	"files": [
+		"dist"
+	],
+	"engines": {
+		"node": ">=10.4.0"
+	},
+	"author": "mharj",
+	"license": "LGPL",
+	"bugs": {
+		"url": "https://github.com/mharj/diskinfo/issues"
+	},
+	"homepage": "https://github.com/mharj/diskinfo#readme",
+	"devDependencies": {
+		"@biomejs/biome": "^2.4.15",
+		"@tsconfig/node16": "^16.1.8",
+		"@types/buffer-crc32": "^0.2.0",
+		"@types/node": "^22.19.1",
+		"@vitest/coverage-v8": "^4.1.6",
+		"buffer-crc32": "^0.2.13",
+		"c8": "^11.0.0",
+		"lefthook": "^2.1.6",
+		"tsdown": "^0.22.0",
+		"tslib": "^2.8.1",
+		"typescript": "^6.0.3",
+		"vite": "^8.0.12",
+		"vitest": "^4.1.6"
+	},
+	"packageManager": "pnpm@10.33.4+sha512.1c67b3b359b2d408119ba1ed289f34b8fc3c6873412bec6fd264fbdc82489e510fcbecb9ce9d22dae7f3b76269d8441046014bdca53b9979cd7a561ad631b800"
 }

package/diskinfo.js

@@ -1,179 +0,0 @@
-const fs = require('fs');
-const iconv = require('iconv-lite');
-const uuidParse = require('uuid-parse');
-const EFI_PART = Buffer.from([0x45, 0x46, 0x49, 0x20, 0x50, 0x41, 0x52, 0x54]);
-
-const gptPartTypes = Object.freeze({
-	EMPTY:				'00000000-0000-0000-0000-000000000000',
-	MBR:				'024dee41-33e7-11d3-9d69-0008c781f39f',
-	EFI:				'c12a7328-f81f-11d2-ba4b-00a0c93ec93b',
-	LINUX:				'0fc63daf-8483-4772-8e79-3d69d8477de4',
-	LINUX_SWAP:			'0657fd6d-a4ab-43c4-84e5-0933c84b4f4f',
-	LINUX_LVM:			'e6d6d379-f507-44c2-a23c-238f2a3df928',
-	LINUX_RAID:			'a19d880f-05fc-4d3b-a006-743f0f84911e',
-	MSR:				'e3c9e316-0b5c-4db8-817d-f92df00215ae',
-	BASIC_DATA:			'ebd0a0a2-b9e5-4433-87c0-68b6b72699c7',
-	getName: function(val) { // print names for values
-		for (let k in gptPartTypes) {
-			if (gptPartTypes[k] == val) {
-				return k;
-			}
-		}
-		return 'Unknown';
-	},
-});
-module.exports.gptPartTypes = gptPartTypes;
-
-const partTypes = {
-	EMPTY:				0x00,
-	EXTENDED:			0x05,
-	NTFS:				0x07,
-	LINUX_SWAP:			0x82,
-	LINUX:				0x83,
-	LINUX_EXTENDED:		0x85,
-	LINUX_LVM:			0x8e,
-	GPT:				0xee,
-	EFI:				0xef,
-	LINUX_RAID:			0xfd,
-	getName: function(val) { // print names for values
-		for (let k in partTypes) {
-			if (partTypes[k] == val) {
-				return k+' ('+val.toString(16)+')';
-			}
-		}
-		return '('+val.toString(16)+')';
-	},
-};
-module.exports.partTypes = partTypes;
-
-function parseMBRPartition(part) {
-	let out = {};
-	out.active = (part.readUInt8(0)==0x80?true:false);
-//	out.startCHS = Buffer.from([part[1],part[2],part[3]]); // obsolete
-	out.type = part.readUInt8(4);
-//	out.endCHS = Buffer.from([part[5],part[6],part[7]]); // obsolete
-	out.startLBA = part.readUInt32LE(8);
-	out.partitionSize = part.readUInt32LE(12);
-	out.endLBA = out.startLBA+out.partitionSize;
-	return out;
-}
-
-function parseMBR(mbr) {
-	if ( mbr.length < 512 || mbr[0x1fe] != 85 || mbr[0x1ff] != 170 ) { // MBR signature
-		throw Error('no MBR signature or buffer is less than 512 bytes');
-	}
-	let ret = {partitions: []};
-	if ( mbr[0x1bc] == 90 && mbr[0x1bc] == 90 ) { // 0x5A5A = copy protected (UEFI)
-		ret.copyProtected = true;
-	}
-	ret.uuid = Buffer.from([mbr[0x1bb], mbr[0x1ba], mbr[0x1b9], mbr[0x1b8]]).toString('hex'); // DiskID: 1B8 (hex) through 1BE (hex) (looks like reverse)
-	for (let i = 446; i <= 508; i += 16) { // MBR table blocks
-		ret.partitions.push( parseMBRPartition( mbr.slice(i, i+16) ) );
-	}
-	return ret;
-}
-module.exports.parseMBR = parseMBR;
-
-function readUuidBytes(buf, pos) {
-	return [
-		buf[(pos+3)], buf[(pos+2)], buf[(pos+1)], buf[(pos+0)],
-		buf[(pos+5)], buf[(pos+4)], buf[(pos+7)], buf[(pos+6)],
-		buf[(pos+8)], buf[(pos+9)], buf[(pos+10)], buf[(pos+11)],
-		buf[(pos+12)], buf[(pos+13)], buf[(pos+14)], buf[(pos+15)],
-	];
-}
-
-function parseGPT(buf) { // https://en.wikipedia.org/wiki/GUID_Partition_Table
-	let out = {};
-	if ( buf.indexOf(EFI_PART) != 0 ) {
-		throw Error('not GTP entry');
-	}
-	out.revision = buf[8]+'.'+buf[9]+'.'+buf[10]+'.'+buf[11];
-	out.headerSize = buf.readUInt32LE(12);
-	out.headerCRC32 = buf.readUInt32LE(16);
-	// buf.readUInt32LE(20); // reserved; must be zero
-	out.currentLBA = buf.readBigUInt64LE(24); // Warning: 64bit uint, JS uses this as 53bit
-	out.backupLBA = buf.readBigUInt64LE(32); // Warning: 64bit uint, JS uses this as 53bit
-	out.firstUsableLBA = buf.readBigUInt64LE(40); // Warning: 64bit uint, JS uses this as 53bit
-	out.lastUsableLBA = buf.readBigUInt64LE(48); // Warning: 64bit uint, JS uses this as 53bit
-	out.uuid = uuidParse.unparse(readUuidBytes(buf, 56));
-	out.tableLBA = buf.readBigUInt64LE(72); // Warning: 64bit uint, JS uses this as 53bit
-	out.partitions = buf.readUInt32LE(80);
-	out.partitionSize = buf.readUInt32LE(84);
-	out.partitionCRC32 = buf.readUInt32LE(88);
-	return out;
-}
-module.exports.parseGPT = parseGPT;
-
-function parseGPTable(buf) {
-	let out = {};
-	out.typeId = uuidParse.unparse(readUuidBytes(buf, 0));
-	out.type = gptPartTypes.getName(out.typeId);
-	out.uuid = uuidParse.unparse(readUuidBytes(buf, 16));
-	out.active = (out.uuid==gptPartTypes.EMPTY?false:true);
-	out.startLBA = buf.readBigUInt64LE(32); // Warning: 64bit uint, JS uses this as 53bit
-	out.endLBA = buf.readBigUInt64LE(40); // Warning: 64bit uint, JS uses this as 53bit
-	out.partitionSize = out.endLBA-out.startLBA + 1n; // +1?
-	out.attributes = buf.readBigUInt64BE(48); // Warning: 64bit uint, JS uses this as 53bit
-	out.label = iconv.decode(buf.slice(56, 128), 'utf16le').split('\u0000')[0]; // bit hack in here
-	return out;
-}
-module.exports.parseGPTable = parseGPTable;
-
-const buffer = Buffer.allocUnsafe(512);
-function scan(fd) {
-	if ( fs.readSync(fd, buffer, 0, buffer.length, 0) != 512 ) {
-		throw Error('read only partial data from MBR');
-	}
-	let rootMbr = parseMBR(buffer);
-	rootMbr.type = 'MBR';
-	rootMbr.partitions.forEach(function(p) {
-		if ( p.type == partTypes.EXTENDED ) { // Extended partition reading
-			fs.readSync(fd, buffer, 0, buffer.length, (p.startSector*512));
-			let extparts = parseMBR(buffer);
-			extparts.partitions.forEach(function(extpart) {
-				if ( extpart.type != partTypes.EMPTY ) {
-					extpart.startLBA = extpart.startLBA + p.startLBA;
-					rootMbr.partitions.push(extpart);
-				}
-			});
-		}
-		if ( p.type == partTypes.GPT ) { // GPT partition table reading
-			fs.readSync(fd, buffer, 0, buffer.length, 512);
-			let gpt = parseGPT(buffer);
-			rootMbr.uuid = gpt.uuid;
-			let gBuff = Buffer.allocUnsafe( (gpt.partitions*gpt.partitionSize) );
-			fs.readSync(fd, gBuff, 0, gBuff.length, (Number(gpt.tableLBA)*512));
-			let partitions = [];
-			for (let i=0; i < (gpt.partitions*gpt.partitionSize); i+=gpt.partitionSize ) {
-				let table = parseGPTable(gBuff.slice(i, i+gpt.partitionSize));
-				if ( table.typeId != gptPartTypes.EMPTY ) {
-					partitions.push(table);
-				}
-			}
-			rootMbr.partitions = partitions;
-			rootMbr.type = 'GPT';
-		}
-	});
-	return rootMbr;
-}
-module.exports.scan = scan;
-
-function magic(fd) {
-	this.haveExt = function(offset) {
-		let data = Buffer.allocUnsafe(2048);
-		fs.readSync(fd, data, 0, data.length, (512*offset) );
-		return (data.readInt16BE(1080) == 0x53ef);
-	};
-	this.haveNtfs = function(offset) {
-		let data = Buffer.allocUnsafe(512);
-		fs.readSync(fd, data, 0, data.length, (512*offset) );
-		return (data.readInt32BE(3) == 0x4e544653);
-	};
-	this.haveLvm2 = function(offset) {
-		let data = Buffer.allocUnsafe(1024);
-		fs.readSync(fd, data, 0, data.length, (512*offset) );
-		return (data.readInt32BE(536) == 0x4c564d32);
-	};
-}
-module.exports.magic = magic;