{"mappings":"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","names":["idl_exports","__export","Bool","BoolClass","ConstructType","Empty","EmptyClass","FixedIntClass","FixedNatClass","Float32","Float64","FloatClass","Func","FuncClass","Int","Int16","Int32","Int64","Int8","IntClass","Nat","Nat16","Nat32","Nat64","Nat8","NatClass","Null","NullClass","Opt","OptClass","PrimitiveType","Principal","PrincipalClass","Rec","RecClass","Record","RecordClass","Reserved","ReservedClass","Service","ServiceClass","Text","TextClass","Tuple","TupleClass","Type","Unknown","UnknownClass","Variant","VariantClass","Vec","VecClass","Visitor","decode","encode","PrincipalId","concat","buffers","result","acc","curr","index","b","toHexString","bytes","str","byte","fromHexString","hexString","_a","PipeArrayBuffer","buffer","length","bufFromBufLike","num","buf","offset","amount","v","uint8ToBuf","arr","bufLike","idlHash","s","array","h","c","idlLabelToId","label","num","eob","safeRead","pipe","num","safeReadUint8","byte","lebEncode","value","byteLength","PipeArrayBuffer","i","lebDecode","weight","slebEncode","isNeg","getLowerBytes","bytes","slebDecode","pipeView","len","writeUIntLE","writeIntLE","mul","sub","readUIntLE","val","readIntLE","iexp2","nBig","magicNumber","toReadableString_max","zipWith","xs","ys","f","x","TypeTable","obj","type","buf","idx","knot","knotIdx","len","lebEncode","concat","typeName","slebEncode","Visitor","t","data","ty","fields","components","i","Type","toReadableString","typeTable","PrimitiveType","ConstructType","RecClass","EmptyClass","v","d","UnknownClass","b","decodedValue","typeFunc","BoolClass","safeReadUint8","NullClass","ReservedClass","TextClass","lebDecode","safeRead","IntClass","slebDecode","NatClass","FloatClass","_bits","view","opcode","bytes","FixedIntClass","min","iexp2","max","ok","writeIntLE","offset","num","readIntLE","FixedNatClass","writeUIntLE","readUIntLE","VecClass","_VecClass","_type","bits","e","PipeArrayBuffer","encoded","opCode","buffer","vec","rets","OptClass","_OptClass","opt","RecordClass","_RecordClass","a","idlLabelToId","res","key","k","values","bufs","c","T","_","value","record","expectedRecordIdx","actualRecordIdx","hash","expectKey","expectType","expectedId","actualId","TupleClass","_TupleClass","_components","tuple","wireType","VariantClass","_VariantClass","name","variant","wireHash","_RecClass","decodePrincipalId","PrincipalId","PrincipalClass","FuncClass","argTypes","retTypes","annotations","types","principal","methodName","canister","method","methodLen","arg","argLen","args","retLen","annLen","anns","mLen","annon","str","ann","ServiceClass","func","meths","label","labelBuf","labelLen","_key","encode","magic","table","typs","vals","decode","magicBuffer","readTypeTable","pipe","objectLength","prevHash","argLength","returnValues","returnValuesLength","annotationLength","servLength","methods","nameLength","funcName","funcType","rawList","length","rawTable","rawTypes","Rec","getType","Null","Bool","Nat","Int","Nat8","Nat16","Nat32","Nat64","Int8","Int16","Int32","Int64","Float32","Float64","Text","Reserved","Empty","Principal","buildType","entry","Vec","Opt","Record","Tuple","Variant","Func","rec","typeRef","Service","output","ind","Unknown","ret","Principal","InputBox","idl","ui","status","config","value","input","err","dom","container","label","InputForm","e","form","oldContainer","RecordForm","fields","key","type","v","_","i","TupleForm","components","VariantForm","index","variant","select","selected","OptionForm","ty","opt","VecForm","len","t","InputConfig","parsePrimitive","FormConfig","renderInput","inputBox","t","config","InputBox","recordForm","fields","RecordForm","tupleForm","components","TupleForm","variantForm","VariantForm","optForm","ty","OptionForm","vecForm","VecForm","Render","Visitor","d","input","container","form","select","key","type","option","checkbox","len","Parse","v","Principal","x","Random","signed","num","renderValue","value","RenderValue","open","i","selected"],"sources":["../esm/npm/@dfinity/candid@1.4.0/node_modules/@dfinity/candid/src/idl.ts","../esm/npm/@dfinity/candid@1.4.0/node_modules/@dfinity/candid/src/utils/buffer.ts","../esm/npm/@dfinity/candid@1.4.0/node_modules/@dfinity/candid/src/utils/hash.ts","../esm/npm/@dfinity/candid@1.4.0/node_modules/@dfinity/candid/src/utils/leb128.ts","../esm/npm/@dfinity/candid@1.4.0/node_modules/@dfinity/candid/src/utils/bigint-math.ts","../esm/npm/@dfinity/candid@1.4.0/node_modules/@dfinity/candid/src/candid-ui.ts","../esm/npm/@dfinity/candid@1.4.0/node_modules/@dfinity/candid/src/candid-core.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-unused-vars */\n/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Principal as PrincipalId } from '@dfinity/principal';\nimport { JsonValue } from './types';\nimport { concat, PipeArrayBuffer as Pipe } from './utils/buffer';\nimport { idlLabelToId } from './utils/hash';\nimport {\n  lebDecode,\n  lebEncode,\n  readIntLE,\n  readUIntLE,\n  safeRead,\n  safeReadUint8,\n  slebDecode,\n  slebEncode,\n  writeIntLE,\n  writeUIntLE,\n} from './utils/leb128';\nimport { iexp2 } from './utils/bigint-math';\n\n/**\n * This module provides a combinator library to create serializers/deserializers\n * between JavaScript values and IDL used by canisters on the Internet Computer,\n * as documented at https://github.com/dfinity/candid/blob/119703ba342d2fef6ab4972d2541b9fe36ae8e36/spec/Candid.md\n */\n\nconst enum IDLTypeIds {\n  Null = -1,\n  Bool = -2,\n  Nat = -3,\n  Int = -4,\n  Float32 = -13,\n  Float64 = -14,\n  Text = -15,\n  Reserved = -16,\n  Empty = -17,\n  Opt = -18,\n  Vector = -19,\n  Record = -20,\n  Variant = -21,\n  Func = -22,\n  Service = -23,\n  Principal = -24,\n}\n\nconst magicNumber = 'DIDL';\nconst toReadableString_max = 400; // will not display arguments after 400chars. Makes sure 2mb blobs don't get inside the error\n\nfunction zipWith\u003cTX, TY, TR\u003e(xs: TX[], ys: TY[], f: (a: TX, b: TY) =\u003e TR): TR[] {\n  return xs.map((x, i) =\u003e f(x, ys[i]));\n}\n\n/**\n * An IDL Type Table, which precedes the data in the stream.\n */\nclass TypeTable {\n  // List of types. Needs to be an array as the index needs to be stable.\n  private _typs: ArrayBuffer[] = [];\n  private _idx = new Map\u003cstring, number\u003e();\n\n  public has(obj: ConstructType) {\n    return this._idx.has(obj.name);\n  }\n\n  public add\u003cT\u003e(type: ConstructType\u003cT\u003e, buf: ArrayBuffer) {\n    const idx = this._typs.length;\n    this._idx.set(type.name, idx);\n    this._typs.push(buf);\n  }\n\n  public merge\u003cT\u003e(obj: ConstructType\u003cT\u003e, knot: string) {\n    const idx = this._idx.get(obj.name);\n    const knotIdx = this._idx.get(knot);\n    if (idx === undefined) {\n      throw new Error('Missing type index for ' + obj);\n    }\n    if (knotIdx === undefined) {\n      throw new Error('Missing type index for ' + knot);\n    }\n    this._typs[idx] = this._typs[knotIdx];\n\n    // Delete the type.\n    this._typs.splice(knotIdx, 1);\n    this._idx.delete(knot);\n  }\n\n  public encode() {\n    const len = lebEncode(this._typs.length);\n    const buf = concat(...this._typs);\n    return concat(len, buf);\n  }\n\n  public indexOf(typeName: string) {\n    if (!this._idx.has(typeName)) {\n      throw new Error('Missing type index for ' + typeName);\n    }\n    return slebEncode(this._idx.get(typeName) || 0);\n  }\n}\n\nexport abstract class Visitor\u003cD, R\u003e {\n  public visitType\u003cT\u003e(t: Type\u003cT\u003e, data: D): R {\n    throw new Error('Not implemented');\n  }\n  public visitPrimitive\u003cT\u003e(t: PrimitiveType\u003cT\u003e, data: D): R {\n    return this.visitType(t, data);\n  }\n  public visitEmpty(t: EmptyClass, data: D): R {\n    return this.visitPrimitive(t, data);\n  }\n  public visitBool(t: BoolClass, data: D): R {\n    return this.visitPrimitive(t, data);\n  }\n  public visitNull(t: NullClass, data: D): R {\n    return this.visitPrimitive(t, data);\n  }\n  public visitReserved(t: ReservedClass, data: D): R {\n    return this.visitPrimitive(t, data);\n  }\n  public visitText(t: TextClass, data: D): R {\n    return this.visitPrimitive(t, data);\n  }\n  public visitNumber\u003cT\u003e(t: PrimitiveType\u003cT\u003e, data: D): R {\n    return this.visitPrimitive(t, data);\n  }\n  public visitInt(t: IntClass, data: D): R {\n    return this.visitNumber(t, data);\n  }\n  public visitNat(t: NatClass, data: D): R {\n    return this.visitNumber(t, data);\n  }\n  public visitFloat(t: FloatClass, data: D): R {\n    return this.visitPrimitive(t, data);\n  }\n  public visitFixedInt(t: FixedIntClass, data: D): R {\n    return this.visitNumber(t, data);\n  }\n  public visitFixedNat(t: FixedNatClass, data: D): R {\n    return this.visitNumber(t, data);\n  }\n  public visitPrincipal(t: PrincipalClass, data: D): R {\n    return this.visitPrimitive(t, data);\n  }\n\n  public visitConstruct\u003cT\u003e(t: ConstructType\u003cT\u003e, data: D): R {\n    return this.visitType(t, data);\n  }\n  public visitVec\u003cT\u003e(t: VecClass\u003cT\u003e, ty: Type\u003cT\u003e, data: D): R {\n    return this.visitConstruct(t, data);\n  }\n  public visitOpt\u003cT\u003e(t: OptClass\u003cT\u003e, ty: Type\u003cT\u003e, data: D): R {\n    return this.visitConstruct(t, data);\n  }\n  public visitRecord(t: RecordClass, fields: Array\u003c[string, Type]\u003e, data: D): R {\n    return this.visitConstruct(t, data);\n  }\n  public visitTuple\u003cT extends any[]\u003e(t: TupleClass\u003cT\u003e, components: Type[], data: D): R {\n    const fields: Array\u003c[string, Type]\u003e = components.map((ty, i) =\u003e [`_${i}_`, ty]);\n    return this.visitRecord(t, fields, data);\n  }\n  public visitVariant(t: VariantClass, fields: Array\u003c[string, Type]\u003e, data: D): R {\n    return this.visitConstruct(t, data);\n  }\n  public visitRec\u003cT\u003e(t: RecClass\u003cT\u003e, ty: ConstructType\u003cT\u003e, data: D): R {\n    return this.visitConstruct(ty, data);\n  }\n  public visitFunc(t: FuncClass, data: D): R {\n    return this.visitConstruct(t, data);\n  }\n  public visitService(t: ServiceClass, data: D): R {\n    return this.visitConstruct(t, data);\n  }\n}\n\n/**\n * Represents an IDL type.\n */\nexport abstract class Type\u003cT = any\u003e {\n  public abstract readonly name: string;\n  public abstract accept\u003cD, R\u003e(v: Visitor\u003cD, R\u003e, d: D): R;\n\n  /* Display type name */\n  public display(): string {\n    return this.name;\n  }\n\n  public valueToString(x: T): string {\n    return toReadableString(x);\n  }\n\n  /* Implement `T` in the IDL spec, only needed for non-primitive types */\n  public buildTypeTable(typeTable: TypeTable): void {\n    if (!typeTable.has(this)) {\n      this._buildTypeTableImpl(typeTable);\n    }\n  }\n\n  /**\n   * Assert that JavaScript's `x` is the proper type represented by this\n   * Type.\n   */\n  public abstract covariant(x: any): x is T;\n\n  /**\n   * Encode the value. This needs to be public because it is used by\n   * encodeValue() from different types.\n   * @internal\n   */\n  public abstract encodeValue(x: T): ArrayBuffer;\n\n  /**\n   * Implement `I` in the IDL spec.\n   * Encode this type for the type table.\n   */\n  public abstract encodeType(typeTable: TypeTable): ArrayBuffer;\n\n  public abstract checkType(t: Type): Type;\n  public abstract decodeValue(x: Pipe, t: Type): T;\n\n  protected abstract _buildTypeTableImpl(typeTable: TypeTable): void;\n}\n\nexport abstract class PrimitiveType\u003cT = any\u003e extends Type\u003cT\u003e {\n  public checkType(t: Type): Type {\n    if (this.name !== t.name) {\n      throw new Error(`type mismatch: type on the wire ${t.name}, expect type ${this.name}`);\n    }\n    return t;\n  }\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  public _buildTypeTableImpl(typeTable: TypeTable): void {\n    // No type table encoding for Primitive types.\n    return;\n  }\n}\n\nexport abstract class ConstructType\u003cT = any\u003e extends Type\u003cT\u003e {\n  public checkType(t: Type): ConstructType\u003cT\u003e {\n    if (t instanceof RecClass) {\n      const ty = t.getType();\n      if (typeof ty === 'undefined') {\n        throw new Error('type mismatch with uninitialized type');\n      }\n      return ty;\n    }\n    throw new Error(`type mismatch: type on the wire ${t.name}, expect type ${this.name}`);\n  }\n  public encodeType(typeTable: TypeTable) {\n    return typeTable.indexOf(this.name);\n  }\n}\n\n/**\n * Represents an IDL Empty, a type which has no inhabitants.\n * Since no values exist for this type, it cannot be serialised or deserialised.\n * Result types like `Result\u003cText, Empty\u003e` should always succeed.\n */\nexport class EmptyClass extends PrimitiveType\u003cnever\u003e {\n  public accept\u003cD, R\u003e(v: Visitor\u003cD, R\u003e, d: D): R {\n    return v.visitEmpty(this, d);\n  }\n\n  public covariant(x: any): x is never {\n    throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);\n  }\n\n  public encodeValue(): never {\n    throw new Error('Empty cannot appear as a function argument');\n  }\n\n  public valueToString(): never {\n    throw new Error('Empty cannot appear as a value');\n  }\n\n  public encodeType() {\n    return slebEncode(IDLTypeIds.Empty);\n  }\n\n  public decodeValue(): never {\n    throw new Error('Empty cannot appear as an output');\n  }\n\n  get name() {\n    return 'empty';\n  }\n}\n\n/**\n * Represents an IDL Unknown, a placeholder type for deserialization only.\n * When decoding a value as Unknown, all fields will be retained but the names are only available in\n * hashed form.\n * A deserialized unknown will offer it's actual type by calling the `type()` function.\n * Unknown cannot be serialized and attempting to do so will throw an error.\n */\nexport class UnknownClass extends Type {\n  public checkType(t: Type): Type {\n    throw new Error('Method not implemented for unknown.');\n  }\n\n  public accept\u003cD, R\u003e(v: Visitor\u003cD, R\u003e, d: D): R {\n    throw v.visitType(this, d);\n  }\n\n  public covariant(x: any): x is any {\n    throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);\n  }\n\n  public encodeValue(): never {\n    throw new Error('Unknown cannot appear as a function argument');\n  }\n\n  public valueToString(): never {\n    throw new Error('Unknown cannot appear as a value');\n  }\n\n  public encodeType(): never {\n    throw new Error('Unknown cannot be serialized');\n  }\n\n  public decodeValue(b: Pipe, t: Type): any {\n    let decodedValue = t.decodeValue(b, t);\n\n    if (Object(decodedValue) !== decodedValue) {\n      // decodedValue is primitive. Box it, otherwise we cannot add the type() function.\n      // The type() function is important for primitives because otherwise we cannot tell apart the\n      // different number types.\n      decodedValue = Object(decodedValue);\n    }\n\n    let typeFunc;\n    if (t instanceof RecClass) {\n      typeFunc = () =\u003e t.getType();\n    } else {\n      typeFunc = () =\u003e t;\n    }\n    // Do not use 'decodedValue.type = typeFunc' because this would lead to an enumerable property\n    // 'type' which means it would be serialized if the value would be candid encoded again.\n    // This in turn leads to problems if the decoded value is a variant because these values are\n    // only allowed to have a single property.\n    Object.defineProperty(decodedValue, 'type', {\n      value: typeFunc,\n      writable: true,\n      enumerable: false,\n      configurable: true,\n    });\n    return decodedValue;\n  }\n\n  protected _buildTypeTableImpl(): void {\n    throw new Error('Unknown cannot be serialized');\n  }\n\n  get name() {\n    return 'Unknown';\n  }\n}\n\n/**\n * Represents an IDL Bool\n */\nexport class BoolClass extends PrimitiveType\u003cboolean\u003e {\n  public accept\u003cD, R\u003e(v: Visitor\u003cD, R\u003e, d: D): R {\n    return v.visitBool(this, d);\n  }\n\n  public covariant(x: any): x is boolean {\n    if (typeof x === 'boolean') return true;\n    throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);\n  }\n\n  public encodeValue(x: boolean): ArrayBuffer {\n    return new Uint8Array([x ? 1 : 0]);\n  }\n\n  public encodeType() {\n    return slebEncode(IDLTypeIds.Bool);\n  }\n\n  public decodeValue(b: Pipe, t: Type) {\n    this.checkType(t);\n    switch (safeReadUint8(b)) {\n      case 0:\n        return false;\n      case 1:\n        return true;\n      default:\n        throw new Error('Boolean value out of range');\n    }\n  }\n\n  get name() {\n    return 'bool';\n  }\n}\n\n/**\n * Represents an IDL Null\n */\nexport class NullClass extends PrimitiveType\u003cnull\u003e {\n  public accept\u003cD, R\u003e(v: Visitor\u003cD, R\u003e, d: D): R {\n    return v.visitNull(this, d);\n  }\n\n  public covariant(x: any): x is null {\n    if (x === null) return true;\n    throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);\n  }\n\n  public encodeValue() {\n    return new ArrayBuffer(0);\n  }\n\n  public encodeType() {\n    return slebEncode(IDLTypeIds.Null);\n  }\n\n  public decodeValue(b: Pipe, t: Type) {\n    this.checkType(t);\n    return null;\n  }\n\n  get name() {\n    return 'null';\n  }\n}\n\n/**\n * Represents an IDL Reserved\n */\nexport class ReservedClass extends PrimitiveType\u003cany\u003e {\n  public accept\u003cD, R\u003e(v: Visitor\u003cD, R\u003e, d: D): R {\n    return v.visitReserved(this, d);\n  }\n\n  public covariant(x: any): x is any {\n    return true;\n  }\n\n  public encodeValue() {\n    return new ArrayBuffer(0);\n  }\n\n  public encodeType() {\n    return slebEncode(IDLTypeIds.Reserved);\n  }\n\n  public decodeValue(b: Pipe, t: Type) {\n    if (t.name !== this.name) {\n      t.decodeValue(b, t);\n    }\n    return null;\n  }\n\n  get name() {\n    return 'reserved';\n  }\n}\n\n/**\n * Represents an IDL Text\n */\nexport class TextClass extends PrimitiveType\u003cstring\u003e {\n  public accept\u003cD, R\u003e(v: Visitor\u003cD, R\u003e, d: D): R {\n    return v.visitText(this, d);\n  }\n\n  public covariant(x: any): x is string {\n    if (typeof x === 'string') return true;\n    throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);\n  }\n\n  public encodeValue(x: string) {\n    const buf = new TextEncoder().encode(x);\n    const len = lebEncode(buf.byteLength);\n    return concat(len, buf);\n  }\n\n  public encodeType() {\n    return slebEncode(IDLTypeIds.Text);\n  }\n\n  public decodeValue(b: Pipe, t: Type) {\n    this.checkType(t);\n    const len = lebDecode(b);\n    const buf = safeRead(b, Number(len));\n    const decoder = new TextDecoder('utf8', { fatal: true });\n    return decoder.decode(buf);\n  }\n\n  get name() {\n    return 'text';\n  }\n\n  public valueToString(x: string) {\n    return '\"' + x + '\"';\n  }\n}\n\n/**\n * Represents an IDL Int\n */\nexport class IntClass extends PrimitiveType\u003cbigint\u003e {\n  public accept\u003cD, R\u003e(v: Visitor\u003cD, R\u003e, d: D): R {\n    return v.visitInt(this, d);\n  }\n\n  public covariant(x: any): x is bigint {\n    // We allow encoding of JavaScript plain numbers.\n    // But we will always decode to bigint.\n    if (typeof x === 'bigint' || Number.isInteger(x)) return true;\n    throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);\n  }\n\n  public encodeValue(x: bigint | number) {\n    return slebEncode(x);\n  }\n\n  public encodeType() {\n    return slebEncode(IDLTypeIds.Int);\n  }\n\n  public decodeValue(b: Pipe, t: Type) {\n    this.checkType(t);\n    return slebDecode(b);\n  }\n\n  get name() {\n    return 'int';\n  }\n\n  public valueToString(x: bigint) {\n    return x.toString();\n  }\n}\n\n/**\n * Represents an IDL Nat\n */\nexport class NatClass extends PrimitiveType\u003cbigint\u003e {\n  public accept\u003cD, R\u003e(v: Visitor\u003cD, R\u003e, d: D): R {\n    return v.visitNat(this, d);\n  }\n\n  public covariant(x: any): x is bigint {\n    // We allow encoding of JavaScript plain numbers.\n    // But we will always decode to bigint.\n    if ((typeof x === 'bigint' \u0026\u0026 x \u003e= BigInt(0)) || (Number.isInteger(x) \u0026\u0026 x \u003e= 0)) return true;\n    throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);\n  }\n\n  public encodeValue(x: bigint | number) {\n    return lebEncode(x);\n  }\n\n  public encodeType() {\n    return slebEncode(IDLTypeIds.Nat);\n  }\n\n  public decodeValue(b: Pipe, t: Type) {\n    this.checkType(t);\n    return lebDecode(b);\n  }\n\n  get name() {\n    return 'nat';\n  }\n\n  public valueToString(x: bigint) {\n    return x.toString();\n  }\n}\n\n/**\n * Represents an IDL Float\n */\nexport class FloatClass extends PrimitiveType\u003cnumber\u003e {\n  constructor(private _bits: number) {\n    super();\n    if (_bits !== 32 \u0026\u0026 _bits !== 64) {\n      throw new Error('not a valid float type');\n    }\n  }\n  public accept\u003cD, R\u003e(v: Visitor\u003cD, R\u003e, d: D): R {\n    return v.visitFloat(this, d);\n  }\n\n  public covariant(x: any): x is number {\n    if (typeof x === 'number' || x instanceof Number) return true;\n    throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);\n  }\n\n  public encodeValue(x: number) {\n    const buf = new ArrayBuffer(this._bits / 8);\n    const view = new DataView(buf);\n    if (this._bits === 32) {\n      view.setFloat32(0, x, true);\n    } else {\n      view.setFloat64(0, x, true);\n    }\n    return buf;\n  }\n\n  public encodeType() {\n    const opcode = this._bits === 32 ? IDLTypeIds.Float32 : IDLTypeIds.Float64;\n    return slebEncode(opcode);\n  }\n\n  public decodeValue(b: Pipe, t: Type) {\n    this.checkType(t);\n    const bytes = safeRead(b, this._bits / 8);\n    const view = new DataView(bytes);\n    if (this._bits === 32) {\n      return view.getFloat32(0, true);\n    } else {\n      return view.getFloat64(0, true);\n    }\n  }\n\n  get name() {\n    return 'float' + this._bits;\n  }\n\n  public valueToString(x: number) {\n    return x.toString();\n  }\n}\n\n/**\n * Represents an IDL fixed-width Int(n)\n */\nexport class FixedIntClass extends PrimitiveType\u003cbigint | number\u003e {\n  constructor(public readonly _bits: number) {\n    super();\n  }\n\n  public accept\u003cD, R\u003e(v: Visitor\u003cD, R\u003e, d: D): R {\n    return v.visitFixedInt(this, d);\n  }\n\n  public covariant(x: any): x is bigint {\n    const min = iexp2(this._bits - 1) * BigInt(-1);\n    const max = iexp2(this._bits - 1) - BigInt(1);\n    let ok = false;\n    if (typeof x === 'bigint') {\n      ok = x \u003e= min \u0026\u0026 x \u003c= max;\n    } else if (Number.isInteger(x)) {\n      const v = BigInt(x);\n      ok = v \u003e= min \u0026\u0026 v \u003c= max;\n    } else {\n      ok = false;\n    }\n\n    if (ok) return true;\n    throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);\n  }\n\n  public encodeValue(x: bigint | number) {\n    return writeIntLE(x, this._bits / 8);\n  }\n\n  public encodeType() {\n    const offset = Math.log2(this._bits) - 3;\n    return slebEncode(-9 - offset);\n  }\n\n  public decodeValue(b: Pipe, t: Type) {\n    this.checkType(t);\n    const num = readIntLE(b, this._bits / 8);\n    if (this._bits \u003c= 32) {\n      return Number(num);\n    } else {\n      return num;\n    }\n  }\n\n  get name() {\n    return `int${this._bits}`;\n  }\n\n  public valueToString(x: bigint | number) {\n    return x.toString();\n  }\n}\n\n/**\n * Represents an IDL fixed-width Nat(n)\n */\nexport class FixedNatClass extends PrimitiveType\u003cbigint | number\u003e {\n  constructor(public readonly _bits: number) {\n    super();\n  }\n\n  public accept\u003cD, R\u003e(v: Visitor\u003cD, R\u003e, d: D): R {\n    return v.visitFixedNat(this, d);\n  }\n\n  public covariant(x: any): x is bigint {\n    const max = iexp2(this._bits);\n    let ok = false;\n    if (typeof x === 'bigint' \u0026\u0026 x \u003e= BigInt(0)) {\n      ok = x \u003c max;\n    } else if (Number.isInteger(x) \u0026\u0026 x \u003e= 0) {\n      const v = BigInt(x);\n      ok = v \u003c max;\n    } else {\n      ok = false;\n    }\n    if (ok) return true;\n    throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);\n  }\n\n  public encodeValue(x: bigint | number) {\n    return writeUIntLE(x, this._bits / 8);\n  }\n\n  public encodeType() {\n    const offset = Math.log2(this._bits) - 3;\n    return slebEncode(-5 - offset);\n  }\n\n  public decodeValue(b: Pipe, t: Type) {\n    this.checkType(t);\n    const num = readUIntLE(b, this._bits / 8);\n    if (this._bits \u003c= 32) {\n      return Number(num);\n    } else {\n      return num;\n    }\n  }\n\n  get name() {\n    return `nat${this._bits}`;\n  }\n\n  public valueToString(x: bigint | number) {\n    return x.toString();\n  }\n}\n\n/**\n * Represents an IDL Array\n *\n * Arrays of fixed-sized nat/int type (e.g. nat8), are encoded from and decoded to TypedArrays (e.g. Uint8Array).\n * Arrays of float or other non-primitive types are encoded/decoded as untyped array in Javascript.\n * @param {Type} t\n */\nexport class VecClass\u003cT\u003e extends ConstructType\u003cT[]\u003e {\n  // If true, this vector is really a blob and we can just use memcpy.\n  //\n  // NOTE:\n  // With support of encoding/dencoding of TypedArrays, this optimization is\n  // only used when plain array of bytes are passed as encoding input in order\n  // to be backward compatible.\n  private _blobOptimization = false;\n\n  constructor(protected _type: Type\u003cT\u003e) {\n    super();\n    if (_type instanceof FixedNatClass \u0026\u0026 _type._bits === 8) {\n      this._blobOptimization = true;\n    }\n  }\n\n  public accept\u003cD, R\u003e(v: Visitor\u003cD, R\u003e, d: D): R {\n    return v.visitVec(this, this._type, d);\n  }\n\n  public covariant(x: any): x is T[] {\n    // Special case for ArrayBuffer\n    const bits =\n      this._type instanceof FixedNatClass\n        ? this._type._bits\n        : this._type instanceof FixedIntClass\n        ? this._type._bits\n        : 0;\n\n    if (\n      (ArrayBuffer.isView(x) \u0026\u0026 bits == (x as any).BYTES_PER_ELEMENT * 8) ||\n      (Array.isArray(x) \u0026\u0026\n        x.every((v, idx) =\u003e {\n          try {\n            return this._type.covariant(v);\n          } catch (e: any) {\n            throw new Error(`Invalid ${this.display()} argument: \\n\\nindex ${idx} -\u003e ${e.message}`);\n          }\n        }))\n    )\n      return true;\n\n    throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);\n  }\n\n  public encodeValue(x: T[]) {\n    const len = lebEncode(x.length);\n    if (this._blobOptimization) {\n      return concat(len, new Uint8Array(x as unknown as number[]));\n    }\n    if (ArrayBuffer.isView(x)) {\n      return concat(len, new Uint8Array(x.buffer));\n    }\n    const buf = new Pipe(new ArrayBuffer(len.byteLength + x.length), 0);\n    buf.write(len);\n    for (const d of x) {\n      const encoded = this._type.encodeValue(d);\n      buf.write(new Uint8Array(encoded));\n    }\n    return buf.buffer;\n  }\n\n  public _buildTypeTableImpl(typeTable: TypeTable) {\n    this._type.buildTypeTable(typeTable);\n\n    const opCode = slebEncode(IDLTypeIds.Vector);\n    const buffer = this._type.encodeType(typeTable);\n    typeTable.add(this, concat(opCode, buffer));\n  }\n\n  public decodeValue(b: Pipe, t: Type): T[] {\n    const vec = this.checkType(t);\n    if (!(vec instanceof VecClass)) {\n      throw new Error('Not a vector type');\n    }\n    const len = Number(lebDecode(b));\n\n    if (this._type instanceof FixedNatClass) {\n      if (this._type._bits == 8) {\n        return new Uint8Array(b.read(len)) as unknown as T[];\n      }\n      if (this._type._bits == 16) {\n        return new Uint16Array(b.read(len * 2)) as unknown as T[];\n      }\n      if (this._type._bits == 32) {\n        return new Uint32Array(b.read(len * 4)) as unknown as T[];\n      }\n      if (this._type._bits == 64) {\n        return new BigUint64Array(b.read(len * 8)) as unknown as T[];\n      }\n    }\n\n    if (this._type instanceof FixedIntClass) {\n      if (this._type._bits == 8) {\n        return new Int8Array(b.read(len)) as unknown as T[];\n      }\n      if (this._type._bits == 16) {\n        return new Int16Array(b.read(len * 2)) as unknown as T[];\n      }\n      if (this._type._bits == 32) {\n        return new Int32Array(b.read(len * 4)) as unknown as T[];\n      }\n      if (this._type._bits == 64) {\n        return new BigInt64Array(b.read(len * 8)) as unknown as T[];\n      }\n    }\n\n    const rets: T[] = [];\n    for (let i = 0; i \u003c len; i++) {\n      rets.push(this._type.decodeValue(b, vec._type));\n    }\n    return rets;\n  }\n\n  get name() {\n    return `vec ${this._type.name}`;\n  }\n\n  public display() {\n    return `vec ${this._type.display()}`;\n  }\n\n  public valueToString(x: T[]) {\n    const elements = x.map(e =\u003e this._type.valueToString(e));\n    return 'vec {' + elements.join('; ') + '}';\n  }\n}\n\n/**\n * Represents an IDL Option\n * @param {Type} t\n */\nexport class OptClass\u003cT\u003e extends ConstructType\u003c[T] | []\u003e {\n  constructor(protected _type: Type\u003cT\u003e) {\n    super();\n  }\n\n  public accept\u003cD, R\u003e(v: Visitor\u003cD, R\u003e, d: D): R {\n    return v.visitOpt(this, this._type, d);\n  }\n\n  public covariant(x: any): x is [T] | [] {\n    try {\n      if (Array.isArray(x) \u0026\u0026 (x.length === 0 || (x.length === 1 \u0026\u0026 this._type.covariant(x[0]))))\n        return true;\n    } catch (e: any) {\n      throw new Error(\n        `Invalid ${this.display()} argument: ${toReadableString(x)} \\n\\n-\u003e ${e.message}`,\n      );\n    }\n    throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);\n  }\n\n  public encodeValue(x: [T] | []) {\n    if (x.length === 0) {\n      return new Uint8Array([0]);\n    } else {\n      return concat(new Uint8Array([1]), this._type.encodeValue(x[0]));\n    }\n  }\n\n  public _buildTypeTableImpl(typeTable: TypeTable) {\n    this._type.buildTypeTable(typeTable);\n\n    const opCode = slebEncode(IDLTypeIds.Opt);\n    const buffer = this._type.encodeType(typeTable);\n    typeTable.add(this, concat(opCode, buffer));\n  }\n\n  public decodeValue(b: Pipe, t: Type): [T] | [] {\n    const opt = this.checkType(t);\n    if (!(opt instanceof OptClass)) {\n      throw new Error('Not an option type');\n    }\n    switch (safeReadUint8(b)) {\n      case 0:\n        return [];\n      case 1:\n        return [this._type.decodeValue(b, opt._type)];\n      default:\n        throw new Error('Not an option value');\n    }\n  }\n\n  get name() {\n    return `opt ${this._type.name}`;\n  }\n\n  public display() {\n    return `opt ${this._type.display()}`;\n  }\n\n  public valueToString(x: [T] | []) {\n    if (x.length === 0) {\n      return 'null';\n    } else {\n      return `opt ${this._type.valueToString(x[0])}`;\n    }\n  }\n}\n\n/**\n * Represents an IDL Record\n * @param {object} [fields] - mapping of function name to Type\n */\nexport class RecordClass extends ConstructType\u003cRecord\u003cstring, any\u003e\u003e {\n  protected readonly _fields: Array\u003c[string, Type]\u003e;\n\n  constructor(fields: Record\u003cstring, Type\u003e = {}) {\n    super();\n    this._fields = Object.entries(fields).sort((a, b) =\u003e idlLabelToId(a[0]) - idlLabelToId(b[0]));\n  }\n\n  public accept\u003cD, R\u003e(v: Visitor\u003cD, R\u003e, d: D): R {\n    return v.visitRecord(this, this._fields, d);\n  }\n\n  public tryAsTuple(): Type[] | null {\n    const res: Type[] = [];\n    for (let i = 0; i \u003c this._fields.length; i++) {\n      const [key, type] = this._fields[i];\n      if (key !== `_${i}_`) {\n        return null;\n      }\n      res.push(type);\n    }\n    return res;\n  }\n\n  public covariant(x: any): x is Record\u003cstring, any\u003e {\n    if (\n      typeof x === 'object' \u0026\u0026\n      this._fields.every(([k, t]) =\u003e {\n        // eslint-disable-next-line\n        if (!x.hasOwnProperty(k)) {\n          throw new Error(`Record is missing key \"${k}\".`);\n        }\n        try {\n          return t.covariant(x[k]);\n        } catch (e: any) {\n          throw new Error(`Invalid ${this.display()} argument: \\n\\nfield ${k} -\u003e ${e.message}`);\n        }\n      })\n    )\n      return true;\n\n    throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);\n  }\n\n  public encodeValue(x: Record\u003cstring, any\u003e) {\n    const values = this._fields.map(([key]) =\u003e x[key]);\n    const bufs = zipWith(this._fields, values, ([, c], d) =\u003e c.encodeValue(d));\n    return concat(...bufs);\n  }\n\n  public _buildTypeTableImpl(T: TypeTable) {\n    this._fields.forEach(([_, value]) =\u003e value.buildTypeTable(T));\n    const opCode = slebEncode(IDLTypeIds.Record);\n    const len = lebEncode(this._fields.length);\n    const fields = this._fields.map(([key, value]) =\u003e\n      concat(lebEncode(idlLabelToId(key)), value.encodeType(T)),\n    );\n\n    T.add(this, concat(opCode, len, concat(...fields)));\n  }\n\n  public decodeValue(b: Pipe, t: Type) {\n    const record = this.checkType(t);\n    if (!(record instanceof RecordClass)) {\n      throw new Error('Not a record type');\n    }\n    const x: Record\u003cstring, any\u003e = {};\n\n    let expectedRecordIdx = 0;\n    let actualRecordIdx = 0;\n    while (actualRecordIdx \u003c record._fields.length) {\n      const [hash, type] = record._fields[actualRecordIdx];\n\n      if (expectedRecordIdx \u003e= this._fields.length) {\n        // skip unexpected left over fields present on the wire\n        type.decodeValue(b, type);\n        actualRecordIdx++;\n        continue;\n      }\n\n      const [expectKey, expectType] = this._fields[expectedRecordIdx];\n      const expectedId = idlLabelToId(this._fields[expectedRecordIdx][0]);\n      const actualId = idlLabelToId(hash);\n      if (expectedId === actualId) {\n        // the current field on the wire matches the expected field\n        x[expectKey] = expectType.decodeValue(b, type);\n        expectedRecordIdx++;\n        actualRecordIdx++;\n      } else if (actualId \u003e expectedId) {\n        // The expected field does not exist on the wire\n        if (expectType instanceof OptClass || expectType instanceof ReservedClass) {\n          x[expectKey] = [];\n          expectedRecordIdx++;\n        } else {\n          throw new Error('Cannot find required field ' + expectKey);\n        }\n      } else {\n        // The field on the wire does not exist in the output type, so we can skip it\n        type.decodeValue(b, type);\n        actualRecordIdx++;\n      }\n    }\n\n    // initialize left over expected optional fields\n    for (const [expectKey, expectType] of this._fields.slice(expectedRecordIdx)) {\n      if (expectType instanceof OptClass || expectType instanceof ReservedClass) {\n        // TODO this assumes null value in opt is represented as []\n        x[expectKey] = [];\n      } else {\n        throw new Error('Cannot find required field ' + expectKey);\n      }\n    }\n    return x;\n  }\n\n  get name() {\n    const fields = this._fields.map(([key, value]) =\u003e key + ':' + value.name);\n    return `record {${fields.join('; ')}}`;\n  }\n\n  public display() {\n    const fields = this._fields.map(([key, value]) =\u003e key + ':' + value.display());\n    return `record {${fields.join('; ')}}`;\n  }\n\n  public valueToString(x: Record\u003cstring, any\u003e) {\n    const values = this._fields.map(([key]) =\u003e x[key]);\n    const fields = zipWith(this._fields, values, ([k, c], d) =\u003e k + '=' + c.valueToString(d));\n    return `record {${fields.join('; ')}}`;\n  }\n}\n\n/**\n * Represents Tuple, a syntactic sugar for Record.\n * @param {Type} components\n */\nexport class TupleClass\u003cT extends any[]\u003e extends RecordClass {\n  protected readonly _components: Type[];\n\n  constructor(_components: Type[]) {\n    const x: Record\u003cstring, any\u003e = {};\n    _components.forEach((e, i) =\u003e (x['_' + i + '_'] = e));\n    super(x);\n    this._components = _components;\n  }\n\n  public accept\u003cD, R\u003e(v: Visitor\u003cD, R\u003e, d: D): R {\n    return v.visitTuple(this, this._components, d);\n  }\n\n  public covariant(x: any): x is T {\n    // `\u003e=` because tuples can be covariant when encoded.\n\n    if (\n      Array.isArray(x) \u0026\u0026\n      x.length \u003e= this._fields.length \u0026\u0026\n      this._components.every((t, i) =\u003e {\n        try {\n          return t.covariant(x[i]);\n        } catch (e: any) {\n          throw new Error(`Invalid ${this.display()} argument: \\n\\nindex ${i} -\u003e ${e.message}`);\n        }\n      })\n    )\n      return true;\n\n    throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);\n  }\n\n  public encodeValue(x: any[]) {\n    const bufs = zipWith(this._components, x, (c, d) =\u003e c.encodeValue(d));\n    return concat(...bufs);\n  }\n\n  public decodeValue(b: Pipe, t: Type): T {\n    const tuple = this.checkType(t);\n    if (!(tuple instanceof TupleClass)) {\n      throw new Error('not a tuple type');\n    }\n    if (tuple._components.length \u003c this._components.length) {\n      throw new Error('tuple mismatch');\n    }\n    const res = [];\n    for (const [i, wireType] of tuple._components.entries()) {\n      if (i \u003e= this._components.length) {\n        // skip value\n        wireType.decodeValue(b, wireType);\n      } else {\n        res.push(this._components[i].decodeValue(b, wireType));\n      }\n    }\n    return res as T;\n  }\n\n  public display() {\n    const fields = this._components.map(value =\u003e value.display());\n    return `record {${fields.join('; ')}}`;\n  }\n\n  public valueToString(values: any[]) {\n    const fields = zipWith(this._components, values, (c, d) =\u003e c.valueToString(d));\n    return `record {${fields.join('; ')}}`;\n  }\n}\n\n/**\n * Represents an IDL Variant\n * @param {object} [fields] - mapping of function name to Type\n */\nexport class VariantClass extends ConstructType\u003cRecord\u003cstring, any\u003e\u003e {\n  private readonly _fields: Array\u003c[string, Type]\u003e;\n\n  constructor(fields: Record\u003cstring, Type\u003e = {}) {\n    super();\n    this._fields = Object.entries(fields).sort((a, b) =\u003e idlLabelToId(a[0]) - idlLabelToId(b[0]));\n  }\n\n  public accept\u003cD, R\u003e(v: Visitor\u003cD, R\u003e, d: D): R {\n    return v.visitVariant(this, this._fields, d);\n  }\n\n  public covariant(x: any): x is Record\u003cstring, any\u003e {\n    if (\n      typeof x === 'object' \u0026\u0026\n      Object.entries(x).length === 1 \u0026\u0026\n      this._fields.every(([k, v]) =\u003e {\n        try {\n          // eslint-disable-next-line\n          return !x.hasOwnProperty(k) || v.covariant(x[k]);\n        } catch (e: any) {\n          throw new Error(`Invalid ${this.display()} argument: \\n\\nvariant ${k} -\u003e ${e.message}`);\n        }\n      })\n    )\n      return true;\n\n    throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);\n  }\n\n  public encodeValue(x: Record\u003cstring, any\u003e) {\n    for (let i = 0; i \u003c this._fields.length; i++) {\n      const [name, type] = this._fields[i];\n      // eslint-disable-next-line\n      if (x.hasOwnProperty(name)) {\n        const idx = lebEncode(i);\n        const buf = type.encodeValue(x[name]);\n\n        return concat(idx, buf);\n      }\n    }\n    throw Error('Variant has no data: ' + x);\n  }\n\n  public _buildTypeTableImpl(typeTable: TypeTable) {\n    this._fields.forEach(([, type]) =\u003e {\n      type.buildTypeTable(typeTable);\n    });\n    const opCode = slebEncode(IDLTypeIds.Variant);\n    const len = lebEncode(this._fields.length);\n    const fields = this._fields.map(([key, value]) =\u003e\n      concat(lebEncode(idlLabelToId(key)), value.encodeType(typeTable)),\n    );\n    typeTable.add(this, concat(opCode, len, ...fields));\n  }\n\n  public decodeValue(b: Pipe, t: Type) {\n    const variant = this.checkType(t);\n    if (!(variant instanceof VariantClass)) {\n      throw new Error('Not a variant type');\n    }\n    const idx = Number(lebDecode(b));\n    if (idx \u003e= variant._fields.length) {\n      throw Error('Invalid variant index: ' + idx);\n    }\n    const [wireHash, wireType] = variant._fields[idx];\n    for (const [key, expectType] of this._fields) {\n      if (idlLabelToId(wireHash) === idlLabelToId(key)) {\n        const value = expectType.decodeValue(b, wireType);\n        return { [key]: value };\n      }\n    }\n    throw new Error('Cannot find field hash ' + wireHash);\n  }\n\n  get name() {\n    const fields = this._fields.map(([key, type]) =\u003e key + ':' + type.name);\n    return `variant {${fields.join('; ')}}`;\n  }\n\n  public display() {\n    const fields = this._fields.map(\n      ([key, type]) =\u003e key + (type.name === 'null' ? '' : `:${type.display()}`),\n    );\n    return `variant {${fields.join('; ')}}`;\n  }\n\n  public valueToString(x: Record\u003cstring, any\u003e) {\n    for (const [name, type] of this._fields) {\n      // eslint-disable-next-line\n      if (x.hasOwnProperty(name)) {\n        const value = type.valueToString(x[name]);\n        if (value === 'null') {\n          return `variant {${name}}`;\n        } else {\n          return `variant {${name}=${value}}`;\n        }\n      }\n    }\n    throw new Error('Variant has no data: ' + x);\n  }\n}\n\n/**\n * Represents a reference to an IDL type, used for defining recursive data\n * types.\n */\nexport class RecClass\u003cT = any\u003e extends ConstructType\u003cT\u003e {\n  private static _counter = 0;\n  private _id = RecClass._counter++;\n  private _type: ConstructType\u003cT\u003e | undefined = undefined;\n\n  public accept\u003cD, R\u003e(v: Visitor\u003cD, R\u003e, d: D): R {\n    if (!this._type) {\n      throw Error('Recursive type uninitialized.');\n    }\n    return v.visitRec(this, this._type, d);\n  }\n\n  public fill(t: ConstructType\u003cT\u003e) {\n    this._type = t;\n  }\n\n  public getType() {\n    return this._type;\n  }\n\n  public covariant(x: any): x is T {\n    if (this._type ? this._type.covariant(x) : false) return true;\n    throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);\n  }\n\n  public encodeValue(x: T) {\n    if (!this._type) {\n      throw Error('Recursive type uninitialized.');\n    }\n    return this._type.encodeValue(x);\n  }\n\n  public _buildTypeTableImpl(typeTable: TypeTable) {\n    if (!this._type) {\n      throw Error('Recursive type uninitialized.');\n    }\n    typeTable.add(this, new Uint8Array([]));\n    this._type.buildTypeTable(typeTable);\n    typeTable.merge(this, this._type.name);\n  }\n\n  public decodeValue(b: Pipe, t: Type) {\n    if (!this._type) {\n      throw Error('Recursive type uninitialized.');\n    }\n    return this._type.decodeValue(b, t);\n  }\n\n  get name() {\n    return `rec_${this._id}`;\n  }\n\n  public display() {\n    if (!this._type) {\n      throw Error('Recursive type uninitialized.');\n    }\n    return `μ${this.name}.${this._type.name}`;\n  }\n\n  public valueToString(x: T) {\n    if (!this._type) {\n      throw Error('Recursive type uninitialized.');\n    }\n    return this._type.valueToString(x);\n  }\n}\n\nfunction decodePrincipalId(b: Pipe): PrincipalId {\n  const x = safeReadUint8(b);\n  if (x !== 1) {\n    throw new Error('Cannot decode principal');\n  }\n\n  const len = Number(lebDecode(b));\n  return PrincipalId.fromUint8Array(new Uint8Array(safeRead(b, len)));\n}\n\n/**\n * Represents an IDL principal reference\n */\nexport class PrincipalClass extends PrimitiveType\u003cPrincipalId\u003e {\n  public accept\u003cD, R\u003e(v: Visitor\u003cD, R\u003e, d: D): R {\n    return v.visitPrincipal(this, d);\n  }\n\n  public covariant(x: any): x is PrincipalId {\n    if (x \u0026\u0026 x._isPrincipal) return true;\n    throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);\n  }\n\n  public encodeValue(x: PrincipalId): ArrayBuffer {\n    const buf = x.toUint8Array();\n    const len = lebEncode(buf.byteLength);\n    return concat(new Uint8Array([1]), len, buf);\n  }\n\n  public encodeType() {\n    return slebEncode(IDLTypeIds.Principal);\n  }\n\n  public decodeValue(b: Pipe, t: Type): PrincipalId {\n    this.checkType(t);\n    return decodePrincipalId(b);\n  }\n\n  get name() {\n    return 'principal';\n  }\n  public valueToString(x: PrincipalId) {\n    return `${this.name} \"${x.toText()}\"`;\n  }\n}\n\n/**\n * Represents an IDL function reference.\n * @param argTypes Argument types.\n * @param retTypes Return types.\n * @param annotations Function annotations.\n */\nexport class FuncClass extends ConstructType\u003c[PrincipalId, string]\u003e {\n  public static argsToString(types: Type[], v: any[]) {\n    if (types.length !== v.length) {\n      throw new Error('arity mismatch');\n    }\n    return '(' + types.map((t, i) =\u003e t.valueToString(v[i])).join(', ') + ')';\n  }\n\n  constructor(public argTypes: Type[], public retTypes: Type[], public annotations: string[] = []) {\n    super();\n  }\n\n  public accept\u003cD, R\u003e(v: Visitor\u003cD, R\u003e, d: D): R {\n    return v.visitFunc(this, d);\n  }\n  public covariant(x: any): x is [PrincipalId, string] {\n    if (Array.isArray(x) \u0026\u0026 x.length === 2 \u0026\u0026 x[0] \u0026\u0026 x[0]._isPrincipal \u0026\u0026 typeof x[1] === 'string')\n      return true;\n    throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);\n  }\n\n  public encodeValue([principal, methodName]: [PrincipalId, string]) {\n    const buf = principal.toUint8Array();\n    const len = lebEncode(buf.byteLength);\n    const canister = concat(new Uint8Array([1]), len, buf);\n\n    const method = new TextEncoder().encode(methodName);\n    const methodLen = lebEncode(method.byteLength);\n    return concat(new Uint8Array([1]), canister, methodLen, method);\n  }\n\n  public _buildTypeTableImpl(T: TypeTable) {\n    this.argTypes.forEach(arg =\u003e arg.buildTypeTable(T));\n    this.retTypes.forEach(arg =\u003e arg.buildTypeTable(T));\n\n    const opCode = slebEncode(IDLTypeIds.Func);\n    const argLen = lebEncode(this.argTypes.length);\n    const args = concat(...this.argTypes.map(arg =\u003e arg.encodeType(T)));\n    const retLen = lebEncode(this.retTypes.length);\n    const rets = concat(...this.retTypes.map(arg =\u003e arg.encodeType(T)));\n    const annLen = lebEncode(this.annotations.length);\n    const anns = concat(...this.annotations.map(a =\u003e this.encodeAnnotation(a)));\n\n    T.add(this, concat(opCode, argLen, args, retLen, rets, annLen, anns));\n  }\n\n  public decodeValue(b: Pipe): [PrincipalId, string] {\n    const x = safeReadUint8(b);\n    if (x !== 1) {\n      throw new Error('Cannot decode function reference');\n    }\n    const canister = decodePrincipalId(b);\n\n    const mLen = Number(lebDecode(b));\n    const buf = safeRead(b, mLen);\n    const decoder = new TextDecoder('utf8', { fatal: true });\n    const method = decoder.decode(buf);\n\n    return [canister, method];\n  }\n\n  get name() {\n    const args = this.argTypes.map(arg =\u003e arg.name).join(', ');\n    const rets = this.retTypes.map(arg =\u003e arg.name).join(', ');\n    const annon = ' ' + this.annotations.join(' ');\n    return `(${args}) -\u003e (${rets})${annon}`;\n  }\n\n  public valueToString([principal, str]: [PrincipalId, string]) {\n    return `func \"${principal.toText()}\".${str}`;\n  }\n\n  public display(): string {\n    const args = this.argTypes.map(arg =\u003e arg.display()).join(', ');\n    const rets = this.retTypes.map(arg =\u003e arg.display()).join(', ');\n    const annon = ' ' + this.annotations.join(' ');\n    return `(${args}) → (${rets})${annon}`;\n  }\n\n  private encodeAnnotation(ann: string): ArrayBuffer {\n    if (ann === 'query') {\n      return new Uint8Array([1]);\n    } else if (ann === 'oneway') {\n      return new Uint8Array([2]);\n    } else if (ann === 'composite_query') {\n      return new Uint8Array([3]);\n    } else {\n      throw new Error('Illegal function annotation');\n    }\n  }\n}\n\nexport class ServiceClass extends ConstructType\u003cPrincipalId\u003e {\n  public readonly _fields: Array\u003c[string, FuncClass]\u003e;\n  constructor(fields: Record\u003cstring, FuncClass\u003e) {\n    super();\n    this._fields = Object.entries(fields).sort((a, b) =\u003e {\n      if (a[0] \u003c b[0]) {\n        return -1;\n      }\n      if (a[0] \u003e b[0]) {\n        return 1;\n      }\n      return 0;\n    });\n  }\n  public accept\u003cD, R\u003e(v: Visitor\u003cD, R\u003e, d: D): R {\n    return v.visitService(this, d);\n  }\n  public covariant(x: any): x is PrincipalId {\n    if (x \u0026\u0026 x._isPrincipal) return true;\n    throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);\n  }\n\n  public encodeValue(x: PrincipalId) {\n    const buf = x.toUint8Array();\n    const len = lebEncode(buf.length);\n    return concat(new Uint8Array([1]), len, buf);\n  }\n\n  public _buildTypeTableImpl(T: TypeTable) {\n    this._fields.forEach(([_, func]) =\u003e func.buildTypeTable(T));\n    const opCode = slebEncode(IDLTypeIds.Service);\n    const len = lebEncode(this._fields.length);\n    const meths = this._fields.map(([label, func]) =\u003e {\n      const labelBuf = new TextEncoder().encode(label);\n      const labelLen = lebEncode(labelBuf.length);\n      return concat(labelLen, labelBuf, func.encodeType(T));\n    });\n\n    T.add(this, concat(opCode, len, ...meths));\n  }\n\n  public decodeValue(b: Pipe): PrincipalId {\n    return decodePrincipalId(b);\n  }\n  get name() {\n    const fields = this._fields.map(([key, value]) =\u003e key + ':' + value.name);\n    return `service {${fields.join('; ')}}`;\n  }\n\n  public valueToString(x: PrincipalId) {\n    return `service \"${x.toText()}\"`;\n  }\n}\n\n/**\n * Takes an unknown value and returns a string representation of it.\n * @param x - unknown value\n * @returns {string} string representation of the value\n */\nfunction toReadableString(x: unknown): string {\n  const str = JSON.stringify(x, (_key, value) =\u003e\n    typeof value === 'bigint' ? `BigInt(${value})` : value,\n  );\n\n  return str \u0026\u0026 str.length \u003e toReadableString_max\n    ? str.substring(0, toReadableString_max - 3) + '...'\n    : str;\n}\n\n/**\n * Encode a array of values\n * @param argTypes - array of Types\n * @param args - array of values\n * @returns {ArrayBuffer} serialised value\n */\nexport function encode(argTypes: Array\u003cType\u003cany\u003e\u003e, args: any[]): ArrayBuffer {\n  if (args.length \u003c argTypes.length) {\n    throw Error('Wrong number of message arguments');\n  }\n\n  const typeTable = new TypeTable();\n  argTypes.forEach(t =\u003e t.buildTypeTable(typeTable));\n\n  const magic = new TextEncoder().encode(magicNumber);\n  const table = typeTable.encode();\n  const len = lebEncode(args.length);\n  const typs = concat(...argTypes.map(t =\u003e t.encodeType(typeTable)));\n  const vals = concat(\n    ...zipWith(argTypes, args, (t, x) =\u003e {\n      try {\n        t.covariant(x);\n      } catch (e: any) {\n        const err = new Error(e.message + '\\n\\n');\n        throw err;\n      }\n\n      return t.encodeValue(x);\n    }),\n  );\n\n  return concat(magic, table, len, typs, vals);\n}\n\n/**\n * Decode a binary value\n * @param retTypes - Types expected in the buffer.\n * @param bytes - hex-encoded string, or buffer.\n * @returns Value deserialised to JS type\n */\nexport function decode(retTypes: Type[], bytes: ArrayBuffer): JsonValue[] {\n  const b = new Pipe(bytes);\n\n  if (bytes.byteLength \u003c magicNumber.length) {\n    throw new Error('Message length smaller than magic number');\n  }\n  const magicBuffer = safeRead(b, magicNumber.length);\n  const magic = new TextDecoder().decode(magicBuffer);\n  if (magic !== magicNumber) {\n    throw new Error('Wrong magic number: ' + JSON.stringify(magic));\n  }\n\n  function readTypeTable(pipe: Pipe): [Array\u003c[IDLTypeIds, any]\u003e, number[]] {\n    const typeTable: Array\u003c[IDLTypeIds, any]\u003e = [];\n    const len = Number(lebDecode(pipe));\n\n    for (let i = 0; i \u003c len; i++) {\n      const ty = Number(slebDecode(pipe));\n      switch (ty) {\n        case IDLTypeIds.Opt:\n        case IDLTypeIds.Vector: {\n          const t = Number(slebDecode(pipe));\n          typeTable.push([ty, t]);\n          break;\n        }\n        case IDLTypeIds.Record:\n        case IDLTypeIds.Variant: {\n          const fields = [];\n          let objectLength = Number(lebDecode(pipe));\n          let prevHash;\n          while (objectLength--) {\n            const hash = Number(lebDecode(pipe));\n            if (hash \u003e= Math.pow(2, 32)) {\n              throw new Error('field id out of 32-bit range');\n            }\n            if (typeof prevHash === 'number' \u0026\u0026 prevHash \u003e= hash) {\n              throw new Error('field id collision or not sorted');\n            }\n            prevHash = hash;\n            const t = Number(slebDecode(pipe));\n            fields.push([hash, t]);\n          }\n          typeTable.push([ty, fields]);\n          break;\n        }\n        case IDLTypeIds.Func: {\n          const args = [];\n          let argLength = Number(lebDecode(pipe));\n          while (argLength--) {\n            args.push(Number(slebDecode(pipe)));\n          }\n          const returnValues = [];\n          let returnValuesLength = Number(lebDecode(pipe));\n          while (returnValuesLength--) {\n            returnValues.push(Number(slebDecode(pipe)));\n          }\n          const annotations = [];\n          let annotationLength = Number(lebDecode(pipe));\n          while (annotationLength--) {\n            const annotation = Number(lebDecode(pipe));\n            switch (annotation) {\n              case 1: {\n                annotations.push('query');\n                break;\n              }\n              case 2: {\n                annotations.push('oneway');\n                break;\n              }\n              case 3: {\n                annotations.push('composite_query');\n                break;\n              }\n              default:\n                throw new Error('unknown annotation');\n            }\n          }\n          typeTable.push([ty, [args, returnValues, annotations]]);\n          break;\n        }\n        case IDLTypeIds.Service: {\n          let servLength = Number(lebDecode(pipe));\n          const methods = [];\n          while (servLength--) {\n            const nameLength = Number(lebDecode(pipe));\n            const funcName = new TextDecoder().decode(safeRead(pipe, nameLength));\n            const funcType = slebDecode(pipe);\n            methods.push([funcName, funcType]);\n          }\n          typeTable.push([ty, methods]);\n          break;\n        }\n        default:\n          throw new Error('Illegal op_code: ' + ty);\n      }\n    }\n\n    const rawList: number[] = [];\n    const length = Number(lebDecode(pipe));\n    for (let i = 0; i \u003c length; i++) {\n      rawList.push(Number(slebDecode(pipe)));\n    }\n    return [typeTable, rawList];\n  }\n  const [rawTable, rawTypes] = readTypeTable(b);\n  if (rawTypes.length \u003c retTypes.length) {\n    throw new Error('Wrong number of return values');\n  }\n\n  const table: RecClass[] = rawTable.map(_ =\u003e Rec());\n  function getType(t: number): Type {\n    if (t \u003c -24) {\n      throw new Error('future value not supported');\n    }\n    if (t \u003c 0) {\n      switch (t) {\n        case -1:\n          return Null;\n        case -2:\n          return Bool;\n        case -3:\n          return Nat;\n        case -4:\n          return Int;\n        case -5:\n          return Nat8;\n        case -6:\n          return Nat16;\n        case -7:\n          return Nat32;\n        case -8:\n          return Nat64;\n        case -9:\n          return Int8;\n        case -10:\n          return Int16;\n        case -11:\n          return Int32;\n        case -12:\n          return Int64;\n        case -13:\n          return Float32;\n        case -14:\n          return Float64;\n        case -15:\n          return Text;\n        case -16:\n          return Reserved;\n        case -17:\n          return Empty;\n        case -24:\n          return Principal;\n        default:\n          throw new Error('Illegal op_code: ' + t);\n      }\n    }\n    if (t \u003e= rawTable.length) {\n      throw new Error('type index out of range');\n    }\n    return table[t];\n  }\n  function buildType(entry: [IDLTypeIds, any]): Type {\n    switch (entry[0]) {\n      case IDLTypeIds.Vector: {\n        const ty = getType(entry[1]);\n        return Vec(ty);\n      }\n      case IDLTypeIds.Opt: {\n        const ty = getType(entry[1]);\n        return Opt(ty);\n      }\n      case IDLTypeIds.Record: {\n        const fields: Record\u003cstring, Type\u003e = {};\n        for (const [hash, ty] of entry[1]) {\n          const name = `_${hash}_`;\n          fields[name] = getType(ty);\n        }\n        const record = Record(fields);\n        const tuple = record.tryAsTuple();\n        if (Array.isArray(tuple)) {\n          return Tuple(...tuple);\n        } else {\n          return record;\n        }\n      }\n      case IDLTypeIds.Variant: {\n        const fields: Record\u003cstring, Type\u003e = {};\n        for (const [hash, ty] of entry[1]) {\n          const name = `_${hash}_`;\n          fields[name] = getType(ty);\n        }\n        return Variant(fields);\n      }\n      case IDLTypeIds.Func: {\n        const [args, returnValues, annotations] = entry[1];\n        return Func(\n          args.map((t: number) =\u003e getType(t)),\n          returnValues.map((t: number) =\u003e getType(t)),\n          annotations,\n        );\n      }\n      case IDLTypeIds.Service: {\n        const rec: Record\u003cstring, FuncClass\u003e = {};\n        const methods = entry[1] as [[string, number]];\n        for (const [name, typeRef] of methods) {\n          let type: Type | undefined = getType(typeRef);\n\n          if (type instanceof RecClass) {\n            // unpack reference type\n            type = type.getType();\n          }\n          if (!(type instanceof FuncClass)) {\n            throw new Error('Illegal service definition: services can only contain functions');\n          }\n          rec[name] = type;\n        }\n        return Service(rec);\n      }\n      default:\n        throw new Error('Illegal op_code: ' + entry[0]);\n    }\n  }\n\n  rawTable.forEach((entry, i) =\u003e {\n    // Process function type first, so that we can construct the correct service type\n    if (entry[0] === IDLTypeIds.Func) {\n      const t = buildType(entry);\n      table[i].fill(t);\n    }\n  });\n  rawTable.forEach((entry, i) =\u003e {\n    if (entry[0] !== IDLTypeIds.Func) {\n      const t = buildType(entry);\n      table[i].fill(t);\n    }\n  });\n\n  const types = rawTypes.map(t =\u003e getType(t));\n  const output = retTypes.map((t, i) =\u003e {\n    return t.decodeValue(b, types[i]);\n  });\n\n  // skip unused values\n  for (let ind = retTypes.length; ind \u003c types.length; ind++) {\n    types[ind].decodeValue(b, types[ind]);\n  }\n\n  if (b.byteLength \u003e 0) {\n    throw new Error('decode: Left-over bytes');\n  }\n\n  return output;\n}\n\n/**\n * An Interface Factory, normally provided by a Candid code generation.\n */\nexport type InterfaceFactory = (idl: {\n  IDL: {\n    Empty: EmptyClass;\n    Reserved: ReservedClass;\n    Unknown: UnknownClass;\n    Bool: BoolClass;\n    Null: NullClass;\n    Text: TextClass;\n    Int: IntClass;\n    Nat: NatClass;\n\n    Float32: FloatClass;\n    Float64: FloatClass;\n\n    Int8: FixedIntClass;\n    Int16: FixedIntClass;\n    Int32: FixedIntClass;\n    Int64: FixedIntClass;\n\n    Nat8: FixedNatClass;\n    Nat16: FixedNatClass;\n    Nat32: FixedNatClass;\n    Nat64: FixedNatClass;\n\n    Principal: PrincipalClass;\n\n    Tuple: typeof Tuple;\n    Vec: typeof Vec;\n    Opt: typeof Opt;\n    Record: typeof Record;\n    Variant: typeof Variant;\n    Rec: typeof Rec;\n    Func: typeof Func;\n\n    Service(t: Record\u003cstring, FuncClass\u003e): ServiceClass;\n  };\n}) =\u003e ServiceClass;\n\n// Export Types instances.\nexport const Empty = new EmptyClass();\nexport const Reserved = new ReservedClass();\n/**\n * Client-only type for deserializing unknown data. Not supported by Candid, and its use is discouraged.\n */\nexport const Unknown = new UnknownClass();\nexport const Bool = new BoolClass();\nexport const Null = new NullClass();\nexport const Text = new TextClass();\nexport const Int = new IntClass();\nexport const Nat = new NatClass();\n\nexport const Float32 = new FloatClass(32);\nexport const Float64 = new FloatClass(64);\n\nexport const Int8 = new FixedIntClass(8);\nexport const Int16 = new FixedIntClass(16);\nexport const Int32 = new FixedIntClass(32);\nexport const Int64 = new FixedIntClass(64);\n\nexport const Nat8 = new FixedNatClass(8);\nexport const Nat16 = new FixedNatClass(16);\nexport const Nat32 = new FixedNatClass(32);\nexport const Nat64 = new FixedNatClass(64);\n\nexport const Principal = new PrincipalClass();\n\n/**\n *\n * @param types array of any types\n * @returns TupleClass from those types\n */\nexport function Tuple\u003cT extends any[]\u003e(...types: T): TupleClass\u003cT\u003e {\n  return new TupleClass(types);\n}\n/**\n *\n * @param t IDL Type\n * @returns VecClass from that type\n */\nexport function Vec\u003cT\u003e(t: Type\u003cT\u003e): VecClass\u003cT\u003e {\n  return new VecClass(t);\n}\n/**\n *\n * @param t IDL Type\n * @returns OptClass of Type\n */\nexport function Opt\u003cT\u003e(t: Type\u003cT\u003e): OptClass\u003cT\u003e {\n  return new OptClass(t);\n}\n/**\n *\n * @param t Record of string and IDL Type\n * @returns RecordClass of string and Type\n */\nexport function Record(t: Record\u003cstring, Type\u003e): RecordClass {\n  return new RecordClass(t);\n}\n\n/**\n *\n * @param fields Record of string and IDL Type\n * @returns VariantClass\n */\nexport function Variant(fields: Record\u003cstring, Type\u003e): VariantClass {\n  return new VariantClass(fields);\n}\n/**\n *\n * @returns new RecClass\n */\nexport function Rec(): RecClass {\n  return new RecClass();\n}\n\n/**\n *\n * @param args array of IDL Types\n * @param ret array of IDL Types\n * @param annotations array of strings, [] by default\n * @returns new FuncClass\n */\nexport function Func(args: Type[], ret: Type[], annotations: string[] = []): FuncClass {\n  return new FuncClass(args, ret, annotations);\n}\n\n/**\n *\n * @param t Record of string and FuncClass\n * @returns ServiceClass\n */\nexport function Service(t: Record\u003cstring, FuncClass\u003e): ServiceClass {\n  return new ServiceClass(t);\n}\n","/**\n * Concatenate multiple array buffers.\n * @param buffers The buffers to concatenate.\n */\nexport function concat(...buffers: ArrayBuffer[]): ArrayBuffer {\n  const result = new Uint8Array(buffers.reduce((acc, curr) =\u003e acc + curr.byteLength, 0));\n  let index = 0;\n  for (const b of buffers) {\n    result.set(new Uint8Array(b), index);\n    index += b.byteLength;\n  }\n  return result;\n}\n\n/**\n * Returns an hexadecimal representation of an array buffer.\n * @param bytes The array buffer.\n */\nexport function toHexString(bytes: ArrayBuffer): string {\n  return new Uint8Array(bytes).reduce((str, byte) =\u003e str + byte.toString(16).padStart(2, '0'), '');\n}\n\n/**\n * Return an array buffer from its hexadecimal representation.\n * @param hexString The hexadecimal string.\n */\nexport function fromHexString(hexString: string): ArrayBuffer {\n  return new Uint8Array((hexString.match(/.{1,2}/g) ?? []).map(byte =\u003e parseInt(byte, 16)));\n}\n\n/**\n * A class that abstracts a pipe-like ArrayBuffer.\n */\nexport class PipeArrayBuffer {\n  /**\n   * The reading view. It's a sliding window as we read and write, pointing to the buffer.\n   * @private\n   */\n  private _view: Uint8Array;\n\n  /**\n   * The actual buffer containing the bytes.\n   * @private\n   */\n  private _buffer: ArrayBuffer;\n\n  /**\n   * Creates a new instance of a pipe\n   * @param buffer an optional buffer to start with\n   * @param length an optional amount of bytes to use for the length.\n   */\n  constructor(buffer?: ArrayBuffer, length = buffer?.byteLength || 0) {\n    this._buffer = bufFromBufLike(buffer || new ArrayBuffer(0));\n    this._view = new Uint8Array(this._buffer, 0, length);\n  }\n\n  get buffer(): ArrayBuffer {\n    // Return a copy of the buffer.\n    return bufFromBufLike(this._view.slice());\n  }\n\n  get byteLength(): number {\n    return this._view.byteLength;\n  }\n\n  /**\n   * Read `num` number of bytes from the front of the pipe.\n   * @param num The number of bytes to read.\n   */\n  public read(num: number): ArrayBuffer {\n    const result = this._view.subarray(0, num);\n    this._view = this._view.subarray(num);\n    return result.slice().buffer;\n  }\n\n  public readUint8(): number | undefined {\n    const result = this._view[0];\n    this._view = this._view.subarray(1);\n    return result;\n  }\n\n  /**\n   * Write a buffer to the end of the pipe.\n   * @param buf The bytes to write.\n   */\n  public write(buf: ArrayBuffer): void {\n    const b = new Uint8Array(buf);\n    const offset = this._view.byteLength;\n    if (this._view.byteOffset + this._view.byteLength + b.byteLength \u003e= this._buffer.byteLength) {\n      // Alloc grow the view to include the new bytes.\n      this.alloc(b.byteLength);\n    } else {\n      // Update the view to include the new bytes.\n      this._view = new Uint8Array(\n        this._buffer,\n        this._view.byteOffset,\n        this._view.byteLength + b.byteLength,\n      );\n    }\n\n    this._view.set(b, offset);\n  }\n\n  /**\n   * Whether or not there is more data to read from the buffer\n   */\n  public get end(): boolean {\n    return this._view.byteLength === 0;\n  }\n\n  /**\n   * Allocate a fixed amount of memory in the buffer. This does not affect the view.\n   * @param amount A number of bytes to add to the buffer.\n   */\n  public alloc(amount: number) {\n    // Add a little bit of exponential growth.\n    const b = new ArrayBuffer(((this._buffer.byteLength + amount) * 1.2) | 0);\n    const v = new Uint8Array(b, 0, this._view.byteLength + amount);\n    v.set(this._view);\n    this._buffer = b;\n    this._view = v;\n  }\n}\n\n/**\n * Returns a true ArrayBuffer from a Uint8Array, as Uint8Array.buffer is unsafe.\n * @param {Uint8Array} arr Uint8Array to convert\n * @returns ArrayBuffer\n */\nexport function uint8ToBuf(arr: Uint8Array): ArrayBuffer {\n  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength).buffer;\n}\n\n/**\n * Returns a true ArrayBuffer from an ArrayBufferLike object.\n * @param bufLike a buffer-like object\n * @returns ArrayBuffer\n */\nexport function bufFromBufLike(\n  bufLike:\n    | ArrayBuffer\n    | Uint8Array\n    | DataView\n    | ArrayBufferView\n    | ArrayBufferLike\n    | [number]\n    | number[]\n    | { buffer: ArrayBuffer },\n): ArrayBuffer {\n  if (bufLike instanceof Uint8Array) {\n    return uint8ToBuf(bufLike);\n  }\n  if (bufLike instanceof ArrayBuffer) {\n    return bufLike;\n  }\n  if (Array.isArray(bufLike)) {\n    return uint8ToBuf(new Uint8Array(bufLike));\n  }\n  if ('buffer' in bufLike) {\n    return bufFromBufLike(bufLike.buffer);\n  }\n  return uint8ToBuf(new Uint8Array(bufLike));\n}\n","/**\n * Hashes a string to a number. Algorithm can be found here:\n * https://caml.inria.fr/pub/papers/garrigue-polymorphic_variants-ml98.pdf\n * @param s - string to hash\n * @returns number representing hashed string\n */\nfunction idlHash(s: string): number {\n  const utf8encoder = new TextEncoder();\n  const array = utf8encoder.encode(s);\n\n  let h = 0;\n  for (const c of array) {\n    h = (h * 223 + c) % 2 ** 32;\n  }\n  return h;\n}\n\n/**\n *\n * @param label string\n * @returns number representing hashed label\n */\nexport function idlLabelToId(label: string): number {\n  if (/^_\\d+_$/.test(label) || /^_0x[0-9a-fA-F]+_$/.test(label)) {\n    const num = +label.slice(1, -1);\n    if (Number.isSafeInteger(num) \u0026\u0026 num \u003e= 0 \u0026\u0026 num \u003c 2 ** 32) {\n      return num;\n    }\n  }\n  return idlHash(label);\n}\n","/* eslint-disable no-constant-condition */\n// Note: this file uses buffer-pipe, which on Node only, uses the Node Buffer\n//       implementation, which isn't compatible with the NPM buffer package\n//       which we use everywhere else. This means that we have to transform\n//       one into the other, hence why every function that returns a Buffer\n//       actually return `new Buffer(pipe.buffer)`.\n// TODO: The best solution would be to have our own buffer type around\n//       Uint8Array which is standard.\nimport { PipeArrayBuffer as Pipe } from './buffer';\n\nfunction eob(): never {\n  throw new Error('unexpected end of buffer');\n}\n\n/**\n *\n * @param pipe Pipe from buffer-pipe\n * @param num number\n * @returns Buffer\n */\nexport function safeRead(pipe: Pipe, num: number): ArrayBuffer {\n  if (pipe.byteLength \u003c num) {\n    eob();\n  }\n  return pipe.read(num);\n}\n\n/**\n * @param pipe - PipeArrayBuffer simulating buffer-pipe api\n */\nexport function safeReadUint8(pipe: Pipe): number {\n  const byte = pipe.readUint8();\n  if (byte === undefined) {\n    eob();\n  }\n  return byte;\n}\n\n/**\n * Encode a positive number (or bigint) into a Buffer. The number will be floored to the\n * nearest integer.\n * @param value The number to encode.\n */\nexport function lebEncode(value: bigint | number): ArrayBuffer {\n  if (typeof value === 'number') {\n    value = BigInt(value);\n  }\n\n  if (value \u003c BigInt(0)) {\n    throw new Error('Cannot leb encode negative values.');\n  }\n\n  const byteLength = (value === BigInt(0) ? 0 : Math.ceil(Math.log2(Number(value)))) + 1;\n  const pipe = new Pipe(new ArrayBuffer(byteLength), 0);\n  while (true) {\n    const i = Number(value \u0026 BigInt(0x7f));\n    value /= BigInt(0x80);\n    if (value === BigInt(0)) {\n      pipe.write(new Uint8Array([i]));\n      break;\n    } else {\n      pipe.write(new Uint8Array([i | 0x80]));\n    }\n  }\n\n  return pipe.buffer;\n}\n\n/**\n * Decode a leb encoded buffer into a bigint. The number will always be positive (does not\n * support signed leb encoding).\n * @param pipe A Buffer containing the leb encoded bits.\n */\nexport function lebDecode(pipe: Pipe): bigint {\n  let weight = BigInt(1);\n  let value = BigInt(0);\n  let byte;\n\n  do {\n    byte = safeReadUint8(pipe);\n    value += BigInt(byte \u0026 0x7f).valueOf() * weight;\n    weight *= BigInt(128);\n  } while (byte \u003e= 0x80);\n\n  return value;\n}\n\n/**\n * Encode a number (or bigint) into a Buffer, with support for negative numbers. The number\n * will be floored to the nearest integer.\n * @param value The number to encode.\n */\nexport function slebEncode(value: bigint | number): ArrayBuffer {\n  if (typeof value === 'number') {\n    value = BigInt(value);\n  }\n\n  const isNeg = value \u003c BigInt(0);\n  if (isNeg) {\n    value = -value - BigInt(1);\n  }\n  const byteLength = (value === BigInt(0) ? 0 : Math.ceil(Math.log2(Number(value)))) + 1;\n  const pipe = new Pipe(new ArrayBuffer(byteLength), 0);\n  while (true) {\n    const i = getLowerBytes(value);\n    value /= BigInt(0x80);\n\n    // prettier-ignore\n    if (   ( isNeg \u0026\u0026 value === BigInt(0) \u0026\u0026 (i \u0026 0x40) !== 0)\n          || (!isNeg \u0026\u0026 value === BigInt(0) \u0026\u0026 (i \u0026 0x40) === 0)) {\n        pipe.write(new Uint8Array([i]));\n        break;\n      } else {\n        pipe.write(new Uint8Array([i | 0x80]));\n      }\n  }\n\n  function getLowerBytes(num: bigint): number {\n    const bytes = num % BigInt(0x80);\n    if (isNeg) {\n      // We swap the bits here again, and remove 1 to do two's complement.\n      return Number(BigInt(0x80) - bytes - BigInt(1));\n    } else {\n      return Number(bytes);\n    }\n  }\n  return pipe.buffer;\n}\n\n/**\n * Decode a leb encoded buffer into a bigint. The number is decoded with support for negative\n * signed-leb encoding.\n * @param pipe A Buffer containing the signed leb encoded bits.\n */\nexport function slebDecode(pipe: Pipe): bigint {\n  // Get the size of the buffer, then cut a buffer of that size.\n  const pipeView = new Uint8Array(pipe.buffer);\n  let len = 0;\n  for (; len \u003c pipeView.byteLength; len++) {\n    if (pipeView[len] \u003c 0x80) {\n      // If it's a positive number, we reuse lebDecode.\n      if ((pipeView[len] \u0026 0x40) === 0) {\n        return lebDecode(pipe);\n      }\n      break;\n    }\n  }\n\n  const bytes = new Uint8Array(safeRead(pipe, len + 1));\n  let value = BigInt(0);\n  for (let i = bytes.byteLength - 1; i \u003e= 0; i--) {\n    value = value * BigInt(0x80) + BigInt(0x80 - (bytes[i] \u0026 0x7f) - 1);\n  }\n  return -value - BigInt(1);\n}\n\n/**\n *\n * @param value bigint or number\n * @param byteLength number\n * @returns Buffer\n */\nexport function writeUIntLE(value: bigint | number, byteLength: number): ArrayBuffer {\n  if (BigInt(value) \u003c BigInt(0)) {\n    throw new Error('Cannot write negative values.');\n  }\n  return writeIntLE(value, byteLength);\n}\n\n/**\n *\n * @param value - bigint or number\n * @param byteLength - number\n * @returns ArrayBuffer\n */\nexport function writeIntLE(value: bigint | number, byteLength: number): ArrayBuffer {\n  value = BigInt(value);\n\n  const pipe = new Pipe(new ArrayBuffer(Math.min(1, byteLength)), 0);\n  let i = 0;\n  let mul = BigInt(256);\n  let sub = BigInt(0);\n  let byte = Number(value % mul);\n  pipe.write(new Uint8Array([byte]));\n  while (++i \u003c byteLength) {\n    if (value \u003c 0 \u0026\u0026 sub === BigInt(0) \u0026\u0026 byte !== 0) {\n      sub = BigInt(1);\n    }\n    byte = Number((value / mul - sub) % BigInt(256));\n    pipe.write(new Uint8Array([byte]));\n    mul *= BigInt(256);\n  }\n\n  return pipe.buffer;\n}\n\n/**\n *\n * @param pipe Pipe from buffer-pipe\n * @param byteLength number\n * @returns bigint\n */\nexport function readUIntLE(pipe: Pipe, byteLength: number): bigint {\n  let val = BigInt(safeReadUint8(pipe));\n  let mul = BigInt(1);\n  let i = 0;\n  while (++i \u003c byteLength) {\n    mul *= BigInt(256);\n    const byte = BigInt(safeReadUint8(pipe));\n    val = val + mul * byte;\n  }\n  return val;\n}\n\n/**\n *\n * @param pipe Pipe from buffer-pipe\n * @param byteLength number\n * @returns bigint\n */\nexport function readIntLE(pipe: Pipe, byteLength: number): bigint {\n  let val = readUIntLE(pipe, byteLength);\n  const mul = BigInt(2) ** (BigInt(8) * BigInt(byteLength - 1) + BigInt(7));\n  if (val \u003e= mul) {\n    val -= mul * BigInt(2);\n  }\n  return val;\n}\n","/**\n * Equivalent to `Math.log2(n)` with support for `BigInt` values\n * @param n bigint or integer\n * @returns integer\n */\nexport function ilog2(n: bigint | number): number {\n  const nBig = BigInt(n);\n  if (n \u003c= 0) {\n    throw new RangeError('Input must be positive');\n  }\n  return nBig.toString(2).length - 1;\n}\n\n/**\n * Equivalent to `2 ** n` with support for `BigInt` values\n * (necessary for browser preprocessors which replace the `**` operator with `Math.pow`)\n * @param n bigint or integer\n * @returns bigint\n */\nexport function iexp2(n: bigint | number): bigint {\n  const nBig = BigInt(n);\n  if (n \u003c 0) {\n    throw new RangeError('Input must be non-negative');\n  }\n  return BigInt(1) \u003c\u003c nBig;\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/no-unused-vars */\nimport * as IDL from './idl';\nimport { Principal } from '@dfinity/principal';\nimport * as UI from './candid-core';\n\ntype InputBox = UI.InputBox;\n\nconst InputConfig: UI.UIConfig = { parse: parsePrimitive };\nconst FormConfig: UI.FormConfig = { render: renderInput };\n\nexport const inputBox = (t: IDL.Type, config: Partial\u003cUI.UIConfig\u003e) =\u003e {\n  return new UI.InputBox(t, { ...InputConfig, ...config });\n};\nexport const recordForm = (fields: Array\u003c[string, IDL.Type]\u003e, config: Partial\u003cUI.FormConfig\u003e) =\u003e {\n  return new UI.RecordForm(fields, { ...FormConfig, ...config });\n};\nexport const tupleForm = (components: IDL.Type[], config: Partial\u003cUI.FormConfig\u003e) =\u003e {\n  return new UI.TupleForm(components, { ...FormConfig, ...config });\n};\nexport const variantForm = (fields: Array\u003c[string, IDL.Type]\u003e, config: Partial\u003cUI.FormConfig\u003e) =\u003e {\n  return new UI.VariantForm(fields, { ...FormConfig, ...config });\n};\nexport const optForm = (ty: IDL.Type, config: Partial\u003cUI.FormConfig\u003e) =\u003e {\n  return new UI.OptionForm(ty, { ...FormConfig, ...config });\n};\nexport const vecForm = (ty: IDL.Type, config: Partial\u003cUI.FormConfig\u003e) =\u003e {\n  return new UI.VecForm(ty, { ...FormConfig, ...config });\n};\n\nexport class Render extends IDL.Visitor\u003cnull, InputBox\u003e {\n  public visitType\u003cT\u003e(t: IDL.Type\u003cT\u003e, d: null): InputBox {\n    const input = document.createElement('input');\n    input.classList.add('argument');\n    input.placeholder = t.display();\n    return inputBox(t, { input });\n  }\n  public visitNull(t: IDL.NullClass, d: null): InputBox {\n    return inputBox(t, {});\n  }\n  public visitRecord(t: IDL.RecordClass, fields: Array\u003c[string, IDL.Type]\u003e, d: null): InputBox {\n    let config = {};\n    if (fields.length \u003e 1) {\n      const container = document.createElement('div');\n      container.classList.add('popup-form');\n      config = { container };\n    }\n    const form = recordForm(fields, config);\n    return inputBox(t, { form });\n  }\n  public visitTuple\u003cT extends any[]\u003e(\n    t: IDL.TupleClass\u003cT\u003e,\n    components: IDL.Type[],\n    d: null,\n  ): InputBox {\n    let config = {};\n    if (components.length \u003e 1) {\n      const container = document.createElement('div');\n      container.classList.add('popup-form');\n      config = { container };\n    }\n    const form = tupleForm(components, config);\n    return inputBox(t, { form });\n  }\n  public visitVariant(t: IDL.VariantClass, fields: Array\u003c[string, IDL.Type]\u003e, d: null): InputBox {\n    const select = document.createElement('select');\n    for (const [key, type] of fields) {\n      const option = new Option(key);\n      select.add(option);\n    }\n    select.selectedIndex = -1;\n    select.classList.add('open');\n    const config: Partial\u003cUI.FormConfig\u003e = { open: select, event: 'change' };\n    const form = variantForm(fields, config);\n    return inputBox(t, { form });\n  }\n  public visitOpt\u003cT\u003e(t: IDL.OptClass\u003cT\u003e, ty: IDL.Type\u003cT\u003e, d: null): InputBox {\n    const checkbox = document.createElement('input');\n    checkbox.type = 'checkbox';\n    checkbox.classList.add('open');\n    const form = optForm(ty, { open: checkbox, event: 'change' });\n    return inputBox(t, { form });\n  }\n  public visitVec\u003cT\u003e(t: IDL.VecClass\u003cT\u003e, ty: IDL.Type\u003cT\u003e, d: null): InputBox {\n    const len = document.createElement('input');\n    len.type = 'number';\n    len.min = '0';\n    len.max = '100';\n    len.style.width = '8rem';\n    len.placeholder = 'len';\n    len.classList.add('open');\n    const container = document.createElement('div');\n    container.classList.add('popup-form');\n    const form = vecForm(ty, { open: len, event: 'change', container });\n    return inputBox(t, { form });\n  }\n  public visitRec\u003cT\u003e(t: IDL.RecClass\u003cT\u003e, ty: IDL.ConstructType\u003cT\u003e, d: null): InputBox {\n    return renderInput(ty);\n  }\n}\n\nclass Parse extends IDL.Visitor\u003cstring, any\u003e {\n  public visitNull(t: IDL.NullClass, v: string): null {\n    return null;\n  }\n  public visitBool(t: IDL.BoolClass, v: string): boolean {\n    if (v === 'true') {\n      return true;\n    }\n    if (v === 'false') {\n      return false;\n    }\n    throw new Error(`Cannot parse ${v} as boolean`);\n  }\n  public visitText(t: IDL.TextClass, v: string): string {\n    return v;\n  }\n  public visitFloat(t: IDL.FloatClass, v: string): number {\n    return parseFloat(v);\n  }\n  public visitFixedInt(t: IDL.FixedIntClass, v: string): number | bigint {\n    if (t._bits \u003c= 32) {\n      return parseInt(v, 10);\n    } else {\n      return BigInt(v);\n    }\n  }\n  public visitFixedNat(t: IDL.FixedNatClass, v: string): number | bigint {\n    if (t._bits \u003c= 32) {\n      return parseInt(v, 10);\n    } else {\n      return BigInt(v);\n    }\n  }\n  public visitNumber(t: IDL.PrimitiveType, v: string): bigint {\n    return BigInt(v);\n  }\n  public visitPrincipal(t: IDL.PrincipalClass, v: string): Principal {\n    return Principal.fromText(v);\n  }\n  public visitService(t: IDL.ServiceClass, v: string): Principal {\n    return Principal.fromText(v);\n  }\n  public visitFunc(t: IDL.FuncClass, v: string): [Principal, string] {\n    const x = v.split('.', 2);\n    return [Principal.fromText(x[0]), x[1]];\n  }\n}\n\nclass Random extends IDL.Visitor\u003cstring, any\u003e {\n  public visitNull(t: IDL.NullClass, v: string): null {\n    return null;\n  }\n  public visitBool(t: IDL.BoolClass, v: string): boolean {\n    return Math.random() \u003c 0.5;\n  }\n  public visitText(t: IDL.TextClass, v: string): string {\n    return Math.random().toString(36).substring(6);\n  }\n  public visitFloat(t: IDL.FloatClass, v: string): number {\n    return Math.random();\n  }\n  public visitInt(t: IDL.IntClass, v: string): bigint {\n    return BigInt(this.generateNumber(true));\n  }\n  public visitNat(t: IDL.NatClass, v: string): bigint {\n    return BigInt(this.generateNumber(false));\n  }\n  public visitFixedInt(t: IDL.FixedIntClass, v: string): number | bigint {\n    const x = this.generateNumber(true);\n    if (t._bits \u003c= 32) {\n      return x;\n    } else {\n      return BigInt(v);\n    }\n  }\n  public visitFixedNat(t: IDL.FixedNatClass, v: string): number | bigint {\n    const x = this.generateNumber(false);\n    if (t._bits \u003c= 32) {\n      return x;\n    } else {\n      return BigInt(v);\n    }\n  }\n  private generateNumber(signed: boolean): number {\n    const num = Math.floor(Math.random() * 100);\n    if (signed \u0026\u0026 Math.random() \u003c 0.5) {\n      return -num;\n    } else {\n      return num;\n    }\n  }\n}\n\nfunction parsePrimitive(t: IDL.Type, config: UI.ParseConfig, d: string) {\n  if (config.random \u0026\u0026 d === '') {\n    return t.accept(new Random(), d);\n  } else {\n    return t.accept(new Parse(), d);\n  }\n}\n\n/**\n *\n * @param t an IDL type\n * @returns an input for that type\n */\nexport function renderInput(t: IDL.Type): InputBox {\n  return t.accept(new Render(), null);\n}\n\ninterface ValueConfig {\n  input: InputBox;\n  value: any;\n}\n\n/**\n *\n * @param t an IDL Type\n * @param input an InputBox\n * @param value any\n * @returns rendering that value to the provided input\n */\nexport function renderValue(t: IDL.Type, input: InputBox, value: any) {\n  return t.accept(new RenderValue(), { input, value });\n}\n\nclass RenderValue extends IDL.Visitor\u003cValueConfig, void\u003e {\n  public visitType\u003cT\u003e(t: IDL.Type\u003cT\u003e, d: ValueConfig) {\n    (d.input.ui.input as HTMLInputElement).value = t.valueToString(d.value);\n  }\n  // eslint-disable-next-line @typescript-eslint/no-empty-function\n  public visitNull(t: IDL.NullClass, d: ValueConfig) {}\n  public visitText(t: IDL.TextClass, d: ValueConfig) {\n    (d.input.ui.input as HTMLInputElement).value = d.value;\n  }\n  public visitRec\u003cT\u003e(t: IDL.RecClass\u003cT\u003e, ty: IDL.ConstructType\u003cT\u003e, d: ValueConfig) {\n    renderValue(ty, d.input, d.value);\n  }\n  public visitOpt\u003cT\u003e(t: IDL.OptClass\u003cT\u003e, ty: IDL.Type\u003cT\u003e, d: ValueConfig) {\n    if (d.value.length === 0) {\n      return;\n    } else {\n      const form = d.input.ui.form!;\n      const open = form.ui.open as HTMLInputElement;\n      open.checked = true;\n      open.dispatchEvent(new Event(form.ui.event!));\n      renderValue(ty, form.form[0], d.value[0]);\n    }\n  }\n  public visitRecord(t: IDL.RecordClass, fields: Array\u003c[string, IDL.Type]\u003e, d: ValueConfig) {\n    const form = d.input.ui.form!;\n    fields.forEach(([key, type], i) =\u003e {\n      renderValue(type, form.form[i], d.value[key]);\n    });\n  }\n  public visitTuple\u003cT extends any[]\u003e(t: IDL.TupleClass\u003cT\u003e, components: IDL.Type[], d: ValueConfig) {\n    const form = d.input.ui.form!;\n    components.forEach((type, i) =\u003e {\n      renderValue(type, form.form[i], d.value[i]);\n    });\n  }\n  public visitVariant(t: IDL.VariantClass, fields: Array\u003c[string, IDL.Type]\u003e, d: ValueConfig) {\n    const form = d.input.ui.form!;\n    const selected = Object.entries(d.value)[0];\n    fields.forEach(([key, type], i) =\u003e {\n      if (key === selected[0]) {\n        const open = form.ui.open as HTMLSelectElement;\n        open.selectedIndex = i;\n        open.dispatchEvent(new Event(form.ui.event!));\n        renderValue(type, form.form[0], selected[1]);\n      }\n    });\n  }\n  public visitVec\u003cT\u003e(t: IDL.VecClass\u003cT\u003e, ty: IDL.Type\u003cT\u003e, d: ValueConfig) {\n    const form = d.input.ui.form!;\n    const len = d.value.length;\n    const open = form.ui.open as HTMLInputElement;\n    open.value = len;\n    open.dispatchEvent(new Event(form.ui.event!));\n    d.value.forEach((v: T, i: number) =\u003e {\n      renderValue(ty, form.form[i], v);\n    });\n  }\n}\n","/* eslint-disable @typescript-eslint/no-unused-vars */\n/* eslint-disable @typescript-eslint/no-this-alias */\n/* eslint-disable @typescript-eslint/no-explicit-any */\nimport * as IDL from './idl';\n\nexport interface ParseConfig {\n  random?: boolean;\n}\n\nexport interface UIConfig {\n  input?: HTMLElement;\n  form?: InputForm;\n  parse(t: IDL.Type, config: ParseConfig, v: string): any;\n}\n\nexport interface FormConfig {\n  open?: HTMLElement;\n  event?: string;\n  labelMap?: Record\u003cstring, string\u003e;\n  container?: HTMLElement;\n  render(t: IDL.Type): InputBox;\n}\n\nexport class InputBox {\n  public status: HTMLElement;\n  public label: string | null = null;\n  public value: any = undefined;\n\n  constructor(public idl: IDL.Type, public ui: UIConfig) {\n    const status = document.createElement('span');\n    status.className = 'status';\n    this.status = status;\n\n    if (ui.input) {\n      ui.input.addEventListener('blur', () =\u003e {\n        if ((ui.input as HTMLInputElement).value === '') {\n          return;\n        }\n        this.parse();\n      });\n      ui.input.addEventListener('input', () =\u003e {\n        status.style.display = 'none';\n        ui.input!.classList.remove('reject');\n      });\n    }\n  }\n  public isRejected(): boolean {\n    return this.value === undefined;\n  }\n\n  public parse(config: ParseConfig = {}): any {\n    if (this.ui.form) {\n      const value = this.ui.form.parse(config);\n      this.value = value;\n      return value;\n    }\n\n    if (this.ui.input) {\n      const input = this.ui.input as HTMLInputElement;\n      try {\n        const value = this.ui.parse(this.idl, config, input.value);\n        if (!this.idl.covariant(value)) {\n          throw new Error(`${input.value} is not of type ${this.idl.display()}`);\n        }\n        this.status.style.display = 'none';\n        this.value = value;\n        return value;\n      } catch (err) {\n        input.classList.add('reject');\n        this.status.style.display = 'block';\n        this.status.innerHTML = 'InputError: ' + (err as Error).message;\n        this.value = undefined;\n        return undefined;\n      }\n    }\n    return null;\n  }\n  public render(dom: HTMLElement): void {\n    const container = document.createElement('span');\n    if (this.label) {\n      const label = document.createElement('label');\n      label.innerText = this.label;\n      container.appendChild(label);\n    }\n    if (this.ui.input) {\n      container.appendChild(this.ui.input);\n      container.appendChild(this.status);\n    }\n\n    if (this.ui.form) {\n      this.ui.form.render(container);\n    }\n    dom.appendChild(container);\n  }\n}\n\nexport abstract class InputForm {\n  public form: InputBox[] = [];\n  constructor(public ui: FormConfig) {}\n\n  public abstract parse(config: ParseConfig): any;\n  public abstract generateForm(): any;\n  public renderForm(dom: HTMLElement): void {\n    if (this.ui.container) {\n      this.form.forEach(e =\u003e e.render(this.ui.container!));\n      dom.appendChild(this.ui.container);\n    } else {\n      this.form.forEach(e =\u003e e.render(dom));\n    }\n  }\n  public render(dom: HTMLElement): void {\n    if (this.ui.open \u0026\u0026 this.ui.event) {\n      dom.appendChild(this.ui.open);\n      const form = this;\n      // eslint-disable-next-line\n      form.ui.open!.addEventListener(form.ui.event!, () =\u003e {\n        // Remove old form\n        if (form.ui.container) {\n          form.ui.container.innerHTML = '';\n        } else {\n          const oldContainer = form.ui.open!.nextElementSibling;\n          if (oldContainer) {\n            oldContainer.parentNode!.removeChild(oldContainer);\n          }\n        }\n        // Render form\n        form.generateForm();\n        form.renderForm(dom);\n      });\n    } else {\n      this.generateForm();\n      this.renderForm(dom);\n    }\n  }\n}\n\nexport class RecordForm extends InputForm {\n  constructor(public fields: Array\u003c[string, IDL.Type]\u003e, public ui: FormConfig) {\n    super(ui);\n  }\n  public generateForm(): void {\n    this.form = this.fields.map(([key, type]) =\u003e {\n      const input = this.ui.render(type);\n      // eslint-disable-next-line\n      if (this.ui.labelMap \u0026\u0026 this.ui.labelMap.hasOwnProperty(key)) {\n        input.label = this.ui.labelMap[key] + ' ';\n      } else {\n        input.label = key + ' ';\n      }\n      return input;\n    });\n  }\n  public parse(config: ParseConfig): Record\u003cstring, any\u003e | undefined {\n    const v: Record\u003cstring, any\u003e = {};\n    this.fields.forEach(([key, _], i) =\u003e {\n      const value = this.form[i].parse(config);\n      v[key] = value;\n    });\n    if (this.form.some(input =\u003e input.isRejected())) {\n      return undefined;\n    }\n    return v;\n  }\n}\n\nexport class TupleForm extends InputForm {\n  constructor(public components: IDL.Type[], public ui: FormConfig) {\n    super(ui);\n  }\n  public generateForm(): void {\n    this.form = this.components.map(type =\u003e {\n      const input = this.ui.render(type);\n      return input;\n    });\n  }\n  public parse(config: ParseConfig): any[] | undefined {\n    const v: any[] = [];\n    this.components.forEach((_, i) =\u003e {\n      const value = this.form[i].parse(config);\n      v.push(value);\n    });\n    if (this.form.some(input =\u003e input.isRejected())) {\n      return undefined;\n    }\n    return v;\n  }\n}\n\nexport class VariantForm extends InputForm {\n  constructor(public fields: Array\u003c[string, IDL.Type]\u003e, public ui: FormConfig) {\n    super(ui);\n  }\n  public generateForm(): void {\n    const index = (this.ui.open as HTMLSelectElement).selectedIndex;\n    const [_, type] = this.fields[index];\n    const variant = this.ui.render(type);\n    this.form = [variant];\n  }\n  public parse(config: ParseConfig): Record\u003cstring, any\u003e | undefined {\n    const select = this.ui.open as HTMLSelectElement;\n    const selected = select.options[select.selectedIndex].value;\n    const value = this.form[0].parse(config);\n    if (value === undefined) {\n      return undefined;\n    }\n    const v: Record\u003cstring, any\u003e = {};\n    v[selected] = value;\n    return v;\n  }\n}\n\nexport class OptionForm extends InputForm {\n  constructor(public ty: IDL.Type, public ui: FormConfig) {\n    super(ui);\n  }\n  public generateForm(): void {\n    if ((this.ui.open as HTMLInputElement).checked) {\n      const opt = this.ui.render(this.ty);\n      this.form = [opt];\n    } else {\n      this.form = [];\n    }\n  }\n  public parse\u003cT\u003e(config: ParseConfig): [T] | [] | undefined {\n    if (this.form.length === 0) {\n      return [];\n    } else {\n      const value = this.form[0].parse(config);\n      if (value === undefined) {\n        return undefined;\n      }\n      return [value];\n    }\n  }\n}\n\nexport class VecForm extends InputForm {\n  constructor(public ty: IDL.Type, public ui: FormConfig) {\n    super(ui);\n  }\n  public generateForm(): void {\n    const len = +(this.ui.open as HTMLInputElement).value;\n    this.form = [];\n    for (let i = 0; i \u003c len; i++) {\n      const t = this.ui.render(this.ty);\n      this.form.push(t);\n    }\n  }\n  public parse\u003cT\u003e(config: ParseConfig): T[] | undefined {\n    const value = this.form.map(input =\u003e {\n      return input.parse(config);\n    });\n    if (this.form.some(input =\u003e input.isRejected())) {\n      return undefined;\n    }\n    return value;\n  }\n}\n"],"version":3}