@scalar/snippetz 0.2.6 → 0.2.8

package/dist/httpsnippet-lite/dist/esm/helpers/code-builder.js

@@ -0,0 +1,60 @@
+const DEFAULT_INDENTATION_CHARACTER = '';
+const DEFAULT_LINE_JOIN = '\n';
+class CodeBuilder {
+    /**
+     * Helper object to format and aggragate lines of code.
+     * Lines are aggregated in a `code` array, and need to be joined to obtain a proper code snippet.
+     */
+    constructor({ indent, join } = {}) {
+        this.postProcessors = [];
+        this.code = [];
+        this.indentationCharacter = DEFAULT_INDENTATION_CHARACTER;
+        this.lineJoin = DEFAULT_LINE_JOIN;
+        /**
+         * Add given indentation level to given line of code
+         */
+        this.indentLine = (line, indentationLevel = 0) => {
+            const indent = this.indentationCharacter.repeat(indentationLevel);
+            return `${indent}${line}`;
+        };
+        /**
+         * Add the line at the beginning of the current lines
+         */
+        this.unshift = (line, indentationLevel) => {
+            const newLine = this.indentLine(line, indentationLevel);
+            this.code.unshift(newLine);
+        };
+        /**
+         * Add the line at the end of the current lines
+         */
+        this.push = (line, indentationLevel) => {
+            const newLine = this.indentLine(line, indentationLevel);
+            this.code.push(newLine);
+        };
+        /**
+         * Add an empty line at the end of current lines
+         */
+        this.blank = () => {
+            this.code.push('');
+        };
+        /**
+         * Concatenate all current lines using the given lineJoin, then apply any replacers that may have been added
+         */
+        this.join = () => {
+            const unreplacedCode = this.code.join(this.lineJoin);
+            const replacedOutput = this.postProcessors.reduce((accumulator, replacer) => replacer(accumulator), unreplacedCode);
+            return replacedOutput;
+        };
+        /**
+         * Often when writing modules you may wish to add a literal tag or bit of metadata that you wish to transform after other processing as a final step.
+         * To do so, you can provide a PostProcessor function and it will be run automatically for you when you call `join()` later on.
+         */
+        this.addPostProcessor = (postProcessor) => {
+            this.postProcessors = [...this.postProcessors, postProcessor];
+        };
+        this.indentationCharacter = indent || DEFAULT_INDENTATION_CHARACTER;
+        this.lineJoin = join !== null && join !== void 0 ? join : DEFAULT_LINE_JOIN;
+    }
+}
+
+export { CodeBuilder };

package/dist/httpsnippet-lite/dist/esm/helpers/escape.js

@@ -0,0 +1,72 @@
+/**
+ * Escape characters within a value to make it safe to insert directly into a
+ * snippet. Takes options which define the escape requirements.
+ *
+ * This is closely based on the JSON-stringify string serialization algorithm,
+ * but generalized for other string delimiters (e.g. " or ') and different escape
+ * characters (e.g. Powershell uses `)
+ *
+ * See https://tc39.es/ecma262/multipage/structured-data.html#sec-quotejsonstring
+ * for the complete original algorithm.
+ */
+function escapeString(rawValue, options = {}) {
+    const { delimiter = '"', escapeChar = '\\', escapeNewlines = true } = options;
+    const stringValue = rawValue.toString();
+    return [...stringValue]
+        .map(c => {
+        if (c === '\b') {
+            return `${escapeChar}b`;
+        }
+        else if (c === '\t') {
+            return `${escapeChar}t`;
+        }
+        else if (c === '\n') {
+            if (escapeNewlines) {
+                return `${escapeChar}n`;
+            }
+            return c; // Don't just continue, or this is caught by < \u0020
+        }
+        else if (c === '\f') {
+            return `${escapeChar}f`;
+        }
+        else if (c === '\r') {
+            if (escapeNewlines) {
+                return `${escapeChar}r`;
+            }
+            return c; // Don't just continue, or this is caught by < \u0020
+        }
+        else if (c === escapeChar) {
+            return escapeChar + escapeChar;
+        }
+        else if (c === delimiter) {
+            return escapeChar + delimiter;
+        }
+        else if (c < '\u0020' || c > '\u007E') {
+            // Delegate the trickier non-ASCII cases to the normal algorithm. Some of these
+            // are escaped as \uXXXX, whilst others are represented literally. Since we're
+            // using this primarily for header values that are generally (though not 100%
+            // strictly?) ASCII-only, this should almost never happen.
+            return JSON.stringify(c).slice(1, -1);
+        }
+        return c;
+    })
+        .join('');
+}
+/**
+ * Make a string value safe to insert literally into a snippet within single quotes,
+ * by escaping problematic characters, including single quotes inside the string,
+ * backslashes, newlines, and other special characters.
+ *
+ * If value is not a string, it will be stringified with .toString() first.
+ */
+const escapeForSingleQuotes = (value) => escapeString(value, { delimiter: "'" });
+/**
+ * Make a string value safe to insert literally into a snippet within double quotes,
+ * by escaping problematic characters, including double quotes inside the string,
+ * backslashes, newlines, and other special characters.
+ *
+ * If value is not a string, it will be stringified with .toString() first.
+ */
+const escapeForDoubleQuotes = (value) => escapeString(value, { delimiter: '"' });
+
+export { escapeForDoubleQuotes, escapeForSingleQuotes, escapeString };

