@diplodoc/components 0.0.0-rc-pdf-icon-custimization-24387828749

package/build/esm/config/index.js

@@ -0,0 +1,34 @@
+// src/config/index.ts
+import { Lang as LangUIKit, configure as configureUIKit } from "@gravity-ui/uikit";
+import { Lang } from "../models";
+import { configureI18N } from "./i18n";
+var subs = /* @__PURE__ */ new Set();
+var config = {
+  lang: Lang.En
+};
+var configure = (newConfig = {}) => {
+  config = Object.assign({}, config, newConfig);
+  configureI18N({
+    lang: config.lang,
+    loc: config.loc
+  });
+  configureUIKit({
+    lang: Object.values(LangUIKit).includes(config.lang) ? config.lang : LangUIKit.En
+  });
+  subs.forEach((sub) => {
+    sub(config);
+  });
+};
+var subscribeConfigure = (sub) => {
+  subs.add(sub);
+  return () => {
+    subs.delete(sub);
+  };
+};
+var getConfig = () => config;
+export {
+  configure,
+  getConfig,
+  subscribeConfigure
+};
+//# sourceMappingURL=index.js.map

package/build/esm/config/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/config/index.ts"],
+  "sourcesContent": ["import type {Config} from '../models';\n\nimport {Lang as LangUIKit, configure as configureUIKit} from '@gravity-ui/uikit';\n\nimport {Lang} from '../models';\n\nimport {configureI18N} from './i18n';\n\ntype Subscriber = (config: Config) => void;\n\nconst subs: Set<Subscriber> = new Set();\n\nlet config: Config = {\n    lang: Lang.En,\n};\n\nexport const configure = (newConfig: Partial<Config> = {}) => {\n    config = Object.assign({}, config, newConfig);\n\n    configureI18N({\n        lang: config.lang,\n        loc: config.loc,\n    });\n\n    configureUIKit({\n        lang: Object.values(LangUIKit).includes(config.lang as LangUIKit)\n            ? (config.lang as LangUIKit)\n            : LangUIKit.En,\n    });\n\n    subs.forEach((sub) => {\n        sub(config);\n    });\n};\n\nexport const subscribeConfigure = (sub: Subscriber) => {\n    subs.add(sub);\n\n    return () => {\n        subs.delete(sub);\n    };\n};\n\nexport const getConfig = () => config;\n"],
+  "mappings": ";AAEA,SAAQ,QAAQ,WAAW,aAAa,sBAAqB;AAE7D,SAAQ,YAAW;AAEnB,SAAQ,qBAAoB;AAI5B,IAAM,OAAwB,oBAAI,IAAI;AAEtC,IAAI,SAAiB;AAAA,EACjB,MAAM,KAAK;AACf;AAEO,IAAM,YAAY,CAAC,YAA6B,CAAC,MAAM;AAC1D,WAAS,OAAO,OAAO,CAAC,GAAG,QAAQ,SAAS;AAE5C,gBAAc;AAAA,IACV,MAAM,OAAO;AAAA,IACb,KAAK,OAAO;AAAA,EAChB,CAAC;AAED,iBAAe;AAAA,IACX,MAAM,OAAO,OAAO,SAAS,EAAE,SAAS,OAAO,IAAiB,IACzD,OAAO,OACR,UAAU;AAAA,EACpB,CAAC;AAED,OAAK,QAAQ,CAAC,QAAQ;AAClB,QAAI,MAAM;AAAA,EACd,CAAC;AACL;AAEO,IAAM,qBAAqB,CAAC,QAAoB;AACnD,OAAK,IAAI,GAAG;AAEZ,SAAO,MAAM;AACT,SAAK,OAAO,GAAG;AAAA,EACnB;AACJ;AAEO,IAAM,YAAY,MAAM;",
+  "names": []
+}

package/build/esm/constants.d.ts

