code.ts

// Created by Disky.eth/https://github.com/Diskyeth - November 2025

figma.showUI(__html__, { width: 400, height: 550 });

const variableCollectionCache: Map<string, VariableCollection> = new Map();
const variableCache: Map<string, Variable> = new Map();

const variableIdToNameMap: Map<string, string> = new Map();

const originalIdToFigmaIdMap: Map<string, string> = new Map();

figma.ui.onmessage = async (msg) => {
  if (msg.type === 'reconstruct-frame') {
    try {
      
      let frameData: any;
      
      if (typeof msg.data === 'string') {
        
        try {
          frameData = JSON.parse(msg.data);
        } catch (parseError) {
          
          frameData = msg.data;
        }
      } else {
        
        frameData = msg.data;
      }
      
      
      
      const expandedData = expandKeys(frameData);
      
      
      
      const variablesData = expandedData.variablesData || 
                           expandedData.variableCollections || 
                           expandedData.variables ||
                           (expandedData as any).__variables;
      
      if (variablesData) {
        try {
          await createVariableCollections(variablesData);
        } catch (error) {
          
        }
      }
      
      
      const componentMap = new Map<string, ComponentNode>();
      await collectAndCreateComponents(expandedData, figma.currentPage, componentMap);
      
      
      const reconstructedFrame = await reconstructNode(expandedData, figma.currentPage, componentMap);
      
      if (reconstructedFrame) {
        
        if (!reconstructedFrame.parent) {
          figma.currentPage.appendChild(reconstructedFrame);
        }
        
        
        try {
          await applyVariableBindings(reconstructedFrame, expandedData);
        } catch (error) {
          
        }
        
        figma.currentPage.selection = [reconstructedFrame];
        figma.viewport.scrollAndZoomIntoView([reconstructedFrame]);
        
        figma.ui.postMessage({ 
          type: 'reconstruction-complete' 
        });
      }
    } catch (error) {
      const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
      figma.ui.postMessage({ 
        type: 'reconstruction-error',
        message: errorMessage
      });
    }
  }
};

const PROPERTY_EXPANSIONS: Record<string, string> = {
  
  'W': 'width',
  'H': 'height',
  'rot': 'rotation',
  'v': 'visible',
  'l': 'locked',
  'o': 'opacity',
  'bm': 'blendMode',
  
  
  'lm': 'layoutMode',
  'la': 'layoutAlign',
  'paai': 'primaryAxisAlignItems',
  'caai': 'counterAxisAlignItems',
  'pasm': 'primaryAxisSizingMode',
  'casm': 'counterAxisSizingMode',
  'pl': 'paddingLeft',
  'pr': 'paddingRight',
  'pt': 'paddingTop',
  'pb': 'paddingBottom',
  'is': 'itemSpacing',
  'lw': 'layoutWrap',
  'cas': 'counterAxisSpacing',
  'lpos': 'layoutPositioning',
  'rT': 'relativeTransform',
  'con': 'constraints',
  'cc': 'clipsContent',
  
  
  'lg': 'layoutGrow',
  'lsh': 'layoutSizingHorizontal',
  'lsv': 'layoutSizingVertical',
  
  
  'sW': 'strokeWeight',
  'sA': 'strokeAlign',
  'str': 'strokes',
  
  
  'f': 'fills',
  'e': 'effects',
  'cr': 'cornerRadius',
  'tlr': 'topLeftRadius',
  'trr': 'topRightRadius',
  'blr': 'bottomLeftRadius',
  'brr': 'bottomRightRadius',
  
  
  'ch': 'characters',
  'fs': 'fontSize',
  'fn': 'fontName',
  'tah': 'textAlignHorizontal',
  'tav': 'textAlignVertical',
  'ls': 'letterSpacing',
  'lh': 'lineHeight',
  'tar': 'textAutoResize',
  
  
  'vp': 'vectorPaths',
  'vn': 'vectorNetwork',
  'hm': 'handleMirroring',
  'sc': 'strokeCap',
  'sj': 'strokeJoin',
  'vert': 'vertices',
  'seg': 'segments',
  'ts': 'tangentStart',
  'te': 'tangentEnd',
  'st': 'start',
  'en': 'end',
  'reg': 'regions',
  'lp': 'loops',
  
  
  'fsi': 'fillStyleId',
  'ssi': 'strokeStyleId',
  'tsi': 'textStyleId',
  'esi': 'effectStyleId',
  'bv': 'boundVariables',
  
  
  'vars': 'variables',
  'rt': 'resolvedType',
  'vbm': 'valuesByMode',
  'mds': 'modes',
  'mid': 'modeId',
  
  
  'sm': 'scaleMode',
  'ih': 'imageHash',
  'gs': 'gradientStops',
  'gt': 'gradientTransform',
  
  
  'pc': 'pointCount',
  'ir': 'innerRadius',
  
  
  'mcid': 'mainComponentId',
  'mck': 'mainComponentKey',
  'ck': 'componentKey',
  
  
  'c': 'children',
  'p': 'position',
  'wr': 'windingRule',
};

const VALUE_EXPANSIONS: Record<string, string> = {
  
  '0': 'NONE',
  'M': 'MITER',
  'N': 'NORMAL',
  'S': 'SOLID',
  
  
  'PT': 'PASS_THROUGH',
  
  
  'I': 'INHERIT',
  'm': 'MIN',
  'x': 'MAX',
  'A': 'AUTO',
  'F': 'FIXED',
  
  
  'IN': 'INSIDE',
  'OUT': 'OUTSIDE',
  'C': 'CENTER',
  
  
  'NZ': 'NONZERO',
  'EO': 'EVENODD',
};

function fromScientificNotation(value: any): any {
  if (typeof value === 'string') {
    
    if (/^-?\d+\.?\d*e[+-]?\d+$/i.test(value)) {
      return parseFloat(value);
    }
  }
  return value;
}

function expandValue(value: any): any {
  
  const numValue = fromScientificNotation(value);
  if (numValue !== value) return numValue;
  
  
  if (typeof value === 'string' && VALUE_EXPANSIONS[value]) {
    return VALUE_EXPANSIONS[value];
  }
  return value;
}

function expandKeys(obj: any): any {
  if (obj === null || obj === undefined) return obj;
  if (typeof obj !== 'object') return expandValue(obj);
  if (Array.isArray(obj)) return obj.map(expandKeys);
  
  const result: any = {};
  for (const [key, value] of Object.entries(obj)) {
    const newKey = PROPERTY_EXPANSIONS[key] || key;
    result[newKey] = expandKeys(value);
  }
  return result;
}

function expandAbbreviations(obj: any): any {
  return expandKeys(obj);
}

