rdapify 0.3.0 → 0.3.2

package/dist/esm/shared/errors/base.error.js

@@ -0,0 +1,140 @@
+export class RDAPifyError extends Error {
+    constructor(message, code, statusCode, context, suggestion) {
+        super(message);
+        this.name = this.constructor.name;
+        this.code = code;
+        this.statusCode = statusCode;
+        this.context = context;
+        this.timestamp = Date.now();
+        this.suggestion = suggestion;
+        this.queryType = context?.['queryType'];
+        this.queryValue = context?.['queryValue'];
+        this.serverUrl = context?.['serverUrl'];
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            code: this.code,
+            message: this.message,
+            statusCode: this.statusCode,
+            context: this.context,
+            timestamp: this.timestamp,
+            suggestion: this.suggestion,
+            queryType: this.queryType,
+            queryValue: this.queryValue,
+            serverUrl: this.serverUrl,
+        };
+    }
+    getUserMessage() {
+        const parts = [this.message];
+        if (this.suggestion) {
+            parts.push(`Suggestion: ${this.suggestion}`);
+        }
+        return parts.join('. ');
+    }
+    getDetailedMessage() {
+        const parts = [this.message];
+        if (this.queryType && this.queryValue) {
+            parts.push(`Query: ${this.queryType} ${this.queryValue}`);
+        }
+        if (this.serverUrl) {
+            parts.push(`Server: ${this.serverUrl}`);
+        }
+        if (this.suggestion) {
+            parts.push(`Suggestion: ${this.suggestion}`);
+        }
+        return parts.join('. ');
+    }
+}
+export class ValidationError extends RDAPifyError {
+    constructor(message, context, suggestion) {
+        super(message, 'VALIDATION_ERROR', 400, context, suggestion || 'Please check your input and try again');
+    }
+}
+export class ConfigurationError extends RDAPifyError {
+    constructor(message, context, suggestion) {
+        super(message, 'CONFIGURATION_ERROR', 400, context, suggestion || 'Please check your configuration and try again');
+    }
+}
+export class NetworkError extends RDAPifyError {
+    constructor(message, statusCode, context, suggestion) {
+        super(message, 'NETWORK_ERROR', statusCode || 500, context, suggestion || 'Check your network connection and try again');
+    }
+}
+export class TimeoutError extends RDAPifyError {
+    constructor(message, context, suggestion) {
+        super(message, 'TIMEOUT_ERROR', 408, context, suggestion || 'The request took too long. Try increasing the timeout or check the server status');
+    }
+}
+export class RDAPServerError extends RDAPifyError {
+    constructor(message, statusCode, context, suggestion) {
+        const defaultSuggestion = statusCode === 404
+            ? 'The requested resource was not found. Verify the domain/IP/ASN exists'
+            : statusCode === 429
+                ? 'Rate limit exceeded. Wait a moment before retrying'
+                : statusCode >= 500
+                    ? 'The RDAP server is experiencing issues. Try again later'
+                    : 'Check the RDAP server status and try again';
+        super(message, 'RDAP_SERVER_ERROR', statusCode, context, suggestion || defaultSuggestion);
+    }
+}
+export class NoServerFoundError extends RDAPifyError {
+    constructor(message, context) {
+        super(message, 'NO_SERVER_FOUND', 404, context);
+    }
+}
+export class ParseError extends RDAPifyError {
+    constructor(message, context) {
+        super(message, 'PARSE_ERROR', 500, context);
+    }
+}
+export class CacheError extends RDAPifyError {
+    constructor(message, context) {
+        super(message, 'CACHE_ERROR', 500, context);
+    }
+}
+export class RateLimitError extends RDAPifyError {
+    constructor(message, context, retryAfter) {
+        const suggestion = retryAfter
+            ? `Rate limit exceeded. Retry after ${retryAfter}ms`
+            : 'Rate limit exceeded. Slow down your requests';
+        super(message, 'RATE_LIMIT_ERROR', 429, context, suggestion);
+        this.retryAfter = retryAfter;
+    }
+}
+export class SSRFProtectionError extends RDAPifyError {
+    constructor(message, context) {
+        super(message, 'SSRF_PROTECTION_ERROR', 403, context);
+    }
+}
+export class SearchNotSupportedError extends RDAPifyError {
+    constructor(message, context) {
+        super(message, 'SEARCH_NOT_SUPPORTED', 404, context);
+    }
+}
+export class QueryAbortedError extends RDAPifyError {
+    constructor(query) {
+        super(query ? `Query aborted by middleware: ${query}` : 'Query aborted by middleware', 'QUERY_ABORTED', 0);
+    }
+}
+export function isRDAPifyError(error) {
+    return error instanceof RDAPifyError;
+}
+export function isSSRFProtectionError(error) {
+    return error instanceof SSRFProtectionError;
+}
+export function isNetworkError(error) {
+    return error instanceof NetworkError;
+}
+export function isTimeoutError(error) {
+    return error instanceof TimeoutError;
+}
+export function isRateLimitError(error) {
+    return error instanceof RateLimitError;
+}
+export function isConfigurationError(error) {
+    return error instanceof ConfigurationError;
+}