@@ -0,0 +1,26 @@
+import { Lang, TextSizes, Theme } from './models';
+export declare const DEFAULT_SETTINGS: {
+    fullScreen: boolean;
+    singlePage: boolean;
+    wideFormat: boolean;
+    showMiniToc: boolean;
+    bookmarkedPage: boolean;
+    lang: Lang;
+    theme: Theme;
+    textSize: TextSizes;
+    isLiked: boolean;
+    isDisliked: boolean;
+    isPinned: boolean;
+    notification: boolean;
+};
+export declare const ERROR_CODES: {
+    ACCESS_DENIED: number;
+    NOT_FOUND: number;
+    SERVER_ERROR: number;
+};
+export declare const DEFAULT_LANGS: string[];
+export declare const LEGACY_LANG_ITEMS: {
+    value: Lang;
+    text: string;
+}[];
+export declare const SUPPORTED_LANGS: string[];

package/build/esm/constants.js

@@ -0,0 +1,37 @@
+// src/constants.ts
+import { Lang, TextSizes, Theme } from "./models";
+import langs from "./i18n";
+var DEFAULT_SETTINGS = {
+  fullScreen: false,
+  singlePage: false,
+  wideFormat: false,
+  showMiniToc: true,
+  bookmarkedPage: false,
+  lang: Lang.En,
+  theme: Theme.Dark,
+  textSize: TextSizes.M,
+  isLiked: false,
+  isDisliked: false,
+  isPinned: false,
+  notification: false
+};
+var ERROR_CODES = {
+  ACCESS_DENIED: 403,
+  NOT_FOUND: 404,
+  SERVER_ERROR: 500
+};
+var DEFAULT_LANGS = ["en", "ru", "he"];
+var LEGACY_LANG_ITEMS = [
+  { value: Lang.Ru, text: "\u0420\u0443\u0441\u0441\u043A\u0438\u0439" },
+  { value: Lang.En, text: "English" },
+  { value: Lang.He, text: "Hebrew" }
+];
+var SUPPORTED_LANGS = Object.keys(langs);
+export {
+  DEFAULT_LANGS,
+  DEFAULT_SETTINGS,
+  ERROR_CODES,
+  LEGACY_LANG_ITEMS,
+  SUPPORTED_LANGS
+};
+//# sourceMappingURL=constants.js.map

package/build/esm/constants.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/constants.ts"],
+  "sourcesContent": ["import {Lang, TextSizes, Theme} from './models';\nimport langs from './i18n';\n\nexport const DEFAULT_SETTINGS = {\n    fullScreen: false,\n    singlePage: false,\n    wideFormat: false,\n    showMiniToc: true,\n    bookmarkedPage: false,\n    lang: Lang.En,\n    theme: Theme.Dark,\n    textSize: TextSizes.M,\n    isLiked: false,\n    isDisliked: false,\n    isPinned: false,\n    notification: false,\n};\n\nexport const ERROR_CODES = {\n    ACCESS_DENIED: 403,\n    NOT_FOUND: 404,\n    SERVER_ERROR: 500,\n};\n\nexport const DEFAULT_LANGS = ['en', 'ru', 'he'];\nexport const LEGACY_LANG_ITEMS = [\n    {value: Lang.Ru, text: '\u0420\u0443\u0441\u0441\u043A\u0438\u0439'},\n    {value: Lang.En, text: 'English'},\n    {value: Lang.He, text: 'Hebrew'},\n];\nexport const SUPPORTED_LANGS = Object.keys(langs);\n"],
+  "mappings": ";AAAA,SAAQ,MAAM,WAAW,aAAY;AACrC,OAAO,WAAW;AAEX,IAAM,mBAAmB;AAAA,EAC5B,YAAY;AAAA,EACZ,YAAY;AAAA,EACZ,YAAY;AAAA,EACZ,aAAa;AAAA,EACb,gBAAgB;AAAA,EAChB,MAAM,KAAK;AAAA,EACX,OAAO,MAAM;AAAA,EACb,UAAU,UAAU;AAAA,EACpB,SAAS;AAAA,EACT,YAAY;AAAA,EACZ,UAAU;AAAA,EACV,cAAc;AAClB;AAEO,IAAM,cAAc;AAAA,EACvB,eAAe;AAAA,EACf,WAAW;AAAA,EACX,cAAc;AAClB;AAEO,IAAM,gBAAgB,CAAC,MAAM,MAAM,IAAI;AACvC,IAAM,oBAAoB;AAAA,EAC7B,EAAC,OAAO,KAAK,IAAI,MAAM,6CAAS;AAAA,EAChC,EAAC,OAAO,KAAK,IAAI,MAAM,UAAS;AAAA,EAChC,EAAC,OAAO,KAAK,IAAI,MAAM,SAAQ;AACnC;AACO,IAAM,kBAAkB,OAAO,KAAK,KAAK;",
+  "names": []
+}

