slidge-whatsapp 0.3.0__cp311-cp311-manylinux_2_36_aarch64.whl → 0.3.1__cp311-cp311-manylinux_2_36_aarch64.whl

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/proto/waWeb/WAWebProtobufsWeb.proto

@@ -307,6 +307,9 @@ message WebMessageInfo {
 	repeated string statusMentionSources = 71;
 	repeated Citation supportAiCitations = 72;
 	optional string botTargetID = 73;
+	optional GroupHistoryIndividualMessageInfo groupHistoryIndividualMessageInfo = 74;
+	optional GroupHistoryBundleInfo groupHistoryBundleInfo = 75;
+	optional InteractiveMessageAdditionalMetadata interactiveMessageAdditionalMetadata = 76;
 }
 
 message PaymentInfo {
@@ -468,6 +471,17 @@ message MessageAddOn {
 	optional LegacyMessage legacyMessage = 8;
 }
 
+message GroupHistoryBundleInfo {
+	enum ProcessState {
+		NOT_DOWNLOADED = 0;
+		DOWNLOADED = 1;
+		DOWNLOAD_FAILED = 2;
+	}
+
+	optional WAWebProtobufsE2E.MessageHistoryBundle deprecatedMessageHistoryBundle = 1;
+	optional ProcessState processState = 2;
+}
+
 message CommentMetadata {
 	optional WACommon.MessageKey commentParentKey = 1;
 	optional uint32 replyCount = 2;
@@ -535,6 +549,10 @@ message PollAdditionalMetadata {
 	optional bool pollInvalidated = 1;
 }
 
+message InteractiveMessageAdditionalMetadata {
+	optional bool isGalaxyFlowCompleted = 1;
+}
+
 message EventAdditionalMetadata {
 	optional bool isStale = 1;
 }
@@ -579,3 +597,7 @@ message Citation {
 	required string cmsID = 3;
 	required string imageURL = 4;
 }
+
+message GroupHistoryIndividualMessageInfo {
+	optional WACommon.MessageKey bundleMessageKey = 1;
+}

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/receipt.go

@@ -239,6 +239,8 @@ func (cli *Client) sendMessageReceipt(info *types.MessageInfo) {
 	}
 	if info.IsFromMe {
 		attrs["type"] = string(types.ReceiptTypeSender)
+	} else if info.Type == "peer_msg" {
+		attrs["type"] = string(types.ReceiptTypePeerMsg)
 	} else if cli.sendActiveReceipts.Load() == 0 {
 		attrs["type"] = string(types.ReceiptTypeInactive)
 	}

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/request.go

@@ -98,6 +98,7 @@ type infoQuery struct {
 	To        types.JID
 	Target    types.JID
 	ID        string
+	SMaxID    string
 	Content   interface{}
 
 	Timeout time.Duration
@@ -118,6 +119,9 @@ func (cli *Client) sendIQAsyncAndGetData(query *infoQuery) (<-chan *waBinary.Nod
 		"xmlns": query.Namespace,
 		"type":  string(query.Type),
 	}
+	if query.SMaxID != "" {
+		attrs["smax_id"] = query.SMaxID
+	}
 	if !query.To.IsEmpty() {
 		attrs["to"] = query.To
 	}

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/retry.go

@@ -157,8 +157,7 @@ func (cli *Client) handleRetryReceipt(ctx context.Context, receipt *events.Recei
 		signalSKDMessage, err := builder.Create(ctx, senderKeyName)
 		if err != nil {
 			cli.Log.Warnf("Failed to create sender key distribution message to include in retry of %s in %s to %s: %v", messageID, receipt.Chat, receipt.Sender, err)
-		}
-		if msg.wa != nil {
+		} else if msg.wa != nil {
 			msg.wa.SenderKeyDistributionMessage = &waE2E.SenderKeyDistributionMessage{
 				GroupID:                             proto.String(receipt.Chat.String()),
 				AxolotlSenderKeyDistributionMessage: signalSKDMessage.Serialize(),
@@ -252,7 +251,7 @@ func (cli *Client) handleRetryReceipt(ctx context.Context, receipt *events.Recei
 				encryptionIdentity = lidForPN
 			}
 		}
-		encrypted, includeDeviceIdentity, err = cli.encryptMessageForDevice(ctx, plaintext, encryptionIdentity, bundle, encAttrs)
+		encrypted, includeDeviceIdentity, err = cli.encryptMessageForDevice(ctx, plaintext, encryptionIdentity, bundle, encAttrs, nil)
 	} else {
 		encrypted, err = cli.encryptMessageForDeviceV3(ctx, &waMsgTransport.MessageTransport_Payload{
 			ApplicationPayload: &waCommon.SubProtocol{

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/send.go

@@ -29,7 +29,7 @@ import (
 	"google.golang.org/protobuf/proto"
 
 	waBinary "go.mau.fi/whatsmeow/binary"
-	"go.mau.fi/whatsmeow/proto/waBotMetadata"
+	"go.mau.fi/whatsmeow/proto/waAICommon"
 	"go.mau.fi/whatsmeow/proto/waCommon"
 	"go.mau.fi/whatsmeow/proto/waE2E"
 	"go.mau.fi/whatsmeow/types"
@@ -74,7 +74,8 @@ func GenerateMessageID() types.MessageID {
 }
 
 type MessageDebugTimings struct {
-	Queue time.Duration
+	LIDFetch time.Duration
+	Queue    time.Duration
 
 	Marshal         time.Duration
 	GetParticipants time.Duration
@@ -88,6 +89,9 @@ type MessageDebugTimings struct {
 }
 
 func (mdt MessageDebugTimings) MarshalZerologObject(evt *zerolog.Event) {
+	if mdt.LIDFetch != 0 {
+		evt.Dur("lid_fetch", mdt.LIDFetch)
+	}
 	evt.Dur("queue", mdt.Queue)
 	evt.Dur("marshal", mdt.Marshal)
 	if mdt.GetParticipants != 0 {
@@ -149,6 +153,8 @@ type SendRequestExtra struct {
 	MediaHandle string
 
 	Meta *types.MsgMetaInfo
+	// use this only if you know what you are doing
+	AdditionalNodes *[]waBinary.Node
 }
 
 // SendMessage sends the given message.
@@ -238,7 +244,7 @@ func (cli *Client) SendMessage(ctx context.Context, to types.JID, message *waE2E
 
 	if isBotMode {
 		if message.MessageContextInfo.BotMetadata == nil {
-			message.MessageContextInfo.BotMetadata = &waBotMetadata.BotMetadata{
+			message.MessageContextInfo.BotMetadata = &waAICommon.BotMetadata{
 				PersonaID: proto.String("867051314767696$760019659443059"),
 			}
 		}
@@ -272,7 +278,11 @@ func (cli *Client) SendMessage(ctx context.Context, to types.JID, message *waE2E
 				return
 			}
 
-			participantNodes, _ := cli.encryptMessageForDevices(ctx, []types.JID{req.InlineBotJID}, resp.ID, messagePlaintext, nil, waBinary.Attrs{})
+			var participantNodes []waBinary.Node
+			participantNodes, _, err = cli.encryptMessageForDevices(ctx, []types.JID{req.InlineBotJID}, resp.ID, messagePlaintext, nil, waBinary.Attrs{})
+			if err != nil {
+				return
+			}
 			extraParams.botNode = &waBinary.Node{
 				Tag:     "bot",
 				Attrs:   nil,
@@ -311,6 +321,28 @@ func (cli *Client) SendMessage(ctx context.Context, to types.JID, message *waE2E
 		resp.DebugTimings.GetParticipants = time.Since(start)
 	} else if to.Server == types.HiddenUserServer {
 		ownID = cli.getOwnLID()
+	} else if to.Server == types.DefaultUserServer && cli.Store.LIDMigrationTimestamp > 0 {
+		start := time.Now()
+		var toLID types.JID
+		toLID, err = cli.Store.LIDs.GetLIDForPN(ctx, to)
+		if err != nil {
+			err = fmt.Errorf("failed to get LID for PN %s: %w", to, err)
+			return
+		} else if toLID.IsEmpty() {
+			var info map[types.JID]types.UserInfo
+			info, err = cli.GetUserInfo([]types.JID{to})
+			if err != nil {
+				err = fmt.Errorf("failed to get user info for %s to fill LID cache: %w", to, err)
+				return
+			} else if toLID = info[to].LID; toLID.IsEmpty() {
+				err = fmt.Errorf("no LID found for %s from server", to)
+				return
+			}
+		}
+		resp.DebugTimings.LIDFetch = time.Since(start)
+		cli.Log.Debugf("Replacing SendMessage destination with LID as migration timestamp is set %s -> %s", to, toLID)
+		to = toLID
+		ownID = cli.getOwnLID()
 	}
 	if req.Meta != nil {
 		extraParams.metaNode = &waBinary.Node{
@@ -326,6 +358,10 @@ func (cli *Client) SendMessage(ctx context.Context, to types.JID, message *waE2E
 		}
 	}
 
+	if req.AdditionalNodes != nil {
+		extraParams.additionalNodes = req.AdditionalNodes
+	}
+
 	resp.Sender = ownID
 
 	start := time.Now()
@@ -582,6 +618,9 @@ func ParseDisappearingTimerString(val string) (time.Duration, bool) {
 func (cli *Client) SetDisappearingTimer(chat types.JID, timer time.Duration, settingTS time.Time) (err error) {
 	switch chat.Server {
 	case types.DefaultUserServer, types.HiddenUserServer:
+		if settingTS.IsZero() {
+			settingTS = time.Now()
+		}
 		_, err = cli.SendMessage(context.TODO(), chat, &waE2E.Message{
 			ProtocolMessage: &waE2E.ProtocolMessage{
 				Type:                      waE2E.ProtocolMessage_EPHEMERAL_SETTING.Enum(),
@@ -673,9 +712,10 @@ func (cli *Client) sendNewsletter(
 }
 
 type nodeExtraParams struct {
-	botNode        *waBinary.Node
-	metaNode       *waBinary.Node
-	addressingMode types.AddressingMode
+	botNode         *waBinary.Node
+	metaNode        *waBinary.Node
+	additionalNodes *[]waBinary.Node
+	addressingMode  types.AddressingMode
 }
 
 func (cli *Client) sendGroup(
@@ -1001,7 +1041,7 @@ func (cli *Client) preparePeerMessageNode(
 		}
 	}
 	start = time.Now()
-	encrypted, isPreKey, err := cli.encryptMessageForDevice(ctx, plaintext, encryptionIdentity, nil, nil)
+	encrypted, isPreKey, err := cli.encryptMessageForDevice(ctx, plaintext, encryptionIdentity, nil, nil, nil)
 	timings.PeerEncrypt = time.Since(start)
 	if err != nil {
 		return nil, fmt.Errorf("failed to encrypt peer message for %s: %v", to, err)
@@ -1047,6 +1087,9 @@ func (cli *Client) getMessageContent(
 	if extraParams.metaNode != nil {
 		content = append(content, *extraParams.metaNode)
 	}
+	if extraParams.additionalNodes != nil {
+		content = append(content, *extraParams.additionalNodes...)
+	}
 
 	if buttonType := getButtonTypeFromMessage(message); buttonType != "" {
 		content = append(content, waBinary.Node{
@@ -1101,10 +1144,13 @@ func (cli *Client) prepareMessageNode(
 	}
 
 	start = time.Now()
-	participantNodes, includeIdentity := cli.encryptMessageForDevices(
+	participantNodes, includeIdentity, err := cli.encryptMessageForDevices(
 		ctx, allDevices, id, plaintext, dsmPlaintext, encAttrs,
 	)
 	timings.PeerEncrypt = time.Since(start)
+	if err != nil {
+		return nil, nil, err
+	}
 	participantNode := waBinary.Node{
 		Tag:     "participants",
 		Content: participantNodes,
@@ -1162,11 +1208,43 @@ func (cli *Client) encryptMessageForDevices(
 	id string,
 	msgPlaintext, dsmPlaintext []byte,
 	encAttrs waBinary.Attrs,
-) ([]waBinary.Node, bool) {
+) ([]waBinary.Node, bool, error) {
 	ownJID := cli.getOwnID()
 	ownLID := cli.getOwnLID()
 	includeIdentity := false
 	participantNodes := make([]waBinary.Node, 0, len(allDevices))
+
+	var pnDevices []types.JID
+	for _, jid := range allDevices {
+		if jid.Server == types.DefaultUserServer {
+			pnDevices = append(pnDevices, jid)
+		}
+	}
+	lidMappings, err := cli.Store.LIDs.GetManyLIDsForPNs(ctx, pnDevices)
+	if err != nil {
+		return nil, false, fmt.Errorf("failed to fetch LID mappings: %w", err)
+	}
+
+	encryptionIdentities := make(map[types.JID]types.JID, len(allDevices))
+	var sessionAddresses []string
+	for _, jid := range allDevices {
+		encryptionIdentity := jid
+		if jid.Server == types.DefaultUserServer {
+			// TODO query LID from server for missing entries
+			if lidForPN, ok := lidMappings[jid]; ok && !lidForPN.IsEmpty() {
+				cli.migrateSessionStore(ctx, jid, lidForPN)
+				encryptionIdentity = lidForPN
+			}
+		}
+		encryptionIdentities[jid] = encryptionIdentity
+		sessionAddresses = append(sessionAddresses, encryptionIdentity.SignalAddress().String())
+	}
+
+	existingSessions, err := cli.Store.Sessions.HasManySessions(ctx, sessionAddresses)
+	if err != nil {
+		return nil, false, fmt.Errorf("failed to check which sessions exist: %w", err)
+	}
+
 	var retryDevices, retryEncryptionIdentities []types.JID
 	for _, jid := range allDevices {
 		plaintext := msgPlaintext
@@ -1176,19 +1254,10 @@ func (cli *Client) encryptMessageForDevices(
 			}
 			plaintext = dsmPlaintext
 		}
-		encryptionIdentity := jid
-		if jid.Server == types.DefaultUserServer {
-			lidForPN, err := cli.Store.LIDs.GetLIDForPN(ctx, jid)
-			if err != nil {
-				cli.Log.Warnf("Failed to get LID for %s: %v", jid, err)
-			} else if !lidForPN.IsEmpty() {
-				cli.migrateSessionStore(ctx, jid, lidForPN)
-				encryptionIdentity = lidForPN
-			}
-		}
+		encryptionIdentity := encryptionIdentities[jid]
 
 		encrypted, isPreKey, err := cli.encryptMessageForDeviceAndWrap(
-			ctx, plaintext, jid, encryptionIdentity, nil, encAttrs,
+			ctx, plaintext, jid, encryptionIdentity, nil, encAttrs, existingSessions,
 		)
 		if errors.Is(err, ErrNoSession) {
 			retryDevices = append(retryDevices, jid)
@@ -1197,6 +1266,9 @@ func (cli *Client) encryptMessageForDevices(
 		} else if err != nil {
 			// TODO return these errors if it's a fatal one (like context cancellation or database)
 			cli.Log.Warnf("Failed to encrypt %s for %s: %v", id, jid, err)
+			if ctx.Err() != nil {
+				return nil, false, err
+			}
 			continue
 		}
 
@@ -1221,7 +1293,7 @@ func (cli *Client) encryptMessageForDevices(
 					plaintext = dsmPlaintext
 				}
 				encrypted, isPreKey, err := cli.encryptMessageForDeviceAndWrap(
-					ctx, plaintext, jid, retryEncryptionIdentities[i], resp.bundle, encAttrs,
+					ctx, plaintext, jid, retryEncryptionIdentities[i], resp.bundle, encAttrs, nil,
 				)
 				if err != nil {
 					// TODO return these errors if it's a fatal one (like context cancellation or database)
@@ -1235,7 +1307,7 @@ func (cli *Client) encryptMessageForDevices(
 			}
 		}
 	}
-	return participantNodes, includeIdentity
+	return participantNodes, includeIdentity, nil
 }
 
 func (cli *Client) encryptMessageForDeviceAndWrap(
@@ -1245,9 +1317,10 @@ func (cli *Client) encryptMessageForDeviceAndWrap(
 	encryptionIdentity types.JID,
 	bundle *prekey.Bundle,
 	encAttrs waBinary.Attrs,
+	existingSessions map[string]bool,
 ) (*waBinary.Node, bool, error) {
 	node, includeDeviceIdentity, err := cli.encryptMessageForDevice(
-		ctx, plaintext, encryptionIdentity, bundle, encAttrs,
+		ctx, plaintext, encryptionIdentity, bundle, encAttrs, existingSessions,
 	)
 	if err != nil {
 		return nil, false, err
@@ -1271,6 +1344,7 @@ func (cli *Client) encryptMessageForDevice(
 	to types.JID,
 	bundle *prekey.Bundle,
 	extraAttrs waBinary.Attrs,
+	existingSessions map[string]bool,
 ) (*waBinary.Node, bool, error) {
 	builder := session.NewBuilderFromSignal(cli.Store, to.SignalAddress(), pbSerializer)
 	if bundle != nil {
@@ -1287,10 +1361,18 @@ func (cli *Client) encryptMessageForDevice(
 		if err != nil {
 			return nil, false, fmt.Errorf("failed to process prekey bundle: %w", err)
 		}
-	} else if contains, err := cli.Store.ContainsSession(ctx, to.SignalAddress()); err != nil {
-		return nil, false, err
-	} else if !contains {
-		return nil, false, fmt.Errorf("%w with %s", ErrNoSession, to.SignalAddress().String())
+	} else {
+		sessionExists, checked := existingSessions[to.SignalAddress().String()]
+		if !checked {
+			var err error
+			sessionExists, err = cli.Store.ContainsSession(ctx, to.SignalAddress())
+			if err != nil {
+				return nil, false, err
+			}
+		}
+		if !sessionExists {
+			return nil, false, fmt.Errorf("%w with %s", ErrNoSession, to.SignalAddress().String())
+		}
 	}
 	cipher := session.NewCipher(builder, to.SignalAddress())
 	ciphertext, err := cipher.Encrypt(ctx, padMessage(plaintext))

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/store/clientpayload.go

@@ -76,7 +76,7 @@ func (vc WAVersionContainer) ProtoAppVersion() *waWa6.ClientPayload_UserAgent_Ap
 }
 
 // waVersion is the WhatsApp web client version
-var waVersion = WAVersionContainer{2, 3000, 1026436087}
+var waVersion = WAVersionContainer{2, 3000, 1027949008}
 
 // waVersionHash is the md5 hash of a dot-separated waVersion
 var waVersionHash [16]byte

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/store/noop.go

@@ -68,6 +68,10 @@ func (n *NoopStore) HasSession(ctx context.Context, address string) (bool, error
 	return false, n.Error
 }
 
+func (n *NoopStore) HasManySessions(ctx context.Context, addresses []string) (map[string]bool, error) {
+	return nil, n.Error
+}
+
 func (n *NoopStore) PutSession(ctx context.Context, address string, session []byte) error {
 	return n.Error
 }
@@ -168,6 +172,10 @@ func (n *NoopStore) PutAllContactNames(ctx context.Context, contacts []ContactEn
 	return n.Error
 }
 
+func (n *NoopStore) PutManyRedactedPhones(ctx context.Context, entries []RedactedPhoneEntry) error {
+	return n.Error
+}
+
 func (n *NoopStore) GetContact(ctx context.Context, user types.JID) (types.ContactInfo, error) {
 	return types.ContactInfo{}, n.Error
 }
@@ -244,6 +252,10 @@ func (n *NoopStore) GetLIDForPN(ctx context.Context, pn types.JID) (types.JID, e
 	return types.JID{}, n.Error
 }
 
+func (n *NoopStore) GetManyLIDsForPNs(ctx context.Context, pns []types.JID) (map[types.JID]types.JID, error) {
+	return nil, n.Error
+}
+
 func (n *NoopStore) GetPNForLID(ctx context.Context, lid types.JID) (types.JID, error) {
 	return types.JID{}, n.Error
 }

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/store/sqlstore/lidmap.go

@@ -13,10 +13,12 @@ import (
 	"errors"
 	"fmt"
 	"slices"
+	"strings"
 	"sync"
 
 	"github.com/rs/zerolog"
 	"go.mau.fi/util/dbutil"
+	"go.mau.fi/util/exslices"
 
 	"go.mau.fi/whatsmeow/store"
 	"go.mau.fi/whatsmeow/types"
@@ -61,18 +63,30 @@ func (s *CachedLIDMap) FillCache(ctx context.Context) error {
 	if err != nil {
 		return err
 	}
-	defer rows.Close()
+	err = s.scanManyLids(rows, nil)
+	s.cacheFilled = err == nil
+	return err
+}
+
+func (s *CachedLIDMap) scanManyLids(rows dbutil.Rows, fn func(lid, pn string)) error {
+	if fn == nil {
+		fn = func(lid, pn string) {}
+	}
 	for rows.Next() {
 		var lid, pn string
-		err = rows.Scan(&lid, &pn)
+		err := rows.Scan(&lid, &pn)
 		if err != nil {
 			return err
 		}
 		s.pnToLIDCache[pn] = lid
 		s.lidToPNCache[lid] = pn
+		fn(lid, pn)
 	}
-	s.cacheFilled = true
-	return nil
+	err := rows.Close()
+	if err != nil {
+		return err
+	}
+	return rows.Err()
 }
 
 func (s *CachedLIDMap) getLIDMapping(ctx context.Context, source types.JID, targetServer, query string, sourceToTarget, targetToSource map[string]string) (types.JID, error) {
@@ -122,6 +136,69 @@ func (s *CachedLIDMap) GetPNForLID(ctx context.Context, lid types.JID) (types.JI
 	)
 }
 
+func (s *CachedLIDMap) GetManyLIDsForPNs(ctx context.Context, pns []types.JID) (map[types.JID]types.JID, error) {
+	if len(pns) == 0 {
+		return nil, nil
+	}
+
+	result := make(map[types.JID]types.JID, len(pns))
+
+	s.lidCacheLock.RLock()
+	missingPNs := make([]string, 0, len(pns))
+	missingPNDevices := make(map[string][]types.JID)
+	for _, pn := range pns {
+		if pn.Server != types.DefaultUserServer {
+			continue
+		}
+		if lidUser, ok := s.pnToLIDCache[pn.User]; ok && lidUser != "" {
+			result[pn] = types.JID{User: lidUser, Device: pn.Device, Server: types.HiddenUserServer}
+		} else if !s.cacheFilled {
+			missingPNs = append(missingPNs, pn.User)
+			missingPNDevices[pn.User] = append(missingPNDevices[pn.User], pn)
+		}
+	}
+	s.lidCacheLock.RUnlock()
+
+	if len(missingPNs) == 0 {
+		return result, nil
+	}
+
+	s.lidCacheLock.Lock()
+	defer s.lidCacheLock.Unlock()
+
+	var rows dbutil.Rows
+	var err error
+	if s.db.Dialect == dbutil.Postgres && PostgresArrayWrapper != nil {
+		rows, err = s.db.Query(
+			ctx,
+			`SELECT lid, pn FROM whatsmeow_lid_map WHERE pn = ANY($1)`,
+			PostgresArrayWrapper(missingPNs),
+		)
+	} else {
+		placeholders := make([]string, len(missingPNs))
+		for i := range missingPNs {
+			placeholders[i] = fmt.Sprintf("$%d", i+1)
+		}
+		rows, err = s.db.Query(
+			ctx,
+			fmt.Sprintf(`SELECT lid, pn FROM whatsmeow_lid_map WHERE pn IN (%s)`, strings.Join(placeholders, ",")),
+			exslices.CastToAny(missingPNs)...,
+		)
+	}
+	if err != nil {
+		return nil, err
+	}
+	err = s.scanManyLids(rows, func(lid, pn string) {
+		for _, dev := range missingPNDevices[pn] {
+			lidDev := dev
+			lidDev.Server = types.HiddenUserServer
+			lidDev.User = lid
+			result[dev] = lidDev.ToNonAD()
+		}
+	})
+	return result, err
+}
+
 func (s *CachedLIDMap) PutLIDMapping(ctx context.Context, lid, pn types.JID) error {
 	if lid.Server != types.HiddenUserServer || pn.Server != types.DefaultUserServer {
 		return fmt.Errorf("invalid PutLIDMapping call %s/%s", lid, pn)
@@ -154,6 +231,7 @@ func (s *CachedLIDMap) PutManyLIDMappings(ctx context.Context, mappings []store.
 		}
 		return false
 	})
+	mappings = exslices.DeduplicateUnsortedOverwrite(mappings)
 	if len(mappings) == 0 {
 		return nil
 	}