@ttsc/win32-arm64 0.33.0 → 0.34.0

package/bin/go/src/vendor/modules.txt

@@ -1,25 +1,31 @@
-# golang.org/x/crypto v0.46.1-0.20251210140736-7dacc380ba00
-## explicit; go 1.24.0
+# golang.org/x/crypto v0.52.1-0.20260526024921-9beb694f9766
+## explicit; go 1.25.0
 golang.org/x/crypto/chacha20
 golang.org/x/crypto/chacha20poly1305
 golang.org/x/crypto/cryptobyte
 golang.org/x/crypto/cryptobyte/asn1
+golang.org/x/crypto/hkdf
 golang.org/x/crypto/internal/alias
 golang.org/x/crypto/internal/poly1305
-# golang.org/x/net v0.47.1-0.20260925170545-1431957440b7
-## explicit; go 1.24.0
+# golang.org/x/net v0.55.1-0.20260731170536-c1d18010be90
+## explicit; go 1.25.0
 golang.org/x/net/dns/dnsmessage
 golang.org/x/net/http/httpguts
 golang.org/x/net/http/httpproxy
 golang.org/x/net/http2/hpack
+golang.org/x/net/http3
 golang.org/x/net/idna
+golang.org/x/net/internal/http3
+golang.org/x/net/internal/httpcommon
+golang.org/x/net/internal/quic/quicwire
 golang.org/x/net/lif
 golang.org/x/net/nettest
-# golang.org/x/sys v0.39.0
-## explicit; go 1.24.0
+golang.org/x/net/quic
+# golang.org/x/sys v0.45.0
+## explicit; go 1.25.0
 golang.org/x/sys/cpu
