{"version":3,"file":"immerser.esm.mjs","mappings":"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","sources":["webpack://immerser/./node_modules/@dubaua/merge-options/dist/merge-options.min.js","webpack://immerser/./node_modules/@dubaua/observable/dist/observable.min.js","webpack://immerser/webpack/bootstrap","webpack://immerser/webpack/runtime/compat get default export","webpack://immerser/webpack/runtime/define property getters","webpack://immerser/webpack/runtime/hasOwnProperty shorthand","webpack://immerser/./src/events.ts","webpack://immerser/./src/styles.ts","webpack://immerser/./src/selectors.ts","webpack://immerser/./src/options.ts","webpack://immerser/./src/utils/get-last-scroll-position.ts","webpack://immerser/./src/utils/query-element-array.ts","webpack://immerser/./src/immerser.ts","webpack://immerser/./src/utils/validate-immerser-markup.ts","webpack://immerser/./src/utils/calculate-layer-state-array.ts","webpack://immerser/./src/utils/calculate-layers-runtime-state.ts","webpack://immerser/./src/utils/calculate-scroll-target.ts","webpack://immerser/./src/utils/assign-inline-styles.ts","webpack://immerser/./src/utils/once-handler.ts"],"sourcesContent":["\"use strict\";function o(o,e){return Object.prototype.hasOwnProperty.call(o,e)}function e(o){return null!==o&&\"object\"==typeof o&&!1===Array.isArray(o)}function t(e){var t=e.optionConfig,i=e.userOptions,r=void 0===i?{}:i,n=e.prefix,a=void 0===n?\"\":n,f=e.suffix,u=void 0===f?\"\":f,p=e.strict,d=void 0===p||p,c=function(o){return[a,o,u].join(\" \")},s={};for(var l in t)if(o(t,l)){var g=t[l],v=g.required,y=g.default,b=g.description,x=g.validator,h=r[l],q=!!o(g,\"required\")&&(\"function\"==typeof v?v(r):v),E=o(r,l),w=x(h,r);if(q){if(!E)throw new TypeError(c(l+\" is required.\"));if(!w)throw new TypeError(c(\"Expected \"+l+\" to be \"+b+\", got \"+typeof h+\" \"+h+\".\"));s[l]=h}else if(s[l]=y,E)if(w)s[l]=h;else{if(d)throw new TypeError(c(\"Expected \"+l+\" to be \"+b+\", got \"+typeof h+\" \"+h+\".\"));console.warn(c(\"Expected \"+l+\" to be \"+b+\", got \"+typeof h+\" \"+h+\". Fallback to default value \"+y+\".\"))}}return s}var i=\"[mergeOptions]:\",r=\"\\nCheck out documentation https://github.com/dubaua/merge-options#parameters-and-return\";function n(o){throw new TypeError([i,o,r].join(\" \"))}var a={optionConfig:{required:!0,validator:function(t){for(var i in t)if(o(t,i)){var r=t[i];if(e(r)||n(\"Expected optionConfig.\"+i+\" to be an object with declarative option configuration, got \"+typeof r+\" \"+r+\".\"),o(r,\"required\")){var a=r.required,f=typeof a;\"boolean\"!==f&&\"function\"!==f&&n(\"Expected optionConfig.\"+i+\".required to be either boolean or function, got \"+typeof a+\" \"+a+\".\")}else o(r,\"default\")||n(\"Expected optionConfig.\"+i+\" to either have required or default value.\");if(o(r,\"default\")||o(r,\"required\")||n(\"Expected optionConfig.\"+i+\" to either have required or default value.\"),o(r,\"description\")){var u=r.description;\"string\"!=typeof r.description&&n(\"Expected optionConfig.\"+i+\".description to be a string, got \"+typeof u+\" \"+u+\".\")}else n(\"Missing description on optionConfig.\"+i+\" config.\");if(o(r,\"validator\")){var p=r.validator;\"function\"!=typeof r.validator&&n(\"Expected optionConfig.\"+i+\".validator to be a function, got \"+typeof p+\" \"+p+\".\")}else n(\"Missing validator on optionConfig.\"+i+\" config.\")}return e(t)},description:\"an object with declarative option configuration\"},userOptions:{required:!1,default:{},validator:e,description:\"an object\"},prefix:{required:!1,default:\"\",validator:function(o){return\"string\"==typeof o},description:\"a string\"},suffix:{required:!1,default:\"\",validator:function(o){return\"string\"==typeof o},description:\"a string\"},strict:{required:!1,default:!0,validator:function(o){return\"boolean\"==typeof o},description:\"a boolean\"}};module.exports=function(o){var e=t({optionConfig:a,userOptions:o,prefix:i,suffix:r});return t(e)};\n//# sourceMappingURL=merge-options.min.js.map\n","\"use strict\";function t(t){var e=function(t){if(\"object\"!=typeof t||!t)return t;var e=t[Symbol.toPrimitive];if(void 0!==e){var i=e.call(t,\"string\");if(\"object\"!=typeof i)return i;throw new TypeError(\"@@toPrimitive must return a primitive value.\")}return String(t)}(t);return\"symbol\"==typeof e?e:e+\"\"}module.exports=/*#__PURE__*/function(){function Observable(t){this.callbacks=[],this.internal=t,this.initialValue=t}var e,i,r=Observable.prototype;return r.subscribe=function(t){var e=this;if(\"function\"!=typeof t)throw new TypeError(\"[createObservable]: expected callback to be a function.\");return this.callbacks.push(t),function(){var i=e.callbacks.indexOf(t);e.callbacks=e.callbacks.slice(0,i).concat(e.callbacks.slice(i+1))}},r.reset=function(){this.callbacks=[],this.internal=this.initialValue},e=Observable,(i=[{key:\"value\",get:function(){return this.internal},set:function(t){if(t!==this.internal){var e=this.internal;this.internal=t;for(var i=0;i<this.callbacks.length;i++)this.callbacks[i](this.internal,e)}}}])&&function(e,i){for(var r=0;r<i.length;r++){var n=i[r];n.enumerable=n.enumerable||!1,n.configurable=!0,\"value\"in n&&(n.writable=!0),Object.defineProperty(e,t(n.key),n)}}(e.prototype,i),Object.defineProperty(e,\"prototype\",{writable:!1}),e}();\n//# sourceMappingURL=observable.min.js.map\n","// The module cache\nconst __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tconst cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tconst module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tconst getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter/value functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tif(Array.isArray(definition)) {\n\t\tvar i = 0;\n\t\twhile(i < definition.length) {\n\t\t\tvar key = definition[i++];\n\t\t\tvar binding = definition[i++];\n\t\t\tif(!__webpack_require__.o(exports, key)) {\n\t\t\t\tif(binding === 0) {\n\t\t\t\t\tObject.defineProperty(exports, key, { enumerable: true, value: definition[i++] });\n\t\t\t\t} else {\n\t\t\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: binding });\n\t\t\t\t}\n\t\t\t} else if(binding === 0) { i++; }\n\t\t}\n\t} else {\n\t\tfor(var key in definition) {\n\t\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t\t}\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","/** @public All available immerser event names. */\nexport const EventNames = {\n  init: 'init',\n  mount: 'mount',\n  unmount: 'unmount',\n  destroy: 'destroy',\n  structureChange: 'structureChange',\n  layoutChange: 'layoutChange',\n  activeLayerChange: 'activeLayerChange',\n  layerProgressChange: 'layerProgressChange',\n  stateChange: 'stateChange',\n} as const;\n\n/** @public All available immerser event names as an iterable array. */\nexport const EventNameArray = Object.values(EventNames);\n","/** @public Style used for masks and mask inners, exposed to use with external rendered */\nexport const CroppedFullAbsoluteStyles: Record<string, string> = {\n  position: 'absolute',\n  top: '0',\n  right: '0',\n  bottom: '0',\n  left: '0',\n  overflow: 'hidden',\n};\n\n/** @public Style for immerser root, to make in click transparent, exposed to use with external rendered */\nexport const NotInteractiveStyles: Record<string, string> = {\n  pointerEvents: 'none',\n  touchAction: 'none',\n};\n\n/** @public Style for immerser solids, to make them clickable again inside not clickable immerser root, exposed to use with external rendered */\nexport const InteractiveStyles: Record<string, string> = {\n  pointerEvents: 'all',\n  touchAction: 'auto',\n};\n","export const ImmerserSelectors = {\n  root: '[data-immerser]',\n  layer: '[data-immerser-layer]',\n  solid: '[data-immerser-solid]',\n  pagerLink: '[data-immerser-pager-link]',\n  mask: '[data-immerser-mask]',\n  maskInner: '[data-immerser-mask-inner]',\n  synchroHover: '[data-immerser-synchro-hover]',\n};\n","import type { OptionConfig as MergeOptionConfig } from '@dubaua/merge-options';\nimport { EventNameArray } from './events';\nimport type { EventName, Options } from './types';\n\nconst ClassnameRegex = /^[a-z_-][a-z\\d_-]*$/i;\n\n/** @public Option lifecycle mode used by runtime filtering and documentation generators. */\nexport type OptionUpdateMode = 'hot' | 'init';\n\nfunction classnameValidator(str: string): boolean {\n  return typeof str === 'string' && str !== '' && ClassnameRegex.test(str);\n}\n\nfunction onOptionValidator(on?: Options['on']): boolean {\n  if (on === undefined) {\n    return true;\n  }\n  if (!on || typeof on !== 'object' || Array.isArray(on)) {\n    return false;\n  }\n  return Object.keys(on).every(\n    (eventName) =>\n      EventNameArray.includes(eventName as EventName) &&\n      (on as Record<string, unknown>)[eventName] !== undefined &&\n      typeof (on as Record<string, unknown>)[eventName] === 'function',\n  );\n}\n\n/** @public Runtime option config used by merge-options and wrapper documentation generators. */\nexport const OptionConfig: MergeOptionConfig<Options> = {\n  autoMount: {\n    default: true,\n    description: 'a boolean',\n    validator: (x) => typeof x === 'boolean',\n  },\n  selectorRoot: {\n    // actually defaults to document in browser env, here `undefined` because this file also used in build pipeline\n    default: undefined,\n    description: 'a parent node used for selector discovery',\n    validator: (x) => x === undefined || (x && typeof (x as ParentNode).querySelectorAll === 'function'),\n  },\n  solidClassnamesByLayerId: {\n    default: {},\n    description: 'object mapping layer ids to solid classname maps',\n    validator: (x) => x !== null && typeof x === 'object' && !Array.isArray(x),\n  },\n  fromViewportWidth: {\n    default: 0,\n    description: 'a natural number',\n    validator: (x) => typeof x === 'number' && 0 <= x && x % 1 === 0,\n  },\n  pagerThreshold: {\n    default: 0.5,\n    description: 'a number between 0 and 1',\n    validator: (x) => typeof x === 'number' && 0 <= x && x <= 1,\n  },\n  updateLocationHash: {\n    default: undefined,\n    description: 'a function or undefined',\n    validator: (x) => x === undefined || typeof x === 'function',\n  },\n  scrollAdjustThreshold: {\n    default: 0,\n    description: 'a number greater than or equal to 0',\n    validator: (x) => typeof x === 'number' && x >= 0,\n  },\n  scrollAdjustDelay: {\n    default: 600,\n    description: 'a number greater than or equal to 300',\n    validator: (x) => typeof x === 'number' && x >= 300,\n  },\n  pagerLinkActiveClassname: {\n    default: 'pager-link-active',\n    description: 'valid non empty classname string',\n    validator: classnameValidator,\n  },\n  hasExternalScroll: {\n    default: false,\n    description: 'a boolean',\n    validator: (x) => typeof x === 'boolean',\n  },\n  hasExternalRenderer: {\n    default: false,\n    description: 'a boolean',\n    validator: (x) => typeof x === 'boolean',\n  },\n  debug: {\n    default: false,\n    description: 'a boolean',\n    validator: (x) => typeof x === 'boolean',\n  },\n  on: {\n    default: {},\n    description: 'an object containing event handlers',\n    validator: onOptionValidator,\n  },\n};\n\n/** @public Option update mode used by runtime filtering and documentation generators. */\nexport const OptionUpdateModeByName: Record<keyof Options, OptionUpdateMode> = {\n  autoMount: 'init',\n  selectorRoot: 'init',\n  solidClassnamesByLayerId: 'init',\n  fromViewportWidth: 'hot',\n  pagerThreshold: 'hot',\n  updateLocationHash: 'hot',\n  scrollAdjustThreshold: 'hot',\n  scrollAdjustDelay: 'hot',\n  pagerLinkActiveClassname: 'init',\n  hasExternalScroll: 'init',\n  hasExternalRenderer: 'init',\n  debug: 'hot',\n  on: 'init',\n};\n","function limit(number: number, min: number, max: number): number {\n  return Math.max(Math.min(number, max), min);\n}\n\nexport default function getLastScrollPosition(): { x: number; y: number } {\n  const scrollX = window.scrollX || document.documentElement.scrollLeft;\n  const scrollY = window.scrollY || document.documentElement.scrollTop;\n  // limit scroll position between 0 and document height in case of iOS overflow scroll\n  return {\n    x: limit(scrollX, 0, document.documentElement.offsetWidth),\n    y: limit(scrollY, 0, document.documentElement.offsetHeight),\n  };\n}\n","export default function queryElementArray<T extends Element = HTMLElement>({\n  selector,\n  parent = document,\n}: {\n  selector: string;\n  parent?: ParentNode | null;\n}): T[] {\n  if (!parent) {\n    return [];\n  }\n  const nodeList = parent.querySelectorAll<T>(selector);\n  return Array.from(nodeList);\n}\n","import mergeOptions from '@dubaua/merge-options';\nimport Observable from '@dubaua/observable';\nimport calculateLayerStateArray from './utils/calculate-layer-state-array';\nimport calculateLayersRuntimeState from './utils/calculate-layers-runtime-state';\nimport calculateScrollTarget from './utils/calculate-scroll-target';\nimport { EventNameArray, EventNames } from './events';\nimport { CroppedFullAbsoluteStyles, InteractiveStyles, NotInteractiveStyles } from './styles';\nimport { ImmerserSelectors } from './selectors';\nimport { OptionConfig, OptionUpdateMode, OptionUpdateModeByName } from './options';\nimport { getOriginalHandler, wrapOnceHandler } from './utils/once-handler';\nimport assignInlineStyles from './utils/assign-inline-styles';\nimport getLastScrollPosition from './utils/get-last-scroll-position';\nimport queryElementArray from './utils/query-element-array';\nimport validateImmerserMarkup from './utils/validate-immerser-markup';\nimport type {\n  ICalculationResult,\n  IClonedSolid,\n  IImmerserLayerState,\n  IMaskMarkup,\n  IReportParams,\n} from './internal-types';\nimport type {\n  ActiveLayerChangeHandler,\n  BaseHandler,\n  EventHandlers,\n  EventName,\n  HandlerArgs,\n  HandlerByEventName,\n  LayerProgressChangeHandler,\n  Options,\n  RuntimeOptions,\n  SolidClassnames,\n  SolidClassnamesByLayerId,\n  UpdateLocationHashHandler,\n} from './types';\n\nconst MessagePrefix = '[immerser]:';\nconst RuntimeOptionNames = Object.keys(OptionUpdateModeByName).filter(\n  (optionName) => OptionUpdateModeByName[optionName] === 'hot',\n) as (keyof RuntimeOptions)[];\n\n/** @public Main Immerser controller orchestrating markup preparation and scroll-driven transitions. */\nexport default class Immerser {\n  private _options!: Options;\n  private _selectors = ImmerserSelectors;\n  private _userOptions: Partial<Options> = {};\n  private _layerStateArray: IImmerserLayerState[] = [];\n  private _isMounted = false;\n  private _rootNode: HTMLElement | null = null;\n  private _selectorRoot: ParentNode = document;\n  private _layerNodeArray: HTMLElement[] = [];\n  private _maskNodeArray: HTMLElement[] = [];\n  private _pagerLinkNodeArray: HTMLElement[] = [];\n  private _originalSolidNodeArray: HTMLElement[] = [];\n  private _clonedSolidArray: IClonedSolid[] = [];\n  private _preparedMaskMarkupArray: IMaskMarkup[] = [];\n  private _solidNodeArray: HTMLElement[] = [];\n  private _synchroHoverNodeArray: HTMLElement[] = [];\n  private _activeIndex = -1;\n  private _rootHeight = 0;\n  private _viewportHeight = 0;\n  private _resizeObserver: ResizeObserver | null = null;\n  private _flushFrameId: number | null = null;\n  private _scrollAdjustTimerId: ReturnType<typeof setTimeout> | null = null;\n  private _reactiveSynchroHoverId = new Observable<string | null>(null);\n  private _unsubscribeSynchroHover: (() => void) | null = null;\n  private _handlers: Record<EventName, Set<HandlerByEventName[EventName]>> = {\n    [EventNames.init]: new Set(),\n    [EventNames.mount]: new Set(),\n    [EventNames.unmount]: new Set(),\n    [EventNames.destroy]: new Set(),\n    [EventNames.structureChange]: new Set(),\n    [EventNames.layoutChange]: new Set(),\n    [EventNames.layerProgressChange]: new Set(),\n    [EventNames.activeLayerChange]: new Set(),\n    [EventNames.stateChange]: new Set(),\n  };\n  private _onResize: (() => void) | null = null;\n  private _onScroll: (() => void) | null = null;\n  private _onSynchroHoverMouseOver: ((e: MouseEvent) => void) | null = null;\n  private _onSynchroHoverMouseOut: (() => void) | null = null;\n  private _isLayoutSet = false;\n  private _layerProgressArray: number[] = [];\n  private _structureSignature = '';\n  private _layoutSignature = '';\n  private _drawSignature = '';\n  private _pendingSync = {\n    structure: false,\n    layout: false,\n    draw: false,\n  };\n\n  /** Enables warning reporting */\n  public debug = false;\n\n  /**\n   * Creates immerser instance and runs DOM setup unless autoMount is disabled.\n   * @param userOptions - overrides for defaults defined in OptionConfig when they pass validation\n   */\n  constructor(userOptions?: Partial<Options>) {\n    this._init(userOptions);\n  }\n\n  /** Keeps construction reusable for future full-state reinitialization paths. */\n  private _init(userOptions?: Partial<Options>): void {\n    this._userOptions = userOptions ?? {};\n    const options = this._mergeOptions(this._userOptions);\n    this._options = options;\n    this._selectorRoot = options.selectorRoot ?? document;\n    this.debug = options.debug;\n    this._registerHandlersFromOptions();\n    this._addResizeListener();\n\n    if (options.autoMount) {\n      this.mount();\n    }\n\n    this._emit(EventNames.init, this);\n  }\n\n  /** Saves event handlers passed via options into internal registry. */\n  private _registerHandlersFromOptions(): void {\n    if (!this._options.on) {\n      return;\n    }\n    EventNameArray.forEach((eventName) => {\n      const handler = this._options.on[eventName];\n      if (typeof handler === 'function') {\n        this.on(eventName, handler);\n      }\n    });\n  }\n\n  /** Executes registered event handlers with provided arguments. */\n  private _emit<K extends EventName>(eventName: K, ...args: HandlerArgs<K>): void {\n    const handlerSet = this._handlers[eventName];\n    handlerSet.forEach((handler: HandlerByEventName[K]) => {\n      try {\n        handler.apply(undefined, args);\n      } catch (error) {\n        this._report({\n          message: `handler for ${eventName} event failed`,\n          error,\n          docsHash: '#events',\n        });\n      }\n    });\n\n    if (eventName !== EventNames.stateChange) {\n      this._emit(EventNames.stateChange, this);\n    }\n  }\n\n  /** Centralizes diagnostics so validation failures and warnings point users to the relevant docs section. */\n  private _report({ message, error, isWarning = false, docsHash = '' }: IReportParams): void {\n    const resultMessage = `${MessagePrefix} ${message} \\nCheck out documentation https://github.com/dubaua/immerser${docsHash}`;\n\n    if (isWarning) {\n      if (!this.debug) {\n        return;\n      }\n\n      error !== undefined ? console.warn(resultMessage, error) : console.warn(resultMessage);\n\n      return;\n    }\n\n    throw new Error(resultMessage, { cause: error });\n  }\n\n  /** Discovers root, layers and existing masks, then rebuilds layer state references. */\n  private _syncStructure(): void {\n    this._rootNode = this._selectorRoot.querySelector<HTMLElement>(this._selectors.root);\n    this._layerNodeArray = queryElementArray({ selector: this._selectors.layer, parent: this._selectorRoot });\n    this._maskNodeArray = queryElementArray({ selector: this._selectors.mask, parent: this._rootNode });\n\n    this._validateMarkup();\n\n    const previousLayerStateById = new Map(this._layerStateArray.map((layerState) => [layerState.id, layerState]));\n\n    this._layerStateArray = this._layerNodeArray.map((layerNode, order) => {\n      const previousLayerState = previousLayerStateById.get(layerNode.id);\n\n      return {\n        calculation: previousLayerState?.calculation ?? null,\n        id: layerNode.id,\n        layerNode,\n        maskInnerNode: previousLayerState?.maskInnerNode ?? null,\n        maskNode: previousLayerState?.maskNode ?? null,\n        order,\n        solidClassnames: this._options.solidClassnamesByLayerId[layerNode.id] ?? null,\n      };\n    });\n\n    this._structureSignature = this._createLayerSignature(this._layerNodeArray, this._maskNodeArray);\n    this._emit(EventNames.structureChange, this);\n  }\n\n  /** Validates required markup and option references. */\n  private _validateMarkup(): void {\n    const messageArray = validateImmerserMarkup({\n      layerNodeArray: this._layerNodeArray,\n      maskInnerSelector: this._selectors.maskInner,\n      maskNodeArray: this._maskNodeArray,\n      rootNode: this._rootNode,\n      solidClassnamesByLayerId: this._options.solidClassnamesByLayerId,\n    });\n\n    if (messageArray.length > 0) {\n      messageArray.forEach((message) => {\n        this._report({\n          message,\n          docsHash: '#prepare-your-markup',\n        });\n      });\n    }\n  }\n\n  /** Merges user options with defaults and attaches helper metadata to messages. */\n  private _mergeOptions(userOptions?: Partial<Options>): Options {\n    return mergeOptions({\n      optionConfig: OptionConfig,\n      userOptions,\n      prefix: MessagePrefix,\n      suffix: '\\nCheck out documentation https://github.com/dubaua/immerser#options',\n      strict: false,\n    });\n  }\n\n  /** Creates a cheap identity snapshot for detecting layer-list changes without comparing DOM nodes. */\n  private _createLayerSignature(layerNodeArray: HTMLElement[], maskNodeArray: HTMLElement[]): string {\n    return layerNodeArray\n      .map((layerNode) => {\n        const maskNode = maskNodeArray.find((node) => node.dataset.immerserLayerId === layerNode.id);\n        const maskInnerNodeArray = queryElementArray({ selector: this._selectors.maskInner, parent: maskNode });\n        let maskState = 0;\n        maskState += maskNode ? 1 : 0;\n        maskState += maskInnerNodeArray.length > 0 ? 1 : 0;\n        return `${layerNode.id}:${maskState}`;\n      })\n      .join('|');\n  }\n\n  /** Reads the current DOM layer identity so dynamic markup can be compared with mounted state. */\n  private _getLayerSignature(): string {\n    const layerNodeArray = queryElementArray({ selector: this._selectors.layer, parent: this._selectorRoot });\n    const maskNodeArray = queryElementArray({ selector: this._selectors.mask, parent: this._rootNode });\n    return this._createLayerSignature(layerNodeArray, maskNodeArray);\n  }\n\n  /** Applies the configured breakpoint before expensive markup work starts. */\n  private _shouldMount(): boolean {\n    return window.innerWidth >= this._options.fromViewportWidth;\n  }\n\n  /** Recalculates sizes and thresholds for each layer. */\n  private _syncLayoutSizes(): void {\n    const rootNode = this._rootNode as HTMLElement;\n    const layers = this._layerStateArray.map(({ layerNode }) => ({\n      bottom: layerNode.offsetTop + layerNode.offsetHeight,\n      top: layerNode.offsetTop,\n    }));\n    this._isLayoutSet = true;\n    this._rootHeight = rootNode.offsetHeight;\n    this._viewportHeight = window.innerHeight;\n    const layerCalculationArray = calculateLayerStateArray({\n      layers,\n      rootHeight: this._rootHeight,\n      rootTop: rootNode.offsetTop,\n    });\n    this._layerStateArray = this._layerStateArray.map((layerState, layerIndex) => ({\n      ...layerState,\n      calculation: layerCalculationArray[layerIndex],\n    }));\n    if (this._layerProgressArray.length === 0) {\n      this._layerProgressArray = layers.map(() => 0);\n    }\n\n    this._layoutSignature = this._createLayoutSignature();\n    // Same progress can produce different pixel transforms after layout changes.\n    this._drawSignature = '';\n\n    this._emit(EventNames.layoutChange, this);\n  }\n\n  /** Creates a layout snapshot for skipping redraws that would produce the same geometry. */\n  private _createLayoutSignature(): string {\n    const rootNode = this._rootNode as HTMLElement;\n\n    return [\n      window.innerHeight,\n      rootNode.offsetHeight,\n      ...this._layerStateArray.map(({ layerNode }) => layerNode.offsetHeight),\n    ].join('|');\n  }\n\n  /** Keeps breakpoint remounting available even when the runtime is currently unmounted. */\n  private _addResizeListener(): void {\n    if (!this._onResize) {\n      this._onResize = this._handleResize.bind(this);\n      window.addEventListener('resize', this._onResize, false);\n      window.addEventListener('orientationchange', this._onResize, false);\n    }\n  }\n\n  /** Attaches runtime listeners respecting hasExternalScroll flag. */\n  private _addMountedListeners(): void {\n    if (!this._options.hasExternalScroll && !this._onScroll) {\n      this._onScroll = this._handleScroll.bind(this);\n      window.addEventListener('scroll', this._onScroll, false);\n    }\n    if (typeof ResizeObserver !== 'undefined') {\n      this._resizeObserver = new ResizeObserver(this._onResize);\n      this._resizeObserver.observe(this._rootNode);\n    }\n  }\n\n  /** Clears internal caches, observables and references after destroy. */\n  private _resetInternalState(): void {\n    this._layerStateArray = [];\n    this._isMounted = false;\n    this._rootNode = null;\n    this._selectorRoot = document;\n    this._layerNodeArray = [];\n    this._maskNodeArray = [];\n    this._pagerLinkNodeArray = [];\n    this._synchroHoverNodeArray = [];\n    this._resizeObserver = null;\n    this._flushFrameId = null;\n    this._scrollAdjustTimerId = null;\n    this._reactiveSynchroHoverId.reset();\n    this._unsubscribeSynchroHover = null;\n    this._onResize = null;\n    this._onScroll = null;\n    this._onSynchroHoverMouseOver = null;\n    this._onSynchroHoverMouseOut = null;\n    this._originalSolidNodeArray = [];\n    this._clonedSolidArray = [];\n    this._preparedMaskMarkupArray = [];\n    this._solidNodeArray = [];\n    this._structureSignature = '';\n    this._layoutSignature = '';\n    this._drawSignature = '';\n    this._pendingSync.structure = false;\n    this._pendingSync.layout = false;\n    this._pendingSync.draw = false;\n    this._resetMountedState();\n  }\n\n  /** Connects external mask markup or prepares controller-owned markup. */\n  private _prepareMarkup(): void {\n    if (this._options.hasExternalRenderer) {\n      this._connectExistingMaskMarkup();\n      return;\n    }\n    if (this._preparedMaskMarkupArray.length > 0) {\n      this._cleanupMarkup();\n    }\n\n    const layerStateArray = this._layerStateArray;\n    const maskMarkupArray = this._resolveMaskMarkup(layerStateArray);\n    const nextLayerStateArray = this._connectLayerStates(layerStateArray, maskMarkupArray);\n    const originalSolidNodeArray = this._findSourceSolids(maskMarkupArray);\n    const clonedSolidArray = this._cloneSolids(nextLayerStateArray, originalSolidNodeArray);\n    const solidNodeArray = this._collectSolidNodes(maskMarkupArray, clonedSolidArray);\n\n    this._reportEmptyMarkup(originalSolidNodeArray, maskMarkupArray);\n    this._applyTechnicalStyles(maskMarkupArray, solidNodeArray);\n    this._commitNodes(maskMarkupArray, clonedSolidArray);\n    this._applyCreatedMasksAria(maskMarkupArray);\n    this._savePreparedMarkupState(maskMarkupArray, clonedSolidArray, originalSolidNodeArray, solidNodeArray);\n    this._detachOriginalSolids(originalSolidNodeArray);\n  }\n\n  /** Restores markup according to controller-recorded ownership. */\n  private _cleanupMarkup(): void {\n    if (this._options.hasExternalRenderer) {\n      return;\n    }\n    this._removeClonedSolids();\n    this._restoreOriginalSolids();\n    this._clearTechnicalStyles();\n    this._removeCreatedMasks();\n    this._resetMarkupState();\n    this._layerStateArray = this._layerStateArray.map((layerState) => ({\n      ...layerState,\n      maskInnerNode: null,\n      maskNode: null,\n    }));\n  }\n\n  /** Collects pager links that will receive runtime active state. */\n  private _initPagerLinks(): void {\n    if (this._options.hasExternalRenderer) {\n      return;\n    }\n    this._pagerLinkNodeArray = queryElementArray({ selector: this._selectors.pagerLink, parent: this._rootNode });\n  }\n\n  /** Sets up hover synchronization listeners and reactive updates. */\n  private _initHoverSynchronization(): void {\n    if (this._options.hasExternalRenderer) {\n      return;\n    }\n    this._synchroHoverNodeArray = queryElementArray({ selector: this._selectors.synchroHover, parent: this._rootNode });\n\n    this._onSynchroHoverMouseOver = (e: MouseEvent): void => {\n      const target = e.currentTarget as HTMLElement;\n      const synchroHoverId = target.dataset.immerserSynchroHover;\n      this._reactiveSynchroHoverId.value = synchroHoverId;\n    };\n\n    this._onSynchroHoverMouseOut = (): void => {\n      this._reactiveSynchroHoverId.value = null;\n    };\n\n    this._synchroHoverNodeArray.forEach((synchroHoverNode) => {\n      synchroHoverNode.addEventListener('mouseover', this._onSynchroHoverMouseOver!);\n      synchroHoverNode.addEventListener('mouseout', this._onSynchroHoverMouseOut!);\n    });\n    if (this._synchroHoverNodeArray.length > 0) {\n      this._unsubscribeSynchroHover = this._reactiveSynchroHoverId.subscribe(this._drawHoverSynchronization.bind(this));\n    }\n  }\n\n  /** Removes hover synchronization listeners and reactive updates. */\n  private _destroyHoverSynchronization(): void {\n    this._unsubscribeSynchroHover?.();\n    this._synchroHoverNodeArray.forEach((synchroHoverNode) => {\n      synchroHoverNode.removeEventListener('mouseover', this._onSynchroHoverMouseOver!);\n      synchroHoverNode.removeEventListener('mouseout', this._onSynchroHoverMouseOut!);\n    });\n  }\n\n  /** Clears runtime active state from pager links. */\n  private _clearPagerLinks(): void {\n    this._pagerLinkNodeArray.forEach((node) => {\n      node.classList.remove(this._options.pagerLinkActiveClassname);\n    });\n  }\n\n  /** Removes the global resize hooks when the instance is permanently destroyed. */\n  private _removeResizeListener(): void {\n    if (this._onResize) {\n      window.removeEventListener('resize', this._onResize, false);\n      window.removeEventListener('orientationchange', this._onResize, false);\n      this._onResize = null;\n    }\n  }\n\n  /** Removes runtime listeners while keeping breakpoint resize handling alive. */\n  private _removeMountedListeners(): void {\n    if (!this._options.hasExternalScroll && this._onScroll) {\n      window.removeEventListener('scroll', this._onScroll, false);\n      this._onScroll = null;\n    }\n    this._resizeObserver?.disconnect();\n    this._resizeObserver = null;\n  }\n\n  /** Prevents stale synchronization work from running after newer DOM or lifecycle changes. */\n  private _cancelFlushFrame(): void {\n    if (this._flushFrameId !== null) {\n      window.cancelAnimationFrame(this._flushFrameId);\n      this._flushFrameId = null;\n    }\n  }\n\n  /** Clears the pending scroll-adjust timer. */\n  private _clearScrollAdjustTimer(): void {\n    if (this._scrollAdjustTimerId !== null) {\n      clearTimeout(this._scrollAdjustTimerId);\n      this._scrollAdjustTimerId = null;\n    }\n  }\n\n  /** Cancels deferred runtime work before mounted markup is cleaned. */\n  private _cancelScheduledRuntimeWork(): void {\n    this._cancelFlushFrame();\n    this._clearScrollAdjustTimer();\n    this._pendingSync.structure = false;\n    this._pendingSync.layout = false;\n    this._pendingSync.draw = false;\n  }\n\n  /** Escalates DOM mutations into the full sync pipeline only when layer identity changed. */\n  private _invalidateStructure(): void {\n    if (!this.isMounted || this._pendingSync.structure) {\n      return;\n    }\n\n    const nextLayerSignature = this._getLayerSignature();\n\n    if (nextLayerSignature === this._structureSignature) {\n      this._invalidateLayout();\n      return;\n    }\n\n    this._pendingSync.structure = true;\n    this._pendingSync.layout = true;\n    this._pendingSync.draw = true;\n    this._scheduleFlush();\n  }\n\n  /** Escalates resize/content changes into layout work only when geometry changed. */\n  private _invalidateLayout(): void {\n    if (!this.isMounted || this._pendingSync.layout) {\n      return;\n    }\n\n    const nextLayoutSignature = this._createLayoutSignature();\n\n    if (nextLayoutSignature === this._layoutSignature) {\n      this._invalidateDraw();\n      return;\n    }\n\n    this._pendingSync.layout = true;\n    this._pendingSync.draw = true;\n    this._scheduleFlush();\n  }\n\n  /** Queues visual updates without forcing structure or layout recalculation. */\n  private _invalidateDraw(): void {\n    if (!this.isMounted) {\n      return;\n    }\n\n    this._pendingSync.draw = true;\n    this._scheduleFlush();\n  }\n\n  /** Batches pending synchronization into one animation frame for a coherent DOM update. */\n  private _scheduleFlush(): void {\n    if (this._flushFrameId !== null) {\n      return;\n    }\n\n    this._flushFrameId = window.requestAnimationFrame(() => {\n      this._flushFrameId = null;\n      this._flush();\n    });\n  }\n\n  /** Runs queued synchronization in dependency order so draw always uses current structure and layout. */\n  private _flush(): void {\n    if (!this.isMounted) {\n      return;\n    }\n\n    if (this._pendingSync.structure) {\n      this._pendingSync.structure = false;\n      this._syncMountedStructure();\n    }\n\n    if (this._pendingSync.layout) {\n      this._pendingSync.layout = false;\n      this._syncLayoutSizes();\n    }\n\n    if (this._pendingSync.draw) {\n      this._pendingSync.draw = false;\n      this._drawCurrentState();\n    }\n  }\n\n  /** Rebuilds controller-owned mounted state after a layer-list change without recreating the instance. */\n  private _syncMountedStructure(): void {\n    this._destroyHoverSynchronization();\n    this._clearPagerLinks();\n    this._cleanupMarkup();\n    this._resetMountedState();\n    this._syncStructure();\n    this._prepareMarkup();\n    this._initPagerLinks();\n    this._initHoverSynchronization();\n  }\n\n  /** Keeps runtime rendering idempotent so unchanged scroll state does not emit duplicate events. */\n  private _drawCurrentState(): void {\n    if (!this._isLayoutSet) {\n      return;\n    }\n\n    const calculation = this._calculate(getLastScrollPosition().y);\n    const nextDrawSignature = this._createDrawSignature(calculation);\n\n    if (nextDrawSignature === this._drawSignature) {\n      return;\n    }\n\n    this._drawSignature = nextDrawSignature;\n    this._draw(calculation);\n    this._emit(EventNames.layerProgressChange, [...calculation.layerProgressArray], this);\n  }\n\n  /** Stores the latest calculated scroll state as the source for public getters and later transitions. */\n  private _calculate(scrollY: number): ICalculationResult {\n    if (!this._isLayoutSet) {\n      throw new Error('Immerser layout is not set.');\n    }\n\n    const calculation = calculateLayersRuntimeState({\n      layerCalculationArray: this._layerStateArray.map(({ calculation }) => calculation),\n      pagerThreshold: this._options.pagerThreshold,\n      previousActiveIndex: this._activeIndex,\n      rootHeight: this._rootHeight,\n      scrollY,\n      viewportHeight: this._viewportHeight,\n    });\n\n    this._activeIndex = calculation.activeIndex;\n    this._layerProgressArray = [...calculation.layerProgressArray];\n\n    return calculation;\n  }\n\n  /** Creates a stable render identity so equivalent transition results can be skipped. */\n  private _createDrawSignature({ activeIndex, layerProgressArray }: ICalculationResult): string {\n    return `${activeIndex}:${layerProgressArray.join('|')}`;\n  }\n\n  /** Applies transforms based on scroll position and updates active layer state. */\n  private _draw({ activeIndex, previousActiveIndex, transforms }: ICalculationResult): void {\n    this._layerStateArray.forEach(({ maskNode, maskInnerNode }, layerIndex) => {\n      if (!maskNode || !maskInnerNode) {\n        return;\n      }\n      const translateY = transforms[layerIndex];\n      maskNode.style.transform = `translateY(${translateY}px)`;\n      maskInnerNode.style.transform = `translateY(${-translateY}px)`;\n    });\n\n    if (!this._isMounted || activeIndex === previousActiveIndex) {\n      return;\n    }\n    this._drawPagerLinks(activeIndex);\n    this._drawHash(activeIndex);\n    this._emit(EventNames.activeLayerChange, activeIndex, this);\n  }\n\n  /** Adds or removes active pager classname according to current layer. */\n  private _drawPagerLinks(layerIndex?: number): void {\n    if (this._options.hasExternalRenderer) {\n      return;\n    }\n    const layerId = layerIndex === undefined ? undefined : this._layerStateArray[layerIndex]?.id;\n    this._pagerLinkNodeArray.forEach((pagerLinkNode) => {\n      const href = (pagerLinkNode as HTMLAnchorElement).getAttribute('href');\n\n      pagerLinkNode.classList.toggle(\n        this._options.pagerLinkActiveClassname,\n        Boolean(layerId && href?.endsWith(`#${layerId}`)),\n      );\n    });\n  }\n\n  /** Passes active layer id to configured hash update handler. */\n  private _drawHash(layerIndex: number): void {\n    if (!this._options.updateLocationHash) {\n      return;\n    }\n    const layerState = this._layerStateArray[layerIndex];\n    if (!layerState) {\n      return;\n    }\n    const { id, layerNode } = layerState;\n    layerNode.removeAttribute('id');\n    try {\n      this._options.updateLocationHash(id);\n    } finally {\n      layerNode.setAttribute('id', id);\n    }\n  }\n\n  /** Syncs hover state across elements with matching synchro hover id. */\n  private _drawHoverSynchronization(synchroHoverId?: string): void {\n    if (this._options.hasExternalRenderer) {\n      return;\n    }\n    this._synchroHoverNodeArray.forEach((synchroHoverNode) => {\n      if (synchroHoverNode.dataset.immerserSynchroHover === synchroHoverId) {\n        synchroHoverNode.classList.add('_hover');\n      } else {\n        synchroHoverNode.classList.remove('_hover');\n      }\n    });\n  }\n\n  /** Adjusts scroll to layer edges when near thresholds, improving alignment. */\n  private _adjustScroll(): void {\n    const { x, y } = getLastScrollPosition();\n    const scrollTarget = this._calculateScrollTarget(y, this._options.scrollAdjustThreshold);\n    if (scrollTarget !== null) {\n      window.scrollTo(x, scrollTarget);\n    }\n  }\n\n  /** Delegates snap-target calculation only when there is an active layer to align against. */\n  private _calculateScrollTarget(scrollY: number, scrollAdjustThreshold: number): number | null {\n    if (!this._isLayoutSet) {\n      throw new Error('Immerser layout is not set.');\n    }\n\n    const activeLayer = this._layerStateArray[this._activeIndex]?.calculation;\n    if (!activeLayer) {\n      return null;\n    }\n\n    return calculateScrollTarget({\n      activeLayer,\n      scrollAdjustThreshold,\n      scrollY,\n      viewportHeight: this._viewportHeight,\n    });\n  }\n\n  /** Invalidates draw on scroll and optionally schedules scroll snapping. */\n  private _handleScroll(): void {\n    if (!this._isMounted) {\n      return;\n    }\n\n    this._invalidateDraw();\n\n    if (this._options.scrollAdjustThreshold > 0) {\n      this._clearScrollAdjustTimer();\n      this._scrollAdjustTimerId = setTimeout(this._adjustScroll.bind(this), this._options.scrollAdjustDelay);\n    }\n  }\n\n  /** Invalidates layout on resize-like changes and toggles mount state by breakpoint. */\n  private _handleResize(): void {\n    if (!this._shouldMount()) {\n      this.unmount();\n      return;\n    }\n    if (!this._isMounted) {\n      this.mount();\n      return;\n    }\n    this._invalidateLayout();\n  }\n\n  /** Keeps updateOptions scoped to runtime fields even when called from plain JavaScript. */\n  private _pickRuntimeOptions(userOptions: Partial<Options>): Partial<RuntimeOptions> {\n    return RuntimeOptionNames.reduce<Partial<RuntimeOptions>>((result, optionName) => {\n      if (optionName in userOptions) {\n        result[optionName] = userOptions[optionName] as never;\n      }\n      return result;\n    }, {});\n  }\n\n  /** Connects already existing masks without creating or mutating markup. */\n  private _connectExistingMaskMarkup(): void {\n    if (this._maskNodeArray.length === 0) {\n      return;\n    }\n\n    const maskMarkupArray = this._layerStateArray.map(({ id }) => {\n      const maskNode = this._maskNodeArray.find((node) => node.dataset.immerserLayerId === id);\n      if (!maskNode) {\n        const message = `existing markup mask not found for layer id \"${id}\".`;\n        this._report({ message, docsHash: '#prepare-your-markup' });\n        throw new Error(message);\n      }\n      return this._connectMaskMarkup(maskNode);\n    });\n    this._connectLayerStates(this._layerStateArray, maskMarkupArray);\n  }\n\n  /** Uses complete existing masks by layer id or creates a detached mask set when none exists. */\n  private _resolveMaskMarkup(layerStateArray: IImmerserLayerState[]): IMaskMarkup[] {\n    const existingMaskNodeArray = queryElementArray({ selector: this._selectors.mask, parent: this._rootNode });\n    if (existingMaskNodeArray.length === 0) {\n      return layerStateArray.map(({ id }) => this._createMaskMarkup(id));\n    }\n    if (existingMaskNodeArray.length !== layerStateArray.length) {\n      const message = 'existing markup mask count differs from count of layers.';\n      this._report({ message, docsHash: '#prepare-your-markup' });\n      throw new Error(message);\n    }\n\n    return layerStateArray.map(({ id }) => {\n      const maskNodeArray = existingMaskNodeArray.filter((maskNode) => maskNode.dataset.immerserLayerId === id);\n      if (maskNodeArray.length > 1) {\n        const message = `existing markup has duplicate mask layer id \"${id}\".`;\n        this._report({ message, docsHash: '#prepare-your-markup' });\n        throw new Error(message);\n      }\n      const maskNode = maskNodeArray[0];\n      if (!maskNode) {\n        const message = `existing markup mask not found for layer id \"${id}\".`;\n        this._report({ message, docsHash: '#prepare-your-markup' });\n        throw new Error(message);\n      }\n      return this._connectMaskMarkup(maskNode);\n    });\n  }\n\n  /** Creates one detached mask and its required inner node. */\n  private _createMaskMarkup(layerId: string): IMaskMarkup {\n    const maskNode = document.createElement('div');\n    const maskInnerNode = document.createElement('div');\n    maskNode.dataset.immerserMask = '';\n    maskNode.dataset.immerserLayerId = layerId;\n    maskInnerNode.dataset.immerserMaskInner = '';\n    maskNode.appendChild(maskInnerNode);\n    return { createdMask: true, maskInnerNode, maskNode };\n  }\n\n  /** Connects the inner node belonging to an existing mask. */\n  private _connectMaskMarkup(maskNode: HTMLElement): IMaskMarkup {\n    const maskInnerNode = maskNode.querySelector<HTMLElement>(this._selectors.maskInner);\n    return { createdMask: false, maskInnerNode, maskNode };\n  }\n\n  /** Associates each layer state with its corresponding validated mask pair. */\n  private _connectLayerStates(\n    layerStateArray: IImmerserLayerState[],\n    maskMarkupArray: IMaskMarkup[],\n  ): IImmerserLayerState[] {\n    const nextLayerStateArray = layerStateArray.map((layerState, layerIndex) => ({\n      ...layerState,\n      maskInnerNode: maskMarkupArray[layerIndex].maskInnerNode,\n      maskNode: maskMarkupArray[layerIndex].maskNode,\n    }));\n    this._layerStateArray = nextLayerStateArray;\n    return nextLayerStateArray;\n  }\n\n  /** Finds source solids while excluding client-owned content already placed inside masks. */\n  private _findSourceSolids(maskMarkupArray: IMaskMarkup[]): HTMLElement[] {\n    return queryElementArray({ selector: this._selectors.solid, parent: this._rootNode }).filter(\n      (solidNode) => !maskMarkupArray.some(({ maskNode }) => maskNode.contains(solidNode)),\n    );\n  }\n\n  /** Builds configured clones and records the inner node that will receive each clone. */\n  private _cloneSolids(layerStateArray: IImmerserLayerState[], originalSolidNodeArray: HTMLElement[]): IClonedSolid[] {\n    return layerStateArray.reduce<IClonedSolid[]>((result, { maskInnerNode, solidClassnames }) => {\n      originalSolidNodeArray.forEach((originalSolidNode) => {\n        const clonedSolidNode = originalSolidNode.cloneNode(true);\n        if (clonedSolidNode instanceof HTMLElement && maskInnerNode) {\n          const solidId = clonedSolidNode.dataset.immerserSolid;\n          const classname = solidId ? solidClassnames?.[solidId] : undefined;\n          if (classname) {\n            clonedSolidNode.classList.add(classname);\n          }\n          result.push({ maskInnerNode, node: clonedSolidNode });\n        }\n      });\n      return result;\n    }, []);\n  }\n\n  /** Collects existing and cloned solids that require interactive technical styles. */\n  private _collectSolidNodes(maskMarkupArray: IMaskMarkup[], clonedSolidArray: IClonedSolid[]): HTMLElement[] {\n    const existingSolidNodeArray = maskMarkupArray.flatMap(({ maskInnerNode }) =>\n      queryElementArray({ selector: this._selectors.solid, parent: maskInnerNode }),\n    );\n    return [...existingSolidNodeArray, ...clonedSolidArray.map(({ node }) => node)];\n  }\n\n  /** Warns when neither source solids nor existing mask content can produce a visual result. */\n  private _reportEmptyMarkup(originalSolidNodeArray: HTMLElement[], maskMarkupArray: IMaskMarkup[]): void {\n    if (\n      originalSolidNodeArray.length === 0 &&\n      maskMarkupArray.every(({ maskInnerNode }) => maskInnerNode.children.length === 0)\n    ) {\n      this._report({\n        message: 'immerser will do nothing without source solids or existing mask content.',\n        docsHash: '#prepare-your-markup',\n        isWarning: true,\n      });\n    }\n  }\n\n  /** Replaces inline styles on controller-managed runtime nodes with technical styles. */\n  private _applyTechnicalStyles(maskMarkupArray: IMaskMarkup[], solidNodeArray: HTMLElement[]): void {\n    this._setTechnicalStyles(this._rootNode as HTMLElement, NotInteractiveStyles);\n    maskMarkupArray.forEach(({ maskInnerNode, maskNode }) => {\n      this._setTechnicalStyles(maskNode, { ...CroppedFullAbsoluteStyles, transform: '' });\n      this._setTechnicalStyles(maskInnerNode, { ...CroppedFullAbsoluteStyles, transform: '' });\n    });\n    solidNodeArray.forEach((node) => {\n      this._setTechnicalStyles(node, InteractiveStyles);\n    });\n  }\n\n  /** Drops client inline styles before assigning the complete technical style set. */\n  private _setTechnicalStyles(node: HTMLElement, styles: Record<string, string>): void {\n    node.removeAttribute('style');\n    assignInlineStyles(node, styles);\n  }\n\n  /** Inserts staged clones and appends controller-created masks to the live root. */\n  private _commitNodes(maskMarkupArray: IMaskMarkup[], clonedSolidArray: IClonedSolid[]): void {\n    clonedSolidArray.forEach(({ maskInnerNode, node }) => {\n      maskInnerNode.appendChild(node);\n    });\n    maskMarkupArray\n      .filter(({ createdMask }) => createdMask)\n      .forEach(({ maskNode }) => (this._rootNode as HTMLElement).appendChild(maskNode));\n  }\n\n  /** Hides duplicate content only on masks created by this instance. */\n  private _applyCreatedMasksAria(maskMarkupArray: IMaskMarkup[]): void {\n    maskMarkupArray\n      .filter(({ createdMask }) => createdMask)\n      .forEach(({ maskNode }, maskIndex) => {\n        if (maskIndex !== 0) {\n          maskNode.setAttribute('aria-hidden', 'true');\n        }\n      });\n  }\n\n  /** Stores references required to clean the committed markup lifecycle. */\n  private _savePreparedMarkupState(\n    maskMarkupArray: IMaskMarkup[],\n    clonedSolidArray: IClonedSolid[],\n    originalSolidNodeArray: HTMLElement[],\n    solidNodeArray: HTMLElement[],\n  ): void {\n    this._clonedSolidArray = clonedSolidArray;\n    this._preparedMaskMarkupArray = maskMarkupArray;\n    this._originalSolidNodeArray = originalSolidNodeArray;\n    this._solidNodeArray = solidNodeArray;\n  }\n\n  /** Detaches source solids after every clone and mask has been committed successfully. */\n  private _detachOriginalSolids(originalSolidNodeArray: HTMLElement[]): void {\n    originalSolidNodeArray.forEach((solidNode) => solidNode.remove());\n  }\n\n  /** Removes every clone owned by this instance without touching existing mask content. */\n  private _removeClonedSolids(): void {\n    this._clonedSolidArray.forEach(({ node }) => node.remove());\n  }\n\n  /** Returns detached source solids to the root in their original relative order. */\n  private _restoreOriginalSolids(): void {\n    this._originalSolidNodeArray.forEach((solidNode) => (this._rootNode as HTMLElement).appendChild(solidNode));\n  }\n\n  /** Clears technical styles from the root and client-owned existing masks. */\n  private _clearTechnicalStyles(): void {\n    (this._rootNode as HTMLElement).removeAttribute('style');\n    this._preparedMaskMarkupArray.forEach(({ createdMask, maskInnerNode, maskNode }) => {\n      if (!createdMask) {\n        maskNode.removeAttribute('style');\n        maskInnerNode.removeAttribute('style');\n      }\n    });\n    this._solidNodeArray.forEach((node) => node.removeAttribute('style'));\n  }\n\n  /** Removes only masks that were created by this instance. */\n  private _removeCreatedMasks(): void {\n    this._preparedMaskMarkupArray.filter(({ createdMask }) => createdMask).forEach(({ maskNode }) => maskNode.remove());\n  }\n\n  /** Clears committed ownership references after cleanup completes. */\n  private _resetMarkupState(): void {\n    this._originalSolidNodeArray = [];\n    this._clonedSolidArray = [];\n    this._preparedMaskMarkupArray = [];\n    this._solidNodeArray = [];\n  }\n\n  /** Resets runtime-derived values so the next mount starts from an unmeasured state. */\n  private _resetMountedState(): void {\n    this._isLayoutSet = false;\n    this._rootHeight = 0;\n    this._viewportHeight = 0;\n    this._activeIndex = -1;\n    this._layerProgressArray = [];\n  }\n\n  /** Discovers DOM state, validates configuration and starts runtime when breakpoint allows it. */\n  public mount(): void {\n    if (this._isMounted || !this._shouldMount()) {\n      return;\n    }\n    this._syncStructure();\n    this._prepareMarkup();\n    this._syncLayoutSizes();\n    this._initPagerLinks();\n    this._initHoverSynchronization();\n    this._addMountedListeners();\n    this._isMounted = true;\n    this._drawCurrentState();\n    this._emit(EventNames.mount, this);\n  }\n\n  /**\n   * Stops runtime behavior while keeping resize handling active for breakpoint remount.\n   * Safe to call multiple times; no-op when already unmounted.\n   */\n  public unmount(): void {\n    if (!this._isMounted) {\n      return;\n    }\n    this._cancelScheduledRuntimeWork();\n    this._destroyHoverSynchronization();\n    this._clearPagerLinks();\n    this._removeMountedListeners();\n    this._cleanupMarkup();\n    this._isMounted = false;\n    this._emit(EventNames.unmount, this);\n    this._resetMountedState();\n  }\n\n  /** Updates runtime options and applies minimal side effects without remounting the instance. */\n  public updateOptions(userOptions: Partial<RuntimeOptions>): void {\n    const previousOptions = this._options;\n    const runtimeOptions = this._pickRuntimeOptions(userOptions as Partial<Options>);\n    this._userOptions = { ...this._userOptions, ...runtimeOptions };\n    const options = this._mergeOptions(this._userOptions);\n    this._options = options;\n    this.debug = options.debug;\n\n    if (\n      previousOptions.scrollAdjustDelay !== options.scrollAdjustDelay ||\n      previousOptions.scrollAdjustThreshold !== options.scrollAdjustThreshold\n    ) {\n      this._clearScrollAdjustTimer();\n    }\n\n    if (previousOptions.fromViewportWidth !== options.fromViewportWidth) {\n      if (this._isMounted || this._onResize) {\n        this._handleResize();\n      }\n    } else if (previousOptions.pagerThreshold !== options.pagerThreshold) {\n      this._invalidateDraw();\n    }\n  }\n\n  /**\n   * Fully destroys immerser: unmounts runtime, removes resize handling, runs destroy event and clears references.\n   * Use when component is permanently removed.\n   */\n  public destroy(): void {\n    this.unmount();\n    this._removeResizeListener();\n    this._emit(EventNames.destroy, this);\n    this._resetInternalState();\n    EventNameArray.forEach((eventName) => this._handlers[eventName].clear());\n  }\n\n  /**\n   * Schedules structure, layout and draw synchronization after DOM mutations.\n   * Designed for dynamic content updates without reinitializing immerser.\n   *\n   * No throttling or performance optimization is applied here. The client is responsible for invocation frequency.\n   */\n  public render(): void {\n    this._invalidateStructure();\n  }\n\n  /**\n   * Syncs immerser with an externally controlled scroll position.\n   * Designed for using with custom scroll handlers when `hasExternalScroll=true`.\n   *\n   * No throttling or performance optimization is applied here. The client is responsible for invocation frequency.\n   */\n  public syncScroll(): void {\n    this._invalidateDraw();\n  }\n\n  /** Registers persistent event handler. */\n  public on<K extends EventName>(eventName: K, handler: HandlerByEventName[K]): void {\n    this._handlers[eventName].add(handler);\n  }\n\n  /** Registers event handler that will be removed after first call. */\n  public once<K extends EventName>(eventName: K, handler: HandlerByEventName[K]): void {\n    this._handlers[eventName].add(\n      wrapOnceHandler(handler, (...args: HandlerArgs<K>) => {\n        this.off(eventName, handler);\n        handler.apply(undefined, args);\n      }),\n    );\n  }\n\n  /** Removes handler(s) for provided event. */\n  public off<K extends EventName>(eventName: K, handler: HandlerByEventName[K]): void {\n    const handlerSet = this._handlers[eventName];\n\n    handlerSet.forEach((storedHandler) => {\n      const original = getOriginalHandler(storedHandler);\n      if (storedHandler === handler || original === handler) {\n        handlerSet.delete(storedHandler);\n      }\n    });\n  }\n\n  /** Current active layer index derived from scroll position. */\n  public get activeIndex(): number {\n    return this._activeIndex;\n  }\n\n  /** Indicates whether immerser runtime is mounted. */\n  public get isMounted(): boolean {\n    return this._isMounted;\n  }\n\n  /** The root DOM node immerser is attached to. */\n  public get rootNode(): HTMLElement | null {\n    return this._rootNode;\n  }\n\n  /** Progress of each layer from 0 (off-screen) to 1 (fully visible). */\n  public get layerProgressArray(): readonly number[] {\n    return this._layerProgressArray;\n  }\n\n  /** Layer ids in the same order as layers appear in DOM. */\n  public get layerIds(): readonly string[] {\n    return this._layerStateArray.map(({ id }) => id);\n  }\n\n  /** Current structure signature used to detect layer-list changes. */\n  public get structureSignature(): string {\n    return this._structureSignature;\n  }\n\n  /** Current layout signature used to detect geometry changes. */\n  public get layoutSignature(): string {\n    return this._layoutSignature;\n  }\n\n  /** Current draw signature used to detect visual state changes. */\n  public get drawSignature(): string {\n    return this._drawSignature;\n  }\n}\n\n// Keeps public values reachable from the UMD default export without changing the CommonJS entry shape.\nObject.assign(Immerser, {\n  CroppedFullAbsoluteStyles,\n  EventNameArray,\n  EventNames,\n  InteractiveStyles,\n  NotInteractiveStyles,\n  OptionConfig,\n  OptionUpdateModeByName,\n});\n\n// Used by typedef generation.\nexport type {\n  ActiveLayerChangeHandler,\n  BaseHandler,\n  EventHandlers,\n  EventName,\n  HandlerByEventName,\n  LayerProgressChangeHandler,\n  OptionUpdateMode,\n  Options,\n  RuntimeOptions,\n  SolidClassnames,\n  SolidClassnamesByLayerId,\n  UpdateLocationHashHandler,\n};\nexport {\n  EventNameArray,\n  EventNames,\n  CroppedFullAbsoluteStyles,\n  InteractiveStyles,\n  NotInteractiveStyles,\n  OptionConfig,\n  OptionUpdateModeByName,\n};\n","import type { SolidClassnamesByLayerId } from '../types';\n\ninterface IValidateImmerserMarkupParams {\n  layerNodeArray: HTMLElement[];\n  maskInnerSelector: string;\n  maskNodeArray: HTMLElement[];\n  rootNode: HTMLElement | null;\n  solidClassnamesByLayerId: SolidClassnamesByLayerId;\n}\n\nexport default function validateImmerserMarkup({\n  layerNodeArray,\n  maskInnerSelector,\n  maskNodeArray,\n  rootNode,\n  solidClassnamesByLayerId,\n}: IValidateImmerserMarkupParams): string[] {\n  const messageArray: string[] = [];\n\n  if (!rootNode) {\n    messageArray.push('root node not found.');\n  }\n  if (layerNodeArray.length === 0) {\n    messageArray.push('layer nodes not found.');\n  }\n\n  const layerIdSet = new Set<string>();\n  layerNodeArray.forEach((layerNode, layerIndex) => {\n    const { id } = layerNode;\n    if (!id) {\n      messageArray.push(`layer id not found for layer at index ${layerIndex}.`);\n      return;\n    }\n    if (layerIdSet.has(id)) {\n      messageArray.push(`duplicate layer id \"${id}\".`);\n    }\n    layerIdSet.add(id);\n  });\n\n  if (maskNodeArray.length > 0) {\n    if (maskNodeArray.length !== layerNodeArray.length) {\n      messageArray.push('existing markup mask count differs from count of layers.');\n    }\n\n    const maskLayerIdSet = new Set<string>();\n    maskNodeArray.forEach((maskNode, maskIndex) => {\n      const maskLayerId = maskNode.dataset.immerserLayerId;\n      if (!maskNode.querySelector<HTMLElement>(maskInnerSelector)) {\n        messageArray.push(`existing markup mask-inner not found for mask at index ${maskIndex}.`);\n      }\n      if (!maskLayerId) {\n        messageArray.push(`existing markup mask layer id not found for mask at index ${maskIndex}.`);\n        return;\n      }\n      if (maskLayerIdSet.has(maskLayerId)) {\n        messageArray.push(`existing markup has duplicate mask layer id \"${maskLayerId}\".`);\n      }\n      if (!layerIdSet.has(maskLayerId)) {\n        messageArray.push(`existing markup mask contains unknown layer id \"${maskLayerId}\".`);\n      }\n      maskLayerIdSet.add(maskLayerId);\n    });\n\n    layerIdSet.forEach((layerId) => {\n      if (!maskLayerIdSet.has(layerId)) {\n        messageArray.push(`existing markup mask not found for layer id \"${layerId}\".`);\n      }\n    });\n  }\n\n  if (\n    !solidClassnamesByLayerId ||\n    typeof solidClassnamesByLayerId !== 'object' ||\n    Array.isArray(solidClassnamesByLayerId)\n  ) {\n    messageArray.push('solidClassnamesByLayerId must be an object');\n    return messageArray;\n  }\n\n  const entries = Object.entries(solidClassnamesByLayerId);\n  const hasInvalidEntry = entries.some(\n    (entry) =>\n      !entry[1] ||\n      typeof entry[1] !== 'object' ||\n      Array.isArray(entry[1]) ||\n      Object.values(entry[1]).some((classname) => typeof classname !== 'string'),\n  );\n  if (hasInvalidEntry) {\n    messageArray.push('solidClassnamesByLayerId entries must map solid ids to classname strings');\n  }\n\n  entries.forEach(([layerId]) => {\n    if (!layerIdSet.has(layerId)) {\n      messageArray.push(`solidClassnamesByLayerId contains unknown layer id \"${layerId}\"`);\n    }\n  });\n\n  return messageArray;\n}\n","import type { ILayerCalculation } from '../internal-types';\n\n/** Derives scroll transition boundaries for every layer from the measured layout. */\nexport default function calculateLayerStateArray({\n  layers,\n  rootHeight,\n  rootTop,\n}: {\n  layers: readonly Pick<ILayerCalculation, 'bottom' | 'top'>[];\n  rootHeight: number;\n  rootTop: number;\n}): ILayerCalculation[] {\n  return layers.map(({ bottom, top }) => {\n    const endEnter = top - rootTop;\n    const beginEnter = endEnter - rootHeight;\n    const endLeave = bottom - rootTop;\n    const beginLeave = endLeave - rootHeight;\n\n    return {\n      beginEnter,\n      beginLeave,\n      bottom,\n      endEnter,\n      endLeave,\n      top,\n    };\n  });\n}\n","import type { ICalculationResult, ILayerCalculation } from '../internal-types';\n\n/** Calculates the scroll-derived runtime snapshot for all prepared layers. */\nexport default function calculateLayersRuntimeState({\n  layerCalculationArray,\n  pagerThreshold,\n  previousActiveIndex,\n  rootHeight,\n  scrollY,\n  viewportHeight,\n}: {\n  layerCalculationArray: ILayerCalculation[];\n  pagerThreshold: number;\n  previousActiveIndex: number;\n  rootHeight: number;\n  scrollY: number;\n  viewportHeight: number;\n}): ICalculationResult {\n  const pagerScrollActivePoint = scrollY + viewportHeight * (1 - pagerThreshold);\n  let activeIndex = previousActiveIndex;\n  const layerProgressArray: number[] = [];\n  const transforms = layerCalculationArray.map((layer, layerIndex) => {\n    if (layer.top <= pagerScrollActivePoint && pagerScrollActivePoint < layer.bottom) {\n      activeIndex = layerIndex;\n    }\n\n    const viewportBottom = scrollY + viewportHeight;\n    const layerHeight = layer.bottom - layer.top;\n    const overlap = Math.min(layer.bottom, viewportBottom) - Math.max(layer.top, scrollY);\n    const overlapBase = Math.min(layerHeight, viewportHeight);\n    layerProgressArray.push(overlapBase <= 0 ? 0 : Math.max(0, Math.min(1, overlap / overlapBase)));\n\n    let progress: number;\n\n    if (layer.beginEnter > scrollY) {\n      progress = rootHeight;\n    } else if (layer.beginEnter <= scrollY && scrollY < layer.endEnter) {\n      progress = layer.endEnter - scrollY;\n    } else if (layer.endEnter <= scrollY && scrollY < layer.beginLeave) {\n      progress = 0;\n    } else if (layer.beginLeave <= scrollY && scrollY < layer.endLeave) {\n      progress = layer.beginLeave - scrollY;\n    } else {\n      progress = -rootHeight;\n    }\n\n    return progress;\n  });\n\n  return {\n    activeIndex,\n    layerProgressArray,\n    previousActiveIndex,\n    transforms,\n  };\n}\n","import type { ILayerCalculation } from '../internal-types';\n\n/** Returns the nearest layer-edge scroll target without clamping it to a scroll container's bounds. */\nexport default function calculateScrollTarget({\n  activeLayer,\n  scrollAdjustThreshold,\n  scrollY,\n  viewportHeight,\n}: {\n  activeLayer: ILayerCalculation;\n  scrollAdjustThreshold: number;\n  scrollY: number;\n  viewportHeight: number;\n}): number | null {\n  const topThreshold = Math.abs(scrollY - activeLayer.top);\n  const bottomThreshold = Math.abs(scrollY + viewportHeight - activeLayer.bottom);\n\n  if (topThreshold !== 0 && bottomThreshold !== 0) {\n    if (topThreshold <= bottomThreshold && topThreshold <= scrollAdjustThreshold) {\n      return activeLayer.top;\n    }\n    if (bottomThreshold <= topThreshold && bottomThreshold <= scrollAdjustThreshold) {\n      return activeLayer.bottom - viewportHeight;\n    }\n  }\n\n  return null;\n}\n","export default function assignInlineStyles(\n  node: HTMLElement,\n  styles: Partial<Record<keyof CSSStyleDeclaration, string>>,\n): void {\n  for (const rule in styles) {\n    Reflect.set(node.style, rule, styles[rule]);\n  }\n}\n","type WrappedOnceHandler<F extends (...args: any[]) => void> = F & {\n  __immerserOriginalHandler?: F;\n};\n\nexport function wrapOnceHandler<F extends(...args: any[]) => void>(\n  original: F,\n  wrapper: (...args: Parameters<F>) => void,\n): F {\n  const wrapped = wrapper as WrappedOnceHandler<F>;\n  wrapped.__immerserOriginalHandler = original;\n  return wrapped;\n}\n\nexport function getOriginalHandler<F extends(...args: any[]) => void>(handler: F): F | undefined {\n  return (handler as WrappedOnceHandler<F>).__immerserOriginalHandler;\n}\n"],"names":["o","e","Object","prototype","hasOwnProperty","call","Array","isArray","t","optionConfig","i","userOptions","r","n","prefix","a","f","suffix","u","p","strict","d","c","join","s","l","g","v","required","y","default","b","description","x","validator","h","q","E","w","TypeError","console","warn","module","exports","Symbol","toPrimitive","String","Observable","this","callbacks","internal","initialValue","subscribe","push","indexOf","slice","concat","reset","key","get","set","length","enumerable","configurable","writable","defineProperty","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","undefined","__webpack_modules__","getter","__esModule","definition","binding","value","obj","prop","EventNames","init","mount","unmount","destroy","structureChange","layoutChange","activeLayerChange","layerProgressChange","stateChange","EventNameArray","values","CroppedFullAbsoluteStyles","position","top","right","bottom","left","overflow","NotInteractiveStyles","pointerEvents","touchAction","InteractiveStyles","ImmerserSelectors","root","layer","solid","pagerLink","mask","maskInner","synchroHover","ClassnameRegex","OptionConfig","autoMount","selectorRoot","querySelectorAll","solidClassnamesByLayerId","_typeof","fromViewportWidth","pagerThreshold","updateLocationHash","scrollAdjustThreshold","scrollAdjustDelay","pagerLinkActiveClassname","str","test","hasExternalScroll","hasExternalRenderer","debug","on","keys","every","eventName","includes","OptionUpdateModeByName","limit","number","min","max","Math","getLastScrollPosition","scrollX","window","document","documentElement","scrollLeft","scrollY","scrollTop","offsetWidth","offsetHeight","queryElementArray","_ref","selector","_ref$parent","parent","nodeList","from","MessagePrefix","RuntimeOptionNames","filter","optionName","Immerser","_classCallCheck","_defineProperty","Set","structure","layout","draw","_init","_options$selectorRoot","_userOptions","options","_mergeOptions","_options","_selectorRoot","_registerHandlersFromOptions","_addResizeListener","_emit","_this","forEach","handler","_this2","_len","arguments","args","_key","_handlers","apply","error","_report","message","docsHash","_ref$isWarning","isWarning","_ref$docsHash","resultMessage","Error","cause","_this3","_rootNode","querySelector","_selectors","_layerNodeArray","_maskNodeArray","_validateMarkup","previousLayerStateById","Map","_layerStateArray","map","layerState","id","layerNode","order","_previousLayerState$c","_previousLayerState$m","_previousLayerState$m2","_this3$_options$solid","previousLayerState","calculation","maskInnerNode","maskNode","solidClassnames","_structureSignature","_createLayerSignature","_this4","messageArray","layerNodeArray","maskInnerSelector","maskNodeArray","rootNode","layerIdSet","layerIndex","has","add","maskLayerIdSet","maskIndex","maskLayerId","dataset","immerserLayerId","layerId","entries","some","entry","classname","_ref2","_slicedToArray","validateImmerserMarkup","mergeOptions","_this5","find","node","maskState","innerWidth","layers","offsetTop","_isLayoutSet","_rootHeight","_viewportHeight","innerHeight","layerCalculationArray","rootHeight","rootTop","endEnter","endLeave","beginEnter","beginLeave","calculateLayerStateArray","_objectSpread","_layerProgressArray","_layoutSignature","_createLayoutSignature","_drawSignature","_toConsumableArray","_ref3","_onResize","_handleResize","bind","addEventListener","_onScroll","_handleScroll","ResizeObserver","_resizeObserver","observe","_isMounted","_pagerLinkNodeArray","_synchroHoverNodeArray","_flushFrameId","_scrollAdjustTimerId","_reactiveSynchroHoverId","_unsubscribeSynchroHover","_onSynchroHoverMouseOver","_onSynchroHoverMouseOut","_originalSolidNodeArray","_clonedSolidArray","_preparedMaskMarkupArray","_solidNodeArray","_pendingSync","_resetMountedState","_connectExistingMaskMarkup","_cleanupMarkup","layerStateArray","maskMarkupArray","_resolveMaskMarkup","nextLayerStateArray","_connectLayerStates","originalSolidNodeArray","_findSourceSolids","clonedSolidArray","_cloneSolids","solidNodeArray","_collectSolidNodes","_reportEmptyMarkup","_applyTechnicalStyles","_commitNodes","_applyCreatedMasksAria","_savePreparedMarkupState","_detachOriginalSolids","_removeClonedSolids","_restoreOriginalSolids","_clearTechnicalStyles","_removeCreatedMasks","_resetMarkupState","_this6","synchroHoverId","currentTarget","immerserSynchroHover","synchroHoverNode","_drawHoverSynchronization","_this$_unsubscribeSyn","_this7","removeEventListener","_this8","classList","remove","_this$_resizeObserver","disconnect","cancelAnimationFrame","clearTimeout","_cancelFlushFrame","_clearScrollAdjustTimer","isMounted","_getLayerSignature","_scheduleFlush","_invalidateLayout","_invalidateDraw","_this9","requestAnimationFrame","_flush","_syncMountedStructure","_syncLayoutSizes","_drawCurrentState","_destroyHoverSynchronization","_clearPagerLinks","_syncStructure","_prepareMarkup","_initPagerLinks","_initHoverSynchronization","_calculate","nextDrawSignature","_createDrawSignature","_draw","layerProgressArray","previousActiveIndex","viewportHeight","pagerScrollActivePoint","activeIndex","transforms","viewportBottom","layerHeight","overlap","overlapBase","calculateLayersRuntimeState","_ref4","_activeIndex","_ref5","_ref6","_ref7","translateY","style","transform","_drawPagerLinks","_drawHash","_this$_layerStateArra","_this0","pagerLinkNode","href","getAttribute","toggle","Boolean","endsWith","removeAttribute","setAttribute","_getLastScrollPositio","scrollTarget","_calculateScrollTarget","scrollTo","_this$_layerStateArra2","activeLayer","topThreshold","abs","bottomThreshold","calculateScrollTarget","setTimeout","_adjustScroll","_shouldMount","reduce","result","_this1","_ref8","_connectMaskMarkup","_this10","existingMaskNodeArray","_ref9","_createMaskMarkup","_ref0","createElement","immerserMask","immerserMaskInner","appendChild","createdMask","solidNode","_ref1","contains","_ref10","originalSolidNode","clonedSolidNode","cloneNode","HTMLElement","solidId","immerserSolid","_this11","existingSolidNodeArray","flatMap","_ref11","_ref12","_ref13","children","_this12","_setTechnicalStyles","_ref14","styles","rule","Reflect","assignInlineStyles","_this13","_ref15","_ref16","_ref17","_ref18","_ref19","_ref20","_this14","_ref21","_ref22","_ref23","_addMountedListeners","_cancelScheduledRuntimeWork","_removeMountedListeners","previousOptions","runtimeOptions","_pickRuntimeOptions","_this15","_removeResizeListener","_resetInternalState","clear","_invalidateStructure","original","wrapper","wrapped","_this16","off","_len2","_key2","__immerserOriginalHandler","handlerSet","storedHandler","getOriginalHandler","delete","_ref24","assign"],"sourceRoot":""}