El problema: programar con IA sin método

/**
 * Acortador de URLs - Módulo sin dependencias que guarda enlaces en memoria
 */

class AcortadorURL {
  constructor() {
    this.enlaces = new Map();
    this.contador = 0;
    this.caracteres = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
  }

  /**
   * Genera un código corto único
   * @returns {string} Código aleatorio de 6 caracteres
   */
  generarCodigo() {
    let codigo;
    do {
      codigo = Array.from({ length: 6 }, () =>
        this.caracteres[Math.floor(Math.random() * this.caracteres.length)]
      ).join('');
    } while (this.enlaces.has(codigo));
    return codigo;
  }

  /**
   * Acorta una URL
   * @param {string} urlOriginal - La URL a acortar
   * @param {string} [codigoCustom] - Código personalizado (opcional)
   * @returns {object} Objeto con la URL acortada y datos del enlace
   * @throws {Error} Si el código personalizado ya existe o la URL es inválida
   */
  acortar(urlOriginal, codigoCustom = null) {
    if (!urlOriginal || typeof urlOriginal !== 'string') {
      throw new Error('URL inválida');
    }

    const codigo = codigoCustom || this.generarCodigo();

    if (this.enlaces.has(codigo)) {
      throw new Error(`El código "${codigo}" ya está en uso`);
    }

    const enlace = {
      codigo,
      urlOriginal,
      urlAcortada: `url.short/${codigo}`,
      creado: new Date().toISOString(),
      accesos: 0
    };

    this.enlaces.set(codigo, enlace);
    return enlace;
  }

  /**
   * Recupera una URL original por su código
   * @param {string} codigo - Código corto
   * @returns {string} La URL original
   * @throws {Error} Si el código no existe
   */
  expandir(codigo) {
    if (!this.enlaces.has(codigo)) {
      throw new Error(`Código "${codigo}" no encontrado`);
    }

    const enlace = this.enlaces.get(codigo);
    enlace.accesos += 1;
    return enlace.urlOriginal;
  }

  /**
   * Obtiene estadísticas de un enlace acortado
   * @param {string} codigo - Código corto
   * @returns {object} Información del enlace
   */
  obtenerEstadisticas(codigo) {
    if (!this.enlaces.has(codigo)) {
      throw new Error(`Código "${codigo}" no encontrado`);
    }
    return { ...this.enlaces.get(codigo) };
  }

  /**
   * Lista todos los enlaces acortados
   * @returns {array} Array de todos los enlaces
   */
  listarEnlaces() {
    return Array.from(this.enlaces.values());
  }

  /**
   * Elimina un enlace acortado
   * @param {string} codigo - Código a eliminar
   * @returns {boolean} True si se eliminó, false si no existe
   */
  eliminar(codigo) {
    return this.enlaces.delete(codigo);
  }

  /**
   * Limpia todos los enlaces
   */
  limpiar() {
    this.enlaces.clear();
  }

  /**
   * Obtiene el total de enlaces almacenados
   * @returns {number} Cantidad de enlaces
   */
  obtenerTotal() {
    return this.enlaces.size;
  }
}

// Exportar para Node.js y navegadores
if (typeof module !== 'undefined' && module.exports) {
  module.exports = AcortadorURL;
}

'use strict';

const ALFABETO = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';

function codificar(n) {
  if (n === 0) return ALFABETO[0];
  let s = '';
  while (n > 0) {
    s = ALFABETO[n % 62] + s;
    n = Math.floor(n / 62);
  }
  return s;
}

function validarUrl(url) {
  if (typeof url !== 'string') throw new TypeError('La URL debe ser una cadena');
  let u;
  try {
    u = new URL(url.trim());
  } catch {
    throw new Error('URL no válida: ' + url);
  }
  if (u.protocol !== 'http:' && u.protocol !== 'https:') {
    throw new Error('Solo se admiten URLs http o https');
  }
  return u.href;
}

class Acortador {
  constructor({ base = 'https://cort.o/', longitudMinima = 4 } = {}) {
    this.base = base.endsWith('/') ? base : base + '/';
    this.longitudMinima = longitudMinima;
    this.porCodigo = new Map(); // codigo -> { url, creado, visitas }
    this.porUrl = new Map(); // url -> codigo
    this.contador = 0;
  }

  _nuevoCodigo() {
    // Contador mezclado con una permutación multiplicativa para que no sea secuencial.
    let codigo;
    do {
      this.contador++;
      const n = (this.contador * 2654435761) % 14776336 + 14776336; // 62^4 .. 2*62^4
      codigo = codificar(n).padStart(this.longitudMinima, '0');
    } while (this.porCodigo.has(codigo));
    return codigo;
  }

