wormajs 0.0.1

package/dist/core/loader/astLoader/parsers/forward/array.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../../../../utils");
+exports.default = {
+    is(schema) {
+        // 判断是否为数组类型
+        // 1. type 为 'array'
+        // 2. 或者有 items 字段
+        return schema && (schema.type === 'array' || (0, utils_1.isMaybeArraySchemaObject)(schema));
+    },
+    to: 'array',
+};

package/dist/core/loader/astLoader/parsers/forward/enum.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    is(schema) {
+        // 判断是否为枚举类型
+        // 有 enum 字段且不为空数组
+        return schema && !!schema.enum && Array.isArray(schema.enum) && schema.enum.length > 0;
+    },
+    to: 'enum',
+};

package/dist/core/loader/astLoader/parsers/forward/group.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    is(schema) {
+        // 判断是否为组合类型
+        // 1. 有 oneOf 字段（联合类型）
+        // 2. 或者有 anyOf 字段（联合类型）
+        // 3. 或者有 allOf 字段（交叉类型）
+        return schema && (!!schema.oneOf || !!schema.anyOf || !!schema.allOf);
+    },
+    to: 'group',
+};

package/dist/core/loader/astLoader/parsers/forward/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forwarders = void 0;
+exports.forward = forward;
+const array_1 = __importDefault(require("./array"));
+const enum_1 = __importDefault(require("./enum"));
+const group_1 = __importDefault(require("./group"));
+const object_1 = __importDefault(require("./object"));
+const tuple_1 = __importDefault(require("./tuple"));
+exports.forwarders = [object_1.default, enum_1.default, tuple_1.default, array_1.default, group_1.default];
+function forward(schema) {
+    for (const forwarder of exports.forwarders) {
+        if (forwarder.is(schema)) {
+            return forwarder.to;
+        }
+    }
+}

package/dist/core/loader/astLoader/parsers/forward/object.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    is(schema) {
+        // 判断是否为对象类型
+        // 1. type 为 'object'
+        // 2. 或者有 properties 字段
+        // 3. 或者有 additionalProperties 字段
+        return schema && (schema.type === 'object' || !!schema.properties || !!schema.additionalProperties);
+    },
+    to: 'object',
+};

package/dist/core/loader/astLoader/parsers/forward/tuple.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    is(schema) {
+        // 判断是否为元组类型
+        // 1. type 为 'array'
+        // 2. 且 items 是数组（表示固定位置的元素类型）
+        return schema && schema.type === 'array' && Array.isArray(schema.items) && schema.items.length > 0;
+    },
+    to: 'tuple',
+};

package/dist/core/loader/astLoader/parsers/forward/type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/loader/astLoader/parsers/group.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupTypeParser = groupTypeParser;
+const helper_1 = require("../../../../helper");
+const type_1 = require("../../../../type");
+const utils_1 = require("./utils");
+function groupTypeParser(schema, ctx) {
+    const result = {
+        ...(0, utils_1.initAST)(schema, ctx),
+    };
+    const items = schema.anyOf || schema.oneOf || schema.allOf || [];
+    const params = items.map(value => ctx.next(value, ctx.options));
+    const deepCommenter = helper_1.CommentHelper.load({
+        type: ctx.options.commentType,
+    });
+    params.forEach((itemsAst, idx) => {
+        const comment = helper_1.CommentHelper.parseStr(itemsAst.comment ?? '');
+        const deepComment = helper_1.CommentHelper.parseStr(itemsAst.deepComment ?? '');
+        if (comment || deepComment) {
+            deepCommenter
+                .add(`[params${idx + 1}] start`)
+                .add(comment)
+                .add(deepComment)
+                .add(`[params${idx + 1}] end`);
+        }
+    });
+    result.deepComment = deepCommenter.end();
+    if (schema.anyOf || schema.oneOf) {
+        return {
+            ...result,
+            type: type_1.ASTType.UNION,
+            params,
+        };
+    }
+    if (schema.allOf) {
+        // 显式检查 allOf
+        return {
+            ...result,
+            type: type_1.ASTType.INTERSECTION,
+            params,
+        };
+    }
+    throw helper_1.logger.throwError('schema must contain anyOf, oneOf or allOf', {
+        schema,
+    });
+}
+exports.default = {
+    type: 'group',
+    parse: groupTypeParser,
+};

package/dist/core/loader/astLoader/parsers/index.js

