up n_m

node_modules/react-helmet-async/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2018 The New York Times Company
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

node_modules/react-helmet-async/README.md

@@ -0,0 +1,204 @@
+# react-helmet-async
+
+[![CircleCI](https://circleci.com/gh/staylor/react-helmet-async.svg?style=svg)](https://circleci.com/gh/staylor/react-helmet-async)
+
+[Announcement post on Times Open blog](https://open.nytimes.com/the-future-of-meta-tag-management-for-modern-react-development-ec26a7dc9183)
+
+This package is a fork of [React Helmet](https://github.com/nfl/react-helmet).
+`<Helmet>` usage is synonymous, but server and client now requires `<HelmetProvider>` to encapsulate state per request.
+
+`react-helmet` relies on `react-side-effect`, which is not thread-safe. If you are doing anything asynchronous on the server, you need Helmet to encapsulate data on a per-request basis, this package does just that.
+
+## Usage
+
+**New is 1.0.0:** No more default export! `import { Helmet } from 'react-helmet-async'`
+
+The main way that this package differs from `react-helmet` is that it requires using a Provider to encapsulate Helmet state for your React tree. If you use libraries like Redux or Apollo, you are already familiar with this paradigm:
+
+```javascript
+import React from 'react';
+import ReactDOM from 'react-dom';
+import { Helmet, HelmetProvider } from 'react-helmet-async';
+
+const app = (
+  <HelmetProvider>
+    <App>
+      <Helmet>
+        <title>Hello World</title>
+        <link rel="canonical" href="https://www.tacobell.com/" />
+      </Helmet>
+      <h1>Hello World</h1>
+    </App>
+  </HelmetProvider>
+);
+
+ReactDOM.hydrate(
+  app,
+  document.getElementById(‘app’)
+);
+```
+
+On the server, we will no longer use static methods to extract state. `react-side-effect`
+exposed a `.rewind()` method, which Helmet used when calling `Helmet.renderStatic()`. Instead, we are going
+to pass a `context` prop to `HelmetProvider`, which will hold our state specific to each request.
+
+```javascript
+import React from 'react';
+import { renderToString } from 'react-dom/server';
+import { Helmet, HelmetProvider } from 'react-helmet-async';
+
+const helmetContext = {};
+
+const app = (
+  <HelmetProvider context={helmetContext}>
+    <App>
+      <Helmet>
+        <title>Hello World</title>
+        <link rel="canonical" href="https://www.tacobell.com/" />
+      </Helmet>
+      <h1>Hello World</h1>
+    </App>
+  </HelmetProvider>
+);
+
+const html = renderToString(app);
+
+const { helmet } = helmetContext;
+
+// helmet.title.toString() etc…
+```
+
+## Streams
+
+This package only works with streaming if your `<head>` data is output outside of `renderToNodeStream()`.
+This is possible if your data hydration method already parses your React tree. Example:
+
+```javascript
+import through from 'through';
+import { renderToNodeStream } from 'react-dom/server';
+import { getDataFromTree } from 'react-apollo';
+import { Helmet, HelmetProvider } from 'react-helmet-async';
+import template from 'server/template';
+
+const helmetContext = {};
+
+const app = (
+  <HelmetProvider context={helmetContext}>
+    <App>
+      <Helmet>
+        <title>Hello World</title>
+        <link rel="canonical" href="https://www.tacobell.com/" />
+      </Helmet>
+      <h1>Hello World</h1>
+    </App>
+  </HelmetProvider>
+);
+
+await getDataFromTree(app);
+
+const [header, footer] = template({
+  helmet: helmetContext.helmet,
+});
+
+res.status(200);
+res.write(header);
+renderToNodeStream(app)
+  .pipe(
+    through(
+      function write(data) {
+        this.queue(data);
+      },
+      function end() {
+        this.queue(footer);
+        this.queue(null);
+      }
+    )
+  )
+  .pipe(res);
+```
+
+## Usage in Jest
+While testing in using jest, if there is a need to emulate SSR, the following string is required to have the test behave the way they are expected to.
+
+```javascript
+import { HelmetProvider } from 'react-helmet-async';
+
+HelmetProvider.canUseDOM = false;
+```
+
+## Prioritizing tags for SEO
+
+It is understood that in some cases for SEO, certain tags should appear earlier in the HEAD. Using the `prioritizeSeoTags` flag on any `<Helmet>` component allows the server render of react-helmet-async to expose a method for prioritizing relevant SEO tags.
+
+In the component:
+```javascript
+<Helmet prioritizeSeoTags>
+  <title>A fancy webpage</title>
+  <link rel="notImportant" href="https://www.chipotle.com" />
+  <meta name="whatever" value="notImportant" />
+  <link rel="canonical" href="https://www.tacobell.com" />
+  <meta property="og:title" content="A very important title"/>
+</Helmet>
+```
+
+In your server template:
+
+```javascript
+<html>
+  <head>
+    ${helmet.title.toString()}
+    ${helmet.priority.toString()}
+    ${helmet.meta.toString()}
+    ${helmet.link.toString()}
+    ${helmet.script.toString()}
+  </head>
+  ...
+</html>
+```
+
+Will result in:
+
+```html
+<html>
+  <head>
+    <title>A fancy webpage</title>
+    <meta property="og:title" content="A very important title"/>
+    <link rel="canonical" href="https://www.tacobell.com" />
+    <meta name="whatever" value="notImportant" />
+    <link rel="notImportant" href="https://www.chipotle.com" />
+  </head>
+  ...
+</html>
+```
+
+A list of prioritized tags and attributes can be found in [constants.js](./src/constants.js).
+
+## Usage without Context
+You can optionally use `<Helmet>` outside a context by manually creating a stateful `HelmetData` instance, and passing that stateful object to each `<Helmet>` instance:
+
+
+```js
+import React from 'react';
+import { renderToString } from 'react-dom/server';
+import { Helmet, HelmetProvider, HelmetData } from 'react-helmet-async';
+
+const helmetData = new HelmetData({});
+
+const app = (
+    <App>
+      <Helmet helmetData={helmetData}>
+        <title>Hello World</title>
+        <link rel="canonical" href="https://www.tacobell.com/" />
+      </Helmet>
+      <h1>Hello World</h1>
+    </App>
+);
+
+const html = renderToString(app);
+
+const { helmet } = helmetData.context;
+```
+
+## License
+
+Licensed under the Apache 2.0 License, Copyright © 2018 Scott Taylor

node_modules/react-helmet-async/index.d.ts

@@ -0,0 +1,95 @@
+declare module 'react-helmet-async' {
+  import * as React from 'react';
+
+  interface OtherElementAttributes {
+    [key: string]: string | number | boolean | null | undefined;
+  }
+
+  type HtmlProps = JSX.IntrinsicElements['html'] & OtherElementAttributes;
+
+  type BodyProps = JSX.IntrinsicElements['body'] & OtherElementAttributes;
+
+  type LinkProps = JSX.IntrinsicElements['link'];
+
+  type MetaProps = JSX.IntrinsicElements['meta'];
+
+  export interface HelmetTags {
+    baseTag: Array<any>;
+    linkTags: Array<HTMLLinkElement>;
+    metaTags: Array<HTMLMetaElement>;
+    noscriptTags: Array<any>;
+    scriptTags: Array<HTMLScriptElement>;
+    styleTags: Array<HTMLStyleElement>;
+  }
+
+  export interface HelmetProps {
+    async?: boolean;
+    base?: any;
+    bodyAttributes?: BodyProps;
+    defaultTitle?: string;
+    defer?: boolean;
+    encodeSpecialCharacters?: boolean;
+    helmetData?: HelmetData;
+    htmlAttributes?: HtmlProps;
+    onChangeClientState?: (newState: any, addedTags: HelmetTags, removedTags: HelmetTags) => void;
+    link?: LinkProps[];
+    meta?: MetaProps[];
+    noscript?: Array<any>;
+    script?: Array<any>;
+    style?: Array<any>;
+    title?: string;
+    titleAttributes?: Object;
+    titleTemplate?: string;
+    prioritizeSeoTags?: boolean;
+  }
+
+  export class Helmet extends React.Component<React.PropsWithChildren<HelmetProps>> {}
+
+  export interface HelmetServerState {
+    base: HelmetDatum;
+    bodyAttributes: HelmetHTMLBodyDatum;
+    htmlAttributes: HelmetHTMLElementDatum;
+    link: HelmetDatum;
+    meta: HelmetDatum;
+    noscript: HelmetDatum;
+    script: HelmetDatum;
+    style: HelmetDatum;
+    title: HelmetDatum;
+    titleAttributes: HelmetDatum;
+    priority: HelmetDatum;
+  }
+
+  export interface HelmetDatum {
+    toString(): string;
+    toComponent(): React.Component<any>;
+  }
+
+  export interface HelmetHTMLBodyDatum {
+    toString(): string;
+    toComponent(): React.HTMLAttributes<HTMLBodyElement>;
+  }
+
+  export interface HelmetHTMLElementDatum {
+    toString(): string;
+    toComponent(): React.HTMLAttributes<HTMLHtmlElement>;
+  }
+
+  export interface FilledContext {
+    helmet: HelmetServerState;
+  }
+
+  interface ProviderProps {
+    context?: {};
+  }
+
+  export class HelmetData {
+    constructor(context: any);
+    context: {
+      helmet: HelmetServerState;
+    };
+  }
+
+  export class HelmetProvider extends React.Component<React.PropsWithChildren<ProviderProps>> {
+    static canUseDOM: boolean;
+  }
+}

node_modules/react-helmet-async/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "react-helmet-async",
+  "version": "1.3.0",
+  "description": "Thread-safe Helmet for React 16+ and friends",
+  "main": "lib/index.js",
+  "umd:main": "lib/index.umd.js",
+  "module": "lib/index.module.js",
+  "source": "src/index.js",
+  "types": "index.d.ts",
+  "repository": "http://github.com/staylor/react-helmet-async",
+  "author": "Scott Taylor <scott.c.taylor@mac.com>",
+  "license": "Apache-2.0",
+  "files": [
+    "lib/",
+    "src/",
+    "index.d.ts"
+  ],
+  "dependencies": {
+    "@babel/runtime": "^7.12.5",
+    "invariant": "^2.2.4",
+    "prop-types": "^15.7.2",
+    "react-fast-compare": "^3.2.0",
+    "shallowequal": "^1.1.0"
+  },
+  "devDependencies": {
+    "@babel/cli": "7.17.6",
+    "@babel/core": "7.17.9",
+    "@babel/eslint-parser": "7.17.0",
+    "@babel/eslint-plugin": "7.17.7",
+    "@commitlint/cli": "16.2.3",
+    "@commitlint/config-conventional": "16.2.1",
+    "babel-preset-kyt-react": "1.3.18",
+    "enzyme": "3.11.0",
+    "enzyme-adapter-react-16": "1.15.6",
+    "enzyme-to-json": "3.6.2",
+    "eslint": "7.32.0",
+    "eslint-config-airbnb": "18.2.1",
+    "eslint-config-kyt": "1.6.2",
+    "eslint-config-prettier": "8.3.0",
+    "eslint-plugin-import": "2.24.1",
+    "eslint-plugin-jest": "26.1.4",
+    "eslint-plugin-jest-formatting": "3.0.0",
+    "eslint-plugin-json": "3.1.0",
+    "eslint-plugin-jsx-a11y": "6.4.1",
+    "eslint-plugin-prettier": "3.4.1",
+    "eslint-plugin-react": "7.24.0",
+    "eslint-plugin-react-hooks": "4.2.0",
+    "husky": "7.0.4",
+    "jest": "27.5.1",
+    "jsdom": "16.4.0",
+    "microbundle": "0.14.2",
+    "prettier": "2.6.2",
+    "raf": "3.4.1",
+    "react": "16.14.0",
+    "react-dom": "16.14.0",
+    "rimraf": "3.0.2"
+  },
+  "peerDependencies": {
+    "react": "^16.6.0 || ^17.0.0 || ^18.0.0",
+    "react-dom": "^16.6.0 || ^17.0.0 || ^18.0.0"
+  },
+  "scripts": {
+    "clean": "rimraf lib",
+    "lint": "eslint . --report-unused-disable-directives",
+    "lint-fix": "eslint . --fix",
+    "test": "NODE_ENV=test BABEL_ENV=test jest",
+    "test-watch": "yarn test --watch",
+    "test-update": "yarn test -u",
+    "compile": "yarn run clean && KYT_ENV_TYPE=client NODE_ENV=production microbundle --generateTypes=false --jsx React.createElement",
+    "prepare": "yarn compile && husky install"
+  }
+}

node_modules/react-helmet-async/src/Dispatcher.js

@@ -0,0 +1,69 @@
+import { Component } from 'react';
+import shallowEqual from 'shallowequal';
+import handleStateChangeOnClient from './client';
+import mapStateOnServer from './server';
+import { reducePropsToState } from './utils';
+import Provider, { providerShape } from './Provider';
+
+export default class Dispatcher extends Component {
+  static propTypes = {
+    context: providerShape.isRequired,
+  };
+
+  static displayName = 'HelmetDispatcher';
+
+  rendered = false;
+
+  shouldComponentUpdate(nextProps) {
+    return !shallowEqual(nextProps, this.props);
+  }
+
+  componentDidUpdate() {
+    this.emitChange();
+  }
+
+  componentWillUnmount() {
+    const { helmetInstances } = this.props.context;
+    helmetInstances.remove(this);
+    this.emitChange();
+  }
+
+  emitChange() {
+    const { helmetInstances, setHelmet } = this.props.context;
+    let serverState = null;
+    const state = reducePropsToState(
+      helmetInstances.get().map(instance => {
+        const props = { ...instance.props };
+        delete props.context;
+        return props;
+      })
+    );
+    if (Provider.canUseDOM) {
+      handleStateChangeOnClient(state);
+    } else if (mapStateOnServer) {
+      serverState = mapStateOnServer(state);
+    }
+    setHelmet(serverState);
+  }
+
+  // componentWillMount will be deprecated
+  // for SSR, initialize on first render
+  // constructor is also unsafe in StrictMode
+  init() {
+    if (this.rendered) {
+      return;
+    }
+
+    this.rendered = true;
+
+    const { helmetInstances } = this.props.context;
+    helmetInstances.add(this);
+    this.emitChange();
+  }
+
+  render() {
+    this.init();
+
+    return null;
+  }
+}

node_modules/react-helmet-async/src/HelmetData.js

@@ -0,0 +1,48 @@
+import mapStateOnServer from './server';
+
+const instances = [];
+
+export function clearInstances() {
+  instances.length = 0;
+}
+
+export default class HelmetData {
+  instances = [];
+
+  value = {
+    setHelmet: serverState => {
+      this.context.helmet = serverState;
+    },
+    helmetInstances: {
+      get: () => (this.canUseDOM ? instances : this.instances),
+      add: instance => {
+        (this.canUseDOM ? instances : this.instances).push(instance);
+      },
+      remove: instance => {
+        const index = (this.canUseDOM ? instances : this.instances).indexOf(instance);
+        (this.canUseDOM ? instances : this.instances).splice(index, 1);
+      },
+    },
+  };
+
+  constructor(context, canUseDOM = typeof document !== 'undefined') {
+    this.context = context;
+    this.canUseDOM = canUseDOM;
+
+    if (!canUseDOM) {
+      context.helmet = mapStateOnServer({
+        baseTag: [],
+        bodyAttributes: {},
+        encodeSpecialCharacters: true,
+        htmlAttributes: {},
+        linkTags: [],
+        metaTags: [],
+        noscriptTags: [],
+        scriptTags: [],
+        styleTags: [],
+        title: '',
+        titleAttributes: {},
+      });
+    }
+  }
+}

node_modules/react-helmet-async/src/Provider.js

@@ -0,0 +1,45 @@
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import HelmetData from './HelmetData';
+
+const defaultValue = {};
+
+export const Context = React.createContext(defaultValue);
+
+export const providerShape = PropTypes.shape({
+  setHelmet: PropTypes.func,
+  helmetInstances: PropTypes.shape({
+    get: PropTypes.func,
+    add: PropTypes.func,
+    remove: PropTypes.func,
+  }),
+});
+
+const canUseDOM = typeof document !== 'undefined';
+
+export default class Provider extends Component {
+  static canUseDOM = canUseDOM;
+
+  static propTypes = {
+    context: PropTypes.shape({
+      helmet: PropTypes.shape(),
+    }),
+    children: PropTypes.node.isRequired,
+  };
+
+  static defaultProps = {
+    context: {},
+  };
+
+  static displayName = 'HelmetProvider';
+
+  constructor(props) {
+    super(props);
+
+    this.helmetData = new HelmetData(this.props.context, Provider.canUseDOM);
+  }
+
+  render() {
+    return <Context.Provider value={this.helmetData.value}>{this.props.children}</Context.Provider>;
+  }
+}

node_modules/react-helmet-async/src/client.js

@@ -0,0 +1,176 @@
+import { HELMET_ATTRIBUTE, TAG_NAMES, TAG_PROPERTIES } from './constants';
+import { flattenArray } from './utils';
+
+const updateTags = (type, tags) => {
+  const headElement = document.head || document.querySelector(TAG_NAMES.HEAD);
+  const tagNodes = headElement.querySelectorAll(`${type}[${HELMET_ATTRIBUTE}]`);
+  const oldTags = [].slice.call(tagNodes);
+  const newTags = [];
+  let indexToDelete;
+
+  if (tags && tags.length) {
+    tags.forEach(tag => {
+      const newElement = document.createElement(type);
+
+      // eslint-disable-next-line
+      for (const attribute in tag) {
+        if (Object.prototype.hasOwnProperty.call(tag, attribute)) {
+          if (attribute === TAG_PROPERTIES.INNER_HTML) {
+            newElement.innerHTML = tag.innerHTML;
+          } else if (attribute === TAG_PROPERTIES.CSS_TEXT) {
+            if (newElement.styleSheet) {
+              newElement.styleSheet.cssText = tag.cssText;
+            } else {
+              newElement.appendChild(document.createTextNode(tag.cssText));
+            }
+          } else {
+            const value = typeof tag[attribute] === 'undefined' ? '' : tag[attribute];
+            newElement.setAttribute(attribute, value);
+          }
+        }
+      }
+
+      newElement.setAttribute(HELMET_ATTRIBUTE, 'true');
+
+      // Remove a duplicate tag from domTagstoRemove, so it isn't cleared.
+      if (
+        oldTags.some((existingTag, index) => {
+          indexToDelete = index;
+          return newElement.isEqualNode(existingTag);
+        })
+      ) {
+        oldTags.splice(indexToDelete, 1);
+      } else {
+        newTags.push(newElement);
+      }
+    });
+  }
+
+  oldTags.forEach(tag => tag.parentNode.removeChild(tag));
+  newTags.forEach(tag => headElement.appendChild(tag));
+
+  return {
+    oldTags,
+    newTags,
+  };
+};
+
+const updateAttributes = (tagName, attributes) => {
+  const elementTag = document.getElementsByTagName(tagName)[0];
+
+  if (!elementTag) {
+    return;
+  }
+
+  const helmetAttributeString = elementTag.getAttribute(HELMET_ATTRIBUTE);
+  const helmetAttributes = helmetAttributeString ? helmetAttributeString.split(',') : [];
+  const attributesToRemove = [].concat(helmetAttributes);
+  const attributeKeys = Object.keys(attributes);
+
+  for (let i = 0; i < attributeKeys.length; i += 1) {
+    const attribute = attributeKeys[i];
+    const value = attributes[attribute] || '';
+
+    if (elementTag.getAttribute(attribute) !== value) {
+      elementTag.setAttribute(attribute, value);
+    }
+
+    if (helmetAttributes.indexOf(attribute) === -1) {
+      helmetAttributes.push(attribute);
+    }
+
+    const indexToSave = attributesToRemove.indexOf(attribute);
+    if (indexToSave !== -1) {
+      attributesToRemove.splice(indexToSave, 1);
+    }
+  }
+
+  for (let i = attributesToRemove.length - 1; i >= 0; i -= 1) {
+    elementTag.removeAttribute(attributesToRemove[i]);
+  }
+
+  if (helmetAttributes.length === attributesToRemove.length) {
+    elementTag.removeAttribute(HELMET_ATTRIBUTE);
+  } else if (elementTag.getAttribute(HELMET_ATTRIBUTE) !== attributeKeys.join(',')) {
+    elementTag.setAttribute(HELMET_ATTRIBUTE, attributeKeys.join(','));
+  }
+};
+
+const updateTitle = (title, attributes) => {
+  if (typeof title !== 'undefined' && document.title !== title) {
+    document.title = flattenArray(title);
+  }
+
+  updateAttributes(TAG_NAMES.TITLE, attributes);
+};
+
+const commitTagChanges = (newState, cb) => {
+  const {
+    baseTag,
+    bodyAttributes,
+    htmlAttributes,
+    linkTags,
+    metaTags,
+    noscriptTags,
+    onChangeClientState,
+    scriptTags,
+    styleTags,
+    title,
+    titleAttributes,
+  } = newState;
+  updateAttributes(TAG_NAMES.BODY, bodyAttributes);
+  updateAttributes(TAG_NAMES.HTML, htmlAttributes);
+
+  updateTitle(title, titleAttributes);
+
+  const tagUpdates = {
+    baseTag: updateTags(TAG_NAMES.BASE, baseTag),
+    linkTags: updateTags(TAG_NAMES.LINK, linkTags),
+    metaTags: updateTags(TAG_NAMES.META, metaTags),
+    noscriptTags: updateTags(TAG_NAMES.NOSCRIPT, noscriptTags),
+    scriptTags: updateTags(TAG_NAMES.SCRIPT, scriptTags),
+    styleTags: updateTags(TAG_NAMES.STYLE, styleTags),
+  };
+
+  const addedTags = {};
+  const removedTags = {};
+
+  Object.keys(tagUpdates).forEach(tagType => {
+    const { newTags, oldTags } = tagUpdates[tagType];
+
+    if (newTags.length) {
+      addedTags[tagType] = newTags;
+    }
+    if (oldTags.length) {
+      removedTags[tagType] = tagUpdates[tagType].oldTags;
+    }
+  });
+
+  if (cb) {
+    cb();
+  }
+
+  onChangeClientState(newState, addedTags, removedTags);
+};
+
+// eslint-disable-next-line
+let _helmetCallback = null;
+
+const handleStateChangeOnClient = newState => {
+  if (_helmetCallback) {
+    cancelAnimationFrame(_helmetCallback);
+  }
+
+  if (newState.defer) {
+    _helmetCallback = requestAnimationFrame(() => {
+      commitTagChanges(newState, () => {
+        _helmetCallback = null;
+      });
+    });
+  } else {
+    commitTagChanges(newState);
+    _helmetCallback = null;
+  }
+};
+
+export default handleStateChangeOnClient;

node_modules/react-helmet-async/src/constants.js

@@ -0,0 +1,76 @@
+export const TAG_PROPERTIES = {
+  CHARSET: 'charset',
+  CSS_TEXT: 'cssText',
+  HREF: 'href',
+  HTTPEQUIV: 'http-equiv',
+  INNER_HTML: 'innerHTML',
+  ITEM_PROP: 'itemprop',
+  NAME: 'name',
+  PROPERTY: 'property',
+  REL: 'rel',
+  SRC: 'src',
+};
+
+export const ATTRIBUTE_NAMES = {
+  BODY: 'bodyAttributes',
+  HTML: 'htmlAttributes',
+  TITLE: 'titleAttributes',
+};
+
+export const TAG_NAMES = {
+  BASE: 'base',
+  BODY: 'body',
+  HEAD: 'head',
+  HTML: 'html',
+  LINK: 'link',
+  META: 'meta',
+  NOSCRIPT: 'noscript',
+  SCRIPT: 'script',
+  STYLE: 'style',
+  TITLE: 'title',
+  FRAGMENT: 'Symbol(react.fragment)',
+};
+
+export const SEO_PRIORITY_TAGS = {
+  link: { rel: ['amphtml', 'canonical', 'alternate'] },
+  script: { type: ['application/ld+json'] },
+  meta: {
+    charset: '',
+    name: ['robots', 'description'],
+    property: [
+      'og:type',
+      'og:title',
+      'og:url',
+      'og:image',
+      'og:image:alt',
+      'og:description',
+      'twitter:url',
+      'twitter:title',
+      'twitter:description',
+      'twitter:image',
+      'twitter:image:alt',
+      'twitter:card',
+      'twitter:site',
+    ],
+  },
+};
+
+export const VALID_TAG_NAMES = Object.keys(TAG_NAMES).map(name => TAG_NAMES[name]);
+
+export const REACT_TAG_MAP = {
+  accesskey: 'accessKey',
+  charset: 'charSet',
+  class: 'className',
+  contenteditable: 'contentEditable',
+  contextmenu: 'contextMenu',
+  'http-equiv': 'httpEquiv',
+  itemprop: 'itemProp',
+  tabindex: 'tabIndex',
+};
+
+export const HTML_TAG_MAP = Object.keys(REACT_TAG_MAP).reduce((obj, key) => {
+  obj[REACT_TAG_MAP[key]] = key;
+  return obj;
+}, {});
+
+export const HELMET_ATTRIBUTE = 'data-rh';

node_modules/react-helmet-async/src/index.js

@@ -0,0 +1,247 @@
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import fastCompare from 'react-fast-compare';
+import invariant from 'invariant';
+import { Context } from './Provider';
+import HelmetData from './HelmetData';
+import Dispatcher from './Dispatcher';
+import { without } from './utils';
+import { TAG_NAMES, VALID_TAG_NAMES, HTML_TAG_MAP } from './constants';
+
+export { default as HelmetData } from './HelmetData';
+export { default as HelmetProvider } from './Provider';
+
+/* eslint-disable class-methods-use-this */
+export class Helmet extends Component {
+  /**
+   * @param {Object} base: {"target": "_blank", "href": "http://mysite.com/"}
+   * @param {Object} bodyAttributes: {"className": "root"}
+   * @param {String} defaultTitle: "Default Title"
+   * @param {Boolean} defer: true
+   * @param {Boolean} encodeSpecialCharacters: true
+   * @param {Object} htmlAttributes: {"lang": "en", "amp": undefined}
+   * @param {Array} link: [{"rel": "canonical", "href": "http://mysite.com/example"}]
+   * @param {Array} meta: [{"name": "description", "content": "Test description"}]
+   * @param {Array} noscript: [{"innerHTML": "<img src='http://mysite.com/js/test.js'"}]
+   * @param {Function} onChangeClientState: "(newState) => console.log(newState)"
+   * @param {Array} script: [{"type": "text/javascript", "src": "http://mysite.com/js/test.js"}]
+   * @param {Array} style: [{"type": "text/css", "cssText": "div { display: block; color: blue; }"}]
+   * @param {String} title: "Title"
+   * @param {Object} titleAttributes: {"itemprop": "name"}
+   * @param {String} titleTemplate: "MySite.com - %s"
+   * @param {Boolean} prioritizeSeoTags: false
+   */
+  /* eslint-disable react/forbid-prop-types, react/require-default-props */
+  static propTypes = {
+    base: PropTypes.object,
+    bodyAttributes: PropTypes.object,
+    children: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.node), PropTypes.node]),
+    defaultTitle: PropTypes.string,
+    defer: PropTypes.bool,
+    encodeSpecialCharacters: PropTypes.bool,
+    htmlAttributes: PropTypes.object,
+    link: PropTypes.arrayOf(PropTypes.object),
+    meta: PropTypes.arrayOf(PropTypes.object),
+    noscript: PropTypes.arrayOf(PropTypes.object),
+    onChangeClientState: PropTypes.func,
+    script: PropTypes.arrayOf(PropTypes.object),
+    style: PropTypes.arrayOf(PropTypes.object),
+    title: PropTypes.string,
+    titleAttributes: PropTypes.object,
+    titleTemplate: PropTypes.string,
+    prioritizeSeoTags: PropTypes.bool,
+    helmetData: PropTypes.object,
+  };
+  /* eslint-enable react/prop-types, react/forbid-prop-types, react/require-default-props */
+
+  static defaultProps = {
+    defer: true,
+    encodeSpecialCharacters: true,
+    prioritizeSeoTags: false,
+  };
+
+  static displayName = 'Helmet';
+
+  shouldComponentUpdate(nextProps) {
+    return !fastCompare(without(this.props, 'helmetData'), without(nextProps, 'helmetData'));
+  }
+
+  mapNestedChildrenToProps(child, nestedChildren) {
+    if (!nestedChildren) {
+      return null;
+    }
+
+    switch (child.type) {
+      case TAG_NAMES.SCRIPT:
+      case TAG_NAMES.NOSCRIPT:
+        return {
+          innerHTML: nestedChildren,
+        };
+
+      case TAG_NAMES.STYLE:
+        return {
+          cssText: nestedChildren,
+        };
+      default:
+        throw new Error(
+          `<${child.type} /> elements are self-closing and can not contain children. Refer to our API for more information.`
+        );
+    }
+  }
+
+  flattenArrayTypeChildren({ child, arrayTypeChildren, newChildProps, nestedChildren }) {
+    return {
+      ...arrayTypeChildren,
+      [child.type]: [
+        ...(arrayTypeChildren[child.type] || []),
+        {
+          ...newChildProps,
+          ...this.mapNestedChildrenToProps(child, nestedChildren),
+        },
+      ],
+    };
+  }
+
+  mapObjectTypeChildren({ child, newProps, newChildProps, nestedChildren }) {
+    switch (child.type) {
+      case TAG_NAMES.TITLE:
+        return {
+          ...newProps,
+          [child.type]: nestedChildren,
+          titleAttributes: { ...newChildProps },
+        };
+
+      case TAG_NAMES.BODY:
+        return {
+          ...newProps,
+          bodyAttributes: { ...newChildProps },
+        };
+
+      case TAG_NAMES.HTML:
+        return {
+          ...newProps,
+          htmlAttributes: { ...newChildProps },
+        };
+      default:
+        return {
+          ...newProps,
+          [child.type]: { ...newChildProps },
+        };
+    }
+  }
+
+  mapArrayTypeChildrenToProps(arrayTypeChildren, newProps) {
+    let newFlattenedProps = { ...newProps };
+
+    Object.keys(arrayTypeChildren).forEach(arrayChildName => {
+      newFlattenedProps = {
+        ...newFlattenedProps,
+        [arrayChildName]: arrayTypeChildren[arrayChildName],
+      };
+    });
+
+    return newFlattenedProps;
+  }
+
+  warnOnInvalidChildren(child, nestedChildren) {
+    invariant(
+      VALID_TAG_NAMES.some(name => child.type === name),
+      typeof child.type === 'function'
+        ? `You may be attempting to nest <Helmet> components within each other, which is not allowed. Refer to our API for more information.`
+        : `Only elements types ${VALID_TAG_NAMES.join(
+            ', '
+          )} are allowed. Helmet does not support rendering <${
+            child.type
+          }> elements. Refer to our API for more information.`
+    );
+
+    invariant(
+      !nestedChildren ||
+        typeof nestedChildren === 'string' ||
+        (Array.isArray(nestedChildren) &&
+          !nestedChildren.some(nestedChild => typeof nestedChild !== 'string')),
+      `Helmet expects a string as a child of <${child.type}>. Did you forget to wrap your children in braces? ( <${child.type}>{\`\`}</${child.type}> ) Refer to our API for more information.`
+    );
+
+    return true;
+  }
+
+  mapChildrenToProps(children, newProps) {
+    let arrayTypeChildren = {};
+
+    React.Children.forEach(children, child => {
+      if (!child || !child.props) {
+        return;
+      }
+
+      const { children: nestedChildren, ...childProps } = child.props;
+      // convert React props to HTML attributes
+      const newChildProps = Object.keys(childProps).reduce((obj, key) => {
+        obj[HTML_TAG_MAP[key] || key] = childProps[key];
+        return obj;
+      }, {});
+
+      let { type } = child;
+      if (typeof type === 'symbol') {
+        type = type.toString();
+      } else {
+        this.warnOnInvalidChildren(child, nestedChildren);
+      }
+
+      switch (type) {
+        case TAG_NAMES.FRAGMENT:
+          newProps = this.mapChildrenToProps(nestedChildren, newProps);
+          break;
+
+        case TAG_NAMES.LINK:
+        case TAG_NAMES.META:
+        case TAG_NAMES.NOSCRIPT:
+        case TAG_NAMES.SCRIPT:
+        case TAG_NAMES.STYLE:
+          arrayTypeChildren = this.flattenArrayTypeChildren({
+            child,
+            arrayTypeChildren,
+            newChildProps,
+            nestedChildren,
+          });
+          break;
+
+        default:
+          newProps = this.mapObjectTypeChildren({
+            child,
+            newProps,
+            newChildProps,
+            nestedChildren,
+          });
+          break;
+      }
+    });
+
+    return this.mapArrayTypeChildrenToProps(arrayTypeChildren, newProps);
+  }
+
+  render() {
+    const { children, ...props } = this.props;
+    let newProps = { ...props };
+    let { helmetData } = props;
+
+    if (children) {
+      newProps = this.mapChildrenToProps(children, newProps);
+    }
+
+    if (helmetData && !(helmetData instanceof HelmetData)) {
+      helmetData = new HelmetData(helmetData.context, helmetData.instances);
+    }
+
+    return helmetData ? (
+      // eslint-disable-next-line react/jsx-props-no-spreading
+      <Dispatcher {...newProps} context={helmetData.value} helmetData={undefined} />
+    ) : (
+      <Context.Consumer>
+        {(
+          context // eslint-disable-next-line react/jsx-props-no-spreading
+        ) => <Dispatcher {...newProps} context={context} />}
+      </Context.Consumer>
+    );
+  }
+}

