@genai-fi/nanogpt 0.20.0 → 0.20.2

package/dist/utilities/sentences.js

@@ -0,0 +1,32 @@
+import { I as e, Wr as t, _r as n, mn as r, un as i } from "../dist-BewPQWjc.js";
+//#region lib/utilities/sentences.ts
+var a = 16;
+function o(e, n) {
+	if (!n) return e.mean(1);
+	let a = i(n, 2), o = t(e, a), s = r(o, 1), c = r(n, 1, !0), l = s.div(c.maximum(1e-9));
+	return a.dispose(), o.dispose(), s.dispose(), c.dispose(), l;
+}
+function s(t, r, i = a) {
+	let s = t.tokeniser, c = t.config.blockSize, l = null, u = 0;
+	for (; u < r.length;) {
+		let d = r.slice(u, u + a).map((e) => s.encode(e)), f = [], p = [];
+		for (let e of d) e.length > c ? (f.push(e.slice(e.length - c, e.length)), p.push(Array(c).fill(1))) : e.length < c ? (f.push(e.concat(Array(c - e.length).fill(0))), p.push(Array(e.length).fill(1).concat(Array(c - e.length).fill(0)))) : (f.push(e), p.push(Array(c).fill(1)));
+		let m = e(f, [f.length, c], "int32"), h = e(p, [p.length, c], "float32"), g = t.model.forward({
+			skipLogits: !0,
+			training: !1
+		}, m), _ = o(g, h);
+		if (h.dispose(), g.dispose(), l === null) l = _;
+		else {
+			let e = l;
+			l = n([l, _], 0), e.dispose(), _.dispose();
+		}
+		u += i;
+	}
+	return l;
+}
+async function c(e, t, n = a) {
+	let r = await s(e, t, n), i = await r.array();
+	return r.dispose(), i;
+}
+//#endregion
+export { o as meanPooling, c as sentenceEmbeddings, s as sentenceEmbeddingsTensor };

package/dist/utilities/tokenParse.d.ts

@@ -0,0 +1 @@
+export default function parseTokens(text: string): string[];

package/dist/utilities/tokenParse.js

@@ -0,0 +1,17 @@
+//#region lib/utilities/tokenParse.ts
+function e(e) {
+	let t = Array.from(e), n = [], r = /(\p{P}|\p{S}|\s)/gu, i = "";
+	for (let e = 0; e < t.length; e++) {
+		let a = t[e];
+		if (a === " ") (t[e + 1] ?? "") === " " ? i += a : (n.push(i), i = a);
+		else if (a.match(r)) {
+			n.push(i);
+			let r = a;
+			for (; e + 1 < t.length && t[e + 1] === a;) r += t[e + 1], e++;
+			n.push(r), i = "";
+		} else i += a;
+	}
+	return i.length > 0 && n.push(i), n.filter((e) => e.length > 0);
+}
+//#endregion
+export { e as default };

package/dist/utilities/topP.d.ts

@@ -0,0 +1 @@
+export default function topP(probs: number[][], tP: number): number[];

package/dist/utilities/topP.js

@@ -0,0 +1,12 @@
+//#region lib/utilities/topP.ts
+function e(e, t) {
+	let n = e[0].map((e, t) => ({
+		prob: e,
+		index: t
+	})).sort((e, t) => t.prob - e.prob), r = 0, i = Array(n.length).fill(0);
+	for (let e of n) if (r += e.prob, i[e.index] = e.prob, r >= t) break;
+	let a = i.reduce((e, t) => e + t, 0);
+	return i.map((e) => e / a);
+}
+//#endregion
+export { e as default };

package/dist/utilities/waitForModel.d.ts

@@ -0,0 +1,2 @@
+import { TeachableLLM } from '../../main';
+export default function waitForModel(model: TeachableLLM): Promise<void>;

package/dist/utilities/waitForModel.js

@@ -0,0 +1,12 @@
+//#region lib/utilities/waitForModel.ts
+function e(e) {
+	return new Promise((t, n) => {
+		e.ready ? t() : (e.on("status", (e) => {
+			e === "ready" && t();
+		}), e.on("error", (e) => {
+			n(e);
+		}));
+	});
+}
+//#endregion
+export { e as default };

package/dist/utilities/weights.d.ts

@@ -0,0 +1,12 @@
+import { Tensor } from '@tensorflow/tfjs-core';
+export interface ITensorSpec {
+    shape: number[];
+    min?: number;
+    scale?: number;
+}
+export interface IWeightManifest {
+    spec: ITensorSpec[];
+    data: Float32Array;
+}
+export declare function exportWeights(weights: Tensor[]): Promise<IWeightManifest>;
+export declare function importWeights(manifest: IWeightManifest): Promise<Tensor[]>;

