@jackuait/blok 0.17.0 → 0.19.0

package/dist/chunks/MatroskaParser-fxFuCddu.mjs

@@ -0,0 +1,814 @@
+import { i as e } from "./chunk-5O_1xk2F.mjs";
+import { D as t, T as n, c as r, l as i, s as a, t as o, u as s, v as c } from "./BasicParser-BFTgNkp-.mjs";
+import { i as l } from "./core-CqiEzfU3.mjs";
+import { n as u, t as d } from "./types-gj36fzRQ.mjs";
+//#region node_modules/music-metadata/lib/ebml/types.js
+var f = /* @__PURE__ */ e(r(), 1), p = {
+	string: 0,
+	uint: 1,
+	uid: 2,
+	bool: 3,
+	binary: 4,
+	float: 5
+}, m = {
+	name: "dtd",
+	container: {
+		440786851: {
+			name: "ebml",
+			container: {
+				17030: {
+					name: "ebmlVersion",
+					value: p.uint
+				},
+				17143: {
+					name: "ebmlReadVersion",
+					value: p.uint
+				},
+				17138: {
+					name: "ebmlMaxIDWidth",
+					value: p.uint
+				},
+				17139: {
+					name: "ebmlMaxSizeWidth",
+					value: p.uint
+				},
+				17026: {
+					name: "docType",
+					value: p.string
+				},
+				17031: {
+					name: "docTypeVersion",
+					value: p.uint
+				},
+				17029: {
+					name: "docTypeReadVersion",
+					value: p.uint
+				}
+			}
+		},
+		408125543: {
+			name: "segment",
+			container: {
+				290298740: {
+					name: "seekHead",
+					container: { 19899: {
+						name: "seek",
+						multiple: !0,
+						container: {
+							21419: {
+								name: "id",
+								value: p.binary
+							},
+							21420: {
+								name: "position",
+								value: p.uint
+							}
+						}
+					} }
+				},
+				357149030: {
+					name: "info",
+					container: {
+						29604: {
+							name: "uid",
+							value: p.uid
+						},
+						29572: {
+							name: "filename",
+							value: p.string
+						},
+						3979555: {
+							name: "prevUID",
+							value: p.uid
+						},
+						3965867: {
+							name: "prevFilename",
+							value: p.string
+						},
+						4110627: {
+							name: "nextUID",
+							value: p.uid
+						},
+						4096955: {
+							name: "nextFilename",
+							value: p.string
+						},
+						2807729: {
+							name: "timecodeScale",
+							value: p.uint
+						},
+						17545: {
+							name: "duration",
+							value: p.float
+						},
+						17505: {
+							name: "dateUTC",
+							value: p.uint
+						},
+						31657: {
+							name: "title",
+							value: p.string
+						},
+						19840: {
+							name: "muxingApp",
+							value: p.string
+						},
+						22337: {
+							name: "writingApp",
+							value: p.string
+						}
+					}
+				},
+				524531317: {
+					name: "cluster",
+					multiple: !0,
+					container: {
+						231: {
+							name: "timecode",
+							value: p.uid
+						},
+						22743: {
+							name: "silentTracks ",
+							multiple: !0
+						},
+						167: {
+							name: "position",
+							value: p.uid
+						},
+						171: {
+							name: "prevSize",
+							value: p.uid
+						},
+						160: { name: "blockGroup" },
+						163: { name: "simpleBlock" }
+					}
+				},
+				374648427: {
+					name: "tracks",
+					container: { 174: {
+						name: "entries",
+						multiple: !0,
+						container: {
+							215: {
+								name: "trackNumber",
+								value: p.uint
+							},
+							29637: {
+								name: "uid",
+								value: p.uid
+							},
+							131: {
+								name: "trackType",
+								value: p.uint
+							},
+							185: {
+								name: "flagEnabled",
+								value: p.bool
+							},
+							136: {
+								name: "flagDefault",
+								value: p.bool
+							},
+							21930: {
+								name: "flagForced",
+								value: p.bool
+							},
+							156: {
+								name: "flagLacing",
+								value: p.bool
+							},
+							28135: {
+								name: "minCache",
+								value: p.uint
+							},
+							28136: {
+								name: "maxCache",
+								value: p.uint
+							},
+							2352003: {
+								name: "defaultDuration",
+								value: p.uint
+							},
+							2306383: {
+								name: "timecodeScale",
+								value: p.float
+							},
+							21358: {
+								name: "name",
+								value: p.string
+							},
+							2274716: {
+								name: "language",
+								value: p.string
+							},
+							134: {
+								name: "codecID",
+								value: p.string
+							},
+							25506: {
+								name: "codecPrivate",
+								value: p.binary
+							},
+							2459272: {
+								name: "codecName",
+								value: p.string
+							},
+							3839639: {
+								name: "codecSettings",
+								value: p.string
+							},
+							3883072: {
+								name: "codecInfoUrl",
+								value: p.string
+							},
+							2536e3: {
+								name: "codecDownloadUrl",
+								value: p.string
+							},
+							170: {
+								name: "codecDecodeAll",
+								value: p.bool
+							},
+							28587: {
+								name: "trackOverlay",
+								value: p.uint
+							},
+							224: {
+								name: "video",
+								container: {
+									154: {
+										name: "flagInterlaced",
+										value: p.bool
+									},
+									21432: {
+										name: "stereoMode",
+										value: p.uint
+									},
+									176: {
+										name: "pixelWidth",
+										value: p.uint
+									},
+									186: {
+										name: "pixelHeight",
+										value: p.uint
+									},
+									21680: {
+										name: "displayWidth",
+										value: p.uint
+									},
+									21690: {
+										name: "displayHeight",
+										value: p.uint
+									},
+									21683: {
+										name: "aspectRatioType",
+										value: p.uint
+									},
+									3061028: {
+										name: "colourSpace",
+										value: p.uint
+									},
+									3126563: {
+										name: "gammaValue",
+										value: p.float
+									}
+								}
+							},
+							225: {
+								name: "audio",
+								container: {
+									181: {
+										name: "samplingFrequency",
+										value: p.float
+									},
+									30901: {
+										name: "outputSamplingFrequency",
+										value: p.float
+									},
+									159: {
+										name: "channels",
+										value: p.uint
+									},
+									148: {
+										name: "channels",
+										value: p.uint
+									},
+									32123: {
+										name: "channelPositions",
+										value: p.binary
+									},
+									25188: {
+										name: "bitDepth",
+										value: p.uint
+									}
+								}
+							},
+							28032: {
+								name: "contentEncodings",
+								container: { 25152: {
+									name: "contentEncoding",
+									container: {
+										20529: {
+											name: "order",
+											value: p.uint
+										},
+										20530: {
+											name: "scope",
+											value: p.bool
+										},
+										20531: {
+											name: "type",
+											value: p.uint
+										},
+										20532: {
+											name: "contentEncoding",
+											container: {
+												16980: {
+													name: "contentCompAlgo",
+													value: p.uint
+												},
+												16981: {
+													name: "contentCompSettings",
+													value: p.binary
+												}
+											}
+										},
+										20533: {
+											name: "contentEncoding",
+											container: {
+												18401: {
+													name: "contentEncAlgo",
+													value: p.uint
+												},
+												18402: {
+													name: "contentEncKeyID",
+													value: p.binary
+												},
+												18403: {
+													name: "contentSignature ",
+													value: p.binary
+												},
+												18404: {
+													name: "ContentSigKeyID  ",
+													value: p.binary
+												},
+												18405: {
+													name: "contentSigAlgo ",
+													value: p.uint
+												},
+												18406: {
+													name: "contentSigHashAlgo ",
+													value: p.uint
+												}
+											}
+										},
+										25188: {
+											name: "bitDepth",
+											value: p.uint
+										}
+									}
+								} }
+							}
+						}
+					} }
+				},
+				475249515: {
+					name: "cues",
+					container: { 187: {
+						name: "cuePoint",
+						container: {
+							179: {
+								name: "cueTime",
+								value: p.uid
+							},
+							183: {
+								name: "positions",
+								container: {
+									247: {
+										name: "track",
+										value: p.uint
+									},
+									241: {
+										name: "clusterPosition",
+										value: p.uint
+									},
+									21368: {
+										name: "blockNumber",
+										value: p.uint
+									},
+									234: {
+										name: "codecState",
+										value: p.uint
+									},
+									219: {
+										name: "reference",
+										container: {
+											150: {
+												name: "time",
+												value: p.uint
+											},
+											151: {
+												name: "cluster",
+												value: p.uint
+											},
+											21343: {
+												name: "number",
+												value: p.uint
+											},
+											235: {
+												name: "codecState",
+												value: p.uint
+											}
+										}
+									},
+									240: {
+										name: "relativePosition",
+										value: p.uint
+									}
+								}
+							}
+						}
+					} }
+				},
+				423732329: {
+					name: "attachments",
+					container: { 24999: {
+						name: "attachedFiles",
+						multiple: !0,
+						container: {
+							18046: {
+								name: "description",
+								value: p.string
+							},
+							18030: {
+								name: "name",
+								value: p.string
+							},
+							18016: {
+								name: "mimeType",
+								value: p.string
+							},
+							18012: {
+								name: "data",
+								value: p.binary
+							},
+							18094: {
+								name: "uid",
+								value: p.uid
+							}
+						}
+					} }
+				},
+				272869232: {
+					name: "chapters",
+					container: { 17849: {
+						name: "editionEntry",
+						container: { 182: {
+							name: "chapterAtom",
+							container: {
+								29636: {
+									name: "uid",
+									value: p.uid
+								},
+								145: {
+									name: "timeStart",
+									value: p.uint
+								},
+								146: {
+									name: "timeEnd",
+									value: p.uid
+								},
+								152: {
+									name: "hidden",
+									value: p.bool
+								},
+								17816: {
+									name: "enabled",
+									value: p.uid
+								},
+								143: {
+									name: "track",
+									container: {
+										137: {
+											name: "trackNumber",
+											value: p.uid
+										},
+										128: {
+											name: "display",
+											container: {
+												133: {
+													name: "string",
+													value: p.string
+												},
+												17276: {
+													name: "language ",
+													value: p.string
+												},
+												17278: {
+													name: "country ",
+													value: p.string
+												}
+											}
+										}
+									}
+								}
+							}
+						} }
+					} }
+				},
+				307544935: {
+					name: "tags",
+					container: { 29555: {
+						name: "tag",
+						multiple: !0,
+						container: {
+							25536: {
+								name: "target",
+								container: {
+									25541: {
+										name: "tagTrackUID",
+										value: p.uid
+									},
+									25540: {
+										name: "tagChapterUID",
+										value: p.uint
+									},
+									25542: {
+										name: "tagAttachmentUID",
+										value: p.uid
+									},
+									25546: {
+										name: "targetType",
+										value: p.string
+									},
+									26826: {
+										name: "targetTypeValue",
+										value: p.uint
+									},
+									25545: {
+										name: "tagEditionUID",
+										value: p.uid
+									}
+								}
+							},
+							26568: {
+								name: "simpleTags",
+								multiple: !0,
+								container: {
+									17827: {
+										name: "name",
+										value: p.string
+									},
+									17543: {
+										name: "string",
+										value: p.string
+									},
+									17541: {
+										name: "binary",
+										value: p.binary
+									},
+									17530: {
+										name: "language",
+										value: p.string
+									},
+									17531: {
+										name: "languageIETF",
+										value: p.string
+									},
+									17540: {
+										name: "default",
+										value: p.bool
+									}
+								}
+							}
+						}
+					} }
+				}
+			}
+		}
+	}
+}, h = (0, f.default)("music-metadata:parser:ebml"), g = class extends a("EBML") {}, _ = {
+	ReadNext: 0,
+	IgnoreElement: 2,
+	SkipSiblings: 3,
+	TerminateParsing: 4,
+	SkipElement: 5
+}, v = class {
+	constructor(e) {
+		var t = this;
+		this.parserMap = /* @__PURE__ */ new Map(), this.ebmlMaxIDLength = 4, this.ebmlMaxSizeLength = 8, this.tokenizer = e, this.parserMap.set(p.uint, (e) => this.readUint(e)), this.parserMap.set(p.string, (e) => this.readString(e)), this.parserMap.set(p.binary, (e) => this.readBuffer(e)), this.parserMap.set(p.uid, async (e) => t.readBuffer(e)), this.parserMap.set(p.bool, (e) => this.readFlag(e)), this.parserMap.set(p.float, (e) => this.readFloat(e));
+	}
+	async iterate(e, t, n) {
+		return this.parseContainer(x(e), t, n);
+	}
+	async parseContainer(e, t, n) {
+		var r = this;
+		let i = {};
+		for (; r.tokenizer.position < t;) {
+			let a, o = r.tokenizer.position;
+			try {
+				a = await r.readElement();
+			} catch (e) {
+				if (e instanceof l) break;
+				throw e;
+			}
+			let s = e.container[a.id];
+			if (s) switch (n.startNext(s)) {
+				case _.ReadNext:
+					if (a.id, h(`Read element: name=${S(s)}{id=0x${a.id.toString(16)}, container=${!!s.container}} at position=${o}`), s.container) {
+						let e = await r.parseContainer(s, a.len >= 0 ? r.tokenizer.position + a.len : -1, n);
+						s.multiple ? (i[s.name] || (i[s.name] = []), i[s.name].push(e)) : i[s.name] = e, await n.elementValue(s, e, o);
+					} else {
+						let e = r.parserMap.get(s.value);
+						if (typeof e == "function") {
+							let t = await e(a);
+							i[s.name] = t, await n.elementValue(s, t, o);
+						}
+					}
+					break;
+				case _.SkipElement:
+					h(`Go to next element: name=${S(s)}, element.id=0x${a.id}, container=${!!s.container} at position=${o}`);
+					break;
+				case _.IgnoreElement:
+					h(`Ignore element: name=${S(s)}, element.id=0x${a.id}, container=${!!s.container} at position=${o}`), await r.tokenizer.ignore(a.len);
+					break;
+				case _.SkipSiblings:
+					h(`Ignore remaining container, at: name=${S(s)}, element.id=0x${a.id}, container=${!!s.container} at position=${o}`), await r.tokenizer.ignore(t - r.tokenizer.position);
+					break;
+				case _.TerminateParsing: return h(`Terminate parsing at element: name=${S(s)}, element.id=0x${a.id}, container=${!!s.container} at position=${o}`), i;
+			}
+			else switch (a.id) {
+				case 236:
+					await r.tokenizer.ignore(a.len);
+					break;
+				default: h(`parseEbml: parent=${S(e)}, unknown child: id=${a.id.toString(16)} at position=${o}`), await r.tokenizer.ignore(a.len);
+			}
+		}
+		return i;
+	}
+	async readVintData(e) {
+		var n = this;
+		let r = await n.tokenizer.peekNumber(t), i = 128, a = 1;
+		for (; (r & i) === 0;) {
+			if (a > e) throw new g("VINT value exceeding maximum size");
+			++a, i >>= 1;
+		}
+		let o = new Uint8Array(a);
+		return await n.tokenizer.readBuffer(o), o;
+	}
+	async readElement() {
+		var e = this;
+		let t = await e.readVintData(e.ebmlMaxIDLength), n = await e.readVintData(e.ebmlMaxSizeLength);
+		return n[0] ^= 128 >> n.length - 1, {
+			id: y(t, t.length),
+			len: y(n, n.length)
+		};
+	}
+	async readFloat(e) {
+		var t = this;
+		switch (e.len) {
+			case 0: return 0;
+			case 4: return t.tokenizer.readNumber(i);
+			case 8: return t.tokenizer.readNumber(s);
+			case 10: return t.tokenizer.readNumber(s);
+			default: throw new g(`Invalid IEEE-754 float length: ${e.len}`);
+		}
+	}
+	async readFlag(e) {
+		return await this.readUint(e) === 1;
+	}
+	async readUint(e) {
+		return y(await this.readBuffer(e), e.len);
+	}
+	async readString(e) {
+		return (await this.tokenizer.readToken(new c(e.len, "utf-8"))).replace(/\x00.*$/g, "");
+	}
+	async readBuffer(e) {
+		var t = this;
+		let n = new Uint8Array(e.len);
+		return await t.tokenizer.readBuffer(n), n;
+	}
+};
+function y(e, t) {
+	return Number(b(e, t));
+}
+function b(e, t) {
+	let r = new Uint8Array(8), i = e.subarray(0, t);
+	try {
+		return r.set(i, 8 - t), n.get(r, 0);
+	} catch (e) {
+		return BigInt(-1);
+	}
+}
+function x(e) {
+	return e.container && Object.keys(e.container).map((t) => {
+		let n = e.container[t];
+		return n.id = Number.parseInt(t, 10), n;
+	}).forEach((t) => {
+		t.parent = e, x(t);
+	}), e;
+}
+function S(e) {
+	let t = "";
+	return e.parent && e.parent.name !== "dtd" && (t += `${S(e.parent)}/`), t + e.name;
+}
+//#endregion
+//#region node_modules/music-metadata/lib/matroska/MatroskaParser.js
+var C = (0, f.default)("music-metadata:parser:matroska"), w = class extends o {
+	constructor() {
+		var e;
+		super(...arguments), this.seekHeadOffset = 0, this.flagUseIndexToSkipClusters = (e = this.options.mkvUseIndex) == null ? !1 : e;
+	}
+	async parse() {
+		var e = this, t;
+		let n = (t = e.tokenizer.fileInfo.size) == null ? 2 ** 53 - 1 : t, r = new v(e.tokenizer);
+		C("Initializing DTD end MatroskaIterator"), await r.iterate(m, n, {
+			startNext: (t) => {
+				switch (t.id) {
+					case 475249515: return C(`Skip element: name=${t.name}, id=0x${t.id.toString(16)}`), _.IgnoreElement;
+					case 524531317:
+						if (e.flagUseIndexToSkipClusters && e.seekHead) {
+							let t = e.seekHead.seek.find((t) => t.position + e.seekHeadOffset > e.tokenizer.position);
+							if (t) {
+								let n = t.position + e.seekHeadOffset - e.tokenizer.position;
+								return C(`Use index to go to next position, ignoring ${n} bytes`), e.tokenizer.ignore(n), _.SkipElement;
+							}
+						}
+						return _.IgnoreElement;
+					default: return _.ReadNext;
+				}
+			},
+			elementValue: async (t, n, r) => {
+				switch (C(`Received: name=${t.name}, value=${n}`), t.id) {
+					case 17026:
+						e.metadata.setFormat("container", `EBML/${n}`);
+						break;
+					case 290298740:
+						e.seekHead = n, e.seekHeadOffset = r;
+						break;
+					case 357149030:
+						{
+							let t = n, r = t.timecodeScale ? t.timecodeScale : 1e6;
+							if (typeof t.duration == "number") {
+								let n = t.duration * r / 1e9;
+								await e.addTag("segment:title", t.title), e.metadata.setFormat("duration", Number(n));
+							}
+						}
+						break;
+					case 374648427:
+						{
+							let t = n;
+							if (t != null && t.entries) {
+								t.entries.forEach((t) => {
+									let n = {
+										codecName: t.codecID.replace("A_", "").replace("V_", ""),
+										codecSettings: t.codecSettings,
+										flagDefault: t.flagDefault,
+										flagLacing: t.flagLacing,
+										flagEnabled: t.flagEnabled,
+										language: t.language,
+										name: t.name,
+										type: t.trackType,
+										audio: t.audio,
+										video: t.video
+									};
+									e.metadata.addStreamInfo(n);
+								});
+								let n = t.entries.filter((e) => e.trackType === u.audio).reduce((e, t) => !e || t.flagDefault && !e.flagDefault || t.trackNumber < e.trackNumber ? t : e, null);
+								n && (e.metadata.setFormat("codec", n.codecID.replace("A_", "")), e.metadata.setFormat("sampleRate", n.audio.samplingFrequency), e.metadata.setFormat("numberOfChannels", n.audio.channels));
+							}
+						}
+						break;
+					case 307544935:
+						{
+							let t = n;
+							await Promise.all(t.tag.map(async (t) => {
+								let n = t.target, r = n != null && n.targetTypeValue ? d[n.targetTypeValue] : n != null && n.targetType ? n.targetType : "track";
+								await Promise.all(t.simpleTags.map(async (t) => {
+									let n = t.string ? t.string : t.binary;
+									await e.addTag(`${r}:${t.name}`, n);
+								}));
+							}));
+						}
+						break;
+					case 423732329:
+						{
+							let t = n;
+							await Promise.all(t.attachedFiles.filter((e) => e.mimeType.startsWith("image/")).map((t) => e.addTag("picture", {
+								data: t.data,
+								format: t.mimeType,
+								description: t.description,
+								name: t.name
+							})));
+						}
+						break;
+				}
+			}
+		});
+	}
+	async addTag(e, t) {
+		await this.metadata.addTag("matroska", e, t);
+	}
+};
+//#endregion
+export { w as MatroskaParser };