DOM mixin

import { artefact } from '../core/library.js';

import { setMouseChanged } from '../helper/system-flags.js';

import { correctAngle, isa_dom, isa_fn, isa_obj, isa_quaternion, mergeOver, pushUnique, removeItem, xt, xta, λnull, Ωempty } from '../helper/utilities.js';

import { addLocalMouseMoveListener, currentCorePosition, removeLocalMouseMoveListener, uiSubscribedElements } from '../core/user-interaction.js';

import { addDomShowElement, setDomShowRequired } from '../core/document.js';

import { makeQuaternion, releaseQuaternion, requestQuaternion } from '../untracked-factory/quaternion.js';

import { releaseCell, requestCell } from '../untracked-factory/cell-fragment.js';

import positionMix from './position.js';
import deltaMix from './delta.js';
import pivotMix from './pivot.js';
import mimicMix from './mimic.js';
import pathMix from './path.js';

import { _entries, _isArray, _isFinite, _round, ABSOLUTE, ARIA_HIDDEN, BORDER_BOX, CORNER_LABELS, CORNER_SELECTOR, DIV, MIMIC, MOUSE, PARTICLE, PATH, PC0, PC100, PIVOT, SPACE, T_STACK, TRUE, ZERO_STR } from '../helper/shared-vars.js'

const BOTTOMLEFT = 'bottomLeft',
    BOTTOMRIGHT = 'bottomRight',
    CLASS_REGEX = /[\s\uFEFF\xA0]+/g,
    CORNER_ATTR = 'data-scrawl-corner-div',
    CORNER_ATTR_VAL = 'sc',
    LOCAL = 'local',
    TABINDEX = 'tabindex',
    TOPLEFT = 'topLeft',
    TOPRIGHT = 'topRight';

const PERMITTED_TRACKED_ELEMENTS = ['ARTICLE', 'ASIDE', 'DIV', 'FOOTER', 'HEADER', 'MAIN', 'NAV', 'SECTION', 'ADDRESS', 'BLOCKQUOTE', 'DL', 'FIGURE', 'FORM', 'H1', 'H2', 'H3', 'H4', 'H5', 'H6', 'HGROUP', 'MENU', 'METER', 'OL', 'P', 'PRE', 'PROGRESS', 'SEARCH', 'SELECT', 'TABLE', 'TEXTAREA', 'UL', 'OUTPUT'];

