Bump vite from 5.4.17 to 5.4.21 - #143

packages/components/index.test.ts
  ✅ export correct values

packages/components/src/css.test.ts
  ✅ return correct styles
  ✅ return correct styles if it contains variables
  ✅ return correct styles if 'prependStyles' is set
  ✅ return undefined if styles are empty

packages/components/src/html.test.ts
  ✅ return correct html
  ✅ return correct html if it contains variables

packages/components/src/webcomponents.test.ts
  ✅ instantiation > cannot instantiate directly
  ✅ instantiation > can be instantiated through other class
  ✅ template and styles > set template as shadow dom
  ✅ template and styles > set styles in shadow dom
  ✅ template and styles > do not set shadow dom content if no template and styles defined
  ✅ template and styles > set styles and template in shadow dom
  ✅ properties > set properties as observedAttributes
  ✅ properties > getter and setter via instance property > String property
  ✅ properties > getter and setter via instance property > Number property
  ✅ properties > getter and setter via instance property > Boolean property true
  ✅ properties > getter and setter via instance property > Object property
  ✅ properties > getter and setter via setAttribute and removeAttribute > String property
  ✅ properties > getter and setter via setAttribute and removeAttribute > Number property
  ✅ properties > getter and setter via setAttribute and removeAttribute > Boolean property
  ✅ properties > getter and setter via setAttribute and removeAttribute > Object property
  ✅ helper methods > getElement > return element from template
  ✅ helper methods > getElement > return undefined if ref not exists
  ✅ helper methods > applyTemplate > apply template 2 times
  ✅ helper methods > applyTemplate > apply template 1 and then 2 times and do not recreate first elements
  ✅ helper methods > applyTemplate > apply template 2 and then 1 times and keep first elements
  ✅ helper methods > applyTemplate > getElement inside applied template
  ✅ helper methods > applyTemplate > applyTemplate inside applied template
  ✅ helper methods > applyTemplate > do nothing if data-ref is not a template

packages/content-negotiation/index.test.ts
  ✅ export correct values

packages/content-negotiation/src/matchAcceptHeader.test.ts
  ✅ header: 'text/html, application/xhtml+xml, app…'; match: [ 'text/html', 'application/json' ]; expected: 'text/html'
  ✅ header: 'text/html, application/xhtml+xml, app…'; match: [ 'application/json', 'text/html' ]; expected: 'text/html'
  ✅ header: 'text/html, application/xhtml+xml, app…'; match: [ 'audio/mp3', 'audio/waf' ]; expected: 'audio/mp3'
  ✅ header: 'application/json'; match: [ 'application/*', 'application/json' ]; expected: 'application/json'
  ✅ header: 'application/json'; match: [ 'application/json', 'application/*' ]; expected: 'application/json'
  ✅ header: 'application/json, application/*'; match: [ 'application/xml' ]; expected: 'application/xml'
  ✅ header: 'application/json, application/json'; match: [ 'application/xml' ]; expected: undefined
  ✅ header: 'application/xml'; match: [ Array(2) ]; expected: 'application/xml'
  ✅ header: 'text/*, text/plain, text/plain;format…'; match: [ 'text/*', 'text/plain', …(2) ]; expected: 'text/plain;format=flowed'
  ✅ header: 'text/*, text/plain;format=flowed, tex…'; match: [ 'text/*', 'text/plain', …(2) ]; expected: 'text/plain;format=flowed'
  ✅ header: 'text/*, text/plain, text/plain;format…'; match: [ 'text/*', …(3) ]; expected: 'text/plain;format=flowed'
  ✅ header: '*/*, text/*, text/plain, text/plain;f…'; match: [ 'text/*', …(3) ]; expected: 'text/plain;format=flowed'
  ✅ header: 'text/plain;format=flowed'; match: [ 'text/*', …(3) ]; expected: 'text/plain;format=flowed'
  ✅ header: 'text/*'; match: [ 'text/*', …(3) ]; expected: 'text/plain;format=flowed'
  ✅ header: 'text/*'; match: [ '*/*', 'text/*', …(2) ]; expected: 'text/plain;format=flowed'

