@zephyr3d/device 0.1.0

package/dist/index.js

@@ -0,0 +1,16 @@
+export { DeviceGPUObjectAddedEvent, DeviceGPUObjectRemovedEvent, DeviceGPUObjectRenameEvent, DeviceLostEvent, DeviceResizeEvent, DeviceRestoreEvent, ShaderType, encodePixel, encodePixelToArray, getTextureFormatBlockHeight, getTextureFormatBlockSize, getTextureFormatBlockWidth, hasAlphaChannel, hasBlueChannel, hasDepthChannel, hasGreenChannel, hasRedChannel, hasStencilChannel, isCompressedTextureFormat, isFloatTextureFormat, isIntegerTextureFormat, isSRGBTextureFormat, isSignedTextureFormat, linearTextureFormatToSRGB } from './base_types.js';
+export { VertexData } from './vertexdata.js';
+export { GPUResourceUsageFlags, MAX_BINDING_GROUPS, MAX_TEXCOORD_INDEX_COUNT, MAX_VERTEX_ATTRIBUTES, VERTEX_ATTRIB_BLEND_INDICES, VERTEX_ATTRIB_BLEND_WEIGHT, VERTEX_ATTRIB_DIFFUSE, VERTEX_ATTRIB_NORMAL, VERTEX_ATTRIB_POSITION, VERTEX_ATTRIB_TANGENT, VERTEX_ATTRIB_TEXCOORD0, VERTEX_ATTRIB_TEXCOORD1, VERTEX_ATTRIB_TEXCOORD2, VERTEX_ATTRIB_TEXCOORD3, VERTEX_ATTRIB_TEXCOORD4, VERTEX_ATTRIB_TEXCOORD5, VERTEX_ATTRIB_TEXCOORD6, VERTEX_ATTRIB_TEXCOORD7, genDefaultName, getVertexAttribByName, getVertexAttribFormat, getVertexAttribName, getVertexBufferAttribType, getVertexBufferAttribTypeBySemantic, getVertexBufferLength, getVertexBufferStride, getVertexFormatSize, makeVertexBufferType, semanticList, semanticToAttrib } from './gpuobject.js';
+export { BaseDevice } from './device.js';
+export { PBShaderExp, Proxiable, getCurrentProgramBuilder, makeConstructor, setCurrentProgramBuilder } from './builder/base.js';
+export { ASTAddressOf, ASTArrayIndex, ASTAssignment, ASTBinaryFunc, ASTBreak, ASTCallFunction, ASTCast, ASTContinue, ASTDeclareVar, ASTDiscard, ASTDoWhile, ASTExpression, ASTFunction, ASTFunctionParameter, ASTGlobalScope, ASTHash, ASTIf, ASTLValue, ASTLValueArray, ASTLValueDeclare, ASTLValueHash, ASTLValueScalar, ASTNakedScope, ASTPrimitive, ASTRange, ASTReferenceOf, ASTReturn, ASTScalar, ASTScope, ASTSelect, ASTShaderExpConstructor, ASTStructDefine, ASTTouch, ASTUnaryFunc, ASTWhile, DeclareType, ShaderAST, ShaderPrecisionType, builtinVariables, genSamplerName, getBuiltinInputStructInstanceName, getBuiltinInputStructName, getBuiltinOutputStructInstanceName, getBuiltinOutputStructName, getTextureSampleType } from './builder/ast.js';
+export { PBBuiltinScope, PBDoWhileScope, PBForScope, PBFunctionScope, PBGlobalScope, PBIfScope, PBInputScope, PBInsideFunctionScope, PBLocalScope, PBNakedScope, PBOutputScope, PBScope, PBWhileScope, ProgramBuilder } from './builder/programbuilder.js';
+export { PBAddressSpace, PBAnyTypeInfo, PBArrayTypeInfo, PBAtomicI32TypeInfo, PBAtomicU32TypeInfo, PBFunctionTypeInfo, PBPointerTypeInfo, PBPrimitiveType, PBPrimitiveTypeInfo, PBSamplerAccessMode, PBSamplerTypeInfo, PBStructTypeInfo, PBTextureType, PBTextureTypeInfo, PBTypeInfo, PBVoidTypeInfo, typeAny, typeAtomicI32, typeAtomicU32, typeBVec2, typeBVec3, typeBVec4, typeBool, typeF16, typeF16Vec2, typeF16Vec3, typeF16Vec4, typeF32, typeF32Vec2, typeF32Vec3, typeF32Vec4, typeFrexpResult, typeFrexpResultVec2, typeFrexpResultVec3, typeFrexpResultVec4, typeI16, typeI16Vec2, typeI16Vec2_Norm, typeI16Vec3, typeI16Vec3_Norm, typeI16Vec4, typeI16Vec4_Norm, typeI16_Norm, typeI32, typeI32Vec2, typeI32Vec2_Norm, typeI32Vec3, typeI32Vec3_Norm, typeI32Vec4, typeI32Vec4_Norm, typeI32_Norm, typeI8, typeI8Vec2, typeI8Vec2_Norm, typeI8Vec3, typeI8Vec3_Norm, typeI8Vec4, typeI8Vec4_Norm, typeI8_Norm, typeITex1D, typeITex2D, typeITex2DArray, typeITex3D, typeITexCube, typeITexCubeArray, typeITexMultisampled2D, typeMat2, typeMat2x3, typeMat2x4, typeMat3, typeMat3x2, typeMat3x4, typeMat4, typeMat4x2, typeMat4x3, typeSampler, typeSamplerComparison, typeTex1D, typeTex2D, typeTex2DArray, typeTex3D, typeTexCube, typeTexCubeArray, typeTexDepth2D, typeTexDepth2DArray, typeTexDepthCube, typeTexDepthCubeArray, typeTexDepthMultisampled2D, typeTexExternal, typeTexMultisampled2D, typeTexStorage1D_bgra8unorm, typeTexStorage1D_r32float, typeTexStorage1D_r32sint, typeTexStorage1D_r32uint, typeTexStorage1D_rg32float, typeTexStorage1D_rg32sint, typeTexStorage1D_rg32uint, typeTexStorage1D_rgba16float, typeTexStorage1D_rgba16sint, typeTexStorage1D_rgba16uint, typeTexStorage1D_rgba32float, typeTexStorage1D_rgba32sint, typeTexStorage1D_rgba32uint, typeTexStorage1D_rgba8sint, typeTexStorage1D_rgba8snorm, typeTexStorage1D_rgba8uint, typeTexStorage1D_rgba8unorm, typeTexStorage2DArray_bgra8unorm, typeTexStorage2DArray_r32float, typeTexStorage2DArray_r32sint, typeTexStorage2DArray_r32uint, typeTexStorage2DArray_rg32float, typeTexStorage2DArray_rg32sint, typeTexStorage2DArray_rg32uint, typeTexStorage2DArray_rgba16float, typeTexStorage2DArray_rgba16sint, typeTexStorage2DArray_rgba16uint, typeTexStorage2DArray_rgba32float, typeTexStorage2DArray_rgba32sint, typeTexStorage2DArray_rgba32uint, typeTexStorage2DArray_rgba8sint, typeTexStorage2DArray_rgba8snorm, typeTexStorage2DArray_rgba8uint, typeTexStorage2DArray_rgba8unorm, typeTexStorage2D_bgra8unorm, typeTexStorage2D_r32float, typeTexStorage2D_r32sint, typeTexStorage2D_r32uint, typeTexStorage2D_rg32float, typeTexStorage2D_rg32sint, typeTexStorage2D_rg32uint, typeTexStorage2D_rgba16float, typeTexStorage2D_rgba16sint, typeTexStorage2D_rgba16uint, typeTexStorage2D_rgba32float, typeTexStorage2D_rgba32sint, typeTexStorage2D_rgba32uint, typeTexStorage2D_rgba8sint, typeTexStorage2D_rgba8snorm, typeTexStorage2D_rgba8uint, typeTexStorage2D_rgba8unorm, typeTexStorage3D_bgra8unorm, typeTexStorage3D_r32float, typeTexStorage3D_r32sint, typeTexStorage3D_r32uint, typeTexStorage3D_rg32float, typeTexStorage3D_rg32sint, typeTexStorage3D_rg32uint, typeTexStorage3D_rgba16float, typeTexStorage3D_rgba16sint, typeTexStorage3D_rgba16uint, typeTexStorage3D_rgba32float, typeTexStorage3D_rgba32sint, typeTexStorage3D_rgba32uint, typeTexStorage3D_rgba8sint, typeTexStorage3D_rgba8snorm, typeTexStorage3D_rgba8uint, typeTexStorage3D_rgba8unorm, typeU16, typeU16Vec2, typeU16Vec2_Norm, typeU16Vec3, typeU16Vec3_Norm, typeU16Vec4, typeU16Vec4_Norm, typeU16_Norm, typeU32, typeU32Vec2, typeU32Vec2_Norm, typeU32Vec3, typeU32Vec3_Norm, typeU32Vec4, typeU32Vec4_Norm, typeU32_Norm, typeU8, typeU8Vec2, typeU8Vec2_Norm, typeU8Vec3, typeU8Vec3_Norm, typeU8Vec4, typeU8Vec4_Norm, typeU8_Norm, typeUTex1D, typeUTex2D, typeUTex2DArray, typeUTex3D, typeUTexCube, typeUTexCubeArray, typeUTexMultisampled2D, typeVoid } from './builder/types.js';
+export { PBReflection } from './builder/reflection.js';
+export { TextureAtlasManager } from './helpers/textureatlas.js';
+export { Font, FontCanvas } from './helpers/font.js';
+export { GlyphManager } from './helpers/glyphmanager.js';
+export { DrawText } from './helpers/drawtext.js';
+export { CPUTimer } from './timer.js';
+export { StructuredBufferData } from './uniformdata.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;"}

