rlint 0.4.0 → 0.6.0

package/dist/proxy/client-script.js

@@ -0,0 +1,449 @@
+/**
+ * Generates the client-side JavaScript that gets injected into pages via the proxy.
+ * This script runs all rlint checks directly in the user's browser and POSTs
+ * results back to the proxy server.
+ *
+ * The check logic mirrors the page.evaluate() bodies in src/checks/*.ts.
+ */
+export function getClientScript() {
+    return `(function() {
+  'use strict';
+  if (window.__rlint__) return;
+  window.__rlint__ = { version: '0.6.0', results: null };
+
+  var ENDPOINT = '/__rlint__/results';
+  var IGNORE = ['[data-rlint-ignore]'];
+  var INTERACTIVE = ['button','a','input:not([type="hidden"])','select','textarea','[role="button"]','[role="link"]','[onclick]','[tabindex="0"]'];
+
+  // === Shared helpers ===
+
+  function makeSelector(el) {
+    var s = el.tagName.toLowerCase();
+    if (el.id) s += '#' + el.id;
+    if (el.className && typeof el.className === 'string') {
+      s += '.' + el.className.trim().split(/\\s+/).join('.');
+    }
+    return s;
+  }
+
+  function makeRect(rect) {
+    return { width: rect.width, height: rect.height, left: rect.left, top: rect.top, right: rect.right, bottom: rect.bottom };
+  }
+
+  function isIgnored(el, extra) {
+    var sels = IGNORE.concat(extra || []);
+    for (var i = 0; i < sels.length; i++) {
+      try { if (el.matches(sels[i])) return true; } catch(e) {}
+    }
+    return false;
+  }
+
+  function isHidden(el) {
+    var s = getComputedStyle(el);
+    return s.display === 'none' || s.visibility === 'hidden' || s.opacity === '0';
+  }
+
+  function isOffScreen(rect) {
+    return rect.right < 0 || rect.bottom < 0 || rect.left > window.innerWidth || rect.top > window.innerHeight;
+  }
+
+  function makeElement(el, rect) {
+    return {
+      selector: makeSelector(el),
+      tagName: el.tagName,
+      className: typeof el.className === 'string' ? el.className : '',
+      id: el.id || null,
+      textContent: (el.textContent || '').slice(0, 50).trim() || null,
+      rect: makeRect(rect || el.getBoundingClientRect()),
+    };
+  }
+
+  // === Check: Overflow ===
+  function checkOverflow() {
+    var issues = [];
+    var vw = window.innerWidth;
+    var docW = document.documentElement.scrollWidth;
+    if (docW <= vw) return { check: 'overflow', passed: 1, issues: issues };
+
+    var all = document.querySelectorAll('*');
+    var culprits = [];
+    for (var i = 0; i < all.length; i++) {
+      var el = all[i];
+      if (isIgnored(el)) continue;
+      var rect = el.getBoundingClientRect();
+      if (rect.right > vw + 1) {
+        culprits.push({ el: el, rect: rect, overflow: rect.right - vw });
+      }
+    }
+    culprits.sort(function(a, b) { return b.overflow - a.overflow; });
+    culprits = culprits.slice(0, 10);
+
+    if (culprits.length > 0) {
+      var main = culprits[0];
+      issues.push({
+        check: 'overflow',
+        severity: 'error',
+        message: 'Horizontal overflow detected (page scrolls ' + (docW - vw) + 'px beyond viewport)',
+        element: makeElement(main.el, main.rect),
+        details: {
+          documentScrollWidth: docW,
+          viewportWidth: vw,
+          overflowAmount: main.overflow,
+          otherCulprits: culprits.slice(1).map(function(c) { return makeSelector(c.el); }),
+        },
+        fixHint: 'Add overflow-x: hidden to a container, or check for elements with fixed widths, 100vw, or negative margins',
+      });
+    }
+    return { check: 'overflow', passed: issues.length === 0 ? 1 : 0, issues: issues };
+  }
+
+  // === Check: Clickability ===
+  function checkClickability() {
+    var issues = [];
+    var EDGE_INSET = 2;
+    var selectorStr = INTERACTIVE.join(', ');
+    var elements = document.querySelectorAll(selectorStr);
+    var total = 0;
+
+    function isCovered(el, x, y) {
+      if (x < 0 || y < 0 || x > window.innerWidth || y > window.innerHeight) return null;
+      var top = document.elementFromPoint(x, y);
+      if (top && top !== el && !el.contains(top) && !top.contains(el)) return top;
+      return null;
+    }
+
+    for (var i = 0; i < elements.length; i++) {
+      var el = elements[i];
+      if (isIgnored(el)) continue;
+      if (isHidden(el)) continue;
+      var rect = el.getBoundingClientRect();
+      if (rect.width === 0 || rect.height === 0) continue;
+      if (isOffScreen(rect)) continue;
+      total++;
+
+      var points = [
+        { name: 'center', x: rect.left + rect.width / 2, y: rect.top + rect.height / 2 },
+        { name: 'top-left', x: rect.left + EDGE_INSET, y: rect.top + EDGE_INSET },
+        { name: 'top-right', x: rect.right - EDGE_INSET, y: rect.top + EDGE_INSET },
+        { name: 'bottom-left', x: rect.left + EDGE_INSET, y: rect.bottom - EDGE_INSET },
+        { name: 'bottom-right', x: rect.right - EDGE_INSET, y: rect.bottom - EDGE_INSET },
+      ];
+
+      var coveredPoints = [];
+      var firstCoverer = null;
+      for (var j = 0; j < points.length; j++) {
+        var coverer = isCovered(el, points[j].x, points[j].y);
+        if (coverer) {
+          coveredPoints.push(points[j].name);
+          if (!firstCoverer) firstCoverer = coverer;
+        }
+      }
+
+      if (coveredPoints.length > 0 && firstCoverer) {
+        var allCovered = coveredPoints.length === points.length;
+        var desc = allCovered ? 'fully covered' : 'partially covered (' + coveredPoints.join(', ') + ')';
+        issues.push({
+          check: 'clickability',
+          severity: 'error',
+          message: 'Interactive element is ' + desc + ' by another element',
+          element: makeElement(el, rect),
+          details: {
+            coveredBy: makeSelector(firstCoverer),
+            coveredPoints: coveredPoints,
+            totalPoints: points.length,
+          },
+          fixHint: 'Check z-index of ' + makeSelector(el) + ' and ' + makeSelector(firstCoverer) + ', or remove/reposition the covering element',
+        });
+      }
+    }
+    return { check: 'clickability', passed: Math.max(0, total - issues.length), issues: issues };
+  }
+
+  // === Check: Touch Targets ===
+  function checkTouchTargets() {
+    var issues = [];
+    var MIN_W = 44, MIN_H = 44, MIN_GAP = 8, MAX_PAIRS = 20;
+    var sels = ['button','a','input:not([type="hidden"])','select','textarea','[role="button"]','[role="link"]','[role="checkbox"]','[role="radio"]','[tabindex="0"]'];
+    var elements = document.querySelectorAll(sels.join(', '));
+    var visible = [];
+    var total = 0;
+
+    for (var i = 0; i < elements.length; i++) {
+      var el = elements[i];
+      if (isIgnored(el)) continue;
+      if (isHidden(el)) continue;
+      var rect = el.getBoundingClientRect();
+      if (rect.width === 0 && rect.height === 0) continue;
+      if (isOffScreen(rect)) continue;
+      visible.push({ el: el, rect: rect });
+      total++;
+
+      if (rect.width < MIN_W || rect.height < MIN_H) {
+        issues.push({
+          check: 'touch-targets',
+          severity: 'warning',
+          message: 'Touch target too small: ' + Math.round(rect.width) + 'x' + Math.round(rect.height) + 'px (min: ' + MIN_W + 'x' + MIN_H + 'px)',
+          element: makeElement(el, rect),
+          details: { actualWidth: rect.width, actualHeight: rect.height, minWidth: MIN_W, minHeight: MIN_H },
+          fixHint: 'Add min-width: ' + MIN_W + 'px and min-height: ' + MIN_H + 'px, or increase padding',
+        });
+      }
+    }
+
+    // Spacing check
+    var pairCount = 0;
+    for (var a = 0; a < visible.length && pairCount < MAX_PAIRS; a++) {
+      for (var b = a + 1; b < visible.length && pairCount < MAX_PAIRS; b++) {
+        var va = visible[a], vb = visible[b];
+        if (va.el.contains(vb.el) || vb.el.contains(va.el)) continue;
+
+        var hGap = Math.max(0, Math.max(vb.rect.left - va.rect.right, va.rect.left - vb.rect.right));
+        var vGap = Math.max(0, Math.max(vb.rect.top - va.rect.bottom, va.rect.top - vb.rect.bottom));
+        var oH = va.rect.right > vb.rect.left && vb.rect.right > va.rect.left;
+        var oV = va.rect.bottom > vb.rect.top && vb.rect.bottom > va.rect.top;
+
+        var gap;
+        if (oH && oV) gap = 0;
+        else if (oH) gap = vGap;
+        else if (oV) gap = hGap;
+        else gap = Math.sqrt(hGap * hGap + vGap * vGap);
+
+        if (gap < MIN_GAP) {
+          pairCount++;
+          var selA = makeSelector(va.el), selB = makeSelector(vb.el);
+          issues.push({
+            check: 'touch-targets',
+            severity: 'warning',
+            message: 'Touch targets too close: ' + Math.round(gap) + 'px gap between ' + selA + ' and ' + selB + ' (min: ' + MIN_GAP + 'px)',
+            element: makeElement(va.el, va.rect),
+            details: { gap: Math.round(gap), minGap: MIN_GAP, nearElement: selB },
+            fixHint: 'Add at least ' + MIN_GAP + 'px margin between ' + selA + ' and ' + selB,
+          });
+        }
+      }
+    }
+    return { check: 'touch-targets', passed: Math.max(0, total - issues.length), issues: issues };
+  }
+
+  // === Check: Visibility ===
+  function checkVisibility() {
+    var issues = [];
+    var sels = ['button','a[href]','input:not([type="hidden"])','select','textarea','[role="button"]'];
+    var ignoreExtra = ['[aria-hidden="true"]','.sr-only','.visually-hidden','[hidden]'];
+    var elements = document.querySelectorAll(sels.join(', '));
+    var total = 0;
+
+    for (var i = 0; i < elements.length; i++) {
+      var el = elements[i];
+      if (isIgnored(el, ignoreExtra)) continue;
+      total++;
+
+      var style = getComputedStyle(el);
+      var rect = el.getBoundingClientRect();
+      var reason = null;
+
+      if (style.display === 'none') reason = 'display: none';
+      else if (style.visibility === 'hidden') reason = 'visibility: hidden';
+      else if (style.opacity === '0') reason = 'opacity: 0';
+      else if (rect.width === 0 && rect.height === 0) reason = 'zero size (0x0)';
+      else if (rect.right < 0) reason = 'off-screen left';
+      else if (rect.bottom < 0) reason = 'off-screen top';
+      else if (rect.left > window.innerWidth) reason = 'off-screen right';
+      else if (rect.top > window.innerHeight) reason = 'off-screen bottom';
+      else if (style.clipPath && style.clipPath.indexOf('inset(100%)') !== -1) reason = 'clipped (clip-path)';
+
+      if (reason) {
+        var parent = el.parentElement;
+        if (parent) {
+          var ps = getComputedStyle(parent);
+          if (ps.display === 'none' || ps.visibility === 'hidden') continue;
+        }
+        issues.push({
+          check: 'visibility',
+          severity: 'warning',
+          message: 'Interactive element is not visible: ' + reason,
+          element: makeElement(el, rect),
+          details: { reason: reason },
+          fixHint: 'Check if this element should be visible. If intentionally hidden, add [data-rlint-ignore] or .sr-only',
+        });
+      }
+    }
+    return { check: 'visibility', passed: Math.max(0, total - issues.length), issues: issues };
+  }
+
+  // === Check: Text Overflow ===
+  function checkTextOverflow() {
+    var issues = [];
+    var ignoreExtra = ['.truncate','[data-truncate]','.line-clamp'];
+    var elements = document.querySelectorAll('p, span, h1, h2, h3, h4, h5, h6, label, li, td, th, div, a');
+
+    for (var i = 0; i < elements.length; i++) {
+      var el = elements[i];
+      if (isIgnored(el, ignoreExtra)) continue;
+      var style = getComputedStyle(el);
+      if (style.display === 'none' || style.visibility === 'hidden') continue;
+      if (!(el.textContent || '').trim()) continue;
+
+      var hOver = el.scrollWidth > el.clientWidth + 1;
+      var vOver = el.scrollHeight > el.clientHeight + 1;
+      if (!hOver && !vOver) continue;
+
+      var hasScroll = ['scroll','auto'].indexOf(style.overflow) !== -1 ||
+        ['scroll','auto'].indexOf(style.overflowX) !== -1 ||
+        ['scroll','auto'].indexOf(style.overflowY) !== -1;
+      if (hasScroll) continue;
+
+      if (style.textOverflow === 'ellipsis') continue;
+      if (style.webkitLineClamp) continue;
+
+      var isClipping = style.overflow === 'hidden' || style.overflowX === 'hidden' || style.overflowY === 'hidden';
+      if (isClipping || (!hasScroll && (hOver || vOver))) {
+        var rect = el.getBoundingClientRect();
+        var dir = (hOver && vOver) ? 'both directions' : hOver ? 'horizontally' : 'vertically';
+        issues.push({
+          check: 'text-overflow',
+          severity: 'warning',
+          message: 'Text overflows container ' + dir,
+          element: makeElement(el, rect),
+          details: { scrollWidth: el.scrollWidth, clientWidth: el.clientWidth, scrollHeight: el.scrollHeight, clientHeight: el.clientHeight },
+          fixHint: 'Add overflow: auto for scrolling, text-overflow: ellipsis for truncation, or increase container size',
+        });
+        if (issues.length >= 20) break;
+      }
+    }
+    return { check: 'text-overflow', passed: 0, issues: issues };
+  }
+
+  // === Check: Viewport Meta ===
+  function checkViewportMeta() {
+    var issues = [];
+    var dummy = { selector: 'head', tagName: 'HEAD', className: '', id: null, textContent: null, rect: { width: 0, height: 0, left: 0, top: 0, right: 0, bottom: 0 } };
+    var meta = document.querySelector('meta[name="viewport"]');
+
+    if (!meta) {
+      issues.push({
+        check: 'viewport-meta',
+        severity: 'warning',
+        message: 'Missing viewport meta tag — page will not render correctly on mobile devices',
+        element: dummy,
+        details: { expected: '<meta name="viewport" content="width=device-width, initial-scale=1">' },
+        fixHint: 'Add <meta name="viewport" content="width=device-width, initial-scale=1"> to <head>',
+      });
+    } else {
+      var content = meta.getAttribute('content') || '';
+      var directives = content.split(',').map(function(d) { return d.trim().toLowerCase(); });
+
+      var hasWidth = directives.some(function(d) { return d.replace(/\\s+/g, '').indexOf('width=device-width') === 0; });
+      var hasNoScale = directives.some(function(d) { var c = d.replace(/\\s+/g, ''); return c === 'user-scalable=no' || c === 'user-scalable=0'; });
+      var hasMaxScale = directives.some(function(d) { var c = d.replace(/\\s+/g, ''); return c.indexOf('maximum-scale=') === 0 && parseFloat(c.split('=')[1]) <= 1; });
+
+      if (!hasWidth) {
+        issues.push({
+          check: 'viewport-meta',
+          severity: 'warning',
+          message: 'Viewport meta tag is missing width=device-width — mobile browsers will use default 980px width',
+          element: dummy,
+          details: { current: content, expected: 'width=device-width' },
+          fixHint: 'Add width=device-width to your viewport meta tag',
+        });
+      }
+      if (hasNoScale) {
+        issues.push({
+          check: 'viewport-meta',
+          severity: 'warning',
+          message: 'Viewport meta tag disables user scaling — this is an accessibility problem (WCAG 1.4.4)',
+          element: dummy,
+          details: { current: content, problem: 'user-scalable=no' },
+          fixHint: 'Remove user-scalable=no from your viewport meta tag to allow pinch-to-zoom',
+        });
+      }
+      if (hasMaxScale) {
+        issues.push({
+          check: 'viewport-meta',
+          severity: 'warning',
+          message: 'Viewport meta tag restricts maximum scale to 1 — this prevents pinch-to-zoom (WCAG 1.4.4)',
+          element: dummy,
+          details: { current: content, problem: 'maximum-scale=1' },
+          fixHint: 'Remove maximum-scale=1 or set it to at least 5 to allow zooming',
+        });
+      }
+    }
+    return { check: 'viewport-meta', passed: issues.length === 0 ? 1 : 0, issues: issues };
+  }
+
+  // === Runner ===
+  function runAllChecks() {
+    var checks = [checkOverflow, checkClickability, checkTouchTargets, checkVisibility, checkTextOverflow, checkViewportMeta];
+    var allIssues = [];
+    var passed = 0;
+
+    for (var i = 0; i < checks.length; i++) {
+      try {
+        var result = checks[i]();
+        allIssues = allIssues.concat(result.issues);
+        passed += result.passed;
+      } catch(e) {
+        console.warn('[rlint] check error:', e);
+      }
+    }
+
+    var errors = 0, warnings = 0;
+    for (var j = 0; j < allIssues.length; j++) {
+      if (allIssues[j].severity === 'error') errors++;
+      else if (allIssues[j].severity === 'warning') warnings++;
+    }
+
+    var results = {
+      url: location.pathname + location.search,
+      viewport: { width: window.innerWidth, height: window.innerHeight },
+      timestamp: new Date().toISOString(),
+      summary: { passed: passed, errors: errors, warnings: warnings },
+      issues: allIssues,
+    };
+
+    window.__rlint__.results = results;
+
+    fetch(ENDPOINT, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(results),
+    }).catch(function() {});
+
+    return results;
+  }
+
+  // === Navigation detection ===
+  var debounceTimer = null;
+  function scheduleCheck() {
+    clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(runAllChecks, 800);
+  }
+
+  var origPush = history.pushState;
+  var origReplace = history.replaceState;
+  history.pushState = function() { origPush.apply(this, arguments); scheduleCheck(); };
+  history.replaceState = function() { origReplace.apply(this, arguments); scheduleCheck(); };
+  window.addEventListener('popstate', scheduleCheck);
+
+  // === Initial run ===
+  if (document.readyState === 'complete' || document.readyState === 'interactive') {
+    setTimeout(runAllChecks, 500);
+  } else {
+    window.addEventListener('DOMContentLoaded', function() { setTimeout(runAllChecks, 500); });
+  }
+
+  // === MutationObserver for dynamic content ===
+  setTimeout(function() {
+    var mutTimer = null;
+    var observer = new MutationObserver(function() {
+      clearTimeout(mutTimer);
+      mutTimer = setTimeout(runAllChecks, 2000);
+    });
+    if (document.body) {
+      observer.observe(document.body, { childList: true, subtree: true });
+    }
+  }, 3000);
+
+})();`;
+}
+//# sourceMappingURL=client-script.js.map

