@vodafone_de/publish-test 0.0.1 → 53.0.0

package/dist/props-B5OwQmNC.js

@@ -0,0 +1,584 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { u as ulTagName, r as olTagName } from "./tags-BeNegJAK.js";
+const richTextComponentName = "RichText";
+var BLOCKS = /* @__PURE__ */ (function(BLOCKS2) {
+  BLOCKS2["DOCUMENT"] = "document";
+  BLOCKS2["PARAGRAPH"] = "paragraph";
+  BLOCKS2["HEADING_1"] = "heading-1";
+  BLOCKS2["HEADING_2"] = "heading-2";
+  BLOCKS2["HEADING_3"] = "heading-3";
+  BLOCKS2["HEADING_4"] = "heading-4";
+  BLOCKS2["HEADING_5"] = "heading-5";
+  BLOCKS2["HEADING_6"] = "heading-6";
+  BLOCKS2["OL_LIST"] = "ordered-list";
+  BLOCKS2["UL_LIST"] = "unordered-list";
+  BLOCKS2["LIST_ITEM"] = "list-item";
+  BLOCKS2["HR"] = "hr";
+  BLOCKS2["QUOTE"] = "blockquote";
+  BLOCKS2["EMBEDDED_ENTRY"] = "embedded-entry-block";
+  BLOCKS2["EMBEDDED_ASSET"] = "embedded-asset-block";
+  BLOCKS2["EMBEDDED_RESOURCE"] = "embedded-resource-block";
+  BLOCKS2["TABLE"] = "table";
+  BLOCKS2["TABLE_ROW"] = "table-row";
+  BLOCKS2["TABLE_CELL"] = "table-cell";
+  BLOCKS2["TABLE_HEADER_CELL"] = "table-header-cell";
+  return BLOCKS2;
+})({});
+var INLINES = /* @__PURE__ */ (function(INLINES2) {
+  INLINES2["ASSET_HYPERLINK"] = "asset-hyperlink";
+  INLINES2["EMBEDDED_ENTRY"] = "embedded-entry-inline";
+  INLINES2["EMBEDDED_RESOURCE"] = "embedded-resource-inline";
+  INLINES2["ENTRY_HYPERLINK"] = "entry-hyperlink";
+  INLINES2["HYPERLINK"] = "hyperlink";
+  INLINES2["RESOURCE_HYPERLINK"] = "resource-hyperlink";
+  return INLINES2;
+})({});
+var MARKS = /* @__PURE__ */ (function(MARKS2) {
+  MARKS2["BOLD"] = "bold";
+  MARKS2["ITALIC"] = "italic";
+  MARKS2["UNDERLINE"] = "underline";
+  MARKS2["CODE"] = "code";
+  MARKS2["SUPERSCRIPT"] = "superscript";
+  MARKS2["SUBSCRIPT"] = "subscript";
+  MARKS2["STRIKETHROUGH"] = "strikethrough";
+  return MARKS2;
+})({});
+const TOP_LEVEL_BLOCKS = [
+  BLOCKS.PARAGRAPH,
+  BLOCKS.HEADING_1,
+  BLOCKS.HEADING_2,
+  BLOCKS.HEADING_3,
+  BLOCKS.HEADING_4,
+  BLOCKS.HEADING_5,
+  BLOCKS.HEADING_6,
+  BLOCKS.OL_LIST,
+  BLOCKS.UL_LIST,
+  BLOCKS.HR,
+  BLOCKS.QUOTE,
+  BLOCKS.EMBEDDED_ENTRY,
+  BLOCKS.EMBEDDED_ASSET,
+  BLOCKS.EMBEDDED_RESOURCE,
+  BLOCKS.TABLE
+];
+const LIST_ITEM_BLOCKS = [
+  BLOCKS.PARAGRAPH,
+  BLOCKS.HEADING_1,
+  BLOCKS.HEADING_2,
+  BLOCKS.HEADING_3,
+  BLOCKS.HEADING_4,
+  BLOCKS.HEADING_5,
+  BLOCKS.HEADING_6,
+  BLOCKS.OL_LIST,
+  BLOCKS.UL_LIST,
+  BLOCKS.HR,
+  BLOCKS.QUOTE,
+  BLOCKS.EMBEDDED_ENTRY,
+  BLOCKS.EMBEDDED_ASSET,
+  BLOCKS.EMBEDDED_RESOURCE
+];
+[
+  BLOCKS.TABLE,
+  BLOCKS.TABLE_ROW,
+  BLOCKS.TABLE_CELL,
+  BLOCKS.TABLE_HEADER_CELL
+];
+[
+  BLOCKS.HR,
+  BLOCKS.EMBEDDED_ENTRY,
+  BLOCKS.EMBEDDED_ASSET,
+  BLOCKS.EMBEDDED_RESOURCE
+];
+const CONTAINERS = {
+  [BLOCKS.OL_LIST]: [
+    BLOCKS.LIST_ITEM
+  ],
+  [BLOCKS.UL_LIST]: [
+    BLOCKS.LIST_ITEM
+  ],
+  [BLOCKS.LIST_ITEM]: LIST_ITEM_BLOCKS,
+  [BLOCKS.QUOTE]: [
+    BLOCKS.PARAGRAPH
+  ],
+  [BLOCKS.TABLE]: [
+    BLOCKS.TABLE_ROW
+  ],
+  [BLOCKS.TABLE_ROW]: [
+    BLOCKS.TABLE_CELL,
+    BLOCKS.TABLE_HEADER_CELL
+  ],
+  [BLOCKS.TABLE_CELL]: [
+    BLOCKS.PARAGRAPH,
+    BLOCKS.UL_LIST,
+    BLOCKS.OL_LIST
+  ],
+  [BLOCKS.TABLE_HEADER_CELL]: [
+    BLOCKS.PARAGRAPH
+  ]
+};
+const HEADINGS = [
+  BLOCKS.HEADING_1,
+  BLOCKS.HEADING_2,
+  BLOCKS.HEADING_3,
+  BLOCKS.HEADING_4,
+  BLOCKS.HEADING_5,
+  BLOCKS.HEADING_6
+];
+[
+  BLOCKS.PARAGRAPH,
+  ...HEADINGS
+];
+[
+  BLOCKS.DOCUMENT,
+  BLOCKS.PARAGRAPH,
+  BLOCKS.HEADING_1,
+  BLOCKS.HEADING_2,
+  BLOCKS.HEADING_3,
+  BLOCKS.HEADING_4,
+  BLOCKS.HEADING_5,
+  BLOCKS.HEADING_6,
+  BLOCKS.OL_LIST,
+  BLOCKS.UL_LIST,
+  BLOCKS.LIST_ITEM,
+  BLOCKS.HR,
+  BLOCKS.QUOTE,
+  BLOCKS.EMBEDDED_ENTRY,
+  BLOCKS.EMBEDDED_ASSET,
+  INLINES.HYPERLINK,
+  INLINES.ENTRY_HYPERLINK,
+  INLINES.ASSET_HYPERLINK,
+  INLINES.EMBEDDED_ENTRY,
+  "text"
+];
+[
+  MARKS.BOLD,
+  MARKS.CODE,
+  MARKS.ITALIC,
+  MARKS.UNDERLINE
+];
+({
+  nodeType: BLOCKS.DOCUMENT,
+  content: [
+    {
+      nodeType: BLOCKS.PARAGRAPH,
+      data: {},
+      content: [
+        {
+          nodeType: "text",
+          value: "",
+          marks: [],
+          data: {}
+        }
+      ]
+    }
+  ]
+});
+const typeMismatchError = ({ path, property, typeName, value }) => {
+  return {
+    details: `The type of "${property}" is incorrect, expected type: ${typeName}`,
+    name: "type",
+    path: path.toArray(),
+    type: typeName,
+    value
+  };
+};
+const minSizeError = ({ min, value, path }) => {
+  return {
+    name: "size",
+    min,
+    path: path.toArray(),
+    details: `Size must be at least ${min}`,
+    value
+  };
+};
+const maxSizeError = ({ max, value, path }) => {
+  return {
+    name: "size",
+    max,
+    path: path.toArray(),
+    details: `Size must be at most ${max}`,
+    value
+  };
+};
+const enumError = ({ expected, value, path }) => {
+  return {
+    details: `Value must be one of expected values`,
+    name: "in",
+    expected: [
+      ...expected
+    ].sort(),
+    path: path.toArray(),
+    value
+  };
+};
+const unknownPropertyError = ({ property, path }) => {
+  return {
+    details: `The property "${property}" is not expected`,
+    name: "unexpected",
+    path: path.toArray()
+  };
+};
+const requiredPropertyError = ({ property, path }) => {
+  return {
+    details: `The property "${property}" is required here`,
+    name: "required",
+    path: path.toArray()
+  };
+};
+class ObjectAssertion {
+  constructor(obj, path) {
+    __publicField(this, "obj");
+    __publicField(this, "path");
+    __publicField(this, "_errors", []);
+    __publicField(this, "catch", (...errors) => {
+      this._errors.push(...errors);
+    });
+    __publicField(this, "exists", (key) => {
+      if (key in this.obj) {
+        return true;
+      }
+      this.catch(requiredPropertyError({
+        property: key,
+        path: this.path.of(key)
+      }));
+      return false;
+    });
+    __publicField(this, "object", (key) => {
+      const value = key ? this.obj[key] : this.obj;
+      if (key) {
+        if (!this.exists(key)) {
+          return false;
+        }
+      }
+      if (typeof value === "object" && !Array.isArray(value) && value !== null) {
+        return true;
+      }
+      const path = key ? this.path.of(key) : this.path;
+      const property = key ?? this.path.last() ?? "value";
+      this.catch(typeMismatchError({
+        typeName: "Object",
+        property,
+        path,
+        value
+      }));
+      return false;
+    });
+    __publicField(this, "string", (key) => {
+      const value = this.obj[key];
+      if (key && !this.exists(key)) {
+        return false;
+      }
+      if (typeof value === "string") {
+        return true;
+      }
+      this.catch(typeMismatchError({
+        typeName: "String",
+        property: key,
+        path: this.path.of(key),
+        value
+      }));
+      return false;
+    });
+    __publicField(this, "number", (key, optional) => {
+      const value = this.obj[key];
+      if (optional && !(key in this.obj)) {
+        return true;
+      }
+      if (!this.exists(key)) {
+        return false;
+      }
+      if (typeof value === "number" && !Number.isNaN(value)) {
+        return true;
+      }
+      this.catch(typeMismatchError({
+        typeName: "Number",
+        property: key,
+        path: this.path.of(key),
+        value
+      }));
+      return false;
+    });
+    __publicField(this, "array", (key) => {
+      const value = this.obj[key];
+      if (key && !this.exists(key)) {
+        return false;
+      }
+      if (Array.isArray(value)) {
+        return true;
+      }
+      this.catch(typeMismatchError({
+        typeName: "Array",
+        property: key,
+        path: this.path.of(key),
+        value
+      }));
+      return false;
+    });
+    __publicField(this, "enum", (key, expected) => {
+      const value = this.obj[key];
+      if (typeof value === "string" && expected.includes(value)) {
+        return true;
+      }
+      this.catch(enumError({
+        expected,
+        value,
+        path: this.path.of(key)
+      }));
+      return false;
+    });
+    __publicField(this, "empty", (key) => {
+      if (!this.array(key)) {
+        return false;
+      }
+      const value = this.obj[key];
+      if (value.length === 0) {
+        return true;
+      }
+      this.catch(maxSizeError({
+        max: 0,
+        value,
+        path: this.path.of(key)
+      }));
+      return false;
+    });
+    __publicField(this, "minLength", (key, min) => {
+      if (!this.array(key)) {
+        return false;
+      }
+      const value = this.obj[key];
+      if (value.length >= min) {
+        return true;
+      }
+      this.catch(minSizeError({
+        min,
+        value,
+        path: this.path.of(key)
+      }));
+      return false;
+    });
+    __publicField(this, "noAdditionalProperties", (properties) => {
+      const unknowns = Object.keys(this.obj).sort().filter((key) => !properties.includes(key));
+      unknowns.forEach((property) => this.catch(unknownPropertyError({
+        property,
+        path: this.path.of(property)
+      })));
+      return unknowns.length === 0;
+    });
+    __publicField(this, "each", (key, assert2) => {
+      if (!this.array(key)) {
+        return;
+      }
+      const value = this.obj[key];
+      let foundErrors = false;
+      value.forEach((item, index) => {
+        if (foundErrors) {
+          return;
+        }
+        const errors = assert2(item, this.path.of(key).of(index));
+        if (errors.length > 0) {
+          foundErrors = true;
+        }
+        this.catch(...errors);
+      });
+    });
+    this.obj = obj;
+    this.path = path;
+  }
+  get errors() {
+    const serializeError = (error) => JSON.stringify({
+      details: error.details,
+      path: error.path
+    });
+    return this._errors.filter((error, index) => this._errors.findIndex((step) => serializeError(error) === serializeError(step)) === index);
+  }
+}
+const VOID_CONTENT = [];
+class NodeAssertion {
+  constructor(contentRule, validateData) {
+    __publicField(this, "contentRule");
+    __publicField(this, "validateData");
+    this.contentRule = contentRule;
+    this.validateData = validateData;
+  }
+  assert(node, path) {
+    var _a;
+    const $ = new ObjectAssertion(node, path);
+    if (!$.object()) {
+      return $.errors;
+    }
+    $.noAdditionalProperties([
+      "nodeType",
+      "data",
+      "content"
+    ]);
+    const { nodeTypes, min = 0 } = Array.isArray(this.contentRule) ? {
+      nodeTypes: this.contentRule
+    } : this.contentRule(node, path);
+    if (nodeTypes.length === 0 && min > 0) {
+      throw new Error(`Invalid content rule. Cannot have enforce a 'min' of ${min} with no nodeTypes`);
+    }
+    $.minLength("content", min);
+    if (nodeTypes.length === 0) {
+      $.empty("content");
+    } else {
+      $.each("content", (item, path2) => {
+        const item$ = new ObjectAssertion(item, path2);
+        if (!item$.object()) {
+          return item$.errors;
+        }
+        item$.enum("nodeType", nodeTypes);
+        return item$.errors;
+      });
+    }
+    if ($.object("data")) {
+      const dataErrors = ((_a = this.validateData) == null ? void 0 : _a.call(this, node.data, path.of("data"))) ?? [];
+      $.catch(...dataErrors);
+    }
+    return $.errors;
+  }
+}
+class EntityLinkAssertion extends NodeAssertion {
+  constructor(linkType, contentNodeTypes) {
+    super(contentNodeTypes, (data, path) => this.assertLink(data, path));
+    __publicField(this, "linkType");
+    __publicField(this, "type");
+    __publicField(this, "assertLink", (data, path) => {
+      const $ = new ObjectAssertion(data, path);
+      if ($.object("target")) {
+        const sys$ = new ObjectAssertion(data.target.sys, path.of("target").of("sys"));
+        if (sys$.object()) {
+          sys$.enum("type", [
+            this.type
+          ]);
+          sys$.enum("linkType", [
+            this.linkType
+          ]);
+          if (this.type === "Link") {
+            sys$.string("id");
+            sys$.noAdditionalProperties([
+              "type",
+              "linkType",
+              "id"
+            ]);
+          } else if (this.type === "ResourceLink") {
+            sys$.string("urn");
+            sys$.noAdditionalProperties([
+              "type",
+              "linkType",
+              "urn"
+            ]);
+          }
+        }
+        $.catch(...sys$.errors);
+      }
+      $.noAdditionalProperties([
+        "target"
+      ]);
+      return $.errors;
+    });
+    this.linkType = linkType;
+    this.type = this.linkType.startsWith("Contentful:") ? "ResourceLink" : "Link";
+  }
+}
+class HyperLinkAssertion extends NodeAssertion {
+  constructor() {
+    super([
+      "text"
+    ], (data, path) => this.assertLink(data, path));
+    __publicField(this, "assertLink", (data, path) => {
+      const $ = new ObjectAssertion(data, path);
+      $.string("uri");
+      $.noAdditionalProperties([
+        "uri"
+      ]);
+      return $.errors;
+    });
+  }
+}
+const assert = (contentRule, validateData) => {
+  return new NodeAssertion(contentRule, validateData);
+};
+const assertLink = (linkType, contentRule) => {
+  return new EntityLinkAssertion(linkType, contentRule);
+};
+const assertInlineOrText = assert([
+  ...Object.values(INLINES),
+  "text"
+].sort());
+const assertList = assert([
+  BLOCKS.LIST_ITEM
+]);
+const assertVoidEntryLink = assertLink("Entry", VOID_CONTENT);
+const assertTableCell = assert(() => ({
+  nodeTypes: [
+    BLOCKS.PARAGRAPH
+  ],
+  min: 1
+}), (data, path) => {
+  const $ = new ObjectAssertion(data, path);
+  $.noAdditionalProperties([
+    "colspan",
+    "rowspan"
+  ]);
+  $.number("colspan", true);
+  $.number("rowspan", true);
+  return $.errors;
+});
+({
+  [BLOCKS.DOCUMENT]: assert(TOP_LEVEL_BLOCKS),
+  [BLOCKS.PARAGRAPH]: assertInlineOrText,
+  [BLOCKS.HEADING_1]: assertInlineOrText,
+  [BLOCKS.HEADING_2]: assertInlineOrText,
+  [BLOCKS.HEADING_3]: assertInlineOrText,
+  [BLOCKS.HEADING_4]: assertInlineOrText,
+  [BLOCKS.HEADING_5]: assertInlineOrText,
+  [BLOCKS.HEADING_6]: assertInlineOrText,
+  [BLOCKS.QUOTE]: assert(CONTAINERS[BLOCKS.QUOTE]),
+  [BLOCKS.EMBEDDED_ENTRY]: assertVoidEntryLink,
+  [BLOCKS.EMBEDDED_ASSET]: assertLink("Asset", VOID_CONTENT),
+  [BLOCKS.EMBEDDED_RESOURCE]: assertLink("Contentful:Entry", VOID_CONTENT),
+  [BLOCKS.HR]: assert(VOID_CONTENT),
+  [BLOCKS.OL_LIST]: assertList,
+  [BLOCKS.UL_LIST]: assertList,
+  [BLOCKS.LIST_ITEM]: assert([
+    ...LIST_ITEM_BLOCKS
+  ].sort()),
+  [BLOCKS.TABLE]: assert(() => ({
+    nodeTypes: [
+      BLOCKS.TABLE_ROW
+    ],
+    min: 1
+  })),
+  [BLOCKS.TABLE_ROW]: assert(() => ({
+    nodeTypes: [
+      BLOCKS.TABLE_CELL,
+      BLOCKS.TABLE_HEADER_CELL
+    ],
+    min: 1
+  })),
+  [BLOCKS.TABLE_CELL]: assertTableCell,
+  [BLOCKS.TABLE_HEADER_CELL]: assertTableCell,
+  [INLINES.HYPERLINK]: new HyperLinkAssertion(),
+  [INLINES.EMBEDDED_ENTRY]: assertVoidEntryLink,
+  [INLINES.EMBEDDED_RESOURCE]: assertLink("Contentful:Entry", VOID_CONTENT),
+  [INLINES.ENTRY_HYPERLINK]: assertLink("Entry", [
+    "text"
+  ]),
+  [INLINES.ASSET_HYPERLINK]: assertLink("Asset", [
+    "text"
+  ]),
+  [INLINES.RESOURCE_HYPERLINK]: assertLink("Contentful:Entry", [
+    "text"
+  ])
+});
+const richTextContentfulComponentName = "RichTextContentful";
+const textListTags = [ulTagName, olTagName];
+export {
+  BLOCKS as B,
+  INLINES as I,
+  MARKS as M,
+  richTextComponentName as a,
+  richTextContentfulComponentName as r,
+  textListTags as t
+};

