github.com/primecitizens/pcz/std@v0.2.1/plat/js/webext/accessibilityprivate/bindings/ffi_bindings.ts (about) 1 import { importModule, Application, heap, Pointer } from "@ffi"; 2 3 importModule("plat/js/webext/accessibilityprivate", (A: Application) => { 4 const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser; 5 6 return { 7 "constof_AcceleratorAction": (ref: heap.Ref<string>): number => { 8 const idx = ["focusPreviousPane", "focusNextPane"].indexOf(A.H.get(ref)); 9 return idx < 0 ? 0 : idx + 1; 10 }, 11 "constof_AccessibilityFeature": (ref: heap.Ref<string>): number => { 12 const idx = [ 13 "googleTtsLanguagePacks", 14 "dictationContextChecking", 15 "chromevoxSettingsMigration", 16 "gameFaceIntegration", 17 "googleTtsHighQualityVoices", 18 ].indexOf(A.H.get(ref)); 19 return idx < 0 ? 0 : idx + 1; 20 }, 21 22 "store_AlertInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 23 const x = A.H.get<any>(ref); 24 25 if (typeof x === "undefined") { 26 A.store.Bool(ptr + 4, false); 27 A.store.Ref(ptr + 0, undefined); 28 } else { 29 A.store.Bool(ptr + 4, true); 30 A.store.Ref(ptr + 0, x["message"]); 31 } 32 }, 33 "load_AlertInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 34 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 35 36 x["message"] = A.load.Ref(ptr + 0, undefined); 37 return create === A.H.TRUE ? A.H.push(x) : ref; 38 }, 39 "constof_AssistiveTechnologyType": (ref: heap.Ref<string>): number => { 40 const idx = ["chromeVox", "selectToSpeak", "switchAccess", "autoClick", "magnifier", "dictation"].indexOf( 41 A.H.get(ref) 42 ); 43 return idx < 0 ? 0 : idx + 1; 44 }, 45 "constof_DictationBubbleHintType": (ref: heap.Ref<string>): number => { 46 const idx = ["trySaying", "type", "delete", "selectAll", "undo", "help", "unselect", "copy"].indexOf( 47 A.H.get(ref) 48 ); 49 return idx < 0 ? 0 : idx + 1; 50 }, 51 "constof_DictationBubbleIconType": (ref: heap.Ref<string>): number => { 52 const idx = ["hidden", "standby", "macroSuccess", "macroFail"].indexOf(A.H.get(ref)); 53 return idx < 0 ? 0 : idx + 1; 54 }, 55 56 "store_DictationBubbleProperties": (ptr: Pointer, ref: heap.Ref<any>) => { 57 const x = A.H.get<any>(ref); 58 59 if (typeof x === "undefined") { 60 A.store.Bool(ptr + 13, false); 61 A.store.Ref(ptr + 0, undefined); 62 A.store.Enum(ptr + 4, -1); 63 A.store.Ref(ptr + 8, undefined); 64 A.store.Bool(ptr + 12, false); 65 } else { 66 A.store.Bool(ptr + 13, true); 67 A.store.Ref(ptr + 0, x["hints"]); 68 A.store.Enum(ptr + 4, ["hidden", "standby", "macroSuccess", "macroFail"].indexOf(x["icon"] as string)); 69 A.store.Ref(ptr + 8, x["text"]); 70 A.store.Bool(ptr + 12, x["visible"] ? true : false); 71 } 72 }, 73 "load_DictationBubbleProperties": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 74 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 75 76 x["hints"] = A.load.Ref(ptr + 0, undefined); 77 x["icon"] = A.load.Enum(ptr + 4, ["hidden", "standby", "macroSuccess", "macroFail"]); 78 x["text"] = A.load.Ref(ptr + 8, undefined); 79 x["visible"] = A.load.Bool(ptr + 12); 80 return create === A.H.TRUE ? A.H.push(x) : ref; 81 }, 82 "constof_DlcType": (ref: heap.Ref<string>): number => { 83 const idx = [ 84 "ttsBnBd", 85 "ttsCsCz", 86 "ttsDaDk", 87 "ttsDeDe", 88 "ttsElGr", 89 "ttsEnAu", 90 "ttsEnGb", 91 "ttsEnUs", 92 "ttsEsEs", 93 "ttsEsUs", 94 "ttsFiFi", 95 "ttsFilPh", 96 "ttsFrFr", 97 "ttsHiIn", 98 "ttsHuHu", 99 "ttsIdId", 100 "ttsItIt", 101 "ttsJaJp", 102 "ttsKmKh", 103 "ttsKoKr", 104 "ttsNbNo", 105 "ttsNeNp", 106 "ttsNlNl", 107 "ttsPlPl", 108 "ttsPtBr", 109 "ttsSiLk", 110 "ttsSkSk", 111 "ttsSvSe", 112 "ttsThTh", 113 "ttsTrTr", 114 "ttsUkUa", 115 "ttsViVn", 116 "ttsYueHk", 117 ].indexOf(A.H.get(ref)); 118 return idx < 0 ? 0 : idx + 1; 119 }, 120 121 "store_ScreenRect": (ptr: Pointer, ref: heap.Ref<any>) => { 122 const x = A.H.get<any>(ref); 123 124 if (typeof x === "undefined") { 125 A.store.Bool(ptr + 32, false); 126 A.store.Int64(ptr + 0, 0); 127 A.store.Int64(ptr + 8, 0); 128 A.store.Int64(ptr + 16, 0); 129 A.store.Int64(ptr + 24, 0); 130 } else { 131 A.store.Bool(ptr + 32, true); 132 A.store.Int64(ptr + 0, x["height"] === undefined ? 0 : (x["height"] as number)); 133 A.store.Int64(ptr + 8, x["left"] === undefined ? 0 : (x["left"] as number)); 134 A.store.Int64(ptr + 16, x["top"] === undefined ? 0 : (x["top"] as number)); 135 A.store.Int64(ptr + 24, x["width"] === undefined ? 0 : (x["width"] as number)); 136 } 137 }, 138 "load_ScreenRect": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 139 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 140 141 x["height"] = A.load.Int64(ptr + 0); 142 x["left"] = A.load.Int64(ptr + 8); 143 x["top"] = A.load.Int64(ptr + 16); 144 x["width"] = A.load.Int64(ptr + 24); 145 return create === A.H.TRUE ? A.H.push(x) : ref; 146 }, 147 "constof_FocusRingStackingOrder": (ref: heap.Ref<string>): number => { 148 const idx = ["aboveAccessibilityBubbles", "belowAccessibilityBubbles"].indexOf(A.H.get(ref)); 149 return idx < 0 ? 0 : idx + 1; 150 }, 151 "constof_FocusType": (ref: heap.Ref<string>): number => { 152 const idx = ["glow", "solid", "dashed"].indexOf(A.H.get(ref)); 153 return idx < 0 ? 0 : idx + 1; 154 }, 155 156 "store_FocusRingInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 157 const x = A.H.get<any>(ref); 158 159 if (typeof x === "undefined") { 160 A.store.Bool(ptr + 28, false); 161 A.store.Ref(ptr + 0, undefined); 162 A.store.Ref(ptr + 4, undefined); 163 A.store.Ref(ptr + 8, undefined); 164 A.store.Ref(ptr + 12, undefined); 165 A.store.Ref(ptr + 16, undefined); 166 A.store.Enum(ptr + 20, -1); 167 A.store.Enum(ptr + 24, -1); 168 } else { 169 A.store.Bool(ptr + 28, true); 170 A.store.Ref(ptr + 0, x["backgroundColor"]); 171 A.store.Ref(ptr + 4, x["color"]); 172 A.store.Ref(ptr + 8, x["id"]); 173 A.store.Ref(ptr + 12, x["rects"]); 174 A.store.Ref(ptr + 16, x["secondaryColor"]); 175 A.store.Enum( 176 ptr + 20, 177 ["aboveAccessibilityBubbles", "belowAccessibilityBubbles"].indexOf(x["stackingOrder"] as string) 178 ); 179 A.store.Enum(ptr + 24, ["glow", "solid", "dashed"].indexOf(x["type"] as string)); 180 } 181 }, 182 "load_FocusRingInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 183 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 184 185 x["backgroundColor"] = A.load.Ref(ptr + 0, undefined); 186 x["color"] = A.load.Ref(ptr + 4, undefined); 187 x["id"] = A.load.Ref(ptr + 8, undefined); 188 x["rects"] = A.load.Ref(ptr + 12, undefined); 189 x["secondaryColor"] = A.load.Ref(ptr + 16, undefined); 190 x["stackingOrder"] = A.load.Enum(ptr + 20, ["aboveAccessibilityBubbles", "belowAccessibilityBubbles"]); 191 x["type"] = A.load.Enum(ptr + 24, ["glow", "solid", "dashed"]); 192 return create === A.H.TRUE ? A.H.push(x) : ref; 193 }, 194 "constof_Gesture": (ref: heap.Ref<string>): number => { 195 const idx = [ 196 "click", 197 "swipeLeft1", 198 "swipeUp1", 199 "swipeRight1", 200 "swipeDown1", 201 "swipeLeft2", 202 "swipeUp2", 203 "swipeRight2", 204 "swipeDown2", 205 "swipeLeft3", 206 "swipeUp3", 207 "swipeRight3", 208 "swipeDown3", 209 "swipeLeft4", 210 "swipeUp4", 211 "swipeRight4", 212 "swipeDown4", 213 "tap2", 214 "tap3", 215 "tap4", 216 "touchExplore", 217 ].indexOf(A.H.get(ref)); 218 return idx < 0 ? 0 : idx + 1; 219 }, 220 "get_IS_DEFAULT_EVENT_SOURCE_TOUCH": (retPtr: Pointer): heap.Ref<boolean> => { 221 if (WEBEXT?.accessibilityPrivate && "IS_DEFAULT_EVENT_SOURCE_TOUCH" in WEBEXT?.accessibilityPrivate) { 222 const val = WEBEXT.accessibilityPrivate.IS_DEFAULT_EVENT_SOURCE_TOUCH; 223 A.store.Int64(retPtr, val); 224 return A.H.TRUE; 225 } 226 227 return A.H.FALSE; 228 }, 229 "set_IS_DEFAULT_EVENT_SOURCE_TOUCH": (val: number): heap.Ref<boolean> => { 230 return Reflect.set(WEBEXT.accessibilityPrivate, "IS_DEFAULT_EVENT_SOURCE_TOUCH", val, WEBEXT.accessibilityPrivate) 231 ? A.H.TRUE 232 : A.H.FALSE; 233 }, 234 "constof_MagnifierCommand": (ref: heap.Ref<string>): number => { 235 const idx = ["moveStop", "moveUp", "moveDown", "moveLeft", "moveRight"].indexOf(A.H.get(ref)); 236 return idx < 0 ? 0 : idx + 1; 237 }, 238 239 "store_PointScanPoint": (ptr: Pointer, ref: heap.Ref<any>) => { 240 const x = A.H.get<any>(ref); 241 242 if (typeof x === "undefined") { 243 A.store.Bool(ptr + 16, false); 244 A.store.Float64(ptr + 0, 0); 245 A.store.Float64(ptr + 8, 0); 246 } else { 247 A.store.Bool(ptr + 16, true); 248 A.store.Float64(ptr + 0, x["x"] === undefined ? 0 : (x["x"] as number)); 249 A.store.Float64(ptr + 8, x["y"] === undefined ? 0 : (x["y"] as number)); 250 } 251 }, 252 "load_PointScanPoint": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 253 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 254 255 x["x"] = A.load.Float64(ptr + 0); 256 x["y"] = A.load.Float64(ptr + 8); 257 return create === A.H.TRUE ? A.H.push(x) : ref; 258 }, 259 "constof_PointScanState": (ref: heap.Ref<string>): number => { 260 const idx = ["start", "stop"].indexOf(A.H.get(ref)); 261 return idx < 0 ? 0 : idx + 1; 262 }, 263 264 "store_PumpkinData": (ptr: Pointer, ref: heap.Ref<any>) => { 265 const x = A.H.get<any>(ref); 266 267 if (typeof x === "undefined") { 268 A.store.Bool(ptr + 52, false); 269 A.store.Ref(ptr + 0, undefined); 270 A.store.Ref(ptr + 4, undefined); 271 A.store.Ref(ptr + 8, undefined); 272 A.store.Ref(ptr + 12, undefined); 273 A.store.Ref(ptr + 16, undefined); 274 A.store.Ref(ptr + 20, undefined); 275 A.store.Ref(ptr + 24, undefined); 276 A.store.Ref(ptr + 28, undefined); 277 A.store.Ref(ptr + 32, undefined); 278 A.store.Ref(ptr + 36, undefined); 279 A.store.Ref(ptr + 40, undefined); 280 A.store.Ref(ptr + 44, undefined); 281 A.store.Ref(ptr + 48, undefined); 282 } else { 283 A.store.Bool(ptr + 52, true); 284 A.store.Ref(ptr + 0, x["de_de_action_config_binarypb"]); 285 A.store.Ref(ptr + 4, x["de_de_pumpkin_config_binarypb"]); 286 A.store.Ref(ptr + 8, x["en_us_action_config_binarypb"]); 287 A.store.Ref(ptr + 12, x["en_us_pumpkin_config_binarypb"]); 288 A.store.Ref(ptr + 16, x["es_es_action_config_binarypb"]); 289 A.store.Ref(ptr + 20, x["es_es_pumpkin_config_binarypb"]); 290 A.store.Ref(ptr + 24, x["fr_fr_action_config_binarypb"]); 291 A.store.Ref(ptr + 28, x["fr_fr_pumpkin_config_binarypb"]); 292 A.store.Ref(ptr + 32, x["it_it_action_config_binarypb"]); 293 A.store.Ref(ptr + 36, x["it_it_pumpkin_config_binarypb"]); 294 A.store.Ref(ptr + 40, x["js_pumpkin_tagger_bin_js"]); 295 A.store.Ref(ptr + 44, x["tagger_wasm_main_js"]); 296 A.store.Ref(ptr + 48, x["tagger_wasm_main_wasm"]); 297 } 298 }, 299 "load_PumpkinData": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 300 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 301 302 x["de_de_action_config_binarypb"] = A.load.Ref(ptr + 0, undefined); 303 x["de_de_pumpkin_config_binarypb"] = A.load.Ref(ptr + 4, undefined); 304 x["en_us_action_config_binarypb"] = A.load.Ref(ptr + 8, undefined); 305 x["en_us_pumpkin_config_binarypb"] = A.load.Ref(ptr + 12, undefined); 306 x["es_es_action_config_binarypb"] = A.load.Ref(ptr + 16, undefined); 307 x["es_es_pumpkin_config_binarypb"] = A.load.Ref(ptr + 20, undefined); 308 x["fr_fr_action_config_binarypb"] = A.load.Ref(ptr + 24, undefined); 309 x["fr_fr_pumpkin_config_binarypb"] = A.load.Ref(ptr + 28, undefined); 310 x["it_it_action_config_binarypb"] = A.load.Ref(ptr + 32, undefined); 311 x["it_it_pumpkin_config_binarypb"] = A.load.Ref(ptr + 36, undefined); 312 x["js_pumpkin_tagger_bin_js"] = A.load.Ref(ptr + 40, undefined); 313 x["tagger_wasm_main_js"] = A.load.Ref(ptr + 44, undefined); 314 x["tagger_wasm_main_wasm"] = A.load.Ref(ptr + 48, undefined); 315 return create === A.H.TRUE ? A.H.push(x) : ref; 316 }, 317 318 "store_ScreenPoint": (ptr: Pointer, ref: heap.Ref<any>) => { 319 const x = A.H.get<any>(ref); 320 321 if (typeof x === "undefined") { 322 A.store.Bool(ptr + 16, false); 323 A.store.Int64(ptr + 0, 0); 324 A.store.Int64(ptr + 8, 0); 325 } else { 326 A.store.Bool(ptr + 16, true); 327 A.store.Int64(ptr + 0, x["x"] === undefined ? 0 : (x["x"] as number)); 328 A.store.Int64(ptr + 8, x["y"] === undefined ? 0 : (x["y"] as number)); 329 } 330 }, 331 "load_ScreenPoint": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 332 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 333 334 x["x"] = A.load.Int64(ptr + 0); 335 x["y"] = A.load.Int64(ptr + 8); 336 return create === A.H.TRUE ? A.H.push(x) : ref; 337 }, 338 "constof_SelectToSpeakPanelAction": (ref: heap.Ref<string>): number => { 339 const idx = [ 340 "previousParagraph", 341 "previousSentence", 342 "pause", 343 "resume", 344 "nextSentence", 345 "nextParagraph", 346 "exit", 347 "changeSpeed", 348 ].indexOf(A.H.get(ref)); 349 return idx < 0 ? 0 : idx + 1; 350 }, 351 "constof_SelectToSpeakState": (ref: heap.Ref<string>): number => { 352 const idx = ["selecting", "speaking", "inactive"].indexOf(A.H.get(ref)); 353 return idx < 0 ? 0 : idx + 1; 354 }, 355 "constof_SetNativeChromeVoxResponse": (ref: heap.Ref<string>): number => { 356 const idx = [ 357 "success", 358 "talkbackNotInstalled", 359 "windowNotFound", 360 "failure", 361 "needDeprecationConfirmation", 362 ].indexOf(A.H.get(ref)); 363 return idx < 0 ? 0 : idx + 1; 364 }, 365 "constof_SwitchAccessBubble": (ref: heap.Ref<string>): number => { 366 const idx = ["backButton", "menu"].indexOf(A.H.get(ref)); 367 return idx < 0 ? 0 : idx + 1; 368 }, 369 "constof_SwitchAccessCommand": (ref: heap.Ref<string>): number => { 370 const idx = ["select", "next", "previous"].indexOf(A.H.get(ref)); 371 return idx < 0 ? 0 : idx + 1; 372 }, 373 "constof_SwitchAccessMenuAction": (ref: heap.Ref<string>): number => { 374 const idx = [ 375 "copy", 376 "cut", 377 "decrement", 378 "dictation", 379 "endTextSelection", 380 "increment", 381 "itemScan", 382 "jumpToBeginningOfText", 383 "jumpToEndOfText", 384 "keyboard", 385 "leftClick", 386 "moveBackwardOneCharOfText", 387 "moveBackwardOneWordOfText", 388 "moveCursor", 389 "moveDownOneLineOfText", 390 "moveForwardOneCharOfText", 391 "moveForwardOneWordOfText", 392 "moveUpOneLineOfText", 393 "paste", 394 "pointScan", 395 "rightClick", 396 "scrollDown", 397 "scrollLeft", 398 "scrollRight", 399 "scrollUp", 400 "select", 401 "settings", 402 "startTextSelection", 403 ].indexOf(A.H.get(ref)); 404 return idx < 0 ? 0 : idx + 1; 405 }, 406 407 "store_SyntheticKeyboardModifiers": (ptr: Pointer, ref: heap.Ref<any>) => { 408 const x = A.H.get<any>(ref); 409 410 if (typeof x === "undefined") { 411 A.store.Bool(ptr + 8, false); 412 A.store.Bool(ptr + 4, false); 413 A.store.Bool(ptr + 0, false); 414 A.store.Bool(ptr + 5, false); 415 A.store.Bool(ptr + 1, false); 416 A.store.Bool(ptr + 6, false); 417 A.store.Bool(ptr + 2, false); 418 A.store.Bool(ptr + 7, false); 419 A.store.Bool(ptr + 3, false); 420 } else { 421 A.store.Bool(ptr + 8, true); 422 A.store.Bool(ptr + 4, "alt" in x ? true : false); 423 A.store.Bool(ptr + 0, x["alt"] ? true : false); 424 A.store.Bool(ptr + 5, "ctrl" in x ? true : false); 425 A.store.Bool(ptr + 1, x["ctrl"] ? true : false); 426 A.store.Bool(ptr + 6, "search" in x ? true : false); 427 A.store.Bool(ptr + 2, x["search"] ? true : false); 428 A.store.Bool(ptr + 7, "shift" in x ? true : false); 429 A.store.Bool(ptr + 3, x["shift"] ? true : false); 430 } 431 }, 432 "load_SyntheticKeyboardModifiers": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 433 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 434 435 if (A.load.Bool(ptr + 4)) { 436 x["alt"] = A.load.Bool(ptr + 0); 437 } else { 438 delete x["alt"]; 439 } 440 if (A.load.Bool(ptr + 5)) { 441 x["ctrl"] = A.load.Bool(ptr + 1); 442 } else { 443 delete x["ctrl"]; 444 } 445 if (A.load.Bool(ptr + 6)) { 446 x["search"] = A.load.Bool(ptr + 2); 447 } else { 448 delete x["search"]; 449 } 450 if (A.load.Bool(ptr + 7)) { 451 x["shift"] = A.load.Bool(ptr + 3); 452 } else { 453 delete x["shift"]; 454 } 455 return create === A.H.TRUE ? A.H.push(x) : ref; 456 }, 457 "constof_SyntheticKeyboardEventType": (ref: heap.Ref<string>): number => { 458 const idx = ["keyup", "keydown"].indexOf(A.H.get(ref)); 459 return idx < 0 ? 0 : idx + 1; 460 }, 461 462 "store_SyntheticKeyboardEvent": (ptr: Pointer, ref: heap.Ref<any>) => { 463 const x = A.H.get<any>(ref); 464 465 if (typeof x === "undefined") { 466 A.store.Bool(ptr + 24, false); 467 A.store.Int64(ptr + 0, 0); 468 469 A.store.Bool(ptr + 8 + 8, false); 470 A.store.Bool(ptr + 8 + 4, false); 471 A.store.Bool(ptr + 8 + 0, false); 472 A.store.Bool(ptr + 8 + 5, false); 473 A.store.Bool(ptr + 8 + 1, false); 474 A.store.Bool(ptr + 8 + 6, false); 475 A.store.Bool(ptr + 8 + 2, false); 476 A.store.Bool(ptr + 8 + 7, false); 477 A.store.Bool(ptr + 8 + 3, false); 478 A.store.Enum(ptr + 20, -1); 479 } else { 480 A.store.Bool(ptr + 24, true); 481 A.store.Int64(ptr + 0, x["keyCode"] === undefined ? 0 : (x["keyCode"] as number)); 482 483 if (typeof x["modifiers"] === "undefined") { 484 A.store.Bool(ptr + 8 + 8, false); 485 A.store.Bool(ptr + 8 + 4, false); 486 A.store.Bool(ptr + 8 + 0, false); 487 A.store.Bool(ptr + 8 + 5, false); 488 A.store.Bool(ptr + 8 + 1, false); 489 A.store.Bool(ptr + 8 + 6, false); 490 A.store.Bool(ptr + 8 + 2, false); 491 A.store.Bool(ptr + 8 + 7, false); 492 A.store.Bool(ptr + 8 + 3, false); 493 } else { 494 A.store.Bool(ptr + 8 + 8, true); 495 A.store.Bool(ptr + 8 + 4, "alt" in x["modifiers"] ? true : false); 496 A.store.Bool(ptr + 8 + 0, x["modifiers"]["alt"] ? true : false); 497 A.store.Bool(ptr + 8 + 5, "ctrl" in x["modifiers"] ? true : false); 498 A.store.Bool(ptr + 8 + 1, x["modifiers"]["ctrl"] ? true : false); 499 A.store.Bool(ptr + 8 + 6, "search" in x["modifiers"] ? true : false); 500 A.store.Bool(ptr + 8 + 2, x["modifiers"]["search"] ? true : false); 501 A.store.Bool(ptr + 8 + 7, "shift" in x["modifiers"] ? true : false); 502 A.store.Bool(ptr + 8 + 3, x["modifiers"]["shift"] ? true : false); 503 } 504 A.store.Enum(ptr + 20, ["keyup", "keydown"].indexOf(x["type"] as string)); 505 } 506 }, 507 "load_SyntheticKeyboardEvent": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 508 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 509 510 x["keyCode"] = A.load.Int64(ptr + 0); 511 if (A.load.Bool(ptr + 8 + 8)) { 512 x["modifiers"] = {}; 513 if (A.load.Bool(ptr + 8 + 4)) { 514 x["modifiers"]["alt"] = A.load.Bool(ptr + 8 + 0); 515 } else { 516 delete x["modifiers"]["alt"]; 517 } 518 if (A.load.Bool(ptr + 8 + 5)) { 519 x["modifiers"]["ctrl"] = A.load.Bool(ptr + 8 + 1); 520 } else { 521 delete x["modifiers"]["ctrl"]; 522 } 523 if (A.load.Bool(ptr + 8 + 6)) { 524 x["modifiers"]["search"] = A.load.Bool(ptr + 8 + 2); 525 } else { 526 delete x["modifiers"]["search"]; 527 } 528 if (A.load.Bool(ptr + 8 + 7)) { 529 x["modifiers"]["shift"] = A.load.Bool(ptr + 8 + 3); 530 } else { 531 delete x["modifiers"]["shift"]; 532 } 533 } else { 534 delete x["modifiers"]; 535 } 536 x["type"] = A.load.Enum(ptr + 20, ["keyup", "keydown"]); 537 return create === A.H.TRUE ? A.H.push(x) : ref; 538 }, 539 "constof_SyntheticMouseEventButton": (ref: heap.Ref<string>): number => { 540 const idx = ["left", "middle", "right", "back", "foward"].indexOf(A.H.get(ref)); 541 return idx < 0 ? 0 : idx + 1; 542 }, 543 "constof_SyntheticMouseEventType": (ref: heap.Ref<string>): number => { 544 const idx = ["press", "release", "drag", "move", "enter", "exit"].indexOf(A.H.get(ref)); 545 return idx < 0 ? 0 : idx + 1; 546 }, 547 548 "store_SyntheticMouseEvent": (ptr: Pointer, ref: heap.Ref<any>) => { 549 const x = A.H.get<any>(ref); 550 551 if (typeof x === "undefined") { 552 A.store.Bool(ptr + 33, false); 553 A.store.Enum(ptr + 0, -1); 554 A.store.Bool(ptr + 32, false); 555 A.store.Bool(ptr + 4, false); 556 A.store.Enum(ptr + 8, -1); 557 A.store.Int64(ptr + 16, 0); 558 A.store.Int64(ptr + 24, 0); 559 } else { 560 A.store.Bool(ptr + 33, true); 561 A.store.Enum(ptr + 0, ["left", "middle", "right", "back", "foward"].indexOf(x["mouseButton"] as string)); 562 A.store.Bool(ptr + 32, "touchAccessibility" in x ? true : false); 563 A.store.Bool(ptr + 4, x["touchAccessibility"] ? true : false); 564 A.store.Enum(ptr + 8, ["press", "release", "drag", "move", "enter", "exit"].indexOf(x["type"] as string)); 565 A.store.Int64(ptr + 16, x["x"] === undefined ? 0 : (x["x"] as number)); 566 A.store.Int64(ptr + 24, x["y"] === undefined ? 0 : (x["y"] as number)); 567 } 568 }, 569 "load_SyntheticMouseEvent": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 570 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 571 572 x["mouseButton"] = A.load.Enum(ptr + 0, ["left", "middle", "right", "back", "foward"]); 573 if (A.load.Bool(ptr + 32)) { 574 x["touchAccessibility"] = A.load.Bool(ptr + 4); 575 } else { 576 delete x["touchAccessibility"]; 577 } 578 x["type"] = A.load.Enum(ptr + 8, ["press", "release", "drag", "move", "enter", "exit"]); 579 x["x"] = A.load.Int64(ptr + 16); 580 x["y"] = A.load.Int64(ptr + 24); 581 return create === A.H.TRUE ? A.H.push(x) : ref; 582 }, 583 "constof_ToastType": (ref: heap.Ref<string>): number => { 584 const idx = ["dictationNoFocusedTextField"].indexOf(A.H.get(ref)); 585 return idx < 0 ? 0 : idx + 1; 586 }, 587 "has_DarkenScreen": (): heap.Ref<boolean> => { 588 if (WEBEXT?.accessibilityPrivate && "darkenScreen" in WEBEXT?.accessibilityPrivate) { 589 return A.H.TRUE; 590 } 591 return A.H.FALSE; 592 }, 593 "func_DarkenScreen": (fn: Pointer): void => { 594 A.store.Ref(fn, WEBEXT.accessibilityPrivate.darkenScreen); 595 }, 596 "call_DarkenScreen": (retPtr: Pointer, enabled: heap.Ref<boolean>): void => { 597 const _ret = WEBEXT.accessibilityPrivate.darkenScreen(enabled === A.H.TRUE); 598 }, 599 "try_DarkenScreen": (retPtr: Pointer, errPtr: Pointer, enabled: heap.Ref<boolean>): heap.Ref<boolean> => { 600 try { 601 const _ret = WEBEXT.accessibilityPrivate.darkenScreen(enabled === A.H.TRUE); 602 return A.H.TRUE; 603 } catch (err: any) { 604 A.store.Ref(errPtr, err); 605 return A.H.FALSE; 606 } 607 }, 608 "has_EnableMouseEvents": (): heap.Ref<boolean> => { 609 if (WEBEXT?.accessibilityPrivate && "enableMouseEvents" in WEBEXT?.accessibilityPrivate) { 610 return A.H.TRUE; 611 } 612 return A.H.FALSE; 613 }, 614 "func_EnableMouseEvents": (fn: Pointer): void => { 615 A.store.Ref(fn, WEBEXT.accessibilityPrivate.enableMouseEvents); 616 }, 617 "call_EnableMouseEvents": (retPtr: Pointer, enabled: heap.Ref<boolean>): void => { 618 const _ret = WEBEXT.accessibilityPrivate.enableMouseEvents(enabled === A.H.TRUE); 619 }, 620 "try_EnableMouseEvents": (retPtr: Pointer, errPtr: Pointer, enabled: heap.Ref<boolean>): heap.Ref<boolean> => { 621 try { 622 const _ret = WEBEXT.accessibilityPrivate.enableMouseEvents(enabled === A.H.TRUE); 623 return A.H.TRUE; 624 } catch (err: any) { 625 A.store.Ref(errPtr, err); 626 return A.H.FALSE; 627 } 628 }, 629 "has_ForwardKeyEventsToSwitchAccess": (): heap.Ref<boolean> => { 630 if (WEBEXT?.accessibilityPrivate && "forwardKeyEventsToSwitchAccess" in WEBEXT?.accessibilityPrivate) { 631 return A.H.TRUE; 632 } 633 return A.H.FALSE; 634 }, 635 "func_ForwardKeyEventsToSwitchAccess": (fn: Pointer): void => { 636 A.store.Ref(fn, WEBEXT.accessibilityPrivate.forwardKeyEventsToSwitchAccess); 637 }, 638 "call_ForwardKeyEventsToSwitchAccess": (retPtr: Pointer, shouldForward: heap.Ref<boolean>): void => { 639 const _ret = WEBEXT.accessibilityPrivate.forwardKeyEventsToSwitchAccess(shouldForward === A.H.TRUE); 640 }, 641 "try_ForwardKeyEventsToSwitchAccess": ( 642 retPtr: Pointer, 643 errPtr: Pointer, 644 shouldForward: heap.Ref<boolean> 645 ): heap.Ref<boolean> => { 646 try { 647 const _ret = WEBEXT.accessibilityPrivate.forwardKeyEventsToSwitchAccess(shouldForward === A.H.TRUE); 648 return A.H.TRUE; 649 } catch (err: any) { 650 A.store.Ref(errPtr, err); 651 return A.H.FALSE; 652 } 653 }, 654 "has_GetBatteryDescription": (): heap.Ref<boolean> => { 655 if (WEBEXT?.accessibilityPrivate && "getBatteryDescription" in WEBEXT?.accessibilityPrivate) { 656 return A.H.TRUE; 657 } 658 return A.H.FALSE; 659 }, 660 "func_GetBatteryDescription": (fn: Pointer): void => { 661 A.store.Ref(fn, WEBEXT.accessibilityPrivate.getBatteryDescription); 662 }, 663 "call_GetBatteryDescription": (retPtr: Pointer): void => { 664 const _ret = WEBEXT.accessibilityPrivate.getBatteryDescription(); 665 A.store.Ref(retPtr, _ret); 666 }, 667 "try_GetBatteryDescription": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 668 try { 669 const _ret = WEBEXT.accessibilityPrivate.getBatteryDescription(); 670 A.store.Ref(retPtr, _ret); 671 return A.H.TRUE; 672 } catch (err: any) { 673 A.store.Ref(errPtr, err); 674 return A.H.FALSE; 675 } 676 }, 677 "has_GetDisplayNameForLocale": (): heap.Ref<boolean> => { 678 if (WEBEXT?.accessibilityPrivate && "getDisplayNameForLocale" in WEBEXT?.accessibilityPrivate) { 679 return A.H.TRUE; 680 } 681 return A.H.FALSE; 682 }, 683 "func_GetDisplayNameForLocale": (fn: Pointer): void => { 684 A.store.Ref(fn, WEBEXT.accessibilityPrivate.getDisplayNameForLocale); 685 }, 686 "call_GetDisplayNameForLocale": ( 687 retPtr: Pointer, 688 localeCodeToTranslate: heap.Ref<object>, 689 displayLocaleCode: heap.Ref<object> 690 ): void => { 691 const _ret = WEBEXT.accessibilityPrivate.getDisplayNameForLocale( 692 A.H.get<object>(localeCodeToTranslate), 693 A.H.get<object>(displayLocaleCode) 694 ); 695 A.store.Ref(retPtr, _ret); 696 }, 697 "try_GetDisplayNameForLocale": ( 698 retPtr: Pointer, 699 errPtr: Pointer, 700 localeCodeToTranslate: heap.Ref<object>, 701 displayLocaleCode: heap.Ref<object> 702 ): heap.Ref<boolean> => { 703 try { 704 const _ret = WEBEXT.accessibilityPrivate.getDisplayNameForLocale( 705 A.H.get<object>(localeCodeToTranslate), 706 A.H.get<object>(displayLocaleCode) 707 ); 708 A.store.Ref(retPtr, _ret); 709 return A.H.TRUE; 710 } catch (err: any) { 711 A.store.Ref(errPtr, err); 712 return A.H.FALSE; 713 } 714 }, 715 "has_GetDlcContents": (): heap.Ref<boolean> => { 716 if (WEBEXT?.accessibilityPrivate && "getDlcContents" in WEBEXT?.accessibilityPrivate) { 717 return A.H.TRUE; 718 } 719 return A.H.FALSE; 720 }, 721 "func_GetDlcContents": (fn: Pointer): void => { 722 A.store.Ref(fn, WEBEXT.accessibilityPrivate.getDlcContents); 723 }, 724 "call_GetDlcContents": (retPtr: Pointer, dlc: number): void => { 725 const _ret = WEBEXT.accessibilityPrivate.getDlcContents( 726 dlc > 0 && dlc <= 33 727 ? [ 728 "ttsBnBd", 729 "ttsCsCz", 730 "ttsDaDk", 731 "ttsDeDe", 732 "ttsElGr", 733 "ttsEnAu", 734 "ttsEnGb", 735 "ttsEnUs", 736 "ttsEsEs", 737 "ttsEsUs", 738 "ttsFiFi", 739 "ttsFilPh", 740 "ttsFrFr", 741 "ttsHiIn", 742 "ttsHuHu", 743 "ttsIdId", 744 "ttsItIt", 745 "ttsJaJp", 746 "ttsKmKh", 747 "ttsKoKr", 748 "ttsNbNo", 749 "ttsNeNp", 750 "ttsNlNl", 751 "ttsPlPl", 752 "ttsPtBr", 753 "ttsSiLk", 754 "ttsSkSk", 755 "ttsSvSe", 756 "ttsThTh", 757 "ttsTrTr", 758 "ttsUkUa", 759 "ttsViVn", 760 "ttsYueHk", 761 ][dlc - 1] 762 : undefined 763 ); 764 A.store.Ref(retPtr, _ret); 765 }, 766 "try_GetDlcContents": (retPtr: Pointer, errPtr: Pointer, dlc: number): heap.Ref<boolean> => { 767 try { 768 const _ret = WEBEXT.accessibilityPrivate.getDlcContents( 769 dlc > 0 && dlc <= 33 770 ? [ 771 "ttsBnBd", 772 "ttsCsCz", 773 "ttsDaDk", 774 "ttsDeDe", 775 "ttsElGr", 776 "ttsEnAu", 777 "ttsEnGb", 778 "ttsEnUs", 779 "ttsEsEs", 780 "ttsEsUs", 781 "ttsFiFi", 782 "ttsFilPh", 783 "ttsFrFr", 784 "ttsHiIn", 785 "ttsHuHu", 786 "ttsIdId", 787 "ttsItIt", 788 "ttsJaJp", 789 "ttsKmKh", 790 "ttsKoKr", 791 "ttsNbNo", 792 "ttsNeNp", 793 "ttsNlNl", 794 "ttsPlPl", 795 "ttsPtBr", 796 "ttsSiLk", 797 "ttsSkSk", 798 "ttsSvSe", 799 "ttsThTh", 800 "ttsTrTr", 801 "ttsUkUa", 802 "ttsViVn", 803 "ttsYueHk", 804 ][dlc - 1] 805 : undefined 806 ); 807 A.store.Ref(retPtr, _ret); 808 return A.H.TRUE; 809 } catch (err: any) { 810 A.store.Ref(errPtr, err); 811 return A.H.FALSE; 812 } 813 }, 814 "has_GetLocalizedDomKeyStringForKeyCode": (): heap.Ref<boolean> => { 815 if (WEBEXT?.accessibilityPrivate && "getLocalizedDomKeyStringForKeyCode" in WEBEXT?.accessibilityPrivate) { 816 return A.H.TRUE; 817 } 818 return A.H.FALSE; 819 }, 820 "func_GetLocalizedDomKeyStringForKeyCode": (fn: Pointer): void => { 821 A.store.Ref(fn, WEBEXT.accessibilityPrivate.getLocalizedDomKeyStringForKeyCode); 822 }, 823 "call_GetLocalizedDomKeyStringForKeyCode": (retPtr: Pointer, keyCode: number): void => { 824 const _ret = WEBEXT.accessibilityPrivate.getLocalizedDomKeyStringForKeyCode(keyCode); 825 A.store.Ref(retPtr, _ret); 826 }, 827 "try_GetLocalizedDomKeyStringForKeyCode": ( 828 retPtr: Pointer, 829 errPtr: Pointer, 830 keyCode: number 831 ): heap.Ref<boolean> => { 832 try { 833 const _ret = WEBEXT.accessibilityPrivate.getLocalizedDomKeyStringForKeyCode(keyCode); 834 A.store.Ref(retPtr, _ret); 835 return A.H.TRUE; 836 } catch (err: any) { 837 A.store.Ref(errPtr, err); 838 return A.H.FALSE; 839 } 840 }, 841 "has_HandleScrollableBoundsForPointFound": (): heap.Ref<boolean> => { 842 if (WEBEXT?.accessibilityPrivate && "handleScrollableBoundsForPointFound" in WEBEXT?.accessibilityPrivate) { 843 return A.H.TRUE; 844 } 845 return A.H.FALSE; 846 }, 847 "func_HandleScrollableBoundsForPointFound": (fn: Pointer): void => { 848 A.store.Ref(fn, WEBEXT.accessibilityPrivate.handleScrollableBoundsForPointFound); 849 }, 850 "call_HandleScrollableBoundsForPointFound": (retPtr: Pointer, rect: Pointer): void => { 851 const rect_ffi = {}; 852 853 rect_ffi["height"] = A.load.Int64(rect + 0); 854 rect_ffi["left"] = A.load.Int64(rect + 8); 855 rect_ffi["top"] = A.load.Int64(rect + 16); 856 rect_ffi["width"] = A.load.Int64(rect + 24); 857 858 const _ret = WEBEXT.accessibilityPrivate.handleScrollableBoundsForPointFound(rect_ffi); 859 }, 860 "try_HandleScrollableBoundsForPointFound": (retPtr: Pointer, errPtr: Pointer, rect: Pointer): heap.Ref<boolean> => { 861 try { 862 const rect_ffi = {}; 863 864 rect_ffi["height"] = A.load.Int64(rect + 0); 865 rect_ffi["left"] = A.load.Int64(rect + 8); 866 rect_ffi["top"] = A.load.Int64(rect + 16); 867 rect_ffi["width"] = A.load.Int64(rect + 24); 868 869 const _ret = WEBEXT.accessibilityPrivate.handleScrollableBoundsForPointFound(rect_ffi); 870 return A.H.TRUE; 871 } catch (err: any) { 872 A.store.Ref(errPtr, err); 873 return A.H.FALSE; 874 } 875 }, 876 "has_InstallPumpkinForDictation": (): heap.Ref<boolean> => { 877 if (WEBEXT?.accessibilityPrivate && "installPumpkinForDictation" in WEBEXT?.accessibilityPrivate) { 878 return A.H.TRUE; 879 } 880 return A.H.FALSE; 881 }, 882 "func_InstallPumpkinForDictation": (fn: Pointer): void => { 883 A.store.Ref(fn, WEBEXT.accessibilityPrivate.installPumpkinForDictation); 884 }, 885 "call_InstallPumpkinForDictation": (retPtr: Pointer): void => { 886 const _ret = WEBEXT.accessibilityPrivate.installPumpkinForDictation(); 887 A.store.Ref(retPtr, _ret); 888 }, 889 "try_InstallPumpkinForDictation": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 890 try { 891 const _ret = WEBEXT.accessibilityPrivate.installPumpkinForDictation(); 892 A.store.Ref(retPtr, _ret); 893 return A.H.TRUE; 894 } catch (err: any) { 895 A.store.Ref(errPtr, err); 896 return A.H.FALSE; 897 } 898 }, 899 "has_IsFeatureEnabled": (): heap.Ref<boolean> => { 900 if (WEBEXT?.accessibilityPrivate && "isFeatureEnabled" in WEBEXT?.accessibilityPrivate) { 901 return A.H.TRUE; 902 } 903 return A.H.FALSE; 904 }, 905 "func_IsFeatureEnabled": (fn: Pointer): void => { 906 A.store.Ref(fn, WEBEXT.accessibilityPrivate.isFeatureEnabled); 907 }, 908 "call_IsFeatureEnabled": (retPtr: Pointer, feature: number): void => { 909 const _ret = WEBEXT.accessibilityPrivate.isFeatureEnabled( 910 feature > 0 && feature <= 5 911 ? [ 912 "googleTtsLanguagePacks", 913 "dictationContextChecking", 914 "chromevoxSettingsMigration", 915 "gameFaceIntegration", 916 "googleTtsHighQualityVoices", 917 ][feature - 1] 918 : undefined 919 ); 920 A.store.Ref(retPtr, _ret); 921 }, 922 "try_IsFeatureEnabled": (retPtr: Pointer, errPtr: Pointer, feature: number): heap.Ref<boolean> => { 923 try { 924 const _ret = WEBEXT.accessibilityPrivate.isFeatureEnabled( 925 feature > 0 && feature <= 5 926 ? [ 927 "googleTtsLanguagePacks", 928 "dictationContextChecking", 929 "chromevoxSettingsMigration", 930 "gameFaceIntegration", 931 "googleTtsHighQualityVoices", 932 ][feature - 1] 933 : undefined 934 ); 935 A.store.Ref(retPtr, _ret); 936 return A.H.TRUE; 937 } catch (err: any) { 938 A.store.Ref(errPtr, err); 939 return A.H.FALSE; 940 } 941 }, 942 "has_IsLacrosPrimary": (): heap.Ref<boolean> => { 943 if (WEBEXT?.accessibilityPrivate && "isLacrosPrimary" in WEBEXT?.accessibilityPrivate) { 944 return A.H.TRUE; 945 } 946 return A.H.FALSE; 947 }, 948 "func_IsLacrosPrimary": (fn: Pointer): void => { 949 A.store.Ref(fn, WEBEXT.accessibilityPrivate.isLacrosPrimary); 950 }, 951 "call_IsLacrosPrimary": (retPtr: Pointer): void => { 952 const _ret = WEBEXT.accessibilityPrivate.isLacrosPrimary(); 953 A.store.Ref(retPtr, _ret); 954 }, 955 "try_IsLacrosPrimary": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 956 try { 957 const _ret = WEBEXT.accessibilityPrivate.isLacrosPrimary(); 958 A.store.Ref(retPtr, _ret); 959 return A.H.TRUE; 960 } catch (err: any) { 961 A.store.Ref(errPtr, err); 962 return A.H.FALSE; 963 } 964 }, 965 "has_MagnifierCenterOnPoint": (): heap.Ref<boolean> => { 966 if (WEBEXT?.accessibilityPrivate && "magnifierCenterOnPoint" in WEBEXT?.accessibilityPrivate) { 967 return A.H.TRUE; 968 } 969 return A.H.FALSE; 970 }, 971 "func_MagnifierCenterOnPoint": (fn: Pointer): void => { 972 A.store.Ref(fn, WEBEXT.accessibilityPrivate.magnifierCenterOnPoint); 973 }, 974 "call_MagnifierCenterOnPoint": (retPtr: Pointer, point: Pointer): void => { 975 const point_ffi = {}; 976 977 point_ffi["x"] = A.load.Int64(point + 0); 978 point_ffi["y"] = A.load.Int64(point + 8); 979 980 const _ret = WEBEXT.accessibilityPrivate.magnifierCenterOnPoint(point_ffi); 981 }, 982 "try_MagnifierCenterOnPoint": (retPtr: Pointer, errPtr: Pointer, point: Pointer): heap.Ref<boolean> => { 983 try { 984 const point_ffi = {}; 985 986 point_ffi["x"] = A.load.Int64(point + 0); 987 point_ffi["y"] = A.load.Int64(point + 8); 988 989 const _ret = WEBEXT.accessibilityPrivate.magnifierCenterOnPoint(point_ffi); 990 return A.H.TRUE; 991 } catch (err: any) { 992 A.store.Ref(errPtr, err); 993 return A.H.FALSE; 994 } 995 }, 996 "has_MoveMagnifierToRect": (): heap.Ref<boolean> => { 997 if (WEBEXT?.accessibilityPrivate && "moveMagnifierToRect" in WEBEXT?.accessibilityPrivate) { 998 return A.H.TRUE; 999 } 1000 return A.H.FALSE; 1001 }, 1002 "func_MoveMagnifierToRect": (fn: Pointer): void => { 1003 A.store.Ref(fn, WEBEXT.accessibilityPrivate.moveMagnifierToRect); 1004 }, 1005 "call_MoveMagnifierToRect": (retPtr: Pointer, rect: Pointer): void => { 1006 const rect_ffi = {}; 1007 1008 rect_ffi["height"] = A.load.Int64(rect + 0); 1009 rect_ffi["left"] = A.load.Int64(rect + 8); 1010 rect_ffi["top"] = A.load.Int64(rect + 16); 1011 rect_ffi["width"] = A.load.Int64(rect + 24); 1012 1013 const _ret = WEBEXT.accessibilityPrivate.moveMagnifierToRect(rect_ffi); 1014 }, 1015 "try_MoveMagnifierToRect": (retPtr: Pointer, errPtr: Pointer, rect: Pointer): heap.Ref<boolean> => { 1016 try { 1017 const rect_ffi = {}; 1018 1019 rect_ffi["height"] = A.load.Int64(rect + 0); 1020 rect_ffi["left"] = A.load.Int64(rect + 8); 1021 rect_ffi["top"] = A.load.Int64(rect + 16); 1022 rect_ffi["width"] = A.load.Int64(rect + 24); 1023 1024 const _ret = WEBEXT.accessibilityPrivate.moveMagnifierToRect(rect_ffi); 1025 return A.H.TRUE; 1026 } catch (err: any) { 1027 A.store.Ref(errPtr, err); 1028 return A.H.FALSE; 1029 } 1030 }, 1031 "has_OnAccessibilityGesture": (): heap.Ref<boolean> => { 1032 if ( 1033 WEBEXT?.accessibilityPrivate?.onAccessibilityGesture && 1034 "addListener" in WEBEXT?.accessibilityPrivate?.onAccessibilityGesture 1035 ) { 1036 return A.H.TRUE; 1037 } 1038 return A.H.FALSE; 1039 }, 1040 "func_OnAccessibilityGesture": (fn: Pointer): void => { 1041 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onAccessibilityGesture.addListener); 1042 }, 1043 "call_OnAccessibilityGesture": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1044 const _ret = WEBEXT.accessibilityPrivate.onAccessibilityGesture.addListener(A.H.get<object>(callback)); 1045 }, 1046 "try_OnAccessibilityGesture": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1047 try { 1048 const _ret = WEBEXT.accessibilityPrivate.onAccessibilityGesture.addListener(A.H.get<object>(callback)); 1049 return A.H.TRUE; 1050 } catch (err: any) { 1051 A.store.Ref(errPtr, err); 1052 return A.H.FALSE; 1053 } 1054 }, 1055 "has_OffAccessibilityGesture": (): heap.Ref<boolean> => { 1056 if ( 1057 WEBEXT?.accessibilityPrivate?.onAccessibilityGesture && 1058 "removeListener" in WEBEXT?.accessibilityPrivate?.onAccessibilityGesture 1059 ) { 1060 return A.H.TRUE; 1061 } 1062 return A.H.FALSE; 1063 }, 1064 "func_OffAccessibilityGesture": (fn: Pointer): void => { 1065 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onAccessibilityGesture.removeListener); 1066 }, 1067 "call_OffAccessibilityGesture": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1068 const _ret = WEBEXT.accessibilityPrivate.onAccessibilityGesture.removeListener(A.H.get<object>(callback)); 1069 }, 1070 "try_OffAccessibilityGesture": ( 1071 retPtr: Pointer, 1072 errPtr: Pointer, 1073 callback: heap.Ref<object> 1074 ): heap.Ref<boolean> => { 1075 try { 1076 const _ret = WEBEXT.accessibilityPrivate.onAccessibilityGesture.removeListener(A.H.get<object>(callback)); 1077 return A.H.TRUE; 1078 } catch (err: any) { 1079 A.store.Ref(errPtr, err); 1080 return A.H.FALSE; 1081 } 1082 }, 1083 "has_HasOnAccessibilityGesture": (): heap.Ref<boolean> => { 1084 if ( 1085 WEBEXT?.accessibilityPrivate?.onAccessibilityGesture && 1086 "hasListener" in WEBEXT?.accessibilityPrivate?.onAccessibilityGesture 1087 ) { 1088 return A.H.TRUE; 1089 } 1090 return A.H.FALSE; 1091 }, 1092 "func_HasOnAccessibilityGesture": (fn: Pointer): void => { 1093 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onAccessibilityGesture.hasListener); 1094 }, 1095 "call_HasOnAccessibilityGesture": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1096 const _ret = WEBEXT.accessibilityPrivate.onAccessibilityGesture.hasListener(A.H.get<object>(callback)); 1097 A.store.Bool(retPtr, _ret); 1098 }, 1099 "try_HasOnAccessibilityGesture": ( 1100 retPtr: Pointer, 1101 errPtr: Pointer, 1102 callback: heap.Ref<object> 1103 ): heap.Ref<boolean> => { 1104 try { 1105 const _ret = WEBEXT.accessibilityPrivate.onAccessibilityGesture.hasListener(A.H.get<object>(callback)); 1106 A.store.Bool(retPtr, _ret); 1107 return A.H.TRUE; 1108 } catch (err: any) { 1109 A.store.Ref(errPtr, err); 1110 return A.H.FALSE; 1111 } 1112 }, 1113 "has_OnAnnounceForAccessibility": (): heap.Ref<boolean> => { 1114 if ( 1115 WEBEXT?.accessibilityPrivate?.onAnnounceForAccessibility && 1116 "addListener" in WEBEXT?.accessibilityPrivate?.onAnnounceForAccessibility 1117 ) { 1118 return A.H.TRUE; 1119 } 1120 return A.H.FALSE; 1121 }, 1122 "func_OnAnnounceForAccessibility": (fn: Pointer): void => { 1123 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onAnnounceForAccessibility.addListener); 1124 }, 1125 "call_OnAnnounceForAccessibility": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1126 const _ret = WEBEXT.accessibilityPrivate.onAnnounceForAccessibility.addListener(A.H.get<object>(callback)); 1127 }, 1128 "try_OnAnnounceForAccessibility": ( 1129 retPtr: Pointer, 1130 errPtr: Pointer, 1131 callback: heap.Ref<object> 1132 ): heap.Ref<boolean> => { 1133 try { 1134 const _ret = WEBEXT.accessibilityPrivate.onAnnounceForAccessibility.addListener(A.H.get<object>(callback)); 1135 return A.H.TRUE; 1136 } catch (err: any) { 1137 A.store.Ref(errPtr, err); 1138 return A.H.FALSE; 1139 } 1140 }, 1141 "has_OffAnnounceForAccessibility": (): heap.Ref<boolean> => { 1142 if ( 1143 WEBEXT?.accessibilityPrivate?.onAnnounceForAccessibility && 1144 "removeListener" in WEBEXT?.accessibilityPrivate?.onAnnounceForAccessibility 1145 ) { 1146 return A.H.TRUE; 1147 } 1148 return A.H.FALSE; 1149 }, 1150 "func_OffAnnounceForAccessibility": (fn: Pointer): void => { 1151 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onAnnounceForAccessibility.removeListener); 1152 }, 1153 "call_OffAnnounceForAccessibility": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1154 const _ret = WEBEXT.accessibilityPrivate.onAnnounceForAccessibility.removeListener(A.H.get<object>(callback)); 1155 }, 1156 "try_OffAnnounceForAccessibility": ( 1157 retPtr: Pointer, 1158 errPtr: Pointer, 1159 callback: heap.Ref<object> 1160 ): heap.Ref<boolean> => { 1161 try { 1162 const _ret = WEBEXT.accessibilityPrivate.onAnnounceForAccessibility.removeListener(A.H.get<object>(callback)); 1163 return A.H.TRUE; 1164 } catch (err: any) { 1165 A.store.Ref(errPtr, err); 1166 return A.H.FALSE; 1167 } 1168 }, 1169 "has_HasOnAnnounceForAccessibility": (): heap.Ref<boolean> => { 1170 if ( 1171 WEBEXT?.accessibilityPrivate?.onAnnounceForAccessibility && 1172 "hasListener" in WEBEXT?.accessibilityPrivate?.onAnnounceForAccessibility 1173 ) { 1174 return A.H.TRUE; 1175 } 1176 return A.H.FALSE; 1177 }, 1178 "func_HasOnAnnounceForAccessibility": (fn: Pointer): void => { 1179 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onAnnounceForAccessibility.hasListener); 1180 }, 1181 "call_HasOnAnnounceForAccessibility": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1182 const _ret = WEBEXT.accessibilityPrivate.onAnnounceForAccessibility.hasListener(A.H.get<object>(callback)); 1183 A.store.Bool(retPtr, _ret); 1184 }, 1185 "try_HasOnAnnounceForAccessibility": ( 1186 retPtr: Pointer, 1187 errPtr: Pointer, 1188 callback: heap.Ref<object> 1189 ): heap.Ref<boolean> => { 1190 try { 1191 const _ret = WEBEXT.accessibilityPrivate.onAnnounceForAccessibility.hasListener(A.H.get<object>(callback)); 1192 A.store.Bool(retPtr, _ret); 1193 return A.H.TRUE; 1194 } catch (err: any) { 1195 A.store.Ref(errPtr, err); 1196 return A.H.FALSE; 1197 } 1198 }, 1199 "has_OnCustomSpokenFeedbackToggled": (): heap.Ref<boolean> => { 1200 if ( 1201 WEBEXT?.accessibilityPrivate?.onCustomSpokenFeedbackToggled && 1202 "addListener" in WEBEXT?.accessibilityPrivate?.onCustomSpokenFeedbackToggled 1203 ) { 1204 return A.H.TRUE; 1205 } 1206 return A.H.FALSE; 1207 }, 1208 "func_OnCustomSpokenFeedbackToggled": (fn: Pointer): void => { 1209 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onCustomSpokenFeedbackToggled.addListener); 1210 }, 1211 "call_OnCustomSpokenFeedbackToggled": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1212 const _ret = WEBEXT.accessibilityPrivate.onCustomSpokenFeedbackToggled.addListener(A.H.get<object>(callback)); 1213 }, 1214 "try_OnCustomSpokenFeedbackToggled": ( 1215 retPtr: Pointer, 1216 errPtr: Pointer, 1217 callback: heap.Ref<object> 1218 ): heap.Ref<boolean> => { 1219 try { 1220 const _ret = WEBEXT.accessibilityPrivate.onCustomSpokenFeedbackToggled.addListener(A.H.get<object>(callback)); 1221 return A.H.TRUE; 1222 } catch (err: any) { 1223 A.store.Ref(errPtr, err); 1224 return A.H.FALSE; 1225 } 1226 }, 1227 "has_OffCustomSpokenFeedbackToggled": (): heap.Ref<boolean> => { 1228 if ( 1229 WEBEXT?.accessibilityPrivate?.onCustomSpokenFeedbackToggled && 1230 "removeListener" in WEBEXT?.accessibilityPrivate?.onCustomSpokenFeedbackToggled 1231 ) { 1232 return A.H.TRUE; 1233 } 1234 return A.H.FALSE; 1235 }, 1236 "func_OffCustomSpokenFeedbackToggled": (fn: Pointer): void => { 1237 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onCustomSpokenFeedbackToggled.removeListener); 1238 }, 1239 "call_OffCustomSpokenFeedbackToggled": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1240 const _ret = WEBEXT.accessibilityPrivate.onCustomSpokenFeedbackToggled.removeListener(A.H.get<object>(callback)); 1241 }, 1242 "try_OffCustomSpokenFeedbackToggled": ( 1243 retPtr: Pointer, 1244 errPtr: Pointer, 1245 callback: heap.Ref<object> 1246 ): heap.Ref<boolean> => { 1247 try { 1248 const _ret = WEBEXT.accessibilityPrivate.onCustomSpokenFeedbackToggled.removeListener( 1249 A.H.get<object>(callback) 1250 ); 1251 return A.H.TRUE; 1252 } catch (err: any) { 1253 A.store.Ref(errPtr, err); 1254 return A.H.FALSE; 1255 } 1256 }, 1257 "has_HasOnCustomSpokenFeedbackToggled": (): heap.Ref<boolean> => { 1258 if ( 1259 WEBEXT?.accessibilityPrivate?.onCustomSpokenFeedbackToggled && 1260 "hasListener" in WEBEXT?.accessibilityPrivate?.onCustomSpokenFeedbackToggled 1261 ) { 1262 return A.H.TRUE; 1263 } 1264 return A.H.FALSE; 1265 }, 1266 "func_HasOnCustomSpokenFeedbackToggled": (fn: Pointer): void => { 1267 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onCustomSpokenFeedbackToggled.hasListener); 1268 }, 1269 "call_HasOnCustomSpokenFeedbackToggled": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1270 const _ret = WEBEXT.accessibilityPrivate.onCustomSpokenFeedbackToggled.hasListener(A.H.get<object>(callback)); 1271 A.store.Bool(retPtr, _ret); 1272 }, 1273 "try_HasOnCustomSpokenFeedbackToggled": ( 1274 retPtr: Pointer, 1275 errPtr: Pointer, 1276 callback: heap.Ref<object> 1277 ): heap.Ref<boolean> => { 1278 try { 1279 const _ret = WEBEXT.accessibilityPrivate.onCustomSpokenFeedbackToggled.hasListener(A.H.get<object>(callback)); 1280 A.store.Bool(retPtr, _ret); 1281 return A.H.TRUE; 1282 } catch (err: any) { 1283 A.store.Ref(errPtr, err); 1284 return A.H.FALSE; 1285 } 1286 }, 1287 "has_OnIntroduceChromeVox": (): heap.Ref<boolean> => { 1288 if ( 1289 WEBEXT?.accessibilityPrivate?.onIntroduceChromeVox && 1290 "addListener" in WEBEXT?.accessibilityPrivate?.onIntroduceChromeVox 1291 ) { 1292 return A.H.TRUE; 1293 } 1294 return A.H.FALSE; 1295 }, 1296 "func_OnIntroduceChromeVox": (fn: Pointer): void => { 1297 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onIntroduceChromeVox.addListener); 1298 }, 1299 "call_OnIntroduceChromeVox": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1300 const _ret = WEBEXT.accessibilityPrivate.onIntroduceChromeVox.addListener(A.H.get<object>(callback)); 1301 }, 1302 "try_OnIntroduceChromeVox": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1303 try { 1304 const _ret = WEBEXT.accessibilityPrivate.onIntroduceChromeVox.addListener(A.H.get<object>(callback)); 1305 return A.H.TRUE; 1306 } catch (err: any) { 1307 A.store.Ref(errPtr, err); 1308 return A.H.FALSE; 1309 } 1310 }, 1311 "has_OffIntroduceChromeVox": (): heap.Ref<boolean> => { 1312 if ( 1313 WEBEXT?.accessibilityPrivate?.onIntroduceChromeVox && 1314 "removeListener" in WEBEXT?.accessibilityPrivate?.onIntroduceChromeVox 1315 ) { 1316 return A.H.TRUE; 1317 } 1318 return A.H.FALSE; 1319 }, 1320 "func_OffIntroduceChromeVox": (fn: Pointer): void => { 1321 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onIntroduceChromeVox.removeListener); 1322 }, 1323 "call_OffIntroduceChromeVox": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1324 const _ret = WEBEXT.accessibilityPrivate.onIntroduceChromeVox.removeListener(A.H.get<object>(callback)); 1325 }, 1326 "try_OffIntroduceChromeVox": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1327 try { 1328 const _ret = WEBEXT.accessibilityPrivate.onIntroduceChromeVox.removeListener(A.H.get<object>(callback)); 1329 return A.H.TRUE; 1330 } catch (err: any) { 1331 A.store.Ref(errPtr, err); 1332 return A.H.FALSE; 1333 } 1334 }, 1335 "has_HasOnIntroduceChromeVox": (): heap.Ref<boolean> => { 1336 if ( 1337 WEBEXT?.accessibilityPrivate?.onIntroduceChromeVox && 1338 "hasListener" in WEBEXT?.accessibilityPrivate?.onIntroduceChromeVox 1339 ) { 1340 return A.H.TRUE; 1341 } 1342 return A.H.FALSE; 1343 }, 1344 "func_HasOnIntroduceChromeVox": (fn: Pointer): void => { 1345 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onIntroduceChromeVox.hasListener); 1346 }, 1347 "call_HasOnIntroduceChromeVox": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1348 const _ret = WEBEXT.accessibilityPrivate.onIntroduceChromeVox.hasListener(A.H.get<object>(callback)); 1349 A.store.Bool(retPtr, _ret); 1350 }, 1351 "try_HasOnIntroduceChromeVox": ( 1352 retPtr: Pointer, 1353 errPtr: Pointer, 1354 callback: heap.Ref<object> 1355 ): heap.Ref<boolean> => { 1356 try { 1357 const _ret = WEBEXT.accessibilityPrivate.onIntroduceChromeVox.hasListener(A.H.get<object>(callback)); 1358 A.store.Bool(retPtr, _ret); 1359 return A.H.TRUE; 1360 } catch (err: any) { 1361 A.store.Ref(errPtr, err); 1362 return A.H.FALSE; 1363 } 1364 }, 1365 "has_OnMagnifierBoundsChanged": (): heap.Ref<boolean> => { 1366 if ( 1367 WEBEXT?.accessibilityPrivate?.onMagnifierBoundsChanged && 1368 "addListener" in WEBEXT?.accessibilityPrivate?.onMagnifierBoundsChanged 1369 ) { 1370 return A.H.TRUE; 1371 } 1372 return A.H.FALSE; 1373 }, 1374 "func_OnMagnifierBoundsChanged": (fn: Pointer): void => { 1375 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onMagnifierBoundsChanged.addListener); 1376 }, 1377 "call_OnMagnifierBoundsChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1378 const _ret = WEBEXT.accessibilityPrivate.onMagnifierBoundsChanged.addListener(A.H.get<object>(callback)); 1379 }, 1380 "try_OnMagnifierBoundsChanged": ( 1381 retPtr: Pointer, 1382 errPtr: Pointer, 1383 callback: heap.Ref<object> 1384 ): heap.Ref<boolean> => { 1385 try { 1386 const _ret = WEBEXT.accessibilityPrivate.onMagnifierBoundsChanged.addListener(A.H.get<object>(callback)); 1387 return A.H.TRUE; 1388 } catch (err: any) { 1389 A.store.Ref(errPtr, err); 1390 return A.H.FALSE; 1391 } 1392 }, 1393 "has_OffMagnifierBoundsChanged": (): heap.Ref<boolean> => { 1394 if ( 1395 WEBEXT?.accessibilityPrivate?.onMagnifierBoundsChanged && 1396 "removeListener" in WEBEXT?.accessibilityPrivate?.onMagnifierBoundsChanged 1397 ) { 1398 return A.H.TRUE; 1399 } 1400 return A.H.FALSE; 1401 }, 1402 "func_OffMagnifierBoundsChanged": (fn: Pointer): void => { 1403 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onMagnifierBoundsChanged.removeListener); 1404 }, 1405 "call_OffMagnifierBoundsChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1406 const _ret = WEBEXT.accessibilityPrivate.onMagnifierBoundsChanged.removeListener(A.H.get<object>(callback)); 1407 }, 1408 "try_OffMagnifierBoundsChanged": ( 1409 retPtr: Pointer, 1410 errPtr: Pointer, 1411 callback: heap.Ref<object> 1412 ): heap.Ref<boolean> => { 1413 try { 1414 const _ret = WEBEXT.accessibilityPrivate.onMagnifierBoundsChanged.removeListener(A.H.get<object>(callback)); 1415 return A.H.TRUE; 1416 } catch (err: any) { 1417 A.store.Ref(errPtr, err); 1418 return A.H.FALSE; 1419 } 1420 }, 1421 "has_HasOnMagnifierBoundsChanged": (): heap.Ref<boolean> => { 1422 if ( 1423 WEBEXT?.accessibilityPrivate?.onMagnifierBoundsChanged && 1424 "hasListener" in WEBEXT?.accessibilityPrivate?.onMagnifierBoundsChanged 1425 ) { 1426 return A.H.TRUE; 1427 } 1428 return A.H.FALSE; 1429 }, 1430 "func_HasOnMagnifierBoundsChanged": (fn: Pointer): void => { 1431 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onMagnifierBoundsChanged.hasListener); 1432 }, 1433 "call_HasOnMagnifierBoundsChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1434 const _ret = WEBEXT.accessibilityPrivate.onMagnifierBoundsChanged.hasListener(A.H.get<object>(callback)); 1435 A.store.Bool(retPtr, _ret); 1436 }, 1437 "try_HasOnMagnifierBoundsChanged": ( 1438 retPtr: Pointer, 1439 errPtr: Pointer, 1440 callback: heap.Ref<object> 1441 ): heap.Ref<boolean> => { 1442 try { 1443 const _ret = WEBEXT.accessibilityPrivate.onMagnifierBoundsChanged.hasListener(A.H.get<object>(callback)); 1444 A.store.Bool(retPtr, _ret); 1445 return A.H.TRUE; 1446 } catch (err: any) { 1447 A.store.Ref(errPtr, err); 1448 return A.H.FALSE; 1449 } 1450 }, 1451 "has_OnMagnifierCommand": (): heap.Ref<boolean> => { 1452 if ( 1453 WEBEXT?.accessibilityPrivate?.onMagnifierCommand && 1454 "addListener" in WEBEXT?.accessibilityPrivate?.onMagnifierCommand 1455 ) { 1456 return A.H.TRUE; 1457 } 1458 return A.H.FALSE; 1459 }, 1460 "func_OnMagnifierCommand": (fn: Pointer): void => { 1461 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onMagnifierCommand.addListener); 1462 }, 1463 "call_OnMagnifierCommand": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1464 const _ret = WEBEXT.accessibilityPrivate.onMagnifierCommand.addListener(A.H.get<object>(callback)); 1465 }, 1466 "try_OnMagnifierCommand": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1467 try { 1468 const _ret = WEBEXT.accessibilityPrivate.onMagnifierCommand.addListener(A.H.get<object>(callback)); 1469 return A.H.TRUE; 1470 } catch (err: any) { 1471 A.store.Ref(errPtr, err); 1472 return A.H.FALSE; 1473 } 1474 }, 1475 "has_OffMagnifierCommand": (): heap.Ref<boolean> => { 1476 if ( 1477 WEBEXT?.accessibilityPrivate?.onMagnifierCommand && 1478 "removeListener" in WEBEXT?.accessibilityPrivate?.onMagnifierCommand 1479 ) { 1480 return A.H.TRUE; 1481 } 1482 return A.H.FALSE; 1483 }, 1484 "func_OffMagnifierCommand": (fn: Pointer): void => { 1485 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onMagnifierCommand.removeListener); 1486 }, 1487 "call_OffMagnifierCommand": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1488 const _ret = WEBEXT.accessibilityPrivate.onMagnifierCommand.removeListener(A.H.get<object>(callback)); 1489 }, 1490 "try_OffMagnifierCommand": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1491 try { 1492 const _ret = WEBEXT.accessibilityPrivate.onMagnifierCommand.removeListener(A.H.get<object>(callback)); 1493 return A.H.TRUE; 1494 } catch (err: any) { 1495 A.store.Ref(errPtr, err); 1496 return A.H.FALSE; 1497 } 1498 }, 1499 "has_HasOnMagnifierCommand": (): heap.Ref<boolean> => { 1500 if ( 1501 WEBEXT?.accessibilityPrivate?.onMagnifierCommand && 1502 "hasListener" in WEBEXT?.accessibilityPrivate?.onMagnifierCommand 1503 ) { 1504 return A.H.TRUE; 1505 } 1506 return A.H.FALSE; 1507 }, 1508 "func_HasOnMagnifierCommand": (fn: Pointer): void => { 1509 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onMagnifierCommand.hasListener); 1510 }, 1511 "call_HasOnMagnifierCommand": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1512 const _ret = WEBEXT.accessibilityPrivate.onMagnifierCommand.hasListener(A.H.get<object>(callback)); 1513 A.store.Bool(retPtr, _ret); 1514 }, 1515 "try_HasOnMagnifierCommand": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1516 try { 1517 const _ret = WEBEXT.accessibilityPrivate.onMagnifierCommand.hasListener(A.H.get<object>(callback)); 1518 A.store.Bool(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_OnPointScanSet": (): heap.Ref<boolean> => { 1526 if ( 1527 WEBEXT?.accessibilityPrivate?.onPointScanSet && 1528 "addListener" in WEBEXT?.accessibilityPrivate?.onPointScanSet 1529 ) { 1530 return A.H.TRUE; 1531 } 1532 return A.H.FALSE; 1533 }, 1534 "func_OnPointScanSet": (fn: Pointer): void => { 1535 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onPointScanSet.addListener); 1536 }, 1537 "call_OnPointScanSet": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1538 const _ret = WEBEXT.accessibilityPrivate.onPointScanSet.addListener(A.H.get<object>(callback)); 1539 }, 1540 "try_OnPointScanSet": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1541 try { 1542 const _ret = WEBEXT.accessibilityPrivate.onPointScanSet.addListener(A.H.get<object>(callback)); 1543 return A.H.TRUE; 1544 } catch (err: any) { 1545 A.store.Ref(errPtr, err); 1546 return A.H.FALSE; 1547 } 1548 }, 1549 "has_OffPointScanSet": (): heap.Ref<boolean> => { 1550 if ( 1551 WEBEXT?.accessibilityPrivate?.onPointScanSet && 1552 "removeListener" in WEBEXT?.accessibilityPrivate?.onPointScanSet 1553 ) { 1554 return A.H.TRUE; 1555 } 1556 return A.H.FALSE; 1557 }, 1558 "func_OffPointScanSet": (fn: Pointer): void => { 1559 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onPointScanSet.removeListener); 1560 }, 1561 "call_OffPointScanSet": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1562 const _ret = WEBEXT.accessibilityPrivate.onPointScanSet.removeListener(A.H.get<object>(callback)); 1563 }, 1564 "try_OffPointScanSet": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1565 try { 1566 const _ret = WEBEXT.accessibilityPrivate.onPointScanSet.removeListener(A.H.get<object>(callback)); 1567 return A.H.TRUE; 1568 } catch (err: any) { 1569 A.store.Ref(errPtr, err); 1570 return A.H.FALSE; 1571 } 1572 }, 1573 "has_HasOnPointScanSet": (): heap.Ref<boolean> => { 1574 if ( 1575 WEBEXT?.accessibilityPrivate?.onPointScanSet && 1576 "hasListener" in WEBEXT?.accessibilityPrivate?.onPointScanSet 1577 ) { 1578 return A.H.TRUE; 1579 } 1580 return A.H.FALSE; 1581 }, 1582 "func_HasOnPointScanSet": (fn: Pointer): void => { 1583 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onPointScanSet.hasListener); 1584 }, 1585 "call_HasOnPointScanSet": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1586 const _ret = WEBEXT.accessibilityPrivate.onPointScanSet.hasListener(A.H.get<object>(callback)); 1587 A.store.Bool(retPtr, _ret); 1588 }, 1589 "try_HasOnPointScanSet": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1590 try { 1591 const _ret = WEBEXT.accessibilityPrivate.onPointScanSet.hasListener(A.H.get<object>(callback)); 1592 A.store.Bool(retPtr, _ret); 1593 return A.H.TRUE; 1594 } catch (err: any) { 1595 A.store.Ref(errPtr, err); 1596 return A.H.FALSE; 1597 } 1598 }, 1599 "has_OnScrollableBoundsForPointRequested": (): heap.Ref<boolean> => { 1600 if ( 1601 WEBEXT?.accessibilityPrivate?.onScrollableBoundsForPointRequested && 1602 "addListener" in WEBEXT?.accessibilityPrivate?.onScrollableBoundsForPointRequested 1603 ) { 1604 return A.H.TRUE; 1605 } 1606 return A.H.FALSE; 1607 }, 1608 "func_OnScrollableBoundsForPointRequested": (fn: Pointer): void => { 1609 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onScrollableBoundsForPointRequested.addListener); 1610 }, 1611 "call_OnScrollableBoundsForPointRequested": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1612 const _ret = WEBEXT.accessibilityPrivate.onScrollableBoundsForPointRequested.addListener( 1613 A.H.get<object>(callback) 1614 ); 1615 }, 1616 "try_OnScrollableBoundsForPointRequested": ( 1617 retPtr: Pointer, 1618 errPtr: Pointer, 1619 callback: heap.Ref<object> 1620 ): heap.Ref<boolean> => { 1621 try { 1622 const _ret = WEBEXT.accessibilityPrivate.onScrollableBoundsForPointRequested.addListener( 1623 A.H.get<object>(callback) 1624 ); 1625 return A.H.TRUE; 1626 } catch (err: any) { 1627 A.store.Ref(errPtr, err); 1628 return A.H.FALSE; 1629 } 1630 }, 1631 "has_OffScrollableBoundsForPointRequested": (): heap.Ref<boolean> => { 1632 if ( 1633 WEBEXT?.accessibilityPrivate?.onScrollableBoundsForPointRequested && 1634 "removeListener" in WEBEXT?.accessibilityPrivate?.onScrollableBoundsForPointRequested 1635 ) { 1636 return A.H.TRUE; 1637 } 1638 return A.H.FALSE; 1639 }, 1640 "func_OffScrollableBoundsForPointRequested": (fn: Pointer): void => { 1641 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onScrollableBoundsForPointRequested.removeListener); 1642 }, 1643 "call_OffScrollableBoundsForPointRequested": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1644 const _ret = WEBEXT.accessibilityPrivate.onScrollableBoundsForPointRequested.removeListener( 1645 A.H.get<object>(callback) 1646 ); 1647 }, 1648 "try_OffScrollableBoundsForPointRequested": ( 1649 retPtr: Pointer, 1650 errPtr: Pointer, 1651 callback: heap.Ref<object> 1652 ): heap.Ref<boolean> => { 1653 try { 1654 const _ret = WEBEXT.accessibilityPrivate.onScrollableBoundsForPointRequested.removeListener( 1655 A.H.get<object>(callback) 1656 ); 1657 return A.H.TRUE; 1658 } catch (err: any) { 1659 A.store.Ref(errPtr, err); 1660 return A.H.FALSE; 1661 } 1662 }, 1663 "has_HasOnScrollableBoundsForPointRequested": (): heap.Ref<boolean> => { 1664 if ( 1665 WEBEXT?.accessibilityPrivate?.onScrollableBoundsForPointRequested && 1666 "hasListener" in WEBEXT?.accessibilityPrivate?.onScrollableBoundsForPointRequested 1667 ) { 1668 return A.H.TRUE; 1669 } 1670 return A.H.FALSE; 1671 }, 1672 "func_HasOnScrollableBoundsForPointRequested": (fn: Pointer): void => { 1673 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onScrollableBoundsForPointRequested.hasListener); 1674 }, 1675 "call_HasOnScrollableBoundsForPointRequested": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1676 const _ret = WEBEXT.accessibilityPrivate.onScrollableBoundsForPointRequested.hasListener( 1677 A.H.get<object>(callback) 1678 ); 1679 A.store.Bool(retPtr, _ret); 1680 }, 1681 "try_HasOnScrollableBoundsForPointRequested": ( 1682 retPtr: Pointer, 1683 errPtr: Pointer, 1684 callback: heap.Ref<object> 1685 ): heap.Ref<boolean> => { 1686 try { 1687 const _ret = WEBEXT.accessibilityPrivate.onScrollableBoundsForPointRequested.hasListener( 1688 A.H.get<object>(callback) 1689 ); 1690 A.store.Bool(retPtr, _ret); 1691 return A.H.TRUE; 1692 } catch (err: any) { 1693 A.store.Ref(errPtr, err); 1694 return A.H.FALSE; 1695 } 1696 }, 1697 "has_OnSelectToSpeakContextMenuClicked": (): heap.Ref<boolean> => { 1698 if ( 1699 WEBEXT?.accessibilityPrivate?.onSelectToSpeakContextMenuClicked && 1700 "addListener" in WEBEXT?.accessibilityPrivate?.onSelectToSpeakContextMenuClicked 1701 ) { 1702 return A.H.TRUE; 1703 } 1704 return A.H.FALSE; 1705 }, 1706 "func_OnSelectToSpeakContextMenuClicked": (fn: Pointer): void => { 1707 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onSelectToSpeakContextMenuClicked.addListener); 1708 }, 1709 "call_OnSelectToSpeakContextMenuClicked": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1710 const _ret = WEBEXT.accessibilityPrivate.onSelectToSpeakContextMenuClicked.addListener(A.H.get<object>(callback)); 1711 }, 1712 "try_OnSelectToSpeakContextMenuClicked": ( 1713 retPtr: Pointer, 1714 errPtr: Pointer, 1715 callback: heap.Ref<object> 1716 ): heap.Ref<boolean> => { 1717 try { 1718 const _ret = WEBEXT.accessibilityPrivate.onSelectToSpeakContextMenuClicked.addListener( 1719 A.H.get<object>(callback) 1720 ); 1721 return A.H.TRUE; 1722 } catch (err: any) { 1723 A.store.Ref(errPtr, err); 1724 return A.H.FALSE; 1725 } 1726 }, 1727 "has_OffSelectToSpeakContextMenuClicked": (): heap.Ref<boolean> => { 1728 if ( 1729 WEBEXT?.accessibilityPrivate?.onSelectToSpeakContextMenuClicked && 1730 "removeListener" in WEBEXT?.accessibilityPrivate?.onSelectToSpeakContextMenuClicked 1731 ) { 1732 return A.H.TRUE; 1733 } 1734 return A.H.FALSE; 1735 }, 1736 "func_OffSelectToSpeakContextMenuClicked": (fn: Pointer): void => { 1737 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onSelectToSpeakContextMenuClicked.removeListener); 1738 }, 1739 "call_OffSelectToSpeakContextMenuClicked": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1740 const _ret = WEBEXT.accessibilityPrivate.onSelectToSpeakContextMenuClicked.removeListener( 1741 A.H.get<object>(callback) 1742 ); 1743 }, 1744 "try_OffSelectToSpeakContextMenuClicked": ( 1745 retPtr: Pointer, 1746 errPtr: Pointer, 1747 callback: heap.Ref<object> 1748 ): heap.Ref<boolean> => { 1749 try { 1750 const _ret = WEBEXT.accessibilityPrivate.onSelectToSpeakContextMenuClicked.removeListener( 1751 A.H.get<object>(callback) 1752 ); 1753 return A.H.TRUE; 1754 } catch (err: any) { 1755 A.store.Ref(errPtr, err); 1756 return A.H.FALSE; 1757 } 1758 }, 1759 "has_HasOnSelectToSpeakContextMenuClicked": (): heap.Ref<boolean> => { 1760 if ( 1761 WEBEXT?.accessibilityPrivate?.onSelectToSpeakContextMenuClicked && 1762 "hasListener" in WEBEXT?.accessibilityPrivate?.onSelectToSpeakContextMenuClicked 1763 ) { 1764 return A.H.TRUE; 1765 } 1766 return A.H.FALSE; 1767 }, 1768 "func_HasOnSelectToSpeakContextMenuClicked": (fn: Pointer): void => { 1769 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onSelectToSpeakContextMenuClicked.hasListener); 1770 }, 1771 "call_HasOnSelectToSpeakContextMenuClicked": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1772 const _ret = WEBEXT.accessibilityPrivate.onSelectToSpeakContextMenuClicked.hasListener(A.H.get<object>(callback)); 1773 A.store.Bool(retPtr, _ret); 1774 }, 1775 "try_HasOnSelectToSpeakContextMenuClicked": ( 1776 retPtr: Pointer, 1777 errPtr: Pointer, 1778 callback: heap.Ref<object> 1779 ): heap.Ref<boolean> => { 1780 try { 1781 const _ret = WEBEXT.accessibilityPrivate.onSelectToSpeakContextMenuClicked.hasListener( 1782 A.H.get<object>(callback) 1783 ); 1784 A.store.Bool(retPtr, _ret); 1785 return A.H.TRUE; 1786 } catch (err: any) { 1787 A.store.Ref(errPtr, err); 1788 return A.H.FALSE; 1789 } 1790 }, 1791 "has_OnSelectToSpeakKeysPressedChanged": (): heap.Ref<boolean> => { 1792 if ( 1793 WEBEXT?.accessibilityPrivate?.onSelectToSpeakKeysPressedChanged && 1794 "addListener" in WEBEXT?.accessibilityPrivate?.onSelectToSpeakKeysPressedChanged 1795 ) { 1796 return A.H.TRUE; 1797 } 1798 return A.H.FALSE; 1799 }, 1800 "func_OnSelectToSpeakKeysPressedChanged": (fn: Pointer): void => { 1801 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onSelectToSpeakKeysPressedChanged.addListener); 1802 }, 1803 "call_OnSelectToSpeakKeysPressedChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1804 const _ret = WEBEXT.accessibilityPrivate.onSelectToSpeakKeysPressedChanged.addListener(A.H.get<object>(callback)); 1805 }, 1806 "try_OnSelectToSpeakKeysPressedChanged": ( 1807 retPtr: Pointer, 1808 errPtr: Pointer, 1809 callback: heap.Ref<object> 1810 ): heap.Ref<boolean> => { 1811 try { 1812 const _ret = WEBEXT.accessibilityPrivate.onSelectToSpeakKeysPressedChanged.addListener( 1813 A.H.get<object>(callback) 1814 ); 1815 return A.H.TRUE; 1816 } catch (err: any) { 1817 A.store.Ref(errPtr, err); 1818 return A.H.FALSE; 1819 } 1820 }, 1821 "has_OffSelectToSpeakKeysPressedChanged": (): heap.Ref<boolean> => { 1822 if ( 1823 WEBEXT?.accessibilityPrivate?.onSelectToSpeakKeysPressedChanged && 1824 "removeListener" in WEBEXT?.accessibilityPrivate?.onSelectToSpeakKeysPressedChanged 1825 ) { 1826 return A.H.TRUE; 1827 } 1828 return A.H.FALSE; 1829 }, 1830 "func_OffSelectToSpeakKeysPressedChanged": (fn: Pointer): void => { 1831 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onSelectToSpeakKeysPressedChanged.removeListener); 1832 }, 1833 "call_OffSelectToSpeakKeysPressedChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1834 const _ret = WEBEXT.accessibilityPrivate.onSelectToSpeakKeysPressedChanged.removeListener( 1835 A.H.get<object>(callback) 1836 ); 1837 }, 1838 "try_OffSelectToSpeakKeysPressedChanged": ( 1839 retPtr: Pointer, 1840 errPtr: Pointer, 1841 callback: heap.Ref<object> 1842 ): heap.Ref<boolean> => { 1843 try { 1844 const _ret = WEBEXT.accessibilityPrivate.onSelectToSpeakKeysPressedChanged.removeListener( 1845 A.H.get<object>(callback) 1846 ); 1847 return A.H.TRUE; 1848 } catch (err: any) { 1849 A.store.Ref(errPtr, err); 1850 return A.H.FALSE; 1851 } 1852 }, 1853 "has_HasOnSelectToSpeakKeysPressedChanged": (): heap.Ref<boolean> => { 1854 if ( 1855 WEBEXT?.accessibilityPrivate?.onSelectToSpeakKeysPressedChanged && 1856 "hasListener" in WEBEXT?.accessibilityPrivate?.onSelectToSpeakKeysPressedChanged 1857 ) { 1858 return A.H.TRUE; 1859 } 1860 return A.H.FALSE; 1861 }, 1862 "func_HasOnSelectToSpeakKeysPressedChanged": (fn: Pointer): void => { 1863 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onSelectToSpeakKeysPressedChanged.hasListener); 1864 }, 1865 "call_HasOnSelectToSpeakKeysPressedChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1866 const _ret = WEBEXT.accessibilityPrivate.onSelectToSpeakKeysPressedChanged.hasListener(A.H.get<object>(callback)); 1867 A.store.Bool(retPtr, _ret); 1868 }, 1869 "try_HasOnSelectToSpeakKeysPressedChanged": ( 1870 retPtr: Pointer, 1871 errPtr: Pointer, 1872 callback: heap.Ref<object> 1873 ): heap.Ref<boolean> => { 1874 try { 1875 const _ret = WEBEXT.accessibilityPrivate.onSelectToSpeakKeysPressedChanged.hasListener( 1876 A.H.get<object>(callback) 1877 ); 1878 A.store.Bool(retPtr, _ret); 1879 return A.H.TRUE; 1880 } catch (err: any) { 1881 A.store.Ref(errPtr, err); 1882 return A.H.FALSE; 1883 } 1884 }, 1885 "has_OnSelectToSpeakMouseChanged": (): heap.Ref<boolean> => { 1886 if ( 1887 WEBEXT?.accessibilityPrivate?.onSelectToSpeakMouseChanged && 1888 "addListener" in WEBEXT?.accessibilityPrivate?.onSelectToSpeakMouseChanged 1889 ) { 1890 return A.H.TRUE; 1891 } 1892 return A.H.FALSE; 1893 }, 1894 "func_OnSelectToSpeakMouseChanged": (fn: Pointer): void => { 1895 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onSelectToSpeakMouseChanged.addListener); 1896 }, 1897 "call_OnSelectToSpeakMouseChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1898 const _ret = WEBEXT.accessibilityPrivate.onSelectToSpeakMouseChanged.addListener(A.H.get<object>(callback)); 1899 }, 1900 "try_OnSelectToSpeakMouseChanged": ( 1901 retPtr: Pointer, 1902 errPtr: Pointer, 1903 callback: heap.Ref<object> 1904 ): heap.Ref<boolean> => { 1905 try { 1906 const _ret = WEBEXT.accessibilityPrivate.onSelectToSpeakMouseChanged.addListener(A.H.get<object>(callback)); 1907 return A.H.TRUE; 1908 } catch (err: any) { 1909 A.store.Ref(errPtr, err); 1910 return A.H.FALSE; 1911 } 1912 }, 1913 "has_OffSelectToSpeakMouseChanged": (): heap.Ref<boolean> => { 1914 if ( 1915 WEBEXT?.accessibilityPrivate?.onSelectToSpeakMouseChanged && 1916 "removeListener" in WEBEXT?.accessibilityPrivate?.onSelectToSpeakMouseChanged 1917 ) { 1918 return A.H.TRUE; 1919 } 1920 return A.H.FALSE; 1921 }, 1922 "func_OffSelectToSpeakMouseChanged": (fn: Pointer): void => { 1923 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onSelectToSpeakMouseChanged.removeListener); 1924 }, 1925 "call_OffSelectToSpeakMouseChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1926 const _ret = WEBEXT.accessibilityPrivate.onSelectToSpeakMouseChanged.removeListener(A.H.get<object>(callback)); 1927 }, 1928 "try_OffSelectToSpeakMouseChanged": ( 1929 retPtr: Pointer, 1930 errPtr: Pointer, 1931 callback: heap.Ref<object> 1932 ): heap.Ref<boolean> => { 1933 try { 1934 const _ret = WEBEXT.accessibilityPrivate.onSelectToSpeakMouseChanged.removeListener(A.H.get<object>(callback)); 1935 return A.H.TRUE; 1936 } catch (err: any) { 1937 A.store.Ref(errPtr, err); 1938 return A.H.FALSE; 1939 } 1940 }, 1941 "has_HasOnSelectToSpeakMouseChanged": (): heap.Ref<boolean> => { 1942 if ( 1943 WEBEXT?.accessibilityPrivate?.onSelectToSpeakMouseChanged && 1944 "hasListener" in WEBEXT?.accessibilityPrivate?.onSelectToSpeakMouseChanged 1945 ) { 1946 return A.H.TRUE; 1947 } 1948 return A.H.FALSE; 1949 }, 1950 "func_HasOnSelectToSpeakMouseChanged": (fn: Pointer): void => { 1951 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onSelectToSpeakMouseChanged.hasListener); 1952 }, 1953 "call_HasOnSelectToSpeakMouseChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1954 const _ret = WEBEXT.accessibilityPrivate.onSelectToSpeakMouseChanged.hasListener(A.H.get<object>(callback)); 1955 A.store.Bool(retPtr, _ret); 1956 }, 1957 "try_HasOnSelectToSpeakMouseChanged": ( 1958 retPtr: Pointer, 1959 errPtr: Pointer, 1960 callback: heap.Ref<object> 1961 ): heap.Ref<boolean> => { 1962 try { 1963 const _ret = WEBEXT.accessibilityPrivate.onSelectToSpeakMouseChanged.hasListener(A.H.get<object>(callback)); 1964 A.store.Bool(retPtr, _ret); 1965 return A.H.TRUE; 1966 } catch (err: any) { 1967 A.store.Ref(errPtr, err); 1968 return A.H.FALSE; 1969 } 1970 }, 1971 "has_OnSelectToSpeakPanelAction": (): heap.Ref<boolean> => { 1972 if ( 1973 WEBEXT?.accessibilityPrivate?.onSelectToSpeakPanelAction && 1974 "addListener" in WEBEXT?.accessibilityPrivate?.onSelectToSpeakPanelAction 1975 ) { 1976 return A.H.TRUE; 1977 } 1978 return A.H.FALSE; 1979 }, 1980 "func_OnSelectToSpeakPanelAction": (fn: Pointer): void => { 1981 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onSelectToSpeakPanelAction.addListener); 1982 }, 1983 "call_OnSelectToSpeakPanelAction": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1984 const _ret = WEBEXT.accessibilityPrivate.onSelectToSpeakPanelAction.addListener(A.H.get<object>(callback)); 1985 }, 1986 "try_OnSelectToSpeakPanelAction": ( 1987 retPtr: Pointer, 1988 errPtr: Pointer, 1989 callback: heap.Ref<object> 1990 ): heap.Ref<boolean> => { 1991 try { 1992 const _ret = WEBEXT.accessibilityPrivate.onSelectToSpeakPanelAction.addListener(A.H.get<object>(callback)); 1993 return A.H.TRUE; 1994 } catch (err: any) { 1995 A.store.Ref(errPtr, err); 1996 return A.H.FALSE; 1997 } 1998 }, 1999 "has_OffSelectToSpeakPanelAction": (): heap.Ref<boolean> => { 2000 if ( 2001 WEBEXT?.accessibilityPrivate?.onSelectToSpeakPanelAction && 2002 "removeListener" in WEBEXT?.accessibilityPrivate?.onSelectToSpeakPanelAction 2003 ) { 2004 return A.H.TRUE; 2005 } 2006 return A.H.FALSE; 2007 }, 2008 "func_OffSelectToSpeakPanelAction": (fn: Pointer): void => { 2009 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onSelectToSpeakPanelAction.removeListener); 2010 }, 2011 "call_OffSelectToSpeakPanelAction": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2012 const _ret = WEBEXT.accessibilityPrivate.onSelectToSpeakPanelAction.removeListener(A.H.get<object>(callback)); 2013 }, 2014 "try_OffSelectToSpeakPanelAction": ( 2015 retPtr: Pointer, 2016 errPtr: Pointer, 2017 callback: heap.Ref<object> 2018 ): heap.Ref<boolean> => { 2019 try { 2020 const _ret = WEBEXT.accessibilityPrivate.onSelectToSpeakPanelAction.removeListener(A.H.get<object>(callback)); 2021 return A.H.TRUE; 2022 } catch (err: any) { 2023 A.store.Ref(errPtr, err); 2024 return A.H.FALSE; 2025 } 2026 }, 2027 "has_HasOnSelectToSpeakPanelAction": (): heap.Ref<boolean> => { 2028 if ( 2029 WEBEXT?.accessibilityPrivate?.onSelectToSpeakPanelAction && 2030 "hasListener" in WEBEXT?.accessibilityPrivate?.onSelectToSpeakPanelAction 2031 ) { 2032 return A.H.TRUE; 2033 } 2034 return A.H.FALSE; 2035 }, 2036 "func_HasOnSelectToSpeakPanelAction": (fn: Pointer): void => { 2037 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onSelectToSpeakPanelAction.hasListener); 2038 }, 2039 "call_HasOnSelectToSpeakPanelAction": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2040 const _ret = WEBEXT.accessibilityPrivate.onSelectToSpeakPanelAction.hasListener(A.H.get<object>(callback)); 2041 A.store.Bool(retPtr, _ret); 2042 }, 2043 "try_HasOnSelectToSpeakPanelAction": ( 2044 retPtr: Pointer, 2045 errPtr: Pointer, 2046 callback: heap.Ref<object> 2047 ): heap.Ref<boolean> => { 2048 try { 2049 const _ret = WEBEXT.accessibilityPrivate.onSelectToSpeakPanelAction.hasListener(A.H.get<object>(callback)); 2050 A.store.Bool(retPtr, _ret); 2051 return A.H.TRUE; 2052 } catch (err: any) { 2053 A.store.Ref(errPtr, err); 2054 return A.H.FALSE; 2055 } 2056 }, 2057 "has_OnSelectToSpeakStateChangeRequested": (): heap.Ref<boolean> => { 2058 if ( 2059 WEBEXT?.accessibilityPrivate?.onSelectToSpeakStateChangeRequested && 2060 "addListener" in WEBEXT?.accessibilityPrivate?.onSelectToSpeakStateChangeRequested 2061 ) { 2062 return A.H.TRUE; 2063 } 2064 return A.H.FALSE; 2065 }, 2066 "func_OnSelectToSpeakStateChangeRequested": (fn: Pointer): void => { 2067 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onSelectToSpeakStateChangeRequested.addListener); 2068 }, 2069 "call_OnSelectToSpeakStateChangeRequested": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2070 const _ret = WEBEXT.accessibilityPrivate.onSelectToSpeakStateChangeRequested.addListener( 2071 A.H.get<object>(callback) 2072 ); 2073 }, 2074 "try_OnSelectToSpeakStateChangeRequested": ( 2075 retPtr: Pointer, 2076 errPtr: Pointer, 2077 callback: heap.Ref<object> 2078 ): heap.Ref<boolean> => { 2079 try { 2080 const _ret = WEBEXT.accessibilityPrivate.onSelectToSpeakStateChangeRequested.addListener( 2081 A.H.get<object>(callback) 2082 ); 2083 return A.H.TRUE; 2084 } catch (err: any) { 2085 A.store.Ref(errPtr, err); 2086 return A.H.FALSE; 2087 } 2088 }, 2089 "has_OffSelectToSpeakStateChangeRequested": (): heap.Ref<boolean> => { 2090 if ( 2091 WEBEXT?.accessibilityPrivate?.onSelectToSpeakStateChangeRequested && 2092 "removeListener" in WEBEXT?.accessibilityPrivate?.onSelectToSpeakStateChangeRequested 2093 ) { 2094 return A.H.TRUE; 2095 } 2096 return A.H.FALSE; 2097 }, 2098 "func_OffSelectToSpeakStateChangeRequested": (fn: Pointer): void => { 2099 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onSelectToSpeakStateChangeRequested.removeListener); 2100 }, 2101 "call_OffSelectToSpeakStateChangeRequested": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2102 const _ret = WEBEXT.accessibilityPrivate.onSelectToSpeakStateChangeRequested.removeListener( 2103 A.H.get<object>(callback) 2104 ); 2105 }, 2106 "try_OffSelectToSpeakStateChangeRequested": ( 2107 retPtr: Pointer, 2108 errPtr: Pointer, 2109 callback: heap.Ref<object> 2110 ): heap.Ref<boolean> => { 2111 try { 2112 const _ret = WEBEXT.accessibilityPrivate.onSelectToSpeakStateChangeRequested.removeListener( 2113 A.H.get<object>(callback) 2114 ); 2115 return A.H.TRUE; 2116 } catch (err: any) { 2117 A.store.Ref(errPtr, err); 2118 return A.H.FALSE; 2119 } 2120 }, 2121 "has_HasOnSelectToSpeakStateChangeRequested": (): heap.Ref<boolean> => { 2122 if ( 2123 WEBEXT?.accessibilityPrivate?.onSelectToSpeakStateChangeRequested && 2124 "hasListener" in WEBEXT?.accessibilityPrivate?.onSelectToSpeakStateChangeRequested 2125 ) { 2126 return A.H.TRUE; 2127 } 2128 return A.H.FALSE; 2129 }, 2130 "func_HasOnSelectToSpeakStateChangeRequested": (fn: Pointer): void => { 2131 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onSelectToSpeakStateChangeRequested.hasListener); 2132 }, 2133 "call_HasOnSelectToSpeakStateChangeRequested": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2134 const _ret = WEBEXT.accessibilityPrivate.onSelectToSpeakStateChangeRequested.hasListener( 2135 A.H.get<object>(callback) 2136 ); 2137 A.store.Bool(retPtr, _ret); 2138 }, 2139 "try_HasOnSelectToSpeakStateChangeRequested": ( 2140 retPtr: Pointer, 2141 errPtr: Pointer, 2142 callback: heap.Ref<object> 2143 ): heap.Ref<boolean> => { 2144 try { 2145 const _ret = WEBEXT.accessibilityPrivate.onSelectToSpeakStateChangeRequested.hasListener( 2146 A.H.get<object>(callback) 2147 ); 2148 A.store.Bool(retPtr, _ret); 2149 return A.H.TRUE; 2150 } catch (err: any) { 2151 A.store.Ref(errPtr, err); 2152 return A.H.FALSE; 2153 } 2154 }, 2155 "has_OnShowChromeVoxTutorial": (): heap.Ref<boolean> => { 2156 if ( 2157 WEBEXT?.accessibilityPrivate?.onShowChromeVoxTutorial && 2158 "addListener" in WEBEXT?.accessibilityPrivate?.onShowChromeVoxTutorial 2159 ) { 2160 return A.H.TRUE; 2161 } 2162 return A.H.FALSE; 2163 }, 2164 "func_OnShowChromeVoxTutorial": (fn: Pointer): void => { 2165 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onShowChromeVoxTutorial.addListener); 2166 }, 2167 "call_OnShowChromeVoxTutorial": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2168 const _ret = WEBEXT.accessibilityPrivate.onShowChromeVoxTutorial.addListener(A.H.get<object>(callback)); 2169 }, 2170 "try_OnShowChromeVoxTutorial": ( 2171 retPtr: Pointer, 2172 errPtr: Pointer, 2173 callback: heap.Ref<object> 2174 ): heap.Ref<boolean> => { 2175 try { 2176 const _ret = WEBEXT.accessibilityPrivate.onShowChromeVoxTutorial.addListener(A.H.get<object>(callback)); 2177 return A.H.TRUE; 2178 } catch (err: any) { 2179 A.store.Ref(errPtr, err); 2180 return A.H.FALSE; 2181 } 2182 }, 2183 "has_OffShowChromeVoxTutorial": (): heap.Ref<boolean> => { 2184 if ( 2185 WEBEXT?.accessibilityPrivate?.onShowChromeVoxTutorial && 2186 "removeListener" in WEBEXT?.accessibilityPrivate?.onShowChromeVoxTutorial 2187 ) { 2188 return A.H.TRUE; 2189 } 2190 return A.H.FALSE; 2191 }, 2192 "func_OffShowChromeVoxTutorial": (fn: Pointer): void => { 2193 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onShowChromeVoxTutorial.removeListener); 2194 }, 2195 "call_OffShowChromeVoxTutorial": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2196 const _ret = WEBEXT.accessibilityPrivate.onShowChromeVoxTutorial.removeListener(A.H.get<object>(callback)); 2197 }, 2198 "try_OffShowChromeVoxTutorial": ( 2199 retPtr: Pointer, 2200 errPtr: Pointer, 2201 callback: heap.Ref<object> 2202 ): heap.Ref<boolean> => { 2203 try { 2204 const _ret = WEBEXT.accessibilityPrivate.onShowChromeVoxTutorial.removeListener(A.H.get<object>(callback)); 2205 return A.H.TRUE; 2206 } catch (err: any) { 2207 A.store.Ref(errPtr, err); 2208 return A.H.FALSE; 2209 } 2210 }, 2211 "has_HasOnShowChromeVoxTutorial": (): heap.Ref<boolean> => { 2212 if ( 2213 WEBEXT?.accessibilityPrivate?.onShowChromeVoxTutorial && 2214 "hasListener" in WEBEXT?.accessibilityPrivate?.onShowChromeVoxTutorial 2215 ) { 2216 return A.H.TRUE; 2217 } 2218 return A.H.FALSE; 2219 }, 2220 "func_HasOnShowChromeVoxTutorial": (fn: Pointer): void => { 2221 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onShowChromeVoxTutorial.hasListener); 2222 }, 2223 "call_HasOnShowChromeVoxTutorial": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2224 const _ret = WEBEXT.accessibilityPrivate.onShowChromeVoxTutorial.hasListener(A.H.get<object>(callback)); 2225 A.store.Bool(retPtr, _ret); 2226 }, 2227 "try_HasOnShowChromeVoxTutorial": ( 2228 retPtr: Pointer, 2229 errPtr: Pointer, 2230 callback: heap.Ref<object> 2231 ): heap.Ref<boolean> => { 2232 try { 2233 const _ret = WEBEXT.accessibilityPrivate.onShowChromeVoxTutorial.hasListener(A.H.get<object>(callback)); 2234 A.store.Bool(retPtr, _ret); 2235 return A.H.TRUE; 2236 } catch (err: any) { 2237 A.store.Ref(errPtr, err); 2238 return A.H.FALSE; 2239 } 2240 }, 2241 "has_OnSwitchAccessCommand": (): heap.Ref<boolean> => { 2242 if ( 2243 WEBEXT?.accessibilityPrivate?.onSwitchAccessCommand && 2244 "addListener" in WEBEXT?.accessibilityPrivate?.onSwitchAccessCommand 2245 ) { 2246 return A.H.TRUE; 2247 } 2248 return A.H.FALSE; 2249 }, 2250 "func_OnSwitchAccessCommand": (fn: Pointer): void => { 2251 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onSwitchAccessCommand.addListener); 2252 }, 2253 "call_OnSwitchAccessCommand": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2254 const _ret = WEBEXT.accessibilityPrivate.onSwitchAccessCommand.addListener(A.H.get<object>(callback)); 2255 }, 2256 "try_OnSwitchAccessCommand": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2257 try { 2258 const _ret = WEBEXT.accessibilityPrivate.onSwitchAccessCommand.addListener(A.H.get<object>(callback)); 2259 return A.H.TRUE; 2260 } catch (err: any) { 2261 A.store.Ref(errPtr, err); 2262 return A.H.FALSE; 2263 } 2264 }, 2265 "has_OffSwitchAccessCommand": (): heap.Ref<boolean> => { 2266 if ( 2267 WEBEXT?.accessibilityPrivate?.onSwitchAccessCommand && 2268 "removeListener" in WEBEXT?.accessibilityPrivate?.onSwitchAccessCommand 2269 ) { 2270 return A.H.TRUE; 2271 } 2272 return A.H.FALSE; 2273 }, 2274 "func_OffSwitchAccessCommand": (fn: Pointer): void => { 2275 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onSwitchAccessCommand.removeListener); 2276 }, 2277 "call_OffSwitchAccessCommand": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2278 const _ret = WEBEXT.accessibilityPrivate.onSwitchAccessCommand.removeListener(A.H.get<object>(callback)); 2279 }, 2280 "try_OffSwitchAccessCommand": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2281 try { 2282 const _ret = WEBEXT.accessibilityPrivate.onSwitchAccessCommand.removeListener(A.H.get<object>(callback)); 2283 return A.H.TRUE; 2284 } catch (err: any) { 2285 A.store.Ref(errPtr, err); 2286 return A.H.FALSE; 2287 } 2288 }, 2289 "has_HasOnSwitchAccessCommand": (): heap.Ref<boolean> => { 2290 if ( 2291 WEBEXT?.accessibilityPrivate?.onSwitchAccessCommand && 2292 "hasListener" in WEBEXT?.accessibilityPrivate?.onSwitchAccessCommand 2293 ) { 2294 return A.H.TRUE; 2295 } 2296 return A.H.FALSE; 2297 }, 2298 "func_HasOnSwitchAccessCommand": (fn: Pointer): void => { 2299 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onSwitchAccessCommand.hasListener); 2300 }, 2301 "call_HasOnSwitchAccessCommand": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2302 const _ret = WEBEXT.accessibilityPrivate.onSwitchAccessCommand.hasListener(A.H.get<object>(callback)); 2303 A.store.Bool(retPtr, _ret); 2304 }, 2305 "try_HasOnSwitchAccessCommand": ( 2306 retPtr: Pointer, 2307 errPtr: Pointer, 2308 callback: heap.Ref<object> 2309 ): heap.Ref<boolean> => { 2310 try { 2311 const _ret = WEBEXT.accessibilityPrivate.onSwitchAccessCommand.hasListener(A.H.get<object>(callback)); 2312 A.store.Bool(retPtr, _ret); 2313 return A.H.TRUE; 2314 } catch (err: any) { 2315 A.store.Ref(errPtr, err); 2316 return A.H.FALSE; 2317 } 2318 }, 2319 "has_OnToggleDictation": (): heap.Ref<boolean> => { 2320 if ( 2321 WEBEXT?.accessibilityPrivate?.onToggleDictation && 2322 "addListener" in WEBEXT?.accessibilityPrivate?.onToggleDictation 2323 ) { 2324 return A.H.TRUE; 2325 } 2326 return A.H.FALSE; 2327 }, 2328 "func_OnToggleDictation": (fn: Pointer): void => { 2329 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onToggleDictation.addListener); 2330 }, 2331 "call_OnToggleDictation": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2332 const _ret = WEBEXT.accessibilityPrivate.onToggleDictation.addListener(A.H.get<object>(callback)); 2333 }, 2334 "try_OnToggleDictation": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2335 try { 2336 const _ret = WEBEXT.accessibilityPrivate.onToggleDictation.addListener(A.H.get<object>(callback)); 2337 return A.H.TRUE; 2338 } catch (err: any) { 2339 A.store.Ref(errPtr, err); 2340 return A.H.FALSE; 2341 } 2342 }, 2343 "has_OffToggleDictation": (): heap.Ref<boolean> => { 2344 if ( 2345 WEBEXT?.accessibilityPrivate?.onToggleDictation && 2346 "removeListener" in WEBEXT?.accessibilityPrivate?.onToggleDictation 2347 ) { 2348 return A.H.TRUE; 2349 } 2350 return A.H.FALSE; 2351 }, 2352 "func_OffToggleDictation": (fn: Pointer): void => { 2353 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onToggleDictation.removeListener); 2354 }, 2355 "call_OffToggleDictation": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2356 const _ret = WEBEXT.accessibilityPrivate.onToggleDictation.removeListener(A.H.get<object>(callback)); 2357 }, 2358 "try_OffToggleDictation": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2359 try { 2360 const _ret = WEBEXT.accessibilityPrivate.onToggleDictation.removeListener(A.H.get<object>(callback)); 2361 return A.H.TRUE; 2362 } catch (err: any) { 2363 A.store.Ref(errPtr, err); 2364 return A.H.FALSE; 2365 } 2366 }, 2367 "has_HasOnToggleDictation": (): heap.Ref<boolean> => { 2368 if ( 2369 WEBEXT?.accessibilityPrivate?.onToggleDictation && 2370 "hasListener" in WEBEXT?.accessibilityPrivate?.onToggleDictation 2371 ) { 2372 return A.H.TRUE; 2373 } 2374 return A.H.FALSE; 2375 }, 2376 "func_HasOnToggleDictation": (fn: Pointer): void => { 2377 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onToggleDictation.hasListener); 2378 }, 2379 "call_HasOnToggleDictation": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2380 const _ret = WEBEXT.accessibilityPrivate.onToggleDictation.hasListener(A.H.get<object>(callback)); 2381 A.store.Bool(retPtr, _ret); 2382 }, 2383 "try_HasOnToggleDictation": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2384 try { 2385 const _ret = WEBEXT.accessibilityPrivate.onToggleDictation.hasListener(A.H.get<object>(callback)); 2386 A.store.Bool(retPtr, _ret); 2387 return A.H.TRUE; 2388 } catch (err: any) { 2389 A.store.Ref(errPtr, err); 2390 return A.H.FALSE; 2391 } 2392 }, 2393 "has_OnTwoFingerTouchStart": (): heap.Ref<boolean> => { 2394 if ( 2395 WEBEXT?.accessibilityPrivate?.onTwoFingerTouchStart && 2396 "addListener" in WEBEXT?.accessibilityPrivate?.onTwoFingerTouchStart 2397 ) { 2398 return A.H.TRUE; 2399 } 2400 return A.H.FALSE; 2401 }, 2402 "func_OnTwoFingerTouchStart": (fn: Pointer): void => { 2403 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onTwoFingerTouchStart.addListener); 2404 }, 2405 "call_OnTwoFingerTouchStart": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2406 const _ret = WEBEXT.accessibilityPrivate.onTwoFingerTouchStart.addListener(A.H.get<object>(callback)); 2407 }, 2408 "try_OnTwoFingerTouchStart": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2409 try { 2410 const _ret = WEBEXT.accessibilityPrivate.onTwoFingerTouchStart.addListener(A.H.get<object>(callback)); 2411 return A.H.TRUE; 2412 } catch (err: any) { 2413 A.store.Ref(errPtr, err); 2414 return A.H.FALSE; 2415 } 2416 }, 2417 "has_OffTwoFingerTouchStart": (): heap.Ref<boolean> => { 2418 if ( 2419 WEBEXT?.accessibilityPrivate?.onTwoFingerTouchStart && 2420 "removeListener" in WEBEXT?.accessibilityPrivate?.onTwoFingerTouchStart 2421 ) { 2422 return A.H.TRUE; 2423 } 2424 return A.H.FALSE; 2425 }, 2426 "func_OffTwoFingerTouchStart": (fn: Pointer): void => { 2427 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onTwoFingerTouchStart.removeListener); 2428 }, 2429 "call_OffTwoFingerTouchStart": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2430 const _ret = WEBEXT.accessibilityPrivate.onTwoFingerTouchStart.removeListener(A.H.get<object>(callback)); 2431 }, 2432 "try_OffTwoFingerTouchStart": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2433 try { 2434 const _ret = WEBEXT.accessibilityPrivate.onTwoFingerTouchStart.removeListener(A.H.get<object>(callback)); 2435 return A.H.TRUE; 2436 } catch (err: any) { 2437 A.store.Ref(errPtr, err); 2438 return A.H.FALSE; 2439 } 2440 }, 2441 "has_HasOnTwoFingerTouchStart": (): heap.Ref<boolean> => { 2442 if ( 2443 WEBEXT?.accessibilityPrivate?.onTwoFingerTouchStart && 2444 "hasListener" in WEBEXT?.accessibilityPrivate?.onTwoFingerTouchStart 2445 ) { 2446 return A.H.TRUE; 2447 } 2448 return A.H.FALSE; 2449 }, 2450 "func_HasOnTwoFingerTouchStart": (fn: Pointer): void => { 2451 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onTwoFingerTouchStart.hasListener); 2452 }, 2453 "call_HasOnTwoFingerTouchStart": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2454 const _ret = WEBEXT.accessibilityPrivate.onTwoFingerTouchStart.hasListener(A.H.get<object>(callback)); 2455 A.store.Bool(retPtr, _ret); 2456 }, 2457 "try_HasOnTwoFingerTouchStart": ( 2458 retPtr: Pointer, 2459 errPtr: Pointer, 2460 callback: heap.Ref<object> 2461 ): heap.Ref<boolean> => { 2462 try { 2463 const _ret = WEBEXT.accessibilityPrivate.onTwoFingerTouchStart.hasListener(A.H.get<object>(callback)); 2464 A.store.Bool(retPtr, _ret); 2465 return A.H.TRUE; 2466 } catch (err: any) { 2467 A.store.Ref(errPtr, err); 2468 return A.H.FALSE; 2469 } 2470 }, 2471 "has_OnTwoFingerTouchStop": (): heap.Ref<boolean> => { 2472 if ( 2473 WEBEXT?.accessibilityPrivate?.onTwoFingerTouchStop && 2474 "addListener" in WEBEXT?.accessibilityPrivate?.onTwoFingerTouchStop 2475 ) { 2476 return A.H.TRUE; 2477 } 2478 return A.H.FALSE; 2479 }, 2480 "func_OnTwoFingerTouchStop": (fn: Pointer): void => { 2481 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onTwoFingerTouchStop.addListener); 2482 }, 2483 "call_OnTwoFingerTouchStop": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2484 const _ret = WEBEXT.accessibilityPrivate.onTwoFingerTouchStop.addListener(A.H.get<object>(callback)); 2485 }, 2486 "try_OnTwoFingerTouchStop": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2487 try { 2488 const _ret = WEBEXT.accessibilityPrivate.onTwoFingerTouchStop.addListener(A.H.get<object>(callback)); 2489 return A.H.TRUE; 2490 } catch (err: any) { 2491 A.store.Ref(errPtr, err); 2492 return A.H.FALSE; 2493 } 2494 }, 2495 "has_OffTwoFingerTouchStop": (): heap.Ref<boolean> => { 2496 if ( 2497 WEBEXT?.accessibilityPrivate?.onTwoFingerTouchStop && 2498 "removeListener" in WEBEXT?.accessibilityPrivate?.onTwoFingerTouchStop 2499 ) { 2500 return A.H.TRUE; 2501 } 2502 return A.H.FALSE; 2503 }, 2504 "func_OffTwoFingerTouchStop": (fn: Pointer): void => { 2505 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onTwoFingerTouchStop.removeListener); 2506 }, 2507 "call_OffTwoFingerTouchStop": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2508 const _ret = WEBEXT.accessibilityPrivate.onTwoFingerTouchStop.removeListener(A.H.get<object>(callback)); 2509 }, 2510 "try_OffTwoFingerTouchStop": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2511 try { 2512 const _ret = WEBEXT.accessibilityPrivate.onTwoFingerTouchStop.removeListener(A.H.get<object>(callback)); 2513 return A.H.TRUE; 2514 } catch (err: any) { 2515 A.store.Ref(errPtr, err); 2516 return A.H.FALSE; 2517 } 2518 }, 2519 "has_HasOnTwoFingerTouchStop": (): heap.Ref<boolean> => { 2520 if ( 2521 WEBEXT?.accessibilityPrivate?.onTwoFingerTouchStop && 2522 "hasListener" in WEBEXT?.accessibilityPrivate?.onTwoFingerTouchStop 2523 ) { 2524 return A.H.TRUE; 2525 } 2526 return A.H.FALSE; 2527 }, 2528 "func_HasOnTwoFingerTouchStop": (fn: Pointer): void => { 2529 A.store.Ref(fn, WEBEXT.accessibilityPrivate.onTwoFingerTouchStop.hasListener); 2530 }, 2531 "call_HasOnTwoFingerTouchStop": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2532 const _ret = WEBEXT.accessibilityPrivate.onTwoFingerTouchStop.hasListener(A.H.get<object>(callback)); 2533 A.store.Bool(retPtr, _ret); 2534 }, 2535 "try_HasOnTwoFingerTouchStop": ( 2536 retPtr: Pointer, 2537 errPtr: Pointer, 2538 callback: heap.Ref<object> 2539 ): heap.Ref<boolean> => { 2540 try { 2541 const _ret = WEBEXT.accessibilityPrivate.onTwoFingerTouchStop.hasListener(A.H.get<object>(callback)); 2542 A.store.Bool(retPtr, _ret); 2543 return A.H.TRUE; 2544 } catch (err: any) { 2545 A.store.Ref(errPtr, err); 2546 return A.H.FALSE; 2547 } 2548 }, 2549 "has_OpenSettingsSubpage": (): heap.Ref<boolean> => { 2550 if (WEBEXT?.accessibilityPrivate && "openSettingsSubpage" in WEBEXT?.accessibilityPrivate) { 2551 return A.H.TRUE; 2552 } 2553 return A.H.FALSE; 2554 }, 2555 "func_OpenSettingsSubpage": (fn: Pointer): void => { 2556 A.store.Ref(fn, WEBEXT.accessibilityPrivate.openSettingsSubpage); 2557 }, 2558 "call_OpenSettingsSubpage": (retPtr: Pointer, subpage: heap.Ref<object>): void => { 2559 const _ret = WEBEXT.accessibilityPrivate.openSettingsSubpage(A.H.get<object>(subpage)); 2560 }, 2561 "try_OpenSettingsSubpage": (retPtr: Pointer, errPtr: Pointer, subpage: heap.Ref<object>): heap.Ref<boolean> => { 2562 try { 2563 const _ret = WEBEXT.accessibilityPrivate.openSettingsSubpage(A.H.get<object>(subpage)); 2564 return A.H.TRUE; 2565 } catch (err: any) { 2566 A.store.Ref(errPtr, err); 2567 return A.H.FALSE; 2568 } 2569 }, 2570 "has_PerformAcceleratorAction": (): heap.Ref<boolean> => { 2571 if (WEBEXT?.accessibilityPrivate && "performAcceleratorAction" in WEBEXT?.accessibilityPrivate) { 2572 return A.H.TRUE; 2573 } 2574 return A.H.FALSE; 2575 }, 2576 "func_PerformAcceleratorAction": (fn: Pointer): void => { 2577 A.store.Ref(fn, WEBEXT.accessibilityPrivate.performAcceleratorAction); 2578 }, 2579 "call_PerformAcceleratorAction": (retPtr: Pointer, acceleratorAction: number): void => { 2580 const _ret = WEBEXT.accessibilityPrivate.performAcceleratorAction( 2581 acceleratorAction > 0 && acceleratorAction <= 2 2582 ? ["focusPreviousPane", "focusNextPane"][acceleratorAction - 1] 2583 : undefined 2584 ); 2585 }, 2586 "try_PerformAcceleratorAction": ( 2587 retPtr: Pointer, 2588 errPtr: Pointer, 2589 acceleratorAction: number 2590 ): heap.Ref<boolean> => { 2591 try { 2592 const _ret = WEBEXT.accessibilityPrivate.performAcceleratorAction( 2593 acceleratorAction > 0 && acceleratorAction <= 2 2594 ? ["focusPreviousPane", "focusNextPane"][acceleratorAction - 1] 2595 : undefined 2596 ); 2597 return A.H.TRUE; 2598 } catch (err: any) { 2599 A.store.Ref(errPtr, err); 2600 return A.H.FALSE; 2601 } 2602 }, 2603 "has_SendSyntheticKeyEvent": (): heap.Ref<boolean> => { 2604 if (WEBEXT?.accessibilityPrivate && "sendSyntheticKeyEvent" in WEBEXT?.accessibilityPrivate) { 2605 return A.H.TRUE; 2606 } 2607 return A.H.FALSE; 2608 }, 2609 "func_SendSyntheticKeyEvent": (fn: Pointer): void => { 2610 A.store.Ref(fn, WEBEXT.accessibilityPrivate.sendSyntheticKeyEvent); 2611 }, 2612 "call_SendSyntheticKeyEvent": (retPtr: Pointer, keyEvent: Pointer, useRewriters: heap.Ref<boolean>): void => { 2613 const keyEvent_ffi = {}; 2614 2615 keyEvent_ffi["keyCode"] = A.load.Int64(keyEvent + 0); 2616 if (A.load.Bool(keyEvent + 8 + 8)) { 2617 keyEvent_ffi["modifiers"] = {}; 2618 if (A.load.Bool(keyEvent + 8 + 4)) { 2619 keyEvent_ffi["modifiers"]["alt"] = A.load.Bool(keyEvent + 8 + 0); 2620 } 2621 if (A.load.Bool(keyEvent + 8 + 5)) { 2622 keyEvent_ffi["modifiers"]["ctrl"] = A.load.Bool(keyEvent + 8 + 1); 2623 } 2624 if (A.load.Bool(keyEvent + 8 + 6)) { 2625 keyEvent_ffi["modifiers"]["search"] = A.load.Bool(keyEvent + 8 + 2); 2626 } 2627 if (A.load.Bool(keyEvent + 8 + 7)) { 2628 keyEvent_ffi["modifiers"]["shift"] = A.load.Bool(keyEvent + 8 + 3); 2629 } 2630 } 2631 keyEvent_ffi["type"] = A.load.Enum(keyEvent + 20, ["keyup", "keydown"]); 2632 2633 const _ret = WEBEXT.accessibilityPrivate.sendSyntheticKeyEvent(keyEvent_ffi, useRewriters === A.H.TRUE); 2634 }, 2635 "try_SendSyntheticKeyEvent": ( 2636 retPtr: Pointer, 2637 errPtr: Pointer, 2638 keyEvent: Pointer, 2639 useRewriters: heap.Ref<boolean> 2640 ): heap.Ref<boolean> => { 2641 try { 2642 const keyEvent_ffi = {}; 2643 2644 keyEvent_ffi["keyCode"] = A.load.Int64(keyEvent + 0); 2645 if (A.load.Bool(keyEvent + 8 + 8)) { 2646 keyEvent_ffi["modifiers"] = {}; 2647 if (A.load.Bool(keyEvent + 8 + 4)) { 2648 keyEvent_ffi["modifiers"]["alt"] = A.load.Bool(keyEvent + 8 + 0); 2649 } 2650 if (A.load.Bool(keyEvent + 8 + 5)) { 2651 keyEvent_ffi["modifiers"]["ctrl"] = A.load.Bool(keyEvent + 8 + 1); 2652 } 2653 if (A.load.Bool(keyEvent + 8 + 6)) { 2654 keyEvent_ffi["modifiers"]["search"] = A.load.Bool(keyEvent + 8 + 2); 2655 } 2656 if (A.load.Bool(keyEvent + 8 + 7)) { 2657 keyEvent_ffi["modifiers"]["shift"] = A.load.Bool(keyEvent + 8 + 3); 2658 } 2659 } 2660 keyEvent_ffi["type"] = A.load.Enum(keyEvent + 20, ["keyup", "keydown"]); 2661 2662 const _ret = WEBEXT.accessibilityPrivate.sendSyntheticKeyEvent(keyEvent_ffi, useRewriters === A.H.TRUE); 2663 return A.H.TRUE; 2664 } catch (err: any) { 2665 A.store.Ref(errPtr, err); 2666 return A.H.FALSE; 2667 } 2668 }, 2669 "has_SendSyntheticMouseEvent": (): heap.Ref<boolean> => { 2670 if (WEBEXT?.accessibilityPrivate && "sendSyntheticMouseEvent" in WEBEXT?.accessibilityPrivate) { 2671 return A.H.TRUE; 2672 } 2673 return A.H.FALSE; 2674 }, 2675 "func_SendSyntheticMouseEvent": (fn: Pointer): void => { 2676 A.store.Ref(fn, WEBEXT.accessibilityPrivate.sendSyntheticMouseEvent); 2677 }, 2678 "call_SendSyntheticMouseEvent": (retPtr: Pointer, mouseEvent: Pointer): void => { 2679 const mouseEvent_ffi = {}; 2680 2681 mouseEvent_ffi["mouseButton"] = A.load.Enum(mouseEvent + 0, ["left", "middle", "right", "back", "foward"]); 2682 if (A.load.Bool(mouseEvent + 32)) { 2683 mouseEvent_ffi["touchAccessibility"] = A.load.Bool(mouseEvent + 4); 2684 } 2685 mouseEvent_ffi["type"] = A.load.Enum(mouseEvent + 8, ["press", "release", "drag", "move", "enter", "exit"]); 2686 mouseEvent_ffi["x"] = A.load.Int64(mouseEvent + 16); 2687 mouseEvent_ffi["y"] = A.load.Int64(mouseEvent + 24); 2688 2689 const _ret = WEBEXT.accessibilityPrivate.sendSyntheticMouseEvent(mouseEvent_ffi); 2690 }, 2691 "try_SendSyntheticMouseEvent": (retPtr: Pointer, errPtr: Pointer, mouseEvent: Pointer): heap.Ref<boolean> => { 2692 try { 2693 const mouseEvent_ffi = {}; 2694 2695 mouseEvent_ffi["mouseButton"] = A.load.Enum(mouseEvent + 0, ["left", "middle", "right", "back", "foward"]); 2696 if (A.load.Bool(mouseEvent + 32)) { 2697 mouseEvent_ffi["touchAccessibility"] = A.load.Bool(mouseEvent + 4); 2698 } 2699 mouseEvent_ffi["type"] = A.load.Enum(mouseEvent + 8, ["press", "release", "drag", "move", "enter", "exit"]); 2700 mouseEvent_ffi["x"] = A.load.Int64(mouseEvent + 16); 2701 mouseEvent_ffi["y"] = A.load.Int64(mouseEvent + 24); 2702 2703 const _ret = WEBEXT.accessibilityPrivate.sendSyntheticMouseEvent(mouseEvent_ffi); 2704 return A.H.TRUE; 2705 } catch (err: any) { 2706 A.store.Ref(errPtr, err); 2707 return A.H.FALSE; 2708 } 2709 }, 2710 "has_SetFocusRings": (): heap.Ref<boolean> => { 2711 if (WEBEXT?.accessibilityPrivate && "setFocusRings" in WEBEXT?.accessibilityPrivate) { 2712 return A.H.TRUE; 2713 } 2714 return A.H.FALSE; 2715 }, 2716 "func_SetFocusRings": (fn: Pointer): void => { 2717 A.store.Ref(fn, WEBEXT.accessibilityPrivate.setFocusRings); 2718 }, 2719 "call_SetFocusRings": (retPtr: Pointer, focusRings: heap.Ref<object>, atType: number): void => { 2720 const _ret = WEBEXT.accessibilityPrivate.setFocusRings( 2721 A.H.get<object>(focusRings), 2722 atType > 0 && atType <= 6 2723 ? ["chromeVox", "selectToSpeak", "switchAccess", "autoClick", "magnifier", "dictation"][atType - 1] 2724 : undefined 2725 ); 2726 }, 2727 "try_SetFocusRings": ( 2728 retPtr: Pointer, 2729 errPtr: Pointer, 2730 focusRings: heap.Ref<object>, 2731 atType: number 2732 ): heap.Ref<boolean> => { 2733 try { 2734 const _ret = WEBEXT.accessibilityPrivate.setFocusRings( 2735 A.H.get<object>(focusRings), 2736 atType > 0 && atType <= 6 2737 ? ["chromeVox", "selectToSpeak", "switchAccess", "autoClick", "magnifier", "dictation"][atType - 1] 2738 : undefined 2739 ); 2740 return A.H.TRUE; 2741 } catch (err: any) { 2742 A.store.Ref(errPtr, err); 2743 return A.H.FALSE; 2744 } 2745 }, 2746 "has_SetHighlights": (): heap.Ref<boolean> => { 2747 if (WEBEXT?.accessibilityPrivate && "setHighlights" in WEBEXT?.accessibilityPrivate) { 2748 return A.H.TRUE; 2749 } 2750 return A.H.FALSE; 2751 }, 2752 "func_SetHighlights": (fn: Pointer): void => { 2753 A.store.Ref(fn, WEBEXT.accessibilityPrivate.setHighlights); 2754 }, 2755 "call_SetHighlights": (retPtr: Pointer, rects: heap.Ref<object>, color: heap.Ref<object>): void => { 2756 const _ret = WEBEXT.accessibilityPrivate.setHighlights(A.H.get<object>(rects), A.H.get<object>(color)); 2757 }, 2758 "try_SetHighlights": ( 2759 retPtr: Pointer, 2760 errPtr: Pointer, 2761 rects: heap.Ref<object>, 2762 color: heap.Ref<object> 2763 ): heap.Ref<boolean> => { 2764 try { 2765 const _ret = WEBEXT.accessibilityPrivate.setHighlights(A.H.get<object>(rects), A.H.get<object>(color)); 2766 return A.H.TRUE; 2767 } catch (err: any) { 2768 A.store.Ref(errPtr, err); 2769 return A.H.FALSE; 2770 } 2771 }, 2772 "has_SetKeyboardListener": (): heap.Ref<boolean> => { 2773 if (WEBEXT?.accessibilityPrivate && "setKeyboardListener" in WEBEXT?.accessibilityPrivate) { 2774 return A.H.TRUE; 2775 } 2776 return A.H.FALSE; 2777 }, 2778 "func_SetKeyboardListener": (fn: Pointer): void => { 2779 A.store.Ref(fn, WEBEXT.accessibilityPrivate.setKeyboardListener); 2780 }, 2781 "call_SetKeyboardListener": (retPtr: Pointer, enabled: heap.Ref<boolean>, capture: heap.Ref<boolean>): void => { 2782 const _ret = WEBEXT.accessibilityPrivate.setKeyboardListener(enabled === A.H.TRUE, capture === A.H.TRUE); 2783 }, 2784 "try_SetKeyboardListener": ( 2785 retPtr: Pointer, 2786 errPtr: Pointer, 2787 enabled: heap.Ref<boolean>, 2788 capture: heap.Ref<boolean> 2789 ): heap.Ref<boolean> => { 2790 try { 2791 const _ret = WEBEXT.accessibilityPrivate.setKeyboardListener(enabled === A.H.TRUE, capture === A.H.TRUE); 2792 return A.H.TRUE; 2793 } catch (err: any) { 2794 A.store.Ref(errPtr, err); 2795 return A.H.FALSE; 2796 } 2797 }, 2798 "has_SetNativeAccessibilityEnabled": (): heap.Ref<boolean> => { 2799 if (WEBEXT?.accessibilityPrivate && "setNativeAccessibilityEnabled" in WEBEXT?.accessibilityPrivate) { 2800 return A.H.TRUE; 2801 } 2802 return A.H.FALSE; 2803 }, 2804 "func_SetNativeAccessibilityEnabled": (fn: Pointer): void => { 2805 A.store.Ref(fn, WEBEXT.accessibilityPrivate.setNativeAccessibilityEnabled); 2806 }, 2807 "call_SetNativeAccessibilityEnabled": (retPtr: Pointer, enabled: heap.Ref<boolean>): void => { 2808 const _ret = WEBEXT.accessibilityPrivate.setNativeAccessibilityEnabled(enabled === A.H.TRUE); 2809 }, 2810 "try_SetNativeAccessibilityEnabled": ( 2811 retPtr: Pointer, 2812 errPtr: Pointer, 2813 enabled: heap.Ref<boolean> 2814 ): heap.Ref<boolean> => { 2815 try { 2816 const _ret = WEBEXT.accessibilityPrivate.setNativeAccessibilityEnabled(enabled === A.H.TRUE); 2817 return A.H.TRUE; 2818 } catch (err: any) { 2819 A.store.Ref(errPtr, err); 2820 return A.H.FALSE; 2821 } 2822 }, 2823 "has_SetNativeChromeVoxArcSupportForCurrentApp": (): heap.Ref<boolean> => { 2824 if (WEBEXT?.accessibilityPrivate && "setNativeChromeVoxArcSupportForCurrentApp" in WEBEXT?.accessibilityPrivate) { 2825 return A.H.TRUE; 2826 } 2827 return A.H.FALSE; 2828 }, 2829 "func_SetNativeChromeVoxArcSupportForCurrentApp": (fn: Pointer): void => { 2830 A.store.Ref(fn, WEBEXT.accessibilityPrivate.setNativeChromeVoxArcSupportForCurrentApp); 2831 }, 2832 "call_SetNativeChromeVoxArcSupportForCurrentApp": (retPtr: Pointer, enabled: heap.Ref<boolean>): void => { 2833 const _ret = WEBEXT.accessibilityPrivate.setNativeChromeVoxArcSupportForCurrentApp(enabled === A.H.TRUE); 2834 A.store.Ref(retPtr, _ret); 2835 }, 2836 "try_SetNativeChromeVoxArcSupportForCurrentApp": ( 2837 retPtr: Pointer, 2838 errPtr: Pointer, 2839 enabled: heap.Ref<boolean> 2840 ): heap.Ref<boolean> => { 2841 try { 2842 const _ret = WEBEXT.accessibilityPrivate.setNativeChromeVoxArcSupportForCurrentApp(enabled === A.H.TRUE); 2843 A.store.Ref(retPtr, _ret); 2844 return A.H.TRUE; 2845 } catch (err: any) { 2846 A.store.Ref(errPtr, err); 2847 return A.H.FALSE; 2848 } 2849 }, 2850 "has_SetPointScanState": (): heap.Ref<boolean> => { 2851 if (WEBEXT?.accessibilityPrivate && "setPointScanState" in WEBEXT?.accessibilityPrivate) { 2852 return A.H.TRUE; 2853 } 2854 return A.H.FALSE; 2855 }, 2856 "func_SetPointScanState": (fn: Pointer): void => { 2857 A.store.Ref(fn, WEBEXT.accessibilityPrivate.setPointScanState); 2858 }, 2859 "call_SetPointScanState": (retPtr: Pointer, state: number): void => { 2860 const _ret = WEBEXT.accessibilityPrivate.setPointScanState( 2861 state > 0 && state <= 2 ? ["start", "stop"][state - 1] : undefined 2862 ); 2863 }, 2864 "try_SetPointScanState": (retPtr: Pointer, errPtr: Pointer, state: number): heap.Ref<boolean> => { 2865 try { 2866 const _ret = WEBEXT.accessibilityPrivate.setPointScanState( 2867 state > 0 && state <= 2 ? ["start", "stop"][state - 1] : undefined 2868 ); 2869 return A.H.TRUE; 2870 } catch (err: any) { 2871 A.store.Ref(errPtr, err); 2872 return A.H.FALSE; 2873 } 2874 }, 2875 "has_SetSelectToSpeakState": (): heap.Ref<boolean> => { 2876 if (WEBEXT?.accessibilityPrivate && "setSelectToSpeakState" in WEBEXT?.accessibilityPrivate) { 2877 return A.H.TRUE; 2878 } 2879 return A.H.FALSE; 2880 }, 2881 "func_SetSelectToSpeakState": (fn: Pointer): void => { 2882 A.store.Ref(fn, WEBEXT.accessibilityPrivate.setSelectToSpeakState); 2883 }, 2884 "call_SetSelectToSpeakState": (retPtr: Pointer, state: number): void => { 2885 const _ret = WEBEXT.accessibilityPrivate.setSelectToSpeakState( 2886 state > 0 && state <= 3 ? ["selecting", "speaking", "inactive"][state - 1] : undefined 2887 ); 2888 }, 2889 "try_SetSelectToSpeakState": (retPtr: Pointer, errPtr: Pointer, state: number): heap.Ref<boolean> => { 2890 try { 2891 const _ret = WEBEXT.accessibilityPrivate.setSelectToSpeakState( 2892 state > 0 && state <= 3 ? ["selecting", "speaking", "inactive"][state - 1] : undefined 2893 ); 2894 return A.H.TRUE; 2895 } catch (err: any) { 2896 A.store.Ref(errPtr, err); 2897 return A.H.FALSE; 2898 } 2899 }, 2900 "has_SetVirtualKeyboardVisible": (): heap.Ref<boolean> => { 2901 if (WEBEXT?.accessibilityPrivate && "setVirtualKeyboardVisible" in WEBEXT?.accessibilityPrivate) { 2902 return A.H.TRUE; 2903 } 2904 return A.H.FALSE; 2905 }, 2906 "func_SetVirtualKeyboardVisible": (fn: Pointer): void => { 2907 A.store.Ref(fn, WEBEXT.accessibilityPrivate.setVirtualKeyboardVisible); 2908 }, 2909 "call_SetVirtualKeyboardVisible": (retPtr: Pointer, isVisible: heap.Ref<boolean>): void => { 2910 const _ret = WEBEXT.accessibilityPrivate.setVirtualKeyboardVisible(isVisible === A.H.TRUE); 2911 }, 2912 "try_SetVirtualKeyboardVisible": ( 2913 retPtr: Pointer, 2914 errPtr: Pointer, 2915 isVisible: heap.Ref<boolean> 2916 ): heap.Ref<boolean> => { 2917 try { 2918 const _ret = WEBEXT.accessibilityPrivate.setVirtualKeyboardVisible(isVisible === A.H.TRUE); 2919 return A.H.TRUE; 2920 } catch (err: any) { 2921 A.store.Ref(errPtr, err); 2922 return A.H.FALSE; 2923 } 2924 }, 2925 "has_ShowConfirmationDialog": (): heap.Ref<boolean> => { 2926 if (WEBEXT?.accessibilityPrivate && "showConfirmationDialog" in WEBEXT?.accessibilityPrivate) { 2927 return A.H.TRUE; 2928 } 2929 return A.H.FALSE; 2930 }, 2931 "func_ShowConfirmationDialog": (fn: Pointer): void => { 2932 A.store.Ref(fn, WEBEXT.accessibilityPrivate.showConfirmationDialog); 2933 }, 2934 "call_ShowConfirmationDialog": ( 2935 retPtr: Pointer, 2936 title: heap.Ref<object>, 2937 description: heap.Ref<object>, 2938 cancelName: heap.Ref<object> 2939 ): void => { 2940 const _ret = WEBEXT.accessibilityPrivate.showConfirmationDialog( 2941 A.H.get<object>(title), 2942 A.H.get<object>(description), 2943 A.H.get<object>(cancelName) 2944 ); 2945 A.store.Ref(retPtr, _ret); 2946 }, 2947 "try_ShowConfirmationDialog": ( 2948 retPtr: Pointer, 2949 errPtr: Pointer, 2950 title: heap.Ref<object>, 2951 description: heap.Ref<object>, 2952 cancelName: heap.Ref<object> 2953 ): heap.Ref<boolean> => { 2954 try { 2955 const _ret = WEBEXT.accessibilityPrivate.showConfirmationDialog( 2956 A.H.get<object>(title), 2957 A.H.get<object>(description), 2958 A.H.get<object>(cancelName) 2959 ); 2960 A.store.Ref(retPtr, _ret); 2961 return A.H.TRUE; 2962 } catch (err: any) { 2963 A.store.Ref(errPtr, err); 2964 return A.H.FALSE; 2965 } 2966 }, 2967 "has_ShowToast": (): heap.Ref<boolean> => { 2968 if (WEBEXT?.accessibilityPrivate && "showToast" in WEBEXT?.accessibilityPrivate) { 2969 return A.H.TRUE; 2970 } 2971 return A.H.FALSE; 2972 }, 2973 "func_ShowToast": (fn: Pointer): void => { 2974 A.store.Ref(fn, WEBEXT.accessibilityPrivate.showToast); 2975 }, 2976 "call_ShowToast": (retPtr: Pointer, type: number): void => { 2977 const _ret = WEBEXT.accessibilityPrivate.showToast( 2978 type > 0 && type <= 1 ? ["dictationNoFocusedTextField"][type - 1] : undefined 2979 ); 2980 }, 2981 "try_ShowToast": (retPtr: Pointer, errPtr: Pointer, type: number): heap.Ref<boolean> => { 2982 try { 2983 const _ret = WEBEXT.accessibilityPrivate.showToast( 2984 type > 0 && type <= 1 ? ["dictationNoFocusedTextField"][type - 1] : undefined 2985 ); 2986 return A.H.TRUE; 2987 } catch (err: any) { 2988 A.store.Ref(errPtr, err); 2989 return A.H.FALSE; 2990 } 2991 }, 2992 "has_SilenceSpokenFeedback": (): heap.Ref<boolean> => { 2993 if (WEBEXT?.accessibilityPrivate && "silenceSpokenFeedback" in WEBEXT?.accessibilityPrivate) { 2994 return A.H.TRUE; 2995 } 2996 return A.H.FALSE; 2997 }, 2998 "func_SilenceSpokenFeedback": (fn: Pointer): void => { 2999 A.store.Ref(fn, WEBEXT.accessibilityPrivate.silenceSpokenFeedback); 3000 }, 3001 "call_SilenceSpokenFeedback": (retPtr: Pointer): void => { 3002 const _ret = WEBEXT.accessibilityPrivate.silenceSpokenFeedback(); 3003 }, 3004 "try_SilenceSpokenFeedback": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 3005 try { 3006 const _ret = WEBEXT.accessibilityPrivate.silenceSpokenFeedback(); 3007 return A.H.TRUE; 3008 } catch (err: any) { 3009 A.store.Ref(errPtr, err); 3010 return A.H.FALSE; 3011 } 3012 }, 3013 "has_ToggleDictation": (): heap.Ref<boolean> => { 3014 if (WEBEXT?.accessibilityPrivate && "toggleDictation" in WEBEXT?.accessibilityPrivate) { 3015 return A.H.TRUE; 3016 } 3017 return A.H.FALSE; 3018 }, 3019 "func_ToggleDictation": (fn: Pointer): void => { 3020 A.store.Ref(fn, WEBEXT.accessibilityPrivate.toggleDictation); 3021 }, 3022 "call_ToggleDictation": (retPtr: Pointer): void => { 3023 const _ret = WEBEXT.accessibilityPrivate.toggleDictation(); 3024 }, 3025 "try_ToggleDictation": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 3026 try { 3027 const _ret = WEBEXT.accessibilityPrivate.toggleDictation(); 3028 return A.H.TRUE; 3029 } catch (err: any) { 3030 A.store.Ref(errPtr, err); 3031 return A.H.FALSE; 3032 } 3033 }, 3034 "has_UpdateDictationBubble": (): heap.Ref<boolean> => { 3035 if (WEBEXT?.accessibilityPrivate && "updateDictationBubble" in WEBEXT?.accessibilityPrivate) { 3036 return A.H.TRUE; 3037 } 3038 return A.H.FALSE; 3039 }, 3040 "func_UpdateDictationBubble": (fn: Pointer): void => { 3041 A.store.Ref(fn, WEBEXT.accessibilityPrivate.updateDictationBubble); 3042 }, 3043 "call_UpdateDictationBubble": (retPtr: Pointer, properties: Pointer): void => { 3044 const properties_ffi = {}; 3045 3046 properties_ffi["hints"] = A.load.Ref(properties + 0, undefined); 3047 properties_ffi["icon"] = A.load.Enum(properties + 4, ["hidden", "standby", "macroSuccess", "macroFail"]); 3048 properties_ffi["text"] = A.load.Ref(properties + 8, undefined); 3049 properties_ffi["visible"] = A.load.Bool(properties + 12); 3050 3051 const _ret = WEBEXT.accessibilityPrivate.updateDictationBubble(properties_ffi); 3052 }, 3053 "try_UpdateDictationBubble": (retPtr: Pointer, errPtr: Pointer, properties: Pointer): heap.Ref<boolean> => { 3054 try { 3055 const properties_ffi = {}; 3056 3057 properties_ffi["hints"] = A.load.Ref(properties + 0, undefined); 3058 properties_ffi["icon"] = A.load.Enum(properties + 4, ["hidden", "standby", "macroSuccess", "macroFail"]); 3059 properties_ffi["text"] = A.load.Ref(properties + 8, undefined); 3060 properties_ffi["visible"] = A.load.Bool(properties + 12); 3061 3062 const _ret = WEBEXT.accessibilityPrivate.updateDictationBubble(properties_ffi); 3063 return A.H.TRUE; 3064 } catch (err: any) { 3065 A.store.Ref(errPtr, err); 3066 return A.H.FALSE; 3067 } 3068 }, 3069 "has_UpdateSelectToSpeakPanel": (): heap.Ref<boolean> => { 3070 if (WEBEXT?.accessibilityPrivate && "updateSelectToSpeakPanel" in WEBEXT?.accessibilityPrivate) { 3071 return A.H.TRUE; 3072 } 3073 return A.H.FALSE; 3074 }, 3075 "func_UpdateSelectToSpeakPanel": (fn: Pointer): void => { 3076 A.store.Ref(fn, WEBEXT.accessibilityPrivate.updateSelectToSpeakPanel); 3077 }, 3078 "call_UpdateSelectToSpeakPanel": ( 3079 retPtr: Pointer, 3080 show: heap.Ref<boolean>, 3081 anchor: Pointer, 3082 isPaused: heap.Ref<boolean>, 3083 speed: number 3084 ): void => { 3085 const anchor_ffi = {}; 3086 3087 anchor_ffi["height"] = A.load.Int64(anchor + 0); 3088 anchor_ffi["left"] = A.load.Int64(anchor + 8); 3089 anchor_ffi["top"] = A.load.Int64(anchor + 16); 3090 anchor_ffi["width"] = A.load.Int64(anchor + 24); 3091 3092 const _ret = WEBEXT.accessibilityPrivate.updateSelectToSpeakPanel( 3093 show === A.H.TRUE, 3094 anchor_ffi, 3095 isPaused === A.H.TRUE, 3096 speed 3097 ); 3098 }, 3099 "try_UpdateSelectToSpeakPanel": ( 3100 retPtr: Pointer, 3101 errPtr: Pointer, 3102 show: heap.Ref<boolean>, 3103 anchor: Pointer, 3104 isPaused: heap.Ref<boolean>, 3105 speed: number 3106 ): heap.Ref<boolean> => { 3107 try { 3108 const anchor_ffi = {}; 3109 3110 anchor_ffi["height"] = A.load.Int64(anchor + 0); 3111 anchor_ffi["left"] = A.load.Int64(anchor + 8); 3112 anchor_ffi["top"] = A.load.Int64(anchor + 16); 3113 anchor_ffi["width"] = A.load.Int64(anchor + 24); 3114 3115 const _ret = WEBEXT.accessibilityPrivate.updateSelectToSpeakPanel( 3116 show === A.H.TRUE, 3117 anchor_ffi, 3118 isPaused === A.H.TRUE, 3119 speed 3120 ); 3121 return A.H.TRUE; 3122 } catch (err: any) { 3123 A.store.Ref(errPtr, err); 3124 return A.H.FALSE; 3125 } 3126 }, 3127 "has_UpdateSwitchAccessBubble": (): heap.Ref<boolean> => { 3128 if (WEBEXT?.accessibilityPrivate && "updateSwitchAccessBubble" in WEBEXT?.accessibilityPrivate) { 3129 return A.H.TRUE; 3130 } 3131 return A.H.FALSE; 3132 }, 3133 "func_UpdateSwitchAccessBubble": (fn: Pointer): void => { 3134 A.store.Ref(fn, WEBEXT.accessibilityPrivate.updateSwitchAccessBubble); 3135 }, 3136 "call_UpdateSwitchAccessBubble": ( 3137 retPtr: Pointer, 3138 bubble: number, 3139 show: heap.Ref<boolean>, 3140 anchor: Pointer, 3141 actions: heap.Ref<object> 3142 ): void => { 3143 const anchor_ffi = {}; 3144 3145 anchor_ffi["height"] = A.load.Int64(anchor + 0); 3146 anchor_ffi["left"] = A.load.Int64(anchor + 8); 3147 anchor_ffi["top"] = A.load.Int64(anchor + 16); 3148 anchor_ffi["width"] = A.load.Int64(anchor + 24); 3149 3150 const _ret = WEBEXT.accessibilityPrivate.updateSwitchAccessBubble( 3151 bubble > 0 && bubble <= 2 ? ["backButton", "menu"][bubble - 1] : undefined, 3152 show === A.H.TRUE, 3153 anchor_ffi, 3154 A.H.get<object>(actions) 3155 ); 3156 }, 3157 "try_UpdateSwitchAccessBubble": ( 3158 retPtr: Pointer, 3159 errPtr: Pointer, 3160 bubble: number, 3161 show: heap.Ref<boolean>, 3162 anchor: Pointer, 3163 actions: heap.Ref<object> 3164 ): heap.Ref<boolean> => { 3165 try { 3166 const anchor_ffi = {}; 3167 3168 anchor_ffi["height"] = A.load.Int64(anchor + 0); 3169 anchor_ffi["left"] = A.load.Int64(anchor + 8); 3170 anchor_ffi["top"] = A.load.Int64(anchor + 16); 3171 anchor_ffi["width"] = A.load.Int64(anchor + 24); 3172 3173 const _ret = WEBEXT.accessibilityPrivate.updateSwitchAccessBubble( 3174 bubble > 0 && bubble <= 2 ? ["backButton", "menu"][bubble - 1] : undefined, 3175 show === A.H.TRUE, 3176 anchor_ffi, 3177 A.H.get<object>(actions) 3178 ); 3179 return A.H.TRUE; 3180 } catch (err: any) { 3181 A.store.Ref(errPtr, err); 3182 return A.H.FALSE; 3183 } 3184 }, 3185 }; 3186 });