react-native-parity-blur 0.1.0

package/lib/module/pipeline/units.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["sigmaPxFromDp","blurRadiusDp","displayScale","Number","isFinite","sigmaSnapshotFromPx","sigmaPx","downsample"],"sourceRoot":"../../../src","sources":["pipeline/units.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAIA;AACA;AACA;AACA;AACA,OAAO,SAASA,aAAaA,CAACC,YAAoB,EAAEC,YAAoB,EAAU;EAChF,IAAI,CAACC,MAAM,CAACC,QAAQ,CAACH,YAAY,CAAC,IAAIA,YAAY,IAAI,CAAC,EAAE,OAAO,CAAC;EACjE,IAAI,CAACE,MAAM,CAACC,QAAQ,CAACF,YAAY,CAAC,IAAIA,YAAY,IAAI,CAAC,EAAE,OAAO,CAAC;EACjE,OAAOD,YAAY,GAAGC,YAAY;AACpC;;AAEA;AACA;AACA;AACA;AACA,OAAO,SAASG,mBAAmBA,CAACC,OAAe,EAAEC,UAAsB,EAAU;EACnF,IAAI,CAACJ,MAAM,CAACC,QAAQ,CAACE,OAAO,CAAC,IAAIA,OAAO,IAAI,CAAC,EAAE,OAAO,CAAC;EACvD,OAAOA,OAAO,GAAGC,UAAU;AAC7B","ignoreList":[]}

package/lib/module/presets.js

@@ -0,0 +1,96 @@
+"use strict";
+
+/**
+ * Material-like presets (plan §11, plan §41 / Milestone 8).
+ *
+ * A preset is nothing more than a fixed, explicit
+ * `{ blurRadius, saturation, overlayColor }` prop bundle. There is no
+ * hidden or platform-specific behavior: applying `BlurPresets.dark` is
+ * exactly equivalent to spreading that plain object onto `<BlurView>`
+ * yourself, and the resulting three numbers/strings go through the same
+ * calibrated pipeline as any other explicit props (docs/PIPELINE_SPEC.md).
+ * Because blurRadius/saturation/overlayColor are calibrated to match
+ * cross-platform (docs/CALIBRATION_REPORT.md — worst measured ΔE76 0.90,
+ * SSIM ≥ 0.983), a given preset renders the same on iOS and Android.
+ *
+ * These are *approximations* of the visual weight of iOS system materials
+ * (UIBlurEffect styles), chosen by eye against reasonable blurRadius /
+ * saturation / overlayColor values — they are not derived from, measured
+ * against, or guaranteed to match `UIVisualEffectView` output, and Android
+ * has no equivalent native material to match at all. Treat the names as a
+ * starting point, not a parity claim (plan §43 — nested/material stacking
+ * is deterministic, not an Apple material emulation).
+ *
+ * Usage:
+ * ```tsx
+ * <BlurView {...BlurPresets.dark} style={styles.sheet}>
+ *   {children}
+ * </BlurView>
+ * ```
+ *
+ * Every field is a plain public prop, so you can still override any one of
+ * them by spreading the preset first and your own prop second:
+ * ```tsx
+ * <BlurView {...BlurPresets.dark} blurRadius={30} />
+ * ```
+ *
+ * Or, for the same effect without spreading, pass the `preset` prop
+ * directly to `<BlurView>` (`src/BlurView.tsx`) — it resolves to this same
+ * object client-side before any explicit blurRadius/saturation/overlayColor
+ * prop is applied on top of it. Both forms are pure JS convenience; neither
+ * adds a native prop.
+ */
+
+/** One named preset: an explicit bundle of public BlurView props. */
+
+/** Keys of {@link BlurPresets}. */
+
+/**
+ * Named material-like preset table. See the module doc comment above for
+ * semantics and the "not a parity claim" caveat.
+ */
+export const BlurPresets = {
+  /** Barely-there frosted glass: minimal blur, faint light tint. */
+  ultraThin: {
+    blurRadius: 10,
+    saturation: 1.3,
+    overlayColor: 'rgba(255,255,255,0.15)'
+  },
+  /** Light frosted glass, subtle. */
+  thin: {
+    blurRadius: 14,
+    saturation: 1.4,
+    overlayColor: 'rgba(255,255,255,0.25)'
+  },
+  /** Neutral, medium-weight — a reasonable default over photos/color. */
+  regular: {
+    blurRadius: 20,
+    saturation: 1.2,
+    overlayColor: 'rgba(128,128,128,0.16)'
+  },
+  /** Heavier blur, more opaque neutral-dark tint. */
+  thick: {
+    blurRadius: 28,
+    saturation: 1.3,
+    overlayColor: 'rgba(20,20,20,0.35)'
+  },
+  /** Near-opaque, low-saturation — for toolbar/nav-bar-like surfaces. */
+  chrome: {
+    blurRadius: 24,
+    saturation: 1.1,
+    overlayColor: 'rgba(230,230,230,0.55)'
+  },
+  /** Classic light material: strong blur, warm-white tint, boosted saturation. */
+  light: {
+    blurRadius: 20,
+    saturation: 1.8,
+    overlayColor: 'rgba(255,255,255,0.4)'
+  },
+  /** Classic dark material: strong blur, near-black tint, boosted saturation. */
+  dark: {
+    blurRadius: 20,
+    saturation: 1.5,
+    overlayColor: 'rgba(16,16,16,0.45)'
+  }
+};
+//# sourceMappingURL=presets.js.map

