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

     1  import { importModule, Application, heap, Pointer } from "@ffi";
     2  
     3  importModule("plat/js/webext/socket", (A: Application) => {
     4    const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser;
     5  
     6    return {
     7      "store_AcceptInfo": (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 + 10, false);
    12          A.store.Bool(ptr + 8, false);
    13          A.store.Int32(ptr + 0, 0);
    14          A.store.Bool(ptr + 9, false);
    15          A.store.Int32(ptr + 4, 0);
    16        } else {
    17          A.store.Bool(ptr + 10, true);
    18          A.store.Bool(ptr + 8, "resultCode" in x ? true : false);
    19          A.store.Int32(ptr + 0, x["resultCode"] === undefined ? 0 : (x["resultCode"] as number));
    20          A.store.Bool(ptr + 9, "socketId" in x ? true : false);
    21          A.store.Int32(ptr + 4, x["socketId"] === undefined ? 0 : (x["socketId"] as number));
    22        }
    23      },
    24      "load_AcceptInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    25        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    26  
    27        if (A.load.Bool(ptr + 8)) {
    28          x["resultCode"] = A.load.Int32(ptr + 0);
    29        } else {
    30          delete x["resultCode"];
    31        }
    32        if (A.load.Bool(ptr + 9)) {
    33          x["socketId"] = A.load.Int32(ptr + 4);
    34        } else {
    35          delete x["socketId"];
    36        }
    37        return create === A.H.TRUE ? A.H.push(x) : ref;
    38      },
    39  
    40      "store_CreateInfo": (ptr: Pointer, ref: heap.Ref<any>) => {
    41        const x = A.H.get<any>(ref);
    42  
    43        if (typeof x === "undefined") {
    44          A.store.Bool(ptr + 5, false);
    45          A.store.Bool(ptr + 4, false);
    46          A.store.Int32(ptr + 0, 0);
    47        } else {
    48          A.store.Bool(ptr + 5, true);
    49          A.store.Bool(ptr + 4, "socketId" in x ? true : false);
    50          A.store.Int32(ptr + 0, x["socketId"] === undefined ? 0 : (x["socketId"] as number));
    51        }
    52      },
    53      "load_CreateInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    54        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    55  
    56        if (A.load.Bool(ptr + 4)) {
    57          x["socketId"] = A.load.Int32(ptr + 0);
    58        } else {
    59          delete x["socketId"];
    60        }
    61        return create === A.H.TRUE ? A.H.push(x) : ref;
    62      },
    63  
    64      "store_CreateOptions": (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_CreateOptions": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    74        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    75  
    76        return create === A.H.TRUE ? A.H.push(x) : ref;
    77      },
    78      "constof_SocketType": (ref: heap.Ref<string>): number => {
    79        const idx = ["tcp", "udp"].indexOf(A.H.get(ref));
    80        return idx < 0 ? 0 : idx + 1;
    81      },
    82  
    83      "store_SocketInfo": (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 + 27, false);
    88          A.store.Enum(ptr + 0, -1);
    89          A.store.Bool(ptr + 24, false);
    90          A.store.Bool(ptr + 4, false);
    91          A.store.Ref(ptr + 8, undefined);
    92          A.store.Bool(ptr + 25, false);
    93          A.store.Int32(ptr + 12, 0);
    94          A.store.Ref(ptr + 16, undefined);
    95          A.store.Bool(ptr + 26, false);
    96          A.store.Int32(ptr + 20, 0);
    97        } else {
    98          A.store.Bool(ptr + 27, true);
    99          A.store.Enum(ptr + 0, ["tcp", "udp"].indexOf(x["socketType"] as string));
   100          A.store.Bool(ptr + 24, "connected" in x ? true : false);
   101          A.store.Bool(ptr + 4, x["connected"] ? true : false);
   102          A.store.Ref(ptr + 8, x["peerAddress"]);
   103          A.store.Bool(ptr + 25, "peerPort" in x ? true : false);
   104          A.store.Int32(ptr + 12, x["peerPort"] === undefined ? 0 : (x["peerPort"] as number));
   105          A.store.Ref(ptr + 16, x["localAddress"]);
   106          A.store.Bool(ptr + 26, "localPort" in x ? true : false);
   107          A.store.Int32(ptr + 20, x["localPort"] === undefined ? 0 : (x["localPort"] as number));
   108        }
   109      },
   110      "load_SocketInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   111        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   112  
   113        x["socketType"] = A.load.Enum(ptr + 0, ["tcp", "udp"]);
   114        if (A.load.Bool(ptr + 24)) {
   115          x["connected"] = A.load.Bool(ptr + 4);
   116        } else {
   117          delete x["connected"];
   118        }
   119        x["peerAddress"] = A.load.Ref(ptr + 8, undefined);
   120        if (A.load.Bool(ptr + 25)) {
   121          x["peerPort"] = A.load.Int32(ptr + 12);
   122        } else {
   123          delete x["peerPort"];
   124        }
   125        x["localAddress"] = A.load.Ref(ptr + 16, undefined);
   126        if (A.load.Bool(ptr + 26)) {
   127          x["localPort"] = A.load.Int32(ptr + 20);
   128        } else {
   129          delete x["localPort"];
   130        }
   131        return create === A.H.TRUE ? A.H.push(x) : ref;
   132      },
   133  
   134      "store_NetworkInterface": (ptr: Pointer, ref: heap.Ref<any>) => {
   135        const x = A.H.get<any>(ref);
   136  
   137        if (typeof x === "undefined") {
   138          A.store.Bool(ptr + 13, false);
   139          A.store.Ref(ptr + 0, undefined);
   140          A.store.Ref(ptr + 4, undefined);
   141          A.store.Bool(ptr + 12, false);
   142          A.store.Int32(ptr + 8, 0);
   143        } else {
   144          A.store.Bool(ptr + 13, true);
   145          A.store.Ref(ptr + 0, x["name"]);
   146          A.store.Ref(ptr + 4, x["address"]);
   147          A.store.Bool(ptr + 12, "prefixLength" in x ? true : false);
   148          A.store.Int32(ptr + 8, x["prefixLength"] === undefined ? 0 : (x["prefixLength"] as number));
   149        }
   150      },
   151      "load_NetworkInterface": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   152        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   153  
   154        x["name"] = A.load.Ref(ptr + 0, undefined);
   155        x["address"] = A.load.Ref(ptr + 4, undefined);
   156        if (A.load.Bool(ptr + 12)) {
   157          x["prefixLength"] = A.load.Int32(ptr + 8);
   158        } else {
   159          delete x["prefixLength"];
   160        }
   161        return create === A.H.TRUE ? A.H.push(x) : ref;
   162      },
   163  
   164      "store_ReadInfo": (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.Int32(ptr + 0, 0);
   171          A.store.Ref(ptr + 4, undefined);
   172        } else {
   173          A.store.Bool(ptr + 9, true);
   174          A.store.Bool(ptr + 8, "resultCode" in x ? true : false);
   175          A.store.Int32(ptr + 0, x["resultCode"] === undefined ? 0 : (x["resultCode"] as number));
   176          A.store.Ref(ptr + 4, x["data"]);
   177        }
   178      },
   179      "load_ReadInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   180        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   181  
   182        if (A.load.Bool(ptr + 8)) {
   183          x["resultCode"] = A.load.Int32(ptr + 0);
   184        } else {
   185          delete x["resultCode"];
   186        }
   187        x["data"] = A.load.Ref(ptr + 4, undefined);
   188        return create === A.H.TRUE ? A.H.push(x) : ref;
   189      },
   190  
   191      "store_RecvFromInfo": (ptr: Pointer, ref: heap.Ref<any>) => {
   192        const x = A.H.get<any>(ref);
   193  
   194        if (typeof x === "undefined") {
   195          A.store.Bool(ptr + 18, false);
   196          A.store.Bool(ptr + 16, false);
   197          A.store.Int32(ptr + 0, 0);
   198          A.store.Ref(ptr + 4, undefined);
   199          A.store.Ref(ptr + 8, undefined);
   200          A.store.Bool(ptr + 17, false);
   201          A.store.Int32(ptr + 12, 0);
   202        } else {
   203          A.store.Bool(ptr + 18, true);
   204          A.store.Bool(ptr + 16, "resultCode" in x ? true : false);
   205          A.store.Int32(ptr + 0, x["resultCode"] === undefined ? 0 : (x["resultCode"] as number));
   206          A.store.Ref(ptr + 4, x["data"]);
   207          A.store.Ref(ptr + 8, x["address"]);
   208          A.store.Bool(ptr + 17, "port" in x ? true : false);
   209          A.store.Int32(ptr + 12, x["port"] === undefined ? 0 : (x["port"] as number));
   210        }
   211      },
   212      "load_RecvFromInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   213        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   214  
   215        if (A.load.Bool(ptr + 16)) {
   216          x["resultCode"] = A.load.Int32(ptr + 0);
   217        } else {
   218          delete x["resultCode"];
   219        }
   220        x["data"] = A.load.Ref(ptr + 4, undefined);
   221        x["address"] = A.load.Ref(ptr + 8, undefined);
   222        if (A.load.Bool(ptr + 17)) {
   223          x["port"] = A.load.Int32(ptr + 12);
   224        } else {
   225          delete x["port"];
   226        }
   227        return create === A.H.TRUE ? A.H.push(x) : ref;
   228      },
   229  
   230      "store_TLSVersionConstraints": (ptr: Pointer, ref: heap.Ref<any>) => {
   231        const x = A.H.get<any>(ref);
   232  
   233        if (typeof x === "undefined") {
   234          A.store.Bool(ptr + 8, false);
   235          A.store.Ref(ptr + 0, undefined);
   236          A.store.Ref(ptr + 4, undefined);
   237        } else {
   238          A.store.Bool(ptr + 8, true);
   239          A.store.Ref(ptr + 0, x["min"]);
   240          A.store.Ref(ptr + 4, x["max"]);
   241        }
   242      },
   243      "load_TLSVersionConstraints": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   244        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   245  
   246        x["min"] = A.load.Ref(ptr + 0, undefined);
   247        x["max"] = A.load.Ref(ptr + 4, undefined);
   248        return create === A.H.TRUE ? A.H.push(x) : ref;
   249      },
   250  
   251      "store_SecureOptions": (ptr: Pointer, ref: heap.Ref<any>) => {
   252        const x = A.H.get<any>(ref);
   253  
   254        if (typeof x === "undefined") {
   255          A.store.Bool(ptr + 9, false);
   256  
   257          A.store.Bool(ptr + 0 + 8, false);
   258          A.store.Ref(ptr + 0 + 0, undefined);
   259          A.store.Ref(ptr + 0 + 4, undefined);
   260        } else {
   261          A.store.Bool(ptr + 9, true);
   262  
   263          if (typeof x["tlsVersion"] === "undefined") {
   264            A.store.Bool(ptr + 0 + 8, false);
   265            A.store.Ref(ptr + 0 + 0, undefined);
   266            A.store.Ref(ptr + 0 + 4, undefined);
   267          } else {
   268            A.store.Bool(ptr + 0 + 8, true);
   269            A.store.Ref(ptr + 0 + 0, x["tlsVersion"]["min"]);
   270            A.store.Ref(ptr + 0 + 4, x["tlsVersion"]["max"]);
   271          }
   272        }
   273      },
   274      "load_SecureOptions": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   275        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   276  
   277        if (A.load.Bool(ptr + 0 + 8)) {
   278          x["tlsVersion"] = {};
   279          x["tlsVersion"]["min"] = A.load.Ref(ptr + 0 + 0, undefined);
   280          x["tlsVersion"]["max"] = A.load.Ref(ptr + 0 + 4, undefined);
   281        } else {
   282          delete x["tlsVersion"];
   283        }
   284        return create === A.H.TRUE ? A.H.push(x) : ref;
   285      },
   286  
   287      "store_WriteInfo": (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.Bool(ptr + 4, false);
   293          A.store.Int32(ptr + 0, 0);
   294        } else {
   295          A.store.Bool(ptr + 5, true);
   296          A.store.Bool(ptr + 4, "bytesWritten" in x ? true : false);
   297          A.store.Int32(ptr + 0, x["bytesWritten"] === undefined ? 0 : (x["bytesWritten"] as number));
   298        }
   299      },
   300      "load_WriteInfo": (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        if (A.load.Bool(ptr + 4)) {
   304          x["bytesWritten"] = A.load.Int32(ptr + 0);
   305        } else {
   306          delete x["bytesWritten"];
   307        }
   308        return create === A.H.TRUE ? A.H.push(x) : ref;
   309      },
   310      "has_Accept": (): heap.Ref<boolean> => {
   311        if (WEBEXT?.socket && "accept" in WEBEXT?.socket) {
   312          return A.H.TRUE;
   313        }
   314        return A.H.FALSE;
   315      },
   316      "func_Accept": (fn: Pointer): void => {
   317        A.store.Ref(fn, WEBEXT.socket.accept);
   318      },
   319      "call_Accept": (retPtr: Pointer, socketId: number, callback: heap.Ref<object>): void => {
   320        const _ret = WEBEXT.socket.accept(socketId, A.H.get<object>(callback));
   321      },
   322      "try_Accept": (
   323        retPtr: Pointer,
   324        errPtr: Pointer,
   325        socketId: number,
   326        callback: heap.Ref<object>
   327      ): heap.Ref<boolean> => {
   328        try {
   329          const _ret = WEBEXT.socket.accept(socketId, A.H.get<object>(callback));
   330          return A.H.TRUE;
   331        } catch (err: any) {
   332          A.store.Ref(errPtr, err);
   333          return A.H.FALSE;
   334        }
   335      },
   336      "has_Bind": (): heap.Ref<boolean> => {
   337        if (WEBEXT?.socket && "bind" in WEBEXT?.socket) {
   338          return A.H.TRUE;
   339        }
   340        return A.H.FALSE;
   341      },
   342      "func_Bind": (fn: Pointer): void => {
   343        A.store.Ref(fn, WEBEXT.socket.bind);
   344      },
   345      "call_Bind": (
   346        retPtr: Pointer,
   347        socketId: number,
   348        address: heap.Ref<object>,
   349        port: number,
   350        callback: heap.Ref<object>
   351      ): void => {
   352        const _ret = WEBEXT.socket.bind(socketId, A.H.get<object>(address), port, A.H.get<object>(callback));
   353      },
   354      "try_Bind": (
   355        retPtr: Pointer,
   356        errPtr: Pointer,
   357        socketId: number,
   358        address: heap.Ref<object>,
   359        port: number,
   360        callback: heap.Ref<object>
   361      ): heap.Ref<boolean> => {
   362        try {
   363          const _ret = WEBEXT.socket.bind(socketId, A.H.get<object>(address), port, A.H.get<object>(callback));
   364          return A.H.TRUE;
   365        } catch (err: any) {
   366          A.store.Ref(errPtr, err);
   367          return A.H.FALSE;
   368        }
   369      },
   370      "has_Connect": (): heap.Ref<boolean> => {
   371        if (WEBEXT?.socket && "connect" in WEBEXT?.socket) {
   372          return A.H.TRUE;
   373        }
   374        return A.H.FALSE;
   375      },
   376      "func_Connect": (fn: Pointer): void => {
   377        A.store.Ref(fn, WEBEXT.socket.connect);
   378      },
   379      "call_Connect": (
   380        retPtr: Pointer,
   381        socketId: number,
   382        hostname: heap.Ref<object>,
   383        port: number,
   384        callback: heap.Ref<object>
   385      ): void => {
   386        const _ret = WEBEXT.socket.connect(socketId, A.H.get<object>(hostname), port, A.H.get<object>(callback));
   387      },
   388      "try_Connect": (
   389        retPtr: Pointer,
   390        errPtr: Pointer,
   391        socketId: number,
   392        hostname: heap.Ref<object>,
   393        port: number,
   394        callback: heap.Ref<object>
   395      ): heap.Ref<boolean> => {
   396        try {
   397          const _ret = WEBEXT.socket.connect(socketId, A.H.get<object>(hostname), port, A.H.get<object>(callback));
   398          return A.H.TRUE;
   399        } catch (err: any) {
   400          A.store.Ref(errPtr, err);
   401          return A.H.FALSE;
   402        }
   403      },
   404      "has_Create": (): heap.Ref<boolean> => {
   405        if (WEBEXT?.socket && "create" in WEBEXT?.socket) {
   406          return A.H.TRUE;
   407        }
   408        return A.H.FALSE;
   409      },
   410      "func_Create": (fn: Pointer): void => {
   411        A.store.Ref(fn, WEBEXT.socket.create);
   412      },
   413      "call_Create": (retPtr: Pointer, type: number, options: Pointer, callback: heap.Ref<object>): void => {
   414        const options_ffi = {};
   415  
   416        const _ret = WEBEXT.socket.create(
   417          type > 0 && type <= 2 ? ["tcp", "udp"][type - 1] : undefined,
   418          options_ffi,
   419          A.H.get<object>(callback)
   420        );
   421      },
   422      "try_Create": (
   423        retPtr: Pointer,
   424        errPtr: Pointer,
   425        type: number,
   426        options: Pointer,
   427        callback: heap.Ref<object>
   428      ): heap.Ref<boolean> => {
   429        try {
   430          const options_ffi = {};
   431  
   432          const _ret = WEBEXT.socket.create(
   433            type > 0 && type <= 2 ? ["tcp", "udp"][type - 1] : undefined,
   434            options_ffi,
   435            A.H.get<object>(callback)
   436          );
   437          return A.H.TRUE;
   438        } catch (err: any) {
   439          A.store.Ref(errPtr, err);
   440          return A.H.FALSE;
   441        }
   442      },
   443      "has_Destroy": (): heap.Ref<boolean> => {
   444        if (WEBEXT?.socket && "destroy" in WEBEXT?.socket) {
   445          return A.H.TRUE;
   446        }
   447        return A.H.FALSE;
   448      },
   449      "func_Destroy": (fn: Pointer): void => {
   450        A.store.Ref(fn, WEBEXT.socket.destroy);
   451      },
   452      "call_Destroy": (retPtr: Pointer, socketId: number): void => {
   453        const _ret = WEBEXT.socket.destroy(socketId);
   454      },
   455      "try_Destroy": (retPtr: Pointer, errPtr: Pointer, socketId: number): heap.Ref<boolean> => {
   456        try {
   457          const _ret = WEBEXT.socket.destroy(socketId);
   458          return A.H.TRUE;
   459        } catch (err: any) {
   460          A.store.Ref(errPtr, err);
   461          return A.H.FALSE;
   462        }
   463      },
   464      "has_Disconnect": (): heap.Ref<boolean> => {
   465        if (WEBEXT?.socket && "disconnect" in WEBEXT?.socket) {
   466          return A.H.TRUE;
   467        }
   468        return A.H.FALSE;
   469      },
   470      "func_Disconnect": (fn: Pointer): void => {
   471        A.store.Ref(fn, WEBEXT.socket.disconnect);
   472      },
   473      "call_Disconnect": (retPtr: Pointer, socketId: number): void => {
   474        const _ret = WEBEXT.socket.disconnect(socketId);
   475      },
   476      "try_Disconnect": (retPtr: Pointer, errPtr: Pointer, socketId: number): heap.Ref<boolean> => {
   477        try {
   478          const _ret = WEBEXT.socket.disconnect(socketId);
   479          return A.H.TRUE;
   480        } catch (err: any) {
   481          A.store.Ref(errPtr, err);
   482          return A.H.FALSE;
   483        }
   484      },
   485      "has_GetInfo": (): heap.Ref<boolean> => {
   486        if (WEBEXT?.socket && "getInfo" in WEBEXT?.socket) {
   487          return A.H.TRUE;
   488        }
   489        return A.H.FALSE;
   490      },
   491      "func_GetInfo": (fn: Pointer): void => {
   492        A.store.Ref(fn, WEBEXT.socket.getInfo);
   493      },
   494      "call_GetInfo": (retPtr: Pointer, socketId: number, callback: heap.Ref<object>): void => {
   495        const _ret = WEBEXT.socket.getInfo(socketId, A.H.get<object>(callback));
   496      },
   497      "try_GetInfo": (
   498        retPtr: Pointer,
   499        errPtr: Pointer,
   500        socketId: number,
   501        callback: heap.Ref<object>
   502      ): heap.Ref<boolean> => {
   503        try {
   504          const _ret = WEBEXT.socket.getInfo(socketId, A.H.get<object>(callback));
   505          return A.H.TRUE;
   506        } catch (err: any) {
   507          A.store.Ref(errPtr, err);
   508          return A.H.FALSE;
   509        }
   510      },
   511      "has_GetJoinedGroups": (): heap.Ref<boolean> => {
   512        if (WEBEXT?.socket && "getJoinedGroups" in WEBEXT?.socket) {
   513          return A.H.TRUE;
   514        }
   515        return A.H.FALSE;
   516      },
   517      "func_GetJoinedGroups": (fn: Pointer): void => {
   518        A.store.Ref(fn, WEBEXT.socket.getJoinedGroups);
   519      },
   520      "call_GetJoinedGroups": (retPtr: Pointer, socketId: number, callback: heap.Ref<object>): void => {
   521        const _ret = WEBEXT.socket.getJoinedGroups(socketId, A.H.get<object>(callback));
   522      },
   523      "try_GetJoinedGroups": (
   524        retPtr: Pointer,
   525        errPtr: Pointer,
   526        socketId: number,
   527        callback: heap.Ref<object>
   528      ): heap.Ref<boolean> => {
   529        try {
   530          const _ret = WEBEXT.socket.getJoinedGroups(socketId, A.H.get<object>(callback));
   531          return A.H.TRUE;
   532        } catch (err: any) {
   533          A.store.Ref(errPtr, err);
   534          return A.H.FALSE;
   535        }
   536      },
   537      "has_GetNetworkList": (): heap.Ref<boolean> => {
   538        if (WEBEXT?.socket && "getNetworkList" in WEBEXT?.socket) {
   539          return A.H.TRUE;
   540        }
   541        return A.H.FALSE;
   542      },
   543      "func_GetNetworkList": (fn: Pointer): void => {
   544        A.store.Ref(fn, WEBEXT.socket.getNetworkList);
   545      },
   546      "call_GetNetworkList": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   547        const _ret = WEBEXT.socket.getNetworkList(A.H.get<object>(callback));
   548      },
   549      "try_GetNetworkList": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   550        try {
   551          const _ret = WEBEXT.socket.getNetworkList(A.H.get<object>(callback));
   552          return A.H.TRUE;
   553        } catch (err: any) {
   554          A.store.Ref(errPtr, err);
   555          return A.H.FALSE;
   556        }
   557      },
   558      "has_JoinGroup": (): heap.Ref<boolean> => {
   559        if (WEBEXT?.socket && "joinGroup" in WEBEXT?.socket) {
   560          return A.H.TRUE;
   561        }
   562        return A.H.FALSE;
   563      },
   564      "func_JoinGroup": (fn: Pointer): void => {
   565        A.store.Ref(fn, WEBEXT.socket.joinGroup);
   566      },
   567      "call_JoinGroup": (
   568        retPtr: Pointer,
   569        socketId: number,
   570        address: heap.Ref<object>,
   571        callback: heap.Ref<object>
   572      ): void => {
   573        const _ret = WEBEXT.socket.joinGroup(socketId, A.H.get<object>(address), A.H.get<object>(callback));
   574      },
   575      "try_JoinGroup": (
   576        retPtr: Pointer,
   577        errPtr: Pointer,
   578        socketId: number,
   579        address: heap.Ref<object>,
   580        callback: heap.Ref<object>
   581      ): heap.Ref<boolean> => {
   582        try {
   583          const _ret = WEBEXT.socket.joinGroup(socketId, A.H.get<object>(address), A.H.get<object>(callback));
   584          return A.H.TRUE;
   585        } catch (err: any) {
   586          A.store.Ref(errPtr, err);
   587          return A.H.FALSE;
   588        }
   589      },
   590      "has_LeaveGroup": (): heap.Ref<boolean> => {
   591        if (WEBEXT?.socket && "leaveGroup" in WEBEXT?.socket) {
   592          return A.H.TRUE;
   593        }
   594        return A.H.FALSE;
   595      },
   596      "func_LeaveGroup": (fn: Pointer): void => {
   597        A.store.Ref(fn, WEBEXT.socket.leaveGroup);
   598      },
   599      "call_LeaveGroup": (
   600        retPtr: Pointer,
   601        socketId: number,
   602        address: heap.Ref<object>,
   603        callback: heap.Ref<object>
   604      ): void => {
   605        const _ret = WEBEXT.socket.leaveGroup(socketId, A.H.get<object>(address), A.H.get<object>(callback));
   606      },
   607      "try_LeaveGroup": (
   608        retPtr: Pointer,
   609        errPtr: Pointer,
   610        socketId: number,
   611        address: heap.Ref<object>,
   612        callback: heap.Ref<object>
   613      ): heap.Ref<boolean> => {
   614        try {
   615          const _ret = WEBEXT.socket.leaveGroup(socketId, A.H.get<object>(address), A.H.get<object>(callback));
   616          return A.H.TRUE;
   617        } catch (err: any) {
   618          A.store.Ref(errPtr, err);
   619          return A.H.FALSE;
   620        }
   621      },
   622      "has_Listen": (): heap.Ref<boolean> => {
   623        if (WEBEXT?.socket && "listen" in WEBEXT?.socket) {
   624          return A.H.TRUE;
   625        }
   626        return A.H.FALSE;
   627      },
   628      "func_Listen": (fn: Pointer): void => {
   629        A.store.Ref(fn, WEBEXT.socket.listen);
   630      },
   631      "call_Listen": (
   632        retPtr: Pointer,
   633        socketId: number,
   634        address: heap.Ref<object>,
   635        port: number,
   636        backlog: number,
   637        callback: heap.Ref<object>
   638      ): void => {
   639        const _ret = WEBEXT.socket.listen(socketId, A.H.get<object>(address), port, backlog, A.H.get<object>(callback));
   640      },
   641      "try_Listen": (
   642        retPtr: Pointer,
   643        errPtr: Pointer,
   644        socketId: number,
   645        address: heap.Ref<object>,
   646        port: number,
   647        backlog: number,
   648        callback: heap.Ref<object>
   649      ): heap.Ref<boolean> => {
   650        try {
   651          const _ret = WEBEXT.socket.listen(socketId, A.H.get<object>(address), port, backlog, A.H.get<object>(callback));
   652          return A.H.TRUE;
   653        } catch (err: any) {
   654          A.store.Ref(errPtr, err);
   655          return A.H.FALSE;
   656        }
   657      },
   658      "has_Read": (): heap.Ref<boolean> => {
   659        if (WEBEXT?.socket && "read" in WEBEXT?.socket) {
   660          return A.H.TRUE;
   661        }
   662        return A.H.FALSE;
   663      },
   664      "func_Read": (fn: Pointer): void => {
   665        A.store.Ref(fn, WEBEXT.socket.read);
   666      },
   667      "call_Read": (retPtr: Pointer, socketId: number, bufferSize: number, callback: heap.Ref<object>): void => {
   668        const _ret = WEBEXT.socket.read(socketId, bufferSize, A.H.get<object>(callback));
   669      },
   670      "try_Read": (
   671        retPtr: Pointer,
   672        errPtr: Pointer,
   673        socketId: number,
   674        bufferSize: number,
   675        callback: heap.Ref<object>
   676      ): heap.Ref<boolean> => {
   677        try {
   678          const _ret = WEBEXT.socket.read(socketId, bufferSize, A.H.get<object>(callback));
   679          return A.H.TRUE;
   680        } catch (err: any) {
   681          A.store.Ref(errPtr, err);
   682          return A.H.FALSE;
   683        }
   684      },
   685      "has_RecvFrom": (): heap.Ref<boolean> => {
   686        if (WEBEXT?.socket && "recvFrom" in WEBEXT?.socket) {
   687          return A.H.TRUE;
   688        }
   689        return A.H.FALSE;
   690      },
   691      "func_RecvFrom": (fn: Pointer): void => {
   692        A.store.Ref(fn, WEBEXT.socket.recvFrom);
   693      },
   694      "call_RecvFrom": (retPtr: Pointer, socketId: number, bufferSize: number, callback: heap.Ref<object>): void => {
   695        const _ret = WEBEXT.socket.recvFrom(socketId, bufferSize, A.H.get<object>(callback));
   696      },
   697      "try_RecvFrom": (
   698        retPtr: Pointer,
   699        errPtr: Pointer,
   700        socketId: number,
   701        bufferSize: number,
   702        callback: heap.Ref<object>
   703      ): heap.Ref<boolean> => {
   704        try {
   705          const _ret = WEBEXT.socket.recvFrom(socketId, bufferSize, A.H.get<object>(callback));
   706          return A.H.TRUE;
   707        } catch (err: any) {
   708          A.store.Ref(errPtr, err);
   709          return A.H.FALSE;
   710        }
   711      },
   712      "has_Secure": (): heap.Ref<boolean> => {
   713        if (WEBEXT?.socket && "secure" in WEBEXT?.socket) {
   714          return A.H.TRUE;
   715        }
   716        return A.H.FALSE;
   717      },
   718      "func_Secure": (fn: Pointer): void => {
   719        A.store.Ref(fn, WEBEXT.socket.secure);
   720      },
   721      "call_Secure": (retPtr: Pointer, socketId: number, options: Pointer, callback: heap.Ref<object>): void => {
   722        const options_ffi = {};
   723  
   724        if (A.load.Bool(options + 0 + 8)) {
   725          options_ffi["tlsVersion"] = {};
   726          options_ffi["tlsVersion"]["min"] = A.load.Ref(options + 0 + 0, undefined);
   727          options_ffi["tlsVersion"]["max"] = A.load.Ref(options + 0 + 4, undefined);
   728        }
   729  
   730        const _ret = WEBEXT.socket.secure(socketId, options_ffi, A.H.get<object>(callback));
   731      },
   732      "try_Secure": (
   733        retPtr: Pointer,
   734        errPtr: Pointer,
   735        socketId: number,
   736        options: Pointer,
   737        callback: heap.Ref<object>
   738      ): heap.Ref<boolean> => {
   739        try {
   740          const options_ffi = {};
   741  
   742          if (A.load.Bool(options + 0 + 8)) {
   743            options_ffi["tlsVersion"] = {};
   744            options_ffi["tlsVersion"]["min"] = A.load.Ref(options + 0 + 0, undefined);
   745            options_ffi["tlsVersion"]["max"] = A.load.Ref(options + 0 + 4, undefined);
   746          }
   747  
   748          const _ret = WEBEXT.socket.secure(socketId, options_ffi, A.H.get<object>(callback));
   749          return A.H.TRUE;
   750        } catch (err: any) {
   751          A.store.Ref(errPtr, err);
   752          return A.H.FALSE;
   753        }
   754      },
   755      "has_SendTo": (): heap.Ref<boolean> => {
   756        if (WEBEXT?.socket && "sendTo" in WEBEXT?.socket) {
   757          return A.H.TRUE;
   758        }
   759        return A.H.FALSE;
   760      },
   761      "func_SendTo": (fn: Pointer): void => {
   762        A.store.Ref(fn, WEBEXT.socket.sendTo);
   763      },
   764      "call_SendTo": (
   765        retPtr: Pointer,
   766        socketId: number,
   767        data: heap.Ref<object>,
   768        address: heap.Ref<object>,
   769        port: number,
   770        callback: heap.Ref<object>
   771      ): void => {
   772        const _ret = WEBEXT.socket.sendTo(
   773          socketId,
   774          A.H.get<object>(data),
   775          A.H.get<object>(address),
   776          port,
   777          A.H.get<object>(callback)
   778        );
   779      },
   780      "try_SendTo": (
   781        retPtr: Pointer,
   782        errPtr: Pointer,
   783        socketId: number,
   784        data: heap.Ref<object>,
   785        address: heap.Ref<object>,
   786        port: number,
   787        callback: heap.Ref<object>
   788      ): heap.Ref<boolean> => {
   789        try {
   790          const _ret = WEBEXT.socket.sendTo(
   791            socketId,
   792            A.H.get<object>(data),
   793            A.H.get<object>(address),
   794            port,
   795            A.H.get<object>(callback)
   796          );
   797          return A.H.TRUE;
   798        } catch (err: any) {
   799          A.store.Ref(errPtr, err);
   800          return A.H.FALSE;
   801        }
   802      },
   803      "has_SetKeepAlive": (): heap.Ref<boolean> => {
   804        if (WEBEXT?.socket && "setKeepAlive" in WEBEXT?.socket) {
   805          return A.H.TRUE;
   806        }
   807        return A.H.FALSE;
   808      },
   809      "func_SetKeepAlive": (fn: Pointer): void => {
   810        A.store.Ref(fn, WEBEXT.socket.setKeepAlive);
   811      },
   812      "call_SetKeepAlive": (
   813        retPtr: Pointer,
   814        socketId: number,
   815        enable: heap.Ref<boolean>,
   816        delay: number,
   817        callback: heap.Ref<object>
   818      ): void => {
   819        const _ret = WEBEXT.socket.setKeepAlive(socketId, enable === A.H.TRUE, delay, A.H.get<object>(callback));
   820      },
   821      "try_SetKeepAlive": (
   822        retPtr: Pointer,
   823        errPtr: Pointer,
   824        socketId: number,
   825        enable: heap.Ref<boolean>,
   826        delay: number,
   827        callback: heap.Ref<object>
   828      ): heap.Ref<boolean> => {
   829        try {
   830          const _ret = WEBEXT.socket.setKeepAlive(socketId, enable === A.H.TRUE, delay, A.H.get<object>(callback));
   831          return A.H.TRUE;
   832        } catch (err: any) {
   833          A.store.Ref(errPtr, err);
   834          return A.H.FALSE;
   835        }
   836      },
   837      "has_SetMulticastLoopbackMode": (): heap.Ref<boolean> => {
   838        if (WEBEXT?.socket && "setMulticastLoopbackMode" in WEBEXT?.socket) {
   839          return A.H.TRUE;
   840        }
   841        return A.H.FALSE;
   842      },
   843      "func_SetMulticastLoopbackMode": (fn: Pointer): void => {
   844        A.store.Ref(fn, WEBEXT.socket.setMulticastLoopbackMode);
   845      },
   846      "call_SetMulticastLoopbackMode": (
   847        retPtr: Pointer,
   848        socketId: number,
   849        enabled: heap.Ref<boolean>,
   850        callback: heap.Ref<object>
   851      ): void => {
   852        const _ret = WEBEXT.socket.setMulticastLoopbackMode(socketId, enabled === A.H.TRUE, A.H.get<object>(callback));
   853      },
   854      "try_SetMulticastLoopbackMode": (
   855        retPtr: Pointer,
   856        errPtr: Pointer,
   857        socketId: number,
   858        enabled: heap.Ref<boolean>,
   859        callback: heap.Ref<object>
   860      ): heap.Ref<boolean> => {
   861        try {
   862          const _ret = WEBEXT.socket.setMulticastLoopbackMode(socketId, enabled === A.H.TRUE, A.H.get<object>(callback));
   863          return A.H.TRUE;
   864        } catch (err: any) {
   865          A.store.Ref(errPtr, err);
   866          return A.H.FALSE;
   867        }
   868      },
   869      "has_SetMulticastTimeToLive": (): heap.Ref<boolean> => {
   870        if (WEBEXT?.socket && "setMulticastTimeToLive" in WEBEXT?.socket) {
   871          return A.H.TRUE;
   872        }
   873        return A.H.FALSE;
   874      },
   875      "func_SetMulticastTimeToLive": (fn: Pointer): void => {
   876        A.store.Ref(fn, WEBEXT.socket.setMulticastTimeToLive);
   877      },
   878      "call_SetMulticastTimeToLive": (
   879        retPtr: Pointer,
   880        socketId: number,
   881        ttl: number,
   882        callback: heap.Ref<object>
   883      ): void => {
   884        const _ret = WEBEXT.socket.setMulticastTimeToLive(socketId, ttl, A.H.get<object>(callback));
   885      },
   886      "try_SetMulticastTimeToLive": (
   887        retPtr: Pointer,
   888        errPtr: Pointer,
   889        socketId: number,
   890        ttl: number,
   891        callback: heap.Ref<object>
   892      ): heap.Ref<boolean> => {
   893        try {
   894          const _ret = WEBEXT.socket.setMulticastTimeToLive(socketId, ttl, A.H.get<object>(callback));
   895          return A.H.TRUE;
   896        } catch (err: any) {
   897          A.store.Ref(errPtr, err);
   898          return A.H.FALSE;
   899        }
   900      },
   901      "has_SetNoDelay": (): heap.Ref<boolean> => {
   902        if (WEBEXT?.socket && "setNoDelay" in WEBEXT?.socket) {
   903          return A.H.TRUE;
   904        }
   905        return A.H.FALSE;
   906      },
   907      "func_SetNoDelay": (fn: Pointer): void => {
   908        A.store.Ref(fn, WEBEXT.socket.setNoDelay);
   909      },
   910      "call_SetNoDelay": (
   911        retPtr: Pointer,
   912        socketId: number,
   913        noDelay: heap.Ref<boolean>,
   914        callback: heap.Ref<object>
   915      ): void => {
   916        const _ret = WEBEXT.socket.setNoDelay(socketId, noDelay === A.H.TRUE, A.H.get<object>(callback));
   917      },
   918      "try_SetNoDelay": (
   919        retPtr: Pointer,
   920        errPtr: Pointer,
   921        socketId: number,
   922        noDelay: heap.Ref<boolean>,
   923        callback: heap.Ref<object>
   924      ): heap.Ref<boolean> => {
   925        try {
   926          const _ret = WEBEXT.socket.setNoDelay(socketId, noDelay === A.H.TRUE, A.H.get<object>(callback));
   927          return A.H.TRUE;
   928        } catch (err: any) {
   929          A.store.Ref(errPtr, err);
   930          return A.H.FALSE;
   931        }
   932      },
   933      "has_Write": (): heap.Ref<boolean> => {
   934        if (WEBEXT?.socket && "write" in WEBEXT?.socket) {
   935          return A.H.TRUE;
   936        }
   937        return A.H.FALSE;
   938      },
   939      "func_Write": (fn: Pointer): void => {
   940        A.store.Ref(fn, WEBEXT.socket.write);
   941      },
   942      "call_Write": (retPtr: Pointer, socketId: number, data: heap.Ref<object>, callback: heap.Ref<object>): void => {
   943        const _ret = WEBEXT.socket.write(socketId, A.H.get<object>(data), A.H.get<object>(callback));
   944      },
   945      "try_Write": (
   946        retPtr: Pointer,
   947        errPtr: Pointer,
   948        socketId: number,
   949        data: heap.Ref<object>,
   950        callback: heap.Ref<object>
   951      ): heap.Ref<boolean> => {
   952        try {
   953          const _ret = WEBEXT.socket.write(socketId, A.H.get<object>(data), A.H.get<object>(callback));
   954          return A.H.TRUE;
   955        } catch (err: any) {
   956          A.store.Ref(errPtr, err);
   957          return A.H.FALSE;
   958        }
   959      },
   960    };
   961  });