Why Resources.json is not build using the 'new' format of uBlock Origin templated scriptlet resources?

in resource_assembler.rs you can find the explanation about the new format.

There is the line

A short prelude containing an array of [{{1}}, {{2}}, {{3}}, ...] can be used to backport the newer scriptlet format into the older one; the new one will be directly supported in a future update.

in adBlockRustUtils.js

you can find the line:

const wrapScriptletArgFormat = (fnString, dependencyPrelude) => `{
  const args = ["{{1}}", "{{2}}", "{{3}}", "{{4}}", "{{5}}", "{{6}}", "{{7}}", "{{8}}", "{{9}}"];
  let last_arg_index = 0;
  for (const arg_index in args) {
    if (args[arg_index] === '{{' + (Number(arg_index) + 1) + '}}') {
      break;
    }
    last_arg_index += 1;
  }
  ${dependencyPrelude}
  (${fnString})(...args.slice(0, last_arg_index))
}`

that gets added to every scriptlet rule causing a bunch of duplication code everywhere.

Why not use this which will use the new format?

const wrapScriptletArgFormat = (fnString, dependencyPrelude) => `${fnString}
  ${dependencyPrelude}`

While I know the limitation of Brave's current implementation compared to the 'new format' compared to what uBlock does, it can still be used, and works great, it is exactly what I have been using for more than two months without any issues.

First differences or limitations are:

1. Brave only uses the first function/the function that is at the top for the arguments even if that function doesn't have any arguments, while uBlock will be able to use the one at the bottom or the top, that means ${fnString} has no real value in how Brave parses it.
2. Brave will still duplicate code, because the ${dependencyPrelude} is still applied per scriptlet, while uBlock will just place a single dependency for every Scriptlet.

For 1. the solution is simple, add the ${fnString} at the top and then ${dependencyPrelude}, 2 or 3 months ago, uBlock started doing that in some commit (maybe this one gorhill/uBlock@b381ced or some other, who knows) started to place the ${fnString} at the top, and that means Brave would look almost the same as what uBlock is doing that.

For 2., yes, the JS will get duplicated like if two different scriptlets ave the safe-self.js, there will be two safe-self functions in both Scriptlets, which means, it is not like uBlock, where there would only be one.

But using the 'new' format avoids to add the same duplicate Scriptlet code over and over again only because you have multiple Adblocker Scriptlet rules having different values.

So for example, instead of having 3 different trused-set-cookie functions with all their dependencies duplicates just to add different arguments, using the new format will add a single Scriptlet code, and then add:

try {
trustedSetCookie("name", "value123", "1year", "", "reload", "1", "domain", ".example.com", "dontOverwrite", "0")
} catch ( e ) { }
try {
trustedSetCookie("name2", "value123", "1year", "", "reload", "1", "domain", ".example.com", "dontOverwrite", "0")
} catch ( e ) { }
try {
trustedSetCookie("name3", "value123", "1year", "", "reload", "1", "domain", ".example.com", "dontOverwrite", "0")
} catch ( e ) { }

That means it will reduce completely the JS being injected because it doesn't need to add 3 different trustedSetCookie, setCookieFn, safeSelf, for those 3 rules, and instead it will just have them once per Scriptlet and only add the arguments at the end.

Now all I did was to go to adBlockRustUtils.js and change the lines for the simplest and done:

const wrapScriptletArgFormat = (fnString, dependencyPrelude) => `${fnString}
  ${dependencyPrelude}`

I have been using it this way and it works fine.

Another reason why new format is better is because of the arguments, old format was limited to 9 arguments, but as you can see, in the trustedSetCookie I provided, it has 10, which means if you use:

example.com##+js(trusted-set-cookie, name, value123, 1year , , reload, 1, domain, .example.com, dontOverwrite, 0)

With the old format, it will start to refresh the page endlessly, which is bad. Of course, not all Scriptlets have many arguments like trusted-set-cookie, but it shows that new format having pretty much no limitation in the arguments, will be better to avoid any issues like that if ever happens.

But this is a question too, maybe you are aware of this and you just don't do it because the old format still works, but just the JS duplication of the old format makes the partially-almostfully supported new format a better alternative since having a single Scriptlet for multiple rules, is better than 3 or 10 or 50 different Scriptlets JS code being injected because you had a long list of set-local-storage items or something like that.

