terraconstructs 0.0.11 → 0.0.13

package/lib/aws/compute/ec2-util-v2.d.ts

@@ -0,0 +1,141 @@
+/**
+ * NetworkUtils contains helpers to work with network constructs (subnets/ranges)
+ */
+export declare class NetworkUtils {
+    /**
+     * Validates an IPv4 address string.
+     *
+     * @param ipAddress The IPv4 address string to be validated.
+     * @returns True if the string is a valid IPv4 address, false otherwise.
+     * Validates an IPv4 string
+     *
+     * returns true of the string contains 4 numbers between 0-255 delimited by
+     * a `.` character
+     */
+    static validIp(ipAddress: string): boolean;
+    /**
+     * Converts a string representation of an IPv4 address to its corresponding numerical value.
+     *
+     * Uses the formula:
+     * (first octet * 256³) + (second octet * 256²) + (third octet * 256) +
+     * (fourth octet)
+     *
+     * @param  ipAddress the IP address (e.g. 174.66.173.168)
+     * @returns the integer value of the IP address (e.g 2923605416)
+     */
+    static ipToNum(ipAddress: string): number;
+    /**
+     * Takes number and converts it to IPv4 address string
+     *
+     * Takes a number (e.g 2923605416) and converts it to an IPv4 address string
+     * currently only supports IPv4
+     *
+     * @param ipNum integer value of the IP address (e.g 2923605416)
+     * @returns IPv4 address (e.g. 174.66.173.168)
+     */
+    static numToIp(ipNum: number): string;
+}
+/**
+ * Exported class from VPC to support subnet filtering
+ * and CIDR validation
+ */
+export declare class CidrBlock {
+    /**
+     * Calculates the netmask for a given CIDR mask
+     *
+     * The netmask is a 32-bit binary value used to separate the network portion from the host portion of an IPv4 address.
+     * It is calculated based on the CIDR prefix length (the number of bits used to represent the network portion).
+     *
+     * For example:
+     * CidrBlock.calculateNetmask(24) returns '255.255.255.0'
+     *
+     * @param mask The CIDR prefix length (between 0 and 32) for which to calculate the netmask.
+      // Calculate the netmask by performing a bitwise NOT on the result of (2^32 - 2^(32 - mask))
+     * @returns The netmask string in IPv4 address format.
+     */
+    static calculateNetmask(mask: number): string;
+    /**
+     * Calculates the number IP addresses in a CIDR Mask
+     *
+     * For example:
+     * CidrBlock.calculateNetsize(16) returns 65536
+     *
+     * @param mask The CIDR prefix length (between 0 and 32) for which to calculate the network size.
+     * CidrBlock.calculateNetsize(24) returns 256
+     */
+    static calculateNetsize(mask: number): number;
+    /**
+     * IP address in the CIDR block.
+     */
+    readonly cidr: string;
+    readonly mask: number;
+    readonly networkSize: number;
+    private readonly networkAddress;
+    constructor(cidr: string);
+    constructor(ipAddress: number, mask: number);
+    maxIp(): string;
+    minIp(): string;
+    minAddress(): number;
+    maxAddress(): number;
+    nextBlock(): CidrBlock;
+    containsCidr(other: CidrBlock): boolean;
+    /**
+     * Checks if two IPv4 address ranges overlap.
+     *
+     * @param range1 The first IP address range represented as an array [start, end].
+     * @param range2 The second IP address range represented as an array [start, end].
+     * @returns True if the two IP address ranges overlap, false otherwise.
+     *
+     * Note: This method assumes that the start and end addresses are valid IPv4 addresses.
+     */
+    rangesOverlap(range1: [string, string], range2: [string, string]): boolean;
+}
+/**
+ * Class with helper functions to support
+ * Subnet Ipv6 Address Validation
+ *
+ * This class provides methods for working with IPv6 CIDR blocks, including calculating the minimum and maximum
+ * IP addresses in a CIDR block, and checking if two CIDR blocks overlap.
+ */
+export declare class CidrBlockIpv6 {
+    /**
+     * Ipv6 CIDR range
+     */
+    cidr: string;
+    /**
+     * The CIDR prefix length (number of bits used for the network portion of the address).
+     */
+    cidrPrefix: number;
+    private ipParts;
+    private networkBits;
+    private networkPart;
+    constructor(cidr: string);
+    private parseBigIntParts;
+    /**
+     * @returns Minimum IPv6 address for a provided CIDR
+     */
+    minIp(): string;
+    /**
+     * @returns Maximum IPv6 address for a provided CIDR
+     */
+    maxIp(): string;
+    private formatIPv6Part;
+    /**
+     *
+     * @param range1 Ipv6 CIDR range to compare
+     * @param range2 Ipv6 CIDR range to compare
+     * @returns true if two ranges overlap, false otherwise
+     */
+    rangesOverlap(range1: string, range2: string): boolean;
+    /**
+     *
+     * @param cidr
+     * @returns Range in the from of big int number [start, end]
+     */
+    private getIPv6Range;
+    /**
+     * @param ipv6Address
+     * @returns Converts given ipv6 address range to big int number
+     */
+    private ipv6ToNumber;
+}

