@ttsc/win32-arm64 0.33.1 → 0.34.0

package/bin/go/src/vendor/golang.org/x/net/internal/http3/qpack.go

@@ -0,0 +1,356 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package http3
+
+import (
+	"errors"
+	"io"
+
+	"golang.org/x/net/http/httpguts"
+	"golang.org/x/net/http2/hpack"
+)
+
+// QPACK (RFC 9204) header compression wire encoding.
+// https://www.rfc-editor.org/rfc/rfc9204.html
+
+// tableType is the static or dynamic table.
+//
+// The T bit in QPACK instructions indicates whether a table index refers to
+// the dynamic (T=0) or static (T=1) table. tableTypeForTBit and tableType.tbit
+// convert a T bit from the wire encoding to/from a tableType.
+type tableType byte
+
+const (
+	dynamicTable = 0x00 // T=0, dynamic table
+	staticTable  = 0xff // T=1, static table
+)
+
+// tableTypeForTbit returns the table type corresponding to a T bit value.
+// The input parameter contains a byte masked to contain only the T bit.
+func tableTypeForTbit(bit byte) tableType {
+	if bit == 0 {
+		return dynamicTable
+	}
+	return staticTable
+}
+
+// tbit produces the T bit corresponding to the table type.
+// The input parameter contains a byte with the T bit set to 1,
+// and the return is either the input or 0 depending on the table type.
+func (t tableType) tbit(bit byte) byte {
+	return bit & byte(t)
+}
+
+// indexType indicates a literal's indexing status.
+//
+// The N bit in QPACK instructions indicates whether a literal is "never-indexed".
+// A never-indexed literal (N=1) must not be encoded as an indexed literal if it
+// forwarded on another connection.
+//
+// (See https://www.rfc-editor.org/rfc/rfc9204.html#section-7.1 for details on the
+// security reasons for never-indexed literals.)
+type indexType byte
+
+const (
+	mayIndex   = 0x00 // N=0, not a never-indexed literal
+	neverIndex = 0xff // N=1, never-indexed literal
+)
+
+// indexTypeForNBit returns the index type corresponding to a N bit value.
+// The input parameter contains a byte masked to contain only the N bit.
+func indexTypeForNBit(bit byte) indexType {
+	if bit == 0 {
+		return mayIndex
+	}
+	return neverIndex
+}
+
+// nbit produces the N bit corresponding to the table type.
+// The input parameter contains a byte with the N bit set to 1,
+// and the return is either the input or 0 depending on the table type.
+func (t indexType) nbit(bit byte) byte {
+	return bit & byte(t)
+}
+
+// Indexed Field Line:
+//
+//       0   1   2   3   4   5   6   7
+//     +---+---+---+---+---+---+---+---+
+//     | 1 | T |      Index (6+)       |
+//     +---+---+-----------------------+
+//
+// https://www.rfc-editor.org/rfc/rfc9204.html#section-4.5.2
+
+func appendIndexedFieldLine(b []byte, ttype tableType, index int) []byte {
+	const tbit = 0b_01000000
+	return appendPrefixedInt(b, 0b_1000_0000|ttype.tbit(tbit), 6, int64(index))
+}
+
+func (st *stream) decodeIndexedFieldLine(b byte) (itype indexType, name, value string, err error) {
+	index, err := st.readPrefixedIntWithByte(b, 6)
+	if err != nil {
+		return 0, "", "", err
+	}
+	const tbit = 0b_0100_0000
+	if tableTypeForTbit(b&tbit) == staticTable {
+		ent, err := staticTableEntry(index)
+		if err != nil {
+			return 0, "", "", err
+		}
+		return mayIndex, ent.name, ent.value, nil
+	} else {
+		return 0, "", "", errors.New("dynamic table is not supported yet")
+	}
+}
+
+// Literal Field Line With Name Reference:
+//
+//      0   1   2   3   4   5   6   7
+//     +---+---+---+---+---+---+---+---+
+//     | 0 | 1 | N | T |Name Index (4+)|
+//     +---+---+---+---+---------------+
+//     | H |     Value Length (7+)     |
+//     +---+---------------------------+
+//     |  Value String (Length bytes)  |
+//     +-------------------------------+
+//
+// https://www.rfc-editor.org/rfc/rfc9204.html#section-4.5.4
+
+func appendLiteralFieldLineWithNameReference(b []byte, ttype tableType, itype indexType, nameIndex int, value string) []byte {
+	const tbit = 0b_0001_0000
+	const nbit = 0b_0010_0000
+	b = appendPrefixedInt(b, 0b_0100_0000|itype.nbit(nbit)|ttype.tbit(tbit), 4, int64(nameIndex))
+	b = appendPrefixedString(b, 0, 7, value)
+	return b
+}
+
+func (st *stream) decodeLiteralFieldLineWithNameReference(b byte) (itype indexType, name, value string, err error) {
+	nameIndex, err := st.readPrefixedIntWithByte(b, 4)
+	if err != nil {
+		return 0, "", "", err
+	}
+
+	const tbit = 0b_0001_0000
+	if tableTypeForTbit(b&tbit) == staticTable {
+		ent, err := staticTableEntry(nameIndex)
+		if err != nil {
+			return 0, "", "", err
+		}
+		name = ent.name
+	} else {
+		return 0, "", "", errors.New("dynamic table is not supported yet")
+	}
+
+	_, value, err = st.readPrefixedString(7)
+	if err != nil {
+		return 0, "", "", err
+	}
+
+	const nbit = 0b_0010_0000
+	itype = indexTypeForNBit(b & nbit)
+
+	return itype, name, value, nil
+}
+
+// Literal Field Line with Literal Name:
+//
+//       0   1   2   3   4   5   6   7
+//     +---+---+---+---+---+---+---+---+
+//     | 0 | 0 | 1 | N | H |NameLen(3+)|
+//     +---+---+---+---+---+-----------+
+//     |  Name String (Length bytes)   |
+//     +---+---------------------------+
+//     | H |     Value Length (7+)     |
+//     +---+---------------------------+
+//     |  Value String (Length bytes)  |
+//     +-------------------------------+
+//
+// https://www.rfc-editor.org/rfc/rfc9204.html#section-4.5.6
+
+func appendLiteralFieldLineWithLiteralName(b []byte, itype indexType, name, value string) []byte {
+	const nbit = 0b_0001_0000
+	b = appendPrefixedString(b, 0b_0010_0000|itype.nbit(nbit), 3, name)
+	b = appendPrefixedString(b, 0, 7, value)
+	return b
+}
+
+func (st *stream) decodeLiteralFieldLineWithLiteralName(b byte) (itype indexType, name, value string, err error) {
+	name, err = st.readPrefixedStringWithByte(b, 3)
+	if err != nil {
+		return 0, "", "", err
+	}
+	_, value, err = st.readPrefixedString(7)
+	if err != nil {
+		return 0, "", "", err
+	}
+	const nbit = 0b_0001_0000
+	itype = indexTypeForNBit(b & nbit)
+	return itype, name, value, nil
+}
+
+// Prefixed-integer encoding from RFC 7541, section 5.1
+//
+// Prefixed integers consist of some number of bits of data,
+// N bits of encoded integer, and 0 or more additional bytes of
+// encoded integer.
+//
+// The RFCs represent this as, for example:
+//
+//       0   1   2   3   4   5   6   7
+//     +---+---+---+---+---+---+---+---+
+//     | 0 | 0 | 1 |   Capacity (5+)   |
+//     +---+---+---+-------------------+
+//
+// "Capacity" is an integer with a 5-bit prefix.
+//
+// In the following functions, a "prefixLen" parameter is the number
+// of integer bits in the first byte (5 in the above example), and
+// a "firstByte" parameter is a byte containing the first byte of
+// the encoded value (0x001x_xxxx in the above example).
+//
+// https://www.rfc-editor.org/rfc/rfc9204.html#section-4.1.1
+// https://www.rfc-editor.org/rfc/rfc7541#section-5.1
+
+// readPrefixedInt reads an RFC 7541 prefixed integer from st.
+func (st *stream) readPrefixedInt(prefixLen uint8) (firstByte byte, v int64, err error) {
+	firstByte, err = st.ReadByte()
+	if err != nil {
+		return 0, 0, errQPACKDecompressionFailed
+	}
+	v, err = st.readPrefixedIntWithByte(firstByte, prefixLen)
+	return firstByte, v, err
+}
+
+// readPrefixedIntWithByte reads an RFC 7541 prefixed integer from st.
+// The first byte has already been read from the stream.
+func (st *stream) readPrefixedIntWithByte(firstByte byte, prefixLen uint8) (v int64, err error) {
+	prefixMask := (byte(1) << prefixLen) - 1
+	v = int64(firstByte & prefixMask)
+	if v != int64(prefixMask) {
+		return v, nil
+	}
+	m := 0
+	for {
+		b, err := st.ReadByte()
+		if err != nil {
+			return 0, errQPACKDecompressionFailed
+		}
+		v += int64(b&127) << m
+		m += 7
+		if b&128 == 0 {
+			break
+		}
+	}
+	return v, err
+}
+
+// appendPrefixedInt appends an RFC 7541 prefixed integer to b.
+//
+// The firstByte parameter includes the non-integer bits of the first byte.
+// The other bits must be zero.
+func appendPrefixedInt(b []byte, firstByte byte, prefixLen uint8, i int64) []byte {
+	u := uint64(i)
+	prefixMask := (uint64(1) << prefixLen) - 1
+	if u < prefixMask {
+		return append(b, firstByte|byte(u))
+	}
+	b = append(b, firstByte|byte(prefixMask))
+	u -= prefixMask
+	for u >= 128 {
+		b = append(b, 0x80|byte(u&0x7f))
+		u >>= 7
+	}
+	return append(b, byte(u))
+}
+
+// String literal encoding from RFC 7541, section 5.2
+//
+// String literals consist of a single bit flag indicating
+// whether the string is Huffman-encoded, a prefixed integer (see above),
+// and the string.
+//
+// https://www.rfc-editor.org/rfc/rfc9204.html#section-4.1.2
+// https://www.rfc-editor.org/rfc/rfc7541#section-5.2
+
+// readPrefixedString reads an RFC 7541 string from st.
+func (st *stream) readPrefixedString(prefixLen uint8) (firstByte byte, s string, err error) {
+	firstByte, err = st.ReadByte()
+	if err != nil {
+		return 0, "", errQPACKDecompressionFailed
+	}
+	s, err = st.readPrefixedStringWithByte(firstByte, prefixLen)
+	return firstByte, s, err
+}
+
+// readPrefixedStringWithByte reads an RFC 7541 string from st.
+// The first byte has already been read from the stream.
+func (st *stream) readPrefixedStringWithByte(firstByte byte, prefixLen uint8) (s string, err error) {
+	size, err := st.readPrefixedIntWithByte(firstByte, prefixLen)
+	if err != nil {
+		return "", errQPACKDecompressionFailed
+	}
+
+	hbit := byte(1) << prefixLen
+	isHuffman := firstByte&hbit != 0
+
+	// TODO: Avoid allocating here.
+	data := make([]byte, size)
+	if _, err := io.ReadFull(st, data); err != nil {
+		return "", errQPACKDecompressionFailed
+	}
+	if isHuffman {
+		// TODO: Move Huffman functions into a new package that hpack (HTTP/2)
+		// and this package can both import. Most of the hpack package isn't
+		// relevant to HTTP/3.
+		s, err := hpack.HuffmanDecodeToString(data)
+		if err != nil {
+			return "", errQPACKDecompressionFailed
+		}
+		return s, nil
+	}
+	return string(data), nil
+}
+
+// appendPrefixedString appends an RFC 7541 string to st,
+// applying Huffman encoding and setting the H bit (indicating Huffman encoding)
+// when appropriate.
+//
+// The firstByte parameter includes the non-integer bits of the first byte.
+// The other bits must be zero.
+func appendPrefixedString(b []byte, firstByte byte, prefixLen uint8, s string) []byte {
+	huffmanLen := hpack.HuffmanEncodeLength(s)
+	if huffmanLen < uint64(len(s)) {
+		hbit := byte(1) << prefixLen
+		b = appendPrefixedInt(b, firstByte|hbit, prefixLen, int64(huffmanLen))
+		b = hpack.AppendHuffmanString(b, s)
+	} else {
+		b = appendPrefixedInt(b, firstByte, prefixLen, int64(len(s)))
+		b = append(b, s...)
+	}
+	return b
+}
+
+// validWireHeaderFieldName reports whether v is a valid header field
+// name (key). See httpguts.ValidHeaderFieldName for the base rules.
+//
+// Further, http3 says:
+// "A request or response containing uppercase characters in field names MUST
+// be treated as malformed."
+//
+// This function does not validate whether a pseudo-header field name is valid.
+func validWireHeaderFieldName(v string) bool {
+	if len(v) == 0 {
+		return false
+	}
+	for _, r := range v {
+		if !httpguts.IsTokenRune(r) {
+			return false
+		}
+		if 'A' <= r && r <= 'Z' {
+			return false
+		}
+	}
+	return true
+}