package/dist/esm/shared/errors/index.js

@@ -0,0 +1 @@
+export * from './base.error';

package/dist/esm/shared/types/entities.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/shared/types/enums.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/shared/types/errors.js

@@ -0,0 +1,82 @@
+export class RDAPifyError extends Error {
+    constructor(message, code, statusCode, details) {
+        super(message);
+        this.name = 'RDAPifyError';
+        this.code = code;
+        this.statusCode = statusCode;
+        this.details = details;
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+}
+export class SSRFProtectionError extends RDAPifyError {
+    constructor(message, details) {
+        super(message, 'SSRF_PROTECTION', 403, details);
+        this.name = 'SSRFProtectionError';
+    }
+}
+export class NetworkError extends RDAPifyError {
+    constructor(message, statusCode, details) {
+        super(message, 'NETWORK_ERROR', statusCode, details);
+        this.name = 'NetworkError';
+    }
+}
+export class TimeoutError extends RDAPifyError {
+    constructor(message, details) {
+        super(message, 'TIMEOUT', 408, details);
+        this.name = 'TimeoutError';
+    }
+}
+export class RDAPServerError extends RDAPifyError {
+    constructor(message, statusCode, details) {
+        super(message, 'RDAP_SERVER_ERROR', statusCode, details);
+        this.name = 'RDAPServerError';
+    }
+}
+export class NoServerFoundError extends RDAPifyError {
+    constructor(message, details) {
+        super(message, 'NO_SERVER_FOUND', 404, details);
+        this.name = 'NoServerFoundError';
+    }
+}
+export class ValidationError extends RDAPifyError {
+    constructor(message, details) {
+        super(message, 'VALIDATION_ERROR', 400, details);
+        this.name = 'ValidationError';
+    }
+}
+export class ParseError extends RDAPifyError {
+    constructor(message, details) {
+        super(message, 'PARSE_ERROR', 500, details);
+        this.name = 'ParseError';
+    }
+}
+export class CacheError extends RDAPifyError {
+    constructor(message, details) {
+        super(message, 'CACHE_ERROR', 500, details);
+        this.name = 'CacheError';
+    }
+}
+export class RateLimitError extends RDAPifyError {
+    constructor(message, retryAfter, details) {
+        super(message, 'RATE_LIMIT_EXCEEDED', 429, details);
+        this.name = 'RateLimitError';
+        this.retryAfter = retryAfter;
+    }
+}
+export function isRDAPifyError(error) {
+    return error instanceof RDAPifyError;
+}
+export function isSSRFProtectionError(error) {
+    return error instanceof SSRFProtectionError;
+}
+export function isNetworkError(error) {
+    return error instanceof NetworkError;
+}
+export function isTimeoutError(error) {
+    return error instanceof TimeoutError;
+}
+export function isRateLimitError(error) {
+    return error instanceof RateLimitError;
+}

package/dist/esm/shared/types/generics.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/shared/types/index.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/shared/types/options.js

@@ -0,0 +1,66 @@
+export const DEFAULT_OPTIONS = {
+    cache: {
+        strategy: 'memory',
+        ttl: 3600,
+        maxSize: 1000,
+    },
+    retry: {
+        maxAttempts: 3,
+        initialDelay: 1000,
+        maxDelay: 10000,
+        backoff: 'exponential',
+        retryableStatusCodes: [408, 429, 500, 502, 503, 504],
+    },
+    ssrfProtection: {
+        enabled: true,
+        blockPrivateIPs: true,
+        blockLocalhost: true,
+        blockLinkLocal: true,
+        blockedDomains: [],
+        allowedDomains: [],
+        dnsRebinding: false,
+    },
+    privacy: {
+        redactPII: true,
+        redactFields: ['email', 'phone', 'fax'],
+        redactionText: '[REDACTED]',
+    },
+    timeout: {
+        connect: 5000,
+        request: 10000,
+        dns: 3000,
+    },
+    logging: {
+        level: 'warn',
+    },
+    rateLimit: {
+        enabled: false,
+        maxRequests: 100,
+        windowMs: 60000,
+    },
+    debug: {
+        enabled: false,
+    },
+    userAgent: 'RDAPify/0.1.8 (https://rdapify.com)',
+    includeRaw: false,
+    followRedirects: true,
+    maxRedirects: 5,
+    headers: {},
+    bootstrapUrl: 'https://data.iana.org/rdap',
+    middleware: {},
+    deduplication: false,
+    backend: 'auto',
+    bootstrap: {
+        customServers: [],
+        ttl: 86400,
+        fallback: true,
+    },
+    http2: false,
+    telemetry: {
+        enabled: false,
+    },
+    signal: undefined,
+    usageTelemetry: {
+        enabled: false,
+    },
+};

package/dist/esm/shared/types/responses.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/shared/utils/deprecation.js

@@ -0,0 +1,20 @@
+const emitted = new Set();
+export function deprecated(name, alternative, code) {
+    const depCode = code ?? `DEP_RDAPIFY_${name.toUpperCase().replace(/[^A-Z0-9]/g, '_')}`;
+    if (emitted.has(depCode))
+        return;
+    emitted.add(depCode);
+    const msg = alternative
+        ? `${name} is deprecated and will be removed in a future major release. Use ${alternative} instead.`
+        : `${name} is deprecated and will be removed in a future major release.`;
+    if (typeof process !== 'undefined' &&
+        typeof process['emitWarning'] === 'function') {
+        process.emitWarning(msg, { type: 'DeprecationWarning', code: depCode });
+    }
+    else {
+        console.warn(`[rdapify DeprecationWarning] ${depCode}: ${msg}`);
+    }
+}
+export function _resetDeprecationState() {
+    emitted.clear();
+}

package/dist/esm/shared/utils/enhanced-validators.js

@@ -0,0 +1,148 @@
+import { ValidationError } from '../errors';
+export function idnToAscii(domain) {
+    try {
+        const url = new URL(`http://${domain}`);
+        return url.hostname;
+    }
+    catch {
+        return domain;
+    }
+}
+export function asciiToIdn(domain) {
+    try {
+        if (domain.includes('xn--')) {
+            const url = new URL(`http://${domain}`);
+            return url.hostname;
+        }
+        return domain;
+    }
+    catch {
+        return domain;
+    }
+}
+export function validateIdnDomain(domain) {
+    if (!domain || typeof domain !== 'string') {
+        throw new ValidationError('Domain must be a non-empty string', {
+            suggestion: 'Provide a valid domain name',
+        });
+    }
+    domain = domain.trim();
+    if (/[\s<>]/.test(domain)) {
+        throw new ValidationError('Domain contains invalid characters', {
+            suggestion: 'Remove spaces and special characters',
+        });
+    }
+    const asciiDomain = idnToAscii(domain);
+    const domainRegex = /^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)*[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/i;
+    if (!domainRegex.test(asciiDomain)) {
+        throw new ValidationError(`Invalid domain format: ${domain}`, {
+            suggestion: 'Provide a valid domain name (e.g., example.com)',
+        });
+    }
+    return asciiDomain.toLowerCase();
+}
+export function validateIpv6WithZone(ip) {
+    if (!ip || typeof ip !== 'string') {
+        throw new ValidationError('IP address must be a non-empty string', {
+            suggestion: 'Provide a valid IPv6 address',
+        });
+    }
+    const zoneMatch = ip.match(/^([0-9a-f:]+)%(.+)$/i);
+    if (zoneMatch) {
+        const ipPart = zoneMatch[1];
+        const zonePart = zoneMatch[2];
+        if (!ipPart || !zonePart) {
+            throw new ValidationError(`Invalid IPv6 format: ${ip}`, {
+                suggestion: 'Provide a valid IPv6 address',
+            });
+        }
+        const ipv6Regex = /^(([0-9a-f]{1,4}:){7}[0-9a-f]{1,4}|([0-9a-f]{1,4}:){1,7}:|([0-9a-f]{1,4}:){1,6}:[0-9a-f]{1,4}|([0-9a-f]{1,4}:){1,5}(:[0-9a-f]{1,4}){1,2}|([0-9a-f]{1,4}:){1,4}(:[0-9a-f]{1,4}){1,3}|([0-9a-f]{1,4}:){1,3}(:[0-9a-f]{1,4}){1,4}|([0-9a-f]{1,4}:){1,2}(:[0-9a-f]{1,4}){1,5}|[0-9a-f]{1,4}:((:[0-9a-f]{1,4}){1,6})|:((:[0-9a-f]{1,4}){1,7}|:))$/i;
+        if (!ipv6Regex.test(ipPart)) {
+            throw new ValidationError(`Invalid IPv6 address: ${ipPart}`, {
+                suggestion: 'Provide a valid IPv6 address',
+            });
+        }
+        return {
+            ip: ipPart.toLowerCase(),
+            zone: zonePart,
+        };
+    }
+    const ipv6Regex = /^(([0-9a-f]{1,4}:){7}[0-9a-f]{1,4}|([0-9a-f]{1,4}:){1,7}:|([0-9a-f]{1,4}:){1,6}:[0-9a-f]{1,4}|([0-9a-f]{1,4}:){1,5}(:[0-9a-f]{1,4}){1,2}|([0-9a-f]{1,4}:){1,4}(:[0-9a-f]{1,4}){1,3}|([0-9a-f]{1,4}:){1,3}(:[0-9a-f]{1,4}){1,4}|([0-9a-f]{1,4}:){1,2}(:[0-9a-f]{1,4}){1,5}|[0-9a-f]{1,4}:((:[0-9a-f]{1,4}){1,6})|:((:[0-9a-f]{1,4}){1,7}|:))$/i;
+    if (!ipv6Regex.test(ip)) {
+        throw new ValidationError(`Invalid IPv6 address: ${ip}`, {
+            suggestion: 'Provide a valid IPv6 address',
+        });
+    }
+    return { ip: ip.toLowerCase() };
+}
+export function validateAsnRange(asn) {
+    const asnStr = typeof asn === 'number' ? asn.toString() : asn;
+    const rangeMatch = asnStr.match(/^(?:AS)?(\d+)-(?:AS)?(\d+)$/i);
+    if (rangeMatch) {
+        const startStr = rangeMatch[1];
+        const endStr = rangeMatch[2];
+        if (!startStr || !endStr) {
+            throw new ValidationError(`Invalid ASN range format: ${asnStr}`, {
+                suggestion: 'Provide a valid ASN range',
+            });
+        }
+        const start = parseInt(startStr, 10);
+        const end = parseInt(endStr, 10);
+        if (start < 0 || start > 4294967295) {
+            throw new ValidationError(`Invalid ASN start: ${start}`, {
+                suggestion: 'ASN must be between 0 and 4294967295',
+            });
+        }
+        if (end < 0 || end > 4294967295) {
+            throw new ValidationError(`Invalid ASN end: ${end}`, {
+                suggestion: 'ASN must be between 0 and 4294967295',
+            });
+        }
+        if (start >= end) {
+            throw new ValidationError(`Invalid ASN range: start (${start}) must be less than end (${end})`, {
+                suggestion: 'Provide a valid ASN range',
+            });
+        }
+        return { start, end };
+    }
+    const asnMatch = asnStr.match(/^(?:AS)?(\d+)$/i);
+    if (!asnMatch || !asnMatch[1]) {
+        throw new ValidationError(`Invalid ASN format: ${asnStr}`, {
+            suggestion: 'Provide a valid ASN (e.g., 15169 or AS15169)',
+        });
+    }
+    const asnNumber = parseInt(asnMatch[1], 10);
+    if (asnNumber < 0 || asnNumber > 4294967295) {
+        throw new ValidationError(`Invalid ASN: ${asnNumber}`, {
+            suggestion: 'ASN must be between 0 and 4294967295',
+        });
+    }
+    return { start: asnNumber };
+}
+export function isIdnDomain(domain) {
+    return /[^\x00-\x7F]/.test(domain);
+}
+export function isPunycodeDomain(domain) {
+    return domain.includes('xn--');
+}
+export function validateEmail(email) {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(email);
+}
+export function validatePhone(phone) {
+    const cleaned = phone.replace(/[\s\-().]/g, '');
+    const phoneRegex = /^\+?\d{10,15}$/;
+    return phoneRegex.test(cleaned);
+}
+export function normalizeWhitespace(str) {
+    return str.trim().replace(/\s+/g, ' ');
+}
+export function validateUrl(url) {
+    try {
+        new URL(url);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/esm/shared/utils/helpers/async.js

@@ -0,0 +1,40 @@
+export function calculateBackoff(attempt, strategy, initialDelay, maxDelay) {
+    let delay;
+    switch (strategy) {
+        case 'linear':
+            delay = initialDelay * attempt;
+            break;
+        case 'exponential':
+            delay = initialDelay * Math.pow(2, attempt - 1);
+            break;
+        case 'fixed':
+        default:
+            delay = initialDelay;
+            break;
+    }
+    return Math.min(delay, maxDelay);
+}
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export function createTimeout(ms, message) {
+    let timeoutId;
+    const promise = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => {
+            reject(new Error(message || `Operation timed out after ${ms}ms`));
+        }, ms);
+    });
+    return {
+        promise,
+        cancel: () => clearTimeout(timeoutId),
+    };
+}
+export async function withTimeout(promise, timeoutMs, timeoutMessage) {
+    const timeout = createTimeout(timeoutMs, timeoutMessage);
+    try {
+        return await Promise.race([promise, timeout.promise]);
+    }
+    finally {
+        timeout.cancel();
+    }
+}

