@opengeni/sdk 0.57.0 → 1.0.0

package/dist/chunk-DUVIYER4.js

@@ -0,0 +1,639 @@
+import {
+  OpenGeniToolsClient
+} from "./chunk-4SMEOV3P.js";
+import {
+  OpenGeniClient
+} from "./chunk-FG3OO5LM.js";
+import {
+  OpenGeniApiError
+} from "./chunk-V6GIY62B.js";
+
+// ../contracts/src/site-session-http.ts
+var SITE_WORKSPACE_PREFIX = "/v1/workspaces/site-host";
+var SiteSessionPathError = class extends Error {
+  code = "site_session_path_unsupported";
+  constructor() {
+    super("Unsupported Site session API path");
+    this.name = "SiteSessionPathError";
+  }
+};
+function siteSessionPath(path, workspaceId, _method = "GET", siteId) {
+  const pathname = path.split("?")[0];
+  const workspace = pathname === SITE_WORKSPACE_PREFIX || pathname.startsWith(`${SITE_WORKSPACE_PREFIX}/`);
+  const context = pathname === "/v1/config/client";
+  if (!workspace && !context || /[%\\#\u0000-\u0020\u007f]/u.test(pathname) || pathname.split("/").some((p) => p === "." || p === "..")) {
+    throw new SiteSessionPathError();
+  }
+  const rewritten = path.replace(
+    "/workspaces/site-host",
+    `/workspaces/${encodeURIComponent(workspaceId)}`
+  );
+  const url = new URL(rewritten, "http://site.invalid");
+  if (url.searchParams.get("originSiteId") === "current" && workspaceId !== "site-host") {
+    url.searchParams.set("originSiteId", siteId ?? "00000000-0000-0000-0000-000000000000");
+    return url.pathname + url.search;
+  }
+  return rewritten;
+}
+function siteRequestHeaders(input) {
+  const headers = new Headers(input);
+  const connectionHeaders = (headers.get("connection") ?? "").split(",").map((value) => value.trim().toLowerCase());
+  for (const name of [...headers.keys()]) {
+    if (connectionHeaders.includes(name) || /^(authorization|proxy-authorization|cookie|cookie2|host|origin|referer|connection|keep-alive|proxy-connection|te|trailer|transfer-encoding|upgrade|content-length|accept-encoding|forwarded|x-api-key)$/i.test(
+      name
+    ) || /^(sec-|x-forwarded-|x-opengeni-(access-key|external-actor|site-|managed-actor))/i.test(name))
+      headers.delete(name);
+  }
+  return headers;
+}
+
+// src/site-http.ts
+var SITE_HTTP = "opengeni.site.http";
+var SITE_WORKSPACE = "site-host";
+function isSiteHttpRequest(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return v.type === SITE_HTTP && typeof v.requestId === "string" && typeof v.path === "string" && typeof v.method === "string" && /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/u.test(v.method) && (v.body === void 0 || typeof v.body === "string") && Array.isArray(v.headers) && v.headers.every(
+    (h) => Array.isArray(h) && h.length === 2 && h.every((x) => typeof x === "string")
+  );
+}
+async function serveSiteHttp(message, port, fetchResponse, signal) {
+  let reader;
+  let wake;
+  let pulling = false;
+  const onMessage = (event) => {
+    if (event.data === "pull") {
+      pulling = true;
+      wake?.();
+    }
+  };
+  const abort = () => {
+    void reader?.cancel(signal.reason).catch(() => {
+    });
+    wake?.();
+  };
+  port.addEventListener("message", onMessage);
+  signal.addEventListener("abort", abort, { once: true });
+  port.start();
+  try {
+    if (signal.aborted) throw signal.reason;
+    const response = await fetchResponse(message, signal);
+    reader = response.body?.getReader();
+    port.postMessage({ status: response.status, headers: [...response.headers], body: !!reader });
+    if (reader)
+      while (!signal.aborted) {
+        if (!pulling)
+          await new Promise((resolve) => {
+            wake = resolve;
+          });
+        wake = void 0;
+        if (signal.aborted) break;
+        pulling = false;
+        const part = await reader.read();
+        if (part.done) {
+          port.postMessage({ done: true });
+          break;
+        }
+        port.postMessage({ chunk: part.value });
+      }
+    if (signal.aborted) throw signal.reason;
+  } catch (error) {
+    port.postMessage({ error: error instanceof Error ? error.message : "Site request failed" });
+  } finally {
+    signal.removeEventListener("abort", abort);
+    port.removeEventListener("message", onMessage);
+    await reader?.cancel().catch(() => {
+    });
+    port.close();
+  }
+}
+async function sitePortFetch(port, input, init) {
+  const request = new Request(input, init);
+  const url = new URL(request.url);
+  const path = `${url.pathname}${url.search}`;
+  siteSessionPath(path, SITE_WORKSPACE, request.method);
+  const channel = new MessageChannel();
+  const requestId = crypto.randomUUID();
+  const body = request.body ? await request.text() : void 0;
+  return await new Promise((resolve, reject) => {
+    let controller;
+    let finished = false;
+    const cleanup = () => {
+      finished = true;
+      request.signal.removeEventListener("abort", abort);
+      channel.port1.close();
+    };
+    const abort = () => {
+      if (finished) return;
+      port.postMessage({ type: "opengeni.site.cancel", version: 2, requestId });
+      const error = request.signal.reason ?? new DOMException("Cancelled", "AbortError");
+      controller?.error(error);
+      reject(error);
+      cleanup();
+    };
+    channel.port1.onmessage = (event) => {
+      const data = event.data;
+      if (data.error) {
+        const error = new Error(data.error);
+        controller?.error(error);
+        reject(error);
+        cleanup();
+      } else if (data.status) {
+        const stream = data.body ? new ReadableStream({
+          start(c) {
+            controller = c;
+          },
+          pull() {
+            channel.port1.postMessage("pull");
+          },
+          cancel() {
+            controller = void 0;
+            abort();
+          }
+        }) : null;
+        resolve(new Response(stream, { status: data.status, headers: data.headers }));
+        if (!data.body) cleanup();
+      } else if (data.done) {
+        controller?.close();
+        cleanup();
+      } else if (data.chunk) controller?.enqueue(data.chunk);
+    };
+    if (request.signal.aborted) {
+      abort();
+      return;
+    }
+    request.signal.addEventListener("abort", abort, { once: true });
+    port.postMessage(
+      {
+        type: SITE_HTTP,
+        requestId,
+        path,
+        method: request.method,
+        headers: [...request.headers],
+        ...body === void 0 ? {} : { body }
+      },
+      [channel.port2]
+    );
+  });
+}
+
+// src/site-tool-bridge.ts
+function createSiteToolBridge(input) {
+  const allowed = input.requestedTools ? new Set(input.requestedTools.map(identityKey)) : null;
+  let projectedCatalog = null;
+  const loadCatalog = async ({
+    signal,
+    refresh = false
+  }) => {
+    signal.throwIfAborted();
+    if (projectedCatalog && !refresh) return projectedCatalog;
+    const current = await input.workspaceTools.$catalog({
+      signal,
+      ...refresh ? { refresh } : {}
+    });
+    signal.throwIfAborted();
+    if (current.workspaceId !== input.workspaceId)
+      throw new Error("Site catalog workspace mismatch");
+    projectedCatalog = {
+      version: current.version,
+      generation: current.generation,
+      digest: current.digest,
+      createdAt: current.createdAt,
+      entries: current.entries.filter(
+        (entry) => !allowed || allowed.has(identityKey(entry.identity))
+      )
+    };
+    return projectedCatalog;
+  };
+  return {
+    ...input.fetchResponse ? {
+      fetch: async (message, signal) => {
+        const path = siteSessionPath(
+          message.path,
+          input.workspaceId,
+          message.method,
+          input.artifactId
+        );
+        const headers = siteRequestHeaders(message.headers);
+        if (input.artifactId) {
+          headers.set("x-opengeni-site-id", input.artifactId);
+          headers.set("x-opengeni-site-version", input.siteVersionId);
+        }
+        return input.fetchResponse(path, {
+          method: message.method,
+          signal,
+          headers: Object.fromEntries(headers),
+          ...message.body === void 0 ? {} : { body: message.body }
+        });
+      }
+    } : {},
+    catalog: loadCatalog,
+    call: async (request, { signal }) => {
+      if (allowed && !allowed.has(identityKey(request.identity)))
+        throw new Error("This tool is not available to the Site");
+      const call = async (refresh = false) => {
+        const catalog = await loadCatalog({ signal, refresh });
+        if (!catalog.entries.some(
+          (entry) => identityKey(entry.identity) === identityKey(request.identity)
+        ))
+          throw new Error("This requested tool is not enabled in the workspace");
+        return input.callTool({
+          workspaceId: input.workspaceId,
+          signal,
+          request: {
+            ...request.operationId ? { operationId: request.operationId } : {},
+            catalogDigest: catalog.digest,
+            identity: request.identity,
+            arguments: request.arguments,
+            ...input.artifactId ? { siteArtifactId: input.artifactId, siteVersionId: input.siteVersionId } : {}
+          }
+        });
+      };
+      try {
+        return await call();
+      } catch (error) {
+        if (!(input.isCatalogStale ?? isSiteCatalogStaleError)(error)) throw error;
+        projectedCatalog = null;
+        return await call(true);
+      }
+    }
+  };
+}
+function isSiteCatalogStaleError(error) {
+  return error instanceof OpenGeniApiError && error.status === 409 && error.details?.code === "catalog_stale";
+}
+function identityKey(identity) {
+  return `${identity.serverId}\0${identity.toolName}`;
+}
+
+// src/site.ts
+var OPENGENI_SITE_BRIDGE_VERSION = 2;
+var OPENGENI_SITE_BRIDGE_CONNECT = "opengeni.site.connect";
+var OPENGENI_SITE_BRIDGE_READY = "opengeni.site.ready";
+var OPENGENI_SITE_BRIDGE_REQUEST = "opengeni.site.request";
+var OPENGENI_SITE_BRIDGE_RESPONSE = "opengeni.site.response";
+var OPENGENI_SITE_BRIDGE_CANCEL = "opengeni.site.cancel";
+var OPENGENI_SITE_BRIDGE_BOOTSTRAP_GLOBAL = "__opengeniSiteBridgeBootstrapV2";
+var OPENGENI_SITE_LOCAL_CODEMODE_PATH = "/__opengeni/site-tools";
+var OpenGeniSiteBridgeError = class extends Error {
+  constructor(code, message, retryable = false, outcomeUnknown = false) {
+    super(message);
+    this.code = code;
+    this.retryable = retryable;
+    this.outcomeUnknown = outcomeUnknown;
+    this.name = "OpenGeniSiteBridgeError";
+  }
+};
+function createOpenGeniSiteClient(options = {}) {
+  const transport = shouldUseLocalCodemode(options) ? new OpenGeniSiteLocalCodemodeTransport(options) : new OpenGeniSiteBridgeTransport(options);
+  return {
+    client: new OpenGeniClient({
+      baseUrl: "https://site.opengeni.invalid",
+      fetch: (input, init) => transport.fetch(input, init)
+    }),
+    workspaceId: SITE_WORKSPACE,
+    tools: new OpenGeniToolsClient(transport).forWorkspace("site-host"),
+    close: () => transport.close()
+  };
+}
+var OpenGeniSiteLocalCodemodeTransport = class {
+  fetchImpl;
+  basePath;
+  constructor(options) {
+    this.fetchImpl = options.fetch ?? globalThis.fetch.bind(globalThis);
+    const configured = options.localCodemodePath;
+    this.basePath = (typeof configured === "string" ? configured : OPENGENI_SITE_LOCAL_CODEMODE_PATH).replace(/\/+$/u, "");
+  }
+  close() {
+  }
+  async fetch(input, init) {
+    const request = new Request(input, init);
+    const url = new URL(request.url);
+    const path = `${url.pathname}${url.search}`;
+    siteSessionPath(path, SITE_WORKSPACE, request.method);
+    return this.fetchImpl(`${this.basePath}/sdk${path}`, {
+      method: request.method,
+      headers: request.headers,
+      signal: request.signal,
+      ...request.body ? { body: await request.text() } : {}
+    });
+  }
+  async requestJson(method, path, body, _query, options = {}) {
+    const suffix = localCodemodeSuffix(method, path);
+    const response = await this.fetchImpl(`${this.basePath}${suffix}`, {
+      method,
+      ...options.signal ? { signal: options.signal } : {},
+      ...body === void 0 ? {} : {
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(body)
+      }
+    });
+    const value = await response.json();
+    if (response.ok) return value;
+    const envelope = isRecord(value) && isRecord(value.error) ? value.error : {};
+    throw new OpenGeniSiteBridgeError(
+      typeof envelope.code === "string" ? envelope.code : "local_codemode_error",
+      typeof envelope.message === "string" ? envelope.message : `Local Site tool request failed with HTTP ${response.status}`,
+      envelope.retryable === true,
+      envelope.outcomeUnknown === true
+    );
+  }
+};
+function shouldUseLocalCodemode(options) {
+  if (options.localCodemodePath === false || options.bootstrapPort) return false;
+  if (typeof options.localCodemodePath === "string") return true;
+  const siteWindow = options.siteWindow ?? globalThis.window;
+  return Boolean(siteWindow && siteWindow.parent === siteWindow);
+}
+function localCodemodeSuffix(method, path) {
+  if (method === "GET" && path.endsWith("/tools/catalog")) return "/catalog";
+  if (method === "GET" && path.endsWith("/tools/declarations")) return "/declarations";
+  if (method === "POST" && path.endsWith("/tools/calls")) return "/calls";
+  throw new OpenGeniSiteBridgeError("unsupported_request", "Unsupported Site tool request");
+}
+function isOpenGeniSiteBridgeConnectMessage(value) {
+  return isRecord(value) && value.type === OPENGENI_SITE_BRIDGE_CONNECT && value.version === OPENGENI_SITE_BRIDGE_VERSION;
+}
+function isOpenGeniSiteBridgeRequestMessage(value) {
+  if (!isRecord(value) || value.type !== OPENGENI_SITE_BRIDGE_REQUEST || value.version !== OPENGENI_SITE_BRIDGE_VERSION || typeof value.requestId !== "string" || !value.requestId) {
+    return false;
+  }
+  if (value.method === "catalog" || value.method === "declarations") return true;
+  return value.method === "call" && isRecord(value.payload);
+}
+function isOpenGeniSiteBridgeCancelMessage(value) {
+  return isRecord(value) && value.type === OPENGENI_SITE_BRIDGE_CANCEL && value.version === OPENGENI_SITE_BRIDGE_VERSION && typeof value.requestId === "string" && Boolean(value.requestId);
+}
+function sanitizeOpenGeniSiteToolCallRequest(value) {
+  return {
+    ...value.operationId === void 0 ? {} : { operationId: value.operationId },
+    catalogDigest: value.catalogDigest,
+    identity: value.identity,
+    arguments: value.arguments
+  };
+}
+var OpenGeniSiteBridgeTransport = class {
+  options;
+  bootstrap;
+  port = null;
+  connecting = null;
+  closed = false;
+  constructor(options) {
+    this.options = options;
+    this.bootstrap = createSiteBridgeBootstrap(options);
+  }
+  async fetch(input, init) {
+    return sitePortFetch(await this.connect(), input, init);
+  }
+  async requestJson(method, path, body, _query, requestOptions = {}) {
+    if (method === "GET" && path.endsWith("/tools/catalog")) {
+      return await this.request({ method: "catalog" }, requestOptions);
+    }
+    if (method === "GET" && path.endsWith("/tools/declarations")) {
+      return await this.request({ method: "declarations" }, requestOptions);
+    }
+    if (method === "POST" && path.endsWith("/tools/calls")) {
+      if (!isRecord(body)) throw new TypeError("Site tool call payload is required");
+      return await this.request(
+        {
+          method: "call",
+          payload: sanitizeOpenGeniSiteToolCallRequest(body)
+        },
+        requestOptions
+      );
+    }
+    throw new OpenGeniSiteBridgeError("unsupported_request", "Unsupported Site bridge request");
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.bootstrap.close();
+    this.port?.close();
+    this.port = null;
+  }
+  async request(request, options) {
+    const port = await this.connect();
+    const requestId = crypto.randomUUID();
+    const timeoutMs = positiveTimeout(
+      options.timeoutMs ?? this.options.requestTimeoutMs ?? 12e4,
+      "requestTimeoutMs"
+    );
+    return await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        cleanup();
+        cancel(port, requestId);
+        reject(
+          request.method === "call" ? new OpenGeniSiteBridgeError(
+            "timeout",
+            "Site tool request timed out after execution may have started",
+            false,
+            true
+          ) : new OpenGeniSiteBridgeError("timeout", "Site tool request timed out", true)
+        );
+      }, timeoutMs);
+      const abort = () => {
+        cleanup();
+        cancel(port, requestId);
+        reject(options.signal?.reason ?? new DOMException("Request aborted", "AbortError"));
+      };
+      const onMessage = (event) => {
+        const response = event.data;
+        if (!isRecord(response) || response.type !== OPENGENI_SITE_BRIDGE_RESPONSE || response.version !== OPENGENI_SITE_BRIDGE_VERSION || response.requestId !== requestId || typeof response.ok !== "boolean") {
+          return;
+        }
+        cleanup();
+        if (response.ok) {
+          resolve(response.value);
+          return;
+        }
+        const error = isRecord(response.error) ? response.error : {};
+        reject(
+          new OpenGeniSiteBridgeError(
+            typeof error.code === "string" ? error.code : "bridge_error",
+            typeof error.message === "string" ? error.message : "Site tool request failed",
+            error.retryable === true,
+            error.outcomeUnknown === true
+          )
+        );
+      };
+      const cleanup = () => {
+        clearTimeout(timeout);
+        options.signal?.removeEventListener("abort", abort);
+        port.removeEventListener("message", onMessage);
+      };
+      if (options.signal?.aborted) {
+        abort();
+        return;
+      }
+      options.signal?.addEventListener("abort", abort, { once: true });
+      port.addEventListener("message", onMessage);
+      port.postMessage({
+        type: OPENGENI_SITE_BRIDGE_REQUEST,
+        version: OPENGENI_SITE_BRIDGE_VERSION,
+        requestId,
+        ...request
+      });
+    });
+  }
+  async connect() {
+    if (this.closed) throw new OpenGeniSiteBridgeError("closed", "Site bridge is closed");
+    if (this.port) return this.port;
+    if (this.connecting) return await this.connecting;
+    const channel = (this.options.createMessageChannel ?? (() => new MessageChannel()))();
+    const timeoutMs = positiveTimeout(this.options.connectTimeoutMs ?? 1e4, "connectTimeoutMs");
+    this.connecting = new Promise((resolve, reject) => {
+      let active = true;
+      const timeout = setTimeout(() => {
+        cleanup();
+        channel.port1.close();
+        reject(new OpenGeniSiteBridgeError("host_timeout", "Opengeni Site host did not respond"));
+      }, timeoutMs);
+      const onMessage = (event) => {
+        const message = event.data;
+        if (!isRecord(message) || message.type !== OPENGENI_SITE_BRIDGE_READY || message.version !== OPENGENI_SITE_BRIDGE_VERSION) {
+          return;
+        }
+        cleanup();
+        this.port = channel.port1;
+        resolve(channel.port1);
+      };
+      const cleanup = () => {
+        active = false;
+        clearTimeout(timeout);
+        channel.port1.removeEventListener("message", onMessage);
+      };
+      channel.port1.addEventListener("message", onMessage);
+      channel.port1.start();
+      void this.bootstrap.port().then((bootstrapPort) => {
+        if (!active) return;
+        if (this.closed) throw new OpenGeniSiteBridgeError("closed", "Site bridge is closed");
+        bootstrapPort.postMessage(
+          {
+            type: OPENGENI_SITE_BRIDGE_CONNECT,
+            version: OPENGENI_SITE_BRIDGE_VERSION
+          },
+          [channel.port2]
+        );
+      }).catch((error) => {
+        cleanup();
+        channel.port1.close();
+        reject(error);
+      });
+    }).finally(() => {
+      this.connecting = null;
+    });
+    return await this.connecting;
+  }
+};
+function createSiteBridgeBootstrap(options) {
+  if (options.bootstrapPort) {
+    return {
+      port: async () => options.bootstrapPort,
+      close: () => options.bootstrapPort?.close()
+    };
+  }
+  const siteWindow = options.siteWindow ?? globalThis.window;
+  const parentWindow = options.parentWindow ?? siteWindow?.parent;
+  if (!siteWindow || !parentWindow || parentWindow === siteWindow) {
+    return {
+      port: async () => {
+        throw new OpenGeniSiteBridgeError(
+          "host_unavailable",
+          "Opengeni Site client must run inside a hosted iframe"
+        );
+      },
+      close: () => void 0
+    };
+  }
+  const retainedPort = retainedSiteBridgeBootstrapPort(siteWindow);
+  if (retainedPort) {
+    return {
+      port: async () => retainedPort,
+      close: () => void 0
+    };
+  }
+  let settledPort = null;
+  let rejectBootstrap = null;
+  const onMessage = (event) => {
+    if (event.source !== parentWindow || !isOpenGeniSiteBridgeReadyMessage(event.data) || event.ports.length !== 1) {
+      return;
+    }
+    cleanup();
+    settledPort = event.ports[0];
+    settledPort.start();
+    retainSiteBridgeBootstrapPort(siteWindow, settledPort);
+    resolveBootstrap?.(settledPort);
+  };
+  let resolveBootstrap = null;
+  const cleanup = () => siteWindow.removeEventListener("message", onMessage);
+  const port = new Promise((resolve, reject) => {
+    resolveBootstrap = resolve;
+    rejectBootstrap = reject;
+    siteWindow.addEventListener("message", onMessage);
+  });
+  void port.catch(() => void 0);
+  return {
+    port: async () => await port,
+    close: () => {
+      cleanup();
+      rejectBootstrap?.(new OpenGeniSiteBridgeError("closed", "Site bridge is closed"));
+      resolveBootstrap = null;
+      rejectBootstrap = null;
+    }
+  };
+}
+function retainedSiteBridgeBootstrapPort(siteWindow) {
+  const state = siteWindow[OPENGENI_SITE_BRIDGE_BOOTSTRAP_GLOBAL];
+  if (!isRecord(state)) return null;
+  const candidate = state.port;
+  return candidate && typeof candidate.postMessage === "function" && typeof candidate.addEventListener === "function" && typeof candidate.start === "function" ? candidate : null;
+}
+function retainSiteBridgeBootstrapPort(siteWindow, port) {
+  try {
+    Object.defineProperty(siteWindow, OPENGENI_SITE_BRIDGE_BOOTSTRAP_GLOBAL, {
+      configurable: true,
+      value: { port }
+    });
+  } catch {
+  }
+}
+function isOpenGeniSiteBridgeReadyMessage(value) {
+  return isRecord(value) && value.type === OPENGENI_SITE_BRIDGE_READY && value.version === OPENGENI_SITE_BRIDGE_VERSION;
+}
+function cancel(port, requestId) {
+  port.postMessage({
+    type: OPENGENI_SITE_BRIDGE_CANCEL,
+    version: OPENGENI_SITE_BRIDGE_VERSION,
+    requestId
+  });
+}
+function positiveTimeout(value, label) {
+  if (!Number.isFinite(value) || value <= 0) throw new RangeError(`${label} must be positive`);
+  return value;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export {
+  siteSessionPath,
+  isSiteHttpRequest,
+  serveSiteHttp,
+  createSiteToolBridge,
+  isSiteCatalogStaleError,
+  OPENGENI_SITE_BRIDGE_VERSION,
+  OPENGENI_SITE_BRIDGE_CONNECT,
+  OPENGENI_SITE_BRIDGE_READY,
+  OPENGENI_SITE_BRIDGE_REQUEST,
+  OPENGENI_SITE_BRIDGE_RESPONSE,
+  OPENGENI_SITE_BRIDGE_CANCEL,
+  OPENGENI_SITE_BRIDGE_BOOTSTRAP_GLOBAL,
+  OPENGENI_SITE_LOCAL_CODEMODE_PATH,
+  OpenGeniSiteBridgeError,
+  createOpenGeniSiteClient,
+  isOpenGeniSiteBridgeConnectMessage,
+  isOpenGeniSiteBridgeRequestMessage,
+  isOpenGeniSiteBridgeCancelMessage,
+  sanitizeOpenGeniSiteToolCallRequest
+};
+//# sourceMappingURL=chunk-DUVIYER4.js.map