nuget add source --username USERNAME --password ${{ secrets.GITHUB_TOKEN }} --store-password-in-clear-text --name github "https://nuget.pkg.github.com/NAMESPACE/index.json"/: GitHub’s official command line tools

"Skip to content
cli
/
cli

Type / to search

Code
Issues
494
Pull requests
20
Discussions
Actions
Projects
Security
1
Insights

cli
Public
cli/cli

t
Add file
Folders and files
Name
Latest commit

dependabot[bot]
build(deps): bump actions/cache from 3 to 4 (#8594)
32ab65f
 · 
3 hours ago
History
.devcontainer
Align devcontainer Go version with go.mod (#8570)
last week
.github
build(deps): bump actions/cache from 3 to 4 (#8594)
3 hours ago
api
Rename authCfg.Token to authCfg.ActiveToken and authCfg.SetToken to a…
last month
build/windows
New deployment workflow
8 months ago
cmd
Remove redundant error on migration failure
last month
context
gh pr create duplicates targets if there are duplicate remotes (#8184)
3 months ago
docs
Fix some typos raised by codespell
yesterday
git
Simplify git AddRemote to remove unused arg (#8392)
last month
internal
Fix some typos raised by codespell
yesterday
pkg
Add force flag to setup-git command (#8552)
7 hours ago
script
Fix some typos raised by codespell
yesterday
test
Pass web browser to each individual command
3 years ago
utils
Add headers to all tables (#8157)
3 months ago
.gitattributes
Retire copy-release-to-another-repo action
4 years ago
.gitignore
New deployment workflow
8 months ago
.golangci.yml
Re-enable linters now that golangci-lint has been updated (#5615)
2 years ago
.goreleaser.yml
Update deployment workflow for final HSM solution
last month
LICENSE
Create LICENSE
5 years ago
Makefile
Make: Fix target name for Windows platform (#7370)
8 months ago
README.md
Add Webi as an option for installation (#8555)
3 days ago
go.mod
build(deps): bump golang.org/x/crypto from 0.14.0 to 0.17.0 (#8473)
2 weeks ago
go.sum
build(deps): bump golang.org/x/crypto from 0.14.0 to 0.17.0 (#8473)
2 weeks ago
Repository files navigation
README
Code of conduct
MIT license
Security
GitHub CLI
gh is GitHub on the command line. It brings pull requests, issues, and other GitHub concepts to the terminal next to where you are already working with git and your code.

GitHub CLI is supported for users on GitHub.com and GitHub Enterprise Server 2.20+ with support for macOS, Windows, and Linux.

Documentation
For installation options see below, for usage instructions see the manual.

Contributing
If anything feels off, or if you feel that some functionality is missing, please check out the contributing page. There you will find instructions for sharing your feedback, building the tool locally, and submitting pull requests to the project.

If you are a hubber and are interested in shipping new commands for the CLI, check out our doc on internal contributions.

Installation
macOS
gh is available via Homebrew, MacPorts, Conda, Spack, Webi, and as a downloadable binary from the releases page.

Homebrew
Install: Upgrade:
brew install gh brew upgrade gh
MacPorts
Install: Upgrade:
sudo port install gh sudo port selfupdate && sudo port upgrade gh
Conda
Install: Upgrade:
conda install gh --channel conda-forge conda update gh --channel conda-forge
Additional Conda installation options available on the gh-feedstock page.

Spack
Install: Upgrade:
spack install gh spack uninstall gh && spack install gh
Webi
Install: Upgrade:
curl -sS https://webi.sh/gh | sh webi gh@stable
For more information about the Webi installer see its homepage.

Linux & BSD
gh is available via:

our Debian and RPM repositories;
community-maintained repositories in various Linux distros;
OS-agnostic package managers such as Homebrew, Conda, Spack, Webi; and
our releases page as precompiled binaries.
For more information, see Linux & BSD installation.

Windows
gh is available via WinGet, scoop, Chocolatey, Conda, Webi, and as downloadable MSI.

WinGet
Install: Upgrade:
winget install --id GitHub.cli winget upgrade --id GitHub.cli
Note
The Windows installer modifies your PATH. When using Windows Terminal, you will need to open a new window for the changes to take effect. (Simply opening a new tab will not be sufficient.)

scoop
Install: Upgrade:
scoop install gh scoop update gh
Chocolatey
Install: Upgrade:
choco install gh choco upgrade gh
Signed MSI
MSI installers are available for download on the releases page.

Codespaces
To add GitHub CLI to your codespace, add the following to your devcontainer file:

"features": {
"ghcr.io/devcontainers/features/github-cli:1": {}
}
GitHub Actions
GitHub CLI comes pre-installed in all GitHub-Hosted Runners.

Other platforms
Download packaged binaries from the releases page.

Build from source
See here on how to build GitHub CLI from source.

Comparison with hub
For many years, hub was the unofficial GitHub CLI tool. gh is a new project that helps us explore what an official GitHub CLI tool can look like with a fundamentally different design. While both tools bring GitHub to the terminal, hub behaves as a proxy to git, and gh is a standalone tool. Check out our more detailed explanation to learn more.

About
GitHub’s official command line tool

cli.github.com
Topics
git cli golang github-api-v4
Resources
Readme
License
MIT license
Code of conduct
Code of conduct
Security policy
Security policy
Activity
Custom properties
Stars
34.3k stars
Watchers
866 watching
Forks
5.9k forks
Report repository
Releases 145
GitHub CLI 2.42.1
Latest
2 days ago

• 144 releases
  Contributors
  467

• 453 contributors
  Languages
  Go
  99.7%

Other
0.3%
Footer
© 2024 GitHub, Inc.
Footer navigation
Terms
Privacy
Security
Status
Docs
Contact
Manage cookies
Do not share my personal information
"
https://github.com/cli/cli#:~:text=Skip%20to%20content,my%20personal%20information
/*****************************************************************
|
| Virtual ZIP file HTTP Server
|
| (c) 2001-2014 Gilles Boccon-Gibod
| Author: Gilles Boccon-Gibod (bok@bok.net)
|
****************************************************************/

/----------------------------------------------------------------------
| includes
+---------------------------------------------------------------------/
#include "Neptune.h"

/----------------------------------------------------------------------
| logging
+---------------------------------------------------------------------/
NPT_SET_LOCAL_LOGGER("neptune.ziphttpserver")

/----------------------------------------------------------------------
| GetContentType
+---------------------------------------------------------------------/
struct FileTypeMapEntry {
const char* extension;
const char* mime_type;
};
static const FileTypeMapEntry
DefaultFileTypeMap[] = {
{"xml", "text/xml" },
{"htm", "text/html" },
{"html", "text/html" },
{"c", "text/plain"},
{"h", "text/plain"},
{"txt", "text/plain"},
{"css", "text/css" },
{"gif", "image/gif" },
{"thm", "image/jpeg"},
{"png", "image/png"},
{"tif", "image/tiff"},
{"tiff", "image/tiff"},
{"jpg", "image/jpeg"},
{"jpeg", "image/jpeg"},
{"jpe", "image/jpeg"},
{"jp2", "image/jp2" },
{"png", "image/png" },
{"bmp", "image/bmp" },
{"aif", "audio/x-aiff"},
{"aifc", "audio/x-aiff"},
{"aiff", "audio/x-aiff"},
{"mpa", "audio/mpeg"},
{"mp2", "audio/mpeg"},
{"mp3", "audio/mpeg"},
{"m4a", "audio/mp4"},
{"wma", "audio/x-ms-wma"},
{"wav", "audio/x-wav"},
{"mpeg", "video/mpeg"},
{"mpg", "video/mpeg"},
{"mp4", "video/mp4"},
{"m4v", "video/mp4"},
{"m4f", "video/mp4"},
{"m4s", "video/mp4"},
{"ts", "video/MP2T"}, // RFC 3555
{"mov", "video/quicktime"},
{"wmv", "video/x-ms-wmv"},
{"asf", "video/x-ms-asf"},
{"avi", "video/x-msvideo"},
{"divx", "video/x-msvideo"},
{"xvid", "video/x-msvideo"},
{"doc", "application/msword"},
{"js", "application/javascript"},
{"m3u8", "application/x-mpegURL"},
{"pdf", "application/pdf"},
{"ps", "application/postscript"},
{"eps", "application/postscript"},
{"zip", "application/zip"},
{"mpd", "application/dash+xml"}
};

NPT_Map<NPT_String, NPT_String> FileTypeMap;

static const char*
GetContentType(const NPT_String& filename)
{
int last_dot = filename.ReverseFind('.');
if (last_dot > 0) {
NPT_String extension = filename.GetChars()+last_dot+1;
extension.MakeLowercase();

    NPT_String* mime_type;
    if (NPT_SUCCEEDED(FileTypeMap.Get(extension, mime_type))) {
        return mime_type->GetChars();
    }
}

return "application/octet-stream";

}

/----------------------------------------------------------------------
| ZipRequestHandler
+---------------------------------------------------------------------/
class ZipRequestHandler : public NPT_HttpRequestHandler
{
public:
// constructors
ZipRequestHandler(const char* url_root,
const char* file_root) :
m_UrlRoot(url_root),
m_FileRoot(file_root) {}

// NPT_HttpRequestHandler methods
virtual NPT_Result SetupResponse(NPT_HttpRequest&              request, 
                                 const NPT_HttpRequestContext& context,
                                 NPT_HttpResponse&             response);

private:
NPT_String m_UrlRoot;
NPT_String m_FileRoot;
};

/----------------------------------------------------------------------
| ZipRequestHandler::SetupResponse
+---------------------------------------------------------------------/
NPT_Result
ZipRequestHandler::SetupResponse(NPT_HttpRequest& request,
const NPT_HttpRequestContext& /context/,
NPT_HttpResponse& response)
{
NPT_HttpEntity* entity = response.GetEntity();
if (entity == NULL) return NPT_ERROR_INVALID_STATE;

// check the method
if (request.GetMethod() != NPT_HTTP_METHOD_GET &&
    request.GetMethod() != NPT_HTTP_METHOD_HEAD) {
    response.SetStatus(405, "Method Not Allowed");
    return NPT_SUCCESS;
}

// set some default headers
response.GetHeaders().SetHeader(NPT_HTTP_HEADER_ACCEPT_RANGES, "bytes");

// declare HTTP/1.1 if the client asked for it
if (request.GetProtocol() == NPT_HTTP_PROTOCOL_1_1) {
    response.SetProtocol(NPT_HTTP_PROTOCOL_1_1);
}

// default status
response.SetStatus(404, "Not Found");

// check that the request's path is an entry under the url root
if (!request.GetUrl().GetPath().StartsWith(m_UrlRoot)) {
    return NPT_ERROR_INVALID_PARAMETERS;
}

// compute the path relative to the URL root
NPT_String relative_path = NPT_Url::PercentDecode(request.GetUrl().GetPath().GetChars()+m_UrlRoot.GetLength());

// check that there is no '..' in the path, for security reasons
if (relative_path.Find("..") >= 0) {
    NPT_LOG_INFO(".. in path is not supported");
    return NPT_SUCCESS;
}
// check that the path does not end with a /
if (relative_path.EndsWith("/")) {
    NPT_LOG_INFO("skipping paths that end in /");
    return NPT_SUCCESS;
}
NPT_List<NPT_String> path_parts = relative_path.Split("/");

// walk down the path until we find a file
NPT_String path = m_FileRoot;
NPT_String subpath;
NPT_List<NPT_String>::Iterator fragment = path_parts.GetFirstItem();
bool anchor_found = false;
bool is_zip = false;
for (; fragment; ++fragment) {
    if (!anchor_found) {
        path += '/';
        path += *fragment;

        // get info about the file
        NPT_FileInfo info;
        NPT_File::GetInfo(path, &info);
        if (info.m_Type == NPT_FileInfo::FILE_TYPE_DIRECTORY) {
            continue;
        } else if (info.m_Type == NPT_FileInfo::FILE_TYPE_REGULAR) {
            anchor_found = true;
            if (path.EndsWith(".zip", true)) {
                // this is a zip file
                is_zip = true;
            }
        } else {
            return NPT_SUCCESS;
        }
    } else {
        if (!subpath.IsEmpty()) {
            subpath += '/';
        }
        subpath += *fragment;
    }
}
NPT_LOG_FINE_3("is_zip=%d, path=%s, subpath=%s", (int)is_zip, path.GetChars(), subpath.GetChars());

// return now if no anchor was found
if (!anchor_found) {
    return NPT_SUCCESS;
}

// deal with regular files
if (!is_zip) {
    if (subpath.IsEmpty()) {
        // open the file
        NPT_File file(path);
        NPT_Result result = file.Open(NPT_FILE_OPEN_MODE_READ);
        if (NPT_FAILED(result)) {
            NPT_LOG_FINE("file not found");
            return NPT_SUCCESS;
        }
        NPT_InputStreamReference file_stream;
        file.GetInputStream(file_stream);
        entity->SetInputStream(file_stream, true);
        entity->SetContentType(GetContentType(path));
        response.SetStatus(200, "OK");
    }
    return NPT_SUCCESS;
}

// load the zip file
NPT_File file(path);
NPT_Result result = file.Open(NPT_FILE_OPEN_MODE_READ);
if (NPT_FAILED(result)) {
    NPT_LOG_WARNING_1("failed to open file (%d)", result);
    return result;
}
NPT_InputStreamReference zip_stream;
file.GetInputStream(zip_stream);
NPT_ZipFile* zip_file = NULL;
result = NPT_ZipFile::Parse(*zip_stream, zip_file);
if (NPT_FAILED(result)) {
    NPT_LOG_WARNING_1("failed to parse zip file (%d)", result);
    return result;
}

// look for the entry in the zip file
for (unsigned int i=0; i<zip_file->GetEntries().GetItemCount(); i++) {
    NPT_ZipFile::Entry& entry = zip_file->GetEntries()[i];
    if (subpath == entry.m_Name) {
        // send the file
        NPT_InputStream* file_stream = NULL;
        result = NPT_ZipFile::GetInputStream(entry, zip_stream, file_stream);
        if (NPT_FAILED(result)) {
            NPT_LOG_WARNING_1("failed to get the file stream (%d)", result);
            delete zip_file;
            return result;
        }
        NPT_InputStreamReference file_stream_ref(file_stream);
        entity->SetInputStream(file_stream_ref, true);
        entity->SetContentType(GetContentType(subpath));
        response.SetStatus(200, "OK");
        break;
    }
}

delete zip_file;
return NPT_SUCCESS;

}

/----------------------------------------------------------------------
| ZipHttpWorker
+---------------------------------------------------------------------/
class ZipHttpServer;
class ZipHttpWorker : public NPT_Thread {
public:
// types
enum {
IDLE,
RUNNING,
DEAD
} State;

// constructor
ZipHttpWorker(unsigned int id, ZipHttpServer* server) :
    m_Id(id),
    m_Server(server),
    m_State(IDLE),
    m_Verbose(false) {}

// NPT_Runnable methods
virtual void Run();
NPT_Result Respond();

// members
unsigned int              m_Id;
ZipHttpServer*            m_Server;
NPT_SharedVariable        m_State;
NPT_InputStreamReference  m_InputStream;
NPT_OutputStreamReference m_OutputStream;
NPT_HttpRequestContext    m_Context;
bool                      m_Verbose;

};

/----------------------------------------------------------------------
| ZipHttpServer
+---------------------------------------------------------------------/
class ZipHttpServer : public NPT_HttpServer {
public:
ZipHttpServer(const char* file_root,
const char* url_root,
unsigned int port,
unsigned int threads);

void Loop();
void OnWorkerDone(ZipHttpWorker* worker);

private:
NPT_Mutex m_Lock;
unsigned int m_Threads;
ZipRequestHandler* m_Handler;
NPT_List<ZipHttpWorker*> m_Workers;
NPT_List<ZipHttpWorker*> m_ReadyWorkers;
NPT_SharedVariable m_AllWorkersBusy;
};

/----------------------------------------------------------------------
| ZipHttpServer::ZipHttpServer
+---------------------------------------------------------------------/
ZipHttpServer::ZipHttpServer(const char* file_root,
const char* url_root,
unsigned int port,
unsigned int threads) :
NPT_HttpServer(port),
m_Threads(threads),
m_AllWorkersBusy(0)
{
m_Handler = new ZipRequestHandler(url_root, file_root);
AddRequestHandler(m_Handler, url_root, true);

for (unsigned int i=0; i<threads; i++) {
    ZipHttpWorker* worker = new ZipHttpWorker(i, this);
    m_Workers.Add(worker);
    m_ReadyWorkers.Add(worker);
    
    // start threads unless we're single threaded
    if (threads > 1) {
        worker->Start();
    }
}

}

/----------------------------------------------------------------------
| ZipHttpServer::Loop
+---------------------------------------------------------------------/
void
ZipHttpServer::Loop()
{
for (;;) {
// wait until at least one worker is ready
if (m_AllWorkersBusy.GetValue() == 1) {
NPT_LOG_FINEST("all workers busy");
}
NPT_LOG_FINEST("waiting for a worker");
m_AllWorkersBusy.WaitUntilEquals(0);
NPT_LOG_FINEST("got a worker");

    // pick a worker
    m_Lock.Lock();
    ZipHttpWorker* worker = NULL;
    m_ReadyWorkers.PopHead(worker);
    if (m_ReadyWorkers.GetItemCount() == 0) {
        m_AllWorkersBusy.SetValue(1);
    }
    m_Lock.Unlock();
    
    NPT_Result result = WaitForNewClient(worker->m_InputStream, worker->m_OutputStream, &worker->m_Context);
    if (NPT_FAILED(result)) {
        NPT_LOG_WARNING_1("WaitForNewClient returned %d", result);
        
        // wait a bit before continuing
        NPT_System::Sleep(NPT_TimeInterval(1.0));
    }

    if (m_Threads == 1) {
        // single threaded
        worker->Respond();
        OnWorkerDone(worker);
    } else {
        worker->m_State.SetValue(ZipHttpWorker::RUNNING);
    }
    worker = NULL;
}

}

/----------------------------------------------------------------------
| ZipHttpWorker::OnWorkerDone
+---------------------------------------------------------------------/
void
ZipHttpServer::OnWorkerDone(ZipHttpWorker* worker)
{
NPT_LOG_FINEST_1("worker %d done", worker->m_Id);
m_Lock.Lock();
m_ReadyWorkers.Add(worker);
m_AllWorkersBusy.SetValue(0);
m_Lock.Unlock();
}

/----------------------------------------------------------------------
| ZipHttpWorker::Run
+---------------------------------------------------------------------/
void
ZipHttpWorker::Run(void)
{
NPT_LOG_FINE_1("worker %d started", m_Id);
for (;;) {
// wait while we're idle
NPT_LOG_FINER_1("worker %d waiting for work", m_Id);
m_State.WaitWhileEquals(IDLE);

    NPT_LOG_FINER_1("worker %d woke up", m_Id);

    if (m_State.GetValue() == DEAD) {
        NPT_LOG_FINE_1("worker %d exiting", m_Id);
        return;
    }
    
    // respond to the client
    Respond();
    
    // update our state
    m_State.SetValue(IDLE);
    
    // notify the server
    m_Server->OnWorkerDone(this);
}

}

/----------------------------------------------------------------------
| ZipHttpWorker::Respond
+---------------------------------------------------------------------/
NPT_Result
ZipHttpWorker::Respond()
{
NPT_LOG_FINER_1("worker %d responding to request", m_Id);

NPT_Result result = m_Server->RespondToClient(m_InputStream, m_OutputStream, m_Context);

NPT_LOG_FINER_2("worker %d responded to request (%d)", m_Id, result);

m_InputStream  = NULL;
m_OutputStream = NULL;

return result;

}

/----------------------------------------------------------------------
| main
+---------------------------------------------------------------------/
int
main(int /argc/, char** argv)
{
NPT_String file_root;
NPT_String url_root = "/";
unsigned int port = 8000;
unsigned int threads = 5;
bool verbose = false;

while (const char* arg = *++argv) {
    if (NPT_StringsEqual(arg, "--help") ||
        NPT_StringsEqual(arg, "-h")) {
        NPT_Console::Output("usage: ziphttpserver [--file-root <dir>] [--url-root <path>] [--port <port>] [--threads <n>] [--verbose]\n");
        return 0;
    } else if (NPT_StringsEqual(arg, "--file-root")) {
        arg = *++argv;
        if (arg == NULL) {
            NPT_Console::Output("ERROR: missing argument for --file-root option\n");
            return 1;
        }
        file_root = arg;
    } else if (NPT_StringsEqual(arg, "--url-root")) {
        arg = *++argv;
        if (arg == NULL) {
            NPT_Console::Output("ERROR: missing argument for --url-root option\n");
            return 1;
        }
        url_root = arg;
    } else if (NPT_StringsEqual(arg, "--port")) {
        arg = *++argv;
        if (arg == NULL) {
            NPT_Console::Output("ERROR: missing argument for --port option\n");
            return 1;
        }
        NPT_ParseInteger(arg, port, true);
    } else if (NPT_StringsEqual(arg, "--threads")) {
        arg = *++argv;
        if (arg == NULL) {
            NPT_Console::Output("ERROR: missing argument for --threads option\n");
            return 1;
        }
        NPT_ParseInteger(arg, threads, true);
    } else if (NPT_StringsEqual(arg, "--verbose")) {
        verbose = true;
    }
}

// sanity check on some parameters
if (threads == 0 || threads > 20) {
    fprintf(stderr, "ERROR: --threads must be between 1 and 20");
    return 1;
}

// ensure the URL root start with a /
if (!url_root.StartsWith("/")) {
    url_root = "/"+url_root;
}

// initialize the file type map
for (unsigned int i=0; i<NPT_ARRAY_SIZE(DefaultFileTypeMap); i++) {
    FileTypeMap[DefaultFileTypeMap[i].extension] =DefaultFileTypeMap[i].mime_type;
}

if (file_root.GetLength() == 0) {
    NPT_File::GetWorkingDir(file_root);
}

if (verbose) {
    NPT_Console::OutputF("Starting server on port %d, file-root=%s, url-root=%s, threads=%d\n",
                         port, file_root.GetChars(), url_root.GetChars(), threads);
}

ZipHttpServer* server = new ZipHttpServer(file_root, url_root, port, threads);
server->Loop();
delete server;

return 0;

}

all

icon.png

Кадавальнік AAC Audio

AAC Audio Enkoder

Codificador d'àudio AAC

Enkodér zvuku AAC

AAC Lydindkoder

AAC Audioencoder

AAC Audio Encoder

AAC Audio Encoder

AAC Audio Encoder

AAC Audio Encoder

Codificador de Audio AAC

Codificador de audio AAC

AAC helikooder

AAC-äänikooderi

Encodeur Audio AAC

AAC zvučni enkôder

AAC Audio Encoder

Enkoder Audio AAC

AAC-hljóðkóðari

Codificatore Audio AAC

AAC 오디오 인코더

AAC audio kodētājs

AAC-lydkoder

AAC Audio Encoder

Encodador àudio AAC

Koder dźwięku AAC

Encoder de áudio AAC

Кодировщик аудио AAC

Audio kodér AAC

AAC Ljud Encoder

AAC Ses Kodlayıcı

Кодувальник аудіо AAC

AAC 音频编码器

AAC - набор кодакаў, распрацаваны для забеспячэння сціскання, лепшага за MP3, і ёсць палепшанымі версіямі аўдыё MPEG.
AAC je skupina kodeka dizajnirana da pruži bolje sabijanje od MP3-a, te su poboljšane verzije MPEG audia.
AAC és un conjunt de còdecs dissenyats per proporcionar una millor compressió que els MP3 i són versions millorades de l'àudio MPEG.
AAC je sada kodeků navržených pro lepší kompresi než MP3 a obsahují zlepšení oproti zvuku MPEG.
AAC er et sæt codecs designet til at give bedre komprimering end MP3'er og er forbedrede versioner af MPEG-lyd.
AAC ist eine Sammlung von Codecs mit einer besseren Komprimierung als MP3. Sie sind verbesserte Versionen von MPEG-Audio.
AAC is a set of codecs designed to provide better compression than MP3s, and are improved versions of MPEG audio.
AAC is a set of codecs designed to provide better compression than MP3s, and are improved versions of MPEG audio.
AAC is a set of codecs designed to provide better compression than MP3s, and are improved versions of MPEG audio.
AAC is a set of codecs designed to provide better compression than MP3s, and are improved versions of MPEG audio.
ACC es un conjunto de codificadores diseñados para comprimir mejor que MP3, y son versiones mejoradas de audio MPEG.
AAc es un conjunto de códecs diseñados para proveer mejor compresión que los MP3, y son versiones mejoradas de audio MPEG.
AAC on koodekite komplekt, mis on loodud pakkumaks paremat tihendamist kui MP3 ja on MPEG-heli täiustatud versioonid.
AAC on joukko koodekkeja, jotka on suunniteltu tarjoamaan MP3-tiedostoja parempaa pakkausta kuin ja ne ovat parannettuja MPEG-äänen versioita.
AAC est un ensemble de codecs conçus pour fournir une meilleur compression que le MP3, et sont des versions améliorés de MPEG audio.
AAC je skup kôdeka dizajniranih za omogućavanje bolje kompresije od MP3 formata, te je poboljšana inačica MPEG zvuka.
Az AAC az MP3 -oknál jobb tömörítést biztosító kodekkészlet, és az MPEG audió továbbfejlesztett változata
AAC adalah seperangkat codec yang dirancang untuk memberikan kompresi yang lebih baik daripada MP3, dan merupakan versi audio MPEG yang ditingkatkan.
AAC er sett af kóðunarlyklum sem hannaðir eru til að gefa betri þjöppun en MP3 og eru endurbættar útgáfur af MPEG-hljóði.
AAC è un insieme di codec progettati per fornire una compressione migliore rispetto agli MP3: sono versioni migliorate dell'Audio MPEG.
AAC는 MP3보다 더 나은 압축을 제공하도록 설계된 코덱 세트이며 MPEG 오디오의 개선된 버전입니다.
AAC ir kodeku komplekts, kas izstrādāts, lai nodrošinātu labāku saspiešanu nekā MP3, un ir uzlabotās MPEG audio versijas pēctecis.
AAC is een set codecs die zijn ontworpen om een betere compressie te bieden dan MP3's, en zijn verbeterde versies van MPEG-audio.
AAC es un ensem de codecs concebuts per fornir una compression melhora que ço dels MP3, e son de versions melhoradas de MPEG audio.
AAC to zestaw kodeków zaprojektowanych w celu zapewnienia lepszej kompresji niż pliki MP3, są ulepszonymi wersjami audio MPEG.
AAC é um conjunto de codecs projetado para fornecer melhor compactação do que MP3s e são versões aprimoradas de áudio MPEG.
AAC - это набор кодеков, разработанных для обеспечения лучшего сжатия, чем MP3, и являющихся улучшенными версиями аудио MPEG.
AAC je sada kodekov navrhnutých tak, aby poskytovali lepšiu kompresiu ako MP3 a sú vylepšenými verziami MPEG audia.
AAC är en uppsättning codecs utformade för att ge bättre komprimering än MP3-filer och är förbättrade versioner av MPEG-ljud.
AAC, MP3'lerden daha iyi sıkıştırma sağlamak üzere tasarlanmış bir dizi codec bileşenleridir ve MPEG sesinin geliştirilmiş sürümleridir.
AAC - це набір кодеків, призначених для забезпечення кращого стиснення, ніж MP3, і є поліпшеними версіями аудіо MPEG.
AAC 是一组编解码器，旨在提供比 MP3 更好的压缩，是 MPEG 音频的改进版本。

Skip to main content
Help Center
Using X
Managing your account
Safety and security
Rules and policies
Resources

Contact Us

🔐 Managing your account
Login and password

Help with two-factor authentication
Help with logging in
How to reset a lost or forgotten password - X password recovery
How to use two-factor authentication
Help with temporary account lock out
Help with logging in to mobile.X.com
How to reset your password on iPhone or iPad
How to reset your password on Android
Help with logging in
About additional sign up and log in details

See less
Username, email, and phone

Help with username registration
How to update your email address
Help with connecting a phone number to your account
Help with email address confirmation
Help with common username issues
Phone number FAQs
How to change your X username
Help with an email, phone number, or username that's already in use
How to update the phone number on your account
How to add your phone number to your account
Help with email address access
Help with confirmation emails
About email addresses

See less
Account settings

How to customize your profile
How to change your country settings
How to download your X archive
How to access your X data
About your activity dashboard
How to use the Delegate feature
How to increase your reach
About third-party apps and log in sessions
How to change your language settings
About Moments engagement metrics
About account home
How to manage multiple accounts
How to customize settings for your new X account
Help with saving account settings
How to change your time zone settings
Help with uploading a profile photo

See less
Notifications

About notifications on mobile devices
How to enable web and browser notifications
Help with receiving emails from X
How to use X Alerts
How to receive recommendations from X
About the Notifications timeline
How we use your data for push notifications
How to update your email preferences

See less
Verified accounts

About Verified accounts
Legacy Verification policy
Suspended accounts

Help with locked or limited account
About suspended accounts
Deactivate and reactivate accounts

How to reactivate your account
How to deactivate your account
Help with account reactivation
Help with account deactivation
About account restoration
X platform
X.com
Status
Accessibility
Embed a post
Privacy Center
Transparency Center
Download the X app
X Corp.
About the company
Company news
Brand toolkit
Jobs and internships
Investors
Help
Help Center
Using X
X for creators
Ads Help Center
Managing your account
Email Preference Center
Rules and policies
Contact us
Developer resources
Developer home
Documentation
Forums
Communities
Developer blog
Engineering blog
Developer terms
Business resources
Advertise
X for business
Resources and guides
X for marketers
Marketing insights
Brand inspiration
X Ads Academy
© 2024 X Corp.
Cookies
Privacy
Terms and conditions
English
Skip to main content
Help Center
Using X
Managing your account
Safety and security
Rules and policies
Resources

Contact Us

🔐 Managing your account
Login and password

Help with two-factor authentication
Help with logging in
How to reset a lost or forgotten password - X password recovery
How to use two-factor authentication
Help with temporary account lock out
Help with logging in to mobile.X.com
How to reset your password on iPhone or iPad
How to reset your password on Android
Help with logging in
About additional sign up and log in details

See less
Username, email, and phone

Help with username registration
How to update your email address
Help with connecting a phone number to your account
Help with email address confirmation
Help with common username issues
Phone number FAQs
How to change your X username
Help with an email, phone number, or username that's already in use
How to update the phone number on your account
How to add your phone number to your account
Help with email address access
Help with confirmation emails
About email addresses

See less
Account settings

How to customize your profile
How to change your country settings
How to download your X archive
How to access your X data
About your activity dashboard
How to use the Delegate feature
How to increase your reach
About third-party apps and log in sessions
How to change your language settings
About Moments engagement metrics
About account home
How to manage multiple accounts
How to customize settings for your new X account
Help with saving account settings
How to change your time zone settings
Help with uploading a profile photo

See less
Notifications

About notifications on mobile devices
How to enable web and browser notifications
Help with receiving emails from X
How to use X Alerts
How to receive recommendations from X
About the Notifications timeline
How we use your data for push notifications
How to update your email preferences

See less
Verified accounts

About Verified accounts
Legacy Verification policy
Suspended accounts

Help with locked or limited account
About suspended accounts
Deactivate and reactivate accounts

How to reactivate your account
How to deactivate your account
Help with account reactivation
Help with account deactivation
About account restoration
X platform
X.com
Status
Accessibility
Embed a post
Privacy Center
Transparency Center
Download the X app
X Corp.
About the company
Company news
Brand toolkit
Jobs and internships
Investors
Help
Help Center
Using X
X for creators
Ads Help Center
Managing your account
Email Preference Center
Rules and policies
Contact us
Developer resources
Developer home
Documentation
Forums
Communities
Developer blog
Engineering blog
Developer terms
Business resources
Advertise
X for business
Resources and guides
X for marketers
Marketing insights
Brand inspiration
X Ads Academy
© 2024 X Corp.
Cookies
Privacy
Terms and conditions
English MIT License

Copyright (c) 2019 GitHub Inc.

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
pdx-col.eum-appdynamics.com*0=: {<"https://help.twitter.com/en/resources/new-user-faq">}Payments profile
Payments profile ID
7669-5812-8867
Country/Region
United States (US)
Account type
Individual
United States tax exemption info
Name
Kenneth Roberts
Address
3542 Dawson Street
Jacksonville, FL 32209
United States
Document language preference
English (United States)

The body mixes GitHub CLI material with unrelated C++ source and does not identify a GDK file, test, or requested change. First clarify the intended component and acceptance criteria, then use the referenced GitHub CLI URL or the relevant GDK entry point to define what documentation should be updated.