playwriter 0.0.105 → 0.2.0

package/dist/performance-profiling.md

@@ -0,0 +1,417 @@
+# Profile Website Performance with Playwriter
+
+Playwriter can profile a real website in your own Chrome using **CDP**, **Navigation Timing**,
+and **PerformanceObserver**.
+
+Use it to answer four practical questions quickly:
+
+1. **Did the page render fast enough?**
+2. **What requests cost the most bytes?**
+3. **What blocked first paint or LCP?**
+4. **What blocked interactivity?**
+
+## What to measure
+
+| Metric | Good | Needs work | Usually means |
+| --- | --- | --- | --- |
+| **TTFB** | under **800ms** | over **1.2s** | slow server or cache miss |
+| **FCP** | under **1.8s** | over **3s** | content appears late |
+| **LCP** | under **2.5s** | over **4s** | hero image, font, CSS, server, or JS delay |
+| **CLS** | under **0.1** | over **0.25** | unstable layout |
+| **Long task** | under **50ms** | over **100ms** | main thread blocked by JS |
+| **JS transfer** | under **250KB** | over **500KB** | too much hydration or client code |
+| **Font / media transfer** | context dependent | large above-the-fold assets | fonts, posters, videos, hero images |
+
+## What usually blocks what
+
+- **First paint / FCP** is usually gated by **TTFB**, critical HTML, critical CSS, and above-the-fold fonts/images.
+- **LCP** is usually gated by the **largest hero asset**. Common causes: hero image, poster image, custom font, render-blocking CSS, or slow server response.
+- **Interactivity** is usually gated by **long tasks**. Common causes: too much JS on startup, hydration, or a large framework chunk.
+- **Load event** often stays late because of **non-critical assets** like videos, analytics, background images, and delayed client bundles.
+
+## Quick commands
+
+Create a session and open a page:
+
+```bash
+playwriter session new
+playwriter -s 1 -e 'state.page = context.pages().find((p) => p.url() === "about:blank") ?? (await context.newPage()); await state.page.goto("https://example.com", { waitUntil: "domcontentloaded" })'
+```
+
+Collect a concise vitals report:
+
+```bash
+playwriter -s 1 -e "$(cat <<'EOF'
+await state.page.evaluate(() => {
+  const metrics = { paints: {}, lcp: 0, cls: 0 }
+  globalThis.__pwMetrics = metrics
+
+  new PerformanceObserver((list) => {
+    for (const entry of list.getEntries()) {
+      metrics.paints[entry.name] = entry.startTime
+    }
+  }).observe({ type: 'paint', buffered: true })
+
+  new PerformanceObserver((list) => {
+    const lastEntry = list.getEntries().at(-1)
+    if (lastEntry) {
+      metrics.lcp = lastEntry.startTime
+    }
+  }).observe({ type: 'largest-contentful-paint', buffered: true })
+
+  new PerformanceObserver((list) => {
+    for (const entry of list.getEntries()) {
+      if (!entry.hadRecentInput) {
+        metrics.cls += entry.value
+      }
+    }
+  }).observe({ type: 'layout-shift', buffered: true })
+})
+
+await state.page.reload({ waitUntil: 'domcontentloaded' })
+await waitForPageLoad({ page: state.page, timeout: 10000 })
+await state.page.waitForTimeout(3000)
+
+const report = await state.page.evaluate(() => {
+  const nav = performance.getEntriesByType('navigation')[0]
+  const metrics = globalThis.__pwMetrics
+  return {
+    ttfb: nav?.responseStart || 0,
+    domContentLoaded: nav?.domContentLoadedEventEnd || 0,
+    load: nav?.loadEventEnd || 0,
+    fcp: metrics?.paints['first-contentful-paint'] || 0,
+    lcp: metrics?.lcp || 0,
+    cls: metrics?.cls || 0,
+  }
+})
+
+console.log(JSON.stringify(report, null, 2))
+EOF
+)"
+```
+
+List the heaviest requests with CDP:
+
+```bash
+playwriter -s 1 -e "$(cat <<'EOF'
+const cdp = await getCDPSession({ page: state.page })
+await cdp.send('Network.enable')
+await cdp.send('Network.setCacheDisabled', { cacheDisabled: true })
+
+const responses = new Map()
+const finished = new Map()
+
+cdp.on('Network.responseReceived', (event) => {
+  responses.set(event.requestId, {
+    url: event.response.url,
+    mimeType: event.response.mimeType,
+  })
+})
+
+cdp.on('Network.loadingFinished', (event) => {
+  finished.set(event.requestId, event.encodedDataLength)
+})
+
+await state.page.reload({ waitUntil: 'domcontentloaded' })
+await waitForPageLoad({ page: state.page, timeout: 10000 })
+await state.page.waitForTimeout(3000)
+
+const largest = [...responses.entries()]
+  .map(([requestId, response]) => ({
+    url: response.url,
+    mimeType: response.mimeType,
+    bytes: finished.get(requestId) || 0,
+  }))
+  .sort((a, b) => b.bytes - a.bytes)
+  .slice(0, 10)
+
+console.log(JSON.stringify(largest, null, 2))
+EOF
+)"
+```
+
+Check interactivity blockers:
+
+```bash
+playwriter -s 1 -e "$(cat <<'EOF'
+await state.page.evaluate(() => {
+  globalThis.__pwLongTasks = []
+  globalThis.__pwEvents = []
+
+  new PerformanceObserver((list) => {
+    globalThis.__pwLongTasks.push(
+      ...list.getEntries().map((entry) => ({ startTime: entry.startTime, duration: entry.duration })),
+    )
+  }).observe({ type: 'longtask', buffered: true })
+
+  new PerformanceObserver((list) => {
+    globalThis.__pwEvents.push(
+      ...list.getEntries().map((entry) => ({
+        name: entry.name,
+        duration: entry.duration,
+        interactionId: entry.interactionId,
+      })),
+    )
+  }).observe({ type: 'event', buffered: true, durationThreshold: 16 })
+})
+
+await state.page.getByRole('button').first().click()
+await state.page.waitForTimeout(1000)
+
+const report = await state.page.evaluate(() => ({
+  longTasks: globalThis.__pwLongTasks.filter((entry) => entry.duration >= 50),
+  interactions: globalThis.__pwEvents.filter((entry) => entry.interactionId !== 0),
+}))
+
+console.log(JSON.stringify(report, null, 2))
+EOF
+)"
+```
+
+## How to read the results
+
+**Fast render, heavy payload**
+
+- If **FCP** and **LCP** are good but total bytes are huge, the page probably **looks fast on desktop** but wastes bandwidth on mobile.
+- This often happens with **hero videos**, large poster images, or custom fonts.
+
+**Slow first paint**
+
+- If **TTFB** is high, fix **server latency** or caching first.
+- If **TTFB** is fine but **FCP** is slow, inspect critical CSS, fonts, and above-the-fold images.
+
+**Slow interactivity**
+
+- If you see **long tasks over 50ms**, startup JS is the first suspect.
+- Look for large client bundles, hydration-heavy UI, and event handlers doing too much work.
+
+**Need deeper CPU answers**
+
+- If vitals and request sizes are not enough, record a **`.cpuprofile`** with Playwriter's raw **`Profiler.*`** CDP commands and inspect it with **[profano](https://github.com/remorses/profano)**.
+- A good place to keep your reusable profiling snippets is your dots repo, for example **`~/.config/opencode/`**.
+
+**Good load event is not enough**
+
+- A page can have a decent `load` time and still feel slow if **LCP** or **long tasks** are bad.
+- Prefer **TTFB + FCP + LCP + CLS + long tasks** over the load event alone.
+
+## Performance checklist
+
+**If TTFB is bad**
+
+- cache HTML closer to users
+- reduce origin work before response
+- avoid expensive server-side data fetching on the critical route
+
+**If FCP or LCP is bad**
+
+- trim or defer render-blocking CSS
+- avoid large above-the-fold fonts and images
+- preload only truly critical assets
+- compress hero media harder
+
+**If interactivity is bad**
+
+- reduce startup JS
+- split large client bundles
+- avoid hydrating UI that is not immediately interactive
+- move optional widgets behind user action or idle time
+- if the culprit is still unclear, switch from vitals to a CPU profile and inspect hot functions with **profano**
+
+**If bytes are bad but vitals look good**
+
+- optimize for slower devices anyway
+- background videos are the first thing to cut
+- subset fonts and trim non-critical client features
+
+## Examples
+
+```ts
+// Example snippets for profiling website performance with Playwriter and CDP.
+
+import { console, getCDPSession, page } from './debugger-examples-types.js'
+
+type PerfMetrics = {
+  paints: Record<string, number>
+  lcp: number
+  cls: number
+}
+
+type ObservedPerfEntry = {
+  name: string
+  startTime: number
+  duration: number
+  hadRecentInput?: boolean
+  value?: number
+  interactionId?: number
+}
+
+type NavigationTimingEntry = {
+  responseStart: number
+  domContentLoadedEventEnd: number
+  loadEventEnd: number
+}
+
+type LongTaskEntry = {
+  startTime: number
+  duration: number
+}
+
+type EventTimingEntry = {
+  name: string
+  duration: number
+  interactionId: number
+}
+
+// Example: Collect navigation timing and basic web vitals from the current page
+async function collectWebVitals() {
+  await page.evaluate(() => {
+    const metrics: PerfMetrics = {
+      paints: {},
+      lcp: 0,
+      cls: 0,
+    }
+
+    const perfGlobal = globalThis as typeof globalThis & {
+      __pwPerfMetrics?: PerfMetrics
+    }
+
+    perfGlobal.__pwPerfMetrics = metrics
+
+    new PerformanceObserver((list) => {
+      for (const entry of list.getEntries() as ObservedPerfEntry[]) {
+        metrics.paints[entry.name] = entry.startTime
+      }
+    }).observe({ type: 'paint', buffered: true } as never)
+
+    new PerformanceObserver((list) => {
+      const entries = list.getEntries() as ObservedPerfEntry[]
+      const lastEntry = entries[entries.length - 1]
+      if (!lastEntry) {
+        return
+      }
+      metrics.lcp = lastEntry.startTime
+    }).observe({ type: 'largest-contentful-paint', buffered: true } as never)
+
+    new PerformanceObserver((list) => {
+      for (const entry of list.getEntries() as ObservedPerfEntry[]) {
+        if (entry.hadRecentInput) {
+          continue
+        }
+        metrics.cls += entry.value || 0
+      }
+    }).observe({ type: 'layout-shift', buffered: true } as never)
+  })
+
+  await page.reload({ waitUntil: 'domcontentloaded' })
+
+  const report = await page.evaluate(() => {
+    const perfGlobal = globalThis as typeof globalThis & {
+      __pwPerfMetrics?: PerfMetrics
+    }
+    const nav = performance.getEntriesByType('navigation' as never)[0] as unknown as
+      | NavigationTimingEntry
+      | undefined
+    const metrics = perfGlobal.__pwPerfMetrics
+
+    return {
+      ttfb: nav?.responseStart || 0,
+      domContentLoaded: nav?.domContentLoadedEventEnd || 0,
+      load: nav?.loadEventEnd || 0,
+      fcp: metrics?.paints['first-contentful-paint'] || 0,
+      lcp: metrics?.lcp || 0,
+      cls: metrics?.cls || 0,
+    }
+  })
+
+  console.log(report)
+}
+
+// Example: Measure the biggest transferred requests with raw CDP network events
+async function collectHeaviestRequests() {
+  const cdp = await getCDPSession({ page })
+  await cdp.send('Network.enable')
+  await cdp.send('Network.setCacheDisabled', { cacheDisabled: true })
+
+  const responses = new Map<string, { url: string; mimeType: string }>()
+  const finished = new Map<string, number>()
+
+  cdp.on('Network.responseReceived', (event) => {
+    responses.set(event.requestId, {
+      url: event.response.url,
+      mimeType: event.response.mimeType,
+    })
+  })
+
+  cdp.on('Network.loadingFinished', (event) => {
+    finished.set(event.requestId, event.encodedDataLength)
+  })
+
+  await page.reload({ waitUntil: 'domcontentloaded' })
+
+  const largest = [...responses.entries()]
+    .map(([requestId, response]) => {
+      return {
+        url: response.url,
+        mimeType: response.mimeType,
+        bytes: finished.get(requestId) || 0,
+      }
+    })
+    .sort((a, b) => b.bytes - a.bytes)
+    .slice(0, 10)
+
+  console.log(largest)
+}
+
+// Example: Check whether interactivity is blocked by long tasks or slow events
+async function measureInteractivity() {
+  await page.evaluate(() => {
+    const perfGlobal = globalThis as typeof globalThis & {
+      __pwLongTasks?: LongTaskEntry[]
+      __pwEventTimings?: EventTimingEntry[]
+    }
+
+    perfGlobal.__pwLongTasks = []
+    perfGlobal.__pwEventTimings = []
+
+    new PerformanceObserver((list) => {
+      perfGlobal.__pwLongTasks?.push(
+        ...(list.getEntries() as ObservedPerfEntry[]).map((entry) => ({
+          startTime: entry.startTime,
+          duration: entry.duration,
+        })),
+      )
+    }).observe({ type: 'longtask', buffered: true } as never)
+
+    new PerformanceObserver((list) => {
+      perfGlobal.__pwEventTimings?.push(
+        ...(list.getEntries() as ObservedPerfEntry[]).map((entry) => ({
+          name: entry.name,
+          duration: entry.duration,
+          interactionId: entry.interactionId || 0,
+        })),
+      )
+    }).observe({ type: 'event', buffered: true, durationThreshold: 16 } as never)
+  })
+
+  const button = page.getByRole('button').first()
+  await button.click()
+
+  const report = await page.evaluate(() => {
+    const perfGlobal = globalThis as typeof globalThis & {
+      __pwLongTasks?: LongTaskEntry[]
+      __pwEventTimings?: EventTimingEntry[]
+    }
+
+    return {
+      longTasks: (perfGlobal.__pwLongTasks || []).filter((entry) => entry.duration >= 50),
+      events: (perfGlobal.__pwEventTimings || []).filter((entry) => entry.interactionId !== 0),
+    }
+  })
+
+  console.log(report)
+}
+
+export { collectWebVitals, collectHeaviestRequests, measureInteractivity }
+
+```