package/dist/esm/shared/utils/helpers/cache.js

@@ -0,0 +1,3 @@
+export function generateCacheKey(type, query) {
+    return `rdap:${type}:${query.toLowerCase()}`;
+}

package/dist/esm/shared/utils/helpers/format.js

@@ -0,0 +1,17 @@
+export function formatBytes(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+}
+export function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60000)
+        return `${(ms / 1000).toFixed(2)}s`;
+    if (ms < 3600000)
+        return `${(ms / 60000).toFixed(2)}m`;
+    return `${(ms / 3600000).toFixed(2)}h`;
+}

package/dist/esm/shared/utils/helpers/http.js

@@ -0,0 +1,13 @@
+export function parseRetryAfter(value) {
+    if (!value)
+        return undefined;
+    const seconds = parseInt(value, 10);
+    if (!isNaN(seconds)) {
+        return seconds * 1000;
+    }
+    const date = new Date(value);
+    if (!isNaN(date.getTime())) {
+        return Math.max(0, date.getTime() - Date.now());
+    }
+    return undefined;
+}

package/dist/esm/shared/utils/helpers/index.js

@@ -0,0 +1,7 @@
+export { calculateBackoff, sleep, createTimeout, withTimeout } from './async';
+export { extractTLD, sanitizeUrl, truncate } from './string';
+export { isPlainObject, deepMerge } from './object';
+export { generateCacheKey } from './cache';
+export { parseRetryAfter } from './http';
+export { formatBytes, formatDuration } from './format';
+export { isNode, isBrowser, isDeno, isBun, isCloudflareWorkers, getRuntimeName } from './runtime';

