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

package/build/cjs/config/index.js

@@ -0,0 +1,55 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/config/index.ts
+var config_exports = {};
+__export(config_exports, {
+  configure: () => configure,
+  getConfig: () => getConfig,
+  subscribeConfigure: () => subscribeConfigure
+});
+module.exports = __toCommonJS(config_exports);
+var import_uikit = require("@gravity-ui/uikit");
+var import_models = require("../models");
+var import_i18n = require("./i18n");
+var subs = /* @__PURE__ */ new Set();
+var config = {
+  lang: import_models.Lang.En
+};
+var configure = (newConfig = {}) => {
+  config = Object.assign({}, config, newConfig);
+  (0, import_i18n.configureI18N)({
+    lang: config.lang,
+    loc: config.loc
+  });
+  (0, import_uikit.configure)({
+    lang: Object.values(import_uikit.Lang).includes(config.lang) ? config.lang : import_uikit.Lang.En
+  });
+  subs.forEach((sub) => {
+    sub(config);
+  });
+};
+var subscribeConfigure = (sub) => {
+  subs.add(sub);
+  return () => {
+    subs.delete(sub);
+  };
+};
+var getConfig = () => config;
+//# sourceMappingURL=index.js.map

package/build/cjs/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": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,mBAA6D;AAE7D,oBAAmB;AAEnB,kBAA4B;AAI5B,IAAM,OAAwB,oBAAI,IAAI;AAEtC,IAAI,SAAiB;AAAA,EACjB,MAAM,mBAAK;AACf;AAEO,IAAM,YAAY,CAAC,YAA6B,CAAC,MAAM;AAC1D,WAAS,OAAO,OAAO,CAAC,GAAG,QAAQ,SAAS;AAE5C,iCAAc;AAAA,IACV,MAAM,OAAO;AAAA,IACb,KAAK,OAAO;AAAA,EAChB,CAAC;AAED,mBAAAA,WAAe;AAAA,IACX,MAAM,OAAO,OAAO,aAAAC,IAAS,EAAE,SAAS,OAAO,IAAiB,IACzD,OAAO,OACR,aAAAA,KAAU;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": ["configureUIKit", "LangUIKit"]
+}

package/build/cjs/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/cjs/constants.js

@@ -0,0 +1,68 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/constants.ts
+var constants_exports = {};
+__export(constants_exports, {
+  DEFAULT_LANGS: () => DEFAULT_LANGS,
+  DEFAULT_SETTINGS: () => DEFAULT_SETTINGS,
+  ERROR_CODES: () => ERROR_CODES,
+  LEGACY_LANG_ITEMS: () => LEGACY_LANG_ITEMS,
+  SUPPORTED_LANGS: () => SUPPORTED_LANGS
+});
+module.exports = __toCommonJS(constants_exports);
+var import_models = require("./models");
+var import_i18n = __toESM(require("./i18n"));
+var DEFAULT_SETTINGS = {
+  fullScreen: false,
+  singlePage: false,
+  wideFormat: false,
+  showMiniToc: true,
+  bookmarkedPage: false,
+  lang: import_models.Lang.En,
+  theme: import_models.Theme.Dark,
+  textSize: import_models.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: import_models.Lang.Ru, text: "\u0420\u0443\u0441\u0441\u043A\u0438\u0439" },
+  { value: import_models.Lang.En, text: "English" },
+  { value: import_models.Lang.He, text: "Hebrew" }
+];
+var SUPPORTED_LANGS = Object.keys(import_i18n.default);
+//# sourceMappingURL=constants.js.map

package/build/cjs/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;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAqC;AACrC,kBAAkB;AAEX,IAAM,mBAAmB;AAAA,EAC5B,YAAY;AAAA,EACZ,YAAY;AAAA,EACZ,YAAY;AAAA,EACZ,aAAa;AAAA,EACb,gBAAgB;AAAA,EAChB,MAAM,mBAAK;AAAA,EACX,OAAO,oBAAM;AAAA,EACb,UAAU,wBAAU;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,mBAAK,IAAI,MAAM,6CAAS;AAAA,EAChC,EAAC,OAAO,mBAAK,IAAI,MAAM,UAAS;AAAA,EAChC,EAAC,OAAO,mBAAK,IAAI,MAAM,SAAQ;AACnC;AACO,IAAM,kBAAkB,OAAO,KAAK,YAAAA,OAAK;",
+  "names": ["langs"]
+}

package/build/cjs/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/cjs/contexts/InterfaceContext.js

@@ -0,0 +1,64 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/contexts/InterfaceContext.tsx
+var InterfaceContext_exports = {};
+__export(InterfaceContext_exports, {
+  InterfaceContext: () => InterfaceContext,
+  InterfaceProvider: () => InterfaceProvider
+});
+module.exports = __toCommonJS(InterfaceContext_exports);
+var import_react = __toESM(require("react"));
+var InterfaceContext = (0, import_react.createContext)({
+  interface: {},
+  isHidden: () => false
+});
+var InterfaceProvider = ({
+  interface: viewerInterface,
+  children
+}) => {
+  const isHidden = (0, import_react.useCallback)(
+    (name) => {
+      if (viewerInterface && name in viewerInterface) {
+        return !viewerInterface[name];
+      }
+      return false;
+    },
+    [viewerInterface]
+  );
+  const value = (0, import_react.useMemo)(
+    () => ({
+      interface: viewerInterface,
+      isHidden
+    }),
+    [viewerInterface, isHidden]
+  );
+  return /* @__PURE__ */ import_react.default.createElement(InterfaceContext.Provider, { value }, children);
+};
+//# sourceMappingURL=InterfaceContext.js.map