packages/content-negotiation/src/matchLanguage.test.ts
  ✅ languages: 'de-DE, en-US'; available: [ 'en', 'de' ]; expected: 'de'
  ✅ languages: 'de-DE;q=0.9, en-US'; available: [ 'en', 'de' ]; expected: 'en'
  ✅ languages: [ 'de-DE', 'en-US' ]; available: [ 'en', 'de' ]; expected: 'de'
  ✅ languages: [ 'en-US', 'de-DE' ]; available: [ 'en', 'de' ]; expected: 'en'
  ✅ languages: [ 'en-US', 'de-DE' ]; available: [ 'fr', 'es' ]; expected: undefined
  ✅ languages: [ 'en', 'de' ]; available: [ 'de-DE', 'en-US' ]; expected: undefined
  ✅ languages: [ 'en', 'de' ]; available: [ 'de-DE', 'en-US', 'de' ]; expected: 'de'
  ✅ languages: [ 'en', 'de-DE', 'de' ]; available: [ 'de-DE', 'en-US', 'de' ]; expected: 'de-DE'
  ✅ languages: [ 'en-Latn-US', 'de-Latn-DE' ]; available: [ 'de', 'en' ]; expected: 'en'
  ✅ languages: [ 'en-Latn-US', 'de-Latn-DE' ]; available: [ 'de-DE', 'en-US' ]; expected: 'en-US'
  ✅ languages: [ 'en-Latn-US', 'de-Latn-DE' ]; available: [ 'de-DE', 'en-US' ]; expected: 'en-US'
  ✅ languages: [ 'sr-RS' ]; available: [ 'sr-Latn-RS', 'sr-Cyrl-RS' ]; expected: undefined
  ✅ languages: [ 'sr-Cyrl-RS' ]; available: [ 'sr-Latn-RS', 'sr-Cyrl-RS' ]; expected: 'sr-Cyrl-RS'
  ✅ languages: [ 'sr-RS', 'en-US' ]; available: [ 'sr-Latn', 'en' ]; expected: 'en'
  ✅ languages: [ 'sr-Latn-RS', 'sr-RS', 'en-US' ]; available: [ 'sr-Latn', 'en' ]; expected: 'sr-Latn'

