squidclaw 2026.4.17 → 2026.4.19

package/dist/.buildstamp

@@ -1 +1 @@
-{"builtAt":1775944565689,"head":"32e5acebe3ea82c0e34b0ca64344b77867ad1458"}
+{"builtAt":1775947787852,"head":"789374efc613ef23597f9383ff4b823af9d22752"}

package/dist/APEv2Parser-Byki9wgz.js

@@ -0,0 +1,270 @@
+import { s as __toESM } from "./chunk-iyeSoAlh.js";
+import { t as require_src } from "./src-CIahKhwM.js";
+import { t as fromBuffer } from "./lib-CHnMkEa4.js";
+import { E as Uint8ArrayType, O as textDecode, S as UINT32_LE, g as StringType, i as InternalParserError, k as textEncode, o as makeUnexpectedFileContentError, r as FieldDecodingError, t as BasicParser, v as UINT16_LE } from "./BasicParser-BqmIJ1g9.js";
+import { i as findZero, t as a2hex } from "./Util-PR05EC9j.js";
+//#region node_modules/.pnpm/music-metadata@11.12.3/node_modules/music-metadata/lib/common/FourCC.js
+const validFourCC = /^[\x21-\x7e©][\x20-\x7e\x00()]{3}/;
+/**
+* Token for read FourCC
+* Ref: https://en.wikipedia.org/wiki/FourCC
+*/
+const FourCcToken = {
+	len: 4,
+	get: (buf, off) => {
+		const id = textDecode(buf.subarray(off, off + FourCcToken.len), "latin1");
+		if (!id.match(validFourCC)) throw new FieldDecodingError(`FourCC contains invalid characters: ${a2hex(id)} "${id}"`);
+		return id;
+	},
+	put: (buffer, offset, id) => {
+		const str = textEncode(id, "latin1");
+		if (str.length !== 4) throw new InternalParserError("Invalid length");
+		buffer.set(str, offset);
+		return offset + 4;
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/music-metadata@11.12.3/node_modules/music-metadata/lib/apev2/APEv2Token.js
+const DataType = {
+	text_utf8: 0,
+	binary: 1,
+	external_info: 2,
+	reserved: 3
+};
+/**
+* APE_DESCRIPTOR: defines the sizes (and offsets) of all the pieces, as well as the MD5 checksum
+*/
+const DescriptorParser = {
+	len: 52,
+	get: (buf, off) => {
+		return {
+			ID: FourCcToken.get(buf, off),
+			version: UINT32_LE.get(buf, off + 4) / 1e3,
+			descriptorBytes: UINT32_LE.get(buf, off + 8),
+			headerBytes: UINT32_LE.get(buf, off + 12),
+			seekTableBytes: UINT32_LE.get(buf, off + 16),
+			headerDataBytes: UINT32_LE.get(buf, off + 20),
+			apeFrameDataBytes: UINT32_LE.get(buf, off + 24),
+			apeFrameDataBytesHigh: UINT32_LE.get(buf, off + 28),
+			terminatingDataBytes: UINT32_LE.get(buf, off + 32),
+			fileMD5: new Uint8ArrayType(16).get(buf, off + 36)
+		};
+	}
+};
+/**
+* APE_HEADER: describes all of the necessary information about the APE file
+*/
+const Header = {
+	len: 24,
+	get: (buf, off) => {
+		return {
+			compressionLevel: UINT16_LE.get(buf, off),
+			formatFlags: UINT16_LE.get(buf, off + 2),
+			blocksPerFrame: UINT32_LE.get(buf, off + 4),
+			finalFrameBlocks: UINT32_LE.get(buf, off + 8),
+			totalFrames: UINT32_LE.get(buf, off + 12),
+			bitsPerSample: UINT16_LE.get(buf, off + 16),
+			channel: UINT16_LE.get(buf, off + 18),
+			sampleRate: UINT32_LE.get(buf, off + 20)
+		};
+	}
+};
+/**
+* APE Tag Header/Footer Version 2.0
+* TAG: describes all the properties of the file [optional]
+*/
+const TagFooter = {
+	len: 32,
+	get: (buf, off) => {
+		return {
+			ID: new StringType(8, "ascii").get(buf, off),
+			version: UINT32_LE.get(buf, off + 8),
+			size: UINT32_LE.get(buf, off + 12),
+			fields: UINT32_LE.get(buf, off + 16),
+			flags: parseTagFlags(UINT32_LE.get(buf, off + 20))
+		};
+	}
+};
+/**
+* APE Tag v2.0 Item Header
+*/
+const TagItemHeader = {
+	len: 8,
+	get: (buf, off) => {
+		return {
+			size: UINT32_LE.get(buf, off),
+			flags: parseTagFlags(UINT32_LE.get(buf, off + 4))
+		};
+	}
+};
+function parseTagFlags(flags) {
+	return {
+		containsHeader: isBitSet(flags, 31),
+		containsFooter: isBitSet(flags, 30),
+		isHeader: isBitSet(flags, 29),
+		readOnly: isBitSet(flags, 0),
+		dataType: (flags & 6) >> 1
+	};
+}
+/**
+* @param num {number}
+* @param bit 0 is least significant bit (LSB)
+* @return {boolean} true if bit is 1; otherwise false
+*/
+function isBitSet(num, bit) {
+	return (num & 1 << bit) !== 0;
+}
+const debug = (0, (/* @__PURE__ */ __toESM(require_src(), 1)).default)("music-metadata:parser:APEv2");
+const tagFormat = "APEv2";
+const preamble = "APETAGEX";
+var ApeContentError = class extends makeUnexpectedFileContentError("APEv2") {};
+function tryParseApeHeader(metadata, tokenizer, options) {
+	return new APEv2Parser(metadata, tokenizer, options).tryParseApeHeader();
+}
+var APEv2Parser = class APEv2Parser extends BasicParser {
+	constructor() {
+		super(...arguments);
+		this.ape = {};
+	}
+	/**
+	* Calculate the media file duration
+	* @param ah ApeHeader
+	* @return {number} duration in seconds
+	*/
+	static calculateDuration(ah) {
+		let duration = ah.totalFrames > 1 ? ah.blocksPerFrame * (ah.totalFrames - 1) : 0;
+		duration += ah.finalFrameBlocks;
+		return duration / ah.sampleRate;
+	}
+	/**
+	* Calculates the APEv1 / APEv2 first field offset
+	* @param tokenizer
+	* @param offset
+	*/
+	static async findApeFooterOffset(tokenizer, offset) {
+		const apeBuf = new Uint8Array(TagFooter.len);
+		const position = tokenizer.position;
+		if (offset <= TagFooter.len) {
+			debug(`Offset is too small to read APE footer: offset=${offset}`);
+			return;
+		}
+		if (offset > TagFooter.len) {
+			await tokenizer.readBuffer(apeBuf, { position: offset - TagFooter.len });
+			tokenizer.setPosition(position);
+			const tagFooter = TagFooter.get(apeBuf, 0);
+			if (tagFooter.ID === "APETAGEX") {
+				if (tagFooter.flags.isHeader) debug(`APE Header found at offset=${offset - TagFooter.len}`);
+				else {
+					debug(`APE Footer found at offset=${offset - TagFooter.len}`);
+					offset -= tagFooter.size;
+				}
+				return {
+					footer: tagFooter,
+					offset
+				};
+			}
+		}
+	}
+	static parseTagFooter(metadata, buffer, options) {
+		const footer = TagFooter.get(buffer, buffer.length - TagFooter.len);
+		if (footer.ID !== preamble) throw new ApeContentError("Unexpected APEv2 Footer ID preamble value");
+		fromBuffer(buffer);
+		return new APEv2Parser(metadata, fromBuffer(buffer), options).parseTags(footer);
+	}
+	/**
+	* Parse APEv1 / APEv2 header if header signature found
+	*/
+	async tryParseApeHeader() {
+		if (this.tokenizer.fileInfo.size && this.tokenizer.fileInfo.size - this.tokenizer.position < TagFooter.len) {
+			debug("No APEv2 header found, end-of-file reached");
+			return;
+		}
+		const footer = await this.tokenizer.peekToken(TagFooter);
+		if (footer.ID === preamble) {
+			await this.tokenizer.ignore(TagFooter.len);
+			return this.parseTags(footer);
+		}
+		debug(`APEv2 header not found at offset=${this.tokenizer.position}`);
+		if (this.tokenizer.fileInfo.size) {
+			const remaining = this.tokenizer.fileInfo.size - this.tokenizer.position;
+			const buffer = new Uint8Array(remaining);
+			await this.tokenizer.readBuffer(buffer);
+			return APEv2Parser.parseTagFooter(this.metadata, buffer, this.options);
+		}
+	}
+	async parse() {
+		const descriptor = await this.tokenizer.readToken(DescriptorParser);
+		if (descriptor.ID !== "MAC ") throw new ApeContentError("Unexpected descriptor ID");
+		this.ape.descriptor = descriptor;
+		const lenExp = descriptor.descriptorBytes - DescriptorParser.len;
+		const header = await (lenExp > 0 ? this.parseDescriptorExpansion(lenExp) : this.parseHeader());
+		this.metadata.setAudioOnly();
+		await this.tokenizer.ignore(header.forwardBytes);
+		return this.tryParseApeHeader();
+	}
+	async parseTags(footer) {
+		const keyBuffer = new Uint8Array(256);
+		let bytesRemaining = footer.size - TagFooter.len;
+		debug(`Parse APE tags at offset=${this.tokenizer.position}, size=${bytesRemaining}`);
+		for (let i = 0; i < footer.fields; i++) {
+			if (bytesRemaining < TagItemHeader.len) {
+				this.metadata.addWarning(`APEv2 Tag-header: ${footer.fields - i} items remaining, but no more tag data to read.`);
+				break;
+			}
+			const tagItemHeader = await this.tokenizer.readToken(TagItemHeader);
+			bytesRemaining -= TagItemHeader.len + tagItemHeader.size;
+			await this.tokenizer.peekBuffer(keyBuffer, { length: Math.min(keyBuffer.length, bytesRemaining) });
+			let zero = findZero(keyBuffer);
+			const key = await this.tokenizer.readToken(new StringType(zero, "ascii"));
+			await this.tokenizer.ignore(1);
+			bytesRemaining -= key.length + 1;
+			switch (tagItemHeader.flags.dataType) {
+				case DataType.text_utf8: {
+					const values = (await this.tokenizer.readToken(new StringType(tagItemHeader.size, "utf8"))).split(/\x00/g);
+					await Promise.all(values.map((val) => this.metadata.addTag(tagFormat, key, val)));
+					break;
+				}
+				case DataType.binary:
+					if (this.options.skipCovers) await this.tokenizer.ignore(tagItemHeader.size);
+					else {
+						const picData = new Uint8Array(tagItemHeader.size);
+						await this.tokenizer.readBuffer(picData);
+						zero = findZero(picData);
+						const description = textDecode(picData.subarray(0, zero), "utf-8");
+						const data = picData.subarray(zero + 1);
+						await this.metadata.addTag(tagFormat, key, {
+							description,
+							data
+						});
+					}
+					break;
+				case DataType.external_info:
+					debug(`Ignore external info ${key}`);
+					await this.tokenizer.ignore(tagItemHeader.size);
+					break;
+				case DataType.reserved:
+					debug(`Ignore external info ${key}`);
+					this.metadata.addWarning(`APEv2 header declares a reserved datatype for "${key}"`);
+					await this.tokenizer.ignore(tagItemHeader.size);
+					break;
+			}
+		}
+	}
+	async parseDescriptorExpansion(lenExp) {
+		await this.tokenizer.ignore(lenExp);
+		return this.parseHeader();
+	}
+	async parseHeader() {
+		const header = await this.tokenizer.readToken(Header);
+		this.metadata.setFormat("lossless", true);
+		this.metadata.setFormat("container", "Monkey's Audio");
+		this.metadata.setFormat("bitsPerSample", header.bitsPerSample);
+		this.metadata.setFormat("sampleRate", header.sampleRate);
+		this.metadata.setFormat("numberOfChannels", header.channel);
+		this.metadata.setFormat("duration", APEv2Parser.calculateDuration(header));
+		if (!this.ape.descriptor) throw new ApeContentError("Missing APE descriptor");
+		return { forwardBytes: this.ape.descriptor.seekTableBytes + this.ape.descriptor.headerDataBytes + this.ape.descriptor.apeFrameDataBytes + this.ape.descriptor.terminatingDataBytes };
+	}
+};
+//#endregion
+export { FourCcToken as i, ApeContentError as n, tryParseApeHeader as r, APEv2Parser as t };

package/dist/APEv2Parser-CEXXwbOf.js

@@ -0,0 +1,2 @@
+import { t as APEv2Parser } from "./APEv2Parser-Byki9wgz.js";
+export { APEv2Parser };

package/dist/AbstractID3Parser-FGwxcTBD.js

@@ -0,0 +1,48 @@
+import { s as __toESM } from "./chunk-iyeSoAlh.js";
+import { t as require_src } from "./src-CIahKhwM.js";
+import { n as EndOfStreamError } from "./lib-CHnMkEa4.js";
+import { t as BasicParser } from "./BasicParser-BqmIJ1g9.js";
+import { r as ID3v2Header } from "./ID3v2Token-BKd56zoU.js";
+import { n as ID3v1Parser } from "./ID3v1Parser-D3djVWtz.js";
+import { t as ID3v2Parser } from "./ID3v2Parser-qYesy3nR.js";
+const debug = (0, (/* @__PURE__ */ __toESM(require_src(), 1)).default)("music-metadata:parser:ID3");
+/**
+* Abstract parser which tries take ID3v2 and ID3v1 headers.
+*/
+var AbstractID3Parser = class extends BasicParser {
+	constructor() {
+		super(...arguments);
+		this.id3parser = new ID3v2Parser();
+	}
+	static async startsWithID3v2Header(tokenizer) {
+		return (await tokenizer.peekToken(ID3v2Header)).fileIdentifier === "ID3";
+	}
+	async parse() {
+		try {
+			await this.parseID3v2();
+		} catch (err) {
+			if (err instanceof EndOfStreamError) debug("End-of-stream");
+			else throw err;
+		}
+	}
+	finalize() {}
+	async parseID3v2() {
+		await this.tryReadId3v2Headers();
+		debug("End of ID3v2 header, go to MPEG-parser: pos=%s", this.tokenizer.position);
+		await this.postId3v2Parse();
+		if (this.options.skipPostHeaders && this.metadata.hasAny()) this.finalize();
+		else {
+			await new ID3v1Parser(this.metadata, this.tokenizer, this.options).parse();
+			this.finalize();
+		}
+	}
+	async tryReadId3v2Headers() {
+		if ((await this.tokenizer.peekToken(ID3v2Header)).fileIdentifier === "ID3") {
+			debug("Found ID3v2 header, pos=%s", this.tokenizer.position);
+			await this.id3parser.parse(this.metadata, this.tokenizer, this.options);
+			return this.tryReadId3v2Headers();
+		}
+	}
+};
+//#endregion
+export { AbstractID3Parser as t };

package/dist/AiffParser-BX46Nzbw.js

@@ -0,0 +1,146 @@
+import { s as __toESM } from "./chunk-iyeSoAlh.js";
+import { t as require_src } from "./src-CIahKhwM.js";
+import { n as EndOfStreamError, t as fromBuffer } from "./lib-CHnMkEa4.js";
+import { E as Uint8ArrayType, T as UINT8, _ as UINT16_BE, g as StringType, o as makeUnexpectedFileContentError, t as BasicParser, x as UINT32_BE } from "./BasicParser-BqmIJ1g9.js";
+import { i as FourCcToken } from "./APEv2Parser-Byki9wgz.js";
+import { t as ID3v2Parser } from "./ID3v2Parser-qYesy3nR.js";
+//#region node_modules/.pnpm/music-metadata@11.12.3/node_modules/music-metadata/lib/aiff/AiffToken.js
+var import_src = /* @__PURE__ */ __toESM(require_src(), 1);
+const compressionTypes = {
+	NONE: "not compressed	PCM	Apple Computer",
+	sowt: "PCM (byte swapped)",
+	fl32: "32-bit floating point IEEE 32-bit float",
+	fl64: "64-bit floating point IEEE 64-bit float	Apple Computer",
+	alaw: "ALaw 2:1	8-bit ITU-T G.711 A-law",
+	ulaw: "µLaw 2:1	8-bit ITU-T G.711 µ-law	Apple Computer",
+	ULAW: "CCITT G.711 u-law 8-bit ITU-T G.711 µ-law",
+	ALAW: "CCITT G.711 A-law 8-bit ITU-T G.711 A-law",
+	FL32: "Float 32	IEEE 32-bit float "
+};
+var AiffContentError = class extends makeUnexpectedFileContentError("AIFF") {};
+var Common = class {
+	constructor(header, isAifc) {
+		this.isAifc = isAifc;
+		const minimumChunkSize = isAifc ? 22 : 18;
+		if (header.chunkSize < minimumChunkSize) throw new AiffContentError(`COMMON CHUNK size should always be at least ${minimumChunkSize}`);
+		this.len = header.chunkSize;
+	}
+	get(buf, off) {
+		const shift = UINT16_BE.get(buf, off + 8) - 16398;
+		const baseSampleRate = UINT16_BE.get(buf, off + 8 + 2);
+		const res = {
+			numChannels: UINT16_BE.get(buf, off),
+			numSampleFrames: UINT32_BE.get(buf, off + 2),
+			sampleSize: UINT16_BE.get(buf, off + 6),
+			sampleRate: shift < 0 ? baseSampleRate >> Math.abs(shift) : baseSampleRate << shift
+		};
+		if (this.isAifc) {
+			res.compressionType = FourCcToken.get(buf, off + 18);
+			if (this.len > 22) {
+				const strLen = UINT8.get(buf, off + 22);
+				if (strLen > 0) {
+					const padding = (strLen + 1) % 2;
+					if (23 + strLen + padding === this.len) res.compressionName = new StringType(strLen, "latin1").get(buf, off + 23);
+					else throw new AiffContentError("Illegal pstring length");
+				} else res.compressionName = void 0;
+			}
+		} else res.compressionName = "PCM";
+		return res;
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/music-metadata@11.12.3/node_modules/music-metadata/lib/iff/index.js
+/**
+* Common AIFF chunk header
+*/
+const Header = {
+	len: 8,
+	get: (buf, off) => {
+		return {
+			chunkID: FourCcToken.get(buf, off),
+			chunkSize: Number(BigInt(UINT32_BE.get(buf, off + 4)))
+		};
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/music-metadata@11.12.3/node_modules/music-metadata/lib/aiff/AiffParser.js
+const debug = (0, import_src.default)("music-metadata:parser:aiff");
+/**
+* AIFF - Audio Interchange File Format
+*
+* Ref:
+* - http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/AIFF/AIFF.html
+* - http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/AIFF/Docs/AIFF-1.3.pdf
+*/
+var AIFFParser = class extends BasicParser {
+	constructor() {
+		super(...arguments);
+		this.isCompressed = null;
+	}
+	async parse() {
+		if ((await this.tokenizer.readToken(Header)).chunkID !== "FORM") throw new AiffContentError("Invalid Chunk-ID, expected 'FORM'");
+		const type = await this.tokenizer.readToken(FourCcToken);
+		switch (type) {
+			case "AIFF":
+				this.metadata.setFormat("container", type);
+				this.isCompressed = false;
+				break;
+			case "AIFC":
+				this.metadata.setFormat("container", "AIFF-C");
+				this.isCompressed = true;
+				break;
+			default: throw new AiffContentError(`Unsupported AIFF type: ${type}`);
+		}
+		this.metadata.setFormat("lossless", !this.isCompressed);
+		this.metadata.setAudioOnly();
+		try {
+			while (!this.tokenizer.fileInfo.size || this.tokenizer.fileInfo.size - this.tokenizer.position >= Header.len) {
+				debug(`Reading AIFF chunk at offset=${this.tokenizer.position}`);
+				const chunkHeader = await this.tokenizer.readToken(Header);
+				const nextChunk = 2 * Math.round(chunkHeader.chunkSize / 2);
+				const bytesRead = await this.readData(chunkHeader);
+				await this.tokenizer.ignore(nextChunk - bytesRead);
+			}
+		} catch (err) {
+			if (err instanceof EndOfStreamError) debug("End-of-stream");
+			else throw err;
+		}
+	}
+	async readData(header) {
+		switch (header.chunkID) {
+			case "COMM": {
+				if (this.isCompressed === null) throw new AiffContentError("Failed to parse AIFF.COMM chunk when compression type is unknown");
+				const common = await this.tokenizer.readToken(new Common(header, this.isCompressed));
+				this.metadata.setFormat("bitsPerSample", common.sampleSize);
+				this.metadata.setFormat("sampleRate", common.sampleRate);
+				this.metadata.setFormat("numberOfChannels", common.numChannels);
+				this.metadata.setFormat("numberOfSamples", common.numSampleFrames);
+				this.metadata.setFormat("duration", common.numSampleFrames / common.sampleRate);
+				if (common.compressionName || common.compressionType) this.metadata.setFormat("codec", common.compressionName ?? compressionTypes[common.compressionType]);
+				return header.chunkSize;
+			}
+			case "ID3 ": {
+				const rst = fromBuffer(await this.tokenizer.readToken(new Uint8ArrayType(header.chunkSize)));
+				await new ID3v2Parser().parse(this.metadata, rst, this.options);
+				return header.chunkSize;
+			}
+			case "SSND":
+				if (this.metadata.format.duration) this.metadata.setFormat("bitrate", 8 * header.chunkSize / this.metadata.format.duration);
+				return 0;
+			case "NAME":
+			case "AUTH":
+			case "(c) ":
+			case "ANNO": return this.readTextChunk(header);
+			default:
+				debug(`Ignore chunk id=${header.chunkID}, size=${header.chunkSize}`);
+				return 0;
+		}
+	}
+	async readTextChunk(header) {
+		const values = (await this.tokenizer.readToken(new StringType(header.chunkSize, "ascii"))).split("\0").map((v) => v.trim()).filter((v) => v?.length);
+		await Promise.all(values.map((v) => this.metadata.addTag("AIFF", header.chunkID, v)));
+		return header.chunkSize;
+	}
+};
+//#endregion
+export { AIFFParser };

package/dist/DsdiffParser-DSRNeRIc.js

@@ -0,0 +1,151 @@
+import { s as __toESM } from "./chunk-iyeSoAlh.js";
+import { t as require_src } from "./src-CIahKhwM.js";
+import { t as fromBuffer } from "./lib-CHnMkEa4.js";
+import { E as Uint8ArrayType, S as UINT32_LE, T as UINT8, _ as UINT16_BE, g as StringType, o as makeUnexpectedFileContentError, p as INT64_BE, t as BasicParser, x as UINT32_BE } from "./BasicParser-BqmIJ1g9.js";
+import { i as FourCcToken } from "./APEv2Parser-Byki9wgz.js";
+import { t as ID3v2Parser } from "./ID3v2Parser-qYesy3nR.js";
+//#region node_modules/.pnpm/music-metadata@11.12.3/node_modules/music-metadata/lib/dsdiff/DsdiffToken.js
+var import_src = /* @__PURE__ */ __toESM(require_src(), 1);
+/**
+* DSDIFF chunk header
+* The data-size encoding is deviating from EA-IFF 85
+* Ref: http://www.sonicstudio.com/pdf/dsd/DSDIFF_1.5_Spec.pdf
+*/
+const ChunkHeader64 = {
+	len: 12,
+	get: (buf, off) => {
+		return {
+			chunkID: FourCcToken.get(buf, off),
+			chunkSize: INT64_BE.get(buf, off + 4)
+		};
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/music-metadata@11.12.3/node_modules/music-metadata/lib/dsdiff/DsdiffParser.js
+const debug = (0, import_src.default)("music-metadata:parser:aiff");
+var DsdiffContentParseError = class extends makeUnexpectedFileContentError("DSDIFF") {};
+/**
+* DSDIFF - Direct Stream Digital Interchange File Format (Phillips)
+*
+* Ref:
+* - http://www.sonicstudio.com/pdf/dsd/DSDIFF_1.5_Spec.pdf
+*/
+var DsdiffParser = class extends BasicParser {
+	async parse() {
+		const header = await this.tokenizer.readToken(ChunkHeader64);
+		if (header.chunkID !== "FRM8") throw new DsdiffContentParseError("Unexpected chunk-ID");
+		this.metadata.setAudioOnly();
+		const type = (await this.tokenizer.readToken(FourCcToken)).trim();
+		switch (type) {
+			case "DSD":
+				this.metadata.setFormat("container", `DSDIFF/${type}`);
+				this.metadata.setFormat("lossless", true);
+				return this.readFmt8Chunks(header.chunkSize - BigInt(FourCcToken.len));
+			default: throw new DsdiffContentParseError(`Unsupported DSDIFF type: ${type}`);
+		}
+	}
+	async readFmt8Chunks(remainingSize) {
+		while (remainingSize >= ChunkHeader64.len) {
+			const chunkHeader = await this.tokenizer.readToken(ChunkHeader64);
+			debug(`Chunk id=${chunkHeader.chunkID}`);
+			await this.readData(chunkHeader);
+			remainingSize -= BigInt(ChunkHeader64.len) + chunkHeader.chunkSize;
+		}
+	}
+	async readData(header) {
+		debug(`Reading data of chunk[ID=${header.chunkID}, size=${header.chunkSize}]`);
+		const p0 = this.tokenizer.position;
+		switch (header.chunkID.trim()) {
+			case "FVER":
+				debug(`DSDIFF version=${await this.tokenizer.readToken(UINT32_LE)}`);
+				break;
+			case "PROP":
+				if (await this.tokenizer.readToken(FourCcToken) !== "SND ") throw new DsdiffContentParseError("Unexpected PROP-chunk ID");
+				await this.handleSoundPropertyChunks(header.chunkSize - BigInt(FourCcToken.len));
+				break;
+			case "ID3": {
+				const rst = fromBuffer(await this.tokenizer.readToken(new Uint8ArrayType(Number(header.chunkSize))));
+				await new ID3v2Parser().parse(this.metadata, rst, this.options);
+				break;
+			}
+			case "DSD":
+				if (this.metadata.format.numberOfChannels) this.metadata.setFormat("numberOfSamples", Number(header.chunkSize * BigInt(8) / BigInt(this.metadata.format.numberOfChannels)));
+				if (this.metadata.format.numberOfSamples && this.metadata.format.sampleRate) this.metadata.setFormat("duration", this.metadata.format.numberOfSamples / this.metadata.format.sampleRate);
+				break;
+			default:
+				debug(`Ignore chunk[ID=${header.chunkID}, size=${header.chunkSize}]`);
+				break;
+		}
+		const remaining = header.chunkSize - BigInt(this.tokenizer.position - p0);
+		if (remaining > 0) {
+			debug(`After Parsing chunk, remaining ${remaining} bytes`);
+			await this.tokenizer.ignore(Number(remaining));
+		}
+	}
+	async handleSoundPropertyChunks(remainingSize) {
+		debug(`Parsing sound-property-chunks, remainingSize=${remainingSize}`);
+		while (remainingSize > 0) {
+			const sndPropHeader = await this.tokenizer.readToken(ChunkHeader64);
+			debug(`Sound-property-chunk[ID=${sndPropHeader.chunkID}, size=${sndPropHeader.chunkSize}]`);
+			const p0 = this.tokenizer.position;
+			switch (sndPropHeader.chunkID.trim()) {
+				case "FS": {
+					const sampleRate = await this.tokenizer.readToken(UINT32_BE);
+					this.metadata.setFormat("sampleRate", sampleRate);
+					break;
+				}
+				case "CHNL": {
+					const numChannels = await this.tokenizer.readToken(UINT16_BE);
+					this.metadata.setFormat("numberOfChannels", numChannels);
+					await this.handleChannelChunks(sndPropHeader.chunkSize - BigInt(UINT16_BE.len));
+					break;
+				}
+				case "CMPR": {
+					const compressionIdCode = (await this.tokenizer.readToken(FourCcToken)).trim();
+					const count = await this.tokenizer.readToken(UINT8);
+					const compressionName = await this.tokenizer.readToken(new StringType(count, "ascii"));
+					if (compressionIdCode === "DSD") {
+						this.metadata.setFormat("lossless", true);
+						this.metadata.setFormat("bitsPerSample", 1);
+					}
+					this.metadata.setFormat("codec", `${compressionIdCode} (${compressionName})`);
+					break;
+				}
+				case "ABSS":
+					debug(`ABSS ${await this.tokenizer.readToken(UINT16_BE)}:${await this.tokenizer.readToken(UINT8)}:${await this.tokenizer.readToken(UINT8)}.${await this.tokenizer.readToken(UINT32_BE)}`);
+					break;
+				case "LSCO":
+					debug(`LSCO lsConfig=${await this.tokenizer.readToken(UINT16_BE)}`);
+					break;
+				default:
+					debug(`Unknown sound-property-chunk[ID=${sndPropHeader.chunkID}, size=${sndPropHeader.chunkSize}]`);
+					await this.tokenizer.ignore(Number(sndPropHeader.chunkSize));
+			}
+			const remaining = sndPropHeader.chunkSize - BigInt(this.tokenizer.position - p0);
+			if (remaining > 0) {
+				debug(`After Parsing sound-property-chunk ${sndPropHeader.chunkSize}, remaining ${remaining} bytes`);
+				await this.tokenizer.ignore(Number(remaining));
+			}
+			remainingSize -= BigInt(ChunkHeader64.len) + sndPropHeader.chunkSize;
+			debug(`Parsing sound-property-chunks, remainingSize=${remainingSize}`);
+		}
+		if (this.metadata.format.lossless && this.metadata.format.sampleRate && this.metadata.format.numberOfChannels && this.metadata.format.bitsPerSample) {
+			const bitrate = this.metadata.format.sampleRate * this.metadata.format.numberOfChannels * this.metadata.format.bitsPerSample;
+			this.metadata.setFormat("bitrate", bitrate);
+		}
+	}
+	async handleChannelChunks(remainingSize) {
+		debug(`Parsing channel-chunks, remainingSize=${remainingSize}`);
+		const channels = [];
+		while (remainingSize >= FourCcToken.len) {
+			const channelId = await this.tokenizer.readToken(FourCcToken);
+			debug(`Channel[ID=${channelId}]`);
+			channels.push(channelId);
+			remainingSize -= BigInt(FourCcToken.len);
+		}
+		debug(`Channels: ${channels.join(", ")}`);
+		return channels;
+	}
+};
+//#endregion
+export { DsdiffParser };