package/dist/timer.js

@@ -0,0 +1,38 @@
+/**
+ * Abstract timer interface
+ * @public
+ */ /**
+ * CPU timer class
+ * @public
+ */ class CPUTimer {
+    /** @internal */ _cpuTimer;
+    /** @internal */ _cpuStart;
+    /** @internal */ _cpuTime;
+    /** @internal */ _ended;
+    constructor(){
+        this._cpuTimer = window.performance || window.Date;
+        this._cpuTime = null;
+        this._ended = false;
+    }
+    now() {
+        return this._cpuTimer.now();
+    }
+    begin() {
+        this._cpuStart = this.now();
+        this._cpuTime = null;
+        this._ended = false;
+    }
+    end() {
+        this._cpuTime = this.now() - this._cpuStart;
+        this._ended = true;
+    }
+    ended() {
+        return this._ended;
+    }
+    elapsed() {
+        return this._cpuTime;
+    }
+}
+
+export { CPUTimer };
+//# sourceMappingURL=timer.js.map

package/dist/timer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timer.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/uniformdata.js

@@ -0,0 +1,147 @@
+import { PBPrimitiveType } from './builder/types.js';
+
+/**
+ * Structured buffer data
+ * @public
+ */ class StructuredBufferData {
+    /** @internal */ _cache;
+    /** @internal */ _buffer;
+    /** @internal */ _size;
+    /** @internal */ _uniformMap;
+    /** @internal */ _uniformPositions;
+    /**
+   * Creates a new structured buffer data
+   * @param layout - Layout of the structure
+   * @param buffer - Buffer that holds the data
+   */ constructor(layout, buffer){
+        this._size = layout.byteSize + 15 & ~15;
+        if (this._size <= 0) {
+            throw new Error(`UniformBuffer(): invalid uniform buffer byte size: ${this._size}`);
+        }
+        // this._cache = new ArrayBuffer(size);
+        this._uniformMap = {};
+        this._uniformPositions = {};
+        this._cache = buffer instanceof ArrayBuffer ? buffer : null;
+        this._buffer = buffer instanceof ArrayBuffer ? null : buffer;
+        this.init(layout, 0, '');
+    }
+    /** The buffer size in bytes */ get byteLength() {
+        return this._size;
+    }
+    /** Get the data cache buffer */ get buffer() {
+        return this._cache;
+    }
+    /** Get all the uniform datas */ get uniforms() {
+        return this._uniformMap;
+    }
+    /**
+   * Sets the value of a structure member
+   * @param name - Name of the member
+   * @param value - Value to set
+   */ set(name, value) {
+        if (value !== undefined) {
+            const view = this._uniformMap[name];
+            if (view) {
+                if (this._cache) {
+                    if (typeof value === 'number') {
+                        view[0] = value;
+                    } else if (value?._v) {
+                        view.set(value._v);
+                    } else if (typeof value?.length === 'number') {
+                        view.set(value);
+                    } else {
+                        throw new Error('invalid uniform value');
+                    }
+                } else {
+                    const size = this._uniformPositions[name][1];
+                    if (typeof value === 'number') {
+                        view[0] = value;
+                        this._buffer.bufferSubData(this._uniformPositions[name][0], view);
+                    } else if (value['BYTES_PER_ELEMENT'] && size <= value['byteLength']) {
+                        const arr = value;
+                        this._buffer.bufferSubData(this._uniformPositions[name][0], arr, 0, size / arr.BYTES_PER_ELEMENT >> 0);
+                    } else {
+                        throw new Error('invalid uniform value');
+                    }
+                }
+            } else {
+                const proto = Object.getPrototypeOf(value);
+                if (proto === Object.getPrototypeOf({})) {
+                    this.setStruct(name, value);
+                } else {
+                    throw new Error('invalid uniform value');
+                }
+            }
+        }
+    }
+    /** @internal */ setStruct(name, value) {
+        for(const k in value){
+            this.set(`${name}.${k}`, value[k]);
+        }
+    }
+    /** @internal */ init(layout, offset, prefix) {
+        for (const entry of layout.entries){
+            if (entry.subLayout) {
+                offset = this.init(entry.subLayout, offset, `${prefix}${entry.name}.`);
+            } else {
+                const name = `${prefix}${entry.name}`;
+                if (this._uniformPositions[name]) {
+                    throw new Error(`UniformBuffer(): duplicate uniform name: ${name}`);
+                }
+                if (entry.offset < offset || entry.byteSize < 0) {
+                    throw new Error('UniformBuffer(): invalid layout');
+                }
+                this._uniformPositions[name] = [
+                    entry.offset,
+                    entry.byteSize
+                ];
+                let viewCtor = null;
+                switch(entry.type){
+                    case PBPrimitiveType.F32:
+                        viewCtor = Float32Array;
+                        break;
+                    case PBPrimitiveType.U32:
+                    case PBPrimitiveType.BOOL:
+                        viewCtor = Uint32Array;
+                        break;
+                    case PBPrimitiveType.I32:
+                        viewCtor = Int32Array;
+                        break;
+                    case PBPrimitiveType.U16:
+                    case PBPrimitiveType.U16_NORM:
+                    case PBPrimitiveType.F16:
+                        viewCtor = Uint16Array;
+                        break;
+                    case PBPrimitiveType.I16:
+                    case PBPrimitiveType.I16_NORM:
+                        viewCtor = Int16Array;
+                        break;
+                    case PBPrimitiveType.U8:
+                    case PBPrimitiveType.U8_NORM:
+                        viewCtor = Uint8Array;
+                        break;
+                    case PBPrimitiveType.I8:
+                    case PBPrimitiveType.I8_NORM:
+                        viewCtor = Int8Array;
+                        break;
+                }
+                if (!viewCtor) {
+                    throw new Error(`UniformBuffer(): invalid data type for uniform: ${name}`);
+                }
+                if (entry.byteSize % viewCtor.BYTES_PER_ELEMENT) {
+                    throw new Error(`UniformBuffer(): invalid byte size for uniform: ${name}`);
+                }
+                if (this._cache) {
+                    this._uniformMap[name] = new viewCtor(this._cache, entry.offset, entry.byteSize / viewCtor.BYTES_PER_ELEMENT);
+                } else {
+                    this._uniformMap[name] = new viewCtor(1);
+                }
+                offset = entry.offset + entry.byteSize;
+            }
+        }
+        return offset;
+    }
+}
+
+export { StructuredBufferData };
+//# sourceMappingURL=uniformdata.js.map

