Skip to content

Open source website builder and Webflow alternative. Webstudio is an advanced visual builder that connects to any headless CMS, supports all CSS properties, and can be hosted anywhere, including with us.

104 KB
Raw Blame
import { expect, test, describe } from "vitest";
import {
  createTemplateComponentFixture,
  css,
  renderTemplate,
  token,
  ws,
} from "@webstudio-is/template";
import type { WebstudioFragment } from "@webstudio-is/sdk";
import { generateFragmentFromHtml as _generateFragmentFromHtml } from "./html";

const HtmlEmbed = createTemplateComponentFixture("HtmlEmbed");
const Image = createTemplateComponentFixture("Image");

// Wrapper that strips skippedSelectors for tests that only compare fragment shape
const generateFragmentFromHtml = (html: string) => {
  const { skippedSelectors: _skipped, ...fragment } =
    _generateFragmentFromHtml(html);
  return fragment;
};

test("generate instances from html", () => {
  expect(
    generateFragmentFromHtml(`
      <main>
        <section>
          <h1>It works!</h1>
          <p>Webstudio is great.</p>
          <ul>
            <li>one</li>
            <li>two</li>
          </ul>
        </section>
      </main>
   `)
  ).toEqual(
    renderTemplate(
      <ws.element ws:tag="main">
        <ws.element ws:tag="section">
          <ws.element ws:tag="h1">It works!</ws.element>
          <ws.element ws:tag="p">Webstudio is great.</ws.element>
          <ws.element ws:tag="ul">
            <ws.element ws:tag="li">one</ws.element>
            <ws.element ws:tag="li">two</ws.element>
          </ws.element>
        </ws.element>
      </ws.element>
    )
  );
});

test("generate multiple root instances from html", () => {
  expect(
    generateFragmentFromHtml(`
      <section>
        <h1>One</h1>
      </section>
      <section>
        <h1>Two</h1>
      </section>
   `)
  ).toEqual(
    renderTemplate(
      <>
        <ws.element ws:tag="section">
          <ws.element ws:tag="h1">One</ws.element>
        </ws.element>
        <ws.element ws:tag="section">
          <ws.element ws:tag="h1">Two</ws.element>
        </ws.element>
      </>
    )
  );
});

test("handle broken html", () => {
  expect(
    generateFragmentFromHtml(`
      <section>
        <h1>One</h1>
      </section attribute="value">
   `)
  ).toEqual(
    renderTemplate(
      <>
        <ws.element ws:tag="section">
          <ws.element ws:tag="h1">One</ws.element>
        </ws.element>
      </>
    )
  );
});

test("handle non-html", () => {
  expect(generateFragmentFromHtml("")).toEqual(renderTemplate(<></>));
  expect(generateFragmentFromHtml("It works!")).toEqual(renderTemplate(<></>));
});

test("ignore custom elements", () => {
  expect(
    generateFragmentFromHtml(`
      <custom-element>
        <div></div>
      </custom-element>
      <section></section>
   `)
  ).toEqual(renderTemplate(<ws.element ws:tag="section"></ws.element>));
});

test("ignore not allowed tags", () => {
  expect(
    generateFragmentFromHtml(`<div><marquee>test</marquee></div>`)
  ).toEqual(renderTemplate(<ws.element ws:tag="div"></ws.element>));
});

test("generate props from html attributes", () => {
  expect(
    generateFragmentFromHtml(`
      <form action="/my-action">
        <button class="my-button">My Button</button>
      </form>
   `)
  ).toEqual(
    renderTemplate(
      <ws.element ws:tag="form" action="/my-action">
        <ws.element ws:tag="button" class="my-button">
          My Button
        </ws.element>
      </ws.element>
    )
  );
});

test("generate props from number and boolean html attributes", () => {
  expect(
    generateFragmentFromHtml(`
      <button autofocus tabindex="-1">My Button</button>
   `)
  ).toEqual(
    renderTemplate(
      <ws.element ws:tag="button" autofocus={true} tabindex={-1}>
        My Button
      </ws.element>
    )
  );
});

test("generate props from number and boolean aria attributes", () => {
  expect(
    generateFragmentFromHtml(`
      <button aria-expanded aria-valuemin="100">My Button</button>
   `)
  ).toEqual(
    renderTemplate(
      <ws.element ws:tag="button" aria-expanded={true} aria-valuemin={100}>
        My Button
      </ws.element>
    )
  );
});

test("skip webstudio runtime attributes from pasted html", () => {
  const fragment = generateFragmentFromHtml(`
    <a
      data-ws-tag="a"
      href="#services"
      data-ws-text-content="View solutions "
      data-ws-id="V8q7r5rwOIOz7m_od3wi3"
      data-ws-component="ws:element"
      data-ws-selector="V8q7r5rwOIOz7m_od3wi3,BUSoEKIavhIKiBd1COmHZ"
    >View solutions </a>
  `);

  expect(fragment.props).toEqual([
    expect.objectContaining({ name: "href", value: "#services" }),
  ]);
  expect(fragment.props.some((prop) => prop.name.startsWith("data-ws-"))).toBe(
    false
  );
  expect(fragment.instances[0]).toEqual(
    expect.objectContaining({
      tag: "a",
      children: [{ type: "text", value: "View solutions " }],
    })
  );
});

test("wrap text with span when spotted outside of rich text", () => {
  expect(
    generateFragmentFromHtml(`
      <div>div<article>article</article></div>
   `)
  ).toEqual(
    renderTemplate(
      <ws.element ws:tag="div">
        <ws.element ws:tag="span">div</ws.element>
        <ws.element ws:tag="article">article</ws.element>
      </ws.element>
    )
  );
  expect(
    generateFragmentFromHtml(`
      <div>div<b><br></b></div>
   `)
  ).toEqual(
    renderTemplate(
      <ws.element ws:tag="div">
        <ws.element ws:tag="span">div</ws.element>
        <ws.element ws:tag="b">
          <ws.element ws:tag="br"></ws.element>
        </ws.element>
      </ws.element>
    )
  );
});

test("do not wrap text with span when spotted near link", () => {
  expect(
    generateFragmentFromHtml(`
      <div>div<a>link</a></div>
   `)
  ).toEqual(
    renderTemplate(
      <ws.element ws:tag="div">
        div
        <ws.element ws:tag="a">link</ws.element>
      </ws.element>
    )
  );
});

test("collapse any spacing characters inside text", () => {
  expect(
    generateFragmentFromHtml(`
      <div>
        line
        another line
      </div>
   `)
  ).toEqual(
    renderTemplate(<ws.element ws:tag="div">{"line another line"}</ws.element>)
  );
});

test("collapse any spacing characters inside rich text", () => {
  expect(
    generateFragmentFromHtml(`
      <div>
        <i> line </i>
        <b> another line </b>
        text
      </div>
   `)
  ).toEqual(
    renderTemplate(
      <ws.element ws:tag="div">
        <ws.element ws:tag="i">{"line "}</ws.element>
        <ws.element ws:tag="b">another line</ws.element> text
      </ws.element>
    )
  );
});

test("preserve leading space in inline element following text without trailing space", () => {
  expect(generateFragmentFromHtml(`<h2>About<span> Us</span></h2>`)).toEqual(
    renderTemplate(
      <ws.element ws:tag="h2">
        {"About"}
        <ws.element ws:tag="span">{" Us"}</ws.element>
      </ws.element>
    )
  );
});

test("generate style attribute as local styles", () => {
  expect(
    generateFragmentFromHtml(`
      <div style="display: inline"></div>
   `)
  ).toEqual(
    renderTemplate(
      <ws.element
        ws:tag="div"
        ws:style={css`
          display: inline;
        `}
      ></ws.element>
    )
  );
});

test("generate nested css math functions as unparsed local styles", () => {
  const value =
    "clamp(1rem, calc(1rem + (2rem - 1rem) * ((100vw - 20rem) / (80rem - 20rem))), 2rem)";
  const fragment = generateFragmentFromHtml(`
    <div style="font-size:${value}">One clamp div</div>
  `);

  expect(fragment.styles).toEqual(
    expect.arrayContaining([
      expect.objectContaining({
        property: "fontSize",
        value: {
          type: "unparsed",
          value:
            "clamp(1rem,calc(1rem + (2rem - 1rem)*((100vw - 20rem)/(80rem - 20rem))),2rem)",
        },
      }),
    ])
  );
});

test("script as html embed", () => {
  expect(generateFragmentFromHtml(`<script>a;</script>`)).toEqual(
    renderTemplate(
      <HtmlEmbed
        ws:label="Script"
        clientOnly={true}
        code={`<script>a;</script>`}
      />
    )
  );
});

test("style as html embed", () => {
  expect(generateFragmentFromHtml(`<style>a;</style>`)).toEqual(
    renderTemplate(<HtmlEmbed code={`<style>a;</style>`} ws:label="Style" />)
  );
});

test("generate textarea element", () => {
  expect(
    generateFragmentFromHtml(`
      <div>
        <textarea>
          my text
        </textarea>
      </div>
    `)
  ).toEqual(
    renderTemplate(
      <ws.element ws:tag="div">
        <ws.element ws:tag="textarea" value="my text" />
      </ws.element>
    )
  );
});

test("generate select element", () => {
  expect(
    generateFragmentFromHtml(`
      <div>
        <select>
          <option value="one">One</option>
          <option value="two" selected>Two</option>
        </select>
        <select>
          <option>One</option>
          <option selected>Two</option>
        </select>
      </div>
    `)
  ).toEqual(
    renderTemplate(
      <ws.element ws:tag="div">
        <ws.element ws:tag="select" value="two">
          <ws.element ws:tag="option" value="one">
            One
          </ws.element>
          <ws.element ws:tag="option" value="two">
            Two
          </ws.element>
        </ws.element>
        <ws.element ws:tag="select" value="Two">
          <ws.element ws:tag="option">One</ws.element>
          <ws.element ws:tag="option">Two</ws.element>
        </ws.element>
      </ws.element>
    )
  );
});

test("generate Image component instead of img element", () => {
  expect(
    generateFragmentFromHtml(`
      <div>
        <img src="./my-url">
      </div>
    `)
  ).toEqual(
    renderTemplate(
      <ws.element ws:tag="div">
        <Image src="./my-url" />
      </ws.element>
    )
  );
});

test("strip unsupported attribute names", () => {
  expect(
    generateFragmentFromHtml(`
      <button @click="open = true">Expand</button>
      <button x-on:click="open = !open">
        Toggle
      </button>
    `)
  ).toEqual(
    renderTemplate(
      <>
        <ws.element ws:tag="button">Expand</ws.element>
        <ws.element ws:tag="button" x-on:click="open = !open">
          Toggle
        </ws.element>
      </>
    )
  );
});

