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

     1  import { importModule, Application, heap, Pointer } from "@ffi";
     2  
     3  importModule("plat/js/webext/scripting", (A: Application) => {
     4    const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser;
     5  
     6    return {
     7      "store_InjectionTarget": (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 + 15, false);
    12          A.store.Bool(ptr + 13, false);
    13          A.store.Int32(ptr + 0, 0);
    14          A.store.Ref(ptr + 4, undefined);
    15          A.store.Ref(ptr + 8, undefined);
    16          A.store.Bool(ptr + 14, false);
    17          A.store.Bool(ptr + 12, false);
    18        } else {
    19          A.store.Bool(ptr + 15, true);
    20          A.store.Bool(ptr + 13, "tabId" in x ? true : false);
    21          A.store.Int32(ptr + 0, x["tabId"] === undefined ? 0 : (x["tabId"] as number));
    22          A.store.Ref(ptr + 4, x["frameIds"]);
    23          A.store.Ref(ptr + 8, x["documentIds"]);
    24          A.store.Bool(ptr + 14, "allFrames" in x ? true : false);
    25          A.store.Bool(ptr + 12, x["allFrames"] ? true : false);
    26        }
    27      },
    28      "load_InjectionTarget": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    29        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    30  
    31        if (A.load.Bool(ptr + 13)) {
    32          x["tabId"] = A.load.Int32(ptr + 0);
    33        } else {
    34          delete x["tabId"];
    35        }
    36        x["frameIds"] = A.load.Ref(ptr + 4, undefined);
    37        x["documentIds"] = A.load.Ref(ptr + 8, undefined);
    38        if (A.load.Bool(ptr + 14)) {
    39          x["allFrames"] = A.load.Bool(ptr + 12);
    40        } else {
    41          delete x["allFrames"];
    42        }
    43        return create === A.H.TRUE ? A.H.push(x) : ref;
    44      },
    45      "constof_StyleOrigin": (ref: heap.Ref<string>): number => {
    46        const idx = ["AUTHOR", "USER"].indexOf(A.H.get(ref));
    47        return idx < 0 ? 0 : idx + 1;
    48      },
    49  
    50      "store_CSSInjection": (ptr: Pointer, ref: heap.Ref<any>) => {
    51        const x = A.H.get<any>(ref);
    52  
    53        if (typeof x === "undefined") {
    54          A.store.Bool(ptr + 28, false);
    55  
    56          A.store.Bool(ptr + 0 + 15, false);
    57          A.store.Bool(ptr + 0 + 13, false);
    58          A.store.Int32(ptr + 0 + 0, 0);
    59          A.store.Ref(ptr + 0 + 4, undefined);
    60          A.store.Ref(ptr + 0 + 8, undefined);
    61          A.store.Bool(ptr + 0 + 14, false);
    62          A.store.Bool(ptr + 0 + 12, false);
    63          A.store.Ref(ptr + 16, undefined);
    64          A.store.Ref(ptr + 20, undefined);
    65          A.store.Enum(ptr + 24, -1);
    66        } else {
    67          A.store.Bool(ptr + 28, true);
    68  
    69          if (typeof x["target"] === "undefined") {
    70            A.store.Bool(ptr + 0 + 15, false);
    71            A.store.Bool(ptr + 0 + 13, false);
    72            A.store.Int32(ptr + 0 + 0, 0);
    73            A.store.Ref(ptr + 0 + 4, undefined);
    74            A.store.Ref(ptr + 0 + 8, undefined);
    75            A.store.Bool(ptr + 0 + 14, false);
    76            A.store.Bool(ptr + 0 + 12, false);
    77          } else {
    78            A.store.Bool(ptr + 0 + 15, true);
    79            A.store.Bool(ptr + 0 + 13, "tabId" in x["target"] ? true : false);
    80            A.store.Int32(ptr + 0 + 0, x["target"]["tabId"] === undefined ? 0 : (x["target"]["tabId"] as number));
    81            A.store.Ref(ptr + 0 + 4, x["target"]["frameIds"]);
    82            A.store.Ref(ptr + 0 + 8, x["target"]["documentIds"]);
    83            A.store.Bool(ptr + 0 + 14, "allFrames" in x["target"] ? true : false);
    84            A.store.Bool(ptr + 0 + 12, x["target"]["allFrames"] ? true : false);
    85          }
    86          A.store.Ref(ptr + 16, x["css"]);
    87          A.store.Ref(ptr + 20, x["files"]);
    88          A.store.Enum(ptr + 24, ["AUTHOR", "USER"].indexOf(x["origin"] as string));
    89        }
    90      },
    91      "load_CSSInjection": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    92        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    93  
    94        if (A.load.Bool(ptr + 0 + 15)) {
    95          x["target"] = {};
    96          if (A.load.Bool(ptr + 0 + 13)) {
    97            x["target"]["tabId"] = A.load.Int32(ptr + 0 + 0);
    98          } else {
    99            delete x["target"]["tabId"];
   100          }
   101          x["target"]["frameIds"] = A.load.Ref(ptr + 0 + 4, undefined);
   102          x["target"]["documentIds"] = A.load.Ref(ptr + 0 + 8, undefined);
   103          if (A.load.Bool(ptr + 0 + 14)) {
   104            x["target"]["allFrames"] = A.load.Bool(ptr + 0 + 12);
   105          } else {
   106            delete x["target"]["allFrames"];
   107          }
   108        } else {
   109          delete x["target"];
   110        }
   111        x["css"] = A.load.Ref(ptr + 16, undefined);
   112        x["files"] = A.load.Ref(ptr + 20, undefined);
   113        x["origin"] = A.load.Enum(ptr + 24, ["AUTHOR", "USER"]);
   114        return create === A.H.TRUE ? A.H.push(x) : ref;
   115      },
   116  
   117      "store_ContentScriptFilter": (ptr: Pointer, ref: heap.Ref<any>) => {
   118        const x = A.H.get<any>(ref);
   119  
   120        if (typeof x === "undefined") {
   121          A.store.Bool(ptr + 4, false);
   122          A.store.Ref(ptr + 0, undefined);
   123        } else {
   124          A.store.Bool(ptr + 4, true);
   125          A.store.Ref(ptr + 0, x["ids"]);
   126        }
   127      },
   128      "load_ContentScriptFilter": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   129        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   130  
   131        x["ids"] = A.load.Ref(ptr + 0, undefined);
   132        return create === A.H.TRUE ? A.H.push(x) : ref;
   133      },
   134      "constof_ExecutionWorld": (ref: heap.Ref<string>): number => {
   135        const idx = ["ISOLATED", "MAIN"].indexOf(A.H.get(ref));
   136        return idx < 0 ? 0 : idx + 1;
   137      },
   138  
   139      "store_RegisteredContentScript": (ptr: Pointer, ref: heap.Ref<any>) => {
   140        const x = A.H.get<any>(ref);
   141  
   142        if (typeof x === "undefined") {
   143          A.store.Bool(ptr + 39, false);
   144          A.store.Ref(ptr + 0, undefined);
   145          A.store.Ref(ptr + 4, undefined);
   146          A.store.Ref(ptr + 8, undefined);
   147          A.store.Ref(ptr + 12, undefined);
   148          A.store.Ref(ptr + 16, undefined);
   149          A.store.Bool(ptr + 36, false);
   150          A.store.Bool(ptr + 20, false);
   151          A.store.Bool(ptr + 37, false);
   152          A.store.Bool(ptr + 21, false);
   153          A.store.Enum(ptr + 24, -1);
   154          A.store.Bool(ptr + 38, false);
   155          A.store.Bool(ptr + 28, false);
   156          A.store.Enum(ptr + 32, -1);
   157        } else {
   158          A.store.Bool(ptr + 39, true);
   159          A.store.Ref(ptr + 0, x["id"]);
   160          A.store.Ref(ptr + 4, x["matches"]);
   161          A.store.Ref(ptr + 8, x["excludeMatches"]);
   162          A.store.Ref(ptr + 12, x["css"]);
   163          A.store.Ref(ptr + 16, x["js"]);
   164          A.store.Bool(ptr + 36, "allFrames" in x ? true : false);
   165          A.store.Bool(ptr + 20, x["allFrames"] ? true : false);
   166          A.store.Bool(ptr + 37, "matchOriginAsFallback" in x ? true : false);
   167          A.store.Bool(ptr + 21, x["matchOriginAsFallback"] ? true : false);
   168          A.store.Enum(ptr + 24, ["document_start", "document_end", "document_idle"].indexOf(x["runAt"] as string));
   169          A.store.Bool(ptr + 38, "persistAcrossSessions" in x ? true : false);
   170          A.store.Bool(ptr + 28, x["persistAcrossSessions"] ? true : false);
   171          A.store.Enum(ptr + 32, ["ISOLATED", "MAIN"].indexOf(x["world"] as string));
   172        }
   173      },
   174      "load_RegisteredContentScript": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   175        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   176  
   177        x["id"] = A.load.Ref(ptr + 0, undefined);
   178        x["matches"] = A.load.Ref(ptr + 4, undefined);
   179        x["excludeMatches"] = A.load.Ref(ptr + 8, undefined);
   180        x["css"] = A.load.Ref(ptr + 12, undefined);
   181        x["js"] = A.load.Ref(ptr + 16, undefined);
   182        if (A.load.Bool(ptr + 36)) {
   183          x["allFrames"] = A.load.Bool(ptr + 20);
   184        } else {
   185          delete x["allFrames"];
   186        }
   187        if (A.load.Bool(ptr + 37)) {
   188          x["matchOriginAsFallback"] = A.load.Bool(ptr + 21);
   189        } else {
   190          delete x["matchOriginAsFallback"];
   191        }
   192        x["runAt"] = A.load.Enum(ptr + 24, ["document_start", "document_end", "document_idle"]);
   193        if (A.load.Bool(ptr + 38)) {
   194          x["persistAcrossSessions"] = A.load.Bool(ptr + 28);
   195        } else {
   196          delete x["persistAcrossSessions"];
   197        }
   198        x["world"] = A.load.Enum(ptr + 32, ["ISOLATED", "MAIN"]);
   199        return create === A.H.TRUE ? A.H.push(x) : ref;
   200      },
   201  
   202      "store_InjectionResult": (ptr: Pointer, ref: heap.Ref<any>) => {
   203        const x = A.H.get<any>(ref);
   204  
   205        if (typeof x === "undefined") {
   206          A.store.Bool(ptr + 13, false);
   207          A.store.Ref(ptr + 0, undefined);
   208          A.store.Bool(ptr + 12, false);
   209          A.store.Int32(ptr + 4, 0);
   210          A.store.Ref(ptr + 8, undefined);
   211        } else {
   212          A.store.Bool(ptr + 13, true);
   213          A.store.Ref(ptr + 0, x["result"]);
   214          A.store.Bool(ptr + 12, "frameId" in x ? true : false);
   215          A.store.Int32(ptr + 4, x["frameId"] === undefined ? 0 : (x["frameId"] as number));
   216          A.store.Ref(ptr + 8, x["documentId"]);
   217        }
   218      },
   219      "load_InjectionResult": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   220        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   221  
   222        x["result"] = A.load.Ref(ptr + 0, undefined);
   223        if (A.load.Bool(ptr + 12)) {
   224          x["frameId"] = A.load.Int32(ptr + 4);
   225        } else {
   226          delete x["frameId"];
   227        }
   228        x["documentId"] = A.load.Ref(ptr + 8, undefined);
   229        return create === A.H.TRUE ? A.H.push(x) : ref;
   230      },
   231  
   232      "has_Properties_GlobalParams": (self: heap.Ref<any>): heap.Ref<boolean> => {
   233        if (WEBEXT?.scripting && "globalParams" in WEBEXT?.scripting) {
   234          return A.H.TRUE;
   235        }
   236        return A.H.FALSE;
   237      },
   238      "func_Properties_GlobalParams": (self: heap.Ref<any>, fn: Pointer): void => {
   239        A.store.Ref(fn, WEBEXT.scripting.globalParams);
   240      },
   241  
   242      "call_Properties_GlobalParams": (self: heap.Ref<object>, retPtr: Pointer): void => {
   243        const thiz = A.H.get<any>(self);
   244  
   245        const _ret = Reflect.apply(WEBEXT.scripting.globalParams, thiz, []);
   246        A.store.Int32(retPtr, _ret);
   247      },
   248      "try_Properties_GlobalParams": (self: heap.Ref<object>, retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
   249        try {
   250          const thiz = A.H.get<any>(self);
   251  
   252          const _ret = Reflect.apply(WEBEXT.scripting.globalParams, thiz, []);
   253          A.store.Int32(retPtr, _ret);
   254          return A.H.TRUE;
   255        } catch (err: any) {
   256          A.store.Ref(errPtr, err);
   257          return A.H.FALSE;
   258        }
   259      },
   260  
   261      "store_ScriptInjection": (ptr: Pointer, ref: heap.Ref<any>) => {
   262        const x = A.H.get<any>(ref);
   263  
   264        if (typeof x === "undefined") {
   265          A.store.Bool(ptr + 38, false);
   266          A.store.Ref(ptr + 0, undefined);
   267          A.store.Ref(ptr + 4, undefined);
   268          A.store.Ref(ptr + 8, undefined);
   269          A.store.Ref(ptr + 12, undefined);
   270  
   271          A.store.Bool(ptr + 16 + 15, false);
   272          A.store.Bool(ptr + 16 + 13, false);
   273          A.store.Int32(ptr + 16 + 0, 0);
   274          A.store.Ref(ptr + 16 + 4, undefined);
   275          A.store.Ref(ptr + 16 + 8, undefined);
   276          A.store.Bool(ptr + 16 + 14, false);
   277          A.store.Bool(ptr + 16 + 12, false);
   278          A.store.Enum(ptr + 32, -1);
   279          A.store.Bool(ptr + 37, false);
   280          A.store.Bool(ptr + 36, false);
   281        } else {
   282          A.store.Bool(ptr + 38, true);
   283          A.store.Ref(ptr + 0, x["func"]);
   284          A.store.Ref(ptr + 4, x["args"]);
   285          A.store.Ref(ptr + 8, x["function"]);
   286          A.store.Ref(ptr + 12, x["files"]);
   287  
   288          if (typeof x["target"] === "undefined") {
   289            A.store.Bool(ptr + 16 + 15, false);
   290            A.store.Bool(ptr + 16 + 13, false);
   291            A.store.Int32(ptr + 16 + 0, 0);
   292            A.store.Ref(ptr + 16 + 4, undefined);
   293            A.store.Ref(ptr + 16 + 8, undefined);
   294            A.store.Bool(ptr + 16 + 14, false);
   295            A.store.Bool(ptr + 16 + 12, false);
   296          } else {
   297            A.store.Bool(ptr + 16 + 15, true);
   298            A.store.Bool(ptr + 16 + 13, "tabId" in x["target"] ? true : false);
   299            A.store.Int32(ptr + 16 + 0, x["target"]["tabId"] === undefined ? 0 : (x["target"]["tabId"] as number));
   300            A.store.Ref(ptr + 16 + 4, x["target"]["frameIds"]);
   301            A.store.Ref(ptr + 16 + 8, x["target"]["documentIds"]);
   302            A.store.Bool(ptr + 16 + 14, "allFrames" in x["target"] ? true : false);
   303            A.store.Bool(ptr + 16 + 12, x["target"]["allFrames"] ? true : false);
   304          }
   305          A.store.Enum(ptr + 32, ["ISOLATED", "MAIN"].indexOf(x["world"] as string));
   306          A.store.Bool(ptr + 37, "injectImmediately" in x ? true : false);
   307          A.store.Bool(ptr + 36, x["injectImmediately"] ? true : false);
   308        }
   309      },
   310      "load_ScriptInjection": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   311        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   312  
   313        x["func"] = A.load.Ref(ptr + 0, undefined);
   314        x["args"] = A.load.Ref(ptr + 4, undefined);
   315        x["function"] = A.load.Ref(ptr + 8, undefined);
   316        x["files"] = A.load.Ref(ptr + 12, undefined);
   317        if (A.load.Bool(ptr + 16 + 15)) {
   318          x["target"] = {};
   319          if (A.load.Bool(ptr + 16 + 13)) {
   320            x["target"]["tabId"] = A.load.Int32(ptr + 16 + 0);
   321          } else {
   322            delete x["target"]["tabId"];
   323          }
   324          x["target"]["frameIds"] = A.load.Ref(ptr + 16 + 4, undefined);
   325          x["target"]["documentIds"] = A.load.Ref(ptr + 16 + 8, undefined);
   326          if (A.load.Bool(ptr + 16 + 14)) {
   327            x["target"]["allFrames"] = A.load.Bool(ptr + 16 + 12);
   328          } else {
   329            delete x["target"]["allFrames"];
   330          }
   331        } else {
   332          delete x["target"];
   333        }
   334        x["world"] = A.load.Enum(ptr + 32, ["ISOLATED", "MAIN"]);
   335        if (A.load.Bool(ptr + 37)) {
   336          x["injectImmediately"] = A.load.Bool(ptr + 36);
   337        } else {
   338          delete x["injectImmediately"];
   339        }
   340        return create === A.H.TRUE ? A.H.push(x) : ref;
   341      },
   342      "has_ExecuteScript": (): heap.Ref<boolean> => {
   343        if (WEBEXT?.scripting && "executeScript" in WEBEXT?.scripting) {
   344          return A.H.TRUE;
   345        }
   346        return A.H.FALSE;
   347      },
   348      "func_ExecuteScript": (fn: Pointer): void => {
   349        A.store.Ref(fn, WEBEXT.scripting.executeScript);
   350      },
   351      "call_ExecuteScript": (retPtr: Pointer, injection: Pointer): void => {
   352        const injection_ffi = {};
   353  
   354        injection_ffi["func"] = A.load.Ref(injection + 0, undefined);
   355        injection_ffi["args"] = A.load.Ref(injection + 4, undefined);
   356        injection_ffi["function"] = A.load.Ref(injection + 8, undefined);
   357        injection_ffi["files"] = A.load.Ref(injection + 12, undefined);
   358        if (A.load.Bool(injection + 16 + 15)) {
   359          injection_ffi["target"] = {};
   360          if (A.load.Bool(injection + 16 + 13)) {
   361            injection_ffi["target"]["tabId"] = A.load.Int32(injection + 16 + 0);
   362          }
   363          injection_ffi["target"]["frameIds"] = A.load.Ref(injection + 16 + 4, undefined);
   364          injection_ffi["target"]["documentIds"] = A.load.Ref(injection + 16 + 8, undefined);
   365          if (A.load.Bool(injection + 16 + 14)) {
   366            injection_ffi["target"]["allFrames"] = A.load.Bool(injection + 16 + 12);
   367          }
   368        }
   369        injection_ffi["world"] = A.load.Enum(injection + 32, ["ISOLATED", "MAIN"]);
   370        if (A.load.Bool(injection + 37)) {
   371          injection_ffi["injectImmediately"] = A.load.Bool(injection + 36);
   372        }
   373  
   374        const _ret = WEBEXT.scripting.executeScript(injection_ffi);
   375        A.store.Ref(retPtr, _ret);
   376      },
   377      "try_ExecuteScript": (retPtr: Pointer, errPtr: Pointer, injection: Pointer): heap.Ref<boolean> => {
   378        try {
   379          const injection_ffi = {};
   380  
   381          injection_ffi["func"] = A.load.Ref(injection + 0, undefined);
   382          injection_ffi["args"] = A.load.Ref(injection + 4, undefined);
   383          injection_ffi["function"] = A.load.Ref(injection + 8, undefined);
   384          injection_ffi["files"] = A.load.Ref(injection + 12, undefined);
   385          if (A.load.Bool(injection + 16 + 15)) {
   386            injection_ffi["target"] = {};
   387            if (A.load.Bool(injection + 16 + 13)) {
   388              injection_ffi["target"]["tabId"] = A.load.Int32(injection + 16 + 0);
   389            }
   390            injection_ffi["target"]["frameIds"] = A.load.Ref(injection + 16 + 4, undefined);
   391            injection_ffi["target"]["documentIds"] = A.load.Ref(injection + 16 + 8, undefined);
   392            if (A.load.Bool(injection + 16 + 14)) {
   393              injection_ffi["target"]["allFrames"] = A.load.Bool(injection + 16 + 12);
   394            }
   395          }
   396          injection_ffi["world"] = A.load.Enum(injection + 32, ["ISOLATED", "MAIN"]);
   397          if (A.load.Bool(injection + 37)) {
   398            injection_ffi["injectImmediately"] = A.load.Bool(injection + 36);
   399          }
   400  
   401          const _ret = WEBEXT.scripting.executeScript(injection_ffi);
   402          A.store.Ref(retPtr, _ret);
   403          return A.H.TRUE;
   404        } catch (err: any) {
   405          A.store.Ref(errPtr, err);
   406          return A.H.FALSE;
   407        }
   408      },
   409      "has_GetRegisteredContentScripts": (): heap.Ref<boolean> => {
   410        if (WEBEXT?.scripting && "getRegisteredContentScripts" in WEBEXT?.scripting) {
   411          return A.H.TRUE;
   412        }
   413        return A.H.FALSE;
   414      },
   415      "func_GetRegisteredContentScripts": (fn: Pointer): void => {
   416        A.store.Ref(fn, WEBEXT.scripting.getRegisteredContentScripts);
   417      },
   418      "call_GetRegisteredContentScripts": (retPtr: Pointer, filter: Pointer): void => {
   419        const filter_ffi = {};
   420  
   421        filter_ffi["ids"] = A.load.Ref(filter + 0, undefined);
   422  
   423        const _ret = WEBEXT.scripting.getRegisteredContentScripts(filter_ffi);
   424        A.store.Ref(retPtr, _ret);
   425      },
   426      "try_GetRegisteredContentScripts": (retPtr: Pointer, errPtr: Pointer, filter: Pointer): heap.Ref<boolean> => {
   427        try {
   428          const filter_ffi = {};
   429  
   430          filter_ffi["ids"] = A.load.Ref(filter + 0, undefined);
   431  
   432          const _ret = WEBEXT.scripting.getRegisteredContentScripts(filter_ffi);
   433          A.store.Ref(retPtr, _ret);
   434          return A.H.TRUE;
   435        } catch (err: any) {
   436          A.store.Ref(errPtr, err);
   437          return A.H.FALSE;
   438        }
   439      },
   440      "has_InsertCSS": (): heap.Ref<boolean> => {
   441        if (WEBEXT?.scripting && "insertCSS" in WEBEXT?.scripting) {
   442          return A.H.TRUE;
   443        }
   444        return A.H.FALSE;
   445      },
   446      "func_InsertCSS": (fn: Pointer): void => {
   447        A.store.Ref(fn, WEBEXT.scripting.insertCSS);
   448      },
   449      "call_InsertCSS": (retPtr: Pointer, injection: Pointer): void => {
   450        const injection_ffi = {};
   451  
   452        if (A.load.Bool(injection + 0 + 15)) {
   453          injection_ffi["target"] = {};
   454          if (A.load.Bool(injection + 0 + 13)) {
   455            injection_ffi["target"]["tabId"] = A.load.Int32(injection + 0 + 0);
   456          }
   457          injection_ffi["target"]["frameIds"] = A.load.Ref(injection + 0 + 4, undefined);
   458          injection_ffi["target"]["documentIds"] = A.load.Ref(injection + 0 + 8, undefined);
   459          if (A.load.Bool(injection + 0 + 14)) {
   460            injection_ffi["target"]["allFrames"] = A.load.Bool(injection + 0 + 12);
   461          }
   462        }
   463        injection_ffi["css"] = A.load.Ref(injection + 16, undefined);
   464        injection_ffi["files"] = A.load.Ref(injection + 20, undefined);
   465        injection_ffi["origin"] = A.load.Enum(injection + 24, ["AUTHOR", "USER"]);
   466  
   467        const _ret = WEBEXT.scripting.insertCSS(injection_ffi);
   468        A.store.Ref(retPtr, _ret);
   469      },
   470      "try_InsertCSS": (retPtr: Pointer, errPtr: Pointer, injection: Pointer): heap.Ref<boolean> => {
   471        try {
   472          const injection_ffi = {};
   473  
   474          if (A.load.Bool(injection + 0 + 15)) {
   475            injection_ffi["target"] = {};
   476            if (A.load.Bool(injection + 0 + 13)) {
   477              injection_ffi["target"]["tabId"] = A.load.Int32(injection + 0 + 0);
   478            }
   479            injection_ffi["target"]["frameIds"] = A.load.Ref(injection + 0 + 4, undefined);
   480            injection_ffi["target"]["documentIds"] = A.load.Ref(injection + 0 + 8, undefined);
   481            if (A.load.Bool(injection + 0 + 14)) {
   482              injection_ffi["target"]["allFrames"] = A.load.Bool(injection + 0 + 12);
   483            }
   484          }
   485          injection_ffi["css"] = A.load.Ref(injection + 16, undefined);
   486          injection_ffi["files"] = A.load.Ref(injection + 20, undefined);
   487          injection_ffi["origin"] = A.load.Enum(injection + 24, ["AUTHOR", "USER"]);
   488  
   489          const _ret = WEBEXT.scripting.insertCSS(injection_ffi);
   490          A.store.Ref(retPtr, _ret);
   491          return A.H.TRUE;
   492        } catch (err: any) {
   493          A.store.Ref(errPtr, err);
   494          return A.H.FALSE;
   495        }
   496      },
   497      "has_RegisterContentScripts": (): heap.Ref<boolean> => {
   498        if (WEBEXT?.scripting && "registerContentScripts" in WEBEXT?.scripting) {
   499          return A.H.TRUE;
   500        }
   501        return A.H.FALSE;
   502      },
   503      "func_RegisterContentScripts": (fn: Pointer): void => {
   504        A.store.Ref(fn, WEBEXT.scripting.registerContentScripts);
   505      },
   506      "call_RegisterContentScripts": (retPtr: Pointer, scripts: heap.Ref<object>): void => {
   507        const _ret = WEBEXT.scripting.registerContentScripts(A.H.get<object>(scripts));
   508        A.store.Ref(retPtr, _ret);
   509      },
   510      "try_RegisterContentScripts": (retPtr: Pointer, errPtr: Pointer, scripts: heap.Ref<object>): heap.Ref<boolean> => {
   511        try {
   512          const _ret = WEBEXT.scripting.registerContentScripts(A.H.get<object>(scripts));
   513          A.store.Ref(retPtr, _ret);
   514          return A.H.TRUE;
   515        } catch (err: any) {
   516          A.store.Ref(errPtr, err);
   517          return A.H.FALSE;
   518        }
   519      },
   520      "has_RemoveCSS": (): heap.Ref<boolean> => {
   521        if (WEBEXT?.scripting && "removeCSS" in WEBEXT?.scripting) {
   522          return A.H.TRUE;
   523        }
   524        return A.H.FALSE;
   525      },
   526      "func_RemoveCSS": (fn: Pointer): void => {
   527        A.store.Ref(fn, WEBEXT.scripting.removeCSS);
   528      },
   529      "call_RemoveCSS": (retPtr: Pointer, injection: Pointer): void => {
   530        const injection_ffi = {};
   531  
   532        if (A.load.Bool(injection + 0 + 15)) {
   533          injection_ffi["target"] = {};
   534          if (A.load.Bool(injection + 0 + 13)) {
   535            injection_ffi["target"]["tabId"] = A.load.Int32(injection + 0 + 0);
   536          }
   537          injection_ffi["target"]["frameIds"] = A.load.Ref(injection + 0 + 4, undefined);
   538          injection_ffi["target"]["documentIds"] = A.load.Ref(injection + 0 + 8, undefined);
   539          if (A.load.Bool(injection + 0 + 14)) {
   540            injection_ffi["target"]["allFrames"] = A.load.Bool(injection + 0 + 12);
   541          }
   542        }
   543        injection_ffi["css"] = A.load.Ref(injection + 16, undefined);
   544        injection_ffi["files"] = A.load.Ref(injection + 20, undefined);
   545        injection_ffi["origin"] = A.load.Enum(injection + 24, ["AUTHOR", "USER"]);
   546  
   547        const _ret = WEBEXT.scripting.removeCSS(injection_ffi);
   548        A.store.Ref(retPtr, _ret);
   549      },
   550      "try_RemoveCSS": (retPtr: Pointer, errPtr: Pointer, injection: Pointer): heap.Ref<boolean> => {
   551        try {
   552          const injection_ffi = {};
   553  
   554          if (A.load.Bool(injection + 0 + 15)) {
   555            injection_ffi["target"] = {};
   556            if (A.load.Bool(injection + 0 + 13)) {
   557              injection_ffi["target"]["tabId"] = A.load.Int32(injection + 0 + 0);
   558            }
   559            injection_ffi["target"]["frameIds"] = A.load.Ref(injection + 0 + 4, undefined);
   560            injection_ffi["target"]["documentIds"] = A.load.Ref(injection + 0 + 8, undefined);
   561            if (A.load.Bool(injection + 0 + 14)) {
   562              injection_ffi["target"]["allFrames"] = A.load.Bool(injection + 0 + 12);
   563            }
   564          }
   565          injection_ffi["css"] = A.load.Ref(injection + 16, undefined);
   566          injection_ffi["files"] = A.load.Ref(injection + 20, undefined);
   567          injection_ffi["origin"] = A.load.Enum(injection + 24, ["AUTHOR", "USER"]);
   568  
   569          const _ret = WEBEXT.scripting.removeCSS(injection_ffi);
   570          A.store.Ref(retPtr, _ret);
   571          return A.H.TRUE;
   572        } catch (err: any) {
   573          A.store.Ref(errPtr, err);
   574          return A.H.FALSE;
   575        }
   576      },
   577      "has_UnregisterContentScripts": (): heap.Ref<boolean> => {
   578        if (WEBEXT?.scripting && "unregisterContentScripts" in WEBEXT?.scripting) {
   579          return A.H.TRUE;
   580        }
   581        return A.H.FALSE;
   582      },
   583      "func_UnregisterContentScripts": (fn: Pointer): void => {
   584        A.store.Ref(fn, WEBEXT.scripting.unregisterContentScripts);
   585      },
   586      "call_UnregisterContentScripts": (retPtr: Pointer, filter: Pointer): void => {
   587        const filter_ffi = {};
   588  
   589        filter_ffi["ids"] = A.load.Ref(filter + 0, undefined);
   590  
   591        const _ret = WEBEXT.scripting.unregisterContentScripts(filter_ffi);
   592        A.store.Ref(retPtr, _ret);
   593      },
   594      "try_UnregisterContentScripts": (retPtr: Pointer, errPtr: Pointer, filter: Pointer): heap.Ref<boolean> => {
   595        try {
   596          const filter_ffi = {};
   597  
   598          filter_ffi["ids"] = A.load.Ref(filter + 0, undefined);
   599  
   600          const _ret = WEBEXT.scripting.unregisterContentScripts(filter_ffi);
   601          A.store.Ref(retPtr, _ret);
   602          return A.H.TRUE;
   603        } catch (err: any) {
   604          A.store.Ref(errPtr, err);
   605          return A.H.FALSE;
   606        }
   607      },
   608      "has_UpdateContentScripts": (): heap.Ref<boolean> => {
   609        if (WEBEXT?.scripting && "updateContentScripts" in WEBEXT?.scripting) {
   610          return A.H.TRUE;
   611        }
   612        return A.H.FALSE;
   613      },
   614      "func_UpdateContentScripts": (fn: Pointer): void => {
   615        A.store.Ref(fn, WEBEXT.scripting.updateContentScripts);
   616      },
   617      "call_UpdateContentScripts": (retPtr: Pointer, scripts: heap.Ref<object>): void => {
   618        const _ret = WEBEXT.scripting.updateContentScripts(A.H.get<object>(scripts));
   619        A.store.Ref(retPtr, _ret);
   620      },
   621      "try_UpdateContentScripts": (retPtr: Pointer, errPtr: Pointer, scripts: heap.Ref<object>): heap.Ref<boolean> => {
   622        try {
   623          const _ret = WEBEXT.scripting.updateContentScripts(A.H.get<object>(scripts));
   624          A.store.Ref(retPtr, _ret);
   625          return A.H.TRUE;
   626        } catch (err: any) {
   627          A.store.Ref(errPtr, err);
   628          return A.H.FALSE;
   629        }
   630      },
   631    };
   632  });