@skyramp/mcp 0.1.8 → 0.2.0-rc.1

package/node_modules/playwright/lib/dom-analyzer/crawler.js

@@ -0,0 +1,384 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var crawler_exports = {};
+__export(crawler_exports, {
+  crawl: () => crawl,
+  crawlSinglePage: () => crawlSinglePage
+});
+module.exports = __toCommonJS(crawler_exports);
+var playwright = __toESM(require("playwright-core"));
+var import_blueprint = require("./blueprint");
+var import_serialization = require("./serialization");
+const DESTRUCTIVE_VERB_RE = /(delete|remove|destroy|submit|send|confirm|place\s*order|checkout|pay|purchase|buy|charge|cancel|close\s*account|deactivate|publish|approve|reject|logout|sign\s*out)/i;
+function isSameOrigin(a, b) {
+  try {
+    return new URL(a).origin === new URL(b).origin;
+  } catch {
+    return false;
+  }
+}
+function isBogusHref(href) {
+  if (!href)
+    return true;
+  const trimmed = href.trim();
+  if (!trimmed)
+    return true;
+  const stripped = trimmed.replace(/^["']|["']$/g, "");
+  if (!stripped || stripped === "#")
+    return true;
+  if (stripped.startsWith("#"))
+    return true;
+  if (/^javascript:/i.test(stripped))
+    return true;
+  if (/^mailto:/i.test(stripped))
+    return true;
+  if (/^tel:/i.test(stripped))
+    return true;
+  return false;
+}
+function resolveUrl(href, base) {
+  try {
+    return new URL(href, base).href;
+  } catch {
+    return null;
+  }
+}
+function substituteUrlSegments(url, params) {
+  try {
+    const parsed = new URL(url);
+    const segments = parsed.pathname.split("/");
+    for (let i = 0; i < segments.length; i++) {
+      for (const [paramName, paramValue] of Object.entries(params)) {
+        if (paramValue && segments[i] === paramValue) {
+          segments[i] = `{${paramName}}`;
+          break;
+        }
+      }
+    }
+    parsed.pathname = segments.join("/");
+    const newParams = new URLSearchParams();
+    for (const [key, value] of parsed.searchParams.entries()) {
+      let replaced = value;
+      for (const [paramName, paramValue] of Object.entries(params)) {
+        if (paramValue && replaced === paramValue) {
+          replaced = `{${paramName}}`;
+          break;
+        }
+      }
+      newParams.append(key, replaced);
+    }
+    parsed.search = newParams.toString();
+    return parsed.href.replace(/%7B/gi, "{").replace(/%7D/gi, "}");
+  } catch {
+    return url;
+  }
+}
+async function probeClickNavigations(page, fromUrl, blueprint, probeMode, sameOriginOnly, entryUrl, bogusHrefLinkLabels) {
+  if (probeMode === "none")
+    return [];
+  const results = [];
+  const seenXpaths = /* @__PURE__ */ new Set();
+  const candidates = [];
+  for (const section of blueprint.sections) {
+    for (const el of section.elements) {
+      if (el.role === "button") {
+        candidates.push({
+          logicalName: el.logicalName,
+          label: el.accessibleName,
+          role: "button",
+          xpath: el.xpath,
+          mutability: el.mutability
+        });
+      } else if (el.role === "link" && bogusHrefLinkLabels.has(el.accessibleName)) {
+        candidates.push({
+          logicalName: el.logicalName,
+          label: el.accessibleName,
+          role: "link",
+          xpath: el.xpath,
+          mutability: el.mutability
+        });
+      }
+    }
+    for (const rep of section.repeatingElements) {
+      if (rep.role !== "button" && rep.role !== "link")
+        continue;
+      if (rep.items.length === 0)
+        continue;
+      const probedItem = rep.items[0].parameters;
+      const label = rep.accessibleNameTemplate.replace(
+        /\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g,
+        (_, k) => probedItem[k] ?? `{${k}}`
+      );
+      if (rep.role === "link" && !bogusHrefLinkLabels.has(label))
+        continue;
+      candidates.push({
+        logicalName: rep.logicalName,
+        label,
+        role: rep.role,
+        xpath: (0, import_blueprint.resolveXpath)(rep, probedItem),
+        mutability: rep.mutability,
+        repeatingSource: {
+          parameters: [...rep.parameters],
+          probedItemParameters: { ...probedItem }
+        }
+      });
+    }
+  }
+  for (const candidate of candidates) {
+    if (seenXpaths.has(candidate.xpath))
+      continue;
+    seenXpaths.add(candidate.xpath);
+    if (probeMode === "immutable-only") {
+      if (candidate.mutability !== "immutable")
+        continue;
+      if (DESTRUCTIVE_VERB_RE.test(candidate.label))
+        continue;
+    }
+    try {
+      await page.goto(fromUrl, { waitUntil: "networkidle" });
+      const beforeUrl = page.url();
+      await page.locator(`xpath=${candidate.xpath}`).click();
+      try {
+        await page.waitForURL((url) => url.toString() !== beforeUrl, { timeout: 2e3 });
+      } catch {
+        continue;
+      }
+      const afterUrl = page.url();
+      if (afterUrl === beforeUrl)
+        continue;
+      if (sameOriginOnly && !isSameOrigin(afterUrl, entryUrl))
+        continue;
+      const mutability = candidate.mutability === "mutable" ? "mutable" : "immutable";
+      results.push({
+        logicalName: candidate.logicalName,
+        label: candidate.label,
+        url: (0, import_serialization.normalizeUrl)(afterUrl),
+        mutability,
+        probedRole: candidate.role,
+        repeatingSource: candidate.repeatingSource
+      });
+    } catch {
+    }
+  }
+  return results;
+}
+async function crawl(entryUrl, options) {
+  const { depth, maxPages, sameOriginOnly, probeButtons, playwrightStoragePath } = options;
+  const normalizedEntryUrl = (0, import_serialization.normalizeUrl)(entryUrl);
+  const visited = /* @__PURE__ */ new Set();
+  const pages = {};
+  const edges = [];
+  const browser = await playwright.chromium.launch();
+  try {
+    const context = await browser.newContext(playwrightStoragePath ? { storageState: playwrightStoragePath } : void 0);
+    const page = await context.newPage();
+    const queue = [{ url: normalizedEntryUrl, fromUrl: null, edgeVia: null, depth: 0 }];
+    while (queue.length > 0 && Object.keys(pages).length < maxPages) {
+      const entry = queue.shift();
+      const { url, fromUrl, edgeVia, depth: currentDepth } = entry;
+      if (visited.has(url))
+        continue;
+      visited.add(url);
+      await page.goto(url, { waitUntil: "networkidle" });
+      const resolvedUrl = (0, import_serialization.normalizeUrl)(page.url());
+      if (resolvedUrl !== url) {
+        if (visited.has(resolvedUrl))
+          continue;
+        visited.add(resolvedUrl);
+      }
+      let blueprint;
+      try {
+        blueprint = await (0, import_blueprint.buildPageBlueprint)(page);
+      } catch (err) {
+        if (err instanceof import_blueprint.BlueprintInvariantError) {
+          console.warn(`[dom-analyzer] Skipping blueprint for ${page.url()} \u2014 invariant violated: ${err.message}`);
+          continue;
+        }
+        throw err;
+      }
+      pages[resolvedUrl] = blueprint;
+      if (fromUrl && edgeVia) {
+        const via = {
+          logicalName: edgeVia.logicalName,
+          mutability: edgeVia.mutability
+        };
+        let toTemplate;
+        if (edgeVia.repeatingSource) {
+          const tmpl = substituteUrlSegments(
+            resolvedUrl,
+            edgeVia.repeatingSource.probedItemParameters
+          );
+          if (tmpl !== resolvedUrl) {
+            toTemplate = tmpl;
+            const usedParams = edgeVia.repeatingSource.parameters.filter(
+              (p) => tmpl.includes(`{${p}}`)
+            );
+            if (usedParams.length > 0)
+              via.parameters = usedParams;
+          }
+        }
+        edges.push({
+          from: (0, import_serialization.normalizeUrl)(fromUrl),
+          to: resolvedUrl,
+          ...toTemplate ? { toTemplate } : {},
+          via,
+          label: edgeVia.label,
+          action: edgeVia.action
+        });
+      }
+      if (currentDepth < depth) {
+        const aria = await page.locator("body").ariaSnapshot();
+        const bogusHrefLinkLabels = /* @__PURE__ */ new Set();
+        for (const { label, href } of extractLinksFromAriaSnapshot(aria)) {
+          if (isBogusHref(href)) {
+            bogusHrefLinkLabels.add(label);
+            continue;
+          }
+          const resolved = resolveUrl(href, resolvedUrl);
+          if (!resolved)
+            continue;
+          const normalized = (0, import_serialization.normalizeUrl)(resolved);
+          if (sameOriginOnly && !isSameOrigin(normalized, normalizedEntryUrl))
+            continue;
+          if (visited.has(normalized))
+            continue;
+          const linkMatch = findLinkByLabel(blueprint, label);
+          const logicalName = linkMatch?.logicalName ?? "unknown_link";
+          queue.push({
+            url: normalized,
+            fromUrl: resolvedUrl,
+            edgeVia: { logicalName, mutability: "immutable", action: "link", label },
+            depth: currentDepth + 1
+          });
+        }
+        const clickNavs = await probeClickNavigations(
+          page,
+          resolvedUrl,
+          blueprint,
+          probeButtons,
+          sameOriginOnly,
+          normalizedEntryUrl,
+          bogusHrefLinkLabels
+        );
+        for (const nav of clickNavs) {
+          if (visited.has(nav.url))
+            continue;
+          queue.push({
+            url: nav.url,
+            fromUrl: resolvedUrl,
+            edgeVia: {
+              logicalName: nav.logicalName,
+              mutability: nav.mutability,
+              // A probed link that took us to a new URL is recorded as a
+              // 'link' action (matches the nav intent). Probed buttons stay
+              // as 'click'.
+              action: nav.probedRole === "link" ? "link" : "click",
+              label: nav.label,
+              repeatingSource: nav.repeatingSource
+            },
+            depth: currentDepth + 1
+          });
+        }
+      }
+    }
+    await context.close();
+  } finally {
+    await browser.close();
+  }
+  return {
+    schemaVersion: import_serialization.SCHEMA_VERSION,
+    entryUrl: normalizedEntryUrl,
+    cachedAt: (0, import_serialization.nowTimestamp)(),
+    pages,
+    edges
+  };
+}
+async function crawlSinglePage(entryUrl, options) {
+  const browser = await playwright.chromium.launch();
+  try {
+    const context = await browser.newContext(options.playwrightStoragePath ? { storageState: options.playwrightStoragePath } : void 0);
+    const page = await context.newPage();
+    await page.goto(entryUrl, { waitUntil: "networkidle" });
+    let blueprint;
+    try {
+      blueprint = await (0, import_blueprint.buildPageBlueprint)(page);
+    } catch (err) {
+      if (err instanceof import_blueprint.BlueprintInvariantError) {
+        console.warn(`[dom-analyzer] Blueprint skipped \u2014 invariant violated: ${err.message}`);
+        await context.close();
+        throw err;
+      }
+      throw err;
+    }
+    const normalizedEntryUrl = (0, import_serialization.normalizeUrl)(page.url());
+    await context.close();
+    return {
+      schemaVersion: import_serialization.SCHEMA_VERSION,
+      entryUrl: normalizedEntryUrl,
+      cachedAt: (0, import_serialization.nowTimestamp)(),
+      pages: { [normalizedEntryUrl]: blueprint },
+      edges: []
+    };
+  } finally {
+    await browser.close();
+  }
+}
+function extractLinksFromAriaSnapshot(aria) {
+  const out = [];
+  const lines = aria.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const m = line.match(/-\s+link\s+"([^"]+)"/);
+    if (!m)
+      continue;
+    const label = m[1];
+    for (let j = i + 1; j < Math.min(i + 5, lines.length); j++) {
+      const urlMatch = lines[j].match(/-\s+\/url:\s+(\S+)/);
+      if (urlMatch) {
+        out.push({ label, href: urlMatch[1] });
+        break;
+      }
+    }
+  }
+  return out;
+}
+function findLinkByLabel(blueprint, label) {
+  for (const section of blueprint.sections) {
+    for (const el of section.elements) {
+      if (el.role === "link" && el.accessibleName === label)
+        return { logicalName: el.logicalName };
+    }
+  }
+  return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  crawl,
+  crawlSinglePage
+});

