@redocly/openapi-docs 3.12.0 → 3.12.2

package/lib/services/OpenAPIParser.js

@@ -1 +1,321 @@
-import{IS_BROWSER as q,isObject as S,isString as E,isUndefined as o}from"@redocly/theme/core/openapi";import{tryDecodeURIComponent as B,getDefinitionName as v}from"../utils/index.js";import{JsonPointer as x}from"../utils/JsonPointer.js";import{normalizeOptions as W}from"./config-options/normalizeOptions.js";function A(m,e){return e&&m[m.length-1]!==e?[...m,e]:m}function R(m,e){return e?m.concat(e):m}class V{options;definitionUrl;definition;allowMergeRefs=!1;constructor(e,t,l=W({})){this.options=l,this.definition=Object.assign({},e),this.validate(e),this.definition=e,this.allowMergeRefs=e.openapi.startsWith("3.1");const n=q?window.location.href:"";E(t)&&(this.definitionUrl=new URL(t,n).href)}validate(e){if(o(e.openapi))throw new Error("Document must be valid OpenAPI 3.0.0 definition")}byRef=e=>{let t;if(this.definition){e.charAt(0)!=="#"&&(e="#"+e),e=B(e);try{t=x.get(this.definition,e)}catch{}return t||{}}};isRef(e){return e?(e=e,e.$ref!==void 0&&e.$ref!==null):!1}deref(e,t=[],l=!1,n=0){const i=e?.["x-refsStack"];if(t=R(t,i),n>5)return{resolved:Object.assign({},e,{"x-complex":!0}),refsStack:t};if(this.isRef(e)){const r=v(e.$ref);if(r&&this.options.ignoreNamedSchemas.has(r))return{resolved:{type:"object",title:r},refsStack:t};let s=this.byRef(e.$ref);if(!s)throw new Error(`Failed to resolve $ref "${e.$ref}"`);return t.includes(e.$ref)?s=Object.assign({},s,{"x-circular-ref":!0}):this.isRef(s)&&(s=this.deref(s,t,l,n).resolved),this.allowMergeRefs&&(s=this.mergeRefs(e,s,l)),{resolved:s,refsStack:A(t,e.$ref)}}return{resolved:e,refsStack:R(t,i)}}mergeRefs(e,t,l){const{$ref:n,...i}=e,r=Object.keys(i);if(r.length===0)return t;if(l&&r.some(s=>!["description","title","externalDocs","x-refsStack","x-parentRefs","readOnly","writeOnly","x-complex"].includes(s))){const{description:s,title:p,readOnly:u,writeOnly:d,...O}=i;return{allOf:[{description:s,title:p,readOnly:u,writeOnly:d},t,O]}}else return{...t,...i}}mergeAllOf(e,t,l,n="",i=0){if(e["x-circular-ref"])return e;if(e=this.hoistOneOfs(e),e.allOf===void 0)return{absolutePointer:n,...e};let r={...e,"x-parentRefs":[],absolutePointer:x.join(n,["allOf"]),allOf:void 0,title:i===0?e.title||v(t):e.title};!o(r.properties)&&S(r.properties)&&(r.properties={...r.properties}),!o(r.items)&&S(r.items)&&(r.items={...r.items});const s=e.allOf.map((p,u)=>{const{resolved:d,refsStack:O}=this.deref(p,l,!0,i),f=p.$ref,y=f||x.join(n,[String(u)]);if(d["x-complex"])return{$ref:f,refsStack:A(O,f),schema:{"x-complex":!0},absolutePointer:y};const a=this.mergeAllOf(d,f,O,y,i+1);if(!(a["x-circular-ref"]&&a.allOf))return f&&r["x-parentRefs"]?.push(...a["x-parentRefs"]||[],f),{$ref:f,refsStack:A(O,f),schema:a,absolutePointer:y}}).filter(Boolean);for(const[p,{schema:u,refsStack:d,absolutePointer:O}]of s.entries()){const{type:f,enum:y,properties:a,items:b,required:w,title:I,description:D,readOnly:C,writeOnly:M,oneOf:$,anyOf:k,"x-circular-ref":g,"x-complex":P,...N}=u||{};if(!(r.type!==f&&!o(r.type)&&!o(f)&&!i)){if(o(f)||(Array.isArray(f)&&Array.isArray(r.type)?r.type=[...f,...r.type]:r.type=f),o(y)||(Array.isArray(y)&&Array.isArray(r.enum)?r.enum=Array.from(new Set([...y,...r.enum])):r.enum=y),!o(a)&&S(a)){r.properties=r.properties||{};for(const c in a){const h=R(d,a[c]?.["x-refsStack"]);if(!r.properties[c])r.properties[c]={...a[c],absolutePointer:x.join(O,["properties",c]),"x-refsStack":h};else if(!g){const U=this.mergeAllOf({allOf:[r.properties[c],a[c]],"x-refsStack":h},t+"/properties/"+c,h,x.join(O,["allOf",String(p),"properties",c]),i+1);r.properties[c]=U}}}if(!o(b)&&!g&&!P){const c=typeof r.items=="boolean"?{}:Object.assign({},r.items),h=typeof u.items=="boolean"?{}:Object.assign({},u.items);r.items=this.mergeAllOf({allOf:[c,h]},t+"/items",d,"",i+1)}o($)||(r.oneOf=$),o(k)||(r.anyOf=k),Array.isArray(w)&&(r.required=[...r.required||[],...w]),r={...r,title:r.title||I,description:r.description||D,readOnly:o(r.readOnly)?C:r.readOnly,writeOnly:o(r.writeOnly)?M:r.writeOnly,"x-circular-ref":r["x-circular-ref"]||g,"x-complex":r["x-complex"]||P,...N}}}return r}findDerived(e){const t={},l=this.definition.components&&this.definition.components.schemas||{};for(const n in l){const{resolved:i}=this.deref(l[n]);!o(i.allOf)&&i.allOf.find(r=>!o(r.$ref)&&e.indexOf(r.$ref)>-1)&&(t["#/components/schemas/"+n]=[i["x-discriminator-value"]||n])}return t}hoistOneOfs(e){if(o(e.allOf))return e;const{allOf:t,...l}=e;for(let n=0;n<t.length;n++){const{oneOf:i,...r}=t[n];if(i&&Array.isArray(i)){const s=t.slice(0,n),p=t.slice(n+1),u=Object.keys(r).length>0?[r]:[];return{...l,oneOf:i.map(d=>({allOf:[...s,...u,d,...p]}))}}}return e}}export{V as OpenAPIParser,R as concatRefStacks,A as pushRef};
+import { IS_BROWSER, isObject, isString, isUndefined } from '@redocly/theme/core/openapi';
+import { tryDecodeURIComponent, getDefinitionName } from '../utils/index.js';
+import { JsonPointer } from '../utils/JsonPointer.js';
+import { normalizeOptions } from './config-options/normalizeOptions.js';
+/**
+ * Loads and keeps spec. Provides raw spec operations
+ */
+export function pushRef(stack, ref) {
+    return ref && stack[stack.length - 1] !== ref ? [...stack, ref] : stack;
+}
+export function concatRefStacks(base, stack) {
+    return stack ? base.concat(stack) : base;
+}
+export class OpenAPIParser {
+    options;
+    definitionUrl;
+    definition;
+    // private _refCounter: RefCounter = new RefCounter();
+    allowMergeRefs = false;
+    constructor(definition, definitionUrl, options = normalizeOptions({})) {
+        this.options = options;
+        this.definition = Object.assign({}, definition);
+        this.validate(definition);
+        this.definition = definition;
+        this.allowMergeRefs = definition.openapi.startsWith('3.1');
+        const href = IS_BROWSER ? window.location.href : '';
+        if (isString(definitionUrl)) {
+            this.definitionUrl = new URL(definitionUrl, href).href;
+        }
+    }
+    validate(spec) {
+        if (isUndefined(spec.openapi)) {
+            throw new Error('Document must be valid OpenAPI 3.0.0 definition');
+        }
+    }
+    /**
+     * get spec part by JsonPointer ($ref)
+     */
+    byRef = (ref) => {
+        let res;
+        if (!this.definition) {
+            return;
+        }
+        if (ref.charAt(0) !== '#') {
+            ref = '#' + ref;
+        }
+        ref = tryDecodeURIComponent(ref);
+        try {
+            res = JsonPointer.get(this.definition, ref);
+        }
+        catch {
+            // do nothing
+        }
+        return res || {};
+    };
+    /**
+     * checks if the object is OpenAPI reference (contains $ref property)
+     */
+    isRef(obj) {
+        if (!obj) {
+            return false;
+        }
+        obj = obj;
+        return obj.$ref !== undefined && obj.$ref !== null;
+    }
+    /**
+     * Resolve given reference object or return as is if it is not a reference
+     * @param obj object to dereference
+     * @param baseRefsStack
+     * @param mergeAsAllOf
+     */
+    deref(obj, baseRefsStack = [], mergeAsAllOf = false, level = 0) {
+        // this can be set by all of when it merges props from different sources
+        const objRefsStack = obj?.['x-refsStack'];
+        baseRefsStack = concatRefStacks(baseRefsStack, objRefsStack);
+        if (level > 5) {
+            return {
+                resolved: Object.assign({}, obj, { 'x-complex': true }),
+                refsStack: baseRefsStack,
+            };
+        }
+        if (this.isRef(obj)) {
+            const schemaName = getDefinitionName(obj.$ref);
+            if (schemaName && this.options.ignoreNamedSchemas.has(schemaName)) {
+                return { resolved: { type: 'object', title: schemaName }, refsStack: baseRefsStack };
+            }
+            let resolved = this.byRef(obj.$ref);
+            if (!resolved) {
+                throw new Error(`Failed to resolve $ref "${obj.$ref}"`);
+            }
+            if (baseRefsStack.includes(obj.$ref)) {
+                resolved = Object.assign({}, resolved, { 'x-circular-ref': true });
+            }
+            else if (this.isRef(resolved)) {
+                const res = this.deref(resolved, baseRefsStack, mergeAsAllOf, level);
+                resolved = res.resolved;
+            }
+            if (this.allowMergeRefs) {
+                resolved = this.mergeRefs(obj, resolved, mergeAsAllOf);
+            }
+            return { resolved, refsStack: pushRef(baseRefsStack, obj.$ref) };
+        }
+        return {
+            resolved: obj,
+            refsStack: concatRefStacks(baseRefsStack, objRefsStack),
+        };
+    }
+    mergeRefs(ref, resolved, mergeAsAllOf) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { $ref, ...rest } = ref;
+        const keys = Object.keys(rest);
+        if (keys.length === 0) {
+            return resolved;
+        }
+        if (mergeAsAllOf &&
+            keys.some((k) => ![
+                'description',
+                'title',
+                'externalDocs',
+                'x-refsStack',
+                'x-parentRefs',
+                'readOnly',
+                'writeOnly',
+                'x-complex',
+            ].includes(k))) {
+            const { description, title, readOnly, writeOnly, ...restSchema } = rest;
+            return {
+                allOf: [{ description, title, readOnly, writeOnly }, resolved, restSchema],
+            };
+        }
+        else {
+            // small optimization
+            return {
+                ...resolved,
+                ...rest,
+            };
+        }
+    }
+    /**
+     * Merge allOf constraints.
+     * @param schema schema with allOF
+     * @param $ref pointer of the schema
+     * @param refsStack
+     * @param absolutePointer
+     */
+    mergeAllOf(schema, $ref, refsStack, absolutePointer = '', level = 0) {
+        if (schema['x-circular-ref']) {
+            return schema;
+        }
+        schema = this.hoistOneOfs(schema);
+        if (schema.allOf === undefined) {
+            return { absolutePointer, ...schema };
+        }
+        let receiver = {
+            ...schema,
+            'x-parentRefs': [],
+            absolutePointer: JsonPointer.join(absolutePointer, ['allOf']),
+            allOf: undefined,
+            title: level === 0 ? schema.title || getDefinitionName($ref) : schema.title,
+        };
+        // avoid mutating inner objects
+        if (!isUndefined(receiver.properties) && isObject(receiver.properties)) {
+            receiver.properties = { ...receiver.properties };
+        }
+        if (!isUndefined(receiver.items) && isObject(receiver.items)) {
+            receiver.items = { ...receiver.items };
+        }
+        const allOfSchemas = schema.allOf
+            .map((subSchema, index) => {
+            const { resolved, refsStack: subRefsStack } = this.deref(subSchema, refsStack, true, level);
+            const subRef = subSchema.$ref;
+            const subAbsolutePointer = subRef || JsonPointer.join(absolutePointer, [String(index)]);
+            if (resolved['x-complex']) {
+                return {
+                    $ref: subRef,
+                    refsStack: pushRef(subRefsStack, subRef),
+                    schema: { 'x-complex': true },
+                    absolutePointer: subAbsolutePointer,
+                };
+            }
+            const subMerged = this.mergeAllOf(resolved, subRef, subRefsStack, subAbsolutePointer, level + 1);
+            if (subMerged['x-circular-ref'] && subMerged.allOf) {
+                // if mergeAllOf is circular and still contains allOf, we should ignore it
+                return undefined;
+            }
+            if (subRef) {
+                // collect information for implicit descriminator lookup
+                receiver['x-parentRefs']?.push(...(subMerged['x-parentRefs'] || []), subRef);
+            }
+            return {
+                $ref: subRef,
+                refsStack: pushRef(subRefsStack, subRef),
+                schema: subMerged,
+                absolutePointer: subAbsolutePointer,
+            };
+        })
+            .filter(Boolean);
+        for (const [index, { schema: subSchema, refsStack: subRefsStack, absolutePointer },] of allOfSchemas.entries()) {
+            const { type, enum: enumProperty, properties, items, required, title, description, readOnly, writeOnly, oneOf, anyOf, 'x-circular-ref': isCircular, 'x-complex': isComplex, ...otherConstraints } = subSchema || {};
+            if (receiver.type !== type && !isUndefined(receiver.type) && !isUndefined(type) && !level) {
+                // console.warn(`Incompatible types in allOf at "${$ref}": "${receiver.type}" and "${type}"`);
+                continue;
+            }
+            if (!isUndefined(type)) {
+                if (Array.isArray(type) && Array.isArray(receiver.type)) {
+                    receiver.type = [...type, ...receiver.type];
+                }
+                else {
+                    receiver.type = type;
+                }
+            }
+            if (!isUndefined(enumProperty)) {
+                if (Array.isArray(enumProperty) && Array.isArray(receiver.enum)) {
+                    receiver.enum = Array.from(new Set([...enumProperty, ...receiver.enum]));
+                }
+                else {
+                    receiver.enum = enumProperty;
+                }
+            }
+            if (!isUndefined(properties) && isObject(properties)) {
+                receiver.properties = receiver.properties || {};
+                for (const prop in properties) {
+                    const propRefsStack = concatRefStacks(subRefsStack, properties[prop]?.['x-refsStack']);
+                    if (!receiver.properties[prop]) {
+                        receiver.properties[prop] = {
+                            ...properties[prop],
+                            absolutePointer: JsonPointer.join(absolutePointer, ['properties', prop]),
+                            'x-refsStack': propRefsStack,
+                        };
+                    }
+                    else if (!isCircular) {
+                        // merge inner properties
+                        const mergedProp = this.mergeAllOf({
+                            allOf: [receiver.properties[prop], properties[prop]],
+                            'x-refsStack': propRefsStack,
+                        }, $ref + '/properties/' + prop, propRefsStack, JsonPointer.join(absolutePointer, ['allOf', String(index), 'properties', prop]), level + 1);
+                        receiver.properties[prop] = mergedProp;
+                    }
+                }
+            }
+            if (!isUndefined(items) && !isCircular && !isComplex) {
+                const receiverItems = typeof receiver.items === 'boolean'
+                    ? {}
+                    : Object.assign({}, receiver.items);
+                const subSchemaItems = typeof subSchema.items === 'boolean'
+                    ? {}
+                    : Object.assign({}, subSchema.items);
+                // merge inner properties
+                receiver.items = this.mergeAllOf({
+                    allOf: [receiverItems, subSchemaItems],
+                }, $ref + '/items', subRefsStack, '', level + 1);
+            }
+            if (!isUndefined(oneOf)) {
+                receiver.oneOf = oneOf;
+            }
+            if (!isUndefined(anyOf)) {
+                receiver.anyOf = anyOf;
+            }
+            if (Array.isArray(required)) {
+                receiver.required = [...(receiver.required || []), ...required];
+            }
+            // merge rest of constraints
+            // TODO: do more intelligent merge
+            receiver = {
+                ...receiver,
+                title: receiver.title || title,
+                description: receiver.description || description,
+                readOnly: !isUndefined(receiver.readOnly) ? receiver.readOnly : readOnly,
+                writeOnly: !isUndefined(receiver.writeOnly) ? receiver.writeOnly : writeOnly,
+                'x-circular-ref': receiver['x-circular-ref'] || isCircular,
+                'x-complex': receiver['x-complex'] || isComplex,
+                ...otherConstraints,
+            };
+        }
+        return receiver;
+    }
+    /**
+     * Find all derived definitions among #/components/schemas from any of $refs
+     * returns map of definition pointer to definition name
+     * @param $refs array of references to find derived from
+     */
+    findDerived($refs) {
+        const res = {};
+        const schemas = (this.definition.components && this.definition.components.schemas) || {};
+        for (const defName in schemas) {
+            const { resolved: def } = this.deref(schemas[defName]);
+            if (!isUndefined(def.allOf) &&
+                def.allOf.find((obj) => !isUndefined(obj.$ref) && $refs.indexOf(obj.$ref) > -1)) {
+                res['#/components/schemas/' + defName] = [def['x-discriminator-value'] || defName];
+            }
+        }
+        return res;
+    }
+    hoistOneOfs(schema) {
+        if (isUndefined(schema.allOf)) {
+            return schema;
+        }
+        const { allOf, ...restSchema } = schema;
+        for (let i = 0; i < allOf.length; i++) {
+            const { oneOf, ...sub } = allOf[i];
+            if (!oneOf) {
+                continue;
+            }
+            if (Array.isArray(oneOf)) {
+                const beforeAllOf = allOf.slice(0, i);
+                const afterAllOf = allOf.slice(i + 1);
+                const siblingValues = Object.keys(sub).length > 0 ? [sub] : [];
+                return {
+                    ...restSchema,
+                    oneOf: oneOf.map((part) => {
+                        return {
+                            allOf: [...beforeAllOf, ...siblingValues, part, ...afterAllOf],
+                        };
+                    }),
+                };
+            }
+        }
+        return schema;
+    }
+}
+//# sourceMappingURL=OpenAPIParser.js.map