  acortar(url, alias) {
    const normalizada = validarUrl(url);
    if (alias !== undefined) {
      if (!/^[\w-]{1,64}$/.test(alias)) throw new Error('Alias no válido');
      const existente = this.porCodigo.get(alias);
      if (existente && existente.url !== normalizada) throw new Error('El alias ya está en uso');
      if (!existente) {
        this.porCodigo.set(alias, { url: normalizada, creado: new Date(), visitas: 0 });
        if (!this.porUrl.has(normalizada)) this.porUrl.set(normalizada, alias);
      }
      return this.base + alias;
    }
    const previo = this.porUrl.get(normalizada);
    if (previo) return this.base + previo;
    const codigo = this._nuevoCodigo();
    this.porCodigo.set(codigo, { url: normalizada, creado: new Date(), visitas: 0 });
    this.porUrl.set(normalizada, codigo);
    return this.base + codigo;
  }

  _codigo(entrada) {
    return entrada.startsWith(this.base) ? entrada.slice(this.base.length) : entrada;
  }

  resolver(entrada) {
    const reg = this.porCodigo.get(this._codigo(entrada));
    if (!reg) return null;
    reg.visitas++;
    return reg.url;
  }

  estadisticas(entrada) {
    const reg = this.porCodigo.get(this._codigo(entrada));
    return reg ? { ...reg } : null;
  }

  eliminar(entrada) {
    const codigo = this._codigo(entrada);
    const reg = this.porCodigo.get(codigo);
    if (!reg) return false;
    this.porCodigo.delete(codigo);
    if (this.porUrl.get(reg.url) === codigo) this.porUrl.delete(reg.url);
    return true;
  }

  get tamaño() {
    return this.porCodigo.size;
  }
}

module.exports = { Acortador };

'use strict';

/**
 * Acortador de URLs en memoria, sin dependencias.
 *
 * Uso:
 *   const { crearAcortador } = require('./acortador');
 *   const acortador = crearAcortador({ base: 'https://ac.or/' });
 *   const { codigo, corta } = acortador.acortar('https://ejemplo.com/una/ruta/larga');
 *   acortador.resolver(codigo); // -> 'https://ejemplo.com/una/ruta/larga'
 */

const ALFABETO = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
const ALIAS_VALIDO = /^[A-Za-z0-9_-]{1,64}$/;

function bytesAleatorios(n) {
  const c = globalThis.crypto;
  if (c && typeof c.getRandomValues === 'function') {
    return c.getRandomValues(new Uint8Array(n));
  }
  const out = new Uint8Array(n);
  for (let i = 0; i < n; i++) out[i] = Math.floor(Math.random() * 256);
  return out;
}

function generarCodigo(longitud) {
  // 248 = 62 * 4: descartamos bytes >= 248 para evitar sesgo de módulo.
  let codigo = '';
  while (codigo.length < longitud) {
    for (const b of bytesAleatorios(longitud * 2)) {
      if (b < 248) codigo += ALFABETO[b % 62];
      if (codigo.length === longitud) break;
    }
  }
  return codigo;
}

function normalizarUrl(url) {
  if (typeof url !== 'string' || url.trim() === '') {
    throw new TypeError('La URL debe ser una cadena no vacía');
  }
  let parsed;
  try {
    parsed = new URL(url.trim());
  } catch {
    throw new TypeError(`URL no válida: ${url}`);
  }
  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
    throw new TypeError(`Protocolo no permitido: ${parsed.protocol}`);
  }
  return parsed.href;
}