async function createVariableCollections(variablesData: any): Promise<void> {
  if (!variablesData) {
    return;
  }
  
  
  let collections: any[] = [];
  
  if (Array.isArray(variablesData)) {
    collections = variablesData;
  } else if (typeof variablesData === 'object') {
    
    if (variablesData.collections && Array.isArray(variablesData.collections)) {
      collections = variablesData.collections;
    } else if (variablesData.variables && Array.isArray(variablesData.variables)) {
      
      collections = [variablesData];
    } else {
      
      collections = [variablesData];
    }
  }
  
  if (collections.length === 0) {
    return;
  }
  
  
  variableCollectionCache.clear();
  variableCache.clear();
  variableIdToNameMap.clear();
  originalIdToFigmaIdMap.clear();
  
  let createdCollections = 0;
  let existingCollections = 0;
  
  for (const collectionData of collections) {
    try {
      
      const collectionName = collectionData.name || 'Variables';
      let collection: VariableCollection;
      
      
      const localCollections = figma.variables.getLocalVariableCollections();
      const existing = localCollections.find(c => c.name === collectionName);
      
      if (existing) {
        collection = existing;
        existingCollections++;
      } else {
        
        collection = figma.variables.createVariableCollection(collectionName);
        createdCollections++;
        
        
        
        if (collectionData.modes && Array.isArray(collectionData.modes) && collectionData.modes.length > 0) {
          const firstModeData = collectionData.modes[0];
          const firstModeName = firstModeData.name || firstModeData.modeId || 'Default';
          
          
          if (collection.modes.length > 0 && collection.modes[0].name !== firstModeName) {
            try {
              
              collection.renameMode(collection.modes[0].modeId, firstModeName);
            } catch (e) {
              
              
            }
          }
        }
      }
      
      
      
      if (collectionData.modes && Array.isArray(collectionData.modes)) {
        const currentModes = collection.modes;
        const currentModeNames = new Set(currentModes.map(m => m.name));
        
        
        for (const modeData of collectionData.modes) {
          const modeName = modeData.name || modeData.modeId || 'Default';
          
          
          if (currentModeNames.has(modeName)) {
            continue;
          }
          
          try {
            collection.addMode(modeName);
          } catch (e) {
            
          }
        }
      }
      
      variableCollectionCache.set(collectionData.id || collectionName, collection);
      
      
      if (collectionData.variables && Array.isArray(collectionData.variables)) {
        for (const variableData of collectionData.variables) {
          try {
            const variableName = variableData.name;
            if (!variableName) {
              continue;
            }
            
            const variableType = variableData.resolvedType || variableData.type || 'FLOAT';
            
            
            
            const existingVariables = collection.variableIds.map(id => {
              try {
                return figma.variables.getVariableById(id);
              } catch {
                return null;
              }
            }).filter(v => v !== null) as Variable[];
            const existingVar = existingVariables.find(v => v.name === variableName);
            
            let variable: Variable;
            
            if (existingVar) {
              variable = existingVar;
            } else {
              
              if (variableType === 'COLOR') {
                variable = figma.variables.createVariable(variableName, collection, 'COLOR');
              } else if (variableType === 'FLOAT' || variableType === 'NUMBER') {
                variable = figma.variables.createVariable(variableName, collection, 'FLOAT');
              } else if (variableType === 'STRING') {
                variable = figma.variables.createVariable(variableName, collection, 'STRING');
              } else if (variableType === 'BOOLEAN') {
                variable = figma.variables.createVariable(variableName, collection, 'BOOLEAN');
              } else {
                
                variable = figma.variables.createVariable(variableName, collection, 'FLOAT');
              }
            }
            
            
            if (variableData.valuesByMode && collection.modes) {
              const valuesByModeKeys = Object.keys(variableData.valuesByMode);
              
              
              
              const modeMapping: Map<string, string> = new Map();
              
              
              if (collectionData.modes && Array.isArray(collectionData.modes)) {
                for (let i = 0; i < collectionData.modes.length && i < collection.modes.length; i++) {
                  const originalMode = collectionData.modes[i];
                  const currentMode = collection.modes[i];
                  const originalModeId = originalMode.modeId || originalMode.id;
                  const originalModeName = originalMode.name || originalMode.modeId || originalMode.id;
                  
                  if (originalModeId) {
                    modeMapping.set(originalModeId, currentMode.modeId);
                  }
                  if (originalModeName) {
                    modeMapping.set(originalModeName, currentMode.modeId);
                    modeMapping.set(originalModeName.toLowerCase(), currentMode.modeId);
                  }
                }
              }
              
              
              for (const mode of collection.modes) {
                modeMapping.set(mode.name, mode.modeId);
                modeMapping.set(mode.name.toLowerCase(), mode.modeId);
                modeMapping.set(mode.modeId, mode.modeId);
              }
              
              
              for (const [key, modeValue] of Object.entries(variableData.valuesByMode)) {
                
                let targetModeId: string | undefined = modeMapping.get(key);
                
                
                if (!targetModeId) {
                  const matchingMode = collection.modes.find(m => 
                    m.modeId === key || 
                    m.name === key || 
                    m.name.toLowerCase() === key.toLowerCase()
                  );
                  if (matchingMode) {
                    targetModeId = matchingMode.modeId;
                  }
                }
                
                
                if (!targetModeId && collectionData.modes) {
                  const keyIndex = valuesByModeKeys.indexOf(key);
                  if (keyIndex >= 0 && keyIndex < collection.modes.length) {
                    targetModeId = collection.modes[keyIndex].modeId;
                  }
                }
                
                if (targetModeId && modeValue !== undefined && modeValue !== null) {
                  const targetMode = collection.modes.find(m => m.modeId === targetModeId);
                  const modeName = targetMode?.name || key;
                  
                  try {
                    
                    if (typeof modeValue === 'object' && modeValue !== null && 'type' in modeValue && modeValue.type === 'VARIABLE_ALIAS') {
                      const aliasObj = modeValue as any;
                      const aliasId = aliasObj.aliasId || aliasObj.id;
                      const aliasName = aliasObj.aliasName;
                      
                      
                      let referencedVar: Variable | null = null;
                      
                      
                      if (aliasName) {
                        referencedVar = variableCache.get(aliasName) || null;
                      }
                      
                      
                      if (!referencedVar && aliasId) {
                        referencedVar = variableCache.get(aliasId) || null;
                      }
                      
                      
                      if (!referencedVar && aliasName) {
                        const allLocalVars = figma.variables.getLocalVariables();
                        referencedVar = allLocalVars.find(v => v.name === aliasName) || null;
                        
                        if (referencedVar) {
                          variableCache.set(aliasName, referencedVar);
                        }
                      }
                      
                      if (referencedVar) {
                        
                        const alias: VariableAlias = {
                          type: 'VARIABLE_ALIAS',
                          id: referencedVar.id
                        };
                        variable.setValueForMode(targetModeId, alias);
                      } else if (aliasObj.resolvedValue !== undefined && aliasObj.resolvedValue !== null) {
                        
                        
                        if (variableType === 'COLOR') {
                          const resolvedColor = aliasObj.resolvedValue as any;
                          let r = parseNumber(resolvedColor.r ?? resolvedColor.red ?? 0);
                          let g = parseNumber(resolvedColor.g ?? resolvedColor.green ?? 0);
                          let b = parseNumber(resolvedColor.b ?? resolvedColor.blue ?? 0);
                          let a = parseNumber(resolvedColor.a ?? resolvedColor.alpha ?? 1);
                          
                          
                          if (r > 1 || g > 1 || b > 1) {
                            r = r / 255;
                            g = g / 255;
                            b = b / 255;
                          }
                          
                          const clampedColor: RGBA = {
                            r: Math.max(0, Math.min(1, r)),
                            g: Math.max(0, Math.min(1, g)),
                            b: Math.max(0, Math.min(1, b)),
                            a: Math.max(0, Math.min(1, a))
                          };
                          
                          variable.setValueForMode(targetModeId, clampedColor);
                        } else {
                          
                          variable.setValueForMode(targetModeId, aliasObj.resolvedValue as VariableValue);
                        }
                      }
                    } else if (variableType === 'COLOR') {
                      
                      let color: any;
                      if (typeof modeValue === 'object' && modeValue !== null) {
                        const colorObj = modeValue as any;
                        
                        if ('r' in colorObj || 'red' in colorObj) {
                          let r = parseNumber(colorObj.r ?? colorObj.red ?? 0);
                          let g = parseNumber(colorObj.g ?? colorObj.green ?? 0);
                          let b = parseNumber(colorObj.b ?? colorObj.blue ?? 0);
                          let a = parseNumber(colorObj.a ?? colorObj.alpha ?? 1);
                          
                          
                          if (r > 1 || g > 1 || b > 1) {
                            r = r / 255;
                            g = g / 255;
                            b = b / 255;
                          }
                          
                          color = { r, g, b, a };
                        } else {
                          
                          let r = parseNumber(colorObj.r ?? 0);
                          let g = parseNumber(colorObj.g ?? 0);
                          let b = parseNumber(colorObj.b ?? 0);
                          let a = parseNumber(colorObj.a ?? 1);
                          
                          
                          if (r > 1 || g > 1 || b > 1) {
                            r = r / 255;
                            g = g / 255;
                            b = b / 255;
                          }
                          
                          color = { r, g, b, a };
                        }
                      } else {
                        
                        color = { r: 0, g: 0, b: 0, a: 1 };
                      }
                      
                      
                      const clampedColor: RGBA = {
                        r: Math.max(0, Math.min(1, color.r)),
                        g: Math.max(0, Math.min(1, color.g)),
                        b: Math.max(0, Math.min(1, color.b)),
                        a: Math.max(0, Math.min(1, color.a))
                      };
                      
                      variable.setValueForMode(targetModeId, clampedColor);
                    } else {
                      variable.setValueForMode(targetModeId, modeValue as VariableValue);
                    }
                  } catch (e) {
                    
                  }
                }
              }
            }
            
            const varId = variableData.id || variableName;
            
            
            if (varId && variable.id) {
              originalIdToFigmaIdMap.set(varId, variable.id);
            }
            
            
            variableCache.set(varId, variable);
            
            variableCache.set(variable.id, variable);
            
            if (varId) {
              variableIdToNameMap.set(varId, variableName);
            }
          } catch (e) {
            
          }
        }
      }
    } catch (e) {
      
    }
  }
  
}