package/lib/services/check.js

@@ -1 +1,104 @@
-import{cryptoLib as o}from"./utils.js";function u(e){return"then"in e?e:new Promise(t=>{e.oncomplete=r=>{t(r.target.result)}})}function l(e){const t=new ArrayBuffer(e.length),r=new Uint8Array(t);for(let i=0,n=e.length;i<n;i++)r[i]=e.charCodeAt(i);return t}const a=()=>{const e=l(atob(typeof REDOCLY_PUBLIC_KEY<"u"?REDOCLY_PUBLIC_KEY:"MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAMHjNir5fXx/ZXoaEeXQ5XyxbNJ4YJYczoCRdSkL6NLzw1FHnng5Vfcgk5+bvox9QRYRbuk84mA4f2NhywDbXKECAwEAAQ=="));return u(o?.subtle.importKey("spki",e,{name:"RSASSA-PKCS1-v1_5",hash:"SHA-256"},!0,["verify"]))};function f(e){if(window.TextEncoder)return new TextEncoder().encode(e);const t=unescape(encodeURIComponent(e)),r=new Uint8Array(t.length);for(let i=0;i<t.length;i++)r[i]=t.charCodeAt(i);return r}async function c(e,t){return u(o?.subtle.verify({name:"RSASSA-PKCS1-v1_5",hash:"SHA-256"},await a(),l(atob(t)),f(e)))}function s(e,t){return t===!0?!0:Array.isArray(t)&&typeof window<"u"?e==="localhost"||e==="127.0.0.1"||e.endsWith(".localhost")||t.find(r=>r===e||e.endsWith("."+r))?!0:!!t.find(r=>{if(r.indexOf("*")!==r.lastIndexOf("*"))return;const[i,n]=r.split("*");return n&&e.startsWith(i)&&e.endsWith(n)&&n.split(".").length>2}):!1}async function d(e){if(process.env.NODE_ENV==="development")return{valid:!0,allowed:!0};const t=window.location.hostname;if(!e)return t==="localhost"||t==="127.0.0.1"||t.endsWith(".localhost")?{local:!0}:{};const[r,i]=e.split(".");let n;try{if(!await c(atob(r),i))return{valid:!1};n=JSON.parse(atob(r))}catch{return{valid:!1,cryptoMissing:!0}}return n.valid=!0,(!n.e||Date.now()/1e3>n.e)&&(n.expired=!0),n.allowed=s(t,n.h),n}export{d as default,s as isHostAllowed};
+import { cryptoLib } from './utils.js';
+function promisifyIECryptoRes(res) {
+    if ('then' in res) {
+        return res;
+    }
+    else {
+        return new Promise((resolve) => {
+            res.oncomplete = (e) => {
+                resolve(e.target.result);
+            };
+        });
+    }
+}
+function str2ab(str) {
+    const buf = new ArrayBuffer(str.length);
+    const bufView = new Uint8Array(buf);
+    for (let i = 0, strLen = str.length; i < strLen; i++) {
+        bufView[i] = str.charCodeAt(i);
+    }
+    return buf;
+}
+const getKey = () => {
+    const publickeyDer = str2ab(atob(typeof REDOCLY_PUBLIC_KEY !== 'undefined'
+        ? REDOCLY_PUBLIC_KEY
+        : 'MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAMHjNir5fXx/ZXoaEeXQ5XyxbNJ4YJYczoCRdSkL6NLzw1FHnng5Vfcgk5+bvox9QRYRbuk84mA4f2NhywDbXKECAwEAAQ=='));
+    return promisifyIECryptoRes(cryptoLib?.subtle.importKey('spki', publickeyDer, {
+        name: 'RSASSA-PKCS1-v1_5',
+        hash: 'SHA-256',
+    }, true, ['verify']));
+};
+function textEncode(str) {
+    if (window.TextEncoder) {
+        return new TextEncoder().encode(str);
+    }
+    const utf8 = unescape(encodeURIComponent(str));
+    const result = new Uint8Array(utf8.length);
+    for (let i = 0; i < utf8.length; i++) {
+        result[i] = utf8.charCodeAt(i);
+    }
+    return result;
+}
+async function verify(message, signature) {
+    return promisifyIECryptoRes(cryptoLib?.subtle.verify({ name: 'RSASSA-PKCS1-v1_5', hash: 'SHA-256' }, await getKey(), str2ab(atob(signature)), textEncode(message)));
+}
+export function isHostAllowed(hostname, hosts) {
+    if (hosts === true)
+        return true;
+    if (Array.isArray(hosts) && typeof window !== 'undefined') {
+        if (hostname === 'localhost' ||
+            hostname === '127.0.0.1' ||
+            hostname.endsWith('.localhost') ||
+            !!hosts.find((h) => h === hostname || hostname.endsWith('.' + h))) {
+            return true;
+        }
+        return !!hosts.find((h) => {
+            if (h.indexOf('*') !== h.lastIndexOf('*'))
+                return;
+            const [leftPart, rightPart] = h.split('*');
+            return (rightPart &&
+                hostname.startsWith(leftPart) &&
+                hostname.endsWith(rightPart) &&
+                rightPart.split('.').length > 2);
+        });
+    }
+    return false;
+}
+// TODO: add tests
+export default async function parse(key) {
+    if (process.env.NODE_ENV === 'development') {
+        return {
+            valid: true,
+            allowed: true,
+        };
+    }
+    const hostname = window.location.hostname;
+    if (!key) {
+        if (hostname === 'localhost' || hostname === '127.0.0.1' || hostname.endsWith('.localhost')) {
+            return {
+                local: true,
+            };
+        }
+        else {
+            return {};
+        }
+    }
+    const [token, signature] = key.split('.');
+    let info;
+    try {
+        if (!(await verify(atob(token), signature))) {
+            return { valid: false };
+        }
+        info = JSON.parse(atob(token));
+    }
+    catch {
+        return { valid: false, cryptoMissing: true };
+    }
+    info.valid = true;
+    if (!info.e || Date.now() / 1000 > info.e) {
+        info.expired = true;
+    }
+    info.allowed = isHostAllowed(hostname, info.h);
+    return info;
+}
+//# sourceMappingURL=check.js.map

package/lib/services/code-samples/constants.js

@@ -1 +1,16 @@
-const a={curl:"curl",JavaScript:"JavaScript",NodeJs:"Node.js",Python:"Python",Java:"Java",CSharp:"C#",PHP:"PHP",Go:"Go",Ruby:"Ruby",R:"R",Payload:"Payload"};export{a as Languages};
+export const Languages = {
+    curl: 'curl',
+    JavaScript: 'JavaScript',
+    NodeJs: 'Node.js',
+    Python: 'Python',
+    Java: 'Java',
+    // Java8: 'Java8+Apache',
+    CSharp: 'C#',
+    // CSharpNewtonsoft: 'C#+Newtonsoft',
+    PHP: 'PHP',
+    Go: 'Go',
+    Ruby: 'Ruby',
+    R: 'R',
+    Payload: 'Payload',
+};
+//# sourceMappingURL=constants.js.map