@foxford/sdk 5.0.0

package/index.cjs

@@ -0,0 +1,1794 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+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 __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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 __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Analytics: () => Analytics,
+  ApiService: () => import_services3.ApiService,
+  AppOptionsService: () => AppOptionsService,
+  CaptchaError: () => import_services3.CaptchaError,
+  CaptchaService: () => import_services3.CaptchaService,
+  CartService: () => CartService,
+  CourseService: () => CourseService,
+  Foxford: () => Foxford,
+  FoxfordAntibot: () => FoxfordAntibot,
+  LeadRequestService: () => LeadRequestService,
+  LeadRequestType: () => LeadRequestType,
+  ProductPackService: () => ProductPackService,
+  PromoService: () => PromoService,
+  RequestPlugin: () => import_services3.RequestPlugin,
+  ResponseFailPlugin: () => import_services3.ResponseFailPlugin,
+  ResponseSuccessPlugin: () => import_services3.ResponseSuccessPlugin,
+  TagService: () => TagService,
+  User: () => User,
+  UserService: () => UserService,
+  Widgets: () => Widgets
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/foxford.ts
+var import_services2 = require("@foxford/services");
+
+// src/antibot/index.ts
+if (window.antibotInitialized === void 0) window.antibotInitialized = false;
+var _FoxfordAntibot = class _FoxfordAntibot {
+  constructor(config = _FoxfordAntibot.DEFAULT_CONFIG) {
+    this.createAntibotFrame = (params) => {
+      if (window.location.hostname.endsWith("foxford.ru") || window.location.hostname.endsWith("netology-group.services") || this.config.debug) {
+        const frame = _FoxfordAntibot.createFrame(params.src, params == null ? void 0 : params.onload, params == null ? void 0 : params.onerror);
+        document.body.appendChild(frame);
+        window.antibotInitialized = true;
+      }
+    };
+    this.config = __spreadValues(__spreadValues({}, _FoxfordAntibot.DEFAULT_CONFIG), config);
+    if (!document.body) throw new Error("Body element not found");
+    if (window.onCaptureReady !== void 0) {
+      console.debug("Seo4Ajax crawler injects own callback. FoxfordAntibot initialization will be ignored.");
+      return;
+    }
+    if (_FoxfordAntibot.antibotIsInitialized()) {
+      console.debug("FoxfordAntibot is already mounted");
+      return;
+    }
+    if (process.env.NODE_ENV === "production") {
+      this.createAntibotFrame({
+        onerror: this.config.antibotOnerror,
+        onload: this.config.antibotOnload,
+        src: this.config.antibotFrameSrc
+      });
+    }
+  }
+  static antibotIsInitialized() {
+    if (window.antibotInitialized || document.querySelectorAll(`iframe.${_FoxfordAntibot.FRAME_CLASSNAME}`).length > 0) {
+      return true;
+    }
+    try {
+      return window.top ? window.self !== window.top && Boolean(window.top.antibotInitialized) : false;
+    } catch (e) {
+      return false;
+    }
+  }
+};
+_FoxfordAntibot.FOXFORD_ANTIBOT_URL = "https://foxford.ru/antibot/ping";
+_FoxfordAntibot.DEFAULT_CONFIG = {
+  antibotFrameSrc: _FoxfordAntibot.FOXFORD_ANTIBOT_URL
+};
+_FoxfordAntibot.FRAME_CLASSNAME = "antibot";
+_FoxfordAntibot.createFrame = (src, onload, onerror) => {
+  const frame = document.createElement("iframe");
+  frame.classList.add(_FoxfordAntibot.FRAME_CLASSNAME);
+  frame.style.width = "1px";
+  frame.style.height = "1px";
+  frame.style.position = "fixed";
+  frame.style.zIndex = "-1";
+  frame.style.top = "0";
+  frame.style.left = "0";
+  frame.style.border = "0";
+  frame.referrerPolicy = "origin";
+  frame.src = src;
+  frame.onload = (e) => {
+    if (typeof onload === "function") onload(e);
+  };
+  frame.onerror = () => {
+    if (typeof onerror === "function") onerror();
+  };
+  return frame;
+};
+var FoxfordAntibot = _FoxfordAntibot;
+
+// src/constants.ts
+var CSRF_COOKIE_NAME = "_csrf_token";
+var FOXFORD_HOST = "https://foxford.ru";
+
+// src/api/config.ts
+var apiBaseConfig = {
+  headers: { "X-Requested-With": "XMLHttpRequest" },
+  withXSRFToken: true,
+  xsrfCookieName: CSRF_COOKIE_NAME,
+  xsrfHeaderName: "X-CSRF-Token"
+};
+var apiConfig = __spreadProps(__spreadValues({}, apiBaseConfig), {
+  withCredentials: true
+});
+
+// src/utils/camelize.ts
+var import_camelcase_keys_deep = __toESM(require("camelcase-keys-deep"), 1);
+var import_decamelize_keys_deep = __toESM(require("decamelize-keys-deep"), 1);
+var camelize = (obj) => (0, import_camelcase_keys_deep.default)(obj);
+var decamelize = (obj) => (0, import_decamelize_keys_deep.default)(obj);
+
+// src/api/plugins/CamelizeRequestPlugin.ts
+var CamelizeRequestPlugin = class {
+  constructor() {
+    this.pluginType = "request";
+    this.pluginName = "camelizeRequestPlugin";
+  }
+  // требуется публичный метод, а для внутренней реализации может понадобиться this
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
+  execute(config, instance) {
+    return new Promise((resolve) => {
+      const convert = typeof config.camelize === "boolean" ? config.camelize : true;
+      if (convert) {
+        const defaultTransform = instance.defaults.transformResponse;
+        const camelizeResponse = (data) => {
+          return camelize(data);
+        };
+        if (defaultTransform) {
+          config.transformResponse = Array.isArray(defaultTransform) ? [...defaultTransform, camelizeResponse] : [defaultTransform, camelizeResponse];
+        }
+      }
+      resolve(config);
+    });
+  }
+  // требуется публичный метод, а для внутренней реализации может понадобиться this
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
+  isApplicable(config) {
+    return typeof config.camelize === "boolean" ? config.camelize : true;
+  }
+};
+
+// src/api/plugins/DataLayerEventDispatcherPlugin.ts
+var DataLayerEventDispatcherPlugin = class {
+  constructor() {
+    this.pluginType = "responseSuccess";
+    this.pluginName = "dataLayerEventDispatcherPlugin";
+  }
+  // требуется публичный метод, а для внутренней реализации может понадобиться this
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
+  execute(response) {
+    return new Promise((resolve) => {
+      try {
+        const rawResponse = JSON.parse(response.request.response);
+        if (Array.isArray(rawResponse["data_layer_events"])) {
+          if (!Array.isArray(window.dataLayer)) {
+            window.dataLayer = [];
+          }
+          window.dataLayer.push(...rawResponse["data_layer_events"]);
+        }
+      } catch (e) {
+      }
+      resolve(response);
+    });
+  }
+  // требуется публичный метод, а для внутренней реализации может понадобиться this
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
+  isApplicable() {
+    return true;
+  }
+};
+
+// src/utils/pathToRegexp.ts
+function lexer(str) {
+  const tokens = [];
+  let i = 0;
+  while (i < str.length) {
+    const char = str[i];
+    if (char === "*" || char === "+" || char === "?") {
+      tokens.push({ index: i, type: "MODIFIER", value: str[i++] });
+      continue;
+    }
+    if (char === "\\") {
+      tokens.push({ index: i++, type: "ESCAPED_CHAR", value: str[i++] });
+      continue;
+    }
+    if (char === "{") {
+      tokens.push({ index: i, type: "OPEN", value: str[i++] });
+      continue;
+    }
+    if (char === "}") {
+      tokens.push({ index: i, type: "CLOSE", value: str[i++] });
+      continue;
+    }
+    if (char === ":") {
+      let name = "";
+      let j = i + 1;
+      while (j < str.length) {
+        const code = str.charCodeAt(j);
+        if (
+          // `0-9`
+          code >= 48 && code <= 57 || // `A-Z`
+          code >= 65 && code <= 90 || // `a-z`
+          code >= 97 && code <= 122 || // `_`
+          code === 95
+        ) {
+          name += str[j++];
+          continue;
+        }
+        break;
+      }
+      if (!name) throw new TypeError(`Missing parameter name at ${i}`);
+      tokens.push({ index: i, type: "NAME", value: name });
+      i = j;
+      continue;
+    }
+    if (char === "(") {
+      let count = 1;
+      let pattern = "";
+      let j = i + 1;
+      if (str[j] === "?") {
+        throw new TypeError(`Pattern cannot start with "?" at ${j}`);
+      }
+      while (j < str.length) {
+        if (str[j] === "\\") {
+          pattern += str[j++] + str[j++];
+          continue;
+        }
+        if (str[j] === ")") {
+          count--;
+          if (count === 0) {
+            j++;
+            break;
+          }
+        } else if (str[j] === "(") {
+          count++;
+          if (str[j + 1] !== "?") {
+            throw new TypeError(`Capturing groups are not allowed at ${j}`);
+          }
+        }
+        pattern += str[j++];
+      }
+      if (count) throw new TypeError(`Unbalanced pattern at ${i}`);
+      if (!pattern) throw new TypeError(`Missing pattern at ${i}`);
+      tokens.push({ index: i, type: "PATTERN", value: pattern });
+      i = j;
+      continue;
+    }
+    tokens.push({ index: i, type: "CHAR", value: str[i++] });
+  }
+  tokens.push({ index: i, type: "END", value: "" });
+  return tokens;
+}
+function parse(str, options = {}) {
+  const tokens = lexer(str);
+  const { prefixes = "./" } = options;
+  const defaultPattern = `[^${escapeString(options.delimiter || "/#?")}]+?`;
+  const result = [];
+  let key = 0;
+  let i = 0;
+  let path = "";
+  const tryConsume = (type) => {
+    var _a, _b;
+    if (i < tokens.length && ((_a = tokens[i]) == null ? void 0 : _a.type) === type) return (_b = tokens[i++]) == null ? void 0 : _b.value;
+    return void 0;
+  };
+  const mustConsume = (type) => {
+    var _a, _b;
+    const value = tryConsume(type);
+    if (value !== void 0) return value;
+    throw new TypeError(`Unexpected ${(_a = tokens[i]) == null ? void 0 : _a.type} at ${(_b = tokens[i]) == null ? void 0 : _b.index}, expected ${type}`);
+  };
+  const consumeText = () => {
+    let result2 = "";
+    let value;
+    while (value = tryConsume("CHAR") || tryConsume("ESCAPED_CHAR")) {
+      result2 += value;
+    }
+    return result2;
+  };
+  while (i < tokens.length) {
+    const char = tryConsume("CHAR");
+    const name = tryConsume("NAME");
+    const pattern = tryConsume("PATTERN");
+    if (name || pattern) {
+      let prefix = char || "";
+      if (prefixes.indexOf(prefix) === -1) {
+        path += prefix;
+        prefix = "";
+      }
+      if (path) {
+        result.push(path);
+        path = "";
+      }
+      result.push({
+        modifier: tryConsume("MODIFIER") || "",
+        name: name || key++,
+        pattern: pattern || defaultPattern,
+        prefix,
+        suffix: ""
+      });
+      continue;
+    }
+    const value = char || tryConsume("ESCAPED_CHAR");
+    if (value) {
+      path += value;
+      continue;
+    }
+    if (path) {
+      result.push(path);
+      path = "";
+    }
+    const open = tryConsume("OPEN");
+    if (open) {
+      const prefix = consumeText();
+      const name2 = tryConsume("NAME") || "";
+      const pattern2 = tryConsume("PATTERN") || "";
+      const suffix = consumeText();
+      mustConsume("CLOSE");
+      result.push({
+        modifier: tryConsume("MODIFIER") || "",
+        name: name2 || (pattern2 ? key++ : ""),
+        pattern: name2 && !pattern2 ? defaultPattern : pattern2,
+        prefix,
+        suffix
+      });
+      continue;
+    }
+    mustConsume("END");
+  }
+  return result;
+}
+function escapeString(str) {
+  return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");
+}
+function flags(options) {
+  return options && options.sensitive ? "" : "i";
+}
+function regexpToRegexp(path, keys) {
+  if (!keys) return path;
+  const groupsRegex = /\((?:\?<(.*?)>)?(?!\?)/g;
+  let index = 0;
+  let execResult = groupsRegex.exec(path.source);
+  while (execResult) {
+    keys.push({
+      modifier: "",
+      // Use parenthesized substring match if available, index otherwise
+      name: execResult[1] || index++,
+      pattern: "",
+      prefix: "",
+      suffix: ""
+    });
+    execResult = groupsRegex.exec(path.source);
+  }
+  return path;
+}
+function arrayToRegexp(paths, keys, options) {
+  const parts = paths.map((path) => pathToRegexp(path, keys, options).source);
+  return new RegExp(`(?:${parts.join("|")})`, flags(options));
+}
+function stringToRegexp(path, keys, options) {
+  return tokensToRegexp(parse(path, options), keys, options);
+}
+function tokensToRegexp(tokens, keys, options = {}) {
+  const {
+    strict = false,
+    start = true,
+    end = true,
+    encode = (x) => x,
+    delimiter = "/#?",
+    endsWith = ""
+  } = options;
+  const endsWithRe = `[${escapeString(endsWith)}]|$`;
+  const delimiterRe = `[${escapeString(delimiter)}]`;
+  let route = start ? "^" : "";
+  for (const token of tokens) {
+    if (typeof token === "string") {
+      route += escapeString(encode(token));
+    } else {
+      const prefix = escapeString(encode(token.prefix));
+      const suffix = escapeString(encode(token.suffix));
+      if (token.pattern) {
+        if (keys) keys.push(token);
+        if (prefix || suffix) {
+          if (token.modifier === "+" || token.modifier === "*") {
+            const mod = token.modifier === "*" ? "?" : "";
+            route += `(?:${prefix}((?:${token.pattern})(?:${suffix}${prefix}(?:${token.pattern}))*)${suffix})${mod}`;
+          } else {
+            route += `(?:${prefix}(${token.pattern})${suffix})${token.modifier}`;
+          }
+        } else {
+          if (token.modifier === "+" || token.modifier === "*") {
+            route += `((?:${token.pattern})${token.modifier})`;
+          } else {
+            route += `(${token.pattern})${token.modifier}`;
+          }
+        }
+      } else {
+        route += `(?:${prefix}${suffix})${token.modifier}`;
+      }
+    }
+  }
+  if (end) {
+    if (!strict) route += `${delimiterRe}?`;
+    route += !options.endsWith ? "$" : `(?=${endsWithRe})`;
+  } else {
+    const endToken = tokens[tokens.length - 1];
+    const isEndDelimited = typeof endToken === "string" ? delimiterRe.indexOf(endToken[endToken.length - 1]) > -1 : endToken === void 0;
+    if (!strict) {
+      route += `(?:${delimiterRe}(?=${endsWithRe}))?`;
+    }
+    if (!isEndDelimited) {
+      route += `(?=${delimiterRe}|${endsWithRe})`;
+    }
+  }
+  return new RegExp(route, flags(options));
+}
+function pathToRegexp(path, keys, options) {
+  if (path instanceof RegExp) return regexpToRegexp(path, keys);
+  if (Array.isArray(path)) return arrayToRegexp(path, keys, options);
+  return stringToRegexp(path, keys, options);
+}
+
+// src/utils/matchPath.ts
+var cache = {};
+var cacheLimit = 1e4;
+var cacheCount = 0;
+function compilePath(path, options) {
+  const { end = false, strict = false, sensitive = false } = options;
+  const cacheKey = `${path}/${end.toString()}/${strict.toString()}/${sensitive.toString()}`;
+  const pathCache = cache[cacheKey] || (cache[cacheKey] = {});
+  if (pathCache[path]) return pathCache[path];
+  const keys = [];
+  const regexp = pathToRegexp(path, keys, options);
+  const result = { keys, regexp };
+  if (cacheCount < cacheLimit) {
+    pathCache[path] = result;
+    cacheCount += 1;
+  }
+  return result;
+}
+var matchPath = (pathname, options) => {
+  if (options === void 0) {
+    options = {};
+  }
+  if (typeof options === "string" || Array.isArray(options)) {
+    options = {
+      path: options
+    };
+  }
+  const _options = options, path = _options.path, _options$exact = _options.exact, exact = _options$exact === void 0 ? false : _options$exact, _options$strict = _options.strict, strict = _options$strict === void 0 ? false : _options$strict, _options$sensitive = _options.sensitive, sensitive = _options$sensitive === void 0 ? false : _options$sensitive;
+  const paths = [].concat(path);
+  return paths.reduce(function(matched, path2) {
+    if (!path2 && path2 !== "") return null;
+    if (matched) return matched;
+    const _compilePath = compilePath(path2, {
+      end: exact,
+      sensitive,
+      strict
+    }), regexp = _compilePath.regexp, keys = _compilePath.keys;
+    const match = regexp.exec(pathname);
+    if (!match) return null;
+    const url = match[0], values = match.slice(1);
+    const isExact = pathname === url;
+    if (exact && !isExact) return null;
+    return {
+      // the matched portion of the URL
+      isExact,
+      // whether or not we matched exactly
+      params: keys.reduce(function(memo, key, index) {
+        memo[key.name] = values[index];
+        return memo;
+      }, {}),
+      path: path2,
+      // the path used to match
+      url: path2 === "/" && url === "" ? "/" : url
+    };
+  }, null);
+};
+
+// src/api/plugins/ReferrerRequestPlugin.ts
+var REFERRER_PAYLOAD_NAME = "referrer";
+var REFERRER_ENDPOINTS = {
+  delete: [],
+  get: [],
+  patch: [],
+  post: ["/api/email_registration", "/api/phone_registration", "/api/auth/registration"],
+  put: []
+};
+var ReferrerRequestPlugin = class {
+  constructor() {
+    this.pluginType = "request";
+    this.pluginName = "referrerRequestPlugin";
+  }
+  // требуется публичный метод, а для внутренней реализации может понадобиться this
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
+  execute(config) {
+    return new Promise((resolve) => {
+      const referrer = String(window.__fox_referrer__);
+      if (!referrer) {
+        resolve(config);
+      }
+      config.params = __spreadProps(__spreadValues({}, config.params), {
+        [REFERRER_PAYLOAD_NAME]: referrer
+      });
+      resolve(config);
+    });
+  }
+  // требуется публичный метод, а для внутренней реализации может понадобиться this
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
+  getEndpoints() {
+    return REFERRER_ENDPOINTS;
+  }
+  isApplicable(config) {
+    var _a;
+    const { method, url: pathUrl = "" } = config;
+    const endpointMethod = method ? method : "post";
+    const endpoints = this.getEndpoints();
+    const referrerURLs = (_a = endpoints[endpointMethod]) != null ? _a : [];
+    return referrerURLs.some((url) => url === pathUrl || pathUrl && matchPath(pathUrl, { exact: true, path: url })) || config.withReferrer === true;
+  }
+};
+
+// src/api/index.ts
+var referrerRequestPlugin = new ReferrerRequestPlugin();
+var camelizeRequestPlugin = new CamelizeRequestPlugin();
+var dataLayerEventDispatcherPlugin = new DataLayerEventDispatcherPlugin();
+var defaultPlugins = [
+  camelizeRequestPlugin,
+  referrerRequestPlugin,
+  dataLayerEventDispatcherPlugin
+];
+
+// src/api/plugins/CaptchaPlugin.ts
+var import_services = require("@foxford/services");
+var CaptchaPlugin = class {
+  constructor(captchaConfig) {
+    this.pluginType = "responseFail";
+    this.pluginName = "captchaPlugin";
+    this.captchaConfig = captchaConfig;
+  }
+  // требуется публичный метод, а для внутренней реализации может понадобиться this
+  // eslint-disable-next-line complexity
+  execute(error) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      try {
+        const captchaConfig = typeof this.captchaConfig === "function" ? this.captchaConfig() : this.captchaConfig;
+        if (!captchaConfig) return error;
+        const { settings = {} } = (_b = (_a = error.response) == null ? void 0 : _a.data) != null ? _b : {};
+        const { provider } = settings;
+        const siteKey = settings.siteKey || settings.site_key || void 0;
+        if (!settings || !provider || !siteKey) return error;
+        this.captcha = new import_services.CaptchaService(__spreadProps(__spreadValues({}, captchaConfig), {
+          provider,
+          sitekey: siteKey
+        }));
+        const { config } = error;
+        const captchaAnswer = yield this.captcha.execute({
+          location: config.url,
+          method: config.method
+        });
+        if (captchaAnswer === null || captchaAnswer === void 0 || typeof (captchaAnswer == null ? void 0 : captchaAnswer.captcha_token) !== "string") {
+          return config;
+        }
+        const captchaPayload = {
+          verification: {
+            settings: {
+              token: captchaAnswer.captcha_token
+            },
+            type: "captcha"
+          }
+        };
+        if (config.method === "get") {
+          config.params = __spreadValues(__spreadValues({}, config.params), captchaPayload);
+        }
+        if (typeof config.data === "string") {
+          try {
+            let data = JSON.parse(config.data);
+            data = __spreadValues(__spreadValues({}, data), captchaPayload);
+            config.data = JSON.stringify(data);
+          } catch (err) {
+            console.error(err);
+          }
+        } else if (config.data instanceof FormData) {
+          const formData = config.data;
+          formData.append("verification[settings][token]", captchaPayload.verification.settings.token);
+          formData.append("verification[type]", captchaPayload.verification.type);
+          config.data = formData;
+        } else if (typeof config.data === "object") {
+          config.data = __spreadValues(__spreadValues({}, config.data), captchaPayload);
+        }
+        return config;
+      } catch (error2) {
+        return error2;
+      }
+    });
+  }
+  // требуется публичный метод, а для внутренней реализации может понадобиться this
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
+  isApplicable(error) {
+    var _a;
+    return ((_a = error.response) == null ? void 0 : _a.status) === 449;
+  }
+};
+
+// src/api-plugins.ts
+var getPlugins = (config, captchaConfig) => {
+  const apiPlugins = config.plugins || [];
+  const addedPlugins = [];
+  const resultPlugins = [];
+  apiPlugins.forEach((plugin) => {
+    if (!addedPlugins.includes(plugin.pluginName)) {
+      resultPlugins.push(plugin);
+      addedPlugins.push(plugin.pluginName);
+    }
+  });
+  defaultPlugins.forEach((plugin) => {
+    if (!addedPlugins.includes(plugin.pluginName)) {
+      resultPlugins.push(plugin);
+      addedPlugins.push(plugin.pluginName);
+    }
+  });
+  if (captchaConfig) {
+    const captchaRequestPlugin = new CaptchaPlugin(captchaConfig);
+    if (!addedPlugins.includes(captchaRequestPlugin.pluginName)) {
+      resultPlugins.push(captchaRequestPlugin);
+      addedPlugins.push(captchaRequestPlugin.pluginName);
+    }
+  }
+  return resultPlugins;
+};
+
+// src/services/app-options.ts
+var AppOptionsService = class {
+  constructor(apiInstance, eventName) {
+    this.appOptions = null;
+    this.api = apiInstance;
+    this.eventName = eventName;
+  }
+  getCurrentAppOptions() {
+    return __async(this, null, function* () {
+      if (this.appOptions) return this.appOptions;
+      const data = yield this.getAppOptions();
+      return data;
+    });
+  }
+  /**
+   * Get app options data from api
+   */
+  getAppOptions() {
+    return __async(this, null, function* () {
+      const result = yield this.api.get(`/api/app_options`);
+      this.appOptions = result.data;
+      if (window) window.dispatchEvent(new CustomEvent(this.eventName, { detail: result.data }));
+      return result.data;
+    });
+  }
+};
+
+// src/services/cart.ts
+var CartService = class {
+  constructor(apiInstance) {
+    this.api = apiInstance;
+  }
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
+  createCartItem(id, type) {
+    return {
+      cart_item_type: type,
+      resource_id: id
+    };
+  }
+  addCartItemToCart(cartItem) {
+    return __async(this, null, function* () {
+      const { data } = yield this.api.post(`/api/cart_items`, {
+        cart_item: cartItem
+      });
+      return data;
+    });
+  }
+};
+
+// src/services/course.ts
+var CourseService = class {
+  constructor(apiInstance) {
+    this.api = apiInstance;
+  }
+  getCourse(id) {
+    return __async(this, null, function* () {
+      if (typeof id !== "number") throw new TypeError("id is wrong");
+      const { data } = yield this.api.get(`/api/courses/${id}`);
+      return data;
+    });
+  }
+  enrollCourse(id) {
+    return __async(this, null, function* () {
+      if (typeof id !== "number") throw new TypeError("id is wrong");
+      yield this.api.post(`/api/courses/${id}/users_courses`);
+    });
+  }
+};
+
+// src/services/lead-request.ts
+var LR_REGISTRATION_SET = "LeadRequest.registration.set";
+var LeadRequestType = /* @__PURE__ */ ((LeadRequestType2) => {
+  LeadRequestType2["Algorithmics"] = "LeadRequests::Algorithmics";
+  LeadRequestType2["External"] = "LeadRequests::External";
+  LeadRequestType2["Callback"] = "LeadRequests::Callback";
+  LeadRequestType2["Basic"] = "LeadRequests::Basic";
+  LeadRequestType2["Main"] = "LeadRequests::Main";
+  LeadRequestType2["Coach"] = "LeadRequests::Coach";
+  LeadRequestType2["Media"] = "LeadRequests::Media";
+  LeadRequestType2["MiniGroup"] = "LeadRequests::MiniGroup";
+  LeadRequestType2["Externship"] = "LeadRequests::Externship";
+  LeadRequestType2["CoachUserCoursePlanUpgradeCallback"] = "LeadRequests::CoachUserCoursePlanUpgradeCallback";
+  LeadRequestType2["ParentCallback"] = "LeadRequests::ParentCallback";
+  LeadRequestType2["TeacherCallback"] = "LeadRequests::TeacherCallback";
+  LeadRequestType2["Email"] = "LeadRequests::EmailSubscription";
+  LeadRequestType2["IThubLead"] = "LeadRequests::IThubLead";
+  return LeadRequestType2;
+})(LeadRequestType || {});
+var LeadRequestService = class {
+  constructor(apiInstance) {
+    this.types = LeadRequestType;
+    this.api = apiInstance;
+  }
+  /**
+   * Create lead request
+   * @param {LeadRequestType} type
+   * @param {LeadRequest['context']} context
+   * @param {LeadRequestPayload} data
+   */
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
+  createLeadRequest(type, context, data = {}) {
+    const payload = data;
+    return __spreadProps(__spreadValues({}, payload), {
+      agreement: true,
+      context,
+      type
+    });
+  }
+  /**
+   * Send lead request with specific data
+   * @param {LeadRequest} leadRequest
+   */
+  send(leadRequest) {
+    return __async(this, null, function* () {
+      const { data } = yield this.api.post(`/api/lead_requests`, {
+        lead_request: leadRequest
+      });
+      if (data.newUser) {
+        window.dispatchEvent(new CustomEvent(LR_REGISTRATION_SET));
+      }
+      return { leadRequest, response: data };
+    });
+  }
+  /**
+   * Update lead request with specific data
+   * @param {string} id
+   * @param {LeadRequestPayload} lrData
+   */
+  update(_0) {
+    return __async(this, arguments, function* (id, lrData = {}) {
+      const { data } = yield this.api.put(`/api/lead_requests/${id}`, {
+        lead_request: lrData
+      });
+      return data;
+    });
+  }
+};
+
+// src/services/product-pack.ts
+var ProductPackService = class {
+  constructor(apiInstance) {
+    this.api = apiInstance;
+  }
+  getProductPack(id) {
+    return __async(this, null, function* () {
+      if (typeof id !== "number") throw new TypeError("id is wrong");
+      const { data } = yield this.api.get(`/api/product_packs/${id}`);
+      return data;
+    });
+  }
+};
+
+// src/services/promo.ts
+var PromoService = class {
+  constructor(apiInstance) {
+    this.api = apiInstance;
+  }
+  checkPromocode(code) {
+    return __async(this, null, function* () {
+      const { data } = yield this.api.get(`/api/promo_codes/invite/${code}`);
+      return data;
+    });
+  }
+  /**
+   * Send data if user saw the promo code
+   * @param {string} promoCode
+   * @returns {Promise}
+   */
+  trackCodeCampaign(promoCode) {
+    return __async(this, null, function* () {
+      yield this.api.post(`/api/tracking/promo_code`, { promo_code: promoCode });
+    });
+  }
+};
+
+// src/services/tag.ts
+var TagService = class {
+  constructor(apiInstance) {
+    this.api = apiInstance;
+  }
+  addTag(id) {
+    return __async(this, null, function* () {
+      const { data } = yield this.api.post(`/api/user/tag?id=${id}`);
+      return data;
+    });
+  }
+};
+
+// src/entities/user/constants.ts
+var GRADE_MAP = {
+  1: "1 \u043A\u043B\u0430\u0441\u0441",
+  2: "2 \u043A\u043B\u0430\u0441\u0441",
+  3: "3 \u043A\u043B\u0430\u0441\u0441",
+  4: "4 \u043A\u043B\u0430\u0441\u0441",
+  5: "5 \u043A\u043B\u0430\u0441\u0441",
+  6: "6 \u043A\u043B\u0430\u0441\u0441",
+  7: "7 \u043A\u043B\u0430\u0441\u0441",
+  8: "8 \u043A\u043B\u0430\u0441\u0441",
+  9: "9 \u043A\u043B\u0430\u0441\u0441",
+  10: "10 \u043A\u043B\u0430\u0441\u0441",
+  11: "11 \u043A\u043B\u0430\u0441\u0441"
+};
+var DEFAULT_USER = {
+  address: {
+    building: null,
+    cityId: null,
+    cityName: null,
+    countryId: null,
+    countryName: null,
+    house: null,
+    index: null,
+    regionId: null,
+    regionName: null,
+    room: null,
+    street: null
+  },
+  avatarUrl: "",
+  bonus: {
+    giftAmount: 0,
+    realMoneyAmount: 0
+  },
+  bonusAmount: 0,
+  cartItemsCount: 0,
+  cartTemplateId: null,
+  createdAt: null,
+  disciplineIds: [],
+  email: "",
+  emailConfirmed: false,
+  externshipUser: false,
+  fakeEmail: false,
+  fakeUser: false,
+  firstName: "",
+  freeAccessFinishesAt: null,
+  fullName: "",
+  grade: {
+    id: null,
+    index: null,
+    name: "",
+    translit: ""
+  },
+  gradeChecked: false,
+  hasAccessToAttestationSheets: false,
+  hasAccessToMultiDaysStreaks: false,
+  hasActivePurchases: false,
+  hasAttemptsSolveExamRehearsals: false,
+  hasBookmarks: false,
+  hasExternshipAttestationAccess: false,
+  hasPurchasedExternshipContracts: false,
+  id: null,
+  isAgent: false,
+  isCoach: false,
+  isCustomer: null,
+  isElementaryPupil: false,
+  isExternshipCoach: false,
+  isGraduated: false,
+  isMiniGroupTeacher: false,
+  isParent: false,
+  lastName: "",
+  locale: null,
+  methodist: false,
+  middleName: "",
+  onboardingFinished: false,
+  onboardingFinishedAt: null,
+  parentPhone: null,
+  parentPhoneConfirmed: false,
+  phone: null,
+  phoneConfirmed: false,
+  privacy: {
+    publicProfile: false
+  },
+  profileEnriched: false,
+  purchaseAnyExternshipContracts: false,
+  recapUuid: null,
+  shortName: "",
+  skype: null,
+  socialNets: [],
+  socializationProfile: null,
+  tags: null,
+  timezone: null,
+  type: null,
+  webSocketNotificationsJwt: null
+};
+
+// src/entities/user/index.ts
+var _User = class _User {
+  constructor(props, isDefault = false) {
+    this.props = props;
+    this.isDefault = isDefault;
+    /**
+     * Возвращает роль пользователя
+     * @returns {UserRole} роль как строка
+     */
+    this.getRole = () => {
+      if (this.isCoach) return "\u0420\u0435\u043F\u0435\u0442\u0438\u0442\u043E\u0440";
+      if (this.isAgent) return "\u0423\u0447\u0438\u0442\u0435\u043B\u044C";
+      if (this.isParent) return "\u0420\u043E\u0434\u0438\u0442\u0435\u043B\u044C";
+      switch (this.type) {
+        case "pupil":
+          return this.getPupilRole();
+        case "agent":
+          return "\u0423\u0447\u0438\u0442\u0435\u043B\u044C";
+        default:
+          return "\u0423\u0447\u0435\u043D\u0438\u043A";
+      }
+    };
+    /**
+     * Возвращает фамилию и инициалы юзера
+     * @param {User} user
+     * @return {string} 'Пупкин В.'
+     */
+    this.getInitials = () => {
+      var _a, _b;
+      return `${this.lastName}${this.firstName ? ` ${(_a = this.firstName[0]) == null ? void 0 : _a.toUpperCase()}.` : ""}${this.middleName !== "" && this.middleName !== null ? ` ${(_b = this.middleName[0]) == null ? void 0 : _b.toUpperCase()}.` : ""}`;
+    };
+  }
+  get id() {
+    return this.props.id;
+  }
+  get email() {
+    return this.props.email;
+  }
+  get firstName() {
+    return this.props.firstName;
+  }
+  get middleName() {
+    return this.props.middleName;
+  }
+  get lastName() {
+    return this.props.lastName;
+  }
+  get fullName() {
+    return this.props.fullName;
+  }
+  get shortName() {
+    return this.props.shortName;
+  }
+  get createdAt() {
+    return this.props.createdAt;
+  }
+  get timezone() {
+    return this.props.timezone;
+  }
+  get locale() {
+    return this.props.locale;
+  }
+  get grade() {
+    return this.props.grade;
+  }
+  get phone() {
+    return this.props.phone;
+  }
+  get avatarUrl() {
+    return this.props.avatarUrl;
+  }
+  get isParent() {
+    return this.props.isParent;
+  }
+  get isGraduated() {
+    return this.props.isGraduated;
+  }
+  get gradeChecked() {
+    return this.props.gradeChecked;
+  }
+  get type() {
+    return this.props.type;
+  }
+  get isCoach() {
+    return this.props.isCoach;
+  }
+  get isMiniGroupTeacher() {
+    return this.props.isMiniGroupTeacher;
+  }
+  get isExternshipCoach() {
+    return this.props.isExternshipCoach;
+  }
+  get isAgent() {
+    return this.props.isAgent;
+  }
+  get methodist() {
+    return this.props.methodist;
+  }
+  get address() {
+    return this.props.address;
+  }
+  get socialNets() {
+    return this.props.socialNets;
+  }
+  get skype() {
+    return this.props.skype;
+  }
+  get settings() {
+    return this.props.settings;
+  }
+  get bonus() {
+    return this.props.bonus;
+  }
+  get bonusAmount() {
+    return this.props.bonusAmount;
+  }
+  get hasActivePurchases() {
+    return this.props.hasActivePurchases;
+  }
+  get hasAttemptsSolveExamRehearsals() {
+    return this.props.hasAttemptsSolveExamRehearsals;
+  }
+  get hasBookmarks() {
+    return this.props.hasBookmarks;
+  }
+  get tags() {
+    return this.props.tags;
+  }
+  get cartTemplateId() {
+    return this.props.cartTemplateId;
+  }
+  get cartItemsCount() {
+    return this.props.cartItemsCount;
+  }
+  get onboardingFinished() {
+    return this.props.onboardingFinished;
+  }
+  get onboardingFinishedAt() {
+    return this.props.onboardingFinishedAt;
+  }
+  get emailConfirmed() {
+    return this.props.emailConfirmed;
+  }
+  get phoneConfirmed() {
+    return this.props.phoneConfirmed;
+  }
+  get fakeEmail() {
+    return this.props.fakeEmail;
+  }
+  get fakeUser() {
+    return this.props.fakeUser;
+  }
+  get profileEnriched() {
+    return this.props.profileEnriched;
+  }
+  get recapUuid() {
+    return this.props.recapUuid;
+  }
+  get disciplineIds() {
+    return this.props.disciplineIds;
+  }
+  get privacy() {
+    return this.props.privacy;
+  }
+  get parentPhone() {
+    return this.props.parentPhone;
+  }
+  get parentPhoneConfirmed() {
+    return this.props.parentPhoneConfirmed;
+  }
+  get isCustomer() {
+    return this.props.isCustomer;
+  }
+  get hasAccessToMultiDaysStreaks() {
+    return this.props.hasAccessToMultiDaysStreaks;
+  }
+  get isElementaryPupil() {
+    return this.props.isElementaryPupil;
+  }
+  get webSocketNotificationsJwt() {
+    return this.props.webSocketNotificationsJwt;
+  }
+  get hasAccessToAttestationSheets() {
+    return this.props.hasAccessToAttestationSheets;
+  }
+  get externshipUser() {
+    return this.props.externshipUser;
+  }
+  get hasPurchasedExternshipContracts() {
+    return this.props.hasPurchasedExternshipContracts;
+  }
+  get hasExternshipAttestationAccess() {
+    return this.props.hasExternshipAttestationAccess;
+  }
+  get socializationProfile() {
+    return this.props.socializationProfile;
+  }
+  get freeAccessFinishesAt() {
+    return this.props.freeAccessFinishesAt;
+  }
+  get hasUnseenRoomFeatures() {
+    return this.props.hasUnseenRoomFeatures;
+  }
+  get purchaseAnyExternshipContracts() {
+    return this.props.purchaseAnyExternshipContracts;
+  }
+  /**
+   * Глубокое клонирование объекта с защитой от циклических ссылок
+   * @private
+   * @param obj - объект для клонирования
+   * @param hash - WeakMap для отслеживания уже клонированных объектов
+   * @returns клонированный объект
+   */
+  static deepClone(obj, hash = /* @__PURE__ */ new WeakMap()) {
+    if (obj === null || typeof obj !== "object") {
+      return obj;
+    }
+    if (hash.has(obj)) {
+      return hash.get(obj);
+    }
+    if (obj instanceof Date) {
+      return new Date(obj.getTime());
+    }
+    if (obj instanceof RegExp) {
+      return new RegExp(obj.source, obj.flags);
+    }
+    if (Array.isArray(obj)) {
+      const clonedArr = [];
+      hash.set(obj, clonedArr);
+      obj.forEach((item, index) => {
+        clonedArr[index] = this.deepClone(item, hash);
+      });
+      return clonedArr;
+    }
+    const clonedObj = Object.create(Object.getPrototypeOf(obj));
+    hash.set(obj, clonedObj);
+    Object.keys(obj).forEach((key) => {
+      clonedObj[key] = this.deepClone(obj[key], hash);
+    });
+    return clonedObj;
+  }
+  static createDefault() {
+    return new _User(this.deepClone(DEFAULT_USER), true);
+  }
+  /**
+   * Санитизирует строку: удаляет null-байты и обрезает пробелы
+   * @private
+   * @param str - исходная строка
+   * @returns санитизированная строка
+   */
+  static sanitizeString(str) {
+    if (typeof str !== "string") {
+      console.warn("[User] Invalid string type:", typeof str);
+      return String(str);
+    }
+    return str.replace(/\x00/g, "").trim();
+  }
+  static fromApi(input) {
+    const sanitizedData = this.sanitizeUserData(this.deepClone(input));
+    return new _User(sanitizedData);
+  }
+  /**
+   * Санитизирует данные пользователя
+   * @private
+   * @param data - исходные данные
+   * @returns санитизированные данные
+   */
+  static sanitizeUserData(data) {
+    return __spreadProps(__spreadValues({}, data), {
+      email: this.sanitizeString(data.email),
+      firstName: this.sanitizeString(data.firstName),
+      fullName: this.sanitizeString(data.fullName),
+      lastName: this.sanitizeString(data.lastName),
+      middleName: data.middleName ? this.sanitizeString(data.middleName) : data.middleName,
+      shortName: this.sanitizeString(data.shortName)
+    });
+  }
+  isDefaultUser() {
+    return this.isDefault;
+  }
+  isLoggedIn() {
+    return this.id && this.id > 0 ? true : false;
+  }
+  /**
+   * Возвращает тектовое представление роли / класса пользователя
+   *
+   * @returns {UserRole}
+   */
+  getPupilRole() {
+    if (this.grade.index === 0) {
+      return "\u0414\u043E\u0448\u043A\u043E\u043B\u044C\u043D\u0438\u043A";
+    }
+    if (this.grade.index == null) return "\u0412\u044B\u043F\u0443\u0441\u043A\u043D\u0438\u043A";
+    return _User.getGradeString(this.grade.index);
+  }
+  toJson() {
+    return JSON.stringify(this.props);
+  }
+};
+_User.getGradeString = (index) => GRADE_MAP[index] || GRADE_MAP[1];
+var User = _User;
+
+// src/errors/login-error.ts
+var LogginError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "LogginError";
+    this.cause = options == null ? void 0 : options.cause;
+  }
+};
+
+// src/errors/confirmation-code-error.ts
+var ConfirmationCodeRequestError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "ConfirmationCodeRequestError";
+    this.cause = options == null ? void 0 : options.cause;
+  }
+};
+
+// src/services/user.ts
+var UserService = class {
+  constructor(apiInstance, appOptionsService) {
+    this.api = apiInstance;
+    this.appOptionsService = appOptionsService;
+  }
+  /**
+   * Create user instance
+   * @param {UserDTO} data data of user
+   */
+  static createUser(data) {
+    return User.fromApi(data);
+  }
+  /**
+   * Create default user
+   * @returns {User}
+   */
+  static createDefaultUser() {
+    return User.createDefault();
+  }
+  /**
+   * Get current user data
+   * @return {Promise} Server response with user data
+   */
+  getUser() {
+    return __async(this, null, function* () {
+      try {
+        const data = yield this.api.get("/api/user/me").then(({ data: data2 }) => data2);
+        const user = User.fromApi(data);
+        return user;
+      } catch (e) {
+        return User.createDefault();
+      }
+    });
+  }
+  /**
+   * Логин или регистрация юзера по email
+   * @param email email юзера
+   * @param password пароль
+   * @returns {Promise<{ user: User; result: LoginOrRegistrationResponse }>}
+   */
+  loginByEmail(email, password) {
+    return __async(this, null, function* () {
+      const data = yield this.api.post("/api/email_registration", {
+        email,
+        password
+      }).then(({ data: data2 }) => data2);
+      const user = yield this.getUser();
+      return { result: data, user };
+    });
+  }
+  /**
+   * Запрос кода на подтвеждение телефона
+   */
+  getConfirmationCode(phone) {
+    return __async(this, null, function* () {
+      const appOptions = yield this.appOptionsService.getCurrentAppOptions();
+      try {
+        const payload = {
+          phone,
+          type: appOptions.phoneConfirmationType
+        };
+        const confirm = yield this.api.post("/api/phone_confirmation_codes", payload);
+        return confirm;
+      } catch (error) {
+        throw new ConfirmationCodeRequestError("\u041E\u0448\u0438\u0431\u043A\u0430 \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u0438\u044F \u043A\u043E\u0434\u0430 \u043F\u043E\u0434\u0442\u0432\u0435\u0440\u0436\u0434\u0435\u043D\u0438\u044F", { cause: error });
+      }
+    });
+  }
+  /**
+   * Логин или регистрация юзера по телефону
+   * @param phone номер телефона
+   * @param params
+   * @returns {Promise<{ user: User; result: LoginOrRegistrationResponse }>}
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  loginByPhone(phone, params) {
+    return __async(this, null, function* () {
+      const appOptions = yield this.appOptionsService.getCurrentAppOptions();
+      const phoneCheck = yield this.api.post("/api/phone_check", { phone });
+      if (phoneCheck.data.state === "not_confirmed") {
+        if (phoneCheck.data.fakeEmail === false) {
+          let checkMethod = "email";
+          const email = yield params.onEmailRequest(phoneCheck.data);
+          try {
+            yield this.api.post("/api/phone_check/verification", {
+              check_method: checkMethod,
+              email,
+              phone,
+              type: appOptions.phoneConfirmationType
+            });
+          } catch (e) {
+            checkMethod = "name";
+          }
+          try {
+            if (checkMethod === "name") {
+              const { first_name, last_name } = yield params.onNameRequest();
+              yield this.api.post("/api/phone_check/verification", {
+                check_method: "name",
+                first_name,
+                last_name,
+                phone,
+                type: appOptions.phoneConfirmationType
+              });
+            }
+          } catch (error) {
+            throw new LogginError("\u041E\u0448\u0438\u0431\u043A\u0430 \u0430\u0432\u0442\u043E\u0440\u0438\u0437\u0430\u0446\u0438\u0438", { cause: error });
+          }
+        }
+      }
+      let confirm;
+      try {
+        confirm = yield this.getConfirmationCode(phone);
+        params.onConfirmationCodeResponse(confirm.data);
+      } catch (error) {
+        throw new LogginError("\u041E\u0448\u0438\u0431\u043A\u0430 \u0430\u0432\u0442\u043E\u0440\u0438\u0437\u0430\u0446\u0438\u0438", { cause: error });
+      }
+      if (!confirm) return void 0;
+      const code = yield params.onCodeRequest();
+      let token;
+      try {
+        const resultConfirmation = yield this.api.post("/api/phone_confirmations", {
+          code,
+          phone
+        });
+        token = resultConfirmation.data.verificationToken;
+      } catch (error) {
+        params.onConfirmationCodeError(error);
+      }
+      const data = yield this.api.post("/api/phone_registration", {
+        phone,
+        phone_verification_token: token
+      }).then(({ data: data2 }) => data2);
+      const user = yield this.getUser();
+      return { result: data, user };
+    });
+  }
+  /**
+   * Получение покупок текущего пользователя
+   * @param  {Number} params.resourceId     Resource ID
+   * @param  {String} params.resourceType   Resource type
+   * @return {Promise}                      Server response with user purchases
+   */
+  purchases(_0) {
+    return __async(this, arguments, function* ({ resourceId, resourceType }) {
+      if (resourceId && typeof resourceId !== "number") {
+        throw new Error("resourceId must be a number");
+      }
+      if (resourceType && typeof resourceType !== "string") {
+        throw new Error("resourceType must be a string");
+      }
+      const params = [];
+      if (resourceId) params.push(`resource_id=${encodeURIComponent(resourceId)}`);
+      if (resourceType) params.push(`resource_type=${encodeURIComponent(resourceType)}`);
+      const query = params.length ? `?${params.join("&")}` : "";
+      const { data } = yield this.api.get(`/api/user/purchases${query}`);
+      return data;
+    });
+  }
+  /**
+   * Навигация на страницу входа и перенаправление на указанный путь после успешного входа.
+   * @param  {String} options.redirectUrl URL для редиректа.
+   */
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
+  signIn({ redirectUrl = void 0 }) {
+    if (redirectUrl && typeof redirectUrl !== "string") {
+      throw new Error("redirectUrl must be a string");
+    }
+    let url = `${FOXFORD_HOST}/user/registration?redirect_url=`;
+    if (redirectUrl) url += encodeURIComponent(document.location.href);
+    document.location.href = url;
+  }
+  /**
+   * Выход из аккаунта с перезагрузкой страницы
+   */
+  signOut(reloadAfter = true) {
+    return __async(this, null, function* () {
+      const data = yield this.api.delete(`/user/log_out`);
+      if (reloadAfter) window.location.reload();
+      return data;
+    });
+  }
+  pushEvent(event) {
+    return __async(this, null, function* () {
+      yield this.api.post(`/api/user/event`, {
+        event
+      });
+    });
+  }
+  /**
+   * Установить подписку пользователю
+   * @param {CommunicationSubscriptions} subscriptions пользовательские подписки
+   */
+  setSubscriptions(subscriptions) {
+    return __async(this, null, function* () {
+      yield this.api.put(`/api/user/communication_subscriptions`, {
+        communication_subscriptions: subscriptions
+      });
+    });
+  }
+  /**
+   * Получение интересов пользователя
+   */
+  getUserInterests() {
+    return __async(this, null, function* () {
+      const { data } = yield this.api.get("/api/user/user_interest");
+      return data;
+    });
+  }
+  /**
+   * Обновление интересов пользователя
+   * @param {Partial<UserInterests>} data интересы пользователя
+   */
+  updateUserInterests(data) {
+    return __async(this, null, function* () {
+      yield this.api.put("/api/user/user_interest", { user_interest: decamelize(data) });
+    });
+  }
+  /**
+   * Обновления множества интересов пользователя
+   * @param {Partial<UserInterests>} data интересы пользователя
+   */
+  updateMultipleUserInterests(data) {
+    return __async(this, null, function* () {
+      yield this.api.put("/api/user/user_interest", { user_interests: data.map((i) => decamelize(i)) });
+    });
+  }
+};
+
+// src/utils/merge.ts
+function isObject(item) {
+  return Boolean(item) && typeof item === "object" && !Array.isArray(item);
+}
+function mergeDeep(target, ...sources) {
+  if (!sources.length) return target;
+  const output = Object.assign({}, target);
+  const source = sources.shift();
+  if (isObject(target) && isObject(source)) {
+    for (const key in source) {
+      if (isObject(source[key])) {
+        if (!(key in target)) {
+          Object.assign(output, { [key]: source[key] });
+        } else {
+          output[key] = mergeDeep(target[key], source[key]);
+        }
+      } else {
+        Object.assign(output, { [key]: source[key] });
+      }
+    }
+  }
+  return output;
+}
+
+// src/services/widgets.ts
+var _Widgets = class _Widgets {
+  constructor(config = _Widgets.DEFAULT_CONFIG, apiInstance) {
+    this.manifest = null;
+    this.config = mergeDeep(_Widgets.DEFAULT_CONFIG, config);
+    this.api = apiInstance;
+  }
+  create(config) {
+    return __async(this, null, function* () {
+      if (!config) throw new Error("You must specify config for creating widgets");
+      yield this.loadManifest();
+      yield this.loadAssets();
+      if (!window.Foxford || !window.Foxford.Widgets) throw new Error("FoxfordWidgets not found in global scope");
+      if (typeof window.Foxford.Widgets.create !== "function")
+        throw new Error("Not found function create in FoxfordWidgets library");
+      window.Foxford.Widgets.create(config);
+    });
+  }
+  // Публичный метод у инстанса
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
+  update(name, config) {
+    return __async(this, null, function* () {
+      if (window.Foxford && window.Foxford.Widgets) window.Foxford.Widgets.update(name, config);
+    });
+  }
+  loadManifest() {
+    return __async(this, null, function* () {
+      const url = `https://dist.ngcdn.ru/libs/foxford-widgets/${this.config.version}/manifest.json`;
+      const response = yield this.api.get(url);
+      this.manifest = response.data;
+    });
+  }
+  static appendScript(src) {
+    return __async(this, null, function* () {
+      return new Promise((resolve, reject) => {
+        const script = document.createElement("script");
+        script.type = "text/javascript";
+        script.defer = true;
+        script.onload = () => resolve(true);
+        script.onerror = (event) => reject(event);
+        script.src = src;
+        document.body.appendChild(script);
+      });
+    });
+  }
+  loadAssets() {
+    return __async(this, null, function* () {
+      if (!this.config.version) this.config.version = "latest";
+      yield Promise.all(
+        _Widgets.ENTRY.map((entry) => {
+          if (!this.manifest) return Promise.resolve;
+          const src = this.manifest[entry];
+          if (!src) return Promise.resolve;
+          return _Widgets.appendScript(`https://dist.ngcdn.ru/libs/foxford-widgets/${this.config.version}/${src}`).then(
+            (res) => res
+          );
+        })
+      );
+    });
+  }
+};
+_Widgets.ENTRY = ["vendors~react.js", "vendors~ui.js", "main.js"];
+_Widgets.DEFAULT_CONFIG = {
+  locale: "ru",
+  version: "latest"
+};
+var Widgets = _Widgets;
+
+// src/foxford.ts
+var _Foxford = class _Foxford {
+  constructor(config = _Foxford.DEFAULT_CONFIG) {
+    var _a, _b, _c, _d;
+    this.config = mergeDeep(_Foxford.DEFAULT_CONFIG, config);
+    this.foxApi = this.buildFoxApi();
+    this.api = import_services2.ApiService.createApiInstance({ config: apiBaseConfig });
+    this.staticApi = import_services2.ApiService.createStaticApiInstance();
+    this.appOptions = new AppOptionsService(this.foxApi, _Foxford.events.FETCH_APP_OPTIONS);
+    this.user = new UserService(this.foxApi, this.appOptions);
+    this.promo = new PromoService(this.foxApi);
+    this.tag = new TagService(this.foxApi);
+    this.cart = new CartService(this.foxApi);
+    this.course = new CourseService(this.foxApi);
+    this.widgets = new Widgets(
+      __spreadValues({
+        version: this.config.widgetsVersion
+      }, this.config.widgetsConfig),
+      this.api
+    );
+    this.productPack = new ProductPackService(this.foxApi);
+    this.leadrequest = new LeadRequestService(this.foxApi);
+    this.captcha = new import_services2.CaptchaService(
+      typeof ((_a = this.config) == null ? void 0 : _a.captchaConfig) === "function" ? (_b = this.config) == null ? void 0 : _b.captchaConfig() : (_d = (_c = this.config) == null ? void 0 : _c.captchaConfig) != null ? _d : {}
+    );
+    if (this.config.antibot === true) {
+      new FoxfordAntibot(this.config.antibotConfig);
+    }
+  }
+  buildFoxApi() {
+    var _a, _b, _c, _d;
+    const apiConfig2 = ((_a = this.config) == null ? void 0 : _a.api) || { config: {} };
+    const captchaConfig = (_b = this.config) == null ? void 0 : _b.captchaConfig;
+    const apiInstance = import_services2.ApiService.createFoxApiInstance({
+      config: apiConfig2.config,
+      plugins: getPlugins(apiConfig2, captchaConfig)
+    });
+    if (!((_d = (_c = this.config) == null ? void 0 : _c.api) == null ? void 0 : _d.config.baseURL) && this.config.host) apiInstance.defaults.baseURL = this.config.host;
+    return apiInstance;
+  }
+  /**
+   * Get short link
+   * @param {string} url link for shortening
+   */
+  shortURL(url) {
+    return this.foxApi.post(`/api/short_urls`, {
+      link: url
+    }).then((data) => data);
+  }
+  /**
+   * Applies and throwing itself into plugin for access to Api
+   * @param {SdkPlugin} plugin Plugin to apply
+   */
+  applyPlugin(plugin) {
+    plugin.apply(this);
+  }
+};
+_Foxford.events = {
+  FETCH_APP_OPTIONS: "Foxford.app_options.fetch",
+  LR_REGISTRATION_SET
+};
+_Foxford.DEFAULT_CONFIG = {
+  antibot: true,
+  api: {
+    config: apiConfig
+  },
+  host: FOXFORD_HOST,
+  widgetsConfig: {
+    locale: "ru",
+    version: "latest"
+  },
+  widgetsVersion: "latest"
+};
+var Foxford = _Foxford;
+
+// src/analytics/external/abstract.external.ts
+var ExternalScript = class _ExternalScript {
+  constructor(analytics) {
+    this.sendCallstack = [];
+    this.ready = false;
+    this.analytics = analytics;
+  }
+  static appendScript(src) {
+    return new Promise((resolve, reject) => {
+      const script = document.createElement("script");
+      script.type = "text/javascript";
+      script.defer = true;
+      script.onload = () => resolve(true);
+      script.onerror = (event) => reject(event);
+      script.src = src;
+      document.body.appendChild(script);
+    });
+  }
+  load() {
+    return __async(this, null, function* () {
+      if (!this.url) return;
+      try {
+        if (!this.ready) yield _ExternalScript.appendScript(this.url);
+        this.ready = true;
+      } catch (error) {
+        console.error(error);
+      }
+    });
+  }
+  send(payload, forced) {
+    return __async(this, null, function* () {
+      if (!this.analytics.__isInitialized__ && !forced) {
+        this.sendCallstack.push(payload);
+        return Promise.resolve();
+      }
+      return yield this.sendHandler(payload);
+    });
+  }
+  sendForce(_payload) {
+    return __async(this, null, function* () {
+      yield this.load();
+      return yield this.send(_payload, true);
+    });
+  }
+  runSendCallstack() {
+    this.sendCallstack.forEach((payload) => this.send(payload));
+    this.sendCallstack = [];
+  }
+};
+
+// src/analytics/index.ts
+var initObj = { __isInitialized__: false };
+var Analytics = {
+  initGlobal() {
+    return __async(this, null, function* () {
+      if (initObj.__isInitialized__) return;
+      initObj.__isInitialized__ = true;
+      Object.values(this).forEach((provider) => {
+        if (!(provider instanceof ExternalScript)) return;
+        provider.load();
+        provider.runSendCallstack();
+      });
+    });
+  }
+};
+
+// src/index.ts
+var import_services3 = require("@foxford/services");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Analytics,
+  ApiService,
+  AppOptionsService,
+  CaptchaError,
+  CaptchaService,
+  CartService,
+  CourseService,
+  Foxford,
+  FoxfordAntibot,
+  LeadRequestService,
+  LeadRequestType,
+  ProductPackService,
+  PromoService,
+  RequestPlugin,
+  ResponseFailPlugin,
+  ResponseSuccessPlugin,
+  TagService,
+  User,
+  UserService,
+  Widgets
+});