{"version":3,"sources":["../src/index.ts","../src/wgsl.ts","../src/mathUtils.ts","../src/std140.ts"],"sourcesContent":["export { default as wgsl, resolveProgram } from './wgsl';\nexport * from './std140';\n","import { BufferWriter, MaxValue } from 'typed-binary';\nimport { roundUp } from './mathUtils';\nimport { type AlignedSchema } from './std140';\n\nexport class NameRegistry {\n private lastUniqueId = 0;\n private names = new WeakMap();\n\n nameFor(token: WGSLToken) {\n let name = this.names.get(token);\n if (name === undefined) {\n name = `${token.sanitizedName}_${this.lastUniqueId++}`;\n this.names.set(token, name);\n }\n\n return name;\n }\n}\n\nexport class StorageRegistry {\n public size = 0;\n public entries: WGSLStorage[] = [];\n public storageName = new WGSLToken('readonly_storage');\n private locationsMap = new WeakMap();\n\n register(storage: WGSLStorage) {\n this.entries.push(storage);\n // aligning\n this.size = roundUp(this.size, storage.baseAlignment);\n this.locationsMap.set(storage, this.size);\n this.size += storage.size;\n }\n\n locationFor(storage: WGSLStorage) {\n return this.locationsMap.get(storage);\n }\n}\n\nexport class WGSLRuntime {\n public readonly readonlyStorageBuffer?: GPUBuffer;\n\n constructor(\n public readonly device: GPUDevice,\n public readonly names: NameRegistry,\n public readonly readonlyStorage: StorageRegistry,\n ) {\n if (readonlyStorage.size > 0) {\n this.readonlyStorageBuffer = device.createBuffer({\n usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,\n size: roundUp(readonlyStorage.size, 16),\n });\n }\n }\n\n nameFor(token: WGSLToken) {\n return this.names.nameFor(token);\n }\n}\n\nexport interface IResolutionCtx {\n addDependency(item: WGSLItem): void;\n readonlyStorageToken: WGSLToken;\n addReadonlyStorage(storage: WGSLStorage): void;\n nameFor(token: WGSLToken): string;\n resolve(item: WGSLSegment): string;\n}\n\nexport class ResolutionCtx implements IResolutionCtx {\n public dependencies: WGSLItem[] = [];\n public readonlyStorageDeclarationIdx = 0;\n\n private memoizedResults = new WeakMap();\n\n constructor(\n public readonly names: NameRegistry,\n public readonly readonlyStorage: StorageRegistry,\n public readonly paramBindings: [WGSLParam, WGSLParamValue][],\n private readonly group: number,\n ) {}\n\n addDependency(item: WGSLItem) {\n this.resolve(item);\n addUnique(this.dependencies, item);\n }\n\n get readonlyStorageToken() {\n return this.readonlyStorage.storageName;\n }\n\n addReadonlyStorage(storage: WGSLStorage): void {\n this.readonlyStorage.register(storage);\n this.readonlyStorageDeclarationIdx = this.dependencies.length;\n }\n\n nameFor(token: WGSLToken): string {\n return this.names.nameFor(token);\n }\n\n resolve(item: WGSLSegment) {\n if (typeof item === 'string') {\n return item;\n }\n\n if (typeof item === 'number') {\n return String(item);\n }\n\n const memoizedResult = this.memoizedResults.get(item);\n if (memoizedResult !== undefined) {\n return memoizedResult;\n }\n\n const result = item.resolve(this);\n this.memoizedResults.set(item, result);\n return result;\n }\n}\n\nabstract class WGSLItem {\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n getChildren(ctx: IResolutionCtx): WGSLItem[] {\n return [];\n }\n\n abstract resolve(ctx: IResolutionCtx): string;\n}\n\nexport class WGSLToken extends WGSLItem {\n constructor(public readonly description: string) {\n super();\n }\n\n get sanitizedName() {\n return this.description.replaceAll(/\\s/g, '_');\n }\n\n resolve(ctx: IResolutionCtx): string {\n return ctx.nameFor(this);\n }\n}\n\nexport type WGSLParamValue = string | number;\nclass WGSLParam extends WGSLItem {\n constructor(\n public readonly description: string,\n public readonly defaultValue?: WGSLParamValue,\n ) {\n super();\n }\n\n resolve(ctx: ResolutionCtx): string {\n const [, value = this.defaultValue] =\n ctx.paramBindings.find(([param]) => param === this) ?? [];\n if (!value) {\n throw new Error(`Missing parameter binding for '${this.description}'`);\n }\n return String(value);\n }\n}\n\n/**\n * Creates a constant is computed at shader initialization according\n * to the passed in expression.\n */\nclass WGSLConstant extends WGSLItem {\n public token: WGSLToken;\n\n constructor(\n private readonly expr: WGSLSegment,\n public readonly description: string,\n ) {\n super();\n this.token = new WGSLToken(description.replaceAll(/\\s/g, '_'));\n }\n\n resolve(ctx: ResolutionCtx): string {\n ctx.addDependency(code`const ${this.token} = ${this.expr};`);\n\n return ctx.resolve(this.token);\n }\n}\n\nexport interface WGSLStorage {\n readonly nameToken: WGSLToken;\n readonly typeExpr: WGSLSegment;\n readonly size: number;\n readonly baseAlignment: number;\n}\n\nclass WGSLReadonlyStorage extends WGSLItem implements WGSLStorage {\n public nameToken: WGSLToken;\n public size: number;\n public baseAlignment: number;\n\n constructor(\n description: string,\n public readonly typeExpr: WGSLSegment,\n private readonly typeSchema: AlignedSchema,\n ) {\n super();\n\n this.nameToken = new WGSLToken(description);\n this.size = this.typeSchema.measure(MaxValue).size;\n this.baseAlignment = this.typeSchema.baseAlignment;\n }\n\n write(runtime: WGSLRuntime, data: T) {\n const gpuBuffer = runtime.readonlyStorageBuffer;\n\n if (!gpuBuffer) {\n console.warn(\n `Cannot write to the read-only storage buffer. Nothing is used in code.`,\n );\n return;\n }\n\n const bufferOffset = runtime.readonlyStorage.locationFor(this);\n\n if (bufferOffset === undefined) {\n console.warn(`Cannot write to a storage entry that is unused in code.`);\n return;\n }\n\n const hostBuffer = new ArrayBuffer(this.size);\n this.typeSchema.write(new BufferWriter(hostBuffer), data);\n runtime.device.queue.writeBuffer(\n gpuBuffer,\n bufferOffset,\n hostBuffer,\n 0,\n this.size,\n );\n }\n\n resolve(ctx: IResolutionCtx): string {\n ctx.addReadonlyStorage(this);\n ctx.resolve(this.typeExpr); // Adding dependencies of this entry\n\n return (\n ctx.resolve(ctx.readonlyStorageToken) + '.' + ctx.resolve(this.nameToken)\n );\n }\n}\n\nclass WGSLFunction extends WGSLItem {\n private nameToken: WGSLToken;\n\n constructor(\n prefix: string,\n private readonly body: WGSLCode,\n ) {\n super();\n\n this.nameToken = new WGSLToken(prefix);\n }\n\n resolve(ctx: ResolutionCtx): string {\n ctx.addDependency(code`fn ${this.nameToken}${this.body}`);\n\n return ctx.resolve(this.nameToken);\n }\n}\n\nfunction addUnique(list: T[], value: T) {\n if (list.includes(value)) {\n return;\n }\n\n list.push(value);\n}\n\nexport class WGSLCode extends WGSLItem {\n constructor(public readonly segments: WGSLSegment[]) {\n super();\n }\n\n getChildren(): WGSLItem[] {\n return this.segments.filter((s): s is WGSLItem => typeof s !== 'string');\n }\n\n resolve(ctx: ResolutionCtx) {\n let code = '';\n\n for (const s of this.segments) {\n switch (true) {\n case s instanceof WGSLItem:\n code += ctx.resolve(s);\n break;\n default:\n code += String(s);\n }\n }\n\n return code;\n }\n}\n\nexport type WGSLSegment = string | number | WGSLItem;\n\nfunction defined(value: T): value is NonNullable {\n return value !== undefined;\n}\n\nexport function resolveProgram(\n device: GPUDevice,\n root: WGSLItem,\n options: {\n shaderStage: number;\n bindingGroup: number;\n params?: [WGSLParam, WGSLParamValue][];\n },\n) {\n const names = new NameRegistry();\n const readonlyStorage = new StorageRegistry();\n const ctx = new ResolutionCtx(\n names,\n readonlyStorage,\n options.params ?? [],\n options.bindingGroup,\n );\n\n const codeString = ctx.resolve(root); // Resolving\n\n const runtime = new WGSLRuntime(device, names, readonlyStorage);\n\n const bindGroupLayout = device.createBindGroupLayout({\n entries: [\n runtime.readonlyStorageBuffer\n ? {\n binding: 0,\n visibility: options.shaderStage,\n buffer: {\n type: 'read-only-storage' as const,\n },\n }\n : undefined,\n ].filter(defined),\n });\n\n const bindGroup = device.createBindGroup({\n layout: bindGroupLayout,\n entries: [\n runtime.readonlyStorageBuffer\n ? {\n binding: 0,\n resource: {\n buffer: runtime.readonlyStorageBuffer,\n },\n }\n : undefined,\n ].filter(defined),\n });\n\n const readonlyEntries = runtime.readonlyStorage.entries.map(\n (e) => code`${e.nameToken}: ${e.typeExpr},\\n`,\n );\n\n const storageTypeToken = new WGSLToken('ReadonlyStorageType');\n\n const dependencies = ctx.dependencies.slice();\n\n if (readonlyEntries.length > 0) {\n dependencies.splice(\n ctx.readonlyStorageDeclarationIdx,\n 0,\n code`\n struct ${storageTypeToken} {\n ${readonlyEntries}\n }\n\n @group(${options.bindingGroup}) @binding(0) var ${ctx.readonlyStorageToken}: ${storageTypeToken};\n `,\n );\n }\n\n return {\n runtime,\n bindGroupLayout,\n bindGroup,\n code:\n dependencies.map((d) => ctx.resolve(d)).join('\\n') + '\\n' + codeString,\n };\n}\n\nexport function code(\n strings: TemplateStringsArray,\n ...params: (WGSLSegment | WGSLSegment[])[]\n): WGSLCode {\n const segments: WGSLSegment[] = strings.flatMap((string, idx) => {\n if (idx >= params.length) {\n return [string];\n }\n\n const param = params[idx]!;\n return param instanceof Array ? [string, ...param] : [string, param];\n });\n\n return new WGSLCode(segments);\n}\n\nfunction fn(prefix: string = 'function') {\n return (\n strings: TemplateStringsArray,\n ...params: WGSLSegment[]\n ): WGSLFunction => {\n return new WGSLFunction(prefix, code(strings, ...params));\n };\n}\n\nfunction token(prefix: string): WGSLToken {\n return new WGSLToken(prefix);\n}\n\nfunction param(description: string, defaultValue?: WGSLParamValue): WGSLParam {\n return new WGSLParam(description, defaultValue);\n}\n\nfunction constant(expr: WGSLSegment, description?: string): WGSLConstant {\n return new WGSLConstant(expr, description ?? 'constant');\n}\n\nfunction readonlyStorage(\n description: string,\n typeExpr: WGSLSegment,\n typeSchema: AlignedSchema,\n) {\n return new WGSLReadonlyStorage(description, typeExpr, typeSchema);\n}\n\nexport default Object.assign(code, {\n code,\n fn,\n token,\n param,\n constant,\n readonlyStorage,\n});\n","/**\n * @param value\n * @param modulo has to be power of 2\n */\nexport const roundUp = (value: number, modulo: number) => {\n const bitMask = modulo - 1;\n const invBitMask = ~bitMask;\n return (value & bitMask) === 0 ? value : (value & invBitMask) + modulo;\n};\n","/*\n * Typed-binary types that adhere to the `std140` layout rules.\n */\n\nimport {\n type IMeasurer,\n type IRefResolver,\n type ISchema,\n type ISerialInput,\n type ISerialOutput,\n type IUnstableSchema,\n MaxValue,\n Measurer,\n Schema,\n} from 'typed-binary';\nimport * as TB from 'typed-binary';\n\nexport class AlignedSchema extends Schema {\n private innerSchema: ISchema;\n private readonly bitMask: number;\n private readonly inverseBitMask: number;\n\n constructor(\n private readonly _innerUnstableSchema: IUnstableSchema,\n /**\n * Has to be power of 2\n */\n public readonly baseAlignment: number,\n ) {\n super();\n\n // In case this isn't part of a keyed chain,\n // let's assume the inner type is stable.\n this.innerSchema = _innerUnstableSchema as ISchema;\n\n this.bitMask = baseAlignment - 1;\n this.inverseBitMask = ~this.bitMask;\n }\n\n resolve(ctx: IRefResolver): void {\n this.innerSchema = ctx.resolve(this._innerUnstableSchema);\n }\n\n write(output: ISerialOutput, value: T): void {\n const offset = output.currentByteOffset & this.bitMask;\n output.skipBytes((this.baseAlignment - offset) & this.bitMask);\n\n this.innerSchema.write(output, value);\n }\n\n read(input: ISerialInput): T {\n const offset = input.currentByteOffset & this.bitMask;\n input.skipBytes((this.baseAlignment - offset) & this.bitMask);\n\n return this.innerSchema.read(input);\n }\n\n measure(\n value: T | MaxValue,\n measurer: IMeasurer = new Measurer(),\n ): IMeasurer {\n const offset = measurer.size & this.bitMask;\n measurer.add((this.baseAlignment - offset) & this.bitMask);\n\n this.innerSchema.measure(value, measurer);\n\n return measurer;\n }\n}\n\nexport const bool = new AlignedSchema(TB.bool, 4);\nexport const u32 = new AlignedSchema(TB.u32, 4);\nexport const f32 = new AlignedSchema(TB.f32, 4);\n\nexport const vec2u = new AlignedSchema(TB.tupleOf(TB.u32, 2), 8);\nexport const vec2i = new AlignedSchema(TB.tupleOf(TB.i32, 2), 8);\nexport const vec2f = new AlignedSchema(TB.tupleOf(TB.f32, 2), 8);\nexport const vec3u = new AlignedSchema(TB.tupleOf(TB.u32, 3), 16);\nexport const vec3i = new AlignedSchema(TB.tupleOf(TB.i32, 3), 16);\nexport const vec3f = new AlignedSchema(TB.tupleOf(TB.f32, 3), 16);\nexport const vec4u = new AlignedSchema(TB.tupleOf(TB.u32, 4), 16);\nexport const vec4i = new AlignedSchema(TB.tupleOf(TB.i32, 4), 16);\nexport const vec4f = new AlignedSchema(TB.tupleOf(TB.f32, 4), 16);\n\nexport const mat4f = new AlignedSchema(TB.tupleOf(TB.f32, 16), 16); // array of column vectors\n\ntype SchemaMap = { [key in keyof T]: AlignedSchema };\nexport const object = <\n P extends Record = Record,\n>(\n properties: SchemaMap

,\n) => {\n const maxBaseAlignment = Object.values(properties)\n .map((prop: AlignedSchema) => prop.baseAlignment)\n .reduce((a, b) => (a > b ? a : b));\n\n return new AlignedSchema(TB.object(properties), maxBaseAlignment);\n};\n\nexport const arrayOf = >(\n elementType: T,\n size: number,\n) => {\n return new AlignedSchema(\n TB.tupleOf(elementType, size),\n elementType.baseAlignment,\n );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA,cAAAA;AAAA,EAAA,WAAAC;AAAA,EAAA;AAAA,gBAAAC;AAAA,EAAA;AAAA,aAAAC;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA,0BAAuC;;;ACIhC,IAAM,UAAU,CAAC,OAAe,WAAmB;AACxD,QAAM,UAAU,SAAS;AACzB,QAAM,aAAa,CAAC;AACpB,UAAQ,QAAQ,aAAa,IAAI,SAAS,QAAQ,cAAc;AAClE;;;ADJO,IAAM,eAAN,MAAmB;AAAA,EAAnB;AACL,wBAAQ,gBAAe;AACvB,wBAAQ,SAAQ,oBAAI,QAA2B;AAAA;AAAA,EAE/C,QAAQC,QAAkB;AACxB,QAAI,OAAO,KAAK,MAAM,IAAIA,MAAK;AAC/B,QAAI,SAAS,QAAW;AACtB,aAAO,GAAGA,OAAM,aAAa,IAAI,KAAK,cAAc;AACpD,WAAK,MAAM,IAAIA,QAAO,IAAI;AAAA,IAC5B;AAEA,WAAO;AAAA,EACT;AACF;AAEO,IAAM,kBAAN,MAAsB;AAAA,EAAtB;AACL,wBAAO,QAAO;AACd,wBAAO,WAAyB,CAAC;AACjC,wBAAO,eAAc,IAAI,UAAU,kBAAkB;AACrD,wBAAQ,gBAAe,oBAAI,QAA6B;AAAA;AAAA,EAExD,SAAS,SAAsB;AAC7B,SAAK,QAAQ,KAAK,OAAO;AAEzB,SAAK,OAAO,QAAQ,KAAK,MAAM,QAAQ,aAAa;AACpD,SAAK,aAAa,IAAI,SAAS,KAAK,IAAI;AACxC,SAAK,QAAQ,QAAQ;AAAA,EACvB;AAAA,EAEA,YAAY,SAAsB;AAChC,WAAO,KAAK,aAAa,IAAI,OAAO;AAAA,EACtC;AACF;AAEO,IAAM,cAAN,MAAkB;AAAA,EAGvB,YACkB,QACA,OACAC,kBAChB;AAHgB;AACA;AACA,2BAAAA;AALlB,wBAAgB;AAOd,QAAIA,iBAAgB,OAAO,GAAG;AAC5B,WAAK,wBAAwB,OAAO,aAAa;AAAA,QAC/C,OAAO,eAAe,UAAU,eAAe;AAAA,QAC/C,MAAM,QAAQA,iBAAgB,MAAM,EAAE;AAAA,MACxC,CAAC;AAAA,IACH;AAAA,EACF;AAAA,EAEA,QAAQD,QAAkB;AACxB,WAAO,KAAK,MAAM,QAAQA,MAAK;AAAA,EACjC;AACF;AAUO,IAAM,gBAAN,MAA8C;AAAA,EAMnD,YACkB,OACAC,kBACA,eACC,OACjB;AAJgB;AACA,2BAAAA;AACA;AACC;AATnB,wBAAO,gBAA2B,CAAC;AACnC,wBAAO,iCAAgC;AAEvC,wBAAQ,mBAAkB,oBAAI,QAA0B;AAAA,EAOrD;AAAA,EAEH,cAAc,MAAgB;AAC5B,SAAK,QAAQ,IAAI;AACjB,cAAU,KAAK,cAAc,IAAI;AAAA,EACnC;AAAA,EAEA,IAAI,uBAAuB;AACzB,WAAO,KAAK,gBAAgB;AAAA,EAC9B;AAAA,EAEA,mBAAmB,SAA4B;AAC7C,SAAK,gBAAgB,SAAS,OAAO;AACrC,SAAK,gCAAgC,KAAK,aAAa;AAAA,EACzD;AAAA,EAEA,QAAQD,QAA0B;AAChC,WAAO,KAAK,MAAM,QAAQA,MAAK;AAAA,EACjC;AAAA,EAEA,QAAQ,MAAmB;AACzB,QAAI,OAAO,SAAS,UAAU;AAC5B,aAAO;AAAA,IACT;AAEA,QAAI,OAAO,SAAS,UAAU;AAC5B,aAAO,OAAO,IAAI;AAAA,IACpB;AAEA,UAAM,iBAAiB,KAAK,gBAAgB,IAAI,IAAI;AACpD,QAAI,mBAAmB,QAAW;AAChC,aAAO;AAAA,IACT;AAEA,UAAM,SAAS,KAAK,QAAQ,IAAI;AAChC,SAAK,gBAAgB,IAAI,MAAM,MAAM;AACrC,WAAO;AAAA,EACT;AACF;AAEA,IAAe,WAAf,MAAwB;AAAA;AAAA,EAEtB,YAAY,KAAiC;AAC3C,WAAO,CAAC;AAAA,EACV;AAGF;AAEO,IAAM,YAAN,cAAwB,SAAS;AAAA,EACtC,YAA4B,aAAqB;AAC/C,UAAM;AADoB;AAAA,EAE5B;AAAA,EAEA,IAAI,gBAAgB;AAClB,WAAO,KAAK,YAAY,WAAW,OAAO,GAAG;AAAA,EAC/C;AAAA,EAEA,QAAQ,KAA6B;AACnC,WAAO,IAAI,QAAQ,IAAI;AAAA,EACzB;AACF;AAGA,IAAM,YAAN,cAAwB,SAAS;AAAA,EAC/B,YACkB,aACA,cAChB;AACA,UAAM;AAHU;AACA;AAAA,EAGlB;AAAA,EAEA,QAAQ,KAA4B;AAtJtC;AAuJI,UAAM,CAAC,EAAE,QAAQ,KAAK,YAAY,KAChC,SAAI,cAAc,KAAK,CAAC,CAACE,MAAK,MAAMA,WAAU,IAAI,MAAlD,YAAuD,CAAC;AAC1D,QAAI,CAAC,OAAO;AACV,YAAM,IAAI,MAAM,kCAAkC,KAAK,WAAW,GAAG;AAAA,IACvE;AACA,WAAO,OAAO,KAAK;AAAA,EACrB;AACF;AAMA,IAAM,eAAN,cAA2B,SAAS;AAAA,EAGlC,YACmB,MACD,aAChB;AACA,UAAM;AAHW;AACD;AAJlB,wBAAO;AAOL,SAAK,QAAQ,IAAI,UAAU,YAAY,WAAW,OAAO,GAAG,CAAC;AAAA,EAC/D;AAAA,EAEA,QAAQ,KAA4B;AAClC,QAAI,cAAc,aAAa,KAAK,KAAK,MAAM,KAAK,IAAI,GAAG;AAE3D,WAAO,IAAI,QAAQ,KAAK,KAAK;AAAA,EAC/B;AACF;AASA,IAAM,sBAAN,cAAqC,SAAgC;AAAA,EAKnE,YACE,aACgB,UACC,YACjB;AACA,UAAM;AAHU;AACC;AAPnB,wBAAO;AACP,wBAAO;AACP,wBAAO;AASL,SAAK,YAAY,IAAI,UAAU,WAAW;AAC1C,SAAK,OAAO,KAAK,WAAW,QAAQ,4BAAQ,EAAE;AAC9C,SAAK,gBAAgB,KAAK,WAAW;AAAA,EACvC;AAAA,EAEA,MAAM,SAAsB,MAAS;AACnC,UAAM,YAAY,QAAQ;AAE1B,QAAI,CAAC,WAAW;AACd,cAAQ;AAAA,QACN;AAAA,MACF;AACA;AAAA,IACF;AAEA,UAAM,eAAe,QAAQ,gBAAgB,YAAY,IAAI;AAE7D,QAAI,iBAAiB,QAAW;AAC9B,cAAQ,KAAK,yDAAyD;AACtE;AAAA,IACF;AAEA,UAAM,aAAa,IAAI,YAAY,KAAK,IAAI;AAC5C,SAAK,WAAW,MAAM,IAAI,iCAAa,UAAU,GAAG,IAAI;AACxD,YAAQ,OAAO,MAAM;AAAA,MACnB;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,KAAK;AAAA,IACP;AAAA,EACF;AAAA,EAEA,QAAQ,KAA6B;AACnC,QAAI,mBAAmB,IAAI;AAC3B,QAAI,QAAQ,KAAK,QAAQ;AAEzB,WACE,IAAI,QAAQ,IAAI,oBAAoB,IAAI,MAAM,IAAI,QAAQ,KAAK,SAAS;AAAA,EAE5E;AACF;AAEA,IAAM,eAAN,cAA2B,SAAS;AAAA,EAGlC,YACE,QACiB,MACjB;AACA,UAAM;AAFW;AAJnB,wBAAQ;AAQN,SAAK,YAAY,IAAI,UAAU,MAAM;AAAA,EACvC;AAAA,EAEA,QAAQ,KAA4B;AAClC,QAAI,cAAc,UAAU,KAAK,SAAS,GAAG,KAAK,IAAI,EAAE;AAExD,WAAO,IAAI,QAAQ,KAAK,SAAS;AAAA,EACnC;AACF;AAEA,SAAS,UAAa,MAAW,OAAU;AACzC,MAAI,KAAK,SAAS,KAAK,GAAG;AACxB;AAAA,EACF;AAEA,OAAK,KAAK,KAAK;AACjB;AAEO,IAAM,WAAN,cAAuB,SAAS;AAAA,EACrC,YAA4B,UAAyB;AACnD,UAAM;AADoB;AAAA,EAE5B;AAAA,EAEA,cAA0B;AACxB,WAAO,KAAK,SAAS,OAAO,CAAC,MAAqB,OAAO,MAAM,QAAQ;AAAA,EACzE;AAAA,EAEA,QAAQ,KAAoB;AAC1B,QAAIC,QAAO;AAEX,eAAW,KAAK,KAAK,UAAU;AAC7B,cAAQ,MAAM;AAAA,QACZ,KAAK,aAAa;AAChB,UAAAA,SAAQ,IAAI,QAAQ,CAAC;AACrB;AAAA,QACF;AACE,UAAAA,SAAQ,OAAO,CAAC;AAAA,MACpB;AAAA,IACF;AAEA,WAAOA;AAAA,EACT;AACF;AAIA,SAAS,QAAW,OAAmC;AACrD,SAAO,UAAU;AACnB;AAEO,SAAS,eACd,QACA,MACA,SAKA;AAvTF;AAwTE,QAAM,QAAQ,IAAI,aAAa;AAC/B,QAAMF,mBAAkB,IAAI,gBAAgB;AAC5C,QAAM,MAAM,IAAI;AAAA,IACd;AAAA,IACAA;AAAA,KACA,aAAQ,WAAR,YAAkB,CAAC;AAAA,IACnB,QAAQ;AAAA,EACV;AAEA,QAAM,aAAa,IAAI,QAAQ,IAAI;AAEnC,QAAM,UAAU,IAAI,YAAY,QAAQ,OAAOA,gBAAe;AAE9D,QAAM,kBAAkB,OAAO,sBAAsB;AAAA,IACnD,SAAS;AAAA,MACP,QAAQ,wBACJ;AAAA,QACE,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,QACpB,QAAQ;AAAA,UACN,MAAM;AAAA,QACR;AAAA,MACF,IACA;AAAA,IACN,EAAE,OAAO,OAAO;AAAA,EAClB,CAAC;AAED,QAAM,YAAY,OAAO,gBAAgB;AAAA,IACvC,QAAQ;AAAA,IACR,SAAS;AAAA,MACP,QAAQ,wBACJ;AAAA,QACE,SAAS;AAAA,QACT,UAAU;AAAA,UACR,QAAQ,QAAQ;AAAA,QAClB;AAAA,MACF,IACA;AAAA,IACN,EAAE,OAAO,OAAO;AAAA,EAClB,CAAC;AAED,QAAM,kBAAkB,QAAQ,gBAAgB,QAAQ;AAAA,IACtD,CAAC,MAAM,OAAO,EAAE,SAAS,KAAK,EAAE,QAAQ;AAAA,EAC1C;AAEA,QAAM,mBAAmB,IAAI,UAAU,qBAAqB;AAE5D,QAAM,eAAe,IAAI,aAAa,MAAM;AAE5C,MAAI,gBAAgB,SAAS,GAAG;AAC9B,iBAAa;AAAA,MACX,IAAI;AAAA,MACJ;AAAA,MACA;AAAA,WACK,gBAAgB;AAAA,MACrB,eAAe;AAAA;AAAA;AAAA,WAGV,QAAQ,YAAY,oCAAoC,IAAI,oBAAoB,KAAK,gBAAgB;AAAA;AAAA,IAE5G;AAAA,EACF;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA,MACE,aAAa,IAAI,CAAC,MAAM,IAAI,QAAQ,CAAC,CAAC,EAAE,KAAK,IAAI,IAAI,OAAO;AAAA,EAChE;AACF;AAEO,SAAS,KACd,YACG,QACO;AACV,QAAM,WAA0B,QAAQ,QAAQ,CAAC,QAAQ,QAAQ;AAC/D,QAAI,OAAO,OAAO,QAAQ;AACxB,aAAO,CAAC,MAAM;AAAA,IAChB;AAEA,UAAMC,SAAQ,OAAO,GAAG;AACxB,WAAOA,kBAAiB,QAAQ,CAAC,QAAQ,GAAGA,MAAK,IAAI,CAAC,QAAQA,MAAK;AAAA,EACrE,CAAC;AAED,SAAO,IAAI,SAAS,QAAQ;AAC9B;AAEA,SAAS,GAAG,SAAiB,YAAY;AACvC,SAAO,CACL,YACG,WACc;AACjB,WAAO,IAAI,aAAa,QAAQ,KAAK,SAAS,GAAG,MAAM,CAAC;AAAA,EAC1D;AACF;AAEA,SAAS,MAAM,QAA2B;AACxC,SAAO,IAAI,UAAU,MAAM;AAC7B;AAEA,SAAS,MAAM,aAAqB,cAA0C;AAC5E,SAAO,IAAI,UAAU,aAAa,YAAY;AAChD;AAEA,SAAS,SAAS,MAAmB,aAAoC;AACvE,SAAO,IAAI,aAAa,MAAM,oCAAe,UAAU;AACzD;AAEA,SAAS,gBACP,aACA,UACA,YACA;AACA,SAAO,IAAI,oBAAoB,aAAa,UAAU,UAAU;AAClE;AAEA,IAAO,eAAQ,OAAO,OAAO,MAAM;AAAA,EACjC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;;;AEhbD,IAAAE,uBAUO;AACP,SAAoB;AAEb,IAAM,gBAAN,cAA+B,4BAAU;AAAA,EAK9C,YACmB,sBAID,eAChB;AACA,UAAM;AANW;AAID;AATlB,wBAAQ;AACR,wBAAiB;AACjB,wBAAiB;AAaf,SAAK,cAAc;AAEnB,SAAK,UAAU,gBAAgB;AAC/B,SAAK,iBAAiB,CAAC,KAAK;AAAA,EAC9B;AAAA,EAEA,QAAQ,KAAyB;AAC/B,SAAK,cAAc,IAAI,QAAQ,KAAK,oBAAoB;AAAA,EAC1D;AAAA,EAEA,MAAM,QAAuB,OAAgB;AAC3C,UAAM,SAAS,OAAO,oBAAoB,KAAK;AAC/C,WAAO,UAAW,KAAK,gBAAgB,SAAU,KAAK,OAAO;AAE7D,SAAK,YAAY,MAAM,QAAQ,KAAK;AAAA,EACtC;AAAA,EAEA,KAAK,OAAwB;AAC3B,UAAM,SAAS,MAAM,oBAAoB,KAAK;AAC9C,UAAM,UAAW,KAAK,gBAAgB,SAAU,KAAK,OAAO;AAE5D,WAAO,KAAK,YAAY,KAAK,KAAK;AAAA,EACpC;AAAA,EAEA,QACE,OACA,WAAsB,IAAI,8BAAS,GACxB;AACX,UAAM,SAAS,SAAS,OAAO,KAAK;AACpC,aAAS,IAAK,KAAK,gBAAgB,SAAU,KAAK,OAAO;AAEzD,SAAK,YAAY,QAAQ,OAAO,QAAQ;AAExC,WAAO;AAAA,EACT;AACF;AAEO,IAAMC,QAAO,IAAI,cAAiB,SAAM,CAAC;AACzC,IAAMC,OAAM,IAAI,cAAiB,QAAK,CAAC;AACvC,IAAMC,OAAM,IAAI,cAAiB,QAAK,CAAC;AAEvC,IAAM,QAAQ,IAAI,cAAiB,WAAW,QAAK,CAAC,GAAG,CAAC;AACxD,IAAM,QAAQ,IAAI,cAAiB,WAAW,QAAK,CAAC,GAAG,CAAC;AACxD,IAAM,QAAQ,IAAI,cAAiB,WAAW,QAAK,CAAC,GAAG,CAAC;AACxD,IAAM,QAAQ,IAAI,cAAiB,WAAW,QAAK,CAAC,GAAG,EAAE;AACzD,IAAM,QAAQ,IAAI,cAAiB,WAAW,QAAK,CAAC,GAAG,EAAE;AACzD,IAAM,QAAQ,IAAI,cAAiB,WAAW,QAAK,CAAC,GAAG,EAAE;AACzD,IAAM,QAAQ,IAAI,cAAiB,WAAW,QAAK,CAAC,GAAG,EAAE;AACzD,IAAM,QAAQ,IAAI,cAAiB,WAAW,QAAK,CAAC,GAAG,EAAE;AACzD,IAAM,QAAQ,IAAI,cAAiB,WAAW,QAAK,CAAC,GAAG,EAAE;AAEzD,IAAM,QAAQ,IAAI,cAAiB,WAAW,QAAK,EAAE,GAAG,EAAE;AAG1D,IAAMC,UAAS,CAGpB,eACG;AACH,QAAM,mBAAmB,OAAO,OAAO,UAAU,EAC9C,IAAI,CAAC,SAAiC,KAAK,aAAa,EACxD,OAAO,CAAC,GAAG,MAAO,IAAI,IAAI,IAAI,CAAE;AAEnC,SAAO,IAAI,cAAiB,UAAO,UAAU,GAAG,gBAAgB;AAClE;AAEO,IAAM,UAAU,CACrB,aACA,SACG;AACH,SAAO,IAAI;AAAA,IACN,WAAQ,aAAa,IAAI;AAAA,IAC5B,YAAY;AAAA,EACd;AACF;","names":["bool","f32","object","u32","token","readonlyStorage","param","code","import_typed_binary","bool","u32","f32","object"]}