package/dist/proxy/client-script.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-script.js","sourceRoot":"","sources":["../../src/proxy/client-script.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,UAAU,eAAe;IAC7B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAsbH,CAAC;AACP,CAAC"}

package/dist/proxy/index.d.ts

@@ -0,0 +1,4 @@
+export { createProxyServer, type ProxyServer, type ProxyOptions } from './server.js';
+export { getClientScript } from './client-script.js';
+export { ResultCache, type CachedResult } from './result-cache.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/proxy/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/proxy/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,KAAK,WAAW,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AACrF,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,WAAW,EAAE,KAAK,YAAY,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/proxy/index.js

@@ -0,0 +1,4 @@
+export { createProxyServer } from './server.js';
+export { getClientScript } from './client-script.js';
+export { ResultCache } from './result-cache.js';
+//# sourceMappingURL=index.js.map

package/dist/proxy/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/proxy/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAuC,MAAM,aAAa,CAAC;AACrF,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,WAAW,EAAqB,MAAM,mBAAmB,CAAC"}

package/dist/proxy/result-cache.d.ts

@@ -0,0 +1,46 @@
+export interface CachedResult {
+    url: string;
+    viewport: {
+        width: number;
+        height: number;
+    };
+    timestamp: string;
+    summary: {
+        passed: number;
+        errors: number;
+        warnings: number;
+    };
+    issues: Array<{
+        check: string;
+        severity: 'error' | 'warning' | 'info';
+        message: string;
+        element: {
+            selector: string;
+            tagName: string;
+            className: string;
+            id: string | null;
+            textContent: string | null;
+            rect: {
+                width: number;
+                height: number;
+                left: number;
+                top: number;
+                right: number;
+                bottom: number;
+            };
+        };
+        details: Record<string, unknown>;
+        fixHint?: string;
+    }>;
+}
+export declare class ResultCache {
+    private cache;
+    set(url: string, result: CachedResult): void;
+    get(url: string): CachedResult | undefined;
+    getAll(): CachedResult[];
+    has(url: string): boolean;
+    clear(): void;
+    get size(): number;
+    private normalize;
+}
+//# sourceMappingURL=result-cache.d.ts.map

