mybase 1.2.3 → 2.0.1

package/dist/ip6addr.js

@@ -0,0 +1,752 @@
+"use strict";
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddrRange = exports.CIDR = exports.Addr = void 0;
+//#endregion
+//#region helpers
+class ParseError extends Error {
+    constructor(input, message, index) {
+        super(index !== undefined ? `${message} at index ${index}` : message);
+        this.name = 'ParseError';
+        this.input = input;
+    }
+}
+function modulo(a, n) {
+    return (n + (a % n)) % n;
+}
+function _arrayToOctetString(input) {
+    let out = (input[0] >> 8) + '.' + (input[0] & 0xff) + '.';
+    out += (input[1] >> 8) + '.' + (input[1] & 0xff);
+    return out;
+}
+function _isAddr(addr) {
+    if (typeof addr === 'object' && addr !== null) {
+        /* It must resemble an Addr object */
+        const candidate = addr;
+        if (Array.isArray(candidate._fields) && typeof candidate._attrs === 'object') {
+            return true;
+        }
+    }
+    return false;
+}
+function _toAddr(input) {
+    if (typeof input === 'string') {
+        return ip6addrParse(input);
+    }
+    else if (_isAddr(input)) {
+        return input;
+    }
+    else {
+        throw new Error('Invalid argument: Addr or parsable string expected');
+    }
+}
+function _arrayToHex(input, zeroElide, zeroPad) {
+    let i;
+    let elStart = null;
+    let elLen = 0;
+    if (zeroElide) {
+        /* find longest run of zeroes to potentially elide */
+        let start = null;
+        let len = 0;
+        for (i = 0; i < input.length; i++) {
+            if (input[i] === 0) {
+                if (start === null) {
+                    start = i;
+                    len = 1;
+                }
+                else {
+                    len++;
+                }
+            }
+            else if (start !== null) {
+                if (len > elLen) {
+                    elStart = start;
+                    elLen = len;
+                }
+                start = null;
+            }
+        }
+        /* capturing last potential zero */
+        if (start !== null && len > elLen) {
+            elStart = start;
+            elLen = len;
+        }
+    }
+    const output = [];
+    let num;
+    for (i = 0; i < input.length; i++) {
+        if (elStart !== null) {
+            if (i === elStart) {
+                if (elLen === 8) {
+                    /* all-zeroes is just '::' */
+                    return ['::'];
+                }
+                else if (elStart === 0 || elStart + elLen === input.length) {
+                    /*
+                     * For elided zeroes at the beginning/end of the address, an extra
+                     * ':' is needed during the join step.
+                     */
+                    output.push(':');
+                }
+                else {
+                    output.push('');
+                }
+            }
+            if (i >= elStart && i < elStart + elLen) {
+                continue;
+            }
+        }
+        num = input[i].toString(16);
+        if (zeroPad && num.length != 4) {
+            num = '0000'.slice(num.length) + num;
+        }
+        output.push(num);
+    }
+    return output;
+}
+function _ipv4Mapped(input) {
+    const comp = [0, 0, 0, 0, 0, 0xffff];
+    for (let i = 0; i < 6; i++) {
+        if (input[i] != comp[i])
+            return false;
+    }
+    return true;
+}
+function _prefixToAddr(len) {
+    len = len | 0;
+    if (len < 0 || len > 128) {
+        throw new Error('prefix length must be between 0 and 128');
+    }
+    const output = new Addr();
+    let i;
+    for (i = 0; len > 16; i++, len -= 16) {
+        output._fields[i] = 0xffff;
+    }
+    if (len > 0) {
+        output._fields[i] = 0xffff - ((1 << (16 - len)) - 1);
+    }
+    return output;
+}
+function _toCIDR(input) {
+    if (typeof input === 'string') {
+        return new CIDR(input);
+    }
+    else if (input instanceof CIDR) {
+        return input;
+    }
+    else {
+        throw new Error('Invalid argument: CIDR or parsable string expected');
+    }
+}
+const strDefaults = {
+    format: 'auto', // Control format of printed address
+    zeroElide: true, // Elide longest run of zeros
+    zeroPad: false // Pad with zeros when a group would print as < 4 chars
+};
+function getStrOpt(opts, name) {
+    if (opts && Object.prototype.hasOwnProperty.call(opts, name)) {
+        return opts[name];
+    }
+    return strDefaults[name];
+}
+/*
+ * Faithful, minimal replacement for `jsprim.parseInteger(field, { base, allowSign: false })`.
+ * Returns the parsed number, or an Error for empty/invalid input. Sign, prefixes,
+ * and whitespace are all rejected (the input fields are already lower-cased).
+ */
+function parseField(field, base) {
+    if (field.length === 0) {
+        return new Error('empty field');
+    }
+    const valid = base === 16 ? /^[0-9a-f]+$/ : /^[0-9]+$/;
+    if (!valid.test(field)) {
+        return new Error('invalid field');
+    }
+    return parseInt(field, base);
+}
+//#endregion
+//#region Addr
+/**
+ * IPv6/IPv4 address representation.
+ *
+ * It should not be instantiated directly by library consumers.
+ */
+class Addr {
+    constructor() {
+        this._fields = [0, 0, 0, 0, 0, 0, 0, 0];
+        this._attrs = {};
+    }
+    kind() {
+        if (v4subnet.contains(this)) {
+            return 'ipv4';
+        }
+        else {
+            return 'ipv6';
+        }
+    }
+    toString(opts) {
+        if (opts !== undefined && (typeof opts !== 'object' || opts === null)) {
+            throw new Error('opts must be an object');
+        }
+        let format = getStrOpt(opts, 'format');
+        const zeroElide = getStrOpt(opts, 'zeroElide');
+        const zeroPad = getStrOpt(opts, 'zeroPad');
+        if (typeof format !== 'string')
+            throw new Error('opts.format must be a string');
+        if (typeof zeroElide !== 'boolean')
+            throw new Error('opts.zeroElide must be a boolean');
+        if (typeof zeroPad !== 'boolean')
+            throw new Error('opts.zeroPad must be a boolean');
+        // Try to print the address the way it was originally formatted
+        if (format === 'auto') {
+            if (this._attrs.ipv4Bare) {
+                format = 'v4';
+            }
+            else if (this._attrs.ipv4Mapped) {
+                format = 'v4-mapped';
+            }
+            else {
+                format = 'v6';
+            }
+        }
+        switch (format) {
+            // Print in dotted-quad notation (but only if truly IPv4)
+            case 'v4':
+                if (!v4subnet.contains(this)) {
+                    throw new Error('cannot print non-v4 address in dotted quad notation');
+                }
+                return _arrayToOctetString(this._fields.slice(6));
+            // Print as an IPv4-mapped IPv6 address
+            case 'v4-mapped': {
+                if (!v4subnet.contains(this)) {
+                    throw new Error('cannot print non-v4 address as a v4-mapped address');
+                }
+                const output = _arrayToHex(this._fields.slice(0, 6), zeroElide, zeroPad);
+                output.push(_arrayToOctetString(this._fields.slice(6)));
+                return output.join(':');
+            }
+            // Print as an IPv6 address
+            case 'v6':
+                return _arrayToHex(this._fields, zeroElide, zeroPad).join(':');
+            // Unrecognized formatting method
+            default:
+                throw new Error('unrecognized format method "' + format + '"');
+        }
+    }
+    toBuffer(buf) {
+        if (buf !== undefined) {
+            if (!Buffer.isBuffer(buf)) {
+                throw new Error('optional arg must be Buffer');
+            }
+        }
+        else {
+            buf = Buffer.alloc(16);
+        }
+        for (let i = 0; i < 8; i++) {
+            buf.writeUInt16BE(this._fields[i], i * 2);
+        }
+        return buf;
+    }
+    toLong() {
+        if (!v4subnet.contains(this)) {
+            throw new Error('only possible for ipv4-mapped addresses');
+        }
+        return ((this._fields[6] << 16) >>> 0) + this._fields[7];
+    }
+    toBigInt() {
+        const IPV6_OFFSET = BigInt('18446744073709551616'); // 2^64 - otherwise collisions with ipv4
+        if (v4subnet.contains(this)) {
+            // Handle IPv4-mapped IPv6 addresses (32-bit)
+            return (BigInt(this._fields[6]) << BigInt(16)) + BigInt(this._fields[7]);
+        }
+        else {
+            // Handle regular IPv6 addresses (128-bit), with offset
+            let result = BigInt(0);
+            for (let i = 0; i < 8; i++) {
+                result = (result << BigInt(16)) + BigInt(this._fields[i]);
+            }
+            return result + IPV6_OFFSET;
+        }
+    }
+    clone() {
+        const out = new Addr();
+        out._fields = this._fields.slice();
+        for (const k in this._attrs) {
+            out._attrs[k] = this._attrs[k];
+        }
+        return out;
+    }
+    // Returns null when the offset would wrap past the representable range. The
+    // declared `Addr` return keeps call-site chaining ergonomic; the `null` is a
+    // documented runtime outcome callers test for explicitly.
+    offset(num) {
+        if (num < -4294967295 || num > 4294967295) {
+            throw new Error('offsets should be between -4294967295 and 4294967295');
+        }
+        const out = this.clone();
+        let moved;
+        for (let i = 7; i >= 0; i--) {
+            moved = out._fields[i] + num;
+            if (moved > 65535) {
+                num = moved >>> 16;
+                moved = moved & 0xffff;
+            }
+            else if (moved < 0) {
+                num = Math.floor(moved / (1 << 16));
+                moved = modulo(moved, 1 << 16);
+            }
+            else {
+                num = 0;
+            }
+            out._fields[i] = moved;
+            /* Prevent wrap-around for both ipv6 and ipv4-mapped addresses */
+            if (num !== 0) {
+                if ((i === 0) || (i === 6 && this._attrs.ipv4Mapped)) {
+                    return null;
+                }
+            }
+            else {
+                break;
+            }
+        }
+        return out;
+    }
+    and(input) {
+        input = _toAddr(input);
+        const output = this.clone();
+        for (let i = 0; i < 8; i++) {
+            output._fields[i] = output._fields[i] & input._fields[i];
+        }
+        return output;
+    }
+    or(input) {
+        input = _toAddr(input);
+        const output = this.clone();
+        for (let i = 0; i < 8; i++) {
+            output._fields[i] = output._fields[i] | input._fields[i];
+        }
+        return output;
+    }
+    not() {
+        const output = this.clone();
+        for (let i = 0; i < 8; i++) {
+            output._fields[i] = (~output._fields[i]) & 0xffff;
+        }
+        return output;
+    }
+    compare(addr) {
+        return ip6addrCompare(this, addr);
+    }
+}
+exports.Addr = Addr;
+//#endregion
+//#region CIDR
+/**
+ * CIDR Block
+ * @param addr CIDR network address
+ * @param prefixLen Length of network prefix
+ *
+ * The addr parameter can be an Addr object or a parseable string.
+ * If prefixLen is omitted, then addr must contain a parseable string in the
+ * form '<address>/<prefix>'.
+ */
+class CIDR {
+    constructor(addr, prefixLen) {
+        if (prefixLen === undefined) {
+            /* OK to pass pass string of "<addr>/<prefix>" */
+            if (typeof addr !== 'string') {
+                throw new Error('Invalid argument: address string expected');
+            }
+            const fields = addr.match(/^([a-fA-F0-9:.]+)\/([0-9]+)$/);
+            if (fields === null) {
+                throw new Error('Invalid argument: <addr>/<prefix> expected');
+            }
+            addr = fields[1];
+            prefixLen = parseInt(fields[2], 10);
+        }
+        prefixLen = prefixLen | 0;
+        const parsed = _toAddr(addr);
+        /* Expand prefix to ipv6 length of bare ipv4 address provided */
+        if (parsed._attrs.ipv4Bare) {
+            prefixLen += 96;
+        }
+        if (prefixLen < 0 || prefixLen > 128) {
+            throw new Error('Invalid prefix length');
+        }
+        this._prefix = prefixLen;
+        this._mask = _prefixToAddr(prefixLen);
+        this._addr = parsed.and(this._mask);
+    }
+    contains(input) {
+        input = _toAddr(input);
+        return (this._addr.compare(input.and(this._mask)) === 0);
+    }
+    first() {
+        if (this._prefix >= 127) {
+            /* Support single-address and point-to-point networks */
+            return this._addr;
+        }
+        else {
+            return this._addr.offset(1);
+        }
+    }
+    last() {
+        const ending = this._addr.or(this._mask.not());
+        if (this._prefix >= 127) {
+            /* Support single-address and point-to-point networks */
+            return ending;
+        }
+        else {
+            if (this._addr._attrs.ipv4Mapped) {
+                /* don't include the broadcast for ipv4 */
+                return ending.offset(-1);
+            }
+            else {
+                return ending;
+            }
+        }
+    }
+    broadcast() {
+        if (!v4subnet.contains(this._addr)) {
+            throw new Error('Only IPv4 networks have broadcast addresses');
+        }
+        return this._addr.or(this._mask.not());
+    }
+    compare(cidr) {
+        return ip6cidrCompare(this, cidr);
+    }
+    prefixLength(format) {
+        if (format === undefined || format === 'auto') {
+            format = this._addr._attrs.ipv4Bare ? 'v4' : 'v6';
+        }
+        switch (format) {
+            case 'v4':
+                if (!v4subnet.contains(this._addr)) {
+                    throw new Error('cannot return v4 prefix length for non-v4 address');
+                }
+                return this._prefix - 96;
+            case 'v6':
+                return this._prefix;
+            default:
+                throw new Error('unrecognized format method "' + format + '"');
+        }
+    }
+    address() {
+        return this._addr;
+    }
+    toString(opts) {
+        if (opts !== undefined && (typeof opts !== 'object' || opts === null)) {
+            throw new Error('opts must be an object');
+        }
+        let format = getStrOpt(opts, 'format');
+        if (format === 'v4-mapped') {
+            format = 'v6';
+        }
+        return this._addr.toString(opts) + '/' + this.prefixLength(format);
+    }
+}
+exports.CIDR = CIDR;
+//#endregion
+//#region AddrRange
+/**
+ * Range of addresses.
+ * @param begin Beginning address of the range
+ * @param end Ending address of the range
+ *
+ * Parameters can be Addr objects or parsable address strings.
+ */
+class AddrRange {
+    constructor(begin, end) {
+        const b = _toAddr(begin);
+        const e = _toAddr(end);
+        if (b.compare(e) > 0) {
+            throw new Error('begin address must be <= end address');
+        }
+        this._begin = b;
+        this._end = e;
+    }
+    contains(input) {
+        input = _toAddr(input);
+        return (this._begin.compare(input) <= 0 && this._end.compare(input) >= 0);
+    }
+    first() {
+        return this._begin;
+    }
+    last() {
+        return this._end;
+    }
+}
+exports.AddrRange = AddrRange;
+//#endregion
+const v4subnet = new CIDR('::ffff:0:0', 96);
+//#region public functions
+function ip6cidrCompare(a, b) {
+    a = _toCIDR(a);
+    b = _toCIDR(b);
+    /*
+     * We compare first on the address component, and then on the prefix length,
+     * such that the network with the smaller prefix length (the larger subnet)
+     * is greater than the network with the larger prefix (the smaller subnet).
+     * This is the same ordering used in Postgres.
+     */
+    const cmp = ip6addrCompare(a._addr, b._addr);
+    return cmp === 0 ? b._prefix - a._prefix : cmp;
+}
+function ip6addrParse(input) {
+    if (typeof input === 'string') {
+        return parseString(input);
+    }
+    else if (typeof input === 'number') {
+        return parseLong(input);
+    }
+    else if (typeof input === 'bigint') {
+        return parseBigInt(input);
+    }
+    else if (typeof input === 'object' && _isAddr(input)) {
+        return input;
+    }
+    else {
+        throw new Error('Invalid argument: only string|number allowed');
+    }
+}
+function parseString(input) {
+    input = input.toLowerCase();
+    const result = new Addr();
+    let ip6Fields = []; // hold parsed hex fields
+    const ip6Raw = []; // hold unparsed hex fields
+    const ip4Raw = []; // hold unparsed decimal fields
+    let expIndex = null; // field index of '::' delimiter
+    let value = ''; // accumulate unparsed hex/dec field
+    let i;
+    let c;
+    //#region scan characters
+    /*
+     * No valid ipv6 is longer than 39 characters.
+     * An extra character of leeway is there to tolerate some :: funny business.
+     */
+    if (input.length > 40) {
+        throw new ParseError(input, 'Input too long');
+    }
+    for (i = 0; i < input.length; i++) {
+        c = input[i];
+        if (c === ':') {
+            if ((i + 1) < input.length && input[i + 1] === ':') {
+                /*
+                 * Variable length '::' delimiter.
+                 * Multiples would be ambiguous
+                 */
+                if (expIndex !== null) {
+                    throw new ParseError(input, 'Multiple :: delimiters', i);
+                }
+                /*
+                 * The value buffer can be empty for cases where the '::' delimiter is
+                 * the first portion of the address.
+                 */
+                if (value !== '') {
+                    ip6Raw.push(value);
+                    value = '';
+                }
+                expIndex = ip6Raw.length;
+                i++;
+            }
+            else {
+                /*
+                 * Standard ':' delimiter
+                 * The value buffer cannot be empty since that would imply an illegal
+                 * pattern such as ':::' or ':.'.
+                 */
+                if (value === '') {
+                    throw new ParseError(input, 'illegal delimiter', i);
+                }
+                ip6Raw.push(value);
+                value = '';
+            }
+        }
+        else if (c === '.') {
+            /*
+             * Handle dotted quad notation for ipv4 and ipv4-mapped addresses.
+             */
+            ip4Raw.push(value);
+            value = '';
+        }
+        else {
+            value = value + c;
+        }
+    }
+    /* Handle the last stashed value */
+    if (value !== '') {
+        if (ip4Raw.length !== 0) {
+            ip4Raw.push(value);
+        }
+        else {
+            ip6Raw.push(value);
+        }
+        value = '';
+    }
+    else {
+        /* With no stashed value, the address must end with '::'. */
+        if (expIndex !== ip6Raw.length || ip4Raw.length > 0) {
+            throw new ParseError(input, 'Cannot end with delimiter besides ::');
+        }
+    }
+    //#endregion
+    //#region validate field counts
+    /* With values collected, ensure we don't have too many/few */
+    if (ip4Raw.length === 0) {
+        if (ip6Raw.length > 8) {
+            throw new ParseError(input, 'Too many fields');
+        }
+        else if (ip6Raw.length < 8 && expIndex === null) {
+            throw new ParseError(input, 'Too few fields');
+        }
+    }
+    else {
+        if (ip4Raw.length !== 4) {
+            throw new ParseError(input, 'IPv4 portion must have 4 fields');
+        }
+        /* If this is a bare IP address, implicitly convert to IPv4 mapped */
+        if (ip6Raw.length === 0 && expIndex === null) {
+            result._attrs.ipv4Bare = true;
+            ip6Raw.push('ffff');
+            expIndex = 0;
+        }
+        if (ip6Raw.length > 6) {
+            throw new ParseError(input, 'Too many fields');
+        }
+        else if (ip6Raw.length < 6 && expIndex === null) {
+            throw new ParseError(input, 'Too few fields');
+        }
+    }
+    //#endregion
+    //#region parse integer values
+    let num;
+    for (i = 0; i < ip6Raw.length; i++) {
+        num = parseField(ip6Raw[i], 16);
+        if (num instanceof Error || num < 0 || num > 65535) {
+            throw new ParseError(input, 'Invalid field value: ' + ip6Raw[i]);
+        }
+        ip6Fields.push(num);
+    }
+    const ip4Fields = [];
+    for (i = 0; i < ip4Raw.length; i++) {
+        num = parseField(ip4Raw[i], 10);
+        if (num instanceof Error || num < 0 || num > 255) {
+            throw new ParseError(input, 'Invalid field value: ' + ip4Raw[i]);
+        }
+        ip4Fields.push(num);
+    }
+    /* Collapse IPv4 portion, if necessary */
+    if (ip4Fields.length !== 0) {
+        ip6Fields.push((ip4Fields[0] * 256) + ip4Fields[1]);
+        ip6Fields.push((ip4Fields[2] * 256) + ip4Fields[3]);
+    }
+    /* Expand '::' delimiter into implied 0s */
+    if (ip6Fields.length < 8 && expIndex !== null) {
+        const filler = [];
+        for (i = 0; i < (8 - ip6Fields.length); i++) {
+            filler.push(0);
+        }
+        ip6Fields = [
+            ...ip6Fields.slice(0, expIndex),
+            ...filler,
+            ...ip6Fields.slice(expIndex)
+        ];
+    }
+    /*
+     * If dotted-quad notation was used, ensure the input was either a bare ipv4
+     * address or a valid ipv4-mapped address.
+     */
+    if (ip4Fields.length !== 0) {
+        if (!_ipv4Mapped(ip6Fields)) {
+            throw new ParseError(input, 'invalid dotted-quad notation');
+        }
+        else {
+            result._attrs.ipv4Mapped = true;
+        }
+    }
+    result._fields = ip6Fields;
+    //#endregion
+    return result;
+}
+function parseLong(input) {
+    if (input !== Math.floor(input)) {
+        throw new Error('Value must be integer');
+    }
+    if (input < 0 || input > 0xffffffff) {
+        throw new Error('Value must be 32 bit');
+    }
+    const out = new Addr();
+    out._fields[7] = input & 0xffff;
+    out._fields[6] = (input >>> 16);
+    /* this is ipv4-mapped */
+    out._fields[5] = 0xffff;
+    out._attrs.ipv4Bare = true;
+    out._attrs.ipv4Mapped = true;
+    return out;
+}
+function parseBigInt(input) {
+    if (typeof input !== 'bigint') {
+        throw new Error('Input must be a BigInt');
+    }
+    const MAX_IPV4 = BigInt(0xffffffff); // Maximum for IPv4
+    const MAX_IPV6 = (BigInt(1) << BigInt(128)) - BigInt(1); // Maximum for IPv6
+    const IPV6_OFFSET = BigInt('18446744073709551616'); // 2^64
+    if (input < BigInt(0) || input > MAX_IPV6) {
+        throw new Error('Value must be within 128-bit range for IPv6');
+    }
+    const out = new Addr();
+    // Handle IPv4 addresses (32-bit or IPv4-mapped IPv6)
+    if (input <= MAX_IPV4) {
+        out._fields[7] = Number(input & BigInt(0xffff)); // Lower 16 bits
+        out._fields[6] = Number(input >> BigInt(16)); // Upper 16 bits
+        out._fields[5] = 0xffff; // IPv4-mapped marker
+        out._fields[4] = 0; // Leading zero fields for IPv4-mapped IPv6
+        out._fields[3] = 0;
+        out._fields[2] = 0;
+        out._fields[1] = 0;
+        out._fields[0] = 0;
+        out._attrs.ipv4Bare = true;
+        out._attrs.ipv4Mapped = true;
+    }
+    // Handle full IPv6 addresses (128-bit), accounting for the offset
+    else {
+        input = input - IPV6_OFFSET; // Adjust input by removing the IPv6 offset
+        for (let i = 7; i >= 0; i--) {
+            out._fields[i] = Number(input & BigInt(0xffff)); // Extract lower 16 bits for each field
+            input = input >> BigInt(16); // Shift input by 16 bits for the next field
+        }
+        out._attrs.ipv4Mapped = false;
+        out._attrs.ipv4Bare = false;
+    }
+    return out;
+}
+/**
+ * Compare Addr objects in a manner suitable for Array.sort().
+ */
+function ip6addrCompare(a, b) {
+    a = _toAddr(a);
+    b = _toAddr(b);
+    for (let i = 0; i < 8; i++) {
+        if (a._fields[i] < b._fields[i]) {
+            return -1;
+        }
+        else if (a._fields[i] > b._fields[i]) {
+            return 1;
+        }
+    }
+    return 0;
+}
+const ip6addr = {
+    parse: ip6addrParse,
+    compare: ip6addrCompare,
+    createCIDR: (addr, len) => new CIDR(addr, len),
+    compareCIDR: ip6cidrCompare,
+    createAddrRange: (begin, end) => new AddrRange(begin, end)
+};
+exports.default = ip6addr;
+//#endregion
+//# sourceMappingURL=ip6addr.js.map