@depup/hono 4.12.8-depup.0

package/dist/cjs/adapter/aws-lambda/handler.js

@@ -0,0 +1,397 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var handler_exports = {};
+__export(handler_exports, {
+  ALBProcessor: () => ALBProcessor,
+  EventProcessor: () => EventProcessor,
+  EventV1Processor: () => EventV1Processor,
+  EventV2Processor: () => EventV2Processor,
+  LatticeV2Processor: () => LatticeV2Processor,
+  defaultIsContentTypeBinary: () => defaultIsContentTypeBinary,
+  getProcessor: () => getProcessor,
+  handle: () => handle,
+  isContentEncodingBinary: () => isContentEncodingBinary,
+  streamHandle: () => streamHandle
+});
+module.exports = __toCommonJS(handler_exports);
+var import_encode = require("../../utils/encode");
+function sanitizeHeaderValue(value) {
+  const hasNonAscii = /[^\x00-\x7F]/.test(value);
+  if (!hasNonAscii) {
+    return value;
+  }
+  return encodeURIComponent(value);
+}
+const getRequestContext = (event) => {
+  return event.requestContext;
+};
+const streamToNodeStream = async (reader, writer) => {
+  let readResult = await reader.read();
+  while (!readResult.done) {
+    writer.write(readResult.value);
+    readResult = await reader.read();
+  }
+  writer.end();
+};
+const streamHandle = (app) => {
+  return awslambda.streamifyResponse(
+    async (event, responseStream, context) => {
+      const processor = getProcessor(event);
+      try {
+        const req = processor.createRequest(event);
+        const requestContext = getRequestContext(event);
+        const res = await app.fetch(req, {
+          event,
+          requestContext,
+          context
+        });
+        const headers = {};
+        const cookies = [];
+        res.headers.forEach((value, name) => {
+          if (name === "set-cookie") {
+            cookies.push(value);
+          } else {
+            headers[name] = value;
+          }
+        });
+        const httpResponseMetadata = {
+          statusCode: res.status,
+          headers,
+          cookies
+        };
+        responseStream = awslambda.HttpResponseStream.from(responseStream, httpResponseMetadata);
+        if (res.body) {
+          await streamToNodeStream(res.body.getReader(), responseStream);
+        } else {
+          responseStream.write("");
+        }
+      } catch (error) {
+        console.error("Error processing request:", error);
+        responseStream.write("Internal Server Error");
+      } finally {
+        responseStream.end();
+      }
+    }
+  );
+};
+const handle = (app, { isContentTypeBinary } = { isContentTypeBinary: void 0 }) => {
+  return async (event, lambdaContext) => {
+    const processor = getProcessor(event);
+    const req = processor.createRequest(event);
+    const requestContext = getRequestContext(event);
+    const res = await app.fetch(req, {
+      event,
+      requestContext,
+      lambdaContext
+    });
+    return processor.createResult(event, res, { isContentTypeBinary });
+  };
+};
+class EventProcessor {
+  getHeaderValue(headers, key) {
+    const value = headers ? Array.isArray(headers[key]) ? headers[key][0] : headers[key] : void 0;
+    return value;
+  }
+  getDomainName(event) {
+    if (event.requestContext && "domainName" in event.requestContext) {
+      return event.requestContext.domainName;
+    }
+    const hostFromHeaders = this.getHeaderValue(event.headers, "host");
+    if (hostFromHeaders) {
+      return hostFromHeaders;
+    }
+    const multiValueHeaders = "multiValueHeaders" in event ? event.multiValueHeaders : {};
+    const hostFromMultiValueHeaders = this.getHeaderValue(multiValueHeaders, "host");
+    return hostFromMultiValueHeaders;
+  }
+  createRequest(event) {
+    const queryString = this.getQueryString(event);
+    const domainName = this.getDomainName(event);
+    const path = this.getPath(event);
+    const urlPath = `https://${domainName}${path}`;
+    const url = queryString ? `${urlPath}?${queryString}` : urlPath;
+    const headers = this.getHeaders(event);
+    const method = this.getMethod(event);
+    const requestInit = {
+      headers,
+      method
+    };
+    if (event.body) {
+      requestInit.body = event.isBase64Encoded ? (0, import_encode.decodeBase64)(event.body) : event.body;
+    }
+    return new Request(url, requestInit);
+  }
+  async createResult(event, res, options) {
+    const contentType = res.headers.get("content-type");
+    const isContentTypeBinary = options.isContentTypeBinary ?? defaultIsContentTypeBinary;
+    let isBase64Encoded = contentType && isContentTypeBinary(contentType) ? true : false;
+    if (!isBase64Encoded) {
+      const contentEncoding = res.headers.get("content-encoding");
+      isBase64Encoded = isContentEncodingBinary(contentEncoding);
+    }
+    const body = isBase64Encoded ? (0, import_encode.encodeBase64)(await res.arrayBuffer()) : await res.text();
+    const result = {
+      body,
+      statusCode: res.status,
+      isBase64Encoded,
+      ..."multiValueHeaders" in event && event.multiValueHeaders ? {
+        multiValueHeaders: {}
+      } : {
+        headers: {}
+      }
+    };
+    this.setCookies(event, res, result);
+    if (result.multiValueHeaders) {
+      res.headers.forEach((value, key) => {
+        result.multiValueHeaders[key] = [value];
+      });
+    } else {
+      res.headers.forEach((value, key) => {
+        result.headers[key] = value;
+      });
+    }
+    return result;
+  }
+  setCookies(_event, res, result) {
+    if (res.headers.has("set-cookie")) {
+      const cookies = res.headers.getSetCookie ? res.headers.getSetCookie() : Array.from(res.headers.entries()).filter(([k]) => k === "set-cookie").map(([, v]) => v);
+      if (Array.isArray(cookies)) {
+        this.setCookiesToResult(result, cookies);
+        res.headers.delete("set-cookie");
+      }
+    }
+  }
+}
+class EventV2Processor extends EventProcessor {
+  getPath(event) {
+    return event.rawPath;
+  }
+  getMethod(event) {
+    return event.requestContext.http.method;
+  }
+  getQueryString(event) {
+    return event.rawQueryString;
+  }
+  getCookies(event, headers) {
+    if (Array.isArray(event.cookies)) {
+      headers.set("Cookie", event.cookies.join("; "));
+    }
+  }
+  setCookiesToResult(result, cookies) {
+    result.cookies = cookies;
+  }
+  getHeaders(event) {
+    const headers = new Headers();
+    this.getCookies(event, headers);
+    if (event.headers) {
+      for (const [k, v] of Object.entries(event.headers)) {
+        if (v) {
+          headers.set(k, v);
+        }
+      }
+    }
+    return headers;
+  }
+}
+const v2Processor = new EventV2Processor();
+class EventV1Processor extends EventProcessor {
+  getPath(event) {
+    return event.path;
+  }
+  getMethod(event) {
+    return event.httpMethod;
+  }
+  getQueryString(event) {
+    if (event.multiValueQueryStringParameters) {
+      return Object.entries(event.multiValueQueryStringParameters || {}).filter(([, value]) => value).map(
+        ([key, values]) => values.map((value) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&")
+      ).join("&");
+    } else {
+      return Object.entries(event.queryStringParameters || {}).filter(([, value]) => value).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value || "")}`).join("&");
+    }
+  }
+  getCookies(_event, _headers) {
+  }
+  getHeaders(event) {
+    const headers = new Headers();
+    this.getCookies(event, headers);
+    if (event.headers) {
+      for (const [k, v] of Object.entries(event.headers)) {
+        if (v) {
+          headers.set(k, sanitizeHeaderValue(v));
+        }
+      }
+    }
+    if (event.multiValueHeaders) {
+      for (const [k, values] of Object.entries(event.multiValueHeaders)) {
+        if (values) {
+          const foundK = headers.get(k);
+          values.forEach((v) => {
+            const sanitizedValue = sanitizeHeaderValue(v);
+            return (!foundK || !foundK.includes(sanitizedValue)) && headers.append(k, sanitizedValue);
+          });
+        }
+      }
+    }
+    return headers;
+  }
+  setCookiesToResult(result, cookies) {
+    result.multiValueHeaders = {
+      "set-cookie": cookies
+    };
+  }
+}
+const v1Processor = new EventV1Processor();
+class ALBProcessor extends EventProcessor {
+  getHeaders(event) {
+    const headers = new Headers();
+    if (event.multiValueHeaders) {
+      for (const [key, values] of Object.entries(event.multiValueHeaders)) {
+        if (values && Array.isArray(values)) {
+          const sanitizedValue = sanitizeHeaderValue(values.join("; "));
+          headers.set(key, sanitizedValue);
+        }
+      }
+    } else {
+      for (const [key, value] of Object.entries(event.headers ?? {})) {
+        if (value) {
+          headers.set(key, sanitizeHeaderValue(value));
+        }
+      }
+    }
+    return headers;
+  }
+  getPath(event) {
+    return event.path;
+  }
+  getMethod(event) {
+    return event.httpMethod;
+  }
+  getQueryString(event) {
+    if (event.multiValueQueryStringParameters) {
+      return Object.entries(event.multiValueQueryStringParameters || {}).filter(([, value]) => value).map(([key, value]) => `${key}=${value.join(`&${key}=`)}`).join("&");
+    } else {
+      return Object.entries(event.queryStringParameters || {}).filter(([, value]) => value).map(([key, value]) => `${key}=${value}`).join("&");
+    }
+  }
+  getCookies(event, headers) {
+    let cookie;
+    if (event.multiValueHeaders) {
+      cookie = event.multiValueHeaders["cookie"]?.join("; ");
+    } else {
+      cookie = event.headers ? event.headers["cookie"] : void 0;
+    }
+    if (cookie) {
+      headers.append("Cookie", cookie);
+    }
+  }
+  setCookiesToResult(result, cookies) {
+    if (result.multiValueHeaders) {
+      result.multiValueHeaders["set-cookie"] = cookies;
+    } else {
+      result.headers["set-cookie"] = cookies.join(", ");
+    }
+  }
+}
+const albProcessor = new ALBProcessor();
+class LatticeV2Processor extends EventProcessor {
+  getPath(event) {
+    return event.path;
+  }
+  getMethod(event) {
+    return event.method;
+  }
+  getQueryString() {
+    return "";
+  }
+  getHeaders(event) {
+    const headers = new Headers();
+    if (event.headers) {
+      for (const [k, values] of Object.entries(event.headers)) {
+        if (values) {
+          const foundK = headers.get(k);
+          values.forEach((v) => {
+            const sanitizedValue = sanitizeHeaderValue(v);
+            return (!foundK || !foundK.includes(sanitizedValue)) && headers.append(k, sanitizedValue);
+          });
+        }
+      }
+    }
+    return headers;
+  }
+  getCookies() {
+  }
+  setCookiesToResult(result, cookies) {
+    result.headers = {
+      ...result.headers,
+      "set-cookie": cookies.join(", ")
+    };
+  }
+}
+const latticeV2Processor = new LatticeV2Processor();
+const getProcessor = (event) => {
+  if (isProxyEventALB(event)) {
+    return albProcessor;
+  }
+  if (isProxyEventV2(event)) {
+    return v2Processor;
+  }
+  if (isLatticeEventV2(event)) {
+    return latticeV2Processor;
+  }
+  return v1Processor;
+};
+const isProxyEventALB = (event) => {
+  if (event.requestContext) {
+    return Object.hasOwn(event.requestContext, "elb");
+  }
+  return false;
+};
+const isProxyEventV2 = (event) => {
+  return Object.hasOwn(event, "rawPath");
+};
+const isLatticeEventV2 = (event) => {
+  if (event.requestContext) {
+    return Object.hasOwn(event.requestContext, "serviceArn");
+  }
+  return false;
+};
+const defaultIsContentTypeBinary = (contentType) => {
+  return !/^text\/(?:plain|html|css|javascript|csv)|(?:\/|\+)(?:json|xml)\s*(?:;|$)/.test(
+    contentType
+  );
+};
+const isContentEncodingBinary = (contentEncoding) => {
+  if (contentEncoding === null) {
+    return false;
+  }
+  return /^(gzip|deflate|compress|br)/.test(contentEncoding);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ALBProcessor,
+  EventProcessor,
+  EventV1Processor,
+  EventV2Processor,
+  LatticeV2Processor,
+  defaultIsContentTypeBinary,
+  getProcessor,
+  handle,
+  isContentEncodingBinary,
+  streamHandle
+});

package/dist/cjs/adapter/aws-lambda/index.js

@@ -0,0 +1,34 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var aws_lambda_exports = {};
+__export(aws_lambda_exports, {
+  defaultIsContentTypeBinary: () => import_handler.defaultIsContentTypeBinary,
+  getConnInfo: () => import_conninfo.getConnInfo,
+  handle: () => import_handler.handle,
+  streamHandle: () => import_handler.streamHandle
+});
+module.exports = __toCommonJS(aws_lambda_exports);
+var import_handler = require("./handler");
+var import_conninfo = require("./conninfo");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defaultIsContentTypeBinary,
+  getConnInfo,
+  handle,
+  streamHandle
+});

package/dist/cjs/adapter/aws-lambda/types.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/cjs/adapter/bun/conninfo.js

@@ -0,0 +1,49 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var conninfo_exports = {};
+__export(conninfo_exports, {
+  getConnInfo: () => getConnInfo
+});
+module.exports = __toCommonJS(conninfo_exports);
+var import_server = require("./server");
+const getConnInfo = (c) => {
+  const server = (0, import_server.getBunServer)(c);
+  if (!server) {
+    throw new TypeError("env has to include the 2nd argument of fetch.");
+  }
+  if (typeof server.requestIP !== "function") {
+    throw new TypeError("server.requestIP is not a function.");
+  }
+  const info = server.requestIP(c.req.raw);
+  if (!info) {
+    return {
+      remote: {}
+    };
+  }
+  return {
+    remote: {
+      address: info.address,
+      addressType: info.family === "IPv6" || info.family === "IPv4" ? info.family : void 0,
+      port: info.port
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getConnInfo
+});

package/dist/cjs/adapter/bun/index.js

@@ -0,0 +1,45 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bun_exports = {};
+__export(bun_exports, {
+  bunFileSystemModule: () => import_ssg.bunFileSystemModule,
+  createBunWebSocket: () => import_websocket.createBunWebSocket,
+  getBunServer: () => import_server.getBunServer,
+  getConnInfo: () => import_conninfo.getConnInfo,
+  serveStatic: () => import_serve_static.serveStatic,
+  toSSG: () => import_ssg.toSSG,
+  upgradeWebSocket: () => import_websocket.upgradeWebSocket,
+  websocket: () => import_websocket.websocket
+});
+module.exports = __toCommonJS(bun_exports);
+var import_serve_static = require("./serve-static");
+var import_ssg = require("./ssg");
+var import_websocket = require("./websocket");
+var import_conninfo = require("./conninfo");
+var import_server = require("./server");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bunFileSystemModule,
+  createBunWebSocket,
+  getBunServer,
+  getConnInfo,
+  serveStatic,
+  toSSG,
+  upgradeWebSocket,
+  websocket
+});

package/dist/cjs/adapter/bun/serve-static.js

@@ -0,0 +1,52 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var serve_static_exports = {};
+__export(serve_static_exports, {
+  serveStatic: () => serveStatic
+});
+module.exports = __toCommonJS(serve_static_exports);
+var import_promises = require("node:fs/promises");
+var import_node_path = require("node:path");
+var import_serve_static = require("../../middleware/serve-static");
+const serveStatic = (options) => {
+  return async function serveStatic2(c, next) {
+    const getContent = async (path) => {
+      const file = Bun.file(path);
+      return await file.exists() ? file : null;
+    };
+    const isDir = async (path) => {
+      let isDir2;
+      try {
+        const stats = await (0, import_promises.stat)(path);
+        isDir2 = stats.isDirectory();
+      } catch {
+      }
+      return isDir2;
+    };
+    return (0, import_serve_static.serveStatic)({
+      ...options,
+      getContent,
+      join: import_node_path.join,
+      isDir
+    })(c, next);
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  serveStatic
+});

package/dist/cjs/adapter/bun/server.js

@@ -0,0 +1,27 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var server_exports = {};
+__export(server_exports, {
+  getBunServer: () => getBunServer
+});
+module.exports = __toCommonJS(server_exports);
+const getBunServer = (c) => "server" in c.env ? c.env.server : c.env;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getBunServer
+});

package/dist/cjs/adapter/bun/ssg.js

@@ -0,0 +1,40 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ssg_exports = {};
+__export(ssg_exports, {
+  bunFileSystemModule: () => bunFileSystemModule,
+  toSSG: () => toSSG
+});
+module.exports = __toCommonJS(ssg_exports);
+var import_ssg = require("../../helper/ssg");
+const { write } = Bun;
+const bunFileSystemModule = {
+  writeFile: async (path, data) => {
+    await write(path, data);
+  },
+  mkdir: async () => {
+  }
+};
+const toSSG = async (app, options) => {
+  return (0, import_ssg.toSSG)(app, bunFileSystemModule, options);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bunFileSystemModule,
+  toSSG
+});