@@ -0,0 +1,66 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.astParse = astParse;
+const type_1 = require("../../../../type");
+const array_1 = __importDefault(require("./array"));
+const enum_1 = __importDefault(require("./enum"));
+const group_1 = __importDefault(require("./group"));
+const object_1 = __importDefault(require("./object"));
+const reference_1 = __importDefault(require("./reference"));
+const simple_1 = __importDefault(require("./simple"));
+const tuple_1 = __importDefault(require("./tuple"));
+const utils_1 = require("./utils");
+__exportStar(require("./type"), exports);
+function astParse(schema, options) {
+    const doParse = (schema, ctx) => {
+        const value = (0, utils_1.parse)(schema, {
+            type: (0, utils_1.getParserSchemaType)(schema),
+            ctx,
+            parsers: [array_1.default, object_1.default, enum_1.default, simple_1.default, reference_1.default, tuple_1.default, group_1.default],
+        });
+        if (!value) {
+            return {
+                type: type_1.ASTType.UNKNOWN,
+            };
+        }
+        return value;
+    };
+    const ctx = {
+        options,
+        next(schema, options) {
+            const hasPathKey = !!ctx.pathKey;
+            if (hasPathKey) {
+                ctx.path.push(ctx.pathKey);
+                ctx.pathKey = '';
+            }
+            ctx.options = options;
+            const nextAST = doParse(schema, ctx);
+            if (hasPathKey) {
+                ctx.path.pop();
+            }
+            return nextAST;
+        },
+        keyName: '',
+        visited: new Set(),
+        pathMap: new Map(),
+        path: ['$'],
+    };
+    return doParse(schema, ctx);
+}

package/dist/core/loader/astLoader/parsers/object.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectTypeParser = objectTypeParser;
+const type_1 = require("../../../../type");
+const utils_1 = require("./utils");
+function objectTypeParser(schema, ctx) {
+    const result = {
+        ...(0, utils_1.initAST)(schema, ctx),
+        type: type_1.ASTType.INTERFACE,
+        params: [],
+    };
+    const properties = schema.properties || {};
+    const required = new Set(schema.required ?? []);
+    for (const [key, value] of Object.entries(properties)) {
+        ctx.pathKey = key;
+        result.params.push({
+            ast: ctx.next(value, ctx.options),
+            keyName: key,
+            isRequired: required.has(key) || !!ctx.options.defaultRequire,
+        });
+    }
+    if (!result.params.length && !schema.additionalProperties) {
+        return {
+            ...result,
+            type: type_1.ASTType.OBJECT,
+        };
+    }
+    if (schema.additionalProperties) {
+        if (typeof schema.additionalProperties === 'boolean') {
+            result.addParams = {
+                type: type_1.ASTType.ANY,
+            };
+        }
+        else {
+            ctx.pathKey = '[key: string]';
+            result.addParams = ctx.next(schema.additionalProperties, ctx.options);
+        }
+    }
+    return result;
+}
+exports.default = {
+    type: 'object',
+    parse: objectTypeParser,
+};

package/dist/core/loader/astLoader/parsers/reference.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.referenceTypeParser = referenceTypeParser;
+const standardLoader_1 = require("../../../../core/loader/standardLoader");
+const helper_1 = require("../../../../helper");
+const type_1 = require("../../../../type");
+const utils_1 = require("../../../../utils");
+const normalize_1 = __importDefault(require("../normalize"));
+const utils_2 = require("./utils");
+function referenceTypeParser(schema, ctx) {
+    const refName = ctx.options.refNameMap?.get(schema.$ref)
+        || standardLoader_1.standardLoader.transformRefName(schema.$ref);
+    const refernceAST = {
+        ...(0, utils_2.initAST)(schema, ctx),
+        type: type_1.ASTType.REFERENCE,
+        params: refName,
+    };
+    if (ctx.visited.has(schema.$ref)) {
+        refernceAST.deepComment = helper_1.CommentHelper.load({
+            type: ctx.options.commentType,
+        })
+            .add('[cycle]', ctx.pathMap.get(schema.$ref))
+            .end();
+        return refernceAST;
+    }
+    const nextSchema = normalize_1.default.normalize((0, utils_1.dereference)(schema, ctx.options.document));
+    ctx.visited.add(schema.$ref);
+    ctx.pathMap.set(schema.$ref, ctx.path.join('.'));
+    ctx.keyName = refName;
+    const result = ctx.next(nextSchema, ctx.options);
+    ctx.options.onReference?.(result);
+    ctx.visited.delete(schema.$ref);
+    return result;
+}
+exports.default = {
+    type: 'reference',
+    parse: referenceTypeParser,
+};