package/build/cjs/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;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAyD;AAOlD,IAAM,uBAAmB,4BAAoC;AAAA,EAChE,WAAW,CAAC;AAAA,EACZ,UAAU,MAAM;AACpB,CAAC;AAOM,IAAM,oBAAsD,CAAC;AAAA,EAChE,WAAW;AAAA,EACX;AACJ,MAAM;AACF,QAAM,eAAW;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,YAAQ;AAAA,IACV,OAAO;AAAA,MACH,WAAW;AAAA,MACX;AAAA,IACJ;AAAA,IACA,CAAC,iBAAiB,QAAQ;AAAA,EAC9B;AAEA,SAAO,6BAAAA,QAAA,cAAC,iBAAiB,UAAjB,EAA0B,SAAe,QAAS;AAC9D;",
+  "names": ["React"]
+}

package/build/cjs/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/cjs/contexts/LangContext.js

@@ -0,0 +1,44 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/contexts/LangContext.ts
+var LangContext_exports = {};
+__export(LangContext_exports, {
+  Lang: () => Lang,
+  default: () => LangContext_default
+});
+module.exports = __toCommonJS(LangContext_exports);
+var import_namedContext = __toESM(require("./_namedContext"));
+var Lang = /* @__PURE__ */ ((Lang2) => {
+  Lang2["Ru"] = "ru";
+  Lang2["En"] = "en";
+  return Lang2;
+})(Lang || {});
+var LangContext_default = (0, import_namedContext.default)("Lang", process.env.DEFAULT_LANG || "en" /* En */);
+//# sourceMappingURL=LangContext.js.map

package/build/cjs/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;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,0BAAyB;AAGlB,IAAK,OAAL,kBAAKA,UAAL;AACH,EAAAA,MAAA,QAAK;AACL,EAAAA,MAAA,QAAK;AAFG,SAAAA;AAAA,GAAA;AAKZ,IAAO,0BAAQ,oBAAAC,SAAmB,QAAS,QAAQ,IAAI,gBAAyB,aAAO;",
+  "names": ["Lang", "namedContext"]
+}

package/build/cjs/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/cjs/contexts/RenderBodyHooksContext.js

@@ -0,0 +1,38 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/contexts/RenderBodyHooksContext.ts
+var RenderBodyHooksContext_exports = {};
+__export(RenderBodyHooksContext_exports, {
+  RenderBodyHooksContext: () => RenderBodyHooksContext
+});
+module.exports = __toCommonJS(RenderBodyHooksContext_exports);
+var import_namedContext = __toESM(require("./_namedContext"));
+var RenderBodyHooksContext = (0, import_namedContext.default)("RenderBodyHooks", []);
+//# sourceMappingURL=RenderBodyHooksContext.js.map

package/build/cjs/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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,0BAAyB;AAMlB,IAAM,6BAAyB,oBAAAA,SAA8B,mBAAmB,CAAC,CAAC;",
+  "names": ["namedContext"]
+}

package/build/cjs/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/cjs/contexts/RouterContext.js

@@ -0,0 +1,38 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/contexts/RouterContext.ts
+var RouterContext_exports = {};
+__export(RouterContext_exports, {
+  default: () => RouterContext_default
+});
+module.exports = __toCommonJS(RouterContext_exports);
+var import_namedContext = __toESM(require("./_namedContext"));
+var RouterContext_default = (0, import_namedContext.default)("Request", {});
+//# sourceMappingURL=RouterContext.js.map

package/build/cjs/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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAYA,0BAAyB;AAEzB,IAAO,4BAAQ,oBAAAA,SAAyB,WAAW,CAAC,CAAe;",
+  "names": ["namedContext"]
+}

package/build/cjs/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/cjs/contexts/_namedContext.js

@@ -0,0 +1,42 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/contexts/_namedContext.ts
+var namedContext_exports = {};
+__export(namedContext_exports, {
+  default: () => namedContext_default
+});
+module.exports = __toCommonJS(namedContext_exports);
+var import_react = __toESM(require("react"));
+function namedContext_default(name, defaults) {
+  const Context = import_react.default.createContext(defaults);
+  Context.displayName = name;
+  return Context;
+}
+//# sourceMappingURL=_namedContext.js.map

package/build/cjs/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;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAkB;AAEH,SAAR,qBAAqB,MAAc,UAA+B;AACrE,QAAM,UAAU,aAAAA,QAAM,cAAc,QAAQ;AAE5C,UAAQ,cAAc;AAEtB,SAAO;AACX;",
+  "names": ["React"]
+}

package/build/cjs/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/cjs/hoc/_withContext.js

@@ -0,0 +1,68 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/hoc/_withContext.tsx
+var withContext_exports = {};
+__export(withContext_exports, {
+  default: () => withContext_default
+});
+module.exports = __toCommonJS(withContext_exports);
+var import_react = __toESM(require("react"));
+var import_hoist_non_react_statics = __toESM(require("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 import_react.default.Component {
+      render() {
+        return /* @__PURE__ */ import_react.default.createElement(Component, __spreadValues(__spreadValues({}, this.props), { [prop]: this.context }));
+      }
+    }
+    __publicField(WithContextProp, "displayName", `with${contextName}(${componentName})`);
+    __publicField(WithContextProp, "contextType", Context);
+    (0, import_hoist_non_react_statics.default)(WithContextProp, Component);
+    return WithContextProp;
+  };
+}
+//# sourceMappingURL=_withContext.js.map

package/build/cjs/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;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAkB;AAClB,qCAAiC;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,aAAAA,QAAM,UAA4B;AAAA,MAK5D,SAAS;AACL,eAAO,6BAAAA,QAAA,cAAC,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,uCAAAC,SAAqB,iBAAiB,SAAS;AAE/C,WAAO;AAAA,EACX;AACJ;",
+  "names": ["React", "hoistNonReactStatics"]
+}