package/lib/module/presets.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["BlurPresets","ultraThin","blurRadius","saturation","overlayColor","thin","regular","thick","chrome","light","dark"],"sourceRoot":"../../src","sources":["presets.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAUA;;AAIA;AACA;AACA;AACA;AACA,OAAO,MAAMA,WAAyD,GAAG;EACvE;EACAC,SAAS,EAAE;IACTC,UAAU,EAAE,EAAE;IACdC,UAAU,EAAE,GAAG;IACfC,YAAY,EAAE;EAChB,CAAC;EACD;EACAC,IAAI,EAAE;IACJH,UAAU,EAAE,EAAE;IACdC,UAAU,EAAE,GAAG;IACfC,YAAY,EAAE;EAChB,CAAC;EACD;EACAE,OAAO,EAAE;IACPJ,UAAU,EAAE,EAAE;IACdC,UAAU,EAAE,GAAG;IACfC,YAAY,EAAE;EAChB,CAAC;EACD;EACAG,KAAK,EAAE;IACLL,UAAU,EAAE,EAAE;IACdC,UAAU,EAAE,GAAG;IACfC,YAAY,EAAE;EAChB,CAAC;EACD;EACAI,MAAM,EAAE;IACNN,UAAU,EAAE,EAAE;IACdC,UAAU,EAAE,GAAG;IACfC,YAAY,EAAE;EAChB,CAAC;EACD;EACAK,KAAK,EAAE;IACLP,UAAU,EAAE,EAAE;IACdC,UAAU,EAAE,GAAG;IACfC,YAAY,EAAE;EAChB,CAAC;EACD;EACAM,IAAI,EAAE;IACJR,UAAU,EAAE,EAAE;IACdC,UAAU,EAAE,GAAG;IACfC,YAAY,EAAE;EAChB;AACF,CAAC","ignoreList":[]}

package/lib/module/types.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=types.js.map

package/lib/module/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../src","sources":["types.ts"],"mappings":"","ignoreList":[]}

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/src/BlurView.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import type { BlurViewProps, BlurViewRef } from './types.js';
+/**
+ * Public backdrop blur component (plan §28/§29/§30).
+ *
+ * Renders the native ParityBlurView host view backed by a real blur on both
+ * platforms: Android API 31+ real-time `RenderEffect` Gaussian blur (older
+ * Android renders `fallbackColor` instead — real CPU blur is intentionally
+ * out of scope, plan §44), iOS `MPSImageGaussianBlur`. `refresh()` is fully
+ * wired to a native coalesced recapture (plan §29). See
+ * docs/PIPELINE_SPEC.md for the canonical pipeline both backends implement
+ * and docs/CALIBRATION_REPORT.md for measured cross-platform parity.
+ */
+export declare const BlurView: React.ForwardRefExoticComponent<BlurViewProps & React.RefAttributes<BlurViewRef>>;
+export default BlurView;
+//# sourceMappingURL=BlurView.d.ts.map

package/lib/typescript/src/BlurView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlurView.d.ts","sourceRoot":"","sources":["../../../src/BlurView.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAiB/B,OAAO,KAAK,EAAkB,aAAa,EAAE,WAAW,EAAE,MAAM,YAAS,CAAC;AAsD1E;;;;;;;;;;GAUG;AACH,eAAO,MAAM,QAAQ,mFA8GpB,CAAC;AAEF,eAAe,QAAQ,CAAC"}