packages/content-negotiation/src/matchMimeType.test.ts
  ✅ strict false > mimeType: 'application/json'; check: 'application/json'; match: true
  ✅ strict false > mimeType: '*/*'; check: 'application/json'; match: true
  ✅ strict false > mimeType: 'application/json'; check: '*/*'; match: true
  ✅ strict false > mimeType: '*/*'; check: '*/*'; match: true
  ✅ strict false > mimeType: '*/*'; check: '*/*;foo=bar'; match: true
  ✅ strict false > mimeType: '*/*;foo=bar'; check: '*/*'; match: true
  ✅ strict false > mimeType: 'application/json;foo=bar'; check: '*/*;foo=bar'; match: true
  ✅ strict false > mimeType: 'text/plain;format=flowed'; check: '*/*;'; match: true
  ✅ strict false > mimeType: '*/*;foo=bar'; check: 'application/json;foo=bar'; match: true
  ✅ strict false > mimeType: 'application/json'; check: 'application/*'; match: true
  ✅ strict false > mimeType: 'application/*'; check: 'application/json'; match: true
  ✅ strict false > mimeType: 'text/plain;format=flowed'; check: 'text/plain;format=flowed'; match: true
  ✅ strict false > mimeType: 'text/*;format=flowed'; check: 'text/plain;format=flowed'; match: true
  ✅ strict false > mimeType: 'text/plain;format=flowed'; check: 'text/*;format=flowed'; match: true
  ✅ strict false > mimeType: 'text/plain'; check: 'text/plain;format=flowed'; match: true
  ✅ strict false > mimeType: 'text/plain;format=flowed'; check: 'text/plain'; match: true
  ✅ strict false > mimeType: 'text/*'; check: 'text/plain;format=flowed'; match: true
  ✅ strict false > mimeType: 'text/plain;format=flowed'; check: 'text/*'; match: true
  ✅ strict false > mimeType: 'text/*;format=flowed'; check: 'text/plain'; match: true
  ✅ strict false > mimeType: 'text/plain'; check: 'text/*;format=flowed'; match: true
  ✅ strict false > mimeType: 'application/json'; check: '*/*;foo=bar'; match: true
  ✅ strict false > mimeType: '*/*;foo=bar'; check: 'application/json'; match: true
  ✅ strict false > mimeType: 'application/json'; check: 'text/html'; match: false
  ✅ strict false > mimeType: 'application/json;foo=bar'; check: 'text/html;foo=bar'; match: false
  ✅ strict false > mimeType: 'application/json'; check: 'application/hal+json'; match: false
  ✅ strict false > mimeType: 'application/json'; check: 'application/xml'; match: false
  ✅ strict false > mimeType: 'text/plain;format=flowed'; check: 'text/plain;foo=bar'; match: false
  ✅ strict false > mimeType: '*/*;foo=bar'; check: '*/*;bar=foo'; match: false
  ✅ strict false > mimeType: 'text/*;foo=bar'; check: 'text/plain;bar=foo'; match: false
  ✅ strict false > mimeType: 'text/plain;foo=bar'; check: 'text/*;bar=foo'; match: false
  ✅ strict true > mimeType: 'application/json'; check: 'application/json'; match: true
  ✅ strict true > mimeType: '*/*'; check: 'application/json'; match: true
  ✅ strict true > mimeType: '*/*'; check: '*/*'; match: true
  ✅ strict true > mimeType: '*/*'; check: '*/*;foo=bar'; match: true
  ✅ strict true > mimeType: '*/*;foo=bar'; check: 'application/json;foo=bar'; match: true
  ✅ strict true > mimeType: 'application/*'; check: 'application/json'; match: true
  ✅ strict true > mimeType: 'text/plain;format=flowed'; check: 'text/plain;format=flowed'; match: true
  ✅ strict true > mimeType: 'text/*;format=flowed'; check: 'text/plain;format=flowed'; match: true
  ✅ strict true > mimeType: 'text/plain'; check: 'text/plain;format=flowed'; match: true
  ✅ strict true > mimeType: 'text/*'; check: 'text/plain;format=flowed'; match: true
  ✅ strict true > mimeType: 'text/plain;format=flowed'; check: '*/*;'; match: false
  ✅ strict true > mimeType: 'application/json'; check: '*/*'; match: false
  ✅ strict true > mimeType: '*/*;foo=bar'; check: '*/*'; match: false
  ✅ strict true > mimeType: 'application/json;foo=bar'; check: '*/*;foo=bar'; match: false
  ✅ strict true > mimeType: 'application/json'; check: 'application/*'; match: false
  ✅ strict true > mimeType: 'text/plain;format=flowed'; check: 'text/*;format=flowed'; match: false
  ✅ strict true > mimeType: 'text/plain;format=flowed'; check: 'text/plain'; match: false
  ✅ strict true > mimeType: 'text/plain;format=flowed'; check: 'text/*'; match: false
  ✅ strict true > mimeType: 'text/*;format=flowed'; check: 'text/plain'; match: false
  ✅ strict true > mimeType: 'text/plain'; check: 'text/*;format=flowed'; match: false
  ✅ strict true > mimeType: 'application/json'; check: 'text/html'; match: false
  ✅ strict true > mimeType: 'application/json;foo=bar'; check: 'text/html;foo=bar'; match: false
  ✅ strict true > mimeType: 'application/json'; check: 'application/hal+json'; match: false
  ✅ strict true > mimeType: 'application/json'; check: 'application/xml'; match: false
  ✅ strict true > mimeType: 'text/plain;format=flowed'; check: 'text/plain;foo=bar'; match: false
  ✅ strict true > mimeType: 'application/json'; check: '*/*;foo=bar'; match: false
  ✅ strict true > mimeType: '*/*;foo=bar'; check: 'application/json'; match: false
  ✅ strict true > mimeType: '*/*;foo=bar'; check: '*/*;bar=foo'; match: false
  ✅ strict true > mimeType: 'text/*;foo=bar'; check: 'text/plain;bar=foo'; match: false
  ✅ strict true > mimeType: 'text/plain;foo=bar'; check: 'text/*;bar=foo'; match: false

