@oamm/textor 1.0.13 → 1.0.14

package/README.md

@@ -209,6 +209,25 @@ pnpm textor rename component Header SiteHeader
 
 Use `--scan` to update imports across the entire project.
 
+### add
+Add a new sub-item (api, hook, test, etc.) to an existing feature or component. This command is additive and will not overwrite existing files unless `--force` is used.
+
+```bash
+# Add API to an existing feature
+pnpm textor add api auth/login
+
+# Add hooks to an existing component
+pnpm textor add hook Button
+
+# Add tests and readme to a feature
+pnpm textor add test auth/login
+pnpm textor add readme auth/login
+```
+
+Textor automatically detects if the target is a feature or a component based on its state.
+
+You can also use the original `add-section` or `create-component` commands with the same flags to add items; they now also support additive mode.
+
 ### remove-section / remove-component
 Safely remove Textor-managed modules.
 

package/dist/bin/textor.js

@@ -716,17 +716,6 @@ async function safeDelete(filePath, options = {}) {
   return { deleted: true };
 }
 
-async function ensureNotExists(filePath, force = false) {
-  if (existsSync(filePath)) {
-    if (!force) {
-      throw new Error(
-        `File already exists: ${filePath}\n` +
-        `Use --force to overwrite.`
-      );
-    }
-  }
-}
-
 async function ensureDir(dirPath) {
   await mkdir(dirPath, { recursive: true });
 }
@@ -2082,19 +2071,25 @@ async function addSectionCommand(route, featurePath, options) {
       }
     }
 
-    await ensureNotExists(featureFilePath, options.force);
-    
-    if (shouldCreateIndex) await ensureNotExists(indexFilePath, options.force);
-    if (shouldCreateContext) await ensureNotExists(contextFilePath, options.force);
-    if (shouldCreateHooks) await ensureNotExists(hookFilePath, options.force);
-    if (shouldCreateTests) await ensureNotExists(testFilePath, options.force);
-    if (shouldCreateTypes) await ensureNotExists(typesFilePath, options.force);
-    if (shouldCreateApi) await ensureNotExists(apiFilePath, options.force);
-    if (shouldCreateServices) await ensureNotExists(servicesFilePath, options.force);
-    if (shouldCreateSchemas) await ensureNotExists(schemasFilePath, options.force);
-    if (shouldCreateReadme) await ensureNotExists(readmeFilePath, options.force);
-    if (shouldCreateStories) await ensureNotExists(storiesFilePath, options.force);
-    if (shouldCreateScriptsDir) await ensureNotExists(scriptsIndexPath, options.force);
+    const featureExists = existsSync(featureFilePath);
+    if (featureExists && !options.force) {
+        console.log(`ℹ Feature already exists at ${featureFilePath}. Entering additive mode.`);
+    }
+
+    // Check sub-items only if not in force mode
+    if (!options.force) {
+        if (shouldCreateIndex && existsSync(indexFilePath)) console.log(`  - Skipping existing index: ${indexFilePath}`);
+        if (shouldCreateContext && existsSync(contextFilePath)) console.log(`  - Skipping existing context: ${contextFilePath}`);
+        if (shouldCreateHooks && existsSync(hookFilePath)) console.log(`  - Skipping existing hook: ${hookFilePath}`);
+        if (shouldCreateTests && existsSync(testFilePath)) console.log(`  - Skipping existing test: ${testFilePath}`);
+        if (shouldCreateTypes && existsSync(typesFilePath)) console.log(`  - Skipping existing types: ${typesFilePath}`);
+        if (shouldCreateApi && existsSync(apiFilePath)) console.log(`  - Skipping existing api: ${apiFilePath}`);
+        if (shouldCreateServices && existsSync(servicesFilePath)) console.log(`  - Skipping existing services: ${servicesFilePath}`);
+        if (shouldCreateSchemas && existsSync(schemasFilePath)) console.log(`  - Skipping existing schemas: ${schemasFilePath}`);
+        if (shouldCreateReadme && existsSync(readmeFilePath)) console.log(`  - Skipping existing readme: ${readmeFilePath}`);
+        if (shouldCreateStories && existsSync(storiesFilePath)) console.log(`  - Skipping existing stories: ${storiesFilePath}`);
+        if (shouldCreateScriptsDir && existsSync(scriptsIndexPath)) console.log(`  - Skipping existing scripts: ${scriptsIndexPath}`);
+    }
     
     let layoutImportPath = null;
     const cliProps = options.prop || {};
