ensureSpecLoadedV2 function
Load the spec for command if not already loaded, and register it. Call before getSpec(command) when using v2.
Implementation
Future<void> ensureSpecLoadedV2(String command) async {
if (hasSpec(command)) return;
switch (command) {
case '-':
await spec_p_.loadLibrary();
registerSpec(spec_p_.specSpec.name, () => spec_p_.specSpec);
break;
case '@commercelayer/cli':
await spec_commercelayer.loadLibrary();
registerSpec(spec_commercelayer.commercelayerCliSpec.name,
() => spec_commercelayer.commercelayerCliSpec);
break;
case '@fig/publish-spec':
await spec_fig_publish_spec.loadLibrary();
registerSpec(spec_fig_publish_spec.figPublishSpecSpec.name,
() => spec_fig_publish_spec.figPublishSpecSpec);
break;
case '@forge/cli':
await spec_forge.loadLibrary();
registerSpec(spec_forge.forgeCliSpec.name, () => spec_forge.forgeCliSpec);
break;
case '@withfig/autocomplete-tools':
await spec_withfig_autocomplete_tools.loadLibrary();
registerSpec(
spec_withfig_autocomplete_tools.withfigAutocompleteToolsSpec.name,
() => spec_withfig_autocomplete_tools.withfigAutocompleteToolsSpec);
break;
case '@wordpress/create-block':
await spec_wordpress_create_block.loadLibrary();
registerSpec(spec_wordpress_create_block.wordpressCreateBlockSpec.name,
() => spec_wordpress_create_block.wordpressCreateBlockSpec);
break;
case 'Rscript':
await spec_rscript.loadLibrary();
registerSpec(
spec_rscript.RscriptSpec.name, () => spec_rscript.RscriptSpec);
break;
case 'act':
await spec_act.loadLibrary();
registerSpec(spec_act.actSpec.name, () => spec_act.actSpec);
break;
case 'adb':
await spec_adb.loadLibrary();
registerSpec(spec_adb.adbSpec.name, () => spec_adb.adbSpec);
break;
case 'adr':
await spec_adr.loadLibrary();
registerSpec(spec_adr.adrSpec.name, () => spec_adr.adrSpec);
break;
case 'afplay':
await spec_afplay.loadLibrary();
registerSpec(spec_afplay.afplaySpec.name, () => spec_afplay.afplaySpec);
break;
case 'aftman':
await spec_aftman.loadLibrary();
registerSpec(spec_aftman.aftmanSpec.name, () => spec_aftman.aftmanSpec);
break;
case 'ag':
await spec_ag.loadLibrary();
registerSpec(spec_ag.agSpec.name, () => spec_ag.agSpec);
break;
case 'agrippa':
await spec_agrippa.loadLibrary();
registerSpec(
spec_agrippa.agrippaSpec.name, () => spec_agrippa.agrippaSpec);
break;
case 'airflow':
await spec_airflow.loadLibrary();
registerSpec(
spec_airflow.airflowSpec.name, () => spec_airflow.airflowSpec);
break;
case 'aliases':
await spec_aliases.loadLibrary();
registerSpec(
spec_aliases.aliasesSpec.name, () => spec_aliases.aliasesSpec);
break;
case 'ampx':
await spec_ampx.loadLibrary();
registerSpec(spec_ampx.ampxSpec.name, () => spec_ampx.ampxSpec);
break;
case 'ansible':
await spec_ansible.loadLibrary();
registerSpec(
spec_ansible.ansibleSpec.name, () => spec_ansible.ansibleSpec);
break;
case 'ansible-config':
await spec_ansible_config.loadLibrary();
registerSpec(spec_ansible_config.ansibleConfigSpec.name,
() => spec_ansible_config.ansibleConfigSpec);
break;
case 'ansible-galaxy':
await spec_ansible_galaxy.loadLibrary();
registerSpec(spec_ansible_galaxy.ansibleGalaxySpec.name,
() => spec_ansible_galaxy.ansibleGalaxySpec);
break;
case 'ansible-lint':
await spec_ansible_lint.loadLibrary();
registerSpec(spec_ansible_lint.ansibleLintSpec.name,
() => spec_ansible_lint.ansibleLintSpec);
break;
case 'ansible-playbook':
await spec_ansible_playbook.loadLibrary();
registerSpec(spec_ansible_playbook.ansiblePlaybookSpec.name,
() => spec_ansible_playbook.ansiblePlaybookSpec);
break;
case 'apt':
await spec_apt.loadLibrary();
registerSpec(spec_apt.aptSpec.name, () => spec_apt.aptSpec);
break;
case 'arch':
await spec_arch.loadLibrary();
registerSpec(spec_arch.archSpec.name, () => spec_arch.archSpec);
break;
case 'argo':
await spec_argo.loadLibrary();
registerSpec(spec_argo.argoSpec.name, () => spec_argo.argoSpec);
break;
case 'artisan':
await spec_php_artisan.loadLibrary();
registerSpec(spec_php_artisan.completionSpec.name,
() => spec_php_artisan.completionSpec);
break;
case 'asar':
await spec_asar.loadLibrary();
registerSpec(spec_asar.asarSpec.name, () => spec_asar.asarSpec);
break;
case 'asciinema':
await spec_asciinema.loadLibrary();
registerSpec(spec_asciinema.asciinemaSpec.name,
() => spec_asciinema.asciinemaSpec);
break;
case 'asr':
await spec_asr.loadLibrary();
registerSpec(spec_asr.asrSpec.name, () => spec_asr.asrSpec);
break;
case 'astro':
await spec_astro.loadLibrary();
registerSpec(spec_astro.astroSpec.name, () => spec_astro.astroSpec);
break;
case 'atlas':
await spec_atlas.loadLibrary();
registerSpec(spec_atlas.atlasSpec.name, () => spec_atlas.atlasSpec);
break;
case 'authchanger':
await spec_authchanger.loadLibrary();
registerSpec(spec_authchanger.authchangerSpec.name,
() => spec_authchanger.authchangerSpec);
break;
case 'autocannon':
await spec_autocannon.loadLibrary();
registerSpec(spec_autocannon.autocannonSpec.name,
() => spec_autocannon.autocannonSpec);
break;
case 'autojump':
await spec_autojump.loadLibrary();
registerSpec(
spec_autojump.autojumpSpec.name, () => spec_autojump.autojumpSpec);
break;
case 'aws':
await spec_aws.loadLibrary();
registerSpec(spec_aws.awsSpec.name, () => spec_aws.awsSpec);
break;
case 'aws-vault':
await spec_aws_vault.loadLibrary();
registerSpec(
spec_aws_vault.awsVaultSpec.name, () => spec_aws_vault.awsVaultSpec);
break;
case 'awsume':
await spec_awsume.loadLibrary();
registerSpec(spec_awsume.awsumeSpec.name, () => spec_awsume.awsumeSpec);
break;
case 'az':
await spec_az.loadLibrary();
registerSpec(spec_az.azSpec.name, () => spec_az.azSpec);
break;
case 'babel':
await spec_babel.loadLibrary();
registerSpec(spec_babel.babelSpec.name, () => spec_babel.babelSpec);
break;
case 'banner':
await spec_banner.loadLibrary();
registerSpec(spec_banner.bannerSpec.name, () => spec_banner.bannerSpec);
break;
case 'barnard59':
await spec_barnard59.loadLibrary();
registerSpec(spec_barnard59.barnard59Spec.name,
() => spec_barnard59.barnard59Spec);
break;
case 'base32':
await spec_base32.loadLibrary();
registerSpec(spec_base32.base32Spec.name, () => spec_base32.base32Spec);
break;
case 'base64':
await spec_base64.loadLibrary();
registerSpec(spec_base64.base64Spec.name, () => spec_base64.base64Spec);
break;
case 'basename':
await spec_basename.loadLibrary();
registerSpec(
spec_basename.basenameSpec.name, () => spec_basename.basenameSpec);
break;
case 'basenc':
await spec_basenc.loadLibrary();
registerSpec(spec_basenc.basencSpec.name, () => spec_basenc.basencSpec);
break;
case 'bat':
await spec_bat.loadLibrary();
registerSpec(spec_bat.batSpec.name, () => spec_bat.batSpec);
break;
case 'bazel':
await spec_bazel.loadLibrary();
registerSpec(spec_bazel.bazelSpec.name, () => spec_bazel.bazelSpec);
break;
case 'bc':
await spec_bc.loadLibrary();
registerSpec(spec_bc.bcSpec.name, () => spec_bc.bcSpec);
break;
case 'bcd':
await spec_bcd.loadLibrary();
registerSpec(spec_bcd.bcdSpec.name, () => spec_bcd.bcdSpec);
break;
case 'bin-console':
await spec_php_bin_console.loadLibrary();
registerSpec(spec_php_bin_console.completionSpec.name,
() => spec_php_bin_console.completionSpec);
break;
case 'bit':
await spec_bit.loadLibrary();
registerSpec(spec_bit.bitSpec.name, () => spec_bit.bitSpec);
break;
case 'blitz':
await spec_blitz.loadLibrary();
registerSpec(spec_blitz.blitzSpec.name, () => spec_blitz.blitzSpec);
break;
case 'br':
await spec_br.loadLibrary();
registerSpec(spec_br.brSpec.name, () => spec_br.brSpec);
break;
case 'brew':
await spec_brew.loadLibrary();
registerSpec(spec_brew.brewSpec.name, () => spec_brew.brewSpec);
break;
case 'broot':
await spec_broot.loadLibrary();
registerSpec(spec_broot.brootSpec.name, () => spec_broot.brootSpec);
break;
case 'browser-sync':
await spec_browser_sync.loadLibrary();
registerSpec(spec_browser_sync.browserSyncSpec.name,
() => spec_browser_sync.browserSyncSpec);
break;
case 'btop':
await spec_btop.loadLibrary();
registerSpec(spec_btop.btopSpec.name, () => spec_btop.btopSpec);
break;
case 'build':
await spec_dotnet_dotnet_build.loadLibrary();
registerSpec(spec_dotnet_dotnet_build.buildSpec.name,
() => spec_dotnet_dotnet_build.buildSpec);
break;
case 'build-server':
await spec_dotnet_dotnet_build_server.loadLibrary();
registerSpec(spec_dotnet_dotnet_build_server.buildServerSpec.name,
() => spec_dotnet_dotnet_build_server.buildServerSpec);
break;
case 'build-storybook':
await spec_build_storybook.loadLibrary();
registerSpec(spec_build_storybook.buildStorybookSpec.name,
() => spec_build_storybook.buildStorybookSpec);
break;
case 'bun':
await spec_bun.loadLibrary();
registerSpec(spec_bun.bunSpec.name, () => spec_bun.bunSpec);
break;
case 'bundle':
await spec_bundle.loadLibrary();
registerSpec(spec_bundle.bundleSpec.name, () => spec_bundle.bundleSpec);
break;
case 'bunx':
await spec_bunx.loadLibrary();
registerSpec(spec_bunx.bunxSpec.name, () => spec_bunx.bunxSpec);
break;
case 'bw':
await spec_bw.loadLibrary();
registerSpec(spec_bw.bwSpec.name, () => spec_bw.bwSpec);
break;
case 'bwdc':
await spec_bwdc.loadLibrary();
registerSpec(spec_bwdc.bwdcSpec.name, () => spec_bwdc.bwdcSpec);
break;
case 'bws':
await spec_bws.loadLibrary();
registerSpec(spec_bws.bwsSpec.name, () => spec_bws.bwsSpec);
break;
case 'c++':
await spec_c__.loadLibrary();
registerSpec(spec_c__.cppSpec.name, () => spec_c__.cppSpec);
break;
case 'caffeinate':
await spec_caffeinate.loadLibrary();
registerSpec(spec_caffeinate.caffeinateSpec.name,
() => spec_caffeinate.caffeinateSpec);
break;
case 'cal':
await spec_cal.loadLibrary();
registerSpec(spec_cal.calSpec.name, () => spec_cal.calSpec);
break;
case 'cap':
await spec_cap.loadLibrary();
registerSpec(spec_cap.capSpec.name, () => spec_cap.capSpec);
break;
case 'capacitor':
await spec_capacitor.loadLibrary();
registerSpec(spec_capacitor.capacitorSpec.name,
() => spec_capacitor.capacitorSpec);
break;
case 'cargo':
await spec_cargo.loadLibrary();
registerSpec(spec_cargo.cargoSpec.name, () => spec_cargo.cargoSpec);
break;
case 'cat':
await spec_cat.loadLibrary();
registerSpec(spec_cat.catSpec.name, () => spec_cat.catSpec);
break;
case 'cci':
await spec_cci.loadLibrary();
registerSpec(spec_cci.cciSpec.name, () => spec_cci.cciSpec);
break;
case 'cd':
await spec_cd.loadLibrary();
registerSpec(spec_cd.cdSpec.name, () => spec_cd.cdSpec);
break;
case 'cdk':
await spec_cdk.loadLibrary();
registerSpec(spec_cdk.cdkSpec.name, () => spec_cdk.cdkSpec);
break;
case 'cdk8s':
await spec_cdk8s.loadLibrary();
registerSpec(spec_cdk8s.cdk8sSpec.name, () => spec_cdk8s.cdk8sSpec);
break;
case 'cf':
await spec_cf.loadLibrary();
registerSpec(spec_cf.cfSpec.name, () => spec_cf.cfSpec);
break;
case 'charm':
await spec_charm.loadLibrary();
registerSpec(spec_charm.charmSpec.name, () => spec_charm.charmSpec);
break;
case 'chmod':
await spec_chmod.loadLibrary();
registerSpec(spec_chmod.chmodSpec.name, () => spec_chmod.chmodSpec);
break;
case 'chown':
await spec_chown.loadLibrary();
registerSpec(spec_chown.chownSpec.name, () => spec_chown.chownSpec);
break;
case 'cicada':
await spec_cicada.loadLibrary();
registerSpec(spec_cicada.cicadaSpec.name, () => spec_cicada.cicadaSpec);
break;
case 'circleci':
await spec_circleci.loadLibrary();
registerSpec(
spec_circleci.circleciSpec.name, () => spec_circleci.circleciSpec);
break;
case 'cl':
await spec_cl.loadLibrary();
registerSpec(spec_cl.clSpec.name, () => spec_cl.clSpec);
break;
case 'clang':
await spec_clang.loadLibrary();
registerSpec(spec_clang.clangSpec.name, () => spec_clang.clangSpec);
break;
case 'clang++':
await spec_clang__.loadLibrary();
registerSpec(
spec_clang__.clangppSpec.name, () => spec_clang__.clangppSpec);
break;
case 'clean':
await spec_dotnet_dotnet_clean.loadLibrary();
registerSpec(spec_dotnet_dotnet_clean.cleanSpec.name,
() => spec_dotnet_dotnet_clean.cleanSpec);
break;
case 'clear':
await spec_clear.loadLibrary();
registerSpec(spec_clear.clearSpec.name, () => spec_clear.clearSpec);
break;
case 'cli':
await spec_capgo_cli.loadLibrary();
registerSpec(spec_capgo_cli.cliSpec.name, () => spec_capgo_cli.cliSpec);
break;
case 'cliff-jumper':
await spec_cliff_jumper.loadLibrary();
registerSpec(spec_cliff_jumper.cliffJumperSpec.name,
() => spec_cliff_jumper.cliffJumperSpec);
break;
case 'clilol':
await spec_clilol.loadLibrary();
registerSpec(spec_clilol.clilolSpec.name, () => spec_clilol.clilolSpec);
break;
case 'clojure':
await spec_clojure.loadLibrary();
registerSpec(
spec_clojure.clojureSpec.name, () => spec_clojure.clojureSpec);
break;
case 'cloudflared':
await spec_cloudflared.loadLibrary();
registerSpec(spec_cloudflared.cloudflaredSpec.name,
() => spec_cloudflared.cloudflaredSpec);
break;
case 'cmake':
await spec_cmake.loadLibrary();
registerSpec(spec_cmake.cmakeSpec.name, () => spec_cmake.cmakeSpec);
break;
case 'coda':
await spec_coda.loadLibrary();
registerSpec(spec_coda.codaSpec.name, () => spec_coda.codaSpec);
break;
case 'code':
await spec_code.loadLibrary();
registerSpec(spec_code.codeSpec.name, () => spec_code.codeSpec);
break;
case 'code-insiders':
await spec_code_insiders.loadLibrary();
registerSpec(spec_code_insiders.codeInsidersSpec.name,
() => spec_code_insiders.codeInsidersSpec);
break;
case 'codesign':
await spec_codesign.loadLibrary();
registerSpec(
spec_codesign.codesignSpec.name, () => spec_codesign.codesignSpec);
break;
case 'command':
await spec_command.loadLibrary();
registerSpec(
spec_command.commandSpec.name, () => spec_command.commandSpec);
break;
case 'composer':
await spec_composer.loadLibrary();
registerSpec(
spec_composer.composerSpec.name, () => spec_composer.composerSpec);
break;
case 'conda':
await spec_conda.loadLibrary();
registerSpec(spec_conda.condaSpec.name, () => spec_conda.condaSpec);
break;
case 'copilot':
await spec_copilot.loadLibrary();
registerSpec(
spec_copilot.copilotSpec.name, () => spec_copilot.copilotSpec);
break;
case 'copyfile':
await spec_copyfile.loadLibrary();
registerSpec(
spec_copyfile.copyfileSpec.name, () => spec_copyfile.copyfileSpec);
break;
case 'copypath':
await spec_copypath.loadLibrary();
registerSpec(
spec_copypath.copypathSpec.name, () => spec_copypath.copypathSpec);
break;
case 'cosign':
await spec_cosign.loadLibrary();
registerSpec(spec_cosign.cosignSpec.name, () => spec_cosign.cosignSpec);
break;
case 'cot':
await spec_cot.loadLibrary();
registerSpec(spec_cot.cotSpec.name, () => spec_cot.cotSpec);
break;
case 'cp':
await spec_cp.loadLibrary();
registerSpec(spec_cp.cpSpec.name, () => spec_cp.cpSpec);
break;
case 'create-completion-spec':
await spec_create_completion_spec.loadLibrary();
registerSpec(spec_create_completion_spec.createCompletionSpecSpec.name,
() => spec_create_completion_spec.createCompletionSpecSpec);
break;
case 'create-next-app':
await spec_create_next_app.loadLibrary();
registerSpec(spec_create_next_app.createNextAppSpec.name,
() => spec_create_next_app.createNextAppSpec);
break;
case 'create-nx-workspace':
await spec_create_nx_workspace.loadLibrary();
registerSpec(spec_create_nx_workspace.createNxWorkspaceSpec.name,
() => spec_create_nx_workspace.createNxWorkspaceSpec);
break;
case 'create-react-app':
await spec_create_react_app.loadLibrary();
registerSpec(spec_create_react_app.createReactAppSpec.name,
() => spec_create_react_app.createReactAppSpec);
break;
case 'create-react-native-app':
await spec_create_react_native_app.loadLibrary();
registerSpec(spec_create_react_native_app.createReactNativeAppSpec.name,
() => spec_create_react_native_app.createReactNativeAppSpec);
break;
case 'create-redwood-app':
await spec_create_redwood_app.loadLibrary();
registerSpec(spec_create_redwood_app.createRedwoodAppSpec.name,
() => spec_create_redwood_app.createRedwoodAppSpec);
break;
case 'create-remix':
await spec_create_remix.loadLibrary();
registerSpec(spec_create_remix.createRemixSpec.name,
() => spec_create_remix.createRemixSpec);
break;
case 'create-t3-app':
await spec_create_t3_app.loadLibrary();
registerSpec(spec_create_t3_app.createT3AppSpec.name,
() => spec_create_t3_app.createT3AppSpec);
break;
case 'create-video':
await spec_create_video.loadLibrary();
registerSpec(spec_create_video.createVideoSpec.name,
() => spec_create_video.createVideoSpec);
break;
case 'create-web3-frontend':
await spec_create_web3_frontend.loadLibrary();
registerSpec(spec_create_web3_frontend.createWeb3FrontendSpec.name,
() => spec_create_web3_frontend.createWeb3FrontendSpec);
break;
case 'croc':
await spec_croc.loadLibrary();
registerSpec(spec_croc.crocSpec.name, () => spec_croc.crocSpec);
break;
case 'crontab':
await spec_crontab.loadLibrary();
registerSpec(
spec_crontab.crontabSpec.name, () => spec_crontab.crontabSpec);
break;
case 'csdx':
await spec_csdx.loadLibrary();
registerSpec(spec_csdx.csdxSpec.name, () => spec_csdx.csdxSpec);
break;
case 'curl':
await spec_curl.loadLibrary();
registerSpec(spec_curl.curlSpec.name, () => spec_curl.curlSpec);
break;
case 'cut':
await spec_cut.loadLibrary();
registerSpec(spec_cut.cutSpec.name, () => spec_cut.cutSpec);
break;
case 'cw':
await spec_cw.loadLibrary();
registerSpec(spec_cw.cwSpec.name, () => spec_cw.cwSpec);
break;
case 'dart':
await spec_dart.loadLibrary();
registerSpec(spec_dart.dartSpec.name, () => spec_dart.dartSpec);
break;
case 'date':
await spec_date.loadLibrary();
registerSpec(spec_date.dateSpec.name, () => spec_date.dateSpec);
break;
case 'dateseq':
await spec_dateseq.loadLibrary();
registerSpec(
spec_dateseq.dateseqSpec.name, () => spec_dateseq.dateseqSpec);
break;
case 'datree':
await spec_datree.loadLibrary();
registerSpec(spec_datree.datreeSpec.name, () => spec_datree.datreeSpec);
break;
case 'dbt':
await spec_dbt.loadLibrary();
registerSpec(spec_dbt.dbtSpec.name, () => spec_dbt.dbtSpec);
break;
case 'dd':
await spec_dd.loadLibrary();
registerSpec(spec_dd.ddSpec.name, () => spec_dd.ddSpec);
break;
case 'ddev':
await spec_ddev.loadLibrary();
registerSpec(spec_ddev.ddevSpec.name, () => spec_ddev.ddevSpec);
break;
case 'ddosify':
await spec_ddosify.loadLibrary();
registerSpec(
spec_ddosify.ddosifySpec.name, () => spec_ddosify.ddosifySpec);
break;
case 'deno':
await spec_deno.loadLibrary();
registerSpec(spec_deno.denoSpec.name, () => spec_deno.denoSpec);
break;
case 'deployctl':
await spec_deployctl.loadLibrary();
registerSpec(spec_deployctl.deployctlSpec.name,
() => spec_deployctl.deployctlSpec);
break;
case 'deta':
await spec_deta.loadLibrary();
registerSpec(spec_deta.detaSpec.name, () => spec_deta.detaSpec);
break;
case 'df':
await spec_df.loadLibrary();
registerSpec(spec_df.dfSpec.name, () => spec_df.dfSpec);
break;
case 'diff':
await spec_diff.loadLibrary();
registerSpec(spec_diff.diffSpec.name, () => spec_diff.diffSpec);
break;
case 'dig':
await spec_dig.loadLibrary();
registerSpec(spec_dig.digSpec.name, () => spec_dig.digSpec);
break;
case 'direnv':
await spec_direnv.loadLibrary();
registerSpec(spec_direnv.direnvSpec.name, () => spec_direnv.direnvSpec);
break;
case 'dirname':
await spec_dirname.loadLibrary();
registerSpec(
spec_dirname.dirnameSpec.name, () => spec_dirname.dirnameSpec);
break;
case 'ditto':
await spec_ditto.loadLibrary();
registerSpec(spec_ditto.dittoSpec.name, () => spec_ditto.dittoSpec);
break;
case 'do':
await spec_do.loadLibrary();
registerSpec(spec_do.doSpec.name, () => spec_do.doSpec);
break;
case 'do-release-upgrade':
await spec_do_release_upgrade.loadLibrary();
registerSpec(spec_do_release_upgrade.doReleaseUpgradeSpec.name,
() => spec_do_release_upgrade.doReleaseUpgradeSpec);
break;
case 'docker':
await spec_docker.loadLibrary();
registerSpec(spec_docker.dockerSpec.name, () => spec_docker.dockerSpec);
break;
case 'docker-compose':
await spec_docker_compose.loadLibrary();
registerSpec(spec_docker_compose.dockerComposeSpec.name,
() => spec_docker_compose.dockerComposeSpec);
break;
case 'doctl':
await spec_doctl.loadLibrary();
registerSpec(spec_doctl.doctlSpec.name, () => spec_doctl.doctlSpec);
break;
case 'dog':
await spec_dog.loadLibrary();
registerSpec(spec_dog.dogSpec.name, () => spec_dog.dogSpec);
break;
case 'doggo':
await spec_doggo.loadLibrary();
registerSpec(spec_doggo.doggoSpec.name, () => spec_doggo.doggoSpec);
break;
case 'dos2unix':
await spec_dos2unix.loadLibrary();
registerSpec(
spec_dos2unix.dos2unixSpec.name, () => spec_dos2unix.dos2unixSpec);
break;
case 'dotenv':
await spec_dotenv.loadLibrary();
registerSpec(spec_dotenv.dotenvSpec.name, () => spec_dotenv.dotenvSpec);
break;
case 'dotenv-vault':
await spec_dotenv_vault.loadLibrary();
registerSpec(spec_dotenv_vault.dotenvVaultSpec.name,
() => spec_dotenv_vault.dotenvVaultSpec);
break;
case 'dotslash':
await spec_dotslash.loadLibrary();
registerSpec(
spec_dotslash.dotslashSpec.name, () => spec_dotslash.dotslashSpec);
break;
case 'dpkg':
await spec_dpkg.loadLibrary();
registerSpec(spec_dpkg.dpkgSpec.name, () => spec_dpkg.dpkgSpec);
break;
case 'dprint':
await spec_dprint.loadLibrary();
registerSpec(spec_dprint.dprintSpec.name, () => spec_dprint.dprintSpec);
break;
case 'dtm':
await spec_dtm.loadLibrary();
registerSpec(spec_dtm.dtmSpec.name, () => spec_dtm.dtmSpec);
break;
case 'du':
await spec_du.loadLibrary();
registerSpec(spec_du.duSpec.name, () => spec_du.duSpec);
break;
case 'dust':
await spec_dust.loadLibrary();
registerSpec(spec_dust.dustSpec.name, () => spec_dust.dustSpec);
break;
case 'eas':
await spec_eas.loadLibrary();
registerSpec(spec_eas.easSpec.name, () => spec_eas.easSpec);
break;
case 'echo':
await spec_echo.loadLibrary();
registerSpec(spec_echo.echoSpec.name, () => spec_echo.echoSpec);
break;
case 'electron':
await spec_electron.loadLibrary();
registerSpec(
spec_electron.electronSpec.name, () => spec_electron.electronSpec);
break;
case 'eleventy':
await spec_eleventy.loadLibrary();
registerSpec(
spec_eleventy.eleventySpec.name, () => spec_eleventy.eleventySpec);
break;
case 'elif':
await spec_elif.loadLibrary();
registerSpec(spec_elif.elifSpec.name, () => spec_elif.elifSpec);
break;
case 'elixir':
await spec_elixir.loadLibrary();
registerSpec(spec_elixir.elixirSpec.name, () => spec_elixir.elixirSpec);
break;
case 'elm':
await spec_elm.loadLibrary();
registerSpec(spec_elm.elmSpec.name, () => spec_elm.elmSpec);
break;
case 'elm-format':
await spec_elm_format.loadLibrary();
registerSpec(spec_elm_format.elmFormatSpec.name,
() => spec_elm_format.elmFormatSpec);
break;
case 'elm-review':
await spec_elm_review.loadLibrary();
registerSpec(spec_elm_review.elmReviewSpec.name,
() => spec_elm_review.elmReviewSpec);
break;
case 'else':
await spec_else.loadLibrary();
registerSpec(spec_else.elseSpec.name, () => spec_else.elseSpec);
break;
case 'emacs':
await spec_emacs.loadLibrary();
registerSpec(spec_emacs.emacsSpec.name, () => spec_emacs.emacsSpec);
break;
case 'enapter':
await spec_enapter.loadLibrary();
registerSpec(
spec_enapter.enapterSpec.name, () => spec_enapter.enapterSpec);
break;
case 'encore':
await spec_encore.loadLibrary();
registerSpec(spec_encore.encoreSpec.name, () => spec_encore.encoreSpec);
break;
case 'env':
await spec_env.loadLibrary();
registerSpec(spec_env.envSpec.name, () => spec_env.envSpec);
break;
case 'envchain':
await spec_envchain.loadLibrary();
registerSpec(
spec_envchain.envchainSpec.name, () => spec_envchain.envchainSpec);
break;
case 'esbuild':
await spec_esbuild.loadLibrary();
registerSpec(
spec_esbuild.esbuildSpec.name, () => spec_esbuild.esbuildSpec);
break;
case 'eslint':
await spec_eslint.loadLibrary();
registerSpec(spec_eslint.eslintSpec.name, () => spec_eslint.eslintSpec);
break;
case 'exa':
await spec_exa.loadLibrary();
registerSpec(spec_exa.exaSpec.name, () => spec_exa.exaSpec);
break;
case 'exec':
await spec_exec.loadLibrary();
registerSpec(spec_exec.execSpec.name, () => spec_exec.execSpec);
break;
case 'exercism':
await spec_exercism.loadLibrary();
registerSpec(
spec_exercism.exercismSpec.name, () => spec_exercism.exercismSpec);
break;
case 'export':
await spec_export.loadLibrary();
registerSpec(spec_export.exportSpec.name, () => spec_export.exportSpec);
break;
case 'eza':
await spec_eza.loadLibrary();
registerSpec(spec_eza.ezaSpec.name, () => spec_eza.ezaSpec);
break;
case 'fastlane':
await spec_fastlane.loadLibrary();
registerSpec(
spec_fastlane.fastlaneSpec.name, () => spec_fastlane.fastlaneSpec);
break;
case 'fastly':
await spec_fastly.loadLibrary();
registerSpec(spec_fastly.fastlySpec.name, () => spec_fastly.fastlySpec);
break;
case 'fd':
await spec_fd.loadLibrary();
registerSpec(spec_fd.fdSpec.name, () => spec_fd.fdSpec);
break;
case 'fdisk':
await spec_fdisk.loadLibrary();
registerSpec(spec_fdisk.fdiskSpec.name, () => spec_fdisk.fdiskSpec);
break;
case 'ffmpeg':
await spec_ffmpeg.loadLibrary();
registerSpec(spec_ffmpeg.ffmpegSpec.name, () => spec_ffmpeg.ffmpegSpec);
break;
case 'fig':
await spec_fig_fig.loadLibrary();
registerSpec(
spec_fig_fig.completionSpec.name, () => spec_fig_fig.completionSpec);
break;
case 'figterm':
await spec_figterm.loadLibrary();
registerSpec(
spec_figterm.figtermSpec.name, () => spec_figterm.figtermSpec);
break;
case 'file':
await spec_file.loadLibrary();
registerSpec(spec_file.fileSpec.name, () => spec_file.fileSpec);
break;
case 'fin':
await spec_fin.loadLibrary();
registerSpec(spec_fin.finSpec.name, () => spec_fin.finSpec);
break;
case 'find':
await spec_find.loadLibrary();
registerSpec(spec_find.findSpec.name, () => spec_find.findSpec);
break;
case 'firebase':
await spec_firebase.loadLibrary();
registerSpec(
spec_firebase.firebaseSpec.name, () => spec_firebase.firebaseSpec);
break;
case 'firefox':
await spec_firefox.loadLibrary();
registerSpec(
spec_firefox.firefoxSpec.name, () => spec_firefox.firefoxSpec);
break;
case 'flutter':
await spec_flutter.loadLibrary();
registerSpec(
spec_flutter.flutterSpec.name, () => spec_flutter.flutterSpec);
break;
case 'fmt':
await spec_fmt.loadLibrary();
registerSpec(spec_fmt.fmtSpec.name, () => spec_fmt.fmtSpec);
break;
case 'fold':
await spec_fold.loadLibrary();
registerSpec(spec_fold.foldSpec.name, () => spec_fold.foldSpec);
break;
case 'for':
await spec_for.loadLibrary();
registerSpec(spec_for.forSpec.name, () => spec_for.forSpec);
break;
case 'forc':
await spec_forc.loadLibrary();
registerSpec(spec_forc.forcSpec.name, () => spec_forc.forcSpec);
break;
case 'format':
await spec_dotnet_dotnet_format.loadLibrary();
registerSpec(spec_dotnet_dotnet_format.formatSpec.name,
() => spec_dotnet_dotnet_format.formatSpec);
break;
case 'fvm':
await spec_fvm.loadLibrary();
registerSpec(spec_fvm.fvmSpec.name, () => spec_fvm.fvmSpec);
break;
case 'fzf':
await spec_fzf.loadLibrary();
registerSpec(spec_fzf.fzfSpec.name, () => spec_fzf.fzfSpec);
break;
case 'fzf-tmux':
await spec_fzf_tmux.loadLibrary();
registerSpec(
spec_fzf_tmux.fzfTmuxSpec.name, () => spec_fzf_tmux.fzfTmuxSpec);
break;
case 'g++':
await spec_g__.loadLibrary();
registerSpec(spec_g__.gppSpec.name, () => spec_g__.gppSpec);
break;
case 'ganache-cli':
await spec_ganache_cli.loadLibrary();
registerSpec(spec_ganache_cli.ganacheCliSpec.name,
() => spec_ganache_cli.ganacheCliSpec);
break;
case 'gatsby':
await spec_gatsby.loadLibrary();
registerSpec(spec_gatsby.gatsbySpec.name, () => spec_gatsby.gatsbySpec);
break;
case 'gcc':
await spec_gcc.loadLibrary();
registerSpec(spec_gcc.gccBase.name, () => spec_gcc.gccBase);
break;
case 'gcloud':
await spec_gcloud.loadLibrary();
registerSpec(spec_gcloud.gcloudSpec.name, () => spec_gcloud.gcloudSpec);
break;
case 'gem':
await spec_gem.loadLibrary();
registerSpec(spec_gem.gemSpec.name, () => spec_gem.gemSpec);
break;
case 'ghq':
await spec_ghq.loadLibrary();
registerSpec(spec_ghq.ghqSpec.name, () => spec_ghq.ghqSpec);
break;
case 'git':
await spec_git.loadLibrary();
registerSpec(spec_git.gitSpec.name, () => spec_git.gitSpec);
break;
case 'git-quick-stats':
await spec_git_quick_stats.loadLibrary();
registerSpec(spec_git_quick_stats.gitQuickStatsSpec.name,
() => spec_git_quick_stats.gitQuickStatsSpec);
break;
case 'github':
await spec_github.loadLibrary();
registerSpec(spec_github.githubSpec.name, () => spec_github.githubSpec);
break;
case 'glow':
await spec_glow.loadLibrary();
registerSpec(spec_glow.glowSpec.name, () => spec_glow.glowSpec);
break;
case 'gltfjsx':
await spec_gltfjsx.loadLibrary();
registerSpec(
spec_gltfjsx.gltfjsxSpec.name, () => spec_gltfjsx.gltfjsxSpec);
break;
case 'go':
await spec_go.loadLibrary();
registerSpec(spec_go.goSpec.name, () => spec_go.goSpec);
break;
case 'go-task':
await spec_task_go_task.loadLibrary();
registerSpec(spec_task_go_task.completionSpec.name,
() => spec_task_go_task.completionSpec);
await spec_task_go_task_1.loadLibrary();
registerSpec(spec_task_go_task_1.goTaskSpec.name,
() => spec_task_go_task_1.goTaskSpec);
break;
case 'goctl':
await spec_goctl.loadLibrary();
registerSpec(spec_goctl.goctlSpec.name, () => spec_goctl.goctlSpec);
break;
case 'googler':
await spec_googler.loadLibrary();
registerSpec(
spec_googler.googlerSpec.name, () => spec_googler.googlerSpec);
break;
case 'goreleaser':
await spec_goreleaser.loadLibrary();
registerSpec(spec_goreleaser.goreleaserSpec.name,
() => spec_goreleaser.goreleaserSpec);
break;
case 'goto':
await spec_goto.loadLibrary();
registerSpec(spec_goto.gotoSpec.name, () => spec_goto.gotoSpec);
break;
case 'gradle':
await spec_gradle.loadLibrary();
registerSpec(spec_gradle.gradleSpec.name, () => spec_gradle.gradleSpec);
break;
case 'graphcdn':
await spec_graphcdn.loadLibrary();
registerSpec(
spec_graphcdn.graphcdnSpec.name, () => spec_graphcdn.graphcdnSpec);
break;
case 'grep':
await spec_grep.loadLibrary();
registerSpec(spec_grep.grepSpec.name, () => spec_grep.grepSpec);
break;
case 'grex':
await spec_grex.loadLibrary();
registerSpec(spec_grex.grexSpec.name, () => spec_grex.grexSpec);
break;
case 'gron':
await spec_gron.loadLibrary();
registerSpec(spec_gron.gronSpec.name, () => spec_gron.gronSpec);
break;
case 'gt':
await spec_gt.loadLibrary();
registerSpec(spec_gt.gtSpec.name, () => spec_gt.gtSpec);
break;
case 'hardhat':
await spec_hardhat.loadLibrary();
registerSpec(
spec_hardhat.hardhatSpec.name, () => spec_hardhat.hardhatSpec);
break;
case 'hasura':
await spec_hasura.loadLibrary();
registerSpec(spec_hasura.hasuraSpec.name, () => spec_hasura.hasuraSpec);
break;
case 'hb-service':
await spec_hb_service.loadLibrary();
registerSpec(spec_hb_service.hbServiceSpec.name,
() => spec_hb_service.hbServiceSpec);
break;
case 'head':
await spec_head.loadLibrary();
registerSpec(spec_head.headSpec.name, () => spec_head.headSpec);
break;
case 'helm':
await spec_helm.loadLibrary();
registerSpec(spec_helm.helmSpec.name, () => spec_helm.helmSpec);
break;
case 'helmfile':
await spec_helmfile.loadLibrary();
registerSpec(
spec_helmfile.helmfileSpec.name, () => spec_helmfile.helmfileSpec);
break;
case 'help':
await spec_dotnet_dotnet_help.loadLibrary();
registerSpec(spec_dotnet_dotnet_help.helpSpec.name,
() => spec_dotnet_dotnet_help.helpSpec);
break;
case 'herd':
await spec_herd.loadLibrary();
registerSpec(spec_herd.herdSpec.name, () => spec_herd.herdSpec);
break;
case 'heroku':
await spec_heroku_8_0_0.loadLibrary();
registerSpec(spec_heroku_8_0_0.herokuSpec.name,
() => spec_heroku_8_0_0.herokuSpec);
await spec_heroku_8_6_0.loadLibrary();
registerSpec(spec_heroku_8_6_0.herokuSpec.name,
() => spec_heroku_8_6_0.herokuSpec);
await spec_heroku_index.loadLibrary();
registerSpec(spec_heroku_index.completionSpec.name,
() => spec_heroku_index.completionSpec);
break;
case 'hexo':
await spec_hexo.loadLibrary();
registerSpec(spec_hexo.hexoSpec.name, () => spec_hexo.hexoSpec);
break;
case 'homey':
await spec_homey.loadLibrary();
registerSpec(spec_homey.homeySpec.name, () => spec_homey.homeySpec);
break;
case 'hop':
await spec_hop.loadLibrary();
registerSpec(spec_hop.hopSpec.name, () => spec_hop.hopSpec);
break;
case 'hostname':
await spec_hostname.loadLibrary();
registerSpec(
spec_hostname.hostnameSpec.name, () => spec_hostname.hostnameSpec);
break;
case 'htop':
await spec_htop.loadLibrary();
registerSpec(spec_htop.htopSpec.name, () => spec_htop.htopSpec);
break;
case 'http':
await spec_http.loadLibrary();
registerSpec(spec_http.httpSpec.name, () => spec_http.httpSpec);
break;
case 'http.server':
await spec_python_http_server.loadLibrary();
registerSpec(spec_python_http_server.httpServerSpec.name,
() => spec_python_http_server.httpServerSpec);
break;
case 'httpy':
await spec_httpy.loadLibrary();
registerSpec(spec_httpy.httpySpec.name, () => spec_httpy.httpySpec);
break;
case 'hub':
await spec_hub.loadLibrary();
registerSpec(spec_hub.hubSpec.name, () => spec_hub.hubSpec);
break;
case 'hugo':
await spec_hugo.loadLibrary();
registerSpec(spec_hugo.hugoSpec.name, () => spec_hugo.hugoSpec);
break;
case 'hx':
await spec_hx.loadLibrary();
registerSpec(spec_hx.hxSpec.name, () => spec_hx.hxSpec);
break;
case 'hyper':
await spec_hyper.loadLibrary();
registerSpec(spec_hyper.hyperSpec.name, () => spec_hyper.hyperSpec);
break;
case 'hyperfine':
await spec_hyperfine.loadLibrary();
registerSpec(spec_hyperfine.hyperfineSpec.name,
() => spec_hyperfine.hyperfineSpec);
break;
case 'iconv':
await spec_iconv.loadLibrary();
registerSpec(spec_iconv.iconvSpec.name, () => spec_iconv.iconvSpec);
break;
case 'id':
await spec_id.loadLibrary();
registerSpec(spec_id.idSpec.name, () => spec_id.idSpec);
break;
case 'iex':
await spec_iex.loadLibrary();
registerSpec(spec_iex.iexSpec.name, () => spec_iex.iexSpec);
break;
case 'if':
await spec_if.loadLibrary();
registerSpec(spec_if.ifSpec.name, () => spec_if.ifSpec);
break;
case 'index':
await spec_appwrite.loadLibrary();
registerSpec(spec_appwrite.indexSpec.name, () => spec_appwrite.indexSpec);
break;
case 'infracost':
await spec_infracost_index.loadLibrary();
registerSpec(spec_infracost_index.completionSpec.name,
() => spec_infracost_index.completionSpec);
break;
case 'install':
await spec_install.loadLibrary();
registerSpec(
spec_install.installSpec.name, () => spec_install.installSpec);
break;
case 'j':
await spec_j.loadLibrary();
registerSpec(spec_j.jSpec.name, () => spec_j.jSpec);
break;
case 'java':
await spec_java.loadLibrary();
registerSpec(spec_java.javaSpec.name, () => spec_java.javaSpec);
break;
case 'jenv':
await spec_jenv.loadLibrary();
registerSpec(spec_jenv.jenvSpec.name, () => spec_jenv.jenvSpec);
break;
case 'jest':
await spec_jest.loadLibrary();
registerSpec(spec_jest.jestSpec.name, () => spec_jest.jestSpec);
break;
case 'jmeter':
await spec_jmeter.loadLibrary();
registerSpec(spec_jmeter.jmeterSpec.name, () => spec_jmeter.jmeterSpec);
break;
case 'join':
await spec_join.loadLibrary();
registerSpec(spec_join.joinSpec.name, () => spec_join.joinSpec);
break;
case 'jq':
await spec_jq.loadLibrary();
registerSpec(spec_jq.jqSpec.name, () => spec_jq.jqSpec);
break;
case 'julia':
await spec_julia.loadLibrary();
registerSpec(spec_julia.juliaSpec.name, () => spec_julia.juliaSpec);
break;
case 'jupyter':
await spec_jupyter.loadLibrary();
registerSpec(
spec_jupyter.jupyterSpec.name, () => spec_jupyter.jupyterSpec);
break;
case 'k3d':
await spec_k3d.loadLibrary();
registerSpec(spec_k3d.k3dSpec.name, () => spec_k3d.k3dSpec);
break;
case 'k6':
await spec_k6.loadLibrary();
registerSpec(spec_k6.k6Spec.name, () => spec_k6.k6Spec);
break;
case 'k9s':
await spec_k9s.loadLibrary();
registerSpec(spec_k9s.k9sSpec.name, () => spec_k9s.k9sSpec);
break;
case 'kafkactl':
await spec_kafkactl.loadLibrary();
registerSpec(
spec_kafkactl.kafkactlSpec.name, () => spec_kafkactl.kafkactlSpec);
break;
case 'kdoctor':
await spec_kdoctor.loadLibrary();
registerSpec(
spec_kdoctor.kdoctorSpec.name, () => spec_kdoctor.kdoctorSpec);
break;
case 'keytool':
await spec_keytool.loadLibrary();
registerSpec(
spec_keytool.keytoolSpec.name, () => spec_keytool.keytoolSpec);
break;
case 'kill':
await spec_kill.loadLibrary();
registerSpec(spec_kill.killSpec.name, () => spec_kill.killSpec);
break;
case 'killall':
await spec_killall.loadLibrary();
registerSpec(
spec_killall.killallSpec.name, () => spec_killall.killallSpec);
break;
case 'kind':
await spec_kind.loadLibrary();
registerSpec(spec_kind.kindSpec.name, () => spec_kind.kindSpec);
break;
case 'kitty':
await spec_kitty.loadLibrary();
registerSpec(spec_kitty.kittySpec.name, () => spec_kitty.kittySpec);
break;
case 'klist':
await spec_klist.loadLibrary();
registerSpec(spec_klist.klistSpec.name, () => spec_klist.klistSpec);
break;
case 'knex':
await spec_knex.loadLibrary();
registerSpec(spec_knex.knexSpec.name, () => spec_knex.knexSpec);
break;
case 'kotlinc':
await spec_kotlinc.loadLibrary();
registerSpec(
spec_kotlinc.kotlincSpec.name, () => spec_kotlinc.kotlincSpec);
break;
case 'kubecolor':
await spec_kubecolor.loadLibrary();
registerSpec(spec_kubecolor.kubecolorSpec.name,
() => spec_kubecolor.kubecolorSpec);
break;
case 'kubectl':
await spec_kubectl.loadLibrary();
registerSpec(
spec_kubectl.kubectlSpec.name, () => spec_kubectl.kubectlSpec);
break;
case 'kubectx':
await spec_kubectx.loadLibrary();
registerSpec(
spec_kubectx.kubectxSpec.name, () => spec_kubectx.kubectxSpec);
break;
case 'kubens':
await spec_kubens.loadLibrary();
registerSpec(spec_kubens.kubensSpec.name, () => spec_kubens.kubensSpec);
break;
case 'laravel':
await spec_laravel.loadLibrary();
registerSpec(
spec_laravel.laravelSpec.name, () => spec_laravel.laravelSpec);
break;
case 'launchctl':
await spec_launchctl.loadLibrary();
registerSpec(spec_launchctl.launchctlSpec.name,
() => spec_launchctl.launchctlSpec);
break;
case 'ldd':
await spec_ldd.loadLibrary();
registerSpec(spec_ldd.lddSpec.name, () => spec_ldd.lddSpec);
break;
case 'leaf':
await spec_leaf.loadLibrary();
registerSpec(spec_leaf.leafSpec.name, () => spec_leaf.leafSpec);
break;
case 'less':
await spec_less.loadLibrary();
registerSpec(spec_less.lessSpec.name, () => spec_less.lessSpec);
break;
case 'lima':
await spec_lima.loadLibrary();
registerSpec(spec_lima.limaSpec.name, () => spec_lima.limaSpec);
break;
case 'list':
await spec_dotnet_dotnet_list.loadLibrary();
registerSpec(spec_dotnet_dotnet_list.listSpec.name,
() => spec_dotnet_dotnet_list.listSpec);
break;
case 'ln':
await spec_ln.loadLibrary();
registerSpec(spec_ln.lnSpec.name, () => spec_ln.lnSpec);
break;
case 'locust':
await spec_locust.loadLibrary();
registerSpec(spec_locust.locustSpec.name, () => spec_locust.locustSpec);
break;
case 'lp':
await spec_lp.loadLibrary();
registerSpec(spec_lp.lpSpec.name, () => spec_lp.lpSpec);
break;
case 'lpass':
await spec_lpass.loadLibrary();
registerSpec(spec_lpass.lpassSpec.name, () => spec_lpass.lpassSpec);
break;
case 'ls':
await spec_ls.loadLibrary();
registerSpec(spec_ls.lsSpec.name, () => spec_ls.lsSpec);
break;
case 'lsblk':
await spec_lsblk.loadLibrary();
registerSpec(spec_lsblk.lsblkSpec.name, () => spec_lsblk.lsblkSpec);
break;
case 'lsd':
await spec_lsd.loadLibrary();
registerSpec(spec_lsd.lsdSpec.name, () => spec_lsd.lsdSpec);
break;
case 'lsof':
await spec_lsof.loadLibrary();
registerSpec(
spec_lsof.completionSpec.name, () => spec_lsof.completionSpec);
break;
case 'luz':
await spec_luz.loadLibrary();
registerSpec(spec_luz.luzSpec.name, () => spec_luz.luzSpec);
break;
case 'lvim':
await spec_lvim.loadLibrary();
registerSpec(spec_lvim.lvimSpec.name, () => spec_lvim.lvimSpec);
break;
case 'm':
await spec_m.loadLibrary();
registerSpec(spec_m.mSpec.name, () => spec_m.mSpec);
break;
case 'mackup':
await spec_mackup.loadLibrary();
registerSpec(spec_mackup.mackupSpec.name, () => spec_mackup.mackupSpec);
break;
case 'magento':
await spec_magento.loadLibrary();
registerSpec(
spec_magento.completionSpec.name, () => spec_magento.completionSpec);
break;
case 'maigret':
await spec_maigret.loadLibrary();
registerSpec(
spec_maigret.maigretSpec.name, () => spec_maigret.maigretSpec);
break;
case 'mailsy':
await spec_mailsy.loadLibrary();
registerSpec(spec_mailsy.mailsySpec.name, () => spec_mailsy.mailsySpec);
break;
case 'main':
await spec_shell_config.loadLibrary();
registerSpec(
spec_shell_config.mainSpec.name, () => spec_shell_config.mainSpec);
break;
case 'make':
await spec_make.loadLibrary();
registerSpec(spec_make.makeSpec.name, () => spec_make.makeSpec);
break;
case 'man':
await spec_man.loadLibrary();
registerSpec(spec_man.completionSpec.name, () => spec_man.completionSpec);
break;
case 'mas':
await spec_mas.loadLibrary();
registerSpec(spec_mas.masSpec.name, () => spec_mas.masSpec);
break;
case 'mask':
await spec_mask.loadLibrary();
registerSpec(spec_mask.maskSpec.name, () => spec_mask.maskSpec);
break;
case 'mdfind':
await spec_mdfind.loadLibrary();
registerSpec(spec_mdfind.mdfindSpec.name, () => spec_mdfind.mdfindSpec);
break;
case 'mdls':
await spec_mdls.loadLibrary();
registerSpec(spec_mdls.mdlsSpec.name, () => spec_mdls.mdlsSpec);
break;
case 'meroxa':
await spec_meroxa.loadLibrary();
registerSpec(spec_meroxa.meroxaSpec.name, () => spec_meroxa.meroxaSpec);
break;
case 'meta':
await spec_meta.loadLibrary();
registerSpec(spec_meta.metaSpec.name, () => spec_meta.metaSpec);
break;
case 'mgnl':
await spec_mgnl.loadLibrary();
registerSpec(spec_mgnl.mgnlSpec.name, () => spec_mgnl.mgnlSpec);
break;
case 'micro':
await spec_micro.loadLibrary();
registerSpec(spec_micro.microSpec.name, () => spec_micro.microSpec);
break;
case 'migrate':
await spec_dotnet_dotnet_migrate.loadLibrary();
registerSpec(spec_dotnet_dotnet_migrate.migrateSpec.name,
() => spec_dotnet_dotnet_migrate.migrateSpec);
break;
case 'mikro-orm':
await spec_mikro_orm.loadLibrary();
registerSpec(
spec_mikro_orm.mikroOrmSpec.name, () => spec_mikro_orm.mikroOrmSpec);
break;
case 'minectl':
await spec_minectl.loadLibrary();
registerSpec(
spec_minectl.minectlSpec.name, () => spec_minectl.minectlSpec);
break;
case 'minikube':
await spec_minikube.loadLibrary();
registerSpec(
spec_minikube.minikubeSpec.name, () => spec_minikube.minikubeSpec);
break;
case 'mix':
await spec_mix.loadLibrary();
registerSpec(spec_mix.mixSpec.name, () => spec_mix.mixSpec);
break;
case 'mkdir':
await spec_mkdir.loadLibrary();
registerSpec(spec_mkdir.mkdirSpec.name, () => spec_mkdir.mkdirSpec);
break;
case 'mkdocs':
await spec_mkdocs.loadLibrary();
registerSpec(spec_mkdocs.mkdocsSpec.name, () => spec_mkdocs.mkdocsSpec);
break;
case 'mkfifo':
await spec_mkfifo.loadLibrary();
registerSpec(spec_mkfifo.mkfifoSpec.name, () => spec_mkfifo.mkfifoSpec);
break;
case 'mknod':
await spec_mknod.loadLibrary();
registerSpec(spec_mknod.mknodSpec.name, () => spec_mknod.mknodSpec);
break;
case 'mob':
await spec_mob.loadLibrary();
registerSpec(spec_mob.mobSpec.name, () => spec_mob.mobSpec);
break;
case 'molecule':
await spec_molecule.loadLibrary();
registerSpec(
spec_molecule.moleculeSpec.name, () => spec_molecule.moleculeSpec);
break;
case 'mongocli':
await spec_mongocli.loadLibrary();
registerSpec(
spec_mongocli.mongocliSpec.name, () => spec_mongocli.mongocliSpec);
break;
case 'mongoimport':
await spec_mongoimport.loadLibrary();
registerSpec(spec_mongoimport.mongoimportSpec.name,
() => spec_mongoimport.mongoimportSpec);
break;
case 'mongosh':
await spec_mongosh.loadLibrary();
registerSpec(
spec_mongosh.mongoshSpec.name, () => spec_mongosh.mongoshSpec);
break;
case 'more':
await spec_more.loadLibrary();
registerSpec(spec_more.moreSpec.name, () => spec_more.moreSpec);
break;
case 'mosh':
await spec_mosh.loadLibrary();
registerSpec(spec_mosh.moshSpec.name, () => spec_mosh.moshSpec);
break;
case 'mount':
await spec_mount.loadLibrary();
registerSpec(spec_mount.mountSpec.name, () => spec_mount.mountSpec);
break;
case 'msbuild':
await spec_dotnet_dotnet_msbuild.loadLibrary();
registerSpec(spec_dotnet_dotnet_msbuild.msbuildSpec.name,
() => spec_dotnet_dotnet_msbuild.msbuildSpec);
break;
case 'multipass':
await spec_multipass.loadLibrary();
registerSpec(spec_multipass.multipassSpec.name,
() => spec_multipass.multipassSpec);
break;
case 'mv':
await spec_mv.loadLibrary();
registerSpec(spec_mv.mvSpec.name, () => spec_mv.mvSpec);
break;
case 'mvn':
await spec_mvn.loadLibrary();
registerSpec(spec_mvn.mvnSpec.name, () => spec_mvn.mvnSpec);
break;
case 'mypy':
await spec_mypy.loadLibrary();
registerSpec(spec_mypy.mypySpec.name, () => spec_mypy.mypySpec);
break;
case 'mysql':
await spec_mysql.loadLibrary();
registerSpec(spec_mysql.mysqlSpec.name, () => spec_mysql.mysqlSpec);
break;
case 'n':
await spec_n.loadLibrary();
registerSpec(spec_n.nSpec.name, () => spec_n.nSpec);
break;
case 'nano':
await spec_nano.loadLibrary();
registerSpec(spec_nano.nanoSpec.name, () => spec_nano.nanoSpec);
break;
case 'nativescript':
await spec_nativescript.loadLibrary();
registerSpec(spec_nativescript.nativescriptSpec.name,
() => spec_nativescript.nativescriptSpec);
break;
case 'nc':
await spec_nc.loadLibrary();
registerSpec(spec_nc.ncSpec.name, () => spec_nc.ncSpec);
break;
case 'ncal':
await spec_ncal.loadLibrary();
registerSpec(spec_ncal.ncalSpec.name, () => spec_ncal.ncalSpec);
break;
case 'ncu':
await spec_ncu.loadLibrary();
registerSpec(spec_ncu.ncuSpec.name, () => spec_ncu.ncuSpec);
break;
case 'neofetch':
await spec_neofetch.loadLibrary();
registerSpec(
spec_neofetch.neofetchSpec.name, () => spec_neofetch.neofetchSpec);
break;
case 'nest':
await spec_nest.loadLibrary();
registerSpec(spec_nest.nestSpec.name, () => spec_nest.nestSpec);
break;
case 'netlify':
await spec_netlify.loadLibrary();
registerSpec(
spec_netlify.netlifySpec.name, () => spec_netlify.netlifySpec);
break;
case 'newman':
await spec_newman.loadLibrary();
registerSpec(spec_newman.newmanSpec.name, () => spec_newman.newmanSpec);
break;
case 'next':
await spec_next.loadLibrary();
registerSpec(spec_next.nextSpec.name, () => spec_next.nextSpec);
break;
case 'nextflow':
await spec_nextflow.loadLibrary();
registerSpec(
spec_nextflow.nextflowSpec.name, () => spec_nextflow.nextflowSpec);
break;
case 'ng':
await spec_ng.loadLibrary();
registerSpec(spec_ng.completionSpec.name, () => spec_ng.completionSpec);
break;
case 'nginx':
await spec_nginx.loadLibrary();
registerSpec(spec_nginx.nginxSpec.name, () => spec_nginx.nginxSpec);
break;
case 'ngrok':
await spec_ngrok.loadLibrary();
registerSpec(spec_ngrok.ngrokSpec.name, () => spec_ngrok.ngrokSpec);
break;
case 'nhost':
await spec_nhost.loadLibrary();
registerSpec(spec_nhost.nhostSpec.name, () => spec_nhost.nhostSpec);
break;
case 'ni':
await spec_ni.loadLibrary();
registerSpec(spec_ni.niSpec.name, () => spec_ni.niSpec);
break;
case 'nl':
await spec_nl.loadLibrary();
registerSpec(spec_nl.nlSpec.name, () => spec_nl.nlSpec);
break;
case 'nmap':
await spec_nmap.loadLibrary();
registerSpec(spec_nmap.nmapSpec.name, () => spec_nmap.nmapSpec);
break;
case 'nocorrect':
await spec_nocorrect.loadLibrary();
registerSpec(spec_nocorrect.nocorrectSpec.name,
() => spec_nocorrect.nocorrectSpec);
break;
case 'node':
await spec_node.loadLibrary();
registerSpec(spec_node.nodeSpec.name, () => spec_node.nodeSpec);
break;
case 'noglob':
await spec_noglob.loadLibrary();
registerSpec(spec_noglob.noglobSpec.name, () => spec_noglob.noglobSpec);
break;
case 'northflank':
await spec_northflank.loadLibrary();
registerSpec(spec_northflank.northflankSpec.name,
() => spec_northflank.northflankSpec);
break;
case 'np':
await spec_np.loadLibrary();
registerSpec(spec_np.npSpec.name, () => spec_np.npSpec);
break;
case 'npm':
await spec_npm.loadLibrary();
registerSpec(spec_npm.npmSpec.name, () => spec_npm.npmSpec);
break;
case 'npx':
await spec_npx.loadLibrary();
registerSpec(spec_npx.npxSpec.name, () => spec_npx.npxSpec);
break;
case 'nr':
await spec_nr.loadLibrary();
registerSpec(spec_nr.completionSpec.name, () => spec_nr.completionSpec);
break;
case 'nrm':
await spec_nrm.loadLibrary();
registerSpec(spec_nrm.completionSpec.name, () => spec_nrm.completionSpec);
break;
case 'ns':
await spec_ns.loadLibrary();
registerSpec(spec_ns.nsSpec.name, () => spec_ns.nsSpec);
break;
case 'nu':
await spec_nu.loadLibrary();
registerSpec(spec_nu.nuSpec.name, () => spec_nu.nuSpec);
break;
case 'nuxi':
await spec_nuxi.loadLibrary();
registerSpec(spec_nuxi.nuxiSpec.name, () => spec_nuxi.nuxiSpec);
break;
case 'nuxt':
await spec_nuxt.loadLibrary();
registerSpec(spec_nuxt.nuxtSpec.name, () => spec_nuxt.nuxtSpec);
break;
case 'nvim':
await spec_nvim.loadLibrary();
registerSpec(spec_nvim.nvimSpec.name, () => spec_nvim.nvimSpec);
break;
case 'nvm':
await spec_nvm.loadLibrary();
registerSpec(spec_nvm.nvmSpec.name, () => spec_nvm.nvmSpec);
break;
case 'nylas':
await spec_nylas.loadLibrary();
registerSpec(spec_nylas.nylasSpec.name, () => spec_nylas.nylasSpec);
break;
case 'oci':
await spec_oci.loadLibrary();
registerSpec(spec_oci.ociSpec.name, () => spec_oci.ociSpec);
break;
case 'od':
await spec_od.loadLibrary();
registerSpec(spec_od.odSpec.name, () => spec_od.odSpec);
break;
case 'oh-my-posh':
await spec_oh_my_posh.loadLibrary();
registerSpec(spec_oh_my_posh.ohMyPoshSpec.name,
() => spec_oh_my_posh.ohMyPoshSpec);
break;
case 'okta':
await spec_okta.loadLibrary();
registerSpec(spec_okta.oktaSpec.name, () => spec_okta.oktaSpec);
break;
case 'ollama':
await spec_ollama.loadLibrary();
registerSpec(spec_ollama.ollamaSpec.name, () => spec_ollama.ollamaSpec);
break;
case 'omz':
await spec_omz.loadLibrary();
registerSpec(spec_omz.omzSpec.name, () => spec_omz.omzSpec);
break;
case 'onboardbase':
await spec_onboardbase.loadLibrary();
registerSpec(spec_onboardbase.onboardbaseSpec.name,
() => spec_onboardbase.onboardbaseSpec);
break;
case 'op':
await spec_op.loadLibrary();
registerSpec(spec_op.opSpec.name, () => spec_op.opSpec);
break;
case 'opa':
await spec_opa.loadLibrary();
registerSpec(spec_opa.opaSpec.name, () => spec_opa.opaSpec);
break;
case 'open':
await spec_open.loadLibrary();
registerSpec(spec_open.openSpec.name, () => spec_open.openSpec);
break;
case 'osascript':
await spec_osascript.loadLibrary();
registerSpec(spec_osascript.osascriptSpec.name,
() => spec_osascript.osascriptSpec);
break;
case 'pac':
await spec_pac.loadLibrary();
registerSpec(spec_pac.pacSpec.name, () => spec_pac.pacSpec);
break;
case 'pack':
await spec_dotnet_dotnet_pack.loadLibrary();
registerSpec(spec_dotnet_dotnet_pack.packSpec.name,
() => spec_dotnet_dotnet_pack.packSpec);
break;
case 'pageres':
await spec_pageres.loadLibrary();
registerSpec(
spec_pageres.pageresSpec.name, () => spec_pageres.pageresSpec);
break;
case 'palera1n':
await spec_palera1n.loadLibrary();
registerSpec(
spec_palera1n.palera1nSpec.name, () => spec_palera1n.palera1nSpec);
break;
case 'paper':
await spec_paper.loadLibrary();
registerSpec(spec_paper.paperSpec.name, () => spec_paper.paperSpec);
break;
case 'pass':
await spec_pass.loadLibrary();
registerSpec(spec_pass.passSpec.name, () => spec_pass.passSpec);
break;
case 'passwd':
await spec_passwd.loadLibrary();
registerSpec(spec_passwd.passwdSpec.name, () => spec_passwd.passwdSpec);
break;
case 'paste':
await spec_paste.loadLibrary();
registerSpec(spec_paste.pasteSpec.name, () => spec_paste.pasteSpec);
break;
case 'path':
await spec_idea.loadLibrary();
registerSpec(spec_idea.ideaSpec.name, () => spec_idea.ideaSpec);
break;
case 'pathchk':
await spec_pathchk.loadLibrary();
registerSpec(
spec_pathchk.pathchkSpec.name, () => spec_pathchk.pathchkSpec);
break;
case 'pdfunite':
await spec_pdfunite.loadLibrary();
registerSpec(
spec_pdfunite.pdfuniteSpec.name, () => spec_pdfunite.pdfuniteSpec);
break;
case 'pg_dump':
await spec_pg_dump.loadLibrary();
registerSpec(
spec_pg_dump.pg_dumpSpec.name, () => spec_pg_dump.pg_dumpSpec);
break;
case 'pgcli':
await spec_pgcli.loadLibrary();
registerSpec(spec_pgcli.pgcliSpec.name, () => spec_pgcli.pgcliSpec);
break;
case 'php':
await spec_php.loadLibrary();
registerSpec(spec_php.phpSpec.name, () => spec_php.phpSpec);
break;
case 'phpunit':
await spec_phpunit.loadLibrary();
registerSpec(
spec_phpunit.phpunitSpec.name, () => spec_phpunit.phpunitSpec);
break;
case 'phpunit-watcher':
await spec_phpunit_watcher.loadLibrary();
registerSpec(spec_phpunit_watcher.phpunitWatcherSpec.name,
() => spec_phpunit_watcher.phpunitWatcherSpec);
break;
case 'pijul':
await spec_pijul.loadLibrary();
registerSpec(spec_pijul.pijulSpec.name, () => spec_pijul.pijulSpec);
break;
case 'ping':
await spec_ping.loadLibrary();
registerSpec(spec_ping.pingSpec.name, () => spec_ping.pingSpec);
break;
case 'pip':
await spec_pip.loadLibrary();
registerSpec(spec_pip.pipSpec.name, () => spec_pip.pipSpec);
break;
case 'pip3':
await spec_pip3.loadLibrary();
registerSpec(spec_pip3.pip3Spec.name, () => spec_pip3.pip3Spec);
break;
case 'pipenv':
await spec_pipenv.loadLibrary();
registerSpec(spec_pipenv.pipenvSpec.name, () => spec_pipenv.pipenvSpec);
break;
case 'pkg-config':
await spec_pkg_config.loadLibrary();
registerSpec(spec_pkg_config.pkgConfigSpec.name,
() => spec_pkg_config.pkgConfigSpec);
break;
case 'pkgutil':
await spec_pkgutil.loadLibrary();
registerSpec(
spec_pkgutil.pkgutilSpec.name, () => spec_pkgutil.pkgutilSpec);
break;
case 'pkill':
await spec_pkill.loadLibrary();
registerSpec(spec_pkill.pkillSpec.name, () => spec_pkill.pkillSpec);
break;
case 'planter':
await spec_planter.loadLibrary();
registerSpec(
spec_planter.planterSpec.name, () => spec_planter.planterSpec);
break;
case 'playwright':
await spec_playwright.loadLibrary();
registerSpec(spec_playwright.playwrightSpec.name,
() => spec_playwright.playwrightSpec);
break;
case 'please':
await spec_php_please.loadLibrary();
registerSpec(spec_php_please.completionSpec.name,
() => spec_php_please.completionSpec);
break;
case 'plutil':
await spec_plutil.loadLibrary();
registerSpec(spec_plutil.plutilSpec.name, () => spec_plutil.plutilSpec);
break;
case 'pm2':
await spec_pm2.loadLibrary();
registerSpec(spec_pm2.pm2Spec.name, () => spec_pm2.pm2Spec);
break;
case 'pmset':
await spec_pmset.loadLibrary();
registerSpec(spec_pmset.pmsetSpec.name, () => spec_pmset.pmsetSpec);
break;
case 'pnpm':
await spec_pnpm.loadLibrary();
registerSpec(spec_pnpm.pnpmSpec.name, () => spec_pnpm.pnpmSpec);
break;
case 'pnpx':
await spec_pnpx.loadLibrary();
registerSpec(spec_pnpx.pnpxSpec.name, () => spec_pnpx.pnpxSpec);
break;
case 'pocketbase':
await spec_pocketbase.loadLibrary();
registerSpec(spec_pocketbase.pocketbaseSpec.name,
() => spec_pocketbase.pocketbaseSpec);
break;
case 'pod':
await spec_pod.loadLibrary();
registerSpec(spec_pod.podSpec.name, () => spec_pod.podSpec);
break;
case 'podman':
await spec_podman.loadLibrary();
registerSpec(spec_podman.podmanSpec.name, () => spec_podman.podmanSpec);
break;
case 'poetry':
await spec_poetry.loadLibrary();
registerSpec(spec_poetry.poetrySpec.name, () => spec_poetry.poetrySpec);
break;
case 'premake':
await spec_premake.loadLibrary();
registerSpec(
spec_premake.premakeSpec.name, () => spec_premake.premakeSpec);
break;
case 'preset':
await spec_preset_cli.loadLibrary();
registerSpec(
spec_preset_cli.presetSpec.name, () => spec_preset_cli.presetSpec);
break;
case 'prettier':
await spec_prettier.loadLibrary();
registerSpec(
spec_prettier.prettierSpec.name, () => spec_prettier.prettierSpec);
break;
case 'prisma':
await spec_prisma.loadLibrary();
registerSpec(spec_prisma.prismaSpec.name, () => spec_prisma.prismaSpec);
break;
case 'pro':
await spec_pro.loadLibrary();
registerSpec(spec_pro.proSpec.name, () => spec_pro.proSpec);
break;
case 'progressline':
await spec_progressline.loadLibrary();
registerSpec(spec_progressline.progresslineSpec.name,
() => spec_progressline.progresslineSpec);
break;
case 'pry':
await spec_pry.loadLibrary();
registerSpec(spec_pry.prySpec.name, () => spec_pry.prySpec);
break;
case 'ps':
await spec_ps.loadLibrary();
registerSpec(spec_ps.psSpec.name, () => spec_ps.psSpec);
break;
case 'psql':
await spec_psql.loadLibrary();
registerSpec(spec_psql.psqlSpec.name, () => spec_psql.psqlSpec);
break;
case 'publish':
await spec_dotnet_dotnet_publish.loadLibrary();
registerSpec(spec_dotnet_dotnet_publish.publishSpec.name,
() => spec_dotnet_dotnet_publish.publishSpec);
await spec_publish.loadLibrary();
registerSpec(
spec_publish.publishSpec.name, () => spec_publish.publishSpec);
break;
case 'pushd':
await spec_pushd.loadLibrary();
registerSpec(spec_pushd.pushdSpec.name, () => spec_pushd.pushdSpec);
break;
case 'pwd':
await spec_pwd.loadLibrary();
registerSpec(spec_pwd.pwdSpec.name, () => spec_pwd.pwdSpec);
break;
case 'pyenv':
await spec_pyenv.loadLibrary();
registerSpec(spec_pyenv.pyenvSpec.name, () => spec_pyenv.pyenvSpec);
break;
case 'pytest':
await spec_pytest.loadLibrary();
registerSpec(spec_pytest.pytestSpec.name, () => spec_pytest.pytestSpec);
break;
case 'qodana':
await spec_qodana.loadLibrary();
registerSpec(spec_qodana.qodanaSpec.name, () => spec_qodana.qodanaSpec);
break;
case 'quasar':
await spec_quasar.loadLibrary();
registerSpec(spec_quasar.quasarSpec.name, () => spec_quasar.quasarSpec);
break;
case 'quickmail':
await spec_quickmail.loadLibrary();
registerSpec(spec_quickmail.quickmailSpec.name,
() => spec_quickmail.quickmailSpec);
break;
case 'railway':
await spec_railway.loadLibrary();
registerSpec(
spec_railway.railwaySpec.name, () => spec_railway.railwaySpec);
break;
case 'rake':
await spec_rake.loadLibrary();
registerSpec(spec_rake.rakeSpec.name, () => spec_rake.rakeSpec);
break;
case 'rbenv':
await spec_rbenv.loadLibrary();
registerSpec(spec_rbenv.rbenvSpec.name, () => spec_rbenv.rbenvSpec);
break;
case 'readlink':
await spec_readlink.loadLibrary();
registerSpec(
spec_readlink.readlinkSpec.name, () => spec_readlink.readlinkSpec);
break;
case 'remix':
await spec_remix.loadLibrary();
registerSpec(spec_remix.remixSpec.name, () => spec_remix.remixSpec);
break;
case 'remotion':
await spec_remotion.loadLibrary();
registerSpec(
spec_remotion.remotionSpec.name, () => spec_remotion.remotionSpec);
break;
case 'repeat':
await spec_repeat.loadLibrary();
registerSpec(spec_repeat.repeatSpec.name, () => spec_repeat.repeatSpec);
break;
case 'restore':
await spec_dotnet_dotnet_restore.loadLibrary();
registerSpec(spec_dotnet_dotnet_restore.restoreSpec.name,
() => spec_dotnet_dotnet_restore.restoreSpec);
break;
case 'rg':
await spec_rg.loadLibrary();
registerSpec(spec_rg.rgSpec.name, () => spec_rg.rgSpec);
break;
case 'rm':
await spec_rm.loadLibrary();
registerSpec(spec_rm.rmSpec.name, () => spec_rm.rmSpec);
break;
case 'rmdir':
await spec_rmdir.loadLibrary();
registerSpec(spec_rmdir.rmdirSpec.name, () => spec_rmdir.rmdirSpec);
break;
case 'robot':
await spec_robot.loadLibrary();
registerSpec(
spec_robot.completionSpec.name, () => spec_robot.completionSpec);
break;
case 'rojo':
await spec_rojo.loadLibrary();
registerSpec(spec_rojo.rojoSpec.name, () => spec_rojo.rojoSpec);
break;
case 'rollup':
await spec_rollup.loadLibrary();
registerSpec(spec_rollup.rollupSpec.name, () => spec_rollup.rollupSpec);
break;
case 'rome':
await spec_rome.loadLibrary();
registerSpec(spec_rome.romeSpec.name, () => spec_rome.romeSpec);
break;
case 'rsync':
await spec_rsync.loadLibrary();
registerSpec(spec_rsync.rsyncSpec.name, () => spec_rsync.rsyncSpec);
break;
case 'ruby':
await spec_ruby.loadLibrary();
registerSpec(spec_ruby.rubySpec.name, () => spec_ruby.rubySpec);
break;
case 'ruff':
await spec_ruff.loadLibrary();
registerSpec(spec_ruff.ruffSpec.name, () => spec_ruff.ruffSpec);
break;
case 'rushx':
await spec_rushx.loadLibrary();
registerSpec(spec_rushx.rushxSpec.name, () => spec_rushx.rushxSpec);
break;
case 'rustc':
await spec_rustc.loadLibrary();
registerSpec(spec_rustc.rustcSpec.name, () => spec_rustc.rustcSpec);
break;
case 'rvm':
await spec_rvm.loadLibrary();
registerSpec(spec_rvm.rvmSpec.name, () => spec_rvm.rvmSpec);
break;
case 'sake':
await spec_sake.loadLibrary();
registerSpec(spec_sake.sakeSpec.name, () => spec_sake.sakeSpec);
break;
case 'sam':
await spec_sam.loadLibrary();
registerSpec(spec_sam.samSpec.name, () => spec_sam.samSpec);
break;
case 'sanity':
await spec_sanity.loadLibrary();
registerSpec(spec_sanity.sanitySpec.name, () => spec_sanity.sanitySpec);
break;
case 'sapphire':
await spec_sapphire.loadLibrary();
registerSpec(
spec_sapphire.sapphireSpec.name, () => spec_sapphire.sapphireSpec);
break;
case 'scc':
await spec_scc.loadLibrary();
registerSpec(spec_scc.sccSpec.name, () => spec_scc.sccSpec);
break;
case 'scp':
await spec_scp.loadLibrary();
registerSpec(spec_scp.scpSpec.name, () => spec_scp.scpSpec);
break;
case 'screen':
await spec_screen.loadLibrary();
registerSpec(spec_screen.screenSpec.name, () => spec_screen.screenSpec);
break;
case 'sdc':
await spec_usermn_sdc_0_0_0.loadLibrary();
registerSpec(spec_usermn_sdc_0_0_0.usermnSds0Spec.name,
() => spec_usermn_sdc_0_0_0.usermnSds0Spec);
await spec_usermn_sdc_sdc.loadLibrary();
registerSpec(spec_usermn_sdc_sdc.usermnSdcSpec.name,
() => spec_usermn_sdc_sdc.usermnSdcSpec);
break;
case 'sed':
await spec_sed.loadLibrary();
registerSpec(spec_sed.sedSpec.name, () => spec_sed.sedSpec);
break;
case 'seq':
await spec_seq.loadLibrary();
registerSpec(spec_seq.seqSpec.name, () => spec_seq.seqSpec);
break;
case 'sequelize':
await spec_sequelize.loadLibrary();
registerSpec(spec_sequelize.sequelizeSpec.name,
() => spec_sequelize.sequelizeSpec);
break;
case 'serve':
await spec_serve.loadLibrary();
registerSpec(spec_serve.serveSpec.name, () => spec_serve.serveSpec);
break;
case 'serverless':
await spec_serverless.loadLibrary();
registerSpec(spec_serverless.serverlessSpec.name,
() => spec_serverless.serverlessSpec);
break;
case 'sfdx':
await spec_sfdx.loadLibrary();
registerSpec(spec_sfdx.sfdxSpec.name, () => spec_sfdx.sfdxSpec);
break;
case 'sftp':
await spec_sftp.loadLibrary();
registerSpec(spec_sftp.sftpSpec.name, () => spec_sftp.sftpSpec);
break;
case 'sha1sum':
await spec_sha1sum.loadLibrary();
registerSpec(
spec_sha1sum.sha1sumSpec.name, () => spec_sha1sum.sha1sumSpec);
break;
case 'shasum':
await spec_shasum.loadLibrary();
registerSpec(spec_shasum.shasumSpec.name, () => spec_shasum.shasumSpec);
break;
case 'shelve':
await spec_shelve.loadLibrary();
registerSpec(spec_shelve.shelveSpec.name, () => spec_shelve.shelveSpec);
break;
case 'shopify':
await spec_shopify_2_0_0.loadLibrary();
registerSpec(spec_shopify_2_0_0.shopifySpec.name,
() => spec_shopify_2_0_0.shopifySpec);
await spec_shopify_3_0_0.loadLibrary();
registerSpec(spec_shopify_3_0_0.shopifySpec.name,
() => spec_shopify_3_0_0.shopifySpec);
await spec_shopify_index.loadLibrary();
registerSpec(spec_shopify_index.completionSpec.name,
() => spec_shopify_index.completionSpec);
break;
case 'shortcuts':
await spec_shortcuts.loadLibrary();
registerSpec(spec_shortcuts.shortcutsSpec.name,
() => spec_shortcuts.shortcutsSpec);
break;
case 'shred':
await spec_shred.loadLibrary();
registerSpec(spec_shred.shredSpec.name, () => spec_shred.shredSpec);
break;
case 'sidekiq':
await spec_sidekiq.loadLibrary();
registerSpec(
spec_sidekiq.sidekiqSpec.name, () => spec_sidekiq.sidekiqSpec);
break;
case 'simctl':
await spec_simctl.loadLibrary();
registerSpec(spec_simctl.simctlSpec.name, () => spec_simctl.simctlSpec);
break;
case 'sips':
await spec_sips.loadLibrary();
registerSpec(spec_sips.sipsSpec.name, () => spec_sips.sipsSpec);
break;
case 'sl':
await spec_sl.loadLibrary();
registerSpec(spec_sl.slSpec.name, () => spec_sl.slSpec);
break;
case 'sls':
await spec_sls.loadLibrary();
registerSpec(spec_sls.slsSpec.name, () => spec_sls.slsSpec);
break;
case 'softwareupdate':
await spec_softwareupdate.loadLibrary();
registerSpec(spec_softwareupdate.softwareupdateSpec.name,
() => spec_softwareupdate.softwareupdateSpec);
break;
case 'sort':
await spec_sort.loadLibrary();
registerSpec(spec_sort.sortSpec.name, () => spec_sort.sortSpec);
break;
case 'source':
await spec_source.loadLibrary();
registerSpec(spec_source.sourceSpec.name, () => spec_source.sourceSpec);
break;
case 'space':
await spec_space.loadLibrary();
registerSpec(spec_space.spaceSpec.name, () => spec_space.spaceSpec);
break;
case 'speedtest':
await spec_speedtest.loadLibrary();
registerSpec(spec_speedtest.speedtestSpec.name,
() => spec_speedtest.speedtestSpec);
break;
case 'speedtest-cli':
await spec_speedtest_cli.loadLibrary();
registerSpec(spec_speedtest_cli.speedtestCliSpec.name,
() => spec_speedtest_cli.speedtestCliSpec);
break;
case 'splash-cli':
await spec_splash.loadLibrary();
registerSpec(
spec_splash.splashCliSpec.name, () => spec_splash.splashCliSpec);
break;
case 'split':
await spec_split.loadLibrary();
registerSpec(spec_split.splitSpec.name, () => spec_split.splitSpec);
break;
case 'spotify':
await spec_spotify.loadLibrary();
registerSpec(
spec_spotify.spotifySpec.name, () => spec_spotify.spotifySpec);
break;
case 'spring':
await spec_spring.loadLibrary();
registerSpec(spec_spring.springSpec.name, () => spec_spring.springSpec);
break;
case 'sqlfluff':
await spec_sqlfluff.loadLibrary();
registerSpec(
spec_sqlfluff.sqlfluffSpec.name, () => spec_sqlfluff.sqlfluffSpec);
break;
case 'sqlite3':
await spec_sqlite3.loadLibrary();
registerSpec(
spec_sqlite3.sqlite3Spec.name, () => spec_sqlite3.sqlite3Spec);
break;
case 'sqlmesh':
await spec_sqlmesh.loadLibrary();
registerSpec(
spec_sqlmesh.sqlmeshSpec.name, () => spec_sqlmesh.sqlmeshSpec);
break;
case 'src':
await spec_src.loadLibrary();
registerSpec(spec_src.srcSpec.name, () => spec_src.srcSpec);
break;
case 'ssh':
await spec_ssh.loadLibrary();
registerSpec(spec_ssh.sshSpec.name, () => spec_ssh.sshSpec);
break;
case 'ssh-keygen':
await spec_ssh_keygen.loadLibrary();
registerSpec(spec_ssh_keygen.sshKeygenSpec.name,
() => spec_ssh_keygen.sshKeygenSpec);
break;
case 'st2':
await spec_st2.loadLibrary();
registerSpec(spec_st2.st2Spec.name, () => spec_st2.st2Spec);
break;
case 'sta':
await spec_sta.loadLibrary();
registerSpec(spec_sta.staSpec.name, () => spec_sta.staSpec);
break;
case 'stack':
await spec_stack.loadLibrary();
registerSpec(spec_stack.stackSpec.name, () => spec_stack.stackSpec);
break;
case 'starkli':
await spec_starkli.loadLibrary();
registerSpec(
spec_starkli.starkliSpec.name, () => spec_starkli.starkliSpec);
break;
case 'start-storybook':
await spec_start_storybook.loadLibrary();
registerSpec(spec_start_storybook.startStorybookSpec.name,
() => spec_start_storybook.startStorybookSpec);
break;
case 'stat':
await spec_stat.loadLibrary();
registerSpec(spec_stat.statSpec.name, () => spec_stat.statSpec);
break;
case 'steadybit':
await spec_steadybit.loadLibrary();
registerSpec(spec_steadybit.steadybitSpec.name,
() => spec_steadybit.steadybitSpec);
break;
case 'stencil':
await spec_stencil.loadLibrary();
registerSpec(
spec_stencil.stencilSpec.name, () => spec_stencil.stencilSpec);
break;
case 'store':
await spec_dotnet_dotnet_store.loadLibrary();
registerSpec(spec_dotnet_dotnet_store.storeSpec.name,
() => spec_dotnet_dotnet_store.storeSpec);
break;
case 'stow':
await spec_stow.loadLibrary();
registerSpec(spec_stow.stowSpec.name, () => spec_stow.stowSpec);
break;
case 'streamlit':
await spec_streamlit.loadLibrary();
registerSpec(spec_streamlit.streamlitSpec.name,
() => spec_streamlit.streamlitSpec);
break;
case 'stripe':
await spec_stripe.loadLibrary();
registerSpec(spec_stripe.stripeSpec.name, () => spec_stripe.stripeSpec);
break;
case 'su':
await spec_su.loadLibrary();
registerSpec(spec_su.suSpec.name, () => spec_su.suSpec);
break;
case 'subl':
await spec_subl.loadLibrary();
registerSpec(spec_subl.sublSpec.name, () => spec_subl.sublSpec);
break;
case 'sudo':
await spec_sudo.loadLibrary();
registerSpec(spec_sudo.sudoSpec.name, () => spec_sudo.sudoSpec);
break;
case 'suitecloud':
await spec_suitecloud.loadLibrary();
registerSpec(spec_suitecloud.suitecloudSpec.name,
() => spec_suitecloud.suitecloudSpec);
break;
case 'supabase':
await spec_supabase.loadLibrary();
registerSpec(
spec_supabase.supabaseSpec.name, () => spec_supabase.supabaseSpec);
break;
case 'surreal':
await spec_surreal.loadLibrary();
registerSpec(
spec_surreal.surrealSpec.name, () => spec_surreal.surrealSpec);
break;
case 'svn':
await spec_svn.loadLibrary();
registerSpec(spec_svn.svnSpec.name, () => spec_svn.svnSpec);
break;
case 'svokit':
await spec_svokit.loadLibrary();
registerSpec(spec_svokit.svokitSpec.name, () => spec_svokit.svokitSpec);
break;
case 'sw_vers':
await spec_sw_vers.loadLibrary();
registerSpec(
spec_sw_vers.sw_versSpec.name, () => spec_sw_vers.sw_versSpec);
break;
case 'swagger-typescript-api':
await spec_swagger_typescript_api.loadLibrary();
registerSpec(spec_swagger_typescript_api.swaggerTypescriptApiSpec.name,
() => spec_swagger_typescript_api.swaggerTypescriptApiSpec);
await spec_swagger_typescript_api_1.loadLibrary();
registerSpec(spec_swagger_typescript_api_1.swaggerTypescriptApiSpec.name,
() => spec_swagger_typescript_api_1.swaggerTypescriptApiSpec);
break;
case 'swc':
await spec_swc.loadLibrary();
registerSpec(spec_swc.swcSpec.name, () => spec_swc.swcSpec);
break;
case 'swift':
await spec_swift.loadLibrary();
registerSpec(spec_swift.swiftSpec.name, () => spec_swift.swiftSpec);
break;
case 'symfony':
await spec_symfony.loadLibrary();
registerSpec(
spec_symfony.symfonySpec.name, () => spec_symfony.symfonySpec);
break;
case 'sysctl':
await spec_sysctl.loadLibrary();
registerSpec(spec_sysctl.sysctlSpec.name, () => spec_sysctl.sysctlSpec);
break;
case 'tac':
await spec_tac.loadLibrary();
registerSpec(spec_tac.tacSpec.name, () => spec_tac.tacSpec);
break;
case 'tail':
await spec_tail.loadLibrary();
registerSpec(spec_tail.tailSpec.name, () => spec_tail.tailSpec);
break;
case 'tailcall':
await spec_tailcall.loadLibrary();
registerSpec(
spec_tailcall.tailcallSpec.name, () => spec_tailcall.tailcallSpec);
break;
case 'tailwindcss':
await spec_tailwindcss.loadLibrary();
registerSpec(spec_tailwindcss.tailwindcssSpec.name,
() => spec_tailwindcss.tailwindcssSpec);
break;
case 'tangram':
await spec_tangram.loadLibrary();
registerSpec(
spec_tangram.tangramSpec.name, () => spec_tangram.tangramSpec);
break;
case 'taplo':
await spec_taplo.loadLibrary();
registerSpec(spec_taplo.taploSpec.name, () => spec_taplo.taploSpec);
break;
case 'tar':
await spec_tar.loadLibrary();
registerSpec(spec_tar.tarSpec.name, () => spec_tar.tarSpec);
break;
case 'task':
await spec_task.loadLibrary();
registerSpec(spec_task.taskSpec.name, () => spec_task.taskSpec);
break;
case 'taskwarrior':
await spec_task_taskwarrior.loadLibrary();
registerSpec(spec_task_taskwarrior.taskwarriorSpec.name,
() => spec_task_taskwarrior.taskwarriorSpec);
await spec_task_taskwarrior_1.loadLibrary();
registerSpec(spec_task_taskwarrior_1.taskwarriorSpec.name,
() => spec_task_taskwarrior_1.taskwarriorSpec);
break;
case 'tb':
await spec_tb.loadLibrary();
registerSpec(spec_tb.tbSpec.name, () => spec_tb.tbSpec);
break;
case 'tccutil':
await spec_tccutil.loadLibrary();
registerSpec(
spec_tccutil.tccutilSpec.name, () => spec_tccutil.tccutilSpec);
break;
case 'tee':
await spec_tee.loadLibrary();
registerSpec(spec_tee.teeSpec.name, () => spec_tee.teeSpec);
break;
case 'tfenv':
await spec_tfenv.loadLibrary();
registerSpec(spec_tfenv.tfenvSpec.name, () => spec_tfenv.tfenvSpec);
break;
case 'then':
await spec_then.loadLibrary();
registerSpec(spec_then.thenSpec.name, () => spec_then.thenSpec);
break;
case 'time':
await spec_time.loadLibrary();
registerSpec(spec_time.timeSpec.name, () => spec_time.timeSpec);
break;
case 'tkn':
await spec_tkn.loadLibrary();
registerSpec(spec_tkn.tknSpec.name, () => spec_tkn.tknSpec);
break;
case 'tldr':
await spec_tldr.loadLibrary();
registerSpec(spec_tldr.tldrSpec.name, () => spec_tldr.tldrSpec);
break;
case 'tmutil':
await spec_tmutil.loadLibrary();
registerSpec(spec_tmutil.tmutilSpec.name, () => spec_tmutil.tmutilSpec);
break;
case 'tmux':
await spec_tmux.loadLibrary();
registerSpec(spec_tmux.tmuxSpec.name, () => spec_tmux.tmuxSpec);
break;
case 'tmuxinator':
await spec_tmuxinator.loadLibrary();
registerSpec(spec_tmuxinator.tmuxinatorSpec.name,
() => spec_tmuxinator.tmuxinatorSpec);
break;
case 'tns':
await spec_tns.loadLibrary();
registerSpec(spec_tns.tnsSpec.name, () => spec_tns.tnsSpec);
break;
case 'tokei':
await spec_tokei.loadLibrary();
registerSpec(spec_tokei.tokeiSpec.name, () => spec_tokei.tokeiSpec);
break;
case 'top':
await spec_top.loadLibrary();
registerSpec(spec_top.topSpec.name, () => spec_top.topSpec);
break;
case 'touch':
await spec_touch.loadLibrary();
registerSpec(spec_touch.touchSpec.name, () => spec_touch.touchSpec);
break;
case 'tr':
await spec_tr.loadLibrary();
registerSpec(spec_tr.trSpec.name, () => spec_tr.trSpec);
break;
case 'traceroute':
await spec_traceroute.loadLibrary();
registerSpec(spec_traceroute.tracerouteSpec.name,
() => spec_traceroute.tracerouteSpec);
break;
case 'trap':
await spec_trap.loadLibrary();
registerSpec(spec_trap.trapSpec.name, () => spec_trap.trapSpec);
break;
case 'trash':
await spec_trash.loadLibrary();
registerSpec(spec_trash.trashSpec.name, () => spec_trash.trashSpec);
break;
case 'tree':
await spec_tree.loadLibrary();
registerSpec(spec_tree.treeSpec.name, () => spec_tree.treeSpec);
break;
case 'trex':
await spec_trex.loadLibrary();
registerSpec(spec_trex.trexSpec.name, () => spec_trex.trexSpec);
break;
case 'truffle':
await spec_truffle.loadLibrary();
registerSpec(
spec_truffle.truffleSpec.name, () => spec_truffle.truffleSpec);
break;
case 'truncate':
await spec_truncate.loadLibrary();
registerSpec(
spec_truncate.truncateSpec.name, () => spec_truncate.truncateSpec);
break;
case 'trunk':
await spec_trunk.loadLibrary();
registerSpec(spec_trunk.trunkSpec.name, () => spec_trunk.trunkSpec);
break;
case 'ts-node':
await spec_ts_node.loadLibrary();
registerSpec(spec_ts_node.tsNodeSpec.name, () => spec_ts_node.tsNodeSpec);
break;
case 'tsc':
await spec_tsc.loadLibrary();
registerSpec(spec_tsc.tscSpec.name, () => spec_tsc.tscSpec);
break;
case 'tsx':
await spec_tsx.loadLibrary();
registerSpec(spec_tsx.tsxSpec.name, () => spec_tsx.tsxSpec);
break;
case 'tuist':
await spec_tuist.loadLibrary();
registerSpec(spec_tuist.tuistSpec.name, () => spec_tuist.tuistSpec);
break;
case 'turbo':
await spec_turbo.loadLibrary();
registerSpec(spec_turbo.turboSpec.name, () => spec_turbo.turboSpec);
break;
case 'twiggy':
await spec_twiggy.loadLibrary();
registerSpec(spec_twiggy.twiggySpec.name, () => spec_twiggy.twiggySpec);
break;
case 'typeorm':
await spec_typeorm.loadLibrary();
registerSpec(
spec_typeorm.typeormSpec.name, () => spec_typeorm.typeormSpec);
break;
case 'typos':
await spec_typos.loadLibrary();
registerSpec(spec_typos.typosSpec.name, () => spec_typos.typosSpec);
break;
case 'typst':
await spec_typst.loadLibrary();
registerSpec(spec_typst.typstSpec.name, () => spec_typst.typstSpec);
break;
case 'ua':
await spec_ua.loadLibrary();
registerSpec(spec_ua.uaSpec.name, () => spec_ua.uaSpec);
break;
case 'ubuntu-advantage':
await spec_ubuntu_advantage.loadLibrary();
registerSpec(spec_ubuntu_advantage.ubuntuAdvantageSpec.name,
() => spec_ubuntu_advantage.ubuntuAdvantageSpec);
break;
case 'uname':
await spec_uname.loadLibrary();
registerSpec(spec_uname.unameSpec.name, () => spec_uname.unameSpec);
break;
case 'uniq':
await spec_uniq.loadLibrary();
registerSpec(spec_uniq.uniqSpec.name, () => spec_uniq.uniqSpec);
break;
case 'unix2dos':
await spec_unix2dos.loadLibrary();
registerSpec(
spec_unix2dos.unix2dosSpec.name, () => spec_unix2dos.unix2dosSpec);
break;
case 'unset':
await spec_unset.loadLibrary();
registerSpec(spec_unset.unsetSpec.name, () => spec_unset.unsetSpec);
break;
case 'until':
await spec_until.loadLibrary();
registerSpec(spec_until.untilSpec.name, () => spec_until.untilSpec);
break;
case 'unzip':
await spec_unzip.loadLibrary();
registerSpec(spec_unzip.unzipSpec.name, () => spec_unzip.unzipSpec);
break;
case 'uv':
await spec_uv.loadLibrary();
registerSpec(spec_uv.uvSpec.name, () => spec_uv.uvSpec);
break;
case 'v':
await spec_v.loadLibrary();
registerSpec(spec_v.vSpec.name, () => spec_v.vSpec);
break;
case 'vale':
await spec_vale.loadLibrary();
registerSpec(spec_vale.valeSpec.name, () => spec_vale.valeSpec);
break;
case 'vapor':
await spec_vapor.loadLibrary();
registerSpec(spec_vapor.vaporSpec.name, () => spec_vapor.vaporSpec);
break;
case 'vault':
await spec_vault.loadLibrary();
registerSpec(spec_vault.vaultSpec.name, () => spec_vault.vaultSpec);
break;
case 'vela':
await spec_vela.loadLibrary();
registerSpec(spec_vela.velaSpec.name, () => spec_vela.velaSpec);
break;
case 'vercel':
await spec_vercel.loadLibrary();
registerSpec(spec_vercel.vercelSpec.name, () => spec_vercel.vercelSpec);
break;
case 'vi':
await spec_vi.loadLibrary();
registerSpec(spec_vi.viSpec.name, () => spec_vi.viSpec);
break;
case 'vim':
await spec_vim.loadLibrary();
registerSpec(spec_vim.vimSpec.name, () => spec_vim.vimSpec);
break;
case 'vimr':
await spec_vimr.loadLibrary();
registerSpec(spec_vimr.vimrSpec.name, () => spec_vimr.vimrSpec);
break;
case 'visudo':
await spec_visudo.loadLibrary();
registerSpec(spec_visudo.visudoSpec.name, () => spec_visudo.visudoSpec);
break;
case 'vite':
await spec_vite.loadLibrary();
registerSpec(spec_vite.viteSpec.name, () => spec_vite.viteSpec);
break;
case 'volta':
await spec_volta.loadLibrary();
registerSpec(spec_volta.voltaSpec.name, () => spec_volta.voltaSpec);
break;
case 'vr':
await spec_vr.loadLibrary();
registerSpec(spec_vr.vrSpec.name, () => spec_vr.vrSpec);
break;
case 'vtex':
await spec_vtex.loadLibrary();
registerSpec(spec_vtex.vtexSpec.name, () => spec_vtex.vtexSpec);
break;
case 'vue':
await spec_vue.loadLibrary();
registerSpec(spec_vue.vueSpec.name, () => spec_vue.vueSpec);
break;
case 'w':
await spec_w.loadLibrary();
registerSpec(spec_w.wSpec.name, () => spec_w.wSpec);
break;
case 'wasm-bindgen':
await spec_wasm_bindgen.loadLibrary();
registerSpec(spec_wasm_bindgen.wasmBindgenSpec.name,
() => spec_wasm_bindgen.wasmBindgenSpec);
break;
case 'wasm-pack':
await spec_wasm_pack.loadLibrary();
registerSpec(
spec_wasm_pack.wasmPackSpec.name, () => spec_wasm_pack.wasmPackSpec);
break;
case 'watchman':
await spec_watchman.loadLibrary();
registerSpec(
spec_watchman.watchmanSpec.name, () => spec_watchman.watchmanSpec);
break;
case 'wc':
await spec_wc.loadLibrary();
registerSpec(spec_wc.wcSpec.name, () => spec_wc.wcSpec);
break;
case 'wd':
await spec_wd.loadLibrary();
registerSpec(spec_wd.wdSpec.name, () => spec_wd.wdSpec);
break;
case 'webpack':
await spec_webpack.loadLibrary();
registerSpec(
spec_webpack.webpackSpec.name, () => spec_webpack.webpackSpec);
break;
case 'wezterm':
await spec_wezterm.loadLibrary();
registerSpec(
spec_wezterm.weztermSpec.name, () => spec_wezterm.weztermSpec);
break;
case 'wget':
await spec_wget.loadLibrary();
registerSpec(spec_wget.wgetSpec.name, () => spec_wget.wgetSpec);
break;
case 'whence':
await spec_whence.loadLibrary();
registerSpec(spec_whence.whenceSpec.name, () => spec_whence.whenceSpec);
break;
case 'where':
await spec_where.loadLibrary();
registerSpec(spec_where.whereSpec.name, () => spec_where.whereSpec);
break;
case 'whereis':
await spec_whereis.loadLibrary();
registerSpec(
spec_whereis.whereisSpec.name, () => spec_whereis.whereisSpec);
break;
case 'which':
await spec_which.loadLibrary();
registerSpec(spec_which.whichSpec.name, () => spec_which.whichSpec);
break;
case 'while':
await spec_while.loadLibrary();
registerSpec(spec_while.whileSpec.name, () => spec_while.whileSpec);
break;
case 'who':
await spec_who.loadLibrary();
registerSpec(spec_who.whoSpec.name, () => spec_who.whoSpec);
break;
case 'whois':
await spec_whois.loadLibrary();
registerSpec(spec_whois.whoisSpec.name, () => spec_whois.whoisSpec);
break;
case 'wifi-password':
await spec_wifi_password.loadLibrary();
registerSpec(spec_wifi_password.wifiPasswordSpec.name,
() => spec_wifi_password.wifiPasswordSpec);
break;
case 'wing':
await spec_wing.loadLibrary();
registerSpec(spec_wing.wingSpec.name, () => spec_wing.wingSpec);
break;
case 'wp':
await spec_wp.loadLibrary();
registerSpec(spec_wp.wpSpec.name, () => spec_wp.wpSpec);
break;
case 'wrangler':
await spec_wrangler.loadLibrary();
registerSpec(
spec_wrangler.wranglerSpec.name, () => spec_wrangler.wranglerSpec);
break;
case 'wrk':
await spec_wrk.loadLibrary();
registerSpec(spec_wrk.wrkSpec.name, () => spec_wrk.wrkSpec);
break;
case 'wscat':
await spec_wscat.loadLibrary();
registerSpec(spec_wscat.wscatSpec.name, () => spec_wscat.wscatSpec);
break;
case 'xargs':
await spec_xargs.loadLibrary();
registerSpec(spec_xargs.xargsSpec.name, () => spec_xargs.xargsSpec);
break;
case 'xc':
await spec_xc.loadLibrary();
registerSpec(spec_xc.xcSpec.name, () => spec_xc.xcSpec);
break;
case 'xcode-select':
await spec_xcode_select.loadLibrary();
registerSpec(spec_xcode_select.xcodeSelectSpec.name,
() => spec_xcode_select.xcodeSelectSpec);
break;
case 'xcodebuild':
await spec_xcodebuild.loadLibrary();
registerSpec(spec_xcodebuild.xcodebuildSpec.name,
() => spec_xcodebuild.xcodebuildSpec);
break;
case 'xcodeproj':
await spec_xcodeproj.loadLibrary();
registerSpec(spec_xcodeproj.xcodeprojSpec.name,
() => spec_xcodeproj.xcodeprojSpec);
break;
case 'xcodes':
await spec_xcodes.loadLibrary();
registerSpec(spec_xcodes.xcodesSpec.name, () => spec_xcodes.xcodesSpec);
break;
case 'xcrun':
await spec_xcrun.loadLibrary();
registerSpec(spec_xcrun.xcrunSpec.name, () => spec_xcrun.xcrunSpec);
break;
case 'xdg-mime':
await spec_xdg_mime.loadLibrary();
registerSpec(
spec_xdg_mime.xdgMimeSpec.name, () => spec_xdg_mime.xdgMimeSpec);
break;
case 'xdg-open':
await spec_xdg_open.loadLibrary();
registerSpec(
spec_xdg_open.xdgOpenSpec.name, () => spec_xdg_open.xdgOpenSpec);
break;
case 'xed':
await spec_xed.loadLibrary();
registerSpec(spec_xed.xedSpec.name, () => spec_xed.xedSpec);
break;
case 'xxd':
await spec_xxd.loadLibrary();
registerSpec(spec_xxd.xxdSpec.name, () => spec_xxd.xxdSpec);
break;
case 'yalc':
await spec_yalc.loadLibrary();
registerSpec(spec_yalc.yalcSpec.name, () => spec_yalc.yalcSpec);
break;
case 'yank':
await spec_yank.loadLibrary();
registerSpec(spec_yank.yankSpec.name, () => spec_yank.yankSpec);
break;
case 'yarn':
await spec_yarn.loadLibrary();
registerSpec(spec_yarn.yarnSpec.name, () => spec_yarn.yarnSpec);
break;
case 'ykman':
await spec_ykman.loadLibrary();
registerSpec(spec_ykman.ykmanSpec.name, () => spec_ykman.ykmanSpec);
break;
case 'yo':
await spec_yo.loadLibrary();
registerSpec(spec_yo.yoSpec.name, () => spec_yo.yoSpec);
break;
case 'yomo':
await spec_yomo.loadLibrary();
registerSpec(spec_yomo.yomoSpec.name, () => spec_yomo.yomoSpec);
break;
case 'youtube-dl':
await spec_youtube_dl.loadLibrary();
registerSpec(spec_youtube_dl.youtubeDlSpec.name,
() => spec_youtube_dl.youtubeDlSpec);
break;
case 'z':
await spec_z.loadLibrary();
registerSpec(spec_z.zShSpec.name, () => spec_z.zShSpec);
break;
case 'zapier-platform-cli':
await spec_zapier.loadLibrary();
registerSpec(spec_zapier.zapierPlatformCliSpec.name,
() => spec_zapier.zapierPlatformCliSpec);
break;
case 'zed':
await spec_zed.loadLibrary();
registerSpec(spec_zed.zedSpec.name, () => spec_zed.zedSpec);
break;
case 'zig':
await spec_zig.loadLibrary();
registerSpec(spec_zig.zigSpec.name, () => spec_zig.zigSpec);
break;
case 'zip':
await spec_zip.loadLibrary();
registerSpec(spec_zip.zipSpec.name, () => spec_zip.zipSpec);
break;
case 'zipcloak':
await spec_zipcloak.loadLibrary();
registerSpec(
spec_zipcloak.zipcloakSpec.name, () => spec_zipcloak.zipcloakSpec);
break;
case 'zoxide':
await spec_zoxide.loadLibrary();
registerSpec(spec_zoxide.zoxideSpec.name, () => spec_zoxide.zoxideSpec);
break;
default:
break;
}
}