llm-strings 1.2.0 → 1.4.0

package/dist/ai-sdk.js

@@ -1,18 +1,49 @@
 import {
   normalize
-} from "./chunk-2ARD4TFU.js";
-import "./chunk-W4NIQY7M.js";
+} from "./chunk-DPVT3FFP.js";
+import {
+  parse
+} from "./chunk-5YTG2NRX.js";
+import "./chunk-76EFNZCF.js";
 
 // src/ai-sdk.ts
 var PROVIDER_OPTION_KEYS = {
   openai: "openai",
+  azure: "azure",
   anthropic: "anthropic",
   google: "google",
+  "google-vertex": "vertex",
   mistral: "mistral",
   cohere: "cohere",
   bedrock: "bedrock",
   openrouter: "openrouter",
-  vercel: "gateway"
+  vercel: "gateway",
+  xai: "xai",
+  groq: "groq",
+  fal: "fal",
+  deepinfra: "deepinfra",
+  "black-forest-labs": "blackForestLabs",
+  together: "together",
+  fireworks: "fireworks",
+  deepseek: "deepseek",
+  moonshotai: "moonshotai",
+  perplexity: "perplexity",
+  alibaba: "alibaba",
+  cerebras: "cerebras",
+  replicate: "replicate",
+  prodia: "prodia",
+  luma: "luma",
+  bytedance: "bytedance",
+  kling: "kling",
+  elevenlabs: "elevenlabs",
+  assemblyai: "assemblyai",
+  deepgram: "deepgram",
+  gladia: "gladia",
+  lmnt: "lmnt",
+  hume: "hume",
+  revai: "revai",
+  baseten: "baseten",
+  huggingface: "huggingface"
 };
 var TRUE_VALUES = /* @__PURE__ */ new Set(["true", "1", "yes", "on"]);
 var FALSE_VALUES = /* @__PURE__ */ new Set(["false", "0", "no", "off"]);
@@ -63,8 +94,7 @@ function mergeObjectOption(options, provider, key, value) {
     setProviderOption(options, provider, key, parsed);
   }
 }