@@ -2235,21 +2230,23 @@ async function addSectionCommand(route, featurePath, options) {
 
     const featureSignature = getSignature(config, config.naming.featureExtension === '.astro' ? 'astro' : 'tsx');
 
-    const featureHash = await writeFileWithSignature(
-      featureFilePath,
-      featureContent,
-      featureSignature,
-      config.hashing?.normalization
-    );
-    await registerFile(featureFilePath, { 
-      kind: 'feature', 
-      template: 'feature', 
-      hash: featureHash,
-      owner: normalizedRoute 
-    });
-    writtenFiles.push(featureFilePath);
+    if (!featureExists || options.force) {
+      const featureHash = await writeFileWithSignature(
+        featureFilePath,
+        featureContent,
+        featureSignature,
+        config.hashing?.normalization
+      );
+      await registerFile(featureFilePath, { 
+        kind: 'feature', 
+        template: 'feature', 
+        hash: featureHash,
+        owner: normalizedRoute 
+      });
+      writtenFiles.push(featureFilePath);
+    }
 
-    if (shouldCreateScriptsDir) {
+    if (shouldCreateScriptsDir && (!existsSync(scriptsIndexPath) || options.force)) {
       const hash = await writeFileWithSignature(
         scriptsIndexPath,
         generateScriptsIndexTemplate(),
@@ -2265,7 +2262,7 @@ async function addSectionCommand(route, featurePath, options) {
       writtenFiles.push(scriptsIndexPath);
     }
 
-    if (shouldCreateIndex) {
+    if (shouldCreateIndex && (!existsSync(indexFilePath) || options.force)) {
       const indexContent = generateIndexTemplate(featureComponentName, config.naming.featureExtension);
       const hash = await writeFileWithSignature(
         indexFilePath,
@@ -2282,7 +2279,7 @@ async function addSectionCommand(route, featurePath, options) {
       writtenFiles.push(indexFilePath);
     }
 
-    if (shouldCreateApi) {
+    if (shouldCreateApi && (!existsSync(apiFilePath) || options.force)) {
       const apiContent = generateApiTemplate(featureComponentName);
       const hash = await writeFileWithSignature(
         apiFilePath, 
@@ -2299,7 +2296,7 @@ async function addSectionCommand(route, featurePath, options) {
       writtenFiles.push(apiFilePath);
     }
 
-    if (shouldCreateServices) {
+    if (shouldCreateServices && (!existsSync(servicesFilePath) || options.force)) {
       const servicesContent = generateServiceTemplate(featureComponentName);
       const hash = await writeFileWithSignature(
         servicesFilePath, 
@@ -2316,7 +2313,7 @@ async function addSectionCommand(route, featurePath, options) {
       writtenFiles.push(servicesFilePath);
     }
 
-    if (shouldCreateSchemas) {
+    if (shouldCreateSchemas && (!existsSync(schemasFilePath) || options.force)) {
       const schemasContent = generateSchemaTemplate(featureComponentName);
       const hash = await writeFileWithSignature(
         schemasFilePath, 
@@ -2333,7 +2330,7 @@ async function addSectionCommand(route, featurePath, options) {
       writtenFiles.push(schemasFilePath);
     }
 
-    if (shouldCreateHooks) {
+    if (shouldCreateHooks && (!existsSync(hookFilePath) || options.force)) {
       const hookName = getHookFunctionName(featureComponentName);
       const hookContent = generateHookTemplate(featureComponentName, hookName);
       const hash = await writeFileWithSignature(
@@ -2351,7 +2348,7 @@ async function addSectionCommand(route, featurePath, options) {
       writtenFiles.push(hookFilePath);
     }
 
-    if (shouldCreateContext) {
+    if (shouldCreateContext && (!existsSync(contextFilePath) || options.force)) {
       const contextContent = generateContextTemplate(featureComponentName);
       const hash = await writeFileWithSignature(
         contextFilePath, 
@@ -2368,7 +2365,7 @@ async function addSectionCommand(route, featurePath, options) {
       writtenFiles.push(contextFilePath);
     }
 
-    if (shouldCreateTests) {
+    if (shouldCreateTests && (!existsSync(testFilePath) || options.force)) {
       const relativeFeaturePath = `./${path.basename(featureFilePath)}`;
       const testContent = generateTestTemplate(featureComponentName, relativeFeaturePath);
       const hash = await writeFileWithSignature(
@@ -2386,7 +2383,7 @@ async function addSectionCommand(route, featurePath, options) {
       writtenFiles.push(testFilePath);
     }
 
-    if (shouldCreateTypes) {
+    if (shouldCreateTypes && (!existsSync(typesFilePath) || options.force)) {
       const typesContent = generateTypesTemplate(featureComponentName);
       const hash = await writeFileWithSignature(
         typesFilePath, 
@@ -2403,7 +2400,7 @@ async function addSectionCommand(route, featurePath, options) {
       writtenFiles.push(typesFilePath);
     }
 
-    if (shouldCreateReadme) {
+    if (shouldCreateReadme && (!existsSync(readmeFilePath) || options.force)) {
       const readmeContent = generateReadmeTemplate(featureComponentName);
       const hash = await writeFileWithSignature(
         readmeFilePath, 
@@ -2420,7 +2417,7 @@ async function addSectionCommand(route, featurePath, options) {
       writtenFiles.push(readmeFilePath);
     }
 
-    if (shouldCreateStories) {
+    if (shouldCreateStories && (!existsSync(storiesFilePath) || options.force)) {
       const relativePath = `./${path.basename(featureFilePath)}`;
       const storiesContent = generateStoriesTemplate(featureComponentName, relativePath);
       const hash = await writeFileWithSignature(
@@ -3437,20 +3434,26 @@ async function createComponentCommand(componentName, options) {
       return;
     }
     
-    await ensureNotExists(componentFilePath, options.force);
-    await ensureNotExists(indexFilePath, options.force);
-    
-    if (shouldCreateContext) await ensureNotExists(contextFilePath, options.force);
-    if (shouldCreateHook) await ensureNotExists(hookFilePath, options.force);
-    if (shouldCreateTests) await ensureNotExists(testFilePath, options.force);
-    if (shouldCreateConfig) await ensureNotExists(configFilePath, options.force);
-    if (shouldCreateConstants) await ensureNotExists(constantsFilePath, options.force);
-    if (shouldCreateTypes) await ensureNotExists(typesFilePath, options.force);
-    if (shouldCreateApi) await ensureNotExists(apiFilePath, options.force);
-    if (shouldCreateServices) await ensureNotExists(servicesFilePath, options.force);
-    if (shouldCreateSchemas) await ensureNotExists(schemasFilePath, options.force);
-    if (shouldCreateReadme) await ensureNotExists(readmeFilePath, options.force);
-    if (shouldCreateStories) await ensureNotExists(storiesFilePath, options.force);
+    const componentExists = existsSync(componentFilePath);
+    if (componentExists && !options.force) {
+        console.log(`ℹ Component already exists at ${componentFilePath}. Entering additive mode.`);
+    }
+
+    // Check sub-items only if not in force mode
+    if (!options.force) {
+        if (existsSync(indexFilePath)) console.log(`  - Skipping existing index: ${indexFilePath}`);
+        if (shouldCreateContext && existsSync(contextFilePath)) console.log(`  - Skipping existing context: ${contextFilePath}`);
+        if (shouldCreateHook && existsSync(hookFilePath)) console.log(`  - Skipping existing hook: ${hookFilePath}`);
+        if (shouldCreateTests && existsSync(testFilePath)) console.log(`  - Skipping existing test: ${testFilePath}`);
+        if (shouldCreateConfig && existsSync(configFilePath)) console.log(`  - Skipping existing config: ${configFilePath}`);
+        if (shouldCreateConstants && existsSync(constantsFilePath)) console.log(`  - Skipping existing constants: ${constantsFilePath}`);
+        if (shouldCreateTypes && existsSync(typesFilePath)) console.log(`  - Skipping existing types: ${typesFilePath}`);
+        if (shouldCreateApi && existsSync(apiFilePath)) console.log(`  - Skipping existing api: ${apiFilePath}`);
+        if (shouldCreateServices && existsSync(servicesFilePath)) console.log(`  - Skipping existing services: ${servicesFilePath}`);
+        if (shouldCreateSchemas && existsSync(schemasFilePath)) console.log(`  - Skipping existing schemas: ${schemasFilePath}`);
+        if (shouldCreateReadme && existsSync(readmeFilePath)) console.log(`  - Skipping existing readme: ${readmeFilePath}`);
+        if (shouldCreateStories && existsSync(storiesFilePath)) console.log(`  - Skipping existing stories: ${storiesFilePath}`);
+    }
     
     await ensureDir(componentDir);
     
@@ -3468,37 +3471,42 @@ async function createComponentCommand(componentName, options) {
     const componentContent = generateComponentTemplate(normalizedName, framework, config.naming.componentExtension);
     const signature = getSignature(config, config.naming.componentExtension === '.astro' ? 'astro' : 'tsx');
 
-    const componentHash = await writeFileWithSignature(
-      componentFilePath,
-      componentContent,
-      signature,
-      config.hashing?.normalization
-    );
-    await registerFile(componentFilePath, { 
-      kind: 'component', 
-      template: 'component', 
-      hash: componentHash,
-      owner: normalizedName 
-    });
+    const writtenFiles = [];
+
+    if (!componentExists || options.force) {
+      const componentHash = await writeFileWithSignature(
+        componentFilePath,
+        componentContent,
+        signature,
+        config.hashing?.normalization
+      );
+      await registerFile(componentFilePath, { 
+        kind: 'component', 
+        template: 'component', 
+        hash: componentHash,
+        owner: normalizedName 
+      });
+      writtenFiles.push(componentFilePath);
+    }
     
-    const writtenFiles = [componentFilePath];
-
-    const indexContent = generateIndexTemplate(normalizedName, config.naming.componentExtension);
-    const indexHash = await writeFileWithSignature(
-      indexFilePath,
-      indexContent,
-      getSignature(config, 'typescript'),
-      config.hashing?.normalization
-    );
-    await registerFile(indexFilePath, { 
-      kind: 'component-file', 
-      template: 'index', 
-      hash: indexHash,
-      owner: normalizedName 
-    });
-    writtenFiles.push(indexFilePath);
+    if (!existsSync(indexFilePath) || options.force) {
+      const indexContent = generateIndexTemplate(normalizedName, config.naming.componentExtension);
+      const indexHash = await writeFileWithSignature(
+        indexFilePath,
+        indexContent,
+        getSignature(config, 'typescript'),
+        config.hashing?.normalization
+      );
+      await registerFile(indexFilePath, { 
+        kind: 'component-file', 
+        template: 'index', 
+        hash: indexHash,
+        owner: normalizedName 
+      });
+      writtenFiles.push(indexFilePath);
+    }
     
-    if (shouldCreateTypes) {
+    if (shouldCreateTypes && (!existsSync(typesFilePath) || options.force)) {
       const typesContent = generateTypesTemplate(normalizedName);
       const hash = await writeFileWithSignature(
         typesFilePath,
@@ -3515,7 +3523,7 @@ async function createComponentCommand(componentName, options) {
       writtenFiles.push(typesFilePath);
     }
     
-    if (shouldCreateContext) {
+    if (shouldCreateContext && (!existsSync(contextFilePath) || options.force)) {
       const contextContent = generateContextTemplate(normalizedName);
       const hash = await writeFileWithSignature(
         contextFilePath,
@@ -3532,7 +3540,7 @@ async function createComponentCommand(componentName, options) {
       writtenFiles.push(contextFilePath);
     }
     
-    if (shouldCreateHook) {
+    if (shouldCreateHook && (!existsSync(hookFilePath) || options.force)) {
       const hookName = getHookFunctionName(normalizedName);
       const hookContent = generateHookTemplate(normalizedName, hookName);
       const hash = await writeFileWithSignature(
@@ -3550,7 +3558,7 @@ async function createComponentCommand(componentName, options) {
       writtenFiles.push(hookFilePath);
     }
     
-    if (shouldCreateTests) {
+    if (shouldCreateTests && (!existsSync(testFilePath) || options.force)) {
       const relativeComponentPath = `../${normalizedName}${config.naming.componentExtension}`;
       const testContent = generateTestTemplate(normalizedName, relativeComponentPath);
       const hash = await writeFileWithSignature(
@@ -3568,7 +3576,7 @@ async function createComponentCommand(componentName, options) {
       writtenFiles.push(testFilePath);
     }
     
-    if (shouldCreateConfig) {
+    if (shouldCreateConfig && (!existsSync(configFilePath) || options.force)) {
       const configContent = generateConfigTemplate(normalizedName);
       const hash = await writeFileWithSignature(
         configFilePath,
@@ -3585,7 +3593,7 @@ async function createComponentCommand(componentName, options) {
       writtenFiles.push(configFilePath);
     }
     
-    if (shouldCreateConstants) {
+    if (shouldCreateConstants && (!existsSync(constantsFilePath) || options.force)) {
       const constantsContent = generateConstantsTemplate(normalizedName);
       const hash = await writeFileWithSignature(
         constantsFilePath,
@@ -3602,7 +3610,7 @@ async function createComponentCommand(componentName, options) {
       writtenFiles.push(constantsFilePath);
     }
 
-    if (shouldCreateApi) {
+    if (shouldCreateApi && (!existsSync(apiFilePath) || options.force)) {
       const apiContent = generateApiTemplate(normalizedName);
       const hash = await writeFileWithSignature(
         apiFilePath,
@@ -3619,7 +3627,7 @@ async function createComponentCommand(componentName, options) {
       writtenFiles.push(apiFilePath);
     }
 
-    if (shouldCreateServices) {
+    if (shouldCreateServices && (!existsSync(servicesFilePath) || options.force)) {
       const servicesContent = generateServiceTemplate(normalizedName);
       const hash = await writeFileWithSignature(
         servicesFilePath,
@@ -3636,7 +3644,7 @@ async function createComponentCommand(componentName, options) {
       writtenFiles.push(servicesFilePath);
     }
 
-    if (shouldCreateSchemas) {
+    if (shouldCreateSchemas && (!existsSync(schemasFilePath) || options.force)) {
       const schemasContent = generateSchemaTemplate(normalizedName);
       const hash = await writeFileWithSignature(
         schemasFilePath,
@@ -3653,7 +3661,7 @@ async function createComponentCommand(componentName, options) {
       writtenFiles.push(schemasFilePath);
     }
 
-    if (shouldCreateReadme) {
+    if (shouldCreateReadme && (!existsSync(readmeFilePath) || options.force)) {
       const readmeContent = generateReadmeTemplate(normalizedName);
       const hash = await writeFileWithSignature(
         readmeFilePath,
@@ -3670,7 +3678,7 @@ async function createComponentCommand(componentName, options) {
       writtenFiles.push(readmeFilePath);
     }
 
-    if (shouldCreateStories) {
+    if (shouldCreateStories && (!existsSync(storiesFilePath) || options.force)) {
       const relativePath = `./${normalizedName}${config.naming.componentExtension}`;
       const storiesContent = generateStoriesTemplate(normalizedName, relativePath);
       const hash = await writeFileWithSignature(
@@ -4601,6 +4609,61 @@ async function pruneMissingCommand(options = {}) {
   }
 }
 
+/**
+ * Add a new item (hook, api, service, etc.) to an existing feature or component.
+ * 
+ * @param {string} itemType The type of item to add (e.g., 'api', 'hook', 'service')
+ * @param {string} targetName The name of the feature or component
+ * @param {Object} options Additional options from Commander
+ */
+async function addItemCommand(itemType, targetName, options) {
+  try {
+    const state = await loadState();
+    
+    // Normalize itemType
+    let normalizedItem = itemType.toLowerCase();
+    if (normalizedItem === 'test') normalizedItem = 'tests';
+    if (normalizedItem === 'service') normalizedItem = 'services';
+    if (normalizedItem === 'schema') normalizedItem = 'schemas';
+    if (normalizedItem === 'hook') normalizedItem = 'hooks'; // for add-section
+
+    // Try to find as section (feature) first
+    let section = findSection(state, targetName);
+    let component = findComponent(state, targetName);
+    
+    // If not found by exact name, try to find by featurePath or part of it
+    if (!section && !component) {
+        section = state.sections.find(s => s.featurePath === targetName || s.featurePath.endsWith('/' + targetName));
+    }
+
+    if (!section && !component) {
+      throw new Error(`Target not found in state: "${targetName}". Please use "add-section" or "create-component" directly if it's not managed by Textor.`);
+    }
+
+    const flags = { [normalizedItem]: true };
+    // Also set singular for create-component which uses 'hook'
+    if (normalizedItem === 'hooks') flags.hook = true;
+
+    if (section) {
+      console.log(`ℹ Adding ${normalizedItem} to feature: ${section.featurePath}`);
+      return await addSectionCommand(undefined, section.featurePath, { ...options, ...flags });
+    }
+    
+    if (component) {
+      console.log(`ℹ Adding ${normalizedItem} to component: ${component.name}`);
+      // For create-component, we might need to be careful with flags that are on by default
+      // but getEffectiveOptions should handle it if we pass them explicitly as true.
+      return await createComponentCommand(component.name, { ...options, ...flags });
+    }
+  } catch (error) {
+    console.error('Error:', error.message);
+    if (typeof process.exit === 'function' && process.env.NODE_ENV !== 'test') {
+      process.exit(1);
+    }
+    throw error;
+  }
+}
+
 /**
  * Dispatcher for rename commands.
  */
@@ -4860,5 +4923,12 @@ program
   .option('--dry-run', 'Show what would be renamed without applying')
   .action(renameCommand);
 
+program
+  .command('add <item> <target>')
+  .description('Add a sub-item (api, hook, test, etc.) to an existing feature or component')
+  .option('--force', 'Overwrite existing files')
+  .option('--dry-run', 'Show what would be created without creating')
+  .action(addItemCommand);
+
 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}