function crearAcortador(opciones = {}) {
  const {
    base = '',
    longitud = 7,
    maxIntentos = 10,
    ahora = () => Date.now(),
  } = opciones;

  if (!Number.isInteger(longitud) || longitud < 1) {
    throw new RangeError('La longitud debe ser un entero positivo');
  }

  /** codigo -> { codigo, url, creado, expira, visitas, ultimaVisita } */
  const porCodigo = new Map();
  /** url -> codigo (solo códigos autogenerados y sin caducidad, para reutilizarlos) */
  const porUrl = new Map();

  const caducado = (e) => e.expira !== null && ahora() >= e.expira;

  function vista(e) {
    return { ...e, corta: base + e.codigo };
  }

  function eliminarEntrada(e) {
    porCodigo.delete(e.codigo);
    if (porUrl.get(e.url) === e.codigo) porUrl.delete(e.url);
  }

  function obtenerVigente(codigo) {
    const e = porCodigo.get(codigo);
    if (!e) return null;
    if (caducado(e)) {
      eliminarEntrada(e);
      return null;
    }
    return e;
  }

  /**
   * Acorta una URL.
   * @param {string} url
   * @param {{ alias?: string, ttlMs?: number }} [op]
   * @returns {{ codigo, url, corta, creado, expira, visitas, ultimaVisita }}
   */
  function acortar(url, op = {}) {
    const destino = normalizarUrl(url);
    const { alias, ttlMs } = op;

    if (ttlMs !== undefined && !(Number.isFinite(ttlMs) && ttlMs > 0)) {
      throw new RangeError('ttlMs debe ser un número positivo');
    }
    const expira = ttlMs === undefined ? null : ahora() + ttlMs;

    let codigo;
    if (alias !== undefined) {
      if (typeof alias !== 'string' || !ALIAS_VALIDO.test(alias)) {
        throw new TypeError('Alias no válido (usa 1-64 caracteres: letras, números, "_" o "-")');
      }
      const existente = obtenerVigente(alias);
      if (existente) {
        if (existente.url === destino) return vista(existente);
        throw new Error(`El alias "${alias}" ya está en uso`);
      }
      codigo = alias;
    } else {
      if (expira === null) {
        const previo = porUrl.get(destino);
        const e = previo && obtenerVigente(previo);
        if (e) return vista(e);
      }
      for (let i = 0; i < maxIntentos && !codigo; i++) {
        const candidato = generarCodigo(longitud);
        if (!obtenerVigente(candidato)) codigo = candidato;
      }
      if (!codigo) {
        throw new Error('No se pudo generar un código único; aumenta la longitud');
      }
    }

    const entrada = {
      codigo,
      url: destino,
      creado: ahora(),
      expira,
      visitas: 0,
      ultimaVisita: null,
    };
    porCodigo.set(codigo, entrada);
    if (alias === undefined && expira === null) porUrl.set(destino, codigo);
    return vista(entrada);
  }

  /**
   * Devuelve la URL original y cuenta la visita, o null si no existe o caducó.
   * @param {string} codigo
   * @returns {string|null}
   */
  function resolver(codigo) {
    const e = obtenerVigente(codigo);
    if (!e) return null;
    e.visitas++;
    e.ultimaVisita = ahora();
    return e.url;
  }

  /** Información del enlace sin contar visita, o null. */
  function info(codigo) {
    const e = obtenerVigente(codigo);
    return e ? vista(e) : null;
  }

  /** Elimina un enlace. Devuelve true si existía. */
  function eliminar(codigo) {
    const e = porCodigo.get(codigo);
    if (!e) return false;
    eliminarEntrada(e);
    return true;
  }

  /** Lista los enlaces vigentes. */
  function listar() {
    const res = [];
    for (const e of [...porCodigo.values()]) {
      if (caducado(e)) eliminarEntrada(e);
      else res.push(vista(e));
    }
    return res;
  }

  /** Purga los enlaces caducados y devuelve cuántos se eliminaron. */
  function purgar() {
    let n = 0;
    for (const e of [...porCodigo.values()]) {
      if (caducado(e)) {
        eliminarEntrada(e);
        n++;
      }
    }
    return n;
  }

  /** Vacía el almacén. */
  function limpiar() {
    porCodigo.clear();
    porUrl.clear();
  }

  return {
    acortar,
    resolver,
    info,
    eliminar,
    listar,
    purgar,
    limpiar,
    get tamano() {
      return porCodigo.size;
    },
  };
}

module.exports = { crearAcortador, normalizarUrl, generarCodigo };

'use strict';

/**
 * Acortador de URLs en memoria, sin dependencias.
 *
 * Uso:
 *   const { crearAcortador } = require('./acortador.js');
 *   const acortador = crearAcortador({ base: 'https://ejemplo.com/' });
 *
 *   const enlace = acortador.acortar('https://www.wikipedia.org/wiki/URL');
 *   enlace.codigo;    // p. ej. 'aZ3kP0q'
 *   enlace.urlCorta;  // 'https://ejemplo.com/aZ3kP0q'
 *
 *   acortador.resolver(enlace.codigo); // 'https://www.wikipedia.org/wiki/URL'
 *
 * Los enlaces viven en un Map del proceso: se pierden al reiniciar y no se
 * comparten entre procesos. No hay límite de tamaño ni caducidad.
 */

const ALFABETO = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
const PATRON_ALIAS = /^[A-Za-z0-9_-]{3,32}$/;
const PROTOCOLOS_PERMITIDOS = new Set(['http:', 'https:']);
const INTENTOS_POR_LONGITUD = 10;