package/node_modules/playwright/lib/dom-analyzer/curatedWidgets.js

@@ -0,0 +1,73 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var curatedWidgets_exports = {};
+__export(curatedWidgets_exports, {
+  CURATED: () => CURATED
+});
+module.exports = __toCommonJS(curatedWidgets_exports);
+var import_liveFingerprints = require("./liveFingerprints");
+const CURATED = {
+  [(0, import_liveFingerprints.fp)("vue-treeselect")]: {
+    source: "curated",
+    confidence: "high",
+    widgetIdentification: "Vue-Treeselect",
+    parameters: ["value"],
+    steps: [
+      { kind: "click", target: "trigger" },
+      { kind: "waitFor", location: "inDom", signal: "visible" },
+      { kind: "click", target: "option", matchBy: "accessibleName", param: "value" }
+    ]
+  },
+  [(0, import_liveFingerprints.fp)("radix-select")]: {
+    source: "curated",
+    confidence: "high",
+    widgetIdentification: "Radix Select",
+    parameters: ["value"],
+    steps: [
+      { kind: "click", target: "trigger" },
+      { kind: "waitFor", location: "portal", signal: "visible" },
+      { kind: "handoff" }
+    ]
+  },
+  [(0, import_liveFingerprints.fp)("stripe-frame")]: {
+    source: "curated",
+    confidence: "high",
+    widgetIdentification: "Stripe CardNumberElement",
+    parameters: ["value"],
+    // framePath uses `title*="card"` rather than `src*="stripe.com"`:
+    //   - Real Stripe Elements iframes have title like "Secure card number
+    //     input frame" — `title*="card"` matches.
+    //   - The widgets.html fixture (used for curating this fingerprint) has
+    //     `title="Stripe card number"` — also matches.
+    //   - `src*="stripe.com"` matches real Stripe but NOT the fixture
+    //     (fixture uses `src="about:blank"` for offline testing). That mismatch
+    //     made the curated contract unrunnable against the same DOM that
+    //     produced its fingerprint. Title-based identification is stable
+    //     across the fixture/production split.
+    steps: [
+      { kind: "enterFrame", framePath: ['iframe[title*="card"]'] },
+      { kind: "fill", target: "activeInput", param: "value" },
+      { kind: "exitFrame" }
+    ]
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CURATED
+});

