github.com/primecitizens/pcz/std@v0.2.1/plat/js/webext/tabs/bindings/ffi_bindings.ts (about) 1 import { importModule, Application, heap, Pointer } from "@ffi"; 2 3 importModule("plat/js/webext/tabs", (A: Application) => { 4 const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser; 5 6 return { 7 "store_ConnectArgConnectInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 8 const x = A.H.get<any>(ref); 9 10 if (typeof x === "undefined") { 11 A.store.Bool(ptr + 21, false); 12 A.store.Ref(ptr + 0, undefined); 13 A.store.Bool(ptr + 20, false); 14 A.store.Int64(ptr + 8, 0); 15 A.store.Ref(ptr + 16, undefined); 16 } else { 17 A.store.Bool(ptr + 21, true); 18 A.store.Ref(ptr + 0, x["documentId"]); 19 A.store.Bool(ptr + 20, "frameId" in x ? true : false); 20 A.store.Int64(ptr + 8, x["frameId"] === undefined ? 0 : (x["frameId"] as number)); 21 A.store.Ref(ptr + 16, x["name"]); 22 } 23 }, 24 "load_ConnectArgConnectInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 25 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 26 27 x["documentId"] = A.load.Ref(ptr + 0, undefined); 28 if (A.load.Bool(ptr + 20)) { 29 x["frameId"] = A.load.Int64(ptr + 8); 30 } else { 31 delete x["frameId"]; 32 } 33 x["name"] = A.load.Ref(ptr + 16, undefined); 34 return create === A.H.TRUE ? A.H.push(x) : ref; 35 }, 36 "constof_MutedInfoReason": (ref: heap.Ref<string>): number => { 37 const idx = ["user", "capture", "extension"].indexOf(A.H.get(ref)); 38 return idx < 0 ? 0 : idx + 1; 39 }, 40 41 "store_MutedInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 42 const x = A.H.get<any>(ref); 43 44 if (typeof x === "undefined") { 45 A.store.Bool(ptr + 12, false); 46 A.store.Ref(ptr + 0, undefined); 47 A.store.Bool(ptr + 4, false); 48 A.store.Enum(ptr + 8, -1); 49 } else { 50 A.store.Bool(ptr + 12, true); 51 A.store.Ref(ptr + 0, x["extensionId"]); 52 A.store.Bool(ptr + 4, x["muted"] ? true : false); 53 A.store.Enum(ptr + 8, ["user", "capture", "extension"].indexOf(x["reason"] as string)); 54 } 55 }, 56 "load_MutedInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 57 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 58 59 x["extensionId"] = A.load.Ref(ptr + 0, undefined); 60 x["muted"] = A.load.Bool(ptr + 4); 61 x["reason"] = A.load.Enum(ptr + 8, ["user", "capture", "extension"]); 62 return create === A.H.TRUE ? A.H.push(x) : ref; 63 }, 64 "constof_TabStatus": (ref: heap.Ref<string>): number => { 65 const idx = ["unloaded", "loading", "complete"].indexOf(A.H.get(ref)); 66 return idx < 0 ? 0 : idx + 1; 67 }, 68 69 "store_Tab": (ptr: Pointer, ref: heap.Ref<any>) => { 70 const x = A.H.get<any>(ref); 71 72 if (typeof x === "undefined") { 73 A.store.Bool(ptr + 125, false); 74 A.store.Bool(ptr + 0, false); 75 A.store.Bool(ptr + 120, false); 76 A.store.Bool(ptr + 1, false); 77 A.store.Bool(ptr + 2, false); 78 A.store.Bool(ptr + 3, false); 79 A.store.Ref(ptr + 4, undefined); 80 A.store.Int64(ptr + 8, 0); 81 A.store.Bool(ptr + 121, false); 82 A.store.Int64(ptr + 16, 0); 83 A.store.Bool(ptr + 24, false); 84 A.store.Bool(ptr + 122, false); 85 A.store.Int64(ptr + 32, 0); 86 A.store.Bool(ptr + 40, false); 87 A.store.Int64(ptr + 48, 0); 88 89 A.store.Bool(ptr + 56 + 12, false); 90 A.store.Ref(ptr + 56 + 0, undefined); 91 A.store.Bool(ptr + 56 + 4, false); 92 A.store.Enum(ptr + 56 + 8, -1); 93 A.store.Bool(ptr + 123, false); 94 A.store.Int64(ptr + 72, 0); 95 A.store.Ref(ptr + 80, undefined); 96 A.store.Bool(ptr + 84, false); 97 A.store.Bool(ptr + 85, false); 98 A.store.Ref(ptr + 88, undefined); 99 A.store.Enum(ptr + 92, -1); 100 A.store.Ref(ptr + 96, undefined); 101 A.store.Ref(ptr + 100, undefined); 102 A.store.Bool(ptr + 124, false); 103 A.store.Int64(ptr + 104, 0); 104 A.store.Int64(ptr + 112, 0); 105 } else { 106 A.store.Bool(ptr + 125, true); 107 A.store.Bool(ptr + 0, x["active"] ? true : false); 108 A.store.Bool(ptr + 120, "audible" in x ? true : false); 109 A.store.Bool(ptr + 1, x["audible"] ? true : false); 110 A.store.Bool(ptr + 2, x["autoDiscardable"] ? true : false); 111 A.store.Bool(ptr + 3, x["discarded"] ? true : false); 112 A.store.Ref(ptr + 4, x["favIconUrl"]); 113 A.store.Int64(ptr + 8, x["groupId"] === undefined ? 0 : (x["groupId"] as number)); 114 A.store.Bool(ptr + 121, "height" in x ? true : false); 115 A.store.Int64(ptr + 16, x["height"] === undefined ? 0 : (x["height"] as number)); 116 A.store.Bool(ptr + 24, x["highlighted"] ? true : false); 117 A.store.Bool(ptr + 122, "id" in x ? true : false); 118 A.store.Int64(ptr + 32, x["id"] === undefined ? 0 : (x["id"] as number)); 119 A.store.Bool(ptr + 40, x["incognito"] ? true : false); 120 A.store.Int64(ptr + 48, x["index"] === undefined ? 0 : (x["index"] as number)); 121 122 if (typeof x["mutedInfo"] === "undefined") { 123 A.store.Bool(ptr + 56 + 12, false); 124 A.store.Ref(ptr + 56 + 0, undefined); 125 A.store.Bool(ptr + 56 + 4, false); 126 A.store.Enum(ptr + 56 + 8, -1); 127 } else { 128 A.store.Bool(ptr + 56 + 12, true); 129 A.store.Ref(ptr + 56 + 0, x["mutedInfo"]["extensionId"]); 130 A.store.Bool(ptr + 56 + 4, x["mutedInfo"]["muted"] ? true : false); 131 A.store.Enum(ptr + 56 + 8, ["user", "capture", "extension"].indexOf(x["mutedInfo"]["reason"] as string)); 132 } 133 A.store.Bool(ptr + 123, "openerTabId" in x ? true : false); 134 A.store.Int64(ptr + 72, x["openerTabId"] === undefined ? 0 : (x["openerTabId"] as number)); 135 A.store.Ref(ptr + 80, x["pendingUrl"]); 136 A.store.Bool(ptr + 84, x["pinned"] ? true : false); 137 A.store.Bool(ptr + 85, x["selected"] ? true : false); 138 A.store.Ref(ptr + 88, x["sessionId"]); 139 A.store.Enum(ptr + 92, ["unloaded", "loading", "complete"].indexOf(x["status"] as string)); 140 A.store.Ref(ptr + 96, x["title"]); 141 A.store.Ref(ptr + 100, x["url"]); 142 A.store.Bool(ptr + 124, "width" in x ? true : false); 143 A.store.Int64(ptr + 104, x["width"] === undefined ? 0 : (x["width"] as number)); 144 A.store.Int64(ptr + 112, x["windowId"] === undefined ? 0 : (x["windowId"] as number)); 145 } 146 }, 147 "load_Tab": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 148 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 149 150 x["active"] = A.load.Bool(ptr + 0); 151 if (A.load.Bool(ptr + 120)) { 152 x["audible"] = A.load.Bool(ptr + 1); 153 } else { 154 delete x["audible"]; 155 } 156 x["autoDiscardable"] = A.load.Bool(ptr + 2); 157 x["discarded"] = A.load.Bool(ptr + 3); 158 x["favIconUrl"] = A.load.Ref(ptr + 4, undefined); 159 x["groupId"] = A.load.Int64(ptr + 8); 160 if (A.load.Bool(ptr + 121)) { 161 x["height"] = A.load.Int64(ptr + 16); 162 } else { 163 delete x["height"]; 164 } 165 x["highlighted"] = A.load.Bool(ptr + 24); 166 if (A.load.Bool(ptr + 122)) { 167 x["id"] = A.load.Int64(ptr + 32); 168 } else { 169 delete x["id"]; 170 } 171 x["incognito"] = A.load.Bool(ptr + 40); 172 x["index"] = A.load.Int64(ptr + 48); 173 if (A.load.Bool(ptr + 56 + 12)) { 174 x["mutedInfo"] = {}; 175 x["mutedInfo"]["extensionId"] = A.load.Ref(ptr + 56 + 0, undefined); 176 x["mutedInfo"]["muted"] = A.load.Bool(ptr + 56 + 4); 177 x["mutedInfo"]["reason"] = A.load.Enum(ptr + 56 + 8, ["user", "capture", "extension"]); 178 } else { 179 delete x["mutedInfo"]; 180 } 181 if (A.load.Bool(ptr + 123)) { 182 x["openerTabId"] = A.load.Int64(ptr + 72); 183 } else { 184 delete x["openerTabId"]; 185 } 186 x["pendingUrl"] = A.load.Ref(ptr + 80, undefined); 187 x["pinned"] = A.load.Bool(ptr + 84); 188 x["selected"] = A.load.Bool(ptr + 85); 189 x["sessionId"] = A.load.Ref(ptr + 88, undefined); 190 x["status"] = A.load.Enum(ptr + 92, ["unloaded", "loading", "complete"]); 191 x["title"] = A.load.Ref(ptr + 96, undefined); 192 x["url"] = A.load.Ref(ptr + 100, undefined); 193 if (A.load.Bool(ptr + 124)) { 194 x["width"] = A.load.Int64(ptr + 104); 195 } else { 196 delete x["width"]; 197 } 198 x["windowId"] = A.load.Int64(ptr + 112); 199 return create === A.H.TRUE ? A.H.push(x) : ref; 200 }, 201 202 "store_CreateArgCreateProperties": (ptr: Pointer, ref: heap.Ref<any>) => { 203 const x = A.H.get<any>(ref); 204 205 if (typeof x === "undefined") { 206 A.store.Bool(ptr + 46, false); 207 A.store.Bool(ptr + 40, false); 208 A.store.Bool(ptr + 0, false); 209 A.store.Bool(ptr + 41, false); 210 A.store.Int64(ptr + 8, 0); 211 A.store.Bool(ptr + 42, false); 212 A.store.Int64(ptr + 16, 0); 213 A.store.Bool(ptr + 43, false); 214 A.store.Bool(ptr + 24, false); 215 A.store.Bool(ptr + 44, false); 216 A.store.Bool(ptr + 25, false); 217 A.store.Ref(ptr + 28, undefined); 218 A.store.Bool(ptr + 45, false); 219 A.store.Int64(ptr + 32, 0); 220 } else { 221 A.store.Bool(ptr + 46, true); 222 A.store.Bool(ptr + 40, "active" in x ? true : false); 223 A.store.Bool(ptr + 0, x["active"] ? true : false); 224 A.store.Bool(ptr + 41, "index" in x ? true : false); 225 A.store.Int64(ptr + 8, x["index"] === undefined ? 0 : (x["index"] as number)); 226 A.store.Bool(ptr + 42, "openerTabId" in x ? true : false); 227 A.store.Int64(ptr + 16, x["openerTabId"] === undefined ? 0 : (x["openerTabId"] as number)); 228 A.store.Bool(ptr + 43, "pinned" in x ? true : false); 229 A.store.Bool(ptr + 24, x["pinned"] ? true : false); 230 A.store.Bool(ptr + 44, "selected" in x ? true : false); 231 A.store.Bool(ptr + 25, x["selected"] ? true : false); 232 A.store.Ref(ptr + 28, x["url"]); 233 A.store.Bool(ptr + 45, "windowId" in x ? true : false); 234 A.store.Int64(ptr + 32, x["windowId"] === undefined ? 0 : (x["windowId"] as number)); 235 } 236 }, 237 "load_CreateArgCreateProperties": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 238 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 239 240 if (A.load.Bool(ptr + 40)) { 241 x["active"] = A.load.Bool(ptr + 0); 242 } else { 243 delete x["active"]; 244 } 245 if (A.load.Bool(ptr + 41)) { 246 x["index"] = A.load.Int64(ptr + 8); 247 } else { 248 delete x["index"]; 249 } 250 if (A.load.Bool(ptr + 42)) { 251 x["openerTabId"] = A.load.Int64(ptr + 16); 252 } else { 253 delete x["openerTabId"]; 254 } 255 if (A.load.Bool(ptr + 43)) { 256 x["pinned"] = A.load.Bool(ptr + 24); 257 } else { 258 delete x["pinned"]; 259 } 260 if (A.load.Bool(ptr + 44)) { 261 x["selected"] = A.load.Bool(ptr + 25); 262 } else { 263 delete x["selected"]; 264 } 265 x["url"] = A.load.Ref(ptr + 28, undefined); 266 if (A.load.Bool(ptr + 45)) { 267 x["windowId"] = A.load.Int64(ptr + 32); 268 } else { 269 delete x["windowId"]; 270 } 271 return create === A.H.TRUE ? A.H.push(x) : ref; 272 }, 273 274 "store_GroupArgOptionsFieldCreateProperties": (ptr: Pointer, ref: heap.Ref<any>) => { 275 const x = A.H.get<any>(ref); 276 277 if (typeof x === "undefined") { 278 A.store.Bool(ptr + 9, false); 279 A.store.Bool(ptr + 8, false); 280 A.store.Int64(ptr + 0, 0); 281 } else { 282 A.store.Bool(ptr + 9, true); 283 A.store.Bool(ptr + 8, "windowId" in x ? true : false); 284 A.store.Int64(ptr + 0, x["windowId"] === undefined ? 0 : (x["windowId"] as number)); 285 } 286 }, 287 "load_GroupArgOptionsFieldCreateProperties": ( 288 ptr: Pointer, 289 create: heap.Ref<boolean>, 290 ref: heap.Ref<any> 291 ): heap.Ref<any> => { 292 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 293 294 if (A.load.Bool(ptr + 8)) { 295 x["windowId"] = A.load.Int64(ptr + 0); 296 } else { 297 delete x["windowId"]; 298 } 299 return create === A.H.TRUE ? A.H.push(x) : ref; 300 }, 301 302 "store_GroupArgOptions": (ptr: Pointer, ref: heap.Ref<any>) => { 303 const x = A.H.get<any>(ref); 304 305 if (typeof x === "undefined") { 306 A.store.Bool(ptr + 29, false); 307 308 A.store.Bool(ptr + 0 + 9, false); 309 A.store.Bool(ptr + 0 + 8, false); 310 A.store.Int64(ptr + 0 + 0, 0); 311 A.store.Bool(ptr + 28, false); 312 A.store.Int64(ptr + 16, 0); 313 A.store.Ref(ptr + 24, undefined); 314 } else { 315 A.store.Bool(ptr + 29, true); 316 317 if (typeof x["createProperties"] === "undefined") { 318 A.store.Bool(ptr + 0 + 9, false); 319 A.store.Bool(ptr + 0 + 8, false); 320 A.store.Int64(ptr + 0 + 0, 0); 321 } else { 322 A.store.Bool(ptr + 0 + 9, true); 323 A.store.Bool(ptr + 0 + 8, "windowId" in x["createProperties"] ? true : false); 324 A.store.Int64( 325 ptr + 0 + 0, 326 x["createProperties"]["windowId"] === undefined ? 0 : (x["createProperties"]["windowId"] as number) 327 ); 328 } 329 A.store.Bool(ptr + 28, "groupId" in x ? true : false); 330 A.store.Int64(ptr + 16, x["groupId"] === undefined ? 0 : (x["groupId"] as number)); 331 A.store.Ref(ptr + 24, x["tabIds"]); 332 } 333 }, 334 "load_GroupArgOptions": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 335 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 336 337 if (A.load.Bool(ptr + 0 + 9)) { 338 x["createProperties"] = {}; 339 if (A.load.Bool(ptr + 0 + 8)) { 340 x["createProperties"]["windowId"] = A.load.Int64(ptr + 0 + 0); 341 } else { 342 delete x["createProperties"]["windowId"]; 343 } 344 } else { 345 delete x["createProperties"]; 346 } 347 if (A.load.Bool(ptr + 28)) { 348 x["groupId"] = A.load.Int64(ptr + 16); 349 } else { 350 delete x["groupId"]; 351 } 352 x["tabIds"] = A.load.Ref(ptr + 24, undefined); 353 return create === A.H.TRUE ? A.H.push(x) : ref; 354 }, 355 356 "store_HighlightArgHighlightInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 357 const x = A.H.get<any>(ref); 358 359 if (typeof x === "undefined") { 360 A.store.Bool(ptr + 17, false); 361 A.store.Ref(ptr + 0, undefined); 362 A.store.Bool(ptr + 16, false); 363 A.store.Int64(ptr + 8, 0); 364 } else { 365 A.store.Bool(ptr + 17, true); 366 A.store.Ref(ptr + 0, x["tabs"]); 367 A.store.Bool(ptr + 16, "windowId" in x ? true : false); 368 A.store.Int64(ptr + 8, x["windowId"] === undefined ? 0 : (x["windowId"] as number)); 369 } 370 }, 371 "load_HighlightArgHighlightInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 372 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 373 374 x["tabs"] = A.load.Ref(ptr + 0, undefined); 375 if (A.load.Bool(ptr + 16)) { 376 x["windowId"] = A.load.Int64(ptr + 8); 377 } else { 378 delete x["windowId"]; 379 } 380 return create === A.H.TRUE ? A.H.push(x) : ref; 381 }, 382 "get_MAX_CAPTURE_VISIBLE_TAB_CALLS_PER_SECOND": (retPtr: Pointer): heap.Ref<boolean> => { 383 if (WEBEXT?.tabs && "MAX_CAPTURE_VISIBLE_TAB_CALLS_PER_SECOND" in WEBEXT?.tabs) { 384 const val = WEBEXT.tabs.MAX_CAPTURE_VISIBLE_TAB_CALLS_PER_SECOND; 385 A.store.Ref(retPtr, val); 386 return A.H.TRUE; 387 } 388 389 return A.H.FALSE; 390 }, 391 "set_MAX_CAPTURE_VISIBLE_TAB_CALLS_PER_SECOND": (val: heap.Ref<object>): heap.Ref<boolean> => { 392 return Reflect.set(WEBEXT.tabs, "MAX_CAPTURE_VISIBLE_TAB_CALLS_PER_SECOND", A.H.get<object>(val), WEBEXT.tabs) 393 ? A.H.TRUE 394 : A.H.FALSE; 395 }, 396 397 "store_MoveArgMoveProperties": (ptr: Pointer, ref: heap.Ref<any>) => { 398 const x = A.H.get<any>(ref); 399 400 if (typeof x === "undefined") { 401 A.store.Bool(ptr + 17, false); 402 A.store.Int64(ptr + 0, 0); 403 A.store.Bool(ptr + 16, false); 404 A.store.Int64(ptr + 8, 0); 405 } else { 406 A.store.Bool(ptr + 17, true); 407 A.store.Int64(ptr + 0, x["index"] === undefined ? 0 : (x["index"] as number)); 408 A.store.Bool(ptr + 16, "windowId" in x ? true : false); 409 A.store.Int64(ptr + 8, x["windowId"] === undefined ? 0 : (x["windowId"] as number)); 410 } 411 }, 412 "load_MoveArgMoveProperties": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 413 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 414 415 x["index"] = A.load.Int64(ptr + 0); 416 if (A.load.Bool(ptr + 16)) { 417 x["windowId"] = A.load.Int64(ptr + 8); 418 } else { 419 delete x["windowId"]; 420 } 421 return create === A.H.TRUE ? A.H.push(x) : ref; 422 }, 423 424 "store_OnActivatedArgActiveInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 425 const x = A.H.get<any>(ref); 426 427 if (typeof x === "undefined") { 428 A.store.Bool(ptr + 16, false); 429 A.store.Int64(ptr + 0, 0); 430 A.store.Int64(ptr + 8, 0); 431 } else { 432 A.store.Bool(ptr + 16, true); 433 A.store.Int64(ptr + 0, x["tabId"] === undefined ? 0 : (x["tabId"] as number)); 434 A.store.Int64(ptr + 8, x["windowId"] === undefined ? 0 : (x["windowId"] as number)); 435 } 436 }, 437 "load_OnActivatedArgActiveInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 438 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 439 440 x["tabId"] = A.load.Int64(ptr + 0); 441 x["windowId"] = A.load.Int64(ptr + 8); 442 return create === A.H.TRUE ? A.H.push(x) : ref; 443 }, 444 445 "store_OnActiveChangedArgSelectInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 446 const x = A.H.get<any>(ref); 447 448 if (typeof x === "undefined") { 449 A.store.Bool(ptr + 8, false); 450 A.store.Int64(ptr + 0, 0); 451 } else { 452 A.store.Bool(ptr + 8, true); 453 A.store.Int64(ptr + 0, x["windowId"] === undefined ? 0 : (x["windowId"] as number)); 454 } 455 }, 456 "load_OnActiveChangedArgSelectInfo": ( 457 ptr: Pointer, 458 create: heap.Ref<boolean>, 459 ref: heap.Ref<any> 460 ): heap.Ref<any> => { 461 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 462 463 x["windowId"] = A.load.Int64(ptr + 0); 464 return create === A.H.TRUE ? A.H.push(x) : ref; 465 }, 466 467 "store_OnAttachedArgAttachInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 468 const x = A.H.get<any>(ref); 469 470 if (typeof x === "undefined") { 471 A.store.Bool(ptr + 16, false); 472 A.store.Int64(ptr + 0, 0); 473 A.store.Int64(ptr + 8, 0); 474 } else { 475 A.store.Bool(ptr + 16, true); 476 A.store.Int64(ptr + 0, x["newPosition"] === undefined ? 0 : (x["newPosition"] as number)); 477 A.store.Int64(ptr + 8, x["newWindowId"] === undefined ? 0 : (x["newWindowId"] as number)); 478 } 479 }, 480 "load_OnAttachedArgAttachInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 481 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 482 483 x["newPosition"] = A.load.Int64(ptr + 0); 484 x["newWindowId"] = A.load.Int64(ptr + 8); 485 return create === A.H.TRUE ? A.H.push(x) : ref; 486 }, 487 488 "store_OnDetachedArgDetachInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 489 const x = A.H.get<any>(ref); 490 491 if (typeof x === "undefined") { 492 A.store.Bool(ptr + 16, false); 493 A.store.Int64(ptr + 0, 0); 494 A.store.Int64(ptr + 8, 0); 495 } else { 496 A.store.Bool(ptr + 16, true); 497 A.store.Int64(ptr + 0, x["oldPosition"] === undefined ? 0 : (x["oldPosition"] as number)); 498 A.store.Int64(ptr + 8, x["oldWindowId"] === undefined ? 0 : (x["oldWindowId"] as number)); 499 } 500 }, 501 "load_OnDetachedArgDetachInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 502 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 503 504 x["oldPosition"] = A.load.Int64(ptr + 0); 505 x["oldWindowId"] = A.load.Int64(ptr + 8); 506 return create === A.H.TRUE ? A.H.push(x) : ref; 507 }, 508 509 "store_OnHighlightChangedArgSelectInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 510 const x = A.H.get<any>(ref); 511 512 if (typeof x === "undefined") { 513 A.store.Bool(ptr + 16, false); 514 A.store.Ref(ptr + 0, undefined); 515 A.store.Int64(ptr + 8, 0); 516 } else { 517 A.store.Bool(ptr + 16, true); 518 A.store.Ref(ptr + 0, x["tabIds"]); 519 A.store.Int64(ptr + 8, x["windowId"] === undefined ? 0 : (x["windowId"] as number)); 520 } 521 }, 522 "load_OnHighlightChangedArgSelectInfo": ( 523 ptr: Pointer, 524 create: heap.Ref<boolean>, 525 ref: heap.Ref<any> 526 ): heap.Ref<any> => { 527 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 528 529 x["tabIds"] = A.load.Ref(ptr + 0, undefined); 530 x["windowId"] = A.load.Int64(ptr + 8); 531 return create === A.H.TRUE ? A.H.push(x) : ref; 532 }, 533 534 "store_OnHighlightedArgHighlightInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 535 const x = A.H.get<any>(ref); 536 537 if (typeof x === "undefined") { 538 A.store.Bool(ptr + 16, false); 539 A.store.Ref(ptr + 0, undefined); 540 A.store.Int64(ptr + 8, 0); 541 } else { 542 A.store.Bool(ptr + 16, true); 543 A.store.Ref(ptr + 0, x["tabIds"]); 544 A.store.Int64(ptr + 8, x["windowId"] === undefined ? 0 : (x["windowId"] as number)); 545 } 546 }, 547 "load_OnHighlightedArgHighlightInfo": ( 548 ptr: Pointer, 549 create: heap.Ref<boolean>, 550 ref: heap.Ref<any> 551 ): heap.Ref<any> => { 552 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 553 554 x["tabIds"] = A.load.Ref(ptr + 0, undefined); 555 x["windowId"] = A.load.Int64(ptr + 8); 556 return create === A.H.TRUE ? A.H.push(x) : ref; 557 }, 558 559 "store_OnMovedArgMoveInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 560 const x = A.H.get<any>(ref); 561 562 if (typeof x === "undefined") { 563 A.store.Bool(ptr + 24, false); 564 A.store.Int64(ptr + 0, 0); 565 A.store.Int64(ptr + 8, 0); 566 A.store.Int64(ptr + 16, 0); 567 } else { 568 A.store.Bool(ptr + 24, true); 569 A.store.Int64(ptr + 0, x["fromIndex"] === undefined ? 0 : (x["fromIndex"] as number)); 570 A.store.Int64(ptr + 8, x["toIndex"] === undefined ? 0 : (x["toIndex"] as number)); 571 A.store.Int64(ptr + 16, x["windowId"] === undefined ? 0 : (x["windowId"] as number)); 572 } 573 }, 574 "load_OnMovedArgMoveInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 575 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 576 577 x["fromIndex"] = A.load.Int64(ptr + 0); 578 x["toIndex"] = A.load.Int64(ptr + 8); 579 x["windowId"] = A.load.Int64(ptr + 16); 580 return create === A.H.TRUE ? A.H.push(x) : ref; 581 }, 582 583 "store_OnRemovedArgRemoveInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 584 const x = A.H.get<any>(ref); 585 586 if (typeof x === "undefined") { 587 A.store.Bool(ptr + 16, false); 588 A.store.Bool(ptr + 0, false); 589 A.store.Int64(ptr + 8, 0); 590 } else { 591 A.store.Bool(ptr + 16, true); 592 A.store.Bool(ptr + 0, x["isWindowClosing"] ? true : false); 593 A.store.Int64(ptr + 8, x["windowId"] === undefined ? 0 : (x["windowId"] as number)); 594 } 595 }, 596 "load_OnRemovedArgRemoveInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 597 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 598 599 x["isWindowClosing"] = A.load.Bool(ptr + 0); 600 x["windowId"] = A.load.Int64(ptr + 8); 601 return create === A.H.TRUE ? A.H.push(x) : ref; 602 }, 603 604 "store_OnSelectionChangedArgSelectInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 605 const x = A.H.get<any>(ref); 606 607 if (typeof x === "undefined") { 608 A.store.Bool(ptr + 8, false); 609 A.store.Int64(ptr + 0, 0); 610 } else { 611 A.store.Bool(ptr + 8, true); 612 A.store.Int64(ptr + 0, x["windowId"] === undefined ? 0 : (x["windowId"] as number)); 613 } 614 }, 615 "load_OnSelectionChangedArgSelectInfo": ( 616 ptr: Pointer, 617 create: heap.Ref<boolean>, 618 ref: heap.Ref<any> 619 ): heap.Ref<any> => { 620 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 621 622 x["windowId"] = A.load.Int64(ptr + 0); 623 return create === A.H.TRUE ? A.H.push(x) : ref; 624 }, 625 626 "store_OnUpdatedArgChangeInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 627 const x = A.H.get<any>(ref); 628 629 if (typeof x === "undefined") { 630 A.store.Bool(ptr + 49, false); 631 A.store.Bool(ptr + 44, false); 632 A.store.Bool(ptr + 0, false); 633 A.store.Bool(ptr + 45, false); 634 A.store.Bool(ptr + 1, false); 635 A.store.Bool(ptr + 46, false); 636 A.store.Bool(ptr + 2, false); 637 A.store.Ref(ptr + 4, undefined); 638 A.store.Bool(ptr + 47, false); 639 A.store.Int64(ptr + 8, 0); 640 641 A.store.Bool(ptr + 16 + 12, false); 642 A.store.Ref(ptr + 16 + 0, undefined); 643 A.store.Bool(ptr + 16 + 4, false); 644 A.store.Enum(ptr + 16 + 8, -1); 645 A.store.Bool(ptr + 48, false); 646 A.store.Bool(ptr + 29, false); 647 A.store.Enum(ptr + 32, -1); 648 A.store.Ref(ptr + 36, undefined); 649 A.store.Ref(ptr + 40, undefined); 650 } else { 651 A.store.Bool(ptr + 49, true); 652 A.store.Bool(ptr + 44, "audible" in x ? true : false); 653 A.store.Bool(ptr + 0, x["audible"] ? true : false); 654 A.store.Bool(ptr + 45, "autoDiscardable" in x ? true : false); 655 A.store.Bool(ptr + 1, x["autoDiscardable"] ? true : false); 656 A.store.Bool(ptr + 46, "discarded" in x ? true : false); 657 A.store.Bool(ptr + 2, x["discarded"] ? true : false); 658 A.store.Ref(ptr + 4, x["favIconUrl"]); 659 A.store.Bool(ptr + 47, "groupId" in x ? true : false); 660 A.store.Int64(ptr + 8, x["groupId"] === undefined ? 0 : (x["groupId"] as number)); 661 662 if (typeof x["mutedInfo"] === "undefined") { 663 A.store.Bool(ptr + 16 + 12, false); 664 A.store.Ref(ptr + 16 + 0, undefined); 665 A.store.Bool(ptr + 16 + 4, false); 666 A.store.Enum(ptr + 16 + 8, -1); 667 } else { 668 A.store.Bool(ptr + 16 + 12, true); 669 A.store.Ref(ptr + 16 + 0, x["mutedInfo"]["extensionId"]); 670 A.store.Bool(ptr + 16 + 4, x["mutedInfo"]["muted"] ? true : false); 671 A.store.Enum(ptr + 16 + 8, ["user", "capture", "extension"].indexOf(x["mutedInfo"]["reason"] as string)); 672 } 673 A.store.Bool(ptr + 48, "pinned" in x ? true : false); 674 A.store.Bool(ptr + 29, x["pinned"] ? true : false); 675 A.store.Enum(ptr + 32, ["unloaded", "loading", "complete"].indexOf(x["status"] as string)); 676 A.store.Ref(ptr + 36, x["title"]); 677 A.store.Ref(ptr + 40, x["url"]); 678 } 679 }, 680 "load_OnUpdatedArgChangeInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 681 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 682 683 if (A.load.Bool(ptr + 44)) { 684 x["audible"] = A.load.Bool(ptr + 0); 685 } else { 686 delete x["audible"]; 687 } 688 if (A.load.Bool(ptr + 45)) { 689 x["autoDiscardable"] = A.load.Bool(ptr + 1); 690 } else { 691 delete x["autoDiscardable"]; 692 } 693 if (A.load.Bool(ptr + 46)) { 694 x["discarded"] = A.load.Bool(ptr + 2); 695 } else { 696 delete x["discarded"]; 697 } 698 x["favIconUrl"] = A.load.Ref(ptr + 4, undefined); 699 if (A.load.Bool(ptr + 47)) { 700 x["groupId"] = A.load.Int64(ptr + 8); 701 } else { 702 delete x["groupId"]; 703 } 704 if (A.load.Bool(ptr + 16 + 12)) { 705 x["mutedInfo"] = {}; 706 x["mutedInfo"]["extensionId"] = A.load.Ref(ptr + 16 + 0, undefined); 707 x["mutedInfo"]["muted"] = A.load.Bool(ptr + 16 + 4); 708 x["mutedInfo"]["reason"] = A.load.Enum(ptr + 16 + 8, ["user", "capture", "extension"]); 709 } else { 710 delete x["mutedInfo"]; 711 } 712 if (A.load.Bool(ptr + 48)) { 713 x["pinned"] = A.load.Bool(ptr + 29); 714 } else { 715 delete x["pinned"]; 716 } 717 x["status"] = A.load.Enum(ptr + 32, ["unloaded", "loading", "complete"]); 718 x["title"] = A.load.Ref(ptr + 36, undefined); 719 x["url"] = A.load.Ref(ptr + 40, undefined); 720 return create === A.H.TRUE ? A.H.push(x) : ref; 721 }, 722 "constof_ZoomSettingsMode": (ref: heap.Ref<string>): number => { 723 const idx = ["automatic", "manual", "disabled"].indexOf(A.H.get(ref)); 724 return idx < 0 ? 0 : idx + 1; 725 }, 726 "constof_ZoomSettingsScope": (ref: heap.Ref<string>): number => { 727 const idx = ["per-origin", "per-tab"].indexOf(A.H.get(ref)); 728 return idx < 0 ? 0 : idx + 1; 729 }, 730 731 "store_ZoomSettings": (ptr: Pointer, ref: heap.Ref<any>) => { 732 const x = A.H.get<any>(ref); 733 734 if (typeof x === "undefined") { 735 A.store.Bool(ptr + 17, false); 736 A.store.Bool(ptr + 16, false); 737 A.store.Float64(ptr + 0, 0); 738 A.store.Enum(ptr + 8, -1); 739 A.store.Enum(ptr + 12, -1); 740 } else { 741 A.store.Bool(ptr + 17, true); 742 A.store.Bool(ptr + 16, "defaultZoomFactor" in x ? true : false); 743 A.store.Float64(ptr + 0, x["defaultZoomFactor"] === undefined ? 0 : (x["defaultZoomFactor"] as number)); 744 A.store.Enum(ptr + 8, ["automatic", "manual", "disabled"].indexOf(x["mode"] as string)); 745 A.store.Enum(ptr + 12, ["per-origin", "per-tab"].indexOf(x["scope"] as string)); 746 } 747 }, 748 "load_ZoomSettings": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 749 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 750 751 if (A.load.Bool(ptr + 16)) { 752 x["defaultZoomFactor"] = A.load.Float64(ptr + 0); 753 } else { 754 delete x["defaultZoomFactor"]; 755 } 756 x["mode"] = A.load.Enum(ptr + 8, ["automatic", "manual", "disabled"]); 757 x["scope"] = A.load.Enum(ptr + 12, ["per-origin", "per-tab"]); 758 return create === A.H.TRUE ? A.H.push(x) : ref; 759 }, 760 761 "store_OnZoomChangeArgZoomChangeInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 762 const x = A.H.get<any>(ref); 763 764 if (typeof x === "undefined") { 765 A.store.Bool(ptr + 42, false); 766 A.store.Float64(ptr + 0, 0); 767 A.store.Float64(ptr + 8, 0); 768 A.store.Int64(ptr + 16, 0); 769 770 A.store.Bool(ptr + 24 + 17, false); 771 A.store.Bool(ptr + 24 + 16, false); 772 A.store.Float64(ptr + 24 + 0, 0); 773 A.store.Enum(ptr + 24 + 8, -1); 774 A.store.Enum(ptr + 24 + 12, -1); 775 } else { 776 A.store.Bool(ptr + 42, true); 777 A.store.Float64(ptr + 0, x["newZoomFactor"] === undefined ? 0 : (x["newZoomFactor"] as number)); 778 A.store.Float64(ptr + 8, x["oldZoomFactor"] === undefined ? 0 : (x["oldZoomFactor"] as number)); 779 A.store.Int64(ptr + 16, x["tabId"] === undefined ? 0 : (x["tabId"] as number)); 780 781 if (typeof x["zoomSettings"] === "undefined") { 782 A.store.Bool(ptr + 24 + 17, false); 783 A.store.Bool(ptr + 24 + 16, false); 784 A.store.Float64(ptr + 24 + 0, 0); 785 A.store.Enum(ptr + 24 + 8, -1); 786 A.store.Enum(ptr + 24 + 12, -1); 787 } else { 788 A.store.Bool(ptr + 24 + 17, true); 789 A.store.Bool(ptr + 24 + 16, "defaultZoomFactor" in x["zoomSettings"] ? true : false); 790 A.store.Float64( 791 ptr + 24 + 0, 792 x["zoomSettings"]["defaultZoomFactor"] === undefined 793 ? 0 794 : (x["zoomSettings"]["defaultZoomFactor"] as number) 795 ); 796 A.store.Enum(ptr + 24 + 8, ["automatic", "manual", "disabled"].indexOf(x["zoomSettings"]["mode"] as string)); 797 A.store.Enum(ptr + 24 + 12, ["per-origin", "per-tab"].indexOf(x["zoomSettings"]["scope"] as string)); 798 } 799 } 800 }, 801 "load_OnZoomChangeArgZoomChangeInfo": ( 802 ptr: Pointer, 803 create: heap.Ref<boolean>, 804 ref: heap.Ref<any> 805 ): heap.Ref<any> => { 806 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 807 808 x["newZoomFactor"] = A.load.Float64(ptr + 0); 809 x["oldZoomFactor"] = A.load.Float64(ptr + 8); 810 x["tabId"] = A.load.Int64(ptr + 16); 811 if (A.load.Bool(ptr + 24 + 17)) { 812 x["zoomSettings"] = {}; 813 if (A.load.Bool(ptr + 24 + 16)) { 814 x["zoomSettings"]["defaultZoomFactor"] = A.load.Float64(ptr + 24 + 0); 815 } else { 816 delete x["zoomSettings"]["defaultZoomFactor"]; 817 } 818 x["zoomSettings"]["mode"] = A.load.Enum(ptr + 24 + 8, ["automatic", "manual", "disabled"]); 819 x["zoomSettings"]["scope"] = A.load.Enum(ptr + 24 + 12, ["per-origin", "per-tab"]); 820 } else { 821 delete x["zoomSettings"]; 822 } 823 return create === A.H.TRUE ? A.H.push(x) : ref; 824 }, 825 "constof_WindowType": (ref: heap.Ref<string>): number => { 826 const idx = ["normal", "popup", "panel", "app", "devtools"].indexOf(A.H.get(ref)); 827 return idx < 0 ? 0 : idx + 1; 828 }, 829 830 "store_QueryArgQueryInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 831 const x = A.H.get<any>(ref); 832 833 if (typeof x === "undefined") { 834 A.store.Bool(ptr + 72, false); 835 A.store.Bool(ptr + 60, false); 836 A.store.Bool(ptr + 0, false); 837 A.store.Bool(ptr + 61, false); 838 A.store.Bool(ptr + 1, false); 839 A.store.Bool(ptr + 62, false); 840 A.store.Bool(ptr + 2, false); 841 A.store.Bool(ptr + 63, false); 842 A.store.Bool(ptr + 3, false); 843 A.store.Bool(ptr + 64, false); 844 A.store.Bool(ptr + 4, false); 845 A.store.Bool(ptr + 65, false); 846 A.store.Int64(ptr + 8, 0); 847 A.store.Bool(ptr + 66, false); 848 A.store.Bool(ptr + 16, false); 849 A.store.Bool(ptr + 67, false); 850 A.store.Int64(ptr + 24, 0); 851 A.store.Bool(ptr + 68, false); 852 A.store.Bool(ptr + 32, false); 853 A.store.Bool(ptr + 69, false); 854 A.store.Bool(ptr + 33, false); 855 A.store.Bool(ptr + 70, false); 856 A.store.Bool(ptr + 34, false); 857 A.store.Enum(ptr + 36, -1); 858 A.store.Ref(ptr + 40, undefined); 859 A.store.Ref(ptr + 44, undefined); 860 A.store.Bool(ptr + 71, false); 861 A.store.Int64(ptr + 48, 0); 862 A.store.Enum(ptr + 56, -1); 863 } else { 864 A.store.Bool(ptr + 72, true); 865 A.store.Bool(ptr + 60, "active" in x ? true : false); 866 A.store.Bool(ptr + 0, x["active"] ? true : false); 867 A.store.Bool(ptr + 61, "audible" in x ? true : false); 868 A.store.Bool(ptr + 1, x["audible"] ? true : false); 869 A.store.Bool(ptr + 62, "autoDiscardable" in x ? true : false); 870 A.store.Bool(ptr + 2, x["autoDiscardable"] ? true : false); 871 A.store.Bool(ptr + 63, "currentWindow" in x ? true : false); 872 A.store.Bool(ptr + 3, x["currentWindow"] ? true : false); 873 A.store.Bool(ptr + 64, "discarded" in x ? true : false); 874 A.store.Bool(ptr + 4, x["discarded"] ? true : false); 875 A.store.Bool(ptr + 65, "groupId" in x ? true : false); 876 A.store.Int64(ptr + 8, x["groupId"] === undefined ? 0 : (x["groupId"] as number)); 877 A.store.Bool(ptr + 66, "highlighted" in x ? true : false); 878 A.store.Bool(ptr + 16, x["highlighted"] ? true : false); 879 A.store.Bool(ptr + 67, "index" in x ? true : false); 880 A.store.Int64(ptr + 24, x["index"] === undefined ? 0 : (x["index"] as number)); 881 A.store.Bool(ptr + 68, "lastFocusedWindow" in x ? true : false); 882 A.store.Bool(ptr + 32, x["lastFocusedWindow"] ? true : false); 883 A.store.Bool(ptr + 69, "muted" in x ? true : false); 884 A.store.Bool(ptr + 33, x["muted"] ? true : false); 885 A.store.Bool(ptr + 70, "pinned" in x ? true : false); 886 A.store.Bool(ptr + 34, x["pinned"] ? true : false); 887 A.store.Enum(ptr + 36, ["unloaded", "loading", "complete"].indexOf(x["status"] as string)); 888 A.store.Ref(ptr + 40, x["title"]); 889 A.store.Ref(ptr + 44, x["url"]); 890 A.store.Bool(ptr + 71, "windowId" in x ? true : false); 891 A.store.Int64(ptr + 48, x["windowId"] === undefined ? 0 : (x["windowId"] as number)); 892 A.store.Enum(ptr + 56, ["normal", "popup", "panel", "app", "devtools"].indexOf(x["windowType"] as string)); 893 } 894 }, 895 "load_QueryArgQueryInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 896 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 897 898 if (A.load.Bool(ptr + 60)) { 899 x["active"] = A.load.Bool(ptr + 0); 900 } else { 901 delete x["active"]; 902 } 903 if (A.load.Bool(ptr + 61)) { 904 x["audible"] = A.load.Bool(ptr + 1); 905 } else { 906 delete x["audible"]; 907 } 908 if (A.load.Bool(ptr + 62)) { 909 x["autoDiscardable"] = A.load.Bool(ptr + 2); 910 } else { 911 delete x["autoDiscardable"]; 912 } 913 if (A.load.Bool(ptr + 63)) { 914 x["currentWindow"] = A.load.Bool(ptr + 3); 915 } else { 916 delete x["currentWindow"]; 917 } 918 if (A.load.Bool(ptr + 64)) { 919 x["discarded"] = A.load.Bool(ptr + 4); 920 } else { 921 delete x["discarded"]; 922 } 923 if (A.load.Bool(ptr + 65)) { 924 x["groupId"] = A.load.Int64(ptr + 8); 925 } else { 926 delete x["groupId"]; 927 } 928 if (A.load.Bool(ptr + 66)) { 929 x["highlighted"] = A.load.Bool(ptr + 16); 930 } else { 931 delete x["highlighted"]; 932 } 933 if (A.load.Bool(ptr + 67)) { 934 x["index"] = A.load.Int64(ptr + 24); 935 } else { 936 delete x["index"]; 937 } 938 if (A.load.Bool(ptr + 68)) { 939 x["lastFocusedWindow"] = A.load.Bool(ptr + 32); 940 } else { 941 delete x["lastFocusedWindow"]; 942 } 943 if (A.load.Bool(ptr + 69)) { 944 x["muted"] = A.load.Bool(ptr + 33); 945 } else { 946 delete x["muted"]; 947 } 948 if (A.load.Bool(ptr + 70)) { 949 x["pinned"] = A.load.Bool(ptr + 34); 950 } else { 951 delete x["pinned"]; 952 } 953 x["status"] = A.load.Enum(ptr + 36, ["unloaded", "loading", "complete"]); 954 x["title"] = A.load.Ref(ptr + 40, undefined); 955 x["url"] = A.load.Ref(ptr + 44, undefined); 956 if (A.load.Bool(ptr + 71)) { 957 x["windowId"] = A.load.Int64(ptr + 48); 958 } else { 959 delete x["windowId"]; 960 } 961 x["windowType"] = A.load.Enum(ptr + 56, ["normal", "popup", "panel", "app", "devtools"]); 962 return create === A.H.TRUE ? A.H.push(x) : ref; 963 }, 964 965 "store_ReloadArgReloadProperties": (ptr: Pointer, ref: heap.Ref<any>) => { 966 const x = A.H.get<any>(ref); 967 968 if (typeof x === "undefined") { 969 A.store.Bool(ptr + 2, false); 970 A.store.Bool(ptr + 1, false); 971 A.store.Bool(ptr + 0, false); 972 } else { 973 A.store.Bool(ptr + 2, true); 974 A.store.Bool(ptr + 1, "bypassCache" in x ? true : false); 975 A.store.Bool(ptr + 0, x["bypassCache"] ? true : false); 976 } 977 }, 978 "load_ReloadArgReloadProperties": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 979 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 980 981 if (A.load.Bool(ptr + 1)) { 982 x["bypassCache"] = A.load.Bool(ptr + 0); 983 } else { 984 delete x["bypassCache"]; 985 } 986 return create === A.H.TRUE ? A.H.push(x) : ref; 987 }, 988 989 "store_SendMessageArgOptions": (ptr: Pointer, ref: heap.Ref<any>) => { 990 const x = A.H.get<any>(ref); 991 992 if (typeof x === "undefined") { 993 A.store.Bool(ptr + 17, false); 994 A.store.Ref(ptr + 0, undefined); 995 A.store.Bool(ptr + 16, false); 996 A.store.Int64(ptr + 8, 0); 997 } else { 998 A.store.Bool(ptr + 17, true); 999 A.store.Ref(ptr + 0, x["documentId"]); 1000 A.store.Bool(ptr + 16, "frameId" in x ? true : false); 1001 A.store.Int64(ptr + 8, x["frameId"] === undefined ? 0 : (x["frameId"] as number)); 1002 } 1003 }, 1004 "load_SendMessageArgOptions": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 1005 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 1006 1007 x["documentId"] = A.load.Ref(ptr + 0, undefined); 1008 if (A.load.Bool(ptr + 16)) { 1009 x["frameId"] = A.load.Int64(ptr + 8); 1010 } else { 1011 delete x["frameId"]; 1012 } 1013 return create === A.H.TRUE ? A.H.push(x) : ref; 1014 }, 1015 "get_TAB_ID_NONE": (retPtr: Pointer): heap.Ref<boolean> => { 1016 if (WEBEXT?.tabs && "TAB_ID_NONE" in WEBEXT?.tabs) { 1017 const val = WEBEXT.tabs.TAB_ID_NONE; 1018 A.store.Ref(retPtr, val); 1019 return A.H.TRUE; 1020 } 1021 1022 return A.H.FALSE; 1023 }, 1024 "set_TAB_ID_NONE": (val: heap.Ref<object>): heap.Ref<boolean> => { 1025 return Reflect.set(WEBEXT.tabs, "TAB_ID_NONE", A.H.get<object>(val), WEBEXT.tabs) ? A.H.TRUE : A.H.FALSE; 1026 }, 1027 1028 "store_UpdateArgUpdateProperties": (ptr: Pointer, ref: heap.Ref<any>) => { 1029 const x = A.H.get<any>(ref); 1030 1031 if (typeof x === "undefined") { 1032 A.store.Bool(ptr + 31, false); 1033 A.store.Bool(ptr + 24, false); 1034 A.store.Bool(ptr + 0, false); 1035 A.store.Bool(ptr + 25, false); 1036 A.store.Bool(ptr + 1, false); 1037 A.store.Bool(ptr + 26, false); 1038 A.store.Bool(ptr + 2, false); 1039 A.store.Bool(ptr + 27, false); 1040 A.store.Bool(ptr + 3, false); 1041 A.store.Bool(ptr + 28, false); 1042 A.store.Int64(ptr + 8, 0); 1043 A.store.Bool(ptr + 29, false); 1044 A.store.Bool(ptr + 16, false); 1045 A.store.Bool(ptr + 30, false); 1046 A.store.Bool(ptr + 17, false); 1047 A.store.Ref(ptr + 20, undefined); 1048 } else { 1049 A.store.Bool(ptr + 31, true); 1050 A.store.Bool(ptr + 24, "active" in x ? true : false); 1051 A.store.Bool(ptr + 0, x["active"] ? true : false); 1052 A.store.Bool(ptr + 25, "autoDiscardable" in x ? true : false); 1053 A.store.Bool(ptr + 1, x["autoDiscardable"] ? true : false); 1054 A.store.Bool(ptr + 26, "highlighted" in x ? true : false); 1055 A.store.Bool(ptr + 2, x["highlighted"] ? true : false); 1056 A.store.Bool(ptr + 27, "muted" in x ? true : false); 1057 A.store.Bool(ptr + 3, x["muted"] ? true : false); 1058 A.store.Bool(ptr + 28, "openerTabId" in x ? true : false); 1059 A.store.Int64(ptr + 8, x["openerTabId"] === undefined ? 0 : (x["openerTabId"] as number)); 1060 A.store.Bool(ptr + 29, "pinned" in x ? true : false); 1061 A.store.Bool(ptr + 16, x["pinned"] ? true : false); 1062 A.store.Bool(ptr + 30, "selected" in x ? true : false); 1063 A.store.Bool(ptr + 17, x["selected"] ? true : false); 1064 A.store.Ref(ptr + 20, x["url"]); 1065 } 1066 }, 1067 "load_UpdateArgUpdateProperties": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 1068 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 1069 1070 if (A.load.Bool(ptr + 24)) { 1071 x["active"] = A.load.Bool(ptr + 0); 1072 } else { 1073 delete x["active"]; 1074 } 1075 if (A.load.Bool(ptr + 25)) { 1076 x["autoDiscardable"] = A.load.Bool(ptr + 1); 1077 } else { 1078 delete x["autoDiscardable"]; 1079 } 1080 if (A.load.Bool(ptr + 26)) { 1081 x["highlighted"] = A.load.Bool(ptr + 2); 1082 } else { 1083 delete x["highlighted"]; 1084 } 1085 if (A.load.Bool(ptr + 27)) { 1086 x["muted"] = A.load.Bool(ptr + 3); 1087 } else { 1088 delete x["muted"]; 1089 } 1090 if (A.load.Bool(ptr + 28)) { 1091 x["openerTabId"] = A.load.Int64(ptr + 8); 1092 } else { 1093 delete x["openerTabId"]; 1094 } 1095 if (A.load.Bool(ptr + 29)) { 1096 x["pinned"] = A.load.Bool(ptr + 16); 1097 } else { 1098 delete x["pinned"]; 1099 } 1100 if (A.load.Bool(ptr + 30)) { 1101 x["selected"] = A.load.Bool(ptr + 17); 1102 } else { 1103 delete x["selected"]; 1104 } 1105 x["url"] = A.load.Ref(ptr + 20, undefined); 1106 return create === A.H.TRUE ? A.H.push(x) : ref; 1107 }, 1108 "has_CaptureVisibleTab": (): heap.Ref<boolean> => { 1109 if (WEBEXT?.tabs && "captureVisibleTab" in WEBEXT?.tabs) { 1110 return A.H.TRUE; 1111 } 1112 return A.H.FALSE; 1113 }, 1114 "func_CaptureVisibleTab": (fn: Pointer): void => { 1115 A.store.Ref(fn, WEBEXT.tabs.captureVisibleTab); 1116 }, 1117 "call_CaptureVisibleTab": (retPtr: Pointer, windowId: number, options: Pointer): void => { 1118 const options_ffi = {}; 1119 1120 options_ffi["format"] = A.load.Enum(options + 0, ["jpeg", "png"]); 1121 if (A.load.Bool(options + 16)) { 1122 options_ffi["quality"] = A.load.Int64(options + 8); 1123 } 1124 1125 const _ret = WEBEXT.tabs.captureVisibleTab(windowId, options_ffi); 1126 A.store.Ref(retPtr, _ret); 1127 }, 1128 "try_CaptureVisibleTab": ( 1129 retPtr: Pointer, 1130 errPtr: Pointer, 1131 windowId: number, 1132 options: Pointer 1133 ): heap.Ref<boolean> => { 1134 try { 1135 const options_ffi = {}; 1136 1137 options_ffi["format"] = A.load.Enum(options + 0, ["jpeg", "png"]); 1138 if (A.load.Bool(options + 16)) { 1139 options_ffi["quality"] = A.load.Int64(options + 8); 1140 } 1141 1142 const _ret = WEBEXT.tabs.captureVisibleTab(windowId, options_ffi); 1143 A.store.Ref(retPtr, _ret); 1144 return A.H.TRUE; 1145 } catch (err: any) { 1146 A.store.Ref(errPtr, err); 1147 return A.H.FALSE; 1148 } 1149 }, 1150 "has_Create": (): heap.Ref<boolean> => { 1151 if (WEBEXT?.tabs && "create" in WEBEXT?.tabs) { 1152 return A.H.TRUE; 1153 } 1154 return A.H.FALSE; 1155 }, 1156 "func_Create": (fn: Pointer): void => { 1157 A.store.Ref(fn, WEBEXT.tabs.create); 1158 }, 1159 "call_Create": (retPtr: Pointer, createProperties: Pointer): void => { 1160 const createProperties_ffi = {}; 1161 1162 if (A.load.Bool(createProperties + 40)) { 1163 createProperties_ffi["active"] = A.load.Bool(createProperties + 0); 1164 } 1165 if (A.load.Bool(createProperties + 41)) { 1166 createProperties_ffi["index"] = A.load.Int64(createProperties + 8); 1167 } 1168 if (A.load.Bool(createProperties + 42)) { 1169 createProperties_ffi["openerTabId"] = A.load.Int64(createProperties + 16); 1170 } 1171 if (A.load.Bool(createProperties + 43)) { 1172 createProperties_ffi["pinned"] = A.load.Bool(createProperties + 24); 1173 } 1174 if (A.load.Bool(createProperties + 44)) { 1175 createProperties_ffi["selected"] = A.load.Bool(createProperties + 25); 1176 } 1177 createProperties_ffi["url"] = A.load.Ref(createProperties + 28, undefined); 1178 if (A.load.Bool(createProperties + 45)) { 1179 createProperties_ffi["windowId"] = A.load.Int64(createProperties + 32); 1180 } 1181 1182 const _ret = WEBEXT.tabs.create(createProperties_ffi); 1183 A.store.Ref(retPtr, _ret); 1184 }, 1185 "try_Create": (retPtr: Pointer, errPtr: Pointer, createProperties: Pointer): heap.Ref<boolean> => { 1186 try { 1187 const createProperties_ffi = {}; 1188 1189 if (A.load.Bool(createProperties + 40)) { 1190 createProperties_ffi["active"] = A.load.Bool(createProperties + 0); 1191 } 1192 if (A.load.Bool(createProperties + 41)) { 1193 createProperties_ffi["index"] = A.load.Int64(createProperties + 8); 1194 } 1195 if (A.load.Bool(createProperties + 42)) { 1196 createProperties_ffi["openerTabId"] = A.load.Int64(createProperties + 16); 1197 } 1198 if (A.load.Bool(createProperties + 43)) { 1199 createProperties_ffi["pinned"] = A.load.Bool(createProperties + 24); 1200 } 1201 if (A.load.Bool(createProperties + 44)) { 1202 createProperties_ffi["selected"] = A.load.Bool(createProperties + 25); 1203 } 1204 createProperties_ffi["url"] = A.load.Ref(createProperties + 28, undefined); 1205 if (A.load.Bool(createProperties + 45)) { 1206 createProperties_ffi["windowId"] = A.load.Int64(createProperties + 32); 1207 } 1208 1209 const _ret = WEBEXT.tabs.create(createProperties_ffi); 1210 A.store.Ref(retPtr, _ret); 1211 return A.H.TRUE; 1212 } catch (err: any) { 1213 A.store.Ref(errPtr, err); 1214 return A.H.FALSE; 1215 } 1216 }, 1217 "has_DetectLanguage": (): heap.Ref<boolean> => { 1218 if (WEBEXT?.tabs && "detectLanguage" in WEBEXT?.tabs) { 1219 return A.H.TRUE; 1220 } 1221 return A.H.FALSE; 1222 }, 1223 "func_DetectLanguage": (fn: Pointer): void => { 1224 A.store.Ref(fn, WEBEXT.tabs.detectLanguage); 1225 }, 1226 "call_DetectLanguage": (retPtr: Pointer, tabId: number): void => { 1227 const _ret = WEBEXT.tabs.detectLanguage(tabId); 1228 A.store.Ref(retPtr, _ret); 1229 }, 1230 "try_DetectLanguage": (retPtr: Pointer, errPtr: Pointer, tabId: number): heap.Ref<boolean> => { 1231 try { 1232 const _ret = WEBEXT.tabs.detectLanguage(tabId); 1233 A.store.Ref(retPtr, _ret); 1234 return A.H.TRUE; 1235 } catch (err: any) { 1236 A.store.Ref(errPtr, err); 1237 return A.H.FALSE; 1238 } 1239 }, 1240 "has_Discard": (): heap.Ref<boolean> => { 1241 if (WEBEXT?.tabs && "discard" in WEBEXT?.tabs) { 1242 return A.H.TRUE; 1243 } 1244 return A.H.FALSE; 1245 }, 1246 "func_Discard": (fn: Pointer): void => { 1247 A.store.Ref(fn, WEBEXT.tabs.discard); 1248 }, 1249 "call_Discard": (retPtr: Pointer, tabId: number): void => { 1250 const _ret = WEBEXT.tabs.discard(tabId); 1251 A.store.Ref(retPtr, _ret); 1252 }, 1253 "try_Discard": (retPtr: Pointer, errPtr: Pointer, tabId: number): heap.Ref<boolean> => { 1254 try { 1255 const _ret = WEBEXT.tabs.discard(tabId); 1256 A.store.Ref(retPtr, _ret); 1257 return A.H.TRUE; 1258 } catch (err: any) { 1259 A.store.Ref(errPtr, err); 1260 return A.H.FALSE; 1261 } 1262 }, 1263 "has_Duplicate": (): heap.Ref<boolean> => { 1264 if (WEBEXT?.tabs && "duplicate" in WEBEXT?.tabs) { 1265 return A.H.TRUE; 1266 } 1267 return A.H.FALSE; 1268 }, 1269 "func_Duplicate": (fn: Pointer): void => { 1270 A.store.Ref(fn, WEBEXT.tabs.duplicate); 1271 }, 1272 "call_Duplicate": (retPtr: Pointer, tabId: number): void => { 1273 const _ret = WEBEXT.tabs.duplicate(tabId); 1274 A.store.Ref(retPtr, _ret); 1275 }, 1276 "try_Duplicate": (retPtr: Pointer, errPtr: Pointer, tabId: number): heap.Ref<boolean> => { 1277 try { 1278 const _ret = WEBEXT.tabs.duplicate(tabId); 1279 A.store.Ref(retPtr, _ret); 1280 return A.H.TRUE; 1281 } catch (err: any) { 1282 A.store.Ref(errPtr, err); 1283 return A.H.FALSE; 1284 } 1285 }, 1286 "has_ExecuteScript": (): heap.Ref<boolean> => { 1287 if (WEBEXT?.tabs && "executeScript" in WEBEXT?.tabs) { 1288 return A.H.TRUE; 1289 } 1290 return A.H.FALSE; 1291 }, 1292 "func_ExecuteScript": (fn: Pointer): void => { 1293 A.store.Ref(fn, WEBEXT.tabs.executeScript); 1294 }, 1295 "call_ExecuteScript": (retPtr: Pointer, tabId: number, details: Pointer): void => { 1296 const details_ffi = {}; 1297 1298 if (A.load.Bool(details + 32)) { 1299 details_ffi["allFrames"] = A.load.Bool(details + 0); 1300 } 1301 details_ffi["code"] = A.load.Ref(details + 4, undefined); 1302 details_ffi["cssOrigin"] = A.load.Enum(details + 8, ["author", "user"]); 1303 details_ffi["file"] = A.load.Ref(details + 12, undefined); 1304 if (A.load.Bool(details + 33)) { 1305 details_ffi["frameId"] = A.load.Int64(details + 16); 1306 } 1307 if (A.load.Bool(details + 34)) { 1308 details_ffi["matchAboutBlank"] = A.load.Bool(details + 24); 1309 } 1310 details_ffi["runAt"] = A.load.Enum(details + 28, ["document_start", "document_end", "document_idle"]); 1311 1312 const _ret = WEBEXT.tabs.executeScript(tabId, details_ffi); 1313 A.store.Ref(retPtr, _ret); 1314 }, 1315 "try_ExecuteScript": (retPtr: Pointer, errPtr: Pointer, tabId: number, details: Pointer): heap.Ref<boolean> => { 1316 try { 1317 const details_ffi = {}; 1318 1319 if (A.load.Bool(details + 32)) { 1320 details_ffi["allFrames"] = A.load.Bool(details + 0); 1321 } 1322 details_ffi["code"] = A.load.Ref(details + 4, undefined); 1323 details_ffi["cssOrigin"] = A.load.Enum(details + 8, ["author", "user"]); 1324 details_ffi["file"] = A.load.Ref(details + 12, undefined); 1325 if (A.load.Bool(details + 33)) { 1326 details_ffi["frameId"] = A.load.Int64(details + 16); 1327 } 1328 if (A.load.Bool(details + 34)) { 1329 details_ffi["matchAboutBlank"] = A.load.Bool(details + 24); 1330 } 1331 details_ffi["runAt"] = A.load.Enum(details + 28, ["document_start", "document_end", "document_idle"]); 1332 1333 const _ret = WEBEXT.tabs.executeScript(tabId, details_ffi); 1334 A.store.Ref(retPtr, _ret); 1335 return A.H.TRUE; 1336 } catch (err: any) { 1337 A.store.Ref(errPtr, err); 1338 return A.H.FALSE; 1339 } 1340 }, 1341 "has_Get": (): heap.Ref<boolean> => { 1342 if (WEBEXT?.tabs && "get" in WEBEXT?.tabs) { 1343 return A.H.TRUE; 1344 } 1345 return A.H.FALSE; 1346 }, 1347 "func_Get": (fn: Pointer): void => { 1348 A.store.Ref(fn, WEBEXT.tabs.get); 1349 }, 1350 "call_Get": (retPtr: Pointer, tabId: number): void => { 1351 const _ret = WEBEXT.tabs.get(tabId); 1352 A.store.Ref(retPtr, _ret); 1353 }, 1354 "try_Get": (retPtr: Pointer, errPtr: Pointer, tabId: number): heap.Ref<boolean> => { 1355 try { 1356 const _ret = WEBEXT.tabs.get(tabId); 1357 A.store.Ref(retPtr, _ret); 1358 return A.H.TRUE; 1359 } catch (err: any) { 1360 A.store.Ref(errPtr, err); 1361 return A.H.FALSE; 1362 } 1363 }, 1364 "has_GetAllInWindow": (): heap.Ref<boolean> => { 1365 if (WEBEXT?.tabs && "getAllInWindow" in WEBEXT?.tabs) { 1366 return A.H.TRUE; 1367 } 1368 return A.H.FALSE; 1369 }, 1370 "func_GetAllInWindow": (fn: Pointer): void => { 1371 A.store.Ref(fn, WEBEXT.tabs.getAllInWindow); 1372 }, 1373 "call_GetAllInWindow": (retPtr: Pointer, windowId: number): void => { 1374 const _ret = WEBEXT.tabs.getAllInWindow(windowId); 1375 A.store.Ref(retPtr, _ret); 1376 }, 1377 "try_GetAllInWindow": (retPtr: Pointer, errPtr: Pointer, windowId: number): heap.Ref<boolean> => { 1378 try { 1379 const _ret = WEBEXT.tabs.getAllInWindow(windowId); 1380 A.store.Ref(retPtr, _ret); 1381 return A.H.TRUE; 1382 } catch (err: any) { 1383 A.store.Ref(errPtr, err); 1384 return A.H.FALSE; 1385 } 1386 }, 1387 "has_GetCurrent": (): heap.Ref<boolean> => { 1388 if (WEBEXT?.tabs && "getCurrent" in WEBEXT?.tabs) { 1389 return A.H.TRUE; 1390 } 1391 return A.H.FALSE; 1392 }, 1393 "func_GetCurrent": (fn: Pointer): void => { 1394 A.store.Ref(fn, WEBEXT.tabs.getCurrent); 1395 }, 1396 "call_GetCurrent": (retPtr: Pointer): void => { 1397 const _ret = WEBEXT.tabs.getCurrent(); 1398 A.store.Ref(retPtr, _ret); 1399 }, 1400 "try_GetCurrent": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 1401 try { 1402 const _ret = WEBEXT.tabs.getCurrent(); 1403 A.store.Ref(retPtr, _ret); 1404 return A.H.TRUE; 1405 } catch (err: any) { 1406 A.store.Ref(errPtr, err); 1407 return A.H.FALSE; 1408 } 1409 }, 1410 "has_GetSelected": (): heap.Ref<boolean> => { 1411 if (WEBEXT?.tabs && "getSelected" in WEBEXT?.tabs) { 1412 return A.H.TRUE; 1413 } 1414 return A.H.FALSE; 1415 }, 1416 "func_GetSelected": (fn: Pointer): void => { 1417 A.store.Ref(fn, WEBEXT.tabs.getSelected); 1418 }, 1419 "call_GetSelected": (retPtr: Pointer, windowId: number): void => { 1420 const _ret = WEBEXT.tabs.getSelected(windowId); 1421 A.store.Ref(retPtr, _ret); 1422 }, 1423 "try_GetSelected": (retPtr: Pointer, errPtr: Pointer, windowId: number): heap.Ref<boolean> => { 1424 try { 1425 const _ret = WEBEXT.tabs.getSelected(windowId); 1426 A.store.Ref(retPtr, _ret); 1427 return A.H.TRUE; 1428 } catch (err: any) { 1429 A.store.Ref(errPtr, err); 1430 return A.H.FALSE; 1431 } 1432 }, 1433 "has_GetZoom": (): heap.Ref<boolean> => { 1434 if (WEBEXT?.tabs && "getZoom" in WEBEXT?.tabs) { 1435 return A.H.TRUE; 1436 } 1437 return A.H.FALSE; 1438 }, 1439 "func_GetZoom": (fn: Pointer): void => { 1440 A.store.Ref(fn, WEBEXT.tabs.getZoom); 1441 }, 1442 "call_GetZoom": (retPtr: Pointer, tabId: number): void => { 1443 const _ret = WEBEXT.tabs.getZoom(tabId); 1444 A.store.Ref(retPtr, _ret); 1445 }, 1446 "try_GetZoom": (retPtr: Pointer, errPtr: Pointer, tabId: number): heap.Ref<boolean> => { 1447 try { 1448 const _ret = WEBEXT.tabs.getZoom(tabId); 1449 A.store.Ref(retPtr, _ret); 1450 return A.H.TRUE; 1451 } catch (err: any) { 1452 A.store.Ref(errPtr, err); 1453 return A.H.FALSE; 1454 } 1455 }, 1456 "has_GetZoomSettings": (): heap.Ref<boolean> => { 1457 if (WEBEXT?.tabs && "getZoomSettings" in WEBEXT?.tabs) { 1458 return A.H.TRUE; 1459 } 1460 return A.H.FALSE; 1461 }, 1462 "func_GetZoomSettings": (fn: Pointer): void => { 1463 A.store.Ref(fn, WEBEXT.tabs.getZoomSettings); 1464 }, 1465 "call_GetZoomSettings": (retPtr: Pointer, tabId: number): void => { 1466 const _ret = WEBEXT.tabs.getZoomSettings(tabId); 1467 A.store.Ref(retPtr, _ret); 1468 }, 1469 "try_GetZoomSettings": (retPtr: Pointer, errPtr: Pointer, tabId: number): heap.Ref<boolean> => { 1470 try { 1471 const _ret = WEBEXT.tabs.getZoomSettings(tabId); 1472 A.store.Ref(retPtr, _ret); 1473 return A.H.TRUE; 1474 } catch (err: any) { 1475 A.store.Ref(errPtr, err); 1476 return A.H.FALSE; 1477 } 1478 }, 1479 "has_GoBack": (): heap.Ref<boolean> => { 1480 if (WEBEXT?.tabs && "goBack" in WEBEXT?.tabs) { 1481 return A.H.TRUE; 1482 } 1483 return A.H.FALSE; 1484 }, 1485 "func_GoBack": (fn: Pointer): void => { 1486 A.store.Ref(fn, WEBEXT.tabs.goBack); 1487 }, 1488 "call_GoBack": (retPtr: Pointer, tabId: number): void => { 1489 const _ret = WEBEXT.tabs.goBack(tabId); 1490 A.store.Ref(retPtr, _ret); 1491 }, 1492 "try_GoBack": (retPtr: Pointer, errPtr: Pointer, tabId: number): heap.Ref<boolean> => { 1493 try { 1494 const _ret = WEBEXT.tabs.goBack(tabId); 1495 A.store.Ref(retPtr, _ret); 1496 return A.H.TRUE; 1497 } catch (err: any) { 1498 A.store.Ref(errPtr, err); 1499 return A.H.FALSE; 1500 } 1501 }, 1502 "has_GoForward": (): heap.Ref<boolean> => { 1503 if (WEBEXT?.tabs && "goForward" in WEBEXT?.tabs) { 1504 return A.H.TRUE; 1505 } 1506 return A.H.FALSE; 1507 }, 1508 "func_GoForward": (fn: Pointer): void => { 1509 A.store.Ref(fn, WEBEXT.tabs.goForward); 1510 }, 1511 "call_GoForward": (retPtr: Pointer, tabId: number): void => { 1512 const _ret = WEBEXT.tabs.goForward(tabId); 1513 A.store.Ref(retPtr, _ret); 1514 }, 1515 "try_GoForward": (retPtr: Pointer, errPtr: Pointer, tabId: number): heap.Ref<boolean> => { 1516 try { 1517 const _ret = WEBEXT.tabs.goForward(tabId); 1518 A.store.Ref(retPtr, _ret); 1519 return A.H.TRUE; 1520 } catch (err: any) { 1521 A.store.Ref(errPtr, err); 1522 return A.H.FALSE; 1523 } 1524 }, 1525 "has_Group": (): heap.Ref<boolean> => { 1526 if (WEBEXT?.tabs && "group" in WEBEXT?.tabs) { 1527 return A.H.TRUE; 1528 } 1529 return A.H.FALSE; 1530 }, 1531 "func_Group": (fn: Pointer): void => { 1532 A.store.Ref(fn, WEBEXT.tabs.group); 1533 }, 1534 "call_Group": (retPtr: Pointer, options: Pointer): void => { 1535 const options_ffi = {}; 1536 1537 if (A.load.Bool(options + 0 + 9)) { 1538 options_ffi["createProperties"] = {}; 1539 if (A.load.Bool(options + 0 + 8)) { 1540 options_ffi["createProperties"]["windowId"] = A.load.Int64(options + 0 + 0); 1541 } 1542 } 1543 if (A.load.Bool(options + 28)) { 1544 options_ffi["groupId"] = A.load.Int64(options + 16); 1545 } 1546 options_ffi["tabIds"] = A.load.Ref(options + 24, undefined); 1547 1548 const _ret = WEBEXT.tabs.group(options_ffi); 1549 A.store.Ref(retPtr, _ret); 1550 }, 1551 "try_Group": (retPtr: Pointer, errPtr: Pointer, options: Pointer): heap.Ref<boolean> => { 1552 try { 1553 const options_ffi = {}; 1554 1555 if (A.load.Bool(options + 0 + 9)) { 1556 options_ffi["createProperties"] = {}; 1557 if (A.load.Bool(options + 0 + 8)) { 1558 options_ffi["createProperties"]["windowId"] = A.load.Int64(options + 0 + 0); 1559 } 1560 } 1561 if (A.load.Bool(options + 28)) { 1562 options_ffi["groupId"] = A.load.Int64(options + 16); 1563 } 1564 options_ffi["tabIds"] = A.load.Ref(options + 24, undefined); 1565 1566 const _ret = WEBEXT.tabs.group(options_ffi); 1567 A.store.Ref(retPtr, _ret); 1568 return A.H.TRUE; 1569 } catch (err: any) { 1570 A.store.Ref(errPtr, err); 1571 return A.H.FALSE; 1572 } 1573 }, 1574 "has_InsertCSS": (): heap.Ref<boolean> => { 1575 if (WEBEXT?.tabs && "insertCSS" in WEBEXT?.tabs) { 1576 return A.H.TRUE; 1577 } 1578 return A.H.FALSE; 1579 }, 1580 "func_InsertCSS": (fn: Pointer): void => { 1581 A.store.Ref(fn, WEBEXT.tabs.insertCSS); 1582 }, 1583 "call_InsertCSS": (retPtr: Pointer, tabId: number, details: Pointer): void => { 1584 const details_ffi = {}; 1585 1586 if (A.load.Bool(details + 32)) { 1587 details_ffi["allFrames"] = A.load.Bool(details + 0); 1588 } 1589 details_ffi["code"] = A.load.Ref(details + 4, undefined); 1590 details_ffi["cssOrigin"] = A.load.Enum(details + 8, ["author", "user"]); 1591 details_ffi["file"] = A.load.Ref(details + 12, undefined); 1592 if (A.load.Bool(details + 33)) { 1593 details_ffi["frameId"] = A.load.Int64(details + 16); 1594 } 1595 if (A.load.Bool(details + 34)) { 1596 details_ffi["matchAboutBlank"] = A.load.Bool(details + 24); 1597 } 1598 details_ffi["runAt"] = A.load.Enum(details + 28, ["document_start", "document_end", "document_idle"]); 1599 1600 const _ret = WEBEXT.tabs.insertCSS(tabId, details_ffi); 1601 A.store.Ref(retPtr, _ret); 1602 }, 1603 "try_InsertCSS": (retPtr: Pointer, errPtr: Pointer, tabId: number, details: Pointer): heap.Ref<boolean> => { 1604 try { 1605 const details_ffi = {}; 1606 1607 if (A.load.Bool(details + 32)) { 1608 details_ffi["allFrames"] = A.load.Bool(details + 0); 1609 } 1610 details_ffi["code"] = A.load.Ref(details + 4, undefined); 1611 details_ffi["cssOrigin"] = A.load.Enum(details + 8, ["author", "user"]); 1612 details_ffi["file"] = A.load.Ref(details + 12, undefined); 1613 if (A.load.Bool(details + 33)) { 1614 details_ffi["frameId"] = A.load.Int64(details + 16); 1615 } 1616 if (A.load.Bool(details + 34)) { 1617 details_ffi["matchAboutBlank"] = A.load.Bool(details + 24); 1618 } 1619 details_ffi["runAt"] = A.load.Enum(details + 28, ["document_start", "document_end", "document_idle"]); 1620 1621 const _ret = WEBEXT.tabs.insertCSS(tabId, details_ffi); 1622 A.store.Ref(retPtr, _ret); 1623 return A.H.TRUE; 1624 } catch (err: any) { 1625 A.store.Ref(errPtr, err); 1626 return A.H.FALSE; 1627 } 1628 }, 1629 "has_Move": (): heap.Ref<boolean> => { 1630 if (WEBEXT?.tabs && "move" in WEBEXT?.tabs) { 1631 return A.H.TRUE; 1632 } 1633 return A.H.FALSE; 1634 }, 1635 "func_Move": (fn: Pointer): void => { 1636 A.store.Ref(fn, WEBEXT.tabs.move); 1637 }, 1638 "call_Move": (retPtr: Pointer, tabIds: heap.Ref<any>, moveProperties: Pointer): void => { 1639 const moveProperties_ffi = {}; 1640 1641 moveProperties_ffi["index"] = A.load.Int64(moveProperties + 0); 1642 if (A.load.Bool(moveProperties + 16)) { 1643 moveProperties_ffi["windowId"] = A.load.Int64(moveProperties + 8); 1644 } 1645 1646 const _ret = WEBEXT.tabs.move(A.H.get<any>(tabIds), moveProperties_ffi); 1647 A.store.Ref(retPtr, _ret); 1648 }, 1649 "try_Move": ( 1650 retPtr: Pointer, 1651 errPtr: Pointer, 1652 tabIds: heap.Ref<any>, 1653 moveProperties: Pointer 1654 ): heap.Ref<boolean> => { 1655 try { 1656 const moveProperties_ffi = {}; 1657 1658 moveProperties_ffi["index"] = A.load.Int64(moveProperties + 0); 1659 if (A.load.Bool(moveProperties + 16)) { 1660 moveProperties_ffi["windowId"] = A.load.Int64(moveProperties + 8); 1661 } 1662 1663 const _ret = WEBEXT.tabs.move(A.H.get<any>(tabIds), moveProperties_ffi); 1664 A.store.Ref(retPtr, _ret); 1665 return A.H.TRUE; 1666 } catch (err: any) { 1667 A.store.Ref(errPtr, err); 1668 return A.H.FALSE; 1669 } 1670 }, 1671 "has_OnActivated": (): heap.Ref<boolean> => { 1672 if (WEBEXT?.tabs?.onActivated && "addListener" in WEBEXT?.tabs?.onActivated) { 1673 return A.H.TRUE; 1674 } 1675 return A.H.FALSE; 1676 }, 1677 "func_OnActivated": (fn: Pointer): void => { 1678 A.store.Ref(fn, WEBEXT.tabs.onActivated.addListener); 1679 }, 1680 "call_OnActivated": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1681 const _ret = WEBEXT.tabs.onActivated.addListener(A.H.get<object>(callback)); 1682 }, 1683 "try_OnActivated": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1684 try { 1685 const _ret = WEBEXT.tabs.onActivated.addListener(A.H.get<object>(callback)); 1686 return A.H.TRUE; 1687 } catch (err: any) { 1688 A.store.Ref(errPtr, err); 1689 return A.H.FALSE; 1690 } 1691 }, 1692 "has_OffActivated": (): heap.Ref<boolean> => { 1693 if (WEBEXT?.tabs?.onActivated && "removeListener" in WEBEXT?.tabs?.onActivated) { 1694 return A.H.TRUE; 1695 } 1696 return A.H.FALSE; 1697 }, 1698 "func_OffActivated": (fn: Pointer): void => { 1699 A.store.Ref(fn, WEBEXT.tabs.onActivated.removeListener); 1700 }, 1701 "call_OffActivated": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1702 const _ret = WEBEXT.tabs.onActivated.removeListener(A.H.get<object>(callback)); 1703 }, 1704 "try_OffActivated": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1705 try { 1706 const _ret = WEBEXT.tabs.onActivated.removeListener(A.H.get<object>(callback)); 1707 return A.H.TRUE; 1708 } catch (err: any) { 1709 A.store.Ref(errPtr, err); 1710 return A.H.FALSE; 1711 } 1712 }, 1713 "has_HasOnActivated": (): heap.Ref<boolean> => { 1714 if (WEBEXT?.tabs?.onActivated && "hasListener" in WEBEXT?.tabs?.onActivated) { 1715 return A.H.TRUE; 1716 } 1717 return A.H.FALSE; 1718 }, 1719 "func_HasOnActivated": (fn: Pointer): void => { 1720 A.store.Ref(fn, WEBEXT.tabs.onActivated.hasListener); 1721 }, 1722 "call_HasOnActivated": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1723 const _ret = WEBEXT.tabs.onActivated.hasListener(A.H.get<object>(callback)); 1724 A.store.Bool(retPtr, _ret); 1725 }, 1726 "try_HasOnActivated": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1727 try { 1728 const _ret = WEBEXT.tabs.onActivated.hasListener(A.H.get<object>(callback)); 1729 A.store.Bool(retPtr, _ret); 1730 return A.H.TRUE; 1731 } catch (err: any) { 1732 A.store.Ref(errPtr, err); 1733 return A.H.FALSE; 1734 } 1735 }, 1736 "has_OnActiveChanged": (): heap.Ref<boolean> => { 1737 if (WEBEXT?.tabs?.onActiveChanged && "addListener" in WEBEXT?.tabs?.onActiveChanged) { 1738 return A.H.TRUE; 1739 } 1740 return A.H.FALSE; 1741 }, 1742 "func_OnActiveChanged": (fn: Pointer): void => { 1743 A.store.Ref(fn, WEBEXT.tabs.onActiveChanged.addListener); 1744 }, 1745 "call_OnActiveChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1746 const _ret = WEBEXT.tabs.onActiveChanged.addListener(A.H.get<object>(callback)); 1747 }, 1748 "try_OnActiveChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1749 try { 1750 const _ret = WEBEXT.tabs.onActiveChanged.addListener(A.H.get<object>(callback)); 1751 return A.H.TRUE; 1752 } catch (err: any) { 1753 A.store.Ref(errPtr, err); 1754 return A.H.FALSE; 1755 } 1756 }, 1757 "has_OffActiveChanged": (): heap.Ref<boolean> => { 1758 if (WEBEXT?.tabs?.onActiveChanged && "removeListener" in WEBEXT?.tabs?.onActiveChanged) { 1759 return A.H.TRUE; 1760 } 1761 return A.H.FALSE; 1762 }, 1763 "func_OffActiveChanged": (fn: Pointer): void => { 1764 A.store.Ref(fn, WEBEXT.tabs.onActiveChanged.removeListener); 1765 }, 1766 "call_OffActiveChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1767 const _ret = WEBEXT.tabs.onActiveChanged.removeListener(A.H.get<object>(callback)); 1768 }, 1769 "try_OffActiveChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1770 try { 1771 const _ret = WEBEXT.tabs.onActiveChanged.removeListener(A.H.get<object>(callback)); 1772 return A.H.TRUE; 1773 } catch (err: any) { 1774 A.store.Ref(errPtr, err); 1775 return A.H.FALSE; 1776 } 1777 }, 1778 "has_HasOnActiveChanged": (): heap.Ref<boolean> => { 1779 if (WEBEXT?.tabs?.onActiveChanged && "hasListener" in WEBEXT?.tabs?.onActiveChanged) { 1780 return A.H.TRUE; 1781 } 1782 return A.H.FALSE; 1783 }, 1784 "func_HasOnActiveChanged": (fn: Pointer): void => { 1785 A.store.Ref(fn, WEBEXT.tabs.onActiveChanged.hasListener); 1786 }, 1787 "call_HasOnActiveChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1788 const _ret = WEBEXT.tabs.onActiveChanged.hasListener(A.H.get<object>(callback)); 1789 A.store.Bool(retPtr, _ret); 1790 }, 1791 "try_HasOnActiveChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1792 try { 1793 const _ret = WEBEXT.tabs.onActiveChanged.hasListener(A.H.get<object>(callback)); 1794 A.store.Bool(retPtr, _ret); 1795 return A.H.TRUE; 1796 } catch (err: any) { 1797 A.store.Ref(errPtr, err); 1798 return A.H.FALSE; 1799 } 1800 }, 1801 "has_OnAttached": (): heap.Ref<boolean> => { 1802 if (WEBEXT?.tabs?.onAttached && "addListener" in WEBEXT?.tabs?.onAttached) { 1803 return A.H.TRUE; 1804 } 1805 return A.H.FALSE; 1806 }, 1807 "func_OnAttached": (fn: Pointer): void => { 1808 A.store.Ref(fn, WEBEXT.tabs.onAttached.addListener); 1809 }, 1810 "call_OnAttached": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1811 const _ret = WEBEXT.tabs.onAttached.addListener(A.H.get<object>(callback)); 1812 }, 1813 "try_OnAttached": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1814 try { 1815 const _ret = WEBEXT.tabs.onAttached.addListener(A.H.get<object>(callback)); 1816 return A.H.TRUE; 1817 } catch (err: any) { 1818 A.store.Ref(errPtr, err); 1819 return A.H.FALSE; 1820 } 1821 }, 1822 "has_OffAttached": (): heap.Ref<boolean> => { 1823 if (WEBEXT?.tabs?.onAttached && "removeListener" in WEBEXT?.tabs?.onAttached) { 1824 return A.H.TRUE; 1825 } 1826 return A.H.FALSE; 1827 }, 1828 "func_OffAttached": (fn: Pointer): void => { 1829 A.store.Ref(fn, WEBEXT.tabs.onAttached.removeListener); 1830 }, 1831 "call_OffAttached": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1832 const _ret = WEBEXT.tabs.onAttached.removeListener(A.H.get<object>(callback)); 1833 }, 1834 "try_OffAttached": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1835 try { 1836 const _ret = WEBEXT.tabs.onAttached.removeListener(A.H.get<object>(callback)); 1837 return A.H.TRUE; 1838 } catch (err: any) { 1839 A.store.Ref(errPtr, err); 1840 return A.H.FALSE; 1841 } 1842 }, 1843 "has_HasOnAttached": (): heap.Ref<boolean> => { 1844 if (WEBEXT?.tabs?.onAttached && "hasListener" in WEBEXT?.tabs?.onAttached) { 1845 return A.H.TRUE; 1846 } 1847 return A.H.FALSE; 1848 }, 1849 "func_HasOnAttached": (fn: Pointer): void => { 1850 A.store.Ref(fn, WEBEXT.tabs.onAttached.hasListener); 1851 }, 1852 "call_HasOnAttached": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1853 const _ret = WEBEXT.tabs.onAttached.hasListener(A.H.get<object>(callback)); 1854 A.store.Bool(retPtr, _ret); 1855 }, 1856 "try_HasOnAttached": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1857 try { 1858 const _ret = WEBEXT.tabs.onAttached.hasListener(A.H.get<object>(callback)); 1859 A.store.Bool(retPtr, _ret); 1860 return A.H.TRUE; 1861 } catch (err: any) { 1862 A.store.Ref(errPtr, err); 1863 return A.H.FALSE; 1864 } 1865 }, 1866 "has_OnCreated": (): heap.Ref<boolean> => { 1867 if (WEBEXT?.tabs?.onCreated && "addListener" in WEBEXT?.tabs?.onCreated) { 1868 return A.H.TRUE; 1869 } 1870 return A.H.FALSE; 1871 }, 1872 "func_OnCreated": (fn: Pointer): void => { 1873 A.store.Ref(fn, WEBEXT.tabs.onCreated.addListener); 1874 }, 1875 "call_OnCreated": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1876 const _ret = WEBEXT.tabs.onCreated.addListener(A.H.get<object>(callback)); 1877 }, 1878 "try_OnCreated": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1879 try { 1880 const _ret = WEBEXT.tabs.onCreated.addListener(A.H.get<object>(callback)); 1881 return A.H.TRUE; 1882 } catch (err: any) { 1883 A.store.Ref(errPtr, err); 1884 return A.H.FALSE; 1885 } 1886 }, 1887 "has_OffCreated": (): heap.Ref<boolean> => { 1888 if (WEBEXT?.tabs?.onCreated && "removeListener" in WEBEXT?.tabs?.onCreated) { 1889 return A.H.TRUE; 1890 } 1891 return A.H.FALSE; 1892 }, 1893 "func_OffCreated": (fn: Pointer): void => { 1894 A.store.Ref(fn, WEBEXT.tabs.onCreated.removeListener); 1895 }, 1896 "call_OffCreated": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1897 const _ret = WEBEXT.tabs.onCreated.removeListener(A.H.get<object>(callback)); 1898 }, 1899 "try_OffCreated": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1900 try { 1901 const _ret = WEBEXT.tabs.onCreated.removeListener(A.H.get<object>(callback)); 1902 return A.H.TRUE; 1903 } catch (err: any) { 1904 A.store.Ref(errPtr, err); 1905 return A.H.FALSE; 1906 } 1907 }, 1908 "has_HasOnCreated": (): heap.Ref<boolean> => { 1909 if (WEBEXT?.tabs?.onCreated && "hasListener" in WEBEXT?.tabs?.onCreated) { 1910 return A.H.TRUE; 1911 } 1912 return A.H.FALSE; 1913 }, 1914 "func_HasOnCreated": (fn: Pointer): void => { 1915 A.store.Ref(fn, WEBEXT.tabs.onCreated.hasListener); 1916 }, 1917 "call_HasOnCreated": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1918 const _ret = WEBEXT.tabs.onCreated.hasListener(A.H.get<object>(callback)); 1919 A.store.Bool(retPtr, _ret); 1920 }, 1921 "try_HasOnCreated": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1922 try { 1923 const _ret = WEBEXT.tabs.onCreated.hasListener(A.H.get<object>(callback)); 1924 A.store.Bool(retPtr, _ret); 1925 return A.H.TRUE; 1926 } catch (err: any) { 1927 A.store.Ref(errPtr, err); 1928 return A.H.FALSE; 1929 } 1930 }, 1931 "has_OnDetached": (): heap.Ref<boolean> => { 1932 if (WEBEXT?.tabs?.onDetached && "addListener" in WEBEXT?.tabs?.onDetached) { 1933 return A.H.TRUE; 1934 } 1935 return A.H.FALSE; 1936 }, 1937 "func_OnDetached": (fn: Pointer): void => { 1938 A.store.Ref(fn, WEBEXT.tabs.onDetached.addListener); 1939 }, 1940 "call_OnDetached": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1941 const _ret = WEBEXT.tabs.onDetached.addListener(A.H.get<object>(callback)); 1942 }, 1943 "try_OnDetached": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1944 try { 1945 const _ret = WEBEXT.tabs.onDetached.addListener(A.H.get<object>(callback)); 1946 return A.H.TRUE; 1947 } catch (err: any) { 1948 A.store.Ref(errPtr, err); 1949 return A.H.FALSE; 1950 } 1951 }, 1952 "has_OffDetached": (): heap.Ref<boolean> => { 1953 if (WEBEXT?.tabs?.onDetached && "removeListener" in WEBEXT?.tabs?.onDetached) { 1954 return A.H.TRUE; 1955 } 1956 return A.H.FALSE; 1957 }, 1958 "func_OffDetached": (fn: Pointer): void => { 1959 A.store.Ref(fn, WEBEXT.tabs.onDetached.removeListener); 1960 }, 1961 "call_OffDetached": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1962 const _ret = WEBEXT.tabs.onDetached.removeListener(A.H.get<object>(callback)); 1963 }, 1964 "try_OffDetached": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1965 try { 1966 const _ret = WEBEXT.tabs.onDetached.removeListener(A.H.get<object>(callback)); 1967 return A.H.TRUE; 1968 } catch (err: any) { 1969 A.store.Ref(errPtr, err); 1970 return A.H.FALSE; 1971 } 1972 }, 1973 "has_HasOnDetached": (): heap.Ref<boolean> => { 1974 if (WEBEXT?.tabs?.onDetached && "hasListener" in WEBEXT?.tabs?.onDetached) { 1975 return A.H.TRUE; 1976 } 1977 return A.H.FALSE; 1978 }, 1979 "func_HasOnDetached": (fn: Pointer): void => { 1980 A.store.Ref(fn, WEBEXT.tabs.onDetached.hasListener); 1981 }, 1982 "call_HasOnDetached": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1983 const _ret = WEBEXT.tabs.onDetached.hasListener(A.H.get<object>(callback)); 1984 A.store.Bool(retPtr, _ret); 1985 }, 1986 "try_HasOnDetached": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1987 try { 1988 const _ret = WEBEXT.tabs.onDetached.hasListener(A.H.get<object>(callback)); 1989 A.store.Bool(retPtr, _ret); 1990 return A.H.TRUE; 1991 } catch (err: any) { 1992 A.store.Ref(errPtr, err); 1993 return A.H.FALSE; 1994 } 1995 }, 1996 "has_OnHighlightChanged": (): heap.Ref<boolean> => { 1997 if (WEBEXT?.tabs?.onHighlightChanged && "addListener" in WEBEXT?.tabs?.onHighlightChanged) { 1998 return A.H.TRUE; 1999 } 2000 return A.H.FALSE; 2001 }, 2002 "func_OnHighlightChanged": (fn: Pointer): void => { 2003 A.store.Ref(fn, WEBEXT.tabs.onHighlightChanged.addListener); 2004 }, 2005 "call_OnHighlightChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2006 const _ret = WEBEXT.tabs.onHighlightChanged.addListener(A.H.get<object>(callback)); 2007 }, 2008 "try_OnHighlightChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2009 try { 2010 const _ret = WEBEXT.tabs.onHighlightChanged.addListener(A.H.get<object>(callback)); 2011 return A.H.TRUE; 2012 } catch (err: any) { 2013 A.store.Ref(errPtr, err); 2014 return A.H.FALSE; 2015 } 2016 }, 2017 "has_OffHighlightChanged": (): heap.Ref<boolean> => { 2018 if (WEBEXT?.tabs?.onHighlightChanged && "removeListener" in WEBEXT?.tabs?.onHighlightChanged) { 2019 return A.H.TRUE; 2020 } 2021 return A.H.FALSE; 2022 }, 2023 "func_OffHighlightChanged": (fn: Pointer): void => { 2024 A.store.Ref(fn, WEBEXT.tabs.onHighlightChanged.removeListener); 2025 }, 2026 "call_OffHighlightChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2027 const _ret = WEBEXT.tabs.onHighlightChanged.removeListener(A.H.get<object>(callback)); 2028 }, 2029 "try_OffHighlightChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2030 try { 2031 const _ret = WEBEXT.tabs.onHighlightChanged.removeListener(A.H.get<object>(callback)); 2032 return A.H.TRUE; 2033 } catch (err: any) { 2034 A.store.Ref(errPtr, err); 2035 return A.H.FALSE; 2036 } 2037 }, 2038 "has_HasOnHighlightChanged": (): heap.Ref<boolean> => { 2039 if (WEBEXT?.tabs?.onHighlightChanged && "hasListener" in WEBEXT?.tabs?.onHighlightChanged) { 2040 return A.H.TRUE; 2041 } 2042 return A.H.FALSE; 2043 }, 2044 "func_HasOnHighlightChanged": (fn: Pointer): void => { 2045 A.store.Ref(fn, WEBEXT.tabs.onHighlightChanged.hasListener); 2046 }, 2047 "call_HasOnHighlightChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2048 const _ret = WEBEXT.tabs.onHighlightChanged.hasListener(A.H.get<object>(callback)); 2049 A.store.Bool(retPtr, _ret); 2050 }, 2051 "try_HasOnHighlightChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2052 try { 2053 const _ret = WEBEXT.tabs.onHighlightChanged.hasListener(A.H.get<object>(callback)); 2054 A.store.Bool(retPtr, _ret); 2055 return A.H.TRUE; 2056 } catch (err: any) { 2057 A.store.Ref(errPtr, err); 2058 return A.H.FALSE; 2059 } 2060 }, 2061 "has_OnHighlighted": (): heap.Ref<boolean> => { 2062 if (WEBEXT?.tabs?.onHighlighted && "addListener" in WEBEXT?.tabs?.onHighlighted) { 2063 return A.H.TRUE; 2064 } 2065 return A.H.FALSE; 2066 }, 2067 "func_OnHighlighted": (fn: Pointer): void => { 2068 A.store.Ref(fn, WEBEXT.tabs.onHighlighted.addListener); 2069 }, 2070 "call_OnHighlighted": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2071 const _ret = WEBEXT.tabs.onHighlighted.addListener(A.H.get<object>(callback)); 2072 }, 2073 "try_OnHighlighted": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2074 try { 2075 const _ret = WEBEXT.tabs.onHighlighted.addListener(A.H.get<object>(callback)); 2076 return A.H.TRUE; 2077 } catch (err: any) { 2078 A.store.Ref(errPtr, err); 2079 return A.H.FALSE; 2080 } 2081 }, 2082 "has_OffHighlighted": (): heap.Ref<boolean> => { 2083 if (WEBEXT?.tabs?.onHighlighted && "removeListener" in WEBEXT?.tabs?.onHighlighted) { 2084 return A.H.TRUE; 2085 } 2086 return A.H.FALSE; 2087 }, 2088 "func_OffHighlighted": (fn: Pointer): void => { 2089 A.store.Ref(fn, WEBEXT.tabs.onHighlighted.removeListener); 2090 }, 2091 "call_OffHighlighted": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2092 const _ret = WEBEXT.tabs.onHighlighted.removeListener(A.H.get<object>(callback)); 2093 }, 2094 "try_OffHighlighted": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2095 try { 2096 const _ret = WEBEXT.tabs.onHighlighted.removeListener(A.H.get<object>(callback)); 2097 return A.H.TRUE; 2098 } catch (err: any) { 2099 A.store.Ref(errPtr, err); 2100 return A.H.FALSE; 2101 } 2102 }, 2103 "has_HasOnHighlighted": (): heap.Ref<boolean> => { 2104 if (WEBEXT?.tabs?.onHighlighted && "hasListener" in WEBEXT?.tabs?.onHighlighted) { 2105 return A.H.TRUE; 2106 } 2107 return A.H.FALSE; 2108 }, 2109 "func_HasOnHighlighted": (fn: Pointer): void => { 2110 A.store.Ref(fn, WEBEXT.tabs.onHighlighted.hasListener); 2111 }, 2112 "call_HasOnHighlighted": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2113 const _ret = WEBEXT.tabs.onHighlighted.hasListener(A.H.get<object>(callback)); 2114 A.store.Bool(retPtr, _ret); 2115 }, 2116 "try_HasOnHighlighted": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2117 try { 2118 const _ret = WEBEXT.tabs.onHighlighted.hasListener(A.H.get<object>(callback)); 2119 A.store.Bool(retPtr, _ret); 2120 return A.H.TRUE; 2121 } catch (err: any) { 2122 A.store.Ref(errPtr, err); 2123 return A.H.FALSE; 2124 } 2125 }, 2126 "has_OnMoved": (): heap.Ref<boolean> => { 2127 if (WEBEXT?.tabs?.onMoved && "addListener" in WEBEXT?.tabs?.onMoved) { 2128 return A.H.TRUE; 2129 } 2130 return A.H.FALSE; 2131 }, 2132 "func_OnMoved": (fn: Pointer): void => { 2133 A.store.Ref(fn, WEBEXT.tabs.onMoved.addListener); 2134 }, 2135 "call_OnMoved": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2136 const _ret = WEBEXT.tabs.onMoved.addListener(A.H.get<object>(callback)); 2137 }, 2138 "try_OnMoved": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2139 try { 2140 const _ret = WEBEXT.tabs.onMoved.addListener(A.H.get<object>(callback)); 2141 return A.H.TRUE; 2142 } catch (err: any) { 2143 A.store.Ref(errPtr, err); 2144 return A.H.FALSE; 2145 } 2146 }, 2147 "has_OffMoved": (): heap.Ref<boolean> => { 2148 if (WEBEXT?.tabs?.onMoved && "removeListener" in WEBEXT?.tabs?.onMoved) { 2149 return A.H.TRUE; 2150 } 2151 return A.H.FALSE; 2152 }, 2153 "func_OffMoved": (fn: Pointer): void => { 2154 A.store.Ref(fn, WEBEXT.tabs.onMoved.removeListener); 2155 }, 2156 "call_OffMoved": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2157 const _ret = WEBEXT.tabs.onMoved.removeListener(A.H.get<object>(callback)); 2158 }, 2159 "try_OffMoved": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2160 try { 2161 const _ret = WEBEXT.tabs.onMoved.removeListener(A.H.get<object>(callback)); 2162 return A.H.TRUE; 2163 } catch (err: any) { 2164 A.store.Ref(errPtr, err); 2165 return A.H.FALSE; 2166 } 2167 }, 2168 "has_HasOnMoved": (): heap.Ref<boolean> => { 2169 if (WEBEXT?.tabs?.onMoved && "hasListener" in WEBEXT?.tabs?.onMoved) { 2170 return A.H.TRUE; 2171 } 2172 return A.H.FALSE; 2173 }, 2174 "func_HasOnMoved": (fn: Pointer): void => { 2175 A.store.Ref(fn, WEBEXT.tabs.onMoved.hasListener); 2176 }, 2177 "call_HasOnMoved": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2178 const _ret = WEBEXT.tabs.onMoved.hasListener(A.H.get<object>(callback)); 2179 A.store.Bool(retPtr, _ret); 2180 }, 2181 "try_HasOnMoved": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2182 try { 2183 const _ret = WEBEXT.tabs.onMoved.hasListener(A.H.get<object>(callback)); 2184 A.store.Bool(retPtr, _ret); 2185 return A.H.TRUE; 2186 } catch (err: any) { 2187 A.store.Ref(errPtr, err); 2188 return A.H.FALSE; 2189 } 2190 }, 2191 "has_OnRemoved": (): heap.Ref<boolean> => { 2192 if (WEBEXT?.tabs?.onRemoved && "addListener" in WEBEXT?.tabs?.onRemoved) { 2193 return A.H.TRUE; 2194 } 2195 return A.H.FALSE; 2196 }, 2197 "func_OnRemoved": (fn: Pointer): void => { 2198 A.store.Ref(fn, WEBEXT.tabs.onRemoved.addListener); 2199 }, 2200 "call_OnRemoved": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2201 const _ret = WEBEXT.tabs.onRemoved.addListener(A.H.get<object>(callback)); 2202 }, 2203 "try_OnRemoved": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2204 try { 2205 const _ret = WEBEXT.tabs.onRemoved.addListener(A.H.get<object>(callback)); 2206 return A.H.TRUE; 2207 } catch (err: any) { 2208 A.store.Ref(errPtr, err); 2209 return A.H.FALSE; 2210 } 2211 }, 2212 "has_OffRemoved": (): heap.Ref<boolean> => { 2213 if (WEBEXT?.tabs?.onRemoved && "removeListener" in WEBEXT?.tabs?.onRemoved) { 2214 return A.H.TRUE; 2215 } 2216 return A.H.FALSE; 2217 }, 2218 "func_OffRemoved": (fn: Pointer): void => { 2219 A.store.Ref(fn, WEBEXT.tabs.onRemoved.removeListener); 2220 }, 2221 "call_OffRemoved": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2222 const _ret = WEBEXT.tabs.onRemoved.removeListener(A.H.get<object>(callback)); 2223 }, 2224 "try_OffRemoved": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2225 try { 2226 const _ret = WEBEXT.tabs.onRemoved.removeListener(A.H.get<object>(callback)); 2227 return A.H.TRUE; 2228 } catch (err: any) { 2229 A.store.Ref(errPtr, err); 2230 return A.H.FALSE; 2231 } 2232 }, 2233 "has_HasOnRemoved": (): heap.Ref<boolean> => { 2234 if (WEBEXT?.tabs?.onRemoved && "hasListener" in WEBEXT?.tabs?.onRemoved) { 2235 return A.H.TRUE; 2236 } 2237 return A.H.FALSE; 2238 }, 2239 "func_HasOnRemoved": (fn: Pointer): void => { 2240 A.store.Ref(fn, WEBEXT.tabs.onRemoved.hasListener); 2241 }, 2242 "call_HasOnRemoved": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2243 const _ret = WEBEXT.tabs.onRemoved.hasListener(A.H.get<object>(callback)); 2244 A.store.Bool(retPtr, _ret); 2245 }, 2246 "try_HasOnRemoved": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2247 try { 2248 const _ret = WEBEXT.tabs.onRemoved.hasListener(A.H.get<object>(callback)); 2249 A.store.Bool(retPtr, _ret); 2250 return A.H.TRUE; 2251 } catch (err: any) { 2252 A.store.Ref(errPtr, err); 2253 return A.H.FALSE; 2254 } 2255 }, 2256 "has_OnReplaced": (): heap.Ref<boolean> => { 2257 if (WEBEXT?.tabs?.onReplaced && "addListener" in WEBEXT?.tabs?.onReplaced) { 2258 return A.H.TRUE; 2259 } 2260 return A.H.FALSE; 2261 }, 2262 "func_OnReplaced": (fn: Pointer): void => { 2263 A.store.Ref(fn, WEBEXT.tabs.onReplaced.addListener); 2264 }, 2265 "call_OnReplaced": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2266 const _ret = WEBEXT.tabs.onReplaced.addListener(A.H.get<object>(callback)); 2267 }, 2268 "try_OnReplaced": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2269 try { 2270 const _ret = WEBEXT.tabs.onReplaced.addListener(A.H.get<object>(callback)); 2271 return A.H.TRUE; 2272 } catch (err: any) { 2273 A.store.Ref(errPtr, err); 2274 return A.H.FALSE; 2275 } 2276 }, 2277 "has_OffReplaced": (): heap.Ref<boolean> => { 2278 if (WEBEXT?.tabs?.onReplaced && "removeListener" in WEBEXT?.tabs?.onReplaced) { 2279 return A.H.TRUE; 2280 } 2281 return A.H.FALSE; 2282 }, 2283 "func_OffReplaced": (fn: Pointer): void => { 2284 A.store.Ref(fn, WEBEXT.tabs.onReplaced.removeListener); 2285 }, 2286 "call_OffReplaced": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2287 const _ret = WEBEXT.tabs.onReplaced.removeListener(A.H.get<object>(callback)); 2288 }, 2289 "try_OffReplaced": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2290 try { 2291 const _ret = WEBEXT.tabs.onReplaced.removeListener(A.H.get<object>(callback)); 2292 return A.H.TRUE; 2293 } catch (err: any) { 2294 A.store.Ref(errPtr, err); 2295 return A.H.FALSE; 2296 } 2297 }, 2298 "has_HasOnReplaced": (): heap.Ref<boolean> => { 2299 if (WEBEXT?.tabs?.onReplaced && "hasListener" in WEBEXT?.tabs?.onReplaced) { 2300 return A.H.TRUE; 2301 } 2302 return A.H.FALSE; 2303 }, 2304 "func_HasOnReplaced": (fn: Pointer): void => { 2305 A.store.Ref(fn, WEBEXT.tabs.onReplaced.hasListener); 2306 }, 2307 "call_HasOnReplaced": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2308 const _ret = WEBEXT.tabs.onReplaced.hasListener(A.H.get<object>(callback)); 2309 A.store.Bool(retPtr, _ret); 2310 }, 2311 "try_HasOnReplaced": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2312 try { 2313 const _ret = WEBEXT.tabs.onReplaced.hasListener(A.H.get<object>(callback)); 2314 A.store.Bool(retPtr, _ret); 2315 return A.H.TRUE; 2316 } catch (err: any) { 2317 A.store.Ref(errPtr, err); 2318 return A.H.FALSE; 2319 } 2320 }, 2321 "has_OnSelectionChanged": (): heap.Ref<boolean> => { 2322 if (WEBEXT?.tabs?.onSelectionChanged && "addListener" in WEBEXT?.tabs?.onSelectionChanged) { 2323 return A.H.TRUE; 2324 } 2325 return A.H.FALSE; 2326 }, 2327 "func_OnSelectionChanged": (fn: Pointer): void => { 2328 A.store.Ref(fn, WEBEXT.tabs.onSelectionChanged.addListener); 2329 }, 2330 "call_OnSelectionChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2331 const _ret = WEBEXT.tabs.onSelectionChanged.addListener(A.H.get<object>(callback)); 2332 }, 2333 "try_OnSelectionChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2334 try { 2335 const _ret = WEBEXT.tabs.onSelectionChanged.addListener(A.H.get<object>(callback)); 2336 return A.H.TRUE; 2337 } catch (err: any) { 2338 A.store.Ref(errPtr, err); 2339 return A.H.FALSE; 2340 } 2341 }, 2342 "has_OffSelectionChanged": (): heap.Ref<boolean> => { 2343 if (WEBEXT?.tabs?.onSelectionChanged && "removeListener" in WEBEXT?.tabs?.onSelectionChanged) { 2344 return A.H.TRUE; 2345 } 2346 return A.H.FALSE; 2347 }, 2348 "func_OffSelectionChanged": (fn: Pointer): void => { 2349 A.store.Ref(fn, WEBEXT.tabs.onSelectionChanged.removeListener); 2350 }, 2351 "call_OffSelectionChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2352 const _ret = WEBEXT.tabs.onSelectionChanged.removeListener(A.H.get<object>(callback)); 2353 }, 2354 "try_OffSelectionChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2355 try { 2356 const _ret = WEBEXT.tabs.onSelectionChanged.removeListener(A.H.get<object>(callback)); 2357 return A.H.TRUE; 2358 } catch (err: any) { 2359 A.store.Ref(errPtr, err); 2360 return A.H.FALSE; 2361 } 2362 }, 2363 "has_HasOnSelectionChanged": (): heap.Ref<boolean> => { 2364 if (WEBEXT?.tabs?.onSelectionChanged && "hasListener" in WEBEXT?.tabs?.onSelectionChanged) { 2365 return A.H.TRUE; 2366 } 2367 return A.H.FALSE; 2368 }, 2369 "func_HasOnSelectionChanged": (fn: Pointer): void => { 2370 A.store.Ref(fn, WEBEXT.tabs.onSelectionChanged.hasListener); 2371 }, 2372 "call_HasOnSelectionChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2373 const _ret = WEBEXT.tabs.onSelectionChanged.hasListener(A.H.get<object>(callback)); 2374 A.store.Bool(retPtr, _ret); 2375 }, 2376 "try_HasOnSelectionChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2377 try { 2378 const _ret = WEBEXT.tabs.onSelectionChanged.hasListener(A.H.get<object>(callback)); 2379 A.store.Bool(retPtr, _ret); 2380 return A.H.TRUE; 2381 } catch (err: any) { 2382 A.store.Ref(errPtr, err); 2383 return A.H.FALSE; 2384 } 2385 }, 2386 "has_OnUpdated": (): heap.Ref<boolean> => { 2387 if (WEBEXT?.tabs?.onUpdated && "addListener" in WEBEXT?.tabs?.onUpdated) { 2388 return A.H.TRUE; 2389 } 2390 return A.H.FALSE; 2391 }, 2392 "func_OnUpdated": (fn: Pointer): void => { 2393 A.store.Ref(fn, WEBEXT.tabs.onUpdated.addListener); 2394 }, 2395 "call_OnUpdated": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2396 const _ret = WEBEXT.tabs.onUpdated.addListener(A.H.get<object>(callback)); 2397 }, 2398 "try_OnUpdated": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2399 try { 2400 const _ret = WEBEXT.tabs.onUpdated.addListener(A.H.get<object>(callback)); 2401 return A.H.TRUE; 2402 } catch (err: any) { 2403 A.store.Ref(errPtr, err); 2404 return A.H.FALSE; 2405 } 2406 }, 2407 "has_OffUpdated": (): heap.Ref<boolean> => { 2408 if (WEBEXT?.tabs?.onUpdated && "removeListener" in WEBEXT?.tabs?.onUpdated) { 2409 return A.H.TRUE; 2410 } 2411 return A.H.FALSE; 2412 }, 2413 "func_OffUpdated": (fn: Pointer): void => { 2414 A.store.Ref(fn, WEBEXT.tabs.onUpdated.removeListener); 2415 }, 2416 "call_OffUpdated": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2417 const _ret = WEBEXT.tabs.onUpdated.removeListener(A.H.get<object>(callback)); 2418 }, 2419 "try_OffUpdated": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2420 try { 2421 const _ret = WEBEXT.tabs.onUpdated.removeListener(A.H.get<object>(callback)); 2422 return A.H.TRUE; 2423 } catch (err: any) { 2424 A.store.Ref(errPtr, err); 2425 return A.H.FALSE; 2426 } 2427 }, 2428 "has_HasOnUpdated": (): heap.Ref<boolean> => { 2429 if (WEBEXT?.tabs?.onUpdated && "hasListener" in WEBEXT?.tabs?.onUpdated) { 2430 return A.H.TRUE; 2431 } 2432 return A.H.FALSE; 2433 }, 2434 "func_HasOnUpdated": (fn: Pointer): void => { 2435 A.store.Ref(fn, WEBEXT.tabs.onUpdated.hasListener); 2436 }, 2437 "call_HasOnUpdated": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2438 const _ret = WEBEXT.tabs.onUpdated.hasListener(A.H.get<object>(callback)); 2439 A.store.Bool(retPtr, _ret); 2440 }, 2441 "try_HasOnUpdated": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2442 try { 2443 const _ret = WEBEXT.tabs.onUpdated.hasListener(A.H.get<object>(callback)); 2444 A.store.Bool(retPtr, _ret); 2445 return A.H.TRUE; 2446 } catch (err: any) { 2447 A.store.Ref(errPtr, err); 2448 return A.H.FALSE; 2449 } 2450 }, 2451 "has_OnZoomChange": (): heap.Ref<boolean> => { 2452 if (WEBEXT?.tabs?.onZoomChange && "addListener" in WEBEXT?.tabs?.onZoomChange) { 2453 return A.H.TRUE; 2454 } 2455 return A.H.FALSE; 2456 }, 2457 "func_OnZoomChange": (fn: Pointer): void => { 2458 A.store.Ref(fn, WEBEXT.tabs.onZoomChange.addListener); 2459 }, 2460 "call_OnZoomChange": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2461 const _ret = WEBEXT.tabs.onZoomChange.addListener(A.H.get<object>(callback)); 2462 }, 2463 "try_OnZoomChange": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2464 try { 2465 const _ret = WEBEXT.tabs.onZoomChange.addListener(A.H.get<object>(callback)); 2466 return A.H.TRUE; 2467 } catch (err: any) { 2468 A.store.Ref(errPtr, err); 2469 return A.H.FALSE; 2470 } 2471 }, 2472 "has_OffZoomChange": (): heap.Ref<boolean> => { 2473 if (WEBEXT?.tabs?.onZoomChange && "removeListener" in WEBEXT?.tabs?.onZoomChange) { 2474 return A.H.TRUE; 2475 } 2476 return A.H.FALSE; 2477 }, 2478 "func_OffZoomChange": (fn: Pointer): void => { 2479 A.store.Ref(fn, WEBEXT.tabs.onZoomChange.removeListener); 2480 }, 2481 "call_OffZoomChange": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2482 const _ret = WEBEXT.tabs.onZoomChange.removeListener(A.H.get<object>(callback)); 2483 }, 2484 "try_OffZoomChange": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2485 try { 2486 const _ret = WEBEXT.tabs.onZoomChange.removeListener(A.H.get<object>(callback)); 2487 return A.H.TRUE; 2488 } catch (err: any) { 2489 A.store.Ref(errPtr, err); 2490 return A.H.FALSE; 2491 } 2492 }, 2493 "has_HasOnZoomChange": (): heap.Ref<boolean> => { 2494 if (WEBEXT?.tabs?.onZoomChange && "hasListener" in WEBEXT?.tabs?.onZoomChange) { 2495 return A.H.TRUE; 2496 } 2497 return A.H.FALSE; 2498 }, 2499 "func_HasOnZoomChange": (fn: Pointer): void => { 2500 A.store.Ref(fn, WEBEXT.tabs.onZoomChange.hasListener); 2501 }, 2502 "call_HasOnZoomChange": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2503 const _ret = WEBEXT.tabs.onZoomChange.hasListener(A.H.get<object>(callback)); 2504 A.store.Bool(retPtr, _ret); 2505 }, 2506 "try_HasOnZoomChange": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2507 try { 2508 const _ret = WEBEXT.tabs.onZoomChange.hasListener(A.H.get<object>(callback)); 2509 A.store.Bool(retPtr, _ret); 2510 return A.H.TRUE; 2511 } catch (err: any) { 2512 A.store.Ref(errPtr, err); 2513 return A.H.FALSE; 2514 } 2515 }, 2516 "has_Query": (): heap.Ref<boolean> => { 2517 if (WEBEXT?.tabs && "query" in WEBEXT?.tabs) { 2518 return A.H.TRUE; 2519 } 2520 return A.H.FALSE; 2521 }, 2522 "func_Query": (fn: Pointer): void => { 2523 A.store.Ref(fn, WEBEXT.tabs.query); 2524 }, 2525 "call_Query": (retPtr: Pointer, queryInfo: Pointer): void => { 2526 const queryInfo_ffi = {}; 2527 2528 if (A.load.Bool(queryInfo + 60)) { 2529 queryInfo_ffi["active"] = A.load.Bool(queryInfo + 0); 2530 } 2531 if (A.load.Bool(queryInfo + 61)) { 2532 queryInfo_ffi["audible"] = A.load.Bool(queryInfo + 1); 2533 } 2534 if (A.load.Bool(queryInfo + 62)) { 2535 queryInfo_ffi["autoDiscardable"] = A.load.Bool(queryInfo + 2); 2536 } 2537 if (A.load.Bool(queryInfo + 63)) { 2538 queryInfo_ffi["currentWindow"] = A.load.Bool(queryInfo + 3); 2539 } 2540 if (A.load.Bool(queryInfo + 64)) { 2541 queryInfo_ffi["discarded"] = A.load.Bool(queryInfo + 4); 2542 } 2543 if (A.load.Bool(queryInfo + 65)) { 2544 queryInfo_ffi["groupId"] = A.load.Int64(queryInfo + 8); 2545 } 2546 if (A.load.Bool(queryInfo + 66)) { 2547 queryInfo_ffi["highlighted"] = A.load.Bool(queryInfo + 16); 2548 } 2549 if (A.load.Bool(queryInfo + 67)) { 2550 queryInfo_ffi["index"] = A.load.Int64(queryInfo + 24); 2551 } 2552 if (A.load.Bool(queryInfo + 68)) { 2553 queryInfo_ffi["lastFocusedWindow"] = A.load.Bool(queryInfo + 32); 2554 } 2555 if (A.load.Bool(queryInfo + 69)) { 2556 queryInfo_ffi["muted"] = A.load.Bool(queryInfo + 33); 2557 } 2558 if (A.load.Bool(queryInfo + 70)) { 2559 queryInfo_ffi["pinned"] = A.load.Bool(queryInfo + 34); 2560 } 2561 queryInfo_ffi["status"] = A.load.Enum(queryInfo + 36, ["unloaded", "loading", "complete"]); 2562 queryInfo_ffi["title"] = A.load.Ref(queryInfo + 40, undefined); 2563 queryInfo_ffi["url"] = A.load.Ref(queryInfo + 44, undefined); 2564 if (A.load.Bool(queryInfo + 71)) { 2565 queryInfo_ffi["windowId"] = A.load.Int64(queryInfo + 48); 2566 } 2567 queryInfo_ffi["windowType"] = A.load.Enum(queryInfo + 56, ["normal", "popup", "panel", "app", "devtools"]); 2568 2569 const _ret = WEBEXT.tabs.query(queryInfo_ffi); 2570 A.store.Ref(retPtr, _ret); 2571 }, 2572 "try_Query": (retPtr: Pointer, errPtr: Pointer, queryInfo: Pointer): heap.Ref<boolean> => { 2573 try { 2574 const queryInfo_ffi = {}; 2575 2576 if (A.load.Bool(queryInfo + 60)) { 2577 queryInfo_ffi["active"] = A.load.Bool(queryInfo + 0); 2578 } 2579 if (A.load.Bool(queryInfo + 61)) { 2580 queryInfo_ffi["audible"] = A.load.Bool(queryInfo + 1); 2581 } 2582 if (A.load.Bool(queryInfo + 62)) { 2583 queryInfo_ffi["autoDiscardable"] = A.load.Bool(queryInfo + 2); 2584 } 2585 if (A.load.Bool(queryInfo + 63)) { 2586 queryInfo_ffi["currentWindow"] = A.load.Bool(queryInfo + 3); 2587 } 2588 if (A.load.Bool(queryInfo + 64)) { 2589 queryInfo_ffi["discarded"] = A.load.Bool(queryInfo + 4); 2590 } 2591 if (A.load.Bool(queryInfo + 65)) { 2592 queryInfo_ffi["groupId"] = A.load.Int64(queryInfo + 8); 2593 } 2594 if (A.load.Bool(queryInfo + 66)) { 2595 queryInfo_ffi["highlighted"] = A.load.Bool(queryInfo + 16); 2596 } 2597 if (A.load.Bool(queryInfo + 67)) { 2598 queryInfo_ffi["index"] = A.load.Int64(queryInfo + 24); 2599 } 2600 if (A.load.Bool(queryInfo + 68)) { 2601 queryInfo_ffi["lastFocusedWindow"] = A.load.Bool(queryInfo + 32); 2602 } 2603 if (A.load.Bool(queryInfo + 69)) { 2604 queryInfo_ffi["muted"] = A.load.Bool(queryInfo + 33); 2605 } 2606 if (A.load.Bool(queryInfo + 70)) { 2607 queryInfo_ffi["pinned"] = A.load.Bool(queryInfo + 34); 2608 } 2609 queryInfo_ffi["status"] = A.load.Enum(queryInfo + 36, ["unloaded", "loading", "complete"]); 2610 queryInfo_ffi["title"] = A.load.Ref(queryInfo + 40, undefined); 2611 queryInfo_ffi["url"] = A.load.Ref(queryInfo + 44, undefined); 2612 if (A.load.Bool(queryInfo + 71)) { 2613 queryInfo_ffi["windowId"] = A.load.Int64(queryInfo + 48); 2614 } 2615 queryInfo_ffi["windowType"] = A.load.Enum(queryInfo + 56, ["normal", "popup", "panel", "app", "devtools"]); 2616 2617 const _ret = WEBEXT.tabs.query(queryInfo_ffi); 2618 A.store.Ref(retPtr, _ret); 2619 return A.H.TRUE; 2620 } catch (err: any) { 2621 A.store.Ref(errPtr, err); 2622 return A.H.FALSE; 2623 } 2624 }, 2625 "has_Reload": (): heap.Ref<boolean> => { 2626 if (WEBEXT?.tabs && "reload" in WEBEXT?.tabs) { 2627 return A.H.TRUE; 2628 } 2629 return A.H.FALSE; 2630 }, 2631 "func_Reload": (fn: Pointer): void => { 2632 A.store.Ref(fn, WEBEXT.tabs.reload); 2633 }, 2634 "call_Reload": (retPtr: Pointer, tabId: number, reloadProperties: Pointer): void => { 2635 const reloadProperties_ffi = {}; 2636 2637 if (A.load.Bool(reloadProperties + 1)) { 2638 reloadProperties_ffi["bypassCache"] = A.load.Bool(reloadProperties + 0); 2639 } 2640 2641 const _ret = WEBEXT.tabs.reload(tabId, reloadProperties_ffi); 2642 A.store.Ref(retPtr, _ret); 2643 }, 2644 "try_Reload": (retPtr: Pointer, errPtr: Pointer, tabId: number, reloadProperties: Pointer): heap.Ref<boolean> => { 2645 try { 2646 const reloadProperties_ffi = {}; 2647 2648 if (A.load.Bool(reloadProperties + 1)) { 2649 reloadProperties_ffi["bypassCache"] = A.load.Bool(reloadProperties + 0); 2650 } 2651 2652 const _ret = WEBEXT.tabs.reload(tabId, reloadProperties_ffi); 2653 A.store.Ref(retPtr, _ret); 2654 return A.H.TRUE; 2655 } catch (err: any) { 2656 A.store.Ref(errPtr, err); 2657 return A.H.FALSE; 2658 } 2659 }, 2660 "has_Remove": (): heap.Ref<boolean> => { 2661 if (WEBEXT?.tabs && "remove" in WEBEXT?.tabs) { 2662 return A.H.TRUE; 2663 } 2664 return A.H.FALSE; 2665 }, 2666 "func_Remove": (fn: Pointer): void => { 2667 A.store.Ref(fn, WEBEXT.tabs.remove); 2668 }, 2669 "call_Remove": (retPtr: Pointer, tabIds: heap.Ref<any>): void => { 2670 const _ret = WEBEXT.tabs.remove(A.H.get<any>(tabIds)); 2671 A.store.Ref(retPtr, _ret); 2672 }, 2673 "try_Remove": (retPtr: Pointer, errPtr: Pointer, tabIds: heap.Ref<any>): heap.Ref<boolean> => { 2674 try { 2675 const _ret = WEBEXT.tabs.remove(A.H.get<any>(tabIds)); 2676 A.store.Ref(retPtr, _ret); 2677 return A.H.TRUE; 2678 } catch (err: any) { 2679 A.store.Ref(errPtr, err); 2680 return A.H.FALSE; 2681 } 2682 }, 2683 "has_RemoveCSS": (): heap.Ref<boolean> => { 2684 if (WEBEXT?.tabs && "removeCSS" in WEBEXT?.tabs) { 2685 return A.H.TRUE; 2686 } 2687 return A.H.FALSE; 2688 }, 2689 "func_RemoveCSS": (fn: Pointer): void => { 2690 A.store.Ref(fn, WEBEXT.tabs.removeCSS); 2691 }, 2692 "call_RemoveCSS": (retPtr: Pointer, tabId: number, details: Pointer): void => { 2693 const details_ffi = {}; 2694 2695 if (A.load.Bool(details + 25)) { 2696 details_ffi["allFrames"] = A.load.Bool(details + 0); 2697 } 2698 details_ffi["code"] = A.load.Ref(details + 4, undefined); 2699 details_ffi["cssOrigin"] = A.load.Enum(details + 8, ["author", "user"]); 2700 details_ffi["file"] = A.load.Ref(details + 12, undefined); 2701 if (A.load.Bool(details + 26)) { 2702 details_ffi["frameId"] = A.load.Int64(details + 16); 2703 } 2704 if (A.load.Bool(details + 27)) { 2705 details_ffi["matchAboutBlank"] = A.load.Bool(details + 24); 2706 } 2707 2708 const _ret = WEBEXT.tabs.removeCSS(tabId, details_ffi); 2709 A.store.Ref(retPtr, _ret); 2710 }, 2711 "try_RemoveCSS": (retPtr: Pointer, errPtr: Pointer, tabId: number, details: Pointer): heap.Ref<boolean> => { 2712 try { 2713 const details_ffi = {}; 2714 2715 if (A.load.Bool(details + 25)) { 2716 details_ffi["allFrames"] = A.load.Bool(details + 0); 2717 } 2718 details_ffi["code"] = A.load.Ref(details + 4, undefined); 2719 details_ffi["cssOrigin"] = A.load.Enum(details + 8, ["author", "user"]); 2720 details_ffi["file"] = A.load.Ref(details + 12, undefined); 2721 if (A.load.Bool(details + 26)) { 2722 details_ffi["frameId"] = A.load.Int64(details + 16); 2723 } 2724 if (A.load.Bool(details + 27)) { 2725 details_ffi["matchAboutBlank"] = A.load.Bool(details + 24); 2726 } 2727 2728 const _ret = WEBEXT.tabs.removeCSS(tabId, details_ffi); 2729 A.store.Ref(retPtr, _ret); 2730 return A.H.TRUE; 2731 } catch (err: any) { 2732 A.store.Ref(errPtr, err); 2733 return A.H.FALSE; 2734 } 2735 }, 2736 "has_SendMessage": (): heap.Ref<boolean> => { 2737 if (WEBEXT?.tabs && "sendMessage" in WEBEXT?.tabs) { 2738 return A.H.TRUE; 2739 } 2740 return A.H.FALSE; 2741 }, 2742 "func_SendMessage": (fn: Pointer): void => { 2743 A.store.Ref(fn, WEBEXT.tabs.sendMessage); 2744 }, 2745 "call_SendMessage": (retPtr: Pointer, tabId: number, message: heap.Ref<object>, options: Pointer): void => { 2746 const options_ffi = {}; 2747 2748 options_ffi["documentId"] = A.load.Ref(options + 0, undefined); 2749 if (A.load.Bool(options + 16)) { 2750 options_ffi["frameId"] = A.load.Int64(options + 8); 2751 } 2752 2753 const _ret = WEBEXT.tabs.sendMessage(tabId, A.H.get<object>(message), options_ffi); 2754 A.store.Ref(retPtr, _ret); 2755 }, 2756 "try_SendMessage": ( 2757 retPtr: Pointer, 2758 errPtr: Pointer, 2759 tabId: number, 2760 message: heap.Ref<object>, 2761 options: Pointer 2762 ): heap.Ref<boolean> => { 2763 try { 2764 const options_ffi = {}; 2765 2766 options_ffi["documentId"] = A.load.Ref(options + 0, undefined); 2767 if (A.load.Bool(options + 16)) { 2768 options_ffi["frameId"] = A.load.Int64(options + 8); 2769 } 2770 2771 const _ret = WEBEXT.tabs.sendMessage(tabId, A.H.get<object>(message), options_ffi); 2772 A.store.Ref(retPtr, _ret); 2773 return A.H.TRUE; 2774 } catch (err: any) { 2775 A.store.Ref(errPtr, err); 2776 return A.H.FALSE; 2777 } 2778 }, 2779 "has_SendRequest": (): heap.Ref<boolean> => { 2780 if (WEBEXT?.tabs && "sendRequest" in WEBEXT?.tabs) { 2781 return A.H.TRUE; 2782 } 2783 return A.H.FALSE; 2784 }, 2785 "func_SendRequest": (fn: Pointer): void => { 2786 A.store.Ref(fn, WEBEXT.tabs.sendRequest); 2787 }, 2788 "call_SendRequest": (retPtr: Pointer, tabId: number, request: heap.Ref<object>): void => { 2789 const _ret = WEBEXT.tabs.sendRequest(tabId, A.H.get<object>(request)); 2790 A.store.Ref(retPtr, _ret); 2791 }, 2792 "try_SendRequest": ( 2793 retPtr: Pointer, 2794 errPtr: Pointer, 2795 tabId: number, 2796 request: heap.Ref<object> 2797 ): heap.Ref<boolean> => { 2798 try { 2799 const _ret = WEBEXT.tabs.sendRequest(tabId, A.H.get<object>(request)); 2800 A.store.Ref(retPtr, _ret); 2801 return A.H.TRUE; 2802 } catch (err: any) { 2803 A.store.Ref(errPtr, err); 2804 return A.H.FALSE; 2805 } 2806 }, 2807 "has_SetZoom": (): heap.Ref<boolean> => { 2808 if (WEBEXT?.tabs && "setZoom" in WEBEXT?.tabs) { 2809 return A.H.TRUE; 2810 } 2811 return A.H.FALSE; 2812 }, 2813 "func_SetZoom": (fn: Pointer): void => { 2814 A.store.Ref(fn, WEBEXT.tabs.setZoom); 2815 }, 2816 "call_SetZoom": (retPtr: Pointer, tabId: number, zoomFactor: number): void => { 2817 const _ret = WEBEXT.tabs.setZoom(tabId, zoomFactor); 2818 A.store.Ref(retPtr, _ret); 2819 }, 2820 "try_SetZoom": (retPtr: Pointer, errPtr: Pointer, tabId: number, zoomFactor: number): heap.Ref<boolean> => { 2821 try { 2822 const _ret = WEBEXT.tabs.setZoom(tabId, zoomFactor); 2823 A.store.Ref(retPtr, _ret); 2824 return A.H.TRUE; 2825 } catch (err: any) { 2826 A.store.Ref(errPtr, err); 2827 return A.H.FALSE; 2828 } 2829 }, 2830 "has_SetZoomSettings": (): heap.Ref<boolean> => { 2831 if (WEBEXT?.tabs && "setZoomSettings" in WEBEXT?.tabs) { 2832 return A.H.TRUE; 2833 } 2834 return A.H.FALSE; 2835 }, 2836 "func_SetZoomSettings": (fn: Pointer): void => { 2837 A.store.Ref(fn, WEBEXT.tabs.setZoomSettings); 2838 }, 2839 "call_SetZoomSettings": (retPtr: Pointer, tabId: number, zoomSettings: Pointer): void => { 2840 const zoomSettings_ffi = {}; 2841 2842 if (A.load.Bool(zoomSettings + 16)) { 2843 zoomSettings_ffi["defaultZoomFactor"] = A.load.Float64(zoomSettings + 0); 2844 } 2845 zoomSettings_ffi["mode"] = A.load.Enum(zoomSettings + 8, ["automatic", "manual", "disabled"]); 2846 zoomSettings_ffi["scope"] = A.load.Enum(zoomSettings + 12, ["per-origin", "per-tab"]); 2847 2848 const _ret = WEBEXT.tabs.setZoomSettings(tabId, zoomSettings_ffi); 2849 A.store.Ref(retPtr, _ret); 2850 }, 2851 "try_SetZoomSettings": ( 2852 retPtr: Pointer, 2853 errPtr: Pointer, 2854 tabId: number, 2855 zoomSettings: Pointer 2856 ): heap.Ref<boolean> => { 2857 try { 2858 const zoomSettings_ffi = {}; 2859 2860 if (A.load.Bool(zoomSettings + 16)) { 2861 zoomSettings_ffi["defaultZoomFactor"] = A.load.Float64(zoomSettings + 0); 2862 } 2863 zoomSettings_ffi["mode"] = A.load.Enum(zoomSettings + 8, ["automatic", "manual", "disabled"]); 2864 zoomSettings_ffi["scope"] = A.load.Enum(zoomSettings + 12, ["per-origin", "per-tab"]); 2865 2866 const _ret = WEBEXT.tabs.setZoomSettings(tabId, zoomSettings_ffi); 2867 A.store.Ref(retPtr, _ret); 2868 return A.H.TRUE; 2869 } catch (err: any) { 2870 A.store.Ref(errPtr, err); 2871 return A.H.FALSE; 2872 } 2873 }, 2874 "has_Ungroup": (): heap.Ref<boolean> => { 2875 if (WEBEXT?.tabs && "ungroup" in WEBEXT?.tabs) { 2876 return A.H.TRUE; 2877 } 2878 return A.H.FALSE; 2879 }, 2880 "func_Ungroup": (fn: Pointer): void => { 2881 A.store.Ref(fn, WEBEXT.tabs.ungroup); 2882 }, 2883 "call_Ungroup": (retPtr: Pointer, tabIds: heap.Ref<any>): void => { 2884 const _ret = WEBEXT.tabs.ungroup(A.H.get<any>(tabIds)); 2885 A.store.Ref(retPtr, _ret); 2886 }, 2887 "try_Ungroup": (retPtr: Pointer, errPtr: Pointer, tabIds: heap.Ref<any>): heap.Ref<boolean> => { 2888 try { 2889 const _ret = WEBEXT.tabs.ungroup(A.H.get<any>(tabIds)); 2890 A.store.Ref(retPtr, _ret); 2891 return A.H.TRUE; 2892 } catch (err: any) { 2893 A.store.Ref(errPtr, err); 2894 return A.H.FALSE; 2895 } 2896 }, 2897 "has_Update": (): heap.Ref<boolean> => { 2898 if (WEBEXT?.tabs && "update" in WEBEXT?.tabs) { 2899 return A.H.TRUE; 2900 } 2901 return A.H.FALSE; 2902 }, 2903 "func_Update": (fn: Pointer): void => { 2904 A.store.Ref(fn, WEBEXT.tabs.update); 2905 }, 2906 "call_Update": (retPtr: Pointer, tabId: number, updateProperties: Pointer): void => { 2907 const updateProperties_ffi = {}; 2908 2909 if (A.load.Bool(updateProperties + 24)) { 2910 updateProperties_ffi["active"] = A.load.Bool(updateProperties + 0); 2911 } 2912 if (A.load.Bool(updateProperties + 25)) { 2913 updateProperties_ffi["autoDiscardable"] = A.load.Bool(updateProperties + 1); 2914 } 2915 if (A.load.Bool(updateProperties + 26)) { 2916 updateProperties_ffi["highlighted"] = A.load.Bool(updateProperties + 2); 2917 } 2918 if (A.load.Bool(updateProperties + 27)) { 2919 updateProperties_ffi["muted"] = A.load.Bool(updateProperties + 3); 2920 } 2921 if (A.load.Bool(updateProperties + 28)) { 2922 updateProperties_ffi["openerTabId"] = A.load.Int64(updateProperties + 8); 2923 } 2924 if (A.load.Bool(updateProperties + 29)) { 2925 updateProperties_ffi["pinned"] = A.load.Bool(updateProperties + 16); 2926 } 2927 if (A.load.Bool(updateProperties + 30)) { 2928 updateProperties_ffi["selected"] = A.load.Bool(updateProperties + 17); 2929 } 2930 updateProperties_ffi["url"] = A.load.Ref(updateProperties + 20, undefined); 2931 2932 const _ret = WEBEXT.tabs.update(tabId, updateProperties_ffi); 2933 A.store.Ref(retPtr, _ret); 2934 }, 2935 "try_Update": (retPtr: Pointer, errPtr: Pointer, tabId: number, updateProperties: Pointer): heap.Ref<boolean> => { 2936 try { 2937 const updateProperties_ffi = {}; 2938 2939 if (A.load.Bool(updateProperties + 24)) { 2940 updateProperties_ffi["active"] = A.load.Bool(updateProperties + 0); 2941 } 2942 if (A.load.Bool(updateProperties + 25)) { 2943 updateProperties_ffi["autoDiscardable"] = A.load.Bool(updateProperties + 1); 2944 } 2945 if (A.load.Bool(updateProperties + 26)) { 2946 updateProperties_ffi["highlighted"] = A.load.Bool(updateProperties + 2); 2947 } 2948 if (A.load.Bool(updateProperties + 27)) { 2949 updateProperties_ffi["muted"] = A.load.Bool(updateProperties + 3); 2950 } 2951 if (A.load.Bool(updateProperties + 28)) { 2952 updateProperties_ffi["openerTabId"] = A.load.Int64(updateProperties + 8); 2953 } 2954 if (A.load.Bool(updateProperties + 29)) { 2955 updateProperties_ffi["pinned"] = A.load.Bool(updateProperties + 16); 2956 } 2957 if (A.load.Bool(updateProperties + 30)) { 2958 updateProperties_ffi["selected"] = A.load.Bool(updateProperties + 17); 2959 } 2960 updateProperties_ffi["url"] = A.load.Ref(updateProperties + 20, undefined); 2961 2962 const _ret = WEBEXT.tabs.update(tabId, updateProperties_ffi); 2963 A.store.Ref(retPtr, _ret); 2964 return A.H.TRUE; 2965 } catch (err: any) { 2966 A.store.Ref(errPtr, err); 2967 return A.H.FALSE; 2968 } 2969 }, 2970 }; 2971 });