package/lib/aws/compute/ec2-util-v2.js

@@ -0,0 +1,286 @@
+"use strict";
+// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/@aws-cdk/aws-ec2-alpha/lib/util.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CidrBlockIpv6 = exports.CidrBlock = exports.NetworkUtils = void 0;
+/*eslint no-bitwise: ["error", { "allow": ["~", "|", "<<", "&"] }] */
+// TODO: Fix duplicates from https://github.com/aws/aws-cdk/blob/v2.175.1/packages/@aws-cdk/aws-ec2-alpha/lib/util.ts
+// classes overlap and seem identical: CidrBlock, NetworkUtils in ./util.ts
+/**
+ * NetworkUtils contains helpers to work with network constructs (subnets/ranges)
+ */
+class NetworkUtils {
+    /**
+     * Validates an IPv4 address string.
+     *
+     * @param ipAddress The IPv4 address string to be validated.
+     * @returns True if the string is a valid IPv4 address, false otherwise.
+     * Validates an IPv4 string
+     *
+     * returns true of the string contains 4 numbers between 0-255 delimited by
+     * a `.` character
+     */
+    static validIp(ipAddress) {
+        const octets = ipAddress.split(".");
+        if (octets.length !== 4) {
+            return false;
+        }
+        return octets
+            .map((octet) => parseInt(octet, 10))
+            .every((octet) => octet >= 0 && octet <= 255);
+    }
+    /**
+     * Converts a string representation of an IPv4 address to its corresponding numerical value.
+     *
+     * Uses the formula:
+     * (first octet * 256³) + (second octet * 256²) + (third octet * 256) +
+     * (fourth octet)
+     *
+     * @param  ipAddress the IP address (e.g. 174.66.173.168)
+     * @returns the integer value of the IP address (e.g 2923605416)
+     */
+    static ipToNum(ipAddress) {
+        if (!this.validIp(ipAddress)) {
+            throw new Error(`${ipAddress} is not valid`);
+        }
+        return ipAddress
+            .split(".")
+            .reduce((p, c, i) => p + parseInt(c, 10) * 256 ** (3 - i), 0);
+    }
+    /**
+     * Takes number and converts it to IPv4 address string
+     *
+     * Takes a number (e.g 2923605416) and converts it to an IPv4 address string
+     * currently only supports IPv4
+     *
+     * @param ipNum integer value of the IP address (e.g 2923605416)
+     * @returns IPv4 address (e.g. 174.66.173.168)
+     */
+    static numToIp(ipNum) {
+        // this all because bitwise math is signed
+        let remaining = ipNum;
+        const address = new Array();
+        for (let i = 0; i < 4; i++) {
+            if (remaining !== 0) {
+                address.push(Math.floor(remaining / 256 ** (3 - i)));
+                remaining = remaining % 256 ** (3 - i);
+            }
+            else {
+                address.push(0);
+            }
+        }
+        const ipAddress = address.join(".");
+        if (!this.validIp(ipAddress)) {
+            throw new Error(`${ipAddress} is not a valid IP Address`);
+        }
+        return ipAddress;
+    }
+}
+exports.NetworkUtils = NetworkUtils;
+/**
+ * Exported class from VPC to support subnet filtering
+ * and CIDR validation
+ */
+class CidrBlock {
+    /**
+     * Calculates the netmask for a given CIDR mask
+     *
+     * The netmask is a 32-bit binary value used to separate the network portion from the host portion of an IPv4 address.
+     * It is calculated based on the CIDR prefix length (the number of bits used to represent the network portion).
+     *
+     * For example:
+     * CidrBlock.calculateNetmask(24) returns '255.255.255.0'
+     *
+     * @param mask The CIDR prefix length (between 0 and 32) for which to calculate the netmask.
+      // Calculate the netmask by performing a bitwise NOT on the result of (2^32 - 2^(32 - mask))
+     * @returns The netmask string in IPv4 address format.
+     */
+    static calculateNetmask(mask) {
+        return NetworkUtils.numToIp(2 ** 32 - 2 ** (32 - mask));
+    }
+    /**
+     * Calculates the number IP addresses in a CIDR Mask
+     *
+     * For example:
+     * CidrBlock.calculateNetsize(16) returns 65536
+     *
+     * @param mask The CIDR prefix length (between 0 and 32) for which to calculate the network size.
+     * CidrBlock.calculateNetsize(24) returns 256
+     */
+    static calculateNetsize(mask) {
+        return 2 ** (32 - mask);
+    }
+    constructor(ipAddressOrCidr, mask) {
+        if (typeof ipAddressOrCidr === "string") {
+            this.mask = parseInt(ipAddressOrCidr.split("/")[1], 10);
+            this.networkAddress =
+                NetworkUtils.ipToNum(ipAddressOrCidr.split("/")[0]) +
+                    CidrBlock.calculateNetsize(this.mask) -
+                    1;
+        }
+        else {
+            if (typeof mask === "number") {
+                this.mask = mask;
+            }
+            else {
+                // this should be impossible
+                this.mask = 16;
+            }
+            this.networkAddress =
+                ipAddressOrCidr + CidrBlock.calculateNetsize(this.mask) - 1;
+            this.networkSize = 2 ** (32 - this.mask);
+        }
+        this.networkSize = 2 ** (32 - this.mask);
+        this.cidr = `${this.minIp()}/${this.mask}`;
+    }
+    /*
+     * The maximum IP in the CIDR Block e.g. '10.0.8.255'
+     */
+    maxIp() {
+        // min + (2^(32-mask)) - 1 [zero needs to count]
+        return NetworkUtils.numToIp(this.maxAddress());
+    }
+    /*
+     * Checks if this CIDR block fully contains the provided CIDR block.
+     *
+     * @param other The CIDR block to check for containment.
+     * @returns True if this CIDR block fully contains the provided CIDR block, false otherwise.
+     *
+     * The minimum IP in the CIDR Block e.g. '10.0.0.0'
+     */
+    minIp() {
+        return NetworkUtils.numToIp(this.minAddress());
+    }
+    /*
+     * Returns the number representation for the minimum IPv4 address
+     */
+    minAddress() {
+        const div = this.networkAddress % this.networkSize;
+        return this.networkAddress - div;
+    }
+    /*
+     * Returns the number representation for the maximum IPv4 address
+     */
+    maxAddress() {
+        /**
+         * The maximum IP address in the CIDR block is calculated as the minimum address + (2^(32-mask)) - 1.
+         * This is because the minimum address represents the network address, and the maximum address is the broadcast address.
+         */
+        // min + (2^(32-mask)) - 1 [zero needs to count]
+        return this.minAddress() + this.networkSize - 1;
+    }
+    /*
+     * Returns the next consecutive CIDR block of the same mask size following this CIDR block.
+     *
+     * For example, if this CIDR block is '10.0.0.0/24', the next block would be '10.0.1.0/24'.
+     *
+     * Returns the next CIDR Block of the same mask size
+     */
+    nextBlock() {
+        return new CidrBlock(this.maxAddress() + 1, this.mask);
+    }
+    /*
+     * Returns true if this CidrBlock fully contains the provided CidrBlock
+     */
+    containsCidr(other) {
+        return (this.maxAddress() >= other.maxAddress() &&
+            this.minAddress() <= other.minAddress());
+    }
+    /**
+     * Checks if two IPv4 address ranges overlap.
+     *
+     * @param range1 The first IP address range represented as an array [start, end].
+     * @param range2 The second IP address range represented as an array [start, end].
+     * @returns True if the two IP address ranges overlap, false otherwise.
+     *
+     * Note: This method assumes that the start and end addresses are valid IPv4 addresses.
+     */
+    rangesOverlap(range1, range2) {
+        const [start1, end1] = range1.map((ip) => NetworkUtils.ipToNum(ip));
+        const [start2, end2] = range2.map((ip) => NetworkUtils.ipToNum(ip));
+        // Check if ranges overlap
+        return start1 <= end2 && start2 <= end1;
+    }
+}
+exports.CidrBlock = CidrBlock;
+/**
+ * Class with helper functions to support
+ * Subnet Ipv6 Address Validation
+ *
+ * This class provides methods for working with IPv6 CIDR blocks, including calculating the minimum and maximum
+ * IP addresses in a CIDR block, and checking if two CIDR blocks overlap.
+ */
+class CidrBlockIpv6 {
+    constructor(cidr) {
+        this.formatIPv6Part = (part) => part.toString(16).padStart(4, "0");
+        this.cidr = cidr;
+        const [ipAddress, prefix] = cidr.split("/");
+        this.cidrPrefix = parseInt(prefix, 10);
+        this.ipParts = this.parseBigIntParts(ipAddress);
+        this.networkBits = this.cidrPrefix;
+        this.networkPart = this.ipParts.slice(0, Math.ceil(this.networkBits / 16));
+    }
+    parseBigIntParts(ipAddress) {
+        return ipAddress
+            .split(":")
+            .map((part) => BigInt(`0x${part.padStart(4, "0")}` || "0"));
+    }
+    /**
+     * @returns Minimum IPv6 address for a provided CIDR
+     */
+    minIp() {
+        const startIP = [...this.networkPart];
+        for (let i = this.networkPart.length; i < 8; i++) {
+            startIP.push(BigInt(0));
+        }
+        return startIP.map(this.formatIPv6Part).join(":");
+    }
+    /**
+     * @returns Maximum IPv6 address for a provided CIDR
+     */
+    maxIp() {
+        const endIP = [...this.networkPart];
+        const hostPart = Array(8 - this.networkPart.length).fill(BigInt(0xffff));
+        endIP.push(...hostPart);
+        return endIP.map(this.formatIPv6Part).join(":");
+    }
+    /**
+     *
+     * @param range1 Ipv6 CIDR range to compare
+     * @param range2 Ipv6 CIDR range to compare
+     * @returns true if two ranges overlap, false otherwise
+     */
+    rangesOverlap(range1, range2) {
+        const [start1, end1] = this.getIPv6Range(range1);
+        const [start2, end2] = this.getIPv6Range(range2);
+        return start1 <= end2 && start2 <= end1;
+    }
+    /**
+     *
+     * @param cidr
+     * @returns Range in the from of big int number [start, end]
+     */
+    getIPv6Range(cidr) {
+        const [ipv6Address, prefixLength] = cidr.split("/");
+        const ipv6Number = this.ipv6ToNumber(ipv6Address);
+        const mask = (BigInt(1) << BigInt(128 - Number(prefixLength))) - BigInt(1);
+        const networkPrefix = ipv6Number & ~mask;
+        const start = networkPrefix;
+        const end = networkPrefix | mask;
+        return [start, end];
+    }
+    /**
+     * @param ipv6Address
+     * @returns Converts given ipv6 address range to big int number
+     */
+    ipv6ToNumber(ipv6Address) {
+        const blocks = this.parseBigIntParts(ipv6Address);
+        let ipv6Number = BigInt(0);
+        for (const block of blocks) {
+            /* tslint:disable:no-bitwise */
+            ipv6Number = (ipv6Number << BigInt(16)) + block;
+        }
+        return ipv6Number;
+    }
+}
+exports.CidrBlockIpv6 = CidrBlockIpv6;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ec2-util-v2.js","sourceRoot":"","sources":["../../../src/aws/compute/ec2-util-v2.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/@aws-cdk/aws-ec2-alpha/lib/util.ts\n\n/*eslint no-bitwise: [\"error\", { \"allow\": [\"~\", \"|\", \"<<\", \"&\"] }] */\n\n// TODO: Fix duplicates from https://github.com/aws/aws-cdk/blob/v2.175.1/packages/@aws-cdk/aws-ec2-alpha/lib/util.ts\n// classes overlap and seem identical: CidrBlock, NetworkUtils in ./util.ts\n\n/**\n * NetworkUtils contains helpers to work with network constructs (subnets/ranges)\n */\nexport class NetworkUtils {\n  /**\n   * Validates an IPv4 address string.\n   *\n   * @param ipAddress The IPv4 address string to be validated.\n   * @returns True if the string is a valid IPv4 address, false otherwise.\n   * Validates an IPv4 string\n   *\n   * returns true of the string contains 4 numbers between 0-255 delimited by\n   * a `.` character\n   */\n  public static validIp(ipAddress: string): boolean {\n    const octets = ipAddress.split(\".\");\n    if (octets.length !== 4) {\n      return false;\n    }\n    return octets\n      .map((octet: string) => parseInt(octet, 10))\n      .every((octet: number) => octet >= 0 && octet <= 255);\n  }\n\n  /**\n   * Converts a string representation of an IPv4 address to its corresponding numerical value.\n   *\n   * Uses the formula:\n   * (first octet * 256³) + (second octet * 256²) + (third octet * 256) +\n   * (fourth octet)\n   *\n   * @param  ipAddress the IP address (e.g. 174.66.173.168)\n   * @returns the integer value of the IP address (e.g 2923605416)\n   */\n  public static ipToNum(ipAddress: string): number {\n    if (!this.validIp(ipAddress)) {\n      throw new Error(`${ipAddress} is not valid`);\n    }\n\n    return ipAddress\n      .split(\".\")\n      .reduce(\n        (p: number, c: string, i: number) =>\n          p + parseInt(c, 10) * 256 ** (3 - i),\n        0,\n      );\n  }\n\n  /**\n   * Takes number and converts it to IPv4 address string\n   *\n   * Takes a number (e.g 2923605416) and converts it to an IPv4 address string\n   * currently only supports IPv4\n   *\n   * @param ipNum integer value of the IP address (e.g 2923605416)\n   * @returns IPv4 address (e.g. 174.66.173.168)\n   */\n  public static numToIp(ipNum: number): string {\n    // this all because bitwise math is signed\n    let remaining = ipNum;\n    const address = new Array<number>();\n    for (let i = 0; i < 4; i++) {\n      if (remaining !== 0) {\n        address.push(Math.floor(remaining / 256 ** (3 - i)));\n        remaining = remaining % 256 ** (3 - i);\n      } else {\n        address.push(0);\n      }\n    }\n    const ipAddress: string = address.join(\".\");\n    if (!this.validIp(ipAddress)) {\n      throw new Error(`${ipAddress} is not a valid IP Address`);\n    }\n    return ipAddress;\n  }\n}\n\n/**\n * Exported class from VPC to support subnet filtering\n * and CIDR validation\n */\nexport class CidrBlock {\n  /**\n   * Calculates the netmask for a given CIDR mask\n   *\n   * The netmask is a 32-bit binary value used to separate the network portion from the host portion of an IPv4 address.\n   * It is calculated based on the CIDR prefix length (the number of bits used to represent the network portion).\n   *\n   * For example:\n   * CidrBlock.calculateNetmask(24) returns '255.255.255.0'\n   *\n   * @param mask The CIDR prefix length (between 0 and 32) for which to calculate the netmask.\n    // Calculate the netmask by performing a bitwise NOT on the result of (2^32 - 2^(32 - mask))\n   * @returns The netmask string in IPv4 address format.\n   */\n  public static calculateNetmask(mask: number): string {\n    return NetworkUtils.numToIp(2 ** 32 - 2 ** (32 - mask));\n  }\n\n  /**\n   * Calculates the number IP addresses in a CIDR Mask\n   *\n   * For example:\n   * CidrBlock.calculateNetsize(16) returns 65536\n   *\n   * @param mask The CIDR prefix length (between 0 and 32) for which to calculate the network size.\n   * CidrBlock.calculateNetsize(24) returns 256\n   */\n  public static calculateNetsize(mask: number): number {\n    return 2 ** (32 - mask);\n  }\n\n  /**\n   * IP address in the CIDR block.\n   */\n  public readonly cidr: string;\n\n  /*\n   * The CIDR mask e.g. for CIDR '10.0.0.0/21' returns 21\n   */\n  public readonly mask: number;\n\n  /*\n   * The total number of IP addresses in the CIDR\n   */\n  public readonly networkSize: number;\n\n  /*\n   * The network address provided in CIDR creation offset by the Netsize -1\n   */\n  private readonly networkAddress: number;\n\n  /*\n   * Parses either CIDR notation String or two numbers representing the IP\n   * space\n   *\n   * cidr expects a string '10.0.0.0/16'\n   * ipAddress expects a number\n   * mask expects a number\n   *\n   * If the given `cidr` or `ipAddress` is not the beginning of the block,\n   * then the next available block will be returned. For example, if\n   * `10.0.3.1/28` is given the returned block will represent `10.0.3.16/28`.\n   */\n  constructor(cidr: string);\n  constructor(ipAddress: number, mask: number);\n  constructor(ipAddressOrCidr: string | number, mask?: number) {\n    if (typeof ipAddressOrCidr === \"string\") {\n      this.mask = parseInt(ipAddressOrCidr.split(\"/\")[1], 10);\n      this.networkAddress =\n        NetworkUtils.ipToNum(ipAddressOrCidr.split(\"/\")[0]) +\n        CidrBlock.calculateNetsize(this.mask) -\n        1;\n    } else {\n      if (typeof mask === \"number\") {\n        this.mask = mask;\n      } else {\n        // this should be impossible\n        this.mask = 16;\n      }\n      this.networkAddress =\n        ipAddressOrCidr + CidrBlock.calculateNetsize(this.mask) - 1;\n      this.networkSize = 2 ** (32 - this.mask);\n    }\n    this.networkSize = 2 ** (32 - this.mask);\n    this.cidr = `${this.minIp()}/${this.mask}`;\n  }\n\n  /*\n   * The maximum IP in the CIDR Block e.g. '10.0.8.255'\n   */\n  public maxIp(): string {\n    // min + (2^(32-mask)) - 1 [zero needs to count]\n    return NetworkUtils.numToIp(this.maxAddress());\n  }\n\n  /*\n   * Checks if this CIDR block fully contains the provided CIDR block.\n   *\n   * @param other The CIDR block to check for containment.\n   * @returns True if this CIDR block fully contains the provided CIDR block, false otherwise.\n   *\n   * The minimum IP in the CIDR Block e.g. '10.0.0.0'\n   */\n  public minIp(): string {\n    return NetworkUtils.numToIp(this.minAddress());\n  }\n\n  /*\n   * Returns the number representation for the minimum IPv4 address\n   */\n  public minAddress(): number {\n    const div = this.networkAddress % this.networkSize;\n    return this.networkAddress - div;\n  }\n\n  /*\n   * Returns the number representation for the maximum IPv4 address\n   */\n  public maxAddress(): number {\n    /**\n     * The maximum IP address in the CIDR block is calculated as the minimum address + (2^(32-mask)) - 1.\n     * This is because the minimum address represents the network address, and the maximum address is the broadcast address.\n     */\n    // min + (2^(32-mask)) - 1 [zero needs to count]\n    return this.minAddress() + this.networkSize - 1;\n  }\n\n  /*\n   * Returns the next consecutive CIDR block of the same mask size following this CIDR block.\n   *\n   * For example, if this CIDR block is '10.0.0.0/24', the next block would be '10.0.1.0/24'.\n   *\n   * Returns the next CIDR Block of the same mask size\n   */\n  public nextBlock(): CidrBlock {\n    return new CidrBlock(this.maxAddress() + 1, this.mask);\n  }\n\n  /*\n   * Returns true if this CidrBlock fully contains the provided CidrBlock\n   */\n  public containsCidr(other: CidrBlock): boolean {\n    return (\n      this.maxAddress() >= other.maxAddress() &&\n      this.minAddress() <= other.minAddress()\n    );\n  }\n\n  /**\n   * Checks if two IPv4 address ranges overlap.\n   *\n   * @param range1 The first IP address range represented as an array [start, end].\n   * @param range2 The second IP address range represented as an array [start, end].\n   * @returns True if the two IP address ranges overlap, false otherwise.\n   *\n   * Note: This method assumes that the start and end addresses are valid IPv4 addresses.\n   */\n  public rangesOverlap(\n    range1: [string, string],\n    range2: [string, string],\n  ): boolean {\n    const [start1, end1] = range1.map((ip) => NetworkUtils.ipToNum(ip));\n    const [start2, end2] = range2.map((ip) => NetworkUtils.ipToNum(ip));\n    // Check if ranges overlap\n    return start1 <= end2 && start2 <= end1;\n  }\n}\n\n/**\n * Class with helper functions to support\n * Subnet Ipv6 Address Validation\n *\n * This class provides methods for working with IPv6 CIDR blocks, including calculating the minimum and maximum\n * IP addresses in a CIDR block, and checking if two CIDR blocks overlap.\n */\nexport class CidrBlockIpv6 {\n  /**\n   * Ipv6 CIDR range\n   */\n  public cidr: string;\n  /**\n   * The CIDR prefix length (number of bits used for the network portion of the address).\n   */\n  public cidrPrefix: number;\n  private ipParts: bigint[];\n  private networkBits: number;\n  private networkPart: bigint[];\n\n  constructor(cidr: string) {\n    this.cidr = cidr;\n    const [ipAddress, prefix] = cidr.split(\"/\");\n    this.cidrPrefix = parseInt(prefix, 10);\n    this.ipParts = this.parseBigIntParts(ipAddress);\n    this.networkBits = this.cidrPrefix;\n    this.networkPart = this.ipParts.slice(0, Math.ceil(this.networkBits / 16));\n  }\n\n  private parseBigIntParts(ipAddress: string): bigint[] {\n    return ipAddress\n      .split(\":\")\n      .map((part) => BigInt(`0x${part.padStart(4, \"0\")}` || \"0\"));\n  }\n\n  /**\n   * @returns Minimum IPv6 address for a provided CIDR\n   */\n  public minIp(): string {\n    const startIP = [...this.networkPart];\n    for (let i = this.networkPart.length; i < 8; i++) {\n      startIP.push(BigInt(0));\n    }\n    return startIP.map(this.formatIPv6Part).join(\":\");\n  }\n\n  /**\n   * @returns Maximum IPv6 address for a provided CIDR\n   */\n  public maxIp(): string {\n    const endIP = [...this.networkPart];\n    const hostPart = Array(8 - this.networkPart.length).fill(BigInt(0xffff));\n    endIP.push(...hostPart);\n\n    return endIP.map(this.formatIPv6Part).join(\":\");\n  }\n\n  private formatIPv6Part = (part: bigint) => part.toString(16).padStart(4, \"0\");\n\n  /**\n   *\n   * @param range1 Ipv6 CIDR range to compare\n   * @param range2 Ipv6 CIDR range to compare\n   * @returns true if two ranges overlap, false otherwise\n   */\n  public rangesOverlap(range1: string, range2: string): boolean {\n    const [start1, end1] = this.getIPv6Range(range1);\n    const [start2, end2] = this.getIPv6Range(range2);\n\n    return start1 <= end2 && start2 <= end1;\n  }\n\n  /**\n   *\n   * @param cidr\n   * @returns Range in the from of big int number [start, end]\n   */\n  private getIPv6Range(cidr: string): [bigint, bigint] {\n    const [ipv6Address, prefixLength] = cidr.split(\"/\");\n    const ipv6Number = this.ipv6ToNumber(ipv6Address);\n    const mask = (BigInt(1) << BigInt(128 - Number(prefixLength))) - BigInt(1);\n    const networkPrefix = ipv6Number & ~mask;\n    const start = networkPrefix;\n    const end = networkPrefix | mask;\n\n    return [start, end];\n  }\n\n  /**\n   * @param ipv6Address\n   * @returns Converts given ipv6 address range to big int number\n   */\n  private ipv6ToNumber(ipv6Address: string): bigint {\n    const blocks = this.parseBigIntParts(ipv6Address);\n    let ipv6Number = BigInt(0);\n    for (const block of blocks) {\n      /* tslint:disable:no-bitwise */\n      ipv6Number = (ipv6Number << BigInt(16)) + block;\n    }\n    return ipv6Number;\n  }\n}\n"]}