package/dist/httpsnippet-lite/dist/esm/helpers/headers.js

@@ -0,0 +1,20 @@
+/**
+ * Given a headers object retrieve a specific header out of it via a case-insensitive key.
+ */
+const getHeaderName = (headers, name) => Object.keys(headers).find(header => header.toLowerCase() === name.toLowerCase());
+/**
+ * Given a headers object retrieve the contents of a header out of it via a case-insensitive key.
+ */
+const getHeader = (headers, name) => {
+    const headerName = getHeaderName(headers, name);
+    if (!headerName) {
+        return undefined;
+    }
+    return headers[headerName];
+};
+/**
+ * Determine if a given case-insensitive header exists within a header object.
+ */
+const hasHeader = (headers, name) => Boolean(getHeaderName(headers, name));
+
+export { getHeader, getHeaderName, hasHeader };

package/dist/httpsnippet-lite/dist/esm/helpers/shell.js

@@ -0,0 +1,16 @@
+/**
+ * Use 'strong quoting' using single quotes so that we only need to deal with nested single quote characters.
+ * see: http://wiki.bash-hackers.org/syntax/quoting#strong_quoting
+ */
+const quote = (value = '') => {
+    const safe = /^[a-z0-9-_/.@%^=:]+$/i;
+    const isShellSafe = safe.test(value);
+    if (isShellSafe) {
+        return value;
+    }
+    // if the value is not shell safe, then quote it
+    return `'${value.replace(/'/g, "'\\''")}'`;
+};
+const escape = (value) => value.replace(/\r/g, '\\r').replace(/\n/g, '\\n');
+
+export { escape, quote };

package/dist/httpsnippet-lite/dist/esm/targets/objc/helpers.js

@@ -0,0 +1,56 @@
+/**
+ * Create a string corresponding to a valid declaration and initialization of an Objective-C object literal.
+ *
+ * @param nsClass Class of the litteral
+ * @param name Desired name of the instance
+ * @param parameters Key-value object of parameters to translate to an Objective-C object litearal
+ * @param indent If true, will declare the litteral by indenting each new key/value pair.
+ * @return A valid Objective-C declaration and initialization of an Objective-C object litteral.
+ *
+ * @example
+ *   nsDeclaration('NSDictionary', 'params', {a: 'b', c: 'd'}, true)
+ *   // returns:
+ *   NSDictionary *params = @{ @"a": @"b",
+ *                             @"c": @"d" };
+ *
+ *   nsDeclaration('NSDictionary', 'params', {a: 'b', c: 'd'})
+ *   // returns:
+ *   NSDictionary *params = @{ @"a": @"b", @"c": @"d" };
+ */
+const nsDeclaration = (nsClass, name, parameters, indent) => {
+    const opening = `${nsClass} *${name} = `;
+    const literal = literalRepresentation(parameters, indent ? opening.length : undefined);
+    return `${opening}${literal};`;
+};
+/**
+ * Create a valid Objective-C string of a literal value according to its type.
+ *
+ * @param value Any JavaScript literal
+ */
+const literalRepresentation = (value, indentation) => {
+    const join = indentation === undefined ? ', ' : `,\n   ${' '.repeat(indentation)}`;
+    switch (Object.prototype.toString.call(value)) {
+        case '[object Number]':
+            return `@${value}`;
+        case '[object Array]': {
+            const valuesRepresentation = value.map((value) => literalRepresentation(value));
+            return `@[ ${valuesRepresentation.join(join)} ]`;
+        }
+        case '[object Object]': {
+            const keyValuePairs = [];
+            for (const key in value) {
+                keyValuePairs.push(`@"${key}": ${literalRepresentation(value[key])}`);
+            }
+            return `@{ ${keyValuePairs.join(join)} }`;
+        }
+        case '[object Boolean]':
+            return value ? '@YES' : '@NO';
+        default:
+            if (value === null || value === undefined) {
+                return '';
+            }
+            return `@"${value.toString().replace(/"/g, '\\"')}"`;
+    }
+};
+
+export { literalRepresentation, nsDeclaration };

