\r\n \r\n\r\n A weboldal akadálymentes nagy kontrasztú nézetét kiválaszthatja a fejléc vagy a lábléc akadálymentes ikonra kattintással.\r\n\r\n A menüpontok kiválasztását a 𝗧𝗔𝗕 billentyűvel, megnyitásukat az 𝗘𝗡𝗧𝗘𝗥 billentyű megnyomásával tudja elvégezni. Az 𝗘𝗦𝗖 gomb megnyomása esetén vissza tud lépni az előző menübe.\r\n\r\n A Friss híreink esetében ha zavarja a képek/szövegek mozgása, akkor nyomja meg a 𝗦𝗣𝗔𝗖𝗘 gombot a mozgás leállításához.\r\n Az akadálymentesítési nyilatkozatot a lábléc “Akadálymentesítési nyilatkozat” gombra kattintással érik el.\r\n
\r\n \r\n )}\r\n \r\n \r\n )\r\n}\r\n\r\nexport default MyApp\r\n","import {\r\n WebMenuTypeEnum,\r\n IWebMenu,\r\n HOME_PAGE_DATA,\r\n WebmenuPathEnum,\r\n isTypeWithSlug,\r\n} from '../interfaces/webMenu'\r\n\r\nexport const mapWebMenus = (arr: IWebMenu[]): { [key: string]: IWebMenu } => {\r\n let map = {} as { [key: string]: IWebMenu }\r\n\r\n arr.forEach((item: IWebMenu) => {\r\n const { id, childList = [], url_HU, url_EN } = item\r\n // TODO remove these to conditions after fixed on BE - GLHF :)\r\n if (url_HU.endsWith('/') && url_HU !== '/') {\r\n item.url_HU = url_HU.substring(0, url_HU.lastIndexOf('/'))\r\n }\r\n if (url_EN.endsWith('/') && url_EN !== '/') {\r\n item.url_EN = url_EN.substring(0, url_EN.lastIndexOf('/'))\r\n }\r\n map[id] = item\r\n let childMap = {}\r\n if (childList.length) {\r\n childMap = mapWebMenus(childList)\r\n }\r\n map = Object.assign(map, childMap)\r\n })\r\n return map\r\n}\r\n\r\nexport const isHomePage = (path: string): boolean => path === '/'\r\n\r\nexport const prepareMap = (webmenus: IWebMenu[]) => {\r\n const { id, childList } = HOME_PAGE_DATA\r\n return [\r\n {\r\n ...HOME_PAGE_DATA,\r\n childList: [\r\n ...childList,\r\n ...webmenus.map((webmenu) => {\r\n webmenu.parent = id\r\n return webmenu\r\n }),\r\n ],\r\n },\r\n ]\r\n}\r\n\r\nexport const getSlug = (path: string): string =>\r\n path.substring(path.lastIndexOf('/') + 1)\r\n\r\nexport const getUrlObjectForComponents = (\r\n type: WebMenuTypeEnum,\r\n id: string,\r\n path: string\r\n) => {\r\n switch (type) {\r\n case WebMenuTypeEnum.HOME:\r\n return { pathname: '/' }\r\n case WebMenuTypeEnum.ACTIVITY:\r\n return {\r\n pathname: `/activity`,\r\n query: { contentId: getSlug(path), webmenuId: id },\r\n }\r\n case WebMenuTypeEnum.ACTIVITY_LIST:\r\n return { pathname: `/activity-list`, query: { webmenuId: id } }\r\n case WebMenuTypeEnum.ARTICLE:\r\n return {\r\n pathname: `/article`,\r\n query: { contentId: getSlug(path), webmenuId: id },\r\n }\r\n case WebMenuTypeEnum.ARTICLELIST:\r\n return { pathname: `/article-list`, query: { webmenuId: id } }\r\n case WebMenuTypeEnum.PHOTOGALLERY:\r\n return {\r\n pathname: `/photo-gallery`,\r\n query: { contentId: getSlug(path), webmenuId: id },\r\n }\r\n case WebMenuTypeEnum.PHOTOGALLERYLIST:\r\n return { pathname: `/photo-gallery-list`, query: { webmenuId: id } }\r\n case WebMenuTypeEnum.VIDEOGALLERY:\r\n return {\r\n pathname: `/video-gallery`,\r\n query: { contentId: getSlug(path), webmenuId: id },\r\n }\r\n case WebMenuTypeEnum.VIDEOGALLERYLIST:\r\n return { pathname: `/video-gallery-list`, query: { webmenuId: id } }\r\n case WebMenuTypeEnum.GENERALLIST:\r\n return { pathname: `/general-list`, query: { webmenuId: id } }\r\n case WebMenuTypeEnum.FILELIST:\r\n return { pathname: `/file-list`, query: { webmenuId: id } }\r\n case WebMenuTypeEnum.MAP:\r\n return { pathname: `/terkep`, query: { webmenuId: id } }\r\n case WebMenuTypeEnum.CITYCARD:\r\n return { pathname: `/citycard`, query: { webmenuId: id } }\r\n case WebMenuTypeEnum.IMPRESSUM:\r\n return { pathname: `/imprint`, query: { webmenuId: id } }\r\n default:\r\n return { pathname: '/_error' }\r\n }\r\n}\r\n\r\nexport const getUrlObjectByParentList = (\r\n type: WebMenuTypeEnum,\r\n path: string,\r\n webmenuId: string,\r\n isPreview: boolean\r\n) => {\r\n return {\r\n pathname: getPathnameByListType(type),\r\n query: isPreview ? { contentId: getSlug(path), webmenuId: webmenuId, preview: 1 } : { contentId: getSlug(path), webmenuId: webmenuId},\r\n }\r\n}\r\n\r\nexport const getPathnameByListType = (type: string) => {\r\n switch (type) {\r\n case WebMenuTypeEnum.ACTIVITY_LIST:\r\n return `/activity`\r\n case WebMenuTypeEnum.ARTICLELIST:\r\n return `/article`\r\n case WebMenuTypeEnum.PHOTOGALLERYLIST:\r\n return `/photo-gallery`\r\n case WebMenuTypeEnum.VIDEOGALLERYLIST:\r\n return `/video-gallery`\r\n case WebMenuTypeEnum.MAP:\r\n return `/poi-article`\r\n case WebMenuTypeEnum.CITYCARD:\r\n return `/citycard-details`\r\n default:\r\n return '/_error'\r\n }\r\n}\r\n\r\nexport const equalToOneOfTheUrls = (url: string, webmenu: IWebMenu) => {\r\n const { url_HU, url_EN } = webmenu\r\n return url === url_HU || url === url_EN\r\n}\r\n\r\nexport const partOfOneOfTheUrls = (url: string, webmenu: IWebMenu) => {\r\n const urlWithoutSlug = url.substring(0, url.lastIndexOf('/'))\r\n return equalToOneOfTheUrls(urlWithoutSlug, webmenu)\r\n}\r\n\r\nexport const findMenuItem = (\r\n webMenus: { [key: string]: IWebMenu },\r\n path: string\r\n): IWebMenu => {\r\n const values = Object.values(webMenus)\r\n let item = values.find((webmenu) => {\r\n if (equalToOneOfTheUrls(path, webmenu)) {\r\n return webmenu\r\n }\r\n })\r\n if (!item) {\r\n const urlWithoutSlug = path.substring(0, path.lastIndexOf('/'))\r\n item =\r\n values.find((webmenu) => {\r\n if (equalToOneOfTheUrls(urlWithoutSlug, webmenu)) {\r\n return webmenu\r\n }\r\n }) || webMenus['HOME'] // TODO change this to dedicated 404\r\n }\r\n\r\n return item\r\n}\r\n\r\nexport const urlObjectFactoryForPagesWithSlug = (\r\n basepath: string,\r\n item: { heading: string; slug: string },\r\n webmenu: IWebMenu\r\n) => {\r\n const { heading, slug } = item\r\n return {\r\n urlObject: {\r\n pathname: basepath,\r\n query: {\r\n webmenuId: webmenu.id || heading,\r\n contentId: slug,\r\n },\r\n },\r\n asPath: webmenu.url_HU + '/' + slug,\r\n }\r\n}\r\n\r\nexport const urlObjectFactoryForPages = (\r\n basepath: string,\r\n item: { heading: string; slug: string },\r\n webmenu: IWebMenu,\r\n type: string\r\n) => {\r\n const { heading, slug } = item\r\n const isWithSlug = type === WebMenuTypeEnum.ARTICLELIST || type === WebMenuTypeEnum.ACTIVITY || type === 'ANNOUNCEMENT' || type === 'NEWS'\r\n return {\r\n urlObject: {\r\n pathname: basepath,\r\n query: {\r\n webmenuId: webmenu.id || heading,\r\n contentId: slug,\r\n },\r\n },\r\n asPath: isWithSlug ? webmenu.url_HU + '/' + slug : webmenu.url_HU,\r\n }\r\n}\r\n\r\n\r\n\r\nexport const urlObjectFactoryForWebmenus = (webmenu: IWebMenu) => {\r\n const { id, url_HU, url_EN, type } = webmenu\r\n const componentUrl = WebmenuPathEnum[type]\r\n return {\r\n urlObject: {\r\n pathname: componentUrl,\r\n query: {\r\n webmenuId: id,\r\n contentId: id,\r\n },\r\n },\r\n asPath: url_HU,\r\n }\r\n}\r\n","(function(){var e={162:function(e){var t=e.exports={};var r;var n;function defaultSetTimout(){throw new Error(\"setTimeout has not been defined\")}function defaultClearTimeout(){throw new Error(\"clearTimeout has not been defined\")}(function(){try{if(typeof setTimeout===\"function\"){r=setTimeout}else{r=defaultSetTimout}}catch(e){r=defaultSetTimout}try{if(typeof clearTimeout===\"function\"){n=clearTimeout}else{n=defaultClearTimeout}}catch(e){n=defaultClearTimeout}})();function runTimeout(e){if(r===setTimeout){return setTimeout(e,0)}if((r===defaultSetTimout||!r)&&setTimeout){r=setTimeout;return setTimeout(e,0)}try{return r(e,0)}catch(t){try{return r.call(null,e,0)}catch(t){return r.call(this,e,0)}}}function runClearTimeout(e){if(n===clearTimeout){return clearTimeout(e)}if((n===defaultClearTimeout||!n)&&clearTimeout){n=clearTimeout;return clearTimeout(e)}try{return n(e)}catch(t){try{return n.call(null,e)}catch(t){return n.call(this,e)}}}var i=[];var o=false;var u;var a=-1;function cleanUpNextTick(){if(!o||!u){return}o=false;if(u.length){i=u.concat(i)}else{a=-1}if(i.length){drainQueue()}}function drainQueue(){if(o){return}var e=runTimeout(cleanUpNextTick);o=true;var t=i.length;while(t){u=i;i=[];while(++a1){for(var r=1;r 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n if (t[2]) _.ops.pop();\r\n _.trys.pop(); continue;\r\n }\r\n op = body.call(thisArg, _);\r\n } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n }\r\n}\n\nvar noop = function () { };\n// Using noop() as the undefined value as undefined can possibly be replaced\n// by something else. Prettier ignore and extra parentheses are necessary here\n// to ensure that tsc doesn't remove the __NOINLINE__ comment.\n// prettier-ignore\nvar UNDEFINED = ( /*#__NOINLINE__*/noop());\nvar OBJECT = Object;\nvar isUndefined = function (v) { return v === UNDEFINED; };\nvar isFunction = function (v) { return typeof v == 'function'; };\nvar mergeObjects = function (a, b) { return OBJECT.assign({}, a, b); };\nvar STR_UNDEFINED = 'undefined';\n// NOTE: Use function to guarantee it's re-evaluated between jsdom and node runtime for tests.\nvar hasWindow = function () { return typeof window != STR_UNDEFINED; };\nvar hasDocument = function () { return typeof document != STR_UNDEFINED; };\nvar hasRequestAnimationFrame = function () {\n return hasWindow() && typeof window['requestAnimationFrame'] != STR_UNDEFINED;\n};\n\n// use WeakMap to store the object->key mapping\n// so the objects can be garbage collected.\n// WeakMap uses a hashtable under the hood, so the lookup\n// complexity is almost O(1).\nvar table = new WeakMap();\n// counter of the key\nvar counter = 0;\n// A stable hash implementation that supports:\n// - Fast and ensures unique hash properties\n// - Handles unserializable values\n// - Handles object key ordering\n// - Generates short results\n//\n// This is not a serialization function, and the result is not guaranteed to be\n// parsible.\nvar stableHash = function (arg) {\n var type = typeof arg;\n var constructor = arg && arg.constructor;\n var isDate = constructor == Date;\n var result;\n var index;\n if (OBJECT(arg) === arg && !isDate && constructor != RegExp) {\n // Object/function, not null/date/regexp. Use WeakMap to store the id first.\n // If it's already hashed, directly return the result.\n result = table.get(arg);\n if (result)\n return result;\n // Store the hash first for circular reference detection before entering the\n // recursive `stableHash` calls.\n // For other objects like set and map, we use this id directly as the hash.\n result = ++counter + '~';\n table.set(arg, result);\n if (constructor == Array) {\n // Array.\n result = '@';\n for (index = 0; index < arg.length; index++) {\n result += stableHash(arg[index]) + ',';\n }\n table.set(arg, result);\n }\n if (constructor == OBJECT) {\n // Object, sort keys.\n result = '#';\n var keys = OBJECT.keys(arg).sort();\n while (!isUndefined((index = keys.pop()))) {\n if (!isUndefined(arg[index])) {\n result += index + ':' + stableHash(arg[index]) + ',';\n }\n }\n table.set(arg, result);\n }\n }\n else {\n result = isDate\n ? arg.toJSON()\n : type == 'symbol'\n ? arg.toString()\n : type == 'string'\n ? JSON.stringify(arg)\n : '' + arg;\n }\n return result;\n};\n\n/**\n * Due to bug https://bugs.chromium.org/p/chromium/issues/detail?id=678075,\n * it's not reliable to detect if the browser is currently online or offline\n * based on `navigator.onLine`.\n * As a work around, we always assume it's online on first load, and change\n * the status upon `online` or `offline` events.\n */\nvar online = true;\nvar isOnline = function () { return online; };\nvar hasWin = hasWindow();\nvar hasDoc = hasDocument();\n// For node and React Native, `add/removeEventListener` doesn't exist on window.\nvar onWindowEvent = hasWin && window.addEventListener\n ? window.addEventListener.bind(window)\n : noop;\nvar onDocumentEvent = hasDoc ? document.addEventListener.bind(document) : noop;\nvar offWindowEvent = hasWin && window.removeEventListener\n ? window.removeEventListener.bind(window)\n : noop;\nvar offDocumentEvent = hasDoc\n ? document.removeEventListener.bind(document)\n : noop;\nvar isVisible = function () {\n var visibilityState = hasDoc && document.visibilityState;\n return isUndefined(visibilityState) || visibilityState !== 'hidden';\n};\nvar initFocus = function (callback) {\n // focus revalidate\n onDocumentEvent('visibilitychange', callback);\n onWindowEvent('focus', callback);\n return function () {\n offDocumentEvent('visibilitychange', callback);\n offWindowEvent('focus', callback);\n };\n};\nvar initReconnect = function (callback) {\n // revalidate on reconnected\n var onOnline = function () {\n online = true;\n callback();\n };\n // nothing to revalidate, just update the status\n var onOffline = function () {\n online = false;\n };\n onWindowEvent('online', onOnline);\n onWindowEvent('offline', onOffline);\n return function () {\n offWindowEvent('online', onOnline);\n offWindowEvent('offline', onOffline);\n };\n};\nvar preset = {\n isOnline: isOnline,\n isVisible: isVisible\n};\nvar defaultConfigOptions = {\n initFocus: initFocus,\n initReconnect: initReconnect\n};\n\nvar IS_SERVER = !hasWindow() || 'Deno' in window;\n// Polyfill requestAnimationFrame\nvar rAF = function (f) {\n return hasRequestAnimationFrame() ? window['requestAnimationFrame'](f) : setTimeout(f, 1);\n};\n// React currently throws a warning when using useLayoutEffect on the server.\n// To get around it, we can conditionally useEffect on the server (no-op) and\n// useLayoutEffect in the browser.\nvar useIsomorphicLayoutEffect = IS_SERVER ? useEffect : useLayoutEffect;\n// This assignment is to extend the Navigator type to use effectiveType.\nvar navigatorConnection = typeof navigator !== 'undefined' &&\n navigator.connection;\n// Adjust the config based on slow connection status (<= 70Kbps).\nvar slowConnection = !IS_SERVER &&\n navigatorConnection &&\n (['slow-2g', '2g'].includes(navigatorConnection.effectiveType) ||\n navigatorConnection.saveData);\n\nvar serialize = function (key) {\n if (isFunction(key)) {\n try {\n key = key();\n }\n catch (err) {\n // dependencies not ready\n key = '';\n }\n }\n var args = [].concat(key);\n // If key is not falsy, or not an empty array, hash it.\n key =\n typeof key == 'string'\n ? key\n : (Array.isArray(key) ? key.length : key)\n ? stableHash(key)\n : '';\n var infoKey = key ? '$swr$' + key : '';\n return [key, args, infoKey];\n};\n\n// Global state used to deduplicate requests and store listeners\nvar SWRGlobalState = new WeakMap();\n\nvar FOCUS_EVENT = 0;\nvar RECONNECT_EVENT = 1;\nvar MUTATE_EVENT = 2;\n\nvar broadcastState = function (cache, key, data, error, isValidating, revalidate, broadcast) {\n if (broadcast === void 0) { broadcast = true; }\n var _a = SWRGlobalState.get(cache), EVENT_REVALIDATORS = _a[0], STATE_UPDATERS = _a[1], FETCH = _a[3];\n var revalidators = EVENT_REVALIDATORS[key];\n var updaters = STATE_UPDATERS[key];\n // Cache was populated, update states of all hooks.\n if (broadcast && updaters) {\n for (var i = 0; i < updaters.length; ++i) {\n updaters[i](data, error, isValidating);\n }\n }\n // If we also need to revalidate, only do it for the first hook.\n if (revalidate) {\n // Invalidate the key by deleting the concurrent request markers so new\n // requests will not be deduped.\n delete FETCH[key];\n if (revalidators && revalidators[0]) {\n return revalidators[0](MUTATE_EVENT).then(function () {\n return cache.get(key);\n });\n }\n }\n return cache.get(key);\n};\n\n// Global timestamp.\nvar __timestamp = 0;\nvar getTimestamp = function () { return ++__timestamp; };\n\nvar internalMutate = function () {\n var args = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n args[_i] = arguments[_i];\n }\n return __awaiter(void 0, void 0, void 0, function () {\n var cache, _key, _data, _opts, options, populateCache, revalidate, rollbackOnError, customOptimisticData, _a, key, keyInfo, _b, MUTATION, data, error, beforeMutationTs, hasCustomOptimisticData, rollbackData, optimisticData, res;\n return __generator(this, function (_c) {\n switch (_c.label) {\n case 0:\n cache = args[0], _key = args[1], _data = args[2], _opts = args[3];\n options = typeof _opts === 'boolean' ? { revalidate: _opts } : _opts || {};\n populateCache = isUndefined(options.populateCache)\n ? true\n : options.populateCache;\n revalidate = options.revalidate !== false;\n rollbackOnError = options.rollbackOnError !== false;\n customOptimisticData = options.optimisticData;\n _a = serialize(_key), key = _a[0], keyInfo = _a[2];\n if (!key)\n return [2 /*return*/];\n _b = SWRGlobalState.get(cache), MUTATION = _b[2];\n // If there is no new data provided, revalidate the key with current state.\n if (args.length < 3) {\n // Revalidate and broadcast state.\n return [2 /*return*/, broadcastState(cache, key, cache.get(key), UNDEFINED, UNDEFINED, revalidate, true)];\n }\n data = _data;\n beforeMutationTs = getTimestamp();\n MUTATION[key] = [beforeMutationTs, 0];\n hasCustomOptimisticData = !isUndefined(customOptimisticData);\n rollbackData = cache.get(key);\n // Do optimistic data update.\n if (hasCustomOptimisticData) {\n optimisticData = isFunction(customOptimisticData)\n ? customOptimisticData(rollbackData)\n : customOptimisticData;\n cache.set(key, optimisticData);\n broadcastState(cache, key, optimisticData);\n }\n if (isFunction(data)) {\n // `data` is a function, call it passing current cache value.\n try {\n data = data(cache.get(key));\n }\n catch (err) {\n // If it throws an error synchronously, we shouldn't update the cache.\n error = err;\n }\n }\n if (!(data && isFunction(data.then))) return [3 /*break*/, 2];\n return [4 /*yield*/, data.catch(function (err) {\n error = err;\n })\n // Check if other mutations have occurred since we've started this mutation.\n // If there's a race we don't update cache or broadcast the change,\n // just return the data.\n ];\n case 1:\n // This means that the mutation is async, we need to check timestamps to\n // avoid race conditions.\n data = _c.sent();\n // Check if other mutations have occurred since we've started this mutation.\n // If there's a race we don't update cache or broadcast the change,\n // just return the data.\n if (beforeMutationTs !== MUTATION[key][0]) {\n if (error)\n throw error;\n return [2 /*return*/, data];\n }\n else if (error && hasCustomOptimisticData && rollbackOnError) {\n // Rollback. Always populate the cache in this case but without\n // transforming the data.\n populateCache = true;\n data = rollbackData;\n cache.set(key, rollbackData);\n }\n _c.label = 2;\n case 2:\n // If we should write back the cache after request.\n if (populateCache) {\n if (!error) {\n // Transform the result into data.\n if (isFunction(populateCache)) {\n data = populateCache(data, rollbackData);\n }\n // Only update cached data if there's no error. Data can be `undefined` here.\n cache.set(key, data);\n }\n // Always update or reset the error.\n cache.set(keyInfo, mergeObjects(cache.get(keyInfo), { error: error }));\n }\n // Reset the timestamp to mark the mutation has ended.\n MUTATION[key][1] = getTimestamp();\n return [4 /*yield*/, broadcastState(cache, key, data, error, UNDEFINED, revalidate, !!populateCache)\n // Throw error or return data\n ];\n case 3:\n res = _c.sent();\n // Throw error or return data\n if (error)\n throw error;\n return [2 /*return*/, populateCache ? res : data];\n }\n });\n });\n};\n\nvar revalidateAllKeys = function (revalidators, type) {\n for (var key in revalidators) {\n if (revalidators[key][0])\n revalidators[key][0](type);\n }\n};\nvar initCache = function (provider, options) {\n // The global state for a specific provider will be used to deduplicate\n // requests and store listeners. As well as a mutate function that bound to\n // the cache.\n // Provider's global state might be already initialized. Let's try to get the\n // global state associated with the provider first.\n if (!SWRGlobalState.has(provider)) {\n var opts = mergeObjects(defaultConfigOptions, options);\n // If there's no global state bound to the provider, create a new one with the\n // new mutate function.\n var EVENT_REVALIDATORS = {};\n var mutate = internalMutate.bind(UNDEFINED, provider);\n var unmount = noop;\n // Update the state if it's new, or the provider has been extended.\n SWRGlobalState.set(provider, [EVENT_REVALIDATORS, {}, {}, {}, mutate]);\n // This is a new provider, we need to initialize it and setup DOM events\n // listeners for `focus` and `reconnect` actions.\n if (!IS_SERVER) {\n // When listening to the native events for auto revalidations,\n // we intentionally put a delay (setTimeout) here to make sure they are\n // fired after immediate JavaScript executions, which can possibly be\n // React's state updates.\n // This avoids some unnecessary revalidations such as\n // https://github.com/vercel/swr/issues/1680.\n var releaseFocus_1 = opts.initFocus(setTimeout.bind(UNDEFINED, revalidateAllKeys.bind(UNDEFINED, EVENT_REVALIDATORS, FOCUS_EVENT)));\n var releaseReconnect_1 = opts.initReconnect(setTimeout.bind(UNDEFINED, revalidateAllKeys.bind(UNDEFINED, EVENT_REVALIDATORS, RECONNECT_EVENT)));\n unmount = function () {\n releaseFocus_1 && releaseFocus_1();\n releaseReconnect_1 && releaseReconnect_1();\n // When un-mounting, we need to remove the cache provider from the state\n // storage too because it's a side-effect. Otherwise when re-mounting we\n // will not re-register those event listeners.\n SWRGlobalState.delete(provider);\n };\n }\n // We might want to inject an extra layer on top of `provider` in the future,\n // such as key serialization, auto GC, etc.\n // For now, it's just a `Map` interface without any modifications.\n return [provider, mutate, unmount];\n }\n return [provider, SWRGlobalState.get(provider)[4]];\n};\n\n// error retry\nvar onErrorRetry = function (_, __, config, revalidate, opts) {\n var maxRetryCount = config.errorRetryCount;\n var currentRetryCount = opts.retryCount;\n // Exponential backoff\n var timeout = ~~((Math.random() + 0.5) *\n (1 << (currentRetryCount < 8 ? currentRetryCount : 8))) * config.errorRetryInterval;\n if (!isUndefined(maxRetryCount) && currentRetryCount > maxRetryCount) {\n return;\n }\n setTimeout(revalidate, timeout, opts);\n};\n// Default cache provider\nvar _a = initCache(new Map()), cache = _a[0], mutate = _a[1];\n// Default config\nvar defaultConfig = mergeObjects({\n // events\n onLoadingSlow: noop,\n onSuccess: noop,\n onError: noop,\n onErrorRetry: onErrorRetry,\n onDiscarded: noop,\n // switches\n revalidateOnFocus: true,\n revalidateOnReconnect: true,\n revalidateIfStale: true,\n shouldRetryOnError: true,\n // timeouts\n errorRetryInterval: slowConnection ? 10000 : 5000,\n focusThrottleInterval: 5 * 1000,\n dedupingInterval: 2 * 1000,\n loadingTimeout: slowConnection ? 5000 : 3000,\n // providers\n compare: function (currentData, newData) {\n return stableHash(currentData) == stableHash(newData);\n },\n isPaused: function () { return false; },\n cache: cache,\n mutate: mutate,\n fallback: {}\n}, \n// use web preset by default\npreset);\n\nvar mergeConfigs = function (a, b) {\n // Need to create a new object to avoid mutating the original here.\n var v = mergeObjects(a, b);\n // If two configs are provided, merge their `use` and `fallback` options.\n if (b) {\n var u1 = a.use, f1 = a.fallback;\n var u2 = b.use, f2 = b.fallback;\n if (u1 && u2) {\n v.use = u1.concat(u2);\n }\n if (f1 && f2) {\n v.fallback = mergeObjects(f1, f2);\n }\n }\n return v;\n};\n\nvar SWRConfigContext = createContext({});\nvar SWRConfig$1 = function (props) {\n var value = props.value;\n // Extend parent context values and middleware.\n var extendedConfig = mergeConfigs(useContext(SWRConfigContext), value);\n // Should not use the inherited provider.\n var provider = value && value.provider;\n // Use a lazy initialized state to create the cache on first access.\n var cacheContext = useState(function () {\n return provider\n ? initCache(provider(extendedConfig.cache || cache), value)\n : UNDEFINED;\n })[0];\n // Override the cache if a new provider is given.\n if (cacheContext) {\n extendedConfig.cache = cacheContext[0];\n extendedConfig.mutate = cacheContext[1];\n }\n // Unsubscribe events.\n useIsomorphicLayoutEffect(function () { return (cacheContext ? cacheContext[2] : UNDEFINED); }, []);\n return createElement(SWRConfigContext.Provider, mergeObjects(props, {\n value: extendedConfig\n }));\n};\n\n/**\n * An implementation of state with dependency-tracking.\n */\nvar useStateWithDeps = function (state, unmountedRef) {\n var rerender = useState({})[1];\n var stateRef = useRef(state);\n // If a state property (data, error or isValidating) is accessed by the render\n // function, we mark the property as a dependency so if it is updated again\n // in the future, we trigger a rerender.\n // This is also known as dependency-tracking.\n var stateDependenciesRef = useRef({\n data: false,\n error: false,\n isValidating: false\n });\n /**\n * @param payload To change stateRef, pass the values explicitly to setState:\n * @example\n * ```js\n * setState({\n * isValidating: false\n * data: newData // set data to newData\n * error: undefined // set error to undefined\n * })\n *\n * setState({\n * isValidating: false\n * data: undefined // set data to undefined\n * error: err // set error to err\n * })\n * ```\n */\n var setState = useCallback(function (payload) {\n var shouldRerender = false;\n var currentState = stateRef.current;\n for (var _ in payload) {\n var k = _;\n // If the property has changed, update the state and mark rerender as\n // needed.\n if (currentState[k] !== payload[k]) {\n currentState[k] = payload[k];\n // If the property is accessed by the component, a rerender should be\n // triggered.\n if (stateDependenciesRef.current[k]) {\n shouldRerender = true;\n }\n }\n }\n if (shouldRerender && !unmountedRef.current) {\n rerender({});\n }\n }, \n // config.suspense isn't allowed to change during the lifecycle\n // eslint-disable-next-line react-hooks/exhaustive-deps\n []);\n // Always update the state reference.\n useIsomorphicLayoutEffect(function () {\n stateRef.current = state;\n });\n return [stateRef, stateDependenciesRef.current, setState];\n};\n\nvar normalize = function (args) {\n return isFunction(args[1])\n ? [args[0], args[1], args[2] || {}]\n : [args[0], null, (args[1] === null ? args[2] : args[1]) || {}];\n};\n\nvar useSWRConfig = function () {\n return mergeObjects(defaultConfig, useContext(SWRConfigContext));\n};\n\n// It's tricky to pass generic types as parameters, so we just directly override\n// the types here.\nvar withArgs = function (hook) {\n return function useSWRArgs() {\n var args = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n args[_i] = arguments[_i];\n }\n // Get the default and inherited configuration.\n var fallbackConfig = useSWRConfig();\n // Normalize arguments.\n var _a = normalize(args), key = _a[0], fn = _a[1], _config = _a[2];\n // Merge configurations.\n var config = mergeConfigs(fallbackConfig, _config);\n // Apply middleware\n var next = hook;\n var use = config.use;\n if (use) {\n for (var i = use.length; i-- > 0;) {\n next = use[i](next);\n }\n }\n return next(key, fn || config.fetcher, config);\n };\n};\n\n// Add a callback function to a list of keyed callback functions and return\n// the unsubscribe function.\nvar subscribeCallback = function (key, callbacks, callback) {\n var keyedRevalidators = callbacks[key] || (callbacks[key] = []);\n keyedRevalidators.push(callback);\n return function () {\n var index = keyedRevalidators.indexOf(callback);\n if (index >= 0) {\n // O(1): faster than splice\n keyedRevalidators[index] = keyedRevalidators[keyedRevalidators.length - 1];\n keyedRevalidators.pop();\n }\n };\n};\n\nvar WITH_DEDUPE = { dedupe: true };\nvar useSWRHandler = function (_key, fetcher, config) {\n var cache = config.cache, compare = config.compare, fallbackData = config.fallbackData, suspense = config.suspense, revalidateOnMount = config.revalidateOnMount, refreshInterval = config.refreshInterval, refreshWhenHidden = config.refreshWhenHidden, refreshWhenOffline = config.refreshWhenOffline;\n var _a = SWRGlobalState.get(cache), EVENT_REVALIDATORS = _a[0], STATE_UPDATERS = _a[1], MUTATION = _a[2], FETCH = _a[3];\n // `key` is the identifier of the SWR `data` state, `keyInfo` holds extra\n // states such as `error` and `isValidating` inside,\n // all of them are derived from `_key`.\n // `fnArgs` is an array of arguments parsed from the key, which will be passed\n // to the fetcher.\n var _b = serialize(_key), key = _b[0], fnArgs = _b[1], keyInfo = _b[2];\n // If it's the initial render of this hook.\n var initialMountedRef = useRef(false);\n // If the hook is unmounted already. This will be used to prevent some effects\n // to be called after unmounting.\n var unmountedRef = useRef(false);\n // Refs to keep the key and config.\n var keyRef = useRef(key);\n var fetcherRef = useRef(fetcher);\n var configRef = useRef(config);\n var getConfig = function () { return configRef.current; };\n var isActive = function () { return getConfig().isVisible() && getConfig().isOnline(); };\n var patchFetchInfo = function (info) {\n return cache.set(keyInfo, mergeObjects(cache.get(keyInfo), info));\n };\n // Get the current state that SWR should return.\n var cached = cache.get(key);\n var fallback = isUndefined(fallbackData)\n ? config.fallback[key]\n : fallbackData;\n var data = isUndefined(cached) ? fallback : cached;\n var info = cache.get(keyInfo) || {};\n var error = info.error;\n var isInitialMount = !initialMountedRef.current;\n // - Suspense mode and there's stale data for the initial render.\n // - Not suspense mode and there is no fallback data and `revalidateIfStale` is enabled.\n // - `revalidateIfStale` is enabled but `data` is not defined.\n var shouldRevalidate = function () {\n // If `revalidateOnMount` is set, we take the value directly.\n if (isInitialMount && !isUndefined(revalidateOnMount))\n return revalidateOnMount;\n // If it's paused, we skip revalidation.\n if (getConfig().isPaused())\n return false;\n // Under suspense mode, it will always fetch on render if there is no\n // stale data so no need to revalidate immediately on mount again.\n // If data exists, only revalidate if `revalidateIfStale` is true.\n if (suspense)\n return isUndefined(data) ? false : config.revalidateIfStale;\n // If there is no stale data, we need to revalidate on mount;\n // If `revalidateIfStale` is set to true, we will always revalidate.\n return isUndefined(data) || config.revalidateIfStale;\n };\n // Resolve the current validating state.\n var resolveValidating = function () {\n if (!key || !fetcher)\n return false;\n if (info.isValidating)\n return true;\n // If it's not mounted yet and it should revalidate on mount, revalidate.\n return isInitialMount && shouldRevalidate();\n };\n var isValidating = resolveValidating();\n var _c = useStateWithDeps({\n data: data,\n error: error,\n isValidating: isValidating\n }, unmountedRef), stateRef = _c[0], stateDependencies = _c[1], setState = _c[2];\n // The revalidation function is a carefully crafted wrapper of the original\n // `fetcher`, to correctly handle the many edge cases.\n var revalidate = useCallback(function (revalidateOpts) { return __awaiter(void 0, void 0, void 0, function () {\n var currentFetcher, newData, startAt, loading, opts, shouldStartNewRequest, isCurrentKeyMounted, cleanupState, newState, finishRequestAndUpdateState, mutationInfo, err_1;\n var _a;\n return __generator(this, function (_b) {\n switch (_b.label) {\n case 0:\n currentFetcher = fetcherRef.current;\n if (!key ||\n !currentFetcher ||\n unmountedRef.current ||\n getConfig().isPaused()) {\n return [2 /*return*/, false];\n }\n loading = true;\n opts = revalidateOpts || {};\n shouldStartNewRequest = !FETCH[key] || !opts.dedupe;\n isCurrentKeyMounted = function () {\n return !unmountedRef.current &&\n key === keyRef.current &&\n initialMountedRef.current;\n };\n cleanupState = function () {\n // Check if it's still the same request before deleting.\n var requestInfo = FETCH[key];\n if (requestInfo && requestInfo[1] === startAt) {\n delete FETCH[key];\n }\n };\n newState = { isValidating: false };\n finishRequestAndUpdateState = function () {\n patchFetchInfo({ isValidating: false });\n // We can only set state if it's safe (still mounted with the same key).\n if (isCurrentKeyMounted()) {\n setState(newState);\n }\n };\n // Start fetching. Change the `isValidating` state, update the cache.\n patchFetchInfo({\n isValidating: true\n });\n setState({ isValidating: true });\n _b.label = 1;\n case 1:\n _b.trys.push([1, 3, , 4]);\n if (shouldStartNewRequest) {\n // Tell all other hooks to change the `isValidating` state.\n broadcastState(cache, key, stateRef.current.data, stateRef.current.error, true);\n // If no cache being rendered currently (it shows a blank page),\n // we trigger the loading slow event.\n if (config.loadingTimeout && !cache.get(key)) {\n setTimeout(function () {\n if (loading && isCurrentKeyMounted()) {\n getConfig().onLoadingSlow(key, config);\n }\n }, config.loadingTimeout);\n }\n // Start the request and save the timestamp.\n FETCH[key] = [currentFetcher.apply(void 0, fnArgs), getTimestamp()];\n }\n _a = FETCH[key], newData = _a[0], startAt = _a[1];\n return [4 /*yield*/, newData];\n case 2:\n newData = _b.sent();\n if (shouldStartNewRequest) {\n // If the request isn't interrupted, clean it up after the\n // deduplication interval.\n setTimeout(cleanupState, config.dedupingInterval);\n }\n // If there're other ongoing request(s), started after the current one,\n // we need to ignore the current one to avoid possible race conditions:\n // req1------------------>res1 (current one)\n // req2---------------->res2\n // the request that fired later will always be kept.\n // The timestamp maybe be `undefined` or a number\n if (!FETCH[key] || FETCH[key][1] !== startAt) {\n if (shouldStartNewRequest) {\n if (isCurrentKeyMounted()) {\n getConfig().onDiscarded(key);\n }\n }\n return [2 /*return*/, false];\n }\n // Clear error.\n patchFetchInfo({\n error: UNDEFINED\n });\n newState.error = UNDEFINED;\n mutationInfo = MUTATION[key];\n if (!isUndefined(mutationInfo) &&\n // case 1\n (startAt <= mutationInfo[0] ||\n // case 2\n startAt <= mutationInfo[1] ||\n // case 3\n mutationInfo[1] === 0)) {\n finishRequestAndUpdateState();\n if (shouldStartNewRequest) {\n if (isCurrentKeyMounted()) {\n getConfig().onDiscarded(key);\n }\n }\n return [2 /*return*/, false];\n }\n // Deep compare with latest state to avoid extra re-renders.\n // For local state, compare and assign.\n if (!compare(stateRef.current.data, newData)) {\n newState.data = newData;\n }\n else {\n // data and newData are deeply equal\n // it should be safe to broadcast the stale data\n newState.data = stateRef.current.data;\n // At the end of this function, `brocastState` invokes the `onStateUpdate` function,\n // which takes care of avoiding the re-render\n }\n // For global state, it's possible that the key has changed.\n // https://github.com/vercel/swr/pull/1058\n if (!compare(cache.get(key), newData)) {\n cache.set(key, newData);\n }\n // Trigger the successful callback if it's the original request.\n if (shouldStartNewRequest) {\n if (isCurrentKeyMounted()) {\n getConfig().onSuccess(newData, key, config);\n }\n }\n return [3 /*break*/, 4];\n case 3:\n err_1 = _b.sent();\n cleanupState();\n // Not paused, we continue handling the error. Otherwise discard it.\n if (!getConfig().isPaused()) {\n // Get a new error, don't use deep comparison for errors.\n patchFetchInfo({ error: err_1 });\n newState.error = err_1;\n // Error event and retry logic. Only for the actual request, not\n // deduped ones.\n if (shouldStartNewRequest && isCurrentKeyMounted()) {\n getConfig().onError(err_1, key, config);\n if ((typeof config.shouldRetryOnError === 'boolean' &&\n config.shouldRetryOnError) ||\n (isFunction(config.shouldRetryOnError) &&\n config.shouldRetryOnError(err_1))) {\n // When retrying, dedupe is always enabled\n if (isActive()) {\n // If it's active, stop. It will auto revalidate when refocusing\n // or reconnecting.\n getConfig().onErrorRetry(err_1, key, config, revalidate, {\n retryCount: (opts.retryCount || 0) + 1,\n dedupe: true\n });\n }\n }\n }\n }\n return [3 /*break*/, 4];\n case 4:\n // Mark loading as stopped.\n loading = false;\n // Update the current hook's state.\n finishRequestAndUpdateState();\n // Here is the source of the request, need to tell all other hooks to\n // update their states.\n if (isCurrentKeyMounted() && shouldStartNewRequest) {\n broadcastState(cache, key, newState.data, newState.error, false);\n }\n return [2 /*return*/, true];\n }\n });\n }); }, \n // `setState` is immutable, and `eventsCallback`, `fnArgs`, `keyInfo`,\n // and `keyValidating` are depending on `key`, so we can exclude them from\n // the deps array.\n //\n // FIXME:\n // `fn` and `config` might be changed during the lifecycle,\n // but they might be changed every render like this.\n // `useSWR('key', () => fetch('/api/'), { suspense: true })`\n // So we omit the values from the deps array\n // even though it might cause unexpected behaviors.\n // eslint-disable-next-line react-hooks/exhaustive-deps\n [key]);\n // Similar to the global mutate, but bound to the current cache and key.\n // `cache` isn't allowed to change during the lifecycle.\n // eslint-disable-next-line react-hooks/exhaustive-deps\n var boundMutate = useCallback(\n // By using `bind` we don't need to modify the size of the rest arguments.\n // Due to https://github.com/microsoft/TypeScript/issues/37181, we have to\n // cast it to any for now.\n internalMutate.bind(UNDEFINED, cache, function () { return keyRef.current; }), \n // eslint-disable-next-line react-hooks/exhaustive-deps\n []);\n // Always update fetcher and config refs.\n useIsomorphicLayoutEffect(function () {\n fetcherRef.current = fetcher;\n configRef.current = config;\n });\n // After mounted or key changed.\n useIsomorphicLayoutEffect(function () {\n if (!key)\n return;\n var keyChanged = key !== keyRef.current;\n var softRevalidate = revalidate.bind(UNDEFINED, WITH_DEDUPE);\n // Expose state updater to global event listeners. So we can update hook's\n // internal state from the outside.\n var onStateUpdate = function (updatedData, updatedError, updatedIsValidating) {\n setState(mergeObjects({\n error: updatedError,\n isValidating: updatedIsValidating\n }, \n // Since `setState` only shallowly compares states, we do a deep\n // comparison here.\n compare(stateRef.current.data, updatedData)\n ? UNDEFINED\n : {\n data: updatedData\n }));\n };\n // Expose revalidators to global event listeners. So we can trigger\n // revalidation from the outside.\n var nextFocusRevalidatedAt = 0;\n var onRevalidate = function (type) {\n if (type == FOCUS_EVENT) {\n var now = Date.now();\n if (getConfig().revalidateOnFocus &&\n now > nextFocusRevalidatedAt &&\n isActive()) {\n nextFocusRevalidatedAt = now + getConfig().focusThrottleInterval;\n softRevalidate();\n }\n }\n else if (type == RECONNECT_EVENT) {\n if (getConfig().revalidateOnReconnect && isActive()) {\n softRevalidate();\n }\n }\n else if (type == MUTATE_EVENT) {\n return revalidate();\n }\n return;\n };\n var unsubUpdate = subscribeCallback(key, STATE_UPDATERS, onStateUpdate);\n var unsubEvents = subscribeCallback(key, EVENT_REVALIDATORS, onRevalidate);\n // Mark the component as mounted and update corresponding refs.\n unmountedRef.current = false;\n keyRef.current = key;\n initialMountedRef.current = true;\n // When `key` updates, reset the state to the initial value\n // and trigger a rerender if necessary.\n if (keyChanged) {\n setState({\n data: data,\n error: error,\n isValidating: isValidating\n });\n }\n // Trigger a revalidation.\n if (shouldRevalidate()) {\n if (isUndefined(data) || IS_SERVER) {\n // Revalidate immediately.\n softRevalidate();\n }\n else {\n // Delay the revalidate if we have data to return so we won't block\n // rendering.\n rAF(softRevalidate);\n }\n }\n return function () {\n // Mark it as unmounted.\n unmountedRef.current = true;\n unsubUpdate();\n unsubEvents();\n };\n }, [key, revalidate]);\n // Polling\n useIsomorphicLayoutEffect(function () {\n var timer;\n function next() {\n // Use the passed interval\n // ...or invoke the function with the updated data to get the interval\n var interval = isFunction(refreshInterval)\n ? refreshInterval(data)\n : refreshInterval;\n // We only start next interval if `refreshInterval` is not 0, and:\n // - `force` is true, which is the start of polling\n // - or `timer` is not 0, which means the effect wasn't canceled\n if (interval && timer !== -1) {\n timer = setTimeout(execute, interval);\n }\n }\n function execute() {\n // Check if it's OK to execute:\n // Only revalidate when the page is visible, online and not errored.\n if (!stateRef.current.error &&\n (refreshWhenHidden || getConfig().isVisible()) &&\n (refreshWhenOffline || getConfig().isOnline())) {\n revalidate(WITH_DEDUPE).then(next);\n }\n else {\n // Schedule next interval to check again.\n next();\n }\n }\n next();\n return function () {\n if (timer) {\n clearTimeout(timer);\n timer = -1;\n }\n };\n }, [refreshInterval, refreshWhenHidden, refreshWhenOffline, revalidate]);\n // Display debug info in React DevTools.\n useDebugValue(data);\n // In Suspense mode, we can't return the empty `data` state.\n // If there is `error`, the `error` needs to be thrown to the error boundary.\n // If there is no `error`, the `revalidation` promise needs to be thrown to\n // the suspense boundary.\n if (suspense && isUndefined(data) && key) {\n // Always update fetcher and config refs even with the Suspense mode.\n fetcherRef.current = fetcher;\n configRef.current = config;\n unmountedRef.current = false;\n throw isUndefined(error) ? revalidate(WITH_DEDUPE) : error;\n }\n return {\n mutate: boundMutate,\n get data() {\n stateDependencies.data = true;\n return data;\n },\n get error() {\n stateDependencies.error = true;\n return error;\n },\n get isValidating() {\n stateDependencies.isValidating = true;\n return isValidating;\n }\n };\n};\nvar SWRConfig = OBJECT.defineProperty(SWRConfig$1, 'default', {\n value: defaultConfig\n});\nvar unstable_serialize = function (key) { return serialize(key)[0]; };\nvar useSWR = withArgs(useSWRHandler);\n\n// useSWR\n\nexport { SWRConfig, useSWR as default, mutate, unstable_serialize, useSWRConfig };\n"],"names":["ref","ref1","module","exports","g","process","env","window","__NEXT_P","push","title","h1","className","url","useRouter","pathname","figure","picture","source","srcSet","serverForImages","type","img","src","alt","Image","loader","imageLoaderForStaticImages","layout","objectFit","div","style","zIndex","setBodyOverflow","value","document","body","overflow","children","isOpen","handleClose","useAppContext","highContrastOn","useEffect","onClick","width","height","name","iconColor","fontColor","iconUrl","large","tabIndex","inHeader","svg","useRef","isDevServer","slice","fetch","method","then","content","text","element","current","innerHTML","getElementsByTagName","remove","margin","Array","from","forEach","p","fill","undefined","imageLoader","color","webmenu","name_HU","backgroundColor","urlObjectFactoryForWebmenus","urlObject","asPath","Link","href","link","as","scroll","shallow","a","target","openNewTab","IconWrapper","span","searchPlaceholder","search","activePage","router","useState","navigateToSearchPage","WebMenuTypeEnum","replace","input","placeholder","id","onChange","event","setInput","onKeyDown","key","transparent","isLarge","opacity","role","apiBaseAddress","apiAddress","devApiAddress","selfAddress","SELF_ADDRESS","partnerApiAddress","server","partnerServer","serverForCityCardArticleImages","NotFoundPage404","version","AppContext","createContext","AppWrapper","webmenus","mainData","setHighContrastOn","accessibilityShown","setAccessibilityShown","Provider","useContext","fetcher","r","json","parseYoutubeEmbeddedId","fileUrl","match","length","toString","HOME","ACCESSIBILITYSTATEMENT","ARTICLELIST","ARTICLE","ACTIVITY_LIST","ACTIVITY","PHOTOGALLERY","PHOTOGALLERYLIST","VIDEOGALLERYLIST","VIDEOGALLERY","GENERALLIST","FILELIST","MAP","CITYCARD","IMPRESSUM","PRIVACYPOLICY","SEARCH","PAGEMAP","WebmenuPathEnum","HOME_PAGE_DATA","name_EN","url_HU","url_EN","parent","breadcrumbs_HU","breadcrumbs_EN","childList","visible","isRelatedArticleWithoutSlug","Object","defineProperty","_param","sizes","unoptimized","priority","loading","lazyRoot","lazyBoundary","quality","objectPosition","onLoadingComplete","blurDataURL","all","_objectWithoutProperties","configContext","_react","_imageConfigContext","ImageConfigContext","config","useMemo","c","configEnv","_imageConfig","imageConfigDefault","allSizes","deviceSizes","imageSizes","sort","b","_objectSpread","rest","defaultImageLoader","customImageLoader","obj","opts","staticSrc","isStaticRequire","isStaticImageData","isStaticImport","staticImageData","default","Error","JSON","stringify","widthInt","getInt","heightInt","qualityInt","isLazy","startsWith","loadedImageURLs","has","sizerSvgUrl","blurComplete","setBlurComplete","_useIntersection","useIntersection","rootRef","rootMargin","disabled","setIntersection","isIntersected","resetIntersected","isVisible","wrapperStyle","boxSizing","display","background","border","padding","sizerStyle","hasSizer","layoutStyle","position","top","left","bottom","right","minWidth","maxWidth","minHeight","maxHeight","imgStyle","assign","blurStyle","filter","backgroundSize","backgroundImage","backgroundPosition","quotient","paddingTop","isNaN","imgAttributes","emptyDataURL","generateImgAttrs","srcString","imageSrcSetPropName","imageSizesPropName","linkProps","useLayoutEffect","onLoadingCompleteRef","previousImageSrc","imgElementArgs","createElement","Fragment","ImageElement","_head","rel","__esModule","newObj","prototype","hasOwnProperty","call","desc","getOwnPropertyDescriptor","get","set","_interopRequireWildcard","require","_normalizeTrailingSlash","_defineProperty","enumerable","configurable","writable","arguments","i","ownKeys","keys","getOwnPropertySymbols","concat","sym","excluded","sourceKeys","indexOf","_objectWithoutPropertiesLoose","sourceSymbolKeys","propertyIsEnumerable","Set","Map","loaders","endsWith","dangerouslyAllowSVG","encodeURIComponent","normalizePathTrailingSlash","path","URL","normalizeSrc","params","searchParams","paramsString","join","getWidths","viewportWidthRe","percentSizes","exec","parseInt","Math","smallestRatio","min","widths","s","kind","map","w","find","last","x","loaderProps","ref2","loaderKey","load","VALID_LOADERS","handleLoading","decode","Promise","resolve","catch","parentNode","add","naturalWidth","naturalHeight","onLoad","onError","decoding","useCallback","complete","currentTarget","_router","_router1","prefetched","prefetch","options","isLocalURL","err","curLocale","locale","_default","forwardRef","props","forwardedRef","legacyBehavior","Boolean","passHref","onMouseEnter","restProps","childrenProp","child","prefetchProp","resolveHref","hrefProp","resolvedHref","resolvedAs","asProp","previousHref","previousAs","Children","only","childRef","setIntersectionRef","resetVisible","setRef","el","shouldPrefetch","isPrefetched","childProps","e","defaultPrevented","nodeName","toUpperCase","metaKey","ctrlKey","shiftKey","altKey","nativeEvent","which","isModifiedEvent","preventDefault","linkClicked","localeDomain","isLocaleDomain","getDomainLocale","locales","domainLocales","addBasePath","addLocale","defaultLocale","cloneElement","isDisabled","hasIntersectionObserver","unobserve","setVisible","root","setRoot","tagName","callback","createObserver","instance","existing","idList","observers","elements","observer","IntersectionObserver","entries","entry","isIntersecting","intersectionRatio","observe","delete","size","disconnect","index","findIndex","splice","idleCallback","_requestIdleCallback","requestIdleCallback","cancelIdleCallback","slogan","dangerouslySetInnerHTML","__html","InfoIcon","iconName","privacyPolicy","sitemap","accessibilityStatement","privacy","values","accessibility","br","data","status","_","useSWR","error","setState","location","state","useFetchMainData","contrastIcon","facebook","youtube","instagram","tikTok","threads","ColoredDivider","subTitle","Toolbar","h2","Slogan","headerImage","sloganTop_HU","header","Logo","HeaderBackgroundLayout","SearchField","HeaderBlockContent","headerData","setHeaderData","isHomePage","subPageHeaderData","CompactBlockContent","phone","mailTo","address","addressTitle","issueLink","issueCover","handleDisplay","fullscreenElement","setIsOpen","addEventListener","removeEventListener","requestFullscreen","iframe","allow","sandbox","allowFullScreen","sloganBottom_HU","footer","Contact","Magazine","Info","WaterMark","SubMenuListItem","li","subMenus","ul","SubMenuList","createCardComponents","webMenu","item","isExtended","ExtendedCard","SimpleCard","HomePageCardListWrapper","nav","SubPageCardListWrapper","CardList","setIsVisible","substring","shouldMenuBeVisible","updatedData","prepareMap","mapWebMenus","query","webmenuId","setWebmenu","findMenuItem","isPreview","includes","equalToOneOfTheUrls","partOfOneOfTheUrls","getUrlObjectByParentList","contentId","getSlug","urlObjects","label","maskedUrl","setBreadcrumbs","breadcrumbs","items","arrayLength","indexOfItem","sessionStorage","getItem","setItem","removeItem","handleClick","scrollTo","behavior","competitionLogo","competitionLogoUrl","open","ACCESSIBILITY_POPUP_ID","setTimeout","show","Modal","activeItemId","setIsActive","isActive","useIsActive","articleHead","prev","next","coverImage","lead","slug","heading","urlObjectFactoryForPagesWithSlug","visibility","ThumbnailTitle","ImageItem","fileThumbUrl","currentItem","setter","stop","interval","setInterval","currentItemIndex","nextItemIndex","clearInterval","articles","inViewport","curr","setActiveItemId","useTimer","stopCarousel","keyDownHandler","setStopCarousel","active","article","section","PageTitle","onTouchStart","setTouchEnd","setTouchStart","targetTouches","clientX","onTouchMove","onTouchEnd","touchStart","touchEnd","distance","FeaturedNewsThumbnail","Marker","LightBackground","Component","pageProps","useFetchWebmenus","useActiveWebmenu","useHighContrast","useAccessibilityInfoShown","isModelShow","getElementsByClassName","back","Script","async","data-cbid","data-blockingmode","script","data-cookieconsent","Header","SubPageHeader","main","Breadcrumbs","featuredNews","FeaturedNewsPanel","campaign","announcements","Menu","ActionButton","Footer","AccessibilityPopup","arr","lastIndexOf","childMap","getPathnameByListType","preview","urlWithoutSlug","webMenus","basepath","urlObjectFactoryForPages","isWithSlug","n","t","defaultSetTimout","defaultClearTimeout","runTimeout","this","clearTimeout","u","o","cleanUpNextTick","drainQueue","run","runClearTimeout","Item","fun","array","noop","nextTick","apply","browser","argv","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","cwd","chdir","umask","__nccwpck_require__","ab","__dirname","__awaiter","thisArg","_arguments","P","generator","reject","fulfilled","step","rejected","result","done","__generator","f","y","sent","trys","ops","verb","Symbol","iterator","v","op","TypeError","pop","hook","UNDEFINED","OBJECT","isUndefined","isFunction","mergeObjects","STR_UNDEFINED","hasWindow","table","WeakMap","counter","stableHash","arg","constructor","isDate","Date","RegExp","toJSON","online","hasWin","hasDoc","onWindowEvent","bind","onDocumentEvent","offWindowEvent","offDocumentEvent","preset","isOnline","visibilityState","defaultConfigOptions","initFocus","initReconnect","onOnline","onOffline","IS_SERVER","rAF","useIsomorphicLayoutEffect","navigatorConnection","navigator","connection","slowConnection","effectiveType","saveData","serialize","args","isArray","SWRGlobalState","broadcastState","cache","isValidating","revalidate","broadcast","_a","EVENT_REVALIDATORS","STATE_UPDATERS","FETCH","revalidators","updaters","__timestamp","getTimestamp","internalMutate","_i","_key","_data","_opts","populateCache","rollbackOnError","customOptimisticData","keyInfo","_b","MUTATION","beforeMutationTs","hasCustomOptimisticData","rollbackData","optimisticData","res","_c","revalidateAllKeys","initCache","provider","mutate","unmount","releaseFocus_1","releaseReconnect_1","defaultConfig","onLoadingSlow","onSuccess","onErrorRetry","__","maxRetryCount","errorRetryCount","currentRetryCount","retryCount","timeout","random","errorRetryInterval","onDiscarded","revalidateOnFocus","revalidateOnReconnect","revalidateIfStale","shouldRetryOnError","focusThrottleInterval","dedupingInterval","loadingTimeout","compare","currentData","newData","isPaused","fallback","mergeConfigs","u1","use","f1","u2","f2","SWRConfigContext","normalize","useSWRConfig","subscribeCallback","callbacks","keyedRevalidators","WITH_DEDUPE","dedupe","extendedConfig","cacheContext","fallbackData","suspense","revalidateOnMount","refreshInterval","refreshWhenHidden","refreshWhenOffline","fnArgs","initialMountedRef","unmountedRef","keyRef","fetcherRef","configRef","getConfig","patchFetchInfo","info","cached","isInitialMount","shouldRevalidate","rerender","stateRef","stateDependenciesRef","payload","shouldRerender","currentState","k","useStateWithDeps","stateDependencies","revalidateOpts","currentFetcher","startAt","shouldStartNewRequest","isCurrentKeyMounted","cleanupState","newState","finishRequestAndUpdateState","mutationInfo","err_1","requestInfo","boundMutate","keyChanged","softRevalidate","nextFocusRevalidatedAt","unsubUpdate","updatedError","updatedIsValidating","unsubEvents","now","timer","execute","useDebugValue","fallbackConfig","fn","_config"],"sourceRoot":""}