package/lib/typescript/src/ParityBlurViewNativeComponent.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Fabric codegen spec for the ParityBlurView native host view.
+ *
+ * Every public prop from plan §28 is plumbed through to native, and the
+ * `refresh()` Fabric command is wired end-to-end to a real coalesced
+ * recapture. Both native backends (Android Kotlin, iOS Swift) implement the
+ * real capture/blur/saturate/overlay pipeline defined in
+ * docs/PIPELINE_SPEC.md — this file only declares the codegen shape, not
+ * the behavior.
+ *
+ * Deviation from plan §28 (documented in the Milestone 1 report): the public
+ * `downsample` prop is `'auto' | 1 | 2 | 4 | 8` (see src/types.ts). Fabric
+ * codegen's TypeScript parser rejects a union that mixes string and numeric
+ * literals for one prop ("Mixed types are not supported"), and a plain
+ * string enum with numeric-looking values ('1', '2', ...) is also unsafe
+ * because the iOS/C++ generator turns each enum option into a bare
+ * identifier (`ParityBlurViewDownsample::1` is not valid C++). Instead this
+ * native prop is a plain Int32 where `0` is a sentinel for `'auto'` and
+ * `1 | 2 | 4 | 8` pass through unchanged. `src/BlurView.tsx` performs the
+ * 'auto' <-> 0 translation; native code treats 0 as "auto".
+ *
+ * Note: this file deliberately imports everything from the 'react-native'
+ * package root rather than deep 'react-native/Libraries/...' paths. This
+ * project's tsconfig opts into the `react-native-strict-api` custom
+ * condition, and react-native's package.json `exports` map explicitly
+ * blocks deep `Libraries/*` subpath imports under that condition -- so
+ * `codegenNativeCommands`, `codegenNativeComponent`, and the CodegenTypes
+ * (Double/Int32/WithDefault) must come from the root barrel, which
+ * re-exports all three for exactly this reason.
+ *
+ * Also note: do NOT re-export `CodegenTypes.WithDefault`/`Double`/`Int32` as
+ * local generic type aliases (an earlier draft of this file did, to shorten
+ * the qualified names). @react-native/codegen's alias resolution does plain
+ * textual substitution with no generic instantiation, so a chain like
+ * `NativeBlurMode -> WithDefault<'static'|'live','static'> -> (local
+ * `WithDefault<Type,Value>` alias) -> CodegenTypes.WithDefault<Type,Value>`
+ * loses the real type arguments and fails with "The default value in
+ * WithDefault must be string, number, boolean or null." Referencing
+ * `CodegenTypes.WithDefault<...>` directly (qualified) avoids the extra
+ * alias hop and keeps the real arguments intact.
+ */
+import { type CodegenTypes, type ColorValue, type HostComponent, type ViewProps } from 'react-native';
+import type * as React from 'react';
+type NativeBlurMode = CodegenTypes.WithDefault<'static' | 'live', 'static'>;
+type NativeBlurQuality = CodegenTypes.WithDefault<'high' | 'balanced' | 'performance', 'balanced'>;
+export interface NativeProps extends ViewProps {
+    blurRadius?: CodegenTypes.WithDefault<CodegenTypes.Double, 0>;
+    mode?: NativeBlurMode;
+    overlayColor?: ColorValue;
+    saturation?: CodegenTypes.WithDefault<CodegenTypes.Double, 1>;
+    quality?: NativeBlurQuality;
+    downsample?: CodegenTypes.WithDefault<CodegenTypes.Int32, 0>;
+    maxFps?: CodegenTypes.WithDefault<CodegenTypes.Int32, 30>;
+    fallbackColor?: ColorValue;
+}
+type ComponentType = HostComponent<NativeProps>;
+interface NativeCommands {
+    refresh: (viewRef: React.ComponentRef<ComponentType>) => void;
+}
+export declare const Commands: NativeCommands;
+declare const _default: ComponentType;
+export default _default;
+//# sourceMappingURL=ParityBlurViewNativeComponent.d.ts.map

package/lib/typescript/src/ParityBlurViewNativeComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParityBlurViewNativeComponent.d.ts","sourceRoot":"","sources":["../../../src/ParityBlurViewNativeComponent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,OAAO,EAGL,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,aAAa,EAClB,KAAK,SAAS,EACf,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAEpC,KAAK,cAAc,GAAG,YAAY,CAAC,WAAW,CAAC,QAAQ,GAAG,MAAM,EAAE,QAAQ,CAAC,CAAC;AAC5E,KAAK,iBAAiB,GAAG,YAAY,CAAC,WAAW,CAC/C,MAAM,GAAG,UAAU,GAAG,aAAa,EACnC,UAAU,CACX,CAAC;AAEF,MAAM,WAAW,WAAY,SAAQ,SAAS;IAC5C,UAAU,CAAC,EAAE,YAAY,CAAC,WAAW,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IAC9D,IAAI,CAAC,EAAE,cAAc,CAAC;IACtB,YAAY,CAAC,EAAE,UAAU,CAAC;IAC1B,UAAU,CAAC,EAAE,YAAY,CAAC,WAAW,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IAC9D,OAAO,CAAC,EAAE,iBAAiB,CAAC;IAE5B,UAAU,CAAC,EAAE,YAAY,CAAC,WAAW,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IAC7D,MAAM,CAAC,EAAE,YAAY,CAAC,WAAW,CAAC,YAAY,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IAC1D,aAAa,CAAC,EAAE,UAAU,CAAC;CAC5B;AAED,KAAK,aAAa,GAAG,aAAa,CAAC,WAAW,CAAC,CAAC;AAEhD,UAAU,cAAc;IACtB,OAAO,EAAE,CAAC,OAAO,EAAE,KAAK,CAAC,YAAY,CAAC,aAAa,CAAC,KAAK,IAAI,CAAC;CAC/D;AAED,eAAO,MAAM,QAAQ,EAAE,cAErB,CAAC;wBAIE,aAAa;AAFlB,wBAEmB"}

package/lib/typescript/src/defaults.d.ts

@@ -0,0 +1,12 @@
+import type { BlurDownsample, BlurMode, BlurQuality } from './types.js';
+export declare const DEFAULT_BLUR_RADIUS = 0;
+export declare const DEFAULT_MODE: BlurMode;
+export declare const DEFAULT_OVERLAY_COLOR = "transparent";
+export declare const DEFAULT_SATURATION = 1;
+export declare const DEFAULT_QUALITY: BlurQuality;
+export declare const DEFAULT_DOWNSAMPLE: BlurDownsample;
+export declare const DEFAULT_MAX_FPS = 30;
+export declare const MIN_MAX_FPS = 1;
+export declare const MAX_MAX_FPS = 120;
+export declare const ALLOWED_DOWNSAMPLE_VALUES: ReadonlyArray<BlurDownsample>;
+//# sourceMappingURL=defaults.d.ts.map

