slidge-whatsapp 0.2.5__cp311-cp311-manylinux_2_36_aarch64.whl → 0.2.7__cp311-cp311-manylinux_2_36_aarch64.whl

slidge_whatsapp/vendor/go.mau.fi/util/dbutil/upgradetable.go

@@ -0,0 +1,331 @@
+// Copyright (c) 2023 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package dbutil
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"io/fs"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+type TxnMode string
+
+const (
+	TxnModeOn                   TxnMode = "on"
+	TxnModeOff                  TxnMode = "off"
+	TxnModeSQLiteForeignKeysOff TxnMode = "sqlite-fkey-off"
+)
+
+type UpgradeTable []upgrade
+
+func (ut *UpgradeTable) extend(toSize int) {
+	if cap(*ut) >= toSize {
+		*ut = (*ut)[:toSize]
+	} else {
+		resized := make([]upgrade, toSize)
+		copy(resized, *ut)
+		*ut = resized
+	}
+}
+
+func (ut *UpgradeTable) Register(from, to, compat int, message string, txn TxnMode, fn upgradeFunc) {
+	if from < 0 {
+		from += to
+	}
+	if from < 0 {
+		panic("invalid from value in UpgradeTable.Register() call")
+	}
+	if compat <= 0 {
+		compat = to
+	}
+	upg := upgrade{message: message, fn: fn, upgradesTo: to, compatVersion: compat, transaction: txn}
+	if len(*ut) == from {
+		*ut = append(*ut, upg)
+		return
+	} else if len(*ut) < from {
+		ut.extend(from + 1)
+	} else if (*ut)[from].fn != nil {
+		panic(fmt.Errorf("tried to override upgrade at %d ('%s') with '%s'", from, (*ut)[from].message, upg.message))
+	}
+	(*ut)[from] = upg
+}
+
+// Syntax is either
+//
+//	-- v0 -> v1: Message
+//
+// or
+//
+//	-- v1: Message
+//
+// Both syntaxes may also have a compatibility notice before the colon:
+//
+//	-- v5 (compatible with v3+): Upgrade with backwards compatibility
+var upgradeHeaderRegex = regexp.MustCompile(`^-- (?:v(\d+) -> )?v(\d+)(?: \(compatible with v(\d+)\+\))?: (.+)$`)
+
+// To disable wrapping the upgrade in a single transaction, put `--transaction: off` on the second line.
+//
+//	-- v5: Upgrade without transaction
+//	-- transaction: off
+//	// do dangerous stuff
+var transactionDisableRegex = regexp.MustCompile(`^-- transaction: ([a-z-]*)`)
+
+func parseFileHeader(file []byte) (from, to, compat int, message string, txn TxnMode, lines [][]byte, err error) {
+	lines = bytes.Split(file, []byte("\n"))
+	if len(lines) < 2 {
+		err = errors.New("upgrade file too short")
+		return
+	}
+	var maybeFrom int
+	match := upgradeHeaderRegex.FindSubmatch(lines[0])
+	lines = lines[1:]
+	if match == nil {
+		err = errors.New("header not found")
+	} else if len(match) != 5 {
+		err = errors.New("unexpected number of items in regex match")
+	} else if maybeFrom, err = strconv.Atoi(string(match[1])); len(match[1]) > 0 && err != nil {
+		err = fmt.Errorf("invalid source version: %w", err)
+	} else if to, err = strconv.Atoi(string(match[2])); err != nil {
+		err = fmt.Errorf("invalid target version: %w", err)
+	} else if compat, err = strconv.Atoi(string(match[3])); len(match[3]) > 0 && err != nil {
+		err = fmt.Errorf("invalid compatible version: %w", err)
+	} else {
+		err = nil
+		if len(match[1]) > 0 {
+			from = maybeFrom
+		} else {
+			from = -1
+		}
+		message = string(match[4])
+		txn = "on"
+		match = transactionDisableRegex.FindSubmatch(lines[0])
+		if match != nil {
+			lines = lines[1:]
+			txn = TxnMode(match[1])
+			switch txn {
+			case TxnModeOff, TxnModeOn, TxnModeSQLiteForeignKeysOff:
+				// ok
+			default:
+				err = fmt.Errorf("invalid value %q for transaction flag", match[1])
+			}
+		}
+	}
+	return
+}
+
+// To limit the next line to one dialect:
+//
+//	-- only: postgres
+//
+// To limit the next N lines:
+//
+//	-- only: sqlite for next 123 lines
+//
+// To limit a block of code, fenced by another directive:
+//
+//	-- only: sqlite until "end only"
+//	QUERY;
+//	ANOTHER QUERY;
+//	-- end only sqlite
+//
+// If the single-line limit is on the second line of the file, the whole file is limited to that dialect.
+//
+// If the filter ends with `(lines commented)`, then ALL lines chosen by the filter will be uncommented.
+var dialectLineFilter = regexp.MustCompile(`^\s*-- only: (postgres|sqlite)(?: for next (\d+) lines| until "(end) only")?(?: \(lines? (commented)\))?`)
+
+// Constants used to make parseDialectFilter clearer
+const (
+	skipUntilEndTag = -1
+	skipNothing     = 0
+	skipNextLine    = 1
+)
+
+func (db *Database) parseDialectFilter(line []byte) (dialect Dialect, lineCount int, uncomment bool, err error) {
+	match := dialectLineFilter.FindSubmatch(line)
+	if match == nil {
+		return
+	}
+	dialect, err = ParseDialect(string(match[1]))
+	if err != nil {
+		return
+	}
+	uncomment = bytes.Equal(match[4], []byte("commented"))
+	if bytes.Equal(match[3], []byte("end")) {
+		lineCount = skipUntilEndTag
+	} else if len(match[2]) == 0 {
+		lineCount = skipNextLine
+	} else {
+		lineCount, err = strconv.Atoi(string(match[2]))
+		if err != nil {
+			err = fmt.Errorf("invalid line count %q: %w", match[2], err)
+		}
+	}
+	return
+}
+
+var endLineFilter = regexp.MustCompile(`^\s*-- end only (postgres|sqlite)$`)
+
+func (db *Database) Internals() *publishDatabaseInternals {
+	return (*publishDatabaseInternals)(db)
+}
+
+type publishDatabaseInternals Database
+
+func (di *publishDatabaseInternals) FilterSQLUpgrade(lines [][]byte) (string, error) {
+	return (*Database)(di).filterSQLUpgrade(lines)
+}
+
+func (db *Database) filterSQLUpgrade(lines [][]byte) (string, error) {
+	output := make([][]byte, 0, len(lines))
+	for i := 0; i < len(lines); i++ {
+		dialect, lineCount, uncomment, err := db.parseDialectFilter(lines[i])
+		if err != nil {
+			return "", err
+		} else if lineCount == skipNothing {
+			output = append(output, lines[i])
+		} else if lineCount == skipUntilEndTag {
+			startedAt := i
+			startedAtMatch := dialectLineFilter.FindSubmatch(lines[startedAt])
+			// Skip filter start line
+			i++
+			for ; i < len(lines); i++ {
+				if match := endLineFilter.FindSubmatch(lines[i]); match != nil {
+					if !bytes.Equal(match[1], startedAtMatch[1]) {
+						return "", fmt.Errorf(`unexpected end tag %q for %q start at line %d`, string(match[0]), string(startedAtMatch[1]), startedAt)
+					}
+					break
+				}
+				if dialect == db.Dialect {
+					if uncomment {
+						output = append(output, bytes.TrimPrefix(lines[i], []byte("--")))
+					} else {
+						output = append(output, lines[i])
+					}
+				}
+			}
+			if i == len(lines) {
+				return "", fmt.Errorf(`didn't get end tag matching start %q at line %d`, string(startedAtMatch[1]), startedAt)
+			}
+		} else if dialect != db.Dialect {
+			i += lineCount
+		} else {
+			// Skip current line, uncomment the specified number of lines
+			i++
+			targetI := i + lineCount
+			for ; i < targetI; i++ {
+				if uncomment {
+					output = append(output, bytes.TrimPrefix(lines[i], []byte("--")))
+				} else {
+					output = append(output, lines[i])
+				}
+			}
+			// Decrement counter to avoid skipping the next line
+			i--
+		}
+	}
+	return string(bytes.Join(output, []byte("\n"))), nil
+}
+
+func sqlUpgradeFunc(fileName string, lines [][]byte) upgradeFunc {
+	return func(ctx context.Context, db *Database) error {
+		if dialect, skip, _, err := db.parseDialectFilter(lines[0]); err == nil && skip == skipNextLine && dialect != db.Dialect {
+			return nil
+		} else if upgradeSQL, err := db.filterSQLUpgrade(lines); err != nil {
+			panic(fmt.Errorf("failed to parse upgrade %s: %w", fileName, err))
+		} else {
+			_, err = db.Exec(ctx, upgradeSQL)
+			return err
+		}
+	}
+}
+
+func splitSQLUpgradeFunc(sqliteData, postgresData string) upgradeFunc {
+	return func(ctx context.Context, db *Database) (err error) {
+		switch db.Dialect {
+		case SQLite:
+			_, err = db.Exec(ctx, sqliteData)
+		case Postgres:
+			_, err = db.Exec(ctx, postgresData)
+		default:
+			err = fmt.Errorf("unknown dialect %s", db.Dialect)
+		}
+		return
+	}
+}
+
+func parseSplitSQLUpgrade(name string, fs fullFS, skipNames map[string]struct{}) (from, to, compat int, message string, txn TxnMode, fn upgradeFunc) {
+	postgresName := fmt.Sprintf("%s.postgres.sql", name)
+	sqliteName := fmt.Sprintf("%s.sqlite.sql", name)
+	skipNames[postgresName] = struct{}{}
+	skipNames[sqliteName] = struct{}{}
+	postgresData, err := fs.ReadFile(postgresName)
+	if err != nil {
+		panic(err)
+	}
+	sqliteData, err := fs.ReadFile(sqliteName)
+	if err != nil {
+		panic(err)
+	}
+	from, to, compat, message, txn, _, err = parseFileHeader(postgresData)
+	if err != nil {
+		panic(fmt.Errorf("failed to parse header in %s: %w", postgresName, err))
+	}
+	sqliteFrom, sqliteTo, sqliteCompat, sqliteMessage, sqliteTxn, _, err := parseFileHeader(sqliteData)
+	if err != nil {
+		panic(fmt.Errorf("failed to parse header in %s: %w", sqliteName, err))
+	}
+	if from != sqliteFrom || to != sqliteTo || compat != sqliteCompat {
+		panic(fmt.Errorf("mismatching versions in postgres and sqlite versions of %s: %d/%d -> %d/%d", name, from, sqliteFrom, to, sqliteTo))
+	} else if message != sqliteMessage {
+		panic(fmt.Errorf("mismatching message in postgres and sqlite versions of %s: %q != %q", name, message, sqliteMessage))
+	} else if txn != sqliteTxn {
+		panic(fmt.Errorf("mismatching transaction flag in postgres and sqlite versions of %s: %s != %s", name, txn, sqliteTxn))
+	}
+	fn = splitSQLUpgradeFunc(string(sqliteData), string(postgresData))
+	return
+}
+
+type fullFS interface {
+	fs.ReadFileFS
+	fs.ReadDirFS
+}
+
+var splitFileNameRegex = regexp.MustCompile(`^(.+)\.(postgres|sqlite)\.sql$`)
+
+func (ut *UpgradeTable) RegisterFS(fs fullFS) {
+	ut.RegisterFSPath(fs, ".")
+}
+
+func (ut *UpgradeTable) RegisterFSPath(fs fullFS, dir string) {
+	files, err := fs.ReadDir(dir)
+	if err != nil {
+		panic(err)
+	}
+	skipNames := map[string]struct{}{}
+	for _, file := range files {
+		if file.IsDir() || !strings.HasSuffix(file.Name(), ".sql") {
+			// do nothing
+		} else if _, skip := skipNames[file.Name()]; skip {
+			// also do nothing
+		} else if splitName := splitFileNameRegex.FindStringSubmatch(file.Name()); splitName != nil {
+			from, to, compat, message, txn, fn := parseSplitSQLUpgrade(splitName[1], fs, skipNames)
+			ut.Register(from, to, compat, message, txn, fn)
+		} else if data, err := fs.ReadFile(filepath.Join(dir, file.Name())); err != nil {
+			panic(err)
+		} else if from, to, compat, message, txn, lines, err := parseFileHeader(data); err != nil {
+			panic(fmt.Errorf("failed to parse header in %s: %w", file.Name(), err))
+		} else {
+			ut.Register(from, to, compat, message, txn, sqlUpgradeFunc(file.Name(), lines))
+		}
+	}
+}

