const palette: { [key: string]: string } = {...

However, unless my feeble brain is feeble, this looks like a valid use case and I might not be alone.

Of course, we can always add more special cases to the type system to detect the specific case of iterating over a known-bounded object literal, but this just leads to the "Why does this code not behave like this other nearly-identical code?" problem when we fail to properly exhaust all the special cases.

Regarding the first example, we have to put aside the fact that we (from inspection) can see the runtime behavior of this code by executing it in our heads.

Regarding mapped types, remember that { [K in T]: U } is a special form - it can't be combined with other properties within the { }. So there's not really a name for the [K in T: U] part because it's just part of the overall "mapped type" syntax { [K in T]: U }

what is the TypeScript Way™ of handling the implicit any that appears due to object literals not having a standard index signature?

Even if it's const, an object can still have properties added later returning any arbitrary type. Indexing into the object would then have to return any - and that's an implicit any.

fresh (i.e. provably do not have properties we don't know about)

Object literals don't have index signatures. They are assignable to types with index signatures if they have compatible properties and are fresh (i.e. provably do not have properties we don't know about) but never have index signatures implicitly or explicitly.

Which... is confusing because Palette technically does have an index signature Palette is a mapped type, and mapped types don't have index signatures. The fact that both use [ ] is a syntactic coincidence.

I thought I knew how they worked, but it looks I was wrong and made two false assumptions: Thought that typeof of object literals are inferred to have (string | number) index signature Thought that mapped types over union of string literals is a way to declare a limited set of string index signatures That's how it looked to me from the example in Typescript Deep Dive

type PaletteColors = keyof typeof palette type Palette = { [Color in PaletteColors]: string }

What you wrote is called a Mapped Type (horrible name for trying to google it).

Generate type with the index signature: interface RandomMappingWithIndexSignature { stringProp: string; numberProp: number; [propName: string]: string | number | undefined; }

we have no way to know that the line nameMap[3] = "bob"; isn't somewhere in your program

The other commenters are right about the potential solutions. However, it is actually considered a best practice to move the object with the index signature to a nested property.Said differently: No property in the object with the index signature should depart from how the index signature is typed.

Like others have noted, your function does not conform to index signature. [key: string]: string means "all fields are strings" and on the next line you declare a field with function in it.This can be solved by using union types:type IFoo = { [foo: string]: string } & { fooMethod(fooParam: string): void }

you can define locally parse and it should take precedence over the one in the library: interface JSON { parse(text: string, reviver?: (key: any, value: any) => any): unknown; }

This PR adds a new top type unknown which is the type-safe counterpart of any. Anything is assignable to unknown, but unknown isn't assignable to anything but itself and any without a type assertion or a control flow based narrowing. Likewise, no operations are permitted on an unknown without first asserting or narrowing to a more specific type.

// Second case (unexpected) interface C { [x:string]: number } interface D { x: number } const d: D = { x: 1 }; const c: C = d; // error // Type 'D' is not assignable to type 'C'. // Index signature is missing in type 'D'.

Seems related, currently there's no way to enforce that object should have attribute values of specific type only. Example: I want to define an abstract Table Row, basically any object limited to attribute values as primitive types. But it doesn't work // Table row export type Row = Record<string, string | number | undefined> // User interface User { name: string } const jim: User = { name: 'Jim' } const row: Row = jim // <== Error

So now the question is, why does Session, an interface, not get implicit index signatures while SessionType, an identically-structured typealias, *does*? Surely, you might again think, the compiler does not simply deny implicit index signatures tointerface` types? Surprisingly enough, this is exactly what happens. See microsoft/TypeScript#15300, specifically this comment: Just to fill people in, this behavior is currently by design. Because interfaces can be augmented by additional declarations but type aliases can't, it's "safer" (heavy quotes on that one) to infer an implicit index signature for type aliases than for interfaces. But we'll consider doing it for interfaces as well if that seems to make sense And there you go. You cannot use a Session in place of a WithAdditionalParams<Session> because it's possible that someone might merge properties that conflict with the index signature at some later date. Whether or not that is a compelling reason is up for rather vigorous debate, as you can see if you read through microsoft/TypeScript#15300.

why is Session not assignable to WithAdditionalParams<Session>? Well, the type WithAdditionalParams<Session> is a subtype of Session with includes a string index signature whose properties are of type unknown. (This is what Record<string, unknown> means.) Since Session does not have an index signature, the compiler does not consider WithAdditionalParams<Session> assignable to Session.

Check whether a value is defined (non-nullable), meaning it is neither `null` or `undefined`. This can be useful as a type guard, as for example, `[1, null].filter(Boolean)` does not always type-guard correctly.

import {isDefined} from 'ts-extras'; [1, null, 2, undefined].filter(isDefined); //=> [1, 2]

The type-fest package contains only types, meaning they are only used at compile-time and nothing is ever compiled into actual JavaScript code. This package contains functions that are compiled into JavaScript code and used at runtime.

export type Simplify<T> = {[KeyType in keyof T]: T[KeyType]};

Having actual functions here is a non-goal. This package is for types only, meaning nothing ends up compiled into actual JS code.

I am not sure about aliases though... The number of aliases for various type definitions could grow without bounds. Unless it is a very common usage Indexify, my 2 cents would be not to create an alias. But I don't make the call on this.

An interface can be re-opened. Whereas a type is sealed. So a solution for microsoft/TypeScript#15300 is to map the interface (which can be defined in many places) to a type.

fieldsToUpdate: Partial<Todo>

Object.hasOwn() is recommended over hasOwnProperty(), in browsers where it is supported.

The hasOwnProperty() method returns a boolean indicating whether the object has the specified property as its own property (as opposed to inheriting it).

Therefore, following the reasoning we’ve developed above, it seems obvious that strings are objects as well. Right?

Rspec hangs after it finishes running through my tests

Esrever

const str = 'mañana mañana' const strReverse = str.split('').reverse().join('') // => "anãnam anañam" // notice how the first word has an ã rather ñ

However, this way of thinking about the built-in sameness operators is not a model that can be stretched to allow a place for ES2015's Object.is on this "spectrum". Object.is isn't "looser" than double equals or "stricter" than triple equals, nor does it fit somewhere in between (i.e., being both stricter than double equals, but looser than triple equals). We can see from the sameness comparisons table below that this is due to the way that Object.is handles NaN. Notice that if Object.is(NaN, NaN) evaluated to false, we could say that it fits on the loose/strict spectrum as an even stricter form of triple equals, one that distinguishes between -0 and +0. The NaN handling means this is untrue, however. Unfortunately, Object.is has to be thought of in terms of its specific characteristics, rather than its looseness or strictness with regard to the equality operators.

A model for understanding equality comparisons

For those coming from Ruby, Javascript has no builtin method like Ruby’s Array#compact.

Another option is the use the functional library Ramda, while the syntax may be a bit different from the Ruby and Pure JS version, I find it to be more declarive: list = [null, "say", "kenglish", "co", null] R.reject(R.isNil, list) // return new array [ 'say', 'kenglish', 'co' ]

The issue seems to be that when there are multiple layouts configured, VS Code sets as key layout the first value for layout form setxkbmap -query, ignoring the current layout. If I switch to be en,de then VS Code uses the EN layout, as it is the first in the list. It would be handy if VS Code could use the current layout instead of the first from the list.

xdotool key ctrl+R;

jq '.profile.exit_type= "Normal" | .profile.exited_cleanly = true' ~pi/.config/chromium/Default/Preferences

sed -i 's/"exited_cleanly":false/"exited_cleanly":true/' ~/.config/chromium/Default/Preferences sed -i 's/"exit_type": "Crashed"/"exit_type": "Normal"/' ~/.config/chromium/Default/Preferences

The best way to now perform this task, without having to use incognito, is to adjust two settings in the Chromium preferences. They are: exited_cleanly exit_type

Disable features that inhibit control and transparency, and add or modify features that promote them (these changes will almost always require manual activation or enabling).

In addition, Google designed Chromium to be easy and intuitive for users, which means they compromise on transparency and control of internal operations.

We will also show you how to de-link your Chrome profile from your Google account(s) by stopping Chrome from syncing with Google in the first place. This will help keep your Chrome profile separate from your Google account and enhance your online privacy.

To do that, Chrome automatically links your Chrome profile to a Google account when you sign in to any Google service on the web. That helps Google deliver a ‘seamless experience’ across all devices by letting you sync your history, bookmarks, passwords, etc., across multiple devices. Meanwhile, privacy-conscious users see this as a major threat to their online privacy and advise users to remove their Google account from Chrome.

As mentioned already, Chrome automatically signs you in to your Google account every time you sign into a Google service, like Gmail, YouTube, Google Photos, etc. It also links your current Chrome profile to that account. While Google says that it does so to offer a ‘seamless experience’, it is a privacy nightmare for many users.

Some Chrome users may like the new functionality as it makes it easier for them to sign in or out of Chrome and Google on the Web. Others may dislike it for privacy and user-choice reasons. Think about it, if you sign in to Chrome you are automatically recognized by any Google property on the web as that Google user.

I have all my bookmarks and settings attached to an account which is part of a Gsuite i'm not part of anymore, so i want to resync my chrome with my personal account, but I don't know how to import all the bookmarks and settings from the old Gsuite account to my personal one

let bookmarkList = Array.from(document.querySelectorAll('.widget>.vbox')) .map(e => e.shadowRoot) .map(e => e && e.querySelector('.device-page-list')) .find(e => e); let bookmarks = Array.from(bookmarkList.querySelectorAll('.vbox')) .map(e => `[${e.querySelector('.device-page-title').innerHTML}](${e.querySelector('x-link').innerHTML})`); copy(bookmarks.join('\n'));

Having a large extension ecosystem is something that can help deal with the lack of certain capabilities, as third-party developers can create their own add-ons that others might find useful as well.

Exporting your active tabs to a TXT or HTML file is something that many people want to do, but which is impossible right now in Google Chrome without turning to an extension.

Desktop files are NOT executed. The line inside them that has an executable command line is the one that gets executed. The rest of the file is parsed by the Desktop Environment.

Upvoted on techical merit; but the correct answer which should be accepted is

Please note that gtk-launch requires the .desktop file to be installed (i.e. located in /usr/share/applications or $HOME/.local/share/applications). So to get around this, we can use a hackish little bash function that temporarily installs the desired .desktop file before launching it. The "correct" way to install a .desktop file is via desktop-file-install but I'm going to ignore that.

Analytics is the key to understanding your app's users: Where are they spending the most time in your app? When do they churn? What actions are they taking?

Users are only counted in the steps they complete in the specified sequence. If the user misses a step, they fall out of the funnel and aren't counted in any subsequent steps.

const fetchWithJSONHeaders = applyDefaults(fetch, { headers: { "Content-Type": "application/json" } }); const fetchWithTextHeaders = applyDefaults(fetch, { headers: { "Content-Type": "application/text" } }); // Fetch JSON content const response = await fetchWithJSONHeaders("/users", { method: "GET" });

function applyDefaults(fetchFn: typeof fetch, defaults: Required<Parameters<typeof fetch>[1]>)

In rare cases, the underlying types aren't exposed from the library. What shall we do then? Maybe we could also use the typeof operator here too and combine it with a TypeScript's built-in type Parameters. Parameters becomes useful whenever you want to extract the type of parameters from a function type:

But there is a lot of things we didn’t handle: How do we pass function arguments through? How do we maintain scope (the value of this)? How do we get the return value? What if an error happens?

A wrapper function is a design concept where a very minimal function is using another function to do it's "work" for it, sometimes using a slightly different set of arguments.

From a client side/application (as a whole) standpoint this is an internal endpoint, for the router of SvelteKit this would be an external resource.

I interpreted it more like "you can (for example) use serverFetch for external resources", rather than "serverFetch is exclusively for fetching external resources"

So if I just forward the cookie header (which contains the access-token), wouldn't that be just what I am not supposed to do. I mean what's the point of using 'HttpOnly' flag if I return the token to the client-side js on every request.

while with server/externalFetch there is no direct way to pass cookie headers from the original request to the external one

You're right, this discussion is starting to go off on a tangent.

Honestly, I think the current discussion has nothing to do with my original issue anymore.

With httponly you only prevent to read the cookie with js, but its still possible to make requests in the name of the user.

They are on client-side, but (usually) they are HTTPOnly. Now if they are part of session, any client-side script is able to access them, and I just don't like introducing vulnerabilities knowingly. As I said above, I found a workaround that works for me and you may have different opinion from me on how much this is a risk.

Right now I am working around this issue by having an internal [...api].js, then call fetch for that endpoint (which automatically passes on cookies) and from there hit the actual external endpoint. It works, there is no risk of leaking anything, but imo shouldn't be necessary.

Sure you can abuse session but I don't like that since there is the risk of exposing credentials to client side code.

Also the problem becomes even worse if you multiple api/resource servers and have to decide in each load function which credentials should be exposed to which server.

I am currently circumventing this issue by using getSession to have access to the cookies/headers in the load method

that is not ideal, since for example 'Cookie' is a forbidden header name, so I have to start worrying about env in load, which is kind of contra to its design.

serverFetch name is unclear. That the docs need to say in bold that it's external is a bit of a code smell.

Rename to externalFetch. That it runs on the server is already implied by it being located in hooks

This function allows you to modify (or replace) a fetch request for an external resource that happens inside a load function that runs on the server (or during pre-rendering). For example, your load function might make a request to a public URL like https://api.yourapp.com when the user performs a client-side navigation to the respective page, but during SSR it might make sense to hit the API directly (bypassing whatever proxies and load balancers sit between it and the public internet).

Because I have already had public API, I don't want to provide an extra "proxy" API by SvelkteKit.

File structure

Collapsing directories Say some directories in a project exist for organizational purposes only, and you prefer not to have them as namespaces. For example, the actions subdirectory in the next example is not meant to represent a namespace, it is there only to group all actions related to bookings: booking.rb -> Booking booking/actions/create.rb -> Booking::Create

You do not configure Zeitwerk manually in a Rails application. Rather, you configure the application using the portable configuration points explained in this guide, and Rails translates that to Zeitwerk on your behalf.

Inflections go the other way around.In classic mode, given a missing constant Rails underscores its name and performs a file lookup. On the other hand, zeitwerk mode checks first the file system, and camelizes file names to know the constant those files are expected to define.While in common names these operations match, if acronyms or custom inflection rules are configured, they may not. For example, by default "HTMLParser".underscore is "html_parser", and "html_parser".camelize is "HtmlParser".

All these problems are solved in zeitwerk mode, it just works as expected, and require_dependency should not be used anymore, it is no longer needed.

For example, there is no point in defining reloadable Rack middleware, because changes would not be reflected in the instance stored in the middleware stack anyway

it does not belong to the autoload paths by default but it belongs to $LOAD_PATH

For historical reasons, this callback may run twice. The code it executes must be idempotent.

Applications can safely autoload constants during boot using a reloader callback: Rails.application.reloader.to_prepare do $PAYMENT_GATEWAY = Rails.env.production? ? RealGateway : MockedGateway end Rails.application.reloader.to_prepare do $PAYMENT_GATEWAY = Rails.env.production? ? RealGateway : MockedGateway end Copy That block runs when the application boots, and every time code is reloaded.

For instance, the application could define a class method PaymentGateway.impl whose definition depends on the environment; or could define PaymentGateway to have a parent class or mixin that depends on the environment

On reload, MockedGateway is reloaded, but $PAYMENT_GATEWAY is not updated because initializers only run on boot. Therefore, it won't reflect the changes.

It is very important to understand that Ruby does not have a way to truly reload classes and modules in memory, and have that reflected everywhere they are already used. Technically, "unloading" the User class means removing the User constant via Object.send(:remove_const, "User").

Please, do not mutate ActiveSupport::Dependencies.autoload_paths, the public interface to change autoload paths is config.autoload_paths.

That may speed legit require calls a bit

One of the most known principles of software development is DRY - Don't Repeat Yourself - which is about avoiding code redundancy.

QueueStore

export interface QueueInterface {   count(): number;   dequeue?(): any;   enqueue(...args: any): void;   flush(): any[];   reset(): void;   setFifo(fifo: boolean): void;   setLifo(lifo: boolean): void;   truncate(length: number): void; } export class queue {   protected elements: any[];   protected fifo = true;   constructor(…args: any) {     this.elements = […args];   }   count() {     return this.elements.length;   }   dequeue?(): any {     if (this.fifo) {       return this.elements.shift();     }     return this.elements.pop();   }   enqueue(…args: any) {     return this.elements.push(…args);   }   // Like dequeue but will flush all queued elements   flush(): any[] {     let elms = [];     while (this.count()) {       elms.push(this.dequeue());     }     return elms;   }   setFifo(fifo = true) {     this.fifo = fifo;   }   setLifo(lifo = true) {     this.fifo = !lifo;   }   reset(): void {     this.truncate(0);   }   truncate(length: number) {     if (Number.isInteger(length) && length > -1) {       this.elements.length = length;     }   } } export default queue;

For me however, things get really interesting with the creation of “custom” stores. The creators of Svelte were/are obviously well aware of the power and flexibility of these stores and have provided a simply interface to adhere to. Basically, any object that implements the “subscribe” method is a store!

One of the (in my opinion) most useful components of the Svelte library is that of “stores”.

Feed Army is a browser based unified dashboard for all your social media & online feeds.

browser based

And on any given day, developing with Svelte and its reactive nature is simply a dream to use. You can tell Svelte to track state changes on practically anything using the $: directive. And it’s quite likely that your first reactive changes will produce all the expected UI results.

And on any given day, developing with Svelte and its reactive nature is simply a dream to use. You can tell Svelte to track state changes on practically anything using the $: directive. And it’s quite likely that your first reactive changes will produce all the expected UI results. But as you start to rely more on UI updates based on variable or array/object changes, it’s likely that your UI will start skipping a beat and dropping values that you know explicitly to be there.

what is the conventional way

Personally I think option 1 is the way to go as it doesn't allocate any memory to create a new array but rather modifies the existing array. Then the assignment just lets the compiler know that you modified the array.

It's a grammar that makes heavy use of regular expressions. So make sure you brush up your skill on backward/forward references and lookarounds, because all these can be used.

TylerRick - HypothesisYour browser indicates if you've visited this linkhttps://hypothes.is › users › TylerRick

If you still have problems, please open a ticket and let us know: Your order number The key you're having trouble activating (please tell us exactly what you're entering) The message displayed by Steam That you've already tried logging out and back into Steam and then still couldn't activate the key.

There are ways to get around the prerequisites of buying this respirator. It is not like you are buying an illegal item, so if you get the chance, you should get this best mask for mold removal.

Where connecting plastic pipe to other types of plastic or other types of piping material; approved listed adapter or transition fittings and listed for the specific transition intended shall be used.

Just for fun, I did a little experimenting at home to show how some of these different types of cement hold up. I started by cementing a bunch of materials together with a bunch of different types of cement. I waited 24 hours, then cut each one roughly in half, down the middle.

Laying a drainage pipe for plumbing is a job for professionals. Most cities and homeowner’s associations won’t look kindly upon extensive do-it-yourself excavation projects.

The Code Expressly prohibits glueing dissimilar plastics together: Listed under "Prohibited Joints" "No glue joints between different tyes of plastic" REF: International Residential Code 2904.16.2 Uniform Plumbing Code 316.1.6 It is true that Oatey makes a glue that is listed as approved for both ABS & PVC however there still remains a good reason why it is not approved for glueing dissimilar types of plastics together. In a normal glueing situation the bonding material sticks to the surface of both pieces being fastened together, thus forming a bond, but such is not the case with plastic plumbing pipe and fittings. When connecting plastic plumbing fittings we must first use a solvent type cleaner/primer. While the cleaner primer does clean the fitting, its primary purpose is to soften or break the smooth glazed surface of the pipe which exposes the inner polimers. The glue then chemically softens the plastic on both the pipe wall and the fitting interior and the two surfaces then fuse together forming a chemical weld. The problem with attempting to glue dissimilar plastic is that they do not react to the glue at the same rate, therefore one material may soften and reharden again before the other surface has softened sufficiently to fuse a true weld. The end result is that while it has all the appearances of having glued together you are left with a weak joint, in the same manner as a cold solder joint.

Best demonstration: glue PVC inside an ABS hub or vice-versa. Cut through the two with a mitre saw and make a nice, clean cut. Look at all the voids where the plastics didn't glue together.

is labeled as a glue for PVC, ABS, CPVC, etc. It's not labelled for gluing different plastics together, only for gluing like plastics together

A plugged vent gives the effect of pouring milk from a jug. Without proper air flow and ventilation, the milk chugs in starts and stops while leaving the jug.

So I told my helper, smart as a whip, if you pour a bottle from slightly above flat, the liquid flows smoothly, but if you tip the bottle up, it glucks.

Anyone here should know it is of extraordinary importance to maintain trap (water) seals. The gas in the downstream is full of methane, odorless and colorless, and it will cause heart and lung problems if let loose inside and lived with. That should be written on the sky.

PVC DWV is dense, straight, and durable; also approved for use.ABS ("black") and PVC expand and contract differently, don't intermember directly. There's a flexible cement available.

My question is, wye is a sanitary tee directional? I maintain that a two way sweep would be a more efficient vent.

Installing a sanitary tee and wye drain, or any multi-outlet drainage fitting requires basic plumbing knowledge. Once you know the basics, it is easy to install this kind of piping system without hiring outside assistance.

A sanitary tee is shaped like the letter ‘T’, while a Wye is similar to ‘Y’. Sanitary tee is used for horizontal to vertical transition, and Wye is used for combining 2 lines into one horizontal line to maintain a flow without causing clogging.

Sanitary Tee and Wye are parts of the drain vent system. If you are doing plumbing works, you may have to use them in some sort. However, they look almost similar, and this confuses a lot of people. Especially to choose the one that best fits your drain system.

We also made it simple to switch displays between HiDPI and LoDPI.  This is especially useful for applications like GIMP and Inkscape whose toolkits do not support HiDPI and appear very small in HiDPI screens.

We’ve also included GSettings and a DBus API to allow other distros to create their own graphical interfaces to the daemon.

Does this daemon benefit me in anyway or is it only used for mismatched resolutions like 1440p with a 1080p display?

Commenting on a recent case from the Washington State Court of Appeals, it says that the outcome “signals a strong return to the legal principle of caveat emptor – otherwise known as ‘buyer beware’.” This ruling is interpreted to mean that “the seller may now intentionally conceal a defect and lie about it, and as long as the buyer’s inspector has some indication of a potential problem and the buyer fails to investigate further, the seller will survive a lawsuit.”

Running containers without Docker is possible with Podman.

daemonless container engine

Hence, Podman allows the creation and execution of Pods from a Kubernetes YAML file (see podman-play-kube). Podman can also generate Kubernetes YAML based on a container or Pod (see podman-generate-kube), which allows for an easy transition from a local development environment to a production Kubernetes cluster.

We believe that Kubernetes is the defacto standard for composing Pods and for orchestrating containers, making Kubernetes YAML a defacto standard file format.

Simply put: alias docker=podman.

What is Podman? Podman is a daemonless container engine for developing, managing, and running OCI Containers on your Linux System.

I find Alt + right-click + drag to be the most convenient way to do this.

gsettings set org.gnome.desktop.wm.keybindings move-to-center "['<Control><Super>c']" gsettings set org.gnome.desktop.wm.keybindings move-to-side-e "['<Control><Super>Right']" gsettings set org.gnome.desktop.wm.keybindings move-to-side-n "['<Control><Super>Up']" gsettings set org.gnome.desktop.wm.keybindings move-to-side-s "['<Control><Super>Down']" gsettings set org.gnome.desktop.wm.keybindings move-to-side-w "['<Control><Super>Left']"

Move a window by dragging the titlebar, or hold down Super and drag anywhere in the window.

You can choose the displayed language by adding a language suffix to the web address so it ends with e.g. .html.en or .html.de. If the web address has no language suffix, the preferred language specified in your web browser's settings is used. For your convenience: [ Change to English Language | Change to Browser's Preferred Language ]

In principle, one can type these directly but you'd have to know the Unicode code points

The key to a functional island fixture vent is that the top elbow must be at least as high as the "flood level" (the peak possible drain water level in the sink). This is to ensure that the vent does not become a de facto drain should the actual drain get clogged.

One of the most common traps to dry out are floor drains such as those typically placed near home furnaces, water heaters and rooms with underfloor heating.

I'm trying to help in some way by bringing these issues to light so a discussion about them can take place.

The number of complaints across the issue tracker and the lack of substantive followup on many of those complaints should be ample evidence that these frustrated users exist and are likely about to leave Fenix behind in droves, if they haven't already.

avoiding a browser monoculture

I honestly believe that if more people aren't aware of these issues, Firefox for Android might soon end up dying a slow, painful death as its users give up in frustration and leave for better web browsers.

I have always rooted for Mozilla in preventing Google from obtaining unequivocal control of what has become the most critical software platform in the modern era, one that holds relevance in nearly everyone's life: the web.

The point of DoH is to bypass any other DNS or censorship further down the line.If you want to use DoH AND your hosts file then you need to use DoH as your OS's DNS so it is after the hosts file.

Also blacklist use-application-dns.n

t's also why it is so annoying to people who actually know what they are doing, when randomly the browser decides to take over a function provided for decades by the OS network stack, and with no notice start bypassing all the infrastructure they set up to their liking (like your hosts file) and funelling all their browsing habits to some shady company (Cloudflare).

It is also why it's implementation in firefox is completely useless, considering that windows/osx/most linux distros plan to add support for DoH/DoT/DNScrypt resolvers in the near future, so firefox doing it itself will provide no additional benefit.

The whole point of DoH in firefox is to not depend on the OS like windows. And it is the OS, which implements the hosts file mechanism.

those users apparently can't even be trusted to choose the option to enable it from a pop-up

How can we get action on the bugzilla bug mentioned above to cause this to be fixed?

If you want to check that the "usual" resolution is working (i.e. the way specified in /etc/nsswitch.conf) you can use getent: getent hosts www.winaproduct.com

If your configuration is not provided by a name server (like the information given in /etc/hosts) those tools will not show them, because they directly ask the name server.

If you want to find the bug, you can run a mozregression to find what broke it (using 70 as your last known good release and 71 as your bad release).

Mac: "3-bar" menu button (or Firefox menu) > Preferences Windows: "3-bar" menu button (or Tools menu) > Options Linux: "3-bar" menu button (or Edit menu) > Preferences

The browser (on PC operating systems) always has a choice to not use the system-provided mechanisms in the first place. It can send its own UDP packets or make TCP connections.

Does Firefox ignore the hosts file? How to make Firefox honor the hosts file

And the latter (DHCP server) is great because it means that all machines connecting to your router will now have their DNS requests routed through your Pi-Hole.

Why is my hosts file entry being ignored by the browser?

Therefore, Firefox already contains the code to look in the hosts file, but it does things in the wrong order: 1. Look up the URL in the DNS server if not found: 2. Send the URL to the default search engine as a search term if not found: 3. Look in the hosts file

The entries in the hosts file are obviously not on a DNS server. Setting the keyword.enabled option FALSE by itself should only turn off the feature that uses the address field as a search field. It would not give Firefox an additional ability that it did not have before.

Firefox ignores the presence of the hosts file, never using it to resolve a URL.

they know about this problem and have willfully and negligently—and perhaps maliciously—ignored it for at least eight years.