/** Devuelve `cantidad` bytes aleatorios; usa Web Crypto si está disponible. */
function bytesAleatorios(cantidad) {
  const bytes = new Uint8Array(cantidad);
  const cripto = globalThis.crypto;
  if (cripto && typeof cripto.getRandomValues === 'function') {
    cripto.getRandomValues(bytes);
  } else {
    // Sin Web Crypto (Node < 19 en CommonJS): códigos válidos pero predecibles.
    for (let i = 0; i < cantidad; i++) bytes[i] = Math.floor(Math.random() * 256);
  }
  return bytes;
}

/** Genera un código base62 de la longitud pedida, sin sesgo de módulo. */
function codigoAleatorio(longitud) {
  // 248 es el mayor múltiplo de 62 que cabe en un byte: se descarta el resto.
  const limite = 256 - (256 % ALFABETO.length);
  let codigo = '';
  while (codigo.length < longitud) {
    for (const byte of bytesAleatorios(longitud * 2)) {
      if (byte >= limite) continue;
      codigo += ALFABETO[byte % ALFABETO.length];
      if (codigo.length === longitud) break;
    }
  }
  return codigo;
}

/** Valida una URL http(s) y la devuelve normalizada. Lanza TypeError si no vale. */
function normalizarUrl(url) {
  if (typeof url !== 'string' || url.trim() === '') {
    throw new TypeError('La URL debe ser una cadena no vacía');
  }
  let analizada;
  try {
    analizada = new URL(url.trim());
  } catch {
    throw new TypeError(`URL no válida: ${url}`);
  }
  if (!PROTOCOLOS_PERMITIDOS.has(analizada.protocol)) {
    throw new TypeError(`Solo se admiten URLs http y https: ${url}`);
  }
  return analizada.href;
}

/**
 * Crea un acortador independiente con su propio almacén en memoria.
 *
 * @param {object} [opciones]
 * @param {string} [opciones.base]      Prefijo de las URLs cortas, p. ej. 'https://ejemplo.com/'.
 * @param {number} [opciones.longitud]  Longitud de los códigos generados (por defecto 7).
 */
function crearAcortador(opciones = {}) {
  const { base = '', longitud = 7 } = opciones;

  if (typeof base !== 'string') {
    throw new TypeError('La opción "base" debe ser una cadena');
  }
  if (!Number.isInteger(longitud) || longitud < 1 || longitud > 64) {
    throw new RangeError('La opción "longitud" debe ser un entero entre 1 y 64');
  }

  const prefijo = base === '' || base.endsWith('/') ? base : `${base}/`;

  /** codigo -> { url, creadoEn, visitas, generado } */
  const enlaces = new Map();
  /** url normalizada -> código generado automáticamente (para no duplicar) */
  const codigoPorUrl = new Map();

  function generarCodigoLibre() {
    for (let largo = longitud; ; largo++) {
      for (let intento = 0; intento < INTENTOS_POR_LONGITUD; intento++) {
        const codigo = codigoAleatorio(largo);
        if (!enlaces.has(codigo)) return codigo;
      }
      // Demasiadas colisiones seguidas: el espacio está saturado, se alarga el código.
    }
  }

  /** Copia pública de un enlace: modificarla no altera el almacén. */
  function vista(codigo) {
    const enlace = enlaces.get(codigo);
    return {
      codigo,
      url: enlace.url,
      urlCorta: prefijo + codigo,
      creadoEn: new Date(enlace.creadoEn),
      visitas: enlace.visitas,
    };
  }

  /**
   * Acorta una URL. Acortar dos veces la misma URL sin alias devuelve el mismo código.
   *
   * @param {string} url
   * @param {object} [opcionesEnlace]
   * @param {string} [opcionesEnlace.alias]  Código elegido a mano (3-32 caracteres: letras, dígitos, _ o -).
   * @returns {{codigo: string, url: string, urlCorta: string, creadoEn: Date, visitas: number}}
   */
  function acortar(url, { alias } = {}) {
    const destino = normalizarUrl(url);

    if (alias !== undefined) {
      if (typeof alias !== 'string' || !PATRON_ALIAS.test(alias)) {
        throw new TypeError('El alias debe tener entre 3 y 32 caracteres: letras, dígitos, "_" o "-"');
      }
      const existente = enlaces.get(alias);
      if (existente) {
        if (existente.url === destino) return vista(alias);
        throw new Error(`El alias "${alias}" ya está en uso`);
      }
      enlaces.set(alias, { url: destino, creadoEn: Date.now(), visitas: 0, generado: false });
      return vista(alias);
    }

    const yaAcortada = codigoPorUrl.get(destino);
    if (yaAcortada !== undefined) return vista(yaAcortada);

    const codigo = generarCodigoLibre();
    enlaces.set(codigo, { url: destino, creadoEn: Date.now(), visitas: 0, generado: true });
    codigoPorUrl.set(destino, codigo);
    return vista(codigo);
  }

  /**
   * Devuelve la URL original de un código y cuenta la visita.
   * @returns {string|null} null si el código no existe.
   */
  function resolver(codigo) {
    const enlace = enlaces.get(codigo);
    if (!enlace) return null;
    enlace.visitas++;
    return enlace.url;
  }

  /**
   * Consulta un enlace sin contar visita.
   * @returns {object|null} null si el código no existe.
   */
  function info(codigo) {
    return enlaces.has(codigo) ? vista(codigo) : null;
  }

  /**
   * Borra un enlace.
   * @returns {boolean} true si existía.
   */
  function eliminar(codigo) {
    const enlace = enlaces.get(codigo);
    if (!enlace) return false;
    enlaces.delete(codigo);
    if (enlace.generado) codigoPorUrl.delete(enlace.url);
    return true;
  }

  /** Lista todos los enlaces, en orden de creación. */
  function listar() {
    return Array.from(enlaces.keys(), vista);
  }

  /** Borra todos los enlaces. */
  function vaciar() {
    enlaces.clear();
    codigoPorUrl.clear();
  }

  return {
    acortar,
    resolver,
    info,
    eliminar,
    listar,
    vaciar,
    get total() {
      return enlaces.size;
    },
  };
}

