@omiron33/omi-neuron-web 0.1.0

package/dist/chunk-XNR42GCJ.js

@@ -0,0 +1,547 @@
+import { Database } from './chunk-RQCGONPN.js';
+import slugify from 'slugify';
+import { z } from 'zod';
+
+// src/core/types/settings.ts
+var DEFAULT_VISUALIZATION_SETTINGS = {
+  domainColors: {},
+  defaultDomainColor: "#c0c5ff",
+  edgeColor: "#4d4d55",
+  edgeActiveColor: "#c6d4ff",
+  backgroundColor: "#020314",
+  defaultCameraPosition: [4, 8, 20],
+  defaultCameraTarget: [0, 0, 0],
+  minZoomDistance: 4,
+  maxZoomDistance: 42,
+  enableStarfield: true,
+  starfieldCount: 1200,
+  labelDistance: 26,
+  maxVisibleLabels: 50,
+  performanceMode: "auto",
+  nodeCountThreshold: 120,
+  pixelRatioCap: 2,
+  enableAnimations: true,
+  focusTweenDuration: 800,
+  filterTransitionDuration: 650,
+  enableHover: true,
+  enableClick: true,
+  enableDoubleClick: true,
+  enablePan: true,
+  enableZoom: true,
+  enableRotate: true
+};
+var DEFAULT_ANALYSIS_SETTINGS = {
+  embeddingModel: "text-embedding-3-small",
+  embeddingDimensions: 1536,
+  embeddingBatchSize: 20,
+  embeddingCacheTTL: 86400,
+  clusteringAlgorithm: "kmeans",
+  defaultClusterCount: 8,
+  minClusterSize: 3,
+  clusterSimilarityThreshold: 0.75,
+  relationshipInferenceModel: "gpt-4o-mini",
+  relationshipMinConfidence: 0.7,
+  relationshipMaxPerNode: 10,
+  openaiRateLimit: 60,
+  maxConcurrentAnalysis: 5
+};
+var slugTransform = (label) => slugify(label, { lower: true, strict: true, trim: true }).slice(0, 255);
+var nodeTierSchema = z.enum(["primary", "secondary", "tertiary", "insight"]);
+var nodeCreateSchema = z.object({
+  slug: z.string().min(1).max(255).optional(),
+  label: z.string().min(1).max(500),
+  nodeType: z.string().min(1).max(100).optional(),
+  domain: z.string().min(1).max(100).optional(),
+  summary: z.string().max(1e3).optional(),
+  description: z.string().optional(),
+  content: z.string().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+  tier: nodeTierSchema.optional()
+}).transform((data) => ({
+  ...data,
+  slug: data.slug ?? slugTransform(data.label)
+}));
+var nodeUpdateSchema = z.object({
+  label: z.string().min(1).max(500).optional(),
+  summary: z.string().max(1e3).optional(),
+  description: z.string().optional(),
+  content: z.string().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+  domain: z.string().min(1).max(100).optional(),
+  tier: nodeTierSchema.optional(),
+  positionOverride: z.tuple([z.number(), z.number(), z.number()]).nullable().optional()
+});
+var nodeBatchCreateSchema = z.object({
+  nodes: z.array(nodeCreateSchema),
+  options: z.object({
+    skipDuplicates: z.boolean().optional(),
+    updateOnConflict: z.boolean().optional(),
+    autoAnalyze: z.boolean().optional(),
+    analysisDepth: z.enum(["embeddings", "cluster", "full"]).optional()
+  }).optional()
+});
+var nodeFilterSchema = z.object({
+  page: z.coerce.number().int().min(1).optional(),
+  limit: z.coerce.number().int().min(1).max(1e3).optional(),
+  nodeType: z.union([z.string(), z.array(z.string())]).optional(),
+  domain: z.union([z.string(), z.array(z.string())]).optional(),
+  clusterId: z.string().uuid().optional(),
+  analysisStatus: z.string().optional(),
+  search: z.string().optional(),
+  sortBy: z.enum(["createdAt", "updatedAt", "label", "connectionCount"]).optional(),
+  sortOrder: z.enum(["asc", "desc"]).optional(),
+  includeEmbeddings: z.coerce.boolean().optional(),
+  includeStats: z.coerce.boolean().optional()
+});
+var edgeEvidenceSchema = z.object({
+  type: z.enum(["text", "url", "citation", "ai_inference"]),
+  content: z.string().min(1),
+  confidence: z.number().min(0).max(1).optional(),
+  sourceId: z.string().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional()
+});
+var edgeCreateSchema = z.object({
+  fromNodeId: z.string().uuid(),
+  toNodeId: z.string().uuid(),
+  relationshipType: z.string().optional(),
+  strength: z.number().min(0).max(1).optional(),
+  confidence: z.number().min(0).max(1).optional(),
+  evidence: z.array(edgeEvidenceSchema).optional(),
+  label: z.string().max(255).optional(),
+  description: z.string().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+  bidirectional: z.boolean().optional()
+});
+var edgeUpdateSchema = z.object({
+  strength: z.number().min(0).max(1).optional(),
+  confidence: z.number().min(0).max(1).optional(),
+  relationshipType: z.string().optional(),
+  label: z.string().max(255).optional(),
+  description: z.string().optional(),
+  evidence: z.array(edgeEvidenceSchema).optional(),
+  metadata: z.record(z.string(), z.unknown()).optional()
+});
+var edgeFilterSchema = z.object({
+  page: z.coerce.number().int().min(1).optional(),
+  limit: z.coerce.number().int().min(1).max(1e3).optional(),
+  fromNodeId: z.string().uuid().optional(),
+  toNodeId: z.string().uuid().optional(),
+  nodeId: z.string().uuid().optional(),
+  relationshipType: z.union([z.string(), z.array(z.string())]).optional(),
+  source: z.enum(["manual", "ai_inferred", "imported"]).optional(),
+  minStrength: z.coerce.number().min(0).max(1).optional(),
+  minConfidence: z.coerce.number().min(0).max(1).optional()
+});
+var analysisOptionsSchema = z.object({
+  nodeIds: z.array(z.string().uuid()).optional(),
+  forceRecompute: z.boolean().optional(),
+  skipEmbeddings: z.boolean().optional(),
+  embeddingModel: z.string().optional(),
+  skipClustering: z.boolean().optional(),
+  clusterCount: z.coerce.number().int().min(1).optional(),
+  clusteringAlgorithm: z.enum(["kmeans", "dbscan", "hierarchical"]).optional(),
+  skipRelationships: z.boolean().optional(),
+  relationshipThreshold: z.coerce.number().min(0).max(1).optional(),
+  maxRelationshipsPerNode: z.coerce.number().int().min(1).optional()
+});
+var analysisRequestSchema = z.object({
+  action: z.enum(["embeddings", "cluster", "infer_relationships", "full"]),
+  options: analysisOptionsSchema.optional()
+});
+var colorSchema = z.string().min(1);
+var nodeTypeConfigSchema = z.object({
+  type: z.string().min(1),
+  label: z.string().min(1),
+  description: z.string().optional(),
+  defaultDomain: z.string().min(1),
+  icon: z.string().optional(),
+  color: colorSchema.optional(),
+  analysisPrompt: z.string().optional()
+});
+var domainConfigSchema = z.object({
+  key: z.string().min(1),
+  label: z.string().min(1),
+  color: colorSchema,
+  description: z.string().optional()
+});
+var relationshipTypeConfigSchema = z.object({
+  type: z.string().min(1),
+  label: z.string().min(1),
+  description: z.string().optional(),
+  bidirectional: z.boolean(),
+  color: colorSchema.optional()
+});
+var visualizationSettingsSchema = z.object({
+  domainColors: z.record(z.string(), colorSchema),
+  defaultDomainColor: colorSchema,
+  edgeColor: colorSchema,
+  edgeActiveColor: colorSchema,
+  backgroundColor: colorSchema,
+  defaultCameraPosition: z.tuple([z.number(), z.number(), z.number()]),
+  defaultCameraTarget: z.tuple([z.number(), z.number(), z.number()]),
+  minZoomDistance: z.number(),
+  maxZoomDistance: z.number(),
+  enableStarfield: z.boolean(),
+  starfieldCount: z.number().int().min(0),
+  labelDistance: z.number().min(0),
+  maxVisibleLabels: z.number().int().min(0),
+  performanceMode: z.enum(["auto", "normal", "degraded", "fallback"]),
+  nodeCountThreshold: z.number().int().min(0),
+  pixelRatioCap: z.number().min(0.5),
+  enableAnimations: z.boolean(),
+  focusTweenDuration: z.number().int().min(0),
+  filterTransitionDuration: z.number().int().min(0),
+  enableHover: z.boolean(),
+  enableClick: z.boolean(),
+  enableDoubleClick: z.boolean(),
+  enablePan: z.boolean(),
+  enableZoom: z.boolean(),
+  enableRotate: z.boolean()
+});
+var analysisSettingsSchema = z.object({
+  embeddingModel: z.enum(["text-embedding-ada-002", "text-embedding-3-small", "text-embedding-3-large"]),
+  embeddingDimensions: z.number().int().min(1),
+  embeddingBatchSize: z.number().int().min(1),
+  embeddingCacheTTL: z.number().int().min(0),
+  clusteringAlgorithm: z.enum(["kmeans", "dbscan", "hierarchical"]),
+  defaultClusterCount: z.number().int().min(1),
+  minClusterSize: z.number().int().min(1),
+  clusterSimilarityThreshold: z.number().min(0).max(1),
+  relationshipInferenceModel: z.string().min(1),
+  relationshipMinConfidence: z.number().min(0).max(1),
+  relationshipMaxPerNode: z.number().int().min(1),
+  openaiRateLimit: z.number().int().min(1),
+  maxConcurrentAnalysis: z.number().int().min(1)
+});
+var instanceSettingsSchema = z.object({
+  name: z.string().min(1),
+  version: z.string().min(1),
+  repoName: z.string().min(1)
+});
+var databaseSettingsSchema = z.object({
+  mode: z.enum(["docker", "external"]),
+  port: z.number().int().min(1).max(65535),
+  containerName: z.string().optional(),
+  image: z.string().optional(),
+  user: z.string().optional(),
+  password: z.string().optional(),
+  database: z.string().optional(),
+  url: z.string().optional(),
+  pool: z.object({
+    min: z.number().int().min(0),
+    max: z.number().int().min(1),
+    idleTimeoutMs: z.number().int().min(0),
+    connectionTimeoutMs: z.number().int().min(0)
+  }).optional(),
+  resources: z.object({
+    memoryLimit: z.string().min(1),
+    cpuLimit: z.string().optional()
+  }).optional()
+});
+var apiSettingsSchema = z.object({
+  basePath: z.string().min(1),
+  enableCors: z.boolean(),
+  rateLimit: z.object({
+    windowMs: z.number().int().min(1),
+    max: z.number().int().min(1)
+  }).optional()
+});
+var loggingSettingsSchema = z.object({
+  level: z.enum(["debug", "info", "warn", "error"]),
+  prettyPrint: z.boolean()
+});
+var neuronSettingsSchema = z.object({
+  instance: instanceSettingsSchema,
+  visualization: visualizationSettingsSchema,
+  analysis: analysisSettingsSchema,
+  nodeTypes: z.array(nodeTypeConfigSchema),
+  domains: z.array(domainConfigSchema),
+  relationshipTypes: z.array(relationshipTypeConfigSchema)
+});
+var neuronSettingsUpdateSchema = z.object({
+  visualization: visualizationSettingsSchema.partial().optional(),
+  analysis: analysisSettingsSchema.partial().optional(),
+  nodeTypes: z.array(nodeTypeConfigSchema).optional(),
+  domains: z.array(domainConfigSchema).optional(),
+  relationshipTypes: z.array(relationshipTypeConfigSchema).optional()
+});
+var neuronConfigSchema = neuronSettingsSchema.extend({
+  openai: z.object({
+    apiKey: z.string().min(1),
+    organization: z.string().optional(),
+    requestsPerMinute: z.number().int().min(1).optional(),
+    maxRetries: z.number().int().min(0).optional()
+  }),
+  database: databaseSettingsSchema,
+  api: apiSettingsSchema,
+  logging: loggingSettingsSchema
+});
+var paginationSchema = z.object({
+  page: z.coerce.number().int().min(1).optional(),
+  limit: z.coerce.number().int().min(1).max(1e3).optional()
+});
+var listNodesParamsSchema = paginationSchema.extend({
+  nodeType: z.union([z.string(), z.array(z.string())]).optional(),
+  domain: z.union([z.string(), z.array(z.string())]).optional(),
+  clusterId: z.string().uuid().optional(),
+  analysisStatus: z.string().optional(),
+  search: z.string().optional(),
+  sortBy: z.enum(["createdAt", "updatedAt", "label", "connectionCount"]).optional(),
+  sortOrder: z.enum(["asc", "desc"]).optional(),
+  includeEmbeddings: z.coerce.boolean().optional(),
+  includeStats: z.coerce.boolean().optional()
+});
+var listEdgesParamsSchema = paginationSchema.extend({
+  fromNodeId: z.string().uuid().optional(),
+  toNodeId: z.string().uuid().optional(),
+  nodeId: z.string().uuid().optional(),
+  relationshipType: z.union([z.string(), z.array(z.string())]).optional(),
+  source: z.enum(["manual", "ai_inferred", "imported"]).optional(),
+  minStrength: z.coerce.number().min(0).max(1).optional(),
+  minConfidence: z.coerce.number().min(0).max(1).optional()
+});
+var getGraphParamsSchema = z.object({
+  nodeTypes: z.union([z.string(), z.array(z.string())]).optional(),
+  domains: z.union([z.string(), z.array(z.string())]).optional(),
+  clusterIds: z.union([z.string(), z.array(z.string())]).optional(),
+  nodeIds: z.union([z.string(), z.array(z.string())]).optional(),
+  depth: z.coerce.number().int().min(1).optional(),
+  minEdgeStrength: z.coerce.number().min(0).max(1).optional(),
+  relationshipTypes: z.union([z.string(), z.array(z.string())]).optional(),
+  maxNodes: z.coerce.number().int().min(1).optional(),
+  includeOrphanNodes: z.coerce.boolean().optional()
+});
+var expandGraphRequestSchema = z.object({
+  fromNodeIds: z.array(z.string().uuid()),
+  depth: z.coerce.number().int().min(1),
+  direction: z.enum(["outbound", "inbound", "both"]),
+  maxNodes: z.coerce.number().int().min(1).optional()
+});
+var findPathRequestSchema = z.object({
+  fromNodeId: z.string().uuid(),
+  toNodeId: z.string().uuid(),
+  maxDepth: z.coerce.number().int().min(1).optional(),
+  algorithm: z.enum(["shortest", "all"]).optional()
+});
+var semanticSearchRequestSchema = z.object({
+  query: z.string().min(1),
+  nodeTypes: z.array(z.string()).optional(),
+  domains: z.array(z.string()).optional(),
+  limit: z.coerce.number().int().min(1).optional()
+});
+var findSimilarRequestSchema = z.object({
+  nodeId: z.string().uuid(),
+  limit: z.coerce.number().int().min(1).optional(),
+  excludeConnected: z.coerce.boolean().optional()
+});
+
+// src/core/analysis/scoring-engine.ts
+var DEFAULT_CONFIG = {
+  similarityWeight: 0.6,
+  connectionWeight: 0.2,
+  recencyWeight: 0.1,
+  domainBoost: 0.1
+};
+var ScoringEngine = class {
+  constructor(db, config) {
+    this.db = db;
+    this.config = { ...DEFAULT_CONFIG, ...config ?? {} };
+  }
+  config;
+  cosineSimilarity(a, b) {
+    let dot = 0;
+    let magA = 0;
+    let magB = 0;
+    for (let i = 0; i < a.length; i += 1) {
+      dot += a[i] * b[i];
+      magA += a[i] * a[i];
+      magB += b[i] * b[i];
+    }
+    if (magA === 0 || magB === 0) return 0;
+    return dot / (Math.sqrt(magA) * Math.sqrt(magB));
+  }
+  async semanticSimilarity(nodeA, nodeB) {
+    const rows = await this.db.query(
+      "SELECT 1 - (a.embedding <=> b.embedding) as similarity FROM nodes a JOIN nodes b ON b.id = $2 WHERE a.id = $1",
+      [nodeA, nodeB]
+    );
+    return rows[0]?.similarity ?? 0;
+  }
+  async scoreForQuery(queryEmbedding, nodeIds) {
+    const filterClause = nodeIds?.length ? "AND id = ANY($2)" : "";
+    const values = nodeIds?.length ? [queryEmbedding, nodeIds] : [queryEmbedding];
+    const nodes = await this.db.query(
+      `SELECT *, 1 - (embedding <=> $1) as similarity FROM nodes WHERE embedding IS NOT NULL ${filterClause} ORDER BY embedding <=> $1`,
+      values
+    );
+    return nodes.map((node) => this.applyScoring(node, node.similarity ?? 0));
+  }
+  async findSimilar(nodeId, limit = 10, excludeConnected = false) {
+    const base = excludeConnected ? `SELECT id FROM nodes WHERE id NOT IN (SELECT to_node_id FROM edges WHERE from_node_id = $1)` : `SELECT id FROM nodes WHERE id != $1`;
+    const nodes = await this.db.query(
+      `SELECT n.*, 1 - (n.embedding <=> (SELECT embedding FROM nodes WHERE id = $1)) as similarity
+       FROM nodes n
+       WHERE n.embedding IS NOT NULL AND n.id IN (${base})
+       ORDER BY n.embedding <=> (SELECT embedding FROM nodes WHERE id = $1)
+       LIMIT $2`,
+      [nodeId, limit]
+    );
+    return nodes.map((node) => this.applyScoring(node, node.similarity ?? 0));
+  }
+  async calculateNodeImportance(nodeId) {
+    const row = await this.db.queryOne(
+      `WITH edge_weights AS (
+        SELECT to_node_id, SUM(strength) as total_inbound
+        FROM edges
+        GROUP BY to_node_id
+      )
+      SELECT COALESCE(ew.total_inbound, 0) + (n.connection_count * 0.1) as importance
+      FROM nodes n
+      LEFT JOIN edge_weights ew ON n.id = ew.to_node_id
+      WHERE n.id = $1`,
+      [nodeId]
+    );
+    return row?.importance ?? 0;
+  }
+  async rankAllNodes() {
+    const rows = await this.db.query(
+      `WITH edge_weights AS (
+        SELECT to_node_id, SUM(strength) as total_inbound
+        FROM edges
+        GROUP BY to_node_id
+      )
+      SELECT n.id, COALESCE(ew.total_inbound, 0) + (n.connection_count * 0.1) as importance
+      FROM nodes n
+      LEFT JOIN edge_weights ew ON n.id = ew.to_node_id
+      ORDER BY importance DESC`
+    );
+    return rows.map((row) => ({ nodeId: row.id, importance: row.importance }));
+  }
+  async scoreRelevance(sourceNodeId, candidateNodeIds, context) {
+    const nodes = await this.db.query(
+      `SELECT *, 1 - (embedding <=> (SELECT embedding FROM nodes WHERE id = $1)) as similarity
+       FROM nodes
+       WHERE embedding IS NOT NULL AND id = ANY($2)
+       ORDER BY embedding <=> (SELECT embedding FROM nodes WHERE id = $1)`,
+      [sourceNodeId, candidateNodeIds]
+    );
+    return nodes.map((node) => {
+      const base = this.applyScoring(node, node.similarity ?? 0);
+      if (context) {
+        base.score += this.config.domainBoost * 0.1;
+      }
+      return base;
+    });
+  }
+  applyScoring(node, similarity) {
+    const connections = node.connectionCount ?? 0;
+    const recency = node.updatedAt ? Math.max(0, 1 - (Date.now() - new Date(node.updatedAt).getTime()) / (1e3 * 60 * 60 * 24 * 30)) : 0;
+    const domainMatch = 0;
+    const score = similarity * this.config.similarityWeight + connections * this.config.connectionWeight + recency * this.config.recencyWeight + domainMatch * this.config.domainBoost;
+    return {
+      node,
+      score,
+      breakdown: {
+        similarity,
+        connections,
+        recency,
+        domainMatch
+      }
+    };
+  }
+};
+
+// src/storage/factory.ts
+var singleton = null;
+function createDatabase(config) {
+  const dbConfig = {
+    connectionString: config.database.url,
+    host: config.database.mode === "docker" ? "localhost" : void 0,
+    port: config.database.port,
+    user: config.database.user,
+    password: config.database.password,
+    database: config.database.database,
+    pool: config.database.pool
+  };
+  return new Database(dbConfig);
+}
+function createDatabaseFromEnv() {
+  const dbConfig = {
+    connectionString: process.env.DATABASE_URL,
+    host: process.env.DB_HOST,
+    port: process.env.DB_PORT ? Number(process.env.DB_PORT) : void 0,
+    user: process.env.DB_USER,
+    password: process.env.DB_PASSWORD,
+    database: process.env.DB_NAME
+  };
+  return new Database(dbConfig);
+}
+function getDatabase(config) {
+  if (!singleton) {
+    singleton = new Database(config ?? {});
+  }
+  return singleton;
+}
+function resetDatabaseSingleton() {
+  singleton = null;
+}
+
+// src/storage/query-helpers.ts
+var buildWhereClause = (where, startIndex = 1) => {
+  if (!where || Object.keys(where).length === 0) {
+    return { clause: "", values: [], nextIndex: startIndex };
+  }
+  const keys = Object.keys(where);
+  const values = [];
+  const conditions = keys.map((key, idx) => {
+    values.push(where[key]);
+    return `${key} = $${startIndex + idx}`;
+  });
+  return {
+    clause: `WHERE ${conditions.join(" AND ")}`,
+    values,
+    nextIndex: startIndex + keys.length
+  };
+};
+var buildInsert = (table, data) => {
+  const keys = Object.keys(data);
+  const values = Object.values(data);
+  const columns = keys.map((key) => `"${key}"`).join(", ");
+  const placeholders = keys.map((_, idx) => `$${idx + 1}`).join(", ");
+  return {
+    sql: `INSERT INTO ${table} (${columns}) VALUES (${placeholders}) RETURNING *`,
+    values
+  };
+};
+var buildUpdate = (table, data, where) => {
+  const keys = Object.keys(data);
+  const values = Object.values(data);
+  const setClause = keys.map((key, idx) => `"${key}" = $${idx + 1}`).join(", ");
+  const whereResult = buildWhereClause(where, keys.length + 1);
+  return {
+    sql: `UPDATE ${table} SET ${setClause} ${whereResult.clause} RETURNING *`,
+    values: [...values, ...whereResult.values]
+  };
+};
+var buildSelect = (table, columns, where, options) => {
+  const columnList = columns === "*" ? "*" : columns.map((col) => `"${col}"`).join(", ");
+  const whereResult = buildWhereClause(where);
+  const orderClause = options?.orderBy ? `ORDER BY ${options.orderBy} ${options.orderDirection ?? "asc"}` : "";
+  const limitClause = options?.limit ? `LIMIT ${options.limit}` : "";
+  const offsetClause = options?.offset ? `OFFSET ${options.offset}` : "";
+  return {
+    sql: `SELECT ${columnList} FROM ${table} ${whereResult.clause} ${orderClause} ${limitClause} ${offsetClause}`.trim(),
+    values: whereResult.values
+  };
+};
+var buildDelete = (table, where) => {
+  const whereResult = buildWhereClause(where);
+  return {
+    sql: `DELETE FROM ${table} ${whereResult.clause}`,
+    values: whereResult.values
+  };
+};
+
+export { DEFAULT_ANALYSIS_SETTINGS, DEFAULT_VISUALIZATION_SETTINGS, ScoringEngine, analysisOptionsSchema, analysisRequestSchema, analysisSettingsSchema, buildDelete, buildInsert, buildSelect, buildUpdate, buildWhereClause, createDatabase, createDatabaseFromEnv, databaseSettingsSchema, domainConfigSchema, edgeCreateSchema, edgeEvidenceSchema, edgeFilterSchema, edgeUpdateSchema, expandGraphRequestSchema, findPathRequestSchema, findSimilarRequestSchema, getDatabase, getGraphParamsSchema, listEdgesParamsSchema, listNodesParamsSchema, neuronConfigSchema, neuronSettingsSchema, neuronSettingsUpdateSchema, nodeBatchCreateSchema, nodeCreateSchema, nodeFilterSchema, nodeTierSchema, nodeTypeConfigSchema, nodeUpdateSchema, paginationSchema, relationshipTypeConfigSchema, resetDatabaseSingleton, semanticSearchRequestSchema, visualizationSettingsSchema };
+//# sourceMappingURL=chunk-XNR42GCJ.js.map
+//# sourceMappingURL=chunk-XNR42GCJ.js.map