vision-accessibility 1.0.0

package/dist/index.esm.js

@@ -0,0 +1,1151 @@
+import require$$0, { useCallback, useState, useEffect, createContext, useContext, useRef } from "react";
+const DEFAULT_ACCESSIBILITY_SETTINGS = {
+  isEnabled: false,
+  colorScheme: "standard",
+  fontSize: "standard",
+  showImages: true
+};
+const STORAGE_KEY = "accessibility-settings";
+const saveToStorage = (settings) => {
+  try {
+    if (typeof window === "undefined") return;
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(settings));
+  } catch (error) {
+    console.warn("Не удалось сохранить настройки доступности:", error);
+  }
+};
+const loadFromStorage = () => {
+  try {
+    if (typeof window === "undefined") return null;
+    const saved = localStorage.getItem(STORAGE_KEY);
+    return saved ? validateSettings(JSON.parse(saved)) : null;
+  } catch (error) {
+    console.warn("Не удалось загрузить настройки доступности:", error);
+    return null;
+  }
+};
+const clearStorage = () => {
+  try {
+    if (typeof window === "undefined") return;
+    localStorage.removeItem(STORAGE_KEY);
+  } catch (error) {
+    console.warn("Не удалось очистить настройки доступности:", error);
+  }
+};
+const validateSettings = (settings) => {
+  if (!settings || typeof settings !== "object") {
+    return DEFAULT_ACCESSIBILITY_SETTINGS;
+  }
+  const s = settings;
+  return {
+    isEnabled: typeof s.isEnabled === "boolean" ? s.isEnabled : DEFAULT_ACCESSIBILITY_SETTINGS.isEnabled,
+    colorScheme: ["standard", "high-contrast", "grayscale"].includes(s.colorScheme) ? s.colorScheme : DEFAULT_ACCESSIBILITY_SETTINGS.colorScheme,
+    fontSize: ["small", "standard", "large"].includes(s.fontSize) ? s.fontSize : DEFAULT_ACCESSIBILITY_SETTINGS.fontSize,
+    showImages: typeof s.showImages === "boolean" ? s.showImages : DEFAULT_ACCESSIBILITY_SETTINGS.showImages
+  };
+};
+const safeLocalStorageOperation = (operation, fallback, errorMessage) => {
+  try {
+    return operation();
+  } catch (error) {
+    console.warn(errorMessage, error);
+    return fallback;
+  }
+};
+const TEXT_ELEMENTS_SELECTOR = "h1, h2, h3, h4, h5, h6, p, span, a, button, label, li";
+const IMAGE_ELEMENTS_SELECTOR = 'img, picture, svg[role="img"]';
+const getTextElements = () => {
+  if (typeof document === "undefined") {
+    return [];
+  }
+  return document.querySelectorAll(TEXT_ELEMENTS_SELECTOR);
+};
+const getImageElements = () => {
+  if (typeof document === "undefined") {
+    return [];
+  }
+  return document.querySelectorAll(IMAGE_ELEMENTS_SELECTOR);
+};
+const applyClassToElements = (elements, className) => {
+  elements.forEach((element) => {
+    if (element && element.classList) {
+      element.classList.add(className);
+    }
+  });
+};
+const removeClassFromElements = (elements, className) => {
+  elements.forEach((element) => {
+    if (element && element.classList) {
+      element.classList.remove(className);
+    }
+  });
+};
+const safeDOMOperation = (operation, errorMessage) => {
+  try {
+    if (typeof window === "undefined") return;
+    operation();
+  } catch (error) {
+    console.warn(errorMessage, error);
+  }
+};
+const isDOMAvailable = () => {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+};
+const ORIGINAL_FONT_SIZE_ATTR = "data-original-font-size";
+const FONT_SIZE_MULTIPLIERS = {
+  small: 0.8,
+  // 80% от оригинального размера
+  standard: 1,
+  // 100% - оригинальный размер
+  large: 1.3
+  // 130% от оригинального размера
+};
+const getComputedFontSize = (element) => {
+  const computedStyle = window.getComputedStyle(element);
+  const fontSize = computedStyle.fontSize;
+  return parseFloat(fontSize);
+};
+const saveOriginalFontSize = (element) => {
+  if (!element.hasAttribute(ORIGINAL_FONT_SIZE_ATTR)) {
+    const originalSize = getComputedFontSize(element);
+    element.setAttribute(ORIGINAL_FONT_SIZE_ATTR, originalSize.toString());
+  }
+};
+const getOriginalFontSize = (element) => {
+  const savedSize = element.getAttribute(ORIGINAL_FONT_SIZE_ATTR);
+  if (savedSize) {
+    return parseFloat(savedSize);
+  }
+  const currentSize = getComputedFontSize(element);
+  element.setAttribute(ORIGINAL_FONT_SIZE_ATTR, currentSize.toString());
+  return currentSize;
+};
+const applyFontSizeToElement = (element, newSize) => {
+  element.style.fontSize = `${newSize}px`;
+};
+const resetElementFontSize = (element) => {
+  element.style.fontSize = "";
+  element.removeAttribute(ORIGINAL_FONT_SIZE_ATTR);
+};
+const applyDynamicFontSize = (size) => {
+  safeDOMOperation(() => {
+    if (!isDOMAvailable()) return;
+    const elements = getTextElements();
+    const multiplier = FONT_SIZE_MULTIPLIERS[size];
+    elements.forEach((element) => {
+      try {
+        if (size === "standard") {
+          resetElementFontSize(element);
+        } else {
+          saveOriginalFontSize(element);
+          const originalSize = getOriginalFontSize(element);
+          const newSize = originalSize * multiplier;
+          applyFontSizeToElement(element, newSize);
+        }
+      } catch (error) {
+        console.warn("Ошибка при изменении размера шрифта элемента:", element, error);
+      }
+    });
+  }, `Ошибка при применении динамического размера шрифта: ${size}`);
+};
+const resetAllFontSizes = () => {
+  safeDOMOperation(() => {
+    if (!isDOMAvailable()) return;
+    const elements = getTextElements();
+    elements.forEach((element) => {
+      try {
+        resetElementFontSize(element);
+      } catch (error) {
+        console.warn("Ошибка при сбросе размера шрифта элемента:", element, error);
+      }
+    });
+  }, "Ошибка при сбросе всех размеров шрифта");
+};
+const updateNewElementsFontSize = (size) => {
+  if (size === "standard") return;
+  safeDOMOperation(() => {
+    if (!isDOMAvailable()) return;
+    const elements = getTextElements();
+    const multiplier = FONT_SIZE_MULTIPLIERS[size];
+    elements.forEach((element) => {
+      if (!element.hasAttribute(ORIGINAL_FONT_SIZE_ATTR) && !element.style.fontSize) {
+        try {
+          saveOriginalFontSize(element);
+          const originalSize = getOriginalFontSize(element);
+          const newSize = originalSize * multiplier;
+          applyFontSizeToElement(element, newSize);
+        } catch (error) {
+          console.warn("Ошибка при обновлении размера шрифта нового элемента:", element, error);
+        }
+      }
+    });
+  }, `Ошибка при обновлении размера шрифта новых элементов: ${size}`);
+};
+const isFontSizeModified = () => {
+  if (!isDOMAvailable()) return false;
+  const elements = getTextElements();
+  for (let i = 0; i < Math.min(elements.length, 10); i++) {
+    if (elements[i].hasAttribute(ORIGINAL_FONT_SIZE_ATTR)) {
+      return true;
+    }
+  }
+  return false;
+};
+const CSS_CLASSES = {
+  HIGH_CONTRAST: "accessibility-high-contrast",
+  FONT_SMALL: "accessibility-font-small",
+  FONT_LARGE: "accessibility-font-large",
+  HIDE_IMAGES: "accessibility-hide-images"
+};
+const applyColorScheme = (scheme) => {
+  safeDOMOperation(() => {
+    if (!isDOMAvailable()) return;
+    document.body.classList.remove(CSS_CLASSES.HIGH_CONTRAST);
+    document.body.style.filter = "";
+    switch (scheme) {
+      case "high-contrast":
+        document.body.classList.add(CSS_CLASSES.HIGH_CONTRAST);
+        break;
+      case "grayscale":
+        document.body.style.filter = "grayscale(100%)";
+        break;
+      case "standard":
+        break;
+      default:
+        console.warn(`Неизвестная цветовая схема: ${scheme}`);
+        break;
+    }
+  }, `Ошибка при применении цветовой схемы: ${scheme}`);
+};
+const applyFontSize = (size) => {
+  applyDynamicFontSize(size);
+};
+const applyImageVisibility = (showImages) => {
+  safeDOMOperation(() => {
+    if (!isDOMAvailable()) return;
+    const elements = getImageElements();
+    if (showImages) {
+      removeClassFromElements(elements, CSS_CLASSES.HIDE_IMAGES);
+    } else {
+      applyClassToElements(elements, CSS_CLASSES.HIDE_IMAGES);
+    }
+  }, `Ошибка при управлении отображением изображений: ${showImages}`);
+};
+const removeAllAccessibilityStyles = () => {
+  safeDOMOperation(() => {
+    if (!isDOMAvailable()) return;
+    document.body.classList.remove(CSS_CLASSES.HIGH_CONTRAST);
+    document.body.classList.remove(CSS_CLASSES.FONT_SMALL);
+    document.body.classList.remove(CSS_CLASSES.FONT_LARGE);
+    document.body.style.filter = "";
+    resetAllFontSizes();
+    const imageElements = getImageElements();
+    removeClassFromElements(imageElements, CSS_CLASSES.HIDE_IMAGES);
+  }, "Ошибка при удалении всех стилей доступности");
+};
+const applyAllSettings = (settings) => {
+  if (!settings.isEnabled) {
+    removeAllAccessibilityStyles();
+    return;
+  }
+  applyColorScheme(settings.colorScheme);
+  applyFontSize(settings.fontSize);
+  applyImageVisibility(settings.showImages);
+};
+const applySettingIfEnabled = (isEnabled, settingType, value) => {
+  if (!isEnabled) {
+    return;
+  }
+  switch (settingType) {
+    case "colorScheme":
+      applyColorScheme(value);
+      break;
+    case "fontSize":
+      applyFontSize(value);
+      break;
+    case "imageVisibility":
+      applyImageVisibility(value);
+      break;
+    default:
+      console.warn(`Неизвестный тип настройки: ${settingType}`);
+  }
+};
+const useAccessibilitySettings = () => {
+  const [settings, setSettings] = useState(DEFAULT_ACCESSIBILITY_SETTINGS);
+  const [isLoaded, setIsLoaded] = useState(false);
+  useEffect(() => {
+    if (typeof window === "undefined" || !isLoaded || !settings.isEnabled) return;
+    const observer = new MutationObserver((mutations) => {
+      let hasNewTextElements = false;
+      mutations.forEach((mutation) => {
+        if (mutation.type === "childList") {
+          mutation.addedNodes.forEach((node) => {
+            if (node.nodeType === Node.ELEMENT_NODE) {
+              const element = node;
+              if (element.matches("h1, h2, h3, h4, h5, h6, p, span, a, button, label, li, div") || element.querySelector("h1, h2, h3, h4, h5, h6, p, span, a, button, label, li, div")) {
+                hasNewTextElements = true;
+              }
+            }
+          });
+        }
+      });
+      if (hasNewTextElements && settings.fontSize !== "standard") {
+        setTimeout(() => {
+          updateNewElementsFontSize(settings.fontSize);
+        }, 100);
+      }
+    });
+    observer.observe(document.body, {
+      childList: true,
+      subtree: true
+    });
+    return () => {
+      observer.disconnect();
+    };
+  }, [isLoaded, settings.isEnabled, settings.fontSize]);
+  useEffect(() => {
+    if (typeof window === "undefined") {
+      return;
+    }
+    try {
+      const savedSettings = loadFromStorage();
+      if (savedSettings) {
+        setSettings(savedSettings);
+        if (savedSettings.isEnabled) {
+          applyAllSettings(savedSettings);
+        }
+      }
+    } catch (error) {
+      console.warn("Ошибка при загрузке настроек доступности:", error);
+      setSettings(DEFAULT_ACCESSIBILITY_SETTINGS);
+    } finally {
+      setIsLoaded(true);
+    }
+  }, []);
+  useEffect(() => {
+    if (!isLoaded) {
+      return;
+    }
+    try {
+      saveToStorage(settings);
+      if (settings.isEnabled) {
+        applyAllSettings(settings);
+      } else {
+        removeAllAccessibilityStyles();
+      }
+    } catch (error) {
+      console.warn("Ошибка при сохранении настроек доступности:", error);
+    }
+  }, [settings, isLoaded]);
+  const updateSettings = useCallback((updates) => {
+    setSettings((prevSettings) => {
+      const newSettings = { ...prevSettings, ...updates };
+      if (prevSettings.isEnabled && !newSettings.isEnabled) {
+        removeAllAccessibilityStyles();
+      }
+      return newSettings;
+    });
+  }, []);
+  const resetSettings = useCallback(() => {
+    try {
+      removeAllAccessibilityStyles();
+      setSettings(DEFAULT_ACCESSIBILITY_SETTINGS);
+      clearStorage();
+    } catch (error) {
+      console.warn("Ошибка при сбросе настроек доступности:", error);
+    }
+  }, []);
+  return {
+    settings,
+    updateSettings,
+    resetSettings,
+    isLoaded
+  };
+};
+const useAccessibilitySetting = (settingKey) => {
+  const { settings, updateSettings } = useAccessibilitySettings();
+  const setValue = useCallback((value) => {
+    updateSettings({ [settingKey]: value });
+  }, [settingKey, updateSettings]);
+  return [settings[settingKey], setValue];
+};
+const useAccessibilityToggle = () => {
+  const { settings, updateSettings } = useAccessibilitySettings();
+  const setEnabled = useCallback((enabled) => {
+    updateSettings({ isEnabled: enabled });
+  }, [updateSettings]);
+  return [settings.isEnabled, setEnabled];
+};
+var jsxRuntime = { exports: {} };
+var reactJsxRuntime_production = {};
+/**
+ * @license React
+ * react-jsx-runtime.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var hasRequiredReactJsxRuntime_production;
+function requireReactJsxRuntime_production() {
+  if (hasRequiredReactJsxRuntime_production) return reactJsxRuntime_production;
+  hasRequiredReactJsxRuntime_production = 1;
+  var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
+  function jsxProd(type, config, maybeKey) {
+    var key = null;
+    void 0 !== maybeKey && (key = "" + maybeKey);
+    void 0 !== config.key && (key = "" + config.key);
+    if ("key" in config) {
+      maybeKey = {};
+      for (var propName in config)
+        "key" !== propName && (maybeKey[propName] = config[propName]);
+    } else maybeKey = config;
+    config = maybeKey.ref;
+    return {
+      $$typeof: REACT_ELEMENT_TYPE,
+      type,
+      key,
+      ref: void 0 !== config ? config : null,
+      props: maybeKey
+    };
+  }
+  reactJsxRuntime_production.Fragment = REACT_FRAGMENT_TYPE;
+  reactJsxRuntime_production.jsx = jsxProd;
+  reactJsxRuntime_production.jsxs = jsxProd;
+  return reactJsxRuntime_production;
+}
+var reactJsxRuntime_development = {};
+/**
+ * @license React
+ * react-jsx-runtime.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var hasRequiredReactJsxRuntime_development;
+function requireReactJsxRuntime_development() {
+  if (hasRequiredReactJsxRuntime_development) return reactJsxRuntime_development;
+  hasRequiredReactJsxRuntime_development = 1;
+  "production" !== process.env.NODE_ENV && function() {
+    function getComponentNameFromType(type) {
+      if (null == type) return null;
+      if ("function" === typeof type)
+        return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
+      if ("string" === typeof type) return type;
+      switch (type) {
+        case REACT_FRAGMENT_TYPE:
+          return "Fragment";
+        case REACT_PROFILER_TYPE:
+          return "Profiler";
+        case REACT_STRICT_MODE_TYPE:
+          return "StrictMode";
+        case REACT_SUSPENSE_TYPE:
+          return "Suspense";
+        case REACT_SUSPENSE_LIST_TYPE:
+          return "SuspenseList";
+        case REACT_ACTIVITY_TYPE:
+          return "Activity";
+      }
+      if ("object" === typeof type)
+        switch ("number" === typeof type.tag && console.error(
+          "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+        ), type.$$typeof) {
+          case REACT_PORTAL_TYPE:
+            return "Portal";
+          case REACT_CONTEXT_TYPE:
+            return type.displayName || "Context";
+          case REACT_CONSUMER_TYPE:
+            return (type._context.displayName || "Context") + ".Consumer";
+          case REACT_FORWARD_REF_TYPE:
+            var innerType = type.render;
+            type = type.displayName;
+            type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef");
+            return type;
+          case REACT_MEMO_TYPE:
+            return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo";
+          case REACT_LAZY_TYPE:
+            innerType = type._payload;
+            type = type._init;
+            try {
+              return getComponentNameFromType(type(innerType));
+            } catch (x) {
+            }
+        }
+      return null;
+    }
+    function testStringCoercion(value) {
+      return "" + value;
+    }
+    function checkKeyStringCoercion(value) {
+      try {
+        testStringCoercion(value);
+        var JSCompiler_inline_result = false;
+      } catch (e) {
+        JSCompiler_inline_result = true;
+      }
+      if (JSCompiler_inline_result) {
+        JSCompiler_inline_result = console;
+        var JSCompiler_temp_const = JSCompiler_inline_result.error;
+        var JSCompiler_inline_result$jscomp$0 = "function" === typeof Symbol && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
+        JSCompiler_temp_const.call(
+          JSCompiler_inline_result,
+          "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+          JSCompiler_inline_result$jscomp$0
+        );
+        return testStringCoercion(value);
+      }
+    }
+    function getTaskName(type) {
+      if (type === REACT_FRAGMENT_TYPE) return "<>";
+      if ("object" === typeof type && null !== type && type.$$typeof === REACT_LAZY_TYPE)
+        return "<...>";
+      try {
+        var name = getComponentNameFromType(type);
+        return name ? "<" + name + ">" : "<...>";
+      } catch (x) {
+        return "<...>";
+      }
+    }
+    function getOwner() {
+      var dispatcher = ReactSharedInternals.A;
+      return null === dispatcher ? null : dispatcher.getOwner();
+    }
+    function UnknownOwner() {
+      return Error("react-stack-top-frame");
+    }
+    function hasValidKey(config) {
+      if (hasOwnProperty.call(config, "key")) {
+        var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+        if (getter && getter.isReactWarning) return false;
+      }
+      return void 0 !== config.key;
+    }
+    function defineKeyPropWarningGetter(props, displayName) {
+      function warnAboutAccessingKey() {
+        specialPropKeyWarningShown || (specialPropKeyWarningShown = true, console.error(
+          "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
+          displayName
+        ));
+      }
+      warnAboutAccessingKey.isReactWarning = true;
+      Object.defineProperty(props, "key", {
+        get: warnAboutAccessingKey,
+        configurable: true
+      });
+    }
+    function elementRefGetterWithDeprecationWarning() {
+      var componentName = getComponentNameFromType(this.type);
+      didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = true, console.error(
+        "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
+      ));
+      componentName = this.props.ref;
+      return void 0 !== componentName ? componentName : null;
+    }
+    function ReactElement(type, key, props, owner, debugStack, debugTask) {
+      var refProp = props.ref;
+      type = {
+        $$typeof: REACT_ELEMENT_TYPE,
+        type,
+        key,
+        props,
+        _owner: owner
+      };
+      null !== (void 0 !== refProp ? refProp : null) ? Object.defineProperty(type, "ref", {
+        enumerable: false,
+        get: elementRefGetterWithDeprecationWarning
+      }) : Object.defineProperty(type, "ref", { enumerable: false, value: null });
+      type._store = {};
+      Object.defineProperty(type._store, "validated", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: 0
+      });
+      Object.defineProperty(type, "_debugInfo", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: null
+      });
+      Object.defineProperty(type, "_debugStack", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: debugStack
+      });
+      Object.defineProperty(type, "_debugTask", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: debugTask
+      });
+      Object.freeze && (Object.freeze(type.props), Object.freeze(type));
+      return type;
+    }
+    function jsxDEVImpl(type, config, maybeKey, isStaticChildren, debugStack, debugTask) {
+      var children = config.children;
+      if (void 0 !== children)
+        if (isStaticChildren)
+          if (isArrayImpl(children)) {
+            for (isStaticChildren = 0; isStaticChildren < children.length; isStaticChildren++)
+              validateChildKeys(children[isStaticChildren]);
+            Object.freeze && Object.freeze(children);
+          } else
+            console.error(
+              "React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead."
+            );
+        else validateChildKeys(children);
+      if (hasOwnProperty.call(config, "key")) {
+        children = getComponentNameFromType(type);
+        var keys = Object.keys(config).filter(function(k) {
+          return "key" !== k;
+        });
+        isStaticChildren = 0 < keys.length ? "{key: someKey, " + keys.join(": ..., ") + ": ...}" : "{key: someKey}";
+        didWarnAboutKeySpread[children + isStaticChildren] || (keys = 0 < keys.length ? "{" + keys.join(": ..., ") + ": ...}" : "{}", console.error(
+          'A props object containing a "key" prop is being spread into JSX:\n  let props = %s;\n  <%s {...props} />\nReact keys must be passed directly to JSX without using spread:\n  let props = %s;\n  <%s key={someKey} {...props} />',
+          isStaticChildren,
+          children,
+          keys,
+          children
+        ), didWarnAboutKeySpread[children + isStaticChildren] = true);
+      }
+      children = null;
+      void 0 !== maybeKey && (checkKeyStringCoercion(maybeKey), children = "" + maybeKey);
+      hasValidKey(config) && (checkKeyStringCoercion(config.key), children = "" + config.key);
+      if ("key" in config) {
+        maybeKey = {};
+        for (var propName in config)
+          "key" !== propName && (maybeKey[propName] = config[propName]);
+      } else maybeKey = config;
+      children && defineKeyPropWarningGetter(
+        maybeKey,
+        "function" === typeof type ? type.displayName || type.name || "Unknown" : type
+      );
+      return ReactElement(
+        type,
+        children,
+        maybeKey,
+        getOwner(),
+        debugStack,
+        debugTask
+      );
+    }
+    function validateChildKeys(node) {
+      isValidElement(node) ? node._store && (node._store.validated = 1) : "object" === typeof node && null !== node && node.$$typeof === REACT_LAZY_TYPE && ("fulfilled" === node._payload.status ? isValidElement(node._payload.value) && node._payload.value._store && (node._payload.value._store.validated = 1) : node._store && (node._store.validated = 1));
+    }
+    function isValidElement(object) {
+      return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
+    }
+    var React = require$$0, REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = Symbol.for("react.activity"), REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"), ReactSharedInternals = React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, hasOwnProperty = Object.prototype.hasOwnProperty, isArrayImpl = Array.isArray, createTask = console.createTask ? console.createTask : function() {
+      return null;
+    };
+    React = {
+      react_stack_bottom_frame: function(callStackForError) {
+        return callStackForError();
+      }
+    };
+    var specialPropKeyWarningShown;
+    var didWarnAboutElementRef = {};
+    var unknownOwnerDebugStack = React.react_stack_bottom_frame.bind(
+      React,
+      UnknownOwner
+    )();
+    var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
+    var didWarnAboutKeySpread = {};
+    reactJsxRuntime_development.Fragment = REACT_FRAGMENT_TYPE;
+    reactJsxRuntime_development.jsx = function(type, config, maybeKey) {
+      var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+      return jsxDEVImpl(
+        type,
+        config,
+        maybeKey,
+        false,
+        trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack,
+        trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask
+      );
+    };
+    reactJsxRuntime_development.jsxs = function(type, config, maybeKey) {
+      var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+      return jsxDEVImpl(
+        type,
+        config,
+        maybeKey,
+        true,
+        trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack,
+        trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask
+      );
+    };
+  }();
+  return reactJsxRuntime_development;
+}
+if (process.env.NODE_ENV === "production") {
+  jsxRuntime.exports = requireReactJsxRuntime_production();
+} else {
+  jsxRuntime.exports = requireReactJsxRuntime_development();
+}
+var jsxRuntimeExports = jsxRuntime.exports;
+const AccessibilityContext = createContext(null);
+const AccessibilityProvider = ({ children }) => {
+  const accessibilityState = useAccessibilitySettings();
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(AccessibilityContext.Provider, { value: accessibilityState, children });
+};
+const useAccessibilityContext = () => {
+  const context = useContext(AccessibilityContext);
+  if (!context) {
+    throw new Error("useAccessibilityContext должен использоваться внутри AccessibilityProvider");
+  }
+  return context;
+};
+const accessibilityToggle = "_accessibilityToggle_jwfla_9";
+const toggleContainer = "_toggleContainer_jwfla_15";
+const toggleLabel = "_toggleLabel_jwfla_21";
+const toggleInput = "_toggleInput_jwfla_42";
+const toggleSlider = "_toggleSlider_jwfla_49";
+const toggleThumb = "_toggleThumb_jwfla_55";
+const toggleContent = "_toggleContent_jwfla_81";
+const toggleTitle = "_toggleTitle_jwfla_88";
+const toggleStatus = "_toggleStatus_jwfla_95";
+const description$2 = "_description_jwfla_102";
+const styles$4 = {
+  accessibilityToggle,
+  toggleContainer,
+  toggleLabel,
+  toggleInput,
+  toggleSlider,
+  toggleThumb,
+  toggleContent,
+  toggleTitle,
+  toggleStatus,
+  description: description$2
+};
+const AccessibilityToggle = ({
+  className
+}) => {
+  const { settings, updateSettings } = useAccessibilityContext();
+  const isEnabled = settings.isEnabled;
+  const handleToggleChange = (event) => {
+    updateSettings({ isEnabled: event.target.checked });
+  };
+  return /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: `${styles$4.accessibilityToggle} ${className || ""}`, children: /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: styles$4.toggleContainer, children: [
+    /* @__PURE__ */ jsxRuntimeExports.jsxs("label", { className: styles$4.toggleLabel, children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx(
+        "input",
+        {
+          type: "checkbox",
+          checked: isEnabled,
+          onChange: handleToggleChange,
+          className: styles$4.toggleInput,
+          "aria-describedby": "accessibility-toggle-description"
+        }
+      ),
+      /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: styles$4.toggleSlider, "aria-hidden": "true", children: /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: styles$4.toggleThumb }) }),
+      /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: styles$4.toggleContent, children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: styles$4.toggleTitle, children: "Режим доступности" }),
+        /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: styles$4.toggleStatus, children: isEnabled ? "Включен" : "Выключен" })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxRuntimeExports.jsx(
+      "p",
+      {
+        id: "accessibility-toggle-description",
+        className: styles$4.description,
+        children: isEnabled ? "Все настройки доступности активны. Используйте элементы управления ниже для точной настройки." : "Включите режим доступности для активации всех настроек. При выключении все изменения будут сброшены."
+      }
+    )
+  ] }) });
+};
+const colorSchemeControl = "_colorSchemeControl_tkb2w_9";
+const disabled$2 = "_disabled_tkb2w_12";
+const title$3 = "_title_tkb2w_12";
+const optionsContainer$1 = "_optionsContainer_tkb2w_23";
+const option$1 = "_option_tkb2w_23";
+const selected$1 = "_selected_tkb2w_50";
+const radioIndicator$1 = "_radioIndicator_tkb2w_54";
+const optionDisabled$1 = "_optionDisabled_tkb2w_62";
+const radioInput$1 = "_radioInput_tkb2w_72";
+const optionContent$1 = "_optionContent_tkb2w_79";
+const optionLabel$1 = "_optionLabel_tkb2w_91";
+const optionDescription$1 = "_optionDescription_tkb2w_98";
+const styles$3 = {
+  colorSchemeControl,
+  disabled: disabled$2,
+  title: title$3,
+  optionsContainer: optionsContainer$1,
+  option: option$1,
+  selected: selected$1,
+  radioIndicator: radioIndicator$1,
+  optionDisabled: optionDisabled$1,
+  radioInput: radioInput$1,
+  optionContent: optionContent$1,
+  optionLabel: optionLabel$1,
+  optionDescription: optionDescription$1
+};
+const COLOR_SCHEME_OPTIONS = [
+  {
+    value: "standard",
+    label: "Стандартный",
+    description: "Обычная цветовая схема сайта"
+  },
+  {
+    value: "high-contrast",
+    label: "Контрастный белый на черном",
+    description: "Высококонтрастная схема для лучшей читаемости"
+  },
+  {
+    value: "grayscale",
+    label: "Черно-белый",
+    description: "Преобразование всех цветов в оттенки серого"
+  }
+];
+const ColorSchemeControl = ({
+  className
+}) => {
+  const { settings, updateSettings } = useAccessibilityContext();
+  const colorScheme = settings.colorScheme;
+  const isEnabled = settings.isEnabled;
+  const handleColorSchemeChange = (event) => {
+    const newColorScheme = event.target.value;
+    updateSettings({ colorScheme: newColorScheme });
+  };
+  return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: `${styles$3.colorSchemeControl} ${className || ""} ${!isEnabled ? styles$3.disabled : ""}`, children: [
+    /* @__PURE__ */ jsxRuntimeExports.jsx("h4", { className: styles$3.title, children: "Цветовая схема" }),
+    /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: styles$3.optionsContainer, role: "radiogroup", "aria-labelledby": "color-scheme-title", children: COLOR_SCHEME_OPTIONS.map((option2) => /* @__PURE__ */ jsxRuntimeExports.jsxs(
+      "label",
+      {
+        className: `${styles$3.option} ${colorScheme === option2.value ? styles$3.selected : ""} ${!isEnabled ? styles$3.optionDisabled : ""}`,
+        children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsx(
+            "input",
+            {
+              type: "radio",
+              name: "colorScheme",
+              value: option2.value,
+              checked: colorScheme === option2.value,
+              onChange: handleColorSchemeChange,
+              className: styles$3.radioInput,
+              "aria-describedby": `color-scheme-${option2.value}-description`,
+              disabled: !isEnabled
+            }
+          ),
+          /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: styles$3.optionContent, children: [
+            /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: styles$3.optionLabel, children: option2.label }),
+            /* @__PURE__ */ jsxRuntimeExports.jsx(
+              "span",
+              {
+                id: `color-scheme-${option2.value}-description`,
+                className: styles$3.optionDescription,
+                children: option2.description
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: styles$3.radioIndicator, "aria-hidden": "true" })
+        ]
+      },
+      option2.value
+    )) })
+  ] });
+};
+const fontSizeControl = "_fontSizeControl_xe2rx_9";
+const disabled$1 = "_disabled_xe2rx_12";
+const title$2 = "_title_xe2rx_12";
+const optionsContainer = "_optionsContainer_xe2rx_23";
+const option = "_option_xe2rx_23";
+const selected = "_selected_xe2rx_50";
+const radioIndicator = "_radioIndicator_xe2rx_54";
+const optionDisabled = "_optionDisabled_xe2rx_62";
+const radioInput = "_radioInput_xe2rx_72";
+const optionContent = "_optionContent_xe2rx_79";
+const optionLabel = "_optionLabel_xe2rx_91";
+const optionDescription = "_optionDescription_xe2rx_98";
+const styles$2 = {
+  fontSizeControl,
+  disabled: disabled$1,
+  title: title$2,
+  optionsContainer,
+  option,
+  selected,
+  radioIndicator,
+  optionDisabled,
+  radioInput,
+  optionContent,
+  optionLabel,
+  optionDescription
+};
+const FONT_SIZE_OPTIONS = [
+  {
+    value: "small",
+    label: "Мелкий",
+    description: "Уменьшенный размер текста (80%)"
+  },
+  {
+    value: "standard",
+    label: "Стандартный",
+    description: "Обычный размер текста"
+  },
+  {
+    value: "large",
+    label: "Крупный",
+    description: "Увеличенный размер текста (130%)"
+  }
+];
+const FontSizeControl = ({
+  className
+}) => {
+  const { settings, updateSettings } = useAccessibilityContext();
+  const fontSize = settings.fontSize;
+  const isEnabled = settings.isEnabled;
+  const handleFontSizeChange = (event) => {
+    const newFontSize = event.target.value;
+    updateSettings({ fontSize: newFontSize });
+  };
+  return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: `${styles$2.fontSizeControl} ${className || ""} ${!isEnabled ? styles$2.disabled : ""}`, children: [
+    /* @__PURE__ */ jsxRuntimeExports.jsx("h4", { className: styles$2.title, children: "Размер шрифта" }),
+    /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: styles$2.optionsContainer, role: "radiogroup", "aria-labelledby": "font-size-title", children: FONT_SIZE_OPTIONS.map((option2) => /* @__PURE__ */ jsxRuntimeExports.jsxs(
+      "label",
+      {
+        className: `${styles$2.option} ${fontSize === option2.value ? styles$2.selected : ""} ${!isEnabled ? styles$2.optionDisabled : ""}`,
+        children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsx(
+            "input",
+            {
+              type: "radio",
+              name: "fontSize",
+              value: option2.value,
+              checked: fontSize === option2.value,
+              onChange: handleFontSizeChange,
+              className: styles$2.radioInput,
+              "aria-describedby": `font-size-${option2.value}-description`,
+              disabled: !isEnabled
+            }
+          ),
+          /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: styles$2.optionContent, children: [
+            /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: styles$2.optionLabel, children: option2.label }),
+            /* @__PURE__ */ jsxRuntimeExports.jsx(
+              "span",
+              {
+                id: `font-size-${option2.value}-description`,
+                className: styles$2.optionDescription,
+                children: option2.description
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: styles$2.radioIndicator, "aria-hidden": "true" })
+        ]
+      },
+      option2.value
+    )) })
+  ] });
+};
+const imageControl = "_imageControl_rczak_9";
+const disabled = "_disabled_rczak_12";
+const title$1 = "_title_rczak_12";
+const switchContainer = "_switchContainer_rczak_23";
+const switchLabel = "_switchLabel_rczak_29";
+const switchDisabled = "_switchDisabled_rczak_49";
+const switchInput = "_switchInput_rczak_59";
+const switchSlider = "_switchSlider_rczak_66";
+const switchThumb = "_switchThumb_rczak_72";
+const switchText = "_switchText_rczak_98";
+const description$1 = "_description_rczak_106";
+const styles$1 = {
+  imageControl,
+  disabled,
+  title: title$1,
+  switchContainer,
+  switchLabel,
+  switchDisabled,
+  switchInput,
+  switchSlider,
+  switchThumb,
+  switchText,
+  description: description$1
+};
+const ImageControl = ({
+  className
+}) => {
+  const { settings, updateSettings } = useAccessibilityContext();
+  const showImages = settings.showImages;
+  const isEnabled = settings.isEnabled;
+  const handleImageVisibilityChange = (event) => {
+    updateSettings({ showImages: event.target.checked });
+  };
+  return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: `${styles$1.imageControl} ${className || ""} ${!isEnabled ? styles$1.disabled : ""}`, children: [
+    /* @__PURE__ */ jsxRuntimeExports.jsx("h4", { className: styles$1.title, children: "Изображения" }),
+    /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: styles$1.switchContainer, children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsxs("label", { className: `${styles$1.switchLabel} ${!isEnabled ? styles$1.switchDisabled : ""}`, children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsx(
+          "input",
+          {
+            type: "checkbox",
+            checked: showImages,
+            onChange: handleImageVisibilityChange,
+            className: styles$1.switchInput,
+            "aria-describedby": "image-control-description",
+            disabled: !isEnabled
+          }
+        ),
+        /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: styles$1.switchSlider, "aria-hidden": "true", children: /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: styles$1.switchThumb }) }),
+        /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: styles$1.switchText, children: showImages ? "Показывать изображения" : "Скрывать изображения" })
+      ] }),
+      /* @__PURE__ */ jsxRuntimeExports.jsx(
+        "p",
+        {
+          id: "image-control-description",
+          className: styles$1.description,
+          children: showImages ? "Изображения отображаются на странице" : "Изображения скрыты для лучшей концентрации на тексте"
+        }
+      )
+    ] })
+  ] });
+};
+const stickyContainer = "_stickyContainer_1xqyi_9";
+const panel = "_panel_1xqyi_23";
+const topRight = "_topRight_1xqyi_38";
+const topLeft = "_topLeft_1xqyi_42";
+const header = "_header_1xqyi_59";
+const title = "_title_1xqyi_68";
+const closeButton = "_closeButton_1xqyi_76";
+const description = "_description_1xqyi_107";
+const content = "_content_1xqyi_115";
+const controls = "_controls_1xqyi_135";
+const slideIn = "_slideIn_1xqyi_1";
+const styles = {
+  stickyContainer,
+  panel,
+  topRight,
+  topLeft,
+  header,
+  title,
+  closeButton,
+  description,
+  content,
+  controls,
+  slideIn
+};
+const AccessibilityPanelInner = ({
+  isOpen,
+  onClose,
+  position = "top-right"
+}) => {
+  const panelRef = useRef(null);
+  useEffect(() => {
+    if (!isOpen) return;
+    const handleClickOutside = (event) => {
+      if (panelRef.current && !panelRef.current.contains(event.target)) {
+        onClose();
+      }
+    };
+    const timeoutId = setTimeout(() => {
+      document.addEventListener("mousedown", handleClickOutside);
+    }, 100);
+    return () => {
+      clearTimeout(timeoutId);
+      document.removeEventListener("mousedown", handleClickOutside);
+    };
+  }, [isOpen, onClose]);
+  useEffect(() => {
+    if (!isOpen) return;
+    const handleEscapeKey = (event) => {
+      if (event.key === "Escape") {
+        onClose();
+      }
+    };
+    document.addEventListener("keydown", handleEscapeKey);
+    return () => {
+      document.removeEventListener("keydown", handleEscapeKey);
+    };
+  }, [isOpen, onClose]);
+  const handleCloseClick = (event) => {
+    event.preventDefault();
+    event.stopPropagation();
+    onClose();
+  };
+  if (!isOpen) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: `${styles.stickyContainer} accessibility-panel-container`, children: /* @__PURE__ */ jsxRuntimeExports.jsxs(
+    "div",
+    {
+      ref: panelRef,
+      className: `${styles.panel} ${styles[position]}`,
+      role: "dialog",
+      "aria-modal": "true",
+      "aria-labelledby": "accessibility-panel-title",
+      "aria-describedby": "accessibility-panel-description",
+      children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: styles.header, children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsx("h3", { id: "accessibility-panel-title", className: styles.title, children: "Настройки доступности" }),
+          /* @__PURE__ */ jsxRuntimeExports.jsx(
+            "button",
+            {
+              onClick: handleCloseClick,
+              className: styles.closeButton,
+              "aria-label": "Закрыть панель настроек доступности",
+              type: "button",
+              children: "×"
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxRuntimeExports.jsx(
+          "div",
+          {
+            id: "accessibility-panel-description",
+            className: styles.description,
+            children: "Настройте отображение страницы для улучшения доступности"
+          }
+        ),
+        /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: styles.content, children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsx(AccessibilityToggle, {}),
+          /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: styles.controls, children: [
+            /* @__PURE__ */ jsxRuntimeExports.jsx(ColorSchemeControl, {}),
+            /* @__PURE__ */ jsxRuntimeExports.jsx(FontSizeControl, {}),
+            /* @__PURE__ */ jsxRuntimeExports.jsx(ImageControl, {})
+          ] })
+        ] })
+      ]
+    }
+  ) });
+};
+const AccessibilityPanel = (props) => {
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(AccessibilityProvider, { children: /* @__PURE__ */ jsxRuntimeExports.jsx(AccessibilityPanelInner, { ...props }) });
+};
+export {
+  AccessibilityPanel,
+  AccessibilityProvider,
+  AccessibilityToggle,
+  CSS_CLASSES,
+  ColorSchemeControl,
+  DEFAULT_ACCESSIBILITY_SETTINGS,
+  FontSizeControl,
+  ImageControl,
+  STORAGE_KEY,
+  applyAllSettings,
+  applyClassToElements,
+  applyColorScheme,
+  applyDynamicFontSize,
+  applyFontSize,
+  applyImageVisibility,
+  applySettingIfEnabled,
+  clearStorage,
+  getImageElements,
+  getTextElements,
+  isDOMAvailable,
+  isFontSizeModified,
+  loadFromStorage,
+  removeAllAccessibilityStyles,
+  removeClassFromElements,
+  resetAllFontSizes,
+  safeDOMOperation,
+  safeLocalStorageOperation,
+  saveToStorage,
+  updateNewElementsFontSize,
+  useAccessibilityContext,
+  useAccessibilitySetting,
+  useAccessibilitySettings,
+  useAccessibilityToggle,
+  validateSettings
+};
+//# sourceMappingURL=index.esm.js.map