package/node_modules/playwright/lib/dom-analyzer/dynamicId.js

@@ -0,0 +1,43 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dynamicId_exports = {};
+__export(dynamicId_exports, {
+  isDynamicId: () => isDynamicId
+});
+module.exports = __toCommonJS(dynamicId_exports);
+function isDynamicId(id) {
+  if (/^react-aria\d+/.test(id)) return true;
+  if (/^mui-\d+/.test(id)) return true;
+  if (/^(mat|cdk)-[a-z]+-\d+$/.test(id)) return true;
+  if (/[-_]\d+$/.test(id)) return true;
+  if (/\d{2,}[_-][a-zA-Z]/.test(id)) return true;
+  if (/^\d+$/.test(id)) return true;
+  if (/\d{4,}$/.test(id)) return true;
+  if (/[-_][0-9a-f]{6,}$/i.test(id)) return true;
+  const shortHexMatch = id.match(/[-_]([0-9a-f]{3,5})$/i);
+  if (shortHexMatch && /[0-9]/.test(shortHexMatch[1])) return true;
+  if (/[a-zA-Z][0-9]{3,}$/.test(id)) return true;
+  if (id.includes(":")) return true;
+  if (/^.+__search_[a-zA-Z0-9]{4,}$/.test(id)) return true;
+  return false;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isDynamicId
+});

