github.com/primecitizens/pcz/std@v0.2.1/plat/js/webext/browseraction/bindings/ffi_bindings.ts (about)

     1  import { importModule, Application, heap, Pointer } from "@ffi";
     2  
     3  importModule("plat/js/webext/browseraction", (A: Application) => {
     4    const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser;
     5  
     6    return {
     7      "store_ImageDataType": (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_ImageDataType": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    17        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    18  
    19        return create === A.H.TRUE ? A.H.push(x) : ref;
    20      },
    21  
    22      "store_SetBadgeBackgroundColorArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => {
    23        const x = A.H.get<any>(ref);
    24  
    25        if (typeof x === "undefined") {
    26          A.store.Bool(ptr + 17, false);
    27          A.store.Ref(ptr + 0, undefined);
    28          A.store.Bool(ptr + 16, false);
    29          A.store.Int64(ptr + 8, 0);
    30        } else {
    31          A.store.Bool(ptr + 17, true);
    32          A.store.Ref(ptr + 0, x["color"]);
    33          A.store.Bool(ptr + 16, "tabId" in x ? true : false);
    34          A.store.Int64(ptr + 8, x["tabId"] === undefined ? 0 : (x["tabId"] as number));
    35        }
    36      },
    37      "load_SetBadgeBackgroundColorArgDetails": (
    38        ptr: Pointer,
    39        create: heap.Ref<boolean>,
    40        ref: heap.Ref<any>
    41      ): heap.Ref<any> => {
    42        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    43  
    44        x["color"] = A.load.Ref(ptr + 0, undefined);
    45        if (A.load.Bool(ptr + 16)) {
    46          x["tabId"] = A.load.Int64(ptr + 8);
    47        } else {
    48          delete x["tabId"];
    49        }
    50        return create === A.H.TRUE ? A.H.push(x) : ref;
    51      },
    52  
    53      "store_SetBadgeTextArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => {
    54        const x = A.H.get<any>(ref);
    55  
    56        if (typeof x === "undefined") {
    57          A.store.Bool(ptr + 13, false);
    58          A.store.Bool(ptr + 12, false);
    59          A.store.Int64(ptr + 0, 0);
    60          A.store.Ref(ptr + 8, undefined);
    61        } else {
    62          A.store.Bool(ptr + 13, true);
    63          A.store.Bool(ptr + 12, "tabId" in x ? true : false);
    64          A.store.Int64(ptr + 0, x["tabId"] === undefined ? 0 : (x["tabId"] as number));
    65          A.store.Ref(ptr + 8, x["text"]);
    66        }
    67      },
    68      "load_SetBadgeTextArgDetails": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    69        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    70  
    71        if (A.load.Bool(ptr + 12)) {
    72          x["tabId"] = A.load.Int64(ptr + 0);
    73        } else {
    74          delete x["tabId"];
    75        }
    76        x["text"] = A.load.Ref(ptr + 8, undefined);
    77        return create === A.H.TRUE ? A.H.push(x) : ref;
    78      },
    79  
    80      "store_SetIconArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => {
    81        const x = A.H.get<any>(ref);
    82  
    83        if (typeof x === "undefined") {
    84          A.store.Bool(ptr + 17, false);
    85          A.store.Ref(ptr + 0, undefined);
    86          A.store.Ref(ptr + 4, undefined);
    87          A.store.Bool(ptr + 16, false);
    88          A.store.Int64(ptr + 8, 0);
    89        } else {
    90          A.store.Bool(ptr + 17, true);
    91          A.store.Ref(ptr + 0, x["imageData"]);
    92          A.store.Ref(ptr + 4, x["path"]);
    93          A.store.Bool(ptr + 16, "tabId" in x ? true : false);
    94          A.store.Int64(ptr + 8, x["tabId"] === undefined ? 0 : (x["tabId"] as number));
    95        }
    96      },
    97      "load_SetIconArgDetails": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    98        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    99  
   100        x["imageData"] = A.load.Ref(ptr + 0, undefined);
   101        x["path"] = A.load.Ref(ptr + 4, undefined);
   102        if (A.load.Bool(ptr + 16)) {
   103          x["tabId"] = A.load.Int64(ptr + 8);
   104        } else {
   105          delete x["tabId"];
   106        }
   107        return create === A.H.TRUE ? A.H.push(x) : ref;
   108      },
   109  
   110      "store_SetPopupArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => {
   111        const x = A.H.get<any>(ref);
   112  
   113        if (typeof x === "undefined") {
   114          A.store.Bool(ptr + 17, false);
   115          A.store.Ref(ptr + 0, undefined);
   116          A.store.Bool(ptr + 16, false);
   117          A.store.Int64(ptr + 8, 0);
   118        } else {
   119          A.store.Bool(ptr + 17, true);
   120          A.store.Ref(ptr + 0, x["popup"]);
   121          A.store.Bool(ptr + 16, "tabId" in x ? true : false);
   122          A.store.Int64(ptr + 8, x["tabId"] === undefined ? 0 : (x["tabId"] as number));
   123        }
   124      },
   125      "load_SetPopupArgDetails": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   126        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   127  
   128        x["popup"] = A.load.Ref(ptr + 0, undefined);
   129        if (A.load.Bool(ptr + 16)) {
   130          x["tabId"] = A.load.Int64(ptr + 8);
   131        } else {
   132          delete x["tabId"];
   133        }
   134        return create === A.H.TRUE ? A.H.push(x) : ref;
   135      },
   136  
   137      "store_SetTitleArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => {
   138        const x = A.H.get<any>(ref);
   139  
   140        if (typeof x === "undefined") {
   141          A.store.Bool(ptr + 13, false);
   142          A.store.Bool(ptr + 12, false);
   143          A.store.Int64(ptr + 0, 0);
   144          A.store.Ref(ptr + 8, undefined);
   145        } else {
   146          A.store.Bool(ptr + 13, true);
   147          A.store.Bool(ptr + 12, "tabId" in x ? true : false);
   148          A.store.Int64(ptr + 0, x["tabId"] === undefined ? 0 : (x["tabId"] as number));
   149          A.store.Ref(ptr + 8, x["title"]);
   150        }
   151      },
   152      "load_SetTitleArgDetails": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   153        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   154  
   155        if (A.load.Bool(ptr + 12)) {
   156          x["tabId"] = A.load.Int64(ptr + 0);
   157        } else {
   158          delete x["tabId"];
   159        }
   160        x["title"] = A.load.Ref(ptr + 8, undefined);
   161        return create === A.H.TRUE ? A.H.push(x) : ref;
   162      },
   163  
   164      "store_TabDetails": (ptr: Pointer, ref: heap.Ref<any>) => {
   165        const x = A.H.get<any>(ref);
   166  
   167        if (typeof x === "undefined") {
   168          A.store.Bool(ptr + 9, false);
   169          A.store.Bool(ptr + 8, false);
   170          A.store.Int64(ptr + 0, 0);
   171        } else {
   172          A.store.Bool(ptr + 9, true);
   173          A.store.Bool(ptr + 8, "tabId" in x ? true : false);
   174          A.store.Int64(ptr + 0, x["tabId"] === undefined ? 0 : (x["tabId"] as number));
   175        }
   176      },
   177      "load_TabDetails": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   178        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   179  
   180        if (A.load.Bool(ptr + 8)) {
   181          x["tabId"] = A.load.Int64(ptr + 0);
   182        } else {
   183          delete x["tabId"];
   184        }
   185        return create === A.H.TRUE ? A.H.push(x) : ref;
   186      },
   187      "has_Disable": (): heap.Ref<boolean> => {
   188        if (WEBEXT?.browserAction && "disable" in WEBEXT?.browserAction) {
   189          return A.H.TRUE;
   190        }
   191        return A.H.FALSE;
   192      },
   193      "func_Disable": (fn: Pointer): void => {
   194        A.store.Ref(fn, WEBEXT.browserAction.disable);
   195      },
   196      "call_Disable": (retPtr: Pointer, tabId: number): void => {
   197        const _ret = WEBEXT.browserAction.disable(tabId);
   198        A.store.Ref(retPtr, _ret);
   199      },
   200      "try_Disable": (retPtr: Pointer, errPtr: Pointer, tabId: number): heap.Ref<boolean> => {
   201        try {
   202          const _ret = WEBEXT.browserAction.disable(tabId);
   203          A.store.Ref(retPtr, _ret);
   204          return A.H.TRUE;
   205        } catch (err: any) {
   206          A.store.Ref(errPtr, err);
   207          return A.H.FALSE;
   208        }
   209      },
   210      "has_Enable": (): heap.Ref<boolean> => {
   211        if (WEBEXT?.browserAction && "enable" in WEBEXT?.browserAction) {
   212          return A.H.TRUE;
   213        }
   214        return A.H.FALSE;
   215      },
   216      "func_Enable": (fn: Pointer): void => {
   217        A.store.Ref(fn, WEBEXT.browserAction.enable);
   218      },
   219      "call_Enable": (retPtr: Pointer, tabId: number): void => {
   220        const _ret = WEBEXT.browserAction.enable(tabId);
   221        A.store.Ref(retPtr, _ret);
   222      },
   223      "try_Enable": (retPtr: Pointer, errPtr: Pointer, tabId: number): heap.Ref<boolean> => {
   224        try {
   225          const _ret = WEBEXT.browserAction.enable(tabId);
   226          A.store.Ref(retPtr, _ret);
   227          return A.H.TRUE;
   228        } catch (err: any) {
   229          A.store.Ref(errPtr, err);
   230          return A.H.FALSE;
   231        }
   232      },
   233      "has_GetBadgeBackgroundColor": (): heap.Ref<boolean> => {
   234        if (WEBEXT?.browserAction && "getBadgeBackgroundColor" in WEBEXT?.browserAction) {
   235          return A.H.TRUE;
   236        }
   237        return A.H.FALSE;
   238      },
   239      "func_GetBadgeBackgroundColor": (fn: Pointer): void => {
   240        A.store.Ref(fn, WEBEXT.browserAction.getBadgeBackgroundColor);
   241      },
   242      "call_GetBadgeBackgroundColor": (retPtr: Pointer, details: Pointer): void => {
   243        const details_ffi = {};
   244  
   245        if (A.load.Bool(details + 8)) {
   246          details_ffi["tabId"] = A.load.Int64(details + 0);
   247        }
   248  
   249        const _ret = WEBEXT.browserAction.getBadgeBackgroundColor(details_ffi);
   250        A.store.Ref(retPtr, _ret);
   251      },
   252      "try_GetBadgeBackgroundColor": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => {
   253        try {
   254          const details_ffi = {};
   255  
   256          if (A.load.Bool(details + 8)) {
   257            details_ffi["tabId"] = A.load.Int64(details + 0);
   258          }
   259  
   260          const _ret = WEBEXT.browserAction.getBadgeBackgroundColor(details_ffi);
   261          A.store.Ref(retPtr, _ret);
   262          return A.H.TRUE;
   263        } catch (err: any) {
   264          A.store.Ref(errPtr, err);
   265          return A.H.FALSE;
   266        }
   267      },
   268      "has_GetBadgeText": (): heap.Ref<boolean> => {
   269        if (WEBEXT?.browserAction && "getBadgeText" in WEBEXT?.browserAction) {
   270          return A.H.TRUE;
   271        }
   272        return A.H.FALSE;
   273      },
   274      "func_GetBadgeText": (fn: Pointer): void => {
   275        A.store.Ref(fn, WEBEXT.browserAction.getBadgeText);
   276      },
   277      "call_GetBadgeText": (retPtr: Pointer, details: Pointer): void => {
   278        const details_ffi = {};
   279  
   280        if (A.load.Bool(details + 8)) {
   281          details_ffi["tabId"] = A.load.Int64(details + 0);
   282        }
   283  
   284        const _ret = WEBEXT.browserAction.getBadgeText(details_ffi);
   285        A.store.Ref(retPtr, _ret);
   286      },
   287      "try_GetBadgeText": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => {
   288        try {
   289          const details_ffi = {};
   290  
   291          if (A.load.Bool(details + 8)) {
   292            details_ffi["tabId"] = A.load.Int64(details + 0);
   293          }
   294  
   295          const _ret = WEBEXT.browserAction.getBadgeText(details_ffi);
   296          A.store.Ref(retPtr, _ret);
   297          return A.H.TRUE;
   298        } catch (err: any) {
   299          A.store.Ref(errPtr, err);
   300          return A.H.FALSE;
   301        }
   302      },
   303      "has_GetPopup": (): heap.Ref<boolean> => {
   304        if (WEBEXT?.browserAction && "getPopup" in WEBEXT?.browserAction) {
   305          return A.H.TRUE;
   306        }
   307        return A.H.FALSE;
   308      },
   309      "func_GetPopup": (fn: Pointer): void => {
   310        A.store.Ref(fn, WEBEXT.browserAction.getPopup);
   311      },
   312      "call_GetPopup": (retPtr: Pointer, details: Pointer): void => {
   313        const details_ffi = {};
   314  
   315        if (A.load.Bool(details + 8)) {
   316          details_ffi["tabId"] = A.load.Int64(details + 0);
   317        }
   318  
   319        const _ret = WEBEXT.browserAction.getPopup(details_ffi);
   320        A.store.Ref(retPtr, _ret);
   321      },
   322      "try_GetPopup": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => {
   323        try {
   324          const details_ffi = {};
   325  
   326          if (A.load.Bool(details + 8)) {
   327            details_ffi["tabId"] = A.load.Int64(details + 0);
   328          }
   329  
   330          const _ret = WEBEXT.browserAction.getPopup(details_ffi);
   331          A.store.Ref(retPtr, _ret);
   332          return A.H.TRUE;
   333        } catch (err: any) {
   334          A.store.Ref(errPtr, err);
   335          return A.H.FALSE;
   336        }
   337      },
   338      "has_GetTitle": (): heap.Ref<boolean> => {
   339        if (WEBEXT?.browserAction && "getTitle" in WEBEXT?.browserAction) {
   340          return A.H.TRUE;
   341        }
   342        return A.H.FALSE;
   343      },
   344      "func_GetTitle": (fn: Pointer): void => {
   345        A.store.Ref(fn, WEBEXT.browserAction.getTitle);
   346      },
   347      "call_GetTitle": (retPtr: Pointer, details: Pointer): void => {
   348        const details_ffi = {};
   349  
   350        if (A.load.Bool(details + 8)) {
   351          details_ffi["tabId"] = A.load.Int64(details + 0);
   352        }
   353  
   354        const _ret = WEBEXT.browserAction.getTitle(details_ffi);
   355        A.store.Ref(retPtr, _ret);
   356      },
   357      "try_GetTitle": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => {
   358        try {
   359          const details_ffi = {};
   360  
   361          if (A.load.Bool(details + 8)) {
   362            details_ffi["tabId"] = A.load.Int64(details + 0);
   363          }
   364  
   365          const _ret = WEBEXT.browserAction.getTitle(details_ffi);
   366          A.store.Ref(retPtr, _ret);
   367          return A.H.TRUE;
   368        } catch (err: any) {
   369          A.store.Ref(errPtr, err);
   370          return A.H.FALSE;
   371        }
   372      },
   373      "has_OnClicked": (): heap.Ref<boolean> => {
   374        if (WEBEXT?.browserAction?.onClicked && "addListener" in WEBEXT?.browserAction?.onClicked) {
   375          return A.H.TRUE;
   376        }
   377        return A.H.FALSE;
   378      },
   379      "func_OnClicked": (fn: Pointer): void => {
   380        A.store.Ref(fn, WEBEXT.browserAction.onClicked.addListener);
   381      },
   382      "call_OnClicked": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   383        const _ret = WEBEXT.browserAction.onClicked.addListener(A.H.get<object>(callback));
   384      },
   385      "try_OnClicked": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   386        try {
   387          const _ret = WEBEXT.browserAction.onClicked.addListener(A.H.get<object>(callback));
   388          return A.H.TRUE;
   389        } catch (err: any) {
   390          A.store.Ref(errPtr, err);
   391          return A.H.FALSE;
   392        }
   393      },
   394      "has_OffClicked": (): heap.Ref<boolean> => {
   395        if (WEBEXT?.browserAction?.onClicked && "removeListener" in WEBEXT?.browserAction?.onClicked) {
   396          return A.H.TRUE;
   397        }
   398        return A.H.FALSE;
   399      },
   400      "func_OffClicked": (fn: Pointer): void => {
   401        A.store.Ref(fn, WEBEXT.browserAction.onClicked.removeListener);
   402      },
   403      "call_OffClicked": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   404        const _ret = WEBEXT.browserAction.onClicked.removeListener(A.H.get<object>(callback));
   405      },
   406      "try_OffClicked": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   407        try {
   408          const _ret = WEBEXT.browserAction.onClicked.removeListener(A.H.get<object>(callback));
   409          return A.H.TRUE;
   410        } catch (err: any) {
   411          A.store.Ref(errPtr, err);
   412          return A.H.FALSE;
   413        }
   414      },
   415      "has_HasOnClicked": (): heap.Ref<boolean> => {
   416        if (WEBEXT?.browserAction?.onClicked && "hasListener" in WEBEXT?.browserAction?.onClicked) {
   417          return A.H.TRUE;
   418        }
   419        return A.H.FALSE;
   420      },
   421      "func_HasOnClicked": (fn: Pointer): void => {
   422        A.store.Ref(fn, WEBEXT.browserAction.onClicked.hasListener);
   423      },
   424      "call_HasOnClicked": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   425        const _ret = WEBEXT.browserAction.onClicked.hasListener(A.H.get<object>(callback));
   426        A.store.Bool(retPtr, _ret);
   427      },
   428      "try_HasOnClicked": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   429        try {
   430          const _ret = WEBEXT.browserAction.onClicked.hasListener(A.H.get<object>(callback));
   431          A.store.Bool(retPtr, _ret);
   432          return A.H.TRUE;
   433        } catch (err: any) {
   434          A.store.Ref(errPtr, err);
   435          return A.H.FALSE;
   436        }
   437      },
   438      "has_OpenPopup": (): heap.Ref<boolean> => {
   439        if (WEBEXT?.browserAction && "openPopup" in WEBEXT?.browserAction) {
   440          return A.H.TRUE;
   441        }
   442        return A.H.FALSE;
   443      },
   444      "func_OpenPopup": (fn: Pointer): void => {
   445        A.store.Ref(fn, WEBEXT.browserAction.openPopup);
   446      },
   447      "call_OpenPopup": (retPtr: Pointer): void => {
   448        const _ret = WEBEXT.browserAction.openPopup();
   449        A.store.Ref(retPtr, _ret);
   450      },
   451      "try_OpenPopup": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
   452        try {
   453          const _ret = WEBEXT.browserAction.openPopup();
   454          A.store.Ref(retPtr, _ret);
   455          return A.H.TRUE;
   456        } catch (err: any) {
   457          A.store.Ref(errPtr, err);
   458          return A.H.FALSE;
   459        }
   460      },
   461      "has_SetBadgeBackgroundColor": (): heap.Ref<boolean> => {
   462        if (WEBEXT?.browserAction && "setBadgeBackgroundColor" in WEBEXT?.browserAction) {
   463          return A.H.TRUE;
   464        }
   465        return A.H.FALSE;
   466      },
   467      "func_SetBadgeBackgroundColor": (fn: Pointer): void => {
   468        A.store.Ref(fn, WEBEXT.browserAction.setBadgeBackgroundColor);
   469      },
   470      "call_SetBadgeBackgroundColor": (retPtr: Pointer, details: Pointer): void => {
   471        const details_ffi = {};
   472  
   473        details_ffi["color"] = A.load.Ref(details + 0, undefined);
   474        if (A.load.Bool(details + 16)) {
   475          details_ffi["tabId"] = A.load.Int64(details + 8);
   476        }
   477  
   478        const _ret = WEBEXT.browserAction.setBadgeBackgroundColor(details_ffi);
   479        A.store.Ref(retPtr, _ret);
   480      },
   481      "try_SetBadgeBackgroundColor": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => {
   482        try {
   483          const details_ffi = {};
   484  
   485          details_ffi["color"] = A.load.Ref(details + 0, undefined);
   486          if (A.load.Bool(details + 16)) {
   487            details_ffi["tabId"] = A.load.Int64(details + 8);
   488          }
   489  
   490          const _ret = WEBEXT.browserAction.setBadgeBackgroundColor(details_ffi);
   491          A.store.Ref(retPtr, _ret);
   492          return A.H.TRUE;
   493        } catch (err: any) {
   494          A.store.Ref(errPtr, err);
   495          return A.H.FALSE;
   496        }
   497      },
   498      "has_SetBadgeText": (): heap.Ref<boolean> => {
   499        if (WEBEXT?.browserAction && "setBadgeText" in WEBEXT?.browserAction) {
   500          return A.H.TRUE;
   501        }
   502        return A.H.FALSE;
   503      },
   504      "func_SetBadgeText": (fn: Pointer): void => {
   505        A.store.Ref(fn, WEBEXT.browserAction.setBadgeText);
   506      },
   507      "call_SetBadgeText": (retPtr: Pointer, details: Pointer): void => {
   508        const details_ffi = {};
   509  
   510        if (A.load.Bool(details + 12)) {
   511          details_ffi["tabId"] = A.load.Int64(details + 0);
   512        }
   513        details_ffi["text"] = A.load.Ref(details + 8, undefined);
   514  
   515        const _ret = WEBEXT.browserAction.setBadgeText(details_ffi);
   516        A.store.Ref(retPtr, _ret);
   517      },
   518      "try_SetBadgeText": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => {
   519        try {
   520          const details_ffi = {};
   521  
   522          if (A.load.Bool(details + 12)) {
   523            details_ffi["tabId"] = A.load.Int64(details + 0);
   524          }
   525          details_ffi["text"] = A.load.Ref(details + 8, undefined);
   526  
   527          const _ret = WEBEXT.browserAction.setBadgeText(details_ffi);
   528          A.store.Ref(retPtr, _ret);
   529          return A.H.TRUE;
   530        } catch (err: any) {
   531          A.store.Ref(errPtr, err);
   532          return A.H.FALSE;
   533        }
   534      },
   535      "has_SetIcon": (): heap.Ref<boolean> => {
   536        if (WEBEXT?.browserAction && "setIcon" in WEBEXT?.browserAction) {
   537          return A.H.TRUE;
   538        }
   539        return A.H.FALSE;
   540      },
   541      "func_SetIcon": (fn: Pointer): void => {
   542        A.store.Ref(fn, WEBEXT.browserAction.setIcon);
   543      },
   544      "call_SetIcon": (retPtr: Pointer, details: Pointer): void => {
   545        const details_ffi = {};
   546  
   547        details_ffi["imageData"] = A.load.Ref(details + 0, undefined);
   548        details_ffi["path"] = A.load.Ref(details + 4, undefined);
   549        if (A.load.Bool(details + 16)) {
   550          details_ffi["tabId"] = A.load.Int64(details + 8);
   551        }
   552  
   553        const _ret = WEBEXT.browserAction.setIcon(details_ffi);
   554        A.store.Ref(retPtr, _ret);
   555      },
   556      "try_SetIcon": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => {
   557        try {
   558          const details_ffi = {};
   559  
   560          details_ffi["imageData"] = A.load.Ref(details + 0, undefined);
   561          details_ffi["path"] = A.load.Ref(details + 4, undefined);
   562          if (A.load.Bool(details + 16)) {
   563            details_ffi["tabId"] = A.load.Int64(details + 8);
   564          }
   565  
   566          const _ret = WEBEXT.browserAction.setIcon(details_ffi);
   567          A.store.Ref(retPtr, _ret);
   568          return A.H.TRUE;
   569        } catch (err: any) {
   570          A.store.Ref(errPtr, err);
   571          return A.H.FALSE;
   572        }
   573      },
   574      "has_SetPopup": (): heap.Ref<boolean> => {
   575        if (WEBEXT?.browserAction && "setPopup" in WEBEXT?.browserAction) {
   576          return A.H.TRUE;
   577        }
   578        return A.H.FALSE;
   579      },
   580      "func_SetPopup": (fn: Pointer): void => {
   581        A.store.Ref(fn, WEBEXT.browserAction.setPopup);
   582      },
   583      "call_SetPopup": (retPtr: Pointer, details: Pointer): void => {
   584        const details_ffi = {};
   585  
   586        details_ffi["popup"] = A.load.Ref(details + 0, undefined);
   587        if (A.load.Bool(details + 16)) {
   588          details_ffi["tabId"] = A.load.Int64(details + 8);
   589        }
   590  
   591        const _ret = WEBEXT.browserAction.setPopup(details_ffi);
   592        A.store.Ref(retPtr, _ret);
   593      },
   594      "try_SetPopup": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => {
   595        try {
   596          const details_ffi = {};
   597  
   598          details_ffi["popup"] = A.load.Ref(details + 0, undefined);
   599          if (A.load.Bool(details + 16)) {
   600            details_ffi["tabId"] = A.load.Int64(details + 8);
   601          }
   602  
   603          const _ret = WEBEXT.browserAction.setPopup(details_ffi);
   604          A.store.Ref(retPtr, _ret);
   605          return A.H.TRUE;
   606        } catch (err: any) {
   607          A.store.Ref(errPtr, err);
   608          return A.H.FALSE;
   609        }
   610      },
   611      "has_SetTitle": (): heap.Ref<boolean> => {
   612        if (WEBEXT?.browserAction && "setTitle" in WEBEXT?.browserAction) {
   613          return A.H.TRUE;
   614        }
   615        return A.H.FALSE;
   616      },
   617      "func_SetTitle": (fn: Pointer): void => {
   618        A.store.Ref(fn, WEBEXT.browserAction.setTitle);
   619      },
   620      "call_SetTitle": (retPtr: Pointer, details: Pointer): void => {
   621        const details_ffi = {};
   622  
   623        if (A.load.Bool(details + 12)) {
   624          details_ffi["tabId"] = A.load.Int64(details + 0);
   625        }
   626        details_ffi["title"] = A.load.Ref(details + 8, undefined);
   627  
   628        const _ret = WEBEXT.browserAction.setTitle(details_ffi);
   629        A.store.Ref(retPtr, _ret);
   630      },
   631      "try_SetTitle": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => {
   632        try {
   633          const details_ffi = {};
   634  
   635          if (A.load.Bool(details + 12)) {
   636            details_ffi["tabId"] = A.load.Int64(details + 0);
   637          }
   638          details_ffi["title"] = A.load.Ref(details + 8, undefined);
   639  
   640          const _ret = WEBEXT.browserAction.setTitle(details_ffi);
   641          A.store.Ref(retPtr, _ret);
   642          return A.H.TRUE;
   643        } catch (err: any) {
   644          A.store.Ref(errPtr, err);
   645          return A.H.FALSE;
   646        }
   647      },
   648    };
   649  });