Remove the module from composer.
553715
private function uninstallFromComposer()
    {
        $uninstallCommand = 'composer remove typicms/'.$this->module;
        if (function_exists('system')) {
            system($uninstallCommand);
        } else {
            $this->line('You can now run '.$uninstallCommand.'.');
        }
    }
943181
public function unregisterModule($name)
    {
        if (array_key_exists($name, $this->modules)) {
            unset($this->modules[$name]);
            return true;
        }
        return false;
    }
988731
protected static function removeNodeModules()
    {
        tap(new Filesystem, function ($files) {
            $files->deleteDirectory(base_path('node_modules'));

            $files->delete(base_path('yarn.lock'));
        });
    }
162890
protected function uninstall()
    {
        $uninstallScripts = array();
        if (!empty($this->installedBundles)) {
            foreach ($this->installedBundles as $autoloader) {
                $bundleName = $autoloader->getBundleName();
                $uninstallScripts[$bundleName] = $autoloader->getActionManagerClass();
                $this->filesystem->remove($this->autoloadersPath . '/' . $bundleName . '.json');
                $this->filesystem->remove($this->configPath);
                $this->filesystem->remove($this->routingPath);
            }
        }

        $this->requireCachedClasses();
        $uninstallerScript = $this->scriptFactory->createScript('PreBootUninstaller');
        $uninstallerScript->executeActions($uninstallScripts);
    }
782172
public function removeStale()
    {
        /** @var \Illuminate\Database\Eloquent\Builder $query */
        $query = $this->importer->getModelInstance()
            ->where('updated_at', '<', $this->now)
            ->orWhereNull('updated_at');

        $this->deleted = $query->count();

        $query->delete();
    }
1210350
function() {
		
		// Remove all previous module with the ComposedModule class
		var el = YAHOO.util.Dom.get("module-category-Composed");
		if( el ) {
			// Purge element (remove listeners on el and childNodes recursively)
	      YAHOO.util.Event.purgeElement(el, true);
			el.innerHTML = "";
		}
		
		
		if(YAHOO.lang.isArray(this.pipes)) {
	       for(var i = 0 ; i < this.pipes.length ; i++) {
	          var module = this.pipes[i];
	
				 var m = {
					name: module.name,
					category: this.composedCategory,
					container: {
		            "xtype": "WireIt.ComposedContainer",
		            "title": module.name,
				  		"wiring": this.pipes[i]
		         }
				 };
				 YAHOO.lang.augmentObject(m, this.pipes[i]);
				
				 this.modulesByName[module.name] = m;
					
				 this.addModuleToList(m);
			}
		}
		
	}
509107
def unload_module(self, path):
        '''

        '''
        with self._mutex:
            if self._obj.unload_module(path) != RTC.RTC_OK:
                raise FailedToUnloadModuleError(path)
116506
def uninstall(self):
        """"""
        if self.is_installed():
            installed = self.installed_dir()
            if installed.is_symlink():
                installed.unlink()
            else:
                shutil.rmtree(str(installed))
312547
def remove(self):
        ""
        if not self.removed:
            self.hook.remove()
            self.removed=True
944298
@Override
    public void unregister(Module module) {
        if (module == null) {
            // May happen on departure.
            return;
        }
        LOGGER.info("Removing Jackson module {}", module.getModuleName());
        synchronized (lock) {
            if (modules.remove(module)) {
                rebuildMappers();
            }
        }
    }
1143174
public function removeModule($module)
    {
        if ($module instanceof ModuleInterface) {
            if (!in_array($module, $this->modules)) {
                throw new \InvalidArgumentException(
                    'This occurrence of '.get_class($module).' is not registered.'
                );
            }

            $this->modules = array_filter($this->modules, function ($instance) use ($module) {
                return $instance !== $module;
            });

            return $this;
        }

        /** @var string $className */
        $className = $module;

        if (!$this->hasModule($className)) {
            throw new \InvalidArgumentException(
                'The container doesn\'t contain a '.$className.' module'
            );
        }

        $this->modules[$className]->detachEvents();
        unset($this->modules[$className]);

        return $this;
    }
19990
private static function clearCompiled(): void
    {
        $laravel = new Application(getcwd());

        if (\file_exists($servicesPath = $laravel->getCachedServicesPath())) {
            @\unlink($servicesPath);
        }

        if (\file_exists($packagesPath = $laravel->getCachedPackagesPath())) {
            @\unlink($packagesPath);
        }

        if (\file_exists($extensionServicesPath = $laravel->getCachedExtensionServicesPath())) {
            @\unlink($extensionServicesPath);
        }
    }
561965
public function uninstall()
    {
        $manager = new Manager($this->app);
        $categories = $manager->getPackageItemCategories();
        $package = $this->getPackageEntity();
        foreach ($categories as $category) {
            if ($category->hasItems($package)) {
                $category->removeItems($package);
            }
        }

        $this->app->make('config')->clearNamespace($this->getPackageHandle());
        $this->app->make('config/database')->clearNamespace($this->getPackageHandle());

        $em = $this->getPackageEntityManager();
        if ($em !== null) {
            $this->destroyProxyClasses($em);
        }

        $em = $this->app->make(EntityManagerInterface::class);
        $em->remove($package);
        $em->flush();

        Localization::clearCache();
    }
588093
def uninstall(self):
        '''
        
        '''

        if self.installed:
            sys.meta_path.remove(self)

        # Reload all decorated items
        import_list = []
        for name in self.__loaded_modules:
            del sys.modules[name]
            import_list.append(name)

        for name in import_list:
            __import__(name)

        self.__reset()
753518
public function remove()
    {

        $origin = $destination = \Devil::getPathOf($this->config['dest']);
        if (isset($this->config['onload'])) {
            $destination .= '/origin';
        }
        $realFileName = $destination . '/' . $this->_primaryKey . '_' . $this->existing;
        if (file_exists($realFileName)) unlink($realFileName);

        if (isset($this->config['onload'])) foreach ($this->config['onload'] as $method=>$config) {
            $methodRemove = $method . 'Remove';
            $this->$methodRemove($origin, $this->_primaryKey . '_' . $this->existing, $config);
        }
    }
216307
function() {
        $module
          .data(metadata.promise, false)
          .data(metadata.xhr, false)
        ;
        $context
          .removeClass(className.error)
          .removeClass(className.loading)
        ;
      }
1228231
public function remove()
    {
        $f = json_decode(file_get_contents(FEnv::get("framework.root").
            "elements/config_files/core/apps.json"));
        foreach ($f as $one => $val) {
            if ($val->name == $this->name) {
                unset($f->$one);
                break;
            }
        }

        $f = json_encode($f, JSON_PRETTY_PRINT);
        file_put_contents(FEnv::get("framework.root")."elements/config_files/core/apps.json", $f);

        Server::delete(FEnv::get("framework.root")."apps/".$this->name, "directory");
        Server::delete(
            FEnv::get("framework.root")."public/components/apps/".strtolower($this->name),
            'directory'
        );
    }