package/node_modules/playwright/lib/dom-analyzer/dynamicId.test.js

@@ -0,0 +1,85 @@
+"use strict";
+var import_dynamicId = require("./dynamicId");
+const cases = [];
+function test(name, run) {
+  cases.push({ name, run });
+}
+function assertTrue(v, msg) {
+  if (!v) throw new Error(msg);
+}
+function assertFalse(v, msg) {
+  if (v) throw new Error(msg);
+}
+test("isDynamicId: react-aria prefix", () => {
+  assertTrue((0, import_dynamicId.isDynamicId)("react-aria9765209213-_r_nj_"), "react-aria");
+});
+test("isDynamicId: mui prefix", () => {
+  assertTrue((0, import_dynamicId.isDynamicId)("mui-6"), "mui-6");
+});
+test("isDynamicId: Angular Material mat-input", () => {
+  assertTrue((0, import_dynamicId.isDynamicId)("mat-input-3"), "mat-input-3");
+  assertTrue((0, import_dynamicId.isDynamicId)("cdk-overlay-0"), "cdk-overlay-0");
+});
+test("isDynamicId: generic numeric suffix after separator", () => {
+  assertTrue((0, import_dynamicId.isDynamicId)("item-42"), "item-42");
+  assertTrue((0, import_dynamicId.isDynamicId)("row_123"), "row_123");
+});
+test("isDynamicId: mid-string counter", () => {
+  assertTrue((0, import_dynamicId.isDynamicId)("_commonPopup27_iframe"), "_commonPopup27_iframe");
+});
+test("isDynamicId: pure numeric", () => {
+  assertTrue((0, import_dynamicId.isDynamicId)("12345"), "12345");
+});
+test("isDynamicId: long numeric sequence suffix", () => {
+  assertTrue((0, import_dynamicId.isDynamicId)("dropdown99924304"), "dropdown99924304");
+});
+test("isDynamicId: long hex suffix", () => {
+  assertTrue((0, import_dynamicId.isDynamicId)("component-a3f2b1"), "component-a3f2b1");
+});
+test("isDynamicId: short hex suffix with digit", () => {
+  assertTrue((0, import_dynamicId.isDynamicId)("input-093d"), "input-093d");
+  assertTrue((0, import_dynamicId.isDynamicId)("input-1a98"), "input-1a98");
+});
+test("isDynamicId: trailing 3+ digits after letter without separator", () => {
+  assertTrue((0, import_dynamicId.isDynamicId)("checkbox877"), "checkbox877");
+  assertTrue((0, import_dynamicId.isDynamicId)("button123"), "button123");
+});
+test("isDynamicId: colon ID (Radix UI)", () => {
+  assertTrue((0, import_dynamicId.isDynamicId)("radix-:ra2:"), "radix-:ra2:");
+  assertTrue((0, import_dynamicId.isDynamicId)("radix-:r0:"), "radix-:r0:");
+});
+test("isDynamicId: Vue Tables 2 search pattern", () => {
+  assertTrue((0, import_dynamicId.isDynamicId)("VueTables__search_abcde"), "VueTables__search");
+});
+test("isDynamicId: stable kebab-case names are not dynamic", () => {
+  assertFalse((0, import_dynamicId.isDynamicId)("vt-trigger"), "vt-trigger");
+  assertFalse((0, import_dynamicId.isDynamicId)("toast-region"), "toast-region");
+  assertFalse((0, import_dynamicId.isDynamicId)("ga_workflow-list"), "ga_workflow-list");
+  assertFalse((0, import_dynamicId.isDynamicId)("mui-component-select-role"), "mui-component-select-role");
+});
+test("isDynamicId: short hex suffix without digit is not dynamic", () => {
+  assertFalse((0, import_dynamicId.isDynamicId)("item-bad"), "item-bad (all letters)");
+  assertFalse((0, import_dynamicId.isDynamicId)("item-fee"), "item-fee (all letters)");
+});
+test("isDynamicId: single trailing digit after letter is not dynamic", () => {
+  assertFalse((0, import_dynamicId.isDynamicId)("item1"), "item1 (single digit)");
+  assertFalse((0, import_dynamicId.isDynamicId)("item12"), "item12 (2 digits, below 3-digit threshold)");
+});
+let failed = 0;
+for (const { name, run } of cases) {
+  try {
+    run();
+    console.log("  \u2713", name);
+  } catch (e) {
+    failed++;
+    console.log("  \u2717", name);
+    console.log("     ", e.message);
+  }
+}
+if (failed > 0) {
+  console.log(`
+${failed}/${cases.length} failed`);
+  process.exit(1);
+}
+console.log(`
+${cases.length} passed`);

