@gaddario98/react-pages/dist/utils/index.mjs.map

A powerful, performance-optimized React component library for creating dynamic pages that work seamlessly across web (React DOM) and React Native with integrated form management, query handling, SEO metadata, lazy loading, and content rendering.

{"version":3,"file":"index.mjs","sources":["../../../utils/optimization.ts","../../../utils/merge.ts","../../../../node_modules/tslib/tslib.es6.js","../../../utils/lazy.tsx","../../../utils/deprecations.ts"],"sourcesContent":["import equal from 'fast-deep-equal';\n\n/**\n * Optimized shallow equality check for objects and functions\n * @param objA - First object to compare\n * @param objB - Second object to compare\n * @returns True if objects are shallow equal\n */\nexport function shallowEqual(objA: any, objB: any): boolean {\n  if (objA === objB) return true;\n  \n  if (!objA || !objB) return false;\n  \n  if (typeof objA !== 'object' || typeof objB !== 'object') {\n    return objA === objB;\n  }\n  \n  if (typeof objA === 'function' && typeof objB === 'function') {\n    return objA.name === objB.name && objA.toString() === objB.toString();\n  }\n  \n  const keysA = Object.keys(objA);\n  const keysB = Object.keys(objB);\n  \n  if (keysA.length !== keysB.length) return false;\n  \n  for (const key of keysA) {\n    if (!keysB.includes(key)) return false;\n    \n    const valA = objA[key];\n    const valB = objB[key];\n    \n    if (typeof valA === 'function' && typeof valB === 'function') {\n      if (valA.name !== valB.name || valA.toString() !== valB.toString()) {\n        return false;\n      }\n      continue;\n    }\n    \n    if (valA !== valB) return false;\n  }\n  \n  return true;\n}\n\n/**\n * Checks if a value is stable for React dependency arrays\n * @param value - Value to check for stability\n * @returns True if value is considered stable\n */\nexport function isStableValue(value: any): boolean {\n  if (value === null || value === undefined) return true;\n  if (typeof value !== 'object' && typeof value !== 'function') return true;\n  if (typeof value === 'function') return value.toString().length < 1000;\n  return false;\n}\n\n/**\n * Creates an optimized dependency array by filtering unstable values\n * @param deps - Array of dependencies to optimize\n * @returns Filtered array of stable dependencies\n */\nexport function optimizeDeps(deps: any[]): any[] {\n  return deps.filter(dep => isStableValue(dep) || typeof dep === 'object');\n}\n\n/**\n * Custom prop comparator for React.memo() to prevent unnecessary re-renders\n * Compares props shallowly and ignores function references if they have the same name\n * @param prevProps - Previous component props\n * @param nextProps - Next component props\n * @returns True if props are equal (component should NOT re-render)\n */\nexport function memoPropsComparator<P extends Record<string, any>>(\n  prevProps: Readonly<P>,\n  nextProps: Readonly<P>\n): boolean {\n  return shallowEqual(prevProps, nextProps);\n}\n\n/**\n * Deep equality check for complex objects\n * Use sparingly - prefer shallow equality for performance\n * Uses fast-deep-equal library for optimized deep comparison with circular reference protection\n * @param objA - First object\n * @param objB - Second object\n * @returns True if objects are deeply equal\n */\nexport function deepEqual(objA: any, objB: any): boolean {\n  return equal(objA, objB);\n}\n\n/**\n * Memoization cache for expensive computations\n * Simple LRU cache with configurable size\n */\nexport class MemoizationCache<K, V> {\n  private cache: Map<K, V>;\n  private maxSize: number;\n\n  constructor(maxSize: number = 100) {\n    this.cache = new Map();\n    this.maxSize = maxSize;\n  }\n\n  get(key: K): V | undefined {\n    const value = this.cache.get(key);\n    if (value !== undefined) {\n      // Move to end (most recently used)\n      this.cache.delete(key);\n      this.cache.set(key, value);\n    }\n    return value;\n  }\n\n  set(key: K, value: V): void {\n    // Delete oldest entry if cache is full\n    if (this.cache.size >= this.maxSize) {\n      const firstKey = this.cache.keys().next().value;\n      if (firstKey !== undefined) {\n        this.cache.delete(firstKey);\n      }\n    }\n    this.cache.set(key, value);\n  }\n\n  has(key: K): boolean {\n    return this.cache.has(key);\n  }\n\n  clear(): void {\n    this.cache.clear();\n  }\n}\n\n/**\n * Creates a memoized function with custom cache key generator\n * @param fn - Function to memoize\n * @param cacheKeyFn - Optional function to generate cache key from arguments\n * @returns Memoized function\n */\nexport function memoize<Args extends any[], Result>(\n  fn: (...args: Args) => Result,\n  cacheKeyFn?: (...args: Args) => string\n): (...args: Args) => Result {\n  const cache = new MemoizationCache<string, Result>();\n\n  return (...args: Args): Result => {\n    const cacheKey = cacheKeyFn\n      ? cacheKeyFn(...args)\n      : JSON.stringify(args);\n\n    if (cache.has(cacheKey)) {\n      return cache.get(cacheKey)!;\n    }\n\n    const result = fn(...args);\n    cache.set(cacheKey, result);\n    return result;\n  };\n}","/**\n * Configuration Merge Utility (T084)\n * Provides deep merging of configuration objects with proper precedence\n * Handles arrays, objects, and primitives correctly\n *\n * @module utils/merge\n */\n\n/**\n * Options for controlling merge behavior\n */\nexport interface MergeOptions {\n  /** If true, arrays are concatenated instead of replaced (default: false) */\n  concatArrays?: boolean;\n\n  /** If true, null/undefined values overwrite existing values (default: false) */\n  overwriteWithEmpty?: boolean;\n\n  /** Maximum depth for recursion to prevent infinite loops (default: 10) */\n  maxDepth?: number;\n\n  /** Keys to skip during merge */\n  skipKeys?: Set<string>;\n}\n\n/**\n * Deep merge of multiple objects with precedence from left to right\n * Later objects override earlier ones, with special handling for nested objects\n *\n * @param objects - Objects to merge (left to right precedence)\n * @param options - Merge options\n * @returns Merged object\n *\n * @example\n * ```typescript\n * const defaults = { theme: 'light', nested: { color: 'black' } };\n * const overrides = { theme: 'dark', nested: { fontSize: 14 } };\n * const result = deepMerge(defaults, overrides);\n * // Result: { theme: 'dark', nested: { color: 'black', fontSize: 14 } }\n * ```\n */\nexport function deepMerge<T extends Record<string, any>>(\n  ...objects: (T | undefined | null)[]\n): T {\n  return deepMergeWithOptions({}, objects.filter((obj) => obj != null), {\n    maxDepth: 10,\n  }) as T;\n}\n\n/**\n * Deep merge with custom options\n * @param target - Target object to merge into\n * @param sources - Source objects to merge\n * @param options - Merge options\n * @returns Merged object\n */\nexport function deepMergeWithOptions<T extends Record<string, any>>(\n  target: T,\n  sources: T[],\n  options: MergeOptions = {}\n): T {\n  const { concatArrays = false, overwriteWithEmpty = false, maxDepth = 10, skipKeys = new Set() } = options;\n\n  function merge(target: any, source: any, depth: number = 0): any {\n    // Prevent infinite recursion\n    if (depth > maxDepth) {\n      console.warn('[deepMerge] Maximum recursion depth exceeded');\n      return source;\n    }\n\n    // Handle null/undefined\n    if (source == null) {\n      return overwriteWithEmpty ? source : target;\n    }\n\n    if (target == null) {\n      return source;\n    }\n\n    // Handle primitives and functions\n    if (typeof source !== 'object' || typeof target !== 'object') {\n      return source;\n    }\n\n    // Handle arrays\n    if (Array.isArray(source)) {\n      if (!Array.isArray(target)) {\n        return source;\n      }\n\n      if (concatArrays) {\n        return [...target, ...source];\n      }\n\n      return source;\n    }\n\n    // Handle non-array objects\n    if (Array.isArray(target)) {\n      return source; // Source object replaces target array\n    }\n\n    // Deep merge objects\n    const result = { ...target };\n\n    for (const key in source) {\n      if (!source.hasOwnProperty(key) || skipKeys.has(key)) {\n        continue;\n      }\n\n      const sourceValue = source[key];\n      const targetValue = result[key];\n\n      if (sourceValue == null) {\n        if (overwriteWithEmpty) {\n          result[key] = sourceValue;\n        }\n        continue;\n      }\n\n      // Recursively merge nested objects\n      if (\n        typeof sourceValue === 'object' &&\n        typeof targetValue === 'object' &&\n        !Array.isArray(sourceValue) &&\n        !Array.isArray(targetValue)\n      ) {\n        result[key] = merge(targetValue, sourceValue, depth + 1);\n      } else {\n        result[key] = sourceValue;\n      }\n    }\n\n    return result;\n  }\n\n  return sources.reduce((acc, source) => merge(acc, source), target);\n}\n\n/**\n * Shallow merge of objects (only top-level keys)\n * @param objects - Objects to merge\n * @returns Merged object\n */\nexport function shallowMerge<T extends Record<string, any>>(\n  ...objects: (T | undefined | null)[]\n): T {\n  const filtered = objects.filter((obj) => obj != null);\n  return Object.assign({}, ...filtered) as T;\n}\n\n/**\n * Merge arrays of objects by a key (useful for config arrays)\n * @param baseArray - Base array\n * @param overrideArray - Array to merge in\n * @param keyName - Key to match on\n * @returns Merged array\n *\n * @example\n * ```typescript\n * const base = [{ id: 'a', name: 'Alice' }, { id: 'b', name: 'Bob' }];\n * const override = [{ id: 'a', name: 'Alicia' }, { id: 'c', name: 'Charlie' }];\n * const result = mergeArraysByKey(base, override, 'id');\n * // Result: [{ id: 'a', name: 'Alicia' }, { id: 'b', name: 'Bob' }, { id: 'c', name: 'Charlie' }]\n * ```\n */\nexport function mergeArraysByKey<T extends Record<string, any>>(\n  baseArray: T[],\n  overrideArray: T[],\n  keyName: string\n): T[] {\n  const baseMap = new Map<any, T>();\n  const result: T[] = [];\n\n  // Add base array items to map\n  baseArray.forEach((item) => {\n    const key = item[keyName];\n    baseMap.set(key, item);\n  });\n\n  // Track which keys we've seen\n  const seenKeys = new Set<any>();\n\n  // Merge overrides\n  overrideArray.forEach((item) => {\n    const key = item[keyName];\n    seenKeys.add(key);\n\n    if (baseMap.has(key)) {\n      // Deep merge if key exists\n      const merged = deepMerge(baseMap.get(key)!, item);\n      baseMap.set(key, merged);\n    } else {\n      // Add new item\n      baseMap.set(key, item);\n    }\n  });\n\n  // Build result maintaining base order, then add new items\n  baseArray.forEach((item) => {\n    const key = item[keyName];\n    result.push(baseMap.get(key)!);\n  });\n\n  // Add new items from override\n  overrideArray.forEach((item) => {\n    const key = item[keyName];\n    if (!baseArray.some((baseItem) => baseItem[keyName] === key)) {\n      result.push(item);\n    }\n  });\n\n  return result;\n}\n\n/**\n * Check if two objects are deeply equal\n * Useful for detecting if a merge actually changed anything\n * Note: Use the fast-deep-equal version from optimization.ts instead\n * @deprecated - Use deepEqual from utils/optimization.ts instead\n * @param obj1 - First object\n * @param obj2 - Second object\n * @returns True if objects are deeply equal\n */\nexport function deepEqualFallback(obj1: any, obj2: any): boolean {\n  if (obj1 === obj2) {\n    return true;\n  }\n\n  if (obj1 == null || obj2 == null) {\n    return obj1 === obj2;\n  }\n\n  if (typeof obj1 !== 'object' || typeof obj2 !== 'object') {\n    return false;\n  }\n\n  const keys1 = Object.keys(obj1);\n  const keys2 = Object.keys(obj2);\n\n  if (keys1.length !== keys2.length) {\n    return false;\n  }\n\n  for (const key of keys1) {\n    if (!keys2.includes(key)) {\n      return false;\n    }\n\n    if (!deepEqualFallback(obj1[key], obj2[key])) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * Stable Cache for memoizing objects across renders\n * Prevents unnecessary object creation in hooks\n *\n * @example\n * ```typescript\n * const cache = useRef(new StableCache<FormConfig>());\n * const formConfig = cache.current.getOrSet('key', () => createConfig());\n * ```\n */\nexport class StableCache<T> {\n  private cache: Map<string, T> = new Map();\n\n  /**\n   * Get value from cache, or set it if not present\n   * @param key - Cache key\n   * @param factory - Function to create value if not cached\n   * @returns Cached or newly created value\n   */\n  getOrSet(key: string, factory: () => T): T {\n    if (this.cache.has(key)) {\n      return this.cache.get(key)!;\n    }\n    const value = factory();\n    this.cache.set(key, value);\n    return value;\n  }\n\n  /**\n   * Get value from cache\n   * @param key - Cache key\n   * @returns Cached value or undefined\n   */\n  get(key: string): T | undefined {\n    return this.cache.get(key);\n  }\n\n  /**\n   * Set value in cache\n   * @param key - Cache key\n   * @param value - Value to cache\n   */\n  set(key: string, value: T): void {\n    this.cache.set(key, value);\n  }\n\n  /**\n   * Check if key exists in cache\n   * @param key - Cache key\n   * @returns True if key exists\n   */\n  has(key: string): boolean {\n    return this.cache.has(key);\n  }\n\n  /**\n   * Clear all cached values\n   */\n  clear(): void {\n    this.cache.clear();\n  }\n\n  /**\n   * Get cache size\n   * @returns Number of cached items\n   */\n  size(): number {\n    return this.cache.size;\n  }\n}\n","/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise, SuppressedError, Symbol, Iterator */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\r\n    function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\r\n    var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\r\n    var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\r\n    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\r\n    var _, done = false;\r\n    for (var i = decorators.length - 1; i >= 0; i--) {\r\n        var context = {};\r\n        for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\r\n        for (var p in contextIn.access) context.access[p] = contextIn.access[p];\r\n        context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\r\n        var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\r\n        if (kind === \"accessor\") {\r\n            if (result === void 0) continue;\r\n            if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\r\n            if (_ = accept(result.get)) descriptor.get = _;\r\n            if (_ = accept(result.set)) descriptor.set = _;\r\n            if (_ = accept(result.init)) initializers.unshift(_);\r\n        }\r\n        else if (_ = accept(result)) {\r\n            if (kind === \"field\") initializers.unshift(_);\r\n            else descriptor[key] = _;\r\n        }\r\n    }\r\n    if (target) Object.defineProperty(target, contextIn.name, descriptor);\r\n    done = true;\r\n};\r\n\r\nexport function __runInitializers(thisArg, initializers, value) {\r\n    var useValue = arguments.length > 2;\r\n    for (var i = 0; i < initializers.length; i++) {\r\n        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\r\n    }\r\n    return useValue ? value : void 0;\r\n};\r\n\r\nexport function __propKey(x) {\r\n    return typeof x === \"symbol\" ? x : \"\".concat(x);\r\n};\r\n\r\nexport function __setFunctionName(f, name, prefix) {\r\n    if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\r\n    return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\r\n};\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === \"function\" ? Iterator : Object).prototype);\r\n    return g.next = verb(0), g[\"throw\"] = verb(1), g[\"return\"] = verb(2), typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (g && (g = 0, op[0] && (_ = 0)), _) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 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}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    var desc = Object.getOwnPropertyDescriptor(m, k);\r\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n        desc = { enumerable: true, get: function() { return m[k]; } };\r\n    }\r\n    Object.defineProperty(o, k2, desc);\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = Object.create((typeof AsyncIterator === \"function\" ? AsyncIterator : Object).prototype), verb(\"next\"), verb(\"throw\"), verb(\"return\", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }\r\n    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nvar ownKeys = function(o) {\r\n    ownKeys = Object.getOwnPropertyNames || function (o) {\r\n        var ar = [];\r\n        for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;\r\n        return ar;\r\n    };\r\n    return ownKeys(o);\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== \"default\") __createBinding(result, mod, k[i]);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n\r\nexport function __classPrivateFieldIn(state, receiver) {\r\n    if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n    return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n}\r\n\r\nexport function __addDisposableResource(env, value, async) {\r\n    if (value !== null && value !== void 0) {\r\n        if (typeof value !== \"object\" && typeof value !== \"function\") throw new TypeError(\"Object expected.\");\r\n        var dispose, inner;\r\n        if (async) {\r\n            if (!Symbol.asyncDispose) throw new TypeError(\"Symbol.asyncDispose is not defined.\");\r\n            dispose = value[Symbol.asyncDispose];\r\n        }\r\n        if (dispose === void 0) {\r\n            if (!Symbol.dispose) throw new TypeError(\"Symbol.dispose is not defined.\");\r\n            dispose = value[Symbol.dispose];\r\n            if (async) inner = dispose;\r\n        }\r\n        if (typeof dispose !== \"function\") throw new TypeError(\"Object not disposable.\");\r\n        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };\r\n        env.stack.push({ value: value, dispose: dispose, async: async });\r\n    }\r\n    else if (async) {\r\n        env.stack.push({ async: true });\r\n    }\r\n    return value;\r\n\r\n}\r\n\r\nvar _SuppressedError = typeof SuppressedError === \"function\" ? SuppressedError : function (error, suppressed, message) {\r\n    var e = new Error(message);\r\n    return e.name = \"SuppressedError\", e.error = error, e.suppressed = suppressed, e;\r\n};\r\n\r\nexport function __disposeResources(env) {\r\n    function fail(e) {\r\n        env.error = env.hasError ? new _SuppressedError(e, env.error, \"An error was suppressed during disposal.\") : e;\r\n        env.hasError = true;\r\n    }\r\n    var r, s = 0;\r\n    function next() {\r\n        while (r = env.stack.pop()) {\r\n            try {\r\n                if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);\r\n                if (r.dispose) {\r\n                    var result = r.dispose.call(r.value);\r\n                    if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });\r\n                }\r\n                else s |= 1;\r\n            }\r\n            catch (e) {\r\n                fail(e);\r\n            }\r\n        }\r\n        if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();\r\n        if (env.hasError) throw env.error;\r\n    }\r\n    return next();\r\n}\r\n\r\nexport function __rewriteRelativeImportExtension(path, preserveJsx) {\r\n    if (typeof path === \"string\" && /^\\.\\.?\\//.test(path)) {\r\n        return path.replace(/\\.(tsx)$|((?:\\.d)?)((?:\\.[^./]+?)?)\\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {\r\n            return tsx ? preserveJsx ? \".jsx\" : \".js\" : d && (!ext || !cm) ? m : (d + ext + \".\" + cm.toLowerCase() + \"js\");\r\n        });\r\n    }\r\n    return path;\r\n}\r\n\r\nexport default {\r\n    __extends: __extends,\r\n    __assign: __assign,\r\n    __rest: __rest,\r\n    __decorate: __decorate,\r\n    __param: __param,\r\n    __esDecorate: __esDecorate,\r\n    __runInitializers: __runInitializers,\r\n    __propKey: __propKey,\r\n    __setFunctionName: __setFunctionName,\r\n    __metadata: __metadata,\r\n    __awaiter: __awaiter,\r\n    __generator: __generator,\r\n    __createBinding: __createBinding,\r\n    __exportStar: __exportStar,\r\n    __values: __values,\r\n    __read: __read,\r\n    __spread: __spread,\r\n    __spreadArrays: __spreadArrays,\r\n    __spreadArray: __spreadArray,\r\n    __await: __await,\r\n    __asyncGenerator: __asyncGenerator,\r\n    __asyncDelegator: __asyncDelegator,\r\n    __asyncValues: __asyncValues,\r\n    __makeTemplateObject: __makeTemplateObject,\r\n    __importStar: __importStar,\r\n    __importDefault: __importDefault,\r\n    __classPrivateFieldGet: __classPrivateFieldGet,\r\n    __classPrivateFieldSet: __classPrivateFieldSet,\r\n    __classPrivateFieldIn: __classPrivateFieldIn,\r\n    __addDisposableResource: __addDisposableResource,\r\n    __disposeResources: __disposeResources,\r\n    __rewriteRelativeImportExtension: __rewriteRelativeImportExtension,\r\n};\r\n","import React, { Suspense, ComponentType, ReactNode } from 'react';\n\n/**\n * Configuration for lazy loading behavior\n */\nexport interface LazyLoadConfig {\n  /** Whether to enable lazy loading (default: true) */\n  enabled?: boolean;\n  /** Preload on hover (only for interactive elements) */\n  preloadOnHover?: boolean;\n  /** Fallback component to show while loading */\n  suspenseFallback?: ReactNode;\n  /** Custom error boundary component */\n  errorBoundary?: ComponentType<{ error: Error; retry: () => void }>;\n  /** T095: Custom Suspense fallback factory function for dynamic fallbacks */\n  fallbackFactory?: (componentName: string) => ReactNode;\n  /** T095: Timeout in ms to show fallback (useful for fast components) */\n  fallbackDelay?: number;\n}\n\n/**\n * Enhanced lazy wrapper with optional preloading capability\n *\n * Wraps React.lazy() with a Suspense boundary and optional preload support.\n * Helps reduce initial bundle size by code-splitting components.\n *\n * @example\n * ```tsx\n * // Basic lazy loading\n * const HeavyComponent = lazyWithPreload(() => import('./Heavy'));\n *\n * function App() {\n *   return (\n *     <lazyWithPreload.Suspense fallback={<Loader />}>\n *       <HeavyComponent />\n *     </lazyWithPreload.Suspense>\n *   );\n * }\n * ```\n *\n * @example\n * ```tsx\n * // With preloading on hover\n * const LazyModal = lazyWithPreload(\n *   () => import('./Modal'),\n *   { preloadOnHover: true }\n * );\n *\n * function Button() {\n *   return (\n *     <button onMouseEnter={() => LazyModal.preload?.()}>\n *       Open Modal\n *     </button>\n *   );\n * }\n * ```\n */\nexport function lazyWithPreload<P extends Record<string, any>>(\n  importFunc: () => Promise<{ default: ComponentType<P> }>,\n  config?: LazyLoadConfig\n) {\n  // Create lazy component\n  const LazyComponent = React.lazy(importFunc);\n\n  // Store preload function for optional use\n  let preloadPromise: Promise<{ default: ComponentType<P> }> | null = null;\n\n  /**\n   * Preload the component by initiating the import\n   */\n  const preload = () => {\n    if (!preloadPromise) {\n      preloadPromise = importFunc();\n    }\n    return preloadPromise;\n  };\n\n  /**\n   * Wrapper component that handles preloading on hover\n   */\n  const LazyWrapper = (props: P & { onMouseEnter?: () => void; onMouseLeave?: () => void }) => {\n    const { onMouseEnter, onMouseLeave, ...restProps } = props;\n\n    const handleMouseEnter = () => {\n      if (config?.preloadOnHover) {\n        preload();\n      }\n      onMouseEnter?.();\n    };\n\n    return (\n      <div onMouseEnter={handleMouseEnter} onMouseLeave={onMouseLeave} style={{ display: 'contents' }}>\n        <LazyComponent {...(restProps as P)} />\n      </div>\n    );\n  };\n\n  // Attach preload function to component for external access\n  (LazyWrapper as any).preload = preload;\n\n  // Attach Suspense for convenience\n  (LazyWrapper as any).Suspense = Suspense;\n\n  // Default fallback\n  const defaultFallback = config?.suspenseFallback || <div>Loading...</div>;\n\n  /**\n   * Wrapped component with integrated Suspense boundary\n   */\n  const WithSuspense = (props: P) => (\n    <Suspense fallback={defaultFallback}>\n      <LazyWrapper {...props} />\n    </Suspense>\n  );\n\n  (WithSuspense as any).preload = preload;\n  (WithSuspense as any).Suspense = Suspense;\n\n  return WithSuspense as ComponentType<P> & {\n    preload: () => Promise<{ default: ComponentType<P> }>;\n    Suspense: typeof Suspense;\n  };\n}\n\n/**\n * Create a batch of lazy components with shared preloading strategy\n *\n * Useful for code-splitting a route or feature module\n *\n * @example\n * ```tsx\n * const lazyPages = lazyBatch({\n *   UserList: () => import('./pages/UserList'),\n *   UserDetail: () => import('./pages/UserDetail'),\n *   UserForm: () => import('./pages/UserForm'),\n * }, {\n *   preloadOnHover: true,\n *   suspenseFallback: <PageLoader />\n * });\n *\n * function App() {\n *   return (\n *     <Routes>\n *       <Route path=\"/users\" element={<lazyPages.UserList />} />\n *       <Route path=\"/users/:id\" element={<lazyPages.UserDetail />} />\n *     </Routes>\n *   );\n * }\n * ```\n */\nexport function lazyBatch<T extends Record<string, () => Promise<{ default: ComponentType<any> }>>>(\n  modules: T,\n  config?: LazyLoadConfig\n) {\n  return Object.entries(modules).reduce((acc, [key, importFunc]) => {\n    acc[key as keyof T] = lazyWithPreload(importFunc, config);\n    return acc;\n  }, {} as T);\n}\n\n/**\n * Preload multiple components in parallel\n *\n * Useful for preloading components before user interaction\n *\n * @example\n * ```tsx\n * // Preload critical components on app mount\n * useEffect(() => {\n *   preloadComponents([UserComponent.preload, SettingsComponent.preload]);\n * }, []);\n * ```\n */\nexport function preloadComponents(\n  preloaders: Array<() => Promise<any>>\n) {\n  return Promise.all(preloaders.map(preload => preload()));\n}\n\n/**\n * Higher-order component to wrap lazy-loaded components with error boundary\n *\n * @example\n * ```tsx\n * const SafeLazyComponent = withLazyErrorBoundary(LazyComponent, {\n *   fallback: <ErrorMessage />\n * });\n * ```\n */\nexport function withLazyErrorBoundary<P extends Record<string, any>>(\n  Component: ComponentType<P>,\n  config?: { fallback?: ReactNode }\n) {\n  const Wrapper = (props: P) => {\n    const [error, setError] = React.useState<Error | null>(null);\n\n    if (error) {\n      return config?.fallback || <div>Error loading component</div>;\n    }\n\n    return (\n      <ErrorBoundary onError={setError}>\n        <Component {...props} />\n      </ErrorBoundary>\n    );\n  };\n\n  return Wrapper;\n}\n\n/**\n * Simple error boundary implementation\n */\nclass ErrorBoundary extends React.Component<\n  { children: ReactNode; onError: (error: Error) => void },\n  { hasError: boolean }\n> {\n  constructor(props: { children: ReactNode; onError: (error: Error) => void }) {\n    super(props);\n    this.state = { hasError: false };\n  }\n\n  static getDerivedStateFromError() {\n    return { hasError: true };\n  }\n\n  componentDidCatch(error: Error) {\n    this.props.onError(error);\n  }\n\n  render() {\n    if (this.state.hasError) {\n      return null;\n    }\n    return this.props.children;\n  }\n}\n\n/**\n * T095: Hook to preload a lazy component on demand\n * Useful for imperative preloading scenarios\n *\n * @example\n * ```tsx\n * function MyComponent() {\n *   const preload = usePreloadLazy(HeavyComponent);\n *\n *   return (\n *     <button onMouseEnter={preload}>\n *       Hover to preload\n *     </button>\n *   );\n * }\n * ```\n */\nexport function usePreloadLazy<P extends Record<string, any>>(\n  component: ComponentType<P> & { preload?: () => Promise<any> }\n) {\n  return React.useCallback(() => {\n    if (component.preload) {\n      component.preload();\n    }\n  }, [component]);\n}\n\n/**\n * T095: Hook to preload multiple lazy components\n * Useful for preloading a set of components before user navigation\n *\n * @example\n * ```tsx\n * function Navigation() {\n *   usePreloadLazyBatch([UserList, UserDetail, UserForm]);\n *\n *   return <nav>...</nav>;\n * }\n * ```\n */\nexport function usePreloadLazyBatch(\n  components: Array<ComponentType<any> & { preload?: () => Promise<any> }>\n) {\n  return React.useCallback(() => {\n    components.forEach(component => {\n      if (component.preload) {\n        component.preload();\n      }\n    });\n  }, [components]);\n}\n\n/**\n * T095: Hook to preload lazy components on viewport intersection\n * Useful for preloading components that are likely to be scrolled into view\n *\n * @example\n * ```tsx\n * function LazySection() {\n *   const ref = usePreloadOnViewport(ExpensiveComponent);\n *\n *   return <div ref={ref}>Content goes here</div>;\n * }\n * ```\n */\nexport function usePreloadOnViewport<P extends Record<string, any>>(\n  component: ComponentType<P> & { preload?: () => Promise<any> }\n) {\n  const ref = React.useRef<HTMLDivElement>(null);\n\n  React.useEffect(() => {\n    if (!ref.current || !component.preload) return;\n\n    const observer = new IntersectionObserver(\n      entries => {\n        entries.forEach(entry => {\n          if (entry.isIntersecting) {\n            component.preload?.();\n            observer.unobserve(entry.target);\n          }\n        });\n      },\n      { threshold: 0.1 }\n    );\n\n    observer.observe(ref.current);\n\n    return () => observer.disconnect();\n  }, [component]);\n\n  return ref;\n}\n","/**\n * Deprecation warnings for v1.x → v2.0 migration\n * This file manages deprecation notices and warnings for removed/changed v1.x APIs\n *\n * @module utils/deprecations\n */\n\n/**\n * Set of deprecated features that have been warned about\n * Prevents duplicate warnings in development mode\n */\nconst warnedFeatures = new Set<string>();\n\n/**\n * Log a deprecation warning (only in development, only once per feature)\n * @param featureName - Name of the deprecated feature\n * @param message - Deprecation message with migration guidance\n * @param replacement - Recommended replacement code/feature\n */\nexport function deprecationWarning(\n  featureName: string,\n  message: string,\n  replacement?: string\n): void {\n  if (process.env.NODE_ENV !== 'development') {\n    return;\n  }\n\n  if (warnedFeatures.has(featureName)) {\n    return; // Already warned about this feature\n  }\n\n  warnedFeatures.add(featureName);\n\n  const fullMessage = [\n    `⚠️ [react-pages v2] Deprecation Warning`,\n    `Feature: ${featureName}`,\n    `${message}`,\n    replacement ? `Recommended replacement:\\n${replacement}` : '',\n    'See https://github.com/gaddario98/react-pages#migration for details',\n  ]\n    .filter(Boolean)\n    .join('\\n');\n\n  console.warn(fullMessage);\n}\n\n/**\n * Warnings for specific v1.x API patterns\n */\nexport const V1_DEPRECATIONS = {\n  HELMET_PROVIDER: {\n    name: 'react-helmet-async wrapper',\n    message:\n      'The <HelmetProvider> wrapper is no longer needed. Metadata injection is now automatic in PageGenerator.',\n    replacement: `Remove <HelmetProvider> from your app:\n// Before (v1.x):\n<HelmetProvider>\n  <PageGenerator {...pageProps} />\n</HelmetProvider>\n\n// After (v2.x):\n<PageGenerator {...pageProps} />`,\n  },\n\n  INLINE_METADATA: {\n    name: 'Inline metadata via viewSettings',\n    message:\n      'Setting metadata directly in viewSettings (metaTitle, metaDescription) is deprecated. Use the new PageProps.meta field instead.',\n    replacement: `Update your PageProps:\n// Before (v1.x):\n{\n  id: \"page\",\n  viewSettings: {\n    metaTitle: \"...\",\n    metaDescription: \"...\"\n  }\n}\n\n// After (v2.x):\n{\n  id: \"page\",\n  meta: {\n    title: \"...\",\n    description: \"...\"\n  }\n}`,\n  },\n\n  MANUAL_LAZY_LOADING: {\n    name: 'Manual React.lazy() for content',\n    message:\n      'Wrapping content in React.lazy() and Suspense manually is no longer needed. Use the ContentItem.lazy configuration instead.',\n    replacement: `// Before (v1.x):\nconst Component = lazy(() => import('./Heavy'));\n<Suspense fallback={<div>Loading...</div>}>\n  <Component />\n</Suspense>\n\n// After (v2.x):\n{\n  type: \"custom\",\n  component: <HeavyComponent />,\n  lazy: true,\n  lazyTrigger: \"viewport\"\n}`,\n  },\n\n  CUSTOM_FORM_DEBOUNCE: {\n    name: 'Custom form debouncing',\n    message:\n      'Custom debouncing logic in form handlers is now built-in. Use the form.debounceDelay property instead.',\n    replacement: `// Before (v1.x): You had to implement debouncing manually\n// After (v2.x):\n{\n  form: {\n    fields: [...],\n    debounceDelay: 300  // Built-in debouncing\n  }\n}`,\n  },\n\n  QUERY_DEPENDENCY_TRACKING: {\n    name: 'Implicit query dependency tracking',\n    message:\n      'Components that depend on specific queries should declare those dependencies explicitly using ContentItem.usedQueries for better performance.',\n    replacement: `// Before (v1.x): All content items re-rendered on any query change\n// After (v2.x): Declare specific dependencies\n{\n  type: \"custom\",\n  component: <MyComponent />,\n  usedQueries: [\"user\", \"posts\"]  // Only re-render when these change\n}`,\n  },\n\n  HELMET_IMPORT: {\n    name: 'Direct react-helmet-async import',\n    message:\n      'Importing react-helmet-async directly is no longer recommended. The library handles metadata automatically.',\n    replacement: `// Before (v1.x):\nimport { Helmet } from 'react-helmet-async';\n<Helmet>\n  <title>Page Title</title>\n</Helmet>\n\n// After (v2.x):\nconst pageProps = {\n  meta: {\n    title: \"Page Title\"\n  }\n}`,\n  },\n} as const;\n\n/**\n * Check if the app is using a deprecated pattern and warn\n * @param pattern - The deprecated pattern to check\n */\nexport function warnIfUsingDeprecatedPattern(\n  pattern: keyof typeof V1_DEPRECATIONS\n): void {\n  const deprecation = V1_DEPRECATIONS[pattern];\n  deprecationWarning(deprecation.name, deprecation.message, deprecation.replacement);\n}\n\n/**\n * Reset deprecation warnings (useful for testing)\n */\nexport function resetDeprecationWarnings(): void {\n  warnedFeatures.clear();\n}\n"],"names":["shallowEqual","objA","objB","name","toString","keysA","Object","keys","keysB","length","key","includes","valA","valB","isStableValue","value","undefined","optimizeDeps","deps","filter","dep","memoPropsComparator","prevProps","nextProps","deepEqual","equal","MemoizationCache","constructor","maxSize","cache","Map","get","delete","set","size","firstKey","next","has","clear","memoize","fn","cacheKeyFn","args","cacheKey","JSON","stringify","result","deepMerge","objects","deepMergeWithOptions","obj","maxDepth","target","sources","options","concatArrays","overwriteWithEmpty","skipKeys","Set","merge","source","depth","console","warn","Array","isArray","assign","hasOwnProperty","sourceValue","targetValue","reduce","acc","shallowMerge","filtered","mergeArraysByKey","baseArray","overrideArray","keyName","baseMap","forEach","item","seenKeys","add","merged","push","some","baseItem","deepEqualFallback","obj1","obj2","keys1","keys2","StableCache","getOrSet","factory","__rest","s","e","t","p","prototype","call","indexOf","getOwnPropertySymbols","i","propertyIsEnumerable","SuppressedError","error","suppressed","message","Error","lazyWithPreload","importFunc","config","LazyComponent","React","lazy","preloadPromise","preload","LazyWrapper","props","onMouseEnter","onMouseLeave","restProps","handleMouseEnter","preloadOnHover","_jsx","style","display","children","Suspense","defaultFallback","suspenseFallback","WithSuspense","fallback","lazyBatch","modules","entries","preloadComponents","preloaders","Promise","all","map","withLazyErrorBoundary","Component","Wrapper","$","_c","setError","useState","t0","Symbol","for","ErrorBoundary","onError","state","hasError","getDerivedStateFromError","componentDidCatch","render","usePreloadLazy","component","usePreloadLazyBatch","components","_temp","usePreloadOnViewport","ref","useRef","useEffect","current","observer","IntersectionObserver","entry","isIntersecting","_a","unobserve","threshold","observe","disconnect","warnedFeatures","deprecationWarning","featureName","replacement","process","env","NODE_ENV","fullMessage","Boolean","join","V1_DEPRECATIONS","HELMET_PROVIDER","INLINE_METADATA","MANUAL_LAZY_LOADING","CUSTOM_FORM_DEBOUNCE","QUERY_DEPENDENCY_TRACKING","HELMET_IMPORT","warnIfUsingDeprecatedPattern","pattern","deprecation","resetDeprecationWarnings"],"mappings":"iJAEA;;;;;AAKG;AACG,SAAUA,YAAYA,CAACC,IAAS,EAAEC,IAAS,EAAA;AAC/C,EAAA,IAAID,IAAI,KAAKC,IAAI,EAAE,OAAO,IAAI;AAE9B,EAAA,IAAI,CAACD,IAAI,IAAI,CAACC,IAAI,EAAE,OAAO,KAAK;EAEhC,IAAI,OAAOD,IAAI,KAAK,QAAQ,IAAI,OAAOC,IAAI,KAAK,QAAQ,EAAE;IACxD,OAAOD,IAAI,KAAKC,IAAI;AACtB,EAAA;EAEA,IAAI,OAAOD,IAAI,KAAK,UAAU,IAAI,OAAOC,IAAI,KAAK,UAAU,EAAE;AAC5D,IAAA,OAAOD,IAAI,CAACE,IAAI,KAAKD,IAAI,CAACC,IAAI,IAAIF,IAAI,CAACG,QAAQ,EAAE,KAAKF,IAAI,CAACE,QAAQ,EAAE;AACvE,EAAA;AAEA,EAAA,MAAMC,KAAK,GAAGC,MAAM,CAACC,IAAI,CAACN,IAAI,CAAC;AAC/B,EAAA,MAAMO,KAAK,GAAGF,MAAM,CAACC,IAAI,CAACL,IAAI,CAAC;EAE/B,IAAIG,KAAK,CAACI,MAAM,KAAKD,KAAK,CAACC,MAAM,EAAE,OAAO,KAAK;AAE/C,EAAA,KAAK,MAAMC,GAAG,IAAIL,KAAK,EAAE;IACvB,IAAI,CAACG,KAAK,CAACG,QAAQ,CAACD,GAAG,CAAC,EAAE,OAAO,KAAK;AAEtC,IAAA,MAAME,IAAI,GAAGX,IAAI,CAACS,GAAG,CAAC;AACtB,IAAA,MAAMG,IAAI,GAAGX,IAAI,CAACQ,GAAG,CAAC;IAEtB,IAAI,OAAOE,IAAI,KAAK,UAAU,IAAI,OAAOC,IAAI,KAAK,UAAU,EAAE;AAC5D,MAAA,IAAID,