From 34675d3edcf44d1a714613c549ad83a1c31d0faf Mon Sep 17 00:00:00 2001
From: Charles Iliya Krempeaux <iamreiver@gmail.com>
Date: Mon, 14 Aug 2023 05:30:30 -0700
Subject: [PATCH] modified package-level global errors in the way the new error
 package Unwrap(), etc understands it

---
 badgateway.go                    | 6 +-----
 badrequest.go                    | 6 +-----
 conflict.go                      | 6 +-----
 expectationfailed.go             | 6 +-----
 faileddependency.go              | 6 +-----
 forbidden.go                     | 6 +-----
 gatewaytimeout.go                | 6 +-----
 gone.go                          | 6 +-----
 httpversionnotsupported.go       | 6 +-----
 insufficientstorage.go           | 6 +-----
 internalservererror.go           | 6 +-----
 lengthrequired.go                | 6 +-----
 locked.go                        | 6 +-----
 loopdetected.go                  | 6 +-----
 methodnotallowed.go              | 6 +-----
 networkauthenticationrequired.go | 6 +-----
 notacceptable.go                 | 6 +-----
 notextended.go                   | 6 +-----
 notfound.go                      | 6 +-----
 notimplemented.go                | 6 +-----
 payloadtoolarge.go               | 6 +-----
 paymentrequired.go               | 6 +-----
 preconditionfailed.go            | 6 +-----
 preconditionrequired.go          | 6 +-----
 proxyauthrequired.go             | 6 +-----
 requestedrangenotsatisfiable.go  | 6 +-----
 requestentitytoolarge.go         | 6 +-----
 requestheaderfieldstoolarge.go   | 6 +-----
 requesttimeout.go                | 6 +-----
 requesturitoolong.go             | 6 +-----
 serviceunavailable.go            | 6 +-----
 teapot.go                        | 6 +-----
 toomanyrequests.go               | 6 +-----
 unauthorized.go                  | 6 +-----
 unavailableforlegalreasons.go    | 6 +-----
 unprocessableentity.go           | 6 +-----
 unsupportedmediatype.go          | 6 +-----
 upgraderequired.go               | 6 +-----
 uritoolong.go                    | 6 +-----
 variantaisonegotiates.go         | 6 +-----
 40 files changed, 40 insertions(+), 200 deletions(-)

diff --git a/badgateway.go b/badgateway.go
index 99de2ae..1bf76dc 100644
--- a/badgateway.go
+++ b/badgateway.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error      = internalBadGateway{}
 var _ BadGateway = internalBadGateway{}
 