package/bin/go/src/vendor/golang.org/x/net/internal/http3/qpack_decode.go

@@ -0,0 +1,81 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package http3
+
+import (
+	"errors"
+	"math/bits"
+)
+
+type qpackDecoder struct {
+	// The decoder has no state for now,
+	// but that'll change once we add dynamic table support.
+	//
+	// TODO: dynamic table support.
+}
+
+func (qd *qpackDecoder) decode(st *stream, f func(itype indexType, name, value string) error) error {
+	// Encoded Field Section prefix.
+
+	// We set SETTINGS_QPACK_MAX_TABLE_CAPACITY to 0,
+	// so the Required Insert Count must be 0.
+	_, requiredInsertCount, err := st.readPrefixedInt(8)
+	if err != nil {
+		return err
+	}
+	if requiredInsertCount != 0 {
+		return errQPACKDecompressionFailed
+	}
+
+	// Delta Base. We don't use the dynamic table yet, so this may be ignored.
+	_, _, err = st.readPrefixedInt(7)
+	if err != nil {
+		return err
+	}
+
+	sawNonPseudo := false
+	for st.lim > 0 {
+		firstByte, err := st.ReadByte()
+		if err != nil {
+			return err
+		}
+		var name, value string
+		var itype indexType
+		switch bits.LeadingZeros8(firstByte) {
+		case 0:
+			// Indexed Field Line
+			itype, name, value, err = st.decodeIndexedFieldLine(firstByte)
+		case 1:
+			// Literal Field Line With Name Reference
+			itype, name, value, err = st.decodeLiteralFieldLineWithNameReference(firstByte)
+		case 2:
+			// Literal Field Line with Literal Name
+			itype, name, value, err = st.decodeLiteralFieldLineWithLiteralName(firstByte)
+		case 3:
+			// Indexed Field Line With Post-Base Index
+			err = errors.New("dynamic table is not supported yet")
+		case 4:
+			// Indexed Field Line With Post-Base Name Reference
+			err = errors.New("dynamic table is not supported yet")
+		}
+		if err != nil {
+			return err
+		}
+		if len(name) == 0 {
+			return errH3MessageError
+		}
+		if name[0] == ':' {
+			if sawNonPseudo {
+				return errH3MessageError
+			}
+		} else {
+			sawNonPseudo = true
+		}
+		if err := f(itype, name, value); err != nil {
+			return err
+		}
+	}
+	return nil
+}