package/dist/uniformdata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uniformdata.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/vertexdata.js

@@ -0,0 +1,135 @@
+import { MAX_VERTEX_ATTRIBUTES, getVertexAttribByName, GPUResourceUsageFlags, getVertexBufferAttribType, getVertexBufferStride } from './gpuobject.js';
+
+/**
+ * The vertex data class
+ * @public
+ */ class VertexData {
+    /** @internal */ _vertexBuffers;
+    /** @internal */ _indexBuffer;
+    /** @internal */ _drawOffset;
+    constructor(){
+        this._vertexBuffers = [];
+        for(let i = 0; i < MAX_VERTEX_ATTRIBUTES; i++){
+            this._vertexBuffers.push(null);
+        }
+        this._indexBuffer = null;
+        this._drawOffset = 0;
+    }
+    /**
+   * Creates a new instance of VertexData by copying from this object
+   * @returns New instance of VertexData
+   */ clone() {
+        const newVertexData = new VertexData();
+        newVertexData._vertexBuffers = this._vertexBuffers.slice();
+        newVertexData._indexBuffer = this._indexBuffer;
+        newVertexData._drawOffset = this._drawOffset;
+        return newVertexData;
+    }
+    /** Vertex buffer information list */ get vertexBuffers() {
+        return this._vertexBuffers;
+    }
+    /** Index buffer */ get indexBuffer() {
+        return this._indexBuffer;
+    }
+    /** Draw offset */ getDrawOffset() {
+        return this._drawOffset;
+    }
+    setDrawOffset(offset) {
+        if (offset !== this._drawOffset) {
+            this._drawOffset = offset;
+        }
+    }
+    /**
+   * Gets the vertex buffer by specific vertex semantic
+   * @param semantic - The vertex semantic
+   * @returns Vertex buffer of the given semantic
+   */ getVertexBuffer(semantic) {
+        return this._vertexBuffers[getVertexAttribByName(semantic)]?.buffer ?? null;
+    }
+    /**
+   * Gets the vertex buffer information by specific vertex semantic
+   * @param semantic - The vertex semantic
+   * @returns Vertex buffer information of the given semantic
+   */ getVertexBufferInfo(semantic) {
+        return this._vertexBuffers[getVertexAttribByName(semantic)] ?? null;
+    }
+    /**
+   * Gets the index buffer
+   * @returns The index buffer
+   */ getIndexBuffer() {
+        return this._indexBuffer || null;
+    }
+    /**
+   * Sets a vertex buffer
+   * @param buffer - The vertex buffer object
+   * @param stepMode - Step mode of the buffer
+   * @returns The buffer that was set
+   */ setVertexBuffer(buffer, stepMode) {
+        if (!buffer || !(buffer.usage & GPUResourceUsageFlags.BF_VERTEX)) {
+            throw new Error('setVertexBuffer() failed: buffer is null or buffer has not Vertex usage flag');
+        }
+        stepMode = stepMode || 'vertex';
+        const vertexType = buffer.structure.structMembers[0].type.elementType;
+        if (vertexType.isStructType()) {
+            let offset = 0;
+            for (const attrib of vertexType.structMembers){
+                const loc = getVertexAttribByName(attrib.name);
+                this.internalSetVertexBuffer(loc, buffer, offset, stepMode);
+                offset += attrib.size;
+            }
+        } else {
+            const loc = getVertexAttribByName(buffer.structure.structMembers[0].name);
+            this.internalSetVertexBuffer(loc, buffer, 0, stepMode);
+        }
+        return buffer;
+    }
+    /**
+   * Removes a vertex buffer
+   * @param buffer - Vertex buffer to be removed
+   * @returns true if the buffer was successfully removed, otherwise false
+   */ removeVertexBuffer(buffer) {
+        let removed = false;
+        for(let loc = 0; loc < this._vertexBuffers.length; loc++){
+            const info = this._vertexBuffers[loc];
+            const remove = info?.buffer === buffer;
+            if (remove) {
+                this._vertexBuffers[loc] = null;
+                removed = true;
+            }
+        }
+        return removed;
+    }
+    /**
+   * Sets the index buffer
+   * @param buffer - Index buffer to be set
+   * @returns The index buffer that was set
+   */ setIndexBuffer(buffer) {
+        if (buffer !== this._indexBuffer) {
+            this._indexBuffer = buffer || null;
+        }
+        return buffer;
+    }
+    /** @internal */ internalSetVertexBuffer(loc, buffer, offset, stepMode) {
+        if (loc < 0 || loc >= MAX_VERTEX_ATTRIBUTES) {
+            throw new Error(`setVertexBuffer() failed: location out of bounds: ${loc}`);
+        }
+        offset = Number(offset) || 0;
+        stepMode = stepMode || 'vertex';
+        const old = this._vertexBuffers[loc];
+        if (!old || old.buffer !== buffer || old.offset !== offset || old.stepMode !== stepMode) {
+            this._vertexBuffers[loc] = {
+                buffer: buffer,
+                offset: offset,
+                type: getVertexBufferAttribType(buffer.structure, loc),
+                stride: getVertexBufferStride(buffer.structure),
+                drawOffset: 0,
+                stepMode: stepMode
+            };
+            return buffer;
+        }
+        return null;
+    }
+}
+
+export { VertexData };
+//# sourceMappingURL=vertexdata.js.map

