gatsby 4.19.0-next.4 → 4.19.2

package/cache-dir/app.js

@@ -1,7 +1,6 @@
 /* global HAS_REACT_18 */
 import React from "react"
 import ReactDOM from "react-dom"
-import io from "socket.io-client"
 
 import socketIo from "./socketIo"
 import emitter from "./emitter"
@@ -40,23 +39,36 @@ loader.setApiRunner(apiRunner)
 
 window.___loader = publicLoader
 
-let reactRender
-let reactHydrate
+let reactFirstRenderOrHydrate
 if (HAS_REACT_18) {
   const reactDomClient = require(`react-dom/client`)
-  reactRender = (Component, el) => {
-    const root = reactDomClient.createRoot(el)
-    root.render(Component)
-    return () => root.unmount()
+  reactFirstRenderOrHydrate = (Component, el) => {
+    // we will use hydrate if mount element has any content inside
+    const useHydrate = el && el.children.length
+
+    if (useHydrate) {
+      const root = reactDomClient.hydrateRoot(el, Component)
+      return () => root.unmount()
+    } else {
+      const root = reactDomClient.createRoot(el)
+      root.render(Component)
+      return () => root.unmount()
+    }
   }
-  reactHydrate = (Component, el) => reactDomClient.hydrateRoot(el, Component)
 } else {
   const reactDomClient = require(`react-dom`)
-  reactRender = (Component, el) => {
-    reactDomClient.render(Component, el)
-    return () => ReactDOM.unmountComponentAtNode(el)
+  reactFirstRenderOrHydrate = (Component, el) => {
+    // we will use hydrate if mount element has any content inside
+    const useHydrate = el && el.children.length
+
+    if (useHydrate) {
+      reactDomClient.hydrate(Component, el)
+      return () => ReactDOM.unmountComponentAtNode(el)
+    } else {
+      reactDomClient.render(Component, el)
+      return () => ReactDOM.unmountComponentAtNode(el)
+    }
   }
-  reactHydrate = reactDomClient.hydrate
 }
 
 // Do dummy dynamic import so the jsonp __webpack_require__.e is added to the commons.js
@@ -80,53 +92,6 @@ apiRunnerAsync(`onClientEntry`).then(() => {
     })
   }
 
-  fetch(`/___services`)
-    .then(res => res.json())
-    .then(services => {
-      if (services.developstatusserver) {
-        let isRestarting = false
-        const parentSocket = io(
-          `${window.location.protocol}//${window.location.hostname}:${services.developstatusserver.port}`
-        )
-
-        parentSocket.on(`structured-log`, msg => {
-          if (
-            !isRestarting &&
-            msg.type === `LOG_ACTION` &&
-            msg.action.type === `DEVELOP` &&
-            msg.action.payload === `RESTART_REQUIRED` &&
-            window.confirm(
-              `The develop process needs to be restarted for the changes to ${msg.action.dirtyFile} to be applied.\nDo you want to restart the develop process now?`
-            )
-          ) {
-            isRestarting = true
-            parentSocket.emit(`develop:restart`, () => {
-              window.location.reload()
-            })
-          }
-
-          if (
-            isRestarting &&
-            msg.type === `LOG_ACTION` &&
-            msg.action.type === `SET_STATUS` &&
-            msg.action.payload === `SUCCESS`
-          ) {
-            isRestarting = false
-            window.location.reload()
-          }
-        })
-
-        // Prevents certain browsers spamming XHR 'ERR_CONNECTION_REFUSED'
-        // errors within the console, such as when exiting the develop process.
-        parentSocket.on(`disconnect`, () => {
-          console.warn(
-            `[socket.io] Disconnected. Unable to perform health-check.`
-          )
-          parentSocket.close()
-        })
-      }
-    })
-
   /**
    * Service Workers are persistent by nature. They stick around,
    * serving a cached version of the site if they aren't removed.
@@ -147,20 +112,10 @@ apiRunnerAsync(`onClientEntry`).then(() => {
   }
 
   const rootElement = document.getElementById(`___gatsby`)
-
-  const focusEl = document.getElementById(`gatsby-focus-wrapper`)
-
-  // Client only pages have any empty body so we just do a normal
-  // render to avoid React complaining about hydration mis-matches.
-  let defaultRenderer = reactRender
-  if (focusEl && focusEl.children.length) {
-    defaultRenderer = reactHydrate
-  }
-
   const renderer = apiRunner(
     `replaceHydrateFunction`,
     undefined,
-    defaultRenderer
+    reactFirstRenderOrHydrate
   )[0]
 
   let dismissLoadingIndicator
@@ -184,7 +139,7 @@ apiRunnerAsync(`onClientEntry`).then(() => {
       if (indicatorMountElement) {
         // If user defined replaceHydrateFunction themselves the cleanupFn return might not be there
         // So fallback to unmountComponentAtNode for now
-        if (cleanupFn) {
+        if (cleanupFn && typeof cleanupFn === `function`) {
           cleanupFn()
         } else {
           ReactDOM.unmountComponentAtNode(indicatorMountElement)

package/cache-dir/commonjs/app.js

@@ -9,8 +9,6 @@ var _react = _interopRequireDefault(require("react"));
 
 var _reactDom = _interopRequireDefault(require("react-dom"));
 
-var _socket = _interopRequireDefault(require("socket.io-client"));
-
 var _socketIo = _interopRequireDefault(require("./socketIo"));
 
 var _emitter = _interopRequireDefault(require("./emitter"));
@@ -52,28 +50,39 @@ const loader = new _devLoader.default(_asyncRequires.default, _matchPaths.defaul
 (0, _loader.setLoader)(loader);
 loader.setApiRunner(_apiRunnerBrowser.apiRunner);
 window.___loader = _loader.publicLoader;
-let reactRender;
-let reactHydrate;
+let reactFirstRenderOrHydrate;
 
 if (HAS_REACT_18) {
   const reactDomClient = require(`react-dom/client`);
 
-  reactRender = (Component, el) => {
-    const root = reactDomClient.createRoot(el);
-    root.render(Component);
-    return () => root.unmount();
-  };
+  reactFirstRenderOrHydrate = (Component, el) => {
+    // we will use hydrate if mount element has any content inside
+    const useHydrate = el && el.children.length;
 
-  reactHydrate = (Component, el) => reactDomClient.hydrateRoot(el, Component);
+    if (useHydrate) {
+      const root = reactDomClient.hydrateRoot(el, Component);
+      return () => root.unmount();
+    } else {
+      const root = reactDomClient.createRoot(el);
+      root.render(Component);
+      return () => root.unmount();
+    }
+  };
 } else {
   const reactDomClient = require(`react-dom`);
 
-  reactRender = (Component, el) => {
-    reactDomClient.render(Component, el);
-    return () => _reactDom.default.unmountComponentAtNode(el);
-  };
+  reactFirstRenderOrHydrate = (Component, el) => {
+    // we will use hydrate if mount element has any content inside
+    const useHydrate = el && el.children.length;
 
-  reactHydrate = reactDomClient.hydrate;
+    if (useHydrate) {
+      reactDomClient.hydrate(Component, el);
+      return () => _reactDom.default.unmountComponentAtNode(el);
+    } else {
+      reactDomClient.render(Component, el);
+      return () => _reactDom.default.unmountComponentAtNode(el);
+    }
+  };
 } // Do dummy dynamic import so the jsonp __webpack_require__.e is added to the commons.js
 // bundle. This ensures hot reloading doesn't break when someone first adds
 // a dynamic import.
@@ -97,32 +106,6 @@ function notCalledFunction() {
       window.location.reload();
     });
   }
-
-  fetch(`/___services`).then(res => res.json()).then(services => {
-    if (services.developstatusserver) {
-      let isRestarting = false;
-      const parentSocket = (0, _socket.default)(`${window.location.protocol}//${window.location.hostname}:${services.developstatusserver.port}`);
-      parentSocket.on(`structured-log`, msg => {
-        if (!isRestarting && msg.type === `LOG_ACTION` && msg.action.type === `DEVELOP` && msg.action.payload === `RESTART_REQUIRED` && window.confirm(`The develop process needs to be restarted for the changes to ${msg.action.dirtyFile} to be applied.\nDo you want to restart the develop process now?`)) {
-          isRestarting = true;
-          parentSocket.emit(`develop:restart`, () => {
-            window.location.reload();
-          });
-        }
-
-        if (isRestarting && msg.type === `LOG_ACTION` && msg.action.type === `SET_STATUS` && msg.action.payload === `SUCCESS`) {
-          isRestarting = false;
-          window.location.reload();
-        }
-      }); // Prevents certain browsers spamming XHR 'ERR_CONNECTION_REFUSED'
-      // errors within the console, such as when exiting the develop process.
-
-      parentSocket.on(`disconnect`, () => {
-        console.warn(`[socket.io] Disconnected. Unable to perform health-check.`);
-        parentSocket.close();
-      });
-    }
-  });
   /**
    * Service Workers are persistent by nature. They stick around,
    * serving a cached version of the site if they aren't removed.
@@ -132,6 +115,7 @@ function notCalledFunction() {
    * Let's warn if we find service workers in development.
    */
 
+
   if (`serviceWorker` in navigator) {
     navigator.serviceWorker.getRegistrations().then(registrations => {
       if (registrations.length > 0) console.warn(`Warning: found one or more service workers present.`, `If your site isn't behaving as expected, you might want to remove these.`, registrations);
@@ -139,16 +123,7 @@ function notCalledFunction() {
   }
 
   const rootElement = document.getElementById(`___gatsby`);
-  const focusEl = document.getElementById(`gatsby-focus-wrapper`); // Client only pages have any empty body so we just do a normal
-  // render to avoid React complaining about hydration mis-matches.
-
-  let defaultRenderer = reactRender;
-
-  if (focusEl && focusEl.children.length) {
-    defaultRenderer = reactHydrate;
-  }
-
-  const renderer = (0, _apiRunnerBrowser.apiRunner)(`replaceHydrateFunction`, undefined, defaultRenderer)[0];
+  const renderer = (0, _apiRunnerBrowser.apiRunner)(`replaceHydrateFunction`, undefined, reactFirstRenderOrHydrate)[0];
   let dismissLoadingIndicator;
 
   if (process.env.GATSBY_EXPERIMENTAL_QUERY_ON_DEMAND && process.env.GATSBY_QUERY_ON_DEMAND_LOADING_INDICATOR === `true`) {
@@ -166,7 +141,7 @@ function notCalledFunction() {
       if (indicatorMountElement) {
         // If user defined replaceHydrateFunction themselves the cleanupFn return might not be there
         // So fallback to unmountComponentAtNode for now
-        if (cleanupFn) {
+        if (cleanupFn && typeof cleanupFn === `function`) {
           cleanupFn();
         } else {
           _reactDom.default.unmountComponentAtNode(indicatorMountElement);

package/cache-dir/commonjs/dev-loader.js

@@ -16,8 +16,6 @@ var _normalizePagePath = _interopRequireDefault(require("./normalize-page-path")
 var _isEqual = _interopRequireDefault(require("lodash/isEqual"));
 
 // TODO move away from lodash
-const preferDefault = m => m && m.default || m;
-
 function mergePageEntry(cachedPage, newPageData) {
   return { ...cachedPage,
     payload: { ...cachedPage.payload,
@@ -36,12 +34,12 @@ function mergePageEntry(cachedPage, newPageData) {
 
 class DevLoader extends _loader.BaseLoader {
   constructor(asyncRequires, matchPaths) {
-    const loadComponent = chunkName => {
-      if (!this.asyncRequires.components[chunkName]) {
+    const loadComponent = (chunkName, exportType = `components`) => {
+      if (!this.asyncRequires[exportType][chunkName]) {
         throw new Error(`We couldn't find the correct component chunk with the name "${chunkName}"`);
       }
 
-      return this.asyncRequires.components[chunkName]().then(preferDefault) // loader will handle the case when component is error
+      return this.asyncRequires[exportType][chunkName]() // loader will handle the case when component is error
       .catch(err => err);
     };
 

package/cache-dir/commonjs/fast-refresh-overlay/components/runtime-errors.js

@@ -32,12 +32,14 @@ function WrappedAccordionItem({
   const stacktrace = _stackTrace.default.parse(error);
 
   const codeFrameInformation = (0, _utils.getCodeFrameInformation)(stacktrace);
-  const filePath = codeFrameInformation === null || codeFrameInformation === void 0 ? void 0 : codeFrameInformation.moduleId;
+  const modulePath = codeFrameInformation === null || codeFrameInformation === void 0 ? void 0 : codeFrameInformation.moduleId;
   const lineNumber = codeFrameInformation === null || codeFrameInformation === void 0 ? void 0 : codeFrameInformation.lineNumber;
   const columnNumber = codeFrameInformation === null || codeFrameInformation === void 0 ? void 0 : codeFrameInformation.columnNumber;
-  const name = codeFrameInformation === null || codeFrameInformation === void 0 ? void 0 : codeFrameInformation.functionName;
+  const name = codeFrameInformation === null || codeFrameInformation === void 0 ? void 0 : codeFrameInformation.functionName; // With the introduction of Metadata management the modulePath can have a resourceQuery that needs to be removed first
+
+  const filePath = modulePath.replace(/\?export=(default|head)$/, ``);
   const res = (0, _hooks.useStackFrame)({
-    moduleId: filePath,
+    moduleId: modulePath,
     lineNumber,
     columnNumber
   });

package/cache-dir/commonjs/head/components/fire-callback-in-effect.js

@@ -0,0 +1,19 @@
+"use strict";
+
+exports.__esModule = true;
+exports.FireCallbackInEffect = FireCallbackInEffect;
+
+var _react = require("react");
+
+/*
+ * Calls callback in an effect and renders children
+ */
+function FireCallbackInEffect({
+  children,
+  callback
+}) {
+  (0, _react.useEffect)(() => {
+    callback();
+  });
+  return children;
+}

package/cache-dir/commonjs/head/constants.js

@@ -0,0 +1,6 @@
+"use strict";
+
+exports.__esModule = true;
+exports.VALID_NODE_NAMES = void 0;
+const VALID_NODE_NAMES = [`link`, `meta`, `style`, `title`, `base`, `noscript`, `script`];
+exports.VALID_NODE_NAMES = VALID_NODE_NAMES;

package/cache-dir/commonjs/head/head-export-handler-for-browser.js

@@ -0,0 +1,106 @@
+"use strict";
+
+exports.__esModule = true;
+exports.headHandlerForBrowser = headHandlerForBrowser;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _gatsby = require("gatsby");
+
+var _reachRouter = require("@gatsbyjs/reach-router");
+
+var _reactDomUtils = require("../react-dom-utils");
+
+var _fireCallbackInEffect = require("./components/fire-callback-in-effect");
+
+var _constants = require("./constants");
+
+var _utils = require("./utils");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const hiddenRoot = document.createElement(`div`);
+
+const removePrevHeadElements = () => {
+  const prevHeadNodes = [...document.querySelectorAll(`[data-gatsby-head]`)];
+  prevHeadNodes.forEach(e => e.remove());
+};
+
+const onHeadRendered = () => {
+  const validHeadNodes = [];
+  removePrevHeadElements();
+  const seenIds = new Map();
+
+  for (const node of hiddenRoot.childNodes) {
+    var _node$attributes$id;
+
+    const nodeName = node.nodeName.toLowerCase();
+    const id = (_node$attributes$id = node.attributes.id) === null || _node$attributes$id === void 0 ? void 0 : _node$attributes$id.value;
+
+    if (!_constants.VALID_NODE_NAMES.includes(nodeName)) {
+      (0, _utils.warnForInvalidTags)(nodeName);
+    } else {
+      const clonedNode = node.cloneNode(true);
+      clonedNode.setAttribute(`data-gatsby-head`, true);
+
+      if (id) {
+        if (!seenIds.has(id)) {
+          validHeadNodes.push(clonedNode);
+          seenIds.set(id, validHeadNodes.length - 1);
+        } else {
+          const indexOfPreviouslyInsertedNode = seenIds.get(id);
+          validHeadNodes[indexOfPreviouslyInsertedNode].remove();
+          validHeadNodes[indexOfPreviouslyInsertedNode] = clonedNode;
+        }
+      } else {
+        validHeadNodes.push(clonedNode);
+      }
+    }
+  }
+
+  document.head.append(...validHeadNodes);
+};
+
+if (process.env.BUILD_STAGE === `develop`) {
+  // We set up observer to be able to regenerate <head> after react-refresh
+  // updates our hidden element.
+  const observer = new MutationObserver(onHeadRendered);
+  observer.observe(hiddenRoot, {
+    attributes: true,
+    childList: true,
+    characterData: true,
+    subtree: true
+  });
+}
+
+function headHandlerForBrowser({
+  pageComponent,
+  staticQueryResults,
+  pageComponentProps
+}) {
+  (0, _react.useEffect)(() => {
+    if (pageComponent !== null && pageComponent !== void 0 && pageComponent.Head) {
+      (0, _utils.headExportValidator)(pageComponent.Head);
+      const {
+        render
+      } = (0, _reactDomUtils.reactDOMUtils)();
+      const Head = pageComponent.Head;
+      render(
+      /*#__PURE__*/
+      // just a hack to call the callback after react has done first render
+      // Note: In dev, we call onHeadRendered twice( in FireCallbackInEffect and after mutualution observer dectects initail render into hiddenRoot) this is for hot reloading
+      // In Prod we only call onHeadRendered in FireCallbackInEffect to render to head
+      _react.default.createElement(_fireCallbackInEffect.FireCallbackInEffect, {
+        callback: onHeadRendered
+      }, /*#__PURE__*/_react.default.createElement(_gatsby.StaticQueryContext.Provider, {
+        value: staticQueryResults
+      }, /*#__PURE__*/_react.default.createElement(_reachRouter.LocationProvider, null, /*#__PURE__*/_react.default.createElement(Head, (0, _utils.filterHeadProps)(pageComponentProps))))), hiddenRoot);
+    }
+
+    return () => {
+      removePrevHeadElements();
+    };
+  });
+}

package/cache-dir/commonjs/head/head-export-handler-for-ssr.js

@@ -0,0 +1,129 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.headHandlerForSSR = headHandlerForSSR;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+const React = require(`react`);
+
+const {
+  grabMatchParams
+} = require(`../find-path`);
+
+const {
+  createElement
+} = require(`react`);
+
+const {
+  StaticQueryContext
+} = require(`gatsby`);
+
+const {
+  headExportValidator,
+  filterHeadProps,
+  warnForInvalidTags
+} = require(`./utils`);
+
+const {
+  ServerLocation,
+  Router
+} = require(`@gatsbyjs/reach-router`);
+
+const {
+  renderToString
+} = require(`react-dom/server`);
+
+const {
+  parse
+} = require(`node-html-parser`);
+
+const {
+  VALID_NODE_NAMES
+} = require(`./constants`);
+
+function headHandlerForSSR({
+  pageComponent,
+  setHeadComponents,
+  staticQueryContext,
+  pageData,
+  pagePath
+}) {
+  if (pageComponent !== null && pageComponent !== void 0 && pageComponent.Head) {
+    headExportValidator(pageComponent.Head);
+
+    function HeadRouteHandler(props) {
+      var _pageData$result, _pageData$result$page;
+
+      const _props = { ...props,
+        ...pageData.result,
+        params: { ...grabMatchParams(props.location.pathname),
+          ...(((_pageData$result = pageData.result) === null || _pageData$result === void 0 ? void 0 : (_pageData$result$page = _pageData$result.pageContext) === null || _pageData$result$page === void 0 ? void 0 : _pageData$result$page.__params) || {})
+        }
+      };
+      return createElement(pageComponent.Head, filterHeadProps(_props));
+    }
+
+    const routerElement = /*#__PURE__*/React.createElement(StaticQueryContext.Provider, {
+      value: staticQueryContext
+    }, /*#__PURE__*/React.createElement(ServerLocation, {
+      url: `${__BASE_PATH__}${pagePath}`
+    }, /*#__PURE__*/React.createElement(Router, {
+      baseuri: __BASE_PATH__,
+      component: ({
+        children
+      }) => /*#__PURE__*/React.createElement(React.Fragment, null, children)
+    }, /*#__PURE__*/React.createElement(HeadRouteHandler, {
+      path: "/*"
+    })))); // extract head nodes from string
+
+    const rawString = renderToString(routerElement);
+    const headNodes = parse(rawString).childNodes;
+    const validHeadNodes = [];
+    const seenIds = new Map();
+
+    for (const node of headNodes) {
+      const {
+        rawTagName
+      } = node;
+      const id = node.attributes.id;
+
+      if (!VALID_NODE_NAMES.includes(rawTagName)) {
+        warnForInvalidTags(rawTagName);
+      } else {
+        let element;
+        const attributes = { ...node.attributes,
+          "data-gatsby-head": true
+        };
+
+        if (rawTagName === `script`) {
+          element = /*#__PURE__*/React.createElement("script", (0, _extends2.default)({}, attributes, {
+            dangerouslySetInnerHTML: {
+              __html: node.text
+            }
+          }));
+        } else {
+          var _node$childNodes$;
+
+          element = /*#__PURE__*/React.createElement(node.rawTagName, attributes, (_node$childNodes$ = node.childNodes[0]) === null || _node$childNodes$ === void 0 ? void 0 : _node$childNodes$.textContent);
+        }
+
+        if (id) {
+          if (!seenIds.has(id)) {
+            validHeadNodes.push(element);
+            seenIds.set(id, validHeadNodes.length - 1);
+          } else {
+            const indexOfPreviouslyInsertedNode = seenIds.get(id);
+            validHeadNodes[indexOfPreviouslyInsertedNode] = element;
+          }
+        } else {
+          validHeadNodes.push(element);
+        }
+      }
+    }
+
+    setHeadComponents(validHeadNodes);
+  }
+}

package/cache-dir/commonjs/head/utils.js

@@ -0,0 +1,61 @@
+"use strict";
+
+exports.__esModule = true;
+exports.filterHeadProps = filterHeadProps;
+exports.headExportValidator = headExportValidator;
+exports.warnForInvalidTags = warnForInvalidTags;
+
+var _constants = require("./constants");
+
+/**
+ * Filter the props coming from a page down to just the ones that are relevant for head.
+ * This e.g. filters out properties that are undefined during SSR.
+ */
+function filterHeadProps(input) {
+  return {
+    location: {
+      pathname: input.location.pathname
+    },
+    params: input.params,
+    data: input.data || {},
+    pageContext: input.pageContext
+  };
+}
+/**
+ * Throw error if Head export is not a valid
+ */
+
+
+function headExportValidator(head) {
+  if (typeof head !== `function`) throw new Error(`Expected "Head" export to be a function got "${typeof head}".`);
+}
+/**
+ * Warn once for same messsage
+ */
+
+
+let warnOnce = _ => {};
+
+if (process.env.NODE_ENV !== `production`) {
+  const warnings = new Set();
+
+  warnOnce = msg => {
+    if (!warnings.has(msg)) {
+      console.warn(msg);
+    }
+
+    warnings.add(msg);
+  };
+}
+/**
+ * Warn for invalid tags in head.
+ * @param {string} tagName
+ */
+
+
+function warnForInvalidTags(tagName) {
+  if (process.env.NODE_ENV !== `production`) {
+    const warning = `<${tagName}> is not a valid head element. Please use one of the following: ${_constants.VALID_NODE_NAMES.join(`, `)}`;
+    warnOnce(warning);
+  }
+}