{"version":3,"sources":["../src/index.ts","../src/node.ts","../src/doubly-linked-list.ts","../src/stack.ts","../src/queue.ts","../src/deque.ts","../src/lru-cache.ts","../src/priority-queue.ts","../src/avl-tree.ts","../src/graph.ts","../src/trie.ts"],"sourcesContent":["export { Node } from './node.js'\nexport { DoublyLinkedList } from './doubly-linked-list.js'\nexport { Stack } from './stack.js'\nexport { Queue } from './queue.js'\nexport { Deque } from './deque.js'\nexport { LRUCache } from './lru-cache.js'\nexport { PriorityQueue } from './priority-queue.js'\nexport { AVLTree } from './avl-tree.js'\nexport { Graph } from './graph.js'\nexport { Trie } from './trie.js'","/**\r\n * Representa un nodo individual en una lista doblemente enlazada.\r\n * @template T - El tipo del valor almacenado en el nodo.\r\n */\r\nexport class Node<T> {\r\n  value: T\r\n  next: Node<T> | null = null\r\n  prev: Node<T> | null = null\r\n\r\n  constructor(value: T) {\r\n    this.value = value\r\n  }\r\n}","import { Node } from './node.js'\r\n\r\n/**\r\n * Lista doblemente enlazada con inserción y eliminación O(1) en ambos extremos.\r\n * \"Doblemente enlazada\" significa que cada nodo conoce tanto al siguiente como al anterior,\r\n * lo que permite recorrerla en ambas direcciones.\r\n * @template T - El tipo de los valores almacenados en la lista.\r\n */\r\nexport class DoublyLinkedList<T> {\r\n  public head: Node<T> | null = null\r\n  public tail: Node<T> | null = null\r\n  private length: number = 0\r\n\r\n  /**\r\n   * Alias de length para compatibilidad con Map y Set.\r\n   */\r\n  get size(): number {\r\n    return this.length\r\n  }\r\n\r\n  /**\r\n   * Indica si la lista está vacía.\r\n   */\r\n  isEmpty(): boolean {\r\n    return this.length === 0\r\n  }\r\n\r\n  /**\r\n   * Agrega un nuevo nodo al final de la lista.\r\n   * @param value - El valor a agregar (primitivo u objeto).\r\n   * @returns La instancia de la lista (permite encadenamiento).\r\n   */\r\n  push(value: T): this {\r\n    const node = new Node(value)\r\n\r\n    if (!this.head) {\r\n      this.head = node\r\n      this.tail = node\r\n    } else {\r\n      node.prev = this.tail\r\n      this.tail!.next = node\r\n      this.tail = node\r\n    }\r\n\r\n    this.length++\r\n    return this\r\n  }\r\n\r\n  /**\r\n   * Elimina y retorna el valor del nodo al final de la lista.\r\n   * Gracias al puntero prev, opera en O(1).\r\n   * @returns El valor del nodo eliminado, o undefined si la lista está vacía.\r\n   */\r\n  pop(): T | undefined {\r\n    if (!this.tail) return undefined\r\n\r\n    const removed = this.tail\r\n\r\n    if (this.length === 1) {\r\n      this.head = null\r\n      this.tail = null\r\n    } else {\r\n      this.tail = this.tail.prev\r\n      this.tail!.next = null\r\n      removed.prev = null\r\n    }\r\n\r\n    this.length--\r\n    return removed.value\r\n  }\r\n\r\n  /**\r\n   * Agrega un nuevo nodo al inicio de la lista.\r\n   * @param value - El valor a agregar (primitivo u objeto).\r\n   * @returns La instancia de la lista (permite encadenamiento).\r\n   */\r\n  unshift(value: T): this {\r\n    const node = new Node(value)\r\n\r\n    if (!this.head) {\r\n      this.head = node\r\n      this.tail = node\r\n    } else {\r\n      node.next = this.head\r\n      this.head.prev = node\r\n      this.head = node\r\n    }\r\n\r\n    this.length++\r\n    return this\r\n  }\r\n\r\n  /**\r\n   * Elimina y retorna el valor del nodo al inicio de la lista.\r\n   * Opera en O(1) porque this.head apunta directamente al primer nodo.\r\n   * @returns El valor del nodo eliminado, o undefined si la lista está vacía.\r\n   */\r\n  shift(): T | undefined {\r\n    if (!this.head) return undefined\r\n\r\n    const removed = this.head\r\n\r\n    if (this.length === 1) {\r\n      this.head = null\r\n      this.tail = null\r\n    } else {\r\n      this.head = this.head.next\r\n      this.head!.prev = null\r\n      removed.next = null\r\n    }\r\n\r\n    this.length--\r\n    return removed.value\r\n  }\r\n\r\n  /**\r\n   * Retorna el nodo en el índice dado sin eliminarlo.\r\n   * Si el índice está en la segunda mitad, recorre desde tail hacia atrás — O(n/2).\r\n   * @param index - Índice base cero del nodo a obtener.\r\n   * @throws {RangeError} Si el índice está fuera de rango.\r\n   * @returns El nodo en ese índice.\r\n   */\r\n  get(index: number): Node<T> {\r\n    if (index < 0 || index >= this.length) {\r\n      throw new RangeError(\r\n        `Index ${index} is out of bounds for list of length ${this.length}`,\r\n      )\r\n    }\r\n\r\n    let current: Node<T>\r\n    if (index <= this.length / 2) {\r\n      current = this.head!\r\n      for (let i = 0; i < index; i++) current = current.next!\r\n    } else {\r\n      current = this.tail!\r\n      for (let i = this.length - 1; i > index; i--) current = current.prev!\r\n    }\r\n\r\n    return current\r\n  }\r\n\r\n  /**\r\n   * Actualiza el valor del nodo en el índice dado.\r\n   * @param index - Índice base cero del nodo a actualizar.\r\n   * @param value - El nuevo valor.\r\n   * @throws {RangeError} Si el índice está fuera de rango.\r\n   */\r\n  set(index: number, value: T): void {\r\n    this.get(index).value = value\r\n  }\r\n\r\n  /**\r\n   * Inserta un nuevo nodo en el índice especificado.\r\n   * Delega a push/unshift en los extremos para mantener O(1).\r\n   * @param index - Índice base cero donde insertar.\r\n   * @param value - El valor a insertar.\r\n   * @throws {RangeError} Si el índice está fuera de rango.\r\n   */\r\n  insert(index: number, value: T): void {\r\n    if (index < 0 || index > this.length) {\r\n      throw new RangeError(\r\n        `Index ${index} is out of bounds for list of length ${this.length}`,\r\n      )\r\n    }\r\n\r\n    if (index === 0) { this.unshift(value); return }\r\n    if (index === this.length) { this.push(value); return }\r\n\r\n    const node = new Node(value)\r\n    const before = this.get(index - 1)\r\n    const after = before.next!\r\n\r\n    before.next = node\r\n    node.prev = before\r\n    node.next = after\r\n    after.prev = node\r\n\r\n    this.length++\r\n  }\r\n\r\n  /**\r\n   * Elimina el nodo en el índice especificado y retorna su valor.\r\n   * Delega a pop/shift en los extremos para mantener O(1).\r\n   * @param index - Índice base cero del nodo a eliminar.\r\n   * @throws {RangeError} Si el índice está fuera de rango.\r\n   * @returns El valor del nodo eliminado.\r\n   */\r\n  remove(index: number): T {\r\n    if (index < 0 || index >= this.length) {\r\n      throw new RangeError(\r\n        `Index ${index} is out of bounds for list of length ${this.length}`,\r\n      )\r\n    }\r\n\r\n    if (index === 0) return this.shift()!\r\n    if (index === this.length - 1) return this.pop()!\r\n\r\n    const node = this.get(index)\r\n    node.prev!.next = node.next\r\n    node.next!.prev = node.prev\r\n    node.next = null\r\n    node.prev = null\r\n\r\n    this.length--\r\n    return node.value\r\n  }\r\n\r\n  /**\r\n   * Elimina un nodo directamente por referencia, sin buscar por índice — O(1).\r\n   * Es el primitivo clave para estructuras avanzadas como caché LRU, grafos y schedulers.\r\n   * Advertencia: pasar un nodo que pertenece a otra lista produce comportamiento indefinido.\r\n   * @param node - El nodo a eliminar.\r\n   * @throws {TypeError} Si el nodo es null o undefined.\r\n   * @returns El valor del nodo eliminado.\r\n   */\r\n  removeNode(node: Node<T>): T {\r\n    if (!node) throw new TypeError('node must be a valid Node instance')\r\n    if (node === this.head) return this.shift()!\r\n    if (node === this.tail) return this.pop()!\r\n\r\n    node.prev!.next = node.next\r\n    node.next!.prev = node.prev\r\n    node.prev = null\r\n    node.next = null\r\n\r\n    this.length--\r\n    return node.value\r\n  }\r\n\r\n  /**\r\n   * Busca el primer nodo cuyo valor satisface el predicado dado.\r\n   * Funciona con objetos porque el predicado tiene control total sobre la comparación.\r\n   * @param predicate - Función que recibe (value, index) y retorna boolean.\r\n   * @returns El nodo que cumple el predicado, o undefined si no hay ninguno.\r\n   */\r\n  findNode(predicate: (value: T, index: number) => boolean): Node<T> | undefined {\r\n    let current = this.head\r\n    let index = 0\r\n    while (current) {\r\n      if (predicate(current.value, index)) return current\r\n      current = current.next\r\n      index++\r\n    }\r\n    return undefined\r\n  }\r\n\r\n  /**\r\n   * Busca el primer valor que satisface el predicado dado.\r\n   * @param predicate - Función que recibe (value, index) y retorna boolean.\r\n   * @returns El valor del primer nodo que cumple el predicado, o undefined si no hay ninguno.\r\n   */\r\n  find(predicate: (value: T, index: number) => boolean): T | undefined {\r\n    return this.findNode(predicate)?.value\r\n  }\r\n\r\n  /**\r\n   * Retorna el índice del primer nodo con el valor dado, usando comparación estricta.\r\n   * Para objetos, usar findNode() con un predicado personalizado.\r\n   * @param value - El valor a buscar.\r\n   * @returns El índice del nodo, o -1 si no existe.\r\n   */\r\n  indexOf(value: T): number {\r\n    let current = this.head\r\n    let index = 0\r\n    while (current) {\r\n      if (current.value === value) return index\r\n      current = current.next\r\n      index++\r\n    }\r\n    return -1\r\n  }\r\n\r\n  /**\r\n   * Indica si la lista contiene al menos un nodo con el valor dado.\r\n   * Para objetos, usar findNode() con un predicado personalizado.\r\n   * @param value - El valor a buscar.\r\n   */\r\n  contains(value: T): boolean {\r\n    return this.indexOf(value) !== -1\r\n  }\r\n\r\n  /**\r\n   * Retorna un array con todos los valores de la lista, de cabeza a cola.\r\n   */\r\n  toArray(): T[] {\r\n    const result: T[] = []\r\n    let current = this.head\r\n    while (current) {\r\n      result.push(current.value)\r\n      current = current.next\r\n    }\r\n    return result\r\n  }\r\n\r\n  /**\r\n   * Vacía la lista en O(1), soltando todas las referencias para que el GC pueda liberarlas.\r\n   */\r\n  clear(): void {\r\n    this.head = null\r\n    this.tail = null\r\n    this.length = 0\r\n  }\r\n\r\n  /**\r\n   * Hace la lista iterable con for...of, spread y destructuring.\r\n   */\r\n  *[Symbol.iterator](): Iterator<T> {\r\n    let current = this.head\r\n    while (current) {\r\n      yield current.value\r\n      current = current.next\r\n    }\r\n  }\r\n}","import { DoublyLinkedList } from './doubly-linked-list.js'\r\n\r\n/**\r\n * Pila (Stack) — estructura LIFO (Last In, First Out).\r\n * El último elemento en entrar es el primero en salir.\r\n * Acepta cualquier valor: primitivos u objetos.\r\n * @template T - El tipo de los valores almacenados en la pila.\r\n */\r\nexport class Stack<T> {\r\n  readonly #list = new DoublyLinkedList<T>()\r\n\r\n  /**\r\n   * Agrega un valor al tope de la pila.\r\n   * @param value - El valor a agregar (primitivo u objeto).\r\n   */\r\n  push(value: T): void {\r\n    this.#list.push(value)\r\n  }\r\n\r\n  /**\r\n   * Elimina y retorna el valor del tope de la pila.\r\n   * @returns El valor eliminado, o undefined si la pila está vacía.\r\n   */\r\n  pop(): T | undefined {\r\n    return this.#list.pop()\r\n  }\r\n\r\n  /**\r\n   * Retorna el valor del tope sin eliminarlo.\r\n   * @returns El valor del tope, o undefined si la pila está vacía.\r\n   */\r\n  peek(): T | undefined {\r\n    return this.#list.tail?.value\r\n  }\r\n\r\n  /**\r\n   * Indica si la pila está vacía.\r\n   */\r\n  isEmpty(): boolean {\r\n    return this.#list.isEmpty()\r\n  }\r\n\r\n  /**\r\n   * Cantidad de elementos en la pila.\r\n   */\r\n  get size(): number {\r\n    return this.#list.size\r\n  }\r\n\r\n  /**\r\n   * Retorna un array con todos los valores de la pila, de base a tope.\r\n   */\r\n  toArray(): T[] {\r\n    return this.#list.toArray()\r\n  }\r\n\r\n  /**\r\n   * Vacía la pila completa.\r\n   */\r\n  clear(): void {\r\n    this.#list.clear()\r\n  }\r\n\r\n  /**\r\n   * Hace la pila iterable con for...of, spread y destructuring.\r\n   */\r\n  *[Symbol.iterator](): Iterator<T> {\r\n    yield* this.#list\r\n  }\r\n}","import { DoublyLinkedList } from './doubly-linked-list.js'\r\n\r\n/**\r\n * Cola (Queue) — estructura FIFO (First In, First Out).\r\n * El primer elemento en entrar es el primero en salir.\r\n * Acepta cualquier valor: primitivos u objetos.\r\n * Para colas con prioridad, usar PriorityQueue.\r\n * @template T - El tipo de los valores almacenados en la cola.\r\n */\r\nexport class Queue<T> {\r\n  readonly #list = new DoublyLinkedList<T>()\r\n\r\n  /**\r\n   * Agrega un valor al final de la cola.\r\n   * @param value - El valor a agregar (primitivo u objeto).\r\n   */\r\n  enqueue(value: T): void {\r\n    this.#list.push(value)\r\n  }\r\n\r\n  /**\r\n   * Elimina y retorna el valor del frente de la cola.\r\n   * @returns El valor eliminado, o undefined si la cola está vacía.\r\n   */\r\n  dequeue(): T | undefined {\r\n    return this.#list.shift()\r\n  }\r\n\r\n  /**\r\n   * Retorna el valor del frente sin eliminarlo.\r\n   * @returns El valor del frente, o undefined si la cola está vacía.\r\n   */\r\n  peek(): T | undefined {\r\n    return this.#list.head?.value\r\n  }\r\n\r\n  /**\r\n   * Cancela (elimina) el primer elemento que satisface el predicado.\r\n   * Para primitivos: cancel(v => v === \"T-001\")\r\n   * Para objetos:   cancel(v => v.id === \"T-001\")\r\n   * @param predicate - Función que recibe el valor y retorna boolean.\r\n   * @returns true si se canceló, false si no se encontró.\r\n   */\r\n  cancel(predicate: (value: T) => boolean): boolean {\r\n    const node = this.#list.findNode(predicate)\r\n    if (!node) return false\r\n    this.#list.removeNode(node)\r\n    return true\r\n  }\r\n\r\n  /**\r\n   * Retorna la posición (base 1) del primer elemento que satisface el predicado.\r\n   * Para primitivos: positionOf(v => v === \"T-001\")\r\n   * Para objetos:   positionOf(v => v.id === \"T-001\")\r\n   * @param predicate - Función que recibe el valor y retorna boolean.\r\n   * @returns La posición en la cola, o undefined si no se encontró.\r\n   */\r\n  positionOf(predicate: (value: T) => boolean): number | undefined {\r\n    let current = this.#list.head\r\n    let position = 1\r\n    while (current) {\r\n      if (predicate(current.value)) return position\r\n      current = current.next\r\n      position++\r\n    }\r\n    return undefined\r\n  }\r\n\r\n  /**\r\n   * Retorna un array con todos los valores en espera, sin modificar la cola.\r\n   */\r\n  toArray(): T[] {\r\n    return this.#list.toArray()\r\n  }\r\n\r\n  /**\r\n   * Vacía la cola completa.\r\n   */\r\n  clear(): void {\r\n    this.#list.clear()\r\n  }\r\n\r\n  /**\r\n   * Indica si la cola está vacía.\r\n   */\r\n  isEmpty(): boolean {\r\n    return this.#list.isEmpty()\r\n  }\r\n\r\n  /**\r\n   * Cantidad de elementos en la cola.\r\n   */\r\n  get size(): number {\r\n    return this.#list.size\r\n  }\r\n\r\n  /**\r\n   * Hace la cola iterable con for...of, spread y destructuring.\r\n   */\r\n  *[Symbol.iterator](): Iterator<T> {\r\n    yield* this.#list\r\n  }\r\n}","import { DoublyLinkedList } from './doubly-linked-list.js'\r\n\r\n/**\r\n * Cola de doble extremo (Deque — Double-Ended Queue).\r\n * Permite inserción y eliminación en ambos extremos en O(1).\r\n * Acepta cualquier valor: primitivos u objetos.\r\n * Generaliza Stack y Queue — puede comportarse como cualquiera de las dos.\r\n * @template T - El tipo de los valores almacenados en el deque.\r\n */\r\nexport class Deque<T> {\r\n  readonly #list = new DoublyLinkedList<T>()\r\n\r\n  /**\r\n   * Agrega un valor al final.\r\n   * @param value - El valor a agregar (primitivo u objeto).\r\n   */\r\n  pushBack(value: T): void {\r\n    this.#list.push(value)\r\n  }\r\n\r\n  /**\r\n   * Agrega un valor al frente.\r\n   * @param value - El valor a agregar (primitivo u objeto).\r\n   */\r\n  pushFront(value: T): void {\r\n    this.#list.unshift(value)\r\n  }\r\n\r\n  /**\r\n   * Elimina y retorna el valor del final.\r\n   * @returns El valor eliminado, o undefined si el deque está vacío.\r\n   */\r\n  popBack(): T | undefined {\r\n    return this.#list.pop()\r\n  }\r\n\r\n  /**\r\n   * Elimina y retorna el valor del frente.\r\n   * @returns El valor eliminado, o undefined si el deque está vacío.\r\n   */\r\n  popFront(): T | undefined {\r\n    return this.#list.shift()\r\n  }\r\n\r\n  /**\r\n   * Retorna el valor del final sin eliminarlo.\r\n   * @returns El valor del final, o undefined si el deque está vacío.\r\n   */\r\n  peekBack(): T | undefined {\r\n    return this.#list.tail?.value\r\n  }\r\n\r\n  /**\r\n   * Retorna el valor del frente sin eliminarlo.\r\n   * @returns El valor del frente, o undefined si el deque está vacío.\r\n   */\r\n  peekFront(): T | undefined {\r\n    return this.#list.head?.value\r\n  }\r\n\r\n  /**\r\n   * Indica si el deque está vacío.\r\n   */\r\n  isEmpty(): boolean {\r\n    return this.#list.isEmpty()\r\n  }\r\n\r\n  /**\r\n   * Cantidad de elementos en el deque.\r\n   */\r\n  get size(): number {\r\n    return this.#list.size\r\n  }\r\n\r\n  /**\r\n   * Retorna un array con todos los valores del deque, de frente a fondo.\r\n   */\r\n  toArray(): T[] {\r\n    return this.#list.toArray()\r\n  }\r\n\r\n  /**\r\n   * Vacía el deque completo.\r\n   */\r\n  clear(): void {\r\n    this.#list.clear()\r\n  }\r\n\r\n  /**\r\n   * Hace el deque iterable con for...of, spread y destructuring.\r\n   */\r\n  *[Symbol.iterator](): Iterator<T> {\r\n    yield* this.#list\r\n  }\r\n}","import { DoublyLinkedList } from './doubly-linked-list.js'\nimport type { Node } from './node.js'\n\n/**\n * Par clave-valor almacenado en cada nodo del caché.\n */\ninterface CacheEntry<K, V> {\n  key: K\n  value: V\n}\n\n/**\n * Caché LRU (Least Recently Used) de capacidad fija.\n * Combina un DoublyLinkedList (para rastrear orden de uso) con un Map (para acceso O(1) por clave).\n * El nodo al inicio de la lista es el menos usado recientemente; el del final, el más reciente.\n * Cuando la capacidad está llena, el elemento menos usado es evictado automáticamente.\n * @template K - Tipo de las claves.\n * @template V - Tipo de los valores.\n */\nexport class LRUCache<K, V> {\n  readonly #capacity: number\n  readonly #list = new DoublyLinkedList<CacheEntry<K, V>>()\n  readonly #map = new Map<K, Node<CacheEntry<K, V>>>()\n\n  constructor(capacity: number) {\n    if (capacity < 1) {\n      throw new RangeError(`La capacidad debe ser al menos 1, recibido: ${capacity}`)\n    }\n    this.#capacity = capacity\n  }\n\n  /**\n   * Obtiene el valor de la clave y la marca como la más recientemente usada.\n   * @returns El valor, o undefined si la clave no existe.\n   */\n  get(key: K): V | undefined {\n    const node = this.#map.get(key)\n    if (!node) return undefined\n    const { value } = node.value\n    this.#list.removeNode(node)\n    this.#list.push({ key, value })\n    this.#map.set(key, this.#list.tail!)\n    return value\n  }\n\n  /**\n   * Inserta o actualiza un par clave-valor.\n   * Si la capacidad está llena, evicta el elemento menos recientemente usado.\n   */\n  put(key: K, value: V): void {\n    if (this.#map.has(key)) {\n      const node = this.#map.get(key)!\n      this.#list.removeNode(node)\n      this.#list.push({ key, value })\n      this.#map.set(key, this.#list.tail!)\n      return\n    }\n    if (this.#list.size >= this.#capacity) {\n      const lruKey = this.#list.head!.value.key\n      this.#list.shift()\n      this.#map.delete(lruKey)\n    }\n    this.#list.push({ key, value })\n    this.#map.set(key, this.#list.tail!)\n  }\n\n  /**\n   * Comprueba si la clave existe en el caché sin modificar el orden de uso.\n   */\n  has(key: K): boolean {\n    return this.#map.has(key)\n  }\n\n  /**\n   * Elimina una entrada del caché.\n   * @returns true si existía, false si no.\n   */\n  delete(key: K): boolean {\n    const node = this.#map.get(key)\n    if (!node) return false\n    this.#list.removeNode(node)\n    this.#map.delete(key)\n    return true\n  }\n\n  /**\n   * Vacía el caché completamente.\n   */\n  clear(): void {\n    this.#list.clear()\n    this.#map.clear()\n  }\n\n  /**\n   * Número de entradas actuales en el caché.\n   */\n  get size(): number {\n    return this.#list.size\n  }\n\n  /**\n   * Capacidad máxima del caché.\n   */\n  get capacity(): number {\n    return this.#capacity\n  }\n\n  /**\n   * Indica si el caché está vacío.\n   */\n  isEmpty(): boolean {\n    return this.#list.size === 0\n  }\n\n  /**\n   * Retorna las entradas en orden de más reciente a menos reciente.\n   */\n  entries(): [K, V][] {\n    const arr = this.#list.toArray()\n    const result: [K, V][] = []\n    for (let i = arr.length - 1; i >= 0; i--) {\n      result.push([arr[i].key, arr[i].value])\n    }\n    return result\n  }\n}\n","/**\n * Cola de prioridad basada en un montículo binario mínimo (Min-Heap).\n * El elemento con menor valor según el comparador siempre sale primero.\n * Inserción y extracción en O(log n).\n *\n * @template T - El tipo de los valores almacenados.\n *\n * @example Min-heap de números (por defecto)\n * ```ts\n * const pq = new PriorityQueue<number>()\n * pq.enqueue(5); pq.enqueue(1); pq.enqueue(3)\n * pq.dequeue() // → 1\n * ```\n *\n * @example FIFO estable entre iguales (stable: true)\n * ```ts\n * interface Patient { name: string; priority: number }\n * const hospital = new PriorityQueue<Patient>(\n *   (a, b) => a.priority - b.priority,\n *   { stable: true }\n * )\n * hospital.enqueue({ name: 'Ana',  priority: 2 })\n * hospital.enqueue({ name: 'Luis', priority: 1 })\n * hospital.enqueue({ name: 'María', priority: 2 })\n * hospital.dequeue()?.name // → 'Luis'   (prioridad 1)\n * hospital.dequeue()?.name // → 'Ana'    (prioridad 2, llegó primero)\n * hospital.dequeue()?.name // → 'María'  (prioridad 2, llegó segunda)\n * ```\n */\nexport class PriorityQueue<T> {\n  // Internal heap stores wrapped entries to support stable tiebreaking.\n  readonly #heap: Array<{ value: T; seq: number }> = []\n  readonly #comparator: (a: T, b: T) => number\n  readonly #stable: boolean\n  #seq = 0\n\n  /**\n   * @param comparator - Función de comparación opcional (a, b) => number.\n   *   Negativo = a tiene mayor prioridad; cero = igual; positivo = b tiene mayor prioridad.\n   *   Por defecto ordena ascendentemente (min-heap natural).\n   * @param options.stable - Si es true, elementos con igual prioridad salen en orden\n   *   de inserción (FIFO). Por defecto false.\n   */\n  constructor(\n    comparator?: (a: T, b: T) => number,\n    options?: { stable?: boolean }\n  ) {\n    this.#comparator = comparator ?? ((a, b) => {\n      if (a < b) return -1\n      if (a > b) return 1\n      return 0\n    })\n    this.#stable = options?.stable ?? false\n  }\n\n  /** Returns true if the priority queue was created in stable mode. */\n  get stable(): boolean {\n    return this.#stable\n  }\n\n  /**\n   * Inserta un valor manteniendo la propiedad del heap.\n   */\n  enqueue(value: T): void {\n    this.#heap.push({ value, seq: this.#seq++ })\n    this.#bubbleUp(this.#heap.length - 1)\n  }\n\n  /**\n   * Elimina y retorna el elemento de mayor prioridad (mínimo por defecto).\n   * En modo stable, desempata por orden de inserción (FIFO).\n   * @returns El elemento, o undefined si la cola está vacía.\n   */\n  dequeue(): T | undefined {\n    if (this.#heap.length === 0) return undefined\n    const top = this.#heap[0].value\n    const last = this.#heap.pop()!\n    if (this.#heap.length > 0) {\n      this.#heap[0] = last\n      this.#bubbleDown(0)\n    }\n    return top\n  }\n\n  /**\n   * Retorna el elemento de mayor prioridad sin eliminarlo.\n   */\n  peek(): T | undefined {\n    return this.#heap[0]?.value\n  }\n\n  /**\n   * Indica si la cola está vacía.\n   */\n  isEmpty(): boolean {\n    return this.#heap.length === 0\n  }\n\n  /**\n   * Número de elementos en la cola.\n   */\n  get size(): number {\n    return this.#heap.length\n  }\n\n  /**\n   * Retorna los elementos en orden interno del heap (no necesariamente ordenados).\n   */\n  toArray(): T[] {\n    return this.#heap.map(e => e.value)\n  }\n\n  /**\n   * Vacía la cola completamente.\n   */\n  clear(): void {\n    this.#heap.length = 0\n    this.#seq = 0\n  }\n\n  // ── Comparación interna ────────────────────────────────────────────────\n\n  /**\n   * Compara dos heap entries usando el comparador del usuario.\n   * En modo stable, el número de secuencia actúa como desempate FIFO\n   * cuando el comparador retorna 0.\n   */\n  #compare(\n    a: { value: T; seq: number },\n    b: { value: T; seq: number }\n  ): number {\n    const result = this.#comparator(a.value, b.value)\n    if (result !== 0 || !this.#stable) return result\n    return a.seq - b.seq  // FIFO tiebreaker: menor seq = llegó antes\n  }\n\n  // ── Índices de nodos padre e hijos ────────────────────────────────────\n\n  #parent(i: number): number {\n    return Math.floor((i - 1) / 2)\n  }\n\n  #left(i: number): number {\n    return 2 * i + 1\n  }\n\n  #right(i: number): number {\n    return 2 * i + 2\n  }\n\n  #swap(i: number, j: number): void {\n    const tmp = this.#heap[i]\n    this.#heap[i] = this.#heap[j]\n    this.#heap[j] = tmp\n  }\n\n  /**\n   * Retorna el índice del hijo con mayor prioridad entre i, left y right.\n   */\n  #highestPriority(i: number, n: number): number {\n    let best = i\n    const left = this.#left(i)\n    const right = this.#right(i)\n    if (left < n && this.#compare(this.#heap[left], this.#heap[best]) < 0) best = left\n    if (right < n && this.#compare(this.#heap[right], this.#heap[best]) < 0) best = right\n    return best\n  }\n\n  #bubbleUp(i: number): void {\n    while (i > 0) {\n      const parent = this.#parent(i)\n      if (this.#compare(this.#heap[i], this.#heap[parent]) < 0) {\n        this.#swap(i, parent)\n        i = parent\n      } else {\n        break\n      }\n    }\n  }\n\n  #bubbleDown(i: number): void {\n    const n = this.#heap.length\n    let next = this.#highestPriority(i, n)\n    while (next !== i) {\n      this.#swap(i, next)\n      i = next\n      next = this.#highestPriority(i, n)\n    }\n  }\n}\n","/**\n * Nodo interno del árbol AVL.\n */\nexport interface AVLNode<T> {\n  value: T\n  left: AVLNode<T> | null\n  right: AVLNode<T> | null\n  height: number\n}\n\n/**\n * Árbol AVL — árbol binario de búsqueda auto-balanceado.\n * Garantiza O(log n) en inserción, búsqueda y eliminación independientemente del orden de inserción.\n * El factor de balance (altura izquierda − derecha) se mantiene entre −1 y 1 en todo momento.\n * @template T - El tipo de los valores almacenados.\n */\nexport class AVLTree<T> {\n  root: AVLNode<T> | null = null\n  #size = 0\n  #didDelete = false\n  readonly #comparator: (a: T, b: T) => number\n\n  /**\n   * @param comparator - Función de comparación opcional (a, b) => number.\n   *   Por defecto usa el operador < para primitivos.\n   */\n  constructor(comparator?: (a: T, b: T) => number) {\n    this.#comparator = comparator ?? ((a, b) => {\n      if (a < b) return -1\n      if (a > b) return 1\n      return 0\n    })\n  }\n\n  /**\n   * Inserta un valor en el árbol.\n   * Si el valor ya existe (según el comparador), lo actualiza.\n   */\n  insert(value: T): void {\n    this.root = this.#insert(this.root, value)\n  }\n\n  /**\n   * Busca si un valor existe en el árbol.\n   */\n  search(value: T): boolean {\n    let current = this.root\n    while (current !== null) {\n      const cmp = this.#comparator(value, current.value)\n      if (cmp === 0) return true\n      current = cmp < 0 ? current.left : current.right\n    }\n    return false\n  }\n\n  /**\n   * Elimina un valor del árbol. El árbol se rebalancea automáticamente.\n   * @returns true si el valor existía y fue eliminado, false si no existía.\n   */\n  delete(value: T): boolean {\n    this.#didDelete = false\n    this.root = this.#delete(this.root, value)\n    if (this.#didDelete) this.#size--\n    return this.#didDelete\n  }\n\n  /**\n   * Retorna el valor mínimo del árbol.\n   */\n  min(): T | undefined {\n    if (!this.root) return undefined\n    return this.#minNode(this.root).value\n  }\n\n  /**\n   * Retorna el valor máximo del árbol.\n   */\n  max(): T | undefined {\n    if (!this.root) return undefined\n    let node = this.root\n    while (node.right) node = node.right\n    return node.value\n  }\n\n  /**\n   * Traversal en orden (izquierda → raíz → derecha).\n   * Retorna los valores en orden ascendente según el comparador.\n   */\n  inOrder(): T[] {\n    const result: T[] = []\n    this.#inOrder(this.root, result)\n    return result\n  }\n\n  /**\n   * Traversal pre-orden (raíz → izquierda → derecha).\n   */\n  preOrder(): T[] {\n    const result: T[] = []\n    this.#preOrder(this.root, result)\n    return result\n  }\n\n  /**\n   * Traversal post-orden (izquierda → derecha → raíz).\n   */\n  postOrder(): T[] {\n    const result: T[] = []\n    this.#postOrder(this.root, result)\n    return result\n  }\n\n  /**\n   * Número de nodos en el árbol.\n   */\n  get size(): number {\n    return this.#size\n  }\n\n  /**\n   * Indica si el árbol está vacío.\n   */\n  isEmpty(): boolean {\n    return this.#size === 0\n  }\n\n  /**\n   * Vacía el árbol completamente.\n   */\n  clear(): void {\n    this.root = null\n    this.#size = 0\n  }\n\n  // ── Rotaciones y balance ──────────────────────────────────────────────\n\n  #height(node: AVLNode<T> | null): number {\n    return node?.height ?? 0\n  }\n\n  #balanceFactor(node: AVLNode<T>): number {\n    return this.#height(node.left) - this.#height(node.right)\n  }\n\n  #updateHeight(node: AVLNode<T>): void {\n    node.height = 1 + Math.max(this.#height(node.left), this.#height(node.right))\n  }\n\n  /**\n   * Rotación simple a la derecha (caso Izquierda-Izquierda).\n   */\n  #rotateRight(y: AVLNode<T>): AVLNode<T> {\n    const x = y.left!\n    const temp = x.right\n    x.right = y\n    y.left = temp\n    this.#updateHeight(y)\n    this.#updateHeight(x)\n    return x\n  }\n\n  /**\n   * Rotación simple a la izquierda (caso Derecha-Derecha).\n   */\n  #rotateLeft(x: AVLNode<T>): AVLNode<T> {\n    const y = x.right!\n    const temp = y.left\n    y.left = x\n    x.right = temp\n    this.#updateHeight(x)\n    this.#updateHeight(y)\n    return y\n  }\n\n  /**\n   * Rebalancea el nodo aplicando la rotación correspondiente según el factor de balance.\n   */\n  #balance(node: AVLNode<T>): AVLNode<T> {\n    this.#updateHeight(node)\n    const bf = this.#balanceFactor(node)\n    if (bf > 1) {\n      if (this.#balanceFactor(node.left!) < 0) {\n        node.left = this.#rotateLeft(node.left!)   // Caso Izquierda-Derecha\n      }\n      return this.#rotateRight(node)               // Caso Izquierda-Izquierda\n    }\n    if (bf < -1) {\n      if (this.#balanceFactor(node.right!) > 0) {\n        node.right = this.#rotateRight(node.right!) // Caso Derecha-Izquierda\n      }\n      return this.#rotateLeft(node)                 // Caso Derecha-Derecha\n    }\n    return node\n  }\n\n  // ── Operaciones recursivas internas ───────────────────────────────────\n\n  #insert(node: AVLNode<T> | null, value: T): AVLNode<T> {\n    if (!node) {\n      this.#size++\n      return { value, left: null, right: null, height: 1 }\n    }\n    const cmp = this.#comparator(value, node.value)\n    if (cmp < 0) {\n      node.left = this.#insert(node.left, value)\n    } else if (cmp > 0) {\n      node.right = this.#insert(node.right, value)\n    } else {\n      node.value = value  // Actualizar duplicado sin cambiar el tamaño\n      return node\n    }\n    return this.#balance(node)\n  }\n\n  #minNode(node: AVLNode<T>): AVLNode<T> {\n    let current = node\n    while (current.left) current = current.left\n    return current\n  }\n\n  #delete(node: AVLNode<T> | null, value: T): AVLNode<T> | null {\n    if (!node) return null\n    const cmp = this.#comparator(value, node.value)\n    if (cmp < 0) {\n      node.left = this.#delete(node.left, value)\n    } else if (cmp > 0) {\n      node.right = this.#delete(node.right, value)\n    } else {\n      this.#didDelete = true\n      if (!node.left) return node.right\n      if (!node.right) return node.left\n      // Dos hijos: reemplazar con el sucesor en orden (mínimo del subárbol derecho)\n      const successor = this.#minNode(node.right)\n      node.value = successor.value\n      this.#didDelete = false  // Se volverá true al eliminar el sucesor en la llamada recursiva\n      node.right = this.#delete(node.right, successor.value)\n    }\n    return this.#balance(node)\n  }\n\n  #inOrder(node: AVLNode<T> | null, result: T[]): void {\n    if (!node) return\n    this.#inOrder(node.left, result)\n    result.push(node.value)\n    this.#inOrder(node.right, result)\n  }\n\n  #preOrder(node: AVLNode<T> | null, result: T[]): void {\n    if (!node) return\n    result.push(node.value)\n    this.#preOrder(node.left, result)\n    this.#preOrder(node.right, result)\n  }\n\n  #postOrder(node: AVLNode<T> | null, result: T[]): void {\n    if (!node) return\n    this.#postOrder(node.left, result)\n    this.#postOrder(node.right, result)\n    result.push(node.value)\n  }\n}\n","/**\n * Grafo genérico representado como lista de adyacencia con pesos.\n * Soporta grafos dirigidos y no dirigidos, con aristas ponderadas opcionales.\n * Incluye recorridos BFS y DFS.\n * @template T - El tipo de los vértices. Debe ser usable como clave de Map.\n */\nexport class Graph<T> {\n  readonly #directed: boolean\n  readonly #adjacency = new Map<T, Map<T, number>>()\n  #edgeCount = 0\n\n  /**\n   * @param directed - true para grafo dirigido (por defecto), false para no dirigido.\n   */\n  constructor(directed = true) {\n    this.#directed = directed\n  }\n\n  /**\n   * Agrega un vértice al grafo. No hace nada si ya existe.\n   */\n  addVertex(v: T): void {\n    if (!this.#adjacency.has(v)) {\n      this.#adjacency.set(v, new Map())\n    }\n  }\n\n  /**\n   * Elimina un vértice y todas sus aristas incidentes.\n   * @returns true si el vértice existía, false si no.\n   */\n  removeVertex(v: T): boolean {\n    if (!this.#adjacency.has(v)) return false\n    this.#adjacency.delete(v)\n    for (const [, neighbors] of this.#adjacency) {\n      neighbors.delete(v)\n    }\n    this.#recomputeEdgeCount()\n    return true\n  }\n\n  /**\n   * Agrega una arista de u hacia v con peso opcional (por defecto 1).\n   * En grafos no dirigidos, también agrega v → u con el mismo peso.\n   * Crea los vértices automáticamente si no existen.\n   */\n  addEdge(u: T, v: T, weight = 1): void {\n    this.addVertex(u)\n    this.addVertex(v)\n    const isNew = !this.#adjacency.get(u)!.has(v)\n    this.#adjacency.get(u)!.set(v, weight)\n    if (!this.#directed) {\n      this.#adjacency.get(v)!.set(u, weight)\n    }\n    if (isNew) this.#edgeCount++\n  }\n\n  /**\n   * Elimina la arista de u a v.\n   * En grafos no dirigidos, también elimina v → u.\n   * @returns true si la arista existía, false si no.\n   */\n  removeEdge(u: T, v: T): boolean {\n    const neighbors = this.#adjacency.get(u)\n    if (!neighbors?.has(v)) return false\n    neighbors.delete(v)\n    this.#edgeCount--\n    if (!this.#directed) {\n      this.#adjacency.get(v)?.delete(u)\n    }\n    return true\n  }\n\n  /**\n   * Indica si el vértice existe en el grafo.\n   */\n  hasVertex(v: T): boolean {\n    return this.#adjacency.has(v)\n  }\n\n  /**\n   * Indica si existe una arista de u a v.\n   */\n  hasEdge(u: T, v: T): boolean {\n    return this.#adjacency.get(u)?.has(v) ?? false\n  }\n\n  /**\n   * Retorna los vértices adyacentes a v (destinos de sus aristas salientes).\n   */\n  neighbors(v: T): T[] {\n    return [...(this.#adjacency.get(v)?.keys() ?? [])]\n  }\n\n  /**\n   * Retorna el peso de la arista u → v, o undefined si no existe.\n   */\n  weight(u: T, v: T): number | undefined {\n    return this.#adjacency.get(u)?.get(v)\n  }\n\n  /**\n   * Recorrido en anchura (BFS) desde el vértice start.\n   * Visita primero los vértices más cercanos.\n   * @returns Array de vértices en orden de visita. Vacío si start no existe.\n   */\n  bfs(start: T): T[] {\n    if (!this.#adjacency.has(start)) return []\n    const visited = new Set<T>([start])\n    const queue: T[] = [start]\n    const result: T[] = []\n    while (queue.length > 0) {\n      const vertex = queue.shift()!\n      result.push(vertex)\n      for (const neighbor of this.#adjacency.get(vertex)!.keys()) {\n        if (!visited.has(neighbor)) {\n          visited.add(neighbor)\n          queue.push(neighbor)\n        }\n      }\n    }\n    return result\n  }\n\n  /**\n   * Recorrido en profundidad (DFS) desde el vértice start.\n   * Explora cada rama hasta el fondo antes de retroceder.\n   * @returns Array de vértices en orden de visita. Vacío si start no existe.\n   */\n  dfs(start: T): T[] {\n    if (!this.#adjacency.has(start)) return []\n    const visited = new Set<T>()\n    const stack: T[] = [start]\n    const result: T[] = []\n    while (stack.length > 0) {\n      const vertex = stack.pop()!\n      if (visited.has(vertex)) continue\n      visited.add(vertex)\n      result.push(vertex)\n      const adj = [...this.#adjacency.get(vertex)!.keys()].reverse()\n      for (const neighbor of adj) {\n        if (!visited.has(neighbor)) stack.push(neighbor)\n      }\n    }\n    return result\n  }\n\n  /**\n   * Número de vértices en el grafo.\n   */\n  get vertexCount(): number {\n    return this.#adjacency.size\n  }\n\n  /**\n   * Número de aristas en el grafo.\n   * En grafos no dirigidos, cada arista se cuenta una sola vez.\n   */\n  get edgeCount(): number {\n    return this.#edgeCount\n  }\n\n  /**\n   * Indica si el grafo está vacío (sin vértices).\n   */\n  isEmpty(): boolean {\n    return this.#adjacency.size === 0\n  }\n\n  /**\n   * Indica si el grafo es dirigido.\n   */\n  get directed(): boolean {\n    return this.#directed\n  }\n\n  /**\n   * Vacía el grafo completamente.\n   */\n  clear(): void {\n    this.#adjacency.clear()\n    this.#edgeCount = 0\n  }\n\n  #recomputeEdgeCount(): void {\n    let count = 0\n    for (const [, neighbors] of this.#adjacency) {\n      count += neighbors.size\n    }\n    this.#edgeCount = this.#directed ? count : count / 2\n  }\n}\n","export interface TrieNode {\n  children: Map<string, TrieNode>\n  isEnd: boolean\n}\n\n/**\n * Trie (árbol de prefijos) para almacenamiento y búsqueda eficiente de cadenas.\n * Inserción, búsqueda y eliminación en O(L), donde L es la longitud de la cadena.\n * Independiente del tamaño del diccionario; mucho más eficiente que un Set para prefijos.\n */\nexport class Trie {\n  readonly root: TrieNode = { children: new Map(), isEnd: false }\n  #size = 0\n\n  /**\n   * Inserta una palabra en el trie.\n   * Si ya existe, no modifica el tamaño.\n   */\n  insert(word: string): void {\n    let current = this.root\n    for (const char of word) {\n      if (!current.children.has(char)) {\n        current.children.set(char, { children: new Map(), isEnd: false })\n      }\n      current = current.children.get(char)!\n    }\n    if (!current.isEnd) {\n      current.isEnd = true\n      this.#size++\n    }\n  }\n\n  /**\n   * Busca si la palabra exacta existe en el trie.\n   */\n  search(word: string): boolean {\n    return this.#traverse(word)?.isEnd ?? false\n  }\n\n  /**\n   * Comprueba si alguna palabra del trie comienza con el prefijo dado.\n   */\n  startsWith(prefix: string): boolean {\n    return this.#traverse(prefix) !== null\n  }\n\n  /**\n   * Elimina una palabra del trie.\n   * Poda las ramas que queden completamente vacías.\n   * @returns true si la palabra existía y fue eliminada, false si no existía.\n   */\n  delete(word: string): boolean {\n    const deleted = this.#delete(this.root, word, 0)\n    if (deleted) this.#size--\n    return deleted\n  }\n\n  /**\n   * Retorna todas las palabras del trie que comienzan con el prefijo dado.\n   * Retorna array vacío si no hay coincidencias.\n   */\n  wordsWithPrefix(prefix: string): string[] {\n    const node = this.#traverse(prefix)\n    if (!node) return []\n    const results: string[] = []\n    this.#collect(node, prefix, results)\n    return results\n  }\n\n  /**\n   * Número de palabras distintas en el trie.\n   */\n  get size(): number {\n    return this.#size\n  }\n\n  /**\n   * Indica si el trie está vacío.\n   */\n  isEmpty(): boolean {\n    return this.#size === 0\n  }\n\n  /**\n   * Vacía el trie completamente.\n   */\n  clear(): void {\n    this.root.children.clear()\n    this.root.isEnd = false\n    this.#size = 0\n  }\n\n  #traverse(str: string): TrieNode | null {\n    let current = this.root\n    for (const char of str) {\n      if (!current.children.has(char)) return null\n      current = current.children.get(char)!\n    }\n    return current\n  }\n\n  #delete(node: TrieNode, word: string, depth: number): boolean {\n    if (depth === word.length) {\n      if (!node.isEnd) return false\n      node.isEnd = false\n      return true\n    }\n    const char = word[depth]!\n    const child = node.children.get(char)\n    if (!child) return false\n    const deleted = this.#delete(child, word, depth + 1)\n    // Podar la rama si quedó vacía y no es fin de otra palabra\n    if (deleted && !child.isEnd && child.children.size === 0) {\n      node.children.delete(char)\n    }\n    return deleted\n  }\n\n  #collect(node: TrieNode, prefix: string, results: string[]): void {\n    if (node.isEnd) results.push(prefix)\n    for (const [char, child] of node.children) {\n      this.#collect(child, prefix + char, results)\n    }\n  }\n}\n"],"mappings":"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","names":[]}