@jackuait/blok 0.16.1 → 0.18.0

package/dist/chunks/core-CqiEzfU3.mjs

@@ -0,0 +1,292 @@
+import { t as e } from "./objectSpread2-jlBcdYeb.mjs";
+//#region node_modules/strtok3/lib/stream/Errors.js
+var t = "End-Of-Stream", n = class extends Error {
+	constructor() {
+		super(t), this.name = "EndOfStreamError";
+	}
+}, r = class extends Error {
+	constructor(e = "The operation was aborted") {
+		super(e), this.name = "AbortError";
+	}
+}, i = class {
+	constructor() {
+		this.endOfStream = !1, this.interrupted = !1, this.peekQueue = [];
+	}
+	async peek(e, t = !1) {
+		var n = this;
+		let r = await n.read(e, t);
+		return n.peekQueue.push(e.subarray(0, r)), r;
+	}
+	async read(e, t = !1) {
+		var r = this;
+		if (e.length === 0) return 0;
+		let i = r.readFromPeekBuffer(e);
+		if (r.endOfStream || (i += await r.readRemainderFromStream(e.subarray(i), t)), i === 0 && !t) throw new n();
+		return i;
+	}
+	readFromPeekBuffer(e) {
+		let t = e.length, n = 0;
+		for (; this.peekQueue.length > 0 && t > 0;) {
+			let r = this.peekQueue.pop();
+			if (!r) throw Error("peekData should be defined");
+			let i = Math.min(r.length, t);
+			e.set(r.subarray(0, i), n), n += i, t -= i, i < r.length && this.peekQueue.push(r.subarray(i));
+		}
+		return n;
+	}
+	async readRemainderFromStream(e, t) {
+		var i = this;
+		let a = 0;
+		for (; a < e.length && !i.endOfStream;) {
+			if (i.interrupted) throw new r();
+			let n = await i.readFromStream(e.subarray(a), t);
+			if (n === 0) break;
+			a += n;
+		}
+		if (!t && a < e.length) throw new n();
+		return a;
+	}
+}, a = class extends i {
+	constructor(e) {
+		super(), this.reader = e;
+	}
+	async abort() {
+		return this.close();
+	}
+	async close() {
+		this.reader.releaseLock();
+	}
+}, o = class extends a {
+	async readFromStream(e, t) {
+		var n = this;
+		if (e.length === 0) return 0;
+		let r = await n.reader.read(new Uint8Array(e.length), { min: t ? void 0 : e.length });
+		return r.done && (n.endOfStream = r.done), r.value ? (e.set(r.value), r.value.length) : 0;
+	}
+}, s = class extends i {
+	constructor(e) {
+		super(), this.reader = e, this.buffer = null;
+	}
+	writeChunk(e, t) {
+		let n = Math.min(t.length, e.length);
+		return e.set(t.subarray(0, n)), n < t.length ? this.buffer = t.subarray(n) : this.buffer = null, n;
+	}
+	async readFromStream(e, t) {
+		var r = this;
+		if (e.length === 0) return 0;
+		let i = 0;
+		for (r.buffer && (i += r.writeChunk(e, r.buffer)); i < e.length && !r.endOfStream;) {
+			let t = await r.reader.read();
+			if (t.done) {
+				r.endOfStream = !0;
+				break;
+			}
+			t.value && (i += r.writeChunk(e.subarray(i), t.value));
+		}
+		if (!t && i === 0 && r.endOfStream) throw new n();
+		return i;
+	}
+	abort() {
+		return this.interrupted = !0, this.reader.cancel();
+	}
+	async close() {
+		var e = this;
+		await e.abort(), e.reader.releaseLock();
+	}
+};
+//#endregion
+//#region node_modules/strtok3/lib/stream/WebStreamReaderFactory.js
+function c(e) {
+	try {
+		let t = e.getReader({ mode: "byob" });
+		return t instanceof ReadableStreamDefaultReader ? new s(t) : new o(t);
+	} catch (t) {
+		if (t instanceof TypeError) return new s(e.getReader());
+		throw t;
+	}
+}
+//#endregion
+//#region node_modules/strtok3/lib/AbstractTokenizer.js
+var l = class {
+	constructor(e) {
+		this.numBuffer = new Uint8Array(8), this.position = 0, this.onClose = e == null ? void 0 : e.onClose, e != null && e.abortSignal && e.abortSignal.addEventListener("abort", () => {
+			this.abort();
+		});
+	}
+	async readToken(e, t = this.position) {
+		var r = this;
+		let i = new Uint8Array(e.len);
+		if (await r.readBuffer(i, { position: t }) < e.len) throw new n();
+		return e.get(i, 0);
+	}
+	async peekToken(e, t = this.position) {
+		var r = this;
+		let i = new Uint8Array(e.len);
+		if (await r.peekBuffer(i, { position: t }) < e.len) throw new n();
+		return e.get(i, 0);
+	}
+	async readNumber(e) {
+		var t = this;
+		if (await t.readBuffer(t.numBuffer, { length: e.len }) < e.len) throw new n();
+		return e.get(t.numBuffer, 0);
+	}
+	async peekNumber(e) {
+		var t = this;
+		if (await t.peekBuffer(t.numBuffer, { length: e.len }) < e.len) throw new n();
+		return e.get(t.numBuffer, 0);
+	}
+	async ignore(e) {
+		var t = this;
+		if (e < 0) throw RangeError("ignore length must be ≥ 0 bytes");
+		if (t.fileInfo.size !== void 0) {
+			let n = t.fileInfo.size - t.position;
+			if (e > n) return t.position += n, n;
+		}
+		return t.position += e, e;
+	}
+	async close() {
+		var e = this, t;
+		await e.abort(), await ((t = e.onClose) == null ? void 0 : t.call(e));
+	}
+	normalizeOptions(t, n) {
+		if (!this.supportsRandomAccess() && n && n.position !== void 0 && n.position < this.position) throw Error("`options.position` must be equal or greater than `tokenizer.position`");
+		return e(e({}, {
+			mayBeLess: !1,
+			offset: 0,
+			length: t.length,
+			position: this.position
+		}), n);
+	}
+	abort() {
+		return Promise.resolve();
+	}
+}, u = 256e3, d = class extends l {
+	constructor(e, t) {
+		var n;
+		super(t), this.streamReader = e, this.fileInfo = (n = t == null ? void 0 : t.fileInfo) == null ? {} : n;
+	}
+	async readBuffer(e, t) {
+		var r = this;
+		let i = r.normalizeOptions(e, t), a = i.position - r.position;
+		if (a > 0) return await r.ignore(a), r.readBuffer(e, t);
+		if (a < 0) throw Error("`options.position` must be equal or greater than `tokenizer.position`");
+		if (i.length === 0) return 0;
+		let o = await r.streamReader.read(e.subarray(0, i.length), i.mayBeLess);
+		if (r.position += o, (!t || !t.mayBeLess) && o < i.length) throw new n();
+		return o;
+	}
+	async peekBuffer(e, t) {
+		var r = this;
+		let i = r.normalizeOptions(e, t), a = 0;
+		if (i.position) {
+			let t = i.position - r.position;
+			if (t > 0) {
+				let n = new Uint8Array(i.length + t);
+				return a = await r.peekBuffer(n, { mayBeLess: i.mayBeLess }), e.set(n.subarray(t)), a - t;
+			}
+			if (t < 0) throw Error("Cannot peek from a negative offset in a stream");
+		}
+		if (i.length > 0) {
+			try {
+				a = await r.streamReader.peek(e.subarray(0, i.length), i.mayBeLess);
+			} catch (e) {
+				if (t != null && t.mayBeLess && e instanceof n) return 0;
+				throw e;
+			}
+			if (!i.mayBeLess && a < i.length) throw new n();
+		}
+		return a;
+	}
+	async ignore(e) {
+		var t = this;
+		if (e < 0) throw RangeError("ignore length must be ≥ 0 bytes");
+		let n = Math.min(u, e), r = new Uint8Array(n), i = 0;
+		for (; i < e;) {
+			let a = e - i, o = await t.readBuffer(r, { length: Math.min(n, a) });
+			if (o < 0) return o;
+			i += o;
+		}
+		return i;
+	}
+	abort() {
+		return this.streamReader.abort();
+	}
+	async close() {
+		return this.streamReader.close();
+	}
+	supportsRandomAccess() {
+		return !1;
+	}
+}, f = class extends l {
+	constructor(t, n) {
+		var r;
+		super(n), this.uint8Array = t, this.fileInfo = e(e({}, (r = n == null ? void 0 : n.fileInfo) == null ? {} : r), { size: t.length });
+	}
+	async readBuffer(e, t) {
+		var n = this;
+		t != null && t.position && (n.position = t.position);
+		let r = await n.peekBuffer(e, t);
+		return n.position += r, r;
+	}
+	async peekBuffer(e, t) {
+		var r = this;
+		let i = r.normalizeOptions(e, t), a = Math.min(r.uint8Array.length - i.position, i.length);
+		if (!i.mayBeLess && a < i.length) throw new n();
+		return e.set(r.uint8Array.subarray(i.position, i.position + a)), a;
+	}
+	close() {
+		return super.close();
+	}
+	supportsRandomAccess() {
+		return !0;
+	}
+	setPosition(e) {
+		this.position = e;
+	}
+}, p = class extends l {
+	constructor(t, n) {
+		var r;
+		super(n), this.blob = t, this.fileInfo = e(e({}, (r = n == null ? void 0 : n.fileInfo) == null ? {} : r), {
+			size: t.size,
+			mimeType: t.type
+		});
+	}
+	async readBuffer(e, t) {
+		var n = this;
+		t != null && t.position && (n.position = t.position);
+		let r = await n.peekBuffer(e, t);
+		return n.position += r, r;
+	}
+	async peekBuffer(e, t) {
+		var r = this;
+		let i = r.normalizeOptions(e, t), a = Math.min(r.blob.size - i.position, i.length);
+		if (!i.mayBeLess && a < i.length) throw new n();
+		let o = await r.blob.slice(i.position, i.position + a).arrayBuffer();
+		return e.set(new Uint8Array(o)), a;
+	}
+	close() {
+		return super.close();
+	}
+	supportsRandomAccess() {
+		return !0;
+	}
+	setPosition(e) {
+		this.position = e;
+	}
+};
+//#endregion
+//#region node_modules/strtok3/lib/core.js
+function m(e, t) {
+	let n = c(e), r = t == null ? {} : t, i = r.onClose;
+	return r.onClose = async () => {
+		if (await n.close(), i) return i();
+	}, new d(n, r);
+}
+function h(e, t) {
+	return new f(e, t);
+}
+function g(e, t) {
+	return new p(e, t);
+}
+//#endregion
+export { n as i, h as n, m as r, g as t };