packages/content-negotiation/src/parse.test.ts
  ✅ return parsed header

packages/cookies/index.test.ts
  ✅ export correct values

packages/cookies/src/create.test.ts
  ✅ create cookie with only key and value
  ✅ create cookie with all properties
  ✅ throw if invalid key > empty key
  ✅ throw if invalid key > not allowed character ";"
  ✅ throw if invalid key > not allowed character ","
  ✅ throw if invalid key > not allowed character " "
  ✅ throw if invalid key > not allowed character "ß"
  ✅ throw if invalid key > not allowed character "ö"
  ✅ throw if invalid key > not allowed character "é"
  ✅ throw if invalid value > empty value
  ✅ throw if invalid value > not allowed character ";"
  ✅ throw if invalid value > not allowed character ","
  ✅ throw if invalid value > not allowed character " "

packages/cookies/src/parse.test.ts
  ✅ parse cookie header

packages/localization/index.test.ts
  ✅ export correct values

packages/localization/src/defaultLanguage.test.ts
  ✅ return navigator.languages if defined
  ✅ return empty array if navigator defined but languages not defined
  ✅ return empty array if navigator not defined

packages/localization/src/export.test.ts
  ✅ return nothing if locales empty
  ✅ return nothing if defaultLocale not set
  ✅ return strings from language if first accepted language
  ✅ return strings from language if not first accepted language
  ✅ return strings from default language accepted language not set
  ✅ return strings from accepted language extended by default language

packages/localization/src/inject.test.ts
  ✅ inject translation into shadow dom element content
  ✅ inject translation into shadow dom element attribute
  ✅ inject translation into template element inside shadow dom
  ✅ inject translation into template element attribute inside shadow dom
  ✅ do not change other than shadow dom
  ✅ change nothing if no content

packages/localization/src/loadLocales.test.ts
  ✅ loadLocaleClient() > set locales from __duduk
  ✅ loadLocaleClient() > replace pre-existing locales
  ✅ loadLocaleClient() > do not change pre-existing locales if __duduk.locales undefined
  ✅ loadLocaleClient() > do not change pre-existing locales if __duduk undefined
  ✅ loadLocale() > add locale with plurals and set defaultLocale if no locale set yet
  ✅ loadLocale() > do not replace defaultLocale if already set
  ✅ loadLocale() > extend locale if already present

packages/localization/src/placeholder.test.ts
  ✅ template: 'This is a string'; values: {}; expected: 'This is a string'
  ✅ template: 'This is a string'; values: { foo: 'bar' }; expected: 'This is a string'
  ✅ template: 'This is a {val} string'; values: { val: 'nice' }; expected: 'This is a nice string'
  ✅ template: 'This is a {val} string'; values: {}; expected: 'This is a {val} string'
  ✅ template: 'This is a {val} string'; values: { foo: 'bar' }; expected: 'This is a {val} string'
  ✅ template: 'This is a {val} {other}'; values: { val: 'nice', other: 'string' }; expected: 'This is a nice string'
  ✅ template: 'This is a {val} {other}'; values: { other: 'string', val: 'nice' }; expected: 'This is a nice string'