package/dist/prompt.md

@@ -57,6 +57,7 @@ You can collaborate with the user - they can help with captchas, difficult eleme
 - **Wait for load**: use `state.page.waitForLoadState('domcontentloaded')` not `state.page.waitForEvent('load')` - waitForEvent times out if already loaded
 - **Minimize timeouts**: prefer proper waits (`waitForSelector`, `waitForPageLoad`) over `state.page.waitForTimeout()`. Short timeouts (1-2s) are acceptable for non-deterministic events like animations, tab opens, or async UI updates where no specific selector is available
 - **Snapshot before screenshot**: always use `snapshot()` first to understand page state (text-based, fast, cheap). Only use `screenshot` when you specifically need visual/spatial information. Never take a screenshot just to check if a page loaded or to read text content — snapshot gives you that instantly without burning image tokens
+- **Always use absolute file paths for Playwright artifact APIs**: for `page.screenshot({ path })`, `locator.screenshot({ path })`, `elementHandle.screenshot({ path })`, `page.pdf({ path })`, `download.saveAs(path)`, and `video.saveAs(path)`, always pass an absolute path. Relative paths are resolved by Playwright client internals, not the sandboxed `fs`, so they may use the relay server cwd instead of your session cwd.
 - **Snapshot replaces page.evaluate() for inspection**: do NOT write `page.evaluate()` calls to manually query class names, bounding boxes, child counts, or visibility flags. `snapshot()` already shows every interactive element with its text, role, and a ready-to-use locator. If you catch yourself writing `document.querySelector` or `getBoundingClientRect` inside evaluate — stop and use `snapshot()` instead. Reserve `page.evaluate()` for actions that modify page state (e.g., `localStorage.clear()`, scroll manipulation) or extract non-DOM data (e.g., `window.__CONFIG__`)
 
 ## interaction feedback loop
