Binary, hexadecimal, and bit operations.

/** Read an IPv4 address as an unsigned, network-byte-order 32-bit value. */
export function ipv4ToUint32(address: string): number {
	const parts = address.split('.');
	const octets = parts.map(Number);
	if (
		octets.length !== 4 ||
		octets.some((octet, index) => !/^\d+$/.test(parts[index] ?? '') || octet < 0 || octet > 255)
	) {
		throw new RangeError('address must contain four decimal octets from 0 to 255');
	}
	const bytes = new Uint8Array(octets);
	return new DataView(bytes.buffer).getUint32(0, false);
}

/** Return the canonical network address for an IPv4 address and prefix. */
export function networkAddress(address: string, prefixLength: number): string {
	if (!Number.isInteger(prefixLength) || prefixLength < 0 || prefixLength > 32) {
		throw new RangeError('prefix length must be an integer from 0 to 32');
	}

	const ip = ipv4ToUint32(address);
	// Avoid JavaScript's shift-count modulo 32 behavior for the /0 boundary.
	const mask = prefixLength === 0 ? 0 : (0xffff_ffff << (32 - prefixLength)) >>> 0;
	// Number bitwise operators coerce to signed int32; >>> 0 restores the uint32 value.
	const network = (ip & mask) >>> 0;
	const bytes = new ArrayBuffer(4);
	new DataView(bytes).setUint32(0, network, false);
	return Array.from(new Uint8Array(bytes)).join('.');
}

function assertUint32(value: number): void {
	if (!Number.isInteger(value) || value < 0 || value > 0xffff_ffff) {
		throw new RangeError('flag values must be unsigned 32-bit integers');
	}
}

function hasFlag(value: number, flag: number): boolean {
	assertUint32(value);
	assertUint32(flag);
	return (value & flag) !== 0;
}

function setFlag(value: number, flag: number): number {
	assertUint32(value);
	assertUint32(flag);
	return (value | flag) >>> 0;
}

function clearFlag(value: number, flag: number): number {
	assertUint32(value);
	assertUint32(flag);
	return (value & ~flag) >>> 0;
}

function toggleFlag(value: number, flag: number): number {
	assertUint32(value);
	assertUint32(flag);
	return (value ^ flag) >>> 0;
}

const address = '192.168.34.77';
console.log(`${address}/20 → ${networkAddress(address, 20)}`);
console.log(`0x25 has 0x04: ${hasFlag(0x25, 0x04)}`);
console.log(`set 0x08: 0x${setFlag(0x25, 0x08).toString(16)}`);
console.log(`clear 0x04: 0x${clearFlag(0x25, 0x04).toString(16)}`);
console.log(`toggle 0x04: 0x${toggleFlag(0x25, 0x04).toString(16)}`);

package main

import (
	"fmt"
	"net/netip"
)

func networkAddress(address string, prefixLength int) (string, error) {
	ip, err := netip.ParseAddr(address)
	if err != nil || !ip.Is4() {
		return "", fmt.Errorf("address must be a valid IPv4 address")
	}
	if prefixLength < 0 || prefixLength > 32 {
		return "", fmt.Errorf("prefix length must be from 0 to 32")
	}

	prefix := netip.PrefixFrom(ip, prefixLength).Masked()
	return prefix.Addr().String(), nil
}

func hasFlag(value, flag uint32) bool {
	return value&flag != 0
}

func setFlag(value, flag uint32) uint32 {
	return value | flag
}

func clearFlag(value, flag uint32) uint32 {
	return value &^ flag
}

func toggleFlag(value, flag uint32) uint32 {
	return value ^ flag
}

func main() {
	address := "192.168.34.77"
	network, err := networkAddress(address, 20)
	if err != nil {
		panic(err)
	}
	fmt.Printf("%s/20 → %s\n", address, network)

	flags := uint32(0x25)
	fmt.Printf("0x25 has 0x04: %t\n", hasFlag(flags, 0x04))
	fmt.Printf("set 0x08: 0x%02x\n", setFlag(flags, 0x08))
	fmt.Printf("clear 0x04: 0x%02x\n", clearFlag(flags, 0x04))
	fmt.Printf("toggle 0x04: 0x%02x\n", toggleFlag(flags, 0x04))
}