@absolutejs/rag 0.6.2 → 0.7.0

package/dist/index.js

@@ -13695,6 +13695,7 @@ var resolveRAGEmbeddingProvider = (providerLike, fallbackEmbed, defaultModel) =>
   }
   const resolvedDefaultModel = provider.defaultModel ?? defaultModel;
   return {
+    cacheNamespace: provider.cacheNamespace,
     defaultModel: resolvedDefaultModel,
     dimensions: provider.dimensions,
     embed: (input) => provider.embed({
@@ -21172,6 +21173,30 @@ var createRAGCollection = (options) => {
     validateRAGEmbeddingDimensions(vector, getExpectedDimensions(), context);
     return vector;
   };
+  const throwIfAborted = (signal) => {
+    if (signal?.aborted) {
+      throw signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+    }
+  };
+  const mapConcurrentSettled = async (values, concurrency, mapper) => {
+    const results = new Array(values.length);
+    let nextIndex = 0;
+    const workers = Array.from({ length: Math.min(values.length, Math.max(1, Math.floor(concurrency))) }, async () => {
+      while (nextIndex < values.length) {
+        const index = nextIndex++;
+        try {
+          results[index] = {
+            status: "fulfilled",
+            value: await mapper(values[index], index)
+          };
+        } catch (reason) {
+          results[index] = { reason, status: "rejected" };
+        }
+      }
+    });
+    await Promise.all(workers);
+    return results;
+  };
   const searchWithTrace = async (input) => {
     const model = input.model ?? options.defaultModel;
     const topK = input.topK ?? defaultTopK;
@@ -21232,17 +21257,20 @@ var createRAGCollection = (options) => {
         stage: "input"
       }
     ];
-    const queryVector = runVector ? await embed({
-      model,
-      signal: input.signal,
-      text: input.query
-    }, "query") : [];
+    const queryVectors = new Map;
+    if (runVector) {
+      for (const query of searchQueries) {
+        queryVectors.set(query, embed({ model, signal: input.signal, text: query }, "query"));
+      }
+    }
+    const primarySearchQuery = searchQueries[0] ?? input.query;
+    const queryVector = runVector ? await queryVectors.get(primarySearchQuery) : [];
     if (runVector) {
       steps.push({
         label: "Embedded primary query",
         metadata: {
           dimensions: queryVector.length,
-          query: input.query
+          query: primarySearchQuery
         },
         stage: "embed"
       });
@@ -21301,11 +21329,7 @@ var createRAGCollection = (options) => {
     }
     const resultGroups = await Promise.all(searchQueries.map(async (query, queryIndex) => {
       const [vectorResults2, lexicalResults2] = await Promise.all([
-        runVector ? embed({
-          model,
-          signal: input.signal,
-          text: query
-        }, "query").then((nextQueryVector) => options.store.query({
+        runVector ? queryVectors.get(query).then((nextQueryVector) => options.store.query({
           filter: input.filter,
           candidateLimit: input.nativeCandidateLimit ?? nativeQueryProfile?.candidateLimit,
           fillPolicy: input.nativeFillPolicy ?? nativeQueryProfile?.fillPolicy,
@@ -21601,32 +21625,46 @@ var createRAGCollection = (options) => {
     return result.results;
   };
   const ingest = async (input) => {
-    const chunks = (await Promise.all(input.chunks.map(async (chunk) => {
-      const normalizedEmbedding = chunk.embedding ? (validateRAGEmbeddingDimensions(chunk.embedding, getExpectedDimensions(), "chunk"), chunk.embedding) : await embed({
-        model: options.defaultModel,
-        text: chunk.text
-      }, "chunk");
-      const normalizedVariants = chunk.embeddingVariants ? await Promise.all(chunk.embeddingVariants.map(async (variant) => {
-        const embedding = variant.embedding ? (validateRAGEmbeddingDimensions(variant.embedding, getExpectedDimensions(), "chunk"), variant.embedding) : await embed({
+    const batchSize = Math.max(1, Math.floor(input.upsertBatchSize ?? 32));
+    const concurrency = Math.max(1, Math.floor(input.embeddingConcurrency ?? 4));
+    for (let start = 0;start < input.chunks.length; start += batchSize) {
+      throwIfAborted(input.signal);
+      const batch = input.chunks.slice(start, start + batchSize);
+      const settled = await mapConcurrentSettled(batch, concurrency, async (chunk) => {
+        throwIfAborted(input.signal);
+        const normalizedEmbedding = chunk.embedding ? (validateRAGEmbeddingDimensions(chunk.embedding, getExpectedDimensions(), "chunk"), chunk.embedding) : await embed({
           model: options.defaultModel,
-          text: variant.text ?? chunk.text
+          signal: input.signal,
+          text: chunk.text
         }, "chunk");
-        return {
-          ...variant,
-          embedding
-        };
-      })) : undefined;
-      return expandChunkForMultivectorStorage({
-        ...chunk,
-        embedding: normalizedEmbedding,
-        embeddingVariants: normalizedVariants,
-        metadata: {
-          ...chunk.metadata ?? {},
-          [MULTIVECTOR_PRIMARY]: true
-        }
+        const normalizedVariants = chunk.embeddingVariants ? await Promise.all(chunk.embeddingVariants.map(async (variant) => {
+          const embedding = variant.embedding ? (validateRAGEmbeddingDimensions(variant.embedding, getExpectedDimensions(), "chunk"), variant.embedding) : await embed({
+            model: options.defaultModel,
+            signal: input.signal,
+            text: variant.text ?? chunk.text
+          }, "chunk");
+          return {
+            ...variant,
+            embedding
+          };
+        })) : undefined;
+        return expandChunkForMultivectorStorage({
+          ...chunk,
+          embedding: normalizedEmbedding,
+          embeddingVariants: normalizedVariants,
+          metadata: {
+            ...chunk.metadata ?? {},
+            [MULTIVECTOR_PRIMARY]: true
+          }
+        });
       });
-    }))).flat();
-    await options.store.upsert({ chunks });
+      const chunks = settled.filter((result) => result.status === "fulfilled").flatMap((result) => result.value);
+      if (chunks.length > 0)
+        await options.store.upsert({ chunks });
+      const failed = settled.find((result) => result.status === "rejected");
+      if (failed)
+        throw failed.reason;
+    }
   };
   const buildSourceUpsertInput = async (sourceId, input) => {
     const sharedMetadata = input.metadata;
@@ -21704,33 +21742,34 @@ var createRAGCollection = (options) => {
     if (!sourceId) {
       throw new Error("ingestSource requires a non-empty sourceId.");
     }
-    if (input.replace !== false) {
-      await removeSource({
-        chunkCount: input.previousChunkCount,
-        sourceId
-      });
-    }
     const built = await buildSourceUpsertInput(sourceId, input);
     const embedKind = input.embedKind ?? "passage";
-    const chunks = await Promise.all(built.chunks.map(async (chunk, index) => {
+    const chunks = built.chunks.map((chunk, index) => {
       const chunkId = `${sourceId}#${index}`;
-      const embedding = chunk.embedding ?? await embed({
-        kind: embedKind,
-        model: options.defaultModel,
-        text: chunk.text
-      }, "chunk");
       return {
         ...chunk,
         chunkId,
-        embedding,
         metadata: {
           ...chunk.metadata ?? {},
+          embeddingKind: embedKind,
           sourceId
         },
         source: chunk.source ?? sourceId
       };
-    }));
-    await ingest({ chunks });
+    });
+    await ingest({
+      chunks,
+      embeddingConcurrency: input.embeddingConcurrency,
+      signal: input.signal,
+      upsertBatchSize: input.upsertBatchSize
+    });
+    if (input.replace !== false && typeof input.previousChunkCount === "number" && input.previousChunkCount > chunks.length) {
+      await removeSource({
+        chunkIds: Array.from({ length: input.previousChunkCount - chunks.length }, (_unused, index) => `${sourceId}#${chunks.length + index}`),
+        filterDelete: false,
+        sourceId
+      });
+    }
     return {
       chunkCount: chunks.length,
       chunkIds: chunks.map((chunk) => chunk.chunkId),
@@ -31614,51 +31653,159 @@ var ragChat = (config) => {
 var createRAGHTMXConfig = (config) => config;
 var createRAGHTMXWorkflowRenderConfig = (config) => config;
 // src/retrieval/embeddingBudget.ts
-var embeddingCacheKey = async (text, model, kind) => {
-  const payload = `${model ?? "default"}:${kind ?? "passage"}:${text}`;
+var embeddingCacheKey = async (text, model, kind, identity) => {
+  const payload = `${identity ?? "provider-default"}:${model ?? "default"}:${kind ?? "passage"}:${text}`;
   const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(payload));
   return Array.from(new Uint8Array(digest)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
 };
-var QUOTA_PATTERN = /RESOURCE_EXHAUSTED|token limit|quota|insufficient_quota|billing hard limit/i;
+var createRAGEmbeddingError = (input) => {
+  const error = new Error(input.message);
+  error.embeddingErrorKind = input.kind ?? "unknown";
+  if (input.retryAfterMs !== undefined)
+    error.retryAfterMs = input.retryAfterMs;
+  if (input.status !== undefined)
+    error.status = input.status;
+  return error;
+};
+var errorMessage = (error) => error instanceof Error ? error.message : typeof error === "string" ? error : "";
+var classifyEmbeddingError = (error) => {
+  if (error && typeof error === "object" && "embeddingErrorKind" in error) {
+    return error.embeddingErrorKind;
+  }
+  const message = errorMessage(error);
+  if (/insufficient_quota|billing hard limit|monthly|allowance|credit balance/i.test(message)) {
+    return "allowance";
+  }
+  if (/rate.?limit|requests? per minute|tokens? per minute|\bTPM\b|\bRPM\b/i.test(message)) {
+    return "rate_limit";
+  }
+  if (/RESOURCE_EXHAUSTED.*(?:quota|token limit)|(?:quota|token limit).*RESOURCE_EXHAUSTED/i.test(message)) {
+    return "allowance";
+  }
+  if (/invalid|too long|maximum context|dimension|malformed/i.test(message)) {
+    return "input";
+  }
+  if (/timeout|timed out|connection|socket|reset|unavailable|5\d\d/i.test(message)) {
+    return "transient";
+  }
+  return "unknown";
+};
 var isEmbeddingQuotaError = (error) => {
-  const message = error instanceof Error ? error.message : typeof error === "string" ? error : "";
-  return QUOTA_PATTERN.test(message);
+  return classifyEmbeddingError(error) === "allowance";
+};
+var isRetryableEmbeddingError = (error) => {
+  const kind = classifyEmbeddingError(error);
+  return kind === "rate_limit" || kind === "transient" || kind === "unknown";
 };
 var withEmbeddingBudget = (provider, options = {}) => {
   const base = typeof provider === "function" ? { embed: provider } : provider;
-  const { cache, onQuotaExhausted } = options;
+  const { cache, onCacheError, onQuotaExhausted } = options;
   let lastError = null;
   let quotaExhaustedAt = null;
+  let rateLimitedAt = null;
+  let recoveredAt = null;
   let reused = 0;
   let embedded = 0;
+  let attempted = 0;
+  let failed = 0;
+  let inFlight = 0;
+  let cacheFailures = 0;
+  const pending = new Map;
+  const hotCache = new Map;
+  const cacheIdentity = [
+    options.cacheNamespace ?? base.cacheNamespace ?? "provider-default",
+    base.dimensions ?? "dimensions-default"
+  ].join(":");
   return {
     ...base,
     embed: async (input) => {
-      const key = cache ? await embeddingCacheKey(input.text, input.model, input.kind) : null;
+      const resolvedModel = input.model ?? base.defaultModel;
+      const key = cache ? await embeddingCacheKey(input.text, resolvedModel, input.kind, cacheIdentity) : null;
       if (key && cache) {
-        const hit = await cache.get(key);
+        const localHit = hotCache.get(key);
+        if (localHit) {
+          reused += 1;
+          return localHit;
+        }
+        let hit = null;
+        try {
+          hit = await cache.get(key);
+        } catch (error) {
+          cacheFailures += 1;
+          onCacheError?.(error, "get");
+        }
         if (hit && hit.length > 0) {
           reused += 1;
+          hotCache.set(key, hit);
           return hit;
         }
+        const existing = pending.get(key);
+        if (existing) {
+          reused += 1;
+          return existing;
+        }
       }
-      const vector = await base.embed(input).catch((error) => {
-        lastError = error instanceof Error ? error.message : String(error);
-        if (isEmbeddingQuotaError(error)) {
-          const first = quotaExhaustedAt === null;
-          quotaExhaustedAt = new Date;
-          if (first)
-            onQuotaExhausted?.(error);
+      const execute = async () => {
+        await options.beforeEmbed?.({ ...input, model: resolvedModel });
+        attempted += 1;
+        inFlight += 1;
+        try {
+          const vector = await base.embed({ ...input, model: resolvedModel });
+          lastError = null;
+          embedded += 1;
+          if (quotaExhaustedAt || rateLimitedAt)
+            recoveredAt = new Date;
+          if (key && cache) {
+            hotCache.set(key, vector);
+            if (hotCache.size > 1000)
+              hotCache.delete(hotCache.keys().next().value);
+            try {
+              await cache.set(key, vector);
+            } catch (error) {
+              cacheFailures += 1;
+              onCacheError?.(error, "set");
+            }
+          }
+          return vector;
+        } catch (error) {
+          failed += 1;
+          lastError = errorMessage(error) || String(error);
+          const kind = classifyEmbeddingError(error);
+          if (kind === "allowance") {
+            const first = quotaExhaustedAt === null;
+            quotaExhaustedAt = new Date;
+            if (first)
+              onQuotaExhausted?.(error);
+          } else if (kind === "rate_limit") {
+            rateLimitedAt = new Date;
+          }
+          throw error;
+        } finally {
+          inFlight -= 1;
         }
-        throw error;
-      });
-      lastError = null;
-      embedded += 1;
-      if (key && cache)
-        await cache.set(key, vector);
-      return vector;
+      };
+      const operation = execute();
+      if (key)
+        pending.set(key, operation);
+      try {
+        return await operation;
+      } finally {
+        if (key && pending.get(key) === operation)
+          pending.delete(key);
+      }
     },
-    health: () => ({ embedded, lastError, quotaExhaustedAt, reused })
+    health: () => ({
+      attempted,
+      cacheFailures,
+      embedded,
+      failed,
+      inFlight,
+      lastError,
+      quotaExhaustedAt,
+      rateLimitedAt,
+      recoveredAt,
+      reused
+    })
   };
 };
 // src/providers/rerankerProviders.ts
@@ -31883,6 +32030,27 @@ var toErrorMessage = async (response) => {
   const text = await response.text();
   return text || `Request failed with status ${response.status}`;
 };
+var parseRetryAfterMs = (response) => {
+  const value = response.headers.get("retry-after");
+  if (!value)
+    return;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds))
+    return Math.max(0, seconds * 1000);
+  const date = Date.parse(value);
+  return Number.isFinite(date) ? Math.max(0, date - Date.now()) : undefined;
+};
+var embeddingResponseError = async (provider, response) => {
+  const message = `${provider} embeddings API error ${response.status}: ${await toErrorMessage(response)}`;
+  const inferred = classifyEmbeddingError(message);
+  const kind = inferred !== "unknown" ? inferred : response.status === 429 ? "rate_limit" : response.status >= 500 ? "transient" : response.status >= 400 && response.status < 500 ? "input" : "unknown";
+  return createRAGEmbeddingError({
+    kind,
+    message,
+    retryAfterMs: parseRetryAfterMs(response),
+    status: response.status
+  });
+};
 var readOpenAIEmbedding = (payload) => {
   if (!isRecord(payload) || !Array.isArray(payload.data)) {
     throw new Error("OpenAI embeddings response is missing data.");
@@ -31917,6 +32085,7 @@ var geminiEmbeddings = (config) => {
   const baseUrl = config.baseUrl ?? DEFAULT_GEMINI_BASE_URL;
   const fetchImpl = config.fetch ?? fetch;
   return createRAGEmbeddingProvider({
+    cacheNamespace: `gemini:${baseUrl}:${config.defaultModel ?? "model-required"}:${config.dimensions ?? "dimensions-default"}`,
     defaultModel: config.defaultModel,
     dimensions: config.dimensions,
     embed: async ({ model, signal, text }) => {
@@ -31941,7 +32110,7 @@ var geminiEmbeddings = (config) => {
         signal
       });
       if (!response.ok) {
-        throw new Error(`Gemini embeddings API error ${response.status}: ${await toErrorMessage(response)}`);
+        throw await embeddingResponseError("Gemini", response);
       }
       return readGeminiEmbedding(await parseJsonResponse(response));
     }
@@ -31967,6 +32136,7 @@ var ollamaEmbeddings = (config = {}) => {
   const baseUrl = config.baseUrl ?? DEFAULT_OLLAMA_BASE_URL;
   const fetchImpl = config.fetch ?? fetch;
   return createRAGEmbeddingProvider({
+    cacheNamespace: `ollama:${baseUrl}:${config.defaultModel ?? "model-required"}`,
     defaultModel: config.defaultModel,
     embed: async ({ model, signal, text }) => {
       const resolvedModel = model ?? config.defaultModel;
@@ -31985,7 +32155,7 @@ var ollamaEmbeddings = (config = {}) => {
         signal
       });
       if (!response.ok) {
-        throw new Error(`Ollama embeddings API error ${response.status}: ${await toErrorMessage(response)}`);
+        throw await embeddingResponseError("Ollama", response);
       }
       return readOllamaEmbedding(await parseJsonResponse(response));
     }
@@ -31999,6 +32169,7 @@ var openaiEmbeddings = (config) => {
   const baseUrl = config.baseUrl ?? DEFAULT_OPENAI_BASE_URL;
   const fetchImpl = config.fetch ?? fetch;
   return createRAGEmbeddingProvider({
+    cacheNamespace: `openai:${baseUrl}:${config.defaultModel ?? "model-required"}:${config.dimensions ?? "dimensions-default"}`,
     defaultModel: config.defaultModel,
     dimensions: config.dimensions,
     embed: async ({ model, signal, text }) => {
@@ -32024,7 +32195,7 @@ var openaiEmbeddings = (config) => {
         signal
       });
       if (!response.ok) {
-        throw new Error(`OpenAI embeddings API error ${response.status}: ${await toErrorMessage(response)}`);
+        throw await embeddingResponseError("OpenAI", response);
       }
       return readOpenAIEmbedding(await parseJsonResponse(response));
     }
@@ -33420,9 +33591,24 @@ var parseSyncState = (content) => {
     return [];
   }
 };
-var createSyncFingerprint = (document) => createHash("sha1").update(document.source ?? "").update(`
-`).update(document.title ?? "").update(`
-`).update(document.text).digest("hex");
+var canonicalSyncValue = (value) => {
+  if (Array.isArray(value))
+    return value.map(canonicalSyncValue);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).filter(([key, entry]) => !key.startsWith("sync") && entry !== undefined).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, canonicalSyncValue(entry)]));
+  }
+  return value;
+};
+var createSyncFingerprint = (document) => createHash("sha256").update(JSON.stringify(canonicalSyncValue({
+  chunking: document.chunking,
+  corpusKey: document.corpusKey,
+  format: document.format,
+  id: document.id,
+  metadata: document.metadata,
+  source: document.source,
+  text: document.text,
+  title: document.title
+}))).digest("hex");
 var toManagedSyncDocument = (sourceId, document, syncKey) => ({
   ...document,
   metadata: {
@@ -35377,7 +35563,7 @@ var createRAGSyncManager = (options) => {
     await persistState();
   };
   const resolveRetryAttempts = (source) => Math.max(0, source.retryAttempts ?? options.retryAttempts ?? 0);
-  const resolveRetryDelayMs = (source) => Math.max(0, source.retryDelayMs ?? options.retryDelayMs ?? 0);
+  const resolveRetryDelayMs = (source) => Math.max(0, source.retryDelayMs ?? options.retryDelayMs ?? 1000);
   const setSourceState = async (record) => {
     state.set(record.id, record);
     await persistState();
@@ -35441,7 +35627,10 @@ var createRAGSyncManager = (options) => {
         } catch (caught) {
           const message = toSyncError(caught);
           const finishedAt = Date.now();
-          const hasRetriesRemaining = attempt < retryAttempts;
+          const hasRetriesRemaining = attempt < retryAttempts && isRetryableEmbeddingError(caught);
+          const retryAfterMs = caught && typeof caught === "object" && "retryAfterMs" in caught && typeof caught.retryAfterMs === "number" ? caught.retryAfterMs : undefined;
+          const exponentialDelay = retryDelayMs * 2 ** attempt;
+          const nextDelayMs = Math.max(retryAfterMs ?? 0, Math.round(exponentialDelay * (0.8 + Math.random() * 0.4)));
           const consecutiveFailures = (previous?.consecutiveFailures ?? 0) + attempt + 1;
           const failed = toSourceRecord(source, {
             chunkCount: previous?.chunkCount,
@@ -35452,7 +35641,7 @@ var createRAGSyncManager = (options) => {
             lastSuccessfulSyncAt: previous?.lastSuccessfulSyncAt,
             lastSyncedAt: finishedAt,
             lastSyncDurationMs: finishedAt - startedAt,
-            nextRetryAt: hasRetriesRemaining ? finishedAt + retryDelayMs : undefined,
+            nextRetryAt: hasRetriesRemaining ? finishedAt + nextDelayMs : undefined,
             reconciliation: previous?.reconciliation,
             retryAttempts,
             status: "failed"
@@ -35461,7 +35650,7 @@ var createRAGSyncManager = (options) => {
           if (!hasRetriesRemaining) {
             return failed;
           }
-          await wait(retryDelayMs);
+          await wait(nextDelayMs);
         }
       }
       return state.get(source.id) ?? toSourceRecord(source, { status: "failed" });
@@ -36107,7 +36296,11 @@ var corpusTextHash = async (text) => {
 var planRAGCorpus = async (store, owner, desired) => {
   const wanted = new Map;
   for (const doc of desired) {
-    if (!wanted.has(doc.chunkId))
+    const existing = wanted.get(doc.chunkId);
+    if (existing && existing.text !== doc.text) {
+      throw new Error(`Conflicting RAG corpus documents share chunkId "${doc.chunkId}".`);
+    }
+    if (!existing)
       wanted.set(doc.chunkId, doc);
   }
   const stored = new Map((await store.list(owner)).map((record) => [record.chunkId, record.textHash]));
@@ -36139,7 +36332,10 @@ var reconcileRAGCorpus = async (store, owner, desired, apply) => {
   let embedded = 0;
   if (plan.embed.length > 0) {
     const outcome = await apply.embed(plan.embed, owner);
-    const written = typeof outcome === "number" ? plan.embed.slice(0, Math.max(0, Math.min(outcome, plan.embed.length))) : filterToWritten(plan.embed, outcome);
+    if (typeof outcome === "number" && outcome !== plan.embed.length) {
+      throw new Error(`A numeric RAG corpus embed result must equal the full plan length (${plan.embed.length}); received ${outcome}. Return exact chunk ids for partial writes.`);
+    }
+    const written = typeof outcome === "number" ? plan.embed : filterToWritten(plan.embed, outcome);
     embedded = written.length;
     if (written.length > 0) {
       await store.remember(owner, await Promise.all(written.map(async (doc) => ({
@@ -36244,6 +36440,7 @@ export {
   loadRAGDocumentFile,
   loadRAGAnswerGroundingEvaluationHistory,
   loadRAGAnswerGroundingCaseDifficultyHistory,
+  isRetryableEmbeddingError,
   isEmbeddingQuotaError,
   inspectRAGSQLiteStoreMigrations,
   ingestRAGSource,
@@ -36344,6 +36541,7 @@ export {
   createRAGEvaluationSuiteSnapshot,
   createRAGEvaluationSuite,
   createRAGEmbeddingProvider,
+  createRAGEmbeddingError,
   createRAGEmailSyncSource,
   createRAGDirectorySyncSource,
   createRAGCollection,
@@ -36370,6 +36568,7 @@ export {
   compareRAGRetrievalTraceSummaries,
   compareRAGRetrievalStrategies,
   compareRAGRerankers,
+  classifyEmbeddingError,
   buildRAGUpsertInputFromUploads,
   buildRAGUpsertInputFromURLs,
   buildRAGUpsertInputFromDocuments,
@@ -36450,5 +36649,5 @@ export {
   addRAGEvaluationSuiteCase
 };
 
-//# debugId=9A8B228F28FF5ED164756E2164756E21
+//# debugId=45A0B325404F956164756E2164756E21
 //# sourceMappingURL=index.js.map