enjanga-components-library 1.0.4 → 1.0.11

package/dist/index.js

@@ -30,6 +30,847 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// node_modules/is-plain-obj/index.js
+var require_is_plain_obj = __commonJS({
+  "node_modules/is-plain-obj/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = (value) => {
+      if (Object.prototype.toString.call(value) !== "[object Object]") {
+        return false;
+      }
+      const prototype = Object.getPrototypeOf(value);
+      return prototype === null || prototype === Object.prototype;
+    };
+  }
+});
+
+// node_modules/moo/moo.js
+var require_moo = __commonJS({
+  "node_modules/moo/moo.js"(exports2, module2) {
+    "use strict";
+    (function(root, factory) {
+      if (typeof define === "function" && define.amd) {
+        define([], factory);
+      } else if (typeof module2 === "object" && module2.exports) {
+        module2.exports = factory();
+      } else {
+        root.moo = factory();
+      }
+    })(exports2, function() {
+      "use strict";
+      var hasOwnProperty = Object.prototype.hasOwnProperty;
+      var toString = Object.prototype.toString;
+      var hasSticky = typeof new RegExp().sticky === "boolean";
+      function isRegExp(o) {
+        return o && toString.call(o) === "[object RegExp]";
+      }
+      function isObject(o) {
+        return o && typeof o === "object" && !isRegExp(o) && !Array.isArray(o);
+      }
+      function reEscape(s) {
+        return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
+      }
+      function reGroups(s) {
+        var re = new RegExp("|" + s);
+        return re.exec("").length - 1;
+      }
+      function reCapture(s) {
+        return "(" + s + ")";
+      }
+      function reUnion(regexps) {
+        if (!regexps.length) return "(?!)";
+        var source = regexps.map(function(s) {
+          return "(?:" + s + ")";
+        }).join("|");
+        return "(?:" + source + ")";
+      }
+      function regexpOrLiteral(obj) {
+        if (typeof obj === "string") {
+          return "(?:" + reEscape(obj) + ")";
+        } else if (isRegExp(obj)) {
+          if (obj.ignoreCase) throw new Error("RegExp /i flag not allowed");
+          if (obj.global) throw new Error("RegExp /g flag is implied");
+          if (obj.sticky) throw new Error("RegExp /y flag is implied");
+          if (obj.multiline) throw new Error("RegExp /m flag is implied");
+          return obj.source;
+        } else {
+          throw new Error("Not a pattern: " + obj);
+        }
+      }
+      function pad(s, length) {
+        if (s.length > length) {
+          return s;
+        }
+        return Array(length - s.length + 1).join(" ") + s;
+      }
+      function lastNLines(string, numLines) {
+        var position = string.length;
+        var lineBreaks = 0;
+        while (true) {
+          var idx = string.lastIndexOf("\n", position - 1);
+          if (idx === -1) {
+            break;
+          } else {
+            lineBreaks++;
+          }
+          position = idx;
+          if (lineBreaks === numLines) {
+            break;
+          }
+          if (position === 0) {
+            break;
+          }
+        }
+        var startPosition = lineBreaks < numLines ? 0 : position + 1;
+        return string.substring(startPosition).split("\n");
+      }
+      function objectToRules(object) {
+        var keys = Object.getOwnPropertyNames(object);
+        var result = [];
+        for (var i = 0; i < keys.length; i++) {
+          var key = keys[i];
+          var thing = object[key];
+          var rules = [].concat(thing);
+          if (key === "include") {
+            for (var j = 0; j < rules.length; j++) {
+              result.push({ include: rules[j] });
+            }
+            continue;
+          }
+          var match = [];
+          rules.forEach(function(rule) {
+            if (isObject(rule)) {
+              if (match.length) result.push(ruleOptions(key, match));
+              result.push(ruleOptions(key, rule));
+              match = [];
+            } else {
+              match.push(rule);
+            }
+          });
+          if (match.length) result.push(ruleOptions(key, match));
+        }
+        return result;
+      }
+      function arrayToRules(array) {
+        var result = [];
+        for (var i = 0; i < array.length; i++) {
+          var obj = array[i];
+          if (obj.include) {
+            var include = [].concat(obj.include);
+            for (var j = 0; j < include.length; j++) {
+              result.push({ include: include[j] });
+            }
+            continue;
+          }
+          if (!obj.type) {
+            throw new Error("Rule has no type: " + JSON.stringify(obj));
+          }
+          result.push(ruleOptions(obj.type, obj));
+        }
+        return result;
+      }
+      function ruleOptions(type, obj) {
+        if (!isObject(obj)) {
+          obj = { match: obj };
+        }
+        if (obj.include) {
+          throw new Error("Matching rules cannot also include states");
+        }
+        var options = {
+          defaultType: type,
+          lineBreaks: !!obj.error || !!obj.fallback,
+          pop: false,
+          next: null,
+          push: null,
+          error: false,
+          fallback: false,
+          value: null,
+          type: null,
+          shouldThrow: false
+        };
+        for (var key in obj) {
+          if (hasOwnProperty.call(obj, key)) {
+            options[key] = obj[key];
+          }
+        }
+        if (typeof options.type === "string" && type !== options.type) {
+          throw new Error("Type transform cannot be a string (type '" + options.type + "' for token '" + type + "')");
+        }
+        var match = options.match;
+        options.match = Array.isArray(match) ? match : match ? [match] : [];
+        options.match.sort(function(a, b) {
+          return isRegExp(a) && isRegExp(b) ? 0 : isRegExp(b) ? -1 : isRegExp(a) ? 1 : b.length - a.length;
+        });
+        return options;
+      }
+      function toRules(spec) {
+        return Array.isArray(spec) ? arrayToRules(spec) : objectToRules(spec);
+      }
+      var defaultErrorRule = ruleOptions("error", { lineBreaks: true, shouldThrow: true });
+      function compileRules(rules, hasStates) {
+        var errorRule = null;
+        var fast = /* @__PURE__ */ Object.create(null);
+        var fastAllowed = true;
+        var unicodeFlag = null;
+        var groups = [];
+        var parts = [];
+        for (var i = 0; i < rules.length; i++) {
+          if (rules[i].fallback) {
+            fastAllowed = false;
+          }
+        }
+        for (var i = 0; i < rules.length; i++) {
+          var options = rules[i];
+          if (options.include) {
+            throw new Error("Inheritance is not allowed in stateless lexers");
+          }
+          if (options.error || options.fallback) {
+            if (errorRule) {
+              if (!options.fallback === !errorRule.fallback) {
+                throw new Error("Multiple " + (options.fallback ? "fallback" : "error") + " rules not allowed (for token '" + options.defaultType + "')");
+              } else {
+                throw new Error("fallback and error are mutually exclusive (for token '" + options.defaultType + "')");
+              }
+            }
+            errorRule = options;
+          }
+          var match = options.match.slice();
+          if (fastAllowed) {
+            while (match.length && typeof match[0] === "string" && match[0].length === 1) {
+              var word = match.shift();
+              fast[word.charCodeAt(0)] = options;
+            }
+          }
+          if (options.pop || options.push || options.next) {
+            if (!hasStates) {
+              throw new Error("State-switching options are not allowed in stateless lexers (for token '" + options.defaultType + "')");
+            }
+            if (options.fallback) {
+              throw new Error("State-switching options are not allowed on fallback tokens (for token '" + options.defaultType + "')");
+            }
+          }
+          if (match.length === 0) {
+            continue;
+          }
+          fastAllowed = false;
+          groups.push(options);
+          for (var j = 0; j < match.length; j++) {
+            var obj = match[j];
+            if (!isRegExp(obj)) {
+              continue;
+            }
+            if (unicodeFlag === null) {
+              unicodeFlag = obj.unicode;
+            } else if (unicodeFlag !== obj.unicode && options.fallback === false) {
+              throw new Error("If one rule is /u then all must be");
+            }
+          }
+          var pat = reUnion(match.map(regexpOrLiteral));
+          var regexp = new RegExp(pat);
+          if (regexp.test("")) {
+            throw new Error("RegExp matches empty string: " + regexp);
+          }
+          var groupCount = reGroups(pat);
+          if (groupCount > 0) {
+            throw new Error("RegExp has capture groups: " + regexp + "\nUse (?: \u2026 ) instead");
+          }
+          if (!options.lineBreaks && regexp.test("\n")) {
+            throw new Error("Rule should declare lineBreaks: " + regexp);
+          }
+          parts.push(reCapture(pat));
+        }
+        var fallbackRule = errorRule && errorRule.fallback;
+        var flags = hasSticky && !fallbackRule ? "ym" : "gm";
+        var suffix = hasSticky || fallbackRule ? "" : "|";
+        if (unicodeFlag === true) flags += "u";
+        var combined = new RegExp(reUnion(parts) + suffix, flags);
+        return { regexp: combined, groups, fast, error: errorRule || defaultErrorRule };
+      }
+      function compile(rules) {
+        var result = compileRules(toRules(rules));
+        return new Lexer({ start: result }, "start");
+      }
+      function checkStateGroup(g, name, map) {
+        var state = g && (g.push || g.next);
+        if (state && !map[state]) {
+          throw new Error("Missing state '" + state + "' (in token '" + g.defaultType + "' of state '" + name + "')");
+        }
+        if (g && g.pop && +g.pop !== 1) {
+          throw new Error("pop must be 1 (in token '" + g.defaultType + "' of state '" + name + "')");
+        }
+      }
+      function compileStates(states, start) {
+        var all = states.$all ? toRules(states.$all) : [];
+        delete states.$all;
+        var keys = Object.getOwnPropertyNames(states);
+        if (!start) start = keys[0];
+        var ruleMap = /* @__PURE__ */ Object.create(null);
+        for (var i = 0; i < keys.length; i++) {
+          var key = keys[i];
+          ruleMap[key] = toRules(states[key]).concat(all);
+        }
+        for (var i = 0; i < keys.length; i++) {
+          var key = keys[i];
+          var rules = ruleMap[key];
+          var included = /* @__PURE__ */ Object.create(null);
+          for (var j = 0; j < rules.length; j++) {
+            var rule = rules[j];
+            if (!rule.include) continue;
+            var splice = [j, 1];
+            if (rule.include !== key && !included[rule.include]) {
+              included[rule.include] = true;
+              var newRules = ruleMap[rule.include];
+              if (!newRules) {
+                throw new Error("Cannot include nonexistent state '" + rule.include + "' (in state '" + key + "')");
+              }
+              for (var k = 0; k < newRules.length; k++) {
+                var newRule = newRules[k];
+                if (rules.indexOf(newRule) !== -1) continue;
+                splice.push(newRule);
+              }
+            }
+            rules.splice.apply(rules, splice);
+            j--;
+          }
+        }
+        var map = /* @__PURE__ */ Object.create(null);
+        for (var i = 0; i < keys.length; i++) {
+          var key = keys[i];
+          map[key] = compileRules(ruleMap[key], true);
+        }
+        for (var i = 0; i < keys.length; i++) {
+          var name = keys[i];
+          var state = map[name];
+          var groups = state.groups;
+          for (var j = 0; j < groups.length; j++) {
+            checkStateGroup(groups[j], name, map);
+          }
+          var fastKeys = Object.getOwnPropertyNames(state.fast);
+          for (var j = 0; j < fastKeys.length; j++) {
+            checkStateGroup(state.fast[fastKeys[j]], name, map);
+          }
+        }
+        return new Lexer(map, start);
+      }
+      function keywordTransform(map) {
+        var isMap = typeof Map !== "undefined";
+        var reverseMap = isMap ? /* @__PURE__ */ new Map() : /* @__PURE__ */ Object.create(null);
+        var types = Object.getOwnPropertyNames(map);
+        for (var i = 0; i < types.length; i++) {
+          var tokenType = types[i];
+          var item = map[tokenType];
+          var keywordList = Array.isArray(item) ? item : [item];
+          keywordList.forEach(function(keyword) {
+            if (typeof keyword !== "string") {
+              throw new Error("keyword must be string (in keyword '" + tokenType + "')");
+            }
+            if (isMap) {
+              reverseMap.set(keyword, tokenType);
+            } else {
+              reverseMap[keyword] = tokenType;
+            }
+          });
+        }
+        return function(k) {
+          return isMap ? reverseMap.get(k) : reverseMap[k];
+        };
+      }
+      var Lexer = function(states, state) {
+        this.startState = state;
+        this.states = states;
+        this.buffer = "";
+        this.stack = [];
+        this.reset();
+      };
+      Lexer.prototype.reset = function(data, info) {
+        this.buffer = data || "";
+        this.index = 0;
+        this.line = info ? info.line : 1;
+        this.col = info ? info.col : 1;
+        this.queuedToken = info ? info.queuedToken : null;
+        this.queuedText = info ? info.queuedText : "";
+        this.queuedThrow = info ? info.queuedThrow : null;
+        this.setState(info ? info.state : this.startState);
+        this.stack = info && info.stack ? info.stack.slice() : [];
+        return this;
+      };
+      Lexer.prototype.save = function() {
+        return {
+          line: this.line,
+          col: this.col,
+          state: this.state,
+          stack: this.stack.slice(),
+          queuedToken: this.queuedToken,
+          queuedText: this.queuedText,
+          queuedThrow: this.queuedThrow
+        };
+      };
+      Lexer.prototype.setState = function(state) {
+        if (!state || this.state === state) return;
+        this.state = state;
+        var info = this.states[state];
+        this.groups = info.groups;
+        this.error = info.error;
+        this.re = info.regexp;
+        this.fast = info.fast;
+      };
+      Lexer.prototype.popState = function() {
+        this.setState(this.stack.pop());
+      };
+      Lexer.prototype.pushState = function(state) {
+        this.stack.push(this.state);
+        this.setState(state);
+      };
+      var eat = hasSticky ? function(re, buffer) {
+        return re.exec(buffer);
+      } : function(re, buffer) {
+        var match = re.exec(buffer);
+        if (match[0].length === 0) {
+          return null;
+        }
+        return match;
+      };
+      Lexer.prototype._getGroup = function(match) {
+        var groupCount = this.groups.length;
+        for (var i = 0; i < groupCount; i++) {
+          if (match[i + 1] !== void 0) {
+            return this.groups[i];
+          }
+        }
+        throw new Error("Cannot find token type for matched text");
+      };
+      function tokenToString() {
+        return this.value;
+      }
+      Lexer.prototype.next = function() {
+        var index = this.index;
+        if (this.queuedGroup) {
+          var token = this._token(this.queuedGroup, this.queuedText, index);
+          this.queuedGroup = null;
+          this.queuedText = "";
+          return token;
+        }
+        var buffer = this.buffer;
+        if (index === buffer.length) {
+          return;
+        }
+        var group = this.fast[buffer.charCodeAt(index)];
+        if (group) {
+          return this._token(group, buffer.charAt(index), index);
+        }
+        var re = this.re;
+        re.lastIndex = index;
+        var match = eat(re, buffer);
+        var error = this.error;
+        if (match == null) {
+          return this._token(error, buffer.slice(index, buffer.length), index);
+        }
+        var group = this._getGroup(match);
+        var text = match[0];
+        if (error.fallback && match.index !== index) {
+          this.queuedGroup = group;
+          this.queuedText = text;
+          return this._token(error, buffer.slice(index, match.index), index);
+        }
+        return this._token(group, text, index);
+      };
+      Lexer.prototype._token = function(group, text, offset) {
+        var lineBreaks = 0;
+        if (group.lineBreaks) {
+          var matchNL = /\n/g;
+          var nl = 1;
+          if (text === "\n") {
+            lineBreaks = 1;
+          } else {
+            while (matchNL.exec(text)) {
+              lineBreaks++;
+              nl = matchNL.lastIndex;
+            }
+          }
+        }
+        var token = {
+          type: typeof group.type === "function" && group.type(text) || group.defaultType,
+          value: typeof group.value === "function" ? group.value(text) : text,
+          text,
+          toString: tokenToString,
+          offset,
+          lineBreaks,
+          line: this.line,
+          col: this.col
+        };
+        var size = text.length;
+        this.index += size;
+        this.line += lineBreaks;
+        if (lineBreaks !== 0) {
+          this.col = size - nl + 1;
+        } else {
+          this.col += size;
+        }
+        if (group.shouldThrow) {
+          var err = new Error(this.formatError(token, "invalid syntax"));
+          throw err;
+        }
+        if (group.pop) this.popState();
+        else if (group.push) this.pushState(group.push);
+        else if (group.next) this.setState(group.next);
+        return token;
+      };
+      if (typeof Symbol !== "undefined" && Symbol.iterator) {
+        var LexerIterator = function(lexer) {
+          this.lexer = lexer;
+        };
+        LexerIterator.prototype.next = function() {
+          var token = this.lexer.next();
+          return { value: token, done: !token };
+        };
+        LexerIterator.prototype[Symbol.iterator] = function() {
+          return this;
+        };
+        Lexer.prototype[Symbol.iterator] = function() {
+          return new LexerIterator(this);
+        };
+      }
+      Lexer.prototype.formatError = function(token, message) {
+        if (token == null) {
+          var text = this.buffer.slice(this.index);
+          var token = {
+            text,
+            offset: this.index,
+            lineBreaks: text.indexOf("\n") === -1 ? 0 : 1,
+            line: this.line,
+            col: this.col
+          };
+        }
+        var numLinesAround = 2;
+        var firstDisplayedLine = Math.max(token.line - numLinesAround, 1);
+        var lastDisplayedLine = token.line + numLinesAround;
+        var lastLineDigits = String(lastDisplayedLine).length;
+        var displayedLines = lastNLines(
+          this.buffer,
+          this.line - token.line + numLinesAround + 1
+        ).slice(0, 5);
+        var errorLines = [];
+        errorLines.push(message + " at line " + token.line + " col " + token.col + ":");
+        errorLines.push("");
+        for (var i = 0; i < displayedLines.length; i++) {
+          var line = displayedLines[i];
+          var lineNo = firstDisplayedLine + i;
+          errorLines.push(pad(String(lineNo), lastLineDigits) + "  " + line);
+          if (lineNo === token.line) {
+            errorLines.push(pad("", lastLineDigits + token.col + 1) + "^");
+          }
+        }
+        return errorLines.join("\n");
+      };
+      Lexer.prototype.clone = function() {
+        return new Lexer(this.states, this.state);
+      };
+      Lexer.prototype.has = function(tokenType) {
+        return true;
+      };
+      return {
+        compile,
+        states: compileStates,
+        error: Object.freeze({ error: true }),
+        fallback: Object.freeze({ fallback: true }),
+        keywords: keywordTransform
+      };
+    });
+  }
+});
+
+// node_modules/@messageformat/parser/lib/lexer.js
+var require_lexer = __commonJS({
+  "node_modules/@messageformat/parser/lib/lexer.js"(exports2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.lexer = exports2.states = void 0;
+    var moo_1 = __importDefault(require_moo());
+    exports2.states = {
+      body: {
+        doubleapos: { match: "''", value: () => "'" },
+        quoted: {
+          lineBreaks: true,
+          match: /'[{}#](?:[^']|'')*'(?!')/u,
+          value: (src) => src.slice(1, -1).replace(/''/g, "'")
+        },
+        argument: {
+          lineBreaks: true,
+          match: /\{\s*[^\p{Pat_Syn}\p{Pat_WS}]+\s*/u,
+          push: "arg",
+          value: (src) => src.substring(1).trim()
+        },
+        octothorpe: "#",
+        end: { match: "}", pop: 1 },
+        content: { lineBreaks: true, match: /[^][^{}#']*/u }
+      },
+      arg: {
+        select: {
+          lineBreaks: true,
+          match: /,\s*(?:plural|select|selectordinal)\s*,\s*/u,
+          next: "select",
+          value: (src) => src.split(",")[1].trim()
+        },
+        "func-args": {
+          lineBreaks: true,
+          match: /,\s*[^\p{Pat_Syn}\p{Pat_WS}]+\s*,/u,
+          next: "body",
+          value: (src) => src.split(",")[1].trim()
+        },
+        "func-simple": {
+          lineBreaks: true,
+          match: /,\s*[^\p{Pat_Syn}\p{Pat_WS}]+\s*/u,
+          value: (src) => src.substring(1).trim()
+        },
+        end: { match: "}", pop: 1 }
+      },
+      select: {
+        offset: {
+          lineBreaks: true,
+          match: /\s*offset\s*:\s*\d+\s*/u,
+          value: (src) => src.split(":")[1].trim()
+        },
+        case: {
+          lineBreaks: true,
+          match: /\s*(?:=\d+|[^\p{Pat_Syn}\p{Pat_WS}]+)\s*\{/u,
+          push: "body",
+          value: (src) => src.substring(0, src.indexOf("{")).trim()
+        },
+        end: { match: /\s*\}/u, pop: 1 }
+      }
+    };
+    exports2.lexer = moo_1.default.states(exports2.states);
+  }
+});
+
+// node_modules/@messageformat/parser/lib/parser.js
+var require_parser = __commonJS({
+  "node_modules/@messageformat/parser/lib/parser.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.ParseError = void 0;
+    exports2.parse = parse2;
+    var lexer_js_1 = require_lexer();
+    var getContext = (lt) => ({
+      offset: lt.offset,
+      line: lt.line,
+      col: lt.col,
+      text: lt.text,
+      lineBreaks: lt.lineBreaks
+    });
+    var isSelectType = (type) => type === "plural" || type === "select" || type === "selectordinal";
+    function strictArgStyleParam(lt, param) {
+      let value = "";
+      let text = "";
+      for (const p of param) {
+        const pText = p.ctx.text;
+        text += pText;
+        switch (p.type) {
+          case "content":
+            value += p.value;
+            break;
+          case "argument":
+          case "function":
+          case "octothorpe":
+            value += pText;
+            break;
+          default:
+            throw new ParseError(lt, `Unsupported part in strict mode function arg style: ${pText}`);
+        }
+      }
+      const c = {
+        type: "content",
+        value: value.trim(),
+        ctx: Object.assign({}, param[0].ctx, { text })
+      };
+      return [c];
+    }
+    var strictArgTypes = [
+      "number",
+      "date",
+      "time",
+      "spellout",
+      "ordinal",
+      "duration"
+    ];
+    var defaultPluralKeys = ["zero", "one", "two", "few", "many", "other"];
+    var ParseError = class extends Error {
+      /** @internal */
+      constructor(lt, msg) {
+        super(lexer_js_1.lexer.formatError(lt, msg));
+      }
+    };
+    exports2.ParseError = ParseError;
+    var Parser = class {
+      constructor(src, opt) {
+        var _a, _b, _c, _d;
+        this.lexer = lexer_js_1.lexer.reset(src);
+        this.cardinalKeys = (_a = opt === null || opt === void 0 ? void 0 : opt.cardinal) !== null && _a !== void 0 ? _a : defaultPluralKeys;
+        this.ordinalKeys = (_b = opt === null || opt === void 0 ? void 0 : opt.ordinal) !== null && _b !== void 0 ? _b : defaultPluralKeys;
+        this.strict = (_c = opt === null || opt === void 0 ? void 0 : opt.strict) !== null && _c !== void 0 ? _c : false;
+        this.strictPluralKeys = (_d = opt === null || opt === void 0 ? void 0 : opt.strictPluralKeys) !== null && _d !== void 0 ? _d : true;
+      }
+      parse() {
+        return this.parseBody(false, true);
+      }
+      checkSelectKey(lt, type, key) {
+        if (key[0] === "=") {
+          if (type === "select") {
+            throw new ParseError(lt, `The case ${key} is not valid with select`);
+          }
+        } else if (type !== "select") {
+          const keys = type === "plural" ? this.cardinalKeys : this.ordinalKeys;
+          if (this.strictPluralKeys && keys.length > 0 && !keys.includes(key)) {
+            const msg = `The ${type} case ${key} is not valid in this locale`;
+            throw new ParseError(lt, msg);
+          }
+        }
+      }
+      parseSelect({ value: arg }, inPlural, ctx, type) {
+        const sel = { type, arg, cases: [], ctx };
+        if (type === "plural" || type === "selectordinal")
+          inPlural = true;
+        else if (this.strict)
+          inPlural = false;
+        for (const lt of this.lexer) {
+          switch (lt.type) {
+            case "offset":
+              if (type === "select") {
+                throw new ParseError(lt, "Unexpected plural offset for select");
+              }
+              if (sel.cases.length > 0) {
+                throw new ParseError(lt, "Plural offset must be set before cases");
+              }
+              sel.pluralOffset = Number(lt.value);
+              ctx.text += lt.text;
+              ctx.lineBreaks += lt.lineBreaks;
+              break;
+            case "case": {
+              this.checkSelectKey(lt, type, lt.value);
+              sel.cases.push({
+                key: lt.value,
+                tokens: this.parseBody(inPlural),
+                ctx: getContext(lt)
+              });
+              break;
+            }
+            case "end":
+              return sel;
+            /* istanbul ignore next: never happens */
+            default:
+              throw new ParseError(lt, `Unexpected lexer token: ${lt.type}`);
+          }
+        }
+        throw new ParseError(null, "Unexpected message end");
+      }
+      parseArgToken(lt, inPlural) {
+        const ctx = getContext(lt);
+        const argType = this.lexer.next();
+        if (!argType)
+          throw new ParseError(null, "Unexpected message end");
+        ctx.text += argType.text;
+        ctx.lineBreaks += argType.lineBreaks;
+        if (this.strict && (argType.type === "func-simple" || argType.type === "func-args") && !strictArgTypes.includes(argType.value)) {
+          const msg = `Invalid strict mode function arg type: ${argType.value}`;
+          throw new ParseError(lt, msg);
+        }
+        switch (argType.type) {
+          case "end":
+            return { type: "argument", arg: lt.value, ctx };
+          case "func-simple": {
+            const end = this.lexer.next();
+            if (!end)
+              throw new ParseError(null, "Unexpected message end");
+            if (end.type !== "end") {
+              throw new ParseError(end, `Unexpected lexer token: ${end.type}`);
+            }
+            ctx.text += end.text;
+            if (isSelectType(argType.value.toLowerCase())) {
+              throw new ParseError(argType, `Invalid type identifier: ${argType.value}`);
+            }
+            return {
+              type: "function",
+              arg: lt.value,
+              key: argType.value,
+              ctx
+            };
+          }
+          case "func-args": {
+            if (isSelectType(argType.value.toLowerCase())) {
+              const msg = `Invalid type identifier: ${argType.value}`;
+              throw new ParseError(argType, msg);
+            }
+            let param = this.parseBody(this.strict ? false : inPlural);
+            if (this.strict && param.length > 0) {
+              param = strictArgStyleParam(lt, param);
+            }
+            return {
+              type: "function",
+              arg: lt.value,
+              key: argType.value,
+              param,
+              ctx
+            };
+          }
+          case "select":
+            if (isSelectType(argType.value)) {
+              return this.parseSelect(lt, inPlural, ctx, argType.value);
+            } else {
+              throw new ParseError(argType, `Unexpected select type ${argType.value}`);
+            }
+          /* istanbul ignore next: never happens */
+          default:
+            throw new ParseError(argType, `Unexpected lexer token: ${argType.type}`);
+        }
+      }
+      parseBody(inPlural, atRoot) {
+        const tokens = [];
+        let content = null;
+        for (const lt of this.lexer) {
+          if (lt.type === "argument") {
+            if (content)
+              content = null;
+            tokens.push(this.parseArgToken(lt, inPlural));
+          } else if (lt.type === "octothorpe" && inPlural) {
+            if (content)
+              content = null;
+            tokens.push({ type: "octothorpe", ctx: getContext(lt) });
+          } else if (lt.type === "end" && !atRoot) {
+            return tokens;
+          } else {
+            let value = lt.value;
+            if (!inPlural && lt.type === "quoted" && value[0] === "#") {
+              if (value.includes("{")) {
+                const errMsg = `Unsupported escape pattern: ${value}`;
+                throw new ParseError(lt, errMsg);
+              }
+              value = lt.text;
+            }
+            if (content) {
+              content.value += value;
+              content.ctx.text += lt.text;
+              content.ctx.lineBreaks += lt.lineBreaks;
+            } else {
+              content = { type: "content", value, ctx: getContext(lt) };
+              tokens.push(content);
+            }
+          }
+        }
+        if (atRoot)
+          return tokens;
+        throw new ParseError(null, "Unexpected message end");
+      }
+    };
+    function parse2(src, options = {}) {
+      const parser = new Parser(src, options);
+      return parser.parse();
+    }
+  }
+});
+
 // node_modules/prop-types/node_modules/react-is/cjs/react-is.production.min.js
 var require_react_is_production_min = __commonJS({
   "node_modules/prop-types/node_modules/react-is/cjs/react-is.production.min.js"(exports2) {
@@ -549,13 +1390,13 @@ var require_factoryWithTypeCheckers = __commonJS({
               err.name = "Invariant Violation";
               throw err;
             } else if (process.env.NODE_ENV !== "production" && typeof console !== "undefined") {
-              var cacheKey = componentName + ":" + propName;
-              if (!manualPropTypeCallCache[cacheKey] && // Avoid spamming the console because they are often not actionable except for lib authors
+              var cacheKey2 = componentName + ":" + propName;
+              if (!manualPropTypeCallCache[cacheKey2] && // Avoid spamming the console because they are often not actionable except for lib authors
               manualPropTypeWarningCount < 3) {
                 printWarning(
                   "You are manually calling a React.PropTypes validation function for the `" + propFullName + "` prop on `" + componentName + "`. This is deprecated and will throw in the standalone `prop-types` package. You may be seeing this warning due to a third-party PropTypes library. See https://fb.me/react-warning-dont-call-proptypes for details."
                 );
-                manualPropTypeCallCache[cacheKey] = true;
+                manualPropTypeCallCache[cacheKey2] = true;
                 manualPropTypeWarningCount++;
               }
             }
@@ -999,7 +1840,7 @@ module.exports = __toCommonJS(index_exports);
 
 // src/components/AppHeader/AppHeader.tsx
 var import_react = require("@carbon/react");
-var import_link = __toESM(require("next/link"));
+var import_next = require("enjanga-core-setup/next");
 var import_jsx_runtime = require("react/jsx-runtime");
 var AppHeader = ({
   brand,
@@ -1022,7 +1863,7 @@ var AppHeader = ({
             isActive: isSideNavExpanded
           }
         ),
-        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react.HeaderName, { prefix: "", as: import_link.default, href: brandRoute, passHref: true, children: brand }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react.HeaderName, { prefix: "", as: import_next.Link, href: brandRoute, passHref: true, children: brand }),
         /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react.HeaderNavigation, { "aria-label": brandLabel, children: navigation }),
         /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
           import_react.SideNav,
@@ -1112,42 +1953,1711 @@ var BrandLogo = ({
         className,
         style,
         value,
-        role
+        role
+      }
+    );
+  }
+  if (import_react2.default.isValidElement(value)) {
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+      BrandLogoComponents,
+      {
+        className,
+        style,
+        value,
+        alt,
+        role
+      }
+    );
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+    BrandLogoFallback,
+    {
+      className,
+      style,
+      value,
+      role
+    }
+  );
+};
+var BrandLogo_default = BrandLogo;
+
+// src/components/Banner/Banner.tsx
+var import_clsx5 = __toESM(require("clsx"));
+
+// src/components/FeatureText/FeatureText.tsx
+var import_clsx4 = __toESM(require("clsx"));
+
+// node_modules/@contentful/rich-text-types/dist/esm/blocks.js
+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;
+})({});
+
+// node_modules/@contentful/rich-text-types/dist/esm/inlines.js
+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;
+})({});
+
+// node_modules/@contentful/rich-text-types/dist/esm/marks.js
+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;
+})({});
+
+// node_modules/@contentful/rich-text-types/dist/esm/schemaConstraints.js
+function _array_like_to_array(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+function _array_without_holes(arr) {
+  if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _define_property(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _iterable_to_array(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+  return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _array_like_to_array(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(n);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+var 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
+];
+var 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
+];
+var TABLE_BLOCKS = [
+  BLOCKS.TABLE,
+  BLOCKS.TABLE_ROW,
+  BLOCKS.TABLE_CELL,
+  BLOCKS.TABLE_HEADER_CELL
+];
+var VOID_BLOCKS = [
+  BLOCKS.HR,
+  BLOCKS.EMBEDDED_ENTRY,
+  BLOCKS.EMBEDDED_ASSET,
+  BLOCKS.EMBEDDED_RESOURCE
+];
+var _obj;
+var CONTAINERS = (_obj = {}, _define_property(_obj, BLOCKS.OL_LIST, [
+  BLOCKS.LIST_ITEM
+]), _define_property(_obj, BLOCKS.UL_LIST, [
+  BLOCKS.LIST_ITEM
+]), _define_property(_obj, BLOCKS.LIST_ITEM, LIST_ITEM_BLOCKS), _define_property(_obj, BLOCKS.QUOTE, [
+  BLOCKS.PARAGRAPH
+]), _define_property(_obj, BLOCKS.TABLE, [
+  BLOCKS.TABLE_ROW
+]), _define_property(_obj, BLOCKS.TABLE_ROW, [
+  BLOCKS.TABLE_CELL,
+  BLOCKS.TABLE_HEADER_CELL
+]), _define_property(_obj, BLOCKS.TABLE_CELL, [
+  BLOCKS.PARAGRAPH,
+  BLOCKS.UL_LIST,
+  BLOCKS.OL_LIST
+]), _define_property(_obj, BLOCKS.TABLE_HEADER_CELL, [
+  BLOCKS.PARAGRAPH
+]), _obj);
+var HEADINGS = [
+  BLOCKS.HEADING_1,
+  BLOCKS.HEADING_2,
+  BLOCKS.HEADING_3,
+  BLOCKS.HEADING_4,
+  BLOCKS.HEADING_5,
+  BLOCKS.HEADING_6
+];
+var TEXT_CONTAINERS = [
+  BLOCKS.PARAGRAPH
+].concat(_to_consumable_array(HEADINGS));
+var V1_NODE_TYPES = [
+  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"
+];
+var V1_MARKS = [
+  MARKS.BOLD,
+  MARKS.CODE,
+  MARKS.ITALIC,
+  MARKS.UNDERLINE
+];
+
+// node_modules/@contentful/rich-text-types/dist/esm/emptyDocument.js
+var EMPTY_DOCUMENT = {
+  nodeType: BLOCKS.DOCUMENT,
+  data: {},
+  content: [
+    {
+      nodeType: BLOCKS.PARAGRAPH,
+      data: {},
+      content: [
+        {
+          nodeType: "text",
+          value: "",
+          marks: [],
+          data: {}
+        }
+      ]
+    }
+  ]
+};
+
+// node_modules/@contentful/rich-text-types/dist/esm/validator/assert.js
+var import_is_plain_obj = __toESM(require_is_plain_obj());
+
+// node_modules/@lingui/message-utils/dist/compileMessage.mjs
+var import_parser = __toESM(require_parser(), 1);
+var DateFormatError = class extends Error {
+  /** @internal */
+  constructor(msg, token, type) {
+    super(msg);
+    this.token = token;
+    this.type = type || "error";
+  }
+};
+var alpha = (width) => width < 4 ? "short" : width === 4 ? "long" : "narrow";
+var numeric = (width) => width % 2 === 0 ? "2-digit" : "numeric";
+function yearOptions(token, onError) {
+  switch (token.char) {
+    case "y":
+      return { year: numeric(token.width) };
+    case "r":
+      return { calendar: "gregory", year: "numeric" };
+    case "u":
+    case "U":
+    case "Y":
+    default:
+      onError(`${token.desc} is not supported; falling back to year:numeric`, DateFormatError.WARNING);
+      return { year: "numeric" };
+  }
+}
+function monthStyle(token, onError) {
+  switch (token.width) {
+    case 1:
+      return "numeric";
+    case 2:
+      return "2-digit";
+    case 3:
+      return "short";
+    case 4:
+      return "long";
+    case 5:
+      return "narrow";
+    default:
+      onError(`${token.desc} is not supported with width ${token.width}`);
+      return void 0;
+  }
+}
+function dayStyle(token, onError) {
+  const { char, desc, width } = token;
+  if (char === "d") {
+    return numeric(width);
+  } else {
+    onError(`${desc} is not supported`);
+    return void 0;
+  }
+}
+function weekdayStyle(token, onError) {
+  const { char, desc, width } = token;
+  if ((char === "c" || char === "e") && width < 3) {
+    const msg = `Numeric value is not supported for ${desc}; falling back to weekday:short`;
+    onError(msg, DateFormatError.WARNING);
+  }
+  return alpha(width);
+}
+function hourOptions(token) {
+  const hour = numeric(token.width);
+  let hourCycle;
+  switch (token.char) {
+    case "h":
+      hourCycle = "h12";
+      break;
+    case "H":
+      hourCycle = "h23";
+      break;
+    case "k":
+      hourCycle = "h24";
+      break;
+    case "K":
+      hourCycle = "h11";
+      break;
+  }
+  return hourCycle ? { hour, hourCycle } : { hour };
+}
+function timeZoneNameStyle(token, onError) {
+  const { char, desc, width } = token;
+  switch (char) {
+    case "v":
+    case "z":
+      return width === 4 ? "long" : "short";
+    case "V":
+      if (width === 4)
+        return "long";
+      onError(`${desc} is not supported with width ${width}`);
+      return void 0;
+    case "X":
+      onError(`${desc} is not supported`);
+      return void 0;
+  }
+  return "short";
+}
+function compileOptions(token, onError) {
+  switch (token.field) {
+    case "era":
+      return { era: alpha(token.width) };
+    case "year":
+      return yearOptions(token, onError);
+    case "month":
+      return { month: monthStyle(token, onError) };
+    case "day":
+      return { day: dayStyle(token, onError) };
+    case "weekday":
+      return { weekday: weekdayStyle(token, onError) };
+    case "period":
+      return void 0;
+    case "hour":
+      return hourOptions(token);
+    case "min":
+      return { minute: numeric(token.width) };
+    case "sec":
+      return { second: numeric(token.width) };
+    case "tz":
+      return { timeZoneName: timeZoneNameStyle(token, onError) };
+    case "quarter":
+    case "week":
+    case "sec-frac":
+    case "ms":
+      onError(`${token.desc} is not supported`);
+  }
+  return void 0;
+}
+function getDateFormatOptions(tokens, timeZone, onError = (error) => {
+  throw error;
+}) {
+  const options = {
+    timeZone
+  };
+  const fields2 = [];
+  for (const token of tokens) {
+    const { error, field, str } = token;
+    if (error) {
+      const dte = new DateFormatError(error.message, token);
+      dte.stack = error.stack;
+      onError(dte);
+    }
+    if (str) {
+      const msg = `Ignoring string part: ${str}`;
+      onError(new DateFormatError(msg, token, DateFormatError.WARNING));
+    }
+    if (field) {
+      if (fields2.indexOf(field) === -1)
+        fields2.push(field);
+      else
+        onError(new DateFormatError(`Duplicate ${field} token`, token));
+    }
+    const opt = compileOptions(token, (msg, isWarning) => onError(new DateFormatError(msg, token, isWarning)));
+    if (opt)
+      Object.assign(options, opt);
+  }
+  return options;
+}
+var fields = {
+  G: { field: "era", desc: "Era" },
+  y: { field: "year", desc: "Year" },
+  Y: { field: "year", desc: 'Year of "Week of Year"' },
+  u: { field: "year", desc: "Extended year" },
+  U: { field: "year", desc: "Cyclic year name" },
+  r: { field: "year", desc: "Related Gregorian year" },
+  Q: { field: "quarter", desc: "Quarter" },
+  q: { field: "quarter", desc: "Stand-alone quarter" },
+  M: { field: "month", desc: "Month in year" },
+  L: { field: "month", desc: "Stand-alone month in year" },
+  w: { field: "week", desc: "Week of year" },
+  W: { field: "week", desc: "Week of month" },
+  d: { field: "day", desc: "Day in month" },
+  D: { field: "day", desc: "Day of year" },
+  F: { field: "day", desc: "Day of week in month" },
+  g: { field: "day", desc: "Modified julian day" },
+  E: { field: "weekday", desc: "Day of week" },
+  e: { field: "weekday", desc: "Local day of week" },
+  c: { field: "weekday", desc: "Stand-alone local day of week" },
+  a: { field: "period", desc: "AM/PM marker" },
+  b: { field: "period", desc: "AM/PM/noon/midnight marker" },
+  B: { field: "period", desc: "Flexible day period" },
+  h: { field: "hour", desc: "Hour in AM/PM (1~12)" },
+  H: { field: "hour", desc: "Hour in day (0~23)" },
+  k: { field: "hour", desc: "Hour in day (1~24)" },
+  K: { field: "hour", desc: "Hour in AM/PM (0~11)" },
+  j: { field: "hour", desc: "Hour in preferred cycle" },
+  J: { field: "hour", desc: "Hour in preferred cycle without marker" },
+  C: { field: "hour", desc: "Hour in preferred cycle with flexible marker" },
+  m: { field: "min", desc: "Minute in hour" },
+  s: { field: "sec", desc: "Second in minute" },
+  S: { field: "sec-frac", desc: "Fractional second" },
+  A: { field: "ms", desc: "Milliseconds in day" },
+  z: { field: "tz", desc: "Time Zone: specific non-location" },
+  Z: { field: "tz", desc: "Time Zone" },
+  O: { field: "tz", desc: "Time Zone: localized" },
+  v: { field: "tz", desc: "Time Zone: generic non-location" },
+  V: { field: "tz", desc: "Time Zone: ID" },
+  X: { field: "tz", desc: "Time Zone: ISO8601 with Z" },
+  x: { field: "tz", desc: "Time Zone: ISO8601" }
+};
+var isLetter = (char) => char >= "A" && char <= "Z" || char >= "a" && char <= "z";
+function readFieldToken(src, pos) {
+  const char = src[pos];
+  let width = 1;
+  while (src[++pos] === char)
+    ++width;
+  const field = fields[char];
+  if (!field) {
+    const msg = `The letter ${char} is not a valid field identifier`;
+    return { char, error: new Error(msg), width };
+  }
+  return { char, field: field.field, desc: field.desc, width };
+}
+function readQuotedToken(src, pos) {
+  let str = src[++pos];
+  let width = 2;
+  if (str === "'")
+    return { char: "'", str, width };
+  while (true) {
+    const next = src[++pos];
+    ++width;
+    if (next === void 0) {
+      const msg = `Unterminated quoted literal in pattern: ${str || src}`;
+      return { char: "'", error: new Error(msg), str, width };
+    } else if (next === "'") {
+      if (src[++pos] !== "'")
+        return { char: "'", str, width };
+      else
+        ++width;
+    }
+    str += next;
+  }
+}
+function readToken(src, pos) {
+  const char = src[pos];
+  if (!char)
+    return null;
+  if (isLetter(char))
+    return readFieldToken(src, pos);
+  if (char === "'")
+    return readQuotedToken(src, pos);
+  let str = char;
+  let width = 1;
+  while (true) {
+    const next = src[++pos];
+    if (!next || isLetter(next) || next === "'")
+      return { char, str, width };
+    str += next;
+    width += 1;
+  }
+}
+function parseDateTokens(src) {
+  const tokens = [];
+  let pos = 0;
+  while (true) {
+    const token = readToken(src, pos);
+    if (!token)
+      return tokens;
+    tokens.push(token);
+    pos += token.width;
+  }
+}
+function processTokens(tokens, mapText) {
+  if (!tokens.filter((token) => token.type !== "content").length) {
+    return tokens.map((token) => mapText(token.value));
+  }
+  return tokens.map((token) => {
+    if (token.type === "content") {
+      return mapText(token.value);
+    } else if (token.type === "octothorpe") {
+      return "#";
+    } else if (token.type === "argument") {
+      return [token.arg];
+    } else if (token.type === "function") {
+      const _param = token?.param?.[0];
+      if (token.key === "date" && _param) {
+        const opts = compileDateExpression(_param.value.trim(), (e) => {
+          throw new Error(`Unable to compile date expression: ${e.message}`);
+        });
+        return [token.arg, token.key, opts];
+      }
+      if (_param) {
+        return [token.arg, token.key, _param.value.trim()];
+      } else {
+        return [token.arg, token.key];
+      }
+    }
+    const offset = token.pluralOffset;
+    const formatProps = {};
+    token.cases.forEach(({ key, tokens: tokens2 }) => {
+      const prop = key[0] === "=" ? key.slice(1) : key;
+      formatProps[prop] = processTokens(tokens2, mapText);
+    });
+    return [
+      token.arg,
+      token.type,
+      {
+        offset,
+        ...formatProps
+      }
+    ];
+  });
+}
+function compileDateExpression(format, onError) {
+  if (/^::/.test(format)) {
+    const tokens = parseDateTokens(format.substring(2));
+    return getDateFormatOptions(tokens, void 0, onError);
+  }
+  return format;
+}
+function compileMessageOrThrow(message, mapText = (v) => v) {
+  return processTokens((0, import_parser.parse)(message), mapText);
+}
+function compileMessage(message, mapText = (v) => v) {
+  try {
+    return compileMessageOrThrow(message, mapText);
+  } catch (e) {
+    console.error(`${e.message} 
+
+Message: ${message}`);
+    return [message];
+  }
+}
+
+// node_modules/@lingui/core/dist/index.mjs
+var isString = (s) => typeof s === "string";
+var isFunction = (f) => typeof f === "function";
+var cache = /* @__PURE__ */ new Map();
+var defaultLocale = "en";
+function normalizeLocales(locales) {
+  const out = Array.isArray(locales) ? locales : [locales];
+  return [...out, defaultLocale];
+}
+function date(locales, value, format) {
+  const _locales = normalizeLocales(locales);
+  if (!format) {
+    format = "default";
+  }
+  let o;
+  if (typeof format === "string") {
+    o = {
+      day: "numeric",
+      month: "short",
+      year: "numeric"
+    };
+    switch (format) {
+      case "full":
+        o.weekday = "long";
+      case "long":
+        o.month = "long";
+        break;
+      case "short":
+        o.month = "numeric";
+        break;
+    }
+  } else {
+    o = format;
+  }
+  const formatter = getMemoized(
+    () => cacheKey("date", _locales, format),
+    () => new Intl.DateTimeFormat(_locales, o)
+  );
+  return formatter.format(isString(value) ? new Date(value) : value);
+}
+function time(locales, value, format) {
+  let o;
+  if (!format) {
+    format = "default";
+  }
+  if (typeof format === "string") {
+    o = {
+      second: "numeric",
+      minute: "numeric",
+      hour: "numeric"
+    };
+    switch (format) {
+      case "full":
+      case "long":
+        o.timeZoneName = "short";
+        break;
+      case "short":
+        delete o.second;
+    }
+  } else {
+    o = format;
+  }
+  return date(locales, value, o);
+}
+function number(locales, value, format) {
+  const _locales = normalizeLocales(locales);
+  const formatter = getMemoized(
+    () => cacheKey("number", _locales, format),
+    () => new Intl.NumberFormat(_locales, format)
+  );
+  return formatter.format(value);
+}
+function plural(locales, ordinal, value, { offset = 0, ...rules }) {
+  const _locales = normalizeLocales(locales);
+  const plurals = ordinal ? getMemoized(
+    () => cacheKey("plural-ordinal", _locales),
+    () => new Intl.PluralRules(_locales, { type: "ordinal" })
+  ) : getMemoized(
+    () => cacheKey("plural-cardinal", _locales),
+    () => new Intl.PluralRules(_locales, { type: "cardinal" })
+  );
+  return rules[value] ?? rules[plurals.select(value - offset)] ?? rules.other;
+}
+function getMemoized(getKey, construct) {
+  const key = getKey();
+  let formatter = cache.get(key);
+  if (!formatter) {
+    formatter = construct();
+    cache.set(key, formatter);
+  }
+  return formatter;
+}
+function cacheKey(type, locales, options) {
+  const localeKey = locales.join("-");
+  return `${type}-${localeKey}-${JSON.stringify(options)}`;
+}
+var ESCAPE_SEQUENCE_REGEX = /\\u[a-fA-F0-9]{4}|\\x[a-fA-F0-9]{2}/;
+var decodeEscapeSequences = (str) => {
+  return str.replace(
+    // Same pattern but with capturing groups for extracting values during replacement
+    /\\u([a-fA-F0-9]{4})|\\x([a-fA-F0-9]{2})/g,
+    (_, unicode, hex) => {
+      if (unicode) {
+        const codePoint = parseInt(unicode, 16);
+        return String.fromCharCode(codePoint);
+      } else {
+        const codePoint = parseInt(hex, 16);
+        return String.fromCharCode(codePoint);
+      }
+    }
+  );
+};
+var OCTOTHORPE_PH = "%__lingui_octothorpe__%";
+var getDefaultFormats = (locale, passedLocales, formats = {}) => {
+  const locales = passedLocales || locale;
+  const style = (format) => {
+    if (typeof format === "object")
+      return format;
+    return formats[format];
+  };
+  const replaceOctothorpe = (value, message) => {
+    const numberFormat = Object.keys(formats).length ? style("number") : void 0;
+    const valueStr = number(locales, value, numberFormat);
+    return message.replace(new RegExp(OCTOTHORPE_PH, "g"), valueStr);
+  };
+  return {
+    plural: (value, cases) => {
+      const { offset = 0 } = cases;
+      const message = plural(locales, false, value, cases);
+      return replaceOctothorpe(value - offset, message);
+    },
+    selectordinal: (value, cases) => {
+      const { offset = 0 } = cases;
+      const message = plural(locales, true, value, cases);
+      return replaceOctothorpe(value - offset, message);
+    },
+    select: selectFormatter,
+    number: (value, format) => number(
+      locales,
+      value,
+      style(format) || { style: format }
+    ),
+    date: (value, format) => date(locales, value, style(format) || format),
+    time: (value, format) => time(locales, value, style(format) || format)
+  };
+};
+var selectFormatter = (value, rules) => rules[value] ?? rules.other;
+function interpolate(translation, locale, locales) {
+  return (values = {}, formats) => {
+    const formatters = getDefaultFormats(locale, locales, formats);
+    const formatMessage = (tokens, replaceOctothorpe = false) => {
+      if (!Array.isArray(tokens))
+        return tokens;
+      return tokens.reduce((message, token) => {
+        if (token === "#" && replaceOctothorpe) {
+          return message + OCTOTHORPE_PH;
+        }
+        if (isString(token)) {
+          return message + token;
+        }
+        const [name, type, format] = token;
+        let interpolatedFormat = {};
+        if (type === "plural" || type === "selectordinal" || type === "select") {
+          Object.entries(format).forEach(
+            ([key, value2]) => {
+              interpolatedFormat[key] = formatMessage(
+                value2,
+                type === "plural" || type === "selectordinal"
+              );
+            }
+          );
+        } else {
+          interpolatedFormat = format;
+        }
+        let value;
+        if (type) {
+          const formatter = formatters[type];
+          value = formatter(values[name], interpolatedFormat);
+        } else {
+          value = values[name];
+        }
+        if (value == null) {
+          return message;
+        }
+        return message + value;
+      }, "");
+    };
+    const result = formatMessage(translation);
+    if (isString(result) && ESCAPE_SEQUENCE_REGEX.test(result)) {
+      return decodeEscapeSequences(result);
+    }
+    if (isString(result))
+      return result;
+    return result ? String(result) : "";
+  };
+}
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var EventEmitter = class {
+  constructor() {
+    __publicField$1(this, "_events", {});
+  }
+  on(event, listener) {
+    var _a;
+    (_a = this._events)[event] ?? (_a[event] = []);
+    this._events[event].push(listener);
+    return () => this.removeListener(event, listener);
+  }
+  removeListener(event, listener) {
+    const maybeListeners = this._getListeners(event);
+    if (!maybeListeners)
+      return;
+    const index = maybeListeners.indexOf(listener);
+    if (~index)
+      maybeListeners.splice(index, 1);
+  }
+  emit(event, ...args) {
+    const maybeListeners = this._getListeners(event);
+    if (!maybeListeners)
+      return;
+    maybeListeners.map((listener) => listener.apply(this, args));
+  }
+  _getListeners(event) {
+    const maybeListeners = this._events[event];
+    return Array.isArray(maybeListeners) ? maybeListeners : false;
+  }
+};
+var __defProp2 = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp2(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);
+  return value;
+};
+var I18n = class extends EventEmitter {
+  constructor(params) {
+    super();
+    __publicField(this, "_locale", "");
+    __publicField(this, "_locales");
+    __publicField(this, "_localeData", {});
+    __publicField(this, "_messages", {});
+    __publicField(this, "_missing");
+    __publicField(this, "_messageCompiler");
+    __publicField(this, "t", this._.bind(this));
+    if (process.env.NODE_ENV !== "production") {
+      this.setMessagesCompiler(compileMessage);
+    }
+    if (params.missing != null)
+      this._missing = params.missing;
+    if (params.messages != null)
+      this.load(params.messages);
+    if (params.localeData != null)
+      this.loadLocaleData(params.localeData);
+    if (typeof params.locale === "string" || params.locales) {
+      this.activate(params.locale ?? defaultLocale, params.locales);
+    }
+  }
+  get locale() {
+    return this._locale;
+  }
+  get locales() {
+    return this._locales;
+  }
+  get messages() {
+    return this._messages[this._locale] ?? {};
+  }
+  /**
+   * @deprecated this has no effect. Please remove this from the code. Deprecated in v4
+   */
+  get localeData() {
+    return this._localeData[this._locale] ?? {};
+  }
+  _loadLocaleData(locale, localeData) {
+    const maybeLocaleData = this._localeData[locale];
+    if (!maybeLocaleData) {
+      this._localeData[locale] = localeData;
+    } else {
+      Object.assign(maybeLocaleData, localeData);
+    }
+  }
+  /**
+   * Registers a `MessageCompiler` to enable the use of uncompiled catalogs at runtime.
+   *
+   * In production builds, the `MessageCompiler` is typically excluded to reduce bundle size.
+   * By default, message catalogs should be precompiled during the build process. However,
+   * if you need to compile catalogs at runtime, you can use this method to set a message compiler.
+   *
+   * Example usage:
+   *
+   * ```ts
+   * import { compileMessage } from "@lingui/message-utils/compileMessage";
+   *
+   * i18n.setMessagesCompiler(compileMessage);
+   * ```
+   */
+  setMessagesCompiler(compiler) {
+    this._messageCompiler = compiler;
+    return this;
+  }
+  /**
+   * @deprecated Plurals automatically used from Intl.PluralRules you can safely remove this call. Deprecated in v4
+   */
+  loadLocaleData(localeOrAllData, localeData) {
+    if (typeof localeOrAllData === "string") {
+      this._loadLocaleData(localeOrAllData, localeData);
+    } else {
+      Object.keys(localeOrAllData).forEach(
+        (locale) => this._loadLocaleData(locale, localeOrAllData[locale])
+      );
+    }
+    this.emit("change");
+  }
+  _load(locale, messages) {
+    const maybeMessages = this._messages[locale];
+    if (!maybeMessages) {
+      this._messages[locale] = messages;
+    } else {
+      Object.assign(maybeMessages, messages);
+    }
+  }
+  load(localeOrMessages, messages) {
+    if (typeof localeOrMessages == "string" && typeof messages === "object") {
+      this._load(localeOrMessages, messages);
+    } else {
+      Object.entries(localeOrMessages).forEach(
+        ([locale, messages2]) => this._load(locale, messages2)
+      );
+    }
+    this.emit("change");
+  }
+  /**
+   * @param options {@link LoadAndActivateOptions}
+   */
+  loadAndActivate({ locale, locales, messages }) {
+    this._locale = locale;
+    this._locales = locales || void 0;
+    this._messages[this._locale] = messages;
+    this.emit("change");
+  }
+  activate(locale, locales) {
+    if (process.env.NODE_ENV !== "production") {
+      if (!this._messages[locale]) {
+        console.warn(`Messages for locale "${locale}" not loaded.`);
+      }
+    }
+    this._locale = locale;
+    this._locales = locales;
+    this.emit("change");
+  }
+  _(id, values, options) {
+    if (!this.locale) {
+      throw new Error(
+        "Lingui: Attempted to call a translation function without setting a locale.\nMake sure to call `i18n.activate(locale)` before using Lingui functions.\nThis issue may also occur due to a race condition in your initialization logic."
+      );
+    }
+    let message = options?.message;
+    if (!id) {
+      id = "";
+    }
+    if (!isString(id)) {
+      values = id.values || values;
+      message = id.message;
+      id = id.id;
+    }
+    const messageForId = this.messages[id];
+    const messageMissing = messageForId === void 0;
+    const missing = this._missing;
+    if (missing && messageMissing) {
+      return isFunction(missing) ? missing(this._locale, id) : missing;
+    }
+    if (messageMissing) {
+      this.emit("missing", { id, locale: this._locale });
+    }
+    let translation = messageForId || message || id;
+    if (isString(translation)) {
+      if (this._messageCompiler) {
+        translation = this._messageCompiler(translation);
+      } else {
+        console.warn(`Uncompiled message detected! Message:
+
+> ${translation}
+
+That means you use raw catalog or your catalog doesn't have a translation for the message and fallback was used.
+ICU features such as interpolation and plurals will not work properly for that message. 
+
+Please compile your catalog first. 
+`);
+      }
+    }
+    if (isString(translation) && ESCAPE_SEQUENCE_REGEX.test(translation))
+      return decodeEscapeSequences(translation);
+    if (isString(translation))
+      return translation;
+    return interpolate(
+      translation,
+      this._locale,
+      this._locales
+    )(values, options?.formats);
+  }
+  date(value, format) {
+    return date(this._locales || this._locale, value, format);
+  }
+  number(value, format) {
+    return number(this._locales || this._locale, value, format);
+  }
+};
+function setupI18n(params = {}) {
+  return new I18n(params);
+}
+var i18n = setupI18n();
+
+// node_modules/@contentful/rich-text-types/dist/esm/validator/errors.js
+function _array_like_to_array2(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+function _array_without_holes2(arr) {
+  if (Array.isArray(arr)) return _array_like_to_array2(arr);
+}
+function _iterable_to_array2(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread2() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array2(arr) {
+  return _array_without_holes2(arr) || _iterable_to_array2(arr) || _unsupported_iterable_to_array2(arr) || _non_iterable_spread2();
+}
+function _unsupported_iterable_to_array2(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _array_like_to_array2(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(n);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array2(o, minLen);
+}
+var typeMismatchError = function(param) {
+  var path = param.path, property = param.property, typeName = param.typeName, value = param.value;
+  return {
+    details: i18n._({
+      id: "RichText.RichTextTypes.Validator.TypeMismatchErrorMessage",
+      message: 'The type of "{property}" is incorrect, expected type: {typeName}',
+      values: {
+        property,
+        typeName
+      }
+    }),
+    name: "type",
+    path: path.toArray(),
+    type: typeName,
+    value
+  };
+};
+var minSizeError = function(param) {
+  var min = param.min, value = param.value, path = param.path;
+  return {
+    name: "size",
+    min,
+    path: path.toArray(),
+    details: i18n._({
+      id: "RichText.RichTextTypes.Validator.MinSizeErrorMessage",
+      message: "Size must be at least {min}",
+      values: {
+        min
+      }
+    }),
+    value
+  };
+};
+var maxSizeError = function(param) {
+  var max = param.max, value = param.value, path = param.path;
+  return {
+    name: "size",
+    max,
+    path: path.toArray(),
+    details: i18n._({
+      id: "RichText.RichTextTypes.Validator.MaxSizeErrorMessage",
+      message: "Size must be at most {max}",
+      values: {
+        max
+      }
+    }),
+    value
+  };
+};
+var enumError = function(param) {
+  var expected = param.expected, value = param.value, path = param.path;
+  return {
+    details: i18n._({
+      id: "RichText.RichTextTypes.Validator.EnumErrorMessage",
+      message: "Value must be one of expected values"
+    }),
+    name: "in",
+    expected: _to_consumable_array2(expected).sort(),
+    path: path.toArray(),
+    value
+  };
+};
+var unknownPropertyError = function(param) {
+  var property = param.property, path = param.path;
+  return {
+    details: i18n._({
+      id: "RichText.RichTextTypes.Validator.UnknownPropertyErrorMessage",
+      message: 'The property "{property}" is not expected',
+      values: {
+        property
+      }
+    }),
+    name: "unexpected",
+    path: path.toArray()
+  };
+};
+var requiredPropertyError = function(param) {
+  var property = param.property, path = param.path;
+  return {
+    details: i18n._({
+      id: "RichText.RichTextTypes.Validator.RequiredPropertyErrorMessage",
+      message: 'The property "{property}" is required here',
+      values: {
+        property
+      }
+    }),
+    name: "required",
+    path: path.toArray()
+  };
+};
+
+// node_modules/@contentful/rich-text-types/dist/esm/validator/assert.js
+function _array_like_to_array3(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+function _array_without_holes3(arr) {
+  if (Array.isArray(arr)) return _array_like_to_array3(arr);
+}
+function _class_call_check(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  return Constructor;
+}
+function _define_property2(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _iterable_to_array3(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread3() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array3(arr) {
+  return _array_without_holes3(arr) || _iterable_to_array3(arr) || _unsupported_iterable_to_array3(arr) || _non_iterable_spread3();
+}
+function _unsupported_iterable_to_array3(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _array_like_to_array3(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(n);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array3(o, minLen);
+}
+var ObjectAssertion = /* @__PURE__ */ (function() {
+  "use strict";
+  function ObjectAssertion2(obj, path) {
+    var _this = this;
+    var _this1 = this;
+    _class_call_check(this, ObjectAssertion2);
+    _define_property2(this, "obj", void 0);
+    _define_property2(this, "path", void 0);
+    _define_property2(this, "_errors", void 0);
+    _define_property2(this, "catch", void 0);
+    _define_property2(this, "exists", void 0);
+    _define_property2(this, "object", void 0);
+    _define_property2(this, "string", void 0);
+    _define_property2(this, "number", void 0);
+    _define_property2(this, "array", void 0);
+    _define_property2(this, "enum", void 0);
+    _define_property2(this, "empty", void 0);
+    _define_property2(this, "minLength", void 0);
+    _define_property2(this, "noAdditionalProperties", void 0);
+    _define_property2(this, "each", void 0);
+    this.obj = obj;
+    this.path = path;
+    this._errors = [];
+    this.catch = function() {
+      for (var _len = arguments.length, errors = new Array(_len), _key = 0; _key < _len; _key++) {
+        errors[_key] = arguments[_key];
+      }
+      var _this__errors;
+      (_this__errors = _this1._errors).push.apply(_this__errors, _to_consumable_array3(errors));
+    };
+    this.exists = function(key) {
+      if (key in _this.obj) {
+        return true;
+      }
+      _this.catch(requiredPropertyError({
+        property: key,
+        path: _this.path.of(key)
+      }));
+      return false;
+    };
+    this.object = function(key) {
+      var value = key ? _this.obj[key] : _this.obj;
+      if (key) {
+        if (!_this.exists(key)) {
+          return false;
+        }
+      }
+      if ((0, import_is_plain_obj.default)(value)) {
+        return true;
+      }
+      var _$path = key ? _this.path.of(key) : _this.path;
+      var _ref;
+      var property = (_ref = key !== null && key !== void 0 ? key : _this.path.last()) !== null && _ref !== void 0 ? _ref : "value";
+      _this.catch(typeMismatchError({
+        typeName: "Object",
+        property,
+        path: _$path,
+        value
+      }));
+      return false;
+    };
+    this.string = function(key) {
+      var 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;
+    };
+    this.number = function(key, optional) {
+      var 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;
+    };
+    this.array = function(key) {
+      var 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;
+    };
+    this.enum = function(key, expected) {
+      var 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;
+    };
+    this.empty = function(key) {
+      if (!_this.array(key)) {
+        return false;
       }
-    );
-  }
-  if (import_react2.default.isValidElement(value)) {
-    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
-      BrandLogoComponents,
-      {
-        className,
-        style,
+      var value = _this.obj[key];
+      if (value.length === 0) {
+        return true;
+      }
+      _this.catch(maxSizeError({
+        max: 0,
         value,
-        alt,
-        role
+        path: _this.path.of(key)
+      }));
+      return false;
+    };
+    this.minLength = function(key, min) {
+      if (!_this.array(key)) {
+        return false;
       }
-    );
+      var value = _this.obj[key];
+      if (value.length >= min) {
+        return true;
+      }
+      _this.catch(minSizeError({
+        min,
+        value,
+        path: _this.path.of(key)
+      }));
+      return false;
+    };
+    this.noAdditionalProperties = function(properties) {
+      var unknowns = Object.keys(_this.obj).sort().filter(function(key) {
+        return !properties.includes(key);
+      });
+      unknowns.forEach(function(property) {
+        return _this.catch(unknownPropertyError({
+          property,
+          path: _this.path.of(property)
+        }));
+      });
+      return unknowns.length === 0;
+    };
+    this.each = function(key, assert2) {
+      if (!_this.array(key)) {
+        return;
+      }
+      var value = _this.obj[key];
+      var foundErrors = false;
+      value.forEach(function(item, index) {
+        if (foundErrors) {
+          return;
+        }
+        var errors = assert2(item, _this.path.of(key).of(index));
+        if (errors.length > 0) {
+          foundErrors = true;
+        }
+        _this.catch.apply(_this, _to_consumable_array3(errors));
+      });
+    };
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
-    BrandLogoFallback,
+  _create_class(ObjectAssertion2, [
     {
-      className,
-      style,
+      key: "errors",
+      get: function get() {
+        var _this = this;
+        var serializeError = function(error) {
+          return JSON.stringify({
+            details: error.details,
+            path: error.path
+          });
+        };
+        return this._errors.filter(function(error, index) {
+          return _this._errors.findIndex(function(step) {
+            return serializeError(error) === serializeError(step);
+          }) === index;
+        });
+      }
+    }
+  ]);
+  return ObjectAssertion2;
+})();
+
+// node_modules/@contentful/rich-text-types/dist/esm/validator/node.js
+function _array_like_to_array4(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+function _array_without_holes4(arr) {
+  if (Array.isArray(arr)) return _array_like_to_array4(arr);
+}
+function _assert_this_initialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+  return self;
+}
+function _call_super(_this, derived, args) {
+  derived = _get_prototype_of(derived);
+  return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check2(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties2(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+function _create_class2(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties2(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties2(Constructor, staticProps);
+  return Constructor;
+}
+function _define_property3(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
       value,
-      role
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _get_prototype_of(o) {
+  _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o2) {
+    return o2.__proto__ || Object.getPrototypeOf(o2);
+  };
+  return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true
     }
-  );
+  });
+  if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _iterable_to_array4(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread4() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _possible_constructor_return(self, call) {
+  if (call && (_type_of(call) === "object" || typeof call === "function")) {
+    return call;
+  }
+  return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+  _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o2, p2) {
+    o2.__proto__ = p2;
+    return o2;
+  };
+  return _set_prototype_of(o, p);
+}
+function _to_consumable_array4(arr) {
+  return _array_without_holes4(arr) || _iterable_to_array4(arr) || _unsupported_iterable_to_array4(arr) || _non_iterable_spread4();
+}
+function _type_of(obj) {
+  "@swc/helpers - typeof";
+  return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array4(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _array_like_to_array4(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(n);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array4(o, minLen);
+}
+function _is_native_reflect_construct() {
+  try {
+    var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+    }));
+  } catch (_) {
+  }
+  return (_is_native_reflect_construct = function() {
+    return !!result;
+  })();
+}
+var VOID_CONTENT = [];
+var NodeAssertion = /* @__PURE__ */ (function() {
+  "use strict";
+  function NodeAssertion2(contentRule, validateData) {
+    _class_call_check2(this, NodeAssertion2);
+    _define_property3(this, "contentRule", void 0);
+    _define_property3(this, "validateData", void 0);
+    this.contentRule = contentRule;
+    this.validateData = validateData;
+  }
+  _create_class2(NodeAssertion2, [
+    {
+      key: "assert",
+      value: function assert2(node, path) {
+        var $ = new ObjectAssertion(node, path);
+        if (!$.object()) {
+          return $.errors;
+        }
+        $.noAdditionalProperties([
+          "nodeType",
+          "data",
+          "content"
+        ]);
+        var _ref = Array.isArray(this.contentRule) ? {
+          nodeTypes: this.contentRule
+        } : this.contentRule(node, path), nodeTypes = _ref.nodeTypes, _ref_min = _ref.min, min = _ref_min === void 0 ? 0 : _ref_min;
+        if (nodeTypes.length === 0 && min > 0) {
+          throw new Error("Invalid content rule. Cannot have enforce a 'min' of ".concat(min, " with no nodeTypes"));
+        }
+        $.minLength("content", min);
+        if (nodeTypes.length === 0) {
+          $.empty("content");
+        } else {
+          $.each("content", function(item, path2) {
+            var item$ = new ObjectAssertion(item, path2);
+            if (!item$.object()) {
+              return item$.errors;
+            }
+            item$.enum("nodeType", nodeTypes);
+            return item$.errors;
+          });
+        }
+        if ($.object("data")) {
+          var _$;
+          var _this_validateData, _this;
+          var _this_validateData1;
+          var dataErrors = (_this_validateData1 = (_this_validateData = (_this = this).validateData) === null || _this_validateData === void 0 ? void 0 : _this_validateData.call(_this, node.data, path.of("data"))) !== null && _this_validateData1 !== void 0 ? _this_validateData1 : [];
+          (_$ = $).catch.apply(_$, _to_consumable_array4(dataErrors));
+        }
+        return $.errors;
+      }
+    }
+  ]);
+  return NodeAssertion2;
+})();
+var EntityLinkAssertion = /* @__PURE__ */ (function(NodeAssertion2) {
+  "use strict";
+  _inherits(EntityLinkAssertion2, NodeAssertion2);
+  function EntityLinkAssertion2(linkType, contentNodeTypes) {
+    _class_call_check2(this, EntityLinkAssertion2);
+    var _this;
+    _this = _call_super(this, EntityLinkAssertion2, [
+      contentNodeTypes,
+      function(data, path) {
+        return _assert_this_initialized(_this).assertLink(data, path);
+      }
+    ]), _define_property3(_this, "linkType", void 0), _define_property3(_this, "type", void 0), _define_property3(_this, "assertLink", void 0), _this.linkType = linkType, _this.assertLink = function(data, path) {
+      var $ = new ObjectAssertion(data, path);
+      if ($.object("target")) {
+        var _$;
+        var 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.apply(_$, _to_consumable_array4(sys$.errors));
+      }
+      $.noAdditionalProperties([
+        "target"
+      ]);
+      return $.errors;
+    };
+    _this.type = _this.linkType.startsWith("Contentful:") ? "ResourceLink" : "Link";
+    return _this;
+  }
+  return EntityLinkAssertion2;
+})(NodeAssertion);
+var HyperLinkAssertion = /* @__PURE__ */ (function(NodeAssertion2) {
+  "use strict";
+  _inherits(HyperLinkAssertion2, NodeAssertion2);
+  function HyperLinkAssertion2() {
+    _class_call_check2(this, HyperLinkAssertion2);
+    var _this;
+    _this = _call_super(this, HyperLinkAssertion2, [
+      [
+        "text"
+      ],
+      function(data, path) {
+        return _assert_this_initialized(_this).assertLink(data, path);
+      }
+    ]), _define_property3(_this, "assertLink", function(data, path) {
+      var $ = new ObjectAssertion(data, path);
+      $.string("uri");
+      $.noAdditionalProperties([
+        "uri"
+      ]);
+      return $.errors;
+    });
+    return _this;
+  }
+  return HyperLinkAssertion2;
+})(NodeAssertion);
+var assert = function(contentRule, validateData) {
+  return new NodeAssertion(contentRule, validateData);
+};
+var assertLink = function(linkType, contentRule) {
+  return new EntityLinkAssertion(linkType, contentRule);
 };
-var BrandLogo_default = BrandLogo;
-
-// src/components/Banner/Banner.tsx
-var import_clsx5 = __toESM(require("clsx"));
 
-// src/components/FeatureText/FeatureText.tsx
-var import_clsx4 = __toESM(require("clsx"));
+// node_modules/@contentful/rich-text-types/dist/esm/validator/index.js
+function _array_like_to_array5(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+function _array_without_holes5(arr) {
+  if (Array.isArray(arr)) return _array_like_to_array5(arr);
+}
+function _define_property4(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _iterable_to_array5(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread5() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array5(arr) {
+  return _array_without_holes5(arr) || _iterable_to_array5(arr) || _unsupported_iterable_to_array5(arr) || _non_iterable_spread5();
+}
+function _unsupported_iterable_to_array5(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _array_like_to_array5(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(n);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array5(o, minLen);
+}
+var assertInlineOrText = assert(_to_consumable_array5(Object.values(INLINES)).concat([
+  "text"
+]).sort());
+var assertList = assert([
+  BLOCKS.LIST_ITEM
+]);
+var assertVoidEntryLink = assertLink("Entry", VOID_CONTENT);
+var assertTableCell = assert(function() {
+  return {
+    nodeTypes: [
+      BLOCKS.PARAGRAPH
+    ],
+    min: 1
+  };
+}, function(data, path) {
+  var $ = new ObjectAssertion(data, path);
+  $.noAdditionalProperties([
+    "colspan",
+    "rowspan"
+  ]);
+  $.number("colspan", true);
+  $.number("rowspan", true);
+  return $.errors;
+});
+var _obj2;
+var nodeValidator = (_obj2 = {}, _define_property4(_obj2, BLOCKS.DOCUMENT, assert(TOP_LEVEL_BLOCKS)), _define_property4(_obj2, BLOCKS.PARAGRAPH, assertInlineOrText), _define_property4(_obj2, BLOCKS.HEADING_1, assertInlineOrText), _define_property4(_obj2, BLOCKS.HEADING_2, assertInlineOrText), _define_property4(_obj2, BLOCKS.HEADING_3, assertInlineOrText), _define_property4(_obj2, BLOCKS.HEADING_4, assertInlineOrText), _define_property4(_obj2, BLOCKS.HEADING_5, assertInlineOrText), _define_property4(_obj2, BLOCKS.HEADING_6, assertInlineOrText), _define_property4(_obj2, BLOCKS.QUOTE, assert(CONTAINERS[BLOCKS.QUOTE])), _define_property4(_obj2, BLOCKS.EMBEDDED_ENTRY, assertVoidEntryLink), _define_property4(_obj2, BLOCKS.EMBEDDED_ASSET, assertLink("Asset", VOID_CONTENT)), _define_property4(_obj2, BLOCKS.EMBEDDED_RESOURCE, assertLink("Contentful:Entry", VOID_CONTENT)), _define_property4(_obj2, BLOCKS.HR, assert(VOID_CONTENT)), _define_property4(_obj2, BLOCKS.OL_LIST, assertList), _define_property4(_obj2, BLOCKS.UL_LIST, assertList), _define_property4(_obj2, BLOCKS.LIST_ITEM, assert(_to_consumable_array5(LIST_ITEM_BLOCKS).sort())), _define_property4(_obj2, BLOCKS.TABLE, assert(function() {
+  return {
+    nodeTypes: [
+      BLOCKS.TABLE_ROW
+    ],
+    min: 1
+  };
+})), _define_property4(_obj2, BLOCKS.TABLE_ROW, assert(function() {
+  return {
+    nodeTypes: [
+      BLOCKS.TABLE_CELL,
+      BLOCKS.TABLE_HEADER_CELL
+    ],
+    min: 1
+  };
+})), _define_property4(_obj2, BLOCKS.TABLE_CELL, assertTableCell), _define_property4(_obj2, BLOCKS.TABLE_HEADER_CELL, assertTableCell), _define_property4(_obj2, INLINES.HYPERLINK, new HyperLinkAssertion()), _define_property4(_obj2, INLINES.EMBEDDED_ENTRY, assertVoidEntryLink), _define_property4(_obj2, INLINES.EMBEDDED_RESOURCE, assertLink("Contentful:Entry", VOID_CONTENT)), _define_property4(_obj2, INLINES.ENTRY_HYPERLINK, assertLink("Entry", [
+  "text"
+])), _define_property4(_obj2, INLINES.ASSET_HYPERLINK, assertLink("Asset", [
+  "text"
+])), _define_property4(_obj2, INLINES.RESOURCE_HYPERLINK, assertLink("Contentful:Entry", [
+  "text"
+])), _obj2);
 
 // src/utils/renderContentfulNode.tsx
-var import_rich_text_types = require("@contentful/rich-text-types");
 var import_jsx_runtime3 = require("react/jsx-runtime");
 var isExternalLink = (url) => {
   const appDomain = "enjanga.com";
@@ -1155,48 +3665,48 @@ var isExternalLink = (url) => {
 };
 var renderContentfulNode = (node, key, options = {}) => {
   switch (node.nodeType) {
-    case import_rich_text_types.BLOCKS.PARAGRAPH: {
+    case BLOCKS.PARAGRAPH: {
       const paragraph = node;
       return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { children: paragraph.content.map(
         (child, i) => renderContentfulNode(child, `${key}-p-${i}`, options)
       ) }, key);
     }
-    case import_rich_text_types.BLOCKS.HEADING_1:
-    case import_rich_text_types.BLOCKS.HEADING_2:
-    case import_rich_text_types.BLOCKS.HEADING_3: {
-      const HeadingTag = node.nodeType === import_rich_text_types.BLOCKS.HEADING_1 ? "h1" : node.nodeType === import_rich_text_types.BLOCKS.HEADING_2 ? "h2" : "h3";
+    case BLOCKS.HEADING_1:
+    case BLOCKS.HEADING_2:
+    case BLOCKS.HEADING_3: {
+      const HeadingTag = node.nodeType === BLOCKS.HEADING_1 ? "h1" : node.nodeType === BLOCKS.HEADING_2 ? "h2" : "h3";
       const heading = node;
       return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(HeadingTag, { children: heading.content.map(
         (child, i) => renderContentfulNode(child, `${key}-h-${i}`, options)
       ) }, key);
     }
-    case import_rich_text_types.BLOCKS.UL_LIST: {
+    case BLOCKS.UL_LIST: {
       const list = node;
       return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("ul", { children: list.content.map(
         (child, i) => renderContentfulNode(child, `${key}-ul-${i}`, options)
       ) }, key);
     }
-    case import_rich_text_types.BLOCKS.OL_LIST: {
+    case BLOCKS.OL_LIST: {
       const list = node;
       return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("ol", { children: list.content.map(
         (child, i) => renderContentfulNode(child, `${key}-ol-${i}`, options)
       ) }, key);
     }
-    case import_rich_text_types.BLOCKS.LIST_ITEM: {
+    case BLOCKS.LIST_ITEM: {
       const listItem = node;
       return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("li", { children: listItem.content.map(
         (child, i) => renderContentfulNode(child, `${key}-li-${i}`, options)
       ) }, key);
     }
-    case import_rich_text_types.BLOCKS.QUOTE: {
+    case BLOCKS.QUOTE: {
       const blockquote = node;
       return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("blockquote", { children: blockquote.content.map(
         (child, i) => renderContentfulNode(child, `${key}-quote-${i}`, options)
       ) }, key);
     }
-    case import_rich_text_types.BLOCKS.HR:
+    case BLOCKS.HR:
       return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("hr", {}, key);
-    case import_rich_text_types.BLOCKS.EMBEDDED_ASSET: {
+    case BLOCKS.EMBEDDED_ASSET: {
       const assetId = node.data?.target?.sys?.id || "";
       const asset = options.assets?.[assetId];
       if (!asset) return null;
@@ -1205,7 +3715,7 @@ var renderContentfulNode = (node, key, options = {}) => {
         asset.title && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("figcaption", { children: asset.title })
       ] }, key);
     }
-    case import_rich_text_types.INLINES.HYPERLINK: {
+    case INLINES.HYPERLINK: {
       const link = node;
       const uri = link.data.uri;
       const isExternal = isExternalLink(uri);
@@ -1234,13 +3744,13 @@ var renderContentfulNode = (node, key, options = {}) => {
       if (textNode.marks?.length) {
         textNode.marks.forEach((mark) => {
           switch (mark.type) {
-            case import_rich_text_types.MARKS.BOLD:
+            case MARKS.BOLD:
               textElement = /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("strong", { children: textElement }, `${key}-bold`);
               break;
-            case import_rich_text_types.MARKS.ITALIC:
+            case MARKS.ITALIC:
               textElement = /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("em", { children: textElement }, `${key}-italic`);
               break;
-            case import_rich_text_types.MARKS.UNDERLINE:
+            case MARKS.UNDERLINE:
               textElement = /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("u", { children: textElement }, `${key}-underline`);
               break;
           }
@@ -1559,7 +4069,7 @@ var Banner_default = Banner;
 var import_react14 = require("react");
 var import_react15 = require("@carbon/react");
 
-// node_modules/@carbon/icons-react/node_modules/@carbon/icon-helpers/es/index.js
+// node_modules/@carbon/icon-helpers/es/index.js
 function _defineProperty(e, r, t) {
   return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
     value: t,
@@ -6903,7 +9413,7 @@ var BookmarkFilled = /* @__PURE__ */ import_react7.default.forwardRef(function B
 if (process.env.NODE_ENV !== "production") {
   BookmarkFilled.propTypes = iconPropTypes;
 }
-var Boolean = /* @__PURE__ */ import_react7.default.forwardRef(function Boolean2({
+var Boolean2 = /* @__PURE__ */ import_react7.default.forwardRef(function Boolean3({
   children,
   size = 16,
   ...rest
@@ -6925,7 +9435,7 @@ var Boolean = /* @__PURE__ */ import_react7.default.forwardRef(function Boolean2
   })), children);
 });
 if (process.env.NODE_ENV !== "production") {
-  Boolean.propTypes = iconPropTypes;
+  Boolean2.propTypes = iconPropTypes;
 }
 var Boot = /* @__PURE__ */ import_react7.default.forwardRef(function Boot2({
   children,
@@ -21056,8 +23566,308 @@ var ContactButton_default = ContactButton;
 // src/components/CustomPictogram/CustomPictogram.tsx
 var import_clsx6 = __toESM(require("clsx"));
 
-// src/components/CustomPictogram/libs/helpers.tsx
-var import_pictograms_react = require("@carbon/pictograms-react");
+// node_modules/@carbon/pictograms-react/es/Icon.js
+var import_prop_types3 = __toESM(require_prop_types());
+var import_react16 = __toESM(require("react"));
+var Icon3 = /* @__PURE__ */ import_react16.default.forwardRef(function Icon4({
+  className,
+  children,
+  tabIndex,
+  xmlns = "http://www.w3.org/2000/svg",
+  preserveAspectRatio = "xMidYMid meet",
+  ...rest
+}, ref) {
+  const {
+    tabindex,
+    ...attrs
+  } = getAttributes({
+    ...rest,
+    tabindex: tabIndex
+  });
+  const props = attrs;
+  if (className) {
+    props.className = className;
+  }
+  if (tabindex !== void 0 && tabindex !== null) {
+    if (typeof tabindex === "number") {
+      props.tabIndex = tabindex;
+    } else {
+      props.tabIndex = Number(tabIndex);
+    }
+  }
+  if (ref) {
+    props.ref = ref;
+  }
+  if (xmlns) {
+    props.xmlns = xmlns;
+  }
+  if (preserveAspectRatio) {
+    props.preserveAspectRatio = preserveAspectRatio;
+  }
+  return /* @__PURE__ */ import_react16.default.createElement("svg", props, children);
+});
+Icon3.displayName = "Icon";
+Icon3.propTypes = {
+  "aria-hidden": import_prop_types3.default.oneOfType([import_prop_types3.default.bool, import_prop_types3.default.oneOf(["true", "false"])]),
+  "aria-label": import_prop_types3.default.string,
+  "aria-labelledby": import_prop_types3.default.string,
+  children: import_prop_types3.default.node,
+  className: import_prop_types3.default.string,
+  height: import_prop_types3.default.oneOfType([import_prop_types3.default.number, import_prop_types3.default.string]),
+  preserveAspectRatio: import_prop_types3.default.string,
+  tabIndex: import_prop_types3.default.oneOfType([import_prop_types3.default.number, import_prop_types3.default.string]),
+  viewBox: import_prop_types3.default.string,
+  width: import_prop_types3.default.oneOfType([import_prop_types3.default.number, import_prop_types3.default.string]),
+  xmlns: import_prop_types3.default.string
+};
+
+// node_modules/@carbon/pictograms-react/es/_rollupPluginBabelHelpers-CuCmpz4u.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);
+}
+
+// node_modules/@carbon/pictograms-react/es/__generated__/bucket-0.js
+var import_react17 = __toESM(require("react"));
+var _path547;
+var _path687;
+var _path1487;
+var AppDeveloper = /* @__PURE__ */ import_react17.default.forwardRef(function AppDeveloper2({ children, ...rest }, ref) {
+  return /* @__PURE__ */ import_react17.default.createElement(Icon3, _extends({ width: 64, height: 64, viewBox: "0 0 32 32", xmlns: "http://www.w3.org/2000/svg", fill: "currentColor", ref }, rest), _path547 || (_path547 = /* @__PURE__ */ import_react17.default.createElement("path", { d: "M3.254,9.254L2.746,8.746L3.991,7.5L2.746,6.254l0.509-0.509L5.009,7.5L3.254,9.254z M3,2	C2.724,2,2.5,2.224,2.5,2.5S2.724,3,3,3s0.5-0.224,0.5-0.5S3.276,2,3,2z M5.5,2.5C5.5,2.776,5.276,3,5,3S4.5,2.776,4.5,2.5	S4.724,2,5,2S5.5,2.224,5.5,2.5z M7.5,2.5C7.5,2.776,7.276,3,7,3S6.5,2.776,6.5,2.5S6.724,2,7,2S7.5,2.224,7.5,2.5z M18.5,6.5	C18.5,6.776,18.276,7,18,7s-0.5-0.224-0.5-0.5S17.724,6,18,6S18.5,6.224,18.5,6.5z M20.5,6.5C20.5,6.776,20.276,7,20,7	s-0.5-0.224-0.5-0.5S19.724,6,20,6S20.5,6.224,20.5,6.5z M22.5,6.5C22.5,6.776,22.276,7,22,7s-0.5-0.224-0.5-0.5S21.724,6,22,6	S22.5,6.224,22.5,6.5z M5.5,24.5C5.5,24.776,5.276,25,5,25s-0.5-0.224-0.5-0.5S4.724,24,5,24S5.5,24.224,5.5,24.5z M13,14.36H1	c-0.199,0-0.36-0.161-0.36-0.36V1c0-0.199,0.161-0.36,0.36-0.36h12c0.199,0,0.36,0.161,0.36,0.36v13	C13.36,14.199,13.199,14.36,13,14.36z M12.64,4.36H1.36v9.28h11.28C12.64,13.64,12.64,4.36,12.64,4.36z M12.64,1.36H1.36v2.281	h11.28C12.64,3.641,12.64,1.36,12.64,1.36z M31.36,5v17c0,0.199-0.161,0.36-0.36,0.36H19.691c-0.301,0.471-0.69,0.885-1.152,1.215	c2.875,1.05,4.819,3.778,4.819,6.902l0.002,0.521L22.639,31l-0.002-0.522c0-3.078-2.09-5.729-5.083-6.45	c-0.15-0.035-0.26-0.163-0.274-0.316s0.07-0.299,0.211-0.361c1.315-0.592,2.165-1.9,2.165-3.334c0-2.017-1.64-3.657-3.656-3.657	c-2.018,0-3.66,1.64-3.66,3.657c0,1.434,0.85,2.742,2.166,3.334c0.141,0.062,0.225,0.208,0.211,0.361s-0.125,0.281-0.274,0.316	c-2.993,0.721-5.084,3.372-5.084,6.449l0.001,0.521L8.64,31l-0.001-0.522c0-3.125,1.943-5.854,4.819-6.903	c-1.138-0.812-1.838-2.134-1.838-3.559c0-2.292,1.772-4.178,4.02-4.362V5c0-0.199,0.161-0.36,0.36-0.36h15	C31.199,4.64,31.36,4.801,31.36,5z M30.64,8.36H16.36v7.295c2.246,0.184,4.017,2.07,4.017,4.362c0,0.566-0.11,1.115-0.315,1.623	H30.64V8.36z M30.64,5.36H16.36v2.28h14.28V5.36z M22,11.64h-4v0.72h4V11.64z M23.64,17.5c0-1.577,1.283-2.86,2.86-2.86	s2.86,1.283,2.86,2.86s-1.283,2.86-2.86,2.86S23.64,19.077,23.64,17.5z M28.242,16.266l-1.383,1.383l-0.004,1.955	c1.01-0.171,1.784-1.046,1.784-2.104C28.64,17.04,28.49,16.615,28.242,16.266z M24.36,17.5c0,1.055,0.769,1.928,1.774,2.103	l0.006-2.253l1.592-1.593c-0.349-0.248-0.773-0.397-1.233-0.397C25.32,15.36,24.36,16.32,24.36,17.5z M8,9.64H5v0.72h3V9.64z M3.5,21.36h3v-0.72h-3V21.36z M3.5,19.36h3v-0.72h-3V19.36z M22,13.64h-4v0.72h4V13.64z M29,11.64h-4v0.72h4V11.64z M29,9.64h-4	v0.72h4V9.64z M22,9.64h-4v0.72h4V9.64z M8.36,17.584v7.832c0,0.521-0.423,0.944-0.944,0.944H2.584	c-0.521,0-0.944-0.424-0.944-0.944v-7.832c0-0.521,0.423-0.944,0.944-0.944h4.832C7.937,16.64,8.36,17.063,8.36,17.584z M7.64,23.36	H2.36v2.056c0,0.123,0.101,0.224,0.224,0.224h4.832c0.124,0,0.224-0.101,0.224-0.224C7.64,25.416,7.64,23.36,7.64,23.36z M7.64,17.584c0-0.123-0.101-0.224-0.224-0.224H2.584c-0.124,0-0.224,0.101-0.224,0.224v5.056h5.28	C7.64,22.64,7.64,17.584,7.64,17.584z" })), children);
+});
+var AssetManagement = /* @__PURE__ */ import_react17.default.forwardRef(function AssetManagement2({ children, ...rest }, ref) {
+  return /* @__PURE__ */ import_react17.default.createElement(Icon3, _extends({ width: 64, height: 64, viewBox: "0 0 32 32", xmlns: "http://www.w3.org/2000/svg", fill: "currentColor", ref }, rest), _path687 || (_path687 = /* @__PURE__ */ import_react17.default.createElement("path", { d: "M13.254,31.255l-0.509-0.51l1-1	c0.057-0.057,0.13-0.093,0.21-0.103l7.32-0.915c0.36-0.045,0.699-0.21,0.954-0.466l6.102-6.103c0.411-0.41,0.411-1.079,0-1.491	c-0.411-0.411-1.081-0.41-1.49,0.001l-6.207,5.046c-0.426,0.404-1.001,0.652-1.634,0.652h-5v-0.721h5	c0.397,0,0.763-0.141,1.048-0.374l-0.004-0.006l0.116-0.095c0.302-0.297,0.488-0.709,0.488-1.163c0-0.354-0.291-0.642-0.648-0.642	h-7.741v-0.721H20c0.755,0,1.369,0.61,1.369,1.36c0,0.063-0.003,0.127-0.008,0.188l4.998-4.061c0.663-0.666,1.79-0.667,2.48,0.024	c0.692,0.692,0.691,1.818,0.001,2.51l-6.102,6.102c-0.368,0.368-0.856,0.607-1.375,0.672l-7.197,0.899L13.254,31.255z M4.255,31.254	l-0.51-0.508l2.904-2.91c0.213-2.925,2.651-5.196,5.61-5.196v0.721c-2.622,0-4.774,2.043-4.9,4.651	c-0.004,0.089-0.042,0.174-0.104,0.236L4.255,31.254z M21,19.36H9c-0.199,0-0.36-0.161-0.36-0.36V4c0-0.199,0.161-0.36,0.36-0.36	h2.64V1c0-0.199,0.161-0.36,0.36-0.36h12c0.199,0,0.36,0.161,0.36,0.36v15c0,0.199-0.161,0.36-0.36,0.36h-2.64V19	C21.36,19.199,21.199,19.36,21,19.36z M9.36,18.64h11.28V8.36H17c-0.199,0-0.36-0.161-0.36-0.36V4.36H9.36V18.64z M21.36,15.64	h2.279V1.36H12.36v2.28H17c0.096,0,0.188,0.038,0.255,0.105l4,4C21.322,7.813,21.36,7.904,21.36,8V15.64z M17.36,7.64h2.771	L17.36,4.869V7.64z M19,15.36h-8v-0.72h8V15.36z M19,13.36h-8v-0.72h8V13.36z M19,11.36h-8v-0.72h8V11.36z" })), children);
+});
+var Carbon = /* @__PURE__ */ import_react17.default.forwardRef(function Carbon2({ children, ...rest }, ref) {
+  return /* @__PURE__ */ import_react17.default.createElement(Icon3, _extends({ width: 64, height: 64, viewBox: "0 0 32 32", xmlns: "http://www.w3.org/2000/svg", fill: "currentColor", ref }, rest), _path1487 || (_path1487 = /* @__PURE__ */ import_react17.default.createElement("path", { d: "M14,31.36c-0.062,0-0.124-0.017-0.18-0.048l-10-5.75	c-0.111-0.064-0.18-0.184-0.18-0.312v-11.5c0-0.129,0.069-0.248,0.18-0.312l10-5.75c0.111-0.064,0.248-0.064,0.359,0l10,5.75	c0.111,0.064,0.181,0.183,0.181,0.312v11.5c0,0.129-0.069,0.248-0.181,0.312l-10,5.75C14.124,31.344,14.062,31.36,14,31.36z M4.36,25.042L14,30.585l9.64-5.543V13.958L14,8.415l-9.64,5.543C4.36,13.958,4.36,25.042,4.36,25.042z M28.36,18h-0.72V6.958	L18,1.415L8.18,7.062L7.82,6.438l10-5.75c0.111-0.064,0.248-0.064,0.359,0l10,5.75C28.29,6.502,28.36,6.621,28.36,6.75	C28.36,6.75,28.36,18,28.36,18z" })), children);
+});
+
+// node_modules/@carbon/pictograms-react/es/__generated__/bucket-1.js
+var import_react18 = __toESM(require("react"));
+var _path920;
+var _path1520;
+var _path1307;
+var CodeExplanation = /* @__PURE__ */ import_react18.default.forwardRef(function CodeExplanation2({
+  children,
+  ...rest
+}, ref) {
+  return /* @__PURE__ */ import_react18.default.createElement(Icon3, _extends({
+    width: 64,
+    height: 64,
+    viewBox: "0 0 32 32",
+    xmlns: "http://www.w3.org/2000/svg",
+    fill: "currentColor",
+    ref
+  }, rest), _path920 || (_path920 = /* @__PURE__ */ import_react18.default.createElement("path", {
+    d: "M27,31.36H5c-0.199,0-0.36-0.161-0.36-0.36	v-4.162C3.232,26.66,2.14,25.455,2.14,24s1.092-2.66,2.5-2.838V17c0-0.199,0.161-0.36,0.36-0.36h1.817	c1.49-2,3.536-3.508,5.732-4.243C10.735,11.249,9.64,9.253,9.64,7c0-3.566,2.793-6.36,6.36-6.36S22.36,3.434,22.36,7	c0,2.253-1.095,4.249-2.909,5.397c2.195,0.734,4.242,2.242,5.731,4.243H27c0.199,0,0.36,0.161,0.36,0.36v4.162	c1.407,0.178,2.5,1.383,2.5,2.838s-1.093,2.66-2.5,2.838V31C27.36,31.199,27.199,31.36,27,31.36z M5.36,30.64h21.28v-3.802	c-1.407-0.178-2.5-1.383-2.5-2.838s1.093-2.66,2.5-2.838V17.36H5.36v3.802c1.408,0.178,2.5,1.383,2.5,2.838s-1.092,2.66-2.5,2.838	V30.64z M27,21.86c-1.18,0-2.14,0.96-2.14,2.14s0.96,2.14,2.14,2.14s2.14-0.96,2.14-2.14S28.18,21.86,27,21.86z M5,21.86	c-1.18,0-2.14,0.96-2.14,2.14S3.82,26.14,5,26.14S7.14,25.18,7.14,24S6.18,21.86,5,21.86z M7.731,16.64H24.27	c-1.558-1.904-3.657-3.27-5.853-3.79c-0.15-0.035-0.261-0.163-0.275-0.316c-0.015-0.154,0.07-0.3,0.211-0.363	C20.381,11.263,21.64,9.281,21.64,7c0-3.163-2.477-5.64-5.64-5.64S10.36,3.838,10.36,7c0,2.281,1.26,4.263,3.288,5.171	c0.141,0.063,0.226,0.209,0.211,0.363c-0.015,0.153-0.125,0.281-0.275,0.316C11.388,13.37,9.289,14.736,7.731,16.64z M14.322,28.161	l-0.644-0.322l4-8l0.645,0.322L14.322,28.161z M19.255,27.255l-0.51-0.51L21.491,24l-2.746-2.745l0.51-0.51L22.509,24L19.255,27.255	z M12.746,27.255L9.491,24l3.255-3.255l0.509,0.51L10.509,24l2.745,2.745L12.746,27.255z"
+  })), children);
+});
+var Collaboration = /* @__PURE__ */ import_react18.default.forwardRef(function Collaboration2({
+  children,
+  ...rest
+}, ref) {
+  return /* @__PURE__ */ import_react18.default.createElement(Icon3, _extends({
+    width: 64,
+    height: 64,
+    viewBox: "0 0 32 32",
+    xmlns: "http://www.w3.org/2000/svg",
+    fill: "currentColor",
+    ref
+  }, rest), _path1520 || (_path1520 = /* @__PURE__ */ import_react18.default.createElement("path", {
+    d: "M1.36,11.318V16H0.64v-4.683c0-2.221,1.342-4.163,3.347-4.969C3.242,5.749,2.79,4.834,2.79,3.85	c0-1.77,1.44-3.21,3.21-3.21s3.21,1.44,3.21,3.21c0,0.984-0.452,1.898-1.197,2.499c2.005,0.806,3.347,2.748,3.347,4.969V16h-0.72	v-4.683c0-2.16-1.467-4.016-3.566-4.514C6.924,6.768,6.813,6.64,6.799,6.487c-0.014-0.154,0.071-0.3,0.212-0.363	c0.899-0.4,1.48-1.293,1.48-2.275c0-1.373-1.117-2.49-2.49-2.49S3.51,2.477,3.51,3.85c0,0.982,0.581,1.875,1.48,2.275	c0.141,0.063,0.226,0.209,0.212,0.362C5.188,6.641,5.077,6.769,4.926,6.804C2.827,7.302,1.36,9.158,1.36,11.318z M28.014,21.349	c0.745-0.601,1.197-1.516,1.197-2.499c0-1.771-1.44-3.21-3.211-3.21s-3.211,1.439-3.211,3.21c0,0.983,0.452,1.898,1.197,2.499	c-2.005,0.806-3.347,2.748-3.347,4.969V31h0.721v-4.683c0-2.16,1.466-4.016,3.565-4.514c0.15-0.036,0.261-0.163,0.275-0.317	c0.015-0.153-0.071-0.3-0.212-0.362c-0.899-0.399-1.479-1.292-1.479-2.274c0-1.373,1.117-2.49,2.49-2.49s2.49,1.117,2.49,2.49	c0,0.982-0.58,1.875-1.479,2.274c-0.141,0.062-0.227,0.209-0.212,0.362c0.015,0.154,0.125,0.281,0.275,0.317	c2.1,0.498,3.565,2.354,3.565,4.514V31h0.721v-4.683C31.36,24.097,30.019,22.154,28.014,21.349z M6.36,23v-5.131l2.386,2.386	l0.509-0.51L6,16.491l-3.254,3.254l0.509,0.51l2.386-2.386V23c0,2.404,1.956,4.36,4.36,4.36h9v-0.72h-9	C7.993,26.64,6.36,25.007,6.36,23z M25.64,8v5.13l-2.385-2.385l-0.51,0.509L26,14.509l3.255-3.255l-0.51-0.509L26.36,13.13V8	c0-2.404-1.956-4.36-4.36-4.36H11v0.72h11C24.007,4.36,25.64,5.993,25.64,8z"
+  })), children);
+});
+var DevicePairing = /* @__PURE__ */ import_react18.default.forwardRef(function DevicePairing2({
+  children,
+  ...rest
+}, ref) {
+  return /* @__PURE__ */ import_react18.default.createElement(Icon3, _extends({
+    width: 64,
+    height: 64,
+    viewBox: "0 0 32 32",
+    xmlns: "http://www.w3.org/2000/svg",
+    fill: "currentColor",
+    ref
+  }, rest), _path1307 || (_path1307 = /* @__PURE__ */ import_react18.default.createElement("path", {
+    d: "M31,29.36h-9c-0.199,0-0.36-0.161-0.36-0.36v-6.64H1v-0.72h20.64v-1.28H4	c-0.75,0-1.36-0.61-1.36-1.36V4c0-0.749,0.61-1.359,1.36-1.36h22c0.75,0,1.36,0.61,1.36,1.36v8.64H31c0.199,0,0.36,0.161,0.36,0.36	v16C31.36,29.199,31.199,29.36,31,29.36z M22.36,28.64h8.279v-2.28H22.36V28.64z M22.36,25.64h8.279V13.36H22.36V25.64z M4,3.36	C3.647,3.361,3.36,3.648,3.36,4v15c0,0.353,0.287,0.64,0.64,0.64h17.64V13c0-0.199,0.161-0.36,0.36-0.36h4.64V4	c0-0.353-0.287-0.64-0.64-0.64C26,3.36,4,3.36,4,3.36z"
+  })), children);
+});
+
+// node_modules/@carbon/pictograms-react/es/__generated__/bucket-2.js
+var import_react19 = __toESM(require("react"));
+var _path707;
+var _path1197;
+var _path2362;
+var Goals = /* @__PURE__ */ import_react19.default.forwardRef(function Goals2({
+  children,
+  ...rest
+}, ref) {
+  return /* @__PURE__ */ import_react19.default.createElement(Icon3, _extends({
+    width: 64,
+    height: 64,
+    viewBox: "0 0 32 32",
+    xmlns: "http://www.w3.org/2000/svg",
+    fill: "currentColor",
+    ref
+  }, rest), _path707 || (_path707 = /* @__PURE__ */ import_react19.default.createElement("path", {
+    d: "M31,10.36h-9.36V1h0.721v8.131l8.385-8.385l0.51,0.509L22.869,9.64H31V10.36z M21.36,16	c0-2.956-2.405-5.36-5.36-5.36c-2.956,0-5.36,2.404-5.36,5.36c0,2.955,2.404,5.36,5.36,5.36C18.955,21.36,21.36,18.955,21.36,16z M20.64,16c0,2.559-2.081,4.64-4.64,4.64s-4.64-2.081-4.64-4.64s2.082-4.64,4.64-4.64S20.64,13.441,20.64,16z M31.36,16	c0-1.353-0.191-2.731-0.569-4.096l-0.693,0.191c0.359,1.303,0.542,2.616,0.542,3.904c0,8.072-6.567,14.64-14.64,14.64	C7.927,30.64,1.36,24.072,1.36,16C1.36,7.927,7.927,1.36,16,1.36c1.287,0,2.601,0.183,3.904,0.543l0.191-0.694	C18.729,0.832,17.352,0.64,16,0.64C7.53,0.64,0.64,7.53,0.64,16S7.53,31.36,16,31.36S31.36,24.47,31.36,16z M26.36,16	c0-1.433-0.292-2.828-0.868-4.144l-0.66,0.288C25.368,13.37,25.64,14.667,25.64,16c0,5.315-4.324,9.64-9.64,9.64	S6.36,21.315,6.36,16S10.685,6.36,16,6.36c1.333,0,2.631,0.272,3.855,0.808l0.289-0.659C18.827,5.932,17.434,5.64,16,5.64	C10.288,5.64,5.64,10.288,5.64,16c0,5.713,4.647,10.36,10.36,10.36S26.36,21.713,26.36,16z M16,15c-0.552,0-1,0.448-1,1s0.448,1,1,1	s1-0.448,1-1S16.552,15,16,15z"
+  })), children);
+});
+var Hills = /* @__PURE__ */ import_react19.default.forwardRef(function Hills2({
+  children,
+  ...rest
+}, ref) {
+  return /* @__PURE__ */ import_react19.default.createElement(Icon3, _extends({
+    width: 64,
+    height: 64,
+    viewBox: "0 0 32 32",
+    xmlns: "http://www.w3.org/2000/svg",
+    fill: "currentColor",
+    ref
+  }, rest), _path1197 || (_path1197 = /* @__PURE__ */ import_react19.default.createElement("path", {
+    d: "M30.192,29.64L16.36,8.891V5.36h4.509l-1.86-1.86l1.86-1.86H15.64v7.251L1.807,29.64H1v0.721h30V29.64H30.192	z M16.36,2.36h2.771l-1.14,1.14l1.14,1.14H16.36V2.36z M2.673,29.64L8,21.649l5.327,7.99L2.673,29.64L2.673,29.64z M14.193,29.64	L8.433,21L12,15.649l9.327,13.991H14.193z M22.192,29.64L12.433,15L16,9.649L29.327,29.64H22.192z"
+  })), children);
+});
+var Leadership = /* @__PURE__ */ import_react19.default.forwardRef(function Leadership2({
+  children,
+  ...rest
+}, ref) {
+  return /* @__PURE__ */ import_react19.default.createElement(Icon3, _extends({
+    width: 64,
+    height: 64,
+    viewBox: "0 0 32 32",
+    xmlns: "http://www.w3.org/2000/svg",
+    fill: "currentColor",
+    ref
+  }, rest), _path2362 || (_path2362 = /* @__PURE__ */ import_react19.default.createElement("path", {
+    d: "M31.36,31h-0.72c0-6.587-4.825-12.394-11.475-13.809	c-0.153-0.032-0.268-0.161-0.283-0.317c-0.016-0.156,0.072-0.304,0.217-0.366c2.91-1.246,4.791-4.095,4.791-7.258	c0-4.351-3.539-7.89-7.89-7.89S8.11,4.9,8.11,9.25c0,3.165,1.881,6.014,4.792,7.258c0.144,0.062,0.232,0.21,0.217,0.366	s-0.13,0.285-0.283,0.317C6.186,18.607,1.36,24.414,1.36,31H0.64c0-6.601,4.604-12.456,11.082-14.275	C9.062,15.203,7.39,12.366,7.39,9.25c0-4.748,3.862-8.61,8.61-8.61s8.61,3.862,8.61,8.61c0,3.116-1.672,5.951-4.333,7.473	C26.755,18.543,31.36,24.398,31.36,31z M19,29.36c-0.072,0-0.146-0.022-0.208-0.066L16,27.319l-2.792,1.975	c-0.127,0.091-0.299,0.089-0.424-0.006c-0.125-0.095-0.175-0.258-0.124-0.406l1.104-3.182l-2.725-1.969	c-0.126-0.092-0.18-0.254-0.131-0.402c0.048-0.149,0.186-0.25,0.342-0.25h3.371l1.037-3.19C15.706,19.74,15.844,19.64,16,19.64l0,0	c0.156,0,0.294,0.101,0.342,0.249l1.037,3.19h3.371c0.156,0,0.295,0.101,0.343,0.25c0.048,0.148-0.005,0.311-0.132,0.402	L18.236,25.7l1.104,3.182c0.052,0.148,0.002,0.312-0.123,0.406C19.152,29.336,19.076,29.36,19,29.36z M16,26.519	c0.073,0,0.146,0.022,0.208,0.066l2.085,1.474l-0.824-2.375c-0.053-0.15,0-0.316,0.129-0.41l2.04-1.474h-2.521	c-0.156,0-0.294-0.101-0.342-0.249L16,21.165l-0.775,2.386c-0.048,0.148-0.187,0.249-0.342,0.249h-2.52l2.04,1.474	c0.129,0.094,0.181,0.26,0.129,0.41l-0.824,2.375l2.084-1.474C15.854,26.541,15.927,26.519,16,26.519z"
+  })), children);
+});
+
+// node_modules/@carbon/pictograms-react/es/__generated__/bucket-3.js
+var import_react20 = __toESM(require("react"));
+var _path2314;
+var _path947;
+var _path11110;
+var _path2017;
+var _path2144;
+var _path2154;
+var _path2452;
+var MagicWand = /* @__PURE__ */ import_react20.default.forwardRef(function MagicWand2({ children, ...rest }, ref) {
+  return /* @__PURE__ */ import_react20.default.createElement(Icon3, _extends({ width: 64, height: 64, viewBox: "0 0 32 32", xmlns: "http://www.w3.org/2000/svg", fill: "currentColor", ref }, rest), _path2314 || (_path2314 = /* @__PURE__ */ import_react20.default.createElement("path", { d: "M3.754,10.246c-0.141-0.141-0.368-0.141-0.509,0	l-1.5,1.5c-0.141,0.141-0.141,0.368,0,0.509l1.5,1.5c0.07,0.07,0.162,0.105,0.254,0.105s0.184-0.035,0.254-0.105l1.5-1.5	c0.141-0.141,0.141-0.368,0-0.509L3.754,10.246z M3.5,12.991L2.509,12L3.5,11.009L4.491,12L3.5,12.991z M4.746,5.254	C4.816,5.325,4.908,5.36,5,5.36s0.184-0.035,0.254-0.105l1.5-1.5c0.141-0.141,0.141-0.368,0-0.509l-1.5-1.5	c-0.141-0.141-0.368-0.141-0.509,0l-1.5,1.5c-0.141,0.141-0.141,0.368,0,0.509L4.746,5.254z M5,2.509L5.991,3.5L5,4.491L4.009,3.5	L5,2.509z M10.972,4.864C11.954,5.109,12.64,5.988,12.64,7c0,0.199,0.161,0.36,0.36,0.36S13.36,7.199,13.36,7	c0-1.012,0.686-1.891,1.729-2.151c0.159-0.04,0.271-0.184,0.271-0.349s-0.112-0.309-0.271-0.349l-0.06-0.015h-0.001	C14.046,3.891,13.36,3.012,13.36,2c0-0.199-0.161-0.36-0.36-0.36S12.64,1.801,12.64,2c0,1.012-0.686,1.891-1.729,2.151	c-0.16,0.041-0.242,0.192-0.241,0.357C10.67,4.673,10.812,4.825,10.972,4.864z M13,3.407c0.246,0.447,0.606,0.826,1.048,1.093	c-0.443,0.268-0.804,0.647-1.05,1.095c-0.245-0.443-0.606-0.82-1.055-1.09C12.39,4.237,12.753,3.857,13,3.407z M10.089,16.151	l-0.06-0.015h-0.001C9.046,15.891,8.36,15.012,8.36,14c0-0.199-0.161-0.36-0.36-0.36S7.64,13.801,7.64,14	c0,1.012-0.686,1.891-1.729,2.151c-0.16,0.041-0.242,0.192-0.241,0.357c0,0.165,0.143,0.316,0.302,0.356	C6.954,17.109,7.64,17.987,7.64,19c0,0.199,0.161,0.36,0.36,0.36S8.36,19.199,8.36,19c0-1.013,0.686-1.891,1.729-2.151	c0.159-0.041,0.271-0.185,0.271-0.349S10.248,16.191,10.089,16.151z M7.999,17.595c-0.245-0.442-0.606-0.819-1.055-1.09	C7.39,16.237,7.753,15.857,8,15.407c0.246,0.447,0.606,0.826,1.048,1.093C8.605,16.768,8.244,17.146,7.999,17.595z M30.255,28.245	l-22-22c-0.141-0.141-0.368-0.141-0.509,0l-1.5,1.5c-0.141,0.141-0.141,0.368,0,0.509l22,22c0.07,0.07,0.163,0.105,0.255,0.105	s0.185-0.035,0.255-0.105l1.5-1.5C30.396,28.614,30.396,28.386,30.255,28.245z M8,7.009l5.741,5.741l-0.991,0.991L7.009,8L8,7.009z M28.5,29.491L13.259,14.25l0.991-0.991L29.491,28.5L28.5,29.491z" })), children);
+});
+var Multitask = /* @__PURE__ */ import_react20.default.forwardRef(function Multitask2({ children, ...rest }, ref) {
+  return /* @__PURE__ */ import_react20.default.createElement(Icon3, _extends({ width: 64, height: 64, viewBox: "0 0 32 32", xmlns: "http://www.w3.org/2000/svg", fill: "currentColor", ref }, rest), _path947 || (_path947 = /* @__PURE__ */ import_react20.default.createElement("path", { d: "M23.61,31h-0.72c0-3.114-2.104-5.849-5.115-6.65c-0.145-0.038-0.25-0.162-0.266-0.312	c-0.015-0.149,0.064-0.292,0.198-0.358c1.331-0.661,2.157-1.982,2.157-3.449c0-2.132-1.733-3.866-3.864-3.866	s-3.865,1.734-3.865,3.866c0,1.466,0.827,2.788,2.158,3.449c0.134,0.066,0.213,0.209,0.198,0.358s-0.121,0.273-0.266,0.312	C11.213,25.151,9.11,27.886,9.11,31H8.39c0-3.17,1.973-5.984,4.886-7.1c-1.165-0.855-1.861-2.201-1.861-3.67	c0-2.528,2.057-4.585,4.585-4.585s4.585,2.057,4.585,4.585c0,1.469-0.697,2.815-1.861,3.67C21.637,25.016,23.61,27.83,23.61,31z M27,17.36c-2.404,0-4.36-1.956-4.36-4.36S24.596,8.64,27,8.64s4.36,1.956,4.36,4.36S29.404,17.36,27,17.36z M27,9.36	c-2.007,0-3.64,1.633-3.64,3.64s1.633,3.64,3.64,3.64s3.64-1.633,3.64-3.64S29.007,9.36,27,9.36z M5,17.36	c-2.404,0-4.36-1.956-4.36-4.36S2.596,8.64,5,8.64S9.36,10.596,9.36,13S7.404,17.36,5,17.36z M5,9.36c-2.007,0-3.64,1.633-3.64,3.64	S2.993,16.64,5,16.64S8.64,15.007,8.64,13S7.007,9.36,5,9.36z M16,9.36c-2.404,0-4.36-1.956-4.36-4.36S13.596,0.64,16,0.64	S20.36,2.596,20.36,5S18.404,9.36,16,9.36z M16,1.36c-2.007,0-3.64,1.633-3.64,3.64S13.993,8.64,16,8.64S19.64,7.007,19.64,5	S18.007,1.36,16,1.36z" })), children);
+});
+var Networking_04 = /* @__PURE__ */ import_react20.default.forwardRef(function Networking_042({ children, ...rest }, ref) {
+  return /* @__PURE__ */ import_react20.default.createElement(Icon3, _extends({ width: 64, height: 64, viewBox: "0 0 32 32", xmlns: "http://www.w3.org/2000/svg", fill: "currentColor", ref }, rest), _path11110 || (_path11110 = /* @__PURE__ */ import_react20.default.createElement("path", { d: "M13,18.64H1c-0.199,0-0.36,0.161-0.36,0.36v12c0,0.199,0.161,0.36,0.36,0.36h12	c0.199,0,0.36-0.161,0.36-0.36V19C13.36,18.801,13.199,18.64,13,18.64z M12.64,30.64H1.36V19.36h11.28	C12.64,19.36,12.64,30.64,12.64,30.64z M25,0.64c-3.507,0-6.36,2.853-6.36,6.36s2.854,6.36,6.36,6.36s6.36-2.853,6.36-6.36	S28.507,0.64,25,0.64z M25,12.64c-3.11,0-5.64-2.53-5.64-5.64S21.89,1.36,25,1.36S30.64,3.89,30.64,7S28.11,12.64,25,12.64z M9.36,26.5c0-0.615-0.3-1.161-0.761-1.5c0.461-0.339,0.761-0.885,0.761-1.5c0-1.025-0.834-1.86-1.86-1.86H4.641v6.721H7.5	C8.525,28.36,9.36,27.525,9.36,26.5z M5.36,22.36H7.5c0.628,0,1.14,0.511,1.14,1.14s-0.512,1.14-1.14,1.14H5.36V22.36z M5.36,25.36	H7.5c0.628,0,1.14,0.511,1.14,1.14s-0.512,1.14-1.14,1.14H5.36V25.36z M24.64,15h0.721v8c0,1.302-1.059,2.36-2.36,2.36H16.37	l2.214,2.213l-0.51,0.51L14.991,25l3.083-3.083l0.51,0.51L16.37,24.64H23c0.904,0,1.64-0.735,1.64-1.64V15z M17.009,7l-3.083,3.083	l-0.509-0.509l2.214-2.214H9C8.096,7.36,7.36,8.096,7.36,9v8H6.64V9c0-1.301,1.059-2.36,2.36-2.36h6.631l-2.214-2.214l0.509-0.509	L17.009,7z M24.671,3.862l-2.386,6l0.67,0.266l0.705-1.773h2.691l0.705,1.773l0.67-0.266l-2.385-6	C25.341,3.862,24.671,3.862,24.671,3.862z M23.946,7.635l1.06-2.666l1.059,2.666H23.946z" })), children);
+});
+var PoughkeepsieBridge = /* @__PURE__ */ import_react20.default.forwardRef(function PoughkeepsieBridge2({ children, ...rest }, ref) {
+  return /* @__PURE__ */ import_react20.default.createElement(Icon3, _extends({ width: 64, height: 64, viewBox: "0 0 32 32", xmlns: "http://www.w3.org/2000/svg", fill: "currentColor", ref }, rest), _path2017 || (_path2017 = /* @__PURE__ */ import_react20.default.createElement("path", { d: "M22,25.36h-4	c-0.199,0-0.36-0.161-0.36-0.36s0.161-0.36,0.36-0.36h4c0.199,0,0.36,0.161,0.36,0.36S22.199,25.36,22,25.36z M14,25.36h-4	c-0.199,0-0.36-0.161-0.36-0.36s0.161-0.36,0.36-0.36h4c0.199,0,0.36,0.161,0.36,0.36S14.199,25.36,14,25.36z M26,23.36H6	c-0.199,0-0.36-0.161-0.36-0.36S5.801,22.64,6,22.64h20c0.199,0,0.36,0.161,0.36,0.36S26.199,23.36,26,23.36z M30,21.36h-9	c-0.199,0-0.36-0.161-0.36-0.36s0.161-0.36,0.36-0.36h9c0.199,0,0.36,0.161,0.36,0.36S30.199,21.36,30,21.36z M18,21.36h-4	c-0.199,0-0.36-0.161-0.36-0.36s0.161-0.36,0.36-0.36h4c0.199,0,0.36,0.161,0.36,0.36S18.199,21.36,18,21.36z M11,21.36H2	c-0.199,0-0.36-0.161-0.36-0.36S1.801,20.64,2,20.64h9c0.199,0,0.36,0.161,0.36,0.36S11.199,21.36,11,21.36z M25.36,21h-0.72v-1.64	h-1.28V21h-0.72v-8.64h-2.639H20h-0.001h-3.998c-0.001,0-0.002,0-0.003,0h-3.997c-0.001,0-0.002,0-0.003,0H9.36V21H8.64v-1.64H7.36	V21H6.64v-8.77l-2.697-0.87H1v-0.72h2.131L0.746,8.254L1,8V7.64h2.997c0.002,0,0.004,0,0.006,0h3.994c0.002,0,0.004,0,0.006,0h3.996	c0.001,0,0.002,0,0.003,0h3.997c0.001,0,0.002,0,0.003,0H20h0h0.001h3.996c0.002,0,0.004,0,0.006,0h3.994c0.002,0,0.004,0,0.006,0	H31V8l0.255,0.254l-2.386,2.386H31v0.72h-2.943l-2.696,0.87L25.36,21L25.36,21z M23.36,18.64h1.279v-6.28H24l0,0h-0.001H23.36V18.64	z M7.36,18.64h1.28v-6.28H8.001c-0.001,0-0.002,0-0.003,0H7.36V18.64z M20.869,11.64h2.262L22,10.509L20.869,11.64z M16.869,11.64	h2.262L18,10.509L16.869,11.64z M12.869,11.64h2.262L14,10.509L12.869,11.64z M8.869,11.64h2.262L10,10.509L8.869,11.64z M27.64,8.869l-2.759,2.759l2.759-0.89V8.869z M4.36,10.738l2.759,0.89L4.36,8.869V10.738z M18.509,10L20,11.491L21.491,10L20,8.509	L18.509,10z M14.509,10L16,11.491L17.491,10L16,8.509L14.509,10z M10.509,10L12,11.491L13.491,10L12,8.509L10.509,10z M24.36,8.36	v2.771l2.771-2.771H24.36z M22.509,10l1.131,1.131V8.869L22.509,10z M8.36,8.869v2.262L9.491,10L8.36,8.869z M4.869,8.36	l2.771,2.771V8.36H4.869z M28.36,8.36v1.771l1.771-1.771H28.36z M1.869,8.36l1.771,1.771V8.36H1.869z M20.869,8.36L22,9.491	l1.131-1.131C23.131,8.36,20.869,8.36,20.869,8.36z M16.869,8.36L18,9.491l1.131-1.131C19.131,8.36,16.869,8.36,16.869,8.36z M12.869,8.36L14,9.491l1.131-1.131C15.131,8.36,12.869,8.36,12.869,8.36z M8.869,8.36L10,9.491l1.131-1.131	C11.131,8.36,8.869,8.36,8.869,8.36z" })), children);
+});
+var Presentation = /* @__PURE__ */ import_react20.default.forwardRef(function Presentation2({ children, ...rest }, ref) {
+  return /* @__PURE__ */ import_react20.default.createElement(Icon3, _extends({ width: 64, height: 64, viewBox: "0 0 32 32", xmlns: "http://www.w3.org/2000/svg", fill: "currentColor", ref }, rest), _path2144 || (_path2144 = /* @__PURE__ */ import_react20.default.createElement("path", { d: "M21.36,31h-0.72l-0.001-1.572c0-1.952-1.254-3.704-3.121-4.36c-0.136-0.048-0.229-0.171-0.24-0.314	c-0.01-0.143,0.065-0.278,0.193-0.345c1.073-0.559,1.739-1.646,1.739-2.837c0-1.771-1.44-3.211-3.211-3.211s-3.212,1.44-3.212,3.211	c0,1.191,0.667,2.279,1.74,2.838c0.127,0.066,0.203,0.202,0.193,0.345c-0.01,0.144-0.104,0.267-0.239,0.314	c-1.866,0.656-3.12,2.408-3.12,4.359L11.359,31h-0.72v-1.572c0-1.952-1.255-3.704-3.122-4.36c-0.135-0.048-0.229-0.171-0.239-0.314	c-0.01-0.143,0.065-0.278,0.192-0.345c1.073-0.559,1.739-1.646,1.739-2.837c0-1.771-1.441-3.211-3.211-3.211	c-1.771,0-3.212,1.44-3.212,3.211c0,1.191,0.667,2.279,1.74,2.838c0.127,0.066,0.203,0.202,0.193,0.345	c-0.01,0.144-0.104,0.267-0.239,0.314c-1.866,0.656-3.12,2.408-3.12,4.359V31H0.64v-1.572c0-2.022,1.162-3.858,2.954-4.763	c-0.956-0.737-1.527-1.87-1.527-3.094c0-2.168,1.764-3.932,3.932-3.932c2.167,0,3.931,1.764,3.931,3.932	c0,1.223-0.571,2.354-1.526,3.092c1.202,0.607,2.122,1.633,2.596,2.854c0.475-1.22,1.393-2.245,2.595-2.852	c-0.956-0.737-1.527-1.87-1.527-3.094c0-2.168,1.764-3.932,3.932-3.932s3.932,1.764,3.932,3.932c0,1.223-0.571,2.354-1.527,3.092	c1.203,0.607,2.122,1.634,2.597,2.854c0.475-1.221,1.394-2.246,2.595-2.853c-0.956-0.737-1.527-1.87-1.527-3.094	c0-2.168,1.764-3.932,3.932-3.932s3.932,1.764,3.932,3.932c0,1.223-0.571,2.354-1.526,3.092c1.793,0.905,2.956,2.742,2.956,4.765V31	H30.64v-1.572c0-1.952-1.254-3.704-3.121-4.36c-0.136-0.048-0.229-0.171-0.24-0.314c-0.01-0.143,0.065-0.278,0.193-0.345	c1.072-0.559,1.738-1.646,1.738-2.837c0-1.771-1.44-3.211-3.211-3.211s-3.211,1.44-3.211,3.211c0,1.192,0.666,2.279,1.739,2.838	c0.128,0.066,0.203,0.202,0.193,0.345c-0.011,0.144-0.104,0.267-0.24,0.314c-1.866,0.656-3.119,2.408-3.119,4.359L21.36,31z M31,15.36H16v-0.72h14.64V1.36H14.36v6.008h2.679c0.75,0,1.36,0.61,1.36,1.36s-0.61,1.36-1.36,1.36H10.36V15H9.64V9.728	c0-0.199,0.161-0.36,0.36-0.36h7.039c0.353,0,0.64-0.287,0.64-0.64s-0.287-0.64-0.64-0.64H7.616c-0.166,0-0.31-0.113-0.35-0.274	C7.227,7.652,7.303,7.485,7.45,7.408C8.519,6.85,9.184,5.763,9.184,4.572C9.184,2.801,7.755,1.36,6,1.36	c-1.774,0-3.218,1.441-3.218,3.212c0,1.192,0.665,2.279,1.735,2.837C4.644,7.475,4.72,7.611,4.709,7.754	C4.699,7.897,4.605,8.021,4.47,8.068c-1.86,0.656-3.11,2.408-3.11,4.36V15H0.64v-2.572c0-2.022,1.159-3.858,2.945-4.763	c-0.953-0.737-1.523-1.87-1.523-3.093C2.062,2.404,3.829,0.64,6,0.64c2.152,0,3.903,1.764,3.903,3.932	c0,1.069-0.435,2.069-1.181,2.796h4.918V1c0-0.199,0.161-0.36,0.36-0.36h17c0.199,0,0.36,0.161,0.36,0.36v14	C31.36,15.199,31.199,15.36,31,15.36z M26,11.36c-0.897,0-1.741-0.35-2.376-0.984C22.989,9.741,22.64,8.897,22.64,8	s0.35-1.741,0.984-2.375c1.27-1.27,3.482-1.27,4.752,0C29.011,6.259,29.36,7.103,29.36,8s-0.35,1.741-0.984,2.375l0,0l0,0l0,0	C27.741,11.01,26.897,11.36,26,11.36z M25.695,10.623c0.791,0.092,1.601-0.185,2.171-0.756l0,0C28.365,9.368,28.64,8.705,28.64,8	c0-0.58-0.186-1.131-0.528-1.586l-1.787,1.772L25.695,10.623z M23.562,6.984C23.43,7.302,23.36,7.646,23.36,8	c0,0.705,0.274,1.368,0.773,1.867c0.251,0.251,0.545,0.446,0.864,0.577l0.586-2.271L23.562,6.984z M23.928,6.364l2.016,1.185	l1.661-1.646c-1.009-0.775-2.558-0.684-3.471,0.23C24.06,6.207,23.991,6.284,23.928,6.364z M20,5.36h-4V4.64h4V5.36z M21,3.36h-5	V2.64h5V3.36z" })), children);
+});
+var Presenter = /* @__PURE__ */ import_react20.default.forwardRef(function Presenter2({ children, ...rest }, ref) {
+  return /* @__PURE__ */ import_react20.default.createElement(Icon3, _extends({ width: 64, height: 64, viewBox: "0 0 32 32", xmlns: "http://www.w3.org/2000/svg", fill: "currentColor", ref }, rest), _path2154 || (_path2154 = /* @__PURE__ */ import_react20.default.createElement("path", { d: "M16,19.14c-1.298,0-2.519,0.506-3.437,1.424C11.646,21.481,11.14,22.702,11.14,24	s0.506,2.519,1.424,3.437c0.917,0.918,2.138,1.424,3.437,1.424c1.298,0,2.519-0.506,3.437-1.424S20.86,25.298,20.86,24	s-0.506-2.519-1.424-3.437S17.298,19.14,16,19.14z M13.072,21.073c0.782-0.782,1.822-1.213,2.928-1.213	c0.989,0,1.926,0.345,2.672,0.978l-2.729,2.711l-3.319-1.946C12.757,21.415,12.907,21.238,13.072,21.073z M13.072,26.927	C12.291,26.146,11.86,25.105,11.86,24c0-0.625,0.138-1.229,0.398-1.777l3.325,1.95l-0.968,3.73	C14.041,27.7,13.515,27.37,13.072,26.927z M18.927,26.927c-0.945,0.947-2.318,1.377-3.615,1.156l1.012-3.897l2.856-2.837	c0.622,0.742,0.96,1.671,0.96,2.651C20.14,25.105,19.709,26.146,18.927,26.927z M29.86,24c0-1.454-1.094-2.644-2.5-2.824V17	c0-0.199-0.161-0.36-0.36-0.36h-1.817c-1.433-1.915-3.49-3.378-5.761-4.116c1.855-1.171,3.014-3.221,3.014-5.444	c0-3.551-2.89-6.44-6.44-6.44c-3.551,0-6.44,2.889-6.44,6.44c0,2.223,1.158,4.274,3.013,5.445c-2.265,0.736-4.319,2.2-5.75,4.115H5	c-0.199,0-0.36,0.161-0.36,0.36v4.176c-1.406,0.179-2.5,1.37-2.5,2.824s1.094,2.645,2.5,2.824V31c0,0.199,0.161,0.36,0.36,0.36h22	c0.199,0,0.36-0.161,0.36-0.36v-4.176C28.766,26.644,29.86,25.454,29.86,24z M13.608,12.98c0.15-0.035,0.261-0.163,0.275-0.316	c0.015-0.153-0.07-0.299-0.211-0.362c-2.063-0.924-3.397-2.974-3.397-5.221c0-3.154,2.566-5.72,5.72-5.72s5.72,2.566,5.72,5.72	c0,2.247-1.333,4.297-3.397,5.221c-0.141,0.063-0.226,0.209-0.211,0.362c0.015,0.154,0.125,0.281,0.275,0.316	c2.273,0.538,4.381,1.856,5.883,3.66H7.734C9.236,14.835,11.34,13.517,13.608,12.98z M2.86,24c0-1.18,0.96-2.14,2.14-2.14	S7.14,22.82,7.14,24S6.18,26.14,5,26.14S2.86,25.18,2.86,24z M5.36,30.64v-3.816c1.406-0.179,2.5-1.37,2.5-2.824	s-1.094-2.645-2.5-2.824V17.36h21.28v3.816c-1.406,0.179-2.5,1.37-2.5,2.824s1.094,2.644,2.5,2.824v3.816H5.36z M27,26.14	c-1.18,0-2.14-0.96-2.14-2.14s0.96-2.14,2.14-2.14s2.14,0.96,2.14,2.14S28.18,26.14,27,26.14z" })), children);
+});
+var Question = /* @__PURE__ */ import_react20.default.forwardRef(function Question2({ children, ...rest }, ref) {
+  return /* @__PURE__ */ import_react20.default.createElement(Icon3, _extends({ width: 64, height: 64, viewBox: "0 0 32 32", xmlns: "http://www.w3.org/2000/svg", fill: "currentColor", ref }, rest), _path2452 || (_path2452 = /* @__PURE__ */ import_react20.default.createElement("path", { d: "M23.668,29.312l-0.359-0.623c4.522-2.61,7.331-7.473,7.331-12.688c0-8.073-6.567-14.64-14.64-14.64	C7.927,1.36,1.36,7.927,1.36,16c0,5.216,2.81,10.078,7.332,12.688l-0.36,0.623C3.587,26.573,0.64,21.473,0.64,16	C0.64,7.53,7.53,0.64,16,0.64S31.36,7.53,31.36,16C31.36,21.473,28.413,26.573,23.668,29.312z M16.355,23.995h-0.72	c0-3.844,1.823-5.201,3.585-6.515c1.599-1.19,3.108-2.315,3.108-5.41c0-3.308-2.657-5.709-6.319-5.709	c-3.485,0-6.32,2.849-6.32,6.35H8.97c0-3.898,3.158-7.07,7.04-7.07c4.079,0,7.04,2.704,7.04,6.429c0,3.456-1.729,4.743-3.398,5.987	C17.956,19.32,16.355,20.513,16.355,23.995z M16,28.5c-0.552,0-1,0.448-1,1s0.448,1,1,1s1-0.448,1-1S16.552,28.5,16,28.5z" })), children);
+});
+
+// node_modules/@carbon/pictograms-react/es/__generated__/bucket-4.js
+var import_react21 = __toESM(require("react"));
+var _path2094;
+var Teacher = /* @__PURE__ */ import_react21.default.forwardRef(function Teacher2({
+  children,
+  ...rest
+}, ref) {
+  return /* @__PURE__ */ import_react21.default.createElement(Icon3, _extends({
+    width: 64,
+    height: 64,
+    viewBox: "0 0 32 32",
+    xmlns: "http://www.w3.org/2000/svg",
+    fill: "currentColor",
+    ref
+  }, rest), _path2094 || (_path2094 = /* @__PURE__ */ import_react21.default.createElement("path", {
+    d: "M21.813,31.36c-0.582,0-0.888-0.196-1.091-0.326	c-0.242-0.156-0.203-0.156-0.445,0c-0.203,0.13-0.509,0.326-1.091,0.326c-1.523,0-2.546-1.959-2.546-3.789	c0-1.836,0.789-2.932,2.11-2.932c0.501,0,0.804,0.136,1.071,0.254c0.111,0.05,0.211,0.094,0.318,0.126V24	c0-0.199,0.161-0.36,0.36-0.36c0.353,0,0.64-0.287,0.64-0.64h0.721c0,0.625-0.425,1.153-1,1.312v0.708	c0.107-0.032,0.207-0.076,0.318-0.126c0.268-0.118,0.57-0.254,1.071-0.254c1.321,0,2.11,1.096,2.11,2.932	c0,0.569-0.099,1.155-0.283,1.695C23.627,30.577,22.781,31.36,21.813,31.36z M20.5,30.211c0.273,0,0.461,0.12,0.611,0.217	c0.17,0.109,0.331,0.212,0.702,0.212c0.76,0,1.315-0.83,1.582-1.607c0.16-0.465,0.244-0.971,0.244-1.461	c0-0.826-0.181-2.211-1.39-2.211c-0.348,0-0.548,0.089-0.779,0.191c-0.249,0.111-0.532,0.237-0.971,0.237s-0.722-0.126-0.971-0.237	c-0.231-0.103-0.432-0.191-0.779-0.191c-1.209,0-1.39,1.385-1.39,2.211c0,1.448,0.781,3.068,1.826,3.068	c0.371,0,0.532-0.103,0.702-0.212C20.039,30.331,20.227,30.211,20.5,30.211z M31.36,31h-0.72c0-6.432-4.777-12.232-11.359-13.792	c-0.15-0.036-0.261-0.163-0.275-0.317s0.071-0.3,0.212-0.363c2.861-1.274,4.71-4.116,4.71-7.241c0-0.313-0.018-0.623-0.054-0.927	h-3.519c0.004,0.046,0.006,0.093,0.006,0.14c0,1.025-0.835,1.86-1.86,1.86s-1.86-0.834-1.86-1.86c0-0.353-0.287-0.64-0.64-0.64	s-0.64,0.287-0.64,0.64c0,1.025-0.834,1.86-1.86,1.86s-1.86-0.834-1.86-1.86c0-0.047,0.001-0.094,0.005-0.14h-3.52	C8.09,8.664,8.072,8.974,8.072,9.287c0,3.125,1.849,5.967,4.71,7.241c0.141,0.063,0.226,0.209,0.212,0.363s-0.125,0.281-0.275,0.317	C6.137,18.768,1.36,24.568,1.36,31H0.64c0-6.46,4.574-12.312,11.002-14.248c-2.634-1.539-4.29-4.375-4.29-7.465	c0-4.768,3.879-8.647,8.648-8.647c4.768,0,8.647,3.879,8.647,8.647c0,3.089-1.657,5.926-4.291,7.465	C26.785,18.688,31.36,24.54,31.36,31z M18.5,7.36c-0.629,0-1.14,0.512-1.14,1.14s0.511,1.14,1.14,1.14s1.14-0.512,1.14-1.14	S19.129,7.36,18.5,7.36z M13.5,7.36c-0.628,0-1.14,0.512-1.14,1.14s0.512,1.14,1.14,1.14s1.14-0.512,1.14-1.14	S14.128,7.36,13.5,7.36z M20.149,7.64h3.605C22.995,4.057,19.807,1.36,16,1.36S9.004,4.057,8.244,7.64h3.607	c0.311-0.594,0.934-1,1.649-1c0.661,0,1.242,0.346,1.572,0.867c0.486-0.455,1.37-0.455,1.856,0C17.258,6.986,17.84,6.64,18.5,6.64	C19.216,6.64,19.838,7.046,20.149,7.64z"
+  })), children);
+});
+
+// node_modules/@carbon/pictograms-react/es/__generated__/bucket-5.js
+var import_react22 = __toESM(require("react"));
+var _path1521;
+var _path1620;
+var _path637;
+var _path677;
+var TransactionalTrust = /* @__PURE__ */ import_react22.default.forwardRef(function TransactionalTrust2({
+  children,
+  ...rest
+}, ref) {
+  return /* @__PURE__ */ import_react22.default.createElement(Icon3, _extends({
+    width: 64,
+    height: 64,
+    viewBox: "0 0 32 32",
+    xmlns: "http://www.w3.org/2000/svg",
+    fill: "currentColor",
+    ref
+  }, rest), _path1521 || (_path1521 = /* @__PURE__ */ import_react22.default.createElement("path", {
+    d: "M30.082,9.856l-0.66,0.288c0.761,1.74,1.154,3.589,1.2,5.496H13.86v-1.386	c0-1.765-1.042-3.314-2.613-3.996c0.558-0.493,0.893-1.209,0.893-1.978c0-1.456-1.184-2.64-2.64-2.64S6.86,6.824,6.86,8.28	c0,0.768,0.335,1.484,0.893,1.978c-1.57,0.682-2.613,2.231-2.613,3.996v1.386H1.378C1.569,7.855,7.855,1.569,15.64,1.378V13h0.72	V1.381c4.255,0.102,8.152,1.999,10.867,5.26H24v0.72h4.36V3h-0.72v3.015C24.716,2.599,20.539,0.64,16,0.64	C7.53,0.64,0.64,7.53,0.64,16c0,2.136,0.43,4.203,1.278,6.145l0.66-0.289c-0.761-1.739-1.154-3.588-1.2-5.496h29.243	c-0.091,3.722-1.576,7.098-3.954,9.635c-0.37-1.217-1.257-2.224-2.422-2.735c0.56-0.494,0.896-1.211,0.896-1.979	c0-1.456-1.185-2.641-2.641-2.641s-2.641,1.185-2.641,2.641c0,0.768,0.335,1.484,0.894,1.978c-1.57,0.681-2.613,2.23-2.613,3.996	v3.211c-0.584,0.086-1.176,0.141-1.78,0.156V19h-0.72v11.619c-4.255-0.102-8.152-1.998-10.867-5.259H8v-0.72H3.64V29h0.72v-3.017	C7.283,29.401,11.461,31.36,16,31.36c8.47,0,15.36-6.891,15.36-15.36C31.36,13.864,30.93,11.797,30.082,9.856z M18.86,27.254	c0-1.695,1.149-3.15,2.797-3.54c0.15-0.036,0.261-0.163,0.275-0.317c0.015-0.153-0.071-0.299-0.212-0.362	c-0.693-0.309-1.141-0.997-1.141-1.754c0-1.059,0.861-1.92,1.92-1.92s1.92,0.861,1.92,1.92c0,0.757-0.447,1.445-1.141,1.754	c-0.142,0.063-0.227,0.209-0.212,0.362c0.015,0.154,0.125,0.281,0.275,0.317c1.401,0.332,2.47,1.479,2.728,2.884	c-1.968,1.871-4.446,3.207-7.21,3.757L18.86,27.254L18.86,27.254z M5.86,14.254c0-1.694,1.15-3.15,2.797-3.541	c0.15-0.036,0.261-0.163,0.275-0.317c0.014-0.153-0.071-0.299-0.212-0.362C8.027,9.726,7.58,9.037,7.58,8.28	c0-1.059,0.861-1.92,1.92-1.92s1.92,0.861,1.92,1.92c0,0.757-0.448,1.445-1.142,1.753c-0.141,0.063-0.226,0.208-0.212,0.362	s0.125,0.281,0.275,0.317c1.647,0.391,2.798,1.847,2.798,3.541v1.386H5.86V14.254z"
+  })), children);
+});
+var Transform_01 = /* @__PURE__ */ import_react22.default.forwardRef(function Transform_012({
+  children,
+  ...rest
+}, ref) {
+  return /* @__PURE__ */ import_react22.default.createElement(Icon3, _extends({
+    width: 64,
+    height: 64,
+    viewBox: "0 0 32 32",
+    xmlns: "http://www.w3.org/2000/svg",
+    fill: "currentColor",
+    ref
+  }, rest), _path1620 || (_path1620 = /* @__PURE__ */ import_react22.default.createElement("path", {
+    d: "M13,31.36H1c-0.199,0-0.36-0.161-0.36-0.36V19c0-0.199,0.161-0.36,0.36-0.36h12	c0.199,0,0.36,0.161,0.36,0.36v12C13.36,31.199,13.199,31.36,13,31.36z M1.36,30.64h11.28V19.36H1.36V30.64z M25,20.528	c-0.139,0-0.271-0.081-0.33-0.216c-0.079-0.183,0.004-0.395,0.186-0.475c3.514-1.535,5.784-5.004,5.784-8.838	c0-5.315-4.324-9.64-9.64-9.64c-3.833,0-7.303,2.271-8.838,5.784c-0.081,0.182-0.293,0.265-0.474,0.186	c-0.182-0.08-0.266-0.292-0.186-0.474C13.152,3.08,16.88,0.64,21,0.64c5.713,0,10.36,4.647,10.36,10.36	c0,4.12-2.44,7.849-6.216,9.498C25.098,20.519,25.048,20.528,25,20.528z M7.36,16.99c0-0.199-0.161-0.36-0.36-0.36	s-0.36,0.161-0.36,0.36V17c0,0.199,0.161,0.355,0.36,0.355S7.36,17.189,7.36,16.99z M17.089,25.36h-0.021	c-0.199,0-0.36-0.161-0.36-0.36s0.161-0.36,0.36-0.36c0.199,0,0.37,0.161,0.37,0.36S17.288,25.36,17.089,25.36z M19.122,25.36	h-0.021c-0.199,0-0.36-0.161-0.36-0.36s0.161-0.36,0.36-0.36c0.199,0,0.37,0.161,0.37,0.36S19.321,25.36,19.122,25.36z M21.042,24.797c-0.132,0-0.259-0.073-0.322-0.199c-0.089-0.178-0.017-0.395,0.161-0.483c0.163-0.11,0.377-0.062,0.489,0.106	c0.109,0.165,0.055,0.395-0.111,0.505c-0.012,0.008-0.042,0.026-0.056,0.033C21.151,24.784,21.097,24.797,21.042,24.797z M22.459,23.363c-0.069,0-0.139-0.02-0.199-0.061c-0.166-0.11-0.211-0.334-0.101-0.499c0.089-0.18,0.302-0.238,0.477-0.151	c0.178,0.09,0.244,0.316,0.155,0.494c-0.007,0.014-0.024,0.044-0.032,0.056C22.689,23.307,22.575,23.363,22.459,23.363z M23,21.421	c-0.199,0-0.36-0.161-0.36-0.36s0.161-0.37,0.36-0.37s0.36,0.15,0.36,0.35v0.021C23.36,21.26,23.199,21.421,23,21.421z M23,19.382	c-0.199,0-0.36-0.161-0.36-0.36s0.161-0.37,0.36-0.37s0.36,0.151,0.36,0.351v0.02C23.36,19.221,23.199,19.382,23,19.382z M23,17.344	c-0.199,0-0.36-0.161-0.36-0.36c0-0.199,0.161-0.37,0.36-0.37s0.36,0.151,0.36,0.35v0.02C23.36,17.183,23.199,17.344,23,17.344z M7,15.322c-0.199,0-0.36-0.151-0.36-0.35v-0.02c0-0.199,0.161-0.36,0.36-0.36s0.36,0.161,0.36,0.36S7.199,15.322,7,15.322z M23,15.305c-0.199,0-0.36-0.161-0.36-0.36s0.161-0.37,0.36-0.37s0.36,0.151,0.36,0.35v0.02C23.36,15.144,23.199,15.305,23,15.305z M7,13.283c-0.004,0-0.009,0-0.013,0c-0.193-0.007-0.346-0.156-0.346-0.35c0-0.009,0-0.039,0.001-0.048	c0.016-0.197,0.183-0.345,0.387-0.331c0.198,0.015,0.346,0.188,0.331,0.387C7.345,13.129,7.188,13.283,7,13.283z M7.542,11.342	c-0.06,0-0.12-0.015-0.175-0.047c-0.172-0.1-0.235-0.312-0.135-0.483l0.01-0.018c0.101-0.171,0.323-0.229,0.492-0.129	c0.172,0.1,0.23,0.321,0.13,0.492C7.797,11.273,7.67,11.342,7.542,11.342z M22.442,11.329c-0.127,0-0.251-0.068-0.316-0.188	c-0.092-0.169-0.04-0.389,0.125-0.489c0.165-0.099,0.374-0.062,0.48,0.1c0.006,0.009,0.021,0.035,0.027,0.044	c0.095,0.174,0.03,0.393-0.144,0.488C22.56,11.315,22.501,11.329,22.442,11.329z M21.014,9.907c-0.062,0-0.124-0.016-0.182-0.049	c-0.172-0.1-0.238-0.326-0.138-0.498c0.1-0.171,0.311-0.235,0.483-0.135l0.018,0.01c0.172,0.1,0.229,0.321,0.129,0.493	C21.258,9.843,21.137,9.907,21.014,9.907z M8.964,9.561h0.009H8.964z M19.074,9.361c-0.008,0-0.017,0-0.025-0.001	c-0.193-0.014-0.352-0.178-0.345-0.372c0.007-0.202,0.217-0.366,0.396-0.346c0.198,0.014,0.348,0.186,0.334,0.385	C19.42,9.216,19.262,9.361,19.074,9.361z M17.035,9.36c-0.199,0-0.37-0.161-0.37-0.36s0.151-0.36,0.35-0.36h0.021	c0.199,0,0.36,0.161,0.36,0.36S17.234,9.36,17.035,9.36z M14.997,9.36c-0.199,0-0.37-0.161-0.37-0.36s0.151-0.36,0.35-0.36h0.02	c0.199,0,0.36,0.161,0.36,0.36S15.195,9.36,14.997,9.36z M12.958,9.36c-0.199,0-0.37-0.161-0.37-0.36s0.151-0.36,0.35-0.36h0.021	c0.199,0,0.36,0.161,0.36,0.36S13.157,9.36,12.958,9.36z M15.37,25c0-0.199-0.167-0.36-0.365-0.36s-0.36,0.161-0.36,0.36	s0.161,0.36,0.36,0.36h0.01C15.213,25.36,15.37,25.199,15.37,25z M10.905,9.36c-0.199,0-0.37-0.161-0.37-0.36s0.151-0.36,0.35-0.36	h0.021c0.199,0,0.36,0.161,0.36,0.36S11.104,9.36,10.905,9.36z M8.978,9.92c-0.199,0-0.37-0.161-0.37-0.36S8.759,9.2,8.958,9.2	h0.021c0.199,0,0.36,0.161,0.36,0.36S9.177,9.92,8.978,9.92z M23,13.294c-0.199,0-0.36-0.161-0.36-0.36s0.161-0.37,0.36-0.37	s0.36,0.151,0.36,0.35v0.02C23.36,13.133,23.199,13.294,23,13.294z"
+  })), children);
+});
+var User = /* @__PURE__ */ import_react22.default.forwardRef(function User2({
+  children,
+  ...rest
+}, ref) {
+  return /* @__PURE__ */ import_react22.default.createElement(Icon3, _extends({
+    width: 64,
+    height: 64,
+    viewBox: "0 0 32 32",
+    xmlns: "http://www.w3.org/2000/svg",
+    fill: "currentColor",
+    ref
+  }, rest), _path637 || (_path637 = /* @__PURE__ */ import_react22.default.createElement("path", {
+    d: "M31.36,31h-0.72c0-6.432-4.777-12.232-11.359-13.792c-0.15-0.036-0.261-0.163-0.275-0.317	c-0.015-0.153,0.071-0.299,0.212-0.362c2.861-1.273,4.71-4.116,4.71-7.241c0-4.371-3.556-7.927-7.927-7.927	c-4.372,0-7.928,3.556-7.928,7.927c0,3.125,1.849,5.968,4.711,7.241c0.141,0.063,0.226,0.209,0.212,0.362	c-0.014,0.154-0.125,0.281-0.275,0.317C6.137,18.768,1.36,24.568,1.36,31H0.64c0-6.46,4.574-12.312,11.002-14.248	c-2.634-1.539-4.291-4.375-4.291-7.465c0-4.768,3.879-8.647,8.648-8.647c4.768,0,8.647,3.879,8.647,8.647	c0,3.09-1.656,5.926-4.29,7.465C26.786,18.688,31.36,24.54,31.36,31z"
+  })), children);
+});
+var UserInterface = /* @__PURE__ */ import_react22.default.forwardRef(function UserInterface2({
+  children,
+  ...rest
+}, ref) {
+  return /* @__PURE__ */ import_react22.default.createElement(Icon3, _extends({
+    width: 64,
+    height: 64,
+    viewBox: "0 0 32 32",
+    xmlns: "http://www.w3.org/2000/svg",
+    fill: "currentColor",
+    ref
+  }, rest), _path677 || (_path677 = /* @__PURE__ */ import_react22.default.createElement("path", {
+    d: "M29,3.5C29,3.776,28.776,4,28.5,4S28,3.776,28,3.5S28.224,3,28.5,3S29,3.224,29,3.5 M26.5,3	C26.224,3,26,3.224,26,3.5S26.224,4,26.5,4S27,3.776,27,3.5S26.776,3,26.5,3 M24.5,3C24.224,3,24,3.224,24,3.5S24.224,4,24.5,4	S25,3.776,25,3.5S24.776,3,24.5,3 M31,30.36H1c-0.199,0-0.36-0.161-0.36-0.36V2c0-0.199,0.161-0.36,0.36-0.36h30	c0.199,0,0.36,0.161,0.36,0.36v28C31.36,30.199,31.199,30.36,31,30.36z M1.36,29.64h29.28V5.36H1.36V29.64z M1.36,4.64h29.28V2.36	H1.36V4.64z M15,25.36h-5c-0.199,0-0.36-0.161-0.36-0.36v-3c0-0.199,0.161-0.36,0.36-0.36h5c0.199,0,0.36,0.161,0.36,0.36v3	C15.36,25.199,15.199,25.36,15,25.36z M10.36,24.64h4.28v-2.28h-4.28C10.36,22.36,10.36,24.64,10.36,24.64z M22,20.36h-5	c-0.199,0-0.36-0.161-0.36-0.36v-3c0-0.199,0.161-0.36,0.36-0.36h5c0.199,0,0.36,0.161,0.36,0.36v3	C22.36,20.199,22.199,20.36,22,20.36z M17.36,19.64h4.279v-2.28H17.36V19.64z M15,20.36h-5c-0.199,0-0.36-0.161-0.36-0.36v-3	c0-0.199,0.161-0.36,0.36-0.36h5c0.199,0,0.36,0.161,0.36,0.36v3C15.36,20.199,15.199,20.36,15,20.36z M10.36,19.64h4.28v-2.28	h-4.28C10.36,17.36,10.36,19.64,10.36,19.64z M22,15.36h-5c-0.199,0-0.36-0.161-0.36-0.36v-3c0-0.199,0.161-0.36,0.36-0.36h5	c0.199,0,0.36,0.161,0.36,0.36v3C22.36,15.199,22.199,15.36,22,15.36z M17.36,14.64h4.279v-2.28H17.36V14.64z M15,15.36h-5	c-0.199,0-0.36-0.161-0.36-0.36v-3c0-0.199,0.161-0.36,0.36-0.36h5c0.199,0,0.36,0.161,0.36,0.36v3	C15.36,15.199,15.199,15.36,15,15.36z M10.36,14.64h4.28v-2.28h-4.28C10.36,12.36,10.36,14.64,10.36,14.64z M8,15.36H3	c-0.199,0-0.36-0.161-0.36-0.36v-3c0-0.199,0.161-0.36,0.36-0.36h5c0.199,0,0.36,0.161,0.36,0.36v3C8.36,15.199,8.199,15.36,8,15.36	z M3.36,14.64h4.28v-2.28H3.36V14.64z M29,10.36h-5c-0.199,0-0.36-0.161-0.36-0.36V7c0-0.199,0.161-0.36,0.36-0.36h5	c0.199,0,0.36,0.161,0.36,0.36v3C29.36,10.199,29.199,10.36,29,10.36z M24.36,9.64h4.279V7.36H24.36V9.64z M22,10.36h-5	c-0.199,0-0.36-0.161-0.36-0.36V7c0-0.199,0.161-0.36,0.36-0.36h5c0.199,0,0.36,0.161,0.36,0.36v3	C22.36,10.199,22.199,10.36,22,10.36z M17.36,9.64h4.279V7.36H17.36V9.64z M15,10.36h-5c-0.199,0-0.36-0.161-0.36-0.36V7	c0-0.199,0.161-0.36,0.36-0.36h5c0.199,0,0.36,0.161,0.36,0.36v3C15.36,10.199,15.199,10.36,15,10.36z M10.36,9.64h4.28V7.36h-4.28	C10.36,7.36,10.36,9.64,10.36,9.64z M8,10.36H3c-0.199,0-0.36-0.161-0.36-0.36V7c0-0.199,0.161-0.36,0.36-0.36h5	c0.199,0,0.36,0.161,0.36,0.36v3C8.36,10.199,8.199,10.36,8,10.36z M3.36,9.64h4.28V7.36H3.36V9.64z"
+  })), children);
+});
+
+// node_modules/@carbon/pictograms-react/es/index.js
+var import_react23 = require("react");
 
 // src/components/CustomPictogram/libs/types.ts
 var CP_nameOpt = [
@@ -21092,27 +23902,27 @@ var isValidPictogramName = (name) => {
   return name in CP_pictogramMap;
 };
 var CP_pictogramMap = {
-  Question: import_pictograms_react.Question,
-  Hills: import_pictograms_react.Hills,
-  "App Developer": import_pictograms_react.AppDeveloper,
-  Leadership: import_pictograms_react.Leadership,
-  DevicePairing: import_pictograms_react.DevicePairing,
-  CodeExplanation: import_pictograms_react.CodeExplanation,
-  MagicWand: import_pictograms_react.MagicWand,
-  User: import_pictograms_react.User,
-  UserInterface: import_pictograms_react.UserInterface,
-  Collaboration: import_pictograms_react.Collaboration,
-  Presentation: import_pictograms_react.Presentation,
-  Transform_01: import_pictograms_react.Transform_01,
-  Networking_04: import_pictograms_react.Networking_04,
-  Goals: import_pictograms_react.Goals,
-  TransactionalTrust: import_pictograms_react.TransactionalTrust,
-  Teacher: import_pictograms_react.Teacher,
-  Carbon: import_pictograms_react.Carbon,
-  Multitask: import_pictograms_react.Multitask,
-  PoughkeepsieBridge: import_pictograms_react.PoughkeepsieBridge,
-  AssetManagement: import_pictograms_react.AssetManagement,
-  Presenter: import_pictograms_react.Presenter
+  Question,
+  Hills,
+  "App Developer": AppDeveloper,
+  Leadership,
+  DevicePairing,
+  CodeExplanation,
+  MagicWand,
+  User,
+  UserInterface,
+  Collaboration,
+  Presentation,
+  Transform_01,
+  Networking_04,
+  Goals,
+  TransactionalTrust,
+  Teacher,
+  Carbon,
+  Multitask,
+  PoughkeepsieBridge,
+  AssetManagement,
+  Presenter
 };
 var CP_getPictogram = ({
   name
@@ -21159,12 +23969,12 @@ var CustomPictogram = ({ name, size = "md", className }) => {
 var CustomPictogram_default = CustomPictogram;
 
 // src/components/CustomTile/index.ts
-var import_react21 = require("react");
+var import_react29 = require("react");
 
 // src/components/CustomTile/CustomTile.tsx
-var import_react18 = require("react");
-var import_react19 = __toESM(require("react"));
-var import_react20 = require("@carbon/react");
+var import_react26 = require("react");
+var import_react27 = __toESM(require("react"));
+var import_react28 = require("@carbon/react");
 
 // src/components/CustomTile/lib/getCustomTileCSSClasses.tsx
 var import_clsx7 = __toESM(require("clsx"));
@@ -21250,7 +24060,7 @@ var getTileContent = ({
 };
 
 // src/components/ContentModal/ContentModal.tsx
-var import_react16 = require("@carbon/react");
+var import_react24 = require("@carbon/react");
 var import_jsx_runtime16 = require("react/jsx-runtime");
 var ContentModal = ({
   isOpen,
@@ -21266,26 +24076,26 @@ var ContentModal = ({
     setIsOpen(false);
   };
   return /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_jsx_runtime16.Fragment, { children: setIsOpen !== void 0 && /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(
-    import_react16.ComposedModal,
+    import_react24.ComposedModal,
     {
       open: isOpen,
       onClose: handleClose,
       size: "md",
       children: [
         /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
-          import_react16.ModalHeader,
+          import_react24.ModalHeader,
           {
             label: modalLabel,
             title: modalHeading,
             closeModal: handleClose
           }
         ),
-        /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(import_react16.ModalBody, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(import_react24.ModalBody, { children: [
           modalSubHeading && /* @__PURE__ */ (0, import_jsx_runtime16.jsx)("p", { style: { marginBottom: "1rem" }, children: modalSubHeading }),
           children
         ] }),
-        /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_react16.ModalFooter, { children: /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
-          import_react16.Button,
+        /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_react24.ModalFooter, { children: /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
+          import_react24.Button,
           {
             kind: "secondary",
             onClick: () => {
@@ -21324,7 +24134,7 @@ function validateCTL_propsType({
 }
 
 // src/components/CustomTile/lib/getHeadingContent.ts
-var import_react17 = __toESM(require("react"));
+var import_react25 = __toESM(require("react"));
 var getHeadingContent = (featuredText) => stripNonAlphanumeric(featuredText?.heading?.children);
 var stripNonAlphanumeric = (prop) => {
   const extractTextFromNode = (node) => {
@@ -21334,7 +24144,7 @@ var stripNonAlphanumeric = (prop) => {
     if (typeof node === "number" || typeof node === "boolean") {
       return String(node);
     }
-    if (import_react17.default.isValidElement(node)) {
+    if (import_react25.default.isValidElement(node)) {
       if (node.props.children) {
         if (Array.isArray(node.props.children)) {
           return node.props.children.map(extractTextFromNode).join("");
@@ -21414,7 +24224,7 @@ var CustomTile = ({
   linksTo,
   linkTarget = "_self"
 }) => {
-  const [modalIsOpen, setModalIsOpen] = (0, import_react18.useState)(
+  const [modalIsOpen, setModalIsOpen] = (0, import_react26.useState)(
     modalIsAvailable !== void 0 ? false : void 0
   );
   validateCTL_propsType({ linksTo, linkTarget, modalIsAvailable });
@@ -21459,13 +24269,13 @@ var CustomTile = ({
   } = useContainerSize();
   return /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)("div", { className: "enj-CustomTile-wrapper", ref: containerRef, children: [
     /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
-      import_react20.Tile,
+      import_react28.Tile,
       {
         className: `${wrapperClassNames} ${className} enj-CustomTile-${activeBreakpoint}`,
         "aria-label": `${componentTitle} tile`,
         role: ctl_role,
         onClick: () => handleCustomTileClick({ modalIsAvailable, setModalIsOpen }),
-        children: linksTo ? /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(import_jsx_runtime19.Fragment, { children: import_react19.default.cloneElement(LinkWrapper, {}, tileContent) }) : tileContent
+        children: linksTo ? /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(import_jsx_runtime19.Fragment, { children: import_react27.default.cloneElement(LinkWrapper, {}, tileContent) }) : tileContent
       }
     ),
     modalIsAvailable && modalIsOpen !== void 0 && /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
@@ -21489,10 +24299,10 @@ var CustomTile = ({
 var CustomTile_default = CustomTile;
 
 // src/components/CustomTile/index.ts
-var MemoizedCustomTile = (0, import_react21.memo)(CustomTile_default);
+var MemoizedCustomTile = (0, import_react29.memo)(CustomTile_default);
 
 // src/components/HeadlinedList/index.ts
-var import_react22 = require("react");
+var import_react30 = require("react");
 
 // src/components/HeadlinedList/HeadlinedList.tsx
 var import_clsx11 = __toESM(require("clsx"));
@@ -21552,11 +24362,11 @@ var HeadlinedList = ({
 var HeadlinedList_default = HeadlinedList;
 
 // src/components/HeadlinedList/index.ts
-var MemoizedHeadlinedList = (0, import_react22.memo)(HeadlinedList_default);
+var MemoizedHeadlinedList = (0, import_react30.memo)(HeadlinedList_default);
 
 // src/components/List/index.ts
-var import_react23 = require("react");
-var MemoizedList = (0, import_react23.memo)(List_default);
+var import_react31 = require("react");
+var MemoizedList = (0, import_react31.memo)(List_default);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AppHeader,