export default function (P = Ωempty) {

    positionMix(P);
    deltaMix(P);
    pivotMix(P);
    mimicMix(P);
    pathMix(P);

    const defaultAttributes = {

        domElement: ZERO_STR,

        pitch: 0,
        yaw: 0,

        offsetZ: 0,

        css: null,

        classes: ZERO_STR,

        position: ABSOLUTE,

        checkForResize: false,

        trackHere: ZERO_STR,

        activePadding: 5,

        includeInTabNavigation: false,

        moreContrastAction: null,
        otherContrastAction: null,
        reduceMotionAction: null,
        noPreferenceMotionAction: null,
        colorSchemeLightAction: null,
        colorSchemeDarkAction: null,
        reduceTransparencyAction: null,
        noPreferenceTransparencyAction: null,
        reduceDataAction: null,
        noPreferenceDataAction: null,
        invertedColorsAction: null,
        normalColorsAction: null,
        noForcedColorsAction: null,
        activeForcedColorsAction: null,
    };
    P.defs = mergeOver(P.defs, defaultAttributes);

    P.packetExclusions = pushUnique(P.packetExclusions, ['domElement', 'pathCorners', 'rotation']);
    P.packetFunctions = pushUnique(P.packetFunctions, ['onEnter', 'onLeave', 'onDown', 'onUp']);

    P.processDOMPacketOut = function (key, value, incs) {

        return this.processFactoryPacketOut(key, value, incs);
    };

    P.processFactoryPacketOut = function (key, value, incs) {

        let result = true;

        if(!incs.includes(key) && value === this.defs[key]) result = false;

        return result;
    };

    P.finalizePacketOut = function (copy, items) {

        if (isa_dom(this.domElement)) {

            const el = this.domElement;
            const node = el.cloneNode(true);

            const kids = node.querySelectorAll(CORNER_SELECTOR);
            kids.forEach(kid => node.removeChild(kid));

            copy.outerHTML = node.outerHTML;
            copy.host = el.parentElement.id;
        }

        copy = this.handlePacketAnchor(copy, items);

        return copy;
    };

    const S = P.setters,
        D = P.deltaSetters;

    S.trackHere = function(val) {

        if (xt(val)) {

            if (val) {

                pushUnique(uiSubscribedElements, this.name);

                if (val === LOCAL) addLocalMouseMoveListener(this);
            }
            else {

                removeItem(uiSubscribedElements, this.name);
                removeLocalMouseMoveListener(this);
            }
            this.trackHere = val;
        }
    };

    S.position = function (item) {

        this.position = item;
        this.dirtyPosition = true;
    };

    S.visibility = function (item) {

        this.visibility = item;
        this.dirtyVisibility = true;
    };

    S.offsetZ = function (item) {

        this.offsetZ = item;
        this.dirtyOffsetZ = true;
    };

    D.offsetZ = function (item) {

        this.offsetZ += item;
        this.dirtyOffsetZ = true;
    };

    S.roll = function (item) {

        this.roll = correctAngle(item);
        this.dirtyRotation = true;
    };
    D.roll = function (item) {

        this.roll = correctAngle(this.roll + item);
        this.dirtyRotation = true;
    };

    S.pitch = function (item) {

        this.pitch = correctAngle(item);
        this.dirtyRotation = true;
    };
    D.pitch = function (item) {

        this.pitch = correctAngle(this.pitch + item);
        this.dirtyRotation = true;
    };

    S.yaw = function (item) {

        this.yaw = correctAngle(item);
        this.dirtyRotation = true;
    };
    D.yaw = function (item) {

        this.yaw = correctAngle(this.yaw + item);
        this.dirtyRotation = true;
    };

    S.css = function (item) {

        this.css = (this.css) ? mergeOver(this.css, item) : item;
        this.dirtyCss = true;
    };

    S.classes = function (item) {

        this.classes = item;
        this.dirtyClasses = true;
    };

    S.stampOrder = function (item) {

        this.stampOrder = item;
        this.dirtyStampOrder = true;
    };

    S.domAttributes = function (item) {

        this.updateDomAttributes(item);
    };

    S.includeInTabNavigation = function (item) {

        const el = this.domElement;

        if (el) {

            this.includeInTabNavigation = item;

            if (item) el.setAttribute(TABINDEX, 0);
            else el.setAttribute(TABINDEX, -1);
        }
    };

    P.updateDomAttributes = function (key, val) {

        const el = this.domElement;

        if (el) {

            if (key.substring && xt(val)) {

                if (xt(val) && val) el.setAttribute(key, val);
                else el.removeAttribute(key);
            }
            else if (isa_obj(key)) {

                _entries(key).forEach(([k, v]) => {

                    if (xt(v) && v) el.setAttribute(k, v);
                    else el.removeAttribute(k);
                });
            }
        }
        return this;
    };

    P.initializeDomLayout = function (items) {

        const el = items.domElement;

        if (el) {

            const style = el.style;

            style.boxSizing = BORDER_BOX;

            if (items.setInitialDimensions) {

                const dims = el.getBoundingClientRect();

                this.currentDimensions[0] = dims.width;
                this.currentDimensions[1] = dims.height;
                items.width = dims.width;
                items.height = dims.height;

                if (el.className) items.classes = el.className;

                let host = false;

                if (items && items.host) {

                    host = items.host;

                    if (host && host.substring && artefact[host]) host = artefact[host];
                }

                if (host && host.domElement) {

                    const hostDims = host.domElement.getBoundingClientRect();

                    if (hostDims) {

                        items.startX = dims.left - hostDims.left;
                        items.startY = dims.top - hostDims.top;
                    }
                }

                if (this.type === T_STACK) {

                    const pStyle = parseFloat(style.perspective);
                    const {perspective, perspectiveX, perspectiveY, perspectiveZ} = items;

                    if (!xta(perspective, perspectiveZ)) {

                        items.perspectiveZ = (_isFinite(pStyle)) ? pStyle : 0;
                    }

                    const pOrigin = style.perspectiveOrigin;

                    if (pOrigin.length) {

                        const [pX, pY] = pOrigin.split(SPACE);

                        if (!xta(perspective, perspectiveX)) items.perspectiveX = pX;
                        if (!xta(perspective, perspectiveY)) items.perspectiveY = pY;
                    }
                }
            }
        }
    };

    P.addClasses = function (item) {

        if (item.substring) {

            const classes = `${this.classes}  ${item}`.trim().replace(CLASS_REGEX, SPACE);

            if (classes !== this.classes) {

                this.classes = classes;
                this.dirtyClasses = true;
            }
        }
        return this;
    };

    P.removeClasses = function (item) {

        if (item.substring) {

            const targets = item.split(' ');

            let classes = this.classes,
                search;

            targets.forEach(cls => {

                search = new RegExp(' ?' + cls + ' ?');
                classes = classes.replace(search, SPACE);
                classes = classes.trim();
                classes = classes.replace(CLASS_REGEX, SPACE);
            });

            if (classes !== this.classes) {

                this.classes = classes;
                this.dirtyClasses = true;
            }
        }
        return this;
    };

    P.addPathCorners = function () {

        const el = this.domElement;

        if (el && !this.noUserInteraction && PERMITTED_TRACKED_ELEMENTS.includes(el.tagName)) {

            const pointMaker = function () {

                const p = document.createElement(DIV);
                const s = p.style;

                s.width = 0;
                s.height = 0;
                s.position = ABSOLUTE;
                s.margin = 0;
                s.border = 0;
                s.padding = 0;

                p.setAttribute(CORNER_ATTR, CORNER_ATTR_VAL);
                p.setAttribute(ARIA_HIDDEN, TRUE);

                return p;
            };

            const corners = this.pathCorners;

            const tl = pointMaker(),
                tr = pointMaker(),
                br = pointMaker(),
                bl = pointMaker();

            tl.style.top = PC0;
            tl.style.left = PC0;

            tr.style.top = PC0;
            tr.style.left = PC100;

            br.style.top = PC100;
            br.style.left = PC100;

            bl.style.top = PC100;
            bl.style.left = PC0;

            el.appendChild(tl);
            el.appendChild(tr);
            el.appendChild(br);
            el.appendChild(bl);

            corners.push(tl);
            corners.push(tr);
            corners.push(br);
            corners.push(bl);

            if (!this.currentCornersData) this.currentCornersData = [];
        }
        return this;
    };

    P.checkCornerPositions = function (corner) {

        const pathCorners = this.pathCorners;

        if (pathCorners.length === 4) {

            const here = this.getHere(),
                x = currentCorePosition.scrollX - (here.offsetX || 0),
                y = currentCorePosition.scrollY - (here.offsetY || 0),
                results = [];

            let client, coord;

            const cornerPush = function (c) {

                coord = c[0];

                if (coord) {

                    results.push(_round(coord.left + x));
                    results.push(_round(coord.top + y));
                }
                else results.push(0, 0);
            };

            switch (corner) {

                case TOPLEFT :

                    client = pathCorners[0].getClientRects();
                    cornerPush(client);
                    return results;

                case TOPRIGHT :

                    client = pathCorners[1].getClientRects();
                    cornerPush(client);
                    return results;

                case BOTTOMRIGHT :

                    client = pathCorners[2].getClientRects();
                    cornerPush(client);
                    return results;

                case BOTTOMLEFT :

                    client = pathCorners[3].getClientRects();
                    cornerPush(client);
                    return results;

                default :

                    pathCorners.forEach(point => {

                        if (isa_dom(point)) {

                            client = point.getClientRects();
                            cornerPush(client);
                        }
                    });
                    return results;
            }
        }
    }

    P.getCornerCoordinate = function (corner) {

        if (CORNER_LABELS.includes(corner)) return this.checkCornerPositions(corner);
        else return [].concat(this.currentStampPosition);
    };

    P.cleanPathObject = function () {

        this.dirtyPathObject = false;

        if (this.domElement && !this.noUserInteraction) {

            if (!this.pathCorners.length) this.addPathCorners();

            if (this.pathCorners.length) {

                if (!this.currentCornersData) this.currentCornersData = [];

                const cornerData = this.currentCornersData;
                cornerData.length = 0;
                cornerData.push(...this.checkCornerPositions());

                const p = this.pathObject = new Path2D();
                p.moveTo(cornerData[0], cornerData[1]);
                p.lineTo(cornerData[2], cornerData[3]);
                p.lineTo(cornerData[4], cornerData[5]);
                p.lineTo(cornerData[6], cornerData[7]);
                p.closePath();
            }
            else {
                const p = this.pathObject = new Path2D();
                p.moveTo(0, 0);
                p.lineTo(10, 0);
                p.lineTo(0, 10);
                p.lineTo(-10, 0);
                p.closePath();
            }
        }
    };

    P.checkHit = function (items = []) {

        if (this.noUserInteraction) return false;

        if (!this.pathObject || this.dirtyPathObject) this.cleanPathObject();

        const tests = (!_isArray(items)) ?  [items] : items;

        const mycell = requestCell(),
            engine = mycell.engine;

        let tx, ty;

        if (tests.some(test => {

            if (_isArray(test)) {

                tx = test[0];
                ty = test[1];
            }
            else if (xta(test, test.x, test.y)) {

                tx = test.x;
                ty = test.y;
            }
            else return false;

            if (!_isFinite(tx) || !_isFinite(ty)) return false;

            return engine.isPointInPath(this.pathObject, tx, ty);

        }, this)) {

            releaseCell(mycell);

            return {
                x: tx,
                y: ty,
                artefact: this,
            };
        }

        releaseCell(mycell);
        return false;
    };

    P.cleanRotation = function () {

        this.dirtyRotation = false;

        if (!this.rotation || !isa_quaternion(this.rotation)) this.rotation = makeQuaternion();

        if (!this.currentRotation || !isa_quaternion(this.rotation)) this.currentRotation = makeQuaternion();

        const calculatedRotation = this.rotation;

        calculatedRotation.setFromEuler({
            pitch: this.pitch || 0,
            yaw: this.yaw || 0,
            roll: this.roll || 0,
        });

        if (calculatedRotation.getMagnitude() !== 1) calculatedRotation.normalize();

        const processedRotation = requestQuaternion(),
            path = this.path,
            mimic = this.mimic,
            pivot = this.pivot,
            lock = this.lockTo;

        if (path && lock.includes(PATH)) {

            processedRotation.set(calculatedRotation);

        }
        else if (mimic && this.useMimicRotation && lock.includes(MIMIC)) {

            if (xt(mimic.currentRotation)) {

                processedRotation.set(mimic.currentRotation);
                if (this.addOwnRotationToMimic) processedRotation.quaternionRotate(calculatedRotation);
            }
            else this.dirtyMimicRotation = true;
        }
        else {

            processedRotation.set(calculatedRotation);

            if (pivot && this.addPivotRotation && lock.includes(PIVOT)) {

                if (xt(pivot.currentRotation)) processedRotation.quaternionRotate(pivot.currentRotation);
                else this.dirtyPivotRotation = true;
            }
        }

        this.currentRotation.set(processedRotation);

        releaseQuaternion(processedRotation);

        this.dirtyPositionSubscribers = true;

        if (this.mimicked && this.mimicked.length) this.dirtyMimicRotation = true;
    };

    P.cleanOffsetZ = function () {

        this.dirtyOffsetZ = false;
    };

    P.cleanContent = function () {

        this.dirtyContent = false;

        if (this.domElement) this.dirtyDimensions = true;
    };

    P.cleanDisplayShape = λnull;

    P.cleanDisplayArea = λnull;

    P.prepareStamp = function () {

        if (this.dirtyScale || this.dirtyDimensions || this.dirtyStart || this.dirtyOffset || this.dirtyHandle || this.dirtyRotation) this.dirtyPathObject = true;

        if (this.dirtyContent) this.cleanContent();
        if (this.dirtyScale) this.cleanScale();
        if (this.dirtyDimensions) this.cleanDimensions();
        if (this.dirtyDisplayArea) this.cleanDisplayArea();
        if (this.dirtyDisplayShape) this.cleanDisplayShape();
        if (this.dirtyLock) this.cleanLock();
        if (this.dirtyStart) this.cleanStart();
        if (this.dirtyOffset) this.cleanOffset();
        if (this.dirtyOffsetZ) this.cleanOffsetZ();
        if (this.dirtyHandle) this.cleanHandle();
        if (this.dirtyRotation) this.cleanRotation();

        if (this.isBeingDragged || this.lockTo.includes(MOUSE) || this.lockTo.includes(PARTICLE)) {

            this.dirtyStampPositions = true;
            this.dirtyStampHandlePositions = true;
        }

        if (this.pivoted.length) this.dirtyStampPositions = true;

        if (this.dirtyStampPositions) this.cleanStampPositions();
        if (this.dirtyStampHandlePositions) this.cleanStampHandlePositions();

        if (this.dirtyPathObject) this.cleanPathObject();

        this.prepareStampAdditionalActions();
    };

    P.prepareStampAdditionalActions = λnull;

    P.stamp = function () {

        if (!this.domElement) return false;

        const [stampX, stampY] = this.currentStampPosition,
            [handleX, handleY] = this.currentStampHandlePosition,
            scale = this.currentScale,
            rotation = this.currentRotation;

        const nTransformOrigin = `${handleX}px ${handleY}px 0`;

        let nTransform = `translate(${stampX - handleX}px,${stampY - handleY}px)`;

        if (this.yaw || this.pitch || this.roll || (this.pivot && this.addPivotRotation) || (this.mimic && this.useMimicRotation) || (this.path && this.addPathRotation)) {

            const v = rotation.v,
                vx = v.x,
                vy = v.y,
                vz = v.z,
                angle = rotation.getAngle(false);

            nTransform += ` rotate3d(${vx},${vy},${vz},${angle}rad)`;
        }

        if (this.offsetZ) nTransform += ` translateZ(${this.offsetZ}px)`;

        if (scale !== 1) nTransform += ` scale(${scale},${scale})`;

        if (nTransform !== this.currentTransformString) {

            this.currentTransformString = nTransform;
            this.dirtyTransform = true;
        }

        if (nTransformOrigin !== this.currentTransformOriginString) {

            this.currentTransformOriginString = nTransformOrigin;
            this.dirtyTransformOrigin = true;
        }

        if (this.dirtyTransform || this.dirtyPerspective || this.dirtyPosition || this.dirtyDomDimensions || this.dirtyTransformOrigin || this.dirtyVisibility || this.dirtyCss || this.dirtyClasses || this.dirtyStampOrder || this.domShowRequired) {

            this.domShowRequired = false;
            addDomShowElement(this.name);
            setDomShowRequired(true);
            setMouseChanged(true);
        }

        if (this.dirtyPositionSubscribers) this.updatePositionSubscribers();

        if(this.dirtyMimicRotation || this.dirtyPivotRotation) {

            this.dirtyMimicRotation = false;
            this.dirtyPivotRotation = false;
            this.dirtyRotation = true;
        }

        if(this.dirtyMimicScale) {

            this.dirtyMimicScale = false;
            this.dirtyScale = true;
        }
    };

    P.initializeAccessibility = function () {

        this.reduceMotionAction = λnull;
        this.noPreferenceMotionAction = λnull;
        this.colorSchemeLightAction = λnull;
        this.colorSchemeDarkAction = λnull;
        this.reduceTransparencyAction = λnull;
        this.noPreferenceTransparencyAction = λnull;
        this.reduceDataAction = λnull;
        this.noPreferenceDataAction = λnull;
        this.moreContrastAction = λnull;
        this.otherContrastAction = λnull;
        this.invertedColorsAction = λnull;
        this.normalColorsAction = λnull;
        this.noForcedColorsAction = λnull;
        this.activeForcedColorsAction = λnull;
    };

    S.moreContrastAction = function (item) {
        if (isa_fn(item)) this.moreContrastAction = item;
    };
    P.setMoreContrastAction = function (item) {
        if (isa_fn(item)) this.moreContrastAction = item;
    };
    S.otherContrastAction = function (item) {
        if (isa_fn(item)) this.otherContrastAction = item;
    };
    P.setOtherContrastAction = function (item) {
        if (isa_fn(item)) this.otherContrastAction = item;
    };
    P.contrastActions = function () {

        const here = this.here;

        if (xt(here)) {

            const accessibilityFlag = here.prefersContrast;

            if (xt(accessibilityFlag)) {

                if (accessibilityFlag) this.moreContrastAction();
                else this.otherContrastAction();
            }
        }
    };

    S.reduceMotionAction = function (item) {
        if (isa_fn(item)) this.reduceMotionAction = item;
    };
    P.setReduceMotionAction = function (item) {
        if (isa_fn(item)) this.reduceMotionAction = item;
    };
    S.noPreferenceMotionAction = function (item) {
        if (isa_fn(item)) this.noPreferenceMotionAction = item;
    };
    P.setNoPreferenceMotionAction = function (item) {
        if (isa_fn(item)) this.noPreferenceMotionAction = item;
    };
    P.reducedMotionActions = function () {

        const here = this.here;

        if (xt(here)) {

            const accessibilityFlag = here.prefersReducedMotion;

            if (xt(accessibilityFlag)) {

                if (accessibilityFlag) this.reduceMotionAction();
                else this.noPreferenceMotionAction();
            }
        }
    };

    S.colorSchemeLightAction = function (item) {
        if (isa_fn(item)) this.colorSchemeLightAction = item;
    };
    P.setColorSchemeLightAction = function (item) {
        if (isa_fn(item)) this.colorSchemeLightAction = item;
    };
    S.colorSchemeDarkAction = function (item) {
        if (isa_fn(item)) this.colorSchemeDarkAction = item;
    };
    P.setColorSchemeDarkAction = function (item) {
        if (isa_fn(item)) this.colorSchemeDarkAction = item;
    };
    P.colorSchemeActions = function () {

        const here = this.here;

        if (xt(here)) {

            const flag = here.prefersDarkColorScheme;

            if (xt(flag)) {

                if (flag) this.colorSchemeDarkAction();
                else this.colorSchemeLightAction();
            }
        }
    };

    S.reduceTransparencyAction = function (item) {
        if (isa_fn(item)) this.reduceTransparencyAction = item;
    };
    P.setReduceTransparencyAction = function (item) {
        if (isa_fn(item)) this.reduceTransparencyAction = item;
    };
    S.noPreferenceTransparencyAction = function (item) {
        if (isa_fn(item)) this.noPreferenceTransparencyAction = item;
    };
    P.setNoPreferenceTransparencyAction = function (item) {
        if (isa_fn(item)) this.noPreferenceTransparencyAction = item;
    };
    P.reducedTransparencyActions = function () {

        const here = this.here;

        if (xt(here)) {

            const flag = here.prefersReduceTransparency;

            if (xt(flag)) {

                if (flag) this.reduceTransparencyAction();
                else this.noPreferenceTransparencyAction();
            }
        }
    };

    S.reduceDataAction = function (item) {
        if (isa_fn(item)) this.reduceDataAction = item;
    };
    P.setReduceDataAction = function (item) {
        if (isa_fn(item)) this.reduceDataAction = item;
    };
    S.noPreferenceDataAction = function (item) {
        if (isa_fn(item)) this.noPreferenceDataAction = item;
    };
    P.setNoPreferenceDataAction = function (item) {
        if (isa_fn(item)) this.noPreferenceDataAction = item;
    };
    P.reducedDataActions = function () {

        const here = this.here;

        if (xt(here)) {

            const flag = here.prefersReduceData;

            if (xt(flag)) {

                if (flag) this.reduceDataAction();
                else this.noPreferenceDataAction();
            }
        }
    };

    S.invertedColorsAction = function (item) {
        if (isa_fn(item)) this.invertedColorsAction = item;
    };
    P.setInvertedColorsAction = function (item) {
        if (isa_fn(item)) this.invertedColorsAction = item;
    };
    S.normalColorsAction = function (item) {
        if (isa_fn(item)) this.normalColorsAction = item;
    };
    P.setNormalColorsAction = function (item) {
        if (isa_fn(item)) this.normalColorsAction = item;
    };
    P.invertedColorsActions = function () {

        const here = this.here;

        if (xt(here)) {

            const flag = here.prefersInvertedColors;

            if (xt(flag)) {

                if (flag) this.invertedColorsAction();
                else this.normalColorsAction();
            }
        }
    };

    S.noForcedColorsAction = function (item) {
        if (isa_fn(item)) this.noForcedColorsAction = item;
    };
    P.setNoForcedColorsAction = function (item) {
        if (isa_fn(item)) this.noForcedColorsAction = item;
    };
    S.activeForcedColorsAction = function (item) {
        if (isa_fn(item)) this.activeForcedColorsAction = item;
    };
    P.setActiveForcedColorsAction = function (item) {
        if (isa_fn(item)) this.activeForcedColorsAction = item;
    };
    P.forcedColorsActions = function () {

        const here = this.here;

        if (xt(here)) {

            const accessibilityFlag = here.prefersForcedColors;

            if (xt(accessibilityFlag)) {

                if (accessibilityFlag) this.activeForcedColorsAction();
                else this.noForcedColorsAction();
            }
        }
    };

    P.checkAccessibilityValues = function () {

        this.contrastActions();
        this.reducedMotionActions();
        this.colorSchemeActions();
        this.reducedTransparencyActions();
        this.reducedDataActions();
        this.invertedColorsActions();
        this.forcedColorsActions()
    };
}