@dotcms/react 0.0.1-alpha.9 → 0.0.1-beta.2

package/index.esm.js

@@ -0,0 +1,3461 @@
+import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
+import { s as styleInject, f as functionUncurryThis, t as toString$4, r as requireObjectCoercible$1, a as toIntegerOrInfinity$1, i as iteratorDefine, b as internalState, c as createIterResultObject$2, d as fails$2, w as wellKnownSymbol$4, e as descriptors, g as classofRaw$1, h as aCallable$2, j as functionBindNative, m as makeBuiltInExports, o as objectDefineProperty, k as objectIsPrototypeOf, l as functionCall, n as anObject$4, p as getMethod$2, q as iterators, u as getBuiltIn$1, v as isCallable$2, x as classof$3, y as inspectSource$1, z as createPropertyDescriptor$2, A as isNullOrUndefined$1, B as tryToString$1, C as toObject$1, D as lengthOfArrayLike$1, E as global$3, F as defineBuiltIn$5, G as arraySlice$2, _ as _export, H as setToStringTag$2, I as iteratorCreateConstructor, J as isObject$1, K as objectCreate, L as hasOwnProperty_1, M as objectAssign } from './es.regexp.to-string.esm.js';
+import { useState, useEffect, createContext, useRef, useContext, createElement, forwardRef } from 'react';
+import { isInsideEditor, initEditor, updateNavigation, destroyEditor, DotCmsClient, postMessageToEditor, CLIENT_ACTIONS, NOTIFY_CLIENT, initInlineEditing } from '@dotcms/client';
+import { Editor } from '@tinymce/tinymce-react';
+
+var isPure = false;
+
+/**
+ * Custom Hook to handle the DotCMS editor interaction with the page.
+ *
+ * @category Hooks
+ * @param {DotcmsPageProps} props {
+ *     pageContext,
+ *     config,
+ * }
+ * @returns {DotCMSPageContext} The context for a DotCMS page provided by the editor.
+ */
+const useDotcmsEditor = ({
+  pageContext,
+  config
+}) => {
+  const {
+    pathname,
+    onReload,
+    editor
+  } = config;
+  const [state, setState] = useState(Object.assign({}, pageContext, {
+    isInsideEditor: false
+  }));
+  /**
+   * Initializes the DotCMS editor.
+   */
+  useEffect(() => {
+    if (!isInsideEditor()) {
+      return;
+    }
+    initEditor({
+      pathname
+    });
+    updateNavigation(pathname || '/');
+    setState(prevState => Object.assign({}, prevState, {
+      isInsideEditor: true
+    }));
+    return () => destroyEditor();
+  }, [pathname]);
+  /**
+   * Reloads the page when changes are made in the editor.
+   */
+  useEffect(() => {
+    const insideEditor = isInsideEditor();
+    const client = DotCmsClient.instance;
+    if (!insideEditor || !onReload) {
+      return;
+    }
+    client.editor.on('changes', () => onReload == null ? void 0 : onReload());
+    return () => client.editor.off('changes');
+  }, [onReload]);
+  /**
+   * Sends a message to the editor when the client is ready.
+   */
+  useEffect(() => {
+    if (!isInsideEditor()) {
+      return;
+    }
+    postMessageToEditor({
+      action: CLIENT_ACTIONS.CLIENT_READY,
+      payload: editor
+    });
+  }, [pathname, editor]);
+  /**
+   * Updates the page asset when changes are made in the editor.
+   */
+  useEffect(() => {
+    if (!isInsideEditor()) {
+      return;
+    }
+    const client = DotCmsClient.instance;
+    client.editor.on('changes', data => {
+      const pageAsset = data;
+      setState(state => Object.assign({}, state, {
+        pageAsset
+      }));
+    });
+    return () => client.editor.off('changes');
+  }, []);
+  return state;
+};
+
+/**
+ * The `PageContext` is a React context that provides access to the DotCMS page context.
+ *
+ * @category Contexts
+ */
+const PageContext = /*#__PURE__*/createContext(null);
+
+/**
+ * `PageProvider` is a functional component that provides a context for a DotCMS page.
+ * It takes a `PageProviderProps` object as a parameter and returns a JSX element.
+ *
+ * @category Components
+ * @param {PageProviderProps} props - The properties for the PageProvider. Includes an `entity` and `children`.
+ * @returns {JSX.Element} - A JSX element that provides a context for a DotCMS page.
+ */
+function PageProvider(props) {
+  const {
+    pageContext,
+    children
+  } = props;
+  return jsx(PageContext.Provider, {
+    value: pageContext,
+    children: children
+  });
+}
+
+var css_248z$1 = ".Row-module_row__1QEdR {\n    display: grid;\n    grid-template-columns: repeat(12, 1fr);\n    gap: 1rem;\n}\n";
+var styles$1 = {"row":"Row-module_row__1QEdR"};
+styleInject(css_248z$1);
+
+var css_248z = ".Column-module_col-start-1__pAqyF {\n    grid-column-start: 1;\n}\n\n.Column-module_col-start-2__WwVhl {\n    grid-column-start: 2;\n}\n\n.Column-module_col-start-3__DAtqM {\n    grid-column-start: 3;\n}\n\n.Column-module_col-start-4__KAXJl {\n    grid-column-start: 4;\n}\n\n.Column-module_col-start-5__9yg8H {\n    grid-column-start: 5;\n}\n\n.Column-module_col-start-6__L9Fl1 {\n    grid-column-start: 6;\n}\n\n.Column-module_col-start-7__7GWMg {\n    grid-column-start: 7;\n}\n\n.Column-module_col-start-8__VPNje {\n    grid-column-start: 8;\n}\n\n.Column-module_col-start-9__TQinR {\n    grid-column-start: 9;\n}\n\n.Column-module_col-start-10__WuD2n {\n    grid-column-start: 10;\n}\n\n.Column-module_col-start-11__ZYzHu {\n    grid-column-start: 11;\n}\n\n.Column-module_col-start-12__XupQX {\n    grid-column-start: 12;\n}\n\n.Column-module_col-end-1__thNVg {\n    grid-column-end: 1;\n}\n\n.Column-module_col-end-2__7vCsE {\n    grid-column-end: 2;\n}\n\n.Column-module_col-end-3__TiQJe {\n    grid-column-end: 3;\n}\n\n.Column-module_col-end-4__66z6K {\n    grid-column-end: 4;\n}\n\n.Column-module_col-end-5__MLwPh {\n    grid-column-end: 5;\n}\n\n.Column-module_col-end-6__dz6-q {\n    grid-column-end: 6;\n}\n\n.Column-module_col-end-7__Loe0Q {\n    grid-column-end: 7;\n}\n\n.Column-module_col-end-8__NePGi {\n    grid-column-end: 8;\n}\n\n.Column-module_col-end-9__V0-is {\n    grid-column-end: 9;\n}\n\n.Column-module_col-end-10__b-1ia {\n    grid-column-end: 10;\n}\n\n.Column-module_col-end-11__QroWM {\n    grid-column-end: 11;\n}\n\n.Column-module_col-end-12__j-YYw {\n    grid-column-end: 12;\n}\n\n.Column-module_col-end-13__khBAA {\n    grid-column-end: 13;\n}\n";
+var styles = {"col-start-1":"Column-module_col-start-1__pAqyF","col-start-2":"Column-module_col-start-2__WwVhl","col-start-3":"Column-module_col-start-3__DAtqM","col-start-4":"Column-module_col-start-4__KAXJl","col-start-5":"Column-module_col-start-5__9yg8H","col-start-6":"Column-module_col-start-6__L9Fl1","col-start-7":"Column-module_col-start-7__7GWMg","col-start-8":"Column-module_col-start-8__VPNje","col-start-9":"Column-module_col-start-9__TQinR","col-start-10":"Column-module_col-start-10__WuD2n","col-start-11":"Column-module_col-start-11__ZYzHu","col-start-12":"Column-module_col-start-12__XupQX","col-end-1":"Column-module_col-end-1__thNVg","col-end-2":"Column-module_col-end-2__7vCsE","col-end-3":"Column-module_col-end-3__TiQJe","col-end-4":"Column-module_col-end-4__66z6K","col-end-5":"Column-module_col-end-5__MLwPh","col-end-6":"Column-module_col-end-6__dz6-q","col-end-7":"Column-module_col-end-7__Loe0Q","col-end-8":"Column-module_col-end-8__NePGi","col-end-9":"Column-module_col-end-9__V0-is","col-end-10":"Column-module_col-end-10__b-1ia","col-end-11":"Column-module_col-end-11__QroWM","col-end-12":"Column-module_col-end-12__j-YYw","col-end-13":"Column-module_col-end-13__khBAA"};
+styleInject(css_248z);
+
+const endClassMap = {
+  1: 'col-end-1',
+  2: 'col-end-2',
+  3: 'col-end-3',
+  4: 'col-end-4',
+  5: 'col-end-5',
+  6: 'col-end-6',
+  7: 'col-end-7',
+  8: 'col-end-8',
+  9: 'col-end-9',
+  10: 'col-end-10',
+  11: 'col-end-11',
+  12: 'col-end-12',
+  13: 'col-end-13'
+};
+const startClassMap = {
+  1: 'col-start-1',
+  2: 'col-start-2',
+  3: 'col-start-3',
+  4: 'col-start-4',
+  5: 'col-start-5',
+  6: 'col-start-6',
+  7: 'col-start-7',
+  8: 'col-start-8',
+  9: 'col-start-9',
+  10: 'col-start-10',
+  11: 'col-start-11',
+  12: 'col-start-12'
+};
+/**
+ * Get the container data from the containers object using the current container reference obtained from the layout.
+ *
+ * @param {ContainerData} containers
+ * @param {DotCMSPageContext['pageAsset']['layout']['body']['rows'][0]['columns'][0]['containers'][0]} containerRef
+ * @returns {Object} Container with all the data it has.
+ */
+const getContainersData = (containers, containerRef) => {
+  var _containers$identifie;
+  const {
+    identifier,
+    uuid
+  } = containerRef;
+  const {
+    containerStructures,
+    container
+  } = containers[identifier];
+  // Get the variant id
+  const {
+    variantId
+  } = (container == null ? void 0 : container.parentPermissionable) || {};
+  // Get accepts types of content types for this container
+  const acceptTypes = containerStructures.map(structure => structure.contentTypeVar).join(',');
+  // Get the contentlets for "this" container
+  const contentlets = (_containers$identifie = containers[identifier].contentlets[`uuid-${uuid}`]) != null ? _containers$identifie : containers[identifier].contentlets[`uuid-dotParser_${uuid}`];
+  if (!contentlets) {
+    console.warn(`We couldn't find the contentlets for the container with the identifier ${identifier} and the uuid ${uuid} becareful by adding content to this container.\nWe recommend to change the container in the layout and add the content again.`);
+  }
+  return Object.assign({}, containers[identifier].container, {
+    acceptTypes,
+    contentlets: contentlets != null ? contentlets : [],
+    variantId
+  });
+};
+/**
+ * Combine classes into a single string.
+ *
+ * @param {string[]} classes
+ * @returns {string} Combined classes
+ */
+const combineClasses = classes => classes.filter(Boolean).join(' ');
+/**
+ * Get the start and end classes for the column based on the left offset and width.
+ *
+ * @param {number} start
+ * @param {number} end
+ * @returns {Object} Start and end classes
+ */
+const getPositionStyleClasses = (start, end) => {
+  const startClass = startClassMap[start];
+  const endClass = endClassMap[end];
+  return {
+    startClass,
+    endClass
+  };
+};
+/**
+ * Validates the structure of a Block Editor block.
+ *
+ * This function checks that:
+ * 1. The blocks parameter is a valid object
+ * 2. The block has a 'doc' type
+ * 3. The block has a valid content array that is not empty
+ *
+ * @param {Block} blocks - The blocks structure to validate
+ * @returns {BlockEditorState} Object containing validation state and any error message
+ * @property {boolean} BlockEditorState.isValid - Whether the blocks structure is valid
+ * @property {string | null} BlockEditorState.error - Error message if invalid, null if valid
+ */
+const isValidBlocks = blocks => {
+  if (!blocks) {
+    return {
+      error: `Error: Blocks object is not defined`
+    };
+  }
+  if (typeof blocks !== 'object') {
+    return {
+      error: `Error: Blocks must be an object, but received: ${typeof blocks}`
+    };
+  }
+  if (blocks.type !== 'doc') {
+    return {
+      error: 'Error: Blocks must have a doc type'
+    };
+  }
+  if (!blocks.content || !Array.isArray(blocks.content)) {
+    return {
+      error: 'Error: Blocks must have a valid content array'
+    };
+  }
+  if (blocks.content.length === 0) {
+    return {
+      error: 'Error: Blocks content is empty'
+    };
+  }
+  return {
+    error: null
+  };
+};
+
+const useCheckHaveContent = () => {
+  const contentletDivRef = useRef(null);
+  const [haveContent, setHaveContent] = useState(false);
+  useEffect(() => {
+    if (!contentletDivRef.current) {
+      return;
+    }
+    const childElement = contentletDivRef.current.firstElementChild;
+    if (!childElement) {
+      return;
+    }
+    const height = childElement.getBoundingClientRect().height;
+    if (height > 0) {
+      setHaveContent(true);
+      return;
+    }
+    setHaveContent(false);
+  }, [contentletDivRef]);
+  return {
+    contentletDivRef,
+    haveContent
+  };
+};
+
+/**
+ * Component to render when there is no component for the content type.
+ *
+ * @param {{ readonly contentType: string }} { contentType }
+ * @return {*}
+ */
+function NoComponent({
+  contentType
+}) {
+  return jsxs("div", {
+    "data-testid": "no-component",
+    children: ["No Component for ", contentType]
+  });
+}
+/**
+ * Component to render when there is no content in the container.
+ *
+ * @return {*}
+ */
+function EmptyContent() {
+  return null;
+}
+/**
+ * Renders a Container with its content using information provided by dotCMS Page API.
+ *
+ * @see {@link https://www.dotcms.com/docs/latest/page-rest-api-layout-as-a-service-laas}
+ * @export
+ * @param {ContainerProps} { containerRef }
+ * @return {JSX.Element} Rendered container with content
+ */
+function Container({
+  containerRef
+}) {
+  const {
+    isInsideEditor
+  } = useContext(PageContext);
+  const {
+    identifier,
+    uuid
+  } = containerRef;
+  const {
+    haveContent,
+    contentletDivRef
+  } = useCheckHaveContent();
+  // Get the containers from the global context
+  const {
+    pageAsset: {
+      containers
+    },
+    components
+  } = useContext(PageContext);
+  const {
+    acceptTypes,
+    contentlets,
+    maxContentlets,
+    variantId,
+    path
+  } = getContainersData(containers, containerRef);
+  const container = {
+    acceptTypes,
+    identifier: path != null ? path : identifier,
+    maxContentlets,
+    variantId,
+    uuid
+  };
+  const containerStyles = contentlets.length ? undefined : {
+    width: '100%',
+    backgroundColor: '#ECF0FD',
+    display: 'flex',
+    justifyContent: 'center',
+    alignItems: 'center',
+    color: '#030E32',
+    height: '10rem'
+  };
+  const ContainerChildren = contentlets.map(contentlet => {
+    const ContentTypeComponent = components[contentlet.contentType];
+    const DefaultComponent = components['CustomNoComponent'] || NoComponent;
+    const Component = isInsideEditor ? ContentTypeComponent || DefaultComponent : ContentTypeComponent || EmptyContent;
+    return isInsideEditor ? jsx("div", {
+      "data-testid": "dot-contentlet",
+      "data-dot-object": "contentlet",
+      "data-dot-identifier": contentlet.identifier,
+      "data-dot-basetype": contentlet.baseType,
+      "data-dot-title": contentlet.widgetTitle || contentlet.title,
+      "data-dot-inode": contentlet.inode,
+      "data-dot-type": contentlet.contentType,
+      "data-dot-container": JSON.stringify(container),
+      "data-dot-on-number-of-pages": contentlet.onNumberOfPages,
+      ref: contentletDivRef,
+      style: {
+        minHeight: haveContent ? undefined : '4rem'
+      },
+      children: jsx(Component, Object.assign({}, contentlet))
+    }, contentlet.identifier) : (/*#__PURE__*/createElement(Component, Object.assign({}, contentlet, {
+      key: contentlet.identifier
+    })));
+  });
+  return isInsideEditor ? jsx("div", {
+    "data-testid": "dot-container",
+    "data-dot-object": "container",
+    "data-dot-accept-types": acceptTypes,
+    "data-dot-identifier": path != null ? path : identifier,
+    "data-max-contentlets": maxContentlets,
+    "data-dot-uuid": uuid,
+    style: containerStyles,
+    children: ContainerChildren.length ? ContainerChildren : 'This container is empty.'
+  }) :
+  // eslint-disable-next-line react/jsx-no-useless-fragment
+  jsx(Fragment, {
+    children: ContainerChildren
+  });
+}
+
+/**
+ * Renders a Column with its containers using information provided by dotCMS Page API.
+ *
+ * @see {@link https://www.dotcms.com/docs/latest/page-rest-api-layout-as-a-service-laas}
+ * @export
+ * @param {ColumnProps} { column }
+ * @return {JSX.Element} Rendered column with containers
+ */
+function Column({
+  column
+}) {
+  const {
+    isInsideEditor
+  } = useContext(PageContext);
+  const {
+    startClass,
+    endClass
+  } = getPositionStyleClasses(column.leftOffset, column.width + column.leftOffset);
+  const combinedClasses = combineClasses([styles[endClass], styles[startClass]]);
+  const columnProps = isInsideEditor ? {
+    'data-dot': 'column',
+    'data-testid': 'column'
+  } : {};
+  return jsx("div", Object.assign({}, columnProps, {
+    className: combinedClasses,
+    children: jsx("div", {
+      className: column.styleClass,
+      children: column.containers.map(container => jsx(Container, {
+        containerRef: container
+      }, `${container.identifier}-${container.uuid}`))
+    })
+  }));
+}
+
+/**
+ * This component renders a row with all it's content using the layout provided by dotCMS Page API.
+ *
+ * @see {@link https://www.dotcms.com/docs/latest/page-rest-api-layout-as-a-service-laas}
+ * @category Components
+ * @param {React.ForwardedRef<HTMLDivElement, RowProps>} ref
+ * @return {JSX.Element} Rendered rows with columns
+ */
+const Row = /*#__PURE__*/forwardRef((props, ref) => {
+  const {
+    isInsideEditor
+  } = useContext(PageContext);
+  const {
+    row
+  } = props;
+  const rowProps = isInsideEditor ? {
+    'data-dot': 'row',
+    'data-testid': 'row',
+    ref
+  } : {};
+  return jsx("div", {
+    className: row.styleClass,
+    children: jsx("div", {
+      className: "container",
+      children: jsx("div", Object.assign({}, rowProps, {
+        className: styles$1.row,
+        children: row.columns.map((column, index) => jsx(Column, {
+          column: column
+        }, index))
+      }))
+    })
+  });
+});
+
+/**
+ * `DotcmsLayout` is a functional component that renders a layout for a DotCMS page.
+ * It takes a `DotcmsPageProps` object as a parameter and returns a JSX element.
+ *
+ * @category Components
+ * @param {DotcmsPageProps} props - The properties for the DotCMS page.
+ * @returns {JSX.Element} - A JSX element that represents the layout for a DotCMS page.
+ * @deprecated Use {@link https://github.com/dotCMS/core/blob/main/core-web/libs/sdk/react/src/lib/next/components/DotCMSLayoutBody/DotCMSLayoutBody.tsx DotCMSLayoutBody} instead.
+ */
+function DotcmsLayout(dotPageProps) {
+  var _pageContext$pageAsse;
+  const pageContext = useDotcmsEditor(dotPageProps);
+  return jsx(PageProvider, {
+    pageContext: pageContext,
+    children: (_pageContext$pageAsse = pageContext.pageAsset) == null || (_pageContext$pageAsse = _pageContext$pageAsse.layout) == null ? void 0 : _pageContext$pageAsse.body.rows.map((row, index) => jsx(Row, {
+      row: row
+    }, index))
+  });
+}
+
+var uncurryThis$9 = functionUncurryThis;
+var toIntegerOrInfinity = toIntegerOrInfinity$1;
+var toString$3 = toString$4;
+var requireObjectCoercible = requireObjectCoercible$1;
+
+var charAt$3 = uncurryThis$9(''.charAt);
+var charCodeAt$1 = uncurryThis$9(''.charCodeAt);
+var stringSlice$2 = uncurryThis$9(''.slice);
+
+var createMethod = function (CONVERT_TO_STRING) {
+  return function ($this, pos) {
+    var S = toString$3(requireObjectCoercible($this));
+    var position = toIntegerOrInfinity(pos);
+    var size = S.length;
+    var first, second;
+    if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;
+    first = charCodeAt$1(S, position);
+    return first < 0xD800 || first > 0xDBFF || position + 1 === size
+      || (second = charCodeAt$1(S, position + 1)) < 0xDC00 || second > 0xDFFF
+        ? CONVERT_TO_STRING
+          ? charAt$3(S, position)
+          : first
+        : CONVERT_TO_STRING
+          ? stringSlice$2(S, position, position + 2)
+          : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;
+  };
+};
+
+var stringMultibyte = {
+  // `String.prototype.codePointAt` method
+  // https://tc39.es/ecma262/#sec-string.prototype.codepointat
+  codeAt: createMethod(false),
+  // `String.prototype.at` method
+  // https://github.com/mathiasbynens/String.prototype.at
+  charAt: createMethod(true)
+};
+
+var charAt$2 = stringMultibyte.charAt;
+var toString$2 = toString$4;
+var InternalStateModule$2 = internalState;
+var defineIterator = iteratorDefine;
+var createIterResultObject$1 = createIterResultObject$2;
+
+var STRING_ITERATOR = 'String Iterator';
+var setInternalState$2 = InternalStateModule$2.set;
+var getInternalState = InternalStateModule$2.getterFor(STRING_ITERATOR);
+
+// `String.prototype[@@iterator]` method
+// https://tc39.es/ecma262/#sec-string.prototype-@@iterator
+defineIterator(String, 'String', function (iterated) {
+  setInternalState$2(this, {
+    type: STRING_ITERATOR,
+    string: toString$2(iterated),
+    index: 0
+  });
+// `%StringIteratorPrototype%.next` method
+// https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next
+}, function next() {
+  var state = getInternalState(this);
+  var string = state.string;
+  var index = state.index;
+  var point;
+  if (index >= string.length) return createIterResultObject$1(undefined, true);
+  point = charAt$2(string, index);
+  state.index += point.length;
+  return createIterResultObject$1(point, false);
+});
+
+var fails$1 = fails$2;
+var wellKnownSymbol$3 = wellKnownSymbol$4;
+var DESCRIPTORS$5 = descriptors;
+var IS_PURE = isPure;
+
+var ITERATOR$3 = wellKnownSymbol$3('iterator');
+
+var urlConstructorDetection = !fails$1(function () {
+  // eslint-disable-next-line unicorn/relative-url-style -- required for testing
+  var url = new URL('b?a=1&b=2&c=3', 'http://a');
+  var params = url.searchParams;
+  var params2 = new URLSearchParams('a=1&a=2&b=3');
+  var result = '';
+  url.pathname = 'c%20d';
+  params.forEach(function (value, key) {
+    params['delete']('b');
+    result += key + value;
+  });
+  params2['delete']('a', 2);
+  // `undefined` case is a Chromium 117 bug
+  // https://bugs.chromium.org/p/v8/issues/detail?id=14222
+  params2['delete']('b', undefined);
+  return (IS_PURE && (!url.toJSON || !params2.has('a', 1) || params2.has('a', 2) || !params2.has('a', undefined) || params2.has('b')))
+    || (!params.size && (IS_PURE || !DESCRIPTORS$5))
+    || !params.sort
+    || url.href !== 'http://a/c%20d?a=1&c=3'
+    || params.get('c') !== '3'
+    || String(new URLSearchParams('?a=1')) !== 'a=1'
+    || !params[ITERATOR$3]
+    // throws in Edge
+    || new URL('https://a@b').username !== 'a'
+    || new URLSearchParams(new URLSearchParams('a=b')).get('a') !== 'b'
+    // not punycoded in Edge
+    || new URL('http://тест').host !== 'xn--e1aybc'
+    // not escaped in Chrome 62-
+    || new URL('http://a#б').hash !== '#%D0%B1'
+    // fails in Chrome 66-
+    || result !== 'a1c3'
+    // throws in Safari
+    || new URL('http://x', undefined).host !== 'x';
+});
+
+var classofRaw = classofRaw$1;
+var uncurryThis$8 = functionUncurryThis;
+
+var functionUncurryThisClause = function (fn) {
+  // Nashorn bug:
+  //   https://github.com/zloirock/core-js/issues/1128
+  //   https://github.com/zloirock/core-js/issues/1130
+  if (classofRaw(fn) === 'Function') return uncurryThis$8(fn);
+};
+
+var uncurryThis$7 = functionUncurryThisClause;
+var aCallable$1 = aCallable$2;
+var NATIVE_BIND = functionBindNative;
+
+var bind$3 = uncurryThis$7(uncurryThis$7.bind);
+
+// optional / simple context binding
+var functionBindContext = function (fn, that) {
+  aCallable$1(fn);
+  return that === undefined ? fn : NATIVE_BIND ? bind$3(fn, that) : function (/* ...args */) {
+    return fn.apply(that, arguments);
+  };
+};
+
+var makeBuiltIn = makeBuiltInExports;
+var defineProperty = objectDefineProperty;
+
+var defineBuiltInAccessor$3 = function (target, name, descriptor) {
+  if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true });
+  if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true });
+  return defineProperty.f(target, name, descriptor);
+};
+
+var isPrototypeOf = objectIsPrototypeOf;
+
+var $TypeError$2 = TypeError;
+
+var anInstance$2 = function (it, Prototype) {
+  if (isPrototypeOf(Prototype, it)) return it;
+  throw new $TypeError$2('Incorrect invocation');
+};
+
+var call$4 = functionCall;
+var anObject$3 = anObject$4;
+var getMethod$1 = getMethod$2;
+
+var iteratorClose$1 = function (iterator, kind, value) {
+  var innerResult, innerError;
+  anObject$3(iterator);
+  try {
+    innerResult = getMethod$1(iterator, 'return');
+    if (!innerResult) {
+      if (kind === 'throw') throw value;
+      return value;
+    }
+    innerResult = call$4(innerResult, iterator);
+  } catch (error) {
+    innerError = true;
+    innerResult = error;
+  }
+  if (kind === 'throw') throw value;
+  if (innerError) throw innerResult;
+  anObject$3(innerResult);
+  return value;
+};
+
+var anObject$2 = anObject$4;
+var iteratorClose = iteratorClose$1;
+
+// call something on iterator step with safe closing on error
+var callWithSafeIterationClosing$1 = function (iterator, fn, value, ENTRIES) {
+  try {
+    return ENTRIES ? fn(anObject$2(value)[0], value[1]) : fn(value);
+  } catch (error) {
+    iteratorClose(iterator, 'throw', error);
+  }
+};
+
+var wellKnownSymbol$2 = wellKnownSymbol$4;
+var Iterators$1 = iterators;
+
+var ITERATOR$2 = wellKnownSymbol$2('iterator');
+var ArrayPrototype = Array.prototype;
+
+// check on default Array iterator
+var isArrayIteratorMethod$1 = function (it) {
+  return it !== undefined && (Iterators$1.Array === it || ArrayPrototype[ITERATOR$2] === it);
+};
+
+var uncurryThis$6 = functionUncurryThis;
+var fails = fails$2;
+var isCallable$1 = isCallable$2;
+var classof$2 = classof$3;
+var getBuiltIn = getBuiltIn$1;
+var inspectSource = inspectSource$1;
+
+var noop = function () { /* empty */ };
+var construct = getBuiltIn('Reflect', 'construct');
+var constructorRegExp = /^\s*(?:class|function)\b/;
+var exec$2 = uncurryThis$6(constructorRegExp.exec);
+var INCORRECT_TO_STRING = !constructorRegExp.test(noop);
+
+var isConstructorModern = function isConstructor(argument) {
+  if (!isCallable$1(argument)) return false;
+  try {
+    construct(noop, [], argument);
+    return true;
+  } catch (error) {
+    return false;
+  }
+};
+
+var isConstructorLegacy = function isConstructor(argument) {
+  if (!isCallable$1(argument)) return false;
+  switch (classof$2(argument)) {
+    case 'AsyncFunction':
+    case 'GeneratorFunction':
+    case 'AsyncGeneratorFunction': return false;
+  }
+  try {
+    // we can't check .prototype since constructors produced by .bind haven't it
+    // `Function#toString` throws on some built-it function in some legacy engines
+    // (for example, `DOMQuad` and similar in FF41-)
+    return INCORRECT_TO_STRING || !!exec$2(constructorRegExp, inspectSource(argument));
+  } catch (error) {
+    return true;
+  }
+};
+
+isConstructorLegacy.sham = true;
+
+// `IsConstructor` abstract operation
+// https://tc39.es/ecma262/#sec-isconstructor
+var isConstructor$1 = !construct || fails(function () {
+  var called;
+  return isConstructorModern(isConstructorModern.call)
+    || !isConstructorModern(Object)
+    || !isConstructorModern(function () { called = true; })
+    || called;
+}) ? isConstructorLegacy : isConstructorModern;
+
+var DESCRIPTORS$4 = descriptors;
+var definePropertyModule = objectDefineProperty;
+var createPropertyDescriptor$1 = createPropertyDescriptor$2;
+
+var createProperty$1 = function (object, key, value) {
+  if (DESCRIPTORS$4) definePropertyModule.f(object, key, createPropertyDescriptor$1(0, value));
+  else object[key] = value;
+};
+
+var classof$1 = classof$3;
+var getMethod = getMethod$2;
+var isNullOrUndefined = isNullOrUndefined$1;
+var Iterators = iterators;
+var wellKnownSymbol$1 = wellKnownSymbol$4;
+
+var ITERATOR$1 = wellKnownSymbol$1('iterator');
+
+var getIteratorMethod$3 = function (it) {
+  if (!isNullOrUndefined(it)) return getMethod(it, ITERATOR$1)
+    || getMethod(it, '@@iterator')
+    || Iterators[classof$1(it)];
+};
+
+var call$3 = functionCall;
+var aCallable = aCallable$2;
+var anObject$1 = anObject$4;
+var tryToString = tryToString$1;
+var getIteratorMethod$2 = getIteratorMethod$3;
+
+var $TypeError$1 = TypeError;
+
+var getIterator$2 = function (argument, usingIterator) {
+  var iteratorMethod = arguments.length < 2 ? getIteratorMethod$2(argument) : usingIterator;
+  if (aCallable(iteratorMethod)) return anObject$1(call$3(iteratorMethod, argument));
+  throw new $TypeError$1(tryToString(argument) + ' is not iterable');
+};
+
+var bind$2 = functionBindContext;
+var call$2 = functionCall;
+var toObject = toObject$1;
+var callWithSafeIterationClosing = callWithSafeIterationClosing$1;
+var isArrayIteratorMethod = isArrayIteratorMethod$1;
+var isConstructor = isConstructor$1;
+var lengthOfArrayLike = lengthOfArrayLike$1;
+var createProperty = createProperty$1;
+var getIterator$1 = getIterator$2;
+var getIteratorMethod$1 = getIteratorMethod$3;
+
+var $Array = Array;
+
+// `Array.from` method implementation
+// https://tc39.es/ecma262/#sec-array.from
+var arrayFrom$1 = function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) {
+  var O = toObject(arrayLike);
+  var IS_CONSTRUCTOR = isConstructor(this);
+  var argumentsLength = arguments.length;
+  var mapfn = argumentsLength > 1 ? arguments[1] : undefined;
+  var mapping = mapfn !== undefined;
+  if (mapping) mapfn = bind$2(mapfn, argumentsLength > 2 ? arguments[2] : undefined);
+  var iteratorMethod = getIteratorMethod$1(O);
+  var index = 0;
+  var length, result, step, iterator, next, value;
+  // if the target is not iterable or it's an array with the default iterator - use a simple case
+  if (iteratorMethod && !(this === $Array && isArrayIteratorMethod(iteratorMethod))) {
+    result = IS_CONSTRUCTOR ? new this() : [];
+    iterator = getIterator$1(O, iteratorMethod);
+    next = iterator.next;
+    for (;!(step = call$2(next, iterator)).done; index++) {
+      value = mapping ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true) : step.value;
+      createProperty(result, index, value);
+    }
+  } else {
+    length = lengthOfArrayLike(O);
+    result = IS_CONSTRUCTOR ? new this(length) : $Array(length);
+    for (;length > index; index++) {
+      value = mapping ? mapfn(O[index], index) : O[index];
+      createProperty(result, index, value);
+    }
+  }
+  result.length = index;
+  return result;
+};
+
+// based on https://github.com/bestiejs/punycode.js/blob/master/punycode.js
+var uncurryThis$5 = functionUncurryThis;
+
+var maxInt = 2147483647; // aka. 0x7FFFFFFF or 2^31-1
+var base = 36;
+var tMin = 1;
+var tMax = 26;
+var skew = 38;
+var damp = 700;
+var initialBias = 72;
+var initialN = 128; // 0x80
+var delimiter = '-'; // '\x2D'
+var regexNonASCII = /[^\0-\u007E]/; // non-ASCII chars
+var regexSeparators = /[.\u3002\uFF0E\uFF61]/g; // RFC 3490 separators
+var OVERFLOW_ERROR = 'Overflow: input needs wider integers to process';
+var baseMinusTMin = base - tMin;
+
+var $RangeError = RangeError;
+var exec$1 = uncurryThis$5(regexSeparators.exec);
+var floor$2 = Math.floor;
+var fromCharCode = String.fromCharCode;
+var charCodeAt = uncurryThis$5(''.charCodeAt);
+var join$2 = uncurryThis$5([].join);
+var push$3 = uncurryThis$5([].push);
+var replace$2 = uncurryThis$5(''.replace);
+var split$2 = uncurryThis$5(''.split);
+var toLowerCase$1 = uncurryThis$5(''.toLowerCase);
+
+/**
+ * Creates an array containing the numeric code points of each Unicode
+ * character in the string. While JavaScript uses UCS-2 internally,
+ * this function will convert a pair of surrogate halves (each of which
+ * UCS-2 exposes as separate characters) into a single code point,
+ * matching UTF-16.
+ */
+var ucs2decode = function (string) {
+  var output = [];
+  var counter = 0;
+  var length = string.length;
+  while (counter < length) {
+    var value = charCodeAt(string, counter++);
+    if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
+      // It's a high surrogate, and there is a next character.
+      var extra = charCodeAt(string, counter++);
+      if ((extra & 0xFC00) === 0xDC00) { // Low surrogate.
+        push$3(output, ((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
+      } else {
+        // It's an unmatched surrogate; only append this code unit, in case the
+        // next code unit is the high surrogate of a surrogate pair.
+        push$3(output, value);
+        counter--;
+      }
+    } else {
+      push$3(output, value);
+    }
+  }
+  return output;
+};
+
+/**
+ * Converts a digit/integer into a basic code point.
+ */
+var digitToBasic = function (digit) {
+  //  0..25 map to ASCII a..z or A..Z
+  // 26..35 map to ASCII 0..9
+  return digit + 22 + 75 * (digit < 26);
+};
+
+/**
+ * Bias adaptation function as per section 3.4 of RFC 3492.
+ * https://tools.ietf.org/html/rfc3492#section-3.4
+ */
+var adapt = function (delta, numPoints, firstTime) {
+  var k = 0;
+  delta = firstTime ? floor$2(delta / damp) : delta >> 1;
+  delta += floor$2(delta / numPoints);
+  while (delta > baseMinusTMin * tMax >> 1) {
+    delta = floor$2(delta / baseMinusTMin);
+    k += base;
+  }
+  return floor$2(k + (baseMinusTMin + 1) * delta / (delta + skew));
+};
+
+/**
+ * Converts a string of Unicode symbols (e.g. a domain name label) to a
+ * Punycode string of ASCII-only symbols.
+ */
+var encode = function (input) {
+  var output = [];
+
+  // Convert the input in UCS-2 to an array of Unicode code points.
+  input = ucs2decode(input);
+
+  // Cache the length.
+  var inputLength = input.length;
+
+  // Initialize the state.
+  var n = initialN;
+  var delta = 0;
+  var bias = initialBias;
+  var i, currentValue;
+
+  // Handle the basic code points.
+  for (i = 0; i < input.length; i++) {
+    currentValue = input[i];
+    if (currentValue < 0x80) {
+      push$3(output, fromCharCode(currentValue));
+    }
+  }
+
+  var basicLength = output.length; // number of basic code points.
+  var handledCPCount = basicLength; // number of code points that have been handled;
+
+  // Finish the basic string with a delimiter unless it's empty.
+  if (basicLength) {
+    push$3(output, delimiter);
+  }
+
+  // Main encoding loop:
+  while (handledCPCount < inputLength) {
+    // All non-basic code points < n have been handled already. Find the next larger one:
+    var m = maxInt;
+    for (i = 0; i < input.length; i++) {
+      currentValue = input[i];
+      if (currentValue >= n && currentValue < m) {
+        m = currentValue;
+      }
+    }
+
+    // Increase `delta` enough to advance the decoder's <n,i> state to <m,0>, but guard against overflow.
+    var handledCPCountPlusOne = handledCPCount + 1;
+    if (m - n > floor$2((maxInt - delta) / handledCPCountPlusOne)) {
+      throw new $RangeError(OVERFLOW_ERROR);
+    }
+
+    delta += (m - n) * handledCPCountPlusOne;
+    n = m;
+
+    for (i = 0; i < input.length; i++) {
+      currentValue = input[i];
+      if (currentValue < n && ++delta > maxInt) {
+        throw new $RangeError(OVERFLOW_ERROR);
+      }
+      if (currentValue === n) {
+        // Represent delta as a generalized variable-length integer.
+        var q = delta;
+        var k = base;
+        while (true) {
+          var t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
+          if (q < t) break;
+          var qMinusT = q - t;
+          var baseMinusT = base - t;
+          push$3(output, fromCharCode(digitToBasic(t + qMinusT % baseMinusT)));
+          q = floor$2(qMinusT / baseMinusT);
+          k += base;
+        }
+
+        push$3(output, fromCharCode(digitToBasic(q)));
+        bias = adapt(delta, handledCPCountPlusOne, handledCPCount === basicLength);
+        delta = 0;
+        handledCPCount++;
+      }
+    }
+
+    delta++;
+    n++;
+  }
+  return join$2(output, '');
+};
+
+var stringPunycodeToAscii = function (input) {
+  var encoded = [];
+  var labels = split$2(replace$2(toLowerCase$1(input), regexSeparators, '\u002E'), '.');
+  var i, label;
+  for (i = 0; i < labels.length; i++) {
+    label = labels[i];
+    push$3(encoded, exec$1(regexNonASCII, label) ? 'xn--' + encode(label) : label);
+  }
+  return join$2(encoded, '.');
+};
+
+var $TypeError = TypeError;
+
+var validateArgumentsLength$4 = function (passed, required) {
+  if (passed < required) throw new $TypeError('Not enough arguments');
+  return passed;
+};
+
+var global$2 = global$3;
+var DESCRIPTORS$3 = descriptors;
+
+// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+
+// Avoid NodeJS experimental warning
+var safeGetBuiltIn$1 = function (name) {
+  if (!DESCRIPTORS$3) return global$2[name];
+  var descriptor = getOwnPropertyDescriptor(global$2, name);
+  return descriptor && descriptor.value;
+};
+
+var defineBuiltIn$4 = defineBuiltIn$5;
+
+var defineBuiltIns$1 = function (target, src, options) {
+  for (var key in src) defineBuiltIn$4(target, key, src[key], options);
+  return target;
+};
+
+var arraySlice$1 = arraySlice$2;
+
+var floor$1 = Math.floor;
+
+var sort = function (array, comparefn) {
+  var length = array.length;
+
+  if (length < 8) {
+    // insertion sort
+    var i = 1;
+    var element, j;
+
+    while (i < length) {
+      j = i;
+      element = array[i];
+      while (j && comparefn(array[j - 1], element) > 0) {
+        array[j] = array[--j];
+      }
+      if (j !== i++) array[j] = element;
+    }
+  } else {
+    // merge sort
+    var middle = floor$1(length / 2);
+    var left = sort(arraySlice$1(array, 0, middle), comparefn);
+    var right = sort(arraySlice$1(array, middle), comparefn);
+    var llength = left.length;
+    var rlength = right.length;
+    var lindex = 0;
+    var rindex = 0;
+
+    while (lindex < llength || rindex < rlength) {
+      array[lindex + rindex] = (lindex < llength && rindex < rlength)
+        ? comparefn(left[lindex], right[rindex]) <= 0 ? left[lindex++] : right[rindex++]
+        : lindex < llength ? left[lindex++] : right[rindex++];
+    }
+  }
+
+  return array;
+};
+
+var arraySort$1 = sort;
+
+// TODO: in core-js@4, move /modules/ dependencies to public entries for better optimization by tools like `preset-env`
+
+var $$2 = _export;
+var global$1 = global$3;
+var safeGetBuiltIn = safeGetBuiltIn$1;
+var call$1 = functionCall;
+var uncurryThis$4 = functionUncurryThis;
+var DESCRIPTORS$2 = descriptors;
+var USE_NATIVE_URL$1 = urlConstructorDetection;
+var defineBuiltIn$3 = defineBuiltIn$5;
+var defineBuiltInAccessor$2 = defineBuiltInAccessor$3;
+var defineBuiltIns = defineBuiltIns$1;
+var setToStringTag$1 = setToStringTag$2;
+var createIteratorConstructor = iteratorCreateConstructor;
+var InternalStateModule$1 = internalState;
+var anInstance$1 = anInstance$2;
+var isCallable = isCallable$2;
+var hasOwn$1 = hasOwnProperty_1;
+var bind$1 = functionBindContext;
+var classof = classof$3;
+var anObject = anObject$4;
+var isObject = isObject$1;
+var $toString$1 = toString$4;
+var create = objectCreate;
+var createPropertyDescriptor = createPropertyDescriptor$2;
+var getIterator = getIterator$2;
+var getIteratorMethod = getIteratorMethod$3;
+var createIterResultObject = createIterResultObject$2;
+var validateArgumentsLength$3 = validateArgumentsLength$4;
+var wellKnownSymbol = wellKnownSymbol$4;
+var arraySort = arraySort$1;
+
+var ITERATOR = wellKnownSymbol('iterator');
+var URL_SEARCH_PARAMS = 'URLSearchParams';
+var URL_SEARCH_PARAMS_ITERATOR = URL_SEARCH_PARAMS + 'Iterator';
+var setInternalState$1 = InternalStateModule$1.set;
+var getInternalParamsState = InternalStateModule$1.getterFor(URL_SEARCH_PARAMS);
+var getInternalIteratorState = InternalStateModule$1.getterFor(URL_SEARCH_PARAMS_ITERATOR);
+
+var nativeFetch = safeGetBuiltIn('fetch');
+var NativeRequest = safeGetBuiltIn('Request');
+var Headers = safeGetBuiltIn('Headers');
+var RequestPrototype = NativeRequest && NativeRequest.prototype;
+var HeadersPrototype = Headers && Headers.prototype;
+var RegExp$1 = global$1.RegExp;
+var TypeError$2 = global$1.TypeError;
+var decodeURIComponent = global$1.decodeURIComponent;
+var encodeURIComponent$1 = global$1.encodeURIComponent;
+var charAt$1 = uncurryThis$4(''.charAt);
+var join$1 = uncurryThis$4([].join);
+var push$2 = uncurryThis$4([].push);
+var replace$1 = uncurryThis$4(''.replace);
+var shift$1 = uncurryThis$4([].shift);
+var splice = uncurryThis$4([].splice);
+var split$1 = uncurryThis$4(''.split);
+var stringSlice$1 = uncurryThis$4(''.slice);
+
+var plus = /\+/g;
+var sequences = Array(4);
+
+var percentSequence = function (bytes) {
+  return sequences[bytes - 1] || (sequences[bytes - 1] = RegExp$1('((?:%[\\da-f]{2}){' + bytes + '})', 'gi'));
+};
+
+var percentDecode = function (sequence) {
+  try {
+    return decodeURIComponent(sequence);
+  } catch (error) {
+    return sequence;
+  }
+};
+
+var deserialize = function (it) {
+  var result = replace$1(it, plus, ' ');
+  var bytes = 4;
+  try {
+    return decodeURIComponent(result);
+  } catch (error) {
+    while (bytes) {
+      result = replace$1(result, percentSequence(bytes--), percentDecode);
+    }
+    return result;
+  }
+};
+
+var find = /[!'()~]|%20/g;
+
+var replacements = {
+  '!': '%21',
+  "'": '%27',
+  '(': '%28',
+  ')': '%29',
+  '~': '%7E',
+  '%20': '+'
+};
+
+var replacer = function (match) {
+  return replacements[match];
+};
+
+var serialize = function (it) {
+  return replace$1(encodeURIComponent$1(it), find, replacer);
+};
+
+var URLSearchParamsIterator = createIteratorConstructor(function Iterator(params, kind) {
+  setInternalState$1(this, {
+    type: URL_SEARCH_PARAMS_ITERATOR,
+    target: getInternalParamsState(params).entries,
+    index: 0,
+    kind: kind
+  });
+}, URL_SEARCH_PARAMS, function next() {
+  var state = getInternalIteratorState(this);
+  var target = state.target;
+  var index = state.index++;
+  if (!target || index >= target.length) {
+    state.target = undefined;
+    return createIterResultObject(undefined, true);
+  }
+  var entry = target[index];
+  switch (state.kind) {
+    case 'keys': return createIterResultObject(entry.key, false);
+    case 'values': return createIterResultObject(entry.value, false);
+  } return createIterResultObject([entry.key, entry.value], false);
+}, true);
+
+var URLSearchParamsState = function (init) {
+  this.entries = [];
+  this.url = null;
+
+  if (init !== undefined) {
+    if (isObject(init)) this.parseObject(init);
+    else this.parseQuery(typeof init == 'string' ? charAt$1(init, 0) === '?' ? stringSlice$1(init, 1) : init : $toString$1(init));
+  }
+};
+
+URLSearchParamsState.prototype = {
+  type: URL_SEARCH_PARAMS,
+  bindURL: function (url) {
+    this.url = url;
+    this.update();
+  },
+  parseObject: function (object) {
+    var entries = this.entries;
+    var iteratorMethod = getIteratorMethod(object);
+    var iterator, next, step, entryIterator, entryNext, first, second;
+
+    if (iteratorMethod) {
+      iterator = getIterator(object, iteratorMethod);
+      next = iterator.next;
+      while (!(step = call$1(next, iterator)).done) {
+        entryIterator = getIterator(anObject(step.value));
+        entryNext = entryIterator.next;
+        if (
+          (first = call$1(entryNext, entryIterator)).done ||
+          (second = call$1(entryNext, entryIterator)).done ||
+          !call$1(entryNext, entryIterator).done
+        ) throw new TypeError$2('Expected sequence with length 2');
+        push$2(entries, { key: $toString$1(first.value), value: $toString$1(second.value) });
+      }
+    } else for (var key in object) if (hasOwn$1(object, key)) {
+      push$2(entries, { key: key, value: $toString$1(object[key]) });
+    }
+  },
+  parseQuery: function (query) {
+    if (query) {
+      var entries = this.entries;
+      var attributes = split$1(query, '&');
+      var index = 0;
+      var attribute, entry;
+      while (index < attributes.length) {
+        attribute = attributes[index++];
+        if (attribute.length) {
+          entry = split$1(attribute, '=');
+          push$2(entries, {
+            key: deserialize(shift$1(entry)),
+            value: deserialize(join$1(entry, '='))
+          });
+        }
+      }
+    }
+  },
+  serialize: function () {
+    var entries = this.entries;
+    var result = [];
+    var index = 0;
+    var entry;
+    while (index < entries.length) {
+      entry = entries[index++];
+      push$2(result, serialize(entry.key) + '=' + serialize(entry.value));
+    } return join$1(result, '&');
+  },
+  update: function () {
+    this.entries.length = 0;
+    this.parseQuery(this.url.query);
+  },
+  updateURL: function () {
+    if (this.url) this.url.update();
+  }
+};
+
+// `URLSearchParams` constructor
+// https://url.spec.whatwg.org/#interface-urlsearchparams
+var URLSearchParamsConstructor = function URLSearchParams(/* init */) {
+  anInstance$1(this, URLSearchParamsPrototype$3);
+  var init = arguments.length > 0 ? arguments[0] : undefined;
+  var state = setInternalState$1(this, new URLSearchParamsState(init));
+  if (!DESCRIPTORS$2) this.size = state.entries.length;
+};
+
+var URLSearchParamsPrototype$3 = URLSearchParamsConstructor.prototype;
+
+defineBuiltIns(URLSearchParamsPrototype$3, {
+  // `URLSearchParams.prototype.append` method
+  // https://url.spec.whatwg.org/#dom-urlsearchparams-append
+  append: function append(name, value) {
+    var state = getInternalParamsState(this);
+    validateArgumentsLength$3(arguments.length, 2);
+    push$2(state.entries, { key: $toString$1(name), value: $toString$1(value) });
+    if (!DESCRIPTORS$2) this.length++;
+    state.updateURL();
+  },
+  // `URLSearchParams.prototype.delete` method
+  // https://url.spec.whatwg.org/#dom-urlsearchparams-delete
+  'delete': function (name /* , value */) {
+    var state = getInternalParamsState(this);
+    var length = validateArgumentsLength$3(arguments.length, 1);
+    var entries = state.entries;
+    var key = $toString$1(name);
+    var $value = length < 2 ? undefined : arguments[1];
+    var value = $value === undefined ? $value : $toString$1($value);
+    var index = 0;
+    while (index < entries.length) {
+      var entry = entries[index];
+      if (entry.key === key && (value === undefined || entry.value === value)) {
+        splice(entries, index, 1);
+        if (value !== undefined) break;
+      } else index++;
+    }
+    if (!DESCRIPTORS$2) this.size = entries.length;
+    state.updateURL();
+  },
+  // `URLSearchParams.prototype.get` method
+  // https://url.spec.whatwg.org/#dom-urlsearchparams-get
+  get: function get(name) {
+    var entries = getInternalParamsState(this).entries;
+    validateArgumentsLength$3(arguments.length, 1);
+    var key = $toString$1(name);
+    var index = 0;
+    for (; index < entries.length; index++) {
+      if (entries[index].key === key) return entries[index].value;
+    }
+    return null;
+  },
+  // `URLSearchParams.prototype.getAll` method
+  // https://url.spec.whatwg.org/#dom-urlsearchparams-getall
+  getAll: function getAll(name) {
+    var entries = getInternalParamsState(this).entries;
+    validateArgumentsLength$3(arguments.length, 1);
+    var key = $toString$1(name);
+    var result = [];
+    var index = 0;
+    for (; index < entries.length; index++) {
+      if (entries[index].key === key) push$2(result, entries[index].value);
+    }
+    return result;
+  },
+  // `URLSearchParams.prototype.has` method
+  // https://url.spec.whatwg.org/#dom-urlsearchparams-has
+  has: function has(name /* , value */) {
+    var entries = getInternalParamsState(this).entries;
+    var length = validateArgumentsLength$3(arguments.length, 1);
+    var key = $toString$1(name);
+    var $value = length < 2 ? undefined : arguments[1];
+    var value = $value === undefined ? $value : $toString$1($value);
+    var index = 0;
+    while (index < entries.length) {
+      var entry = entries[index++];
+      if (entry.key === key && (value === undefined || entry.value === value)) return true;
+    }
+    return false;
+  },
+  // `URLSearchParams.prototype.set` method
+  // https://url.spec.whatwg.org/#dom-urlsearchparams-set
+  set: function set(name, value) {
+    var state = getInternalParamsState(this);
+    validateArgumentsLength$3(arguments.length, 1);
+    var entries = state.entries;
+    var found = false;
+    var key = $toString$1(name);
+    var val = $toString$1(value);
+    var index = 0;
+    var entry;
+    for (; index < entries.length; index++) {
+      entry = entries[index];
+      if (entry.key === key) {
+        if (found) splice(entries, index--, 1);
+        else {
+          found = true;
+          entry.value = val;
+        }
+      }
+    }
+    if (!found) push$2(entries, { key: key, value: val });
+    if (!DESCRIPTORS$2) this.size = entries.length;
+    state.updateURL();
+  },
+  // `URLSearchParams.prototype.sort` method
+  // https://url.spec.whatwg.org/#dom-urlsearchparams-sort
+  sort: function sort() {
+    var state = getInternalParamsState(this);
+    arraySort(state.entries, function (a, b) {
+      return a.key > b.key ? 1 : -1;
+    });
+    state.updateURL();
+  },
+  // `URLSearchParams.prototype.forEach` method
+  forEach: function forEach(callback /* , thisArg */) {
+    var entries = getInternalParamsState(this).entries;
+    var boundFunction = bind$1(callback, arguments.length > 1 ? arguments[1] : undefined);
+    var index = 0;
+    var entry;
+    while (index < entries.length) {
+      entry = entries[index++];
+      boundFunction(entry.value, entry.key, this);
+    }
+  },
+  // `URLSearchParams.prototype.keys` method
+  keys: function keys() {
+    return new URLSearchParamsIterator(this, 'keys');
+  },
+  // `URLSearchParams.prototype.values` method
+  values: function values() {
+    return new URLSearchParamsIterator(this, 'values');
+  },
+  // `URLSearchParams.prototype.entries` method
+  entries: function entries() {
+    return new URLSearchParamsIterator(this, 'entries');
+  }
+}, { enumerable: true });
+
+// `URLSearchParams.prototype[@@iterator]` method
+defineBuiltIn$3(URLSearchParamsPrototype$3, ITERATOR, URLSearchParamsPrototype$3.entries, { name: 'entries' });
+
+// `URLSearchParams.prototype.toString` method
+// https://url.spec.whatwg.org/#urlsearchparams-stringification-behavior
+defineBuiltIn$3(URLSearchParamsPrototype$3, 'toString', function toString() {
+  return getInternalParamsState(this).serialize();
+}, { enumerable: true });
+
+// `URLSearchParams.prototype.size` getter
+// https://github.com/whatwg/url/pull/734
+if (DESCRIPTORS$2) defineBuiltInAccessor$2(URLSearchParamsPrototype$3, 'size', {
+  get: function size() {
+    return getInternalParamsState(this).entries.length;
+  },
+  configurable: true,
+  enumerable: true
+});
+
+setToStringTag$1(URLSearchParamsConstructor, URL_SEARCH_PARAMS);
+
+$$2({ global: true, constructor: true, forced: !USE_NATIVE_URL$1 }, {
+  URLSearchParams: URLSearchParamsConstructor
+});
+
+// Wrap `fetch` and `Request` for correct work with polyfilled `URLSearchParams`
+if (!USE_NATIVE_URL$1 && isCallable(Headers)) {
+  var headersHas = uncurryThis$4(HeadersPrototype.has);
+  var headersSet = uncurryThis$4(HeadersPrototype.set);
+
+  var wrapRequestOptions = function (init) {
+    if (isObject(init)) {
+      var body = init.body;
+      var headers;
+      if (classof(body) === URL_SEARCH_PARAMS) {
+        headers = init.headers ? new Headers(init.headers) : new Headers();
+        if (!headersHas(headers, 'content-type')) {
+          headersSet(headers, 'content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
+        }
+        return create(init, {
+          body: createPropertyDescriptor(0, $toString$1(body)),
+          headers: createPropertyDescriptor(0, headers)
+        });
+      }
+    } return init;
+  };
+
+  if (isCallable(nativeFetch)) {
+    $$2({ global: true, enumerable: true, dontCallGetSet: true, forced: true }, {
+      fetch: function fetch(input /* , init */) {
+        return nativeFetch(input, arguments.length > 1 ? wrapRequestOptions(arguments[1]) : {});
+      }
+    });
+  }
+
+  if (isCallable(NativeRequest)) {
+    var RequestConstructor = function Request(input /* , init */) {
+      anInstance$1(this, RequestPrototype);
+      return new NativeRequest(input, arguments.length > 1 ? wrapRequestOptions(arguments[1]) : {});
+    };
+
+    RequestPrototype.constructor = RequestConstructor;
+    RequestConstructor.prototype = RequestPrototype;
+
+    $$2({ global: true, constructor: true, dontCallGetSet: true, forced: true }, {
+      Request: RequestConstructor
+    });
+  }
+}
+
+var web_urlSearchParams_constructor = {
+  URLSearchParams: URLSearchParamsConstructor,
+  getState: getInternalParamsState
+};
+
+// TODO: in core-js@4, move /modules/ dependencies to public entries for better optimization by tools like `preset-env`
+
+var $$1 = _export;
+var DESCRIPTORS$1 = descriptors;
+var USE_NATIVE_URL = urlConstructorDetection;
+var global = global$3;
+var bind = functionBindContext;
+var uncurryThis$3 = functionUncurryThis;
+var defineBuiltIn$2 = defineBuiltIn$5;
+var defineBuiltInAccessor$1 = defineBuiltInAccessor$3;
+var anInstance = anInstance$2;
+var hasOwn = hasOwnProperty_1;
+var assign = objectAssign;
+var arrayFrom = arrayFrom$1;
+var arraySlice = arraySlice$2;
+var codeAt = stringMultibyte.codeAt;
+var toASCII = stringPunycodeToAscii;
+var $toString = toString$4;
+var setToStringTag = setToStringTag$2;
+var validateArgumentsLength$2 = validateArgumentsLength$4;
+var URLSearchParamsModule = web_urlSearchParams_constructor;
+var InternalStateModule = internalState;
+
+var setInternalState = InternalStateModule.set;
+var getInternalURLState = InternalStateModule.getterFor('URL');
+var URLSearchParams$1 = URLSearchParamsModule.URLSearchParams;
+var getInternalSearchParamsState = URLSearchParamsModule.getState;
+
+var NativeURL = global.URL;
+var TypeError$1 = global.TypeError;
+var parseInt = global.parseInt;
+var floor = Math.floor;
+var pow = Math.pow;
+var charAt = uncurryThis$3(''.charAt);
+var exec = uncurryThis$3(/./.exec);
+var join = uncurryThis$3([].join);
+var numberToString = uncurryThis$3(1.0.toString);
+var pop = uncurryThis$3([].pop);
+var push$1 = uncurryThis$3([].push);
+var replace = uncurryThis$3(''.replace);
+var shift = uncurryThis$3([].shift);
+var split = uncurryThis$3(''.split);
+var stringSlice = uncurryThis$3(''.slice);
+var toLowerCase = uncurryThis$3(''.toLowerCase);
+var unshift = uncurryThis$3([].unshift);
+
+var INVALID_AUTHORITY = 'Invalid authority';
+var INVALID_SCHEME = 'Invalid scheme';
+var INVALID_HOST = 'Invalid host';
+var INVALID_PORT = 'Invalid port';
+
+var ALPHA = /[a-z]/i;
+// eslint-disable-next-line regexp/no-obscure-range -- safe
+var ALPHANUMERIC = /[\d+-.a-z]/i;
+var DIGIT = /\d/;
+var HEX_START = /^0x/i;
+var OCT = /^[0-7]+$/;
+var DEC = /^\d+$/;
+var HEX = /^[\da-f]+$/i;
+/* eslint-disable regexp/no-control-character -- safe */
+var FORBIDDEN_HOST_CODE_POINT = /[\0\t\n\r #%/:<>?@[\\\]^|]/;
+var FORBIDDEN_HOST_CODE_POINT_EXCLUDING_PERCENT = /[\0\t\n\r #/:<>?@[\\\]^|]/;
+var LEADING_C0_CONTROL_OR_SPACE = /^[\u0000-\u0020]+/;
+var TRAILING_C0_CONTROL_OR_SPACE = /(^|[^\u0000-\u0020])[\u0000-\u0020]+$/;
+var TAB_AND_NEW_LINE = /[\t\n\r]/g;
+/* eslint-enable regexp/no-control-character -- safe */
+var EOF;
+
+// https://url.spec.whatwg.org/#ipv4-number-parser
+var parseIPv4 = function (input) {
+  var parts = split(input, '.');
+  var partsLength, numbers, index, part, radix, number, ipv4;
+  if (parts.length && parts[parts.length - 1] === '') {
+    parts.length--;
+  }
+  partsLength = parts.length;
+  if (partsLength > 4) return input;
+  numbers = [];
+  for (index = 0; index < partsLength; index++) {
+    part = parts[index];
+    if (part === '') return input;
+    radix = 10;
+    if (part.length > 1 && charAt(part, 0) === '0') {
+      radix = exec(HEX_START, part) ? 16 : 8;
+      part = stringSlice(part, radix === 8 ? 1 : 2);
+    }
+    if (part === '') {
+      number = 0;
+    } else {
+      if (!exec(radix === 10 ? DEC : radix === 8 ? OCT : HEX, part)) return input;
+      number = parseInt(part, radix);
+    }
+    push$1(numbers, number);
+  }
+  for (index = 0; index < partsLength; index++) {
+    number = numbers[index];
+    if (index === partsLength - 1) {
+      if (number >= pow(256, 5 - partsLength)) return null;
+    } else if (number > 255) return null;
+  }
+  ipv4 = pop(numbers);
+  for (index = 0; index < numbers.length; index++) {
+    ipv4 += numbers[index] * pow(256, 3 - index);
+  }
+  return ipv4;
+};
+
+// https://url.spec.whatwg.org/#concept-ipv6-parser
+// eslint-disable-next-line max-statements -- TODO
+var parseIPv6 = function (input) {
+  var address = [0, 0, 0, 0, 0, 0, 0, 0];
+  var pieceIndex = 0;
+  var compress = null;
+  var pointer = 0;
+  var value, length, numbersSeen, ipv4Piece, number, swaps, swap;
+
+  var chr = function () {
+    return charAt(input, pointer);
+  };
+
+  if (chr() === ':') {
+    if (charAt(input, 1) !== ':') return;
+    pointer += 2;
+    pieceIndex++;
+    compress = pieceIndex;
+  }
+  while (chr()) {
+    if (pieceIndex === 8) return;
+    if (chr() === ':') {
+      if (compress !== null) return;
+      pointer++;
+      pieceIndex++;
+      compress = pieceIndex;
+      continue;
+    }
+    value = length = 0;
+    while (length < 4 && exec(HEX, chr())) {
+      value = value * 16 + parseInt(chr(), 16);
+      pointer++;
+      length++;
+    }
+    if (chr() === '.') {
+      if (length === 0) return;
+      pointer -= length;
+      if (pieceIndex > 6) return;
+      numbersSeen = 0;
+      while (chr()) {
+        ipv4Piece = null;
+        if (numbersSeen > 0) {
+          if (chr() === '.' && numbersSeen < 4) pointer++;
+          else return;
+        }
+        if (!exec(DIGIT, chr())) return;
+        while (exec(DIGIT, chr())) {
+          number = parseInt(chr(), 10);
+          if (ipv4Piece === null) ipv4Piece = number;
+          else if (ipv4Piece === 0) return;
+          else ipv4Piece = ipv4Piece * 10 + number;
+          if (ipv4Piece > 255) return;
+          pointer++;
+        }
+        address[pieceIndex] = address[pieceIndex] * 256 + ipv4Piece;
+        numbersSeen++;
+        if (numbersSeen === 2 || numbersSeen === 4) pieceIndex++;
+      }
+      if (numbersSeen !== 4) return;
+      break;
+    } else if (chr() === ':') {
+      pointer++;
+      if (!chr()) return;
+    } else if (chr()) return;
+    address[pieceIndex++] = value;
+  }
+  if (compress !== null) {
+    swaps = pieceIndex - compress;
+    pieceIndex = 7;
+    while (pieceIndex !== 0 && swaps > 0) {
+      swap = address[pieceIndex];
+      address[pieceIndex--] = address[compress + swaps - 1];
+      address[compress + --swaps] = swap;
+    }
+  } else if (pieceIndex !== 8) return;
+  return address;
+};
+
+var findLongestZeroSequence = function (ipv6) {
+  var maxIndex = null;
+  var maxLength = 1;
+  var currStart = null;
+  var currLength = 0;
+  var index = 0;
+  for (; index < 8; index++) {
+    if (ipv6[index] !== 0) {
+      if (currLength > maxLength) {
+        maxIndex = currStart;
+        maxLength = currLength;
+      }
+      currStart = null;
+      currLength = 0;
+    } else {
+      if (currStart === null) currStart = index;
+      ++currLength;
+    }
+  }
+  if (currLength > maxLength) {
+    maxIndex = currStart;
+    maxLength = currLength;
+  }
+  return maxIndex;
+};
+
+// https://url.spec.whatwg.org/#host-serializing
+var serializeHost = function (host) {
+  var result, index, compress, ignore0;
+  // ipv4
+  if (typeof host == 'number') {
+    result = [];
+    for (index = 0; index < 4; index++) {
+      unshift(result, host % 256);
+      host = floor(host / 256);
+    } return join(result, '.');
+  // ipv6
+  } else if (typeof host == 'object') {
+    result = '';
+    compress = findLongestZeroSequence(host);
+    for (index = 0; index < 8; index++) {
+      if (ignore0 && host[index] === 0) continue;
+      if (ignore0) ignore0 = false;
+      if (compress === index) {
+        result += index ? ':' : '::';
+        ignore0 = true;
+      } else {
+        result += numberToString(host[index], 16);
+        if (index < 7) result += ':';
+      }
+    }
+    return '[' + result + ']';
+  } return host;
+};
+
+var C0ControlPercentEncodeSet = {};
+var fragmentPercentEncodeSet = assign({}, C0ControlPercentEncodeSet, {
+  ' ': 1, '"': 1, '<': 1, '>': 1, '`': 1
+});
+var pathPercentEncodeSet = assign({}, fragmentPercentEncodeSet, {
+  '#': 1, '?': 1, '{': 1, '}': 1
+});
+var userinfoPercentEncodeSet = assign({}, pathPercentEncodeSet, {
+  '/': 1, ':': 1, ';': 1, '=': 1, '@': 1, '[': 1, '\\': 1, ']': 1, '^': 1, '|': 1
+});
+
+var percentEncode = function (chr, set) {
+  var code = codeAt(chr, 0);
+  return code > 0x20 && code < 0x7F && !hasOwn(set, chr) ? chr : encodeURIComponent(chr);
+};
+
+// https://url.spec.whatwg.org/#special-scheme
+var specialSchemes = {
+  ftp: 21,
+  file: null,
+  http: 80,
+  https: 443,
+  ws: 80,
+  wss: 443
+};
+
+// https://url.spec.whatwg.org/#windows-drive-letter
+var isWindowsDriveLetter = function (string, normalized) {
+  var second;
+  return string.length === 2 && exec(ALPHA, charAt(string, 0))
+    && ((second = charAt(string, 1)) === ':' || (!normalized && second === '|'));
+};
+
+// https://url.spec.whatwg.org/#start-with-a-windows-drive-letter
+var startsWithWindowsDriveLetter = function (string) {
+  var third;
+  return string.length > 1 && isWindowsDriveLetter(stringSlice(string, 0, 2)) && (
+    string.length === 2 ||
+    ((third = charAt(string, 2)) === '/' || third === '\\' || third === '?' || third === '#')
+  );
+};
+
+// https://url.spec.whatwg.org/#single-dot-path-segment
+var isSingleDot = function (segment) {
+  return segment === '.' || toLowerCase(segment) === '%2e';
+};
+
+// https://url.spec.whatwg.org/#double-dot-path-segment
+var isDoubleDot = function (segment) {
+  segment = toLowerCase(segment);
+  return segment === '..' || segment === '%2e.' || segment === '.%2e' || segment === '%2e%2e';
+};
+
+// States:
+var SCHEME_START = {};
+var SCHEME = {};
+var NO_SCHEME = {};
+var SPECIAL_RELATIVE_OR_AUTHORITY = {};
+var PATH_OR_AUTHORITY = {};
+var RELATIVE = {};
+var RELATIVE_SLASH = {};
+var SPECIAL_AUTHORITY_SLASHES = {};
+var SPECIAL_AUTHORITY_IGNORE_SLASHES = {};
+var AUTHORITY = {};
+var HOST = {};
+var HOSTNAME = {};
+var PORT = {};
+var FILE = {};
+var FILE_SLASH = {};
+var FILE_HOST = {};
+var PATH_START = {};
+var PATH = {};
+var CANNOT_BE_A_BASE_URL_PATH = {};
+var QUERY = {};
+var FRAGMENT = {};
+
+var URLState = function (url, isBase, base) {
+  var urlString = $toString(url);
+  var baseState, failure, searchParams;
+  if (isBase) {
+    failure = this.parse(urlString);
+    if (failure) throw new TypeError$1(failure);
+    this.searchParams = null;
+  } else {
+    if (base !== undefined) baseState = new URLState(base, true);
+    failure = this.parse(urlString, null, baseState);
+    if (failure) throw new TypeError$1(failure);
+    searchParams = getInternalSearchParamsState(new URLSearchParams$1());
+    searchParams.bindURL(this);
+    this.searchParams = searchParams;
+  }
+};
+
+URLState.prototype = {
+  type: 'URL',
+  // https://url.spec.whatwg.org/#url-parsing
+  // eslint-disable-next-line max-statements -- TODO
+  parse: function (input, stateOverride, base) {
+    var url = this;
+    var state = stateOverride || SCHEME_START;
+    var pointer = 0;
+    var buffer = '';
+    var seenAt = false;
+    var seenBracket = false;
+    var seenPasswordToken = false;
+    var codePoints, chr, bufferCodePoints, failure;
+
+    input = $toString(input);
+
+    if (!stateOverride) {
+      url.scheme = '';
+      url.username = '';
+      url.password = '';
+      url.host = null;
+      url.port = null;
+      url.path = [];
+      url.query = null;
+      url.fragment = null;
+      url.cannotBeABaseURL = false;
+      input = replace(input, LEADING_C0_CONTROL_OR_SPACE, '');
+      input = replace(input, TRAILING_C0_CONTROL_OR_SPACE, '$1');
+    }
+
+    input = replace(input, TAB_AND_NEW_LINE, '');
+
+    codePoints = arrayFrom(input);
+
+    while (pointer <= codePoints.length) {
+      chr = codePoints[pointer];
+      switch (state) {
+        case SCHEME_START:
+          if (chr && exec(ALPHA, chr)) {
+            buffer += toLowerCase(chr);
+            state = SCHEME;
+          } else if (!stateOverride) {
+            state = NO_SCHEME;
+            continue;
+          } else return INVALID_SCHEME;
+          break;
+
+        case SCHEME:
+          if (chr && (exec(ALPHANUMERIC, chr) || chr === '+' || chr === '-' || chr === '.')) {
+            buffer += toLowerCase(chr);
+          } else if (chr === ':') {
+            if (stateOverride && (
+              (url.isSpecial() !== hasOwn(specialSchemes, buffer)) ||
+              (buffer === 'file' && (url.includesCredentials() || url.port !== null)) ||
+              (url.scheme === 'file' && !url.host)
+            )) return;
+            url.scheme = buffer;
+            if (stateOverride) {
+              if (url.isSpecial() && specialSchemes[url.scheme] === url.port) url.port = null;
+              return;
+            }
+            buffer = '';
+            if (url.scheme === 'file') {
+              state = FILE;
+            } else if (url.isSpecial() && base && base.scheme === url.scheme) {
+              state = SPECIAL_RELATIVE_OR_AUTHORITY;
+            } else if (url.isSpecial()) {
+              state = SPECIAL_AUTHORITY_SLASHES;
+            } else if (codePoints[pointer + 1] === '/') {
+              state = PATH_OR_AUTHORITY;
+              pointer++;
+            } else {
+              url.cannotBeABaseURL = true;
+              push$1(url.path, '');
+              state = CANNOT_BE_A_BASE_URL_PATH;
+            }
+          } else if (!stateOverride) {
+            buffer = '';
+            state = NO_SCHEME;
+            pointer = 0;
+            continue;
+          } else return INVALID_SCHEME;
+          break;
+
+        case NO_SCHEME:
+          if (!base || (base.cannotBeABaseURL && chr !== '#')) return INVALID_SCHEME;
+          if (base.cannotBeABaseURL && chr === '#') {
+            url.scheme = base.scheme;
+            url.path = arraySlice(base.path);
+            url.query = base.query;
+            url.fragment = '';
+            url.cannotBeABaseURL = true;
+            state = FRAGMENT;
+            break;
+          }
+          state = base.scheme === 'file' ? FILE : RELATIVE;
+          continue;
+
+        case SPECIAL_RELATIVE_OR_AUTHORITY:
+          if (chr === '/' && codePoints[pointer + 1] === '/') {
+            state = SPECIAL_AUTHORITY_IGNORE_SLASHES;
+            pointer++;
+          } else {
+            state = RELATIVE;
+            continue;
+          } break;
+
+        case PATH_OR_AUTHORITY:
+          if (chr === '/') {
+            state = AUTHORITY;
+            break;
+          } else {
+            state = PATH;
+            continue;
+          }
+
+        case RELATIVE:
+          url.scheme = base.scheme;
+          if (chr === EOF) {
+            url.username = base.username;
+            url.password = base.password;
+            url.host = base.host;
+            url.port = base.port;
+            url.path = arraySlice(base.path);
+            url.query = base.query;
+          } else if (chr === '/' || (chr === '\\' && url.isSpecial())) {
+            state = RELATIVE_SLASH;
+          } else if (chr === '?') {
+            url.username = base.username;
+            url.password = base.password;
+            url.host = base.host;
+            url.port = base.port;
+            url.path = arraySlice(base.path);
+            url.query = '';
+            state = QUERY;
+          } else if (chr === '#') {
+            url.username = base.username;
+            url.password = base.password;
+            url.host = base.host;
+            url.port = base.port;
+            url.path = arraySlice(base.path);
+            url.query = base.query;
+            url.fragment = '';
+            state = FRAGMENT;
+          } else {
+            url.username = base.username;
+            url.password = base.password;
+            url.host = base.host;
+            url.port = base.port;
+            url.path = arraySlice(base.path);
+            url.path.length--;
+            state = PATH;
+            continue;
+          } break;
+
+        case RELATIVE_SLASH:
+          if (url.isSpecial() && (chr === '/' || chr === '\\')) {
+            state = SPECIAL_AUTHORITY_IGNORE_SLASHES;
+          } else if (chr === '/') {
+            state = AUTHORITY;
+          } else {
+            url.username = base.username;
+            url.password = base.password;
+            url.host = base.host;
+            url.port = base.port;
+            state = PATH;
+            continue;
+          } break;
+
+        case SPECIAL_AUTHORITY_SLASHES:
+          state = SPECIAL_AUTHORITY_IGNORE_SLASHES;
+          if (chr !== '/' || charAt(buffer, pointer + 1) !== '/') continue;
+          pointer++;
+          break;
+
+        case SPECIAL_AUTHORITY_IGNORE_SLASHES:
+          if (chr !== '/' && chr !== '\\') {
+            state = AUTHORITY;
+            continue;
+          } break;
+
+        case AUTHORITY:
+          if (chr === '@') {
+            if (seenAt) buffer = '%40' + buffer;
+            seenAt = true;
+            bufferCodePoints = arrayFrom(buffer);
+            for (var i = 0; i < bufferCodePoints.length; i++) {
+              var codePoint = bufferCodePoints[i];
+              if (codePoint === ':' && !seenPasswordToken) {
+                seenPasswordToken = true;
+                continue;
+              }
+              var encodedCodePoints = percentEncode(codePoint, userinfoPercentEncodeSet);
+              if (seenPasswordToken) url.password += encodedCodePoints;
+              else url.username += encodedCodePoints;
+            }
+            buffer = '';
+          } else if (
+            chr === EOF || chr === '/' || chr === '?' || chr === '#' ||
+            (chr === '\\' && url.isSpecial())
+          ) {
+            if (seenAt && buffer === '') return INVALID_AUTHORITY;
+            pointer -= arrayFrom(buffer).length + 1;
+            buffer = '';
+            state = HOST;
+          } else buffer += chr;
+          break;
+
+        case HOST:
+        case HOSTNAME:
+          if (stateOverride && url.scheme === 'file') {
+            state = FILE_HOST;
+            continue;
+          } else if (chr === ':' && !seenBracket) {
+            if (buffer === '') return INVALID_HOST;
+            failure = url.parseHost(buffer);
+            if (failure) return failure;
+            buffer = '';
+            state = PORT;
+            if (stateOverride === HOSTNAME) return;
+          } else if (
+            chr === EOF || chr === '/' || chr === '?' || chr === '#' ||
+            (chr === '\\' && url.isSpecial())
+          ) {
+            if (url.isSpecial() && buffer === '') return INVALID_HOST;
+            if (stateOverride && buffer === '' && (url.includesCredentials() || url.port !== null)) return;
+            failure = url.parseHost(buffer);
+            if (failure) return failure;
+            buffer = '';
+            state = PATH_START;
+            if (stateOverride) return;
+            continue;
+          } else {
+            if (chr === '[') seenBracket = true;
+            else if (chr === ']') seenBracket = false;
+            buffer += chr;
+          } break;
+
+        case PORT:
+          if (exec(DIGIT, chr)) {
+            buffer += chr;
+          } else if (
+            chr === EOF || chr === '/' || chr === '?' || chr === '#' ||
+            (chr === '\\' && url.isSpecial()) ||
+            stateOverride
+          ) {
+            if (buffer !== '') {
+              var port = parseInt(buffer, 10);
+              if (port > 0xFFFF) return INVALID_PORT;
+              url.port = (url.isSpecial() && port === specialSchemes[url.scheme]) ? null : port;
+              buffer = '';
+            }
+            if (stateOverride) return;
+            state = PATH_START;
+            continue;
+          } else return INVALID_PORT;
+          break;
+
+        case FILE:
+          url.scheme = 'file';
+          if (chr === '/' || chr === '\\') state = FILE_SLASH;
+          else if (base && base.scheme === 'file') {
+            switch (chr) {
+              case EOF:
+                url.host = base.host;
+                url.path = arraySlice(base.path);
+                url.query = base.query;
+                break;
+              case '?':
+                url.host = base.host;
+                url.path = arraySlice(base.path);
+                url.query = '';
+                state = QUERY;
+                break;
+              case '#':
+                url.host = base.host;
+                url.path = arraySlice(base.path);
+                url.query = base.query;
+                url.fragment = '';
+                state = FRAGMENT;
+                break;
+              default:
+                if (!startsWithWindowsDriveLetter(join(arraySlice(codePoints, pointer), ''))) {
+                  url.host = base.host;
+                  url.path = arraySlice(base.path);
+                  url.shortenPath();
+                }
+                state = PATH;
+                continue;
+            }
+          } else {
+            state = PATH;
+            continue;
+          } break;
+
+        case FILE_SLASH:
+          if (chr === '/' || chr === '\\') {
+            state = FILE_HOST;
+            break;
+          }
+          if (base && base.scheme === 'file' && !startsWithWindowsDriveLetter(join(arraySlice(codePoints, pointer), ''))) {
+            if (isWindowsDriveLetter(base.path[0], true)) push$1(url.path, base.path[0]);
+            else url.host = base.host;
+          }
+          state = PATH;
+          continue;
+
+        case FILE_HOST:
+          if (chr === EOF || chr === '/' || chr === '\\' || chr === '?' || chr === '#') {
+            if (!stateOverride && isWindowsDriveLetter(buffer)) {
+              state = PATH;
+            } else if (buffer === '') {
+              url.host = '';
+              if (stateOverride) return;
+              state = PATH_START;
+            } else {
+              failure = url.parseHost(buffer);
+              if (failure) return failure;
+              if (url.host === 'localhost') url.host = '';
+              if (stateOverride) return;
+              buffer = '';
+              state = PATH_START;
+            } continue;
+          } else buffer += chr;
+          break;
+
+        case PATH_START:
+          if (url.isSpecial()) {
+            state = PATH;
+            if (chr !== '/' && chr !== '\\') continue;
+          } else if (!stateOverride && chr === '?') {
+            url.query = '';
+            state = QUERY;
+          } else if (!stateOverride && chr === '#') {
+            url.fragment = '';
+            state = FRAGMENT;
+          } else if (chr !== EOF) {
+            state = PATH;
+            if (chr !== '/') continue;
+          } break;
+
+        case PATH:
+          if (
+            chr === EOF || chr === '/' ||
+            (chr === '\\' && url.isSpecial()) ||
+            (!stateOverride && (chr === '?' || chr === '#'))
+          ) {
+            if (isDoubleDot(buffer)) {
+              url.shortenPath();
+              if (chr !== '/' && !(chr === '\\' && url.isSpecial())) {
+                push$1(url.path, '');
+              }
+            } else if (isSingleDot(buffer)) {
+              if (chr !== '/' && !(chr === '\\' && url.isSpecial())) {
+                push$1(url.path, '');
+              }
+            } else {
+              if (url.scheme === 'file' && !url.path.length && isWindowsDriveLetter(buffer)) {
+                if (url.host) url.host = '';
+                buffer = charAt(buffer, 0) + ':'; // normalize windows drive letter
+              }
+              push$1(url.path, buffer);
+            }
+            buffer = '';
+            if (url.scheme === 'file' && (chr === EOF || chr === '?' || chr === '#')) {
+              while (url.path.length > 1 && url.path[0] === '') {
+                shift(url.path);
+              }
+            }
+            if (chr === '?') {
+              url.query = '';
+              state = QUERY;
+            } else if (chr === '#') {
+              url.fragment = '';
+              state = FRAGMENT;
+            }
+          } else {
+            buffer += percentEncode(chr, pathPercentEncodeSet);
+          } break;
+
+        case CANNOT_BE_A_BASE_URL_PATH:
+          if (chr === '?') {
+            url.query = '';
+            state = QUERY;
+          } else if (chr === '#') {
+            url.fragment = '';
+            state = FRAGMENT;
+          } else if (chr !== EOF) {
+            url.path[0] += percentEncode(chr, C0ControlPercentEncodeSet);
+          } break;
+
+        case QUERY:
+          if (!stateOverride && chr === '#') {
+            url.fragment = '';
+            state = FRAGMENT;
+          } else if (chr !== EOF) {
+            if (chr === "'" && url.isSpecial()) url.query += '%27';
+            else if (chr === '#') url.query += '%23';
+            else url.query += percentEncode(chr, C0ControlPercentEncodeSet);
+          } break;
+
+        case FRAGMENT:
+          if (chr !== EOF) url.fragment += percentEncode(chr, fragmentPercentEncodeSet);
+          break;
+      }
+
+      pointer++;
+    }
+  },
+  // https://url.spec.whatwg.org/#host-parsing
+  parseHost: function (input) {
+    var result, codePoints, index;
+    if (charAt(input, 0) === '[') {
+      if (charAt(input, input.length - 1) !== ']') return INVALID_HOST;
+      result = parseIPv6(stringSlice(input, 1, -1));
+      if (!result) return INVALID_HOST;
+      this.host = result;
+    // opaque host
+    } else if (!this.isSpecial()) {
+      if (exec(FORBIDDEN_HOST_CODE_POINT_EXCLUDING_PERCENT, input)) return INVALID_HOST;
+      result = '';
+      codePoints = arrayFrom(input);
+      for (index = 0; index < codePoints.length; index++) {
+        result += percentEncode(codePoints[index], C0ControlPercentEncodeSet);
+      }
+      this.host = result;
+    } else {
+      input = toASCII(input);
+      if (exec(FORBIDDEN_HOST_CODE_POINT, input)) return INVALID_HOST;
+      result = parseIPv4(input);
+      if (result === null) return INVALID_HOST;
+      this.host = result;
+    }
+  },
+  // https://url.spec.whatwg.org/#cannot-have-a-username-password-port
+  cannotHaveUsernamePasswordPort: function () {
+    return !this.host || this.cannotBeABaseURL || this.scheme === 'file';
+  },
+  // https://url.spec.whatwg.org/#include-credentials
+  includesCredentials: function () {
+    return this.username !== '' || this.password !== '';
+  },
+  // https://url.spec.whatwg.org/#is-special
+  isSpecial: function () {
+    return hasOwn(specialSchemes, this.scheme);
+  },
+  // https://url.spec.whatwg.org/#shorten-a-urls-path
+  shortenPath: function () {
+    var path = this.path;
+    var pathSize = path.length;
+    if (pathSize && (this.scheme !== 'file' || pathSize !== 1 || !isWindowsDriveLetter(path[0], true))) {
+      path.length--;
+    }
+  },
+  // https://url.spec.whatwg.org/#concept-url-serializer
+  serialize: function () {
+    var url = this;
+    var scheme = url.scheme;
+    var username = url.username;
+    var password = url.password;
+    var host = url.host;
+    var port = url.port;
+    var path = url.path;
+    var query = url.query;
+    var fragment = url.fragment;
+    var output = scheme + ':';
+    if (host !== null) {
+      output += '//';
+      if (url.includesCredentials()) {
+        output += username + (password ? ':' + password : '') + '@';
+      }
+      output += serializeHost(host);
+      if (port !== null) output += ':' + port;
+    } else if (scheme === 'file') output += '//';
+    output += url.cannotBeABaseURL ? path[0] : path.length ? '/' + join(path, '/') : '';
+    if (query !== null) output += '?' + query;
+    if (fragment !== null) output += '#' + fragment;
+    return output;
+  },
+  // https://url.spec.whatwg.org/#dom-url-href
+  setHref: function (href) {
+    var failure = this.parse(href);
+    if (failure) throw new TypeError$1(failure);
+    this.searchParams.update();
+  },
+  // https://url.spec.whatwg.org/#dom-url-origin
+  getOrigin: function () {
+    var scheme = this.scheme;
+    var port = this.port;
+    if (scheme === 'blob') try {
+      return new URLConstructor(scheme.path[0]).origin;
+    } catch (error) {
+      return 'null';
+    }
+    if (scheme === 'file' || !this.isSpecial()) return 'null';
+    return scheme + '://' + serializeHost(this.host) + (port !== null ? ':' + port : '');
+  },
+  // https://url.spec.whatwg.org/#dom-url-protocol
+  getProtocol: function () {
+    return this.scheme + ':';
+  },
+  setProtocol: function (protocol) {
+    this.parse($toString(protocol) + ':', SCHEME_START);
+  },
+  // https://url.spec.whatwg.org/#dom-url-username
+  getUsername: function () {
+    return this.username;
+  },
+  setUsername: function (username) {
+    var codePoints = arrayFrom($toString(username));
+    if (this.cannotHaveUsernamePasswordPort()) return;
+    this.username = '';
+    for (var i = 0; i < codePoints.length; i++) {
+      this.username += percentEncode(codePoints[i], userinfoPercentEncodeSet);
+    }
+  },
+  // https://url.spec.whatwg.org/#dom-url-password
+  getPassword: function () {
+    return this.password;
+  },
+  setPassword: function (password) {
+    var codePoints = arrayFrom($toString(password));
+    if (this.cannotHaveUsernamePasswordPort()) return;
+    this.password = '';
+    for (var i = 0; i < codePoints.length; i++) {
+      this.password += percentEncode(codePoints[i], userinfoPercentEncodeSet);
+    }
+  },
+  // https://url.spec.whatwg.org/#dom-url-host
+  getHost: function () {
+    var host = this.host;
+    var port = this.port;
+    return host === null ? ''
+      : port === null ? serializeHost(host)
+      : serializeHost(host) + ':' + port;
+  },
+  setHost: function (host) {
+    if (this.cannotBeABaseURL) return;
+    this.parse(host, HOST);
+  },
+  // https://url.spec.whatwg.org/#dom-url-hostname
+  getHostname: function () {
+    var host = this.host;
+    return host === null ? '' : serializeHost(host);
+  },
+  setHostname: function (hostname) {
+    if (this.cannotBeABaseURL) return;
+    this.parse(hostname, HOSTNAME);
+  },
+  // https://url.spec.whatwg.org/#dom-url-port
+  getPort: function () {
+    var port = this.port;
+    return port === null ? '' : $toString(port);
+  },
+  setPort: function (port) {
+    if (this.cannotHaveUsernamePasswordPort()) return;
+    port = $toString(port);
+    if (port === '') this.port = null;
+    else this.parse(port, PORT);
+  },
+  // https://url.spec.whatwg.org/#dom-url-pathname
+  getPathname: function () {
+    var path = this.path;
+    return this.cannotBeABaseURL ? path[0] : path.length ? '/' + join(path, '/') : '';
+  },
+  setPathname: function (pathname) {
+    if (this.cannotBeABaseURL) return;
+    this.path = [];
+    this.parse(pathname, PATH_START);
+  },
+  // https://url.spec.whatwg.org/#dom-url-search
+  getSearch: function () {
+    var query = this.query;
+    return query ? '?' + query : '';
+  },
+  setSearch: function (search) {
+    search = $toString(search);
+    if (search === '') {
+      this.query = null;
+    } else {
+      if (charAt(search, 0) === '?') search = stringSlice(search, 1);
+      this.query = '';
+      this.parse(search, QUERY);
+    }
+    this.searchParams.update();
+  },
+  // https://url.spec.whatwg.org/#dom-url-searchparams
+  getSearchParams: function () {
+    return this.searchParams.facade;
+  },
+  // https://url.spec.whatwg.org/#dom-url-hash
+  getHash: function () {
+    var fragment = this.fragment;
+    return fragment ? '#' + fragment : '';
+  },
+  setHash: function (hash) {
+    hash = $toString(hash);
+    if (hash === '') {
+      this.fragment = null;
+      return;
+    }
+    if (charAt(hash, 0) === '#') hash = stringSlice(hash, 1);
+    this.fragment = '';
+    this.parse(hash, FRAGMENT);
+  },
+  update: function () {
+    this.query = this.searchParams.serialize() || null;
+  }
+};
+
+// `URL` constructor
+// https://url.spec.whatwg.org/#url-class
+var URLConstructor = function URL(url /* , base */) {
+  var that = anInstance(this, URLPrototype);
+  var base = validateArgumentsLength$2(arguments.length, 1) > 1 ? arguments[1] : undefined;
+  var state = setInternalState(that, new URLState(url, false, base));
+  if (!DESCRIPTORS$1) {
+    that.href = state.serialize();
+    that.origin = state.getOrigin();
+    that.protocol = state.getProtocol();
+    that.username = state.getUsername();
+    that.password = state.getPassword();
+    that.host = state.getHost();
+    that.hostname = state.getHostname();
+    that.port = state.getPort();
+    that.pathname = state.getPathname();
+    that.search = state.getSearch();
+    that.searchParams = state.getSearchParams();
+    that.hash = state.getHash();
+  }
+};
+
+var URLPrototype = URLConstructor.prototype;
+
+var accessorDescriptor = function (getter, setter) {
+  return {
+    get: function () {
+      return getInternalURLState(this)[getter]();
+    },
+    set: setter && function (value) {
+      return getInternalURLState(this)[setter](value);
+    },
+    configurable: true,
+    enumerable: true
+  };
+};
+
+if (DESCRIPTORS$1) {
+  // `URL.prototype.href` accessors pair
+  // https://url.spec.whatwg.org/#dom-url-href
+  defineBuiltInAccessor$1(URLPrototype, 'href', accessorDescriptor('serialize', 'setHref'));
+  // `URL.prototype.origin` getter
+  // https://url.spec.whatwg.org/#dom-url-origin
+  defineBuiltInAccessor$1(URLPrototype, 'origin', accessorDescriptor('getOrigin'));
+  // `URL.prototype.protocol` accessors pair
+  // https://url.spec.whatwg.org/#dom-url-protocol
+  defineBuiltInAccessor$1(URLPrototype, 'protocol', accessorDescriptor('getProtocol', 'setProtocol'));
+  // `URL.prototype.username` accessors pair
+  // https://url.spec.whatwg.org/#dom-url-username
+  defineBuiltInAccessor$1(URLPrototype, 'username', accessorDescriptor('getUsername', 'setUsername'));
+  // `URL.prototype.password` accessors pair
+  // https://url.spec.whatwg.org/#dom-url-password
+  defineBuiltInAccessor$1(URLPrototype, 'password', accessorDescriptor('getPassword', 'setPassword'));
+  // `URL.prototype.host` accessors pair
+  // https://url.spec.whatwg.org/#dom-url-host
+  defineBuiltInAccessor$1(URLPrototype, 'host', accessorDescriptor('getHost', 'setHost'));
+  // `URL.prototype.hostname` accessors pair
+  // https://url.spec.whatwg.org/#dom-url-hostname
+  defineBuiltInAccessor$1(URLPrototype, 'hostname', accessorDescriptor('getHostname', 'setHostname'));
+  // `URL.prototype.port` accessors pair
+  // https://url.spec.whatwg.org/#dom-url-port
+  defineBuiltInAccessor$1(URLPrototype, 'port', accessorDescriptor('getPort', 'setPort'));
+  // `URL.prototype.pathname` accessors pair
+  // https://url.spec.whatwg.org/#dom-url-pathname
+  defineBuiltInAccessor$1(URLPrototype, 'pathname', accessorDescriptor('getPathname', 'setPathname'));
+  // `URL.prototype.search` accessors pair
+  // https://url.spec.whatwg.org/#dom-url-search
+  defineBuiltInAccessor$1(URLPrototype, 'search', accessorDescriptor('getSearch', 'setSearch'));
+  // `URL.prototype.searchParams` getter
+  // https://url.spec.whatwg.org/#dom-url-searchparams
+  defineBuiltInAccessor$1(URLPrototype, 'searchParams', accessorDescriptor('getSearchParams'));
+  // `URL.prototype.hash` accessors pair
+  // https://url.spec.whatwg.org/#dom-url-hash
+  defineBuiltInAccessor$1(URLPrototype, 'hash', accessorDescriptor('getHash', 'setHash'));
+}
+
+// `URL.prototype.toJSON` method
+// https://url.spec.whatwg.org/#dom-url-tojson
+defineBuiltIn$2(URLPrototype, 'toJSON', function toJSON() {
+  return getInternalURLState(this).serialize();
+}, { enumerable: true });
+
+// `URL.prototype.toString` method
+// https://url.spec.whatwg.org/#URL-stringification-behavior
+defineBuiltIn$2(URLPrototype, 'toString', function toString() {
+  return getInternalURLState(this).serialize();
+}, { enumerable: true });
+
+if (NativeURL) {
+  var nativeCreateObjectURL = NativeURL.createObjectURL;
+  var nativeRevokeObjectURL = NativeURL.revokeObjectURL;
+  // `URL.createObjectURL` method
+  // https://developer.mozilla.org/en-US/docs/Web/API/URL/createObjectURL
+  if (nativeCreateObjectURL) defineBuiltIn$2(URLConstructor, 'createObjectURL', bind(nativeCreateObjectURL, NativeURL));
+  // `URL.revokeObjectURL` method
+  // https://developer.mozilla.org/en-US/docs/Web/API/URL/revokeObjectURL
+  if (nativeRevokeObjectURL) defineBuiltIn$2(URLConstructor, 'revokeObjectURL', bind(nativeRevokeObjectURL, NativeURL));
+}
+
+setToStringTag(URLConstructor, 'URL');
+
+$$1({ global: true, constructor: true, forced: !USE_NATIVE_URL, sham: !DESCRIPTORS$1 }, {
+  URL: URLConstructor
+});
+
+var $ = _export;
+var call = functionCall;
+
+// `URL.prototype.toJSON` method
+// https://url.spec.whatwg.org/#dom-url-tojson
+$({ target: 'URL', proto: true, enumerable: true }, {
+  toJSON: function toJSON() {
+    return call(URL.prototype.toString, this);
+  }
+});
+
+var defineBuiltIn$1 = defineBuiltIn$5;
+var uncurryThis$2 = functionUncurryThis;
+var toString$1 = toString$4;
+var validateArgumentsLength$1 = validateArgumentsLength$4;
+
+var $URLSearchParams$1 = URLSearchParams;
+var URLSearchParamsPrototype$2 = $URLSearchParams$1.prototype;
+var append = uncurryThis$2(URLSearchParamsPrototype$2.append);
+var $delete = uncurryThis$2(URLSearchParamsPrototype$2['delete']);
+var forEach$1 = uncurryThis$2(URLSearchParamsPrototype$2.forEach);
+var push = uncurryThis$2([].push);
+var params$1 = new $URLSearchParams$1('a=1&a=2&b=3');
+
+params$1['delete']('a', 1);
+// `undefined` case is a Chromium 117 bug
+// https://bugs.chromium.org/p/v8/issues/detail?id=14222
+params$1['delete']('b', undefined);
+
+if (params$1 + '' !== 'a=2') {
+  defineBuiltIn$1(URLSearchParamsPrototype$2, 'delete', function (name /* , value */) {
+    var length = arguments.length;
+    var $value = length < 2 ? undefined : arguments[1];
+    if (length && $value === undefined) return $delete(this, name);
+    var entries = [];
+    forEach$1(this, function (v, k) { // also validates `this`
+      push(entries, { key: k, value: v });
+    });
+    validateArgumentsLength$1(length, 1);
+    var key = toString$1(name);
+    var value = toString$1($value);
+    var index = 0;
+    var dindex = 0;
+    var found = false;
+    var entriesLength = entries.length;
+    var entry;
+    while (index < entriesLength) {
+      entry = entries[index++];
+      if (found || entry.key === key) {
+        found = true;
+        $delete(this, entry.key);
+      } else dindex++;
+    }
+    while (dindex < entriesLength) {
+      entry = entries[dindex++];
+      if (!(entry.key === key && entry.value === value)) append(this, entry.key, entry.value);
+    }
+  }, { enumerable: true, unsafe: true });
+}
+
+var defineBuiltIn = defineBuiltIn$5;
+var uncurryThis$1 = functionUncurryThis;
+var toString = toString$4;
+var validateArgumentsLength = validateArgumentsLength$4;
+
+var $URLSearchParams = URLSearchParams;
+var URLSearchParamsPrototype$1 = $URLSearchParams.prototype;
+var getAll = uncurryThis$1(URLSearchParamsPrototype$1.getAll);
+var $has = uncurryThis$1(URLSearchParamsPrototype$1.has);
+var params = new $URLSearchParams('a=1');
+
+// `undefined` case is a Chromium 117 bug
+// https://bugs.chromium.org/p/v8/issues/detail?id=14222
+if (params.has('a', 2) || !params.has('a', undefined)) {
+  defineBuiltIn(URLSearchParamsPrototype$1, 'has', function has(name /* , value */) {
+    var length = arguments.length;
+    var $value = length < 2 ? undefined : arguments[1];
+    if (length && $value === undefined) return $has(this, name);
+    var values = getAll(this, name); // also validates `this`
+    validateArgumentsLength(length, 1);
+    var value = toString($value);
+    var index = 0;
+    while (index < values.length) {
+      if (values[index++] === value) return true;
+    } return false;
+  }, { enumerable: true, unsafe: true });
+}
+
+var DESCRIPTORS = descriptors;
+var uncurryThis = functionUncurryThis;
+var defineBuiltInAccessor = defineBuiltInAccessor$3;
+
+var URLSearchParamsPrototype = URLSearchParams.prototype;
+var forEach = uncurryThis(URLSearchParamsPrototype.forEach);
+
+// `URLSearchParams.prototype.size` getter
+// https://github.com/whatwg/url/pull/734
+if (DESCRIPTORS && !('size' in URLSearchParamsPrototype)) {
+  defineBuiltInAccessor(URLSearchParamsPrototype, 'size', {
+    get: function size() {
+      var count = 0;
+      forEach(this, function () { count++; });
+      return count;
+    },
+    configurable: true,
+    enumerable: true
+  });
+}
+
+const DEFAULT_TINYMCE_CONFIG = {
+  inline: true,
+  menubar: false,
+  powerpaste_html_import: 'clean',
+  powerpaste_word_import: 'clean',
+  suffix: '.min',
+  valid_styles: {
+    '*': 'font-size,font-family,color,text-decoration,text-align'
+  }
+};
+const TINYMCE_CONFIG = {
+  full: Object.assign({}, DEFAULT_TINYMCE_CONFIG, {
+    plugins: 'link lists autolink charmap',
+    toolbar: ['styleselect undo redo | bold italic underline | forecolor backcolor | alignleft aligncenter alignright alignfull | numlist bullist outdent indent | hr charmap removeformat | link'],
+    style_formats: [{
+      title: 'Paragraph',
+      format: 'p'
+    }, {
+      title: 'Header 1',
+      format: 'h1'
+    }, {
+      title: 'Header 2',
+      format: 'h2'
+    }, {
+      title: 'Header 3',
+      format: 'h3'
+    }, {
+      title: 'Header 4',
+      format: 'h4'
+    }, {
+      title: 'Header 5',
+      format: 'h5'
+    }, {
+      title: 'Header 6',
+      format: 'h6'
+    }, {
+      title: 'Pre',
+      format: 'pre'
+    }, {
+      title: 'Code',
+      format: 'code'
+    }]
+  }),
+  plain: Object.assign({}, DEFAULT_TINYMCE_CONFIG, {
+    plugins: '',
+    toolbar: ''
+  }),
+  minimal: Object.assign({}, DEFAULT_TINYMCE_CONFIG, {
+    plugins: 'link autolink',
+    toolbar: 'bold italic underline | link',
+    valid_elements: 'strong,em,span[style],a[href]'
+  })
+};
+
+const MCE_URL = '/ext/tinymcev7/tinymce.min.js';
+/**
+ * Allows inline edit content pulled from dotCMS API using TinyMCE editor
+ *
+ * @export
+ * @component
+ * @param {Readonly<DotEditableTextProps>} props {
+ *     mode = 'plain',
+ *     format = 'text',
+ *     contentlet,
+ *     fieldName = ''
+ * }
+ * @example
+ * ```javascript
+ * import { DotEditableText } from '@dotcms/react';
+ *
+ * const MyContentletWithTitle = ({ contentlet }) => (
+ *     <h2>
+ *         <DotEditableText
+ *             contentlet={contentlet}
+ *             fieldName="title"
+ *             mode='full'
+ *             format='text'/>
+ *     </h2>
+ * );
+ * ```
+ * @returns {JSX.Element} A component to edit content inline
+ */
+function DotEditableText({
+  mode = 'plain',
+  format = 'text',
+  contentlet,
+  fieldName = ''
+}) {
+  const editorRef = useRef(null);
+  const [scriptSrc, setScriptSrc] = useState('');
+  const [isInsideEditor$1, setIsInsideEditor] = useState(false);
+  const [content, setContent] = useState((contentlet == null ? void 0 : contentlet[fieldName]) || '');
+  useEffect(() => {
+    var _editorRef$current;
+    setIsInsideEditor(isInsideEditor());
+    if (!contentlet || !fieldName) {
+      console.error('DotEditableText: contentlet or fieldName is missing');
+      console.error('Ensure that all needed props are passed to view and edit the content');
+      return;
+    }
+    if (!isInsideEditor()) {
+      return;
+    }
+    const createURL = new URL(MCE_URL, DotCmsClient.dotcmsUrl);
+    setScriptSrc(createURL.toString());
+    const content = (contentlet == null ? void 0 : contentlet[fieldName]) || '';
+    (_editorRef$current = editorRef.current) == null || _editorRef$current.setContent(content, {
+      format
+    });
+    setContent(content);
+  }, [format, fieldName, contentlet]);
+  useEffect(() => {
+    if (!isInsideEditor()) {
+      return;
+    }
+    const onMessage = ({
+      data
+    }) => {
+      const {
+        name,
+        payload
+      } = data;
+      if (name !== NOTIFY_CLIENT.UVE_COPY_CONTENTLET_INLINE_EDITING_SUCCESS) {
+        return;
+      }
+      const {
+        oldInode,
+        inode
+      } = payload;
+      const currentInode = contentlet.inode;
+      const shouldFocus = currentInode === oldInode || currentInode === inode;
+      if (shouldFocus) {
+        var _editorRef$current2;
+        (_editorRef$current2 = editorRef.current) == null || _editorRef$current2.focus();
+      }
+    };
+    window.addEventListener('message', onMessage);
+    return () => {
+      window.removeEventListener('message', onMessage);
+    };
+  }, [contentlet.inode]);
+  const onMouseDown = event => {
+    var _editorRef$current3;
+    const {
+      onNumberOfPages = 1
+    } = contentlet;
+    const {
+      inode,
+      languageId: language
+    } = contentlet;
+    if (onNumberOfPages <= 1 || (_editorRef$current3 = editorRef.current) != null && _editorRef$current3.hasFocus()) {
+      return;
+    }
+    event.stopPropagation();
+    event.preventDefault();
+    postMessageToEditor({
+      action: CLIENT_ACTIONS.COPY_CONTENTLET_INLINE_EDITING,
+      payload: {
+        dataset: {
+          inode,
+          language,
+          fieldName
+        }
+      }
+    });
+  };
+  const onFocusOut = () => {
+    var _editorRef$current4, _editorRef$current5;
+    const editedContent = ((_editorRef$current4 = editorRef.current) == null ? void 0 : _editorRef$current4.getContent({
+      format: format
+    })) || '';
+    const {
+      inode,
+      languageId: langId
+    } = contentlet;
+    if (!((_editorRef$current5 = editorRef.current) != null && _editorRef$current5.isDirty()) || !didContentChange(editedContent)) {
+      return;
+    }
+    postMessageToEditor({
+      action: CLIENT_ACTIONS.UPDATE_CONTENTLET_INLINE_EDITING,
+      payload: {
+        content: editedContent,
+        dataset: {
+          inode,
+          langId,
+          fieldName
+        }
+      }
+    });
+  };
+  const didContentChange = editedContent => {
+    return content !== editedContent;
+  };
+  if (!isInsideEditor$1) {
+    // We can let the user pass the Child Component and create a root to get the HTML for the editor
+    return jsx("span", {
+      dangerouslySetInnerHTML: {
+        __html: content
+      }
+    });
+  }
+  return jsx(Editor, {
+    tinymceScriptSrc: scriptSrc,
+    inline: true,
+    onInit: (_, editor) => editorRef.current = editor,
+    init: TINYMCE_CONFIG[mode],
+    initialValue: content,
+    onMouseDown: onMouseDown,
+    onFocusOut: onFocusOut
+  });
+}
+
+/**
+ * `useDotcmsPageContext` is a custom React hook that provides access to the `PageProviderContext`.
+ * It takes no parameters and returns the context value or `null` if it's not available.
+ *
+ * @category Hooks
+ * @returns {DotCMSPageContext | null} - The context value or `null` if it's not available.
+ */
+function useDotcmsPageContext() {
+  return useContext(PageContext);
+}
+
+/**
+ * Represents the different types of Blocks that can be used in the Block Editor
+ *
+ * @export
+ * @enum {number}
+ */
+var Blocks;
+(function (Blocks) {
+  Blocks["PARAGRAPH"] = "paragraph";
+  Blocks["HEADING"] = "heading";
+  Blocks["TEXT"] = "text";
+  Blocks["BULLET_LIST"] = "bulletList";
+  Blocks["ORDERED_LIST"] = "orderedList";
+  Blocks["LIST_ITEM"] = "listItem";
+  Blocks["BLOCK_QUOTE"] = "blockquote";
+  Blocks["CODE_BLOCK"] = "codeBlock";
+  Blocks["HARDBREAK"] = "hardBreak";
+  Blocks["HORIZONTAL_RULE"] = "horizontalRule";
+  Blocks["DOT_IMAGE"] = "dotImage";
+  Blocks["DOT_VIDEO"] = "dotVideo";
+  Blocks["TABLE"] = "table";
+  Blocks["DOT_CONTENT"] = "dotContent";
+})(Blocks || (Blocks = {}));
+
+/**
+ * Renders a code block component.
+ *
+ * @param attrs - The attributes of the code block.
+ * @param children - The content of the code block.
+ * @returns The rendered code block component.
+ */
+const CodeBlock = ({
+  attrs,
+  children
+}) => {
+  const language = (attrs == null ? void 0 : attrs.language) || '';
+  return jsx("pre", {
+    "data-language": language,
+    children: jsx("code", {
+      children: children
+    })
+  });
+};
+/**
+ * Renders a blockquote component.
+ *
+ * @param children - The content to be rendered inside the blockquote.
+ * @returns The rendered blockquote component.
+ */
+const BlockQuote = ({
+  children
+}) => {
+  return jsx("blockquote", {
+    children: children
+  });
+};
+
+function _objectWithoutPropertiesLoose(r, e) {
+  if (null == r) return {};
+  var t = {};
+  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+    if (e.includes(n)) continue;
+    t[n] = r[n];
+  }
+  return t;
+}
+
+const _excluded = ["customRenderers"];
+/**
+ * Renders the default content for an unknown content type.
+ */
+const DefaultContent = () => jsx("div", {
+  children: "Unknown Content Type"
+});
+/**
+ * Renders a DotContent component.
+ *
+ * @param {DotContentProps} props - The props for the DotContent component.
+ * @returns {JSX.Element} The rendered DotContent component.
+ */
+const DotContent = _ref => {
+  var _customRenderers$data;
+  let {
+      customRenderers
+    } = _ref,
+    props = _objectWithoutPropertiesLoose(_ref, _excluded);
+  const {
+    attrs
+  } = props;
+  const data = attrs == null ? void 0 : attrs.data;
+  const Component = (_customRenderers$data = customRenderers == null ? void 0 : customRenderers[data == null ? void 0 : data.contentType]) != null ? _customRenderers$data : DefaultContent;
+  if (!data) {
+    console.error('DotContent: No data provided');
+  }
+  return jsx(Component, Object.assign({}, props));
+};
+
+/**
+ * Renders an image component for dotCMS.
+ *
+ * @param props - The props for the DotCMSImage component.
+ * @returns The rendered image component.
+ */
+const DotCMSImage = props => {
+  const {
+    data,
+    src,
+    alt
+  } = props.attrs;
+  const client = DotCmsClient.instance;
+  const srcUrl = data != null && data.identifier ? `${client.dotcmsUrl}${src}` : src;
+  return jsx("img", {
+    alt: alt,
+    src: srcUrl
+  });
+};
+
+/**
+ * ListItem component represents a list item in a block editor.
+ *
+ * @param children - The content of the list item.
+ * @returns The rendered list item element.
+ */
+const ListItem = ({
+  children
+}) => {
+  return jsx("li", {
+    children: children
+  });
+};
+/**
+ * Renders an ordered list component.
+ *
+ * @param children - The content to be rendered inside the ordered list.
+ * @returns The ordered list component.
+ */
+const OrderedList = ({
+  children
+}) => {
+  return jsx("ol", {
+    children: children
+  });
+};
+/**
+ * Renders a bullet list component.
+ *
+ * @param children - The content of the bullet list.
+ * @returns The rendered bullet list component.
+ */
+const BulletList = ({
+  children
+}) => {
+  return jsx("ul", {
+    children: children
+  });
+};
+
+/**
+ * Renders a table component for the Block Editor.
+ *
+ * @param content - The content of the table.
+ * @param blockEditorItem - The Block Editor item component.
+ */
+const TableRenderer = ({
+  content,
+  blockEditorItem
+}) => {
+  const BlockEditorItemComponent = blockEditorItem;
+  const renderTableContent = node => {
+    return jsx(BlockEditorItemComponent, {
+      content: node.content
+    });
+  };
+  return jsxs("table", {
+    children: [jsx("thead", {
+      children: content.slice(0, 1).map((rowNode, rowIndex) => {
+        var _rowNode$content;
+        return jsx("tr", {
+          children: (_rowNode$content = rowNode.content) == null ? void 0 : _rowNode$content.map((cellNode, cellIndex) => {
+            var _cellNode$attrs, _cellNode$attrs2;
+            return jsx("th", {
+              colSpan: Number(((_cellNode$attrs = cellNode.attrs) == null ? void 0 : _cellNode$attrs.colspan) || 1),
+              rowSpan: Number(((_cellNode$attrs2 = cellNode.attrs) == null ? void 0 : _cellNode$attrs2.rowspan) || 1),
+              children: renderTableContent(cellNode)
+            }, `${cellNode.type}-${cellIndex}`);
+          })
+        }, `${rowNode.type}-${rowIndex}`);
+      })
+    }), jsx("tbody", {
+      children: content.slice(1).map((rowNode, rowIndex) => {
+        var _rowNode$content2;
+        return jsx("tr", {
+          children: (_rowNode$content2 = rowNode.content) == null ? void 0 : _rowNode$content2.map((cellNode, cellIndex) => {
+            var _cellNode$attrs3, _cellNode$attrs4;
+            return jsx("td", {
+              colSpan: Number(((_cellNode$attrs3 = cellNode.attrs) == null ? void 0 : _cellNode$attrs3.colspan) || 1),
+              rowSpan: Number(((_cellNode$attrs4 = cellNode.attrs) == null ? void 0 : _cellNode$attrs4.rowspan) || 1),
+              children: renderTableContent(cellNode)
+            }, `${cellNode.type}-${cellIndex}`);
+          })
+        }, `${rowNode.type}-${rowIndex}`);
+      })
+    })]
+  });
+};
+
+/**
+ * Renders the text in bold.
+ *
+ * @param children - The content to be rendered in bold.
+ */
+const Bold = ({
+  children
+}) => jsx("strong", {
+  children: children
+});
+/**
+ * Renders the text in italic format.
+ *
+ * @param children - The content to be rendered in italic.
+ */
+const Italic = ({
+  children
+}) => jsx("em", {
+  children: children
+});
+/**
+ * Renders a strike-through text.
+ *
+ * @param children - The content to be rendered within the strike-through element.
+ */
+const Strike = ({
+  children
+}) => jsx("s", {
+  children: children
+});
+/**
+ * Renders an underline element for the given children.
+ *
+ * @param children - The content to be underlined.
+ */
+const Underline = ({
+  children
+}) => jsx("u", {
+  children: children
+});
+/**
+ * Renders a paragraph element.
+ *
+ * @param children - The content of the paragraph.
+ * @param attrs - The style attributes for the paragraph.
+ * @returns The rendered paragraph element.
+ */
+const Paragraph = ({
+  children,
+  attrs
+}) => {
+  return jsx("p", {
+    style: attrs,
+    children: children
+  });
+};
+/**
+ * Renders a link component.
+ *
+ * @param children - The content of the link.
+ * @param attrs - The attributes to be applied to the link.
+ * @returns The rendered link component.
+ */
+const Link = ({
+  children,
+  attrs
+}) => {
+  return jsx("a", Object.assign({}, attrs, {
+    children: children
+  }));
+};
+/**
+ * Renders a heading element with the specified level.
+ *
+ * @param children - The content of the heading.
+ * @param attrs - The attributes for the heading.
+ * @returns The rendered heading element.
+ */
+const Heading = ({
+  children,
+  attrs
+}) => {
+  const level = (attrs == null ? void 0 : attrs.level) || 1;
+  const Tag = `h${level}`;
+  return jsx(Tag, {
+    children: children
+  });
+};
+/**
+ * Renders the superscript text.
+ *
+ * @param children - The content to be rendered as superscript.
+ */
+const Superscript = ({
+  children
+}) => jsx("sup", {
+  children: children
+});
+/**
+ * Renders a subscript element.
+ *
+ * @param children - The content to be rendered as subscript.
+ */
+const Subscript = ({
+  children
+}) => jsx("sub", {
+  children: children
+});
+const nodeMarks = {
+  link: Link,
+  bold: Bold,
+  underline: Underline,
+  italic: Italic,
+  strike: Strike,
+  superscript: Superscript,
+  subscript: Subscript
+};
+/**
+ * Renders a text block with optional marks.
+ *
+ * @param props - The props for the TextBlock component.
+ * @returns The rendered text block.
+ */
+const TextBlock = props => {
+  const {
+    marks = [],
+    text
+  } = props;
+  const mark = marks[0] || {
+    type: '',
+    attrs: {}
+  };
+  const newProps = Object.assign({}, props, {
+    marks: marks.slice(1)
+  });
+  const Component = nodeMarks[mark == null ? void 0 : mark.type];
+  // To avoid the warning: "Warning: Invalid DOM property `class`. Did you mean `className`?"
+  if (mark.attrs) {
+    mark.attrs.className = mark.attrs.class;
+    delete mark.attrs.class;
+  }
+  if (!Component) {
+    return text;
+  }
+  return jsx(Component, {
+    attrs: mark.attrs,
+    children: jsx(TextBlock, Object.assign({}, newProps))
+  });
+};
+
+/**
+ * Renders a video component for displaying videos.
+ *
+ * @param props - The properties for the video component.
+ * @returns The rendered video component.
+ */
+const DotCMSVideo = props => {
+  const {
+    data,
+    src,
+    mimeType,
+    width,
+    height
+  } = props.attrs;
+  const client = DotCmsClient.instance;
+  const srcUrl = data != null && data.identifier ? `${client.dotcmsUrl}${src}` : src;
+  const poster = data != null && data.thumbnail ? `${client.dotcmsUrl}${data == null ? void 0 : data.thumbnail}` : 'poster-image.jpg';
+  return jsxs("video", {
+    controls: true,
+    preload: "metadata",
+    poster: poster,
+    width: width,
+    height: height,
+    children: [jsx("track", {
+      default: true,
+      kind: "captions",
+      srcLang: "en"
+    }), jsx("source", {
+      src: srcUrl,
+      type: mimeType
+    }), "Your browser does not support the ", jsx("code", {
+      children: "video"
+    }), " element."]
+  });
+};
+
+/**
+ * Renders a block editor item based on the provided content and custom renderers.
+ *
+ * @param content - The content nodes to render.
+ * @param customRenderers - Optional custom renderers for specific node types.
+ * @returns The rendered block editor item.
+ */
+const BlockEditorBlock = ({
+  content,
+  customRenderers
+}) => {
+  return content == null ? void 0 : content.map((node, index) => {
+    const CustomRendererComponent = customRenderers == null ? void 0 : customRenderers[node.type];
+    if (CustomRendererComponent) {
+      return jsx(CustomRendererComponent, Object.assign({}, node, {
+        content: node.content,
+        children: jsx(BlockEditorBlock, {
+          content: node.content,
+          customRenderers: customRenderers
+        })
+      }), `${node.type}-${index}`);
+    }
+    switch (node.type) {
+      case Blocks.PARAGRAPH:
+        return jsx(Paragraph, Object.assign({}, node, {
+          children: jsx(BlockEditorBlock, {
+            content: node.content,
+            customRenderers: customRenderers
+          })
+        }), `${node.type}-${index}`);
+      case Blocks.HEADING:
+        return jsx(Heading, Object.assign({}, node, {
+          children: jsx(BlockEditorBlock, {
+            content: node.content,
+            customRenderers: customRenderers
+          })
+        }), `${node.type}-${index}`);
+      case Blocks.TEXT:
+        return jsx(TextBlock, Object.assign({}, node), `${node.type}-${index}`);
+      case Blocks.BULLET_LIST:
+        return jsx(BulletList, {
+          children: jsx(BlockEditorBlock, {
+            content: node.content,
+            customRenderers: customRenderers
+          })
+        }, `${node.type}-${index}`);
+      case Blocks.ORDERED_LIST:
+        return jsx(OrderedList, {
+          children: jsx(BlockEditorBlock, {
+            content: node.content,
+            customRenderers: customRenderers
+          })
+        }, `${node.type}-${index}`);
+      case Blocks.LIST_ITEM:
+        return jsx(ListItem, {
+          children: jsx(BlockEditorBlock, {
+            content: node.content,
+            customRenderers: customRenderers
+          })
+        }, `${node.type}-${index}`);
+      case Blocks.BLOCK_QUOTE:
+        return jsx(BlockQuote, {
+          children: jsx(BlockEditorBlock, {
+            content: node.content,
+            customRenderers: customRenderers
+          })
+        }, `${node.type}-${index}`);
+      case Blocks.CODE_BLOCK:
+        return jsx(CodeBlock, Object.assign({}, node, {
+          children: jsx(BlockEditorBlock, {
+            content: node.content,
+            customRenderers: customRenderers
+          })
+        }), `${node.type}-${index}`);
+      case Blocks.HARDBREAK:
+        return jsx("br", {}, `${node.type}-${index}`);
+      case Blocks.HORIZONTAL_RULE:
+        return jsx("hr", {}, `${node.type}-${index}`);
+      case Blocks.DOT_IMAGE:
+        return jsx(DotCMSImage, Object.assign({}, node), `${node.type}-${index}`);
+      case Blocks.DOT_VIDEO:
+        return jsx(DotCMSVideo, Object.assign({}, node), `${node.type}-${index}`);
+      case Blocks.TABLE:
+        return jsx(TableRenderer, {
+          content: node.content,
+          blockEditorItem: BlockEditorBlock
+        }, `${node.type}-${index}`);
+      case Blocks.DOT_CONTENT:
+        return jsx(DotContent, Object.assign({}, node, {
+          customRenderers: customRenderers
+        }), `${node.type}-${index}`);
+      default:
+        return jsxs("div", {
+          children: ["Unknown Block Type ", node.type]
+        }, `${node.type}-${index}`);
+    }
+  });
+};
+
+/**
+ * BlockEditorRenderer component for rendering block editor field.
+ *
+ * @component
+ * @param {Object} props - The component props.
+ * @param {Block} props.blocks - The blocks of content to render.
+ * @param {CustomRenderer} [props.customRenderers] - Optional custom renderers for specific block types.
+ * @param {string} [props.className] - Optional CSS class name for the container div.
+ * @param {React.CSSProperties} [props.style] - Optional inline styles for the container div.
+ * @param {boolean} props.editable - Flag to enable inline editing. When true, `contentlet` and `fieldName` are required. Note: Enterprise only feature.
+ * @param {DotCMSContentlet} [props.contentlet] - Contentlet object for inline editing. Required when `editable` is true.
+ * @param {string} [props.fieldName] - Field name for inline editing. Required when `editable` is true.
+ * @returns {JSX.Element} A div containing the rendered blocks of content.
+ */
+const BlockEditorRenderer = ({
+  style,
+  blocks,
+  editable,
+  fieldName,
+  className,
+  contentlet,
+  customRenderers
+}) => {
+  const ref = useRef(null);
+  const [blockEditorState, setBlockEditorState] = useState({
+    error: null
+  });
+  /**
+   * Sets up inline editing functionality when the component is editable and inside the editor.
+   *
+   * This effect:
+   * 1. Checks if inline editing should be enabled based on props and editor context
+   * 2. Validates required props for inline editing (contentlet and fieldName)
+   * 3. Extracts necessary data from the contentlet
+   * 4. Adds a click handler to initialize inline editing with the block editor
+   * 5. Cleans up event listener on unmount
+   *
+   * @dependency {boolean} editable - Flag to enable/disable inline editing
+   * @dependency {DotCMSContentlet} contentlet - Contentlet data required for editing
+   * @dependency {Block} blocks - The content blocks to edit
+   * @dependency {string} fieldName - Name of the field being edited
+   */
+  useEffect(() => {
+    if (!editable || !ref.current || !isInsideEditor()) {
+      return;
+    }
+    // TypeScript will throw an error if contentlet or fieldName are not provided when editable is true,
+    // but we need to check them again to avoid runtime errors in Pure JavaScript
+    if (!contentlet || !fieldName) {
+      console.error('contentlet and fieldName are required to enable inline editing');
+      return;
+    }
+    const {
+      inode,
+      languageId: language,
+      contentType
+    } = contentlet;
+    // `ContentNode` lives on `@dotcms/react` that's why we can use it in `@dotcms/client`
+    // We need to move interfaces to external lib
+    const content = blocks;
+    const element = ref.current;
+    const handleClickEvent = () => {
+      initInlineEditing('BLOCK_EDITOR', {
+        inode,
+        content,
+        language,
+        fieldName,
+        contentType
+      });
+    };
+    element.addEventListener('click', handleClickEvent);
+    return () => element.removeEventListener('click', handleClickEvent);
+  }, [editable, contentlet, blocks, fieldName]);
+  /**
+   * Validates the blocks structure and updates the block editor state.
+   *
+   * This effect:
+   * 1. Validates that blocks have the correct structure (doc type, content array, etc)
+   * 2. Updates the block editor state with validation result
+   * 3. Logs any validation errors to console
+   *
+   * @dependency {Block} blocks - The content blocks to validate
+   */
+  useEffect(() => {
+    const validationResult = isValidBlocks(blocks);
+    setBlockEditorState(validationResult);
+    if (validationResult.error) {
+      console.error(validationResult.error);
+    }
+  }, [blocks]);
+  if (blockEditorState.error) {
+    console.error(blockEditorState.error);
+    if (isInsideEditor()) {
+      return jsx("div", {
+        "data-testid": "invalid-blocks-message",
+        children: blockEditorState.error
+      });
+    }
+    return null;
+  }
+  return jsx("div", {
+    className: className,
+    style: style,
+    ref: ref,
+    "data-testid": "dot-block-editor-container",
+    children: jsx(BlockEditorBlock, {
+      content: blocks == null ? void 0 : blocks.content,
+      customRenderers: customRenderers
+    })
+  });
+};
+
+export { BlockEditorRenderer, DotEditableText, DotcmsLayout, PageProvider, Row, useDotcmsPageContext };