slidge_whatsapp/vendor/go.mau.fi/util/exerrors/dualerror.go

@@ -0,0 +1,33 @@
+// Copyright (c) 2022 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package exerrors
+
+import (
+	"errors"
+	"fmt"
+)
+
+type DualError struct {
+	High error
+	Low  error
+}
+
+func NewDualError(high, low error) DualError {
+	return DualError{high, low}
+}
+
+func (err DualError) Is(other error) bool {
+	return errors.Is(other, err.High) || errors.Is(other, err.Low)
+}
+
+func (err DualError) Unwrap() error {
+	return err.Low
+}
+
+func (err DualError) Error() string {
+	return fmt.Sprintf("%v: %v", err.High, err.Low)
+}

slidge_whatsapp/vendor/go.mau.fi/util/exerrors/must.go

@@ -0,0 +1,23 @@
+// Copyright (c) 2024 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package exerrors
+
+func Must[T any](val T, err error) T {
+	PanicIfNotNil(err)
+	return val
+}
+
+func Must2[T any, T2 any](val T, val2 T2, err error) (T, T2) {
+	PanicIfNotNil(err)
+	return val, val2
+}
+
+func PanicIfNotNil(err error) {
+	if err != nil {
+		panic(err)
+	}
+}

slidge_whatsapp/vendor/go.mau.fi/util/exhttp/cors.go