-var ErrBadGateway error = BadGatewayWrap(errors.New("Bad Gateway"))
+var ErrBadGateway error = BadGatewayWrap(nil)
 
 type BadGateway interface {
 	ServerError
diff --git a/badrequest.go b/badrequest.go
index 4000eb7..b98aa37 100644
--- a/badrequest.go
+++ b/badrequest.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error      = internalBadRequest{}
 var _ BadRequest = internalBadRequest{}
 
-var ErrBadRequest = BadRequestWrap(errors.New("Bad Request"))
+var ErrBadRequest = BadRequestWrap(nil)
 
 type BadRequest interface {
 	ClientError
diff --git a/conflict.go b/conflict.go
index a1e4062..3d30cd1 100644
--- a/conflict.go
+++ b/conflict.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error    = internalConflict{}
 var _ Conflict = internalConflict{}
 
-var ErrConflict = ConflictWrap(errors.New("Conflict"))
+var ErrConflict = ConflictWrap(nil)
 
 type Conflict interface {
 	ClientError
diff --git a/expectationfailed.go b/expectationfailed.go
index 30bd594..f89dc36 100644
--- a/expectationfailed.go
+++ b/expectationfailed.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error             = internalExpectationFailed{}
 var _ ExpectationFailed = internalExpectationFailed{}
 
-var ErrExpectationFailed error = ExpectationFailedWrap(errors.New("Expectation Failed"))
+var ErrExpectationFailed error = ExpectationFailedWrap(nil)
 
 type ExpectationFailed interface {
 	ClientError
diff --git a/faileddependency.go b/faileddependency.go
index bfcfec5..16054b4 100644
--- a/faileddependency.go
+++ b/faileddependency.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error            = internalFailedDependency{}
 var _ FailedDependency = internalFailedDependency{}
 
-var ErrFailedDependency error = FailedDependencyWrap(errors.New("Failed Dependency"))
+var ErrFailedDependency error = FailedDependencyWrap(nil)
 
 type FailedDependency interface {
 	ClientError
diff --git a/forbidden.go b/forbidden.go
index bc7840f..41a06f7 100644
--- a/forbidden.go
+++ b/forbidden.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error     = internalForbidden{}
 var _ Forbidden = internalForbidden{}
 
-var ErrForbidden error = ForbiddenWrap(errors.New("Forbidden"))
+var ErrForbidden error = ForbiddenWrap(nil)
 
 type Forbidden interface {
 	ClientError
diff --git a/gatewaytimeout.go b/gatewaytimeout.go
index 969a0ce..d8df590 100644
--- a/gatewaytimeout.go
+++ b/gatewaytimeout.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error          = internalGatewayTimeout{}
 var _ GatewayTimeout = internalGatewayTimeout{}
 
-var ErrGatewayTimeout error = GatewayTimeoutWrap(errors.New("Gateway Timeout"))
+var ErrGatewayTimeout error = GatewayTimeoutWrap(nil)
 
 type GatewayTimeout interface {
 	ServerError
diff --git a/gone.go b/gone.go
index 132c249..1854246 100644
--- a/gone.go
+++ b/gone.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error = internalGone{}
 var _ Gone  = internalGone{}
 
-var ErrGone error = GoneWrap(errors.New("Gone"))
+var ErrGone error = GoneWrap(nil)
 
 type Gone interface {
 	ClientError()
diff --git a/httpversionnotsupported.go b/httpversionnotsupported.go
index 28b7c2c..15cf43e 100644
--- a/httpversionnotsupported.go
+++ b/httpversionnotsupported.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error                   = internalHTTPVersionNotSupported{}
 var _ HTTPVersionNotSupported = internalHTTPVersionNotSupported{}
 
-var ErrHTTPVersionNotSupported error = HTTPVersionNotSupportedWrap(errors.New("HTTP Version Not Supported"))
+var ErrHTTPVersionNotSupported error = HTTPVersionNotSupportedWrap(nil)
 
 type HTTPVersionNotSupported interface {
 	ServerError
diff --git a/insufficientstorage.go b/insufficientstorage.go
index 36cb319..085c573 100644
--- a/insufficientstorage.go
+++ b/insufficientstorage.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error               = internalInsufficientStorage{}
 var _ InsufficientStorage = internalInsufficientStorage{}
 
-var ErrInsufficientStorage error = InsufficientStorageWrap(errors.New("Insufficient Storage"))
+var ErrInsufficientStorage error = InsufficientStorageWrap(nil)
 
 type InsufficientStorage interface {
 	ServerError
diff --git a/internalservererror.go b/internalservererror.go
index d2d34a4..8c35e2d 100644
--- a/internalservererror.go
+++ b/internalservererror.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error               = internalInternalServerError{}
 var _ InternalServerError = internalInternalServerError{}
 
-var ErrInternalServerError error = InternalServerErrorWrap(errors.New("Internal Server Error"))
+var ErrInternalServerError error = InternalServerErrorWrap(nil)
 
 type InternalServerError interface {
 	ServerError
diff --git a/lengthrequired.go b/lengthrequired.go
index 6842b86..0a9cbde 100644
--- a/lengthrequired.go
+++ b/lengthrequired.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error          = internalLengthRequired{}
 var _ LengthRequired = internalLengthRequired{}
 
-var ErrLengthRequired error = LengthRequiredWrap(errors.New("Length Required"))
+var ErrLengthRequired error = LengthRequiredWrap(nil)
 
 type LengthRequired interface {
 	ClientError
diff --git a/locked.go b/locked.go
index 60f4871..b5d01d3 100644
--- a/locked.go
+++ b/locked.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error  = internalLocked{}
 var _ Locked = internalLocked{}
 
-var ErrLocked error = LockedWrap(errors.New("Locked"))
+var ErrLocked error = LockedWrap(nil)
 
 type Locked interface {
 	ClientError
diff --git a/loopdetected.go b/loopdetected.go
index 1b95c2d..4e71137 100644
--- a/loopdetected.go
+++ b/loopdetected.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error        = internalLoopDetected{}
 var _ LoopDetected = internalLoopDetected{}
 
-var ErrLoopDetected error = LoopDetectedWrap(errors.New("Loop Detected"))
+var ErrLoopDetected error = LoopDetectedWrap(nil)
 
 type LoopDetected interface {
 	ServerError
diff --git a/methodnotallowed.go b/methodnotallowed.go
index 8b33bb0..4a666d7 100644
--- a/methodnotallowed.go
+++ b/methodnotallowed.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error            = internalMethodNotAllowed{}
 var _ MethodNotAllowed = internalMethodNotAllowed{}
 
-var ErrMethodNotAllowed error = MethodNotAllowedWrap(errors.New("Method Not Allowed"))
+var ErrMethodNotAllowed error = MethodNotAllowedWrap(nil)
 
 type MethodNotAllowed interface {
 	ClientError
diff --git a/networkauthenticationrequired.go b/networkauthenticationrequired.go
index 3238bbd..3535c0a 100644
--- a/networkauthenticationrequired.go
+++ b/networkauthenticationrequired.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error                         = internalNetworkAuthenticationRequired{}
 var _ NetworkAuthenticationRequired = internalNetworkAuthenticationRequired{}
 
-var ErrNetworkAuthenticationRequired error = NetworkAuthenticationRequiredWrap(errors.New("Network Authentication Required"))
+var ErrNetworkAuthenticationRequired error = NetworkAuthenticationRequiredWrap(nil)
 
 type NetworkAuthenticationRequired interface {
 	ServerError
diff --git a/notacceptable.go b/notacceptable.go
index b8165a9..8de4077 100644
--- a/notacceptable.go
+++ b/notacceptable.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error         = internalNotAcceptable{}
 var _ NotAcceptable = internalNotAcceptable{}
 
-var ErrNotAcceptable error = NotAcceptableWrap(errors.New("Not Acceptable"))
+var ErrNotAcceptable error = NotAcceptableWrap(nil)
 
 type NotAcceptable interface {
 	ClientError
diff --git a/notextended.go b/notextended.go
index 3cc6be1..24e2c98 100644
--- a/notextended.go
+++ b/notextended.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error       = internalNotExtended{}
 var _ NotExtended = internalNotExtended{}
 
-var ErrNotExtended error = NotExtendedWrap(errors.New("Not Extended"))
+var ErrNotExtended error = NotExtendedWrap(nil)
 
 type NotExtended interface {
 	ServerError
diff --git a/notfound.go b/notfound.go
index 003b699..c3c788d 100644
--- a/notfound.go
+++ b/notfound.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error    = internalNotFound{}
 var _ NotFound = internalNotFound{}
 
-var ErrNotFound error = NotFoundWrap(errors.New("Not Found"))
+var ErrNotFound error = NotFoundWrap(nil)
 
 type NotFound  interface {
 	ClientError
diff --git a/notimplemented.go b/notimplemented.go
index 4cbd9fc..9c19965 100644
--- a/notimplemented.go
+++ b/notimplemented.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error          = internalNotImplemented{}
 var _ NotImplemented = internalNotImplemented{}
 
-var ErrNotImplemented error = NotImplementedWrap(errors.New("Not Implemented"))
+var ErrNotImplemented error = NotImplementedWrap(nil)
 
 type NotImplemented interface {
 	ServerError
diff --git a/payloadtoolarge.go b/payloadtoolarge.go
index 2358af6..1fe70b8 100644
--- a/payloadtoolarge.go
+++ b/payloadtoolarge.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error           = internalPayloadTooLarge{}
 var _ PayloadTooLarge = internalPayloadTooLarge{}
 
-var ErrPayloadTooLarge error = PayloadTooLargeWrap(errors.New("Payload Too Large"))
+var ErrPayloadTooLarge error = PayloadTooLargeWrap(nil)
 
 type PayloadTooLarge interface {
 	ClientError
diff --git a/paymentrequired.go b/paymentrequired.go
index f59a85f..f1fa868 100644
--- a/paymentrequired.go
+++ b/paymentrequired.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error           = internalPaymentRequired{}
 var _ PaymentRequired = internalPaymentRequired{}
 
-var ErrPaymentRequired error = PaymentRequiredWrap(errors.New("Payment Required"))
+var ErrPaymentRequired error = PaymentRequiredWrap(nil)
 
 type PaymentRequired interface {
 	ClientError
diff --git a/preconditionfailed.go b/preconditionfailed.go
index aaa9779..d55de39 100644
--- a/preconditionfailed.go
+++ b/preconditionfailed.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error              = internalPreconditionFailed{}
 var _ PreconditionFailed = internalPreconditionFailed{}
 
-var ErrPreconditionFailed error = PreconditionFailedWrap(errors.New("Precondition Failed"))
+var ErrPreconditionFailed error = PreconditionFailedWrap(nil)
 
 type PreconditionFailed interface {
 	ClientError
diff --git a/preconditionrequired.go b/preconditionrequired.go
index 53bf74a..1c19a8c 100644
--- a/preconditionrequired.go
+++ b/preconditionrequired.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error                = internalPreconditionRequired{}
 var _ PreconditionRequired = internalPreconditionRequired{}
 
-var ErrPreconditionRequired error = PreconditionRequiredWrap(errors.New("Precondition Required"))
+var ErrPreconditionRequired error = PreconditionRequiredWrap(nil)
 
 type PreconditionRequired interface {
 	ClientError
diff --git a/proxyauthrequired.go b/proxyauthrequired.go
index f4d062a..8e87cf2 100644
--- a/proxyauthrequired.go
+++ b/proxyauthrequired.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error             = internalProxyAuthRequired{}
 var _ ProxyAuthRequired = internalProxyAuthRequired{}
 
-var ErrProxyAuthRequired error = ProxyAuthRequiredWrap(errors.New("Proxy Auth Required"))
+var ErrProxyAuthRequired error = ProxyAuthRequiredWrap(nil)
 
 type ProxyAuthRequired interface {
 	ClientError
diff --git a/requestedrangenotsatisfiable.go b/requestedrangenotsatisfiable.go
index 0f86ed7..27689f1 100644
--- a/requestedrangenotsatisfiable.go
+++ b/requestedrangenotsatisfiable.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error                        = internalRequestedRangeNotSatisfiable{}
 var _ RequestedRangeNotSatisfiable = internalRequestedRangeNotSatisfiable{}
 
-var ErrRequestedRangeNotSatisfiable error = RequestedRangeNotSatisfiableWrap(errors.New("Requested Range Not Satisfiable"))
+var ErrRequestedRangeNotSatisfiable error = RequestedRangeNotSatisfiableWrap(nil)
 
 type RequestedRangeNotSatisfiable interface {
 	ClientError
diff --git a/requestentitytoolarge.go b/requestentitytoolarge.go
index e602615..e2f10fb 100644
--- a/requestentitytoolarge.go
+++ b/requestentitytoolarge.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error                 = internalRequestEntityTooLarge{}
 var _ RequestEntityTooLarge = internalRequestEntityTooLarge{}
 
-var ErrRequestEntityTooLarge error = RequestEntityTooLargeWrap(errors.New("Request Entity Too Large"))
+var ErrRequestEntityTooLarge error = RequestEntityTooLargeWrap(nil)
 
 type RequestEntityTooLarge interface {
 	ClientError
diff --git a/requestheaderfieldstoolarge.go b/requestheaderfieldstoolarge.go
index 0838f64..3054409 100644
--- a/requestheaderfieldstoolarge.go
+++ b/requestheaderfieldstoolarge.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error                       = internalRequestHeaderFieldsTooLarge{}
 var _ RequestHeaderFieldsTooLarge = internalRequestHeaderFieldsTooLarge{}
 
-var ErrRequestHeaderFieldsTooLarge error = RequestHeaderFieldsTooLargeWrap(errors.New("RequestHeaderFieldsTooLarge"))
+var ErrRequestHeaderFieldsTooLarge error = RequestHeaderFieldsTooLargeWrap(nil)
 
 type RequestHeaderFieldsTooLarge interface {
 	ClientError
diff --git a/requesttimeout.go b/requesttimeout.go
index 44168e7..6c79020 100644
--- a/requesttimeout.go
+++ b/requesttimeout.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error          = internalRequestTimeout{}
 var _ RequestTimeout = internalRequestTimeout{}
 
-var ErrRequestTimeout error = RequestTimeoutWrap(errors.New("Request Timeout"))
+var ErrRequestTimeout error = RequestTimeoutWrap(nil)
 
 type RequestTimeout interface {
 	ClientError
diff --git a/requesturitoolong.go b/requesturitoolong.go
index e20b54c..aa35819 100644
--- a/requesturitoolong.go
+++ b/requesturitoolong.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error             = internalRequestURITooLong{}
 var _ RequestURITooLong = internalRequestURITooLong{}
 
-var ErrRequestURITooLong error = RequestURITooLongWrap(errors.New("Request URI Too Long"))
+var ErrRequestURITooLong error = RequestURITooLongWrap(nil)
 
 type RequestURITooLong interface {
 	ClientError
diff --git a/serviceunavailable.go b/serviceunavailable.go
index 163c2a3..d8e3dd3 100644
--- a/serviceunavailable.go
+++ b/serviceunavailable.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error              = internalServiceUnavailable{}
 var _ ServiceUnavailable = internalServiceUnavailable{}
 
-var ErrServiceUnavailable error = ServiceUnavailableWrap(errors.New("Service Unavailable"))
+var ErrServiceUnavailable error = ServiceUnavailableWrap(nil)
 
 type ServiceUnavailable interface {
 	ServerError
diff --git a/teapot.go b/teapot.go
index 5535dd0..c421e67 100644
--- a/teapot.go
+++ b/teapot.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error  = internalTeapot{}
 var _ Teapot = internalTeapot{}
 
-var ErrTeapot error = TeapotWrap(errors.New("I'm a teapot"))
+var ErrTeapot error = TeapotWrap(nil)
 
 type Teapot interface {
 	ClientError
diff --git a/toomanyrequests.go b/toomanyrequests.go
index d27dd68..1034d66 100644
--- a/toomanyrequests.go
+++ b/toomanyrequests.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error           = internalTooManyRequests{}
 var _ TooManyRequests = internalTooManyRequests{}
 
-var ErrTooManyRequests error = TooManyRequestsWrap(errors.New("Too Many Requests"))
+var ErrTooManyRequests error = TooManyRequestsWrap(nil)
 
 type TooManyRequests interface {
 	ClientError
diff --git a/unauthorized.go b/unauthorized.go
index b38a8c2..24099f3 100644
--- a/unauthorized.go
+++ b/unauthorized.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error        = internalUnauthorized{}
 var _ Unauthorized = internalUnauthorized{}
 
-var ErrUnauthorized error = UnauthorizedWrap(errors.New("Unauthorized"))
+var ErrUnauthorized error = UnauthorizedWrap(nil)
 
 type Unauthorized interface {
 	ClientError
diff --git a/unavailableforlegalreasons.go b/unavailableforlegalreasons.go
index 6a86a90..39d4e41 100644
--- a/unavailableforlegalreasons.go
+++ b/unavailableforlegalreasons.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error                      = internalUnavailableForLegalReasons{}
 var _ UnavailableForLegalReasons = internalUnavailableForLegalReasons{}
 
-var ErrUnavailableForLegalReasons error = UnavailableForLegalReasonsWrap(errors.New("Unavailable For Legal Reasons"))
+var ErrUnavailableForLegalReasons error = UnavailableForLegalReasonsWrap(nil)
 
 type UnavailableForLegalReasons interface {
 	ClientError
diff --git a/unprocessableentity.go b/unprocessableentity.go
index 45e40cd..29a4430 100644
--- a/unprocessableentity.go
+++ b/unprocessableentity.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error               = internalUnprocessableEntity{}
 var _ UnprocessableEntity = internalUnprocessableEntity{}
 
-var ErrUnprocessableEntity error = UnprocessableEntityWrap(errors.New("Unprocessable Entity"))
+var ErrUnprocessableEntity error = UnprocessableEntityWrap(nil)
 
 type UnprocessableEntity interface {
 	ClientError
diff --git a/unsupportedmediatype.go b/unsupportedmediatype.go
index 37d4c57..6221677 100644
--- a/unsupportedmediatype.go
+++ b/unsupportedmediatype.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error                = internalUnsupportedMediaType{}
 var _ UnsupportedMediaType = internalUnsupportedMediaType{}
 
-var ErrUnsupportedMediaType error = UnsupportedMediaTypeWrap(errors.New("Unsupported Media Type"))
+var ErrUnsupportedMediaType error = UnsupportedMediaTypeWrap(nil)
 
 type UnsupportedMediaType interface {
 	ClientError
diff --git a/upgraderequired.go b/upgraderequired.go
index 9c03f74..43b2687 100644
--- a/upgraderequired.go
+++ b/upgraderequired.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error           = internalUpgradeRequired{}
 var _ UpgradeRequired = internalUpgradeRequired{}
 
-var ErrUpgradeRequired error = UpgradeRequiredWrap(errors.New("Upgrade Required"))
+var ErrUpgradeRequired error = UpgradeRequiredWrap(nil)
 
 type UpgradeRequired interface {
 	ClientError
diff --git a/uritoolong.go b/uritoolong.go
index 54e38e5..99aac92 100644
--- a/uritoolong.go
+++ b/uritoolong.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error      = internalURITooLong{}
 var _ URITooLong = internalURITooLong{}
 
-var ErrURITooLong error = URITooLongWrap(errors.New("URI Too Long"))
+var ErrURITooLong error = URITooLongWrap(nil)
 
 type URITooLong interface {
 	ClientError
diff --git a/variantaisonegotiates.go b/variantaisonegotiates.go
index a329228..69601b4 100644
--- a/variantaisonegotiates.go
+++ b/variantaisonegotiates.go
@@ -1,13 +1,9 @@
 package errhttp
 
-import (
-	"errors"
-)
-
 var _ Error                 = internalVariantAlsoNegotiates{}
 var _ VariantAlsoNegotiates = internalVariantAlsoNegotiates{}
 
-var ErrVariantAlsoNegotiates error = VariantAlsoNegotiatesWrap(errors.New("Variant Also Negotiates"))
+var ErrVariantAlsoNegotiates error = VariantAlsoNegotiatesWrap(nil)
 
 type VariantAlsoNegotiates interface {
 	ServerError