Also I don't know if it has anything to do with adblock-rust not being Browser only or some iOS incompatibility or something, but I have been using this new format for a while and no issues in Chromium Brave.

So for example using:

example.com##+js(trusted-set-cookie, name, value123)
example.com##+js(trusted-set-cookie, name2, value123)
example.com##+js(trusted-set-cookie, name3, value123)
example.com##+js(trusted-set-cookie, name4, value123)
example.com##+js(trusted-set-cookie, name5, value123)

with old format has 1592 lines of code

while using the same in new format will only use 333 lines of JS code.

example.com##+js(trusted-set-local-storage-item, name, value123)
example.com##+js(trusted-set-local-storage-item, name2, value123)
example.com##+js(trusted-set-local-storage-item, name3, value123)
example.com##+js(trusted-set-local-storage-item, name4, value123)
example.com##+js(trusted-set-local-storage-item, name5, value123)

will only use 309 in new format while old format is 1472

example.com##+js(rpnt, #text, Example, TEST)
example.com##+js(rpnt, #text, Domain, TEST2)
example.com##+js(rpnt, #text, documents, TEST3)
example.com##+js(rpnt, #text, permission, TEST4)
example.com##+js(rpnt, #text, information, TEST5)

New format = 359 and with old format 1722 lines.

So the gain is better than anything else, especially when the compatibility regardless of partiality is still working fine compared to what uBlock is currently doing when injecting their Scriptlets.

@antonok-edm

[antonok-edm]

Why not use this which will use the new format?

@TEMP-vibM10AY82ddzoWtsBgBaKrnLDQ34SCtKb the main reason is that we dynamically send scriptlets out to all active installations of Brave Browser, unlike uBO which effectively hardcodes a certain version of the scriptlets into each extension installation. Thus when this change to add dependencies and a new format was made in uBO, we had to ensure it could be rolled out in a backwards-compatible manner that wouldn't instantly break all existing Brave installations that hadn't updated yet.

While we don't encourage running an outdated version of the browser, we try not to force it and we've definitely noticed reports from people still using e.g. the last supported version for Windows 7 well past its release date.

I do plan to update the format here once it's considered "safe enough" to do so. We don't have an official policy in that regard, but the tradeoff is as follows:

• keeping things the current way isn't breaking anything; it's just slightly less efficient... versus
• making the change will instantly break adblocking for some nonzero number of users

That makes sense, but I still hope in the not so distant future the decision to finally use the new format can benefit the people who don't run outdated browser, especially the ones that do it even if they have modern OSs, only because they think updating a browser is a 'privacy issue' or something.

But I am sure the difference in how many JS code gets injected in old vs new, should make a difference in resources being used by the browser.

For example, I just checked how many lines of JS get injected on my side in Twitch, which is probably the one that uses more because of a lot of set-local-storage-item scriptlets to set settings for FFZ and BTTV, custom scriptlets to use FFZ and BTTV without using an extension and vaft (latest, not the outdated Brave) and all that and I get I get 16320 lines of JS being injected with the old Format, and with the new format it goes down to 2343.

Of course, this is an 'extreme case', but some pages have multiple Scriptlet rules that are duplicated only because they have different values, as show in my examples.

In the more realistic case of Youtube, which multiple set Scriptlets by default and a clean profile so nothing custom I get 8489 lines of JS, while on my personal installation with custom Scriptlets like ReturnDislikeButton, Sponsorblock and some custom Scriptlets rules to cllick of the "are you still watching" popup, and all that, I still get less JS with 6174 JS being injected.

So, while I am using the new format in my PC since it is easy to build and replace the resources.json, I am sure, especially in mobile, injecting so many unnecessary lines of duplicate code, should make some difference in the way resources will be used at page load and all that, especially since Procedural Cosmetics started to inject even more lines of JS in pages.

So I am just making a case to see if some user's opinion can cause improvement in some things, even if minimal, for CPU resources, loading times and therefore battery life for mobile users/laptop users, by having less unnecessary duplicated code injected in many pages users visit daily, with something a little more efficient.

Thanks for your answer, have a good day!.