package/dist/core/loader/astLoader/parsers/simple.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringTypeParser = stringTypeParser;
+exports.simpleTypeParser = simpleTypeParser;
+const type_1 = require("../../../../type");
+const utils_1 = require("./utils");
+function stringTypeParser(schema, init) {
+    if (schema.format === 'binary') {
+        return {
+            ...init,
+            type: type_1.ASTType.CUSTOM,
+            params: 'Blob',
+        };
+    }
+    return {
+        ...init,
+        type: type_1.ASTType.STRING,
+    };
+}
+function simpleTypeParser(schema, ctx) {
+    const result = (0, utils_1.initAST)(schema, ctx);
+    switch (schema.type) {
+        case 'boolean':
+            result.type = type_1.ASTType.BOOLEAN;
+            break;
+        case 'integer':
+        case 'number':
+            result.type = type_1.ASTType.NUMBER;
+            break;
+        case 'string': {
+            return stringTypeParser(schema, result);
+        }
+        case 'null':
+        case null:
+            result.type = type_1.ASTType.NULL;
+            break;
+        default:
+            // custom
+            result.type = type_1.ASTType.CUSTOM;
+            result.params = `${schema.type}`;
+            break;
+    }
+    return result;
+}
+exports.default = {
+    type: ['boolean', 'integer', 'number', 'string', 'null', 'custom'],
+    parse: simpleTypeParser,
+};

package/dist/core/loader/astLoader/parsers/tuple.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tupleTypeParser = tupleTypeParser;
+const helper_1 = require("../../../../helper");
+const type_1 = require("../../../../type");
+const utils_1 = require("./utils");
+function tupleTypeParser(schema, ctx) {
+    const params = schema.items.map(item => ctx.next(item, ctx.options));
+    const result = {
+        ...(0, utils_1.initAST)(schema, ctx),
+        type: type_1.ASTType.TUPLE,
+        minItems: schema.minItems,
+        maxItems: schema.maxItems,
+        params,
+    };
+    const deepCommenter = helper_1.CommentHelper.load({
+        type: ctx.options.commentType,
+    });
+    params.forEach((itemsAst, idx) => {
+        const comment = helper_1.CommentHelper.parseStr(itemsAst.comment ?? '');
+        const deepComment = helper_1.CommentHelper.parseStr(itemsAst.deepComment ?? '');
+        if (comment || deepComment) {
+            deepCommenter
+                .add(`[params${idx + 1}] start`)
+                .add(comment)
+                .add(deepComment)
+                .add(`[params${idx + 1}] end`);
+        }
+    });
+    result.deepComment = deepCommenter.end();
+    return result;
+}
+exports.default = {
+    type: 'tuple',
+    parse: tupleTypeParser,
+};

package/dist/core/loader/astLoader/parsers/type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/loader/astLoader/parsers/utils.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaPrimitive = void 0;
+exports.getCommentBySchema = getCommentBySchema;
+exports.initAST = initAST;
+exports.parse = parse;
+exports.getParserSchemaType = getParserSchemaType;
+const helper_1 = require("../../../../helper");
+const type_1 = require("../../../../type");
+const utils_1 = require("../../../../utils");
+const forward_1 = require("./forward");
+exports.SchemaPrimitive = ['boolean', 'object', 'number', 'string', 'integer', 'array', 'null'];
+function getCommentBySchema(schema, options) {
+    const commenter = helper_1.CommentHelper.load(options);
+    if (!(0, utils_1.isReferenceObject)(schema) && schema.title) {
+        commenter.add('[title]', schema.title);
+    }
+    if ((0, utils_1.isReferenceObject)(schema) && schema.summary) {
+        commenter.add('[summary]', schema.summary);
+    }
+    if (schema.description) {
+        commenter.add(schema.description);
+    }
+    return commenter.end();
+}
+function initAST(schema, ctx) {
+    const result = {
+        type: type_1.ASTType.UNKNOWN,
+        comment: getCommentBySchema(schema, {
+            type: ctx.options.commentType,
+        }),
+        keyName: ctx.keyName,
+        deprecated: (0, utils_1.isReferenceObject)(schema) ? false : schema.deprecated,
+    };
+    ctx.keyName = '';
+    return result;
+}
+function parse(schema, options) {
+    const { type, ctx, parsers } = options;
+    const parser = parsers.find(parser => [parser.type].flat().includes(type));
+    if (parser) {
+        return parser.parse(schema, ctx);
+    }
+    return null;
+}
+function getParserSchemaType(schema) {
+    if ((0, utils_1.isReferenceObject)(schema)) {
+        return 'reference';
+    }
+    const forwardType = (0, forward_1.forward)(schema);
+    if (forwardType) {
+        return forwardType;
+    }
+    if (schema.type && typeof schema.type === 'string') {
+        return exports.SchemaPrimitive.includes(schema.type) ? schema.type : 'custom';
+    }
+    return 'null';
+}

