@redocly/openapi-docs 3.12.0-rc.7 → 3.12.1

package/lib/services/code-samples/httpsnippet/helpers/code-builder.js

@@ -1,3 +1,252 @@
-import*as S from"util";import{Lang as i,NamingVariableConventions as l,VariableType as c}from"./constants.js";import o from"./string-utility.js";const p={[i.NODEJS]:l.CAMEL_CASE,[i.JAVASCRIPT]:l.CAMEL_CASE,[i.PYTHON]:l.UNDER_SCORES,[i.JAVA8]:l.CAMEL_CASE,[i.JAVA]:l.CAMEL_CASE,[i.CSHARP]:l.PASCAL_CASE,[i.CSHARPNEWTONSOFT]:l.PASCAL_CASE,[i.CURL]:l.CAMEL_CASE,[i.GO]:l.CAMEL_CASE,[i.PHP]:l.CAMEL_CASE,[i.RUBY]:l.UNDER_SCORES,[i.R]:l.UNDER_SCORES},u={default:{joinSymbol:"",variableWrapperFn:a=>a,stringLiteral:a=>a,variableDeclaration:a=>a,urlFieldName:"url"},[i.CSHARP]:{joinSymbol:" + ",stringLiteral:a=>`"${a}"`,variableDeclaration:a=>`var ${a} = "%s";`,urlFieldName:"fullUrl"},[i.CSHARPNEWTONSOFT]:{joinSymbol:" + ",stringLiteral:a=>`"${a}"`,variableDeclaration:a=>`var ${a} = "%s";`,urlFieldName:"fullUrl"},[i.GO]:{joinSymbol:" + ",stringLiteral:a=>`"${a}"`,variableDeclaration:a=>`${a} := "%s";`},[i.JAVA]:{joinSymbol:" + ",stringLiteral:a=>`"${a}"`,variableDeclaration:a=>`var ${a} = "%s";`,urlFieldName:"pathname"},[i.JAVA8]:{joinSymbol:" + ",stringLiteral:a=>`"${a}"`,variableDeclaration:a=>`String ${a} = "%s";`,urlFieldName:"fullUrl"},[i.JAVASCRIPT]:{variableWrapperFn:a=>"${"+a+"}",variableDeclaration:a=>`const ${a} = '%s';`},[i.NODEJS]:{variableWrapperFn:a=>"${"+a+"}",variableDeclaration:a=>`const ${a} = '%s';`},[i.PHP]:{joinSymbol:" . ",stringLiteral:a=>`"${a}"`,variableDeclaration:a=>`const ${a} = "%s";`},[i.PYTHON]:{stringLiteral:a=>`"${a}"`,joinSymbol:" + ",variableDeclaration:a=>`${a} = "%s"`},[i.RUBY]:{joinSymbol:" + ",stringLiteral:a=>`'${a}'`,variableDeclaration:a=>`${a} = '%s'`},[i.CURL]:{variableWrapperFn:(a,e)=>e||`{${a}}`,urlFieldName:"fullUrl",rawName:!0},[i.R]:{joinSymbol:" %&% ",variableDeclaration:a=>`${a} = "%s"`,urlFieldName:"fullUrl",stringLiteral:a=>`"${a}"`,variableWrapperFn:a=>`${a}`}},C=["response","request","requests","data","url","payload","main","accessToken","resp","Program","client","postData","App","httpClient","params","pathname","host","body","fetch","query"];class h{code;indentation;variablesPrefix;lineJoin;capitalize;lang;langOptions;constructor({indentation:e,lineJoin:t=`
-`,variablesPrefix:r="",capitalize:n=!1,lang:s=i.CURL}){this.code=[],this.indentation=e,this.variablesPrefix=r,this.lineJoin=t||`
-`,this.capitalize=n,this.lang=s,this.langOptions={...u.default,...u[s]}}buildLine(e,t){let r="",n=2;if(typeof e=="string")n=1,t=e,e=0;else if(e===null)return null;for(;e;)r+=this.indentation,e--;const s=Array.prototype.slice.call(arguments,n,arguments.length);return s.unshift(r+t),S.format.apply(this,s)}unshift(...e){return this.code.unshift(this.buildLine.apply(this,e)),this}push(...e){return this.code.push(this.buildLine.apply(this,e)),this}blank(){return this.code.push(null),this}join(){return this.code.join(this.lineJoin)}clean(){this.code.splice(1)}var(e,t=c.CUSTOM){if(t===c.PATH){let r=this.variablesPrefix+e;switch(C.includes(r)&&(r=`${r}_path`),p[this.lang]){case l.UNDER_SCORES:r=o.toSnakeCase(r);break;case l.PASCAL_CASE:r=o.toPascalCase(r);break;case l.CAMEL_CASE:default:r=o.toCamelCase(r);break}return r}return this.variablesPrefix?this.variablesPrefix+(this.capitalize?o.toPascalCase(e):e):e}}export{h as CodeBuilder};
+import * as util from 'util';
+import { Lang, NamingVariableConventions, VariableType } from './constants.js';
+import StringUtility from './string-utility.js';
+const langToVarNameConvention = {
+    [Lang.NODEJS]: NamingVariableConventions.CAMEL_CASE,
+    [Lang.JAVASCRIPT]: NamingVariableConventions.CAMEL_CASE,
+    [Lang.PYTHON]: NamingVariableConventions.UNDER_SCORES,
+    [Lang.JAVA8]: NamingVariableConventions.CAMEL_CASE,
+    [Lang.JAVA]: NamingVariableConventions.CAMEL_CASE,
+    [Lang.CSHARP]: NamingVariableConventions.PASCAL_CASE,
+    [Lang.CSHARPNEWTONSOFT]: NamingVariableConventions.PASCAL_CASE,
+    [Lang.CURL]: NamingVariableConventions.CAMEL_CASE,
+    [Lang.GO]: NamingVariableConventions.CAMEL_CASE,
+    [Lang.PHP]: NamingVariableConventions.CAMEL_CASE,
+    [Lang.RUBY]: NamingVariableConventions.UNDER_SCORES,
+    [Lang.R]: NamingVariableConventions.UNDER_SCORES,
+};
+const langOptions = {
+    default: {
+        joinSymbol: '',
+        variableWrapperFn: (v) => v,
+        stringLiteral: (t) => t,
+        variableDeclaration: (n) => n,
+        urlFieldName: 'url',
+    },
+    [Lang.CSHARP]: {
+        joinSymbol: ' + ',
+        stringLiteral: (t) => `"${t}"`,
+        variableDeclaration: (n) => `var ${n} = %s;`,
+        urlFieldName: 'fullUrl',
+    },
+    [Lang.CSHARPNEWTONSOFT]: {
+        joinSymbol: ' + ',
+        stringLiteral: (t) => `"${t}"`,
+        variableDeclaration: (n) => `var ${n} = %s;`,
+        urlFieldName: 'fullUrl',
+    },
+    [Lang.GO]: {
+        joinSymbol: ' + ',
+        stringLiteral: (t) => `"${t}"`,
+        variableDeclaration: (n) => `${n} := %s;`,
+    },
+    [Lang.JAVA]: {
+        joinSymbol: ' + ',
+        stringLiteral: (t) => `"${t}"`,
+        variableDeclaration: (n) => `var ${n} = %s;`,
+        urlFieldName: 'pathname',
+    },
+    [Lang.JAVA8]: {
+        joinSymbol: ' + ',
+        stringLiteral: (t) => `"${t}"`,
+        variableDeclaration: (n) => `String ${n} = %s;`,
+        urlFieldName: 'fullUrl',
+    },
+    [Lang.JAVASCRIPT]: {
+        variableWrapperFn: (v) => '${' + v + '}',
+        variableDeclaration: (n, options) => `const ${n} = ${options?.hasVariableInterpolation ? '`%s`' : "'%s'"};`,
+    },
+    [Lang.NODEJS]: {
+        variableWrapperFn: (v) => '${' + v + '}',
+        variableDeclaration: (n, options) => `const ${n} = ${options?.hasVariableInterpolation ? '`%s`' : "'%s'"};`,
+    },
+    [Lang.PHP]: {
+        joinSymbol: ' . ',
+        stringLiteral: (t) => `"${t}"`,
+        variableDeclaration: (n) => `const ${n} = %s;`,
+    },
+    [Lang.PYTHON]: {
+        stringLiteral: (t) => `"${t}"`,
+        joinSymbol: ' + ',
+        variableDeclaration: (n) => `${n} = %s`,
+    },
+    [Lang.RUBY]: {
+        joinSymbol: ' + ',
+        stringLiteral: (t) => `'${t}'`,
+        variableDeclaration: (n) => `${n} = %s`,
+    },
+    [Lang.CURL]: {
+        variableWrapperFn: (name, value) => value || `{${name}}`,
+        urlFieldName: 'fullUrl',
+        rawName: true,
+    },
+    [Lang.R]: {
+        joinSymbol: ' %&% ',
+        variableDeclaration: (n) => `${n} = %s`,
+        urlFieldName: 'fullUrl',
+        stringLiteral: (t) => `"${t}"`,
+        variableWrapperFn: (name) => `${name}`,
+    },
+};
+const reservedVariableNames = [
+    'response',
+    'request',
+    'requests',
+    'data',
+    'url',
+    'payload',
+    'main',
+    'accessToken',
+    'resp',
+    'Program',
+    'client',
+    'postData',
+    'App',
+    'httpClient',
+    'params',
+    'pathname',
+    'host',
+    'body',
+    'fetch',
+    'query',
+];
+/**
+ * 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.
+ *
+ * @param {string} indentation Desired indentation character for aggregated lines of code
+ * @param {string} lineJoin Desired character to join each line of code
+ */
+export class CodeBuilder {
+    code;
+    indentation;
+    variablesPrefix;
+    lineJoin;
+    capitalize;
+    lang;
+    langOptions;
+    constructor({ indentation, lineJoin = '\n', variablesPrefix = '', capitalize = false, lang = Lang.CURL, }) {
+        this.code = [];
+        this.indentation = indentation;
+        this.variablesPrefix = variablesPrefix;
+        this.lineJoin = lineJoin || '\n';
+        this.capitalize = capitalize;
+        this.lang = lang;
+        this.langOptions = {
+            ...langOptions.default,
+            ...langOptions[lang],
+        };
+    }
+    /**
+     * Add given indentation level to given string and format the string (variadic)
+     * @param {number} [indentationLevel=0] - Desired level of indentation for this line
+     * @param {string} line - Line of code. Can contain formatting placeholders
+     * @param rest
+     * @param {...object} - Parameter to bind to `line`'s formatting placeholders
+     * @return {string}
+     *
+     * @example
+     *   const builder = CodeBuilder('\t')
+     *
+     *   builder.buildLine('console.log("hello world")')
+     *   // returns: 'console.log("hello world")'
+     *
+     *   builder.buildLine(2, 'console.log("hello world")')
+     *   // returns: 'console.log("\t\thello world")'
+     *
+     *   builder.buildLine(2, 'console.log("%s %s")', 'hello', 'world')
+     *   // returns: 'console.log("\t\thello world")'
+     */
+    buildLine(indentationLevel, line) {
+        let lineIndentation = '';
+        let slice = 2;
+        if (typeof indentationLevel === 'string') {
+            slice = 1;
+            line = indentationLevel;
+            indentationLevel = 0;
+        }
+        else if (indentationLevel === null) {
+            return null;
+        }
+        while (indentationLevel) {
+            lineIndentation += this.indentation;
+            indentationLevel--;
+        }
+        // eslint-disable-next-line prefer-rest-params
+        const format = Array.prototype.slice.call(arguments, slice, arguments.length);
+        format.unshift(lineIndentation + line);
+        return util.format.apply(this, format);
+    }
+    /**
+     * Invoke buildLine() and add the line at the top of current lines
+     * @return {this}
+     * @param args
+     */
+    unshift(...args) {
+        // @ts-ignore
+        // eslint-disable-next-line prefer-spread
+        this.code.unshift(this.buildLine.apply(this, args));
+        return this;
+    }
+    /**
+     * Invoke buildLine() and add the line at the bottom of current lines
+     * @return {this}
+     * @param args
+     */
+    push(...args) {
+        // @ts-ignore
+        // eslint-disable-next-line prefer-spread
+        this.code.push(this.buildLine.apply(this, args));
+        return this;
+    }
+    /**
+     * Add an empty line at the end of current lines
+     * @return {this}
+     */
+    blank() {
+        this.code.push(null);
+        return this;
+    }
+    /**
+     * Concatenate all current lines using the given lineJoin
+     * @return {string}
+     */
+    join() {
+        return this.code.join(this.lineJoin);
+    }
+    clean() {
+        this.code.splice(1);
+    }
+    /**
+     * Get variable name, use variablesPrefix if specified
+     * @param {string} name
+     * @param {VariableType} type
+     * @return {string}
+     */
+    var(name, type = VariableType.CUSTOM) {
+        if (type === VariableType.PATH) {
+            let value = this.variablesPrefix + name;
+            if (reservedVariableNames.includes(value)) {
+                value = `${value}_path`;
+            }
+            switch (langToVarNameConvention[this.lang]) {
+                case NamingVariableConventions.UNDER_SCORES:
+                    value = StringUtility.toSnakeCase(value);
+                    break;
+                case NamingVariableConventions.PASCAL_CASE:
+                    value = StringUtility.toPascalCase(value);
+                    break;
+                case NamingVariableConventions.CAMEL_CASE:
+                default:
+                    value = StringUtility.toCamelCase(value);
+                    break;
+            }
+            return value;
+        }
+        // TODO remove, once we refactor all variables in code-samples
+        return this.variablesPrefix
+            ? this.variablesPrefix + (this.capitalize ? StringUtility.toPascalCase(name) : name)
+            : name;
+    }
+}
+//# sourceMappingURL=code-builder.js.map

