@nuskin/nextgen-header 1.0.0-library-setup.1 → 1.0.0

package/package-dist/index.js

@@ -1,84 +1,768 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+/******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	// The require scope
+/******/ 	var __webpack_require__ = {};
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/compat get default export */
+/******/ 	(() => {
+/******/ 		// getDefaultExport function for compatibility with non-harmony modules
+/******/ 		__webpack_require__.n = (module) => {
+/******/ 			var getter = module && module.__esModule ?
+/******/ 				() => (module['default']) :
+/******/ 				() => (module);
+/******/ 			__webpack_require__.d(getter, { a: getter });
+/******/ 			return getter;
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  Header: () => (/* reexport */ src_Main)
+});
+
+;// external "react"
+const external_react_namespaceObject = require("react");
+;// external "prop-types"
+const external_prop_types_namespaceObject = require("prop-types");
+var external_prop_types_default = /*#__PURE__*/__webpack_require__.n(external_prop_types_namespaceObject);
+;// external "react/jsx-runtime"
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+;// ./src/components/HeaderPlaceholder.jsx
+
+
+
+/**
+ * Stub shell for the future header. Replace with real navigation/branding when
+ * Contentstack content types and UX are defined.
+ *
+ * Locale is supplied by the parent (e.g. Main); `getLocale()` can be used upstream
+ * to derive values from the URL when needed.
+ */
+
+function HeaderPlaceholder(_ref) {
+  var country = _ref.country,
+    language = _ref.language,
+    locale = _ref.locale;
+  return /*#__PURE__*/(0,jsx_runtime_namespaceObject.jsx)("header", {
+    role: "banner",
+    "data-testid": "header-placeholder",
+    "data-country": country,
+    "data-language": language,
+    "data-locale": locale,
+    children: /*#__PURE__*/(0,jsx_runtime_namespaceObject.jsx)("p", {
+      children: "Header MFE \u2014 TODO: implement header content"
+    })
+  });
+}
+HeaderPlaceholder.propTypes = {
+  country: (external_prop_types_default()).string,
+  language: (external_prop_types_default()).string,
+  locale: (external_prop_types_default()).string
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+HeaderPlaceholder.defaultProps = {
+  country: "",
+  language: "",
+  locale: ""
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/library/index.js
-var index_exports = {};
-__export(index_exports, {
-  CONTENTSTACK_API_KEY: () => CONTENTSTACK_API_KEY,
-  CONTENTSTACK_DELIVERY_TOKEN: () => CONTENTSTACK_DELIVERY_TOKEN,
-  CONTENTSTACK_ENVIRONMENT: () => CONTENTSTACK_ENVIRONMENT,
-  CONTENTSTACK_PREVIEW_TOKEN: () => CONTENTSTACK_PREVIEW_TOKEN,
-  HeaderMFEContext: () => HeaderMFEContext,
-  HeaderPlaceholder: () => HeaderPlaceholder,
-  Main: () => Main_default,
-  VB_EmptyBlockParentClass: () => VB_EmptyBlockParentClass,
-  getContent: () => getContent,
-  getLocale: () => getLocale,
-  getStackConfig: () => getStackConfig,
-  initLivePreview: () => initLivePreview,
-  isEditingMode: () => isEditingMode,
-  onEntryChange: () => onEntryChange,
-  referenceFields: () => referenceFields,
-  stack: () => stack
+;// ./node_modules/@babel/runtime/helpers/esm/extends.js
+function _extends() {
+  return _extends = Object.assign ? Object.assign.bind() : function (n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends.apply(null, arguments);
+}
+
+;// external "@emotion/react"
+const react_namespaceObject = require("@emotion/react");
+;// ./node_modules/@emotion/hash/dist/emotion-hash.esm.js
+/* eslint-disable */
+// Inspired by https://github.com/garycourt/murmurhash-js
+// Ported from https://github.com/aappleby/smhasher/blob/61a0530f28277f2e850bfc39600ce61d02b518de/src/MurmurHash2.cpp#L37-L86
+function murmur2(str) {
+  // 'm' and 'r' are mixing constants generated offline.
+  // They're not really 'magic', they just happen to work well.
+  // const m = 0x5bd1e995;
+  // const r = 24;
+  // Initialize the hash
+  var h = 0; // Mix 4 bytes at a time into the hash
+
+  var k,
+      i = 0,
+      len = str.length;
+
+  for (; len >= 4; ++i, len -= 4) {
+    k = str.charCodeAt(i) & 0xff | (str.charCodeAt(++i) & 0xff) << 8 | (str.charCodeAt(++i) & 0xff) << 16 | (str.charCodeAt(++i) & 0xff) << 24;
+    k =
+    /* Math.imul(k, m): */
+    (k & 0xffff) * 0x5bd1e995 + ((k >>> 16) * 0xe995 << 16);
+    k ^=
+    /* k >>> r: */
+    k >>> 24;
+    h =
+    /* Math.imul(k, m): */
+    (k & 0xffff) * 0x5bd1e995 + ((k >>> 16) * 0xe995 << 16) ^
+    /* Math.imul(h, m): */
+    (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);
+  } // Handle the last few bytes of the input array
+
+
+  switch (len) {
+    case 3:
+      h ^= (str.charCodeAt(i + 2) & 0xff) << 16;
+
+    case 2:
+      h ^= (str.charCodeAt(i + 1) & 0xff) << 8;
+
+    case 1:
+      h ^= str.charCodeAt(i) & 0xff;
+      h =
+      /* Math.imul(h, m): */
+      (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);
+  } // Do a few final mixes of the hash to ensure the last few
+  // bytes are well-incorporated.
+
+
+  h ^= h >>> 13;
+  h =
+  /* Math.imul(h, m): */
+  (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);
+  return ((h ^ h >>> 15) >>> 0).toString(36);
+}
+
+
+
+;// ./node_modules/@emotion/unitless/dist/emotion-unitless.esm.js
+var unitlessKeys = {
+  animationIterationCount: 1,
+  aspectRatio: 1,
+  borderImageOutset: 1,
+  borderImageSlice: 1,
+  borderImageWidth: 1,
+  boxFlex: 1,
+  boxFlexGroup: 1,
+  boxOrdinalGroup: 1,
+  columnCount: 1,
+  columns: 1,
+  flex: 1,
+  flexGrow: 1,
+  flexPositive: 1,
+  flexShrink: 1,
+  flexNegative: 1,
+  flexOrder: 1,
+  gridRow: 1,
+  gridRowEnd: 1,
+  gridRowSpan: 1,
+  gridRowStart: 1,
+  gridColumn: 1,
+  gridColumnEnd: 1,
+  gridColumnSpan: 1,
+  gridColumnStart: 1,
+  msGridRow: 1,
+  msGridRowSpan: 1,
+  msGridColumn: 1,
+  msGridColumnSpan: 1,
+  fontWeight: 1,
+  lineHeight: 1,
+  opacity: 1,
+  order: 1,
+  orphans: 1,
+  scale: 1,
+  tabSize: 1,
+  widows: 1,
+  zIndex: 1,
+  zoom: 1,
+  WebkitLineClamp: 1,
+  // SVG-related properties
+  fillOpacity: 1,
+  floodOpacity: 1,
+  stopOpacity: 1,
+  strokeDasharray: 1,
+  strokeDashoffset: 1,
+  strokeMiterlimit: 1,
+  strokeOpacity: 1,
+  strokeWidth: 1
+};
+
+
+
+;// ./node_modules/@emotion/memoize/dist/emotion-memoize.esm.js
+function memoize(fn) {
+  var cache = Object.create(null);
+  return function (arg) {
+    if (cache[arg] === undefined) cache[arg] = fn(arg);
+    return cache[arg];
+  };
+}
+
+
+
+;// ./node_modules/@emotion/serialize/dist/emotion-serialize.esm.js
+
+
+
+
+var isDevelopment = false;
+
+var hyphenateRegex = /[A-Z]|^ms/g;
+var animationRegex = /_EMO_([^_]+?)_([^]*?)_EMO_/g;
+
+var isCustomProperty = function isCustomProperty(property) {
+  return property.charCodeAt(1) === 45;
+};
+
+var isProcessableValue = function isProcessableValue(value) {
+  return value != null && typeof value !== 'boolean';
+};
+
+var processStyleName = /* #__PURE__ */memoize(function (styleName) {
+  return isCustomProperty(styleName) ? styleName : styleName.replace(hyphenateRegex, '-$&').toLowerCase();
 });
-module.exports = __toCommonJS(index_exports);
 
-// src/components/HeaderPlaceholder.jsx
-var import_react = __toESM(require("react"));
-function HeaderPlaceholder() {
-  return /* @__PURE__ */ import_react.default.createElement("header", { role: "banner", "data-testid": "header-placeholder" }, /* @__PURE__ */ import_react.default.createElement("p", null, "Header MFE \u2014 TODO: implement header content"));
+var processStyleValue = function processStyleValue(key, value) {
+  switch (key) {
+    case 'animation':
+    case 'animationName':
+      {
+        if (typeof value === 'string') {
+          return value.replace(animationRegex, function (match, p1, p2) {
+            cursor = {
+              name: p1,
+              styles: p2,
+              next: cursor
+            };
+            return p1;
+          });
+        }
+      }
+  }
+
+  if (unitlessKeys[key] !== 1 && !isCustomProperty(key) && typeof value === 'number' && value !== 0) {
+    return value + 'px';
+  }
+
+  return value;
+};
+
+var noComponentSelectorMessage = 'Component selectors can only be used in conjunction with ' + '@emotion/babel-plugin, the swc Emotion plugin, or another Emotion-aware ' + 'compiler transform.';
+
+function handleInterpolation(mergedProps, registered, interpolation) {
+  if (interpolation == null) {
+    return '';
+  }
+
+  var componentSelector = interpolation;
+
+  if (componentSelector.__emotion_styles !== undefined) {
+
+    return componentSelector;
+  }
+
+  switch (typeof interpolation) {
+    case 'boolean':
+      {
+        return '';
+      }
+
+    case 'object':
+      {
+        var keyframes = interpolation;
+
+        if (keyframes.anim === 1) {
+          cursor = {
+            name: keyframes.name,
+            styles: keyframes.styles,
+            next: cursor
+          };
+          return keyframes.name;
+        }
+
+        var serializedStyles = interpolation;
+
+        if (serializedStyles.styles !== undefined) {
+          var next = serializedStyles.next;
+
+          if (next !== undefined) {
+            // not the most efficient thing ever but this is a pretty rare case
+            // and there will be very few iterations of this generally
+            while (next !== undefined) {
+              cursor = {
+                name: next.name,
+                styles: next.styles,
+                next: cursor
+              };
+              next = next.next;
+            }
+          }
+
+          var styles = serializedStyles.styles + ";";
+          return styles;
+        }
+
+        return createStringFromObject(mergedProps, registered, interpolation);
+      }
+
+    case 'function':
+      {
+        if (mergedProps !== undefined) {
+          var previousCursor = cursor;
+          var result = interpolation(mergedProps);
+          cursor = previousCursor;
+          return handleInterpolation(mergedProps, registered, result);
+        }
+
+        break;
+      }
+  } // finalize string values (regular strings and functions interpolated into css calls)
+
+
+  var asString = interpolation;
+
+  if (registered == null) {
+    return asString;
+  }
+
+  var cached = registered[asString];
+  return cached !== undefined ? cached : asString;
+}
+
+function createStringFromObject(mergedProps, registered, obj) {
+  var string = '';
+
+  if (Array.isArray(obj)) {
+    for (var i = 0; i < obj.length; i++) {
+      string += handleInterpolation(mergedProps, registered, obj[i]) + ";";
+    }
+  } else {
+    for (var key in obj) {
+      var value = obj[key];
+
+      if (typeof value !== 'object') {
+        var asString = value;
+
+        if (registered != null && registered[asString] !== undefined) {
+          string += key + "{" + registered[asString] + "}";
+        } else if (isProcessableValue(asString)) {
+          string += processStyleName(key) + ":" + processStyleValue(key, asString) + ";";
+        }
+      } else {
+        if (key === 'NO_COMPONENT_SELECTOR' && isDevelopment) {
+          throw new Error(noComponentSelectorMessage);
+        }
+
+        if (Array.isArray(value) && typeof value[0] === 'string' && (registered == null || registered[value[0]] === undefined)) {
+          for (var _i = 0; _i < value.length; _i++) {
+            if (isProcessableValue(value[_i])) {
+              string += processStyleName(key) + ":" + processStyleValue(key, value[_i]) + ";";
+            }
+          }
+        } else {
+          var interpolated = handleInterpolation(mergedProps, registered, value);
+
+          switch (key) {
+            case 'animation':
+            case 'animationName':
+              {
+                string += processStyleName(key) + ":" + interpolated + ";";
+                break;
+              }
+
+            default:
+              {
+
+                string += key + "{" + interpolated + "}";
+              }
+          }
+        }
+      }
+    }
+  }
+
+  return string;
+}
+
+var labelPattern = /label:\s*([^\s;{]+)\s*(;|$)/g; // this is the cursor for keyframes
+// keyframes are stored on the SerializedStyles object as a linked list
+
+var cursor;
+function serializeStyles(args, registered, mergedProps) {
+  if (args.length === 1 && typeof args[0] === 'object' && args[0] !== null && args[0].styles !== undefined) {
+    return args[0];
+  }
+
+  var stringMode = true;
+  var styles = '';
+  cursor = undefined;
+  var strings = args[0];
+
+  if (strings == null || strings.raw === undefined) {
+    stringMode = false;
+    styles += handleInterpolation(mergedProps, registered, strings);
+  } else {
+    var asTemplateStringsArr = strings;
+
+    styles += asTemplateStringsArr[0];
+  } // we start at 1 since we've already handled the first arg
+
+
+  for (var i = 1; i < args.length; i++) {
+    styles += handleInterpolation(mergedProps, registered, args[i]);
+
+    if (stringMode) {
+      var templateStringsArr = strings;
+
+      styles += templateStringsArr[i];
+    }
+  } // using a global regex with .exec is stateful so lastIndex has to be reset each time
+
+
+  labelPattern.lastIndex = 0;
+  var identifierName = '';
+  var match; // https://esbench.com/bench/5b809c2cf2949800a0f61fb5
+
+  while ((match = labelPattern.exec(styles)) !== null) {
+    identifierName += '-' + match[1];
+  }
+
+  var name = murmur2(styles) + identifierName;
+
+  return {
+    name: name,
+    styles: styles,
+    next: cursor
+  };
+}
+
+
+
+;// ./node_modules/@emotion/use-insertion-effect-with-fallbacks/dist/emotion-use-insertion-effect-with-fallbacks.browser.esm.js
+
+
+var syncFallback = function syncFallback(create) {
+  return create();
+};
+
+var useInsertionEffect = external_react_namespaceObject['useInsertion' + 'Effect'] ? external_react_namespaceObject['useInsertion' + 'Effect'] : false;
+var useInsertionEffectAlwaysWithSyncFallback = useInsertionEffect || syncFallback;
+var useInsertionEffectWithLayoutFallback = useInsertionEffect || external_react_namespaceObject.useLayoutEffect;
+
+
+
+;// ./node_modules/@emotion/utils/dist/emotion-utils.browser.esm.js
+var isBrowser = true;
+
+function getRegisteredStyles(registered, registeredStyles, classNames) {
+  var rawClassName = '';
+  classNames.split(' ').forEach(function (className) {
+    if (registered[className] !== undefined) {
+      registeredStyles.push(registered[className] + ";");
+    } else if (className) {
+      rawClassName += className + " ";
+    }
+  });
+  return rawClassName;
 }
+var registerStyles = function registerStyles(cache, serialized, isStringTag) {
+  var className = cache.key + "-" + serialized.name;
+
+  if ( // we only need to add the styles to the registered cache if the
+  // class name could be used further down
+  // the tree but if it's a string tag, we know it won't
+  // so we don't have to add it to registered cache.
+  // this improves memory usage since we can avoid storing the whole style string
+  (isStringTag === false || // we need to always store it if we're in compat mode and
+  // in node since emotion-server relies on whether a style is in
+  // the registered cache to know whether a style is global or not
+  // also, note that this check will be dead code eliminated in the browser
+  isBrowser === false ) && cache.registered[className] === undefined) {
+    cache.registered[className] = serialized.styles;
+  }
+};
+var insertStyles = function insertStyles(cache, serialized, isStringTag) {
+  registerStyles(cache, serialized, isStringTag);
+  var className = cache.key + "-" + serialized.name;
+
+  if (cache.inserted[serialized.name] === undefined) {
+    var current = serialized;
+
+    do {
+      cache.insert(serialized === current ? "." + className : '', current, cache.sheet, true);
+
+      current = current.next;
+    } while (current !== undefined);
+  }
+};
+
+
 
-// src/Main.js
-var import_react2 = __toESM(require("react"));
-var import_prop_types = __toESM(require("prop-types"));
-var import_react_router_dom = require("react-router-dom");
+;// ./node_modules/@emotion/is-prop-valid/dist/emotion-is-prop-valid.esm.js
 
-// src/styles/Main.styled.js
-var import_styled = __toESM(require("@emotion/styled"));
-var AppContainer = import_styled.default.div`
-  font-family: "Inter", sans-serif;
-`;
 
-// src/utils/locale.js
+// eslint-disable-next-line no-undef
+var reactPropsRegex = /^((children|dangerouslySetInnerHTML|key|ref|autoFocus|defaultValue|defaultChecked|innerHTML|suppressContentEditableWarning|suppressHydrationWarning|valueLink|abbr|accept|acceptCharset|accessKey|action|allow|allowUserMedia|allowPaymentRequest|allowFullScreen|allowTransparency|alt|async|autoComplete|autoPlay|capture|cellPadding|cellSpacing|challenge|charSet|checked|cite|classID|className|cols|colSpan|content|contentEditable|contextMenu|controls|controlsList|coords|crossOrigin|data|dateTime|decoding|default|defer|dir|disabled|disablePictureInPicture|disableRemotePlayback|download|draggable|encType|enterKeyHint|fetchpriority|fetchPriority|form|formAction|formEncType|formMethod|formNoValidate|formTarget|frameBorder|headers|height|hidden|high|href|hrefLang|htmlFor|httpEquiv|id|inputMode|integrity|is|keyParams|keyType|kind|label|lang|list|loading|loop|low|marginHeight|marginWidth|max|maxLength|media|mediaGroup|method|min|minLength|multiple|muted|name|nonce|noValidate|open|optimum|pattern|placeholder|playsInline|popover|popoverTarget|popoverTargetAction|poster|preload|profile|radioGroup|readOnly|referrerPolicy|rel|required|reversed|role|rows|rowSpan|sandbox|scope|scoped|scrolling|seamless|selected|shape|size|sizes|slot|span|spellCheck|src|srcDoc|srcLang|srcSet|start|step|style|summary|tabIndex|target|title|translate|type|useMap|value|width|wmode|wrap|about|datatype|inlist|prefix|property|resource|typeof|vocab|autoCapitalize|autoCorrect|autoSave|color|incremental|fallback|inert|itemProp|itemScope|itemType|itemID|itemRef|on|option|results|security|unselectable|accentHeight|accumulate|additive|alignmentBaseline|allowReorder|alphabetic|amplitude|arabicForm|ascent|attributeName|attributeType|autoReverse|azimuth|baseFrequency|baselineShift|baseProfile|bbox|begin|bias|by|calcMode|capHeight|clip|clipPathUnits|clipPath|clipRule|colorInterpolation|colorInterpolationFilters|colorProfile|colorRendering|contentScriptType|contentStyleType|cursor|cx|cy|d|decelerate|descent|diffuseConstant|direction|display|divisor|dominantBaseline|dur|dx|dy|edgeMode|elevation|enableBackground|end|exponent|externalResourcesRequired|fill|fillOpacity|fillRule|filter|filterRes|filterUnits|floodColor|floodOpacity|focusable|fontFamily|fontSize|fontSizeAdjust|fontStretch|fontStyle|fontVariant|fontWeight|format|from|fr|fx|fy|g1|g2|glyphName|glyphOrientationHorizontal|glyphOrientationVertical|glyphRef|gradientTransform|gradientUnits|hanging|horizAdvX|horizOriginX|ideographic|imageRendering|in|in2|intercept|k|k1|k2|k3|k4|kernelMatrix|kernelUnitLength|kerning|keyPoints|keySplines|keyTimes|lengthAdjust|letterSpacing|lightingColor|limitingConeAngle|local|markerEnd|markerMid|markerStart|markerHeight|markerUnits|markerWidth|mask|maskContentUnits|maskUnits|mathematical|mode|numOctaves|offset|opacity|operator|order|orient|orientation|origin|overflow|overlinePosition|overlineThickness|panose1|paintOrder|pathLength|patternContentUnits|patternTransform|patternUnits|pointerEvents|points|pointsAtX|pointsAtY|pointsAtZ|preserveAlpha|preserveAspectRatio|primitiveUnits|r|radius|refX|refY|renderingIntent|repeatCount|repeatDur|requiredExtensions|requiredFeatures|restart|result|rotate|rx|ry|scale|seed|shapeRendering|slope|spacing|specularConstant|specularExponent|speed|spreadMethod|startOffset|stdDeviation|stemh|stemv|stitchTiles|stopColor|stopOpacity|strikethroughPosition|strikethroughThickness|string|stroke|strokeDasharray|strokeDashoffset|strokeLinecap|strokeLinejoin|strokeMiterlimit|strokeOpacity|strokeWidth|surfaceScale|systemLanguage|tableValues|targetX|targetY|textAnchor|textDecoration|textRendering|textLength|to|transform|u1|u2|underlinePosition|underlineThickness|unicode|unicodeBidi|unicodeRange|unitsPerEm|vAlphabetic|vHanging|vIdeographic|vMathematical|values|vectorEffect|version|vertAdvY|vertOriginX|vertOriginY|viewBox|viewTarget|visibility|widths|wordSpacing|writingMode|x|xHeight|x1|x2|xChannelSelector|xlinkActuate|xlinkArcrole|xlinkHref|xlinkRole|xlinkShow|xlinkTitle|xlinkType|xmlBase|xmlns|xmlnsXlink|xmlLang|xmlSpace|y|y1|y2|yChannelSelector|z|zoomAndPan|for|class|autofocus)|(([Dd][Aa][Tt][Aa]|[Aa][Rr][Ii][Aa]|x)-.*))$/; // https://esbench.com/bench/5bfee68a4cd7e6009ef61d23
+
+var isPropValid = /* #__PURE__ */memoize(function (prop) {
+  return reactPropsRegex.test(prop) || prop.charCodeAt(0) === 111
+  /* o */
+  && prop.charCodeAt(1) === 110
+  /* n */
+  && prop.charCodeAt(2) < 91;
+}
+/* Z+1 */
+);
+
+
+
+;// ./node_modules/@emotion/styled/base/dist/emotion-styled-base.browser.esm.js
+
+
+
+
+
+
+
+
+var emotion_styled_base_browser_esm_isDevelopment = false;
+
+var testOmitPropsOnStringTag = isPropValid;
+
+var testOmitPropsOnComponent = function testOmitPropsOnComponent(key) {
+  return key !== 'theme';
+};
+
+var getDefaultShouldForwardProp = function getDefaultShouldForwardProp(tag) {
+  return typeof tag === 'string' && // 96 is one less than the char code
+  // for "a" so this is checking that
+  // it's a lowercase character
+  tag.charCodeAt(0) > 96 ? testOmitPropsOnStringTag : testOmitPropsOnComponent;
+};
+var composeShouldForwardProps = function composeShouldForwardProps(tag, options, isReal) {
+  var shouldForwardProp;
+
+  if (options) {
+    var optionsShouldForwardProp = options.shouldForwardProp;
+    shouldForwardProp = tag.__emotion_forwardProp && optionsShouldForwardProp ? function (propName) {
+      return tag.__emotion_forwardProp(propName) && optionsShouldForwardProp(propName);
+    } : optionsShouldForwardProp;
+  }
+
+  if (typeof shouldForwardProp !== 'function' && isReal) {
+    shouldForwardProp = tag.__emotion_forwardProp;
+  }
+
+  return shouldForwardProp;
+};
+
+var Insertion = function Insertion(_ref) {
+  var cache = _ref.cache,
+      serialized = _ref.serialized,
+      isStringTag = _ref.isStringTag;
+  registerStyles(cache, serialized, isStringTag);
+  useInsertionEffectAlwaysWithSyncFallback(function () {
+    return insertStyles(cache, serialized, isStringTag);
+  });
+
+  return null;
+};
+
+var createStyled = function createStyled(tag, options) {
+
+  var isReal = tag.__emotion_real === tag;
+  var baseTag = isReal && tag.__emotion_base || tag;
+  var identifierName;
+  var targetClassName;
+
+  if (options !== undefined) {
+    identifierName = options.label;
+    targetClassName = options.target;
+  }
+
+  var shouldForwardProp = composeShouldForwardProps(tag, options, isReal);
+  var defaultShouldForwardProp = shouldForwardProp || getDefaultShouldForwardProp(baseTag);
+  var shouldUseAs = !defaultShouldForwardProp('as');
+  return function () {
+    // eslint-disable-next-line prefer-rest-params
+    var args = arguments;
+    var styles = isReal && tag.__emotion_styles !== undefined ? tag.__emotion_styles.slice(0) : [];
+
+    if (identifierName !== undefined) {
+      styles.push("label:" + identifierName + ";");
+    }
+
+    if (args[0] == null || args[0].raw === undefined) {
+      // eslint-disable-next-line prefer-spread
+      styles.push.apply(styles, args);
+    } else {
+      var templateStringsArr = args[0];
+
+      styles.push(templateStringsArr[0]);
+      var len = args.length;
+      var i = 1;
+
+      for (; i < len; i++) {
+
+        styles.push(args[i], templateStringsArr[i]);
+      }
+    }
+
+    var Styled = (0,react_namespaceObject.withEmotionCache)(function (props, cache, ref) {
+      var FinalTag = shouldUseAs && props.as || baseTag;
+      var className = '';
+      var classInterpolations = [];
+      var mergedProps = props;
+
+      if (props.theme == null) {
+        mergedProps = {};
+
+        for (var key in props) {
+          mergedProps[key] = props[key];
+        }
+
+        mergedProps.theme = external_react_namespaceObject.useContext(react_namespaceObject.ThemeContext);
+      }
+
+      if (typeof props.className === 'string') {
+        className = getRegisteredStyles(cache.registered, classInterpolations, props.className);
+      } else if (props.className != null) {
+        className = props.className + " ";
+      }
+
+      var serialized = serializeStyles(styles.concat(classInterpolations), cache.registered, mergedProps);
+      className += cache.key + "-" + serialized.name;
+
+      if (targetClassName !== undefined) {
+        className += " " + targetClassName;
+      }
+
+      var finalShouldForwardProp = shouldUseAs && shouldForwardProp === undefined ? getDefaultShouldForwardProp(FinalTag) : defaultShouldForwardProp;
+      var newProps = {};
+
+      for (var _key in props) {
+        if (shouldUseAs && _key === 'as') continue;
+
+        if (finalShouldForwardProp(_key)) {
+          newProps[_key] = props[_key];
+        }
+      }
+
+      newProps.className = className;
+
+      if (ref) {
+        newProps.ref = ref;
+      }
+
+      return /*#__PURE__*/external_react_namespaceObject.createElement(external_react_namespaceObject.Fragment, null, /*#__PURE__*/external_react_namespaceObject.createElement(Insertion, {
+        cache: cache,
+        serialized: serialized,
+        isStringTag: typeof FinalTag === 'string'
+      }), /*#__PURE__*/external_react_namespaceObject.createElement(FinalTag, newProps));
+    });
+    Styled.displayName = identifierName !== undefined ? identifierName : "Styled(" + (typeof baseTag === 'string' ? baseTag : baseTag.displayName || baseTag.name || 'Component') + ")";
+    Styled.defaultProps = tag.defaultProps;
+    Styled.__emotion_real = Styled;
+    Styled.__emotion_base = baseTag;
+    Styled.__emotion_styles = styles;
+    Styled.__emotion_forwardProp = shouldForwardProp;
+    Object.defineProperty(Styled, 'toString', {
+      value: function value() {
+        if (targetClassName === undefined && emotion_styled_base_browser_esm_isDevelopment) {
+          return 'NO_COMPONENT_SELECTOR';
+        }
+
+        return "." + targetClassName;
+      }
+    });
+
+    Styled.withComponent = function (nextTag, nextOptions) {
+      var newStyled = createStyled(nextTag, _extends({}, options, nextOptions, {
+        shouldForwardProp: composeShouldForwardProps(Styled, nextOptions, true)
+      }));
+      return newStyled.apply(void 0, styles);
+    };
+
+    return Styled;
+  };
+};
+
+
+
+;// ./src/styles/Main.styled.js
+
+function _EMOTION_STRINGIFIED_CSS_ERROR__() { return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop)."; }
+var AppContainer = /*#__PURE__*/createStyled("div",  true ? {
+  target: "eh9sycj0"
+} : 0)( true ? {
+  name: "1xncdb6",
+  styles: "font-family:\"Inter\",sans-serif"
+} : 0);
+;// ./src/styles/globals.css
+// extracted by mini-css-extract-plugin
+
+;// ./src/utils/locale.js
+/**
+ * Extracts the locale code from the provided URL or the current URL.
+ *
+ * @param options - An object with the following properties:
+ * @param options.url - The URL to extract the locale code from. If not provided, the current URL will be used.
+ * @param options.defaultLocale - The default locale code to use if the locale cannot be extracted from the URL.
+ * @returns The locale code in the format "language_COUNTRY".
+ */
 function getLocaleCodeFromUrl(options) {
-  var _a, _b;
-  const { url = "", defaultLocale = "" } = options ?? {};
-  let localeAsArr = [];
-  let tempUrl = url || typeof location != "undefined" && location.href;
+  var _localeAsArr$;
+  var _ref = options !== null && options !== void 0 ? options : {},
+    _ref$url = _ref.url,
+    url = _ref$url === void 0 ? "" : _ref$url,
+    _ref$defaultLocale = _ref.defaultLocale,
+    defaultLocale = _ref$defaultLocale === void 0 ? "" : _ref$defaultLocale;
+  var localeAsArr = [];
+  var tempUrl = url || typeof location != "undefined" && location.href;
   if (tempUrl) {
-    if (!(tempUrl == null ? void 0 : tempUrl.includes("https://")) && !(tempUrl == null ? void 0 : tempUrl.includes("http://"))) {
-      tempUrl = `https://domain.com${tempUrl}`;
+    var _tempUrl, _tempUrl2;
+    /* adding dummy domain since express originalUrl will not have request domain */
+    if (!((_tempUrl = tempUrl) !== null && _tempUrl !== void 0 && _tempUrl.includes("https://")) && !((_tempUrl2 = tempUrl) !== null && _tempUrl2 !== void 0 && _tempUrl2.includes("http://"))) {
+      tempUrl = "https://domain.com".concat(tempUrl);
     }
-    const updatedUrl = new URL(tempUrl);
-    const pathParams = updatedUrl.pathname;
+    var updatedUrl = new URL(tempUrl);
+    var pathParams = updatedUrl.pathname;
     if (pathParams) {
-      const pathList = (_a = pathParams == null ? void 0 : pathParams.split("/")) == null ? void 0 : _a.filter(Boolean);
+      var _pathParams$split;
+      var pathList = pathParams === null || pathParams === void 0 || (_pathParams$split = pathParams.split("/")) === null || _pathParams$split === void 0 ? void 0 : _pathParams$split.filter(Boolean);
       if (pathList.length > 1) {
         localeAsArr = pathList;
       }
@@ -91,195 +775,105 @@ function getLocaleCodeFromUrl(options) {
   if (localeAsArr.length === 0) {
     localeAsArr = defaultLocale.split("_");
   }
-  return `${(_b = localeAsArr[1]) == null ? void 0 : _b.toUpperCase()}-${localeAsArr[0]}`;
+  return "".concat((_localeAsArr$ = localeAsArr[1]) === null || _localeAsArr$ === void 0 ? void 0 : _localeAsArr$.toUpperCase(), "-").concat(localeAsArr[0]);
 }
-function getLocale({ url } = {}) {
-  var _a, _b;
-  const currentLocale = getLocaleCodeFromUrl(url ? { url } : null);
-  const splitLocale = currentLocale == null ? void 0 : currentLocale.split("-");
+function getLocale() {
+  var _splitLocale$, _splitLocale$2;
+  var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    url = _ref2.url;
+  var currentLocale = getLocaleCodeFromUrl(url ? {
+    url: url
+  } : null);
+  var splitLocale = currentLocale === null || currentLocale === void 0 ? void 0 : currentLocale.split("-");
   return {
     locale: currentLocale,
-    language: (_a = splitLocale == null ? void 0 : splitLocale[1]) == null ? void 0 : _a.toLowerCase(),
-    country: (_b = splitLocale == null ? void 0 : splitLocale[0]) == null ? void 0 : _b.toUpperCase()
+    language: splitLocale === null || splitLocale === void 0 || (_splitLocale$ = splitLocale[1]) === null || _splitLocale$ === void 0 ? void 0 : _splitLocale$.toLowerCase(),
+    country: splitLocale === null || splitLocale === void 0 || (_splitLocale$2 = splitLocale[0]) === null || _splitLocale$2 === void 0 ? void 0 : _splitLocale$2.toUpperCase()
   };
 }
-
-// src/Main.js
-var HeaderMFEContext = (0, import_react2.createContext)({ isMFE: true });
-function Main({ isMFE = true }) {
-  let { country, language } = getLocale();
-  country = country.toLocaleLowerCase();
-  language = language.toLocaleLowerCase();
-  const baseName = isMFE ? `/${country}/${language}` : `/${country}/${language}/static/header-mfe`;
-  return /* @__PURE__ */ import_react2.default.createElement(HeaderMFEContext.Provider, { value: { isMFE } }, /* @__PURE__ */ import_react2.default.createElement(import_react_router_dom.BrowserRouter, { basename: baseName }, /* @__PURE__ */ import_react2.default.createElement(AppContainer, null, /* @__PURE__ */ import_react2.default.createElement(import_react_router_dom.Routes, null, /* @__PURE__ */ import_react2.default.createElement(import_react_router_dom.Route, { path: "*", element: /* @__PURE__ */ import_react2.default.createElement(HeaderPlaceholder, null) })))));
+function locale_isBrowser() {
+  return typeof window !== "undefined" && window != null;
 }
-Main.propTypes = {
-  isMFE: import_prop_types.default.bool
-};
-var Main_default = Main;
 
-// src/utils/config.js
-function getStackConfig() {
-  const { locale } = getLocale();
+/** Normalized `country`, `language`, and `locale` string from explicit market + language. */
+function buildLocaleData(market, language) {
+  var country = String(market).trim().toUpperCase();
+  var lang = String(language).trim().toLowerCase();
+  if (!country || !lang) {
+    throw new Error("@nuskin/nextgen-header: `market` and `language` must be non-empty when provided.");
+  }
   return {
-    contentType: process.env.CONTENTSTACK_HEADER_CONTENT_TYPE || "",
-    locale
+    country: country,
+    language: lang,
+    locale: "".concat(country, "-").concat(lang)
   };
 }
 
-// src/utils/contentstack.js
-var import_delivery_sdk = __toESM(require("@contentstack/delivery-sdk"));
-var import_live_preview_utils = __toESM(require("@contentstack/live-preview-utils"));
-var import_utils = require("@contentstack/utils");
-
-// src/constants.js
-var CONTENTSTACK_API_KEY = process.env.CONTENTSTACK_API_KEY;
-var CONTENTSTACK_DELIVERY_TOKEN = process.env.CONTENTSTACK_DELIVERY_TOKEN;
-var CONTENTSTACK_ENVIRONMENT = process.env.CONTENTSTACK_ENVIRONMENT;
-var CONTENTSTACK_PREVIEW_TOKEN = process.env.CONTENTSTACK_PREVIEW_TOKEN;
-var referenceFields = [];
-var VB_EmptyBlockParentClass = "visual-builder__empty-block-parent";
-
-// src/utils/contentstack.js
-var _stack = null;
-function getStack() {
-  if (!_stack) {
-    _stack = import_delivery_sdk.default.stack({
-      apiKey: CONTENTSTACK_API_KEY,
-      deliveryToken: CONTENTSTACK_DELIVERY_TOKEN,
-      environment: CONTENTSTACK_ENVIRONMENT,
-      live_preview: {
-        enable: true,
-        preview_token: CONTENTSTACK_PREVIEW_TOKEN,
-        host: "rest-preview.contentstack.com"
-      }
-    });
+/**
+ * Resolves locale data (`country`, `language`, `locale`) for the header shell.
+ *
+ * - **SSR (no `window`):** `market` and `language` are required (e.g. from the host or from `requestUrl` in `renderAndExtractContext`).
+ * - **CSR:** `market` and `language` optional; if omitted, derived from the current URL via the same rules as `getLocale()`. Throws if `window` is missing or the path cannot be parsed.
+ */
+function resolveHeaderLocale() {
+  var _ref3 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    market = _ref3.market,
+    language = _ref3.language;
+  var explicit = market != null && language != null && String(market).trim() !== "" && String(language).trim() !== "";
+  if (explicit) {
+    return buildLocaleData(market, language);
   }
-  return _stack;
-}
-var BRIDGED_CONFIG_KEYS = ["live_preview", "headers", "environment"];
-var stack = new Proxy(
-  {},
-  {
-    get(_, prop) {
-      var _a;
-      const s = getStack();
-      if (BRIDGED_CONFIG_KEYS.includes(prop)) {
-        return (_a = s.config) == null ? void 0 : _a[prop];
-      }
-      return s[prop];
-    },
-    set(_, prop, value) {
-      const s = getStack();
-      if (BRIDGED_CONFIG_KEYS.includes(prop)) {
-        if (!s.config) return false;
-        s.config[prop] = value;
-        return true;
-      }
-      s[prop] = value;
-      return true;
-    },
-    has(_, prop) {
-      if (BRIDGED_CONFIG_KEYS.includes(prop)) return true;
-      return prop in getStack();
-    },
-    ownKeys() {
-      return [
-        .../* @__PURE__ */ new Set([...Reflect.ownKeys(getStack()), ...BRIDGED_CONFIG_KEYS])
-      ];
-    },
-    getOwnPropertyDescriptor(_, prop) {
-      var _a;
-      if (BRIDGED_CONFIG_KEYS.includes(prop)) {
-        return {
-          configurable: true,
-          enumerable: true,
-          writable: true,
-          value: (_a = getStack().config) == null ? void 0 : _a[prop]
-        };
-      }
-      return Object.getOwnPropertyDescriptor(getStack(), prop);
-    }
+  if (!locale_isBrowser()) {
+    throw new Error("@nuskin/nextgen-header: SSR requires `market` and `language` on `<Main />`, or pass `requestUrl` into `renderAndExtractContext` so they can be derived from the request path.");
   }
-);
-var _livePreviewInitialized = false;
-var onEntryChange = import_live_preview_utils.default.onEntryChange.bind(
-  import_live_preview_utils.default
-);
-function initLivePreview() {
-  if (_livePreviewInitialized) return;
-  _livePreviewInitialized = true;
-  import_live_preview_utils.default.init({
-    ssr: false,
-    enable: true,
-    mode: "builder",
-    stackSdk: stack,
-    stackDetails: {
-      apiKey: CONTENTSTACK_API_KEY,
-      environment: CONTENTSTACK_ENVIRONMENT
-    },
-    clientUrlParams: {
-      host: "app.contentstack.com"
-    },
-    editButton: {
-      enable: false
-    }
-  });
-}
-function isEditingMode() {
-  if (typeof window === "undefined") {
-    return false;
+  var fromUrl = getLocale();
+  if (!fromUrl.country || !fromUrl.language || !fromUrl.locale || String(fromUrl.locale).includes("undefined")) {
+    throw new Error("@nuskin/nextgen-header: could not derive `market` and `language` from the current URL (expected a path with at least two segments, e.g. /en/us/...). Pass `market` and `language` explicitly.");
   }
-  if (window.self !== window.top) {
-    return true;
-  }
-  const params = new URLSearchParams(window.location.search);
-  return params.has("visual-builder") || params.has("contentstack") || params.has("live_preview");
+  return fromUrl;
 }
-var getContent = async ({
-  url,
-  uid,
-  contentType,
-  language,
-  referenceFields: referenceFields2 = []
-} = {}) => {
-  const tryFetch = async (locale) => {
-    var _a;
-    const CT = stack.contentType(contentType);
-    let fetched = null;
-    if (uid) {
-      fetched = await CT.entry(uid).locale(locale).includeReference(referenceFields2).fetch();
-    } else if (url) {
-      const urlWithSlash = url.startsWith("/") ? url : `/${url}`;
-      const result = await CT.entry().locale(locale).includeReference(referenceFields2).query({ url: urlWithSlash }).find();
-      fetched = (_a = result.entries) == null ? void 0 : _a[0];
-    }
-    if (isEditingMode() && fetched) {
-      (0, import_utils.addEditableTags)(fetched, contentType, true, language, {
-        useLowerCaseLocale: false
-      });
-    }
-    return fetched;
-  };
-  try {
-    const result = await tryFetch(language);
-    return result;
-  } catch (error) {
-    console.warn(
-      "Failed to fetch content with language:",
-      language,
-      error.message
-    );
-    try {
-      const fallbackResult = await tryFetch("en");
-      return fallbackResult;
-    } catch (fallbackError) {
-      console.warn(
-        "Failed to fetch content with fallback language:",
-        fallbackError.message
-      );
-      return null;
-    }
-  }
+
+;// ./src/Main.js
+
+
+
+
+
+
+
+function Main(_ref) {
+  var market = _ref.market,
+    language = _ref.language;
+  var resolved = resolveHeaderLocale({
+    market: market,
+    language: language
+  });
+  return /*#__PURE__*/(0,jsx_runtime_namespaceObject.jsx)(AppContainer, {
+    children: /*#__PURE__*/(0,jsx_runtime_namespaceObject.jsx)(HeaderPlaceholder, {
+      country: resolved.country,
+      language: resolved.language,
+      locale: resolved.locale
+    })
+  });
+}
+Main.propTypes = {
+  market: (external_prop_types_default()).string,
+  language: (external_prop_types_default()).string
 };
+/* harmony default export */ const src_Main = (Main);
+;// ./src/library/index.js
+/**
+ * Public API for `@nuskin/nextgen-header` npm consumers.
+ *
+ * **Header** — `AppContainer` + market/language resolution → renders the header placeholder inside.
+ * (Source: `Main.js`; exported under the product name `Header`.)
+ *
+ * Does not include the Module Federation app entry (`App`), Express server, or bootstrap.
+ * Contentstack helpers are internal for now; re-export here when the public API is defined.
+ */
+
+
+module.exports = __webpack_exports__;
+/******/ })()
+;
 //# sourceMappingURL=index.js.map