@oamm/textor 1.0.9 → 1.0.11

package/dist/bin/textor.js

@@ -647,7 +647,8 @@ async function verifyFileIntegrity(filePath, expectedHash, options = {}) {
     acceptChanges = false, 
     normalization = 'normalizeEOL',
     owner = null,
-    actualOwner = null
+    actualOwner = null,
+    signatures = []
   } = options;
   
   if (force) return { valid: true };
@@ -660,7 +661,7 @@ async function verifyFileIntegrity(filePath, expectedHash, options = {}) {
     };
   }
 
-  const isGenerated = await isTextorGenerated(filePath);
+  const isGenerated = await isTextorGenerated(filePath, signatures);
   if (!isGenerated) {
     return { 
       valid: false, 
@@ -693,7 +694,7 @@ async function verifyFileIntegrity(filePath, expectedHash, options = {}) {
 }
 
 async function safeDelete(filePath, options = {}) {
-  const { force = false, expectedHash = null, acceptChanges = false, owner = null, actualOwner = null } = options;
+  const { force = false, expectedHash = null, acceptChanges = false, owner = null, actualOwner = null, signatures = [] } = options;
   
   if (!existsSync(filePath)) {
     return { deleted: false, reason: 'not-found' };
@@ -703,7 +704,8 @@ async function safeDelete(filePath, options = {}) {
     force, 
     acceptChanges,
     owner,
-    actualOwner
+    actualOwner,
+    signatures
   });
   if (!integrity.valid) {
     return { deleted: false, reason: integrity.reason, message: integrity.message };
@@ -745,7 +747,8 @@ async function isSafeToDeleteDir(dirPath, stateFiles = {}, options = {}) {
         const fileState = stateFiles[normalizedPath];
         const integrity = await verifyFileIntegrity(filePath, fileState?.hash, {
           ...options,
-          actualOwner: fileState?.owner
+          actualOwner: fileState?.owner,
+          signatures: options.signatures || []
         });
         return integrity.valid;
       })
@@ -841,7 +844,8 @@ async function safeMove(fromPath, toPath, options = {}) {
     acceptChanges, 
     normalization,
     owner,
-    actualOwner
+    actualOwner,
+    signatures: options.signatures || []
   });
   if (!integrity.valid) {
     throw new Error(integrity.message);
@@ -1136,6 +1140,68 @@ ${layoutOpening}
 `;
 }
 
+function mergeRouteTemplate(existingContent, featureImportPath, featureComponentName, layoutName) {
+  let content = existingContent;
+  
+  // 1. Add import
+  const importLine = `import ${featureComponentName} from '${featureImportPath}';`;
+  if (!content.includes(importLine)) {
+    // Find the second --- which marks the end of frontmatter
+    const lines = content.split('\n');
+    let frontMatterEndLine = -1;
+    let dashCount = 0;
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].trim() === '---') {
+        dashCount++;
+        if (dashCount === 2) {
+          frontMatterEndLine = i;
+          break;
+        }
+      }
+    }
+
+    if (frontMatterEndLine !== -1) {
+      lines.splice(frontMatterEndLine, 0, importLine);
+      content = lines.join('\n');
+    } else if (content.includes('---')) {
+      // If only one --- found, maybe it's just the start? 
+      // But standard Astro has two. 
+      // Fallback: insert at the beginning if no frontmatter end found
+      content = importLine + '\n' + content;
+    }
+  }
+
+  // 2. Add component usage
+  const componentTag = `<${featureComponentName} />`;
+  if (!content.includes(componentTag)) {
+    if (layoutName && layoutName !== 'none') {
+      const layoutEndTag = `</${layoutName}>`;
+      if (content.includes(layoutEndTag)) {
+        const lines = content.split('\n');
+        let layoutEndLine = -1;
+        for (let i = lines.length - 1; i >= 0; i--) {
+          if (lines[i].includes(layoutEndTag)) {
+            layoutEndLine = i;
+            break;
+          }
+        }
+        if (layoutEndLine !== -1) {
+          lines.splice(layoutEndLine, 0, `  ${componentTag}`);
+          content = lines.join('\n');
+        }
+      } else {
+        // Layout might be self-closing or missing end tag? 
+        // If it's Textor generated it should have it.
+        content += `\n${componentTag}\n`;
+      }
+    } else {
+      content += `\n${componentTag}\n`;
+    }
+  }
+
+  return content;
+}
+
 /**
  * Feature Template Variables:
  * - componentName: Name of the feature component
@@ -1561,9 +1627,9 @@ async function addSectionToState(section) {
   if (normalizedSection.featurePath) {
     normalizedSection.featurePath = normalizeStatePath(normalizedSection.featurePath);
   }
-  // Avoid duplicates by route OR by featurePath if route is null
+  // Avoid duplicates by route AND by featurePath
   if (normalizedSection.route) {
-    state.sections = state.sections.filter(s => s.route !== normalizedSection.route);
+    state.sections = state.sections.filter(s => s.route !== normalizedSection.route || s.featurePath !== normalizedSection.featurePath);
   } else {
     state.sections = state.sections.filter(s => s.featurePath !== normalizedSection.featurePath || s.route);
   }
@@ -1641,6 +1707,10 @@ function reconstructComponents(files, config) {
             path: componentPath
           });
         }
+        // Attribute ownership
+        if (!files[filePath].owner) {
+          files[filePath].owner = componentName;
+        }
       }
     }
   }
@@ -1684,28 +1754,34 @@ function reconstructSections(state, config) {
 
       if (!sections.has(finalRoute)) {
         // Try to find a matching feature by name
-        const routeName = path.basename(finalRoute === '/' ? 'index' : finalRoute);
+        const routeName = path.basename(finalRoute === '/' ? 'index' : finalRoute).toLowerCase();
         // Look for a directory in features with same name or similar
         const possibleFeaturePath = Object.keys(files).find(f => {
            const nf = f.replace(/\\/g, '/');
-           return nf.startsWith(featuresRoot + '/') && nf.includes('/' + routeName + '/');
+           if (!nf.startsWith(featuresRoot + '/')) return false;
+           const relToFeatures = nf.slice(featuresRoot.length + 1);
+           const segments = relToFeatures.toLowerCase().split('/');
+           return segments.includes(routeName);
         });
 
         if (possibleFeaturePath) {
-           const featurePathParts = possibleFeaturePath.replace(/\\/g, '/').split('/');
-           const featuresBase = path.basename(featuresRoot);
-           const featureIndex = featurePathParts.indexOf(featuresBase) + 1;
-           
-           if (featureIndex > 0 && featureIndex < featurePathParts.length) {
-             const featureName = featurePathParts[featureIndex];
-             const featurePath = `${featuresRoot}/${featureName}`;
-
-             sections.set(finalRoute, {
-               name: featureName,
-               route: finalRoute,
-               featurePath: featurePath,
-               extension: path.extname(filePath)
-             });
+           const relToFeatures = path.dirname(path.relative(featuresRoot, possibleFeaturePath)).replace(/\\/g, '/');
+           const featurePath = relToFeatures === '.' ? featuresRoot : `${featuresRoot}/${relToFeatures}`;
+           const featureName = path.basename(featurePath);
+
+           sections.set(finalRoute, {
+             name: featureName,
+             route: finalRoute,
+             featurePath: featurePath,
+             extension: path.extname(filePath)
+           });
+
+           // Attribute ownership to discovered files
+           if (!files[filePath].owner) files[filePath].owner = finalRoute;
+           for (const f in files) {
+             if (f.startsWith(featurePath + '/') || f === featurePath) {
+               if (!files[f].owner) files[f].owner = finalRoute;
+             }
            }
         }
       }
@@ -1986,7 +2062,16 @@ async function addSectionCommand(route, featurePath, options) {
       await saveState(state);
     }
 
-    if (routeFilePath) await ensureNotExists(routeFilePath, options.force);
+    if (routeFilePath) {
+      if (existsSync(routeFilePath)) {
+        const configSignatures = Object.values(config.signatures || {});
+        const isGenerated = await isTextorGenerated(routeFilePath, configSignatures);
+        if (!isGenerated && !options.force) {
+          throw new Error(`File already exists: ${routeFilePath}\nUse --force to overwrite.`);
+        }
+      }
+    }
+
     await ensureNotExists(featureFilePath, options.force);
     
     if (shouldCreateIndex) await ensureNotExists(indexFilePath, options.force);
@@ -2068,15 +2153,42 @@ async function addSectionCommand(route, featurePath, options) {
         routeContent = generateEndpointTemplate(featureComponentName);
         routeSignature = getSignature(config, 'typescript');
       } else {
-        routeContent = generateRouteTemplate(
-          layout,
-          layoutImportPath,
-          featureImportPath,
-          featureComponentName,
-          routeExtension,
-          layoutProps
-        );
         routeSignature = getSignature(config, 'astro');
+        
+        if (existsSync(routeFilePath)) {
+          const existingContent = await readFile(routeFilePath, 'utf-8');
+          // Strip existing signature if present
+          let contentToMerge = existingContent;
+          if (existingContent.startsWith(routeSignature)) {
+            contentToMerge = existingContent.slice(routeSignature.length).trimStart();
+          } else {
+            // Check for generic signature if specific one doesn't match
+            const genericSignature = '@generated by Textor';
+            if (existingContent.includes(genericSignature)) {
+              const lines = existingContent.split('\n');
+              if (lines[0].includes(genericSignature)) {
+                lines.shift();
+                contentToMerge = lines.join('\n').trimStart();
+              }
+            }
+          }
+          
+          routeContent = mergeRouteTemplate(
+            contentToMerge,
+            featureImportPath,
+            featureComponentName,
+            layout
+          );
+        } else {
+          routeContent = generateRouteTemplate(
+            layout,
+            layoutImportPath,
+            featureImportPath,
+            featureComponentName,
+            routeExtension,
+            layoutProps
+          );
+        }
       }
     }
     
@@ -2419,6 +2531,7 @@ async function removeSectionCommand(route, featurePath, options) {
     
     const pagesRoot = resolvePath(config, 'pages');
     const featuresRoot = resolvePath(config, 'features');
+    const configSignatures = Object.values(config.signatures || {});
 
     // Find route file in state if possible
     let routeFilePath = null;
@@ -2468,7 +2581,8 @@ async function removeSectionCommand(route, featurePath, options) {
         acceptChanges: options.acceptChanges,
         normalization: config.hashing?.normalization,
         owner: normalizedRoute,
-        actualOwner: fileState?.owner
+        actualOwner: fileState?.owner,
+        signatures: configSignatures
       });
       
       if (result.deleted) {
@@ -2485,7 +2599,8 @@ async function removeSectionCommand(route, featurePath, options) {
         stateFiles: state.files,
         acceptChanges: options.acceptChanges,
         normalization: config.hashing?.normalization,
-        owner: normalizedRoute
+        owner: normalizedRoute,
+        signatures: configSignatures
       });
       
       if (result.deleted) {
@@ -2712,6 +2827,7 @@ async function moveSectionCommand(fromRoute, fromFeature, toRoute, toFeature, op
     
     const pagesRoot = resolvePath(config, 'pages');
     const featuresRoot = resolvePath(config, 'features');
+    const configSignatures = Object.values(config.signatures || {});
     
     const fromSection = findSection(state, actualFromRoute);
     const routeExtension = (fromSection && fromSection.extension) || config.naming.routeExtension;
@@ -2753,7 +2869,8 @@ async function moveSectionCommand(fromRoute, fromFeature, toRoute, toFeature, op
       expectedHash: routeFileState?.hash,
       acceptChanges: options.acceptChanges,
       owner: normalizedFromRoute,
-      actualOwner: routeFileState?.owner
+      actualOwner: routeFileState?.owner,
+      signatures: configSignatures
     });
     movedFiles.push({ from: fromRoutePath, to: toRoutePath });
     
@@ -2850,7 +2967,8 @@ async function moveSectionCommand(fromRoute, fromFeature, toRoute, toFeature, op
           ...options,
           fromName: fromFeatureComponentName,
           toName: toFeatureComponentName,
-          owner: normalizedFromRoute
+          owner: normalizedFromRoute,
+          signatures: configSignatures
         });
         movedFiles.push({ from: fromFeaturePath, to: toFeaturePath });
         
@@ -3559,6 +3677,7 @@ async function createComponentCommand(componentName, options) {
 async function removeComponentCommand(identifier, options) {
   try {
     const config = await loadConfig();
+    const configSignatures = Object.values(config.signatures || {});
 
     if (config.git?.requireCleanRepo && !await isRepoClean()) {
       throw new Error('Git repository is not clean. Please commit or stash your changes before proceeding.');
@@ -3588,7 +3707,8 @@ async function removeComponentCommand(identifier, options) {
       stateFiles: state.files,
       acceptChanges: options.acceptChanges,
       normalization: config.hashing?.normalization,
-      owner: identifier
+      owner: identifier,
+      signatures: configSignatures
     });
     
     if (result.deleted || (result.reason === 'not-found' && component)) {
@@ -3637,7 +3757,8 @@ async function listSectionsCommand() {
       console.log('  No pages directory found.');
     } else {
       const extensions = [config.naming.routeExtension, '.ts', '.js'];
-      const sections = await findGeneratedFiles(pagesRoot, extensions);
+      const signatures = Object.values(config.signatures || {});
+      const sections = await findGeneratedFiles(pagesRoot, extensions, signatures);
       
       if (sections.length === 0) {
         console.log('  No Textor-managed sections found.');
@@ -3741,7 +3862,7 @@ async function listSectionsCommand() {
   }
 }
 
-async function findGeneratedFiles(dir, extensions) {
+async function findGeneratedFiles(dir, extensions, signatures) {
   const results = [];
   const entries = await readdir(dir);
   const exts = Array.isArray(extensions) ? extensions : [extensions];
@@ -3751,9 +3872,9 @@ async function findGeneratedFiles(dir, extensions) {
     const stats = await stat(fullPath);
 
     if (stats.isDirectory()) {
-      results.push(...await findGeneratedFiles(fullPath, exts));
+      results.push(...await findGeneratedFiles(fullPath, exts, signatures));
     } else if (exts.some(ext => entry.endsWith(ext))) {
-      if (await isTextorGenerated(fullPath)) {
+      if (await isTextorGenerated(fullPath, signatures)) {
         results.push(fullPath);
       }
     }
@@ -3811,11 +3932,12 @@ async function validateStateCommand(options) {
     
     if (options.fix) {
       let fixedCount = 0;
+      const signatures = Object.values(config.signatures || {});
       
       // Fix modified files if they still have the Textor signature
       for (const mod of results.modified) {
         const fullPath = path.join(process.cwd(), mod.path);
-        if (await isTextorGenerated(fullPath)) {
+        if (await isTextorGenerated(fullPath, signatures)) {
           state.files[mod.path].hash = mod.newHash;
           fixedCount++;
         }

package/dist/bin/textor.js.map

@@ -1 +1 @@
-{"version":3,"file":"textor.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"textor.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}