packages/localization/src/translate.test.ts
  ✅ t() > return string from id with defaultLanguage
  ✅ t() > return id if not exists
  ✅ translate() > return undefined if not exists
  ✅ translate() > return string from id
  ✅ translate() > return defaultLocale fallback
  ✅ translate() > apply string variable
  ✅ translate() > apply number variable
  ✅ translate() > plural > get pluralized string with object
  ✅ translate() > plural > get pluralized string with empty object
  ✅ translate() > plural > return undefined if plural rule not exists
  ✅ translate() > plural > get pluralized string with number
  ✅ translate() > plural > get pluralized string with variables
  ✅ translate() > plural > get double pluralized string with object
  ✅ translate() > plural > get double pluralized string with number
  ✅ translate() > $route > return route string from routeId from globals
  ✅ translate() > $route > return route string from routeId from options instead of globals
  ✅ translate() > $route > return undefined on $route if window not defined
  ✅ translate() > $route > return undefined on $route if __duduk not defined
  ✅ translate() > $route > return undefined on $route if __duduk.routeId not defined

packages/messaging/index.test.ts
  ✅ export correct values

packages/messaging/src/global.test.ts
  ✅ return channel from global messenger instance
  ✅ create messenger if not existent in __duduk and return channel
  ✅ create messenger if __duduk not existent and return channel

packages/messaging/src/messenger.test.ts
  ✅ return channel
  ✅ listen > listen to messages
  ✅ listen > multiple listeners
  ✅ listen > listen to messages and call callback
  ✅ listen > do not mix up channels from one messenger
  ✅ listen > do not mix up channels from different messenger
  ✅ listen > do not throw on dispatch if no listeners
  ✅ remove > remove listener
  ✅ remove > do not throw on removeListener if no listener

packages/server/index.test.ts
  ✅ export correct values

packages/server/src/bin/build.test.ts
  ✅ call build with files
  ✅ call watch with files

packages/server/src/bin/help.test.ts
  ✅ print help to console

packages/server/src/bin/index.test.ts
  ✅ contains hash-bang
  ✅ print help > argv only -h
  ✅ print help > argv only --help
  ✅ print help > argv contains -h
  ✅ print help > argv contains --help
  ✅ print help > argv no command
  ✅ print help > argv unknown command
  ✅ print version > argv version
  ✅ print version > argv --version
  ✅ print version > argv -v
  ✅ build > argv build
  ✅ build > argv build --watch

packages/server/src/bin/version.test.ts
  ✅ printVersion() > print version to console
  ✅ getVersion() > return version

packages/server/src/client/getter.test.ts
  ✅ getData() > return pageData
  ✅ getData() > return empty object if pageData is undefined
  ✅ getData() > return empty object if __duduk is undefined
  ✅ getParams() > return pageParams
  ✅ getParams() > return empty object if pageParams is undefined
  ✅ getParams() > return empty object if __duduk is undefined

packages/server/src/inject/locales.test.ts
  ✅ get locale strings

packages/server/src/server/serve-file/serveFile.test.ts
  ✅ return true and set file content
  ✅ return true and set file content but not Content-Type if mime type is unknown
  ✅ return false and set nothing if path not exists
  ✅ return false and set nothing if path is outside base dir
  ✅ return false and set nothing if path is not a file
  ✅ return true and set 405 if method is not GET

packages/server/src/server/serve-route/cookies.test.ts
  ✅ create cookie handler
  ✅ work if cookie header not defined

packages/server/src/server/serve-route/parseRoutes.test.ts
  ✅ return routes

