Related discussion/issue:
- https://github.com/uBlockOrigin/uBlock-issues/issues/2917
- https://github.com/uBlockOrigin/uAssets/discussions/30124
The "list of selectors" parameter is now a "list of steps". A step
can be:
- A selector, which tells the scriptlet to click a matching element. If
no matching element is found, the scriptlet will wait for a matching
element to become available.
- An integer, which tells the scriptlet to wait n ms before processing
the next step
- A directive, which is a string starting with `!` (not implemented yet)
If the last item in the list is an integer, this tells the scriplet to
override the built-in timeout value of 10s, such that the life time of
the scriptlet can now be extended beyond 10s.
Example:
..##+js(trusted-click-element, '1000, a, 500, b, c, 15000')
The scriptlet filter above will perform the following steps, in order:
- Prepare the scriptlet to timeout at 15s from now
- Wait 1000 ms
- Wait for element `a` to become available then click on it
- Wait 500 ms
- Wait for element `b` to become available then click on it
- Wait for element `c` to become available then click on it
- Abort if all the steps cannot be completed before 15s
The changes keep compatiblity with older syntax or with AdGuard
syntax.
Related issue:
https://github.com/uBlockOrigin/uBlock-issues/issues/3799
An infinite loop in the network filter parser was triggered when
the following conditions were fulfilled:
- There was a network option `$` anchor
- There were only whitespace character(s) preceding the anchor
- There was an invalid filter option following the anchor
Since permissions are now managed by the browsers, the browser will take
care whether to enforce those "usafe" rules according to the permissions
in effect on a given site.
Add vararg `throttle, n` where `n` is the time to wait in ms before
returning a response from proxied `fetch()`.
As discussed with filter list maintainers.
The `uritransform=` option will now be converted to a proper DNR
rule when the following condition are fulfilled:
- The value of the `uritransform` option matches `//[replacement]/`,
i.e. the pattern to match is empty, and only the replacement part is
provided.
- The filter pattern is a regex.
Is such case, the DNR rule will be a `redirect` making use of the
`regexSubstitution` property.
In case the above conditions are not fulfilled, the filter will
be discarded as incompatible with DNR syntax (as was the case
before).
This is potentially a breaking change, in cases where a filter
assumed that the part to match was the start of the path part of
a URL.
A reminder that `uritransform` is an option which requires a
trusted source, otherwise it is rejected.
As discussed with filter list maintainers.
Examples of usage:
$ => result is `null`
$+={"modifyOrCreate": "..."}
These expressions were not working with previous version.
As discussed with filter list maintainers.
Examples of JSON path expression to replace a pattern within a string
value:
..book.*.author=repl({"pattern": "Melville", "replacement": "Toto"})
..book.*.author=repl({"regex": "e", "replacement": "o"})
..book.*.author=repl({"regex": "e", "flags": "g", "replacement": "o"})
If the target value is not a string, no modification will occur.
Additionally, fixed a race condition where changes to rulesets would
not be ultimately registered when the changes were made during an
ongoing registration operation. This race condition would be
especially likely to occur on platforms where rulesets registration
take long.
It's not needed and too likely to interfere negatively with uBO's
default lists. It was added a long, long time ago when EasyPrivacy
wasn't making use of uBO's own advanced syntax, which is no longer
an issue.
Related issue:
https://github.com/uBlockOrigin/uBOL-home/issues/325
This is a first version, with support only for custom filters which are
plain CSS selectors. Future versions will extend support to style-based
and procedural cosmetic filters.
Manually text-editing existing custom filters is currently not supported,
this will be added in a future version in the Develop pane. To remove
existing custom filters, the "Remove a custom filter" tool can be used.
WHen a uBO static network filter is pasted into the "Custom DNR
rules" editor, it will be converted into a DNR rule whenever
possible. At the moment, no feedback is provided when the conversion
fails -- this will be improved in the future.
As discussed with filter list maintainers.
@scriptlet edit-inbound-object.js
@description
Prune properties from an object passed as argument to a specific method.
Properties can only be removed.
@param propChain
Property chain of the method to trap.
@param argPos
0-based position of the argument. Use negative integer for position relative
to the end.
@param jsonq
A uBO-flavored JSONPath query.
@scriptlet trusted-edit-inbound-object.js
@description
Edit properties of an object passed as argument to a specific method.
Properties can be assigned new values.
@param propChain
Property chain of the method to trap.
@param argPos
0-based position of the argument. Use negative integer for position relative
to the end.
@param jsonq
A uBO-flavored JSONPath query.
edit-outbound-object-.js
@description
Prune properties from an object returned by a specific method.
Properties can only be removed.
@param jsonq
A uBO-flavored JSONPath query.
trusted-edit-outbound-object.js
@description
Edit properties from an object returned by a specific method.
Properties can be assigned new values.
@param jsonq
A uBO-flavored JSONPath query.
json-edit-xhr-request.js
@description
Edit the object sent as the body in a XHR instance.
Properties can only be removed.
@param jsonq
A uBO-flavored JSONPath query.
@param [propsToMatch, value]
An optional vararg detailing the arguments to match when xhr.open() is
called.
trusted-json-edit-xhr-request.js
@description
Edit the object sent as the body in a XHR instance.
Properties can be assigned new values.
@param jsonq
A uBO-flavored JSONPath query.
@param [propsToMatch, value]
An optional vararg detailing the arguments to match when xhr.open() is
called.
json-edit-fetch-request.js
@description
Edit the request body sent through the fetch API.
Properties can only be removed.
@param jsonq
A uBO-flavored JSONPath query.
@param [propsToMatch, value]
An optional vararg detailing the arguments to match when fetch() is
called.
trusted-json-edit-fetch-request.js
@description
Edit the request body sent through the fetch API.
Properties can be assigned new values.
@param jsonq
A uBO-flavored JSONPath query.
@param [propsToMatch, value]
An optional vararg detailing the arguments to match when fetch() is
called.
This breaks uBOL -- unclear error message but disabling rulesets
eventually unbreak the extension, thus possibly a case of going
over the rule limit as a result of transposition.
The `requestDomains` issue will have to wait for the official
Safari fix.
* Added 4 language codes for Firefox.
* Added 4 language codes for Firefox.
* Added Kabyle to Liste AR as well.
As opposed to just AdGuard Français.
* Added Kabyle to Liste AR as well.
As discussed internally.
The custom DNR rule count will be reported only when it's not zero,
and the count is only for effective DNR rules, i.e. it will not be
reported if "Developer mode" is not enabled.
This feature is hidden behind the "Developer mode" setting in
the dashboard. When "Developer mode" is enabled, a tab named
"Develop" will become available in the dashboard. This tab is
meant to contain tools for technical users.
At the moment, the "Develop" pane allows to create custom DNR
rules through a (CodeMirror-based) editor.
For the sake of convenience, the DNR rule must be entered in
YAML-like format. The format is not really full compliant YAML,
just YAML-like, and very strict in order to ensure the parser
stays simple enough.
Lines starting with `#` are comments and will be ignored by the
parser.
Any line which do not match the parser's expectation will be
marked as invalid, and the whole DNR rule containing such invalid
lines will be discarded.
There must not be empty lines inside a rule definition.
Each DNR rule must be separated with a `---` line, which is
known as a YAML document separator.
String values must not be quoted, otherwise the quotes will be
considered part of the value. There is one exception: `''` will
be parsed as "an empty string".
The editor will attempt to auto-complete known DNR keywords. That
feature will improve over time.
Though the parser will identify some errors, not all invalid DNR
rules are currently identified by the parser, and these will be
reported when the rules are registered through the DNR API. Better
identifying invalid DNR rules at edit time will improve over time.
The editor will report `regexFilter` values which are not
supported by the DNR engine on the current platform.
The editor reacts to instances of `regexFilter: ...` to report
whether a regex value is supported. This means you can test for
a regex value by using `# regexFilter: ...` so that you do not
have to create an actual DNR rules just for the sake of testing.
Custom DNR rules can be exported into a JSON file (a format
known by the DNR API as a "static ruleset").
JSON-based ruleset can be imported, the content will be converted
to YAML-like syntax.
The editor will attempt to convert to YAML pasted content which
can be JSON-parsed. It's possible to paste partially or wholly
JSON-based rulesets.
When disabling "Developer mode", all custom DNR rules will be
unregistered from the DNR API. The DNR rules content will be left
intact in such case. Existing DNR rules will be registered into
the DNR API when re-enabling "Developer mode".
Administrators can prevent "Developer mode" from being enabled
by adding `develop` token to `disabledFeatures` setting.
Related discussion:
https://github.com/uBlockOrigin/uBOL-home/discussions/323
The main motivation is to give list maintainers a tool to assist
with resolving filter issues. Custom DNR rules can assist in
crafting and validating filters meant to work with uBOL.
A secondary motivation is to provide technical users the ability
to further customize their content blocker.
More conveniences will be added over time, this is a first version.
Related issue:
https://github.com/uBlockOrigin/uBOL-home/issues/157
The `header=` option will be converted into DNR's `responseHeaders`
condition.
There will be an attempt to convert regex-based values into DNR-
compatible syntax. Not all regex-based patterns can be converted to
use DNR's patterns with `*` and `?` special characters.
The implementation of `header=` option in uBO has been revisited to
improve compatibility with DNR syntax to minimize burden for list
maintainers when creating `header=` filters compatible with both
uBO and uBOL.
The changes:
- Header names are now case-insensitive by default
- Occurrences of `*` in non-regex-based header values now mean
"matches any number of characters"
- Occurrences of `?` in non-regex-based header values now mean
"matches zero or one character"
At time of commit, and as per MDN, only Chromium-based browsers
currently support filtering on repsonse headers:
https://developer.mozilla.org/docs/Mozilla/Add-ons/WebExtensions/API/declarativeNetRequest/HeaderInfo
Also as per MDN, Chromium 121-127 silently ignore the `responseHeaders`
condition, potentially causing undue blocking of network requests.
Currently uBOL support Chromium 122 and later, meaning we need to mind
potential false positives in Chromium 122-127 for filters using
`header=` option.
Related issue:
https://github.com/uBlockOrigin/uAssets/issues/28408
Stable Safari is known to not block certain network requests due to
the current state of the DNR engine in Safari. The warning is to
ensure volunteers are not burdened by issues originating from the
browser.
Eventually Safari's DNR implementation will catch up with the
specification, at which time the warning will be removed.
This is a first step to integrate CodeMirror6 into the project.
As a side effect, this should take care of:
https://github.com/uBlockOrigin/uBOL-home/issues/297
Though most likely the list of no-filtering websites will probably
move to its own pane as in uBO in some future.
Most of the time the URL doesn't change and just forcing a reload
of the page is sufficient. When a document is strict-blocked, the
URL must be updated however.
Excerpt from <https://openphish.com/terms.html>:
> Except as expressly permitted by OpenPhish in writing, you agree not
> to license, sell, rent, lease, transfer, assign, distribute, display,
> disclose, create derivative works or otherwise make all or any portion
> of the information obtained through the Services available to any
> third party.
onMessage() is now a listener installed synchrnously when uBOL
executes, so no longer need to deal with failure to send messages.
Related commit:
ab458b492a
Setting name: "defaultFiltering"
Type: string
Valid values: "none", "basic", "optimal", "complete"
Additionally, fix default "basic" mode toggling back to "optimal"
upon extension restart when uBOL has broad host permissions. The
default mode will toggle automatically only when there is a change
in broad host permissions status.
The quoted email below was sent to ubo-security at raymondhill dot net:
=====
Dear Raymond,
I am writing to report a potential Regular Expression Denial of Service (ReDoS)
vulnerability in the 1p-filters.js script of uBlock Origin. The vulnerability
occurs due to the use of the regular expression /\s+$/, which is used to remove
trailing whitespace. This issue can lead to a denial of service when processing
strings with a large number of trailing spaces, potentially causing a browser to
freeze.
Affected file(s)
js/1p-filters.js
Vulnerable pattern(s)
Lines 131 and 167: /\s+$/
Description of the issue
The regular expression /\s+$/ is applied to remove trailing whitespace in user‑
provided content. However, when the content has a large number of spaces
(e.g., ~100,000), this pattern causes excessive backtracking in the regular
expression engine, resulting in performance degradation and UI freezing. This is
a classic ReDoS attack vector.
Steps to reproduce
1. Open the uBlock Origin dashboard and navigate to the My filters tab.
2. Run the following code in the browser's DevTools Console or as a bookmarklet.
3. Observe the UI freezing for several seconds or even longer, depending on the
number of spaces used.
PoC (Proof of Concept)
/**
* poc.js — triggers ReDoS in 1p-filters.js
* Expected: <1 ms; Actual: several seconds – UI freeze
*/
(() => {
const payload = " ".repeat(100000) + "!"; // 100,000 spaces + sentinel
const run = () => {
if (!window.cmEditor) {
console.error("cmEditor not ready");
return;
}
// Inject payload into the editor
cmEditor.setValue(payload);
console.time("ReDoS");
// Call the vulnerable function (mirroring getEditorText)
cmEditor.getValue().replace(/\s+$/, '');
// Alternatively, simulate a realistic user flow:
// document.querySelector('#userFiltersApply').click();
console.timeEnd("ReDoS");
};
if (document.readyState === "complete") {
run();
} else {
window.addEventListener("load", run, { once: true });
}
})();
Impact
This issue can significantly degrade the user experience, causing the page to
become unresponsive. If an attacker can inject this malicious string into the
page (for example, through XSS or other attacks), it could lead to a denial of
service (DoS). This vulnerability can be triggered repeatedly, causing the
browser to hang indefinitely.
Suggested fix
The issue can be mitigated by replacing /\s+$/ with a more efficient solution,
such as a look‑behind assertion /(?<=\S)\s+$/ (available in modern browsers)
which ensures no backtracking occurs, or using trimEnd() for legacy support:
// Example of using look-behind:
cmEditor.setValue(text.replace(/(?<=\S)\s+$/, '') + '\n\n');
// Alternatively, using trimEnd():
cmEditor.setValue(text.trimEnd() + '\n\n');
Additional information
If required, I am happy to assist in testing or provide more information.
Please feel free to contact me for further clarification.
Best regards,
[redacted]
=====
As discussed with filter list maintainers.
* @scriptlet trusted-create-element
*
* @description
* Element(s) from a parsed HTML string are added as child element(s) to a
* specific parent element in the DOM.
*
* @param parent
* A CSS selector identifying the element to which created element(s) will be
* added.
*
* @param html
* An HTML string to be parsed using DOMParser, and which resulting elements
* are to be added as child element(s).
*
* @param duration
* Optional. If specified, the time in ms after which the added elements will
* be removed. No removal will occur if not specified.
In Firefox, scriptlets are dynamically registered as content scripts
to ensure they execute in a timely manner.
The race condition could lead to scriptlet injection failing at
browser launch time in Firefox when the setting "Suspend network
activity until all filter lists are loaded" had been disabled[1],
even after forcing a page reload. Causing the filter lists to
reload would make the issue go away.
[1] Default is enabled in Firefox and it is strongly advised to NOT
change this.
Related issue:
https://github.com/uBlockOrigin/uBOL-home/issues/326
uBOL now asks broad host permissions by default. Users can still
choose narrow host permissions by using their browser's controls
for this.
For instance in Chromium, those host permissions controls are found
in the "Site access" section in the detailed view of an extension.
One can set "Site access" to "On click" to revoke broad host
permissions, and grant host permissions to only specific site.
In such mode, uBOL will still block through the DNR API, but no
cosmetic or scriptlet filtering will occurs, as these requires
permission to "read and change data" on websites for which higher
filtering mode is desired.
Some browsers do not automatically grant broad host permissions
even when an extension asks for broad permissions at install time,
and going forward all browsers will likely adopt this approach, and
thus it no longer made sense for uBOL to default to no broad hosts
permissions at install time, especially given this leads to issues
with no solution -- issues solved with the new approach (e.g. like
the ability to deploy uBOL in Optimal mode by default).
Support for paths allows to narrow down specific static extended
filters to specific webpages on a given site.
Examples of usage:
example.com/toto##h1
/example\.com\/toto\d+/#@#h1
Call to postMessage was failing in the zapper when using `use_dynamic_url` in
manifest. Manually overwriting the per-session dynamic hostname with the real
extension id fixes this.
Scriptlets added:
- json-edit
- trusted-json-edit
- json-edit-xhr-response
- trusted-json-edit-xhr-response
- json-edit-fetch-response
- trusted-json-edit-fetch-response
- jsonl-edit-xhr-response
- trusted-jsonl-edit-xhr-response
- jsonl-edit-fetch-response
- trusted-jsonl-edit-fetch-response
These scriptlets are functionally similar to their `json-prune` counterpart,
except that they all use the new uBO-flavored JSONPath syntax, and the
`trusted-` versions allow to modify values instead of just removing them.
The `replace=` filter option has been extended to support applying
uBO-flavored JSONPath syntax to the response body. If the `replace=`
value starts with `json:` or `jsonl:`, the remaining of the value will
be interpreted as a JSONPath directive, which can be used to either
remove or modify property in a JSON document.
A bad test prevented the "no filtering" by default mode to not take
effect immediately when activated while no site had yet been set to
"no filtering". It would however take effect as soon as a specific
site would be excluded from "no filtering".
@description
Conditionally prevent assignment to `innerHTML` property.
@param [selector]
Optional. The element must matches `selector` for the prevention to take
place.
@param [pattern]
Optional. A pattern to match against the assigned value. The pattern can be
a plain string, or a regex. Prepend with `!` to reverse the match condition.
As discussed with filter list volunteers.
`generichide` option is implicitly enforced on all sites unless an
exception overrides `generichide`. Though rare, sometimes a
`generichide` exception needs to be overridden so that generic
cosmetic filtering is made possible on a specific site.
This commit is to add support for restoring generic cosmetic
filtering on sites which were excluded through a `generichide`
exception.
Concretely, this is needed to ensure the test suite can properly
verify that generic cosmetic filtering is working when the
filtering mode is set to "complete":
||ublockorigin.github.io^$generichide,important
Related issue:
https://github.com/uBlockOrigin/uBlock-issues/issues/3576
This is the first step, a trivial code change which disable the
injection of `Cache-Control` header in Firefox.
In the next dev cycle, the second step will be to remove all
the code related to `Cache-Control` injection.
Microsoft Edge for Android requires a "link to the core function
test cases for your Edge Android extension" to verify that the
extension function properly.
New syntax for scriptlet-based filtering: it is now possible to
inject a scriptlet in a context according to whether an ancestor
origin matches a specific hostname. Example:
example.com>>##+js(set, iAmEmbeddedInExampleDotCom, true)
The new `>>` specifier means that the scriptlet will not be injected
in `example.com`, but will be injected in all direct and indirect
embedded contexts in pages loaded from `example.com`
The new ancestor domain specifier also works for entity directives:
example.*##+js(set, iAmEmbeddedInExampleDotEffectiveTLD, true)
This is an experimental feature, to be further evaluated and
discussed by filter list maintainers. This is not a complete
implementation, by choice. Do not open issues regarding this
new syntax, the current shortcomings are known.
The new syntax is being discussed internally at:
https://github.com/uBlockOrigin/uBlock-discussions/discussions/244
This extends coverage of strict-blocking to pattern-based filters
with `doc` filter option.
When proceeding with a URL-skip URL present, no temporary bypass
will be created when the "Don't warn me again about this site" is
left unchecked. The idea is to avoid the intermediate redirects
if we navigate again on the same strict-blocked site, while a
temporary bypass would prevent this.
uBO's "Badware risks" list has been spinned off as its own list.
The idea is that should a site be strict-blocked from that list,
we would want to know the strict-block is due to the
"Badware risks" list.
Deserialization failed to restore proper ArrayBuffer when used by
multiple TypedArrays.
This didn't affect uBO since this specific code path was never
taken.
Submission to Edge Addons store fails with:
----
The following checks failed:
Package acceptance validation error:
Manifest file reference 'urlhaus.full' does not exist in the zip archive.
(Note: File locations are case-sensitive)
Package acceptance validation error:
Manifest file reference 'openphish.domains' does not exist in the zip archive.
(Note: File locations are case-sensitive)
----
Guessing the use of period in ruleset file path is causing the
issue.
Related feedback:
https://github.com/uBlockOrigin/uBlock-issues/issues/760#issuecomment-2540436382
Using quotes in filter option values is meant to remove ambiguity
when the value contains special characters. This was not working when
the value started with `$`. For example, fixes usage of quotes in:
$removeparam='$deep_link'
Also, fixed logger output for scriptlets using empty parameters
in quotes.
Related issue:
https://github.com/uBlockOrigin/uBOL-home/issues/254
Cosmetic filters with only negated hostnames would end up being
classified as specific, while in reality the filter is generic, with
specific exceptions.
This commit fixes the improper classification. Enforcing specific
exception filters in the generic realm is still an issue to
address.
Add information about which ruleset caused a page to be strict-
blocked.
Whenever possible, add ability to URL-skip an incoming redirect
in a strict-blocked page.
Add new default list: "30-day Phishing Domain List"
Related issue:
https://github.com/uBlockOrigin/uBOL-home/issues/214
This implements basic functionality for strict blocking, i.e. the
ability to block navigation to undesirable websites. This is a
first implementation, which converts only filters that are plain
hostnames.
Unlike with uBO, it is not possible to know from which ruleset a
blocking rule originates. Nonetheless, users will have to make a
choice as to whether navigation should proceed or not.
A setting has been added to the dashboard to wholly enable/disable
strict blocking. It is enabled by default.
Potential future improvements, pending investigation on feasability
in an MV3 framework:
- Extend coverage to explicit `document` filters
- Leverage and use `urlskip=` filters in the blocking page in order
to proceed while bypassing unwanted redirects.
Related issue:
https://github.com/uBlockOrigin/uBlock-issues/issues/3452
Use blob-based injection only when direct injection fails because
of a page's CSP. This is a mitigation until a better approach is
devised.
Such future better approach to investigate:
- Use `MAIN` world injection supported by contentScript.register()
since Firefox 128
- Investigate registering script to inject ahead of time thru
some heuristic
Add support for range for the `delay` paramater:
---
@param [delay]
A value to match against the delay. Can be a single value for exact match,
or a range:
- `min-max`: matches if delay >= min and delay <= max
- `min-`: matches if delay >= min
- `-max`: matches if delay <= max
No delay means to match any delay value.
Prepend with `!` to reverse the match condition.
---
As discussed with filter list maintainers.
As discussed with filter list maintainers, added ability to
partially replace an argument using the `repl:` prefix. Updated
documentation:
---
@scriptlet trusted-replace-argument.js
@description
Replace an argument passed to a method. Requires a trusted source.
@param propChain
The property chain to the function which argument must be replaced when
called.
@param argposRaw
The zero-based position of the argument in the argument list. Use a negative
number for a position relative to the last argument.
@param argraw
The replacement value, validated using the same heuristic as with the
`set-constant.js` scriptlet.
If the replacement value matches `json:...`, the value will be the
json-parsed string after `json:`.
If the replacement value matches `repl:/.../.../`, the target argument will
be replaced according the regex-replacement directive following `repl:`
@param [, condition, pattern]
Optional. The replacement will occur only when pattern matches the target
argument.
---
Aditionally, more scriptlets moved into their own files.
New managed setting:
"disabledFeatures": {
"title": "User interface features to disable",
"description": "A list of tokens, each of which correspond to a user interface feature to disable.",
"type": "array",
"items": { "type": "string" }
}
Supported tokens:
- `dashboard`: Prevent access to all dashboard settings
- `filteringMode`: Prevent changes to the default filtering mode,
or the current filtering mode of any site
Related feedback:
https://github.com/uBlockOrigin/uBOL-home/discussions/35#discussioncomment-11326086
Collecting matched rules when the extension is side-loaded is now
opt-in, by enabling "Developer mode" in the dashboard.
The reason is to allow the extension to behave same as the official
released version when side-loaded.
Specifically, as side-loaded extension, uBOL's service worker would
wake up due to matched-rule listener even though it would not wake
up the worker with same configuration in stable release.
Not all matching scriptlets were injected on a given site in Optimal
or Complete mode when default mode was set to Basic or less.
A high profile manifestation of this bug was that Youtube ads were
not being blocked when using Optimal on Youtube while default mode
was Basic.
Related issue:
https://github.com/uBlockOrigin/uBOL-home/issues/229
Add "Filter lists" pane in dashboard
The DNR API now supports enabling 50 static rulesets put of a
maximum of 100 (instead of 10 out of 50 originally). Thus given
the potentially growing number of static rulesets, the available
stock rulesets has been moved to its own pane, with the following
improvements:
- Support sublists
- Support search
Aditionally, "RU AdList: Counter" has been added as a stock
ruleset.
Other changes:
- Do not re-evaluate regexes which failed validation
- Better reduce `removeparam` rules
Related bugzilla issue:
https://bugzilla.mozilla.org/show_bug.cgi?id=1736575
The issue was fixed months ago.
The removed code block is causing uBOL to be flagged as "including
remotely hosted code".
To be clear, the removed obsolete code block was not related to
executing remote code. The referenced code was in the file itself,
not remote, and this was a workaround for when Firefox was not
supporting injecting script in the `MAIN` world.
The issue was fixed months ago in Firefox, so there is no point for
the workaround.
Related discussion:
https://github.com/uBlockOrigin/uBOL-home/discussions/35#discussioncomment-11157444
New policy setting: `rulesets`
Type: array
Type of array items: string
Each item in the list is a list id (as seen in `rulesets/ruleset-details.json`),
prefixed with either `+` to enable the ruleset, or `-` to disable the ruleset.
Users will not be able to enable or disable rulesets present in the `rulesets`
policy. Disabled rulesets will not appear in the dashboard.
Use `-*` to remove all non-default rulesets, except for those added
using `+[ruleset_id]`.
Additionally, some work has been done to properly handle policy changes in
a non-blocking and deferred manner, as I observed that it often takes long
for calls to `storage.manage.get` to resolve. This potentailly takes care
of the following issue:
https://github.com/uBlockOrigin/uBOL-home/issues/174
Add `debug` as disposition option: if the `how` parameter is `debug`,
the scriptlet will trigger a `debugger` statement and the target
method won't be suppressed. Useful to find out how the method is
being called by page code. To be used for investigation purpose only.
Allow negative integer as valid value.
Related issue:
https://github.com/gorhill/uBlock/pull/3927
Additionally, move cookie-related scriptlets/helpers into its own
source code file.
Potentially breaking change:
`urlskip=` option will no longer apply by default to blocked network
requests, only network requests which are not blocked can be skipped
through a `urlskip=` filter.
The new `urlskip=` directive `-blocked` can be used to explicitly
allow a `urlskip=` filter to also apply to blocked network requests.
Example: given the filter `||example.com^`, the filter:
||example.com/path/to/tracker$urlskip=?url
Will not prevent strict-blocking when navigating to:
https://example.com/path/to/tracker?url=https://example.org/
However, the filter:
||example.com/path/to/tracker$urlskip=-blocked ?url
Will cause the strict-blocking to be ignored and allow navigation
to proceed to the URL extracted as a result of applying the `urlskip=`
filter:
https://example.org/
Related discussion:
https://github.com/uBlockOrigin/uBlock-issues/issues/3206#issuecomment-2439627386
@trustedScriptlet trusted-set-attr
@description
Sets the specified attribute on the specified elements. This scriptlet runs
once when the page loads then afterward on DOM mutations.
Reference: https://github.com/AdguardTeam/Scriptlets/blob/master/wiki/about-trusted-scriptlets.md#-%EF%B8%8F-trusted-set-attr
@param selector
A CSS selector for the elements to target.
@param attr
The name of the attribute to modify.
@param value
The new value of the attribute. Since the scriptlet requires a trusted
source, the value can be anything.
=====
Additionally, start to move scriptlets into their own source files
for easier maintenance and code review.
Related feedback:
https://github.com/uBlockOrigin/uBlock-issues/issues/3206#issuecomment-2403795984
The first capture group of the regex will be used as the result of the
transformation. Example:
||podtrac.com/pts/redirect.mp3/$urlskip=/podtrac\.com\/pts\/redirect\.mp3\/(.*?\.mp3\b)/ +https
If the regex is invalid, or if it fails to extract a first capture
group, no redirection will occur.
A single request can require multiple calls to the static network
filtering engine (SNFE). The reported timing is the result of
going through *all* the required calls to SNFE. In effect, a
single call to SNFE.match() is a fraction of the reported timing.
BroadcastChannel constructor throws in Firefox when Enhanced
Tracking Protection is set to "strict".
This behavior could cause scriptlet injection to wholly break
when uBO's logger was opened, as BroadcastChannel() is used
by scriptlets to report information to the logger.
This commit ensures that exceptions from BroadcastChannel
constructor are properly handled.
The scriptlets will fall back to report at the console should
they be unable to report to the logger through BroadcastChannel.
Ensure serialization returns copy of data rather than live
references to data. This allows to immediately deserialize() the
result of serialize().
Also, adjust code to modified behavior of filterQuery().
@description
Override the behavior of a method on matching elements.
@param methodPath
The method which calls must be intercepted.
@param [selector]
A CSS selector which the target element must match. If not specified,
the override will occur for all elements.
@param [disposition]
How the override should be handled. If not specified, the overridden call
will be equivalent to an empty function. If set to `throw`, an exception
will be thrown. Any other value will be validated and returned as a
supported safe constant.
@example
..##+js(trusted-override-element-method, HTMLAnchorElement.prototype.click, a[target="_blank"][style])
@description
Prevent the bypassing of uBO scriptlets through anonymous embedded context.
To ensure that a target method in the embedded context is using the
corresponding parent context's method (which is assumed to be
properly patched), or to replace the embedded context with that of the
parent context.
Root issue:
https://issues.chromium.org/issues/40202434
@param methodPath
The method which calls must be intercepted. The arguments
of the intercepted calls are assumed to be HTMLElement, anything else will
be ignored.
@param selector (optional)
A plain CSS selector which will be used in a `document.querySelector()`
call, to validate that the returned element must be processed by the
scriptlet. If no selector is provided, all elements will be processed.
@param targetMethod (optional)
The method in the embedded context which should be delegated to the
parent context. If no method is specified, the embedded context becomes
the parent one, i.e. all properties of the embedded context will be that
of the parent context.
Add support for synchronous `send()` calls.
`trusted-prevent-xhr` is essentially the same as `prevent-xhr` except
that if the `directive` argument is not a known token, it will be
used as is as the response text of the xhr request, whereas `prevent-xhr`
returns an empty string when the directive is unknown.
Related issue:
https://github.com/uBlockOrigin/uBlock-issues/issues/3394
When the "No large media elements" per-site switch is toggled on,
it will also act to prevent autoplay of video/audio media, regardless
of their size. This also works for xhr-based media streaming.
If blocking by size is not desirable while blocking autoplay is
desired, one can toggle on "No large media elements" switch while
setting "Block media elements larger than ..." to a very high value.
Default to `true`.
Set to `false` to wholly disable calls to `dns.resolve()` (Firefox-
only). Disabling calls to `dns.resolve()` will prevent cname-uncloaking
and will limit ability to enforce `ipaddress` filter option.
Probably beneficial in cases of proxied method called in a tight
loop.
Additionally, added `throwFunc` as valid constant in script helper
`validate-constant.fn`. Does what the name implies.
Related issue:
https://github.com/uBlockOrigin/uBlock-issues/issues/3206
The main purpose is to bypass URLs designed to track whether a user
visited a specific URL, typically used in click-tracking links.
The `urlskip=` option ...
- ... is valid only when used in a trusted filter list
- ... is enforced only on top documents
- ... is enforced on both blocked and non-blocked documents
- ... is a modifier, i.e. it cannot be used along with other
modifier options in a single filter
The syntax is `urlskip=[steps]`, where steps is a space-separated
list of extraction directives detailing what action to perform on
the current URL.
The only supported directive in this first commit is `?name`,
which purpose is to extract the value of a named URL parameter
and use the result as the new URL. Example:
||example.com/path/to/tracker$urlskip=?url
The above filter will cause navigation to
https://example.com/path/to/tracker?url=https://example.org/
to automatically bypass navigation to `example.com` and navigate
directly to
https://example.org/
It is possible to recursively extract URL parameters by using
more than one directive, example:
||example.com/path/to/tracker$urlskip=?url ?to
More extraction capabilities may be added in the future.
DNR conversion module is a dev tool, no point loading it by
default. This was done this way because in a distant past uBO
had to be compatible with browsers not supporting dynamically
loaded modules.
Currently all supported browser versions support dynamically
loaded modules.
In Firefox-specific contentScripts API used to register
scriptlets. This could potentially occurs when there are
registrations pending during a reload of filter lists.
This commit makes the DNS resolution code better suited for both
filtering on cname and ip address. The change allows early availability
of ip address so that `ipaddress=` option can be matched at
onBeforeRequest time.
As a result, it is now possible to block root document using
`ipaddress=` option -- so long as an ip address can be extracted
before first onBeforeRequest() call.
Related issue:
https://github.com/uBlockOrigin/uBlock-issues/issues/2792
Caveat
------
the ip address used is the first one among the list of ip
addresses returned by dns.resolve() method. There is no way for uBO
to know which exact ip address will be used by the browser when
sending the request, so this is at most a best guess. The exact IP
address used by the browser is available at onHeadersReceived time,
and uBO will also filter according to this value, but by then the
network request has already been sent to the remote server.
Possibly a future improvement would make available the whole list
of ip addresses to the filtering engine, but even then it's impossible
to know with certainty which ip address will ultimately be used by the
browser -- it is entirely possible that the ip address used by the
browser might not be in the list received through dns.resolve().
If an IP address can be extracted from the hostname portion of
a URL, the IP address matching will be performed at onBeforeRequest()
time.
Regardless, IP address matching will subsequently always be performed
at onHeadersReceived() time as the request details at that point
contain a reliable IP address value on supported platforms (Firefox-
only as of now).
The `cap_ipaddress` now evaluates to `true` in Chromium-based
browsers. Even though these browsers are unable to provide reliable
IP address value at onHeadersReceived() time, they can still
perform IP address matching for IP address extracted from hostname
portion of a URL.
Properly report unsupported `header=` and `ipaddress=` option in
log file.
`header=` support may become possible soon with Chromium 128
introducing blocking according to response headers content.
The purpose is to block according to the ip address of a network
request. In the current implementation, the filter option can only
be enforced at onHeadersReceived time.
The new filter option cannot be enforced in Chromium-based browsers
since the ip address of network requests is available only at
onResponseStarted time, which is not blocking.
The value assigned to `ipaddress` can either be a plain string which
must match exactly a given ip address, or a regex which will be
matched against the ip address.
The `ipaddress` option can only be enforced when the extension
framework does provide a valid ip address in a onHeadersReceived
listener. For instance, cached resources do not have a valid ip
address and thus can't be a match to `ipaddress` option.
Example:
*$script,ipaddress=93.184.215.14
For the sake of convenience for filter list maintainers, this commit
add ability to quote static network option values, so as to avoid the
need to escape commas when parser ambiguity arises.
The quotes can be `"`, `'`, or backticks.
Example, the following filter requires escaping commas:
example.com$xhr,replace=/"loremIpsum.*?([A-Z]"\}|"\}{2\,4})\}\]\,//,1p
Can be now rewritten with no need to escape when using quotes:
example.com$xhr,replace='/"loremIpsum.*?([A-Z]"\}|"\}{2,4})\}\],//',1p
* Maintenance for the Serbo-Croatian Filters section
* Implemented the request to move to contentURLs
I sure I hope I understood the request correctly, or things would get slightly awkward for me.
Related issue:
https://github.com/uBlockOrigin/uBlock-issues/issues/3362
There used to be a way to test URL against the network filtering engine,
but this was removed in a distant past during refactoring.
The ability has been brought back through uBO's own developer tools,
accessible through the _More_ button in the _Support_ pane in the
dashboard.
To query the static network filtering engine, enter the following
in the text editor:
snfe?url-to-test [type] [url-of-context]
`snfe?` is a prompt indicating the intent to query the static network
filtering engine.
At a minimum there must be a URL to test.
Optionally the type of the resource to match, default to `xhr` if
none specified. Also optionally, the context from within which the
request is made. Example:
Enter:
snfe?https://www.google-analytics.com/analytics.js
Result:
url: https://www.google-analytics.com/analytics.js
blocked: ||google-analytics.com^
Enter:
snfe?https://www.google-analytics.com/analytics.js script
Result:
url: https://www.google-analytics.com/analytics.js
type: script
blocked: ||google-analytics.com^
modified: ||google-analytics.com/analytics.js$script,redirect-rule=google-analytics_analytics.js:5
Enter:
snfe?https://example.com/
Result:
url: https://example.com/
not blocked
Enter:
snfe?https://example.com/ ping
Result:
url: https://example.com/
type: ping
blocked: *$ping,3p
When the replacement starts with `json:`, it will be first
decoded using JSON.parse(). Example:
example.com##+js(trusted-replace-outbound-text, somefn, json:"ok")
The doublequotes are required since this is what JSON.parse()
expects as a valid JSON string.
This helper function is now used by `set-cookie` and
`set-local-storage-item` scriptlets, so changes in the
helper function will benefit both scriptlets.
A new icon has been added to the popup panel, to open a popup
window with a terse list of DNR events for the current tab, in
reverse chronological order (most recent DNR event appears at
the top).
The new ability is available only when the extension is sideloaded,
as per `declarativeNetRequestFeedback` documentation. Ref:
https://developer.chrome.com/docs/extensions/reference/api/declarativeNetRequest#event-onRuleMatchedDebug
Purposefully minimal, so as to have something rather than nothing
when having to diagnose filtering issue with the DNR API. Example:
https://github.com/uBlockOrigin/uBOL-home/issues/156
The content of the popup window does not dynamically update, force
a refresh (F5) to get the most recent DNR events. This might be
improved in the future.
The DNR event buffer is not persisted, so the buffer is empty when
service worker is restarted. This might be improved in the future
by using session storage API.
There is no output filtering ability in this first draft. This
might be improved in the future.
DNR rules are reported. The filter from which a DNR rule
originates is not reported. Given that the rulesets are optimized
after conversion from original filter lists to reduce the DNR rule
count, this is unlikely to ever be possible.
Add `statusText` as overridable property in response instance.
Supported values are: `""`, `"Not Found"`. `statusText` defaults
to `"OK"` when not overridden.
`subject:matches-prop(arg)`
Description: Allows to select an element by a property name (or chain of
properties), and optionally the property value.
Chainable: Yes.
`subject`: Can be a plain CSS selector, or a procedural cosmetic filter.
`arg`: A declaration in the form `chain=value`, where `chain` is a dot-
separated string for the target property, and `value` is the optional
property value to match. `value` can be literal text or literal regular
expression. When no `value` is declared, the operator only tests for
the presence of the target property
Example:
example.org##div:matches-prop(imanad)
example.org##img:matches-prop(naturalWidth=160)
Corrpution would occur when reading back serialized data which
contained multiple references to same instance of an object.
The issue could manifest when reading cache storage-related
data from the browser storage API, since the serializer is not
used when reading from indexedDB. Private/incognito mode
fall back on using browser storage API as cache storage.
Off the top of my head, I think the following conditions all
together could result in high likelihood of malfunction caused
by improperly deserializing data at launch time:
- Load from a selfie
- Selfie created after uBO ran for a while
- Selfie loaded from browser storage API (not the case by
default)
Possibly related to reports of uBO malfunctioning:
https://github.com/uBlockOrigin/uBlock-issues/issues/3217#event-12686416838
Related issue:
https://github.com/uBlockOrigin/uBlock-issues/issues/3157
Paremeters:
- `pattern`: a string or regex to match in the outbound text. If
not provided or empty, the scriptlet will only log the outbound
text without modifying it.
- `replacement`: the replacement string for the matched part.
Eslint supports newer JS syntax such as static fields in classes,
which is supported by all browsers/version with official uBO
support.
Reference:
https://eslint.org/docs/latest/
Fixing all warnings for all JS files will be done over time.
For internal use by filter list maintainers, do not open issues
about this. Left undocumented on purpose.
This new procedural operator allows to target elements in the
shadow root of an element.
subject:shadow(arg)
- Description: Look-up matching elements inside the shadow root (if
present) of _subject_.
- Chainable: Yes
- _subject_: Can be a plain or procedural selector.
- _arg_: A plain or a procedural selector for the elements to target
inside the shadowroot.
Example:
..##body > div:not([class]):shadow(div[style]):has(:shadow([data-i18n^="#ad"]))
New special properties:
- `[-]`: remove an array entry if part right of `[-]` matches the
inspected item.
- `{-}`: remove a property if part right of `{-}` mmatches the
inspected item.
This is useful to remove entries which have unspecified names.
Related issues:
- https://github.com/uBlockOrigin/uBlock-issues/issues/3161
- https://github.com/uBlockOrigin/uBlock-issues/discussions/2895#discussioncomment-8504374
Two checkboxes have been added to the "My filters "pane:
1. A checkbox to wholly disable/enable "My filters". This is equivalent
to the checkbox for "My filters" in "Filter lists" pane.
2. A checkbox to enable/disable the trustworthiness of the content
of "My filters". Default to untrusted.
Since toggling these checkboxes requires reloading all filter lists,
their new state must be committed through the "Apply changes" button.
Additionally: a "book" icon has been added to the top-right of the
dashboard, which is a link to the wiki according to whichever pane is
currently active.
This will make HTML filtering and `replace=` filter option less
likely to be bypassed by uBO, as the body response filterer
previously required an encoding to be expressly declared before
acting on the response body.
UTF-8 usage is currently reported as ~98.2%:
https://w3techs.com/technologies/history_overview/character_encoding
- Group "Pick" and "Preview"
- Set minimal button width
- Auto-minimize when picking instead of fully hiding the dialog:
this allows to quit while in picking mode
To disable collating global blocked/allowed counts.
Boolean, default to `false`.
Setting to `true` will prevent uBO from loading/saving global
blocked/allowed counts, and in such case the "Blocked since
install" count instead reflects the count since uBO launched.
Setting back to `false` will cause the counts to resume from
last time they were saved.
Related issue:
https://github.com/uBlockOrigin/uBlock-issues/issues/3100
Turns out it's currently the fastest among the three currently
implemented (Cache, browser.storage.session, indexedDB). Possibly
because indexedDB can natively persist structure-cloneable data,
something uBO can now benefit with the work on abstracting away
the limitations of various storages being limited to persist only
text or JSON data.
Related issue:
https://github.com/uBlockOrigin/uBlock-issues/issues/2969
In uBO, the "cache storage" is used to save resources which can
be safely discarded, though at the cost of having to fetch or
recompute them again.
Extension storage (browser.storage.local) is now always used as
cache storage backend. This has always been the default for
Chromium-based browsers.
For Firefox-based browsers, IndexedDB was used as backend for
cache storage, with fallback to extension storage when using
Firefox in private mode by default.
Extension storage is reliable since it works in all contexts,
though it may not be the most performant one.
To speed-up loading of resources from extension storage, uBO will
now make use of Cache API storage, which will mirror content of
key assets saved to extension storage. Typically loading resources
from Cache API is faster than loading the same resources from
the extension storage.
Only resources which must be loaded in memory as fast as possible
will make use of the Cache API storage layered on top of the
extension storage.
Compiled filter lists and memory snapshot of filtering engines
(aka "selfies") will be mirrored to the Cache API storage, since
these must be loaded into memory as fast as possible, and reloading
filter lists from their compiled counterpart is a common
operation.
This new design makes it now seamless to work in permanent private
mode for Firefox-based browsers, since extension storage now
always contains cache-related assets.
Support for IndexedDB is removed for the time being, except to
support migration of cached assets the first time uBO runs with
the new cache storage design.
In order to easily support all choices of storage, a new serializer
has been introduced, which is capable of serializing/deserializing
structure-cloneable data to/from a JS string.
Because of this new serializer, JS data structures can be stored
directly from their native representation, and deserialized
directly to their native representation from uBO's point of view,
since the serialization occurs (if needed) only at the storage
interface level.
This new serializer simplifies many code paths where data
structures such as Set, Map, TypedArray, RegExp, etc. had to be
converted in a disparate manner to be able to persist them to
extension storage.
The new serializer supports workers and LZ4 compression. These
can be configured through advanced settings.
With this new layered design, it's possible to introduce more
storage layers if measured as beneficial (i.e. maybe
browser.storage.session)
References:
- https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/storage/local
- https://developer.mozilla.org/en-US/docs/Web/API/Cache
- https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm
This is to reduce the diff size of rulesets in new
releases. Beside smaller diff size, this also makes it
easier to investigate rule changes across releases.
As suggested by https://github.com/distinctmondaylilac in internal
email to ubo-security:
> As a sidenote, it may be worth considering if `set-attr` should
> be able to set event handler attributes. It could potentially
> be used to copy the contents of e.g. onclick to other event handlers,
> resulting in self-clicking buttons.
As reported internally to ubo-security by https://github.com/distinctmondaylila
One issue is a regression from the rewriting of the static filtering
parser in version 1.47.0, specifically the following commit:
https://github.com/gorhill/uBlock/commit/8ea3b0f64c
The existing regex was no longer suitable to properly detect
some usage of `report-xxx` in the rwritten parser.
Another issue which predates 1.47.0 is that the regex used for
validation was case-sensititive, while the `report-uri` directive
can be written using uppercase letters, i.e. `Report-uri`.
Usage:
...##+js(remove-cache-storage-item, cacheNamePattern[, urlPattern])
`cacheNamePattern`: the name of the cache to target. Plain string
or regex.
`urlPattern`: the URL of the resource to remove. Plain string
or regex. If no pattern is provided, the whole cache is removed.
Reference:
https://developer.mozilla.org/en-US/docs/Web/API/CacheStorage
Avoid race conditions between isolated world-side broadcast channel
and main-side broadcast channel, so as to not lose logging
information if the isolated world-side is not yet ready to
receive through its broadcast channel.
Additionally, added new scriptlet: `trusted-replace-argument`.
[...]##+js(trusted-replace-argument, fn, argpos, argval [,condition, pattern])
Where:
- `fn` is the function we want to proxy through an `apply` handler.
This can also be a class, in which case the scriptlet will proxy
through `construct` handler. At the moment, `fn` must exist at the
time the scriptlet executes.
- `argpos` is the 0-based position of the argument we want to change
- `argval` is the value we want to have for the argument -- the value
is interpreted the same way the value for `set-constant` is
interpreted.
- `condition, pattern` is a vararg which tells the scriptlet to act
only if `pattern` is found in the argument to overwrite.
Example of usage:
alliptvlinks.com##+js(trusted-replace-argument, MutationObserver, 0, noopFunc)
This commit brings the following changes to the logger:
All logging output generated by injected scriptlets are now sent to
the logger, the developer console will no longer be used to log
scriptlet logging information.
When the logger is not opened, the scriplets will not output any
logging information.
The goal with this new approach is to allow filter authors to
more easily assess the working of scriptlets without having to
go through scriptlet parameters to enable logging.
Consequently all the previous ways to tell scriptlets to log
information are now obsolete: if the logger is opened, the
scriptlets will log information to the logger.
Another benefit of this approach is that the dev tools do not
need to be open to obtain scriptlets logging information.
Accordingly, new filter expressions have been added to the logger:
"info" and "error". Selecting the "scriptlet" expression will also
keep the logging information from scriptlets.
A new button has been added to the logger (not yet i18n-ed): a
"volume" icon, which allows to enable verbose mode. When verbose
mode is enabled, the scriptlets may choose to output more
information regarding their inner working.
The entries in the logger will automatically expand on mouse hover.
This allows to scroll through entries which text does not fit into
a single row.
Clicking anywhere on an entry in the logger will open the detailed
view when applicable.
Generic information/errors will now be rendered regardless of which
tab is currently selected in the logger (similar to how tabless
entries are already being rendered).
Procedural filters with `:xpath` operator were silently rejected
at conversion time because the parser was failing to evaluate the
xpath expression due to the absence of a `document` object in
nodejs.
If `document` object is not present, the parser will assume the
xpath expression is valid.
Scriptlets parameters which are quoted must be re-quoted when
output to the logger to be sure they can be properly looked up
in the list, and that they can be used through copy-paste
operations.
Related issue:
https://github.com/uBlockOrigin/uBlock-issues/issues/3083
This will not completely eliminate the issue but it should
lower the likelihood it will occur -- so at least uBO can
still benefit from reliable scriptlet execution in Firefox.
If present, `elements` vararg must be a valid CSS selector, which will
be used to apply the scriptlet to only elements matching the
selector.
Related issue:
https://github.com/uBlockOrigin/uBlock-issues/issues/3061
Example of usage:
[...]##+js(aeld, click, return"undefined", elements, a.indirect)
The idea is to remove as many dependencies as possible for
low-level ScriptletFilteringEngine in order to make it easier
to reuse the module outside uBO itself.
The high-level derived class takes care of caching and
injection of scriptlets into documents, which requires
more knowledge about the environment in which scriptlets
are to be used.
Also improve scriptlet cache usage to minimize overhead of
retrieving scriptlets.
If the `manual` parameter is assigned a date in the form of
`YYMMDD`, this will tell uBO to update lists from origin sources
when the current time is within the range of the specified date,
otherwise lists will be updated from CDNs. Updating from CDNs
is always strongly recommended since this enables differential
updates.
For the time being, `manual=1` will always cause to update lists
from origin, but this form will be deprecated once next stable
release is widespread. The idea is to not leave behind stale
and obsolete links which would be detrimental to differential
updates should someone click on one of these old links left
behind.
Purging all the lists from cache storage is detrimental to
differential update, and cause filter lists to be updated less
often and consequently to be less up to date then when letting
differential updater do its work.
Possibly related issue:
https://github.com/uBlockOrigin/uBlock-issues/issues/2136
Also reported internally, steps to reproduce the issue fixed here:
- Open uBO's dashboard through 3-dot > Add-ons > uBO > Settings
- Bring forth "Filter lists" pane
We want the tab to be already opened at next launch
- Quit Firefox for Android
- Launch Firefox for Android
Result:
Very long launch time, lists marked as out of date.
In Support pane's troubleshooting information, a delta sign will
be added to list update information when the list was last updated
through differential update.
Related commit:
https://github.com/uBlockOrigin/uAssets/commit/20312c2178
To work around incompatibity with `urltransform` in 1.53.0.
With this commit support for `urltransform` is dropped in
favor of `uritransform`. Since `uritransform` won't be parsed
by older versions of uBO, the change in syntax for `urltransform`
between 1.53.0 and 1.54.0 will no longer cause issue.
Related issue:
https://github.com/uBlockOrigin/uBlock-issues/issues/2969
Changes:
Use browser.alarms to trigger selfie creation. Presence of a selfie
improve markedly time to readiness when uBO is unsuspended.
Mirror content of storage.local to (in-memory) storage.session for
faster load to readiness when uBO is ususpended.
Related issue:
https://github.com/uBlockOrigin/uBlock-issues/issues/2971
Example usage:
...##+js(trusted-trusted-click-element, #cmpwrapper >>> .cmpboxbtnyes)
The substring before ` >>> ` must select an element with a non-null
shadow root, in which case the substring after ` >>> ` will be used
to find the element in the targeted shadow root. ` >>> ` can be used
recursively when multiple shadow root must be pierced.
Broadcast channels are more suited to uBO than DOM events to dispatch
notifications to different parts of uBO.
DOM events can only be dispatched to local context, broadcast channels
dispatch to all contexts (i.e. background process, workers, auxiliary
pages) -- this last behavior is better suited to uBO to communicate
internal changes to all potential listeners, not just those in the local
context.
Additionally, broadcasting to content scripts is now done through
tabs.sendMessage() instead of through potentially opened message
ports, this simplifies broadcasting to content scripts, and this
doesn't require to have long-lived message ports in content
scripts.
Fortunately, getAvailableLists() filters out non-filter
list resources thus preventing those mistakenly selected
resources from being loaded as filter lists.
Related issue:
https://github.com/uBlockOrigin/uBlock-issues/issues/2526
Improvements:
Support fulfilling the response with the content of a
`web_accessible_resources` resource, using the syntax already
supported by `prevent-xhr`: `war:[name of resource]`
Support fulfilling the response with randomized text with length
specified using `length:min[-max]` directive.
There is a lot asynchronicity in the auto-update code, and
the fix here is to detect then fix instances of out of sync
state between a cached filter list and its metadata stored
separately.
When done compiling, force CSSTree to parse an empty string, so
as to ensure it doesn't keep a reference to that string.
Typically, the string passed to CSSTree is a small slice of a
larger string which is a whole filter list. This means that
holding a reference to the sliced string causes the JS engine
to hold in memory to the whole filter list last parsed.
Reference documentation:
https://adguard.com/kb/general/ad-filtering/create-own-filters/#replace-modifier
This is a network filter option which can only be loaded from a
trusted source.
Since this filter is about modifying the response body, it currently
only works in Firefox.
As discussed with filter list maintainers.
Manual update of one or more lists will cause the most recent version
of these lists to be fetched from the "origin" server, and since the
lists from "origin" servers cannot be updated through differential
update, the lists will be subsequently updated according to their
`Expires` directive.
When the lists are auto-updated, the "CDN" servers will be used,
and as a result the lists will start to be updated trhough
differential updates every 6-hour (currently).
Thus it is recommended and optimal to let the lists auto-update,
since you will benefit from a much shorter delay to get up-to-date
lists (i.e. every 6-hour instead of every 6-day).
You can force the auto-updater to fetch all the lists by clicking
"Purge all caches", then restart uBO without clicking "Update".
This will cause uBO to perform an emergency auto-update at restart
time, after which you will have all the lists which are candidates
for differential update.
The "Update now" button in the "Support" pane will also cause lists
to be fetched from their "origin" server.
Related discussion:
https://github.com/ameshkov/diffupdates
The benefits of diff-patching filter lists is much shorter update
schedule and significantly less bandwidth consumed.
At the moment, only default filter lists are subject to be
diff-patched.
External filter lists can make their lists diff-patchable by
following the specification link above.
Only filter lists fetched by the auto-updater are candidate for
diff-patching.
Forcing a manual update of the filter lists will prevent the
diff-patcher from kicking in until one or more lists are
auto-updated.
Some back-of-the-envelop calculations regarding the load on free
CDN solutions used by uBO to distribute its own filter lists:
Currently, for each CDN (with lists updating after days):
~560 M req/month, ~78 TB/month
With diff-patching lists on a 6-hour schedule:
~390 M req/month, 1 TB/month
Those estimates were done according to statistics shown by
jsDelivr, which is one of 4 CDNs picked randomly when a list
updates:
https://www.jsdelivr.com/package/gh/uBlockOrigin/uAssetsCDN?tab=stats
I worked through some of the websites listed in the google-ima shim
script issue[1], to see what was going wrong. It turned out the
addEventListener method supports an optional context Object, which is
bound to the listener if provided. Some websites make use of that,
and then break when `this` is not bound correctly when events are
dispatched.
See also https://github.com/duckduckgo/tracker-surrogates/pull/24
1 - https://github.com/uBlockOrigin/uBlock-issues/issues/2265
Essentially a complement of `trusted-prune-inbound-object.js` added in
1c9da227d7
To perform object pruning on any object returned synchronously by
any given call.
The arguments for `trusted-prune-outbound-object` in order are:
- The name of the property to trap. Must be a function, and must
exist when the scriptlet tries to install the trap.
- The properties to prune (as with `json-prune`)
- The properties which must all be present for pruning to occur
(as with `json-prune`)
The scriptlets `json-prune.js` and `evaldata-prune.js` essentially
perform the same function, and will eventually be rewritten to
internally delegate to generic `trusted-prune-outbound-object.js`.
Related discussion:
https://github.com/uBlockOrigin/uBlock-issues/discussions/2895
Changes:
The _content of the My filters_ pane is now considered untrusted by
default, and only uBO's own lists are now trusted by default.
It has been observed that too many people will readily copy-paste
filters from random sources. Copy-pasting filters which require trust
represents a security risk to users with no understanding of how the
filters work and their potential abuse.
Using a filter which requires trust in a filter list from an untrusted
source will cause the filter to be invalid, i.e. shown as an error.
A new advanced setting has been added to control which lists are
considered trustworthy: `trustedListPrefixes`, which is a space-
separated list of tokens. Examples of possible values:
- `ublock-`: trust only uBO lists, exclude everything else including
content of _My filters_ (default value)
- `ublock- user-`: trust uBO lists and content of _My filters_
- `-`: trust no list, essentially disabling all filters requiring
trust (admins or people who don't trust us may want to use this)
One can also decide to trust lists maintained elsewhere. For example,
for stock AdGuard lists add ` adguard-`. To trust stock EasyList lists,
add ` easylist-`.
To trust a specific regional stock list, look-up its token in
assets.json and add to `trustedListPrefixes`.
The matching is made with String.startsWith(), hence why `ublock-`
matches all uBO's own filter lists.
This also allows to trust imported lists, for example add
` https://filters.adtidy.org/extension/ublock/filters/` to trust all
non-stock AdGuard lists.
Add the complete URL of a given imported list to trust only that one
list.
URLs not starting with `https://` or `file:///` will be rejected,
i.e. `http://example.org` will be ignored.
Invalid URLs are rejected.
Related issue:
https://github.com/uBlockOrigin/uBlock-issues/issues/2896
TODO: Eventually, distinguish between filtering profile increasing
or decreasing so as to avoid flushing caches when increasing
filtering, which should not affect the scriptlets cache.
As per discussion with filter list maintainers.
To perform object pruning for any given call which has an object
as argument (hence "inbound").
Since `json-prune-stringify` scriptlet is a specific form of
pruning inbound objects, it has been removed.
The arguments for `trusted-prune-inbound-object` in order are:
- The name of the property to trap. Must be a function, and must
exist when the scriptlet tries to install the trap.
- The position of the object to prune in the argument list when
the trapped function is called. The position is 1-based and
must be an integer greater than 0.
- The properties to prune (as with `json-prune`)
- The properties which must all be present for pruning to occur
(as with `json-prune`)
- Varargs:
- `, dontOverwrite, 1`: do not modify the target inbound object
Examples:
Remove `title` and `name` properties before passing the object to
`JSON.stringify` call:
example.org##+js(trusted-prune-inbound-object, JSON.stringify, 1, title name)
Remove `status` property before passing the object to `Object.keys`
call but do not modify caller's instance of the object:
example.org##+js(trusted-prune-inbound-object, Object.keys, 1, status, , dontOverwrite, 1)
When the target world of a scriptlet is the ISOLATED one,
skip Blob-based injection in Firefox, as the current world
is always the ISOLATED one. This should make ISOLATED
world-based scriptlets more reliable (i.e. execute sooner)
in Firefox.
(In addition to in already supported single- and double-quote).
The parsing of (optionally) quoted arguments from an argument
list has been spinned off into a standalone helper in order to
be reused in other parts of the parser eventually.
The `urltransform` option allows to redirect a non-blocked network
request to another URL. There are restrictions on its usage:
- require a trusted source -- thus uBO-maintained lists or user
filters
- the `urltransform` value must start with a `/`
If at least one of these conditions is not fulfilled, the filter
will be invalid and rejected.
The requirement to start with `/` is to enforce that only the path
part of a URL can be modified, thus ensuring the network request
is redirected to the same scheme and authority (as defined at
https://en.wikipedia.org/wiki/Uniform_Resource_Identifier#Syntax).
Usage example (redirect requests for CSS resources to a non-existing
resource, for demonstration purpose):
||iana.org^$css,urltransform=/notfound.css
Name of this option is inspired from DNR API:
https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/declarativeNetRequest/URLTransform
This commit required to bring the concept of "trusted source" to
the static network filtering engine.
As per discussion with uBO volunteers.
Volunteers offering support for uBO will be able to craft links with
specially formed URLs, which once clicked will cause uBO to automatically
force an update of specified filter lists.
The URL must be crafted as shown in the example below:
https://ublockorigin.github.io/uAssets/update-lists.html?listkeys=ublock-filters,easylist
Where the `listkeys` parameter is a comma-separated list of tokens
corresponding to filter lists. If a token does not match an enabled
filter list, it will be ignored.
The ability to update filter lists through a specially crafted link
is available only on uBO's own support sites:
- https://github.com/uBlockOrigin/
- https://reddit.com/r/uBlockOrigin/
- https://ublockorigin.github.io/
Additionally, a visual cue has been added in the "Filter lists" pane
to easily spot the filter lists which have been recently updated, where
"recently" is currently defined as less than an hour ago.
If the `version` vararg is present and set to `2`, and if a
fetch Request argument is present, it will be cloned before
being matched to `propsToMatch` properties.
Additionally, created a `.fn` version of `[...]-fetch-response`
scriptlets to avoid redundant code in final injected scriptlets.
Prevent usage of specific or all (default) canvas APIs.
Syntax
```text
example.com##+js(prevent-canvas [, contextType])
```
- `contextType`: A specific type of canvas API to prevent (default to all
APIs). Can be a string or regex which will be matched against the type
used in getContext() call. Prepend with `!` to test for no-match.
Examples
1. Prevent `example.com` from accessing all canvas APIs
```adblock
example.com##+js(prevent-canvas)
```
2. Prevent access to any flavor of WebGL API, everywhere
```adblock
*##+js(prevent-canvas, /webgl/)
```
3. Prevent `example.com` from accessing any flavor of canvas API except `2d`
```adblock
example.com##+js(prevent-canvas, !2d)
```
References
https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/getContext
[Commits to Master Since This Release](https://github.com/gorhill/uBlock/compare/%version%...master)
#### How to Install the Developer Build:
- **Firefox**: Signing pending <!-- Download the build from [uBlock0_%version%.firefox.signed.xpi](https://github.com/gorhill/uBlock/releases/download/%version%/uBlock0_%version%.firefox.signed.xpi). -->
uBO works best on Gecko-based browsers, check out [why](https://github.com/gorhill/uBlock/wiki/uBlock-Origin-works-best-on-Firefox).
- **Chromium**: Install directly from the [Chrome Web Store](https://chromewebstore.google.com/detail/ublock-origin-development/cgbcahbpdhpcegmbfconppldiemgcoii).
- [Fix Chartbeat flicker control `div`'s](https://github.com/gorhill/uBlock/commit/397d6d47b9) (by @ryanbr)
- [Fix potential exfiltration of browsing history by a rogue list author through `permissions=`](https://github.com/gorhill/uBlock/commit/7b138b58c6)
- [Ignore event handler-related attributes in `set-attr` scriptlet](https://github.com/gorhill/uBlock/commit/3037ae5f04) (suggested by @distinctmondaylilac)
- [Fix potential exfiltration of browsing history by a rogue list author through `csp=`](https://github.com/gorhill/uBlock/commit/db5656f607) (reported by @distinctmondaylilac)
- [Output scriptlet logging information to the logger](https://github.com/gorhill/uBlock/commit/869a653fdf)
- [Fix decompiling of scriptlet parameters](https://github.com/gorhill/uBlock/commit/49dd68ef3d)
- [Add support for `extraMatch` in `trusted-click-element` scriptlet](https://github.com/gorhill/uBlock/commit/45e62c939f)
- [Remove minimum height constraint from "My filters" pane](https://github.com/gorhill/uBlock/commit/f624c835c2)
- [Unregister all scriptlets when disabling uBO on a specific site](https://github.com/gorhill/uBlock/commit/13dcd844a7)
- [Allow `uritransform` to process the hash part of a URL](https://github.com/gorhill/uBlock/commit/b19094339f)
- [Remember presentation state of "My rules" pane](https://github.com/gorhill/uBlock/commit/3d1b100646)
- [Catch cases of `! Expires:` field with no value](https://github.com/gorhill/uBlock/commit/9ce958432d)
----------
# 1.54.0
## New
Differential update of filter lists, as a result of discussions at <https://github.com/AdguardTeam/FiltersCompiler/issues/192>. Resulting spec is [here](https://github.com/ameshkov/diffupdates).
The goal is to **NOT** be ranked among the "most popular projects" by bandwidth usage (as per [jsDelivr's public stats](https://www.jsdelivr.com/statistics)):
It is expected that differential updates will lower both requests and bandwidth usage.
To benefit the much shorter update period enabled by differential updates, you must let uBO auto-update the filter lists. Forcing a manual update will prevent differential updates until the next time a list auto-update.
## Fixes / changes
- [Enable path for native `has()` selector in Firefox](https://github.com/gorhill/uBlock/commit/c5724c1cce)
- [Allow scriptlets to be injected in `about:blank`](https://github.com/gorhill/uBlock/commit/3fd2588650)
- [Fix faulty `as` vararg in `set-constant` scriptlet](https://github.com/gorhill/uBlock/commit/c292a90b90)
- [Add support to redirect to `noop.json`](https://github.com/gorhill/uBlock/commit/bd8a91ed3a)
- [More improvements to the `google-ima` shim script](https://github.com/gorhill/uBlock/commit/c1d8f5908d) (by @kzar)
- [All exceptions filters are exempt from requiring a trusted source](https://github.com/gorhill/uBlock/commit/d2b8d990e6)
- [Allow the use of quotes in `set-cookie` scriptlet ](https://github.com/gorhill/uBlock/commit/7c562d0c5c)
- [Allow the use of quotes in `set-(local|session)-storage-item`](https://github.com/gorhill/uBlock/commit/decafc5cbf)
- [Add ability to trigger cookie removal on specific events](https://github.com/gorhill/uBlock/commit/ef311ddbec)
- [Ensure CSSTree does not hold a reference onto last parsed string](https://github.com/gorhill/uBlock/commit/1dba557c9a)
- [Lower minimum Expires value to 4h](https://github.com/gorhill/uBlock/commit/2360bc02f3)
- [Properly reset needle length in unserialized buffer](https://github.com/gorhill/uBlock/commit/8ed1ad9c9d)
- [Add additional flags to regional lists](https://github.com/gorhill/uBlock/commit/0962366524) (by @DandelionSprout)
- [Harden scriptlets which need to serialize function code into string](https://github.com/gorhill/uBlock/commit/7823d98070)
- [Reset `g` regexes before use in `rmnt`/`rpnt` scriptlets](https://github.com/gorhill/uBlock/commit/cdc3f66a6b)
- [Apply response filtering according to mime type](https://github.com/gorhill/uBlock/commit/6417f54299)
- [Add t/f to set-cookie](https://github.com/gorhill/uBlock/commit/4ab1c36ac9) (by @ryanbr)
- [Have `urltransform=` use the same syntax as `replace=`](https://github.com/gorhill/uBlock/commit/d7c99b46e6)
- [Implement network filter option `replace=`](https://github.com/gorhill/uBlock/commit/7c3e060c01) (Firefox only because [filterResponseData](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/webRequest/filterResponseData#browser_compatibility))
- [Prevent evaluating the SNFE until fully loaded](https://github.com/gorhill/uBlock/commit/89b272775a)
- [Add support for differential update of filter lists](https://github.com/gorhill/uBlock/commit/d05ff8ffeb)
<sub><ahref="https://github.com/gorhill/uBlock/wiki/uBlock-Origin-is-completely-unrelated-to-the-web-site-ublock.org"><b>BEWARE!</b> uBO is (and has always been) COMPLETELY UNRELATED to the website <code>ublock.org</code></a>.</sub>
</p>
***
<palign="center">
<ahref="https://addons.mozilla.org/addon/ublock-origin/"><imgsrc="https://user-images.githubusercontent.com/585534/107280546-7b9b2a00-6a26-11eb-8f9f-f95932f4bfec.png"alt="Get uBlock Origin for Firefox"></a>
<ahref="https://chrome.google.com/webstore/detail/ublock-origin/cjpalhdlnbpafiamejdnhcphjbkeiagm"><imgsrc="https://user-images.githubusercontent.com/585534/107280622-91a8ea80-6a26-11eb-8d07-77c548b28665.png"alt="Get uBlock Origin for Chromium"></a>
<ahref="https://microsoftedge.microsoft.com/addons/detail/ublock-origin/odfafepnkmbhccpbejgmiehpchacaeak"><imgsrc="https://user-images.githubusercontent.com/585534/107280673-a5ece780-6a26-11eb-9cc7-9fa9f9f81180.png"alt="Get uBlock Origin for Microsoft Edge"></a>
<ahref="https://addons.opera.com/extensions/details/ublock/"><imgsrc="https://user-images.githubusercontent.com/585534/107280692-ac7b5f00-6a26-11eb-85c7-088926504452.png"alt="Get uBlockOrigin for Opera"></a>
<ahref="https://addons.thunderbird.net/thunderbird/addon/ublock-origin/"><imgsrc="https://user-images.githubusercontent.com/124740436/235314672-73243149-3683-4407-a2d5-ad0f2b08bc17.png"alt="Get uBlock Origin for Thunderbird"></a>
</p>
| Browser | Install from ... | Status |
| :-------: | ---------------- | ------ |
| <imgsrc="https://github.com/user-attachments/assets/b0136512-56a5-4856-8c50-4971c957a24f"alt="Get uBlock Origin for Firefox"> | <ahref="https://addons.mozilla.org/addon/ublock-origin/">Firefox Add-ons</a> | [uBO works best on Firefox](https://github.com/gorhill/uBlock/wiki/uBlock-Origin-works-best-on-Firefox) |
| <imgsrc="https://github.com/user-attachments/assets/3a7569f8-688b-4eb1-a643-8d0fe173aefe"alt="Get uBlock Origin for Microsoft Edge"> | <ahref="https://microsoftedge.microsoft.com/addons/detail/ublock-origin/odfafepnkmbhccpbejgmiehpchacaeak">Edge Add-ons</a> |
| <imgsrc="https://github.com/user-attachments/assets/938f080c-fe64-4e48-8b89-4bfceabb56e6"alt="Get uBlock Origin for Opera"> | <ahref="https://addons.opera.com/extensions/details/ublock/">Opera Add-ons</a> |
| <imgsrc="https://github.com/user-attachments/assets/5463ef88-873b-4516-8514-5277664cfde7"alt="Get uBlock Origin for Chromium"> | <ahref="https://chromewebstore.google.com/detail/ublock-origin/cjpalhdlnbpafiamejdnhcphjbkeiagm">Chrome Web Store</a> | <ahref="https://github.com/uBlockOrigin/uBlock-issues/wiki/About-Google-Chrome's-%22This-extension-may-soon-no-longer-be-supported%22">About Google Chrome's "This extension may soon no longer be supported"</a><br>End of support on Chrome 139 |
| <imgsrc="https://github.com/user-attachments/assets/2e9037c4-836d-44c1-a716-ba96e89daaff"alt="Get uBlock Origin for Thunderbird"> | <ahref="https://addons.thunderbird.net/thunderbird/addon/ublock-origin/">Thunderbird Add-ons</a> | [No longer updated and stuck at 1.49.2.](https://github.com/uBlockOrigin/uBlock-issues/issues/2928) Later versions require "GitHub - Releases". |
| <imgsrc="https://upload.wikimedia.org/wikipedia/commons/c/c2/GitHub_Invertocat_Logo.svg"height="50"alt="Get uBlock Origin through GitHub"> | <ahref="https://github.com/gorhill/uBlock/releases">GitHub - Releases</a> | Stable and development versions on Firefox, Chromium MV2, and Thunderbird. Must be placed manually into web browsers; the Chromium and Thunderbird versions usually won't auto-update.
***
@@ -93,11 +89,13 @@ uBO [works best][Works Best] on Firefox and is available for desktop and Android
[Thunderbird Add-ons][Thunderbird]
In Thunderbird, uBlock Origin does not affect emails, just feeds.
- Download and unzip `ublock0.chromium.zip` ([latest release desirable](https://github.com/gorhill/uBlock/releases)).
- Rename the unzipped directory to `ublock`
- When you later update manually, replace the **content** of the `ublock` folder with the **content** of the latest zipped version.
-This will ensure that all the extension settings will be preserved
- As long as the extension loads **from same folder path from which it was originally installed**, all your settings will be preserved.
- Go to chromium/chrome *Extensions*.
- Click to check *Developer mode*.
- Click *Load unpacked extension...*.
-In the file selector dialog:
-Select the directory `ublock` which was created above.
- Click *Open*.
1. Download and unzip `ublock0.chromium.zip` ([latest release desirable](https://github.com/gorhill/uBlock/releases)).
2. Rename the unzipped directory to `ublock`.
- When you update manually, replace the **content** of the `ublock` folder with the **content** of the latest zipped version. This ensures all extension settings are preserved.
-As long as the extension loads from the same folder path as it was originally installed, your settings will be kept.
3. Open Chromium/Chrome and go to *Extensions*.
4. Click to enable *Developer mode*.
5. Click *Load unpacked extension...*.
6. In the file selector dialog:
-Select the `ublock` directory you created.
-Click *Open*.
The extension will now be available in your chromium/chromium-based browser.
The extension will now be available in your Chromium/Chromium-based browser.
Remember that you have to update manually also. For some users, updating manually is actually an advantage because:
- You can update when **you** want
- If ever a new version sucks, you can easily just re-install the previous one
**Note:** You must update manually. For some users, manual updates are beneficial because:
- You can update when **you** want.
- If a new version is unsatisfactory, you can easily reinstall the previous one.
### Firefox
## Firefox
Compatible with Firefox 52 and beyond.
Compatible with Firefox 52 and beyond.
#### For stable release version
### For Stable Release Version
This works only if you set `xpinstall.signatures.required` to `false` in `about:config`.<sup>[see "Add-on signing in Firefox"](https://support.mozilla.org/en-US/kb/add-on-signing-in-firefox)</sup>
This method only works if you set `xpinstall.signatures.required` to `false` in `about:config`.<sup>[see "Add-on signing in Firefox"](https://support.mozilla.org/en-US/kb/add-on-signing-in-firefox)</sup>
2. Drag and drop the downloaded `ublock0.firefox.xpi` into Firefox.
#### For beta version
### For Beta Version
- Click on `ublock0.firefox.signed.xpi` ([latest release desirable](https://github.com/gorhill/uBlock/releases)).
#### Location of uBO settings
### Location of uBO Settings
On Linux, the settings are saved in a JSON file located at`~/.mozilla/firefox/[profile name]/browser-extension-data/uBlock0@raymondhill.net/storage.js`.
On Linux, the settings are saved in a JSON file located at:
- Drag and drop the previously downloaded `ublock0.firefox-legacy.xpi` into Firefox
For Firefox 43 and beyond, you may need to toggle the setting `xpinstall.signatures.required` to `false` in `about:config`.<sup>[see "Add-on signing in Firefox"](https://support.mozilla.org/en-US/kb/add-on-signing-in-firefox)</sup>
With Firefox 43 and beyond, you may need to toggle the setting `xpinstall.signatures.required` to `false` in `about:config`.<sup>[see "Add-on signing in Firefox"](https://support.mozilla.org/en-US/kb/add-on-signing-in-firefox)</sup>
Your uBlock Origin settings are preserved even after uninstalling the addon.
Your uBlock Origin settings are kept intact even after you uninstall the addon.
- On Linux, settings are saved in a SQLite file located at:
4.`make mv3-[platform]`, where `[platform]` is either `chromium` or `firefox`
5.This will fully build uBO Lite, and during the process filter lists will be downloaded from their respective remote servers
4.`git submodule init`
5.`git submodule update`
6.`make mv3-[platform]`, where `[platform]` is either `chromium`, `edge`, `firefox`, or `safari`
7. This will fully build uBO Lite, and during the process filter lists will be downloaded from their respective remote servers
Upon completion of the script, the resulting extension package will become present in:
- Chromium: `dist/build/uBOLite.chromium`
- Firefox: `dist/build/uBOLite.firefox`
-Edge: `dist/build/uBOLite.edge`
- Firefox: `dist/build/uBOLite.firefox`
- Safari: `dist/build/uBOLite.safari`
The folder `dist/build/mv3-data` will cache data fetched from remote server, so as to avoid fetching repeatedly from remote server with repeated build commands. Remove `dist/build/mv3-data` if you want to build with latest versions of filter lists.
The folder `dist/build/mv3-data` will cache data fetched from remote servers, so as to avoid fetching repeatedly from remote servers with repeated build commands. Use `make cleanassets` to remove all locally cached filter lists if you want to build with latest versions of filter lists.
The file `dist/build/mv3-data/log.txt` will contain information about what happened during the build process.
The file `dist/build/uBOLite.[platform]/log.txt` will contain information about what happened during the build process.
The entry in the `Makefile` which implement the build process is `tools/make-mv3.sh [platform]`.[1] This Bash script copy various files from uBlock Origin branch and MV3-specific branch into a single folder which will be the final extension package.
@@ -27,5 +31,4 @@ All the final rulesets are present in the `dist/build/uBOLite.[platform]/ruleset
**uBO Lite** (uBOL), an efficient [MV3 API-based](https://developer.chrome.com/docs/extensions/mv3/intro/) content blocker.
uBOL is entirely declarative, meaning there is no need for a permanent uBOL process for the filtering to occur, and CSS/JS injection-based content filtering is [performed reliably](https://developer.chrome.com/docs/extensions/reference/scripting/#method-registerContentScripts) by the browser itself rather than by the extension. This means that uBOL itself does not consume CPU/memory resources while content blocking is ongoing -- uBOL's service worker process is required _only_ when you interact with the popup panel or the option pages.
uBOL does not require broad "read/modify data" [permission](https://developer.chrome.com/docs/extensions/mv3/declare_permissions/) at install time, hence its limited capabilities out of the box compared to uBlock Origin or other content blockers requiring broad "read/modify data" permissions at install time. <details><summary>**However, [...]**</summary>
uBOL allows you to *explicitly* grant extended permissions on specific sites of your choice so that it can better filter on those sites using declarative cosmetic and scriptlet injections.
To grant extended permissions on a given site, open the popup panel and pick a higher filtering mode such as Optimal or Complete.
The browser will then warn you about the effects of granting the additional permissions requested by the extension on the current site, and you will have to tell the browser whether you accept or decline the request:
If you accept uBOL's request for additional permissions on the current site, it will be able to better filter content for the current site:
You can set the default filtering mode from uBOL's options page. If you pick the Optimal or Complete mode as the default one, you will need to grant uBOL the permission to modify and read data on all websites:
uBO Lite (uBOL) is a *permission-less* MV3-based content blocker.
uBO Lite (uBOL) هو مانع محتوى يعتمد على MV3.
تتوافق مجموعة القواعد الافتراضية مع مجموعة عوامل التصفية الافتراضية لـ uBlock Origin:
@@ -7,30 +7,6 @@ uBO Lite (uBOL) is a *permission-less* MV3-based content blocker.
- الخصوصية السهلة
- قائمة خادم الإعلانات والتتبع لبيتر لوي
يمكنك إضافة المزيد من القواعد من خلال زيارة صفحة الخيارات ومن ثم أنقر على رمز _Cogs_ في اللوحة المنبثقة.
يمكنك تفعيل المزيد من مجموعات القواعد من خلال زيارة صفحة الخيارات - انقر على أيقونة _الترس_ في لوحة الإشعارات.
uBOL صريح تمامًا، مما يعني أنه لا تحتاج إلى uBOL بشكل دائم لحدوث تصفية المحتوى، يتم إجراء تصفية المحتوى من خلال إضافة CSS/JS بشكل موثوق به بواسطة المتصفح نفسه بدلًا من الإضافة.
هذا يعني أن uBOL نفسه لا يستهلك موارد وحدة المعالجة المركزية/الذاكرة أثناء استمراره في حظر المحتوى. عملية عامل الخدمة في uBOL مطلوبة _فقط_ عند التفاعل مع اللوحة المنبثقة أو صفحة الخيارات.
لا يتطلب uBOL صلاحية واسعة «لقراءة البيانات وتعديلها» في وقت التثبيت، وبالتالي فإن قدراته محدودة مقارنة بـ uBlock Origin أو إضافات حظر الإعلانات الأخرى التي تتطلب صلاحية واسعة «قراءة البيانات وتعديلها» في وقت التثبيت.
ومع ذلك، يسمح لك uBOL "بوضوح" بمنح صلاحيات موسعة على مواقع محددة من اختيارك حتى يتمكن من التصفية بشكل أفضل على تلك المواقع باستخدام التصفية التجميلية وإضافة النص.
لمنح صلاحيات موسعة على موقع معين، افتح اللوحة المنبثقة واختر وضع التصفية إما الأمثل أو الكامل.
سيحذرك المتصفح من مخاطر منح صلاحيات إضافية التي يطلبها الامتداد على الموقع الحالي، وسيتعين عليك إختيار بما إذا كنت تقبل الطلب أو ترفضه.
إذا قبلت طلب uBOL بالحصول على صلاحيات إضافية على الموقع الحالي، فستتمكن من تصفية المحتوى بشكل أفضل للموقع الحالي.
بإمكانك اختيار وضع التصفية الافتراضية من خلال صفحة خيارات uBOL. إذا اخترت الوضع الأمثل أو الكامل باعتباره الوضع الافتراضي، فستحتاج إلى منح uBOL الإذن لقراءة البيانات وتعديلها على جميع مواقع الويب.
ضع في اعتبارك أن هذا لا يزال عملًا قيد التنفيذ، هذه هي الأهداف النهائية:
لا يمكنك تحديد الأذونات المستخدمة لاحقًا في التثبيت، تحديدك للأذونات سيكون خلال زيارتك لكل موقع.
تقريري تمامًا للموثوقية ولكفاءة وحدة المعالجة المركزية/الذاكرة.
uBOL صريح تمامًا، مما يعني أنه لا تحتاج إلى uBOL بشكل دائم لحدوث تصفية المحتوى، يتم إجراء تصفية المحتوى من خلال إضافة CSS/JS بشكل موثوق به بواسطة المتصفح نفسه بدلًا من الإضافة. هذا يعني أن uBOL نفسه لا يستهلك موارد وحدة المعالجة المركزية/الذاكرة أثناء استمراره في حظر المحتوى.
- Peter Lowe-un Reklam və izləyici server siyahısı
You can add more rulesets by visiting the options page -- click the _Cogs_ icon in the popup panel.
You can enable more rulesets by visiting the options page -- click the _Cogs_ icon in the popup panel.
uBOL is entirely declarative, meaning there is no need for a permanent uBOL process for the filtering to occur, and CSS/JS injection-based content filtering is performed reliably by the browser itself rather than by the extension. This means that uBOL itself does not consume CPU/memory resources while content blocking is ongoing -- uBOL's service worker process is required _only_ when you interact with the popup panel or the option pages.
uBOL does not require broad "read and modify data" permission at install time, hence its limited capabilities out of the box compared to uBlock Origin or other content blockers requiring broad "read and modify data" permissions at install time.
However, uBOL allows you to *explicitly* grant extended permissions on specific sites of your choice so that it can better filter on those sites using cosmetic filtering and scriptlet injections.
To grant extended permissions on a given site, open the popup panel and pick a higher filtering mode such as Optimal or Complete.
The browser will then warn you about the effects of granting the additional permissions requested by the extension on the current site, and you will have to tell the browser whether you accept or decline the request.
If you accept uBOL's request for additional permissions on the current site, it will be able to better filter content for the current site.
You can set the default filtering mode from uBOL's options page. If you pick the Optimal or Complete mode as the default one, you will need to grant uBOL the permission to read and modify data on all websites.
Keep in mind this is still a work in progress, with these end goals:
- No broad host permissions at install time -- extended permissions are granted explicitly by the user on a per-site basis.
- Entirely declarative for reliability and CPU/memory efficiency.
uBO Lite (uBOL) is a *permission-less* MV3-based content blocker.
uBO Lite (uBOL) гэта базаваны на MV3 блакавальнік змесціва.
The default ruleset corresponds to uBlock Origin's default filterset:
Прадвызначаны набор правіл адпавядае тыпавому набору фільтраў uBlock Origin:
- uBlock Origin's built-in filter lists
- Убудаваныя спісы фільтраў uBlock Origin
- EasyList
- EasyPrivacy
- Peter Lowe’s Ad and tracking server list
- Спіс сервераў з рэкламай і адсочвання ад Peter Lowe
You can add more rulesets by visiting the options page -- click the _Cogs_ icon in the popup panel.
Вы можаце ўключыць больш набораў правіл праз старонку налад -- націсніце на значок _Шасцярэнькі_ на ўсплывальнай панэлі.
uBOL is entirely declarative, meaning there is no need for a permanent uBOL process for the filtering to occur, and CSS/JS injection-based content filtering is performed reliably by the browser itself rather than by the extension. This means that uBOL itself does not consume CPU/memory resources while content blocking is ongoing -- uBOL's service worker process is required _only_ when you interact with the popup panel or the option pages.
uBOL does not require broad "read and modify data" permission at install time, hence its limited capabilities out of the box compared to uBlock Origin or other content blockers requiring broad "read and modify data" permissions at install time.
However, uBOL allows you to *explicitly* grant extended permissions on specific sites of your choice so that it can better filter on those sites using cosmetic filtering and scriptlet injections.
To grant extended permissions on a given site, open the popup panel and pick a higher filtering mode such as Optimal or Complete.
The browser will then warn you about the effects of granting the additional permissions requested by the extension on the current site, and you will have to tell the browser whether you accept or decline the request.
If you accept uBOL's request for additional permissions on the current site, it will be able to better filter content for the current site.
You can set the default filtering mode from uBOL's options page. If you pick the Optimal or Complete mode as the default one, you will need to grant uBOL the permission to read and modify data on all websites.
Keep in mind this is still a work in progress, with these end goals:
- No broad host permissions at install time -- extended permissions are granted explicitly by the user on a per-site basis.
- Entirely declarative for reliability and CPU/memory efficiency.
uBOL цалкам дэкларатыўны, то-бок не мае неабходнасці ў сталым uBOL працэсе дзеля фільтрацыі, а фільтрацыя змесціва на аснове інʼекцыі CSS/JS надзейна выконваецца пераважна самім браўзерам замест пашырэння. Гэта значыць, што uBOL не спажывае рэсурсаў працэсара/памяці пры блакаванні зместу -- службовы працэс uBOL патрэбны _толькі_ падчас узаемадзеяння з усплывальнай панэллю або наладамі.
uBO Lite (uBOL) е блокер за съдържание *без разрешения*, базиран на MV3.
uBO Lite (uBOL) е блокер за съдържание, базиран на MV3.
Наборът от правила по подразбиране съответства на набора от филтри по подразбиране на uBlock Origin:
@@ -7,24 +7,6 @@ uBO Lite (uBOL) е блокер за съдържание *без разреше
- EasyPrivacy
- Списък със сървъри на Peter Lowe за реклами и проследяване
Можете да добавите още набори от правила, като посетите страницата с опции – щракнете върху иконата _зъбно колело_ в изскачащия панел.
Можете да включите още набори от правила, като посетите страницата с опции – щракнете върху иконата „зъбно колело“ в изскачащия панел.
uBOL е изцяло декларативен, което означава, че няма нужда от постоянен процес на uBOL за филтриране, а филтрирането на съдържание, базирано на инжектиране на CSS/JS, се извършва надеждно от самия браузър, а не от разширението. Това означава, че самият uBOL не консумира ресурси на процесора/паметта, докато тече блокирането на съдържанието – работният процес на услугата на uBOL е необходим _само_ когато взаимодействате с изскачащия панел или страниците с опции.
uBOL не изисква широко разрешение за "четене и промяна на данни" по време на инсталиране, поради което възможностите му са ограничени в сравнение с uBlock Origin или други блокери на съдържание, изискващи широко разрешение за "четене и промяна на данни" по време на инсталиране.
Въпреки това uBOL ви позволява да предоставите *изрично* разширени разрешения за определени сайтове по ваш избор, за да може да филтрира по-добре тези сайтове, като използва козметично филтриране и инжектиране на скриптове.
За да предоставите разширени разрешения за даден сайт, отворете изскачащия панел и изберете по-висок режим на филтриране, например Оптимален или Пълен.
След това браузърът ще ви предупреди за последиците от предоставянето на допълнителните разрешения, поискани от разширението, за текущия сайт и ще трябва да кажете на браузъра дали приемате или отхвърляте искането.
Ако приемете искането на uBOL за допълнителни разрешения за текущия сайт, той ще може да филтрира по-добре съдържанието на текущия сайт.
Можете да зададете режима на филтриране по подразбиране от страницата с опции на uBOL. Ако изберете оптимален или пълен режим по подразбиране, ще трябва да предоставите на uBOL разрешение за четене и промяна на данни във всички уебсайтове.
Имайте предвид, че това все още е в процес на разработка с тези крайни цели:
- По време на инсталацията няма широки разрешения за хоста – разширените разрешения се предоставят изрично от потребителя за всеки сайт.
- Изцяло декларативен за надеждност и ефективност на процесора/паметта.
uBO Lite (uBOL) হল একটি *অনুমতি-হীন* MV3-ভিত্তিক কন্টেন্ট ব্লকার।
uBO Lite (uBOL) হলো একটি ম্যানিফেস্ট ভার্সন ৩ ভিত্তিক কনটেন্ট ব্লকার
পূর্ব নির্ধারিত নিয়ম সেট uBlock অরিজিনের ডিফল্ট ফিল্টারসেটের সাথে মিলে যায়:
@@ -7,24 +7,6 @@ uBO Lite (uBOL) হল একটি *অনুমতি-হীন* MV3-ভিত
- সহজ গোপনীয়তা
- পিটার লো এর বিজ্ঞাপন এবং ট্র্যাকিং সার্ভার তালিকা
আপনি অপশন পেজে গিয়ে আরও নিয়ম সেট যোগ করতে পারেন -- পপআপ প্যানেলে _Cogs_ আইকনে ক্লিক করুন।
তুমি অপশন পাতায় গিয়ে আরও নিয়ম যোগ করতে পারো -- পপআপ প্যানেলে _গিয়ার_ আইকনে ক্লিক করে।
uBOL সম্পূর্ণরূপে ঘোষণামূলক, অর্থাৎ ফিল্টারিং করতে একটি স্থায়ী uBOL প্রক্রিয়ার প্রয়োজন নেই, এবং CSS/JS ইনজেকশন-ভিত্তিক বিষয়বস্তু ফিল্টারিং এক্সটেনশনের পরিবর্তে ব্রাউজার নিজেই নির্ভরযোগ্যভাবে এই কাজ করে থাকে। এর মানে হল যে কন্টেন্ট ব্লকিং চলমান থাকা অবস্থায় uBOL নিজেই CPU/মেমরি রিসোর্স ব্যবহার করে না -- uBOL-এর পরিষেবার প্রক্রিয়ার প্রয়োজন শুধুমাত্র_ যখন আপনি পপআপ প্যানেল বা অপশন পেজগুলির সাথে ইন্টারঅ্যাক্ট করেন।
uBOL-এর ইন্সটল করার সময় বিস্তৃত "পড়ার ও ডেটা পরিবর্তন করার" অনুমতির প্রয়োজন হয় না, তাই ইউব্লক অরিজিন বা অন্যান্য কনটেন্ট ব্লকের তুলনায় এটির সীমিত ক্ষমতা বাক্সের বাইরে রয়েছে যার জন্য ইন্সটল করার সময় বিস্তৃত "ডেটা পড়ুন এবং পরিবর্তন করুন" অনুমতি প্রয়োজন।
যাইহোক, uBOL আপনাকে আপনার পছন্দের নির্দিষ্ট সাইটে *স্পষ্টভাবে* বর্ধিত অনুমতি প্রদান করে যাতে এটি কসমেটিক ফিল্টারিং এবং স্ক্রিপ্টলেট ইনজেকশন ব্যবহার করে সেই সাইটগুলিতে আরও ভাল ফিল্টার করতে পারে।
একটি সাইটে বর্ধিত অনুমতি প্রদানের জন্য, পপআপ প্যানেল খুলুন এবং একটি উচ্চতর ফিল্টারিং মোড বাছাই করুন যেমন অপটিমাল বা কমপ্লিট।
ব্রাউজারটি তখন বর্তমান সাইটে এক্সটেনশন দ্বারা অনুরোধ করা অতিরিক্ত অনুমতি প্রদানের প্রভাব সম্পর্কে আপনাকে সতর্ক করবে এবং আপনি অনুরোধটি গ্রহণ করবেন বা প্রত্যাখ্যান করবেন কিনা তা আপনার ব্রাউজারকে বলতে হবে।
আপনি যদি বর্তমান সাইটে অতিরিক্ত অনুমতির জন্য uBOL-এর অনুরোধ গ্রহণ করেন, তাহলে এটি বর্তমান সাইটের জন্য আরও ভালভাবে ফিল্টার করতে সক্ষম হবে।
আপনি uBOL এর বিকল্প পৃষ্ঠা থেকে ডিফল্ট ফিল্টারিং মোড সেট করতে পারেন। আপনি যদি অপটিমাল বা কমপ্লিট মোডটিকে ডিফল্ট হিসেবে বেছে নেন, তাহলে আপনাকে uBOL-কে সমস্ত ওয়েবসাইটের ডেটা পড়তে এবং পরিবর্তন করার অনুমতি দিতে হবে।
মনে রাখবেন এই শেষ লক্ষ্যগুলির ফলাফলের সাথে এখনও সংস্করণ কাজ চলছে:
- ইনস্টল করার সময় কোনও বিস্তৃত অনুমতি নেই -- বর্ধিত অনুমতিগুলি প্রতি-সাইট ভিত্তিতে ব্যবহারকারীর দ্বারা স্পষ্টভাবে প্র্রদান করা হয়।
- নির্ভরযোগ্যতা এবং CPU/মেমরি দক্ষতার জন্য সম্পূর্ণরূপে পূর্বঘোষণামুূলক।
uBO Lite (uBOL) zo ur stanker noazadurioù diazezet war ar manifesto MV3.
Ar reolennoù dre ziouer a glot gant silañ dre ziouer uBlock Origin:
- Rolloù siloù genidik a uBlock Origin
- EasyList
- EasyPrivacy
- Roll ar servijerioù brudañ ha heuliañ eus Peter Lowe
Tu zo deoc'h ouzhpennañ reolennoù all en arventennoù -- klikit war an ikon _kendentadur_ er banell popup.
Disklêriañ a ra uBOL penn-da-benn, da lavaret eo n'eus ket ezhomm eus un argerzh uBOL padus evit ma c'hoarvezfe ar silañ, ha silañ endalc'hadoù diazezet war enlakaat CSS/JS a vez graet en un doare fizius gant ar merdeer e-unan kentoc'h eget gant an astenn. Kement-se a dalvez ne vez ket gounezet gant uBOL e-unan arc'hwelioù CPU/memor e-pad ma vez stanket an endalc'hadoù -- ezhomm zo eus argerzh al labourer servij uBOL _nemet_ pa vez etregweredet gant ar banell digeriñ pe ar pajennoù dibarzhioù.
uBO Lite (uBOL) is a *permission-less* MV3-based content blocker.
uBO Lite (uBOL) je blokator sadržaja baziran na MV3.
The default ruleset corresponds to uBlock Origin's default filterset:
Zadani skup pravila odgovara zadanom skupu filtera uBlock Origin:
- uBlock Origin's built-in filter lists
- UBlock Origin ugrađene liste filtera
- EasyList
- EasyPrivacy
- Peter Lowe’s Ad and tracking server list
- Peter Lowe-ova lista servera za oglase i praćenje
You can add more rulesets by visiting the options page -- click the _Cogs_ icon in the popup panel.
Možete omogućiti više skupova pravila posjetom stranice s opcijama -- kliknite na ikonu _Cogs_ u skočnom panelu.
uBOL is entirely declarative, meaning there is no need for a permanent uBOL process for the filtering to occur, and CSS/JS injection-based content filtering is performed reliably by the browser itself rather than by the extension. This means that uBOL itself does not consume CPU/memory resources while content blocking is ongoing -- uBOL's service worker process is required _only_ when you interact with the popup panel or the option pages.
uBOL does not require broad "read and modify data" permission at install time, hence its limited capabilities out of the box compared to uBlock Origin or other content blockers requiring broad "read and modify data" permissions at install time.
However, uBOL allows you to *explicitly* grant extended permissions on specific sites of your choice so that it can better filter on those sites using cosmetic filtering and scriptlet injections.
To grant extended permissions on a given site, open the popup panel and pick a higher filtering mode such as Optimal or Complete.
The browser will then warn you about the effects of granting the additional permissions requested by the extension on the current site, and you will have to tell the browser whether you accept or decline the request.
If you accept uBOL's request for additional permissions on the current site, it will be able to better filter content for the current site.
You can set the default filtering mode from uBOL's options page. If you pick the Optimal or Complete mode as the default one, you will need to grant uBOL the permission to read and modify data on all websites.
Keep in mind this is still a work in progress, with these end goals:
- No broad host permissions at install time -- extended permissions are granted explicitly by the user on a per-site basis.
- Entirely declarative for reliability and CPU/memory efficiency.
uBOL je potpuno deklarativno, što znači da nema potrebe za trajnim uBOL procesom da bi se filtriranje dogodilo, a filtriranje sadržaja zasnovano na CSS/JS injekcijama se pouzdano izvodi od strane samog pretraživača, a ne ekstenzije. To znači da sam uBOL ne troši CPU/memorijske resurse dok je blokiranje sadržaja u toku -- proces uBOL-a servisnog radnika je potreban _samo_ kada stupite u interakciju sa iskačućim panelom ili stranicama sa opcijama.
L'uBO Lite (uBOL) és un blocador de contingut *sense permisos* basat en MV3.
L'uBO Lite (uBOL) és un blocador de contingut basat en MV3.
El conjunt de regles per defecte correspon al conjunt de filtres per defecte d'uBlock Origin:
@@ -7,26 +7,8 @@ El conjunt de regles per defecte correspon al conjunt de filtres per defecte d'u
- EasyPrivacy
- Llista de servidors de seguiment i anuncis de Peter Lowe
Podeu afegir més conjunts de regles si visiteu la pàgina d'opcions: feu clic a la icona _Cogs_ al tauler emergent.
Podeu habilitar més conjunts de regles si visiteu la pàgina d'opcions: feu clic a la icona _Cogs_ al tauler emergent.
L'uBOL és totalment declaratiu, és a dir, no cal un procés uBOL permanent perquè es produeixi el filtratge, i el filtratge de contingut basat en injecció CSS/JS es realitza de manera fiable pel propi navegador més que per l'extensió.
Això vol dir que l'uBOL en si no consumeix recursos de CPU/memòria mentre el bloqueig de contingut està en curs; el procés de treballador de servei d'uBOL només es requereix quan interactueu amb el tauler emergent o les pàgines d'opcions.
L'uBOL no requereix un ampli permís de "lectura i modificació de dades" en el moment de la instal·lació, per tant, les seves capacitats limitades en comparació amb l'uBlock Origin o altres blocadors de contingut que requereixen amplis permisos de "lectura i modificació de dades" en el moment de la instal·lació.
Tanmateix, l'uBOL us permet concedir *explícitament* permisos ampliats en llocs específics que trieu perquè pugui filtrar millor en aquests llocs mitjançant filtres cosmètics i injeccions de scriptlet.
Per concedir permisos ampliats en un lloc determinat, obriu el tauler emergent i seleccioneu un mode de filtrat superior, com ara Òptim o Complet.
Aleshores, el navegador us avisarà sobre els efectes de la concessió dels permisos addicionals sol·licitats per l'extensió al lloc actual, i haureu d'indicar-li al navegador si accepteu o rebutgeu la sol·licitud.
Si accepteu la sol·licitud d'uBOL de permisos addicionals al lloc actual, podrà filtrar millor el contingut del lloc actual.
Podeu establir el mode de filtratge per defecte des de la pàgina d'opcions d'uBOL. Si trieu el mode Òptim o Complet per defecte, haureu de concedir a l'uBOL el permís per llegir i modificar dades a tots els llocs web.
Tingueu en compte que encara és un treball en curs, amb aquests objectius finals:
- No hi ha permisos d'amfitrió amplis en el moment de la instal·lació; els permisos ampliats els concedeix explícitament l'usuari per lloc.
- Totalment declaratiu per a la fiabilitat i l'eficiència de la CPU/memòria.
uBO Lite (uBOL) je blokovač obsahu vyžadující méně oprávnění, založený na MV3.
uBO Lite (uBOL) je blokovač obsahu založený na MV3.
Výchozí sada pravidel koresponduje k výchozím sadám filtrů uBlock Origin:
@@ -7,24 +7,6 @@ Výchozí sada pravidel koresponduje k výchozím sadám filtrů uBlock Origin:
- EasyPrivacy
- Peter Lowe’s Ad and tracking server list
Můžete přidat více sad pravidel navštívením stránky nastavení -- klikněte na ikonu ozubených kol ve vyskakovácím panelu.
Další sady pravidel můžete povolit na stránce nastavení - klikněte na ikonu _Ozubeného kolečka_ ve vyskakovacím panelu.
uBOL je zcela deklarativní, což znamená, že pro filtrování není potřeba permanentní proces uBOL a filtrování obsahu založené na vstřikování CSS/JS je spolehlivě prováděno samotným prohlížečem, nikoli rozšířením. To znamená, že samotný uBOL nespotřebovává zdroje CPU/paměti, zatímco probíhá blokování obsahu – proces servisního pracovníka uBOL je vyžadován _pouze_ při interakci s vyskakovacím panelem nebo stránkami nastavení.
uBOL nevyžaduje rozsáhlá oprávnění ke "čtení a úpravě dat" v době instalace, a proto má ihned po instalaci omezené možnosti ve srovnání s uBlock Origin nebo jinými blokovači obsahu, které vyžadují rozsáhlá oprávnění ke "čtení a úpravě dat" v době instalace.
Nicméně, uBOL vám umožňuje *explicitně* udělit rozšířená oprávnění na konkrétních webech podle vašeho výběru, aby mohl na těchto webech lépe filtrovat pomocí kosmetického filtrování a vstřikování skriptů.
Chcete-li na daném webu udělit rozšířená oprávnění, otevřete vyskakovací panel a vyberte vyšší režim filtrování, například optimální nebo kompletní.
Prohlížeč vás poté upozorní na důsledky udělení dalších oprávnění požadovaných rozšířením na aktuálním webu a vy budete muset prohlížeči sdělit, zda žádost přijímáte nebo odmítáte.
Pokud přijmete žádost uBOL o další oprávnění na aktuálním webu, bude moci lépe filtrovat obsah aktuálního webu.
Výchozí režim filtrování můžete nastavit na stránce nastavení uBOL. Pokud jako výchozí zvolíte režim optimální nebo kompletní, budete muset uBOL udělit oprávnění ke čtení a úpravě dat na všech webových stránkách.
Mějte na paměti, že toto je stále nedokončená práce s těmito konečnými cíli:
- Žádná rozsáhlá oprávnění hostitele v době instalace -- rozšířená oprávnění uděluje explicitně uživatel na jednotlivých stránkách.
- Zcela deklarativní pro spolehlivost a efektivitu CPU/paměti.
uBO Lite (uBOL) is a *permission-less* MV3-based content blocker.
uBO Lite (uBOL) is an MV3-based content blocker.
The default ruleset corresponds to uBlock Origin's default filterset:
@@ -7,24 +7,6 @@ The default ruleset corresponds to uBlock Origin's default filterset:
- EasyPrivacy
- Peter Lowe’s Ad and tracking server list
You can add more rulesets by visiting the options page -- click the _Cogs_ icon in the popup panel.
You can enable more rulesets by visiting the options page -- click the _Cogs_ icon in the popup panel.
uBOL is entirely declarative, meaning there is no need for a permanent uBOL process for the filtering to occur, and CSS/JS injection-based content filtering is performed reliably by the browser itself rather than by the extension. This means that uBOL itself does not consume CPU/memory resources while content blocking is ongoing -- uBOL's service worker process is required _only_ when you interact with the popup panel or the option pages.
uBOL does not require broad "read and modify data" permission at install time, hence its limited capabilities out of the box compared to uBlock Origin or other content blockers requiring broad "read and modify data" permissions at install time.
However, uBOL allows you to *explicitly* grant extended permissions on specific sites of your choice so that it can better filter on those sites using cosmetic filtering and scriptlet injections.
To grant extended permissions on a given site, open the popup panel and pick a higher filtering mode such as Optimal or Complete.
The browser will then warn you about the effects of granting the additional permissions requested by the extension on the current site, and you will have to tell the browser whether you accept or decline the request.
If you accept uBOL's request for additional permissions on the current site, it will be able to better filter content for the current site.
You can set the default filtering mode from uBOL's options page. If you pick the Optimal or Complete mode as the default one, you will need to grant uBOL the permission to read and modify data on all websites.
Keep in mind this is still a work in progress, with these end goals:
- No broad host permissions at install time -- extended permissions are granted explicitly by the user on a per-site basis.
- Entirely declarative for reliability and CPU/memory efficiency.
Mae'r set reolau ddiofyn yn cyfateb i set hidlo diofyn uBlock Origin:
- uBlock Origin's built-in filter lists
- EasyList
- EasyPrivacy
- Peter Lowe’s Ad and tracking server list
You can enable more rulesets by visiting the options page -- click the _Cogs_ icon in the popup panel.
uBOL is entirely declarative, meaning there is no need for a permanent uBOL process for the filtering to occur, and CSS/JS injection-based content filtering is performed reliably by the browser itself rather than by the extension. This means that uBOL itself does not consume CPU/memory resources while content blocking is ongoing -- uBOL's service worker process is required _only_ when you interact with the popup panel or the option pages.
uBO Lite (uBOL) er en *tilladelsesløs* MV3-baseret indholdsblocker.
uBO Lite (uBOL) er en MV3-baseret indholdsblocker.
Standardregelsættet svarer til uBlock Origins standardfiltersæt:
@@ -7,24 +7,6 @@ Standardregelsættet svarer til uBlock Origins standardfiltersæt:
- EasyPrivacy
- Peter Lowe’s Ad and tracking server list
Flere regelsæt kan tilføjes ved at gå til indstillingssiden -- klik på ikonet _Cogs_ i pop op-panelet.
Flere regelsæt kan aktiveres ved at gå til indstillingssiden -- klik på ikonet _Tandhjul_ i pop op-panelet.
uBOL er fuldstændig deklarativ, hvilket betyder, at ingen permanent uBOL-proces behøves for at filtreringen kan finde sted, og CSS/JS-injektionsbaseret indholdsfiltrering udføres pålideligt af browseren selv i stedet for af udvidelsen. Dette betyder, at uBOL ikke selv forbruger CPU-/hukommelsesressourcer under indholdsblokeringen -- uBOLs tjenestearbejdsproces er _kun_ nødvendig under interaktion med pop op-panelet eller indstillingssiderne.
uBOL kræver ikke en omfattende "læse og ændre data" tilladelse under installationen, derfor dens begrænsede egenskaber fra start af sammenlignet med uBlock Origin eller andre indholdsblockere, som kræver omfattende "læse/ændre data" tilladelser under installationen.
uBOL giver dog mulighed for *eksplicit* at tildele udvidede tilladelser på bestemte websteder efter eget valg, så den bedre kan filtrere på disse websteder vha. kosmetisk filtrering og scriptlet-injektioner.
For at tildele udvidede tilladelser på et givent websted, åbn pop op-panelet og vælg en højere filtreringstilstand, såsom Optimal eller Komplet.
Browseren advarer derefter om virkningerne af de ekstra tildelte tilladelser, som udvidelsen anmoder om på det aktuelle websted, og man vil skulle fortælle browseren, hvorvidt anmodningen accepteres eller afslås.
Accepteres uBOLs anmodning om ekstra tilladelser på det aktuelle websted, vil den bedre kunne filtrere indhold på webstedet.
Standardfiltreringstilstanden kan angives via uBOLs indstillingsside. Hvis tilstanden Optimal eller Komplet vælges som standardtilstand, skal uBOL tildeles tilladelse til at læse og ændre data på alle websteder.
Husk dog, at dette stadig er et igangværende arbejde med disse slutmål:
- Ingen omfattende værtstilladelser under installationen -- udvidede tilladelser tildeles eksplicit af brugeren på webstedsbasis.
- Fuldstændig deklarativ for pålidelighed og CPU-/hukommelseseffektivitet.
uBO Lite (uBOL) ist ein Inhaltsblocker, der *ohne Berechtigungen* auskommt und auf MV3 basiert.
uBO Lite (uBOL) ist ein MV3-basierter Inhaltsblocker.
Die Standardregeln entsprechen den Standardfiltern von uBlock Origin:
@@ -7,24 +7,6 @@ Die Standardregeln entsprechen den Standardfiltern von uBlock Origin:
- EasyPrivacy
- Peter Lowe’s Ad and tracking server list
Sie können weitere Regeln hinzufügen, indem Sie die Optionen aufrufen — klicken Sie dazu im Pop-up-Fenster auf das Symbol mit den _Zahnrädern_.
Sie können weitere Regeln aktivieren, indem Sie die Einstellungen aufrufen — klicken Sie dazu im Pop-up-Fenster auf das Symbol mit den _Zahnrädern_.
uBOL ist vollständig deklarativ, d. h. es ist kein dauerhafter uBOL-Prozess für das Filtern erforderlich, und die auf CSS/JS-Injektion basierende Inhaltsfilterung wird zuverlässig vom Browser selbst und nicht von der Erweiterung durchgeführt. Das bedeutet, dass uBOL selbst keine CPU-/Speicherressourcen verbraucht, während der Inhalt blockiert wird — der uBOL-Service-Worker-Prozess wird _nur_ benötigt, wenn Sie mit dem Pop-up-Fenster oder den Optionen interagieren.
uBOL erfordert bei der Installation keine weitreichende Berechtigung zum Lesen und Ändern von Daten, daher sind die Möglichkeiten im Vergleich zu uBlock Origin oder anderen Inhaltsblockern, die bei der Installation weitreichende Berechtigungen zum Lesen und Ändern von Daten erfordern, von vornherein begrenzt.
Allerdings können Sie mit uBOL *explizit* erweiterte Berechtigungen für bestimmte Websites Ihrer Wahl erteilen, sodass diese Websites durch kosmetisches Filtern und Scriptlet-Injektionen besser gefiltert werden können.
Um erweiterte Berechtigungen für eine bestimmte Website zu erteilen, öffnen Sie das Pop-up-Fenster und wählen Sie einen stärkeren Filtermodus wie »Optimal« oder »Vollständig«.
Der Browser warnt Sie anschließend über die Auswirkungen der zusätzlichen Berechtigungen, die von der Erweiterung für die aktuelle Website angefordert werden, und Sie können entscheiden, ob Sie zustimmen oder ablehnen.
Wenn Sie die Anfrage von uBOL nach zusätzlichen Berechtigungen für die aktuelle Website zustimmen, kann uBOL die Inhalte für die aktuelle Website besser filtern.
Sie können den Standardfiltermodus in den Optionen von uBOL festlegen. Wenn Sie den Modus »Optimal« oder »Vollständig« als Standardmodus wählen, müssen Sie uBOL die Berechtigung erteilen, Daten auf allen Websites lesen und ändern zu dürfen.
Denken Sie daran, dass sich dieses Projekt noch in Entwicklung befindet und folgende Ziele verfolgt:
- Keine weitreichenden Host-Berechtigungen bei der Installation — erweiterte Berechtigungen werden explizit von Ihnen für jede einzelne Website erteilt.
- Vollständig deklarativ für Zuverlässigkeit und CPU-/Speichereffizienz.
Το uBO Lite (uBOL) είναι ένας blocker περιεχομένου *χωρίς άδειες* που βασίζεται σε MV3.
Το uBO Lite (uBOL) είναι εργαλείο φραγής περιεχομένου, που βασίζεται στο MV3.
Το προεπιλεγμένο σύνολο κανόνων αντιστοιχεί στο προεπιλεγμένο σύνολο φίλτρων του uBlock Origin:
@@ -7,24 +7,6 @@
- EasyPrivacy
- Peter Lowe’s Ad and tracking server list
Μπορείτε να προσθέσετε περισσότερα σύνολα κανόνων μεταβαίνοντας στη σελίδα επιλογών -- κάντε κλικ στο εικονίδιο _Cogs_ στον αναδυόμενο πίνακα.
Μπορείτε να προσθέσετε περισσότερα σύνολα κανόνων από τη σελίδα επιλογών -- κάντε κλικ στο εικονίδιο _γρανάζι_ στον αναδυόμενο πίνακα.
Το uBOL είναι εξ'ολοκλήρου δηλωτικό, πράγμα που σημαίνει ότι δεν υπάρχει ανάγκη για μόνιμη διαδικασία uBOL γιανα πραγματοποιηθεί το φιλτράρισμα, και το φιλτράρισμα περιεχομένου που βασίζεται σε έγχυση CSS/JS εκτελείται αξιόπιστα από το ίδιο το πρόγραμμα περιήγησης και όχι από την επέκταση. Αυτό σημαίνει ότι το ίδιο το uBOL δεν καταναλώνει πόρους CPU/μνήμης ενώ ο αποκλεισμός περιεχομένου είναι σε εξέλιξη -- η διαδικασία του service worker του uBOL απαιτείται _μόνο_ όταν αλληλεπιδράτε με τον αναδυόμενο πίνακα ή τις σελίδες επιλογών.
Το uBOL δεν απαιτεί ευρεία άδεια "ανάγνωσης και τροποποίησης δεδομένων" κατά τον χρόνο εγκατάστασης, επομένως έχει εξαρχής περιορισμένες δυνατότητές σε σύγκριση με το uBlock Origin ή άλλα προγράμματα αποκλεισμού περιεχομένου που απαιτούν ευρείες άδειες "ανάγνωσης/τροποποίησης δεδομένων" κατά την εγκατάσταση.
Ωστόσο, το uBOL σάς επιτρέπει *ρητά* να εκχωρείτε εκτεταμένες άδειες σε συγκεκριμένους ιστότοπους της επιλογής σας, ώστε να μπορεί να φιλτράρει καλύτερα σε αυτούς τους ιστότοπους χρησιμοποιώντας κοσμητικό φιλτράρισμα και έγχυση scriptlet.
Για να εκχωρήσετε εκτεταμένα δικαιώματα σε έναν δεδομένο ιστότοπο, ανοίξτε το αναδυόμενο πλαίσιο και επιλέξτε μια υψηλότερη λειτουργία φιλτραρίσματος, όπως Βέλτιστη ή Ολοκληρωμένη.
Στη συνέχεια, το πρόγραμμα περιήγησης θα σας προειδοποιήσει για τα αποτελέσματα της χορήγησης των πρόσθετων δικαιωμάτων που ζητούνται από την επέκταση στον τρέχοντα ιστότοπο και θα πρέπει να ενημερώσετε το πρόγραμμα περιήγησης εάν αποδέχεστε ή απορρίπτετε το αίτημα.
Εάν αποδεχτείτε το αίτημα του uBOL για πρόσθετα δικαιώματα στον τρέχοντα ιστότοπο, θα μπορεί να φιλτράρει καλύτερα το περιεχόμενο για τον τρέχοντα ιστότοπο.
Μπορείτε να ορίσετε την προεπιλεγμένη λειτουργία φιλτραρίσματος από τη σελίδα επιλογών του uBOL. Εάν επιλέξετε τη λειτουργία Βέλτιστη ή Ολοκληρωμένη ως προεπιλεγμένη, θα πρέπει να εκχωρήσετε στην uBOL την άδεια ανάγνωσης και τροποποίησης δεδομένων σε όλους τους ιστότοπους.
Λάβετε υπόψη ότι αυτό είναι ακόμη ένα έργο σε εξέλιξη, με αυτούς τους τελικούς στόχους:
- Να μην υπάρχουν ευρείες άδειες hosts κατά την εγκατάσταση -- οι εκτεταμένες άδειες παραχωρούνται ρητά από τον χρήστη σε βάση ανά τοποθεσία.
- Εντελώς δηλωτικό για αξιοπιστία και απόδοση CPU/μνήμης.
uBO Lite (uBOL) is a *permission-less* MV3-based content blocker.
uBO Lite (uBOL) is an MV3-based content blocker.
The default ruleset corresponds to uBlock Origin's default filterset:
@@ -7,24 +7,6 @@ The default ruleset corresponds to uBlock Origin's default filterset:
- EasyPrivacy
- Peter Lowe’s Ad and tracking server list
You can add more rulesets by visiting the options page -- click the _Cogs_ icon in the popup panel.
You can enable more rulesets by visiting the options page -- click the _Cogs_ icon in the popup panel.
uBOL is entirely declarative, meaning there is no need for a permanent uBOL process for the filtering to occur, and CSS/JS injection-based content filtering is performed reliably by the browser itself rather than by the extension. This means that uBOL itself does not consume CPU/memory resources while content blocking is ongoing -- uBOL's service worker process is required _only_ when you interact with the popup panel or the option pages.
uBOL does not require broad "read and modify data" permission at install time, hence its limited capabilities out of the box compared to uBlock Origin or other content blockers requiring broad "read and modify data" permissions at install time.
However, uBOL allows you to *explicitly* grant extended permissions on specific sites of your choice so that it can better filter on those sites using cosmetic filtering and scriptlet injections.
To grant extended permissions on a given site, open the popup panel and pick a higher filtering mode such as Optimal or Complete.
The browser will then warn you about the effects of granting the additional permissions requested by the extension on the current site, and you will have to tell the browser whether you accept or decline the request.
If you accept uBOL's request for additional permissions on the current site, it will be able to better filter content for the current site.
You can set the default filtering mode from uBOL's options page. If you pick the Optimal or Complete mode as the default one, you will need to grant uBOL the permission to read and modify data on all websites.
Keep in mind this is still a work in progress, with these end goals:
- No broad host permissions at install time -- extended permissions are granted explicitly by the user on a per-site basis.
- Entirely declarative for reliability and CPU/memory efficiency.
uBO Lite (uBOL) is a *permission-less* MV3-based content blocker.
uBO Lite (uBOL) is an MV3-based content blocker.
The default ruleset corresponds to uBlock Origin's default filterset:
@@ -7,24 +7,6 @@ The default ruleset corresponds to uBlock Origin's default filterset:
- EasyPrivacy
- Peter Lowe’s Ad and tracking server list
You can add more rulesets by visiting the options page -- click the _Cogs_ icon in the popup panel.
You can enable more rulesets by visiting the options page -- click the _Cogs_ icon in the popup panel.
uBOL is entirely declarative, meaning there is no need for a permanent uBOL process for the filtering to occur, and CSS/JS injection-based content filtering is performed reliably by the browser itself rather than by the extension. This means that uBOL itself does not consume CPU/memory resources while content blocking is ongoing -- uBOL's service worker process is required _only_ when you interact with the popup panel or the option pages.
uBOL does not require broad "read and modify data" permission at install time, hence its limited capabilities out of the box compared to uBlock Origin or other content blockers requiring broad "read and modify data" permissions at install time.
However, uBOL allows you to *explicitly* grant extended permissions on specific sites of your choice so that it can better filter on those sites using cosmetic filtering and scriptlet injections.
To grant extended permissions on a given site, open the popup panel and pick a higher filtering mode such as Optimal or Complete.
The browser will then warn you about the effects of granting the additional permissions requested by the extension on the current site, and you will have to tell the browser whether you accept or decline the request.
If you accept uBOL's request for additional permissions on the current site, it will be able to better filter content for the current site.
You can set the default filtering mode from uBOL's options page. If you pick the Optimal or Complete mode as the default one, you will need to grant uBOL the permission to read and modify data on all websites.
Keep in mind this is still a work in progress, with these end goals:
- No broad host permissions at install time -- extended permissions are granted explicitly by the user on a per-site basis.
- Entirely declarative for reliability and CPU/memory efficiency.
uBO Lite (uBOL) es un bloqueador de contenido con *menos permisos* basado en MV3.
uBO Lite (uBOL) es un bloqueador de contenido basado en MV3.
Por defecto ya trae configuradas las siguientes listas de filtros:
@@ -7,24 +7,6 @@ Por defecto ya trae configuradas las siguientes listas de filtros:
- EasyPrivacy
- Peter Lowe’s Ad and tracking server list
Puedes añadir más conjuntos de reglas visitando la página de opciones, haz clic en el icono de _engranaje_ del panel emergente.
Puedes habilitar más conjuntos de reglas visitando la página de opciones, haz clic en el icono de _engranaje_ del panel emergente.
uBOL es completamente declarativo, lo que significa que no hay necesidad de un proceso uBOL permanente para que se produzca el filtrado, y el filtrado de contenido basado en la inyección de CSS/JS se realiza de forma confiable por el propio navegador en lugar de la extensión. Esto significa que uBOL en sí mismo no consume recursos de CPU/memoria mientras el bloqueo de contenido está en curso, el proceso service worker de uBOL se requiere _solo_ cuando se interactúa con el panel emergente o las páginas de opciones.
uBOL no requiere amplios permisos para "leer y modificar datos" en el momento de la instalación, de ahí sus capacidades limitadas en comparación con uBlock Origin u otros bloqueadores de contenido que requieren amplios permisos para "leer y modificar datos" en el momento de la instalación.
Sin embargo, uBOL te permite otorgar *explícitamente* permisos extendidos en sitios específicos de tu elección para que pueda filtrar mejor en esos sitios usando filtrado cosmético e inyecciones de scriptlet.
Para otorgar permisos extendidos en un sitio determinado, abre el panel emergente y elige un modo de filtrado superior, como óptimo o completo.
Después el navegador te advertirá sobre los efectos de otorgar los permisos adicionales solicitados por la extensión en el sitio actual, y deberás indicar al navegador si aceptas o rechazas la solicitud.
Si aceptas la solicitud de uBOL para permisos adicionales en el sitio actual, será capaz de filtrar mejor el contenido para el sitio actual.
Puedes establecer el modo de filtrado predeterminado desde la página de opciones de uBOL. Si eliges como predeterminado el modo óptimo o completo, tendrás que otorgar a uBOL el permiso para leer y modificar datos en todos los sitios web.
Téngase en cuenta que esto todavía es un trabajo en progreso, con estos objetivos finales:
- Sin amplios permisos de host en el momento de la instalación, los permisos ampliados son otorgados explícitamente por el usuario en cada sitio.
- Completamente declarativo para confiabilidad y eficiencia de la CPU/memoria.
uBO Lite (uBOL) on MV3-l põhinev *lubadeta* sisutõkestaja.
uBO Lite (uBOL) on MV3-l põhinev sisutõkestaja.
Tavaline reeglitekogum vastab uBlock Origini tavalisele filtritekogumile:
@@ -7,24 +7,6 @@ Tavaline reeglitekogum vastab uBlock Origini tavalisele filtritekogumile:
- EasyPrivacy
Peter Lowe'i reklaamide ja jälitusserverite loend
Reeglitekogumeid saate lisada valikute lehelt ehk avanenud paneelis klõpsake _Cogs_ ikooni.
Rohkem reegleid valikutest ehk toksake _Cogs_ ikooni hüpikpaneelis.
uBOL on läbinisti deklaratiivne ehk filtreerimiseks pole vaja kogu aeg töötavat uBOLi protsessi ja CSS/JS süstipõhist sisu filtreerib tegelikult brauser, mitte laiendus. Teisisõnu, uBOL ei kasuta sisu tõkestamisel protsessori/mälu ressursse. uBOLi teenuse toimimise protsessi on vaja _vaid_ juhul, kui kasutate hüpikpaneeli või valikute lehekülgi.
uBOL ei nõua paigaldamise ajal teadatuntud andmete lugemise ja muutmise luba, seega võrreldes seda nõudva äpiga uBlock Origin või muu sisutõkestiga on uBOL-i piiratus üks selle funktsioonidest.
Kuid uBOL võimaldab *selgesõnaliselt* anda täpsemaid lubasid teie valitud veebilehtedele, et neid saaks paremini filtreerida ilufiltrite ja skriptisüstidega.
Veebilehele täpsustatud lubade andmiseks ava hüpikpaneel ja valige põhjalikum filtreerimisrežiim, nagu Optimaalne või Põhjalik.
The browser will then warn you about the effects of granting the additional permissions requested by the extension on the current site, and you will have to tell the browser whether you accept or decline the request.
If you accept uBOL's request for additional permissions on the current site, it will be able to better filter content for the current site.
You can set the default filtering mode from uBOL's options page. Kui määrate optimaalse või põhjaliku režiimi tavaliseks, peate andma uBOLile loa kõikide veebilehtede andmete lugemiseks ja muutmiseks.
Keep in mind this is still a work in progress, with these end goals:
- No broad host permissions at install time -- extended permissions are granted explicitly by the user on a per-site basis.
- Entirely declarative for reliability and CPU/memory efficiency.
uBO Lite (uBOL) is a *permission-less* MV3-based content blocker.
uBO Lite (uBOL) is an MV3-based content blocker.
The default ruleset corresponds to uBlock Origin's default filterset:
Lehenespenez, iragazki-zerrenda hauek ditu konfiguratuta:
- uBlockOrigin's built-in filter lists
- EasyList
- EasyPrivacy
- Peter Lowe’s Ad and tracking server list
UblockOrigin-eko filtro lista
ZerrendaErraza
PribazitateaErraza
Peter Lowe-ren Ad and tracker zerrenda
You can add more rulesets by visiting the options page -- click the _Cogs_ icon in the popup panel.
Ruleta gehiago aktibatu ahal duzu aukerak orria --klikatu _Cogs_ ikonoa panelearen lehioan
uBOL is entirely declarative, meaning there is no need for a permanent uBOL process for the filtering to occur, and CSS/JS injection-based content filtering is performed reliably by the browser itself rather than by the extension. This means that uBOL itself does not consume CPU/memory resources while content blocking is ongoing -- uBOL's service worker process is required _only_ when you interact with the popup panel or the option pages.
uBOL does not require broad "read and modify data" permission at install time, hence its limited capabilities out of the box compared to uBlock Origin or other content blockers requiring broad "read and modify data" permissions at install time.
However, uBOL allows you to *explicitly* grant extended permissions on specific sites of your choice so that it can better filter on those sites using cosmetic filtering and scriptlet injections.
To grant extended permissions on a given site, open the popup panel and pick a higher filtering mode such as Optimal or Complete.
The browser will then warn you about the effects of granting the additional permissions requested by the extension on the current site, and you will have to tell the browser whether you accept or decline the request.
If you accept uBOL's request for additional permissions on the current site, it will be able to better filter content for the current site.
You can set the default filtering mode from uBOL's options page. If you pick the Optimal or Complete mode as the default one, you will need to grant uBOL the permission to read and modify data on all websites.
Keep in mind this is still a work in progress, with these end goals:
- No broad host permissions at install time -- extended permissions are granted explicitly by the user on a per-site basis.
- Entirely declarative for reliability and CPU/memory efficiency.
uBOL guztiz deklaratiboa da, hau da, ez dago uBOL prozesu iraunkor baten beharrik iragazketa gertatzeko, eta CSS/JS injekzioan oinarritutako edukien iragazketa nabigatzaileak berak egiten du fidagarritasunez, luzapenaren arabera beharrean. Horrek esan nahi du uBOLek berak ez duela CPU/memoria baliabiderik kontsumitzen edukien blokeoa martxan dagoen bitartean... uBOLren zerbitzuko langileen prozesua _only_ behar da popup panelarekin edo aukera orriekin elkarreragiten denean.
uBO Lite (uBOL) is a *permission-less* MV3-based content blocker.
uBO Lite (uBOL) is an MV3-based content blocker.
The default ruleset corresponds to uBlock Origin's default filterset:
مجموعه قوانین پیش فرض آن مطابق با مجموعه قوانین پیش فرض uBlock Origin است:
- uBlock Origin's built-in filter lists
- EasyList
- EasyPrivacy
- Peter Lowe’s Ad and tracking server list
You can add more rulesets by visiting the options page -- click the _Cogs_ icon in the popup panel.
You can enable more rulesets by visiting the options page -- click the _Cogs_ icon in the popup panel.
uBOL is entirely declarative, meaning there is no need for a permanent uBOL process for the filtering to occur, and CSS/JS injection-based content filtering is performed reliably by the browser itself rather than by the extension. This means that uBOL itself does not consume CPU/memory resources while content blocking is ongoing -- uBOL's service worker process is required _only_ when you interact with the popup panel or the option pages.
uBOL does not require broad "read and modify data" permission at install time, hence its limited capabilities out of the box compared to uBlock Origin or other content blockers requiring broad "read and modify data" permissions at install time.
However, uBOL allows you to *explicitly* grant extended permissions on specific sites of your choice so that it can better filter on those sites using cosmetic filtering and scriptlet injections.
To grant extended permissions on a given site, open the popup panel and pick a higher filtering mode such as Optimal or Complete.
The browser will then warn you about the effects of granting the additional permissions requested by the extension on the current site, and you will have to tell the browser whether you accept or decline the request.
If you accept uBOL's request for additional permissions on the current site, it will be able to better filter content for the current site.
You can set the default filtering mode from uBOL's options page. If you pick the Optimal or Complete mode as the default one, you will need to grant uBOL the permission to read and modify data on all websites.
Keep in mind this is still a work in progress, with these end goals:
- No broad host permissions at install time -- extended permissions are granted explicitly by the user on a per-site basis.
- Entirely declarative for reliability and CPU/memory efficiency.
Voit lisätä sääntömäärityksiä asetussivulta -- paina ponnahduspaneelin _Rataskuvaketta_.
Voit aktivoida lisää sääntömäärityksiä laajennuksen asetuksista – paina ponnahduspaneelin _Ratas_-kuvaketta.
uBOL on täysin deklaratiivinen, eli suodatus ei edellytä pysyvää uBOL-prosessia ja CSS-/JS-koodin manipulointiin perustuva sisällönsuodatuksen suorittaa laajennusprosessin sijaan luotettavasti selainsovellus. Tämän ansiosta itse uBOL ei kuormita prosessoria tai keskusmuistia sisällöneston tapahtuessa -- uBOL:n työprosessia tarvitaan _ainoastaan_ ponnahduspaneelia ja asetussivuja käytettäessä.
uBOL ei edellytä laajan tietojen luku- ja muokkausoikeuden myöntämistä asennuksen yhteydessä, jonka vuoksi sen oletusarvoiset valmiudet ovat uBlock Originia ja muita vastaavia sisällönestotyökaluja rajallisemmat.
On kuitenkin mahdollista myöntää *yksinomaisesti* uBOL:lle laajennetut käyttöoikeudet sivustokohtaisesti niiden suodatuksen tehostamiseksi kosmeettisella suodatuksella ja scriplet-injektoinnilla.
Laajemmat oikeudet myönnetään avoimelle sivustolle avaamalla ponnahduspaneeli ja valitsemalla korkeampi suodatustaso, kuten Optimaalinen tai Täysi.
Tällöin selain varoittaa laajennuksen avoimelle sivustolle pyytämien käyttöoikeuksien seurauksista ja pyytää hyväksymään tai hylkäämään pyynnön.
Jos uBOL:n käyttöoikeuspyyntö avoimelle sivustolle hyväksytään, se pystyy suodattamaan sivuston sisältöä tehokkaammin.
Voit asettaa oletusarvoisen suodatustilan uBOL:n asetussivulta. Jos valitset oletustilaksi Optimaalinen tai Täysi, on uBOL:lle myönnettävä oikeus lukea ja muokata tietojasi kaikilla verkkosivustoilla.
Huomioithan, että laajennuksen kehitys vielä kesken, seuraavilla tavoitteilla:
- Laajoja käyttöoikeuksia ei tarvita asennusvaiheesssa, vaan laajennetut oikeudet myönnetään aina sivustokohtaisesti käyttäjän toimesta.
- Täysin deklaratiivinen luotettavuutta ja prosessorin/muistin kuormituksen keventämiseksi.
uBO Lite (uBOL) is a *permission-less* MV3-based content blocker.
Isang content blocker na nakabase sa MV3 ang uBO Lite (uBOL).
Tulad ng uBlock Origin, ito rin ang mga default na listahan ng mga filter:
@@ -7,24 +7,6 @@ Tulad ng uBlock Origin, ito rin ang mga default na listahan ng mga filter:
- EasyPrivacy
- Listahan ni Peter Lowe sa mga ad at tracking server (Peter Lowe’s Ad and tracking server list)
Makakapagdagdag ka ng higit pang mga patakaran sa pahina ng mga opsyon -- pindutin ang icon ng _gulong_ sa popup panel.
Maaring magpagana ng mas maraming ruleset sa page ng options -- pindutin ang _Cogs_ sa popup na panel.
Deklaratibo lamang ang uBOL, kaya hindi nito kailangan ng permanenteng proseso upang mag-filter, at mainam na ginagawa ng browser mismo imbes na ekstensyon ang pagfi-filter sa content na nakabase sa CSS o JS. Ibig-sabihin, hindi kumokonsyumo ng CPU o memorya ang uBOL habang nanghaharang -- ang proseso ng trabahante ng serbisyo ay kailangan _lang_ kung nasa popup panel o pahina ng opsyon ka.
Hindi kailangan ng uBOL ang malawakang pahintulot para "basahin at baguhin ang data" pagka-install, kaya kung bago pa lang itong install ay limitado ang kakayahan nito kumpara sa uBlock Origin o iba pang mga pangharang ng content na nangangailangan ng malawakang pahintulot para "basahin at baguhin ang data" pagka-install.
Ngunit, pwede mong *pasadyang* pahintulutan ang uBOL na magkaroon ng pinalawak na pahintulot sa mga website na pipiliin mo para mas mapabuti ang pagfi-filter sa mga site na iyon gamit ang kosmetikong pagfi-filter at injeksyon ng scriptlet.
Upang bigyan ito ng pinalawak na pahintulot sa isang site, buksan ang popup panel at pumili ng isang mode sa pagfi-filter tulad ng Pinainam o Kumpleto.
Babalaan ka ng browser tungkol sa mga epekto ng pagbibigay ng karagdagang pahintulot na hinihiling ng ekstensyon sa kasalukuyang site, at kailangan mong tumugon kung pinapahintulutan mo ba ito o hindi.
Kung tatanggapin mo ang hiling ng uBOL para sa karagdagang mga pahintulot sa kasalukuyang site, mas magiging mainam ang pagfi-filter nito sa content para sa kasalukuyang site.
Maitatakda mo ang default na mode sa pagfi-filter sa pahina ng mga opsyon ng uBOL. Kailangan mong pahintulutan ang uBOL na basahin o baguhin ang datos sa lahat ng mga website kung pipiliin mo ang Pinainam o Kumpleto bilang default na mode sa pagfi-filter.
Tandaang kasalukuyan pang binubuo ang ekstensyong ito, at nilalayon nitong:
- Walang kakailanganing malawakang pahintulot pagka-install -- ibibigay lang ng user ang karagdagang pahintulot sa mga piling site.
- Deklaratibo lamang upang maging mapagkakatiwalaan at matipid sa CPU at memorya.
uBO Lite (uBOL) est un bloqueur de contenu *sans permission* basé sur le manifeste MV3.
uBO Lite (uBOL) est un bloqueur de contenu basé sur le manifeste MV3.
Les règles par défaut correspondent au filtrage par défaut d'uBlock Origin :
@@ -7,24 +7,6 @@ Les règles par défaut correspondent au filtrage par défaut d'uBlock Origin :
- EasyPrivacy
- La liste anti-serveurs pub et pistage de Peter Lowe
Vous pouvez ajouter plus de règles en consultant la page des paramètres -- Cliquez sur l'_Engrenage_ dans le panneau pop-up.
Vous pouvez ajouter plus de règles en consultant la page des paramètres -- Cliquez sur l'icône de l'_Engrenage_ dans le panneau pop-up.
uBOL est entièrement déclarative, c'est-à-dire qu'il n'y a pas besoin d'un processus uBOL permanent pour filtrer, et le filtrage basé sur l'injection CSS/JavaScript se fait en toute fiabilité par le navigateur lui-même. Cela veut dire qu'en soi, uBOL ne consomme pas de ressources processeur/mémoire pendant le blocage de contenu -- l'agent de service d'uBOL n'est sollicité _que_ quand vous interagissez avec le panneau pop-up ou la page des paramètres.
Contrairement à uBlock Origin ou d'autres extensions de blocage, uBOL ne nécessite pas de larges permissions de "lecture/modification des données" au moment de l'installation, ce qui explique ses capacités au départ limitées.
Cependant, uBOL vous permet *explicitement* d'accorder des permissions étendues sur les sites Web de votre choix, pour qu'elle puisse mieux les filtrer en utilisant le filtrage esthétique et des injections de scriptlet.
Pour accorder des permissions étendues sur un site Web donné, ouvrez le panneau pop-up et choisissez un mode de filtrage plus élevé comme le mode Optimal ou le mode Complet.
Le navigateur vous préviendra alors des effets de l'accord de permissions additionnelles requises par l'extension sur le site Web en cours de consultation et vous devrez indiquer votre choix au navigateur (Accepter/Refuser).
Si vous acceptez la requête d'uBOL pour des permissions additionnelles sur le site Web en cours de consultation, le filtrage de son contenu sera renforcé.
Vous pouvez définir le mode de filtrage par défaut depuis la page des paramètres d'uBOL. Si vous choisissez le mode Optimal ou Complet en tant que mode par défaut, vous devrez accorder à uBOL l'autorisation de lire et de modifier des données sur tous les sites Web.
Gardez à l'esprit que c'est en cours de développement, avec comme objectifs :
- De ne pas accorder de permissions globales au moment de l'installation -- les permissions étendues s'accordent explicitement par l'utilisateur site par site.
- De travailler de manière entièrement déclarative pour la fiabilité et l'efficacité processeur/mémoire.
uBO Lite (uBOL) is in *tastimmingsleaze* MV3-basearre ynhâldsblokkearder.
uBO Lite (uBOL) is in MV3-basearre ynhâldsblokkearder.
De standert regelset komt oerien mei de standert filterset fan uBlock Origin:
@@ -7,24 +7,6 @@ De standert regelset komt oerien mei de standert filterset fan uBlock Origin:
- EasyPrivacy
- Peter Lowe’s Ad and tracking-serverlist
Jo kinne mear regelsets tafoegje troch de opsjesside te besykjen – klik op it _tântsjilpiktogram_ yn it pop-uppaniel.
Jo kinne mear regelsets ynskeakelje troch de opsjesside te besykjen – klik op it _tântsjilpiktogram_ yn it pop-uppaniel.
uBOL is folslein deklaratyf, wat betsjut dat in permanint uBOL-proses foar de filtering net nedich is, en ynhâldsfiltering op basis fan CSS/JS-ynjeksje op in betroubere manier troch de browser sels útfierd wurdt yn stee fan de útwreiding. Dit betsjut dat uBOL sels gjin CPU-/ûnthâldboarnen brûkt wylst ynhâldsblokkearring aktyf is – it serviceworker-proses fan uBOL is _allinnich_ fereaske as jo mei it pop-uppaniel of de opsjessiden wurkje.
uBOL fereasket gjin brede tastimming foar it ‘lêzen en oanpassen fan gegevens’ wylst ynstallaasje, fan dêr de beheinde ynboude mooglikheden dêrfan yn fergeliking mei uBlock Origin of oare ynhâldsblokkearders dy’t brede tastimmingen foar it ‘lêzen en oanpassen fan gegevens’ fereaskje wylst de ynstallaasje.
Jo kinne yn uBOL echter *eksplisyt* wiidweidige tastimmingen ferliene op bepaalde websites fan jo kar, sadat it op dy websites better filterje kin fia kosmetyske filtering en scriptlet-ynjeksjes.
Om wiidweidige tastimmingen op in bepaalde website te ferlienen, iepenje jo it pop-uppaniel en kieze jo in hegere filtermodus, lykas Optimaal of Folslein.
De browser warskôget jo dan oer de gefolgen fan it ferlienen fan de troch de útwreiding oanfrege oanfoljende tastimmingen op de aktuele website, en jo moatte de browser witte litte oft jo de oanfraach akseptearje of wegerje.
As jo de oanfraach fan uBOL foar oanfoljende tastimmingen op de aktuele website akseptearje, sil it ynhâld foar de aktuele website better filterje kinne.
Jo kinne de standert filtermodus ynstelle fan de opsjesside fan uBOL ôf. As jo de modus Optimaal of Folslein as de standertmodus kieze, moatte jo uBOL de tastimming foar it lêzen en oanpassen fan gegevens op alle websites te ferlienen.
Unthâld dat dit noch wurk yn útfiering is, mei dizze eindoelen:
- Gjin brede host-tastimmingen wylst ynstallaasje – wiidweidige tastimmingen wurde eksplisyt en per website ferliend troch de brûker.
- Folslein deklaratyf omwille fan betrouberheid en CPU-/ûnthâldeffisjinsje.
uBO Lite (uBOL) is a *permission-less* MV3-based content blocker.
uBO Lite (uBOL) é un bloqueador de contido baseado en MV3.
The default ruleset corresponds to uBlock Origin's default filterset:
O conxunto de regras predeterminado corresponde ao conxunto de filtros predeterminado de uBlock Origin:
- uBlock Origin's built-in filter lists
- Listas de filtros integradas de uBlock Origin
- EasyList
- EasyPrivacy
- Peter Lowe’s Ad and tracking server list
Lista de servidores de seguimento e anuncios de Peter Lowe
You can add more rulesets by visiting the options page -- click the _Cogs_ icon in the popup panel.
Podes activar máis grupos de regras indo á páxina de opcións -- preme na roda dentada no panel emerxente.
uBOL is entirely declarative, meaning there is no need for a permanent uBOL process for the filtering to occur, and CSS/JS injection-based content filtering is performed reliably by the browser itself rather than by the extension. This means that uBOL itself does not consume CPU/memory resources while content blocking is ongoing -- uBOL's service worker process is required _only_ when you interact with the popup panel or the option pages.
uBOL does not require broad "read and modify data" permission at install time, hence its limited capabilities out of the box compared to uBlock Origin or other content blockers requiring broad "read and modify data" permissions at install time.
However, uBOL allows you to *explicitly* grant extended permissions on specific sites of your choice so that it can better filter on those sites using cosmetic filtering and scriptlet injections.
To grant extended permissions on a given site, open the popup panel and pick a higher filtering mode such as Optimal or Complete.
The browser will then warn you about the effects of granting the additional permissions requested by the extension on the current site, and you will have to tell the browser whether you accept or decline the request.
If you accept uBOL's request for additional permissions on the current site, it will be able to better filter content for the current site.
You can set the default filtering mode from uBOL's options page. If you pick the Optimal or Complete mode as the default one, you will need to grant uBOL the permission to read and modify data on all websites.
Keep in mind this is still a work in progress, with these end goals:
- No broad host permissions at install time -- extended permissions are granted explicitly by the user on a per-site basis.
- Entirely declarative for reliability and CPU/memory efficiency.
uBOL é totalmente declarativo, o que significa que non é necesario un proceso permanente de uBOL para que se produza o filtrado e o filtrado de contido baseado en inxección de CSS/JS realízao de forma fiable o propio navegador en lugar da extensión. Isto significa que o propio uBOL non consume recursos de CPU/memoria mentres o bloqueo de contido está en curso -- o proceso do traballador do servizo de uBOL é necesario _só_ cando interactúas co panel emerxente ou coas páxinas de opcións.
uBO Lite (uBOL) is a *permission-less* MV3-based content blocker.
uBO Lite (uBOL) is an MV3-based content blocker.
The default ruleset corresponds to uBlock Origin's default filterset:
@@ -7,24 +7,6 @@ The default ruleset corresponds to uBlock Origin's default filterset:
- EasyPrivacy
- Peter Lowe’s Ad and tracking server list
You can add more rulesets by visiting the options page -- click the _Cogs_ icon in the popup panel.
You can enable more rulesets by visiting the options page -- click the _Cogs_ icon in the popup panel.
uBOL is entirely declarative, meaning there is no need for a permanent uBOL process for the filtering to occur, and CSS/JS injection-based content filtering is performed reliably by the browser itself rather than by the extension. This means that uBOL itself does not consume CPU/memory resources while content blocking is ongoing -- uBOL's service worker process is required _only_ when you interact with the popup panel or the option pages.
uBOL does not require broad "read and modify data" permission at install time, hence its limited capabilities out of the box compared to uBlock Origin or other content blockers requiring broad "read and modify data" permissions at install time.
However, uBOL allows you to *explicitly* grant extended permissions on specific sites of your choice so that it can better filter on those sites using cosmetic filtering and scriptlet injections.
To grant extended permissions on a given site, open the popup panel and pick a higher filtering mode such as Optimal or Complete.
The browser will then warn you about the effects of granting the additional permissions requested by the extension on the current site, and you will have to tell the browser whether you accept or decline the request.
If you accept uBOL's request for additional permissions on the current site, it will be able to better filter content for the current site.
You can set the default filtering mode from uBOL's options page. If you pick the Optimal or Complete mode as the default one, you will need to grant uBOL the permission to read and modify data on all websites.
Keep in mind this is still a work in progress, with these end goals:
- No broad host permissions at install time -- extended permissions are granted explicitly by the user on a per-site basis.
- Entirely declarative for reliability and CPU/memory efficiency.
uBO Lite (uBOL) הוא חוסם תוכן *ללא הרשאות* מבוסס MV3.
uBO Lite (uBOL) הוא חוסם תוכן מבוסס MV3.
ערכת הכללים ברירת מחדל שמתכתבת עם ערכת המסננים של uBlock Origin:
@@ -7,24 +7,6 @@ uBO Lite (uBOL) הוא חוסם תוכן *ללא הרשאות* מבוסס MV3.
- EasyPrivacy
- רשימת שרתי מודעות ומעקב של פיטר לואו
ניתן להוסיף ערכות כללים נוספות מעמוד האפשרויות –על ידי הקשה על סמל _Cogs_ בלוח הצץ.
ניתן לאפשר קבוצות חוקים נוספות בדף האפשרויות - עם לחיצה על סמליל _גלגלי השיניים_ בחלונית הקופצת.
uBOL הוא הכרזתי לחלוטין, כלומר אין צורך בתהליך uBOL קבוע כדי שהסינון יתרחש, וסינון תוכן מבוסס הזרקת CSS/JS מבוצע באופן אמין על ידי הדפדפן עצמו ולא על ידי ההרחבה. המשמעות היא ש־uBOL עצמו לא צורכך משאבי מעבד/זיכרון בזמן שחסימת התוכן מתרחשת – תהליך ה־service worker של uBOL נדרש _אך ורק_ בזמן הידוד עם החלון הקופץ או עם עמוד האפשרויות.
uBOL לא דורש הרשאת "קריאה ושינוי נתונים" נרחבות במהלך ההתקנה, לכן היכולות המוגבלות שלה הישר מהקופסה בהשוואה ל־uBlock Origin או חוסמי תוכן אחרים הדורשים הרשאות "קריאה ושינוי נתונים" נרחבות כבר בזמן ההתקנה.
עם זאת, uBOL מאפשר להעניק *באופן מפורש* הרשאות נרחבות לאתרים מסויימים על פי בחירה, למיטוב הסינון באתרים אלה, באמצעות סינון קוסמטי והזרקות סקריפלטים.
כדי להעניק הרשאות נרחבות באתר נתון, נא לפתוח את הלוח הקופץ ולבחור באופן סינון גבוה יותר כגון מיטבי או מלא.
לאחר מכן, תוצג אזהרת דפדפן על השפעות מתן הרשאות נוספות אותן מבקשת ההרחה באתר הנוכחי, הדפדפן ימתין לקבלת תשובה האם לקבל או לדוחות את בקשת ההרשאה.
אם תקבל את הבקשה של uBOL להרשאות נוספות באתר הנוכחי, הוא יוכל לסנן טוב יותר תוכן עבור האתר הנוכחי.
ניתן להגדיר את מצב הסינון המוגדר כברירת מחדל מדף האפשרויות של uBOL. אם הבחירה היתה באופןסינון מיטבי או מלא כברירת המחדל, יידרש להעניק ל־uBOL הרשאת קריאה שנוי נתונים בכל אתרי הרשת.
יש לזכור שזו עדיין 'עבודה בתהליך', עם המטרות הבאות:
- אין הרשאות מארח רחבות בזמן ההתקנה -- הרשאות מורחבות מוענקות במפורש על ידי המשתמש על בסיס לכל אתר.
uBO Lite (uBOL) एक *अनुमति-रहित* MV3-आधारित कन्टेन्ट ब्लॉकर है।
uBO Lite (uBOL) is an MV3-based content blocker.
डिफ़ॉल्ट रूलसेट uBlock Origin के डिफ़ॉल्ट फ़िल्टर सेट के अनुरूप होता है:
@@ -7,24 +7,6 @@ uBO Lite (uBOL) एक *अनुमति-रहित* MV3-आधारित
- EasyPrivacy
- Peter Lowe की विज्ञापन एवं ट्रैकिंग सर्वर सूची
आप विकल्प पृष्ठ पर जाकर और अधिक रूलसेट जोड़ सकते हैं -- पॉपअप पैनल में _Cogs_ आइकन पर क्लिक करें।
आप विकल्प पृष्ठ पर जाकर और अधिक नियम-सेट सक्षम कर सकते हैं -- पॉपअप पैनल में _Cogs_ आइकन पर क्लिक करें।
uBOL पूरी तरह से वर्णनात्मक है, जिसका यह अर्थ है कि फ़िल्टरिंग के लिए एक स्थायी uBOL प्रक्रिया की कोई आवश्यकता नहीं है, और CSS/JS इंजेक्शन-आधारित कन्टेन्ट फ़िल्टरिंग एक्सटेंशन के बजाय ब्राउज़र द्वारा विश्वसनीय रूप से की जाती है। इसका यह अर्थ है कि कन्टेन्ट ब्लॉक करते समय uBOL द्वारा सीपीयू/मेमोरी संसाधनों का उपभोग स्वयं नहीं किया जाता है -- uBOL की सर्विस प्रोसेस की आवश्यकता _केवल_ तब होती है जब आप पॉपअप पैनल या विकल्प पृष्ठों पर कोई अंत:क्रिया करते हैं।
uBOL को इन्सटॉल करते समय "डेटा को पढ़ने और संशोधित करने" की व्यापक अनुमति की आवश्यकता नहीं होती है, अतः इसकी सीमित क्षमताओं तत्काल उपयोगिता की तुलना में uBlock Origin या अन्य कन्टेन्ट ब्लॉकर को इन्सटॉलेशन के समय "डेटा को पढ़ने और संशोधित करने" की व्यापक अनुमतियों की आवश्यकता होती है।
हालांकि, uBOL आपको अपनी मनपसंद विशिष्ट साइटों पर विस्तारित अनुमतियां देना *स्पष्ट रूप से* अनुमत करता है ताकि यह कॉस्मेटिक फ़िल्टरिंग और स्क्रिप्टलेट इंजेक्शन का उपयोग करके उन साइटों पर अच्छी तरह से फ़िल्टर कर सके।
किसी एक साइट पर विस्तारित अनुमतियां देने के लिए, पॉपअप पैनल खोलें और उच्च फ़िल्टरिंग मोड, जैसे कि 'अनुकूलतम' (ऑप्टिमल) या 'पूर्ण' (कंपलीट) चुनें।
इसके बाद ब्राउज़र द्वारा आपको वर्तमान साइट पर एक्सटेंशन द्वारा अनुरोधित अतिरिक्त अनुमतियों को देने के प्रभावों के बारे में चेतावनी दी जाएगी, और आपको ब्राउज़र को यह बताना होगा कि आप अनुरोध को स्वीकार करते हैं या अस्वीकार करते हैं।
यदि आप वर्तमान साइट पर अतिरिक्त अनुमतियों के लिए uBOL के अनुरोध को स्वीकार करते हैं, तो यह वर्तमान साइट के लिए कन्टेन्ट अच्छी तरह से फ़िल्टर करने में सक्षम होगा।
आप uBOL के विकल्प पृष्ठ से डिफ़ॉल्ट फ़िल्टरिंग मोड को सेट कर सकते हैं। यदि आप 'अनुकूलतम' (ऑप्टिमल) या 'पूर्ण' (कंपलीट) मोड को डिफ़ॉल्ट रूप से चुनते हैं, तो आपको uBOL को सभी वेबसाइटों पर डेटा को पढ़ने और संशोधित करने के लिए अनुमत करना होगा।
ध्यान रखें कि यह कार्य अभी भी प्रगतिधीन है, और इसके निम्नांकित अंतिम लक्ष्यों तय किये गए हैं:
- इन्सटॉल करते समय कोई व्यापक होस्ट अनुमतियां नहीं -- विस्तारित अनुमतियां उपयोगकर्ता द्वारा हर एक साइट के आधार पर स्पष्ट रूप से दी जाती हैं।
- विश्वसनीयता और सीपीयू/मेमोरी दक्षता के लिए पूरी तरह वर्णनात्मक।
uBO Lite (uBOL) je bloker sadržaja *bez dopuštenja* baziran na MV3.
uBO Lite (uBOL) je bloker sadržaja baziran na MV3.
Zadana lista pravila odgovara uBlock Origin-ovoj zadanoj listi filtera:
@@ -7,24 +7,6 @@ Zadana lista pravila odgovara uBlock Origin-ovoj zadanoj listi filtera:
- EasyPrivacy
- Peter Lowe-ova lista oglasa i pratećih servera
Možete dodati više skupova pravila tako što ćete posjetiti stranicu s opcijama -- kliknite ikonu _zupčanika_ na skočnoj ploči.
Možete omogućiti više skupova pravila tako što ćete posjetiti stranicu s opcijama -- kliknite ikonu _Cogs_ na skočnoj ploči.
uBOL je u potpunosti deklarativan, što znači da nema potrebe za trajnim uBOL procesom za filtriranje, a filtriranje sadržaja temeljeno na ubacivanju CSS/JS pouzdano izvodi sam preglednik, a ne ekstenzija. To znači da sam uBOL ne troši CPU/memorijske resurse dok je blokiranje sadržaja u tijeku -- uBOL-ov servisni radni proces potreban je _samo_ kada komunicirate s skočnom pločom ili stranicama s opcijama.
uBOL ne zahtijeva široku dozvolu za "čitanje i izmjenu podataka" u vrijeme instalacije, stoga ima zadane ograničene mogućnosti u usporedbi s uBlock Origin ili drugim blokatorima sadržaja koji zahtijevaju veću dozvolu za "čitanje i izmjenu podataka" u vrijeme instalacije.
Međutim, uBOL vam omogućuje da *eksplicitno* dodijelite proširena dopuštenja na određenim web-stranicama po vašem izboru tako da može bolje filtrirati te web-stranice koristeći kozmetičko filtriranje i injekcijske skripte.
Da biste dodijelili proširena dopuštenja na određenoj web stranici, otvorite skočnu ploču i odaberite viši način filtriranja kao što je Optimalno ili Potpuno.
Preglednik će vas tada upozoriti o učincima dodjele dodatnih dopuštenja koje traži ekstenzija na trenutnom mjestu, a vi ćete morati reći pregledniku prihvaćate li ili odbijate zahtjev.
Ako prihvatite uBOL-ov zahtjev za dodatnim dozvolama na trenutnoj stranici, moći će bolje filtrirati sadržaj na njoj.
Zadani način filtriranja možete postaviti na stranici s opcijama uBOL-a. Ako kao zadano odaberete Optimalni ili Potpuni način rada, morati ćete dati uBOL-u dopuštenje za čitanje i izmjenu podataka na svim web stranicama.
Imajte na umu da je ovo još u tijeku, sa sljedećim krajnjim ciljevima:
- Nema širokih dopuštenja hosta u vrijeme instalacije -- proširena dopuštenja izričito dodjeljuje korisnik za svaku pojedinačnu stranicu.
- Potpuno deklarativno za pouzdanost i učinkovitost CPU/memorije.
uBO Lite (uBOL) is a *permission-less* MV3-based content blocker.
A uBO Lite (uBOL) egy MV3-alapú tartalomblokkoló.
Az alapértelmezett szabálykészlet megfelel a uBlock Origin alapértelmezett szűrőkészletének:
- uBlock Origin beépített filter listái
- uBlock Origin beépített szűrőlistái
- EasyList
- EasyPrivacy
- Peter Lowe hirdetés és nyomkövető szerver listája
- Peter Lowe hirdetési és nyomkövető-kiszolgálókat tartalmazó listája
További szabályokat adhat hozzá a beállítások oldalon - kattintson a _Cogs_ ikonra a felugró panelen.
További szabályokat engedélyezhet a beállítások oldalon – kattintson a _Fogaskerekek_ ikonra a felugró panelen.
Az uBOL teljes mértékben deklaratív, vagyis nincs szükség állandó uBOL folyamatra a szűréshez, és a CSS/JS injekció alapú tartalomszűrést maga a böngésző végzi megbízhatóan, nem pedig a kiterjesztés. Ez azt jelenti, hogy az uBOL maga nem fogyaszt CPU/memória erőforrásokat, amíg a tartalom blokkolása folyamatban van – az uBOL szervizmunkás folyamatára _csak_ akkor van szükség, amikor az előugró panellel vagy a beállítási oldalakkal lép kapcsolatba.
Az uBOL nem igényel széles körű „adatok olvasása és módosítása” engedélyt a telepítéskor, ezért korlátozott képességei vannak, mint az uBlock Origin vagy más tartalomblokkolók, amelyek széles körű „adatok olvasása és módosítása” engedélyeket igényelnek a telepítéskor.
Az uBOL azonban lehetővé teszi, hogy *kifejezetten* kiterjesztett engedélyeket adjon az Ön által választott bizonyos webhelyekhez, hogy jobban szűrhessen ezeken a webhelyeken kozmetikai szűréssel és szkriptlet-injekciókkal.
Ha kiterjesztett engedélyeket szeretne adni egy adott webhelyen, nyissa meg az előugró panelt, és válasszon magasabb szűrési módot, például Optimális vagy Teljes.
A böngésző ekkor figyelmezteti Önt a bővítmény által kért további engedélyek megadásának hatásaira az aktuális webhelyen, és közölnie kell a böngészővel, hogy elfogadja-e vagy elutasítja a kérést.
Ha elfogadja az uBOL további engedélyekre vonatkozó kérését az aktuális webhelyen, akkor jobban tudja szűrni az aktuális webhely tartalmát.
Az alapértelmezett szűrési módot az uBOL beállítási oldalán állíthatja be. Ha az Optimális vagy a Teljes módot választja alapértelmezettként, akkor az uBOL-nak engedélyt kell adnia az adatok olvasására és módosítására az összes webhelyen.
Ne feledje, hogy ez még folyamatban van, a következő célokkal:
- Nincsenek széles körű gazdagép-engedélyek a telepítés során – a kiterjesztett engedélyeket a felhasználó kifejezetten webhelyenként adja meg.
- Teljesen deklaratív a megbízhatóság és a CPU/memória hatékonysága szempontjából.
A uBOL teljes mértékben deklaratív, vagyis nincs szükség állandó uBOL folyamatra a szűréshez, és a CSS/JS injektálás-alapú tartalomszűrést maga a böngésző végzi megbízhatóan, nem pedig a kiegészítő. Ez azt jelenti, hogy az uBOL maga nem fogyaszt CPU/memória erőforrásokat, amíg a tartalom blokkolása folyamatban van – az uBOL service worker folyamatára _csak_ akkor van szükség, amikor az felugró panellel vagy a beállítási oldalakkal érintkezik.
uBO Lite (uBOL) is a *permission-less* MV3-based content blocker.
uBO Lite (uBOL) is an MV3-based content blocker.
Կանոնների լռելյայն փաթեթը համապատասխանում է uBlock Origin-ի լռելյայն զտիչների փաթեթին։
@@ -7,28 +7,6 @@ uBO Lite (uBOL) is a *permission-less* MV3-based content blocker.
- EasyPrivacy
- Peter Lowe-ի գովազդային և հետագծող սպասարկիչների ցուցակ
Դուք կարող եք ավելացնել ուրիշ կանոններ՝ այցելելով ընտրանքների էջը. կտտացրեք Ժանանվակի_պատկերակին դուրս լողացող վահանակում։
You can enable more rulesets by visiting the options page -- click the _Cogs_ icon in the popup panel.
uBOL-ն ամբողջությամբ դեկլարատիվ է, այսինքն՝ զտման համար անընդհատ կատարվող uBOL գործընթացի կարիք չկա, իսկ CSS/JS արմատավորման վրա հիմնված բովանդակության զտումը հուսալիորեն իրականացվում է զննիչի կողմից, այլ ոչ թե ընդլայնման միջոցով։ Սա նշանակում է, որ uBOL հավելումը չի սպառում մշակիչի/հիշողության որևէ ռեսուրս, երբ տեղի է ունենում գովազդի արգելափակումը. uBOL աշխատանքային գործընթացն աշխատում է _միայն_ երբ Դուք փոփոխություններ եք կատարում դուրս լողացող վահանակում կամ ընտրանքների էջում։
uBOL-ը տեղադրման ժամանակ «տվյելները լիովին ընթերցելու և փոփոխելու» թույլտվություն չի պահանջում, ուստի այն ունի սահմանափակ հնարավորություններ՝ համեմատած uBlock Origin-ի և բովանդակության այլ արգելափակիչների հետ, որոնք տեղադրման ժամանակ պահանջում են այդպիսի թույլտվություն։
Однако uBOL позволяет *намеренно* давать расширенные разрешения для определенных сайтов - по вашему усмотрению, чтобы эффективнее работать, используя косметическую фильтрацию и scriptlet-внедрения.
Այնուամենայնիվ, uBOL-ը թույլ է տալիս *դիտմամբ* տրամադրել ընդլայնված թույլտվություններ Ձեր ընտրած կայքերի համար, որպեսզի այն կարողանա էլ ավելի լավ զտել այդ կայքերը՝ օգտագործելով կոսմետիկ զտումը և սցենարների արմատավորումները։
Для предоставления расширенных разрешений на текущем сайте - откройте всплывающую панель и выберите повышенный режим фильтрации: Оптимальный или Полный.
Ընթացիկ կայքում ընդլայնված թույլտվություններ տրամադրելու համար բացեք դուրս լողացող վահանակը և ընտրեք ընդլայնված զտման ռեժիմ՝ Գերադասելի կամ Ամբողջական։
Այնուհետև զննիչը կզգուշացնի Ձեզ ընթացիկ կայքում ընդլայնման կողմից պահանջվող լրացուցիչ թույլտվությունների տրամադրման հետևանքների մասին, և Դուք պետք է ընտրեք՝ ընդունում եք, թե մերժում եք հայտը։
Եթե ընդունեք uBOL-ին լրացուցիչ թույլտվություններ տալու հայտը, ապա այն կկարողանա ավելի արդյունավետ կերպով զտել ընթացիկ կայքի բովանդակությունը։
Դուք կարող եք սահմանել զտման լռելյայն ռեժիմը uBOL-ի ընտրանքների էջում։ Եթե որպես լռելյայն ընտրեք «Գերադասելի» կամ «Ամբողջական» ռեժիմը, պետք կլինի uBOL-ին թույլտվություն տրամադրեք կարդալու և փոփոխելու տվյալները բոլոր կայքերում։
Հիշեք, որ այս նախագիծը մշակման ակտիվ փուլում է, որ ունի հետևյալ նպատակները.
- Տեղադրման ընթացքում Սահմանափակ թույլտվություններով աշխատանք տեղադրման ժամանակ. օգտվողը ընդլայնված թույլտվություններ է տալիս իր հայեցողությամբ, յուրաքանչյուր կայքի համար առանձին։
- Ամբողջովին դեկլարատիվ է հուսալիության և մշակիչի/հիշողության արտադրողականության համար։
uBO Lite (uBOL) adalah pemblokir konten berbasis MV3 yang membutuhkan lebih sedikit perizinan.
uBO Lite (uBOL) adalah pemblokir konten berbasis MV3.
Kumpulan aturan bawaan sesuai dengan kumpulan penyaringan bawaan uBlock Origin:
- Daftar filter asli uBlock Origin
- Daftar filter bawaan uBlock Origin
- EasyList
- EasyPrivacy
- Daftar server iklan dan pelacak Peter Lowe
kamu dapat menambahkan rulesets di halaman opsi -- klik ikon _Cogs_ di panel popup.
Anda dapat mengaktifkan lebih banyak rangkaian aturan dengan mengunjungi halaman opsi -- klik ikon _Cogs_ di panel popup.
uBOL sepenuhnya deklaratif, yang mana tidak membutuhkan proses permanen uBOL untuk penyaringan terjadi, dan penyaringan konten berbasis injeksi CSS/JS dilakukan sepenuhnya oleh perambaan itu sendiri ketimbang oleh ekstensi. Ini berarti uBOL sendiri tidak mengkonsumsi CPU/sumber daya memori selama melakukan pemblokiran konten -- proses pekerja layanan uBOL dibutuhkan _hanya_ ketika anda berinteraksi dengan panel popup atau opsi halaman.
uBOL tidak memerlukan izin "baca dan modifikasi data" yang luas pada waktu penginstalan, oleh karena itu kemampuannya yang terbatas di luar kotak dibandingkan dengan uBlock Origin atau pemblokir konten lain yang memerlukan izin "baca dan modifikasi data" yang luas pada waktu penginstalan.
Namun, uBOL memungkinkan Anda untuk *secara eksplisit* memberikan izin yang tambahan pada situs tertentu pilihan Anda sehingga dapat memfilter situs tersebut dengan lebih baik menggunakan pemfilteran tampilan dan injeksi scriptlet.
Untuk memberikan izin tambahan pada situs tertentu, buka panel popup dan pilih mode pemfilteran yang lebih tinggi seperti Optimal atau Complete.
Perambaan kemudian akan memperingatkan anda tentang efek memberikan izin tambahan yang diminta oleh ekstensi pada situs saat ini, dan Anda harus memberitahu perambaan apakah anda menyetujui atau menolak permintaan.
Jika Anda menyetujui permintaan uBOL untuk izin tambahan pada situs saat ini, itu akan dapat menyaring konten dengan lebih baik pada situs saat ini.
Kamu bisa mengatur Filter default dari halaman pengaturan UBOL's Jika Anda memilih mode Optimal atau Komplit sebagai bawaan, Anda perlu memberikan uBOL izin untuk membaca dan mengubah data pada semua situs web.
Harap diingat bahwa ini masih dalam proses pengerjaan, dengan tujuan akhir ini:
- Tidak ada izin host yang luas saat penginstalan -- izin yang diperpanjang secara eksplisit diberikan pengguna berdasarkan per-situs.
- Sepenuhnya delkaratif untuk reliabilitas dan CPU/efisiensi memori.
uBOL sepenuhnya bersifat deklaratif, artinya tidak diperlukan proses uBOL permanen agar penyaringan dapat terjadi, dan penyaringan konten berbasis injeksi CSS/JS dilakukan secara andal oleh browser itu sendiri dan bukan oleh ekstensi. Artinya uBOL sendiri tidak mengonsumsi sumber daya CPU/memori saat pemblokiran konten sedang berlangsung -- proses pekerja layanan uBOL diperlukan _hanya_ saat Anda berinteraksi dengan panel popup atau halaman opsi.
uBO Lite (uBOL) è un sistema per bloccare contenuti che *non richiede autorizzazioni* basato su MV3.
uBO Lite (uBOL) è un sistema di blocco dei contenuti basato su MV3.
L'insieme di regole predefinite corrisponde a quello di uBlock Origin:
L'insieme di regole predefinito corrisponde all'insieme di filtri predefinito di uBlock Origin:
- Elenco dei filtri integrati in uBlock Origin
- Liste dei filtri integrati di uBlock Origin
- EasyList
- EasyPrivacy
- Elenco dei server di tracciatura e pubblicità di Peter Lowe
- Elenco dei server pubblicitari e di tracciamento di Peter Lowe
Puoi aggiungere altre regole nella pagina delle opzioni. Clicca sull'icona _Ingranaggi_ nel pannello a comparsa.
Puoi abilitare altri set di regole visitando la pagina delle opzioni: clicca sull'icona _Cogs_ nel pannello a comparsa.
uBOL è interamente dichiarativo ovvero non è necessario un processo uBOL permanente per eseguire il filtraggio e il filtraggio dei contenuti CSS/JS inietattai viene eseguito in modo affidabile dal browser stesso piuttosto che dall'estensione. Ciò significa che lo stesso uBOL non consuma risorse di CPU/memoria mentre il blocco dei contenuti è in corso: il processo di lavoro di servizio di uBOL è richiesto _solo_ quando interagisci con il pannello popup o le pagine delle opzioni.
uBOL non richiede un'ampia autorizzazione di "lettura e modifica dei dati" al momento dell'installazione, da qui le sue capacità limitate rispetto a uBlock Origin o ad altre estensioni che richiedono ampie autorizzazioni di "lettura e modifica dei dati" al momento dell'installazione.
Tuttavia, uBOL consente di concedere *esplicitamente* permessi estesi a siti specifici di vostra scelta, in modo da poter filtrare meglio tali siti utilizzando il filtraggio cosmetico e le iniezioni di scriptlet.
Per concedere autorizzazioni estese su un determinato sito, apri il pannello popup e scegli una modalità di filtraggio più restrittiva come Ottimale o Completa.
Il browser ti avviserà degli effetti della concessione delle autorizzazioni aggiuntive richieste dall'estensione sul sito corrente e dovrai comunicare al browser se accetti o rifiuti la richiesta.
Se accetti la richiesta di uBOL per ulteriori autorizzazioni sul sito corrente, sarà in grado di filtrare meglio i contenuti per il sito corrente.
Puoi impostare la modalità di filtraggio predefinita dalla pagina delle opzioni di uBOL. Se scegli come predefinita la modalità Ottimale o Completa, dovrai concedere a uBOL il permesso di leggere e modificare i dati di tutti i siti web.
Tieni presente che questo è ancora un work in progress, con questi obiettivi finali:
- Nessuna autorizzazione host ampia al momento dell'installazione: le autorizzazioni estese vengono concesse esplicitamente dall'utente in base al sito.
- Interamente dichiarativo per l'affidabilità e l'efficienza della CPU/memoria.
uBOL è interamente dichiarativo, ovvero non è necessario che ci sia un processo di uBOL permanente per poter eseguire il filtraggio; e il filtraggio dei contenuti basato sull'iniezione di elementi CSS/JS viene eseguito in modo affidabile dal browser stesso piuttosto che dall'estensione. Ciò significa che lo stesso uBOL non consuma risorse di CPU o memoria mentre il blocco dei contenuti viene eseguito: il processo che esegue il servizio di uBOL è richiesto _solamente_ quando interagisci con il pannello a comparsa o con le pagine delle opzioni.
uBOL სრულად დეკლარაციულია, ანუ არაა საჭირო მუდმივად იყოს გაშვებული uBOL-პროცესი გასაფილტრად, CSS/JS ჩანაცვლებით შიგთავსის გაფილტვრას თავად ბრაუზერი უზრუნველყოფს ნაცვლად გაფართოებისა, რაც მეტად საიმედოა. შესაბამისად, uBOL თავად არ დატვირთავს პროცესორს/ოპერატიულს შიგთავსის შეზღუდვის დროს -- uBOL-ის შუამავალი მომსახურე პროცესი საჭიროა _მხოლოდ_ მაშინ, როცა ამომხტომ არესთან ურთიერთქმედებთ ან ცვლით პარამეტრებს.
uBOL არ საჭიროებს „მონაცემთა წაკითხვისა და შეცვლის“ სრულ ნებართვას დაყენებისას, ვინაიდან მოკვეცილი შესაძლებლობებითაა წარმოდგენილი uBlock Origin-თან ან რეკლამის სხვა შემზღუდავებთან შედარებით, რომლებიც ერთბაშად ითხოვს „მონაცემთა წაკითხვისა და შეცვლის“ უფლებას დაყენებისთანავე.
ამასთანავე, uBOL საშუალებას გაძლევთ *მკაფიო* თანხმობით მიუთითოთ გაფართოებული ნებართვები ცალკეულ საიტებზე სურვილისამებრ, რომ უკეთ შეიზღუდოს შიგთავსი ხილული ელემენტების გაფილტვრითა და პროგრამული ჩამატებებით.
გაფართოებული ნებართვების მისაცემად მითითებულ საიტზე, გახსენით ამომხტომი არე და აირჩიეთ ფილტრაციის უფრო მაღალი დონე, როგორიცაა „წონასწორული“ ან „სრული“.
შემდეგ ბრაუზერი გაგაფრთხილებთ გაფართოების მიერ დამატებითი ნებართვების მოთხოვნის შესახებ მოცემულ საიტზე და აირჩევთ, დათანხმდებით თუ უარყოფთ მოთხოვნას.
თუ დათანხმდებით uBOL-ს მოთხოვნას დამატებითი ნებართვებისთვის მიმდინარე საიტზე, უკეთ შეძლებს შიგთავსის შეზღუდვას აღნიშნულ საიტზე.
შეგიძლიათ მიუთითოთ გაფილტვრის ნაგულისხმევი რეჟიმი uBOL-ის პარამეტრების გვერდიდან. თუ აირჩევთ „წონასწორულ“ ან „სრულ“ რეჟიმს ნაგულისხმევად, uBOL-ს უნდა დართოთ ყველა საიტზე მონაცემთა წაკითხვისა და შეცვლის ნება.
დაიხსომეთ, რომ ჯერ კიდევ მუშავდება შემდეგი მიზნებისთვის:
- არანაირი სრული ნებართვების ერთბაშად მოთხოვნა დაყენებისას -- დამატებითი უფლებები შეიძლება მიეცეს მომხმარებლის მკაფიო თანხმობით თითოეულ საიტზე ცალ-ცალკე.
- სრულად დეკლარაციულია პროცესორის/მეხსიერების დასაზოგად.
uBOL მოქმედებს სრულად დადგენილი წესებით, შესაბამისად, არ ესაჭიროება მუდმივად გაშვებული uBOL-პროცესი გასაფილტრად, ხოლო როცა შიგთავსის შეზღუდვა ითხოვს ჩანაცვლდეს CSS/JS, ამას თავად ბრაუზერი უზრუნველყოფს საიმედო გზით, ნაცვლად გაფართოებისა. აქედან გამომდინარე, uBOL თავად არ მოიხმარს პროცესორს/მეხსიერებას შიგთავსის შეზღუდვისას -- uBOL საჭიროებს შუამავალ მომსახურე პროცესს _მხოლოდ_ მაშინ, როცა ამომხტომ არესთან ურთიერთქმედებთ ან ცვლით პარამეტრებს.
uBO Lite (uBOL) is a *permission-less* MV3-based content blocker.
uBO Lite (uBOL) is an MV3-based content blocker.
The default ruleset corresponds to uBlock Origin's default filterset:
@@ -7,24 +7,6 @@ The default ruleset corresponds to uBlock Origin's default filterset:
- EasyPrivacy
- Peter Lowe’s Ad and tracking server list
You can add more rulesets by visiting the options page -- click the _Cogs_ icon in the popup panel.
You can enable more rulesets by visiting the options page -- click the _Cogs_ icon in the popup panel.
uBOL is entirely declarative, meaning there is no need for a permanent uBOL process for the filtering to occur, and CSS/JS injection-based content filtering is performed reliably by the browser itself rather than by the extension. This means that uBOL itself does not consume CPU/memory resources while content blocking is ongoing -- uBOL's service worker process is required _only_ when you interact with the popup panel or the option pages.
uBOL does not require broad "read and modify data" permission at install time, hence its limited capabilities out of the box compared to uBlock Origin or other content blockers requiring broad "read and modify data" permissions at install time.
However, uBOL allows you to *explicitly* grant extended permissions on specific sites of your choice so that it can better filter on those sites using cosmetic filtering and scriptlet injections.
To grant extended permissions on a given site, open the popup panel and pick a higher filtering mode such as Optimal or Complete.
The browser will then warn you about the effects of granting the additional permissions requested by the extension on the current site, and you will have to tell the browser whether you accept or decline the request.
If you accept uBOL's request for additional permissions on the current site, it will be able to better filter content for the current site.
You can set the default filtering mode from uBOL's options page. If you pick the Optimal or Complete mode as the default one, you will need to grant uBOL the permission to read and modify data on all websites.
Keep in mind this is still a work in progress, with these end goals:
- No broad host permissions at install time -- extended permissions are granted explicitly by the user on a per-site basis.
- Entirely declarative for reliability and CPU/memory efficiency.
uBO Lite (uBOL) is a *permission-less* MV3-based content blocker.
uBO Lite (uBOL) is an MV3-based content blocker.
The default ruleset corresponds to uBlock Origin's default filterset:
@@ -7,24 +7,6 @@ The default ruleset corresponds to uBlock Origin's default filterset:
- EasyPrivacy
- Peter Lowe’s Ad and tracking server list
You can add more rulesets by visiting the options page -- click the _Cogs_ icon in the popup panel.
You can enable more rulesets by visiting the options page -- click the _Cogs_ icon in the popup panel.
uBOL is entirely declarative, meaning there is no need for a permanent uBOL process for the filtering to occur, and CSS/JS injection-based content filtering is performed reliably by the browser itself rather than by the extension. This means that uBOL itself does not consume CPU/memory resources while content blocking is ongoing -- uBOL's service worker process is required _only_ when you interact with the popup panel or the option pages.
uBOL does not require broad "read and modify data" permission at install time, hence its limited capabilities out of the box compared to uBlock Origin or other content blockers requiring broad "read and modify data" permissions at install time.
However, uBOL allows you to *explicitly* grant extended permissions on specific sites of your choice so that it can better filter on those sites using cosmetic filtering and scriptlet injections.
To grant extended permissions on a given site, open the popup panel and pick a higher filtering mode such as Optimal or Complete.
The browser will then warn you about the effects of granting the additional permissions requested by the extension on the current site, and you will have to tell the browser whether you accept or decline the request.
If you accept uBOL's request for additional permissions on the current site, it will be able to better filter content for the current site.
You can set the default filtering mode from uBOL's options page. If you pick the Optimal or Complete mode as the default one, you will need to grant uBOL the permission to read and modify data on all websites.
Keep in mind this is still a work in progress, with these end goals:
- No broad host permissions at install time -- extended permissions are granted explicitly by the user on a per-site basis.
- Entirely declarative for reliability and CPU/memory efficiency.
uBOL is entirely declarative, meaning there is no need for a permanent uBOL process for the filtering to occur, and CSS/JS injection-based content filtering is performed reliably by the browser itself rather than by the extension. ಇದರರ್ಥ ವಿಷಯ ನಿರ್ಬಂಧಿಸುವಿಕೆಯು ನಡೆಯುತ್ತಿರುವಾಗ uBOL ಸ್ವತಃ CPU/ಮೆಮೊರಿ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಬಳಸುವುದಿಲ್ಲ -- ನೀವು ಪಾಪ್ಅಪ್ ಪ್ಯಾನೆಲ್ ಅಥವಾ ಆಯ್ಕೆಯ ಪುಟಗಳೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಿದಾಗ uBOL ನ ಸೇವಾ ವರ್ಕರ್ ಪ್ರಕ್ರಿಯೆಯು _ಮಾತ್ರಾ_ ಅಗತ್ಯವಿದೆ.
@@ -7,24 +7,6 @@ uBO Lite(uBOL)는 *적은 권한을 요구하는* MV3 기반 콘텐츠 차단기
- EasyPrivacy
- Peter Lowe’s Ad and tracking server list
설정 페이지에서 규칙 목록을 더욱 추가할 수 있습니다. 팝업 창의 _Cogs_ 아이콘을 누르세요.
설정 페이지에서 규칙 목록을 더 활성화할 수 있습니다. 팝업 창의 _Cogs_ 아이콘을 누르세요.
uBOL은 완전히 선언적이라 필터링 중 영구적으로 실행되는 uBOL 프로세스를 필요로 하지 않으며, CSS/JS 주입 기반 콘텐츠 필터링이 확장 프로그램이 아닌 브라우저 자체에서 더욱 안정적으로 동작합니다. 즉 uBOL 자체는 콘텐츠 차단을 하는 동안 CPU/메모리 리소스를 소비하지 않습니다. uBOL 서비스워커 프로세스는 사용자가 팝업 창이나 설정을 열었을 _때에만_ 동작합니다.
uBOL은 설치 시 광범위한 "읽기 및 수정" 권한을 요구하지 않으므로, 설치 후 즉시 쓸 수 있는 기능들은 uBlock Origin이나 설치 시 광범위한 "읽기 및 수정" 권한을 요구하는 다른 콘텐츠 차단기에 비해 제한됩니다.
하지만 uBOL에서는 원하는 특정 사이트에 대해 확장된 권한을 부여하여, 해당 사이트를 표면 필터링 및 스크립트 주입을 바탕으로 더욱 잘 필터링할 수 있습니다.
주어진 사이트에 확장된 권한을 부여하려면, 팝업 창을 열고 필터링 모드를 '최적'이나 '완전'과 같이 더 높은 수준으로 선택하세요.
브라우저는 확장 프로그램에 현재 사이트에 대한 추가 권한을 부여했을 때 발생할 수 있는 일에 대해 경고할 것이며, 권한 요청을 수락할지 거부할지 선택해야 합니다.
현재 사이트에 대해 uBOL에 추가 권한을 부여하면, 해당 사이트의 콘텐츠를 더욱 잘 필터링할 수 있습니다.
uBOL 설정 페이지에서 기본 필터링 모드를 설정할 수 있습니다. 기본 모드를 '최적' 혹은 '완전'으로 설정하는 경우, uBOL에 모든 웹사이트에서 데이터를 읽고 수정할 수 있는 권한을 부여해야 합니다.
본 확장 프로그램은 여전히 아래 목표를 달성하기 위해 개발 중인 단계입니다.
- 설치 시 광범위한 호스트 권한을 요구하지 않고, 사용자가 사이트마다 명시적으로 확장된 권한을 부여할 수 있도록 합니다.
uBO Lite (uBOL) is a *permission-less* MV3-based content blocker.
The default ruleset corresponds to uBlock Origin's default filterset:
- uBlock Origin's built-in filter lists
- EasyList
- EasyPrivacy
- Peter Lowe’s Ad and tracking server list
You can add more rulesets by visiting the options page -- click the _Cogs_ icon in the popup panel.
uBOL is entirely declarative, meaning there is no need for a permanent uBOL process for the filtering to occur, and CSS/JS injection-based content filtering is performed reliably by the browser itself rather than by the extension. This means that uBOL itself does not consume CPU/memory resources while content blocking is ongoing -- uBOL's service worker process is required _only_ when you interact with the popup panel or the option pages.
uBOL does not require broad "read and modify data" permission at install time, hence its limited capabilities out of the box compared to uBlock Origin or other content blockers requiring broad "read and modify data" permissions at install time.
However, uBOL allows you to *explicitly* grant extended permissions on specific sites of your choice so that it can better filter on those sites using cosmetic filtering and scriptlet injections.
To grant extended permissions on a given site, open the popup panel and pick a higher filtering mode such as Optimal or Complete.
The browser will then warn you about the effects of granting the additional permissions requested by the extension on the current site, and you will have to tell the browser whether you accept or decline the request.
If you accept uBOL's request for additional permissions on the current site, it will be able to better filter content for the current site.
You can set the default filtering mode from uBOL's options page. If you pick the Optimal or Complete mode as the default one, you will need to grant uBOL the permission to read and modify data on all websites.
Keep in mind this is still a work in progress, with these end goals:
- No broad host permissions at install time -- extended permissions are granted explicitly by the user on a per-site basis.
- Entirely declarative for reliability and CPU/memory efficiency.
uBO Lite (uBOL) is a *permission-less* MV3-based content blocker.
uBO Lite (uBOL) is an MV3-based content blocker.
The default ruleset corresponds to uBlock Origin's default filterset:
@@ -7,24 +7,6 @@ The default ruleset corresponds to uBlock Origin's default filterset:
- EasyPrivacy
- Peter Lowe’s Ad and tracking server list
You can add more rulesets by visiting the options page -- click the _Cogs_ icon in the popup panel.
You can enable more rulesets by visiting the options page -- click the _Cogs_ icon in the popup panel.
uBOL is entirely declarative, meaning there is no need for a permanent uBOL process for the filtering to occur, and CSS/JS injection-based content filtering is performed reliably by the browser itself rather than by the extension. This means that uBOL itself does not consume CPU/memory resources while content blocking is ongoing -- uBOL's service worker process is required _only_ when you interact with the popup panel or the option pages.
uBOL does not require broad "read and modify data" permission at install time, hence its limited capabilities out of the box compared to uBlock Origin or other content blockers requiring broad "read and modify data" permissions at install time.
However, uBOL allows you to *explicitly* grant extended permissions on specific sites of your choice so that it can better filter on those sites using cosmetic filtering and scriptlet injections.
To grant extended permissions on a given site, open the popup panel and pick a higher filtering mode such as Optimal or Complete.
The browser will then warn you about the effects of granting the additional permissions requested by the extension on the current site, and you will have to tell the browser whether you accept or decline the request.
If you accept uBOL's request for additional permissions on the current site, it will be able to better filter content for the current site.
You can set the default filtering mode from uBOL's options page. If you pick the Optimal or Complete mode as the default one, you will need to grant uBOL the permission to read and modify data on all websites.
Keep in mind this is still a work in progress, with these end goals:
- No broad host permissions at install time -- extended permissions are granted explicitly by the user on a per-site basis.
- Entirely declarative for reliability and CPU/memory efficiency.
uBO Lite (uBOL) ir *bezatļauju* uz MV3 balstīts satura aizturētājs.
uBO Lite (uBOL) — uz MV3 balstīts satura aizturētājs.
Noklusējuma nosacījumu kopa atbilst uBokc Origin noklusējuma aizturēšanas kopai:
Noklusējuma nosacījumu kopa atbilst uBock Origin noklusējuma aizturēšanas kopai:
- uBlock Origin iebūvētie aizturēšanas saraksti
- EasyList
- EasyPrivacy
- Pētera Lova (Peter Lowe) reklāmu un izsakošanas serveru saraksts
- Pētera Lova (Peter Lowe) reklāmu un izsekošanas serveru saraksts
Vairāk nosacījumu kopu var pievienot iestatījumu sadaļā -- jāklikšķina _Zobratu_ ikona uznirstošajā logā.
Vairāk nosacījumu kopu var iespējot iestatījumu sadaļā -- jāklikšķina _Zobratu_ ikona uznirstošajā logā.
uBOL ir pilnībā vispārīgs, kas nozīmē, ka nav nepieciešamības pēc pastāvīga uBOL procesa, lai notiktu aizturēšana, un uz CSS/JS ievietošanu balstīta satura aizturēšanu uzticami veic pārlūks, nevis paplašinājums. Tas nozīmē, ka uBOL pats par sevi neizmanto procesoru un atmiņu, kamēr satura aizturēšana ir notiekoša -- uBOL pakalpojuma strādņa process ir nepieciešams _tikai_ tad, kad notiek mijiedarbība ar uznirstošo logu vai iestatījumu sadaļām.
uBOL nav nepieciešamas plašas "lasīt un pārveidot datus" atļaujas uzstādīšanas laikā, tāpēc tam ir ierobežotas spējas pēc noklusējuma, salīdzinājumā ar uBlock Origin vai citiem satura aizturētājiem, kas pieprasa plašas "lasīt un pārveidot datus" atļaujas uzstādīšanas laikā.
Tomēr uBOL ļauj piešķirt paplašinātās atļaujas *tieši* noteiktās vietnēs pēc izvēles, lai tas varētu labāk veikt aizturēšanu tajās, izmantojot kosmētisku aizturēšanu un skriptu ievietošanu.
Lai nodrošinātu paplašinātas piekļuves tiesības noteiktā vietnē, jāatver uznirstošais logs un jāizvēlas striktāks aizturēšanas veids, kā, piemēram, "Labākais" vai "Pilnīgais".
Pārlūks tad brīdinās ietekmi, ko radīs paplašinājuma pieprasīto papildu atļauju nodrošināšana pašreizējā vietnē, un būs jānorāda, vai pieprasījums tiek apstiprināts vai noraidīts.
Ja pašreizējā vietnē tiek apstiprināts uBOL papildu atļauju pieprasījums, paplašinājums varēs labāk veikt satura aizturēšanu.
Noklusējuma aizturēšanas veids ir norādāms uBOL uzstādījumu lapā. Ja tiek izvēlēts "Labākais" vai "Pilnīgais" kā noklusējuma, tad būs nepieciešams nodrošināt uBOL tiesības rakstīt un pārveidot datus visās tīmekļa vietnēs.
Jāpatur prātā, ka šī iespēja joprojām tiek izstrādāta ar šādiem mērķiem:
- Nav plašu saimniekdatora atļauju uzstādīšanas laikā -- paplašinātas atļaujas nodrošina lietotājs atsevišķi katrai vietnei.
- Pilnībā vispārīgs - uzticamībai un procesora/atmiņas lietderīgai izmantošanai.
uBO Lite (uBOL) is a *permission-less* MV3-based content blocker.
uBO Lite (uBOL) is an MV3-based content blocker.
The default ruleset corresponds to uBlock Origin's default filterset:
Стандардниот сет на правила одговара на стандардниот филтер сет на uBlock Origin:
- uBlock Origin's built-in filter lists
- Вградени филтер листи на uBlock Origin
- EasyList
- EasyPrivacy
- Peter Lowe’s Ad and tracking server list
- Листа на реклами и следачи на Peter Lowe
You can add more rulesets by visiting the options page -- click the _Cogs_ icon in the popup panel.
Можете да овозможите повеќе сетови на правила посетувајќи ја страницата со опции - кликнете на иконата _запчаник_ во попап панел.
uBOL is entirely declarative, meaning there is no need for a permanent uBOL process for the filtering to occur, and CSS/JS injection-based content filtering is performed reliably by the browser itself rather than by the extension. This means that uBOL itself does not consume CPU/memory resources while content blocking is ongoing -- uBOL's service worker process is required _only_ when you interact with the popup panel or the option pages.
uBOL does not require broad "read and modify data" permission at install time, hence its limited capabilities out of the box compared to uBlock Origin or other content blockers requiring broad "read and modify data" permissions at install time.
However, uBOL allows you to *explicitly* grant extended permissions on specific sites of your choice so that it can better filter on those sites using cosmetic filtering and scriptlet injections.
To grant extended permissions on a given site, open the popup panel and pick a higher filtering mode such as Optimal or Complete.
The browser will then warn you about the effects of granting the additional permissions requested by the extension on the current site, and you will have to tell the browser whether you accept or decline the request.
If you accept uBOL's request for additional permissions on the current site, it will be able to better filter content for the current site.
You can set the default filtering mode from uBOL's options page. If you pick the Optimal or Complete mode as the default one, you will need to grant uBOL the permission to read and modify data on all websites.
Keep in mind this is still a work in progress, with these end goals:
- No broad host permissions at install time -- extended permissions are granted explicitly by the user on a per-site basis.
- Entirely declarative for reliability and CPU/memory efficiency.
uBOL е целосно декларативен, што значи дека не е потребен траен процес на uBOL за филтрирање да се одвива, а филтрирањето на содржини врз основа на инјекција на CSS/JS се извршува со сигурност од самото браузер, а не од самата екстензија. Ова значи дека самиот uBOL не консумира ресурси на CPU/меморија додека блокирањето на содржини е во тек - процесот на службениот работник на uBOL е потребен _само_ кога ќе е потребен со попап панел или страниците со опции.
- പീറ്റർ ലോവിന്റെ പരസ്യവും ട്രാക്കിംഗ് സെർവർ ലിസ്റ്റും
You can add more rulesets by visiting the options page -- click the _Cogs_ icon in the popup panel.
You can enable more rulesets by visiting the options page -- click the _Cogs_ icon in the popup panel.
uBOL is entirely declarative, meaning there is no need for a permanent uBOL process for the filtering to occur, and CSS/JS injection-based content filtering is performed reliably by the browser itself rather than by the extension. This means that uBOL itself does not consume CPU/memory resources while content blocking is ongoing -- uBOL's service worker process is required _only_ when you interact with the popup panel or the option pages.
uBOL does not require broad "read and modify data" permission at install time, hence its limited capabilities out of the box compared to uBlock Origin or other content blockers requiring broad "read and modify data" permissions at install time.
However, uBOL allows you to *explicitly* grant extended permissions on specific sites of your choice so that it can better filter on those sites using cosmetic filtering and scriptlet injections.
To grant extended permissions on a given site, open the popup panel and pick a higher filtering mode such as Optimal or Complete.
The browser will then warn you about the effects of granting the additional permissions requested by the extension on the current site, and you will have to tell the browser whether you accept or decline the request.
If you accept uBOL's request for additional permissions on the current site, it will be able to better filter content for the current site.
You can set the default filtering mode from uBOL's options page. If you pick the Optimal or Complete mode as the default one, you will need to grant uBOL the permission to read and modify data on all websites.
Keep in mind this is still a work in progress, with these end goals:
- No broad host permissions at install time -- extended permissions are granted explicitly by the user on a per-site basis.
- Entirely declarative for reliability and CPU/memory efficiency.
uBOL പൂർണ്ണമായും ഡിക്ലറേറ്റീവ് ആണ്, അതായത് ഫിൽട്ടറിംഗ് സംഭവിക്കുന്നതിന് ഒരു സ്ഥിരമായ uBOL പ്രക്രിയയുടെ ആവശ്യമില്ല, കൂടാതെ CSS/JS ഇഞ്ചക്ഷൻ അടിസ്ഥാനമാക്കിയുള്ള ഉള്ളടക്ക ഫിൽട്ടറിംഗ്, എക്സ്റ്റൻഷനേക്കാൾ വിശ്വസനീയമായി ബ്രൗസർ തന്നെ നിർവഹിക്കുന്നു. ഉള്ളടക്കം തടയൽ നടന്നുകൊണ്ടിരിക്കുമ്പോൾ uBOL തന്നെ CPU/മെമ്മറി ഉറവിടങ്ങൾ ഉപയോഗിക്കില്ല എന്നാണ് ഇതിനർത്ഥം -- നിങ്ങൾ പോപ്പ്അപ്പ് പാനലുമായോ ഓപ്ഷൻ പേജുകളുമായോ സംവദിക്കുമ്പോൾ _only_ uBOL-ന്റെ സേവന വർക്കർ പ്രോസസ്സ് ആവശ്യമാണ്.
uBO Lite (uBOL) is a *permission-less* MV3-based content blocker.
uBO Lite (uBOL) हे MV3-आधारित कंटेंट ब्लॉकर आहे.
The default ruleset corresponds to uBlock Origin's default filterset:
डीफॉल्ट नियमसंच uBlock Origin च्या डीफॉल्ट फिल्टरसेटशी संबंधित आहे:
- uBlock Origin's built-in filter lists
- uBlock Origin च्या बिल्ट-इन फिल्टर लिस्ट
- EasyList
- EasyPrivacy
- Peter Lowe’s Ad and tracking server list
- पीटर लोवची जाहिरात आणि ट्रॅकिंग सर्व्हर यादी
You can add more rulesets by visiting the options page -- click the _Cogs_ icon in the popup panel.
तुम्ही पर्याय पृष्ठाला भेट देऊन अधिक नियम संच सक्षम करू शकता -- पॉपअप पॅनेलमधील _Cogs_ चिन्हावर क्लिक करा.
uBOL is entirely declarative, meaning there is no need for a permanent uBOL process for the filtering to occur, and CSS/JS injection-based content filtering is performed reliably by the browser itself rather than by the extension. This means that uBOL itself does not consume CPU/memory resources while content blocking is ongoing -- uBOL's service worker process is required _only_ when you interact with the popup panel or the option pages.
uBOL does not require broad "read and modify data" permission at install time, hence its limited capabilities out of the box compared to uBlock Origin or other content blockers requiring broad "read and modify data" permissions at install time.
However, uBOL allows you to *explicitly* grant extended permissions on specific sites of your choice so that it can better filter on those sites using cosmetic filtering and scriptlet injections.
To grant extended permissions on a given site, open the popup panel and pick a higher filtering mode such as Optimal or Complete.
The browser will then warn you about the effects of granting the additional permissions requested by the extension on the current site, and you will have to tell the browser whether you accept or decline the request.
If you accept uBOL's request for additional permissions on the current site, it will be able to better filter content for the current site.
You can set the default filtering mode from uBOL's options page. If you pick the Optimal or Complete mode as the default one, you will need to grant uBOL the permission to read and modify data on all websites.
Keep in mind this is still a work in progress, with these end goals:
- No broad host permissions at install time -- extended permissions are granted explicitly by the user on a per-site basis.
- Entirely declarative for reliability and CPU/memory efficiency.
uBOL पूर्णपणे घोषणात्मक आहे, म्हणजे फिल्टरिंगसाठी कायमस्वरूपी uBOL प्रक्रियेची गरज नाही, आणि CSS/JS इंजेक्शनवर आधारित सामग्री फिल्टरिंग ब्राउझरच्याच मदतीने विश्वासार्हपणे होते, विस्ताराद्वारे नव्हे. याचा अर्थ असा की सामग्री ब्लॉकिंग चालू असताना uBOL स्वतः CPU/मेमरी संसाधने वापरत नाही — uBOL चा सर्व्हिस वर्कर प्रोसेस फक्त तेव्हाच लागतो जेव्हा तुम्ही पॉपअप पॅनल किंवा पर्याय पृष्ठांशी संवाद साधता.
uBO Lite (uBOL) is a *permission-less* MV3-based content blocker.
uBO Lite (uBOL) is an MV3-based content blocker.
The default ruleset corresponds to uBlock Origin's default filterset:
Set peraturan lalai sepadan dengan set penapis lalai uBlock Origin:
- uBlock Origin's built-in filter lists
- Senarai penapis terbina dalam uBlock Origin
- EasyList
- EasyPrivacy
- Peter Lowe’s Ad and tracking server list
- Senarai pelayan iklan dan penjejakan 'Peter Lowe'
You can add more rulesets by visiting the options page -- click the _Cogs_ icon in the popup panel.
You can enable more rulesets by visiting the options page -- click the _Cogs_ icon in the popup panel.
uBOL is entirely declarative, meaning there is no need for a permanent uBOL process for the filtering to occur, and CSS/JS injection-based content filtering is performed reliably by the browser itself rather than by the extension. This means that uBOL itself does not consume CPU/memory resources while content blocking is ongoing -- uBOL's service worker process is required _only_ when you interact with the popup panel or the option pages.
uBOL does not require broad "read and modify data" permission at install time, hence its limited capabilities out of the box compared to uBlock Origin or other content blockers requiring broad "read and modify data" permissions at install time.
However, uBOL allows you to *explicitly* grant extended permissions on specific sites of your choice so that it can better filter on those sites using cosmetic filtering and scriptlet injections.
To grant extended permissions on a given site, open the popup panel and pick a higher filtering mode such as Optimal or Complete.
The browser will then warn you about the effects of granting the additional permissions requested by the extension on the current site, and you will have to tell the browser whether you accept or decline the request.
If you accept uBOL's request for additional permissions on the current site, it will be able to better filter content for the current site.
You can set the default filtering mode from uBOL's options page. If you pick the Optimal or Complete mode as the default one, you will need to grant uBOL the permission to read and modify data on all websites.
Keep in mind this is still a work in progress, with these end goals:
- No broad host permissions at install time -- extended permissions are granted explicitly by the user on a per-site basis.
- Entirely declarative for reliability and CPU/memory efficiency.
uBOL adalah deklaratif sepenuhnya, bermakna tidak ada keperluan untuk proses uBOL kekal untuk penapisan berlaku, dan penapisan kandungan berasaskan suntikan CSS/JS dilakukan sepenuhnya oleh penyemak imbas itu sendiri dan bukannya oleh sambungan. Ini bermakna uBOL sendiri tidak menggunakan sumber CPU/memori semasa penyekatan kandungan sedang berjalan -- proses pekerja perkhidmatan uBOL diperlukan _hanya_ apabila anda berinteraksi dengan panel timbul atau halaman pilihan.
uBO Lite (uBOL) er en *tillatelses-begrenset* MV3-basert innholdsblokkerer.
uBO Lite (uBOL) er en MV3-basert innholdsblokkerer.
Standardregelsettet tilsvarer standardfiltersettet til uBlock Origin:
@@ -10,21 +10,3 @@ Standardregelsettet tilsvarer standardfiltersettet til uBlock Origin:
Du kan legge til flere regelsett ved å gå til innstillingssiden -- klikk _Tannhjul_-ikonet i oppsprettspanelet.
uBOL er fullstendig deklarativ, noe som betyr at det ikke er behov for en permanent uBOL-prosess for at filtreringen skal skje, og CSS/JS-injeksjonsbasert innholdsfiltrering utføres pålitelig av nettleseren selv i stedet for av utvidelsen. Dette betyr at uBOL selv ikke bruker CPU/minneressurser mens innholdsblokkering pågår -- uBOL's service worker-prosess kreves _bare_ når du samhandler med oppsprettspanelet eller innstillingssidene.
uBOL krever ikke bred "lese og endre data"-tillatelse under installasjonen, derav begrensede muligheter i utgangspunktet sammenlignet med uBlock Origin eller andre innholdsblokkerere som krever bred "lese og endre data"-tillatelse under installasjonen.
Men, uBOL lar deg *uttrykkelig* gi utvidede tillatelser på bestemte nettsteder du velger, slik at uBOL bedre kan filtrere på disse nettstedene ved bruk av kosmetisk filtrering og skriptlet-injeksjoner.
For å gi utvidede tillatelser på et gitt nettsted, åpne oppsprettspanelet og velg en høyere filtreringsmodus som Optimal eller Fullstendig.
Nettleseren vil da advare deg om effektene av å gi de ekstra tillatelsene som utvidelsen ber om på det gjeldende nettstedet, og du må fortelle nettleseren om du godtar eller avslår forespørselen.
Hvis du godtar forespørselen fra uBOL om ekstra tillatelser på det gjeldende nettstedet, vil uBOL være i stand til å filtrere innhold bedre for det gjeldende nettstedet.
Du kan angi standard filtreringsmodus fra innstillingssiden i uBOL. Hvis du velger Optimal eller Fullstendig modus som standard, må du gi uBOL tillatelsen til å lese og endre data på alle nettsteder.
Husk at dette fortsatt er et arbeid som pågår, med disse sluttmålene:
- Ingen brede vertstillatelser under installasjonen -- utvidede tillatelser gis uttrykkelig av brukeren på per-side-basis.
- Helt deklarativt for pålitelighet og CPU/minneeffektivitet.
uBO Lite (uBOL) is een toestemmingsloze* MV3-gebaseerde inhoudsblokkeerder.
uBO Lite (uBOL) is een op MV3gebaseerde inhoudsblokkeerder.
De standaard regelset komt overeen met de standaard filterset van uBlock Origin:
@@ -7,24 +7,6 @@ De standaard regelset komt overeen met de standaard filterset van uBlock Origin:
- EasyPrivacy
- Peter Lowe’s Ad and tracking server list
U kunt meer regelsets toevoegen door de optiespagina te bezoeken -- klik op het _tandwielpictogram_ in het pop-uppaneel.
U kunt meer regelsets inschakelen door de optiespagina te bezoeken -- klik hiervoor op het _tandwielpictogram_ in het pop-uppaneel.
uBOL is volledig declaratief, wat betekent dat er geen permanent uBOL-proces voor de filtering nodig is, en inhoudsfiltering op basis van CSS/JS-injectie op een betrouwbare manier door de browser zelf wordt uitgevoerd in plaats van door de extensie. Dit betekent dat uBOL zelf geen CPU-/geheugenbronnen gebruikt terwijl inhoudsblokkering actief is -- het serviceworker-proces van uBOL is _alleen_ vereist als u met het pop-uppaneel of de optiespagina’s werkt.
uBOL vereist geen brede toestemming voor het ‘lezen en aanpassen van gegevens’ tijdens installatie, vandaar de beperkte ingebouwde mogelijkheden ervan in vergelijking met uBlock Origin of andere inhoudsblokkeerders die brede toestemmingen voor het ‘lezen en aanpassen van gegevens’ vereisen tijdens installatie.
U kunt in uBOL echter *expliciet* uitgebreide toestemmingen verlenen op bepaalde websites van uw keuze, zodat het op die websites beter kan filteren via cosmetische filtering en scriptlet-injecties.
Om uitgebreide toestemmingen op een bepaalde website te verlenen, opent u het pop-uppaneel en kiest u een hogere filtermodus, zoals Optimaal of Volledig.
De browser waarschuwt u dan over de gevolgen van het verlenen van de door de extensie aangevraagde aanvullende toestemmingen op de huidige website, en u dient de browser te laten weten of u de aanvraag accepteert of weigert.
Als u de aanvraag van uBOL voor aanvullende toestemmingen op de huidige website accepteert, zal het inhoud voor de huidige website beter kunnen filteren.
U kunt de standaard filtermodus instellen vanaf de optiespagina van uBOL. Als u de modus Optimaal of Volledig als de standaardmodus kiest, dient u uBOL de toestemming voor het lezen en aanpassen van gegevens op alle websites te verlenen.
Onthoud dat dit nog werk in uitvoering is, met deze einddoelen:
- Geen brede host-toestemmingen tijdens installatie -- uitgebreide toestemmingen worden expliciet en per website verleend door de gebruiker.
- Volledig declaratief omwille van betrouwbaarheid en CPU-/geheugenefficiëntie.
uBO Lite (uBOL) is a *permission-less* MV3-based content blocker.
uBO Lite (uBOL) is an MV3-based content blocker.
The default ruleset corresponds to uBlock Origin's default filterset:
@@ -7,24 +7,6 @@ The default ruleset corresponds to uBlock Origin's default filterset:
- EasyPrivacy
- Peter Lowe’s Ad and tracking server list
You can add more rulesets by visiting the options page -- click the _Cogs_ icon in the popup panel.
You can enable more rulesets by visiting the options page -- click the _Cogs_ icon in the popup panel.
uBOL is entirely declarative, meaning there is no need for a permanent uBOL process for the filtering to occur, and CSS/JS injection-based content filtering is performed reliably by the browser itself rather than by the extension. This means that uBOL itself does not consume CPU/memory resources while content blocking is ongoing -- uBOL's service worker process is required _only_ when you interact with the popup panel or the option pages.
uBOL does not require broad "read and modify data" permission at install time, hence its limited capabilities out of the box compared to uBlock Origin or other content blockers requiring broad "read and modify data" permissions at install time.
However, uBOL allows you to *explicitly* grant extended permissions on specific sites of your choice so that it can better filter on those sites using cosmetic filtering and scriptlet injections.
To grant extended permissions on a given site, open the popup panel and pick a higher filtering mode such as Optimal or Complete.
The browser will then warn you about the effects of granting the additional permissions requested by the extension on the current site, and you will have to tell the browser whether you accept or decline the request.
If you accept uBOL's request for additional permissions on the current site, it will be able to better filter content for the current site.
You can set the default filtering mode from uBOL's options page. If you pick the Optimal or Complete mode as the default one, you will need to grant uBOL the permission to read and modify data on all websites.
Keep in mind this is still a work in progress, with these end goals:
- No broad host permissions at install time -- extended permissions are granted explicitly by the user on a per-site basis.
- Entirely declarative for reliability and CPU/memory efficiency.
uBOL is entirely declarative, meaning there is no need for a permanent uBOL process for the filtering to occur, and CSS/JS injection-based content filtering is performed reliably by the browser itself rather than by the extension. This means that uBOL itself does not consume CPU/memory resources while content blocking is ongoing -- uBOL's service worker process is required _only_ when you interact with the popup panel or the option pages.
uBO Lite (uBOL) to *niewymagający uprawnień* bloker treści bazujący na MV3.
uBO Lite (uBOL) to bloker treści oparty na MV3.
Domyślny zestaw reguł odpowiada domyślnemu zestawowi filtrów uBlock Origin:
– wbudowane listy filtrów uBlock Origin
– wbudowane listy filtrów rozszerzenia uBlock Origin
– EasyList
– EasyPrivacy
– lista serwerów śledzących i reklam Petera Lowe'a
Możesz dodać więcej zestawów reguł, odwiedzając stronę opcji – kliknij ikonę _Trybika_ w wyskakującym panelu.
Możesz włączyć więcej zestawów reguł, odwiedzając stronę opcji – kliknij ikonę _koła zębatego_ w wyskakującym panelu.
uBOL jest całkowicie deklaratywny, co oznacza, że nie jest potrzebny stały proces uBOL w celu filtrowania, a filtrowanie treści oparte na wstrzykiwaniu CSS/JS jest wykonywane niezawodnie przez samą przeglądarkę, a nie przez rozszerzenie. Oznacza to, że sam uBOL nie zużywa zasobów procesora/pamięci, gdy trwa blokowanie treści – proces Service Worker uBOL jest wymagany _tylko_ podczas interakcji z panelem wyskakującym lub stronami opcji.
uBOL w trakcie instalacji nie wymaga szerokich uprawnień do „odczytu i modyfikacji danych”, stąd jego ograniczone możliwości w porównaniu z uBlock Origin lub innymi blokerami treści, które w czasie instalacji wymagają szerokich uprawnień do „odczytu i modyfikacji danych”.
Jednakże uBOL umożliwia *jawnie* udzielanie rozszerzonych uprawnień na określonych wybranych witrynach, dzięki czemu może lepiej filtrować te witryny za pomocą filtrowania kosmetycznego i wstrzykiwania skryptletów.
Aby przyznać rozszerzone uprawnienia na danej witrynie, otwórz panel wyskakujący i wybierz wyższy tryb filtrowania, taki jak Optymalny lub Kompletny.
Przeglądarka wyświetli ostrzeżenie o skutkach przyznania dodatkowych uprawnień wymaganych przez rozszerzenie na bieżącej witrynie i będziesz musiał poinformować przeglądarkę, czy akceptujesz, czy odrzucasz żądanie.
Jeśli zaakceptujesz żądanie uBOL o dodatkowe uprawnienia na bieżącej witrynie, będzie on w stanie lepiej filtrować zawartość bieżącej witryny.
Możesz ustawić domyślny tryb filtrowania na stronie opcji uBOL. Jeśli tryb Optymalny lub Pełny zostanie wybrany jako domyślny, trzeba będzie przyznać uBOL uprawnienia do odczytu i modyfikacji danych na wszystkich stronach internetowych.
Należy pamiętać, że nadal trwają prace z następującymi celami końcowymi:
– Brak szerokich uprawnień hosta w czasie instalacji – rozszerzone uprawnienia są przyznawane jawnie przez użytkownika na podstawie poszczególnych witryn.
– Całkowicie deklaratywna niezawodność i wydajność procesora/pamięci.
O uBO Lite (uBOL) é um bloqueador de conteúdo baseado no MV3 com menor permissão.
O uBO Lite (uBOL) é um bloqueador de conteúdo baseado no MV3.
O conjunto de regras padrão corresponde ao conjunto de filtros padrão do uBlock Origin:
- Listas embutidas dos filtros do uBlock Origin
- EasyList
- EasyPrivacy
- Lista de servidores de anúncios e rastreadores do Peter Lowe
- Lista de servidores de anúncios e rastreamento por Peter Lowe
Você pode adicionar mais conjuntos de regras visitando a página das opções -- clique no ícone _Engrenagens_ no painel do pop-up.
Você pode ativar mais conjuntos de regras visitando a página de opções — clique no ícone da _Engranagem_ no painel do pop-up.
O uBOL é totalmente declarativo, significando que não há necessidade de um processo permanente do uBOL para a filtragem ocorrer e a filtragem de conteúdo baseada em injeção do CSS/JS é realizada confiavelmente pelo próprio navegador ao invés da extensão. Isto significa que o próprio uBOL não consome recursos de CPU/memória enquanto o bloqueio de conteúdo está em andamento -- o processo do service worker do uBOL _só_ é necessário quando você interage com o painel do pop-up ou as páginas das opções.
O uBOL não requer permissão ampla pra "ler e modificar dados" na hora da instalação, logo suas capacidades limitadas fora da caixa comparadas com o uBlock Origin ou outros bloqueadores de conteúdo requerem permissões amplas pra "ler e modificar dados" na hora da instalação.
Contudo, o uBOL permite a você garantir *explicitamente* permissões estendidas em sites específicos de sua escolha pra que possa filtrar melhor esses sites usando filtragem cosmética e injeções de scriptlet.
Pra conceder permissões estendidas num site dado, abra o painel do pop-up e escolha um modo de filtragem superior tal como Otimizado ou Completo.
O navegador então avisará você sobre os efeitos de garantir as permissões adicionais requisitadas pela extensão no site atual e você terá que dizer ao navegador se você aceita ou recusa a requisição.
Se você aceitar a requisição do uBOL por permissões adicionais no site atual ele será capaz de filtrar melhor o conteúdo do site atual.
Você pode definir o modo de filtragem padrão na página de opções do uBOL. Se você escolher o Modo Otimizado ou Completo como o modo padrão você precisará garantir ao uBOL a permissão de ler e modificar os dados em todos os sites.
Mantenha em mente que este ainda é um trabalho em progresso com estes objetivos finais:
- Sem permissões amplas do hospedeiro na hora da instalação -- as permissões estendidas são garantidas explicitamente pelo usuário numa base por site.
- Totalmente declarativo para confiabilidade e eficiência de CPU/memória.
O uBOL é totalmente declarativo, significando que não há necessidade de um processo permanente do uBOL para a filtragem ocorrer, e filtragem de conteúdo baseada em injeção de CSS/JS é realizada corretamente pelo próprio navegador ao invés da extensão. Isto significa que o uBOL em si não consome recursos de CPU/memória ao bloquear conteúdo -- o processo do service worker do uBOL _só_ é necessário quando você interage com o painel do pop-up ou as páginas de opções.
O uBO Lite (uBOL) é um bloqueador de conteúdo baseado no MV3 *sem permissões*.
O uBO Lite (uBOL) é um bloqueador de conteúdo baseado em MV3.
O conjunto de regras padrão corresponde ao conjunto de filtros padrão do uBlock Origin:
O conjunto de regras predefinido corresponde ao conjunto de filtros predefinido do uBlock Origin:
- Listas de filtros integrados do uBlock Origin
- EasyList
- EasyPrivacy
- Peter Lowe’s Ad and tracking server list
Pode adicionar mais conjuntos de regras visitando a página de opções -- clique no ícone _Cogs_ no painel pop-up.
Pode ativar mais conjuntos de regras visitando a página de opções -- clique no ícone _Cogs_ no painel popup.
O uBOL é totalmente declarativo, o que significa que não há necessidade de um processo uBOL permanente para que a filtragem ocorra, e a filtragem de conteúdo baseada em injeção de CSS/JS é realizada de forma confiável pelo próprio navegador e não pela extensão. Isto significa que o próprio uBOL não consome recursos da CPU/memória enquanto o bloqueio de conteúdo está em curso -- o processo de service worker do uBOL é necessário _apenas_ quando interage com o painel pop-up ou as páginas de opções.
uBOL não requer ampla permissão de "ler e modificar dados" no momento da instalação, daí as suas capacidades limitadas de pronto a usar em comparação com uBlock Origin ou outros bloqueadores de conteúdo que requerem amplas permissões de "ler e modificar dados" no momento da instalação.
No entanto, o uBOL permite-lhe que *explicitamente* conceda permissões alargadas em websites específicos de sua escolha, para que possa filtrar melhor esses websites usando filtragem cosmética e injeções de scriptlet.
Para conceder permissões alargadas num determinado website, abra o painel pop-up e escolha um modo de filtragem superior, como Ideal ou Completo.
O navegador irá avisá-lo sobre os efeitos da concessão das permissões adicionais solicitadas pela extensão no website atual, e terá que informar ao navegador se aceita ou recusa o pedido.
Se aceitar o pedido do uBOL para permissões adicionais no website atual, o mesmo poderá filtrar melhor o conteúdo do website atual.
Pode definir o modo de filtragem padrão na página de opções do uBOL. Se escolher o modo Ideal ou Completo como o modo predefinido, terá de conceder ao uBOL a permissão para ler e modificar dados em todos os sítios web.
Tenha em mente que este ainda é um trabalho em curso, com estes objetivos finais:
- Sem permissões amplas de host no momento da instalação -- as permissões alargadas são concedidas explicitamente pelo utilizador por website.
- Totalmente declarativo para fiabilidade e eficiência da CPU/memória.
O uBOL é totalmente declarativo, o que significa que não é necessário um processo permanente do uBOL para que a filtragem ocorra, e a filtragem de conteúdos baseada em injeção de CSS/JS é realizada de forma fiável pelo próprio navegador, e não pela extensão. Isto significa que o próprio uBOL não consome recursos de CPU/memória enquanto o bloqueio de conteúdo está ativo -- o processo do service worker do uBOL é necessário apenas quando interage com o painel popup ou com as páginas de opções.
uBO Lite (uBOL) is a *permission-less* MV3-based content blocker.
uBO Lite (uBOL) este un blocker de conținut bazat pe MV3.
Setul de reguli implicit corespunde setului de filtre implicit al uBlock Origin:
Listele de filtre încorporate de uBlock Origin
- EasyList
- EasyPrivacy
- Peter Lowe’s Ad and tracking server list
- -Lista de servere de anunț și de urmărire a lui Peter Lowe
Puteți adăuga mai multe seturi de reguli vizitând pagina de opțiuni -- făcând clic pe pictograma _Cogs_ din panoul pop-up
Puteți activa mai multe seturi de reguli accesând pagina de opțiuni - faceți clic pe pictograma _Cogs_ din panoul pop-up.
uBOL este în întregime declarativ, ceea ce înseamnă că nu este nevoie de un proces uBOL permanent pentru ca filtrarea să aibă loc, iar filtrarea conținutului pe bază de injecție CSS/JS este realizată în mod fiabil de browser în sine, mai degrabă decât de extensie. Aceasta înseamnă că uBOL în sine nu consumă resurse CPU/memorie în timp ce blocarea conținutului este în desfășurare -- procesul de lucru al serviciului uBOL este necesar _doar_ atunci când interacționați cu panoul pop-up sau cu paginile de opțiuni.
uBOL nu necesită permisiunii extinse de „citire și modificare a datelor” în momentul instalării, prin urmare capacitățile sale limitate din momentul instalării în comparație cu uBlock Origin sau alte blocare de conținut care necesită permisiuni largi de „citire și modificare a datelor” în momentul instalării.
Cu toate acestea, uBOL vă permite să acordați *explicit* permisiuni extinse pe anumite site-uri alese de dvs., astfel încât să poată filtra mai bine pe acele site-uri folosind filtrarea cosmetică și injecțiile de scriptlet.
Pentru a acorda permisiuni extinse pe un anumit site, deschideți panoul pop-up și alegeți un mod de filtrare mai ridicat, cum ar fi Optimal sau Complet.
Browser-ul vă va avertiza apoi cu privire la efectele acordării permisiunilor suplimentare solicitate de extensie pe site-ul curent și va trebui să spuneți browserului dacă acceptați sau refuzați cererea.
Dacă acceptați solicitarea uBOL pentru permisiuni suplimentare pe site-ul curent, acesta va putea filtra mai bine conținutul pentru site-ul curent.
Puteți seta modul implicit de filtrare din pagina de opțiuni a uBOL. Dacă alegeți modul optim sau complet ca implicit, va trebui să acordați lui uBOL permisiunea de a citi și modifica datele de pe toate site-urile web.
Rețineți că aceasta este în curs de desfășurare, cu aceste obiective finale:
- Fără permisiuni de gazdă largi în momentul instalării - permisiunile extinse sunt acordate în mod explicit de către utilizator pe bază de site.
- Complet declarativ pentru fiabilitate și eficiență CPU/memorie.
uBOL este în întregime declarativ, ceea ce înseamnă că nu este nevoie de un proces uBOL permanent pentru ca filtrarea să aibă loc, iar filtrarea conținutului pe bază de injecție CSS/JS este realizată în mod sigur de browser în sine, mai degrabă decât de extensie. Aceasta înseamnă că uBOL în sine nu consumă resurse CPU/memorie în timp ce blocarea conținutului este în desfășurare -- procesul de lucru al serviciului uBOL este necesar _doar_ atunci când interacționați cu panoul pop-up sau cu paginile de opțiuni.
Some files were not shown because too many files have changed in this diff
Show More
Reference in New Issue
Block a user
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.