package/lib/typescript/src/defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../../src/defaults.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,YAAS,CAAC;AAErE,eAAO,MAAM,mBAAmB,IAAI,CAAC;AACrC,eAAO,MAAM,YAAY,EAAE,QAAmB,CAAC;AAC/C,eAAO,MAAM,qBAAqB,gBAAgB,CAAC;AACnD,eAAO,MAAM,kBAAkB,IAAI,CAAC;AACpC,eAAO,MAAM,eAAe,EAAE,WAAwB,CAAC;AACvD,eAAO,MAAM,kBAAkB,EAAE,cAAuB,CAAC;AACzD,eAAO,MAAM,eAAe,KAAK,CAAC;AAElC,eAAO,MAAM,WAAW,IAAI,CAAC;AAC7B,eAAO,MAAM,WAAW,MAAM,CAAC;AAE/B,eAAO,MAAM,yBAAyB,EAAE,aAAa,CAAC,cAAc,CAMnE,CAAC"}

package/lib/typescript/src/index.d.ts

@@ -0,0 +1,5 @@
+export { BlurView, default } from './BlurView.js';
+export type { BlurDownsample, BlurMode, BlurQuality, BlurViewProps, BlurViewRef, } from './types.js';
+export { BlurPresets } from './presets.js';
+export type { BlurPreset, BlurPresetName } from './presets.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,eAAY,CAAC;AAC/C,YAAY,EACV,cAAc,EACd,QAAQ,EACR,WAAW,EACX,aAAa,EACb,WAAW,GACZ,MAAM,YAAS,CAAC;AACjB,OAAO,EAAE,WAAW,EAAE,MAAM,cAAW,CAAC;AACxC,YAAY,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,cAAW,CAAC"}

package/lib/typescript/src/pipeline/androidCalibration.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Android RenderEffect calibration (plan §5.2).
+ *
+ * INTERNAL MODULE. The single place the HWUI sigma<->radius relation lives on
+ * the TypeScript side; the Kotlin `AndroidBlurCalibration` must mirror it
+ * exactly. Verified on a Pixel 6a (API 36) in M0: radiusForSigma(10) exactly
+ * equals 16.454486... (matching the on-device measurement 16.45449).
+ *
+ * Relation (HWUI):  sigma = SLOPE * radiusPlatform + INTERCEPT
+ * Inverse:          radiusPlatform = (sigma - INTERCEPT) / SLOPE
+ *
+ * When sigmaSnapshot <= INTERCEPT (0.5) the inverse is non-positive, so we
+ * clamp to a no-blur passthrough rather than feeding a bogus radius to
+ * RenderEffect.createBlurEffect (plan §5.2 "no-op blur" for very small sigma).
+ */
+export interface AndroidBlurParam {
+    /** True when the requested blur collapses to a no-op passthrough. */
+    noBlur: boolean;
+    /**
+     * Platform radius to pass to RenderEffect.createBlurEffect. 0 when noBlur.
+     * Always >= 0.
+     */
+    radiusPlatform: number;
+}
+/**
+ * Forward relation, exposed for tests/verification: the sigma that HWUI
+ * produces for a given platform radius.
+ */
+export declare function sigmaForRadius(radiusPlatform: number): number;
+/**
+ * Inverse relation: the platform radius required to achieve a target
+ * snapshot-domain sigma. Below the intercept this returns a no-blur result.
+ * Monotonically non-decreasing in sigmaSnapshot.
+ */
+export declare function radiusForSigma(sigmaSnapshot: number): AndroidBlurParam;
+/**
+ * iOS MPSImageGaussianBlur takes the snapshot-domain sigma directly (plan §5.3).
+ * Provided here for symmetry so both platform mappings live in the reference.
+ * Sigma at or below 0 means no blur.
+ */
+export declare function iosSigmaForSigma(sigmaSnapshot: number): number;
+//# sourceMappingURL=androidCalibration.d.ts.map

package/lib/typescript/src/pipeline/androidCalibration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"androidCalibration.d.ts","sourceRoot":"","sources":["../../../../src/pipeline/androidCalibration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAQH,MAAM,WAAW,gBAAgB;IAC/B,qEAAqE;IACrE,MAAM,EAAE,OAAO,CAAC;IAChB;;;OAGG;IACH,cAAc,EAAE,MAAM,CAAC;CACxB;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,CAE7D;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,aAAa,EAAE,MAAM,GAAG,gBAAgB,CAQtE;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAG9D"}

