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

     1  import { importModule, Application, heap, Pointer } from "@ffi";
     2  
     3  importModule("plat/js/webext/contextmenus", (A: Application) => {
     4    const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser;
     5  
     6    return {
     7      "get_ACTION_MENU_TOP_LEVEL_LIMIT": (retPtr: Pointer): heap.Ref<boolean> => {
     8        if (WEBEXT?.contextMenus && "ACTION_MENU_TOP_LEVEL_LIMIT" in WEBEXT?.contextMenus) {
     9          const val = WEBEXT.contextMenus.ACTION_MENU_TOP_LEVEL_LIMIT;
    10          A.store.Ref(retPtr, val);
    11          return A.H.TRUE;
    12        }
    13  
    14        return A.H.FALSE;
    15      },
    16      "set_ACTION_MENU_TOP_LEVEL_LIMIT": (val: heap.Ref<object>): heap.Ref<boolean> => {
    17        return Reflect.set(WEBEXT.contextMenus, "ACTION_MENU_TOP_LEVEL_LIMIT", A.H.get<object>(val), WEBEXT.contextMenus)
    18          ? A.H.TRUE
    19          : A.H.FALSE;
    20      },
    21  
    22      "store_OnClickData": (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 + 52, false);
    27          A.store.Bool(ptr + 49, false);
    28          A.store.Bool(ptr + 0, false);
    29          A.store.Bool(ptr + 1, false);
    30          A.store.Bool(ptr + 50, false);
    31          A.store.Int64(ptr + 8, 0);
    32          A.store.Ref(ptr + 16, undefined);
    33          A.store.Ref(ptr + 20, undefined);
    34          A.store.Ref(ptr + 24, undefined);
    35          A.store.Ref(ptr + 28, undefined);
    36          A.store.Ref(ptr + 32, undefined);
    37          A.store.Ref(ptr + 36, undefined);
    38          A.store.Ref(ptr + 40, undefined);
    39          A.store.Ref(ptr + 44, undefined);
    40          A.store.Bool(ptr + 51, false);
    41          A.store.Bool(ptr + 48, false);
    42        } else {
    43          A.store.Bool(ptr + 52, true);
    44          A.store.Bool(ptr + 49, "checked" in x ? true : false);
    45          A.store.Bool(ptr + 0, x["checked"] ? true : false);
    46          A.store.Bool(ptr + 1, x["editable"] ? true : false);
    47          A.store.Bool(ptr + 50, "frameId" in x ? true : false);
    48          A.store.Int64(ptr + 8, x["frameId"] === undefined ? 0 : (x["frameId"] as number));
    49          A.store.Ref(ptr + 16, x["frameUrl"]);
    50          A.store.Ref(ptr + 20, x["linkUrl"]);
    51          A.store.Ref(ptr + 24, x["mediaType"]);
    52          A.store.Ref(ptr + 28, x["menuItemId"]);
    53          A.store.Ref(ptr + 32, x["pageUrl"]);
    54          A.store.Ref(ptr + 36, x["parentMenuItemId"]);
    55          A.store.Ref(ptr + 40, x["selectionText"]);
    56          A.store.Ref(ptr + 44, x["srcUrl"]);
    57          A.store.Bool(ptr + 51, "wasChecked" in x ? true : false);
    58          A.store.Bool(ptr + 48, x["wasChecked"] ? true : false);
    59        }
    60      },
    61      "load_OnClickData": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    62        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    63  
    64        if (A.load.Bool(ptr + 49)) {
    65          x["checked"] = A.load.Bool(ptr + 0);
    66        } else {
    67          delete x["checked"];
    68        }
    69        x["editable"] = A.load.Bool(ptr + 1);
    70        if (A.load.Bool(ptr + 50)) {
    71          x["frameId"] = A.load.Int64(ptr + 8);
    72        } else {
    73          delete x["frameId"];
    74        }
    75        x["frameUrl"] = A.load.Ref(ptr + 16, undefined);
    76        x["linkUrl"] = A.load.Ref(ptr + 20, undefined);
    77        x["mediaType"] = A.load.Ref(ptr + 24, undefined);
    78        x["menuItemId"] = A.load.Ref(ptr + 28, undefined);
    79        x["pageUrl"] = A.load.Ref(ptr + 32, undefined);
    80        x["parentMenuItemId"] = A.load.Ref(ptr + 36, undefined);
    81        x["selectionText"] = A.load.Ref(ptr + 40, undefined);
    82        x["srcUrl"] = A.load.Ref(ptr + 44, undefined);
    83        if (A.load.Bool(ptr + 51)) {
    84          x["wasChecked"] = A.load.Bool(ptr + 48);
    85        } else {
    86          delete x["wasChecked"];
    87        }
    88        return create === A.H.TRUE ? A.H.push(x) : ref;
    89      },
    90      "constof_ItemType": (ref: heap.Ref<string>): number => {
    91        const idx = ["normal", "checkbox", "radio", "separator"].indexOf(A.H.get(ref));
    92        return idx < 0 ? 0 : idx + 1;
    93      },
    94      "constof_ContextType": (ref: heap.Ref<string>): number => {
    95        const idx = [
    96          "all",
    97          "page",
    98          "frame",
    99          "selection",
   100          "link",
   101          "editable",
   102          "image",
   103          "video",
   104          "audio",
   105          "launcher",
   106          "browser_action",
   107          "page_action",
   108          "action",
   109        ].indexOf(A.H.get(ref));
   110        return idx < 0 ? 0 : idx + 1;
   111      },
   112  
   113      "store_CreateArgCreateProperties": (ptr: Pointer, ref: heap.Ref<any>) => {
   114        const x = A.H.get<any>(ref);
   115  
   116        if (typeof x === "undefined") {
   117          A.store.Bool(ptr + 44, false);
   118          A.store.Bool(ptr + 41, false);
   119          A.store.Bool(ptr + 0, false);
   120          A.store.Ref(ptr + 4, undefined);
   121          A.store.Ref(ptr + 8, undefined);
   122          A.store.Bool(ptr + 42, false);
   123          A.store.Bool(ptr + 12, false);
   124          A.store.Ref(ptr + 16, undefined);
   125          A.store.Ref(ptr + 20, undefined);
   126          A.store.Ref(ptr + 24, undefined);
   127          A.store.Ref(ptr + 28, undefined);
   128          A.store.Ref(ptr + 32, undefined);
   129          A.store.Enum(ptr + 36, -1);
   130          A.store.Bool(ptr + 43, false);
   131          A.store.Bool(ptr + 40, false);
   132        } else {
   133          A.store.Bool(ptr + 44, true);
   134          A.store.Bool(ptr + 41, "checked" in x ? true : false);
   135          A.store.Bool(ptr + 0, x["checked"] ? true : false);
   136          A.store.Ref(ptr + 4, x["contexts"]);
   137          A.store.Ref(ptr + 8, x["documentUrlPatterns"]);
   138          A.store.Bool(ptr + 42, "enabled" in x ? true : false);
   139          A.store.Bool(ptr + 12, x["enabled"] ? true : false);
   140          A.store.Ref(ptr + 16, x["id"]);
   141          A.store.Ref(ptr + 20, x["onclick"]);
   142          A.store.Ref(ptr + 24, x["parentId"]);
   143          A.store.Ref(ptr + 28, x["targetUrlPatterns"]);
   144          A.store.Ref(ptr + 32, x["title"]);
   145          A.store.Enum(ptr + 36, ["normal", "checkbox", "radio", "separator"].indexOf(x["type"] as string));
   146          A.store.Bool(ptr + 43, "visible" in x ? true : false);
   147          A.store.Bool(ptr + 40, x["visible"] ? true : false);
   148        }
   149      },
   150      "load_CreateArgCreateProperties": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   151        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   152  
   153        if (A.load.Bool(ptr + 41)) {
   154          x["checked"] = A.load.Bool(ptr + 0);
   155        } else {
   156          delete x["checked"];
   157        }
   158        x["contexts"] = A.load.Ref(ptr + 4, undefined);
   159        x["documentUrlPatterns"] = A.load.Ref(ptr + 8, undefined);
   160        if (A.load.Bool(ptr + 42)) {
   161          x["enabled"] = A.load.Bool(ptr + 12);
   162        } else {
   163          delete x["enabled"];
   164        }
   165        x["id"] = A.load.Ref(ptr + 16, undefined);
   166        x["onclick"] = A.load.Ref(ptr + 20, undefined);
   167        x["parentId"] = A.load.Ref(ptr + 24, undefined);
   168        x["targetUrlPatterns"] = A.load.Ref(ptr + 28, undefined);
   169        x["title"] = A.load.Ref(ptr + 32, undefined);
   170        x["type"] = A.load.Enum(ptr + 36, ["normal", "checkbox", "radio", "separator"]);
   171        if (A.load.Bool(ptr + 43)) {
   172          x["visible"] = A.load.Bool(ptr + 40);
   173        } else {
   174          delete x["visible"];
   175        }
   176        return create === A.H.TRUE ? A.H.push(x) : ref;
   177      },
   178  
   179      "store_UpdateArgUpdateProperties": (ptr: Pointer, ref: heap.Ref<any>) => {
   180        const x = A.H.get<any>(ref);
   181  
   182        if (typeof x === "undefined") {
   183          A.store.Bool(ptr + 40, false);
   184          A.store.Bool(ptr + 37, false);
   185          A.store.Bool(ptr + 0, false);
   186          A.store.Ref(ptr + 4, undefined);
   187          A.store.Ref(ptr + 8, undefined);
   188          A.store.Bool(ptr + 38, false);
   189          A.store.Bool(ptr + 12, false);
   190          A.store.Ref(ptr + 16, undefined);
   191          A.store.Ref(ptr + 20, undefined);
   192          A.store.Ref(ptr + 24, undefined);
   193          A.store.Ref(ptr + 28, undefined);
   194          A.store.Enum(ptr + 32, -1);
   195          A.store.Bool(ptr + 39, false);
   196          A.store.Bool(ptr + 36, false);
   197        } else {
   198          A.store.Bool(ptr + 40, true);
   199          A.store.Bool(ptr + 37, "checked" in x ? true : false);
   200          A.store.Bool(ptr + 0, x["checked"] ? true : false);
   201          A.store.Ref(ptr + 4, x["contexts"]);
   202          A.store.Ref(ptr + 8, x["documentUrlPatterns"]);
   203          A.store.Bool(ptr + 38, "enabled" in x ? true : false);
   204          A.store.Bool(ptr + 12, x["enabled"] ? true : false);
   205          A.store.Ref(ptr + 16, x["onclick"]);
   206          A.store.Ref(ptr + 20, x["parentId"]);
   207          A.store.Ref(ptr + 24, x["targetUrlPatterns"]);
   208          A.store.Ref(ptr + 28, x["title"]);
   209          A.store.Enum(ptr + 32, ["normal", "checkbox", "radio", "separator"].indexOf(x["type"] as string));
   210          A.store.Bool(ptr + 39, "visible" in x ? true : false);
   211          A.store.Bool(ptr + 36, x["visible"] ? true : false);
   212        }
   213      },
   214      "load_UpdateArgUpdateProperties": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   215        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   216  
   217        if (A.load.Bool(ptr + 37)) {
   218          x["checked"] = A.load.Bool(ptr + 0);
   219        } else {
   220          delete x["checked"];
   221        }
   222        x["contexts"] = A.load.Ref(ptr + 4, undefined);
   223        x["documentUrlPatterns"] = A.load.Ref(ptr + 8, undefined);
   224        if (A.load.Bool(ptr + 38)) {
   225          x["enabled"] = A.load.Bool(ptr + 12);
   226        } else {
   227          delete x["enabled"];
   228        }
   229        x["onclick"] = A.load.Ref(ptr + 16, undefined);
   230        x["parentId"] = A.load.Ref(ptr + 20, undefined);
   231        x["targetUrlPatterns"] = A.load.Ref(ptr + 24, undefined);
   232        x["title"] = A.load.Ref(ptr + 28, undefined);
   233        x["type"] = A.load.Enum(ptr + 32, ["normal", "checkbox", "radio", "separator"]);
   234        if (A.load.Bool(ptr + 39)) {
   235          x["visible"] = A.load.Bool(ptr + 36);
   236        } else {
   237          delete x["visible"];
   238        }
   239        return create === A.H.TRUE ? A.H.push(x) : ref;
   240      },
   241      "has_Create": (): heap.Ref<boolean> => {
   242        if (WEBEXT?.contextMenus && "create" in WEBEXT?.contextMenus) {
   243          return A.H.TRUE;
   244        }
   245        return A.H.FALSE;
   246      },
   247      "func_Create": (fn: Pointer): void => {
   248        A.store.Ref(fn, WEBEXT.contextMenus.create);
   249      },
   250      "call_Create": (retPtr: Pointer, createProperties: Pointer, callback: heap.Ref<object>): void => {
   251        const createProperties_ffi = {};
   252  
   253        if (A.load.Bool(createProperties + 41)) {
   254          createProperties_ffi["checked"] = A.load.Bool(createProperties + 0);
   255        }
   256        createProperties_ffi["contexts"] = A.load.Ref(createProperties + 4, undefined);
   257        createProperties_ffi["documentUrlPatterns"] = A.load.Ref(createProperties + 8, undefined);
   258        if (A.load.Bool(createProperties + 42)) {
   259          createProperties_ffi["enabled"] = A.load.Bool(createProperties + 12);
   260        }
   261        createProperties_ffi["id"] = A.load.Ref(createProperties + 16, undefined);
   262        createProperties_ffi["onclick"] = A.load.Ref(createProperties + 20, undefined);
   263        createProperties_ffi["parentId"] = A.load.Ref(createProperties + 24, undefined);
   264        createProperties_ffi["targetUrlPatterns"] = A.load.Ref(createProperties + 28, undefined);
   265        createProperties_ffi["title"] = A.load.Ref(createProperties + 32, undefined);
   266        createProperties_ffi["type"] = A.load.Enum(createProperties + 36, ["normal", "checkbox", "radio", "separator"]);
   267        if (A.load.Bool(createProperties + 43)) {
   268          createProperties_ffi["visible"] = A.load.Bool(createProperties + 40);
   269        }
   270  
   271        const _ret = WEBEXT.contextMenus.create(createProperties_ffi, A.H.get<object>(callback));
   272        A.store.Ref(retPtr, _ret);
   273      },
   274      "try_Create": (
   275        retPtr: Pointer,
   276        errPtr: Pointer,
   277        createProperties: Pointer,
   278        callback: heap.Ref<object>
   279      ): heap.Ref<boolean> => {
   280        try {
   281          const createProperties_ffi = {};
   282  
   283          if (A.load.Bool(createProperties + 41)) {
   284            createProperties_ffi["checked"] = A.load.Bool(createProperties + 0);
   285          }
   286          createProperties_ffi["contexts"] = A.load.Ref(createProperties + 4, undefined);
   287          createProperties_ffi["documentUrlPatterns"] = A.load.Ref(createProperties + 8, undefined);
   288          if (A.load.Bool(createProperties + 42)) {
   289            createProperties_ffi["enabled"] = A.load.Bool(createProperties + 12);
   290          }
   291          createProperties_ffi["id"] = A.load.Ref(createProperties + 16, undefined);
   292          createProperties_ffi["onclick"] = A.load.Ref(createProperties + 20, undefined);
   293          createProperties_ffi["parentId"] = A.load.Ref(createProperties + 24, undefined);
   294          createProperties_ffi["targetUrlPatterns"] = A.load.Ref(createProperties + 28, undefined);
   295          createProperties_ffi["title"] = A.load.Ref(createProperties + 32, undefined);
   296          createProperties_ffi["type"] = A.load.Enum(createProperties + 36, ["normal", "checkbox", "radio", "separator"]);
   297          if (A.load.Bool(createProperties + 43)) {
   298            createProperties_ffi["visible"] = A.load.Bool(createProperties + 40);
   299          }
   300  
   301          const _ret = WEBEXT.contextMenus.create(createProperties_ffi, A.H.get<object>(callback));
   302          A.store.Ref(retPtr, _ret);
   303          return A.H.TRUE;
   304        } catch (err: any) {
   305          A.store.Ref(errPtr, err);
   306          return A.H.FALSE;
   307        }
   308      },
   309      "has_OnClicked": (): heap.Ref<boolean> => {
   310        if (WEBEXT?.contextMenus?.onClicked && "addListener" in WEBEXT?.contextMenus?.onClicked) {
   311          return A.H.TRUE;
   312        }
   313        return A.H.FALSE;
   314      },
   315      "func_OnClicked": (fn: Pointer): void => {
   316        A.store.Ref(fn, WEBEXT.contextMenus.onClicked.addListener);
   317      },
   318      "call_OnClicked": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   319        const _ret = WEBEXT.contextMenus.onClicked.addListener(A.H.get<object>(callback));
   320      },
   321      "try_OnClicked": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   322        try {
   323          const _ret = WEBEXT.contextMenus.onClicked.addListener(A.H.get<object>(callback));
   324          return A.H.TRUE;
   325        } catch (err: any) {
   326          A.store.Ref(errPtr, err);
   327          return A.H.FALSE;
   328        }
   329      },
   330      "has_OffClicked": (): heap.Ref<boolean> => {
   331        if (WEBEXT?.contextMenus?.onClicked && "removeListener" in WEBEXT?.contextMenus?.onClicked) {
   332          return A.H.TRUE;
   333        }
   334        return A.H.FALSE;
   335      },
   336      "func_OffClicked": (fn: Pointer): void => {
   337        A.store.Ref(fn, WEBEXT.contextMenus.onClicked.removeListener);
   338      },
   339      "call_OffClicked": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   340        const _ret = WEBEXT.contextMenus.onClicked.removeListener(A.H.get<object>(callback));
   341      },
   342      "try_OffClicked": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   343        try {
   344          const _ret = WEBEXT.contextMenus.onClicked.removeListener(A.H.get<object>(callback));
   345          return A.H.TRUE;
   346        } catch (err: any) {
   347          A.store.Ref(errPtr, err);
   348          return A.H.FALSE;
   349        }
   350      },
   351      "has_HasOnClicked": (): heap.Ref<boolean> => {
   352        if (WEBEXT?.contextMenus?.onClicked && "hasListener" in WEBEXT?.contextMenus?.onClicked) {
   353          return A.H.TRUE;
   354        }
   355        return A.H.FALSE;
   356      },
   357      "func_HasOnClicked": (fn: Pointer): void => {
   358        A.store.Ref(fn, WEBEXT.contextMenus.onClicked.hasListener);
   359      },
   360      "call_HasOnClicked": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   361        const _ret = WEBEXT.contextMenus.onClicked.hasListener(A.H.get<object>(callback));
   362        A.store.Bool(retPtr, _ret);
   363      },
   364      "try_HasOnClicked": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   365        try {
   366          const _ret = WEBEXT.contextMenus.onClicked.hasListener(A.H.get<object>(callback));
   367          A.store.Bool(retPtr, _ret);
   368          return A.H.TRUE;
   369        } catch (err: any) {
   370          A.store.Ref(errPtr, err);
   371          return A.H.FALSE;
   372        }
   373      },
   374      "has_Remove": (): heap.Ref<boolean> => {
   375        if (WEBEXT?.contextMenus && "remove" in WEBEXT?.contextMenus) {
   376          return A.H.TRUE;
   377        }
   378        return A.H.FALSE;
   379      },
   380      "func_Remove": (fn: Pointer): void => {
   381        A.store.Ref(fn, WEBEXT.contextMenus.remove);
   382      },
   383      "call_Remove": (retPtr: Pointer, menuItemId: heap.Ref<any>, callback: heap.Ref<object>): void => {
   384        const _ret = WEBEXT.contextMenus.remove(A.H.get<any>(menuItemId), A.H.get<object>(callback));
   385      },
   386      "try_Remove": (
   387        retPtr: Pointer,
   388        errPtr: Pointer,
   389        menuItemId: heap.Ref<any>,
   390        callback: heap.Ref<object>
   391      ): heap.Ref<boolean> => {
   392        try {
   393          const _ret = WEBEXT.contextMenus.remove(A.H.get<any>(menuItemId), A.H.get<object>(callback));
   394          return A.H.TRUE;
   395        } catch (err: any) {
   396          A.store.Ref(errPtr, err);
   397          return A.H.FALSE;
   398        }
   399      },
   400      "has_RemoveAll": (): heap.Ref<boolean> => {
   401        if (WEBEXT?.contextMenus && "removeAll" in WEBEXT?.contextMenus) {
   402          return A.H.TRUE;
   403        }
   404        return A.H.FALSE;
   405      },
   406      "func_RemoveAll": (fn: Pointer): void => {
   407        A.store.Ref(fn, WEBEXT.contextMenus.removeAll);
   408      },
   409      "call_RemoveAll": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   410        const _ret = WEBEXT.contextMenus.removeAll(A.H.get<object>(callback));
   411      },
   412      "try_RemoveAll": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   413        try {
   414          const _ret = WEBEXT.contextMenus.removeAll(A.H.get<object>(callback));
   415          return A.H.TRUE;
   416        } catch (err: any) {
   417          A.store.Ref(errPtr, err);
   418          return A.H.FALSE;
   419        }
   420      },
   421      "has_Update": (): heap.Ref<boolean> => {
   422        if (WEBEXT?.contextMenus && "update" in WEBEXT?.contextMenus) {
   423          return A.H.TRUE;
   424        }
   425        return A.H.FALSE;
   426      },
   427      "func_Update": (fn: Pointer): void => {
   428        A.store.Ref(fn, WEBEXT.contextMenus.update);
   429      },
   430      "call_Update": (
   431        retPtr: Pointer,
   432        id: heap.Ref<any>,
   433        updateProperties: Pointer,
   434        callback: heap.Ref<object>
   435      ): void => {
   436        const updateProperties_ffi = {};
   437  
   438        if (A.load.Bool(updateProperties + 37)) {
   439          updateProperties_ffi["checked"] = A.load.Bool(updateProperties + 0);
   440        }
   441        updateProperties_ffi["contexts"] = A.load.Ref(updateProperties + 4, undefined);
   442        updateProperties_ffi["documentUrlPatterns"] = A.load.Ref(updateProperties + 8, undefined);
   443        if (A.load.Bool(updateProperties + 38)) {
   444          updateProperties_ffi["enabled"] = A.load.Bool(updateProperties + 12);
   445        }
   446        updateProperties_ffi["onclick"] = A.load.Ref(updateProperties + 16, undefined);
   447        updateProperties_ffi["parentId"] = A.load.Ref(updateProperties + 20, undefined);
   448        updateProperties_ffi["targetUrlPatterns"] = A.load.Ref(updateProperties + 24, undefined);
   449        updateProperties_ffi["title"] = A.load.Ref(updateProperties + 28, undefined);
   450        updateProperties_ffi["type"] = A.load.Enum(updateProperties + 32, ["normal", "checkbox", "radio", "separator"]);
   451        if (A.load.Bool(updateProperties + 39)) {
   452          updateProperties_ffi["visible"] = A.load.Bool(updateProperties + 36);
   453        }
   454  
   455        const _ret = WEBEXT.contextMenus.update(A.H.get<any>(id), updateProperties_ffi, A.H.get<object>(callback));
   456      },
   457      "try_Update": (
   458        retPtr: Pointer,
   459        errPtr: Pointer,
   460        id: heap.Ref<any>,
   461        updateProperties: Pointer,
   462        callback: heap.Ref<object>
   463      ): heap.Ref<boolean> => {
   464        try {
   465          const updateProperties_ffi = {};
   466  
   467          if (A.load.Bool(updateProperties + 37)) {
   468            updateProperties_ffi["checked"] = A.load.Bool(updateProperties + 0);
   469          }
   470          updateProperties_ffi["contexts"] = A.load.Ref(updateProperties + 4, undefined);
   471          updateProperties_ffi["documentUrlPatterns"] = A.load.Ref(updateProperties + 8, undefined);
   472          if (A.load.Bool(updateProperties + 38)) {
   473            updateProperties_ffi["enabled"] = A.load.Bool(updateProperties + 12);
   474          }
   475          updateProperties_ffi["onclick"] = A.load.Ref(updateProperties + 16, undefined);
   476          updateProperties_ffi["parentId"] = A.load.Ref(updateProperties + 20, undefined);
   477          updateProperties_ffi["targetUrlPatterns"] = A.load.Ref(updateProperties + 24, undefined);
   478          updateProperties_ffi["title"] = A.load.Ref(updateProperties + 28, undefined);
   479          updateProperties_ffi["type"] = A.load.Enum(updateProperties + 32, ["normal", "checkbox", "radio", "separator"]);
   480          if (A.load.Bool(updateProperties + 39)) {
   481            updateProperties_ffi["visible"] = A.load.Bool(updateProperties + 36);
   482          }
   483  
   484          const _ret = WEBEXT.contextMenus.update(A.H.get<any>(id), updateProperties_ffi, A.H.get<object>(callback));
   485          return A.H.TRUE;
   486        } catch (err: any) {
   487          A.store.Ref(errPtr, err);
   488          return A.H.FALSE;
   489        }
   490      },
   491    };
   492  });