@@ -0,0 +1,32 @@
+// Copyright (c) 2024 Sumner Evans
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package exhttp
+
+import "net/http"
+
+func AddCORSHeaders(w http.ResponseWriter) {
+	// Recommended CORS headers can be found in https://spec.matrix.org/v1.3/client-server-api/#web-browser-clients
+	w.Header().Set("Access-Control-Allow-Origin", "*")
+	w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
+	w.Header().Set("Access-Control-Allow-Headers", "X-Requested-With, Content-Type, Authorization")
+	w.Header().Set("Content-Security-Policy", "sandbox; default-src 'none'; script-src 'none'; plugin-types application/pdf; style-src 'unsafe-inline'; object-src 'self';")
+	// Allow browsers to cache above for 1 day
+	w.Header().Set("Access-Control-Max-Age", "86400")
+}
+
+// CORSMiddleware adds CORS headers to the response and handles OPTIONS
+// requests by returning 200 OK immediately.
+func CORSMiddleware(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		AddCORSHeaders(w)
+		if r.Method == http.MethodOptions {
+			w.WriteHeader(http.StatusOK)
+			return
+		}
+		next.ServeHTTP(w, r)
+	})
+}

slidge_whatsapp/vendor/go.mau.fi/util/exhttp/handleerrors.go