packages/server/src/server/serve-route/rootFiles.test.ts
  ✅ rootCss > return rootCss content
  ✅ rootCss > return undefined if no rootCss file
  ✅ appCss > return appCss path
  ✅ appCss > return undefined if no appCss file
  ✅ setupClient > return setupClient path
  ✅ setupClient > return undefined if no setupClient file
  ✅ setupServer > return setup functions
  ✅ setupServer > return undefined if no locales file
  ✅ getLocaleStrings > return getLocaleStrings function
  ✅ getLocaleStrings > return undefined if directory exists but no locales file
  ✅ getLocaleStrings > return undefined if directory not exists

packages/server/src/server/serve-route/servePageEndpoint.test.ts
  ✅ serve rendered html root route without layout
  ✅ serve rendered html root route with layout
  ✅ serve rendered html root route with layout data
  ✅ serve rendered html root route with page data
  ✅ serve rendered html sub route with layout, sub layout and data
  ✅ serve rendered html param sub route with layout, sub layout and data
  ✅ return 500 if no page endpoint specified
  ✅ serve rendered html route with root files
  ✅ serve rendered html route with root files with accept-language with origin without referer
  ✅ serve rendered html route with root files with host without referer or origin
  ✅ serve rendered html route with root files without referer or origin or host

packages/server/src/server/serve-route/serveRoute.test.ts
  ✅ print page > root, "/"
  ✅ print page > root, "/", method POST
  ✅ print page > root, "/", no method defined
  ✅ print page > root, "/", no url defined
  ✅ print page > without layout, with page, "/subRoute"
  ✅ print page > with layout, with page, "/subRoute/subSubRoute"
  ✅ print page > with layout, without page, "/otherRoute"
  ✅ print page > with layout, with page, "/otherRoute/(otherGroup)/otherSubRoute"
  ✅ print page > param route, "/otherRoute/someAsdf"
  ✅ print page > group route, "/(myGroup)/moreRoute"
  ✅ print page > return 405 > if method PUT
  ✅ print page > return 405 > if method PATCH
  ✅ print page > return 405 > if method DELETE
  ✅ print page > execute middlewares and pass locales
  ✅ execute server > root, "/"
  ✅ execute server > without layout, with page, "/subRoute"
  ✅ execute server > with layout, with page, "/subRoute/subSubRoute"
  ✅ execute server > with layout, without page, "/otherRoute"
  ✅ execute server > with layout, with page, "/otherRoute/(otherGroup)/otherSubRoute"
  ✅ execute server > param route, "/otherRoute/someAsdf"
  ✅ execute server > return 405 if method not defined
  ✅ execute server > return 405 if no pageServer defined
  ✅ execute server > fallback from printPage to executeServer
  ✅ execute server > return 405 if fallback from printPage to executeServer but method not defined
  ✅ execute server > execute middlewares and pass locales
  ✅ return 406 if unsupported accept header
  ✅ return 406 if no accept header
  ✅ return false (aka 404) > if groupRoute is addressed directly
  ✅ return false (aka 404) > if route not defined, with accept text/html
  ✅ return false (aka 404) > if route not defined, with accept application/json
  ✅ return false (aka 404) > if route not defined, with accept image/png

packages/server/src/server/serve-route/serveServerEndpoint.test.ts
  ✅ execute server endpoint with layout
  ✅ execute server endpoint with layout if method not set

packages/server/src/server/server.test.ts
  ✅ create server with default values
  ✅ create server with env values
  ✅ only serve file if serveFile returns true
  ✅ serve route if serveFile returns false and serveRoute returns true
  ✅ serve route and end response if serveFile returns false and serveRoute returns true but response not ended yet
  ✅ write 404 if serveFile and serveRoute return false

packages/server/src/server/unique-ids.test.ts
  ✅ uniqueIdFromString() > return unique hash

packages/ssr/index.test.ts
  ✅ export correct values

packages/ssr/src/jsdomWindow.test.ts
  ✅ log error on navigation if not mocked
  ✅ do not log error and not set href on navigation if mocked
  ✅ set other properties even if mocked

packages/ssr/src/ssr.test.ts
  ✅ render HTML