door_models 0.1.1 → 2.0.0

package/dist/index.cjs.js

@@ -0,0 +1,4288 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var require$$0 = require('react');
+var csg = require('@react-three/csg');
+var three = require('@react-spring/three');
+var THREE = require('three');
+var material = require('@mui/material');
+var iconsMaterial = require('@mui/icons-material');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0);
+var THREE__namespace = /*#__PURE__*/_interopNamespace(THREE);
+
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[r] = t, e;
+}
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function (r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread2(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
+      _defineProperty(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+    });
+  }
+  return e;
+}
+function _objectWithoutProperties(e, t) {
+  if (null == e) return {};
+  var o,
+    r,
+    i = _objectWithoutPropertiesLoose(e, t);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(e);
+    for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
+  }
+  return i;
+}
+function _objectWithoutPropertiesLoose(r, e) {
+  if (null == r) return {};
+  var t = {};
+  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+    if (-1 !== e.indexOf(n)) continue;
+    t[n] = r[n];
+  }
+  return t;
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+
+var jsxRuntime = {exports: {}};
+
+var reactJsxRuntime_production_min = {};
+
+/**
+ * @license React
+ * react-jsx-runtime.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var hasRequiredReactJsxRuntime_production_min;
+
+function requireReactJsxRuntime_production_min () {
+	if (hasRequiredReactJsxRuntime_production_min) return reactJsxRuntime_production_min;
+	hasRequiredReactJsxRuntime_production_min = 1;
+var f=require$$0__default["default"],k=Symbol.for("react.element"),l=Symbol.for("react.fragment"),m=Object.prototype.hasOwnProperty,n=f.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner,p={key:!0,ref:!0,__self:!0,__source:!0};
+	function q(c,a,g){var b,d={},e=null,h=null;void 0!==g&&(e=""+g);void 0!==a.key&&(e=""+a.key);void 0!==a.ref&&(h=a.ref);for(b in a)m.call(a,b)&&!p.hasOwnProperty(b)&&(d[b]=a[b]);if(c&&c.defaultProps)for(b in a=c.defaultProps,a)void 0===d[b]&&(d[b]=a[b]);return {$$typeof:k,type:c,key:e,ref:h,props:d,_owner:n.current}}reactJsxRuntime_production_min.Fragment=l;reactJsxRuntime_production_min.jsx=q;reactJsxRuntime_production_min.jsxs=q;
+	return reactJsxRuntime_production_min;
+}
+
+var reactJsxRuntime_development = {};
+
+/**
+ * @license React
+ * react-jsx-runtime.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var hasRequiredReactJsxRuntime_development;
+
+function requireReactJsxRuntime_development () {
+	if (hasRequiredReactJsxRuntime_development) return reactJsxRuntime_development;
+	hasRequiredReactJsxRuntime_development = 1;
+
+	if (process.env.NODE_ENV !== "production") {
+	  (function() {
+
+	var React = require$$0__default["default"];
+
+	// ATTENTION
+	// When adding new symbols to this file,
+	// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+	// The Symbol used to tag the ReactElement-like types.
+	var REACT_ELEMENT_TYPE = Symbol.for('react.element');
+	var REACT_PORTAL_TYPE = Symbol.for('react.portal');
+	var REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+	var REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
+	var REACT_PROFILER_TYPE = Symbol.for('react.profiler');
+	var REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+	var REACT_CONTEXT_TYPE = Symbol.for('react.context');
+	var REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+	var REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+	var REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+	var REACT_MEMO_TYPE = Symbol.for('react.memo');
+	var REACT_LAZY_TYPE = Symbol.for('react.lazy');
+	var REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen');
+	var MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+	var FAUX_ITERATOR_SYMBOL = '@@iterator';
+	function getIteratorFn(maybeIterable) {
+	  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+	    return null;
+	  }
+
+	  var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+	  if (typeof maybeIterator === 'function') {
+	    return maybeIterator;
+	  }
+
+	  return null;
+	}
+
+	var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+	function error(format) {
+	  {
+	    {
+	      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+	        args[_key2 - 1] = arguments[_key2];
+	      }
+
+	      printWarning('error', format, args);
+	    }
+	  }
+	}
+
+	function printWarning(level, format, args) {
+	  // When changing this logic, you might want to also
+	  // update consoleWithStackDev.www.js as well.
+	  {
+	    var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+	    var stack = ReactDebugCurrentFrame.getStackAddendum();
+
+	    if (stack !== '') {
+	      format += '%s';
+	      args = args.concat([stack]);
+	    } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+	    var argsWithFormat = args.map(function (item) {
+	      return String(item);
+	    }); // Careful: RN currently depends on this prefix
+
+	    argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
+	    // breaks IE9: https://github.com/facebook/react/issues/13610
+	    // eslint-disable-next-line react-internal/no-production-logging
+
+	    Function.prototype.apply.call(console[level], console, argsWithFormat);
+	  }
+	}
+
+	// -----------------------------------------------------------------------------
+
+	var enableScopeAPI = false; // Experimental Create Event Handle API.
+	var enableCacheElement = false;
+	var enableTransitionTracing = false; // No known bugs, but needs performance testing
+
+	var enableLegacyHidden = false; // Enables unstable_avoidThisFallback feature in Fiber
+	// stuff. Intended to enable React core members to more easily debug scheduling
+	// issues in DEV builds.
+
+	var enableDebugTracing = false; // Track which Fiber(s) schedule render work.
+
+	var REACT_MODULE_REFERENCE;
+
+	{
+	  REACT_MODULE_REFERENCE = Symbol.for('react.module.reference');
+	}
+
+	function isValidElementType(type) {
+	  if (typeof type === 'string' || typeof type === 'function') {
+	    return true;
+	  } // Note: typeof might be other than 'symbol' or 'number' (e.g. if it's a polyfill).
+
+
+	  if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || enableDebugTracing  || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || enableLegacyHidden  || type === REACT_OFFSCREEN_TYPE || enableScopeAPI  || enableCacheElement  || enableTransitionTracing ) {
+	    return true;
+	  }
+
+	  if (typeof type === 'object' && type !== null) {
+	    if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || // This needs to include all possible module reference object
+	    // types supported by any Flight configuration anywhere since
+	    // we don't know which Flight build this will end up being used
+	    // with.
+	    type.$$typeof === REACT_MODULE_REFERENCE || type.getModuleId !== undefined) {
+	      return true;
+	    }
+	  }
+
+	  return false;
+	}
+
+	function getWrappedName(outerType, innerType, wrapperName) {
+	  var displayName = outerType.displayName;
+
+	  if (displayName) {
+	    return displayName;
+	  }
+
+	  var functionName = innerType.displayName || innerType.name || '';
+	  return functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName;
+	} // Keep in sync with react-reconciler/getComponentNameFromFiber
+
+
+	function getContextName(type) {
+	  return type.displayName || 'Context';
+	} // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead.
+
+
+	function getComponentNameFromType(type) {
+	  if (type == null) {
+	    // Host root, text node or just invalid type.
+	    return null;
+	  }
+
+	  {
+	    if (typeof type.tag === 'number') {
+	      error('Received an unexpected object in getComponentNameFromType(). ' + 'This is likely a bug in React. Please file an issue.');
+	    }
+	  }
+
+	  if (typeof type === 'function') {
+	    return type.displayName || type.name || null;
+	  }
+
+	  if (typeof type === 'string') {
+	    return type;
+	  }
+
+	  switch (type) {
+	    case REACT_FRAGMENT_TYPE:
+	      return 'Fragment';
+
+	    case REACT_PORTAL_TYPE:
+	      return 'Portal';
+
+	    case REACT_PROFILER_TYPE:
+	      return 'Profiler';
+
+	    case REACT_STRICT_MODE_TYPE:
+	      return 'StrictMode';
+
+	    case REACT_SUSPENSE_TYPE:
+	      return 'Suspense';
+
+	    case REACT_SUSPENSE_LIST_TYPE:
+	      return 'SuspenseList';
+
+	  }
+
+	  if (typeof type === 'object') {
+	    switch (type.$$typeof) {
+	      case REACT_CONTEXT_TYPE:
+	        var context = type;
+	        return getContextName(context) + '.Consumer';
+
+	      case REACT_PROVIDER_TYPE:
+	        var provider = type;
+	        return getContextName(provider._context) + '.Provider';
+
+	      case REACT_FORWARD_REF_TYPE:
+	        return getWrappedName(type, type.render, 'ForwardRef');
+
+	      case REACT_MEMO_TYPE:
+	        var outerName = type.displayName || null;
+
+	        if (outerName !== null) {
+	          return outerName;
+	        }
+
+	        return getComponentNameFromType(type.type) || 'Memo';
+
+	      case REACT_LAZY_TYPE:
+	        {
+	          var lazyComponent = type;
+	          var payload = lazyComponent._payload;
+	          var init = lazyComponent._init;
+
+	          try {
+	            return getComponentNameFromType(init(payload));
+	          } catch (x) {
+	            return null;
+	          }
+	        }
+
+	      // eslint-disable-next-line no-fallthrough
+	    }
+	  }
+
+	  return null;
+	}
+
+	var assign = Object.assign;
+
+	// Helpers to patch console.logs to avoid logging during side-effect free
+	// replaying on render function. This currently only patches the object
+	// lazily which won't cover if the log function was extracted eagerly.
+	// We could also eagerly patch the method.
+	var disabledDepth = 0;
+	var prevLog;
+	var prevInfo;
+	var prevWarn;
+	var prevError;
+	var prevGroup;
+	var prevGroupCollapsed;
+	var prevGroupEnd;
+
+	function disabledLog() {}
+
+	disabledLog.__reactDisabledLog = true;
+	function disableLogs() {
+	  {
+	    if (disabledDepth === 0) {
+	      /* eslint-disable react-internal/no-production-logging */
+	      prevLog = console.log;
+	      prevInfo = console.info;
+	      prevWarn = console.warn;
+	      prevError = console.error;
+	      prevGroup = console.group;
+	      prevGroupCollapsed = console.groupCollapsed;
+	      prevGroupEnd = console.groupEnd; // https://github.com/facebook/react/issues/19099
+
+	      var props = {
+	        configurable: true,
+	        enumerable: true,
+	        value: disabledLog,
+	        writable: true
+	      }; // $FlowFixMe Flow thinks console is immutable.
+
+	      Object.defineProperties(console, {
+	        info: props,
+	        log: props,
+	        warn: props,
+	        error: props,
+	        group: props,
+	        groupCollapsed: props,
+	        groupEnd: props
+	      });
+	      /* eslint-enable react-internal/no-production-logging */
+	    }
+
+	    disabledDepth++;
+	  }
+	}
+	function reenableLogs() {
+	  {
+	    disabledDepth--;
+
+	    if (disabledDepth === 0) {
+	      /* eslint-disable react-internal/no-production-logging */
+	      var props = {
+	        configurable: true,
+	        enumerable: true,
+	        writable: true
+	      }; // $FlowFixMe Flow thinks console is immutable.
+
+	      Object.defineProperties(console, {
+	        log: assign({}, props, {
+	          value: prevLog
+	        }),
+	        info: assign({}, props, {
+	          value: prevInfo
+	        }),
+	        warn: assign({}, props, {
+	          value: prevWarn
+	        }),
+	        error: assign({}, props, {
+	          value: prevError
+	        }),
+	        group: assign({}, props, {
+	          value: prevGroup
+	        }),
+	        groupCollapsed: assign({}, props, {
+	          value: prevGroupCollapsed
+	        }),
+	        groupEnd: assign({}, props, {
+	          value: prevGroupEnd
+	        })
+	      });
+	      /* eslint-enable react-internal/no-production-logging */
+	    }
+
+	    if (disabledDepth < 0) {
+	      error('disabledDepth fell below zero. ' + 'This is a bug in React. Please file an issue.');
+	    }
+	  }
+	}
+
+	var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+	var prefix;
+	function describeBuiltInComponentFrame(name, source, ownerFn) {
+	  {
+	    if (prefix === undefined) {
+	      // Extract the VM specific prefix used by each line.
+	      try {
+	        throw Error();
+	      } catch (x) {
+	        var match = x.stack.trim().match(/\n( *(at )?)/);
+	        prefix = match && match[1] || '';
+	      }
+	    } // We use the prefix to ensure our stacks line up with native stack frames.
+
+
+	    return '\n' + prefix + name;
+	  }
+	}
+	var reentry = false;
+	var componentFrameCache;
+
+	{
+	  var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
+	  componentFrameCache = new PossiblyWeakMap();
+	}
+
+	function describeNativeComponentFrame(fn, construct) {
+	  // If something asked for a stack inside a fake render, it should get ignored.
+	  if ( !fn || reentry) {
+	    return '';
+	  }
+
+	  {
+	    var frame = componentFrameCache.get(fn);
+
+	    if (frame !== undefined) {
+	      return frame;
+	    }
+	  }
+
+	  var control;
+	  reentry = true;
+	  var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe It does accept undefined.
+
+	  Error.prepareStackTrace = undefined;
+	  var previousDispatcher;
+
+	  {
+	    previousDispatcher = ReactCurrentDispatcher.current; // Set the dispatcher in DEV because this might be call in the render function
+	    // for warnings.
+
+	    ReactCurrentDispatcher.current = null;
+	    disableLogs();
+	  }
+
+	  try {
+	    // This should throw.
+	    if (construct) {
+	      // Something should be setting the props in the constructor.
+	      var Fake = function () {
+	        throw Error();
+	      }; // $FlowFixMe
+
+
+	      Object.defineProperty(Fake.prototype, 'props', {
+	        set: function () {
+	          // We use a throwing setter instead of frozen or non-writable props
+	          // because that won't throw in a non-strict mode function.
+	          throw Error();
+	        }
+	      });
+
+	      if (typeof Reflect === 'object' && Reflect.construct) {
+	        // We construct a different control for this case to include any extra
+	        // frames added by the construct call.
+	        try {
+	          Reflect.construct(Fake, []);
+	        } catch (x) {
+	          control = x;
+	        }
+
+	        Reflect.construct(fn, [], Fake);
+	      } else {
+	        try {
+	          Fake.call();
+	        } catch (x) {
+	          control = x;
+	        }
+
+	        fn.call(Fake.prototype);
+	      }
+	    } else {
+	      try {
+	        throw Error();
+	      } catch (x) {
+	        control = x;
+	      }
+
+	      fn();
+	    }
+	  } catch (sample) {
+	    // This is inlined manually because closure doesn't do it for us.
+	    if (sample && control && typeof sample.stack === 'string') {
+	      // This extracts the first frame from the sample that isn't also in the control.
+	      // Skipping one frame that we assume is the frame that calls the two.
+	      var sampleLines = sample.stack.split('\n');
+	      var controlLines = control.stack.split('\n');
+	      var s = sampleLines.length - 1;
+	      var c = controlLines.length - 1;
+
+	      while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
+	        // We expect at least one stack frame to be shared.
+	        // Typically this will be the root most one. However, stack frames may be
+	        // cut off due to maximum stack limits. In this case, one maybe cut off
+	        // earlier than the other. We assume that the sample is longer or the same
+	        // and there for cut off earlier. So we should find the root most frame in
+	        // the sample somewhere in the control.
+	        c--;
+	      }
+
+	      for (; s >= 1 && c >= 0; s--, c--) {
+	        // Next we find the first one that isn't the same which should be the
+	        // frame that called our sample function and the control.
+	        if (sampleLines[s] !== controlLines[c]) {
+	          // In V8, the first line is describing the message but other VMs don't.
+	          // If we're about to return the first line, and the control is also on the same
+	          // line, that's a pretty good indicator that our sample threw at same line as
+	          // the control. I.e. before we entered the sample frame. So we ignore this result.
+	          // This can happen if you passed a class to function component, or non-function.
+	          if (s !== 1 || c !== 1) {
+	            do {
+	              s--;
+	              c--; // We may still have similar intermediate frames from the construct call.
+	              // The next one that isn't the same should be our match though.
+
+	              if (c < 0 || sampleLines[s] !== controlLines[c]) {
+	                // V8 adds a "new" prefix for native classes. Let's remove it to make it prettier.
+	                var _frame = '\n' + sampleLines[s].replace(' at new ', ' at '); // If our component frame is labeled "<anonymous>"
+	                // but we have a user-provided "displayName"
+	                // splice it in to make the stack more readable.
+
+
+	                if (fn.displayName && _frame.includes('<anonymous>')) {
+	                  _frame = _frame.replace('<anonymous>', fn.displayName);
+	                }
+
+	                {
+	                  if (typeof fn === 'function') {
+	                    componentFrameCache.set(fn, _frame);
+	                  }
+	                } // Return the line we found.
+
+
+	                return _frame;
+	              }
+	            } while (s >= 1 && c >= 0);
+	          }
+
+	          break;
+	        }
+	      }
+	    }
+	  } finally {
+	    reentry = false;
+
+	    {
+	      ReactCurrentDispatcher.current = previousDispatcher;
+	      reenableLogs();
+	    }
+
+	    Error.prepareStackTrace = previousPrepareStackTrace;
+	  } // Fallback to just using the name if we couldn't make it throw.
+
+
+	  var name = fn ? fn.displayName || fn.name : '';
+	  var syntheticFrame = name ? describeBuiltInComponentFrame(name) : '';
+
+	  {
+	    if (typeof fn === 'function') {
+	      componentFrameCache.set(fn, syntheticFrame);
+	    }
+	  }
+
+	  return syntheticFrame;
+	}
+	function describeFunctionComponentFrame(fn, source, ownerFn) {
+	  {
+	    return describeNativeComponentFrame(fn, false);
+	  }
+	}
+
+	function shouldConstruct(Component) {
+	  var prototype = Component.prototype;
+	  return !!(prototype && prototype.isReactComponent);
+	}
+
+	function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) {
+
+	  if (type == null) {
+	    return '';
+	  }
+
+	  if (typeof type === 'function') {
+	    {
+	      return describeNativeComponentFrame(type, shouldConstruct(type));
+	    }
+	  }
+
+	  if (typeof type === 'string') {
+	    return describeBuiltInComponentFrame(type);
+	  }
+
+	  switch (type) {
+	    case REACT_SUSPENSE_TYPE:
+	      return describeBuiltInComponentFrame('Suspense');
+
+	    case REACT_SUSPENSE_LIST_TYPE:
+	      return describeBuiltInComponentFrame('SuspenseList');
+	  }
+
+	  if (typeof type === 'object') {
+	    switch (type.$$typeof) {
+	      case REACT_FORWARD_REF_TYPE:
+	        return describeFunctionComponentFrame(type.render);
+
+	      case REACT_MEMO_TYPE:
+	        // Memo may contain any component type so we recursively resolve it.
+	        return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn);
+
+	      case REACT_LAZY_TYPE:
+	        {
+	          var lazyComponent = type;
+	          var payload = lazyComponent._payload;
+	          var init = lazyComponent._init;
+
+	          try {
+	            // Lazy may contain any component type so we recursively resolve it.
+	            return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn);
+	          } catch (x) {}
+	        }
+	    }
+	  }
+
+	  return '';
+	}
+
+	var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+	var loggedTypeFailures = {};
+	var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+
+	function setCurrentlyValidatingElement(element) {
+	  {
+	    if (element) {
+	      var owner = element._owner;
+	      var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
+	      ReactDebugCurrentFrame.setExtraStackFrame(stack);
+	    } else {
+	      ReactDebugCurrentFrame.setExtraStackFrame(null);
+	    }
+	  }
+	}
+
+	function checkPropTypes(typeSpecs, values, location, componentName, element) {
+	  {
+	    // $FlowFixMe This is okay but Flow doesn't know it.
+	    var has = Function.call.bind(hasOwnProperty);
+
+	    for (var typeSpecName in typeSpecs) {
+	      if (has(typeSpecs, typeSpecName)) {
+	        var error$1 = void 0; // Prop type validation may throw. In case they do, we don't want to
+	        // fail the render phase where it didn't fail before. So we log it.
+	        // After these have been cleaned up, we'll let them throw.
+
+	        try {
+	          // This is intentionally an invariant that gets caught. It's the same
+	          // behavior as without this statement except with a better message.
+	          if (typeof typeSpecs[typeSpecName] !== 'function') {
+	            // eslint-disable-next-line react-internal/prod-error-codes
+	            var err = Error((componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' + 'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' + 'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.');
+	            err.name = 'Invariant Violation';
+	            throw err;
+	          }
+
+	          error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED');
+	        } catch (ex) {
+	          error$1 = ex;
+	        }
+
+	        if (error$1 && !(error$1 instanceof Error)) {
+	          setCurrentlyValidatingElement(element);
+
+	          error('%s: type specification of %s' + ' `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', location, typeSpecName, typeof error$1);
+
+	          setCurrentlyValidatingElement(null);
+	        }
+
+	        if (error$1 instanceof Error && !(error$1.message in loggedTypeFailures)) {
+	          // Only monitor this failure once because there tends to be a lot of the
+	          // same error.
+	          loggedTypeFailures[error$1.message] = true;
+	          setCurrentlyValidatingElement(element);
+
+	          error('Failed %s type: %s', location, error$1.message);
+
+	          setCurrentlyValidatingElement(null);
+	        }
+	      }
+	    }
+	  }
+	}
+
+	var isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+	function isArray(a) {
+	  return isArrayImpl(a);
+	}
+
+	/*
+	 * The `'' + value` pattern (used in in perf-sensitive code) throws for Symbol
+	 * and Temporal.* types. See https://github.com/facebook/react/pull/22064.
+	 *
+	 * The functions in this module will throw an easier-to-understand,
+	 * easier-to-debug exception with a clear errors message message explaining the
+	 * problem. (Instead of a confusing exception thrown inside the implementation
+	 * of the `value` object).
+	 */
+	// $FlowFixMe only called in DEV, so void return is not possible.
+	function typeName(value) {
+	  {
+	    // toStringTag is needed for namespaced types like Temporal.Instant
+	    var hasToStringTag = typeof Symbol === 'function' && Symbol.toStringTag;
+	    var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || 'Object';
+	    return type;
+	  }
+	} // $FlowFixMe only called in DEV, so void return is not possible.
+
+
+	function willCoercionThrow(value) {
+	  {
+	    try {
+	      testStringCoercion(value);
+	      return false;
+	    } catch (e) {
+	      return true;
+	    }
+	  }
+	}
+
+	function testStringCoercion(value) {
+	  // If you ended up here by following an exception call stack, here's what's
+	  // happened: you supplied an object or symbol value to React (as a prop, key,
+	  // DOM attribute, CSS property, string ref, etc.) and when React tried to
+	  // coerce it to a string using `'' + value`, an exception was thrown.
+	  //
+	  // The most common types that will cause this exception are `Symbol` instances
+	  // and Temporal objects like `Temporal.Instant`. But any object that has a
+	  // `valueOf` or `[Symbol.toPrimitive]` method that throws will also cause this
+	  // exception. (Library authors do this to prevent users from using built-in
+	  // numeric operators like `+` or comparison operators like `>=` because custom
+	  // methods are needed to perform accurate arithmetic or comparison.)
+	  //
+	  // To fix the problem, coerce this object or symbol value to a string before
+	  // passing it to React. The most reliable way is usually `String(value)`.
+	  //
+	  // To find which value is throwing, check the browser or debugger console.
+	  // Before this exception was thrown, there should be `console.error` output
+	  // that shows the type (Symbol, Temporal.PlainDate, etc.) that caused the
+	  // problem and how that type was used: key, atrribute, input value prop, etc.
+	  // In most cases, this console output also shows the component and its
+	  // ancestor components where the exception happened.
+	  //
+	  // eslint-disable-next-line react-internal/safe-string-coercion
+	  return '' + value;
+	}
+	function checkKeyStringCoercion(value) {
+	  {
+	    if (willCoercionThrow(value)) {
+	      error('The provided key is an unsupported type %s.' + ' This value must be coerced to a string before before using it here.', typeName(value));
+
+	      return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
+	    }
+	  }
+	}
+
+	var ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;
+	var RESERVED_PROPS = {
+	  key: true,
+	  ref: true,
+	  __self: true,
+	  __source: true
+	};
+	var specialPropKeyWarningShown;
+	var specialPropRefWarningShown;
+	var didWarnAboutStringRefs;
+
+	{
+	  didWarnAboutStringRefs = {};
+	}
+
+	function hasValidRef(config) {
+	  {
+	    if (hasOwnProperty.call(config, 'ref')) {
+	      var getter = Object.getOwnPropertyDescriptor(config, 'ref').get;
+
+	      if (getter && getter.isReactWarning) {
+	        return false;
+	      }
+	    }
+	  }
+
+	  return config.ref !== undefined;
+	}
+
+	function hasValidKey(config) {
+	  {
+	    if (hasOwnProperty.call(config, 'key')) {
+	      var getter = Object.getOwnPropertyDescriptor(config, 'key').get;
+
+	      if (getter && getter.isReactWarning) {
+	        return false;
+	      }
+	    }
+	  }
+
+	  return config.key !== undefined;
+	}
+
+	function warnIfStringRefCannotBeAutoConverted(config, self) {
+	  {
+	    if (typeof config.ref === 'string' && ReactCurrentOwner.current && self && ReactCurrentOwner.current.stateNode !== self) {
+	      var componentName = getComponentNameFromType(ReactCurrentOwner.current.type);
+
+	      if (!didWarnAboutStringRefs[componentName]) {
+	        error('Component "%s" contains the string ref "%s". ' + 'Support for string refs will be removed in a future major release. ' + 'This case cannot be automatically converted to an arrow function. ' + 'We ask you to manually fix this case by using useRef() or createRef() instead. ' + 'Learn more about using refs safely here: ' + 'https://reactjs.org/link/strict-mode-string-ref', getComponentNameFromType(ReactCurrentOwner.current.type), config.ref);
+
+	        didWarnAboutStringRefs[componentName] = true;
+	      }
+	    }
+	  }
+	}
+
+	function defineKeyPropWarningGetter(props, displayName) {
+	  {
+	    var warnAboutAccessingKey = function () {
+	      if (!specialPropKeyWarningShown) {
+	        specialPropKeyWarningShown = true;
+
+	        error('%s: `key` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://reactjs.org/link/special-props)', displayName);
+	      }
+	    };
+
+	    warnAboutAccessingKey.isReactWarning = true;
+	    Object.defineProperty(props, 'key', {
+	      get: warnAboutAccessingKey,
+	      configurable: true
+	    });
+	  }
+	}
+
+	function defineRefPropWarningGetter(props, displayName) {
+	  {
+	    var warnAboutAccessingRef = function () {
+	      if (!specialPropRefWarningShown) {
+	        specialPropRefWarningShown = true;
+
+	        error('%s: `ref` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://reactjs.org/link/special-props)', displayName);
+	      }
+	    };
+
+	    warnAboutAccessingRef.isReactWarning = true;
+	    Object.defineProperty(props, 'ref', {
+	      get: warnAboutAccessingRef,
+	      configurable: true
+	    });
+	  }
+	}
+	/**
+	 * Factory method to create a new React element. This no longer adheres to
+	 * the class pattern, so do not use new to call it. Also, instanceof check
+	 * will not work. Instead test $$typeof field against Symbol.for('react.element') to check
+	 * if something is a React Element.
+	 *
+	 * @param {*} type
+	 * @param {*} props
+	 * @param {*} key
+	 * @param {string|object} ref
+	 * @param {*} owner
+	 * @param {*} self A *temporary* helper to detect places where `this` is
+	 * different from the `owner` when React.createElement is called, so that we
+	 * can warn. We want to get rid of owner and replace string `ref`s with arrow
+	 * functions, and as long as `this` and owner are the same, there will be no
+	 * change in behavior.
+	 * @param {*} source An annotation object (added by a transpiler or otherwise)
+	 * indicating filename, line number, and/or other information.
+	 * @internal
+	 */
+
+
+	var ReactElement = function (type, key, ref, self, source, owner, props) {
+	  var element = {
+	    // This tag allows us to uniquely identify this as a React Element
+	    $$typeof: REACT_ELEMENT_TYPE,
+	    // Built-in properties that belong on the element
+	    type: type,
+	    key: key,
+	    ref: ref,
+	    props: props,
+	    // Record the component responsible for creating this element.
+	    _owner: owner
+	  };
+
+	  {
+	    // The validation flag is currently mutative. We put it on
+	    // an external backing store so that we can freeze the whole object.
+	    // This can be replaced with a WeakMap once they are implemented in
+	    // commonly used development environments.
+	    element._store = {}; // To make comparing ReactElements easier for testing purposes, we make
+	    // the validation flag non-enumerable (where possible, which should
+	    // include every environment we run tests in), so the test framework
+	    // ignores it.
+
+	    Object.defineProperty(element._store, 'validated', {
+	      configurable: false,
+	      enumerable: false,
+	      writable: true,
+	      value: false
+	    }); // self and source are DEV only properties.
+
+	    Object.defineProperty(element, '_self', {
+	      configurable: false,
+	      enumerable: false,
+	      writable: false,
+	      value: self
+	    }); // Two elements created in two different places should be considered
+	    // equal for testing purposes and therefore we hide it from enumeration.
+
+	    Object.defineProperty(element, '_source', {
+	      configurable: false,
+	      enumerable: false,
+	      writable: false,
+	      value: source
+	    });
+
+	    if (Object.freeze) {
+	      Object.freeze(element.props);
+	      Object.freeze(element);
+	    }
+	  }
+
+	  return element;
+	};
+	/**
+	 * https://github.com/reactjs/rfcs/pull/107
+	 * @param {*} type
+	 * @param {object} props
+	 * @param {string} key
+	 */
+
+	function jsxDEV(type, config, maybeKey, source, self) {
+	  {
+	    var propName; // Reserved names are extracted
+
+	    var props = {};
+	    var key = null;
+	    var ref = null; // Currently, key can be spread in as a prop. This causes a potential
+	    // issue if key is also explicitly declared (ie. <div {...props} key="Hi" />
+	    // or <div key="Hi" {...props} /> ). We want to deprecate key spread,
+	    // but as an intermediary step, we will use jsxDEV for everything except
+	    // <div {...props} key="Hi" />, because we aren't currently able to tell if
+	    // key is explicitly declared to be undefined or not.
+
+	    if (maybeKey !== undefined) {
+	      {
+	        checkKeyStringCoercion(maybeKey);
+	      }
+
+	      key = '' + maybeKey;
+	    }
+
+	    if (hasValidKey(config)) {
+	      {
+	        checkKeyStringCoercion(config.key);
+	      }
+
+	      key = '' + config.key;
+	    }
+
+	    if (hasValidRef(config)) {
+	      ref = config.ref;
+	      warnIfStringRefCannotBeAutoConverted(config, self);
+	    } // Remaining properties are added to a new props object
+
+
+	    for (propName in config) {
+	      if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
+	        props[propName] = config[propName];
+	      }
+	    } // Resolve default props
+
+
+	    if (type && type.defaultProps) {
+	      var defaultProps = type.defaultProps;
+
+	      for (propName in defaultProps) {
+	        if (props[propName] === undefined) {
+	          props[propName] = defaultProps[propName];
+	        }
+	      }
+	    }
+
+	    if (key || ref) {
+	      var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type;
+
+	      if (key) {
+	        defineKeyPropWarningGetter(props, displayName);
+	      }
+
+	      if (ref) {
+	        defineRefPropWarningGetter(props, displayName);
+	      }
+	    }
+
+	    return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
+	  }
+	}
+
+	var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner;
+	var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
+
+	function setCurrentlyValidatingElement$1(element) {
+	  {
+	    if (element) {
+	      var owner = element._owner;
+	      var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
+	      ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
+	    } else {
+	      ReactDebugCurrentFrame$1.setExtraStackFrame(null);
+	    }
+	  }
+	}
+
+	var propTypesMisspellWarningShown;
+
+	{
+	  propTypesMisspellWarningShown = false;
+	}
+	/**
+	 * Verifies the object is a ReactElement.
+	 * See https://reactjs.org/docs/react-api.html#isvalidelement
+	 * @param {?object} object
+	 * @return {boolean} True if `object` is a ReactElement.
+	 * @final
+	 */
+
+
+	function isValidElement(object) {
+	  {
+	    return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+	  }
+	}
+
+	function getDeclarationErrorAddendum() {
+	  {
+	    if (ReactCurrentOwner$1.current) {
+	      var name = getComponentNameFromType(ReactCurrentOwner$1.current.type);
+
+	      if (name) {
+	        return '\n\nCheck the render method of `' + name + '`.';
+	      }
+	    }
+
+	    return '';
+	  }
+	}
+
+	function getSourceInfoErrorAddendum(source) {
+	  {
+	    if (source !== undefined) {
+	      var fileName = source.fileName.replace(/^.*[\\\/]/, '');
+	      var lineNumber = source.lineNumber;
+	      return '\n\nCheck your code at ' + fileName + ':' + lineNumber + '.';
+	    }
+
+	    return '';
+	  }
+	}
+	/**
+	 * Warn if there's no key explicitly set on dynamic arrays of children or
+	 * object keys are not valid. This allows us to keep track of children between
+	 * updates.
+	 */
+
+
+	var ownerHasKeyUseWarning = {};
+
+	function getCurrentComponentErrorInfo(parentType) {
+	  {
+	    var info = getDeclarationErrorAddendum();
+
+	    if (!info) {
+	      var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name;
+
+	      if (parentName) {
+	        info = "\n\nCheck the top-level render call using <" + parentName + ">.";
+	      }
+	    }
+
+	    return info;
+	  }
+	}
+	/**
+	 * Warn if the element doesn't have an explicit key assigned to it.
+	 * This element is in an array. The array could grow and shrink or be
+	 * reordered. All children that haven't already been validated are required to
+	 * have a "key" property assigned to it. Error statuses are cached so a warning
+	 * will only be shown once.
+	 *
+	 * @internal
+	 * @param {ReactElement} element Element that requires a key.
+	 * @param {*} parentType element's parent's type.
+	 */
+
+
+	function validateExplicitKey(element, parentType) {
+	  {
+	    if (!element._store || element._store.validated || element.key != null) {
+	      return;
+	    }
+
+	    element._store.validated = true;
+	    var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);
+
+	    if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
+	      return;
+	    }
+
+	    ownerHasKeyUseWarning[currentComponentErrorInfo] = true; // Usually the current owner is the offender, but if it accepts children as a
+	    // property, it may be the creator of the child that's responsible for
+	    // assigning it a key.
+
+	    var childOwner = '';
+
+	    if (element && element._owner && element._owner !== ReactCurrentOwner$1.current) {
+	      // Give the component that originally created this child.
+	      childOwner = " It was passed a child from " + getComponentNameFromType(element._owner.type) + ".";
+	    }
+
+	    setCurrentlyValidatingElement$1(element);
+
+	    error('Each child in a list should have a unique "key" prop.' + '%s%s See https://reactjs.org/link/warning-keys for more information.', currentComponentErrorInfo, childOwner);
+
+	    setCurrentlyValidatingElement$1(null);
+	  }
+	}
+	/**
+	 * Ensure that every element either is passed in a static location, in an
+	 * array with an explicit keys property defined, or in an object literal
+	 * with valid key property.
+	 *
+	 * @internal
+	 * @param {ReactNode} node Statically passed child of any type.
+	 * @param {*} parentType node's parent's type.
+	 */
+
+
+	function validateChildKeys(node, parentType) {
+	  {
+	    if (typeof node !== 'object') {
+	      return;
+	    }
+
+	    if (isArray(node)) {
+	      for (var i = 0; i < node.length; i++) {
+	        var child = node[i];
+
+	        if (isValidElement(child)) {
+	          validateExplicitKey(child, parentType);
+	        }
+	      }
+	    } else if (isValidElement(node)) {
+	      // This element was passed in a valid location.
+	      if (node._store) {
+	        node._store.validated = true;
+	      }
+	    } else if (node) {
+	      var iteratorFn = getIteratorFn(node);
+
+	      if (typeof iteratorFn === 'function') {
+	        // Entry iterators used to provide implicit keys,
+	        // but now we print a separate warning for them later.
+	        if (iteratorFn !== node.entries) {
+	          var iterator = iteratorFn.call(node);
+	          var step;
+
+	          while (!(step = iterator.next()).done) {
+	            if (isValidElement(step.value)) {
+	              validateExplicitKey(step.value, parentType);
+	            }
+	          }
+	        }
+	      }
+	    }
+	  }
+	}
+	/**
+	 * Given an element, validate that its props follow the propTypes definition,
+	 * provided by the type.
+	 *
+	 * @param {ReactElement} element
+	 */
+
+
+	function validatePropTypes(element) {
+	  {
+	    var type = element.type;
+
+	    if (type === null || type === undefined || typeof type === 'string') {
+	      return;
+	    }
+
+	    var propTypes;
+
+	    if (typeof type === 'function') {
+	      propTypes = type.propTypes;
+	    } else if (typeof type === 'object' && (type.$$typeof === REACT_FORWARD_REF_TYPE || // Note: Memo only checks outer props here.
+	    // Inner props are checked in the reconciler.
+	    type.$$typeof === REACT_MEMO_TYPE)) {
+	      propTypes = type.propTypes;
+	    } else {
+	      return;
+	    }
+
+	    if (propTypes) {
+	      // Intentionally inside to avoid triggering lazy initializers:
+	      var name = getComponentNameFromType(type);
+	      checkPropTypes(propTypes, element.props, 'prop', name, element);
+	    } else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) {
+	      propTypesMisspellWarningShown = true; // Intentionally inside to avoid triggering lazy initializers:
+
+	      var _name = getComponentNameFromType(type);
+
+	      error('Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', _name || 'Unknown');
+	    }
+
+	    if (typeof type.getDefaultProps === 'function' && !type.getDefaultProps.isReactClassApproved) {
+	      error('getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.');
+	    }
+	  }
+	}
+	/**
+	 * Given a fragment, validate that it can only be provided with fragment props
+	 * @param {ReactElement} fragment
+	 */
+
+
+	function validateFragmentProps(fragment) {
+	  {
+	    var keys = Object.keys(fragment.props);
+
+	    for (var i = 0; i < keys.length; i++) {
+	      var key = keys[i];
+
+	      if (key !== 'children' && key !== 'key') {
+	        setCurrentlyValidatingElement$1(fragment);
+
+	        error('Invalid prop `%s` supplied to `React.Fragment`. ' + 'React.Fragment can only have `key` and `children` props.', key);
+
+	        setCurrentlyValidatingElement$1(null);
+	        break;
+	      }
+	    }
+
+	    if (fragment.ref !== null) {
+	      setCurrentlyValidatingElement$1(fragment);
+
+	      error('Invalid attribute `ref` supplied to `React.Fragment`.');
+
+	      setCurrentlyValidatingElement$1(null);
+	    }
+	  }
+	}
+
+	var didWarnAboutKeySpread = {};
+	function jsxWithValidation(type, props, key, isStaticChildren, source, self) {
+	  {
+	    var validType = isValidElementType(type); // We warn in this case but don't throw. We expect the element creation to
+	    // succeed and there will likely be errors in render.
+
+	    if (!validType) {
+	      var info = '';
+
+	      if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) {
+	        info += ' You likely forgot to export your component from the file ' + "it's defined in, or you might have mixed up default and named imports.";
+	      }
+
+	      var sourceInfo = getSourceInfoErrorAddendum(source);
+
+	      if (sourceInfo) {
+	        info += sourceInfo;
+	      } else {
+	        info += getDeclarationErrorAddendum();
+	      }
+
+	      var typeString;
+
+	      if (type === null) {
+	        typeString = 'null';
+	      } else if (isArray(type)) {
+	        typeString = 'array';
+	      } else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) {
+	        typeString = "<" + (getComponentNameFromType(type.type) || 'Unknown') + " />";
+	        info = ' Did you accidentally export a JSX literal instead of a component?';
+	      } else {
+	        typeString = typeof type;
+	      }
+
+	      error('React.jsx: type is invalid -- expected a string (for ' + 'built-in components) or a class/function (for composite ' + 'components) but got: %s.%s', typeString, info);
+	    }
+
+	    var element = jsxDEV(type, props, key, source, self); // The result can be nullish if a mock or a custom function is used.
+	    // TODO: Drop this when these are no longer allowed as the type argument.
+
+	    if (element == null) {
+	      return element;
+	    } // Skip key warning if the type isn't valid since our key validation logic
+	    // doesn't expect a non-string/function type and can throw confusing errors.
+	    // We don't want exception behavior to differ between dev and prod.
+	    // (Rendering will throw with a helpful message and as soon as the type is
+	    // fixed, the key warnings will appear.)
+
+
+	    if (validType) {
+	      var children = props.children;
+
+	      if (children !== undefined) {
+	        if (isStaticChildren) {
+	          if (isArray(children)) {
+	            for (var i = 0; i < children.length; i++) {
+	              validateChildKeys(children[i], type);
+	            }
+
+	            if (Object.freeze) {
+	              Object.freeze(children);
+	            }
+	          } else {
+	            error('React.jsx: Static children should always be an array. ' + 'You are likely explicitly calling React.jsxs or React.jsxDEV. ' + 'Use the Babel transform instead.');
+	          }
+	        } else {
+	          validateChildKeys(children, type);
+	        }
+	      }
+	    }
+
+	    {
+	      if (hasOwnProperty.call(props, 'key')) {
+	        var componentName = getComponentNameFromType(type);
+	        var keys = Object.keys(props).filter(function (k) {
+	          return k !== 'key';
+	        });
+	        var beforeExample = keys.length > 0 ? '{key: someKey, ' + keys.join(': ..., ') + ': ...}' : '{key: someKey}';
+
+	        if (!didWarnAboutKeySpread[componentName + beforeExample]) {
+	          var afterExample = keys.length > 0 ? '{' + keys.join(': ..., ') + ': ...}' : '{}';
+
+	          error('A props object containing a "key" prop is being spread into JSX:\n' + '  let props = %s;\n' + '  <%s {...props} />\n' + 'React keys must be passed directly to JSX without using spread:\n' + '  let props = %s;\n' + '  <%s key={someKey} {...props} />', beforeExample, componentName, afterExample, componentName);
+
+	          didWarnAboutKeySpread[componentName + beforeExample] = true;
+	        }
+	      }
+	    }
+
+	    if (type === REACT_FRAGMENT_TYPE) {
+	      validateFragmentProps(element);
+	    } else {
+	      validatePropTypes(element);
+	    }
+
+	    return element;
+	  }
+	} // These two functions exist to still get child warnings in dev
+	// even with the prod transform. This means that jsxDEV is purely
+	// opt-in behavior for better messages but that we won't stop
+	// giving you warnings if you use production apis.
+
+	function jsxWithValidationStatic(type, props, key) {
+	  {
+	    return jsxWithValidation(type, props, key, true);
+	  }
+	}
+	function jsxWithValidationDynamic(type, props, key) {
+	  {
+	    return jsxWithValidation(type, props, key, false);
+	  }
+	}
+
+	var jsx =  jsxWithValidationDynamic ; // we may want to special case jsxs internally to take advantage of static children.
+	// for now we can ship identical prod functions
+
+	var jsxs =  jsxWithValidationStatic ;
+
+	reactJsxRuntime_development.Fragment = REACT_FRAGMENT_TYPE;
+	reactJsxRuntime_development.jsx = jsx;
+	reactJsxRuntime_development.jsxs = jsxs;
+	  })();
+	}
+	return reactJsxRuntime_development;
+}
+
+var hasRequiredJsxRuntime;
+
+function requireJsxRuntime () {
+	if (hasRequiredJsxRuntime) return jsxRuntime.exports;
+	hasRequiredJsxRuntime = 1;
+
+	if (process.env.NODE_ENV === 'production') {
+	  jsxRuntime.exports = requireReactJsxRuntime_production_min();
+	} else {
+	  jsxRuntime.exports = requireReactJsxRuntime_development();
+	}
+	return jsxRuntime.exports;
+}
+
+var jsxRuntimeExports = requireJsxRuntime();
+
+const _excluded$1 = ["doorDepth"];
+const ConfiguratorContext = /*#__PURE__*/require$$0.createContext(undefined);
+const ConfiguratorProvider = _ref => {
+  let {
+    children
+  } = _ref;
+  const [isPlaneVisible, setIsPlaneVisible] = require$$0.useState(false);
+  const [isFrameVisible, setIsFrameVisible] = require$$0.useState(true);
+  const [cpid, setCpid] = require$$0.useState("");
+  const [totalHeight, setTotalHeight] = require$$0.useState(2700);
+  const [totalWidth, setTotalWidth] = require$$0.useState(974);
+  const [glassVisible, setGlassVisible] = require$$0.useState(false);
+  const [glassDepth, setGlassDepth] = require$$0.useState(8);
+  const [door, setDoor] = require$$0.useState({
+    doorMaterial: "door_material",
+    doorWidth: 0,
+    doorHeight: 0,
+    theDoorDepth: 40,
+    doorPivot: "left",
+    doorOpening: "out"
+  });
+  const [doorFrame, setDoorFrame] = require$$0.useState({
+    frameMaterial: "doorFrame_material",
+    doorStopMaterial: "doorStop_material",
+    gasketMaterial: "gasket_material",
+    hingeMaterial: "hinge_material",
+    glassMaterial: "glass_material",
+    frameDepth: 103,
+    topThk: "20mm",
+    sidesThk: "20mm",
+    doorStopOffset: "30mm",
+    doorStopWidth: 20,
+    doorStopDepth: 13,
+    notchWidth: "20mm",
+    notchDepth: "40mm",
+    notchposition: 0.01,
+    gasketDepth: 5,
+    gasketWidth: 5,
+    secondDoorStopWidth: 20,
+    secondDoorStopDepth: 30,
+    secondDoorStopOffset: 13
+  });
+  const [interiorFanlight, setInteriorFanlight] = require$$0.useState({
+    visible: false,
+    height: 300,
+    material: "interiorFanlight_material"
+  });
+  const [exteriorFanlight, setExteriorFanlight] = require$$0.useState({
+    visible: false,
+    height: 300,
+    depth: 60,
+    material: "exteriorFanlight_material"
+  });
+  const [occulus, setOcculus] = require$$0.useState({
+    visible: false,
+    infillVisible: true,
+    x1: 120,
+    x2: 120,
+    y1: 600,
+    y2: 220,
+    material: "infill_material",
+    depth: 20
+  });
+  const [frontCoverPanel, setFrontCoverPanel] = require$$0.useState({
+    visible: false,
+    width: 73,
+    height: 2200,
+    depth: 12,
+    material: "front_cover_material"
+  });
+  const [backCoverPanel, setBackCoverPanel] = require$$0.useState({
+    visible: false,
+    width: 73,
+    height: 2200,
+    depth: 12,
+    material: "back_cover_material"
+  });
+  const [glass, setGlass] = require$$0.useState({
+    visible: false,
+    material: "infill_material",
+    depth: 20
+  });
+  const [frameType, setFrameType] = require$$0.useState("AF20_40");
+  const [bodyType, setBodyType] = require$$0.useState("40");
+  const [exteriorFanlightType, setExteriorFanlightType] = require$$0.useState("WPFL");
+  const [testDoorMaterial, setTestDoorMaterial] = require$$0.useState("brown");
+  const [testFrameMaterial, setTestFrameMaterial] = require$$0.useState("black");
+  const [testGasketMaterial, setTestGasketMaterial] = require$$0.useState("darkgrey");
+  const [testInteriorFanlightMaterial, setTestInteriorFanlightMaterial] = require$$0.useState("grey");
+  const [testExteriorFanlightMaterial, setTestExteriorFanlightMaterial] = require$$0.useState("metal");
+  const [testOcculusInfillMaterial, setTestOcculusInfillMaterial] = require$$0.useState("glass");
+  const [testGlassInfillMaterial, setTestGlassInfillMaterial] = require$$0.useState("glass");
+  const [testDoorStopMaterial, setTestDoorStopMaterial] = require$$0.useState("black");
+  const [testHingeMaterial, setTestHingeMaterial] = require$$0.useState("metal");
+  const [testFrontCoverPanelMaterial, setTestFrontCoverPanelMaterial] = require$$0.useState("aluminum");
+  const [testBackCoverPanelMaterial, setTestBackCoverPanelMaterial] = require$$0.useState("aluminum");
+
+  //
+  const [parseMessage, setParseMessage] = require$$0.useState({
+    type: "",
+    text: ""
+  });
+  const handleParseCpid = require$$0.useCallback(cpidToParse => {
+    const showMessage = function (text) {
+      let type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "error";
+      setParseMessage({
+        text,
+        type
+      });
+      setTimeout(() => setParseMessage({
+        text: "",
+        type: ""
+      }), 4000);
+    };
+    if (!cpidToParse || !cpidToParse.trim().startsWith("P_")) {
+      showMessage("Invalid format: CPID must start with 'P_'.");
+      return;
+    }
+    const parts = cpidToParse.trim().split("_");
+    if (parts.length < 4) {
+      showMessage("Invalid format: Not enough parts in CPID.");
+      return;
+    }
+    const newConfig = {
+      fanlightVisible: false,
+      fanlightType: "WPFL",
+      interiorFanlightVisible: false,
+      occulusVisible: false,
+      frameType: "",
+      bodyType: ""
+    };
+    let currentIndex = 1;
+
+    //  Door Type
+    if (parts[currentIndex] === "SD") {
+      currentIndex++;
+    } else {
+      showMessage("Unsupported Door Type: Only 'SD' is supported.");
+      return;
+    }
+
+    //Fanlight Type
+    const fanlightPart = parts[currentIndex];
+    const validFanlights = ["WPFL", "ALDGFL", "ALSGFL"];
+    if (fanlightPart === "FH") {
+      newConfig.fanlightVisible = false;
+      currentIndex++;
+    } else if (validFanlights.includes(fanlightPart)) {
+      newConfig.fanlightVisible = true;
+      newConfig.fanlightType = fanlightPart;
+      currentIndex++;
+    } else {
+      showMessage("Invalid Fanlight Type: '".concat(fanlightPart, "'."));
+      return;
+    }
+
+    //  Frame and Body Type
+    const validSimpleFrameTypes = ["AF20", "AF40", "WF", "MXF", "MXCAF", "NOF"];
+    const validBodyTypes = ["40", "50", "FLI", "100", "WDG100", "SG8", "SG10", "SG12"];
+    let framePart = parts[currentIndex];
+    let bodyPartRaw = parts[currentIndex + 1] || "";
+    let frameFound = false;
+    if ("".concat(framePart, "_").concat(bodyPartRaw) === "WDGF_WDG100") {
+      newConfig.frameType = "WDGF_WDG100";
+      newConfig.bodyType = "WDG100";
+      currentIndex += 2;
+      frameFound = true;
+    } else if (validSimpleFrameTypes.includes(framePart)) {
+      let tempBody = bodyPartRaw.replace("OCC", "");
+      if (validBodyTypes.includes(tempBody)) {
+        newConfig.frameType = framePart === "NOF" ? "NOF" : "".concat(framePart, "_").concat(tempBody);
+        newConfig.bodyType = tempBody;
+        if (bodyPartRaw.endsWith("OCC")) {
+          newConfig.occulusVisible = true;
+        }
+        currentIndex += 2;
+        frameFound = true;
+      }
+    }
+    if (!frameFound) {
+      showMessage("Invalid Frame/Body combination starting with '".concat(framePart, "'."));
+      return;
+    }
+    for (let i = currentIndex; i < parts.length; i++) {
+      if (parts[i] === "IFL") {
+        newConfig.interiorFanlightVisible = true;
+      } else if (parts[i] === "OCC") {
+        newConfig.occulusVisible = true;
+      }
+    }
+
+    // Apply final configuration
+    setFrameType(newConfig.frameType);
+    setBodyType(newConfig.bodyType);
+    setExteriorFanlight(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+      visible: newConfig.fanlightVisible
+    }));
+    if (newConfig.fanlightVisible) {
+      setExteriorFanlightType(newConfig.fanlightType);
+    }
+    setInteriorFanlight(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+      visible: newConfig.interiorFanlightVisible
+    }));
+    setOcculus(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+      visible: newConfig.occulusVisible
+    }));
+    showMessage("Configuration Applied!", "success");
+  }, [setBodyType, setExteriorFanlight, setExteriorFanlightType, setFrameType, setInteriorFanlight, setOcculus]);
+
+  // --- BodyType Effect ---
+  require$$0.useEffect(() => {
+    let newDoorDepth = 40;
+    let newMaterial = "brown";
+    switch (bodyType) {
+      case "50":
+        newDoorDepth = 50;
+        break;
+      case "SG8":
+        newDoorDepth = 8;
+        newMaterial = "glass";
+        break;
+      case "SG10":
+        newDoorDepth = 10;
+        newMaterial = "glass";
+        break;
+      case "SG12":
+        newDoorDepth = 12;
+        newMaterial = "glass";
+        break;
+    }
+    setDoor(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+      theDoorDepth: newDoorDepth
+    }));
+    setTestDoorMaterial(newMaterial);
+  }, [bodyType]);
+
+  // --- FrameType Effect ---
+  require$$0.useEffect(() => {
+    setIsFrameVisible(frameType !== "NOF");
+    setGlassVisible(false);
+    let newSettings = {};
+    let lookupKey = frameType;
+    if (frameType.startsWith("AF20_SG")) {
+      lookupKey = "AF20_40";
+    } else if (frameType.startsWith("AF40_SG")) {
+      lookupKey = "AF40_40";
+    }
+    switch (lookupKey) {
+      case "NOF":
+        newSettings = {
+          topThk: "0mm",
+          sidesThk: "0mm",
+          frameDepth: 0
+        };
+        break;
+      case "AF20_40":
+        newSettings = {
+          frameDepth: 103,
+          topThk: "20mm",
+          sidesThk: "20mm",
+          doorStopOffset: "42mm",
+          doorStopWidth: 20,
+          doorStopDepth: 13,
+          notchWidth: "20mm",
+          notchDepth: "40mm",
+          notchposition: 0.01,
+          gasketDepth: 5,
+          gasketWidth: 5
+        };
+        if (frameType === "AF20_40") {
+          newSettings.doorDepth = 40;
+        }
+        break;
+      case "AF20_50":
+        newSettings = {
+          doorDepth: 50,
+          frameDepth: 103,
+          topThk: "20mm",
+          sidesThk: "20mm",
+          doorStopOffset: "30mm",
+          doorStopWidth: 20,
+          doorStopDepth: 13,
+          notchWidth: "20mm",
+          notchDepth: "40mm",
+          notchposition: 0.01,
+          gasketDepth: 5,
+          gasketWidth: 5
+        };
+        break;
+      case "AF40_40":
+        newSettings = {
+          frameDepth: 103,
+          topThk: "40mm",
+          sidesThk: "40mm",
+          doorStopOffset: "42mm",
+          doorStopWidth: 20,
+          doorStopDepth: 13,
+          notchWidth: "20mm",
+          notchDepth: "40mm",
+          notchposition: 0.01,
+          gasketDepth: 5,
+          gasketWidth: 5
+        };
+        if (frameType === "AF40_40") {
+          newSettings.doorDepth = 40;
+        }
+        break;
+      case "AF40_50":
+        newSettings = {
+          doorDepth: 50,
+          frameDepth: 103,
+          topThk: "40mm",
+          sidesThk: "40mm",
+          doorStopOffset: "30mm",
+          doorStopWidth: 20,
+          doorStopDepth: 13,
+          notchWidth: "20mm",
+          notchDepth: "40mm",
+          notchposition: 0.01,
+          gasketDepth: 5,
+          gasketWidth: 5
+        };
+        break;
+      case "WF_40":
+        newSettings = {
+          doorDepth: 39.6,
+          frameDepth: 103,
+          topThk: "31.6mm",
+          sidesThk: "31.6mm",
+          doorStopOffset: "0mm",
+          doorStopWidth: 16.4,
+          doorStopDepth: 58.4,
+          notchWidth: "20mm",
+          notchDepth: "40mm",
+          notchposition: 0.01,
+          gasketDepth: 5,
+          gasketWidth: 5
+        };
+        break;
+      case "WF_50":
+        newSettings = {
+          doorDepth: 51.6,
+          frameDepth: 103,
+          topThk: "31.6mm",
+          sidesThk: "31.6mm",
+          doorStopOffset: "0mm",
+          doorStopWidth: 16,
+          doorStopDepth: 46.4,
+          notchWidth: "20mm",
+          notchDepth: "40mm",
+          notchposition: 0.01,
+          gasketDepth: 5,
+          gasketWidth: 5
+        };
+        break;
+      case "WF_100":
+        newSettings = {
+          doorDepth: 102,
+          frameDepth: 102,
+          topThk: "52mm",
+          sidesThk: "52mm",
+          doorStopOffset: "17.6mm",
+          doorStopWidth: 16.4,
+          doorStopDepth: 44.8,
+          notchWidth: "16mm",
+          notchDepth: "66.5mm",
+          notchposition: 0.02,
+          gasketDepth: 5,
+          gasketWidth: 5,
+          secondDoorStopWidth: 29,
+          secondDoorStopDepth: 17.6,
+          secondDoorStopOffset: 0
+        };
+        break;
+      case "WF_FLI":
+        newSettings = {
+          doorDepth: 51,
+          frameDepth: 102,
+          topThk: "52mm",
+          sidesThk: "52mm",
+          doorStopOffset: "17.4mm",
+          doorStopWidth: 16.4,
+          doorStopDepth: 34,
+          notchWidth: "14mm",
+          notchDepth: "66mm",
+          notchposition: 0.02,
+          gasketDepth: 5,
+          gasketWidth: 5,
+          secondDoorStopWidth: 29,
+          secondDoorStopDepth: 17.6,
+          secondDoorStopOffset: 0
+        };
+        break;
+      case "WDGF_WDG100":
+        newSettings = {
+          doorDepth: 86,
+          frameDepth: 86,
+          topThk: "50mm",
+          sidesThk: "50mm",
+          doorStopOffset: "34mm",
+          doorStopWidth: 13,
+          doorStopDepth: 30,
+          notchWidth: "14mm",
+          notchDepth: "66mm",
+          notchposition: 0.02,
+          gasketDepth: 4.5,
+          gasketWidth: 5,
+          secondDoorStopWidth: 23,
+          secondDoorStopDepth: 30,
+          secondDoorStopOffset: 13
+        };
+        setGlassVisible(true);
+        break;
+      case "MXF_40":
+        newSettings = {
+          doorDepth: 38,
+          frameDepth: 103,
+          topThk: "18mm",
+          sidesThk: "18mm",
+          doorStopOffset: "45mm",
+          doorStopWidth: 15,
+          doorStopDepth: 15,
+          notchWidth: "20mm",
+          notchDepth: "40mm",
+          notchposition: 0.01,
+          gasketDepth: 5,
+          gasketWidth: 5
+        };
+        break;
+      case "MXF_50":
+        newSettings = {
+          doorDepth: 50,
+          frameDepth: 103,
+          topThk: "18.2mm",
+          sidesThk: "18.2mm",
+          doorStopOffset: "33mm",
+          doorStopWidth: 15,
+          doorStopDepth: 15,
+          notchWidth: "20mm",
+          notchDepth: "40mm",
+          notchposition: 0.01,
+          gasketDepth: 5,
+          gasketWidth: 5
+        };
+        break;
+      case "MXCAF_40":
+        newSettings = {
+          doorDepth: 38,
+          frameDepth: 103,
+          topThk: "18mm",
+          sidesThk: "18mm",
+          doorStopOffset: "45mm",
+          doorStopWidth: 15,
+          doorStopDepth: 15,
+          notchWidth: "20mm",
+          notchDepth: "40mm",
+          notchposition: 0.01,
+          gasketDepth: 5,
+          gasketWidth: 5
+        };
+        break;
+      case "MXCAF_50":
+        newSettings = {
+          doorDepth: 50,
+          frameDepth: 103,
+          topThk: "18.2mm",
+          sidesThk: "18.2mm",
+          doorStopOffset: "33mm",
+          doorStopWidth: 15,
+          doorStopDepth: 15,
+          notchWidth: "20mm",
+          notchDepth: "40mm",
+          notchposition: 0.01,
+          gasketDepth: 5,
+          gasketWidth: 5
+        };
+        break;
+    }
+    const isMxCaf = frameType.startsWith("MXCAF");
+    setFrontCoverPanel(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+      visible: isMxCaf
+    }));
+    setBackCoverPanel(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+      visible: isMxCaf
+    }));
+    const {
+        doorDepth
+      } = newSettings,
+      newFrameSettings = _objectWithoutProperties(newSettings, _excluded$1);
+    setDoorFrame(prev => _objectSpread2(_objectSpread2({}, prev), newFrameSettings));
+    if (doorDepth !== undefined) {
+      setDoor(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+        theDoorDepth: doorDepth
+      }));
+    }
+  }, [frameType]);
+
+  // ---  Exterior Fanlight Logic ---
+  require$$0.useEffect(() => {
+    if (!exteriorFanlight.visible) return;
+    switch (exteriorFanlightType) {
+      case "WPFL":
+        setExteriorFanlight(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+          depth: doorFrame.frameDepth
+        }));
+        setTestExteriorFanlightMaterial("metal");
+        break;
+      case "ALDGL":
+        setExteriorFanlight(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+          depth: doorFrame.frameDepth
+        }));
+        setTestExteriorFanlightMaterial("glass");
+        break;
+      case "ALSGL":
+        setExteriorFanlight(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+          depth: 40
+        }));
+        setTestExteriorFanlightMaterial("glass");
+        break;
+    }
+  }, [exteriorFanlight.visible, exteriorFanlightType, doorFrame.frameDepth, setTestExteriorFanlightMaterial, setExteriorFanlight]);
+  require$$0.useEffect(() => {
+    const topThkValue = parseInt(doorFrame.topThk) || 0;
+    const exteriorFanlightHeight = exteriorFanlight.visible ? exteriorFanlight.height : 0;
+    const newDoorHeight = totalHeight - topThkValue - exteriorFanlightHeight;
+    setDoor(prevDoor => _objectSpread2(_objectSpread2({}, prevDoor), {}, {
+      doorHeight: newDoorHeight > 0 ? newDoorHeight : 0
+    }));
+  }, [totalHeight, doorFrame.topThk, exteriorFanlight.visible, exteriorFanlight.height]);
+  require$$0.useEffect(() => {
+    const sidesThkValue = parseInt(doorFrame.sidesThk) || 0;
+    const newDoorWidth = totalWidth - sidesThkValue * 2;
+    setDoor(prevDoor => _objectSpread2(_objectSpread2({}, prevDoor), {}, {
+      doorWidth: newDoorWidth > 0 ? newDoorWidth : 0
+    }));
+  }, [totalWidth, doorFrame.sidesThk]);
+  return /*#__PURE__*/jsxRuntimeExports.jsx(ConfiguratorContext.Provider, {
+    value: {
+      isPlaneVisible,
+      setIsPlaneVisible,
+      isFrameVisible,
+      setIsFrameVisible,
+      cpid,
+      setCpid,
+      door,
+      setDoor,
+      doorFrame,
+      setDoorFrame,
+      interiorFanlight,
+      setInteriorFanlight,
+      exteriorFanlight,
+      setExteriorFanlight,
+      occulus,
+      setOcculus,
+      frontCoverPanel,
+      setFrontCoverPanel,
+      backCoverPanel,
+      setBackCoverPanel,
+      glass,
+      setGlass,
+      frameType,
+      setFrameType,
+      bodyType,
+      setBodyType,
+      totalHeight,
+      setTotalHeight,
+      totalWidth,
+      setTotalWidth,
+      exteriorFanlightType,
+      setExteriorFanlightType,
+      testDoorMaterial,
+      setTestDoorMaterial,
+      testFrameMaterial,
+      setTestFrameMaterial,
+      testGasketMaterial,
+      setTestGasketMaterial,
+      testInteriorFanlightMaterial,
+      setTestInteriorFanlightMaterial,
+      testExteriorFanlightMaterial,
+      setTestExteriorFanlightMaterial,
+      testOcculusInfillMaterial,
+      setTestOcculusInfillMaterial,
+      testGlassInfillMaterial,
+      setTestGlassInfillMaterial,
+      testDoorStopMaterial,
+      setTestDoorStopMaterial,
+      testHingeMaterial,
+      setTestHingeMaterial,
+      testFrontCoverPanelMaterial,
+      setTestFrontCoverPanelMaterial,
+      testBackCoverPanelMaterial,
+      setTestBackCoverPanelMaterial,
+      glassVisible,
+      setGlassVisible,
+      glassDepth,
+      setGlassDepth,
+      handleParseCpid
+    },
+    children: children
+  });
+};
+const useConfigurator = () => {
+  const context = require$$0.useContext(ConfiguratorContext);
+  if (!context) {
+    throw new Error("useConfigurator must be used within a ConfiguratorProvider");
+  }
+  return context;
+};
+
+const placeholderMaterial = new THREE__namespace.MeshStandardMaterial({
+  color: "#cccccc",
+  roughness: 0.8
+});
+const placeholderMaterialforFrames = new THREE__namespace.MeshStandardMaterial({
+  color: "#000",
+  roughness: 0.8
+});
+const availableMaterials = {
+  black: new THREE__namespace.MeshStandardMaterial({
+    color: "#000000"
+  }),
+  metal: new THREE__namespace.MeshStandardMaterial({
+    color: "#0xaaaaaa",
+    metalness: 1.0,
+    roughness: 0.4
+  }),
+  darkgrey: new THREE__namespace.MeshStandardMaterial({
+    color: "#5e5e5e"
+  }),
+  grey: new THREE__namespace.MeshStandardMaterial({
+    color: "#cccccc"
+  }),
+  yellow: new THREE__namespace.MeshStandardMaterial({
+    color: "#ffff00"
+  }),
+  darkBrown: new THREE__namespace.MeshStandardMaterial({
+    color: "#a0522d"
+  }),
+  brown: new THREE__namespace.MeshStandardMaterial({
+    color: "#d2b48c"
+  }),
+  glass: new THREE__namespace.MeshStandardMaterial({
+    color: "#ffffff",
+    roughness: 0.1,
+    transparent: true,
+    opacity: 0.7
+  }),
+  aluminum: new THREE__namespace.MeshStandardMaterial({
+    color: "#dcdcdc",
+    metalness: 1.0,
+    roughness: 0.3
+  }),
+  silver: new THREE__namespace.MeshStandardMaterial({
+    color: "#c0c0c0",
+    metalness: 1.0,
+    roughness: 0.2
+  }),
+  gold: new THREE__namespace.MeshStandardMaterial({
+    color: "#ffd700",
+    metalness: 1.0,
+    roughness: 0.3
+  }),
+  diamond: new THREE__namespace.MeshStandardMaterial({
+    color: "#e0f7fa",
+    metalness: 0.9,
+    roughness: 0.05,
+    transparent: true,
+    opacity: 0.9,
+    envMapIntensity: 1.5
+  })
+};
+function GlassHinge(_ref) {
+  let {
+    position,
+    pivot,
+    frameSideWidth,
+    doorDepthM,
+    material,
+    gasketMaterial
+  } = _ref;
+  const plateWidth = 130 / 1000;
+  const plateHeight = 55 / 1000;
+  const plateThickness = 8 / 1000;
+  const gasketThickness = 1 / 1000;
+  const pivotRadius = 10 / 1000;
+  const pivotHeight = plateHeight;
+  const sideMultiplier = pivot === "left" ? 1 : -1;
+  const plateOffsetX = sideMultiplier * (plateWidth / 2 + frameSideWidth);
+  const holeRadius = 10 / 1000;
+  const holeSpacingX = 45 / 1000;
+  return /*#__PURE__*/jsxRuntimeExports.jsxs("group", {
+    position: position,
+    children: [/*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+      material: material,
+      castShadow: true,
+      receiveShadow: true,
+      "position-x": 0.01,
+      children: /*#__PURE__*/jsxRuntimeExports.jsx("cylinderGeometry", {
+        args: [pivotRadius, pivotRadius, pivotHeight, 32]
+      })
+    }), /*#__PURE__*/jsxRuntimeExports.jsxs("group", {
+      "position-x": plateOffsetX,
+      children: [/*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+        "position-z": -(doorDepthM / 2) - plateThickness / 2 - gasketThickness,
+        material: material,
+        castShadow: true,
+        receiveShadow: true,
+        children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+          args: [plateWidth, plateHeight, plateThickness]
+        })
+      }), /*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+        "position-z": -(doorDepthM / 2) - gasketThickness / 2,
+        material: gasketMaterial,
+        castShadow: true,
+        receiveShadow: true,
+        children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+          args: [plateWidth, plateHeight, gasketThickness]
+        })
+      }), /*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+        "position-z": doorDepthM / 2 + plateThickness / 2 + gasketThickness,
+        castShadow: true,
+        receiveShadow: true,
+        children: /*#__PURE__*/jsxRuntimeExports.jsxs(csg.Geometry, {
+          useGroups: true,
+          children: [/*#__PURE__*/jsxRuntimeExports.jsx(csg.Base, {
+            material: material,
+            children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+              args: [plateWidth, plateHeight, plateThickness]
+            })
+          }), /*#__PURE__*/jsxRuntimeExports.jsx(csg.Subtraction, {
+            position: [-sideMultiplier * (holeSpacingX / 2), 0, 0],
+            rotation: [Math.PI / 2, 0, 0],
+            children: /*#__PURE__*/jsxRuntimeExports.jsx("cylinderGeometry", {
+              args: [holeRadius, holeRadius, plateThickness + 0.01, 32]
+            })
+          }), /*#__PURE__*/jsxRuntimeExports.jsx(csg.Subtraction, {
+            position: [sideMultiplier * (holeSpacingX / 2), 0, 0],
+            rotation: [Math.PI / 2, 0, 0],
+            children: /*#__PURE__*/jsxRuntimeExports.jsx("cylinderGeometry", {
+              args: [holeRadius, holeRadius, plateThickness + 0.01, 32]
+            })
+          })]
+        })
+      }), /*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+        "position-z": doorDepthM / 2 + gasketThickness / 2,
+        material: gasketMaterial,
+        castShadow: true,
+        receiveShadow: true,
+        children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+          args: [plateWidth, plateHeight, gasketThickness]
+        })
+      })]
+    })]
+  });
+}
+function DoorStopCuts(_ref2) {
+  let {
+    visible,
+    width,
+    height,
+    stopWidth,
+    stopDepth,
+    stopPositionZ,
+    centerZ,
+    glassDepthOffset = 0,
+    material,
+    setName
+  } = _ref2;
+  if (!visible) return null;
+  return /*#__PURE__*/jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, {
+    children: [/*#__PURE__*/jsxRuntimeExports.jsx(csg.Subtraction, {
+      name: "cut-top-".concat(setName),
+      material: material,
+      position: [0, height / 2 - stopWidth / 2 + 0.0001, stopPositionZ - centerZ],
+      children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+        args: [width + 0.01, stopWidth, stopDepth + 0.01]
+      })
+    }), /*#__PURE__*/jsxRuntimeExports.jsx(csg.Subtraction, {
+      name: "cut-left-".concat(setName),
+      material: material,
+      position: [-width / 2 + stopWidth / 2 - 0.0001, 0, stopPositionZ - centerZ],
+      children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+        args: [stopWidth, height + 0.01, stopDepth + 0.01]
+      })
+    }), /*#__PURE__*/jsxRuntimeExports.jsx(csg.Subtraction, {
+      name: "cut-right-".concat(setName),
+      material: material,
+      position: [width / 2 - stopWidth / 2 + 0.0001, 0, stopPositionZ - centerZ],
+      children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+        args: [stopWidth, height + 0.01, stopDepth + 0.01]
+      })
+    })]
+  });
+}
+function DoorModels(_ref3) {
+  let {
+    doorName
+  } = _ref3;
+  const {
+    isPlaneVisible,
+    isFrameVisible,
+    door,
+    doorFrame,
+    interiorFanlight,
+    exteriorFanlight,
+    occulus,
+    glass,
+    frontCoverPanel,
+    backCoverPanel,
+    frameType,
+    bodyType,
+    exteriorFanlightType,
+    testDoorMaterial,
+    testFrameMaterial,
+    testGasketMaterial,
+    testInteriorFanlightMaterial,
+    testExteriorFanlightMaterial,
+    testOcculusInfillMaterial,
+    testGlassInfillMaterial,
+    testDoorStopMaterial,
+    testHingeMaterial,
+    glassVisible,
+    testFrontCoverPanelMaterial,
+    testBackCoverPanelMaterial,
+    glassDepth,
+    handleParseCpid
+  } = useConfigurator();
+  require$$0.useEffect(() => {
+    if (doorName) {
+      handleParseCpid(doorName);
+    }
+  }, [doorName, handleParseCpid]);
+
+  // here i get material names from context
+  const {
+    doorMaterial: doorMaterialName
+  } = door;
+  const {
+    frameMaterial: frameMaterialName,
+    gasketMaterial: gasketMaterialName,
+    doorStopMaterial: doorStopMaterialName,
+    hingeMaterial: hingeMaterialName
+  } = doorFrame;
+  const {
+    material: interiorFanlightMaterialName
+  } = interiorFanlight;
+  const {
+    material: exteriorFanlightMaterialName
+  } = exteriorFanlight;
+  const {
+    material: occulusInfillMaterialName
+  } = occulus;
+  const {
+    material: glassInfillMaterialName
+  } = glass;
+  const {
+    material: frontCoverPanelMaterialName
+  } = frontCoverPanel;
+  const {
+    material: backCoverPanelMaterialName
+  } = backCoverPanel;
+
+  // --- Material Logic ---
+  const doorMaterial = require$$0.useMemo(() => availableMaterials[testDoorMaterial] || availableMaterials[doorMaterialName] || placeholderMaterial, [testDoorMaterial, doorMaterialName]);
+  const frameMaterial = require$$0.useMemo(() => availableMaterials[testFrameMaterial] || availableMaterials[frameMaterialName] || placeholderMaterialforFrames, [testFrameMaterial, frameMaterialName]);
+  const gasketMaterial = require$$0.useMemo(() => availableMaterials[testGasketMaterial] || availableMaterials[gasketMaterialName] || new THREE__namespace.MeshStandardMaterial({
+    color: "#111111"
+  }), [testGasketMaterial, gasketMaterialName]);
+  const doorStopMaterial = require$$0.useMemo(() => {
+    return availableMaterials[testDoorStopMaterial] || availableMaterials[doorStopMaterialName || ""] || frameMaterial;
+  }, [testDoorStopMaterial, doorStopMaterialName, frameType, frameMaterial]);
+  const interiorFanlightMaterial = require$$0.useMemo(() => availableMaterials[testInteriorFanlightMaterial] || availableMaterials[interiorFanlightMaterialName] || placeholderMaterial, [testInteriorFanlightMaterial, interiorFanlightMaterialName]);
+  const exteriorFanlightMaterial = require$$0.useMemo(() => availableMaterials[testExteriorFanlightMaterial] || availableMaterials[exteriorFanlightMaterialName] || placeholderMaterial, [testExteriorFanlightMaterial, exteriorFanlightMaterialName]);
+  const occulusInfillMaterial = require$$0.useMemo(() => availableMaterials[testOcculusInfillMaterial] || availableMaterials[occulusInfillMaterialName] || placeholderMaterial, [testOcculusInfillMaterial, occulusInfillMaterialName]);
+  const glassInfillMaterial = require$$0.useMemo(() => availableMaterials[testGlassInfillMaterial] || availableMaterials[glassInfillMaterialName] || placeholderMaterial, [testGlassInfillMaterial, glassInfillMaterialName]);
+  const hingeBodyMaterial = require$$0.useMemo(() => availableMaterials[testHingeMaterial] || availableMaterials[hingeMaterialName] || new THREE__namespace.MeshStandardMaterial({
+    color: "#d4d4d4",
+    metalness: 1.0,
+    roughness: 0.4
+  }), [testHingeMaterial, hingeMaterialName]);
+  const frontCoverPanelMaterial = require$$0.useMemo(() => availableMaterials[testFrontCoverPanelMaterial] || availableMaterials[frontCoverPanelMaterialName] || placeholderMaterial, [testFrontCoverPanelMaterial, frontCoverPanelMaterialName]);
+  const backCoverPanelMaterial = require$$0.useMemo(() => availableMaterials[testBackCoverPanelMaterial] || availableMaterials[backCoverPanelMaterialName] || placeholderMaterial, [testBackCoverPanelMaterial, backCoverPanelMaterialName]);
+  const hingeAccentMaterial = require$$0.useMemo(() => new THREE__namespace.MeshStandardMaterial({
+    color: "#1a1a1a",
+    roughness: 0.1
+  }), []);
+
+  // --- Dimension calculations ---
+  const {
+    doorWidth,
+    doorHeight,
+    theDoorDepth,
+    doorPivot,
+    doorOpening
+  } = door;
+  const {
+    frameDepth,
+    topThk,
+    sidesThk,
+    doorStopWidth,
+    doorStopDepth,
+    doorStopOffset,
+    notchWidth,
+    notchDepth,
+    notchposition,
+    gasketWidth,
+    gasketDepth,
+    secondDoorStopWidth,
+    secondDoorStopDepth,
+    secondDoorStopOffset
+  } = doorFrame;
+  const {
+    height: interiorFanlightHeightValue
+  } = interiorFanlight;
+  const {
+    height: exteriorFanlightHeightValue,
+    depth: exteriorFanlightDepthValue
+  } = exteriorFanlight;
+  const {
+    x1: occulusX1,
+    x2: occulusX2,
+    y1: occulusY1,
+    y2: occulusY2,
+    depth: occulusInfillDepth
+  } = occulus;
+  const {
+    width: architraveWidth,
+    depth: architraveDepth
+  } = frontCoverPanel;
+  const interiorFanlightHeight = interiorFanlight.visible ? interiorFanlightHeightValue : 0;
+  const mainDoorHeight = doorHeight - interiorFanlightHeight;
+  const topThkValue = parseInt(topThk) || 20;
+  const sidesThkValue = parseInt(sidesThk) || 20;
+
+  // Convert dimensions from mm to meters
+  const doorWidthM = doorWidth / 1000;
+  const mainDoorHeightM = mainDoorHeight / 1000;
+  const interiorFanlightHeightM = interiorFanlightHeight / 1000;
+  const totalOpeningHeightM = doorHeight / 1000;
+  const doorDepthM = theDoorDepth / 1000;
+  const frameDepthM = frameDepth / 1000;
+  const topFrameWidthM = topThkValue / 1000;
+  const sidesFrameWidthM = sidesThkValue / 1000;
+  const exteriorFanlightHeightM = exteriorFanlightHeightValue / 1000;
+  const exteriorFanlightDepthM = exteriorFanlightDepthValue / 1000;
+  const occulusX1M = occulusX1 / 1000;
+  const occulusX2M = occulusX2 / 1000;
+  const occulusY1M = occulusY1 / 1000;
+  const occulusY2M = occulusY2 / 1000;
+  const occulusInfillDepthM = occulusInfillDepth / 1000;
+  const doorStopWidthM = doorStopWidth / 1000;
+  const doorStopDepthM = doorStopDepth / 1000;
+
+  // Architrave Dimensions
+  const architraveProfileM = architraveWidth / 1000;
+  const architraveDepthM = architraveDepth / 1000;
+
+  // Gasket Dimensions
+  const gasketWidthM = gasketWidth / 1000;
+  const gasketDepthM = gasketDepth / 1000;
+  const doorStopOffsetValue = parseInt(doorStopOffset);
+  const doorStopOffsetFromEdgeM = doorStopOffsetValue / 1000;
+  const notchDepthValue = parseInt(notchDepth) || 40;
+  const notchWidthValue = parseInt(notchWidth) || 20;
+  const notchWidthM = notchWidthValue / 1000;
+  const notchDepthM = notchDepthValue / 1000;
+  const isOpeningIn = doorOpening === "in";
+  const doorStopPositionZ = require$$0.useMemo(() => isOpeningIn ? frameDepthM / 2 - doorStopOffsetFromEdgeM - doorStopDepthM / 2 : -frameDepthM / 2 + doorStopOffsetFromEdgeM + doorStopDepthM / 2, [isOpeningIn, frameDepthM, doorStopOffsetFromEdgeM, doorStopDepthM]);
+  const gasketZPosition = require$$0.useMemo(() => isOpeningIn ? doorStopPositionZ - doorStopDepthM / 2 - gasketDepthM / 2 : doorStopPositionZ + doorStopDepthM / 2 + gasketDepthM / 2, [isOpeningIn, doorStopPositionZ, doorStopDepthM, gasketDepthM]);
+  const secondDoorStopWidthM = secondDoorStopWidth / 1000;
+  const secondDoorStopDepthM = secondDoorStopDepth / 1000;
+  const secondDoorStopPositionZ = isOpeningIn ? frameDepthM / 2 - secondDoorStopDepthM / 2 : -frameDepthM / 2 + secondDoorStopDepthM / 2;
+
+  // Position the first glass panel against the primary doorstop
+
+  const secondGasketZPosition = isOpeningIn ? secondDoorStopPositionZ - secondDoorStopDepthM / 2 - gasketDepthM / 2 : secondDoorStopPositionZ + secondDoorStopDepthM / 2 + gasketDepthM / 2;
+  const doorCenterZ = require$$0.useMemo(() => {
+    if (frameType === "WF_FLI") {
+      if (isOpeningIn) {
+        return frameDepthM / 2 - doorDepthM / 2;
+      } else {
+        return -frameDepthM / 2 + doorDepthM / 2;
+      }
+    }
+    if (frameType === "WDGF_WDG100" || frameType === "WF_100") {
+      return 0;
+    } else {
+      if (isOpeningIn) {
+        const gasketBackFaceZ = gasketZPosition - gasketDepthM / 2;
+        return gasketBackFaceZ - doorDepthM / 2;
+      } else {
+        const gasketFrontFaceZ = gasketZPosition + gasketDepthM / 2;
+        return gasketFrontFaceZ + doorDepthM / 2;
+      }
+    }
+  }, [isOpeningIn, gasketZPosition, gasketDepthM, doorDepthM, frameType, frameDepthM]);
+  const GlassPanelDepthM = glassDepth / 1000;
+  const frontGlassOffsetZ = doorDepthM / 2 + GlassPanelDepthM / 2;
+  const backGlassOffsetZ = -doorDepthM / 2 - GlassPanelDepthM / 2;
+  const exteriorFanlightZPosition = exteriorFanlightType === "ALSGFL" ? 0 // Center it
+  : isOpeningIn ? -frameDepthM / 2 + exteriorFanlightDepthM / 2 : frameDepthM / 2 - exteriorFanlightDepthM / 2;
+  const occulusWidthM = doorWidthM - occulusX1M - occulusX2M;
+  const occulusHeightM = mainDoorHeightM - occulusY1M - occulusY2M;
+  const occulusPositionXM = (occulusX1M - occulusX2M) / 2;
+  const occulusPositionYM = (occulusY2M - occulusY1M) / 2;
+  const [isOpen, setIsOpen] = require$$0.useState(false);
+  const hingeSideX = doorPivot === "left" ? -doorWidthM / 2 : doorWidthM / 2;
+  const leftGlass_Z = -frameDepthM / 2 + GlassPanelDepthM / 2 - GlassPanelDepthM;
+  const rightGlass_Z = frameDepthM / 2 - GlassPanelDepthM / 2 + GlassPanelDepthM;
+  // --- PIVOT ---
+  const hingeZ = require$$0.useMemo(() => {
+    if (frameType === "WF_FLI") {
+      if (isOpeningIn) {
+        return doorCenterZ - doorDepthM / 2;
+      } else {
+        return doorCenterZ + doorDepthM / 2;
+      }
+    }
+    return isOpeningIn ? -frameDepthM / 2 : frameDepthM / 2;
+  }, [frameType, isOpeningIn, doorCenterZ, doorDepthM, frameDepthM]);
+  const doorOffsetZ = require$$0.useMemo(() => doorCenterZ - hingeZ, [doorCenterZ, hingeZ]);
+  const directionMultiplier = doorOpening === "in" ? 1 : -1;
+  const {
+    rotation
+  } = three.useSpring({
+    rotation: isOpen ? [0, (doorPivot === "left" ? Math.PI / 2 : -Math.PI / 2) * directionMultiplier, 0] : [0, 0, 0],
+    config: {
+      mass: 1,
+      tension: 100,
+      friction: 20
+    }
+  });
+  const handleClick = () => setIsOpen(!isOpen);
+  const totalFrameWidth = doorWidthM + sidesFrameWidthM * 2;
+  const totalFrameHeightM = totalOpeningHeightM + topFrameWidthM;
+  const sideFrameCenterY = topFrameWidthM / 2;
+  const interiorFanlightYPosition = totalOpeningHeightM / 2 - interiorFanlightHeightM / 2;
+  const doorYPosition = -totalOpeningHeightM / 2 + mainDoorHeightM / 2;
+  const topFrameCenterY = totalOpeningHeightM / 2 + topFrameWidthM / 2;
+  const topOfFrameY = topFrameCenterY + topFrameWidthM / 2;
+  const exteriorFanlightYPosition = topOfFrameY + exteriorFanlightHeightM / 2;
+  const frontArchitraveZ = frameDepthM / 2 + architraveDepthM / 2;
+  const backArchitraveZ = -frameDepthM / 2 - architraveDepthM / 2;
+  const sideArchitraveHeight = totalOpeningHeightM;
+  const sideArchitraveCenterY = 0;
+  const leftArchitraveX = -doorWidthM / 2 - architraveProfileM / 2;
+  const rightArchitraveX = doorWidthM / 2 + architraveProfileM / 2;
+  const topArchitraveY = totalOpeningHeightM / 2 + architraveProfileM / 2;
+  const topArchitraveWidth = doorWidthM + 2 * architraveProfileM;
+
+  // --- Primary Gasket Edge Position Calculations ---
+  const topGasketYPosition = totalOpeningHeightM / 2 - doorStopWidthM + gasketWidthM / 2;
+  const leftGasketXPosition = -doorWidthM / 2 + doorStopWidthM - gasketWidthM / 2;
+  const rightGasketXPosition = doorWidthM / 2 - doorStopWidthM + gasketWidthM / 2;
+
+  // --- Second Gasket ---
+
+  const secondTopGasketYPosition = totalOpeningHeightM / 2 - secondDoorStopWidthM + gasketWidthM / 2;
+  const secondLeftGasketXPosition = -doorWidthM / 2 + secondDoorStopWidthM - gasketWidthM / 2;
+  const secondRightGasketXPosition = doorWidthM / 2 - secondDoorStopWidthM + gasketWidthM / 2;
+  // --- HINGE CALCULATIONS ---
+  const hingeTotalHeightM = 120 / 1000;
+  const hingeRadiusM = 8 / 1000;
+  const capHeightM = 4 / 1000;
+  const separatorHeightM = 4 / 1000;
+  const barrelPartHeight = (hingeTotalHeightM - capHeightM * 2 - separatorHeightM) / 2;
+
+  // --- HINGE VISIBILITY LOGIC ---
+  const isGlassDoor = require$$0.useMemo(() => ["SG8", "SG10", "SG12"].includes(bodyType), [bodyType]);
+
+  // Calculate evenly spaced hinge positions
+  const standardHingeYPositions = require$$0.useMemo(() => {
+    const numHinges = 4;
+    const topMargin = 180 / 1000;
+    const bottomMargin = 180 / 1000;
+    const availableHeight = mainDoorHeightM - topMargin - bottomMargin;
+    const spacing = availableHeight / (numHinges - 1);
+    const positions = [];
+    for (let i = 0; i < numHinges; i++) {
+      positions.push(mainDoorHeightM / 2 - topMargin - i * spacing);
+    }
+    return positions;
+  }, [mainDoorHeightM]);
+
+  // Y positions for the new glass hinges
+  const glassHingeYPositions = require$$0.useMemo(() => {
+    const topMargin = 250 / 1000;
+    const secondTopMargin = 450 / 1000;
+    const bottomMargin = 250 / 1000;
+    const top = mainDoorHeightM / 2 - topMargin;
+    const secondTop = mainDoorHeightM / 2 - secondTopMargin;
+    const bottom = -mainDoorHeightM / 2 + bottomMargin;
+    return [top, secondTop, bottom];
+  }, [mainDoorHeightM]);
+  const isStandardHingeVisible = require$$0.useMemo(() => {
+    if (isGlassDoor) return false;
+    if (!isFrameVisible) return false;
+    const invisibleFrameTypes = ["WDGF_WDG100", "WF_100", "WF_FLI"];
+    if (invisibleFrameTypes.includes(frameType)) {
+      return false;
+    }
+    return true;
+  }, [isFrameVisible, frameType, isGlassDoor]);
+  return /*#__PURE__*/jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, {
+    children: [frontCoverPanel.visible && /*#__PURE__*/jsxRuntimeExports.jsxs("group", {
+      "position-z": frontArchitraveZ,
+      children: [/*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+        position: [0, topArchitraveY, 0],
+        castShadow: true,
+        material: frontCoverPanelMaterial,
+        children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+          args: [topArchitraveWidth, architraveProfileM, architraveDepthM]
+        })
+      }), /*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+        position: [leftArchitraveX, sideArchitraveCenterY, 0],
+        castShadow: true,
+        material: frontCoverPanelMaterial,
+        children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+          args: [architraveProfileM, sideArchitraveHeight, architraveDepthM]
+        })
+      }), /*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+        position: [rightArchitraveX, sideArchitraveCenterY, 0],
+        castShadow: true,
+        material: frontCoverPanelMaterial,
+        children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+          args: [architraveProfileM, sideArchitraveHeight, architraveDepthM]
+        })
+      })]
+    }), backCoverPanel.visible && /*#__PURE__*/jsxRuntimeExports.jsxs("group", {
+      "position-z": backArchitraveZ,
+      children: [/*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+        position: [0, topArchitraveY, 0],
+        castShadow: true,
+        material: backCoverPanelMaterial,
+        children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+          args: [topArchitraveWidth, architraveProfileM, architraveDepthM]
+        })
+      }), /*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+        position: [leftArchitraveX, sideArchitraveCenterY, 0],
+        castShadow: true,
+        material: backCoverPanelMaterial,
+        children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+          args: [architraveProfileM, sideArchitraveHeight, architraveDepthM]
+        })
+      }), /*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+        position: [rightArchitraveX, sideArchitraveCenterY, 0],
+        castShadow: true,
+        material: backCoverPanelMaterial,
+        children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+          args: [architraveProfileM, sideArchitraveHeight, architraveDepthM]
+        })
+      })]
+    }), exteriorFanlight.visible && /*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+      position: [0, exteriorFanlightYPosition, exteriorFanlightZPosition],
+      castShadow: true,
+      material: exteriorFanlightMaterial,
+      children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+        args: [totalFrameWidth, exteriorFanlightHeightM, exteriorFanlightDepthM]
+      })
+    }), isFrameVisible && /*#__PURE__*/jsxRuntimeExports.jsxs("group", {
+      children: [/*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+        castShadow: true,
+        position: [0, topFrameCenterY, 0],
+        children: /*#__PURE__*/jsxRuntimeExports.jsxs(csg.Geometry, {
+          useGroups: true,
+          children: [/*#__PURE__*/jsxRuntimeExports.jsx(csg.Base, {
+            name: "frame-base",
+            material: frameMaterial,
+            children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+              args: [doorWidthM, topFrameWidthM, frameDepthM]
+            })
+          }), !["MXF_40", "MXF_50", "MXCAF_40", "MXCAF_50"].includes(frameType) && /*#__PURE__*/jsxRuntimeExports.jsx(csg.Subtraction, {
+            name: "cut-exterior",
+            material: frameMaterial,
+            position: [0, notchposition, 0],
+            children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+              args: [doorWidthM + 0.01, notchWidthM, notchDepthM]
+            })
+          })]
+        })
+      }), /*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+        castShadow: true,
+        position: [-doorWidthM / 2 - sidesFrameWidthM / 2, sideFrameCenterY, 0],
+        children: /*#__PURE__*/jsxRuntimeExports.jsxs(csg.Geometry, {
+          useGroups: true,
+          children: [/*#__PURE__*/jsxRuntimeExports.jsx(csg.Base, {
+            name: "frame-base",
+            material: frameMaterial,
+            children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+              args: [sidesFrameWidthM, totalFrameHeightM, frameDepthM]
+            })
+          }), !["MXF_40", "MXF_50", "MXCAF_40", "MXCAF_50"].includes(frameType) && /*#__PURE__*/jsxRuntimeExports.jsx(csg.Subtraction, {
+            name: "cut-exterior",
+            material: frameMaterial,
+            position: [-notchposition, 0, 0],
+            children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+              args: [notchWidthM, totalFrameHeightM + 0.01, notchDepthM]
+            })
+          })]
+        })
+      }), /*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+        castShadow: true,
+        position: [doorWidthM / 2 + sidesFrameWidthM / 2, sideFrameCenterY, 0],
+        children: /*#__PURE__*/jsxRuntimeExports.jsxs(csg.Geometry, {
+          useGroups: true,
+          children: [/*#__PURE__*/jsxRuntimeExports.jsx(csg.Base, {
+            name: "frame-base",
+            material: frameMaterial,
+            children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+              args: [sidesFrameWidthM, totalFrameHeightM, frameDepthM]
+            })
+          }), !["MXF_40", "MXF_50", "MXCAF_40", "MXCAF_50"].includes(frameType) && /*#__PURE__*/jsxRuntimeExports.jsx(csg.Subtraction, {
+            name: "cut-exterior",
+            material: frameMaterial,
+            position: [notchposition, 0, 0],
+            children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+              args: [notchWidthM, totalFrameHeightM + 0.01, notchDepthM]
+            })
+          })]
+        })
+      }), /*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+        castShadow: true,
+        position: [0, totalOpeningHeightM / 2 - doorStopWidthM / 2, doorStopPositionZ],
+        material: doorStopMaterial,
+        children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+          args: [doorWidthM, doorStopWidthM, doorStopDepthM]
+        })
+      }), /*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+        castShadow: true,
+        position: [-doorWidthM / 2 + doorStopWidthM / 2, 0, doorStopPositionZ],
+        material: doorStopMaterial,
+        children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+          args: [doorStopWidthM, totalOpeningHeightM, doorStopDepthM]
+        })
+      }), /*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+        castShadow: true,
+        position: [doorWidthM / 2 - doorStopWidthM / 2, 0, doorStopPositionZ],
+        material: doorStopMaterial,
+        children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+          args: [doorStopWidthM, totalOpeningHeightM, doorStopDepthM]
+        })
+      }), frameType !== "WF_FLI" && /*#__PURE__*/jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, {
+        children: [/*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+          castShadow: true,
+          position: [0, topGasketYPosition, gasketZPosition],
+          material: gasketMaterial,
+          children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+            args: [doorWidthM - 0.03, gasketWidthM + 0.005, gasketDepthM]
+          })
+        }), /*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+          castShadow: true,
+          position: [leftGasketXPosition - 0.005, -0.005, gasketZPosition],
+          material: gasketMaterial,
+          children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+            args: [gasketWidthM + 0.005, totalOpeningHeightM - 0.02, gasketDepthM]
+          })
+        }), /*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+          castShadow: true,
+          position: [rightGasketXPosition + 0.005, -0.005, gasketZPosition],
+          material: gasketMaterial,
+          children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+            args: [gasketWidthM + 0.005, totalOpeningHeightM - 0.02, gasketDepthM]
+          })
+        })]
+      }), (frameType === "WDGF_WDG100" || frameType === "WF_100" || frameType === "WF_FLI") && /*#__PURE__*/jsxRuntimeExports.jsxs("group", {
+        children: [/*#__PURE__*/jsxRuntimeExports.jsxs("group", {
+          children: [/*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+            castShadow: true,
+            position: [0, totalOpeningHeightM / 2 - secondDoorStopWidthM / 2, secondDoorStopPositionZ],
+            material: doorStopMaterial,
+            children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+              args: [doorWidthM, secondDoorStopWidthM, secondDoorStopDepthM]
+            })
+          }), /*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+            castShadow: true,
+            position: [-doorWidthM / 2 + secondDoorStopWidthM / 2, 0, secondDoorStopPositionZ],
+            material: doorStopMaterial,
+            children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+              args: [secondDoorStopWidthM, totalOpeningHeightM, secondDoorStopDepthM]
+            })
+          }), /*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+            castShadow: true,
+            position: [doorWidthM / 2 - secondDoorStopWidthM / 2, 0, secondDoorStopPositionZ],
+            material: doorStopMaterial,
+            children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+              args: [secondDoorStopWidthM, totalOpeningHeightM, secondDoorStopDepthM]
+            })
+          })]
+        }), /*#__PURE__*/jsxRuntimeExports.jsxs("group", {
+          children: [/*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+            castShadow: true,
+            position: [0, secondTopGasketYPosition - 0.005, secondGasketZPosition],
+            material: gasketMaterial,
+            children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+              args: [doorWidthM - 0.03, gasketWidthM + 0.005, gasketDepthM]
+            })
+          }), /*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+            castShadow: true,
+            position: [secondLeftGasketXPosition - 0.005, -0.01, secondGasketZPosition],
+            material: gasketMaterial,
+            children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+              args: [gasketWidthM + 0.005, totalOpeningHeightM - 0.04, gasketDepthM]
+            })
+          }), /*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+            castShadow: true,
+            position: [secondRightGasketXPosition + 0.005, -0.01, secondGasketZPosition],
+            material: gasketMaterial,
+            children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+              args: [gasketWidthM + 0.004, totalOpeningHeightM - 0.04, gasketDepthM]
+            })
+          })]
+        }), glassVisible && /*#__PURE__*/jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, {
+          children: [/*#__PURE__*/jsxRuntimeExports.jsxs("group", {
+            children: [(frameType === "WDGF_WDG100" || frameType === "WF_100") && /*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+              castShadow: true,
+              position: [0, topFrameCenterY - secondDoorStopWidthM / 2, leftGlass_Z],
+              material: glassInfillMaterial,
+              children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+                args: [doorWidthM - 2 * secondDoorStopWidthM, topFrameWidthM + secondDoorStopWidthM, GlassPanelDepthM]
+              })
+            }), frameType !== "WDGF_WDG100" && frameType !== "WF_100" && /*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+              castShadow: true,
+              position: [0, topFrameCenterY, leftGlass_Z],
+              material: glassInfillMaterial,
+              children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+                args: [doorWidthM - 2 * secondDoorStopWidthM, topFrameWidthM, GlassPanelDepthM]
+              })
+            }), /*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+              castShadow: true,
+              position: [-doorWidthM / 2 - sidesFrameWidthM / 2 + secondDoorStopWidthM / 2, sideFrameCenterY, leftGlass_Z],
+              material: glassInfillMaterial,
+              children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+                args: [sidesFrameWidthM + secondDoorStopWidthM, totalFrameHeightM, GlassPanelDepthM]
+              })
+            }), /*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+              castShadow: true,
+              position: [doorWidthM / 2 + sidesFrameWidthM / 2 - secondDoorStopWidthM / 2, sideFrameCenterY, leftGlass_Z],
+              material: glassInfillMaterial,
+              children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+                args: [sidesFrameWidthM + secondDoorStopWidthM, totalFrameHeightM, GlassPanelDepthM]
+              })
+            })]
+          }), /*#__PURE__*/jsxRuntimeExports.jsxs("group", {
+            children: [/*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+              castShadow: true,
+              position: [0, topFrameCenterY, rightGlass_Z],
+              material: glassInfillMaterial,
+              children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+                args: [doorWidthM, topFrameWidthM, GlassPanelDepthM]
+              })
+            }), /*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+              castShadow: true,
+              position: [-doorWidthM / 2 - sidesFrameWidthM / 2, sideFrameCenterY, rightGlass_Z],
+              material: glassInfillMaterial,
+              children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+                args: [sidesFrameWidthM, totalFrameHeightM, GlassPanelDepthM]
+              })
+            }), /*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+              castShadow: true,
+              position: [doorWidthM / 2 + sidesFrameWidthM / 2, sideFrameCenterY, rightGlass_Z],
+              material: glassInfillMaterial,
+              children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+                args: [sidesFrameWidthM, totalFrameHeightM, GlassPanelDepthM]
+              })
+            })]
+          })]
+        })]
+      })]
+    }), interiorFanlight.visible && /*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+      position: [0, interiorFanlightYPosition, doorCenterZ],
+      castShadow: true,
+      material: interiorFanlightMaterial,
+      children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+        args: [doorWidthM, interiorFanlightHeightM, doorDepthM]
+      })
+    }), isStandardHingeVisible && standardHingeYPositions.map((y, index) => /*#__PURE__*/jsxRuntimeExports.jsxs("group", {
+      position: [hingeSideX, doorYPosition + y, hingeZ],
+      children: [/*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+        material: hingeBodyMaterial,
+        position: [0, separatorHeightM / 2 + barrelPartHeight / 2, 0],
+        castShadow: true,
+        children: /*#__PURE__*/jsxRuntimeExports.jsx("cylinderGeometry", {
+          args: [hingeRadiusM, hingeRadiusM, barrelPartHeight, 32]
+        })
+      }), /*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+        material: hingeAccentMaterial,
+        position: [0, separatorHeightM / 2 + barrelPartHeight + capHeightM / 2, 0],
+        castShadow: true,
+        children: /*#__PURE__*/jsxRuntimeExports.jsx("cylinderGeometry", {
+          args: [hingeRadiusM, hingeRadiusM, capHeightM, 32]
+        })
+      })]
+    }, "frame-hinge-".concat(index))), /*#__PURE__*/jsxRuntimeExports.jsxs(three.a.group, {
+      position: [hingeSideX, doorYPosition, hingeZ],
+      rotation: rotation.to((x, y, z) => [x, y, z]),
+      onClick: handleClick,
+      onPointerOver: () => document.body.style.cursor = "pointer",
+      onPointerOut: () => document.body.style.cursor = "auto",
+      children: [isStandardHingeVisible && standardHingeYPositions.map((y, index) => /*#__PURE__*/jsxRuntimeExports.jsxs("group", {
+        position: [0, y, 0],
+        children: [/*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+          material: hingeBodyMaterial,
+          position: [0, -separatorHeightM / 2 - barrelPartHeight / 2, 0],
+          castShadow: true,
+          children: /*#__PURE__*/jsxRuntimeExports.jsx("cylinderGeometry", {
+            args: [hingeRadiusM, hingeRadiusM, barrelPartHeight, 32]
+          })
+        }), /*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+          material: hingeAccentMaterial,
+          position: [0, -separatorHeightM / 2 - barrelPartHeight - capHeightM / 2, 0],
+          castShadow: true,
+          children: /*#__PURE__*/jsxRuntimeExports.jsx("cylinderGeometry", {
+            args: [hingeRadiusM, hingeRadiusM, capHeightM, 32]
+          })
+        }), /*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+          material: hingeAccentMaterial,
+          position: [0, 0, 0],
+          castShadow: true,
+          children: /*#__PURE__*/jsxRuntimeExports.jsx("cylinderGeometry", {
+            args: [hingeRadiusM, hingeRadiusM, separatorHeightM, 32]
+          })
+        })]
+      }, "door-hinge-".concat(index))), isGlassDoor && isFrameVisible && glassHingeYPositions.map((y, index) => /*#__PURE__*/jsxRuntimeExports.jsx(GlassHinge, {
+        position: [0, y, doorOffsetZ],
+        pivot: doorPivot,
+        frameSideWidth: sidesFrameWidthM,
+        doorDepthM: doorDepthM,
+        material: hingeBodyMaterial,
+        gasketMaterial: gasketMaterial
+      }, "glass-hinge-".concat(index))), /*#__PURE__*/jsxRuntimeExports.jsxs("group", {
+        position: [-hingeSideX, 0, doorOffsetZ],
+        children: [/*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+          castShadow: true,
+          children: /*#__PURE__*/jsxRuntimeExports.jsxs(csg.Geometry, {
+            useGroups: true,
+            children: [/*#__PURE__*/jsxRuntimeExports.jsx(csg.Base, {
+              name: "door-base",
+              material: doorMaterial,
+              children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+                args: [doorWidthM, mainDoorHeightM, doorDepthM]
+              })
+            }), /*#__PURE__*/jsxRuntimeExports.jsx(DoorStopCuts, {
+              visible: frameType === "WDGF_WDG100" || frameType === "WF_100" || frameType === "WF_FLI",
+              width: doorWidthM,
+              height: totalOpeningHeightM,
+              stopWidth: doorStopWidthM,
+              stopDepth: doorStopDepthM,
+              stopPositionZ: doorStopPositionZ,
+              centerZ: doorCenterZ,
+              glassDepthOffset: GlassPanelDepthM / 2,
+              material: doorMaterial,
+              setName: "1"
+            }), /*#__PURE__*/jsxRuntimeExports.jsx(DoorStopCuts, {
+              visible: frameType === "WDGF_WDG100" || frameType === "WF_100" || frameType === "WF_FLI",
+              width: doorWidthM,
+              height: totalOpeningHeightM,
+              stopWidth: secondDoorStopWidthM,
+              stopDepth: secondDoorStopDepthM,
+              stopPositionZ: secondDoorStopPositionZ,
+              centerZ: doorCenterZ,
+              glassDepthOffset: GlassPanelDepthM / 2,
+              material: doorMaterial,
+              setName: "2"
+            }), glassVisible && /*#__PURE__*/jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, {
+              children: [/*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+                position: [0, 0, frontGlassOffsetZ],
+                castShadow: true,
+                material: glassInfillMaterial,
+                children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+                  args: [doorWidthM, mainDoorHeightM, GlassPanelDepthM]
+                })
+              }), frameType !== "WDGF_WDG100" && frameType !== "WF_100" && /*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+                position: [0, 0, backGlassOffsetZ],
+                castShadow: true,
+                material: glassInfillMaterial,
+                children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+                  args: [doorWidthM, mainDoorHeightM, GlassPanelDepthM]
+                })
+              }), (frameType === "WDGF_WDG100" || frameType === "WF_100") && /*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+                position: [0, -secondDoorStopWidthM / 2, backGlassOffsetZ],
+                castShadow: true,
+                material: glassInfillMaterial,
+                children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+                  args: [doorWidthM - 2 * secondDoorStopWidthM, mainDoorHeightM - secondDoorStopWidthM, GlassPanelDepthM]
+                })
+              })]
+            }), occulus.visible && occulusWidthM > 0 && occulusHeightM > 0 && /*#__PURE__*/jsxRuntimeExports.jsx(csg.Subtraction, {
+              material: placeholderMaterial,
+              position: [occulusPositionXM, occulusPositionYM, 0],
+              children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+                args: [occulusWidthM, occulusHeightM, doorDepthM + 0.01]
+              })
+            })]
+          })
+        }), occulus.visible && occulus.infillVisible && occulusWidthM > 0 && occulusHeightM > 0 && /*#__PURE__*/jsxRuntimeExports.jsx("mesh", {
+          position: [occulusPositionXM, occulusPositionYM, 0],
+          castShadow: true,
+          material: occulusInfillMaterial,
+          children: /*#__PURE__*/jsxRuntimeExports.jsx("boxGeometry", {
+            args: [occulusWidthM, occulusHeightM, occulusInfillDepthM]
+          })
+        })]
+      })]
+    }), isPlaneVisible && /*#__PURE__*/jsxRuntimeExports.jsxs("mesh", {
+      receiveShadow: true,
+      rotation: [-Math.PI / 2, 0, 0],
+      position: [0, -totalOpeningHeightM / 2 - 0.01, 0],
+      children: [/*#__PURE__*/jsxRuntimeExports.jsx("planeGeometry", {
+        args: [10, 10]
+      }), /*#__PURE__*/jsxRuntimeExports.jsx("meshStandardMaterial", {
+        color: "#f9f9f9",
+        side: THREE__namespace.DoubleSide
+      })]
+    })]
+  });
+}
+
+const _excluded = ["frameType"];
+const cpidOptions = ["P_SD_FH_AF20_40", "P_SD_FH_AF20_40OCC", "P_SD_FH_AF40_40", "P_SD_FH_AF40_40OCC", "P_SD_FH_WF_40", "P_SD_FH_WF_40OCC", "P_SD_FH_MXF_40", "P_SD_FH_MXF_40OCC", "P_SD_FH_MXCAF_40", "P_SD_FH_MXCAF_40OCC", "P_SD_FH_AF20_50", "P_SD_FH_AF20_50OCC", "P_SD_FH_AF40_50", "P_SD_FH_AF40_50OCC", "P_SD_FH_WF_50", "P_SD_FH_WF_50OCC", "P_SD_FH_WF_FLI", "P_SD_FH_AF20_SG8", "P_SD_FH_AF20_SG10", "P_SD_FH_AF20_SG12", "P_SD_FH_AF40_SG8", "P_SD_FH_AF40_SG10", "P_SD_FH_AF40_SG12", "P_SD_FH_NOF_SG8", "P_SD_FH_NOF_SG10", "P_SD_FH_NOF_SG12", "P_SD_FH_WF_100", "P_SD_FH_WDGF_WDG100", "P_SD_FH_AF20_40_IFL", "P_SD_FH_AF20_40OCC_IFL", "P_SD_FH_AF40_40_IFL", "P_SD_FH_AF40_40OCC_IFL", "P_SD_FH_WF_40_IFL", "P_SD_FH_WF_40OCC_IFL", "P_SD_FH_AF20_50_IFL", "P_SD_FH_AF20_50OCC_IFL", "P_SD_FH_AF40_50_IFL", "P_SD_FH_AF40_50OCC_IFL", "P_SD_FH_WF_50_IFL", "P_SD_FH_WF_50OCC_IFL", "P_SD_WPFL_AF20_40", "P_SD_WPFL_AF20_40OCC", "P_SD_WPFL_AF40_40", "P_SD_WPFL_AF40_40OCC", "P_SD_WPFL_WF_40", "P_SD_WPFL_WF_40OCC", "P_SD_WPFL_AF20_50", "P_SD_WPFL_AF20_50OCC", "P_SD_WPFL_AF40_50", "P_SD_WPFL_AF40_50OCC", "P_SD_WPFL_WF_50", "P_SD_WPFL_WF_50OCC", "P_SD_WPFL_AF20_SG8", "P_SD_WPFL_AF20_SG10", "P_SD_WPFL_AF20_SG12", "P_SD_WPFL_AF40_SG8", "P_SD_WPFL_AF40_SG10", "P_SD_WPFL_AF40_SG12", "P_SD_ALSGFL_AF20_40", "P_SD_ALSGFL_AF20_40OCC", "P_SD_ALSGFL_AF40_40", "P_SD_ALSGFL_AF40_40OCC", "P_SD_ALSGFL_WF_40", "P_SD_ALSGFL_WF_40OCC", "P_SD_ALSGFL_AF20_SG8", "P_SD_ALSGFL_AF20_SG10", "P_SD_ALSGFL_AF20_SG12", "P_SD_ALSGFL_AF40_SG8", "P_SD_ALSGFL_AF40_SG10", "P_SD_ALSGFL_AF40_SG12", "P_SD_ALDGFL_AF20_40", "P_SD_ALDGFL_AF20_40OCC", "P_SD_ALDGFL_AF40_40", "P_SD_ALDGFL_AF40_40OCC", "P_SD_ALDGFL_WF_40", "P_SD_ALDGFL_WF_40OCC", "P_SD_ALDGFL_AF20_50", "P_SD_ALDGFL_AF20_50OCC", "P_SD_ALDGFL_AF40_50", "P_SD_ALDGFL_AF40_50OCC", "P_SD_ALDGFL_WF_50", "P_SD_ALDGFL_WF_50OCC", "P_SD_ALDGFL_AF20_SG8", "P_SD_ALDGFL_AF20_SG10", "P_SD_ALDGFL_AF20_SG12", "P_SD_ALDGFL_AF40_SG8", "P_SD_ALDGFL_AF40_SG10", "P_SD_ALDGFL_AF40_SG12"];
+const EditableSlider = _ref => {
+  let {
+    label,
+    value,
+    min,
+    max,
+    step = 1,
+    onChange
+  } = _ref;
+  const [inputValue, setInputValue] = require$$0.useState(value);
+  require$$0__default["default"].useEffect(() => {
+    setInputValue(value);
+  }, [value]);
+  const handleSliderChange = (_, newValue) => {
+    onChange(Array.isArray(newValue) ? newValue[0] : newValue);
+  };
+  const handleInputChange = event => {
+    setInputValue(event.target.value);
+  };
+  const handleInputBlur = () => {
+    let numericValue = inputValue === "" || isNaN(Number(inputValue)) ? min : Number(inputValue);
+    if (numericValue < min) numericValue = min;
+    if (numericValue > max) numericValue = max;
+    onChange(numericValue);
+  };
+  const handleInputKeyDown = event => {
+    if (event.key === "Enter") {
+      handleInputBlur();
+      event.target.blur();
+    }
+  };
+  return /*#__PURE__*/jsxRuntimeExports.jsxs(material.FormControl, {
+    fullWidth: true,
+    children: [/*#__PURE__*/jsxRuntimeExports.jsxs(material.FormLabel, {
+      sx: {
+        mb: 1,
+        display: "flex",
+        justifyContent: "space-between",
+        alignItems: "center"
+      },
+      children: [/*#__PURE__*/jsxRuntimeExports.jsx("span", {
+        children: label
+      }), /*#__PURE__*/jsxRuntimeExports.jsx(material.TextField, {
+        value: inputValue,
+        size: "small",
+        onChange: handleInputChange,
+        onBlur: handleInputBlur,
+        onKeyDown: handleInputKeyDown,
+        type: "number",
+        variant: "outlined",
+        inputProps: {
+          step: step,
+          min: min,
+          max: max,
+          "aria-labelledby": "input-slider"
+        },
+        InputProps: {
+          endAdornment: /*#__PURE__*/jsxRuntimeExports.jsx(material.InputAdornment, {
+            position: "end",
+            children: "mm"
+          })
+        },
+        sx: {
+          width: "140px"
+        }
+      })]
+    }), /*#__PURE__*/jsxRuntimeExports.jsx(material.Slider, {
+      value: typeof value === "number" ? value : min,
+      min: min,
+      max: max,
+      step: step,
+      onChange: handleSliderChange,
+      "aria-labelledby": "input-slider"
+    })]
+  });
+};
+const MaterialInput = _ref2 => {
+  let {
+    label,
+    value,
+    onChange,
+    onApply
+  } = _ref2;
+  const [inputValue, setInputValue] = require$$0.useState(value);
+  require$$0__default["default"].useEffect(() => {
+    setInputValue(value);
+  }, [value]);
+  const handleApply = () => {
+    if (onApply) {
+      onApply(inputValue);
+    }
+    onChange(inputValue);
+  };
+  return /*#__PURE__*/jsxRuntimeExports.jsxs(material.FormControl, {
+    fullWidth: true,
+    children: [/*#__PURE__*/jsxRuntimeExports.jsx(material.FormLabel, {
+      children: label
+    }), /*#__PURE__*/jsxRuntimeExports.jsxs(material.Stack, {
+      direction: "row",
+      spacing: 1,
+      children: [/*#__PURE__*/jsxRuntimeExports.jsx(material.TextField, {
+        size: "small",
+        value: inputValue,
+        onChange: e => setInputValue(e.target.value)
+      }), /*#__PURE__*/jsxRuntimeExports.jsx(material.Button, {
+        variant: "contained",
+        onClick: handleApply,
+        children: "Apply"
+      })]
+    })]
+  });
+};
+const MaterialSelector = _ref3 => {
+  let {
+    label,
+    value,
+    onChange
+  } = _ref3;
+  const materialOptions = Object.keys(availableMaterials);
+  return /*#__PURE__*/jsxRuntimeExports.jsxs(material.FormControl, {
+    fullWidth: true,
+    size: "small",
+    children: [/*#__PURE__*/jsxRuntimeExports.jsx(material.FormLabel, {
+      children: label
+    }), /*#__PURE__*/jsxRuntimeExports.jsxs(material.Select, {
+      value: value,
+      onChange: e => onChange(e.target.value),
+      children: [/*#__PURE__*/jsxRuntimeExports.jsx(material.MenuItem, {
+        value: "none",
+        children: /*#__PURE__*/jsxRuntimeExports.jsx("em", {
+          children: "None"
+        })
+      }), materialOptions.map(name => /*#__PURE__*/jsxRuntimeExports.jsx(material.MenuItem, {
+        value: name,
+        children: name
+      }, name))]
+    })]
+  });
+};
+const Interface = () => {
+  const {
+    isPlaneVisible,
+    setIsPlaneVisible,
+    cpid,
+    setCpid,
+    door,
+    setDoor,
+    doorFrame,
+    setDoorFrame,
+    interiorFanlight,
+    setInteriorFanlight,
+    exteriorFanlight,
+    setExteriorFanlight,
+    occulus,
+    setOcculus,
+    frontCoverPanel,
+    setFrontCoverPanel,
+    backCoverPanel,
+    setBackCoverPanel,
+    frameType,
+    setFrameType,
+    bodyType,
+    setBodyType,
+    totalHeight,
+    setTotalHeight,
+    totalWidth,
+    setTotalWidth,
+    exteriorFanlightType,
+    setExteriorFanlightType,
+    testDoorMaterial,
+    setTestDoorMaterial,
+    testFrameMaterial,
+    setTestFrameMaterial,
+    testInteriorFanlightMaterial,
+    setTestInteriorFanlightMaterial,
+    testExteriorFanlightMaterial,
+    setTestExteriorFanlightMaterial,
+    testOcculusInfillMaterial,
+    setTestOcculusInfillMaterial,
+    testGlassInfillMaterial,
+    setTestGlassInfillMaterial,
+    testGasketMaterial,
+    setTestGasketMaterial,
+    testDoorStopMaterial,
+    setTestDoorStopMaterial,
+    testHingeMaterial,
+    setTestHingeMaterial,
+    glassVisible,
+    setGlassVisible,
+    glassDepth,
+    setGlassDepth,
+    testFrontCoverPanelMaterial,
+    setTestFrontCoverPanelMaterial,
+    setTestBackCoverPanelMaterial
+  } = useConfigurator();
+  const [parseMessage, setParseMessage] = require$$0.useState({
+    type: "",
+    text: ""
+  });
+  const handleMaterialApply = materialName => {
+    console.log("[DATABASE SIMULATION] Started fetching data for material: \"".concat(materialName, "\""));
+  };
+  const fileInputRef = require$$0.useRef(null);
+  const handleExport = () => {
+    if (!cpid || cpid.trim() === "") {
+      alert("Please enter a Door Title (CPID) before exporting.");
+      return;
+    }
+    const doorFrameWithFrameType = _objectSpread2(_objectSpread2({}, doorFrame), {}, {
+      frameType: frameType
+    });
+    const exportData = {
+      cpid,
+      door,
+      doorFrame: doorFrameWithFrameType,
+      interiorFanlight,
+      exteriorFanlight,
+      occulus,
+      frontCoverPanel,
+      backCoverPanel
+    };
+    const jsonString = "data:text/json;charset=utf-8,".concat(encodeURIComponent(JSON.stringify(exportData, null, 2)));
+    const link = document.createElement("a");
+    link.href = jsonString;
+    link.download = "".concat(cpid.trim(), ".json");
+    link.click();
+  };
+  const handleImportClick = () => {
+    if (fileInputRef.current) {
+      fileInputRef.current.click();
+    }
+  };
+  const handleFileChange = event => {
+    var _event$target$files;
+    const file = (_event$target$files = event.target.files) === null || _event$target$files === void 0 ? void 0 : _event$target$files[0];
+    if (!file) return;
+    const reader = new FileReader();
+    reader.onload = e => {
+      if (e.target && typeof e.target.result === "string") {
+        try {
+          const importedData = JSON.parse(e.target.result);
+          if (importedData.cpid) setCpid(importedData.cpid);
+          if (importedData.door) setDoor(importedData.door);
+          if (importedData.doorFrame) {
+            const _importedData$doorFra = importedData.doorFrame,
+              {
+                frameType: importedFrameType
+              } = _importedData$doorFra,
+              doorFrameData = _objectWithoutProperties(_importedData$doorFra, _excluded);
+            setDoorFrame(doorFrameData);
+            if (importedFrameType) setFrameType(importedFrameType);
+          }
+          if (importedData.interiorFanlight) setInteriorFanlight(importedData.interiorFanlight);
+          if (importedData.exteriorFanlight) setExteriorFanlight(importedData.exteriorFanlight);
+          if (importedData.occulus) setOcculus(importedData.occulus);
+          if (importedData.frontCoverPanel) setFrontCoverPanel(importedData.frontCoverPanel);
+          if (importedData.backCoverPanel) setBackCoverPanel(importedData.backCoverPanel);
+        } catch (error) {
+          console.error("Error parsing JSON file:", error);
+          alert("Error: Could not parse the JSON file.");
+        }
+      } else {
+        console.error("FileReader error: result is not a string or target is null");
+        alert("Error: Could not read the file.");
+      }
+    };
+    reader.readAsText(file);
+    event.target.value = "";
+  };
+  const handleParseCpid = require$$0.useCallback(cpidToParse => {
+    const showMessage = function (text) {
+      let type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "error";
+      setParseMessage({
+        text,
+        type
+      });
+      setTimeout(() => setParseMessage({
+        text: "",
+        type: ""
+      }), 4000);
+    };
+    if (!cpidToParse || !cpidToParse.trim().startsWith("P_")) {
+      showMessage("Invalid format: CPID must start with 'P_'.");
+      return;
+    }
+    const parts = cpidToParse.trim().split("_");
+    if (parts.length < 4) {
+      showMessage("Invalid format: Not enough parts in CPID.");
+      return;
+    }
+    const newConfig = {
+      fanlightVisible: false,
+      fanlightType: "WPFL",
+      interiorFanlightVisible: false,
+      occulusVisible: false,
+      frameType: "",
+      bodyType: ""
+    };
+    let currentIndex = 1;
+
+    //  Door Type
+    if (parts[currentIndex] === "SD") {
+      currentIndex++;
+    } else {
+      showMessage("Unsupported Door Type: Only 'SD' is supported.");
+      return;
+    }
+
+    //Fanlight Type
+    const fanlightPart = parts[currentIndex];
+    const validFanlights = ["WPFL", "ALDGFL", "ALSGFL"];
+    if (fanlightPart === "FH") {
+      newConfig.fanlightVisible = false;
+      currentIndex++;
+    } else if (validFanlights.includes(fanlightPart)) {
+      newConfig.fanlightVisible = true;
+      newConfig.fanlightType = fanlightPart;
+      currentIndex++;
+    } else {
+      showMessage("Invalid Fanlight Type: '".concat(fanlightPart, "'."));
+      return;
+    }
+
+    //  Frame and Body Type
+    const validSimpleFrameTypes = ["AF20", "AF40", "WF", "MXF", "MXCAF", "NOF"];
+    const validBodyTypes = ["40", "50", "FLI", "100", "WDG100", "SG8", "SG10", "SG12"];
+    let framePart = parts[currentIndex];
+    let bodyPartRaw = parts[currentIndex + 1] || "";
+    let frameFound = false;
+    if ("".concat(framePart, "_").concat(bodyPartRaw) === "WDGF_WDG100") {
+      newConfig.frameType = "WDGF_WDG100";
+      newConfig.bodyType = "WDG100";
+      currentIndex += 2;
+      frameFound = true;
+    } else if (validSimpleFrameTypes.includes(framePart)) {
+      let tempBody = bodyPartRaw.replace("OCC", "");
+      if (validBodyTypes.includes(tempBody)) {
+        newConfig.frameType = framePart === "NOF" ? "NOF" : "".concat(framePart, "_").concat(tempBody);
+        newConfig.bodyType = tempBody;
+        if (bodyPartRaw.endsWith("OCC")) {
+          newConfig.occulusVisible = true;
+        }
+        currentIndex += 2;
+        frameFound = true;
+      }
+    }
+    if (!frameFound) {
+      showMessage("Invalid Frame/Body combination starting with '".concat(framePart, "'."));
+      return;
+    }
+    for (let i = currentIndex; i < parts.length; i++) {
+      if (parts[i] === "IFL") {
+        newConfig.interiorFanlightVisible = true;
+      } else if (parts[i] === "OCC") {
+        newConfig.occulusVisible = true;
+      }
+    }
+
+    // Apply final configuration
+    setFrameType(newConfig.frameType);
+    setBodyType(newConfig.bodyType);
+    setExteriorFanlight(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+      visible: newConfig.fanlightVisible
+    }));
+    if (newConfig.fanlightVisible) {
+      setExteriorFanlightType(newConfig.fanlightType);
+    }
+    setInteriorFanlight(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+      visible: newConfig.interiorFanlightVisible
+    }));
+    setOcculus(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+      visible: newConfig.occulusVisible
+    }));
+    showMessage("Configuration Applied!", "success");
+  }, [setBodyType, setExteriorFanlight, setExteriorFanlightType, setFrameType, setInteriorFanlight, setOcculus]);
+  const mainDoorHeight = door.doorHeight - (interiorFanlight.visible ? interiorFanlight.height : 0);
+  const handleExteriorFanlightHeightChange = newHeight => {
+    const oldHeight = exteriorFanlight.height;
+    const heightDifference = newHeight - oldHeight;
+    setExteriorFanlight(_objectSpread2(_objectSpread2({}, exteriorFanlight), {}, {
+      height: newHeight
+    }));
+    setTotalHeight(totalHeight + heightDifference);
+  };
+  return /*#__PURE__*/jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, {
+    children: [parseMessage.text && /*#__PURE__*/jsxRuntimeExports.jsx(material.Box, {
+      sx: {
+        position: "absolute",
+        top: 20,
+        left: "50%",
+        transform: "translateX(-50%)",
+        padding: "10px 20px",
+        backgroundColor: parseMessage.type === "error" ? "rgba(211, 47, 47, 0.8)" : "rgba(46, 125, 50, 0.8)",
+        backdropFilter: "blur(5px)",
+        borderRadius: "10px",
+        color: "white",
+        zIndex: 20,
+        textAlign: "center"
+      },
+      children: /*#__PURE__*/jsxRuntimeExports.jsx(material.Typography, {
+        variant: "body1",
+        children: parseMessage.text
+      })
+    }), /*#__PURE__*/jsxRuntimeExports.jsxs(material.Box, {
+      sx: {
+        position: "absolute",
+        top: 20,
+        left: 20,
+        padding: "10px 15px",
+        backgroundColor: "rgba(0, 0, 0, 0.6)",
+        backdropFilter: "blur(10px)",
+        borderRadius: "10px",
+        color: "white",
+        zIndex: 10
+      },
+      children: [/*#__PURE__*/jsxRuntimeExports.jsxs(material.Typography, {
+        variant: "body1",
+        children: ["Total Width: ", Math.round(totalWidth), " mm"]
+      }), frontCoverPanel.visible && /*#__PURE__*/jsxRuntimeExports.jsxs(material.Typography, {
+        variant: "body1",
+        sx: {
+          color: "#81d4fa"
+        },
+        children: ["Total Width with CAS:", " ", Math.round(totalWidth + frontCoverPanel.width * 2), " mm"]
+      }), /*#__PURE__*/jsxRuntimeExports.jsxs(material.Typography, {
+        variant: "body1",
+        children: ["Total Height: ", Math.round(totalHeight), " mm"]
+      }), /*#__PURE__*/jsxRuntimeExports.jsxs(material.Typography, {
+        variant: "body1",
+        children: ["Frame Depth: ", Math.round(doorFrame.frameDepth), " mm"]
+      }), /*#__PURE__*/jsxRuntimeExports.jsxs(material.Typography, {
+        variant: "body1",
+        children: ["Door Depth: ", Math.round(door.theDoorDepth), " mm"]
+      })]
+    }), /*#__PURE__*/jsxRuntimeExports.jsx(material.Box, {
+      sx: {
+        position: "absolute",
+        top: 0,
+        right: 0,
+        height: "100vh",
+        width: "25%",
+        overflowY: "auto",
+        boxSizing: "border-box",
+        backgroundColor: "rgba(255, 255, 255, 0.95)",
+        backdropFilter: "blur(10px)"
+      },
+      p: 2,
+      children: /*#__PURE__*/jsxRuntimeExports.jsxs(material.Stack, {
+        spacing: 2,
+        children: [/*#__PURE__*/jsxRuntimeExports.jsxs(material.Paper, {
+          elevation: 3,
+          sx: {
+            p: 2
+          },
+          children: [/*#__PURE__*/jsxRuntimeExports.jsxs(material.FormControl, {
+            fullWidth: true,
+            sx: {
+              mb: 2
+            },
+            children: [/*#__PURE__*/jsxRuntimeExports.jsx(material.FormLabel, {
+              children: "Door Title (CPID)"
+            }), /*#__PURE__*/jsxRuntimeExports.jsxs(material.Stack, {
+              direction: "row",
+              spacing: 1,
+              alignItems: "center",
+              children: [/*#__PURE__*/jsxRuntimeExports.jsx(material.TextField, {
+                value: cpid,
+                onChange: e => {
+                  setCpid(e.target.value);
+                },
+                variant: "outlined",
+                size: "small",
+                fullWidth: true,
+                placeholder: "e.g. P_SD_WPFL_AF20_50_IFL"
+              }), /*#__PURE__*/jsxRuntimeExports.jsx(material.Button, {
+                variant: "contained",
+                onClick: () => handleParseCpid(cpid),
+                children: "Apply"
+              })]
+            })]
+          }), /*#__PURE__*/jsxRuntimeExports.jsxs(material.FormControl, {
+            fullWidth: true,
+            children: [/*#__PURE__*/jsxRuntimeExports.jsx(material.FormLabel, {
+              children: "Or Select a Preset (Searchable)"
+            }), /*#__PURE__*/jsxRuntimeExports.jsx(material.Autocomplete, {
+              value: cpid,
+              onChange: (event, newValue) => {
+                if (newValue) {
+                  setCpid(newValue);
+                  handleParseCpid(newValue);
+                }
+              },
+              onInputChange: (event, newInputValue) => {
+                setCpid(newInputValue);
+              },
+              options: cpidOptions,
+              renderInput: params => /*#__PURE__*/jsxRuntimeExports.jsx(material.TextField, _objectSpread2(_objectSpread2({}, params), {}, {
+                size: "small"
+              })),
+              ListboxProps: {
+                style: {
+                  maxHeight: 300
+                }
+              },
+              freeSolo: true,
+              disableClearable: true
+            })]
+          })]
+        }), /*#__PURE__*/jsxRuntimeExports.jsx(material.Paper, {
+          elevation: 3,
+          sx: {
+            p: 2
+          },
+          children: /*#__PURE__*/jsxRuntimeExports.jsxs(material.Stack, {
+            direction: "row",
+            spacing: 2,
+            justifyContent: "center",
+            children: [/*#__PURE__*/jsxRuntimeExports.jsx(material.Button, {
+              variant: "contained",
+              color: "primary",
+              onClick: handleExport,
+              children: "Export JSON"
+            }), /*#__PURE__*/jsxRuntimeExports.jsx(material.Button, {
+              variant: "contained",
+              color: "secondary",
+              onClick: handleImportClick,
+              children: "Import JSON"
+            }), /*#__PURE__*/jsxRuntimeExports.jsx("input", {
+              type: "file",
+              ref: fileInputRef,
+              style: {
+                display: "none"
+              },
+              accept: ".json",
+              onChange: handleFileChange
+            }), /*#__PURE__*/jsxRuntimeExports.jsx(material.Tooltip, {
+              title: isPlaneVisible ? "Hide Ground Plane" : "Show Ground Plane",
+              children: /*#__PURE__*/jsxRuntimeExports.jsx(material.IconButton, {
+                onClick: () => setIsPlaneVisible(!isPlaneVisible),
+                children: isPlaneVisible ? /*#__PURE__*/jsxRuntimeExports.jsx(iconsMaterial.Visibility, {}) : /*#__PURE__*/jsxRuntimeExports.jsx(iconsMaterial.VisibilityOff, {})
+              })
+            })]
+          })
+        }), /*#__PURE__*/jsxRuntimeExports.jsx(material.Paper, {
+          elevation: 3,
+          sx: {
+            p: 2
+          },
+          children: /*#__PURE__*/jsxRuntimeExports.jsxs(material.Stack, {
+            spacing: 2,
+            children: [/*#__PURE__*/jsxRuntimeExports.jsx(material.Typography, {
+              variant: "h6",
+              color: "primary",
+              children: "Door Properties"
+            }), /*#__PURE__*/jsxRuntimeExports.jsx(material.Stack, {
+              direction: "row",
+              spacing: 2,
+              alignItems: "flex-end",
+              children: /*#__PURE__*/jsxRuntimeExports.jsx(MaterialInput, {
+                label: "Door Material",
+                value: door.doorMaterial,
+                onChange: value => setDoor(_objectSpread2(_objectSpread2({}, door), {}, {
+                  doorMaterial: value
+                })),
+                onApply: handleMaterialApply
+              })
+            }), /*#__PURE__*/jsxRuntimeExports.jsx(material.Stack, {
+              direction: "row",
+              spacing: 2,
+              alignItems: "flex-end",
+              children: /*#__PURE__*/jsxRuntimeExports.jsx(MaterialSelector, {
+                label: "Test Material",
+                value: testDoorMaterial,
+                onChange: setTestDoorMaterial
+              })
+            }), /*#__PURE__*/jsxRuntimeExports.jsx(material.Divider, {}), /*#__PURE__*/jsxRuntimeExports.jsxs(material.FormControl, {
+              children: [/*#__PURE__*/jsxRuntimeExports.jsx(material.FormLabel, {
+                children: "Body Type"
+              }), /*#__PURE__*/jsxRuntimeExports.jsxs(material.RadioGroup, {
+                row: true,
+                value: bodyType,
+                onChange: (_, value) => setBodyType(value),
+                children: [/*#__PURE__*/jsxRuntimeExports.jsx(material.FormControlLabel, {
+                  value: "40",
+                  control: /*#__PURE__*/jsxRuntimeExports.jsx(material.Radio, {
+                    size: "small"
+                  }),
+                  label: "40mm"
+                }), /*#__PURE__*/jsxRuntimeExports.jsx(material.FormControlLabel, {
+                  value: "50",
+                  control: /*#__PURE__*/jsxRuntimeExports.jsx(material.Radio, {
+                    size: "small"
+                  }),
+                  label: "50mm"
+                }), /*#__PURE__*/jsxRuntimeExports.jsx(material.FormControlLabel, {
+                  value: "SG8",
+                  control: /*#__PURE__*/jsxRuntimeExports.jsx(material.Radio, {
+                    size: "small"
+                  }),
+                  label: "8mm Glass"
+                }), /*#__PURE__*/jsxRuntimeExports.jsx(material.FormControlLabel, {
+                  value: "SG10",
+                  control: /*#__PURE__*/jsxRuntimeExports.jsx(material.Radio, {
+                    size: "small"
+                  }),
+                  label: "10mm Glass"
+                }), /*#__PURE__*/jsxRuntimeExports.jsx(material.FormControlLabel, {
+                  value: "SG12",
+                  control: /*#__PURE__*/jsxRuntimeExports.jsx(material.Radio, {
+                    size: "small"
+                  }),
+                  label: "12mm Glass"
+                })]
+              })]
+            }), /*#__PURE__*/jsxRuntimeExports.jsx(material.Divider, {}), /*#__PURE__*/jsxRuntimeExports.jsx(EditableSlider, {
+              label: "Total Width",
+              value: totalWidth,
+              min: 600,
+              max: 2200,
+              onChange: setTotalWidth
+            }), /*#__PURE__*/jsxRuntimeExports.jsx(material.FormControl, {
+              fullWidth: true,
+              children: /*#__PURE__*/jsxRuntimeExports.jsxs(material.FormLabel, {
+                sx: {
+                  display: "flex",
+                  justifyContent: "space-between",
+                  alignItems: "center"
+                },
+                children: [/*#__PURE__*/jsxRuntimeExports.jsx("span", {
+                  children: "Calculated Door Width"
+                }), /*#__PURE__*/jsxRuntimeExports.jsx(material.TextField, {
+                  value: Math.round(door.doorWidth),
+                  size: "small",
+                  disabled: true,
+                  variant: "outlined",
+                  InputProps: {
+                    endAdornment: /*#__PURE__*/jsxRuntimeExports.jsx(material.InputAdornment, {
+                      position: "end",
+                      children: "mm"
+                    })
+                  },
+                  sx: {
+                    width: "140px"
+                  }
+                })]
+              })
+            }), /*#__PURE__*/jsxRuntimeExports.jsx(EditableSlider, {
+              label: "Total Height",
+              value: totalHeight,
+              min: 1500,
+              max: 4000,
+              onChange: setTotalHeight
+            }), /*#__PURE__*/jsxRuntimeExports.jsx(material.FormControl, {
+              fullWidth: true,
+              children: /*#__PURE__*/jsxRuntimeExports.jsxs(material.FormLabel, {
+                sx: {
+                  display: "flex",
+                  justifyContent: "space-between",
+                  alignItems: "center"
+                },
+                children: [/*#__PURE__*/jsxRuntimeExports.jsx("span", {
+                  children: "Calculated Door Height"
+                }), /*#__PURE__*/jsxRuntimeExports.jsx(material.TextField, {
+                  value: Math.round(door.doorHeight),
+                  size: "small",
+                  disabled: true,
+                  variant: "outlined",
+                  InputProps: {
+                    endAdornment: /*#__PURE__*/jsxRuntimeExports.jsx(material.InputAdornment, {
+                      position: "end",
+                      children: "mm"
+                    })
+                  },
+                  sx: {
+                    width: "140px"
+                  }
+                })]
+              })
+            }), /*#__PURE__*/jsxRuntimeExports.jsxs(material.Stack, {
+              direction: "row",
+              justifyContent: "space-around",
+              children: [/*#__PURE__*/jsxRuntimeExports.jsxs(material.FormControl, {
+                children: [/*#__PURE__*/jsxRuntimeExports.jsx(material.FormLabel, {
+                  children: "Pivot"
+                }), /*#__PURE__*/jsxRuntimeExports.jsxs(material.RadioGroup, {
+                  row: true,
+                  value: door.doorPivot,
+                  onChange: (_, value) => setDoor(_objectSpread2(_objectSpread2({}, door), {}, {
+                    doorPivot: value
+                  })),
+                  children: [/*#__PURE__*/jsxRuntimeExports.jsx(material.FormControlLabel, {
+                    value: "left",
+                    control: /*#__PURE__*/jsxRuntimeExports.jsx(material.Radio, {
+                      size: "small"
+                    }),
+                    label: "Left"
+                  }), /*#__PURE__*/jsxRuntimeExports.jsx(material.FormControlLabel, {
+                    value: "right",
+                    control: /*#__PURE__*/jsxRuntimeExports.jsx(material.Radio, {
+                      size: "small"
+                    }),
+                    label: "Right"
+                  })]
+                })]
+              }), /*#__PURE__*/jsxRuntimeExports.jsxs(material.FormControl, {
+                children: [/*#__PURE__*/jsxRuntimeExports.jsx(material.FormLabel, {
+                  children: "Opening"
+                }), /*#__PURE__*/jsxRuntimeExports.jsxs(material.RadioGroup, {
+                  row: true,
+                  value: door.doorOpening,
+                  onChange: (_, value) => setDoor(_objectSpread2(_objectSpread2({}, door), {}, {
+                    doorOpening: value
+                  })),
+                  children: [/*#__PURE__*/jsxRuntimeExports.jsx(material.FormControlLabel, {
+                    value: "in",
+                    control: /*#__PURE__*/jsxRuntimeExports.jsx(material.Radio, {
+                      size: "small"
+                    }),
+                    label: "In"
+                  }), /*#__PURE__*/jsxRuntimeExports.jsx(material.FormControlLabel, {
+                    value: "out",
+                    control: /*#__PURE__*/jsxRuntimeExports.jsx(material.Radio, {
+                      size: "small"
+                    }),
+                    label: "Out"
+                  })]
+                })]
+              })]
+            })]
+          })
+        }), /*#__PURE__*/jsxRuntimeExports.jsx(material.Paper, {
+          elevation: 3,
+          sx: {
+            p: 2
+          },
+          children: /*#__PURE__*/jsxRuntimeExports.jsxs(material.Stack, {
+            spacing: 2,
+            children: [/*#__PURE__*/jsxRuntimeExports.jsx(material.Typography, {
+              variant: "h6",
+              color: "primary",
+              children: "Frame Properties"
+            }), /*#__PURE__*/jsxRuntimeExports.jsx(material.Stack, {
+              direction: "row",
+              spacing: 2,
+              alignItems: "flex-end",
+              children: /*#__PURE__*/jsxRuntimeExports.jsx(MaterialInput, {
+                label: "Frame Material",
+                value: doorFrame.frameMaterial,
+                onChange: value => setDoorFrame(_objectSpread2(_objectSpread2({}, doorFrame), {}, {
+                  frameMaterial: value
+                })),
+                onApply: handleMaterialApply
+              })
+            }), /*#__PURE__*/jsxRuntimeExports.jsx(MaterialSelector, {
+              label: "Test Material",
+              value: testFrameMaterial,
+              onChange: setTestFrameMaterial
+            }), /*#__PURE__*/jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, {
+              children: [/*#__PURE__*/jsxRuntimeExports.jsx(material.Divider, {}), /*#__PURE__*/jsxRuntimeExports.jsx(material.Typography, {
+                variant: "subtitle1",
+                color: "secondary",
+                children: "Doorstop Properties"
+              }), /*#__PURE__*/jsxRuntimeExports.jsx(material.Stack, {
+                direction: "row",
+                spacing: 2,
+                alignItems: "flex-end",
+                children: /*#__PURE__*/jsxRuntimeExports.jsx(MaterialInput, {
+                  label: "Doorstop Material",
+                  value: doorFrame.doorStopMaterial || "",
+                  onChange: value => setDoorFrame(_objectSpread2(_objectSpread2({}, doorFrame), {}, {
+                    doorStopMaterial: value
+                  })),
+                  onApply: handleMaterialApply
+                })
+              }), /*#__PURE__*/jsxRuntimeExports.jsx(MaterialSelector, {
+                label: "Test Doorstop Material",
+                value: testDoorStopMaterial,
+                onChange: setTestDoorStopMaterial
+              })]
+            }), /*#__PURE__*/jsxRuntimeExports.jsxs(material.FormControl, {
+              children: [/*#__PURE__*/jsxRuntimeExports.jsx(material.FormLabel, {
+                children: "Frame Type"
+              }), /*#__PURE__*/jsxRuntimeExports.jsxs(material.RadioGroup, {
+                value: frameType,
+                onChange: (_, value) => setFrameType(value),
+                children: [/*#__PURE__*/jsxRuntimeExports.jsx(material.FormControlLabel, {
+                  value: "NOF",
+                  control: /*#__PURE__*/jsxRuntimeExports.jsx(material.Radio, {
+                    size: "small"
+                  }),
+                  label: "NOF"
+                }), /*#__PURE__*/jsxRuntimeExports.jsx(material.FormControlLabel, {
+                  value: "AF20_40",
+                  control: /*#__PURE__*/jsxRuntimeExports.jsx(material.Radio, {
+                    size: "small"
+                  }),
+                  label: "AF20_40"
+                }), /*#__PURE__*/jsxRuntimeExports.jsx(material.FormControlLabel, {
+                  value: "AF20_50",
+                  control: /*#__PURE__*/jsxRuntimeExports.jsx(material.Radio, {
+                    size: "small"
+                  }),
+                  label: "AF20_50"
+                }), /*#__PURE__*/jsxRuntimeExports.jsx(material.FormControlLabel, {
+                  value: "AF40_40",
+                  control: /*#__PURE__*/jsxRuntimeExports.jsx(material.Radio, {
+                    size: "small"
+                  }),
+                  label: "AF40_40"
+                }), /*#__PURE__*/jsxRuntimeExports.jsx(material.FormControlLabel, {
+                  value: "AF40_50",
+                  control: /*#__PURE__*/jsxRuntimeExports.jsx(material.Radio, {
+                    size: "small"
+                  }),
+                  label: "AF40_50"
+                }), /*#__PURE__*/jsxRuntimeExports.jsx(material.FormControlLabel, {
+                  value: "WF_40",
+                  control: /*#__PURE__*/jsxRuntimeExports.jsx(material.Radio, {
+                    size: "small"
+                  }),
+                  label: "WF_40"
+                }), /*#__PURE__*/jsxRuntimeExports.jsx(material.FormControlLabel, {
+                  value: "WF_50",
+                  control: /*#__PURE__*/jsxRuntimeExports.jsx(material.Radio, {
+                    size: "small"
+                  }),
+                  label: "WF_50"
+                }), /*#__PURE__*/jsxRuntimeExports.jsx(material.FormControlLabel, {
+                  value: "WF_100",
+                  control: /*#__PURE__*/jsxRuntimeExports.jsx(material.Radio, {
+                    size: "small"
+                  }),
+                  label: "WF_100"
+                }), /*#__PURE__*/jsxRuntimeExports.jsx(material.FormControlLabel, {
+                  value: "WF_FLI",
+                  control: /*#__PURE__*/jsxRuntimeExports.jsx(material.Radio, {
+                    size: "small"
+                  }),
+                  label: "WF_FLI"
+                }), /*#__PURE__*/jsxRuntimeExports.jsx(material.FormControlLabel, {
+                  value: "WDGF_WDG100",
+                  control: /*#__PURE__*/jsxRuntimeExports.jsx(material.Radio, {
+                    size: "small"
+                  }),
+                  label: "WDGF_WDG100"
+                }), /*#__PURE__*/jsxRuntimeExports.jsx(material.FormControlLabel, {
+                  value: "MXF_40",
+                  control: /*#__PURE__*/jsxRuntimeExports.jsx(material.Radio, {
+                    size: "small"
+                  }),
+                  label: "MXF_40"
+                }), /*#__PURE__*/jsxRuntimeExports.jsx(material.FormControlLabel, {
+                  value: "MXF_50",
+                  control: /*#__PURE__*/jsxRuntimeExports.jsx(material.Radio, {
+                    size: "small"
+                  }),
+                  label: "MXF_50"
+                }), /*#__PURE__*/jsxRuntimeExports.jsx(material.FormControlLabel, {
+                  value: "MXCAF_40",
+                  control: /*#__PURE__*/jsxRuntimeExports.jsx(material.Radio, {
+                    size: "small"
+                  }),
+                  label: "MXCAF_40"
+                }), /*#__PURE__*/jsxRuntimeExports.jsx(material.FormControlLabel, {
+                  value: "MXCAF_50",
+                  control: /*#__PURE__*/jsxRuntimeExports.jsx(material.Radio, {
+                    size: "small"
+                  }),
+                  label: "MXCAF_50"
+                })]
+              })]
+            }), /*#__PURE__*/jsxRuntimeExports.jsx(material.Divider, {}), /*#__PURE__*/jsxRuntimeExports.jsx(material.Typography, {
+              variant: "subtitle1",
+              color: "secondary",
+              children: "Gasket Properties"
+            }), /*#__PURE__*/jsxRuntimeExports.jsx(material.Stack, {
+              direction: "row",
+              spacing: 2,
+              alignItems: "flex-end",
+              children: /*#__PURE__*/jsxRuntimeExports.jsx(MaterialInput, {
+                label: "Gasket Material",
+                value: doorFrame.gasketMaterial,
+                onChange: value => setDoorFrame(_objectSpread2(_objectSpread2({}, doorFrame), {}, {
+                  gasketMaterial: value
+                })),
+                onApply: handleMaterialApply
+              })
+            }), /*#__PURE__*/jsxRuntimeExports.jsx(MaterialSelector, {
+              label: "Test Gasket Material",
+              value: testGasketMaterial,
+              onChange: setTestGasketMaterial
+            }), /*#__PURE__*/jsxRuntimeExports.jsx(material.Divider, {}), /*#__PURE__*/jsxRuntimeExports.jsx(material.Typography, {
+              variant: "subtitle1",
+              color: "secondary",
+              children: "Hinge Properties"
+            }), /*#__PURE__*/jsxRuntimeExports.jsx(material.Stack, {
+              direction: "row",
+              spacing: 2,
+              alignItems: "flex-end",
+              children: /*#__PURE__*/jsxRuntimeExports.jsx(MaterialInput, {
+                label: "Hinge Material",
+                value: doorFrame.hingeMaterial,
+                onChange: value => setDoorFrame(_objectSpread2(_objectSpread2({}, doorFrame), {}, {
+                  hingeMaterial: value
+                })),
+                onApply: handleMaterialApply
+              })
+            }), /*#__PURE__*/jsxRuntimeExports.jsx(MaterialSelector, {
+              label: "Test Hinge Material",
+              value: testHingeMaterial,
+              onChange: setTestHingeMaterial
+            })]
+          })
+        }), /*#__PURE__*/jsxRuntimeExports.jsx(material.Paper, {
+          elevation: 3,
+          sx: {
+            p: 2
+          },
+          children: /*#__PURE__*/jsxRuntimeExports.jsxs(material.Stack, {
+            spacing: 2,
+            children: [/*#__PURE__*/jsxRuntimeExports.jsx(material.FormControlLabel, {
+              control: /*#__PURE__*/jsxRuntimeExports.jsx(material.Switch, {
+                checked: frontCoverPanel.visible,
+                onChange: e => {
+                  const isVisible = e.target.checked;
+                  setFrontCoverPanel(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+                    visible: isVisible
+                  }));
+                  setBackCoverPanel(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+                    visible: isVisible
+                  }));
+                }
+              }),
+              label: /*#__PURE__*/jsxRuntimeExports.jsx(material.Typography, {
+                variant: "h6",
+                color: "primary",
+                children: "CAS Properties"
+              })
+            }), frontCoverPanel.visible && /*#__PURE__*/jsxRuntimeExports.jsx(material.Paper, {
+              variant: "outlined",
+              sx: {
+                p: 2,
+                mt: 1
+              },
+              children: /*#__PURE__*/jsxRuntimeExports.jsxs(material.Stack, {
+                spacing: 2,
+                children: [/*#__PURE__*/jsxRuntimeExports.jsx(MaterialInput, {
+                  label: "Material",
+                  value: frontCoverPanel.material,
+                  onChange: value => {
+                    setFrontCoverPanel(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+                      material: value
+                    }));
+                    setBackCoverPanel(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+                      material: value
+                    }));
+                  },
+                  onApply: handleMaterialApply
+                }), /*#__PURE__*/jsxRuntimeExports.jsx(MaterialSelector, {
+                  label: "Test Material",
+                  value: testFrontCoverPanelMaterial,
+                  onChange: value => {
+                    setTestFrontCoverPanelMaterial(value);
+                    setTestBackCoverPanelMaterial(value);
+                  }
+                }), /*#__PURE__*/jsxRuntimeExports.jsx(EditableSlider, {
+                  label: "Profile Width",
+                  value: frontCoverPanel.width,
+                  min: 20,
+                  max: 500,
+                  onChange: value => {
+                    setFrontCoverPanel(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+                      width: value
+                    }));
+                    setBackCoverPanel(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+                      width: value
+                    }));
+                  }
+                }), /*#__PURE__*/jsxRuntimeExports.jsx(EditableSlider, {
+                  label: "Depth (from frame)",
+                  value: frontCoverPanel.depth,
+                  min: 5,
+                  max: 100,
+                  onChange: value => {
+                    setFrontCoverPanel(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+                      depth: value
+                    }));
+                    setBackCoverPanel(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+                      depth: value
+                    }));
+                  }
+                })]
+              })
+            })]
+          })
+        }), /*#__PURE__*/jsxRuntimeExports.jsx(material.Paper, {
+          elevation: 3,
+          sx: {
+            p: 2
+          },
+          children: /*#__PURE__*/jsxRuntimeExports.jsxs(material.Stack, {
+            spacing: 2,
+            children: [/*#__PURE__*/jsxRuntimeExports.jsx(material.FormControlLabel, {
+              control: /*#__PURE__*/jsxRuntimeExports.jsx(material.Switch, {
+                checked: interiorFanlight.visible,
+                onChange: e => {
+                  setInteriorFanlight(_objectSpread2(_objectSpread2({}, interiorFanlight), {}, {
+                    visible: e.target.checked
+                  }));
+                }
+              }),
+              label: /*#__PURE__*/jsxRuntimeExports.jsx(material.Typography, {
+                variant: "h6",
+                color: "primary",
+                children: "Interior Fanlight"
+              })
+            }), interiorFanlight.visible && /*#__PURE__*/jsxRuntimeExports.jsx(material.Paper, {
+              variant: "outlined",
+              sx: {
+                p: 2,
+                mt: 1
+              },
+              children: /*#__PURE__*/jsxRuntimeExports.jsxs(material.Stack, {
+                spacing: 2,
+                children: [/*#__PURE__*/jsxRuntimeExports.jsx(material.Stack, {
+                  direction: "row",
+                  spacing: 2,
+                  alignItems: "flex-end",
+                  children: /*#__PURE__*/jsxRuntimeExports.jsx(MaterialInput, {
+                    label: "Material",
+                    value: interiorFanlight.material,
+                    onChange: value => setInteriorFanlight(_objectSpread2(_objectSpread2({}, interiorFanlight), {}, {
+                      material: value
+                    })),
+                    onApply: handleMaterialApply
+                  })
+                }), " ", /*#__PURE__*/jsxRuntimeExports.jsx(MaterialSelector, {
+                  label: "Test Material",
+                  value: testInteriorFanlightMaterial,
+                  onChange: setTestInteriorFanlightMaterial
+                }), /*#__PURE__*/jsxRuntimeExports.jsx(EditableSlider, {
+                  label: "Height",
+                  value: interiorFanlight.height,
+                  min: 100,
+                  max: door.doorHeight - 1500 > 100 ? door.doorHeight - 1500 : 100,
+                  onChange: value => setInteriorFanlight(_objectSpread2(_objectSpread2({}, interiorFanlight), {}, {
+                    height: value
+                  }))
+                })]
+              })
+            })]
+          })
+        }), /*#__PURE__*/jsxRuntimeExports.jsx(material.Paper, {
+          elevation: 3,
+          sx: {
+            p: 2
+          },
+          children: /*#__PURE__*/jsxRuntimeExports.jsxs(material.Stack, {
+            spacing: 2,
+            children: [/*#__PURE__*/jsxRuntimeExports.jsx(material.FormControlLabel, {
+              control: /*#__PURE__*/jsxRuntimeExports.jsx(material.Switch, {
+                checked: exteriorFanlight.visible,
+                onChange: e => setExteriorFanlight(_objectSpread2(_objectSpread2({}, exteriorFanlight), {}, {
+                  visible: e.target.checked
+                }))
+              }),
+              label: /*#__PURE__*/jsxRuntimeExports.jsx(material.Typography, {
+                variant: "h6",
+                color: "primary",
+                children: "Exterior Fanlight"
+              })
+            }), exteriorFanlight.visible && /*#__PURE__*/jsxRuntimeExports.jsx(material.Paper, {
+              variant: "outlined",
+              sx: {
+                p: 2,
+                mt: 1
+              },
+              children: /*#__PURE__*/jsxRuntimeExports.jsxs(material.Stack, {
+                spacing: 2,
+                children: [/*#__PURE__*/jsxRuntimeExports.jsxs(material.FormControl, {
+                  children: [/*#__PURE__*/jsxRuntimeExports.jsx(material.FormLabel, {
+                    children: "Type"
+                  }), /*#__PURE__*/jsxRuntimeExports.jsxs(material.RadioGroup, {
+                    row: true,
+                    value: exteriorFanlightType,
+                    onChange: e => setExteriorFanlightType(e.target.value),
+                    children: [/*#__PURE__*/jsxRuntimeExports.jsx(material.FormControlLabel, {
+                      value: "WPFL",
+                      control: /*#__PURE__*/jsxRuntimeExports.jsx(material.Radio, {
+                        size: "small"
+                      }),
+                      label: "WPFL"
+                    }), /*#__PURE__*/jsxRuntimeExports.jsx(material.FormControlLabel, {
+                      value: "ALDGFL",
+                      control: /*#__PURE__*/jsxRuntimeExports.jsx(material.Radio, {
+                        size: "small"
+                      }),
+                      label: "ALDGFL"
+                    }), /*#__PURE__*/jsxRuntimeExports.jsx(material.FormControlLabel, {
+                      value: "ALSGFL",
+                      control: /*#__PURE__*/jsxRuntimeExports.jsx(material.Radio, {
+                        size: "small"
+                      }),
+                      label: "ALSGFL"
+                    })]
+                  })]
+                }), /*#__PURE__*/jsxRuntimeExports.jsx(MaterialInput, {
+                  label: "Material",
+                  value: exteriorFanlight.material,
+                  onChange: value => setExteriorFanlight(_objectSpread2(_objectSpread2({}, exteriorFanlight), {}, {
+                    material: value
+                  })),
+                  onApply: handleMaterialApply
+                }), /*#__PURE__*/jsxRuntimeExports.jsx(MaterialSelector, {
+                  label: "Test Material",
+                  value: testExteriorFanlightMaterial,
+                  onChange: setTestExteriorFanlightMaterial
+                }), /*#__PURE__*/jsxRuntimeExports.jsx(EditableSlider, {
+                  label: "Height",
+                  value: exteriorFanlight.height,
+                  min: 100,
+                  max: 1000,
+                  onChange: handleExteriorFanlightHeightChange
+                }), /*#__PURE__*/jsxRuntimeExports.jsx(EditableSlider, {
+                  label: "Depth",
+                  value: exteriorFanlight.depth,
+                  min: 40,
+                  max: doorFrame.frameDepth,
+                  onChange: value => setExteriorFanlight(_objectSpread2(_objectSpread2({}, exteriorFanlight), {}, {
+                    depth: value
+                  }))
+                })]
+              })
+            })]
+          })
+        }), /*#__PURE__*/jsxRuntimeExports.jsx(material.Paper, {
+          elevation: 3,
+          sx: {
+            p: 2
+          },
+          children: /*#__PURE__*/jsxRuntimeExports.jsxs(material.Stack, {
+            spacing: 2,
+            children: [/*#__PURE__*/jsxRuntimeExports.jsx(material.FormControlLabel, {
+              control: /*#__PURE__*/jsxRuntimeExports.jsx(material.Switch, {
+                checked: occulus.visible,
+                onChange: e => setOcculus(_objectSpread2(_objectSpread2({}, occulus), {}, {
+                  visible: e.target.checked
+                }))
+              }),
+              label: /*#__PURE__*/jsxRuntimeExports.jsx(material.Typography, {
+                variant: "h6",
+                color: "primary",
+                children: "Occulus"
+              })
+            }), occulus.visible && /*#__PURE__*/jsxRuntimeExports.jsx(material.Paper, {
+              variant: "outlined",
+              sx: {
+                p: 2,
+                mt: 1
+              },
+              children: /*#__PURE__*/jsxRuntimeExports.jsxs(material.Stack, {
+                spacing: 2,
+                children: [/*#__PURE__*/jsxRuntimeExports.jsx(EditableSlider, {
+                  label: "Offset from Left (x1)",
+                  value: occulus.x1,
+                  min: 50,
+                  max: door.doorWidth - occulus.x2 - 50,
+                  onChange: value => setOcculus(_objectSpread2(_objectSpread2({}, occulus), {}, {
+                    x1: value
+                  }))
+                }), /*#__PURE__*/jsxRuntimeExports.jsx(EditableSlider, {
+                  label: "Offset from Right (x2)",
+                  value: occulus.x2,
+                  min: 50,
+                  max: door.doorWidth - occulus.x1 - 50,
+                  onChange: value => setOcculus(_objectSpread2(_objectSpread2({}, occulus), {}, {
+                    x2: value
+                  }))
+                }), /*#__PURE__*/jsxRuntimeExports.jsx(EditableSlider, {
+                  label: "Offset from Top (y1)",
+                  value: occulus.y1,
+                  min: 50,
+                  max: mainDoorHeight - occulus.y2 - 50,
+                  onChange: value => setOcculus(_objectSpread2(_objectSpread2({}, occulus), {}, {
+                    y1: value
+                  }))
+                }), /*#__PURE__*/jsxRuntimeExports.jsx(EditableSlider, {
+                  label: "Offset from Bottom (y2)",
+                  value: occulus.y2,
+                  min: 50,
+                  max: mainDoorHeight - occulus.y1 - 50,
+                  onChange: value => setOcculus(_objectSpread2(_objectSpread2({}, occulus), {}, {
+                    y2: value
+                  }))
+                }), /*#__PURE__*/jsxRuntimeExports.jsx(material.Divider, {}), /*#__PURE__*/jsxRuntimeExports.jsx(material.Paper, {
+                  variant: "outlined",
+                  sx: {
+                    p: 2,
+                    mt: 1
+                  },
+                  children: /*#__PURE__*/jsxRuntimeExports.jsxs(material.Stack, {
+                    spacing: 2,
+                    children: [/*#__PURE__*/jsxRuntimeExports.jsx(material.FormControlLabel, {
+                      control: /*#__PURE__*/jsxRuntimeExports.jsx(material.Switch, {
+                        checked: occulus.infillVisible,
+                        onChange: e => setOcculus(_objectSpread2(_objectSpread2({}, occulus), {}, {
+                          infillVisible: e.target.checked
+                        }))
+                      }),
+                      label: "Show Infill"
+                    }), /*#__PURE__*/jsxRuntimeExports.jsx(material.Stack, {
+                      direction: "row",
+                      spacing: 2,
+                      alignItems: "flex-end",
+                      children: /*#__PURE__*/jsxRuntimeExports.jsx(MaterialInput, {
+                        label: "Infill Material",
+                        value: occulus.material,
+                        onChange: value => setOcculus(_objectSpread2(_objectSpread2({}, occulus), {}, {
+                          material: value
+                        })),
+                        onApply: handleMaterialApply
+                      })
+                    }), /*#__PURE__*/jsxRuntimeExports.jsx(MaterialSelector, {
+                      label: "Test Material",
+                      value: testOcculusInfillMaterial,
+                      onChange: setTestOcculusInfillMaterial
+                    }), /*#__PURE__*/jsxRuntimeExports.jsx(EditableSlider, {
+                      label: "Infill Depth",
+                      value: occulus.depth,
+                      min: 10,
+                      max: door.theDoorDepth,
+                      onChange: value => setOcculus(_objectSpread2(_objectSpread2({}, occulus), {}, {
+                        depth: value
+                      }))
+                    })]
+                  })
+                })]
+              })
+            })]
+          })
+        }), /*#__PURE__*/jsxRuntimeExports.jsx(material.Paper, {
+          elevation: 3,
+          sx: {
+            p: 2
+          },
+          children: /*#__PURE__*/jsxRuntimeExports.jsxs(material.Stack, {
+            spacing: 2,
+            children: [/*#__PURE__*/jsxRuntimeExports.jsx(material.FormControlLabel, {
+              control: /*#__PURE__*/jsxRuntimeExports.jsx(material.Switch, {
+                checked: glassVisible,
+                onChange: e => setGlassVisible(e.target.checked)
+              }),
+              label: /*#__PURE__*/jsxRuntimeExports.jsx(material.Typography, {
+                variant: "h6",
+                color: "primary",
+                children: "Glass"
+              })
+            }), glassVisible && /*#__PURE__*/jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, {
+              children: [/*#__PURE__*/jsxRuntimeExports.jsx(MaterialInput, {
+                label: "Glass Material",
+                value: doorFrame.glassMaterial || "",
+                onChange: value => setDoorFrame(_objectSpread2(_objectSpread2({}, doorFrame), {}, {
+                  glassMaterial: value
+                })),
+                onApply: handleMaterialApply
+              }), /*#__PURE__*/jsxRuntimeExports.jsx(MaterialSelector, {
+                label: "Test Glass Material",
+                value: testGlassInfillMaterial,
+                onChange: setTestGlassInfillMaterial
+              }), /*#__PURE__*/jsxRuntimeExports.jsx(EditableSlider, {
+                label: "Glass Depth",
+                value: glassDepth,
+                min: 4,
+                max: 20,
+                step: 0.5,
+                onChange: setGlassDepth
+              })]
+            })]
+          })
+        })]
+      })
+    })]
+  });
+};
+
+exports.ConfiguratorProvider = ConfiguratorProvider;
+exports.DoorModels = DoorModels;
+exports.Interface = Interface;
+exports.useConfigurator = useConfigurator;
+//# sourceMappingURL=index.cjs.js.map