module.exports = { crearAcortador };

'use strict';

/**
 * Acortador de URLs en memoria, sin dependencias.
 *
 * Uso:
 *   const acortador = new Acortador();
 *   const corta = acortador.acortar('https://ejemplo.com/ruta');
 *   acortador.resolver(corta); // URL original o null
 */
class Acortador {
  constructor({ baseUrl = '', longitud = 6 } = {}) {
    if (!Number.isInteger(longitud) || longitud < 1) {
      throw new TypeError('longitud debe ser un entero positivo');
    }

    this.baseUrl = String(baseUrl).replace(/\/+$/, '');
    this.longitud = longitud;
    this.enlaces = new Map();
    this.porDestino = new Map();
    this.caracteres = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
  }

  /** Guarda una URL y devuelve su código corto (o la URL corta completa). */
  acortar(url, { completa = false } = {}) {
    if (typeof url !== 'string' || url.trim() === '') {
      throw new TypeError('url debe ser una cadena no vacía');
    }

    const destino = url.trim();
    const existente = this.porDestino.get(destino);
    if (existente) return completa ? this._formatear(existente) : existente;

    let codigo;
    do {
      codigo = this._generarCodigo();
    } while (this.enlaces.has(codigo));

    this.enlaces.set(codigo, destino);
    this.porDestino.set(destino, codigo);
    return completa ? this._formatear(codigo) : codigo;
  }

  /** Busca por código o por URL corta completa; devuelve null si no existe. */
  resolver(codigoOUrl) {
    if (typeof codigoOUrl !== 'string') return null;
    const codigo = this._extraerCodigo(codigoOUrl.trim());
    return this.enlaces.get(codigo) ?? null;
  }

  /** Elimina un enlace por su código o URL corta. Devuelve true si existía. */
  eliminar(codigoOUrl) {
    if (typeof codigoOUrl !== 'string') return false;
    const codigo = this._extraerCodigo(codigoOUrl.trim());
    const destino = this.enlaces.get(codigo);
    if (destino === undefined) return false;
    this.enlaces.delete(codigo);
    this.porDestino.delete(destino);
    return true;
  }

  /** Vacía todos los enlaces guardados. */
  limpiar() {
    this.enlaces.clear();
    this.porDestino.clear();
  }

  /** Devuelve una copia de los pares código-URL, sin exponer el Map interno. */
  listar() {
    return Array.from(this.enlaces, ([codigo, url]) => ({ codigo, url }));
  }

  _generarCodigo() {
    let codigo = '';
    for (let i = 0; i < this.longitud; i += 1) {
      codigo += this.caracteres[Math.floor(Math.random() * this.caracteres.length)];
    }
    return codigo;
  }

  _formatear(codigo) {
    return this.baseUrl ? `${this.baseUrl}/${codigo}` : codigo;
  }

