.put("SEC_CH_UA_WOW64", "Sec-CH-UA-WoW64")
            .put("SEC_WEBSOCKET_ACCEPT", "Sec-WebSocket-Accept")
            .put("SEC_WEBSOCKET_EXTENSIONS", "Sec-WebSocket-Extensions")
            .put("SEC_WEBSOCKET_KEY", "Sec-WebSocket-Key")
            .put("SEC_WEBSOCKET_PROTOCOL", "Sec-WebSocket-Protocol")
            .put("SEC_WEBSOCKET_VERSION", "Sec-WebSocket-Version")
            .put("X_WEBKIT_CSP", "X-WebKit-CSP")

func (l *lastMinuteLatency) add(t time.Duration) {
	sec := time.Now().Unix()
	l.forwardTo(sec)
	winIdx := sec % 60
	l.Totals[winIdx].add(t)
	l.LastSec = sec
}

// Add  a new duration data
func (l *lastMinuteLatency) addAll(sec int64, a AccElem) {
	l.forwardTo(sec)
	winIdx := sec % 60
	l.Totals[winIdx].merge(a)
	l.LastSec = sec
}

// Merge all recorded latencies of last minute into one

func IsEncrypted(metadata map[string]string) (Type, bool) {
	if S3KMS.IsEncrypted(metadata) {
		return S3KMS, true
	}
	if S3.IsEncrypted(metadata) {
		return S3, true
	}
	if SSEC.IsEncrypted(metadata) {
		return SSEC, true
	}
	if IsMultiPart(metadata) {
		return nil, true
	}
	if _, ok := metadata[MetaIV]; ok {
		return nil, true
	}
	if _, ok := metadata[MetaAlgorithm]; ok {
		return nil, true

 * Sec-WebSocket-Extensions: permessage-deflate; client_max_window_bits=15
 * Sec-WebSocket-Extensions: permessage-deflate; client_no_context_takeover
 * Sec-WebSocket-Extensions: permessage-deflate; server_max_window_bits="15"
 * Sec-WebSocket-Extensions: permessage-deflate; server_max_window_bits=15
 * Sec-WebSocket-Extensions: permessage-deflate; server_no_context_takeover
 * Sec-WebSocket-Extensions: permessage-deflate; server_no_context_takeover;

<script>
  (function() {
    var cx = 'YOUR-CSE-ID';
    var gcse = document.createElement('script');
    gcse.type = 'text/javascript';
    gcse.async = true;
    gcse.src = 'https://cse.google.com/cse.js?cx=' + cx;
    var s = document.getElementsByTagName('script')[0];
    s.parentNode.insertBefore(gcse, s);
  })();
</script>
<gcse:search></gcse:search>
```

With Fess Site Search:

```javascript

        .setHeader("Sec-WebSocket-Accept", "magic")
        .build(),
    )
    webServer.enqueue(
      MockResponse
        .Builder()
        .onRequestStart(CloseSocket())
        .build(),
    )
    val webSocket = newWebSocket()
    clientListener.assertFailure(
      101,
      null,
      ProtocolException::class.java,

	if err != nil {
		return errLifecycleInvalidDate
	}
	// Allow only date timestamp specifying midnight GMT
	hr, m, sec := expDate.Clock()
	nsec := expDate.Nanosecond()
	loc := expDate.Location()
	if hr != 0 || m != 0 || sec != 0 || nsec != 0 || loc.String() != time.UTC.String() {
		return errLifecycleDateNotMidnight
	}

	*eDate = ExpirationDate{expDate}
	return nil
}

	var objectEncryptionKey crypto.ObjectKey
	if isEncrypted {
		if !crypto.SSEC.IsRequested(r.Header) && crypto.SSEC.IsEncrypted(mi.UserDefined) {
			writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrSSEMultipartEncrypted), r.URL)
			return
		}
		if crypto.S3.IsEncrypted(mi.UserDefined) && crypto.SSEC.IsRequested(r.Header) {
			writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrSSEMultipartEncrypted), r.URL)

	CNEG	AL, R2, R3                                       // ERROR "invalid condition"
	CNEGW	NV, R2, R3                                       // ERROR "invalid condition"
	CSET	AL, R2                                           // ERROR "invalid condition"
	CSET	NV, R2                                           // ERROR "invalid condition"
	CSETMW	AL, R2                                           // ERROR "invalid condition"

        ),
      )
  }

  @Test
  fun multiplePerMessageDeflateHeaders() {
    val extensions =
      WebSocketExtensions.parse(
        headersOf(
          "Sec-WebSocket-Extensions",
          "",
          "Sec-WebSocket-Extensions",
          "permessage-deflate",
        ),
      )
    assertThat(extensions)
      .isEqualTo(
        WebSocketExtensions(
          perMessageDeflate = true,