@zimic/http 1.1.2-canary.2 → 1.1.2-canary.4

package/dist/{chunk-NMM3FZVR.mjs → chunk-ZPOGWLJW.mjs}

@@ -3,68 +3,46 @@ import path from 'path';
 import ts3 from 'typescript';
 import color from 'picocolors';
 
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
-// ../zimic-utils/dist/chunk-2D3UJWOA.mjs
-var __defProp2 = Object.defineProperty;
-var __name2 = /* @__PURE__ */ __name((target, value) => __defProp2(target, "name", { value, configurable: true }), "__name");
-
-// ../zimic-utils/dist/chunk-WC2DBWWR.mjs
+// ../zimic-utils/dist/chunk-5UH44FTS.mjs
 function isDefined(value) {
   return value !== void 0 && value !== null;
 }
-__name(isDefined, "isDefined");
-__name2(isDefined, "isDefined");
 var isDefined_default = isDefined;
 function isNeverType(type) {
   return type.kind === ts3.SyntaxKind.NeverKeyword;
 }
-__name(isNeverType, "isNeverType");
 function isUnknownType(type) {
   return type.kind === ts3.SyntaxKind.UnknownKeyword;
 }
-__name(isUnknownType, "isUnknownType");
 function isNullType(type) {
   return type.kind === ts3.SyntaxKind.NullKeyword;
 }
-__name(isNullType, "isNullType");
 function createBlobType() {
   return ts3.factory.createTypeReferenceNode("Blob");
 }
-__name(createBlobType, "createBlobType");
 function createNullType() {
   return ts3.factory.createLiteralTypeNode(ts3.factory.createNull());
 }
-__name(createNullType, "createNullType");
 function createImportSpecifier(importName) {
   return ts3.factory.createImportSpecifier(false, void 0, ts3.factory.createIdentifier(importName));
 }
-__name(createImportSpecifier, "createImportSpecifier");
 function createImportDeclaration(importSpecifiers, moduleName, options) {
   return ts3.factory.createImportDeclaration(
     void 0,
     ts3.factory.createImportClause(
-      options.typeOnly ? ts3.SyntaxKind.TypeKeyword : void 0,
+      ts3.SyntaxKind.TypeKeyword ,
       void 0,
       ts3.factory.createNamedImports(importSpecifiers)
     ),
     ts3.factory.createStringLiteral(moduleName)
   );
 }
