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

     1  import { importModule, Application, heap, Pointer } from "@ffi";
     2  
     3  importModule("plat/js/webext/test", (A: Application) => {
     4    const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser;
     5  
     6    return {
     7      "store_AssertPromiseRejectsArgExpectedMessageChoice1": (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_AssertPromiseRejectsArgExpectedMessageChoice1": (
    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_AssertPromiseRejectsArgPromise": (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_AssertPromiseRejectsArgPromise": (
    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  
    45      "store_AssertPromiseRejectsReturnType": (ptr: Pointer, ref: heap.Ref<any>) => {
    46        const x = A.H.get<any>(ref);
    47  
    48        if (typeof x === "undefined") {
    49          A.store.Bool(ptr + 0, false);
    50        } else {
    51          A.store.Bool(ptr + 0, true);
    52        }
    53      },
    54      "load_AssertPromiseRejectsReturnType": (
    55        ptr: Pointer,
    56        create: heap.Ref<boolean>,
    57        ref: heap.Ref<any>
    58      ): heap.Ref<any> => {
    59        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    60  
    61        return create === A.H.TRUE ? A.H.push(x) : ref;
    62      },
    63  
    64      "store_AssertThrowsArgMessageChoice1": (ptr: Pointer, ref: heap.Ref<any>) => {
    65        const x = A.H.get<any>(ref);
    66  
    67        if (typeof x === "undefined") {
    68          A.store.Bool(ptr + 0, false);
    69        } else {
    70          A.store.Bool(ptr + 0, true);
    71        }
    72      },
    73      "load_AssertThrowsArgMessageChoice1": (
    74        ptr: Pointer,
    75        create: heap.Ref<boolean>,
    76        ref: heap.Ref<any>
    77      ): heap.Ref<any> => {
    78        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    79  
    80        return create === A.H.TRUE ? A.H.push(x) : ref;
    81      },
    82  
    83      "store_GetConfigReturnTypeFieldFtpServer": (ptr: Pointer, ref: heap.Ref<any>) => {
    84        const x = A.H.get<any>(ref);
    85  
    86        if (typeof x === "undefined") {
    87          A.store.Bool(ptr + 8, false);
    88          A.store.Int64(ptr + 0, 0);
    89        } else {
    90          A.store.Bool(ptr + 8, true);
    91          A.store.Int64(ptr + 0, x["port"] === undefined ? 0 : (x["port"] as number));
    92        }
    93      },
    94      "load_GetConfigReturnTypeFieldFtpServer": (
    95        ptr: Pointer,
    96        create: heap.Ref<boolean>,
    97        ref: heap.Ref<any>
    98      ): heap.Ref<any> => {
    99        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   100  
   101        x["port"] = A.load.Int64(ptr + 0);
   102        return create === A.H.TRUE ? A.H.push(x) : ref;
   103      },
   104  
   105      "store_GetConfigReturnTypeFieldLoginStatus": (ptr: Pointer, ref: heap.Ref<any>) => {
   106        const x = A.H.get<any>(ref);
   107  
   108        if (typeof x === "undefined") {
   109          A.store.Bool(ptr + 4, false);
   110          A.store.Bool(ptr + 2, false);
   111          A.store.Bool(ptr + 0, false);
   112          A.store.Bool(ptr + 3, false);
   113          A.store.Bool(ptr + 1, false);
   114        } else {
   115          A.store.Bool(ptr + 4, true);
   116          A.store.Bool(ptr + 2, "isLoggedIn" in x ? true : false);
   117          A.store.Bool(ptr + 0, x["isLoggedIn"] ? true : false);
   118          A.store.Bool(ptr + 3, "isScreenLocked" in x ? true : false);
   119          A.store.Bool(ptr + 1, x["isScreenLocked"] ? true : false);
   120        }
   121      },
   122      "load_GetConfigReturnTypeFieldLoginStatus": (
   123        ptr: Pointer,
   124        create: heap.Ref<boolean>,
   125        ref: heap.Ref<any>
   126      ): heap.Ref<any> => {
   127        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   128  
   129        if (A.load.Bool(ptr + 2)) {
   130          x["isLoggedIn"] = A.load.Bool(ptr + 0);
   131        } else {
   132          delete x["isLoggedIn"];
   133        }
   134        if (A.load.Bool(ptr + 3)) {
   135          x["isScreenLocked"] = A.load.Bool(ptr + 1);
   136        } else {
   137          delete x["isScreenLocked"];
   138        }
   139        return create === A.H.TRUE ? A.H.push(x) : ref;
   140      },
   141  
   142      "store_GetConfigReturnTypeFieldTestServer": (ptr: Pointer, ref: heap.Ref<any>) => {
   143        const x = A.H.get<any>(ref);
   144  
   145        if (typeof x === "undefined") {
   146          A.store.Bool(ptr + 8, false);
   147          A.store.Int64(ptr + 0, 0);
   148        } else {
   149          A.store.Bool(ptr + 8, true);
   150          A.store.Int64(ptr + 0, x["port"] === undefined ? 0 : (x["port"] as number));
   151        }
   152      },
   153      "load_GetConfigReturnTypeFieldTestServer": (
   154        ptr: Pointer,
   155        create: heap.Ref<boolean>,
   156        ref: heap.Ref<any>
   157      ): heap.Ref<any> => {
   158        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   159  
   160        x["port"] = A.load.Int64(ptr + 0);
   161        return create === A.H.TRUE ? A.H.push(x) : ref;
   162      },
   163  
   164      "store_GetConfigReturnType": (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 + 66, false);
   169          A.store.Ref(ptr + 0, undefined);
   170  
   171          A.store.Bool(ptr + 8 + 8, false);
   172          A.store.Int64(ptr + 8 + 0, 0);
   173  
   174          A.store.Bool(ptr + 17 + 4, false);
   175          A.store.Bool(ptr + 17 + 2, false);
   176          A.store.Bool(ptr + 17 + 0, false);
   177          A.store.Bool(ptr + 17 + 3, false);
   178          A.store.Bool(ptr + 17 + 1, false);
   179          A.store.Ref(ptr + 24, undefined);
   180  
   181          A.store.Bool(ptr + 32 + 8, false);
   182          A.store.Int64(ptr + 32 + 0, 0);
   183          A.store.Bool(ptr + 64, false);
   184          A.store.Int64(ptr + 48, 0);
   185          A.store.Bool(ptr + 65, false);
   186          A.store.Int64(ptr + 56, 0);
   187        } else {
   188          A.store.Bool(ptr + 66, true);
   189          A.store.Ref(ptr + 0, x["customArg"]);
   190  
   191          if (typeof x["ftpServer"] === "undefined") {
   192            A.store.Bool(ptr + 8 + 8, false);
   193            A.store.Int64(ptr + 8 + 0, 0);
   194          } else {
   195            A.store.Bool(ptr + 8 + 8, true);
   196            A.store.Int64(ptr + 8 + 0, x["ftpServer"]["port"] === undefined ? 0 : (x["ftpServer"]["port"] as number));
   197          }
   198  
   199          if (typeof x["loginStatus"] === "undefined") {
   200            A.store.Bool(ptr + 17 + 4, false);
   201            A.store.Bool(ptr + 17 + 2, false);
   202            A.store.Bool(ptr + 17 + 0, false);
   203            A.store.Bool(ptr + 17 + 3, false);
   204            A.store.Bool(ptr + 17 + 1, false);
   205          } else {
   206            A.store.Bool(ptr + 17 + 4, true);
   207            A.store.Bool(ptr + 17 + 2, "isLoggedIn" in x["loginStatus"] ? true : false);
   208            A.store.Bool(ptr + 17 + 0, x["loginStatus"]["isLoggedIn"] ? true : false);
   209            A.store.Bool(ptr + 17 + 3, "isScreenLocked" in x["loginStatus"] ? true : false);
   210            A.store.Bool(ptr + 17 + 1, x["loginStatus"]["isScreenLocked"] ? true : false);
   211          }
   212          A.store.Ref(ptr + 24, x["testDataDirectory"]);
   213  
   214          if (typeof x["testServer"] === "undefined") {
   215            A.store.Bool(ptr + 32 + 8, false);
   216            A.store.Int64(ptr + 32 + 0, 0);
   217          } else {
   218            A.store.Bool(ptr + 32 + 8, true);
   219            A.store.Int64(ptr + 32 + 0, x["testServer"]["port"] === undefined ? 0 : (x["testServer"]["port"] as number));
   220          }
   221          A.store.Bool(ptr + 64, "testWebSocketPort" in x ? true : false);
   222          A.store.Int64(ptr + 48, x["testWebSocketPort"] === undefined ? 0 : (x["testWebSocketPort"] as number));
   223          A.store.Bool(ptr + 65, "testWebTransportPort" in x ? true : false);
   224          A.store.Int64(ptr + 56, x["testWebTransportPort"] === undefined ? 0 : (x["testWebTransportPort"] as number));
   225        }
   226      },
   227      "load_GetConfigReturnType": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   228        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   229  
   230        x["customArg"] = A.load.Ref(ptr + 0, undefined);
   231        if (A.load.Bool(ptr + 8 + 8)) {
   232          x["ftpServer"] = {};
   233          x["ftpServer"]["port"] = A.load.Int64(ptr + 8 + 0);
   234        } else {
   235          delete x["ftpServer"];
   236        }
   237        if (A.load.Bool(ptr + 17 + 4)) {
   238          x["loginStatus"] = {};
   239          if (A.load.Bool(ptr + 17 + 2)) {
   240            x["loginStatus"]["isLoggedIn"] = A.load.Bool(ptr + 17 + 0);
   241          } else {
   242            delete x["loginStatus"]["isLoggedIn"];
   243          }
   244          if (A.load.Bool(ptr + 17 + 3)) {
   245            x["loginStatus"]["isScreenLocked"] = A.load.Bool(ptr + 17 + 1);
   246          } else {
   247            delete x["loginStatus"]["isScreenLocked"];
   248          }
   249        } else {
   250          delete x["loginStatus"];
   251        }
   252        x["testDataDirectory"] = A.load.Ref(ptr + 24, undefined);
   253        if (A.load.Bool(ptr + 32 + 8)) {
   254          x["testServer"] = {};
   255          x["testServer"]["port"] = A.load.Int64(ptr + 32 + 0);
   256        } else {
   257          delete x["testServer"];
   258        }
   259        if (A.load.Bool(ptr + 64)) {
   260          x["testWebSocketPort"] = A.load.Int64(ptr + 48);
   261        } else {
   262          delete x["testWebSocketPort"];
   263        }
   264        if (A.load.Bool(ptr + 65)) {
   265          x["testWebTransportPort"] = A.load.Int64(ptr + 56);
   266        } else {
   267          delete x["testWebTransportPort"];
   268        }
   269        return create === A.H.TRUE ? A.H.push(x) : ref;
   270      },
   271  
   272      "store_LoadScriptReturnType": (ptr: Pointer, ref: heap.Ref<any>) => {
   273        const x = A.H.get<any>(ref);
   274  
   275        if (typeof x === "undefined") {
   276          A.store.Bool(ptr + 0, false);
   277        } else {
   278          A.store.Bool(ptr + 0, true);
   279        }
   280      },
   281      "load_LoadScriptReturnType": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   282        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   283  
   284        return create === A.H.TRUE ? A.H.push(x) : ref;
   285      },
   286  
   287      "store_OnMessageArgInfo": (ptr: Pointer, ref: heap.Ref<any>) => {
   288        const x = A.H.get<any>(ref);
   289  
   290        if (typeof x === "undefined") {
   291          A.store.Bool(ptr + 5, false);
   292          A.store.Ref(ptr + 0, undefined);
   293          A.store.Bool(ptr + 4, false);
   294        } else {
   295          A.store.Bool(ptr + 5, true);
   296          A.store.Ref(ptr + 0, x["data"]);
   297          A.store.Bool(ptr + 4, x["lastMessage"] ? true : false);
   298        }
   299      },
   300      "load_OnMessageArgInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   301        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   302  
   303        x["data"] = A.load.Ref(ptr + 0, undefined);
   304        x["lastMessage"] = A.load.Bool(ptr + 4);
   305        return create === A.H.TRUE ? A.H.push(x) : ref;
   306      },
   307      "has_AssertEq": (): heap.Ref<boolean> => {
   308        if (WEBEXT?.test && "assertEq" in WEBEXT?.test) {
   309          return A.H.TRUE;
   310        }
   311        return A.H.FALSE;
   312      },
   313      "func_AssertEq": (fn: Pointer): void => {
   314        A.store.Ref(fn, WEBEXT.test.assertEq);
   315      },
   316      "call_AssertEq": (
   317        retPtr: Pointer,
   318        expected: heap.Ref<object>,
   319        actual: heap.Ref<object>,
   320        message: heap.Ref<object>
   321      ): void => {
   322        const _ret = WEBEXT.test.assertEq(A.H.get<object>(expected), A.H.get<object>(actual), A.H.get<object>(message));
   323      },
   324      "try_AssertEq": (
   325        retPtr: Pointer,
   326        errPtr: Pointer,
   327        expected: heap.Ref<object>,
   328        actual: heap.Ref<object>,
   329        message: heap.Ref<object>
   330      ): heap.Ref<boolean> => {
   331        try {
   332          const _ret = WEBEXT.test.assertEq(A.H.get<object>(expected), A.H.get<object>(actual), A.H.get<object>(message));
   333          return A.H.TRUE;
   334        } catch (err: any) {
   335          A.store.Ref(errPtr, err);
   336          return A.H.FALSE;
   337        }
   338      },
   339      "has_AssertFalse": (): heap.Ref<boolean> => {
   340        if (WEBEXT?.test && "assertFalse" in WEBEXT?.test) {
   341          return A.H.TRUE;
   342        }
   343        return A.H.FALSE;
   344      },
   345      "func_AssertFalse": (fn: Pointer): void => {
   346        A.store.Ref(fn, WEBEXT.test.assertFalse);
   347      },
   348      "call_AssertFalse": (retPtr: Pointer, test: heap.Ref<any>, message: heap.Ref<object>): void => {
   349        const _ret = WEBEXT.test.assertFalse(A.H.get<any>(test), A.H.get<object>(message));
   350      },
   351      "try_AssertFalse": (
   352        retPtr: Pointer,
   353        errPtr: Pointer,
   354        test: heap.Ref<any>,
   355        message: heap.Ref<object>
   356      ): heap.Ref<boolean> => {
   357        try {
   358          const _ret = WEBEXT.test.assertFalse(A.H.get<any>(test), A.H.get<object>(message));
   359          return A.H.TRUE;
   360        } catch (err: any) {
   361          A.store.Ref(errPtr, err);
   362          return A.H.FALSE;
   363        }
   364      },
   365      "has_AssertLastError": (): heap.Ref<boolean> => {
   366        if (WEBEXT?.test && "assertLastError" in WEBEXT?.test) {
   367          return A.H.TRUE;
   368        }
   369        return A.H.FALSE;
   370      },
   371      "func_AssertLastError": (fn: Pointer): void => {
   372        A.store.Ref(fn, WEBEXT.test.assertLastError);
   373      },
   374      "call_AssertLastError": (retPtr: Pointer, expectedError: heap.Ref<object>): void => {
   375        const _ret = WEBEXT.test.assertLastError(A.H.get<object>(expectedError));
   376      },
   377      "try_AssertLastError": (retPtr: Pointer, errPtr: Pointer, expectedError: heap.Ref<object>): heap.Ref<boolean> => {
   378        try {
   379          const _ret = WEBEXT.test.assertLastError(A.H.get<object>(expectedError));
   380          return A.H.TRUE;
   381        } catch (err: any) {
   382          A.store.Ref(errPtr, err);
   383          return A.H.FALSE;
   384        }
   385      },
   386      "has_AssertNe": (): heap.Ref<boolean> => {
   387        if (WEBEXT?.test && "assertNe" in WEBEXT?.test) {
   388          return A.H.TRUE;
   389        }
   390        return A.H.FALSE;
   391      },
   392      "func_AssertNe": (fn: Pointer): void => {
   393        A.store.Ref(fn, WEBEXT.test.assertNe);
   394      },
   395      "call_AssertNe": (
   396        retPtr: Pointer,
   397        expected: heap.Ref<object>,
   398        actual: heap.Ref<object>,
   399        message: heap.Ref<object>
   400      ): void => {
   401        const _ret = WEBEXT.test.assertNe(A.H.get<object>(expected), A.H.get<object>(actual), A.H.get<object>(message));
   402      },
   403      "try_AssertNe": (
   404        retPtr: Pointer,
   405        errPtr: Pointer,
   406        expected: heap.Ref<object>,
   407        actual: heap.Ref<object>,
   408        message: heap.Ref<object>
   409      ): heap.Ref<boolean> => {
   410        try {
   411          const _ret = WEBEXT.test.assertNe(A.H.get<object>(expected), A.H.get<object>(actual), A.H.get<object>(message));
   412          return A.H.TRUE;
   413        } catch (err: any) {
   414          A.store.Ref(errPtr, err);
   415          return A.H.FALSE;
   416        }
   417      },
   418      "has_AssertNoLastError": (): heap.Ref<boolean> => {
   419        if (WEBEXT?.test && "assertNoLastError" in WEBEXT?.test) {
   420          return A.H.TRUE;
   421        }
   422        return A.H.FALSE;
   423      },
   424      "func_AssertNoLastError": (fn: Pointer): void => {
   425        A.store.Ref(fn, WEBEXT.test.assertNoLastError);
   426      },
   427      "call_AssertNoLastError": (retPtr: Pointer): void => {
   428        const _ret = WEBEXT.test.assertNoLastError();
   429      },
   430      "try_AssertNoLastError": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
   431        try {
   432          const _ret = WEBEXT.test.assertNoLastError();
   433          return A.H.TRUE;
   434        } catch (err: any) {
   435          A.store.Ref(errPtr, err);
   436          return A.H.FALSE;
   437        }
   438      },
   439      "has_AssertPromiseRejects": (): heap.Ref<boolean> => {
   440        if (WEBEXT?.test && "assertPromiseRejects" in WEBEXT?.test) {
   441          return A.H.TRUE;
   442        }
   443        return A.H.FALSE;
   444      },
   445      "func_AssertPromiseRejects": (fn: Pointer): void => {
   446        A.store.Ref(fn, WEBEXT.test.assertPromiseRejects);
   447      },
   448      "call_AssertPromiseRejects": (retPtr: Pointer, promise: Pointer, expectedMessage: heap.Ref<any>): void => {
   449        const promise_ffi = {};
   450  
   451        const _ret = WEBEXT.test.assertPromiseRejects(promise_ffi, A.H.get<any>(expectedMessage));
   452        if (typeof _ret === "undefined") {
   453          A.store.Bool(retPtr + 0, false);
   454        } else {
   455          A.store.Bool(retPtr + 0, true);
   456        }
   457      },
   458      "try_AssertPromiseRejects": (
   459        retPtr: Pointer,
   460        errPtr: Pointer,
   461        promise: Pointer,
   462        expectedMessage: heap.Ref<any>
   463      ): heap.Ref<boolean> => {
   464        try {
   465          const promise_ffi = {};
   466  
   467          const _ret = WEBEXT.test.assertPromiseRejects(promise_ffi, A.H.get<any>(expectedMessage));
   468          if (typeof _ret === "undefined") {
   469            A.store.Bool(retPtr + 0, false);
   470          } else {
   471            A.store.Bool(retPtr + 0, true);
   472          }
   473          return A.H.TRUE;
   474        } catch (err: any) {
   475          A.store.Ref(errPtr, err);
   476          return A.H.FALSE;
   477        }
   478      },
   479      "has_AssertThrows": (): heap.Ref<boolean> => {
   480        if (WEBEXT?.test && "assertThrows" in WEBEXT?.test) {
   481          return A.H.TRUE;
   482        }
   483        return A.H.FALSE;
   484      },
   485      "func_AssertThrows": (fn: Pointer): void => {
   486        A.store.Ref(fn, WEBEXT.test.assertThrows);
   487      },
   488      "call_AssertThrows": (
   489        retPtr: Pointer,
   490        fn: heap.Ref<object>,
   491        self: heap.Ref<object>,
   492        args: heap.Ref<object>,
   493        message: heap.Ref<any>
   494      ): void => {
   495        const _ret = WEBEXT.test.assertThrows(
   496          A.H.get<object>(fn),
   497          A.H.get<object>(self),
   498          A.H.get<object>(args),
   499          A.H.get<any>(message)
   500        );
   501      },
   502      "try_AssertThrows": (
   503        retPtr: Pointer,
   504        errPtr: Pointer,
   505        fn: heap.Ref<object>,
   506        self: heap.Ref<object>,
   507        args: heap.Ref<object>,
   508        message: heap.Ref<any>
   509      ): heap.Ref<boolean> => {
   510        try {
   511          const _ret = WEBEXT.test.assertThrows(
   512            A.H.get<object>(fn),
   513            A.H.get<object>(self),
   514            A.H.get<object>(args),
   515            A.H.get<any>(message)
   516          );
   517          return A.H.TRUE;
   518        } catch (err: any) {
   519          A.store.Ref(errPtr, err);
   520          return A.H.FALSE;
   521        }
   522      },
   523      "has_AssertTrue": (): heap.Ref<boolean> => {
   524        if (WEBEXT?.test && "assertTrue" in WEBEXT?.test) {
   525          return A.H.TRUE;
   526        }
   527        return A.H.FALSE;
   528      },
   529      "func_AssertTrue": (fn: Pointer): void => {
   530        A.store.Ref(fn, WEBEXT.test.assertTrue);
   531      },
   532      "call_AssertTrue": (retPtr: Pointer, test: heap.Ref<any>, message: heap.Ref<object>): void => {
   533        const _ret = WEBEXT.test.assertTrue(A.H.get<any>(test), A.H.get<object>(message));
   534      },
   535      "try_AssertTrue": (
   536        retPtr: Pointer,
   537        errPtr: Pointer,
   538        test: heap.Ref<any>,
   539        message: heap.Ref<object>
   540      ): heap.Ref<boolean> => {
   541        try {
   542          const _ret = WEBEXT.test.assertTrue(A.H.get<any>(test), A.H.get<object>(message));
   543          return A.H.TRUE;
   544        } catch (err: any) {
   545          A.store.Ref(errPtr, err);
   546          return A.H.FALSE;
   547        }
   548      },
   549      "has_Callback": (): heap.Ref<boolean> => {
   550        if (WEBEXT?.test && "callback" in WEBEXT?.test) {
   551          return A.H.TRUE;
   552        }
   553        return A.H.FALSE;
   554      },
   555      "func_Callback": (fn: Pointer): void => {
   556        A.store.Ref(fn, WEBEXT.test.callback);
   557      },
   558      "call_Callback": (retPtr: Pointer, func: heap.Ref<object>, expectedError: heap.Ref<object>): void => {
   559        const _ret = WEBEXT.test.callback(A.H.get<object>(func), A.H.get<object>(expectedError));
   560      },
   561      "try_Callback": (
   562        retPtr: Pointer,
   563        errPtr: Pointer,
   564        func: heap.Ref<object>,
   565        expectedError: heap.Ref<object>
   566      ): heap.Ref<boolean> => {
   567        try {
   568          const _ret = WEBEXT.test.callback(A.H.get<object>(func), A.H.get<object>(expectedError));
   569          return A.H.TRUE;
   570        } catch (err: any) {
   571          A.store.Ref(errPtr, err);
   572          return A.H.FALSE;
   573        }
   574      },
   575      "has_CallbackAdded": (): heap.Ref<boolean> => {
   576        if (WEBEXT?.test && "callbackAdded" in WEBEXT?.test) {
   577          return A.H.TRUE;
   578        }
   579        return A.H.FALSE;
   580      },
   581      "func_CallbackAdded": (fn: Pointer): void => {
   582        A.store.Ref(fn, WEBEXT.test.callbackAdded);
   583      },
   584      "call_CallbackAdded": (retPtr: Pointer): void => {
   585        const _ret = WEBEXT.test.callbackAdded();
   586      },
   587      "try_CallbackAdded": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
   588        try {
   589          const _ret = WEBEXT.test.callbackAdded();
   590          return A.H.TRUE;
   591        } catch (err: any) {
   592          A.store.Ref(errPtr, err);
   593          return A.H.FALSE;
   594        }
   595      },
   596      "has_CallbackFail": (): heap.Ref<boolean> => {
   597        if (WEBEXT?.test && "callbackFail" in WEBEXT?.test) {
   598          return A.H.TRUE;
   599        }
   600        return A.H.FALSE;
   601      },
   602      "func_CallbackFail": (fn: Pointer): void => {
   603        A.store.Ref(fn, WEBEXT.test.callbackFail);
   604      },
   605      "call_CallbackFail": (retPtr: Pointer, expectedError: heap.Ref<object>, func: heap.Ref<object>): void => {
   606        const _ret = WEBEXT.test.callbackFail(A.H.get<object>(expectedError), A.H.get<object>(func));
   607      },
   608      "try_CallbackFail": (
   609        retPtr: Pointer,
   610        errPtr: Pointer,
   611        expectedError: heap.Ref<object>,
   612        func: heap.Ref<object>
   613      ): heap.Ref<boolean> => {
   614        try {
   615          const _ret = WEBEXT.test.callbackFail(A.H.get<object>(expectedError), A.H.get<object>(func));
   616          return A.H.TRUE;
   617        } catch (err: any) {
   618          A.store.Ref(errPtr, err);
   619          return A.H.FALSE;
   620        }
   621      },
   622      "has_CallbackPass": (): heap.Ref<boolean> => {
   623        if (WEBEXT?.test && "callbackPass" in WEBEXT?.test) {
   624          return A.H.TRUE;
   625        }
   626        return A.H.FALSE;
   627      },
   628      "func_CallbackPass": (fn: Pointer): void => {
   629        A.store.Ref(fn, WEBEXT.test.callbackPass);
   630      },
   631      "call_CallbackPass": (retPtr: Pointer, func: heap.Ref<object>): void => {
   632        const _ret = WEBEXT.test.callbackPass(A.H.get<object>(func));
   633      },
   634      "try_CallbackPass": (retPtr: Pointer, errPtr: Pointer, func: heap.Ref<object>): heap.Ref<boolean> => {
   635        try {
   636          const _ret = WEBEXT.test.callbackPass(A.H.get<object>(func));
   637          return A.H.TRUE;
   638        } catch (err: any) {
   639          A.store.Ref(errPtr, err);
   640          return A.H.FALSE;
   641        }
   642      },
   643      "has_CheckDeepEq": (): heap.Ref<boolean> => {
   644        if (WEBEXT?.test && "checkDeepEq" in WEBEXT?.test) {
   645          return A.H.TRUE;
   646        }
   647        return A.H.FALSE;
   648      },
   649      "func_CheckDeepEq": (fn: Pointer): void => {
   650        A.store.Ref(fn, WEBEXT.test.checkDeepEq);
   651      },
   652      "call_CheckDeepEq": (retPtr: Pointer, expected: heap.Ref<object>, actual: heap.Ref<object>): void => {
   653        const _ret = WEBEXT.test.checkDeepEq(A.H.get<object>(expected), A.H.get<object>(actual));
   654      },
   655      "try_CheckDeepEq": (
   656        retPtr: Pointer,
   657        errPtr: Pointer,
   658        expected: heap.Ref<object>,
   659        actual: heap.Ref<object>
   660      ): heap.Ref<boolean> => {
   661        try {
   662          const _ret = WEBEXT.test.checkDeepEq(A.H.get<object>(expected), A.H.get<object>(actual));
   663          return A.H.TRUE;
   664        } catch (err: any) {
   665          A.store.Ref(errPtr, err);
   666          return A.H.FALSE;
   667        }
   668      },
   669      "has_Fail": (): heap.Ref<boolean> => {
   670        if (WEBEXT?.test && "fail" in WEBEXT?.test) {
   671          return A.H.TRUE;
   672        }
   673        return A.H.FALSE;
   674      },
   675      "func_Fail": (fn: Pointer): void => {
   676        A.store.Ref(fn, WEBEXT.test.fail);
   677      },
   678      "call_Fail": (retPtr: Pointer, message: heap.Ref<object>): void => {
   679        const _ret = WEBEXT.test.fail(A.H.get<object>(message));
   680      },
   681      "try_Fail": (retPtr: Pointer, errPtr: Pointer, message: heap.Ref<object>): heap.Ref<boolean> => {
   682        try {
   683          const _ret = WEBEXT.test.fail(A.H.get<object>(message));
   684          return A.H.TRUE;
   685        } catch (err: any) {
   686          A.store.Ref(errPtr, err);
   687          return A.H.FALSE;
   688        }
   689      },
   690      "has_GetApiDefinitions": (): heap.Ref<boolean> => {
   691        if (WEBEXT?.test && "getApiDefinitions" in WEBEXT?.test) {
   692          return A.H.TRUE;
   693        }
   694        return A.H.FALSE;
   695      },
   696      "func_GetApiDefinitions": (fn: Pointer): void => {
   697        A.store.Ref(fn, WEBEXT.test.getApiDefinitions);
   698      },
   699      "call_GetApiDefinitions": (retPtr: Pointer, apiNames: heap.Ref<object>): void => {
   700        const _ret = WEBEXT.test.getApiDefinitions(A.H.get<object>(apiNames));
   701      },
   702      "try_GetApiDefinitions": (retPtr: Pointer, errPtr: Pointer, apiNames: heap.Ref<object>): heap.Ref<boolean> => {
   703        try {
   704          const _ret = WEBEXT.test.getApiDefinitions(A.H.get<object>(apiNames));
   705          return A.H.TRUE;
   706        } catch (err: any) {
   707          A.store.Ref(errPtr, err);
   708          return A.H.FALSE;
   709        }
   710      },
   711      "has_GetApiFeatures": (): heap.Ref<boolean> => {
   712        if (WEBEXT?.test && "getApiFeatures" in WEBEXT?.test) {
   713          return A.H.TRUE;
   714        }
   715        return A.H.FALSE;
   716      },
   717      "func_GetApiFeatures": (fn: Pointer): void => {
   718        A.store.Ref(fn, WEBEXT.test.getApiFeatures);
   719      },
   720      "call_GetApiFeatures": (retPtr: Pointer): void => {
   721        const _ret = WEBEXT.test.getApiFeatures();
   722      },
   723      "try_GetApiFeatures": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
   724        try {
   725          const _ret = WEBEXT.test.getApiFeatures();
   726          return A.H.TRUE;
   727        } catch (err: any) {
   728          A.store.Ref(errPtr, err);
   729          return A.H.FALSE;
   730        }
   731      },
   732      "has_GetConfig": (): heap.Ref<boolean> => {
   733        if (WEBEXT?.test && "getConfig" in WEBEXT?.test) {
   734          return A.H.TRUE;
   735        }
   736        return A.H.FALSE;
   737      },
   738      "func_GetConfig": (fn: Pointer): void => {
   739        A.store.Ref(fn, WEBEXT.test.getConfig);
   740      },
   741      "call_GetConfig": (retPtr: Pointer): void => {
   742        const _ret = WEBEXT.test.getConfig();
   743        A.store.Ref(retPtr, _ret);
   744      },
   745      "try_GetConfig": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
   746        try {
   747          const _ret = WEBEXT.test.getConfig();
   748          A.store.Ref(retPtr, _ret);
   749          return A.H.TRUE;
   750        } catch (err: any) {
   751          A.store.Ref(errPtr, err);
   752          return A.H.FALSE;
   753        }
   754      },
   755      "has_GetModuleSystem": (): heap.Ref<boolean> => {
   756        if (WEBEXT?.test && "getModuleSystem" in WEBEXT?.test) {
   757          return A.H.TRUE;
   758        }
   759        return A.H.FALSE;
   760      },
   761      "func_GetModuleSystem": (fn: Pointer): void => {
   762        A.store.Ref(fn, WEBEXT.test.getModuleSystem);
   763      },
   764      "call_GetModuleSystem": (retPtr: Pointer, context: heap.Ref<object>): void => {
   765        const _ret = WEBEXT.test.getModuleSystem(A.H.get<object>(context));
   766        A.store.Ref(retPtr, _ret);
   767      },
   768      "try_GetModuleSystem": (retPtr: Pointer, errPtr: Pointer, context: heap.Ref<object>): heap.Ref<boolean> => {
   769        try {
   770          const _ret = WEBEXT.test.getModuleSystem(A.H.get<object>(context));
   771          A.store.Ref(retPtr, _ret);
   772          return A.H.TRUE;
   773        } catch (err: any) {
   774          A.store.Ref(errPtr, err);
   775          return A.H.FALSE;
   776        }
   777      },
   778      "has_GetWakeEventPage": (): heap.Ref<boolean> => {
   779        if (WEBEXT?.test && "getWakeEventPage" in WEBEXT?.test) {
   780          return A.H.TRUE;
   781        }
   782        return A.H.FALSE;
   783      },
   784      "func_GetWakeEventPage": (fn: Pointer): void => {
   785        A.store.Ref(fn, WEBEXT.test.getWakeEventPage);
   786      },
   787      "call_GetWakeEventPage": (retPtr: Pointer): void => {
   788        const _ret = WEBEXT.test.getWakeEventPage();
   789        A.store.Ref(retPtr, _ret);
   790      },
   791      "try_GetWakeEventPage": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
   792        try {
   793          const _ret = WEBEXT.test.getWakeEventPage();
   794          A.store.Ref(retPtr, _ret);
   795          return A.H.TRUE;
   796        } catch (err: any) {
   797          A.store.Ref(errPtr, err);
   798          return A.H.FALSE;
   799        }
   800      },
   801      "has_IsProcessingUserGesture": (): heap.Ref<boolean> => {
   802        if (WEBEXT?.test && "isProcessingUserGesture" in WEBEXT?.test) {
   803          return A.H.TRUE;
   804        }
   805        return A.H.FALSE;
   806      },
   807      "func_IsProcessingUserGesture": (fn: Pointer): void => {
   808        A.store.Ref(fn, WEBEXT.test.isProcessingUserGesture);
   809      },
   810      "call_IsProcessingUserGesture": (retPtr: Pointer): void => {
   811        const _ret = WEBEXT.test.isProcessingUserGesture();
   812      },
   813      "try_IsProcessingUserGesture": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
   814        try {
   815          const _ret = WEBEXT.test.isProcessingUserGesture();
   816          return A.H.TRUE;
   817        } catch (err: any) {
   818          A.store.Ref(errPtr, err);
   819          return A.H.FALSE;
   820        }
   821      },
   822      "has_ListenForever": (): heap.Ref<boolean> => {
   823        if (WEBEXT?.test && "listenForever" in WEBEXT?.test) {
   824          return A.H.TRUE;
   825        }
   826        return A.H.FALSE;
   827      },
   828      "func_ListenForever": (fn: Pointer): void => {
   829        A.store.Ref(fn, WEBEXT.test.listenForever);
   830      },
   831      "call_ListenForever": (retPtr: Pointer, event: heap.Ref<object>, func: heap.Ref<object>): void => {
   832        const _ret = WEBEXT.test.listenForever(A.H.get<object>(event), A.H.get<object>(func));
   833      },
   834      "try_ListenForever": (
   835        retPtr: Pointer,
   836        errPtr: Pointer,
   837        event: heap.Ref<object>,
   838        func: heap.Ref<object>
   839      ): heap.Ref<boolean> => {
   840        try {
   841          const _ret = WEBEXT.test.listenForever(A.H.get<object>(event), A.H.get<object>(func));
   842          return A.H.TRUE;
   843        } catch (err: any) {
   844          A.store.Ref(errPtr, err);
   845          return A.H.FALSE;
   846        }
   847      },
   848      "has_ListenOnce": (): heap.Ref<boolean> => {
   849        if (WEBEXT?.test && "listenOnce" in WEBEXT?.test) {
   850          return A.H.TRUE;
   851        }
   852        return A.H.FALSE;
   853      },
   854      "func_ListenOnce": (fn: Pointer): void => {
   855        A.store.Ref(fn, WEBEXT.test.listenOnce);
   856      },
   857      "call_ListenOnce": (retPtr: Pointer, event: heap.Ref<object>, func: heap.Ref<object>): void => {
   858        const _ret = WEBEXT.test.listenOnce(A.H.get<object>(event), A.H.get<object>(func));
   859      },
   860      "try_ListenOnce": (
   861        retPtr: Pointer,
   862        errPtr: Pointer,
   863        event: heap.Ref<object>,
   864        func: heap.Ref<object>
   865      ): heap.Ref<boolean> => {
   866        try {
   867          const _ret = WEBEXT.test.listenOnce(A.H.get<object>(event), A.H.get<object>(func));
   868          return A.H.TRUE;
   869        } catch (err: any) {
   870          A.store.Ref(errPtr, err);
   871          return A.H.FALSE;
   872        }
   873      },
   874      "has_LoadScript": (): heap.Ref<boolean> => {
   875        if (WEBEXT?.test && "loadScript" in WEBEXT?.test) {
   876          return A.H.TRUE;
   877        }
   878        return A.H.FALSE;
   879      },
   880      "func_LoadScript": (fn: Pointer): void => {
   881        A.store.Ref(fn, WEBEXT.test.loadScript);
   882      },
   883      "call_LoadScript": (retPtr: Pointer, scriptUrl: heap.Ref<object>): void => {
   884        const _ret = WEBEXT.test.loadScript(A.H.get<object>(scriptUrl));
   885        if (typeof _ret === "undefined") {
   886          A.store.Bool(retPtr + 0, false);
   887        } else {
   888          A.store.Bool(retPtr + 0, true);
   889        }
   890      },
   891      "try_LoadScript": (retPtr: Pointer, errPtr: Pointer, scriptUrl: heap.Ref<object>): heap.Ref<boolean> => {
   892        try {
   893          const _ret = WEBEXT.test.loadScript(A.H.get<object>(scriptUrl));
   894          if (typeof _ret === "undefined") {
   895            A.store.Bool(retPtr + 0, false);
   896          } else {
   897            A.store.Bool(retPtr + 0, true);
   898          }
   899          return A.H.TRUE;
   900        } catch (err: any) {
   901          A.store.Ref(errPtr, err);
   902          return A.H.FALSE;
   903        }
   904      },
   905      "has_Log": (): heap.Ref<boolean> => {
   906        if (WEBEXT?.test && "log" in WEBEXT?.test) {
   907          return A.H.TRUE;
   908        }
   909        return A.H.FALSE;
   910      },
   911      "func_Log": (fn: Pointer): void => {
   912        A.store.Ref(fn, WEBEXT.test.log);
   913      },
   914      "call_Log": (retPtr: Pointer, message: heap.Ref<object>): void => {
   915        const _ret = WEBEXT.test.log(A.H.get<object>(message));
   916      },
   917      "try_Log": (retPtr: Pointer, errPtr: Pointer, message: heap.Ref<object>): heap.Ref<boolean> => {
   918        try {
   919          const _ret = WEBEXT.test.log(A.H.get<object>(message));
   920          return A.H.TRUE;
   921        } catch (err: any) {
   922          A.store.Ref(errPtr, err);
   923          return A.H.FALSE;
   924        }
   925      },
   926      "has_NotifyFail": (): heap.Ref<boolean> => {
   927        if (WEBEXT?.test && "notifyFail" in WEBEXT?.test) {
   928          return A.H.TRUE;
   929        }
   930        return A.H.FALSE;
   931      },
   932      "func_NotifyFail": (fn: Pointer): void => {
   933        A.store.Ref(fn, WEBEXT.test.notifyFail);
   934      },
   935      "call_NotifyFail": (retPtr: Pointer, message: heap.Ref<object>): void => {
   936        const _ret = WEBEXT.test.notifyFail(A.H.get<object>(message));
   937      },
   938      "try_NotifyFail": (retPtr: Pointer, errPtr: Pointer, message: heap.Ref<object>): heap.Ref<boolean> => {
   939        try {
   940          const _ret = WEBEXT.test.notifyFail(A.H.get<object>(message));
   941          return A.H.TRUE;
   942        } catch (err: any) {
   943          A.store.Ref(errPtr, err);
   944          return A.H.FALSE;
   945        }
   946      },
   947      "has_NotifyPass": (): heap.Ref<boolean> => {
   948        if (WEBEXT?.test && "notifyPass" in WEBEXT?.test) {
   949          return A.H.TRUE;
   950        }
   951        return A.H.FALSE;
   952      },
   953      "func_NotifyPass": (fn: Pointer): void => {
   954        A.store.Ref(fn, WEBEXT.test.notifyPass);
   955      },
   956      "call_NotifyPass": (retPtr: Pointer, message: heap.Ref<object>): void => {
   957        const _ret = WEBEXT.test.notifyPass(A.H.get<object>(message));
   958      },
   959      "try_NotifyPass": (retPtr: Pointer, errPtr: Pointer, message: heap.Ref<object>): heap.Ref<boolean> => {
   960        try {
   961          const _ret = WEBEXT.test.notifyPass(A.H.get<object>(message));
   962          return A.H.TRUE;
   963        } catch (err: any) {
   964          A.store.Ref(errPtr, err);
   965          return A.H.FALSE;
   966        }
   967      },
   968      "has_OnMessage": (): heap.Ref<boolean> => {
   969        if (WEBEXT?.test?.onMessage && "addListener" in WEBEXT?.test?.onMessage) {
   970          return A.H.TRUE;
   971        }
   972        return A.H.FALSE;
   973      },
   974      "func_OnMessage": (fn: Pointer): void => {
   975        A.store.Ref(fn, WEBEXT.test.onMessage.addListener);
   976      },
   977      "call_OnMessage": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   978        const _ret = WEBEXT.test.onMessage.addListener(A.H.get<object>(callback));
   979      },
   980      "try_OnMessage": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   981        try {
   982          const _ret = WEBEXT.test.onMessage.addListener(A.H.get<object>(callback));
   983          return A.H.TRUE;
   984        } catch (err: any) {
   985          A.store.Ref(errPtr, err);
   986          return A.H.FALSE;
   987        }
   988      },
   989      "has_OffMessage": (): heap.Ref<boolean> => {
   990        if (WEBEXT?.test?.onMessage && "removeListener" in WEBEXT?.test?.onMessage) {
   991          return A.H.TRUE;
   992        }
   993        return A.H.FALSE;
   994      },
   995      "func_OffMessage": (fn: Pointer): void => {
   996        A.store.Ref(fn, WEBEXT.test.onMessage.removeListener);
   997      },
   998      "call_OffMessage": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   999        const _ret = WEBEXT.test.onMessage.removeListener(A.H.get<object>(callback));
  1000      },
  1001      "try_OffMessage": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
  1002        try {
  1003          const _ret = WEBEXT.test.onMessage.removeListener(A.H.get<object>(callback));
  1004          return A.H.TRUE;
  1005        } catch (err: any) {
  1006          A.store.Ref(errPtr, err);
  1007          return A.H.FALSE;
  1008        }
  1009      },
  1010      "has_HasOnMessage": (): heap.Ref<boolean> => {
  1011        if (WEBEXT?.test?.onMessage && "hasListener" in WEBEXT?.test?.onMessage) {
  1012          return A.H.TRUE;
  1013        }
  1014        return A.H.FALSE;
  1015      },
  1016      "func_HasOnMessage": (fn: Pointer): void => {
  1017        A.store.Ref(fn, WEBEXT.test.onMessage.hasListener);
  1018      },
  1019      "call_HasOnMessage": (retPtr: Pointer, callback: heap.Ref<object>): void => {
  1020        const _ret = WEBEXT.test.onMessage.hasListener(A.H.get<object>(callback));
  1021        A.store.Bool(retPtr, _ret);
  1022      },
  1023      "try_HasOnMessage": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
  1024        try {
  1025          const _ret = WEBEXT.test.onMessage.hasListener(A.H.get<object>(callback));
  1026          A.store.Bool(retPtr, _ret);
  1027          return A.H.TRUE;
  1028        } catch (err: any) {
  1029          A.store.Ref(errPtr, err);
  1030          return A.H.FALSE;
  1031        }
  1032      },
  1033      "has_OpenFileUrl": (): heap.Ref<boolean> => {
  1034        if (WEBEXT?.test && "openFileUrl" in WEBEXT?.test) {
  1035          return A.H.TRUE;
  1036        }
  1037        return A.H.FALSE;
  1038      },
  1039      "func_OpenFileUrl": (fn: Pointer): void => {
  1040        A.store.Ref(fn, WEBEXT.test.openFileUrl);
  1041      },
  1042      "call_OpenFileUrl": (retPtr: Pointer, url: heap.Ref<object>): void => {
  1043        const _ret = WEBEXT.test.openFileUrl(A.H.get<object>(url));
  1044      },
  1045      "try_OpenFileUrl": (retPtr: Pointer, errPtr: Pointer, url: heap.Ref<object>): heap.Ref<boolean> => {
  1046        try {
  1047          const _ret = WEBEXT.test.openFileUrl(A.H.get<object>(url));
  1048          return A.H.TRUE;
  1049        } catch (err: any) {
  1050          A.store.Ref(errPtr, err);
  1051          return A.H.FALSE;
  1052        }
  1053      },
  1054      "has_RunTests": (): heap.Ref<boolean> => {
  1055        if (WEBEXT?.test && "runTests" in WEBEXT?.test) {
  1056          return A.H.TRUE;
  1057        }
  1058        return A.H.FALSE;
  1059      },
  1060      "func_RunTests": (fn: Pointer): void => {
  1061        A.store.Ref(fn, WEBEXT.test.runTests);
  1062      },
  1063      "call_RunTests": (retPtr: Pointer, tests: heap.Ref<object>): void => {
  1064        const _ret = WEBEXT.test.runTests(A.H.get<object>(tests));
  1065      },
  1066      "try_RunTests": (retPtr: Pointer, errPtr: Pointer, tests: heap.Ref<object>): heap.Ref<boolean> => {
  1067        try {
  1068          const _ret = WEBEXT.test.runTests(A.H.get<object>(tests));
  1069          return A.H.TRUE;
  1070        } catch (err: any) {
  1071          A.store.Ref(errPtr, err);
  1072          return A.H.FALSE;
  1073        }
  1074      },
  1075      "has_RunWithUserGesture": (): heap.Ref<boolean> => {
  1076        if (WEBEXT?.test && "runWithUserGesture" in WEBEXT?.test) {
  1077          return A.H.TRUE;
  1078        }
  1079        return A.H.FALSE;
  1080      },
  1081      "func_RunWithUserGesture": (fn: Pointer): void => {
  1082        A.store.Ref(fn, WEBEXT.test.runWithUserGesture);
  1083      },
  1084      "call_RunWithUserGesture": (retPtr: Pointer, functionToRun: heap.Ref<object>): void => {
  1085        const _ret = WEBEXT.test.runWithUserGesture(A.H.get<object>(functionToRun));
  1086      },
  1087      "try_RunWithUserGesture": (
  1088        retPtr: Pointer,
  1089        errPtr: Pointer,
  1090        functionToRun: heap.Ref<object>
  1091      ): heap.Ref<boolean> => {
  1092        try {
  1093          const _ret = WEBEXT.test.runWithUserGesture(A.H.get<object>(functionToRun));
  1094          return A.H.TRUE;
  1095        } catch (err: any) {
  1096          A.store.Ref(errPtr, err);
  1097          return A.H.FALSE;
  1098        }
  1099      },
  1100      "has_SendMessage": (): heap.Ref<boolean> => {
  1101        if (WEBEXT?.test && "sendMessage" in WEBEXT?.test) {
  1102          return A.H.TRUE;
  1103        }
  1104        return A.H.FALSE;
  1105      },
  1106      "func_SendMessage": (fn: Pointer): void => {
  1107        A.store.Ref(fn, WEBEXT.test.sendMessage);
  1108      },
  1109      "call_SendMessage": (retPtr: Pointer, message: heap.Ref<object>): void => {
  1110        const _ret = WEBEXT.test.sendMessage(A.H.get<object>(message));
  1111        A.store.Ref(retPtr, _ret);
  1112      },
  1113      "try_SendMessage": (retPtr: Pointer, errPtr: Pointer, message: heap.Ref<object>): heap.Ref<boolean> => {
  1114        try {
  1115          const _ret = WEBEXT.test.sendMessage(A.H.get<object>(message));
  1116          A.store.Ref(retPtr, _ret);
  1117          return A.H.TRUE;
  1118        } catch (err: any) {
  1119          A.store.Ref(errPtr, err);
  1120          return A.H.FALSE;
  1121        }
  1122      },
  1123      "has_SendScriptResult": (): heap.Ref<boolean> => {
  1124        if (WEBEXT?.test && "sendScriptResult" in WEBEXT?.test) {
  1125          return A.H.TRUE;
  1126        }
  1127        return A.H.FALSE;
  1128      },
  1129      "func_SendScriptResult": (fn: Pointer): void => {
  1130        A.store.Ref(fn, WEBEXT.test.sendScriptResult);
  1131      },
  1132      "call_SendScriptResult": (retPtr: Pointer, result: heap.Ref<object>): void => {
  1133        const _ret = WEBEXT.test.sendScriptResult(A.H.get<object>(result));
  1134        A.store.Ref(retPtr, _ret);
  1135      },
  1136      "try_SendScriptResult": (retPtr: Pointer, errPtr: Pointer, result: heap.Ref<object>): heap.Ref<boolean> => {
  1137        try {
  1138          const _ret = WEBEXT.test.sendScriptResult(A.H.get<object>(result));
  1139          A.store.Ref(retPtr, _ret);
  1140          return A.H.TRUE;
  1141        } catch (err: any) {
  1142          A.store.Ref(errPtr, err);
  1143          return A.H.FALSE;
  1144        }
  1145      },
  1146      "has_SetExceptionHandler": (): heap.Ref<boolean> => {
  1147        if (WEBEXT?.test && "setExceptionHandler" in WEBEXT?.test) {
  1148          return A.H.TRUE;
  1149        }
  1150        return A.H.FALSE;
  1151      },
  1152      "func_SetExceptionHandler": (fn: Pointer): void => {
  1153        A.store.Ref(fn, WEBEXT.test.setExceptionHandler);
  1154      },
  1155      "call_SetExceptionHandler": (retPtr: Pointer, handler: heap.Ref<object>): void => {
  1156        const _ret = WEBEXT.test.setExceptionHandler(A.H.get<object>(handler));
  1157      },
  1158      "try_SetExceptionHandler": (retPtr: Pointer, errPtr: Pointer, handler: heap.Ref<object>): heap.Ref<boolean> => {
  1159        try {
  1160          const _ret = WEBEXT.test.setExceptionHandler(A.H.get<object>(handler));
  1161          return A.H.TRUE;
  1162        } catch (err: any) {
  1163          A.store.Ref(errPtr, err);
  1164          return A.H.FALSE;
  1165        }
  1166      },
  1167      "has_Succeed": (): heap.Ref<boolean> => {
  1168        if (WEBEXT?.test && "succeed" in WEBEXT?.test) {
  1169          return A.H.TRUE;
  1170        }
  1171        return A.H.FALSE;
  1172      },
  1173      "func_Succeed": (fn: Pointer): void => {
  1174        A.store.Ref(fn, WEBEXT.test.succeed);
  1175      },
  1176      "call_Succeed": (retPtr: Pointer, message: heap.Ref<object>): void => {
  1177        const _ret = WEBEXT.test.succeed(A.H.get<object>(message));
  1178      },
  1179      "try_Succeed": (retPtr: Pointer, errPtr: Pointer, message: heap.Ref<object>): heap.Ref<boolean> => {
  1180        try {
  1181          const _ret = WEBEXT.test.succeed(A.H.get<object>(message));
  1182          return A.H.TRUE;
  1183        } catch (err: any) {
  1184          A.store.Ref(errPtr, err);
  1185          return A.H.FALSE;
  1186        }
  1187      },
  1188      "has_WaitForRoundTrip": (): heap.Ref<boolean> => {
  1189        if (WEBEXT?.test && "waitForRoundTrip" in WEBEXT?.test) {
  1190          return A.H.TRUE;
  1191        }
  1192        return A.H.FALSE;
  1193      },
  1194      "func_WaitForRoundTrip": (fn: Pointer): void => {
  1195        A.store.Ref(fn, WEBEXT.test.waitForRoundTrip);
  1196      },
  1197      "call_WaitForRoundTrip": (retPtr: Pointer, message: heap.Ref<object>): void => {
  1198        const _ret = WEBEXT.test.waitForRoundTrip(A.H.get<object>(message));
  1199        A.store.Ref(retPtr, _ret);
  1200      },
  1201      "try_WaitForRoundTrip": (retPtr: Pointer, errPtr: Pointer, message: heap.Ref<object>): heap.Ref<boolean> => {
  1202        try {
  1203          const _ret = WEBEXT.test.waitForRoundTrip(A.H.get<object>(message));
  1204          A.store.Ref(retPtr, _ret);
  1205          return A.H.TRUE;
  1206        } catch (err: any) {
  1207          A.store.Ref(errPtr, err);
  1208          return A.H.FALSE;
  1209        }
  1210      },
  1211    };
  1212  });