@ng-native/components 0.0.1 → 0.1.0

package/dist/view-base.d.ts

@@ -0,0 +1,332 @@
+/**
+ * The props every native view accepts, as typed inputs forwarded to the host node.
+ *
+ * Each input is mirrored by a host binding of the same name, which is what carries the value to
+ * the renderer: once a directive declares an input, Angular routes the binding to the directive
+ * rather than the element. An unset input stays `undefined` and never reaches native, so a view
+ * that mentions none of these sends none of them.
+ *
+ * Web-style `aria-*` names are accepted as aliases and land on the `accessibility*` props React
+ * Native's own `View.js` maps them to. `id` maps to `nativeID` and `tabIndex` to `focusable` the
+ * same way.
+ *
+ * Events are element events, typed in `events.ts`: `(layout)`, `(touchStart)`,
+ * `(accessibilityAction)` and so on. They are deliberately not outputs; see that file.
+ */
+import { type SimpleChanges } from '@angular/core';
+import { HostEngine, type HostNode } from '@ng-native/fabric';
+import type { Insets } from './events.ts';
+import * as i0 from "@angular/core";
+/** The roles assistive technologies understand. `Role` is the web spelling of the same set. */
+export type AccessibilityRole = 'none' | 'button' | 'togglebutton' | 'link' | 'search' | 'image' | 'keyboardkey' | 'text' | 'adjustable' | 'imagebutton' | 'header' | 'summary' | 'alert' | 'checkbox' | 'combobox' | 'menu' | 'menubar' | 'menuitem' | 'progressbar' | 'radio' | 'radiogroup' | 'scrollbar' | 'spinbutton' | 'switch' | 'tab' | 'tabbar' | 'tablist' | 'timer' | 'list' | 'toolbar' | 'grid' | 'pager' | 'scrollview' | 'horizontalscrollview' | 'viewgroup' | 'webview' | 'drawerlayout' | 'slidingdrawer' | 'iconmenu';
+export interface AccessibilityState {
+    readonly disabled?: boolean;
+    readonly selected?: boolean;
+    readonly checked?: boolean | 'mixed';
+    readonly busy?: boolean;
+    readonly expanded?: boolean;
+}
+export interface AccessibilityValue {
+    readonly min?: number;
+    readonly max?: number;
+    readonly now?: number;
+    readonly text?: string;
+}
+export interface AccessibilityAction {
+    readonly name: string;
+    readonly label?: string;
+}
+/** Android's `nativeBackgroundAndroid` and `nativeForegroundAndroid`. */
+export type AndroidDrawable = {
+    readonly type: 'RippleAndroid';
+    readonly color?: string | number;
+    readonly borderless?: boolean;
+    readonly rippleRadius?: number;
+} | {
+    readonly type: 'ThemeAttrAndroid';
+    readonly attribute: string;
+};
+export type PointerEvents = 'box-none' | 'none' | 'box-only' | 'auto';
+export type ImportantForAccessibility = 'auto' | 'yes' | 'no' | 'no-hide-descendants';
+export type AccessibilityLiveRegion = 'none' | 'polite' | 'assertive';
+/**
+ * What a directive on the same node says this view *is*, for a screen reader.
+ *
+ * A host primitive knows it is a view; only the thing composed onto it knows it is a button, a
+ * checkbox or an accordion trigger. Without this seam that knowledge has nowhere to go: the role
+ * and the state are written here, from this class's own inputs, and a later `ngOnChanges` would
+ * overwrite anything a directive had set behind its back.
+ *
+ * Registered on the element with `contributeAccessibility`, and several primitives may contribute
+ * to one element - a trigger that is also a button.
+ */
+export interface AccessibilityContribution {
+    /** The role, if this directive implies one. An explicit `role` on the element still wins. */
+    readonly role?: AccessibilityRole;
+    /**
+     * State to merge in, read on every write so it may be a signal read.
+     *
+     * Spelled in full because `state` is what a primitive calls the thing it publishes for a
+     * stylesheet - `data-state="checked"` - and the two are not the same thing.
+     */
+    readonly accessibilityState?: () => AccessibilityState | undefined;
+}
+/**
+ * Tell the primitive on this element what it is, for a screen reader: a role, and state to merge
+ * into what it announces. Call it from a directive's field initialiser or constructor, on the
+ * element the primitive is on:
+ *
+ *     private readonly contribution = contributeAccessibility({ role: 'button' });
+ *     private readonly contribution = contributeAccessibility(this);
+ *
+ * Kept on the node rather than provided through DI, because asking the injector costs every
+ * element on screen a lookup to learn that nothing contributes - about a tenth of creating a list.
+ * Reading a property that is not there costs nothing.
+ */
+export declare function contributeAccessibility<T extends AccessibilityContribution>(contribution: T): T;
+export declare abstract class ViewBase {
+    /** The retained node this directive sits on. */
+    protected readonly node: HostNode;
+    /**
+     * The engine, because the props these inputs carry are written straight onto the node. Read
+     * off the node where the host put it there, which is one property read against an injector
+     * lookup that walks every ancestor element, for every element on screen.
+     */
+    protected readonly engine: HostEngine;
+    /**
+     * See `contributeAccessibility`. Empty for every element nothing is composed onto. Read, never
+     * cached, from `ngOnInit` onwards: by then every directive on the node has been constructed and
+     * registered what it has to say.
+     */
+    private get contributions();
+    constructor();
+    /** Whether `ngOnInit` has run, which is what writes the props every element starts with. */
+    private initialised;
+    /**
+     * Write what the inputs say, for an element whose view has not been checked by the time the
+     * host commits it. Nothing for one that has.
+     *
+     * The props are written from `ngOnChanges` and `ngOnInit`, which Angular runs in the parent
+     * view's update pass. A component that detaches itself before its first check never gets one,
+     * and on the web that pattern still works, because a listener and an attribute are there from
+     * creation. So the host calls this before the commit that first mounts the element, by when its
+     * static inputs are set: the press handling, the role and the `testID` are there, and the view
+     * behaves as written once something calls `detectChanges()`.
+     */
+    settleProps(): void;
+    /** Whether the view is an accessibility element. Defaults to false for a plain view. */
+    readonly accessible: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+    /** What a screen reader announces for the view. */
+    readonly accessibilityLabel: import("@angular/core").InputSignal<string | undefined>;
+    /** `aria-label`: web spelling of `accessibilityLabel`. */
+    readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
+    /** Android: `nativeID`s of the views that label this one. */
+    readonly accessibilityLabelledBy: import("@angular/core").InputSignal<string | readonly string[] | undefined>;
+    /** `aria-labelledby`: web spelling of `accessibilityLabelledBy`. */
+    readonly ariaLabelledBy: import("@angular/core").InputSignal<string | readonly string[] | undefined>;
+    /** What happens when the user acts on the view, when the label alone does not say. */
+    readonly accessibilityHint: import("@angular/core").InputSignal<string | undefined>;
+    /** The kind of control this is, for assistive technologies. */
+    readonly accessibilityRole: import("@angular/core").InputSignal<AccessibilityRole | undefined>;
+    /** `role`: the web spelling of `accessibilityRole`. */
+    readonly role: import("@angular/core").InputSignal<AccessibilityRole | undefined>;
+    /** Disabled, selected, checked, busy and expanded, as one object. */
+    readonly accessibilityState: import("@angular/core").InputSignal<AccessibilityState | undefined>;
+    /** `aria-busy`. */
+    readonly ariaBusy: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+    /** `aria-checked`. */
+    readonly ariaChecked: import("@angular/core").InputSignal<boolean | "mixed" | undefined>;
+    /** `aria-disabled`. */
+    readonly ariaDisabled: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+    /** `aria-expanded`. */
+    readonly ariaExpanded: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+    /** `aria-selected`. */
+    readonly ariaSelected: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+    /** The current value of an adjustable control, for a screen reader. */
+    readonly accessibilityValue: import("@angular/core").InputSignal<AccessibilityValue | undefined>;
+    /** `aria-valuemin`. */
+    readonly ariaValueMin: import("@angular/core").InputSignalWithTransform<number | undefined, unknown>;
+    /** `aria-valuemax`. */
+    readonly ariaValueMax: import("@angular/core").InputSignalWithTransform<number | undefined, unknown>;
+    /** `aria-valuenow`. */
+    readonly ariaValueNow: import("@angular/core").InputSignalWithTransform<number | undefined, unknown>;
+    /** `aria-valuetext`. */
+    readonly ariaValueText: import("@angular/core").InputSignal<string | undefined>;
+    /** Custom actions a screen reader can invoke; each arrives as `(accessibilityAction)`. */
+    readonly accessibilityActions: import("@angular/core").InputSignal<readonly AccessibilityAction[] | undefined>;
+    /** Android: announce changes to this view's content without focus moving to it. */
+    readonly accessibilityLiveRegion: import("@angular/core").InputSignal<AccessibilityLiveRegion | undefined>;
+    /** `aria-live`. */
+    readonly ariaLive: import("@angular/core").InputSignal<AccessibilityLiveRegion | undefined>;
+    /** iOS: hide this view and its children from assistive technologies. */
+    readonly accessibilityElementsHidden: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+    /** `aria-hidden`: `accessibilityElementsHidden` on iOS, `no-hide-descendants` on Android. */
+    readonly ariaHidden: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+    /** Android: whether this view is exposed to accessibility, and whether its children are. */
+    readonly importantForAccessibility: import("@angular/core").InputSignal<ImportantForAccessibility | undefined>;
+    /** iOS: VoiceOver ignores every sibling while this view is shown, as a modal expects. */
+    readonly accessibilityViewIsModal: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+    /** `aria-modal`. */
+    readonly ariaModal: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+    /** iOS: keep the view's colours when the Invert Colors setting is on; images want this. */
+    readonly accessibilityIgnoresInvertColors: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+    /** iOS: the language VoiceOver reads the label in, as a BCP 47 tag. */
+    readonly accessibilityLanguage: import("@angular/core").InputSignal<string | undefined>;
+    /** iOS: the title shown by the Large Content Viewer on a long press with large text on. */
+    readonly accessibilityLargeContentTitle: import("@angular/core").InputSignal<string | undefined>;
+    /** iOS: opt this view into the Large Content Viewer. */
+    readonly accessibilityShowsLargeContentViewer: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+    /** iOS: tell VoiceOver the view responds to a tap even without a role that implies it. */
+    readonly accessibilityRespondsToUserInteraction: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+    /** A handle native code can find the view by; also what `:id` selectors match. */
+    readonly nativeID: import("@angular/core").InputSignal<string | undefined>;
+    /** `id`: the web spelling of `nativeID`. */
+    readonly id: import("@angular/core").InputSignal<string | undefined>;
+    /** A handle for end-to-end test tooling. */
+    readonly testID: import("@angular/core").InputSignal<string | undefined>;
+    /** Extend the touchable area beyond the view's bounds, without moving anything visible. */
+    readonly hitSlop: import("@angular/core").InputSignal<number | Insets | undefined>;
+    /** Whether this view, its children, or neither can be the target of a touch. */
+    readonly pointerEvents: import("@angular/core").InputSignal<PointerEvents | undefined>;
+    /** Set to false to keep a layout-only view alive; Fabric otherwise removes it from the tree. */
+    readonly collapsable: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+    /** Set to false to keep this view's layout-only children from being flattened. */
+    readonly collapsableChildren: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+    /** Detach children that are outside the visible bounds. A scroll view optimisation. */
+    readonly removeClippedSubviews: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+    /** Composite the view offscreen so a translucent view with children blends correctly. */
+    readonly needsOffscreenAlphaCompositing: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+    /** Android: whether the view takes keyboard or TV focus. RN's `tabIndex` is this. */
+    readonly focusable: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+    /** iOS: render the view to a bitmap once and reuse it; for a static view that animates. */
+    readonly shouldRasterizeIOS: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+    /** Android: cache the view in a hardware texture; the same trade as `shouldRasterizeIOS`. */
+    readonly renderToHardwareTextureAndroid: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+    /** Android: a ripple or theme drawable painted behind the view's content. */
+    readonly nativeBackgroundAndroid: import("@angular/core").InputSignal<AndroidDrawable | undefined>;
+    /** Android: a ripple or theme drawable painted over the view's content. */
+    readonly nativeForegroundAndroid: import("@angular/core").InputSignal<AndroidDrawable | undefined>;
+    /**
+     * What React Native's own JavaScript wrapper would have defaulted, per component.
+     *
+     * Driving the native views directly skips those wrappers, and what is lost is invisible: the
+     * app looks identical and is unusable with a screen reader, because nothing on it is an
+     * accessibility element. Each hook is overridden by the component whose wrapper sets it, and
+     * cites the file it came from.
+     */
+    /** True for anything that behaves like a control. `Pressable.js`: `accessible !== false`. */
+    protected accessibleByDefault(): boolean;
+    /** Whether the platform's focus order should include this. `Pressable.js` again. */
+    protected focusableByDefault(): boolean;
+    /** A role the component itself implies. `Switch.js`: `accessibilityRole ?? 'switch'`. */
+    protected roleByDefault(): AccessibilityRole | undefined;
+    /**
+     * The component's own `disabled`, for the state a screen reader announces.
+     *
+     * React Native merges this whenever the prop was passed, even as false. An input here always
+     * has a value, so there is no telling "passed false" from "not passed"; only true is merged,
+     * and a control that is not disabled says nothing rather than saying so on every node.
+     */
+    protected disabledForAccessibility(): boolean | undefined;
+    /**
+     * The component's own `checked`, for a control whose checked state is not an accessibility
+     * input at all - `Switch`'s `checked` is a `model()`, not one of this class's inputs, so it
+     * cannot reach `ngOnChanges` here any more than `disabled` can.
+     */
+    protected checkedForAccessibility(): boolean | 'mixed' | undefined;
+    /**
+     * Write what the inputs say onto the node.
+     *
+     * This is what thirty host bindings used to do, and it is here rather than there for a reason
+     * that was measured: a host binding costs every element that carries it, on every pass, whether
+     * or not the app ever set the prop, and mounting four hundred rows spent a third of its time on
+     * the accessibility surface alone. Angular calls this once with everything that changed instead.
+     *
+     * It works with signal inputs, which is easy to assume it does not: `ngOnChanges` fires for
+     * them as it does for any other input, because `ngOnChangesSetInput` records a `SimpleChange`
+     * before writing the signal. `signal-onchanges.test.ts` is there to keep that fact honest.
+     *
+     * What remains is the allocation - a signal input builds its node whether or not anything binds
+     * to it, and there are forty-six here. Moving prop groups into directives selected by the props
+     * they carry (`[accessibilityLabel], [aria-label], ...`) is how that goes away: an element that
+     * binds none of them would allocate nothing. Measured on a 400-row mount it is worth about 40ms,
+     * at the price of an import per group.
+     */
+    ngOnChanges(_changes?: SimpleChanges): void;
+    private writeAccessibility;
+    /** The half of accessibility that is about what assistive technology may see, and in which language. */
+    private writeVisibility;
+    /**
+     * Writes a prop, and says nothing when it has nothing to say.
+     *
+     * The `undefined` guard is the whole of it, and it fixes a silent failure that had already been
+     * hit twice. These two methods rewrite roughly forty props from this class's own inputs on every
+     * `ngOnChanges`, so anything that reached the node by another route was overwritten the first
+     * time any input changed. Two routes get here without going through an input of this class:
+     *
+     * - A host binding on the composing component. `ui-alert` sets `[accessible]` that way and
+     *   `ui-separator` sets `[accessibilityLabel]`; both are documented as working, and both were
+     *   one input change away from stopping.
+     * - An element property binding. A component whose `hostDirectives` entry lists `disabled` but
+     *   not `nativeID` leaves `[nativeID]` to be applied as a plain property, and then a bound
+     *   `[disabled]` beside it clobbered the id on the next change. `ui-checkbox` carries a
+     *   per-component workaround for that, listing the identity inputs through explicitly, and
+     *   `ui-select-item` and `ui-dropdown-menu-item` do not - which is the shape of a bug that gets
+     *   copied rather than fixed.
+     *
+     * An input that goes back to `undefined` clears the prop only when this is what set it, so a
+     * binding such as `[pointerEvents]="busy() ? 'none' : undefined"` still switches off, and a
+     * prop that arrived by one of those other routes is still never touched. Clearing a *class*
+     * clears the style it brought, because that goes through the cascade rather than through here.
+     */
+    private writer;
+    /** The props `writer` has set from an input, so it can clear one when its input is unset. */
+    private written;
+    private writeIdentity;
+    /**
+     * The defaults a React Native wrapper would have applied, written once when the element is
+     * created. `ngOnChanges` writes them again whenever an input changes, so an app that later
+     * clears a prop falls back to the default rather than to nothing.
+     */
+    /**
+     * The defaults a React Native wrapper would have applied, for an element nothing was bound on.
+     *
+     * In `ngOnInit` rather than the constructor because a hook like `accessibleByDefault` is
+     * answered from the subclass's own inputs - `Text` asks whether it is pressable - and those
+     * fields do not exist yet while the base constructor runs. Each is guarded on its input being
+     * unset, because `ngOnChanges` has already run by now and its answer, which merges the default
+     * in, is the better one.
+     */
+    ngOnInit(): void;
+    /** The first role any directive on this node claims. Two claiming different ones is a bug. */
+    private contributedRole;
+    /** A label the component itself can supply, as `Image` does from `alt`. */
+    protected labelByDefault(): string | undefined;
+    /**
+     * The merged state, for a component whose own inputs feed it - `disabled` on a pressable or a
+     * switch, which is a signal of theirs and so cannot reach `ngOnChanges` here.
+     *
+     * Those components bind this from their host. It returns the *same object* when nothing has
+     * changed, which is what keeps a host binding from marking the node dirty on every pass.
+     */
+    protected accessibilityStateProp(): AccessibilityState | undefined;
+    private lastAccessibilityState;
+    /** Whether anything could put state on this node. For nearly every node on screen, no. */
+    private hasState;
+    private mergedAccessibilityState;
+    private mergedAccessibilityValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ViewBase, never, never, { "accessible": { "alias": "accessible"; "required": false; "isSignal": true; }; "accessibilityLabel": { "alias": "accessibilityLabel"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "accessibilityLabelledBy": { "alias": "accessibilityLabelledBy"; "required": false; "isSignal": true; }; "ariaLabelledBy": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "accessibilityHint": { "alias": "accessibilityHint"; "required": false; "isSignal": true; }; "accessibilityRole": { "alias": "accessibilityRole"; "required": false; "isSignal": true; }; "role": { "alias": "role"; "required": false; "isSignal": true; }; "accessibilityState": { "alias": "accessibilityState"; "required": false; "isSignal": true; }; "ariaBusy": { "alias": "aria-busy"; "required": false; "isSignal": true; }; "ariaChecked": { "alias": "aria-checked"; "required": false; "isSignal": true; }; "ariaDisabled": { "alias": "aria-disabled"; "required": false; "isSignal": true; }; "ariaExpanded": { "alias": "aria-expanded"; "required": false; "isSignal": true; }; "ariaSelected": { "alias": "aria-selected"; "required": false; "isSignal": true; }; "accessibilityValue": { "alias": "accessibilityValue"; "required": false; "isSignal": true; }; "ariaValueMin": { "alias": "aria-valuemin"; "required": false; "isSignal": true; }; "ariaValueMax": { "alias": "aria-valuemax"; "required": false; "isSignal": true; }; "ariaValueNow": { "alias": "aria-valuenow"; "required": false; "isSignal": true; }; "ariaValueText": { "alias": "aria-valuetext"; "required": false; "isSignal": true; }; "accessibilityActions": { "alias": "accessibilityActions"; "required": false; "isSignal": true; }; "accessibilityLiveRegion": { "alias": "accessibilityLiveRegion"; "required": false; "isSignal": true; }; "ariaLive": { "alias": "aria-live"; "required": false; "isSignal": true; }; "accessibilityElementsHidden": { "alias": "accessibilityElementsHidden"; "required": false; "isSignal": true; }; "ariaHidden": { "alias": "aria-hidden"; "required": false; "isSignal": true; }; "importantForAccessibility": { "alias": "importantForAccessibility"; "required": false; "isSignal": true; }; "accessibilityViewIsModal": { "alias": "accessibilityViewIsModal"; "required": false; "isSignal": true; }; "ariaModal": { "alias": "aria-modal"; "required": false; "isSignal": true; }; "accessibilityIgnoresInvertColors": { "alias": "accessibilityIgnoresInvertColors"; "required": false; "isSignal": true; }; "accessibilityLanguage": { "alias": "accessibilityLanguage"; "required": false; "isSignal": true; }; "accessibilityLargeContentTitle": { "alias": "accessibilityLargeContentTitle"; "required": false; "isSignal": true; }; "accessibilityShowsLargeContentViewer": { "alias": "accessibilityShowsLargeContentViewer"; "required": false; "isSignal": true; }; "accessibilityRespondsToUserInteraction": { "alias": "accessibilityRespondsToUserInteraction"; "required": false; "isSignal": true; }; "nativeID": { "alias": "nativeID"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "testID": { "alias": "testID"; "required": false; "isSignal": true; }; "hitSlop": { "alias": "hitSlop"; "required": false; "isSignal": true; }; "pointerEvents": { "alias": "pointerEvents"; "required": false; "isSignal": true; }; "collapsable": { "alias": "collapsable"; "required": false; "isSignal": true; }; "collapsableChildren": { "alias": "collapsableChildren"; "required": false; "isSignal": true; }; "removeClippedSubviews": { "alias": "removeClippedSubviews"; "required": false; "isSignal": true; }; "needsOffscreenAlphaCompositing": { "alias": "needsOffscreenAlphaCompositing"; "required": false; "isSignal": true; }; "focusable": { "alias": "focusable"; "required": false; "isSignal": true; }; "shouldRasterizeIOS": { "alias": "shouldRasterizeIOS"; "required": false; "isSignal": true; }; "renderToHardwareTextureAndroid": { "alias": "renderToHardwareTextureAndroid"; "required": false; "isSignal": true; }; "nativeBackgroundAndroid": { "alias": "nativeBackgroundAndroid"; "required": false; "isSignal": true; }; "nativeForegroundAndroid": { "alias": "nativeForegroundAndroid"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * `ViewBase` on its own, for a component whose host is a plain view.
+ *
+ * No selector: this is only ever a `hostDirectives` entry, and it is the counterpart to
+ * `PressBehavior` for the parts of a control that do not take a touch. A radio group is the case
+ * that asked for it - it announces itself as a group and holds a value, but pressing it means
+ * nothing, and without a `ViewBase` on the node there is nothing to write that role.
+ */
+export declare class ViewBehavior extends ViewBase {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewBehavior, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ViewBehavior, never, never, {}, {}, never, never, true, never>;
+}