package/dist/httpsnippet-lite/dist/esm/targets/php/helpers.js

@@ -0,0 +1,35 @@
+import { escapeString } from '../../helpers/escape.js';
+
+const convertType = (obj, indent, lastIndent) => {
+    lastIndent = lastIndent || '';
+    indent = indent || '';
+    switch (Object.prototype.toString.call(obj)) {
+        case '[object Null]':
+            return 'null';
+        case '[object Undefined]':
+            return 'null';
+        case '[object String]':
+            return `'${escapeString(obj, { delimiter: "'", escapeNewlines: false })}'`;
+        case '[object Number]':
+            return obj.toString();
+        case '[object Array]': {
+            const contents = obj
+                .map((item) => convertType(item, `${indent}${indent}`, indent))
+                .join(`,\n${indent}`);
+            return `[\n${indent}${contents}\n${lastIndent}]`;
+        }
+        case '[object Object]': {
+            const result = [];
+            for (const i in obj) {
+                if (Object.prototype.hasOwnProperty.call(obj, i)) {
+                    result.push(`${convertType(i, indent)} => ${convertType(obj[i], `${indent}${indent}`, indent)}`);
+                }
+            }
+            return `[\n${indent}${result.join(`,\n${indent}`)}\n${lastIndent}]`;
+        }
+        default:
+            return 'null';
+    }
+};
+
+export { convertType };

package/dist/httpsnippet-lite/dist/esm/targets/powershell/common.js

@@ -0,0 +1,51 @@
+import { CodeBuilder } from '../../helpers/code-builder.js';
+import { escapeString } from '../../helpers/escape.js';
+import { getHeader } from '../../helpers/headers.js';
+
+const generatePowershellConvert = (command) => {
+    const convert = ({ method, headersObj, cookies, uriObj, fullUrl, postData, allHeaders, }) => {
+        const { push, join } = new CodeBuilder();
+        const methods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'];
+        if (!methods.includes(method.toUpperCase())) {
+            return 'Method not supported';
+        }
+        const commandOptions = [];
+        // Add headers, including the cookies
+        const headers = Object.keys(headersObj);
+        // construct headers
+        if (headers.length) {
+            push('$headers=@{}');
+            headers.forEach(key => {
+                if (key !== 'connection') {
+                    // Not allowed
+                    push(`$headers.Add("${key}", "${escapeString(headersObj[key], { escapeChar: '`' })}")`);
+                }
+            });
+            commandOptions.push('-Headers $headers');
+        }
+        // construct cookies
+        if (cookies.length) {
+            push('$session = New-Object Microsoft.PowerShell.Commands.WebRequestSession');
+            cookies.forEach(cookie => {
+                push('$cookie = New-Object System.Net.Cookie');
+                push(`$cookie.Name = '${cookie.name}'`);
+                push(`$cookie.Value = '${cookie.value}'`);
+                push(`$cookie.Domain = '${uriObj.host}'`);
+                push('$session.Cookies.Add($cookie)');
+            });
+            commandOptions.push('-WebSession $session');
+        }
+        if (postData === null || postData === void 0 ? void 0 : postData.text) {
+            commandOptions.push(`-ContentType '${escapeString(getHeader(allHeaders, 'content-type'), {
+                delimiter: "'",
+                escapeChar: '`',
+            })}'`);
+            commandOptions.push(`-Body '${postData.text}'`);
+        }
+        push(`$response = ${command} -Uri '${fullUrl}' -Method ${method} ${commandOptions.join(' ')}`);
+        return join();
+    };
+    return convert;
+};
+
+export { generatePowershellConvert };