package/lib/services/code-samples/httpsnippet/helpers/code-helpers.d.ts

@@ -24,5 +24,5 @@ export type CodeOperand = {
  * parseUrlIntoOperands("/url/:test/", {test: 1})
  **/
 export declare function parseUrlIntoOperands(url: string, params: Record<string, unknown>): CodeOperand[];
-export declare function buildUrlExpression(source: SnippetRequest, code: CodeBuilder): string;
-export declare function printUrlVariablesDeclarations({ pathParameters, serverVariables }: SnippetRequest, code: CodeBuilder, indentationLevel?: number): void;
+export declare function buildUrlExpression(source: SnippetRequest, code: CodeBuilder, url?: string): string;
+export declare function printUrlVariablesDeclarations(source: SnippetRequest, code: CodeBuilder, indentationLevel?: number): void;

package/lib/services/code-samples/httpsnippet/helpers/code-helpers.js

@@ -1,2 +1,90 @@
-import{VariableType as p}from"./constants.js";function g({body:a,authorizationHeader:s}){return function(r,i,e){return a&&i==="body"&&typeof r.body=="string"?r.body:s&&i==="Authorization"&&typeof r.Authorization=="string"?r.Authorization:e}}function h(a,{level:s=0,indent:r="  ",firstLine:i=!0}={}){const e=r.repeat(s),n=a.replace(/(\r\n|\n|\r)/gm,`
-${e}`);return i?e.concat(n):n}function m(a,s){const i=Object.keys(s).map(t=>({name:t,idx:a.indexOf(`{${t}}`)})).filter(({idx:t})=>t>-1).sort((t,o)=>t.idx-o.idx),e=[];let n=0;for(const{name:t,idx:o}of i)o>n&&e.push({type:"string",value:a.substring(n,o)}),e.push({type:"variable",name:t}),n=o+t.length+2;return n<a.length&&e.push({type:"string",value:a.substring(n)}),e}function x(a,s){const{joinSymbol:r,variableWrapperFn:i,stringLiteral:e,urlFieldName:n,rawName:t}=s.langOptions,{pathParameters:o={},serverVariables:f={}}=a,u={...o,...f};return m(a[n]||"",u).map(l=>{if(l.type==="variable"){const b=u[l.name],c=t?l.name:s.var(l.name,p.PATH);return i(c,b)}else return e(l.value)}).join(r)}function d({pathParameters:a={},serverVariables:s={}},r,i){Object.entries({...a,...s}).forEach(([e,n])=>{if(e==="server")return;const t=n||`YOUR_${e}_PARAMETER`,o=r.var(e,p.PATH);i!==void 0?r.push(i,r.langOptions.variableDeclaration(o),t):r.push(r.langOptions.variableDeclaration(o),t)})}export{h as addIndentation,x as buildUrlExpression,g as getPreserveTransformer,m as parseUrlIntoOperands,d as printUrlVariablesDeclarations};
+import { VariableType } from './constants.js';
+export function getPreserveTransformer({ body, authorizationHeader, }) {
+    return function (input, prop, originalResult) {
+        if (body) {
+            // Keep original body without extra stringifying (assume that body already stringified)
+            if (prop === 'body' && typeof input.body === 'string') {
+                return input.body;
+            }
+        }
+        if (authorizationHeader) {
+            // Keep original Authorization header without stringifying (for basic auth code)
+            if (prop === 'Authorization' && typeof input.Authorization === 'string') {
+                return input.Authorization;
+            }
+        }
+        return originalResult;
+    };
+}
+export function addIndentation(str, { level = 0, indent = '  ', firstLine = true } = {}) {
+    const indentation = indent.repeat(level);
+    // TODO: keep original indentaion type
+    const strWithExtraIndentation = str.replace(/(\r\n|\n|\r)/gm, `\n${indentation}`);
+    if (firstLine) {
+        return indentation.concat(strWithExtraIndentation);
+    }
+    return strWithExtraIndentation;
+}
+/**
+ * Parse url with arguments into concatenation operands array so it can be manipulated easily language-independently
+ *
+ * @example
+ * // returns [{type: 'string', value: '/var/'}, {type: 'variable', name: 'test'}, {type: "string", value: "/"}]
+ * parseUrlIntoOperands("/url/:test/", {test: 1})
+ **/
+export function parseUrlIntoOperands(url, params) {
+    const paramNames = Object.keys(params);
+    const paramNamesInOrder = paramNames
+        .map((name) => ({ name, idx: url.indexOf(`{${name}}`) }))
+        .filter(({ idx }) => idx > -1) // filter out unused
+        .sort((a, b) => a.idx - b.idx);
+    const operands = [];
+    let prevIdx = 0;
+    for (const { name, idx } of paramNamesInOrder) {
+        if (idx > prevIdx) {
+            operands.push({ type: 'string', value: url.substring(prevIdx, idx) });
+        }
+        operands.push({ type: 'variable', name });
+        prevIdx = idx + name.length + 2; // 2 for curly braces
+    }
+    if (prevIdx < url.length)
+        operands.push({ type: 'string', value: url.substring(prevIdx) });
+    return operands;
+}
+export function buildUrlExpression(source, code, url) {
+    const { joinSymbol, variableWrapperFn, stringLiteral, urlFieldName, rawName } = code.langOptions;
+    const { pathParameters = {}, serverVariables = {} } = source;
+    const variablesData = { ...pathParameters, ...serverVariables };
+    return parseUrlIntoOperands(url ?? source[urlFieldName] ?? '', variablesData)
+        .map((operand) => {
+        if (operand.type === 'variable') {
+            const variableValue = variablesData[operand.name];
+            const variableName = rawName ? operand.name : code.var(operand.name, VariableType.PATH);
+            return variableWrapperFn(variableName, variableValue);
+        }
+        else {
+            // string
+            return stringLiteral(operand.value);
+        }
+    })
+        .join(joinSymbol);
+}
+export function printUrlVariablesDeclarations(source, code, indentationLevel) {
+    const variablesData = { ...source.pathParameters, ...source.serverVariables };
+    Object.entries(variablesData).forEach(([key, value]) => {
+        if (key === 'server')
+            return; // special case for environment variable called server
+        const variableValue = value || `YOUR_${key}_PARAMETER`;
+        const variableName = code.var(key, VariableType.PATH);
+        const operands = parseUrlIntoOperands(variableValue, variablesData);
+        const hasVariableInterpolation = operands.some((operand) => operand.type === 'variable');
+        const expression = buildUrlExpression(source, code, variableValue);
+        if (indentationLevel !== undefined) {
+            code.push(indentationLevel, code.langOptions.variableDeclaration(variableName, { hasVariableInterpolation }), expression);
+        }
+        else {
+            code.push(code.langOptions.variableDeclaration(variableName, { hasVariableInterpolation }), expression);
+        }
+    });
+}
+//# sourceMappingURL=code-helpers.js.map

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

@@ -1 +1,28 @@
-var C;(function(A){A.NODEJS="Node.js",A.JAVASCRIPT="javascript",A.PYTHON="Python",A.JAVA8="Java8+Apache",A.JAVA="Java",A.CSHARP="C#",A.CSHARPNEWTONSOFT="C#+Newtonsoft",A.CURL="curl",A.GO="Go",A.PHP="PHP",A.RUBY="Ruby",A.R="R"})(C||(C={}));var P;(function(A){A.UNDER_SCORES="under_scores",A.CAMEL_CASE="camelCase",A.PASCAL_CASE="PascalCase"})(P||(P={}));var o;(function(A){A.IMPORT="import",A.CUSTOM="custom",A.PATH="path"})(o||(o={}));export{C as Lang,P as NamingVariableConventions,o as VariableType};
+export var Lang;
+(function (Lang) {
+    Lang["NODEJS"] = "Node.js";
+    Lang["JAVASCRIPT"] = "javascript";
+    Lang["PYTHON"] = "Python";
+    Lang["JAVA8"] = "Java8+Apache";
+    Lang["JAVA"] = "Java";
+    Lang["CSHARP"] = "C#";
+    Lang["CSHARPNEWTONSOFT"] = "C#+Newtonsoft";
+    Lang["CURL"] = "curl";
+    Lang["GO"] = "Go";
+    Lang["PHP"] = "PHP";
+    Lang["RUBY"] = "Ruby";
+    Lang["R"] = "R";
+})(Lang || (Lang = {}));
+export var NamingVariableConventions;
+(function (NamingVariableConventions) {
+    NamingVariableConventions["UNDER_SCORES"] = "under_scores";
+    NamingVariableConventions["CAMEL_CASE"] = "camelCase";
+    NamingVariableConventions["PASCAL_CASE"] = "PascalCase";
+})(NamingVariableConventions || (NamingVariableConventions = {}));
+export var VariableType;
+(function (VariableType) {
+    VariableType["IMPORT"] = "import";
+    VariableType["CUSTOM"] = "custom";
+    VariableType["PATH"] = "path";
+})(VariableType || (VariableType = {}));
+//# sourceMappingURL=constants.js.map

package/lib/services/code-samples/httpsnippet/helpers/lodash-int.js

@@ -1 +1,173 @@
-const c="\\ud800-\\udfff",k="\\u0300-\\u036f",N="\\ufe20-\\ufe2f",D="\\u20d0-\\u20ff",W="\\u1ab0-\\u1aff",F="\\u1dc0-\\u1dff",l=k+N+D+W+F,x="\\u2700-\\u27bf",b="a-z\\xdf-\\xf6\\xf8-\\xff",H="\\xac\\xb1\\xd7\\xf7",I="\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf",V="\\u2000-\\u206f",_=" \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000",g="A-Z\\xc0-\\xd6\\xd8-\\xde",R="\\ufe0e\\ufe0f",m=H+I+V+_,B=/['\u2019]/g,C="['\u2019]",A=`[${m}]`,i=`[${l}]`,S="\\d",J=`[${x}]`,j=`[${b}]`,y=`[^${c}${m+S+x+b+g}]`,a="\\ud83c[\\udffb-\\udfff]",P=`(?:${i}|${a})`,U=`[^${c}]`,d="(?:\\ud83c[\\udde6-\\uddff]){2}",$="[\\ud800-\\udbff][\\udc00-\\udfff]",r=`[${g}]`,h="\\u200d",M=`(?:${j}|${y})`,q=`(?:${r}|${y})`,L=`(?:${C}(?:d|ll|m|re|s|t|ve))?`,w=`(?:${C}(?:D|LL|M|RE|S|T|VE))?`,O=`${P}?`,z=`[${R}]?`,Q=`(?:${h}(?:${[U,d,$].join("|")})${z+O})*`,Y="\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])",G="\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])",E=z+O+Q,K=`(?:${[J,d,$].join("|")})${E}`,X=RegExp([`${r}?${j}+${L}(?=${[A,r,"$"].join("|")})`,`${q}+${w}(?=${[A,r+M,"$"].join("|")})`,`${r}?${M}+${L}`,`${r}+${w}`,G,Y,`${S}+`,K].join("|"),"g"),v=o=>o.match(X),oo=RegExp(`[${h+c+l+R}]`),T=o=>oo.test(o),so=`[${c}]`,no=`${U}${i}?`,to=`(?:${[no,i,d,$,so].join("|")})`,ro=RegExp(`${a}(?=${a})|${to+E}`,"g"),eo=o=>o.match(ro)||[],co=o=>o.split(""),uo=o=>{const s=Object.prototype.toString;return o==null?o===void 0?"[object Undefined]":"[object Null]":s.call(o)},fo=o=>{const s=typeof o;return s=="symbol"||s==="object"&&o!=null&&uo(o)=="[object Symbol]"},io=1/0,u=o=>{if(o==null)return"";if(typeof o=="string")return o;if(Array.isArray(o))return`${o.map(n=>n==null?n:u(n))}`;if(fo(o))return o.toString();const s=`${o}`;return s=="0"&&1/o==-io?"-0":s},ao=RegExp.prototype.test.bind(/[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/),$o=/[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g,po=o=>o.match($o),lo=(o,s,n)=>{let t=o==null?0:o.length;if(!t)return[];s=s??0,n=n===void 0?t:n,s<0&&(s=-s>t?0:t+s),n=n>t?t:n,n<0&&(n+=t),t=s>n?0:n-s>>>0,s>>>=0;let e=-1;const p=new Array(t);for(;++e<t;)p[e]=o[e+s];return p},f=o=>(ao(o)?v(o):po(o))||[],xo=(o,s)=>{const{length:n}=o,t=n;return!s&&t>=n?o:lo(o,s,t)},bo=o=>T(o)?eo(o):co(o),go=o=>s=>{if(!s)return"";const n=T(s)?bo(s):void 0,t=n?n[0]:s[0],e=n?xo(n,1).join(""):s.slice(1);return t[o]()+e},Z=go("toUpperCase"),Ro=o=>f(u(o).replace(/['\u2019]/g,"")).reduce((s,n,t)=>(n=n.toLowerCase(),s+(t?Z(n):n)),""),mo=o=>f(u(o).replace(B,"")).reduce((s,n,t)=>s+(t?" ":"")+n.toLowerCase(),""),Co=o=>f(u(o).replace(/['\u2019]/g,"")).reduce((s,n,t)=>s+(t?"_":"")+n.toLowerCase(),""),Ao=o=>f(`${o}`.replace(/['\u2019]/g,"")).reduce((s,n,t)=>s+(t?" ":"")+Z(n),"");export{Ro as camelCase,mo as lowerCase,Co as snakeCase,Ao as startCase};
+/* Functions in this file are copied from lodash */
+/** Used to compose unicode character classes. */
+const rsAstralRange = '\\ud800-\\udfff';
+const rsComboMarksRange = '\\u0300-\\u036f';
+const reComboHalfMarksRange = '\\ufe20-\\ufe2f';
+const rsComboSymbolsRange = '\\u20d0-\\u20ff';
+const rsComboMarksExtendedRange = '\\u1ab0-\\u1aff';
+const rsComboMarksSupplementRange = '\\u1dc0-\\u1dff';
+const rsComboRange = rsComboMarksRange +
+    reComboHalfMarksRange +
+    rsComboSymbolsRange +
+    rsComboMarksExtendedRange +
+    rsComboMarksSupplementRange;
+const rsDingbatRange = '\\u2700-\\u27bf';
+const rsLowerRange = 'a-z\\xdf-\\xf6\\xf8-\\xff';
+const rsMathOpRange = '\\xac\\xb1\\xd7\\xf7';
+const rsNonCharRange = '\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf';
+const rsPunctuationRange = '\\u2000-\\u206f';
+const rsSpaceRange = ' \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000';
+const rsUpperRange = 'A-Z\\xc0-\\xd6\\xd8-\\xde';
+const rsVarRange = '\\ufe0e\\ufe0f';
+const rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;
+const reQuotes = /['\u2019]/g;
+/** Used to compose unicode capture groups. */
+const rsApos = "['\u2019]";
+const rsBreak = `[${rsBreakRange}]`;
+const rsCombo = `[${rsComboRange}]`;
+const rsDigit = '\\d';
+const rsDingbat = `[${rsDingbatRange}]`;
+const rsLower = `[${rsLowerRange}]`;
+const rsMisc = `[^${rsAstralRange}${rsBreakRange + rsDigit + rsDingbatRange + rsLowerRange + rsUpperRange}]`;
+const rsFitz = '\\ud83c[\\udffb-\\udfff]';
+const rsModifier = `(?:${rsCombo}|${rsFitz})`;
+const rsNonAstral = `[^${rsAstralRange}]`;
+const rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}';
+const rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]';
+const rsUpper = `[${rsUpperRange}]`;
+const rsZWJ = '\\u200d';
+/** Used to compose unicode regexes. */
+const rsMiscLower = `(?:${rsLower}|${rsMisc})`;
+const rsMiscUpper = `(?:${rsUpper}|${rsMisc})`;
+const rsOptContrLower = `(?:${rsApos}(?:d|ll|m|re|s|t|ve))?`;
+const rsOptContrUpper = `(?:${rsApos}(?:D|LL|M|RE|S|T|VE))?`;
+const reOptMod = `${rsModifier}?`;
+const rsOptVar = `[${rsVarRange}]?`;
+const rsOptJoin = `(?:${rsZWJ}(?:${[rsNonAstral, rsRegional, rsSurrPair].join('|')})${rsOptVar + reOptMod})*`;
+const rsOrdLower = '\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])';
+const rsOrdUpper = '\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])';
+const rsSeq = rsOptVar + reOptMod + rsOptJoin;
+const rsEmoji = `(?:${[rsDingbat, rsRegional, rsSurrPair].join('|')})${rsSeq}`;
+const reUnicodeWords = RegExp(
+// eslint-disable-next-line no-misleading-character-class
+[
+    `${rsUpper}?${rsLower}+${rsOptContrLower}(?=${[rsBreak, rsUpper, '$'].join('|')})`,
+    `${rsMiscUpper}+${rsOptContrUpper}(?=${[rsBreak, rsUpper + rsMiscLower, '$'].join('|')})`,
+    `${rsUpper}?${rsMiscLower}+${rsOptContrLower}`,
+    `${rsUpper}+${rsOptContrUpper}`,
+    rsOrdUpper,
+    rsOrdLower,
+    `${rsDigit}+`,
+    rsEmoji,
+].join('|'), 'g');
+const unicodeWords = (string) => string.match(reUnicodeWords);
+/** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */
+// eslint-disable-next-line no-misleading-character-class
+const reHasUnicode = RegExp(`[${rsZWJ + rsAstralRange + rsComboRange + rsVarRange}]`);
+/**
+ * Checks if `string` contains Unicode symbols.
+ *
+ * @private
+ * @param {string} string The string to inspect.
+ * @returns {boolean} Returns `true` if a symbol is found, else `false`.
+ */
+const hasUnicode = (string) => reHasUnicode.test(string);
+/** Used to compose unicode capture groups. */
+const rsAstral = `[${rsAstralRange}]`;
+const rsNonAstralCombo = `${rsNonAstral}${rsCombo}?`;
+const rsSymbol = `(?:${[rsNonAstralCombo, rsCombo, rsRegional, rsSurrPair, rsAstral].join('|')})`;
+/** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */
+// eslint-disable-next-line no-misleading-character-class
+const reUnicode = RegExp(`${rsFitz}(?=${rsFitz})|${rsSymbol + rsSeq}`, 'g');
+const unicodeToArray = (string) => string.match(reUnicode) || [];
+const asciiToArray = (string) => string.split('');
+const getTag = (value) => {
+    const toString = Object.prototype.toString;
+    if (value == null) {
+        return value === undefined ? '[object Undefined]' : '[object Null]';
+    }
+    return toString.call(value);
+};
+const isSymbol = (value) => {
+    const type = typeof value;
+    return (type == 'symbol' || (type === 'object' && value != null && getTag(value) == '[object Symbol]'));
+};
+/** Used as references for various `Number` constants. */
+const INFINITY = 1 / 0;
+const toString = (value) => {
+    if (value == null) {
+        return '';
+    }
+    // Exit early for strings to avoid a performance hit in some environments.
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        // Recursively convert values (susceptible to call stack limits).
+        return `${value.map((other) => (other == null ? other : toString(other)))}`;
+    }
+    if (isSymbol(value)) {
+        return value.toString();
+    }
+    const result = `${value}`;
+    return result == '0' && 1 / value == -INFINITY ? '-0' : result;
+};
+const hasUnicodeWord = RegExp.prototype.test.bind(/[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/);
+/** Used to match words composed of alphanumeric characters. */
+// eslint-disable-next-line no-control-regex
+const reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
+const asciiWords = (string) => string.match(reAsciiWord);
+const slice = (array, start, end) => {
+    let length = array == null ? 0 : array.length;
+    if (!length) {
+        return [];
+    }
+    start = start == null ? 0 : start;
+    end = end === undefined ? length : end;
+    if (start < 0) {
+        start = -start > length ? 0 : length + start;
+    }
+    end = end > length ? length : end;
+    if (end < 0) {
+        end += length;
+    }
+    length = start > end ? 0 : (end - start) >>> 0;
+    start >>>= 0;
+    let index = -1;
+    const result = new Array(length);
+    while (++index < length) {
+        result[index] = array[index + start];
+    }
+    return result;
+};
+const words = (string) => {
+    const result = hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);
+    return result || [];
+};
+const castSlice = (array, start) => {
+    const { length } = array;
+    const end = length;
+    return !start && end >= length ? array : slice(array, start, end);
+};
+const stringToArray = (string) => hasUnicode(string) ? unicodeToArray(string) : asciiToArray(string);
+const createCaseFirst = (methodName) => {
+    return (string) => {
+        if (!string) {
+            return '';
+        }
+        const strSymbols = hasUnicode(string) ? stringToArray(string) : undefined;
+        const chr = strSymbols ? strSymbols[0] : string[0];
+        const trailing = strSymbols ? castSlice(strSymbols, 1).join('') : string.slice(1);
+        return chr[methodName]() + trailing;
+    };
+};
+const upperFirst = createCaseFirst('toUpperCase');
+const camelCase = (string) => words(toString(string).replace(/['\u2019]/g, '')).reduce((result, word, index) => {
+    word = word.toLowerCase();
+    return result + (index ? upperFirst(word) : word);
+}, '');
+const lowerCase = (string) => words(toString(string).replace(reQuotes, '')).reduce((result, word, index) => result + (index ? ' ' : '') + word.toLowerCase(), '');
+const snakeCase = (string) => words(toString(string).replace(/['\u2019]/g, '')).reduce((result, word, index) => result + (index ? '_' : '') + word.toLowerCase(), '');
+const startCase = (string) => words(`${string}`.replace(/['\u2019]/g, '')).reduce((result, word, index) => result + (index ? ' ' : '') + upperFirst(word), '');
+export { camelCase, lowerCase, snakeCase, startCase };
+//# sourceMappingURL=lodash-int.js.map