async function applyVariableBindings(node: SceneNode, nodeData: any): Promise<void> {
  if (!nodeData) return;
  
  
  const expandedData = expandKeys(nodeData);
  
  
  
  
  
  const originalHasBoundVars = nodeData && (nodeData.boundVariables !== undefined || nodeData.bv !== undefined);
  const hasValidBoundVars = expandedData.boundVariables && 
                            typeof expandedData.boundVariables === 'object' && 
                            Object.keys(expandedData.boundVariables).length > 0;
  
  
  if (originalHasBoundVars && hasValidBoundVars) {
    try {
      const boundVars: Record<string, Variable> = {};
      
      
      const resolveVariable = (variableRef: any): Variable | null => {
        let varId: string | undefined;
        let varCollectionId: string | undefined;
        let varName: string | undefined;
        
        
        if (typeof variableRef === 'string') {
          
          varId = variableRef;
        } else if (typeof variableRef === 'object' && variableRef !== null) {
          
          if ((variableRef as any).type === 'VARIABLE_ALIAS') {
            varId = (variableRef as any).id;
          } else {
            varId = (variableRef as any).id || (variableRef as any).variableId;
            varCollectionId = (variableRef as any).collectionId;
            varName = (variableRef as any).name;
          }
        }
        
        if (!varId && !varName) {
          return null;
        }
        
        let variable: Variable | null = null;
        
        
        
        if (varId) {
          
          const figmaId = originalIdToFigmaIdMap.get(varId);
          
          if (figmaId) {
            
            variable = variableCache.get(figmaId) || null;
            
            
            if (!variable) {
              try {
                variable = figma.variables.getVariableById(figmaId);
                if (variable) {
                  
                  variableCache.set(figmaId, variable);
                  variableCache.set(varId, variable); 
                }
              } catch (e) {
                
              }
            }
          } else {
            
            variable = variableCache.get(varId) || null;
            
            
            if (variable) {
              originalIdToFigmaIdMap.set(varId, variable.id);
            } else {
              
            }
          }
        }
        
        
        
        
        
        
        
        
        if (!variable && !varId && varName) {
          const allCollections = figma.variables.getLocalVariableCollections();
          for (const coll of allCollections) {
            const vars = coll.variableIds.map(id => {
              try {
                return figma.variables.getVariableById(id);
              } catch {
                return null;
              }
            }).filter(v => v !== null) as Variable[];
            variable = vars.find(v => v.name === varName) || null;
            if (variable) {
              
              variableCache.set(variable.id, variable);
              break;
            }
          }
        }
        
        return variable;
      };
      
      for (const [property, variableRef] of Object.entries(expandedData.boundVariables)) {
        
        if (property === 'fills' || property === 'strokes') {
          
          if (Array.isArray(variableRef)) {
            const paints = property === 'fills' ? (node as any).fills : (node as any).strokes;
            if (Array.isArray(paints)) {
              const updatedPaints: Paint[] = [];
              for (let i = 0; i < Math.min(paints.length, variableRef.length); i++) {
                const paint = paints[i];
                const varRef = variableRef[i];
                
                if (paint && varRef) {
                  
                  const variable = resolveVariable(varRef);
                  if (variable) {
                    try {
                      
                      
                      
                      if (variable.resolvedType === 'COLOR') {
                        const updatedPaint = figma.variables.setBoundVariableForPaint(paint, 'color', variable);
                        updatedPaints.push(updatedPaint);
                      } else {
                        
                        
                        updatedPaints.push(paint);
                      }
                    } catch (e) {
                      
                      updatedPaints.push(paint);
                    }
                  } else {
                    updatedPaints.push(paint);
                  }
                } else if (paint) {
                  updatedPaints.push(paint);
                }
              }
              
              
              if (updatedPaints.length > 0) {
                try {
                  if (property === 'fills') {
                    (node as any).fills = updatedPaints;
                  } else {
                    (node as any).strokes = updatedPaints;
                  }
                } catch (e) {
                  
                }
              }
            }
          }
          continue;
        }
        
        
        const variable = resolveVariable(variableRef);
        
        
        if (variable) {
          boundVars[property] = variable;
          
        }
      }
      
      
      if (Object.keys(boundVars).length > 0) {
        
        
        
        for (const [property, variable] of Object.entries(boundVars)) {
          try {
            
            const existingBinding = (node as any).boundVariables?.[property];
            const variableAlias: VariableAlias = {
              type: 'VARIABLE_ALIAS',
              id: variable.id
            };
            
            
            if (!existingBinding || 
                (typeof existingBinding === 'object' && existingBinding.id !== variable.id)) {
              (node as any).setBoundVariable(property as any, variableAlias);
            }
          } catch (e) {
            
          }
        }
      }
    } catch (e) {
      
    }
  }
  
  
  
  if (expandedData.children && Array.isArray(expandedData.children) && 'children' in node) {
    const children = (node as any).children;
    if (Array.isArray(children)) {
      
      const childDataMap = new Map<string, any>();
      const childDataByName = new Map<string, any>();
      
      for (const childData of expandedData.children) {
        if (childData.id) {
          childDataMap.set(childData.id, childData);
        }
        if (childData.name) {
          childDataByName.set(childData.name, childData);
        }
      }
      
      
      for (const child of children) {
        let matchedData: any = null;
        
        
        
        
        let componentChildId: string | null = null;
        if (child.id && child.id.includes(';')) {
          
          const parts = child.id.split(';');
          if (parts.length >= 2) {
            componentChildId = parts.slice(1).join(';'); 
          }
        }
        
        
        if (!matchedData && componentChildId) {
          matchedData = childDataMap.get(componentChildId);
          if (matchedData) {
            
            if (child.name && matchedData.name && child.name !== matchedData.name) {
              
            }
          }
        }
        
        
        if (!matchedData && child.id) {
          matchedData = childDataMap.get(child.id);
        }
        
        
        
        
        if (!matchedData) {
          const childIndex = children.indexOf(child);
          if (childIndex >= 0 && childIndex < expandedData.children.length) {
            matchedData = expandedData.children[childIndex];
            
            
            if (matchedData && child.name && matchedData.name && child.name !== matchedData.name) {
              
              
            }
          }
        }
        
        
        if (!matchedData && child.name) {
          const childrenWithSameName = expandedData.children.filter((cd: any) => cd.name === child.name);
          if (childrenWithSameName.length === 1) {
            matchedData = childDataByName.get(child.name);
          }
        }
        
        
        if (matchedData) {
          
          
          const expandedChildData = expandKeys(matchedData);
          
          
          
          
          const originalBoundVars = matchedData.boundVariables || matchedData.bv;
          const hasBoundVariables = originalBoundVars !== undefined && 
                                   originalBoundVars !== null &&
                                   typeof originalBoundVars === 'object' && 
                                   Object.keys(originalBoundVars).length > 0;
          
          
          
          if (hasBoundVariables) {
            await applyVariableBindings(child, expandedChildData);
          } else {
            
            
            
            await applyVariableBindings(child, expandedChildData);
          }
        }
      }
    }
  }
}

function parseNumber(value: any): number {
  if (typeof value === 'number') return value;
  if (typeof value === 'string') {
    return parseFloat(value);
  }
  return 0;
}

function parseColor(colorData: any): RGB {
  return {
    r: parseNumber(colorData.r),
    g: parseNumber(colorData.g),
    b: parseNumber(colorData.b)
  };
}

function parseRGBA(colorData: any): RGBA {
  return {
    r: parseNumber(colorData.r),
    g: parseNumber(colorData.g),
    b: parseNumber(colorData.b),
    a: parseNumber(colorData.a)
  };
}

function deserializePaints(paints: any[]): Paint[] {
  if (!paints || paints.length === 0) return [];
  
  return paints.map((paintData) => {
    
    if (!paintData) {
      return null as any;
    }
    
    const paintType = paintData.type || (paintData as any).$type || 'UNKNOWN';
    
    if (paintType === 'SOLID') {
      return {
        type: 'SOLID',
        visible: paintData.visible !== undefined ? paintData.visible : true,
        opacity: paintData.opacity !== undefined ? parseNumber(paintData.opacity) : 1,
        blendMode: paintData.blendMode !== undefined ? paintData.blendMode : 'NORMAL',
        color: {
          r: parseNumber(paintData.color?.r ?? 0),
          g: parseNumber(paintData.color?.g ?? 0),
          b: parseNumber(paintData.color?.b ?? 0),
        },
      } as SolidPaint;
    } else if (paintType === 'GRADIENT_LINEAR' || paintType === 'GRADIENT_RADIAL' || paintType === 'GRADIENT_ANGULAR' || paintType === 'GRADIENT_DIAMOND') {
      
      if (!paintData.gradientStops || !Array.isArray(paintData.gradientStops) || paintData.gradientStops.length < 2) {
        return null as any;
      }
      
      const gradient = {
        type: paintType as 'GRADIENT_LINEAR' | 'GRADIENT_RADIAL' | 'GRADIENT_ANGULAR' | 'GRADIENT_DIAMOND',
        visible: paintData.visible !== undefined ? paintData.visible : true,
        opacity: paintData.opacity !== undefined ? parseNumber(paintData.opacity) : 1,
        blendMode: paintData.blendMode !== undefined ? paintData.blendMode : 'NORMAL',
        gradientStops: paintData.gradientStops.map((stop: any) => ({
          position: typeof stop.position === 'number' ? stop.position : parseNumber(stop.position ?? 0),
          color: {
            r: typeof stop.color === 'object' && stop.color ? parseNumber(stop.color.r ?? 0) : 0,
            g: typeof stop.color === 'object' && stop.color ? parseNumber(stop.color.g ?? 0) : 0,
            b: typeof stop.color === 'object' && stop.color ? parseNumber(stop.color.b ?? 0) : 0,
            a: typeof stop.color === 'object' && stop.color && stop.color.a !== undefined ? parseNumber(stop.color.a) : 1,
          },
        })),
        gradientTransform: paintData.gradientTransform && Array.isArray(paintData.gradientTransform) ? paintData.gradientTransform : [[1, 0, 0], [0, 1, 0]],
      } as GradientPaint;
      return gradient;
    } else if (paintData.type === 'IMAGE') {
      
      
      if (!paintData.imageHash || paintData.imageHash === '') {
        return null as any;
      }
      
      return {
        type: 'IMAGE',
        scaleMode: paintData.scaleMode || paintData.sm || 'FILL',
        imageHash: paintData.imageHash || paintData.ih || '',
        imageTransform: paintData.imageTransform || [[1, 0, 0], [0, 1, 0]],
        opacity: paintData.opacity !== undefined ? parseNumber(paintData.opacity) : 1,
        visible: paintData.visible !== undefined ? paintData.visible : true,
        blendMode: paintData.blendMode !== undefined ? paintData.blendMode : 'NORMAL',
      } as ImagePaint;
    }
    
    return null as any;
  }).filter(p => p !== null);
}

function deserializeEffects(effects: any[]): Effect[] {
  if (!effects || effects.length === 0) return [];
  
  return effects.map(effectData => {
    if (effectData.type === 'DROP_SHADOW' || effectData.type === 'INNER_SHADOW') {
      return {
        type: effectData.type,
        visible: effectData.visible !== undefined ? effectData.visible : true,
        radius: effectData.radius !== undefined ? parseNumber(effectData.radius) : 0,
        color: effectData.color ? {
          r: parseNumber(effectData.color.r ?? 0),
          g: parseNumber(effectData.color.g ?? 0),
          b: parseNumber(effectData.color.b ?? 0),
          a: effectData.color.a !== undefined ? parseNumber(effectData.color.a) : 1,
        } : { r: 0, g: 0, b: 0, a: 0.5 },
        offset: effectData.offset !== undefined ? effectData.offset : { x: 0, y: 0 },
        spread: effectData.spread !== undefined ? parseNumber(effectData.spread) : 0,
        blendMode: effectData.blendMode !== undefined ? effectData.blendMode : 'NORMAL',
      } as DropShadowEffect | InnerShadowEffect;
    } else if (effectData.type === 'LAYER_BLUR' || effectData.type === 'BACKGROUND_BLUR') {
      return {
        type: effectData.type,
        visible: effectData.visible !== undefined ? effectData.visible : true,
        radius: effectData.radius !== undefined ? parseNumber(effectData.radius) : 0,
      } as BlurEffect;
    }
    
    return {
      type: 'DROP_SHADOW',
      visible: false,
      radius: 0,
      color: { r: 0, g: 0, b: 0, a: 0 },
      offset: { x: 0, y: 0 },
      spread: 0,
      blendMode: 'NORMAL',
    } as DropShadowEffect;
  });
}