@@ -449,7 +450,7 @@ Instead, use simpler alternatives (single download via `a.click()`, store data i
 
 ```js
 const [download] = await Promise.all([state.page.waitForEvent('download'), state.page.click('button.download')])
-await download.saveAs(`/tmp/${download.suggestedFilename()}`)
+await download.saveAs(`/absolute/path/${download.suggestedFilename()}`)
 ```
 
 **iFrames** - two approaches depending on what you need:
@@ -602,6 +603,19 @@ const source = await getReactSource({ locator: state.page.locator('[data-testid=
 // => { fileName, lineNumber, columnNumber, componentName }
 ```
 
+**getReactComponentInfo** - get best-effort React component info for an element. Returns `null` for non-React elements and never throws just because an element was not rendered by React. Source locations are usually only available in React dev builds. Props are sanitized and truncated so functions, DOM nodes, circular refs, and huge objects do not flood the output.
+
+```js
+const info = await getReactComponentInfo({ locator: state.page.locator('[data-testid="submit-btn"]') })
+// => { componentName, source, hierarchy, props } | null
+```
+
+**inspectPinnedElement** - inspect a Playwriter pinned element and print the element `outerHTML` plus React component info when available. Used by the in-page toolbar and right-click copy flow.
+
+```js
+await inspectPinnedElement('https://example.com', 'globalThis.playwriterPinnedElem1')
+```
+
 **getStylesForLocator** - inspect CSS styles applied to an element, like browser DevTools "Styles" panel. Useful for debugging styling issues, finding where a CSS property is defined (file:line), and checking inherited styles. Returns selector, source location, and declarations for each matching rule. ALWAYS fetch `https://playwriter.dev/resources/styles-api.md` first with curl or webfetch tool.
 
 ```js
@@ -654,7 +668,7 @@ await screenshotWithAccessibilityLabels({ page: state.page })
 
 Labels are color-coded: yellow=links, orange=buttons, coral=inputs, pink=checkboxes, peach=sliders, salmon=menus, amber=tabs.
 
-**resizeImageForAgent** - shrink an image so it consumes fewer tokens when read back into context. The resized image is automatically included in the response (visible to the LLM). `await resizeImageForAgent({ input: './screenshot.png' })`. Also accepts `width`, `height`, `maxDimension`, `quality`, `format` (default: `'png'`), `output`. Alias: `resizeImage`.
+**resizeImageForAgent** - shrink an image so it consumes fewer tokens when read back into context. The resized image is automatically included in the response (visible to the LLM). `await resizeImageForAgent({ input: '/absolute/path/to/screenshot.png' })`. Also accepts `width`, `height`, `maxDimension`, `quality`, `format` (default: `'png'`), `output`. Alias: `resizeImage`.
 
 **recording.start / recording.stop** - record the page as a video at native FPS (30-60fps). Uses `chrome.tabCapture` so **recording survives page navigation**. Auto-overlays a ghost cursor that follows mouse actions. Requires user to have clicked the Playwriter extension icon on the tab. Auto-resizes viewport to 16:9 (override with `aspectRatio: null`). Auto-stops after 15 min (override with `maxDurationMs`).
 
@@ -663,7 +677,7 @@ For demos, use interaction methods (`locator.click()`, `page.mouse.move()`) inst
 ```js
 await recording.start({
   page: state.page,
-  outputPath: './recording.mp4',
+  outputPath: '/absolute/path/to/recording.mp4',
   frameRate: 30, // default
   audio: false, // default (tab audio)
   videoBitsPerSecond: 2500000,
@@ -681,11 +695,11 @@ state.recordingResult = await recording.stop({ page: state.page })
 // Other: recording.isRecording({ page }), recording.cancel({ page })
 ```
 
-**ghostCursor.show / ghostCursor.hide** - show/hide cursor overlay for screenshots and demos:
+**ghostCursor.show / ghostCursor.hide** - the ghost cursor overlay is always on: the extension injects it on every Playwriter-attached tab and it stays visible at the last spot Playwright clicked or moved. These methods only matter if you want to change the cursor style or temporarily hide it:
 
 ```js
-await ghostCursor.show({ page: state.page, style: 'minimal' }) // 'minimal', 'dot', 'screenstudio'
-await ghostCursor.hide({ page: state.page })
+await ghostCursor.show({ page: state.page, style: 'screenstudio' }) // 'minimal' (default), 'dot', 'screenstudio'
+await ghostCursor.hide({ page: state.page }) // hide until next show() or hard navigation
 ```
 
 **createDemoVideo** - speeds up idle sections (time between execute() calls) while keeping interactions at normal speed. Requires `ffmpeg`/`ffprobe`. Timestamps are tracked automatically during recording and returned by `recording.stop()`. **Timeout**: can take 60–120+ seconds, always pass `--timeout 120000` or higher.
@@ -717,7 +731,7 @@ await el.click()
 Always use `scale: 'css'` to avoid 2-4x larger images on high-DPI displays:
 
 ```js
-await state.page.screenshot({ path: 'shot.png', scale: 'css' })
+await state.page.screenshot({ path: '/absolute/path/to/shot.png', scale: 'css' })
 ```
 
 If you want to read back the image file into context, resize it first so it consumes fewer tokens:
@@ -896,7 +910,7 @@ await state.page.setViewportSize({ width: 1280, height: 720 })
 ### region screenshot (zoom equivalent)
 
 ```js
-await state.page.screenshot({ path: 'region.png', scale: 'css', clip: { x: 100, y: 200, width: 400, height: 300 } })
+await state.page.screenshot({ path: '/absolute/path/to/region.png', scale: 'css', clip: { x: 100, y: 200, width: 400, height: 300 } })
 ```
 
 Prefer locator-based actions over coordinates — locators are stable across scroll/resize, auto-wait for elements, and don't require screenshot round-trips that burn ~800 image tokens per cycle.

package/dist/react-source.d.ts

@@ -6,8 +6,52 @@ export interface ReactSourceLocation {
     columnNumber: number | null;
     componentName: string | null;
 }
+export type ReactSerializedProp = string | number | boolean | null | ReactSerializedProp[] | {
+    [key: string]: ReactSerializedProp;
+};
+export interface ReactComponentHierarchyItem {
+    componentName: string | null;
+    source: Omit<ReactSourceLocation, 'componentName'> | null;
+    props: ReactSerializedProp;
+}
+export interface ReactComponentInfo {
+    componentName: string | null;
+    source: Omit<ReactSourceLocation, 'componentName'> | null;
+    hierarchy: ReactComponentHierarchyItem[];
+    props: ReactSerializedProp;
+}
+type ReactInspectableValue = string | number | boolean | bigint | symbol | null | undefined | object | ((...args: never[]) => ReactInspectableValue);
+type BrowserElement = object;
+interface BippySourceFrame {
+    fileName?: string | null;
+    lineNumber?: number | null;
+    columnNumber?: number | null;
+    functionName?: string | null;
+}
+interface BippyFiber {
+    return?: BippyFiber | null;
+    type?: ReactInspectableValue;
+    memoizedProps?: ReactInspectableValue;
+}
+interface BippyRuntime {
+    getFiberFromHostInstance(el: BrowserElement): BippyFiber | null;
+    getSource(fiber: BippyFiber): Promise<BippySourceFrame | null>;
+    getOwnerStack(fiber: BippyFiber): Promise<BippySourceFrame[]>;
+    getDisplayName(type: ReactInspectableValue): string | null;
+    isCompositeFiber(fiber: BippyFiber): boolean;
+    normalizeFileName(fileName: string): string;
+    isSourceFile(fileName: string): boolean;
+}
+declare global {
+    var __bippy: BippyRuntime | undefined;
+}
 export declare function getReactSource({ locator, cdp: cdpSession, }: {
     locator: Locator | ElementHandle;
     cdp: ICDPSession;
 }): Promise<ReactSourceLocation | null>;
+export declare function getReactComponentInfo({ locator, cdp: cdpSession, }: {
+    locator: Locator | ElementHandle;
+    cdp: ICDPSession;
+}): Promise<ReactComponentInfo | null>;
+export {};
 //# sourceMappingURL=react-source.d.ts.map

package/dist/react-source.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"react-source.d.ts","sourceRoot":"","sources":["../src/react-source.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAQ,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AAC3E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAEnD,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;CAC7B;AAcD,wBAAsB,cAAc,CAAC,EACnC,OAAO,EACP,GAAG,EAAE,UAAU,GAChB,EAAE;IACD,OAAO,EAAE,OAAO,GAAG,aAAa,CAAA;IAChC,GAAG,EAAE,WAAW,CAAA;CACjB,GAAG,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC,CA6DtC"}
+{"version":3,"file":"react-source.d.ts","sourceRoot":"","sources":["../src/react-source.ts"],"names":[],"mappings":"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"}