effect 4.0.0-rc.112 → 4.0.0-rc.113

package/dist/unstable/net/NetAddress.js

@@ -0,0 +1,956 @@
+/**
+ * Pure, platform-neutral values for MAC, IP, internet socket, and Unix path addresses.
+ *
+ * @since 4.0.0
+ */
+import * as Data from "../../Data.js";
+import * as Equal from "../../Equal.js";
+import { dual } from "../../Function.js";
+import * as Hash from "../../Hash.js";
+import { NodeInspectSymbol } from "../../Inspectable.js";
+import * as Option from "../../Option.js";
+import { hasProperty } from "../../Predicate.js";
+import * as Result from "../../Result.js";
+const TypeId = "~effect/net/NetAddress";
+const getBytes = self => self.bytes;
+/**
+ * A checked network-address operation failure retaining the address or supplied input.
+ *
+ * **Details**
+ *
+ * Address-based operations retain the address value. Parsing and numeric
+ * construction retain the supplied string or array. Composed operations forward
+ * errors from the failing operation unchanged. Failures from external operations
+ * retain the original exception in `cause` when available.
+ *
+ * @category errors
+ * @since 4.0.0
+ */
+export class NetAddressError extends /*#__PURE__*/Data.TaggedError("NetAddressError") {}
+const isAddress = u => hasProperty(u, TypeId);
+/**
+ * Returns `true` when a value is an IPv4 address.
+ *
+ * @category guards
+ * @since 4.0.0
+ */
+export const isIpv4Address = u => isAddress(u) && u._tag === "Ipv4Address";
+/**
+ * Returns `true` when a value is an IPv6 address.
+ *
+ * @category guards
+ * @since 4.0.0
+ */
+export const isIpv6Address = u => isAddress(u) && u._tag === "Ipv6Address";
+/**
+ * Returns `true` when a value is an IPv4 or IPv6 address.
+ *
+ * @category guards
+ * @since 4.0.0
+ */
+export const isIpAddress = u => isIpv4Address(u) || isIpv6Address(u);
+/**
+ * Returns the bit width of an IP address.
+ *
+ * @category getters
+ * @since 4.0.0
+ */
+export const width = address => isIpv4Address(address) ? 32 : 128;
+/**
+ * Returns `true` when a value is a MAC address.
+ *
+ * @category guards
+ * @since 4.0.0
+ */
+export const isMacAddress = u => isAddress(u) && u._tag === "MacAddress";
+/**
+ * Returns `true` when a value is a resolved IPv4 internet address.
+ *
+ * @category guards
+ * @since 4.0.0
+ */
+export const isInetAddressV4 = u => isAddress(u) && u._tag === "InetAddressV4";
+/**
+ * Returns `true` when a value is a resolved IPv6 internet address.
+ *
+ * @category guards
+ * @since 4.0.0
+ */
+export const isInetAddressV6 = u => isAddress(u) && u._tag === "InetAddressV6";
+/**
+ * Returns `true` when a value is a resolved internet address.
+ *
+ * @category guards
+ * @since 4.0.0
+ */
+export const isInetAddress = u => isInetAddressV4(u) || isInetAddressV6(u);
+/**
+ * Returns `true` when a value is a Unix-domain filesystem address.
+ *
+ * @category guards
+ * @since 4.0.0
+ */
+export const isUnixPathAddress = u => isAddress(u) && u._tag === "UnixPathAddress";
+/**
+ * Returns `true` when a value is a portable concrete socket address.
+ *
+ * @category guards
+ * @since 4.0.0
+ */
+export const isSocketAddress = u => isInetAddress(u) || isUnixPathAddress(u);
+const Ipv4Proto = {
+  _tag: "Ipv4Address",
+  [TypeId]: TypeId,
+  [Equal.symbol](that) {
+    return isIpv4Address(that) && bytesEqual(getBytes(this), getBytes(that));
+  },
+  [Hash.symbol]() {
+    return hashBytes("Ipv4Address", getBytes(this));
+  },
+  toString() {
+    return formatIp(this);
+  },
+  toJSON() {
+    return this.toString();
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+};
+const Ipv6Proto = {
+  _tag: "Ipv6Address",
+  [TypeId]: TypeId,
+  [Equal.symbol](that) {
+    return isIpv6Address(that) && bytesEqual(getBytes(this), getBytes(that));
+  },
+  [Hash.symbol]() {
+    return hashBytes("Ipv6Address", getBytes(this));
+  },
+  toString() {
+    return formatIp(this);
+  },
+  toJSON() {
+    return this.toString();
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+};
+const MacProto = {
+  _tag: "MacAddress",
+  [TypeId]: TypeId,
+  [Equal.symbol](that) {
+    return isMacAddress(that) && bytesEqual(getBytes(this), getBytes(that));
+  },
+  [Hash.symbol]() {
+    return hashBytes("MacAddress", getBytes(this));
+  },
+  toString() {
+    return formatMacAddress(this);
+  },
+  toJSON() {
+    return this.toString();
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+};
+const bytesEqual = (self, that) => {
+  if (self.length !== that.length) return false;
+  for (let index = 0; index < self.length; index++) {
+    if (self[index] !== that[index]) return false;
+  }
+  return true;
+};
+const hashBytes = (tag, bytes) => {
+  return Hash.combine(Hash.string(tag), Hash.array(bytes));
+};
+const makeIpv4 = bytes => {
+  const self = Object.assign(Object.create(Ipv4Proto), {
+    bytes: new Uint8Array(bytes)
+  });
+  return Object.freeze(self);
+};
+const makeIpv6 = bytes => {
+  const self = Object.assign(Object.create(Ipv6Proto), {
+    bytes: new Uint8Array(bytes)
+  });
+  return Object.freeze(self);
+};
+const makeMac = bytes => {
+  const self = Object.assign(Object.create(MacProto), {
+    bytes: new Uint8Array(bytes)
+  });
+  return Object.freeze(self);
+};
+/**
+ * Creates an IPv4 address from trusted network-order bytes without validation.
+ *
+ * @category unsafe
+ * @since 4.0.0
+ */
+export const ipv4FromBytesUnsafe = bytes => makeIpv4(bytes);
+/**
+ * Creates an IPv6 address from trusted network-order bytes without validation.
+ *
+ * @category unsafe
+ * @since 4.0.0
+ */
+export const ipv6FromBytesUnsafe = bytes => makeIpv6(bytes);
+/**
+ * The IPv4 loopback address `127.0.0.1`.
+ *
+ * @category constants
+ * @since 4.0.0
+ */
+export const ipv4Loopback = /*#__PURE__*/makeIpv4(/*#__PURE__*/new Uint8Array([127, 0, 0, 1]));
+/**
+ * The IPv6 loopback address `::1`.
+ *
+ * @category constants
+ * @since 4.0.0
+ */
+export const ipv6Loopback = /*#__PURE__*/makeIpv6(/*#__PURE__*/new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]));
+/**
+ * The unspecified IPv4 address `0.0.0.0`.
+ *
+ * @category constants
+ * @since 4.0.0
+ */
+export const ipv4Unspecified = /*#__PURE__*/makeIpv4(/*#__PURE__*/new Uint8Array(4));
+/**
+ * The unspecified IPv6 address `::`.
+ *
+ * @category constants
+ * @since 4.0.0
+ */
+export const ipv6Unspecified = /*#__PURE__*/makeIpv6(/*#__PURE__*/new Uint8Array(16));
+/**
+ * The IPv4 broadcast address `255.255.255.255`.
+ *
+ * @category constants
+ * @since 4.0.0
+ */
+export const ipv4Broadcast = /*#__PURE__*/makeIpv4(/*#__PURE__*/new Uint8Array([255, 255, 255, 255]));
+const addressError = (input, message) => Result.fail(new NetAddressError({
+  input,
+  message
+}));
+/**
+ * Creates an IPv4 address from four checked octets.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const ipv4FromOctets = octets => {
+  if (!octets.every(n => Number.isInteger(n) && n >= 0 && n <= 255)) {
+    return addressError(octets, "octets must be integers from 0 through 255");
+  }
+  return Result.succeed(makeIpv4(new Uint8Array(octets)));
+};
+/**
+ * Creates an IPv6 address from eight checked 16-bit segments.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const ipv6FromSegments = segments => {
+  if (!segments.every(n => Number.isInteger(n) && n >= 0 && n <= 0xffff)) {
+    return addressError(segments, "segments must be integers from 0 through 65535");
+  }
+  const bytes = new Uint8Array(16);
+  for (let index = 0; index < 8; index++) {
+    bytes[index * 2] = segments[index] >> 8;
+    bytes[index * 2 + 1] = segments[index];
+  }
+  return Result.succeed(makeIpv6(bytes));
+};
+/**
+ * Creates a MAC address from six checked octets.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const macAddressFromOctets = octets => {
+  if (!octets.every(n => Number.isInteger(n) && n >= 0 && n <= 255)) {
+    return addressError(octets, "octets must be integers from 0 through 255");
+  }
+  return Result.succeed(makeMac(new Uint8Array(octets)));
+};
+/**
+ * Parses a colon-separated MAC address containing six two-digit hexadecimal octets.
+ *
+ * @category decoding
+ * @since 4.0.0
+ */
+export const macAddressFromString = input => {
+  if (!/^(?:[0-9a-fA-F]{2}:){5}[0-9a-fA-F]{2}$/.test(input)) {
+    return addressError(input, "expected six two-digit hexadecimal octets separated by colons");
+  }
+  return Result.succeed(makeMac(new Uint8Array(input.split(":").map(part => Number.parseInt(part, 16)))));
+};
+/**
+ * Parses a trusted colon-separated MAC address, throwing on failure.
+ *
+ * @category unsafe
+ * @since 4.0.0
+ */
+export const macAddressFromStringUnsafe = input => Result.getOrThrow(macAddressFromString(input));
+/**
+ * Parses a strict dotted-decimal IPv4 address.
+ *
+ * **Details**
+ *
+ * Multi-digit octets with a leading zero are rejected to avoid octal ambiguity.
+ *
+ * @category decoding
+ * @since 4.0.0
+ */
+export const ipv4FromString = input => {
+  const parts = input.split(".");
+  if (parts.length !== 4 || parts.some(part => !/^\d{1,3}$/.test(part))) {
+    return addressError(input, "expected exactly four decimal octets");
+  }
+  if (parts.some(part => part.length > 1 && part[0] === "0")) {
+    return addressError(input, "leading zeroes are not allowed");
+  }
+  const octets = parts.map(Number);
+  if (octets.some(part => part > 255)) {
+    return addressError(input, "octets must be at most 255");
+  }
+  return ipv4FromOctets([octets[0], octets[1], octets[2], octets[3]]);
+};
+const parseIpv6Segments = input => {
+  if (input.includes("[") || input.includes("]") || input.includes("%")) {
+    return addressError(input, "brackets and zone identifiers are not valid in a bare IPv6 address");
+  }
+  const halves = input.split("::");
+  if (halves.length > 2) return addressError(input, "only one compression marker is allowed");
+  const head = halves[0] === "" ? [] : halves[0].split(":");
+  const tail = halves.length === 2 && halves[1] !== "" ? halves[1].split(":") : [];
+  if (head.some(part => part === "") || tail.some(part => part === "")) {
+    return addressError(input, "empty segments are only valid in the compression marker");
+  }
+  const trailing = tail.length > 0 ? tail[tail.length - 1] : head.length > 0 ? head[head.length - 1] : "";
+  let embedded;
+  if (trailing.includes(".")) {
+    if (halves.length === 2 && tail.length === 0) {
+      return addressError(input, "embedded IPv4 syntax must be trailing");
+    }
+    const parsed = Result.map(ipv4FromString(trailing), address => {
+      const octets = ipv4ToOctets(address);
+      return [octets[0] * 256 + octets[1], octets[2] * 256 + octets[3]];
+    });
+    if (Result.isFailure(parsed)) return parsed;
+    embedded = parsed.success;
+    if (tail.length > 0) tail.pop();else head.pop();
+  }
+  const explicit = head.length + tail.length + (embedded ? 2 : 0);
+  if (halves.length === 1 ? explicit !== 8 : explicit >= 8) {
+    return addressError(input, halves.length === 1 ? "expected eight segments" : "compression must replace at least one segment");
+  }
+  const parse = part => /^[0-9a-fA-F]{1,4}$/.test(part) ? Number.parseInt(part, 16) : undefined;
+  const parsedHead = head.map(parse);
+  const parsedTail = tail.map(parse);
+  if (parsedHead.some(part => part === undefined) || parsedTail.some(part => part === undefined)) {
+    return addressError(input, "segments must contain one through four hexadecimal digits");
+  }
+  return Result.succeed([...parsedHead, ...Array(8 - explicit).fill(0), ...parsedTail, ...(embedded ?? [])]);
+};
+/**
+ * Parses an IPv6 address with optional compression and trailing embedded IPv4.
+ *
+ * @category decoding
+ * @since 4.0.0
+ */
+export const ipv6FromString = input => {
+  return Result.flatMap(parseIpv6Segments(input), segments => ipv6FromSegments(segments));
+};
+/**
+ * Parses a bare numeric IPv4 or IPv6 address.
+ *
+ * @category decoding
+ * @since 4.0.0
+ */
+export const ipFromString = input => {
+  const result = input.includes(":") ? ipv6FromString(input) : ipv4FromString(input);
+  return result;
+};
+/**
+ * Parses a trusted bare numeric IPv4 or IPv6 address, throwing on failure.
+ *
+ * @category unsafe
+ * @since 4.0.0
+ */
+export const ipFromStringUnsafe = input => Result.getOrThrow(ipFromString(input));
+/**
+ * Returns the four numeric octets of an IPv4 address in a fresh tuple.
+ *
+ * @category getters
+ * @since 4.0.0
+ */
+export const ipv4ToOctets = self => {
+  const bytes = getBytes(self);
+  return [bytes[0], bytes[1], bytes[2], bytes[3]];
+};
+/**
+ * Returns the eight numeric segments of an IPv6 address in a fresh tuple.
+ *
+ * @category getters
+ * @since 4.0.0
+ */
+export const ipv6ToSegments = self => {
+  const bytes = getBytes(self);
+  const output = Array(8);
+  for (let index = 0; index < 8; index++) {
+    output[index] = bytes[index * 2] * 256 + bytes[index * 2 + 1];
+  }
+  return output;
+};
+/**
+ * Returns the sixteen numeric octets of an IPv6 address in a fresh array.
+ *
+ * @category getters
+ * @since 4.0.0
+ */
+export const ipv6ToOctets = self => Array.from(getBytes(self));
+/**
+ * Returns the six numeric octets of a MAC address in a fresh tuple.
+ *
+ * @category getters
+ * @since 4.0.0
+ */
+export const macAddressToOctets = self => {
+  const bytes = getBytes(self);
+  return [bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5]];
+};
+/**
+ * Formats a MAC address as six lowercase hexadecimal octets separated by colons.
+ *
+ * @category encoding
+ * @since 4.0.0
+ */
+export const formatMacAddress = self => Array.from(getBytes(self), byte => byte.toString(16).padStart(2, "0")).join(":");
+/**
+ * Returns `true` when the MAC address is the all-ones broadcast address.
+ *
+ * @category predicates
+ * @since 4.0.0
+ */
+export const isMacBroadcast = self => getBytes(self).every(byte => byte === 0xff);
+/**
+ * Returns `true` when the MAC address has the IEEE group-address bit set.
+ *
+ * @category predicates
+ * @since 4.0.0
+ */
+export const isMacMulticast = self => (getBytes(self)[0] & 1) !== 0;
+/**
+ * Returns `true` when the MAC address has the IEEE group-address bit clear.
+ *
+ * @category predicates
+ * @since 4.0.0
+ */
+export const isMacUnicast = self => (getBytes(self)[0] & 1) === 0;
+/**
+ * Returns `true` when the MAC address has the IEEE local-administration bit set.
+ *
+ * @category predicates
+ * @since 4.0.0
+ */
+export const isMacLocallyAdministered = self => (getBytes(self)[0] & 2) !== 0;
+/**
+ * Returns `true` when the MAC address has the IEEE local-administration bit clear.
+ *
+ * @category predicates
+ * @since 4.0.0
+ */
+export const isMacUniversallyAdministered = self => (getBytes(self)[0] & 2) === 0;
+/**
+ * Folds an IP address by its numeric version.
+ *
+ * @category pattern matching
+ * @since 4.0.0
+ */
+export const match = /*#__PURE__*/dual(2, (self, options) => isIpv4Address(self) ? options.onIpv4(self) : options.onIpv6(self));
+/**
+ * Formats an IP address in canonical numeric form.
+ *
+ * @category encoding
+ * @since 4.0.0
+ */
+export const formatIp = self => {
+  if (isIpv4Address(self)) return ipv4ToOctets(self).join(".");
+  const segments = ipv6ToSegments(self);
+  if (isIpv4Mapped(self)) {
+    return `::ffff:${segments[6] >> 8}.${segments[6] & 0xff}.${segments[7] >> 8}.${segments[7] & 0xff}`;
+  }
+  let bestStart = -1;
+  let bestLength = 0;
+  let start = -1;
+  for (let index = 0; index <= 8; index++) {
+    if (index < 8 && segments[index] === 0) {
+      if (start === -1) start = index;
+    } else if (start !== -1) {
+      if (index - start > bestLength) {
+        bestStart = start;
+        bestLength = index - start;
+      }
+      start = -1;
+    }
+  }
+  if (bestLength < 2) return segments.map(segment => segment.toString(16)).join(":");
+  const head = segments.slice(0, bestStart).map(segment => segment.toString(16)).join(":");
+  const tail = segments.slice(bestStart + bestLength).map(segment => segment.toString(16)).join(":");
+  return `${head}::${tail}`;
+};
+/**
+ * Returns `true` for the all-zero address of either IP version.
+ *
+ * @category predicates
+ * @since 4.0.0
+ */
+export const isUnspecified = self => getBytes(self).every(byte => byte === 0);
+/**
+ * Returns `true` for IPv4 `127.0.0.0/8` or IPv6 `::1`.
+ *
+ * @category predicates
+ * @since 4.0.0
+ */
+export const isLoopback = self => {
+  if (isIpv4Address(self)) return getBytes(self)[0] === 127;
+  const bytes = getBytes(self);
+  for (let index = 0; index < 15; index++) {
+    if (bytes[index] !== 0) return false;
+  }
+  return bytes[15] === 1;
+};
+/**
+ * Returns `true` for IPv4 `224.0.0.0/4` or IPv6 `ff00::/8`.
+ *
+ * @category predicates
+ * @since 4.0.0
+ */
+export const isMulticast = self => {
+  if (isIpv4Address(self)) return getBytes(self)[0] >> 4 === 0xe;
+  return getBytes(self)[0] === 0xff;
+};
+/**
+ * Returns `true` for the IPv4 broadcast address `255.255.255.255`.
+ *
+ * @category predicates
+ * @since 4.0.0
+ */
+export const isBroadcast = self => getBytes(self).every(byte => byte === 0xff);
+/**
+ * Returns `true` for IPv4 `169.254.0.0/16` or IPv6 `fe80::/10`.
+ *
+ * @category predicates
+ * @since 4.0.0
+ */
+export const isLinkLocal = self => {
+  if (isIpv4Address(self)) {
+    const bytes = getBytes(self);
+    return bytes[0] === 0xa9 && bytes[1] === 0xfe;
+  }
+  const bytes = getBytes(self);
+  return bytes[0] === 0xfe && (bytes[1] & 0xc0) === 0x80;
+};
+/**
+ * Returns `true` for IPv4 private-use ranges defined by RFC 1918.
+ *
+ * @category predicates
+ * @since 4.0.0
+ */
+export const isPrivate = self => {
+  const bytes = getBytes(self);
+  return bytes[0] === 10 || bytes[0] === 172 && (bytes[1] & 0xf0) === 16 || bytes[0] === 192 && bytes[1] === 168;
+};
+/**
+ * Returns `true` for IPv6 unique-local addresses in `fc00::/7`.
+ *
+ * @category predicates
+ * @since 4.0.0
+ */
+export const isUniqueLocal = self => (getBytes(self)[0] & 0xfe) === 0xfc;
+/**
+ * Returns `true` when an IPv6 address is in the `::ffff:0:0/96` mapped range.
+ *
+ * @category predicates
+ * @since 4.0.0
+ */
+export const isIpv4Mapped = self => {
+  const bytes = getBytes(self);
+  for (let index = 0; index < 10; index++) {
+    if (bytes[index] !== 0) return false;
+  }
+  return bytes[10] === 0xff && bytes[11] === 0xff;
+};
+/**
+ * Converts an IPv4 address to its IPv4-mapped IPv6 representation.
+ *
+ * @category converting
+ * @since 4.0.0
+ */
+export const toIpv4Mapped = self => {
+  const bytes = new Uint8Array(16);
+  bytes[10] = 0xff;
+  bytes[11] = 0xff;
+  bytes.set(getBytes(self), 12);
+  return makeIpv6(bytes);
+};
+/**
+ * Extracts the IPv4 value from an IPv4-mapped IPv6 address.
+ *
+ * @category converting
+ * @since 4.0.0
+ */
+export const fromIpv4Mapped = self => isIpv4Mapped(self) ? Option.some(makeIpv4(getBytes(self).slice(12))) : Option.none();
+/**
+ * Converts an IPv4-mapped IPv6 address to IPv4, leaving all other addresses unchanged.
+ *
+ * @category converting
+ * @since 4.0.0
+ */
+export const toCanonical = self => isIpv6Address(self) ? Option.getOrElse(fromIpv4Mapped(self), () => self) : self;
+const InetV4Proto = {
+  _tag: "InetAddressV4",
+  [TypeId]: TypeId,
+  [Equal.symbol](that) {
+    return isInetAddressV4(that) && this.port === that.port && Equal.equals(this.address, that.address);
+  },
+  [Hash.symbol]() {
+    return Hash.combine(Hash.hash(this.address), Hash.number(this.port));
+  },
+  toString() {
+    return formatInet(this);
+  },
+  toJSON() {
+    return this.toString();
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+};
+const InetV6Proto = {
+  _tag: "InetAddressV6",
+  [TypeId]: TypeId,
+  [Equal.symbol](that) {
+    return isInetAddressV6(that) && this.port === that.port && this.scopeId === that.scopeId && Equal.equals(this.address, that.address);
+  },
+  [Hash.symbol]() {
+    return Hash.combine(Hash.combine(Hash.hash(this.address), Hash.number(this.port)), Hash.number(this.scopeId));
+  },
+  toString() {
+    return formatInet(this);
+  },
+  toJSON() {
+    return this.toString();
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+};
+const checkPort = port => Number.isInteger(port) && port >= 0 && port <= 0xffff;
+/**
+ * Creates a checked IPv4 internet address.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const inetAddressV4 = (address, port) => {
+  if (!checkPort(port)) {
+    return addressError(address, "port must be an integer from 0 through 65535");
+  }
+  const self = Object.create(InetV4Proto);
+  self.address = address;
+  self.port = port;
+  return Result.succeed(Object.freeze(self));
+};
+/**
+ * Creates a checked IPv6 internet address with an optional scope identifier.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const inetAddressV6 = (address, port, options) => {
+  if (!checkPort(port)) {
+    return addressError(address, "port must be an integer from 0 through 65535");
+  }
+  const scopeId = options?.scopeId ?? 0;
+  if (!Number.isInteger(scopeId) || scopeId < 0 || scopeId > 0xffffffff) {
+    return addressError(address, "scopeId must be an unsigned 32-bit integer");
+  }
+  const self = Object.create(InetV6Proto);
+  self.address = address;
+  self.port = port;
+  self.scopeId = scopeId;
+  return Result.succeed(Object.freeze(self));
+};
+/**
+ * Creates a checked internet address for an IP address and port.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const inetAddress = (address, port) => isIpv4Address(address) ? inetAddressV4(address, port) : inetAddressV6(address, port);
+/**
+ * Creates an internet address from a trusted IP address and port, throwing on failure.
+ *
+ * @category unsafe
+ * @since 4.0.0
+ */
+export const inetAddressUnsafe = (address, port) => Result.getOrThrow(inetAddress(address, port));
+/**
+ * Creates a checked internet address from a numeric IP string and port.
+ *
+ * **Gotchas**
+ *
+ * The address must be a numeric IPv4 or IPv6 literal. This function does not
+ * resolve hostnames or accept IPv6 brackets.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const inetAddressFromIpString = (address, port) => {
+  return Result.flatMap(ipFromString(address), address => inetAddress(address, port));
+};
+/**
+ * Creates an internet address from a trusted numeric IP string and port.
+ *
+ * **Gotchas**
+ *
+ * This function throws when either input is invalid. Use only when both values
+ * are already known to satisfy the checked constructor's requirements.
+ *
+ * @category unsafe
+ * @since 4.0.0
+ */
+export const inetAddressFromIpStringUnsafe = (address, port) => Result.getOrThrow(inetAddressFromIpString(address, port));
+/**
+ * Parses `IPv4:port` or `[IPv6]:port` without DNS resolution.
+ *
+ * @category decoding
+ * @since 4.0.0
+ */
+export const inetAddressFromString = input => {
+  let host;
+  let portText;
+  let scopeId = 0;
+  const bracketed = input.startsWith("[");
+  if (bracketed) {
+    const end = input.indexOf("]");
+    if (end < 0 || input[end + 1] !== ":" || input.indexOf("]", end + 1) !== -1) {
+      return addressError(input, "expected [IPv6]:port");
+    }
+    host = input.slice(1, end);
+    portText = input.slice(end + 2);
+    const scopeSeparator = host.indexOf("%");
+    if (scopeSeparator !== -1) {
+      const scopeText = host.slice(scopeSeparator + 1);
+      if (host.indexOf("%", scopeSeparator + 1) !== -1 || !/^\d+$/.test(scopeText)) {
+        return addressError(input, "scope identifier must be decimal");
+      }
+      scopeId = Number(scopeText);
+      if (!Number.isInteger(scopeId) || scopeId > 0xffffffff) {
+        return addressError(input, "scope identifier must be an unsigned 32-bit integer");
+      }
+      host = host.slice(0, scopeSeparator);
+    }
+  } else {
+    const separator = input.lastIndexOf(":");
+    if (separator < 0) {
+      return addressError(input, "expected host:port or [IPv6]:port");
+    }
+    if (input.indexOf(":") !== separator) {
+      return addressError(input, "IPv6 addresses must be bracketed");
+    }
+    host = input.slice(0, separator);
+    portText = input.slice(separator + 1);
+  }
+  if (!/^(0|[1-9]\d*)$/.test(portText)) {
+    return addressError(input, "port must be an unpadded decimal integer");
+  }
+  return Result.flatMap(ipFromString(host), address => {
+    if (bracketed !== isIpv6Address(address)) {
+      return addressError(input, "only IPv6 addresses use brackets");
+    }
+    return isIpv6Address(address) ? inetAddressV6(address, Number(portText), {
+      scopeId
+    }) : inetAddressV4(address, Number(portText));
+  });
+};
+/**
+ * Parses a trusted numeric internet address and port, throwing on failure.
+ *
+ * @category unsafe
+ * @since 4.0.0
+ */
+export const inetAddressFromStringUnsafe = input => Result.getOrThrow(inetAddressFromString(input));
+/**
+ * Formats a resolved internet address, bracketing IPv6 around its port.
+ *
+ * @category encoding
+ * @since 4.0.0
+ */
+export const formatInet = self => {
+  if (self._tag === "InetAddressV4") return `${formatIp(self.address)}:${self.port}`;
+  const scope = self.scopeId === 0 ? "" : `%${self.scopeId}`;
+  return `[${formatIp(self.address)}${scope}]:${self.port}`;
+};
+/**
+ * Formats an IP address for use as a URL authority host.
+ *
+ * @category encoding
+ * @since 4.0.0
+ */
+export const formatUrlHost = self => isIpv4Address(self) ? formatIp(self) : `[${formatIp(self)}]`;
+/**
+ * Converts an IP address or internet socket address to a WHATWG `URL`.
+ *
+ * **Details**
+ *
+ * Defaults to the HTTP scheme and uses standard URL normalization, including
+ * IPv6 brackets and omission of default ports. Bare IP addresses have no
+ * explicit port; internet socket addresses retain their port, including zero.
+ * Unspecified addresses are preserved.
+ *
+ * **Gotchas**
+ *
+ * Returns a `NetAddressError` for scoped IPv6 addresses or inputs that the URL
+ * constructor rejects. Supply the scheme without a trailing colon, for example
+ * `"https"`.
+ *
+ * @category conversions
+ * @since 4.0.0
+ */
+export const toUrl = (self, scheme = "http") => {
+  if (self._tag === "InetAddressV6" && self.scopeId !== 0) {
+    return addressError(self, "scoped IPv6 addresses are not supported by WHATWG URLs");
+  }
+  return Result.try({
+    try: () => new URL(`${scheme}://${isInetAddress(self) ? formatInet(self) : formatUrlHost(self)}`),
+    catch: cause => new NetAddressError({
+      input: self,
+      message: "failed to construct URL",
+      cause
+    })
+  });
+};
+/**
+ * Formats an IP or socket address as a URL display string.
+ *
+ * **Details**
+ *
+ * Defaults to HTTP, brackets IPv6 addresses, and omits default ports and the
+ * trailing slash. Custom schemes such as `"tcp"` retain their scheme and host.
+ * Unix socket addresses use {@link formatUnixPath}, preserving the raw path
+ * with a `unix://` prefix regardless of the supplied scheme.
+ *
+ * **Gotchas**
+ *
+ * Returns a `NetAddressError` when URL conversion fails, including for scoped
+ * IPv6 addresses.
+ *
+ * @category encoding
+ * @since 4.0.0
+ */
+export const formatUrl = (self, scheme = "http") => isUnixPathAddress(self) ? Result.succeed(formatUnixPath(self)) : Result.map(toUrl(self, scheme), url => `${url.protocol}//${url.host}`);
+/**
+ * Formats an IP or socket address as a URL display string,
+ * throwing a `NetAddressError` when conversion fails.
+ *
+ * @see {@link formatUrl} for the checked version and formatting behavior.
+ *
+ * @category unsafe
+ * @since 4.0.0
+ */
+export const formatUrlUnsafe = (self, scheme = "http") => Result.getOrThrow(formatUrl(self, scheme));
+/**
+ * Formats a hostname or numeric IP address for use as a URL authority host.
+ *
+ * @category encoding
+ * @since 4.0.0
+ */
+export const formatUrlHostString = host => host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
+const UnixPathProto = {
+  _tag: "UnixPathAddress",
+  [TypeId]: TypeId,
+  [Equal.symbol](that) {
+    return isUnixPathAddress(that) && this.path === that.path;
+  },
+  [Hash.symbol]() {
+    return Hash.combine(Hash.string("UnixPathAddress"), Hash.string(this.path));
+  },
+  toString() {
+    return this.path;
+  },
+  toJSON() {
+    return this.toString();
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+};
+/**
+ * Creates a Unix-domain filesystem address without normalizing its opaque path.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const unixPathAddress = path => {
+  const self = Object.create(UnixPathProto);
+  self.path = path;
+  return Object.freeze(self);
+};
+/**
+ * Formats a Unix-domain socket path as a readable `unix://path` display string.
+ *
+ * **Details**
+ *
+ * Preserves the raw path without URL encoding or normalization. The resulting
+ * string is intended for display.
+ *
+ * @category encoding
+ * @since 4.0.0
+ */
+export const formatUnixPath = self => `unix://${self.path}`;
+/**
+ * Converts a `SocketAddress.Input` to a concrete socket address.
+ *
+ * **Details**
+ *
+ * Numeric IP strings are parsed without hostname resolution. Invalid IP
+ * literals, ports, and input shapes return a `NetAddressError`.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const socketAddressFromInput = input => {
+  if (isSocketAddress(input)) return Result.succeed(input);
+  if (typeof input === "string") return inetAddressFromString(input);
+  if (hasProperty(input, "path")) {
+    return typeof input.path === "string" ? Result.succeed(unixPathAddress(input.path)) : addressError(input, "path must be a string");
+  }
+  if (!hasProperty(input, "address") || !hasProperty(input, "port")) {
+    return addressError(input, "expected an address and port or a Unix path");
+  }
+  const address = typeof input.address === "string" ? ipFromString(input.address) : isIpAddress(input.address) ? Result.succeed(input.address) : addressError(input, "address must be an IP address or numeric IP string");
+  return Result.flatMap(address, address => inetAddress(address, input.port));
+};
+/**
+ * Converts a trusted `SocketAddress.Input` to a concrete socket address,
+ * throwing on failure.
+ *
+ * @category unsafe
+ * @since 4.0.0
+ */
+export const socketAddressFromInputUnsafe = input => Result.getOrThrow(socketAddressFromInput(input));
+/**
+ * Formats a portable socket address for human-readable output.
+ *
+ * @category encoding
+ * @since 4.0.0
+ */
+export const formatSocketAddress = self => self._tag === "UnixPathAddress" ? self.path : formatInet(self);
+//# sourceMappingURL=NetAddress.js.map