mime: incorrect mime-type for .js files on windows 10 (text/plain instead of application/javascript)

Question

mime: incorrect mime-type for .js files on windows 10 (text/plain instead of application/javascript)

kjk opened this issue 5 years ago · 26 comments

What version of Go are you using (`go version`)?

$ go version
go version go1.12.5 windows/amd64

Does this issue reproduce with the latest release?

Yes

What operating system and processor architecture are you using (`go env`)?

go env Output

$ go env
set GOARCH=amd64
set GOBIN=
set GOCACHE=C:\Users\kjk\AppData\Local\go-build
set GOEXE=.exe
set GOFLAGS=
set GOHOSTARCH=amd64
set GOHOSTOS=windows
set GOOS=windows
set GOPATH=C:\Users\kjk\go
set GOPROXY=
set GORACE=
set GOROOT=C:\Go
set GOTMPDIR=
set GOTOOLDIR=C:\Go\pkg\tool\windows_amd64
set GCCGO=gccgo
set CC=gcc
set CXX=g++
set CGO_ENABLED=1
set GOMOD=C:\Users\kjk\src\apps\offdocs\go.mod
set CGO_CFLAGS=-g -O2
set CGO_CPPFLAGS=
set CGO_CXXFLAGS=-g -O2
set CGO_FFLAGS=-g -O2
set CGO_LDFLAGS=-g -O2
set PKG_CONFIG=pkg-config
set GOGCCFLAGS=-m64 -mthreads -fmessage-length=0 -fdebug-prefix-map=C:\Users\kjk\AppData\Local\Temp\go-build840166758=/tmp/go-build -gno-record-gcc-switches

What did you do?

Consider this program:

package main

import (
	"fmt"
	"mime"
)

func main() {
	ct := mime.TypeByExtension(".js")
	fmt.Printf("ct: %s\n", ct)
}

https://play.golang.org/p/JTVjWc9xMDE

What did you expect to see?

Mime-type for .js files should be application/javascript on all platforms.

What did you see instead?

On Linux it returns ct: application/javascript

On my latest Windows 10 it returns ct: text/plain; charset=utf-8

This also affects Content-Type returned by http.ServeFile() for .js files.

This is because in src\mime\type.go:

func initMime() {
	if fn := testInitMime; fn != nil {
		fn()
	} else {
		setMimeTypes(builtinTypesLower, builtinTypesLower)
		osInitMime()
	}
}

On Windows osInitMime() reads info for additional extensions from registry and over-writes mime-type for .js files.

Note: it's possible this won't repro on every version on Windows.

Reversing the initialization order should fix it:

osInitMime()
setMimeTypes(builtinTypesLower, builtinTypesLower)

Answer 1 · 2019-05-31T23:32:41.000Z

Reversing the order would be a pretty heavy-handed fix. Local system configuration should have precedence over the builtin defaults.

Does this issue reproduce on a clean Windows install?

Answer 2 · 2019-08-27T02:36:48.000Z

This issue started to appear out of the blue on a Windows 10 1903 install (go 1.12.9).

Answer 3 · 2019-08-27T02:39:49.000Z

A terrible work-around:

var builtinMimeTypesLower = map[string]string{
	".css":  "text/css; charset=utf-8",
	".gif":  "image/gif",
	".htm":  "text/html; charset=utf-8",
	".html": "text/html; charset=utf-8",
	".jpg":  "image/jpeg",
	".js":   "application/javascript",
	".wasm": "application/wasm",
	".pdf":  "application/pdf",
	".png":  "image/png",
	".svg":  "image/svg+xml",
	".xml":  "text/xml; charset=utf-8",
}

func staticFileGetMimeType(ext string) string {
	if v, ok := builtinMimeTypesLower[ext]; ok {
		return v
	}
	return mime.TypeByExtension(ext)
}

Answer 4 · 2019-08-27T02:59:06.000Z

~~On Windows7, mime type of .js is application/javascript:~~

Sorry, it may not be default configuration.

C:\>reg query HKCR\.js /v "Content Type"

