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

     1  import { importModule, Application, heap, Pointer } from "@ffi";
     2  
     3  importModule("plat/js/webext/cookies", (A: Application) => {
     4    const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser;
     5  
     6    return {
     7      "constof_SameSiteStatus": (ref: heap.Ref<string>): number => {
     8        const idx = ["no_restriction", "lax", "strict", "unspecified"].indexOf(A.H.get(ref));
     9        return idx < 0 ? 0 : idx + 1;
    10      },
    11  
    12      "store_Cookie": (ptr: Pointer, ref: heap.Ref<any>) => {
    13        const x = A.H.get<any>(ref);
    14  
    15        if (typeof x === "undefined") {
    16          A.store.Bool(ptr + 45, false);
    17          A.store.Ref(ptr + 0, undefined);
    18          A.store.Bool(ptr + 44, false);
    19          A.store.Float64(ptr + 8, 0);
    20          A.store.Bool(ptr + 16, false);
    21          A.store.Bool(ptr + 17, false);
    22          A.store.Ref(ptr + 20, undefined);
    23          A.store.Ref(ptr + 24, undefined);
    24          A.store.Enum(ptr + 28, -1);
    25          A.store.Bool(ptr + 32, false);
    26          A.store.Bool(ptr + 33, false);
    27          A.store.Ref(ptr + 36, undefined);
    28          A.store.Ref(ptr + 40, undefined);
    29        } else {
    30          A.store.Bool(ptr + 45, true);
    31          A.store.Ref(ptr + 0, x["domain"]);
    32          A.store.Bool(ptr + 44, "expirationDate" in x ? true : false);
    33          A.store.Float64(ptr + 8, x["expirationDate"] === undefined ? 0 : (x["expirationDate"] as number));
    34          A.store.Bool(ptr + 16, x["hostOnly"] ? true : false);
    35          A.store.Bool(ptr + 17, x["httpOnly"] ? true : false);
    36          A.store.Ref(ptr + 20, x["name"]);
    37          A.store.Ref(ptr + 24, x["path"]);
    38          A.store.Enum(ptr + 28, ["no_restriction", "lax", "strict", "unspecified"].indexOf(x["sameSite"] as string));
    39          A.store.Bool(ptr + 32, x["secure"] ? true : false);
    40          A.store.Bool(ptr + 33, x["session"] ? true : false);
    41          A.store.Ref(ptr + 36, x["storeId"]);
    42          A.store.Ref(ptr + 40, x["value"]);
    43        }
    44      },
    45      "load_Cookie": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    46        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    47  
    48        x["domain"] = A.load.Ref(ptr + 0, undefined);
    49        if (A.load.Bool(ptr + 44)) {
    50          x["expirationDate"] = A.load.Float64(ptr + 8);
    51        } else {
    52          delete x["expirationDate"];
    53        }
    54        x["hostOnly"] = A.load.Bool(ptr + 16);
    55        x["httpOnly"] = A.load.Bool(ptr + 17);
    56        x["name"] = A.load.Ref(ptr + 20, undefined);
    57        x["path"] = A.load.Ref(ptr + 24, undefined);
    58        x["sameSite"] = A.load.Enum(ptr + 28, ["no_restriction", "lax", "strict", "unspecified"]);
    59        x["secure"] = A.load.Bool(ptr + 32);
    60        x["session"] = A.load.Bool(ptr + 33);
    61        x["storeId"] = A.load.Ref(ptr + 36, undefined);
    62        x["value"] = A.load.Ref(ptr + 40, undefined);
    63        return create === A.H.TRUE ? A.H.push(x) : ref;
    64      },
    65  
    66      "store_CookieDetails": (ptr: Pointer, ref: heap.Ref<any>) => {
    67        const x = A.H.get<any>(ref);
    68  
    69        if (typeof x === "undefined") {
    70          A.store.Bool(ptr + 12, false);
    71          A.store.Ref(ptr + 0, undefined);
    72          A.store.Ref(ptr + 4, undefined);
    73          A.store.Ref(ptr + 8, undefined);
    74        } else {
    75          A.store.Bool(ptr + 12, true);
    76          A.store.Ref(ptr + 0, x["name"]);
    77          A.store.Ref(ptr + 4, x["storeId"]);
    78          A.store.Ref(ptr + 8, x["url"]);
    79        }
    80      },
    81      "load_CookieDetails": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    82        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    83  
    84        x["name"] = A.load.Ref(ptr + 0, undefined);
    85        x["storeId"] = A.load.Ref(ptr + 4, undefined);
    86        x["url"] = A.load.Ref(ptr + 8, undefined);
    87        return create === A.H.TRUE ? A.H.push(x) : ref;
    88      },
    89  
    90      "store_CookieStore": (ptr: Pointer, ref: heap.Ref<any>) => {
    91        const x = A.H.get<any>(ref);
    92  
    93        if (typeof x === "undefined") {
    94          A.store.Bool(ptr + 8, false);
    95          A.store.Ref(ptr + 0, undefined);
    96          A.store.Ref(ptr + 4, undefined);
    97        } else {
    98          A.store.Bool(ptr + 8, true);
    99          A.store.Ref(ptr + 0, x["id"]);
   100          A.store.Ref(ptr + 4, x["tabIds"]);
   101        }
   102      },
   103      "load_CookieStore": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   104        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   105  
   106        x["id"] = A.load.Ref(ptr + 0, undefined);
   107        x["tabIds"] = A.load.Ref(ptr + 4, undefined);
   108        return create === A.H.TRUE ? A.H.push(x) : ref;
   109      },
   110  
   111      "store_GetAllArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => {
   112        const x = A.H.get<any>(ref);
   113  
   114        if (typeof x === "undefined") {
   115          A.store.Bool(ptr + 26, false);
   116          A.store.Ref(ptr + 0, undefined);
   117          A.store.Ref(ptr + 4, undefined);
   118          A.store.Ref(ptr + 8, undefined);
   119          A.store.Bool(ptr + 24, false);
   120          A.store.Bool(ptr + 12, false);
   121          A.store.Bool(ptr + 25, false);
   122          A.store.Bool(ptr + 13, false);
   123          A.store.Ref(ptr + 16, undefined);
   124          A.store.Ref(ptr + 20, undefined);
   125        } else {
   126          A.store.Bool(ptr + 26, true);
   127          A.store.Ref(ptr + 0, x["domain"]);
   128          A.store.Ref(ptr + 4, x["name"]);
   129          A.store.Ref(ptr + 8, x["path"]);
   130          A.store.Bool(ptr + 24, "secure" in x ? true : false);
   131          A.store.Bool(ptr + 12, x["secure"] ? true : false);
   132          A.store.Bool(ptr + 25, "session" in x ? true : false);
   133          A.store.Bool(ptr + 13, x["session"] ? true : false);
   134          A.store.Ref(ptr + 16, x["storeId"]);
   135          A.store.Ref(ptr + 20, x["url"]);
   136        }
   137      },
   138      "load_GetAllArgDetails": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   139        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   140  
   141        x["domain"] = A.load.Ref(ptr + 0, undefined);
   142        x["name"] = A.load.Ref(ptr + 4, undefined);
   143        x["path"] = A.load.Ref(ptr + 8, undefined);
   144        if (A.load.Bool(ptr + 24)) {
   145          x["secure"] = A.load.Bool(ptr + 12);
   146        } else {
   147          delete x["secure"];
   148        }
   149        if (A.load.Bool(ptr + 25)) {
   150          x["session"] = A.load.Bool(ptr + 13);
   151        } else {
   152          delete x["session"];
   153        }
   154        x["storeId"] = A.load.Ref(ptr + 16, undefined);
   155        x["url"] = A.load.Ref(ptr + 20, undefined);
   156        return create === A.H.TRUE ? A.H.push(x) : ref;
   157      },
   158      "constof_OnChangedCause": (ref: heap.Ref<string>): number => {
   159        const idx = ["evicted", "expired", "explicit", "expired_overwrite", "overwrite"].indexOf(A.H.get(ref));
   160        return idx < 0 ? 0 : idx + 1;
   161      },
   162  
   163      "store_OnChangedArgChangeInfo": (ptr: Pointer, ref: heap.Ref<any>) => {
   164        const x = A.H.get<any>(ref);
   165  
   166        if (typeof x === "undefined") {
   167          A.store.Bool(ptr + 55, false);
   168          A.store.Enum(ptr + 0, -1);
   169  
   170          A.store.Bool(ptr + 8 + 45, false);
   171          A.store.Ref(ptr + 8 + 0, undefined);
   172          A.store.Bool(ptr + 8 + 44, false);
   173          A.store.Float64(ptr + 8 + 8, 0);
   174          A.store.Bool(ptr + 8 + 16, false);
   175          A.store.Bool(ptr + 8 + 17, false);
   176          A.store.Ref(ptr + 8 + 20, undefined);
   177          A.store.Ref(ptr + 8 + 24, undefined);
   178          A.store.Enum(ptr + 8 + 28, -1);
   179          A.store.Bool(ptr + 8 + 32, false);
   180          A.store.Bool(ptr + 8 + 33, false);
   181          A.store.Ref(ptr + 8 + 36, undefined);
   182          A.store.Ref(ptr + 8 + 40, undefined);
   183          A.store.Bool(ptr + 54, false);
   184        } else {
   185          A.store.Bool(ptr + 55, true);
   186          A.store.Enum(
   187            ptr + 0,
   188            ["evicted", "expired", "explicit", "expired_overwrite", "overwrite"].indexOf(x["cause"] as string)
   189          );
   190  
   191          if (typeof x["cookie"] === "undefined") {
   192            A.store.Bool(ptr + 8 + 45, false);
   193            A.store.Ref(ptr + 8 + 0, undefined);
   194            A.store.Bool(ptr + 8 + 44, false);
   195            A.store.Float64(ptr + 8 + 8, 0);
   196            A.store.Bool(ptr + 8 + 16, false);
   197            A.store.Bool(ptr + 8 + 17, false);
   198            A.store.Ref(ptr + 8 + 20, undefined);
   199            A.store.Ref(ptr + 8 + 24, undefined);
   200            A.store.Enum(ptr + 8 + 28, -1);
   201            A.store.Bool(ptr + 8 + 32, false);
   202            A.store.Bool(ptr + 8 + 33, false);
   203            A.store.Ref(ptr + 8 + 36, undefined);
   204            A.store.Ref(ptr + 8 + 40, undefined);
   205          } else {
   206            A.store.Bool(ptr + 8 + 45, true);
   207            A.store.Ref(ptr + 8 + 0, x["cookie"]["domain"]);
   208            A.store.Bool(ptr + 8 + 44, "expirationDate" in x["cookie"] ? true : false);
   209            A.store.Float64(
   210              ptr + 8 + 8,
   211              x["cookie"]["expirationDate"] === undefined ? 0 : (x["cookie"]["expirationDate"] as number)
   212            );
   213            A.store.Bool(ptr + 8 + 16, x["cookie"]["hostOnly"] ? true : false);
   214            A.store.Bool(ptr + 8 + 17, x["cookie"]["httpOnly"] ? true : false);
   215            A.store.Ref(ptr + 8 + 20, x["cookie"]["name"]);
   216            A.store.Ref(ptr + 8 + 24, x["cookie"]["path"]);
   217            A.store.Enum(
   218              ptr + 8 + 28,
   219              ["no_restriction", "lax", "strict", "unspecified"].indexOf(x["cookie"]["sameSite"] as string)
   220            );
   221            A.store.Bool(ptr + 8 + 32, x["cookie"]["secure"] ? true : false);
   222            A.store.Bool(ptr + 8 + 33, x["cookie"]["session"] ? true : false);
   223            A.store.Ref(ptr + 8 + 36, x["cookie"]["storeId"]);
   224            A.store.Ref(ptr + 8 + 40, x["cookie"]["value"]);
   225          }
   226          A.store.Bool(ptr + 54, x["removed"] ? true : false);
   227        }
   228      },
   229      "load_OnChangedArgChangeInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   230        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   231  
   232        x["cause"] = A.load.Enum(ptr + 0, ["evicted", "expired", "explicit", "expired_overwrite", "overwrite"]);
   233        if (A.load.Bool(ptr + 8 + 45)) {
   234          x["cookie"] = {};
   235          x["cookie"]["domain"] = A.load.Ref(ptr + 8 + 0, undefined);
   236          if (A.load.Bool(ptr + 8 + 44)) {
   237            x["cookie"]["expirationDate"] = A.load.Float64(ptr + 8 + 8);
   238          } else {
   239            delete x["cookie"]["expirationDate"];
   240          }
   241          x["cookie"]["hostOnly"] = A.load.Bool(ptr + 8 + 16);
   242          x["cookie"]["httpOnly"] = A.load.Bool(ptr + 8 + 17);
   243          x["cookie"]["name"] = A.load.Ref(ptr + 8 + 20, undefined);
   244          x["cookie"]["path"] = A.load.Ref(ptr + 8 + 24, undefined);
   245          x["cookie"]["sameSite"] = A.load.Enum(ptr + 8 + 28, ["no_restriction", "lax", "strict", "unspecified"]);
   246          x["cookie"]["secure"] = A.load.Bool(ptr + 8 + 32);
   247          x["cookie"]["session"] = A.load.Bool(ptr + 8 + 33);
   248          x["cookie"]["storeId"] = A.load.Ref(ptr + 8 + 36, undefined);
   249          x["cookie"]["value"] = A.load.Ref(ptr + 8 + 40, undefined);
   250        } else {
   251          delete x["cookie"];
   252        }
   253        x["removed"] = A.load.Bool(ptr + 54);
   254        return create === A.H.TRUE ? A.H.push(x) : ref;
   255      },
   256  
   257      "store_RemoveReturnType": (ptr: Pointer, ref: heap.Ref<any>) => {
   258        const x = A.H.get<any>(ref);
   259  
   260        if (typeof x === "undefined") {
   261          A.store.Bool(ptr + 12, false);
   262          A.store.Ref(ptr + 0, undefined);
   263          A.store.Ref(ptr + 4, undefined);
   264          A.store.Ref(ptr + 8, undefined);
   265        } else {
   266          A.store.Bool(ptr + 12, true);
   267          A.store.Ref(ptr + 0, x["name"]);
   268          A.store.Ref(ptr + 4, x["storeId"]);
   269          A.store.Ref(ptr + 8, x["url"]);
   270        }
   271      },
   272      "load_RemoveReturnType": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   273        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   274  
   275        x["name"] = A.load.Ref(ptr + 0, undefined);
   276        x["storeId"] = A.load.Ref(ptr + 4, undefined);
   277        x["url"] = A.load.Ref(ptr + 8, undefined);
   278        return create === A.H.TRUE ? A.H.push(x) : ref;
   279      },
   280  
   281      "store_SetArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => {
   282        const x = A.H.get<any>(ref);
   283  
   284        if (typeof x === "undefined") {
   285          A.store.Bool(ptr + 51, false);
   286          A.store.Ref(ptr + 0, undefined);
   287          A.store.Bool(ptr + 48, false);
   288          A.store.Float64(ptr + 8, 0);
   289          A.store.Bool(ptr + 49, false);
   290          A.store.Bool(ptr + 16, false);
   291          A.store.Ref(ptr + 20, undefined);
   292          A.store.Ref(ptr + 24, undefined);
   293          A.store.Enum(ptr + 28, -1);
   294          A.store.Bool(ptr + 50, false);
   295          A.store.Bool(ptr + 32, false);
   296          A.store.Ref(ptr + 36, undefined);
   297          A.store.Ref(ptr + 40, undefined);
   298          A.store.Ref(ptr + 44, undefined);
   299        } else {
   300          A.store.Bool(ptr + 51, true);
   301          A.store.Ref(ptr + 0, x["domain"]);
   302          A.store.Bool(ptr + 48, "expirationDate" in x ? true : false);
   303          A.store.Float64(ptr + 8, x["expirationDate"] === undefined ? 0 : (x["expirationDate"] as number));
   304          A.store.Bool(ptr + 49, "httpOnly" in x ? true : false);
   305          A.store.Bool(ptr + 16, x["httpOnly"] ? true : false);
   306          A.store.Ref(ptr + 20, x["name"]);
   307          A.store.Ref(ptr + 24, x["path"]);
   308          A.store.Enum(ptr + 28, ["no_restriction", "lax", "strict", "unspecified"].indexOf(x["sameSite"] as string));
   309          A.store.Bool(ptr + 50, "secure" in x ? true : false);
   310          A.store.Bool(ptr + 32, x["secure"] ? true : false);
   311          A.store.Ref(ptr + 36, x["storeId"]);
   312          A.store.Ref(ptr + 40, x["url"]);
   313          A.store.Ref(ptr + 44, x["value"]);
   314        }
   315      },
   316      "load_SetArgDetails": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   317        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   318  
   319        x["domain"] = A.load.Ref(ptr + 0, undefined);
   320        if (A.load.Bool(ptr + 48)) {
   321          x["expirationDate"] = A.load.Float64(ptr + 8);
   322        } else {
   323          delete x["expirationDate"];
   324        }
   325        if (A.load.Bool(ptr + 49)) {
   326          x["httpOnly"] = A.load.Bool(ptr + 16);
   327        } else {
   328          delete x["httpOnly"];
   329        }
   330        x["name"] = A.load.Ref(ptr + 20, undefined);
   331        x["path"] = A.load.Ref(ptr + 24, undefined);
   332        x["sameSite"] = A.load.Enum(ptr + 28, ["no_restriction", "lax", "strict", "unspecified"]);
   333        if (A.load.Bool(ptr + 50)) {
   334          x["secure"] = A.load.Bool(ptr + 32);
   335        } else {
   336          delete x["secure"];
   337        }
   338        x["storeId"] = A.load.Ref(ptr + 36, undefined);
   339        x["url"] = A.load.Ref(ptr + 40, undefined);
   340        x["value"] = A.load.Ref(ptr + 44, undefined);
   341        return create === A.H.TRUE ? A.H.push(x) : ref;
   342      },
   343      "has_Get": (): heap.Ref<boolean> => {
   344        if (WEBEXT?.cookies && "get" in WEBEXT?.cookies) {
   345          return A.H.TRUE;
   346        }
   347        return A.H.FALSE;
   348      },
   349      "func_Get": (fn: Pointer): void => {
   350        A.store.Ref(fn, WEBEXT.cookies.get);
   351      },
   352      "call_Get": (retPtr: Pointer, details: Pointer): void => {
   353        const details_ffi = {};
   354  
   355        details_ffi["name"] = A.load.Ref(details + 0, undefined);
   356        details_ffi["storeId"] = A.load.Ref(details + 4, undefined);
   357        details_ffi["url"] = A.load.Ref(details + 8, undefined);
   358  
   359        const _ret = WEBEXT.cookies.get(details_ffi);
   360        A.store.Ref(retPtr, _ret);
   361      },
   362      "try_Get": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => {
   363        try {
   364          const details_ffi = {};
   365  
   366          details_ffi["name"] = A.load.Ref(details + 0, undefined);
   367          details_ffi["storeId"] = A.load.Ref(details + 4, undefined);
   368          details_ffi["url"] = A.load.Ref(details + 8, undefined);
   369  
   370          const _ret = WEBEXT.cookies.get(details_ffi);
   371          A.store.Ref(retPtr, _ret);
   372          return A.H.TRUE;
   373        } catch (err: any) {
   374          A.store.Ref(errPtr, err);
   375          return A.H.FALSE;
   376        }
   377      },
   378      "has_GetAll": (): heap.Ref<boolean> => {
   379        if (WEBEXT?.cookies && "getAll" in WEBEXT?.cookies) {
   380          return A.H.TRUE;
   381        }
   382        return A.H.FALSE;
   383      },
   384      "func_GetAll": (fn: Pointer): void => {
   385        A.store.Ref(fn, WEBEXT.cookies.getAll);
   386      },
   387      "call_GetAll": (retPtr: Pointer, details: Pointer): void => {
   388        const details_ffi = {};
   389  
   390        details_ffi["domain"] = A.load.Ref(details + 0, undefined);
   391        details_ffi["name"] = A.load.Ref(details + 4, undefined);
   392        details_ffi["path"] = A.load.Ref(details + 8, undefined);
   393        if (A.load.Bool(details + 24)) {
   394          details_ffi["secure"] = A.load.Bool(details + 12);
   395        }
   396        if (A.load.Bool(details + 25)) {
   397          details_ffi["session"] = A.load.Bool(details + 13);
   398        }
   399        details_ffi["storeId"] = A.load.Ref(details + 16, undefined);
   400        details_ffi["url"] = A.load.Ref(details + 20, undefined);
   401  
   402        const _ret = WEBEXT.cookies.getAll(details_ffi);
   403        A.store.Ref(retPtr, _ret);
   404      },
   405      "try_GetAll": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => {
   406        try {
   407          const details_ffi = {};
   408  
   409          details_ffi["domain"] = A.load.Ref(details + 0, undefined);
   410          details_ffi["name"] = A.load.Ref(details + 4, undefined);
   411          details_ffi["path"] = A.load.Ref(details + 8, undefined);
   412          if (A.load.Bool(details + 24)) {
   413            details_ffi["secure"] = A.load.Bool(details + 12);
   414          }
   415          if (A.load.Bool(details + 25)) {
   416            details_ffi["session"] = A.load.Bool(details + 13);
   417          }
   418          details_ffi["storeId"] = A.load.Ref(details + 16, undefined);
   419          details_ffi["url"] = A.load.Ref(details + 20, undefined);
   420  
   421          const _ret = WEBEXT.cookies.getAll(details_ffi);
   422          A.store.Ref(retPtr, _ret);
   423          return A.H.TRUE;
   424        } catch (err: any) {
   425          A.store.Ref(errPtr, err);
   426          return A.H.FALSE;
   427        }
   428      },
   429      "has_GetAllCookieStores": (): heap.Ref<boolean> => {
   430        if (WEBEXT?.cookies && "getAllCookieStores" in WEBEXT?.cookies) {
   431          return A.H.TRUE;
   432        }
   433        return A.H.FALSE;
   434      },
   435      "func_GetAllCookieStores": (fn: Pointer): void => {
   436        A.store.Ref(fn, WEBEXT.cookies.getAllCookieStores);
   437      },
   438      "call_GetAllCookieStores": (retPtr: Pointer): void => {
   439        const _ret = WEBEXT.cookies.getAllCookieStores();
   440        A.store.Ref(retPtr, _ret);
   441      },
   442      "try_GetAllCookieStores": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
   443        try {
   444          const _ret = WEBEXT.cookies.getAllCookieStores();
   445          A.store.Ref(retPtr, _ret);
   446          return A.H.TRUE;
   447        } catch (err: any) {
   448          A.store.Ref(errPtr, err);
   449          return A.H.FALSE;
   450        }
   451      },
   452      "has_OnChanged": (): heap.Ref<boolean> => {
   453        if (WEBEXT?.cookies?.onChanged && "addListener" in WEBEXT?.cookies?.onChanged) {
   454          return A.H.TRUE;
   455        }
   456        return A.H.FALSE;
   457      },
   458      "func_OnChanged": (fn: Pointer): void => {
   459        A.store.Ref(fn, WEBEXT.cookies.onChanged.addListener);
   460      },
   461      "call_OnChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   462        const _ret = WEBEXT.cookies.onChanged.addListener(A.H.get<object>(callback));
   463      },
   464      "try_OnChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   465        try {
   466          const _ret = WEBEXT.cookies.onChanged.addListener(A.H.get<object>(callback));
   467          return A.H.TRUE;
   468        } catch (err: any) {
   469          A.store.Ref(errPtr, err);
   470          return A.H.FALSE;
   471        }
   472      },
   473      "has_OffChanged": (): heap.Ref<boolean> => {
   474        if (WEBEXT?.cookies?.onChanged && "removeListener" in WEBEXT?.cookies?.onChanged) {
   475          return A.H.TRUE;
   476        }
   477        return A.H.FALSE;
   478      },
   479      "func_OffChanged": (fn: Pointer): void => {
   480        A.store.Ref(fn, WEBEXT.cookies.onChanged.removeListener);
   481      },
   482      "call_OffChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   483        const _ret = WEBEXT.cookies.onChanged.removeListener(A.H.get<object>(callback));
   484      },
   485      "try_OffChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   486        try {
   487          const _ret = WEBEXT.cookies.onChanged.removeListener(A.H.get<object>(callback));
   488          return A.H.TRUE;
   489        } catch (err: any) {
   490          A.store.Ref(errPtr, err);
   491          return A.H.FALSE;
   492        }
   493      },
   494      "has_HasOnChanged": (): heap.Ref<boolean> => {
   495        if (WEBEXT?.cookies?.onChanged && "hasListener" in WEBEXT?.cookies?.onChanged) {
   496          return A.H.TRUE;
   497        }
   498        return A.H.FALSE;
   499      },
   500      "func_HasOnChanged": (fn: Pointer): void => {
   501        A.store.Ref(fn, WEBEXT.cookies.onChanged.hasListener);
   502      },
   503      "call_HasOnChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   504        const _ret = WEBEXT.cookies.onChanged.hasListener(A.H.get<object>(callback));
   505        A.store.Bool(retPtr, _ret);
   506      },
   507      "try_HasOnChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   508        try {
   509          const _ret = WEBEXT.cookies.onChanged.hasListener(A.H.get<object>(callback));
   510          A.store.Bool(retPtr, _ret);
   511          return A.H.TRUE;
   512        } catch (err: any) {
   513          A.store.Ref(errPtr, err);
   514          return A.H.FALSE;
   515        }
   516      },
   517      "has_Remove": (): heap.Ref<boolean> => {
   518        if (WEBEXT?.cookies && "remove" in WEBEXT?.cookies) {
   519          return A.H.TRUE;
   520        }
   521        return A.H.FALSE;
   522      },
   523      "func_Remove": (fn: Pointer): void => {
   524        A.store.Ref(fn, WEBEXT.cookies.remove);
   525      },
   526      "call_Remove": (retPtr: Pointer, details: Pointer): void => {
   527        const details_ffi = {};
   528  
   529        details_ffi["name"] = A.load.Ref(details + 0, undefined);
   530        details_ffi["storeId"] = A.load.Ref(details + 4, undefined);
   531        details_ffi["url"] = A.load.Ref(details + 8, undefined);
   532  
   533        const _ret = WEBEXT.cookies.remove(details_ffi);
   534        A.store.Ref(retPtr, _ret);
   535      },
   536      "try_Remove": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => {
   537        try {
   538          const details_ffi = {};
   539  
   540          details_ffi["name"] = A.load.Ref(details + 0, undefined);
   541          details_ffi["storeId"] = A.load.Ref(details + 4, undefined);
   542          details_ffi["url"] = A.load.Ref(details + 8, undefined);
   543  
   544          const _ret = WEBEXT.cookies.remove(details_ffi);
   545          A.store.Ref(retPtr, _ret);
   546          return A.H.TRUE;
   547        } catch (err: any) {
   548          A.store.Ref(errPtr, err);
   549          return A.H.FALSE;
   550        }
   551      },
   552      "has_Set": (): heap.Ref<boolean> => {
   553        if (WEBEXT?.cookies && "set" in WEBEXT?.cookies) {
   554          return A.H.TRUE;
   555        }
   556        return A.H.FALSE;
   557      },
   558      "func_Set": (fn: Pointer): void => {
   559        A.store.Ref(fn, WEBEXT.cookies.set);
   560      },
   561      "call_Set": (retPtr: Pointer, details: Pointer): void => {
   562        const details_ffi = {};
   563  
   564        details_ffi["domain"] = A.load.Ref(details + 0, undefined);
   565        if (A.load.Bool(details + 48)) {
   566          details_ffi["expirationDate"] = A.load.Float64(details + 8);
   567        }
   568        if (A.load.Bool(details + 49)) {
   569          details_ffi["httpOnly"] = A.load.Bool(details + 16);
   570        }
   571        details_ffi["name"] = A.load.Ref(details + 20, undefined);
   572        details_ffi["path"] = A.load.Ref(details + 24, undefined);
   573        details_ffi["sameSite"] = A.load.Enum(details + 28, ["no_restriction", "lax", "strict", "unspecified"]);
   574        if (A.load.Bool(details + 50)) {
   575          details_ffi["secure"] = A.load.Bool(details + 32);
   576        }
   577        details_ffi["storeId"] = A.load.Ref(details + 36, undefined);
   578        details_ffi["url"] = A.load.Ref(details + 40, undefined);
   579        details_ffi["value"] = A.load.Ref(details + 44, undefined);
   580  
   581        const _ret = WEBEXT.cookies.set(details_ffi);
   582        A.store.Ref(retPtr, _ret);
   583      },
   584      "try_Set": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => {
   585        try {
   586          const details_ffi = {};
   587  
   588          details_ffi["domain"] = A.load.Ref(details + 0, undefined);
   589          if (A.load.Bool(details + 48)) {
   590            details_ffi["expirationDate"] = A.load.Float64(details + 8);
   591          }
   592          if (A.load.Bool(details + 49)) {
   593            details_ffi["httpOnly"] = A.load.Bool(details + 16);
   594          }
   595          details_ffi["name"] = A.load.Ref(details + 20, undefined);
   596          details_ffi["path"] = A.load.Ref(details + 24, undefined);
   597          details_ffi["sameSite"] = A.load.Enum(details + 28, ["no_restriction", "lax", "strict", "unspecified"]);
   598          if (A.load.Bool(details + 50)) {
   599            details_ffi["secure"] = A.load.Bool(details + 32);
   600          }
   601          details_ffi["storeId"] = A.load.Ref(details + 36, undefined);
   602          details_ffi["url"] = A.load.Ref(details + 40, undefined);
   603          details_ffi["value"] = A.load.Ref(details + 44, undefined);
   604  
   605          const _ret = WEBEXT.cookies.set(details_ffi);
   606          A.store.Ref(retPtr, _ret);
   607          return A.H.TRUE;
   608        } catch (err: any) {
   609          A.store.Ref(errPtr, err);
   610          return A.H.FALSE;
   611        }
   612      },
   613    };
   614  });