@piagent/platform 1.2.17 → 1.3.0-ie.8

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/router/trie-router/node.js

@@ -0,0 +1,188 @@
+// src/router/trie-router/node.ts
+import { METHOD_NAME_ALL } from "../../router.js";
+import { getPattern, splitPath, splitRoutingPath } from "../../utils/url.js";
+var emptyParams = /* @__PURE__ */ Object.create(null);
+var hasChildren = (children) => {
+  for (const _ in children) {
+    return true;
+  }
+  return false;
+};
+var Node = class _Node {
+  #methods;
+  #children;
+  #patterns;
+  #order = 0;
+  #params = emptyParams;
+  constructor(method, handler, children) {
+    this.#children = children || /* @__PURE__ */ Object.create(null);
+    this.#methods = [];
+    if (method && handler) {
+      const m = /* @__PURE__ */ Object.create(null);
+      m[method] = { handler, possibleKeys: [], score: 0 };
+      this.#methods = [m];
+    }
+    this.#patterns = [];
+  }
+  insert(method, path, handler) {
+    this.#order = ++this.#order;
+    let curNode = this;
+    const parts = splitRoutingPath(path);
+    const possibleKeys = [];
+    for (let i = 0, len = parts.length; i < len; i++) {
+      const p = parts[i];
+      const nextP = parts[i + 1];
+      const pattern = getPattern(p, nextP);
+      const key = Array.isArray(pattern) ? pattern[0] : p;
+      if (key in curNode.#children) {
+        curNode = curNode.#children[key];
+        if (pattern) {
+          possibleKeys.push(pattern[1]);
+        }
+        continue;
+      }
+      curNode.#children[key] = new _Node();
+      if (pattern) {
+        curNode.#patterns.push(pattern);
+        possibleKeys.push(pattern[1]);
+      }
+      curNode = curNode.#children[key];
+    }
+    curNode.#methods.push({
+      [method]: {
+        handler,
+        possibleKeys: possibleKeys.filter((v, i, a) => a.indexOf(v) === i),
+        score: this.#order
+      }
+    });
+    return curNode;
+  }
+  #pushHandlerSets(handlerSets, node, method, nodeParams, params) {
+    for (let i = 0, len = node.#methods.length; i < len; i++) {
+      const m = node.#methods[i];
+      const handlerSet = m[method] || m[METHOD_NAME_ALL];
+      const processedSet = {};
+      if (handlerSet !== void 0) {
+        handlerSet.params = /* @__PURE__ */ Object.create(null);
+        handlerSets.push(handlerSet);
+        if (nodeParams !== emptyParams || params && params !== emptyParams) {
+          for (let i2 = 0, len2 = handlerSet.possibleKeys.length; i2 < len2; i2++) {
+            const key = handlerSet.possibleKeys[i2];
+            const processed = processedSet[handlerSet.score];
+            handlerSet.params[key] = params?.[key] && !processed ? params[key] : nodeParams[key] ?? params?.[key];
+            processedSet[handlerSet.score] = true;
+          }
+        }
+      }
+    }
+  }
+  search(method, path) {
+    const handlerSets = [];
+    this.#params = emptyParams;
+    const curNode = this;
+    let curNodes = [curNode];
+    const parts = splitPath(path);
+    const curNodesQueue = [];
+    const len = parts.length;
+    let partOffsets = null;
+    for (let i = 0; i < len; i++) {
+      const part = parts[i];
+      const isLast = i === len - 1;
+      const tempNodes = [];
+      for (let j = 0, len2 = curNodes.length; j < len2; j++) {
+        const node = curNodes[j];
+        const nextNode = node.#children[part];
+        if (nextNode) {
+          nextNode.#params = node.#params;
+          if (isLast) {
+            if (nextNode.#children["*"]) {
+              this.#pushHandlerSets(handlerSets, nextNode.#children["*"], method, node.#params);
+            }
+            this.#pushHandlerSets(handlerSets, nextNode, method, node.#params);
+          } else {
+            tempNodes.push(nextNode);
+          }
+        }
+        for (let k = 0, len3 = node.#patterns.length; k < len3; k++) {
+          const pattern = node.#patterns[k];
+          const params = node.#params === emptyParams ? {} : { ...node.#params };
+          if (pattern === "*") {
+            const astNode = node.#children["*"];
+            if (astNode) {
+              this.#pushHandlerSets(handlerSets, astNode, method, node.#params);
+              astNode.#params = params;
+              tempNodes.push(astNode);
+            }
+            continue;
+          }
+          const [key, name, matcher] = pattern;
+          if (!part && !(matcher instanceof RegExp)) {
+            continue;
+          }
+          const child = node.#children[key];
+          if (matcher instanceof RegExp) {
+            if (partOffsets === null) {
+              partOffsets = new Array(len);
+              let offset = path[0] === "/" ? 1 : 0;
+              for (let p = 0; p < len; p++) {
+                partOffsets[p] = offset;
+                offset += parts[p].length + 1;
+              }
+            }
+            const restPathString = path.substring(partOffsets[i]);
+            const m = matcher.exec(restPathString);
+            if (m) {
+              params[name] = m[0];
+              this.#pushHandlerSets(handlerSets, child, method, node.#params, params);
+              if (m[0].length === restPathString.length && child.#children["*"]) {
+                this.#pushHandlerSets(
+                  handlerSets,
+                  child.#children["*"],
+                  method,
+                  node.#params,
+                  params
+                );
+              }
+              if (hasChildren(child.#children)) {
+                child.#params = params;
+                const componentCount = m[0].match(/\//g)?.length ?? 0;
+                const targetCurNodes = curNodesQueue[componentCount] ||= [];
+                targetCurNodes.push(child);
+              }
+              continue;
+            }
+          }
+          if (matcher === true || matcher.test(part)) {
+            params[name] = part;
+            if (isLast) {
+              this.#pushHandlerSets(handlerSets, child, method, params, node.#params);
+              if (child.#children["*"]) {
+                this.#pushHandlerSets(
+                  handlerSets,
+                  child.#children["*"],
+                  method,
+                  params,
+                  node.#params
+                );
+              }
+            } else {
+              child.#params = params;
+              tempNodes.push(child);
+            }
+          }
+        }
+      }
+      const shifted = curNodesQueue.shift();
+      curNodes = shifted ? tempNodes.concat(shifted) : tempNodes;
+    }
+    if (handlerSets.length > 1) {
+      handlerSets.sort((a, b) => {
+        return a.score - b.score;
+      });
+    }
+    return [handlerSets.map(({ handler, params }) => [handler, params])];
+  }
+};
+export {
+  Node
+};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/router/trie-router/router.js