package/dist/httpsnippet-lite/dist/esm/targets/python/helpers.js

@@ -0,0 +1,61 @@
+/**
+ * Create a string corresponding to a Dictionary or Array literal representation with pretty option
+ * and indentation.
+ */
+function concatValues(concatType, values, pretty, indentation, indentLevel) {
+    const currentIndent = indentation.repeat(indentLevel);
+    const closingBraceIndent = indentation.repeat(indentLevel - 1);
+    const join = pretty ? `,\n${currentIndent}` : ', ';
+    const openingBrace = concatType === 'object' ? '{' : '[';
+    const closingBrace = concatType === 'object' ? '}' : ']';
+    if (pretty) {
+        return `${openingBrace}\n${currentIndent}${values.join(join)}\n${closingBraceIndent}${closingBrace}`;
+    }
+    if (concatType === 'object' && values.length > 0) {
+        return `${openingBrace} ${values.join(join)} ${closingBrace}`;
+    }
+    return `${openingBrace}${values.join(join)}${closingBrace}`;
+}
+/**
+ * Create a valid Python string of a literal value according to its type.
+ *
+ * @param {*} value Any JavaScript literal
+ * @param {Object} opts Target options
+ * @return {string}
+ */
+const literalRepresentation = (value, opts, indentLevel) => {
+    indentLevel = indentLevel === undefined ? 1 : indentLevel + 1;
+    switch (Object.prototype.toString.call(value)) {
+        case '[object Number]':
+            return value;
+        case '[object Array]': {
+            let pretty = false;
+            const valuesRepresentation = value.map(v => {
+                // Switch to prettify if the value is a dictionary with multiple keys
+                if (Object.prototype.toString.call(v) === '[object Object]') {
+                    pretty = Object.keys(v).length > 1;
+                }
+                return literalRepresentation(v, opts, indentLevel);
+            });
+            return concatValues('array', valuesRepresentation, pretty, opts.indent, indentLevel);
+        }
+        case '[object Object]': {
+            const keyValuePairs = [];
+            for (const key in value) {
+                keyValuePairs.push(`"${key}": ${literalRepresentation(value[key], opts, indentLevel)}`);
+            }
+            return concatValues('object', keyValuePairs, opts.pretty && keyValuePairs.length > 1, opts.indent, indentLevel);
+        }
+        case '[object Null]':
+            return 'None';
+        case '[object Boolean]':
+            return value ? 'True' : 'False';
+        default:
+            if (value === null || value === undefined) {
+                return '';
+            }
+            return `"${value.toString().replace(/"/g, '\\"')}"`;
+    }
+};
+
+export { literalRepresentation };

package/dist/httpsnippet-lite/dist/esm/targets/swift/helpers.js