package/dist/utilities/weights.js

@@ -0,0 +1,40 @@
+import { fi as e } from "../dist-BewPQWjc.js";
+//#region lib/utilities/weights.ts
+function t(e) {
+	let t = e.reduce((e, t) => e + t.length, 0), n = new Float32Array(t), r = 0;
+	for (let t of e) n.set(t, r), r += t.length;
+	return n;
+}
+async function n(e) {
+	let n = {
+		spec: [],
+		data: new Float32Array()
+	}, r = [];
+	for (let t of e) {
+		if (!t || !Array.isArray(t.shape) || t.shape.length === 0) {
+			console.warn("Skipping weight with invalid shape:", t);
+			continue;
+		}
+		let e = t.min(), i = t.max(), a = (await e.data())[0], o = (await i.data())[0] - a;
+		n.spec.push({
+			shape: t.shape,
+			min: a,
+			scale: o
+		}), e.dispose(), i.dispose();
+		let s = await t.data();
+		r.push(s);
+	}
+	return n.data = t(r), n;
+}
+async function r(t) {
+	let n = [], r = 0;
+	for (let i of t.spec) {
+		let a = i.shape.reduce((e, t) => e * t, 1), o = t.data.slice(r, r + a);
+		r += a;
+		let s = e(o, i.shape, "float32");
+		n.push(s);
+	}
+	return n;
+}
+//#endregion
+export { n as exportWeights, r as importWeights };

package/dist/utilities/yielder.d.ts

@@ -0,0 +1 @@
+export declare function yieldIfNeeded(lastYield: number, cb?: (vocab: number) => void, param?: number): Promise<number>;

package/dist/utilities/yielder.js

@@ -0,0 +1,7 @@
+//#region lib/utilities/yielder.ts
+async function e(e, t, n) {
+	let r = performance.now();
+	return r - e > 40 ? (await new Promise(requestAnimationFrame), t && t(n ?? 0), r) : e;
+}
+//#endregion
+export { e as yieldIfNeeded };

package/dist/webgpu-Dt7BMzWz.js