package/dist/props-B9bM_KV-.js

@@ -0,0 +1,14 @@
+const imageComponentName = "Image";
+const youTubeVideoComponentName = "YouTubeVideo";
+const mediaTextPositionTop = "top";
+const mediaTextPositionLeft = "left";
+const mediaTextPositionRight = "right";
+const mediaTextPositions = [mediaTextPositionTop, mediaTextPositionLeft, mediaTextPositionRight];
+export {
+  mediaTextPositionRight as a,
+  mediaTextPositionTop as b,
+  mediaTextPositions as c,
+  imageComponentName as i,
+  mediaTextPositionLeft as m,
+  youTubeVideoComponentName as y
+};

package/dist/props-BBT_7iiy.js

@@ -0,0 +1,13 @@
+import { a as iconSizeXl, b as iconSize2xl, c as iconSize3xl, d as iconSize4xl, e as iconSize5xl, f as iconSize2xs, g as iconSizeXs, i as iconSizeSm, h as iconSizeMd, j as iconSizeLg } from "./IconSize-Da9zhR76.js";
+const iconSizes = [iconSize2xs, iconSizeXs, iconSizeSm, iconSizeMd, iconSizeLg, iconSizeXl, iconSize2xl, iconSize3xl, iconSize4xl, iconSize5xl];
+const IconWithAccent = [iconSizeXl, iconSize2xl, iconSize3xl, iconSize4xl, iconSize5xl];
+const inlineIconModeFill = "fill";
+const inlineIconModeStroke = "stroke";
+const inlineIconModes = [inlineIconModeFill, inlineIconModeStroke];
+export {
+  IconWithAccent as I,
+  inlineIconModeFill as a,
+  inlineIconModeStroke as b,
+  inlineIconModes as c,
+  iconSizes as i
+};