package/dist/vertexdata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vertexdata.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@zephyr3d/device",
+  "version": "0.1.0",
+  "description": "base system for zephyr3d library",
+  "homepage": "https://github.com/gavinyork/zephyr3d#readme",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "**/*.js",
+    "**/*.d.ts",
+    "**/*.js.map"
+  ],
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gavinyork/zephyr3d.git"
+  },
+  "scripts": {
+    "clean": "shx rm -rf ./dist .tsbuildinfo",
+    "tsc": "tsc -p . --noEmit",
+    "build": "cross-env NODE_OPTIONS=--max_old_space_size=8192 rollup -c --silent"
+  },
+  "keywords": [
+    "javascript",
+    "3d",
+    "rendering",
+    "engine",
+    "webgl",
+    "webgpu",
+    "canvas",
+    "zephyr3d",
+    "device"
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/gavinyork/zephyr3d/issues"
+  },
+  "engines": {
+    "node": ">=16.18.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.20.12",
+    "@babel/preset-env": "^7.20.2",
+    "@rollup/plugin-babel": "^6.0.3",
+    "@rollup/plugin-node-resolve": "^15.0.1",
+    "@rollup/plugin-strip": "^3.0.2",
+    "@rollup/plugin-terser": "^0.4.0",
+    "@rollup/pluginutils": "^5.0.2",
+    "rollup": "^3.15.0",
+    "rollup-plugin-dts": "^5.2.0",
+    "rollup-plugin-copy": "^3.4.0",
+    "rollup-plugin-typescript2": "^0.34.1",
+    "@swc/core": "^1.3.62",
+    "rollup-plugin-swc3": "^0.8.2",
+    "shx": "^0.3.4",
+    "cross-env": "^7.0.3",
+    "typescript": "^5.1.3",
+    "@zephyr3d/base": "workspace:^0.1.0"
+  },
+  "peerDependencies": {
+    "@zephyr3d/base": "workspace:^0.1.0"
+  },
+  "dependencies": {
+    "@webgpu/types": "^0.1.31",
+    "@types/node": "^18.13.0"
+  }
+}