-# golang.org/x/text v0.32.0
-## explicit; go 1.24.0
+# golang.org/x/text v0.37.0
+## explicit; go 1.25.0
 golang.org/x/text/secure/bidirule
 golang.org/x/text/transform
 golang.org/x/text/unicode/bidi

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/win32-arm64",
-  "version": "0.33.0",
+  "version": "0.34.0",
   "description": "Windows arm64 native ttsc/ttscserver binaries and bundled Go compiler for ttsc.",
   "os": [
     "win32"

package/bin/go/src/crypto/internal/fips140/nistec/p256_ordinv_noasm.go

@@ -1,13 +0,0 @@
-// Copyright 2022 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.
-
-//go:build (!amd64 && !arm64) || purego
-
-package nistec
-
-import "errors"
-
-func P256OrdInverse(k []byte) ([]byte, error) {
-	return nil, errors.New("unimplemented")
-}

package/bin/go/src/go/internal/scannerhooks/hooks.go

@@ -1,11 +0,0 @@
-// 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 scannerhooks defines nonexported channels between parser and scanner.
-// Ideally this package could be eliminated by adding API to scanner.
-package scannerhooks
-
-import "go/token"
-
-var StringEnd func(scanner any) token.Pos

package/bin/go/src/hash/maphash/maphash_purego.go

@@ -1,200 +0,0 @@
-// Copyright 2023 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.
-
-//go:build purego
-
-package maphash
-
-import (
-	"crypto/rand"
-	"errors"
-	"internal/byteorder"
-	"math"
-	"math/bits"
-	"reflect"
-)
-
-const purego = true
-
-var hashkey [4]uint64
-
-func init() {
-	for i := range hashkey {
-		hashkey[i] = randUint64()
-	}
-}
-
-func rthash(buf []byte, seed uint64) uint64 {
-	if len(buf) == 0 {
-		return seed
-	}
-	return wyhash(buf, seed, uint64(len(buf)))
-}
-
-func rthashString(s string, state uint64) uint64 {
-	return rthash([]byte(s), state)
-}
-
-func randUint64() uint64 {
-	buf := make([]byte, 8)
-	_, _ = rand.Read(buf)
-	return byteorder.LEUint64(buf)
-}
-
-// This is a port of wyhash implementation in runtime/hash64.go,
-// without using unsafe for purego.
-
-const m5 = 0x1d8e4e27c47d124f
-
-func wyhash(key []byte, seed, len uint64) uint64 {
-	p := key
-	i := len
-	var a, b uint64
-	seed ^= hashkey[0]
-
-	if i > 16 {
-		if i > 48 {
-			seed1 := seed
-			seed2 := seed
-			for ; i > 48; i -= 48 {
-				seed = mix(r8(p)^hashkey[1], r8(p[8:])^seed)
-				seed1 = mix(r8(p[16:])^hashkey[2], r8(p[24:])^seed1)
-				seed2 = mix(r8(p[32:])^hashkey[3], r8(p[40:])^seed2)
-				p = p[48:]
-			}
-			seed ^= seed1 ^ seed2
-		}
-		for ; i > 16; i -= 16 {
-			seed = mix(r8(p)^hashkey[1], r8(p[8:])^seed)
-			p = p[16:]
-		}
-	}
-	switch {
-	case i == 0:
-		return seed
-	case i < 4:
-		a = r3(p, i)
-	default:
-		n := (i >> 3) << 2
-		a = r4(p)<<32 | r4(p[n:])
-		b = r4(p[i-4:])<<32 | r4(p[i-4-n:])
-	}
-	return mix(m5^len, mix(a^hashkey[1], b^seed))
-}
-
-func r3(p []byte, k uint64) uint64 {
-	return (uint64(p[0]) << 16) | (uint64(p[k>>1]) << 8) | uint64(p[k-1])
-}
-
-func r4(p []byte) uint64 {
-	return uint64(byteorder.LEUint32(p))
-}
-
-func r8(p []byte) uint64 {
-	return byteorder.LEUint64(p)
-}
-
-func mix(a, b uint64) uint64 {
-	hi, lo := bits.Mul64(a, b)
-	return hi ^ lo
-}
-
-func comparableHash[T comparable](v T, seed Seed) uint64 {
-	var h Hash
-	h.SetSeed(seed)
-	writeComparable(&h, v)
-	return h.Sum64()
-}
-
-func writeComparable[T comparable](h *Hash, v T) {
-	vv := reflect.ValueOf(v)
-	appendT(h, vv)
-}
-
-// appendT hash a value.
-func appendT(h *Hash, v reflect.Value) {
-	h.WriteString(v.Type().String())
-	switch v.Kind() {
-	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
-		var buf [8]byte
-		byteorder.LEPutUint64(buf[:], uint64(v.Int()))
-		h.Write(buf[:])
-		return
-	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint, reflect.Uintptr:
-		var buf [8]byte
-		byteorder.LEPutUint64(buf[:], v.Uint())
-		h.Write(buf[:])
-		return
-	case reflect.Array:
-		var buf [8]byte
-		for i := range uint64(v.Len()) {
-			byteorder.LEPutUint64(buf[:], i)
-			// do not want to hash to the same value,
-			// [2]string{"foo", ""} and [2]string{"", "foo"}.
-			h.Write(buf[:])
-			appendT(h, v.Index(int(i)))
-		}
-		return
-	case reflect.String:
-		h.WriteString(v.String())
-		return
-	case reflect.Struct:
-		var buf [8]byte
-		for i := range v.NumField() {
-			f := v.Field(i)
-			byteorder.LEPutUint64(buf[:], uint64(i))
-			// do not want to hash to the same value,
-			// struct{a,b string}{"foo",""} and
-			// struct{a,b string}{"","foo"}.
-			h.Write(buf[:])
-			appendT(h, f)
-		}
-		return
-	case reflect.Complex64, reflect.Complex128:
-		c := v.Complex()
-		h.float64(real(c))
-		h.float64(imag(c))
-		return
-	case reflect.Float32, reflect.Float64:
-		h.float64(v.Float())
-		return
-	case reflect.Bool:
-		h.WriteByte(btoi(v.Bool()))
-		return
-	case reflect.UnsafePointer, reflect.Pointer, reflect.Chan:
-		var buf [8]byte
-		// because pointing to the abi.Escape call in comparableReady,
-		// So this is ok to hash pointer,
-		// this way because we know their target won't be moved.
-		byteorder.LEPutUint64(buf[:], uint64(v.Pointer()))
-		h.Write(buf[:])
-		return
-	case reflect.Interface:
-		appendT(h, v.Elem())
-		return
-	}
-	panic(errors.New("maphash: hash of unhashable type " + v.Type().String()))
-}
-
-func (h *Hash) float64(f float64) {
-	if f == 0 {
-		h.WriteByte(0)
-		return
-	}
-	var buf [8]byte
-	if f != f {
-		byteorder.LEPutUint64(buf[:], randUint64())
-		h.Write(buf[:])
-		return
-	}
-	byteorder.LEPutUint64(buf[:], math.Float64bits(f))
-	h.Write(buf[:])
-}
-
-func btoi(b bool) byte {
-	if b {
-		return 1
-	}
-	return 0
-}

package/bin/go/src/hash/maphash/maphash_runtime.go

@@ -1,64 +0,0 @@
-// Copyright 2023 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.
-
-//go:build !purego
-
-package maphash
-
-import (
-	"internal/abi"
-	"internal/runtime/maps"
-	"unsafe"
-)
-
-const purego = false
-
-//go:linkname runtime_rand runtime.rand
-func runtime_rand() uint64
-
-//go:linkname runtime_memhash runtime.memhash
-//go:noescape
-func runtime_memhash(p unsafe.Pointer, seed, s uintptr) uintptr
-
-func rthash(buf []byte, seed uint64) uint64 {
-	if len(buf) == 0 {
-		return seed
-	}
-	len := len(buf)
-	// The runtime hasher only works on uintptr. For 64-bit
-	// architectures, we use the hasher directly. Otherwise,
-	// we use two parallel hashers on the lower and upper 32 bits.
-	if maps.Use64BitHash {
-		return uint64(runtime_memhash(unsafe.Pointer(&buf[0]), uintptr(seed), uintptr(len)))
-	}
-	lo := runtime_memhash(unsafe.Pointer(&buf[0]), uintptr(uint32(seed)), uintptr(len))
-	hi := runtime_memhash(unsafe.Pointer(&buf[0]), uintptr(seed>>32), uintptr(len))
-	return uint64(hi)<<32 | uint64(lo)
-}
-
-func rthashString(s string, state uint64) uint64 {
-	buf := unsafe.Slice(unsafe.StringData(s), len(s))
-	return rthash(buf, state)
-}
-
-func randUint64() uint64 {
-	return runtime_rand()
-}
-
-func comparableHash[T comparable](v T, seed Seed) uint64 {
-	s := seed.s
-	var m map[T]struct{}
-	mTyp := abi.TypeOf(m)
-	hasher := (*abi.MapType)(unsafe.Pointer(mTyp)).Hasher
-	if maps.Use64BitHash {
-		return uint64(hasher(abi.NoEscape(unsafe.Pointer(&v)), uintptr(s)))
-	}
-	lo := hasher(abi.NoEscape(unsafe.Pointer(&v)), uintptr(uint32(s)))
-	hi := hasher(abi.NoEscape(unsafe.Pointer(&v)), uintptr(s>>32))
-	return uint64(hi)<<32 | uint64(lo)
-}
-
-func writeComparable[T comparable](h *Hash, v T) {
-	h.state.s = comparableHash(v, h.state)
-}

package/bin/go/src/internal/goexperiment/exp_goroutineleakprofile_off.go

@@ -1,8 +0,0 @@
-// Code generated by mkconsts.go. DO NOT EDIT.
-
-//go:build !goexperiment.goroutineleakprofile
-
-package goexperiment
-
-const GoroutineLeakProfile = false
-const GoroutineLeakProfileInt = 0

package/bin/go/src/internal/goexperiment/exp_goroutineleakprofile_on.go

@@ -1,8 +0,0 @@
-// Code generated by mkconsts.go. DO NOT EDIT.
-
-//go:build goexperiment.goroutineleakprofile
-
-package goexperiment
-
-const GoroutineLeakProfile = true
-const GoroutineLeakProfileInt = 1

package/bin/go/src/internal/strconv/atofeisel.go

@@ -1,166 +0,0 @@
-// Copyright 2020 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 strconv
-
-// This file implements the Eisel-Lemire ParseFloat algorithm, published in
-// 2020 and discussed extensively at
-// https://nigeltao.github.io/blog/2020/eisel-lemire.html
-//
-// The original C++ implementation is at
-// https://github.com/lemire/fast_double_parser/blob/644bef4306059d3be01a04e77d3cc84b379c596f/include/fast_double_parser.h#L840
-//
-// This Go re-implementation closely follows the C re-implementation at
-// https://github.com/google/wuffs/blob/ba3818cb6b473a2ed0b38ecfc07dbbd3a97e8ae7/internal/cgen/base/floatconv-submodule-code.c#L990
-//
-// Additional testing (on over several million test strings) is done by
-// https://github.com/nigeltao/parse-number-fxx-test-data/blob/5280dcfccf6d0b02a65ae282dad0b6d9de50e039/script/test-go-strconv.go
-
-import (
-	"math/bits"
-)
-
-func eiselLemire64(man uint64, exp10 int, neg bool) (f float64, ok bool) {
-	// The terse comments in this function body refer to sections of the
-	// https://nigeltao.github.io/blog/2020/eisel-lemire.html blog post.
-
-	// Exp10 Range.
-	if man == 0 {
-		if neg {
-			f = float64frombits(0x8000000000000000) // Negative zero.
-		}
-		return f, true
-	}
-	pow, exp2, ok := pow10(exp10)
-	if !ok {
-		return 0, false
-	}
-
-	// Normalization.
-	clz := bits.LeadingZeros64(man)
-	man <<= uint(clz)
-	retExp2 := uint64(exp2+63-float64Bias) - uint64(clz)
-
-	// Multiplication.
-	xHi, xLo := bits.Mul64(man, pow.Hi)
-
-	// Wider Approximation.
-	if xHi&0x1FF == 0x1FF && xLo+man < man {
-		yHi, yLo := bits.Mul64(man, pow.Lo)
-		mergedHi, mergedLo := xHi, xLo+yHi
-		if mergedLo < xLo {
-			mergedHi++
-		}
-		if mergedHi&0x1FF == 0x1FF && mergedLo+1 == 0 && yLo+man < man {
-			return 0, false
-		}
-		xHi, xLo = mergedHi, mergedLo
-	}
-
-	// Shifting to 54 Bits.
-	msb := xHi >> 63
-	retMantissa := xHi >> (msb + 9)
-	retExp2 -= 1 ^ msb
-
-	// Half-way Ambiguity.
-	if xLo == 0 && xHi&0x1FF == 0 && retMantissa&3 == 1 {
-		return 0, false
-	}
-
-	// From 54 to 53 Bits.
-	retMantissa += retMantissa & 1
-	retMantissa >>= 1
-	if retMantissa>>53 > 0 {
-		retMantissa >>= 1
-		retExp2 += 1
-	}
-	// retExp2 is a uint64. Zero or underflow means that we're in subnormal
-	// float64 space. 0x7FF or above means that we're in Inf/NaN float64 space.
-	//
-	// The if block is equivalent to (but has fewer branches than):
-	//   if retExp2 <= 0 || retExp2 >= 0x7FF { etc }
-	if retExp2-1 >= 0x7FF-1 {
-		return 0, false
-	}
-	retBits := retExp2<<float64MantBits | retMantissa&(1<<float64MantBits-1)
-	if neg {
-		retBits |= 0x8000000000000000
-	}
-	return float64frombits(retBits), true
-}
-
-func eiselLemire32(man uint64, exp10 int, neg bool) (f float32, ok bool) {
-	// The terse comments in this function body refer to sections of the
-	// https://nigeltao.github.io/blog/2020/eisel-lemire.html blog post.
-	//
-	// That blog post discusses the float64 flavor (11 exponent bits with a
-	// -1023 bias, 52 mantissa bits) of the algorithm, but the same approach
-	// applies to the float32 flavor (8 exponent bits with a -127 bias, 23
-	// mantissa bits). The computation here happens with 64-bit values (e.g.
-	// man, xHi, retMantissa) before finally converting to a 32-bit float.
-
-	// Exp10 Range.
-	if man == 0 {
-		if neg {
-			f = float32frombits(0x80000000) // Negative zero.
-		}
-		return f, true
-	}
-	pow, exp2, ok := pow10(exp10)
-	if !ok {
-		return 0, false
-	}
-
-	// Normalization.
-	clz := bits.LeadingZeros64(man)
-	man <<= uint(clz)
-	retExp2 := uint64(exp2+63-float32Bias) - uint64(clz)
-
-	// Multiplication.
-	xHi, xLo := bits.Mul64(man, pow.Hi)
-
-	// Wider Approximation.
-	if xHi&0x3FFFFFFFFF == 0x3FFFFFFFFF && xLo+man < man {
-		yHi, yLo := bits.Mul64(man, pow.Lo)
-		mergedHi, mergedLo := xHi, xLo+yHi
-		if mergedLo < xLo {
-			mergedHi++
-		}
-		if mergedHi&0x3FFFFFFFFF == 0x3FFFFFFFFF && mergedLo+1 == 0 && yLo+man < man {
-			return 0, false
-		}
-		xHi, xLo = mergedHi, mergedLo
-	}
-
-	// Shifting to 54 Bits (and for float32, it's shifting to 25 bits).
-	msb := xHi >> 63
-	retMantissa := xHi >> (msb + 38)
-	retExp2 -= 1 ^ msb
-
-	// Half-way Ambiguity.
-	if xLo == 0 && xHi&0x3FFFFFFFFF == 0 && retMantissa&3 == 1 {
-		return 0, false
-	}
-
-	// From 54 to 53 Bits (and for float32, it's from 25 to 24 bits).
-	retMantissa += retMantissa & 1
-	retMantissa >>= 1
-	if retMantissa>>24 > 0 {
-		retMantissa >>= 1
-		retExp2 += 1
-	}
-	// retExp2 is a uint64. Zero or underflow means that we're in subnormal
-	// float32 space. 0xFF or above means that we're in Inf/NaN float32 space.
-	//
-	// The if block is equivalent to (but has fewer branches than):
-	//   if retExp2 <= 0 || retExp2 >= 0xFF { etc }
-	if retExp2-1 >= 0xFF-1 {
-		return 0, false
-	}
-	retBits := retExp2<<float32MantBits | retMantissa&(1<<float32MantBits-1)
-	if neg {
-		retBits |= 0x80000000
-	}
-	return float32frombits(uint32(retBits)), true
-}