package/dist/esm/shared/utils/helpers/object.js

@@ -0,0 +1,19 @@
+export function isPlainObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+export function deepMerge(target, source) {
+    const result = { ...target };
+    for (const key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+            const sourceValue = source[key];
+            const targetValue = result[key];
+            if (isPlainObject(sourceValue) && isPlainObject(targetValue)) {
+                result[key] = deepMerge(targetValue, sourceValue);
+            }
+            else {
+                result[key] = sourceValue;
+            }
+        }
+    }
+    return result;
+}

package/dist/esm/shared/utils/helpers/runtime.js

@@ -0,0 +1,34 @@
+export function isNode() {
+    return (typeof process !== 'undefined' &&
+        process.versions?.node != null);
+}
+export function isBrowser() {
+    return typeof globalThis !== 'undefined' &&
+        'window' in globalThis &&
+        typeof globalThis.window !== 'undefined';
+}
+export function isDeno() {
+    return typeof globalThis !== 'undefined' && 'Deno' in globalThis;
+}
+export function isBun() {
+    return typeof globalThis !== 'undefined' && 'Bun' in globalThis;
+}
+export function isCloudflareWorkers() {
+    return (typeof globalThis !== 'undefined' &&
+        'caches' in globalThis &&
+        typeof globalThis.navigator !== 'undefined' &&
+        globalThis.navigator?.userAgent === 'Cloudflare-Workers');
+}
+export function getRuntimeName() {
+    if (isDeno())
+        return 'Deno';
+    if (isBun())
+        return 'Bun';
+    if (isCloudflareWorkers())
+        return 'Cloudflare Workers';
+    if (isNode())
+        return 'Node.js';
+    if (isBrowser())
+        return 'Browser';
+    return 'Unknown';
+}