package/bin/go/src/vendor/golang.org/x/net/internal/http3/qpack_encode.go

@@ -0,0 +1,61 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package http3
+
+import (
+	"golang.org/x/net/internal/httpcommon"
+)
+
+type qpackEncoder struct {
+	// The encoder has no state for now,
+	// but that'll change once we add dynamic table support.
+	//
+	// TODO: dynamic table support.
+}
+
+func (qe *qpackEncoder) init() {
+	staticTableOnce.Do(initStaticTableMaps)
+}
+
+// encode encodes a list of headers into a QPACK encoded field section.
+//
+// The headers func must produce the same headers on repeated calls,
+// although the order may vary.
+func (qe *qpackEncoder) encode(headers func(func(itype indexType, name, value string))) []byte {
+	// Encoded Field Section prefix.
+	//
+	// We don't yet use the dynamic table, so both values here are zero.
+	var b []byte
+	b = appendPrefixedInt(b, 0, 8, 0) // Required Insert Count
+	b = appendPrefixedInt(b, 0, 7, 0) // Delta Base
+
+	headers(func(itype indexType, name, value string) {
+		// Technically, it is the responsibility of the protocol using HTTP/3
+		// to ensure that all field names are already in lowercase. However,
+		// this QPACK implementation is solely used by and live in the http3
+		// package. So, we might as well do the lowercasing here to make sure
+		// we do not miss any callsites or need to create yet another struct
+		// wrapping the qpackEncoder.
+		name, ascii := httpcommon.LowerHeader(name)
+		// Skip writing invalid headers. Per RFC 9114 section 4.2: "Field
+		// names are strings containing a subset of ASCII characters."
+		if !ascii {
+			return
+		}
+		if itype == mayIndex {
+			if i, ok := staticTableByNameValue[tableEntry{name, value}]; ok {
+				b = appendIndexedFieldLine(b, staticTable, i)
+				return
+			}
+		}
+		if i, ok := staticTableByName[name]; ok {
+			b = appendLiteralFieldLineWithNameReference(b, staticTable, itype, i, value)
+		} else {
+			b = appendLiteralFieldLineWithLiteralName(b, itype, name, value)
+		}
+	})
+
+	return b
+}