@@ -0,0 +1,74 @@
+/**
+ * Create an string of given length filled with blank spaces
+ *
+ * @param length Length of the array to return
+ * @param str String to pad out with
+ */
+const buildString = (length, str) => str.repeat(length);
+/**
+ * Create a string corresponding to a Dictionary or Array literal representation with pretty option and indentation.
+ */
+const concatArray = (arr, pretty, indentation, indentLevel) => {
+    const currentIndent = buildString(indentLevel, indentation);
+    const closingBraceIndent = buildString(indentLevel - 1, indentation);
+    const join = pretty ? `,\n${currentIndent}` : ', ';
+    if (pretty) {
+        return `[\n${currentIndent}${arr.join(join)}\n${closingBraceIndent}]`;
+    }
+    return `[${arr.join(join)}]`;
+};
+/**
+ * Create a string corresponding to a valid declaration and initialization of a Swift array or dictionary literal
+ *
+ * @param name Desired name of the instance
+ * @param parameters Key-value object of parameters to translate to a Swift object litearal
+ * @param opts Target options
+ * @return {string}
+ */
+const literalDeclaration = (name, parameters, opts) => `let ${name} = ${literalRepresentation(parameters, opts)}`;
+/**
+ * Create a valid Swift string of a literal value according to its type.
+ *
+ * @param value Any JavaScript literal
+ * @param opts Target options
+ */
+const literalRepresentation = (value, opts, indentLevel) => {
+    indentLevel = indentLevel === undefined ? 1 : indentLevel + 1;
+    switch (Object.prototype.toString.call(value)) {
+        case '[object Number]':
+            return value;
+        case '[object Array]': {
+            // Don't prettify arrays nto not take too much space
+            let pretty = false;
+            const valuesRepresentation = value.map((v) => {
+                // Switch to prettify if the value is a dictionary with multiple keys
+                if (Object.prototype.toString.call(v) === '[object Object]') {
+                    pretty = Object.keys(v).length > 1;
+                }
+                return literalRepresentation(v, opts, indentLevel);
+            });
+            // @ts-expect-error needs better types
+            return concatArray(valuesRepresentation, pretty, opts.indent, indentLevel);
+        }
+        case '[object Object]': {
+            const keyValuePairs = [];
+            for (const key in value) {
+                keyValuePairs.push(`"${key}": ${literalRepresentation(value[key], opts, indentLevel)}`);
+            }
+            return concatArray(keyValuePairs, 
+            // @ts-expect-error needs better types
+            opts.pretty && keyValuePairs.length > 1, 
+            // @ts-expect-error needs better types
+            opts.indent, indentLevel);
+        }
+        case '[object Boolean]':
+            return value.toString();
+        default:
+            if (value === null || value === undefined) {
+                return '';
+            }
+            return `"${value.toString().replace(/"/g, '\\"')}"`;
+    }
+};
+
+export { literalDeclaration, literalRepresentation };

package/dist/plugins/c/libcurl/index.d.ts

@@ -0,0 +1,2 @@
+export * from './libcurl.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/c/libcurl/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/c/libcurl/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAA"}

package/dist/plugins/c/libcurl/index.js

@@ -0,0 +1 @@
+export { cLibcurl } from './libcurl.js';

package/dist/plugins/c/libcurl/libcurl.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from '../../../core/index.js';
+/**
+ * c/libcurl
+ */
+export declare const cLibcurl: Plugin;
+//# sourceMappingURL=libcurl.d.ts.map

package/dist/plugins/c/libcurl/libcurl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"libcurl.d.ts","sourceRoot":"","sources":["../../../../src/plugins/c/libcurl/libcurl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAKpC;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,MAOtB,CAAA"}

package/dist/plugins/c/libcurl/libcurl.js

@@ -0,0 +1,16 @@
+import { convertWithHttpSnippetLite } from '../../../core/utils/convertWithHttpSnippetLite.js';
+import { libcurl } from '../../../_virtual/client28.js';
+
+/**
+ * c/libcurl
+ */
+const cLibcurl = {
+    target: 'c',
+    client: 'libcurl',
+    generate(request) {
+        // TODO: Write an own converter
+        return convertWithHttpSnippetLite(libcurl, request);
+    },
+};
+
+export { cLibcurl };

package/dist/plugins/clojure/clj_http/clj_http.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from '../../../core/index.js';
+/**
+ * clojure/clj_http
+ */
+export declare const clojureCljhttp: Plugin;
+//# sourceMappingURL=clj_http.d.ts.map

package/dist/plugins/clojure/clj_http/clj_http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clj_http.d.ts","sourceRoot":"","sources":["../../../../src/plugins/clojure/clj_http/clj_http.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAKpC;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,MAO5B,CAAA"}

package/dist/plugins/clojure/clj_http/clj_http.js

