@oamm/textor 1.0.8 → 1.0.10

package/README.md

@@ -279,6 +279,20 @@ pnpm textor normalize-state
 **Options:**
 - `--dry-run`: Print the normalized state without writing it.
 
+### prune-missing
+Remove missing references from Textor state. This command identifies files that are tracked in the state but are no longer present on disk and removes them from `.textor/state.json`. 
+
+**Safe-by-default**: This command never deletes any files from your disk; it only updates the state tracker.
+
+```bash
+pnpm textor prune-missing
+```
+
+**Options:**
+- `--dry-run`: Preview what would be removed from the state without making changes.
+- `--yes`: Skip confirmation prompt.
+- `--no-interactive`: Disable interactive prompts (useful for CI).
+
 ## 🏗️ Technical Architecture
 
 Textor is designed with enterprise-grade robustness, moving beyond simple scaffolding to provide a reliable refactoring engine.

package/dist/bin/textor.js

@@ -6,6 +6,7 @@ import path from 'path';
 import { createHash } from 'crypto';
 import { exec } from 'child_process';
 import { promisify } from 'util';
+import readline from 'readline';
 
 const CONFIG_DIR$1 = '.textor';
 const CONFIG_FILE = 'config.json';
@@ -1135,6 +1136,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
@@ -1560,9 +1623,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);
   }
@@ -1640,6 +1703,10 @@ function reconstructComponents(files, config) {
             path: componentPath
           });
         }
+        // Attribute ownership
+        if (!files[filePath].owner) {
+          files[filePath].owner = componentName;
+        }
       }
     }
   }
@@ -1683,28 +1750,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;
+             }
            }
         }
       }
@@ -1985,7 +2058,15 @@ async function addSectionCommand(route, featurePath, options) {
       await saveState(state);
     }
 
-    if (routeFilePath) await ensureNotExists(routeFilePath, options.force);
+    if (routeFilePath) {
+      if (existsSync(routeFilePath)) {
+        const isGenerated = await isTextorGenerated(routeFilePath);
+        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);
@@ -2067,15 +2148,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
+          );
+        }
       }
     }
     
@@ -3844,67 +3952,87 @@ async function validateStateCommand(options) {
   }
 }
 