  _extraerCodigo(codigoOUrl) {
    if (!this.baseUrl || !codigoOUrl.startsWith(`${this.baseUrl}/`)) {
      return codigoOUrl;
    }
    return codigoOUrl.slice(this.baseUrl.length + 1).split(/[?#]/, 1)[0];
  }
}

module.exports = Acortador;
module.exports.Acortador = Acortador;

'use strict';

/** Acortador en memoria. Cada instancia mantiene sus propios enlaces. */
class AcortadorURLs {
  constructor(baseUrl = 'https://corto.local/') {
    const base = this._validarUrl(baseUrl);
    base.search = '';
    base.hash = '';
    base.pathname = base.pathname.replace(/\/+$/, '') + '/';
    this.baseUrl = base.href;
    this._enlaces = new Map();
    this._codigos = new Map();
    this._contador = 0n;
  }

  /** Devuelve siempre el mismo enlace corto para una URL ya guardada. */
  acortar(url) {
    const destino = this._validarUrl(url).href;
    let codigo = this._codigos.get(destino);
    if (codigo === undefined) {
      codigo = (++this._contador).toString(36);
      this._enlaces.set(codigo, destino);
      this._codigos.set(destino, codigo);
    }
    return this.baseUrl + codigo;
  }

  /** Acepta un código o un enlace corto; devuelve null si no existe. */
  resolver(codigoOUrl) {
    const codigo = this._extraerCodigo(codigoOUrl);
    return codigo === null ? null : (this._enlaces.get(codigo) ?? null);
  }

  /** Elimina un enlace y devuelve si existía. */
  eliminar(codigoOUrl) {
    const codigo = this._extraerCodigo(codigoOUrl);
    if (codigo === null || !this._enlaces.has(codigo)) return false;
    this._codigos.delete(this._enlaces.get(codigo));
    this._enlaces.delete(codigo);
    return true;
  }

  get cantidad() {
    return this._enlaces.size;
  }

  /** Vacía la memoria sin reutilizar códigos ya emitidos. */
  limpiar() {
    this._enlaces.clear();
    this._codigos.clear();
  }

  _validarUrl(valor) {
    if (typeof valor !== 'string' || valor.trim() === '') {
      throw new TypeError('La URL debe ser una cadena no vacía.');
    }
    let url;
    try {
      url = new URL(valor);
    } catch {
      throw new TypeError('La URL debe ser absoluta y válida.');
    }
    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
      throw new TypeError('Solo se permiten URLs HTTP y HTTPS.');
    }
    return url;
  }

  _extraerCodigo(valor) {
    if (typeof valor !== 'string') return null;
    const codigo = valor.startsWith(this.baseUrl)
      ? valor.slice(this.baseUrl.length)
      : valor;
    return /^[0-9a-z]+$/.test(codigo) ? codigo : null;
  }
}

// CommonJS: const AcortadorURLs = require('./acortador');
module.exports = AcortadorURLs;
module.exports.AcortadorURLs = AcortadorURLs;

'use strict';

/**
 * Acortador de URLs sin dependencias y con almacenamiento en memoria.
 * CommonJS: const { crearAcortador } = require('./acortador');
 *
 * const enlaces = crearAcortador({ baseUrl: 'https://corto.example/' });
 * const corto = enlaces.acortar('https://example.com/articulo');
 * enlaces.resolver(corto); // 'https://example.com/articulo'
 *
 * Los datos desaparecen al cerrar el proceso. Cada instancia es independiente.
 * Los códigos son secuenciales: no deben usarse como secretos de acceso.
 */
function crearAcortador({ baseUrl = 'https://corto.local/' } = {}) {
  function validarUrl(valor) {
    if (typeof valor !== 'string' || valor.trim() === '') {
      throw new TypeError('La URL debe ser una cadena no vacía.');
    }
    let url;
    try {
      url = new URL(valor);
    } catch {
      throw new TypeError('La URL debe ser absoluta y válida.');
    }
    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
      throw new TypeError('Solo se permiten URLs HTTP y HTTPS.');
    }
    if (url.username || url.password) {
      throw new TypeError('No se permiten credenciales en la URL.');
    }
    return url;
  }

  const base = validarUrl(baseUrl);
  if (base.search || base.hash) {
    throw new TypeError('La URL base no puede contener consulta ni fragmento.');
  }
  if (!base.pathname.endsWith('/')) base.pathname += '/';
  const prefijo = base.href;
  const porCodigo = new Map();
  const porUrl = new Map();
  let siguiente = 0n;

  function obtenerCodigo(valor) {
    if (typeof valor !== 'string') {
      throw new TypeError('Se esperaba un código o una URL corta.');
    }
    if (/^[0-9a-z]+$/.test(valor)) return valor;
    let url;
    try {
      url = new URL(valor);
    } catch {
      return undefined;
    }
    if (url.origin !== base.origin || url.username || url.password ||
        url.search || url.hash || !url.pathname.startsWith(base.pathname)) {
      return undefined;
    }
    const codigo = url.pathname.slice(base.pathname.length);
    return /^[0-9a-z]+$/.test(codigo) ? codigo : undefined;
  }