describe("style tag to tokens", () => {
  test("extract single class from style tag as token", () => {
    const cardToken = token(
      "card",
      css`
        display: flex;
      `
    );
    expect(
      generateFragmentFromHtml(`
        <style>.card { display: flex; }</style>
        <div class="card">Hello</div>
      `)
    ).toEqual(
      renderTemplate(
        <ws.element ws:tag="div" ws:tokens={[cardToken]}>
          Hello
        </ws.element>
      )
    );
  });

  test("extract multiple classes from style tag as tokens", () => {
    const cardToken = token(
      "card",
      css`
        display: flex;
        padding: 16px;
      `
    );
    const titleToken = token(
      "title",
      css`
        font-size: 24px;
        font-weight: bold;
      `
    );
    expect(
      generateFragmentFromHtml(`
        <style>
          .card { display: flex; padding: 16px; }
          .title { font-size: 24px; font-weight: bold; }
        </style>
        <div class="card">
          <h1 class="title">Hello</h1>
        </div>
      `)
    ).toEqual(
      renderTemplate(
        <ws.element ws:tag="div" ws:tokens={[cardToken]}>
          <ws.element ws:tag="h1" ws:tokens={[titleToken]}>
            Hello
          </ws.element>
        </ws.element>
      )
    );
  });

  test("reuse same token when class appears on multiple elements", () => {
    const cardToken = token(
      "card",
      css`
        display: flex;
      `
    );
    expect(
      generateFragmentFromHtml(`
        <style>.card { display: flex; }</style>
        <div class="card">
          <section class="card">Hello</section>
        </div>
      `)
    ).toEqual(
      renderTemplate(
        <ws.element ws:tag="div" ws:tokens={[cardToken]}>
          <ws.element ws:tag="section" ws:tokens={[cardToken]}>
            Hello
          </ws.element>
        </ws.element>
      )
    );
  });

  test("preserve unresolved class names as class prop", () => {
    const cardToken = token(
      "card",
      css`
        display: flex;
      `
    );
    expect(
      generateFragmentFromHtml(`
        <style>.card { display: flex; }</style>
        <div class="card external-lib">Hello</div>
      `)
    ).toEqual(
      renderTemplate(
        <ws.element ws:tag="div" class="external-lib" ws:tokens={[cardToken]}>
          Hello
        </ws.element>
      )
    );
  });

  test("remove class prop entirely when all classes resolved to tokens", () => {
    const fragment = generateFragmentFromHtml(`
      <style>.card { display: flex; }</style>
      <div class="card">Hello</div>
    `);
    expect(fragment.props.find((p) => p.name === "class")).toBeUndefined();
  });

  test("combine inline style attribute with class token", () => {
    const fragment = generateFragmentFromHtml(`
      <style>.card { display: flex; }</style>
      <div class="card" style="color: red">Hello</div>
    `);
    const cardToken = fragment.styleSources.find(
      (source) => source.type === "token" && source.name === "card"
    );
    expect(cardToken).toBeDefined();
    expect(fragment.children).toEqual([{ type: "id", value: "0" }]);
    expect(fragment.instances).toEqual([
      {
        type: "instance",
        id: "0",
        component: "ws:element",
        tag: "div",
        children: [{ type: "text", value: "Hello" }],
      },
    ]);
    expect(fragment.styleSourceSelections).toEqual([
      { instanceId: "0", values: [cardToken!.id, "0:ws:style"] },
    ]);
    expect(fragment.styles).toEqual(
      expect.arrayContaining([
        {
          styleSourceId: cardToken!.id,
          breakpointId: "base",
          property: "display",
          value: { type: "keyword", value: "flex" },
        },
        {
          styleSourceId: "0:ws:style",
          breakpointId: "base",
          property: "color",
          value: { type: "keyword", value: "red" },
        },
      ])
    );
  });

  test("no html embed when all style rules are class rules", () => {
    const fragment = generateFragmentFromHtml(`
      <style>
        .card { display: flex; }
        .title { font-size: 24px; }
      </style>
      <div class="card">
        <h1 class="title">Hello</h1>
      </div>
    `);
    expect(fragment.instances.some((i) => i.component === "HtmlEmbed")).toBe(
      false
    );
  });

  test("keep style tag as html embed when it has no class rules", () => {
    expect(
      generateFragmentFromHtml(`
        <style>#hero { color: red; }</style>
        <div>Hello</div>
      `)
    ).toEqual(
      renderTemplate(
        <>
          <HtmlEmbed
            ws:label="Style"
            code={`<style>#hero { color: red; }</style>`}
          />
          <ws.element ws:tag="div">Hello</ws.element>
        </>
      )
    );
  });

  test("extract class rules and keep remaining rules as html embed", () => {
    const fragment = generateFragmentFromHtml(`
      <style>
        .card { display: flex; }
        #hero { color: red; }
      </style>
      <div class="card">Hello</div>
    `);
    // token for .card should be created
    const tokenSource = fragment.styleSources.find(
      (s) => s.type === "token" && s.name === "card"
    );
    expect(tokenSource).toBeDefined();
    // remaining #hero rule should stay as HtmlEmbed
    const htmlEmbed = fragment.instances.find(
      (i) => i.component === "HtmlEmbed"
    );
    expect(htmlEmbed).toBeDefined();
    const codeProp = fragment.props.find(
      (p) => p.instanceId === htmlEmbed!.id && p.name === "code"
    );
    expect(codeProp).toBeDefined();
    expect(codeProp!.type === "string" && codeProp!.value).toContain("#hero");
    // class prop should not be set since .card was resolved
    expect(fragment.props.find((p) => p.name === "class")).toBeUndefined();
  });

  test("extract classes from multiple style tags", () => {
    const cardToken = token(
      "card",
      css`
        display: flex;
      `
    );
    const titleToken = token(
      "title",
      css`
        font-size: 24px;
      `
    );
    expect(
      generateFragmentFromHtml(`
        <style>.card { display: flex; }</style>
        <style>.title { font-size: 24px; }</style>
        <div class="card">
          <h1 class="title">Hello</h1>
        </div>
      `)
    ).toEqual(
      renderTemplate(
        <ws.element ws:tag="div" ws:tokens={[cardToken]}>
          <ws.element ws:tag="h1" ws:tokens={[titleToken]}>
            Hello
          </ws.element>
        </ws.element>
      )
    );
  });

  test("resolve nested selectors - descendant", () => {
    const cardInnerToken = token(
      "card__inner",
      css`
        color: red;
      `
    );
    expect(
      generateFragmentFromHtml(`
        <style>.card .inner { color: red; }</style>
        <div class="card">
          <span class="inner">Hello</span>
        </div>
      `)
    ).toEqual(
      renderTemplate(
        <ws.element ws:tag="div" class="card">
          <ws.element ws:tag="span" ws:tokens={[cardInnerToken]}>
            Hello
          </ws.element>
        </ws.element>
      )
    );
  });

  test("resolve nested selectors - child combinator", () => {
    const parentChildToken = token(
      "parent__child",
      css`
        margin: 0;
      `
    );
    expect(
      generateFragmentFromHtml(`
        <style>.parent > .child { margin: 0; }</style>
        <div class="parent"><span class="child">Hello</span></div>
      `)
    ).toEqual(
      renderTemplate(
        <ws.element ws:tag="div" class="parent">
          <ws.element ws:tag="span" ws:tokens={[parentChildToken]}>
            Hello
          </ws.element>
        </ws.element>
      )
    );
  });

  test("ignore element selectors in style tag", () => {
    // element selectors like `div { }` should not become tokens
    expect(
      generateFragmentFromHtml(`
        <style>div { color: red; }</style>
        <div>Hello</div>
      `)
    ).toEqual(
      renderTemplate(
        <>
          <HtmlEmbed
            ws:label="Style"
            code={`<style>div { color: red; }</style>`}
          />
          <ws.element ws:tag="div">Hello</ws.element>
        </>
      )
    );
  });

  test("handle multiple classes on one element with multiple tokens", () => {
    const cardToken = token(
      "card",
      css`
        display: flex;
      `
    );
    const largeToken = token(
      "large",
      css`
        font-size: 32px;
      `
    );
    expect(
      generateFragmentFromHtml(`
        <style>
          .card { display: flex; }
          .large { font-size: 32px; }
        </style>
        <div class="card large">Hello</div>
      `)
    ).toEqual(
      renderTemplate(
        <ws.element ws:tag="div" ws:tokens={[cardToken, largeToken]}>
          Hello
        </ws.element>
      )
    );
  });

  test("handle class with multiple properties", () => {
    const cardToken = token(
      "card",
      css`
        display: flex;
        gap: 16px;
        padding: 24px;
        border-radius: 8px;
      `
    );
    expect(
      generateFragmentFromHtml(`
        <style>
          .card {
            display: flex;
            gap: 16px;
            padding: 24px;
            border-radius: 8px;
          }
        </style>
        <div class="card">Hello</div>
      `)
    ).toEqual(
      renderTemplate(
        <ws.element ws:tag="div" ws:tokens={[cardToken]}>
          Hello
        </ws.element>
      )
    );
  });

  test("empty style tag produces no html embed", () => {
    expect(
      generateFragmentFromHtml(`
        <style></style>
        <div>Hello</div>
      `)
    ).toEqual(renderTemplate(<ws.element ws:tag="div">Hello</ws.element>));
  });

  test("class attribute without any style tag stays as prop", () => {
    // existing behavior: class is just a prop when no style tag is present
    expect(
      generateFragmentFromHtml(`
        <div class="my-class">Hello</div>
      `)
    ).toEqual(
      renderTemplate(
        <ws.element ws:tag="div" class="my-class">
          Hello
        </ws.element>
      )
    );
  });

  test("style tag with only whitespace produces no html embed", () => {
    expect(
      generateFragmentFromHtml(`
        <style>   </style>
        <div>Hello</div>
      `)
    ).toEqual(renderTemplate(<ws.element ws:tag="div">Hello</ws.element>));
  });

  test("extract token and apply to nested structure", () => {
    const wrapperToken = token(
      "wrapper",
      css`
        max-width: 1200px;
        margin-left: auto;
        margin-right: auto;
      `
    );
    const gridToken = token(
      "grid",
      css`
        display: grid;
        gap: 16px;
      `
    );
    const itemToken = token(
      "item",
      css`
        padding: 8px;
      `
    );
    expect(
      generateFragmentFromHtml(`
        <style>
          .wrapper { max-width: 1200px; margin-left: auto; margin-right: auto; }
          .grid { display: grid; gap: 16px; }
          .item { padding: 8px; }
        </style>
        <div class="wrapper">
          <div class="grid">
            <div class="item">One</div>
            <div class="item">Two</div>
            <div class="item">Three</div>
          </div>
        </div>
      `)
    ).toEqual(
      renderTemplate(
        <ws.element ws:tag="div" ws:tokens={[wrapperToken]}>
          <ws.element ws:tag="div" ws:tokens={[gridToken]}>
            <ws.element ws:tag="div" ws:tokens={[itemToken]}>
              One
            </ws.element>
            <ws.element ws:tag="div" ws:tokens={[itemToken]}>
              Two
            </ws.element>
            <ws.element ws:tag="div" ws:tokens={[itemToken]}>
              Three
            </ws.element>
          </ws.element>
        </ws.element>
      )
    );
  });

  test("element with both resolved and unresolved classes plus inline style", () => {
    const fragment = generateFragmentFromHtml(`
      <style>.card { display: flex; }</style>
      <div class="card external" style="color: red">Hello</div>
    `);
    const cardToken = fragment.styleSources.find(
      (source) => source.type === "token" && source.name === "card"
    );
    expect(cardToken).toBeDefined();
    expect(fragment.children).toEqual([{ type: "id", value: "0" }]);
    expect(fragment.instances).toEqual([
      {
        type: "instance",
        id: "0",
        component: "ws:element",
        tag: "div",
        children: [{ type: "text", value: "Hello" }],
      },
    ]);
    expect(fragment.props).toEqual([
      {
        id: "0:class",
        instanceId: "0",
        name: "class",
        type: "string",
        value: "external",
      },
    ]);
    expect(fragment.styleSourceSelections).toEqual([
      { instanceId: "0", values: [cardToken!.id, "0:ws:style"] },
    ]);
    expect(fragment.styles).toEqual(
      expect.arrayContaining([
        {
          styleSourceId: cardToken!.id,
          breakpointId: "base",
          property: "display",
          value: { type: "keyword", value: "flex" },
        },
        {
          styleSourceId: "0:ws:style",
          breakpointId: "base",
          property: "color",
          value: { type: "keyword", value: "red" },
        },
      ])
    );
  });

  test("token names preserve original class names", () => {
    const fragment = generateFragmentFromHtml(`
      <style>
        .my-component { display: flex; }
        .text-lg { font-size: 18px; }
        .bg_primary { background-color: blue; }
      </style>
      <div class="my-component">
        <span class="text-lg bg_primary">Hello</span>
      </div>
    `);
    const tokenNames = fragment.styleSources
      .filter((s) => s.type === "token")
      .map((s) => (s as { name: string }).name);
    expect(tokenNames).toContain("my-component");
    expect(tokenNames).toContain("text-lg");
    expect(tokenNames).toContain("bg_primary");
  });

  test("class defined in style tag but not used by any element", () => {
    const fragment = generateFragmentFromHtml(`
      <style>
        .used { display: flex; }
        .unused { color: red; }
      </style>
      <div class="used">Hello</div>
    `);
    // all class rules become tokens, even if not referenced by elements
    const tokenNames = fragment.styleSources
      .filter((s) => s.type === "token")
      .map((s) => (s as { name: string }).name);
    expect(tokenNames).toContain("used");
    expect(tokenNames).toContain("unused");
    // only "used" is assigned to the instance
    const divInstance = fragment.instances.find((i) => i.tag === "div");
    const sel = fragment.styleSourceSelections.find(
      (s) => s.instanceId === divInstance?.id
    );
    const usedToken = fragment.styleSources.find(
      (s) => s.type === "token" && s.name === "used"
    );
    const unusedToken = fragment.styleSources.find(
      (s) => s.type === "token" && s.name === "unused"
    );
    expect(sel?.values).toContain(usedToken?.id);
    expect(sel?.values).not.toContain(unusedToken?.id);
    // no HtmlEmbed since all rules are class rules
    expect(fragment.instances.some((i) => i.component === "HtmlEmbed")).toBe(
      false
    );
  });

  test("duplicate class rules across multiple style tags are merged", () => {
    const fragment = generateFragmentFromHtml(`
      <style>.card { display: flex; }</style>
      <style>.card { padding: 16px; }</style>
      <div class="card">Hello</div>
    `);
    // should create a single token with both properties
    const tokens = fragment.styleSources.filter((s) => s.type === "token");
    expect(tokens).toHaveLength(1);
    const tokenId = tokens[0].id;
    const tokenStyles = fragment.styles.filter(
      (s) => s.styleSourceId === tokenId
    );
    const properties = tokenStyles.map((s) => s.property);
    expect(properties).toContain("display");
    expect(properties).toContain("paddingTop");
  });

  test("script tag still becomes html embed alongside token extraction", () => {
    const cardToken = token(
      "card",
      css`
        display: flex;
      `
    );
    expect(
      generateFragmentFromHtml(`
        <style>.card { display: flex; }</style>
        <script>console.log("hi");</script>
        <div class="card">Hello</div>
      `)
    ).toEqual(
      renderTemplate(
        <>
          <HtmlEmbed
            ws:label="Script"
            clientOnly={true}
            code={`<script>console.log("hi");</script>`}
          />
          <ws.element ws:tag="div" ws:tokens={[cardToken]}>
            Hello
          </ws.element>
        </>
      )
    );
  });

  test("style tag with pseudo-class creates token with state", () => {
    const fragment = generateFragmentFromHtml(`
      <style>
        .btn { background-color: blue; }
        .btn:hover { background-color: darkblue; }
      </style>
      <button class="btn">Click me</button>
    `);
    const tokenSource = fragment.styleSources.find(
      (s) => s.type === "token" && s.name === "btn"
    );
    expect(tokenSource).toBeDefined();
    // base style
    const baseStyle = fragment.styles.find(
      (s) =>
        s.styleSourceId === tokenSource!.id &&
        s.property === "backgroundColor" &&
        s.state === undefined
    );
    expect(baseStyle).toBeDefined();
    // hover state style
    const hoverStyle = fragment.styles.find(
      (s) =>
        s.styleSourceId === tokenSource!.id &&
        s.property === "backgroundColor" &&
        s.state === ":hover"
    );
    expect(hoverStyle).toBeDefined();
  });

  test("style tag with media query creates token with breakpoint styles", () => {
    const fragment = generateFragmentFromHtml(`
      <style>
        .container { padding: 8px; }
        @media (min-width: 768px) {
          .container { padding: 16px; }
        }
      </style>
      <div class="container">Hello</div>
    `);
    const tokenSource = fragment.styleSources.find(
      (s) => s.type === "token" && s.name === "container"
    );
    expect(tokenSource).toBeDefined();
    // should have styles on different breakpoints
    const tokenStyles = fragment.styles.filter(
      (s) => s.styleSourceId === tokenSource!.id
    );
    const breakpointIds = new Set(tokenStyles.map((s) => s.breakpointId));
    // should have at least 2 different breakpoints (base + media query)
    expect(breakpointIds.size).toBeGreaterThanOrEqual(2);
  });

  test("handle real-world html snippet with style tag", () => {
    const heroToken = token(
      "hero",
      css`
        display: flex;
        flex-direction: column;
        align-items: center;
        padding: 64px;
      `
    );
    const heroTitleToken = token(
      "hero-title",
      css`
        font-size: 48px;
        font-weight: bold;
        line-height: 1.2;
      `
    );
    const heroTextToken = token(
      "hero-text",
      css`
        font-size: 18px;
        color: gray;
      `
    );
    expect(
      generateFragmentFromHtml(`
        <style>
          .hero {
            display: flex;
            flex-direction: column;
            align-items: center;
            padding: 64px;
          }
          .hero-title {
            font-size: 48px;
            font-weight: bold;
            line-height: 1.2;
          }
          .hero-text {
            font-size: 18px;
            color: gray;
          }
        </style>
        <section class="hero">
          <h1 class="hero-title">Welcome</h1>
          <p class="hero-text">Build something amazing</p>
        </section>
      `)
    ).toEqual(
      renderTemplate(
        <ws.element ws:tag="section" ws:tokens={[heroToken]}>
          <ws.element ws:tag="h1" ws:tokens={[heroTitleToken]}>
            Welcome
          </ws.element>
          <ws.element ws:tag="p" ws:tokens={[heroTextToken]}>
            Build something amazing
          </ws.element>
        </ws.element>
      )
    );
  });

  test("create tokens from style-only paste without HTML elements", () => {
    const result = generateFragmentFromHtml(`
      <style>.card { display: flex; padding: 16px; }</style>
    `);
    expect(result.children).toEqual([]);
    expect(result.instances).toEqual([]);
    expect(result.styleSources).toEqual([
      { type: "token", id: expect.any(String), name: "card" },
    ]);
    expect(result.styles).toEqual([
      {
        styleSourceId: result.styleSources[0].id,
        breakpointId: expect.any(String),
        property: "display",
        value: { type: "keyword", value: "flex" },
      },
      {
        styleSourceId: result.styleSources[0].id,
        breakpointId: expect.any(String),
        property: "paddingTop",
        value: { type: "unit", unit: "px", value: 16 },
      },
      {
        styleSourceId: result.styleSources[0].id,
        breakpointId: expect.any(String),
        property: "paddingRight",
        value: { type: "unit", unit: "px", value: 16 },
      },
      {
        styleSourceId: result.styleSources[0].id,
        breakpointId: expect.any(String),
        property: "paddingBottom",
        value: { type: "unit", unit: "px", value: 16 },
      },
      {
        styleSourceId: result.styleSources[0].id,
        breakpointId: expect.any(String),
        property: "paddingLeft",
        value: { type: "unit", unit: "px", value: 16 },
      },
    ]);
    expect(result.styleSourceSelections).toEqual([]);
  });

  test("create multiple tokens from style-only paste", () => {
    const result = generateFragmentFromHtml(`
      <style>
        .card { display: flex; }
        .title { font-weight: bold; }
      </style>
    `);
    expect(result.children).toEqual([]);
    expect(result.styleSources).toEqual([
      { type: "token", id: expect.any(String), name: "card" },
      { type: "token", id: expect.any(String), name: "title" },
    ]);
    expect(result.styles).toHaveLength(2);
  });

  test("create tokens with media queries from style-only paste", () => {
    const result = generateFragmentFromHtml(`
      <style>
        .card { display: flex; }
        @media (min-width: 768px) {
          .card { flex-direction: row; }
        }
      </style>
    `);
    expect(result.children).toEqual([]);
    expect(result.styleSources).toEqual([
      { type: "token", id: expect.any(String), name: "card" },
    ]);
    // base style + breakpoint style
    expect(result.styles).toHaveLength(2);
    expect(result.breakpoints).toHaveLength(2); // base + 768px
  });

  test("style-only paste with non-class rules creates leftover embed", () => {
    const result = generateFragmentFromHtml(`
      <style>
        .card { display: flex; }
        div { color: red; }
      </style>
    `);
    // card token created
    expect(result.styleSources).toEqual([
      { type: "token", id: expect.any(String), name: "card" },
    ]);
    // leftover non-class rule kept as HtmlEmbed
    expect(result.instances).toHaveLength(1);
    expect(result.instances[0].component).toBe("HtmlEmbed");
  });

  describe("media queries", () => {
    test("extract class with min-width media query into breakpoint", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .card { display: flex; }
          @media (min-width: 768px) {
            .card { flex-direction: row; }
          }
        </style>
        <div class="card">Hello</div>
      `);
      const tokenSource = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "card"
      );
      expect(tokenSource).toBeDefined();
      // base style
      const baseStyle = fragment.styles.find(
        (s) =>
          s.styleSourceId === tokenSource!.id &&
          s.property === "display" &&
          s.state === undefined
      );
      expect(baseStyle).toBeDefined();
      // breakpoint style
      const bpStyle = fragment.styles.find(
        (s) =>
          s.styleSourceId === tokenSource!.id && s.property === "flexDirection"
      );
      expect(bpStyle).toBeDefined();
      expect(bpStyle!.breakpointId).not.toBe(baseStyle!.breakpointId);
      // breakpoint should be created with minWidth
      const bp = fragment.breakpoints.find(
        (b) => b.id === bpStyle!.breakpointId
      );
      expect(bp).toBeDefined();
      expect(bp!.minWidth).toBe(768);
    });

    test("extract class with max-width media query into breakpoint", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .container { padding: 32px; }
          @media (max-width: 480px) {
            .container { padding: 16px; }
          }
        </style>
        <div class="container">Hello</div>
      `);
      const tokenSource = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "container"
      );
      expect(tokenSource).toBeDefined();
      const bpStyle = fragment.styles.find(
        (s) =>
          s.styleSourceId === tokenSource!.id &&
          s.property === "paddingTop" &&
          s.breakpointId !== "base"
      );
      expect(bpStyle).toBeDefined();
      const bp = fragment.breakpoints.find(
        (b) => b.id === bpStyle!.breakpointId
      );
      expect(bp).toBeDefined();
      expect(bp!.maxWidth).toBe(480);
    });

    test("extract class across multiple media queries", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .card { font-size: 14px; }
          @media (min-width: 768px) {
            .card { font-size: 16px; }
          }
          @media (min-width: 1024px) {
            .card { font-size: 18px; }
          }
        </style>
        <div class="card">Hello</div>
      `);
      const tokenSource = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "card"
      );
      expect(tokenSource).toBeDefined();
      const tokenStyles = fragment.styles.filter(
        (s) => s.styleSourceId === tokenSource!.id
      );
      const breakpointIds = new Set(tokenStyles.map((s) => s.breakpointId));
      // base + 768px + 1024px = 3 breakpoints
      expect(breakpointIds.size).toBe(3);
    });

    test("media query with non-class selectors stays as html embed", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          @media (min-width: 768px) {
            #hero { font-size: 24px; }
          }
        </style>
        <div>Hello</div>
      `);
      expect(fragment.instances.some((i) => i.component === "HtmlEmbed")).toBe(
        true
      );
      expect(
        fragment.styleSources.filter((s) => s.type === "token")
      ).toHaveLength(0);
    });

    test("media query with mixed class and non-class selectors", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          @media (min-width: 768px) {
            .card { display: flex; }
            #hero { color: red; }
          }
        </style>
        <div class="card">Hello</div>
      `);
      // .card in media query should become token
      const tokenSource = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "card"
      );
      expect(tokenSource).toBeDefined();
      // #hero in media query should remain as html embed
      const htmlEmbed = fragment.instances.find(
        (i) => i.component === "HtmlEmbed"
      );
      expect(htmlEmbed).toBeDefined();
    });

    test("same class in base and media query produces single token", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .btn { padding: 8px; }
          @media (min-width: 768px) {
            .btn { padding: 16px; }
          }
        </style>
        <button class="btn">Click</button>
      `);
      const tokens = fragment.styleSources.filter((s) => s.type === "token");
      expect(tokens).toHaveLength(1);
      expect(tokens[0].type === "token" && tokens[0].name).toBe("btn");
    });

    test("multiple classes in same media query", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .card { display: flex; }
          .title { font-size: 16px; }
          @media (min-width: 768px) {
            .card { flex-direction: row; }
            .title { font-size: 24px; }
          }
        </style>
        <div class="card">
          <h1 class="title">Hello</h1>
        </div>
      `);
      const tokens = fragment.styleSources.filter((s) => s.type === "token");
      expect(tokens).toHaveLength(2);
      const cardToken = tokens.find(
        (s) => s.type === "token" && s.name === "card"
      );
      const titleToken = tokens.find(
        (s) => s.type === "token" && s.name === "title"
      );
      expect(cardToken).toBeDefined();
      expect(titleToken).toBeDefined();
    });
  });

  describe("pseudo-classes and pseudo-elements", () => {
    test("extract :hover pseudo-class as state", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .link { color: blue; }
          .link:hover { color: darkblue; }
        </style>
        <a class="link">Click</a>
      `);
      const tokenSource = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "link"
      );
      expect(tokenSource).toBeDefined();
      const hoverStyle = fragment.styles.find(
        (s) => s.styleSourceId === tokenSource!.id && s.state === ":hover"
      );
      expect(hoverStyle).toBeDefined();
    });

    test("extract :focus pseudo-class as state", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .input { border-color: gray; }
          .input:focus { border-color: blue; }
        </style>
        <input class="input" />
      `);
      const tokenSource = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "input"
      );
      expect(tokenSource).toBeDefined();
      const focusStyle = fragment.styles.find(
        (s) => s.styleSourceId === tokenSource!.id && s.state === ":focus"
      );
      expect(focusStyle).toBeDefined();
    });

    test("extract multiple pseudo-classes on same class", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .btn { background: blue; }
          .btn:hover { background: darkblue; }
          .btn:focus { outline-color: blue; }
          .btn:active { background: navy; }
        </style>
        <button class="btn">Click</button>
      `);
      const tokenSource = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "btn"
      );
      expect(tokenSource).toBeDefined();
      const states = fragment.styles
        .filter((s) => s.styleSourceId === tokenSource!.id && s.state)
        .map((s) => s.state);
      expect(states).toContain(":hover");
      expect(states).toContain(":focus");
      expect(states).toContain(":active");
    });

    test("extract ::before pseudo-element as state", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .decorated { position: relative; }
          .decorated::before { content: "★"; }
        </style>
        <div class="decorated">Hello</div>
      `);
      const tokenSource = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "decorated"
      );
      expect(tokenSource).toBeDefined();
      const beforeStyle = fragment.styles.find(
        (s) => s.styleSourceId === tokenSource!.id && s.state === "::before"
      );
      expect(beforeStyle).toBeDefined();
    });

    test("extract ::after pseudo-element as state", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .clearfix::after {
            content: "";
            display: table;
            clear: both;
          }
        </style>
        <div class="clearfix">Hello</div>
      `);
      const tokenSource = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "clearfix"
      );
      expect(tokenSource).toBeDefined();
      const afterStyles = fragment.styles.filter(
        (s) => s.styleSourceId === tokenSource!.id && s.state === "::after"
      );
      expect(afterStyles.length).toBeGreaterThanOrEqual(1);
    });

    test("pseudo-class on non-class selector ignored (stays in embed)", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          a:hover { color: red; }
        </style>
        <a>Link</a>
      `);
      expect(
        fragment.styleSources.filter((s) => s.type === "token")
      ).toHaveLength(0);
      expect(fragment.instances.some((i) => i.component === "HtmlEmbed")).toBe(
        true
      );
    });

    test("pseudo-class combined with media query", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .btn { background: blue; }
          .btn:hover { background: darkblue; }
          @media (min-width: 768px) {
            .btn { padding: 16px; }
            .btn:hover { background: royalblue; }
          }
        </style>
        <button class="btn">Click</button>
      `);
      const tokenSource = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "btn"
      );
      expect(tokenSource).toBeDefined();
      // should have hover styles on base breakpoint
      const baseHover = fragment.styles.find(
        (s) =>
          s.styleSourceId === tokenSource!.id &&
          s.state === ":hover" &&
          s.breakpointId === "base"
      );
      expect(baseHover).toBeDefined();
      // should have hover styles on 768px breakpoint
      const bpHover = fragment.styles.find(
        (s) =>
          s.styleSourceId === tokenSource!.id &&
          s.state === ":hover" &&
          s.breakpointId !== "base"
      );
      expect(bpHover).toBeDefined();
    });

    test("::placeholder pseudo-element as state", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .input { color: black; }
          .input::placeholder { color: gray; }
        </style>
        <input class="input" />
      `);
      const tokenSource = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "input"
      );
      expect(tokenSource).toBeDefined();
      const placeholderStyle = fragment.styles.find(
        (s) =>
          s.styleSourceId === tokenSource!.id && s.state === "::placeholder"
      );
      expect(placeholderStyle).toBeDefined();
    });
  });

  describe("at-rules and special CSS", () => {
    test("@keyframes stays as html embed", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          @keyframes spin {
            from { transform: rotate(0deg); }
            to { transform: rotate(360deg); }
          }
          .spinner { animation: spin 1s infinite; }
        </style>
        <div class="spinner">Loading</div>
      `);
      // .spinner class should still become a token
      const tokenSource = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "spinner"
      );
      expect(tokenSource).toBeDefined();
      // @keyframes should remain as html embed
      const htmlEmbed = fragment.instances.find(
        (i) => i.component === "HtmlEmbed"
      );
      expect(htmlEmbed).toBeDefined();
      const codeProp = fragment.props.find(
        (p) => p.instanceId === htmlEmbed!.id && p.name === "code"
      );
      expect(codeProp).toBeDefined();
      expect(codeProp!.type === "string" && codeProp!.value).toContain(
        "@keyframes"
      );
    });

    test("@font-face stays as html embed", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          @font-face {
            font-family: "MyFont";
            src: url("font.woff2");
          }
          .text { font-family: "MyFont"; }
        </style>
        <p class="text">Hello</p>
      `);
      // .text class should become a token
      const tokenSource = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "text"
      );
      expect(tokenSource).toBeDefined();
      // @font-face should remain as html embed
      const htmlEmbed = fragment.instances.find(
        (i) => i.component === "HtmlEmbed"
      );
      expect(htmlEmbed).toBeDefined();
      const codeProp = fragment.props.find(
        (p) => p.instanceId === htmlEmbed!.id && p.name === "code"
      );
      expect(codeProp).toBeDefined();
      expect(codeProp!.type === "string" && codeProp!.value).toContain(
        "@font-face"
      );
    });

    test("@media print stays as html embed", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .card { display: flex; }
          @media print {
            .card { display: block; }
          }
        </style>
        <div class="card">Hello</div>
      `);
      // base .card should become a token
      const tokenSource = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "card"
      );
      expect(tokenSource).toBeDefined();
      // @media print should remain as html embed since parseCss ignores print
      const htmlEmbed = fragment.instances.find(
        (i) => i.component === "HtmlEmbed"
      );
      expect(htmlEmbed).toBeDefined();
    });

    test("grouped class selectors like .a, .b are extracted as separate tokens", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .primary, .secondary { font-weight: bold; }
        </style>
        <span class="primary">One</span>
        <span class="secondary">Two</span>
      `);
      const primaryToken = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "primary"
      );
      const secondaryToken = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "secondary"
      );
      expect(primaryToken).toBeDefined();
      expect(secondaryToken).toBeDefined();
      // both should have the same style
      const primaryStyle = fragment.styles.find(
        (s) => s.styleSourceId === primaryToken!.id
      );
      const secondaryStyle = fragment.styles.find(
        (s) => s.styleSourceId === secondaryToken!.id
      );
      expect(primaryStyle?.property).toBe("fontWeight");
      expect(secondaryStyle?.property).toBe("fontWeight");
    });

    test("grouped selector with class + non-class stays partially in embed", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .card, #hero { display: flex; }
        </style>
        <div class="card">Hello</div>
      `);
      // .card should become token
      const tokenSource = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "card"
      );
      expect(tokenSource).toBeDefined();
      // #hero part should remain as html embed
      const htmlEmbed = fragment.instances.find(
        (i) => i.component === "HtmlEmbed"
      );
      expect(htmlEmbed).toBeDefined();
    });
  });

  describe("condition breakpoints", () => {
    test("@media (prefers-color-scheme: dark) creates condition breakpoint", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .card { background: white; color: black; }
          @media (prefers-color-scheme: dark) {
            .card { background: black; color: white; }
          }
        </style>
        <div class="card">Hello</div>
      `);
      const tokenSource = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "card"
      );
      expect(tokenSource).toBeDefined();
      // should have base styles
      const baseStyle = fragment.styles.find(
        (s) =>
          s.styleSourceId === tokenSource!.id &&
          s.property === "backgroundColor" &&
          s.state === undefined
      );
      expect(baseStyle).toBeDefined();
      // should have dark mode styles on condition breakpoint
      const darkStyle = fragment.styles.find(
        (s) =>
          s.styleSourceId === tokenSource!.id &&
          s.property === "backgroundColor" &&
          s.breakpointId !== baseStyle!.breakpointId
      );
      expect(darkStyle).toBeDefined();
      const bp = fragment.breakpoints.find(
        (b) => b.id === darkStyle!.breakpointId
      );
      expect(bp).toBeDefined();
      expect(bp!.condition).toBe("prefers-color-scheme:dark");
      expect(bp!.minWidth).toBeUndefined();
      expect(bp!.maxWidth).toBeUndefined();
    });

    test("@media (orientation: portrait) creates condition breakpoint", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .layout { flex-direction: row; }
          @media (orientation: portrait) {
            .layout { flex-direction: column; }
          }
        </style>
        <div class="layout">Hello</div>
      `);
      const tokenSource = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "layout"
      );
      expect(tokenSource).toBeDefined();
      const portraitStyle = fragment.styles.find(
        (s) =>
          s.styleSourceId === tokenSource!.id &&
          s.property === "flexDirection" &&
          s.breakpointId !== "base"
      );
      expect(portraitStyle).toBeDefined();
      const bp = fragment.breakpoints.find(
        (b) => b.id === portraitStyle!.breakpointId
      );
      expect(bp).toBeDefined();
      expect(bp!.condition).toBe("orientation:portrait");
    });

    test("@media (hover: hover) creates condition breakpoint", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .interactive { cursor: default; }
          @media (hover: hover) {
            .interactive { cursor: pointer; }
          }
        </style>
        <div class="interactive">Hello</div>
      `);
      const tokenSource = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "interactive"
      );
      expect(tokenSource).toBeDefined();
      const hoverStyle = fragment.styles.find(
        (s) =>
          s.styleSourceId === tokenSource!.id &&
          s.property === "cursor" &&
          s.breakpointId !== "base"
      );
      expect(hoverStyle).toBeDefined();
      const bp = fragment.breakpoints.find(
        (b) => b.id === hoverStyle!.breakpointId
      );
      expect(bp).toBeDefined();
      expect(bp!.condition).toBe("hover:hover");
    });

    test("@media (prefers-reduced-motion: reduce) creates condition breakpoint", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .animated { transition: transform 0.3s; }
          @media (prefers-reduced-motion: reduce) {
            .animated { transition: none; }
          }
        </style>
        <div class="animated">Hello</div>
      `);
      const tokenSource = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "animated"
      );
      expect(tokenSource).toBeDefined();
      const reduceStyle = fragment.styles.find(
        (s) =>
          s.styleSourceId === tokenSource!.id &&
          s.property === "transitionProperty" &&
          s.breakpointId !== "base"
      );
      expect(reduceStyle).toBeDefined();
      const bp = fragment.breakpoints.find(
        (b) => b.id === reduceStyle!.breakpointId
      );
      expect(bp).toBeDefined();
      expect(bp!.condition).toBe("prefers-reduced-motion:reduce");
    });

    test("combined min-width and max-width uses range breakpoint", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .tablet-only { display: none; }
          @media (min-width: 768px) and (max-width: 1024px) {
            .tablet-only { display: block; }
          }
        </style>
        <div class="tablet-only">Tablet content</div>
      `);
      const tokenSource = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "tablet-only"
      );
      expect(tokenSource).toBeDefined();
      const tabletStyle = fragment.styles.find(
        (s) =>
          s.styleSourceId === tokenSource!.id &&
          s.property === "display" &&
          s.breakpointId !== "base"
      );
      expect(tabletStyle).toBeDefined();
      const bp = fragment.breakpoints.find(
        (b) => b.id === tabletStyle!.breakpointId
      );
      expect(bp).toBeDefined();
      // Combined width queries use both minWidth and maxWidth
      expect(bp!.minWidth).toBe(768);
      expect(bp!.maxWidth).toBe(1024);
      expect(bp!.condition).toBeUndefined();
    });

    test("overlapping min/max-width breakpoints get rounded to non-overlapping values", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .a { font-size: 14px; }
          @media (min-width: 600px) and (max-width: 900px) {
            .a { font-size: 16px; }
          }
          @media (min-width: 800px) and (max-width: 1200px) {
            .a { font-size: 18px; }
          }
        </style>
        <div class="a">Hello</div>
      `);
      const tokenSource = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "a"
      );
      expect(tokenSource).toBeDefined();
      const tokenStyles = fragment.styles.filter(
        (s) => s.styleSourceId === tokenSource!.id && s.property === "fontSize"
      );
      // base + 2 range breakpoints = 3 styles
      expect(tokenStyles).toHaveLength(3);
      const rangeBreakpoints = tokenStyles
        .filter((s) => s.breakpointId !== "base")
        .map((s) => fragment.breakpoints.find((b) => b.id === s.breakpointId))
        .filter(Boolean)
        .sort((a, b) => (a!.minWidth ?? 0) - (b!.minWidth ?? 0));
      expect(rangeBreakpoints).toHaveLength(2);
      // ranges should not overlap: first.maxWidth < second.minWidth
      const first = rangeBreakpoints[0]!;
      const second = rangeBreakpoints[1]!;
      expect(first.maxWidth).toBeDefined();
      expect(second.minWidth).toBeDefined();
      expect(first.maxWidth!).toBeLessThan(second.minWidth!);
    });

    test("non-overlapping range breakpoints stay unchanged", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .a { font-size: 14px; }
          @media (min-width: 400px) and (max-width: 700px) {
            .a { font-size: 16px; }
          }
          @media (min-width: 800px) and (max-width: 1200px) {
            .a { font-size: 18px; }
          }
        </style>
        <div class="a">Hello</div>
      `);
      const tokenSource = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "a"
      );
      expect(tokenSource).toBeDefined();
      const rangeBreakpoints = fragment.breakpoints
        .filter((b) => b.minWidth !== undefined && b.maxWidth !== undefined)
        .sort((a, b) => (a.minWidth ?? 0) - (b.minWidth ?? 0));
      expect(rangeBreakpoints).toHaveLength(2);
      // values should remain exactly as authored since they don't overlap
      expect(rangeBreakpoints[0].minWidth).toBe(400);
      expect(rangeBreakpoints[0].maxWidth).toBe(700);
      expect(rangeBreakpoints[1].minWidth).toBe(800);
      expect(rangeBreakpoints[1].maxWidth).toBe(1200);
    });

    test("adjacent range breakpoints (touching) stay unchanged", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .a { font-size: 14px; }
          @media (min-width: 400px) and (max-width: 799px) {
            .a { font-size: 16px; }
          }
          @media (min-width: 800px) and (max-width: 1200px) {
            .a { font-size: 18px; }
          }
        </style>
        <div class="a">Hello</div>
      `);
      const rangeBreakpoints = fragment.breakpoints
        .filter((b) => b.minWidth !== undefined && b.maxWidth !== undefined)
        .sort((a, b) => (a.minWidth ?? 0) - (b.minWidth ?? 0));
      expect(rangeBreakpoints).toHaveLength(2);
      // touching but not overlapping — keep as is
      expect(rangeBreakpoints[0].maxWidth).toBe(799);
      expect(rangeBreakpoints[1].minWidth).toBe(800);
    });

    test("overlapping range: first.maxWidth rounded down to second.minWidth - 1", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .a { font-size: 14px; }
          @media (min-width: 600px) and (max-width: 1000px) {
            .a { font-size: 16px; }
          }
          @media (min-width: 900px) and (max-width: 1400px) {
            .a { font-size: 18px; }
          }
        </style>
        <div class="a">Hello</div>
      `);
      const rangeBreakpoints = fragment.breakpoints
        .filter((b) => b.minWidth !== undefined && b.maxWidth !== undefined)
        .sort((a, b) => (a.minWidth ?? 0) - (b.minWidth ?? 0));
      expect(rangeBreakpoints).toHaveLength(2);
      // first range's maxWidth should be adjusted to not overlap second's minWidth
      expect(rangeBreakpoints[0].minWidth).toBe(600);
      expect(rangeBreakpoints[0].maxWidth!).toBeLessThan(
        rangeBreakpoints[1].minWidth!
      );
      // second range should keep its original values
      expect(rangeBreakpoints[1].minWidth).toBe(900);
      expect(rangeBreakpoints[1].maxWidth).toBe(1400);
    });

    test("three overlapping ranges all get adjusted", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .a { font-size: 14px; }
          @media (min-width: 400px) and (max-width: 800px) {
            .a { font-size: 16px; }
          }
          @media (min-width: 700px) and (max-width: 1100px) {
            .a { font-size: 18px; }
          }
          @media (min-width: 1000px) and (max-width: 1400px) {
            .a { font-size: 20px; }
          }
        </style>
        <div class="a">Hello</div>
      `);
      const rangeBreakpoints = fragment.breakpoints
        .filter((b) => b.minWidth !== undefined && b.maxWidth !== undefined)
        .sort((a, b) => (a.minWidth ?? 0) - (b.minWidth ?? 0));
      expect(rangeBreakpoints).toHaveLength(3);
      // no pair should overlap
      expect(rangeBreakpoints[0].maxWidth!).toBeLessThan(
        rangeBreakpoints[1].minWidth!
      );
      expect(rangeBreakpoints[1].maxWidth!).toBeLessThan(
        rangeBreakpoints[2].minWidth!
      );
    });

    test("exact duplicate range breakpoints get deduplicated", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .a { font-size: 14px; }
          .b { color: red; }
          @media (min-width: 768px) and (max-width: 1024px) {
            .a { font-size: 18px; }
          }
          @media (min-width: 768px) and (max-width: 1024px) {
            .b { color: blue; }
          }
        </style>
        <div class="a"><span class="b">Hello</span></div>
      `);
      // same range should reuse a single breakpoint
      const rangeBreakpoints = fragment.breakpoints.filter(
        (b) => b.minWidth !== undefined && b.maxWidth !== undefined
      );
      expect(rangeBreakpoints).toHaveLength(1);
      expect(rangeBreakpoints[0].minWidth).toBe(768);
      expect(rangeBreakpoints[0].maxWidth).toBe(1024);
    });

    test("range breakpoint overlapping with simple min-width breakpoint", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .a { font-size: 14px; }
          @media (min-width: 768px) {
            .a { font-size: 18px; }
          }
          @media (min-width: 600px) and (max-width: 900px) {
            .a { font-size: 16px; }
          }
        </style>
        <div class="a">Hello</div>
      `);
      const tokenSource = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "a"
      );
      expect(tokenSource).toBeDefined();
      const tokenStyles = fragment.styles.filter(
        (s) => s.styleSourceId === tokenSource!.id && s.property === "fontSize"
      );
      // base + min-width + range = 3 breakpoints
      expect(tokenStyles).toHaveLength(3);
      // simple min-width breakpoint should exist
      const minWidthBp = fragment.breakpoints.find(
        (b) =>
          b.minWidth !== undefined &&
          b.maxWidth === undefined &&
          b.condition === undefined
      );
      expect(minWidthBp).toBeDefined();
      // range breakpoint should exist and not overlap min-width
      const rangeBp = fragment.breakpoints.find(
        (b) => b.minWidth !== undefined && b.maxWidth !== undefined
      );
      expect(rangeBp).toBeDefined();
      // range's maxWidth must be less than the min-width breakpoint's minWidth
      // so they don't overlap
      expect(rangeBp!.maxWidth!).toBeLessThan(minWidthBp!.minWidth!);
    });

    test("range breakpoint overlapping with simple max-width breakpoint", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .a { font-size: 14px; }
          @media (max-width: 600px) {
            .a { font-size: 12px; }
          }
          @media (min-width: 400px) and (max-width: 900px) {
            .a { font-size: 16px; }
          }
        </style>
        <div class="a">Hello</div>
      `);
      const tokenSource = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "a"
      );
      expect(tokenSource).toBeDefined();
      const tokenStyles = fragment.styles.filter(
        (s) => s.styleSourceId === tokenSource!.id && s.property === "fontSize"
      );
      // base + max-width + range = 3 breakpoints
      expect(tokenStyles).toHaveLength(3);
      // simple max-width breakpoint should exist
      const maxWidthBp = fragment.breakpoints.find(
        (b) =>
          b.maxWidth !== undefined &&
          b.minWidth === undefined &&
          b.condition === undefined
      );
      expect(maxWidthBp).toBeDefined();
      // range breakpoint should exist and not overlap max-width
      const rangeBp = fragment.breakpoints.find(
        (b) => b.minWidth !== undefined && b.maxWidth !== undefined
      );
      expect(rangeBp).toBeDefined();
      // range's minWidth must be greater than the max-width breakpoint's maxWidth
      expect(rangeBp!.minWidth!).toBeGreaterThan(maxWidthBp!.maxWidth!);
    });

    test("completely contained range gets clamped", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .a { font-size: 14px; }
          @media (min-width: 400px) and (max-width: 1200px) {
            .a { font-size: 16px; }
          }
          @media (min-width: 600px) and (max-width: 900px) {
            .a { font-size: 18px; }
          }
        </style>
        <div class="a">Hello</div>
      `);
      const rangeBreakpoints = fragment.breakpoints
        .filter((b) => b.minWidth !== undefined && b.maxWidth !== undefined)
        .sort((a, b) => (a.minWidth ?? 0) - (b.minWidth ?? 0));
      expect(rangeBreakpoints).toHaveLength(2);
      // the outer range should be split/adjusted so inner doesn't overlap
      expect(rangeBreakpoints[0].maxWidth!).toBeLessThan(
        rangeBreakpoints[1].minWidth!
      );
    });

    test("combined width and feature uses condition breakpoint", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .widget { font-size: 14px; }
          @media (min-width: 768px) and (orientation: landscape) {
            .widget { font-size: 18px; }
          }
        </style>
        <div class="widget">Hello</div>
      `);
      const tokenSource = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "widget"
      );
      expect(tokenSource).toBeDefined();
      const landscapeStyle = fragment.styles.find(
        (s) =>
          s.styleSourceId === tokenSource!.id &&
          s.property === "fontSize" &&
          s.breakpointId !== "base"
      );
      expect(landscapeStyle).toBeDefined();
      const bp = fragment.breakpoints.find(
        (b) => b.id === landscapeStyle!.breakpointId
      );
      expect(bp).toBeDefined();
      // Mixed width + feature query becomes a condition
      expect(bp!.condition).toBeDefined();
    });

    test("multiple condition features combined", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .accessible { font-size: 16px; }
          @media (prefers-color-scheme: dark) and (prefers-contrast: more) {
            .accessible { font-size: 18px; }
          }
        </style>
        <div class="accessible">Hello</div>
      `);
      const tokenSource = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "accessible"
      );
      expect(tokenSource).toBeDefined();
      const conditionStyle = fragment.styles.find(
        (s) =>
          s.styleSourceId === tokenSource!.id &&
          s.property === "fontSize" &&
          s.breakpointId !== "base"
      );
      expect(conditionStyle).toBeDefined();
      const bp = fragment.breakpoints.find(
        (b) => b.id === conditionStyle!.breakpointId
      );
      expect(bp).toBeDefined();
      expect(bp!.condition).toBeDefined();
      // condition should contain both features
      expect(bp!.condition).toContain("prefers-color-scheme");
      expect(bp!.condition).toContain("prefers-contrast");
    });

    test("same condition breakpoint reused for multiple classes", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .card { background: white; }
          .text { color: black; }
          @media (prefers-color-scheme: dark) {
            .card { background: black; }
            .text { color: white; }
          }
        </style>
        <div class="card">
          <p class="text">Hello</p>
        </div>
      `);
      const cardToken = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "card"
      );
      const textToken = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "text"
      );
      expect(cardToken).toBeDefined();
      expect(textToken).toBeDefined();
      // both dark styles should reference the same breakpoint
      const cardDarkStyle = fragment.styles.find(
        (s) =>
          s.styleSourceId === cardToken!.id &&
          s.property === "backgroundColor" &&
          s.breakpointId !== "base"
      );
      const textDarkStyle = fragment.styles.find(
        (s) =>
          s.styleSourceId === textToken!.id &&
          s.property === "color" &&
          s.breakpointId !== "base"
      );
      expect(cardDarkStyle).toBeDefined();
      expect(textDarkStyle).toBeDefined();
      expect(cardDarkStyle!.breakpointId).toBe(textDarkStyle!.breakpointId);
    });
  });

  describe("nested at-rules", () => {
    test("nested @media rules extract class with flattened condition", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .card { display: flex; }
          @media (min-width: 768px) {
            @media (prefers-color-scheme: dark) {
              .card { background: black; }
            }
          }
        </style>
        <div class="card">Hello</div>
      `);
      const tokenSource = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "card"
      );
      expect(tokenSource).toBeDefined();
      // nested @media should flatten into a combined condition
      const nestedStyle = fragment.styles.find(
        (s) =>
          s.styleSourceId === tokenSource!.id &&
          s.property === "backgroundColor"
      );
      expect(nestedStyle).toBeDefined();
      const bp = fragment.breakpoints.find(
        (b) => b.id === nestedStyle!.breakpointId
      );
      expect(bp).toBeDefined();
      // flattened condition should include both queries
      expect(bp!.condition).toBeDefined();
    });

    test("deeply nested @media still extracts class tokens", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .card { padding: 8px; }
          @media (min-width: 768px) {
            @media (orientation: landscape) {
              @media (hover: hover) {
                .card { padding: 32px; }
              }
            }
          }
        </style>
        <div class="card">Hello</div>
      `);
      const tokenSource = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "card"
      );
      expect(tokenSource).toBeDefined();
      const deepStyle = fragment.styles.find(
        (s) =>
          s.styleSourceId === tokenSource!.id &&
          s.property === "paddingTop" &&
          s.breakpointId !== "base"
      );
      expect(deepStyle).toBeDefined();
      const bp = fragment.breakpoints.find(
        (b) => b.id === deepStyle!.breakpointId
      );
      expect(bp).toBeDefined();
      expect(bp!.condition).toBeDefined();
    });

    test("nested @media with same feature type combines correctly", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .responsive { font-size: 14px; }
          @media (min-width: 768px) {
            .responsive { font-size: 16px; }
            @media (min-width: 1024px) {
              .responsive { font-size: 20px; }
            }
          }
        </style>
        <div class="responsive">Hello</div>
      `);
      const tokenSource = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "responsive"
      );
      expect(tokenSource).toBeDefined();
      // outer @media (min-width: 768px) should have simple breakpoint
      const outerStyle = fragment.styles.find(
        (s) =>
          s.styleSourceId === tokenSource!.id &&
          s.property === "fontSize" &&
          s.breakpointId !== "base" &&
          fragment.breakpoints.find(
            (b) => b.id === s.breakpointId && b.minWidth === 768
          )
      );
      expect(outerStyle).toBeDefined();
      // nested @media (min-width: 1024px) inside @media (min-width: 768px)
      // should still produce a breakpoint (the effective min-width is 1024px)
      const innerStyles = fragment.styles.filter(
        (s) =>
          s.styleSourceId === tokenSource!.id &&
          s.property === "fontSize" &&
          s.breakpointId !== "base" &&
          s.breakpointId !== outerStyle!.breakpointId
      );
      expect(innerStyles).toHaveLength(1);
    });

    test("@supports nested inside @media keeps class in embed", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .grid { display: flex; }
          @supports (display: grid) {
            .grid { display: grid; }
          }
        </style>
        <div class="grid">Hello</div>
      `);
      // base class should become token
      const tokenSource = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "grid"
      );
      expect(tokenSource).toBeDefined();
      // @supports should remain as html embed (not a media query)
      const htmlEmbed = fragment.instances.find(
        (i) => i.component === "HtmlEmbed"
      );
      expect(htmlEmbed).toBeDefined();
    });
  });

  describe("selector edge cases", () => {
    test("class with compound selector .card.active is extracted as combo token", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .card.active { opacity: 1; }
        </style>
        <div class="card active">Hello</div>
      `);
      // compound selectors become combo tokens (Webflow-style naming)
      const tokenSource = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "card.active"
      );
      expect(tokenSource).toBeDefined();
      // no leftover for pure class rule
      expect(fragment.instances.some((i) => i.component === "HtmlEmbed")).toBe(
        false
      );
    });

    test("class with attribute selector .btn[disabled] is extracted with state", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .btn[disabled] { opacity: 0.5; }
        </style>
        <button class="btn" disabled>Click</button>
      `);
      const tokenSource = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "btn"
      );
      expect(tokenSource).toBeDefined();
      // the style should have [disabled] state
      const style = fragment.styles.find(
        (s) => s.styleSourceId === tokenSource!.id
      );
      expect(style).toBeDefined();
      expect(style!.state).toBe("[disabled]");
      // no leftover
      expect(fragment.instances.some((i) => i.component === "HtmlEmbed")).toBe(
        false
      );
    });

    test("class with sibling combinator .a + .b is not extracted", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .a + .b { margin-top: 8px; }
        </style>
        <div class="a">A</div>
        <div class="b">B</div>
      `);
      expect(
        fragment.styleSources.filter((s) => s.type === "token")
      ).toHaveLength(0);
    });

    test("class with general sibling .a ~ .b is not extracted", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .a ~ .b { color: red; }
        </style>
        <div class="a">A</div>
        <div class="b">B</div>
      `);
      expect(
        fragment.styleSources.filter((s) => s.type === "token")
      ).toHaveLength(0);
    });

    test(":root selector is extracted as local styles on the root instance, not as html embed", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          :root { --color: blue; }
          .card { color: var(--color); }
        </style>
        <div class="card">Hello</div>
      `);
      // .card should become token
      const tokenSource = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "card"
      );
      expect(tokenSource).toBeDefined();
      // :root should NOT produce an html embed
      expect(fragment.instances.some((i) => i.component === "HtmlEmbed")).toBe(
        false
      );
      // :root styles should be on the root instance selection
      const rootSelection = fragment.styleSourceSelections.find(
        (sel) => sel.instanceId === ":root"
      );
      expect(rootSelection).toBeDefined();
      const rootStyleSourceId = rootSelection!.values[0];
      const rootStyle = fragment.styles.find(
        (s) => s.styleSourceId === rootStyleSourceId && s.property === "--color"
      );
      expect(rootStyle).toBeDefined();
    });

    test(":root only styles are extracted as local styles on root instance", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          :root {
            color: red;
          }
        </style>
      `);
      // no html embed
      expect(fragment.instances.some((i) => i.component === "HtmlEmbed")).toBe(
        false
      );
      // style on :root instance
      const rootSelection = fragment.styleSourceSelections.find(
        (sel) => sel.instanceId === ":root"
      );
      expect(rootSelection).toBeDefined();
      const rootStyleSourceId = rootSelection!.values[0];
      const rootStyle = fragment.styles.find(
        (s) => s.styleSourceId === rootStyleSourceId && s.property === "color"
      );
      expect(rootStyle).toBeDefined();
      expect(rootStyle!.value).toMatchObject({ type: "keyword", value: "red" });
    });

    test("cross-selector gradient vars stay as var() references in pasted tokens", () => {
      const fragment = generateFragmentFromHtml(`
        <section class="scope">
          <style>
            .scope {
              --tone-1: #ff0000;
              --tone-2: #00ff00;
              --tone-3: #0000ff;
            }

            .panel {
              background: linear-gradient(38deg, var(--tone-1), var(--tone-2), var(--tone-3));
            }
          </style>

          <div class="panel">test</div>
        </section>
      `);
      const tokenSource = fragment.styleSources.find(
        (source) => source.type === "token" && source.name === "panel"
      );
      expect(tokenSource).toBeDefined();
      const backgroundImage = fragment.styles.find(
        (style) =>
          style.styleSourceId === tokenSource!.id &&
          style.property === "backgroundImage"
      );
      expect(backgroundImage?.value).toMatchObject({
        type: "layers",
        value: [
          {
            type: "unparsed",
            value:
              "linear-gradient(38deg,var(--tone-1),var(--tone-2),var(--tone-3))",
          },
        ],
      });
      expect(fragment.instances.some((i) => i.component === "HtmlEmbed")).toBe(
        false
      );
    });

    test("universal selector * stays as html embed", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          * { box-sizing: border-box; }
        </style>
        <div>Hello</div>
      `);
      expect(
        fragment.styleSources.filter((s) => s.type === "token")
      ).toHaveLength(0);
      expect(fragment.instances.some((i) => i.component === "HtmlEmbed")).toBe(
        true
      );
    });
  });

  describe("compound class selectors", () => {
    test("compound .card.active extracts as combo token when element has both classes", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .card { display: flex; }
          .card.active { opacity: 1; }
        </style>
        <div class="card active">Hello</div>
      `);
      const cardToken = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "card"
      );
      const comboToken = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "card.active"
      );
      expect(cardToken).toBeDefined();
      expect(comboToken).toBeDefined();
      // instance should reference both tokens
      const sel = fragment.styleSourceSelections.find(
        (s) =>
          s.values.includes(cardToken!.id) && s.values.includes(comboToken!.id)
      );
      expect(sel).toBeDefined();
    });

    test("compound .a.b.c extracts as triple combo token", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .a.b.c { color: red; }
        </style>
        <div class="a b c">Hello</div>
      `);
      const comboToken = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "a.b.c"
      );
      expect(comboToken).toBeDefined();
      const style = fragment.styles.find(
        (s) => s.styleSourceId === comboToken!.id && s.property === "color"
      );
      expect(style).toBeDefined();
    });

    test("compound class not matched when element is missing a class", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .card.active { opacity: 1; }
        </style>
        <div class="card">Hello</div>
      `);
      // token is created for all class rules, even if not applied to elements
      const comboToken = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "card.active"
      );
      expect(comboToken).toBeDefined();
      // but NOT assigned to the div (missing "active" class)
      const divInstance = fragment.instances.find((i) => i.tag === "div");
      const sel = fragment.styleSourceSelections.find(
        (s) => s.instanceId === divInstance?.id
      );
      // No selection for this instance, or if one exists, it shouldn't contain the combo token
      expect(sel?.values ?? []).not.toContain(comboToken?.id);
    });

    test("compound class with :hover pseudo extracts correctly", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .btn.primary:hover { background: blue; }
        </style>
        <button class="btn primary">Click</button>
      `);
      const comboToken = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "btn.primary"
      );
      expect(comboToken).toBeDefined();
      const style = fragment.styles.find(
        (s) => s.styleSourceId === comboToken!.id
      );
      expect(style).toBeDefined();
      expect(style!.state).toBe(":hover");
    });

    test("compound class inside @media query creates breakpoint style", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .card.featured { display: block; }
          @media (min-width: 768px) {
            .card.featured { display: flex; }
          }
        </style>
        <div class="card featured">Hello</div>
      `);
      const comboToken = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "card.featured"
      );
      expect(comboToken).toBeDefined();
      // Should have both base and breakpoint styles
      const comboStyles = fragment.styles.filter(
        (s) => s.styleSourceId === comboToken!.id
      );
      expect(comboStyles.length).toBe(2);
      const bpIds = new Set(comboStyles.map((s) => s.breakpointId));
      expect(bpIds.size).toBe(2);
    });
  });

  describe("attribute selectors as state", () => {
    test(".btn[disabled] extracts with [disabled] state", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .btn { padding: 8px; }
          .btn[disabled] { opacity: 0.5; }
        </style>
        <button class="btn" disabled>Click</button>
      `);
      const btnToken = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "btn"
      );
      expect(btnToken).toBeDefined();
      const baseStyle = fragment.styles.find(
        (s) => s.styleSourceId === btnToken!.id && s.state === undefined
      );
      expect(baseStyle).toBeDefined();
      expect(baseStyle!.property).toBe("paddingTop");
      const stateStyle = fragment.styles.find(
        (s) => s.styleSourceId === btnToken!.id && s.state === "[disabled]"
      );
      expect(stateStyle).toBeDefined();
      expect(stateStyle!.property).toBe("opacity");
    });

    test(".input[readonly] extracts with [readonly] state", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .input[readonly] { background: #eee; }
        </style>
        <input class="input" readonly>
      `);
      const inputToken = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "input"
      );
      expect(inputToken).toBeDefined();
      const stateStyle = fragment.styles.find(
        (s) => s.styleSourceId === inputToken!.id && s.state === "[readonly]"
      );
      expect(stateStyle).toBeDefined();
    });

    test("attribute selector combined with pseudo keeps pseudo state", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .btn:hover { color: blue; }
          .btn[disabled] { opacity: 0.5; }
        </style>
        <button class="btn" disabled>Click</button>
      `);
      const btnToken = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "btn"
      );
      expect(btnToken).toBeDefined();
      const hoverStyle = fragment.styles.find(
        (s) => s.styleSourceId === btnToken!.id && s.state === ":hover"
      );
      expect(hoverStyle).toBeDefined();
      const disabledStyle = fragment.styles.find(
        (s) => s.styleSourceId === btnToken!.id && s.state === "[disabled]"
      );
      expect(disabledStyle).toBeDefined();
    });
  });

  describe("mixed comma selectors (partial extraction)", () => {
    test(".card, div {} extracts .card token, keeps div in leftover", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .card, div { display: flex; }
        </style>
        <div class="card">Hello</div>
      `);
      const cardToken = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "card"
      );
      expect(cardToken).toBeDefined();
      // div part should stay as html embed
      const htmlEmbed = fragment.instances.find(
        (i) => i.component === "HtmlEmbed"
      );
      expect(htmlEmbed).toBeDefined();
      const codeProp = fragment.props.find(
        (p) => p.instanceId === htmlEmbed!.id && p.name === "code"
      );
      expect(codeProp).toBeDefined();
      // The leftover should only contain the div selector, not .card
      expect(codeProp!.type === "string" && codeProp!.value).toContain("div");
      expect(codeProp!.type === "string" && codeProp!.value).not.toMatch(
        /\.card/
      );
    });

    test(".a, .b, #id {} extracts .a and .b, keeps #id in leftover", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .a, .b, #id { color: red; }
        </style>
        <div class="a">A</div>
        <div class="b">B</div>
      `);
      const tokenA = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "a"
      );
      const tokenB = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "b"
      );
      expect(tokenA).toBeDefined();
      expect(tokenB).toBeDefined();
      // #id should stay in embed
      const htmlEmbed = fragment.instances.find(
        (i) => i.component === "HtmlEmbed"
      );
      expect(htmlEmbed).toBeDefined();
    });

    test(".a, .b {} with all class selectors produces no leftover", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .a, .b { padding: 4px; }
        </style>
        <div class="a">A</div>
        <div class="b">B</div>
      `);
      // Both should become tokens
      expect(
        fragment.styleSources.filter((s) => s.type === "token")
      ).toHaveLength(2);
      // No leftover embed
      expect(fragment.instances.some((i) => i.component === "HtmlEmbed")).toBe(
        false
      );
    });
  });

  describe("breakpoint labels", () => {
    test("condition breakpoint gets human-readable label", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          @media (prefers-color-scheme: dark) {
            .card { background: black; }
          }
        </style>
        <div class="card">Hello</div>
      `);
      const condBp = fragment.breakpoints.find((b) => b.condition);
      expect(condBp).toBeDefined();
      // capitalCase transforms "prefers-color-scheme:dark" → "Prefers Color Scheme Dark"
      expect(condBp!.label).toBe("Prefers Color Scheme Dark");
    });

    test("width breakpoint gets readable label", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          @media (min-width: 768px) {
            .card { display: flex; }
          }
        </style>
        <div class="card">Hello</div>
      `);
      const bp = fragment.breakpoints.find((b) => b.minWidth === 768);
      expect(bp).toBeDefined();
      expect(bp!.label).toBe("≥ 768px");
    });

    test("range breakpoint gets combined label", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          @media (min-width: 768px) and (max-width: 1024px) {
            .card { display: flex; }
          }
        </style>
        <div class="card">Hello</div>
      `);
      const bp = fragment.breakpoints.find(
        (b) => b.minWidth === 768 && b.maxWidth === 1024
      );
      expect(bp).toBeDefined();
      expect(bp!.label).toBe("≥ 768px and ≤ 1024px");
    });
  });

  describe("complex real-world scenarios", () => {
    test("responsive card component with hover states", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .card {
            display: flex;
            flex-direction: column;
            padding: 16px;
            border-radius: 8px;
          }
          .card:hover {
            box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
          }
          @media (min-width: 768px) {
            .card {
              flex-direction: row;
              padding: 24px;
            }
          }
          .card-title {
            font-size: 18px;
            font-weight: bold;
          }
          @media (min-width: 768px) {
            .card-title {
              font-size: 24px;
            }
          }
        </style>
        <div class="card">
          <h2 class="card-title">Title</h2>
          <p>Description</p>
        </div>
      `);
      // both tokens should be created
      const cardToken = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "card"
      );
      const titleToken = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "card-title"
      );
      expect(cardToken).toBeDefined();
      expect(titleToken).toBeDefined();
      // card should have hover state
      expect(
        fragment.styles.some(
          (s) => s.styleSourceId === cardToken!.id && s.state === ":hover"
        )
      ).toBe(true);
      // card should have breakpoint styles
      const cardBreakpoints = new Set(
        fragment.styles
          .filter((s) => s.styleSourceId === cardToken!.id && !s.state)
          .map((s) => s.breakpointId)
      );
      expect(cardBreakpoints.size).toBeGreaterThanOrEqual(2);
      // title should have breakpoint styles
      const titleBreakpoints = new Set(
        fragment.styles
          .filter((s) => s.styleSourceId === titleToken!.id)
          .map((s) => s.breakpointId)
      );
      expect(titleBreakpoints.size).toBeGreaterThanOrEqual(2);
      // no HtmlEmbed (all rules are class-based)
      expect(fragment.instances.some((i) => i.component === "HtmlEmbed")).toBe(
        false
      );
    });

    test("html with mixed class rules, id rules, keyframes, and media queries", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          @keyframes fadeIn {
            from { opacity: 0; }
            to { opacity: 1; }
          }
          .fade-in { animation: fadeIn 0.3s ease-in; }
          .card { display: flex; }
          #app { min-height: 100vh; }
          @media (min-width: 768px) {
            .card { flex-direction: row; }
          }
        </style>
        <div class="card fade-in">
          <p>Hello</p>
        </div>
      `);
      // class tokens should be extracted
      expect(
        fragment.styleSources.find(
          (s) => s.type === "token" && s.name === "card"
        )
      ).toBeDefined();
      expect(
        fragment.styleSources.find(
          (s) => s.type === "token" && s.name === "fade-in"
        )
      ).toBeDefined();
      // @keyframes and #app should remain as html embed
      const htmlEmbed = fragment.instances.find(
        (i) => i.component === "HtmlEmbed"
      );
      expect(htmlEmbed).toBeDefined();
      const codeProp = fragment.props.find(
        (p) => p.instanceId === htmlEmbed!.id && p.name === "code"
      );
      expect(codeProp!.type === "string" && codeProp!.value).toContain(
        "@keyframes"
      );
      expect(codeProp!.type === "string" && codeProp!.value).toContain("#app");
    });

    test("navigation component with multiple states and breakpoints", () => {
      const fragment = generateFragmentFromHtml(`
        <style>
          .nav { display: flex; gap: 8px; }
          .nav-link { color: gray; text-decoration: none; }
          .nav-link:hover { color: blue; }
          .nav-link:focus { outline: 2px solid blue; }
          .nav-link::after { content: ""; display: block; height: 2px; }
          @media (min-width: 768px) {
            .nav { gap: 16px; }
            .nav-link { font-size: 16px; }
          }
        </style>
        <nav class="nav">
          <a class="nav-link">Home</a>
          <a class="nav-link">About</a>
        </nav>
      `);
      const navToken = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "nav"
      );
      const linkToken = fragment.styleSources.find(
        (s) => s.type === "token" && s.name === "nav-link"
      );
      expect(navToken).toBeDefined();
      expect(linkToken).toBeDefined();
      // nav-link should have hover, focus, and ::after states
      const linkStates = new Set(
        fragment.styles
          .filter((s) => s.styleSourceId === linkToken!.id && s.state)
          .map((s) => s.state)
      );
      expect(linkStates.has(":hover")).toBe(true);
      expect(linkStates.has(":focus")).toBe(true);
      expect(linkStates.has("::after")).toBe(true);
      // both should have breakpoint styles
      const navBreakpoints = new Set(
        fragment.styles
          .filter((s) => s.styleSourceId === navToken!.id)
          .map((s) => s.breakpointId)
      );
      expect(navBreakpoints.size).toBeGreaterThanOrEqual(2);
      // nav-link token should be reused for both <a> elements
      const linkSelections = fragment.styleSourceSelections.filter((sel) =>
        sel.values.includes(linkToken!.id)
      );
      expect(linkSelections).toHaveLength(2);
    });
  });

  describe("nested selectors", () => {
    test("resolve descendant selector to matching element", () => {
      const cardInnerToken = token(
        "card__inner",
        css`
          color: red;
        `
      );
      expect(
        generateFragmentFromHtml(`
          <style>.card .inner { color: red; }</style>
          <div class="card"><span class="inner">Hello</span></div>
        `)
      ).toEqual(
        renderTemplate(
          <ws.element ws:tag="div" class="card">
            <ws.element ws:tag="span" ws:tokens={[cardInnerToken]}>
              Hello
            </ws.element>
          </ws.element>
        )
      );
    });

    test("resolve child combinator to direct child", () => {
      const parentChildToken = token(
        "parent__child",
        css`
          margin: 0;
        `
      );
      expect(
        generateFragmentFromHtml(`
          <style>.parent > .child { margin: 0; }</style>
          <div class="parent"><span class="child">Hello</span></div>
        `)
      ).toEqual(
        renderTemplate(
          <ws.element ws:tag="div" class="parent">
            <ws.element ws:tag="span" ws:tokens={[parentChildToken]}>
              Hello
            </ws.element>
          </ws.element>
        )
      );
    });

    test("child combinator does not match non-direct child", () => {
      const result = _generateFragmentFromHtml(`
        <style>.parent > .child { color: red; }</style>
        <div class="parent"><div><span class="child">Hello</span></div></div>
      `);
      // .child is nested inside an intermediate div, not a direct child of .parent
      expect(result.skippedSelectors).toEqual([".parent > .child"]);
      // no token created for the nested rule
      expect(
        result.styleSources.filter((s) => s.type === "token")
      ).toHaveLength(0);
    });

    test("skip unresolved nested selector and report it", () => {
      const result = _generateFragmentFromHtml(`
        <style>.card .title { color: red; }</style>
        <div class="card"><span>No title class here</span></div>
      `);
      expect(result.skippedSelectors).toEqual([".card .title"]);
      expect(
        result.styleSources.filter((s) => s.type === "token")
      ).toHaveLength(0);
    });

    test("style-only paste with nested selector — all skipped", () => {
      const result = _generateFragmentFromHtml(`
        <style>.card .title { color: red; }</style>
      `);
      expect(result.skippedSelectors).toEqual([".card .title"]);
      expect(result.styleSources).toHaveLength(0);
    });

    test("mixed simple and nested selectors", () => {
      const result = _generateFragmentFromHtml(`
        <style>
          .card { display: flex; }
          .card .title { font-weight: bold; }
        </style>
        <div class="card"><h1 class="title">Hello</h1></div>
      `);
      expect(result.skippedSelectors).toEqual([]);
      // .card token + .card__title nested token
      const tokenNames = result.styleSources
        .filter((s) => s.type === "token")
        .map((s) => s.name);
      expect(tokenNames).toContain("card");
      expect(tokenNames).toContain("card__title");
    });

    test("multiple ancestors: .a .b .c", () => {
      const result = _generateFragmentFromHtml(`
        <style>.a .b .c { color: red; }</style>
        <div class="a"><div class="b"><span class="c">Hi</span></div></div>
      `);
      expect(result.skippedSelectors).toEqual([]);
      const tokenNames = result.styleSources
        .filter((s) => s.type === "token")
        .map((s) => s.name);
      expect(tokenNames).toContain("a__b__c");
    });

    test("nested selector with media query", () => {
      const result = _generateFragmentFromHtml(`
        <style>
          .card .title { color: red; }
          @media (min-width: 768px) {
            .card .title { color: blue; }
          }
        </style>
        <div class="card"><h1 class="title">Hello</h1></div>
      `);
      expect(result.skippedSelectors).toEqual([]);
      const nestedToken = result.styleSources.find(
        (s) => s.type === "token" && s.name === "card__title"
      );
      expect(nestedToken).toBeDefined();
      // should have styles at base breakpoint and 768px breakpoint
      const nestedStyles = result.styles.filter(
        (s) => s.styleSourceId === nestedToken!.id
      );
      const breakpointIds = new Set(nestedStyles.map((s) => s.breakpointId));
      expect(breakpointIds.size).toBe(2);
    });

    test("sibling combinators stay as leftover", () => {
      const result = _generateFragmentFromHtml(`
        <style>.a + .b { color: red; }</style>
        <div class="a">A</div><div class="b">B</div>
      `);
      // sibling selector is not class-based → stays as HtmlEmbed
      expect(result.instances.some((i) => i.component === "HtmlEmbed")).toBe(
        true
      );
    });
  });

  test("resolves cross-rule CSS variable in background shorthand", () => {
    // --clr-red is defined in .my-parent but used in .my-child.
    // background: var(--clr-red) must expand to background-color with the
    // var() reference preserved — NOT inlined to the concrete color #f00.
    const result = _generateFragmentFromHtml(`
      <style>
        .my-parent { --clr-red: #f00; }
        .my-child { background: var(--clr-red); }
      </style>
      <div class="my-parent">
        <div class="my-child">test</div>
      </div>
    `);
    const childToken = result.styleSources.find(
      (s) => s.type === "token" && s.name === "my-child"
    );
    expect(childToken).toBeDefined();
    const bgColor = result.styles.find(
      (s) =>
        s.styleSourceId === childToken!.id && s.property === "backgroundColor"
    );
    // Must be a var() reference, not a concrete inlined color
    expect(bgColor?.value).toEqual(
      expect.objectContaining({ type: "var", value: "clr-red" })
    );
  });

  describe("preserve border color var() references", () => {
    const getTokenStyle = (
      fragment: WebstudioFragment,
      tokenName: string,
      property: string
    ) => {
      const tokenSource = fragment.styleSources.find(
        (source) => source.type === "token" && source.name === tokenName
      );
      expect(tokenSource).toBeDefined();
      return fragment.styles.find(
        (style) =>
          style.styleSourceId === tokenSource!.id && style.property === property
      );
    };

    const getSelection = (fragment: WebstudioFragment, instanceId: string) => {
      return fragment.styleSourceSelections.find(
        (selection) => selection.instanceId === instanceId
      );
    };

    test("typed arbitrary color utility keeps var reference", () => {
      const fragment = _generateFragmentFromHtml(`
        <style>
          .border { border-width: 1px; border-style: solid; border-color: #e5e7eb; }
          .border-\\[color\\:var\\(--border-color\\)\\] { border-color: var(--border-color); }
        </style>
        <div class="p-8 border border-[color:var(--border-color)]"></div>
      `);
      const borderColorStyle = getTokenStyle(
        fragment,
        "border-[color:var(--border-color)]",
        "borderTopColor"
      );
      expect(borderColorStyle?.value).toEqual(
        expect.objectContaining({ type: "var", value: "border-color" })
      );
    });

    test("css variable shorthand utility keeps var reference", () => {
      const fragment = _generateFragmentFromHtml(`
        <style>
          .border { border-width: 1px; border-style: solid; border-color: #e5e7eb; }
          .border-\\(--border-color\\) { border-color: var(--border-color); }
        </style>
        <div class="p-8 border border-(--border-color)"></div>
      `);
      const borderColorStyle = getTokenStyle(
        fragment,
        "border-(--border-color)",
        "borderTopColor"
      );
      expect(borderColorStyle?.value).toEqual(
        expect.objectContaining({ type: "var", value: "border-color" })
      );
    });

    test("inline border-color style keeps var reference", () => {
      const fragment = _generateFragmentFromHtml(`
        <style>
          .border { border-width: 1px; border-style: solid; border-color: #e5e7eb; }
        </style>
        <div class="p-8 border" style="border-color: var(--border-color)"></div>
      `);
      const divInstance = fragment.instances.find(
        (instance) => instance.tag === "div"
      );
      expect(divInstance).toBeDefined();
      expect(getSelection(fragment, divInstance!.id)?.values).toEqual([
        expect.any(String),
        `${divInstance!.id}:ws:style`,
      ]);
      const localStyle = fragment.styles.find(
        (style) =>
          style.styleSourceId === `${divInstance!.id}:ws:style` &&
          style.property === "borderTopColor"
      );
      expect(localStyle?.value).toEqual(
        expect.objectContaining({ type: "var", value: "border-color" })
      );
    });

    test("arbitrary property utility keeps var reference", () => {
      const fragment = _generateFragmentFromHtml(`
        <style>
          .border { border-width: 1px; border-style: solid; border-color: #e5e7eb; }
          .\\[border-color\\:var\\(--border-color\\)\\] { border-color: var(--border-color); }
        </style>
        <div class="p-8 border [border-color:var(--border-color)]"></div>
      `);
      const borderColorStyle = getTokenStyle(
        fragment,
        "[border-color:var(--border-color)]",
        "borderTopColor"
      );
      expect(borderColorStyle?.value).toEqual(
        expect.objectContaining({ type: "var", value: "border-color" })
      );
    });

    test("typed literal utility keeps literal color", () => {
      const fragment = _generateFragmentFromHtml(`
        <style>
          .border { border-width: 1px; border-style: solid; border-color: #e5e7eb; }
          .border-\\[color\\:\\#000\\] { border-color: #000; }
        </style>
        <div class="p-8 border border-[color:#000]"></div>
      `);
      const borderColorStyle = getTokenStyle(
        fragment,
        "border-[color:#000]",
        "borderTopColor"
      );
      expect(borderColorStyle?.value).toEqual(
        expect.objectContaining({ type: "color", colorSpace: "hex" })
      );
    });

    test("border side utility with var color keeps var reference", () => {
      const fragment = _generateFragmentFromHtml(`
        <style>
          .border-t { border-top-width: 1px; border-top-style: solid; border-color: #e5e7eb; }
          .border-\\[color\\:var\\(--border-color\\)\\] { border-color: var(--border-color); }
        </style>
        <div class="p-8 border-t border-[color:var(--border-color)]"></div>
      `);
      const borderColorStyle = getTokenStyle(
        fragment,
        "border-[color:var(--border-color)]",
        "borderTopColor"
      );
      expect(borderColorStyle?.value).toEqual(
        expect.objectContaining({ type: "var", value: "border-color" })
      );
    });

    test("inline border shorthand keeps var color reference", () => {
      const fragment = _generateFragmentFromHtml(`
        <style>
          .border { border-width: 1px; border-style: solid; border-color: #e5e7eb; }
        </style>
        <div class="p-8 border" style="border: 1px solid var(--border-color)"></div>
      `);
      const divInstance = fragment.instances.find(
        (instance) => instance.tag === "div"
      );
      expect(divInstance).toBeDefined();
      expect(getSelection(fragment, divInstance!.id)?.values).toEqual([
        expect.any(String),
        `${divInstance!.id}:ws:style`,
      ]);
      const localStyle = fragment.styles.find(
        (style) =>
          style.styleSourceId === `${divInstance!.id}:ws:style` &&
          style.property === "borderTopColor"
      );
      expect(localStyle?.value).toEqual(
        expect.objectContaining({ type: "var", value: "border-color" })
      );
    });
  });
});