-__name(createImportDeclaration, "createImportDeclaration");
 
 // src/types/schema.ts
 var HTTP_METHODS = Object.freeze(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
 
 // ../zimic-utils/dist/logging/Logger.mjs
 var Logger = class _Logger {
-  static {
-    __name(this, "_Logger");
-  }
-  static {
-    __name2(this, "Logger");
-  }
   prefix;
   raw;
   constructor(options = {}) {
@@ -144,19 +122,15 @@ var logger = new Logger_default({
 function createOperationsIdentifierText(serviceName) {
   return `${serviceName}Operations`;
 }
-__name(createOperationsIdentifierText, "createOperationsIdentifierText");
 function createOperationsIdentifier(serviceName) {
   return ts3.factory.createIdentifier(createOperationsIdentifierText(serviceName));
 }
-__name(createOperationsIdentifier, "createOperationsIdentifier");
 function isOperationsDeclaration(node) {
   return node !== void 0 && ts3.isInterfaceDeclaration(node) && node.name.text === "operations";
 }
-__name(isOperationsDeclaration, "isOperationsDeclaration");
 function isOperation(node) {
   return ts3.isPropertySignature(node) && (ts3.isIdentifier(node.name) || ts3.isStringLiteral(node.name)) && node.type !== void 0 && ts3.isTypeLiteralNode(node.type);
 }
-__name(isOperation, "isOperation");
 function normalizeOperation(operation, context) {
   if (!isOperation(operation)) {
     return void 0;
@@ -170,7 +144,6 @@ function normalizeOperation(operation, context) {
     newType
   );
 }
-__name(normalizeOperation, "normalizeOperation");
 function normalizeOperations(operations, context) {
   const newIdentifier = createOperationsIdentifier(context.serviceName);
   const newMembers = operations.members.map((operation) => normalizeOperation(operation, context)).filter(isDefined_default);
@@ -183,7 +156,6 @@ function normalizeOperations(operations, context) {
     newMembers
   );
 }
-__name(normalizeOperations, "normalizeOperations");
 function removeOperationIfUnreferenced(operation, context) {
   if (!isOperation(operation)) {
     return void 0;
@@ -196,7 +168,6 @@ function removeOperationIfUnreferenced(operation, context) {
   }
   return void 0;
 }
-__name(removeOperationIfUnreferenced, "removeOperationIfUnreferenced");
 function removeUnreferencedOperations(operations, context) {
   const newMembers = operations.members.map((operation) => removeOperationIfUnreferenced(operation, context)).filter(isDefined_default);
   context.referencedTypes.operations.clear();
@@ -212,45 +183,35 @@ function removeUnreferencedOperations(operations, context) {
     newMembers
   );
 }
-__name(removeUnreferencedOperations, "removeUnreferencedOperations");
 
 // src/typegen/openapi/transform/methods.ts
 function isMethod(node) {
   return ts3.isPropertySignature(node) && ts3.isIdentifier(node.name) && node.type !== void 0 && (ts3.isTypeLiteralNode(node.type) || ts3.isIndexedAccessTypeNode(node.type));
 }
-__name(isMethod, "isMethod");
 function isMethodMember(node) {
   return ts3.isPropertySignature(node) && ts3.isIdentifier(node.name) && node.type !== void 0 && (ts3.isTypeLiteralNode(node.type) || ts3.isIndexedAccessTypeNode(node.type) || isNeverType(node.type));
 }
-__name(isMethodMember, "isMethodMember");
 function isRequestMember(node) {
   return ts3.isPropertySignature(node) && ts3.isIdentifier(node.name) && node.type !== void 0 && !isNeverType(node.type);
 }
-__name(isRequestMember, "isRequestMember");
 function isRequestHeaders(node) {
   return isRequestMember(node) && node.name.text === "headers" && ts3.isTypeLiteralNode(node.type);
 }
-__name(isRequestHeaders, "isRequestHeaders");
 function isNormalizedRequestHeaders(node) {
   return isRequestMember(node) && node.name.text === "headers" && ts3.isTypeLiteralNode(node.type);
 }
-__name(isNormalizedRequestHeaders, "isNormalizedRequestHeaders");
 function isRequestParameters(node) {
   return isRequestMember(node) && node.name.text === "parameters" && ts3.isTypeLiteralNode(node.type);
 }
-__name(isRequestParameters, "isRequestParameters");
 function isContentPropertySignature(node) {
   return isRequestMember(node) && node.name.text === "content" && ts3.isTypeLiteralNode(node.type);
 }
-__name(isContentPropertySignature, "isContentPropertySignature");
 function isContentMember(node) {
   return ts3.isPropertySignature(node) && (ts3.isIdentifier(node.name) || ts3.isStringLiteral(node.name)) && node.type !== void 0 && !isNeverType(node.type);
 }
-__name(isContentMember, "isContentMember");
 function isResponse(node) {
   return ts3.isPropertySignature(node) && (ts3.isIdentifier(node.name) || ts3.isStringLiteral(node.name) || ts3.isNumericLiteral(node.name)) && node.type !== void 0;
 }
-__name(isResponse, "isResponse");
 function removeRedundantNullUnionIfNecessary(type) {
   const containsRedundantNullUnion = ts3.isUnionTypeNode(type) && type.types.some((type2) => {
     const isNull = ts3.isLiteralTypeNode(type2) && isNullType(type2.literal);
@@ -275,21 +236,18 @@ function removeRedundantNullUnionIfNecessary(type) {
   });
   return ts3.factory.createUnionTypeNode(typesWithoutRedundantNullUnion);
 }
-__name(removeRedundantNullUnionIfNecessary, "removeRedundantNullUnionIfNecessary");
 function wrapFormDataContentType(type, context) {
   context.typeImports.http.add("HttpFormData");
   return ts3.factory.createTypeReferenceNode(ts3.factory.createIdentifier("HttpFormData"), [
     renameComponentReferences(type, context)
   ]);
 }
-__name(wrapFormDataContentType, "wrapFormDataContentType");
 function wrapURLEncodedContentType(type, context) {
   context.typeImports.http.add("HttpSearchParams");
   return ts3.factory.createTypeReferenceNode(ts3.factory.createIdentifier("HttpSearchParams"), [
     renameComponentReferences(type, context)
   ]);
 }
-__name(wrapURLEncodedContentType, "wrapURLEncodedContentType");
 function normalizeRequestBodyMember(requestBodyMember, context, options) {
   if (!isContentMember(requestBodyMember)) {
     return void 0;
@@ -313,7 +271,6 @@ function normalizeRequestBodyMember(requestBodyMember, context, options) {
     )
   };
 }
-__name(normalizeRequestBodyMember, "normalizeRequestBodyMember");
 function normalizeHeaders(headers) {
   const newHeaderMembers = headers.members.filter((header) => {
     if (ts3.isIndexSignatureDeclaration(header)) {
@@ -329,7 +286,6 @@ function normalizeHeaders(headers) {
   }
   return ts3.factory.updateTypeLiteralNode(headers, ts3.factory.createNodeArray(newHeaderMembers));
 }
-__name(normalizeHeaders, "normalizeHeaders");
 function normalizeRequestHeaders(requestHeader) {
   if (!isRequestHeaders(requestHeader)) {
     return void 0;
@@ -346,7 +302,6 @@ function normalizeRequestHeaders(requestHeader) {
     newType
   );
 }
-__name(normalizeRequestHeaders, "normalizeRequestHeaders");
 function createHeaderForUnionByContentType(existingHeader, contentTypeName) {
   const existingHeaderMembers = existingHeader?.type.members ?? [];
   const contentTypeIdentifier = ts3.factory.createIdentifier('"content-type"');
@@ -362,7 +317,6 @@ function createHeaderForUnionByContentType(existingHeader, contentTypeName) {
     newHeaderType
   );
 }
-__name(createHeaderForUnionByContentType, "createHeaderForUnionByContentType");
 function normalizeContentType(contentType, context, options) {
   const { bodyQuestionToken } = options;
   if (ts3.isIndexedAccessTypeNode(contentType)) {
@@ -389,7 +343,6 @@ function normalizeContentType(contentType, context, options) {
     return ts3.factory.createUnionTypeNode(bodyMemberUnionTypes);
   }
 }
-__name(normalizeContentType, "normalizeContentType");
 function normalizeRequest(request, context) {
   const newIdentifier = ts3.factory.createIdentifier("request");
   const newType = normalizeContentType(request.type, context, {
@@ -401,7 +354,6 @@ function normalizeRequest(request, context) {
   }
   return ts3.factory.updatePropertySignature(request, request.modifiers, newIdentifier, void 0, newType);
 }
-__name(normalizeRequest, "normalizeRequest");
 function normalizeResponseType(responseType, context, options) {
   const { questionToken } = options;
   if (!ts3.isTypeLiteralNode(responseType)) {
@@ -409,7 +361,6 @@ function normalizeResponseType(responseType, context, options) {
   }
   return normalizeContentType(responseType, context, { bodyQuestionToken: questionToken });
 }
-__name(normalizeResponseType, "normalizeResponseType");
 var NON_NUMERIC_RESPONSE_STATUS_TO_MAPPED_TYPE = {
   default: "HttpStatusCode",
   "1xx": "HttpStatusCode.Information",
@@ -465,7 +416,6 @@ function normalizeResponse(response, context, options = {}) {
     }
   };
 }
-__name(normalizeResponse, "normalizeResponse");
 function normalizeResponses(responses, context) {
   if (isNeverType(responses.type) || !ts3.isTypeLiteralNode(responses.type)) {
     return void 0;
@@ -513,7 +463,6 @@ function normalizeResponses(responses, context) {
     renameComponentReferences(newType, context)
   );
 }
-__name(normalizeResponses, "normalizeResponses");
 function normalizeMethodMember(methodMember, context) {
   if (isMethodMember(methodMember)) {
     if (methodMember.name.text === "requestBody") {
@@ -526,7 +475,6 @@ function normalizeMethodMember(methodMember, context) {
   }
   return void 0;
 }
-__name(normalizeMethodMember, "normalizeMethodMember");
 function normalizeRequestQueryWithParameters(requestMember, context) {
   const newIdentifier = ts3.factory.createIdentifier("searchParams");
   const newQuestionToken = void 0;
@@ -539,7 +487,6 @@ function normalizeRequestQueryWithParameters(requestMember, context) {
     newType
   );
 }
-__name(normalizeRequestQueryWithParameters, "normalizeRequestQueryWithParameters");
 function normalizeRequestHeadersWithParameters(requestMember, context) {
   const newIdentifier = ts3.factory.createIdentifier("headers");
   const newQuestionToken = void 0;
@@ -552,7 +499,6 @@ function normalizeRequestHeadersWithParameters(requestMember, context) {
     newType
   );
 }
-__name(normalizeRequestHeadersWithParameters, "normalizeRequestHeadersWithParameters");
 function normalizeRequestMemberWithParameters(requestMember, context) {
   if (!isRequestMember(requestMember) || requestMember.name.text === "path") {
     return void 0;
@@ -565,7 +511,6 @@ function normalizeRequestMemberWithParameters(requestMember, context) {
   }
   return requestMember;
 }
-__name(normalizeRequestMemberWithParameters, "normalizeRequestMemberWithParameters");
 function mergeRequestHeadersMember(headers, otherHeaders) {
   const newType = ts3.factory.updateTypeLiteralNode(
     headers.type,
@@ -579,7 +524,6 @@ function mergeRequestHeadersMember(headers, otherHeaders) {
     newType
   );
 }
-__name(mergeRequestHeadersMember, "mergeRequestHeadersMember");
 function mergeRequestHeadersMembers(members) {
   let mergedHeaders;
   let firstHeadersIndex;
@@ -600,7 +544,6 @@ function mergeRequestHeadersMembers(members) {
   }
   return mergedHeadersMembers.filter(isDefined_default);
 }
-__name(mergeRequestHeadersMembers, "mergeRequestHeadersMembers");
 function mergeRequestAndParameterTypes(requestType, methodMembers, context) {
   const parameters = methodMembers.find(isRequestParameters);
   const parametersMembers = parameters ? parameters.type.members : [];
@@ -615,7 +558,6 @@ function mergeRequestAndParameterTypes(requestType, methodMembers, context) {
   }
   return ts3.factory.createTypeLiteralNode(newMembers);
 }
-__name(mergeRequestAndParameterTypes, "mergeRequestAndParameterTypes");
 function normalizeRequestTypeWithParameters(requestType, methodMembers, context) {
   if (ts3.isUnionTypeNode(requestType)) {
     const newTypes = requestType.types.map((type) => normalizeRequestTypeWithParameters(type, methodMembers, context)).filter(isDefined_default);
@@ -627,7 +569,6 @@ function normalizeRequestTypeWithParameters(requestType, methodMembers, context)
   }
   return mergeRequestAndParameterTypes(requestType, methodMembers, context);
 }
-__name(normalizeRequestTypeWithParameters, "normalizeRequestTypeWithParameters");
 function normalizeMethodMemberWithParameters(methodMember, methodMembers, context) {
   if (!ts3.isIdentifier(methodMember.name) || !methodMember.type) {
     return void 0;
@@ -650,12 +591,10 @@ function normalizeMethodMemberWithParameters(methodMember, methodMembers, contex
   }
   return void 0;
 }
-__name(normalizeMethodMemberWithParameters, "normalizeMethodMemberWithParameters");
 function normalizeTypeLiteralMethodType(methodType, context) {
   const newMembers = methodType.members.map((member) => normalizeMethodMember(member, context)).filter(isDefined_default).map((member, _index, partialMembers) => normalizeMethodMemberWithParameters(member, partialMembers, context)).filter(isDefined_default);
   return ts3.factory.updateTypeLiteralNode(methodType, ts3.factory.createNodeArray(newMembers));
 }
-__name(normalizeTypeLiteralMethodType, "normalizeTypeLiteralMethodType");
 function normalizeIndexedAccessMethodType(methodType, context) {
   const isOperationsReference = ts3.isTypeReferenceNode(methodType.objectType) && ts3.isIdentifier(methodType.objectType.typeName) && methodType.objectType.typeName.text === "operations";
   if (!isOperationsReference) {
@@ -670,7 +609,6 @@ function normalizeIndexedAccessMethodType(methodType, context) {
   }
   return ts3.factory.updateIndexedAccessTypeNode(methodType, newObjectType, methodType.indexType);
 }
-__name(normalizeIndexedAccessMethodType, "normalizeIndexedAccessMethodType");
 function normalizeMethod(method, context, options) {
   if (!isMethod(method)) {
     return void 0;
@@ -680,13 +618,13 @@ function normalizeMethod(method, context, options) {
     return void 0;
   }
   const matchesPositiveFilters = context.filters.paths.positive.length === 0 || context.filters.paths.positive.some(
-    (filter) => filter.methodPattern.test(methodName) && filter.pathPattern.test(options.pathName)
+    (filter) => filter.methodRegex.test(methodName) && filter.pathRegex.test(options.pathName)
   );
   if (!matchesPositiveFilters) {
     return void 0;
   }
   const matchesNegativeFilters = context.filters.paths.negative.length > 0 && context.filters.paths.negative.some(
-    (filter) => filter.methodPattern.test(methodName) && filter.pathPattern.test(options.pathName)
+    (filter) => filter.methodRegex.test(methodName) && filter.pathRegex.test(options.pathName)
   );
   if (matchesNegativeFilters) {
     return void 0;
@@ -695,23 +633,18 @@ function normalizeMethod(method, context, options) {
   const newType = ts3.isTypeLiteralNode(method.type) ? normalizeTypeLiteralMethodType(method.type, context) : normalizeIndexedAccessMethodType(method.type, context);
   return ts3.factory.updatePropertySignature(method, method.modifiers, newIdentifier, method.questionToken, newType);
 }
-__name(normalizeMethod, "normalizeMethod");
 function createPathsIdentifier(serviceName) {
   return ts3.factory.createIdentifier(`${serviceName}Schema`);
 }
-__name(createPathsIdentifier, "createPathsIdentifier");
 function isPathsDeclaration(node) {
   return node !== void 0 && (ts3.isInterfaceDeclaration(node) || ts3.isTypeAliasDeclaration(node)) && node.name.text === "paths";
 }
-__name(isPathsDeclaration, "isPathsDeclaration");
 function isPath(node) {
   return ts3.isPropertySignature(node) && (ts3.isIdentifier(node.name) || ts3.isStringLiteral(node.name)) && node.type !== void 0 && (ts3.isTypeLiteralNode(node.type) || ts3.isIndexedAccessTypeNode(node.type));
 }
-__name(isPath, "isPath");
 function normalizePathNameWithParameters(pathName) {
   return pathName.replace(/{([^}]+)}/g, ":$1");
 }
-__name(normalizePathNameWithParameters, "normalizePathNameWithParameters");
 function normalizePath(path4, context, options = {}) {
   const { isComponent: isComponent2 = false } = options;
   if (!isPath(path4)) {
@@ -731,13 +664,11 @@ function normalizePath(path4, context, options = {}) {
   }
   return ts3.factory.updatePropertySignature(path4, path4.modifiers, newIdentifier, path4.questionToken, newType);
 }
-__name(normalizePath, "normalizePath");
 function wrapPathsType(type, context) {
   context.typeImports.http.add("HttpSchema");
   const httpSchemaPathsWrapper = ts3.factory.createIdentifier("HttpSchema");
   return ts3.factory.createTypeReferenceNode(httpSchemaPathsWrapper, [type]);
 }
-__name(wrapPathsType, "wrapPathsType");
 function normalizePaths(pathsOrTypeAlias, context) {
   const newIdentifier = createPathsIdentifier(context.serviceName);
   const paths = ts3.isTypeAliasDeclaration(pathsOrTypeAlias) ? ts3.factory.createInterfaceDeclaration(pathsOrTypeAlias.modifiers, pathsOrTypeAlias.name, void 0, void 0, []) : pathsOrTypeAlias;
@@ -750,38 +681,30 @@ function normalizePaths(pathsOrTypeAlias, context) {
     wrapPathsType(newType, context)
   );
 }
-__name(normalizePaths, "normalizePaths");
 
 // src/typegen/openapi/transform/components.ts
 function createComponentsIdentifierText(serviceName) {
   return `${serviceName}Components`;
 }
-__name(createComponentsIdentifierText, "createComponentsIdentifierText");
 function createComponentsIdentifier(serviceName) {
   return ts3.factory.createIdentifier(createComponentsIdentifierText(serviceName));
 }
-__name(createComponentsIdentifier, "createComponentsIdentifier");
 function isComponentsDeclaration(node, context) {
   const componentIdentifiers = ["components", createComponentsIdentifierText(context.serviceName)];
   return node !== void 0 && ts3.isInterfaceDeclaration(node) && componentIdentifiers.includes(node.name.text);
 }
-__name(isComponentsDeclaration, "isComponentsDeclaration");
 function isComponentGroup(node) {
   return ts3.isPropertySignature(node) && node.type !== void 0 && ts3.isTypeLiteralNode(node.type) && ts3.isIdentifier(node.name);
 }
-__name(isComponentGroup, "isComponentGroup");
 function isComponent(node) {
   return ts3.isPropertySignature(node) && node.type !== void 0 && !isNeverType(node.type) && (ts3.isIdentifier(node.name) || ts3.isStringLiteral(node.name));
 }
-__name(isComponent, "isComponent");
 function isRequestComponent(node) {
   return ts3.isTypeLiteralNode(node.type);
 }
-__name(isRequestComponent, "isRequestComponent");
 function unchangedIndexedAccessTypeNode(node) {
   return node;
 }
-__name(unchangedIndexedAccessTypeNode, "unchangedIndexedAccessTypeNode");
 function visitComponentReferences(node, context, options) {
   const { onComponentReference, renameComponentReference = unchangedIndexedAccessTypeNode } = options;
   if (isUnknownType(node)) {
@@ -866,14 +789,12 @@ function visitComponentReferences(node, context, options) {
   }
   return node;
 }
-__name(visitComponentReferences, "visitComponentReferences");
 function normalizeComponentGroupName(rawComponentGroupName) {
   if (rawComponentGroupName === "requestBodies") {
     return "requests";
   }
   return rawComponentGroupName;
 }
-__name(normalizeComponentGroupName, "normalizeComponentGroupName");
 function renameComponentReferences(node, context) {
   return visitComponentReferences(node, context, {
     onComponentReference(_node, componentPath) {
@@ -891,7 +812,6 @@ function renameComponentReferences(node, context) {
     }
   });
 }
-__name(renameComponentReferences, "renameComponentReferences");
 function processPendingRequestComponentActions(component, context) {
   const pendingRequestActions = context.pendingActions.components.requests;
   const componentName = component.name.text;
@@ -900,7 +820,6 @@ function processPendingRequestComponentActions(component, context) {
   pendingRequestActions.toMarkBodyAsOptional.delete(componentName);
   return { bodyQuestionToken };
 }
-__name(processPendingRequestComponentActions, "processPendingRequestComponentActions");
 function normalizeRequestComponent(component, context) {
   if (!isRequestComponent(component)) {
     return void 0;
@@ -915,7 +834,6 @@ function normalizeRequestComponent(component, context) {
     newType
   );
 }
-__name(normalizeRequestComponent, "normalizeRequestComponent");
 function normalizeComponent(component, componentGroupName, context) {
   if (!isComponent(component)) {
     return void 0;
@@ -938,7 +856,6 @@ function normalizeComponent(component, componentGroupName, context) {
     renameComponentReferences(component.type, context)
   );
 }
-__name(normalizeComponent, "normalizeComponent");
 function normalizeComponentGroup(componentGroup, context) {
   if (!isComponentGroup(componentGroup)) {
     return void 0;
@@ -955,7 +872,6 @@ function normalizeComponentGroup(componentGroup, context) {
     newType
   );
 }
-__name(normalizeComponentGroup, "normalizeComponentGroup");
 function normalizeComponents(components, context) {
   const newIdentifier = createComponentsIdentifier(context.serviceName);
   const newMembers = components.members.map((componentGroup) => normalizeComponentGroup(componentGroup, context)).filter(isDefined_default);
@@ -968,7 +884,6 @@ function normalizeComponents(components, context) {
     newMembers
   );
 }
-__name(normalizeComponents, "normalizeComponents");
 function populateReferencedComponents(components, context) {
   const pathsToVisit = new Set(context.referencedTypes.components);
   while (pathsToVisit.size > 0) {
@@ -1002,7 +917,6 @@ function populateReferencedComponents(components, context) {
     }
   }
 }
-__name(populateReferencedComponents, "populateReferencedComponents");
 function removeComponentIfUnreferenced(component, componentGroupName, context) {
   if (!isComponent(component)) {
     return void 0;
@@ -1015,7 +929,6 @@ function removeComponentIfUnreferenced(component, componentGroupName, context) {
   }
   return void 0;
 }
-__name(removeComponentIfUnreferenced, "removeComponentIfUnreferenced");
 function removeUnreferencedComponentsInGroup(componentGroup, context) {
   if (!isComponentGroup(componentGroup)) {
     return void 0;
@@ -1033,7 +946,6 @@ function removeUnreferencedComponentsInGroup(componentGroup, context) {
     ts3.factory.updateTypeLiteralNode(componentGroup.type, ts3.factory.createNodeArray(newComponents))
   );
 }
-__name(removeUnreferencedComponentsInGroup, "removeUnreferencedComponentsInGroup");
 function removeUnreferencedComponents(components, context) {
   const newComponentGroups = components.members.map((componentGroup) => removeUnreferencedComponentsInGroup(componentGroup, context)).filter(isDefined_default);
   context.referencedTypes.components.clear();
@@ -1049,136 +961,53 @@ function removeUnreferencedComponents(components, context) {
     newComponentGroups
   );
 }
-__name(removeUnreferencedComponents, "removeUnreferencedComponents");
 
 // src/utils/strings.ts
 function convertToPascalCase(value) {
   return value.replace(/(?:^|[^A-Za-z\d])([A-Za-z\d])/g, (_match, letter) => letter.toUpperCase());
 }
-__name(convertToPascalCase, "convertToPascalCase");
 
 // ../zimic-utils/dist/data/isNonEmpty.mjs
 function isNonEmpty(value) {
   return isDefined_default(value) && value !== "";
 }
-__name(isNonEmpty, "isNonEmpty");
-__name2(isNonEmpty, "isNonEmpty");
 var isNonEmpty_default = isNonEmpty;
 
-// ../zimic-utils/dist/chunk-FPJJAH7P.mjs
-function getExtraPatternsToEscape() {
+// ../zimic-utils/dist/chunk-TYSDS3LQ.mjs
+function createPathCharactersToEscapeRegex() {
   return /([.(){}+$])/g;
 }
-__name(getExtraPatternsToEscape, "getExtraPatternsToEscape");
-__name2(getExtraPatternsToEscape, "getExtraPatternsToEscape");
-function getURIEncodedBackSlashPattern() {
-  return /%5C/g;
-}
-__name(getURIEncodedBackSlashPattern, "getURIEncodedBackSlashPattern");
-__name2(getURIEncodedBackSlashPattern, "getURIEncodedBackSlashPattern");
-function getPathParamPattern() {
-  return /(?<escape>\\)?:(?<identifier>[$_\p{ID_Start}][$\p{ID_Continue}]+)/gu;
-}
-__name(getPathParamPattern, "getPathParamPattern");
-__name2(getPathParamPattern, "getPathParamPattern");
-function getRepeatingPathParamPattern() {
-  return /(?<escape>\\)?:(?<identifier>[$_\p{ID_Start}][$\p{ID_Continue}]+)\\+/gu;
-}
-__name(getRepeatingPathParamPattern, "getRepeatingPathParamPattern");
-__name2(getRepeatingPathParamPattern, "getRepeatingPathParamPattern");
-function getOptionalPathParamPattern() {
-  return /(?<leadingSlash>\/)?(?<escape>\\)?:(?<identifier>[$_\p{ID_Start}][$\p{ID_Continue}]+)\?(?<trailingSlash>\/)?/gu;
-}
-__name(getOptionalPathParamPattern, "getOptionalPathParamPattern");
-__name2(getOptionalPathParamPattern, "getOptionalPathParamPattern");
-function getOptionalRepeatingPathParamPattern() {
-  return /(?<leadingSlash>\/)?(?<escape>\\)?:(?<identifier>[$_\p{ID_Start}][$\p{ID_Continue}]+)\*(?<trailingSlash>\/)?/gu;
-}
-__name(getOptionalRepeatingPathParamPattern, "getOptionalRepeatingPathParamPattern");
-__name2(getOptionalRepeatingPathParamPattern, "getOptionalRepeatingPathParamPattern");
-function createParametrizedPathPattern(path4) {
-  const replacedURL = encodeURI(path4).replace(/^\/+/g, "").replace(/\/+$/g, "").replace(getExtraPatternsToEscape(), "\\$1").replace(getURIEncodedBackSlashPattern(), "\\").replace(
-    getOptionalRepeatingPathParamPattern(),
-    (_match, leadingSlash, escape, identifier, trailingSlash) => {
-      if (escape) {
-        return `:${identifier}`;
-      }
-      const hasSegmentBeforePrefix = leadingSlash === "/";
-      const prefixExpression = hasSegmentBeforePrefix ? "/?" : leadingSlash;
-      const hasSegmentAfterSuffix = trailingSlash === "/";
-      const suffixExpression = hasSegmentAfterSuffix ? "/?" : trailingSlash;
-      if (prefixExpression && suffixExpression) {
-        return `(?:${prefixExpression}(?<${identifier}>.+?)?${suffixExpression})?`;
-      } else if (prefixExpression) {
-        return `(?:${prefixExpression}(?<${identifier}>.+?))?`;
-      } else if (suffixExpression) {
-        return `(?:(?<${identifier}>.+?)${suffixExpression})?`;
-      } else {
-        return `(?<${identifier}>.+?)?`;
-      }
-    }
-  ).replace(getRepeatingPathParamPattern(), (_match, escape, identifier) => {
-    return escape ? `:${identifier}` : `(?<${identifier}>.+)`;
-  }).replace(
-    getOptionalPathParamPattern(),
-    (_match, leadingSlash, escape, identifier, trailingSlash) => {
-      if (escape) {
-        return `:${identifier}`;
-      }
-      const hasSegmentBeforePrefix = leadingSlash === "/";
-      const prefixExpression = hasSegmentBeforePrefix ? "/?" : leadingSlash;
-      const hasSegmentAfterSuffix = trailingSlash === "/";
-      const suffixExpression = hasSegmentAfterSuffix ? "/?" : trailingSlash;
-      if (prefixExpression && suffixExpression) {
-        return `(?:${prefixExpression}(?<${identifier}>[^\\/]+?)?${suffixExpression})`;
-      } else if (prefixExpression) {
-        return `(?:${prefixExpression}(?<${identifier}>[^\\/]+?))?`;
-      } else if (suffixExpression) {
-        return `(?:(?<${identifier}>[^\\/]+?)${suffixExpression})?`;
-      } else {
-        return `(?<${identifier}>[^\\/]+?)?`;
-      }
-    }
-  ).replace(getPathParamPattern(), (_match, escape, identifier) => {
-    return escape ? `:${identifier}` : `(?<${identifier}>[^\\/]+?)`;
-  });
-  return new RegExp(`^/?${replacedURL}/?$`);
+function preparePathForRegex(path4) {
+  const pathURLPrefix = `data:${path4.startsWith("/") ? "" : "/"}`;
+  const pathAsURL = new URL(`${pathURLPrefix}${path4}`);
+  const encodedPath = pathAsURL.href.replace(pathURLPrefix, "");
+  return encodedPath.replace(/^\/+/g, "").replace(/\/+$/g, "").replace(createPathCharactersToEscapeRegex(), "\\$1");
 }
-__name(createParametrizedPathPattern, "createParametrizedPathPattern");
-__name2(createParametrizedPathPattern, "createParametrizedPathPattern");
 
-// ../zimic-utils/dist/url/createWildcardPathPattern.mjs
-function getSingleWildcardPattern() {
+// ../zimic-utils/dist/url/createWildcardRegexFromPath.mjs
+function getSingleWildcardPathRegex() {
   return /(?<wildcardPrefix>^|[^*])(?<escape>\\)?\*(?<wildcardSuffix>[^*]|$)/g;
 }
-__name(getSingleWildcardPattern, "getSingleWildcardPattern");
-__name2(getSingleWildcardPattern, "getSingleWildcardPattern");
-function getDoubleWildcardPattern() {
+function getDoubleWildcardPathRegex() {
   return /(?<escape>\\)?\*\*/g;
 }
-__name(getDoubleWildcardPattern, "getDoubleWildcardPattern");
-__name2(getDoubleWildcardPattern, "getDoubleWildcardPattern");
-function getTripleWildcardPattern() {
+function getTripleWildcardPathRegex() {
   return /(?<escape>\\)?\*\*\/\*(?<wildcardSuffix>[^*]|$)/g;
 }
-__name(getTripleWildcardPattern, "getTripleWildcardPattern");
-__name2(getTripleWildcardPattern, "getTripleWildcardPattern");
-function createWildcardPathPattern(path4) {
-  const replacedURL = encodeURI(path4).replace(/^\/+/g, "").replace(/\/+$/g, "").replace(getExtraPatternsToEscape(), "\\$1").replace(getURIEncodedBackSlashPattern(), "\\").replace(getTripleWildcardPattern(), (_match, escape, wildcardSuffix) => {
+function createWildcardRegexFromPath(path4) {
+  const pathRegexContent = preparePathForRegex(path4).replace(getTripleWildcardPathRegex(), (_match, escape, wildcardSuffix) => {
     return escape === "\\" ? `\\*\\*/\\*${wildcardSuffix}` : `**${wildcardSuffix}`;
   }).replace(
-    getSingleWildcardPattern(),
+    getSingleWildcardPathRegex(),
     (_match, wildcardPrefix, escape, wildcardSuffix) => {
       return escape === "\\" ? `${wildcardPrefix}\\*${wildcardSuffix}` : `${wildcardPrefix}[^/]*${wildcardSuffix}`;
     }
-  ).replace(getDoubleWildcardPattern(), (_match, escape) => {
+  ).replace(getDoubleWildcardPathRegex(), (_match, escape) => {
     return escape === "\\" ? "\\*\\*" : ".*";
   });
-  return new RegExp(`^/?${replacedURL}/?$`);
+  return new RegExp(`^/?${pathRegexContent}/?$`);
 }
-__name(createWildcardPathPattern, "createWildcardPathPattern");
-__name2(createWildcardPathPattern, "createWildcardPathPattern");
-var createWildcardPathPattern_default = createWildcardPathPattern;
+var createWildcardRegexFromPath_default = createWildcardRegexFromPath;
 var HTTP_METHOD_OPTIONS = HTTP_METHODS.join("|");
 var MODIFIER_GROUP = "(?<modifier>!?)";
 var METHOD_FILTER_GROUP = `(?<method>(?:\\*|(?:${HTTP_METHOD_OPTIONS})(?:,\\s*(?:${HTTP_METHOD_OPTIONS}))*))`;
@@ -1193,12 +1022,11 @@ function parseRawFilter(rawFilter) {
     return void 0;
   }
   return {
-    methodPattern: new RegExp(`(?:${filteredMethodsOrWildcard.toUpperCase().replace(/,/g, "|").replace(/\*/g, ".*")})`),
-    pathPattern: createWildcardPathPattern_default(filteredPath),
+    methodRegex: new RegExp(`(?:${filteredMethodsOrWildcard.toUpperCase().replace(/,/g, "|").replace(/\*/g, ".*")})`),
+    pathRegex: createWildcardRegexFromPath_default(filteredPath),
     isNegativeMatch: filterModifier === "!"
   };
 }
-__name(parseRawFilter, "parseRawFilter");
 function groupParsedFiltersByMatch(parsedFilters) {
   return parsedFilters.reduce(
     (groupedFilters, filter) => {
@@ -1214,18 +1042,15 @@ function groupParsedFiltersByMatch(parsedFilters) {
     { positive: [], negative: [] }
   );
 }
-__name(groupParsedFiltersByMatch, "groupParsedFiltersByMatch");
 async function readPathFiltersFromFile(filePath) {
   const fileContent = await filesystem.readFile(path.resolve(filePath), "utf-8");
   const fileContentWithoutComments = fileContent.replace(/#.*$/gm, "");
   const filters = fileContentWithoutComments.split("\n");
   return filters;
 }
-__name(readPathFiltersFromFile, "readPathFiltersFromFile");
 function ignoreEmptyFilters(filters) {
   return filters.map((line) => line.trim()).filter(isNonEmpty_default);
 }
-__name(ignoreEmptyFilters, "ignoreEmptyFilters");
 
 // src/typegen/openapi/transform/context.ts
 function createTypeTransformationContext(serviceName, rawFilters) {
@@ -1249,29 +1074,23 @@ function createTypeTransformationContext(serviceName, rawFilters) {
     }
   };
 }
-__name(createTypeTransformationContext, "createTypeTransformationContext");
 
 // src/typegen/openapi/transform/imports.ts
 var TYPEGEN_HTTP_IMPORT_MODULE = "@zimic/http";
 function createImportDeclarations(context) {
   const httpTypeImports = Array.from(context.typeImports.http).sort().map(createImportSpecifier);
-  const httpImportDeclaration = createImportDeclaration(httpTypeImports, TYPEGEN_HTTP_IMPORT_MODULE, {
-    typeOnly: true
-  });
+  const httpImportDeclaration = createImportDeclaration(httpTypeImports, TYPEGEN_HTTP_IMPORT_MODULE);
   return [httpImportDeclaration];
 }
-__name(createImportDeclarations, "createImportDeclarations");
 
 // ../zimic-utils/dist/import/createCachedDynamicImport.mjs
 function createCachedDynamicImport(importModuleDynamically) {
   let cachedImportResult;
-  return /* @__PURE__ */ __name2(/* @__PURE__ */ __name(async function importModuleDynamicallyWithCache() {
+  return async function importModuleDynamicallyWithCache() {
     cachedImportResult ??= await importModuleDynamically();
     return cachedImportResult;
-  }, "importModuleDynamicallyWithCache"), "importModuleDynamicallyWithCache");
+  };
 }
-__name(createCachedDynamicImport, "createCachedDynamicImport");
-__name2(createCachedDynamicImport, "createCachedDynamicImport");
 var createCachedDynamicImport_default = createCachedDynamicImport;
 var importOpenapiTypeScript = createCachedDynamicImport_default(() => import('openapi-typescript'));
 function transformSchemaObject(schemaObject) {
@@ -1284,7 +1103,6 @@ function transformSchemaObject(schemaObject) {
     return blobType;
   }
 }
-__name(transformSchemaObject, "transformSchemaObject");
 function convertFilePathOrURLToURL(filePathOrURL) {
   try {
     return new URL(filePathOrURL);
@@ -1292,7 +1110,6 @@ function convertFilePathOrURLToURL(filePathOrURL) {
     return new URL(`file://${path.resolve(filePathOrURL)}`);
   }
 }
-__name(convertFilePathOrURLToURL, "convertFilePathOrURLToURL");
 async function importTypesFromOpenAPI(filePathOrURL) {
   const schemaURL = convertFilePathOrURLToURL(filePathOrURL);
   const { default: generateTypesFromOpenAPI2 } = await importOpenapiTypeScript();
@@ -1314,7 +1131,6 @@ async function importTypesFromOpenAPI(filePathOrURL) {
   });
   return rawNodes;
 }
-__name(importTypesFromOpenAPI, "importTypesFromOpenAPI");
 async function convertTypesToString(nodes, options) {
   const { astToString: convertTypeASTToString } = await importOpenapiTypeScript();
   const typeOutput = convertTypeASTToString(nodes, {
@@ -1322,7 +1138,6 @@ async function convertTypesToString(nodes, options) {
   });
   return typeOutput;
 }
-__name(convertTypesToString, "convertTypesToString");
 function prepareTypeOutputToSave(output) {
   const formattedOutput = output.replace(/^export (\w+)/gm, "\nexport $1").replace(/^( {4})+/gm, (match) => match.replace(/ {4}/g, "  "));
   const formattedOutputWithPrefix = [
@@ -1332,13 +1147,11 @@ function prepareTypeOutputToSave(output) {
   ].join("\n");
   return formattedOutputWithPrefix;
 }
-__name(prepareTypeOutputToSave, "prepareTypeOutputToSave");
 async function writeTypeOutputToStandardOutput(formattedOutput) {
   await new Promise((resolve) => {
     process.stdout.write(formattedOutput, "utf-8", resolve);
   });
 }
-__name(writeTypeOutputToStandardOutput, "writeTypeOutputToStandardOutput");
 
 // src/typegen/openapi/generate.ts
 var RESOURCES_TO_REMOVE_IF_NOT_NORMALIZED = ["paths", "webhooks", "operations", "components", "$defs"];
@@ -1349,7 +1162,6 @@ function removeUnknownResources(node) {
   }
   return node;
 }
-__name(removeUnknownResources, "removeUnknownResources");
 function normalizeRawNodes(rawNodes, context, options) {
   let normalizedNodes = rawNodes.map((node) => isPathsDeclaration(node) ? normalizePaths(node, context) : node);
   if (options.prune) {
@@ -1367,7 +1179,6 @@ function normalizeRawNodes(rawNodes, context, options) {
   normalizedNodes = normalizedNodes.map((node) => isComponentsDeclaration(node, context) ? normalizeComponents(node, context) : node).map(removeUnknownResources).filter(isDefined_default);
   return normalizedNodes;
 }
-__name(normalizeRawNodes, "normalizeRawNodes");
 async function generateTypesFromOpenAPI({
   input: inputFilePathOrURL,
   output: outputFilePath,
@@ -1395,7 +1206,6 @@ async function generateTypesFromOpenAPI({
     await filesystem.writeFile(path.resolve(outputFilePath), formattedOutput);
   }
 }
-__name(generateTypesFromOpenAPI, "generateTypesFromOpenAPI");
 var generate_default = generateTypesFromOpenAPI;
 /* istanbul ignore if -- @preserve
  * Operation members are always expected to be an operation. */
@@ -1437,6 +1247,6 @@ var generate_default = generateTypesFromOpenAPI;
 /* istanbul ignore next -- @preserve
  * The root import module is defined at build time. The fallback is not expected to be used. */
 
-export { __name, generate_default, logger };
-//# sourceMappingURL=chunk-NMM3FZVR.mjs.map
-//# sourceMappingURL=chunk-NMM3FZVR.mjs.map
+export { generate_default, logger };
+//# sourceMappingURL=chunk-ZPOGWLJW.mjs.map
+//# sourceMappingURL=chunk-ZPOGWLJW.mjs.map