HKEY_CLASSES_ROOT\.js
    Content Type    REG_SZ    application/javascript

Answer 5 · 2019-08-27T03:32:56.000Z

Interesting, I wonder what is changing this. Thanks for the pointer.

C:\>reg query HKCR\.js /v "Content Type"

HKEY_CLASSES_ROOT\.js
    Content Type    REG_SZ    text/plain

Answer 6 · 2019-08-27T05:04:16.000Z

As a result that I swimed in internet for 10 minutes, I figure out this value of the registory key seems to be possibly changed by some text editor or casual confguration.

https://timothytocci.com/tag/registry/ (text/plain)

https://www.jianshu.com/p/a443991462d7 (application/x-javascript)

And it is not registered in default on Windows 10. I think this should not be set from registory. Or should be non-overwritable.

Answer 7 · 2019-08-27T05:43:37.000Z

Change https://golang.org/cl/191917 mentions this issue: mime: do not change initial configuration for mimeTypes

Answer 8 · 2019-09-06T12:20:15.000Z

builtinTypesLower is safe. it is not overwritable. mime.types or registory is NOT safe. This can be added to mimeTypes easily. (ex with installing text editor on Windows). So cl191917 disable overwrite to mimeTypes from mime.types or registory. What about this?

Answer 9 · 2019-11-25T06:57:25.000Z

Currently this issue prevents service worker to load as browsers block it if it's content type is not JavaScript

Answer 10 · 2020-02-27T22:51:19.000Z

Hey, just wanted to mention that I have created a little tool to check if the problem is also caused on your machine and to fix the issue by setting the mentioned registry key to the expected value application/javascript. Just if someone might be interested.

https://github.com/zekroTJA/go-win-mime-fix

Answer 11 · 2020-05-29T08:58:58.000Z

Hi
I think that this is caused by the registry settings in windows 10.

If you are looking for a temporary solution, please import the following registry items:

Windows Registry Editor Version 5.00

[HKEY_CLASSES_ROOT\.js]
"Content Type"="text/javascript"

[HKEY_LOCAL_MACHINE\SOFTWARE\Classes\.js]
"Content Type"="text/javascript"

IMHO this one is caused by system, but not golang itself.

Did I miss something?

Answer 12 · 2020-07-15T20:11:35.000Z

There seems to be some evolution.
On Windows 10 latest, registry key only defines the file type and no Content Type appears.

%GOPATH%\mime>ver

Microsoft Windows [Version 10.0.18363.959]

%GOPATH%\mime>go version
go version go1.14.5 windows/amd64

%GOPATH%\mime>reg query HKCR\.js

HKEY_CLASSES_ROOT\.js
    (Default)    REG_SZ    JSFile

HKEY_CLASSES_ROOT\.js\PersistentHandler

%GOPATH%\mime>go run jsmimetype.go
ct: text/javascript; charset=utf-8

These values appear in line with Mozilla documentation.

Answer 13 · 2020-09-28T18:20:53.000Z

Hi
I think that this is caused by the registry settings in windows 10.

If you are looking for a temporary solution, please import the following registry items:
Windows Registry Editor Version 5.00

[HKEY_CLASSES_ROOT\.js]
"Content Type"="text/javascript"

[HKEY_LOCAL_MACHINE\SOFTWARE\Classes\.js]
"Content Type"="text/javascript"
IMHO this one is caused by system, but not golang itself.

Did I miss something?

The requirement of the mime package should be to correctly ascertain the mime type of common files, regardless of Windows registry settings. If a web server can't properly serve up a js file, that's a major facepalm right there.

For .js, .html, and .css, the code should return the expected mime type on Windows if the Content Type registry value is missing. Those three are sensible special cases for fallbacks in case of missing values in the Windows registry.

Answer 14 · 2020-10-16T04:04:31.000Z

Same problem persists in Win 10 with go 1.15.3

Answer 15 · 2021-06-18T19:16:53.000Z

Same problem on Go 1.16.2

Answer 16 · 2021-06-18T20:55:58.000Z

cc @neild for decision, though i believe this is working as intended

Answer 17 · 2021-06-22T00:57:58.000Z