  return Object.freeze({
    /** Devuelve una URL corta; reutiliza el código de una URL ya guardada. */
    acortar(urlOriginal) {
      const original = validarUrl(urlOriginal).href;
      let codigo = porUrl.get(original);
      if (codigo === undefined) {
        siguiente += 1n;
        codigo = siguiente.toString(36);
        porCodigo.set(codigo, original);
        porUrl.set(original, codigo);
      }
      return prefijo + codigo;
    },

    /** Acepta un código o URL corta. Devuelve undefined si no existe. */
    resolver(codigoOUrl) {
      return porCodigo.get(obtenerCodigo(codigoOUrl));
    },

    /** Elimina un enlace y devuelve si existía. Los códigos no se reutilizan. */
    eliminar(codigoOUrl) {
      const codigo = obtenerCodigo(codigoOUrl);
      const original = porCodigo.get(codigo);
      if (original === undefined) return false;
      porCodigo.delete(codigo);
      porUrl.delete(original);
      return true;
    },

    /** Vacía el almacenamiento sin reutilizar códigos anteriores. */
    limpiar() {
      porCodigo.clear();
      porUrl.clear();
    },

    get cantidad() {
      return porCodigo.size;
    }
  });
}

module.exports = { crearAcortador };

'use strict';

/**
 * Acortador de URLs en memoria, sin dependencias.
 *
 * Uso:
 *   const { Acortador } = require('./acortador');
 *   const ac = new Acortador({ baseUrl: 'https://sho.rt' });
 *   const corto = ac.acortar('https://example.com/muy/larga');
 *   ac.resolver(corto.codigo); // -> URL original
 */

const ALFABETO = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';

/**
 * Valida que una cadena sea una URL http(s) absoluta y devuelve su forma normalizada.
 * @param {string} url
 * @returns {string}
 */
function normalizarUrl(url) {
  if (typeof url !== 'string' || url.trim() === '') {
    throw new TypeError('La URL debe ser una cadena no vacía');
  }
  let parsed;
  try {
    parsed = new URL(url.trim());
  } catch {
    throw new TypeError(`URL inválida: ${url}`);
  }
  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
    throw new TypeError('Solo se admiten URLs http(s)');
  }
  return parsed.toString();
}

class Acortador {
  /**
   * @param {object} [opciones]
   * @param {string} [opciones.baseUrl=''] Prefijo para construir el enlace corto.
   * @param {number} [opciones.longitudCodigo=6] Longitud de los códigos generados.
   * @param {() => number} [opciones.aleatorio] Fuente de aleatoriedad inyectable (tests).
   */
  constructor({ baseUrl = '', longitudCodigo = 6, aleatorio = Math.random } = {}) {
    if (!Number.isInteger(longitudCodigo) || longitudCodigo < 1) {
      throw new RangeError('longitudCodigo debe ser un entero >= 1');
    }
    this.baseUrl = String(baseUrl).replace(/\/+$/, '');
    this.longitudCodigo = longitudCodigo;
    this.aleatorio = aleatorio;
    /** @type {Map<string, {url: string, codigo: string, creadoEn: number, visitas: number}>} */
    this._porCodigo = new Map();
    /** @type {Map<string, string>} url normalizada -> código */
    this._porUrl = new Map();
  }

  /**
   * Genera un código aleatorio que no colisione.
   * @returns {string}
   */
  _generarCodigo() {
    let codigo;
    do {
      codigo = '';
      for (let i = 0; i < this.longitudCodigo; i++) {
        const idx = Math.floor(this.aleatorio() * ALFABETO.length);
        codigo += ALFABETO[Math.min(idx, ALFABETO.length - 1)];
      }
    } while (this._porCodigo.has(codigo));
    return codigo;
  }

  /**
   * Acorta una URL. Si ya fue acortada, reutiliza el mismo código.
   * @param {string} url
   * @param {string} [codigoPersonalizado] Código concreto a usar.
   * @returns {{codigo: string, corta: string, larga: string, creadoEn: number}}
   */
  acortar(url, codigoPersonalizado) {
    const larga = normalizarUrl(url);

    let codigo;
    if (codigoPersonalizado !== undefined) {
      codigo = String(codigoPersonalizado);
      if (!/^[A-Za-z0-9_-]+$/.test(codigo)) {
        throw new TypeError('El código personalizado solo admite letras, números, "-" y "_"');
      }
      if (this._porCodigo.has(codigo)) {
        throw new Error(`El código "${codigo}" ya está en uso`);
      }
    } else {
      const existente = this._porUrl.get(larga);
      if (existente) return this._formar(existente);
      codigo = this._generarCodigo();
    }

    const entrada = { url: larga, codigo, creadoEn: Date.now(), visitas: 0 };
    this._porCodigo.set(codigo, entrada);
    this._porUrl.set(larga, codigo);
    return this._formar(codigo);
  }