@@ -0,0 +1,16 @@
+import { convertWithHttpSnippetLite } from '../../../core/utils/convertWithHttpSnippetLite.js';
+import { clj_http } from '../../../_virtual/client27.js';
+
+/**
+ * clojure/clj_http
+ */
+const clojureCljhttp = {
+    target: 'clojure',
+    client: 'clj_http',
+    generate(request) {
+        // TODO: Write an own converter
+        return convertWithHttpSnippetLite(clj_http, request);
+    },
+};
+
+export { clojureCljhttp };

package/dist/plugins/clojure/clj_http/index.d.ts

@@ -0,0 +1,2 @@
+export * from './clj_http.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/clojure/clj_http/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/clojure/clj_http/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA"}

package/dist/plugins/clojure/clj_http/index.js

@@ -0,0 +1 @@
+export { clojureCljhttp } from './clj_http.js';

package/dist/plugins/csharp/httpclient/httpclient.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from '../../../core/index.js';
+/**
+ * csharp/httpclient
+ */
+export declare const csharpHttpclient: Plugin;
+//# sourceMappingURL=httpclient.d.ts.map

package/dist/plugins/csharp/httpclient/httpclient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"httpclient.d.ts","sourceRoot":"","sources":["../../../../src/plugins/csharp/httpclient/httpclient.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAKpC;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAO9B,CAAA"}

package/dist/plugins/csharp/httpclient/httpclient.js

@@ -0,0 +1,16 @@
+import { convertWithHttpSnippetLite } from '../../../core/utils/convertWithHttpSnippetLite.js';
+import { httpclient } from '../../../_virtual/client26.js';
+
+/**
+ * csharp/httpclient
+ */
+const csharpHttpclient = {
+    target: 'csharp',
+    client: 'httpclient',
+    generate(request) {
+        // TODO: Write an own converter
+        return convertWithHttpSnippetLite(httpclient, request);
+    },
+};
+
+export { csharpHttpclient };

package/dist/plugins/csharp/httpclient/index.d.ts

@@ -0,0 +1,2 @@
+export * from './httpclient.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/csharp/httpclient/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/csharp/httpclient/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA"}

package/dist/plugins/csharp/httpclient/index.js

@@ -0,0 +1 @@
+export { csharpHttpclient } from './httpclient.js';

package/dist/plugins/csharp/restsharp/index.d.ts

@@ -0,0 +1,2 @@
+export * from './restsharp.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/csharp/restsharp/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/csharp/restsharp/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA"}

package/dist/plugins/csharp/restsharp/index.js

@@ -0,0 +1 @@
+export { csharpRestsharp } from './restsharp.js';

package/dist/plugins/csharp/restsharp/restsharp.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from '../../../core/index.js';
+/**
+ * csharp/restsharp
+ */
+export declare const csharpRestsharp: Plugin;
+//# sourceMappingURL=restsharp.d.ts.map

package/dist/plugins/csharp/restsharp/restsharp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"restsharp.d.ts","sourceRoot":"","sources":["../../../../src/plugins/csharp/restsharp/restsharp.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAKpC;;GAEG;AACH,eAAO,MAAM,eAAe,EAAE,MAO7B,CAAA"}

package/dist/plugins/csharp/restsharp/restsharp.js

@@ -0,0 +1,16 @@
+import { convertWithHttpSnippetLite } from '../../../core/utils/convertWithHttpSnippetLite.js';
+import { restsharp } from '../../../_virtual/client25.js';
+
+/**
+ * csharp/restsharp
+ */
+const csharpRestsharp = {
+    target: 'csharp',
+    client: 'restsharp',
+    generate(request) {
+        // TODO: Write an own converter
+        return convertWithHttpSnippetLite(restsharp, request);
+    },
+};
+
+export { csharpRestsharp };

package/dist/plugins/go/native/index.d.ts

@@ -0,0 +1,2 @@
+export * from './native.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/go/native/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/go/native/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA"}

package/dist/plugins/go/native/index.js

@@ -0,0 +1 @@
+export { goNative } from './native.js';

package/dist/plugins/go/native/native.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from '../../../core/index.js';
+/**
+ * go/native
+ */
+export declare const goNative: Plugin;
+//# sourceMappingURL=native.d.ts.map

package/dist/plugins/go/native/native.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native.d.ts","sourceRoot":"","sources":["../../../../src/plugins/go/native/native.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAKpC;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,MAOtB,CAAA"}