package/build/esm/contexts/InterfaceContext.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+export interface InterfaceContextType {
+    interface: Record<string, boolean>;
+    isHidden: (name: string) => boolean;
+}
+export declare const InterfaceContext: React.Context<InterfaceContextType>;
+export interface InterfaceProviderProps {
+    interface: Record<string, boolean>;
+    children: React.ReactNode;
+}
+export declare const InterfaceProvider: React.FC<InterfaceProviderProps>;

package/build/esm/contexts/InterfaceContext.js

@@ -0,0 +1,33 @@
+// src/contexts/InterfaceContext.tsx
+import React, { createContext, useCallback, useMemo } from "react";
+var InterfaceContext = createContext({
+  interface: {},
+  isHidden: () => false
+});
+var InterfaceProvider = ({
+  interface: viewerInterface,
+  children
+}) => {
+  const isHidden = useCallback(
+    (name) => {
+      if (viewerInterface && name in viewerInterface) {
+        return !viewerInterface[name];
+      }
+      return false;
+    },
+    [viewerInterface]
+  );
+  const value = useMemo(
+    () => ({
+      interface: viewerInterface,
+      isHidden
+    }),
+    [viewerInterface, isHidden]
+  );
+  return /* @__PURE__ */ React.createElement(InterfaceContext.Provider, { value }, children);
+};
+export {
+  InterfaceContext,
+  InterfaceProvider
+};
+//# sourceMappingURL=InterfaceContext.js.map

package/build/esm/contexts/InterfaceContext.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/contexts/InterfaceContext.tsx"],
+  "sourcesContent": ["import React, {createContext, useCallback, useMemo} from 'react';\n\nexport interface InterfaceContextType {\n    interface: Record<string, boolean>;\n    isHidden: (name: string) => boolean;\n}\n\nexport const InterfaceContext = createContext<InterfaceContextType>({\n    interface: {},\n    isHidden: () => false,\n});\n\nexport interface InterfaceProviderProps {\n    interface: Record<string, boolean>;\n    children: React.ReactNode;\n}\n\nexport const InterfaceProvider: React.FC<InterfaceProviderProps> = ({\n    interface: viewerInterface,\n    children,\n}) => {\n    const isHidden = useCallback(\n        (name: string) => {\n            if (viewerInterface && name in viewerInterface) {\n                return !viewerInterface[name];\n            }\n            return false;\n        },\n        [viewerInterface],\n    );\n\n    const value = useMemo(\n        () => ({\n            interface: viewerInterface,\n            isHidden,\n        }),\n        [viewerInterface, isHidden],\n    );\n\n    return <InterfaceContext.Provider value={value}>{children}</InterfaceContext.Provider>;\n};\n"],
+  "mappings": ";AAAA,OAAO,SAAQ,eAAe,aAAa,eAAc;AAOlD,IAAM,mBAAmB,cAAoC;AAAA,EAChE,WAAW,CAAC;AAAA,EACZ,UAAU,MAAM;AACpB,CAAC;AAOM,IAAM,oBAAsD,CAAC;AAAA,EAChE,WAAW;AAAA,EACX;AACJ,MAAM;AACF,QAAM,WAAW;AAAA,IACb,CAAC,SAAiB;AACd,UAAI,mBAAmB,QAAQ,iBAAiB;AAC5C,eAAO,CAAC,gBAAgB,IAAI;AAAA,MAChC;AACA,aAAO;AAAA,IACX;AAAA,IACA,CAAC,eAAe;AAAA,EACpB;AAEA,QAAM,QAAQ;AAAA,IACV,OAAO;AAAA,MACH,WAAW;AAAA,MACX;AAAA,IACJ;AAAA,IACA,CAAC,iBAAiB,QAAQ;AAAA,EAC9B;AAEA,SAAO,oCAAC,iBAAiB,UAAjB,EAA0B,SAAe,QAAS;AAC9D;",
+  "names": []
+}