function reconstructFills(fillsData: any[]): Paint[] {
  return deserializePaints(fillsData);
}

function reconstructStrokes(strokesData: any[]): Paint[] {
  if (!strokesData || strokesData.length === 0) return [];
  return deserializePaints(strokesData);
}

function collectComponentStructures(data: any, componentStructures: Map<string, any>): void {
  data = expandKeys(data);
  
  
  if (data.type === 'COMPONENT' && data.id) {
    if (!componentStructures.has(data.id)) {
      componentStructures.set(data.id, data);
    }
  }
  
  
  
  
  if (data.type === 'INSTANCE' && data.mainComponentStructure && data.mainComponentId) {
    
    if (!componentStructures.has(data.mainComponentId)) {
      const componentStructure = expandKeys(data.mainComponentStructure);
      componentStructures.set(data.mainComponentId, componentStructure);
      
      
      
      collectComponentStructures(componentStructure, componentStructures);
    }
  }
  
  
  if (data.children && Array.isArray(data.children)) {
    for (const childData of data.children) {
      collectComponentStructures(childData, componentStructures);
    }
  }
}

async function collectAndCreateComponents(
  frameData: any,
  parent: BaseNode & ChildrenMixin,
  componentMap: Map<string, ComponentNode>
): Promise<void> {
  
  const componentStructures = new Map<string, any>();
  collectComponentStructures(frameData, componentStructures);
  
  
  
  
  for (const [originalId, componentData] of componentStructures.entries()) {
    const comp = figma.createComponent();
    
    
    if (componentData.name) comp.name = componentData.name;
    if (componentData.width && componentData.height) {
      comp.resize(componentData.width, componentData.height);
    }
    
    
    if (componentData.visible !== undefined) comp.visible = componentData.visible;
    if (componentData.locked !== undefined) comp.locked = componentData.locked;
    if (componentData.opacity !== undefined) comp.opacity = componentData.opacity;
    if (componentData.blendMode !== undefined) comp.blendMode = componentData.blendMode;
    
    
    if (componentData.fills !== undefined) {
      try {
        const paints = deserializePaints(componentData.fills);
        const validPaints = paints.filter(p => p !== null);
        if (validPaints.length > 0) {
          comp.fills = validPaints;
        }
      } catch (error) {
        
      }
    }
    
    
    if (componentData.strokes !== undefined) {
      try {
        comp.strokes = deserializePaints(componentData.strokes);
        if (componentData.strokeWeight !== undefined) comp.strokeWeight = componentData.strokeWeight;
        if (componentData.strokeAlign !== undefined) comp.strokeAlign = componentData.strokeAlign;
      } catch (error) {
        
      }
    }
    
    
    if (componentData.effects !== undefined) {
      try {
        comp.effects = deserializeEffects(componentData.effects);
      } catch (error) {
        
      }
    }
    
    
    if (componentData.cornerRadius !== undefined) {
      comp.cornerRadius = componentData.cornerRadius;
    } else if (componentData.topLeftRadius !== undefined) {
      comp.topLeftRadius = componentData.topLeftRadius;
      comp.topRightRadius = componentData.topRightRadius;
      comp.bottomLeftRadius = componentData.bottomLeftRadius;
      comp.bottomRightRadius = componentData.bottomRightRadius;
    }
    
    
    if (componentData.layoutMode !== undefined) {
      comp.layoutMode = componentData.layoutMode;
      if (componentData.layoutMode !== 'NONE') {
        if (componentData.layoutAlign !== undefined) comp.layoutAlign = componentData.layoutAlign;
        if (componentData.primaryAxisAlignItems !== undefined) comp.primaryAxisAlignItems = componentData.primaryAxisAlignItems;
        if (componentData.counterAxisAlignItems !== undefined) comp.counterAxisAlignItems = componentData.counterAxisAlignItems;
        if (componentData.primaryAxisSizingMode !== undefined) comp.primaryAxisSizingMode = componentData.primaryAxisSizingMode;
        if (componentData.counterAxisSizingMode !== undefined) {
          if (componentData.counterAxisSizingMode === 'FIXED' || componentData.counterAxisSizingMode === 'AUTO') {
            comp.counterAxisSizingMode = componentData.counterAxisSizingMode;
          }
        }
        if (componentData.paddingLeft !== undefined) comp.paddingLeft = componentData.paddingLeft;
        if (componentData.paddingRight !== undefined) comp.paddingRight = componentData.paddingRight;
        if (componentData.paddingTop !== undefined) comp.paddingTop = componentData.paddingTop;
        if (componentData.paddingBottom !== undefined) comp.paddingBottom = componentData.paddingBottom;
        if (componentData.itemSpacing !== undefined) comp.itemSpacing = componentData.itemSpacing;
        if (componentData.layoutWrap !== undefined) comp.layoutWrap = componentData.layoutWrap;
        if (componentData.counterAxisSpacing !== undefined) {
          comp.counterAxisSpacing = componentData.counterAxisSpacing;
        }
      }
    }
    
    
    componentMap.set(originalId, comp);
    
    
    if (componentData.mainComponentKey) {
      componentMap.set(componentData.mainComponentKey, comp);
    }
    if (componentData.componentKey) {
      componentMap.set(componentData.componentKey, comp);
    }
  }
  
  
  
  for (const [originalId, componentData] of componentStructures.entries()) {
    const comp = componentMap.get(originalId);
    if (!comp) continue;
    
    
    
    if (componentData.children && Array.isArray(componentData.children)) {
      for (const childData of componentData.children) {
        await reconstructNode(childData, comp, componentMap);
      }
    }
    
    
    
    parent.appendChild(comp);
    
    
    comp.x = -10000;
    comp.y = -10000;
    
    
    if (componentData.boundVariables) {
      try {
        await applyVariableBindings(comp, componentData);
      } catch (error) {
        
      }
    }
  }
}

async function reconstructNode(nodeData: any, parent?: BaseNode & ChildrenMixin, componentMap?: Map<string, ComponentNode>): Promise<SceneNode | null> {
  const nodeType = nodeData.type;
  
  
  if (nodeType === 'COMPONENT' && componentMap && nodeData.id && componentMap.has(nodeData.id)) {
    
    return componentMap.get(nodeData.id)!;
  }
  
  if (nodeType === 'FRAME') {
    const frame = await reconstructFrame(nodeData, parent, componentMap);
    return frame;
  } else if (nodeType === 'COMPONENT') {
    
    const component = await reconstructComponent(nodeData, parent, componentMap);
    return component;
  } else if (nodeType === 'INSTANCE') {
    const instance = await reconstructInstance(nodeData, parent, componentMap);
    return instance;
  } else if (nodeType === 'COMPONENT_SET') {
    const componentSet = await reconstructComponentSet(nodeData, parent);
    return componentSet;
  } else if (nodeType === 'VECTOR') {
    const vector = await reconstructVector(nodeData, parent);
    return vector;
  } else if (nodeType === 'RECTANGLE') {
    const rect = await reconstructRectangle(nodeData, parent);
    return rect;
  } else if (nodeType === 'ELLIPSE') {
    const ellipse = await reconstructEllipse(nodeData, parent);
    return ellipse;
  } else if (nodeType === 'POLYGON') {
    const polygon = await reconstructPolygon(nodeData, parent);
    return polygon;
  } else if (nodeType === 'STAR') {
    const star = await reconstructStar(nodeData, parent);
    return star;
  } else if (nodeType === 'LINE') {
    const line = await reconstructLine(nodeData, parent);
    return line;
  } else if (nodeType === 'TEXT') {
    const text = await reconstructText(nodeData, parent);
    return text;
  } else if (nodeType === 'GROUP') {
    
    const group = await reconstructGroup(nodeData, parent, componentMap);
    return group;
  }
  
  return null;
}