@@ -0,0 +1,64 @@
+// Copyright (c) 2024 Sumner Evans
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package exhttp
+
+import "net/http"
+
+type ErrorBodyGenerators struct {
+	NotFound         func() []byte
+	MethodNotAllowed func() []byte
+}
+
+func HandleErrors(next http.Handler, gen ErrorBodyGenerators) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		next.ServeHTTP(&bodyOverrider{
+			ResponseWriter:                      w,
+			statusNotFoundBodyGenerator:         gen.NotFound,
+			statusMethodNotAllowedBodyGenerator: gen.MethodNotAllowed,
+		}, r)
+	})
+}
+
+type bodyOverrider struct {
+	http.ResponseWriter
+
+	code     int
+	override bool
+
+	statusNotFoundBodyGenerator         func() []byte
+	statusMethodNotAllowedBodyGenerator func() []byte
+}
+
+var _ http.ResponseWriter = (*bodyOverrider)(nil)
+
+func (b *bodyOverrider) WriteHeader(code int) {
+	if b.Header().Get("Content-Type") == "text/plain; charset=utf-8" {
+		b.Header().Set("Content-Type", "application/json")
+
+		b.override = true
+	}
+
+	b.code = code
+	b.ResponseWriter.WriteHeader(code)
+}
+
+func (b *bodyOverrider) Write(body []byte) (int, error) {
+	if b.override {
+		switch b.code {
+		case http.StatusNotFound:
+			if b.statusNotFoundBodyGenerator != nil {
+				body = b.statusNotFoundBodyGenerator()
+			}
+		case http.StatusMethodNotAllowed:
+			if b.statusMethodNotAllowedBodyGenerator != nil {
+				body = b.statusMethodNotAllowedBodyGenerator()
+			}
+		}
+	}
+
+	return b.ResponseWriter.Write(body)
+}

slidge_whatsapp/vendor/go.mau.fi/util/exhttp/json.go

@@ -0,0 +1,36 @@
+// Copyright (c) 2024 Sumner Evans
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package exhttp
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+var AutoAllowCORS = true
+
+func WriteJSONResponse(w http.ResponseWriter, httpStatusCode int, jsonData any) {
+	if AutoAllowCORS {
+		AddCORSHeaders(w)
+	}
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(httpStatusCode)
+	_ = json.NewEncoder(w).Encode(jsonData)
+}
+
+func WriteJSONData(w http.ResponseWriter, httpStatusCode int, data []byte) {
+	if AutoAllowCORS {
+		AddCORSHeaders(w)
+	}
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(httpStatusCode)
+	_, _ = w.Write(data)
+}
+
+func WriteEmptyJSONResponse(w http.ResponseWriter, httpStatusCode int) {
+	WriteJSONData(w, httpStatusCode, []byte("{}"))
+}

