@ohos-ports/curlconverter 4.12.0-beta.0

package/dist/src/generators/c.js

@@ -0,0 +1,1230 @@
+import { Word, eq, mergeWords } from "../shell/Word.js";
+import { parse, getFirst, COMMON_SUPPORTED_ARGS } from "../parse.js";
+export const supportedArgs = new Set([
+    ...COMMON_SUPPORTED_ARGS,
+    "disallow-username-in-url",
+    "path-as-is",
+    "alt-svc",
+    "unix-socket",
+    "abstract-unix-socket",
+    "compressed",
+    "no-compressed",
+    "verbose",
+    "no-verbose",
+    "proxy",
+    "proxy-user",
+    "proxytunnel",
+    "noproxy",
+    "preproxy",
+    "proxy-anyauth",
+    "proxy-basic",
+    "proxy-digest",
+    "proxy-negotiate",
+    "proxy-ntlm",
+    "proxy-ca-native",
+    "proxy-cacert",
+    "proxy-capath",
+    "proxy-cert-type",
+    "proxy-cert",
+    "proxy-ciphers",
+    "proxy-crlfile",
+    "proxy-header",
+    "proxy-http2",
+    "proxy-insecure",
+    "proxy-key",
+    "proxy-key-type",
+    "proxy-pass",
+    "proxy-pinnedpubkey",
+    "proxy-service-name",
+    "proxy-ssl-allow-beast",
+    "proxy-ssl-auto-client-cert",
+    "proxy-tls13-ciphers",
+    "proxy-tlsuser",
+    "proxy-tlspassword",
+    "proxy-tlsauthtype",
+    "proxy-tlsv1",
+    "socks4",
+    "socks4a",
+    "socks5",
+    "socks5-hostname",
+    "socks5-basic",
+    "socks5-gssapi",
+    "socks5-gssapi-nec",
+    "socks5-gssapi-service",
+    "haproxy-clientip",
+    "haproxy-protocol",
+    "interface",
+    "netrc",
+    "netrc-file",
+    "netrc-optional",
+    // "anyauth",
+    // "no-anyauth",
+    "digest",
+    "no-digest",
+    "negotiate",
+    "no-negotiate",
+    "service-name",
+    "ntlm",
+    "no-ntlm",
+    "ntlm-wb",
+    "no-ntlm-wb",
+    "aws-sigv4",
+    "delegation",
+    "oauth2-bearer",
+    "ipv4",
+    "ipv6",
+    "local-port",
+    "ftp-skip-pasv-ip",
+    "sasl-authzid",
+    "sasl-ir",
+    "tr-encoding",
+    "tcp-fastopen",
+    // Not parsed properly
+    // "proto",
+    // "proto-redir",
+    "proto-default",
+    "ignore-content-length",
+    "no-ignore-content-length",
+    "remote-time",
+    // "time-cond",
+    // requires that the underlying libcurl was built to support c-ares
+    // "dns-interface",
+    // "dns-ipv4-addr",
+    // "dns-ipv6-addr",
+    // "dns-servers",
+    // No effect
+    // "dump-header",
+    // "include",
+    // "engine",
+    // Adds a If-None-Match header
+    // "etag-compare",
+    // "etag-save", // No effect
+    "fail",
+    // "fail-with-body",
+    // "fail-early",
+    "continue-at",
+    "speed-limit",
+    "speed-time",
+    "limit-rate",
+    "max-filesize",
+    "http0.9",
+    "http1.0",
+    "http1.1",
+    "http2",
+    "http2-prior-knowledge",
+    "http3",
+    "http3-only",
+    "cookie-jar",
+    "junk-session-cookies",
+    "crlf",
+    "no-crlf",
+    "use-ascii",
+    // "write-out",
+    "pass",
+    "cacert",
+    "capath",
+    "crlfile",
+    "pinnedpubkey",
+    "curves",
+    "cert",
+    "cert-status",
+    "cert-type",
+    "key",
+    "key-type",
+    "ca-native",
+    "ssl-allow-beast",
+    "ciphers",
+    "tls13-ciphers",
+    "tlsuser",
+    "tlspassword",
+    "tlsauthtype",
+    "ssl",
+    "ssl-auto-client-cert",
+    "ssl-no-revoke",
+    "ssl-reqd",
+    "ssl-revoke-best-effort",
+    // "sslv2",  // ignored
+    // "sslv3",  // ignored
+    "tlsv1",
+    "tlsv1.0",
+    "tlsv1.1",
+    "tlsv1.2",
+    "tlsv1.3",
+    "tls-max",
+    // "false-start",
+    "hsts",
+    "alpn",
+    "no-alpn",
+    "form",
+    "form-string",
+    "form-escape",
+    "no-form-escape",
+    "doh-url",
+    "doh-cert-status",
+    // "doh-insecure",  // has no effect
+    "location",
+    "no-location",
+    "location-trusted",
+    "no-location-trusted",
+    "max-redirs",
+    "post301",
+    "post302",
+    "post303",
+    "max-time",
+    "connect-timeout",
+    "expect100-timeout",
+    "happy-eyeballs-timeout-ms",
+    "resolve",
+    "connect-to",
+    "keepalive",
+    "no-keepalive",
+    "keepalive-time",
+    "insecure",
+    "no-insecure",
+]);
+const regexEscape = /"|\\|\p{C}|[^ \P{Z}]/gu;
+export function reprStr(s) {
+    return ('"' +
+        s.replace(regexEscape, (c) => {
+            switch (c) {
+                case "\x07":
+                    return "\\a";
+                case "\b":
+                    return "\\b";
+                case "\f":
+                    return "\\f";
+                case "\n":
+                    return "\\n";
+                case "\r":
+                    return "\\r";
+                case "\t":
+                    return "\\t";
+                case "\v":
+                    return "\\v";
+                case "\\":
+                    return "\\\\";
+                case '"':
+                    return '\\"';
+            }
+            const hex = c.codePointAt(0).toString(16);
+            if (hex.length <= 2) {
+                return "\\x" + hex.padStart(2, "0");
+            }
+            if (hex.length <= 4) {
+                return "\\u" + hex.padStart(4, "0");
+            }
+            return "\\U" + hex.padStart(8, "0");
+        }) +
+        '"');
+}
+export function repr(word, imports) {
+    const reprs = [];
+    for (const t of word.tokens) {
+        if (typeof t === "string") {
+            reprs.push(reprStr(t));
+        }
+        else if (t.type === "variable") {
+            reprs.push("getenv(" + reprStr(t.value) + ")");
+            imports.add("stdlib.h");
+        }
+        else if (t.type === "command") {
+            // TODO: read the FILE contents
+            reprs.push("popen(" + reprStr(t.value) + ', "r")');
+            imports.add("stdio.h");
+        }
+    }
+    // TODO: C can't concatenate strings
+    return reprs.join(" + ");
+}
+export function atof1000(word, imports) {
+    if (word.isString()) {
+        // TODO: check it's actually a valid float
+        const asFloat = parseFloat(word.toString());
+        if (!Number.isNaN(asFloat)) {
+            return Math.floor(asFloat * 1000) + "L";
+        }
+    }
+    return "(long)(atof(" + repr(word, imports) + ") * 1000)";
+}
+export function atoi(word, imports) {
+    if (word.isString()) {
+        // TODO: check it's actually a valid int
+        return word.toString();
+    }
+    return "atoi(" + repr(word, imports) + ")";
+}
+export function atol(word, imports) {
+    if (word.isString()) {
+        // TODO: check it's actually a valid int
+        return word.toString() + "L";
+    }
+    return "atol(" + repr(word, imports) + ")";
+}
+const AUTH_TO_VAR = {
+    basic: "CURLAUTH_BASIC",
+    negotiate: "CURLAUTH_NEGOTIATE",
+    // technically what --libcurl generates but older
+    // negotiate: "CURLAUTH_GSSNEGOTIATE",
+    digest: "CURLAUTH_DIGEST",
+    ntlm: "CURLAUTH_NTLM",
+    "ntlm-wb": "CURLAUTH_NTLM_WB",
+    bearer: "CURLAUTH_BEARER",
+    "aws-sigv4": "CURLAUTH_AWS_SIGV4",
+    none: "CURLAUTH_NONE",
+};
+function requestToC(request, warnings = [], imports) {
+    let preamble = "";
+    preamble += "int main(int argc, char *argv[])\n";
+    preamble += "{\n";
+    preamble += "  CURLcode ret;\n";
+    preamble += "  CURL *hnd;\n";
+    let vars = "";
+    let code = "";
+    code += "  hnd = curl_easy_init();\n";
+    let cleanup = "";
+    cleanup += "  curl_easy_cleanup(hnd);\n";
+    cleanup += "  hnd = NULL;\n";
+    if (request.tcpFastopen) {
+        code += "  curl_easy_setopt(hnd, CURLOPT_TCP_FASTOPEN, 1L);\n";
+    }
+    const bufferSize = request.limitRate
+        ? atol(request.limitRate, imports) // TODO: parse
+        : "102400L";
+    code += "  curl_easy_setopt(hnd, CURLOPT_BUFFERSIZE, " + bufferSize + ");\n";
+    if (request.localPort) {
+        const [start, end] = request.localPort;
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_LOCALPORT, " +
+                atol(start, imports) +
+                ");\n";
+        let range = "1L";
+        if (end) {
+            range = atol(end, imports) + "-" + atol(start, imports);
+        }
+        code += "  curl_easy_setopt(hnd, CURLOPT_LOCALPORTRANGE, " + range + ");\n";
+    }
+    // TODO: if it doesn't have a query string from --data, it's better to
+    // do originalUrl because it doesn't need to have the http[s]://
+    const url = request.urls[0].url;
+    code += "  curl_easy_setopt(hnd, CURLOPT_URL, " + repr(url, imports) + ");\n";
+    code += "  curl_easy_setopt(hnd, CURLOPT_NOPROGRESS, 1L);\n";
+    if (request.oauth2Bearer) {
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_XOAUTH2_BEARER, " +
+                repr(request.oauth2Bearer, imports) +
+                ");\n";
+    }
+    if (request.proxy) {
+        const proxy = repr(request.proxy, imports);
+        code += "  curl_easy_setopt(hnd, CURLOPT_PROXY, " + proxy + ");\n";
+    }
+    if (request.proxyType) {
+        if (request.proxyType === "http2") {
+            code += "  curl_easy_setopt(hnd, CURLOPT_PROXYTYPE, 3L);\n";
+        }
+        else if (request.proxyType === "http1") {
+            code +=
+                "  curl_easy_setopt(hnd, CURLOPT_PROXYTYPE, (long)CURLPROXY_HTTP_1_0);\n";
+        }
+        else if (request.proxyType === "socks4") {
+            code +=
+                "  curl_easy_setopt(hnd, CURLOPT_PROXYTYPE, (long)CURLPROXY_SOCKS4);\n";
+        }
+        else if (request.proxyType === "socks4a") {
+            code +=
+                "  curl_easy_setopt(hnd, CURLOPT_PROXYTYPE, (long)CURLPROXY_SOCKS4A);\n";
+        }
+        else if (request.proxyType === "socks5") {
+            code +=
+                "  curl_easy_setopt(hnd, CURLOPT_PROXYTYPE, (long)CURLPROXY_SOCKS5);\n";
+        }
+        else if (request.proxyType === "socks5-hostname") {
+            code +=
+                "  curl_easy_setopt(hnd, CURLOPT_PROXYTYPE, (long)CURLPROXY_SOCKS5_HOSTNAME);\n";
+        }
+    }
+    if (request.proxyAuth) {
+        const proxyUserpwd = repr(request.proxyAuth, imports);
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_PROXYUSERPWD, " + proxyUserpwd + ");\n";
+    }
+    if (request.proxytunnel) {
+        code += "  curl_easy_setopt(hnd, CURLOPT_HTTPPROXYTUNNEL, 1L);\n";
+    }
+    if (request.proxyAuth) {
+        const proxyAuth = AUTH_TO_VAR[request.proxyAuthType];
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_PROXYAUTH, (long)" + proxyAuth + ");\n";
+    }
+    if (request.preproxy) {
+        const preproxy = repr(request.preproxy, imports);
+        code += "  curl_easy_setopt(hnd, CURLOPT_PRE_PROXY, " + preproxy + ");\n";
+    }
+    if (request.noproxy) {
+        const noproxy = repr(request.noproxy, imports);
+        code += "  curl_easy_setopt(hnd, CURLOPT_NOPROXY, " + noproxy + ");\n";
+    }
+    if (request.fail) {
+        code += "  curl_easy_setopt(hnd, CURLOPT_FAILONERROR, 1L);\n";
+    }
+    if (request.netrc) {
+        const netrc = {
+            optional: "CURL_NETRC_OPTIONAL",
+            required: "CURL_NETRC_REQUIRED",
+            ignored: "CURL_NETRC_IGNORED",
+        }[request.netrc || "ignored"];
+        code += "  curl_easy_setopt(hnd, CURLOPT_NETRC, (long)" + netrc + ");\n";
+    }
+    if (request.netrcFile) {
+        const netrcFile = repr(request.netrcFile, imports);
+        code += "  curl_easy_setopt(hnd, CURLOPT_NETRC_FILE, " + netrcFile + ");\n";
+    }
+    if (request.useAscii) {
+        code += "  curl_easy_setopt(hnd, CURLOPT_TRANSFERTEXT, 1L);\n";
+    }
+    if (request.urls[0].auth) {
+        const [username, password] = request.urls[0].auth;
+        const userpwd = repr(mergeWords(username, ":", password), imports);
+        code += "  curl_easy_setopt(hnd, CURLOPT_USERPWD, " + userpwd + ");\n";
+    }
+    if (request.timeout) {
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_TIMEOUT_MS, " +
+                atof1000(request.timeout, imports) +
+                ");\n";
+    }
+    if (request.urls[0].uploadFile) {
+        // TODO
+    }
+    else if (request.multipartUploads) {
+        preamble += "  curl_mime *mime1;\n";
+        preamble += "  curl_mimepart *part1;\n";
+        vars += "  mime1 = NULL;\n";
+        code += "  mime1 = curl_mime_init(hnd);\n";
+        for (const m of request.multipartUploads) {
+            code += "  part1 = curl_mime_addpart(mime1);\n";
+            if ("contentFile" in m && m.contentFile) {
+                code +=
+                    "  curl_mime_filedata(part1, " +
+                        repr(m.contentFile, imports) +
+                        ");\n";
+            }
+            else if ("content" in m && m.content) {
+                code +=
+                    "  curl_mime_data(part1, " +
+                        repr(m.content, imports) +
+                        ", CURL_ZERO_TERMINATED);\n";
+            }
+            if ("encoder" in m && m.encoder) {
+                code +=
+                    "  curl_mime_encoder(part1, " + repr(m.encoder, imports) + ");\n";
+            }
+            if ("filename" in m &&
+                m.filename &&
+                !("contentFile" in m && m.contentFile && eq(m.filename, m.contentFile))) {
+                code +=
+                    "  curl_mime_filename(part1, " + repr(m.filename, imports) + ");\n";
+            }
+            else if (!m.filename && "contentFile" in m && m.contentFile) {
+                code += "  curl_mime_filename(part1, NULL);\n";
+            }
+            code += "  curl_mime_name(part1, " + repr(m.name, imports) + ");\n";
+            if ("contentType" in m && m.contentType) {
+                code +=
+                    "  curl_mime_type(part1, " + repr(m.contentType, imports) + ");\n";
+            }
+            if ("headers" in m && m.headers) {
+                warnings.push([
+                    "multipart-headers",
+                    "multipart headers are not supported: " +
+                        m.headers.map((h) => h.toString()).join(", "),
+                ]);
+            }
+            if ("headerFiles" in m && m.headerFiles) {
+                warnings.push([
+                    "multipart-headers",
+                    "multipart header files are not supported: " +
+                        m.headerFiles.map((h) => h.toString()).join(", "),
+                ]);
+            }
+        }
+        code += "  curl_easy_setopt(hnd, CURLOPT_MIMEPOST, mime1);\n";
+        cleanup += "  curl_mime_free(mime1);\n";
+        cleanup += "  mime1 = NULL;\n";
+    }
+    else if (request.data) {
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, " +
+                repr(request.data, imports) +
+                ");\n";
+        // this isn't correct if .data reads files
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_POSTFIELDSIZE_LARGE, (curl_off_t)" +
+                request.data.length.toString() +
+                ");\n";
+    }
+    if (request.formEscape) {
+        code += "  curl_easy_setopt(hnd, CURLOPT_MIME_OPTIONS, 1L);\n";
+    }
+    if (request.urls[0].auth) {
+        const curlAuth = AUTH_TO_VAR[request.authType];
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_HTTPAUTH, (long)" + curlAuth + ");\n";
+    }
+    const headerLines = [];
+    for (const [headerName, headerValue] of request.headers) {
+        const h = headerName.toLowerCase();
+        if (eq(h, "user-agent") || eq(h, "referer")) {
+            continue;
+        }
+        if (headerValue === null) {
+            headerLines.push("  headers = curl_slist_append(headers, " +
+                repr(mergeWords(headerName, ":"), imports) +
+                ");\n");
+        }
+        else if (eq(headerValue, "")) {
+            headerLines.push("  headers = curl_slist_append(headers, " +
+                repr(mergeWords(headerName, ";"), imports) +
+                ");\n");
+        }
+        else {
+            headerLines.push("  headers = curl_slist_append(headers, " +
+                repr(mergeWords(headerName, ": ", headerValue), imports) +
+                ");\n");
+        }
+    }
+    if (headerLines.length) {
+        preamble += "  struct curl_slist *headers;\n";
+        vars += "  headers = NULL;\n";
+        vars += headerLines.join("");
+        code += "  curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);\n";
+        cleanup += "  curl_slist_free_all(headers);\n";
+        cleanup += "  headers = NULL;\n";
+    }
+    const referer = request.headers.get("referer");
+    if (referer) {
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_REFERER, " +
+                repr(referer, imports) +
+                ");\n";
+        // TODO: only if passed with --referer and not -H
+    }
+    const userAgent = request.headers.get("user-agent");
+    if (userAgent) {
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_USERAGENT, " +
+                repr(userAgent, imports) +
+                ");\n";
+    }
+    else if (userAgent === undefined) {
+        // TODO: needs to be kept up-to-date with VERSION in cli.ts
+        code += '  curl_easy_setopt(hnd, CURLOPT_USERAGENT, "curl/8.2.1");\n';
+    }
+    if (request.followRedirects) {
+        code += "  curl_easy_setopt(hnd, CURLOPT_FOLLOWLOCATION, 1L);\n";
+        if (request.followRedirectsTrusted) {
+            code += "  curl_easy_setopt(hnd, CURLOPT_UNRESTRICTED_AUTH, 1L);\n";
+        }
+    }
+    if (request.awsSigV4) {
+        const awsSig = repr(request.awsSigV4, imports);
+        code += "  curl_easy_setopt(hnd, CURLOPT_AWS_SIGV4, " + awsSig + ");\n";
+    }
+    if (request.refererAuto) {
+        code += "  curl_easy_setopt(hnd, CURLOPT_AUTOREFERER, 1L);\n";
+    }
+    if (request.proxyHeaders.length) {
+        // TODO: camelCase snake_case orjustoneword?
+        preamble += "  struct curl_slist *proxy_headers;\n";
+        if (vars) {
+            vars += "\n";
+        }
+        vars += "  proxy_headers = NULL;\n";
+        for (const [headerName, headerValue] of request.proxyHeaders) {
+            if (headerValue === null) {
+                vars +=
+                    "  proxy_headers = curl_slist_append(proxy_headers, " +
+                        repr(mergeWords(headerName, ":"), imports) +
+                        ");\n";
+            }
+            else if (eq(headerValue, "")) {
+                vars +=
+                    "  proxy_headers = curl_slist_append(proxy_headers, " +
+                        repr(mergeWords(headerName, ";"), imports) +
+                        ");\n";
+            }
+            else {
+                vars +=
+                    "  proxy_headers = curl_slist_append(proxy_headers, " +
+                        repr(mergeWords(headerName, ": ", headerValue), imports) +
+                        ");\n";
+            }
+        }
+        code += "  curl_easy_setopt(hnd, CURLOPT_PROXYHEADER, proxy_headers);\n";
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_HEADEROPT, (long)CURLHEADER_SEPARATE);\n";
+        cleanup += "  curl_slist_free_all(proxy_headers);\n";
+        cleanup += "  proxy_headers = NULL;\n";
+    }
+    const maxRedirs = request.maxRedirects || new Word("50");
+    code +=
+        "  curl_easy_setopt(hnd, CURLOPT_MAXREDIRS, " +
+            atol(maxRedirs, imports) +
+            ");\n";
+    let httpVersion = "CURL_HTTP_VERSION_2TLS";
+    if (request.httpVersion) {
+        httpVersion = {
+            "1.0": "CURL_HTTP_VERSION_1_0",
+            "1.1": "CURL_HTTP_VERSION_1_1",
+            "2": "CURL_HTTP_VERSION_2_0",
+            "2-prior-knowledge": "CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE",
+            "3": "CURL_HTTP_VERSION_3",
+            "3-only": "CURL_HTTP_VERSION_3ONLY",
+        }[request.httpVersion];
+    }
+    code +=
+        "  curl_easy_setopt(hnd, CURLOPT_HTTP_VERSION, (long)" +
+            httpVersion +
+            ");\n";
+    if (request.http0_9) {
+        code += "  curl_easy_setopt(hnd, CURLOPT_HTTP09_ALLOWED, 1L);\n";
+    }
+    if (request.post301 || request.post302 || request.post303) {
+        const postRedir = [];
+        if (request.post301) {
+            postRedir.push("CURL_REDIR_POST_301");
+        }
+        if (request.post302) {
+            postRedir.push("CURL_REDIR_POST_302");
+        }
+        if (request.post303) {
+            postRedir.push("CURL_REDIR_POST_303");
+        }
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_POSTREDIR, " +
+                postRedir.join(" | ") +
+                ");\n";
+    }
+    if (request.compressed) {
+        code += '  curl_easy_setopt(hnd, CURLOPT_ACCEPT_ENCODING, "");\n';
+    }
+    if (request.transferEncoding) {
+        code += "  curl_easy_setopt(hnd, CURLOPT_TRANSFER_ENCODING, 1L);\n";
+    }
+    if (request.speedLimit || request.speedTime) {
+        const speedLimit = atol(request.speedLimit || new Word("1"), imports);
+        const speedTime = atol(request.speedTime || new Word("30"), imports);
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_LOW_SPEED_LIMIT, " + speedLimit + ");\n";
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_LOW_SPEED_TIME, " + speedTime + ");\n";
+    }
+    if (request.limitRate) {
+        // TODO: parse
+        const limitRate = repr(request.limitRate, imports);
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_MAX_SEND_SPEED_LARGE, (curl_off_t)" +
+                limitRate +
+                ");\n";
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_MAX_RECV_SPEED_LARGE, (curl_off_t)" +
+                limitRate +
+                ");\n";
+    }
+    if (request.continueAt) {
+        if (!eq(request.continueAt, "-")) {
+            const continueAt = atoi(request.continueAt, imports);
+            code +=
+                "  curl_easy_setopt(hnd, CURLOPT_RESUME_FROM_LARGE, (curl_off_t)" +
+                    continueAt +
+                    ");\n";
+        }
+    }
+    if (request.pass) {
+        const pass = repr(request.pass, imports);
+        // TODO: --cert can also set this
+        code += "  curl_easy_setopt(hnd, CURLOPT_KEYPASSWD, " + pass + ");\n";
+    }
+    if (request.proxyPass) {
+        // TODO: --proxy-cert can also set this
+        const proxyPass = repr(request.proxyPass, imports);
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_PROXY_KEYPASSWD, " + proxyPass + ");\n";
+    }
+    if (request.cacert) {
+        const cacert = repr(request.cacert, imports);
+        code += "  curl_easy_setopt(hnd, CURLOPT_CAINFO, " + cacert + ");\n";
+    }
+    if (request.proxyCacert) {
+        const proxyCacert = repr(request.proxyCacert, imports);
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_PROXY_CAINFO, " + proxyCacert + ");\n";
+    }
+    if (request.capath || request.proxyCapath) {
+        if (request.capath) {
+            const capath = repr(request.capath, imports);
+            code += "  curl_easy_setopt(hnd, CURLOPT_CAPATH, " + capath + ");\n";
+            const proxyCapath = repr(request.proxyCapath || request.capath, imports);
+            code +=
+                "  curl_easy_setopt(hnd, CURLOPT_PROXY_CAPATH, " + proxyCapath + ");\n";
+        }
+        else if (request.proxyCapath) {
+            // placate type checker
+            const proxyCapath = repr(request.proxyCapath, imports);
+            code +=
+                "  curl_easy_setopt(hnd, CURLOPT_PROXY_CAPATH, " + proxyCapath + ");\n";
+        }
+    }
+    if (request.crlfile || request.proxyCrlfile) {
+        if (request.crlfile) {
+            const crlfile = repr(request.crlfile, imports);
+            code += "  curl_easy_setopt(hnd, CURLOPT_CRLFILE, " + crlfile + ");\n";
+            const proxyCrlfile = repr(request.proxyCrlfile || request.crlfile, imports);
+            code +=
+                "  curl_easy_setopt(hnd, CURLOPT_PROXY_CRLFILE, " +
+                    proxyCrlfile +
+                    ");\n";
+        }
+        else if (request.proxyCrlfile) {
+            // placate type checker
+            const proxyCrlfile = repr(request.proxyCrlfile, imports);
+            code +=
+                "  curl_easy_setopt(hnd, CURLOPT_PROXY_CRLFILE, " +
+                    proxyCrlfile +
+                    ");\n";
+        }
+    }
+    if (request.pinnedpubkey) {
+        const pinnedpubkey = repr(request.pinnedpubkey, imports);
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_PINNEDPUBLICKEY, " +
+                pinnedpubkey +
+                ");\n";
+    }
+    // TODO: --proxy-pinnedpubkey ?
+    if (request.curves) {
+        const curves = repr(request.curves, imports);
+        code += "  curl_easy_setopt(hnd, CURLOPT_SSL_EC_CURVES, " + curves + ");\n";
+    }
+    if (request.cert) {
+        const [cert, pass] = request.cert;
+        if (pass) {
+            code +=
+                "  curl_easy_setopt(hnd, CURLOPT_KEYPASSWD, " +
+                    repr(pass, imports) +
+                    ");\n";
+        }
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_SSLCERT, " +
+                repr(cert, imports) +
+                ");\n";
+    }
+    if (request.proxyCert) {
+        // TODO: split
+        const proxyCert = repr(request.proxyCert, imports);
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_PROXY_SSLCERT, " + proxyCert + ");\n";
+    }
+    if (request.certType) {
+        const certType = repr(request.certType, imports);
+        code += "  curl_easy_setopt(hnd, CURLOPT_SSLCERTTYPE, " + certType + ");\n";
+    }
+    if (request.proxyCertType) {
+        const proxyCertType = repr(request.proxyCertType, imports);
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_PROXY_SSLCERTTYPE, " +
+                proxyCertType +
+                ");\n";
+    }
+    if (request.key) {
+        const key = repr(request.key, imports);
+        code += "  curl_easy_setopt(hnd, CURLOPT_SSLKEY, " + key + ");\n";
+    }
+    if (request.proxyKey) {
+        const proxyKey = repr(request.proxyKey, imports);
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_PROXY_SSLKEY, " + proxyKey + ");\n";
+    }
+    if (request.keyType) {
+        const keyType = repr(request.keyType, imports);
+        code += "  curl_easy_setopt(hnd, CURLOPT_SSLKEYTYPE, " + keyType + ");\n";
+    }
+    if (request.proxyKeyType) {
+        const proxyKeyType = repr(request.proxyKeyType, imports);
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_PROXY_SSLKEYTYPE, " +
+                proxyKeyType +
+                ");\n";
+    }
+    if (request.insecure) {
+        code += "  curl_easy_setopt(hnd, CURLOPT_SSL_VERIFYPEER, 0L);\n";
+        code += "  curl_easy_setopt(hnd, CURLOPT_SSL_VERIFYHOST, 0L);\n";
+    }
+    if (request.proxyInsecure) {
+        code += "  curl_easy_setopt(hnd, CURLOPT_PROXY_SSL_VERIFYPEER, 0L);\n";
+        code += "  curl_easy_setopt(hnd, CURLOPT_PROXY_SSL_VERIFYHOST, 0L);\n";
+    }
+    if (request.certStatus) {
+        code += "  curl_easy_setopt(hnd, CURLOPT_SSL_VERIFYSTATUS, 1L);\n";
+    }
+    if (request.dohCertStatus) {
+        code += "  curl_easy_setopt(hnd, CURLOPT_DOH_SSL_VERIFYSTATUS, 1L);\n";
+    }
+    let tlsVersion = null;
+    if (request.tlsVersion) {
+        tlsVersion = {
+            "1": "CURL_SSLVERSION_TLSv1",
+            "1.0": "CURL_SSLVERSION_TLSv1_0",
+            "1.1": "CURL_SSLVERSION_TLSv1_1",
+            "1.2": "CURL_SSLVERSION_TLSv1_2",
+            "1.3": "CURL_SSLVERSION_TLSv1_3",
+        }[request.tlsVersion];
+    }
+    let tlsMax = null;
+    if (request.tlsMax) {
+        if (request.tlsMax.isString()) {
+            const tlsMaxVal = request.tlsMax.toString();
+            switch (tlsMaxVal) {
+                case "1.0":
+                    tlsMax = "CURL_SSLVERSION_MAX_TLSv1_0";
+                    break;
+                case "1.1":
+                    tlsMax = "CURL_SSLVERSION_MAX_TLSv1_1";
+                    break;
+                case "1.2":
+                    tlsMax = "CURL_SSLVERSION_MAX_TLSv1_2";
+                    break;
+                case "1.3":
+                    tlsMax = "CURL_SSLVERSION_MAX_TLSv1_3";
+                    break;
+                case "default":
+                    tlsMax = "CURL_SSLVERSION_MAX_DEFAULT";
+                    break;
+                default:
+                    warnings.push([
+                        "tls-max",
+                        "unknown value for --tls-max: " + JSON.stringify(tlsMaxVal),
+                    ]);
+            }
+        }
+        else {
+            warnings.push([
+                "tls-max",
+                "unparseable value for --tls-max: " +
+                    JSON.stringify(request.tlsMax.toString()),
+            ]);
+        }
+    }
+    if (tlsVersion || tlsMax) {
+        if (!tlsVersion) {
+            // not really necessary since it's 0
+            tlsVersion = "CURL_SSLVERSION_DEFAULT";
+        }
+        code += "  curl_easy_setopt(hnd, CURLOPT_SSLVERSION, (long)";
+        if (tlsMax) {
+            code += "(" + tlsVersion + " | " + tlsMax + ")";
+        }
+        else {
+            code += tlsVersion;
+        }
+        code += ");\n";
+    }
+    if (request.proxyTlsv1) {
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_PROXY_SSLVERSION, (long)CURL_SSLVERSION_TLSv1);\n";
+    }
+    if (request.sslAllowBeast ||
+        request.sslNoRevoke ||
+        request.sslRevokeBestEffort ||
+        request.caNative ||
+        request.sslAutoClientCert) {
+        const sslOptions = [];
+        if (request.sslAllowBeast) {
+            sslOptions.push("CURLSSLOPT_ALLOW_BEAST");
+        }
+        if (request.sslNoRevoke) {
+            sslOptions.push("CURLSSLOPT_NO_REVOKE");
+        }
+        if (request.sslRevokeBestEffort) {
+            sslOptions.push("CURLSSLOPT_REVOKE_BEST_EFFORT");
+        }
+        if (request.caNative) {
+            sslOptions.push("CURLSSLOPT_NATIVE_CA");
+        }
+        if (request.sslAutoClientCert) {
+            sslOptions.push("CURLSSLOPT_AUTO_CLIENT_CERT");
+        }
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_SSL_OPTIONS, (long)" +
+                (sslOptions.length > 1 ? "(" : "") +
+                sslOptions.join(" | ") +
+                (sslOptions.length > 1 ? ")" : "") +
+                ");\n";
+    }
+    if (request.proxySslAllowBeast ||
+        request.proxyCaNative ||
+        request.proxySslAutoClientCert) {
+        const sslOptions = [];
+        if (request.proxySslAllowBeast) {
+            sslOptions.push("CURLSSLOPT_ALLOW_BEAST");
+        }
+        if (request.proxyCaNative) {
+            sslOptions.push("CURLSSLOPT_NATIVE_CA");
+        }
+        if (request.proxySslAutoClientCert) {
+            sslOptions.push("CURLSSLOPT_AUTO_CLIENT_CERT");
+        }
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_PROXY_SSL_OPTIONS, (long)" +
+                sslOptions.join(" | (long)") +
+                ");\n";
+    }
+    if (request.pathAsIs) {
+        code += "  curl_easy_setopt(hnd, CURLOPT_PATH_AS_IS, 1L);\n";
+    }
+    if (request.remoteTime) {
+        code += "  curl_easy_setopt(hnd, CURLOPT_FILETIME, 1L);\n";
+    }
+    if (request.crlf) {
+        code += "  curl_easy_setopt(hnd, CURLOPT_CRLF, 1L);\n";
+    }
+    if (request.cookieFiles) {
+        for (const cookieFile of request.cookieFiles) {
+            // TODO: why can curl set this more than once?
+            const cookieFile_ = repr(cookieFile, imports);
+            code +=
+                "  curl_easy_setopt(hnd, CURLOPT_COOKIEFILE, " + cookieFile_ + ");\n";
+        }
+    }
+    if (request.cookieJar) {
+        const cookieJar = repr(request.cookieJar, imports);
+        code += "  curl_easy_setopt(hnd, CURLOPT_COOKIEJAR, " + cookieJar + ");\n";
+    }
+    if (request.junkSessionCookies) {
+        code += "  curl_easy_setopt(hnd, CURLOPT_COOKIESESSION, 1L);\n";
+    }
+    // TODO: this is more complicated.
+    // --head just sets CURLOPT_NOBODY and CURLOPT_FILETIME
+    // --upload-file just sets CURLOPT_UPLOAD and CURLOPT_INFILESIZE_LARGE
+    let expectedMethod = "GET";
+    if (request.data || request.multipartUploads) {
+        expectedMethod = "POST";
+    }
+    if (!eq(request.urls[0].method, expectedMethod)) {
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, " +
+                repr(request.urls[0].method, imports) +
+                ");\n";
+    }
+    if (request.interface) {
+        const interface_ = repr(request.interface, imports);
+        code += "  curl_easy_setopt(hnd, CURLOPT_INTERFACE, " + interface_ + ");\n";
+    }
+    if (request.krb) {
+        const krb = repr(request.krb, imports);
+        code += "  curl_easy_setopt(hnd, CURLOPT_KRBLEVEL, " + krb + ");\n";
+    }
+    if (request.connectTimeout) {
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_CONNECTTIMEOUT_MS, " +
+                atof1000(request.connectTimeout, imports) +
+                ");\n";
+    }
+    if (request.dohUrl) {
+        const dohUrl = repr(request.dohUrl, imports);
+        code += "  curl_easy_setopt(hnd, CURLOPT_DOH_URL, " + dohUrl + ");\n";
+    }
+    if (request.ciphers) {
+        const ciphers = repr(request.ciphers, imports);
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_SSL_CIPHER_LIST, " + ciphers + ");\n";
+    }
+    if (request.proxyCiphers) {
+        const proxyCiphers = repr(request.proxyCiphers, imports);
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_PROXY_SSL_CIPHER_LIST, " +
+                proxyCiphers +
+                ");\n";
+    }
+    if (request.tls13Ciphers) {
+        const tls13Ciphers = repr(request.tls13Ciphers, imports);
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_TLS13_CIPHERS, " + tls13Ciphers + ");\n";
+    }
+    if (request.proxyTls13Ciphers) {
+        const proxyTls13Ciphers = repr(request.proxyTls13Ciphers, imports);
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_PROXY_TLS13_CIPHERS, " +
+                proxyTls13Ciphers +
+                ");\n";
+    }
+    if (request.verbose) {
+        code += "  curl_easy_setopt(hnd, CURLOPT_VERBOSE, 1L);\n";
+    }
+    if (request.maxFilesize) {
+        // TODO: parse
+        const maxFilesize = atol(request.maxFilesize, imports);
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_MAXFILESIZE_LARGE, (curl_off_t)" +
+                maxFilesize +
+                ");\n";
+    }
+    // TODO: these should be mutually exclusive
+    if (request.ipv6) {
+        code += "  curl_easy_setopt(hnd, CURLOPT_IPRESOLVE, 2L);\n";
+    }
+    else if (request.ipv4) {
+        code += "  curl_easy_setopt(hnd, CURLOPT_IPRESOLVE, 1L);\n";
+    }
+    if (request.sslReqd || request.ssl) {
+        if (request.sslReqd) {
+            code +=
+                "  curl_easy_setopt(hnd, CURLOPT_USE_SSL, (long)CURLUSESSL_ALL);\n";
+        }
+        else if (request.ssl) {
+            code +=
+                "  curl_easy_setopt(hnd, CURLOPT_USE_SSL, (long)CURLUSESSL_TRY);\n";
+        }
+    }
+    if (request.socks5GssapiNec) {
+        code += "  curl_easy_setopt(hnd, CURLOPT_SOCKS5_GSSAPI_NEC, 1L);\n";
+    }
+    if (request.socks5Basic) {
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_SOCKS5_AUTH, (long)CURLAUTH_BASIC);\n";
+    }
+    else if (request.socks5Gssapi) {
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_SOCKS5_AUTH, (long)CURLAUTH_GSSNEGOTIATE);\n";
+    }
+    if (request.socks5GssapiService) {
+        const socks5GssapiService = repr(request.socks5GssapiService, imports);
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_PROXY_SERVICE_NAME, " +
+                socks5GssapiService +
+                ");\n";
+    }
+    if (request.serviceName) {
+        const serviceName = repr(request.serviceName, imports);
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_SERVICE_NAME, " + serviceName + ");\n";
+    }
+    if (request.proxyServiceName) {
+        const proxyServiceName = repr(request.proxyServiceName, imports);
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_PROXY_SERVICE_NAME, " +
+                proxyServiceName +
+                ");\n";
+    }
+    // TODO: check
+    if (request.ignoreContentLength) {
+        code += "  curl_easy_setopt(hnd, CURLOPT_IGNORE_CONTENT_LENGTH, 1L);\n";
+    }
+    if (request.ftpSkipPasvIp !== false) {
+        code += "  curl_easy_setopt(hnd, CURLOPT_FTP_SKIP_PASV_IP, 1L);\n";
+    }
+    if (request.keepAlive !== false) {
+        code += "  curl_easy_setopt(hnd, CURLOPT_TCP_KEEPALIVE, 1L);\n";
+        if (request.keepAliveTime) {
+            const keepAliveTime = atol(request.keepAliveTime, imports);
+            code +=
+                "  curl_easy_setopt(hnd, CURLOPT_TCP_KEEPIDLE, " +
+                    keepAliveTime +
+                    ");\n";
+            code +=
+                "  curl_easy_setopt(hnd, CURLOPT_TCP_KEEPINTVL, " +
+                    keepAliveTime +
+                    ");\n";
+        }
+    }
+    if (request.proto) {
+        // TODO: parse
+        const proto = repr(request.proto, imports);
+        code += "  curl_easy_setopt(hnd, CURLOPT_PROTOCOLS_STR, " + proto + ");\n";
+    }
+    if (request.protoRedir) {
+        // TODO: parse
+        const protoRedir = repr(request.protoRedir, imports);
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_REDIR_PROTOCOLS_STR, " +
+                protoRedir +
+                ");\n";
+    }
+    if (request.resolve) {
+        preamble += "  struct curl_slist *resolve;\n";
+        if (vars) {
+            vars += "\n";
+        }
+        vars += "  resolve = NULL;\n";
+        for (const line of request.resolve) {
+            vars +=
+                "  resolve = curl_slist_append(resolve, " +
+                    repr(line, imports) +
+                    ");\n";
+        }
+        code += "  curl_easy_setopt(hnd, CURLOPT_RESOLVE, resolve);\n";
+        cleanup += "  curl_slist_free_all(resolve);\n";
+        cleanup += "  resolve = NULL;\n";
+    }
+    if (request.connectTo) {
+        // TODO: camelCase snake_case orjustoneword?
+        preamble += "  struct curl_slist *connect_to;\n";
+        if (vars) {
+            vars += "\n";
+        }
+        vars += "  connect_to = NULL;\n";
+        for (const line of request.connectTo) {
+            vars +=
+                "  connect_to = curl_slist_append(connect_to, " +
+                    repr(line, imports) +
+                    ");\n";
+        }
+        code += "  curl_easy_setopt(hnd, CURLOPT_CONNECT_TO, connect_to);\n";
+        cleanup += "  curl_slist_free_all(connect_to);\n";
+        cleanup += "  connect_to = NULL;\n";
+    }
+    if (request.tlsuser) {
+        const tlsuser = repr(request.tlsuser, imports);
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_TLSAUTH_USERNAME, " + tlsuser + ");\n";
+    }
+    if (request.tlspassword) {
+        const tlspassword = repr(request.tlspassword, imports);
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_TLSAUTH_PASSWORD, " +
+                tlspassword +
+                ");\n";
+    }
+    if (request.tlsauthtype) {
+        const tlsauthtype = repr(request.tlsauthtype, imports);
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_TLSAUTH_TYPE, " + tlsauthtype + ");\n";
+    }
+    if (request.proxyTlsuser) {
+        const proxyTlsuser = repr(request.proxyTlsuser, imports);
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_PROXY_TLSAUTH_USERNAME, " +
+                proxyTlsuser +
+                ");\n";
+    }
+    if (request.proxyTlspassword) {
+        const proxyTlspassword = repr(request.proxyTlspassword, imports);
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_PROXY_TLSAUTH_PASSWORD, " +
+                proxyTlspassword +
+                ");\n";
+    }
+    if (request.proxyTlsauthtype) {
+        const proxyTlsauthtype = repr(request.proxyTlsauthtype, imports);
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_PROXY_TLSAUTH_TYPE, " +
+                proxyTlsauthtype +
+                ");\n";
+    }
+    if (request.delegation) {
+        if (eq(request.delegation, "always")) {
+            code += "  curl_easy_setopt(hnd, CURLOPT_GSSAPI_DELEGATION, 2L);\n";
+        }
+        else if (eq(request.delegation, "policy")) {
+            code += "  curl_easy_setopt(hnd, CURLOPT_GSSAPI_DELEGATION, 1L);\n";
+        }
+    }
+    if (request.saslAuthzid) {
+        const zid = repr(request.saslAuthzid, imports);
+        code += "  curl_easy_setopt(hnd, CURLOPT_SASL_AUTHZID, " + zid + ");\n";
+    }
+    if (request.saslIr) {
+        code += "  curl_easy_setopt(hnd, CURLOPT_SASL_IR, 1L);\n";
+    }
+    if (request.alpn === false) {
+        code += "  curl_easy_setopt(hnd, CURLOPT_SSL_ENABLE_ALPN, 0L);\n";
+    }
+    if (request.unixSocket) {
+        const socket = repr(request.unixSocket, imports);
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_UNIX_SOCKET_PATH, " + socket + ");\n";
+    }
+    if (request.abstractUnixSocket) {
+        const socket = repr(request.abstractUnixSocket, imports);
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_ABSTRACT_UNIX_SOCKET, " +
+                socket +
+                ");\n";
+    }
+    if (request.protoDefault) {
+        const protoDefault = repr(request.protoDefault, imports);
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_DEFAULT_PROTOCOL, " +
+                protoDefault +
+                ");\n";
+    }
+    if (request.expect100Timeout) {
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_EXPECT_100_TIMEOUT_MS, " +
+                atof1000(request.expect100Timeout, imports) +
+                ");\n";
+    }
+    if (request.happyEyeballsTimeoutMs) {
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_HAPPY_EYEBALLS_TIMEOUT_MS, " +
+                atol(request.happyEyeballsTimeoutMs, imports) +
+                ");\n";
+    }
+    if (request.haproxyClientIp) {
+        const haproxyClientIp = repr(request.haproxyClientIp, imports);
+        code +=
+            "  curl_easy_setopt(hnd, CURLOPT_HAPROXY_CLIENT_IP, " +
+                haproxyClientIp +
+                ");\n";
+    }
+    if (request.haproxyProtocol) {
+        code += "  curl_easy_setopt(hnd, CURLOPT_HAPROXYPROTOCOL, 1L);\n";
+    }
+    if (request.disallowUsernameInUrl) {
+        code += "  curl_easy_setopt(hnd, CURLOPT_DISALLOW_USERNAME_IN_URL, 1L);\n";
+    }
+    if (request.altSvc) {
+        const altSvc = repr(request.altSvc, imports);
+        code += "  curl_easy_setopt(hnd, CURLOPT_ALTSVC, " + altSvc + ");\n";
+    }
+    if (request.hsts) {
+        // TODO: warn that files aren't read?
+        const hsts = repr(request.hsts[request.hsts.length - 1], imports);
+        code += "  curl_easy_setopt(hnd, CURLOPT_HSTS, " + hsts + ");\n";
+    }
+    code += "\n";
+    code += "  ret = curl_easy_perform(hnd);\n";
+    let end = "";
+    end += "  return (int)ret;\n";
+    end += "}\n";
+    return (preamble +
+        (vars ? "\n" + vars : "") +
+        "\n" +
+        code +
+        "\n" +
+        cleanup +
+        "\n" +
+        end);
+}
+export function printImports(imps) {
+    let s = "";
+    for (const imp of Array.from(imps).sort()) {
+        s += "#include <" + imp + ">\n";
+    }
+    return s;
+}
+export function _toC(requests, warnings = []) {
+    const imports = new Set(["curl/curl.h"]);
+    const request = getFirst(requests, warnings, { cookieFiles: true });
+    const code = requestToC(request, warnings, imports);
+    return printImports(imports) + "\n" + code;
+}
+export function toCWarn(curlCommand, warnings = []) {
+    const requests = parse(curlCommand, supportedArgs, warnings);
+    const c = _toC(requests, warnings);
+    return [c, warnings];
+}
+export function toC(curlCommand) {
+    return toCWarn(curlCommand)[0];
+}
+//# sourceMappingURL=c.js.map