-function addOpenAiOption(options, key, value) {
-  const target = "openai";
+function addOpenAiOption(options, key, value, target = "openai") {
   const mappings = {
     reasoning_effort: "reasoningEffort",
     max_completion_tokens: "maxCompletionTokens",
@@ -176,8 +206,7 @@ function addAnthropicOption(options, key, value) {
   }
   setProviderOption(options, target, optionKey, typedValue(value));
 }
-function addGoogleOption(options, key, value) {
-  const target = "google";
+function addGoogleOption(options, key, value, target = "google") {
   if (key === "thinking_budget" || key === "thinking_level" || key === "include_thoughts") {
     const current = options[target]?.thinkingConfig;
     const thinkingConfig = current && typeof current === "object" && !Array.isArray(current) ? { ...current } : {};
@@ -413,21 +442,71 @@ function addOpenRouterOption(options, key, value) {
     setProviderOption(options, target, "user", value);
   }
 }
+function addFlexibleProviderOption(options, target, key, value) {
+  setProviderOption(options, target, key, typedValue(value));
+}
 function addProviderSpecificOption(options, provider, key, value, includeGatewayOptions) {
   if (provider === "vercel") {
     if (includeGatewayOptions) addGatewayOption(options, key, value);
     return;
   }
   if (provider === "openai") addOpenAiOption(options, key, value);
+  if (provider === "azure") addOpenAiOption(options, key, value, "azure");
   if (provider === "anthropic") addAnthropicOption(options, key, value);
   if (provider === "google") addGoogleOption(options, key, value);
+  if (provider === "google-vertex")
+    addGoogleOption(options, key, value, "vertex");
   if (provider === "mistral") addMistralOption(options, key, value);
   if (provider === "cohere") addCohereOption(options, key, value);
   if (provider === "bedrock") addBedrockOption(options, key, value);
   if (provider === "openrouter") addOpenRouterOption(options, key, value);
+  if (provider === "xai") addOpenAiOption(options, key, value, "xai");
+  if (provider === "groq") addOpenAiOption(options, key, value, "groq");
+  if (provider === "fal") addFlexibleProviderOption(options, "fal", key, value);
+  if (provider === "deepinfra")
+    addOpenAiOption(options, key, value, "deepinfra");
+  if (provider === "black-forest-labs")
+    addFlexibleProviderOption(options, "blackForestLabs", key, value);
+  if (provider === "together") addOpenAiOption(options, key, value, "together");
+  if (provider === "fireworks")
+    addOpenAiOption(options, key, value, "fireworks");
+  if (provider === "deepseek") addOpenAiOption(options, key, value, "deepseek");
+  if (provider === "moonshotai")
+    addOpenAiOption(options, key, value, "moonshotai");
+  if (provider === "perplexity")
+    addOpenAiOption(options, key, value, "perplexity");
+  if (provider === "alibaba") addOpenAiOption(options, key, value, "alibaba");
+  if (provider === "cerebras") addOpenAiOption(options, key, value, "cerebras");
+  if (provider === "replicate")
+    addFlexibleProviderOption(options, "replicate", key, value);
+  if (provider === "prodia")
+    addFlexibleProviderOption(options, "prodia", key, value);
+  if (provider === "luma")
+    addFlexibleProviderOption(options, "luma", key, value);
+  if (provider === "bytedance")
+    addFlexibleProviderOption(options, "bytedance", key, value);
+  if (provider === "kling")
+    addFlexibleProviderOption(options, "kling", key, value);
+  if (provider === "elevenlabs")
+    addFlexibleProviderOption(options, "elevenlabs", key, value);
+  if (provider === "assemblyai")
+    addFlexibleProviderOption(options, "assemblyai", key, value);
+  if (provider === "deepgram")
+    addFlexibleProviderOption(options, "deepgram", key, value);
+  if (provider === "gladia")
+    addFlexibleProviderOption(options, "gladia", key, value);
+  if (provider === "lmnt")
+    addFlexibleProviderOption(options, "lmnt", key, value);
+  if (provider === "hume")
+    addFlexibleProviderOption(options, "hume", key, value);
+  if (provider === "revai")
+    addFlexibleProviderOption(options, "revai", key, value);
+  if (provider === "baseten") addOpenAiOption(options, key, value, "baseten");
+  if (provider === "huggingface")
+    addOpenAiOption(options, key, value, "huggingface");
 }
 function createAiSdkProviderOptions(configOrResult, options = {}) {
-  const normalized = "changes" in configOrResult && "subProvider" in configOrResult ? configOrResult : normalize(configOrResult, options);
+  const normalized = typeof configOrResult === "string" ? normalize(parse(configOrResult), options) : "changes" in configOrResult && "subProvider" in configOrResult ? configOrResult : normalize(configOrResult, options);
   const providerOptions = {};
   if (!normalized.provider) {
     return {
@@ -462,4 +541,3 @@ function createAiSdkProviderOptions(configOrResult, options = {}) {
 export {
   createAiSdkProviderOptions
 };
-//# sourceMappingURL=ai-sdk.js.map

package/dist/{chunk-BCOUH7LH.js → chunk-5YTG2NRX.js}

@@ -1,6 +1,6 @@
 import {
   resolveHostAlias
-} from "./chunk-W4NIQY7M.js";
+} from "./chunk-76EFNZCF.js";
 
 // src/parse.ts
 function parse(connectionString) {
@@ -40,4 +40,3 @@ export {
   parse,
   build
 };
-//# sourceMappingURL=chunk-BCOUH7LH.js.map

package/dist/{chunk-W4NIQY7M.js → chunk-76EFNZCF.js}

@@ -4,8 +4,10 @@ function hasOwn(object, key) {
 }
 var HOST_ALIASES = {
   openai: "api.openai.com",
+  azure: "models.inference.ai.azure.com",
   anthropic: "api.anthropic.com",
   google: "generativelanguage.googleapis.com",
+  "google-vertex": "aiplatform.googleapis.com",
   aistudio: "generativelanguage.googleapis.com",
   mistral: "api.mistral.ai",
   cohere: "api.cohere.com",
@@ -15,8 +17,16 @@ var HOST_ALIASES = {
   alibaba: "dashscope-intl.aliyuncs.com",
   alibabacloud: "dashscope-intl.aliyuncs.com",
   dashscope: "dashscope-intl.aliyuncs.com",
+  groq: "api.groq.com",
+  fal: "fal.run",
   fireworks: "api.fireworks.ai",
   fireworksai: "api.fireworks.ai",
+  "black-forest-labs": "api.bfl.ai",
+  bfl: "api.bfl.ai",
+  deepseek: "api.deepseek.com",
+  moonshotai: "api.moonshot.ai",
+  moonshot: "api.moonshot.ai",
+  perplexity: "api.perplexity.ai",
   venice: "api.venice.ai",
   parasail: "api.parasail.io",
   deepinfra: "api.deepinfra.com",
@@ -25,6 +35,23 @@ var HOST_ALIASES = {
   novitaai: "api.novita.ai",
   grok: "api.x.ai",
   xai: "api.x.ai",
+  together: "api.together.xyz",
+  togetherai: "api.together.xyz",
+  cerebras: "api.cerebras.ai",
+  replicate: "api.replicate.com",
+  prodia: "api.prodia.com",
+  luma: "api.lumalabs.ai",
+  bytedance: "ark.cn-beijing.volces.com",
+  kling: "api.klingai.com",
+  elevenlabs: "api.elevenlabs.io",
+  assemblyai: "api.assemblyai.com",
+  deepgram: "api.deepgram.com",
+  gladia: "api.gladia.io",
+  lmnt: "api.lmnt.com",
+  hume: "api.hume.ai",
+  revai: "api.rev.ai",
+  baseten: "api.baseten.co",
+  huggingface: "api-inference.huggingface.co",
   wandb: "api.inference.wandb.ai",
   weightsandbiases: "api.inference.wandb.ai",
   baidu: "qianfan.baidubce.com",
@@ -33,6 +60,18 @@ var HOST_ALIASES = {
   xiaomi: "api.xiaomimimo.com",
   minimax: "api.minimax.io"
 };
+var HOST_ALIAS_PROVIDERS = {
+  aistudio: "google",
+  vertex: "google-vertex",
+  grok: "xai",
+  bfl: "black-forest-labs",
+  moonshot: "moonshotai",
+  alibaba: "alibaba",
+  alibabacloud: "alibaba",
+  dashscope: "alibaba",
+  togetherai: "together",
+  fireworksai: "fireworks"
+};
 function readProcessEnv() {
   return typeof process !== "undefined" && process.env ? process.env : {};
 }
@@ -69,6 +108,9 @@ function providerFromHostAlias(alias) {
   if (hasOwn(PROVIDER_PARAMS, normalizedAlias)) {
     return normalizedAlias;
   }
+  if (hasOwn(HOST_ALIAS_PROVIDERS, normalizedAlias)) {
+    return HOST_ALIAS_PROVIDERS[normalizedAlias];
+  }
   return void 0;
 }
 function detectProvider(host) {
@@ -76,6 +118,34 @@ function detectProvider(host) {
   if (host.includes("openrouter")) return "openrouter";
   if (host.includes("gateway.ai.vercel")) return "vercel";
   if (host.includes("amazonaws") || host.includes("bedrock")) return "bedrock";
+  if (host.includes("aiplatform.googleapis")) return "google-vertex";
+  if (host.includes("api.x.ai")) return "xai";
+  if (host.includes("groq")) return "groq";
+  if (host.includes("fal.run") || host.includes("fal.ai")) return "fal";
+  if (host.includes("deepinfra")) return "deepinfra";
+  if (host.includes("bfl.ai")) return "black-forest-labs";
+  if (host.includes("together")) return "together";
+  if (host.includes("fireworks")) return "fireworks";
+  if (host.includes("deepseek")) return "deepseek";
+  if (host.includes("moonshot")) return "moonshotai";
+  if (host.includes("perplexity")) return "perplexity";
+  if (host.includes("dashscope") || host.includes("aliyuncs")) return "alibaba";
+  if (host.includes("cerebras")) return "cerebras";
+  if (host.includes("replicate")) return "replicate";
+  if (host.includes("prodia")) return "prodia";
+  if (host.includes("lumalabs") || host.includes("luma")) return "luma";
+  if (host.includes("volces") || host.includes("bytedance")) return "bytedance";
+  if (host.includes("kling")) return "kling";
+  if (host.includes("elevenlabs")) return "elevenlabs";
+  if (host.includes("assemblyai")) return "assemblyai";
+  if (host.includes("deepgram")) return "deepgram";
+  if (host.includes("gladia")) return "gladia";
+  if (host.includes("lmnt")) return "lmnt";
+  if (host.includes("hume")) return "hume";
+  if (host.includes("rev.ai")) return "revai";
+  if (host.includes("baseten")) return "baseten";
+  if (host.includes("huggingface")) return "huggingface";
+  if (host.includes("azure")) return "azure";
   if (host.includes("openai")) return "openai";
   if (host.includes("anthropic") || host.includes("claude")) return "anthropic";
   if (host.includes("googleapis") || host.includes("google")) return "google";
@@ -130,6 +200,33 @@ var ALIASES = {
   cachePoint: "cache",
   cache_point: "cache"
 };
+var OPENAI_COMPATIBLE_PARAMS = {
+  temperature: "temperature",
+  max_tokens: "max_tokens",
+  top_p: "top_p",
+  top_k: "top_k",
+  frequency_penalty: "frequency_penalty",
+  presence_penalty: "presence_penalty",
+  stop: "stop",
+  n: "n",
+  seed: "seed",
+  stream: "stream",
+  effort: "reasoning_effort"
+};
+var GOOGLE_COMPATIBLE_PARAMS = {
+  temperature: "temperature",
+  max_tokens: "maxOutputTokens",
+  top_p: "topP",
+  top_k: "topK",
+  frequency_penalty: "frequencyPenalty",
+  presence_penalty: "presencePenalty",
+  stop: "stopSequences",
+  n: "candidateCount",
+  stream: "stream",
+  seed: "seed",
+  responseMimeType: "responseMimeType",
+  responseSchema: "responseSchema"
+};
 var PROVIDER_PARAMS = {
   openai: {
     temperature: "temperature",
@@ -143,6 +240,7 @@ var PROVIDER_PARAMS = {
     stream: "stream",
     effort: "reasoning_effort"
   },
+  azure: OPENAI_COMPATIBLE_PARAMS,
   anthropic: {
     temperature: "temperature",
     max_tokens: "max_tokens",
@@ -168,6 +266,7 @@ var PROVIDER_PARAMS = {
     responseMimeType: "responseMimeType",
     responseSchema: "responseSchema"
   },
+  "google-vertex": GOOGLE_COMPATIBLE_PARAMS,
   mistral: {
     temperature: "temperature",
     max_tokens: "max_tokens",
@@ -231,8 +330,139 @@ var PROVIDER_PARAMS = {
     seed: "seed",
     stream: "stream",
     effort: "reasoning_effort"
+  },
+  xai: OPENAI_COMPATIBLE_PARAMS,
+  groq: OPENAI_COMPATIBLE_PARAMS,
+  fal: {},
+  deepinfra: OPENAI_COMPATIBLE_PARAMS,
+  "black-forest-labs": {},
+  together: OPENAI_COMPATIBLE_PARAMS,
+  fireworks: OPENAI_COMPATIBLE_PARAMS,
+  deepseek: OPENAI_COMPATIBLE_PARAMS,
+  moonshotai: OPENAI_COMPATIBLE_PARAMS,
+  perplexity: OPENAI_COMPATIBLE_PARAMS,
+  alibaba: OPENAI_COMPATIBLE_PARAMS,
+  cerebras: OPENAI_COMPATIBLE_PARAMS,
+  replicate: {},
+  prodia: {},
+  luma: {},
+  bytedance: {},
+  kling: {},
+  elevenlabs: {},
+  assemblyai: {},
+  deepgram: {},
+  gladia: {},
+  lmnt: {},
+  hume: {},
+  revai: {},
+  baseten: OPENAI_COMPATIBLE_PARAMS,
+  huggingface: OPENAI_COMPATIBLE_PARAMS
+};
+var OPENAI_COMPATIBLE_PARAM_SPECS = {
+  temperature: {
+    type: "number",
+    min: 0,
+    max: 2,
+    default: 0.7,
+    description: "Controls randomness"
+  },
+  max_tokens: {
+    type: "number",
+    min: 1,
+    default: 4096,
+    description: "Maximum output tokens"
+  },
+  top_p: {
+    type: "number",
+    min: 0,
+    max: 1,
+    default: 1,
+    description: "Nucleus sampling"
+  },
+  top_k: {
+    type: "number",
+    min: 0,
+    default: 40,
+    description: "Top-K sampling"
+  },
+  frequency_penalty: {
+    type: "number",
+    min: -2,
+    max: 2,
+    default: 0,
+    description: "Penalize frequent tokens"
+  },
+  presence_penalty: {
+    type: "number",
+    min: -2,
+    max: 2,
+    default: 0,
+    description: "Penalize repeated topics"
+  },
+  stop: { type: "string", description: "Stop sequences" },
+  n: { type: "number", min: 1, default: 1, description: "Completions count" },
+  seed: { type: "number", description: "Random seed" },
+  stream: { type: "boolean", default: false, description: "Stream response" },
+  reasoning_effort: {
+    type: "string",
+    values: ["none", "minimal", "low", "medium", "high", "xhigh"],
+    default: "medium",
+    description: "Reasoning effort"
   }
 };
+var GOOGLE_COMPATIBLE_PARAM_SPECS = {
+  temperature: {
+    type: "number",
+    min: 0,
+    max: 2,
+    default: 0.7,
+    description: "Controls randomness"
+  },
+  maxOutputTokens: {
+    type: "number",
+    min: 1,
+    default: 4096,
+    description: "Maximum output tokens"
+  },
+  topP: {
+    type: "number",
+    min: 0,
+    max: 1,
+    default: 1,
+    description: "Nucleus sampling"
+  },
+  topK: {
+    type: "number",
+    min: 0,
+    default: 40,
+    description: "Top-K sampling"
+  },
+  frequencyPenalty: {
+    type: "number",
+    min: -2,
+    max: 2,
+    default: 0,
+    description: "Penalize frequent tokens"
+  },
+  presencePenalty: {
+    type: "number",
+    min: -2,
+    max: 2,
+    default: 0,
+    description: "Penalize repeated topics"
+  },
+  stopSequences: { type: "string", description: "Stop sequences" },
+  candidateCount: {
+    type: "number",
+    min: 1,
+    default: 1,
+    description: "Candidate count"
+  },
+  stream: { type: "boolean", default: false, description: "Stream response" },
+  seed: { type: "number", description: "Random seed" },
+  responseMimeType: { type: "string", description: "Response MIME type" },
+  responseSchema: { type: "string", description: "Response schema" }
+};
 var PARAM_SPECS = {
   openai: {
     temperature: {
@@ -280,6 +510,7 @@ var PARAM_SPECS = {
       description: "Reasoning effort"
     }
   },
+  azure: OPENAI_COMPATIBLE_PARAM_SPECS,
   anthropic: {
     temperature: {
       type: "number",
@@ -381,6 +612,7 @@ var PARAM_SPECS = {
     responseMimeType: { type: "string", description: "Response MIME type" },
     responseSchema: { type: "string", description: "Response schema" }
   },
+  "google-vertex": GOOGLE_COMPATIBLE_PARAM_SPECS,
   mistral: {
     temperature: {
       type: "number",
@@ -626,7 +858,33 @@ var PARAM_SPECS = {
       default: "medium",
       description: "Reasoning effort"
     }
-  }
+  },
+  xai: OPENAI_COMPATIBLE_PARAM_SPECS,
+  groq: OPENAI_COMPATIBLE_PARAM_SPECS,
+  fal: {},
+  deepinfra: OPENAI_COMPATIBLE_PARAM_SPECS,
+  "black-forest-labs": {},
+  together: OPENAI_COMPATIBLE_PARAM_SPECS,
+  fireworks: OPENAI_COMPATIBLE_PARAM_SPECS,
+  deepseek: OPENAI_COMPATIBLE_PARAM_SPECS,
+  moonshotai: OPENAI_COMPATIBLE_PARAM_SPECS,
+  perplexity: OPENAI_COMPATIBLE_PARAM_SPECS,
+  alibaba: OPENAI_COMPATIBLE_PARAM_SPECS,
+  cerebras: OPENAI_COMPATIBLE_PARAM_SPECS,
+  replicate: {},
+  prodia: {},
+  luma: {},
+  bytedance: {},
+  kling: {},
+  elevenlabs: {},
+  assemblyai: {},
+  deepgram: {},
+  gladia: {},
+  lmnt: {},
+  hume: {},
+  revai: {},
+  baseten: OPENAI_COMPATIBLE_PARAM_SPECS,
+  huggingface: OPENAI_COMPATIBLE_PARAM_SPECS
 };
 function isReasoningModel(model) {
   const name = model.includes("/") ? model.split("/").pop() : model;
@@ -683,28 +941,84 @@ function bedrockSupportsCaching(model) {
 var CACHE_VALUES = {
   openai: void 0,
   // OpenAI auto-caches; no explicit param
+  azure: void 0,
   anthropic: "ephemeral",
   google: void 0,
   // Google uses explicit caching API, not a param
+  "google-vertex": void 0,
   mistral: void 0,
   cohere: void 0,
   bedrock: "ephemeral",
   // Supported for Claude models on Bedrock
   openrouter: void 0,
   // Depends on underlying provider
-  vercel: void 0
+  vercel: void 0,
   // Depends on underlying provider
+  xai: void 0,
+  groq: void 0,
+  fal: void 0,
+  deepinfra: void 0,
+  "black-forest-labs": void 0,
+  together: void 0,
+  fireworks: void 0,
+  deepseek: void 0,
+  moonshotai: void 0,
+  perplexity: void 0,
+  alibaba: void 0,
+  cerebras: void 0,
+  replicate: void 0,
+  prodia: void 0,
+  luma: void 0,
+  bytedance: void 0,
+  kling: void 0,
+  elevenlabs: void 0,
+  assemblyai: void 0,
+  deepgram: void 0,
+  gladia: void 0,
+  lmnt: void 0,
+  hume: void 0,
+  revai: void 0,
+  baseten: void 0,
+  huggingface: void 0
 };
 var CACHE_TTLS = {
   openai: void 0,
+  azure: void 0,
   anthropic: ["5m", "1h"],
   google: void 0,
+  "google-vertex": void 0,
   mistral: void 0,
   cohere: void 0,
   bedrock: ["5m", "1h"],
   // Claude on Bedrock uses same TTLs as direct Anthropic
   openrouter: void 0,
-  vercel: void 0
+  vercel: void 0,
+  xai: void 0,
+  groq: void 0,
+  fal: void 0,
+  deepinfra: void 0,
+  "black-forest-labs": void 0,
+  together: void 0,
+  fireworks: void 0,
+  deepseek: void 0,
+  moonshotai: void 0,
+  perplexity: void 0,
+  alibaba: void 0,
+  cerebras: void 0,
+  replicate: void 0,
+  prodia: void 0,
+  luma: void 0,
+  bytedance: void 0,
+  kling: void 0,
+  elevenlabs: void 0,
+  assemblyai: void 0,
+  deepgram: void 0,
+  gladia: void 0,
+  lmnt: void 0,
+  hume: void 0,
+  revai: void 0,
+  baseten: void 0,
+  huggingface: void 0
 };
 var DURATION_RE = /^\d+[mh]$/;
 
@@ -727,4 +1041,3 @@ export {
   CACHE_TTLS,
   DURATION_RE
 };
-//# sourceMappingURL=chunk-W4NIQY7M.js.map

package/dist/{chunk-2ARD4TFU.js → chunk-DPVT3FFP.js}

@@ -11,7 +11,7 @@ import {
   isGatewayProvider,
   isReasoningModel,
   providerFromHostAlias
-} from "./chunk-W4NIQY7M.js";
+} from "./chunk-76EFNZCF.js";
 
 // src/normalize.ts
 function normalize(config, options = {}) {
@@ -114,4 +114,3 @@ function normalize(config, options = {}) {
 export {
   normalize
 };
-//# sourceMappingURL=chunk-2ARD4TFU.js.map

package/dist/{chunk-RPXK2A7O.js → chunk-OBLFZFNR.js}

@@ -1,9 +1,9 @@
 import {
   normalize
-} from "./chunk-2ARD4TFU.js";
+} from "./chunk-DPVT3FFP.js";
 import {
   parse
-} from "./chunk-BCOUH7LH.js";
+} from "./chunk-5YTG2NRX.js";
 import {
   PARAM_SPECS,
   PROVIDER_PARAMS,
@@ -12,7 +12,7 @@ import {
   canHostOpenAIModels,
   detectBedrockModelFamily,
   isReasoningModel
-} from "./chunk-W4NIQY7M.js";
+} from "./chunk-76EFNZCF.js";
 
 // src/validate.ts
 function buildReverseParamMap(provider) {
@@ -173,4 +173,3 @@ function validate(connectionString, options = {}) {
 export {
   validate
 };
-//# sourceMappingURL=chunk-RPXK2A7O.js.map