node_modules/react-helmet-async/src/server.js

@@ -0,0 +1,197 @@
+import React from 'react';
+import {
+  HELMET_ATTRIBUTE,
+  TAG_NAMES,
+  REACT_TAG_MAP,
+  TAG_PROPERTIES,
+  ATTRIBUTE_NAMES,
+  SEO_PRIORITY_TAGS,
+} from './constants';
+import { flattenArray, prioritizer } from './utils';
+
+const SELF_CLOSING_TAGS = [TAG_NAMES.NOSCRIPT, TAG_NAMES.SCRIPT, TAG_NAMES.STYLE];
+
+const encodeSpecialCharacters = (str, encode = true) => {
+  if (encode === false) {
+    return String(str);
+  }
+
+  return String(str)
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#x27;');
+};
+
+const generateElementAttributesAsString = attributes =>
+  Object.keys(attributes).reduce((str, key) => {
+    const attr = typeof attributes[key] !== 'undefined' ? `${key}="${attributes[key]}"` : `${key}`;
+    return str ? `${str} ${attr}` : attr;
+  }, '');
+
+const generateTitleAsString = (type, title, attributes, encode) => {
+  const attributeString = generateElementAttributesAsString(attributes);
+  const flattenedTitle = flattenArray(title);
+  return attributeString
+    ? `<${type} ${HELMET_ATTRIBUTE}="true" ${attributeString}>${encodeSpecialCharacters(
+        flattenedTitle,
+        encode
+      )}</${type}>`
+    : `<${type} ${HELMET_ATTRIBUTE}="true">${encodeSpecialCharacters(
+        flattenedTitle,
+        encode
+      )}</${type}>`;
+};
+
+const generateTagsAsString = (type, tags, encode) =>
+  tags.reduce((str, tag) => {
+    const attributeHtml = Object.keys(tag)
+      .filter(
+        attribute =>
+          !(attribute === TAG_PROPERTIES.INNER_HTML || attribute === TAG_PROPERTIES.CSS_TEXT)
+      )
+      .reduce((string, attribute) => {
+        const attr =
+          typeof tag[attribute] === 'undefined'
+            ? attribute
+            : `${attribute}="${encodeSpecialCharacters(tag[attribute], encode)}"`;
+        return string ? `${string} ${attr}` : attr;
+      }, '');
+
+    const tagContent = tag.innerHTML || tag.cssText || '';
+
+    const isSelfClosing = SELF_CLOSING_TAGS.indexOf(type) === -1;
+
+    return `${str}<${type} ${HELMET_ATTRIBUTE}="true" ${attributeHtml}${
+      isSelfClosing ? `/>` : `>${tagContent}</${type}>`
+    }`;
+  }, '');
+
+const convertElementAttributesToReactProps = (attributes, initProps = {}) =>
+  Object.keys(attributes).reduce((obj, key) => {
+    obj[REACT_TAG_MAP[key] || key] = attributes[key];
+    return obj;
+  }, initProps);
+
+const generateTitleAsReactComponent = (type, title, attributes) => {
+  // assigning into an array to define toString function on it
+  const initProps = {
+    key: title,
+    [HELMET_ATTRIBUTE]: true,
+  };
+  const props = convertElementAttributesToReactProps(attributes, initProps);
+
+  return [React.createElement(TAG_NAMES.TITLE, props, title)];
+};
+
+const generateTagsAsReactComponent = (type, tags) =>
+  tags.map((tag, i) => {
+    const mappedTag = {
+      key: i,
+      [HELMET_ATTRIBUTE]: true,
+    };
+
+    Object.keys(tag).forEach(attribute => {
+      const mappedAttribute = REACT_TAG_MAP[attribute] || attribute;
+
+      if (
+        mappedAttribute === TAG_PROPERTIES.INNER_HTML ||
+        mappedAttribute === TAG_PROPERTIES.CSS_TEXT
+      ) {
+        const content = tag.innerHTML || tag.cssText;
+        mappedTag.dangerouslySetInnerHTML = { __html: content };
+      } else {
+        mappedTag[mappedAttribute] = tag[attribute];
+      }
+    });
+
+    return React.createElement(type, mappedTag);
+  });
+
+const getMethodsForTag = (type, tags, encode) => {
+  switch (type) {
+    case TAG_NAMES.TITLE:
+      return {
+        toComponent: () =>
+          generateTitleAsReactComponent(type, tags.title, tags.titleAttributes, encode),
+        toString: () => generateTitleAsString(type, tags.title, tags.titleAttributes, encode),
+      };
+    case ATTRIBUTE_NAMES.BODY:
+    case ATTRIBUTE_NAMES.HTML:
+      return {
+        toComponent: () => convertElementAttributesToReactProps(tags),
+        toString: () => generateElementAttributesAsString(tags),
+      };
+    default:
+      return {
+        toComponent: () => generateTagsAsReactComponent(type, tags),
+        toString: () => generateTagsAsString(type, tags, encode),
+      };
+  }
+};
+
+const getPriorityMethods = ({ metaTags, linkTags, scriptTags, encode }) => {
+  const meta = prioritizer(metaTags, SEO_PRIORITY_TAGS.meta);
+  const link = prioritizer(linkTags, SEO_PRIORITY_TAGS.link);
+  const script = prioritizer(scriptTags, SEO_PRIORITY_TAGS.script);
+
+  // need to have toComponent() and toString()
+  const priorityMethods = {
+    toComponent: () => [
+      ...generateTagsAsReactComponent(TAG_NAMES.META, meta.priority),
+      ...generateTagsAsReactComponent(TAG_NAMES.LINK, link.priority),
+      ...generateTagsAsReactComponent(TAG_NAMES.SCRIPT, script.priority),
+    ],
+    toString: () =>
+      // generate all the tags as strings and concatenate them
+      `${getMethodsForTag(TAG_NAMES.META, meta.priority, encode)} ${getMethodsForTag(
+        TAG_NAMES.LINK,
+        link.priority,
+        encode
+      )} ${getMethodsForTag(TAG_NAMES.SCRIPT, script.priority, encode)}`,
+  };
+
+  return {
+    priorityMethods,
+    metaTags: meta.default,
+    linkTags: link.default,
+    scriptTags: script.default,
+  };
+};
+
+const mapStateOnServer = props => {
+  const {
+    baseTag,
+    bodyAttributes,
+    encode,
+    htmlAttributes,
+    noscriptTags,
+    styleTags,
+    title = '',
+    titleAttributes,
+    prioritizeSeoTags,
+  } = props;
+  let { linkTags, metaTags, scriptTags } = props;
+  let priorityMethods = {
+    toComponent: () => {},
+    toString: () => '',
+  };
+  if (prioritizeSeoTags) {
+    ({ priorityMethods, linkTags, metaTags, scriptTags } = getPriorityMethods(props));
+  }
+  return {
+    priority: priorityMethods,
+    base: getMethodsForTag(TAG_NAMES.BASE, baseTag, encode),
+    bodyAttributes: getMethodsForTag(ATTRIBUTE_NAMES.BODY, bodyAttributes, encode),
+    htmlAttributes: getMethodsForTag(ATTRIBUTE_NAMES.HTML, htmlAttributes, encode),
+    link: getMethodsForTag(TAG_NAMES.LINK, linkTags, encode),
+    meta: getMethodsForTag(TAG_NAMES.META, metaTags, encode),
+    noscript: getMethodsForTag(TAG_NAMES.NOSCRIPT, noscriptTags, encode),
+    script: getMethodsForTag(TAG_NAMES.SCRIPT, scriptTags, encode),
+    style: getMethodsForTag(TAG_NAMES.STYLE, styleTags, encode),
+    title: getMethodsForTag(TAG_NAMES.TITLE, { title, titleAttributes }, encode),
+  };
+};
+
+export default mapStateOnServer;

