@genai-fi/nanogpt 0.23.0 → 1.0.0

package/README.md

@@ -1,29 +1,14 @@
 # GenAI NanoGPT
 
-A browser-native implementation of GPT language models built on TensorFlow.js, developed as part of the Finnish Generation AI research project. This library enables training, fine-tuning, and inference of transformer-based language models entirely in the browser with support for explainable AI (XAI) features. It is intended to be used as an educational tool for learning about the model training process since it targets mostly tiny models. In principle it could be adapted to load other pre-trained models from Hugging Face.
+A browser-native implementation of small transformer language models using TensorFlow.js. This project is an educational toolkit for creating, training and running compact GPT-style models client-side. It supports model creation, tokenisation, dataset preparation, training, and text generation with a single high-level entrypoint: `TeachableLLM`.
 
-Live version available here: https://lm.gen-ai.fi
+Live demo: https://lm.gen-ai.fi
 
-## Overview
+**Design goals**
 
-GenAI NanoGPT is inspired by [Andrej Karpathy's NanoGPT](https://github.com/karpathy/nanoGPT) but reimagined for the browser using TensorFlow.js. It provides a complete pipeline for:
-
--   **Training** language models from scratch in the browser
--   **Loading** pre-trained models from various sources (Hugging Face, local files)
--   **Generating** text efficiently on a wide range of devices
--   **Analyzing** model behavior through attention visualization and embeddings
--   **Optimizing** performance across CPU, WebGL, and WebGPU backends
-
-### Key Features
-
--   🚀 **Browser-Native**: No server required - train and run models entirely client-side
--   📱 **Works on Small Devices**: Train models on iPads, phones, and Chromebooks - no powerful hardware needed
--   🎯 **Multiple Backends**: Automatic backend selection (CPU, WebGL, WebGPU) for optimal performance
--   🔧 **Flexible Tokenization**: Support for both character-level and BPE tokenizers
--   📊 **XAI Support**: Attention score visualization, gradient analysis, and embedding extraction
--   💾 **Model Persistence**: Save and load models in SafeTensors format
--   ⚡ **Performance Optimizations**: Custom WebGPU kernels, gradient checkpointing, and mixed precision training
--   🎨 **Real-time Training**: Live training metrics and generation during training
+- Small models suitable for experimentation on laptops and mobile devices
+- Clear, teachable APIs for training and generation
+- Browser-first implementation using CPU, WebGL or WebGPU backends
 
 ## Installation
 
@@ -31,239 +16,111 @@ GenAI NanoGPT is inspired by [Andrej Karpathy's NanoGPT](https://github.com/karp
 npm install @genai-fi/nanogpt
 ```
 
-## Quick Start
+## Main concepts
 
-### Creating and Training a Model
-
-```javascript
-import { TeachableLLM, selectBackend } from '@genai-fi/nanogpt';
+- `TeachableLLM` — primary entrypoint. Create, load, save models; access training and responses APIs.
+- `tokenise` — tokeniser helpers and token store (character and BPE tokenisers).
+- `data` — helpers to load text data and stream conversational inputs.
 
-// Select the best available backend
-await selectBackend('webgpu'); // or 'webgl', 'cpu'
+The project export surface is centred around `TeachableLLM` (see `lib/main.ts`). This README focuses on the runtime API you will use in applications.
 
-// Create a new model
-const model = TeachableLLM.create('char', {
-    vocabSize: 200,
-    blockSize: 128, // Context window size
-    nLayer: 4, // Number of transformer layers
-    nHead: 4, // Number of attention heads
-    nEmbed: 192, // Embedding dimension
-    dropout: 0.1,
-    useRope: true, // Use Rotary Position Embeddings
-});
+## Quick examples
 
-// Training data
-const trainingText = [
-    'The quick brown fox jumps over the lazy dog.',
-    'A journey of a thousand miles begins with a single step.',
-    // ... more text
-];
-
-// Train the model
-await model.train(trainingText, {
-    batchSize: 16,
-    learningRate: 3e-4,
-    maxSteps: 1000,
-    logInterval: 10,
-    validationSplit: 0.1,
-});
-
-// Generate text
-const output = await model.generateText('Once upon a time', {
-    maxLength: 100,
-    temperature: 0.8,
-    topP: 0.9,
-});
-
-console.log(output);
-```
-
-### Loading a Pre-trained Model
+Creating a model instance
 
 ```javascript
-import { TeachableLLM, waitForModel } from '@genai-fi/nanogpt';
-
-// Load from Hugging Face
-const model = TeachableLLM.loadModel('username/model-name');
-
-// Or load from a file
-const fileInput = document.getElementById('fileInput');
-fileInput.addEventListener('change', async (event) => {
-    const file = event.target.files[0];
-    const model = TeachableLLM.loadModel(file);
-    await waitForModel(model);
-
-    const text = await model.generateText('Hello');
-    console.log(text);
-});
-```
+import { TeachableLLM } from '@genai-fi/nanogpt';
 
-## Event Handlers and Real-time Updates
-
-### Monitoring Training Progress
-
-Track training metrics in real-time with event handlers:
-
-```javascript
-const model = TeachableLLM.create('char', config);
-
-// Listen for training step updates
-model.on('trainStep', (step, progress) => {
-    console.log(`Step ${step.step}/${progress.totalSteps}`);
-    console.log(`Loss: ${step.loss.toFixed(4)}`);
-    console.log(`Validation Loss: ${step.valLoss?.toFixed(4) || 'N/A'}`);
-    console.log(`Progress: ${(progress.progress * 100).toFixed(1)}%`);
-    console.log(`Time Remaining: ${progress.timeRemaining}s`);
-
-    // Update UI progress bar
-    updateProgressBar(progress.progress);
-    updateLossChart(step.loss, step.valLoss);
+// Create a new model with a char or bpe tokeniser
+const model = TeachableLLM.create('char', {
+    vocabSize: 200,
+    blockSize: 128,
+    nLayer: 4,
+    nHead: 4,
+    nEmbed: 192,
 });
 
-await model.train(trainingText, options);
+// Switch backend if needed
+await TeachableLLM.selectBackend('webgpu');
 ```
 
-### Real-time Token Generation
-
-Stream generated tokens as they're produced:
+Training the tokeniser (when using streamed conversational data)
 
 ```javascript
-const generator = model.generator();
+import { data, tokenise } from '@genai-fi/nanogpt';
 
-// Listen for generated tokens
-generator.on('tokens', (tokens) => {
-    // tokens is an array of new token IDs
-    const text = model.tokeniser.decode(tokens);
-    console.log('New tokens:', text);
+// Prepare streams using data.loadTextData or MemoryConversationStream
+const streams = await data.loadTextData(['Some example text', 'More text']);
 
-    // Update UI incrementally
-    appendToOutput(text);
-});
-
-// Generation lifecycle events
-generator.on('start', () => {
-    console.log('Generation started');
-    showSpinner();
-});
-
-generator.on('stop', () => {
-    console.log('Generation complete');
-    hideSpinner();
-});
-
-generator.on('error', (error) => {
-    console.error('Generation error:', error);
-});
-
-// Start generation
-await generator.generate('Once upon a time', {
-    maxLength: 200,
-    temperature: 0.8,
-});
+// Train the tokeniser on streams
+const tokens = await model.trainTokeniser(streams);
+console.log('Trained token count:', tokens);
 ```
 
-## Training on Small Devices
-
-GenAI NanoGPT is designed to work efficiently on resource-constrained devices like iPads, phones, and Chromebooks:
-
-### Recommended Settings for Small Devices
+Start a training job
 
 ```javascript
-// Smaller model configuration for mobile devices
-const mobileModel = TeachableLLM.create('char', {
-    vocabSize: 200,
-    blockSize: 128, // Smaller context window
-    nLayer: 4, // Fewer layers
-    nHead: 3, // Fewer attention heads
-    nEmbed: 192, // Smaller embeddings
-});
+const job = await model.training.job(options, streams, datasets);
 
-// Training options optimized for limited memory
-await mobileModel.train(trainingText, {
-    batchSize: 8, // Smaller batch size
-    learningRate: 3e-4,
-    maxSteps: 500,
-    validationSplit: 0.1,
-    logInterval: 50,
-    gradientCheckpointing: true,
-    mixedPrecision: true,
+// Listen for training progress
+model.training.on('progress', (job) => {
+    console.log('Training job progress:', job.progress);
+    console.log('Latest log entry:', job.history?.[job.history.length - 1]);
 });
-```
-
-### Tips for Training on Mobile Devices
 
-1. **Start Small**: Use smaller models (4 layers) and shorter context windows (128 tokens)
-2. **Reduce Batch Size**: Use batch sizes of 8-16 depending on available memory
-3. **Use Character Tokenization**: Character-level tokenizers use less memory than BPE
-4. **Optimize Training Data**: Use smaller datasets or train in stages
-
-## Advanced Usage
+// Pause, resume, cancel via training API using the returned job id
+```
 
-### Attention Visualization
+Generate text (responses API)
 
 ```javascript
-const generator = model.generator();
+// Create a response — returns an id and may stream tokens via callback
+const resp = await model.responses.create(
+    {
+        input: 'Once upon a time',
+        maxLength: 100,
+        temperature: 0.9,
+    },
+    (chunk) => {
+        // called for intermediate chunks when provided
+        console.log('Partial output:', chunk.output);
+    }
+);
 
-const text = await generator.generate('Prompt', {
-    attentionScores: true,
-    maxLength: 50,
-});
-
-// Get attention data for visualization
-const attentionData = generator.getAttentionData();
-// Shape: [num_tokens][num_layers][num_heads][seq_len][seq_len]
+console.log('Final output:', resp.output);
 
-const probabilities = generator.getProbabilitiesData();
-// Shape: [num_tokens][seq_len][vocab_size]
+// Manage responses
+// model.responses.cancel(id)
+// model.responses.hook(id)
+// model.responses.resume(id)
 ```
 
-### Streaming Generation
+Tokenisers and token stores
 
 ```javascript
-const generator = model.generator();
+import { tokenise } from '@genai-fi/nanogpt';
 
-generator.on('tokens', (tokens) => {
-    // Update UI with new tokens in real-time
-    updateDisplay(tokens);
-});
+// Character and BPE tokenisers are available
+const { CharTokeniser, BPETokeniser, TokenStore, createTokenStore } = tokenise;
 
-generator.on('start', () => console.log('Generation started'));
-generator.on('stop', () => console.log('Generation complete'));
-
-await generator.generate('Once upon a time', {
-    maxLength: 200,
-});
+// Use TokenStore to persist prepared token sequences for training
 ```
 
-### Memory Management
+Data helpers
 
 ```javascript
-// Enable profiling
-model.enableProfiler = true;
+import { data } from '@genai-fi/nanogpt';
 
-// After training/generation
-const profiler = model.getProfiler();
-if (profiler) {
-    console.log('Memory stats:', profiler.getStats());
-}
+// Load plain text into conversation streams
+const streams = await data.loadTextData(['Line one', 'Line two']);
 
-// Clean up
-model.dispose();
+// MemoryConversationStream is useful for in-memory conversations
+const { MemoryConversationStream } = data;
 ```
 
-## Examples
-
-See the [`browser-tests`](browser-tests/) directory for complete examples:
-
--   [`generate.html`](browser-tests/generate.html): Text generation with UI
--   [`rope-train.html`](browser-tests/rope-train.html): Training a model with RoPE
--   [`hf.html`](browser-tests/hf.html): Loading from Hugging Face
--   [`loader.html`](browser-tests/loader.html): Loading different file formats
--   [`perf.html`](browser-tests/perf.html): Performance testing
-
 ## Development
 
-### Setup
+Clone and install dependencies:
 
 ```bash
 git clone https://github.com/knicos/genai-nanogpt.git
@@ -271,84 +128,24 @@ cd genai-nanogpt
 npm install
 ```
 
-### Building
-
-```bash
-npm run build       # Build for production
-npm run dev         # Development mode with watch
-```
-
-### Testing
-
-```bash
-npm test            # Run all tests
-```
-
-### Browser Tests
-
-```bash
-npm run test:gl       # Start dev server
-```
-
-### Project Structure
-
-```
-lib/
-├── models/          # Model architectures (NanoGPT)
-├── layers/          # Transformer layers (attention, MLP, etc.)
-├── ops/             # Custom TensorFlow.js operations
-│   ├── cpu/         # CPU kernels
-│   ├── webgl/       # WebGL kernels
-│   └── webgpu/      # WebGPU kernels
-├── training/        # Training utilities and optimizers
-├── tokeniser/       # Tokenization implementations
-├── loader/          # Model loading/saving
-├── utilities/       # Helper functions
-└── TeachableLLM.ts  # Main API
-```
-
-### Custom Operations
-
-This library implements several custom TensorFlow.js operations optimized for transformer models:
-
--   **RoPE**: Rotary Position Embeddings
--   **Attention Mask**: Causal attention masking
--   **RMS Norm**: Root Mean Square normalization
--   **Adam Optimizer**: Extended Adam with weight decay
--   **16-bit Operators**: To enable mixed-precision training
-
-See [`lib/ops`](lib/ops/) for implementations.
-
-### Contributing
-
-1. Fork the repository
-2. Create a feature branch: `git checkout -b feature/amazing-feature`
-3. Commit your changes: `git commit -m 'Add amazing feature'`
-4. Push to the branch: `git push origin feature/amazing-feature`
-5. Open a Pull Request
-
-### Code Style
-
-This project uses ESLint and Prettier for code formatting:
+Build and run browser tests:
 
 ```bash
-npm run lint        # Check code style
+npm run build
+npm run dev
+npm test
+npm run test:gl
 ```
 
-## Performance Tips
+## Examples and demos
 
-1. **Use WebGPU**: Provides the best performance for training and inference
-2. **Batch Size**: Larger batches improve GPU utilization but require more memory
-3. **Mixed Precision**: Enable for faster training on supported hardware (coming soon)
-4. **Gradient Checkpointing**: Reduce memory usage during training, but slower
-5. **Use RoPE**: More efficient than absolute position embeddings
-6. **Start Small on Mobile**: Use 2-4 layers and batch size 2-8 on phones/tablets
+See the `browser-tests/` directory for small example pages demonstrating generation, training, and model loading.
 
 ## Acknowledgments
 
--   Inspired by [Andrej Karpathy's NanoGPT](https://github.com/karpathy/nanoGPT)
--   Built with [TensorFlow.js](https://www.tensorflow.org/js)
--   Developed as part of the Finnish [Generation AI research project](https://generation-ai-stn.fi)
+- Inspired by Andrej Karpathy's NanoGPT: https://github.com/karpathy/nanoGPT
+- Built with TensorFlow.js: https://www.tensorflow.org/js
+- Developed as part of the Finnish Generation AI research project: https://generation-ai-stn.fi
 
 ## Citation
 

package/dist/{DatasetBuilder-C0iJT29K.js → DatasetBuilder-DU1G1OKX.js}

@@ -58,17 +58,17 @@ function b(e) {
 	return e != null && !ArrayBuffer.isView(e) && (Array.isArray(e) || typeof e == "object" && !(e instanceof f) && !(e instanceof Promise) && !t);
 }
 function x(e) {
-	return e == null || S(e) || Array.isArray(e) || typeof e == "object" && e instanceof f || l(e);
+	return e == null || ee(e) || Array.isArray(e) || typeof e == "object" && e instanceof f || l(e);
 }
-function S(e) {
+function ee(e) {
 	return e === null || typeof e != "object" && typeof e != "function";
 }
 //#endregion
 //#region node_modules/@tensorflow/tfjs-data/dist/util/deep_clone.js
-function C(e) {
-	return h(e, ee);
+function S(e) {
+	return h(e, C);
 }
-function ee(e) {
+function C(e) {
 	return e instanceof f ? {
 		value: e.clone(),
 		recurse: !1
@@ -249,7 +249,7 @@ var O = class {
 		};
 		let e = this.items[this.trav];
 		return this.trav++, {
-			value: C(e),
+			value: S(e),
 			done: !1
 		};
 	}
@@ -683,9 +683,9 @@ var ne = class {
 		let { batchSize: n = 32, noShuffle: r = !1, ignoreIndex: i = 65535 } = t || {}, a = e.getTokenCount();
 		if (a < this.blockSize + 1) throw Error(`Not enough tokens (${a}) for block size ${this.blockSize}`);
 		let o = Math.ceil(e.shardSize / this.blockSize), c = {
-			shuffledShards: new Uint32Array(e.getShardCount()),
-			shuffledIndexes: new Uint32Array(o),
-			lastShardIndexes: new Uint32Array(Math.ceil(e.getShardLength(e.getShardCount() - 1) / this.blockSize)),
+			shuffledShards: new Uint16Array(e.getShardCount()),
+			shuffledIndexes: new Uint16Array(o),
+			lastShardIndexes: new Uint16Array(Math.ceil(e.getShardLength(e.getShardCount() - 1) / this.blockSize)),
 			currentMask: null,
 			nextMask: null,
 			currentShard: null,
@@ -703,22 +703,19 @@ var ne = class {
 		})), {
 			dataset: Y(async function* () {
 				for (;;) {
-					let t = (c.shardIndex === c.shuffledShards.length - 1 ? c.lastShardIndexes : c.shuffledIndexes)[c.step], n = t * this.blockSize, a = c.currentShard, o = c.currentMask, s = $(c, e, r);
-					if (!a) break;
-					if (n + this.blockSize + 1 > a.length) {
-						console.warn("Index out of bounds for current shard, moving to next shard", t, n, a.length);
-						continue;
-					}
-					let l = new Int32Array(a.slice(n, n + this.blockSize)), u = new Int32Array(a.slice(n + 1, n + this.blockSize + 1));
-					if (o) {
-						let e = 0, t = o.slice(n + 1, n + this.blockSize + 1);
-						for (let n = 0; n < u.length; n++) t[n] === 0 && (u[n] = i, e++);
-						if (e === u.length) continue;
+					let t = (c.shardIndex === c.shuffledShards.length - 1 ? c.lastShardIndexes : c.shuffledIndexes)[c.step] * this.blockSize, n = c.currentShard, a = c.currentMask, o = $(c, e, r);
+					if (!n) break;
+					t + this.blockSize + 1 > n.length && (t = n.length - this.blockSize - 1);
+					let s = new Int32Array(n.slice(t, t + this.blockSize)), l = new Int32Array(n.slice(t + 1, t + this.blockSize + 1));
+					if (a) {
+						let e = 0, n = a.slice(t + 1, t + this.blockSize + 1);
+						for (let t = 0; t < l.length; t++) n[t] === 0 && (l[t] = i, e++);
+						if (e === l.length) continue;
 					}
 					yield {
-						xs: l,
-						ys: u
-					}, await s;
+						xs: s,
+						ys: l
+					}, await o;
 				}
 			}.bind(this)).batch(n).map((e) => {
 				let t = e;

package/dist/{RealDiv-CNsvC4AU.js → RealDiv-CSnvtN2E.js}

@@ -1,9 +1,9 @@
 import { Dn as e, En as t, Io as n, Ks as r, Ms as i, Si as a, Tn as o, nc as s, oc as c, wn as l, xn as u } from "./dist-Da20xy8E.js";
 import { L as d } from "./backend_util-DAV0I34P.js";
-import { o as f } from "./gpgpu_math-DBYEAAdI.js";
-import { J as p, b as m } from "./shared-CfTzpULd.js";
-import { S as h, n as g } from "./kernel_funcs_utils-D-mATnGR.js";
-import { t as _ } from "./Reshape-dnm9bO3B.js";
+import { Z as f } from "./gpgpu_math-20tPK8LM.js";
+import { b as p, n as m } from "./kernel_funcs_utils-ql8Y8qPn.js";
+import { t as h } from "./Reshape-BlylqwWy.js";
+import { J as g, b as _ } from "./shared-CfTzpULd.js";
 //#region node_modules/@tensorflow/tfjs-backend-webgl/dist/mean_gpu.js
 var v = class {
 	constructor(e, t) {
@@ -246,7 +246,7 @@ var w = class {
 		let n = Array(e.length);
 		for (let r = 0; r < n.length; r++) n[r] = e[t[r]];
 		if (this.outputShape = n, this.rank = n.length, this.rank > 6) throw Error(`Packed transpose for rank ${this.rank} is not yet supported.`);
-		let r = f(this.rank), i = h("rc", this.rank), a = Array(this.rank);
+		let r = f(this.rank), i = p("rc", this.rank), a = Array(this.rank);
 		for (let e = 0; e < t.length; e++) a[t[e]] = i[e];
 		let o = `vec2(${a.slice(-2).join()})`, s = `++${i[this.rank - 1]} < ${n[this.rank - 1]}`, c = `getChannel(getA(${a.join()}), ${o})`;
 		this.userCode = `
@@ -278,15 +278,15 @@ function T(e, t, n) {
 //#endregion
 //#region node_modules/@tensorflow/tfjs-backend-webgl/dist/kernels/Sum_impl.js
 function E(n, r, i, d) {
-	let f = r, p = n.shape.length, m = s(f, n.shape), h = m, g = t(h, p), v = g != null, y = n;
-	v && (y = T(n, g, d), h = e(h.length, p)), u("sum", h, p);
-	let [b, S] = l(y.shape, h), C = b;
+	let f = r, p = n.shape.length, m = s(f, n.shape), g = m, _ = t(g, p), v = _ != null, y = n;
+	v && (y = T(n, _, d), g = e(g.length, p)), u("sum", g, p);
+	let [b, S] = l(y.shape, g), C = b;
 	i && (C = o(b, m));
-	let w = c(S), E = c(n.shape) / w, D = _({
+	let w = c(S), E = c(n.shape) / w, D = h({
 		inputs: { x: y },
 		attrs: { shape: [E, w] },
 		backend: d
-	}), O = x(D, a(n.dtype), "sum", d), k = _({
+	}), O = x(D, a(n.dtype), "sum", d), k = h({
 		inputs: { x: O },
 		attrs: { shape: C },
 		backend: d
@@ -307,11 +307,11 @@ var O = {
 //#endregion
 //#region node_modules/@tensorflow/tfjs-backend-webgl/dist/kernels/Max_impl.js
 function k(e, t, n, r) {
-	let i = c(t), a = c(e.shape) / i, o = _({
+	let i = c(t), a = c(e.shape) / i, o = h({
 		inputs: { x: e },
 		attrs: { shape: [a, i] },
 		backend: r
-	}), s = x(o, e.dtype, "max", r), l = _({
+	}), s = x(o, e.dtype, "max", r), l = h({
 		inputs: { x: s },
 		attrs: { shape: n },
 		backend: r
@@ -321,24 +321,24 @@ function k(e, t, n, r) {
 //#endregion
 //#region node_modules/@tensorflow/tfjs-backend-webgl/dist/kernels/Max.js
 function A(n) {
-	let { inputs: r, backend: i, attrs: a } = n, { x: d } = r, { reductionIndices: f, keepDims: h } = a, g = d.shape.length, _ = s(f, d.shape), v = _, y = t(v, g), b = y != null, x = i.shouldExecuteOnCPU([d]), S = d;
+	let { inputs: r, backend: i, attrs: a } = n, { x: d } = r, { reductionIndices: f, keepDims: p } = a, m = d.shape.length, h = s(f, d.shape), v = h, y = t(v, m), b = y != null, x = i.shouldExecuteOnCPU([d]), S = d;
 	if (b) {
 		if (x) {
-			let e = i.texData.get(S.dataId).values, t = Array(g);
+			let e = i.texData.get(S.dataId).values, t = Array(m);
 			for (let e = 0; e < t.length; e++) t[e] = d.shape[y[e]];
-			let n = p(e, d.shape, d.dtype, y, t);
+			let n = g(e, d.shape, d.dtype, y, t);
 			S = i.makeTensorInfo(t, d.dtype);
 			let r = i.texData.get(S.dataId);
 			r.values = n;
 		} else S = T(d, y, i);
-		v = e(v.length, g);
+		v = e(v.length, m);
 	}
-	u("max", v, g);
+	u("max", v, m);
 	let [C, w] = l(S.shape, v), E = C;
-	h && (E = o(C, _));
+	p && (E = o(C, h));
 	let D;
 	if (x) {
-		let e = i.texData.get(S.dataId).values, t = m(e, c(w), E, d.dtype);
+		let e = i.texData.get(S.dataId).values, t = _(e, c(w), E, d.dtype);
 		D = i.makeTensorInfo(E, d.dtype);
 		let n = i.texData.get(D.dataId);
 		n.values = t;
@@ -349,7 +349,7 @@ var j = {
 	kernelName: "Max",
 	backendName: "webgl",
 	kernelFunc: A
-}, M = g({
+}, M = m({
 	opSnippet: "\nif (a == b) {\n  return 1.0;\n};\nreturn a / b;",
 	packedOpSnippet: "\n  // vec4 one = vec4(equal(a, b));\n  // return one + (vec4(1.0) - one) * a / b;\n  vec4 result = a / b;\n  if(a.x == b.x) {\n    result.x = 1.;\n  }\n  if(a.y == b.y) {\n    result.y = 1.;\n  }\n  if(a.z == b.z) {\n    result.z = 1.;\n  }\n  if(a.w == b.w) {\n    result.w = 1.;\n  }\n\n  return result;\n",
 	checkOutOfBounds: !0