@@ -0,0 +1,525 @@
+import { Ai as e, Ms as t, Oi as n, Ps as r, Rs as i, Vs as a, Xr as o, Ys as s, fc as c, ii as l, ki as u, lc as d, oc as f, pc as p, zs as m } from "./dist-BewPQWjc.js";
+import { s as h } from "./complex_util-CkazZsaH.js";
+import { l as g, n as _, t as v } from "./webgpu_program-WOyIVMlZ.js";
+import { l as y, t as b } from "./webgpu_util-B_F3SShA.js";
+//#region node_modules/@tensorflow/tfjs-backend-webgpu/dist/flags_webgpu.js
+var x = t();
+x.registerFlag("WEBGPU_DEFERRED_SUBMIT_BATCH_SIZE", () => 15), x.registerFlag("WEBGPU_CPU_FORWARD", () => !0), x.registerFlag("WEBGPU_MATMUL_PROGRAM_TYPE", () => -1), x.registerFlag("WEBGPU_USE_NAIVE_CONV2D_TRANSPOSE", () => !0), x.registerFlag("WEBGPU_USE_LOW_POWER_GPU", () => !1), x.registerFlag("WEBGPU_CPU_HANDOFF_SIZE_THRESHOLD", () => 1e3), x.registerFlag("WEBGPU_USE_PROFILE_TOOL", () => !1), x.registerFlag("WEBGPU_IMPORT_EXTERNAL_TEXTURE", () => !0), x.registerFlag("WEBGPU_USE_NAIVE_CONV2D_DEBUG", () => !1), x.registerFlag("WEBGPU_THRESHOLD_TO_INCREASE_WORKGROUPS_FOR_MATMUL", () => -1), x.registerFlag("WEBGPU_CONV_SEPARATE_IM2COL_SHADER", () => !1), x.registerFlag("WEBGPU_PRINT_SHADER", () => ""), x.registerFlag("WEBGPU_ENGINE_COMPILE_ONLY", () => !1);
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-webgpu/dist/adapter_info.js
+var S = class {
+	constructor(e) {
+		e && (this.vendor = e.vendor, this.architecture = e.architecture, this.intelGPUGeneration = this.getIntelGPUGeneration());
+	}
+	getIntelGPUGeneration() {
+		if (this.isIntel()) {
+			if (this.architecture.startsWith("gen")) return Number(this.architecture.match(/\d+/));
+			if (this.architecture.startsWith("xe")) return 12;
+		}
+		return 0;
+	}
+	isIntel() {
+		return this.vendor === "intel";
+	}
+}, C = class {
+	constructor(e) {
+		this.device = e, this.numUsedBuffers = 0, this.numFreeBuffers = 0, this.freeBuffers = /* @__PURE__ */ new Map(), this.usedBuffers = /* @__PURE__ */ new Map(), this.numBytesUsed = 0, this.numBytesAllocated = 0;
+	}
+	acquireBuffer(e, t, n = !1, r = !0) {
+		let i, a = w(e, t);
+		return r ? (this.freeBuffers.has(a) || this.freeBuffers.set(a, []), this.freeBuffers.get(a).length > 0 ? (i = this.freeBuffers.get(a).pop(), this.numFreeBuffers--) : (i = this.device.createBuffer({
+			size: e,
+			usage: t,
+			mappedAtCreation: n
+		}), this.numBytesAllocated += e)) : (i = this.device.createBuffer({
+			size: e,
+			usage: t,
+			mappedAtCreation: n
+		}), this.numBytesAllocated += e), this.usedBuffers.has(a) || this.usedBuffers.set(a, []), this.usedBuffers.get(a).push(i), this.numUsedBuffers++, this.numBytesUsed += e, i;
+	}
+	releaseBuffer(e, t = !0) {
+		if (this.freeBuffers.size === 0) return;
+		let n = e.size, r = e.usage, i = w(n, r), a = this.usedBuffers.get(i), o = a.indexOf(e);
+		if (o < 0) throw Error("Cannot find the buffer in buffer manager");
+		a[o] = a[a.length - 1], a.pop(), this.numUsedBuffers--, this.numBytesUsed -= n, t ? (this.freeBuffers.get(i).push(e), this.numFreeBuffers++) : (e.destroy(), this.numBytesAllocated -= n);
+	}
+	getNumUsedBuffers() {
+		return this.numUsedBuffers;
+	}
+	getNumFreeBuffers() {
+		return this.numFreeBuffers;
+	}
+	dispose() {
+		this.freeBuffers.forEach((e, t) => {
+			e.forEach((e) => {
+				e.destroy();
+			});
+		}), this.usedBuffers.forEach((e, t) => {
+			e.forEach((e) => {
+				e.destroy();
+			});
+		}), this.freeBuffers = /* @__PURE__ */ new Map(), this.usedBuffers = /* @__PURE__ */ new Map(), this.numUsedBuffers = 0, this.numFreeBuffers = 0, this.numBytesUsed = 0, this.numBytesAllocated = 0;
+	}
+};
+function w(e, t) {
+	return `${e}_${t}`;
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-webgpu/dist/texture_manager.js
+var T = class {
+	constructor(e) {
+		this.device = e, this.numUsedTextures = 0, this.numFreeTextures = 0, this.freeTextures = /* @__PURE__ */ new Map(), this.usedTextures = /* @__PURE__ */ new Map(), this.numBytesUsed = 0, this.numBytesAllocated = 0;
+	}
+	acquireTexture(e, t, n, r) {
+		let i = D(n), a = e * t * i, o = E(e, t, n, r);
+		if (this.freeTextures.has(o) || this.freeTextures.set(o, []), this.usedTextures.has(o) || this.usedTextures.set(o, []), this.numBytesUsed += a, this.numUsedTextures++, this.freeTextures.get(o).length > 0) {
+			this.numFreeTextures--;
+			let e = this.freeTextures.get(o).shift();
+			return this.usedTextures.get(o).push(e), e;
+		}
+		this.numBytesAllocated += a;
+		let s = this.device.createTexture({
+			size: [e, t],
+			format: n,
+			usage: r
+		});
+		return this.usedTextures.get(o).push(s), s;
+	}
+	releaseTexture(e) {
+		if (this.freeTextures.size === 0) return;
+		let t = e.width, n = e.height, r = e.format, i = e.usage, a = E(t, n, r, i);
+		this.freeTextures.has(a) || this.freeTextures.set(a, []), this.freeTextures.get(a).push(e), this.numFreeTextures++, this.numUsedTextures--;
+		let o = this.usedTextures.get(a), s = o.indexOf(e);
+		if (s < 0) throw Error("Cannot release a texture that was never provided by this texture manager");
+		o.splice(s, 1);
+		let c = D(r), l = t * n * c;
+		this.numBytesUsed -= l;
+	}
+	getNumUsedTextures() {
+		return this.numUsedTextures;
+	}
+	getNumFreeTextures() {
+		return this.numFreeTextures;
+	}
+	dispose() {
+		this.freeTextures.forEach((e, t) => {
+			e.forEach((e) => {
+				e.destroy();
+			});
+		}), this.usedTextures.forEach((e, t) => {
+			e.forEach((e) => {
+				e.destroy();
+			});
+		}), this.freeTextures = /* @__PURE__ */ new Map(), this.usedTextures = /* @__PURE__ */ new Map(), this.numUsedTextures = 0, this.numFreeTextures = 0, this.numBytesUsed = 0, this.numBytesAllocated = 0;
+	}
+};
+function E(e, t, n, r) {
+	return `${e}_${t}_${n}_${r}`;
+}
+function D(e) {
+	if (e === "rgba8unorm") return 16;
+	throw Error(`${e} is not supported!`);
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-webgpu/dist/backend_webgpu.js
+var O = t().getNumber("WEBGPU_CPU_HANDOFF_SIZE_THRESHOLD"), k = (e, t) => {
+	let n = e.limits.maxComputeWorkgroupsPerDimension, i = t.dispatchLayout, a = t.dispatch;
+	if (a.every((e) => e <= n)) return a;
+	r(a[0] > n && i.y === void 0 && i.z === void 0, () => "Dispatch size exceeds WebGPU limits in Y or Z dimension.");
+	let o = Math.ceil(Math.sqrt(a[0]));
+	return o > n ? (o = Math.ceil(Math.cbrt(a[0])), r(o <= n, () => "Total dispatch size exceeds WebGPU maximum."), [
+		o,
+		o,
+		o
+	]) : [
+		o,
+		o,
+		1
+	];
+}, A = class x extends p {
+	nextDataId() {
+		return x.nextDataId++;
+	}
+	constructor(e, n) {
+		if (super(), this.commandQueueOwnedIds = /* @__PURE__ */ new WeakSet(), this.dispatchCountInPass = 0, this.disposed = !1, this.downloadWaitMs = 0, this.tensorDataPendingDisposal = [], this.queryResolveBuffer = null, this.querySet = null, this.querySetCount = 2, this.stagingPendingDisposal = [], this.uniformPendingDisposal = [], this.uploadWaitMs = 0, this.hasReadSyncWarned = !1, this.hasTimestampQueryWarned = !1, !y()) throw Error("WebGPU is not supported on this device");
+		this.pipelineCache = {}, this.device = e, this.queue = e.queue, this.commandEncoder = null, this.computePassEncoder = null, this.adapterInfo = new S(n), this.supportTimestampQuery = this.device.features.has("timestamp-query"), this.thresholdToIncreaseWorkgroups = this.adapterInfo.intelGPUGeneration >= 12 ? 16 : 8, this.bufferManager = new C(this.device), this.textureManager = new T(this.device), this.tensorMap = new c(this, l()), t().getBool("WEBGPU_USE_PROFILE_TOOL") && (this.dummyCanvas = document.createElement("canvas"), this.dummyCanvas.width = 1, this.dummyCanvas.height = 1, this.dummyContext = this.dummyCanvas.getContext("webgpu"), this.dummyContext.configure({
+			device: e,
+			format: "bgra8unorm"
+		}), document.body.appendChild(this.dummyCanvas));
+	}
+	floatPrecision() {
+		return 32;
+	}
+	disposeData(e, t = !1) {
+		if (!this.tensorMap.has(e)) return !0;
+		let n = this.tensorMap.get(e);
+		return t ? n.refCount = 0 : n.refCount--, n.refCount > 0 ? !1 : (n.complexTensorInfos != null && (this.disposeData(n.complexTensorInfos.real.dataId), this.disposeData(n.complexTensorInfos.imag.dataId)), this.commandQueueOwnedIds.has(e) ? (this.tensorDataPendingDisposal.push(e), !0) : (this.releaseResource(e), this.tensorMap.delete(e), !0));
+	}
+	memory() {
+		return {
+			numBytesInGPU: this.bufferManager.numBytesUsed,
+			numBytesAllocatedInGPU: this.bufferManager.numBytesAllocated,
+			unreliable: !1
+		};
+	}
+	releaseResource(e) {
+		let t = this.tensorMap.get(e);
+		if (!(!t || !t.resource)) {
+			if (t.external) {
+				t.resource = null;
+				return;
+			}
+			t.resource instanceof GPUBuffer ? this.bufferManager.releaseBuffer(t.resource) : t.resource instanceof GPUTexture && this.textureManager.releaseTexture(t.resource), t.resource = null;
+		}
+	}
+	refCount(e) {
+		return this.tensorMap.has(e) ? this.tensorMap.get(e).refCount : 0;
+	}
+	incRef(e) {
+		let t = this.tensorMap.get(e);
+		t.refCount++;
+	}
+	decRef(e) {
+		if (this.tensorMap.has(e)) {
+			let t = this.tensorMap.get(e);
+			t.refCount--;
+		}
+	}
+	write(e, t, n) {
+		if (n === "complex64" && e != null) throw Error("Cannot write to a complex64 dtype. Please use tf.complex(real, imag).");
+		let r = { id: this.nextDataId() };
+		return this.tensorMap.set(r, {
+			dtype: n,
+			shape: t,
+			values: e,
+			refCount: 1
+		}), r;
+	}
+	move(e, t, n, r, i) {
+		if (r === "complex64") throw Error("Cannot write to a complex64 dtype. Please use tf.complex(real, imag).");
+		this.tensorMap.set(e, {
+			dtype: r,
+			shape: n,
+			values: t,
+			refCount: i
+		});
+	}
+	submitQueue() {
+		this.queue.submit([this.commandEncoder.finish()]), this.commandEncoder = null, this.dispatchCountInPass = 0, this.commandQueueOwnedIds = /* @__PURE__ */ new WeakSet(), this.tensorDataPendingDisposal.forEach((e) => {
+			this.releaseResource(e), this.tensorMap.delete(e);
+		}), this.uniformPendingDisposal.forEach((e) => this.bufferManager.releaseBuffer(e)), this.stagingPendingDisposal.forEach((e) => this.bufferManager.releaseBuffer(e, !1)), this.tensorDataPendingDisposal = [], this.uniformPendingDisposal = [], this.stagingPendingDisposal = [];
+	}
+	ensureCommandEncoderReady() {
+		this.commandEncoder ||= this.device.createCommandEncoder();
+	}
+	endComputePassEncoder() {
+		this.computePassEncoder &&= (this.computePassEncoder.end(), null);
+	}
+	async checkCompileCompletionAsync() {
+		let e;
+		try {
+			e = await Promise.all(Object.values(this.pipelineCache));
+		} catch (e) {
+			throw Error(e.message);
+		}
+		Object.keys(this.pipelineCache).map((t, n) => {
+			this.pipelineCache[t] = e[n];
+		});
+	}
+	async getBufferData(e) {
+		if (t().getBool("WEBGPU_ENGINE_COMPILE_ONLY")) return console.warn("The data may be invalid since WEBGPU_ENGINE_COMPILE_ONLY is true, this can only be called when WEBGPU_ENGINE_COMPILE_ONLY is false"), null;
+		let n = e.size, i = this.bufferManager.acquireBuffer(n, GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ);
+		this.ensureCommandEncoderReady(), this.endComputePassEncoder(), this.commandEncoder.copyBufferToBuffer(e, 0, i, 0, n), this.submitQueue(), await i.mapAsync(GPUMapMode.READ);
+		let a = i.getMappedRange().slice(0);
+		return i.unmap(), i != null && this.bufferManager.releaseBuffer(i), t().getBool("WEBGPU_USE_PROFILE_TOOL") && (r(this.dummyContext !== void 0, () => "Fail to get context for profiling tool"), this.dummyContext.getCurrentTexture()), a;
+	}
+	convertAndCacheOnCPU(e, t) {
+		let n = this.tensorMap.get(e);
+		return n.values = t, n.values;
+	}
+	readSync(e) {
+		let t = this.tensorMap.get(e), { values: n, complexTensorInfos: i } = t;
+		if (n != null || t.dtype === "string") return n;
+		if (t.dtype === "complex64") {
+			let t = m(h(this.readSync(i.real.dataId), this.readSync(i.imag.dataId)).buffer, "float32");
+			return this.convertAndCacheOnCPU(e, t), t;
+		}
+		this.hasReadSyncWarned || (this.hasReadSyncWarned = !0, console.warn("The performance of synchronously reading data from GPU to CPU is poor on the webgpu backend, please use asynchronous APIs instead."));
+		let a = ["opaque", "premultiplied"], o = t.resource, s = o.size;
+		r(s % 4 == 0, () => "Because there is 4 bytes for one pixel, buffer size must be multiple of 4.");
+		let c = s / 4, l = new ArrayBuffer(s), u = a.map((e) => new OffscreenCanvas(256, 256)), d = new OffscreenCanvas(256, 256);
+		this.endComputePassEncoder(), u.map((e, t) => {
+			let n = e.getContext("webgpu");
+			return n.configure({
+				device: this.device,
+				format: "bgra8unorm",
+				usage: GPUTextureUsage.COPY_DST,
+				alphaMode: a[t]
+			}), n.getCurrentTexture();
+		}).map((e, t) => {
+			let n = (n, r, i) => {
+				this.ensureCommandEncoderReady(), this.commandEncoder.copyBufferToTexture({
+					buffer: o,
+					bytesPerRow: 1024,
+					offset: i
+				}, { texture: e }, {
+					width: n,
+					height: r
+				}), this.submitQueue();
+				let s = d.getContext("2d", { willReadFrequently: !0 });
+				s.clearRect(0, 0, n, r), s.drawImage(u[t], 0, 0);
+				let c = s.getImageData(0, 0, n, r).data, f = a[t], p = new Uint8ClampedArray(l, i, n * r * 4);
+				for (let e = 0; e < p.length; e += 4) if (f === "premultiplied") p[e + 3] = c[e + 3];
+				else {
+					let t = c[e];
+					p[e] = c[e + 2], p[e + 1] = c[e + 1], p[e + 2] = t;
+				}
+			}, r = Math.floor(c / (256 * 256)), i = 256, s = 256, f = 0;
+			for (let e = 0; e < r; e++) n(i, s, f), f += 256 * 256 * 4;
+			let p = c % (256 * 256);
+			s = Math.floor(p / 256), s > 0 && (n(i, s, f), f += 256 * 4 * s), i = p % 256, i > 0 && n(i, 1, f);
+		});
+		let f = m(l, t.dtype);
+		return this.convertAndCacheOnCPU(e, f), f;
+	}
+	async read(e) {
+		if (!this.tensorMap.has(e)) throw Error(`Tensor ${e} was not registered!`);
+		let t = this.tensorMap.get(e), { values: n } = t;
+		if (n != null) return n;
+		let r;
+		if (t.dtype === "complex64") {
+			let e = await Promise.all([this.read(t.complexTensorInfos.real.dataId), this.read(t.complexTensorInfos.imag.dataId)]), n = e[0], i = e[1];
+			r = h(n, i);
+		} else r = m(await this.getBufferData(t.resource), t.dtype);
+		return this.convertAndCacheOnCPU(e, r), r;
+	}
+	copyBuffer(e) {
+		let t = e.size, n = e.usage, r = this.bufferManager.acquireBuffer(t, n);
+		return this.ensureCommandEncoderReady(), this.endComputePassEncoder(), this.commandEncoder.copyBufferToBuffer(e, 0, r, 0, t), this.submitQueue(), r;
+	}
+	createTensorFromGPUData(e, t, n) {
+		let r = e.buffer;
+		if (n === "complex64") throw Error("Cannot write to a complex64 dtype. ");
+		let i = { id: this.nextDataId() };
+		this.tensorMap.set(i, {
+			dtype: n,
+			shape: t,
+			values: null,
+			refCount: 1,
+			external: e.zeroCopy
+		});
+		let a = this.tensorMap.get(i), o = b(a.dtype) * f(a.shape);
+		if (e.buffer.size < o) throw Error(`GPUBuffer size(${e.buffer.size}) is smaller than tensor size(${o})!`);
+		if ((e.buffer.usage & (GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC)) !== (GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC)) throw Error("GPUBuffer.usage should include GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC!");
+		return e.zeroCopy !== !0 && (r = this.copyBuffer(r)), a.resource = r, l().makeTensorFromDataId(i, t, n, this);
+	}
+	readToGPU(e) {
+		let { values: t, dtype: n, shape: r, resource: i } = this.tensorMap.get(e);
+		if (n === "complex64") throw Error("Does not support reading buffer for complex64 dtype.");
+		if (i == null) throw Error(t == null ? "There is no data on GPU or CPU." : "Data is not on GPU but on CPU.");
+		let a = i, o = a.size, s = a.usage, c = this.bufferManager.acquireBuffer(o, s);
+		this.ensureCommandEncoderReady(), this.endComputePassEncoder(), this.commandEncoder.copyBufferToBuffer(i, 0, c, 0, o), this.submitQueue();
+		let u = this.makeTensorInfo(r, n), d = l().makeTensorFromTensorInfo(u), f = this.tensorMap.get(u.dataId);
+		return f.resource = c, {
+			tensorRef: d,
+			buffer: c
+		};
+	}
+	bufferSync(e) {
+		let t = this.readSync(e.dataId);
+		if (e.dtype === "string") try {
+			let r = t.map((e) => n(e));
+			return o(e.shape, e.dtype, r);
+		} catch {
+			throw Error("Failed to decode encoded string bytes into utf-8");
+		}
+		return o(e.shape, e.dtype, t);
+	}
+	async time(t) {
+		!this.supportTimestampQuery && !this.hasTimestampQueryWarned && (console.warn("This device doesn't support timestamp-query extension. Start Chrome browser with flag --enable-dawn-features=allow_unsafe_apis to try it again. Otherwise, zero will be shown for the kernel time when profiling mode is enabled."), this.hasTimestampQueryWarned = !0);
+		let n = this.activeTimers, r = [], i = !1;
+		this.programTimersStack == null ? (this.programTimersStack = r, i = !0) : this.activeTimers.push(r), this.activeTimers = r, t();
+		let a = e(this.activeTimers.map((e) => e.query)).filter((e) => e != null), o = e(this.activeTimers.map((e) => e.name)).filter((e) => e != null);
+		this.activeTimers = n, i && (this.programTimersStack = null);
+		let s = {
+			uploadWaitMs: this.uploadWaitMs,
+			downloadWaitMs: this.downloadWaitMs,
+			kernelMs: null,
+			wallMs: null
+		}, c = await Promise.all(a);
+		return s.kernelMs = d(c), s.getExtraProfileInfo = () => c.map((e, t) => ({
+			name: o[t],
+			ms: e
+		})).map((e) => `${e.name}: ${e.ms}`).join(", "), this.uploadWaitMs = 0, this.downloadWaitMs = 0, s;
+	}
+	makeTensorInfo(e, t, n) {
+		return t === "string" && n != null && n.length > 0 && s(n[0]) && (n = n.map((e) => u(e))), {
+			dataId: this.write(n, e, t),
+			shape: e,
+			dtype: t
+		};
+	}
+	tensorToBinding(e) {
+		if (!e) return null;
+		let t = this.tensorMap.get(e.dataId).resource;
+		return t instanceof GPUBuffer ? { buffer: t } : t instanceof GPUTexture ? t.createView() : t;
+	}
+	uploadToGPU(e) {
+		let t = this.tensorMap.get(e);
+		if (t.resource != null) return;
+		let n = b(t.dtype) * f(t.shape), r, i = GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST;
+		if (t.values) {
+			if (r = this.bufferManager.acquireBuffer(n, i, !0), r.mapState === "unmapped") {
+				let e = this.bufferManager.acquireBuffer(n, GPUBufferUsage.MAP_WRITE | GPUBufferUsage.COPY_SRC, !0, !1), i = e.getMappedRange();
+				t.dtype === "int32" || t.dtype === "packedF16" || t.dtype === "bool" ? new Int32Array(i).set(t.values) : new Float32Array(i).set(t.values), e.unmap(), this.ensureCommandEncoderReady(), this.endComputePassEncoder(), this.commandEncoder.copyBufferToBuffer(e, 0, r, 0, n), this.stagingPendingDisposal.push(e);
+			} else {
+				let e = r.getMappedRange();
+				t.dtype === "int32" || t.dtype === "packedF16" || t.dtype === "bool" ? new Int32Array(e).set(t.values) : new Float32Array(e).set(t.values), r.unmap();
+			}
+			t.values = null;
+		} else r = this.bufferManager.acquireBuffer(n, i);
+		t.resource = r;
+	}
+	makeUniforms(e) {
+		let t = 0, n = 0, i = [], a = 1;
+		e.forEach((e) => {
+			e.data.length === 0 && (e.data = [1]);
+			let o;
+			switch (e.data.length) {
+				case 1:
+					o = 4;
+					break;
+				case 2:
+					o = 8;
+					break;
+				case 3:
+					o = 16;
+					break;
+				case 4:
+					o = 16;
+					break;
+				case 5:
+					o = 16;
+					break;
+				case 6:
+					o = 16;
+					break;
+				default: r(!1, () => `Unsupported ${e.data.length}D shape`);
+			}
+			(n === 5 || n === 6) && (o = 16), o > a && (a = o), t = Math.ceil(t / o) * o, n = e.data.length, i.push(t), t += e.data.length * 4;
+		}), t = Math.ceil(t / a) * a;
+		let o = new ArrayBuffer(t);
+		e.forEach((e, t) => {
+			let n = i[t];
+			e.type === "int32" ? new Int32Array(o, n, e.data.length).set(e.data) : e.type === "uint32" ? new Uint32Array(o, n, e.data.length).set(e.data) : new Float32Array(o, n, e.data.length).set(e.data);
+		});
+		let s = this.bufferManager.acquireBuffer(t, GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM);
+		return this.queue.writeBuffer(s, 0, o, 0, t), this.uniformPendingDisposal.push(s), {
+			offset: 0,
+			size: t,
+			buffer: s
+		};
+	}
+	runWebGPUProgram(e, n, r, i, o) {
+		if (o ||= this.makeTensorInfo(e.outputShape, r), f(o.shape) === 0) return this.tensorMap.get(o.dataId).values = a(o.dtype, 0), o;
+		this.uploadToGPU(o.dataId), e.dispatch = k(this.device, e);
+		let s = n.map((t, n) => {
+			if (t.dtype === "complex64") throw Error("GPGPUProgram does not support complex64 input. For complex64 dtypes, please separate the program into real and imaginary parts.");
+			return this.uploadToGPU(t.dataId), {
+				dtype: this.tensorMap.get(t.dataId).dtype,
+				shape: t.shape,
+				name: e.variableNames[n]
+			};
+		});
+		e.shaderKey = g(e, s, o);
+		let c = t().getBool("WEBGPU_ENGINE_COMPILE_ONLY");
+		return e.shaderKey in this.pipelineCache || (this.pipelineCache[e.shaderKey] = _(this.device, e, s, o, c)), e.pipeline = this.pipelineCache[e.shaderKey], c || this.recordAndSubmit(e, o, n, i), o;
+	}
+	recordAndSubmit(e, n, r, a) {
+		if (e.pipeline instanceof Promise) throw Error("Please call checkCompileCompletionAsync to ensure parallel compilation is done!");
+		let o = [], s = [], c = "int32";
+		if (e.pixelsOpType == null) {
+			o.push({
+				type: "float32",
+				data: [NaN]
+			}, {
+				type: "float32",
+				data: [Infinity]
+			}), s = r.concat(n).map((e) => e.shape);
+			let e = "int32";
+			s.map((t) => {
+				o.push({
+					type: e,
+					data: t
+				});
+				let n = i(t);
+				o.push({
+					type: e,
+					data: n
+				});
+			});
+		} else {
+			let e = i(n.shape);
+			o.push({
+				type: c,
+				data: e
+			});
+		}
+		if (e.size) {
+			let t = f(e.outputShape);
+			o.push({
+				type: c,
+				data: [e.outputComponent ? t / e.outputComponent : t]
+			});
+		}
+		a && (o = [...o, ...a]);
+		let l = [
+			this.tensorToBinding(n),
+			...r.map((e) => this.tensorToBinding(e)),
+			this.makeUniforms(o)
+		];
+		r.forEach((e) => {
+			this.commandQueueOwnedIds.add(e.dataId);
+		}), this.commandQueueOwnedIds.add(n.dataId);
+		let u = this.device.createBindGroup({
+			layout: e.pipeline.getBindGroupLayout(0),
+			entries: l.map((e, t) => ({
+				binding: t,
+				resource: e
+			}))
+		}), d = this.activeTimers != null;
+		this.ensureCommandEncoderReady();
+		let p = {};
+		d && this.supportTimestampQuery ? (this.endComputePassEncoder(), this.querySet ??= this.device.createQuerySet({
+			type: "timestamp",
+			count: this.querySetCount
+		}), p.timestampWrites = {
+			querySet: this.querySet,
+			beginningOfPassWriteIndex: 0,
+			endOfPassWriteIndex: 1
+		}, this.computePassEncoder = this.commandEncoder.beginComputePass(p)) : this.computePassEncoder ||= this.commandEncoder.beginComputePass(p), this.computePassEncoder.setPipeline(e.pipeline), this.computePassEncoder.setBindGroup(0, u), this.computePassEncoder.dispatchWorkgroups(e.dispatch[0], e.dispatch[1], e.dispatch[2]), this.dispatchCountInPass++, (d || t().get("WEBGPU_DEFERRED_SUBMIT_BATCH_SIZE") <= this.dispatchCountInPass || e.pixelsOpType === v.DRAW) && (this.endComputePassEncoder(), d ? this.activeTimers.push({
+			name: e.constructor.name,
+			query: this.getQueryTime()
+		}) : this.submitQueue());
+	}
+	async getQueryTime() {
+		if (!this.supportTimestampQuery) return 0;
+		this.queryResolveBuffer ??= this.bufferManager.acquireBuffer(this.querySetCount * 8, GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE), this.commandEncoder.resolveQuerySet(this.querySet, 0, this.querySetCount, this.queryResolveBuffer, 0);
+		let e = this.bufferManager.acquireBuffer(this.querySetCount * 8, GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST);
+		this.commandEncoder.copyBufferToBuffer(this.queryResolveBuffer, 0, e, 0, this.querySetCount * 8), this.submitQueue(), await e.mapAsync(GPUMapMode.READ);
+		let t = new BigUint64Array(e.getMappedRange()), n = Number(t[1] - t[0]) / 1e6;
+		return e.unmap(), this.bufferManager.releaseBuffer(e), n;
+	}
+	shouldExecuteOnCPU(e, n = O) {
+		return t().getBool("WEBGPU_CPU_FORWARD") && e.every((e) => this.tensorMap.get(e.dataId).resource == null && f(e.shape) < n);
+	}
+	numDataIds() {
+		return this.tensorMap.numDataIds() - this.tensorDataPendingDisposal.length;
+	}
+	dispose() {
+		this.disposed ||= (this.querySet != null && this.querySet.destroy(), this.bufferManager.dispose(), this.textureManager.dispose(), !0);
+	}
+};
+A.nextDataId = 0;
+//#endregion
+export { A as t };