github.com/primecitizens/pcz/std@v0.2.1/plat/js/webext/inputmethodprivate/bindings/ffi_bindings.ts (about) 1 import { importModule, Application, heap, Pointer } from "@ffi"; 2 3 importModule("plat/js/webext/inputmethodprivate", (A: Application) => { 4 const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser; 5 6 return { 7 "constof_AutoCapitalizeType": (ref: heap.Ref<string>): number => { 8 const idx = ["off", "characters", "words", "sentences"].indexOf(A.H.get(ref)); 9 return idx < 0 ? 0 : idx + 1; 10 }, 11 12 "store_FinishComposingTextArgParameters": (ptr: Pointer, ref: heap.Ref<any>) => { 13 const x = A.H.get<any>(ref); 14 15 if (typeof x === "undefined") { 16 A.store.Bool(ptr + 8, false); 17 A.store.Int64(ptr + 0, 0); 18 } else { 19 A.store.Bool(ptr + 8, true); 20 A.store.Int64(ptr + 0, x["contextID"] === undefined ? 0 : (x["contextID"] as number)); 21 } 22 }, 23 "load_FinishComposingTextArgParameters": ( 24 ptr: Pointer, 25 create: heap.Ref<boolean>, 26 ref: heap.Ref<any> 27 ): heap.Ref<any> => { 28 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 29 30 x["contextID"] = A.load.Int64(ptr + 0); 31 return create === A.H.TRUE ? A.H.push(x) : ref; 32 }, 33 "constof_FocusReason": (ref: heap.Ref<string>): number => { 34 const idx = ["mouse", "touch", "pen", "other"].indexOf(A.H.get(ref)); 35 return idx < 0 ? 0 : idx + 1; 36 }, 37 38 "store_GetInputMethodConfigReturnType": (ptr: Pointer, ref: heap.Ref<any>) => { 39 const x = A.H.get<any>(ref); 40 41 if (typeof x === "undefined") { 42 A.store.Bool(ptr + 2, false); 43 A.store.Bool(ptr + 0, false); 44 A.store.Bool(ptr + 1, false); 45 } else { 46 A.store.Bool(ptr + 2, true); 47 A.store.Bool(ptr + 0, x["isImeMenuActivated"] ? true : false); 48 A.store.Bool(ptr + 1, x["isPhysicalKeyboardAutocorrectEnabled"] ? true : false); 49 } 50 }, 51 "load_GetInputMethodConfigReturnType": ( 52 ptr: Pointer, 53 create: heap.Ref<boolean>, 54 ref: heap.Ref<any> 55 ): heap.Ref<any> => { 56 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 57 58 x["isImeMenuActivated"] = A.load.Bool(ptr + 0); 59 x["isPhysicalKeyboardAutocorrectEnabled"] = A.load.Bool(ptr + 1); 60 return create === A.H.TRUE ? A.H.push(x) : ref; 61 }, 62 63 "store_GetInputMethodsReturnTypeElem": (ptr: Pointer, ref: heap.Ref<any>) => { 64 const x = A.H.get<any>(ref); 65 66 if (typeof x === "undefined") { 67 A.store.Bool(ptr + 12, false); 68 A.store.Ref(ptr + 0, undefined); 69 A.store.Ref(ptr + 4, undefined); 70 A.store.Ref(ptr + 8, undefined); 71 } else { 72 A.store.Bool(ptr + 12, true); 73 A.store.Ref(ptr + 0, x["id"]); 74 A.store.Ref(ptr + 4, x["indicator"]); 75 A.store.Ref(ptr + 8, x["name"]); 76 } 77 }, 78 "load_GetInputMethodsReturnTypeElem": ( 79 ptr: Pointer, 80 create: heap.Ref<boolean>, 81 ref: heap.Ref<any> 82 ): heap.Ref<any> => { 83 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 84 85 x["id"] = A.load.Ref(ptr + 0, undefined); 86 x["indicator"] = A.load.Ref(ptr + 4, undefined); 87 x["name"] = A.load.Ref(ptr + 8, undefined); 88 return create === A.H.TRUE ? A.H.push(x) : ref; 89 }, 90 91 "store_GetSurroundingTextReturnType": (ptr: Pointer, ref: heap.Ref<any>) => { 92 const x = A.H.get<any>(ref); 93 94 if (typeof x === "undefined") { 95 A.store.Bool(ptr + 12, false); 96 A.store.Ref(ptr + 0, undefined); 97 A.store.Ref(ptr + 4, undefined); 98 A.store.Ref(ptr + 8, undefined); 99 } else { 100 A.store.Bool(ptr + 12, true); 101 A.store.Ref(ptr + 0, x["after"]); 102 A.store.Ref(ptr + 4, x["before"]); 103 A.store.Ref(ptr + 8, x["selected"]); 104 } 105 }, 106 "load_GetSurroundingTextReturnType": ( 107 ptr: Pointer, 108 create: heap.Ref<boolean>, 109 ref: heap.Ref<any> 110 ): heap.Ref<any> => { 111 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 112 113 x["after"] = A.load.Ref(ptr + 0, undefined); 114 x["before"] = A.load.Ref(ptr + 4, undefined); 115 x["selected"] = A.load.Ref(ptr + 8, undefined); 116 return create === A.H.TRUE ? A.H.push(x) : ref; 117 }, 118 119 "store_GetTextFieldBoundsArgParameters": (ptr: Pointer, ref: heap.Ref<any>) => { 120 const x = A.H.get<any>(ref); 121 122 if (typeof x === "undefined") { 123 A.store.Bool(ptr + 8, false); 124 A.store.Int64(ptr + 0, 0); 125 } else { 126 A.store.Bool(ptr + 8, true); 127 A.store.Int64(ptr + 0, x["contextID"] === undefined ? 0 : (x["contextID"] as number)); 128 } 129 }, 130 "load_GetTextFieldBoundsArgParameters": ( 131 ptr: Pointer, 132 create: heap.Ref<boolean>, 133 ref: heap.Ref<any> 134 ): heap.Ref<any> => { 135 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 136 137 x["contextID"] = A.load.Int64(ptr + 0); 138 return create === A.H.TRUE ? A.H.push(x) : ref; 139 }, 140 141 "store_GetTextFieldBoundsReturnType": (ptr: Pointer, ref: heap.Ref<any>) => { 142 const x = A.H.get<any>(ref); 143 144 if (typeof x === "undefined") { 145 A.store.Bool(ptr + 32, false); 146 A.store.Int64(ptr + 0, 0); 147 A.store.Int64(ptr + 8, 0); 148 A.store.Int64(ptr + 16, 0); 149 A.store.Int64(ptr + 24, 0); 150 } else { 151 A.store.Bool(ptr + 32, true); 152 A.store.Int64(ptr + 0, x["height"] === undefined ? 0 : (x["height"] as number)); 153 A.store.Int64(ptr + 8, x["width"] === undefined ? 0 : (x["width"] as number)); 154 A.store.Int64(ptr + 16, x["x"] === undefined ? 0 : (x["x"] as number)); 155 A.store.Int64(ptr + 24, x["y"] === undefined ? 0 : (x["y"] as number)); 156 } 157 }, 158 "load_GetTextFieldBoundsReturnType": ( 159 ptr: Pointer, 160 create: heap.Ref<boolean>, 161 ref: heap.Ref<any> 162 ): heap.Ref<any> => { 163 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 164 165 x["height"] = A.load.Int64(ptr + 0); 166 x["width"] = A.load.Int64(ptr + 8); 167 x["x"] = A.load.Int64(ptr + 16); 168 x["y"] = A.load.Int64(ptr + 24); 169 return create === A.H.TRUE ? A.H.push(x) : ref; 170 }, 171 "constof_InputModeType": (ref: heap.Ref<string>): number => { 172 const idx = ["noKeyboard", "text", "tel", "url", "email", "numeric", "decimal", "search"].indexOf(A.H.get(ref)); 173 return idx < 0 ? 0 : idx + 1; 174 }, 175 "constof_InputContextType": (ref: heap.Ref<string>): number => { 176 const idx = ["text", "search", "tel", "url", "email", "number", "password", "null"].indexOf(A.H.get(ref)); 177 return idx < 0 ? 0 : idx + 1; 178 }, 179 180 "store_InputContext": (ptr: Pointer, ref: heap.Ref<any>) => { 181 const x = A.H.get<any>(ref); 182 183 if (typeof x === "undefined") { 184 A.store.Bool(ptr + 40, false); 185 A.store.Ref(ptr + 0, undefined); 186 A.store.Enum(ptr + 4, -1); 187 A.store.Bool(ptr + 8, false); 188 A.store.Bool(ptr + 9, false); 189 A.store.Int64(ptr + 16, 0); 190 A.store.Enum(ptr + 24, -1); 191 A.store.Enum(ptr + 28, -1); 192 A.store.Bool(ptr + 32, false); 193 A.store.Bool(ptr + 33, false); 194 A.store.Enum(ptr + 36, -1); 195 } else { 196 A.store.Bool(ptr + 40, true); 197 A.store.Ref(ptr + 0, x["appKey"]); 198 A.store.Enum(ptr + 4, ["off", "characters", "words", "sentences"].indexOf(x["autoCapitalize"] as string)); 199 A.store.Bool(ptr + 8, x["autoComplete"] ? true : false); 200 A.store.Bool(ptr + 9, x["autoCorrect"] ? true : false); 201 A.store.Int64(ptr + 16, x["contextID"] === undefined ? 0 : (x["contextID"] as number)); 202 A.store.Enum(ptr + 24, ["mouse", "touch", "pen", "other"].indexOf(x["focusReason"] as string)); 203 A.store.Enum( 204 ptr + 28, 205 ["noKeyboard", "text", "tel", "url", "email", "numeric", "decimal", "search"].indexOf(x["mode"] as string) 206 ); 207 A.store.Bool(ptr + 32, x["shouldDoLearning"] ? true : false); 208 A.store.Bool(ptr + 33, x["spellCheck"] ? true : false); 209 A.store.Enum( 210 ptr + 36, 211 ["text", "search", "tel", "url", "email", "number", "password", "null"].indexOf(x["type"] as string) 212 ); 213 } 214 }, 215 "load_InputContext": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 216 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 217 218 x["appKey"] = A.load.Ref(ptr + 0, undefined); 219 x["autoCapitalize"] = A.load.Enum(ptr + 4, ["off", "characters", "words", "sentences"]); 220 x["autoComplete"] = A.load.Bool(ptr + 8); 221 x["autoCorrect"] = A.load.Bool(ptr + 9); 222 x["contextID"] = A.load.Int64(ptr + 16); 223 x["focusReason"] = A.load.Enum(ptr + 24, ["mouse", "touch", "pen", "other"]); 224 x["mode"] = A.load.Enum(ptr + 28, ["noKeyboard", "text", "tel", "url", "email", "numeric", "decimal", "search"]); 225 x["shouldDoLearning"] = A.load.Bool(ptr + 32); 226 x["spellCheck"] = A.load.Bool(ptr + 33); 227 x["type"] = A.load.Enum(ptr + 36, ["text", "search", "tel", "url", "email", "number", "password", "null"]); 228 return create === A.H.TRUE ? A.H.push(x) : ref; 229 }, 230 231 "store_InputMethodSettingsFieldPinyinFuzzyConfig": (ptr: Pointer, ref: heap.Ref<any>) => { 232 const x = A.H.get<any>(ref); 233 234 if (typeof x === "undefined") { 235 A.store.Bool(ptr + 24, false); 236 A.store.Bool(ptr + 12, false); 237 A.store.Bool(ptr + 0, false); 238 A.store.Bool(ptr + 13, false); 239 A.store.Bool(ptr + 1, false); 240 A.store.Bool(ptr + 14, false); 241 A.store.Bool(ptr + 2, false); 242 A.store.Bool(ptr + 15, false); 243 A.store.Bool(ptr + 3, false); 244 A.store.Bool(ptr + 16, false); 245 A.store.Bool(ptr + 4, false); 246 A.store.Bool(ptr + 17, false); 247 A.store.Bool(ptr + 5, false); 248 A.store.Bool(ptr + 18, false); 249 A.store.Bool(ptr + 6, false); 250 A.store.Bool(ptr + 19, false); 251 A.store.Bool(ptr + 7, false); 252 A.store.Bool(ptr + 20, false); 253 A.store.Bool(ptr + 8, false); 254 A.store.Bool(ptr + 21, false); 255 A.store.Bool(ptr + 9, false); 256 A.store.Bool(ptr + 22, false); 257 A.store.Bool(ptr + 10, false); 258 A.store.Bool(ptr + 23, false); 259 A.store.Bool(ptr + 11, false); 260 } else { 261 A.store.Bool(ptr + 24, true); 262 A.store.Bool(ptr + 12, "an_ang" in x ? true : false); 263 A.store.Bool(ptr + 0, x["an_ang"] ? true : false); 264 A.store.Bool(ptr + 13, "c_ch" in x ? true : false); 265 A.store.Bool(ptr + 1, x["c_ch"] ? true : false); 266 A.store.Bool(ptr + 14, "en_eng" in x ? true : false); 267 A.store.Bool(ptr + 2, x["en_eng"] ? true : false); 268 A.store.Bool(ptr + 15, "f_h" in x ? true : false); 269 A.store.Bool(ptr + 3, x["f_h"] ? true : false); 270 A.store.Bool(ptr + 16, "ian_iang" in x ? true : false); 271 A.store.Bool(ptr + 4, x["ian_iang"] ? true : false); 272 A.store.Bool(ptr + 17, "in_ing" in x ? true : false); 273 A.store.Bool(ptr + 5, x["in_ing"] ? true : false); 274 A.store.Bool(ptr + 18, "k_g" in x ? true : false); 275 A.store.Bool(ptr + 6, x["k_g"] ? true : false); 276 A.store.Bool(ptr + 19, "l_n" in x ? true : false); 277 A.store.Bool(ptr + 7, x["l_n"] ? true : false); 278 A.store.Bool(ptr + 20, "r_l" in x ? true : false); 279 A.store.Bool(ptr + 8, x["r_l"] ? true : false); 280 A.store.Bool(ptr + 21, "s_sh" in x ? true : false); 281 A.store.Bool(ptr + 9, x["s_sh"] ? true : false); 282 A.store.Bool(ptr + 22, "uan_uang" in x ? true : false); 283 A.store.Bool(ptr + 10, x["uan_uang"] ? true : false); 284 A.store.Bool(ptr + 23, "z_zh" in x ? true : false); 285 A.store.Bool(ptr + 11, x["z_zh"] ? true : false); 286 } 287 }, 288 "load_InputMethodSettingsFieldPinyinFuzzyConfig": ( 289 ptr: Pointer, 290 create: heap.Ref<boolean>, 291 ref: heap.Ref<any> 292 ): heap.Ref<any> => { 293 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 294 295 if (A.load.Bool(ptr + 12)) { 296 x["an_ang"] = A.load.Bool(ptr + 0); 297 } else { 298 delete x["an_ang"]; 299 } 300 if (A.load.Bool(ptr + 13)) { 301 x["c_ch"] = A.load.Bool(ptr + 1); 302 } else { 303 delete x["c_ch"]; 304 } 305 if (A.load.Bool(ptr + 14)) { 306 x["en_eng"] = A.load.Bool(ptr + 2); 307 } else { 308 delete x["en_eng"]; 309 } 310 if (A.load.Bool(ptr + 15)) { 311 x["f_h"] = A.load.Bool(ptr + 3); 312 } else { 313 delete x["f_h"]; 314 } 315 if (A.load.Bool(ptr + 16)) { 316 x["ian_iang"] = A.load.Bool(ptr + 4); 317 } else { 318 delete x["ian_iang"]; 319 } 320 if (A.load.Bool(ptr + 17)) { 321 x["in_ing"] = A.load.Bool(ptr + 5); 322 } else { 323 delete x["in_ing"]; 324 } 325 if (A.load.Bool(ptr + 18)) { 326 x["k_g"] = A.load.Bool(ptr + 6); 327 } else { 328 delete x["k_g"]; 329 } 330 if (A.load.Bool(ptr + 19)) { 331 x["l_n"] = A.load.Bool(ptr + 7); 332 } else { 333 delete x["l_n"]; 334 } 335 if (A.load.Bool(ptr + 20)) { 336 x["r_l"] = A.load.Bool(ptr + 8); 337 } else { 338 delete x["r_l"]; 339 } 340 if (A.load.Bool(ptr + 21)) { 341 x["s_sh"] = A.load.Bool(ptr + 9); 342 } else { 343 delete x["s_sh"]; 344 } 345 if (A.load.Bool(ptr + 22)) { 346 x["uan_uang"] = A.load.Bool(ptr + 10); 347 } else { 348 delete x["uan_uang"]; 349 } 350 if (A.load.Bool(ptr + 23)) { 351 x["z_zh"] = A.load.Bool(ptr + 11); 352 } else { 353 delete x["z_zh"]; 354 } 355 return create === A.H.TRUE ? A.H.push(x) : ref; 356 }, 357 358 "store_InputMethodSettings": (ptr: Pointer, ref: heap.Ref<any>) => { 359 const x = A.H.get<any>(ref); 360 361 if (typeof x === "undefined") { 362 A.store.Bool(ptr + 138, false); 363 A.store.Bool(ptr + 108, false); 364 A.store.Bool(ptr + 0, false); 365 A.store.Bool(ptr + 109, false); 366 A.store.Bool(ptr + 1, false); 367 A.store.Bool(ptr + 110, false); 368 A.store.Bool(ptr + 2, false); 369 A.store.Bool(ptr + 111, false); 370 A.store.Bool(ptr + 3, false); 371 A.store.Bool(ptr + 112, false); 372 A.store.Bool(ptr + 4, false); 373 A.store.Bool(ptr + 113, false); 374 A.store.Bool(ptr + 5, false); 375 A.store.Ref(ptr + 8, undefined); 376 A.store.Bool(ptr + 114, false); 377 A.store.Bool(ptr + 12, false); 378 A.store.Bool(ptr + 115, false); 379 A.store.Bool(ptr + 13, false); 380 A.store.Bool(ptr + 116, false); 381 A.store.Int64(ptr + 16, 0); 382 A.store.Bool(ptr + 117, false); 383 A.store.Bool(ptr + 24, false); 384 A.store.Bool(ptr + 118, false); 385 A.store.Bool(ptr + 25, false); 386 A.store.Bool(ptr + 119, false); 387 A.store.Bool(ptr + 26, false); 388 A.store.Bool(ptr + 120, false); 389 A.store.Bool(ptr + 27, false); 390 A.store.Bool(ptr + 121, false); 391 A.store.Bool(ptr + 28, false); 392 A.store.Bool(ptr + 122, false); 393 A.store.Bool(ptr + 29, false); 394 A.store.Bool(ptr + 123, false); 395 A.store.Bool(ptr + 30, false); 396 A.store.Bool(ptr + 124, false); 397 A.store.Bool(ptr + 31, false); 398 A.store.Bool(ptr + 125, false); 399 A.store.Bool(ptr + 32, false); 400 401 A.store.Bool(ptr + 33 + 24, false); 402 A.store.Bool(ptr + 33 + 12, false); 403 A.store.Bool(ptr + 33 + 0, false); 404 A.store.Bool(ptr + 33 + 13, false); 405 A.store.Bool(ptr + 33 + 1, false); 406 A.store.Bool(ptr + 33 + 14, false); 407 A.store.Bool(ptr + 33 + 2, false); 408 A.store.Bool(ptr + 33 + 15, false); 409 A.store.Bool(ptr + 33 + 3, false); 410 A.store.Bool(ptr + 33 + 16, false); 411 A.store.Bool(ptr + 33 + 4, false); 412 A.store.Bool(ptr + 33 + 17, false); 413 A.store.Bool(ptr + 33 + 5, false); 414 A.store.Bool(ptr + 33 + 18, false); 415 A.store.Bool(ptr + 33 + 6, false); 416 A.store.Bool(ptr + 33 + 19, false); 417 A.store.Bool(ptr + 33 + 7, false); 418 A.store.Bool(ptr + 33 + 20, false); 419 A.store.Bool(ptr + 33 + 8, false); 420 A.store.Bool(ptr + 33 + 21, false); 421 A.store.Bool(ptr + 33 + 9, false); 422 A.store.Bool(ptr + 33 + 22, false); 423 A.store.Bool(ptr + 33 + 10, false); 424 A.store.Bool(ptr + 33 + 23, false); 425 A.store.Bool(ptr + 33 + 11, false); 426 A.store.Bool(ptr + 126, false); 427 A.store.Bool(ptr + 58, false); 428 A.store.Bool(ptr + 127, false); 429 A.store.Bool(ptr + 59, false); 430 A.store.Bool(ptr + 128, false); 431 A.store.Bool(ptr + 60, false); 432 A.store.Bool(ptr + 129, false); 433 A.store.Bool(ptr + 61, false); 434 A.store.Bool(ptr + 130, false); 435 A.store.Bool(ptr + 62, false); 436 A.store.Bool(ptr + 131, false); 437 A.store.Bool(ptr + 63, false); 438 A.store.Bool(ptr + 132, false); 439 A.store.Bool(ptr + 64, false); 440 A.store.Bool(ptr + 133, false); 441 A.store.Bool(ptr + 65, false); 442 A.store.Bool(ptr + 134, false); 443 A.store.Bool(ptr + 66, false); 444 A.store.Bool(ptr + 135, false); 445 A.store.Int64(ptr + 72, 0); 446 A.store.Bool(ptr + 136, false); 447 A.store.Bool(ptr + 80, false); 448 A.store.Ref(ptr + 84, undefined); 449 A.store.Ref(ptr + 88, undefined); 450 A.store.Bool(ptr + 137, false); 451 A.store.Int64(ptr + 96, 0); 452 A.store.Ref(ptr + 104, undefined); 453 } else { 454 A.store.Bool(ptr + 138, true); 455 A.store.Bool(ptr + 108, "enableCompletion" in x ? true : false); 456 A.store.Bool(ptr + 0, x["enableCompletion"] ? true : false); 457 A.store.Bool(ptr + 109, "enableDoubleSpacePeriod" in x ? true : false); 458 A.store.Bool(ptr + 1, x["enableDoubleSpacePeriod"] ? true : false); 459 A.store.Bool(ptr + 110, "enableGestureTyping" in x ? true : false); 460 A.store.Bool(ptr + 2, x["enableGestureTyping"] ? true : false); 461 A.store.Bool(ptr + 111, "enablePrediction" in x ? true : false); 462 A.store.Bool(ptr + 3, x["enablePrediction"] ? true : false); 463 A.store.Bool(ptr + 112, "enableSoundOnKeypress" in x ? true : false); 464 A.store.Bool(ptr + 4, x["enableSoundOnKeypress"] ? true : false); 465 A.store.Bool(ptr + 113, "koreanEnableSyllableInput" in x ? true : false); 466 A.store.Bool(ptr + 5, x["koreanEnableSyllableInput"] ? true : false); 467 A.store.Ref(ptr + 8, x["koreanKeyboardLayout"]); 468 A.store.Bool(ptr + 114, "koreanShowHangulCandidate" in x ? true : false); 469 A.store.Bool(ptr + 12, x["koreanShowHangulCandidate"] ? true : false); 470 A.store.Bool(ptr + 115, "physicalKeyboardAutoCorrectionEnabledByDefault" in x ? true : false); 471 A.store.Bool(ptr + 13, x["physicalKeyboardAutoCorrectionEnabledByDefault"] ? true : false); 472 A.store.Bool(ptr + 116, "physicalKeyboardAutoCorrectionLevel" in x ? true : false); 473 A.store.Int64( 474 ptr + 16, 475 x["physicalKeyboardAutoCorrectionLevel"] === undefined 476 ? 0 477 : (x["physicalKeyboardAutoCorrectionLevel"] as number) 478 ); 479 A.store.Bool(ptr + 117, "physicalKeyboardEnableCapitalization" in x ? true : false); 480 A.store.Bool(ptr + 24, x["physicalKeyboardEnableCapitalization"] ? true : false); 481 A.store.Bool(ptr + 118, "physicalKeyboardEnableDiacriticsOnLongpress" in x ? true : false); 482 A.store.Bool(ptr + 25, x["physicalKeyboardEnableDiacriticsOnLongpress"] ? true : false); 483 A.store.Bool(ptr + 119, "physicalKeyboardEnablePredictiveWriting" in x ? true : false); 484 A.store.Bool(ptr + 26, x["physicalKeyboardEnablePredictiveWriting"] ? true : false); 485 A.store.Bool(ptr + 120, "pinyinChinesePunctuation" in x ? true : false); 486 A.store.Bool(ptr + 27, x["pinyinChinesePunctuation"] ? true : false); 487 A.store.Bool(ptr + 121, "pinyinDefaultChinese" in x ? true : false); 488 A.store.Bool(ptr + 28, x["pinyinDefaultChinese"] ? true : false); 489 A.store.Bool(ptr + 122, "pinyinEnableFuzzy" in x ? true : false); 490 A.store.Bool(ptr + 29, x["pinyinEnableFuzzy"] ? true : false); 491 A.store.Bool(ptr + 123, "pinyinEnableLowerPaging" in x ? true : false); 492 A.store.Bool(ptr + 30, x["pinyinEnableLowerPaging"] ? true : false); 493 A.store.Bool(ptr + 124, "pinyinEnableUpperPaging" in x ? true : false); 494 A.store.Bool(ptr + 31, x["pinyinEnableUpperPaging"] ? true : false); 495 A.store.Bool(ptr + 125, "pinyinFullWidthCharacter" in x ? true : false); 496 A.store.Bool(ptr + 32, x["pinyinFullWidthCharacter"] ? true : false); 497 498 if (typeof x["pinyinFuzzyConfig"] === "undefined") { 499 A.store.Bool(ptr + 33 + 24, false); 500 A.store.Bool(ptr + 33 + 12, false); 501 A.store.Bool(ptr + 33 + 0, false); 502 A.store.Bool(ptr + 33 + 13, false); 503 A.store.Bool(ptr + 33 + 1, false); 504 A.store.Bool(ptr + 33 + 14, false); 505 A.store.Bool(ptr + 33 + 2, false); 506 A.store.Bool(ptr + 33 + 15, false); 507 A.store.Bool(ptr + 33 + 3, false); 508 A.store.Bool(ptr + 33 + 16, false); 509 A.store.Bool(ptr + 33 + 4, false); 510 A.store.Bool(ptr + 33 + 17, false); 511 A.store.Bool(ptr + 33 + 5, false); 512 A.store.Bool(ptr + 33 + 18, false); 513 A.store.Bool(ptr + 33 + 6, false); 514 A.store.Bool(ptr + 33 + 19, false); 515 A.store.Bool(ptr + 33 + 7, false); 516 A.store.Bool(ptr + 33 + 20, false); 517 A.store.Bool(ptr + 33 + 8, false); 518 A.store.Bool(ptr + 33 + 21, false); 519 A.store.Bool(ptr + 33 + 9, false); 520 A.store.Bool(ptr + 33 + 22, false); 521 A.store.Bool(ptr + 33 + 10, false); 522 A.store.Bool(ptr + 33 + 23, false); 523 A.store.Bool(ptr + 33 + 11, false); 524 } else { 525 A.store.Bool(ptr + 33 + 24, true); 526 A.store.Bool(ptr + 33 + 12, "an_ang" in x["pinyinFuzzyConfig"] ? true : false); 527 A.store.Bool(ptr + 33 + 0, x["pinyinFuzzyConfig"]["an_ang"] ? true : false); 528 A.store.Bool(ptr + 33 + 13, "c_ch" in x["pinyinFuzzyConfig"] ? true : false); 529 A.store.Bool(ptr + 33 + 1, x["pinyinFuzzyConfig"]["c_ch"] ? true : false); 530 A.store.Bool(ptr + 33 + 14, "en_eng" in x["pinyinFuzzyConfig"] ? true : false); 531 A.store.Bool(ptr + 33 + 2, x["pinyinFuzzyConfig"]["en_eng"] ? true : false); 532 A.store.Bool(ptr + 33 + 15, "f_h" in x["pinyinFuzzyConfig"] ? true : false); 533 A.store.Bool(ptr + 33 + 3, x["pinyinFuzzyConfig"]["f_h"] ? true : false); 534 A.store.Bool(ptr + 33 + 16, "ian_iang" in x["pinyinFuzzyConfig"] ? true : false); 535 A.store.Bool(ptr + 33 + 4, x["pinyinFuzzyConfig"]["ian_iang"] ? true : false); 536 A.store.Bool(ptr + 33 + 17, "in_ing" in x["pinyinFuzzyConfig"] ? true : false); 537 A.store.Bool(ptr + 33 + 5, x["pinyinFuzzyConfig"]["in_ing"] ? true : false); 538 A.store.Bool(ptr + 33 + 18, "k_g" in x["pinyinFuzzyConfig"] ? true : false); 539 A.store.Bool(ptr + 33 + 6, x["pinyinFuzzyConfig"]["k_g"] ? true : false); 540 A.store.Bool(ptr + 33 + 19, "l_n" in x["pinyinFuzzyConfig"] ? true : false); 541 A.store.Bool(ptr + 33 + 7, x["pinyinFuzzyConfig"]["l_n"] ? true : false); 542 A.store.Bool(ptr + 33 + 20, "r_l" in x["pinyinFuzzyConfig"] ? true : false); 543 A.store.Bool(ptr + 33 + 8, x["pinyinFuzzyConfig"]["r_l"] ? true : false); 544 A.store.Bool(ptr + 33 + 21, "s_sh" in x["pinyinFuzzyConfig"] ? true : false); 545 A.store.Bool(ptr + 33 + 9, x["pinyinFuzzyConfig"]["s_sh"] ? true : false); 546 A.store.Bool(ptr + 33 + 22, "uan_uang" in x["pinyinFuzzyConfig"] ? true : false); 547 A.store.Bool(ptr + 33 + 10, x["pinyinFuzzyConfig"]["uan_uang"] ? true : false); 548 A.store.Bool(ptr + 33 + 23, "z_zh" in x["pinyinFuzzyConfig"] ? true : false); 549 A.store.Bool(ptr + 33 + 11, x["pinyinFuzzyConfig"]["z_zh"] ? true : false); 550 } 551 A.store.Bool(ptr + 126, "vietnameseTelexAllowFlexibleDiacritics" in x ? true : false); 552 A.store.Bool(ptr + 58, x["vietnameseTelexAllowFlexibleDiacritics"] ? true : false); 553 A.store.Bool(ptr + 127, "vietnameseTelexInsertDoubleHornOnUo" in x ? true : false); 554 A.store.Bool(ptr + 59, x["vietnameseTelexInsertDoubleHornOnUo"] ? true : false); 555 A.store.Bool(ptr + 128, "vietnameseTelexInsertUHornOnW" in x ? true : false); 556 A.store.Bool(ptr + 60, x["vietnameseTelexInsertUHornOnW"] ? true : false); 557 A.store.Bool(ptr + 129, "vietnameseTelexNewStyleToneMarkPlacement" in x ? true : false); 558 A.store.Bool(ptr + 61, x["vietnameseTelexNewStyleToneMarkPlacement"] ? true : false); 559 A.store.Bool(ptr + 130, "vietnameseTelexShowUnderline" in x ? true : false); 560 A.store.Bool(ptr + 62, x["vietnameseTelexShowUnderline"] ? true : false); 561 A.store.Bool(ptr + 131, "vietnameseVniAllowFlexibleDiacritics" in x ? true : false); 562 A.store.Bool(ptr + 63, x["vietnameseVniAllowFlexibleDiacritics"] ? true : false); 563 A.store.Bool(ptr + 132, "vietnameseVniInsertDoubleHornOnUo" in x ? true : false); 564 A.store.Bool(ptr + 64, x["vietnameseVniInsertDoubleHornOnUo"] ? true : false); 565 A.store.Bool(ptr + 133, "vietnameseVniNewStyleToneMarkPlacement" in x ? true : false); 566 A.store.Bool(ptr + 65, x["vietnameseVniNewStyleToneMarkPlacement"] ? true : false); 567 A.store.Bool(ptr + 134, "vietnameseVniShowUnderline" in x ? true : false); 568 A.store.Bool(ptr + 66, x["vietnameseVniShowUnderline"] ? true : false); 569 A.store.Bool(ptr + 135, "virtualKeyboardAutoCorrectionLevel" in x ? true : false); 570 A.store.Int64( 571 ptr + 72, 572 x["virtualKeyboardAutoCorrectionLevel"] === undefined 573 ? 0 574 : (x["virtualKeyboardAutoCorrectionLevel"] as number) 575 ); 576 A.store.Bool(ptr + 136, "virtualKeyboardEnableCapitalization" in x ? true : false); 577 A.store.Bool(ptr + 80, x["virtualKeyboardEnableCapitalization"] ? true : false); 578 A.store.Ref(ptr + 84, x["xkbLayout"]); 579 A.store.Ref(ptr + 88, x["zhuyinKeyboardLayout"]); 580 A.store.Bool(ptr + 137, "zhuyinPageSize" in x ? true : false); 581 A.store.Int64(ptr + 96, x["zhuyinPageSize"] === undefined ? 0 : (x["zhuyinPageSize"] as number)); 582 A.store.Ref(ptr + 104, x["zhuyinSelectKeys"]); 583 } 584 }, 585 "load_InputMethodSettings": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 586 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 587 588 if (A.load.Bool(ptr + 108)) { 589 x["enableCompletion"] = A.load.Bool(ptr + 0); 590 } else { 591 delete x["enableCompletion"]; 592 } 593 if (A.load.Bool(ptr + 109)) { 594 x["enableDoubleSpacePeriod"] = A.load.Bool(ptr + 1); 595 } else { 596 delete x["enableDoubleSpacePeriod"]; 597 } 598 if (A.load.Bool(ptr + 110)) { 599 x["enableGestureTyping"] = A.load.Bool(ptr + 2); 600 } else { 601 delete x["enableGestureTyping"]; 602 } 603 if (A.load.Bool(ptr + 111)) { 604 x["enablePrediction"] = A.load.Bool(ptr + 3); 605 } else { 606 delete x["enablePrediction"]; 607 } 608 if (A.load.Bool(ptr + 112)) { 609 x["enableSoundOnKeypress"] = A.load.Bool(ptr + 4); 610 } else { 611 delete x["enableSoundOnKeypress"]; 612 } 613 if (A.load.Bool(ptr + 113)) { 614 x["koreanEnableSyllableInput"] = A.load.Bool(ptr + 5); 615 } else { 616 delete x["koreanEnableSyllableInput"]; 617 } 618 x["koreanKeyboardLayout"] = A.load.Ref(ptr + 8, undefined); 619 if (A.load.Bool(ptr + 114)) { 620 x["koreanShowHangulCandidate"] = A.load.Bool(ptr + 12); 621 } else { 622 delete x["koreanShowHangulCandidate"]; 623 } 624 if (A.load.Bool(ptr + 115)) { 625 x["physicalKeyboardAutoCorrectionEnabledByDefault"] = A.load.Bool(ptr + 13); 626 } else { 627 delete x["physicalKeyboardAutoCorrectionEnabledByDefault"]; 628 } 629 if (A.load.Bool(ptr + 116)) { 630 x["physicalKeyboardAutoCorrectionLevel"] = A.load.Int64(ptr + 16); 631 } else { 632 delete x["physicalKeyboardAutoCorrectionLevel"]; 633 } 634 if (A.load.Bool(ptr + 117)) { 635 x["physicalKeyboardEnableCapitalization"] = A.load.Bool(ptr + 24); 636 } else { 637 delete x["physicalKeyboardEnableCapitalization"]; 638 } 639 if (A.load.Bool(ptr + 118)) { 640 x["physicalKeyboardEnableDiacriticsOnLongpress"] = A.load.Bool(ptr + 25); 641 } else { 642 delete x["physicalKeyboardEnableDiacriticsOnLongpress"]; 643 } 644 if (A.load.Bool(ptr + 119)) { 645 x["physicalKeyboardEnablePredictiveWriting"] = A.load.Bool(ptr + 26); 646 } else { 647 delete x["physicalKeyboardEnablePredictiveWriting"]; 648 } 649 if (A.load.Bool(ptr + 120)) { 650 x["pinyinChinesePunctuation"] = A.load.Bool(ptr + 27); 651 } else { 652 delete x["pinyinChinesePunctuation"]; 653 } 654 if (A.load.Bool(ptr + 121)) { 655 x["pinyinDefaultChinese"] = A.load.Bool(ptr + 28); 656 } else { 657 delete x["pinyinDefaultChinese"]; 658 } 659 if (A.load.Bool(ptr + 122)) { 660 x["pinyinEnableFuzzy"] = A.load.Bool(ptr + 29); 661 } else { 662 delete x["pinyinEnableFuzzy"]; 663 } 664 if (A.load.Bool(ptr + 123)) { 665 x["pinyinEnableLowerPaging"] = A.load.Bool(ptr + 30); 666 } else { 667 delete x["pinyinEnableLowerPaging"]; 668 } 669 if (A.load.Bool(ptr + 124)) { 670 x["pinyinEnableUpperPaging"] = A.load.Bool(ptr + 31); 671 } else { 672 delete x["pinyinEnableUpperPaging"]; 673 } 674 if (A.load.Bool(ptr + 125)) { 675 x["pinyinFullWidthCharacter"] = A.load.Bool(ptr + 32); 676 } else { 677 delete x["pinyinFullWidthCharacter"]; 678 } 679 if (A.load.Bool(ptr + 33 + 24)) { 680 x["pinyinFuzzyConfig"] = {}; 681 if (A.load.Bool(ptr + 33 + 12)) { 682 x["pinyinFuzzyConfig"]["an_ang"] = A.load.Bool(ptr + 33 + 0); 683 } else { 684 delete x["pinyinFuzzyConfig"]["an_ang"]; 685 } 686 if (A.load.Bool(ptr + 33 + 13)) { 687 x["pinyinFuzzyConfig"]["c_ch"] = A.load.Bool(ptr + 33 + 1); 688 } else { 689 delete x["pinyinFuzzyConfig"]["c_ch"]; 690 } 691 if (A.load.Bool(ptr + 33 + 14)) { 692 x["pinyinFuzzyConfig"]["en_eng"] = A.load.Bool(ptr + 33 + 2); 693 } else { 694 delete x["pinyinFuzzyConfig"]["en_eng"]; 695 } 696 if (A.load.Bool(ptr + 33 + 15)) { 697 x["pinyinFuzzyConfig"]["f_h"] = A.load.Bool(ptr + 33 + 3); 698 } else { 699 delete x["pinyinFuzzyConfig"]["f_h"]; 700 } 701 if (A.load.Bool(ptr + 33 + 16)) { 702 x["pinyinFuzzyConfig"]["ian_iang"] = A.load.Bool(ptr + 33 + 4); 703 } else { 704 delete x["pinyinFuzzyConfig"]["ian_iang"]; 705 } 706 if (A.load.Bool(ptr + 33 + 17)) { 707 x["pinyinFuzzyConfig"]["in_ing"] = A.load.Bool(ptr + 33 + 5); 708 } else { 709 delete x["pinyinFuzzyConfig"]["in_ing"]; 710 } 711 if (A.load.Bool(ptr + 33 + 18)) { 712 x["pinyinFuzzyConfig"]["k_g"] = A.load.Bool(ptr + 33 + 6); 713 } else { 714 delete x["pinyinFuzzyConfig"]["k_g"]; 715 } 716 if (A.load.Bool(ptr + 33 + 19)) { 717 x["pinyinFuzzyConfig"]["l_n"] = A.load.Bool(ptr + 33 + 7); 718 } else { 719 delete x["pinyinFuzzyConfig"]["l_n"]; 720 } 721 if (A.load.Bool(ptr + 33 + 20)) { 722 x["pinyinFuzzyConfig"]["r_l"] = A.load.Bool(ptr + 33 + 8); 723 } else { 724 delete x["pinyinFuzzyConfig"]["r_l"]; 725 } 726 if (A.load.Bool(ptr + 33 + 21)) { 727 x["pinyinFuzzyConfig"]["s_sh"] = A.load.Bool(ptr + 33 + 9); 728 } else { 729 delete x["pinyinFuzzyConfig"]["s_sh"]; 730 } 731 if (A.load.Bool(ptr + 33 + 22)) { 732 x["pinyinFuzzyConfig"]["uan_uang"] = A.load.Bool(ptr + 33 + 10); 733 } else { 734 delete x["pinyinFuzzyConfig"]["uan_uang"]; 735 } 736 if (A.load.Bool(ptr + 33 + 23)) { 737 x["pinyinFuzzyConfig"]["z_zh"] = A.load.Bool(ptr + 33 + 11); 738 } else { 739 delete x["pinyinFuzzyConfig"]["z_zh"]; 740 } 741 } else { 742 delete x["pinyinFuzzyConfig"]; 743 } 744 if (A.load.Bool(ptr + 126)) { 745 x["vietnameseTelexAllowFlexibleDiacritics"] = A.load.Bool(ptr + 58); 746 } else { 747 delete x["vietnameseTelexAllowFlexibleDiacritics"]; 748 } 749 if (A.load.Bool(ptr + 127)) { 750 x["vietnameseTelexInsertDoubleHornOnUo"] = A.load.Bool(ptr + 59); 751 } else { 752 delete x["vietnameseTelexInsertDoubleHornOnUo"]; 753 } 754 if (A.load.Bool(ptr + 128)) { 755 x["vietnameseTelexInsertUHornOnW"] = A.load.Bool(ptr + 60); 756 } else { 757 delete x["vietnameseTelexInsertUHornOnW"]; 758 } 759 if (A.load.Bool(ptr + 129)) { 760 x["vietnameseTelexNewStyleToneMarkPlacement"] = A.load.Bool(ptr + 61); 761 } else { 762 delete x["vietnameseTelexNewStyleToneMarkPlacement"]; 763 } 764 if (A.load.Bool(ptr + 130)) { 765 x["vietnameseTelexShowUnderline"] = A.load.Bool(ptr + 62); 766 } else { 767 delete x["vietnameseTelexShowUnderline"]; 768 } 769 if (A.load.Bool(ptr + 131)) { 770 x["vietnameseVniAllowFlexibleDiacritics"] = A.load.Bool(ptr + 63); 771 } else { 772 delete x["vietnameseVniAllowFlexibleDiacritics"]; 773 } 774 if (A.load.Bool(ptr + 132)) { 775 x["vietnameseVniInsertDoubleHornOnUo"] = A.load.Bool(ptr + 64); 776 } else { 777 delete x["vietnameseVniInsertDoubleHornOnUo"]; 778 } 779 if (A.load.Bool(ptr + 133)) { 780 x["vietnameseVniNewStyleToneMarkPlacement"] = A.load.Bool(ptr + 65); 781 } else { 782 delete x["vietnameseVniNewStyleToneMarkPlacement"]; 783 } 784 if (A.load.Bool(ptr + 134)) { 785 x["vietnameseVniShowUnderline"] = A.load.Bool(ptr + 66); 786 } else { 787 delete x["vietnameseVniShowUnderline"]; 788 } 789 if (A.load.Bool(ptr + 135)) { 790 x["virtualKeyboardAutoCorrectionLevel"] = A.load.Int64(ptr + 72); 791 } else { 792 delete x["virtualKeyboardAutoCorrectionLevel"]; 793 } 794 if (A.load.Bool(ptr + 136)) { 795 x["virtualKeyboardEnableCapitalization"] = A.load.Bool(ptr + 80); 796 } else { 797 delete x["virtualKeyboardEnableCapitalization"]; 798 } 799 x["xkbLayout"] = A.load.Ref(ptr + 84, undefined); 800 x["zhuyinKeyboardLayout"] = A.load.Ref(ptr + 88, undefined); 801 if (A.load.Bool(ptr + 137)) { 802 x["zhuyinPageSize"] = A.load.Int64(ptr + 96); 803 } else { 804 delete x["zhuyinPageSize"]; 805 } 806 x["zhuyinSelectKeys"] = A.load.Ref(ptr + 104, undefined); 807 return create === A.H.TRUE ? A.H.push(x) : ref; 808 }, 809 "constof_MenuItemStyle": (ref: heap.Ref<string>): number => { 810 const idx = ["check", "radio", "separator"].indexOf(A.H.get(ref)); 811 return idx < 0 ? 0 : idx + 1; 812 }, 813 814 "store_MenuItem": (ptr: Pointer, ref: heap.Ref<any>) => { 815 const x = A.H.get<any>(ref); 816 817 if (typeof x === "undefined") { 818 A.store.Bool(ptr + 20, false); 819 A.store.Bool(ptr + 17, false); 820 A.store.Bool(ptr + 0, false); 821 A.store.Bool(ptr + 18, false); 822 A.store.Bool(ptr + 1, false); 823 A.store.Ref(ptr + 4, undefined); 824 A.store.Ref(ptr + 8, undefined); 825 A.store.Enum(ptr + 12, -1); 826 A.store.Bool(ptr + 19, false); 827 A.store.Bool(ptr + 16, false); 828 } else { 829 A.store.Bool(ptr + 20, true); 830 A.store.Bool(ptr + 17, "checked" in x ? true : false); 831 A.store.Bool(ptr + 0, x["checked"] ? true : false); 832 A.store.Bool(ptr + 18, "enabled" in x ? true : false); 833 A.store.Bool(ptr + 1, x["enabled"] ? true : false); 834 A.store.Ref(ptr + 4, x["id"]); 835 A.store.Ref(ptr + 8, x["label"]); 836 A.store.Enum(ptr + 12, ["check", "radio", "separator"].indexOf(x["style"] as string)); 837 A.store.Bool(ptr + 19, "visible" in x ? true : false); 838 A.store.Bool(ptr + 16, x["visible"] ? true : false); 839 } 840 }, 841 "load_MenuItem": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 842 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 843 844 if (A.load.Bool(ptr + 17)) { 845 x["checked"] = A.load.Bool(ptr + 0); 846 } else { 847 delete x["checked"]; 848 } 849 if (A.load.Bool(ptr + 18)) { 850 x["enabled"] = A.load.Bool(ptr + 1); 851 } else { 852 delete x["enabled"]; 853 } 854 x["id"] = A.load.Ref(ptr + 4, undefined); 855 x["label"] = A.load.Ref(ptr + 8, undefined); 856 x["style"] = A.load.Enum(ptr + 12, ["check", "radio", "separator"]); 857 if (A.load.Bool(ptr + 19)) { 858 x["visible"] = A.load.Bool(ptr + 16); 859 } else { 860 delete x["visible"]; 861 } 862 return create === A.H.TRUE ? A.H.push(x) : ref; 863 }, 864 865 "store_OnAutocorrectArgParameters": (ptr: Pointer, ref: heap.Ref<any>) => { 866 const x = A.H.get<any>(ref); 867 868 if (typeof x === "undefined") { 869 A.store.Bool(ptr + 28, false); 870 A.store.Int64(ptr + 0, 0); 871 A.store.Ref(ptr + 8, undefined); 872 A.store.Int64(ptr + 16, 0); 873 A.store.Ref(ptr + 24, undefined); 874 } else { 875 A.store.Bool(ptr + 28, true); 876 A.store.Int64(ptr + 0, x["contextID"] === undefined ? 0 : (x["contextID"] as number)); 877 A.store.Ref(ptr + 8, x["correctedWord"]); 878 A.store.Int64(ptr + 16, x["startIndex"] === undefined ? 0 : (x["startIndex"] as number)); 879 A.store.Ref(ptr + 24, x["typedWord"]); 880 } 881 }, 882 "load_OnAutocorrectArgParameters": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 883 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 884 885 x["contextID"] = A.load.Int64(ptr + 0); 886 x["correctedWord"] = A.load.Ref(ptr + 8, undefined); 887 x["startIndex"] = A.load.Int64(ptr + 16); 888 x["typedWord"] = A.load.Ref(ptr + 24, undefined); 889 return create === A.H.TRUE ? A.H.push(x) : ref; 890 }, 891 892 "store_OnCaretBoundsChangedArgCaretBounds": (ptr: Pointer, ref: heap.Ref<any>) => { 893 const x = A.H.get<any>(ref); 894 895 if (typeof x === "undefined") { 896 A.store.Bool(ptr + 32, false); 897 A.store.Int64(ptr + 0, 0); 898 A.store.Int64(ptr + 8, 0); 899 A.store.Int64(ptr + 16, 0); 900 A.store.Int64(ptr + 24, 0); 901 } else { 902 A.store.Bool(ptr + 32, true); 903 A.store.Int64(ptr + 0, x["h"] === undefined ? 0 : (x["h"] as number)); 904 A.store.Int64(ptr + 8, x["w"] === undefined ? 0 : (x["w"] as number)); 905 A.store.Int64(ptr + 16, x["x"] === undefined ? 0 : (x["x"] as number)); 906 A.store.Int64(ptr + 24, x["y"] === undefined ? 0 : (x["y"] as number)); 907 } 908 }, 909 "load_OnCaretBoundsChangedArgCaretBounds": ( 910 ptr: Pointer, 911 create: heap.Ref<boolean>, 912 ref: heap.Ref<any> 913 ): heap.Ref<any> => { 914 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 915 916 x["h"] = A.load.Int64(ptr + 0); 917 x["w"] = A.load.Int64(ptr + 8); 918 x["x"] = A.load.Int64(ptr + 16); 919 x["y"] = A.load.Int64(ptr + 24); 920 return create === A.H.TRUE ? A.H.push(x) : ref; 921 }, 922 "constof_UnderlineStyle": (ref: heap.Ref<string>): number => { 923 const idx = ["underline", "doubleUnderline", "noUnderline"].indexOf(A.H.get(ref)); 924 return idx < 0 ? 0 : idx + 1; 925 }, 926 927 "store_SetCompositionRangeArgParametersFieldSegmentsElem": (ptr: Pointer, ref: heap.Ref<any>) => { 928 const x = A.H.get<any>(ref); 929 930 if (typeof x === "undefined") { 931 A.store.Bool(ptr + 20, false); 932 A.store.Int64(ptr + 0, 0); 933 A.store.Int64(ptr + 8, 0); 934 A.store.Enum(ptr + 16, -1); 935 } else { 936 A.store.Bool(ptr + 20, true); 937 A.store.Int64(ptr + 0, x["end"] === undefined ? 0 : (x["end"] as number)); 938 A.store.Int64(ptr + 8, x["start"] === undefined ? 0 : (x["start"] as number)); 939 A.store.Enum(ptr + 16, ["underline", "doubleUnderline", "noUnderline"].indexOf(x["style"] as string)); 940 } 941 }, 942 "load_SetCompositionRangeArgParametersFieldSegmentsElem": ( 943 ptr: Pointer, 944 create: heap.Ref<boolean>, 945 ref: heap.Ref<any> 946 ): heap.Ref<any> => { 947 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 948 949 x["end"] = A.load.Int64(ptr + 0); 950 x["start"] = A.load.Int64(ptr + 8); 951 x["style"] = A.load.Enum(ptr + 16, ["underline", "doubleUnderline", "noUnderline"]); 952 return create === A.H.TRUE ? A.H.push(x) : ref; 953 }, 954 955 "store_SetCompositionRangeArgParameters": (ptr: Pointer, ref: heap.Ref<any>) => { 956 const x = A.H.get<any>(ref); 957 958 if (typeof x === "undefined") { 959 A.store.Bool(ptr + 32, false); 960 A.store.Int64(ptr + 0, 0); 961 A.store.Ref(ptr + 8, undefined); 962 A.store.Int64(ptr + 16, 0); 963 A.store.Int64(ptr + 24, 0); 964 } else { 965 A.store.Bool(ptr + 32, true); 966 A.store.Int64(ptr + 0, x["contextID"] === undefined ? 0 : (x["contextID"] as number)); 967 A.store.Ref(ptr + 8, x["segments"]); 968 A.store.Int64(ptr + 16, x["selectionAfter"] === undefined ? 0 : (x["selectionAfter"] as number)); 969 A.store.Int64(ptr + 24, x["selectionBefore"] === undefined ? 0 : (x["selectionBefore"] as number)); 970 } 971 }, 972 "load_SetCompositionRangeArgParameters": ( 973 ptr: Pointer, 974 create: heap.Ref<boolean>, 975 ref: heap.Ref<any> 976 ): heap.Ref<any> => { 977 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 978 979 x["contextID"] = A.load.Int64(ptr + 0); 980 x["segments"] = A.load.Ref(ptr + 8, undefined); 981 x["selectionAfter"] = A.load.Int64(ptr + 16); 982 x["selectionBefore"] = A.load.Int64(ptr + 24); 983 return create === A.H.TRUE ? A.H.push(x) : ref; 984 }, 985 "has_AddWordToDictionary": (): heap.Ref<boolean> => { 986 if (WEBEXT?.inputMethodPrivate && "addWordToDictionary" in WEBEXT?.inputMethodPrivate) { 987 return A.H.TRUE; 988 } 989 return A.H.FALSE; 990 }, 991 "func_AddWordToDictionary": (fn: Pointer): void => { 992 A.store.Ref(fn, WEBEXT.inputMethodPrivate.addWordToDictionary); 993 }, 994 "call_AddWordToDictionary": (retPtr: Pointer, word: heap.Ref<object>): void => { 995 const _ret = WEBEXT.inputMethodPrivate.addWordToDictionary(A.H.get<object>(word)); 996 A.store.Ref(retPtr, _ret); 997 }, 998 "try_AddWordToDictionary": (retPtr: Pointer, errPtr: Pointer, word: heap.Ref<object>): heap.Ref<boolean> => { 999 try { 1000 const _ret = WEBEXT.inputMethodPrivate.addWordToDictionary(A.H.get<object>(word)); 1001 A.store.Ref(retPtr, _ret); 1002 return A.H.TRUE; 1003 } catch (err: any) { 1004 A.store.Ref(errPtr, err); 1005 return A.H.FALSE; 1006 } 1007 }, 1008 "has_FetchAllDictionaryWords": (): heap.Ref<boolean> => { 1009 if (WEBEXT?.inputMethodPrivate && "fetchAllDictionaryWords" in WEBEXT?.inputMethodPrivate) { 1010 return A.H.TRUE; 1011 } 1012 return A.H.FALSE; 1013 }, 1014 "func_FetchAllDictionaryWords": (fn: Pointer): void => { 1015 A.store.Ref(fn, WEBEXT.inputMethodPrivate.fetchAllDictionaryWords); 1016 }, 1017 "call_FetchAllDictionaryWords": (retPtr: Pointer): void => { 1018 const _ret = WEBEXT.inputMethodPrivate.fetchAllDictionaryWords(); 1019 A.store.Ref(retPtr, _ret); 1020 }, 1021 "try_FetchAllDictionaryWords": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 1022 try { 1023 const _ret = WEBEXT.inputMethodPrivate.fetchAllDictionaryWords(); 1024 A.store.Ref(retPtr, _ret); 1025 return A.H.TRUE; 1026 } catch (err: any) { 1027 A.store.Ref(errPtr, err); 1028 return A.H.FALSE; 1029 } 1030 }, 1031 "has_FinishComposingText": (): heap.Ref<boolean> => { 1032 if (WEBEXT?.inputMethodPrivate && "finishComposingText" in WEBEXT?.inputMethodPrivate) { 1033 return A.H.TRUE; 1034 } 1035 return A.H.FALSE; 1036 }, 1037 "func_FinishComposingText": (fn: Pointer): void => { 1038 A.store.Ref(fn, WEBEXT.inputMethodPrivate.finishComposingText); 1039 }, 1040 "call_FinishComposingText": (retPtr: Pointer, parameters: Pointer): void => { 1041 const parameters_ffi = {}; 1042 1043 parameters_ffi["contextID"] = A.load.Int64(parameters + 0); 1044 1045 const _ret = WEBEXT.inputMethodPrivate.finishComposingText(parameters_ffi); 1046 A.store.Ref(retPtr, _ret); 1047 }, 1048 "try_FinishComposingText": (retPtr: Pointer, errPtr: Pointer, parameters: Pointer): heap.Ref<boolean> => { 1049 try { 1050 const parameters_ffi = {}; 1051 1052 parameters_ffi["contextID"] = A.load.Int64(parameters + 0); 1053 1054 const _ret = WEBEXT.inputMethodPrivate.finishComposingText(parameters_ffi); 1055 A.store.Ref(retPtr, _ret); 1056 return A.H.TRUE; 1057 } catch (err: any) { 1058 A.store.Ref(errPtr, err); 1059 return A.H.FALSE; 1060 } 1061 }, 1062 "has_GetCurrentInputMethod": (): heap.Ref<boolean> => { 1063 if (WEBEXT?.inputMethodPrivate && "getCurrentInputMethod" in WEBEXT?.inputMethodPrivate) { 1064 return A.H.TRUE; 1065 } 1066 return A.H.FALSE; 1067 }, 1068 "func_GetCurrentInputMethod": (fn: Pointer): void => { 1069 A.store.Ref(fn, WEBEXT.inputMethodPrivate.getCurrentInputMethod); 1070 }, 1071 "call_GetCurrentInputMethod": (retPtr: Pointer): void => { 1072 const _ret = WEBEXT.inputMethodPrivate.getCurrentInputMethod(); 1073 A.store.Ref(retPtr, _ret); 1074 }, 1075 "try_GetCurrentInputMethod": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 1076 try { 1077 const _ret = WEBEXT.inputMethodPrivate.getCurrentInputMethod(); 1078 A.store.Ref(retPtr, _ret); 1079 return A.H.TRUE; 1080 } catch (err: any) { 1081 A.store.Ref(errPtr, err); 1082 return A.H.FALSE; 1083 } 1084 }, 1085 "has_GetInputMethodConfig": (): heap.Ref<boolean> => { 1086 if (WEBEXT?.inputMethodPrivate && "getInputMethodConfig" in WEBEXT?.inputMethodPrivate) { 1087 return A.H.TRUE; 1088 } 1089 return A.H.FALSE; 1090 }, 1091 "func_GetInputMethodConfig": (fn: Pointer): void => { 1092 A.store.Ref(fn, WEBEXT.inputMethodPrivate.getInputMethodConfig); 1093 }, 1094 "call_GetInputMethodConfig": (retPtr: Pointer): void => { 1095 const _ret = WEBEXT.inputMethodPrivate.getInputMethodConfig(); 1096 A.store.Ref(retPtr, _ret); 1097 }, 1098 "try_GetInputMethodConfig": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 1099 try { 1100 const _ret = WEBEXT.inputMethodPrivate.getInputMethodConfig(); 1101 A.store.Ref(retPtr, _ret); 1102 return A.H.TRUE; 1103 } catch (err: any) { 1104 A.store.Ref(errPtr, err); 1105 return A.H.FALSE; 1106 } 1107 }, 1108 "has_GetInputMethods": (): heap.Ref<boolean> => { 1109 if (WEBEXT?.inputMethodPrivate && "getInputMethods" in WEBEXT?.inputMethodPrivate) { 1110 return A.H.TRUE; 1111 } 1112 return A.H.FALSE; 1113 }, 1114 "func_GetInputMethods": (fn: Pointer): void => { 1115 A.store.Ref(fn, WEBEXT.inputMethodPrivate.getInputMethods); 1116 }, 1117 "call_GetInputMethods": (retPtr: Pointer): void => { 1118 const _ret = WEBEXT.inputMethodPrivate.getInputMethods(); 1119 A.store.Ref(retPtr, _ret); 1120 }, 1121 "try_GetInputMethods": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 1122 try { 1123 const _ret = WEBEXT.inputMethodPrivate.getInputMethods(); 1124 A.store.Ref(retPtr, _ret); 1125 return A.H.TRUE; 1126 } catch (err: any) { 1127 A.store.Ref(errPtr, err); 1128 return A.H.FALSE; 1129 } 1130 }, 1131 "has_GetSettings": (): heap.Ref<boolean> => { 1132 if (WEBEXT?.inputMethodPrivate && "getSettings" in WEBEXT?.inputMethodPrivate) { 1133 return A.H.TRUE; 1134 } 1135 return A.H.FALSE; 1136 }, 1137 "func_GetSettings": (fn: Pointer): void => { 1138 A.store.Ref(fn, WEBEXT.inputMethodPrivate.getSettings); 1139 }, 1140 "call_GetSettings": (retPtr: Pointer, engineID: heap.Ref<object>): void => { 1141 const _ret = WEBEXT.inputMethodPrivate.getSettings(A.H.get<object>(engineID)); 1142 A.store.Ref(retPtr, _ret); 1143 }, 1144 "try_GetSettings": (retPtr: Pointer, errPtr: Pointer, engineID: heap.Ref<object>): heap.Ref<boolean> => { 1145 try { 1146 const _ret = WEBEXT.inputMethodPrivate.getSettings(A.H.get<object>(engineID)); 1147 A.store.Ref(retPtr, _ret); 1148 return A.H.TRUE; 1149 } catch (err: any) { 1150 A.store.Ref(errPtr, err); 1151 return A.H.FALSE; 1152 } 1153 }, 1154 "has_GetSurroundingText": (): heap.Ref<boolean> => { 1155 if (WEBEXT?.inputMethodPrivate && "getSurroundingText" in WEBEXT?.inputMethodPrivate) { 1156 return A.H.TRUE; 1157 } 1158 return A.H.FALSE; 1159 }, 1160 "func_GetSurroundingText": (fn: Pointer): void => { 1161 A.store.Ref(fn, WEBEXT.inputMethodPrivate.getSurroundingText); 1162 }, 1163 "call_GetSurroundingText": (retPtr: Pointer, beforeLength: number, afterLength: number): void => { 1164 const _ret = WEBEXT.inputMethodPrivate.getSurroundingText(beforeLength, afterLength); 1165 A.store.Ref(retPtr, _ret); 1166 }, 1167 "try_GetSurroundingText": ( 1168 retPtr: Pointer, 1169 errPtr: Pointer, 1170 beforeLength: number, 1171 afterLength: number 1172 ): heap.Ref<boolean> => { 1173 try { 1174 const _ret = WEBEXT.inputMethodPrivate.getSurroundingText(beforeLength, afterLength); 1175 A.store.Ref(retPtr, _ret); 1176 return A.H.TRUE; 1177 } catch (err: any) { 1178 A.store.Ref(errPtr, err); 1179 return A.H.FALSE; 1180 } 1181 }, 1182 "has_GetTextFieldBounds": (): heap.Ref<boolean> => { 1183 if (WEBEXT?.inputMethodPrivate && "getTextFieldBounds" in WEBEXT?.inputMethodPrivate) { 1184 return A.H.TRUE; 1185 } 1186 return A.H.FALSE; 1187 }, 1188 "func_GetTextFieldBounds": (fn: Pointer): void => { 1189 A.store.Ref(fn, WEBEXT.inputMethodPrivate.getTextFieldBounds); 1190 }, 1191 "call_GetTextFieldBounds": (retPtr: Pointer, parameters: Pointer): void => { 1192 const parameters_ffi = {}; 1193 1194 parameters_ffi["contextID"] = A.load.Int64(parameters + 0); 1195 1196 const _ret = WEBEXT.inputMethodPrivate.getTextFieldBounds(parameters_ffi); 1197 A.store.Ref(retPtr, _ret); 1198 }, 1199 "try_GetTextFieldBounds": (retPtr: Pointer, errPtr: Pointer, parameters: Pointer): heap.Ref<boolean> => { 1200 try { 1201 const parameters_ffi = {}; 1202 1203 parameters_ffi["contextID"] = A.load.Int64(parameters + 0); 1204 1205 const _ret = WEBEXT.inputMethodPrivate.getTextFieldBounds(parameters_ffi); 1206 A.store.Ref(retPtr, _ret); 1207 return A.H.TRUE; 1208 } catch (err: any) { 1209 A.store.Ref(errPtr, err); 1210 return A.H.FALSE; 1211 } 1212 }, 1213 "has_HideInputView": (): heap.Ref<boolean> => { 1214 if (WEBEXT?.inputMethodPrivate && "hideInputView" in WEBEXT?.inputMethodPrivate) { 1215 return A.H.TRUE; 1216 } 1217 return A.H.FALSE; 1218 }, 1219 "func_HideInputView": (fn: Pointer): void => { 1220 A.store.Ref(fn, WEBEXT.inputMethodPrivate.hideInputView); 1221 }, 1222 "call_HideInputView": (retPtr: Pointer): void => { 1223 const _ret = WEBEXT.inputMethodPrivate.hideInputView(); 1224 A.store.Ref(retPtr, _ret); 1225 }, 1226 "try_HideInputView": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 1227 try { 1228 const _ret = WEBEXT.inputMethodPrivate.hideInputView(); 1229 A.store.Ref(retPtr, _ret); 1230 return A.H.TRUE; 1231 } catch (err: any) { 1232 A.store.Ref(errPtr, err); 1233 return A.H.FALSE; 1234 } 1235 }, 1236 "has_NotifyInputMethodReadyForTesting": (): heap.Ref<boolean> => { 1237 if (WEBEXT?.inputMethodPrivate && "notifyInputMethodReadyForTesting" in WEBEXT?.inputMethodPrivate) { 1238 return A.H.TRUE; 1239 } 1240 return A.H.FALSE; 1241 }, 1242 "func_NotifyInputMethodReadyForTesting": (fn: Pointer): void => { 1243 A.store.Ref(fn, WEBEXT.inputMethodPrivate.notifyInputMethodReadyForTesting); 1244 }, 1245 "call_NotifyInputMethodReadyForTesting": (retPtr: Pointer): void => { 1246 const _ret = WEBEXT.inputMethodPrivate.notifyInputMethodReadyForTesting(); 1247 }, 1248 "try_NotifyInputMethodReadyForTesting": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 1249 try { 1250 const _ret = WEBEXT.inputMethodPrivate.notifyInputMethodReadyForTesting(); 1251 return A.H.TRUE; 1252 } catch (err: any) { 1253 A.store.Ref(errPtr, err); 1254 return A.H.FALSE; 1255 } 1256 }, 1257 "has_OnAutocorrect": (): heap.Ref<boolean> => { 1258 if (WEBEXT?.inputMethodPrivate && "onAutocorrect" in WEBEXT?.inputMethodPrivate) { 1259 return A.H.TRUE; 1260 } 1261 return A.H.FALSE; 1262 }, 1263 "func_OnAutocorrect": (fn: Pointer): void => { 1264 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onAutocorrect); 1265 }, 1266 "call_OnAutocorrect": (retPtr: Pointer, parameters: Pointer): void => { 1267 const parameters_ffi = {}; 1268 1269 parameters_ffi["contextID"] = A.load.Int64(parameters + 0); 1270 parameters_ffi["correctedWord"] = A.load.Ref(parameters + 8, undefined); 1271 parameters_ffi["startIndex"] = A.load.Int64(parameters + 16); 1272 parameters_ffi["typedWord"] = A.load.Ref(parameters + 24, undefined); 1273 1274 const _ret = WEBEXT.inputMethodPrivate.onAutocorrect(parameters_ffi); 1275 }, 1276 "try_OnAutocorrect": (retPtr: Pointer, errPtr: Pointer, parameters: Pointer): heap.Ref<boolean> => { 1277 try { 1278 const parameters_ffi = {}; 1279 1280 parameters_ffi["contextID"] = A.load.Int64(parameters + 0); 1281 parameters_ffi["correctedWord"] = A.load.Ref(parameters + 8, undefined); 1282 parameters_ffi["startIndex"] = A.load.Int64(parameters + 16); 1283 parameters_ffi["typedWord"] = A.load.Ref(parameters + 24, undefined); 1284 1285 const _ret = WEBEXT.inputMethodPrivate.onAutocorrect(parameters_ffi); 1286 return A.H.TRUE; 1287 } catch (err: any) { 1288 A.store.Ref(errPtr, err); 1289 return A.H.FALSE; 1290 } 1291 }, 1292 "has_OnCaretBoundsChanged": (): heap.Ref<boolean> => { 1293 if ( 1294 WEBEXT?.inputMethodPrivate?.onCaretBoundsChanged && 1295 "addListener" in WEBEXT?.inputMethodPrivate?.onCaretBoundsChanged 1296 ) { 1297 return A.H.TRUE; 1298 } 1299 return A.H.FALSE; 1300 }, 1301 "func_OnCaretBoundsChanged": (fn: Pointer): void => { 1302 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onCaretBoundsChanged.addListener); 1303 }, 1304 "call_OnCaretBoundsChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1305 const _ret = WEBEXT.inputMethodPrivate.onCaretBoundsChanged.addListener(A.H.get<object>(callback)); 1306 }, 1307 "try_OnCaretBoundsChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1308 try { 1309 const _ret = WEBEXT.inputMethodPrivate.onCaretBoundsChanged.addListener(A.H.get<object>(callback)); 1310 return A.H.TRUE; 1311 } catch (err: any) { 1312 A.store.Ref(errPtr, err); 1313 return A.H.FALSE; 1314 } 1315 }, 1316 "has_OffCaretBoundsChanged": (): heap.Ref<boolean> => { 1317 if ( 1318 WEBEXT?.inputMethodPrivate?.onCaretBoundsChanged && 1319 "removeListener" in WEBEXT?.inputMethodPrivate?.onCaretBoundsChanged 1320 ) { 1321 return A.H.TRUE; 1322 } 1323 return A.H.FALSE; 1324 }, 1325 "func_OffCaretBoundsChanged": (fn: Pointer): void => { 1326 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onCaretBoundsChanged.removeListener); 1327 }, 1328 "call_OffCaretBoundsChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1329 const _ret = WEBEXT.inputMethodPrivate.onCaretBoundsChanged.removeListener(A.H.get<object>(callback)); 1330 }, 1331 "try_OffCaretBoundsChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1332 try { 1333 const _ret = WEBEXT.inputMethodPrivate.onCaretBoundsChanged.removeListener(A.H.get<object>(callback)); 1334 return A.H.TRUE; 1335 } catch (err: any) { 1336 A.store.Ref(errPtr, err); 1337 return A.H.FALSE; 1338 } 1339 }, 1340 "has_HasOnCaretBoundsChanged": (): heap.Ref<boolean> => { 1341 if ( 1342 WEBEXT?.inputMethodPrivate?.onCaretBoundsChanged && 1343 "hasListener" in WEBEXT?.inputMethodPrivate?.onCaretBoundsChanged 1344 ) { 1345 return A.H.TRUE; 1346 } 1347 return A.H.FALSE; 1348 }, 1349 "func_HasOnCaretBoundsChanged": (fn: Pointer): void => { 1350 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onCaretBoundsChanged.hasListener); 1351 }, 1352 "call_HasOnCaretBoundsChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1353 const _ret = WEBEXT.inputMethodPrivate.onCaretBoundsChanged.hasListener(A.H.get<object>(callback)); 1354 A.store.Bool(retPtr, _ret); 1355 }, 1356 "try_HasOnCaretBoundsChanged": ( 1357 retPtr: Pointer, 1358 errPtr: Pointer, 1359 callback: heap.Ref<object> 1360 ): heap.Ref<boolean> => { 1361 try { 1362 const _ret = WEBEXT.inputMethodPrivate.onCaretBoundsChanged.hasListener(A.H.get<object>(callback)); 1363 A.store.Bool(retPtr, _ret); 1364 return A.H.TRUE; 1365 } catch (err: any) { 1366 A.store.Ref(errPtr, err); 1367 return A.H.FALSE; 1368 } 1369 }, 1370 "has_OnChanged": (): heap.Ref<boolean> => { 1371 if (WEBEXT?.inputMethodPrivate?.onChanged && "addListener" in WEBEXT?.inputMethodPrivate?.onChanged) { 1372 return A.H.TRUE; 1373 } 1374 return A.H.FALSE; 1375 }, 1376 "func_OnChanged": (fn: Pointer): void => { 1377 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onChanged.addListener); 1378 }, 1379 "call_OnChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1380 const _ret = WEBEXT.inputMethodPrivate.onChanged.addListener(A.H.get<object>(callback)); 1381 }, 1382 "try_OnChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1383 try { 1384 const _ret = WEBEXT.inputMethodPrivate.onChanged.addListener(A.H.get<object>(callback)); 1385 return A.H.TRUE; 1386 } catch (err: any) { 1387 A.store.Ref(errPtr, err); 1388 return A.H.FALSE; 1389 } 1390 }, 1391 "has_OffChanged": (): heap.Ref<boolean> => { 1392 if (WEBEXT?.inputMethodPrivate?.onChanged && "removeListener" in WEBEXT?.inputMethodPrivate?.onChanged) { 1393 return A.H.TRUE; 1394 } 1395 return A.H.FALSE; 1396 }, 1397 "func_OffChanged": (fn: Pointer): void => { 1398 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onChanged.removeListener); 1399 }, 1400 "call_OffChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1401 const _ret = WEBEXT.inputMethodPrivate.onChanged.removeListener(A.H.get<object>(callback)); 1402 }, 1403 "try_OffChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1404 try { 1405 const _ret = WEBEXT.inputMethodPrivate.onChanged.removeListener(A.H.get<object>(callback)); 1406 return A.H.TRUE; 1407 } catch (err: any) { 1408 A.store.Ref(errPtr, err); 1409 return A.H.FALSE; 1410 } 1411 }, 1412 "has_HasOnChanged": (): heap.Ref<boolean> => { 1413 if (WEBEXT?.inputMethodPrivate?.onChanged && "hasListener" in WEBEXT?.inputMethodPrivate?.onChanged) { 1414 return A.H.TRUE; 1415 } 1416 return A.H.FALSE; 1417 }, 1418 "func_HasOnChanged": (fn: Pointer): void => { 1419 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onChanged.hasListener); 1420 }, 1421 "call_HasOnChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1422 const _ret = WEBEXT.inputMethodPrivate.onChanged.hasListener(A.H.get<object>(callback)); 1423 A.store.Bool(retPtr, _ret); 1424 }, 1425 "try_HasOnChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1426 try { 1427 const _ret = WEBEXT.inputMethodPrivate.onChanged.hasListener(A.H.get<object>(callback)); 1428 A.store.Bool(retPtr, _ret); 1429 return A.H.TRUE; 1430 } catch (err: any) { 1431 A.store.Ref(errPtr, err); 1432 return A.H.FALSE; 1433 } 1434 }, 1435 "has_OnDictionaryChanged": (): heap.Ref<boolean> => { 1436 if ( 1437 WEBEXT?.inputMethodPrivate?.onDictionaryChanged && 1438 "addListener" in WEBEXT?.inputMethodPrivate?.onDictionaryChanged 1439 ) { 1440 return A.H.TRUE; 1441 } 1442 return A.H.FALSE; 1443 }, 1444 "func_OnDictionaryChanged": (fn: Pointer): void => { 1445 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onDictionaryChanged.addListener); 1446 }, 1447 "call_OnDictionaryChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1448 const _ret = WEBEXT.inputMethodPrivate.onDictionaryChanged.addListener(A.H.get<object>(callback)); 1449 }, 1450 "try_OnDictionaryChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1451 try { 1452 const _ret = WEBEXT.inputMethodPrivate.onDictionaryChanged.addListener(A.H.get<object>(callback)); 1453 return A.H.TRUE; 1454 } catch (err: any) { 1455 A.store.Ref(errPtr, err); 1456 return A.H.FALSE; 1457 } 1458 }, 1459 "has_OffDictionaryChanged": (): heap.Ref<boolean> => { 1460 if ( 1461 WEBEXT?.inputMethodPrivate?.onDictionaryChanged && 1462 "removeListener" in WEBEXT?.inputMethodPrivate?.onDictionaryChanged 1463 ) { 1464 return A.H.TRUE; 1465 } 1466 return A.H.FALSE; 1467 }, 1468 "func_OffDictionaryChanged": (fn: Pointer): void => { 1469 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onDictionaryChanged.removeListener); 1470 }, 1471 "call_OffDictionaryChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1472 const _ret = WEBEXT.inputMethodPrivate.onDictionaryChanged.removeListener(A.H.get<object>(callback)); 1473 }, 1474 "try_OffDictionaryChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1475 try { 1476 const _ret = WEBEXT.inputMethodPrivate.onDictionaryChanged.removeListener(A.H.get<object>(callback)); 1477 return A.H.TRUE; 1478 } catch (err: any) { 1479 A.store.Ref(errPtr, err); 1480 return A.H.FALSE; 1481 } 1482 }, 1483 "has_HasOnDictionaryChanged": (): heap.Ref<boolean> => { 1484 if ( 1485 WEBEXT?.inputMethodPrivate?.onDictionaryChanged && 1486 "hasListener" in WEBEXT?.inputMethodPrivate?.onDictionaryChanged 1487 ) { 1488 return A.H.TRUE; 1489 } 1490 return A.H.FALSE; 1491 }, 1492 "func_HasOnDictionaryChanged": (fn: Pointer): void => { 1493 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onDictionaryChanged.hasListener); 1494 }, 1495 "call_HasOnDictionaryChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1496 const _ret = WEBEXT.inputMethodPrivate.onDictionaryChanged.hasListener(A.H.get<object>(callback)); 1497 A.store.Bool(retPtr, _ret); 1498 }, 1499 "try_HasOnDictionaryChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1500 try { 1501 const _ret = WEBEXT.inputMethodPrivate.onDictionaryChanged.hasListener(A.H.get<object>(callback)); 1502 A.store.Bool(retPtr, _ret); 1503 return A.H.TRUE; 1504 } catch (err: any) { 1505 A.store.Ref(errPtr, err); 1506 return A.H.FALSE; 1507 } 1508 }, 1509 "has_OnDictionaryLoaded": (): heap.Ref<boolean> => { 1510 if ( 1511 WEBEXT?.inputMethodPrivate?.onDictionaryLoaded && 1512 "addListener" in WEBEXT?.inputMethodPrivate?.onDictionaryLoaded 1513 ) { 1514 return A.H.TRUE; 1515 } 1516 return A.H.FALSE; 1517 }, 1518 "func_OnDictionaryLoaded": (fn: Pointer): void => { 1519 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onDictionaryLoaded.addListener); 1520 }, 1521 "call_OnDictionaryLoaded": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1522 const _ret = WEBEXT.inputMethodPrivate.onDictionaryLoaded.addListener(A.H.get<object>(callback)); 1523 }, 1524 "try_OnDictionaryLoaded": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1525 try { 1526 const _ret = WEBEXT.inputMethodPrivate.onDictionaryLoaded.addListener(A.H.get<object>(callback)); 1527 return A.H.TRUE; 1528 } catch (err: any) { 1529 A.store.Ref(errPtr, err); 1530 return A.H.FALSE; 1531 } 1532 }, 1533 "has_OffDictionaryLoaded": (): heap.Ref<boolean> => { 1534 if ( 1535 WEBEXT?.inputMethodPrivate?.onDictionaryLoaded && 1536 "removeListener" in WEBEXT?.inputMethodPrivate?.onDictionaryLoaded 1537 ) { 1538 return A.H.TRUE; 1539 } 1540 return A.H.FALSE; 1541 }, 1542 "func_OffDictionaryLoaded": (fn: Pointer): void => { 1543 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onDictionaryLoaded.removeListener); 1544 }, 1545 "call_OffDictionaryLoaded": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1546 const _ret = WEBEXT.inputMethodPrivate.onDictionaryLoaded.removeListener(A.H.get<object>(callback)); 1547 }, 1548 "try_OffDictionaryLoaded": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1549 try { 1550 const _ret = WEBEXT.inputMethodPrivate.onDictionaryLoaded.removeListener(A.H.get<object>(callback)); 1551 return A.H.TRUE; 1552 } catch (err: any) { 1553 A.store.Ref(errPtr, err); 1554 return A.H.FALSE; 1555 } 1556 }, 1557 "has_HasOnDictionaryLoaded": (): heap.Ref<boolean> => { 1558 if ( 1559 WEBEXT?.inputMethodPrivate?.onDictionaryLoaded && 1560 "hasListener" in WEBEXT?.inputMethodPrivate?.onDictionaryLoaded 1561 ) { 1562 return A.H.TRUE; 1563 } 1564 return A.H.FALSE; 1565 }, 1566 "func_HasOnDictionaryLoaded": (fn: Pointer): void => { 1567 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onDictionaryLoaded.hasListener); 1568 }, 1569 "call_HasOnDictionaryLoaded": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1570 const _ret = WEBEXT.inputMethodPrivate.onDictionaryLoaded.hasListener(A.H.get<object>(callback)); 1571 A.store.Bool(retPtr, _ret); 1572 }, 1573 "try_HasOnDictionaryLoaded": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1574 try { 1575 const _ret = WEBEXT.inputMethodPrivate.onDictionaryLoaded.hasListener(A.H.get<object>(callback)); 1576 A.store.Bool(retPtr, _ret); 1577 return A.H.TRUE; 1578 } catch (err: any) { 1579 A.store.Ref(errPtr, err); 1580 return A.H.FALSE; 1581 } 1582 }, 1583 "has_OnFocus": (): heap.Ref<boolean> => { 1584 if (WEBEXT?.inputMethodPrivate?.onFocus && "addListener" in WEBEXT?.inputMethodPrivate?.onFocus) { 1585 return A.H.TRUE; 1586 } 1587 return A.H.FALSE; 1588 }, 1589 "func_OnFocus": (fn: Pointer): void => { 1590 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onFocus.addListener); 1591 }, 1592 "call_OnFocus": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1593 const _ret = WEBEXT.inputMethodPrivate.onFocus.addListener(A.H.get<object>(callback)); 1594 }, 1595 "try_OnFocus": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1596 try { 1597 const _ret = WEBEXT.inputMethodPrivate.onFocus.addListener(A.H.get<object>(callback)); 1598 return A.H.TRUE; 1599 } catch (err: any) { 1600 A.store.Ref(errPtr, err); 1601 return A.H.FALSE; 1602 } 1603 }, 1604 "has_OffFocus": (): heap.Ref<boolean> => { 1605 if (WEBEXT?.inputMethodPrivate?.onFocus && "removeListener" in WEBEXT?.inputMethodPrivate?.onFocus) { 1606 return A.H.TRUE; 1607 } 1608 return A.H.FALSE; 1609 }, 1610 "func_OffFocus": (fn: Pointer): void => { 1611 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onFocus.removeListener); 1612 }, 1613 "call_OffFocus": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1614 const _ret = WEBEXT.inputMethodPrivate.onFocus.removeListener(A.H.get<object>(callback)); 1615 }, 1616 "try_OffFocus": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1617 try { 1618 const _ret = WEBEXT.inputMethodPrivate.onFocus.removeListener(A.H.get<object>(callback)); 1619 return A.H.TRUE; 1620 } catch (err: any) { 1621 A.store.Ref(errPtr, err); 1622 return A.H.FALSE; 1623 } 1624 }, 1625 "has_HasOnFocus": (): heap.Ref<boolean> => { 1626 if (WEBEXT?.inputMethodPrivate?.onFocus && "hasListener" in WEBEXT?.inputMethodPrivate?.onFocus) { 1627 return A.H.TRUE; 1628 } 1629 return A.H.FALSE; 1630 }, 1631 "func_HasOnFocus": (fn: Pointer): void => { 1632 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onFocus.hasListener); 1633 }, 1634 "call_HasOnFocus": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1635 const _ret = WEBEXT.inputMethodPrivate.onFocus.hasListener(A.H.get<object>(callback)); 1636 A.store.Bool(retPtr, _ret); 1637 }, 1638 "try_HasOnFocus": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1639 try { 1640 const _ret = WEBEXT.inputMethodPrivate.onFocus.hasListener(A.H.get<object>(callback)); 1641 A.store.Bool(retPtr, _ret); 1642 return A.H.TRUE; 1643 } catch (err: any) { 1644 A.store.Ref(errPtr, err); 1645 return A.H.FALSE; 1646 } 1647 }, 1648 "has_OnImeMenuActivationChanged": (): heap.Ref<boolean> => { 1649 if ( 1650 WEBEXT?.inputMethodPrivate?.onImeMenuActivationChanged && 1651 "addListener" in WEBEXT?.inputMethodPrivate?.onImeMenuActivationChanged 1652 ) { 1653 return A.H.TRUE; 1654 } 1655 return A.H.FALSE; 1656 }, 1657 "func_OnImeMenuActivationChanged": (fn: Pointer): void => { 1658 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onImeMenuActivationChanged.addListener); 1659 }, 1660 "call_OnImeMenuActivationChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1661 const _ret = WEBEXT.inputMethodPrivate.onImeMenuActivationChanged.addListener(A.H.get<object>(callback)); 1662 }, 1663 "try_OnImeMenuActivationChanged": ( 1664 retPtr: Pointer, 1665 errPtr: Pointer, 1666 callback: heap.Ref<object> 1667 ): heap.Ref<boolean> => { 1668 try { 1669 const _ret = WEBEXT.inputMethodPrivate.onImeMenuActivationChanged.addListener(A.H.get<object>(callback)); 1670 return A.H.TRUE; 1671 } catch (err: any) { 1672 A.store.Ref(errPtr, err); 1673 return A.H.FALSE; 1674 } 1675 }, 1676 "has_OffImeMenuActivationChanged": (): heap.Ref<boolean> => { 1677 if ( 1678 WEBEXT?.inputMethodPrivate?.onImeMenuActivationChanged && 1679 "removeListener" in WEBEXT?.inputMethodPrivate?.onImeMenuActivationChanged 1680 ) { 1681 return A.H.TRUE; 1682 } 1683 return A.H.FALSE; 1684 }, 1685 "func_OffImeMenuActivationChanged": (fn: Pointer): void => { 1686 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onImeMenuActivationChanged.removeListener); 1687 }, 1688 "call_OffImeMenuActivationChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1689 const _ret = WEBEXT.inputMethodPrivate.onImeMenuActivationChanged.removeListener(A.H.get<object>(callback)); 1690 }, 1691 "try_OffImeMenuActivationChanged": ( 1692 retPtr: Pointer, 1693 errPtr: Pointer, 1694 callback: heap.Ref<object> 1695 ): heap.Ref<boolean> => { 1696 try { 1697 const _ret = WEBEXT.inputMethodPrivate.onImeMenuActivationChanged.removeListener(A.H.get<object>(callback)); 1698 return A.H.TRUE; 1699 } catch (err: any) { 1700 A.store.Ref(errPtr, err); 1701 return A.H.FALSE; 1702 } 1703 }, 1704 "has_HasOnImeMenuActivationChanged": (): heap.Ref<boolean> => { 1705 if ( 1706 WEBEXT?.inputMethodPrivate?.onImeMenuActivationChanged && 1707 "hasListener" in WEBEXT?.inputMethodPrivate?.onImeMenuActivationChanged 1708 ) { 1709 return A.H.TRUE; 1710 } 1711 return A.H.FALSE; 1712 }, 1713 "func_HasOnImeMenuActivationChanged": (fn: Pointer): void => { 1714 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onImeMenuActivationChanged.hasListener); 1715 }, 1716 "call_HasOnImeMenuActivationChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1717 const _ret = WEBEXT.inputMethodPrivate.onImeMenuActivationChanged.hasListener(A.H.get<object>(callback)); 1718 A.store.Bool(retPtr, _ret); 1719 }, 1720 "try_HasOnImeMenuActivationChanged": ( 1721 retPtr: Pointer, 1722 errPtr: Pointer, 1723 callback: heap.Ref<object> 1724 ): heap.Ref<boolean> => { 1725 try { 1726 const _ret = WEBEXT.inputMethodPrivate.onImeMenuActivationChanged.hasListener(A.H.get<object>(callback)); 1727 A.store.Bool(retPtr, _ret); 1728 return A.H.TRUE; 1729 } catch (err: any) { 1730 A.store.Ref(errPtr, err); 1731 return A.H.FALSE; 1732 } 1733 }, 1734 "has_OnImeMenuItemsChanged": (): heap.Ref<boolean> => { 1735 if ( 1736 WEBEXT?.inputMethodPrivate?.onImeMenuItemsChanged && 1737 "addListener" in WEBEXT?.inputMethodPrivate?.onImeMenuItemsChanged 1738 ) { 1739 return A.H.TRUE; 1740 } 1741 return A.H.FALSE; 1742 }, 1743 "func_OnImeMenuItemsChanged": (fn: Pointer): void => { 1744 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onImeMenuItemsChanged.addListener); 1745 }, 1746 "call_OnImeMenuItemsChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1747 const _ret = WEBEXT.inputMethodPrivate.onImeMenuItemsChanged.addListener(A.H.get<object>(callback)); 1748 }, 1749 "try_OnImeMenuItemsChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1750 try { 1751 const _ret = WEBEXT.inputMethodPrivate.onImeMenuItemsChanged.addListener(A.H.get<object>(callback)); 1752 return A.H.TRUE; 1753 } catch (err: any) { 1754 A.store.Ref(errPtr, err); 1755 return A.H.FALSE; 1756 } 1757 }, 1758 "has_OffImeMenuItemsChanged": (): heap.Ref<boolean> => { 1759 if ( 1760 WEBEXT?.inputMethodPrivate?.onImeMenuItemsChanged && 1761 "removeListener" in WEBEXT?.inputMethodPrivate?.onImeMenuItemsChanged 1762 ) { 1763 return A.H.TRUE; 1764 } 1765 return A.H.FALSE; 1766 }, 1767 "func_OffImeMenuItemsChanged": (fn: Pointer): void => { 1768 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onImeMenuItemsChanged.removeListener); 1769 }, 1770 "call_OffImeMenuItemsChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1771 const _ret = WEBEXT.inputMethodPrivate.onImeMenuItemsChanged.removeListener(A.H.get<object>(callback)); 1772 }, 1773 "try_OffImeMenuItemsChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1774 try { 1775 const _ret = WEBEXT.inputMethodPrivate.onImeMenuItemsChanged.removeListener(A.H.get<object>(callback)); 1776 return A.H.TRUE; 1777 } catch (err: any) { 1778 A.store.Ref(errPtr, err); 1779 return A.H.FALSE; 1780 } 1781 }, 1782 "has_HasOnImeMenuItemsChanged": (): heap.Ref<boolean> => { 1783 if ( 1784 WEBEXT?.inputMethodPrivate?.onImeMenuItemsChanged && 1785 "hasListener" in WEBEXT?.inputMethodPrivate?.onImeMenuItemsChanged 1786 ) { 1787 return A.H.TRUE; 1788 } 1789 return A.H.FALSE; 1790 }, 1791 "func_HasOnImeMenuItemsChanged": (fn: Pointer): void => { 1792 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onImeMenuItemsChanged.hasListener); 1793 }, 1794 "call_HasOnImeMenuItemsChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1795 const _ret = WEBEXT.inputMethodPrivate.onImeMenuItemsChanged.hasListener(A.H.get<object>(callback)); 1796 A.store.Bool(retPtr, _ret); 1797 }, 1798 "try_HasOnImeMenuItemsChanged": ( 1799 retPtr: Pointer, 1800 errPtr: Pointer, 1801 callback: heap.Ref<object> 1802 ): heap.Ref<boolean> => { 1803 try { 1804 const _ret = WEBEXT.inputMethodPrivate.onImeMenuItemsChanged.hasListener(A.H.get<object>(callback)); 1805 A.store.Bool(retPtr, _ret); 1806 return A.H.TRUE; 1807 } catch (err: any) { 1808 A.store.Ref(errPtr, err); 1809 return A.H.FALSE; 1810 } 1811 }, 1812 "has_OnImeMenuListChanged": (): heap.Ref<boolean> => { 1813 if ( 1814 WEBEXT?.inputMethodPrivate?.onImeMenuListChanged && 1815 "addListener" in WEBEXT?.inputMethodPrivate?.onImeMenuListChanged 1816 ) { 1817 return A.H.TRUE; 1818 } 1819 return A.H.FALSE; 1820 }, 1821 "func_OnImeMenuListChanged": (fn: Pointer): void => { 1822 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onImeMenuListChanged.addListener); 1823 }, 1824 "call_OnImeMenuListChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1825 const _ret = WEBEXT.inputMethodPrivate.onImeMenuListChanged.addListener(A.H.get<object>(callback)); 1826 }, 1827 "try_OnImeMenuListChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1828 try { 1829 const _ret = WEBEXT.inputMethodPrivate.onImeMenuListChanged.addListener(A.H.get<object>(callback)); 1830 return A.H.TRUE; 1831 } catch (err: any) { 1832 A.store.Ref(errPtr, err); 1833 return A.H.FALSE; 1834 } 1835 }, 1836 "has_OffImeMenuListChanged": (): heap.Ref<boolean> => { 1837 if ( 1838 WEBEXT?.inputMethodPrivate?.onImeMenuListChanged && 1839 "removeListener" in WEBEXT?.inputMethodPrivate?.onImeMenuListChanged 1840 ) { 1841 return A.H.TRUE; 1842 } 1843 return A.H.FALSE; 1844 }, 1845 "func_OffImeMenuListChanged": (fn: Pointer): void => { 1846 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onImeMenuListChanged.removeListener); 1847 }, 1848 "call_OffImeMenuListChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1849 const _ret = WEBEXT.inputMethodPrivate.onImeMenuListChanged.removeListener(A.H.get<object>(callback)); 1850 }, 1851 "try_OffImeMenuListChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1852 try { 1853 const _ret = WEBEXT.inputMethodPrivate.onImeMenuListChanged.removeListener(A.H.get<object>(callback)); 1854 return A.H.TRUE; 1855 } catch (err: any) { 1856 A.store.Ref(errPtr, err); 1857 return A.H.FALSE; 1858 } 1859 }, 1860 "has_HasOnImeMenuListChanged": (): heap.Ref<boolean> => { 1861 if ( 1862 WEBEXT?.inputMethodPrivate?.onImeMenuListChanged && 1863 "hasListener" in WEBEXT?.inputMethodPrivate?.onImeMenuListChanged 1864 ) { 1865 return A.H.TRUE; 1866 } 1867 return A.H.FALSE; 1868 }, 1869 "func_HasOnImeMenuListChanged": (fn: Pointer): void => { 1870 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onImeMenuListChanged.hasListener); 1871 }, 1872 "call_HasOnImeMenuListChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1873 const _ret = WEBEXT.inputMethodPrivate.onImeMenuListChanged.hasListener(A.H.get<object>(callback)); 1874 A.store.Bool(retPtr, _ret); 1875 }, 1876 "try_HasOnImeMenuListChanged": ( 1877 retPtr: Pointer, 1878 errPtr: Pointer, 1879 callback: heap.Ref<object> 1880 ): heap.Ref<boolean> => { 1881 try { 1882 const _ret = WEBEXT.inputMethodPrivate.onImeMenuListChanged.hasListener(A.H.get<object>(callback)); 1883 A.store.Bool(retPtr, _ret); 1884 return A.H.TRUE; 1885 } catch (err: any) { 1886 A.store.Ref(errPtr, err); 1887 return A.H.FALSE; 1888 } 1889 }, 1890 "has_OnInputMethodOptionsChanged": (): heap.Ref<boolean> => { 1891 if ( 1892 WEBEXT?.inputMethodPrivate?.onInputMethodOptionsChanged && 1893 "addListener" in WEBEXT?.inputMethodPrivate?.onInputMethodOptionsChanged 1894 ) { 1895 return A.H.TRUE; 1896 } 1897 return A.H.FALSE; 1898 }, 1899 "func_OnInputMethodOptionsChanged": (fn: Pointer): void => { 1900 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onInputMethodOptionsChanged.addListener); 1901 }, 1902 "call_OnInputMethodOptionsChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1903 const _ret = WEBEXT.inputMethodPrivate.onInputMethodOptionsChanged.addListener(A.H.get<object>(callback)); 1904 }, 1905 "try_OnInputMethodOptionsChanged": ( 1906 retPtr: Pointer, 1907 errPtr: Pointer, 1908 callback: heap.Ref<object> 1909 ): heap.Ref<boolean> => { 1910 try { 1911 const _ret = WEBEXT.inputMethodPrivate.onInputMethodOptionsChanged.addListener(A.H.get<object>(callback)); 1912 return A.H.TRUE; 1913 } catch (err: any) { 1914 A.store.Ref(errPtr, err); 1915 return A.H.FALSE; 1916 } 1917 }, 1918 "has_OffInputMethodOptionsChanged": (): heap.Ref<boolean> => { 1919 if ( 1920 WEBEXT?.inputMethodPrivate?.onInputMethodOptionsChanged && 1921 "removeListener" in WEBEXT?.inputMethodPrivate?.onInputMethodOptionsChanged 1922 ) { 1923 return A.H.TRUE; 1924 } 1925 return A.H.FALSE; 1926 }, 1927 "func_OffInputMethodOptionsChanged": (fn: Pointer): void => { 1928 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onInputMethodOptionsChanged.removeListener); 1929 }, 1930 "call_OffInputMethodOptionsChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1931 const _ret = WEBEXT.inputMethodPrivate.onInputMethodOptionsChanged.removeListener(A.H.get<object>(callback)); 1932 }, 1933 "try_OffInputMethodOptionsChanged": ( 1934 retPtr: Pointer, 1935 errPtr: Pointer, 1936 callback: heap.Ref<object> 1937 ): heap.Ref<boolean> => { 1938 try { 1939 const _ret = WEBEXT.inputMethodPrivate.onInputMethodOptionsChanged.removeListener(A.H.get<object>(callback)); 1940 return A.H.TRUE; 1941 } catch (err: any) { 1942 A.store.Ref(errPtr, err); 1943 return A.H.FALSE; 1944 } 1945 }, 1946 "has_HasOnInputMethodOptionsChanged": (): heap.Ref<boolean> => { 1947 if ( 1948 WEBEXT?.inputMethodPrivate?.onInputMethodOptionsChanged && 1949 "hasListener" in WEBEXT?.inputMethodPrivate?.onInputMethodOptionsChanged 1950 ) { 1951 return A.H.TRUE; 1952 } 1953 return A.H.FALSE; 1954 }, 1955 "func_HasOnInputMethodOptionsChanged": (fn: Pointer): void => { 1956 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onInputMethodOptionsChanged.hasListener); 1957 }, 1958 "call_HasOnInputMethodOptionsChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1959 const _ret = WEBEXT.inputMethodPrivate.onInputMethodOptionsChanged.hasListener(A.H.get<object>(callback)); 1960 A.store.Bool(retPtr, _ret); 1961 }, 1962 "try_HasOnInputMethodOptionsChanged": ( 1963 retPtr: Pointer, 1964 errPtr: Pointer, 1965 callback: heap.Ref<object> 1966 ): heap.Ref<boolean> => { 1967 try { 1968 const _ret = WEBEXT.inputMethodPrivate.onInputMethodOptionsChanged.hasListener(A.H.get<object>(callback)); 1969 A.store.Bool(retPtr, _ret); 1970 return A.H.TRUE; 1971 } catch (err: any) { 1972 A.store.Ref(errPtr, err); 1973 return A.H.FALSE; 1974 } 1975 }, 1976 "has_OnScreenProjectionChanged": (): heap.Ref<boolean> => { 1977 if ( 1978 WEBEXT?.inputMethodPrivate?.onScreenProjectionChanged && 1979 "addListener" in WEBEXT?.inputMethodPrivate?.onScreenProjectionChanged 1980 ) { 1981 return A.H.TRUE; 1982 } 1983 return A.H.FALSE; 1984 }, 1985 "func_OnScreenProjectionChanged": (fn: Pointer): void => { 1986 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onScreenProjectionChanged.addListener); 1987 }, 1988 "call_OnScreenProjectionChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1989 const _ret = WEBEXT.inputMethodPrivate.onScreenProjectionChanged.addListener(A.H.get<object>(callback)); 1990 }, 1991 "try_OnScreenProjectionChanged": ( 1992 retPtr: Pointer, 1993 errPtr: Pointer, 1994 callback: heap.Ref<object> 1995 ): heap.Ref<boolean> => { 1996 try { 1997 const _ret = WEBEXT.inputMethodPrivate.onScreenProjectionChanged.addListener(A.H.get<object>(callback)); 1998 return A.H.TRUE; 1999 } catch (err: any) { 2000 A.store.Ref(errPtr, err); 2001 return A.H.FALSE; 2002 } 2003 }, 2004 "has_OffScreenProjectionChanged": (): heap.Ref<boolean> => { 2005 if ( 2006 WEBEXT?.inputMethodPrivate?.onScreenProjectionChanged && 2007 "removeListener" in WEBEXT?.inputMethodPrivate?.onScreenProjectionChanged 2008 ) { 2009 return A.H.TRUE; 2010 } 2011 return A.H.FALSE; 2012 }, 2013 "func_OffScreenProjectionChanged": (fn: Pointer): void => { 2014 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onScreenProjectionChanged.removeListener); 2015 }, 2016 "call_OffScreenProjectionChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2017 const _ret = WEBEXT.inputMethodPrivate.onScreenProjectionChanged.removeListener(A.H.get<object>(callback)); 2018 }, 2019 "try_OffScreenProjectionChanged": ( 2020 retPtr: Pointer, 2021 errPtr: Pointer, 2022 callback: heap.Ref<object> 2023 ): heap.Ref<boolean> => { 2024 try { 2025 const _ret = WEBEXT.inputMethodPrivate.onScreenProjectionChanged.removeListener(A.H.get<object>(callback)); 2026 return A.H.TRUE; 2027 } catch (err: any) { 2028 A.store.Ref(errPtr, err); 2029 return A.H.FALSE; 2030 } 2031 }, 2032 "has_HasOnScreenProjectionChanged": (): heap.Ref<boolean> => { 2033 if ( 2034 WEBEXT?.inputMethodPrivate?.onScreenProjectionChanged && 2035 "hasListener" in WEBEXT?.inputMethodPrivate?.onScreenProjectionChanged 2036 ) { 2037 return A.H.TRUE; 2038 } 2039 return A.H.FALSE; 2040 }, 2041 "func_HasOnScreenProjectionChanged": (fn: Pointer): void => { 2042 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onScreenProjectionChanged.hasListener); 2043 }, 2044 "call_HasOnScreenProjectionChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2045 const _ret = WEBEXT.inputMethodPrivate.onScreenProjectionChanged.hasListener(A.H.get<object>(callback)); 2046 A.store.Bool(retPtr, _ret); 2047 }, 2048 "try_HasOnScreenProjectionChanged": ( 2049 retPtr: Pointer, 2050 errPtr: Pointer, 2051 callback: heap.Ref<object> 2052 ): heap.Ref<boolean> => { 2053 try { 2054 const _ret = WEBEXT.inputMethodPrivate.onScreenProjectionChanged.hasListener(A.H.get<object>(callback)); 2055 A.store.Bool(retPtr, _ret); 2056 return A.H.TRUE; 2057 } catch (err: any) { 2058 A.store.Ref(errPtr, err); 2059 return A.H.FALSE; 2060 } 2061 }, 2062 "has_OnSettingsChanged": (): heap.Ref<boolean> => { 2063 if ( 2064 WEBEXT?.inputMethodPrivate?.onSettingsChanged && 2065 "addListener" in WEBEXT?.inputMethodPrivate?.onSettingsChanged 2066 ) { 2067 return A.H.TRUE; 2068 } 2069 return A.H.FALSE; 2070 }, 2071 "func_OnSettingsChanged": (fn: Pointer): void => { 2072 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onSettingsChanged.addListener); 2073 }, 2074 "call_OnSettingsChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2075 const _ret = WEBEXT.inputMethodPrivate.onSettingsChanged.addListener(A.H.get<object>(callback)); 2076 }, 2077 "try_OnSettingsChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2078 try { 2079 const _ret = WEBEXT.inputMethodPrivate.onSettingsChanged.addListener(A.H.get<object>(callback)); 2080 return A.H.TRUE; 2081 } catch (err: any) { 2082 A.store.Ref(errPtr, err); 2083 return A.H.FALSE; 2084 } 2085 }, 2086 "has_OffSettingsChanged": (): heap.Ref<boolean> => { 2087 if ( 2088 WEBEXT?.inputMethodPrivate?.onSettingsChanged && 2089 "removeListener" in WEBEXT?.inputMethodPrivate?.onSettingsChanged 2090 ) { 2091 return A.H.TRUE; 2092 } 2093 return A.H.FALSE; 2094 }, 2095 "func_OffSettingsChanged": (fn: Pointer): void => { 2096 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onSettingsChanged.removeListener); 2097 }, 2098 "call_OffSettingsChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2099 const _ret = WEBEXT.inputMethodPrivate.onSettingsChanged.removeListener(A.H.get<object>(callback)); 2100 }, 2101 "try_OffSettingsChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2102 try { 2103 const _ret = WEBEXT.inputMethodPrivate.onSettingsChanged.removeListener(A.H.get<object>(callback)); 2104 return A.H.TRUE; 2105 } catch (err: any) { 2106 A.store.Ref(errPtr, err); 2107 return A.H.FALSE; 2108 } 2109 }, 2110 "has_HasOnSettingsChanged": (): heap.Ref<boolean> => { 2111 if ( 2112 WEBEXT?.inputMethodPrivate?.onSettingsChanged && 2113 "hasListener" in WEBEXT?.inputMethodPrivate?.onSettingsChanged 2114 ) { 2115 return A.H.TRUE; 2116 } 2117 return A.H.FALSE; 2118 }, 2119 "func_HasOnSettingsChanged": (fn: Pointer): void => { 2120 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onSettingsChanged.hasListener); 2121 }, 2122 "call_HasOnSettingsChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2123 const _ret = WEBEXT.inputMethodPrivate.onSettingsChanged.hasListener(A.H.get<object>(callback)); 2124 A.store.Bool(retPtr, _ret); 2125 }, 2126 "try_HasOnSettingsChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2127 try { 2128 const _ret = WEBEXT.inputMethodPrivate.onSettingsChanged.hasListener(A.H.get<object>(callback)); 2129 A.store.Bool(retPtr, _ret); 2130 return A.H.TRUE; 2131 } catch (err: any) { 2132 A.store.Ref(errPtr, err); 2133 return A.H.FALSE; 2134 } 2135 }, 2136 "has_OnSuggestionsChanged": (): heap.Ref<boolean> => { 2137 if ( 2138 WEBEXT?.inputMethodPrivate?.onSuggestionsChanged && 2139 "addListener" in WEBEXT?.inputMethodPrivate?.onSuggestionsChanged 2140 ) { 2141 return A.H.TRUE; 2142 } 2143 return A.H.FALSE; 2144 }, 2145 "func_OnSuggestionsChanged": (fn: Pointer): void => { 2146 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onSuggestionsChanged.addListener); 2147 }, 2148 "call_OnSuggestionsChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2149 const _ret = WEBEXT.inputMethodPrivate.onSuggestionsChanged.addListener(A.H.get<object>(callback)); 2150 }, 2151 "try_OnSuggestionsChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2152 try { 2153 const _ret = WEBEXT.inputMethodPrivate.onSuggestionsChanged.addListener(A.H.get<object>(callback)); 2154 return A.H.TRUE; 2155 } catch (err: any) { 2156 A.store.Ref(errPtr, err); 2157 return A.H.FALSE; 2158 } 2159 }, 2160 "has_OffSuggestionsChanged": (): heap.Ref<boolean> => { 2161 if ( 2162 WEBEXT?.inputMethodPrivate?.onSuggestionsChanged && 2163 "removeListener" in WEBEXT?.inputMethodPrivate?.onSuggestionsChanged 2164 ) { 2165 return A.H.TRUE; 2166 } 2167 return A.H.FALSE; 2168 }, 2169 "func_OffSuggestionsChanged": (fn: Pointer): void => { 2170 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onSuggestionsChanged.removeListener); 2171 }, 2172 "call_OffSuggestionsChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2173 const _ret = WEBEXT.inputMethodPrivate.onSuggestionsChanged.removeListener(A.H.get<object>(callback)); 2174 }, 2175 "try_OffSuggestionsChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2176 try { 2177 const _ret = WEBEXT.inputMethodPrivate.onSuggestionsChanged.removeListener(A.H.get<object>(callback)); 2178 return A.H.TRUE; 2179 } catch (err: any) { 2180 A.store.Ref(errPtr, err); 2181 return A.H.FALSE; 2182 } 2183 }, 2184 "has_HasOnSuggestionsChanged": (): heap.Ref<boolean> => { 2185 if ( 2186 WEBEXT?.inputMethodPrivate?.onSuggestionsChanged && 2187 "hasListener" in WEBEXT?.inputMethodPrivate?.onSuggestionsChanged 2188 ) { 2189 return A.H.TRUE; 2190 } 2191 return A.H.FALSE; 2192 }, 2193 "func_HasOnSuggestionsChanged": (fn: Pointer): void => { 2194 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onSuggestionsChanged.hasListener); 2195 }, 2196 "call_HasOnSuggestionsChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2197 const _ret = WEBEXT.inputMethodPrivate.onSuggestionsChanged.hasListener(A.H.get<object>(callback)); 2198 A.store.Bool(retPtr, _ret); 2199 }, 2200 "try_HasOnSuggestionsChanged": ( 2201 retPtr: Pointer, 2202 errPtr: Pointer, 2203 callback: heap.Ref<object> 2204 ): heap.Ref<boolean> => { 2205 try { 2206 const _ret = WEBEXT.inputMethodPrivate.onSuggestionsChanged.hasListener(A.H.get<object>(callback)); 2207 A.store.Bool(retPtr, _ret); 2208 return A.H.TRUE; 2209 } catch (err: any) { 2210 A.store.Ref(errPtr, err); 2211 return A.H.FALSE; 2212 } 2213 }, 2214 "has_OnTouch": (): heap.Ref<boolean> => { 2215 if (WEBEXT?.inputMethodPrivate?.onTouch && "addListener" in WEBEXT?.inputMethodPrivate?.onTouch) { 2216 return A.H.TRUE; 2217 } 2218 return A.H.FALSE; 2219 }, 2220 "func_OnTouch": (fn: Pointer): void => { 2221 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onTouch.addListener); 2222 }, 2223 "call_OnTouch": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2224 const _ret = WEBEXT.inputMethodPrivate.onTouch.addListener(A.H.get<object>(callback)); 2225 }, 2226 "try_OnTouch": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2227 try { 2228 const _ret = WEBEXT.inputMethodPrivate.onTouch.addListener(A.H.get<object>(callback)); 2229 return A.H.TRUE; 2230 } catch (err: any) { 2231 A.store.Ref(errPtr, err); 2232 return A.H.FALSE; 2233 } 2234 }, 2235 "has_OffTouch": (): heap.Ref<boolean> => { 2236 if (WEBEXT?.inputMethodPrivate?.onTouch && "removeListener" in WEBEXT?.inputMethodPrivate?.onTouch) { 2237 return A.H.TRUE; 2238 } 2239 return A.H.FALSE; 2240 }, 2241 "func_OffTouch": (fn: Pointer): void => { 2242 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onTouch.removeListener); 2243 }, 2244 "call_OffTouch": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2245 const _ret = WEBEXT.inputMethodPrivate.onTouch.removeListener(A.H.get<object>(callback)); 2246 }, 2247 "try_OffTouch": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2248 try { 2249 const _ret = WEBEXT.inputMethodPrivate.onTouch.removeListener(A.H.get<object>(callback)); 2250 return A.H.TRUE; 2251 } catch (err: any) { 2252 A.store.Ref(errPtr, err); 2253 return A.H.FALSE; 2254 } 2255 }, 2256 "has_HasOnTouch": (): heap.Ref<boolean> => { 2257 if (WEBEXT?.inputMethodPrivate?.onTouch && "hasListener" in WEBEXT?.inputMethodPrivate?.onTouch) { 2258 return A.H.TRUE; 2259 } 2260 return A.H.FALSE; 2261 }, 2262 "func_HasOnTouch": (fn: Pointer): void => { 2263 A.store.Ref(fn, WEBEXT.inputMethodPrivate.onTouch.hasListener); 2264 }, 2265 "call_HasOnTouch": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2266 const _ret = WEBEXT.inputMethodPrivate.onTouch.hasListener(A.H.get<object>(callback)); 2267 A.store.Bool(retPtr, _ret); 2268 }, 2269 "try_HasOnTouch": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 2270 try { 2271 const _ret = WEBEXT.inputMethodPrivate.onTouch.hasListener(A.H.get<object>(callback)); 2272 A.store.Bool(retPtr, _ret); 2273 return A.H.TRUE; 2274 } catch (err: any) { 2275 A.store.Ref(errPtr, err); 2276 return A.H.FALSE; 2277 } 2278 }, 2279 "has_OpenOptionsPage": (): heap.Ref<boolean> => { 2280 if (WEBEXT?.inputMethodPrivate && "openOptionsPage" in WEBEXT?.inputMethodPrivate) { 2281 return A.H.TRUE; 2282 } 2283 return A.H.FALSE; 2284 }, 2285 "func_OpenOptionsPage": (fn: Pointer): void => { 2286 A.store.Ref(fn, WEBEXT.inputMethodPrivate.openOptionsPage); 2287 }, 2288 "call_OpenOptionsPage": (retPtr: Pointer, inputMethodId: heap.Ref<object>): void => { 2289 const _ret = WEBEXT.inputMethodPrivate.openOptionsPage(A.H.get<object>(inputMethodId)); 2290 }, 2291 "try_OpenOptionsPage": (retPtr: Pointer, errPtr: Pointer, inputMethodId: heap.Ref<object>): heap.Ref<boolean> => { 2292 try { 2293 const _ret = WEBEXT.inputMethodPrivate.openOptionsPage(A.H.get<object>(inputMethodId)); 2294 return A.H.TRUE; 2295 } catch (err: any) { 2296 A.store.Ref(errPtr, err); 2297 return A.H.FALSE; 2298 } 2299 }, 2300 "has_Reset": (): heap.Ref<boolean> => { 2301 if (WEBEXT?.inputMethodPrivate && "reset" in WEBEXT?.inputMethodPrivate) { 2302 return A.H.TRUE; 2303 } 2304 return A.H.FALSE; 2305 }, 2306 "func_Reset": (fn: Pointer): void => { 2307 A.store.Ref(fn, WEBEXT.inputMethodPrivate.reset); 2308 }, 2309 "call_Reset": (retPtr: Pointer): void => { 2310 const _ret = WEBEXT.inputMethodPrivate.reset(); 2311 }, 2312 "try_Reset": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 2313 try { 2314 const _ret = WEBEXT.inputMethodPrivate.reset(); 2315 return A.H.TRUE; 2316 } catch (err: any) { 2317 A.store.Ref(errPtr, err); 2318 return A.H.FALSE; 2319 } 2320 }, 2321 "has_SetCompositionRange": (): heap.Ref<boolean> => { 2322 if (WEBEXT?.inputMethodPrivate && "setCompositionRange" in WEBEXT?.inputMethodPrivate) { 2323 return A.H.TRUE; 2324 } 2325 return A.H.FALSE; 2326 }, 2327 "func_SetCompositionRange": (fn: Pointer): void => { 2328 A.store.Ref(fn, WEBEXT.inputMethodPrivate.setCompositionRange); 2329 }, 2330 "call_SetCompositionRange": (retPtr: Pointer, parameters: Pointer): void => { 2331 const parameters_ffi = {}; 2332 2333 parameters_ffi["contextID"] = A.load.Int64(parameters + 0); 2334 parameters_ffi["segments"] = A.load.Ref(parameters + 8, undefined); 2335 parameters_ffi["selectionAfter"] = A.load.Int64(parameters + 16); 2336 parameters_ffi["selectionBefore"] = A.load.Int64(parameters + 24); 2337 2338 const _ret = WEBEXT.inputMethodPrivate.setCompositionRange(parameters_ffi); 2339 A.store.Ref(retPtr, _ret); 2340 }, 2341 "try_SetCompositionRange": (retPtr: Pointer, errPtr: Pointer, parameters: Pointer): heap.Ref<boolean> => { 2342 try { 2343 const parameters_ffi = {}; 2344 2345 parameters_ffi["contextID"] = A.load.Int64(parameters + 0); 2346 parameters_ffi["segments"] = A.load.Ref(parameters + 8, undefined); 2347 parameters_ffi["selectionAfter"] = A.load.Int64(parameters + 16); 2348 parameters_ffi["selectionBefore"] = A.load.Int64(parameters + 24); 2349 2350 const _ret = WEBEXT.inputMethodPrivate.setCompositionRange(parameters_ffi); 2351 A.store.Ref(retPtr, _ret); 2352 return A.H.TRUE; 2353 } catch (err: any) { 2354 A.store.Ref(errPtr, err); 2355 return A.H.FALSE; 2356 } 2357 }, 2358 "has_SetCurrentInputMethod": (): heap.Ref<boolean> => { 2359 if (WEBEXT?.inputMethodPrivate && "setCurrentInputMethod" in WEBEXT?.inputMethodPrivate) { 2360 return A.H.TRUE; 2361 } 2362 return A.H.FALSE; 2363 }, 2364 "func_SetCurrentInputMethod": (fn: Pointer): void => { 2365 A.store.Ref(fn, WEBEXT.inputMethodPrivate.setCurrentInputMethod); 2366 }, 2367 "call_SetCurrentInputMethod": (retPtr: Pointer, inputMethodId: heap.Ref<object>): void => { 2368 const _ret = WEBEXT.inputMethodPrivate.setCurrentInputMethod(A.H.get<object>(inputMethodId)); 2369 A.store.Ref(retPtr, _ret); 2370 }, 2371 "try_SetCurrentInputMethod": ( 2372 retPtr: Pointer, 2373 errPtr: Pointer, 2374 inputMethodId: heap.Ref<object> 2375 ): heap.Ref<boolean> => { 2376 try { 2377 const _ret = WEBEXT.inputMethodPrivate.setCurrentInputMethod(A.H.get<object>(inputMethodId)); 2378 A.store.Ref(retPtr, _ret); 2379 return A.H.TRUE; 2380 } catch (err: any) { 2381 A.store.Ref(errPtr, err); 2382 return A.H.FALSE; 2383 } 2384 }, 2385 "has_SetSettings": (): heap.Ref<boolean> => { 2386 if (WEBEXT?.inputMethodPrivate && "setSettings" in WEBEXT?.inputMethodPrivate) { 2387 return A.H.TRUE; 2388 } 2389 return A.H.FALSE; 2390 }, 2391 "func_SetSettings": (fn: Pointer): void => { 2392 A.store.Ref(fn, WEBEXT.inputMethodPrivate.setSettings); 2393 }, 2394 "call_SetSettings": (retPtr: Pointer, engineID: heap.Ref<object>, settings: Pointer): void => { 2395 const settings_ffi = {}; 2396 2397 if (A.load.Bool(settings + 108)) { 2398 settings_ffi["enableCompletion"] = A.load.Bool(settings + 0); 2399 } 2400 if (A.load.Bool(settings + 109)) { 2401 settings_ffi["enableDoubleSpacePeriod"] = A.load.Bool(settings + 1); 2402 } 2403 if (A.load.Bool(settings + 110)) { 2404 settings_ffi["enableGestureTyping"] = A.load.Bool(settings + 2); 2405 } 2406 if (A.load.Bool(settings + 111)) { 2407 settings_ffi["enablePrediction"] = A.load.Bool(settings + 3); 2408 } 2409 if (A.load.Bool(settings + 112)) { 2410 settings_ffi["enableSoundOnKeypress"] = A.load.Bool(settings + 4); 2411 } 2412 if (A.load.Bool(settings + 113)) { 2413 settings_ffi["koreanEnableSyllableInput"] = A.load.Bool(settings + 5); 2414 } 2415 settings_ffi["koreanKeyboardLayout"] = A.load.Ref(settings + 8, undefined); 2416 if (A.load.Bool(settings + 114)) { 2417 settings_ffi["koreanShowHangulCandidate"] = A.load.Bool(settings + 12); 2418 } 2419 if (A.load.Bool(settings + 115)) { 2420 settings_ffi["physicalKeyboardAutoCorrectionEnabledByDefault"] = A.load.Bool(settings + 13); 2421 } 2422 if (A.load.Bool(settings + 116)) { 2423 settings_ffi["physicalKeyboardAutoCorrectionLevel"] = A.load.Int64(settings + 16); 2424 } 2425 if (A.load.Bool(settings + 117)) { 2426 settings_ffi["physicalKeyboardEnableCapitalization"] = A.load.Bool(settings + 24); 2427 } 2428 if (A.load.Bool(settings + 118)) { 2429 settings_ffi["physicalKeyboardEnableDiacriticsOnLongpress"] = A.load.Bool(settings + 25); 2430 } 2431 if (A.load.Bool(settings + 119)) { 2432 settings_ffi["physicalKeyboardEnablePredictiveWriting"] = A.load.Bool(settings + 26); 2433 } 2434 if (A.load.Bool(settings + 120)) { 2435 settings_ffi["pinyinChinesePunctuation"] = A.load.Bool(settings + 27); 2436 } 2437 if (A.load.Bool(settings + 121)) { 2438 settings_ffi["pinyinDefaultChinese"] = A.load.Bool(settings + 28); 2439 } 2440 if (A.load.Bool(settings + 122)) { 2441 settings_ffi["pinyinEnableFuzzy"] = A.load.Bool(settings + 29); 2442 } 2443 if (A.load.Bool(settings + 123)) { 2444 settings_ffi["pinyinEnableLowerPaging"] = A.load.Bool(settings + 30); 2445 } 2446 if (A.load.Bool(settings + 124)) { 2447 settings_ffi["pinyinEnableUpperPaging"] = A.load.Bool(settings + 31); 2448 } 2449 if (A.load.Bool(settings + 125)) { 2450 settings_ffi["pinyinFullWidthCharacter"] = A.load.Bool(settings + 32); 2451 } 2452 if (A.load.Bool(settings + 33 + 24)) { 2453 settings_ffi["pinyinFuzzyConfig"] = {}; 2454 if (A.load.Bool(settings + 33 + 12)) { 2455 settings_ffi["pinyinFuzzyConfig"]["an_ang"] = A.load.Bool(settings + 33 + 0); 2456 } 2457 if (A.load.Bool(settings + 33 + 13)) { 2458 settings_ffi["pinyinFuzzyConfig"]["c_ch"] = A.load.Bool(settings + 33 + 1); 2459 } 2460 if (A.load.Bool(settings + 33 + 14)) { 2461 settings_ffi["pinyinFuzzyConfig"]["en_eng"] = A.load.Bool(settings + 33 + 2); 2462 } 2463 if (A.load.Bool(settings + 33 + 15)) { 2464 settings_ffi["pinyinFuzzyConfig"]["f_h"] = A.load.Bool(settings + 33 + 3); 2465 } 2466 if (A.load.Bool(settings + 33 + 16)) { 2467 settings_ffi["pinyinFuzzyConfig"]["ian_iang"] = A.load.Bool(settings + 33 + 4); 2468 } 2469 if (A.load.Bool(settings + 33 + 17)) { 2470 settings_ffi["pinyinFuzzyConfig"]["in_ing"] = A.load.Bool(settings + 33 + 5); 2471 } 2472 if (A.load.Bool(settings + 33 + 18)) { 2473 settings_ffi["pinyinFuzzyConfig"]["k_g"] = A.load.Bool(settings + 33 + 6); 2474 } 2475 if (A.load.Bool(settings + 33 + 19)) { 2476 settings_ffi["pinyinFuzzyConfig"]["l_n"] = A.load.Bool(settings + 33 + 7); 2477 } 2478 if (A.load.Bool(settings + 33 + 20)) { 2479 settings_ffi["pinyinFuzzyConfig"]["r_l"] = A.load.Bool(settings + 33 + 8); 2480 } 2481 if (A.load.Bool(settings + 33 + 21)) { 2482 settings_ffi["pinyinFuzzyConfig"]["s_sh"] = A.load.Bool(settings + 33 + 9); 2483 } 2484 if (A.load.Bool(settings + 33 + 22)) { 2485 settings_ffi["pinyinFuzzyConfig"]["uan_uang"] = A.load.Bool(settings + 33 + 10); 2486 } 2487 if (A.load.Bool(settings + 33 + 23)) { 2488 settings_ffi["pinyinFuzzyConfig"]["z_zh"] = A.load.Bool(settings + 33 + 11); 2489 } 2490 } 2491 if (A.load.Bool(settings + 126)) { 2492 settings_ffi["vietnameseTelexAllowFlexibleDiacritics"] = A.load.Bool(settings + 58); 2493 } 2494 if (A.load.Bool(settings + 127)) { 2495 settings_ffi["vietnameseTelexInsertDoubleHornOnUo"] = A.load.Bool(settings + 59); 2496 } 2497 if (A.load.Bool(settings + 128)) { 2498 settings_ffi["vietnameseTelexInsertUHornOnW"] = A.load.Bool(settings + 60); 2499 } 2500 if (A.load.Bool(settings + 129)) { 2501 settings_ffi["vietnameseTelexNewStyleToneMarkPlacement"] = A.load.Bool(settings + 61); 2502 } 2503 if (A.load.Bool(settings + 130)) { 2504 settings_ffi["vietnameseTelexShowUnderline"] = A.load.Bool(settings + 62); 2505 } 2506 if (A.load.Bool(settings + 131)) { 2507 settings_ffi["vietnameseVniAllowFlexibleDiacritics"] = A.load.Bool(settings + 63); 2508 } 2509 if (A.load.Bool(settings + 132)) { 2510 settings_ffi["vietnameseVniInsertDoubleHornOnUo"] = A.load.Bool(settings + 64); 2511 } 2512 if (A.load.Bool(settings + 133)) { 2513 settings_ffi["vietnameseVniNewStyleToneMarkPlacement"] = A.load.Bool(settings + 65); 2514 } 2515 if (A.load.Bool(settings + 134)) { 2516 settings_ffi["vietnameseVniShowUnderline"] = A.load.Bool(settings + 66); 2517 } 2518 if (A.load.Bool(settings + 135)) { 2519 settings_ffi["virtualKeyboardAutoCorrectionLevel"] = A.load.Int64(settings + 72); 2520 } 2521 if (A.load.Bool(settings + 136)) { 2522 settings_ffi["virtualKeyboardEnableCapitalization"] = A.load.Bool(settings + 80); 2523 } 2524 settings_ffi["xkbLayout"] = A.load.Ref(settings + 84, undefined); 2525 settings_ffi["zhuyinKeyboardLayout"] = A.load.Ref(settings + 88, undefined); 2526 if (A.load.Bool(settings + 137)) { 2527 settings_ffi["zhuyinPageSize"] = A.load.Int64(settings + 96); 2528 } 2529 settings_ffi["zhuyinSelectKeys"] = A.load.Ref(settings + 104, undefined); 2530 2531 const _ret = WEBEXT.inputMethodPrivate.setSettings(A.H.get<object>(engineID), settings_ffi); 2532 A.store.Ref(retPtr, _ret); 2533 }, 2534 "try_SetSettings": ( 2535 retPtr: Pointer, 2536 errPtr: Pointer, 2537 engineID: heap.Ref<object>, 2538 settings: Pointer 2539 ): heap.Ref<boolean> => { 2540 try { 2541 const settings_ffi = {}; 2542 2543 if (A.load.Bool(settings + 108)) { 2544 settings_ffi["enableCompletion"] = A.load.Bool(settings + 0); 2545 } 2546 if (A.load.Bool(settings + 109)) { 2547 settings_ffi["enableDoubleSpacePeriod"] = A.load.Bool(settings + 1); 2548 } 2549 if (A.load.Bool(settings + 110)) { 2550 settings_ffi["enableGestureTyping"] = A.load.Bool(settings + 2); 2551 } 2552 if (A.load.Bool(settings + 111)) { 2553 settings_ffi["enablePrediction"] = A.load.Bool(settings + 3); 2554 } 2555 if (A.load.Bool(settings + 112)) { 2556 settings_ffi["enableSoundOnKeypress"] = A.load.Bool(settings + 4); 2557 } 2558 if (A.load.Bool(settings + 113)) { 2559 settings_ffi["koreanEnableSyllableInput"] = A.load.Bool(settings + 5); 2560 } 2561 settings_ffi["koreanKeyboardLayout"] = A.load.Ref(settings + 8, undefined); 2562 if (A.load.Bool(settings + 114)) { 2563 settings_ffi["koreanShowHangulCandidate"] = A.load.Bool(settings + 12); 2564 } 2565 if (A.load.Bool(settings + 115)) { 2566 settings_ffi["physicalKeyboardAutoCorrectionEnabledByDefault"] = A.load.Bool(settings + 13); 2567 } 2568 if (A.load.Bool(settings + 116)) { 2569 settings_ffi["physicalKeyboardAutoCorrectionLevel"] = A.load.Int64(settings + 16); 2570 } 2571 if (A.load.Bool(settings + 117)) { 2572 settings_ffi["physicalKeyboardEnableCapitalization"] = A.load.Bool(settings + 24); 2573 } 2574 if (A.load.Bool(settings + 118)) { 2575 settings_ffi["physicalKeyboardEnableDiacriticsOnLongpress"] = A.load.Bool(settings + 25); 2576 } 2577 if (A.load.Bool(settings + 119)) { 2578 settings_ffi["physicalKeyboardEnablePredictiveWriting"] = A.load.Bool(settings + 26); 2579 } 2580 if (A.load.Bool(settings + 120)) { 2581 settings_ffi["pinyinChinesePunctuation"] = A.load.Bool(settings + 27); 2582 } 2583 if (A.load.Bool(settings + 121)) { 2584 settings_ffi["pinyinDefaultChinese"] = A.load.Bool(settings + 28); 2585 } 2586 if (A.load.Bool(settings + 122)) { 2587 settings_ffi["pinyinEnableFuzzy"] = A.load.Bool(settings + 29); 2588 } 2589 if (A.load.Bool(settings + 123)) { 2590 settings_ffi["pinyinEnableLowerPaging"] = A.load.Bool(settings + 30); 2591 } 2592 if (A.load.Bool(settings + 124)) { 2593 settings_ffi["pinyinEnableUpperPaging"] = A.load.Bool(settings + 31); 2594 } 2595 if (A.load.Bool(settings + 125)) { 2596 settings_ffi["pinyinFullWidthCharacter"] = A.load.Bool(settings + 32); 2597 } 2598 if (A.load.Bool(settings + 33 + 24)) { 2599 settings_ffi["pinyinFuzzyConfig"] = {}; 2600 if (A.load.Bool(settings + 33 + 12)) { 2601 settings_ffi["pinyinFuzzyConfig"]["an_ang"] = A.load.Bool(settings + 33 + 0); 2602 } 2603 if (A.load.Bool(settings + 33 + 13)) { 2604 settings_ffi["pinyinFuzzyConfig"]["c_ch"] = A.load.Bool(settings + 33 + 1); 2605 } 2606 if (A.load.Bool(settings + 33 + 14)) { 2607 settings_ffi["pinyinFuzzyConfig"]["en_eng"] = A.load.Bool(settings + 33 + 2); 2608 } 2609 if (A.load.Bool(settings + 33 + 15)) { 2610 settings_ffi["pinyinFuzzyConfig"]["f_h"] = A.load.Bool(settings + 33 + 3); 2611 } 2612 if (A.load.Bool(settings + 33 + 16)) { 2613 settings_ffi["pinyinFuzzyConfig"]["ian_iang"] = A.load.Bool(settings + 33 + 4); 2614 } 2615 if (A.load.Bool(settings + 33 + 17)) { 2616 settings_ffi["pinyinFuzzyConfig"]["in_ing"] = A.load.Bool(settings + 33 + 5); 2617 } 2618 if (A.load.Bool(settings + 33 + 18)) { 2619 settings_ffi["pinyinFuzzyConfig"]["k_g"] = A.load.Bool(settings + 33 + 6); 2620 } 2621 if (A.load.Bool(settings + 33 + 19)) { 2622 settings_ffi["pinyinFuzzyConfig"]["l_n"] = A.load.Bool(settings + 33 + 7); 2623 } 2624 if (A.load.Bool(settings + 33 + 20)) { 2625 settings_ffi["pinyinFuzzyConfig"]["r_l"] = A.load.Bool(settings + 33 + 8); 2626 } 2627 if (A.load.Bool(settings + 33 + 21)) { 2628 settings_ffi["pinyinFuzzyConfig"]["s_sh"] = A.load.Bool(settings + 33 + 9); 2629 } 2630 if (A.load.Bool(settings + 33 + 22)) { 2631 settings_ffi["pinyinFuzzyConfig"]["uan_uang"] = A.load.Bool(settings + 33 + 10); 2632 } 2633 if (A.load.Bool(settings + 33 + 23)) { 2634 settings_ffi["pinyinFuzzyConfig"]["z_zh"] = A.load.Bool(settings + 33 + 11); 2635 } 2636 } 2637 if (A.load.Bool(settings + 126)) { 2638 settings_ffi["vietnameseTelexAllowFlexibleDiacritics"] = A.load.Bool(settings + 58); 2639 } 2640 if (A.load.Bool(settings + 127)) { 2641 settings_ffi["vietnameseTelexInsertDoubleHornOnUo"] = A.load.Bool(settings + 59); 2642 } 2643 if (A.load.Bool(settings + 128)) { 2644 settings_ffi["vietnameseTelexInsertUHornOnW"] = A.load.Bool(settings + 60); 2645 } 2646 if (A.load.Bool(settings + 129)) { 2647 settings_ffi["vietnameseTelexNewStyleToneMarkPlacement"] = A.load.Bool(settings + 61); 2648 } 2649 if (A.load.Bool(settings + 130)) { 2650 settings_ffi["vietnameseTelexShowUnderline"] = A.load.Bool(settings + 62); 2651 } 2652 if (A.load.Bool(settings + 131)) { 2653 settings_ffi["vietnameseVniAllowFlexibleDiacritics"] = A.load.Bool(settings + 63); 2654 } 2655 if (A.load.Bool(settings + 132)) { 2656 settings_ffi["vietnameseVniInsertDoubleHornOnUo"] = A.load.Bool(settings + 64); 2657 } 2658 if (A.load.Bool(settings + 133)) { 2659 settings_ffi["vietnameseVniNewStyleToneMarkPlacement"] = A.load.Bool(settings + 65); 2660 } 2661 if (A.load.Bool(settings + 134)) { 2662 settings_ffi["vietnameseVniShowUnderline"] = A.load.Bool(settings + 66); 2663 } 2664 if (A.load.Bool(settings + 135)) { 2665 settings_ffi["virtualKeyboardAutoCorrectionLevel"] = A.load.Int64(settings + 72); 2666 } 2667 if (A.load.Bool(settings + 136)) { 2668 settings_ffi["virtualKeyboardEnableCapitalization"] = A.load.Bool(settings + 80); 2669 } 2670 settings_ffi["xkbLayout"] = A.load.Ref(settings + 84, undefined); 2671 settings_ffi["zhuyinKeyboardLayout"] = A.load.Ref(settings + 88, undefined); 2672 if (A.load.Bool(settings + 137)) { 2673 settings_ffi["zhuyinPageSize"] = A.load.Int64(settings + 96); 2674 } 2675 settings_ffi["zhuyinSelectKeys"] = A.load.Ref(settings + 104, undefined); 2676 2677 const _ret = WEBEXT.inputMethodPrivate.setSettings(A.H.get<object>(engineID), settings_ffi); 2678 A.store.Ref(retPtr, _ret); 2679 return A.H.TRUE; 2680 } catch (err: any) { 2681 A.store.Ref(errPtr, err); 2682 return A.H.FALSE; 2683 } 2684 }, 2685 "has_SetXkbLayout": (): heap.Ref<boolean> => { 2686 if (WEBEXT?.inputMethodPrivate && "setXkbLayout" in WEBEXT?.inputMethodPrivate) { 2687 return A.H.TRUE; 2688 } 2689 return A.H.FALSE; 2690 }, 2691 "func_SetXkbLayout": (fn: Pointer): void => { 2692 A.store.Ref(fn, WEBEXT.inputMethodPrivate.setXkbLayout); 2693 }, 2694 "call_SetXkbLayout": (retPtr: Pointer, xkb_name: heap.Ref<object>): void => { 2695 const _ret = WEBEXT.inputMethodPrivate.setXkbLayout(A.H.get<object>(xkb_name)); 2696 A.store.Ref(retPtr, _ret); 2697 }, 2698 "try_SetXkbLayout": (retPtr: Pointer, errPtr: Pointer, xkb_name: heap.Ref<object>): heap.Ref<boolean> => { 2699 try { 2700 const _ret = WEBEXT.inputMethodPrivate.setXkbLayout(A.H.get<object>(xkb_name)); 2701 A.store.Ref(retPtr, _ret); 2702 return A.H.TRUE; 2703 } catch (err: any) { 2704 A.store.Ref(errPtr, err); 2705 return A.H.FALSE; 2706 } 2707 }, 2708 "has_ShowInputView": (): heap.Ref<boolean> => { 2709 if (WEBEXT?.inputMethodPrivate && "showInputView" in WEBEXT?.inputMethodPrivate) { 2710 return A.H.TRUE; 2711 } 2712 return A.H.FALSE; 2713 }, 2714 "func_ShowInputView": (fn: Pointer): void => { 2715 A.store.Ref(fn, WEBEXT.inputMethodPrivate.showInputView); 2716 }, 2717 "call_ShowInputView": (retPtr: Pointer): void => { 2718 const _ret = WEBEXT.inputMethodPrivate.showInputView(); 2719 A.store.Ref(retPtr, _ret); 2720 }, 2721 "try_ShowInputView": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 2722 try { 2723 const _ret = WEBEXT.inputMethodPrivate.showInputView(); 2724 A.store.Ref(retPtr, _ret); 2725 return A.H.TRUE; 2726 } catch (err: any) { 2727 A.store.Ref(errPtr, err); 2728 return A.H.FALSE; 2729 } 2730 }, 2731 "has_SwitchToLastUsedInputMethod": (): heap.Ref<boolean> => { 2732 if (WEBEXT?.inputMethodPrivate && "switchToLastUsedInputMethod" in WEBEXT?.inputMethodPrivate) { 2733 return A.H.TRUE; 2734 } 2735 return A.H.FALSE; 2736 }, 2737 "func_SwitchToLastUsedInputMethod": (fn: Pointer): void => { 2738 A.store.Ref(fn, WEBEXT.inputMethodPrivate.switchToLastUsedInputMethod); 2739 }, 2740 "call_SwitchToLastUsedInputMethod": (retPtr: Pointer): void => { 2741 const _ret = WEBEXT.inputMethodPrivate.switchToLastUsedInputMethod(); 2742 A.store.Ref(retPtr, _ret); 2743 }, 2744 "try_SwitchToLastUsedInputMethod": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 2745 try { 2746 const _ret = WEBEXT.inputMethodPrivate.switchToLastUsedInputMethod(); 2747 A.store.Ref(retPtr, _ret); 2748 return A.H.TRUE; 2749 } catch (err: any) { 2750 A.store.Ref(errPtr, err); 2751 return A.H.FALSE; 2752 } 2753 }, 2754 }; 2755 });