package/lib/typescript/src/pipeline/captureRect.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Capture-rect math (plan §7, §12).
+ *
+ * INTERNAL MODULE. All rectangles here are in TARGET-LOCAL DEVICE PIXELS unless
+ * a field/return is explicitly documented as snapshot pixels.
+ *
+ * Pipeline of this module:
+ *   1. supportMarginPx  — Gaussian support margin = ceil(K * sigmaPx)
+ *   2. expandCaptureRect — expand visible rect by margin, clamp to target bounds
+ *   3. snapshotRectFor   — map the clamped device-px rect into integer snapshot
+ *                          pixels (floor origin, ceil far edge = conservative
+ *                          cover)
+ *   4. cropRectFor       — the sub-region of the snapshot that maps back to the
+ *                          visible rect (fractional, snapshot px)
+ *   5. cropRectToViewPx  — inverse mapping used to prove round-tripping
+ *
+ * Rounding rule (LOCKED): in the snapshot domain the origin FLOORS and the far
+ * edge CEILS, so `size = ceil(farEdge/D) - floor(origin/D)`. This is the
+ * conservative reading of "floor for origin, ceil for size": it guarantees
+ * every device pixel of the clamped capture rect is covered by the snapshot
+ * rect, at the cost of at most one extra snapshot pixel per side. A naive
+ * `floor(origin), ceil(width)` would fail to cover the far edge and is NOT used.
+ */
+import type { Downsample, Rect } from './types.js';
+/** Gaussian support margin in device px (plan §7): ceil(K * sigmaPx). */
+export declare function supportMarginPx(sigmaPx: number, k?: number): number;
+/** Intersection of two rects; empty (zero-size) rect if they do not overlap. */
+export declare function intersectRect(a: Rect, b: Rect): Rect;
+/**
+ * Expand the visible blur rect by the Gaussian support margin and clamp to the
+ * target bounds. Returns a float device-px rect (plan §7). The margin only
+ * covers content that exists inside the target; CLAMP handles the outer edge
+ * where the margin was cut off (plan §8).
+ */
+export declare function expandCaptureRect(visibleRect: Rect, targetBounds: Rect, sigmaPx: number, k?: number): Rect;
+/** Area of a rect in device px^2 (helper for downsample selection). */
+export declare function rectArea(r: Rect): number;
+/**
+ * Map a clamped device-px capture rect into integer snapshot pixels for
+ * downsample factor D. Floor the origin, ceil the far edge (conservative
+ * cover). The returned rect is in SNAPSHOT PIXELS (indices), so its device-px
+ * footprint is `snapshotRect * D`.
+ */
+export declare function snapshotRectFor(captureRectPx: Rect, downsample: Downsample): Rect;
+/**
+ * The fractional crop rect, in SNAPSHOT PIXELS, that selects the visible region
+ * out of the (larger) snapshot rect after blur. Because the snapshot origin was
+ * floored, the crop origin carries a fractional remainder in [0, 1) snapshot px
+ * which the upsample step resolves with bilinear sampling (plan §12).
+ *
+ *   cropX = visibleRect.x / D  -  snapshotRect.x
+ *   cropW = visibleRect.width / D
+ */
+export declare function cropRectFor(visibleRect: Rect, snapshotRect: Rect, downsample: Downsample): Rect;
+/**
+ * Inverse of {@link cropRectFor}: map a snapshot-px crop rect back to
+ * target-local device px. Used to verify round-tripping (should recover the
+ * original visible rect within half a snapshot pixel = D/2 device px).
+ */
+export declare function cropRectToViewPx(cropRect: Rect, snapshotRect: Rect, downsample: Downsample): Rect;
+export interface CapturePlan {
+    /** Input visible blur rect (target-local device px). */
+    visibleRect: Rect;
+    /** Gaussian support margin (device px). */
+    marginPx: number;
+    /** Expanded + clamped capture rect (target-local device px, float). */
+    captureRectPx: Rect;
+    /** Capture area used for downsample selection (device px^2). */
+    captureAreaPx: number;
+    /** Selected downsample factor. */
+    downsample: Downsample;
+    /** Integer snapshot-pixel rect to allocate/blur. */
+    snapshotRect: Rect;
+    /** Fractional snapshot-px crop rect selecting the visible region. */
+    cropRect: Rect;
+}
+/**
+ * Assemble the full capture plan for a given visible rect, target bounds,
+ * sigmaPx and pre-resolved downsample factor. Downsample resolution lives in
+ * downsample.ts and takes `captureAreaPx` from this same computation, so the
+ * caller sequences: expand -> area -> resolveDownsample -> buildCapturePlan.
+ */
+export declare function buildCapturePlan(visibleRect: Rect, targetBounds: Rect, sigmaPx: number, downsample: Downsample, k?: number): CapturePlan;
+//# sourceMappingURL=captureRect.d.ts.map