-async function statusCommand() {
-  try {
-    const config = await loadConfig();
-    const state = await loadState();
-    
-    const results = {
-      missing: [],
-      modified: [],
-      untracked: [], // Has signature, not in state
-      orphaned: [],  // No signature, not in state
-      synced: 0
-    };
+/**
+ * Computes the drift between the state and the actual files on disk.
+ * 
+ * @param {import('./config.js').TextorConfig} config 
+ * @param {Object} state 
+ * @returns {Promise<{
+ *   missing: string[],
+ *   modified: string[],
+ *   untracked: string[],
+ *   orphaned: string[],
+ *   synced: number
+ * }>}
+ */
+async function getProjectStatus(config, state) {
+  const results = {
+    missing: [],
+    modified: [],
+    untracked: [], // Has signature, not in state
+    orphaned: [],  // No signature, not in state
+    synced: 0
+  };
 
-    const roots = [
-      resolvePath(config, 'pages'),
-      resolvePath(config, 'features'),
-      resolvePath(config, 'components')
-    ].map(p => path.resolve(p));
+  const roots = [
+    resolvePath(config, 'pages'),
+    resolvePath(config, 'features'),
+    resolvePath(config, 'components')
+  ].map(p => path.resolve(p));
 
-    const diskFiles = new Set();
-    const configSignatures = Object.values(config.signatures || {});
+  const diskFiles = new Set();
+  const configSignatures = Object.values(config.signatures || {});
 
-    for (const root of roots) {
-      if (existsSync(root)) {
-        await scanDirectory(root, diskFiles);
-      }
+  for (const root of roots) {
+    if (existsSync(root)) {
+      await scanDirectory(root, diskFiles);
     }
+  }
 
-    // 1. Check state files against disk
-    for (const relativePath in state.files) {
-      const fullPath = path.join(process.cwd(), relativePath);
-      
-      if (!existsSync(fullPath)) {
-        results.missing.push(relativePath);
-        continue;
-      }
+  // 1. Check state files against disk
+  for (const relativePath in state.files) {
+    const fullPath = path.join(process.cwd(), relativePath);
+    
+    if (!existsSync(fullPath)) {
+      results.missing.push(relativePath);
+      continue;
+    }
 
-      diskFiles.delete(relativePath);
+    // It exists on disk, so it's not untracked/orphaned
+    diskFiles.delete(relativePath);
 
-      const content = await readFile(fullPath, 'utf-8');
-      const currentHash = calculateHash(content, config.hashing?.normalization);
-      const fileData = state.files[relativePath];
+    const content = await readFile(fullPath, 'utf-8');
+    const currentHash = calculateHash(content, config.hashing?.normalization);
+    const fileData = state.files[relativePath];
 
-      if (currentHash !== fileData.hash) {
-        results.modified.push(relativePath);
-      } else {
-        results.synced++;
-      }
+    if (currentHash !== fileData.hash) {
+      results.modified.push(relativePath);
+    } else {
+      results.synced++;
     }
+  }
 
-    // 2. Check remaining disk files
-    for (const relativePath of diskFiles) {
-      const fullPath = path.join(process.cwd(), relativePath);
-      const isGenerated = await isTextorGenerated(fullPath, configSignatures);
-      
-      if (isGenerated) {
-        results.untracked.push(relativePath);
-      } else {
-        results.orphaned.push(relativePath);
-      }
+  // 2. Check remaining disk files
+  for (const relativePath of diskFiles) {
+    const fullPath = path.join(process.cwd(), relativePath);
+    const isGenerated = await isTextorGenerated(fullPath, configSignatures);
+    
+    if (isGenerated) {
+      results.untracked.push(relativePath);
+    } else {
+      results.orphaned.push(relativePath);
     }
+  }
+
+  return results;
+}
+
+async function statusCommand() {
+  try {
+    const config = await loadConfig();
+    const state = await loadState();
+    
+    const results = await getProjectStatus(config, state);
 
     // Reporting
     console.log('Textor Status Report:');
@@ -4329,6 +4457,71 @@ async function normalizeStateCommand(options) {
   }
 }
 
+/**
+ * Removes missing references from Textor state.
+ * @param {Object} options 
+ * @param {boolean} options.dryRun 
+ * @param {boolean} options.yes 
+ */
+async function pruneMissingCommand(options = {}) {
+  try {
+    const config = await loadConfig();
+    const state = await loadState();
+    
+    const results = await getProjectStatus(config, state);
+    
+    if (results.missing.length === 0) {
+      console.log('No missing references found.');
+      return;
+    }
+
+    console.log(`Found ${results.missing.length} missing references:`);
+    results.missing.forEach(f => console.log(`  - ${f}`));
+
+    if (options.dryRun) {
+      console.log('\nDry run: no changes applied to state.');
+      return;
+    }
+
+    if (!options.yes && options.interactive !== false && process.stdin.isTTY && process.env.NODE_ENV !== 'test') {
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+
+      const confirmed = await new Promise(resolve => {
+        rl.question('\nDo you want to proceed with pruning? (y/N) ', (answer) => {
+          rl.close();
+          resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+        });
+      });
+
+      if (!confirmed) {
+        console.log('Aborted.');
+        return;
+      }
+    }
+
+    for (const relPath of results.missing) {
+      delete state.files[relPath];
+    }
+
+    // Reconstruct metadata
+    state.components = reconstructComponents(state.files, config);
+    state.sections = reconstructSections(state, config);
+
+    await saveState(state);
+    console.log(`\n✓ Successfully removed ${results.missing.length} missing references from state.`);
+
+  } catch (error) {
+    console.error('Error:', error.message);
+    if (typeof process.exit === 'function' && process.env.NODE_ENV !== 'test') {
+      process.exit(1);
+    }
+    throw error;
+  }
+}
+
 const program = new Command();
 
 program
@@ -4466,5 +4659,13 @@ program
   .option('--dry-run', 'Show the normalized state without writing to disk')
   .action(normalizeStateCommand);
 
+program
+  .command('prune-missing')
+  .description('Remove missing files from state (files that are in state but not on disk)')
+  .option('--dry-run', 'Show what would be removed without applying')
+  .option('--yes', 'Skip confirmation')
+  .option('--no-interactive', 'Disable interactive prompts')
+  .action(pruneMissingCommand);
+
 program.parse();
 //# sourceMappingURL=textor.js.map

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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}