package/dist/props-BCMLpYc6.js

@@ -0,0 +1,24 @@
+import { d as divTagName, c as spanTagName } from "./tags-BeNegJAK.js";
+import { i as iconSizeSm, j as iconSizeLg, c as iconSize3xl } from "./IconSize-Da9zhR76.js";
+const inlineLinkComponentName = "InlineLink";
+const linkAsButtonComponentName = "LinkAsButton";
+const iconSnippetIconSizes = [iconSizeSm, iconSizeLg, iconSize3xl];
+const iconSnippetOrientationHorizontal = "horizontal";
+const iconSnippetOrientationVertical = "vertical";
+const iconSnippetOrientations = [iconSnippetOrientationHorizontal, iconSnippetOrientationVertical];
+const iconSnippetAlignTop = "top";
+const iconSnippetAlignCenter = "center";
+const iconSnippetAligns = [iconSnippetAlignTop, iconSnippetAlignCenter];
+const iconSnippetTags = [divTagName, spanTagName];
+export {
+  iconSnippetAlignTop as a,
+  iconSnippetAligns as b,
+  iconSnippetIconSizes as c,
+  iconSnippetOrientationHorizontal as d,
+  iconSnippetOrientationVertical as e,
+  iconSnippetOrientations as f,
+  iconSnippetTags as g,
+  inlineLinkComponentName as h,
+  iconSnippetAlignCenter as i,
+  linkAsButtonComponentName as l
+};

