Initial React project

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,240 @@
+# react-helmet-async
+
+[![CI](https://github.com/staylor/react-helmet-async/actions/workflows/ci.yml/badge.svg)](https://github.com/staylor/react-helmet-async/actions/workflows/ci.yml)
+
+[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.
+
+## React 19
+
+React 19 has built-in support for hoisting `<title>`, `<meta>`, `<link>`, `<style>`, and `<script>` elements to `<head>`. Starting with version 3.0.0, this package detects the React version at runtime:
+
+- **React 19+**: `<Helmet>` renders actual DOM elements and lets React handle hoisting them to `<head>`. `<HelmetProvider>` becomes a transparent passthrough. The existing API is fully compatible — you do not need to change any code.
+- **React 16–18**: The existing behavior is preserved. `<Helmet>` collects all instances, deduplicates tags, and applies changes to the DOM via manual manipulation (client) or serializes them for the response (server).
+
+> **Note:** `htmlAttributes` and `bodyAttributes` do not have a React 19 equivalent, so they are still applied via direct DOM manipulation on both code paths.
+
+If you are starting a new React 19 project and do not need `htmlAttributes`/`bodyAttributes`, SSR `context` serialization, `onChangeClientState`, `prioritizeSeoTags`, or `titleTemplate` support, you may not need this package at all — React 19's built-in metadata handling may be sufficient.
+
+## Usage
+
+**New in 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 { createRoot } from 'react-dom/client';
+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>
+);
+
+createRoot(document.getElementById('app')).render(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…
+```
+
+> **React 19 SSR note:** When using React 19, `<title>`, `<meta>`, and `<link>` tags rendered inside `<Helmet>` are included directly in the React render output and hoisted to `<head>` by React itself. The `context` object will not be populated with helmet state on React 19. If you rely on the `context` for server rendering, you can render these tags directly in your component tree instead and let React 19 handle them natively.
+
+## 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);
+```
+
+> **React 19:** React 19's `renderToReadableStream` natively handles `<title>`, `<meta>`, and `<link>` hoisting during streaming, so the manual context extraction shown above is not necessary.
+
+## 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;
+```
+
+> This is only relevant for React 16–18. On React 19, `HelmetProvider` is a passthrough and `canUseDOM` has no effect.
+
+## 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.ts](./src/constants.ts).
+
+> **React 19:** The `prioritizeSeoTags` flag has no effect on React 19, since tags are rendered as regular JSX elements and their order in `<head>` is determined by React's rendering order.
+
+## 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, 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;
+```
+
+> **React 19:** The `helmetData` prop is ignored on React 19, since `<Helmet>` renders elements directly without the need for external state management.
+
+## Compatibility
+
+| React Version | Behavior |
+|---|---|
+| 16.6+ | Full support via `HelmetProvider` context and manual DOM updates |
+| 17.x | Full support via `HelmetProvider` context and manual DOM updates |
+| 18.x | Full support via `HelmetProvider` context and manual DOM updates |
+| 19.x+ | Renders native JSX elements; React handles `<head>` hoisting |
+
+## Development
+
+```bash
+pnpm install
+pnpm test            # unit tests
+pnpm run test:e2e    # server + browser e2e tests
+pnpm run test:all    # everything
+```
+
+## License
+
+Licensed under the Apache 2.0 License, Copyright © 2018 Scott Taylor

node_modules/react-helmet-async/lib/Dispatcher.d.ts

@@ -0,0 +1,23 @@
+import { Component } from 'react';
+import type { HelmetServerState } from './types';
+export interface DispatcherContextProp {
+    setHelmet: (newState: HelmetServerState | null) => void;
+    helmetInstances: {
+        get: () => HelmetDispatcher[];
+        add: (helmet: HelmetDispatcher) => void;
+        remove: (helmet: HelmetDispatcher) => void;
+    };
+}
+interface DispatcherProps {
+    context: DispatcherContextProp;
+}
+export default class HelmetDispatcher extends Component<DispatcherProps> {
+    rendered: boolean;
+    shouldComponentUpdate(nextProps: DispatcherProps): boolean;
+    componentDidUpdate(): void;
+    componentWillUnmount(): void;
+    emitChange(): void;
+    init(): void;
+    render(): null;
+}
+export {};

node_modules/react-helmet-async/lib/HelmetData.d.ts

@@ -0,0 +1,26 @@
+import type HelmetDispatcher from './Dispatcher';
+import type { HelmetServerState } from './types';
+export declare function clearInstances(): void;
+export interface HelmetDataType {
+    instances: HelmetDispatcher[];
+    context: HelmetDataContext;
+}
+interface HelmetDataContext {
+    helmet: HelmetServerState | null;
+}
+export declare const isDocument: boolean;
+export default class HelmetData implements HelmetDataType {
+    instances: never[];
+    canUseDOM: boolean;
+    context: HelmetDataContext;
+    value: {
+        setHelmet: (serverState: HelmetServerState | null) => void;
+        helmetInstances: {
+            get: () => HelmetDispatcher[];
+            add: (instance: HelmetDispatcher) => void;
+            remove: (instance: HelmetDispatcher) => void;
+        };
+    };
+    constructor(context: any, canUseDOM?: boolean);
+}
+export {};

node_modules/react-helmet-async/lib/Provider.d.ts

@@ -0,0 +1,17 @@
+import type { PropsWithChildren } from 'react';
+import React, { Component } from 'react';
+import HelmetData from './HelmetData';
+import type { HelmetServerState } from './types';
+export declare const Context: React.Context<{}>;
+interface ProviderProps {
+    context?: {
+        helmet?: HelmetServerState | null;
+    };
+}
+export default class HelmetProvider extends Component<PropsWithChildren<ProviderProps>> {
+    static canUseDOM: boolean;
+    helmetData: HelmetData | null;
+    constructor(props: PropsWithChildren<ProviderProps>);
+    render(): React.JSX.Element;
+}
+export {};

node_modules/react-helmet-async/lib/React19Dispatcher.d.ts

@@ -0,0 +1,38 @@
+import React, { Component } from 'react';
+import type { HelmetProps } from './types';
+interface React19DispatcherProps extends HelmetProps {
+    /**
+     * The processed props including mapped children. These come from Helmet's
+     * mapChildrenToProps or the raw API props.
+     */
+    [key: string]: any;
+}
+/**
+ * React 19+ Dispatcher: Instead of manual DOM manipulation, this component
+ * renders actual JSX elements. React 19 automatically hoists <title>, <meta>,
+ * <link>, <style>, and <script async> to <head>.
+ *
+ * For htmlAttributes and bodyAttributes, we still apply via direct DOM
+ * manipulation since React 19 doesn't handle those.
+ */
+export default class React19Dispatcher extends Component<React19DispatcherProps> {
+    componentDidMount(): void;
+    componentDidUpdate(): void;
+    componentWillUnmount(): void;
+    resolveTitle(): string | undefined;
+    renderTitle(): React.DetailedReactHTMLElement<{
+        [key: string]: any;
+    }, HTMLElement> | null;
+    renderBase(): React.DetailedReactHTMLElement<{
+        [key: string]: any;
+    }, HTMLElement> | null;
+    renderMeta(): React.DetailedReactHTMLElement<React.HTMLAttributes<HTMLElement>, HTMLElement>[] | null;
+    renderLink(): React.DetailedReactHTMLElement<React.HTMLAttributes<HTMLElement>, HTMLElement>[] | null;
+    renderScript(): React.DetailedReactHTMLElement<React.HTMLAttributes<HTMLElement>, HTMLElement>[] | null;
+    renderStyle(): React.DetailedReactHTMLElement<React.HTMLAttributes<HTMLElement>, HTMLElement>[] | null;
+    renderNoscript(): React.DetailedReactHTMLElement<React.HTMLAttributes<HTMLElement>, HTMLElement>[] | null;
+    render(): React.FunctionComponentElement<{
+        children?: React.ReactNode;
+    }>;
+}
+export {};

node_modules/react-helmet-async/lib/client.d.ts

@@ -0,0 +1,3 @@
+import type { StateUpdate } from './types';
+declare const handleStateChangeOnClient: (newState: StateUpdate) => void;
+export default handleStateChangeOnClient;

node_modules/react-helmet-async/lib/constants.d.ts

@@ -0,0 +1,58 @@
+export declare enum 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 declare enum ATTRIBUTE_NAMES {
+    BODY = "bodyAttributes",
+    HTML = "htmlAttributes",
+    TITLE = "titleAttributes"
+}
+export declare enum 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 declare const SEO_PRIORITY_TAGS: {
+    link: {
+        rel: string[];
+    };
+    script: {
+        type: string[];
+    };
+    meta: {
+        charset: string;
+        name: string[];
+        property: string[];
+    };
+};
+export declare const VALID_TAG_NAMES: TAG_NAMES[];
+export declare const REACT_TAG_MAP: {
+    accesskey: string;
+    charset: string;
+    class: string;
+    contenteditable: string;
+    contextmenu: string;
+    'http-equiv': string;
+    itemprop: string;
+    tabindex: string;
+};
+export declare const HTML_TAG_MAP: {
+    [key: string]: string;
+};
+export declare const HELMET_ATTRIBUTE = "data-rh";

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

@@ -0,0 +1,21 @@
+import type { PropsWithChildren } from 'react';
+import React, { Component } from 'react';
+import type { HelmetProps } from './types';
+export type { Attributes, BodyProps, HelmetDatum, HelmetHTMLBodyDatum, HelmetHTMLElementDatum, HelmetProps, HelmetServerState, HelmetTags, HtmlProps, LinkProps, MetaProps, StateUpdate, TagList, TitleProps, } from './types';
+export { default as HelmetData } from './HelmetData';
+export { default as HelmetProvider } from './Provider';
+export declare class Helmet extends Component<PropsWithChildren<HelmetProps>> {
+    static defaultProps: {
+        defer: boolean;
+        encodeSpecialCharacters: boolean;
+        prioritizeSeoTags: boolean;
+    };
+    shouldComponentUpdate(nextProps: HelmetProps): boolean;
+    private mapNestedChildrenToProps;
+    private flattenArrayTypeChildren;
+    private mapObjectTypeChildren;
+    private mapArrayTypeChildrenToProps;
+    private warnOnInvalidChildren;
+    private mapChildrenToProps;
+    render(): React.JSX.Element;
+}

node_modules/react-helmet-async/lib/index.esm.js

@@ -0,0 +1,983 @@
+// src/index.tsx
+import React5, { Component as Component4 } from "react";
+import fastCompare from "react-fast-compare";
+import invariant from "invariant";
+
+// src/Provider.tsx
+import React3, { Component } from "react";
+
+// src/server.ts
+import React from "react";
+
+// src/constants.ts
+var TAG_NAMES = /* @__PURE__ */ ((TAG_NAMES2) => {
+  TAG_NAMES2["BASE"] = "base";
+  TAG_NAMES2["BODY"] = "body";
+  TAG_NAMES2["HEAD"] = "head";
+  TAG_NAMES2["HTML"] = "html";
+  TAG_NAMES2["LINK"] = "link";
+  TAG_NAMES2["META"] = "meta";
+  TAG_NAMES2["NOSCRIPT"] = "noscript";
+  TAG_NAMES2["SCRIPT"] = "script";
+  TAG_NAMES2["STYLE"] = "style";
+  TAG_NAMES2["TITLE"] = "title";
+  TAG_NAMES2["FRAGMENT"] = "Symbol(react.fragment)";
+  return TAG_NAMES2;
+})(TAG_NAMES || {});
+var SEO_PRIORITY_TAGS = {
+  link: { rel: ["amphtml", "canonical", "alternate"] },
+  script: { type: ["application/ld+json"] },
+  meta: {
+    charset: "",
+    name: ["generator", "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"
+    ]
+  }
+};
+var VALID_TAG_NAMES = Object.values(TAG_NAMES);
+var REACT_TAG_MAP = {
+  accesskey: "accessKey",
+  charset: "charSet",
+  class: "className",
+  contenteditable: "contentEditable",
+  contextmenu: "contextMenu",
+  "http-equiv": "httpEquiv",
+  itemprop: "itemProp",
+  tabindex: "tabIndex"
+};
+var HTML_TAG_MAP = Object.entries(REACT_TAG_MAP).reduce(
+  (carry, [key, value]) => {
+    carry[value] = key;
+    return carry;
+  },
+  {}
+);
+var HELMET_ATTRIBUTE = "data-rh";
+
+// src/utils.ts
+var HELMET_PROPS = {
+  DEFAULT_TITLE: "defaultTitle",
+  DEFER: "defer",
+  ENCODE_SPECIAL_CHARACTERS: "encodeSpecialCharacters",
+  ON_CHANGE_CLIENT_STATE: "onChangeClientState",
+  TITLE_TEMPLATE: "titleTemplate",
+  PRIORITIZE_SEO_TAGS: "prioritizeSeoTags"
+};
+var 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;
+};
+var getTitleFromPropsList = (propsList) => {
+  let innermostTitle = getInnermostProperty(propsList, "title" /* TITLE */);
+  const innermostTemplate = getInnermostProperty(propsList, HELMET_PROPS.TITLE_TEMPLATE);
+  if (Array.isArray(innermostTitle)) {
+    innermostTitle = innermostTitle.join("");
+  }
+  if (innermostTemplate && innermostTitle) {
+    return innermostTemplate.replace(/%s/g, () => innermostTitle);
+  }
+  const innermostDefaultTitle = getInnermostProperty(propsList, HELMET_PROPS.DEFAULT_TITLE);
+  return innermostTitle || innermostDefaultTitle || void 0;
+};
+var getOnChangeClientState = (propsList) => getInnermostProperty(propsList, HELMET_PROPS.ON_CHANGE_CLIENT_STATE) || (() => {
+});
+var getAttributesFromPropsList = (tagType, propsList) => propsList.filter((props) => typeof props[tagType] !== "undefined").map((props) => props[tagType]).reduce((tagAttrs, current) => ({ ...tagAttrs, ...current }), {});
+var getBaseTagFromPropsList = (primaryAttributes, propsList) => propsList.filter((props) => typeof props["base" /* BASE */] !== "undefined").map((props) => props["base" /* 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;
+}, []);
+var warn = (msg) => console && typeof console.warn === "function" && console.warn(msg);
+var getTagsFromPropsList = (tagName, primaryAttributes, 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 keys2 = Object.keys(tag);
+      for (let i = 0; i < keys2.length; i += 1) {
+        const attributeKey = keys2[i];
+        const lowerCaseAttributeKey = attributeKey.toLowerCase();
+        if (primaryAttributes.indexOf(lowerCaseAttributeKey) !== -1 && !(primaryAttributeKey === "rel" /* REL */ && tag[primaryAttributeKey].toLowerCase() === "canonical") && !(lowerCaseAttributeKey === "rel" /* REL */ && tag[lowerCaseAttributeKey].toLowerCase() === "stylesheet")) {
+          primaryAttributeKey = lowerCaseAttributeKey;
+        }
+        if (primaryAttributes.indexOf(attributeKey) !== -1 && (attributeKey === "innerHTML" /* INNER_HTML */ || attributeKey === "cssText" /* CSS_TEXT */ || attributeKey === "itemprop" /* 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));
+    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();
+};
+var 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;
+};
+var reducePropsToState = (propsList) => ({
+  baseTag: getBaseTagFromPropsList(["href" /* HREF */], propsList),
+  bodyAttributes: getAttributesFromPropsList("bodyAttributes" /* BODY */, propsList),
+  defer: getInnermostProperty(propsList, HELMET_PROPS.DEFER),
+  encode: getInnermostProperty(propsList, HELMET_PROPS.ENCODE_SPECIAL_CHARACTERS),
+  htmlAttributes: getAttributesFromPropsList("htmlAttributes" /* HTML */, propsList),
+  linkTags: getTagsFromPropsList(
+    "link" /* LINK */,
+    ["rel" /* REL */, "href" /* HREF */],
+    propsList
+  ),
+  metaTags: getTagsFromPropsList(
+    "meta" /* META */,
+    [
+      "name" /* NAME */,
+      "charset" /* CHARSET */,
+      "http-equiv" /* HTTPEQUIV */,
+      "property" /* PROPERTY */,
+      "itemprop" /* ITEM_PROP */
+    ],
+    propsList
+  ),
+  noscriptTags: getTagsFromPropsList("noscript" /* NOSCRIPT */, ["innerHTML" /* INNER_HTML */], propsList),
+  onChangeClientState: getOnChangeClientState(propsList),
+  scriptTags: getTagsFromPropsList(
+    "script" /* SCRIPT */,
+    ["src" /* SRC */, "innerHTML" /* INNER_HTML */],
+    propsList
+  ),
+  styleTags: getTagsFromPropsList("style" /* STYLE */, ["cssText" /* CSS_TEXT */], propsList),
+  title: getTitleFromPropsList(propsList),
+  titleAttributes: getAttributesFromPropsList("titleAttributes" /* TITLE */, propsList),
+  prioritizeSeoTags: getAnyTrueFromPropsList(propsList, HELMET_PROPS.PRIORITIZE_SEO_TAGS)
+});
+var flattenArray = (possibleArray) => Array.isArray(possibleArray) ? possibleArray.join("") : possibleArray;
+var checkIfPropsMatch = (props, toMatch) => {
+  const keys = Object.keys(props);
+  for (let i = 0; i < keys.length; i += 1) {
+    if (toMatch[keys[i]] && toMatch[keys[i]].includes(props[keys[i]])) {
+      return true;
+    }
+  }
+  return false;
+};
+var 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, priority: [] };
+};
+var without = (obj, key) => {
+  return {
+    ...obj,
+    [key]: void 0
+  };
+};
+
+// src/server.ts
+var SELF_CLOSING_TAGS = ["noscript" /* NOSCRIPT */, "script" /* SCRIPT */, "style" /* STYLE */];
+var encodeSpecialCharacters = (str, encode = true) => {
+  if (encode === false) {
+    return String(str);
+  }
+  return String(str).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;");
+};
+var generateElementAttributesAsString = (attributes) => Object.keys(attributes).reduce((str, key) => {
+  const attr = typeof attributes[key] !== "undefined" ? `${key}="${attributes[key]}"` : `${key}`;
+  return str ? `${str} ${attr}` : attr;
+}, "");
+var 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}>`;
+};
+var generateTagsAsString = (type, tags, encode = true) => tags.reduce((str, t) => {
+  const tag = t;
+  const attributeHtml = Object.keys(tag).filter(
+    (attribute) => !(attribute === "innerHTML" /* INNER_HTML */ || attribute === "cssText" /* 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}>`}`;
+}, "");
+var convertElementAttributesToReactProps = (attributes, initProps = {}) => Object.keys(attributes).reduce((obj, key) => {
+  const mapped = REACT_TAG_MAP[key];
+  obj[mapped || key] = attributes[key];
+  return obj;
+}, initProps);
+var generateTitleAsReactComponent = (_type, title, attributes) => {
+  const initProps = {
+    key: title,
+    [HELMET_ATTRIBUTE]: true
+  };
+  const props = convertElementAttributesToReactProps(attributes, initProps);
+  return [React.createElement("title" /* TITLE */, props, title)];
+};
+var generateTagsAsReactComponent = (type, tags) => tags.map((tag, i) => {
+  const mappedTag = {
+    key: i,
+    [HELMET_ATTRIBUTE]: true
+  };
+  Object.keys(tag).forEach((attribute) => {
+    const mapped = REACT_TAG_MAP[attribute];
+    const mappedAttribute = mapped || attribute;
+    if (mappedAttribute === "innerHTML" /* INNER_HTML */ || mappedAttribute === "cssText" /* CSS_TEXT */) {
+      const content = tag.innerHTML || tag.cssText;
+      mappedTag.dangerouslySetInnerHTML = { __html: content };
+    } else {
+      mappedTag[mappedAttribute] = tag[attribute];
+    }
+  });
+  return React.createElement(type, mappedTag);
+});
+var getMethodsForTag = (type, tags, encode = true) => {
+  switch (type) {
+    case "title" /* TITLE */:
+      return {
+        toComponent: () => generateTitleAsReactComponent(type, tags.title, tags.titleAttributes),
+        toString: () => generateTitleAsString(type, tags.title, tags.titleAttributes, encode)
+      };
+    case "bodyAttributes" /* BODY */:
+    case "htmlAttributes" /* HTML */:
+      return {
+        toComponent: () => convertElementAttributesToReactProps(tags),
+        toString: () => generateElementAttributesAsString(tags)
+      };
+    default:
+      return {
+        toComponent: () => generateTagsAsReactComponent(type, tags),
+        toString: () => generateTagsAsString(type, tags, encode)
+      };
+  }
+};
+var 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);
+  const priorityMethods = {
+    toComponent: () => [
+      ...generateTagsAsReactComponent("meta" /* META */, meta.priority),
+      ...generateTagsAsReactComponent("link" /* LINK */, link.priority),
+      ...generateTagsAsReactComponent("script" /* SCRIPT */, script.priority)
+    ],
+    toString: () => (
+      // generate all the tags as strings and concatenate them
+      `${getMethodsForTag("meta" /* META */, meta.priority, encode)} ${getMethodsForTag(
+        "link" /* LINK */,
+        link.priority,
+        encode
+      )} ${getMethodsForTag("script" /* SCRIPT */, script.priority, encode)}`
+    )
+  };
+  return {
+    priorityMethods,
+    metaTags: meta.default,
+    linkTags: link.default,
+    scriptTags: script.default
+  };
+};
+var mapStateOnServer = (props) => {
+  const {
+    baseTag,
+    bodyAttributes,
+    encode = true,
+    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("base" /* BASE */, baseTag, encode),
+    bodyAttributes: getMethodsForTag("bodyAttributes" /* BODY */, bodyAttributes, encode),
+    htmlAttributes: getMethodsForTag("htmlAttributes" /* HTML */, htmlAttributes, encode),
+    link: getMethodsForTag("link" /* LINK */, linkTags, encode),
+    meta: getMethodsForTag("meta" /* META */, metaTags, encode),
+    noscript: getMethodsForTag("noscript" /* NOSCRIPT */, noscriptTags, encode),
+    script: getMethodsForTag("script" /* SCRIPT */, scriptTags, encode),
+    style: getMethodsForTag("style" /* STYLE */, styleTags, encode),
+    title: getMethodsForTag("title" /* TITLE */, { title, titleAttributes }, encode)
+  };
+};
+var server_default = mapStateOnServer;
+
+// src/HelmetData.ts
+var instances = [];
+var isDocument = !!(typeof window !== "undefined" && window.document && window.document.createElement);
+var HelmetData = class {
+  instances = [];
+  canUseDOM = isDocument;
+  context;
+  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) {
+    this.context = context;
+    this.canUseDOM = canUseDOM || false;
+    if (!canUseDOM) {
+      context.helmet = server_default({
+        baseTag: [],
+        bodyAttributes: {},
+        encodeSpecialCharacters: true,
+        htmlAttributes: {},
+        linkTags: [],
+        metaTags: [],
+        noscriptTags: [],
+        scriptTags: [],
+        styleTags: [],
+        title: "",
+        titleAttributes: {}
+      });
+    }
+  }
+};
+
+// src/reactVersion.ts
+import React2 from "react";
+var major = parseInt(React2.version.split(".")[0], 10);
+var isReact19 = major >= 19;
+
+// src/Provider.tsx
+var defaultValue = {};
+var Context = React3.createContext(defaultValue);
+var HelmetProvider = class _HelmetProvider extends Component {
+  static canUseDOM = isDocument;
+  helmetData;
+  constructor(props) {
+    super(props);
+    if (isReact19) {
+      this.helmetData = null;
+    } else {
+      this.helmetData = new HelmetData(this.props.context || {}, _HelmetProvider.canUseDOM);
+    }
+  }
+  render() {
+    if (isReact19) {
+      return /* @__PURE__ */ React3.createElement(React3.Fragment, null, this.props.children);
+    }
+    return /* @__PURE__ */ React3.createElement(Context.Provider, { value: this.helmetData.value }, this.props.children);
+  }
+};
+
+// src/Dispatcher.tsx
+import { Component as Component2 } from "react";
+import shallowEqual from "shallowequal";
+
+// src/client.ts
+var updateTags = (type, tags) => {
+  const headElement = document.head || document.querySelector("head" /* 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);
+      for (const attribute in tag) {
+        if (Object.prototype.hasOwnProperty.call(tag, attribute)) {
+          if (attribute === "innerHTML" /* INNER_HTML */) {
+            newElement.innerHTML = tag.innerHTML;
+          } else if (attribute === "cssText" /* CSS_TEXT */) {
+            const cssText = tag.cssText;
+            newElement.appendChild(document.createTextNode(cssText));
+          } else {
+            const attr = attribute;
+            const value = typeof tag[attr] === "undefined" ? "" : tag[attr];
+            newElement.setAttribute(attribute, value);
+          }
+        }
+      }
+      newElement.setAttribute(HELMET_ATTRIBUTE, "true");
+      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
+  };
+};
+var 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 = [...helmetAttributes];
+  const attributeKeys = Object.keys(attributes);
+  for (const attribute of attributeKeys) {
+    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(","));
+  }
+};
+var updateTitle = (title, attributes) => {
+  if (typeof title !== "undefined" && document.title !== title) {
+    document.title = flattenArray(title);
+  }
+  updateAttributes("title" /* TITLE */, attributes);
+};
+var commitTagChanges = (newState, cb) => {
+  const {
+    baseTag,
+    bodyAttributes,
+    htmlAttributes,
+    linkTags,
+    metaTags,
+    noscriptTags,
+    onChangeClientState,
+    scriptTags,
+    styleTags,
+    title,
+    titleAttributes
+  } = newState;
+  updateAttributes("body" /* BODY */, bodyAttributes);
+  updateAttributes("html" /* HTML */, htmlAttributes);
+  updateTitle(title, titleAttributes);
+  const tagUpdates = {
+    baseTag: updateTags("base" /* BASE */, baseTag),
+    linkTags: updateTags("link" /* LINK */, linkTags),
+    metaTags: updateTags("meta" /* META */, metaTags),
+    noscriptTags: updateTags("noscript" /* NOSCRIPT */, noscriptTags),
+    scriptTags: updateTags("script" /* SCRIPT */, scriptTags),
+    styleTags: updateTags("style" /* 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);
+};
+var _helmetCallback = null;
+var handleStateChangeOnClient = (newState) => {
+  if (_helmetCallback) {
+    cancelAnimationFrame(_helmetCallback);
+  }
+  if (newState.defer) {
+    _helmetCallback = requestAnimationFrame(() => {
+      commitTagChanges(newState, () => {
+        _helmetCallback = null;
+      });
+    });
+  } else {
+    commitTagChanges(newState);
+    _helmetCallback = null;
+  }
+};
+var client_default = handleStateChangeOnClient;
+
+// src/Dispatcher.tsx
+var HelmetDispatcher = class extends Component2 {
+  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 { context: _context, ...props } = instance.props;
+        return props;
+      })
+    );
+    if (HelmetProvider.canUseDOM) {
+      client_default(state);
+    } else if (server_default) {
+      serverState = server_default(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;
+  }
+};
+
+// src/React19Dispatcher.tsx
+import React4, { Component as Component3 } from "react";
+var react19Instances = [];
+var toHtmlAttributes = (props) => {
+  const result = {};
+  for (const key of Object.keys(props)) {
+    result[HTML_TAG_MAP[key] || key] = props[key];
+  }
+  return result;
+};
+var toReactProps = (attrs) => {
+  const result = {};
+  for (const key of Object.keys(attrs)) {
+    const mapped = REACT_TAG_MAP[key];
+    result[mapped || key] = attrs[key];
+  }
+  return result;
+};
+var applyAttributes = (tagName, attributes) => {
+  if (!isDocument)
+    return;
+  const el = document.getElementsByTagName(tagName)[0];
+  if (!el)
+    return;
+  const managedAttr = "data-rh-managed";
+  const prev = el.getAttribute(managedAttr);
+  const prevKeys = prev ? prev.split(",") : [];
+  const nextKeys = Object.keys(attributes);
+  for (const key of prevKeys) {
+    if (!nextKeys.includes(key)) {
+      el.removeAttribute(key);
+    }
+  }
+  for (const key of nextKeys) {
+    const value = attributes[key];
+    if (value === void 0 || value === null || value === false) {
+      el.removeAttribute(key);
+    } else if (value === true) {
+      el.setAttribute(key, "");
+    } else {
+      el.setAttribute(key, String(value));
+    }
+  }
+  if (nextKeys.length > 0) {
+    el.setAttribute(managedAttr, nextKeys.join(","));
+  } else {
+    el.removeAttribute(managedAttr);
+  }
+};
+var syncAllAttributes = () => {
+  const htmlAttrs = {};
+  const bodyAttrs = {};
+  for (const instance of react19Instances) {
+    const { htmlAttributes, bodyAttributes } = instance.props;
+    if (htmlAttributes) {
+      Object.assign(htmlAttrs, toHtmlAttributes(htmlAttributes));
+    }
+    if (bodyAttributes) {
+      Object.assign(bodyAttrs, toHtmlAttributes(bodyAttributes));
+    }
+  }
+  applyAttributes("html" /* HTML */, htmlAttrs);
+  applyAttributes("body" /* BODY */, bodyAttrs);
+};
+var React19Dispatcher = class extends Component3 {
+  componentDidMount() {
+    react19Instances.push(this);
+    syncAllAttributes();
+  }
+  componentDidUpdate() {
+    syncAllAttributes();
+  }
+  componentWillUnmount() {
+    const index = react19Instances.indexOf(this);
+    if (index !== -1) {
+      react19Instances.splice(index, 1);
+    }
+    syncAllAttributes();
+  }
+  resolveTitle() {
+    const { title, titleTemplate, defaultTitle } = this.props;
+    if (title && titleTemplate) {
+      return titleTemplate.replace(/%s/g, () => Array.isArray(title) ? title.join("") : title);
+    }
+    return title || defaultTitle || void 0;
+  }
+  renderTitle() {
+    const title = this.resolveTitle();
+    if (title === void 0)
+      return null;
+    const titleAttributes = this.props.titleAttributes || {};
+    return React4.createElement("title" /* TITLE */, toReactProps(titleAttributes), title);
+  }
+  renderBase() {
+    const { base } = this.props;
+    if (!base)
+      return null;
+    return React4.createElement("base" /* BASE */, toReactProps(base));
+  }
+  renderMeta() {
+    const { meta } = this.props;
+    if (!meta || !Array.isArray(meta))
+      return null;
+    return meta.map(
+      (attrs, i) => React4.createElement("meta" /* META */, {
+        key: i,
+        ...toReactProps(attrs)
+      })
+    );
+  }
+  renderLink() {
+    const { link } = this.props;
+    if (!link || !Array.isArray(link))
+      return null;
+    return link.map(
+      (attrs, i) => React4.createElement("link" /* LINK */, {
+        key: i,
+        ...toReactProps(attrs)
+      })
+    );
+  }
+  renderScript() {
+    const { script } = this.props;
+    if (!script || !Array.isArray(script))
+      return null;
+    return script.map((attrs, i) => {
+      const { innerHTML, ...rest } = attrs;
+      const props = toReactProps(rest);
+      if (innerHTML) {
+        props.dangerouslySetInnerHTML = { __html: innerHTML };
+      }
+      return React4.createElement("script" /* SCRIPT */, { key: i, ...props });
+    });
+  }
+  renderStyle() {
+    const { style } = this.props;
+    if (!style || !Array.isArray(style))
+      return null;
+    return style.map((attrs, i) => {
+      const { cssText, ...rest } = attrs;
+      const props = toReactProps(rest);
+      if (cssText) {
+        props.dangerouslySetInnerHTML = { __html: cssText };
+      }
+      return React4.createElement("style" /* STYLE */, { key: i, ...props });
+    });
+  }
+  renderNoscript() {
+    const { noscript } = this.props;
+    if (!noscript || !Array.isArray(noscript))
+      return null;
+    return noscript.map((attrs, i) => {
+      const { innerHTML, ...rest } = attrs;
+      const props = toReactProps(rest);
+      if (innerHTML) {
+        props.dangerouslySetInnerHTML = { __html: innerHTML };
+      }
+      return React4.createElement("noscript" /* NOSCRIPT */, { key: i, ...props });
+    });
+  }
+  render() {
+    return React4.createElement(
+      React4.Fragment,
+      null,
+      this.renderTitle(),
+      this.renderBase(),
+      this.renderMeta(),
+      this.renderLink(),
+      this.renderScript(),
+      this.renderStyle(),
+      this.renderNoscript()
+    );
+  }
+};
+
+// src/index.tsx
+var Helmet = class extends Component4 {
+  static defaultProps = {
+    defer: true,
+    encodeSpecialCharacters: true,
+    prioritizeSeoTags: false
+  };
+  shouldComponentUpdate(nextProps) {
+    return !fastCompare(without(this.props, "helmetData"), without(nextProps, "helmetData"));
+  }
+  mapNestedChildrenToProps(child, nestedChildren) {
+    if (!nestedChildren) {
+      return null;
+    }
+    switch (child.type) {
+      case "script" /* SCRIPT */:
+      case "noscript" /* NOSCRIPT */:
+        return {
+          innerHTML: nestedChildren
+        };
+      case "style" /* 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 "title" /* TITLE */:
+        return {
+          ...newProps,
+          [child.type]: nestedChildren,
+          titleAttributes: { ...newChildProps }
+        };
+      case "body" /* BODY */:
+        return {
+          ...newProps,
+          bodyAttributes: { ...newChildProps }
+        };
+      case "html" /* 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 = {};
+    React5.Children.forEach(children, (child) => {
+      if (!child || !child.props) {
+        return;
+      }
+      const { children: nestedChildren, ...childProps } = child.props;
+      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 "Symbol(react.fragment)" /* FRAGMENT */:
+          newProps = this.mapChildrenToProps(nestedChildren, newProps);
+          break;
+        case "link" /* LINK */:
+        case "meta" /* META */:
+        case "noscript" /* NOSCRIPT */:
+        case "script" /* SCRIPT */:
+        case "style" /* 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)) {
+      const data = helmetData;
+      helmetData = new HelmetData(data.context, true);
+      delete newProps.helmetData;
+    }
+    if (isReact19) {
+      return /* @__PURE__ */ React5.createElement(React19Dispatcher, { ...newProps });
+    }
+    return helmetData ? /* @__PURE__ */ React5.createElement(HelmetDispatcher, { ...newProps, context: helmetData.value }) : /* @__PURE__ */ React5.createElement(Context.Consumer, null, (context) => /* @__PURE__ */ React5.createElement(HelmetDispatcher, { ...newProps, context }));
+  }
+};
+export {
+  Helmet,
+  HelmetData,
+  HelmetProvider
+};

node_modules/react-helmet-async/lib/reactVersion.d.ts

@@ -0,0 +1 @@
+export declare const isReact19: boolean;

node_modules/react-helmet-async/lib/server.d.ts

@@ -0,0 +1,45 @@
+import React from 'react';
+import type { MappedServerState } from './types';
+declare const mapStateOnServer: (props: MappedServerState) => {
+    priority: {
+        toComponent: () => React.ReactElement[];
+        toString: () => string;
+    };
+    base: {
+        toComponent: () => {};
+        toString: () => string;
+    };
+    bodyAttributes: {
+        toComponent: () => {};
+        toString: () => string;
+    };
+    htmlAttributes: {
+        toComponent: () => {};
+        toString: () => string;
+    };
+    link: {
+        toComponent: () => {};
+        toString: () => string;
+    };
+    meta: {
+        toComponent: () => {};
+        toString: () => string;
+    };
+    noscript: {
+        toComponent: () => {};
+        toString: () => string;
+    };
+    script: {
+        toComponent: () => {};
+        toString: () => string;
+    };
+    style: {
+        toComponent: () => {};
+        toString: () => string;
+    };
+    title: {
+        toComponent: () => {};
+        toString: () => string;
+    };
+};
+export default mapStateOnServer;

node_modules/react-helmet-async/lib/types.d.ts

@@ -0,0 +1,84 @@
+import type { HTMLAttributes, JSX } from 'react';
+import type HelmetData from './HelmetData';
+export type Attributes = {
+    [key: string]: string;
+};
+interface OtherElementAttributes {
+    [key: string]: string | number | boolean | null | undefined;
+}
+export type HtmlProps = JSX.IntrinsicElements['html'] & OtherElementAttributes;
+export type BodyProps = JSX.IntrinsicElements['body'] & OtherElementAttributes;
+export type LinkProps = JSX.IntrinsicElements['link'];
+export type MetaProps = JSX.IntrinsicElements['meta'] & {
+    charset?: string | undefined;
+    'http-equiv'?: string | undefined;
+    itemprop?: string | undefined;
+};
+export type TitleProps = HTMLAttributes<HTMLTitleElement>;
+export interface HelmetTags {
+    baseTag: HTMLBaseElement[];
+    linkTags: HTMLLinkElement[];
+    metaTags: HTMLMetaElement[];
+    noscriptTags: HTMLElement[];
+    scriptTags: HTMLScriptElement[];
+    styleTags: HTMLStyleElement[];
+}
+export interface HelmetDatum {
+    toString(): string;
+    toComponent(): React.ReactElement[];
+}
+export interface HelmetHTMLBodyDatum {
+    toString(): string;
+    toComponent(): React.HTMLAttributes<HTMLBodyElement>;
+}
+export interface HelmetHTMLElementDatum {
+    toString(): string;
+    toComponent(): React.HTMLAttributes<HTMLHtmlElement>;
+}
+export interface HelmetServerState {
+    base: HelmetDatum;
+    bodyAttributes: HelmetHTMLBodyDatum;
+    htmlAttributes: HelmetHTMLElementDatum;
+    link: HelmetDatum;
+    meta: HelmetDatum;
+    noscript: HelmetDatum;
+    script: HelmetDatum;
+    style: HelmetDatum;
+    title: HelmetDatum;
+    priority: HelmetDatum;
+}
+export type MappedServerState = HelmetProps & HelmetTags & {
+    encode?: boolean;
+};
+export interface TagList {
+    [key: string]: HTMLElement[];
+}
+export interface StateUpdate extends HelmetTags {
+    bodyAttributes: BodyProps;
+    defer: boolean;
+    htmlAttributes: HtmlProps;
+    onChangeClientState: (newState: StateUpdate, addedTags: TagList, removedTags: TagList) => void;
+    title: string;
+    titleAttributes: TitleProps;
+}
+export interface HelmetProps {
+    async?: boolean;
+    base?: Attributes;
+    bodyAttributes?: BodyProps;
+    defaultTitle?: string;
+    defer?: boolean;
+    encodeSpecialCharacters?: boolean;
+    helmetData?: HelmetData;
+    htmlAttributes?: HtmlProps;
+    onChangeClientState?: (newState: StateUpdate, addedTags: HelmetTags, removedTags: HelmetTags) => void;
+    link?: LinkProps[];
+    meta?: MetaProps[];
+    noscript?: Attributes[];
+    script?: Attributes[];
+    style?: Attributes[];
+    title?: string;
+    titleAttributes?: Attributes;
+    titleTemplate?: string;
+    prioritizeSeoTags?: boolean;
+}
+export {};

node_modules/react-helmet-async/lib/utils.d.ts

@@ -0,0 +1,33 @@
+interface PropList {
+    [key: string]: any;
+}
+type PropsList = PropList[];
+type AttributeList = string[];
+interface MatchProps {
+    [key: string]: string | AttributeList;
+}
+declare const reducePropsToState: (propsList: PropsList) => {
+    baseTag: any;
+    bodyAttributes: any;
+    defer: any;
+    encode: any;
+    htmlAttributes: any;
+    linkTags: any;
+    metaTags: any;
+    noscriptTags: any;
+    onChangeClientState: any;
+    scriptTags: any;
+    styleTags: any;
+    title: any;
+    titleAttributes: any;
+    prioritizeSeoTags: boolean;
+};
+export declare const flattenArray: (possibleArray: string[] | string) => string;
+export { reducePropsToState };
+export declare const prioritizer: (elementsList: HTMLElement[], propsToMatch: MatchProps) => {
+    priority: HTMLElement[];
+    default: HTMLElement[];
+};
+export declare const without: (obj: PropList, key: string) => {
+    [x: string]: any;
+};

node_modules/react-helmet-async/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "react-helmet-async",
+  "version": "3.0.0",
+  "description": "Thread-safe Helmet for React 16–18, with native support for React 19+",
+  "sideEffects": false,
+  "main": "./lib/index.js",
+  "module": "./lib/index.esm.js",
+  "types": "./lib/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./lib/index.d.ts",
+        "default": "./lib/index.esm.js"
+      },
+      "require": {
+        "types": "./lib/index.d.ts",
+        "default": "./lib/index.js"
+      }
+    }
+  },
+  "repository": "http://github.com/staylor/react-helmet-async",
+  "author": "Scott Taylor <scott.c.taylor@mac.com>",
+  "license": "Apache-2.0",
+  "files": [
+    "lib/"
+  ],
+  "dependencies": {
+    "invariant": "^2.2.4",
+    "react-fast-compare": "^3.2.2",
+    "shallowequal": "^1.1.0"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "18.4.3",
+    "@commitlint/config-conventional": "18.4.3",
+    "@playwright/test": "^1.58.2",
+    "@remix-run/eslint-config": "2.3.1",
+    "@testing-library/jest-dom": "6.1.5",
+    "@testing-library/react": "14.1.2",
+    "@types/eslint": "8.44.8",
+    "@types/invariant": "2.2.37",
+    "@types/jsdom": "21.1.6",
+    "@types/react": "18.2.39",
+    "@types/react-dom": "^18.3.7",
+    "@types/shallowequal": "1.1.5",
+    "@vitejs/plugin-react": "4.2.0",
+    "esbuild": "0.19.8",
+    "eslint": "8.54.0",
+    "eslint-config-prettier": "9.0.0",
+    "eslint-plugin-prettier": "5.0.1",
+    "husky": "8.0.3",
+    "jsdom": "22.1.0",
+    "playwright": "^1.58.2",
+    "prettier": "3.1.0",
+    "raf": "3.4.1",
+    "react": "18.2.0",
+    "react-dom": "18.2.0",
+    "rimraf": "5.0.5",
+    "tsx": "4.6.1",
+    "typescript": "5.2.2",
+    "vite": "4.5.0",
+    "vitest": "0.34.6"
+  },
+  "peerDependencies": {
+    "react": "^16.6.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+  },
+  "scripts": {
+    "clean": "rimraf lib",
+    "lint": "eslint --cache --cache-location ./node_modules/.cache/eslint --report-unused-disable-directives .",
+    "lint-fix": "pnpm lint --fix",
+    "test": "vitest run",
+    "test:e2e:server": "vitest run --config e2e/vitest.config.ts",
+    "test:e2e:browser": "playwright test --config e2e/playwright.config.ts",
+    "test:e2e": "pnpm run test:e2e:server && pnpm run test:e2e:browser",
+    "test:all": "pnpm test && pnpm run test:e2e",
+    "test-watch": "pnpm test -- --watch",
+    "test-update": "pnpm test -- -u",
+    "compile": "pnpm run clean && NODE_ENV=production tsx build.ts && pnpm run types",
+    "prepare": "pnpm run compile && husky install",
+    "types": "tsc --project tsconfig.build.json"
+  }
+}