package/dist/esm/shared/utils/helpers/string.js

@@ -0,0 +1,23 @@
+export function extractTLD(domain) {
+    const parts = domain.split('.');
+    const tld = parts[parts.length - 1];
+    if (!tld) {
+        throw new Error('Invalid domain: no TLD found');
+    }
+    return tld;
+}
+export function sanitizeUrl(url) {
+    try {
+        const parsed = new URL(url);
+        parsed.search = '';
+        return parsed.toString();
+    }
+    catch {
+        return '[invalid-url]';
+    }
+}
+export function truncate(str, maxLength) {
+    if (str.length <= maxLength)
+        return str;
+    return str.substring(0, maxLength - 3) + '...';
+}

package/dist/esm/shared/utils/validators/asn.js

@@ -0,0 +1,25 @@
+import { ValidationError } from '../../types/errors';
+export function validateASN(asn) {
+    let asnNumber;
+    if (typeof asn === 'string') {
+        const cleaned = asn.trim().replace(/^AS/i, '');
+        asnNumber = parseInt(cleaned, 10);
+    }
+    else if (typeof asn === 'number') {
+        asnNumber = asn;
+    }
+    else {
+        throw new ValidationError('ASN must be a string or number');
+    }
+    if (isNaN(asnNumber)) {
+        throw new ValidationError(`Invalid ASN format: ${asn}`);
+    }
+    if (asnNumber < 0 || asnNumber > 4294967295) {
+        throw new ValidationError(`ASN out of valid range (0-4294967295): ${asnNumber}`);
+    }
+    return asnNumber;
+}
+export function normalizeASN(asn) {
+    const asnNumber = validateASN(asn);
+    return `AS${asnNumber}`;
+}