{"version":3,"sources":["../../../src/helpers/ip/ipv4.ts","../../../src/helpers/ip/ranges.ts","../../../src/helpers/ip/utils.ts","../../../src/helpers/ip/ipv6.ts","../../../src/helpers/ip/index.ts"],"sourcesContent":["import ipRanges from './ranges'\nimport * as util from './utils'\n\n/**\n * Given an IPv4 address, convert it to a 32-bit long integer.\n * @param ip the IPv4 address to expand\n * @throws if the string is not a valid IPv4 address\n */\nfunction ipv4ToLong (ip: string) {\n    if (!util.isIPv4(ip)) {\n        throw new Error(`not a valid IPv4 address: ${ip}`)\n    }\n    const octets = ip.split('.')\n    return (\n        ((parseInt(octets[0], 10) << 24) +\n            (parseInt(octets[1], 10) << 16) +\n            (parseInt(octets[2], 10) << 8) +\n            parseInt(octets[3], 10)) >>>\n        0\n    )\n}\n\n// this is the most optimised checker.\nfunction createLongChecker (subnet: string): (addressLong: number) => boolean {\n    const [subnetAddress, prefixLengthString] = subnet.split('/')\n    const prefixLength = parseInt(prefixLengthString, 10)\n    if (!subnetAddress || !Number.isInteger(prefixLength)) {\n        throw new Error(`not a valid IPv4 subnet: ${subnet}`)\n    }\n\n    if (prefixLength < 0 || prefixLength > 32) {\n        throw new Error(`not a valid IPv4 prefix length: ${prefixLength} (from ${subnet})`)\n    }\n\n    const subnetLong = ipv4ToLong(subnetAddress)\n    return addressLong => {\n        if (prefixLength === 0) {\n            return true\n        }\n        const subnetPrefix = subnetLong >> (32 - prefixLength)\n        const addressPrefix = addressLong >> (32 - prefixLength)\n\n        return subnetPrefix === addressPrefix\n    }\n}\n\n/**\n * The functional version, creates a checking function that takes an IPv4 Address and\n * returns whether or not it is contained in (one of) the subnet(s).\n * @param subnetOrSubnets the IPv4 CIDR to test (or an array of them)\n * @throws if the subnet is not a valid IP addresses, or the CIDR prefix length\n *  is not valid\n */\nexport function createChecker (\n    subnetOrSubnets: string | string[]\n): (address: string) => boolean {\n    if (Array.isArray(subnetOrSubnets)) {\n        const checks = subnetOrSubnets.map(subnet => createLongChecker(subnet))\n        return address => {\n            const addressLong = ipv4ToLong(address)\n            return checks.some(check => check(addressLong))\n        }\n    }\n    const check = createLongChecker(subnetOrSubnets)\n    return address => {\n        const addressLong = ipv4ToLong(address)\n        return check(addressLong)\n    }\n}\n\n/**\n * Test if the given IPv4 address is contained in the specified subnet.\n * @param address the IPv4 address to check\n * @param subnetOrSubnets the IPv4 CIDR to test (or an array of them)\n * @throws if the address or subnet are not valid IP addresses, or the CIDR prefix length\n *  is not valid\n */\nexport function isInSubnet (address: string, subnetOrSubnets: string | string[]): boolean {\n    return createChecker(subnetOrSubnets)(address)\n}\n\n// cache these special subnet checkers\nconst specialNetsCache: Record<string, (address: string) => boolean> = {}\n\n/** Test if the given IP address is a private/internal IP address. */\nexport function isPrivate (address: string) {\n    if (!('private' in specialNetsCache)) {\n        specialNetsCache['private'] = createChecker(ipRanges.private.ipv4)\n    }\n    return specialNetsCache['private'](address)\n}\n\n/** Test if the given IP address is a localhost address. */\nexport function isLocalhost (address: string) {\n    if (!('localhost' in specialNetsCache)) {\n        specialNetsCache['localhost'] = createChecker(ipRanges.localhost.ipv4)\n    }\n    return specialNetsCache['localhost'](address)\n}\n\n/** Test if the given IP address is in a known reserved range and not a normal host IP */\nexport function isReserved (address: string) {\n    if (!('reserved' in specialNetsCache)) {\n        specialNetsCache['reserved'] = createChecker(ipRanges.reserved.ipv4)\n    }\n    return specialNetsCache['reserved'](address)\n}\n\n/**\n * Test if the given IP address is a special address of any kind (private, reserved,\n * localhost)\n */\nexport function isSpecial (address: string) {\n    if (!('special' in specialNetsCache)) {\n        specialNetsCache['special'] = createChecker([\n            ...ipRanges.private.ipv4,\n            ...ipRanges.localhost.ipv4,\n            ...ipRanges.reserved.ipv4,\n        ])\n    }\n    return specialNetsCache['special'](address)\n}","export default {\n    /** localhost IP ranges */\n    localhost: {\n        /** the localhost address ranges for IPv4 */\n        ipv4: ['127.0.0.0/8'],\n\n        /** the localhost address ranges for IPv6 */\n        ipv6: ['::1/128'],\n    },\n\n    /** private IP ranges */\n    private: {\n        /** private address ranges for IPv4 */\n        ipv4: [\n            '10.0.0.0/8', // RFC 1918\n            '172.16.0.0/12', // RFC 1918\n            '192.168.0.0/16', // RFC 1918\n        ],\n\n        /** private address ranges for IPv6 */\n        ipv6: [\n            'fe80::/10', // link-local address\n            'fc00::/7', // unique local address (ULA)\n        ],\n    },\n\n    /** reserved IP ranges */\n    reserved: {\n        /** reserved address ranges for IPv4 */\n        ipv4: [\n            '0.0.0.0/8', // broadcast \"this\"\n            '100.64.0.0/10', // carrier-grade NAT\n            '169.254.0.0/16', // DHCP fallback\n            '192.0.0.0/24', // IANA Special Purpose Address Registry\n            '192.0.2.0/24', // TEST-NET-1 for documentation examples\n            '192.88.99.0/24', // deprecated 6to4 anycast relays\n            '198.18.0.0/15', // for testing inter-network comms between two subnets\n            '198.51.100.0/24', // TEST-NET-2 for documentation examples\n            '203.0.113.0/24', // TEST-NET-3 for documentation examples\n            '224.0.0.0/4', // multicast\n            '240.0.0.0/4', // reserved unspecified\n            '255.255.255.255/32', // limited broadcast address\n        ],\n\n        /** reserved address ranges for IPv6 */\n        ipv6: [\n            '::/128', // unspecified address\n            '64:ff9b::/96', // IPv4/IPv6 translation\n            '100::/64', // discard prefix\n            '2001::/32', // Teredo tunneling\n            '2001:10::/28', // deprecated\n            '2001:20::/28', // ORCHIDv2\n            '2001:db8::/32', // for documentation and examples\n            '2002::/16', // 6to4\n            'ff00::/8', // multicast\n        ],\n    },\n}","// RegExp for testing if a string represents an IPv4 address\nconst v4Seg = '(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'\nconst v4Str = `(${v4Seg}[.]){3}${v4Seg}`\nconst IPv4Reg = new RegExp(`^${v4Str}$`)\n\n// RegExp for testing if a string represents an IPv6 address\nconst v6Seg = '(?:[0-9a-fA-F]{1,4})'\nconst IPv6Reg = new RegExp(\n    '^(' +\n    `(?:${v6Seg}:){7}(?:${v6Seg}|:)|` +\n    `(?:${v6Seg}:){6}(?:${v4Str}|:${v6Seg}|:)|` +\n    `(?:${v6Seg}:){5}(?::${v4Str}|(:${v6Seg}){1,2}|:)|` +\n    `(?:${v6Seg}:){4}(?:(:${v6Seg}){0,1}:${v4Str}|(:${v6Seg}){1,3}|:)|` +\n    `(?:${v6Seg}:){3}(?:(:${v6Seg}){0,2}:${v4Str}|(:${v6Seg}){1,4}|:)|` +\n    `(?:${v6Seg}:){2}(?:(:${v6Seg}){0,3}:${v4Str}|(:${v6Seg}){1,5}|:)|` +\n    `(?:${v6Seg}:){1}(?:(:${v6Seg}){0,4}:${v4Str}|(:${v6Seg}){1,6}|:)|` +\n    `(?::((?::${v6Seg}){0,5}:${v4Str}|(?::${v6Seg}){1,7}|:))` +\n    ')(%[0-9a-zA-Z]{1,})?$'\n)\n\n/**\n * Returns true if the string represents an IPv4 address. Matches Node.js net.isIPv4\n * functionality.\n */\nexport function isIPv4 (s: string) {\n    return IPv4Reg.test(s)\n}\n\n/**\n * Returns true if the string represents an IPv6 address. Matches Node.js net.isIPv6\n * functionality.\n */\nexport function isIPv6 (s: string) {\n    return IPv6Reg.test(s)\n}\n\nexport function isIP (s: string) {\n    if (isIPv4(s)) return 4\n    if (isIPv6(s)) return 6\n    return 0\n}\n","import ipRanges from './ranges'\nimport * as util from './utils'\n\n// Note: Profiling shows that on recent versions of Node, string.split(RegExp) is faster\n// than string.split(string).\nconst dot = /\\./\nconst mappedIpv4 = /^(.+:ffff:)(\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3})(?:%.+)?$/\nconst colon = /:/\nconst doubleColon = /::/\n\n/**\n * Given a mapped IPv4 address (e.g. ::ffff:203.0.113.38 or similar), convert it to the\n * equivalent standard IPv6 address.\n * @param ip the IPv4-to-IPv6 mapped address\n */\nfunction mappedIpv4ToIpv6 (ip: string) {\n    const matches = ip.match(mappedIpv4)\n\n    if (!matches || !util.isIPv4(matches[2])) {\n        throw new Error(`not a mapped IPv4 address: ${ip}`)\n    }\n\n    // mapped IPv4 address\n    const prefix = matches[1]\n    const ipv4 = matches[2]\n\n    const parts = ipv4.split(dot).map(x => parseInt(x, 10))\n\n    const segment7 = ((parts[0] << 8) + parts[1]).toString(16)\n    const segment8 = ((parts[2] << 8) + parts[3]).toString(16)\n\n    return `${prefix}${segment7}:${segment8}`\n}\n\n/**\n * Given a mapped IPv4 address, return the bare IPv4 equivalent.\n */\nexport function extractMappedIpv4 (ip: string) {\n    const matches = ip.match(mappedIpv4)\n\n    if (!matches || !util.isIPv4(matches[2])) {\n        throw new Error(`not a mapped IPv4 address: ${ip}`)\n    }\n\n    return matches[2]\n}\n\n/**\n * Given an IP address that may have double-colons, expand all segments and return them\n * as an array of 8 segments (16-bit words). As a peformance enhancement (indicated by\n * profiling), for any segment that was missing but should be a '0', returns undefined.\n * @param ip the IPv6 address to expand\n * @throws if the string is not a valid IPv6 address\n */\nfunction getIpv6Segments (ip: string): string[] {\n    if (!util.isIPv6(ip)) {\n        throw new Error(`not a valid IPv6 address: ${ip}`)\n    }\n\n    if (dot.test(ip)) {\n        return getIpv6Segments(mappedIpv4ToIpv6(ip))\n    }\n\n    // break it into an array, including missing \"::\" segments\n    const [beforeChunk, afterChunk] = ip.split(doubleColon)\n\n    const beforeParts = (beforeChunk && beforeChunk.split(colon)) || []\n    const afterParts = (afterChunk && afterChunk.split(colon)) || []\n    const missingSegments = new Array<string>(8 - (beforeParts.length + afterParts.length))\n\n    return beforeParts.concat(missingSegments, afterParts)\n}\n\n/**\n * Test if the given IPv6 address is contained in the specified subnet.\n * @param address the IPv6 address to check\n * @param subnetOrSubnets the IPv6 CIDR to test (or an array of them)\n * @throws if the address or subnet are not valid IP addresses, or the CIDR prefix length\n *  is not valid\n */\nexport function isInSubnet (address: string, subnetOrSubnets: string | string[]): boolean {\n    return createChecker(subnetOrSubnets)(address)\n}\n\n/**\n * Create a function to test if a given IPv6 address is contained in the specified subnet.\n * @param subnetOrSubnets the IPv6 CIDR to test (or an array of them)\n * @throws if the subnet(s) are not valid IP addresses, or the CIDR prefix lengths\n *  are not valid\n */\nexport function createChecker (\n    subnetOrSubnets: string | string[]\n): (address: string) => boolean {\n    if (Array.isArray(subnetOrSubnets)) {\n        const checks = subnetOrSubnets.map(subnet => createSegmentChecker(subnet))\n        return address => {\n            const segments = getIpv6Segments(address)\n            return checks.some(check => check(segments))\n        }\n    }\n    const check = createSegmentChecker(subnetOrSubnets)\n    return address => {\n        const segments = getIpv6Segments(address)\n        return check(segments)\n    }\n}\n\n// This creates the last function that works on the most deconstructed data\nfunction createSegmentChecker (subnet: string): (segments: string[]) => boolean {\n    const [subnetAddress, prefixLengthString] = subnet.split('/')\n    const prefixLength = parseInt(prefixLengthString, 10)\n\n    if (!subnetAddress || !Number.isInteger(prefixLength)) {\n        throw new Error(`not a valid IPv6 CIDR subnet: ${subnet}`)\n    }\n\n    if (prefixLength < 0 || prefixLength > 128) {\n        throw new Error(`not a valid IPv6 prefix length: ${prefixLength} (from ${subnet})`)\n    }\n\n    // the next line throws if the address is not a valid IPv6 address\n    const subnetSegments = getIpv6Segments(subnetAddress)\n\n    return addressSegments => {\n        for (let i = 0; i < 8; ++i) {\n            const bitCount = Math.min(prefixLength - i * 16, 16)\n\n            if (bitCount <= 0) {\n                break\n            }\n\n            const subnetPrefix =\n                ((subnetSegments[i] && parseInt(subnetSegments[i], 16)) || 0) >> (16 - bitCount)\n\n            const addressPrefix =\n                ((addressSegments[i] && parseInt(addressSegments[i], 16)) || 0) >>\n                (16 - bitCount)\n\n            if (subnetPrefix !== addressPrefix) {\n                return false\n            }\n        }\n\n        return true\n    }\n}\n\n// cache these special subnet checkers\nconst specialNetsCache: Record<string, (address: string) => boolean> = {}\n\n/** Test if the given IP address is a private/internal IP address. */\nexport function isPrivate (address: string) {\n    if (!('private' in specialNetsCache)) {\n        specialNetsCache['private'] = createChecker(ipRanges.private.ipv6)\n    }\n    return specialNetsCache['private'](address)\n}\n\n/** Test if the given IP address is a localhost address. */\nexport function isLocalhost (address: string) {\n    if (!('localhost' in specialNetsCache)) {\n        specialNetsCache['localhost'] = createChecker(ipRanges.localhost.ipv6)\n    }\n    return specialNetsCache['localhost'](address)\n}\n\n/** Test if the given IP address is an IPv4 address mapped onto IPv6 */\nexport function isIPv4MappedAddress (address: string) {\n    if (!('mapped' in specialNetsCache)) {\n        specialNetsCache['mapped'] = createChecker('::ffff:0:0/96')\n    }\n    if (specialNetsCache['mapped'](address)) {\n        const matches = address.match(mappedIpv4)\n        return Boolean(matches && util.isIPv4(matches[2]))\n    }\n    return false\n}\n\n/** Test if the given IP address is in a known reserved range and not a normal host IP */\nexport function isReserved (address: string) {\n    if (!('reserved' in specialNetsCache)) {\n        specialNetsCache['reserved'] = createChecker(ipRanges.reserved.ipv6)\n    }\n    return specialNetsCache['reserved'](address)\n}\n\n/**\n * Test if the given IP address is a special address of any kind (private, reserved,\n * localhost)\n */\nexport function isSpecial (address: string) {\n    if (!('special' in specialNetsCache)) {\n        specialNetsCache['special'] = createChecker([\n            ...ipRanges.private.ipv6,\n            ...ipRanges.localhost.ipv6,\n            ...ipRanges.reserved.ipv6,\n        ])\n    }\n    return specialNetsCache['special'](address)\n}","import * as IPv4 from './ipv4'\nimport * as IPv6 from './ipv6'\nimport * as util from './utils'\n\nexport { isIP, isIPv4, isIPv6 } from './utils'\nexport { IPv4, IPv6 }\n\n/**\n * Test if the given IP address is contained in the specified subnet.\n * @param address the IPv4 or IPv6 address to check\n * @param subnetOrSubnets the IPv4 or IPv6 CIDR to test (or an array of them)\n * @throws if any of the address or subnet(s) are not valid IP addresses, or the CIDR\n *  prefix length is not valid\n */\nexport function isInSubnet (address: string, subnetOrSubnets: string | string[]): boolean {\n    return createChecker(subnetOrSubnets)(address)\n}\n/**\n * Create a function to test if the given IP address is contained in the specified subnet.\n * @param subnetOrSubnets the IPv4 or IPv6 CIDR to test (or an array of them)\n * @throws if any of the subnet(s) are not valid IP addresses, or the CIDR\n *  prefix length is not valid\n */\nexport function createChecker (\n    subnetOrSubnets: string | string[]\n): (address: string) => boolean {\n    if (!Array.isArray(subnetOrSubnets)) {\n        return createChecker([subnetOrSubnets])\n    }\n\n    const subnetsByVersion = subnetOrSubnets.reduce(\n        (acc, subnet) => {\n            const ip = subnet.split('/')[0];\n            (acc[util.isIP(ip)] as string[]).push(subnet)\n            return acc\n        },\n        { 0: [], 4: [], 6: [] }\n    )\n\n    if (subnetsByVersion[0].length !== 0) {\n        throw new Error(`some subnets are not valid IP addresses: ${subnetsByVersion[0]}`)\n    }\n\n    const check4 = IPv4.createChecker(subnetsByVersion[4])\n    const check6 = IPv6.createChecker(subnetsByVersion[6])\n\n    return address => {\n        if (!util.isIP(address)) {\n            throw new Error(`not a valid IPv4 or IPv6 address: ${address}`)\n        }\n\n        // for mapped IPv4 addresses, compare against both IPv6 and IPv4 subnets\n        if (util.isIPv6(address) && IPv6.isIPv4MappedAddress(address)) {\n            return check6(address) || check4(IPv6.extractMappedIpv4(address))\n        }\n\n        if (util.isIPv6(address)) {\n            return check6(address)\n        } else {\n            return check4(address)\n        }\n    }\n}\n\n/** Test if the given IP address is a private/internal IP address. */\nexport function isPrivate (address: string) {\n    if (util.isIPv6(address)) {\n        if (IPv6.isIPv4MappedAddress(address)) {\n            return IPv4.isPrivate(IPv6.extractMappedIpv4(address))\n        }\n        return IPv6.isPrivate(address)\n    } else {\n        return IPv4.isPrivate(address)\n    }\n}\n\n/** Test if the given IP address is a localhost address. */\nexport function isLocalhost (address: string) {\n    if (util.isIPv6(address)) {\n        if (IPv6.isIPv4MappedAddress(address)) {\n            return IPv4.isLocalhost(IPv6.extractMappedIpv4(address))\n        }\n        return IPv6.isLocalhost(address)\n    } else {\n        return IPv4.isLocalhost(address)\n    }\n}\n\n/** Test if the given IP address is an IPv4 address mapped onto IPv6 */\nexport function isIPv4MappedAddress (address: string) {\n    if (util.isIPv6(address)) {\n        return IPv6.isIPv4MappedAddress(address)\n    } else {\n        return false\n    }\n}\n\n/** Test if the given IP address is in a known reserved range and not a normal host IP */\nexport function isReserved (address: string) {\n    if (util.isIPv6(address)) {\n        if (IPv6.isIPv4MappedAddress(address)) {\n            return IPv4.isReserved(IPv6.extractMappedIpv4(address))\n        }\n        return IPv6.isReserved(address)\n    } else {\n        return IPv4.isReserved(address)\n    }\n}\n\n/**\n * Test if the given IP address is a special address of any kind (private, reserved,\n * localhost)\n */\nexport function isSpecial (address: string) {\n    if (util.isIPv6(address)) {\n        if (IPv6.isIPv4MappedAddress(address)) {\n            return IPv4.isSpecial(IPv6.extractMappedIpv4(address))\n        }\n        return IPv6.isSpecial(address)\n    } else {\n        return IPv4.isSpecial(address)\n    }\n}\n\nexport const check = isInSubnet"],"mappings":"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","names":["check","createChecker","isInSubnet","isLocalhost","isPrivate","isReserved","isSpecial","isInSubnet","createChecker","check","specialNetsCache","isPrivate","isLocalhost","isReserved","isSpecial","isInSubnet","createChecker","isPrivate","isLocalhost","isIPv4MappedAddress","isReserved","isSpecial"]}