github.com/primecitizens/pcz/std@v0.2.1/plat/js/webext/usb/bindings/ffi_bindings.ts (about) 1 import { importModule, Application, heap, Pointer } from "@ffi"; 2 3 importModule("plat/js/webext/usb", (A: Application) => { 4 const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser; 5 6 return { 7 "constof_TransferType": (ref: heap.Ref<string>): number => { 8 const idx = ["control", "interrupt", "isochronous", "bulk"].indexOf(A.H.get(ref)); 9 return idx < 0 ? 0 : idx + 1; 10 }, 11 "constof_Direction": (ref: heap.Ref<string>): number => { 12 const idx = ["in", "out"].indexOf(A.H.get(ref)); 13 return idx < 0 ? 0 : idx + 1; 14 }, 15 "constof_SynchronizationType": (ref: heap.Ref<string>): number => { 16 const idx = ["asynchronous", "adaptive", "synchronous"].indexOf(A.H.get(ref)); 17 return idx < 0 ? 0 : idx + 1; 18 }, 19 "constof_UsageType": (ref: heap.Ref<string>): number => { 20 const idx = ["data", "feedback", "explicitFeedback", "periodic", "notification"].indexOf(A.H.get(ref)); 21 return idx < 0 ? 0 : idx + 1; 22 }, 23 24 "store_EndpointDescriptor": (ptr: Pointer, ref: heap.Ref<any>) => { 25 const x = A.H.get<any>(ref); 26 27 if (typeof x === "undefined") { 28 A.store.Bool(ptr + 35, false); 29 A.store.Bool(ptr + 32, false); 30 A.store.Int32(ptr + 0, 0); 31 A.store.Enum(ptr + 4, -1); 32 A.store.Enum(ptr + 8, -1); 33 A.store.Bool(ptr + 33, false); 34 A.store.Int32(ptr + 12, 0); 35 A.store.Enum(ptr + 16, -1); 36 A.store.Enum(ptr + 20, -1); 37 A.store.Bool(ptr + 34, false); 38 A.store.Int32(ptr + 24, 0); 39 A.store.Ref(ptr + 28, undefined); 40 } else { 41 A.store.Bool(ptr + 35, true); 42 A.store.Bool(ptr + 32, "address" in x ? true : false); 43 A.store.Int32(ptr + 0, x["address"] === undefined ? 0 : (x["address"] as number)); 44 A.store.Enum(ptr + 4, ["control", "interrupt", "isochronous", "bulk"].indexOf(x["type"] as string)); 45 A.store.Enum(ptr + 8, ["in", "out"].indexOf(x["direction"] as string)); 46 A.store.Bool(ptr + 33, "maximumPacketSize" in x ? true : false); 47 A.store.Int32(ptr + 12, x["maximumPacketSize"] === undefined ? 0 : (x["maximumPacketSize"] as number)); 48 A.store.Enum(ptr + 16, ["asynchronous", "adaptive", "synchronous"].indexOf(x["synchronization"] as string)); 49 A.store.Enum( 50 ptr + 20, 51 ["data", "feedback", "explicitFeedback", "periodic", "notification"].indexOf(x["usage"] as string) 52 ); 53 A.store.Bool(ptr + 34, "pollingInterval" in x ? true : false); 54 A.store.Int32(ptr + 24, x["pollingInterval"] === undefined ? 0 : (x["pollingInterval"] as number)); 55 A.store.Ref(ptr + 28, x["extra_data"]); 56 } 57 }, 58 "load_EndpointDescriptor": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 59 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 60 61 if (A.load.Bool(ptr + 32)) { 62 x["address"] = A.load.Int32(ptr + 0); 63 } else { 64 delete x["address"]; 65 } 66 x["type"] = A.load.Enum(ptr + 4, ["control", "interrupt", "isochronous", "bulk"]); 67 x["direction"] = A.load.Enum(ptr + 8, ["in", "out"]); 68 if (A.load.Bool(ptr + 33)) { 69 x["maximumPacketSize"] = A.load.Int32(ptr + 12); 70 } else { 71 delete x["maximumPacketSize"]; 72 } 73 x["synchronization"] = A.load.Enum(ptr + 16, ["asynchronous", "adaptive", "synchronous"]); 74 x["usage"] = A.load.Enum(ptr + 20, ["data", "feedback", "explicitFeedback", "periodic", "notification"]); 75 if (A.load.Bool(ptr + 34)) { 76 x["pollingInterval"] = A.load.Int32(ptr + 24); 77 } else { 78 delete x["pollingInterval"]; 79 } 80 x["extra_data"] = A.load.Ref(ptr + 28, undefined); 81 return create === A.H.TRUE ? A.H.push(x) : ref; 82 }, 83 84 "store_InterfaceDescriptor": (ptr: Pointer, ref: heap.Ref<any>) => { 85 const x = A.H.get<any>(ref); 86 87 if (typeof x === "undefined") { 88 A.store.Bool(ptr + 37, false); 89 A.store.Bool(ptr + 32, false); 90 A.store.Int32(ptr + 0, 0); 91 A.store.Bool(ptr + 33, false); 92 A.store.Int32(ptr + 4, 0); 93 A.store.Bool(ptr + 34, false); 94 A.store.Int32(ptr + 8, 0); 95 A.store.Bool(ptr + 35, false); 96 A.store.Int32(ptr + 12, 0); 97 A.store.Bool(ptr + 36, false); 98 A.store.Int32(ptr + 16, 0); 99 A.store.Ref(ptr + 20, undefined); 100 A.store.Ref(ptr + 24, undefined); 101 A.store.Ref(ptr + 28, undefined); 102 } else { 103 A.store.Bool(ptr + 37, true); 104 A.store.Bool(ptr + 32, "interfaceNumber" in x ? true : false); 105 A.store.Int32(ptr + 0, x["interfaceNumber"] === undefined ? 0 : (x["interfaceNumber"] as number)); 106 A.store.Bool(ptr + 33, "alternateSetting" in x ? true : false); 107 A.store.Int32(ptr + 4, x["alternateSetting"] === undefined ? 0 : (x["alternateSetting"] as number)); 108 A.store.Bool(ptr + 34, "interfaceClass" in x ? true : false); 109 A.store.Int32(ptr + 8, x["interfaceClass"] === undefined ? 0 : (x["interfaceClass"] as number)); 110 A.store.Bool(ptr + 35, "interfaceSubclass" in x ? true : false); 111 A.store.Int32(ptr + 12, x["interfaceSubclass"] === undefined ? 0 : (x["interfaceSubclass"] as number)); 112 A.store.Bool(ptr + 36, "interfaceProtocol" in x ? true : false); 113 A.store.Int32(ptr + 16, x["interfaceProtocol"] === undefined ? 0 : (x["interfaceProtocol"] as number)); 114 A.store.Ref(ptr + 20, x["description"]); 115 A.store.Ref(ptr + 24, x["endpoints"]); 116 A.store.Ref(ptr + 28, x["extra_data"]); 117 } 118 }, 119 "load_InterfaceDescriptor": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 120 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 121 122 if (A.load.Bool(ptr + 32)) { 123 x["interfaceNumber"] = A.load.Int32(ptr + 0); 124 } else { 125 delete x["interfaceNumber"]; 126 } 127 if (A.load.Bool(ptr + 33)) { 128 x["alternateSetting"] = A.load.Int32(ptr + 4); 129 } else { 130 delete x["alternateSetting"]; 131 } 132 if (A.load.Bool(ptr + 34)) { 133 x["interfaceClass"] = A.load.Int32(ptr + 8); 134 } else { 135 delete x["interfaceClass"]; 136 } 137 if (A.load.Bool(ptr + 35)) { 138 x["interfaceSubclass"] = A.load.Int32(ptr + 12); 139 } else { 140 delete x["interfaceSubclass"]; 141 } 142 if (A.load.Bool(ptr + 36)) { 143 x["interfaceProtocol"] = A.load.Int32(ptr + 16); 144 } else { 145 delete x["interfaceProtocol"]; 146 } 147 x["description"] = A.load.Ref(ptr + 20, undefined); 148 x["endpoints"] = A.load.Ref(ptr + 24, undefined); 149 x["extra_data"] = A.load.Ref(ptr + 28, undefined); 150 return create === A.H.TRUE ? A.H.push(x) : ref; 151 }, 152 153 "store_ConfigDescriptor": (ptr: Pointer, ref: heap.Ref<any>) => { 154 const x = A.H.get<any>(ref); 155 156 if (typeof x === "undefined") { 157 A.store.Bool(ptr + 33, false); 158 A.store.Bool(ptr + 28, false); 159 A.store.Bool(ptr + 0, false); 160 A.store.Bool(ptr + 29, false); 161 A.store.Int32(ptr + 4, 0); 162 A.store.Ref(ptr + 8, undefined); 163 A.store.Bool(ptr + 30, false); 164 A.store.Bool(ptr + 12, false); 165 A.store.Bool(ptr + 31, false); 166 A.store.Bool(ptr + 13, false); 167 A.store.Bool(ptr + 32, false); 168 A.store.Int32(ptr + 16, 0); 169 A.store.Ref(ptr + 20, undefined); 170 A.store.Ref(ptr + 24, undefined); 171 } else { 172 A.store.Bool(ptr + 33, true); 173 A.store.Bool(ptr + 28, "active" in x ? true : false); 174 A.store.Bool(ptr + 0, x["active"] ? true : false); 175 A.store.Bool(ptr + 29, "configurationValue" in x ? true : false); 176 A.store.Int32(ptr + 4, x["configurationValue"] === undefined ? 0 : (x["configurationValue"] as number)); 177 A.store.Ref(ptr + 8, x["description"]); 178 A.store.Bool(ptr + 30, "selfPowered" in x ? true : false); 179 A.store.Bool(ptr + 12, x["selfPowered"] ? true : false); 180 A.store.Bool(ptr + 31, "remoteWakeup" in x ? true : false); 181 A.store.Bool(ptr + 13, x["remoteWakeup"] ? true : false); 182 A.store.Bool(ptr + 32, "maxPower" in x ? true : false); 183 A.store.Int32(ptr + 16, x["maxPower"] === undefined ? 0 : (x["maxPower"] as number)); 184 A.store.Ref(ptr + 20, x["interfaces"]); 185 A.store.Ref(ptr + 24, x["extra_data"]); 186 } 187 }, 188 "load_ConfigDescriptor": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 189 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 190 191 if (A.load.Bool(ptr + 28)) { 192 x["active"] = A.load.Bool(ptr + 0); 193 } else { 194 delete x["active"]; 195 } 196 if (A.load.Bool(ptr + 29)) { 197 x["configurationValue"] = A.load.Int32(ptr + 4); 198 } else { 199 delete x["configurationValue"]; 200 } 201 x["description"] = A.load.Ref(ptr + 8, undefined); 202 if (A.load.Bool(ptr + 30)) { 203 x["selfPowered"] = A.load.Bool(ptr + 12); 204 } else { 205 delete x["selfPowered"]; 206 } 207 if (A.load.Bool(ptr + 31)) { 208 x["remoteWakeup"] = A.load.Bool(ptr + 13); 209 } else { 210 delete x["remoteWakeup"]; 211 } 212 if (A.load.Bool(ptr + 32)) { 213 x["maxPower"] = A.load.Int32(ptr + 16); 214 } else { 215 delete x["maxPower"]; 216 } 217 x["interfaces"] = A.load.Ref(ptr + 20, undefined); 218 x["extra_data"] = A.load.Ref(ptr + 24, undefined); 219 return create === A.H.TRUE ? A.H.push(x) : ref; 220 }, 221 222 "store_ConnectionHandle": (ptr: Pointer, ref: heap.Ref<any>) => { 223 const x = A.H.get<any>(ref); 224 225 if (typeof x === "undefined") { 226 A.store.Bool(ptr + 15, false); 227 A.store.Bool(ptr + 12, false); 228 A.store.Int32(ptr + 0, 0); 229 A.store.Bool(ptr + 13, false); 230 A.store.Int32(ptr + 4, 0); 231 A.store.Bool(ptr + 14, false); 232 A.store.Int32(ptr + 8, 0); 233 } else { 234 A.store.Bool(ptr + 15, true); 235 A.store.Bool(ptr + 12, "handle" in x ? true : false); 236 A.store.Int32(ptr + 0, x["handle"] === undefined ? 0 : (x["handle"] as number)); 237 A.store.Bool(ptr + 13, "vendorId" in x ? true : false); 238 A.store.Int32(ptr + 4, x["vendorId"] === undefined ? 0 : (x["vendorId"] as number)); 239 A.store.Bool(ptr + 14, "productId" in x ? true : false); 240 A.store.Int32(ptr + 8, x["productId"] === undefined ? 0 : (x["productId"] as number)); 241 } 242 }, 243 "load_ConnectionHandle": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 244 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 245 246 if (A.load.Bool(ptr + 12)) { 247 x["handle"] = A.load.Int32(ptr + 0); 248 } else { 249 delete x["handle"]; 250 } 251 if (A.load.Bool(ptr + 13)) { 252 x["vendorId"] = A.load.Int32(ptr + 4); 253 } else { 254 delete x["vendorId"]; 255 } 256 if (A.load.Bool(ptr + 14)) { 257 x["productId"] = A.load.Int32(ptr + 8); 258 } else { 259 delete x["productId"]; 260 } 261 return create === A.H.TRUE ? A.H.push(x) : ref; 262 }, 263 "constof_Recipient": (ref: heap.Ref<string>): number => { 264 const idx = ["device", "_interface", "endpoint", "other"].indexOf(A.H.get(ref)); 265 return idx < 0 ? 0 : idx + 1; 266 }, 267 "constof_RequestType": (ref: heap.Ref<string>): number => { 268 const idx = ["standard", "class", "vendor", "reserved"].indexOf(A.H.get(ref)); 269 return idx < 0 ? 0 : idx + 1; 270 }, 271 272 "store_ControlTransferInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 273 const x = A.H.get<any>(ref); 274 275 if (typeof x === "undefined") { 276 A.store.Bool(ptr + 41, false); 277 A.store.Enum(ptr + 0, -1); 278 A.store.Enum(ptr + 4, -1); 279 A.store.Enum(ptr + 8, -1); 280 A.store.Bool(ptr + 36, false); 281 A.store.Int32(ptr + 12, 0); 282 A.store.Bool(ptr + 37, false); 283 A.store.Int32(ptr + 16, 0); 284 A.store.Bool(ptr + 38, false); 285 A.store.Int32(ptr + 20, 0); 286 A.store.Bool(ptr + 39, false); 287 A.store.Int32(ptr + 24, 0); 288 A.store.Ref(ptr + 28, undefined); 289 A.store.Bool(ptr + 40, false); 290 A.store.Int32(ptr + 32, 0); 291 } else { 292 A.store.Bool(ptr + 41, true); 293 A.store.Enum(ptr + 0, ["in", "out"].indexOf(x["direction"] as string)); 294 A.store.Enum(ptr + 4, ["device", "_interface", "endpoint", "other"].indexOf(x["recipient"] as string)); 295 A.store.Enum(ptr + 8, ["standard", "class", "vendor", "reserved"].indexOf(x["requestType"] as string)); 296 A.store.Bool(ptr + 36, "request" in x ? true : false); 297 A.store.Int32(ptr + 12, x["request"] === undefined ? 0 : (x["request"] as number)); 298 A.store.Bool(ptr + 37, "value" in x ? true : false); 299 A.store.Int32(ptr + 16, x["value"] === undefined ? 0 : (x["value"] as number)); 300 A.store.Bool(ptr + 38, "index" in x ? true : false); 301 A.store.Int32(ptr + 20, x["index"] === undefined ? 0 : (x["index"] as number)); 302 A.store.Bool(ptr + 39, "length" in x ? true : false); 303 A.store.Int32(ptr + 24, x["length"] === undefined ? 0 : (x["length"] as number)); 304 A.store.Ref(ptr + 28, x["data"]); 305 A.store.Bool(ptr + 40, "timeout" in x ? true : false); 306 A.store.Int32(ptr + 32, x["timeout"] === undefined ? 0 : (x["timeout"] as number)); 307 } 308 }, 309 "load_ControlTransferInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 310 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 311 312 x["direction"] = A.load.Enum(ptr + 0, ["in", "out"]); 313 x["recipient"] = A.load.Enum(ptr + 4, ["device", "_interface", "endpoint", "other"]); 314 x["requestType"] = A.load.Enum(ptr + 8, ["standard", "class", "vendor", "reserved"]); 315 if (A.load.Bool(ptr + 36)) { 316 x["request"] = A.load.Int32(ptr + 12); 317 } else { 318 delete x["request"]; 319 } 320 if (A.load.Bool(ptr + 37)) { 321 x["value"] = A.load.Int32(ptr + 16); 322 } else { 323 delete x["value"]; 324 } 325 if (A.load.Bool(ptr + 38)) { 326 x["index"] = A.load.Int32(ptr + 20); 327 } else { 328 delete x["index"]; 329 } 330 if (A.load.Bool(ptr + 39)) { 331 x["length"] = A.load.Int32(ptr + 24); 332 } else { 333 delete x["length"]; 334 } 335 x["data"] = A.load.Ref(ptr + 28, undefined); 336 if (A.load.Bool(ptr + 40)) { 337 x["timeout"] = A.load.Int32(ptr + 32); 338 } else { 339 delete x["timeout"]; 340 } 341 return create === A.H.TRUE ? A.H.push(x) : ref; 342 }, 343 344 "store_Device": (ptr: Pointer, ref: heap.Ref<any>) => { 345 const x = A.H.get<any>(ref); 346 347 if (typeof x === "undefined") { 348 A.store.Bool(ptr + 32, false); 349 A.store.Bool(ptr + 28, false); 350 A.store.Int32(ptr + 0, 0); 351 A.store.Bool(ptr + 29, false); 352 A.store.Int32(ptr + 4, 0); 353 A.store.Bool(ptr + 30, false); 354 A.store.Int32(ptr + 8, 0); 355 A.store.Bool(ptr + 31, false); 356 A.store.Int32(ptr + 12, 0); 357 A.store.Ref(ptr + 16, undefined); 358 A.store.Ref(ptr + 20, undefined); 359 A.store.Ref(ptr + 24, undefined); 360 } else { 361 A.store.Bool(ptr + 32, true); 362 A.store.Bool(ptr + 28, "device" in x ? true : false); 363 A.store.Int32(ptr + 0, x["device"] === undefined ? 0 : (x["device"] as number)); 364 A.store.Bool(ptr + 29, "vendorId" in x ? true : false); 365 A.store.Int32(ptr + 4, x["vendorId"] === undefined ? 0 : (x["vendorId"] as number)); 366 A.store.Bool(ptr + 30, "productId" in x ? true : false); 367 A.store.Int32(ptr + 8, x["productId"] === undefined ? 0 : (x["productId"] as number)); 368 A.store.Bool(ptr + 31, "version" in x ? true : false); 369 A.store.Int32(ptr + 12, x["version"] === undefined ? 0 : (x["version"] as number)); 370 A.store.Ref(ptr + 16, x["productName"]); 371 A.store.Ref(ptr + 20, x["manufacturerName"]); 372 A.store.Ref(ptr + 24, x["serialNumber"]); 373 } 374 }, 375 "load_Device": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 376 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 377 378 if (A.load.Bool(ptr + 28)) { 379 x["device"] = A.load.Int32(ptr + 0); 380 } else { 381 delete x["device"]; 382 } 383 if (A.load.Bool(ptr + 29)) { 384 x["vendorId"] = A.load.Int32(ptr + 4); 385 } else { 386 delete x["vendorId"]; 387 } 388 if (A.load.Bool(ptr + 30)) { 389 x["productId"] = A.load.Int32(ptr + 8); 390 } else { 391 delete x["productId"]; 392 } 393 if (A.load.Bool(ptr + 31)) { 394 x["version"] = A.load.Int32(ptr + 12); 395 } else { 396 delete x["version"]; 397 } 398 x["productName"] = A.load.Ref(ptr + 16, undefined); 399 x["manufacturerName"] = A.load.Ref(ptr + 20, undefined); 400 x["serialNumber"] = A.load.Ref(ptr + 24, undefined); 401 return create === A.H.TRUE ? A.H.push(x) : ref; 402 }, 403 404 "store_DeviceFilter": (ptr: Pointer, ref: heap.Ref<any>) => { 405 const x = A.H.get<any>(ref); 406 407 if (typeof x === "undefined") { 408 A.store.Bool(ptr + 25, false); 409 A.store.Bool(ptr + 20, false); 410 A.store.Int32(ptr + 0, 0); 411 A.store.Bool(ptr + 21, false); 412 A.store.Int32(ptr + 4, 0); 413 A.store.Bool(ptr + 22, false); 414 A.store.Int32(ptr + 8, 0); 415 A.store.Bool(ptr + 23, false); 416 A.store.Int32(ptr + 12, 0); 417 A.store.Bool(ptr + 24, false); 418 A.store.Int32(ptr + 16, 0); 419 } else { 420 A.store.Bool(ptr + 25, true); 421 A.store.Bool(ptr + 20, "vendorId" in x ? true : false); 422 A.store.Int32(ptr + 0, x["vendorId"] === undefined ? 0 : (x["vendorId"] as number)); 423 A.store.Bool(ptr + 21, "productId" in x ? true : false); 424 A.store.Int32(ptr + 4, x["productId"] === undefined ? 0 : (x["productId"] as number)); 425 A.store.Bool(ptr + 22, "interfaceClass" in x ? true : false); 426 A.store.Int32(ptr + 8, x["interfaceClass"] === undefined ? 0 : (x["interfaceClass"] as number)); 427 A.store.Bool(ptr + 23, "interfaceSubclass" in x ? true : false); 428 A.store.Int32(ptr + 12, x["interfaceSubclass"] === undefined ? 0 : (x["interfaceSubclass"] as number)); 429 A.store.Bool(ptr + 24, "interfaceProtocol" in x ? true : false); 430 A.store.Int32(ptr + 16, x["interfaceProtocol"] === undefined ? 0 : (x["interfaceProtocol"] as number)); 431 } 432 }, 433 "load_DeviceFilter": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 434 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 435 436 if (A.load.Bool(ptr + 20)) { 437 x["vendorId"] = A.load.Int32(ptr + 0); 438 } else { 439 delete x["vendorId"]; 440 } 441 if (A.load.Bool(ptr + 21)) { 442 x["productId"] = A.load.Int32(ptr + 4); 443 } else { 444 delete x["productId"]; 445 } 446 if (A.load.Bool(ptr + 22)) { 447 x["interfaceClass"] = A.load.Int32(ptr + 8); 448 } else { 449 delete x["interfaceClass"]; 450 } 451 if (A.load.Bool(ptr + 23)) { 452 x["interfaceSubclass"] = A.load.Int32(ptr + 12); 453 } else { 454 delete x["interfaceSubclass"]; 455 } 456 if (A.load.Bool(ptr + 24)) { 457 x["interfaceProtocol"] = A.load.Int32(ptr + 16); 458 } else { 459 delete x["interfaceProtocol"]; 460 } 461 return create === A.H.TRUE ? A.H.push(x) : ref; 462 }, 463 464 "store_DevicePromptOptions": (ptr: Pointer, ref: heap.Ref<any>) => { 465 const x = A.H.get<any>(ref); 466 467 if (typeof x === "undefined") { 468 A.store.Bool(ptr + 9, false); 469 A.store.Bool(ptr + 8, false); 470 A.store.Bool(ptr + 0, false); 471 A.store.Ref(ptr + 4, undefined); 472 } else { 473 A.store.Bool(ptr + 9, true); 474 A.store.Bool(ptr + 8, "multiple" in x ? true : false); 475 A.store.Bool(ptr + 0, x["multiple"] ? true : false); 476 A.store.Ref(ptr + 4, x["filters"]); 477 } 478 }, 479 "load_DevicePromptOptions": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 480 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 481 482 if (A.load.Bool(ptr + 8)) { 483 x["multiple"] = A.load.Bool(ptr + 0); 484 } else { 485 delete x["multiple"]; 486 } 487 x["filters"] = A.load.Ref(ptr + 4, undefined); 488 return create === A.H.TRUE ? A.H.push(x) : ref; 489 }, 490 491 "store_EnumerateDevicesAndRequestAccessOptions": (ptr: Pointer, ref: heap.Ref<any>) => { 492 const x = A.H.get<any>(ref); 493 494 if (typeof x === "undefined") { 495 A.store.Bool(ptr + 15, false); 496 A.store.Bool(ptr + 12, false); 497 A.store.Int32(ptr + 0, 0); 498 A.store.Bool(ptr + 13, false); 499 A.store.Int32(ptr + 4, 0); 500 A.store.Bool(ptr + 14, false); 501 A.store.Int32(ptr + 8, 0); 502 } else { 503 A.store.Bool(ptr + 15, true); 504 A.store.Bool(ptr + 12, "vendorId" in x ? true : false); 505 A.store.Int32(ptr + 0, x["vendorId"] === undefined ? 0 : (x["vendorId"] as number)); 506 A.store.Bool(ptr + 13, "productId" in x ? true : false); 507 A.store.Int32(ptr + 4, x["productId"] === undefined ? 0 : (x["productId"] as number)); 508 A.store.Bool(ptr + 14, "interfaceId" in x ? true : false); 509 A.store.Int32(ptr + 8, x["interfaceId"] === undefined ? 0 : (x["interfaceId"] as number)); 510 } 511 }, 512 "load_EnumerateDevicesAndRequestAccessOptions": ( 513 ptr: Pointer, 514 create: heap.Ref<boolean>, 515 ref: heap.Ref<any> 516 ): heap.Ref<any> => { 517 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 518 519 if (A.load.Bool(ptr + 12)) { 520 x["vendorId"] = A.load.Int32(ptr + 0); 521 } else { 522 delete x["vendorId"]; 523 } 524 if (A.load.Bool(ptr + 13)) { 525 x["productId"] = A.load.Int32(ptr + 4); 526 } else { 527 delete x["productId"]; 528 } 529 if (A.load.Bool(ptr + 14)) { 530 x["interfaceId"] = A.load.Int32(ptr + 8); 531 } else { 532 delete x["interfaceId"]; 533 } 534 return create === A.H.TRUE ? A.H.push(x) : ref; 535 }, 536 537 "store_EnumerateDevicesOptions": (ptr: Pointer, ref: heap.Ref<any>) => { 538 const x = A.H.get<any>(ref); 539 540 if (typeof x === "undefined") { 541 A.store.Bool(ptr + 14, false); 542 A.store.Bool(ptr + 12, false); 543 A.store.Int32(ptr + 0, 0); 544 A.store.Bool(ptr + 13, false); 545 A.store.Int32(ptr + 4, 0); 546 A.store.Ref(ptr + 8, undefined); 547 } else { 548 A.store.Bool(ptr + 14, true); 549 A.store.Bool(ptr + 12, "vendorId" in x ? true : false); 550 A.store.Int32(ptr + 0, x["vendorId"] === undefined ? 0 : (x["vendorId"] as number)); 551 A.store.Bool(ptr + 13, "productId" in x ? true : false); 552 A.store.Int32(ptr + 4, x["productId"] === undefined ? 0 : (x["productId"] as number)); 553 A.store.Ref(ptr + 8, x["filters"]); 554 } 555 }, 556 "load_EnumerateDevicesOptions": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 557 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 558 559 if (A.load.Bool(ptr + 12)) { 560 x["vendorId"] = A.load.Int32(ptr + 0); 561 } else { 562 delete x["vendorId"]; 563 } 564 if (A.load.Bool(ptr + 13)) { 565 x["productId"] = A.load.Int32(ptr + 4); 566 } else { 567 delete x["productId"]; 568 } 569 x["filters"] = A.load.Ref(ptr + 8, undefined); 570 return create === A.H.TRUE ? A.H.push(x) : ref; 571 }, 572 573 "store_GenericTransferInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 574 const x = A.H.get<any>(ref); 575 576 if (typeof x === "undefined") { 577 A.store.Bool(ptr + 23, false); 578 A.store.Enum(ptr + 0, -1); 579 A.store.Bool(ptr + 20, false); 580 A.store.Int32(ptr + 4, 0); 581 A.store.Bool(ptr + 21, false); 582 A.store.Int32(ptr + 8, 0); 583 A.store.Ref(ptr + 12, undefined); 584 A.store.Bool(ptr + 22, false); 585 A.store.Int32(ptr + 16, 0); 586 } else { 587 A.store.Bool(ptr + 23, true); 588 A.store.Enum(ptr + 0, ["in", "out"].indexOf(x["direction"] as string)); 589 A.store.Bool(ptr + 20, "endpoint" in x ? true : false); 590 A.store.Int32(ptr + 4, x["endpoint"] === undefined ? 0 : (x["endpoint"] as number)); 591 A.store.Bool(ptr + 21, "length" in x ? true : false); 592 A.store.Int32(ptr + 8, x["length"] === undefined ? 0 : (x["length"] as number)); 593 A.store.Ref(ptr + 12, x["data"]); 594 A.store.Bool(ptr + 22, "timeout" in x ? true : false); 595 A.store.Int32(ptr + 16, x["timeout"] === undefined ? 0 : (x["timeout"] as number)); 596 } 597 }, 598 "load_GenericTransferInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 599 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 600 601 x["direction"] = A.load.Enum(ptr + 0, ["in", "out"]); 602 if (A.load.Bool(ptr + 20)) { 603 x["endpoint"] = A.load.Int32(ptr + 4); 604 } else { 605 delete x["endpoint"]; 606 } 607 if (A.load.Bool(ptr + 21)) { 608 x["length"] = A.load.Int32(ptr + 8); 609 } else { 610 delete x["length"]; 611 } 612 x["data"] = A.load.Ref(ptr + 12, undefined); 613 if (A.load.Bool(ptr + 22)) { 614 x["timeout"] = A.load.Int32(ptr + 16); 615 } else { 616 delete x["timeout"]; 617 } 618 return create === A.H.TRUE ? A.H.push(x) : ref; 619 }, 620 621 "store_IsochronousTransferInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 622 const x = A.H.get<any>(ref); 623 624 if (typeof x === "undefined") { 625 A.store.Bool(ptr + 34, false); 626 627 A.store.Bool(ptr + 0 + 23, false); 628 A.store.Enum(ptr + 0 + 0, -1); 629 A.store.Bool(ptr + 0 + 20, false); 630 A.store.Int32(ptr + 0 + 4, 0); 631 A.store.Bool(ptr + 0 + 21, false); 632 A.store.Int32(ptr + 0 + 8, 0); 633 A.store.Ref(ptr + 0 + 12, undefined); 634 A.store.Bool(ptr + 0 + 22, false); 635 A.store.Int32(ptr + 0 + 16, 0); 636 A.store.Bool(ptr + 32, false); 637 A.store.Int32(ptr + 24, 0); 638 A.store.Bool(ptr + 33, false); 639 A.store.Int32(ptr + 28, 0); 640 } else { 641 A.store.Bool(ptr + 34, true); 642 643 if (typeof x["transferInfo"] === "undefined") { 644 A.store.Bool(ptr + 0 + 23, false); 645 A.store.Enum(ptr + 0 + 0, -1); 646 A.store.Bool(ptr + 0 + 20, false); 647 A.store.Int32(ptr + 0 + 4, 0); 648 A.store.Bool(ptr + 0 + 21, false); 649 A.store.Int32(ptr + 0 + 8, 0); 650 A.store.Ref(ptr + 0 + 12, undefined); 651 A.store.Bool(ptr + 0 + 22, false); 652 A.store.Int32(ptr + 0 + 16, 0); 653 } else { 654 A.store.Bool(ptr + 0 + 23, true); 655 A.store.Enum(ptr + 0 + 0, ["in", "out"].indexOf(x["transferInfo"]["direction"] as string)); 656 A.store.Bool(ptr + 0 + 20, "endpoint" in x["transferInfo"] ? true : false); 657 A.store.Int32( 658 ptr + 0 + 4, 659 x["transferInfo"]["endpoint"] === undefined ? 0 : (x["transferInfo"]["endpoint"] as number) 660 ); 661 A.store.Bool(ptr + 0 + 21, "length" in x["transferInfo"] ? true : false); 662 A.store.Int32( 663 ptr + 0 + 8, 664 x["transferInfo"]["length"] === undefined ? 0 : (x["transferInfo"]["length"] as number) 665 ); 666 A.store.Ref(ptr + 0 + 12, x["transferInfo"]["data"]); 667 A.store.Bool(ptr + 0 + 22, "timeout" in x["transferInfo"] ? true : false); 668 A.store.Int32( 669 ptr + 0 + 16, 670 x["transferInfo"]["timeout"] === undefined ? 0 : (x["transferInfo"]["timeout"] as number) 671 ); 672 } 673 A.store.Bool(ptr + 32, "packets" in x ? true : false); 674 A.store.Int32(ptr + 24, x["packets"] === undefined ? 0 : (x["packets"] as number)); 675 A.store.Bool(ptr + 33, "packetLength" in x ? true : false); 676 A.store.Int32(ptr + 28, x["packetLength"] === undefined ? 0 : (x["packetLength"] as number)); 677 } 678 }, 679 "load_IsochronousTransferInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 680 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 681 682 if (A.load.Bool(ptr + 0 + 23)) { 683 x["transferInfo"] = {}; 684 x["transferInfo"]["direction"] = A.load.Enum(ptr + 0 + 0, ["in", "out"]); 685 if (A.load.Bool(ptr + 0 + 20)) { 686 x["transferInfo"]["endpoint"] = A.load.Int32(ptr + 0 + 4); 687 } else { 688 delete x["transferInfo"]["endpoint"]; 689 } 690 if (A.load.Bool(ptr + 0 + 21)) { 691 x["transferInfo"]["length"] = A.load.Int32(ptr + 0 + 8); 692 } else { 693 delete x["transferInfo"]["length"]; 694 } 695 x["transferInfo"]["data"] = A.load.Ref(ptr + 0 + 12, undefined); 696 if (A.load.Bool(ptr + 0 + 22)) { 697 x["transferInfo"]["timeout"] = A.load.Int32(ptr + 0 + 16); 698 } else { 699 delete x["transferInfo"]["timeout"]; 700 } 701 } else { 702 delete x["transferInfo"]; 703 } 704 if (A.load.Bool(ptr + 32)) { 705 x["packets"] = A.load.Int32(ptr + 24); 706 } else { 707 delete x["packets"]; 708 } 709 if (A.load.Bool(ptr + 33)) { 710 x["packetLength"] = A.load.Int32(ptr + 28); 711 } else { 712 delete x["packetLength"]; 713 } 714 return create === A.H.TRUE ? A.H.push(x) : ref; 715 }, 716 717 "store_TransferResultInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 718 const x = A.H.get<any>(ref); 719 720 if (typeof x === "undefined") { 721 A.store.Bool(ptr + 9, false); 722 A.store.Bool(ptr + 8, false); 723 A.store.Int32(ptr + 0, 0); 724 A.store.Ref(ptr + 4, undefined); 725 } else { 726 A.store.Bool(ptr + 9, true); 727 A.store.Bool(ptr + 8, "resultCode" in x ? true : false); 728 A.store.Int32(ptr + 0, x["resultCode"] === undefined ? 0 : (x["resultCode"] as number)); 729 A.store.Ref(ptr + 4, x["data"]); 730 } 731 }, 732 "load_TransferResultInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 733 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 734 735 if (A.load.Bool(ptr + 8)) { 736 x["resultCode"] = A.load.Int32(ptr + 0); 737 } else { 738 delete x["resultCode"]; 739 } 740 x["data"] = A.load.Ref(ptr + 4, undefined); 741 return create === A.H.TRUE ? A.H.push(x) : ref; 742 }, 743 "has_BulkTransfer": (): heap.Ref<boolean> => { 744 if (WEBEXT?.usb && "bulkTransfer" in WEBEXT?.usb) { 745 return A.H.TRUE; 746 } 747 return A.H.FALSE; 748 }, 749 "func_BulkTransfer": (fn: Pointer): void => { 750 A.store.Ref(fn, WEBEXT.usb.bulkTransfer); 751 }, 752 "call_BulkTransfer": (retPtr: Pointer, handle: Pointer, transferInfo: Pointer): void => { 753 const handle_ffi = {}; 754 755 if (A.load.Bool(handle + 12)) { 756 handle_ffi["handle"] = A.load.Int32(handle + 0); 757 } 758 if (A.load.Bool(handle + 13)) { 759 handle_ffi["vendorId"] = A.load.Int32(handle + 4); 760 } 761 if (A.load.Bool(handle + 14)) { 762 handle_ffi["productId"] = A.load.Int32(handle + 8); 763 } 764 765 const transferInfo_ffi = {}; 766 767 transferInfo_ffi["direction"] = A.load.Enum(transferInfo + 0, ["in", "out"]); 768 if (A.load.Bool(transferInfo + 20)) { 769 transferInfo_ffi["endpoint"] = A.load.Int32(transferInfo + 4); 770 } 771 if (A.load.Bool(transferInfo + 21)) { 772 transferInfo_ffi["length"] = A.load.Int32(transferInfo + 8); 773 } 774 transferInfo_ffi["data"] = A.load.Ref(transferInfo + 12, undefined); 775 if (A.load.Bool(transferInfo + 22)) { 776 transferInfo_ffi["timeout"] = A.load.Int32(transferInfo + 16); 777 } 778 779 const _ret = WEBEXT.usb.bulkTransfer(handle_ffi, transferInfo_ffi); 780 A.store.Ref(retPtr, _ret); 781 }, 782 "try_BulkTransfer": ( 783 retPtr: Pointer, 784 errPtr: Pointer, 785 handle: Pointer, 786 transferInfo: Pointer 787 ): heap.Ref<boolean> => { 788 try { 789 const handle_ffi = {}; 790 791 if (A.load.Bool(handle + 12)) { 792 handle_ffi["handle"] = A.load.Int32(handle + 0); 793 } 794 if (A.load.Bool(handle + 13)) { 795 handle_ffi["vendorId"] = A.load.Int32(handle + 4); 796 } 797 if (A.load.Bool(handle + 14)) { 798 handle_ffi["productId"] = A.load.Int32(handle + 8); 799 } 800 801 const transferInfo_ffi = {}; 802 803 transferInfo_ffi["direction"] = A.load.Enum(transferInfo + 0, ["in", "out"]); 804 if (A.load.Bool(transferInfo + 20)) { 805 transferInfo_ffi["endpoint"] = A.load.Int32(transferInfo + 4); 806 } 807 if (A.load.Bool(transferInfo + 21)) { 808 transferInfo_ffi["length"] = A.load.Int32(transferInfo + 8); 809 } 810 transferInfo_ffi["data"] = A.load.Ref(transferInfo + 12, undefined); 811 if (A.load.Bool(transferInfo + 22)) { 812 transferInfo_ffi["timeout"] = A.load.Int32(transferInfo + 16); 813 } 814 815 const _ret = WEBEXT.usb.bulkTransfer(handle_ffi, transferInfo_ffi); 816 A.store.Ref(retPtr, _ret); 817 return A.H.TRUE; 818 } catch (err: any) { 819 A.store.Ref(errPtr, err); 820 return A.H.FALSE; 821 } 822 }, 823 "has_ClaimInterface": (): heap.Ref<boolean> => { 824 if (WEBEXT?.usb && "claimInterface" in WEBEXT?.usb) { 825 return A.H.TRUE; 826 } 827 return A.H.FALSE; 828 }, 829 "func_ClaimInterface": (fn: Pointer): void => { 830 A.store.Ref(fn, WEBEXT.usb.claimInterface); 831 }, 832 "call_ClaimInterface": (retPtr: Pointer, handle: Pointer, interfaceNumber: number): void => { 833 const handle_ffi = {}; 834 835 if (A.load.Bool(handle + 12)) { 836 handle_ffi["handle"] = A.load.Int32(handle + 0); 837 } 838 if (A.load.Bool(handle + 13)) { 839 handle_ffi["vendorId"] = A.load.Int32(handle + 4); 840 } 841 if (A.load.Bool(handle + 14)) { 842 handle_ffi["productId"] = A.load.Int32(handle + 8); 843 } 844 845 const _ret = WEBEXT.usb.claimInterface(handle_ffi, interfaceNumber); 846 A.store.Ref(retPtr, _ret); 847 }, 848 "try_ClaimInterface": ( 849 retPtr: Pointer, 850 errPtr: Pointer, 851 handle: Pointer, 852 interfaceNumber: number 853 ): heap.Ref<boolean> => { 854 try { 855 const handle_ffi = {}; 856 857 if (A.load.Bool(handle + 12)) { 858 handle_ffi["handle"] = A.load.Int32(handle + 0); 859 } 860 if (A.load.Bool(handle + 13)) { 861 handle_ffi["vendorId"] = A.load.Int32(handle + 4); 862 } 863 if (A.load.Bool(handle + 14)) { 864 handle_ffi["productId"] = A.load.Int32(handle + 8); 865 } 866 867 const _ret = WEBEXT.usb.claimInterface(handle_ffi, interfaceNumber); 868 A.store.Ref(retPtr, _ret); 869 return A.H.TRUE; 870 } catch (err: any) { 871 A.store.Ref(errPtr, err); 872 return A.H.FALSE; 873 } 874 }, 875 "has_CloseDevice": (): heap.Ref<boolean> => { 876 if (WEBEXT?.usb && "closeDevice" in WEBEXT?.usb) { 877 return A.H.TRUE; 878 } 879 return A.H.FALSE; 880 }, 881 "func_CloseDevice": (fn: Pointer): void => { 882 A.store.Ref(fn, WEBEXT.usb.closeDevice); 883 }, 884 "call_CloseDevice": (retPtr: Pointer, handle: Pointer): void => { 885 const handle_ffi = {}; 886 887 if (A.load.Bool(handle + 12)) { 888 handle_ffi["handle"] = A.load.Int32(handle + 0); 889 } 890 if (A.load.Bool(handle + 13)) { 891 handle_ffi["vendorId"] = A.load.Int32(handle + 4); 892 } 893 if (A.load.Bool(handle + 14)) { 894 handle_ffi["productId"] = A.load.Int32(handle + 8); 895 } 896 897 const _ret = WEBEXT.usb.closeDevice(handle_ffi); 898 A.store.Ref(retPtr, _ret); 899 }, 900 "try_CloseDevice": (retPtr: Pointer, errPtr: Pointer, handle: Pointer): heap.Ref<boolean> => { 901 try { 902 const handle_ffi = {}; 903 904 if (A.load.Bool(handle + 12)) { 905 handle_ffi["handle"] = A.load.Int32(handle + 0); 906 } 907 if (A.load.Bool(handle + 13)) { 908 handle_ffi["vendorId"] = A.load.Int32(handle + 4); 909 } 910 if (A.load.Bool(handle + 14)) { 911 handle_ffi["productId"] = A.load.Int32(handle + 8); 912 } 913 914 const _ret = WEBEXT.usb.closeDevice(handle_ffi); 915 A.store.Ref(retPtr, _ret); 916 return A.H.TRUE; 917 } catch (err: any) { 918 A.store.Ref(errPtr, err); 919 return A.H.FALSE; 920 } 921 }, 922 "has_ControlTransfer": (): heap.Ref<boolean> => { 923 if (WEBEXT?.usb && "controlTransfer" in WEBEXT?.usb) { 924 return A.H.TRUE; 925 } 926 return A.H.FALSE; 927 }, 928 "func_ControlTransfer": (fn: Pointer): void => { 929 A.store.Ref(fn, WEBEXT.usb.controlTransfer); 930 }, 931 "call_ControlTransfer": (retPtr: Pointer, handle: Pointer, transferInfo: Pointer): void => { 932 const handle_ffi = {}; 933 934 if (A.load.Bool(handle + 12)) { 935 handle_ffi["handle"] = A.load.Int32(handle + 0); 936 } 937 if (A.load.Bool(handle + 13)) { 938 handle_ffi["vendorId"] = A.load.Int32(handle + 4); 939 } 940 if (A.load.Bool(handle + 14)) { 941 handle_ffi["productId"] = A.load.Int32(handle + 8); 942 } 943 944 const transferInfo_ffi = {}; 945 946 transferInfo_ffi["direction"] = A.load.Enum(transferInfo + 0, ["in", "out"]); 947 transferInfo_ffi["recipient"] = A.load.Enum(transferInfo + 4, ["device", "_interface", "endpoint", "other"]); 948 transferInfo_ffi["requestType"] = A.load.Enum(transferInfo + 8, ["standard", "class", "vendor", "reserved"]); 949 if (A.load.Bool(transferInfo + 36)) { 950 transferInfo_ffi["request"] = A.load.Int32(transferInfo + 12); 951 } 952 if (A.load.Bool(transferInfo + 37)) { 953 transferInfo_ffi["value"] = A.load.Int32(transferInfo + 16); 954 } 955 if (A.load.Bool(transferInfo + 38)) { 956 transferInfo_ffi["index"] = A.load.Int32(transferInfo + 20); 957 } 958 if (A.load.Bool(transferInfo + 39)) { 959 transferInfo_ffi["length"] = A.load.Int32(transferInfo + 24); 960 } 961 transferInfo_ffi["data"] = A.load.Ref(transferInfo + 28, undefined); 962 if (A.load.Bool(transferInfo + 40)) { 963 transferInfo_ffi["timeout"] = A.load.Int32(transferInfo + 32); 964 } 965 966 const _ret = WEBEXT.usb.controlTransfer(handle_ffi, transferInfo_ffi); 967 A.store.Ref(retPtr, _ret); 968 }, 969 "try_ControlTransfer": ( 970 retPtr: Pointer, 971 errPtr: Pointer, 972 handle: Pointer, 973 transferInfo: Pointer 974 ): heap.Ref<boolean> => { 975 try { 976 const handle_ffi = {}; 977 978 if (A.load.Bool(handle + 12)) { 979 handle_ffi["handle"] = A.load.Int32(handle + 0); 980 } 981 if (A.load.Bool(handle + 13)) { 982 handle_ffi["vendorId"] = A.load.Int32(handle + 4); 983 } 984 if (A.load.Bool(handle + 14)) { 985 handle_ffi["productId"] = A.load.Int32(handle + 8); 986 } 987 988 const transferInfo_ffi = {}; 989 990 transferInfo_ffi["direction"] = A.load.Enum(transferInfo + 0, ["in", "out"]); 991 transferInfo_ffi["recipient"] = A.load.Enum(transferInfo + 4, ["device", "_interface", "endpoint", "other"]); 992 transferInfo_ffi["requestType"] = A.load.Enum(transferInfo + 8, ["standard", "class", "vendor", "reserved"]); 993 if (A.load.Bool(transferInfo + 36)) { 994 transferInfo_ffi["request"] = A.load.Int32(transferInfo + 12); 995 } 996 if (A.load.Bool(transferInfo + 37)) { 997 transferInfo_ffi["value"] = A.load.Int32(transferInfo + 16); 998 } 999 if (A.load.Bool(transferInfo + 38)) { 1000 transferInfo_ffi["index"] = A.load.Int32(transferInfo + 20); 1001 } 1002 if (A.load.Bool(transferInfo + 39)) { 1003 transferInfo_ffi["length"] = A.load.Int32(transferInfo + 24); 1004 } 1005 transferInfo_ffi["data"] = A.load.Ref(transferInfo + 28, undefined); 1006 if (A.load.Bool(transferInfo + 40)) { 1007 transferInfo_ffi["timeout"] = A.load.Int32(transferInfo + 32); 1008 } 1009 1010 const _ret = WEBEXT.usb.controlTransfer(handle_ffi, transferInfo_ffi); 1011 A.store.Ref(retPtr, _ret); 1012 return A.H.TRUE; 1013 } catch (err: any) { 1014 A.store.Ref(errPtr, err); 1015 return A.H.FALSE; 1016 } 1017 }, 1018 "has_FindDevices": (): heap.Ref<boolean> => { 1019 if (WEBEXT?.usb && "findDevices" in WEBEXT?.usb) { 1020 return A.H.TRUE; 1021 } 1022 return A.H.FALSE; 1023 }, 1024 "func_FindDevices": (fn: Pointer): void => { 1025 A.store.Ref(fn, WEBEXT.usb.findDevices); 1026 }, 1027 "call_FindDevices": (retPtr: Pointer, options: Pointer): void => { 1028 const options_ffi = {}; 1029 1030 if (A.load.Bool(options + 12)) { 1031 options_ffi["vendorId"] = A.load.Int32(options + 0); 1032 } 1033 if (A.load.Bool(options + 13)) { 1034 options_ffi["productId"] = A.load.Int32(options + 4); 1035 } 1036 if (A.load.Bool(options + 14)) { 1037 options_ffi["interfaceId"] = A.load.Int32(options + 8); 1038 } 1039 1040 const _ret = WEBEXT.usb.findDevices(options_ffi); 1041 A.store.Ref(retPtr, _ret); 1042 }, 1043 "try_FindDevices": (retPtr: Pointer, errPtr: Pointer, options: Pointer): heap.Ref<boolean> => { 1044 try { 1045 const options_ffi = {}; 1046 1047 if (A.load.Bool(options + 12)) { 1048 options_ffi["vendorId"] = A.load.Int32(options + 0); 1049 } 1050 if (A.load.Bool(options + 13)) { 1051 options_ffi["productId"] = A.load.Int32(options + 4); 1052 } 1053 if (A.load.Bool(options + 14)) { 1054 options_ffi["interfaceId"] = A.load.Int32(options + 8); 1055 } 1056 1057 const _ret = WEBEXT.usb.findDevices(options_ffi); 1058 A.store.Ref(retPtr, _ret); 1059 return A.H.TRUE; 1060 } catch (err: any) { 1061 A.store.Ref(errPtr, err); 1062 return A.H.FALSE; 1063 } 1064 }, 1065 "has_GetConfiguration": (): heap.Ref<boolean> => { 1066 if (WEBEXT?.usb && "getConfiguration" in WEBEXT?.usb) { 1067 return A.H.TRUE; 1068 } 1069 return A.H.FALSE; 1070 }, 1071 "func_GetConfiguration": (fn: Pointer): void => { 1072 A.store.Ref(fn, WEBEXT.usb.getConfiguration); 1073 }, 1074 "call_GetConfiguration": (retPtr: Pointer, handle: Pointer): void => { 1075 const handle_ffi = {}; 1076 1077 if (A.load.Bool(handle + 12)) { 1078 handle_ffi["handle"] = A.load.Int32(handle + 0); 1079 } 1080 if (A.load.Bool(handle + 13)) { 1081 handle_ffi["vendorId"] = A.load.Int32(handle + 4); 1082 } 1083 if (A.load.Bool(handle + 14)) { 1084 handle_ffi["productId"] = A.load.Int32(handle + 8); 1085 } 1086 1087 const _ret = WEBEXT.usb.getConfiguration(handle_ffi); 1088 A.store.Ref(retPtr, _ret); 1089 }, 1090 "try_GetConfiguration": (retPtr: Pointer, errPtr: Pointer, handle: Pointer): heap.Ref<boolean> => { 1091 try { 1092 const handle_ffi = {}; 1093 1094 if (A.load.Bool(handle + 12)) { 1095 handle_ffi["handle"] = A.load.Int32(handle + 0); 1096 } 1097 if (A.load.Bool(handle + 13)) { 1098 handle_ffi["vendorId"] = A.load.Int32(handle + 4); 1099 } 1100 if (A.load.Bool(handle + 14)) { 1101 handle_ffi["productId"] = A.load.Int32(handle + 8); 1102 } 1103 1104 const _ret = WEBEXT.usb.getConfiguration(handle_ffi); 1105 A.store.Ref(retPtr, _ret); 1106 return A.H.TRUE; 1107 } catch (err: any) { 1108 A.store.Ref(errPtr, err); 1109 return A.H.FALSE; 1110 } 1111 }, 1112 "has_GetConfigurations": (): heap.Ref<boolean> => { 1113 if (WEBEXT?.usb && "getConfigurations" in WEBEXT?.usb) { 1114 return A.H.TRUE; 1115 } 1116 return A.H.FALSE; 1117 }, 1118 "func_GetConfigurations": (fn: Pointer): void => { 1119 A.store.Ref(fn, WEBEXT.usb.getConfigurations); 1120 }, 1121 "call_GetConfigurations": (retPtr: Pointer, device: Pointer): void => { 1122 const device_ffi = {}; 1123 1124 if (A.load.Bool(device + 28)) { 1125 device_ffi["device"] = A.load.Int32(device + 0); 1126 } 1127 if (A.load.Bool(device + 29)) { 1128 device_ffi["vendorId"] = A.load.Int32(device + 4); 1129 } 1130 if (A.load.Bool(device + 30)) { 1131 device_ffi["productId"] = A.load.Int32(device + 8); 1132 } 1133 if (A.load.Bool(device + 31)) { 1134 device_ffi["version"] = A.load.Int32(device + 12); 1135 } 1136 device_ffi["productName"] = A.load.Ref(device + 16, undefined); 1137 device_ffi["manufacturerName"] = A.load.Ref(device + 20, undefined); 1138 device_ffi["serialNumber"] = A.load.Ref(device + 24, undefined); 1139 1140 const _ret = WEBEXT.usb.getConfigurations(device_ffi); 1141 A.store.Ref(retPtr, _ret); 1142 }, 1143 "try_GetConfigurations": (retPtr: Pointer, errPtr: Pointer, device: Pointer): heap.Ref<boolean> => { 1144 try { 1145 const device_ffi = {}; 1146 1147 if (A.load.Bool(device + 28)) { 1148 device_ffi["device"] = A.load.Int32(device + 0); 1149 } 1150 if (A.load.Bool(device + 29)) { 1151 device_ffi["vendorId"] = A.load.Int32(device + 4); 1152 } 1153 if (A.load.Bool(device + 30)) { 1154 device_ffi["productId"] = A.load.Int32(device + 8); 1155 } 1156 if (A.load.Bool(device + 31)) { 1157 device_ffi["version"] = A.load.Int32(device + 12); 1158 } 1159 device_ffi["productName"] = A.load.Ref(device + 16, undefined); 1160 device_ffi["manufacturerName"] = A.load.Ref(device + 20, undefined); 1161 device_ffi["serialNumber"] = A.load.Ref(device + 24, undefined); 1162 1163 const _ret = WEBEXT.usb.getConfigurations(device_ffi); 1164 A.store.Ref(retPtr, _ret); 1165 return A.H.TRUE; 1166 } catch (err: any) { 1167 A.store.Ref(errPtr, err); 1168 return A.H.FALSE; 1169 } 1170 }, 1171 "has_GetDevices": (): heap.Ref<boolean> => { 1172 if (WEBEXT?.usb && "getDevices" in WEBEXT?.usb) { 1173 return A.H.TRUE; 1174 } 1175 return A.H.FALSE; 1176 }, 1177 "func_GetDevices": (fn: Pointer): void => { 1178 A.store.Ref(fn, WEBEXT.usb.getDevices); 1179 }, 1180 "call_GetDevices": (retPtr: Pointer, options: Pointer): void => { 1181 const options_ffi = {}; 1182 1183 if (A.load.Bool(options + 12)) { 1184 options_ffi["vendorId"] = A.load.Int32(options + 0); 1185 } 1186 if (A.load.Bool(options + 13)) { 1187 options_ffi["productId"] = A.load.Int32(options + 4); 1188 } 1189 options_ffi["filters"] = A.load.Ref(options + 8, undefined); 1190 1191 const _ret = WEBEXT.usb.getDevices(options_ffi); 1192 A.store.Ref(retPtr, _ret); 1193 }, 1194 "try_GetDevices": (retPtr: Pointer, errPtr: Pointer, options: Pointer): heap.Ref<boolean> => { 1195 try { 1196 const options_ffi = {}; 1197 1198 if (A.load.Bool(options + 12)) { 1199 options_ffi["vendorId"] = A.load.Int32(options + 0); 1200 } 1201 if (A.load.Bool(options + 13)) { 1202 options_ffi["productId"] = A.load.Int32(options + 4); 1203 } 1204 options_ffi["filters"] = A.load.Ref(options + 8, undefined); 1205 1206 const _ret = WEBEXT.usb.getDevices(options_ffi); 1207 A.store.Ref(retPtr, _ret); 1208 return A.H.TRUE; 1209 } catch (err: any) { 1210 A.store.Ref(errPtr, err); 1211 return A.H.FALSE; 1212 } 1213 }, 1214 "has_GetUserSelectedDevices": (): heap.Ref<boolean> => { 1215 if (WEBEXT?.usb && "getUserSelectedDevices" in WEBEXT?.usb) { 1216 return A.H.TRUE; 1217 } 1218 return A.H.FALSE; 1219 }, 1220 "func_GetUserSelectedDevices": (fn: Pointer): void => { 1221 A.store.Ref(fn, WEBEXT.usb.getUserSelectedDevices); 1222 }, 1223 "call_GetUserSelectedDevices": (retPtr: Pointer, options: Pointer): void => { 1224 const options_ffi = {}; 1225 1226 if (A.load.Bool(options + 8)) { 1227 options_ffi["multiple"] = A.load.Bool(options + 0); 1228 } 1229 options_ffi["filters"] = A.load.Ref(options + 4, undefined); 1230 1231 const _ret = WEBEXT.usb.getUserSelectedDevices(options_ffi); 1232 A.store.Ref(retPtr, _ret); 1233 }, 1234 "try_GetUserSelectedDevices": (retPtr: Pointer, errPtr: Pointer, options: Pointer): heap.Ref<boolean> => { 1235 try { 1236 const options_ffi = {}; 1237 1238 if (A.load.Bool(options + 8)) { 1239 options_ffi["multiple"] = A.load.Bool(options + 0); 1240 } 1241 options_ffi["filters"] = A.load.Ref(options + 4, undefined); 1242 1243 const _ret = WEBEXT.usb.getUserSelectedDevices(options_ffi); 1244 A.store.Ref(retPtr, _ret); 1245 return A.H.TRUE; 1246 } catch (err: any) { 1247 A.store.Ref(errPtr, err); 1248 return A.H.FALSE; 1249 } 1250 }, 1251 "has_InterruptTransfer": (): heap.Ref<boolean> => { 1252 if (WEBEXT?.usb && "interruptTransfer" in WEBEXT?.usb) { 1253 return A.H.TRUE; 1254 } 1255 return A.H.FALSE; 1256 }, 1257 "func_InterruptTransfer": (fn: Pointer): void => { 1258 A.store.Ref(fn, WEBEXT.usb.interruptTransfer); 1259 }, 1260 "call_InterruptTransfer": (retPtr: Pointer, handle: Pointer, transferInfo: Pointer): void => { 1261 const handle_ffi = {}; 1262 1263 if (A.load.Bool(handle + 12)) { 1264 handle_ffi["handle"] = A.load.Int32(handle + 0); 1265 } 1266 if (A.load.Bool(handle + 13)) { 1267 handle_ffi["vendorId"] = A.load.Int32(handle + 4); 1268 } 1269 if (A.load.Bool(handle + 14)) { 1270 handle_ffi["productId"] = A.load.Int32(handle + 8); 1271 } 1272 1273 const transferInfo_ffi = {}; 1274 1275 transferInfo_ffi["direction"] = A.load.Enum(transferInfo + 0, ["in", "out"]); 1276 if (A.load.Bool(transferInfo + 20)) { 1277 transferInfo_ffi["endpoint"] = A.load.Int32(transferInfo + 4); 1278 } 1279 if (A.load.Bool(transferInfo + 21)) { 1280 transferInfo_ffi["length"] = A.load.Int32(transferInfo + 8); 1281 } 1282 transferInfo_ffi["data"] = A.load.Ref(transferInfo + 12, undefined); 1283 if (A.load.Bool(transferInfo + 22)) { 1284 transferInfo_ffi["timeout"] = A.load.Int32(transferInfo + 16); 1285 } 1286 1287 const _ret = WEBEXT.usb.interruptTransfer(handle_ffi, transferInfo_ffi); 1288 A.store.Ref(retPtr, _ret); 1289 }, 1290 "try_InterruptTransfer": ( 1291 retPtr: Pointer, 1292 errPtr: Pointer, 1293 handle: Pointer, 1294 transferInfo: Pointer 1295 ): heap.Ref<boolean> => { 1296 try { 1297 const handle_ffi = {}; 1298 1299 if (A.load.Bool(handle + 12)) { 1300 handle_ffi["handle"] = A.load.Int32(handle + 0); 1301 } 1302 if (A.load.Bool(handle + 13)) { 1303 handle_ffi["vendorId"] = A.load.Int32(handle + 4); 1304 } 1305 if (A.load.Bool(handle + 14)) { 1306 handle_ffi["productId"] = A.load.Int32(handle + 8); 1307 } 1308 1309 const transferInfo_ffi = {}; 1310 1311 transferInfo_ffi["direction"] = A.load.Enum(transferInfo + 0, ["in", "out"]); 1312 if (A.load.Bool(transferInfo + 20)) { 1313 transferInfo_ffi["endpoint"] = A.load.Int32(transferInfo + 4); 1314 } 1315 if (A.load.Bool(transferInfo + 21)) { 1316 transferInfo_ffi["length"] = A.load.Int32(transferInfo + 8); 1317 } 1318 transferInfo_ffi["data"] = A.load.Ref(transferInfo + 12, undefined); 1319 if (A.load.Bool(transferInfo + 22)) { 1320 transferInfo_ffi["timeout"] = A.load.Int32(transferInfo + 16); 1321 } 1322 1323 const _ret = WEBEXT.usb.interruptTransfer(handle_ffi, transferInfo_ffi); 1324 A.store.Ref(retPtr, _ret); 1325 return A.H.TRUE; 1326 } catch (err: any) { 1327 A.store.Ref(errPtr, err); 1328 return A.H.FALSE; 1329 } 1330 }, 1331 "has_IsochronousTransfer": (): heap.Ref<boolean> => { 1332 if (WEBEXT?.usb && "isochronousTransfer" in WEBEXT?.usb) { 1333 return A.H.TRUE; 1334 } 1335 return A.H.FALSE; 1336 }, 1337 "func_IsochronousTransfer": (fn: Pointer): void => { 1338 A.store.Ref(fn, WEBEXT.usb.isochronousTransfer); 1339 }, 1340 "call_IsochronousTransfer": (retPtr: Pointer, handle: Pointer, transferInfo: Pointer): void => { 1341 const handle_ffi = {}; 1342 1343 if (A.load.Bool(handle + 12)) { 1344 handle_ffi["handle"] = A.load.Int32(handle + 0); 1345 } 1346 if (A.load.Bool(handle + 13)) { 1347 handle_ffi["vendorId"] = A.load.Int32(handle + 4); 1348 } 1349 if (A.load.Bool(handle + 14)) { 1350 handle_ffi["productId"] = A.load.Int32(handle + 8); 1351 } 1352 1353 const transferInfo_ffi = {}; 1354 1355 if (A.load.Bool(transferInfo + 0 + 23)) { 1356 transferInfo_ffi["transferInfo"] = {}; 1357 transferInfo_ffi["transferInfo"]["direction"] = A.load.Enum(transferInfo + 0 + 0, ["in", "out"]); 1358 if (A.load.Bool(transferInfo + 0 + 20)) { 1359 transferInfo_ffi["transferInfo"]["endpoint"] = A.load.Int32(transferInfo + 0 + 4); 1360 } 1361 if (A.load.Bool(transferInfo + 0 + 21)) { 1362 transferInfo_ffi["transferInfo"]["length"] = A.load.Int32(transferInfo + 0 + 8); 1363 } 1364 transferInfo_ffi["transferInfo"]["data"] = A.load.Ref(transferInfo + 0 + 12, undefined); 1365 if (A.load.Bool(transferInfo + 0 + 22)) { 1366 transferInfo_ffi["transferInfo"]["timeout"] = A.load.Int32(transferInfo + 0 + 16); 1367 } 1368 } 1369 if (A.load.Bool(transferInfo + 32)) { 1370 transferInfo_ffi["packets"] = A.load.Int32(transferInfo + 24); 1371 } 1372 if (A.load.Bool(transferInfo + 33)) { 1373 transferInfo_ffi["packetLength"] = A.load.Int32(transferInfo + 28); 1374 } 1375 1376 const _ret = WEBEXT.usb.isochronousTransfer(handle_ffi, transferInfo_ffi); 1377 A.store.Ref(retPtr, _ret); 1378 }, 1379 "try_IsochronousTransfer": ( 1380 retPtr: Pointer, 1381 errPtr: Pointer, 1382 handle: Pointer, 1383 transferInfo: Pointer 1384 ): heap.Ref<boolean> => { 1385 try { 1386 const handle_ffi = {}; 1387 1388 if (A.load.Bool(handle + 12)) { 1389 handle_ffi["handle"] = A.load.Int32(handle + 0); 1390 } 1391 if (A.load.Bool(handle + 13)) { 1392 handle_ffi["vendorId"] = A.load.Int32(handle + 4); 1393 } 1394 if (A.load.Bool(handle + 14)) { 1395 handle_ffi["productId"] = A.load.Int32(handle + 8); 1396 } 1397 1398 const transferInfo_ffi = {}; 1399 1400 if (A.load.Bool(transferInfo + 0 + 23)) { 1401 transferInfo_ffi["transferInfo"] = {}; 1402 transferInfo_ffi["transferInfo"]["direction"] = A.load.Enum(transferInfo + 0 + 0, ["in", "out"]); 1403 if (A.load.Bool(transferInfo + 0 + 20)) { 1404 transferInfo_ffi["transferInfo"]["endpoint"] = A.load.Int32(transferInfo + 0 + 4); 1405 } 1406 if (A.load.Bool(transferInfo + 0 + 21)) { 1407 transferInfo_ffi["transferInfo"]["length"] = A.load.Int32(transferInfo + 0 + 8); 1408 } 1409 transferInfo_ffi["transferInfo"]["data"] = A.load.Ref(transferInfo + 0 + 12, undefined); 1410 if (A.load.Bool(transferInfo + 0 + 22)) { 1411 transferInfo_ffi["transferInfo"]["timeout"] = A.load.Int32(transferInfo + 0 + 16); 1412 } 1413 } 1414 if (A.load.Bool(transferInfo + 32)) { 1415 transferInfo_ffi["packets"] = A.load.Int32(transferInfo + 24); 1416 } 1417 if (A.load.Bool(transferInfo + 33)) { 1418 transferInfo_ffi["packetLength"] = A.load.Int32(transferInfo + 28); 1419 } 1420 1421 const _ret = WEBEXT.usb.isochronousTransfer(handle_ffi, transferInfo_ffi); 1422 A.store.Ref(retPtr, _ret); 1423 return A.H.TRUE; 1424 } catch (err: any) { 1425 A.store.Ref(errPtr, err); 1426 return A.H.FALSE; 1427 } 1428 }, 1429 "has_ListInterfaces": (): heap.Ref<boolean> => { 1430 if (WEBEXT?.usb && "listInterfaces" in WEBEXT?.usb) { 1431 return A.H.TRUE; 1432 } 1433 return A.H.FALSE; 1434 }, 1435 "func_ListInterfaces": (fn: Pointer): void => { 1436 A.store.Ref(fn, WEBEXT.usb.listInterfaces); 1437 }, 1438 "call_ListInterfaces": (retPtr: Pointer, handle: Pointer): void => { 1439 const handle_ffi = {}; 1440 1441 if (A.load.Bool(handle + 12)) { 1442 handle_ffi["handle"] = A.load.Int32(handle + 0); 1443 } 1444 if (A.load.Bool(handle + 13)) { 1445 handle_ffi["vendorId"] = A.load.Int32(handle + 4); 1446 } 1447 if (A.load.Bool(handle + 14)) { 1448 handle_ffi["productId"] = A.load.Int32(handle + 8); 1449 } 1450 1451 const _ret = WEBEXT.usb.listInterfaces(handle_ffi); 1452 A.store.Ref(retPtr, _ret); 1453 }, 1454 "try_ListInterfaces": (retPtr: Pointer, errPtr: Pointer, handle: Pointer): heap.Ref<boolean> => { 1455 try { 1456 const handle_ffi = {}; 1457 1458 if (A.load.Bool(handle + 12)) { 1459 handle_ffi["handle"] = A.load.Int32(handle + 0); 1460 } 1461 if (A.load.Bool(handle + 13)) { 1462 handle_ffi["vendorId"] = A.load.Int32(handle + 4); 1463 } 1464 if (A.load.Bool(handle + 14)) { 1465 handle_ffi["productId"] = A.load.Int32(handle + 8); 1466 } 1467 1468 const _ret = WEBEXT.usb.listInterfaces(handle_ffi); 1469 A.store.Ref(retPtr, _ret); 1470 return A.H.TRUE; 1471 } catch (err: any) { 1472 A.store.Ref(errPtr, err); 1473 return A.H.FALSE; 1474 } 1475 }, 1476 "has_OnDeviceAdded": (): heap.Ref<boolean> => { 1477 if (WEBEXT?.usb?.onDeviceAdded && "addListener" in WEBEXT?.usb?.onDeviceAdded) { 1478 return A.H.TRUE; 1479 } 1480 return A.H.FALSE; 1481 }, 1482 "func_OnDeviceAdded": (fn: Pointer): void => { 1483 A.store.Ref(fn, WEBEXT.usb.onDeviceAdded.addListener); 1484 }, 1485 "call_OnDeviceAdded": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1486 const _ret = WEBEXT.usb.onDeviceAdded.addListener(A.H.get<object>(callback)); 1487 }, 1488 "try_OnDeviceAdded": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1489 try { 1490 const _ret = WEBEXT.usb.onDeviceAdded.addListener(A.H.get<object>(callback)); 1491 return A.H.TRUE; 1492 } catch (err: any) { 1493 A.store.Ref(errPtr, err); 1494 return A.H.FALSE; 1495 } 1496 }, 1497 "has_OffDeviceAdded": (): heap.Ref<boolean> => { 1498 if (WEBEXT?.usb?.onDeviceAdded && "removeListener" in WEBEXT?.usb?.onDeviceAdded) { 1499 return A.H.TRUE; 1500 } 1501 return A.H.FALSE; 1502 }, 1503 "func_OffDeviceAdded": (fn: Pointer): void => { 1504 A.store.Ref(fn, WEBEXT.usb.onDeviceAdded.removeListener); 1505 }, 1506 "call_OffDeviceAdded": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1507 const _ret = WEBEXT.usb.onDeviceAdded.removeListener(A.H.get<object>(callback)); 1508 }, 1509 "try_OffDeviceAdded": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1510 try { 1511 const _ret = WEBEXT.usb.onDeviceAdded.removeListener(A.H.get<object>(callback)); 1512 return A.H.TRUE; 1513 } catch (err: any) { 1514 A.store.Ref(errPtr, err); 1515 return A.H.FALSE; 1516 } 1517 }, 1518 "has_HasOnDeviceAdded": (): heap.Ref<boolean> => { 1519 if (WEBEXT?.usb?.onDeviceAdded && "hasListener" in WEBEXT?.usb?.onDeviceAdded) { 1520 return A.H.TRUE; 1521 } 1522 return A.H.FALSE; 1523 }, 1524 "func_HasOnDeviceAdded": (fn: Pointer): void => { 1525 A.store.Ref(fn, WEBEXT.usb.onDeviceAdded.hasListener); 1526 }, 1527 "call_HasOnDeviceAdded": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1528 const _ret = WEBEXT.usb.onDeviceAdded.hasListener(A.H.get<object>(callback)); 1529 A.store.Bool(retPtr, _ret); 1530 }, 1531 "try_HasOnDeviceAdded": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1532 try { 1533 const _ret = WEBEXT.usb.onDeviceAdded.hasListener(A.H.get<object>(callback)); 1534 A.store.Bool(retPtr, _ret); 1535 return A.H.TRUE; 1536 } catch (err: any) { 1537 A.store.Ref(errPtr, err); 1538 return A.H.FALSE; 1539 } 1540 }, 1541 "has_OnDeviceRemoved": (): heap.Ref<boolean> => { 1542 if (WEBEXT?.usb?.onDeviceRemoved && "addListener" in WEBEXT?.usb?.onDeviceRemoved) { 1543 return A.H.TRUE; 1544 } 1545 return A.H.FALSE; 1546 }, 1547 "func_OnDeviceRemoved": (fn: Pointer): void => { 1548 A.store.Ref(fn, WEBEXT.usb.onDeviceRemoved.addListener); 1549 }, 1550 "call_OnDeviceRemoved": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1551 const _ret = WEBEXT.usb.onDeviceRemoved.addListener(A.H.get<object>(callback)); 1552 }, 1553 "try_OnDeviceRemoved": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1554 try { 1555 const _ret = WEBEXT.usb.onDeviceRemoved.addListener(A.H.get<object>(callback)); 1556 return A.H.TRUE; 1557 } catch (err: any) { 1558 A.store.Ref(errPtr, err); 1559 return A.H.FALSE; 1560 } 1561 }, 1562 "has_OffDeviceRemoved": (): heap.Ref<boolean> => { 1563 if (WEBEXT?.usb?.onDeviceRemoved && "removeListener" in WEBEXT?.usb?.onDeviceRemoved) { 1564 return A.H.TRUE; 1565 } 1566 return A.H.FALSE; 1567 }, 1568 "func_OffDeviceRemoved": (fn: Pointer): void => { 1569 A.store.Ref(fn, WEBEXT.usb.onDeviceRemoved.removeListener); 1570 }, 1571 "call_OffDeviceRemoved": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1572 const _ret = WEBEXT.usb.onDeviceRemoved.removeListener(A.H.get<object>(callback)); 1573 }, 1574 "try_OffDeviceRemoved": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1575 try { 1576 const _ret = WEBEXT.usb.onDeviceRemoved.removeListener(A.H.get<object>(callback)); 1577 return A.H.TRUE; 1578 } catch (err: any) { 1579 A.store.Ref(errPtr, err); 1580 return A.H.FALSE; 1581 } 1582 }, 1583 "has_HasOnDeviceRemoved": (): heap.Ref<boolean> => { 1584 if (WEBEXT?.usb?.onDeviceRemoved && "hasListener" in WEBEXT?.usb?.onDeviceRemoved) { 1585 return A.H.TRUE; 1586 } 1587 return A.H.FALSE; 1588 }, 1589 "func_HasOnDeviceRemoved": (fn: Pointer): void => { 1590 A.store.Ref(fn, WEBEXT.usb.onDeviceRemoved.hasListener); 1591 }, 1592 "call_HasOnDeviceRemoved": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1593 const _ret = WEBEXT.usb.onDeviceRemoved.hasListener(A.H.get<object>(callback)); 1594 A.store.Bool(retPtr, _ret); 1595 }, 1596 "try_HasOnDeviceRemoved": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1597 try { 1598 const _ret = WEBEXT.usb.onDeviceRemoved.hasListener(A.H.get<object>(callback)); 1599 A.store.Bool(retPtr, _ret); 1600 return A.H.TRUE; 1601 } catch (err: any) { 1602 A.store.Ref(errPtr, err); 1603 return A.H.FALSE; 1604 } 1605 }, 1606 "has_OpenDevice": (): heap.Ref<boolean> => { 1607 if (WEBEXT?.usb && "openDevice" in WEBEXT?.usb) { 1608 return A.H.TRUE; 1609 } 1610 return A.H.FALSE; 1611 }, 1612 "func_OpenDevice": (fn: Pointer): void => { 1613 A.store.Ref(fn, WEBEXT.usb.openDevice); 1614 }, 1615 "call_OpenDevice": (retPtr: Pointer, device: Pointer): void => { 1616 const device_ffi = {}; 1617 1618 if (A.load.Bool(device + 28)) { 1619 device_ffi["device"] = A.load.Int32(device + 0); 1620 } 1621 if (A.load.Bool(device + 29)) { 1622 device_ffi["vendorId"] = A.load.Int32(device + 4); 1623 } 1624 if (A.load.Bool(device + 30)) { 1625 device_ffi["productId"] = A.load.Int32(device + 8); 1626 } 1627 if (A.load.Bool(device + 31)) { 1628 device_ffi["version"] = A.load.Int32(device + 12); 1629 } 1630 device_ffi["productName"] = A.load.Ref(device + 16, undefined); 1631 device_ffi["manufacturerName"] = A.load.Ref(device + 20, undefined); 1632 device_ffi["serialNumber"] = A.load.Ref(device + 24, undefined); 1633 1634 const _ret = WEBEXT.usb.openDevice(device_ffi); 1635 A.store.Ref(retPtr, _ret); 1636 }, 1637 "try_OpenDevice": (retPtr: Pointer, errPtr: Pointer, device: Pointer): heap.Ref<boolean> => { 1638 try { 1639 const device_ffi = {}; 1640 1641 if (A.load.Bool(device + 28)) { 1642 device_ffi["device"] = A.load.Int32(device + 0); 1643 } 1644 if (A.load.Bool(device + 29)) { 1645 device_ffi["vendorId"] = A.load.Int32(device + 4); 1646 } 1647 if (A.load.Bool(device + 30)) { 1648 device_ffi["productId"] = A.load.Int32(device + 8); 1649 } 1650 if (A.load.Bool(device + 31)) { 1651 device_ffi["version"] = A.load.Int32(device + 12); 1652 } 1653 device_ffi["productName"] = A.load.Ref(device + 16, undefined); 1654 device_ffi["manufacturerName"] = A.load.Ref(device + 20, undefined); 1655 device_ffi["serialNumber"] = A.load.Ref(device + 24, undefined); 1656 1657 const _ret = WEBEXT.usb.openDevice(device_ffi); 1658 A.store.Ref(retPtr, _ret); 1659 return A.H.TRUE; 1660 } catch (err: any) { 1661 A.store.Ref(errPtr, err); 1662 return A.H.FALSE; 1663 } 1664 }, 1665 "has_ReleaseInterface": (): heap.Ref<boolean> => { 1666 if (WEBEXT?.usb && "releaseInterface" in WEBEXT?.usb) { 1667 return A.H.TRUE; 1668 } 1669 return A.H.FALSE; 1670 }, 1671 "func_ReleaseInterface": (fn: Pointer): void => { 1672 A.store.Ref(fn, WEBEXT.usb.releaseInterface); 1673 }, 1674 "call_ReleaseInterface": (retPtr: Pointer, handle: Pointer, interfaceNumber: number): void => { 1675 const handle_ffi = {}; 1676 1677 if (A.load.Bool(handle + 12)) { 1678 handle_ffi["handle"] = A.load.Int32(handle + 0); 1679 } 1680 if (A.load.Bool(handle + 13)) { 1681 handle_ffi["vendorId"] = A.load.Int32(handle + 4); 1682 } 1683 if (A.load.Bool(handle + 14)) { 1684 handle_ffi["productId"] = A.load.Int32(handle + 8); 1685 } 1686 1687 const _ret = WEBEXT.usb.releaseInterface(handle_ffi, interfaceNumber); 1688 A.store.Ref(retPtr, _ret); 1689 }, 1690 "try_ReleaseInterface": ( 1691 retPtr: Pointer, 1692 errPtr: Pointer, 1693 handle: Pointer, 1694 interfaceNumber: number 1695 ): heap.Ref<boolean> => { 1696 try { 1697 const handle_ffi = {}; 1698 1699 if (A.load.Bool(handle + 12)) { 1700 handle_ffi["handle"] = A.load.Int32(handle + 0); 1701 } 1702 if (A.load.Bool(handle + 13)) { 1703 handle_ffi["vendorId"] = A.load.Int32(handle + 4); 1704 } 1705 if (A.load.Bool(handle + 14)) { 1706 handle_ffi["productId"] = A.load.Int32(handle + 8); 1707 } 1708 1709 const _ret = WEBEXT.usb.releaseInterface(handle_ffi, interfaceNumber); 1710 A.store.Ref(retPtr, _ret); 1711 return A.H.TRUE; 1712 } catch (err: any) { 1713 A.store.Ref(errPtr, err); 1714 return A.H.FALSE; 1715 } 1716 }, 1717 "has_RequestAccess": (): heap.Ref<boolean> => { 1718 if (WEBEXT?.usb && "requestAccess" in WEBEXT?.usb) { 1719 return A.H.TRUE; 1720 } 1721 return A.H.FALSE; 1722 }, 1723 "func_RequestAccess": (fn: Pointer): void => { 1724 A.store.Ref(fn, WEBEXT.usb.requestAccess); 1725 }, 1726 "call_RequestAccess": (retPtr: Pointer, device: Pointer, interfaceId: number): void => { 1727 const device_ffi = {}; 1728 1729 if (A.load.Bool(device + 28)) { 1730 device_ffi["device"] = A.load.Int32(device + 0); 1731 } 1732 if (A.load.Bool(device + 29)) { 1733 device_ffi["vendorId"] = A.load.Int32(device + 4); 1734 } 1735 if (A.load.Bool(device + 30)) { 1736 device_ffi["productId"] = A.load.Int32(device + 8); 1737 } 1738 if (A.load.Bool(device + 31)) { 1739 device_ffi["version"] = A.load.Int32(device + 12); 1740 } 1741 device_ffi["productName"] = A.load.Ref(device + 16, undefined); 1742 device_ffi["manufacturerName"] = A.load.Ref(device + 20, undefined); 1743 device_ffi["serialNumber"] = A.load.Ref(device + 24, undefined); 1744 1745 const _ret = WEBEXT.usb.requestAccess(device_ffi, interfaceId); 1746 A.store.Ref(retPtr, _ret); 1747 }, 1748 "try_RequestAccess": ( 1749 retPtr: Pointer, 1750 errPtr: Pointer, 1751 device: Pointer, 1752 interfaceId: number 1753 ): heap.Ref<boolean> => { 1754 try { 1755 const device_ffi = {}; 1756 1757 if (A.load.Bool(device + 28)) { 1758 device_ffi["device"] = A.load.Int32(device + 0); 1759 } 1760 if (A.load.Bool(device + 29)) { 1761 device_ffi["vendorId"] = A.load.Int32(device + 4); 1762 } 1763 if (A.load.Bool(device + 30)) { 1764 device_ffi["productId"] = A.load.Int32(device + 8); 1765 } 1766 if (A.load.Bool(device + 31)) { 1767 device_ffi["version"] = A.load.Int32(device + 12); 1768 } 1769 device_ffi["productName"] = A.load.Ref(device + 16, undefined); 1770 device_ffi["manufacturerName"] = A.load.Ref(device + 20, undefined); 1771 device_ffi["serialNumber"] = A.load.Ref(device + 24, undefined); 1772 1773 const _ret = WEBEXT.usb.requestAccess(device_ffi, interfaceId); 1774 A.store.Ref(retPtr, _ret); 1775 return A.H.TRUE; 1776 } catch (err: any) { 1777 A.store.Ref(errPtr, err); 1778 return A.H.FALSE; 1779 } 1780 }, 1781 "has_ResetDevice": (): heap.Ref<boolean> => { 1782 if (WEBEXT?.usb && "resetDevice" in WEBEXT?.usb) { 1783 return A.H.TRUE; 1784 } 1785 return A.H.FALSE; 1786 }, 1787 "func_ResetDevice": (fn: Pointer): void => { 1788 A.store.Ref(fn, WEBEXT.usb.resetDevice); 1789 }, 1790 "call_ResetDevice": (retPtr: Pointer, handle: Pointer): void => { 1791 const handle_ffi = {}; 1792 1793 if (A.load.Bool(handle + 12)) { 1794 handle_ffi["handle"] = A.load.Int32(handle + 0); 1795 } 1796 if (A.load.Bool(handle + 13)) { 1797 handle_ffi["vendorId"] = A.load.Int32(handle + 4); 1798 } 1799 if (A.load.Bool(handle + 14)) { 1800 handle_ffi["productId"] = A.load.Int32(handle + 8); 1801 } 1802 1803 const _ret = WEBEXT.usb.resetDevice(handle_ffi); 1804 A.store.Ref(retPtr, _ret); 1805 }, 1806 "try_ResetDevice": (retPtr: Pointer, errPtr: Pointer, handle: Pointer): heap.Ref<boolean> => { 1807 try { 1808 const handle_ffi = {}; 1809 1810 if (A.load.Bool(handle + 12)) { 1811 handle_ffi["handle"] = A.load.Int32(handle + 0); 1812 } 1813 if (A.load.Bool(handle + 13)) { 1814 handle_ffi["vendorId"] = A.load.Int32(handle + 4); 1815 } 1816 if (A.load.Bool(handle + 14)) { 1817 handle_ffi["productId"] = A.load.Int32(handle + 8); 1818 } 1819 1820 const _ret = WEBEXT.usb.resetDevice(handle_ffi); 1821 A.store.Ref(retPtr, _ret); 1822 return A.H.TRUE; 1823 } catch (err: any) { 1824 A.store.Ref(errPtr, err); 1825 return A.H.FALSE; 1826 } 1827 }, 1828 "has_SetConfiguration": (): heap.Ref<boolean> => { 1829 if (WEBEXT?.usb && "setConfiguration" in WEBEXT?.usb) { 1830 return A.H.TRUE; 1831 } 1832 return A.H.FALSE; 1833 }, 1834 "func_SetConfiguration": (fn: Pointer): void => { 1835 A.store.Ref(fn, WEBEXT.usb.setConfiguration); 1836 }, 1837 "call_SetConfiguration": (retPtr: Pointer, handle: Pointer, configurationValue: number): void => { 1838 const handle_ffi = {}; 1839 1840 if (A.load.Bool(handle + 12)) { 1841 handle_ffi["handle"] = A.load.Int32(handle + 0); 1842 } 1843 if (A.load.Bool(handle + 13)) { 1844 handle_ffi["vendorId"] = A.load.Int32(handle + 4); 1845 } 1846 if (A.load.Bool(handle + 14)) { 1847 handle_ffi["productId"] = A.load.Int32(handle + 8); 1848 } 1849 1850 const _ret = WEBEXT.usb.setConfiguration(handle_ffi, configurationValue); 1851 A.store.Ref(retPtr, _ret); 1852 }, 1853 "try_SetConfiguration": ( 1854 retPtr: Pointer, 1855 errPtr: Pointer, 1856 handle: Pointer, 1857 configurationValue: number 1858 ): heap.Ref<boolean> => { 1859 try { 1860 const handle_ffi = {}; 1861 1862 if (A.load.Bool(handle + 12)) { 1863 handle_ffi["handle"] = A.load.Int32(handle + 0); 1864 } 1865 if (A.load.Bool(handle + 13)) { 1866 handle_ffi["vendorId"] = A.load.Int32(handle + 4); 1867 } 1868 if (A.load.Bool(handle + 14)) { 1869 handle_ffi["productId"] = A.load.Int32(handle + 8); 1870 } 1871 1872 const _ret = WEBEXT.usb.setConfiguration(handle_ffi, configurationValue); 1873 A.store.Ref(retPtr, _ret); 1874 return A.H.TRUE; 1875 } catch (err: any) { 1876 A.store.Ref(errPtr, err); 1877 return A.H.FALSE; 1878 } 1879 }, 1880 "has_SetInterfaceAlternateSetting": (): heap.Ref<boolean> => { 1881 if (WEBEXT?.usb && "setInterfaceAlternateSetting" in WEBEXT?.usb) { 1882 return A.H.TRUE; 1883 } 1884 return A.H.FALSE; 1885 }, 1886 "func_SetInterfaceAlternateSetting": (fn: Pointer): void => { 1887 A.store.Ref(fn, WEBEXT.usb.setInterfaceAlternateSetting); 1888 }, 1889 "call_SetInterfaceAlternateSetting": ( 1890 retPtr: Pointer, 1891 handle: Pointer, 1892 interfaceNumber: number, 1893 alternateSetting: number 1894 ): void => { 1895 const handle_ffi = {}; 1896 1897 if (A.load.Bool(handle + 12)) { 1898 handle_ffi["handle"] = A.load.Int32(handle + 0); 1899 } 1900 if (A.load.Bool(handle + 13)) { 1901 handle_ffi["vendorId"] = A.load.Int32(handle + 4); 1902 } 1903 if (A.load.Bool(handle + 14)) { 1904 handle_ffi["productId"] = A.load.Int32(handle + 8); 1905 } 1906 1907 const _ret = WEBEXT.usb.setInterfaceAlternateSetting(handle_ffi, interfaceNumber, alternateSetting); 1908 A.store.Ref(retPtr, _ret); 1909 }, 1910 "try_SetInterfaceAlternateSetting": ( 1911 retPtr: Pointer, 1912 errPtr: Pointer, 1913 handle: Pointer, 1914 interfaceNumber: number, 1915 alternateSetting: number 1916 ): heap.Ref<boolean> => { 1917 try { 1918 const handle_ffi = {}; 1919 1920 if (A.load.Bool(handle + 12)) { 1921 handle_ffi["handle"] = A.load.Int32(handle + 0); 1922 } 1923 if (A.load.Bool(handle + 13)) { 1924 handle_ffi["vendorId"] = A.load.Int32(handle + 4); 1925 } 1926 if (A.load.Bool(handle + 14)) { 1927 handle_ffi["productId"] = A.load.Int32(handle + 8); 1928 } 1929 1930 const _ret = WEBEXT.usb.setInterfaceAlternateSetting(handle_ffi, interfaceNumber, alternateSetting); 1931 A.store.Ref(retPtr, _ret); 1932 return A.H.TRUE; 1933 } catch (err: any) { 1934 A.store.Ref(errPtr, err); 1935 return A.H.FALSE; 1936 } 1937 }, 1938 }; 1939 });