async function reconstructFrame(frameData: any, parent?: BaseNode & ChildrenMixin, componentMap?: Map<string, ComponentNode>): Promise<FrameNode> {
  const frame = figma.createFrame();
  
  
  frame.name = frameData.name || 'Frame';
  frame.visible = frameData.visible !== false;
  frame.locked = frameData.locked === true;
  
  
  
  if (parent) {
    parent.appendChild(frame);
  }
  
  
  
  if (frameData.relativeTransform !== undefined) {
    frame.relativeTransform = frameData.relativeTransform;
  } else {
    
    frame.x = parseNumber(frameData.x ?? 0);
    frame.y = parseNumber(frameData.y ?? 0);
    frame.rotation = parseNumber(frameData.rotation ?? 0);
  }
  
  
  
  
  const willHaveAutoCounterAxis = frameData.counterAxisSizingMode === 'AUTO' && 
                                  frameData.layoutMode && 
                                  frameData.layoutMode !== 'NONE' &&
                                  frameData.layoutAlign === 'STRETCH';
  
  const willHaveAutoPrimaryAxis = frameData.primaryAxisSizingMode === 'AUTO' && 
                                  frameData.layoutMode && 
                                  frameData.layoutMode !== 'NONE';
  
  
  const isVerticalLayout = frameData.layoutMode === 'VERTICAL';
  
  
  const shouldSkipWidthResize = (willHaveAutoCounterAxis && isVerticalLayout) || (willHaveAutoPrimaryAxis && !isVerticalLayout);
  const shouldSkipHeightResize = (willHaveAutoCounterAxis && !isVerticalLayout) || (willHaveAutoPrimaryAxis && isVerticalLayout);
  
  if (shouldSkipWidthResize && shouldSkipHeightResize) {
    
  } else if (shouldSkipWidthResize) {
    
    if (frameData.height !== undefined && !shouldSkipHeightResize) {
      frame.resize(frame.width, parseNumber(frameData.height));
    }
  } else if (shouldSkipHeightResize) {
    
    if (frameData.width !== undefined && !shouldSkipWidthResize) {
      frame.resize(parseNumber(frameData.width), frame.height);
    }
  } else {
    
    if (frameData.width !== undefined && frameData.height !== undefined) {
      frame.resize(parseNumber(frameData.width), parseNumber(frameData.height));
    }
  }
  
  
  if (frameData.constraints !== undefined) {
    frame.constraints = frameData.constraints;
  }
  
  
  if (frameData.layoutPositioning !== undefined) frame.layoutPositioning = frameData.layoutPositioning;
  
  
  if (frameData.layoutMode !== undefined) {
    frame.layoutMode = frameData.layoutMode;
    
    
    if (frameData.layoutMode !== 'NONE') {
      
      
      if (frameData.primaryAxisSizingMode !== undefined) {
        frame.primaryAxisSizingMode = frameData.primaryAxisSizingMode;
      } else {
        
        
        if (frameData.layoutMode === 'VERTICAL' && frameData.layoutGrow === 1) {
          frame.primaryAxisSizingMode = 'AUTO';
        }
      }
      
      if (frameData.counterAxisSizingMode !== undefined) {
        if (frameData.counterAxisSizingMode === 'FIXED' || frameData.counterAxisSizingMode === 'AUTO') {
          frame.counterAxisSizingMode = frameData.counterAxisSizingMode;
        }
        
      }
      
      if (frameData.layoutAlign !== undefined) frame.layoutAlign = frameData.layoutAlign;
      if (frameData.primaryAxisAlignItems !== undefined) frame.primaryAxisAlignItems = frameData.primaryAxisAlignItems;
      if (frameData.counterAxisAlignItems !== undefined) frame.counterAxisAlignItems = frameData.counterAxisAlignItems;
      if (frameData.paddingLeft !== undefined) frame.paddingLeft = parseNumber(frameData.paddingLeft);
      if (frameData.paddingRight !== undefined) frame.paddingRight = parseNumber(frameData.paddingRight);
      if (frameData.paddingTop !== undefined) frame.paddingTop = parseNumber(frameData.paddingTop);
      if (frameData.paddingBottom !== undefined) frame.paddingBottom = parseNumber(frameData.paddingBottom);
      if (frameData.itemSpacing !== undefined) frame.itemSpacing = parseNumber(frameData.itemSpacing);
      
      
      if (frameData.layoutWrap !== undefined) frame.layoutWrap = frameData.layoutWrap;
      if (frameData.counterAxisSpacing !== undefined) {
        frame.counterAxisSpacing = parseNumber(frameData.counterAxisSpacing);
      }
    }
  }
  
  
  frame.opacity = parseNumber(frameData.opacity ?? 1);
  if (frameData.blendMode !== undefined) frame.blendMode = frameData.blendMode;
  
  
  
  if (frameData.fills !== undefined && Array.isArray(frameData.fills) && frameData.fills.length > 0) {
    try {
      const paints = deserializePaints(frameData.fills);
      
      const validPaints = paints.filter(p => p !== null);
      if (validPaints.length > 0) {
        frame.fills = validPaints;
      }
    } catch (error) {
      
    }
  }
  
  
  if (frameData.fills !== undefined && Array.isArray(frameData.fills) && frameData.fills.length === 0) {
    
    try {
      frame.fills = [{
        type: 'SOLID',
        color: { r: 0, g: 0, b: 0 },
        opacity: 0,
        visible: true
      }];
    } catch (e) {
      
    }
  }
  
  
  if (frameData.fillStyleId) {
    try {
      frame.fillStyleId = frameData.fillStyleId;
    } catch (e) {
      
    }
  }
  
  
  if (frameData.strokes !== undefined) {
    try {
      const paints = deserializePaints(frameData.strokes);
      frame.strokes = paints;
      if (frameData.strokeWeight !== undefined) frame.strokeWeight = parseNumber(frameData.strokeWeight);
      if (frameData.strokeAlign !== undefined) frame.strokeAlign = frameData.strokeAlign;
    } catch (error) {
      
    }
  }
  
  
  if (frameData.strokeStyleId) {
    try {
      frame.strokeStyleId = frameData.strokeStyleId;
    } catch (e) {
      
    }
  }
  
  
  if (frameData.topLeftRadius !== undefined && 
      frameData.topRightRadius !== undefined && 
      frameData.bottomLeftRadius !== undefined && 
      frameData.bottomRightRadius !== undefined) {
    
    if (typeof frame.topLeftRadius === 'number') frame.topLeftRadius = parseNumber(frameData.topLeftRadius);
    if (typeof frame.topRightRadius === 'number') frame.topRightRadius = parseNumber(frameData.topRightRadius);
    if (typeof frame.bottomLeftRadius === 'number') frame.bottomLeftRadius = parseNumber(frameData.bottomLeftRadius);
    if (typeof frame.bottomRightRadius === 'number') frame.bottomRightRadius = parseNumber(frameData.bottomRightRadius);
  } else if (frameData.cornerRadius !== undefined) {
    
    frame.cornerRadius = parseNumber(frameData.cornerRadius);
  }
  
  
  if (frameData.effects !== undefined) {
    try {
      frame.effects = deserializeEffects(frameData.effects);
    } catch (error) {
      
    }
  }
  
  
  if (frameData.clipsContent !== undefined) {
    frame.clipsContent = frameData.clipsContent;
  }
  
  
  if (frameData.effectStyleId) {
    try {
      frame.effectStyleId = frameData.effectStyleId;
    } catch (e) {
      
    }
  }
  
  
  
  if (frameData.children && Array.isArray(frameData.children)) {
    for (const childData of frameData.children) {
      const child = await reconstructNode(childData, frame, componentMap);
      if (child) {
        
        
        if (frame.layoutMode && frame.layoutMode !== 'NONE') {
          if (childData.layoutGrow !== undefined) {
            try {
              (child as any).layoutGrow = parseNumber(childData.layoutGrow);
            } catch (e) {
              
            }
          }
          
          if (childData.layoutAlign !== undefined) {
            try {
              (child as any).layoutAlign = childData.layoutAlign;
            } catch (e) {
              
            }
          }
          
          if (childData.layoutSizingHorizontal !== undefined) {
            try {
              (child as any).layoutSizingHorizontal = childData.layoutSizingHorizontal;
            } catch (e) {
              
            }
          }
          
          if (childData.layoutSizingVertical !== undefined) {
            try {
              (child as any).layoutSizingVertical = childData.layoutSizingVertical;
            } catch (e) {
              
            }
          }
        }
      }
    }
  }
  
  
    
    if (frameData.counterAxisSizingMode === 'AUTO' && frameData.layoutAlign === 'STRETCH') {
      if (frame.counterAxisSizingMode !== 'AUTO') {
        frame.counterAxisSizingMode = 'AUTO';
      }
    }
    
    
    
    
    if (frameData.layoutMode === 'VERTICAL' && frameData.layoutGrow === 1) {
      if (frame.primaryAxisSizingMode !== 'AUTO') {
        
        
        const currentWidth = frame.width;
        
        frame.resize(currentWidth, 1); 
        
        frame.primaryAxisSizingMode = 'AUTO';
      }
    }
    
    else if (frameData.layoutMode === 'VERTICAL' && frameData.primaryAxisSizingMode === 'AUTO') {
      if (frame.primaryAxisSizingMode !== 'AUTO') {
        frame.primaryAxisSizingMode = 'AUTO';
      }
    }
  
  
  
  
  if (frameData.fills === undefined) {
    try {
      
      
      frame.fills = [{
        type: 'SOLID',
        color: { r: 0, g: 0, b: 0 },
        opacity: 0,
        visible: true
      }];
    } catch (e) {
      
    }
  }
  
  return frame;
}