package/dist/proxy/result-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-cache.d.ts","sourceRoot":"","sources":["../../src/proxy/result-cache.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAC5C,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9D,MAAM,EAAE,KAAK,CAAC;QACZ,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;QACvC,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE;YACP,QAAQ,EAAE,MAAM,CAAC;YACjB,OAAO,EAAE,MAAM,CAAC;YAChB,SAAS,EAAE,MAAM,CAAC;YAClB,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;YAClB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;YAC3B,IAAI,EAAE;gBAAE,KAAK,EAAE,MAAM,CAAC;gBAAC,MAAM,EAAE,MAAM,CAAC;gBAAC,IAAI,EAAE,MAAM,CAAC;gBAAC,GAAG,EAAE,MAAM,CAAC;gBAAC,KAAK,EAAE,MAAM,CAAC;gBAAC,MAAM,EAAE,MAAM,CAAA;aAAE,CAAC;SACnG,CAAC;QACF,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACjC,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC,CAAC;CACJ;AAED,qBAAa,WAAW;IACtB,OAAO,CAAC,KAAK,CAAmC;IAEhD,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,GAAG,IAAI;IAK5C,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAI1C,MAAM,IAAI,YAAY,EAAE;IAIxB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzB,KAAK,IAAI,IAAI;IAIb,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,OAAO,CAAC,SAAS;CAIlB"}