package/node_modules/playwright/lib/dom-analyzer/fingerprint.js

@@ -0,0 +1,90 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fingerprint_exports = {};
+__export(fingerprint_exports, {
+  BEM_ISH: () => BEM_ISH,
+  CSS_MODULE_HASH: () => CSS_MODULE_HASH,
+  FRAMEWORK_PREFIXES: () => FRAMEWORK_PREFIXES,
+  NUMERIC_INDEX_SUFFIX: () => NUMERIC_INDEX_SUFFIX,
+  STATE_TOKENS: () => STATE_TOKENS,
+  TAILWIND_UTILITY: () => TAILWIND_UTILITY,
+  canonicalJson: () => canonicalJson,
+  computeFingerprintFromInput: () => computeFingerprintFromInput,
+  normalizeClasses: () => normalizeClasses
+});
+module.exports = __toCommonJS(fingerprint_exports);
+var crypto = __toESM(require("crypto"));
+const BEM_ISH = /^[a-z][a-z-]+(__[a-z-]+)?(--[a-z-]+)?$/;
+const FRAMEWORK_PREFIXES = ["data-radix-", "data-headlessui-", "MuiSelect-", "ant-select-"];
+const TAILWIND_UTILITY = /^(bg|text|p|m|w|h|flex|grid|border|rounded|shadow)-|^(hover|focus|md|lg|sm|xl):/;
+const CSS_MODULE_HASH = /_[a-z0-9]{5,}$/;
+const NUMERIC_INDEX_SUFFIX = /-\d+$/;
+const STATE_TOKENS = /* @__PURE__ */ new Set(["is-active", "is-open", "expanded", "selected", "active", "open"]);
+function isStructural(cls) {
+  if (!cls) return false;
+  if (FRAMEWORK_PREFIXES.some((p) => cls.startsWith(p))) return true;
+  if (STATE_TOKENS.has(cls)) return false;
+  if (TAILWIND_UTILITY.test(cls)) return false;
+  if (CSS_MODULE_HASH.test(cls)) return false;
+  if (NUMERIC_INDEX_SUFFIX.test(cls)) return false;
+  return BEM_ISH.test(cls);
+}
+function normalizeClasses(className) {
+  if (!className) return "";
+  const tokens = className.split(/\s+/).filter(Boolean);
+  const kept = tokens.filter(isStructural);
+  const deduped = Array.from(new Set(kept));
+  deduped.sort();
+  return deduped.join(" ");
+}
+function canonicalJson(value) {
+  if (value === null || typeof value !== "object")
+    return JSON.stringify(value);
+  if (Array.isArray(value))
+    return "[" + value.map(canonicalJson).join(",") + "]";
+  const obj = value;
+  const keys = Object.keys(obj).sort();
+  return "{" + keys.map((k) => JSON.stringify(k) + ":" + canonicalJson(obj[k])).join(",") + "}";
+}
+function computeFingerprintFromInput(input) {
+  const json = canonicalJson(input);
+  return crypto.createHash("sha256").update(json).digest("hex").slice(0, 16);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BEM_ISH,
+  CSS_MODULE_HASH,
+  FRAMEWORK_PREFIXES,
+  NUMERIC_INDEX_SUFFIX,
+  STATE_TOKENS,
+  TAILWIND_UTILITY,
+  canonicalJson,
+  computeFingerprintFromInput,
+  normalizeClasses
+});