@vodafone_de/publish-test 0.0.1 → 53.0.0

package/dist/index-B39bJrc9.js

@@ -0,0 +1,1033 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import React, { isValidElement, cloneElement, createElement, useEffect } from "react";
+import { c as spanTagName, d as divTagName, g as headingHtmlTags, f as supTagName, e as strongTagName, r as olTagName, u as ulTagName } from "./tags-BeNegJAK.js";
+import { c as spacingSm, b as spacingNone, s as spacingMd } from "./Spacing-Dj-qX3Z5.js";
+import parse, { Element, domToReact } from "html-react-parser";
+import Body from "./components/Body/index.js";
+import { F as FootnoteLink } from "./index-lCL2zeQr.js";
+import Heading from "./components/Heading/index.js";
+import InlineLink from "./components/InlineLink/index.js";
+import { B as BLOCKS, I as INLINES, M as MARKS, r as richTextContentfulComponentName, a as richTextComponentName } from "./props-B5OwQmNC.js";
+import styled from "styled-components";
+import { v as viewport } from "./index-CG4uiVbZ.js";
+import { getBorderColor } from "./foundations/token/getBorderColor/index.js";
+import { getFontWeight } from "./foundations/token/getFontWeight/index.js";
+import { g as getSpacing } from "./index-l-i-mIeP.js";
+import { getTextColor } from "./foundations/token/getTextColor/index.js";
+import { f as colorBorderSubtle, a as colorBorderNeutral } from "./BorderColor-BACbvI20.js";
+import { a as fontWeightBold, f as fontWeightRegular } from "./FontWeight-C8c-UnWu.js";
+import { a as colorTextNeutral } from "./TextColor-DsntmDNw.js";
+import Divider from "./components/Divider/index.js";
+import { getBottomSpacing } from "./foundations/token/getBottomSpacing/index.js";
+import { s as shouldForwardProp } from "./shouldForwardProp-CONMmlMa.js";
+import { translateLayoutPropsToCss } from "./foundations/layout/index.js";
+import { getBodySize } from "./foundations/token/getBodySize/index.js";
+import { a as textBodySm, t as textBodyMd } from "./TextBodySize-CP9q4gRv.js";
+import "./index-p6eyyJpy.js";
+import "./props-GrMT6XLD.js";
+import "./hooks/useLinkComponent/index.js";
+import { t as textHeadingXs, a as textHeadingSm, b as textHeadingMd, c as textHeadingLg, d as textHeadingXl } from "./HeadingSize-O__w72MO.js";
+var ElementType;
+(function(ElementType2) {
+  ElementType2["Root"] = "root";
+  ElementType2["Text"] = "text";
+  ElementType2["Directive"] = "directive";
+  ElementType2["Comment"] = "comment";
+  ElementType2["Script"] = "script";
+  ElementType2["Style"] = "style";
+  ElementType2["Tag"] = "tag";
+  ElementType2["CDATA"] = "cdata";
+  ElementType2["Doctype"] = "doctype";
+})(ElementType || (ElementType = {}));
+const Root = ElementType.Root;
+const Text = ElementType.Text;
+const Directive = ElementType.Directive;
+const Comment = ElementType.Comment;
+const Script = ElementType.Script;
+const Style = ElementType.Style;
+const Tag = ElementType.Tag;
+const CDATA = ElementType.CDATA;
+ElementType.Doctype;
+const xmlCodeMap = /* @__PURE__ */ new Map([
+  [34, """],
+  [38, "&"],
+  [39, "'"],
+  [60, "<"],
+  [62, ">"]
+]);
+const getCodePoint = typeof String.prototype.codePointAt === "function" ? (input, index) => input.codePointAt(index) : (
+  // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+  (c, index) => (c.charCodeAt(index) & 64512) === 55296 ? (c.charCodeAt(index) - 55296) * 1024 + c.charCodeAt(index + 1) - 56320 + 65536 : c.charCodeAt(index)
+);
+const XML_BITSET_VALUE = 1342177476;
+function encodeXML(input) {
+  let out;
+  let last = 0;
+  const { length } = input;
+  for (let index = 0; index < length; index++) {
+    const char = input.charCodeAt(index);
+    if (char < 128 && ((XML_BITSET_VALUE >>> char & 1) === 0 || char >= 64 || char < 32)) {
+      continue;
+    }
+    if (out === void 0)
+      out = input.substring(0, index);
+    else if (last !== index)
+      out += input.substring(last, index);
+    if (char < 64) {
+      out += xmlCodeMap.get(char);
+      last = index + 1;
+      continue;
+    }
+    const cp = getCodePoint(input, index);
+    out += `&#x${cp.toString(16)};`;
+    if (cp !== char)
+      index++;
+    last = index + 1;
+  }
+  if (out === void 0)
+    return input;
+  if (last < length)
+    out += input.substr(last);
+  return out;
+}
+function getEscaper(regex, map) {
+  return function escape(data) {
+    let match;
+    let lastIndex = 0;
+    let result = "";
+    while (match = regex.exec(data)) {
+      if (lastIndex !== match.index) {
+        result += data.substring(lastIndex, match.index);
+      }
+      result += map.get(match[0].charCodeAt(0));
+      lastIndex = match.index + 1;
+    }
+    return result + data.substring(lastIndex);
+  };
+}
+const escapeAttribute = /* @__PURE__ */ getEscaper(/["&\u00A0]/g, /* @__PURE__ */ new Map([
+  [34, "&quot;"],
+  [38, "&amp;"],
+  [160, "&nbsp;"]
+]));
+const escapeText = /* @__PURE__ */ getEscaper(/[&<>\u00A0]/g, /* @__PURE__ */ new Map([
+  [38, "&amp;"],
+  [60, "&lt;"],
+  [62, "&gt;"],
+  [160, "&nbsp;"]
+]));
+const elementNames = new Map("altGlyph altGlyphDef altGlyphItem animateColor animateMotion animateTransform clipPath feBlend feColorMatrix feComponentTransfer feComposite feConvolveMatrix feDiffuseLighting feDisplacementMap feDistantLight feDropShadow feFlood feFuncA feFuncB feFuncG feFuncR feGaussianBlur feImage feMerge feMergeNode feMorphology feOffset fePointLight feSpecularLighting feSpotLight feTile feTurbulence foreignObject glyphRef linearGradient radialGradient textPath".split(" ").map((name) => [name.toLowerCase(), name]));
+const attributeNames = new Map("definitionURL attributeName attributeType baseFrequency baseProfile calcMode clipPathUnits diffuseConstant edgeMode filterUnits glyphRef gradientTransform gradientUnits kernelMatrix kernelUnitLength keyPoints keySplines keyTimes lengthAdjust limitingConeAngle markerHeight markerUnits markerWidth maskContentUnits maskUnits numOctaves pathLength patternContentUnits patternTransform patternUnits pointsAtX pointsAtY pointsAtZ preserveAlpha preserveAspectRatio primitiveUnits refX refY repeatCount repeatDur requiredExtensions requiredFeatures specularConstant specularExponent spreadMethod startOffset stdDeviation stitchTiles surfaceScale systemLanguage tableValues targetX targetY textLength viewBox viewTarget xChannelSelector yChannelSelector zoomAndPan".split(" ").map((name) => [name.toLowerCase(), name]));
+const unencodedElements = new Set("style script xmp iframe noembed noframes plaintext noscript".split(" "));
+const voidElements = new Set("area base basefont br col command embed frame hr img input isindex keygen link meta param source track wbr".split(" "));
+const foreignElements = /* @__PURE__ */ new Set(["svg", "math"]);
+const foreignModeIntegrationPoints = new Set("mi mo mn ms mtext annotation-xml foreignObject desc title".split(" "));
+function render(node, options = {}) {
+  const nodes = "length" in node ? node : [node];
+  const xmlMode = options.xmlMode ?? false;
+  let output = "";
+  for (let index = 0; index < nodes.length; index++) {
+    output += renderNode(nodes[index], options, xmlMode);
+  }
+  return output;
+}
+function renderChildren(children, options, xmlMode) {
+  let output = "";
+  for (let index = 0; index < children.length; index++) {
+    output += renderNode(children[index], options, xmlMode);
+  }
+  return output;
+}
+function renderNode(node, options, xmlMode) {
+  switch (node.type) {
+    case Root: {
+      return renderChildren(node.children, options, xmlMode);
+    }
+    case Directive: {
+      return `<${node.data}>`;
+    }
+    case Comment: {
+      return `<!--${node.data}-->`;
+    }
+    case CDATA: {
+      return `<![CDATA[${node.children[0].data}]]>`;
+    }
+    case Script:
+    case Style:
+    case Tag: {
+      return renderTag(node, options, xmlMode);
+    }
+    case Text: {
+      const element = node;
+      const data = element.data || "";
+      if ((options.encodeEntities ?? options.decodeEntities) !== false && !(!xmlMode && element.parent && unencodedElements.has(element.parent.name))) {
+        return xmlMode || options.encodeEntities !== "utf8" ? encodeXML(data) : escapeText(data);
+      }
+      return data;
+    }
+  }
+}
+function renderTag(element, options, xmlMode) {
+  if (xmlMode === "foreign") {
+    element.name = elementNames.get(element.name) ?? element.name;
+    if (element.parent && foreignModeIntegrationPoints.has(element.parent.name)) {
+      xmlMode = false;
+    }
+  }
+  if (!xmlMode && foreignElements.has(element.name)) {
+    xmlMode = "foreign";
+  }
+  const { name, children } = element;
+  const isVoid = !xmlMode && voidElements.has(name);
+  let tag = `<${name}${formatAttributes(element.attribs, options, xmlMode)}`;
+  if (children.length === 0 && (xmlMode ? options.selfClosingTags !== false : options.selfClosingTags && isVoid)) {
+    tag += xmlMode ? "/>" : " />";
+  } else {
+    tag += ">";
+    if (children.length > 0) {
+      tag += renderChildren(children, options, xmlMode);
+    }
+    if (!isVoid) {
+      tag += `</${name}>`;
+    }
+  }
+  return tag;
+}
+function replaceQuotes(value) {
+  return value.replaceAll('"', "&quot;");
+}
+function formatAttributes(attributes, options, xmlMode) {
+  if (!attributes)
+    return "";
+  const encode = (options.encodeEntities ?? options.decodeEntities) === false ? replaceQuotes : xmlMode || options.encodeEntities !== "utf8" ? encodeXML : escapeAttribute;
+  const isForeign = xmlMode === "foreign";
+  const showEmpty = !!(options.emptyAttrs ?? xmlMode);
+  let result = "";
+  for (const key in attributes) {
+    if (!Object.hasOwn(attributes, key))
+      continue;
+    const value = attributes[key];
+    const k = isForeign ? attributeNames.get(key) ?? key : key;
+    result += !showEmpty && (value == null || value === "") ? ` ${k}` : ` ${k}="${encode(value == null ? "" : String(value))}"`;
+  }
+  return result;
+}
+const tableAlignLeft = "left";
+const tableAlignRight = "right";
+const tableAligns = [tableAlignLeft, tableAlignRight];
+const TableWrapperStyled = styled.div.withConfig({
+  displayName: "TableWrapperStyled",
+  componentId: "sc-y6pzpn-0"
+})({
+  overflowX: "auto"
+});
+const TableStyled = styled.table.withConfig({
+  displayName: "TableStyled",
+  componentId: "sc-y6pzpn-1"
+})({
+  all: "unset",
+  // Reset all inherited styles
+  display: "table",
+  width: "100%",
+  overflow: "auto"
+});
+const TableHeadStyled = styled.thead.withConfig({
+  displayName: "TableHeadStyled",
+  componentId: "sc-y6pzpn-2"
+})({
+  all: "unset",
+  // Reset all inherited styles for thead
+  display: "table-header-group"
+});
+const TableRowStyled = styled.tr.withConfig({
+  displayName: "TableRowStyled",
+  componentId: "sc-y6pzpn-3"
+})({
+  all: "unset",
+  // Reset all inherited styles for tr
+  display: "table-row"
+});
+const TableCellStyled = styled.td.withConfig({
+  displayName: "TableCellStyled",
+  componentId: "sc-y6pzpn-4"
+})(({
+  align,
+  as
+}) => ({
+  all: "unset",
+  // Reset all inherited styles for cell
+  display: "table-cell",
+  boxSizing: "border-box",
+  padding: `${getSpacing(spacingSm)}`,
+  textAlign: align,
+  color: getTextColor(colorTextNeutral),
+  borderBottom: `1px solid ${as === "th" ? getBorderColor(colorBorderNeutral) : getBorderColor(colorBorderSubtle)}`,
+  fontWeight: as === "th" ? getFontWeight(fontWeightBold) : getFontWeight(fontWeightRegular),
+  minWidth: 180,
+  wordBreak: "break-word",
+  whiteSpace: "normal",
+  overflowWrap: "break-word",
+  ...viewport.lg({
+    minWidth: 248
+  }),
+  // Style for tfoot cells
+  "tfoot &": {
+    borderBottom: `1px solid ${getBorderColor(colorBorderSubtle)}`,
+    fontWeight: getFontWeight(fontWeightBold)
+  }
+}));
+function isText(node) {
+  return node.nodeType === "text";
+}
+function isEmptyParagraph(node) {
+  if (node.nodeType !== BLOCKS.PARAGRAPH) {
+    return false;
+  }
+  if (node.content.length !== 1) {
+    return false;
+  }
+  const textNode = node.content[0];
+  return textNode.nodeType === "text" && textNode.value === "";
+}
+function isValidDocument(document) {
+  return document != null && typeof document === "object" && "content" in document && Array.isArray(document.content);
+}
+const MIN_NODES_FOR_STRIPPING = 2;
+function stripEmptyTrailingParagraphFromDocument(document) {
+  if (!isValidDocument(document) || document.content.length < MIN_NODES_FOR_STRIPPING) {
+    return document;
+  }
+  const lastNode = document.content[document.content.length - 1];
+  if (isEmptyParagraph(lastNode)) {
+    return {
+      ...document,
+      content: document.content.slice(0, -1)
+    };
+  }
+  return document;
+}
+function appendKeyToValidElement(element, key) {
+  if (isValidElement(element) && element.key === null) {
+    return cloneElement(element, {
+      key
+    });
+  }
+  return element;
+}
+function nodeListToReactComponents(nodes, options) {
+  return nodes.map((node, index) => {
+    return appendKeyToValidElement(nodeToReactComponent(node, options), index);
+  });
+}
+function nodeToReactComponent(node, options) {
+  const { renderNode: renderNode2, renderMark, renderText, preserveWhitespace } = options;
+  if (isText(node)) {
+    let nodeValue = renderText ? renderText(node.value) : node.value;
+    if (preserveWhitespace && !renderText) {
+      nodeValue = nodeValue.replace(/ {2,}/g, (match) => " ".repeat(match.length));
+      const lines = nodeValue.split("\n");
+      const jsxLines = [];
+      lines.forEach((line, index) => {
+        jsxLines.push(line);
+        if (index !== lines.length - 1) {
+          jsxLines.push(React.createElement("br", null));
+        }
+      });
+      nodeValue = jsxLines;
+    }
+    return node.marks.reduce((value, mark) => {
+      if (!renderMark[mark.type]) {
+        return value;
+      }
+      return renderMark[mark.type](value);
+    }, nodeValue);
+  } else {
+    const children = nodeListToReactComponents(node.content, options);
+    if (!node.nodeType || !renderNode2[node.nodeType]) {
+      return React.createElement(React.Fragment, null, children);
+    }
+    return renderNode2[node.nodeType](node, children);
+  }
+}
+const defaultNodeRenderers = {
+  [BLOCKS.DOCUMENT]: (node, children) => children,
+  [BLOCKS.PARAGRAPH]: (node, children) => React.createElement("p", null, children),
+  [BLOCKS.HEADING_1]: (node, children) => React.createElement("h1", null, children),
+  [BLOCKS.HEADING_2]: (node, children) => React.createElement("h2", null, children),
+  [BLOCKS.HEADING_3]: (node, children) => React.createElement("h3", null, children),
+  [BLOCKS.HEADING_4]: (node, children) => React.createElement("h4", null, children),
+  [BLOCKS.HEADING_5]: (node, children) => React.createElement("h5", null, children),
+  [BLOCKS.HEADING_6]: (node, children) => React.createElement("h6", null, children),
+  [BLOCKS.EMBEDDED_ENTRY]: (node, children) => React.createElement("div", null, children),
+  [BLOCKS.EMBEDDED_RESOURCE]: (node, children) => React.createElement("div", null, children),
+  [BLOCKS.UL_LIST]: (node, children) => React.createElement("ul", null, children),
+  [BLOCKS.OL_LIST]: (node, children) => React.createElement("ol", null, children),
+  [BLOCKS.LIST_ITEM]: (node, children) => React.createElement("li", null, children),
+  [BLOCKS.QUOTE]: (node, children) => React.createElement("blockquote", null, children),
+  [BLOCKS.HR]: () => React.createElement("hr", null),
+  [BLOCKS.TABLE]: (node, children) => React.createElement("table", null, React.createElement("tbody", null, children)),
+  [BLOCKS.TABLE_ROW]: (node, children) => React.createElement("tr", null, children),
+  [BLOCKS.TABLE_HEADER_CELL]: (node, children) => React.createElement("th", null, children),
+  [BLOCKS.TABLE_CELL]: (node, children) => React.createElement("td", null, children),
+  [INLINES.ASSET_HYPERLINK]: (node) => defaultInline(INLINES.ASSET_HYPERLINK, node),
+  [INLINES.ENTRY_HYPERLINK]: (node) => defaultInline(INLINES.ENTRY_HYPERLINK, node),
+  [INLINES.RESOURCE_HYPERLINK]: (node) => defaultInlineResource(INLINES.RESOURCE_HYPERLINK, node),
+  [INLINES.EMBEDDED_ENTRY]: (node) => defaultInline(INLINES.EMBEDDED_ENTRY, node),
+  [INLINES.EMBEDDED_RESOURCE]: (node, _children) => defaultInlineResource(INLINES.EMBEDDED_RESOURCE, node),
+  [INLINES.HYPERLINK]: (node, children) => React.createElement("a", {
+    href: node.data.uri
+  }, children)
+};
+const defaultMarkRenderers = {
+  [MARKS.BOLD]: (text) => React.createElement("b", null, text),
+  [MARKS.ITALIC]: (text) => React.createElement("i", null, text),
+  [MARKS.UNDERLINE]: (text) => React.createElement("u", null, text),
+  [MARKS.CODE]: (text) => React.createElement("code", null, text),
+  [MARKS.SUPERSCRIPT]: (text) => React.createElement("sup", null, text),
+  [MARKS.SUBSCRIPT]: (text) => React.createElement("sub", null, text),
+  [MARKS.STRIKETHROUGH]: (text) => React.createElement("s", null, text)
+};
+function defaultInline(type, node) {
+  return React.createElement("span", {
+    key: node.data.target.sys.id
+  }, "type: ", node.nodeType, " id: ", node.data.target.sys.id);
+}
+function defaultInlineResource(type, node) {
+  return React.createElement("span", {
+    key: node.data.target.sys.urn
+  }, "type: ", node.nodeType, " urn: ", node.data.target.sys.urn);
+}
+function documentToReactComponents(richTextDocument, options = {}) {
+  if (!richTextDocument) {
+    return null;
+  }
+  let processedDocument = richTextDocument;
+  if (options.stripEmptyTrailingParagraph) {
+    processedDocument = stripEmptyTrailingParagraphFromDocument(richTextDocument);
+  }
+  return nodeToReactComponent(processedDocument, {
+    renderNode: {
+      ...defaultNodeRenderers,
+      ...options.renderNode
+    },
+    renderMark: {
+      ...defaultMarkRenderers,
+      ...options.renderMark
+    },
+    renderText: options.renderText,
+    preserveWhitespace: options.preserveWhitespace
+  });
+}
+const TARGET_BLANK_PREFIX = "@@@TARGETBLANK@@@";
+const hasTargetBlank = (uri) => (uri == null ? void 0 : uri.includes(TARGET_BLANK_PREFIX)) === true;
+const getHref = (uri) => hasTargetBlank(uri) ? uri.replace(TARGET_BLANK_PREFIX, "") : uri || "";
+const getTarget = (uri) => hasTargetBlank(uri) ? "_blank" : void 0;
+const wrapInDocument = (content) => ({
+  nodeType: BLOCKS.DOCUMENT,
+  data: {},
+  content
+});
+const createListItems = (content, listType) => content.map((item, index) => ({
+  uid: `contentful-${listType}-item-${index}`,
+  richText: {
+    component: richTextContentfulComponentName,
+    html: wrapInDocument(item.content),
+    paragraphSpacing: spacingNone
+  }
+}));
+const getCellDataValue = (cell, key) => {
+  var _a, _b, _c;
+  if ((_a = cell.data) == null ? void 0 : _a[key]) {
+    return cell.data[key];
+  }
+  const childWithValue = (_b = cell.content) == null ? void 0 : _b.find((child) => {
+    var _a2;
+    return (_a2 = child.data) == null ? void 0 : _a2[key];
+  });
+  return (_c = childWithValue == null ? void 0 : childWithValue.data) == null ? void 0 : _c[key];
+};
+const getCellAlign = (cell) => {
+  const align = getCellDataValue(cell, "align");
+  return align === tableAlignLeft || align === tableAlignRight ? align : void 0;
+};
+const getCellColSpan = (cell) => {
+  const rawColSpan = getCellDataValue(cell, "colSpan");
+  const colSpan = typeof rawColSpan === "number" ? rawColSpan : parseInt(String(rawColSpan || ""), 10);
+  return Number.isFinite(colSpan) && colSpan > 1 ? colSpan : void 0;
+};
+const isTableHeaderCell = (cell) => cell.nodeType === BLOCKS.TABLE_HEADER_CELL;
+const isTableFooterRow = (row, index) => index > 0 && row.content.length > 0 && row.content.every((cell) => isTableHeaderCell(cell));
+const isCellEmpty = (cell) => {
+  if (!cell.content || cell.content.length === 0) {
+    return true;
+  }
+  return cell.content.every((child) => {
+    const block = child;
+    if (block.nodeType !== BLOCKS.PARAGRAPH) {
+      return false;
+    }
+    if (!block.content || block.content.length === 0) {
+      return true;
+    }
+    return block.content.every((textNode) => textNode.nodeType === "text" && textNode.value === "");
+  });
+};
+const getRenderableCells = (cells) => {
+  let coveredCells = 0;
+  return cells.reduce((mappedCells, cell) => {
+    if (coveredCells > 0 && isCellEmpty(cell)) {
+      coveredCells -= 1;
+      return mappedCells;
+    }
+    coveredCells = 0;
+    const colSpan = getCellColSpan(cell);
+    if (colSpan) {
+      coveredCells = colSpan - 1;
+    }
+    mappedCells.push(cell);
+    return mappedCells;
+  }, []);
+};
+const getCellContent = (cell) => ({
+  component: richTextContentfulComponentName,
+  html: wrapInDocument(cell.content),
+  paragraphSpacing: spacingNone
+});
+const mapTableCell = (cell, _cellIndex, scope, isFooter = false) => {
+  const isHeaderCell = !isFooter && isTableHeaderCell(cell);
+  return {
+    richText: getCellContent(cell),
+    align: getCellAlign(cell),
+    colSpan: getCellColSpan(cell),
+    as: isHeaderCell ? "th" : "td",
+    scope: isHeaderCell ? scope : void 0
+  };
+};
+const mapTableCells = (row, useRowScope, isFooter = false) => getRenderableCells(row.content).map((cell, cellIndex) => mapTableCell(cell, cellIndex, useRowScope && cellIndex === 0 ? "row" : void 0, isFooter));
+const getColumnCount = (rows) => rows.reduce((max, row) => Math.max(max, getRenderableCells(row.content).length), 0);
+const hasHeaderRow = (tableRows) => {
+  const firstRow = tableRows[0];
+  return !!firstRow && firstRow.content.every((cell) => isTableHeaderCell(cell));
+};
+const getFooterRow = (tableRows) => {
+  const footerRowIndex = tableRows.reduce((footerIndex, row, index) => isTableFooterRow(row, index) ? index : footerIndex, -1);
+  return footerRowIndex === tableRows.length - 1 ? tableRows[footerRowIndex] : void 0;
+};
+const contentfulTableToTableProps = (tableRows) => {
+  const firstRow = tableRows[0];
+  const footerRow = getFooterRow(tableRows);
+  const bodyRows = tableRows.slice(1, footerRow ? -1 : void 0);
+  const columns = getRenderableCells(firstRow.content).map((cell, index) => ({
+    key: `col-${index}`,
+    label: getCellContent(cell),
+    align: getCellAlign(cell)
+  }));
+  return {
+    columns,
+    rows: bodyRows.map((row, rowIndex) => ({
+      key: `row-${rowIndex}`,
+      cells: mapTableCells(row, true)
+    })),
+    footCells: footerRow ? mapTableCells(footerRow, false, true) : void 0
+  };
+};
+const contentfulHeaderlessTableToTableProps = (tableRows) => {
+  const footerRow = getFooterRow(tableRows);
+  const bodyRows = tableRows.slice(0, footerRow ? -1 : void 0);
+  const columns = Array.from({
+    length: getColumnCount(tableRows)
+  }, (_unused, index) => ({
+    key: `col-${index}`
+  }));
+  return {
+    columns,
+    rows: bodyRows.map((row, rowIndex) => ({
+      key: `row-${rowIndex}`,
+      cells: mapTableCells(row, true)
+    })),
+    footCells: footerRow ? mapTableCells(footerRow, false, true) : void 0
+  };
+};
+const getOptions$1 = (tagProps = {}) => {
+  const options = {
+    renderMark: {
+      [MARKS.BOLD]: (text) => {
+        return /* @__PURE__ */ jsx(Body, { tag: "strong", bottomSpacing: spacingNone, children: text });
+      },
+      [MARKS.ITALIC]: (text) => {
+        return /* @__PURE__ */ jsx(Body, { tag: "span", bottomSpacing: spacingNone, children: text });
+      },
+      [MARKS.UNDERLINE]: (text) => {
+        return /* @__PURE__ */ jsx(Body, { tag: "span", bottomSpacing: spacingNone, children: text });
+      },
+      [MARKS.CODE]: (text) => {
+        return /* @__PURE__ */ jsx(Body, { tag: "span", bottomSpacing: spacingNone, children: text });
+      },
+      [MARKS.SUPERSCRIPT]: (text) => {
+        return /* @__PURE__ */ jsx(Body, { tag: "sup", bottomSpacing: spacingNone, children: text });
+      },
+      [MARKS.SUBSCRIPT]: (text) => {
+        return /* @__PURE__ */ jsx(Body, { tag: "span", bottomSpacing: spacingNone, children: text });
+      },
+      [MARKS.STRIKETHROUGH]: (text) => {
+        return /* @__PURE__ */ jsx(Body, { tag: "span", bottomSpacing: spacingNone, children: text });
+      }
+    },
+    renderNode: {
+      [BLOCKS.PARAGRAPH]: (node, children) => {
+        if (node.data.nestedPatch) {
+          return children;
+        }
+        return /* @__PURE__ */ jsx(Body, { ...tagProps.p, bottomSpacing: spacingNone, children });
+      },
+      [BLOCKS.HEADING_1]: (_block, children) => {
+        return /* @__PURE__ */ jsx(Heading, { size: "xl", bottomSpacing: spacingNone, children });
+      },
+      [BLOCKS.HEADING_2]: (_block, children) => {
+        return /* @__PURE__ */ jsx(Heading, { size: "lg", bottomSpacing: spacingNone, children });
+      },
+      [BLOCKS.HEADING_3]: (_block, children) => {
+        return /* @__PURE__ */ jsx(Heading, { size: "md", bottomSpacing: spacingNone, children });
+      },
+      [BLOCKS.HEADING_4]: (_block, children) => {
+        return /* @__PURE__ */ jsx(Heading, { size: "sm", bottomSpacing: spacingNone, children });
+      },
+      [BLOCKS.HEADING_5]: (_block, children) => {
+        return /* @__PURE__ */ jsx(Heading, { size: "xs", bottomSpacing: spacingNone, children });
+      },
+      [BLOCKS.HEADING_6]: (_block, children) => {
+        return /* @__PURE__ */ jsx(Heading, { tag: "h6", size: "xs", bottomSpacing: spacingNone, children });
+      },
+      [BLOCKS.OL_LIST]: (block, _children) => {
+        return /* @__PURE__ */ jsx(TextList, { tag: "ol", items: createListItems(block.content, "ol"), bottomSpacing: spacingNone });
+      },
+      [BLOCKS.UL_LIST]: (block, _children) => {
+        return /* @__PURE__ */ jsx(TextList, { tag: "ul", items: createListItems(block.content, "ul"), bottomSpacing: spacingNone });
+      },
+      [BLOCKS.HR]: () => {
+        return /* @__PURE__ */ jsx(Divider, { bottomSpacing: spacingNone });
+      },
+      [BLOCKS.TABLE]: (node) => {
+        const tableRows = node.content.filter((row) => row.nodeType === BLOCKS.TABLE_ROW);
+        if (!hasHeaderRow(tableRows)) {
+          const {
+            columns,
+            rows,
+            footCells
+          } = contentfulHeaderlessTableToTableProps(tableRows);
+          return /* @__PURE__ */ jsx(TableWrapperStyled, { children: /* @__PURE__ */ jsxs(TableStyled, { children: [
+            /* @__PURE__ */ jsx(TableBody, { columns, rows }),
+            footCells && /* @__PURE__ */ jsx(TableFoot, { cells: footCells })
+          ] }) });
+        }
+        return /* @__PURE__ */ jsx(TableWrapper, { ...contentfulTableToTableProps(tableRows) });
+      },
+      [INLINES.HYPERLINK]: (node, children) => {
+        if (node.data.footnoteLink) {
+          const footnoteLinkProps = node.data.footnoteLink;
+          return /* @__PURE__ */ jsx(FootnoteLink, { ...footnoteLinkProps });
+        }
+        return /* @__PURE__ */ jsx(InlineLink, { href: getHref(node.data.uri), target: getTarget(node.data.uri), children });
+      }
+    },
+    /**
+     * https://www.contentful.com/blog/rich-text-field-tips-and-tricks/
+     */
+    renderText: (text) => {
+      return text.split("\n").reduce((children, textSegment, index) => {
+        const parts = textSegment.split(/(&nbsp;|&shy;)/).filter(Boolean).map((segment) => {
+          if (segment === "&nbsp;") return " ";
+          if (segment === "&shy;") return "­";
+          return segment;
+        });
+        return [...children, index > 0 && /* @__PURE__ */ jsx("br", {}, index), ...parts].filter(Boolean);
+      }, []);
+    }
+  };
+  return options;
+};
+const RichTextContentfulStyled = styled.div.withConfig({
+  shouldForwardProp,
+  displayName: "RichTextContentfulStyled",
+  componentId: "sc-lhpjox-0"
+})(
+  ({
+    bottomSpacing
+  }) => ({
+    ...getBottomSpacing({
+      bottomSpacing
+    })
+  }),
+  /**
+   * The spacing between content blocks is owned by this container instead of the
+   * individual blocks. An inline root (`span`) must stay in the phrasing content
+   * flow, so it cannot become a flex container.
+   */
+  ({
+    as,
+    paragraphSpacing = spacingMd
+  }) => as === spanTagName ? {} : {
+    display: "flex",
+    flexDirection: "column",
+    gap: getSpacing(paragraphSpacing)
+  },
+  ({
+    layout
+  }) => layout && translateLayoutPropsToCss(layout)
+);
+const richTextContentfulTags = [divTagName, spanTagName];
+const RichTextContentful = ({
+  html,
+  paragraphSpacing,
+  bottomSpacing,
+  layout,
+  tagProps = {},
+  ...props
+}) => {
+  var _a;
+  const rendered = documentToReactComponents(html, getOptions$1(tagProps));
+  return /* @__PURE__ */ jsx(RichTextContentfulStyled, { ...props, as: (_a = tagProps.root) == null ? void 0 : _a.tag, paragraphSpacing, bottomSpacing, layout, children: rendered });
+};
+const TableCell = ({
+  richText,
+  align = tableAlignLeft,
+  colSpan,
+  as = "td",
+  scope,
+  ...rest
+}) => {
+  return /* @__PURE__ */ jsxs(TableCellStyled, { as, align, colSpan, scope, ...rest, children: [
+    richTextContentfulComponentName === richText.component && /* @__PURE__ */ jsx(RichTextContentful, { ...richText, bottomSpacing: "None" }),
+    richTextComponentName === richText.component && /* @__PURE__ */ jsx(RichText, { ...richText, bottomSpacing: "None" })
+  ] });
+};
+const TableBody = ({
+  columns,
+  rows,
+  sideHeader
+}) => /* @__PURE__ */ jsx("tbody", { children: rows.map((row) => /* @__PURE__ */ jsx(TableRowStyled, { children: row.cells.map((cell, i) => {
+  var _a;
+  const align = cell.align || ((_a = columns == null ? void 0 : columns[i]) == null ? void 0 : _a.align) || tableAlignLeft;
+  const cellKey = `${row.key}-${i}`;
+  const as = sideHeader && i === 0 ? "th" : cell.as;
+  const scope = sideHeader && i === 0 ? "row" : cell.scope;
+  return /* @__PURE__ */ createElement(TableCell, { ...cell, key: cellKey, as, scope, align });
+}) }, row.key)) });
+TableBody.displayName = "TableBody";
+const TableFoot = ({
+  cells
+}) => /* @__PURE__ */ jsx("tfoot", { children: /* @__PURE__ */ jsx(TableRowStyled, { children: cells.map((cell, i) => /* @__PURE__ */ jsx(TableCell, { ...cell, as: cell.as || "td" }, "foot-" + i)) }) });
+TableFoot.displayName = "TableFoot";
+const TableHead = ({
+  columns
+}) => /* @__PURE__ */ jsx(TableHeadStyled, { children: /* @__PURE__ */ jsx(TableRowStyled, { children: columns.map((col) => col.label && /* @__PURE__ */ jsx(TableCell, { align: col.align, as: "th", scope: "col", richText: col.label }, col.key)) }) });
+TableHead.displayName = "TableHead";
+const TableWrapper = ({
+  columns,
+  rows,
+  sideHeader,
+  footCells,
+  ...rest
+}) => {
+  useEffect(() => {
+    rows.forEach((row) => {
+      if (row.cells.length !== columns.length) {
+        console.warn(`Table row "${row.key}" has ${row.cells.length} cells, but ${columns.length} columns were provided.`);
+      }
+    });
+  }, [columns, rows]);
+  return /* @__PURE__ */ jsx(TableWrapperStyled, { ...rest, children: /* @__PURE__ */ jsxs(TableStyled, { children: [
+    /* @__PURE__ */ jsx(TableHead, { columns }),
+    /* @__PURE__ */ jsx(TableBody, { columns, rows, sideHeader }),
+    footCells && /* @__PURE__ */ jsx(TableFoot, { cells: footCells })
+  ] }) });
+};
+const mapSizeToTag = {
+  h1: textHeadingXl,
+  h2: textHeadingLg,
+  h3: textHeadingMd,
+  h4: textHeadingSm,
+  h5: textHeadingXs,
+  h6: textHeadingXs
+};
+const footnoteScreenReaderLabel = "Details zur Fußnote";
+const getTableAlign = (align) => {
+  return align === tableAlignLeft || align === tableAlignRight ? align : void 0;
+};
+const findChildElement = (node, name) => node.children.find((child) => child instanceof Element && child.name === name);
+const getTextListItemHtml = (listItemNode) => {
+  const childrenHtml = render(listItemNode.children);
+  if (childrenHtml.trim()) {
+    return childrenHtml;
+  }
+  return render(listItemNode).replace(/^<li[^>]*>/, "").replace(/<\/li>$/, "");
+};
+const createTextListItems = (listNode, listKey, itemProps) => listNode.children.flatMap((child, itemIndex) => {
+  if (!(child instanceof Element) || child.name !== "li") {
+    return [];
+  }
+  return [{
+    ...itemProps,
+    uid: `${listKey}-item-${itemIndex}`,
+    richText: {
+      component: richTextComponentName,
+      html: getTextListItemHtml(child)
+    }
+  }];
+});
+const parseTableCells = (tr) => tr.children.filter((cell) => cell instanceof Element && (cell.name === "td" || cell.name === "th")).map((cell) => {
+  const attribs = cell.attribs || {};
+  return {
+    richText: {
+      component: richTextComponentName,
+      html: render(cell.children)
+    },
+    align: getTableAlign(attribs.align),
+    as: cell.name === "th" ? "th" : "td",
+    colSpan: attribs.colspan ? parseInt(attribs.colspan, 10) : void 0,
+    scope: attribs.scope
+  };
+});
+const parseTableColumns = (thead) => {
+  const tr = thead && findChildElement(thead, "tr");
+  if (!tr) {
+    return [];
+  }
+  return tr.children.filter((child) => child instanceof Element && child.name === "th").map((th, i) => {
+    const attribs = th.attribs || {};
+    return {
+      key: attribs.key || `col${i}`,
+      label: {
+        component: richTextComponentName,
+        html: render(th.children)
+      },
+      align: getTableAlign(attribs.align)
+    };
+  });
+};
+const parseTableRows = (tbody) => {
+  var _a;
+  if (!tbody) {
+    return {
+      rows: [],
+      sideHeader: false
+    };
+  }
+  const sideheaderAttrib = (_a = tbody.attribs) == null ? void 0 : _a.sideheader;
+  const sideHeader = typeof sideheaderAttrib !== "undefined" && (sideheaderAttrib === "" || sideheaderAttrib === "true");
+  const rows = tbody.children.filter((child) => child instanceof Element && child.name === "tr").map((tr, i) => ({
+    key: `row${i}`,
+    cells: parseTableCells(tr)
+  }));
+  return {
+    rows,
+    sideHeader
+  };
+};
+const parseTableFootCells = (tfoot) => {
+  const tr = tfoot && findChildElement(tfoot, "tr");
+  return tr ? parseTableCells(tr) : [];
+};
+const getTableProps = (domNode) => {
+  const thead = findChildElement(domNode, "thead");
+  const tbody = findChildElement(domNode, "tbody");
+  const tfoot = findChildElement(domNode, "tfoot");
+  const {
+    rows,
+    sideHeader
+  } = parseTableRows(tbody);
+  const footCells = parseTableFootCells(tfoot);
+  return {
+    columns: parseTableColumns(thead),
+    rows,
+    sideHeader,
+    footCells: footCells.length ? footCells : void 0
+  };
+};
+const renderHeading = (domNode, key, options, paragraphSpacing, headingProps) => /* @__PURE__ */ jsx(Heading, { ...headingProps, size: mapSizeToTag[domNode.name], bottomSpacing: paragraphSpacing, children: domToReact(domNode.children, options) }, key);
+const renderList = (domNode, key, listProps, itemProps, tag) => /* @__PURE__ */ jsx(TextList, { ...listProps, ...tag ? {
+  tag
+} : {}, items: createTextListItems(domNode, key, itemProps) }, key);
+const renderTable = (domNode, key) => /* @__PURE__ */ jsx(TableWrapper, { ...getTableProps(domNode) }, key);
+const renderStrong = (domNode, key, options, strongProps) => /* @__PURE__ */ jsx(Body, { ...strongProps, tag: strongTagName, children: domToReact(domNode.children, options) }, key);
+const renderSmall = (domNode, key, options, smallProps) => /* @__PURE__ */ jsx(Body, { ...smallProps, size: textBodySm, children: domToReact(domNode.children, options) }, key);
+const renderSup = (domNode, key, options, supProps, uidState) => {
+  const children = domToReact(domNode.children, options);
+  if (Number.isInteger(parseInt(children))) {
+    uidState.current += 1;
+    return /* @__PURE__ */ jsx(FootnoteLink, { uid: `footnote-link-${uidState.current}-${children}`, contentUid: `footnote-content-${children}`, screenReaderLabel: footnoteScreenReaderLabel, children }, key);
+  }
+  return /* @__PURE__ */ jsx(Body, { ...supProps, tag: supTagName, children }, key);
+};
+const renderParagraph = (domNode, key, options, paragraphSpacing, pProps) => {
+  if (domNode.children.some((child) => child instanceof Element && (child.name === "ol" || child.name === "ul"))) {
+    return domToReact(domNode.children, options);
+  }
+  return /* @__PURE__ */ jsx(Body, { ...pProps, bottomSpacing: paragraphSpacing, children: domToReact(domNode.children, options) }, key);
+};
+const renderLink = (domNode, key, options, aProps, uidState) => {
+  const linkLabel = domToReact(domNode.children, options);
+  const isNumber = parseInt(linkLabel, 10);
+  const href = domNode.attribs.href;
+  const isAnchor = href && href.indexOf("#") === 0;
+  if (!isNaN(isNumber) && isAnchor) {
+    return /* @__PURE__ */ jsx(FootnoteLink, { uid: `${uidState.current}`, contentUid: href.replace("#", ""), screenReaderLabel: footnoteScreenReaderLabel, children: linkLabel }, key);
+  }
+  return /* @__PURE__ */ jsx(InlineLink, { ...aProps, href: domNode.attribs.href, target: domNode.attribs.target, children: domToReact(domNode.children, options) }, key);
+};
+const tagHandlers = {
+  li: () => null,
+  ol: (domNode, key, ctx) => renderList(domNode, key, ctx.additionalProps.ol, ctx.additionalProps.li, olTagName),
+  ul: (domNode, key, ctx) => renderList(domNode, key, ctx.additionalProps.ul, ctx.additionalProps.li),
+  table: (domNode, key) => renderTable(domNode, key),
+  strong: (domNode, key, ctx) => renderStrong(domNode, key, ctx.options, ctx.additionalProps.strong),
+  small: (domNode, key, ctx) => renderSmall(domNode, key, ctx.options, ctx.additionalProps.small),
+  sup: (domNode, key, ctx) => renderSup(domNode, key, ctx.options, ctx.additionalProps.sup, ctx.uidState),
+  p: (domNode, key, ctx) => renderParagraph(domNode, key, ctx.options, ctx.paragraphSpacing, ctx.additionalProps.p),
+  a: (domNode, key, ctx) => renderLink(domNode, key, ctx.options, ctx.additionalProps.a, ctx.uidState)
+};
+for (const headingTag of headingHtmlTags) {
+  tagHandlers[headingTag] = (domNode, key, ctx) => renderHeading(domNode, key, ctx.options, ctx.paragraphSpacing, ctx.additionalProps.heading);
+}
+const getOptions = (paragraphSpacing, additionalProps = {}) => {
+  const uidState = {
+    current: 0
+  };
+  const options = {
+    replace(domNode, index) {
+      if (!(domNode instanceof Element)) {
+        return void 0;
+      }
+      const handler = tagHandlers[domNode.name];
+      if (!handler) {
+        return void 0;
+      }
+      return handler(domNode, `rt-${domNode.name}-${index}`, {
+        options,
+        paragraphSpacing,
+        additionalProps,
+        uidState
+      });
+    }
+  };
+  return options;
+};
+const parseHtml = (html, paragraphSpacing, tagProps = {}) => {
+  const parsed = parse(html, getOptions(paragraphSpacing, tagProps));
+  return parsed;
+};
+const RichTextStyled = styled.div.withConfig({
+  shouldForwardProp,
+  displayName: "RichTextStyled",
+  componentId: "sc-1k2leu2-0"
+})(({
+  bottomSpacing
+}) => ({
+  ...getBottomSpacing({
+    bottomSpacing
+  }),
+  ":not(li) > & > *:last-child": {
+    marginBottom: 0
+  }
+}));
+const RichText = ({
+  html,
+  paragraphSpacing,
+  bottomSpacing,
+  tagProps = {},
+  ...props
+}) => {
+  const parsedHtml = parseHtml(html, paragraphSpacing, tagProps);
+  return /* @__PURE__ */ jsx(RichTextStyled, { ...props, bottomSpacing, children: parsedHtml });
+};
+const TextListItemStyled = styled.li.withConfig({
+  shouldForwardProp,
+  displayName: "TextListItemStyled",
+  componentId: "sc-1vq8s8n-0"
+})({
+  display: "list-item"
+}, ({
+  bottomSpacing = spacingNone
+}) => getBottomSpacing({
+  bottomSpacing
+}), ({
+  layout
+}) => layout && translateLayoutPropsToCss(layout));
+const TextListItem = ({
+  richText,
+  ...props
+}) => /* @__PURE__ */ jsxs(TextListItemStyled, { ...props, children: [
+  richTextContentfulComponentName === richText.component && /* @__PURE__ */ jsx(RichTextContentful, { ...richText }),
+  richTextComponentName === richText.component && /* @__PURE__ */ jsx(RichText, { ...richText })
+] });
+const TextListStyled = styled.ul.withConfig({
+  shouldForwardProp,
+  displayName: "TextListStyled",
+  componentId: "sc-9y4ru5-0"
+})({
+  display: "block",
+  marginBlockStart: "0px",
+  marginBlockEnd: "0px",
+  marginInlineStart: "0px",
+  marginInlineEnd: "0px",
+  paddingInlineStart: getSpacing(spacingMd),
+  marginBottom: getSpacing(spacingMd)
+}, ({
+  as
+}) => ({
+  listStyleType: olTagName === as ? "decimal" : "disc"
+}), ({
+  size = textBodyMd
+}) => {
+  const bodySize = getBodySize(size);
+  return {
+    ...bodySize,
+    "& *": bodySize
+  };
+}, ({
+  weight = fontWeightRegular
+}) => {
+  return {
+    fontWeight: getFontWeight(weight)
+  };
+}, ({
+  bottomSpacing = spacingMd
+}) => getBottomSpacing({
+  bottomSpacing
+}), ({
+  layout
+}) => layout && translateLayoutPropsToCss(layout));
+const renderItems = ({
+  items,
+  itemSpacing
+}) => {
+  return items.map(({
+    ...props
+  }, index) => /* @__PURE__ */ createElement(TextListItem, { ...props, key: props.uid, bottomSpacing: index === items.length - 1 && itemSpacing ? spacingNone : itemSpacing }));
+};
+const TextList = ({
+  items,
+  layout,
+  itemSpacing,
+  tag = ulTagName,
+  ...props
+}) => /* @__PURE__ */ jsx(TextListStyled, { ...props, bottomSpacing: props.bottomSpacing, layout, as: tag, children: renderItems({
+  items,
+  itemSpacing
+}) });
+export {
+  RichText as R,
+  TableWrapper as T,
+  RichTextContentful as a,
+  TableBody as b,
+  TableCell as c,
+  TableFoot as d,
+  TableHead as e,
+  TextList as f,
+  TextListItem as g,
+  tableAlignRight as h,
+  tableAligns as i,
+  RichTextContentfulStyled as j,
+  richTextContentfulTags as r,
+  tableAlignLeft as t
+};