package/dist/props-BT2CkRl1.js

@@ -0,0 +1,14 @@
+const imageHeaderVariantFull = "full";
+const imageHeaderVariantSplit = "split";
+const imageHeaderVariants = [imageHeaderVariantFull, imageHeaderVariantSplit];
+const imageHeaderPositionRight = "right";
+const imageHeaderPositionLeft = "left";
+const imageHeaderPositions = [imageHeaderPositionLeft, imageHeaderPositionRight];
+export {
+  imageHeaderPositionRight as a,
+  imageHeaderPositions as b,
+  imageHeaderVariantFull as c,
+  imageHeaderVariantSplit as d,
+  imageHeaderVariants as e,
+  imageHeaderPositionLeft as i
+};

package/dist/props-BYequ6c_.js

@@ -0,0 +1,6 @@
+const overlayAppearancePrimary = "primary";
+const overlayAppearanceSecondary = "secondary";
+export {
+  overlayAppearanceSecondary as a,
+  overlayAppearancePrimary as o
+};

package/dist/props-B_ZIEzzu.js

@@ -0,0 +1,8 @@
+const iconButtonShapeSquare = "square";
+const iconButtonShapeCircle = "circle";
+const iconButtonShapes = [iconButtonShapeSquare, iconButtonShapeCircle];
+export {
+  iconButtonShapeSquare as a,
+  iconButtonShapes as b,
+  iconButtonShapeCircle as i
+};