@@ -0,0 +1,26 @@
+// src/router/trie-router/router.ts
+import { checkOptionalParameter } from "../../utils/url.js";
+import { Node } from "./node.js";
+var TrieRouter = class {
+  name = "TrieRouter";
+  #node;
+  constructor() {
+    this.#node = new Node();
+  }
+  add(method, path, handler) {
+    const results = checkOptionalParameter(path);
+    if (results) {
+      for (let i = 0, len = results.length; i < len; i++) {
+        this.#node.insert(method, results[i], handler);
+      }
+      return;
+    }
+    this.#node.insert(method, path, handler);
+  }
+  match(method, path) {
+    return this.#node.search(method, path);
+  }
+};
+export {
+  TrieRouter
+};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/router.js

@@ -0,0 +1,14 @@
+// src/router.ts
+var METHOD_NAME_ALL = "ALL";
+var METHOD_NAME_ALL_LOWERCASE = "all";
+var METHODS = ["get", "post", "put", "delete", "options", "patch", "query"];
+var MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
+var UnsupportedPathError = class extends Error {
+};
+export {
+  MESSAGE_MATCHER_IS_ALREADY_BUILT,
+  METHODS,
+  METHOD_NAME_ALL,
+  METHOD_NAME_ALL_LOWERCASE,
+  UnsupportedPathError
+};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/types/adapter/aws-lambda/conninfo.d.ts