package/lib/typescript/src/pipeline/captureRect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"captureRect.d.ts","sourceRoot":"","sources":["../../../../src/pipeline/captureRect.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,YAAS,CAAC;AAEhD,yEAAyE;AACzE,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC,GAAE,MAA0B,GAAG,MAAM,CAGtF;AAED,gFAAgF;AAChF,wBAAgB,aAAa,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,IAAI,CAWpD;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,IAAI,EACjB,YAAY,EAAE,IAAI,EAClB,OAAO,EAAE,MAAM,EACf,CAAC,GAAE,MAA0B,GAC5B,IAAI,CASN;AAED,uEAAuE;AACvE,wBAAgB,QAAQ,CAAC,CAAC,EAAE,IAAI,GAAG,MAAM,CAExC;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,aAAa,EAAE,IAAI,EAAE,UAAU,EAAE,UAAU,GAAG,IAAI,CAMjF;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CACzB,WAAW,EAAE,IAAI,EACjB,YAAY,EAAE,IAAI,EAClB,UAAU,EAAE,UAAU,GACrB,IAAI,CAON;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,IAAI,EACd,YAAY,EAAE,IAAI,EAClB,UAAU,EAAE,UAAU,GACrB,IAAI,CAON;AAED,MAAM,WAAW,WAAW;IAC1B,wDAAwD;IACxD,WAAW,EAAE,IAAI,CAAC;IAClB,2CAA2C;IAC3C,QAAQ,EAAE,MAAM,CAAC;IACjB,uEAAuE;IACvE,aAAa,EAAE,IAAI,CAAC;IACpB,gEAAgE;IAChE,aAAa,EAAE,MAAM,CAAC;IACtB,kCAAkC;IAClC,UAAU,EAAE,UAAU,CAAC;IACvB,oDAAoD;IACpD,YAAY,EAAE,IAAI,CAAC;IACnB,qEAAqE;IACrE,QAAQ,EAAE,IAAI,CAAC;CAChB;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,IAAI,EACjB,YAAY,EAAE,IAAI,EAClB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,UAAU,EACtB,CAAC,GAAE,MAA0B,GAC5B,WAAW,CAcb"}

package/lib/typescript/src/pipeline/color.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Color parsing for the overlay prop.
+ *
+ * INTERNAL MODULE. Parses the subset of CSS color syntaxes React Native
+ * accepts for a string color prop into straight-alpha RGBA in [0,1]:
+ *   - 'transparent'
+ *   - #rgb / #rgba / #rrggbb / #rrggbbaa
+ *   - rgb(r,g,b) / rgba(r,g,b,a)   (r,g,b integer 0-255, a float 0-1)
+ *
+ * Any unrecognised value returns a fully-transparent color (no overlay), which
+ * is the documented default (plan §11). The native backends parse the same
+ * prop with their platform color parsers; this reference fixes the expected
+ * numeric result for parity fixtures.
+ */
+import type { RGBA } from './types.js';
+export declare const TRANSPARENT: RGBA;
+/** Parse a color string into straight-alpha RGBA. Unrecognised -> transparent. */
+export declare function parseColor(input: string | null | undefined): RGBA;
+//# sourceMappingURL=color.d.ts.map

package/lib/typescript/src/pipeline/color.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"color.d.ts","sourceRoot":"","sources":["../../../../src/pipeline/color.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAS,CAAC;AAEpC,eAAO,MAAM,WAAW,EAAE,IAAiC,CAAC;AAU5D,kFAAkF;AAClF,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,CAqCjE"}

package/lib/typescript/src/pipeline/constants.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Locked calibration constants for the canonical pipeline.
+ *
+ * INTERNAL MODULE. These are the single source of truth for the reference
+ * implementation. Native backends must mirror these exact values. Per the
+ * plan (§5.2, §38) constants remain provisional until the parity milestone,
+ * but M0 device verification already confirmed the HWUI relation on API 36.
+ */
+/**
+ * HWUI RenderEffect Gaussian relation, verified exact on a Pixel 6a (API 36)
+ * in M0: `sigma = HWUI_SIGMA_SLOPE * radiusPlatform + HWUI_SIGMA_INTERCEPT`.
+ * Isolated here so a future version-aware calibration can override it in one
+ * place (plan §5.2). Do NOT inline these anywhere else.
+ */
+export declare const HWUI_SIGMA_SLOPE = 0.57735;
+export declare const HWUI_SIGMA_INTERCEPT = 0.5;
+/**
+ * Below this snapshot-domain sigma the Android RenderEffect relation inverts
+ * to a non-positive radius, so we emit a no-blur passthrough instead. Equal to
+ * HWUI_SIGMA_INTERCEPT by construction (radius 0 <=> sigma 0.5).
+ */
+export declare const ANDROID_MIN_BLUR_SIGMA = 0.5;
+/** Gaussian support multiplier for capture expansion (plan §7). */
+export declare const CAPTURE_SUPPORT_K = 3;
+/**
+ * Auto-downsample: target lower bound on snapshot-domain sigma. Keeping
+ * sigmaSnapshot at or above this prevents over-downsampling that would make
+ * the kernel degenerate (plan §12). 1 snapshot px.
+ */
+export declare const MIN_SIGMA_SNAPSHOT = 1;
+/**
+ * Auto-downsample: captures with area (device px^2) below this are considered
+ * "small" and are never downsampled beyond 2x — aggressive reduction of a tiny
+ * region buys no meaningful performance while degrading quality.
+ * 256 * 256 device px.
+ */
+export declare const SMALL_CAPTURE_AREA_PX: number;
+/**
+ * Auto-downsample: per-quality ceiling on the downsample factor (plan §13).
+ *   high        -> prefer 1x or 2x
+ *   balanced    -> prefer 2x or 4x
+ *   performance -> prefer 4x or 8x
+ */
+export declare const QUALITY_MAX_DOWNSAMPLE: Record<'high' | 'balanced' | 'performance', 1 | 2 | 4 | 8>;
+/**
+ * Rec. 709 luminance coefficients (plan §10). Sum to 1.0. Used for the
+ * saturation matrix on both platforms.
+ */
+export declare const LUMA_R = 0.2126;
+export declare const LUMA_G = 0.7152;
+export declare const LUMA_B = 0.0722;
+//# sourceMappingURL=constants.d.ts.map