async function reconstructComponent(componentData: any, parent?: BaseNode & ChildrenMixin, componentMap?: Map<string, ComponentNode>): Promise<ComponentNode> {
  const component = figma.createComponent();
  
  
  component.name = componentData.name || 'Component';
  component.visible = componentData.visible !== false;
  component.locked = componentData.locked === true;
  
  
  
  if (parent) {
    parent.appendChild(component);
  }
  
  
  if (componentData.relativeTransform !== undefined) {
    component.relativeTransform = componentData.relativeTransform;
  } else {
    component.x = parseNumber(componentData.x ?? 0);
    component.y = parseNumber(componentData.y ?? 0);
    component.rotation = parseNumber(componentData.rotation ?? 0);
  }
  
  if (componentData.width !== undefined && componentData.height !== undefined) {
    component.resize(parseNumber(componentData.width), parseNumber(componentData.height));
  }
  
  
  if (componentData.constraints !== undefined) {
    component.constraints = componentData.constraints;
  }
  
  
  if (componentData.layoutMode !== undefined) {
    component.layoutMode = componentData.layoutMode;
    
    if (componentData.layoutMode !== 'NONE') {
      if (componentData.primaryAxisSizingMode !== undefined) {
        component.primaryAxisSizingMode = componentData.primaryAxisSizingMode;
      }
      if (componentData.counterAxisSizingMode !== undefined) {
        if (componentData.counterAxisSizingMode === 'FIXED' || componentData.counterAxisSizingMode === 'AUTO') {
          component.counterAxisSizingMode = componentData.counterAxisSizingMode;
        }
      }
      if (componentData.layoutAlign !== undefined) component.layoutAlign = componentData.layoutAlign;
      if (componentData.primaryAxisAlignItems !== undefined) component.primaryAxisAlignItems = componentData.primaryAxisAlignItems;
      if (componentData.counterAxisAlignItems !== undefined) component.counterAxisAlignItems = componentData.counterAxisAlignItems;
      if (componentData.paddingLeft !== undefined) component.paddingLeft = parseNumber(componentData.paddingLeft);
      if (componentData.paddingRight !== undefined) component.paddingRight = parseNumber(componentData.paddingRight);
      if (componentData.paddingTop !== undefined) component.paddingTop = parseNumber(componentData.paddingTop);
      if (componentData.paddingBottom !== undefined) component.paddingBottom = parseNumber(componentData.paddingBottom);
      if (componentData.itemSpacing !== undefined) component.itemSpacing = parseNumber(componentData.itemSpacing);
      if (componentData.layoutWrap !== undefined) component.layoutWrap = componentData.layoutWrap;
      if (componentData.counterAxisSpacing !== undefined) {
        component.counterAxisSpacing = parseNumber(componentData.counterAxisSpacing);
      }
    }
  }
  
  
  component.opacity = parseNumber(componentData.opacity ?? 1);
  if (componentData.blendMode !== undefined) component.blendMode = componentData.blendMode;
  
  
  if (componentData.fills !== undefined && Array.isArray(componentData.fills) && componentData.fills.length > 0) {
    try {
      const paints = deserializePaints(componentData.fills);
      const validPaints = paints.filter(p => p !== null);
      if (validPaints.length > 0) {
        component.fills = validPaints;
      }
    } catch (error) {
      
    }
  }
  
  
  if (componentData.fills !== undefined && Array.isArray(componentData.fills) && componentData.fills.length === 0) {
    try {
      component.fills = [{
        type: 'SOLID',
        color: { r: 0, g: 0, b: 0 },
        opacity: 0,
        visible: true
      }];
    } catch (e) {
      
    }
  }
  
  
  if (componentData.fills === undefined) {
    try {
      component.fills = [{
        type: 'SOLID',
        color: { r: 0, g: 0, b: 0 },
        opacity: 0,
        visible: true
      }];
    } catch (e) {
      
    }
  }
  
  
  if (componentData.fillStyleId) {
    try {
      component.fillStyleId = componentData.fillStyleId;
    } catch (e) {
      
    }
  }
  
  
  if (componentData.strokes !== undefined) {
    try {
      const paints = deserializePaints(componentData.strokes);
      component.strokes = paints;
      if (componentData.strokeWeight !== undefined) component.strokeWeight = parseNumber(componentData.strokeWeight);
      if (componentData.strokeAlign !== undefined) component.strokeAlign = componentData.strokeAlign;
    } catch (error) {
      
    }
  }
  
  
  if (componentData.strokeStyleId) {
    try {
      component.strokeStyleId = componentData.strokeStyleId;
    } catch (e) {
      
    }
  }
  
  
  if (componentData.topLeftRadius !== undefined && 
      componentData.topRightRadius !== undefined && 
      componentData.bottomLeftRadius !== undefined && 
      componentData.bottomRightRadius !== undefined) {
    component.topLeftRadius = parseNumber(componentData.topLeftRadius);
    component.topRightRadius = parseNumber(componentData.topRightRadius);
    component.bottomLeftRadius = parseNumber(componentData.bottomLeftRadius);
    component.bottomRightRadius = parseNumber(componentData.bottomRightRadius);
  } else if (componentData.cornerRadius !== undefined) {
    component.cornerRadius = parseNumber(componentData.cornerRadius);
  }
  
  
  if (componentData.effects !== undefined) {
    try {
      component.effects = deserializeEffects(componentData.effects);
    } catch (error) {
      
    }
  }
  
  
  if (componentData.clipsContent !== undefined) {
    component.clipsContent = componentData.clipsContent;
  }
  
  
  if (componentData.effectStyleId) {
    try {
      component.effectStyleId = componentData.effectStyleId;
    } catch (e) {
      
    }
  }
  
  
  
  if (componentData.children && Array.isArray(componentData.children)) {
    for (const childData of componentData.children) {
      const child = await reconstructNode(childData, component, componentMap);
      if (child) {
        
        if (component.layoutMode && component.layoutMode !== 'NONE') {
          if (childData.layoutGrow !== undefined) {
            try {
              (child as any).layoutGrow = parseNumber(childData.layoutGrow);
            } catch (e) {
              
            }
          }
          
          if (childData.layoutAlign !== undefined) {
            try {
              (child as any).layoutAlign = childData.layoutAlign;
            } catch (e) {
              
            }
          }
          
          if (childData.layoutSizingHorizontal !== undefined) {
            try {
              (child as any).layoutSizingHorizontal = childData.layoutSizingHorizontal;
            } catch (e) {
              
            }
          }
          
          if (childData.layoutSizingVertical !== undefined) {
            try {
              (child as any).layoutSizingVertical = childData.layoutSizingVertical;
            } catch (e) {
              
            }
          }
        }
      }
    }
  }
  
  
  if (componentData.counterAxisSizingMode === 'AUTO' && componentData.layoutAlign === 'STRETCH') {
    if (component.counterAxisSizingMode !== 'AUTO') {
      component.counterAxisSizingMode = 'AUTO';
    }
  }
  
  if (componentData.layoutMode === 'VERTICAL' && componentData.layoutGrow === 1) {
    if (component.primaryAxisSizingMode !== 'AUTO') {
      const currentWidth = component.width;
      component.resize(currentWidth, 1);
      component.primaryAxisSizingMode = 'AUTO';
    }
  } else if (componentData.layoutMode === 'VERTICAL' && componentData.primaryAxisSizingMode === 'AUTO') {
    if (component.primaryAxisSizingMode !== 'AUTO') {
      component.primaryAxisSizingMode = 'AUTO';
    }
  }
  
  
  if (componentData.boundVariables) {
    try {
      await applyVariableBindings(component, componentData);
    } catch (error) {
      
    }
  }
  
  return component;
}

async function reconstructInstance(instanceData: any, parent?: BaseNode & ChildrenMixin, componentMap?: Map<string, ComponentNode>): Promise<InstanceNode | FrameNode> {
  
  let mainComponent: ComponentNode | null = null;
  
  if (componentMap && instanceData.mainComponentId) {
    mainComponent = componentMap.get(instanceData.mainComponentId) || null;
    
    
    if (!mainComponent && instanceData.mainComponentKey) {
      mainComponent = componentMap.get(instanceData.mainComponentKey) || null;
    }
  }
  
  
  if (!mainComponent && instanceData.mainComponentId) {
    try {
      mainComponent = figma.getNodeById(instanceData.mainComponentId) as ComponentNode | null;
    } catch (e) {
      
    }
  }
  
  
  if (!mainComponent && instanceData.mainComponentName) {
    const allComponents = figma.root.findAll(node => node.type === 'COMPONENT') as ComponentNode[];
    mainComponent = allComponents.find(comp => comp.name === instanceData.mainComponentName) || null;
  }
  
  
  let instance: InstanceNode | FrameNode;
  if (mainComponent) {
    instance = mainComponent.createInstance();
  } else {
    
    instance = figma.createFrame();
  }
  
  
  instance.name = instanceData.name || 'Instance';
  instance.visible = instanceData.visible !== false;
  instance.locked = instanceData.locked === true;
  
  
  
  if (parent) {
    parent.appendChild(instance);
  }
  
  
  if (instanceData.relativeTransform !== undefined) {
    instance.relativeTransform = instanceData.relativeTransform;
  } else {
    instance.x = parseNumber(instanceData.x ?? 0);
    instance.y = parseNumber(instanceData.y ?? 0);
    instance.rotation = parseNumber(instanceData.rotation ?? 0);
  }
  
  if (instanceData.width !== undefined && instanceData.height !== undefined) {
    instance.resize(parseNumber(instanceData.width), parseNumber(instanceData.height));
  }
  
  
  if (instanceData.constraints !== undefined) {
    instance.constraints = instanceData.constraints;
  }
  
  
  instance.opacity = parseNumber(instanceData.opacity ?? 1);
  if (instanceData.blendMode !== undefined) instance.blendMode = instanceData.blendMode;
  
  
  
  
  
  
  if (instanceData.boundVariables) {
    try {
      await applyVariableBindings(instance, instanceData);
    } catch (error) {
      
    }
  }
  
  return instance;
}

async function reconstructComponentSet(componentSetData: any, parent?: BaseNode & ChildrenMixin): Promise<SceneNode> {
  
  
  const tempFrame = figma.createFrame();
  figma.currentPage.appendChild(tempFrame);
  
  
  const componentChildren: ComponentNode[] = [];
  if (componentSetData.children && Array.isArray(componentSetData.children)) {
    for (const childData of componentSetData.children) {
      const expandedChild = expandKeys(childData);
      if (expandedChild.type === 'COMPONENT') {
        const component = await reconstructComponent(expandedChild);
        tempFrame.appendChild(component);
        componentChildren.push(component);
      }
    }
  }
  
  
  let componentSet: ComponentSetNode | FrameNode | ComponentNode;
  if (componentChildren.length > 1) {
    try {
      componentSet = figma.combineAsVariants(componentChildren, tempFrame);
      
      tempFrame.remove();
    } catch (error) {
      
      componentSet = tempFrame;
    }
  } else if (componentChildren.length === 1) {
    
    componentSet = componentChildren[0];
    tempFrame.remove();
  } else {
    
    componentSet = tempFrame;
  }
  
  
  componentSet.name = componentSetData.name || 'Component Set';
  componentSet.visible = componentSetData.visible !== false;
  componentSet.locked = componentSetData.locked === true;
  
  
  if (parent && !componentSet.parent) {
    parent.appendChild(componentSet);
  }
  
  
  if ('x' in componentSet && componentSetData.x !== undefined) {
    componentSet.x = parseNumber(componentSetData.x);
  }
  if ('y' in componentSet && componentSetData.y !== undefined) {
    componentSet.y = parseNumber(componentSetData.y);
  }
  if ('rotation' in componentSet && componentSetData.rotation !== undefined) {
    componentSet.rotation = parseNumber(componentSetData.rotation);
  }
  
  return componentSet;
}