package/build/esm/contexts/LangContext.d.ts

@@ -0,0 +1,6 @@
+export declare enum Lang {
+    Ru = "ru",
+    En = "en"
+}
+declare const _default: import("react").Context<Lang>;
+export default _default;

package/build/esm/contexts/LangContext.js

@@ -0,0 +1,13 @@
+// src/contexts/LangContext.ts
+import namedContext from "./_namedContext";
+var Lang = /* @__PURE__ */ ((Lang2) => {
+  Lang2["Ru"] = "ru";
+  Lang2["En"] = "en";
+  return Lang2;
+})(Lang || {});
+var LangContext_default = namedContext("Lang", process.env.DEFAULT_LANG || "en" /* En */);
+export {
+  Lang,
+  LangContext_default as default
+};
+//# sourceMappingURL=LangContext.js.map

package/build/esm/contexts/LangContext.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/contexts/LangContext.ts"],
+  "sourcesContent": ["import namedContext from './_namedContext';\n\n//TODO: replace it with type Lang from models when there is a new major\nexport enum Lang {\n    Ru = 'ru',\n    En = 'en',\n}\n\nexport default namedContext<Lang>('Lang', (process.env.DEFAULT_LANG as Lang) || Lang.En);\n"],
+  "mappings": ";AAAA,OAAO,kBAAkB;AAGlB,IAAK,OAAL,kBAAKA,UAAL;AACH,EAAAA,MAAA,QAAK;AACL,EAAAA,MAAA,QAAK;AAFG,SAAAA;AAAA,GAAA;AAKZ,IAAO,sBAAQ,aAAmB,QAAS,QAAQ,IAAI,gBAAyB,aAAO;",
+  "names": ["Lang"]
+}

package/build/esm/contexts/RenderBodyHooksContext.d.ts

@@ -0,0 +1,5 @@
+import type { FC } from 'react';
+import type { RenderBodyProps } from '../components/DocPage';
+export type RenderBodyHook = (c: FC<RenderBodyProps>) => FC<RenderBodyProps>;
+export type RenderBodyHooks = RenderBodyHook[];
+export declare const RenderBodyHooksContext: import("react").Context<RenderBodyHooks>;

package/build/esm/contexts/RenderBodyHooksContext.js

@@ -0,0 +1,7 @@
+// src/contexts/RenderBodyHooksContext.ts
+import namedContext from "./_namedContext";
+var RenderBodyHooksContext = namedContext("RenderBodyHooks", []);
+export {
+  RenderBodyHooksContext
+};
+//# sourceMappingURL=RenderBodyHooksContext.js.map

package/build/esm/contexts/RenderBodyHooksContext.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/contexts/RenderBodyHooksContext.ts"],
+  "sourcesContent": ["import type {FC} from 'react';\nimport type {RenderBodyProps} from '../components/DocPage';\n\nimport namedContext from './_namedContext';\n\nexport type RenderBodyHook = (c: FC<RenderBodyProps>) => FC<RenderBodyProps>;\n\nexport type RenderBodyHooks = RenderBodyHook[];\n\nexport const RenderBodyHooksContext = namedContext<RenderBodyHooks>('RenderBodyHooks', []);\n"],
+  "mappings": ";AAGA,OAAO,kBAAkB;AAMlB,IAAM,yBAAyB,aAA8B,mBAAmB,CAAC,CAAC;",
+  "names": []
+}

package/build/esm/contexts/RouterContext.d.ts

@@ -0,0 +1,12 @@
+import type { Query } from '../models';
+export interface RouterData {
+    page: string;
+    pathname: string;
+    query: Query;
+    hash?: string;
+    as: string;
+    hostname: string;
+    serverRouter?: RouterData;
+}
+declare const _default: import("react").Context<RouterData>;
+export default _default;

package/build/esm/contexts/RouterContext.js

