From 3ac1ee16f377d31a0fb80c8dae28b6239ac4229e Mon Sep 17 00:00:00 2001
From: Terin Stock <terinjokes@gmail.com>
Date: Sun, 9 Mar 2025 17:47:56 +0100
Subject: [chore] remove vendor

---
 vendor/golang.org/x/net/http2/hpack/huffman.go | 226 -------------------------
 1 file changed, 226 deletions(-)
 delete mode 100644 vendor/golang.org/x/net/http2/hpack/huffman.go

(limited to 'vendor/golang.org/x/net/http2/hpack/huffman.go')

diff --git a/vendor/golang.org/x/net/http2/hpack/huffman.go b/vendor/golang.org/x/net/http2/hpack/huffman.go
deleted file mode 100644
index 20d083a71..000000000
--- a/vendor/golang.org/x/net/http2/hpack/huffman.go
+++ /dev/null
@@ -1,226 +0,0 @@
-// Copyright 2014 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 hpack
-
-import (
-	"bytes"
-	"errors"
-	"io"
-	"sync"
-)
-
-var bufPool = sync.Pool{
-	New: func() interface{} { return new(bytes.Buffer) },
-}
-
-// HuffmanDecode decodes the string in v and writes the expanded
-// result to w, returning the number of bytes written to w and the
-// Write call's return value. At most one Write call is made.
-func HuffmanDecode(w io.Writer, v []byte) (int, error) {
-	buf := bufPool.Get().(*bytes.Buffer)
-	buf.Reset()
-	defer bufPool.Put(buf)
-	if err := huffmanDecode(buf, 0, v); err != nil {
-		return 0, err
-	}
-	return w.Write(buf.Bytes())
-}
-
-// HuffmanDecodeToString decodes the string in v.
-func HuffmanDecodeToString(v []byte) (string, error) {
-	buf := bufPool.Get().(*bytes.Buffer)
-	buf.Reset()
-	defer bufPool.Put(buf)
-	if err := huffmanDecode(buf, 0, v); err != nil {
-		return "", err
-	}
-	return buf.String(), nil
-}
-
-// ErrInvalidHuffman is returned for errors found decoding
-// Huffman-encoded strings.
-var ErrInvalidHuffman = errors.New("hpack: invalid Huffman-encoded data")
-
-// huffmanDecode decodes v to buf.
-// If maxLen is greater than 0, attempts to write more to buf than
-// maxLen bytes will return ErrStringLength.
-func huffmanDecode(buf *bytes.Buffer, maxLen int, v []byte) error {
-	rootHuffmanNode := getRootHuffmanNode()
-	n := rootHuffmanNode
-	// cur is the bit buffer that has not been fed into n.
-	// cbits is the number of low order bits in cur that are valid.
-	// sbits is the number of bits of the symbol prefix being decoded.
-	cur, cbits, sbits := uint(0), uint8(0), uint8(0)
-	for _, b := range v {
-		cur = cur<<8 | uint(b)
-		cbits += 8
-		sbits += 8
-		for cbits >= 8 {
-			idx := byte(cur >> (cbits - 8))
-			n = n.children[idx]
-			if n == nil {
-				return ErrInvalidHuffman
-			}
-			if n.children == nil {
-				if maxLen != 0 && buf.Len() == maxLen {
-					return ErrStringLength
-				}
-				buf.WriteByte(n.sym)
-				cbits -= n.codeLen
-				n = rootHuffmanNode
-				sbits = cbits
-			} else {
-				cbits -= 8
-			}
-		}
-	}
-	for cbits > 0 {
-		n = n.children[byte(cur<<(8-cbits))]
-		if n == nil {
-			return ErrInvalidHuffman
-		}
-		if n.children != nil || n.codeLen > cbits {
-			break
-		}
-		if maxLen != 0 && buf.Len() == maxLen {
-			return ErrStringLength
-		}
-		buf.WriteByte(n.sym)
-		cbits -= n.codeLen
-		n = rootHuffmanNode
-		sbits = cbits
-	}
-	if sbits > 7 {
-		// Either there was an incomplete symbol, or overlong padding.
-		// Both are decoding errors per RFC 7541 section 5.2.
-		return ErrInvalidHuffman
-	}
-	if mask := uint(1<<cbits - 1); cur&mask != mask {
-		// Trailing bits must be a prefix of EOS per RFC 7541 section 5.2.
-		return ErrInvalidHuffman
-	}
-
-	return nil
-}
-
-// incomparable is a zero-width, non-comparable type. Adding it to a struct
-// makes that struct also non-comparable, and generally doesn't add
-// any size (as long as it's first).
-type incomparable [0]func()
-
-type node struct {
-	_ incomparable
-
-	// children is non-nil for internal nodes
-	children *[256]*node
-
-	// The following are only valid if children is nil:
-	codeLen uint8 // number of bits that led to the output of sym
-	sym     byte  // output symbol
-}
-
-func newInternalNode() *node {
-	return &node{children: new([256]*node)}
-}
-
-var (
-	buildRootOnce       sync.Once
-	lazyRootHuffmanNode *node
-)
-
-func getRootHuffmanNode() *node {
-	buildRootOnce.Do(buildRootHuffmanNode)
-	return lazyRootHuffmanNode
-}
-
-func buildRootHuffmanNode() {
-	if len(huffmanCodes) != 256 {
-		panic("unexpected size")
-	}
-	lazyRootHuffmanNode = newInternalNode()
-	// allocate a leaf node for each of the 256 symbols
-	leaves := new([256]node)
-
-	for sym, code := range huffmanCodes {
-		codeLen := huffmanCodeLen[sym]
-
-		cur := lazyRootHuffmanNode
-		for codeLen > 8 {
-			codeLen -= 8
-			i := uint8(code >> codeLen)
-			if cur.children[i] == nil {
-				cur.children[i] = newInternalNode()
-			}
-			cur = cur.children[i]
-		}
-		shift := 8 - codeLen
-		start, end := int(uint8(code<<shift)), int(1<<shift)
-
-		leaves[sym].sym = byte(sym)
-		leaves[sym].codeLen = codeLen
-		for i := start; i < start+end; i++ {
-			cur.children[i] = &leaves[sym]
-		}
-	}
-}
-
-// AppendHuffmanString appends s, as encoded in Huffman codes, to dst
-// and returns the extended buffer.
-func AppendHuffmanString(dst []byte, s string) []byte {
-	// This relies on the maximum huffman code length being 30 (See tables.go huffmanCodeLen array)
-	// So if a uint64 buffer has less than 32 valid bits can always accommodate another huffmanCode.
-	var (
-		x uint64 // buffer
-		n uint   // number valid of bits present in x
-	)
-	for i := 0; i < len(s); i++ {
-		c := s[i]
-		n += uint(huffmanCodeLen[c])
-		x <<= huffmanCodeLen[c] % 64
-		x |= uint64(huffmanCodes[c])
-		if n >= 32 {
-			n %= 32             // Normally would be -= 32 but %= 32 informs compiler 0 <= n <= 31 for upcoming shift
-			y := uint32(x >> n) // Compiler doesn't combine memory writes if y isn't uint32
-			dst = append(dst, byte(y>>24), byte(y>>16), byte(y>>8), byte(y))
-		}
-	}
-	// Add padding bits if necessary
-	if over := n % 8; over > 0 {
-		const (
-			eosCode    = 0x3fffffff
-			eosNBits   = 30
-			eosPadByte = eosCode >> (eosNBits - 8)
-		)
-		pad := 8 - over
-		x = (x << pad) | (eosPadByte >> over)
-		n += pad // 8 now divides into n exactly
-	}
-	// n in (0, 8, 16, 24, 32)
-	switch n / 8 {
-	case 0:
-		return dst
-	case 1:
-		return append(dst, byte(x))
-	case 2:
-		y := uint16(x)
-		return append(dst, byte(y>>8), byte(y))
-	case 3:
-		y := uint16(x >> 8)
-		return append(dst, byte(y>>8), byte(y), byte(x))
-	}
-	//	case 4:
-	y := uint32(x)
-	return append(dst, byte(y>>24), byte(y>>16), byte(y>>8), byte(y))
-}
-
-// HuffmanEncodeLength returns the number of bytes required to encode
-// s in Huffman codes. The result is round up to byte boundary.
-func HuffmanEncodeLength(s string) uint64 {
-	n := uint64(0)
-	for i := 0; i < len(s); i++ {
-		n += uint64(huffmanCodeLen[s[i]])
-	}
-	return (n + 7) / 8
-}
-- 
cgit v1.2.3