\" ).append( jQuery.parseHTML( responseText ) ).find( selector ) :\n\n\t\t\t\t// Otherwise use the full result\n\t\t\t\tresponseText );\n\n\t\t// If the request succeeds, this function gets \"data\", \"status\", \"jqXHR\"\n\t\t// but they are ignored because response was set above.\n\t\t// If it fails, this function gets \"jqXHR\", \"status\", \"error\"\n\t\t} ).always( callback && function( jqXHR, status ) {\n\t\t\tself.each( function() {\n\t\t\t\tcallback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] );\n\t\t\t} );\n\t\t} );\n\t}\n\n\treturn this;\n};\n\n} );\n","define( [\n\t\"../core\",\n\t\"../var/document\",\n\t\"../ajax\"\n], function( jQuery, document ) {\n\n\"use strict\";\n\n// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)\njQuery.ajaxPrefilter( function( s ) {\n\tif ( s.crossDomain ) {\n\t\ts.contents.script = false;\n\t}\n} );\n\n// Install script dataType\njQuery.ajaxSetup( {\n\taccepts: {\n\t\tscript: \"text/javascript, application/javascript, \" +\n\t\t\t\"application/ecmascript, application/x-ecmascript\"\n\t},\n\tcontents: {\n\t\tscript: /\\b(?:java|ecma)script\\b/\n\t},\n\tconverters: {\n\t\t\"text script\": function( text ) {\n\t\t\tjQuery.globalEval( text );\n\t\t\treturn text;\n\t\t}\n\t}\n} );\n\n// Handle cache's special case and crossDomain\njQuery.ajaxPrefilter( \"script\", function( s ) {\n\tif ( s.cache === undefined ) {\n\t\ts.cache = false;\n\t}\n\tif ( s.crossDomain ) {\n\t\ts.type = \"GET\";\n\t}\n} );\n\n// Bind script tag hack transport\njQuery.ajaxTransport( \"script\", function( s ) {\n\n\t// This transport only deals with cross domain or forced-by-attrs requests\n\tif ( s.crossDomain || s.scriptAttrs ) {\n\t\tvar script, callback;\n\t\treturn {\n\t\t\tsend: function( _, complete ) {\n\t\t\t\tscript = jQuery( \"\");\n },\n};\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar registeredStoreGenerators = new Map();\nvar hydratedStores = new Map();\nexports.default = {\n /**\n * Register a store generator, a function that takes props and returns a store.\n * @param storeGenerators { name1: storeGenerator1, name2: storeGenerator2 }\n */\n register: function (storeGenerators) {\n Object.keys(storeGenerators).forEach(function (name) {\n if (registeredStoreGenerators.has(name)) {\n console.warn('Called registerStore for store that is already registered', name);\n }\n var store = storeGenerators[name];\n if (!store) {\n throw new Error('Called ReactOnRails.registerStores with a null or undefined as a value ' +\n \"for the store generator with key \".concat(name, \".\"));\n }\n registeredStoreGenerators.set(name, store);\n });\n },\n /**\n * Used by components to get the hydrated store which contains props.\n * @param name\n * @param throwIfMissing Defaults to true. Set to false to have this call return undefined if\n * there is no store with the given name.\n * @returns Redux Store, possibly hydrated\n */\n getStore: function (name, throwIfMissing) {\n if (throwIfMissing === void 0) { throwIfMissing = true; }\n if (hydratedStores.has(name)) {\n return hydratedStores.get(name);\n }\n var storeKeys = Array.from(hydratedStores.keys()).join(', ');\n if (storeKeys.length === 0) {\n var msg = \"There are no stores hydrated and you are requesting the store \".concat(name, \".\\nThis can happen if you are server rendering and either:\\n1. You do not call redux_store near the top of your controller action's view (not the layout)\\n and before any call to react_component.\\n2. You do not render redux_store_hydration_data anywhere on your page.\");\n throw new Error(msg);\n }\n if (throwIfMissing) {\n console.log('storeKeys', storeKeys);\n throw new Error(\"Could not find hydrated store with name '\".concat(name, \"'. \") +\n \"Hydrated store names include [\".concat(storeKeys, \"].\"));\n }\n return undefined;\n },\n /**\n * Internally used function to get the store creator that was passed to `register`.\n * @param name\n * @returns storeCreator with given name\n */\n getStoreGenerator: function (name) {\n if (registeredStoreGenerators.has(name)) {\n return registeredStoreGenerators.get(name);\n }\n var storeKeys = Array.from(registeredStoreGenerators.keys()).join(', ');\n throw new Error(\"Could not find store registered with name '\".concat(name, \"'. Registered store \") +\n \"names include [ \".concat(storeKeys, \" ]. Maybe you forgot to register the store?\"));\n },\n /**\n * Internally used function to set the hydrated store after a Rails page is loaded.\n * @param name\n * @param store (not the storeGenerator, but the hydrated store)\n */\n setStore: function (name, store) {\n hydratedStores.set(name, store);\n },\n /**\n * Internally used function to completely clear hydratedStores Map.\n */\n clearHydratedStores: function () {\n hydratedStores.clear();\n },\n /**\n * Get a Map containing all registered store generators. Useful for debugging.\n * @returns Map where key is the component name and values are the store generators.\n */\n storeGenerators: function () {\n return registeredStoreGenerators;\n },\n /**\n * Get a Map containing all hydrated stores. Useful for debugging.\n * @returns Map where key is the component name and values are the hydrated stores.\n */\n stores: function () {\n return hydratedStores;\n },\n};\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.consoleReplay = void 0;\nvar RenderUtils_1 = __importDefault(require(\"./RenderUtils\"));\nvar scriptSanitizedVal_1 = __importDefault(require(\"./scriptSanitizedVal\"));\nfunction consoleReplay() {\n // console.history is a global polyfill used in server rendering.\n // $FlowFixMe\n if (!(console.history instanceof Array)) {\n return '';\n }\n var lines = console.history.map(function (msg) {\n var stringifiedList = msg.arguments.map(function (arg) {\n var val;\n try {\n val = (typeof arg === 'string' || arg instanceof String) ? arg : JSON.stringify(arg);\n if (val === undefined) {\n val = 'undefined';\n }\n }\n catch (e) {\n val = \"\".concat(e.message, \": \").concat(arg);\n }\n return (0, scriptSanitizedVal_1.default)(val);\n });\n return \"console.\".concat(msg.level, \".apply(console, \").concat(JSON.stringify(stringifiedList), \");\");\n });\n return lines.join('\\n');\n}\nexports.consoleReplay = consoleReplay;\nfunction buildConsoleReplay() {\n return RenderUtils_1.default.wrapInScriptTags('consoleReplayLog', consoleReplay());\n}\nexports.default = buildConsoleReplay;\n","\"use strict\";\nvar __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {\n if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n if (ar || !(i in from)) {\n if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n ar[i] = from[i];\n }\n }\n return to.concat(ar || Array.prototype.slice.call(from));\n};\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.clientStartup = exports.reactOnRailsPageLoaded = void 0;\nvar react_dom_1 = __importDefault(require(\"react-dom\"));\nvar createReactOutput_1 = __importDefault(require(\"./createReactOutput\"));\nvar isServerRenderResult_1 = require(\"./isServerRenderResult\");\nvar reactHydrateOrRender_1 = __importDefault(require(\"./reactHydrateOrRender\"));\nvar reactApis_1 = require(\"./reactApis\");\nvar REACT_ON_RAILS_STORE_ATTRIBUTE = 'data-js-react-on-rails-store';\nfunction findContext() {\n if (typeof window.ReactOnRails !== 'undefined') {\n return window;\n }\n else if (typeof ReactOnRails !== 'undefined') {\n return global;\n }\n throw new Error(\"ReactOnRails is undefined in both global and window namespaces.\\n \");\n}\nfunction debugTurbolinks() {\n var msg = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n msg[_i] = arguments[_i];\n }\n if (!window) {\n return;\n }\n var context = findContext();\n if (context.ReactOnRails && context.ReactOnRails.option('traceTurbolinks')) {\n console.log.apply(console, __spreadArray(['TURBO:'], msg, false));\n }\n}\nfunction turbolinksInstalled() {\n return (typeof Turbolinks !== 'undefined');\n}\nfunction turboInstalled() {\n var context = findContext();\n if (context.ReactOnRails) {\n return context.ReactOnRails.option('turbo') === true;\n }\n return false;\n}\nfunction reactOnRailsHtmlElements() {\n return document.getElementsByClassName('js-react-on-rails-component');\n}\nfunction initializeStore(el, context, railsContext) {\n var name = el.getAttribute(REACT_ON_RAILS_STORE_ATTRIBUTE) || '';\n var props = (el.textContent !== null) ? JSON.parse(el.textContent) : {};\n var storeGenerator = context.ReactOnRails.getStoreGenerator(name);\n var store = storeGenerator(props, railsContext);\n context.ReactOnRails.setStore(name, store);\n}\nfunction forEachStore(context, railsContext) {\n var els = document.querySelectorAll(\"[\".concat(REACT_ON_RAILS_STORE_ATTRIBUTE, \"]\"));\n for (var i = 0; i < els.length; i += 1) {\n initializeStore(els[i], context, railsContext);\n }\n}\nfunction turbolinksVersion5() {\n return (typeof Turbolinks.controller !== 'undefined');\n}\nfunction turbolinksSupported() {\n return Turbolinks.supported;\n}\nfunction delegateToRenderer(componentObj, props, railsContext, domNodeId, trace) {\n var name = componentObj.name, component = componentObj.component, isRenderer = componentObj.isRenderer;\n if (isRenderer) {\n if (trace) {\n console.log(\"DELEGATING TO RENDERER \".concat(name, \" for dom node with id: \").concat(domNodeId, \" with props, railsContext:\"), props, railsContext);\n }\n component(props, railsContext, domNodeId);\n return true;\n }\n return false;\n}\nfunction domNodeIdForEl(el) {\n return el.getAttribute('data-dom-id') || '';\n}\n/**\n * Used for client rendering by ReactOnRails. Either calls ReactDOM.hydrate, ReactDOM.render, or\n * delegates to a renderer registered by the user.\n */\nfunction render(el, context, railsContext) {\n // This must match lib/react_on_rails/helper.rb\n var name = el.getAttribute('data-component-name') || '';\n var domNodeId = domNodeIdForEl(el);\n var props = (el.textContent !== null) ? JSON.parse(el.textContent) : {};\n var trace = el.getAttribute('data-trace') === 'true';\n try {\n var domNode = document.getElementById(domNodeId);\n if (domNode) {\n var componentObj = context.ReactOnRails.getComponent(name);\n if (delegateToRenderer(componentObj, props, railsContext, domNodeId, trace)) {\n return;\n }\n // Hydrate if available and was server rendered\n // @ts-expect-error potentially present if React 18 or greater\n var shouldHydrate = !!(react_dom_1.default.hydrate || react_dom_1.default.hydrateRoot) && !!domNode.innerHTML;\n var reactElementOrRouterResult = (0, createReactOutput_1.default)({\n componentObj: componentObj,\n props: props,\n domNodeId: domNodeId,\n trace: trace,\n railsContext: railsContext,\n shouldHydrate: shouldHydrate,\n });\n if ((0, isServerRenderResult_1.isServerRenderHash)(reactElementOrRouterResult)) {\n throw new Error(\"You returned a server side type of react-router error: \".concat(JSON.stringify(reactElementOrRouterResult), \"\\nYou should return a React.Component always for the client side entry point.\"));\n }\n else {\n var rootOrElement = (0, reactHydrateOrRender_1.default)(domNode, reactElementOrRouterResult, shouldHydrate);\n if (reactApis_1.supportsRootApi) {\n context.roots.push(rootOrElement);\n }\n }\n }\n }\n catch (e) {\n console.error(e.message);\n e.message = \"ReactOnRails encountered an error while rendering component: \".concat(name, \". See above error message.\");\n throw e;\n }\n}\nfunction forEachReactOnRailsComponentRender(context, railsContext) {\n var els = reactOnRailsHtmlElements();\n for (var i = 0; i < els.length; i += 1) {\n render(els[i], context, railsContext);\n }\n}\nfunction parseRailsContext() {\n var el = document.getElementById('js-react-on-rails-context');\n if (!el) {\n // The HTML page will not have an element with ID 'js-react-on-rails-context' if there are no\n // react on rails components\n return null;\n }\n if (!el.textContent) {\n throw new Error('The HTML element with ID \\'js-react-on-rails-context\\' has no textContent');\n }\n return JSON.parse(el.textContent);\n}\nfunction reactOnRailsPageLoaded() {\n debugTurbolinks('reactOnRailsPageLoaded');\n var railsContext = parseRailsContext();\n // If no react on rails components\n if (!railsContext)\n return;\n var context = findContext();\n if (reactApis_1.supportsRootApi) {\n context.roots = [];\n }\n forEachStore(context, railsContext);\n forEachReactOnRailsComponentRender(context, railsContext);\n}\nexports.reactOnRailsPageLoaded = reactOnRailsPageLoaded;\nfunction unmount(el) {\n var domNodeId = domNodeIdForEl(el);\n var domNode = document.getElementById(domNodeId);\n if (domNode === null) {\n return;\n }\n try {\n react_dom_1.default.unmountComponentAtNode(domNode);\n }\n catch (e) {\n console.info(\"Caught error calling unmountComponentAtNode: \".concat(e.message, \" for domNode\"), domNode, e);\n }\n}\nfunction reactOnRailsPageUnloaded() {\n debugTurbolinks('reactOnRailsPageUnloaded');\n if (reactApis_1.supportsRootApi) {\n var roots = findContext().roots;\n // If no react on rails components\n if (!roots)\n return;\n for (var _i = 0, roots_1 = roots; _i < roots_1.length; _i++) {\n var root = roots_1[_i];\n root.unmount();\n }\n }\n else {\n var els = reactOnRailsHtmlElements();\n for (var i = 0; i < els.length; i += 1) {\n unmount(els[i]);\n }\n }\n}\nfunction renderInit() {\n // Install listeners when running on the client (browser).\n // We must do this check for turbolinks AFTER the document is loaded because we load the\n // Webpack bundles first.\n if ((!turbolinksInstalled() || !turbolinksSupported()) && !turboInstalled()) {\n debugTurbolinks('NOT USING TURBOLINKS: calling reactOnRailsPageLoaded');\n reactOnRailsPageLoaded();\n return;\n }\n if (turboInstalled()) {\n debugTurbolinks('USING TURBO: document added event listeners ' +\n 'turbo:before-render and turbo:render.');\n document.addEventListener('turbo:before-render', reactOnRailsPageUnloaded);\n document.addEventListener('turbo:render', reactOnRailsPageLoaded);\n reactOnRailsPageLoaded();\n }\n else if (turbolinksVersion5()) {\n debugTurbolinks('USING TURBOLINKS 5: document added event listeners ' +\n 'turbolinks:before-render and turbolinks:render.');\n document.addEventListener('turbolinks:before-render', reactOnRailsPageUnloaded);\n document.addEventListener('turbolinks:render', reactOnRailsPageLoaded);\n reactOnRailsPageLoaded();\n }\n else {\n debugTurbolinks('USING TURBOLINKS 2: document added event listeners page:before-unload and ' +\n 'page:change.');\n document.addEventListener('page:before-unload', reactOnRailsPageUnloaded);\n document.addEventListener('page:change', reactOnRailsPageLoaded);\n }\n}\nfunction isWindow(context) {\n return context.document !== undefined;\n}\nfunction onPageReady(callback) {\n if (document.readyState === \"complete\") {\n callback();\n }\n else {\n document.addEventListener(\"readystatechange\", function onReadyStateChange() {\n onPageReady(callback);\n document.removeEventListener(\"readystatechange\", onReadyStateChange);\n });\n }\n}\nfunction clientStartup(context) {\n // Check if server rendering\n if (!isWindow(context)) {\n return;\n }\n var document = context.document;\n // Tried with a file local variable, but the install handler gets called twice.\n // eslint-disable-next-line no-underscore-dangle\n if (context.__REACT_ON_RAILS_EVENT_HANDLERS_RAN_ONCE__) {\n return;\n }\n // eslint-disable-next-line no-underscore-dangle, no-param-reassign\n context.__REACT_ON_RAILS_EVENT_HANDLERS_RAN_ONCE__ = true;\n onPageReady(renderInit);\n}\nexports.clientStartup = clientStartup;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * Get the context, be it window or global\n * @returns {boolean|Window|*|context}\n */\nfunction context() {\n return ((typeof window !== 'undefined') && window) ||\n ((typeof global !== 'undefined') && global) ||\n this;\n}\nexports.default = context;\n","\"use strict\";\n/* eslint-disable react/prop-types */\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar react_1 = __importDefault(require(\"react\"));\nvar isServerRenderResult_1 = require(\"./isServerRenderResult\");\n/**\n * Logic to either call the renderFunction or call React.createElement to get the\n * React.Component\n * @param options\n * @param options.componentObj\n * @param options.props\n * @param options.domNodeId\n * @param options.trace\n * @param options.location\n * @returns {ReactElement}\n */\nfunction createReactOutput(_a) {\n var componentObj = _a.componentObj, props = _a.props, railsContext = _a.railsContext, domNodeId = _a.domNodeId, trace = _a.trace, shouldHydrate = _a.shouldHydrate;\n var name = componentObj.name, component = componentObj.component, renderFunction = componentObj.renderFunction;\n if (trace) {\n if (railsContext && railsContext.serverSide) {\n console.log(\"RENDERED \".concat(name, \" to dom node with id: \").concat(domNodeId));\n }\n else if (shouldHydrate) {\n console.log(\"HYDRATED \".concat(name, \" in dom node with id: \").concat(domNodeId, \" using props, railsContext:\"), props, railsContext);\n }\n else {\n console.log(\"RENDERED \".concat(name, \" to dom node with id: \").concat(domNodeId, \" with props, railsContext:\"), props, railsContext);\n }\n }\n if (renderFunction) {\n // Let's invoke the function to get the result\n if (trace) {\n console.log(\"\".concat(name, \" is a renderFunction\"));\n }\n var renderFunctionResult = component(props, railsContext);\n if ((0, isServerRenderResult_1.isServerRenderHash)(renderFunctionResult)) {\n // We just return at this point, because calling function knows how to handle this case and\n // we can't call React.createElement with this type of Object.\n return renderFunctionResult;\n }\n if ((0, isServerRenderResult_1.isPromise)(renderFunctionResult)) {\n // We just return at this point, because calling function knows how to handle this case and\n // we can't call React.createElement with this type of Object.\n return renderFunctionResult;\n }\n if (react_1.default.isValidElement(renderFunctionResult)) {\n // If already a ReactElement, then just return it.\n console.error(\"Warning: ReactOnRails: Your registered render-function (ReactOnRails.register) for \".concat(name, \"\\nincorrectly returned a React Element (JSX). Instead, return a React Function Component by\\nwrapping your JSX in a function. ReactOnRails v13 will throw error on this, as React Hooks do not\\nwork if you return JSX. Update by wrapping the result JSX of \").concat(name, \" in a fat arrow function.\"));\n return renderFunctionResult;\n }\n // If a component, then wrap in an element\n var reactComponent = renderFunctionResult;\n return react_1.default.createElement(reactComponent, props);\n }\n // else\n return react_1.default.createElement(component, props);\n}\nexports.default = createReactOutput;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar react_1 = __importDefault(require(\"react\"));\nvar server_1 = __importDefault(require(\"react-dom/server\"));\nfunction handleRenderFunctionIssue(options) {\n var e = options.e, name = options.name;\n var msg = '';\n if (name) {\n var lastLine = 'A Render-Function takes a single arg of props (and the location for react-router) ' +\n 'and returns a ReactElement.';\n var shouldBeRenderFunctionError = \"ERROR: ReactOnRails is incorrectly detecting Render-Function to be false. The React\\ncomponent '\".concat(name, \"' seems to be a Render-Function.\\n\").concat(lastLine);\n var reMatchShouldBeGeneratorError = /Can't add property context, object is not extensible/;\n if (reMatchShouldBeGeneratorError.test(e.message)) {\n msg += \"\".concat(shouldBeRenderFunctionError, \"\\n\\n\");\n console.error(shouldBeRenderFunctionError);\n }\n shouldBeRenderFunctionError =\n \"ERROR: ReactOnRails is incorrectly detecting renderFunction to be true, but the React\\ncomponent '\".concat(name, \"' is not a Render-Function.\\n\").concat(lastLine);\n var reMatchShouldNotBeGeneratorError = /Cannot call a class as a function/;\n if (reMatchShouldNotBeGeneratorError.test(e.message)) {\n msg += \"\".concat(shouldBeRenderFunctionError, \"\\n\\n\");\n console.error(shouldBeRenderFunctionError);\n }\n }\n return msg;\n}\nvar handleError = function (options) {\n var e = options.e, jsCode = options.jsCode, serverSide = options.serverSide;\n console.error('Exception in rendering!');\n var msg = handleRenderFunctionIssue(options);\n if (jsCode) {\n console.error(\"JS code was: \".concat(jsCode));\n }\n if (e.fileName) {\n console.error(\"location: \".concat(e.fileName, \":\").concat(e.lineNumber));\n }\n console.error(\"message: \".concat(e.message));\n console.error(\"stack: \".concat(e.stack));\n if (serverSide) {\n msg += \"Exception in rendering!\\n\".concat(e.fileName ? \"\\nlocation: \".concat(e.fileName, \":\").concat(e.lineNumber) : '', \"\\nMessage: \").concat(e.message, \"\\n\\n\").concat(e.stack);\n var reactElement = react_1.default.createElement('pre', null, msg);\n return server_1.default.renderToString(reactElement);\n }\n return \"undefined\";\n};\nexports.default = handleError;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * Used to determine we'll call be calling React.createElement on the component of if this is a\n * Render-Function used return a function that takes props to return a React element\n * @param component\n * @returns {boolean}\n */\nfunction isRenderFunction(component) {\n // No for es5 or es6 React Component\n if (component.prototype &&\n component.prototype.isReactComponent) {\n return false;\n }\n if (component.renderFunction) {\n return true;\n }\n // If zero or one args, then we know that this is a regular function that will\n // return a React component\n if (component.length >= 2) {\n return true;\n }\n return false;\n}\nexports.default = isRenderFunction;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.isPromise = exports.isServerRenderHash = void 0;\nfunction isServerRenderHash(testValue) {\n return !!(testValue.renderedHtml ||\n testValue.redirectLocation ||\n testValue.routeError ||\n testValue.error);\n}\nexports.isServerRenderHash = isServerRenderHash;\nfunction isPromise(testValue) {\n return !!(testValue.then);\n}\nexports.isPromise = isPromise;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nvar _a;\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.supportsRootApi = void 0;\nvar react_dom_1 = __importDefault(require(\"react-dom\"));\nvar reactMajorVersion = ((_a = react_dom_1.default.version) === null || _a === void 0 ? void 0 : _a.split('.')[0]) || 16;\n// TODO: once we require React 18, we can remove this and inline everything guarded by it.\n// Not the default export because others may be added for future React versions.\n// eslint-disable-next-line import/prefer-default-export\nexports.supportsRootApi = reactMajorVersion >= 18;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.reactRender = exports.reactHydrate = void 0;\nvar react_dom_1 = __importDefault(require(\"react-dom\"));\nvar reactApis_1 = require(\"./reactApis\");\n// TODO: once React dependency is updated to >= 18, we can remove this and just\n// import ReactDOM from 'react-dom/client';\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nvar reactDomClient;\nif (reactApis_1.supportsRootApi) {\n // This will never throw an exception, but it's the way to tell Webpack the dependency is optional\n // https://github.com/webpack/webpack/issues/339#issuecomment-47739112\n // Unfortunately, it only converts the error to a warning.\n try {\n // eslint-disable-next-line global-require,import/no-unresolved\n reactDomClient = require('react-dom/client');\n }\n catch (e) {\n // We should never get here, but if we do, we'll just use the default ReactDOM\n // and live with the warning.\n reactDomClient = react_dom_1.default;\n }\n}\nexports.reactHydrate = reactApis_1.supportsRootApi ?\n reactDomClient.hydrateRoot :\n function (domNode, reactElement) { return react_dom_1.default.hydrate(reactElement, domNode); };\nfunction reactRender(domNode, reactElement) {\n if (reactApis_1.supportsRootApi) {\n var root = reactDomClient.createRoot(domNode);\n root.render(reactElement);\n return root;\n }\n // eslint-disable-next-line react/no-render-return-value\n return react_dom_1.default.render(reactElement, domNode);\n}\nexports.reactRender = reactRender;\nfunction reactHydrateOrRender(domNode, reactElement, hydrate) {\n return hydrate ? (0, exports.reactHydrate)(domNode, reactElement) : reactRender(domNode, reactElement);\n}\nexports.default = reactHydrateOrRender;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.default = (function (val) {\n // Replace closing\n var re = /<\\/\\W*script/gi;\n return val.replace(re, '(/script');\n});\n","\"use strict\";\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n function verb(n) { return function (v) { return step([n, v]); }; }\n function step(op) {\n if (f) throw new TypeError(\"Generator is already executing.\");\n while (g && (g = 0, op[0] && (_ = 0)), _) try {\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;\n if (y = 0, t) op = [op[0] & 2, t.value];\n switch (op[0]) {\n case 0: case 1: t = op; break;\n case 4: _.label++; return { value: op[1], done: false };\n case 5: _.label++; y = op[1]; op = [0]; continue;\n case 7: op = _.ops.pop(); _.trys.pop(); continue;\n default:\n if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n if (t[2]) _.ops.pop();\n _.trys.pop(); continue;\n }\n op = body.call(thisArg, _);\n } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n }\n};\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar server_1 = __importDefault(require(\"react-dom/server\"));\nvar ComponentRegistry_1 = __importDefault(require(\"./ComponentRegistry\"));\nvar createReactOutput_1 = __importDefault(require(\"./createReactOutput\"));\nvar isServerRenderResult_1 = require(\"./isServerRenderResult\");\nvar buildConsoleReplay_1 = __importDefault(require(\"./buildConsoleReplay\"));\nvar handleError_1 = __importDefault(require(\"./handleError\"));\nfunction serverRenderReactComponent(options) {\n var _this = this;\n var name = options.name, domNodeId = options.domNodeId, trace = options.trace, props = options.props, railsContext = options.railsContext, renderingReturnsPromises = options.renderingReturnsPromises, throwJsErrors = options.throwJsErrors;\n var renderResult = null;\n var hasErrors = false;\n var renderingError = null;\n try {\n var componentObj = ComponentRegistry_1.default.get(name);\n if (componentObj.isRenderer) {\n throw new Error(\"Detected a renderer while server rendering component '\".concat(name, \"'. See https://github.com/shakacode/react_on_rails#renderer-functions\"));\n }\n var reactRenderingResult_1 = (0, createReactOutput_1.default)({\n componentObj: componentObj,\n domNodeId: domNodeId,\n trace: trace,\n props: props,\n railsContext: railsContext,\n });\n var processServerRenderHash = function () {\n // We let the client side handle any redirect\n // Set hasErrors in case we want to throw a Rails exception\n hasErrors = !!reactRenderingResult_1.routeError;\n if (hasErrors) {\n console.error(\"React Router ERROR: \".concat(JSON.stringify(reactRenderingResult_1.routeError)));\n }\n if (reactRenderingResult_1.redirectLocation) {\n if (trace) {\n var redirectLocation = reactRenderingResult_1.redirectLocation;\n var redirectPath = redirectLocation.pathname + redirectLocation.search;\n console.log(\" ROUTER REDIRECT: \".concat(name, \" to dom node with id: \").concat(domNodeId, \", redirect to \").concat(redirectPath));\n }\n // For redirects on server rendering, we can't stop Rails from returning the same result.\n // Possibly, someday, we could have the rails server redirect.\n return '';\n }\n return reactRenderingResult_1.renderedHtml;\n };\n var processPromise = function () {\n if (!renderingReturnsPromises) {\n console.error('Your render function returned a Promise, which is only supported by a node renderer, not ExecJS.');\n }\n return reactRenderingResult_1;\n };\n var processReactElement = function () {\n try {\n return server_1.default.renderToString(reactRenderingResult_1);\n }\n catch (error) {\n console.error(\"Invalid call to renderToString. Possibly you have a renderFunction, a function that already\\ncalls renderToString, that takes one parameter. You need to add an extra unused parameter to identify this function\\nas a renderFunction and not a simple React Function Component.\");\n throw error;\n }\n };\n if ((0, isServerRenderResult_1.isServerRenderHash)(reactRenderingResult_1)) {\n renderResult = processServerRenderHash();\n }\n else if ((0, isServerRenderResult_1.isPromise)(reactRenderingResult_1)) {\n renderResult = processPromise();\n }\n else {\n renderResult = processReactElement();\n }\n }\n catch (e) {\n if (throwJsErrors) {\n throw e;\n }\n hasErrors = true;\n renderResult = (0, handleError_1.default)({\n e: e,\n name: name,\n serverSide: true,\n });\n renderingError = e;\n }\n var consoleReplayScript = (0, buildConsoleReplay_1.default)();\n var addRenderingErrors = function (resultObject, renderError) {\n resultObject.renderingError = {\n message: renderError.message,\n stack: renderError.stack,\n };\n };\n if (renderingReturnsPromises) {\n var resolveRenderResult = function () { return __awaiter(_this, void 0, void 0, function () {\n var promiseResult, e_1;\n var _a;\n return __generator(this, function (_b) {\n switch (_b.label) {\n case 0:\n _b.trys.push([0, 2, , 3]);\n _a = {};\n return [4 /*yield*/, renderResult];\n case 1:\n promiseResult = (_a.html = _b.sent(),\n _a.consoleReplayScript = consoleReplayScript,\n _a.hasErrors = hasErrors,\n _a);\n return [3 /*break*/, 3];\n case 2:\n e_1 = _b.sent();\n if (throwJsErrors) {\n throw e_1;\n }\n promiseResult = {\n html: (0, handleError_1.default)({\n e: e_1,\n name: name,\n serverSide: true,\n }),\n consoleReplayScript: consoleReplayScript,\n hasErrors: true,\n };\n renderingError = e_1;\n return [3 /*break*/, 3];\n case 3:\n if (renderingError !== null) {\n addRenderingErrors(promiseResult, renderingError);\n }\n return [2 /*return*/, promiseResult];\n }\n });\n }); };\n return resolveRenderResult();\n }\n var result = {\n html: renderResult,\n consoleReplayScript: consoleReplayScript,\n hasErrors: hasErrors,\n };\n if (renderingError) {\n addRenderingErrors(result, renderingError);\n }\n return JSON.stringify(result);\n}\nexports.default = serverRenderReactComponent;\n","/**\n * @license React\n * react.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';var l=Symbol.for(\"react.element\"),n=Symbol.for(\"react.portal\"),p=Symbol.for(\"react.fragment\"),q=Symbol.for(\"react.strict_mode\"),r=Symbol.for(\"react.profiler\"),t=Symbol.for(\"react.provider\"),u=Symbol.for(\"react.context\"),v=Symbol.for(\"react.forward_ref\"),w=Symbol.for(\"react.suspense\"),x=Symbol.for(\"react.memo\"),y=Symbol.for(\"react.lazy\"),z=Symbol.iterator;function A(a){if(null===a||\"object\"!==typeof a)return null;a=z&&a[z]||a[\"@@iterator\"];return\"function\"===typeof a?a:null}\nvar B={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},C=Object.assign,D={};function E(a,b,e){this.props=a;this.context=b;this.refs=D;this.updater=e||B}E.prototype.isReactComponent={};\nE.prototype.setState=function(a,b){if(\"object\"!==typeof a&&\"function\"!==typeof a&&null!=a)throw Error(\"setState(...): takes an object of state variables to update or a function which returns an object of state variables.\");this.updater.enqueueSetState(this,a,b,\"setState\")};E.prototype.forceUpdate=function(a){this.updater.enqueueForceUpdate(this,a,\"forceUpdate\")};function F(){}F.prototype=E.prototype;function G(a,b,e){this.props=a;this.context=b;this.refs=D;this.updater=e||B}var H=G.prototype=new F;\nH.constructor=G;C(H,E.prototype);H.isPureReactComponent=!0;var I=Array.isArray,J=Object.prototype.hasOwnProperty,K={current:null},L={key:!0,ref:!0,__self:!0,__source:!0};\nfunction M(a,b,e){var d,c={},k=null,h=null;if(null!=b)for(d in void 0!==b.ref&&(h=b.ref),void 0!==b.key&&(k=\"\"+b.key),b)J.call(b,d)&&!L.hasOwnProperty(d)&&(c[d]=b[d]);var g=arguments.length-2;if(1===g)c.children=e;else if(1
>>1,e=a[d];if(0>>1;dg(C,c))ng(x,C)?(a[d]=x,a[n]=c,d=n):(a[d]=C,a[m]=c,d=m);else if(ng(x,c))a[d]=x,a[n]=c,d=n;else break a}}return b}\nfunction g(a,b){var c=a.sortIndex-b.sortIndex;return 0!==c?c:a.id-b.id}if(\"object\"===typeof performance&&\"function\"===typeof performance.now){var l=performance;exports.unstable_now=function(){return l.now()}}else{var p=Date,q=p.now();exports.unstable_now=function(){return p.now()-q}}var r=[],t=[],u=1,v=null,y=3,z=!1,A=!1,B=!1,D=\"function\"===typeof setTimeout?setTimeout:null,E=\"function\"===typeof clearTimeout?clearTimeout:null,F=\"undefined\"!==typeof setImmediate?setImmediate:null;\n\"undefined\"!==typeof navigator&&void 0!==navigator.scheduling&&void 0!==navigator.scheduling.isInputPending&&navigator.scheduling.isInputPending.bind(navigator.scheduling);function G(a){for(var b=h(t);null!==b;){if(null===b.callback)k(t);else if(b.startTime<=a)k(t),b.sortIndex=b.expirationTime,f(r,b);else break;b=h(t)}}function H(a){B=!1;G(a);if(!A)if(null!==h(r))A=!0,I(J);else{var b=h(t);null!==b&&K(H,b.startTime-a)}}\nfunction J(a,b){A=!1;B&&(B=!1,E(L),L=-1);z=!0;var c=y;try{G(b);for(v=h(r);null!==v&&(!(v.expirationTime>b)||a&&!M());){var d=v.callback;if(\"function\"===typeof d){v.callback=null;y=v.priorityLevel;var e=d(v.expirationTime<=b);b=exports.unstable_now();\"function\"===typeof e?v.callback=e:v===h(r)&&k(r);G(b)}else k(r);v=h(r)}if(null!==v)var w=!0;else{var m=h(t);null!==m&&K(H,m.startTime-b);w=!1}return w}finally{v=null,y=c,z=!1}}var N=!1,O=null,L=-1,P=5,Q=-1;\nfunction M(){return exports.unstable_now()-Qa||125d?(a.sortIndex=c,f(t,a),null===h(r)&&a===h(t)&&(B?(E(L),L=-1):B=!0,K(H,c-d))):(a.sortIndex=e,f(r,a),A||z||(A=!0,I(J)));return a};\nexports.unstable_shouldYield=M;exports.unstable_wrapCallback=function(a){var b=y;return function(){var c=y;y=b;try{return a.apply(this,arguments)}finally{y=c}}};\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n module.exports = require('./cjs/scheduler.production.min.js');\n} else {\n module.exports = require('./cjs/scheduler.development.js');\n}\n"],"names":["jqueryUjsInit","$","undefined","rails","error","$document","document","linkClickSelector","buttonClickSelector","inputChangeSelector","formSubmitSelector","formInputClickSelector","disableSelector","enableSelector","requiredInputSelector","fileInputSelector","linkDisableSelector","buttonDisableSelector","csrfToken","attr","csrfParam","CSRFProtection","xhr","token","setRequestHeader","refreshCSRFTokens","val","fire","obj","name","data","event","Event","trigger","result","confirm","message","ajax","options","href","element","isRemote","handleRemote","method","url","withCredentials","dataType","ajaxSettings","is","serializeArray","button","push","serialize","type","beforeSend","settings","accepts","script","success","status","complete","crossDomain","isCrossDomain","xhrFields","originAnchor","createElement","location","urlAnchor","protocol","host","e","handleMethod","link","target","form","metadataInput","hide","append","appendTo","submit","formElements","selector","elements","filter","find","disableFormElements","each","disableFormElement","this","replacement","prop","enableFormElements","enableFormElement","removeData","allowAction","callback","answer","console","log","call","stack","blankInputs","specifiedSelector","nonBlank","input","radiosForNameWithNoneSelected","radioName","foundInputs","requiredInputs","checkedRadioButtonNames","length","add","nonBlankInputs","stopEverything","stopImmediatePropagation","disableElement","html","on","enableElement","off","ajaxPrefilter","originalOptions","window","metaClick","metaKey","ctrlKey","fail","blankRequiredInputs","nonBlankFileInputs","remote","setTimeout","aborted","value","closest","jQuery","module","exports","isFunction","rnothtmlwhite","nonce","rquery","r20","rhash","rantiCache","rheaders","rnoContent","rprotocol","prefilters","transports","allTypes","concat","addToPrefiltersOrTransports","structure","dataTypeExpression","func","i","dataTypes","toLowerCase","match","slice","unshift","inspectPrefiltersOrTransports","jqXHR","inspected","seekingTransport","inspect","selected","_","prefilterOrFactory","dataTypeOrTransport","ajaxExtend","src","key","deep","flatOptions","extend","active","lastModified","etag","isLocal","test","global","processData","async","contentType","text","xml","json","contents","responseFields","converters","String","JSON","parse","parseXML","context","ajaxSetup","ajaxTransport","transport","cacheURL","responseHeadersString","responseHeaders","timeoutTimer","completed","fireGlobals","uncached","s","callbackContext","globalEventContext","nodeType","jquery","deferred","Deferred","completeDeferred","Callbacks","statusCode","requestHeaders","requestHeadersNames","strAbort","readyState","getResponseHeader","exec","join","getAllResponseHeaders","overrideMimeType","mimeType","map","code","always","abort","statusText","finalText","done","promise","replace","param","traditional","toUpperCase","hasContent","indexOf","cache","guid","ifModified","headers","timeout","send","nativeStatusText","responses","isSuccess","response","modified","clearTimeout","ct","finalDataType","firstDataType","shift","ajaxHandleResponses","inArray","conv2","current","conv","tmp","prev","dataFilter","split","throws","state","ajaxConvert","resolveWith","rejectWith","fireWith","getJSON","get","getScript","_i","isPlainObject","oldCallbacks","rjsonp","jsonp","jsonpCallback","pop","expando","originalSettings","callbackName","overwritten","responseContainer","jsonProp","arguments","removeProp","stripAndCollapse","fn","load","params","self","responseText","parseHTML","apply","globalEval","scriptAttrs","charset","scriptCharset","evt","remove","head","appendChild","Date","now","support","XMLHttpRequest","xhrSuccessStatus","xhrSupported","cors","errorCallback","open","username","password","onload","onerror","onabort","ontimeout","onreadystatechange","responseType","binary","access","nodeName","boolHook","attrHandle","expr","removeAttr","elem","ret","hooks","nType","getAttribute","isXMLDoc","attrHooks","bool","set","setAttribute","radioValue","attrNames","removeAttribute","source","getter","isXML","handle","lowercaseName","dataPriv","getClass","classesToArray","Array","isArray","addClass","classNames","cur","curValue","className","finalValue","j","removeClass","toggleClass","stateVal","isValidValue","hasClass","rfocusable","rclickable","propFix","propHooks","tabIndex","tabindex","parseInt","optSelected","parent","parentNode","selectedIndex","opt","checkOn","rreturn","valueIsFunction","valHooks","option","select","index","one","values","max","disabled","optionSet","makeArray","checked","toType","object","flag","createOptions","firing","memory","fired","locked","list","queue","firingIndex","once","stopOnFalse","args","arg","unique","has","splice","empty","disable","lock","arr","getProto","flat","class2type","toString","hasOwn","fnToString","ObjectFunctionString","isWindow","DOMEval","version","rhtmlSuffix","init","isArrayLike","prototype","constructor","toArray","num","pushStack","elems","merge","prevObject","first","eq","last","even","grep","_elem","odd","len","end","sort","copy","copyIsArray","clone","Math","random","isReady","msg","Error","noop","proto","Ctor","isEmptyObject","doc","node","textContent","nodeValue","results","Object","namespace","namespaceURI","docElem","ownerDocument","documentElement","second","invert","matches","callbackExpect","Symbol","iterator","preservedScriptAttributes","noModule","removeChild","chainable","emptyGet","raw","bulk","_key","rmsPrefix","rdashAlpha","fcamelCase","_all","letter","string","rsingleTag","rootjQuery","rquickExpr","root","getElementById","ready","isAttached","contains","composed","getRootNode","buildFragment","keepScripts","createHTMLDocument","base","implementation","scripts","parsed","childNodes","parserErrorElem","DOMParser","parseFromString","getElementsByTagName","el","readyList","removeEventListener","then","catch","readyException","readyWait","wait","doScroll","addEventListener","body","innerHTML","camelCase","rcssNum","rnumnonpx","rcustomProp","cssExpand","getStyles","swap","curCSS","adjustCSS","addGetHookIf","finalPropName","rdisplayswap","cssShow","position","visibility","display","cssNormalTransform","letterSpacing","fontWeight","setPositiveNumber","subtract","boxModelAdjustment","dimension","box","isBorderBox","styles","computedVal","extra","delta","marginDelta","css","ceil","getWidthOrHeight","boxSizingReliable","valueIsBorderBox","offsetProp","reliableTrDimensions","parseFloat","getClientRects","cssHooks","opacity","computed","cssNumber","animationIterationCount","aspectRatio","borderImageSlice","columnCount","flexGrow","flexShrink","gridArea","gridColumn","gridColumnEnd","gridColumnStart","gridRow","gridRowEnd","gridRowStart","lineHeight","order","orphans","scale","widows","zIndex","zoom","fillOpacity","floodOpacity","stopOpacity","strokeMiterlimit","strokeOpacity","cssProps","style","origName","isCustomProp","clearCloneStyle","setProperty","isFinite","getBoundingClientRect","width","scrollboxSizeBuggy","scrollboxSize","marginLeft","reliableMarginLeft","left","margin","padding","border","prefix","suffix","expand","expanded","parts","conditionFn","hookFn","valueParts","tween","adjusted","maxIterations","currentValue","initial","unit","initialInUnit","start","rboxStyle","rtrimCSS","minWidth","maxWidth","getPropertyValue","pixelBoxStyles","cssPrefixes","emptyStyle","vendorProps","final","capName","vendorPropName","pseudos","hidden","visible","offsetWidth","offsetHeight","isHiddenWithinTree","defaultDisplayMap","getDefaultDisplay","temp","showHide","show","toggle","computeStyleTests","div","container","cssText","divStyle","getComputedStyle","pixelPositionVal","top","reliableMarginLeftVal","roundPixelMeasures","right","pixelBoxStylesVal","boxSizingReliableVal","scrollboxSizeVal","measure","round","reliableTrDimensionsVal","backgroundClip","cloneNode","pixelPosition","table","tr","trChild","trStyle","height","borderTopWidth","borderBottomWidth","view","defaultView","opener","RegExp","pnum","old","dataUser","rbrace","rmultiDash","dataAttr","getData","hasData","_data","_removeData","attrs","attributes","acceptData","Data","uid","owner","defineProperty","configurable","Identity","v","Thrower","ex","adoptValue","resolve","reject","noValue","tuples","pipe","fns","newDefer","tuple","returned","progress","notify","onFulfilled","onRejected","onProgress","maxDepth","depth","handler","special","that","mightThrow","TypeError","notifyWith","process","exceptionHook","getErrorHook","getStackHook","stateString","when","singleValue","remaining","resolveContexts","resolveValues","primary","updateFunc","rerrorNames","asyncError","warn","rtrim","proxy","holdReady","hold","parseJSON","isNumeric","isNaN","trim","bind","types","unbind","delegate","undelegate","hover","fnOver","fnOut","mouseenter","mouseleave","Height","Width","content","defaultExtra","funcName","fxNow","inProgress","rfxtypes","rrun","schedule","requestAnimationFrame","fx","interval","tick","createFxNow","genFx","includeWidth","which","createTween","animation","collection","Animation","tweeners","properties","stopped","currentTime","startTime","duration","percent","tweens","run","props","opts","specialEasing","easing","_default","originalProperties","Tween","stop","gotoEnd","propFilter","_queueHooks","timer","anim","tweener","oldfire","propTween","restoreDisplay","isBox","orig","dataShow","unqueued","overflow","overflowX","overflowY","prefilter","prepend","speed","speeds","dequeue","fadeTo","to","animate","optall","doAnimation","finish","clearQueue","stopQueue","timers","cssFn","slideDown","slideUp","slideToggle","fadeIn","fadeOut","fadeToggle","slow","fast","eased","pos","step","scrollTop","scrollLeft","linear","p","swing","cos","PI","animated","rcheckableType","rtypenamespace","returnTrue","returnFalse","origFn","leverageNative","isSetup","saved","isTrigger","delegateType","stopPropagation","preventDefault","isImmediatePropagationStopped","handleObjIn","eventHandle","events","t","handleObj","handlers","namespaces","origType","elemData","matchesSelector","create","triggered","dispatch","bindType","needsContext","delegateCount","setup","mappedTypes","origCount","teardown","removeEvent","nativeEvent","matched","handlerQueue","fix","delegateTarget","preDispatch","isPropagationStopped","currentTarget","rnamespace","postDispatch","sel","matchedHandlers","matchedSelectors","addProp","hook","enumerable","originalEvent","writable","noBubble","click","beforeunload","returnValue","isDefaultPrevented","defaultPrevented","relatedTarget","timeStamp","isSimulated","altKey","bubbles","cancelable","changedTouches","detail","eventPhase","pageX","pageY","shiftKey","charCode","keyCode","buttons","clientX","clientY","offsetX","offsetY","pointerId","pointerType","screenX","screenY","targetTouches","toElement","touches","focus","blur","focusMappedHandler","documentMode","simulate","attaches","dataHolder","pointerenter","pointerleave","related","rfocusMorph","stopPropagationCallback","onlyHandlers","bubbleType","ontype","lastElement","eventPath","parentWindow","triggerHandler","_jQuery","_$","noConflict","noGlobal","rtagName","rscriptType","wrapMap","getAll","setGlobalEval","rnoInnerhtml","rchecked","rcleanScript","manipulationTarget","firstChild","children","disableScript","restoreScript","cloneCopyEvent","dest","l","udataOld","udataCur","fixInput","defaultValue","domManip","ignored","fragment","hasScripts","iNoClone","checkClone","_evalUrl","keepData","nodes","cleanData","htmlPrefilter","dataAndEvents","deepDataAndEvents","srcElements","destElements","inPage","noCloneChecked","detach","insertBefore","before","after","nextSibling","replaceWith","replaceChild","prependTo","insertAfter","replaceAll","original","insert","rhtml","selection","tag","wrap","attached","createDocumentFragment","lastChild","createTextNode","querySelectorAll","refElements","thead","col","td","tbody","tfoot","colgroup","caption","th","optgroup","offset","setOffset","curPosition","curLeft","curCSSTop","curTop","curOffset","curCSSLeft","curElem","using","rect","win","pageYOffset","pageXOffset","offsetParent","parentOffset","scrollTo","startLength","setter","count","defer","delay","time","next","whitespace","preferredDoc","pushNative","Expr","outermostContext","sortInput","hasDuplicate","documentIsHTML","rbuggyQSA","dirruns","classCache","createCache","tokenCache","compilerCache","nonnativeSelectorCache","sortOrder","a","b","booleans","identifier","rwhitespace","rcomma","rleadingCombinator","rdescend","rpseudo","ridentifier","matchExpr","ID","CLASS","TAG","ATTR","PSEUDO","CHILD","rinputs","rheader","rsibling","runescape","funescape","escape","nonHex","high","fromCharCode","unloadHandler","setDocument","inDisabledFieldset","addCombinator","dir","els","seed","m","nid","groups","newSelector","newContext","id","getElementsByClassName","testContext","scope","escapeSelector","tokenize","toSelector","qsaError","keys","cacheLength","markFunction","assert","createInputPseudo","createButtonPseudo","createDisabledPseudo","isDisabled","createPositionalPseudo","argument","matchIndexes","subWindow","webkitMatchesSelector","msMatchesSelector","getById","getElementsByName","disconnectedMatch","cssHas","querySelector","attrId","getAttributeNode","compare","compareDocumentPosition","sortDetached","uniqueSort","duplicates","sortStable","createPseudo","relative","preFilter","excess","unquoted","nodeNameSelector","expectedNodeName","pattern","operator","check","what","_argument","simple","forward","ofType","_context","outerCache","nodeIndex","useCache","diff","pseudo","setFilters","hasOwnProperty","idx","not","matcher","compile","unmatched","lang","elemLang","hash","activeElement","err","safeActiveElement","hasFocus","enabled","header","_matchIndexes","lt","gt","nth","radio","checkbox","file","image","reset","parseOnly","tokens","soFar","preFilters","cached","combinator","skip","checkNonElements","doneName","oldCache","newCache","elementMatcher","matchers","condense","newUnmatched","mapped","setMatcher","postFilter","postFinder","postSelector","matcherOut","preMap","postMap","preexisting","contexts","multipleContexts","matcherIn","matcherFromTokens","checkContext","leadingRelative","implicitRelative","matchContext","matchAnyContext","setMatchers","elementMatchers","bySet","byElement","superMatcher","outermost","matchedCount","setMatched","contextBackup","dirrunsUnique","matcherFromGroupMatchers","compiled","filters","getText","selectors","bup","rcssescape","fcssescape","ch","asCodePoint","charCodeAt","rbracket","rCRLF","rsubmitterTypes","rsubmittable","buildParams","valueOrFunction","encodeURIComponent","siblings","rneedsContext","rparentsprev","guaranteedUnique","sibling","targets","prevAll","addBack","parents","parentsUntil","until","nextAll","nextUntil","prevUntil","contentDocument","reverse","winnow","qualifier","truncate","n","array","getPrototypeOf","item","wrapAll","firstElementChild","wrapInner","htmlIsFunction","unwrap","aa","c","fa","ha","ia","ja","r","d","f","g","acceptsBooleans","attributeName","attributeNamespace","mustUseProperty","propertyName","sanitizeURL","removeEmptyString","forEach","ka","la","xlinkHref","u","borderImageOutset","borderImageWidth","boxFlex","boxFlexGroup","boxOrdinalGroup","columns","flex","flexPositive","flexNegative","flexOrder","gridRowSpan","gridColumnSpan","lineClamp","tabSize","strokeDasharray","strokeDashoffset","strokeWidth","ma","charAt","substring","na","oa","pa","qa","w","insertionMode","selectedValue","sa","Map","ta","x","y","__html","va","A","wa","xa","ya","h","k","q","Children","ua","C","D","za","Ca","Da","stringify","Fa","generateStaticMarkup","B","assign","Ga","for","Ha","Ia","Ja","Ka","La","Ma","Na","Oa","Pa","Qa","Ra","Sa","Ta","Ua","Va","Wa","Xa","displayName","$$typeof","render","_payload","_init","Ya","Za","contextTypes","E","F","_currentValue2","parentValue","$a","ab","bb","cb","G","db","isMounted","enqueueSetState","_reactInternals","enqueueReplaceState","enqueueForceUpdate","eb","updater","contextType","getDerivedStateFromProps","getSnapshotBeforeUpdate","UNSAFE_componentWillMount","componentWillMount","fb","gb","H","clz32","ib","jb","LN2","lb","I","ob","J","K","L","M","N","O","P","Q","pb","memoizedState","qb","rb","sb","tb","delete","action","ub","vb","wb","R","xb","readContext","useContext","useMemo","useReducer","useRef","useState","useInsertionEffect","useLayoutEffect","useCallback","useImperativeHandle","useEffect","useDebugValue","useDeferredValue","useTransition","useId","treeContext","S","idPrefix","useMutableSource","_source","useSyncExternalStore","yb","__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED","ReactCurrentDispatcher","zb","T","Bb","allPendingTasks","pendingRootTasks","pendingTasks","ping","pingedTasks","Cb","blockedBoundary","blockedSegment","abortSet","legacyContext","U","parentFlushed","chunks","formatContext","boundary","lastPushedText","textEmbedded","V","onError","W","onShellError","onFatalError","destination","destroy","fatalError","Db","Eb","childContextTypes","getChildContext","X","Fb","defaultProps","Gb","isReactComponent","fallback","rootSegmentID","forceClientRender","completedSegments","byteSize","fallbackAbortableTasks","Set","errorDigest","Hb","responseState","Y","_defaultValue","ra","ref","Ib","Jb","Kb","Lb","clientRenderedBoundaries","clear","onAllReady","completedRootSegment","onShellReady","completedBoundaries","partialBoundaries","z","Mb","Z","nextSegmentId","placeholderPrefix","Nb","nextSuspenseID","boundaryPrefix","progressiveChunkSize","Ob","segmentPrefix","Aa","Ba","Pb","Qb","startInlineScript","sentCompleteBoundaryFunction","sentCompleteSegmentFunction","bootstrapChunks","errorMessage","errorComponentStack","sentClientRenderFunction","ba","ca","mb","da","nb","ea","Rb","abortableTasks","Sb","Tb","Ab","Ea","identifierPrefix","Infinity","renderToNodeStream","renderToStaticMarkup","renderToStaticNodeStream","renderToString","enqueue","Uint8Array","buffer","subarray","TextEncoder","encode","close","hb","kb","Ub","Vb","Wb","Xb","Yb","Zb","$b","ac","bc","cc","dc","ec","fc","gc","hc","ic","jc","kc","lc","_currentValue","mc","nc","oc","pc","qc","rc","sc","tc","uc","wc","xc","zc","Ac","Bc","Cc","Dc","Ec","Fc","Gc","Hc","Ic","Jc","Kc","Lc","Mc","Oc","Nc","Pc","Qc","Tc","Uc","Sc","Vc","Wc","Xc","Yc","Zc","$c","ad","bd","cd","dd","ed","fd","gd","hd","jd","kd","ld","renderToReadableStream","Promise","Rc","bootstrapScriptContent","bootstrapScripts","bootstrapModules","ReadableStream","pull","cancel","highWaterMark","allReady","signal","reason","setAttributeNS","prepareStackTrace","Reflect","construct","includes","_valueTracker","getOwnPropertyDescriptor","getValue","setValue","stopTracking","defaultChecked","_wrapperState","initialChecked","initialValue","controlled","defaultSelected","dangerouslySetInnerHTML","valueOf","MSApp","execUnsafeLocalFunction","menuitem","area","br","embed","hr","img","keygen","meta","track","wbr","srcElement","correspondingUseElement","stateNode","alternate","return","flags","dehydrated","child","unstable_scheduleCallback","unstable_cancelCallback","unstable_shouldYield","unstable_requestPaint","unstable_now","unstable_getCurrentPriorityLevel","unstable_ImmediatePriority","unstable_UserBlockingPriority","unstable_NormalPriority","unstable_LowPriority","unstable_IdlePriority","pendingLanes","suspendedLanes","pingedLanes","entangledLanes","entanglements","vc","yc","eventTimes","blockedOn","domEventName","eventSystemFlags","targetContainers","priority","isDehydrated","containerInfo","dispatchEvent","ReactCurrentBatchConfig","transition","md","nd","od","pd","qd","rd","_reactName","_targetInst","cancelBubble","persist","isPersistent","wd","xd","yd","sd","isTrusted","ud","vd","Ad","getModifierState","zd","fromElement","movementX","movementY","Bd","Dd","dataTransfer","Fd","Hd","animationName","elapsedTime","pseudoElement","Id","clipboardData","Jd","Ld","Md","Esc","Spacebar","Left","Up","Right","Down","Del","Win","Menu","Apps","Scroll","MozPrintableKey","Nd","Od","Alt","Control","Meta","Shift","Pd","Qd","repeat","locale","Rd","Td","pressure","tangentialPressure","tiltX","tiltY","twist","isPrimary","Vd","Xd","Yd","deltaX","wheelDeltaX","deltaY","wheelDeltaY","wheelDelta","deltaZ","deltaMode","Zd","$d","ae","be","ce","de","ee","fe","ge","he","ie","le","color","date","datetime","email","month","number","range","search","tel","week","me","ne","oe","listeners","pe","qe","re","se","te","ue","ve","we","xe","ye","ze","oninput","Ae","detachEvent","Be","Ce","attachEvent","De","Ee","Fe","He","Ie","Je","Ke","Le","Me","HTMLIFrameElement","contentWindow","Ne","contentEditable","Oe","focusedElem","selectionRange","selectionStart","selectionEnd","min","getSelection","rangeCount","anchorNode","anchorOffset","focusNode","focusOffset","createRange","setStart","removeAllRanges","addRange","setEnd","Pe","Qe","Re","Se","Te","Ue","Ve","We","animationend","animationiteration","animationstart","transitionend","Xe","Ye","Ze","$e","af","bf","cf","df","ef","ff","gf","hf","lf","mf","nf","instance","listener","of","pf","qf","rf","sf","capture","passive","tf","uf","vf","wf","je","char","ke","xf","yf","zf","Af","Bf","Cf","Df","Ef","Ff","Gf","Hf","Jf","queueMicrotask","If","Kf","Lf","Mf","previousSibling","Nf","Of","Pf","Qf","Rf","Sf","Tf","Uf","Vf","Wf","Xf","Yf","__reactInternalMemoizedUnmaskedChildContext","__reactInternalMemoizedMaskedChildContext","Zf","$f","ag","bg","cg","__reactInternalMemoizedMergedChildContext","dg","eg","fg","gg","hg","jg","kg","lg","mg","ng","og","pg","qg","rg","sg","tg","ug","vg","wg","xg","yg","zg","Ag","Bg","elementType","deletions","Cg","pendingProps","retryLane","Dg","mode","Eg","Fg","Gg","memoizedProps","Hg","Ig","Jg","Kg","Lg","Mg","Ng","Og","Pg","Qg","Rg","Sg","childLanes","Tg","dependencies","firstContext","lanes","Ug","Vg","memoizedValue","Wg","Xg","Yg","interleaved","Zg","$g","ah","updateQueue","baseState","firstBaseUpdate","lastBaseUpdate","shared","pending","effects","bh","eventTime","lane","payload","dh","eh","fh","gh","hh","ih","jh","Component","refs","kh","nh","lh","mh","oh","shouldComponentUpdate","isPureReactComponent","ph","qh","componentWillReceiveProps","UNSAFE_componentWillReceiveProps","rh","componentDidMount","sh","_owner","_stringRef","uh","vh","wh","xh","yh","zh","Ah","Bh","Ch","Dh","Eh","Fh","Gh","Hh","Ih","tagName","Jh","Kh","Lh","Mh","revealOrder","Nh","Oh","_workInProgressVersionPrimary","Ph","Qh","Rh","Sh","Th","Uh","Vh","Wh","Xh","Yh","Zh","$h","ai","bi","ci","baseQueue","di","ei","fi","lastRenderedReducer","hasEagerState","eagerState","lastRenderedState","gi","hi","ii","ji","ki","getSnapshot","li","mi","ni","lastEffect","stores","oi","pi","qi","ri","deps","si","ti","ui","vi","wi","xi","yi","zi","Ai","Bi","Ci","Di","Ei","Fi","Gi","Hi","Ii","Ji","unstable_isNewReconciler","Ki","digest","Li","Mi","Ni","WeakMap","Oi","Pi","Qi","Ri","getDerivedStateFromError","componentDidCatch","Si","componentStack","Ti","pingCache","Ui","Vi","Wi","Xi","ReactCurrentOwner","Yi","Zi","$i","aj","bj","cj","dj","ej","baseLanes","cachePool","transitions","fj","gj","hj","ij","jj","UNSAFE_componentWillUpdate","componentWillUpdate","componentDidUpdate","kj","lj","pendingContext","mj","Aj","Bj","Cj","Dj","nj","oj","pj","qj","rj","tj","dataset","dgst","uj","vj","_reactRetry","sj","subtreeFlags","wj","xj","isBackwards","rendering","renderingStartTime","tail","tailMode","yj","Ej","Fj","Gj","wasMultiple","multiple","suppressHydrationWarning","onClick","onclick","size","createElementNS","autoFocus","Hj","Ij","Jj","Kj","Lj","WeakSet","Mj","Nj","Oj","Qj","Rj","Sj","Tj","Uj","Vj","Wj","_reactRootContainer","Xj","Yj","Zj","ak","onCommitFiberUnmount","componentWillUnmount","bk","ck","dk","ek","fk","isHidden","gk","hk","ik","jk","kk","lk","__reactInternalSnapshotBeforeUpdate","Wk","mk","nk","ok","pk","qk","rk","sk","tk","uk","vk","wk","xk","yk","zk","Ak","Bk","Ck","Dk","Ek","callbackNode","expirationTimes","expiredLanes","callbackPriority","ig","Fk","Gk","Hk","Ik","Jk","Kk","Lk","Mk","Nk","Ok","Pk","finishedWork","finishedLanes","Qk","timeoutHandle","Rk","Sk","Tk","Uk","Vk","mutableReadLanes","Pj","onCommitFiberRoot","onRecoverableError","Xk","onPostCommitFiberRoot","Yk","Zk","al","pendingChildren","bl","mutableSourceEagerHydrationData","cl","pendingSuspenseBoundaries","fl","gl","hl","il","jl","zj","$k","ll","reportError","ml","_internalRoot","nl","ol","pl","ql","sl","rl","unmount","unstable_scheduleHydration","tl","usingClientEntryPoint","Events","ul","findFiberByHostInstance","bundleType","rendererPackageName","vl","rendererConfig","overrideHookState","overrideHookStateDeletePath","overrideHookStateRenamePath","overrideProps","overridePropsDeletePath","overridePropsRenamePath","setErrorHandler","setSuspenseHandler","scheduleUpdate","currentDispatcherRef","findHostInstanceByFiber","findHostInstancesForRefresh","scheduleRefresh","scheduleRoot","setRefreshHandler","getCurrentFiber","reconcilerVersion","__REACT_DEVTOOLS_GLOBAL_HOOK__","wl","supportsFiber","inject","createPortal","dl","createRoot","unstable_strictMode","findDOMNode","flushSync","hydrate","hydrateRoot","hydratedSources","_getVersion","unmountComponentAtNode","unstable_batchedUpdates","unstable_renderSubtreeIntoContainer","checkDCE","authenticityToken","HTMLMetaElement","authenticityHeaders","otherHeaders","__importDefault","mod","__esModule","isRenderFunction_1","registeredComponents","register","components","component","renderFunction","default","isRenderer","from","__createBinding","o","k2","desc","__setModuleDefault","__importStar","ClientStartup","handleError_1","ComponentRegistry_1","StoreRegistry_1","serverRenderReactComponent_1","buildConsoleReplay_1","createReactOutput_1","Authenticity_1","context_1","reactHydrateOrRender_1","ctx","DEFAULT_OPTIONS","traceTurbolinks","turbo","ReactOnRails","registerStore","getStore","throwIfMissing","reactHydrateOrRender","domNode","reactElement","setOptions","newOptions","reactOnRailsPageLoaded","getStoreGenerator","setStore","store","clearHydratedStores","domNodeId","componentObj","getComponent","serverRenderReactComponent","handleError","buildConsoleReplay","storeGenerators","resetOptions","clientStartup","wrapInScriptTags","scriptId","scriptBody","registeredStoreGenerators","hydratedStores","storeKeys","consoleReplay","RenderUtils_1","scriptSanitizedVal_1","history","stringifiedList","level","__spreadArray","pack","ar","react_dom_1","isServerRenderResult_1","reactApis_1","REACT_ON_RAILS_STORE_ATTRIBUTE","findContext","debugTurbolinks","turboInstalled","reactOnRailsHtmlElements","initializeStore","railsContext","storeGenerator","domNodeIdForEl","trace","delegateToRenderer","shouldHydrate","reactElementOrRouterResult","isServerRenderHash","rootOrElement","supportsRootApi","roots","parseRailsContext","forEachStore","forEachReactOnRailsComponentRender","info","reactOnRailsPageUnloaded","roots_1","renderInit","Turbolinks","supported","controller","onPageReady","onReadyStateChange","__REACT_ON_RAILS_EVENT_HANDLERS_RAN_ONCE__","react_1","_a","serverSide","renderFunctionResult","isPromise","isValidElement","reactComponent","server_1","jsCode","lastLine","shouldBeRenderFunctionError","handleRenderFunctionIssue","fileName","lineNumber","testValue","renderedHtml","redirectLocation","routeError","reactMajorVersion","reactRender","reactHydrate","reactDomClient","__awaiter","thisArg","_arguments","generator","fulfilled","rejected","__generator","label","sent","trys","ops","verb","op","_this","renderingReturnsPromises","throwJsErrors","renderResult","hasErrors","renderingError","reactRenderingResult_1","redirectPath","pathname","processServerRenderHash","processReactElement","consoleReplayScript","addRenderingErrors","resultObject","renderError","promiseResult","e_1","_b","setState","forceUpdate","__self","__source","_status","_result","only","Fragment","Profiler","PureComponent","StrictMode","Suspense","cloneElement","createContext","_threadCount","Provider","Consumer","_globalName","createFactory","createRef","forwardRef","lazy","memo","startTransition","unstable_act","sortIndex","performance","setImmediate","expirationTime","priorityLevel","navigator","scheduling","isInputPending","MessageChannel","port2","port1","onmessage","postMessage","unstable_Profiling","unstable_continueExecution","unstable_forceFrameRate","floor","unstable_getFirstCallbackNode","unstable_next","unstable_pauseExecution","unstable_runWithPriority","unstable_wrapCallback"],"sourceRoot":""}