@symbiote-native/angular 0.8.0 → 2.0.0

package/build/angular/elements.js

@@ -0,0 +1,1444 @@
+// One `@Directive` per intrinsic tag, so an app can hand-write `<view>` / `<text>` /
+// `<text-input>` in an ordinary Angular template and have ngtsc check it.
+//
+// WHY A DIRECTIVE AND NOT A SCHEMA. `CUSTOM_ELEMENTS_SCHEMA` admits an unknown element only when
+// the name is a valid CUSTOM ELEMENT name, and the HTML spec requires a HYPHEN — so half our tag
+// alphabet (`view`, `text`, `image`, `switch`, `modal`, `pressable`) is NG8001 under it.
+// `NO_ERRORS_SCHEMA` compiles them at the cost of every element and property check in the app.
+// A matching directive makes the element known with NO schema, and gives strictly MORE than either
+// schema ever could: both schemas return `true` for every property on a tag they admit
+// (`dom_element_schema_registry.ts:407`, "we don't know which properties a custom element will
+// get"), while a declared input has a TYPE. Measured in `bare-intrinsic-tag-aot.test.ts`.
+//
+// WHY EVERY BOUND PROP MUST BE DECLARED HERE. Matching a directive turns every binding on the tag
+// into an input lookup, so a prop this file does not declare is `Can't bind to 'x'` — the cost of
+// the route, and the reason the surface below is exhaustive rather than convenient.
+//
+// WHY THE PROPS ARE FIELDS AND NOT A DERIVED NAME LIST. `@Directive({ inputs: [...SHARED] })`
+// compiles fine against a shared const array (measured; `@Directive.inputs` is a mutable-array
+// type, so a `readonly`/`as const` array must be spread), and it would have made this file
+// nineteen one-liners. It also makes every such input UNTYPED: ngtsc reads an input's type from a
+// real class-member declaration node, and a merged `interface X extends IProps {}` — which does
+// put the property on the class's TYPE — leaves `<view [testID]="42">` compiling clean. Since the
+// type check is the whole reason to prefer this route over `NO_ERRORS_SCHEMA`, the names are
+// fields. What is derived is each field's TYPE, indexed off the shared prop interface, so a type
+// that changes upstream cannot drift here.
+//
+// EVENTS ARE NOT DECLARED. `(press)` / `(layout)` on a tag a directive matches still compiles and
+// still reaches `Renderer2.listen` -> the engine; an `@Output` would CONSUME the binding the same
+// way an `@Input` consumes a prop. Measured both halves — see `elements.test.ts`. The cost is that
+// `$event` types as the DOM `Event` there, since ngtsc falls back to the DOM schema for an event no
+// directive claims; the typed spelling of the same handler is the flat-bag `@Input` beside it
+// (`[onPressMove]="fn"`, where `fn` keeps its `ISymbioteEvent` parameter).
+//
+// `valueChange` is the ONE exception, and it is forced rather than chosen: see ValueChangeElement.
+import { ChangeDetectorRef, Directive, ElementRef, EventEmitter, Input, Output, Renderer2, forwardRef, inject, } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { VALUE_CHANGE_EVENT } from './renderer/value-change';
+import { createCallbackWrapper, registerViewFlush, unregisterViewFlush, } from './change-detection-flush';
+import * as i0 from "@angular/core";
+/**
+ * The shared half of every element directive: the prop surface all tags accept, and the ONE
+ * generic forward that puts a claimed binding back on the engine node.
+ *
+ * The forward is the deciding fact of this whole route. A binding claimed by a directive input
+ * never reaches `Renderer2.setProperty` on its own — Angular writes it to the directive instance
+ * — so without this loop a bare tag commits nothing at all. It stays generic on purpose: per-prop
+ * forwarding code is a component wrapper by another name, which is what this migration removes.
+ * `renderer.setProperty` lands in the adapter's own renderer, which routes the value through the
+ * engine's `routeProp` and applies the `id` -> `nativeID` and `symbioteStyle` -> `style` aliases.
+ */
+export class SymbioteElement {
+    renderer = inject(Renderer2);
+    host = inject(ElementRef);
+    detector = inject(ChangeDetectorRef);
+    // An `onX` PROP is called by the engine, so Angular is never told it fired. Shared with the
+    // component path's `SymbioteHostPropsDirective`, which has the identical deficit — see
+    // `createCallbackWrapper`.
+    wrapCallback = createCallbackWrapper(this.detector, this.host.nativeElement);
+    testID;
+    nativeID;
+    id;
+    accessible;
+    accessibilityLabel;
+    accessibilityHint;
+    accessibilityRole;
+    accessibilityState;
+    accessibilityValue;
+    accessibilityActions;
+    accessibilityLabelledBy;
+    importantForAccessibility;
+    accessibilityLiveRegion;
+    screenReaderFocusable;
+    accessibilityViewIsModal;
+    accessibilityElementsHidden;
+    accessibilityIgnoresInvertColors;
+    accessibilityLanguage;
+    accessibilityRespondsToUserInteraction;
+    accessibilityShowsLargeContentViewer;
+    accessibilityLargeContentTitle;
+    onAccessibilityAction;
+    onAccessibilityTap;
+    onMagicTap;
+    onAccessibilityEscape;
+    // The web aliases. Native reads only `accessibility*`; the engine folds these on the way in.
+    role;
+    'aria-label';
+    'aria-labelledby';
+    'aria-live';
+    'aria-hidden';
+    'aria-busy';
+    'aria-checked';
+    'aria-disabled';
+    'aria-expanded';
+    'aria-selected';
+    'aria-modal';
+    'aria-valuemax';
+    'aria-valuemin';
+    'aria-valuenow';
+    'aria-valuetext';
+    // The responder gates return a boolean, which an Angular `(event)` binding cannot carry back to
+    // the caller — so the whole family is inputs, never outputs.
+    onStartShouldSetResponder;
+    onStartShouldSetResponderCapture;
+    onMoveShouldSetResponder;
+    onMoveShouldSetResponderCapture;
+    onResponderGrant;
+    onResponderReject;
+    onResponderStart;
+    onResponderMove;
+    onResponderEnd;
+    onResponderRelease;
+    onResponderTerminate;
+    onResponderTerminationRequest;
+    pointerEvents;
+    hitSlop;
+    focusable;
+    collapsable;
+    removeClippedSubviews;
+    renderToHardwareTextureAndroid;
+    shouldRasterizeIOS;
+    needsOffscreenAlphaCompositing;
+    symbioteStyle;
+    // Declared, and the reason is the one `element-props.ts` used to give for NOT declaring it —
+    // reversed by measurement. `[style]` on an element with no directive input reaches Angular's own
+    // CSS styling engine (`ɵɵstyleMap`), which cannot represent an RN StyleProp: an ARRAY decomposes
+    // into numeric-index keys and a FUNCTION — the press-state callback this ecosystem writes — dies
+    // in `toStylingKeyValueArray` as "ASSERTION ERROR: Unsupported styling type: function", taking
+    // the whole enclosing template update with it. Device-reported 2026-09-11: every `ActionButton`
+    // in examples/angular painted as an empty bordered box, because the throw aborted the update
+    // before its `<text>` child was ever reached.
+    //
+    // A declared input CLAIMS the binding at compile time, so it never reaches the styling engine —
+    // the same mechanism the primitive host COMPONENTS have always relied on
+    // (`primitives/shared.ts`), which is why `<Pressable [style]>` worked and its replacement tag did
+    // not. `[style.borderWidth.px]` is a different instruction (`ɵɵstyleProp`) and is untouched: it
+    // still reaches `Renderer2.setStyle`, which merges per key.
+    //
+    // The press-state callback rides the BASE type rather than `PressableElement` alone: a subclass
+    // cannot widen an inherited property, and only the pressables have a `pressed` to read — so on
+    // any other tag the engine resolves it at `pressed: false` and the looseness is in the type, not
+    // in what commits.
+    style;
+    // The flat-bag spelling of the events below. `(press)` and `[onPress]` are both supported and
+    // land in the same place; an app that already holds a handler bag binds the props.
+    onPress;
+    onPressIn;
+    onPressOut;
+    onPressMove;
+    onLongPress;
+    onLayout;
+    onFocus;
+    onBlur;
+    ngOnChanges(changes) {
+        for (const name of Object.keys(changes)) {
+            this.renderer.setProperty(this.host.nativeElement, name, this.wrapCallback(name, changes[name]?.currentValue));
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: SymbioteElement, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: SymbioteElement, isStandalone: true, inputs: { testID: "testID", nativeID: "nativeID", id: "id", accessible: "accessible", accessibilityLabel: "accessibilityLabel", accessibilityHint: "accessibilityHint", accessibilityRole: "accessibilityRole", accessibilityState: "accessibilityState", accessibilityValue: "accessibilityValue", accessibilityActions: "accessibilityActions", accessibilityLabelledBy: "accessibilityLabelledBy", importantForAccessibility: "importantForAccessibility", accessibilityLiveRegion: "accessibilityLiveRegion", screenReaderFocusable: "screenReaderFocusable", accessibilityViewIsModal: "accessibilityViewIsModal", accessibilityElementsHidden: "accessibilityElementsHidden", accessibilityIgnoresInvertColors: "accessibilityIgnoresInvertColors", accessibilityLanguage: "accessibilityLanguage", accessibilityRespondsToUserInteraction: "accessibilityRespondsToUserInteraction", accessibilityShowsLargeContentViewer: "accessibilityShowsLargeContentViewer", accessibilityLargeContentTitle: "accessibilityLargeContentTitle", onAccessibilityAction: "onAccessibilityAction", onAccessibilityTap: "onAccessibilityTap", onMagicTap: "onMagicTap", onAccessibilityEscape: "onAccessibilityEscape", role: "role", "aria-label": "aria-label", "aria-labelledby": "aria-labelledby", "aria-live": "aria-live", "aria-hidden": "aria-hidden", "aria-busy": "aria-busy", "aria-checked": "aria-checked", "aria-disabled": "aria-disabled", "aria-expanded": "aria-expanded", "aria-selected": "aria-selected", "aria-modal": "aria-modal", "aria-valuemax": "aria-valuemax", "aria-valuemin": "aria-valuemin", "aria-valuenow": "aria-valuenow", "aria-valuetext": "aria-valuetext", onStartShouldSetResponder: "onStartShouldSetResponder", onStartShouldSetResponderCapture: "onStartShouldSetResponderCapture", onMoveShouldSetResponder: "onMoveShouldSetResponder", onMoveShouldSetResponderCapture: "onMoveShouldSetResponderCapture", onResponderGrant: "onResponderGrant", onResponderReject: "onResponderReject", onResponderStart: "onResponderStart", onResponderMove: "onResponderMove", onResponderEnd: "onResponderEnd", onResponderRelease: "onResponderRelease", onResponderTerminate: "onResponderTerminate", onResponderTerminationRequest: "onResponderTerminationRequest", pointerEvents: "pointerEvents", hitSlop: "hitSlop", focusable: "focusable", collapsable: "collapsable", removeClippedSubviews: "removeClippedSubviews", renderToHardwareTextureAndroid: "renderToHardwareTextureAndroid", shouldRasterizeIOS: "shouldRasterizeIOS", needsOffscreenAlphaCompositing: "needsOffscreenAlphaCompositing", symbioteStyle: "symbioteStyle", style: "style", onPress: "onPress", onPressIn: "onPressIn", onPressOut: "onPressOut", onPressMove: "onPressMove", onLongPress: "onLongPress", onLayout: "onLayout", onFocus: "onFocus", onBlur: "onBlur" }, usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: SymbioteElement, decorators: [{
+            type: Directive
+        }], propDecorators: { testID: [{
+                type: Input
+            }], nativeID: [{
+                type: Input
+            }], id: [{
+                type: Input
+            }], accessible: [{
+                type: Input
+            }], accessibilityLabel: [{
+                type: Input
+            }], accessibilityHint: [{
+                type: Input
+            }], accessibilityRole: [{
+                type: Input
+            }], accessibilityState: [{
+                type: Input
+            }], accessibilityValue: [{
+                type: Input
+            }], accessibilityActions: [{
+                type: Input
+            }], accessibilityLabelledBy: [{
+                type: Input
+            }], importantForAccessibility: [{
+                type: Input
+            }], accessibilityLiveRegion: [{
+                type: Input
+            }], screenReaderFocusable: [{
+                type: Input
+            }], accessibilityViewIsModal: [{
+                type: Input
+            }], accessibilityElementsHidden: [{
+                type: Input
+            }], accessibilityIgnoresInvertColors: [{
+                type: Input
+            }], accessibilityLanguage: [{
+                type: Input
+            }], accessibilityRespondsToUserInteraction: [{
+                type: Input
+            }], accessibilityShowsLargeContentViewer: [{
+                type: Input
+            }], accessibilityLargeContentTitle: [{
+                type: Input
+            }], onAccessibilityAction: [{
+                type: Input
+            }], onAccessibilityTap: [{
+                type: Input
+            }], onMagicTap: [{
+                type: Input
+            }], onAccessibilityEscape: [{
+                type: Input
+            }], role: [{
+                type: Input
+            }], "aria-label": [{
+                type: Input
+            }], "aria-labelledby": [{
+                type: Input
+            }], "aria-live": [{
+                type: Input
+            }], "aria-hidden": [{
+                type: Input
+            }], "aria-busy": [{
+                type: Input
+            }], "aria-checked": [{
+                type: Input
+            }], "aria-disabled": [{
+                type: Input
+            }], "aria-expanded": [{
+                type: Input
+            }], "aria-selected": [{
+                type: Input
+            }], "aria-modal": [{
+                type: Input
+            }], "aria-valuemax": [{
+                type: Input
+            }], "aria-valuemin": [{
+                type: Input
+            }], "aria-valuenow": [{
+                type: Input
+            }], "aria-valuetext": [{
+                type: Input
+            }], onStartShouldSetResponder: [{
+                type: Input
+            }], onStartShouldSetResponderCapture: [{
+                type: Input
+            }], onMoveShouldSetResponder: [{
+                type: Input
+            }], onMoveShouldSetResponderCapture: [{
+                type: Input
+            }], onResponderGrant: [{
+                type: Input
+            }], onResponderReject: [{
+                type: Input
+            }], onResponderStart: [{
+                type: Input
+            }], onResponderMove: [{
+                type: Input
+            }], onResponderEnd: [{
+                type: Input
+            }], onResponderRelease: [{
+                type: Input
+            }], onResponderTerminate: [{
+                type: Input
+            }], onResponderTerminationRequest: [{
+                type: Input
+            }], pointerEvents: [{
+                type: Input
+            }], hitSlop: [{
+                type: Input
+            }], focusable: [{
+                type: Input
+            }], collapsable: [{
+                type: Input
+            }], removeClippedSubviews: [{
+                type: Input
+            }], renderToHardwareTextureAndroid: [{
+                type: Input
+            }], shouldRasterizeIOS: [{
+                type: Input
+            }], needsOffscreenAlphaCompositing: [{
+                type: Input
+            }], symbioteStyle: [{
+                type: Input
+            }], style: [{
+                type: Input
+            }], onPress: [{
+                type: Input
+            }], onPressIn: [{
+                type: Input
+            }], onPressOut: [{
+                type: Input
+            }], onPressMove: [{
+                type: Input
+            }], onLongPress: [{
+                type: Input
+            }], onLayout: [{
+                type: Input
+            }], onFocus: [{
+                type: Input
+            }], onBlur: [{
+                type: Input
+            }] } });
+/**
+ * The base for a tag whose app callback an engine behavior READS BACK inside the same microtask
+ * turn — `<text-input>`, `<switch>`, `<refresh-control>`. Zoneless change detection is a macrotask,
+ * so without this the behavior sees the PRE-event value and undoes the user; the full mechanism,
+ * and why this is `detectChanges()` on one view rather than `ApplicationRef.tick()`, is in
+ * `./change-detection-flush`.
+ *
+ * The directive is the only thing in the adapter that owns a `ChangeDetectorRef` for the view
+ * holding the binding, so it hands one to the renderer keyed on its own node.
+ */
+class ReadBackElement extends SymbioteElement {
+    constructor() {
+        super();
+        const node = this.host.nativeElement;
+        if (typeof node === 'object' && node !== null) {
+            registerViewFlush(node, () => this.detector.detectChanges());
+        }
+    }
+    ngOnDestroy() {
+        const node = this.host.nativeElement;
+        if (typeof node === 'object' && node !== null)
+            unregisterViewFlush(node);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ReadBackElement, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: ReadBackElement, isStandalone: true, usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ReadBackElement, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [] });
+export class ViewElement extends SymbioteElement {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ViewElement, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: ViewElement, isStandalone: true, selector: "view", usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ViewElement, decorators: [{
+            type: Directive,
+            args: [{ selector: 'view', standalone: true }]
+        }] });
+export class PressableElement extends SymbioteElement {
+    disabled;
+    cancelable;
+    delayLongPress;
+    delayHoverIn;
+    delayHoverOut;
+    onHoverIn;
+    onHoverOut;
+    pressRetentionOffset;
+    unstable_pressDelay;
+    android_ripple;
+    android_disableSound;
+    hasTVPreferredFocus;
+    nextFocusDown;
+    nextFocusForward;
+    nextFocusLeft;
+    nextFocusRight;
+    nextFocusUp;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: PressableElement, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: PressableElement, isStandalone: true, selector: "pressable", inputs: { disabled: "disabled", cancelable: "cancelable", delayLongPress: "delayLongPress", delayHoverIn: "delayHoverIn", delayHoverOut: "delayHoverOut", onHoverIn: "onHoverIn", onHoverOut: "onHoverOut", pressRetentionOffset: "pressRetentionOffset", unstable_pressDelay: "unstable_pressDelay", android_ripple: "android_ripple", android_disableSound: "android_disableSound", hasTVPreferredFocus: "hasTVPreferredFocus", nextFocusDown: "nextFocusDown", nextFocusForward: "nextFocusForward", nextFocusLeft: "nextFocusLeft", nextFocusRight: "nextFocusRight", nextFocusUp: "nextFocusUp" }, usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: PressableElement, decorators: [{
+            type: Directive,
+            args: [{ selector: 'pressable', standalone: true }]
+        }], propDecorators: { disabled: [{
+                type: Input
+            }], cancelable: [{
+                type: Input
+            }], delayLongPress: [{
+                type: Input
+            }], delayHoverIn: [{
+                type: Input
+            }], delayHoverOut: [{
+                type: Input
+            }], onHoverIn: [{
+                type: Input
+            }], onHoverOut: [{
+                type: Input
+            }], pressRetentionOffset: [{
+                type: Input
+            }], unstable_pressDelay: [{
+                type: Input
+            }], android_ripple: [{
+                type: Input
+            }], android_disableSound: [{
+                type: Input
+            }], hasTVPreferredFocus: [{
+                type: Input
+            }], nextFocusDown: [{
+                type: Input
+            }], nextFocusForward: [{
+                type: Input
+            }], nextFocusLeft: [{
+                type: Input
+            }], nextFocusRight: [{
+                type: Input
+            }], nextFocusUp: [{
+                type: Input
+            }] } });
+// RN's TouchableOpacity is a Pressable that also fades, and both halves are on the engine node —
+// so it takes the same inputs and adds only the fade's own knob.
+export class TouchableOpacityElement extends PressableElement {
+    activeOpacity;
+    delayPressIn;
+    delayPressOut;
+    minPressDuration;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: TouchableOpacityElement, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: TouchableOpacityElement, isStandalone: true, selector: "touchable-opacity", inputs: { activeOpacity: "activeOpacity", delayPressIn: "delayPressIn", delayPressOut: "delayPressOut", minPressDuration: "minPressDuration" }, usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: TouchableOpacityElement, decorators: [{
+            type: Directive,
+            args: [{ selector: 'touchable-opacity', standalone: true }]
+        }], propDecorators: { activeOpacity: [{
+                type: Input
+            }], delayPressIn: [{
+                type: Input
+            }], delayPressOut: [{
+                type: Input
+            }], minPressDuration: [{
+                type: Input
+            }] } });
+// RN's TouchableHighlight is a Pressable that swaps its own background while pressed
+// (TouchableHighlight.js), and the underlay machine runs on the engine node — so the tag takes the
+// press surface plus the two knobs that describe the underlay. `onShowUnderlay`/`onHideUnderlay`
+// need no @Input: they are events, bound as `(showUnderlay)` through the renderer's own listen.
+export class TouchableHighlightElement extends PressableElement {
+    activeOpacity;
+    underlayColor;
+    delayPressIn;
+    delayPressOut;
+    minPressDuration;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: TouchableHighlightElement, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: TouchableHighlightElement, isStandalone: true, selector: "touchable-highlight", inputs: { activeOpacity: "activeOpacity", underlayColor: "underlayColor", delayPressIn: "delayPressIn", delayPressOut: "delayPressOut", minPressDuration: "minPressDuration" }, usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: TouchableHighlightElement, decorators: [{
+            type: Directive,
+            args: [{ selector: 'touchable-highlight', standalone: true }]
+        }], propDecorators: { activeOpacity: [{
+                type: Input
+            }], underlayColor: [{
+                type: Input
+            }], delayPressIn: [{
+                type: Input
+            }], delayPressOut: [{
+                type: Input
+            }], minPressDuration: [{
+                type: Input
+            }] } });
+// RN's TouchableNativeFeedback is a Pressable that CLONES onto its single child instead of
+// rendering anything (TouchableNativeFeedback.js:339) — so the tag takes the press surface plus the
+// two props that pick the Android ripple drawable. The tag itself commits no native view; the
+// behavior configures the child, which is why `elements.test.ts` reads it as an anchor.
+export class TouchableNativeFeedbackElement extends PressableElement {
+    background;
+    useForeground;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: TouchableNativeFeedbackElement, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: TouchableNativeFeedbackElement, isStandalone: true, selector: "touchable-native-feedback", inputs: { background: "background", useForeground: "useForeground" }, usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: TouchableNativeFeedbackElement, decorators: [{
+            type: Directive,
+            args: [{ selector: 'touchable-native-feedback', standalone: true }]
+        }], propDecorators: { background: [{
+                type: Input
+            }], useForeground: [{
+                type: Input
+            }] } });
+// RN's TouchableWithoutFeedback clones onto its single child the same way
+// (TouchableWithoutFeedback.js:286) and installs no drawable, so it takes the press surface plus the
+// three timing knobs it forwards to Pressability (:186-190) and nothing else. Like the tag above it
+// commits no native view; `elements.test.ts` reads it as an anchor.
+export class TouchableWithoutFeedbackElement extends PressableElement {
+    delayPressIn;
+    delayPressOut;
+    minPressDuration;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: TouchableWithoutFeedbackElement, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: TouchableWithoutFeedbackElement, isStandalone: true, selector: "touchable-without-feedback", inputs: { delayPressIn: "delayPressIn", delayPressOut: "delayPressOut", minPressDuration: "minPressDuration" }, usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: TouchableWithoutFeedbackElement, decorators: [{
+            type: Directive,
+            args: [{ selector: 'touchable-without-feedback', standalone: true }]
+        }], propDecorators: { delayPressIn: [{
+                type: Input
+            }], delayPressOut: [{
+                type: Input
+            }], minPressDuration: [{
+                type: Input
+            }] } });
+// RN's Button IS a TouchableOpacity (Button.js:384), and the behavior builds the view and the
+// label under it — so the tag takes the touchable's surface plus the four props Button owns. There
+// is no `style`: RN's Button has no such prop, and the label/background come from `color`.
+export class ButtonElement extends TouchableOpacityElement {
+    title;
+    color;
+    touchSoundDisabled;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ButtonElement, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: ButtonElement, isStandalone: true, selector: "button", inputs: { title: "title", color: "color", touchSoundDisabled: "touchSoundDisabled" }, usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ButtonElement, decorators: [{
+            type: Directive,
+            args: [{ selector: 'button', standalone: true }]
+        }], propDecorators: { title: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }], touchSoundDisabled: [{
+                type: Input
+            }] } });
+export class TextElement extends SymbioteElement {
+    // Narrows the inherited input to a TEXT style so `fontSize`/`fontWeight` type-check here. The
+    // initializer is what TS2612 asks for to accept a redeclaration as deliberate; `declare` would
+    // be the other answer and cannot carry a decorator.
+    style = undefined;
+    numberOfLines;
+    ellipsizeMode;
+    selectable;
+    adjustsFontSizeToFit;
+    minimumFontScale;
+    allowFontScaling;
+    maxFontSizeMultiplier;
+    selectionColor;
+    disabled;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: TextElement, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: TextElement, isStandalone: true, selector: "text", inputs: { style: "style", numberOfLines: "numberOfLines", ellipsizeMode: "ellipsizeMode", selectable: "selectable", adjustsFontSizeToFit: "adjustsFontSizeToFit", minimumFontScale: "minimumFontScale", allowFontScaling: "allowFontScaling", maxFontSizeMultiplier: "maxFontSizeMultiplier", selectionColor: "selectionColor", disabled: "disabled" }, usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: TextElement, decorators: [{
+            type: Directive,
+            args: [{ selector: 'text', standalone: true }]
+        }], propDecorators: { style: [{
+                type: Input
+            }], numberOfLines: [{
+                type: Input
+            }], ellipsizeMode: [{
+                type: Input
+            }], selectable: [{
+                type: Input
+            }], adjustsFontSizeToFit: [{
+                type: Input
+            }], minimumFontScale: [{
+                type: Input
+            }], allowFontScaling: [{
+                type: Input
+            }], maxFontSizeMultiplier: [{
+                type: Input
+            }], selectionColor: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }] } });
+export class ImageElement extends SymbioteElement {
+    source;
+    src;
+    srcSet;
+    alt;
+    width;
+    height;
+    resizeMode;
+    resizeMethod;
+    defaultSource;
+    loadingIndicatorSource;
+    blurRadius;
+    capInsets;
+    crossOrigin;
+    referrerPolicy;
+    fadeDuration;
+    progressiveRenderingEnabled;
+    tintColor;
+    onLoad;
+    onLoadStart;
+    onLoadEnd;
+    onError;
+    onProgress;
+    onPartialLoad;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ImageElement, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: ImageElement, isStandalone: true, selector: "image", inputs: { source: "source", src: "src", srcSet: "srcSet", alt: "alt", width: "width", height: "height", resizeMode: "resizeMode", resizeMethod: "resizeMethod", defaultSource: "defaultSource", loadingIndicatorSource: "loadingIndicatorSource", blurRadius: "blurRadius", capInsets: "capInsets", crossOrigin: "crossOrigin", referrerPolicy: "referrerPolicy", fadeDuration: "fadeDuration", progressiveRenderingEnabled: "progressiveRenderingEnabled", tintColor: "tintColor", onLoad: "onLoad", onLoadStart: "onLoadStart", onLoadEnd: "onLoadEnd", onError: "onError", onProgress: "onProgress", onPartialLoad: "onPartialLoad" }, usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ImageElement, decorators: [{
+            type: Directive,
+            args: [{ selector: 'image', standalone: true }]
+        }], propDecorators: { source: [{
+                type: Input
+            }], src: [{
+                type: Input
+            }], srcSet: [{
+                type: Input
+            }], alt: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], resizeMode: [{
+                type: Input
+            }], resizeMethod: [{
+                type: Input
+            }], defaultSource: [{
+                type: Input
+            }], loadingIndicatorSource: [{
+                type: Input
+            }], blurRadius: [{
+                type: Input
+            }], capInsets: [{
+                type: Input
+            }], crossOrigin: [{
+                type: Input
+            }], referrerPolicy: [{
+                type: Input
+            }], fadeDuration: [{
+                type: Input
+            }], progressiveRenderingEnabled: [{
+                type: Input
+            }], tintColor: [{
+                type: Input
+            }], onLoad: [{
+                type: Input
+            }], onLoadStart: [{
+                type: Input
+            }], onLoadEnd: [{
+                type: Input
+            }], onError: [{
+                type: Input
+            }], onProgress: [{
+                type: Input
+            }], onPartialLoad: [{
+                type: Input
+            }] } });
+// The box, not the image. Every Image prop below rides the engine's `slotPropsExcept` redirect onto
+// the absolutely-filled image the behavior builds, exactly as RN's own `...props` spread does
+// (ImageBackground.js:81) — so this directive declares them to make the BINDING legal, and the
+// engine decides which node each lands on.
+export class ImageBackgroundElement extends SymbioteElement {
+    imageStyle;
+    source;
+    src;
+    srcSet;
+    alt;
+    width;
+    height;
+    resizeMode;
+    resizeMethod;
+    defaultSource;
+    loadingIndicatorSource;
+    blurRadius;
+    capInsets;
+    crossOrigin;
+    referrerPolicy;
+    fadeDuration;
+    progressiveRenderingEnabled;
+    tintColor;
+    onLoad;
+    onLoadStart;
+    onLoadEnd;
+    onError;
+    onProgress;
+    onPartialLoad;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ImageBackgroundElement, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: ImageBackgroundElement, isStandalone: true, selector: "image-background", inputs: { imageStyle: "imageStyle", source: "source", src: "src", srcSet: "srcSet", alt: "alt", width: "width", height: "height", resizeMode: "resizeMode", resizeMethod: "resizeMethod", defaultSource: "defaultSource", loadingIndicatorSource: "loadingIndicatorSource", blurRadius: "blurRadius", capInsets: "capInsets", crossOrigin: "crossOrigin", referrerPolicy: "referrerPolicy", fadeDuration: "fadeDuration", progressiveRenderingEnabled: "progressiveRenderingEnabled", tintColor: "tintColor", onLoad: "onLoad", onLoadStart: "onLoadStart", onLoadEnd: "onLoadEnd", onError: "onError", onProgress: "onProgress", onPartialLoad: "onPartialLoad" }, usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ImageBackgroundElement, decorators: [{
+            type: Directive,
+            args: [{ selector: 'image-background', standalone: true }]
+        }], propDecorators: { imageStyle: [{
+                type: Input
+            }], source: [{
+                type: Input
+            }], src: [{
+                type: Input
+            }], srcSet: [{
+                type: Input
+            }], alt: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], resizeMode: [{
+                type: Input
+            }], resizeMethod: [{
+                type: Input
+            }], defaultSource: [{
+                type: Input
+            }], loadingIndicatorSource: [{
+                type: Input
+            }], blurRadius: [{
+                type: Input
+            }], capInsets: [{
+                type: Input
+            }], crossOrigin: [{
+                type: Input
+            }], referrerPolicy: [{
+                type: Input
+            }], fadeDuration: [{
+                type: Input
+            }], progressiveRenderingEnabled: [{
+                type: Input
+            }], tintColor: [{
+                type: Input
+            }], onLoad: [{
+                type: Input
+            }], onLoadStart: [{
+                type: Input
+            }], onLoadEnd: [{
+                type: Input
+            }], onError: [{
+                type: Input
+            }], onProgress: [{
+                type: Input
+            }], onPartialLoad: [{
+                type: Input
+            }] } });
+export class ScrollViewElement extends SymbioteElement {
+    // No `horizontal` @Input: the axis is the TAG you write, never a prop — see
+    // `../components/scroll-view-props.ts`'s header. `HorizontalScrollViewElement` below is the
+    // other spelling, not a variant of this one.
+    scrollEnabled;
+    scrollEventThrottle;
+    contentContainerStyle;
+    contentInset;
+    contentInsetAdjustmentBehavior;
+    contentOffset;
+    scrollIndicatorInsets;
+    showsHorizontalScrollIndicator;
+    showsVerticalScrollIndicator;
+    alwaysBounceHorizontal;
+    alwaysBounceVertical;
+    bounces;
+    bouncesZoom;
+    centerContent;
+    decelerationRate;
+    directionalLockEnabled;
+    disableIntervalMomentum;
+    endFillColor;
+    fadingEdgeLength;
+    indicatorStyle;
+    invertStickyHeaders;
+    keyboardDismissMode;
+    keyboardShouldPersistTaps;
+    automaticallyAdjustKeyboardInsets;
+    maintainVisibleContentPosition;
+    maximumZoomScale;
+    minimumZoomScale;
+    zoomScale;
+    nestedScrollEnabled;
+    overScrollMode;
+    pagingEnabled;
+    persistentScrollbar;
+    pinchGestureEnabled;
+    snapToAlignment;
+    snapToEnd;
+    snapToInterval;
+    snapToOffsets;
+    snapToStart;
+    stickyHeaderIndices;
+    onScroll;
+    onScrollBeginDrag;
+    onScrollEndDrag;
+    onMomentumScrollBegin;
+    onMomentumScrollEnd;
+    onScrollToTop;
+    onContentSizeChange;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ScrollViewElement, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: ScrollViewElement, isStandalone: true, selector: "scroll-view", inputs: { scrollEnabled: "scrollEnabled", scrollEventThrottle: "scrollEventThrottle", contentContainerStyle: "contentContainerStyle", contentInset: "contentInset", contentInsetAdjustmentBehavior: "contentInsetAdjustmentBehavior", contentOffset: "contentOffset", scrollIndicatorInsets: "scrollIndicatorInsets", showsHorizontalScrollIndicator: "showsHorizontalScrollIndicator", showsVerticalScrollIndicator: "showsVerticalScrollIndicator", alwaysBounceHorizontal: "alwaysBounceHorizontal", alwaysBounceVertical: "alwaysBounceVertical", bounces: "bounces", bouncesZoom: "bouncesZoom", centerContent: "centerContent", decelerationRate: "decelerationRate", directionalLockEnabled: "directionalLockEnabled", disableIntervalMomentum: "disableIntervalMomentum", endFillColor: "endFillColor", fadingEdgeLength: "fadingEdgeLength", indicatorStyle: "indicatorStyle", invertStickyHeaders: "invertStickyHeaders", keyboardDismissMode: "keyboardDismissMode", keyboardShouldPersistTaps: "keyboardShouldPersistTaps", automaticallyAdjustKeyboardInsets: "automaticallyAdjustKeyboardInsets", maintainVisibleContentPosition: "maintainVisibleContentPosition", maximumZoomScale: "maximumZoomScale", minimumZoomScale: "minimumZoomScale", zoomScale: "zoomScale", nestedScrollEnabled: "nestedScrollEnabled", overScrollMode: "overScrollMode", pagingEnabled: "pagingEnabled", persistentScrollbar: "persistentScrollbar", pinchGestureEnabled: "pinchGestureEnabled", snapToAlignment: "snapToAlignment", snapToEnd: "snapToEnd", snapToInterval: "snapToInterval", snapToOffsets: "snapToOffsets", snapToStart: "snapToStart", stickyHeaderIndices: "stickyHeaderIndices", onScroll: "onScroll", onScrollBeginDrag: "onScrollBeginDrag", onScrollEndDrag: "onScrollEndDrag", onMomentumScrollBegin: "onMomentumScrollBegin", onMomentumScrollEnd: "onMomentumScrollEnd", onScrollToTop: "onScrollToTop", onContentSizeChange: "onContentSizeChange" }, usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ScrollViewElement, decorators: [{
+            type: Directive,
+            args: [{ selector: 'scroll-view', standalone: true }]
+        }], propDecorators: { scrollEnabled: [{
+                type: Input
+            }], scrollEventThrottle: [{
+                type: Input
+            }], contentContainerStyle: [{
+                type: Input
+            }], contentInset: [{
+                type: Input
+            }], contentInsetAdjustmentBehavior: [{
+                type: Input
+            }], contentOffset: [{
+                type: Input
+            }], scrollIndicatorInsets: [{
+                type: Input
+            }], showsHorizontalScrollIndicator: [{
+                type: Input
+            }], showsVerticalScrollIndicator: [{
+                type: Input
+            }], alwaysBounceHorizontal: [{
+                type: Input
+            }], alwaysBounceVertical: [{
+                type: Input
+            }], bounces: [{
+                type: Input
+            }], bouncesZoom: [{
+                type: Input
+            }], centerContent: [{
+                type: Input
+            }], decelerationRate: [{
+                type: Input
+            }], directionalLockEnabled: [{
+                type: Input
+            }], disableIntervalMomentum: [{
+                type: Input
+            }], endFillColor: [{
+                type: Input
+            }], fadingEdgeLength: [{
+                type: Input
+            }], indicatorStyle: [{
+                type: Input
+            }], invertStickyHeaders: [{
+                type: Input
+            }], keyboardDismissMode: [{
+                type: Input
+            }], keyboardShouldPersistTaps: [{
+                type: Input
+            }], automaticallyAdjustKeyboardInsets: [{
+                type: Input
+            }], maintainVisibleContentPosition: [{
+                type: Input
+            }], maximumZoomScale: [{
+                type: Input
+            }], minimumZoomScale: [{
+                type: Input
+            }], zoomScale: [{
+                type: Input
+            }], nestedScrollEnabled: [{
+                type: Input
+            }], overScrollMode: [{
+                type: Input
+            }], pagingEnabled: [{
+                type: Input
+            }], persistentScrollbar: [{
+                type: Input
+            }], pinchGestureEnabled: [{
+                type: Input
+            }], snapToAlignment: [{
+                type: Input
+            }], snapToEnd: [{
+                type: Input
+            }], snapToInterval: [{
+                type: Input
+            }], snapToOffsets: [{
+                type: Input
+            }], snapToStart: [{
+                type: Input
+            }], stickyHeaderIndices: [{
+                type: Input
+            }], onScroll: [{
+                type: Input
+            }], onScrollBeginDrag: [{
+                type: Input
+            }], onScrollEndDrag: [{
+                type: Input
+            }], onMomentumScrollBegin: [{
+                type: Input
+            }], onMomentumScrollEnd: [{
+                type: Input
+            }], onScrollToTop: [{
+                type: Input
+            }], onContentSizeChange: [{
+                type: Input
+            }] } });
+export class HorizontalScrollViewElement extends ScrollViewElement {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: HorizontalScrollViewElement, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: HorizontalScrollViewElement, isStandalone: true, selector: "horizontal-scroll-view", usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: HorizontalScrollViewElement, decorators: [{
+            type: Directive,
+            args: [{ selector: 'horizontal-scroll-view', standalone: true }]
+        }] });
+export class ScrollContentElement extends SymbioteElement {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ScrollContentElement, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: ScrollContentElement, isStandalone: true, selector: "scroll-content", usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ScrollContentElement, decorators: [{
+            type: Directive,
+            args: [{ selector: 'scroll-content', standalone: true }]
+        }] });
+export class HorizontalScrollContentElement extends SymbioteElement {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: HorizontalScrollContentElement, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: HorizontalScrollContentElement, isStandalone: true, selector: "horizontal-scroll-content", usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: HorizontalScrollContentElement, decorators: [{
+            type: Directive,
+            args: [{ selector: 'horizontal-scroll-content', standalone: true }]
+        }] });
+/**
+ * The `[(value)]` half of a controlled tag — `<switch>` and `<text-input>`.
+ *
+ * The one `@Output` in this file, and it is FORCED rather than chosen. `[(value)]` desugars to
+ * `[value]` + `(valueChange)`, and ngtsc requires both halves to resolve to the SAME target: a
+ * declared `value` input beside an event no directive claims is NG8007, "the property and event
+ * halves are not bound to the same target". So the sugar this adapter documents cannot work without
+ * the output existing, whatever the file header says about events in general.
+ *
+ * The bridge below is NOT what makes the binding work today, and the comment says so because the
+ * obvious reading is wrong: the file header's "an `@Output` CONSUMES the binding" holds for a
+ * COMPONENT, and an element is the other case — Angular attaches the renderer listener for the
+ * event as well, so `Renderer2.listen` still runs and the engine still hears the change. Measured
+ * under JIT by deleting this whole hook: every case in `lowered-two-way-value.test.ts` stayed
+ * green, delivery included, and exactly ONCE (nothing double-fires when both paths exist).
+ *
+ * It is kept because the measurement is JIT-only and this adapter has a recorded case of JIT and
+ * AOT resolving a binding differently (`test-harness-false-greens.md` §21). If AOT routes the event
+ * exclusively to the output, this hook is the only thing keeping `[(value)]` alive; if it routes to
+ * both, it is one extra listener on a control an app explicitly bound. Delete it once something
+ * executes the LINKED artifact and shows the renderer listener is attached there too.
+ *
+ * Opened only when something is SUBSCRIBED: the prop's PRESENCE is what a behavior reads to decide
+ * it is controlled, so a `<switch>` given a handler nobody asked for changes how it snaps back.
+ * `.observed` is readable from `ngOnInit` because Angular subscribes outputs in the creation pass,
+ * before the update pass runs the hook — observed directly (true for the two bound tags, false for
+ * an unbound one), not assumed.
+ */
+class ValueChangeElement extends ReadBackElement {
+    valueRenderer = inject(Renderer2);
+    valueHost = inject(ElementRef);
+    unlistenValue;
+    ngOnInit() {
+        if (!this.hasValueSubscriber())
+            return;
+        this.unlistenValue = this.valueRenderer.listen(this.valueHost.nativeElement, VALUE_CHANGE_EVENT, (value) => {
+            this.emitValue(value);
+        });
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this.unlistenValue?.();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ValueChangeElement, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: ValueChangeElement, isStandalone: true, usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ValueChangeElement, decorators: [{
+            type: Directive
+        }] });
+export class TextInputElement extends ValueChangeElement {
+    value;
+    defaultValue;
+    placeholder;
+    placeholderTextColor;
+    multiline;
+    numberOfLines;
+    maxLength;
+    editable;
+    readOnly;
+    autoFocus;
+    autoCapitalize;
+    autoComplete;
+    autoCorrect;
+    blurOnSubmit;
+    submitBehavior;
+    cursorColor;
+    enterKeyHint;
+    returnKeyType;
+    inputMode;
+    keyboardType;
+    inputAccessoryViewID;
+    scrollEnabled;
+    secureTextEntry;
+    selectTextOnFocus;
+    selection;
+    selectionColor;
+    selectionHandleColor;
+    showSoftInputOnFocus;
+    textAlign;
+    textContentType;
+    underlineColorAndroid;
+    onValueChange;
+    onContentSizeChange;
+    onEndEditing;
+    onKeyPress;
+    onSelectionChange;
+    onSubmitEditing;
+    // NonNullable, not the prop type: `[(value)]="name"` binds a `string`, and an emitter that can
+    // also emit `undefined` fails the two-way assignability check ngtsc runs on the event half.
+    valueChange = new EventEmitter();
+    hasValueSubscriber() {
+        return this.valueChange.observed;
+    }
+    emitValue(value) {
+        if (typeof value === 'string')
+            this.valueChange.emit(value);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: TextInputElement, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: TextInputElement, isStandalone: true, selector: "text-input", inputs: { value: "value", defaultValue: "defaultValue", placeholder: "placeholder", placeholderTextColor: "placeholderTextColor", multiline: "multiline", numberOfLines: "numberOfLines", maxLength: "maxLength", editable: "editable", readOnly: "readOnly", autoFocus: "autoFocus", autoCapitalize: "autoCapitalize", autoComplete: "autoComplete", autoCorrect: "autoCorrect", blurOnSubmit: "blurOnSubmit", submitBehavior: "submitBehavior", cursorColor: "cursorColor", enterKeyHint: "enterKeyHint", returnKeyType: "returnKeyType", inputMode: "inputMode", keyboardType: "keyboardType", inputAccessoryViewID: "inputAccessoryViewID", scrollEnabled: "scrollEnabled", secureTextEntry: "secureTextEntry", selectTextOnFocus: "selectTextOnFocus", selection: "selection", selectionColor: "selectionColor", selectionHandleColor: "selectionHandleColor", showSoftInputOnFocus: "showSoftInputOnFocus", textAlign: "textAlign", textContentType: "textContentType", underlineColorAndroid: "underlineColorAndroid", onValueChange: "onValueChange", onContentSizeChange: "onContentSizeChange", onEndEditing: "onEndEditing", onKeyPress: "onKeyPress", onSelectionChange: "onSelectionChange", onSubmitEditing: "onSubmitEditing" }, outputs: { valueChange: "valueChange" }, usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: TextInputElement, decorators: [{
+            type: Directive,
+            args: [{ selector: 'text-input', standalone: true }]
+        }], propDecorators: { value: [{
+                type: Input
+            }], defaultValue: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], placeholderTextColor: [{
+                type: Input
+            }], multiline: [{
+                type: Input
+            }], numberOfLines: [{
+                type: Input
+            }], maxLength: [{
+                type: Input
+            }], editable: [{
+                type: Input
+            }], readOnly: [{
+                type: Input
+            }], autoFocus: [{
+                type: Input
+            }], autoCapitalize: [{
+                type: Input
+            }], autoComplete: [{
+                type: Input
+            }], autoCorrect: [{
+                type: Input
+            }], blurOnSubmit: [{
+                type: Input
+            }], submitBehavior: [{
+                type: Input
+            }], cursorColor: [{
+                type: Input
+            }], enterKeyHint: [{
+                type: Input
+            }], returnKeyType: [{
+                type: Input
+            }], inputMode: [{
+                type: Input
+            }], keyboardType: [{
+                type: Input
+            }], inputAccessoryViewID: [{
+                type: Input
+            }], scrollEnabled: [{
+                type: Input
+            }], secureTextEntry: [{
+                type: Input
+            }], selectTextOnFocus: [{
+                type: Input
+            }], selection: [{
+                type: Input
+            }], selectionColor: [{
+                type: Input
+            }], selectionHandleColor: [{
+                type: Input
+            }], showSoftInputOnFocus: [{
+                type: Input
+            }], textAlign: [{
+                type: Input
+            }], textContentType: [{
+                type: Input
+            }], underlineColorAndroid: [{
+                type: Input
+            }], onValueChange: [{
+                type: Input
+            }], onContentSizeChange: [{
+                type: Input
+            }], onEndEditing: [{
+                type: Input
+            }], onKeyPress: [{
+                type: Input
+            }], onSelectionChange: [{
+                type: Input
+            }], onSubmitEditing: [{
+                type: Input
+            }], valueChange: [{
+                type: Output
+            }] } });
+export class MultilineTextInputElement extends TextInputElement {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: MultilineTextInputElement, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: MultilineTextInputElement, isStandalone: true, selector: "text-input-multiline", usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: MultilineTextInputElement, decorators: [{
+            type: Directive,
+            args: [{ selector: 'text-input-multiline', standalone: true }]
+        }] });
+// The COMPONENT path's spelling of the pair above — same native views, a tag the behavior registry
+// deliberately does not carry (`component-names/shared.ts`). Declared so the tag alphabet is
+// complete; an app writes the plain name.
+export class ManagedTextInputElement extends TextInputElement {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ManagedTextInputElement, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: ManagedTextInputElement, isStandalone: true, selector: "text-input-managed", usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ManagedTextInputElement, decorators: [{
+            type: Directive,
+            args: [{ selector: 'text-input-managed', standalone: true }]
+        }] });
+export class ManagedMultilineTextInputElement extends TextInputElement {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ManagedMultilineTextInputElement, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: ManagedMultilineTextInputElement, isStandalone: true, selector: "text-input-multiline-managed", usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ManagedMultilineTextInputElement, decorators: [{
+            type: Directive,
+            args: [{ selector: 'text-input-multiline-managed', standalone: true }]
+        }] });
+export class SwitchElement extends ValueChangeElement {
+    value;
+    disabled;
+    trackColor;
+    thumbColor;
+    ios_backgroundColor;
+    onValueChange;
+    valueChange = new EventEmitter();
+    hasValueSubscriber() {
+        return this.valueChange.observed;
+    }
+    emitValue(value) {
+        if (typeof value === 'boolean')
+            this.valueChange.emit(value);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: SwitchElement, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: SwitchElement, isStandalone: true, selector: "switch", inputs: { value: "value", disabled: "disabled", trackColor: "trackColor", thumbColor: "thumbColor", ios_backgroundColor: "ios_backgroundColor", onValueChange: "onValueChange" }, outputs: { valueChange: "valueChange" }, usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: SwitchElement, decorators: [{
+            type: Directive,
+            args: [{ selector: 'switch', standalone: true }]
+        }], propDecorators: { value: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], trackColor: [{
+                type: Input
+            }], thumbColor: [{
+                type: Input
+            }], ios_backgroundColor: [{
+                type: Input
+            }], onValueChange: [{
+                type: Input
+            }], valueChange: [{
+                type: Output
+            }] } });
+export class ManagedSwitchElement extends SwitchElement {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ManagedSwitchElement, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: ManagedSwitchElement, isStandalone: true, selector: "switch-managed", usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ManagedSwitchElement, decorators: [{
+            type: Directive,
+            args: [{ selector: 'switch-managed', standalone: true }]
+        }] });
+/**
+ * `[(ngModel)]` / `formControlName` on a `<text-input>` or a `<switch>`.
+ *
+ * The wrappers provided `NG_VALUE_ACCESSOR` themselves; a tag has no class for @angular/forms to
+ * call into, so the accessor moves onto a directive of its own rather than being dropped — the
+ * shape Angular's own `DefaultValueAccessor` takes for `<input>`. Providing it unconditionally is
+ * safe: @angular/forms looks the accessor up only when an `ngModel` / `formControl*` directive sits
+ * on the SAME element, so a plain `<switch [(value)]>` never reaches it.
+ *
+ * Everything below goes through `Renderer2`, which is the adapter's own — `setProperty` lands in
+ * `routeProp` and `listen('valueChange')` is already unwrapped to a bare value there, so this
+ * directive holds no fold of its own.
+ */
+class SymbioteValueAccessor {
+    renderer = inject(Renderer2);
+    host = inject(ElementRef);
+    unlisten;
+    setProp(name, value) {
+        this.renderer.setProperty(this.host.nativeElement, name, value);
+    }
+    writeValue(value) {
+        this.setProp('value', value ?? undefined);
+    }
+    registerOnChange(fn) {
+        this.unlisten?.();
+        this.unlisten = this.renderer.listen(this.host.nativeElement, VALUE_CHANGE_EVENT, (value) => {
+            fn(value);
+        });
+    }
+    // Native has no blur-driven "touched" signal distinct from `blur`, and RN's own onBlur is what an
+    // app binds — so touched is driven off the same event rather than a second channel.
+    registerOnTouched(fn) {
+        this.setProp('onBlur', () => fn());
+    }
+    setDisabledState(isDisabled) {
+        this.writeDisabled(isDisabled);
+    }
+    ngOnDestroy() {
+        this.unlisten?.();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: SymbioteValueAccessor, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: SymbioteValueAccessor, isStandalone: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: SymbioteValueAccessor, decorators: [{
+            type: Directive
+        }] });
+export class TextInputValueAccessor extends SymbioteValueAccessor {
+    writeDisabled(isDisabled) {
+        this.setProp('editable', !isDisabled);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: TextInputValueAccessor, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: TextInputValueAccessor, isStandalone: true, selector: "text-input[ngModel], text-input[formControl], text-input[formControlName], text-input-multiline[ngModel], text-input-multiline[formControl], text-input-multiline[formControlName]", providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => TextInputValueAccessor),
+                multi: true,
+            },
+        ], usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: TextInputValueAccessor, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'text-input[ngModel], text-input[formControl], text-input[formControlName], text-input-multiline[ngModel], text-input-multiline[formControl], text-input-multiline[formControlName]',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => TextInputValueAccessor),
+                            multi: true,
+                        },
+                    ],
+                }]
+        }] });
+export class SwitchValueAccessor extends SymbioteValueAccessor {
+    writeDisabled(isDisabled) {
+        this.setProp('disabled', isDisabled);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: SwitchValueAccessor, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: SwitchValueAccessor, isStandalone: true, selector: "switch[ngModel], switch[formControl], switch[formControlName], switch-managed[ngModel], switch-managed[formControl], switch-managed[formControlName]", providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => SwitchValueAccessor),
+                multi: true,
+            },
+        ], usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: SwitchValueAccessor, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'switch[ngModel], switch[formControl], switch[formControlName], switch-managed[ngModel], switch-managed[formControl], switch-managed[formControlName]',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => SwitchValueAccessor),
+                            multi: true,
+                        },
+                    ],
+                }]
+        }] });
+// The HOST — RN's centering RCTView (ActivityIndicator.js:112), which is the tag an app writes.
+// The four spinner props are declared here because that is where the app writes them; the engine's
+// behavior redirects them onto the spinner it builds underneath (`slotProps`).
+export class ActivityIndicatorElement extends SymbioteElement {
+    animating;
+    color;
+    size;
+    hidesWhenStopped;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ActivityIndicatorElement, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: ActivityIndicatorElement, isStandalone: true, selector: "activity-indicator", inputs: { animating: "animating", color: "color", size: "size", hidesWhenStopped: "hidesWhenStopped" }, usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ActivityIndicatorElement, decorators: [{
+            type: Directive,
+            args: [{ selector: 'activity-indicator', standalone: true }]
+        }], propDecorators: { animating: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], hidesWhenStopped: [{
+                type: Input
+            }] } });
+// The native spinner. Built by the behavior's `buildStructure` and by the wrapper's render fn, never
+// written in an app template — declared only so the tag alphabet stays covered, the same as
+// `scroll-content`.
+export class ActivityIndicatorSpinnerElement extends ActivityIndicatorElement {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ActivityIndicatorSpinnerElement, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: ActivityIndicatorSpinnerElement, isStandalone: true, selector: "activity-indicator-spinner", usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ActivityIndicatorSpinnerElement, decorators: [{
+            type: Directive,
+            args: [{ selector: 'activity-indicator-spinner', standalone: true }]
+        }] });
+export class SafeAreaViewElement extends SymbioteElement {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: SafeAreaViewElement, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: SafeAreaViewElement, isStandalone: true, selector: "safe-area-view", usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: SafeAreaViewElement, decorators: [{
+            type: Directive,
+            args: [{ selector: 'safe-area-view', standalone: true }]
+        }] });
+export class ModalElement extends SymbioteElement {
+    visible;
+    transparent;
+    animationType;
+    presentationStyle;
+    supportedOrientations;
+    hardwareAccelerated;
+    statusBarTranslucent;
+    navigationBarTranslucent;
+    allowSwipeDismissal;
+    backdropColor;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ModalElement, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: ModalElement, isStandalone: true, selector: "modal", inputs: { visible: "visible", transparent: "transparent", animationType: "animationType", presentationStyle: "presentationStyle", supportedOrientations: "supportedOrientations", hardwareAccelerated: "hardwareAccelerated", statusBarTranslucent: "statusBarTranslucent", navigationBarTranslucent: "navigationBarTranslucent", allowSwipeDismissal: "allowSwipeDismissal", backdropColor: "backdropColor" }, usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ModalElement, decorators: [{
+            type: Directive,
+            args: [{ selector: 'modal', standalone: true }]
+        }], propDecorators: { visible: [{
+                type: Input
+            }], transparent: [{
+                type: Input
+            }], animationType: [{
+                type: Input
+            }], presentationStyle: [{
+                type: Input
+            }], supportedOrientations: [{
+                type: Input
+            }], hardwareAccelerated: [{
+                type: Input
+            }], statusBarTranslucent: [{
+                type: Input
+            }], navigationBarTranslucent: [{
+                type: Input
+            }], allowSwipeDismissal: [{
+                type: Input
+            }], backdropColor: [{
+                type: Input
+            }] } });
+export class RefreshControlElement extends ReadBackElement {
+    refreshing;
+    enabled;
+    colors;
+    tintColor;
+    title;
+    titleColor;
+    size;
+    progressBackgroundColor;
+    progressViewOffset;
+    onRefresh;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: RefreshControlElement, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: RefreshControlElement, isStandalone: true, selector: "refresh-control", inputs: { refreshing: "refreshing", enabled: "enabled", colors: "colors", tintColor: "tintColor", title: "title", titleColor: "titleColor", size: "size", progressBackgroundColor: "progressBackgroundColor", progressViewOffset: "progressViewOffset", onRefresh: "onRefresh" }, usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: RefreshControlElement, decorators: [{
+            type: Directive,
+            args: [{ selector: 'refresh-control', standalone: true }]
+        }], propDecorators: { refreshing: [{
+                type: Input
+            }], enabled: [{
+                type: Input
+            }], colors: [{
+                type: Input
+            }], tintColor: [{
+                type: Input
+            }], title: [{
+                type: Input
+            }], titleColor: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], progressBackgroundColor: [{
+                type: Input
+            }], progressViewOffset: [{
+                type: Input
+            }], onRefresh: [{
+                type: Input
+            }] } });
+export class StickyHeaderElement extends SymbioteElement {
+    inverted;
+    nextHeaderLayoutY;
+    scrollAnimatedValue;
+    scrollViewHeight;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: StickyHeaderElement, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: StickyHeaderElement, isStandalone: true, selector: "sticky-header", inputs: { inverted: "inverted", nextHeaderLayoutY: "nextHeaderLayoutY", scrollAnimatedValue: "scrollAnimatedValue", scrollViewHeight: "scrollViewHeight" }, usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: StickyHeaderElement, decorators: [{
+            type: Directive,
+            args: [{ selector: 'sticky-header', standalone: true }]
+        }], propDecorators: { inverted: [{
+                type: Input
+            }], nextHeaderLayoutY: [{
+                type: Input
+            }], scrollAnimatedValue: [{
+                type: Input
+            }], scrollViewHeight: [{
+                type: Input
+            }] } });
+export class InputAccessoryViewElement extends SymbioteElement {
+    backgroundColor;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: InputAccessoryViewElement, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: InputAccessoryViewElement, isStandalone: true, selector: "input-accessory-view", inputs: { backgroundColor: "backgroundColor" }, usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: InputAccessoryViewElement, decorators: [{
+            type: Directive,
+            args: [{ selector: 'input-accessory-view', standalone: true }]
+        }], propDecorators: { backgroundColor: [{
+                type: Input
+            }] } });
+/**
+ * Every element directive, as ONE symbol an app puts in `imports`. Angular flattens a nested array
+ * there, so the line does not grow as the tag alphabet does — and a per-component `imports` line is
+ * the floor for standalone components whatever we ship (there is no global-import mechanism, by
+ * design: angular/angular#43784).
+ *
+ * `elements.test.ts` asserts this covers every key of `COMPONENT_DESCRIPTORS`, derived from that
+ * table, so a future primitive joins by existing rather than by someone remembering.
+ */
+export const SYMBIOTE_ELEMENTS = [
+    ViewElement,
+    PressableElement,
+    TouchableOpacityElement,
+    TouchableHighlightElement,
+    TouchableNativeFeedbackElement,
+    TouchableWithoutFeedbackElement,
+    ButtonElement,
+    TextElement,
+    ImageElement,
+    ImageBackgroundElement,
+    ScrollViewElement,
+    HorizontalScrollViewElement,
+    ScrollContentElement,
+    HorizontalScrollContentElement,
+    TextInputElement,
+    MultilineTextInputElement,
+    ManagedTextInputElement,
+    ManagedMultilineTextInputElement,
+    SwitchElement,
+    ManagedSwitchElement,
+    ActivityIndicatorElement,
+    ActivityIndicatorSpinnerElement,
+    SafeAreaViewElement,
+    ModalElement,
+    RefreshControlElement,
+    StickyHeaderElement,
+    InputAccessoryViewElement,
+    // Not tags — the `[(ngModel)]` / `formControl*` accessors for the two controlled ones. They ride
+    // this list so an app that already imports it keeps the forms integration the deleted wrappers
+    // provided, and `elements.test.ts` subtracts them from its tag-coverage check by name.
+    TextInputValueAccessor,
+    SwitchValueAccessor,
+];
+const DECLARES_EVERY_PROP = {
+    view: true,
+    pressable: true,
+    touchableOpacity: true,
+    touchableHighlight: true,
+    text: true,
+    image: true,
+    imageBackground: true,
+    scrollView: true,
+    textInput: true,
+    switch: true,
+    activityIndicator: true,
+    modal: true,
+    refreshControl: true,
+    stickyHeader: true,
+    inputAccessoryView: true,
+};
+void DECLARES_EVERY_PROP;
+//# sourceMappingURL=elements.js.map