package/lib/typescript/src/pipeline/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/pipeline/constants.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,UAAU,CAAC;AACxC,eAAO,MAAM,oBAAoB,MAAM,CAAC;AAExC;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,MAAuB,CAAC;AAE3D,mEAAmE;AACnE,eAAO,MAAM,iBAAiB,IAAI,CAAC;AAEnC;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,IAAM,CAAC;AAEtC;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,QAAY,CAAC;AAE/C;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,EAAE,MAAM,CACzC,MAAM,GAAG,UAAU,GAAG,aAAa,EACnC,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAKd,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,MAAM,SAAS,CAAC;AAC7B,eAAO,MAAM,MAAM,SAAS,CAAC;AAC7B,eAAO,MAAM,MAAM,SAAS,CAAC"}

package/lib/typescript/src/pipeline/downsample.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Auto downsample selection (plan §12, §13).
+ *
+ * INTERNAL MODULE. Deterministic function of (sigmaPx, captureAreaPx, quality)
+ * -> D in {1,2,4,8}. Both backends must select identically for identical input.
+ *
+ * The chosen factor is the largest allowed value that satisfies ALL of three
+ * independent ceilings, then snapped down to a real factor in {1,2,4,8}:
+ *
+ *   1. quality ceiling   — QUALITY_MAX_DOWNSAMPLE[quality]
+ *   2. sigma floor        — keep sigmaSnapshot = sigmaPx / D >= MIN_SIGMA_SNAPSHOT,
+ *                            i.e. D <= floor(sigmaPx / MIN_SIGMA_SNAPSHOT)
+ *   3. area ceiling       — tiny captures (< SMALL_CAPTURE_AREA_PX) never exceed 2x
+ *
+ * See docs/PIPELINE_SPEC.md for the locked decision table.
+ */
+import type { BlurDownsample, BlurQuality, Downsample } from './types.js';
+/**
+ * Resolve the auto-selected downsample factor.
+ *
+ * @param sigmaPx      device-pixel sigma (blurRadius * displayScale)
+ * @param captureAreaPx expanded capture area in device px^2
+ * @param quality      quality tier
+ */
+export declare function autoDownsample(sigmaPx: number, captureAreaPx: number, quality: BlurQuality): Downsample;
+/**
+ * Resolve a public `downsample` prop to a concrete factor. An explicit numeric
+ * value is honoured verbatim; 'auto' delegates to {@link autoDownsample}.
+ */
+export declare function resolveDownsample(prop: BlurDownsample, sigmaPx: number, captureAreaPx: number, quality: BlurQuality): Downsample;
+//# sourceMappingURL=downsample.d.ts.map

package/lib/typescript/src/pipeline/downsample.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"downsample.d.ts","sourceRoot":"","sources":["../../../../src/pipeline/downsample.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAOH,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,YAAS,CAAC;AAWvE;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,WAAW,GACnB,UAAU,CAeZ;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,cAAc,EACpB,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,WAAW,GACnB,UAAU,CAGZ"}

package/lib/typescript/src/pipeline/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Canonical pipeline reference implementation — INTERNAL barrel.
+ *
+ * This module is the executable form of docs/PIPELINE_SPEC.md: pure TypeScript,
+ * no react-native imports, no side effects. Native backends (Kotlin / Swift)
+ * must reproduce these exact rules.
+ *
+ * IMPORTANT: this barrel is intentionally NOT re-exported from src/index.ts.
+ * It is a spec/testing artifact, not part of the package's public API.
+ */
+export * from './types.js';
+export * from './constants.js';
+export * from './units.js';
+export * from './androidCalibration.js';
+export * from './downsample.js';
+export * from './captureRect.js';
+export * from './saturation.js';
+export * from './color.js';
+export * from './overlay.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/pipeline/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/pipeline/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,cAAc,YAAS,CAAC;AACxB,cAAc,gBAAa,CAAC;AAC5B,cAAc,YAAS,CAAC;AACxB,cAAc,yBAAsB,CAAC;AACrC,cAAc,iBAAc,CAAC;AAC7B,cAAc,kBAAe,CAAC;AAC9B,cAAc,iBAAc,CAAC;AAC7B,cAAc,YAAS,CAAC;AACxB,cAAc,cAAW,CAAC"}