package/dist/proxy/result-cache.js

@@ -0,0 +1,27 @@
+export class ResultCache {
+    cache = new Map();
+    set(url, result) {
+        const key = this.normalize(url);
+        this.cache.set(key, result);
+    }
+    get(url) {
+        return this.cache.get(this.normalize(url));
+    }
+    getAll() {
+        return Array.from(this.cache.values());
+    }
+    has(url) {
+        return this.cache.has(this.normalize(url));
+    }
+    clear() {
+        this.cache.clear();
+    }
+    get size() {
+        return this.cache.size;
+    }
+    normalize(url) {
+        // Strip trailing slash and hash fragment
+        return url.replace(/\/$/, '').replace(/#.*$/, '');
+    }
+}
+//# sourceMappingURL=result-cache.js.map

package/dist/proxy/result-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-cache.js","sourceRoot":"","sources":["../../src/proxy/result-cache.ts"],"names":[],"mappings":"AAsBA,MAAM,OAAO,WAAW;IACd,KAAK,GAAG,IAAI,GAAG,EAAwB,CAAC;IAEhD,GAAG,CAAC,GAAW,EAAE,MAAoB;QACnC,MAAM,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;QAChC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;IAC9B,CAAC;IAED,GAAG,CAAC,GAAW;QACb,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC;IAC7C,CAAC;IAED,MAAM;QACJ,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;IACzC,CAAC;IAED,GAAG,CAAC,GAAW;QACb,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC;IAC7C,CAAC;IAED,KAAK;QACH,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;IACrB,CAAC;IAED,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC;IACzB,CAAC;IAEO,SAAS,CAAC,GAAW;QAC3B,yCAAyC;QACzC,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IACpD,CAAC;CACF"}

package/dist/proxy/server.d.ts

@@ -0,0 +1,17 @@
+import { type CachedResult } from './result-cache.js';
+export interface ProxyOptions {
+    target: string;
+    port?: number;
+    onResults?: (result: CachedResult) => void;
+}
+export interface ProxyServer {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getResults(): CachedResult[];
+    getResult(url: string): CachedResult | undefined;
+    clearResults(): void;
+    readonly port: number;
+    readonly target: string;
+}
+export declare function createProxyServer(options: ProxyOptions): ProxyServer;
+//# sourceMappingURL=server.d.ts.map

package/dist/proxy/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/proxy/server.ts"],"names":[],"mappings":"AAGA,OAAO,EAAe,KAAK,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEnE,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,CAAC;CAC5C;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,UAAU,IAAI,YAAY,EAAE,CAAC;IAC7B,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAAC;IACjD,YAAY,IAAI,IAAI,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,YAAY,GAAG,WAAW,CAqNpE"}