@@ -0,0 +1,27 @@
+import type { GetConnInfo } from '../../helper/conninfo';
+/**
+ * Get connection information from AWS Lambda
+ *
+ * Extracts client IP from various Lambda event sources:
+ * - API Gateway v1 (REST API): requestContext.identity.sourceIp
+ * - API Gateway v2 (HTTP API/Function URLs): requestContext.http.sourceIp
+ * - ALB: Falls back to x-forwarded-for header
+ *
+ * @param c - Context
+ * @returns Connection information including remote address
+ * @example
+ * ```ts
+ * import { Hono } from 'hono'
+ * import { handle, getConnInfo } from 'hono/aws-lambda'
+ *
+ * const app = new Hono()
+ *
+ * app.get('/', (c) => {
+ *   const info = getConnInfo(c)
+ *   return c.text(`Your IP: ${info.remote.address}`)
+ * })
+ *
+ * export const handler = handle(app)
+ * ```
+ */
+export declare const getConnInfo: GetConnInfo;

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/types/adapter/aws-lambda/handler.d.ts

@@ -0,0 +1,184 @@
+import type { Hono } from '../../hono';
+import type { Env, Schema } from '../../types';
+import type { ALBRequestContext, ApiGatewayRequestContext, ApiGatewayRequestContextV2, Handler, LambdaContext, LatticeRequestContextV2 } from './types';
+export type LambdaEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2 | ALBProxyEvent | LatticeProxyEventV2;
+export interface LatticeProxyEventV2 {
+    version: string;
+    path: string;
+    method: string;
+    headers: Record<string, string[] | undefined>;
+    queryStringParameters: Record<string, string[] | undefined>;
+    body: string | null;
+    isBase64Encoded: boolean;
+    requestContext: LatticeRequestContextV2;
+}
+export interface APIGatewayProxyEventV2 {
+    version: string;
+    routeKey: string;
+    headers: Record<string, string | undefined>;
+    multiValueHeaders?: undefined;
+    cookies?: string[];
+    rawPath: string;
+    rawQueryString: string;
+    body: string | null;
+    isBase64Encoded: boolean;
+    requestContext: ApiGatewayRequestContextV2;
+    queryStringParameters?: {
+        [name: string]: string | undefined;
+    };
+    pathParameters?: {
+        [name: string]: string | undefined;
+    };
+    stageVariables?: {
+        [name: string]: string | undefined;
+    };
+}
+export interface APIGatewayProxyEvent {
+    version: string;
+    httpMethod: string;
+    headers: Record<string, string | undefined>;
+    multiValueHeaders?: {
+        [headerKey: string]: string[];
+    };
+    path: string;
+    body: string | null;
+    isBase64Encoded: boolean;
+    queryStringParameters?: Record<string, string | undefined>;
+    requestContext: ApiGatewayRequestContext;
+    resource: string;
+    multiValueQueryStringParameters?: {
+        [parameterKey: string]: string[];
+    };
+    pathParameters?: Record<string, string>;
+    stageVariables?: Record<string, string>;
+}
+export interface ALBProxyEvent {
+    httpMethod: string;
+    headers?: Record<string, string | undefined>;
+    multiValueHeaders?: Record<string, string[] | undefined>;
+    path: string;
+    body: string | null;
+    isBase64Encoded: boolean;
+    queryStringParameters?: Record<string, string | undefined>;
+    multiValueQueryStringParameters?: {
+        [parameterKey: string]: string[];
+    };
+    requestContext: ALBRequestContext;
+}
+type WithHeaders = {
+    headers: Record<string, string | string[]>;
+    multiValueHeaders?: undefined;
+};
+type WithMultiValueHeaders = {
+    headers?: undefined;
+    multiValueHeaders: Record<string, string[]>;
+};
+export type APIGatewayProxyResult = {
+    statusCode: number;
+    statusDescription?: string;
+    body: string;
+    cookies?: string[];
+    isBase64Encoded: boolean;
+} & (WithHeaders | WithMultiValueHeaders);
+export declare const streamHandle: <E extends Env = Env, S extends Schema = {}, BasePath extends string = "/">(app: Hono<E, S, BasePath>) => Handler;
+type HandleOptions = {
+    isContentTypeBinary: ((contentType: string) => boolean) | undefined;
+};
+/**
+ * Converts a Hono application to an AWS Lambda handler.
+ *
+ * Accepts events from API Gateway (v1 and v2), Application Load Balancer (ALB),
+ * and Lambda Function URLs.
+ *
+ * @param app - The Hono application instance
+ * @param options - Optional configuration
+ * @param options.isContentTypeBinary - A function to determine if the content type is binary.
+ *                                      If not provided, the default function will be used.
+ * @returns Lambda handler function
+ *
+ * @example
+ * ```js
+ * import { Hono } from 'hono'
+ * import { handle } from 'hono/aws-lambda'
+ *
+ * const app = new Hono()
+ *
+ * app.get('/', (c) => c.text('Hello from Lambda'))
+ * app.get('/json', (c) => c.json({ message: 'Hello JSON' }))
+ *
+ * export const handler = handle(app)
+ * ```
+ *
+ * @example
+ * ```js
+ * // With custom binary content type detection
+ * import { handle, defaultIsContentTypeBinary } from 'hono/aws-lambda'
+ * export const handler = handle(app, {
+ *   isContentTypeBinary: (contentType) => {
+ *     if (defaultIsContentTypeBinary(contentType)) {
+ *       // default logic same as prior to v4.8.4
+ *       return true
+ *     }
+ *     return contentType.startsWith('image/') || contentType === 'application/pdf'
+ *   }
+ * })
+ * ```
+ */
+export declare const handle: <E extends Env = Env, S extends Schema = {}, BasePath extends string = "/">(app: Hono<E, S, BasePath>, { isContentTypeBinary }?: HandleOptions) => (<L extends LambdaEvent>(event: L, lambdaContext?: LambdaContext) => Promise<APIGatewayProxyResult & (L extends {
+    multiValueHeaders: Record<string, string[]>;
+} ? WithMultiValueHeaders : WithHeaders)>);
+export declare abstract class EventProcessor<E extends LambdaEvent> {
+    protected abstract getPath(event: E): string;
+    protected abstract getMethod(event: E): string;
+    protected abstract getQueryString(event: E): string;
+    protected abstract getHeaders(event: E): Headers;
+    protected abstract getCookies(event: E, headers: Headers): void;
+    protected abstract setCookiesToResult(result: APIGatewayProxyResult, cookies: string[]): void;
+    protected getHeaderValue(headers: E['headers'], key: string): string | undefined;
+    protected getDomainName(event: E): string | undefined;
+    createRequest(event: E): Request;
+    createResult(event: E, res: Response, options: Pick<HandleOptions, 'isContentTypeBinary'>): Promise<APIGatewayProxyResult>;
+    setCookies(_event: E, res: Response, result: APIGatewayProxyResult): void;
+}
+export declare class EventV2Processor extends EventProcessor<APIGatewayProxyEventV2> {
+    protected getPath(event: APIGatewayProxyEventV2): string;
+    protected getMethod(event: APIGatewayProxyEventV2): string;
+    protected getQueryString(event: APIGatewayProxyEventV2): string;
+    protected getCookies(event: APIGatewayProxyEventV2, headers: Headers): void;
+    protected setCookiesToResult(result: APIGatewayProxyResult, cookies: string[]): void;
+    protected getHeaders(event: APIGatewayProxyEventV2): Headers;
+}
+export declare class EventV1Processor extends EventProcessor<APIGatewayProxyEvent> {
+    protected getPath(event: APIGatewayProxyEvent): string;
+    protected getMethod(event: APIGatewayProxyEvent): string;
+    protected getQueryString(event: APIGatewayProxyEvent): string;
+    protected getCookies(_event: APIGatewayProxyEvent, _headers: Headers): void;
+    protected getHeaders(event: APIGatewayProxyEvent): Headers;
+    protected setCookiesToResult(result: APIGatewayProxyResult, cookies: string[]): void;
+}
+export declare class ALBProcessor extends EventProcessor<ALBProxyEvent> {
+    protected getHeaders(event: ALBProxyEvent): Headers;
+    protected getPath(event: ALBProxyEvent): string;
+    protected getMethod(event: ALBProxyEvent): string;
+    protected getQueryString(event: ALBProxyEvent): string;
+    protected getCookies(event: ALBProxyEvent, headers: Headers): void;
+    protected setCookiesToResult(result: APIGatewayProxyResult, cookies: string[]): void;
+}
+export declare class LatticeV2Processor extends EventProcessor<LatticeProxyEventV2> {
+    protected getPath(event: LatticeProxyEventV2): string;
+    protected getMethod(event: LatticeProxyEventV2): string;
+    protected getQueryString(): string;
+    protected getHeaders(event: LatticeProxyEventV2): Headers;
+    protected getCookies(): void;
+    protected setCookiesToResult(result: APIGatewayProxyResult, cookies: string[]): void;
+}
+export declare const getProcessor: (event: LambdaEvent) => EventProcessor<LambdaEvent>;
+/**
+ * Check if the given content type is binary.
+ * This is a default function and may be overwritten by the user via `isContentTypeBinary` option in handler().
+ * @param contentType The content type to check.
+ * @returns True if the content type is binary, false otherwise.
+ */
+export declare const defaultIsContentTypeBinary: (contentType: string) => boolean;
+export declare const isContentEncodingBinary: (contentEncoding: string | null) => boolean;
+export {};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/types/adapter/aws-lambda/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @module
+ * AWS Lambda Adapter for Hono.
+ */
+export { handle, streamHandle, defaultIsContentTypeBinary } from './handler';
+export { getConnInfo } from './conninfo';
+export type { APIGatewayProxyResult, LambdaEvent } from './handler';
+export type { ApiGatewayRequestContext, ApiGatewayRequestContextV2, ALBRequestContext, LambdaContext, } from './types';

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/types/adapter/aws-lambda/types.d.ts