@@ -0,0 +1,7 @@
+// src/contexts/RouterContext.ts
+import namedContext from "./_namedContext";
+var RouterContext_default = namedContext("Request", {});
+export {
+  RouterContext_default as default
+};
+//# sourceMappingURL=RouterContext.js.map

package/build/esm/contexts/RouterContext.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/contexts/RouterContext.ts"],
+  "sourcesContent": ["import type {Query} from '../models';\n\nexport interface RouterData {\n    page: string;\n    pathname: string;\n    query: Query;\n    hash?: string;\n    as: string;\n    hostname: string;\n    serverRouter?: RouterData;\n}\n\nimport namedContext from './_namedContext';\n\nexport default namedContext<RouterData>('Request', {} as RouterData);\n"],
+  "mappings": ";AAYA,OAAO,kBAAkB;AAEzB,IAAO,wBAAQ,aAAyB,WAAW,CAAC,CAAe;",
+  "names": []
+}

package/build/esm/contexts/_namedContext.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export default function <T>(name: string, defaults: T): React.Context<T>;

package/build/esm/contexts/_namedContext.js

@@ -0,0 +1,11 @@
+// src/contexts/_namedContext.ts
+import React from "react";
+function namedContext_default(name, defaults) {
+  const Context = React.createContext(defaults);
+  Context.displayName = name;
+  return Context;
+}
+export {
+  namedContext_default as default
+};
+//# sourceMappingURL=_namedContext.js.map

package/build/esm/contexts/_namedContext.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/contexts/_namedContext.ts"],
+  "sourcesContent": ["import React from 'react';\n\nexport default function <T>(name: string, defaults: T): React.Context<T> {\n    const Context = React.createContext(defaults);\n\n    Context.displayName = name;\n\n    return Context;\n}\n"],
+  "mappings": ";AAAA,OAAO,WAAW;AAEH,SAAR,qBAAqB,MAAc,UAA+B;AACrE,QAAM,UAAU,MAAM,cAAc,QAAQ;AAE5C,UAAQ,cAAc;AAEtB,SAAO;AACX;",
+  "names": []
+}

package/build/esm/hoc/_withContext.d.ts