async function reconstructVector(vectorData: any, parent?: BaseNode & ChildrenMixin): Promise<VectorNode> {
  const vector = figma.createVector();
  
  vector.name = vectorData.name || 'Vector';
  vector.visible = vectorData.visible !== false;
  vector.locked = vectorData.locked === true;
  vector.opacity = parseNumber(vectorData.opacity ?? 1);
  
  
  
  if (parent) {
    parent.appendChild(vector);
  }
  
  
  
  if (vectorData.relativeTransform !== undefined) {
    vector.relativeTransform = vectorData.relativeTransform;
  } else {
    vector.x = parseNumber(vectorData.x ?? 0);
    vector.y = parseNumber(vectorData.y ?? 0);
  }
  vector.resize(parseNumber(vectorData.width ?? 100), parseNumber(vectorData.height ?? 100));
  vector.rotation = parseNumber(vectorData.rotation ?? 0);
  
  if (vectorData.fills) {
    vector.fills = reconstructFills(vectorData.fills);
  }
  
  if (vectorData.fillStyleId) {
    try {
      vector.fillStyleId = vectorData.fillStyleId;
    } catch (e) {
      
    }
  }
  
  if (vectorData.strokes) {
    vector.strokes = reconstructStrokes(vectorData.strokes);
    vector.strokeWeight = parseNumber(vectorData.strokeWeight ?? 1);
    if (vectorData.strokeAlign) vector.strokeAlign = vectorData.strokeAlign;
  }
  
  if (vectorData.strokeStyleId) {
    try {
      vector.strokeStyleId = vectorData.strokeStyleId;
    } catch (e) {
      
    }
  }
  
  if (vectorData.blendMode) vector.blendMode = vectorData.blendMode;
  
  if (vectorData.cornerRadius !== undefined) {
    vector.cornerRadius = parseNumber(vectorData.cornerRadius);
  }
  
  if (vectorData.vectorPaths && Array.isArray(vectorData.vectorPaths)) {
    vector.vectorPaths = vectorData.vectorPaths.map((path: any) => ({
      windingRule: path.windingRule || path.wr || 'NONZERO',
      data: path.data
    }));
  }
  
  if (vectorData.vectorNetwork || vectorData.vn) {
    try {
      const network = vectorData.vectorNetwork || vectorData.vn;
      const reconstructedNetwork: VectorNetwork = {
        vertices: (network.vertices || network.vert || []).map((v: any) => ({
          x: parseNumber(v.x),
          y: parseNumber(v.y),
          strokeCap: v.strokeCap || v.sc || 'NONE',
          strokeJoin: v.strokeJoin || v.sj || 'MITER',
          cornerRadius: parseNumber(v.cornerRadius ?? 0),
          handleMirroring: v.handleMirroring || v.hm || 'NONE'
        })),
        segments: (network.segments || network.seg || []).map((s: any) => ({
          start: s.start || s.st,
          end: s.end || s.en,
          tangentStart: (s.tangentStart || s.ts) ? {
            x: parseNumber((s.tangentStart || s.ts).x),
            y: parseNumber((s.tangentStart || s.ts).y)
          } : { x: 0, y: 0 },
          tangentEnd: (s.tangentEnd || s.te) ? {
            x: parseNumber((s.tangentEnd || s.te).x),
            y: parseNumber((s.tangentEnd || s.te).y)
          } : { x: 0, y: 0 }
        })),
        regions: (network.regions || network.reg || [])?.map((r: any) => ({
          windingRule: r.windingRule || r.wr || 'NONZERO',
          loops: r.loops || r.lp || [],
          fills: reconstructFills(r.fills || r.f || [])
        })) || []
      };
      vector.vectorNetwork = reconstructedNetwork;
    } catch (error) {
    }
  }
  
  if (vectorData.effects) {
    vector.effects = vectorData.effects;
  }
  
  if (vectorData.effectStyleId) {
    try {
      vector.effectStyleId = vectorData.effectStyleId;
    } catch (e) {
      
    }
  }
  
  
  
  return vector;
}

async function reconstructRectangle(rectData: any, parent?: BaseNode & ChildrenMixin): Promise<RectangleNode> {
  const rect = figma.createRectangle();
  
  rect.name = rectData.name || 'Rectangle';
  rect.visible = rectData.visible !== false;
  rect.locked = rectData.locked === true;
  rect.opacity = parseNumber(rectData.opacity ?? 1);
  
  
  if (parent) {
    parent.appendChild(rect);
  }
  
  
  
  if (rectData.relativeTransform !== undefined) {
    rect.relativeTransform = rectData.relativeTransform;
  } else {
    rect.x = parseNumber(rectData.x ?? 0);
    rect.y = parseNumber(rectData.y ?? 0);
  }
  rect.resize(parseNumber(rectData.width ?? 100), parseNumber(rectData.height ?? 100));
  rect.rotation = parseNumber(rectData.rotation ?? 0);
  
  if (rectData.fills) {
    rect.fills = reconstructFills(rectData.fills);
  }
  
  if (rectData.fillStyleId) {
    try {
      rect.fillStyleId = rectData.fillStyleId;
    } catch (e) {
      
    }
  }
  
  if (rectData.strokes) {
    rect.strokes = reconstructStrokes(rectData.strokes);
    rect.strokeWeight = parseNumber(rectData.strokeWeight ?? 1);
    if (rectData.strokeAlign) rect.strokeAlign = rectData.strokeAlign;
  }
  
  if (rectData.strokeStyleId) {
    try {
      rect.strokeStyleId = rectData.strokeStyleId;
    } catch (e) {
      
    }
  }
  
  if (rectData.cornerRadius !== undefined) {
    rect.cornerRadius = parseNumber(rectData.cornerRadius);
  }
  
  
  if (rectData.topLeftRadius !== undefined) {
    if (typeof rect.topLeftRadius === 'number') {
      rect.topLeftRadius = parseNumber(rectData.topLeftRadius);
    }
  }
  if (rectData.topRightRadius !== undefined) {
    if (typeof rect.topRightRadius === 'number') {
      rect.topRightRadius = parseNumber(rectData.topRightRadius);
    }
  }
  if (rectData.bottomLeftRadius !== undefined) {
    if (typeof rect.bottomLeftRadius === 'number') {
      rect.bottomLeftRadius = parseNumber(rectData.bottomLeftRadius);
    }
  }
  if (rectData.bottomRightRadius !== undefined) {
    if (typeof rect.bottomRightRadius === 'number') {
      rect.bottomRightRadius = parseNumber(rectData.bottomRightRadius);
    }
  }
  
  if (rectData.blendMode) rect.blendMode = rectData.blendMode;
  
  if (rectData.effects) {
    rect.effects = rectData.effects;
  }
  
  if (rectData.effectStyleId) {
    try {
      rect.effectStyleId = rectData.effectStyleId;
    } catch (e) {
      
    }
  }
  
  
  
  return rect;
}

async function reconstructEllipse(ellipseData: any, parent?: BaseNode & ChildrenMixin): Promise<EllipseNode> {
  const ellipse = figma.createEllipse();
  
  ellipse.name = ellipseData.name || 'Ellipse';
  ellipse.visible = ellipseData.visible !== false;
  ellipse.locked = ellipseData.locked === true;
  ellipse.opacity = parseNumber(ellipseData.opacity ?? 1);
  
  
  if (parent) {
    parent.appendChild(ellipse);
  }
  
  
  
  if (ellipseData.relativeTransform !== undefined) {
    ellipse.relativeTransform = ellipseData.relativeTransform;
  } else {
    ellipse.x = parseNumber(ellipseData.x ?? 0);
    ellipse.y = parseNumber(ellipseData.y ?? 0);
  }
  ellipse.resize(parseNumber(ellipseData.width ?? 100), parseNumber(ellipseData.height ?? 100));
  ellipse.rotation = parseNumber(ellipseData.rotation ?? 0);
  
  if (ellipseData.fills) {
    ellipse.fills = reconstructFills(ellipseData.fills);
  }
  
  if (ellipseData.fillStyleId) {
    try {
      ellipse.fillStyleId = ellipseData.fillStyleId;
    } catch (e) {
      
    }
  }
  
  if (ellipseData.strokes) {
    ellipse.strokes = reconstructStrokes(ellipseData.strokes);
    ellipse.strokeWeight = parseNumber(ellipseData.strokeWeight ?? 1);
    if (ellipseData.strokeAlign) ellipse.strokeAlign = ellipseData.strokeAlign;
  }
  
  if (ellipseData.strokeStyleId) {
    try {
      ellipse.strokeStyleId = ellipseData.strokeStyleId;
    } catch (e) {
      
    }
  }
  
  if (ellipseData.blendMode) ellipse.blendMode = ellipseData.blendMode;
  
  if (ellipseData.effects) {
    ellipse.effects = ellipseData.effects;
  }
  
  if (ellipseData.effectStyleId) {
    try {
      ellipse.effectStyleId = ellipseData.effectStyleId;
    } catch (e) {
      
    }
  }
  
  return ellipse;
}