slidge_whatsapp/vendor/go.mau.fi/util/exhttp/middleware.go

@@ -0,0 +1,30 @@
+// Copyright (c) 2024 Sumner Evans
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package exhttp
+
+import "net/http"
+
+// Middleware represents a middleware that can be applied to an [http.Handler].
+type Middleware func(http.Handler) http.Handler
+
+// ApplyMiddleware applies the provided [Middleware] functions to the given
+// router. The middlewares will be applied in the order they are provided.
+func ApplyMiddleware(router http.Handler, middlewares ...Middleware) http.Handler {
+	// Apply middlewares in reverse order because the first middleware provided
+	// needs to be the outermost one.
+	for i := len(middlewares) - 1; i >= 0; i-- {
+		router = middlewares[i](router)
+	}
+	return router
+}
+
+// StripPrefix is a wrapper for [http.StripPrefix] is compatible with the middleware pattern.
+func StripPrefix(prefix string) Middleware {
+	return func(next http.Handler) http.Handler {
+		return http.StripPrefix(prefix, next)
+	}
+}

slidge_whatsapp/vendor/go.mau.fi/util/exhttp/networkerror.go

@@ -0,0 +1,37 @@
+// Copyright (c) 2025 Toni Spets
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package exhttp
+
+import (
+	"errors"
+	"net"
+	"syscall"
+
+	"golang.org/x/net/http2"
+)
+
+func IsNetworkError(err error) bool {
+	if errno := syscall.Errno(0); errors.As(err, &errno) {
+		// common errnos for network related operations
+		return errno == syscall.ENETDOWN ||
+			errno == syscall.ENETUNREACH ||
+			errno == syscall.ENETRESET ||
+			errno == syscall.ECONNABORTED ||
+			errno == syscall.ECONNRESET ||
+			errno == syscall.ENOBUFS ||
+			errno == syscall.ETIMEDOUT ||
+			errno == syscall.ECONNREFUSED ||
+			errno == syscall.EHOSTDOWN ||
+			errno == syscall.EHOSTUNREACH
+	} else if netError := net.Error(nil); errors.As(err, &netError) {
+		return true
+	} else if errors.As(err, &http2.StreamError{}) {
+		return true
+	}
+
+	return false
+}

slidge_whatsapp/vendor/go.mau.fi/util/exstrings/stringutil.go

@@ -0,0 +1,76 @@
+// Copyright (c) 2025 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package exstrings
+
+import (
+	"crypto/sha256"
+	"crypto/subtle"
+	"strings"
+	"unsafe"
+)
+
+// UnsafeBytes returns a byte slice that points to the same memory as the input string.
+//
+// The returned byte slice must not be modified.
+func UnsafeBytes(str string) []byte {
+	return unsafe.Slice(unsafe.StringData(str), len(str))
+}
+
+// SHA256 returns the SHA-256 hash of the input string without copying the string.
+func SHA256(str string) [32]byte {
+	return sha256.Sum256(UnsafeBytes(str))
+}
+
+// ConstantTimeEqual compares two strings using [subtle.ConstantTimeCompare] without copying the strings.
+//
+// Note that ConstantTimeCompare is not constant time if the strings are of different length.
+func ConstantTimeEqual(a, b string) bool {
+	return subtle.ConstantTimeCompare(UnsafeBytes(a), UnsafeBytes(b)) == 1
+}
+
+// LongestSequenceOf returns the length of the longest contiguous sequence of a single rune in a string.
+func LongestSequenceOf(a string, b rune) int {
+	// IndexRune has some optimizations, so use it to find the starting point
+	firstIndex := strings.IndexRune(a, b)
+	if firstIndex == -1 {
+		return 0
+	}
+	count := 0
+	maxCount := 0
+	for _, r := range a[firstIndex:] {
+		if r == b {
+			count++
+			if count > maxCount {
+				maxCount = count
+			}
+		} else {
+			count = 0
+		}
+	}
+	return maxCount
+}
+
+// LongestSequenceOfFunc returns the length of the longest contiguous sequence of runes in a string.
+//
+// If the provided function returns zero or higher, the return value is added to the current count.
+// If the return value is negative, the count is reset to zero.
+func LongestSequenceOfFunc(a string, fn func(b rune) int) int {
+	count := 0
+	maxCount := 0
+	for _, r := range a {
+		val := fn(r)
+		if val < 0 {
+			count = 0
+		} else {
+			count += val
+			if count > maxCount {
+				maxCount = count
+			}
+		}
+	}
+	return maxCount
+}