package/lib/aws/compute/ec2-util.d.ts

@@ -0,0 +1,52 @@
+import { Construct } from "constructs";
+import { ISubnet, SubnetType } from "./vpc";
+/**
+ * Turn an arbitrary string into one that can be used as a CloudFormation identifier by stripping special characters
+ *
+ * (At the moment, no efforts are taken to prevent collisions, but we can add that later when it becomes necessary).
+ */
+export declare function slugify(x: string): string;
+/**
+ * The default names for every subnet type
+ */
+export declare function defaultSubnetName(type: SubnetType): "Public" | "Private" | "Isolated";
+/**
+ * Return a subnet name from its construct ID
+ *
+ * All subnet names look like NAME <> "Subnet" <> INDEX
+ */
+export declare function subnetGroupNameFromConstructId(subnet: ISubnet): string;
+/**
+ * Make the subnet construct ID from a name and number
+ */
+export declare function subnetId(name: string, i: number): string;
+export declare class ImportSubnetGroup {
+    private readonly availabilityZones;
+    private readonly subnetIds;
+    private readonly names;
+    private readonly routeTableIds;
+    private readonly ipv4CidrBlocks;
+    private readonly groups;
+    constructor(subnetIds: string[] | undefined, names: string[] | undefined, routeTableIds: string[] | undefined, ipv4CidrBlocks: string[] | undefined, type: SubnetType, availabilityZones: string[], idField: string, nameField: string, routeTableIdField: string, ipv4CidrBlockField: string);
+    import(scope: Construct): ISubnet[];
+    /**
+     * Return a list with a name for every subnet
+     */
+    private normalizeNames;
+    /**
+     * Return the i'th AZ
+     */
+    private pickAZ;
+}
+/**
+ * Generate the list of numbers of [0..n)
+ */
+export declare function range(n: number): number[];
+/**
+ * Return the union of table IDs from all selected subnets
+ */
+export declare function allRouteTableIds(subnets: ISubnet[]): string[];
+/**
+ * Flatten a list of lists into a list of elements
+ */
+export declare function flatten<A>(xs: A[][]): A[];