@@ -0,0 +1,153 @@
+export interface CognitoIdentity {
+    cognitoIdentityId: string;
+    cognitoIdentityPoolId: string;
+}
+export interface ClientContext {
+    client: ClientContextClient;
+    Custom?: any;
+    env: ClientContextEnv;
+}
+export interface ClientContextClient {
+    installationId: string;
+    appTitle: string;
+    appVersionName: string;
+    appVersionCode: string;
+    appPackageName: string;
+}
+export interface ClientContextEnv {
+    platformVersion: string;
+    platform: string;
+    make: string;
+    model: string;
+    locale: string;
+}
+/**
+ * {@link Handler} context parameter.
+ * See {@link https://docs.aws.amazon.com/lambda/latest/dg/nodejs-prog-model-context.html AWS documentation}.
+ */
+export interface LambdaContext {
+    callbackWaitsForEmptyEventLoop: boolean;
+    functionName: string;
+    functionVersion: string;
+    invokedFunctionArn: string;
+    memoryLimitInMB: string;
+    awsRequestId: string;
+    logGroupName: string;
+    logStreamName: string;
+    identity?: CognitoIdentity | undefined;
+    clientContext?: ClientContext | undefined;
+    getRemainingTimeInMillis(): number;
+}
+type Callback<TResult = any> = (error?: Error | string | null, result?: TResult) => void;
+export type Handler<TEvent = any, TResult = any> = (event: TEvent, context: LambdaContext, callback: Callback<TResult>) => void | Promise<TResult>;
+interface ClientCert {
+    clientCertPem: string;
+    subjectDN: string;
+    issuerDN: string;
+    serialNumber: string;
+    validity: {
+        notBefore: string;
+        notAfter: string;
+    };
+}
+interface Identity {
+    accessKey?: string;
+    accountId?: string;
+    caller?: string;
+    cognitoAuthenticationProvider?: string;
+    cognitoAuthenticationType?: string;
+    cognitoIdentityId?: string;
+    cognitoIdentityPoolId?: string;
+    principalOrgId?: string;
+    sourceIp: string;
+    user?: string;
+    userAgent: string;
+    userArn?: string;
+    clientCert?: ClientCert;
+}
+export interface ApiGatewayRequestContext {
+    accountId: string;
+    apiId: string;
+    authorizer: {
+        claims?: unknown;
+        scopes?: unknown;
+    };
+    domainName: string;
+    domainPrefix: string;
+    extendedRequestId: string;
+    httpMethod: string;
+    identity: Identity;
+    path: string;
+    protocol: string;
+    requestId: string;
+    requestTime: string;
+    requestTimeEpoch: number;
+    resourceId?: string;
+    resourcePath: string;
+    stage: string;
+}
+interface Authorizer {
+    iam?: {
+        accessKey: string;
+        accountId: string;
+        callerId: string;
+        cognitoIdentity: null;
+        principalOrgId: null;
+        userArn: string;
+        userId: string;
+    };
+    jwt?: {
+        claims: Record<string, string | number | boolean | string[]>;
+        scopes: string[] | null;
+    };
+    /**
+     * The `context` object returned by a Lambda (REQUEST) authorizer.
+     * It is `null` when the authorizer returns no context.
+     */
+    lambda?: Record<string, unknown> | null;
+}
+export interface ApiGatewayRequestContextV2 {
+    accountId: string;
+    apiId: string;
+    authentication: null;
+    authorizer: Authorizer;
+    domainName: string;
+    domainPrefix: string;
+    http: {
+        method: string;
+        path: string;
+        protocol: string;
+        sourceIp: string;
+        userAgent: string;
+    };
+    requestId: string;
+    routeKey: string;
+    stage: string;
+    time: string;
+    timeEpoch: number;
+}
+export interface ALBRequestContext {
+    elb: {
+        targetGroupArn: string;
+    };
+}
+export interface LatticeRequestContextV2 {
+    serviceNetworkArn: string;
+    serviceArn: string;
+    targetGroupArn: string;
+    region: string;
+    timeEpoch: string;
+    identity: {
+        sourceVpcArn?: string;
+        type?: string;
+        principal?: string;
+        principalOrgID?: string;
+        sessionName?: string;
+        x509IssuerOu?: string;
+        x509SanDns?: string;
+        x509SanNameCn?: string;
+        x509SanUri?: string;
+        x509SubjectCn?: string;
+    };
+}
+export {};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/types/adapter/bun/conninfo.d.ts

