github.com/primecitizens/pcz/std@v0.2.1/plat/js/webext/fontsettings/bindings/ffi_bindings.ts (about) 1 import { importModule, Application, heap, Pointer } from "@ffi"; 2 3 importModule("plat/js/webext/fontsettings", (A: Application) => { 4 const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser; 5 6 return { 7 "store_ClearDefaultFixedFontSizeArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => { 8 const x = A.H.get<any>(ref); 9 10 if (typeof x === "undefined") { 11 A.store.Bool(ptr + 0, false); 12 } else { 13 A.store.Bool(ptr + 0, true); 14 } 15 }, 16 "load_ClearDefaultFixedFontSizeArgDetails": ( 17 ptr: Pointer, 18 create: heap.Ref<boolean>, 19 ref: heap.Ref<any> 20 ): heap.Ref<any> => { 21 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 22 23 return create === A.H.TRUE ? A.H.push(x) : ref; 24 }, 25 26 "store_ClearDefaultFontSizeArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => { 27 const x = A.H.get<any>(ref); 28 29 if (typeof x === "undefined") { 30 A.store.Bool(ptr + 0, false); 31 } else { 32 A.store.Bool(ptr + 0, true); 33 } 34 }, 35 "load_ClearDefaultFontSizeArgDetails": ( 36 ptr: Pointer, 37 create: heap.Ref<boolean>, 38 ref: heap.Ref<any> 39 ): heap.Ref<any> => { 40 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 41 42 return create === A.H.TRUE ? A.H.push(x) : ref; 43 }, 44 "constof_GenericFamily": (ref: heap.Ref<string>): number => { 45 const idx = ["standard", "sansserif", "serif", "fixed", "cursive", "fantasy", "math"].indexOf(A.H.get(ref)); 46 return idx < 0 ? 0 : idx + 1; 47 }, 48 "constof_ScriptCode": (ref: heap.Ref<string>): number => { 49 const idx = [ 50 "Afak", 51 "Arab", 52 "Armi", 53 "Armn", 54 "Avst", 55 "Bali", 56 "Bamu", 57 "Bass", 58 "Batk", 59 "Beng", 60 "Blis", 61 "Bopo", 62 "Brah", 63 "Brai", 64 "Bugi", 65 "Buhd", 66 "Cakm", 67 "Cans", 68 "Cari", 69 "Cham", 70 "Cher", 71 "Cirt", 72 "Copt", 73 "Cprt", 74 "Cyrl", 75 "Cyrs", 76 "Deva", 77 "Dsrt", 78 "Dupl", 79 "Egyd", 80 "Egyh", 81 "Egyp", 82 "Elba", 83 "Ethi", 84 "Geor", 85 "Geok", 86 "Glag", 87 "Goth", 88 "Gran", 89 "Grek", 90 "Gujr", 91 "Guru", 92 "Hang", 93 "Hani", 94 "Hano", 95 "Hans", 96 "Hant", 97 "Hebr", 98 "Hluw", 99 "Hmng", 100 "Hung", 101 "Inds", 102 "Ital", 103 "Java", 104 "Jpan", 105 "Jurc", 106 "Kali", 107 "Khar", 108 "Khmr", 109 "Khoj", 110 "Knda", 111 "Kpel", 112 "Kthi", 113 "Lana", 114 "Laoo", 115 "Latf", 116 "Latg", 117 "Latn", 118 "Lepc", 119 "Limb", 120 "Lina", 121 "Linb", 122 "Lisu", 123 "Loma", 124 "Lyci", 125 "Lydi", 126 "Mand", 127 "Mani", 128 "Maya", 129 "Mend", 130 "Merc", 131 "Mero", 132 "Mlym", 133 "Moon", 134 "Mong", 135 "Mroo", 136 "Mtei", 137 "Mymr", 138 "Narb", 139 "Nbat", 140 "Nkgb", 141 "Nkoo", 142 "Nshu", 143 "Ogam", 144 "Olck", 145 "Orkh", 146 "Orya", 147 "Osma", 148 "Palm", 149 "Perm", 150 "Phag", 151 "Phli", 152 "Phlp", 153 "Phlv", 154 "Phnx", 155 "Plrd", 156 "Prti", 157 "Rjng", 158 "Roro", 159 "Runr", 160 "Samr", 161 "Sara", 162 "Sarb", 163 "Saur", 164 "Sgnw", 165 "Shaw", 166 "Shrd", 167 "Sind", 168 "Sinh", 169 "Sora", 170 "Sund", 171 "Sylo", 172 "Syrc", 173 "Syre", 174 "Syrj", 175 "Syrn", 176 "Tagb", 177 "Takr", 178 "Tale", 179 "Talu", 180 "Taml", 181 "Tang", 182 "Tavt", 183 "Telu", 184 "Teng", 185 "Tfng", 186 "Tglg", 187 "Thaa", 188 "Thai", 189 "Tibt", 190 "Tirh", 191 "Ugar", 192 "Vaii", 193 "Visp", 194 "Wara", 195 "Wole", 196 "Xpeo", 197 "Xsux", 198 "Yiii", 199 "Zmth", 200 "Zsym", 201 "Zyyy", 202 ].indexOf(A.H.get(ref)); 203 return idx < 0 ? 0 : idx + 1; 204 }, 205 206 "store_ClearFontArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => { 207 const x = A.H.get<any>(ref); 208 209 if (typeof x === "undefined") { 210 A.store.Bool(ptr + 8, false); 211 A.store.Enum(ptr + 0, -1); 212 A.store.Enum(ptr + 4, -1); 213 } else { 214 A.store.Bool(ptr + 8, true); 215 A.store.Enum( 216 ptr + 0, 217 ["standard", "sansserif", "serif", "fixed", "cursive", "fantasy", "math"].indexOf( 218 x["genericFamily"] as string 219 ) 220 ); 221 A.store.Enum( 222 ptr + 4, 223 [ 224 "Afak", 225 "Arab", 226 "Armi", 227 "Armn", 228 "Avst", 229 "Bali", 230 "Bamu", 231 "Bass", 232 "Batk", 233 "Beng", 234 "Blis", 235 "Bopo", 236 "Brah", 237 "Brai", 238 "Bugi", 239 "Buhd", 240 "Cakm", 241 "Cans", 242 "Cari", 243 "Cham", 244 "Cher", 245 "Cirt", 246 "Copt", 247 "Cprt", 248 "Cyrl", 249 "Cyrs", 250 "Deva", 251 "Dsrt", 252 "Dupl", 253 "Egyd", 254 "Egyh", 255 "Egyp", 256 "Elba", 257 "Ethi", 258 "Geor", 259 "Geok", 260 "Glag", 261 "Goth", 262 "Gran", 263 "Grek", 264 "Gujr", 265 "Guru", 266 "Hang", 267 "Hani", 268 "Hano", 269 "Hans", 270 "Hant", 271 "Hebr", 272 "Hluw", 273 "Hmng", 274 "Hung", 275 "Inds", 276 "Ital", 277 "Java", 278 "Jpan", 279 "Jurc", 280 "Kali", 281 "Khar", 282 "Khmr", 283 "Khoj", 284 "Knda", 285 "Kpel", 286 "Kthi", 287 "Lana", 288 "Laoo", 289 "Latf", 290 "Latg", 291 "Latn", 292 "Lepc", 293 "Limb", 294 "Lina", 295 "Linb", 296 "Lisu", 297 "Loma", 298 "Lyci", 299 "Lydi", 300 "Mand", 301 "Mani", 302 "Maya", 303 "Mend", 304 "Merc", 305 "Mero", 306 "Mlym", 307 "Moon", 308 "Mong", 309 "Mroo", 310 "Mtei", 311 "Mymr", 312 "Narb", 313 "Nbat", 314 "Nkgb", 315 "Nkoo", 316 "Nshu", 317 "Ogam", 318 "Olck", 319 "Orkh", 320 "Orya", 321 "Osma", 322 "Palm", 323 "Perm", 324 "Phag", 325 "Phli", 326 "Phlp", 327 "Phlv", 328 "Phnx", 329 "Plrd", 330 "Prti", 331 "Rjng", 332 "Roro", 333 "Runr", 334 "Samr", 335 "Sara", 336 "Sarb", 337 "Saur", 338 "Sgnw", 339 "Shaw", 340 "Shrd", 341 "Sind", 342 "Sinh", 343 "Sora", 344 "Sund", 345 "Sylo", 346 "Syrc", 347 "Syre", 348 "Syrj", 349 "Syrn", 350 "Tagb", 351 "Takr", 352 "Tale", 353 "Talu", 354 "Taml", 355 "Tang", 356 "Tavt", 357 "Telu", 358 "Teng", 359 "Tfng", 360 "Tglg", 361 "Thaa", 362 "Thai", 363 "Tibt", 364 "Tirh", 365 "Ugar", 366 "Vaii", 367 "Visp", 368 "Wara", 369 "Wole", 370 "Xpeo", 371 "Xsux", 372 "Yiii", 373 "Zmth", 374 "Zsym", 375 "Zyyy", 376 ].indexOf(x["script"] as string) 377 ); 378 } 379 }, 380 "load_ClearFontArgDetails": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 381 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 382 383 x["genericFamily"] = A.load.Enum(ptr + 0, [ 384 "standard", 385 "sansserif", 386 "serif", 387 "fixed", 388 "cursive", 389 "fantasy", 390 "math", 391 ]); 392 x["script"] = A.load.Enum(ptr + 4, [ 393 "Afak", 394 "Arab", 395 "Armi", 396 "Armn", 397 "Avst", 398 "Bali", 399 "Bamu", 400 "Bass", 401 "Batk", 402 "Beng", 403 "Blis", 404 "Bopo", 405 "Brah", 406 "Brai", 407 "Bugi", 408 "Buhd", 409 "Cakm", 410 "Cans", 411 "Cari", 412 "Cham", 413 "Cher", 414 "Cirt", 415 "Copt", 416 "Cprt", 417 "Cyrl", 418 "Cyrs", 419 "Deva", 420 "Dsrt", 421 "Dupl", 422 "Egyd", 423 "Egyh", 424 "Egyp", 425 "Elba", 426 "Ethi", 427 "Geor", 428 "Geok", 429 "Glag", 430 "Goth", 431 "Gran", 432 "Grek", 433 "Gujr", 434 "Guru", 435 "Hang", 436 "Hani", 437 "Hano", 438 "Hans", 439 "Hant", 440 "Hebr", 441 "Hluw", 442 "Hmng", 443 "Hung", 444 "Inds", 445 "Ital", 446 "Java", 447 "Jpan", 448 "Jurc", 449 "Kali", 450 "Khar", 451 "Khmr", 452 "Khoj", 453 "Knda", 454 "Kpel", 455 "Kthi", 456 "Lana", 457 "Laoo", 458 "Latf", 459 "Latg", 460 "Latn", 461 "Lepc", 462 "Limb", 463 "Lina", 464 "Linb", 465 "Lisu", 466 "Loma", 467 "Lyci", 468 "Lydi", 469 "Mand", 470 "Mani", 471 "Maya", 472 "Mend", 473 "Merc", 474 "Mero", 475 "Mlym", 476 "Moon", 477 "Mong", 478 "Mroo", 479 "Mtei", 480 "Mymr", 481 "Narb", 482 "Nbat", 483 "Nkgb", 484 "Nkoo", 485 "Nshu", 486 "Ogam", 487 "Olck", 488 "Orkh", 489 "Orya", 490 "Osma", 491 "Palm", 492 "Perm", 493 "Phag", 494 "Phli", 495 "Phlp", 496 "Phlv", 497 "Phnx", 498 "Plrd", 499 "Prti", 500 "Rjng", 501 "Roro", 502 "Runr", 503 "Samr", 504 "Sara", 505 "Sarb", 506 "Saur", 507 "Sgnw", 508 "Shaw", 509 "Shrd", 510 "Sind", 511 "Sinh", 512 "Sora", 513 "Sund", 514 "Sylo", 515 "Syrc", 516 "Syre", 517 "Syrj", 518 "Syrn", 519 "Tagb", 520 "Takr", 521 "Tale", 522 "Talu", 523 "Taml", 524 "Tang", 525 "Tavt", 526 "Telu", 527 "Teng", 528 "Tfng", 529 "Tglg", 530 "Thaa", 531 "Thai", 532 "Tibt", 533 "Tirh", 534 "Ugar", 535 "Vaii", 536 "Visp", 537 "Wara", 538 "Wole", 539 "Xpeo", 540 "Xsux", 541 "Yiii", 542 "Zmth", 543 "Zsym", 544 "Zyyy", 545 ]); 546 return create === A.H.TRUE ? A.H.push(x) : ref; 547 }, 548 549 "store_ClearMinimumFontSizeArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => { 550 const x = A.H.get<any>(ref); 551 552 if (typeof x === "undefined") { 553 A.store.Bool(ptr + 0, false); 554 } else { 555 A.store.Bool(ptr + 0, true); 556 } 557 }, 558 "load_ClearMinimumFontSizeArgDetails": ( 559 ptr: Pointer, 560 create: heap.Ref<boolean>, 561 ref: heap.Ref<any> 562 ): heap.Ref<any> => { 563 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 564 565 return create === A.H.TRUE ? A.H.push(x) : ref; 566 }, 567 568 "store_FontName": (ptr: Pointer, ref: heap.Ref<any>) => { 569 const x = A.H.get<any>(ref); 570 571 if (typeof x === "undefined") { 572 A.store.Bool(ptr + 8, false); 573 A.store.Ref(ptr + 0, undefined); 574 A.store.Ref(ptr + 4, undefined); 575 } else { 576 A.store.Bool(ptr + 8, true); 577 A.store.Ref(ptr + 0, x["displayName"]); 578 A.store.Ref(ptr + 4, x["fontId"]); 579 } 580 }, 581 "load_FontName": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 582 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 583 584 x["displayName"] = A.load.Ref(ptr + 0, undefined); 585 x["fontId"] = A.load.Ref(ptr + 4, undefined); 586 return create === A.H.TRUE ? A.H.push(x) : ref; 587 }, 588 589 "store_GetDefaultFixedFontSizeArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => { 590 const x = A.H.get<any>(ref); 591 592 if (typeof x === "undefined") { 593 A.store.Bool(ptr + 0, false); 594 } else { 595 A.store.Bool(ptr + 0, true); 596 } 597 }, 598 "load_GetDefaultFixedFontSizeArgDetails": ( 599 ptr: Pointer, 600 create: heap.Ref<boolean>, 601 ref: heap.Ref<any> 602 ): heap.Ref<any> => { 603 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 604 605 return create === A.H.TRUE ? A.H.push(x) : ref; 606 }, 607 "constof_LevelOfControl": (ref: heap.Ref<string>): number => { 608 const idx = [ 609 "not_controllable", 610 "controlled_by_other_extensions", 611 "controllable_by_this_extension", 612 "controlled_by_this_extension", 613 ].indexOf(A.H.get(ref)); 614 return idx < 0 ? 0 : idx + 1; 615 }, 616 617 "store_GetDefaultFixedFontSizeReturnType": (ptr: Pointer, ref: heap.Ref<any>) => { 618 const x = A.H.get<any>(ref); 619 620 if (typeof x === "undefined") { 621 A.store.Bool(ptr + 16, false); 622 A.store.Enum(ptr + 0, -1); 623 A.store.Int64(ptr + 8, 0); 624 } else { 625 A.store.Bool(ptr + 16, true); 626 A.store.Enum( 627 ptr + 0, 628 [ 629 "not_controllable", 630 "controlled_by_other_extensions", 631 "controllable_by_this_extension", 632 "controlled_by_this_extension", 633 ].indexOf(x["levelOfControl"] as string) 634 ); 635 A.store.Int64(ptr + 8, x["pixelSize"] === undefined ? 0 : (x["pixelSize"] as number)); 636 } 637 }, 638 "load_GetDefaultFixedFontSizeReturnType": ( 639 ptr: Pointer, 640 create: heap.Ref<boolean>, 641 ref: heap.Ref<any> 642 ): heap.Ref<any> => { 643 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 644 645 x["levelOfControl"] = A.load.Enum(ptr + 0, [ 646 "not_controllable", 647 "controlled_by_other_extensions", 648 "controllable_by_this_extension", 649 "controlled_by_this_extension", 650 ]); 651 x["pixelSize"] = A.load.Int64(ptr + 8); 652 return create === A.H.TRUE ? A.H.push(x) : ref; 653 }, 654 655 "store_GetDefaultFontSizeArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => { 656 const x = A.H.get<any>(ref); 657 658 if (typeof x === "undefined") { 659 A.store.Bool(ptr + 0, false); 660 } else { 661 A.store.Bool(ptr + 0, true); 662 } 663 }, 664 "load_GetDefaultFontSizeArgDetails": ( 665 ptr: Pointer, 666 create: heap.Ref<boolean>, 667 ref: heap.Ref<any> 668 ): heap.Ref<any> => { 669 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 670 671 return create === A.H.TRUE ? A.H.push(x) : ref; 672 }, 673 674 "store_GetDefaultFontSizeReturnType": (ptr: Pointer, ref: heap.Ref<any>) => { 675 const x = A.H.get<any>(ref); 676 677 if (typeof x === "undefined") { 678 A.store.Bool(ptr + 16, false); 679 A.store.Enum(ptr + 0, -1); 680 A.store.Int64(ptr + 8, 0); 681 } else { 682 A.store.Bool(ptr + 16, true); 683 A.store.Enum( 684 ptr + 0, 685 [ 686 "not_controllable", 687 "controlled_by_other_extensions", 688 "controllable_by_this_extension", 689 "controlled_by_this_extension", 690 ].indexOf(x["levelOfControl"] as string) 691 ); 692 A.store.Int64(ptr + 8, x["pixelSize"] === undefined ? 0 : (x["pixelSize"] as number)); 693 } 694 }, 695 "load_GetDefaultFontSizeReturnType": ( 696 ptr: Pointer, 697 create: heap.Ref<boolean>, 698 ref: heap.Ref<any> 699 ): heap.Ref<any> => { 700 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 701 702 x["levelOfControl"] = A.load.Enum(ptr + 0, [ 703 "not_controllable", 704 "controlled_by_other_extensions", 705 "controllable_by_this_extension", 706 "controlled_by_this_extension", 707 ]); 708 x["pixelSize"] = A.load.Int64(ptr + 8); 709 return create === A.H.TRUE ? A.H.push(x) : ref; 710 }, 711 712 "store_GetFontArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => { 713 const x = A.H.get<any>(ref); 714 715 if (typeof x === "undefined") { 716 A.store.Bool(ptr + 8, false); 717 A.store.Enum(ptr + 0, -1); 718 A.store.Enum(ptr + 4, -1); 719 } else { 720 A.store.Bool(ptr + 8, true); 721 A.store.Enum( 722 ptr + 0, 723 ["standard", "sansserif", "serif", "fixed", "cursive", "fantasy", "math"].indexOf( 724 x["genericFamily"] as string 725 ) 726 ); 727 A.store.Enum( 728 ptr + 4, 729 [ 730 "Afak", 731 "Arab", 732 "Armi", 733 "Armn", 734 "Avst", 735 "Bali", 736 "Bamu", 737 "Bass", 738 "Batk", 739 "Beng", 740 "Blis", 741 "Bopo", 742 "Brah", 743 "Brai", 744 "Bugi", 745 "Buhd", 746 "Cakm", 747 "Cans", 748 "Cari", 749 "Cham", 750 "Cher", 751 "Cirt", 752 "Copt", 753 "Cprt", 754 "Cyrl", 755 "Cyrs", 756 "Deva", 757 "Dsrt", 758 "Dupl", 759 "Egyd", 760 "Egyh", 761 "Egyp", 762 "Elba", 763 "Ethi", 764 "Geor", 765 "Geok", 766 "Glag", 767 "Goth", 768 "Gran", 769 "Grek", 770 "Gujr", 771 "Guru", 772 "Hang", 773 "Hani", 774 "Hano", 775 "Hans", 776 "Hant", 777 "Hebr", 778 "Hluw", 779 "Hmng", 780 "Hung", 781 "Inds", 782 "Ital", 783 "Java", 784 "Jpan", 785 "Jurc", 786 "Kali", 787 "Khar", 788 "Khmr", 789 "Khoj", 790 "Knda", 791 "Kpel", 792 "Kthi", 793 "Lana", 794 "Laoo", 795 "Latf", 796 "Latg", 797 "Latn", 798 "Lepc", 799 "Limb", 800 "Lina", 801 "Linb", 802 "Lisu", 803 "Loma", 804 "Lyci", 805 "Lydi", 806 "Mand", 807 "Mani", 808 "Maya", 809 "Mend", 810 "Merc", 811 "Mero", 812 "Mlym", 813 "Moon", 814 "Mong", 815 "Mroo", 816 "Mtei", 817 "Mymr", 818 "Narb", 819 "Nbat", 820 "Nkgb", 821 "Nkoo", 822 "Nshu", 823 "Ogam", 824 "Olck", 825 "Orkh", 826 "Orya", 827 "Osma", 828 "Palm", 829 "Perm", 830 "Phag", 831 "Phli", 832 "Phlp", 833 "Phlv", 834 "Phnx", 835 "Plrd", 836 "Prti", 837 "Rjng", 838 "Roro", 839 "Runr", 840 "Samr", 841 "Sara", 842 "Sarb", 843 "Saur", 844 "Sgnw", 845 "Shaw", 846 "Shrd", 847 "Sind", 848 "Sinh", 849 "Sora", 850 "Sund", 851 "Sylo", 852 "Syrc", 853 "Syre", 854 "Syrj", 855 "Syrn", 856 "Tagb", 857 "Takr", 858 "Tale", 859 "Talu", 860 "Taml", 861 "Tang", 862 "Tavt", 863 "Telu", 864 "Teng", 865 "Tfng", 866 "Tglg", 867 "Thaa", 868 "Thai", 869 "Tibt", 870 "Tirh", 871 "Ugar", 872 "Vaii", 873 "Visp", 874 "Wara", 875 "Wole", 876 "Xpeo", 877 "Xsux", 878 "Yiii", 879 "Zmth", 880 "Zsym", 881 "Zyyy", 882 ].indexOf(x["script"] as string) 883 ); 884 } 885 }, 886 "load_GetFontArgDetails": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 887 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 888 889 x["genericFamily"] = A.load.Enum(ptr + 0, [ 890 "standard", 891 "sansserif", 892 "serif", 893 "fixed", 894 "cursive", 895 "fantasy", 896 "math", 897 ]); 898 x["script"] = A.load.Enum(ptr + 4, [ 899 "Afak", 900 "Arab", 901 "Armi", 902 "Armn", 903 "Avst", 904 "Bali", 905 "Bamu", 906 "Bass", 907 "Batk", 908 "Beng", 909 "Blis", 910 "Bopo", 911 "Brah", 912 "Brai", 913 "Bugi", 914 "Buhd", 915 "Cakm", 916 "Cans", 917 "Cari", 918 "Cham", 919 "Cher", 920 "Cirt", 921 "Copt", 922 "Cprt", 923 "Cyrl", 924 "Cyrs", 925 "Deva", 926 "Dsrt", 927 "Dupl", 928 "Egyd", 929 "Egyh", 930 "Egyp", 931 "Elba", 932 "Ethi", 933 "Geor", 934 "Geok", 935 "Glag", 936 "Goth", 937 "Gran", 938 "Grek", 939 "Gujr", 940 "Guru", 941 "Hang", 942 "Hani", 943 "Hano", 944 "Hans", 945 "Hant", 946 "Hebr", 947 "Hluw", 948 "Hmng", 949 "Hung", 950 "Inds", 951 "Ital", 952 "Java", 953 "Jpan", 954 "Jurc", 955 "Kali", 956 "Khar", 957 "Khmr", 958 "Khoj", 959 "Knda", 960 "Kpel", 961 "Kthi", 962 "Lana", 963 "Laoo", 964 "Latf", 965 "Latg", 966 "Latn", 967 "Lepc", 968 "Limb", 969 "Lina", 970 "Linb", 971 "Lisu", 972 "Loma", 973 "Lyci", 974 "Lydi", 975 "Mand", 976 "Mani", 977 "Maya", 978 "Mend", 979 "Merc", 980 "Mero", 981 "Mlym", 982 "Moon", 983 "Mong", 984 "Mroo", 985 "Mtei", 986 "Mymr", 987 "Narb", 988 "Nbat", 989 "Nkgb", 990 "Nkoo", 991 "Nshu", 992 "Ogam", 993 "Olck", 994 "Orkh", 995 "Orya", 996 "Osma", 997 "Palm", 998 "Perm", 999 "Phag", 1000 "Phli", 1001 "Phlp", 1002 "Phlv", 1003 "Phnx", 1004 "Plrd", 1005 "Prti", 1006 "Rjng", 1007 "Roro", 1008 "Runr", 1009 "Samr", 1010 "Sara", 1011 "Sarb", 1012 "Saur", 1013 "Sgnw", 1014 "Shaw", 1015 "Shrd", 1016 "Sind", 1017 "Sinh", 1018 "Sora", 1019 "Sund", 1020 "Sylo", 1021 "Syrc", 1022 "Syre", 1023 "Syrj", 1024 "Syrn", 1025 "Tagb", 1026 "Takr", 1027 "Tale", 1028 "Talu", 1029 "Taml", 1030 "Tang", 1031 "Tavt", 1032 "Telu", 1033 "Teng", 1034 "Tfng", 1035 "Tglg", 1036 "Thaa", 1037 "Thai", 1038 "Tibt", 1039 "Tirh", 1040 "Ugar", 1041 "Vaii", 1042 "Visp", 1043 "Wara", 1044 "Wole", 1045 "Xpeo", 1046 "Xsux", 1047 "Yiii", 1048 "Zmth", 1049 "Zsym", 1050 "Zyyy", 1051 ]); 1052 return create === A.H.TRUE ? A.H.push(x) : ref; 1053 }, 1054 1055 "store_GetFontReturnType": (ptr: Pointer, ref: heap.Ref<any>) => { 1056 const x = A.H.get<any>(ref); 1057 1058 if (typeof x === "undefined") { 1059 A.store.Bool(ptr + 8, false); 1060 A.store.Ref(ptr + 0, undefined); 1061 A.store.Enum(ptr + 4, -1); 1062 } else { 1063 A.store.Bool(ptr + 8, true); 1064 A.store.Ref(ptr + 0, x["fontId"]); 1065 A.store.Enum( 1066 ptr + 4, 1067 [ 1068 "not_controllable", 1069 "controlled_by_other_extensions", 1070 "controllable_by_this_extension", 1071 "controlled_by_this_extension", 1072 ].indexOf(x["levelOfControl"] as string) 1073 ); 1074 } 1075 }, 1076 "load_GetFontReturnType": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 1077 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 1078 1079 x["fontId"] = A.load.Ref(ptr + 0, undefined); 1080 x["levelOfControl"] = A.load.Enum(ptr + 4, [ 1081 "not_controllable", 1082 "controlled_by_other_extensions", 1083 "controllable_by_this_extension", 1084 "controlled_by_this_extension", 1085 ]); 1086 return create === A.H.TRUE ? A.H.push(x) : ref; 1087 }, 1088 1089 "store_GetMinimumFontSizeArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => { 1090 const x = A.H.get<any>(ref); 1091 1092 if (typeof x === "undefined") { 1093 A.store.Bool(ptr + 0, false); 1094 } else { 1095 A.store.Bool(ptr + 0, true); 1096 } 1097 }, 1098 "load_GetMinimumFontSizeArgDetails": ( 1099 ptr: Pointer, 1100 create: heap.Ref<boolean>, 1101 ref: heap.Ref<any> 1102 ): heap.Ref<any> => { 1103 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 1104 1105 return create === A.H.TRUE ? A.H.push(x) : ref; 1106 }, 1107 1108 "store_GetMinimumFontSizeReturnType": (ptr: Pointer, ref: heap.Ref<any>) => { 1109 const x = A.H.get<any>(ref); 1110 1111 if (typeof x === "undefined") { 1112 A.store.Bool(ptr + 16, false); 1113 A.store.Enum(ptr + 0, -1); 1114 A.store.Int64(ptr + 8, 0); 1115 } else { 1116 A.store.Bool(ptr + 16, true); 1117 A.store.Enum( 1118 ptr + 0, 1119 [ 1120 "not_controllable", 1121 "controlled_by_other_extensions", 1122 "controllable_by_this_extension", 1123 "controlled_by_this_extension", 1124 ].indexOf(x["levelOfControl"] as string) 1125 ); 1126 A.store.Int64(ptr + 8, x["pixelSize"] === undefined ? 0 : (x["pixelSize"] as number)); 1127 } 1128 }, 1129 "load_GetMinimumFontSizeReturnType": ( 1130 ptr: Pointer, 1131 create: heap.Ref<boolean>, 1132 ref: heap.Ref<any> 1133 ): heap.Ref<any> => { 1134 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 1135 1136 x["levelOfControl"] = A.load.Enum(ptr + 0, [ 1137 "not_controllable", 1138 "controlled_by_other_extensions", 1139 "controllable_by_this_extension", 1140 "controlled_by_this_extension", 1141 ]); 1142 x["pixelSize"] = A.load.Int64(ptr + 8); 1143 return create === A.H.TRUE ? A.H.push(x) : ref; 1144 }, 1145 1146 "store_OnDefaultFixedFontSizeChangedArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => { 1147 const x = A.H.get<any>(ref); 1148 1149 if (typeof x === "undefined") { 1150 A.store.Bool(ptr + 16, false); 1151 A.store.Enum(ptr + 0, -1); 1152 A.store.Int64(ptr + 8, 0); 1153 } else { 1154 A.store.Bool(ptr + 16, true); 1155 A.store.Enum( 1156 ptr + 0, 1157 [ 1158 "not_controllable", 1159 "controlled_by_other_extensions", 1160 "controllable_by_this_extension", 1161 "controlled_by_this_extension", 1162 ].indexOf(x["levelOfControl"] as string) 1163 ); 1164 A.store.Int64(ptr + 8, x["pixelSize"] === undefined ? 0 : (x["pixelSize"] as number)); 1165 } 1166 }, 1167 "load_OnDefaultFixedFontSizeChangedArgDetails": ( 1168 ptr: Pointer, 1169 create: heap.Ref<boolean>, 1170 ref: heap.Ref<any> 1171 ): heap.Ref<any> => { 1172 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 1173 1174 x["levelOfControl"] = A.load.Enum(ptr + 0, [ 1175 "not_controllable", 1176 "controlled_by_other_extensions", 1177 "controllable_by_this_extension", 1178 "controlled_by_this_extension", 1179 ]); 1180 x["pixelSize"] = A.load.Int64(ptr + 8); 1181 return create === A.H.TRUE ? A.H.push(x) : ref; 1182 }, 1183 1184 "store_OnDefaultFontSizeChangedArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => { 1185 const x = A.H.get<any>(ref); 1186 1187 if (typeof x === "undefined") { 1188 A.store.Bool(ptr + 16, false); 1189 A.store.Enum(ptr + 0, -1); 1190 A.store.Int64(ptr + 8, 0); 1191 } else { 1192 A.store.Bool(ptr + 16, true); 1193 A.store.Enum( 1194 ptr + 0, 1195 [ 1196 "not_controllable", 1197 "controlled_by_other_extensions", 1198 "controllable_by_this_extension", 1199 "controlled_by_this_extension", 1200 ].indexOf(x["levelOfControl"] as string) 1201 ); 1202 A.store.Int64(ptr + 8, x["pixelSize"] === undefined ? 0 : (x["pixelSize"] as number)); 1203 } 1204 }, 1205 "load_OnDefaultFontSizeChangedArgDetails": ( 1206 ptr: Pointer, 1207 create: heap.Ref<boolean>, 1208 ref: heap.Ref<any> 1209 ): heap.Ref<any> => { 1210 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 1211 1212 x["levelOfControl"] = A.load.Enum(ptr + 0, [ 1213 "not_controllable", 1214 "controlled_by_other_extensions", 1215 "controllable_by_this_extension", 1216 "controlled_by_this_extension", 1217 ]); 1218 x["pixelSize"] = A.load.Int64(ptr + 8); 1219 return create === A.H.TRUE ? A.H.push(x) : ref; 1220 }, 1221 1222 "store_OnFontChangedArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => { 1223 const x = A.H.get<any>(ref); 1224 1225 if (typeof x === "undefined") { 1226 A.store.Bool(ptr + 16, false); 1227 A.store.Ref(ptr + 0, undefined); 1228 A.store.Enum(ptr + 4, -1); 1229 A.store.Enum(ptr + 8, -1); 1230 A.store.Enum(ptr + 12, -1); 1231 } else { 1232 A.store.Bool(ptr + 16, true); 1233 A.store.Ref(ptr + 0, x["fontId"]); 1234 A.store.Enum( 1235 ptr + 4, 1236 ["standard", "sansserif", "serif", "fixed", "cursive", "fantasy", "math"].indexOf( 1237 x["genericFamily"] as string 1238 ) 1239 ); 1240 A.store.Enum( 1241 ptr + 8, 1242 [ 1243 "not_controllable", 1244 "controlled_by_other_extensions", 1245 "controllable_by_this_extension", 1246 "controlled_by_this_extension", 1247 ].indexOf(x["levelOfControl"] as string) 1248 ); 1249 A.store.Enum( 1250 ptr + 12, 1251 [ 1252 "Afak", 1253 "Arab", 1254 "Armi", 1255 "Armn", 1256 "Avst", 1257 "Bali", 1258 "Bamu", 1259 "Bass", 1260 "Batk", 1261 "Beng", 1262 "Blis", 1263 "Bopo", 1264 "Brah", 1265 "Brai", 1266 "Bugi", 1267 "Buhd", 1268 "Cakm", 1269 "Cans", 1270 "Cari", 1271 "Cham", 1272 "Cher", 1273 "Cirt", 1274 "Copt", 1275 "Cprt", 1276 "Cyrl", 1277 "Cyrs", 1278 "Deva", 1279 "Dsrt", 1280 "Dupl", 1281 "Egyd", 1282 "Egyh", 1283 "Egyp", 1284 "Elba", 1285 "Ethi", 1286 "Geor", 1287 "Geok", 1288 "Glag", 1289 "Goth", 1290 "Gran", 1291 "Grek", 1292 "Gujr", 1293 "Guru", 1294 "Hang", 1295 "Hani", 1296 "Hano", 1297 "Hans", 1298 "Hant", 1299 "Hebr", 1300 "Hluw", 1301 "Hmng", 1302 "Hung", 1303 "Inds", 1304 "Ital", 1305 "Java", 1306 "Jpan", 1307 "Jurc", 1308 "Kali", 1309 "Khar", 1310 "Khmr", 1311 "Khoj", 1312 "Knda", 1313 "Kpel", 1314 "Kthi", 1315 "Lana", 1316 "Laoo", 1317 "Latf", 1318 "Latg", 1319 "Latn", 1320 "Lepc", 1321 "Limb", 1322 "Lina", 1323 "Linb", 1324 "Lisu", 1325 "Loma", 1326 "Lyci", 1327 "Lydi", 1328 "Mand", 1329 "Mani", 1330 "Maya", 1331 "Mend", 1332 "Merc", 1333 "Mero", 1334 "Mlym", 1335 "Moon", 1336 "Mong", 1337 "Mroo", 1338 "Mtei", 1339 "Mymr", 1340 "Narb", 1341 "Nbat", 1342 "Nkgb", 1343 "Nkoo", 1344 "Nshu", 1345 "Ogam", 1346 "Olck", 1347 "Orkh", 1348 "Orya", 1349 "Osma", 1350 "Palm", 1351 "Perm", 1352 "Phag", 1353 "Phli", 1354 "Phlp", 1355 "Phlv", 1356 "Phnx", 1357 "Plrd", 1358 "Prti", 1359 "Rjng", 1360 "Roro", 1361 "Runr", 1362 "Samr", 1363 "Sara", 1364 "Sarb", 1365 "Saur", 1366 "Sgnw", 1367 "Shaw", 1368 "Shrd", 1369 "Sind", 1370 "Sinh", 1371 "Sora", 1372 "Sund", 1373 "Sylo", 1374 "Syrc", 1375 "Syre", 1376 "Syrj", 1377 "Syrn", 1378 "Tagb", 1379 "Takr", 1380 "Tale", 1381 "Talu", 1382 "Taml", 1383 "Tang", 1384 "Tavt", 1385 "Telu", 1386 "Teng", 1387 "Tfng", 1388 "Tglg", 1389 "Thaa", 1390 "Thai", 1391 "Tibt", 1392 "Tirh", 1393 "Ugar", 1394 "Vaii", 1395 "Visp", 1396 "Wara", 1397 "Wole", 1398 "Xpeo", 1399 "Xsux", 1400 "Yiii", 1401 "Zmth", 1402 "Zsym", 1403 "Zyyy", 1404 ].indexOf(x["script"] as string) 1405 ); 1406 } 1407 }, 1408 "load_OnFontChangedArgDetails": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 1409 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 1410 1411 x["fontId"] = A.load.Ref(ptr + 0, undefined); 1412 x["genericFamily"] = A.load.Enum(ptr + 4, [ 1413 "standard", 1414 "sansserif", 1415 "serif", 1416 "fixed", 1417 "cursive", 1418 "fantasy", 1419 "math", 1420 ]); 1421 x["levelOfControl"] = A.load.Enum(ptr + 8, [ 1422 "not_controllable", 1423 "controlled_by_other_extensions", 1424 "controllable_by_this_extension", 1425 "controlled_by_this_extension", 1426 ]); 1427 x["script"] = A.load.Enum(ptr + 12, [ 1428 "Afak", 1429 "Arab", 1430 "Armi", 1431 "Armn", 1432 "Avst", 1433 "Bali", 1434 "Bamu", 1435 "Bass", 1436 "Batk", 1437 "Beng", 1438 "Blis", 1439 "Bopo", 1440 "Brah", 1441 "Brai", 1442 "Bugi", 1443 "Buhd", 1444 "Cakm", 1445 "Cans", 1446 "Cari", 1447 "Cham", 1448 "Cher", 1449 "Cirt", 1450 "Copt", 1451 "Cprt", 1452 "Cyrl", 1453 "Cyrs", 1454 "Deva", 1455 "Dsrt", 1456 "Dupl", 1457 "Egyd", 1458 "Egyh", 1459 "Egyp", 1460 "Elba", 1461 "Ethi", 1462 "Geor", 1463 "Geok", 1464 "Glag", 1465 "Goth", 1466 "Gran", 1467 "Grek", 1468 "Gujr", 1469 "Guru", 1470 "Hang", 1471 "Hani", 1472 "Hano", 1473 "Hans", 1474 "Hant", 1475 "Hebr", 1476 "Hluw", 1477 "Hmng", 1478 "Hung", 1479 "Inds", 1480 "Ital", 1481 "Java", 1482 "Jpan", 1483 "Jurc", 1484 "Kali", 1485 "Khar", 1486 "Khmr", 1487 "Khoj", 1488 "Knda", 1489 "Kpel", 1490 "Kthi", 1491 "Lana", 1492 "Laoo", 1493 "Latf", 1494 "Latg", 1495 "Latn", 1496 "Lepc", 1497 "Limb", 1498 "Lina", 1499 "Linb", 1500 "Lisu", 1501 "Loma", 1502 "Lyci", 1503 "Lydi", 1504 "Mand", 1505 "Mani", 1506 "Maya", 1507 "Mend", 1508 "Merc", 1509 "Mero", 1510 "Mlym", 1511 "Moon", 1512 "Mong", 1513 "Mroo", 1514 "Mtei", 1515 "Mymr", 1516 "Narb", 1517 "Nbat", 1518 "Nkgb", 1519 "Nkoo", 1520 "Nshu", 1521 "Ogam", 1522 "Olck", 1523 "Orkh", 1524 "Orya", 1525 "Osma", 1526 "Palm", 1527 "Perm", 1528 "Phag", 1529 "Phli", 1530 "Phlp", 1531 "Phlv", 1532 "Phnx", 1533 "Plrd", 1534 "Prti", 1535 "Rjng", 1536 "Roro", 1537 "Runr", 1538 "Samr", 1539 "Sara", 1540 "Sarb", 1541 "Saur", 1542 "Sgnw", 1543 "Shaw", 1544 "Shrd", 1545 "Sind", 1546 "Sinh", 1547 "Sora", 1548 "Sund", 1549 "Sylo", 1550 "Syrc", 1551 "Syre", 1552 "Syrj", 1553 "Syrn", 1554 "Tagb", 1555 "Takr", 1556 "Tale", 1557 "Talu", 1558 "Taml", 1559 "Tang", 1560 "Tavt", 1561 "Telu", 1562 "Teng", 1563 "Tfng", 1564 "Tglg", 1565 "Thaa", 1566 "Thai", 1567 "Tibt", 1568 "Tirh", 1569 "Ugar", 1570 "Vaii", 1571 "Visp", 1572 "Wara", 1573 "Wole", 1574 "Xpeo", 1575 "Xsux", 1576 "Yiii", 1577 "Zmth", 1578 "Zsym", 1579 "Zyyy", 1580 ]); 1581 return create === A.H.TRUE ? A.H.push(x) : ref; 1582 }, 1583 1584 "store_OnMinimumFontSizeChangedArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => { 1585 const x = A.H.get<any>(ref); 1586 1587 if (typeof x === "undefined") { 1588 A.store.Bool(ptr + 16, false); 1589 A.store.Enum(ptr + 0, -1); 1590 A.store.Int64(ptr + 8, 0); 1591 } else { 1592 A.store.Bool(ptr + 16, true); 1593 A.store.Enum( 1594 ptr + 0, 1595 [ 1596 "not_controllable", 1597 "controlled_by_other_extensions", 1598 "controllable_by_this_extension", 1599 "controlled_by_this_extension", 1600 ].indexOf(x["levelOfControl"] as string) 1601 ); 1602 A.store.Int64(ptr + 8, x["pixelSize"] === undefined ? 0 : (x["pixelSize"] as number)); 1603 } 1604 }, 1605 "load_OnMinimumFontSizeChangedArgDetails": ( 1606 ptr: Pointer, 1607 create: heap.Ref<boolean>, 1608 ref: heap.Ref<any> 1609 ): heap.Ref<any> => { 1610 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 1611 1612 x["levelOfControl"] = A.load.Enum(ptr + 0, [ 1613 "not_controllable", 1614 "controlled_by_other_extensions", 1615 "controllable_by_this_extension", 1616 "controlled_by_this_extension", 1617 ]); 1618 x["pixelSize"] = A.load.Int64(ptr + 8); 1619 return create === A.H.TRUE ? A.H.push(x) : ref; 1620 }, 1621 1622 "store_SetDefaultFixedFontSizeArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => { 1623 const x = A.H.get<any>(ref); 1624 1625 if (typeof x === "undefined") { 1626 A.store.Bool(ptr + 8, false); 1627 A.store.Int64(ptr + 0, 0); 1628 } else { 1629 A.store.Bool(ptr + 8, true); 1630 A.store.Int64(ptr + 0, x["pixelSize"] === undefined ? 0 : (x["pixelSize"] as number)); 1631 } 1632 }, 1633 "load_SetDefaultFixedFontSizeArgDetails": ( 1634 ptr: Pointer, 1635 create: heap.Ref<boolean>, 1636 ref: heap.Ref<any> 1637 ): heap.Ref<any> => { 1638 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 1639 1640 x["pixelSize"] = A.load.Int64(ptr + 0); 1641 return create === A.H.TRUE ? A.H.push(x) : ref; 1642 }, 1643 1644 "store_SetDefaultFontSizeArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => { 1645 const x = A.H.get<any>(ref); 1646 1647 if (typeof x === "undefined") { 1648 A.store.Bool(ptr + 8, false); 1649 A.store.Int64(ptr + 0, 0); 1650 } else { 1651 A.store.Bool(ptr + 8, true); 1652 A.store.Int64(ptr + 0, x["pixelSize"] === undefined ? 0 : (x["pixelSize"] as number)); 1653 } 1654 }, 1655 "load_SetDefaultFontSizeArgDetails": ( 1656 ptr: Pointer, 1657 create: heap.Ref<boolean>, 1658 ref: heap.Ref<any> 1659 ): heap.Ref<any> => { 1660 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 1661 1662 x["pixelSize"] = A.load.Int64(ptr + 0); 1663 return create === A.H.TRUE ? A.H.push(x) : ref; 1664 }, 1665 1666 "store_SetFontArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => { 1667 const x = A.H.get<any>(ref); 1668 1669 if (typeof x === "undefined") { 1670 A.store.Bool(ptr + 12, false); 1671 A.store.Ref(ptr + 0, undefined); 1672 A.store.Enum(ptr + 4, -1); 1673 A.store.Enum(ptr + 8, -1); 1674 } else { 1675 A.store.Bool(ptr + 12, true); 1676 A.store.Ref(ptr + 0, x["fontId"]); 1677 A.store.Enum( 1678 ptr + 4, 1679 ["standard", "sansserif", "serif", "fixed", "cursive", "fantasy", "math"].indexOf( 1680 x["genericFamily"] as string 1681 ) 1682 ); 1683 A.store.Enum( 1684 ptr + 8, 1685 [ 1686 "Afak", 1687 "Arab", 1688 "Armi", 1689 "Armn", 1690 "Avst", 1691 "Bali", 1692 "Bamu", 1693 "Bass", 1694 "Batk", 1695 "Beng", 1696 "Blis", 1697 "Bopo", 1698 "Brah", 1699 "Brai", 1700 "Bugi", 1701 "Buhd", 1702 "Cakm", 1703 "Cans", 1704 "Cari", 1705 "Cham", 1706 "Cher", 1707 "Cirt", 1708 "Copt", 1709 "Cprt", 1710 "Cyrl", 1711 "Cyrs", 1712 "Deva", 1713 "Dsrt", 1714 "Dupl", 1715 "Egyd", 1716 "Egyh", 1717 "Egyp", 1718 "Elba", 1719 "Ethi", 1720 "Geor", 1721 "Geok", 1722 "Glag", 1723 "Goth", 1724 "Gran", 1725 "Grek", 1726 "Gujr", 1727 "Guru", 1728 "Hang", 1729 "Hani", 1730 "Hano", 1731 "Hans", 1732 "Hant", 1733 "Hebr", 1734 "Hluw", 1735 "Hmng", 1736 "Hung", 1737 "Inds", 1738 "Ital", 1739 "Java", 1740 "Jpan", 1741 "Jurc", 1742 "Kali", 1743 "Khar", 1744 "Khmr", 1745 "Khoj", 1746 "Knda", 1747 "Kpel", 1748 "Kthi", 1749 "Lana", 1750 "Laoo", 1751 "Latf", 1752 "Latg", 1753 "Latn", 1754 "Lepc", 1755 "Limb", 1756 "Lina", 1757 "Linb", 1758 "Lisu", 1759 "Loma", 1760 "Lyci", 1761 "Lydi", 1762 "Mand", 1763 "Mani", 1764 "Maya", 1765 "Mend", 1766 "Merc", 1767 "Mero", 1768 "Mlym", 1769 "Moon", 1770 "Mong", 1771 "Mroo", 1772 "Mtei", 1773 "Mymr", 1774 "Narb", 1775 "Nbat", 1776 "Nkgb", 1777 "Nkoo", 1778 "Nshu", 1779 "Ogam", 1780 "Olck", 1781 "Orkh", 1782 "Orya", 1783 "Osma", 1784 "Palm", 1785 "Perm", 1786 "Phag", 1787 "Phli", 1788 "Phlp", 1789 "Phlv", 1790 "Phnx", 1791 "Plrd", 1792 "Prti", 1793 "Rjng", 1794 "Roro", 1795 "Runr", 1796 "Samr", 1797 "Sara", 1798 "Sarb", 1799 "Saur", 1800 "Sgnw", 1801 "Shaw", 1802 "Shrd", 1803 "Sind", 1804 "Sinh", 1805 "Sora", 1806 "Sund", 1807 "Sylo", 1808 "Syrc", 1809 "Syre", 1810 "Syrj", 1811 "Syrn", 1812 "Tagb", 1813 "Takr", 1814 "Tale", 1815 "Talu", 1816 "Taml", 1817 "Tang", 1818 "Tavt", 1819 "Telu", 1820 "Teng", 1821 "Tfng", 1822 "Tglg", 1823 "Thaa", 1824 "Thai", 1825 "Tibt", 1826 "Tirh", 1827 "Ugar", 1828 "Vaii", 1829 "Visp", 1830 "Wara", 1831 "Wole", 1832 "Xpeo", 1833 "Xsux", 1834 "Yiii", 1835 "Zmth", 1836 "Zsym", 1837 "Zyyy", 1838 ].indexOf(x["script"] as string) 1839 ); 1840 } 1841 }, 1842 "load_SetFontArgDetails": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 1843 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 1844 1845 x["fontId"] = A.load.Ref(ptr + 0, undefined); 1846 x["genericFamily"] = A.load.Enum(ptr + 4, [ 1847 "standard", 1848 "sansserif", 1849 "serif", 1850 "fixed", 1851 "cursive", 1852 "fantasy", 1853 "math", 1854 ]); 1855 x["script"] = A.load.Enum(ptr + 8, [ 1856 "Afak", 1857 "Arab", 1858 "Armi", 1859 "Armn", 1860 "Avst", 1861 "Bali", 1862 "Bamu", 1863 "Bass", 1864 "Batk", 1865 "Beng", 1866 "Blis", 1867 "Bopo", 1868 "Brah", 1869 "Brai", 1870 "Bugi", 1871 "Buhd", 1872 "Cakm", 1873 "Cans", 1874 "Cari", 1875 "Cham", 1876 "Cher", 1877 "Cirt", 1878 "Copt", 1879 "Cprt", 1880 "Cyrl", 1881 "Cyrs", 1882 "Deva", 1883 "Dsrt", 1884 "Dupl", 1885 "Egyd", 1886 "Egyh", 1887 "Egyp", 1888 "Elba", 1889 "Ethi", 1890 "Geor", 1891 "Geok", 1892 "Glag", 1893 "Goth", 1894 "Gran", 1895 "Grek", 1896 "Gujr", 1897 "Guru", 1898 "Hang", 1899 "Hani", 1900 "Hano", 1901 "Hans", 1902 "Hant", 1903 "Hebr", 1904 "Hluw", 1905 "Hmng", 1906 "Hung", 1907 "Inds", 1908 "Ital", 1909 "Java", 1910 "Jpan", 1911 "Jurc", 1912 "Kali", 1913 "Khar", 1914 "Khmr", 1915 "Khoj", 1916 "Knda", 1917 "Kpel", 1918 "Kthi", 1919 "Lana", 1920 "Laoo", 1921 "Latf", 1922 "Latg", 1923 "Latn", 1924 "Lepc", 1925 "Limb", 1926 "Lina", 1927 "Linb", 1928 "Lisu", 1929 "Loma", 1930 "Lyci", 1931 "Lydi", 1932 "Mand", 1933 "Mani", 1934 "Maya", 1935 "Mend", 1936 "Merc", 1937 "Mero", 1938 "Mlym", 1939 "Moon", 1940 "Mong", 1941 "Mroo", 1942 "Mtei", 1943 "Mymr", 1944 "Narb", 1945 "Nbat", 1946 "Nkgb", 1947 "Nkoo", 1948 "Nshu", 1949 "Ogam", 1950 "Olck", 1951 "Orkh", 1952 "Orya", 1953 "Osma", 1954 "Palm", 1955 "Perm", 1956 "Phag", 1957 "Phli", 1958 "Phlp", 1959 "Phlv", 1960 "Phnx", 1961 "Plrd", 1962 "Prti", 1963 "Rjng", 1964 "Roro", 1965 "Runr", 1966 "Samr", 1967 "Sara", 1968 "Sarb", 1969 "Saur", 1970 "Sgnw", 1971 "Shaw", 1972 "Shrd", 1973 "Sind", 1974 "Sinh", 1975 "Sora", 1976 "Sund", 1977 "Sylo", 1978 "Syrc", 1979 "Syre", 1980 "Syrj", 1981 "Syrn", 1982 "Tagb", 1983 "Takr", 1984 "Tale", 1985 "Talu", 1986 "Taml", 1987 "Tang", 1988 "Tavt", 1989 "Telu", 1990 "Teng", 1991 "Tfng", 1992 "Tglg", 1993 "Thaa", 1994 "Thai", 1995 "Tibt", 1996 "Tirh", 1997 "Ugar", 1998 "Vaii", 1999 "Visp", 2000 "Wara", 2001 "Wole", 2002 "Xpeo", 2003 "Xsux", 2004 "Yiii", 2005 "Zmth", 2006 "Zsym", 2007 "Zyyy", 2008 ]); 2009 return create === A.H.TRUE ? A.H.push(x) : ref; 2010 }, 2011 2012 "store_SetMinimumFontSizeArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => { 2013 const x = A.H.get<any>(ref); 2014 2015 if (typeof x === "undefined") { 2016 A.store.Bool(ptr + 8, false); 2017 A.store.Int64(ptr + 0, 0); 2018 } else { 2019 A.store.Bool(ptr + 8, true); 2020 A.store.Int64(ptr + 0, x["pixelSize"] === undefined ? 0 : (x["pixelSize"] as number)); 2021 } 2022 }, 2023 "load_SetMinimumFontSizeArgDetails": ( 2024 ptr: Pointer, 2025 create: heap.Ref<boolean>, 2026 ref: heap.Ref<any> 2027 ): heap.Ref<any> => { 2028 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 2029 2030 x["pixelSize"] = A.load.Int64(ptr + 0); 2031 return create === A.H.TRUE ? A.H.push(x) : ref; 2032 }, 2033 "has_ClearDefaultFixedFontSize": (): heap.Ref<boolean> => { 2034 if (WEBEXT?.fontSettings && "clearDefaultFixedFontSize" in WEBEXT?.fontSettings) { 2035 return A.H.TRUE; 2036 } 2037 return A.H.FALSE; 2038 }, 2039 "func_ClearDefaultFixedFontSize": (fn: Pointer): void => { 2040 A.store.Ref(fn, WEBEXT.fontSettings.clearDefaultFixedFontSize); 2041 }, 2042 "call_ClearDefaultFixedFontSize": (retPtr: Pointer, details: Pointer): void => { 2043 const details_ffi = {}; 2044 2045 const _ret = WEBEXT.fontSettings.clearDefaultFixedFontSize(details_ffi); 2046 A.store.Ref(retPtr, _ret); 2047 }, 2048 "try_ClearDefaultFixedFontSize": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => { 2049 try { 2050 const details_ffi = {}; 2051 2052 const _ret = WEBEXT.fontSettings.clearDefaultFixedFontSize(details_ffi); 2053 A.store.Ref(retPtr, _ret); 2054 return A.H.TRUE; 2055 } catch (err: any) { 2056 A.store.Ref(errPtr, err); 2057 return A.H.FALSE; 2058 } 2059 }, 2060 "has_ClearDefaultFontSize": (): heap.Ref<boolean> => { 2061 if (WEBEXT?.fontSettings && "clearDefaultFontSize" in WEBEXT?.fontSettings) { 2062 return A.H.TRUE; 2063 } 2064 return A.H.FALSE; 2065 }, 2066 "func_ClearDefaultFontSize": (fn: Pointer): void => { 2067 A.store.Ref(fn, WEBEXT.fontSettings.clearDefaultFontSize); 2068 }, 2069 "call_ClearDefaultFontSize": (retPtr: Pointer, details: Pointer): void => { 2070 const details_ffi = {}; 2071 2072 const _ret = WEBEXT.fontSettings.clearDefaultFontSize(details_ffi); 2073 A.store.Ref(retPtr, _ret); 2074 }, 2075 "try_ClearDefaultFontSize": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => { 2076 try { 2077 const details_ffi = {}; 2078 2079 const _ret = WEBEXT.fontSettings.clearDefaultFontSize(details_ffi); 2080 A.store.Ref(retPtr, _ret); 2081 return A.H.TRUE; 2082 } catch (err: any) { 2083 A.store.Ref(errPtr, err); 2084 return A.H.FALSE; 2085 } 2086 }, 2087 "has_ClearFont": (): heap.Ref<boolean> => { 2088 if (WEBEXT?.fontSettings && "clearFont" in WEBEXT?.fontSettings) { 2089 return A.H.TRUE; 2090 } 2091 return A.H.FALSE; 2092 }, 2093 "func_ClearFont": (fn: Pointer): void => { 2094 A.store.Ref(fn, WEBEXT.fontSettings.clearFont); 2095 }, 2096 "call_ClearFont": (retPtr: Pointer, details: Pointer): void => { 2097 const details_ffi = {}; 2098 2099 details_ffi["genericFamily"] = A.load.Enum(details + 0, [ 2100 "standard", 2101 "sansserif", 2102 "serif", 2103 "fixed", 2104 "cursive", 2105 "fantasy", 2106 "math", 2107 ]); 2108 details_ffi["script"] = A.load.Enum(details + 4, [ 2109 "Afak", 2110 "Arab", 2111 "Armi", 2112 "Armn", 2113 "Avst", 2114 "Bali", 2115 "Bamu", 2116 "Bass", 2117 "Batk", 2118 "Beng", 2119 "Blis", 2120 "Bopo", 2121 "Brah", 2122 "Brai", 2123 "Bugi", 2124 "Buhd", 2125 "Cakm", 2126 "Cans", 2127 "Cari", 2128 "Cham", 2129 "Cher", 2130 "Cirt", 2131 "Copt", 2132 "Cprt", 2133 "Cyrl", 2134 "Cyrs", 2135 "Deva", 2136 "Dsrt", 2137 "Dupl", 2138 "Egyd", 2139 "Egyh", 2140 "Egyp", 2141 "Elba", 2142 "Ethi", 2143 "Geor", 2144 "Geok", 2145 "Glag", 2146 "Goth", 2147 "Gran", 2148 "Grek", 2149 "Gujr", 2150 "Guru", 2151 "Hang", 2152 "Hani", 2153 "Hano", 2154 "Hans", 2155 "Hant", 2156 "Hebr", 2157 "Hluw", 2158 "Hmng", 2159 "Hung", 2160 "Inds", 2161 "Ital", 2162 "Java", 2163 "Jpan", 2164 "Jurc", 2165 "Kali", 2166 "Khar", 2167 "Khmr", 2168 "Khoj", 2169 "Knda", 2170 "Kpel", 2171 "Kthi", 2172 "Lana", 2173 "Laoo", 2174 "Latf", 2175 "Latg", 2176 "Latn", 2177 "Lepc", 2178 "Limb", 2179 "Lina", 2180 "Linb", 2181 "Lisu", 2182 "Loma", 2183 "Lyci", 2184 "Lydi", 2185 "Mand", 2186 "Mani", 2187 "Maya", 2188 "Mend", 2189 "Merc", 2190 "Mero", 2191 "Mlym", 2192 "Moon", 2193 "Mong", 2194 "Mroo", 2195 "Mtei", 2196 "Mymr", 2197 "Narb", 2198 "Nbat", 2199 "Nkgb", 2200 "Nkoo", 2201 "Nshu", 2202 "Ogam", 2203 "Olck", 2204 "Orkh", 2205 "Orya", 2206 "Osma", 2207 "Palm", 2208 "Perm", 2209 "Phag", 2210 "Phli", 2211 "Phlp", 2212 "Phlv", 2213 "Phnx", 2214 "Plrd", 2215 "Prti", 2216 "Rjng", 2217 "Roro", 2218 "Runr", 2219 "Samr", 2220 "Sara", 2221 "Sarb", 2222 "Saur", 2223 "Sgnw", 2224 "Shaw", 2225 "Shrd", 2226 "Sind", 2227 "Sinh", 2228 "Sora", 2229 "Sund", 2230 "Sylo", 2231 "Syrc", 2232 "Syre", 2233 "Syrj", 2234 "Syrn", 2235 "Tagb", 2236 "Takr", 2237 "Tale", 2238 "Talu", 2239 "Taml", 2240 "Tang", 2241 "Tavt", 2242 "Telu", 2243 "Teng", 2244 "Tfng", 2245 "Tglg", 2246 "Thaa", 2247 "Thai", 2248 "Tibt", 2249 "Tirh", 2250 "Ugar", 2251 "Vaii", 2252 "Visp", 2253 "Wara", 2254 "Wole", 2255 "Xpeo", 2256 "Xsux", 2257 "Yiii", 2258 "Zmth", 2259 "Zsym", 2260 "Zyyy", 2261 ]); 2262 2263 const _ret = WEBEXT.fontSettings.clearFont(details_ffi); 2264 A.store.Ref(retPtr, _ret); 2265 }, 2266 "try_ClearFont": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => { 2267 try { 2268 const details_ffi = {}; 2269 2270 details_ffi["genericFamily"] = A.load.Enum(details + 0, [ 2271 "standard", 2272 "sansserif", 2273 "serif", 2274 "fixed", 2275 "cursive", 2276 "fantasy", 2277 "math", 2278 ]); 2279 details_ffi["script"] = A.load.Enum(details + 4, [ 2280 "Afak", 2281 "Arab", 2282 "Armi", 2283 "Armn", 2284 "Avst", 2285 "Bali", 2286 "Bamu", 2287 "Bass", 2288 "Batk", 2289 "Beng", 2290 "Blis", 2291 "Bopo", 2292 "Brah", 2293 "Brai", 2294 "Bugi", 2295 "Buhd", 2296 "Cakm", 2297 "Cans", 2298 "Cari", 2299 "Cham", 2300 "Cher", 2301 "Cirt", 2302 "Copt", 2303 "Cprt", 2304 "Cyrl", 2305 "Cyrs", 2306 "Deva", 2307 "Dsrt", 2308 "Dupl", 2309 "Egyd", 2310 "Egyh", 2311 "Egyp", 2312 "Elba", 2313 "Ethi", 2314 "Geor", 2315 "Geok", 2316 "Glag", 2317 "Goth", 2318 "Gran", 2319 "Grek", 2320 "Gujr", 2321 "Guru", 2322 "Hang", 2323 "Hani", 2324 "Hano", 2325 "Hans", 2326 "Hant", 2327 "Hebr", 2328 "Hluw", 2329 "Hmng", 2330 "Hung", 2331 "Inds", 2332 "Ital", 2333 "Java", 2334 "Jpan", 2335 "Jurc", 2336 "Kali", 2337 "Khar", 2338 "Khmr", 2339 "Khoj", 2340 "Knda", 2341 "Kpel", 2342 "Kthi", 2343 "Lana", 2344 "Laoo", 2345 "Latf", 2346 "Latg", 2347 "Latn", 2348 "Lepc", 2349 "Limb", 2350 "Lina", 2351 "Linb", 2352 "Lisu", 2353 "Loma", 2354 "Lyci", 2355 "Lydi", 2356 "Mand", 2357 "Mani", 2358 "Maya", 2359 "Mend", 2360 "Merc", 2361 "Mero", 2362 "Mlym", 2363 "Moon", 2364 "Mong", 2365 "Mroo", 2366 "Mtei", 2367 "Mymr", 2368 "Narb", 2369 "Nbat", 2370 "Nkgb", 2371 "Nkoo", 2372 "Nshu", 2373 "Ogam", 2374 "Olck", 2375 "Orkh", 2376 "Orya", 2377 "Osma", 2378 "Palm", 2379 "Perm", 2380 "Phag", 2381 "Phli", 2382 "Phlp", 2383 "Phlv", 2384 "Phnx", 2385 "Plrd", 2386 "Prti", 2387 "Rjng", 2388 "Roro", 2389 "Runr", 2390 "Samr", 2391 "Sara", 2392 "Sarb", 2393 "Saur", 2394 "Sgnw", 2395 "Shaw", 2396 "Shrd", 2397 "Sind", 2398 "Sinh", 2399 "Sora", 2400 "Sund", 2401 "Sylo", 2402 "Syrc", 2403 "Syre", 2404 "Syrj", 2405 "Syrn", 2406 "Tagb", 2407 "Takr", 2408 "Tale", 2409 "Talu", 2410 "Taml", 2411 "Tang", 2412 "Tavt", 2413 "Telu", 2414 "Teng", 2415 "Tfng", 2416 "Tglg", 2417 "Thaa", 2418 "Thai", 2419 "Tibt", 2420 "Tirh", 2421 "Ugar", 2422 "Vaii", 2423 "Visp", 2424 "Wara", 2425 "Wole", 2426 "Xpeo", 2427 "Xsux", 2428 "Yiii", 2429 "Zmth", 2430 "Zsym", 2431 "Zyyy", 2432 ]); 2433 2434 const _ret = WEBEXT.fontSettings.clearFont(details_ffi); 2435 A.store.Ref(retPtr, _ret); 2436 return A.H.TRUE; 2437 } catch (err: any) { 2438 A.store.Ref(errPtr, err); 2439 return A.H.FALSE; 2440 } 2441 }, 2442 "has_ClearMinimumFontSize": (): heap.Ref<boolean> => { 2443 if (WEBEXT?.fontSettings && "clearMinimumFontSize" in WEBEXT?.fontSettings) { 2444 return A.H.TRUE; 2445 } 2446 return A.H.FALSE; 2447 }, 2448 "func_ClearMinimumFontSize": (fn: Pointer): void => { 2449 A.store.Ref(fn, WEBEXT.fontSettings.clearMinimumFontSize); 2450 }, 2451 "call_ClearMinimumFontSize": (retPtr: Pointer, details: Pointer): void => { 2452 const details_ffi = {}; 2453 2454 const _ret = WEBEXT.fontSettings.clearMinimumFontSize(details_ffi); 2455 A.store.Ref(retPtr, _ret); 2456 }, 2457 "try_ClearMinimumFontSize": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => { 2458 try { 2459 const details_ffi = {}; 2460 2461 const _ret = WEBEXT.fontSettings.clearMinimumFontSize(details_ffi); 2462 A.store.Ref(retPtr, _ret); 2463 return A.H.TRUE; 2464 } catch (err: any) { 2465 A.store.Ref(errPtr, err); 2466 return A.H.FALSE; 2467 } 2468 }, 2469 "has_GetDefaultFixedFontSize": (): heap.Ref<boolean> => { 2470 if (WEBEXT?.fontSettings && "getDefaultFixedFontSize" in WEBEXT?.fontSettings) { 2471 return A.H.TRUE; 2472 } 2473 return A.H.FALSE; 2474 }, 2475 "func_GetDefaultFixedFontSize": (fn: Pointer): void => { 2476 A.store.Ref(fn, WEBEXT.fontSettings.getDefaultFixedFontSize); 2477 }, 2478 "call_GetDefaultFixedFontSize": (retPtr: Pointer, details: Pointer): void => { 2479 const details_ffi = {}; 2480 2481 const _ret = WEBEXT.fontSettings.getDefaultFixedFontSize(details_ffi); 2482 A.store.Ref(retPtr, _ret); 2483 }, 2484 "try_GetDefaultFixedFontSize": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => { 2485 try { 2486 const details_ffi = {}; 2487 2488 const _ret = WEBEXT.fontSettings.getDefaultFixedFontSize(details_ffi); 2489 A.store.Ref(retPtr, _ret); 2490 return A.H.TRUE; 2491 } catch (err: any) { 2492 A.store.Ref(errPtr, err); 2493 return A.H.FALSE; 2494 } 2495 }, 2496 "has_GetDefaultFontSize": (): heap.Ref<boolean> => { 2497 if (WEBEXT?.fontSettings && "getDefaultFontSize" in WEBEXT?.fontSettings) { 2498 return A.H.TRUE; 2499 } 2500 return A.H.FALSE; 2501 }, 2502 "func_GetDefaultFontSize": (fn: Pointer): void => { 2503 A.store.Ref(fn, WEBEXT.fontSettings.getDefaultFontSize); 2504 }, 2505 "call_GetDefaultFontSize": (retPtr: Pointer, details: Pointer): void => { 2506 const details_ffi = {}; 2507 2508 const _ret = WEBEXT.fontSettings.getDefaultFontSize(details_ffi); 2509 A.store.Ref(retPtr, _ret); 2510 }, 2511 "try_GetDefaultFontSize": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => { 2512 try { 2513 const details_ffi = {}; 2514 2515 const _ret = WEBEXT.fontSettings.getDefaultFontSize(details_ffi); 2516 A.store.Ref(retPtr, _ret); 2517 return A.H.TRUE; 2518 } catch (err: any) { 2519 A.store.Ref(errPtr, err); 2520 return A.H.FALSE; 2521 } 2522 }, 2523 "has_GetFont": (): heap.Ref<boolean> => { 2524 if (WEBEXT?.fontSettings && "getFont" in WEBEXT?.fontSettings) { 2525 return A.H.TRUE; 2526 } 2527 return A.H.FALSE; 2528 }, 2529 "func_GetFont": (fn: Pointer): void => { 2530 A.store.Ref(fn, WEBEXT.fontSettings.getFont); 2531 }, 2532 "call_GetFont": (retPtr: Pointer, details: Pointer): void => { 2533 const details_ffi = {}; 2534 2535 details_ffi["genericFamily"] = A.load.Enum(details + 0, [ 2536 "standard", 2537 "sansserif", 2538 "serif", 2539 "fixed", 2540 "cursive", 2541 "fantasy", 2542 "math", 2543 ]); 2544 details_ffi["script"] = A.load.Enum(details + 4, [ 2545 "Afak", 2546 "Arab", 2547 "Armi", 2548 "Armn", 2549 "Avst", 2550 "Bali", 2551 "Bamu", 2552 "Bass", 2553 "Batk", 2554 "Beng", 2555 "Blis", 2556 "Bopo", 2557 "Brah", 2558 "Brai", 2559 "Bugi", 2560 "Buhd", 2561 "Cakm", 2562 "Cans", 2563 "Cari", 2564 "Cham", 2565 "Cher", 2566 "Cirt", 2567 "Copt", 2568 "Cprt", 2569 "Cyrl", 2570 "Cyrs", 2571 "Deva", 2572 "Dsrt", 2573 "Dupl", 2574 "Egyd", 2575 "Egyh", 2576 "Egyp", 2577 "Elba", 2578 "Ethi", 2579 "Geor", 2580 "Geok", 2581 "Glag", 2582 "Goth", 2583 "Gran", 2584 "Grek", 2585 "Gujr", 2586 "Guru", 2587 "Hang", 2588 "Hani", 2589 "Hano", 2590 "Hans", 2591 "Hant", 2592 "Hebr", 2593 "Hluw", 2594 "Hmng", 2595 "Hung", 2596 "Inds", 2597 "Ital", 2598 "Java", 2599 "Jpan", 2600 "Jurc", 2601 "Kali", 2602 "Khar", 2603 "Khmr", 2604 "Khoj", 2605 "Knda", 2606 "Kpel", 2607 "Kthi", 2608 "Lana", 2609 "Laoo", 2610 "Latf", 2611 "Latg", 2612 "Latn", 2613 "Lepc", 2614 "Limb", 2615 "Lina", 2616 "Linb", 2617 "Lisu", 2618 "Loma", 2619 "Lyci", 2620 "Lydi", 2621 "Mand", 2622 "Mani", 2623 "Maya", 2624 "Mend", 2625 "Merc", 2626 "Mero", 2627 "Mlym", 2628 "Moon", 2629 "Mong", 2630 "Mroo", 2631 "Mtei", 2632 "Mymr", 2633 "Narb", 2634 "Nbat", 2635 "Nkgb", 2636 "Nkoo", 2637 "Nshu", 2638 "Ogam", 2639 "Olck", 2640 "Orkh", 2641 "Orya", 2642 "Osma", 2643 "Palm", 2644 "Perm", 2645 "Phag", 2646 "Phli", 2647 "Phlp", 2648 "Phlv", 2649 "Phnx", 2650 "Plrd", 2651 "Prti", 2652 "Rjng", 2653 "Roro", 2654 "Runr", 2655 "Samr", 2656 "Sara", 2657 "Sarb", 2658 "Saur", 2659 "Sgnw", 2660 "Shaw", 2661 "Shrd", 2662 "Sind", 2663 "Sinh", 2664 "Sora", 2665 "Sund", 2666 "Sylo", 2667 "Syrc", 2668 "Syre", 2669 "Syrj", 2670 "Syrn", 2671 "Tagb", 2672 "Takr", 2673 "Tale", 2674 "Talu", 2675 "Taml", 2676 "Tang", 2677 "Tavt", 2678 "Telu", 2679 "Teng", 2680 "Tfng", 2681 "Tglg", 2682 "Thaa", 2683 "Thai", 2684 "Tibt", 2685 "Tirh", 2686 "Ugar", 2687 "Vaii", 2688 "Visp", 2689 "Wara", 2690 "Wole", 2691 "Xpeo", 2692 "Xsux", 2693 "Yiii", 2694 "Zmth", 2695 "Zsym", 2696 "Zyyy", 2697 ]); 2698 2699 const _ret = WEBEXT.fontSettings.getFont(details_ffi); 2700 A.store.Ref(retPtr, _ret); 2701 }, 2702 "try_GetFont": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => { 2703 try { 2704 const details_ffi = {}; 2705 2706 details_ffi["genericFamily"] = A.load.Enum(details + 0, [ 2707 "standard", 2708 "sansserif", 2709 "serif", 2710 "fixed", 2711 "cursive", 2712 "fantasy", 2713 "math", 2714 ]); 2715 details_ffi["script"] = A.load.Enum(details + 4, [ 2716 "Afak", 2717 "Arab", 2718 "Armi", 2719 "Armn", 2720 "Avst", 2721 "Bali", 2722 "Bamu", 2723 "Bass", 2724 "Batk", 2725 "Beng", 2726 "Blis", 2727 "Bopo", 2728 "Brah", 2729 "Brai", 2730 "Bugi", 2731 "Buhd", 2732 "Cakm", 2733 "Cans", 2734 "Cari", 2735 "Cham", 2736 "Cher", 2737 "Cirt", 2738 "Copt", 2739 "Cprt", 2740 "Cyrl", 2741 "Cyrs", 2742 "Deva", 2743 "Dsrt", 2744 "Dupl", 2745 "Egyd", 2746 "Egyh", 2747 "Egyp", 2748 "Elba", 2749 "Ethi", 2750 "Geor", 2751 "Geok", 2752 "Glag", 2753 "Goth", 2754 "Gran", 2755 "Grek", 2756 "Gujr", 2757 "Guru", 2758 "Hang", 2759 "Hani", 2760 "Hano", 2761 "Hans", 2762 "Hant", 2763 "Hebr", 2764 "Hluw", 2765 "Hmng", 2766 "Hung", 2767 "Inds", 2768 "Ital", 2769 "Java", 2770 "Jpan", 2771 "Jurc", 2772 "Kali", 2773 "Khar", 2774 "Khmr", 2775 "Khoj", 2776 "Knda", 2777 "Kpel", 2778 "Kthi", 2779 "Lana", 2780 "Laoo", 2781 "Latf", 2782 "Latg", 2783 "Latn", 2784 "Lepc", 2785 "Limb", 2786 "Lina", 2787 "Linb", 2788 "Lisu", 2789 "Loma", 2790 "Lyci", 2791 "Lydi", 2792 "Mand", 2793 "Mani", 2794 "Maya", 2795 "Mend", 2796 "Merc", 2797 "Mero", 2798 "Mlym", 2799 "Moon", 2800 "Mong", 2801 "Mroo", 2802 "Mtei", 2803 "Mymr", 2804 "Narb", 2805 "Nbat", 2806 "Nkgb", 2807 "Nkoo", 2808 "Nshu", 2809 "Ogam", 2810 "Olck", 2811 "Orkh", 2812 "Orya", 2813 "Osma", 2814 "Palm", 2815 "Perm", 2816 "Phag", 2817 "Phli", 2818 "Phlp", 2819 "Phlv", 2820 "Phnx", 2821 "Plrd", 2822 "Prti", 2823 "Rjng", 2824 "Roro", 2825 "Runr", 2826 "Samr", 2827 "Sara", 2828 "Sarb", 2829 "Saur", 2830 "Sgnw", 2831 "Shaw", 2832 "Shrd", 2833 "Sind", 2834 "Sinh", 2835 "Sora", 2836 "Sund", 2837 "Sylo", 2838 "Syrc", 2839 "Syre", 2840 "Syrj", 2841 "Syrn", 2842 "Tagb", 2843 "Takr", 2844 "Tale", 2845 "Talu", 2846 "Taml", 2847 "Tang", 2848 "Tavt", 2849 "Telu", 2850 "Teng", 2851 "Tfng", 2852 "Tglg", 2853 "Thaa", 2854 "Thai", 2855 "Tibt", 2856 "Tirh", 2857 "Ugar", 2858 "Vaii", 2859 "Visp", 2860 "Wara", 2861 "Wole", 2862 "Xpeo", 2863 "Xsux", 2864 "Yiii", 2865 "Zmth", 2866 "Zsym", 2867 "Zyyy", 2868 ]); 2869 2870 const _ret = WEBEXT.fontSettings.getFont(details_ffi); 2871 A.store.Ref(retPtr, _ret); 2872 return A.H.TRUE; 2873 } catch (err: any) { 2874 A.store.Ref(errPtr, err); 2875 return A.H.FALSE; 2876 } 2877 }, 2878 "has_GetFontList": (): heap.Ref<boolean> => { 2879 if (WEBEXT?.fontSettings && "getFontList" in WEBEXT?.fontSettings) { 2880 return A.H.TRUE; 2881 } 2882 return A.H.FALSE; 2883 }, 2884 "func_GetFontList": (fn: Pointer): void => { 2885 A.store.Ref(fn, WEBEXT.fontSettings.getFontList); 2886 }, 2887 "call_GetFontList": (retPtr: Pointer): void => { 2888 const _ret = WEBEXT.fontSettings.getFontList(); 2889 A.store.Ref(retPtr, _ret); 2890 }, 2891 "try_GetFontList": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 2892 try { 2893 const _ret = WEBEXT.fontSettings.getFontList(); 2894 A.store.Ref(retPtr, _ret); 2895 return A.H.TRUE; 2896 } catch (err: any) { 2897 A.store.Ref(errPtr, err); 2898 return A.H.FALSE; 2899 } 2900 }, 2901 "has_GetMinimumFontSize": (): heap.Ref<boolean> => { 2902 if (WEBEXT?.fontSettings && "getMinimumFontSize" in WEBEXT?.fontSettings) { 2903 return A.H.TRUE; 2904 } 2905 return A.H.FALSE; 2906 }, 2907 "func_GetMinimumFontSize": (fn: Pointer): void => { 2908 A.store.Ref(fn, WEBEXT.fontSettings.getMinimumFontSize); 2909 }, 2910 "call_GetMinimumFontSize": (retPtr: Pointer, details: Pointer): void => { 2911 const details_ffi = {}; 2912 2913 const _ret = WEBEXT.fontSettings.getMinimumFontSize(details_ffi); 2914 A.store.Ref(retPtr, _ret); 2915 }, 2916 "try_GetMinimumFontSize": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => { 2917 try { 2918 const details_ffi = {}; 2919 2920 const _ret = WEBEXT.fontSettings.getMinimumFontSize(details_ffi); 2921 A.store.Ref(retPtr, _ret); 2922 return A.H.TRUE; 2923 } catch (err: any) { 2924 A.store.Ref(errPtr, err); 2925 return A.H.FALSE; 2926 } 2927 }, 2928 "has_OnDefaultFixedFontSizeChanged": (): heap.Ref<boolean> => { 2929 if ( 2930 WEBEXT?.fontSettings?.onDefaultFixedFontSizeChanged && 2931 "addListener" in WEBEXT?.fontSettings?.onDefaultFixedFontSizeChanged 2932 ) { 2933 return A.H.TRUE; 2934 } 2935 return A.H.FALSE; 2936 }, 2937 "func_OnDefaultFixedFontSizeChanged": (fn: Pointer): void => { 2938 A.store.Ref(fn, WEBEXT.fontSettings.onDefaultFixedFontSizeChanged.addListener); 2939 }, 2940 "call_OnDefaultFixedFontSizeChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2941 const _ret = WEBEXT.fontSettings.onDefaultFixedFontSizeChanged.addListener(A.H.get<object>(callback)); 2942 }, 2943 "try_OnDefaultFixedFontSizeChanged": ( 2944 retPtr: Pointer, 2945 errPtr: Pointer, 2946 callback: heap.Ref<object> 2947 ): heap.Ref<boolean> => { 2948 try { 2949 const _ret = WEBEXT.fontSettings.onDefaultFixedFontSizeChanged.addListener(A.H.get<object>(callback)); 2950 return A.H.TRUE; 2951 } catch (err: any) { 2952 A.store.Ref(errPtr, err); 2953 return A.H.FALSE; 2954 } 2955 }, 2956 "has_OffDefaultFixedFontSizeChanged": (): heap.Ref<boolean> => { 2957 if ( 2958 WEBEXT?.fontSettings?.onDefaultFixedFontSizeChanged && 2959 "removeListener" in WEBEXT?.fontSettings?.onDefaultFixedFontSizeChanged 2960 ) { 2961 return A.H.TRUE; 2962 } 2963 return A.H.FALSE; 2964 }, 2965 "func_OffDefaultFixedFontSizeChanged": (fn: Pointer): void => { 2966 A.store.Ref(fn, WEBEXT.fontSettings.onDefaultFixedFontSizeChanged.removeListener); 2967 }, 2968 "call_OffDefaultFixedFontSizeChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2969 const _ret = WEBEXT.fontSettings.onDefaultFixedFontSizeChanged.removeListener(A.H.get<object>(callback)); 2970 }, 2971 "try_OffDefaultFixedFontSizeChanged": ( 2972 retPtr: Pointer, 2973 errPtr: Pointer, 2974 callback: heap.Ref<object> 2975 ): heap.Ref<boolean> => { 2976 try { 2977 const _ret = WEBEXT.fontSettings.onDefaultFixedFontSizeChanged.removeListener(A.H.get<object>(callback)); 2978 return A.H.TRUE; 2979 } catch (err: any) { 2980 A.store.Ref(errPtr, err); 2981 return A.H.FALSE; 2982 } 2983 }, 2984 "has_HasOnDefaultFixedFontSizeChanged": (): heap.Ref<boolean> => { 2985 if ( 2986 WEBEXT?.fontSettings?.onDefaultFixedFontSizeChanged && 2987 "hasListener" in WEBEXT?.fontSettings?.onDefaultFixedFontSizeChanged 2988 ) { 2989 return A.H.TRUE; 2990 } 2991 return A.H.FALSE; 2992 }, 2993 "func_HasOnDefaultFixedFontSizeChanged": (fn: Pointer): void => { 2994 A.store.Ref(fn, WEBEXT.fontSettings.onDefaultFixedFontSizeChanged.hasListener); 2995 }, 2996 "call_HasOnDefaultFixedFontSizeChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 2997 const _ret = WEBEXT.fontSettings.onDefaultFixedFontSizeChanged.hasListener(A.H.get<object>(callback)); 2998 A.store.Bool(retPtr, _ret); 2999 }, 3000 "try_HasOnDefaultFixedFontSizeChanged": ( 3001 retPtr: Pointer, 3002 errPtr: Pointer, 3003 callback: heap.Ref<object> 3004 ): heap.Ref<boolean> => { 3005 try { 3006 const _ret = WEBEXT.fontSettings.onDefaultFixedFontSizeChanged.hasListener(A.H.get<object>(callback)); 3007 A.store.Bool(retPtr, _ret); 3008 return A.H.TRUE; 3009 } catch (err: any) { 3010 A.store.Ref(errPtr, err); 3011 return A.H.FALSE; 3012 } 3013 }, 3014 "has_OnDefaultFontSizeChanged": (): heap.Ref<boolean> => { 3015 if ( 3016 WEBEXT?.fontSettings?.onDefaultFontSizeChanged && 3017 "addListener" in WEBEXT?.fontSettings?.onDefaultFontSizeChanged 3018 ) { 3019 return A.H.TRUE; 3020 } 3021 return A.H.FALSE; 3022 }, 3023 "func_OnDefaultFontSizeChanged": (fn: Pointer): void => { 3024 A.store.Ref(fn, WEBEXT.fontSettings.onDefaultFontSizeChanged.addListener); 3025 }, 3026 "call_OnDefaultFontSizeChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 3027 const _ret = WEBEXT.fontSettings.onDefaultFontSizeChanged.addListener(A.H.get<object>(callback)); 3028 }, 3029 "try_OnDefaultFontSizeChanged": ( 3030 retPtr: Pointer, 3031 errPtr: Pointer, 3032 callback: heap.Ref<object> 3033 ): heap.Ref<boolean> => { 3034 try { 3035 const _ret = WEBEXT.fontSettings.onDefaultFontSizeChanged.addListener(A.H.get<object>(callback)); 3036 return A.H.TRUE; 3037 } catch (err: any) { 3038 A.store.Ref(errPtr, err); 3039 return A.H.FALSE; 3040 } 3041 }, 3042 "has_OffDefaultFontSizeChanged": (): heap.Ref<boolean> => { 3043 if ( 3044 WEBEXT?.fontSettings?.onDefaultFontSizeChanged && 3045 "removeListener" in WEBEXT?.fontSettings?.onDefaultFontSizeChanged 3046 ) { 3047 return A.H.TRUE; 3048 } 3049 return A.H.FALSE; 3050 }, 3051 "func_OffDefaultFontSizeChanged": (fn: Pointer): void => { 3052 A.store.Ref(fn, WEBEXT.fontSettings.onDefaultFontSizeChanged.removeListener); 3053 }, 3054 "call_OffDefaultFontSizeChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 3055 const _ret = WEBEXT.fontSettings.onDefaultFontSizeChanged.removeListener(A.H.get<object>(callback)); 3056 }, 3057 "try_OffDefaultFontSizeChanged": ( 3058 retPtr: Pointer, 3059 errPtr: Pointer, 3060 callback: heap.Ref<object> 3061 ): heap.Ref<boolean> => { 3062 try { 3063 const _ret = WEBEXT.fontSettings.onDefaultFontSizeChanged.removeListener(A.H.get<object>(callback)); 3064 return A.H.TRUE; 3065 } catch (err: any) { 3066 A.store.Ref(errPtr, err); 3067 return A.H.FALSE; 3068 } 3069 }, 3070 "has_HasOnDefaultFontSizeChanged": (): heap.Ref<boolean> => { 3071 if ( 3072 WEBEXT?.fontSettings?.onDefaultFontSizeChanged && 3073 "hasListener" in WEBEXT?.fontSettings?.onDefaultFontSizeChanged 3074 ) { 3075 return A.H.TRUE; 3076 } 3077 return A.H.FALSE; 3078 }, 3079 "func_HasOnDefaultFontSizeChanged": (fn: Pointer): void => { 3080 A.store.Ref(fn, WEBEXT.fontSettings.onDefaultFontSizeChanged.hasListener); 3081 }, 3082 "call_HasOnDefaultFontSizeChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 3083 const _ret = WEBEXT.fontSettings.onDefaultFontSizeChanged.hasListener(A.H.get<object>(callback)); 3084 A.store.Bool(retPtr, _ret); 3085 }, 3086 "try_HasOnDefaultFontSizeChanged": ( 3087 retPtr: Pointer, 3088 errPtr: Pointer, 3089 callback: heap.Ref<object> 3090 ): heap.Ref<boolean> => { 3091 try { 3092 const _ret = WEBEXT.fontSettings.onDefaultFontSizeChanged.hasListener(A.H.get<object>(callback)); 3093 A.store.Bool(retPtr, _ret); 3094 return A.H.TRUE; 3095 } catch (err: any) { 3096 A.store.Ref(errPtr, err); 3097 return A.H.FALSE; 3098 } 3099 }, 3100 "has_OnFontChanged": (): heap.Ref<boolean> => { 3101 if (WEBEXT?.fontSettings?.onFontChanged && "addListener" in WEBEXT?.fontSettings?.onFontChanged) { 3102 return A.H.TRUE; 3103 } 3104 return A.H.FALSE; 3105 }, 3106 "func_OnFontChanged": (fn: Pointer): void => { 3107 A.store.Ref(fn, WEBEXT.fontSettings.onFontChanged.addListener); 3108 }, 3109 "call_OnFontChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 3110 const _ret = WEBEXT.fontSettings.onFontChanged.addListener(A.H.get<object>(callback)); 3111 }, 3112 "try_OnFontChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 3113 try { 3114 const _ret = WEBEXT.fontSettings.onFontChanged.addListener(A.H.get<object>(callback)); 3115 return A.H.TRUE; 3116 } catch (err: any) { 3117 A.store.Ref(errPtr, err); 3118 return A.H.FALSE; 3119 } 3120 }, 3121 "has_OffFontChanged": (): heap.Ref<boolean> => { 3122 if (WEBEXT?.fontSettings?.onFontChanged && "removeListener" in WEBEXT?.fontSettings?.onFontChanged) { 3123 return A.H.TRUE; 3124 } 3125 return A.H.FALSE; 3126 }, 3127 "func_OffFontChanged": (fn: Pointer): void => { 3128 A.store.Ref(fn, WEBEXT.fontSettings.onFontChanged.removeListener); 3129 }, 3130 "call_OffFontChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 3131 const _ret = WEBEXT.fontSettings.onFontChanged.removeListener(A.H.get<object>(callback)); 3132 }, 3133 "try_OffFontChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 3134 try { 3135 const _ret = WEBEXT.fontSettings.onFontChanged.removeListener(A.H.get<object>(callback)); 3136 return A.H.TRUE; 3137 } catch (err: any) { 3138 A.store.Ref(errPtr, err); 3139 return A.H.FALSE; 3140 } 3141 }, 3142 "has_HasOnFontChanged": (): heap.Ref<boolean> => { 3143 if (WEBEXT?.fontSettings?.onFontChanged && "hasListener" in WEBEXT?.fontSettings?.onFontChanged) { 3144 return A.H.TRUE; 3145 } 3146 return A.H.FALSE; 3147 }, 3148 "func_HasOnFontChanged": (fn: Pointer): void => { 3149 A.store.Ref(fn, WEBEXT.fontSettings.onFontChanged.hasListener); 3150 }, 3151 "call_HasOnFontChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 3152 const _ret = WEBEXT.fontSettings.onFontChanged.hasListener(A.H.get<object>(callback)); 3153 A.store.Bool(retPtr, _ret); 3154 }, 3155 "try_HasOnFontChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 3156 try { 3157 const _ret = WEBEXT.fontSettings.onFontChanged.hasListener(A.H.get<object>(callback)); 3158 A.store.Bool(retPtr, _ret); 3159 return A.H.TRUE; 3160 } catch (err: any) { 3161 A.store.Ref(errPtr, err); 3162 return A.H.FALSE; 3163 } 3164 }, 3165 "has_OnMinimumFontSizeChanged": (): heap.Ref<boolean> => { 3166 if ( 3167 WEBEXT?.fontSettings?.onMinimumFontSizeChanged && 3168 "addListener" in WEBEXT?.fontSettings?.onMinimumFontSizeChanged 3169 ) { 3170 return A.H.TRUE; 3171 } 3172 return A.H.FALSE; 3173 }, 3174 "func_OnMinimumFontSizeChanged": (fn: Pointer): void => { 3175 A.store.Ref(fn, WEBEXT.fontSettings.onMinimumFontSizeChanged.addListener); 3176 }, 3177 "call_OnMinimumFontSizeChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 3178 const _ret = WEBEXT.fontSettings.onMinimumFontSizeChanged.addListener(A.H.get<object>(callback)); 3179 }, 3180 "try_OnMinimumFontSizeChanged": ( 3181 retPtr: Pointer, 3182 errPtr: Pointer, 3183 callback: heap.Ref<object> 3184 ): heap.Ref<boolean> => { 3185 try { 3186 const _ret = WEBEXT.fontSettings.onMinimumFontSizeChanged.addListener(A.H.get<object>(callback)); 3187 return A.H.TRUE; 3188 } catch (err: any) { 3189 A.store.Ref(errPtr, err); 3190 return A.H.FALSE; 3191 } 3192 }, 3193 "has_OffMinimumFontSizeChanged": (): heap.Ref<boolean> => { 3194 if ( 3195 WEBEXT?.fontSettings?.onMinimumFontSizeChanged && 3196 "removeListener" in WEBEXT?.fontSettings?.onMinimumFontSizeChanged 3197 ) { 3198 return A.H.TRUE; 3199 } 3200 return A.H.FALSE; 3201 }, 3202 "func_OffMinimumFontSizeChanged": (fn: Pointer): void => { 3203 A.store.Ref(fn, WEBEXT.fontSettings.onMinimumFontSizeChanged.removeListener); 3204 }, 3205 "call_OffMinimumFontSizeChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 3206 const _ret = WEBEXT.fontSettings.onMinimumFontSizeChanged.removeListener(A.H.get<object>(callback)); 3207 }, 3208 "try_OffMinimumFontSizeChanged": ( 3209 retPtr: Pointer, 3210 errPtr: Pointer, 3211 callback: heap.Ref<object> 3212 ): heap.Ref<boolean> => { 3213 try { 3214 const _ret = WEBEXT.fontSettings.onMinimumFontSizeChanged.removeListener(A.H.get<object>(callback)); 3215 return A.H.TRUE; 3216 } catch (err: any) { 3217 A.store.Ref(errPtr, err); 3218 return A.H.FALSE; 3219 } 3220 }, 3221 "has_HasOnMinimumFontSizeChanged": (): heap.Ref<boolean> => { 3222 if ( 3223 WEBEXT?.fontSettings?.onMinimumFontSizeChanged && 3224 "hasListener" in WEBEXT?.fontSettings?.onMinimumFontSizeChanged 3225 ) { 3226 return A.H.TRUE; 3227 } 3228 return A.H.FALSE; 3229 }, 3230 "func_HasOnMinimumFontSizeChanged": (fn: Pointer): void => { 3231 A.store.Ref(fn, WEBEXT.fontSettings.onMinimumFontSizeChanged.hasListener); 3232 }, 3233 "call_HasOnMinimumFontSizeChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 3234 const _ret = WEBEXT.fontSettings.onMinimumFontSizeChanged.hasListener(A.H.get<object>(callback)); 3235 A.store.Bool(retPtr, _ret); 3236 }, 3237 "try_HasOnMinimumFontSizeChanged": ( 3238 retPtr: Pointer, 3239 errPtr: Pointer, 3240 callback: heap.Ref<object> 3241 ): heap.Ref<boolean> => { 3242 try { 3243 const _ret = WEBEXT.fontSettings.onMinimumFontSizeChanged.hasListener(A.H.get<object>(callback)); 3244 A.store.Bool(retPtr, _ret); 3245 return A.H.TRUE; 3246 } catch (err: any) { 3247 A.store.Ref(errPtr, err); 3248 return A.H.FALSE; 3249 } 3250 }, 3251 "has_SetDefaultFixedFontSize": (): heap.Ref<boolean> => { 3252 if (WEBEXT?.fontSettings && "setDefaultFixedFontSize" in WEBEXT?.fontSettings) { 3253 return A.H.TRUE; 3254 } 3255 return A.H.FALSE; 3256 }, 3257 "func_SetDefaultFixedFontSize": (fn: Pointer): void => { 3258 A.store.Ref(fn, WEBEXT.fontSettings.setDefaultFixedFontSize); 3259 }, 3260 "call_SetDefaultFixedFontSize": (retPtr: Pointer, details: Pointer): void => { 3261 const details_ffi = {}; 3262 3263 details_ffi["pixelSize"] = A.load.Int64(details + 0); 3264 3265 const _ret = WEBEXT.fontSettings.setDefaultFixedFontSize(details_ffi); 3266 A.store.Ref(retPtr, _ret); 3267 }, 3268 "try_SetDefaultFixedFontSize": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => { 3269 try { 3270 const details_ffi = {}; 3271 3272 details_ffi["pixelSize"] = A.load.Int64(details + 0); 3273 3274 const _ret = WEBEXT.fontSettings.setDefaultFixedFontSize(details_ffi); 3275 A.store.Ref(retPtr, _ret); 3276 return A.H.TRUE; 3277 } catch (err: any) { 3278 A.store.Ref(errPtr, err); 3279 return A.H.FALSE; 3280 } 3281 }, 3282 "has_SetDefaultFontSize": (): heap.Ref<boolean> => { 3283 if (WEBEXT?.fontSettings && "setDefaultFontSize" in WEBEXT?.fontSettings) { 3284 return A.H.TRUE; 3285 } 3286 return A.H.FALSE; 3287 }, 3288 "func_SetDefaultFontSize": (fn: Pointer): void => { 3289 A.store.Ref(fn, WEBEXT.fontSettings.setDefaultFontSize); 3290 }, 3291 "call_SetDefaultFontSize": (retPtr: Pointer, details: Pointer): void => { 3292 const details_ffi = {}; 3293 3294 details_ffi["pixelSize"] = A.load.Int64(details + 0); 3295 3296 const _ret = WEBEXT.fontSettings.setDefaultFontSize(details_ffi); 3297 A.store.Ref(retPtr, _ret); 3298 }, 3299 "try_SetDefaultFontSize": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => { 3300 try { 3301 const details_ffi = {}; 3302 3303 details_ffi["pixelSize"] = A.load.Int64(details + 0); 3304 3305 const _ret = WEBEXT.fontSettings.setDefaultFontSize(details_ffi); 3306 A.store.Ref(retPtr, _ret); 3307 return A.H.TRUE; 3308 } catch (err: any) { 3309 A.store.Ref(errPtr, err); 3310 return A.H.FALSE; 3311 } 3312 }, 3313 "has_SetFont": (): heap.Ref<boolean> => { 3314 if (WEBEXT?.fontSettings && "setFont" in WEBEXT?.fontSettings) { 3315 return A.H.TRUE; 3316 } 3317 return A.H.FALSE; 3318 }, 3319 "func_SetFont": (fn: Pointer): void => { 3320 A.store.Ref(fn, WEBEXT.fontSettings.setFont); 3321 }, 3322 "call_SetFont": (retPtr: Pointer, details: Pointer): void => { 3323 const details_ffi = {}; 3324 3325 details_ffi["fontId"] = A.load.Ref(details + 0, undefined); 3326 details_ffi["genericFamily"] = A.load.Enum(details + 4, [ 3327 "standard", 3328 "sansserif", 3329 "serif", 3330 "fixed", 3331 "cursive", 3332 "fantasy", 3333 "math", 3334 ]); 3335 details_ffi["script"] = A.load.Enum(details + 8, [ 3336 "Afak", 3337 "Arab", 3338 "Armi", 3339 "Armn", 3340 "Avst", 3341 "Bali", 3342 "Bamu", 3343 "Bass", 3344 "Batk", 3345 "Beng", 3346 "Blis", 3347 "Bopo", 3348 "Brah", 3349 "Brai", 3350 "Bugi", 3351 "Buhd", 3352 "Cakm", 3353 "Cans", 3354 "Cari", 3355 "Cham", 3356 "Cher", 3357 "Cirt", 3358 "Copt", 3359 "Cprt", 3360 "Cyrl", 3361 "Cyrs", 3362 "Deva", 3363 "Dsrt", 3364 "Dupl", 3365 "Egyd", 3366 "Egyh", 3367 "Egyp", 3368 "Elba", 3369 "Ethi", 3370 "Geor", 3371 "Geok", 3372 "Glag", 3373 "Goth", 3374 "Gran", 3375 "Grek", 3376 "Gujr", 3377 "Guru", 3378 "Hang", 3379 "Hani", 3380 "Hano", 3381 "Hans", 3382 "Hant", 3383 "Hebr", 3384 "Hluw", 3385 "Hmng", 3386 "Hung", 3387 "Inds", 3388 "Ital", 3389 "Java", 3390 "Jpan", 3391 "Jurc", 3392 "Kali", 3393 "Khar", 3394 "Khmr", 3395 "Khoj", 3396 "Knda", 3397 "Kpel", 3398 "Kthi", 3399 "Lana", 3400 "Laoo", 3401 "Latf", 3402 "Latg", 3403 "Latn", 3404 "Lepc", 3405 "Limb", 3406 "Lina", 3407 "Linb", 3408 "Lisu", 3409 "Loma", 3410 "Lyci", 3411 "Lydi", 3412 "Mand", 3413 "Mani", 3414 "Maya", 3415 "Mend", 3416 "Merc", 3417 "Mero", 3418 "Mlym", 3419 "Moon", 3420 "Mong", 3421 "Mroo", 3422 "Mtei", 3423 "Mymr", 3424 "Narb", 3425 "Nbat", 3426 "Nkgb", 3427 "Nkoo", 3428 "Nshu", 3429 "Ogam", 3430 "Olck", 3431 "Orkh", 3432 "Orya", 3433 "Osma", 3434 "Palm", 3435 "Perm", 3436 "Phag", 3437 "Phli", 3438 "Phlp", 3439 "Phlv", 3440 "Phnx", 3441 "Plrd", 3442 "Prti", 3443 "Rjng", 3444 "Roro", 3445 "Runr", 3446 "Samr", 3447 "Sara", 3448 "Sarb", 3449 "Saur", 3450 "Sgnw", 3451 "Shaw", 3452 "Shrd", 3453 "Sind", 3454 "Sinh", 3455 "Sora", 3456 "Sund", 3457 "Sylo", 3458 "Syrc", 3459 "Syre", 3460 "Syrj", 3461 "Syrn", 3462 "Tagb", 3463 "Takr", 3464 "Tale", 3465 "Talu", 3466 "Taml", 3467 "Tang", 3468 "Tavt", 3469 "Telu", 3470 "Teng", 3471 "Tfng", 3472 "Tglg", 3473 "Thaa", 3474 "Thai", 3475 "Tibt", 3476 "Tirh", 3477 "Ugar", 3478 "Vaii", 3479 "Visp", 3480 "Wara", 3481 "Wole", 3482 "Xpeo", 3483 "Xsux", 3484 "Yiii", 3485 "Zmth", 3486 "Zsym", 3487 "Zyyy", 3488 ]); 3489 3490 const _ret = WEBEXT.fontSettings.setFont(details_ffi); 3491 A.store.Ref(retPtr, _ret); 3492 }, 3493 "try_SetFont": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => { 3494 try { 3495 const details_ffi = {}; 3496 3497 details_ffi["fontId"] = A.load.Ref(details + 0, undefined); 3498 details_ffi["genericFamily"] = A.load.Enum(details + 4, [ 3499 "standard", 3500 "sansserif", 3501 "serif", 3502 "fixed", 3503 "cursive", 3504 "fantasy", 3505 "math", 3506 ]); 3507 details_ffi["script"] = A.load.Enum(details + 8, [ 3508 "Afak", 3509 "Arab", 3510 "Armi", 3511 "Armn", 3512 "Avst", 3513 "Bali", 3514 "Bamu", 3515 "Bass", 3516 "Batk", 3517 "Beng", 3518 "Blis", 3519 "Bopo", 3520 "Brah", 3521 "Brai", 3522 "Bugi", 3523 "Buhd", 3524 "Cakm", 3525 "Cans", 3526 "Cari", 3527 "Cham", 3528 "Cher", 3529 "Cirt", 3530 "Copt", 3531 "Cprt", 3532 "Cyrl", 3533 "Cyrs", 3534 "Deva", 3535 "Dsrt", 3536 "Dupl", 3537 "Egyd", 3538 "Egyh", 3539 "Egyp", 3540 "Elba", 3541 "Ethi", 3542 "Geor", 3543 "Geok", 3544 "Glag", 3545 "Goth", 3546 "Gran", 3547 "Grek", 3548 "Gujr", 3549 "Guru", 3550 "Hang", 3551 "Hani", 3552 "Hano", 3553 "Hans", 3554 "Hant", 3555 "Hebr", 3556 "Hluw", 3557 "Hmng", 3558 "Hung", 3559 "Inds", 3560 "Ital", 3561 "Java", 3562 "Jpan", 3563 "Jurc", 3564 "Kali", 3565 "Khar", 3566 "Khmr", 3567 "Khoj", 3568 "Knda", 3569 "Kpel", 3570 "Kthi", 3571 "Lana", 3572 "Laoo", 3573 "Latf", 3574 "Latg", 3575 "Latn", 3576 "Lepc", 3577 "Limb", 3578 "Lina", 3579 "Linb", 3580 "Lisu", 3581 "Loma", 3582 "Lyci", 3583 "Lydi", 3584 "Mand", 3585 "Mani", 3586 "Maya", 3587 "Mend", 3588 "Merc", 3589 "Mero", 3590 "Mlym", 3591 "Moon", 3592 "Mong", 3593 "Mroo", 3594 "Mtei", 3595 "Mymr", 3596 "Narb", 3597 "Nbat", 3598 "Nkgb", 3599 "Nkoo", 3600 "Nshu", 3601 "Ogam", 3602 "Olck", 3603 "Orkh", 3604 "Orya", 3605 "Osma", 3606 "Palm", 3607 "Perm", 3608 "Phag", 3609 "Phli", 3610 "Phlp", 3611 "Phlv", 3612 "Phnx", 3613 "Plrd", 3614 "Prti", 3615 "Rjng", 3616 "Roro", 3617 "Runr", 3618 "Samr", 3619 "Sara", 3620 "Sarb", 3621 "Saur", 3622 "Sgnw", 3623 "Shaw", 3624 "Shrd", 3625 "Sind", 3626 "Sinh", 3627 "Sora", 3628 "Sund", 3629 "Sylo", 3630 "Syrc", 3631 "Syre", 3632 "Syrj", 3633 "Syrn", 3634 "Tagb", 3635 "Takr", 3636 "Tale", 3637 "Talu", 3638 "Taml", 3639 "Tang", 3640 "Tavt", 3641 "Telu", 3642 "Teng", 3643 "Tfng", 3644 "Tglg", 3645 "Thaa", 3646 "Thai", 3647 "Tibt", 3648 "Tirh", 3649 "Ugar", 3650 "Vaii", 3651 "Visp", 3652 "Wara", 3653 "Wole", 3654 "Xpeo", 3655 "Xsux", 3656 "Yiii", 3657 "Zmth", 3658 "Zsym", 3659 "Zyyy", 3660 ]); 3661 3662 const _ret = WEBEXT.fontSettings.setFont(details_ffi); 3663 A.store.Ref(retPtr, _ret); 3664 return A.H.TRUE; 3665 } catch (err: any) { 3666 A.store.Ref(errPtr, err); 3667 return A.H.FALSE; 3668 } 3669 }, 3670 "has_SetMinimumFontSize": (): heap.Ref<boolean> => { 3671 if (WEBEXT?.fontSettings && "setMinimumFontSize" in WEBEXT?.fontSettings) { 3672 return A.H.TRUE; 3673 } 3674 return A.H.FALSE; 3675 }, 3676 "func_SetMinimumFontSize": (fn: Pointer): void => { 3677 A.store.Ref(fn, WEBEXT.fontSettings.setMinimumFontSize); 3678 }, 3679 "call_SetMinimumFontSize": (retPtr: Pointer, details: Pointer): void => { 3680 const details_ffi = {}; 3681 3682 details_ffi["pixelSize"] = A.load.Int64(details + 0); 3683 3684 const _ret = WEBEXT.fontSettings.setMinimumFontSize(details_ffi); 3685 A.store.Ref(retPtr, _ret); 3686 }, 3687 "try_SetMinimumFontSize": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => { 3688 try { 3689 const details_ffi = {}; 3690 3691 details_ffi["pixelSize"] = A.load.Int64(details + 0); 3692 3693 const _ret = WEBEXT.fontSettings.setMinimumFontSize(details_ffi); 3694 A.store.Ref(retPtr, _ret); 3695 return A.H.TRUE; 3696 } catch (err: any) { 3697 A.store.Ref(errPtr, err); 3698 return A.H.FALSE; 3699 } 3700 }, 3701 }; 3702 });