async function reconstructPolygon(polygonData: any, parent?: BaseNode & ChildrenMixin): Promise<PolygonNode> {
  const polygon = figma.createPolygon();
  
  polygon.name = polygonData.name || 'Polygon';
  polygon.visible = polygonData.visible !== false;
  polygon.locked = polygonData.locked === true;
  polygon.opacity = parseNumber(polygonData.opacity ?? 1);
  
  
  if (parent) {
    parent.appendChild(polygon);
  }
  
  
  
  if (polygonData.relativeTransform !== undefined) {
    polygon.relativeTransform = polygonData.relativeTransform;
  } else {
    polygon.x = parseNumber(polygonData.x ?? 0);
    polygon.y = parseNumber(polygonData.y ?? 0);
  }
  polygon.resize(parseNumber(polygonData.width ?? 100), parseNumber(polygonData.height ?? 100));
  polygon.rotation = parseNumber(polygonData.rotation ?? 0);
  
  if (polygonData.pointCount !== undefined) {
    polygon.pointCount = parseNumber(polygonData.pointCount);
  }
  
  if (polygonData.fills) {
    polygon.fills = reconstructFills(polygonData.fills);
  }
  
  if (polygonData.fillStyleId) {
    try {
      polygon.fillStyleId = polygonData.fillStyleId;
    } catch (e) {
      
    }
  }
  
  if (polygonData.strokes) {
    polygon.strokes = reconstructStrokes(polygonData.strokes);
    polygon.strokeWeight = parseNumber(polygonData.strokeWeight ?? 1);
    if (polygonData.strokeAlign) polygon.strokeAlign = polygonData.strokeAlign;
  }
  
  if (polygonData.strokeStyleId) {
    try {
      polygon.strokeStyleId = polygonData.strokeStyleId;
    } catch (e) {
      
    }
  }
  
  if (polygonData.blendMode) polygon.blendMode = polygonData.blendMode;
  
  if (polygonData.effects) {
    polygon.effects = polygonData.effects;
  }
  
  if (polygonData.effectStyleId) {
    try {
      polygon.effectStyleId = polygonData.effectStyleId;
    } catch (e) {
      
    }
  }
  
  return polygon;
}

async function reconstructStar(starData: any, parent?: BaseNode & ChildrenMixin): Promise<StarNode> {
  const star = figma.createStar();
  
  star.name = starData.name || 'Star';
  star.visible = starData.visible !== false;
  star.locked = starData.locked === true;
  star.opacity = parseNumber(starData.opacity ?? 1);
  
  
  if (parent) {
    parent.appendChild(star);
  }
  
  
  
  if (starData.relativeTransform !== undefined) {
    star.relativeTransform = starData.relativeTransform;
  } else {
    star.x = parseNumber(starData.x ?? 0);
    star.y = parseNumber(starData.y ?? 0);
  }
  star.resize(parseNumber(starData.width ?? 100), parseNumber(starData.height ?? 100));
  star.rotation = parseNumber(starData.rotation ?? 0);
  
  if (starData.pointCount !== undefined) {
    star.pointCount = parseNumber(starData.pointCount);
  }
  
  if (starData.innerRadius !== undefined) {
    star.innerRadius = parseNumber(starData.innerRadius);
  }
  
  if (starData.fills) {
    star.fills = reconstructFills(starData.fills);
  }
  
  if (starData.fillStyleId) {
    try {
      star.fillStyleId = starData.fillStyleId;
    } catch (e) {
      
    }
  }
  
  if (starData.strokes) {
    star.strokes = reconstructStrokes(starData.strokes);
    star.strokeWeight = parseNumber(starData.strokeWeight ?? 1);
    if (starData.strokeAlign) star.strokeAlign = starData.strokeAlign;
  }
  
  if (starData.strokeStyleId) {
    try {
      star.strokeStyleId = starData.strokeStyleId;
    } catch (e) {
      
    }
  }
  
  if (starData.blendMode) star.blendMode = starData.blendMode;
  
  if (starData.effects) {
    star.effects = starData.effects;
  }
  
  if (starData.effectStyleId) {
    try {
      star.effectStyleId = starData.effectStyleId;
    } catch (e) {
      
    }
  }
  
  return star;
}

async function reconstructLine(lineData: any, parent?: BaseNode & ChildrenMixin): Promise<LineNode> {
  const line = figma.createLine();
  
  line.name = lineData.name || 'Line';
  line.visible = lineData.visible !== false;
  line.locked = lineData.locked === true;
  line.opacity = parseNumber(lineData.opacity ?? 1);
  
  
  if (parent) {
    parent.appendChild(line);
  }
  
  
  
  if (lineData.relativeTransform !== undefined) {
    line.relativeTransform = lineData.relativeTransform;
  } else {
    line.x = parseNumber(lineData.x ?? 0);
    line.y = parseNumber(lineData.y ?? 0);
  }
  line.rotation = parseNumber(lineData.rotation ?? 0);
  
  
  if (lineData.width !== undefined && lineData.height !== undefined) {
    line.resize(parseNumber(lineData.width), parseNumber(lineData.height));
  }
  
  if (lineData.strokes) {
    line.strokes = reconstructStrokes(lineData.strokes);
    line.strokeWeight = parseNumber(lineData.strokeWeight ?? 1);
    if (lineData.strokeAlign) line.strokeAlign = lineData.strokeAlign;
  }
  
  if (lineData.strokeStyleId) {
    try {
      line.strokeStyleId = lineData.strokeStyleId;
    } catch (e) {
      
    }
  }
  
  if (lineData.blendMode) line.blendMode = lineData.blendMode;
  
  if (lineData.effects) {
    line.effects = lineData.effects;
  }
  
  if (lineData.effectStyleId) {
    try {
      line.effectStyleId = lineData.effectStyleId;
    } catch (e) {
      
    }
  }
  
  return line;
}

async function reconstructText(textData: any, parent?: BaseNode & ChildrenMixin): Promise<TextNode> {
  const text = figma.createText();
  
  
  let fontFamily = "Inter";
  let fontStyle = "Regular";
  
  if (textData.fontName || textData.fn) {
    const fontName = textData.fontName || textData.fn;
    fontFamily = fontName.family || "Inter";
    fontStyle = fontName.style || "Regular";
  }
  
  
  
  try {
    await figma.loadFontAsync({ family: fontFamily, style: fontStyle });
  } catch (e) {
    
    try {
      await figma.loadFontAsync({ family: "Inter", style: "Regular" });
      fontFamily = "Inter";
      fontStyle = "Regular";
    } catch (e2) {
      
      throw new Error(`Failed to load font: ${fontFamily} ${fontStyle}`);
    }
  }
  
  
  text.name = textData.name || 'Text';
  text.visible = textData.visible !== false;
  text.locked = textData.locked === true;
  text.opacity = parseNumber(textData.opacity ?? 1);
  
  
  if (parent) {
    parent.appendChild(text);
  }
  
  
  
  if (textData.relativeTransform !== undefined) {
    text.relativeTransform = textData.relativeTransform;
  } else {
    text.x = parseNumber(textData.x ?? 0);
    text.y = parseNumber(textData.y ?? 0);
  }
  
  
  text.fontName = { family: fontFamily, style: fontStyle };
  
  
  if (textData.fontSize) {
    text.fontSize = parseNumber(textData.fontSize);
  }
  
  
  
  if (textData.textAutoResize !== undefined) {
    text.textAutoResize = textData.textAutoResize;
  }
  
  
  if (textData.characters) {
    text.characters = textData.characters;
  }
  
  
  
  if (!textData.textAutoResize || textData.textAutoResize === 'NONE') {
    
    if (textData.width !== undefined && textData.height !== undefined) {
      text.resize(parseNumber(textData.width), parseNumber(textData.height));
    }
  }
  
  if (textData.textAlignHorizontal || textData.tah) {
    text.textAlignHorizontal = textData.textAlignHorizontal || textData.tah;
  }
  
  if (textData.textAlignVertical || textData.tav) {
    text.textAlignVertical = textData.textAlignVertical || textData.tav;
  }
  
  if (textData.letterSpacing || textData.ls !== undefined) {
    const letterSpacing = textData.letterSpacing || textData.ls;
    if (typeof letterSpacing === 'object' && letterSpacing.value !== undefined) {
      text.letterSpacing = letterSpacing;
    } else if (typeof letterSpacing === 'number') {
      text.letterSpacing = { value: letterSpacing, unit: 'PIXELS' };
    }
  }
  
  if (textData.lineHeight || textData.lh !== undefined) {
    const lineHeight = textData.lineHeight || textData.lh;
    if (typeof lineHeight === 'object' && lineHeight.value !== undefined) {
      text.lineHeight = lineHeight;
    } else if (typeof lineHeight === 'number') {
      text.lineHeight = { value: lineHeight, unit: 'PIXELS' };
    }
  }
  
  if (textData.fills) {
    text.fills = reconstructFills(textData.fills);
  }
  
  if (textData.textStyleId) {
    try {
      text.textStyleId = textData.textStyleId;
    } catch (e) {
      
    }
  }
  
  
  
  return text;
}

async function reconstructGroup(groupData: any, parent?: BaseNode & ChildrenMixin, componentMap?: Map<string, ComponentNode>): Promise<GroupNode> {
  
  
  
  const children: SceneNode[] = [];
  const tempParent = figma.currentPage;
  
  if (groupData.children && Array.isArray(groupData.children)) {
    
    
    for (const childData of groupData.children) {
      const child = await reconstructNode(childData, tempParent, componentMap);
      if (child) {
        children.push(child);
      }
    }
  }
  
  
  if (children.length === 0) {
    const emptyFrame = figma.createFrame();
    emptyFrame.name = groupData.name || 'Group';
    if (parent && !emptyFrame.parent) {
      parent.appendChild(emptyFrame);
    }
    if ('x' in emptyFrame && groupData.x !== undefined) emptyFrame.x = parseNumber(groupData.x);
    if ('y' in emptyFrame && groupData.y !== undefined) emptyFrame.y = parseNumber(groupData.y);
    return emptyFrame as any;
  }
  
  
  const targetParent = parent || figma.currentPage;
  const group = figma.group(children, targetParent);
  
  
  
  group.name = groupData.name || 'Group';
  if ('x' in group && groupData.x !== undefined) {
    group.x = parseNumber(groupData.x);
  }
  if ('y' in group && groupData.y !== undefined) {
    group.y = parseNumber(groupData.y);
  }
  group.visible = groupData.visible !== false;
  group.locked = groupData.locked === true;
  group.opacity = parseNumber(groupData.opacity ?? 1);
  
  if (groupData.blendMode) group.blendMode = groupData.blendMode;
  
  if (groupData.effects) {
    group.effects = groupData.effects;
  }
  
  if (groupData.effectStyleId) {
    try {
      group.effectStyleId = groupData.effectStyleId;
    } catch (e) {
      
    }
  }
  
  
  
  return group;
}