package/dist/props-BgLhK53x.js

@@ -0,0 +1,5 @@
+import { e as iconSize5xl, k as iconSize6xl, l as iconSize7xl, m as iconSize8xl, n as iconSize9xl } from "./IconSize-Da9zhR76.js";
+const hifiIconSizes = [iconSize5xl, iconSize6xl, iconSize7xl, iconSize8xl, iconSize9xl];
+export {
+  hifiIconSizes as h
+};

package/dist/props-BhXFN7yR.js

@@ -0,0 +1,28 @@
+const flexOrientationHorizontal = "horizontal";
+const flexOrientationVertical = "vertical";
+const flexOrientations = [flexOrientationHorizontal, flexOrientationVertical];
+const flexJustifyStart = "start";
+const flexJustifyEnd = "end";
+const flexJustifyCenter = "center";
+const flexJustifyBetween = "between";
+const flexJustifyBehaviors = [flexJustifyStart, flexJustifyEnd, flexJustifyCenter, flexJustifyBetween];
+const flexAlignStart = "start";
+const flexAlignEnd = "end";
+const flexAlignCenter = "center";
+const flexAlignBehaviors = [flexAlignStart, flexAlignEnd, flexAlignCenter];
+const flexTags = ["div", "ul"];
+export {
+  flexAlignCenter as a,
+  flexAlignEnd as b,
+  flexAlignStart as c,
+  flexJustifyBehaviors as d,
+  flexJustifyBetween as e,
+  flexAlignBehaviors as f,
+  flexJustifyCenter as g,
+  flexJustifyEnd as h,
+  flexJustifyStart as i,
+  flexOrientationHorizontal as j,
+  flexOrientationVertical as k,
+  flexOrientations as l,
+  flexTags as m
+};