package/lib/typescript/src/pipeline/overlay.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Overlay source-over compositing (plan §11).
+ *
+ * INTERNAL MODULE. The overlay color (straight alpha, parsed from the prop) is
+ * the SOURCE; the saturated blur result is the DESTINATION. Applied AFTER
+ * saturation, BEFORE final clipping (plan §6 step 10). This is the only tint in
+ * the pipeline — no hidden platform tint is permitted.
+ *
+ * Straight-alpha (non-premultiplied) source-over, per channel:
+ *
+ *   outA = srcA + dstA * (1 - srcA)
+ *   outC = (srcC*srcA + dstC*dstA*(1 - srcA)) / outA    (outA > 0)
+ *          0                                             (outA = 0)
+ *
+ * In v1 the capture surface is an opaque backdrop, so dstA = 1 and this reduces
+ * to the familiar linear blend  outC = srcC*srcA + dstC*(1 - srcA), outA = 1.
+ * The general form is implemented so the reference stays correct if a future
+ * version captures translucent backdrops.
+ */
+import type { RGBA } from './types.js';
+/**
+ * Source-over composite of a straight-alpha source over a straight-alpha
+ * destination. Returns straight-alpha RGBA.
+ */
+export declare function sourceOver(src: RGBA, dst: RGBA): RGBA;
+/**
+ * Convenience: composite an overlay color over an opaque (alpha=1) blurred
+ * pixel — the v1 case. Equivalent to sourceOver(overlay, {..dst, a:1}).
+ */
+export declare function overlayOnOpaque(overlay: RGBA, dst: RGBA): RGBA;
+//# sourceMappingURL=overlay.d.ts.map

package/lib/typescript/src/pipeline/overlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlay.d.ts","sourceRoot":"","sources":["../../../../src/pipeline/overlay.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAS,CAAC;AAEpC;;;GAGG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,GAAG,IAAI,CAWrD;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,GAAG,IAAI,CAE9D"}

package/lib/typescript/src/pipeline/saturation.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Saturation color matrix (plan §10).
+ *
+ * INTERNAL MODULE. One canonical 4x5 color matrix (Android ColorMatrix layout:
+ * 4 output rows R,G,B,A; 5 columns R,G,B,A,offset) using Rec.709 luminance
+ * coefficients. Applied AFTER blur, BEFORE overlay (plan §6 step 9).
+ *
+ * For saturation s and luma coefficients (lr,lg,lb) with t = 1 - s:
+ *
+ *   R' = (t*lr + s)*R +  t*lg*G     +  t*lb*B
+ *   G' =  t*lr*R     + (t*lg + s)*G +  t*lb*B
+ *   B' =  t*lr*R     +  t*lg*G      + (t*lb + s)*B
+ *   A' = A
+ *
+ *   s = 1 -> identity;  s = 0 -> luminance grayscale;  s > 1 -> more saturated.
+ *
+ * The alpha row is untouched and there is no offset column (all offsets 0).
+ * The matrix operates on the same channel representation the backend blurs in
+ * (gamma-space, straight color for the opaque v1 backdrop). It does NOT itself
+ * premultiply — see docs/PIPELINE_SPEC.md §Color.
+ */
+/**
+ * Row-major 4x5 saturation matrix (20 numbers), matching Android's
+ * ColorMatrix and directly transcribable to a Metal 4x4 + bias.
+ */
+export declare function saturationMatrix(s: number, lr?: number, lg?: number, lb?: number): number[];
+/**
+ * Apply a 4x5 saturation matrix to a straight-alpha RGBA tuple (channels in
+ * [0,1]). Returned RGB is clamped to [0,1]; alpha is passed through untouched.
+ * Reference for backend parity tests.
+ */
+export declare function applySaturation(matrix: number[], r: number, g: number, b: number, a: number): {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+};
+//# sourceMappingURL=saturation.d.ts.map

package/lib/typescript/src/pipeline/saturation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"saturation.d.ts","sourceRoot":"","sources":["../../../../src/pipeline/saturation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAIH;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,CAAC,EAAE,MAAM,EACT,EAAE,GAAE,MAAe,EACnB,EAAE,GAAE,MAAe,EACnB,EAAE,GAAE,MAAe,GAClB,MAAM,EAAE,CAQV;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,MAAM,EAAE,EAChB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACR;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAUhD"}

package/lib/typescript/src/pipeline/types.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Shared value types for the canonical pipeline reference implementation.
+ *
+ * INTERNAL MODULE. Nothing here is re-exported from src/index.ts. These types
+ * describe the language-neutral contract that both native backends implement;
+ * they are the executable form of docs/PIPELINE_SPEC.md.
+ */
+import type { BlurDownsample, BlurQuality } from '../types.js';
+/** Integer downsample factor actually used by the pipeline (never 'auto'). */
+export type Downsample = 1 | 2 | 4 | 8;
+/** The four concrete downsample factors, largest first (selection order). */
+export declare const DOWNSAMPLE_FACTORS: readonly Downsample[];
+/**
+ * Axis-aligned rectangle. Units are documented per-field by the producing
+ * function (device px in target-local space, or snapshot px). Origin is the
+ * top-left corner; width/height grow right/down.
+ */
+export interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** Straight-alpha RGBA colour, all channels normalised to [0, 1]. */
+export interface RGBA {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+export type { BlurDownsample, BlurQuality };
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/src/pipeline/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/pipeline/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,aAAU,CAAC;AAE5D,8EAA8E;AAC9E,MAAM,MAAM,UAAU,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAEvC,6EAA6E;AAC7E,eAAO,MAAM,kBAAkB,EAAE,SAAS,UAAU,EAAiB,CAAC;AAEtE;;;;GAIG;AACH,MAAM,WAAW,IAAI;IACnB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,qEAAqE;AACrE,MAAM,WAAW,IAAI;IACnB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,YAAY,EAAE,cAAc,EAAE,WAAW,EAAE,CAAC"}