@@ -0,0 +1,7 @@
+import type { GetConnInfo } from '../../helper/conninfo';
+/**
+ * Get ConnInfo with Bun
+ * @param c Context
+ * @returns ConnInfo
+ */
+export declare const getConnInfo: GetConnInfo;

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/types/adapter/bun/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @module
+ * Bun Adapter for Hono.
+ */
+export { serveStatic } from './serve-static';
+export { bunFileSystemModule, toSSG } from './ssg';
+export { createBunWebSocket, upgradeWebSocket, websocket } from './websocket';
+export type { BunWebSocketData, BunWebSocketHandler } from './websocket';
+export { getConnInfo } from './conninfo';
+export { getBunServer } from './server';

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/types/adapter/bun/serve-static.d.ts

@@ -0,0 +1,3 @@
+import type { ServeStaticOptions } from '../../middleware/serve-static';
+import type { Env, MiddlewareHandler } from '../../types';
+export declare const serveStatic: <E extends Env = Env>(options?: ServeStaticOptions<E>) => MiddlewareHandler;

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/types/adapter/bun/server.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Getting Bun Server Object for Bun adapters
+ * @module
+ */
+import type { Context } from '../../context';
+/**
+ * Get Bun Server Object from Context
+ * @template T - The type of Bun Server
+ * @param c Context
+ * @returns Bun Server
+ */
+export declare const getBunServer: <T>(c: Context) => T | undefined;

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/types/adapter/bun/ssg.d.ts

@@ -0,0 +1,13 @@
+import type { FileSystemModule, ToSSGAdaptorInterface } from '../../helper/ssg';
+/**
+ * @experimental
+ * `bunFileSystemModule` is an experimental feature.
+ * The API might be changed.
+ */
+export declare const bunFileSystemModule: FileSystemModule;
+/**
+ * @experimental
+ * `toSSG` is an experimental feature.
+ * The API might be changed.
+ */
+export declare const toSSG: ToSSGAdaptorInterface;