cc @neild for decision, though i believe this is working as intended

Unfortunately, the docs contain this sentence: "On Windows, MIME types are extracted from the registry." This means that Microsoft can and did break the behavior of TypeByExtension. (Maybe we need a function called TypeByExtensionButIgnoringMicrosoftInsanity. ;) )

One could make the argument that the requirement for TypeByExtension is to return expected mime types, not merely types subject to Microsoft's breakage. In fact, MDN states explicitly this:

Per the HTML specification, JavaScript files should always be served using the MIME type text/javascript. No other values are considered valid, and using any of those may result in scripts that do not load or run.

Arguably, the current implementation is incorrect because it depends on an unreliable operating system feature. Adherence to the expectations of millions of developers and to industry standards should be the requirement. The requirement should not be to comply with an unreliable Windows feature.

Changing the function to ignore Microsoft's insanity would be a breaking change, but maybe a breaking change is better than a function whose implementation allows it to be broken by Microsoft. Therefore, for crucial file types -- html, css, and js -- perhaps the mime types should be hardcoded. Yes, a breaking change. But a breaking change that fixes and prevents breakage.

Answer 18 · 2021-06-22T01:15:34.000Z

also @mattn has a PR to disallow the override of this type by default with the option to do it if needed via an argument to setExtensionType

https://go-review.googlesource.com/c/go/+/191917/

Answer 19 · 2021-08-23T14:11:44.000Z

Same issue on Go 1.16.3 but in linux environment

More details can be found here #47912

Answer 20 · 2021-08-31T03:26:33.000Z

Same bug on Go 1.16.4 windows 10 amd64.

Answer 21 · 2021-12-27T09:47:24.000Z

@tushardas ,
Did you solve the issue?
I am facing the same problem on linux env.
Loading module from “http://localhost:3000/polyfills.d103671dae517af0.js” was blocked because of a disallowed MIME type (“text/plain”).

Most of the answers here are for Window's OS, Should there be a separate ticket for Linux?

Answer 22 · 2022-01-13T22:14:37.000Z

Same problem in Windows 11. Go 1.17.5
Simple app:

	fs := http.FileServer(http.Dir("./static"))
	router.PathPrefix("/static/").Handler(http.StripPrefix("/static/", fs))
        log.Fatal(http.ListenAndServe(":8080", router))

In the static folder are some js/vue files, but all .vue files are served as 'text/plain' despite the fact that the content type is set correctly in the registry.

reg query "HKCR\.vue\Content Type"

HKEY_CLASSES_ROOT\.vue\Content Type
    (Default)    REG_SZ    application/javascript

Answer 23 · 2022-01-24T17:28:46.000Z

Windows is just being Windows, wasted half an hour figuring out why JS was served as text/plain

Answer 24 · 2022-05-17T06:43:23.000Z

I had the same problem and I borrowed dvaldivia solution.
If you don't want to change the Windows registry, you can modify it like this in code:

// Execute before the service runs.
func init () {
    _ = mime.AddExtensionType(".js", "text/javascript")
}

Answer 25 · 2022-05-17T19:30:26.000Z

Change https://go.dev/cl/406894 mentions this issue: mime: ignore .js => text/plain in Windows registry

Answer 26 · 2022-05-17T19:30:29.000Z

This situation is clearly unfortunate but I don't think that changing the mime package is the right approach. In general local system configuration should override defaults, not the other way around. I don't know why Windows is providing a strange configuration, but overriding the local configuration is just going to produce a different set of strange bugs.

The problem is not unique to Go; here is the same problem reported for Python: https://bugs.python.org/issue43975 , https://www.taricorp.net/2020/windows-mime-pitfalls/ .

This bug report says that it is a problem with Visual Studio: https://developercommunity.visualstudio.com/t/installer-mime-type-for-js-extension-is-set-to-tex/954263 .

If we do something here it should be a very focused fix on this specific problem. I suggest https://go.dev/cl/406894. Can somebody who is encountering this problem on their Windows system please see if that patch fixes it? Thanks.

What version of Go are you using (go version)?