package/bin/go/src/vendor/golang.org/x/net/internal/http3/qpack_static.go

@@ -0,0 +1,142 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package http3
+
+import "sync"
+
+type tableEntry struct {
+	name  string
+	value string
+}
+
+// staticTableEntry returns the static table entry with the given index.
+func staticTableEntry(index int64) (tableEntry, error) {
+	if index >= int64(len(staticTableEntries)) {
+		return tableEntry{}, errQPACKDecompressionFailed
+	}
+	return staticTableEntries[index], nil
+}
+
+func initStaticTableMaps() {
+	staticTableByName = make(map[string]int)
+	staticTableByNameValue = make(map[tableEntry]int)
+	for i, ent := range staticTableEntries {
+		if _, ok := staticTableByName[ent.name]; !ok {
+			staticTableByName[ent.name] = i
+		}
+		staticTableByNameValue[ent] = i
+	}
+}
+
+var (
+	staticTableOnce        sync.Once
+	staticTableByName      map[string]int
+	staticTableByNameValue map[tableEntry]int
+)
+
+// https://www.rfc-editor.org/rfc/rfc9204.html#appendix-A
+//
+// Note that this is different from the HTTP/2 static table.
+var staticTableEntries = [...]tableEntry{
+	0:  {":authority", ""},
+	1:  {":path", "/"},
+	2:  {"age", "0"},
+	3:  {"content-disposition", ""},
+	4:  {"content-length", "0"},
+	5:  {"cookie", ""},
+	6:  {"date", ""},
+	7:  {"etag", ""},
+	8:  {"if-modified-since", ""},
+	9:  {"if-none-match", ""},
+	10: {"last-modified", ""},
+	11: {"link", ""},
+	12: {"location", ""},
+	13: {"referer", ""},
+	14: {"set-cookie", ""},
+	15: {":method", "CONNECT"},
+	16: {":method", "DELETE"},
+	17: {":method", "GET"},
+	18: {":method", "HEAD"},
+	19: {":method", "OPTIONS"},
+	20: {":method", "POST"},
+	21: {":method", "PUT"},
+	22: {":scheme", "http"},
+	23: {":scheme", "https"},
+	24: {":status", "103"},
+	25: {":status", "200"},
+	26: {":status", "304"},
+	27: {":status", "404"},
+	28: {":status", "503"},
+	29: {"accept", "*/*"},
+	30: {"accept", "application/dns-message"},
+	31: {"accept-encoding", "gzip, deflate, br"},
+	32: {"accept-ranges", "bytes"},
+	33: {"access-control-allow-headers", "cache-control"},
+	34: {"access-control-allow-headers", "content-type"},
+	35: {"access-control-allow-origin", "*"},
+	36: {"cache-control", "max-age=0"},
+	37: {"cache-control", "max-age=2592000"},
+	38: {"cache-control", "max-age=604800"},
+	39: {"cache-control", "no-cache"},
+	40: {"cache-control", "no-store"},
+	41: {"cache-control", "public, max-age=31536000"},
+	42: {"content-encoding", "br"},
+	43: {"content-encoding", "gzip"},
+	44: {"content-type", "application/dns-message"},
+	45: {"content-type", "application/javascript"},
+	46: {"content-type", "application/json"},
+	47: {"content-type", "application/x-www-form-urlencoded"},
+	48: {"content-type", "image/gif"},
+	49: {"content-type", "image/jpeg"},
+	50: {"content-type", "image/png"},
+	51: {"content-type", "text/css"},
+	52: {"content-type", "text/html; charset=utf-8"},
+	53: {"content-type", "text/plain"},
+	54: {"content-type", "text/plain;charset=utf-8"},
+	55: {"range", "bytes=0-"},
+	56: {"strict-transport-security", "max-age=31536000"},
+	57: {"strict-transport-security", "max-age=31536000; includesubdomains"},
+	58: {"strict-transport-security", "max-age=31536000; includesubdomains; preload"},
+	59: {"vary", "accept-encoding"},
+	60: {"vary", "origin"},
+	61: {"x-content-type-options", "nosniff"},
+	62: {"x-xss-protection", "1; mode=block"},
+	63: {":status", "100"},
+	64: {":status", "204"},
+	65: {":status", "206"},
+	66: {":status", "302"},
+	67: {":status", "400"},
+	68: {":status", "403"},
+	69: {":status", "421"},
+	70: {":status", "425"},
+	71: {":status", "500"},
+	72: {"accept-language", ""},
+	73: {"access-control-allow-credentials", "FALSE"},
+	74: {"access-control-allow-credentials", "TRUE"},
+	75: {"access-control-allow-headers", "*"},
+	76: {"access-control-allow-methods", "get"},
+	77: {"access-control-allow-methods", "get, post, options"},
+	78: {"access-control-allow-methods", "options"},
+	79: {"access-control-expose-headers", "content-length"},
+	80: {"access-control-request-headers", "content-type"},
+	81: {"access-control-request-method", "get"},
+	82: {"access-control-request-method", "post"},
+	83: {"alt-svc", "clear"},
+	84: {"authorization", ""},
+	85: {"content-security-policy", "script-src 'none'; object-src 'none'; base-uri 'none'"},
+	86: {"early-data", "1"},
+	87: {"expect-ct", ""},
+	88: {"forwarded", ""},
+	89: {"if-range", ""},
+	90: {"origin", ""},
+	91: {"purpose", "prefetch"},
+	92: {"server", ""},
+	93: {"timing-allow-origin", "*"},
+	94: {"upgrade-insecure-requests", "1"},
+	95: {"user-agent", ""},
+	96: {"x-forwarded-for", ""},
+	97: {"x-frame-options", "deny"},
+	98: {"x-frame-options", "sameorigin"},
+}

package/bin/go/src/vendor/golang.org/x/net/internal/http3/quic.go

@@ -0,0 +1,40 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package http3
+
+import (
+	"crypto/tls"
+
+	"golang.org/x/net/quic"
+)
+
+func initConfig(config *quic.Config) *quic.Config {
+	if config == nil {
+		config = &quic.Config{}
+	}
+
+	// maybeCloneTLSConfig clones the user-provided tls.Config (but only once)
+	// prior to us modifying it.
+	needCloneTLSConfig := true
+	maybeCloneTLSConfig := func() *tls.Config {
+		if needCloneTLSConfig {
+			config.TLSConfig = config.TLSConfig.Clone()
+			needCloneTLSConfig = false
+		}
+		return config.TLSConfig
+	}
+
+	if config.TLSConfig == nil {
+		config.TLSConfig = &tls.Config{}
+		needCloneTLSConfig = false
+	}
+	if config.TLSConfig.MinVersion == 0 {
+		maybeCloneTLSConfig().MinVersion = tls.VersionTLS13
+	}
+	if config.TLSConfig.NextProtos == nil {
+		maybeCloneTLSConfig().NextProtos = []string{"h3"}
+	}
+	return config
+}