node_modules/react-helmet-async/src/utils.js

@@ -0,0 +1,259 @@
+import { TAG_NAMES, TAG_PROPERTIES, ATTRIBUTE_NAMES } from './constants';
+
+const HELMET_PROPS = {
+  DEFAULT_TITLE: 'defaultTitle',
+  DEFER: 'defer',
+  ENCODE_SPECIAL_CHARACTERS: 'encodeSpecialCharacters',
+  ON_CHANGE_CLIENT_STATE: 'onChangeClientState',
+  TITLE_TEMPLATE: 'titleTemplate',
+  PRIORITIZE_SEO_TAGS: 'prioritizeSeoTags',
+};
+
+const getInnermostProperty = (propsList, property) => {
+  for (let i = propsList.length - 1; i >= 0; i -= 1) {
+    const props = propsList[i];
+
+    if (Object.prototype.hasOwnProperty.call(props, property)) {
+      return props[property];
+    }
+  }
+
+  return null;
+};
+
+const getTitleFromPropsList = propsList => {
+  let innermostTitle = getInnermostProperty(propsList, TAG_NAMES.TITLE);
+  const innermostTemplate = getInnermostProperty(propsList, HELMET_PROPS.TITLE_TEMPLATE);
+  if (Array.isArray(innermostTitle)) {
+    innermostTitle = innermostTitle.join('');
+  }
+  if (innermostTemplate && innermostTitle) {
+    // use function arg to avoid need to escape $ characters
+    return innermostTemplate.replace(/%s/g, () => innermostTitle);
+  }
+
+  const innermostDefaultTitle = getInnermostProperty(propsList, HELMET_PROPS.DEFAULT_TITLE);
+
+  return innermostTitle || innermostDefaultTitle || undefined;
+};
+
+const getOnChangeClientState = propsList =>
+  getInnermostProperty(propsList, HELMET_PROPS.ON_CHANGE_CLIENT_STATE) || (() => {});
+
+const getAttributesFromPropsList = (tagType, propsList) =>
+  propsList
+    .filter(props => typeof props[tagType] !== 'undefined')
+    .map(props => props[tagType])
+    .reduce((tagAttrs, current) => ({ ...tagAttrs, ...current }), {});
+
+const getBaseTagFromPropsList = (primaryAttributes, propsList) =>
+  propsList
+    .filter(props => typeof props[TAG_NAMES.BASE] !== 'undefined')
+    .map(props => props[TAG_NAMES.BASE])
+    .reverse()
+    .reduce((innermostBaseTag, tag) => {
+      if (!innermostBaseTag.length) {
+        const keys = Object.keys(tag);
+
+        for (let i = 0; i < keys.length; i += 1) {
+          const attributeKey = keys[i];
+          const lowerCaseAttributeKey = attributeKey.toLowerCase();
+
+          if (
+            primaryAttributes.indexOf(lowerCaseAttributeKey) !== -1 &&
+            tag[lowerCaseAttributeKey]
+          ) {
+            return innermostBaseTag.concat(tag);
+          }
+        }
+      }
+
+      return innermostBaseTag;
+    }, []);
+
+// eslint-disable-next-line no-console
+const warn = msg => console && typeof console.warn === 'function' && console.warn(msg);
+
+const getTagsFromPropsList = (tagName, primaryAttributes, propsList) => {
+  // Calculate list of tags, giving priority innermost component (end of the propslist)
+  const approvedSeenTags = {};
+
+  return propsList
+    .filter(props => {
+      if (Array.isArray(props[tagName])) {
+        return true;
+      }
+      if (typeof props[tagName] !== 'undefined') {
+        warn(
+          `Helmet: ${tagName} should be of type "Array". Instead found type "${typeof props[
+            tagName
+          ]}"`
+        );
+      }
+      return false;
+    })
+    .map(props => props[tagName])
+    .reverse()
+    .reduce((approvedTags, instanceTags) => {
+      const instanceSeenTags = {};
+
+      instanceTags
+        .filter(tag => {
+          let primaryAttributeKey;
+          const keys = Object.keys(tag);
+          for (let i = 0; i < keys.length; i += 1) {
+            const attributeKey = keys[i];
+            const lowerCaseAttributeKey = attributeKey.toLowerCase();
+
+            // Special rule with link tags, since rel and href are both primary tags, rel takes priority
+            if (
+              primaryAttributes.indexOf(lowerCaseAttributeKey) !== -1 &&
+              !(
+                primaryAttributeKey === TAG_PROPERTIES.REL &&
+                tag[primaryAttributeKey].toLowerCase() === 'canonical'
+              ) &&
+              !(
+                lowerCaseAttributeKey === TAG_PROPERTIES.REL &&
+                tag[lowerCaseAttributeKey].toLowerCase() === 'stylesheet'
+              )
+            ) {
+              primaryAttributeKey = lowerCaseAttributeKey;
+            }
+            // Special case for innerHTML which doesn't work lowercased
+            if (
+              primaryAttributes.indexOf(attributeKey) !== -1 &&
+              (attributeKey === TAG_PROPERTIES.INNER_HTML ||
+                attributeKey === TAG_PROPERTIES.CSS_TEXT ||
+                attributeKey === TAG_PROPERTIES.ITEM_PROP)
+            ) {
+              primaryAttributeKey = attributeKey;
+            }
+          }
+
+          if (!primaryAttributeKey || !tag[primaryAttributeKey]) {
+            return false;
+          }
+
+          const value = tag[primaryAttributeKey].toLowerCase();
+
+          if (!approvedSeenTags[primaryAttributeKey]) {
+            approvedSeenTags[primaryAttributeKey] = {};
+          }
+
+          if (!instanceSeenTags[primaryAttributeKey]) {
+            instanceSeenTags[primaryAttributeKey] = {};
+          }
+
+          if (!approvedSeenTags[primaryAttributeKey][value]) {
+            instanceSeenTags[primaryAttributeKey][value] = true;
+            return true;
+          }
+
+          return false;
+        })
+        .reverse()
+        .forEach(tag => approvedTags.push(tag));
+
+      // Update seen tags with tags from this instance
+      const keys = Object.keys(instanceSeenTags);
+      for (let i = 0; i < keys.length; i += 1) {
+        const attributeKey = keys[i];
+        const tagUnion = {
+          ...approvedSeenTags[attributeKey],
+          ...instanceSeenTags[attributeKey],
+        };
+
+        approvedSeenTags[attributeKey] = tagUnion;
+      }
+
+      return approvedTags;
+    }, [])
+    .reverse();
+};
+
+const getAnyTrueFromPropsList = (propsList, checkedTag) => {
+  if (Array.isArray(propsList) && propsList.length) {
+    for (let index = 0; index < propsList.length; index += 1) {
+      const prop = propsList[index];
+      if (prop[checkedTag]) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+
+const reducePropsToState = propsList => ({
+  baseTag: getBaseTagFromPropsList([TAG_PROPERTIES.HREF], propsList),
+  bodyAttributes: getAttributesFromPropsList(ATTRIBUTE_NAMES.BODY, propsList),
+  defer: getInnermostProperty(propsList, HELMET_PROPS.DEFER),
+  encode: getInnermostProperty(propsList, HELMET_PROPS.ENCODE_SPECIAL_CHARACTERS),
+  htmlAttributes: getAttributesFromPropsList(ATTRIBUTE_NAMES.HTML, propsList),
+  linkTags: getTagsFromPropsList(
+    TAG_NAMES.LINK,
+    [TAG_PROPERTIES.REL, TAG_PROPERTIES.HREF],
+    propsList
+  ),
+  metaTags: getTagsFromPropsList(
+    TAG_NAMES.META,
+    [
+      TAG_PROPERTIES.NAME,
+      TAG_PROPERTIES.CHARSET,
+      TAG_PROPERTIES.HTTPEQUIV,
+      TAG_PROPERTIES.PROPERTY,
+      TAG_PROPERTIES.ITEM_PROP,
+    ],
+    propsList
+  ),
+  noscriptTags: getTagsFromPropsList(TAG_NAMES.NOSCRIPT, [TAG_PROPERTIES.INNER_HTML], propsList),
+  onChangeClientState: getOnChangeClientState(propsList),
+  scriptTags: getTagsFromPropsList(
+    TAG_NAMES.SCRIPT,
+    [TAG_PROPERTIES.SRC, TAG_PROPERTIES.INNER_HTML],
+    propsList
+  ),
+  styleTags: getTagsFromPropsList(TAG_NAMES.STYLE, [TAG_PROPERTIES.CSS_TEXT], propsList),
+  title: getTitleFromPropsList(propsList),
+  titleAttributes: getAttributesFromPropsList(ATTRIBUTE_NAMES.TITLE, propsList),
+  prioritizeSeoTags: getAnyTrueFromPropsList(propsList, HELMET_PROPS.PRIORITIZE_SEO_TAGS),
+});
+
+export const flattenArray = possibleArray =>
+  Array.isArray(possibleArray) ? possibleArray.join('') : possibleArray;
+
+export { reducePropsToState };
+
+const checkIfPropsMatch = (props, toMatch) => {
+  const keys = Object.keys(props);
+  for (let i = 0; i < keys.length; i += 1) {
+    // e.g. if rel exists in the list of allowed props [amphtml, alternate, etc]
+    if (toMatch[keys[i]] && toMatch[keys[i]].includes(props[keys[i]])) {
+      return true;
+    }
+  }
+  return false;
+};
+
+export const prioritizer = (elementsList, propsToMatch) => {
+  if (Array.isArray(elementsList)) {
+    return elementsList.reduce(
+      (acc, elementAttrs) => {
+        if (checkIfPropsMatch(elementAttrs, propsToMatch)) {
+          acc.priority.push(elementAttrs);
+        } else {
+          acc.default.push(elementAttrs);
+        }
+        return acc;
+      },
+      { priority: [], default: [] }
+    );
+  }
+  return { default: elementsList };
+};
+
+export const without = (obj, key) => {
+  return {
+    ...obj,
+    [key]: undefined,
+  };
+};