package/dist/core/loader/callingCodeLoader/helper.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDefaultValues = void 0;
+exports.removeComments = removeComments;
+exports.generateDefaultValuesFormat = generateDefaultValuesFormat;
+const utils_1 = require("../../../utils");
+// Remove comments
+function removeComments(content) {
+    // Remove single line comments
+    content = content.replace(/\/\/.*$/gm, '');
+    // Remove multi-line comments and documentation comments
+    content = content.replace(/\/\*[\s\S]*?\*\//g, '');
+    return content;
+}
+const LEFT_BRACKET = ['(', '<', '{', '['];
+const RIGHT_BRACKET = [')', '>', '}', ']'];
+const NOT_SUPPORTED = [/^\[key: string\]/];
+function parseTypeBody(typeBody) {
+    const processedTypeBody = typeBody
+        .replace(/:[\t\v\f\r \xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF]*\n\s*\|/g, ':') // Handle union type after colon
+        .replace(/:[\t\v\f\r \xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF]*\n\s*&/g, ':') // Handle intersection type after colon
+        .replace(/\n\s*\|/g, '|') // Handle union type line breaks
+        .replace(/\n\s*&/g, '&'); // Handle intersection type line breaks
+    const properties = [];
+    let bracketCount = 0;
+    let currentProperty = '';
+    for (let i = 0; i < processedTypeBody.length; i += 1) {
+        const char = processedTypeBody[i];
+        if (LEFT_BRACKET.includes(char)) {
+            bracketCount += 1;
+        }
+        else if (RIGHT_BRACKET.includes(char)) {
+            bracketCount -= 1;
+        }
+        currentProperty += char;
+        if (currentProperty.trim() && /\n/.test(char) && bracketCount === 0) {
+            properties.push(currentProperty.trim());
+            currentProperty = '';
+        }
+    }
+    if (currentProperty.trim()) {
+        properties.push(currentProperty.trim());
+    }
+    const parsedProperties = properties.filter(item => !NOT_SUPPORTED.some(regex => regex.test(item)))
+        .map((prop) => {
+        const [keyOrigin, ...valueOrigin] = prop.split(':');
+        const key = keyOrigin.trim();
+        const value = valueOrigin.join(':').trim();
+        const isOptional = key.endsWith('?');
+        const defaultValue = getDefaultValue(value);
+        return { key: key.replace('?', ''), value: defaultValue, isOptional };
+    })
+        .filter(prop => !prop.isOptional)
+        .map(prop => `${prop.key}: ${prop.value}`)
+        .join(',\n');
+    return `{\n${parsedProperties}\n}`;
+}
+function isSplitType(type, c) {
+    if (!type.includes(c)) {
+        return false;
+    }
+    let bracketCount = 0;
+    for (let i = 0; i < type.length; i += 1) {
+        const char = type[i];
+        if (LEFT_BRACKET.includes(char)) {
+            bracketCount += 1;
+        }
+        else if (RIGHT_BRACKET.includes(char)) {
+            bracketCount -= 1;
+        }
+        if (bracketCount === 0 && char === c) {
+            return true;
+        }
+    }
+    return false;
+}
+function splitTypes(typeStr, c) {
+    const result = [];
+    let bracketCount = 0;
+    let currentType = '';
+    for (let i = 0; i < typeStr.length; i += 1) {
+        const char = typeStr[i];
+        if (LEFT_BRACKET.includes(char)) {
+            bracketCount += 1;
+        }
+        else if (RIGHT_BRACKET.includes(char)) {
+            bracketCount -= 1;
+        }
+        if (char === c && bracketCount === 0) {
+            result.push(currentType.trim());
+            currentType = '';
+        }
+        else {
+            currentType += char;
+        }
+    }
+    if (currentType.trim()) {
+        result.push(currentType.trim());
+    }
+    return result;
+}
+function isIntersectionType(type) {
+    return isSplitType(type, '&');
+}
+function isUnionType(type) {
+    return isSplitType(type, '|');
+}
+function getDefaultValue(type) {
+    // Remove trailing semicolon
+    type = type.replace(/;$/, '');
+    if (isUnionType(type)) {
+        const types = splitTypes(type, '|');
+        return getDefaultValue(types[0]);
+    }
+    if (isIntersectionType(type)) {
+        const types = splitTypes(type, '&');
+        const mergedDefaults = types.map(t => getDefaultValue(t));
+        return mergedDefaults.reduce((acc, curr) => {
+            if (curr.startsWith('{') && curr.endsWith('}')) {
+                const currProperties = curr.slice(1, -1).trim();
+                if (acc === '{ }') {
+                    return `{\n ${currProperties} \n}`;
+                }
+                return `${acc.slice(0, -2)},\n ${currProperties} \n}`;
+            }
+            return acc;
+        }, '{ }');
+    }
+    if (type.startsWith('(') && type.endsWith(')')) {
+        return getDefaultValue(type.slice(1, -1).trim());
+    }
+    if (type.startsWith('{') && type.endsWith('}')) {
+        return parseTypeBody(type.slice(1, -1).trim());
+    }
+    if (type.endsWith(')[]') && type.startsWith('(')) {
+        return '[]';
+    }
+    if (type.endsWith('[]') || type.startsWith('Array<')) {
+        return '[]';
+    }
+    if (type.startsWith('[') && type.endsWith(']')) {
+        return parseTuple(type);
+    }
+    if ((type.startsWith('\'') && type.endsWith('\'')) || (type.startsWith('"') && type.endsWith('"'))) {
+        return type;
+    }
+    if (Number.parseInt(type, 10)) {
+        return type;
+    }
+    switch (type) {
+        case 'string':
+            return '""';
+        case 'number':
+            return '0';
+        case 'boolean':
+            return 'false';
+        case 'null':
+        case 'undefined':
+            return type;
+        default:
+            return '{ }';
+    }
+}
+function parseTuple(tupleType) {
+    const elements = tupleType
+        .slice(1, -1)
+        .split(',')
+        .map(el => el.trim());
+    const parsedElements = elements.map(el => getDefaultValue(el));
+    return `[${parsedElements.join(', ')}]`;
+}
+const generateDefaultValues = (sourceCode) => getDefaultValue(removeComments(sourceCode).trim());
+exports.generateDefaultValues = generateDefaultValues;
+/**
+ * Generates default value objects for types and interfaces from the given TypeScript source code.
+ * @param sourceCode -TypeScript source code string
+ * @returns Object containing type and interface default values
+ */
+function generateDefaultValuesFormat(sourceCode) {
+    return (0, utils_1.format)((0, exports.generateDefaultValues)(sourceCode), {
+        parser: 'json',
+    });
+}

package/dist/core/loader/callingCodeLoader/index.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callingCodeLoader = exports.CallingCodeLoader = void 0;
+const utils_1 = require("../../../utils");
+const helper_1 = require("./helper");
+class CallingCodeLoader {
+    constructor() {
+        this.name = 'callingCodeLoader';
+    }
+    transform(input, options) {
+        if (options?.format) {
+            return (0, helper_1.generateDefaultValuesFormat)(input);
+        }
+        return Promise.resolve((0, helper_1.generateDefaultValues)(input));
+    }
+    async transformApi(api) {
+        const configStrArr = [];
+        if (api.pathParametersComment) {
+            configStrArr.push(`pathParams: ${await this.transform(api.pathParametersComment.replace(/\*/g, ''))}`);
+        }
+        if (api.queryParametersComment) {
+            configStrArr.push(`params: ${await this.transform(api.queryParametersComment.replace(/\*/g, ''))}`);
+        }
+        if (api.requestBodyComment) {
+            configStrArr.push(`data: ${await this.transform(api.requestBodyComment.replace(/\*/g, ''))}`);
+        }
+        return (0, utils_1.format)(`${api.name}({${configStrArr.join(',\n')}})`, {
+            printWidth: 40, // Shorten print width to force line breaks
+            tabWidth: 2,
+            semi: false, // Remove the trailing semicolon
+            useTabs: false,
+            trailingComma: 'none',
+            endOfLine: 'lf',
+            bracketSpacing: true,
+            arrowParens: 'always',
+        });
+    }
+}
+exports.CallingCodeLoader = CallingCodeLoader;
+exports.callingCodeLoader = new CallingCodeLoader();