  /**
   * Devuelve la URL original asociada a un código y suma una visita.
   * @param {string} codigo
   * @param {{contarVisita?: boolean}} [opciones]
   * @returns {string|null}
   */
  resolver(codigo, { contarVisita = true } = {}) {
    const entrada = this._porCodigo.get(String(codigo));
    if (!entrada) return null;
    if (contarVisita) entrada.visitas += 1;
    return entrada.url;
  }

  /**
   * Metadatos de un código sin contabilizar visita.
   * @param {string} codigo
   * @returns {{codigo: string, url: string, creadoEn: number, visitas: number}|null}
   */
  info(codigo) {
    const entrada = this._porCodigo.get(String(codigo));
    return entrada ? { ...entrada } : null;
  }

  /**
   * Elimina un código.
   * @param {string} codigo
   * @returns {boolean} true si existía.
   */
  eliminar(codigo) {
    const entrada = this._porCodigo.get(String(codigo));
    if (!entrada) return false;
    this._porCodigo.delete(entrada.codigo);
    this._porUrl.delete(entrada.url);
    return true;
  }

  /** Vacía el almacén. */
  limpiar() {
    this._porCodigo.clear();
    this._porUrl.clear();
  }

  /** Número de enlaces almacenados. */
  get tamano() {
    return this._porCodigo.size;
  }

  /**
   * Construye la respuesta a partir de un código.
   * @param {string} codigo
   */
  _formar(codigo) {
    return {
      codigo,
      corta: this.baseUrl ? `${this.baseUrl}/${codigo}` : codigo,
      larga: this._porCodigo.get(codigo).url,
      creadoEn: this._porCodigo.get(codigo).creadoEn,
    };
  }
}

module.exports = { Acortador, normalizarUrl, ALFABETO };

// Acortador de URLs en memoria, sin dependencias.

// Almacén de enlaces: código corto -> URL original.
const enlaces = new Map();

// Alfabeto usado para generar los códigos cortos aleatorios.
const ALFABETO =
  'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';

// Longitud por defecto de los códigos generados.
const LONGITUD_POR_DEFECTO = 6;

// Genera un código corto aleatorio de la longitud indicada.
function generarCodigo(longitud = LONGITUD_POR_DEFECTO) {
  let codigo = '';
  for (let i = 0; i < longitud; i++) {
    codigo += ALFABETO[Math.floor(Math.random() * ALFABETO.length)];
  }
  return codigo;
}

// Valida y normaliza la URL de entrada.
function validarUrl(url) {
  if (typeof url !== 'string' || url.trim() === '') {
    throw new Error('La URL no puede estar vacía');
  }
  const normalizada = url.trim();
  try {
    // Acepta tanto URLs absolutas como relativas (p. ej. "ejemplo.com").
    new URL(normalizada.startsWith('http') ? normalizada : `https://${normalizada}`);
  } catch {
    throw new Error(`URL no válida: ${url}`);
  }
  return normalizada;
}

// Acorta una URL. Devuelve el código corto.
// Si se pasa `codigoPersonalizado`, se usa ese código en lugar de generar uno.
export function acortar(url, codigoPersonalizado = null) {
  const urlValida = validarUrl(url);

  if (codigoPersonalizado !== null) {
    if (typeof codigoPersonalizado !== 'string' || codigoPersonalizado.trim() === '') {
      throw new Error('El código personalizado no puede estar vacío');
    }
    const codigo = codigoPersonalizado.trim();
    if (enlaces.has(codigo)) {
      throw new Error(`El código "${codigo}" ya está en uso`);
    }
    enlaces.set(codigo, urlValida);
    return codigo;
  }

  let codigo;
  do {
    codigo = generarCodigo();
  } while (enlaces.has(codigo));

  enlaces.set(codigo, urlValida);
  return codigo;
}

// Resuelve un código corto a su URL original.
// Devuelve la URL o `undefined` si el código no existe.
export function resolver(codigo) {
  return enlaces.get(codigo);
}

// Elimina un código corto. Devuelve `true` si existía y fue eliminado.
export function eliminar(codigo) {
  return enlaces.delete(codigo);
}

// Devuelve una copia de todos los enlaces almacenados (código -> URL).
export function listar() {
  return new Map(enlaces);
}

// Devuelve el número de enlaces almacenados.
export function total() {
  return enlaces.size;
}

export default { acortar, resolver, eliminar, listar, total };