@@ -0,0 +1,55 @@
+import React from 'react';
+export default function <P extends Record<string, any>>(prop: string, Context: React.Context<any> & {
+    name?: string;
+}): <T extends Record<string, any>>(Component: React.ComponentType<any>) => {
+    new (props: Omit<T, keyof P>): {
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<Omit<T, keyof P>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<Omit<T, keyof P>>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<Omit<T, keyof P>>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Omit<T, keyof P>>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<Omit<T, keyof P>>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Omit<T, keyof P>>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Omit<T, keyof P>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Omit<T, keyof P>>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Omit<T, keyof P>>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: Omit<T, keyof P>, context: any): {
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<Omit<T, keyof P>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<Omit<T, keyof P>>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<Omit<T, keyof P>>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Omit<T, keyof P>>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<Omit<T, keyof P>>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Omit<T, keyof P>>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Omit<T, keyof P>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Omit<T, keyof P>>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Omit<T, keyof P>>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    displayName: string;
+    contextType: React.Context<any> & {
+        name?: string;
+    };
+};

package/build/esm/hoc/_withContext.js

@@ -0,0 +1,40 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/hoc/_withContext.tsx
+import React from "react";
+import hoistNonReactStatics from "hoist-non-react-statics";
+function withContext_default(prop, Context) {
+  return function(Component) {
+    const contextName = Context.displayName || Context.name || "Context";
+    const componentName = Component.displayName || Component.name || "Component";
+    class WithContextProp extends React.Component {
+      render() {
+        return /* @__PURE__ */ React.createElement(Component, __spreadValues(__spreadValues({}, this.props), { [prop]: this.context }));
+      }
+    }
+    __publicField(WithContextProp, "displayName", `with${contextName}(${componentName})`);
+    __publicField(WithContextProp, "contextType", Context);
+    hoistNonReactStatics(WithContextProp, Component);
+    return WithContextProp;
+  };
+}
+export {
+  withContext_default as default
+};
+//# sourceMappingURL=_withContext.js.map

package/build/esm/hoc/_withContext.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/hoc/_withContext.tsx"],
+  "sourcesContent": ["import React from 'react';\nimport hoistNonReactStatics from 'hoist-non-react-statics';\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport default function <P extends Record<string, any>>(\n    prop: string,\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Context: React.Context<any> & {name?: string},\n) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    return function <T extends Record<string, any>>(Component: React.ComponentType<any>) {\n        const contextName = Context.displayName || Context.name || 'Context';\n        const componentName = Component.displayName || Component.name || 'Component';\n\n        class WithContextProp extends React.Component<Omit<T, keyof P>> {\n            static displayName = `with${contextName}(${componentName})`;\n\n            static contextType = Context;\n\n            render() {\n                return <Component {...this.props} {...{[prop]: this.context}} />;\n            }\n        }\n\n        // Copies non-react specific statics from a child component to a parent component\n        hoistNonReactStatics(WithContextProp, Component);\n\n        return WithContextProp;\n    };\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;AAAA,OAAO,WAAW;AAClB,OAAO,0BAA0B;AAGlB,SAAR,oBACH,MAEA,SACF;AAEE,SAAO,SAAyC,WAAqC;AACjF,UAAM,cAAc,QAAQ,eAAe,QAAQ,QAAQ;AAC3D,UAAM,gBAAgB,UAAU,eAAe,UAAU,QAAQ;AAAA,IAEjE,MAAM,wBAAwB,MAAM,UAA4B;AAAA,MAK5D,SAAS;AACL,eAAO,oCAAC,6CAAc,KAAK,QAAW,EAAC,CAAC,IAAI,GAAG,KAAK,QAAO,EAAG;AAAA,MAClE;AAAA,IACJ;AAPI,kBADE,iBACK,eAAc,OAAO,WAAW,IAAI,aAAa;AAExD,kBAHE,iBAGK,eAAc;AAQzB,yBAAqB,iBAAiB,SAAS;AAE/C,WAAO;AAAA,EACX;AACJ;",
+  "names": []
+}

package/build/esm/hoc/withLang.d.ts

@@ -0,0 +1,57 @@
+import type { Lang } from '../contexts/LangContext';
+export interface WithLangProps {
+    lang: Lang;
+}
+declare const _default: <T extends Record<string, any>>(Component: React.ComponentType<any>) => {
+    new (props: Omit<T, "lang">): {
+        render(): import("react").JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<Omit<T, "lang">>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<Omit<T, "lang">>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: import("react").ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<Omit<T, "lang">>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Omit<T, "lang">>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<Omit<T, "lang">>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Omit<T, "lang">>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Omit<T, "lang">>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Omit<T, "lang">>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Omit<T, "lang">>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: Omit<T, "lang">, context: any): {
+        render(): import("react").JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<Omit<T, "lang">>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<Omit<T, "lang">>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: import("react").ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<Omit<T, "lang">>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Omit<T, "lang">>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<Omit<T, "lang">>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Omit<T, "lang">>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Omit<T, "lang">>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Omit<T, "lang">>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Omit<T, "lang">>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    displayName: string;
+    contextType: import("react").Context<any> & {
+        name?: string;
+    };
+};
+export default _default;

package/build/esm/hoc/withLang.js

@@ -0,0 +1,8 @@
+// src/hoc/withLang.ts
+import LangContext from "../contexts/LangContext";
+import withPropContext from "./_withContext";
+var withLang_default = withPropContext("lang", LangContext);
+export {
+  withLang_default as default
+};
+//# sourceMappingURL=withLang.js.map

package/build/esm/hoc/withLang.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/hoc/withLang.ts"],
+  "sourcesContent": ["import type {Lang} from '../contexts/LangContext';\n\nimport LangContext from '../contexts/LangContext';\n\nimport withPropContext from './_withContext';\n\nexport interface WithLangProps {\n    lang: Lang;\n}\n\nexport default withPropContext<WithLangProps>('lang', LangContext);\n"],
+  "mappings": ";AAEA,OAAO,iBAAiB;AAExB,OAAO,qBAAqB;AAM5B,IAAO,mBAAQ,gBAA+B,QAAQ,WAAW;",
+  "names": []
+}

package/build/esm/hoc/withRouter.d.ts

@@ -0,0 +1,57 @@
+import type { RouterData } from '../contexts/RouterContext';
+export interface WithRouterProps {
+    router: RouterData;
+}
+declare const _default: <T extends Record<string, any>>(Component: React.ComponentType<any>) => {
+    new (props: Omit<T, "router">): {
+        render(): import("react").JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<Omit<T, "router">>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<Omit<T, "router">>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: import("react").ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<Omit<T, "router">>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Omit<T, "router">>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<Omit<T, "router">>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Omit<T, "router">>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Omit<T, "router">>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Omit<T, "router">>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Omit<T, "router">>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: Omit<T, "router">, context: any): {
+        render(): import("react").JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<Omit<T, "router">>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<Omit<T, "router">>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: import("react").ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<Omit<T, "router">>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Omit<T, "router">>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<Omit<T, "router">>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Omit<T, "router">>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Omit<T, "router">>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Omit<T, "router">>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Omit<T, "router">>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    displayName: string;
+    contextType: import("react").Context<any> & {
+        name?: string;
+    };
+};
+export default _default;

package/build/esm/hoc/withRouter.js

@@ -0,0 +1,8 @@
+// src/hoc/withRouter.ts
+import RouterContext from "../contexts/RouterContext";
+import withPropContext from "./_withContext";
+var withRouter_default = withPropContext("router", RouterContext);
+export {
+  withRouter_default as default
+};
+//# sourceMappingURL=withRouter.js.map

package/build/esm/hoc/withRouter.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/hoc/withRouter.ts"],
+  "sourcesContent": ["import type {RouterData} from '../contexts/RouterContext';\n\nimport RouterContext from '../contexts/RouterContext';\n\nimport withPropContext from './_withContext';\n\nexport interface WithRouterProps {\n    router: RouterData;\n}\n\nexport default withPropContext<WithRouterProps>('router', RouterContext);\n"],
+  "mappings": ";AAEA,OAAO,mBAAmB;AAE1B,OAAO,qBAAqB;AAM5B,IAAO,qBAAQ,gBAAiC,UAAU,aAAa;",
+  "names": []
+}

package/build/esm/hooks/index.d.ts

@@ -0,0 +1,8 @@
+export * from './usePopper';
+export * from './useTimer';
+export * from './useTranslation';
+export * from './usePopupState';
+export * from './useAnalytics';
+export * from './useVirtualElementRef';
+export * from './useShareHandler';
+export * from './useInterface';

package/build/esm/hooks/index.js

@@ -0,0 +1,10 @@
+// src/hooks/index.ts
+export * from "./usePopper";
+export * from "./useTimer";
+export * from "./useTranslation";
+export * from "./usePopupState";
+export * from "./useAnalytics";
+export * from "./useVirtualElementRef";
+export * from "./useShareHandler";
+export * from "./useInterface";
+//# sourceMappingURL=index.js.map

package/build/esm/hooks/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/hooks/index.ts"],
+  "sourcesContent": ["export * from './usePopper';\nexport * from './useTimer';\nexport * from './useTranslation';\nexport * from './usePopupState';\nexport * from './useAnalytics';\nexport * from './useVirtualElementRef';\nexport * from './useShareHandler';\nexport * from './useInterface';\n"],
+  "mappings": ";AAAA,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;",
+  "names": []
+}

package/build/esm/hooks/useAnalytics.d.ts

@@ -0,0 +1,22 @@
+import type { Router } from '../models';
+type GtagEventFunction = (data: {
+    type?: string;
+    event?: string;
+    action?: string;
+    params?: Record<string, string | number | undefined>;
+}, force?: boolean) => void;
+declare global {
+    interface Window {
+        gtag: undefined | null | GtagEventFunction;
+    }
+}
+export type AnalyticsParams = {
+    gtmId: string;
+    router: Router;
+    useConsent?: boolean;
+    consentMode?: 'base' | 'notification';
+};
+export declare const useAnalytics: ({ gtmId, router, useConsent }: AnalyticsParams) => {
+    sendEvent: GtagEventFunction;
+};
+export {};