@akanjs/next 0.0.33 → 0.0.35

package/index.js

@@ -1,21 +1,2724 @@
-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 });
+(() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+  }) : x)(function(x) {
+    if (typeof require !== "undefined")
+      return require.apply(this, arguments);
+    throw Error('Dynamic require of "' + x + '" is not supported');
+  });
+  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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+
+  // pkgs/@akanjs/next/src/useFetch.ts
+  var import_react = __require("react");
+  var useFetch = (fnOrPromise, { onError } = {}) => {
+    const [fetchState, setFetchState] = (0, import_react.useState)(
+      fnOrPromise instanceof Promise ? { fulfilled: false, value: null } : { fulfilled: true, value: fnOrPromise }
+    );
+    (0, import_react.useEffect)(() => {
+      void (async () => {
+        try {
+          const ret = fnOrPromise instanceof Promise ? await fnOrPromise : fnOrPromise;
+          setFetchState({ fulfilled: true, value: ret });
+        } catch (err) {
+          const content = `Error: ${typeof err === "string" ? err : err.message}`;
+          onError?.(content);
+          throw new Error(content);
+        }
+      })();
+    }, []);
+    return fetchState;
+  };
+
+  // pkgs/@akanjs/next/src/lazy.ts
+  var import_dynamic = __toESM(__require("next/dynamic"));
+  var lazy = (loader, option) => (0, import_dynamic.default)(loader, option ?? {});
+
+  // pkgs/@akanjs/base/src/base.ts
+  var version = "0.9.0";
+  var logo = `
+     _    _                  _     
+    / \\  | | ____ _ _ __    (_)___ 
+   / _ \\ | |/ / _' | '_ \\   | / __|
+  / ___ \\|   < (_| | | | |_ | \\__ \\
+ /_/   \\_\\_|\\_\\__,_|_| |_(_)/ |___/
+                          |__/      ver ${version}
+? See more details on docs  https://www.akanjs.com/docs
+\u2605 Star Akanjs on GitHub     https://github.com/aka-bassman/akanjs
+
+`;
+
+  // pkgs/@akanjs/base/src/baseEnv.ts
+  var appName = process.env.NEXT_PUBLIC_APP_NAME ?? "unknown";
+  var repoName = process.env.NEXT_PUBLIC_REPO_NAME ?? "unknown";
+  var serveDomain = process.env.NEXT_PUBLIC_SERVE_DOMAIN ?? "unknown";
+  if (appName === "unknown")
+    throw new Error("environment variable NEXT_PUBLIC_APP_NAME is required");
+  if (repoName === "unknown")
+    throw new Error("environment variable NEXT_PUBLIC_REPO_NAME is required");
+  if (serveDomain === "unknown")
+    throw new Error("environment variable NEXT_PUBLIC_SERVE_DOMAIN is required");
+  var environment = process.env.NEXT_PUBLIC_ENV ?? "debug";
+  var operationType = typeof window !== "undefined" ? "client" : process.env.NEXT_RUNTIME ? "client" : "server";
+  var operationMode = process.env.NEXT_PUBLIC_OPERATION_MODE ?? "cloud";
+  var networkType = process.env.NEXT_PUBLIC_NETWORK_TYPE ?? (environment === "main" ? "mainnet" : environment === "develop" ? "testnet" : "debugnet");
+  var tunnelUsername = process.env.SSU_TUNNEL_USERNAME ?? "root";
+  var tunnelPassword = process.env.SSU_TUNNEL_PASSWORD ?? repoName;
+  var baseEnv = {
+    repoName,
+    serveDomain,
+    appName,
+    environment,
+    operationType,
+    operationMode,
+    networkType,
+    tunnelUsername,
+    tunnelPassword
+  };
+  var side = typeof window === "undefined" ? "server" : "client";
+  var renderMode = process.env.RENDER_ENV ?? "ssr";
+  var clientHost = process.env.NEXT_PUBLIC_CLIENT_HOST ?? (operationMode === "local" || side === "server" ? "localhost" : window.location.hostname);
+  var clientPort = parseInt(
+    process.env.NEXT_PUBLIC_CLIENT_PORT ?? (operationMode === "local" ? renderMode === "ssr" ? "4200" : "4201" : "443")
+  );
+  var clientHttpProtocol = side === "client" ? window.location.protocol : clientHost === "localhost" ? "http:" : "https:";
+  var clientHttpUri = `${clientHttpProtocol}//${clientHost}${clientPort === 443 ? "" : `:${clientPort}`}`;
+  var serverHost = process.env.SERVER_HOST ?? (operationMode === "local" ? typeof window === "undefined" ? "localhost" : window.location.host.split(":")[0] : renderMode === "csr" ? `${appName}-${environment}.${serveDomain}` : side === "client" ? window.location.host.split(":")[0] : operationMode === "cloud" ? `backend-svc.${appName}-${environment}.svc.cluster.local` : "localhost");
+  var serverPort = parseInt(
+    process.env.SERVER_PORT ?? (operationMode === "local" || side === "server" ? "8080" : "443")
+  );
+  var serverHttpProtocol = side === "client" ? window.location.protocol : "http:";
+  var serverHttpUri = `${serverHttpProtocol}//${serverHost}${serverPort === 443 ? "" : `:${serverPort}`}/backend`;
+  var serverGraphqlUri = `${serverHttpUri}/graphql`;
+  var serverWsProtocol = serverHttpProtocol === "http:" ? "ws:" : "wss:";
+  var serverWsUri = `${serverWsProtocol}//${serverHost}${serverPort === 443 ? "" : `:${serverPort}`}`;
+  var baseClientEnv = {
+    ...baseEnv,
+    side,
+    renderMode,
+    websocket: true,
+    clientHost,
+    clientPort,
+    clientHttpProtocol,
+    clientHttpUri,
+    serverHost,
+    serverPort,
+    serverHttpProtocol,
+    serverHttpUri,
+    serverGraphqlUri,
+    serverWsProtocol,
+    serverWsUri
+  };
+
+  // pkgs/@akanjs/base/src/scalar.ts
+  var import_dayjs = __toESM(__require("dayjs"));
+  var dayjs = import_dayjs.default;
+  var Int = class {
+    __Scalar__;
+  };
+  var Upload = class {
+    __Scalar__;
+    filename;
+    mimetype;
+    encoding;
+    createReadStream;
+  };
+  var Float = class {
+    __Scalar__;
+  };
+  var ID = class {
+    __Scalar__;
+  };
+  var JSON2 = class {
+    __Scalar__;
+  };
+  var getNonArrayModel = (arraiedModel2) => {
+    let arrDepth = 0;
+    let target = arraiedModel2;
+    while (Array.isArray(target)) {
+      target = target[0];
+      arrDepth++;
+    }
+    return [target, arrDepth];
+  };
+  var scalarSet = /* @__PURE__ */ new Set([String, Boolean, Date, ID, Int, Float, Upload, JSON2, Map]);
+  var scalarNameMap = /* @__PURE__ */ new Map([
+    [ID, "ID"],
+    [Int, "Int"],
+    [Float, "Float"],
+    [String, "String"],
+    [Boolean, "Boolean"],
+    [Date, "Date"],
+    [Upload, "Upload"],
+    [JSON2, "JSON"],
+    [Map, "Map"]
+  ]);
+  var scalarArgMap = /* @__PURE__ */ new Map([
+    [ID, null],
+    [String, ""],
+    [Boolean, false],
+    [Date, dayjs(/* @__PURE__ */ new Date(-1))],
+    [Int, 0],
+    [Float, 0],
+    [JSON2, {}],
+    [Map, {}]
+  ]);
+  var scalarDefaultMap = /* @__PURE__ */ new Map([
+    [ID, null],
+    [String, ""],
+    [Boolean, false],
+    [Date, dayjs(/* @__PURE__ */ new Date(-1))],
+    [Int, 0],
+    [Float, 0],
+    [JSON2, {}]
+  ]);
+  var isGqlScalar = (modelRef) => scalarSet.has(modelRef);
+  var isGqlMap = (modelRef) => modelRef === Map;
+
+  // pkgs/@akanjs/client/src/types.ts
+  var import_clsx = __require("clsx");
+
+  // pkgs/@akanjs/client/src/csrTypes.ts
+  var import_react2 = __require("react");
+  var DEFAULT_TOP_INSET = 48;
+  var DEFAULT_BOTTOM_INSET = 60;
+  var defaultPageState = {
+    transition: "none",
+    topSafeArea: 0,
+    bottomSafeArea: 0,
+    topInset: 0,
+    bottomInset: 0,
+    gesture: true,
+    cache: false
+  };
+  var csrContext = (0, import_react2.createContext)({});
+  var pathContext = (0, import_react2.createContext)({});
+
+  // pkgs/@akanjs/common/src/splitVersion.ts
+  var splitVersion = (version2) => {
+    const [major, minor, patch] = version2.split(".");
+    return { major, minor, patch };
+  };
+
+  // pkgs/@akanjs/common/src/isDayjs.ts
+  var import_dayjs2 = __require("dayjs");
+
+  // pkgs/@akanjs/common/src/pathGet.ts
+  var pathGet = (path, obj, separator = ".") => {
+    const properties = Array.isArray(path) ? path : path.split(separator);
+    return properties.reduce((prev, curr) => prev[curr], obj);
+  };
+
+  // pkgs/@akanjs/common/src/isQueryEqual.ts
+  var import_dayjs3 = __toESM(__require("dayjs"));
+
+  // pkgs/@akanjs/common/src/isValidDate.ts
+  var import_dayjs4 = __toESM(__require("dayjs"));
+  var import_customParseFormat = __toESM(__require("dayjs/plugin/customParseFormat"));
+  import_dayjs4.default.extend(import_customParseFormat.default);
+
+  // pkgs/@akanjs/common/src/mergeVersion.ts
+  var mergeVersion = (major, minor, patch) => `${major}.${minor}.${patch}`;
+
+  // pkgs/@akanjs/common/src/pluralize.ts
+  var import_pluralize = __toESM(__require("pluralize"));
+
+  // pkgs/@akanjs/common/src/Logger.ts
+  var import_dayjs5 = __toESM(__require("dayjs"));
+  var logLevels = ["trace", "verbose", "debug", "log", "info", "warn", "error"];
+  var clc = {
+    bold: (text) => `\x1B[1m${text}\x1B[0m`,
+    green: (text) => `\x1B[32m${text}\x1B[39m`,
+    yellow: (text) => `\x1B[33m${text}\x1B[39m`,
+    red: (text) => `\x1B[31m${text}\x1B[39m`,
+    magentaBright: (text) => `\x1B[95m${text}\x1B[39m`,
+    cyanBright: (text) => `\x1B[96m${text}\x1B[39m`
+  };
+  var colorizeMap = {
+    trace: clc.bold,
+    verbose: clc.cyanBright,
+    debug: clc.magentaBright,
+    log: clc.green,
+    info: clc.green,
+    warn: clc.yellow,
+    error: clc.red
+  };
+  var Logger = class _Logger {
+    static #ignoreCtxSet = /* @__PURE__ */ new Set([
+      "InstanceLoader",
+      "RoutesResolver",
+      "RouterExplorer",
+      "NestFactory",
+      "WebSocketsController",
+      "GraphQLModule",
+      "NestApplication"
+    ]);
+    static level = process.env.NEXT_PUBLIC_LOG_LEVEL ?? "log";
+    static #levelIdx = logLevels.findIndex((l) => l === process.env.NEXT_PUBLIC_LOG_LEVEL);
+    static #startAt = (0, import_dayjs5.default)();
+    static setLevel(level) {
+      this.level = level;
+      this.#levelIdx = logLevels.findIndex((l) => l === level);
+    }
+    name;
+    constructor(name) {
+      this.name = name;
+    }
+    trace(msg, context = "") {
+      if (_Logger.#levelIdx <= 0)
+        _Logger.#printMessages(this.name ?? "App", msg, context, "trace");
+    }
+    verbose(msg, context = "") {
+      if (_Logger.#levelIdx <= 1)
+        _Logger.#printMessages(this.name ?? "App", msg, context, "verbose");
+    }
+    debug(msg, context = "") {
+      if (_Logger.#levelIdx <= 2)
+        _Logger.#printMessages(this.name ?? "App", msg, context, "debug");
+    }
+    log(msg, context = "") {
+      if (_Logger.#levelIdx <= 3)
+        _Logger.#printMessages(this.name ?? "App", msg, context, "log");
+    }
+    info(msg, context = "") {
+      if (_Logger.#levelIdx <= 4)
+        _Logger.#printMessages(this.name ?? "App", msg, context, "info");
+    }
+    warn(msg, context = "") {
+      if (_Logger.#levelIdx <= 5)
+        _Logger.#printMessages(this.name ?? "App", msg, context, "warn");
+    }
+    error(msg, context = "") {
+      if (_Logger.#levelIdx <= 6)
+        _Logger.#printMessages(this.name ?? "App", msg, context, "error");
+    }
+    raw(msg, method) {
+      _Logger.rawLog(msg, method);
+    }
+    rawLog(msg, method) {
+      _Logger.rawLog(msg, method);
+    }
+    static trace(msg, context = "") {
+      if (_Logger.#levelIdx <= 0)
+        _Logger.#printMessages("App", msg, context, "trace");
+    }
+    static verbose(msg, context = "") {
+      if (_Logger.#levelIdx <= 1)
+        _Logger.#printMessages("App", msg, context, "verbose");
+    }
+    static debug(msg, context = "") {
+      if (_Logger.#levelIdx <= 2)
+        _Logger.#printMessages("App", msg, context, "debug");
+    }
+    static log(msg, context = "") {
+      if (_Logger.#levelIdx <= 3)
+        _Logger.#printMessages("App", msg, context, "log");
+    }
+    static info(msg, context = "") {
+      if (_Logger.#levelIdx <= 4)
+        _Logger.#printMessages("App", msg, context, "info");
+    }
+    static warn(msg, context = "") {
+      if (_Logger.#levelIdx <= 5)
+        _Logger.#printMessages("App", msg, context, "warn");
+    }
+    static error(msg, context = "") {
+      if (_Logger.#levelIdx <= 6)
+        _Logger.#printMessages("App", msg, context, "error");
+    }
+    static #colorize(msg, logLevel) {
+      return colorizeMap[logLevel](msg);
+    }
+    static #printMessages(name, content, context, logLevel, writeStreamType = logLevel === "error" ? "stderr" : "stdout") {
+      if (this.#ignoreCtxSet.has(context))
+        return;
+      const now = (0, import_dayjs5.default)();
+      const processMsg = this.#colorize(
+        `[${name ?? "App"}] ${global.process?.pid ?? "window"} -`,
+        logLevel
+      );
+      const timestampMsg = now.format("MM/DD/YYYY, HH:mm:ss A");
+      const logLevelMsg = this.#colorize(logLevel.toUpperCase().padStart(7, " "), logLevel);
+      const contextMsg = context ? clc.yellow(`[${context}] `) : "";
+      const contentMsg = this.#colorize(content, logLevel);
+      const timeDiffMsg = clc.yellow(`+${now.diff(_Logger.#startAt, "ms")}ms`);
+      if (typeof window === "undefined")
+        process[writeStreamType].write(
+          `${processMsg} ${timestampMsg} ${logLevelMsg} ${contextMsg} ${contentMsg} ${timeDiffMsg}
+`
+        );
+      else
+        console.log(`${processMsg} ${timestampMsg} ${logLevelMsg} ${contextMsg} ${contentMsg} ${timeDiffMsg}
+`);
+    }
+    static rawLog(msg, method) {
+      this.raw(`${msg}
+`, method);
+    }
+    static raw(msg, method) {
+      if (typeof window === "undefined" && method !== "console" && global.process)
+        global.process.stdout.write(msg);
+      else
+        console.log(msg);
+    }
+  };
+
+  // pkgs/@akanjs/common/src/lowerlize.ts
+  var lowerlize = (str) => {
+    return str.charAt(0).toLowerCase() + str.slice(1);
+  };
+
+  // pkgs/@akanjs/common/src/sleep.ts
+  var sleep = async (ms) => {
+    return new Promise((resolve) => {
+      setTimeout(() => {
+        resolve(true);
+      }, ms);
+    });
+  };
+
+  // pkgs/@akanjs/client/src/router.ts
+  var import_navigation = __require("next/navigation");
+  var getPathInfo = (href, lang, prefix) => {
+    const langLength = lang.length + 1;
+    const pathWithSubRoute = href === `/${lang}` ? "/" : href.startsWith(`/${lang}/`) ? href.slice(langLength) : href;
+    const prefixLength = prefix ? prefix.length + 1 : 0;
+    const path = !prefixLength ? pathWithSubRoute : pathWithSubRoute === `/${prefix}` ? "/" : pathWithSubRoute.startsWith(`/${prefix}`) ? pathWithSubRoute.slice(prefixLength) : pathWithSubRoute;
+    const subRoute = prefix ? `/${prefix}` : "";
+    const pathname = path.startsWith("http") ? path : path === "/" ? `/${lang}${subRoute}` : `/${lang}${subRoute}${path}`;
+    return { path, pathname };
+  };
+  var Router = class {
+    isInitialized = false;
+    #prefix = "";
+    #lang = "en";
+    #instance = {
+      push: (href) => {
+        const { pathname } = this.#getPathInfo(href);
+        Logger.log(`push to:${pathname}`);
+        if (baseClientEnv.side === "server")
+          void (0, import_navigation.redirect)(pathname);
+      },
+      replace: (href) => {
+        const { pathname } = this.#getPathInfo(href);
+        Logger.log(`replace to:${pathname}`);
+        if (baseClientEnv.side === "server")
+          void (0, import_navigation.redirect)(pathname);
+      },
+      back: () => {
+        throw new Error("back is only available in client");
+      },
+      refresh: () => {
+        throw new Error("refresh is only available in client");
+      }
+    };
+    init(options) {
+      this.#prefix = options.prefix ?? "";
+      this.#lang = options.lang ?? "en";
+      if (options.type === "csr")
+        this.#initCSRClientRouter(options);
+      else if (options.side === "server")
+        this.#initNextServerRouter(options);
+      else
+        this.#initNextClientRouter(options);
+      this.isInitialized = true;
+      Logger.verbose("Router initialized");
+    }
+    #initNextServerRouter(options) {
+    }
+    #initNextClientRouter(options) {
+      this.#instance = {
+        push: (href) => {
+          const { path, pathname } = this.#getPathInfo(href);
+          this.#postPathChange({ path, pathname });
+          options.router.push(pathname);
+        },
+        replace: (href) => {
+          const { path, pathname } = this.#getPathInfo(href);
+          this.#postPathChange({ path, pathname });
+          options.router.replace(pathname);
+        },
+        back: () => {
+          const { path, pathname } = this.#getPathInfo(document.referrer);
+          this.#postPathChange({ path, pathname });
+          options.router.back();
+        },
+        refresh: () => {
+          const { path, pathname } = this.#getPathInfo(location.pathname);
+          this.#postPathChange({ path, pathname });
+          options.router.refresh();
+        }
+      };
+    }
+    #initCSRClientRouter(options) {
+      this.#instance = {
+        push: (href) => {
+          const { path, pathname } = this.#getPathInfo(href);
+          if (location.pathname === pathname)
+            return;
+          this.#postPathChange({ path, pathname });
+          options.router.push(pathname);
+        },
+        replace: (href) => {
+          const { path, pathname } = this.#getPathInfo(href);
+          if (location.pathname === pathname)
+            return;
+          this.#postPathChange({ path, pathname });
+          options.router.replace(pathname);
+        },
+        back: () => {
+          const { path, pathname } = this.#getPathInfo(document.referrer);
+          if (location.pathname === pathname)
+            return;
+          this.#postPathChange({ path, pathname });
+          options.router.back();
+        },
+        refresh: () => {
+          const { path, pathname } = this.#getPathInfo(location.pathname);
+          this.#postPathChange({ path, pathname });
+          options.router.refresh();
+        }
+      };
+    }
+    #checkInitialized() {
+      if (!this.isInitialized)
+        throw new Error("Router is not initialized");
+    }
+    #getPathInfo(href, prefix = this.#prefix) {
+      return getPathInfo(href, this.#lang, prefix);
+    }
+    #postPathChange({ path, pathname }) {
+      Logger.log(`pathChange-start:${path}`);
+      window.parent.postMessage({ type: "pathChange", path, pathname }, "*");
+    }
+    push(href) {
+      this.#checkInitialized();
+      this.#instance.push(href);
+      return void 0;
+    }
+    replace(href) {
+      this.#checkInitialized();
+      this.#instance.replace(href);
+      return void 0;
+    }
+    back() {
+      if (baseClientEnv.side === "server")
+        throw new Error("back is only available in client side");
+      this.#checkInitialized();
+      this.#instance.back();
+      return void 0;
+    }
+    refresh() {
+      if (baseClientEnv.side === "server")
+        throw new Error("refresh is only available in client side");
+      this.#checkInitialized();
+      this.#instance.refresh();
+      return void 0;
+    }
+    async redirect(href) {
+      if (baseClientEnv.side === "server") {
+        const nextHeaders = __require("next/headers");
+        const headers2 = await nextHeaders.headers?.() ?? /* @__PURE__ */ new Map();
+        const lang = headers2.get("x-locale") ?? this.#lang;
+        const basePath = headers2.get("x-base-path");
+        const { pathname } = getPathInfo(href, lang, basePath ?? "");
+        Logger.log(`redirect to:${pathname}`);
+        (0, import_navigation.redirect)(pathname);
+      } else {
+        const { pathname } = getPathInfo(href, this.#lang, this.#prefix);
+        this.#instance.replace(pathname);
+      }
+      return void 0;
+    }
+    notFound() {
+      this.#checkInitialized();
+      if (baseClientEnv.side === "server") {
+        Logger.log(`redirect to:/404`);
+        (0, import_navigation.notFound)();
+      } else
+        this.#instance.replace("/404");
+      return void 0;
+    }
+    setLang(lang) {
+      if (baseClientEnv.side === "server")
+        throw new Error("setLang is only available in client side");
+      this.#checkInitialized();
+      const { path } = getPathInfo(window.location.pathname, this.#lang, this.#prefix);
+      this.#lang = lang;
+      this.#instance.replace(`/${lang}${path}`);
+      return void 0;
+    }
+    getPath(pathname = window.location.pathname) {
+      if (baseClientEnv.side === "server")
+        throw new Error("getPath is only available in client side");
+      const { path } = getPathInfo(pathname, this.#lang, this.#prefix);
+      return path;
+    }
+    getFullPath(withLang = true) {
+      if (baseClientEnv.side === "server")
+        throw new Error("getPath is only available in client side");
+      return `${withLang ? `/${this.#lang}` : ""}/${this.#prefix}${this.getPath()}`;
+    }
+    getPrefix() {
+      return this.#prefix;
+    }
+    getPrefixedPath(path) {
+      return this.#prefix ? `${this.#lang ? `/${this.#lang}` : ""}/${this.#prefix}${path}` : path;
+    }
+  };
+  var router = new Router();
+
+  // pkgs/@akanjs/signal/src/client.ts
+  var import_core = __require("@urql/core");
+  var import_socket = __require("socket.io-client");
+  var SocketIo = class {
+    socket;
+    roomSubscribeMap = /* @__PURE__ */ new Map();
+    constructor(uri) {
+      this.socket = (0, import_socket.io)(uri, { transports: ["websocket"] });
+      this.socket.on("connect", () => {
+        this.roomSubscribeMap.forEach((option) => {
+          this.socket.emit(option.key, { ...option.message, __subscribe__: true });
+        });
+      });
+    }
+    on(event, callback) {
+      this.socket.on(event, callback);
+    }
+    removeListener(event, callback) {
+      this.socket.removeListener(event, callback);
+    }
+    removeAllListeners() {
+      this.socket.removeAllListeners();
+    }
+    hasListeners(event) {
+      return this.socket.hasListeners(event);
+    }
+    emit(key, data) {
+      this.socket.emit(key, data);
+    }
+    subscribe(option) {
+      if (!this.roomSubscribeMap.has(option.roomId)) {
+        this.roomSubscribeMap.set(option.roomId, option);
+        this.socket.emit(option.key, { ...option.message, __subscribe__: true });
+      }
+      this.socket.on(option.roomId, option.handleEvent);
+    }
+    unsubscribe(roomId, handleEvent) {
+      this.socket.removeListener(roomId, handleEvent);
+      const option = this.roomSubscribeMap.get(roomId);
+      if (this.hasListeners(roomId) || !option)
+        return;
+      this.roomSubscribeMap.delete(roomId);
+      this.socket.emit(option.key, { ...option.message, __subscribe__: false });
+    }
+    disconnect() {
+      this.socket.disconnect();
+      return this;
+    }
+  };
+  var Client = class _Client {
+    static globalIoMap = /* @__PURE__ */ new Map();
+    static tokenStore = /* @__PURE__ */ new Map();
+    async waitUntilWebSocketConnected(ws = baseClientEnv.serverWsUri) {
+      if (baseClientEnv.side === "server")
+        return true;
+      while (!this.getIo(ws).socket.connected) {
+        Logger.verbose("waiting for websocket to initialize...");
+        await sleep(300);
+      }
+    }
+    isInitialized = false;
+    uri = baseClientEnv.serverGraphqlUri;
+    ws = baseClientEnv.serverWsUri;
+    udp = null;
+    gql = (0, import_core.createClient)({ url: this.uri, fetch, exchanges: [import_core.cacheExchange, import_core.fetchExchange] });
+    jwt = null;
+    async getJwt() {
+      const isNextServer = baseClientEnv.side === "server" && baseEnv.operationType === "client";
+      if (isNextServer) {
+        const nextHeaders = __require("next/headers");
+        return (await nextHeaders.cookies?.())?.get("jwt")?.value ?? (await nextHeaders.headers?.())?.get("jwt") ?? this.jwt ?? null;
+      } else
+        return _Client.tokenStore.get(this) ?? null;
+    }
+    io = null;
+    init(data = {}) {
+      Object.assign(this, data);
+      this.setLink(data.uri);
+      this.setIo(data.ws);
+      this.isInitialized = true;
+    }
+    setIo(ws = baseClientEnv.serverWsUri) {
+      this.ws = ws;
+      const existingIo = _Client.globalIoMap.get(ws);
+      if (existingIo) {
+        this.io = existingIo;
+        return;
+      }
+      this.io = new SocketIo(ws);
+      _Client.globalIoMap.set(ws, this.io);
+    }
+    getIo(ws = baseClientEnv.serverWsUri) {
+      const existingIo = _Client.globalIoMap.get(ws);
+      if (existingIo)
+        return existingIo;
+      const io2 = new SocketIo(ws);
+      _Client.globalIoMap.set(ws, io2);
+      return io2;
+    }
+    setLink(uri = baseClientEnv.serverGraphqlUri) {
+      this.uri = uri;
+      this.gql = (0, import_core.createClient)({
+        url: this.uri,
+        fetch,
+        exchanges: [import_core.cacheExchange, import_core.fetchExchange],
+        // requestPolicy: "network-only",
+        fetchOptions: () => {
+          return {
+            headers: {
+              "apollo-require-preflight": "true",
+              ...this.jwt ? { authorization: `Bearer ${this.jwt}` } : {}
+            }
+          };
+        }
+      });
+    }
+    setJwt(jwt) {
+      _Client.tokenStore.set(this, jwt);
+    }
+    reset() {
+      this.io?.disconnect();
+      this.io = null;
+      this.jwt = null;
+    }
+    clone(data = {}) {
+      const newClient = new _Client();
+      newClient.init({ ...this, ...data });
+      if (data.jwt)
+        _Client.tokenStore.set(newClient, data.jwt);
+      return newClient;
+    }
+    terminate() {
+      this.reset();
+      _Client.globalIoMap.forEach((io2) => io2.disconnect());
+      this.isInitialized = false;
+    }
+    setUdp(udp) {
+      this.udp = udp;
+    }
+  };
+  var client = new Client();
+
+  // pkgs/@akanjs/constant/src/scalar.ts
+  var import_reflect_metadata = __require("reflect-metadata");
+  var scalarExampleMap = /* @__PURE__ */ new Map([
+    [ID, "1234567890abcdef12345678"],
+    [Int, 0],
+    [Float, 0],
+    [String, "String"],
+    [Boolean, true],
+    [Date, (/* @__PURE__ */ new Date()).toISOString()],
+    [Upload, "FileUpload"],
+    [JSON2, {}],
+    [Map, {}]
+  ]);
+  var getClassMeta = (modelRef) => {
+    const [target] = getNonArrayModel(modelRef);
+    const classMeta = Reflect.getMetadata("class", target.prototype);
+    if (!classMeta)
+      throw new Error(`No ClassMeta for this target ${target.name}`);
+    return classMeta;
+  };
+  var getFieldMetas = (modelRef) => {
+    const [target] = getNonArrayModel(modelRef);
+    const metadataMap = Reflect.getMetadata("fields", target.prototype) ?? /* @__PURE__ */ new Map();
+    const keySortMap = { id: -1, createdAt: 1, updatedAt: 2, removedAt: 3 };
+    return [...metadataMap.values()].sort((a, b) => (keySortMap[a.key] ?? 0) - (keySortMap[b.key] ?? 0));
+  };
+  var getFieldMetaMapOnPrototype = (prototype) => {
+    const metadataMap = Reflect.getMetadata("fields", prototype) ?? /* @__PURE__ */ new Map();
+    return new Map(metadataMap);
+  };
+  var setFieldMetaMapOnPrototype = (prototype, metadataMap) => {
+    Reflect.defineMetadata("fields", new Map(metadataMap), prototype);
+  };
+
+  // pkgs/@akanjs/constant/src/fieldMeta.ts
+  var applyFieldMeta = (modelRef, arrDepth, option, optionArrDepth) => {
+    const isArray = arrDepth > 0;
+    const isClass = !isGqlScalar(modelRef);
+    const isMap = isGqlMap(modelRef);
+    const { refName, type } = isClass ? getClassMeta(modelRef) : { refName: "", type: "scalar" };
+    const name = isClass ? refName : scalarNameMap.get(modelRef) ?? "Unknown";
+    if (isMap && !option.of)
+      throw new Error("Map type must have 'of' option");
+    return (prototype, key) => {
+      const metadata = {
+        nullable: option.nullable ?? false,
+        ref: option.ref,
+        refPath: option.refPath,
+        refType: option.refType,
+        default: option.default ?? (isArray ? [] : null),
+        type: option.type,
+        fieldType: option.fieldType ?? "property",
+        immutable: option.immutable ?? false,
+        min: option.min,
+        max: option.max,
+        enum: option.enum,
+        select: option.select ?? true,
+        minlength: option.minlength,
+        maxlength: option.maxlength,
+        query: option.query,
+        accumulate: option.accumulate,
+        example: option.example,
+        validate: option.validate,
+        key,
+        name,
+        isClass,
+        isScalar: type === "scalar",
+        modelRef,
+        arrDepth,
+        isArray,
+        optArrDepth: optionArrDepth,
+        isMap,
+        of: option.of,
+        text: option.text
+      };
+      const metadataMap = getFieldMetaMapOnPrototype(prototype);
+      metadataMap.set(key, metadata);
+      setFieldMetaMapOnPrototype(prototype, metadataMap);
+    };
+  };
+  var makeField = (customOption) => (returns, fieldOption) => {
+    const [modelRef, arrDepth] = getNonArrayModel(returns());
+    if (!fieldOption)
+      return applyFieldMeta(modelRef, arrDepth, { ...customOption }, arrDepth);
+    const [opt, optArrDepth] = getNonArrayModel(fieldOption);
+    return applyFieldMeta(modelRef, arrDepth, { ...opt, ...customOption }, optArrDepth);
+  };
+  var Field = {
+    Prop: makeField({ fieldType: "property" }),
+    Hidden: makeField({ fieldType: "hidden", nullable: true }),
+    Secret: makeField({ fieldType: "hidden", select: false, nullable: true }),
+    Resolve: makeField({ fieldType: "resolve" })
+  };
+
+  // pkgs/@akanjs/constant/src/constantDecorator.ts
+  var import_reflect_metadata2 = __require("reflect-metadata");
+
+  // pkgs/@akanjs/constant/src/filterMeta.ts
+  var setFilterMeta = (filterRef, filterMeta) => {
+    const existingFilterMeta = Reflect.getMetadata("filter", filterRef.prototype);
+    if (existingFilterMeta)
+      Object.assign(filterMeta.sort, existingFilterMeta.sort);
+    Reflect.defineMetadata("filter", filterMeta, filterRef.prototype);
+  };
+  var getFilterKeyMetaMapOnPrototype = (prototype) => {
+    const metadataMap = Reflect.getMetadata("filterKey", prototype) ?? /* @__PURE__ */ new Map();
+    return new Map(metadataMap);
+  };
+  var setFilterKeyMetaMapOnPrototype = (prototype, metadataMap) => {
+    Reflect.defineMetadata("filterKey", new Map(metadataMap), prototype);
+  };
+  var applyFilterKeyMeta = (option) => {
+    return (prototype, key, descriptor) => {
+      const metadata = { key, ...option, descriptor };
+      const metadataMap = getFilterKeyMetaMapOnPrototype(prototype);
+      metadataMap.set(key, metadata);
+      setFilterKeyMetaMapOnPrototype(prototype, metadataMap);
+    };
+  };
+  var makeFilter = (customOption) => (fieldOption) => {
+    return applyFilterKeyMeta({ ...customOption, ...fieldOption });
+  };
+  var getFilterArgMetasOnPrototype = (prototype, key) => {
+    const filterArgMetas = Reflect.getMetadata("filterArg", prototype, key) ?? [];
+    return filterArgMetas;
+  };
+  var setFilterArgMetasOnPrototype = (prototype, key, filterArgMetas) => {
+    Reflect.defineMetadata("filterArg", filterArgMetas, prototype, key);
+  };
+  var applyFilterArgMeta = (name, returns, argOption) => {
+    return (prototype, key, idx) => {
+      const [modelRef, arrDepth] = getNonArrayModel(returns());
+      const [opt, optArrDepth] = getNonArrayModel(argOption ?? {});
+      const filterArgMeta = { name, ...opt, modelRef, arrDepth, isArray: arrDepth > 0, optArrDepth };
+      const filterArgMetas = getFilterArgMetasOnPrototype(prototype, key);
+      filterArgMetas[idx] = filterArgMeta;
+      setFilterArgMetasOnPrototype(prototype, key, filterArgMetas);
+    };
+  };
+  var Filter = {
+    Mongo: makeFilter({ type: "mongo" }),
+    // Meili: makeFilter({ fieldType: "hidden", nullable: true }),
+    Arg: applyFilterArgMeta
+  };
+
+  // pkgs/@akanjs/constant/src/baseGql.ts
+  var import_reflect_metadata3 = __require("reflect-metadata");
+  var defaultFieldMeta = {
+    fieldType: "property",
+    immutable: false,
+    select: true,
+    isClass: false,
+    isScalar: true,
+    nullable: false,
+    isArray: false,
+    arrDepth: 0,
+    optArrDepth: 0,
+    default: null,
+    isMap: false
+  };
+  var idFieldMeta = { ...defaultFieldMeta, key: "id", name: "ID", modelRef: ID };
+  var createdAtFieldMeta = { ...defaultFieldMeta, key: "createdAt", name: "Date", modelRef: Date };
+  var updatedAtFieldMeta = { ...defaultFieldMeta, key: "updatedAt", name: "Date", modelRef: Date };
+  var removedAtFieldMeta = {
+    ...defaultFieldMeta,
+    key: "removedAt",
+    name: "Date",
+    modelRef: Date,
+    nullable: true,
+    default: null
+  };
+
+  // pkgs/@akanjs/constant/src/classMeta.ts
+  var import_reflect_metadata4 = __require("reflect-metadata");
+  var InputModelStorage = class {
+  };
+  var LightModelStorage = class {
+  };
+  var FullModelStorage = class {
+  };
+  var ScalarModelStorage = class {
+  };
+  var FilterModelStorage = class {
+  };
+  var hasTextField = (modelRef) => {
+    const fieldMetas = getFieldMetas(modelRef);
+    return fieldMetas.some(
+      (fieldMeta) => !!fieldMeta.text || fieldMeta.isScalar && fieldMeta.isClass && fieldMeta.select && hasTextField(fieldMeta.modelRef)
+    );
+  };
+  var applyClassMeta = (type, modelType, storage2) => {
+    return function(refName) {
+      return function(target) {
+        const modelRef = target;
+        const classMeta = { refName, type, modelType, modelRef, hasTextField: hasTextField(modelRef) };
+        Reflect.defineMetadata("class", classMeta, modelRef.prototype);
+        Reflect.defineMetadata(refName, modelRef, storage2.prototype);
+      };
+    };
+  };
+  var applyFilterMeta = (storage2) => {
+    return function(refName) {
+      return function(target) {
+        const modelRef = target;
+        setFilterMeta(modelRef, { refName, sort: {} });
+        Reflect.defineMetadata(refName, modelRef, storage2.prototype);
+      };
+    };
+  };
+  var Model = {
+    Light: applyClassMeta("light", "data", LightModelStorage),
+    Object: applyClassMeta("full", "ephemeral", FullModelStorage),
+    Full: applyClassMeta("full", "data", FullModelStorage),
+    Input: applyClassMeta("input", "data", InputModelStorage),
+    Scalar: applyClassMeta("scalar", "data", ScalarModelStorage),
+    Summary: applyClassMeta("scalar", "summary", ScalarModelStorage),
+    Insight: applyClassMeta("scalar", "insight", ScalarModelStorage),
+    Filter: applyFilterMeta(FilterModelStorage)
+  };
+
+  // pkgs/@akanjs/signal/src/immerify.ts
+  var import_immer = __require("immer");
+
+  // pkgs/@akanjs/signal/src/signalDecorators.ts
+  var import_reflect_metadata5 = __require("reflect-metadata");
+  var createArgMetaDecorator = (type) => {
+    return function(option = {}) {
+      return function(prototype, key, idx) {
+        const argMetas = getArgMetasOnPrototype(prototype, key);
+        argMetas[idx] = { key, idx, type, option };
+        setArgMetasOnPrototype(prototype, key, argMetas);
+      };
+    };
+  };
+  var Account = createArgMetaDecorator("Account");
+  var defaultAccount = {
+    __InternalArg__: "Account",
+    appName: baseEnv.appName,
+    environment: baseEnv.environment
+  };
+  var Self = createArgMetaDecorator("Self");
+  var Me = createArgMetaDecorator("Me");
+  var UserIp = createArgMetaDecorator("UserIp");
+  var Access = createArgMetaDecorator("Access");
+  var Req = createArgMetaDecorator("Req");
+  var Res = createArgMetaDecorator("Res");
+  var Ws = createArgMetaDecorator("Ws");
+  var Job = createArgMetaDecorator("Job");
+  var getQuery = (allow) => function(returns, signalOption = {}, guards = []) {
+    return (prototype, key, descriptor) => {
+      const metadataMap = getGqlMetaMapOnPrototype(prototype);
+      metadataMap.set(key, {
+        returns,
+        signalOption,
+        key,
+        descriptor,
+        guards: [allow, ...guards],
+        type: "Query"
+      });
+      setGqlMetaMapOnPrototype(prototype, metadataMap);
+    };
+  };
+  var getMutation = (allow) => function(returns, signalOption = {}, guards = []) {
+    return (prototype, key, descriptor) => {
+      const metadataMap = getGqlMetaMapOnPrototype(prototype);
+      metadataMap.set(key, {
+        returns,
+        signalOption,
+        key,
+        descriptor,
+        guards: [allow, ...guards],
+        type: "Mutation"
+      });
+      setGqlMetaMapOnPrototype(prototype, metadataMap);
+    };
+  };
+  var getMessage = (allow) => function(returns, signalOption = {}, guards = []) {
+    return (prototype, key, descriptor) => {
+      const metadataMap = getGqlMetaMapOnPrototype(prototype);
+      metadataMap.set(key, {
+        returns,
+        signalOption,
+        key,
+        descriptor,
+        guards: [allow, ...guards],
+        type: "Message"
+      });
+      setGqlMetaMapOnPrototype(prototype, metadataMap);
+    };
+  };
+  var getPubsub = (allow) => function(returns, signalOption = {}, guards = []) {
+    return (prototype, key, descriptor) => {
+      const metadataMap = getGqlMetaMapOnPrototype(prototype);
+      metadataMap.set(key, {
+        returns,
+        signalOption,
+        key,
+        descriptor,
+        guards: [allow, ...guards],
+        type: "Pubsub"
+      });
+      setGqlMetaMapOnPrototype(prototype, metadataMap);
+    };
+  };
+  var getProcess = (serverType) => function(returns, signalOption = {}) {
+    return (prototype, key, descriptor) => {
+      const metadataMap = getGqlMetaMapOnPrototype(prototype);
+      metadataMap.set(key, {
+        returns,
+        signalOption: { ...signalOption, serverType: lowerlize(serverType) },
+        key,
+        descriptor,
+        guards: ["None"],
+        type: "Process"
+      });
+      setGqlMetaMapOnPrototype(prototype, metadataMap);
+    };
+  };
+  var Query = {
+    Public: getQuery("Public"),
+    Every: getQuery("Every"),
+    Admin: getQuery("Admin"),
+    User: getQuery("User"),
+    SuperAdmin: getQuery("SuperAdmin"),
+    None: getQuery("None"),
+    Owner: getQuery("Owner")
+  };
+  var Mutation = {
+    Public: getMutation("Public"),
+    Every: getMutation("Every"),
+    Admin: getMutation("Admin"),
+    User: getMutation("User"),
+    SuperAdmin: getMutation("SuperAdmin"),
+    None: getMutation("None"),
+    Owner: getMutation("Owner")
+  };
+  var Message = {
+    Public: getMessage("Public"),
+    Every: getMessage("Every"),
+    Admin: getMessage("Admin"),
+    User: getMessage("User"),
+    SuperAdmin: getMessage("SuperAdmin"),
+    None: getMessage("None"),
+    Owner: getMessage("Owner")
+  };
+  var Pubsub = {
+    Public: getPubsub("Public"),
+    Every: getPubsub("Every"),
+    Admin: getPubsub("Admin"),
+    User: getPubsub("User"),
+    SuperAdmin: getPubsub("SuperAdmin"),
+    None: getPubsub("None"),
+    Owner: getPubsub("Owner")
+  };
+  var Process = {
+    Federation: getProcess("Federation"),
+    Batch: getProcess("Batch"),
+    All: getProcess("All")
+  };
+  var getArg = (type) => function(name, returns, argsOption = {}) {
+    return function(prototype, key, idx) {
+      const argMetas = getArgMetasOnPrototype(prototype, key);
+      argMetas[idx] = { name, returns, argsOption, key, idx, type };
+      setArgMetasOnPrototype(prototype, key, argMetas);
+    };
+  };
+  var Arg = {
+    Body: getArg("Body"),
+    Param: getArg("Param"),
+    Query: getArg("Query"),
+    Upload: getArg("Upload"),
+    Msg: getArg("Msg"),
+    Room: getArg("Room")
+  };
+  var getGqlMetaMapOnPrototype = (prototype) => {
+    const gqlMetaMap = Reflect.getMetadata("gql", prototype);
+    return gqlMetaMap ?? /* @__PURE__ */ new Map();
+  };
+  var setGqlMetaMapOnPrototype = (prototype, gqlMetaMap) => {
+    Reflect.defineMetadata("gql", gqlMetaMap, prototype);
+  };
+  var getArgMetasOnPrototype = (prototype, key) => {
+    return Reflect.getMetadata("args", prototype, key) ?? [];
+  };
+  var setArgMetasOnPrototype = (prototype, key, argMetas) => {
+    Reflect.defineMetadata("args", argMetas, prototype, key);
+  };
+
+  // pkgs/@akanjs/signal/src/baseFetch.ts
+  var nativeFetch = fetch;
+  var baseFetch = Object.assign(nativeFetch, {
+    client,
+    clone: function(option = {}) {
+      return {
+        ...this,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+        client: this.client.clone(option)
+      };
+    }
+  });
+
+  // pkgs/@akanjs/client/src/cookie.ts
+  var import_core2 = __require("@capacitor/core");
+  var import_js_cookie = __toESM(__require("js-cookie"));
+  var import_jwt_decode = __require("jwt-decode");
+  var import_react3 = __toESM(__require("react"));
+
+  // pkgs/@akanjs/client/src/storage.ts
+  var import_preferences = __require("@capacitor/preferences");
+  var storage = {
+    getItem: async (key) => {
+      if (baseClientEnv.side === "server")
+        return;
+      if (baseClientEnv.renderMode === "ssr")
+        return localStorage.getItem(key);
+      else
+        return (await import_preferences.Preferences.get({ key })).value;
+    },
+    setItem: async (key, value) => {
+      if (baseClientEnv.side === "server")
+        return;
+      if (baseClientEnv.renderMode === "ssr") {
+        localStorage.setItem(key, value);
+        return;
+      } else {
+        await import_preferences.Preferences.set({ key, value });
+        return;
+      }
+    },
+    removeItem: (key) => {
+      if (baseClientEnv.side === "server")
+        return;
+      if (baseClientEnv.renderMode === "ssr") {
+        localStorage.removeItem(key);
+        return;
+      } else
+        return import_preferences.Preferences.remove({ key });
+    }
+  };
+
+  // pkgs/@akanjs/client/src/cookie.ts
+  var cookies = baseClientEnv.side === "server" ? () => {
+    const nextHeaders = __require("next/headers");
+    const cookies2 = nextHeaders.cookies();
+    return import_react3.default.use(cookies2);
+  } : () => {
+    const cookie = import_js_cookie.default.get();
+    return new Map(
+      Object.entries(cookie).map(([key, value]) => [
+        key,
+        {
+          name: key,
+          value: typeof value === "string" && value.startsWith("j:") ? JSON.parse(value.slice(2)) : value
+        }
+      ])
+    );
+  };
+  var setCookie = (key, value, options = { path: "/", sameSite: "none", secure: true }) => {
+    if (baseClientEnv.side === "server")
+      return;
+    else
+      void import_core2.CapacitorCookies.setCookie({ key, value });
+  };
+  var headers = baseClientEnv.side === "server" ? () => import_react3.default.use(__require("next/headers").headers()) : () => /* @__PURE__ */ new Map();
+  var getHeader = (key) => {
+    return headers().get(key);
+  };
+  var setAuth = ({ jwt }) => {
+    client.setJwt(jwt);
+    setCookie("jwt", jwt);
+    void storage.setItem("jwt", jwt);
+  };
+  var initAuth = ({ jwt } = {}) => {
+    const token = jwt ?? cookies().get("jwt")?.value;
+    if (token)
+      setAuth({ jwt: token });
+    client.init();
+    Logger.verbose(`JWT set from cookie: ${token}`);
+  };
+
+  // pkgs/@akanjs/client/src/device.ts
+  var import_device = __require("@capacitor/device");
+  var import_haptics = __require("@capacitor/haptics");
+  var import_keyboard = __require("@capacitor/keyboard");
+  var import_capacitor_plugin_safe_area = __require("capacitor-plugin-safe-area");
+  var import_react_device_detect = __require("react-device-detect");
+  var Device = class {
+    info;
+    lang;
+    topSafeArea;
+    bottomSafeArea;
+    isMobile = import_react_device_detect.isMobile;
+    #keyboard = import_keyboard.Keyboard;
+    #haptics = import_haptics.Haptics;
+    #pageContentRef = null;
+    async init({ lang, supportLanguages: supportLanguages2 = [] } = {}) {
+      const [
+        info,
+        { value: languageCode },
+        {
+          insets: { top: topSafeArea, bottom: bottomSafeArea }
+        }
+      ] = await Promise.all([import_device.Device.getInfo(), import_device.Device.getLanguageCode(), import_capacitor_plugin_safe_area.SafeArea.getSafeAreaInsets()]);
+      const predefinedLangPath = window.location.pathname.split("/")[1]?.split("?")[0];
+      const predefinedLang = supportLanguages2.find((language) => language === predefinedLangPath);
+      this.info = info;
+      this.lang = lang ?? predefinedLang ?? languageCode;
+      this.topSafeArea = topSafeArea;
+      this.bottomSafeArea = bottomSafeArea;
+    }
+    setPageContentRef(pageContentRef) {
+      this.#pageContentRef = pageContentRef;
+    }
+    async showKeyboard() {
+      if (this.info.platform === "web")
+        return;
+      await this.#keyboard.show();
+    }
+    async hideKeyboard() {
+      if (this.info.platform === "web")
+        return;
+      await this.#keyboard.hide();
+    }
+    listenKeyboardChanged(onKeyboardChanged) {
+      if (this.info.platform === "web")
+        return;
+      void this.#keyboard.addListener("keyboardWillShow", (keyboard) => {
+        onKeyboardChanged(keyboard.keyboardHeight);
+      });
+      void this.#keyboard.addListener("keyboardDidShow", (keyboard) => {
+        onKeyboardChanged(keyboard.keyboardHeight);
+      });
+      void this.#keyboard.addListener("keyboardWillHide", () => {
+        onKeyboardChanged(0);
+      });
+      void this.#keyboard.addListener("keyboardDidHide", () => {
+        onKeyboardChanged(0);
+      });
+    }
+    unlistenKeyboardChanged() {
+      if (this.info.platform === "web")
+        return;
+      void this.#keyboard.removeAllListeners();
+    }
+    async vibrate(type = "medium") {
+      if (typeof type === "number") {
+        await this.#haptics.vibrate({ duration: type });
+        return;
+      }
+      const handleImpact = {
+        light: async () => {
+          await this.#haptics.impact({ style: import_haptics.ImpactStyle.Light });
+        },
+        medium: async () => {
+          await this.#haptics.impact({ style: import_haptics.ImpactStyle.Medium });
+        },
+        heavy: async () => {
+          await this.#haptics.impact({ style: import_haptics.ImpactStyle.Heavy });
+        },
+        selectionStart: async () => {
+          await this.#haptics.selectionStart();
+        },
+        selectionChanged: async () => {
+          await this.#haptics.selectionChanged();
+        },
+        selectionEnd: async () => {
+          await this.#haptics.selectionEnd();
+        }
+      };
+      await handleImpact[type]();
+    }
+    getScrollTop() {
+      if (this.info.platform === "web")
+        return window.scrollY;
+      return this.#pageContentRef?.current?.scrollTop ?? 0;
+    }
+    setScrollTop(scrollTop) {
+      if (this.info.platform === "web") {
+        window.scrollTo({ top: scrollTop });
+        return;
+      }
+      return this.#pageContentRef?.current?.scrollTo({ top: scrollTop });
+    }
+  };
+  var device = new Device();
+
+  // pkgs/@akanjs/next/src/makePageProto.tsx
+  var getPageInfo = () => {
+    if (baseClientEnv.side !== "server") {
+      return {
+        locale: window.location.pathname.split("/")[1] ?? "en",
+        path: "/" + window.location.pathname.split("/").slice(2).join("/")
+      };
+    }
+    const locale = getHeader("x-locale") ?? "en";
+    const path = getHeader("x-path") ?? "/";
+    return { locale, path };
+  };
+  var langIdx = { en: 0, ko: 1, zhChs: 2, zhCht: 3 };
+  var dictionary = {};
+  var translator = (lang, key, param) => {
+    const idx = langIdx[lang];
+    try {
+      const msg = pathGet(key, dictionary)?.[idx];
+      if (!msg) {
+        Logger.error(`No translation for ${key}`);
+        return key;
+      }
+      return param ? msg.replace(/{([^}]+)}/g, (_, key2) => param[key2]) : msg;
+    } catch (e) {
+      return key;
+    }
+  };
+  translator.rich = (lang, key, param) => {
+    const idx = langIdx[lang];
+    const msg = pathGet(key, dictionary)?.[idx];
+    if (!msg) {
+      Logger.error(`No translation for ${key}`);
+      return key;
+    }
+    return param ? msg.replace(/{([^}]+)}/g, (_, key2) => param[key2]) : msg;
+  };
+  var makePageProto = (locales) => {
+    locales.forEach((locale) => {
+      Object.keys(locale).forEach((key) => dictionary[key] = Object.assign(dictionary[key] ?? {}, locale[key]));
+    });
+    return () => {
+      const { locale, path } = getPageInfo();
+      const lang = locale;
+      const l = (key, param) => translator(lang, key, param);
+      l.rich = (key, param) => /* @__PURE__ */ React.createElement(
+        "span",
+        {
+          dangerouslySetInnerHTML: {
+            __html: translator.rich(lang, key, {
+              ...param,
+              // strong: (chunks: string) => `<b>${chunks}</b>`,
+              // "bg-primary": (chunks: string) => `<span className="bg-primary text-base-100">${chunks}</span>`,
+              // primary: (chunks: string) => `<span className="bg-base-100 text-primary">${chunks}</span>`,
+              br: `<br />`
+            })
+          }
+        }
+      );
+      l.field = (model, field) => {
+        const key = `${model}.${field}`;
+        return l(key);
+      };
+      l.desc = (model, field) => {
+        const key = `${model}.desc-${field}`;
+        return l(key);
+      };
+      l.enum = (model, field, value) => {
+        const key = `${model}.enum-${field}-${value}`;
+        return l(key);
+      };
+      l.enumdesc = (model, field, value) => {
+        const key = `${model}.enumdesc-${field}-${value}`;
+        return l(key);
+      };
+      l.api = (model, endpoint) => {
+        const key = `${model}.api-${endpoint}`;
+        return l(key);
+      };
+      l.apidesc = (model, endpoint) => {
+        const key = `${model}.apidesc-${endpoint}`;
+        return l(key);
+      };
+      l.arg = (model, endpoint, arg) => {
+        const key = `${model}.arg-${endpoint}-${arg}`;
+        return l(key);
+      };
+      l.argdesc = (model, endpoint, arg) => {
+        const key = `${model}.argdesc-${endpoint}-${arg}`;
+        return l(key);
+      };
+      l.qry = (model, queryKey) => {
+        const key = `${model}.qry-${queryKey}`;
+        return l(key);
+      };
+      l.qrydesc = (model, queryKey) => {
+        const key = `${model}.qrydesc-${queryKey}`;
+        return l(key);
+      };
+      l.qarg = (model, queryKey, arg) => {
+        const key = `${model}.qarg-${queryKey}-${arg}`;
+        return l(key);
+      };
+      l.qargdesc = (model, queryKey, arg) => {
+        const key = `${model}.qargdesc-${queryKey}-${arg}`;
+        return l(key);
+      };
+      return { path, l, lang };
+    };
+  };
+
+  // pkgs/@akanjs/next/src/useDebounce.ts
+  var import_react4 = __require("react");
+  var debounce = (callback, wait = 500) => {
+    let timer;
+    return (...args) => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        callback(...args);
+      }, wait);
+    };
+  };
+  var useDebounce = (callback, states = [], wait = 100) => {
+    const fn = (0, import_react4.useCallback)(debounce(callback, wait), states);
+    return fn;
+  };
+
+  // pkgs/@akanjs/next/src/useInterval.ts
+  var import_react5 = __require("react");
+  var useInterval = (callback, delay) => {
+    const savedCallback = (0, import_react5.useRef)(null);
+    (0, import_react5.useEffect)(() => {
+      savedCallback.current = callback;
+    }, [callback]);
+    (0, import_react5.useEffect)(() => {
+      const tick = () => {
+        void savedCallback.current?.();
+      };
+      const id = setInterval(tick, delay);
+      return () => {
+        clearInterval(id);
+      };
+    }, [delay]);
+    return savedCallback;
+  };
+
+  // pkgs/@akanjs/next/src/bootCsr.tsx
+  var import_react10 = __toESM(__require("react"));
+  var ReactDOM = __toESM(__require("react-dom/client"));
+
+  // pkgs/@akanjs/next/src/useCsrValues.ts
+  var import_app = __require("@capacitor/app");
+  var import_web = __require("@react-spring/web");
+  var import_react8 = __require("@use-gesture/react");
+  var import_react9 = __require("react");
+
+  // pkgs/@akanjs/next/src/useHistory.ts
+  var import_react6 = __require("react");
+  var useHistory = (locations = []) => {
+    const history = (0, import_react6.useRef)({
+      type: "initial",
+      locations,
+      scrollMap: /* @__PURE__ */ new Map([[window.location.pathname, 0]]),
+      idxMap: /* @__PURE__ */ new Map([[window.location.pathname, 0]]),
+      cachedLocationMap: /* @__PURE__ */ new Map(),
+      idx: 0
+    });
+    const setHistoryForward = (0, import_react6.useCallback)(({ type, location: location2, scrollTop = 0 }) => {
+      history.current.type = "forward";
+      history.current.scrollMap.set(location2.pathname, scrollTop);
+      history.current.idxMap.set(location2.pathname, history.current.idx);
+      if (type === "push")
+        history.current.locations = [...history.current.locations.slice(0, history.current.idx + 1), location2];
+      else if (type === "replace")
+        history.current.locations = [...history.current.locations.slice(0, history.current.idx), location2];
+      if (location2.pathRoute.pageState.cache)
+        history.current.cachedLocationMap.set(location2.pathRoute.path, location2);
+      if (type === "push" || type === "popForward")
+        history.current.idx++;
+    }, []);
+    const setHistoryBack = (0, import_react6.useCallback)(({ location: location2, scrollTop = 0 }) => {
+      history.current.type = "back";
+      history.current.scrollMap.set(location2.pathname, scrollTop);
+      history.current.idxMap.set(location2.pathname, history.current.idx);
+      if (location2.pathRoute.pageState.cache)
+        history.current.cachedLocationMap.set(location2.pathRoute.path, location2);
+      history.current.idx--;
+    }, []);
+    const getCurrentLocation = (0, import_react6.useCallback)(() => {
+      return history.current.locations[history.current.idx];
+    }, []);
+    const getPrevLocation = (0, import_react6.useCallback)(() => {
+      return history.current.locations[history.current.idx - 1] ?? null;
+    }, []);
+    const getScrollTop = (0, import_react6.useCallback)((pathname = history.current.locations[history.current.idx]?.pathname ?? "/") => {
+      return history.current.scrollMap.get(pathname) ?? 0;
+    }, []);
+    return { history, setHistoryForward, setHistoryBack, getCurrentLocation, getPrevLocation, getScrollTop };
+  };
+
+  // pkgs/@akanjs/next/src/useLocation.ts
+  var import_react7 = __require("react");
+  var useLocation = ({ rootRouteGuide }) => {
+    const getLocation = (0, import_react7.useCallback)((href) => {
+      const getPathSegments = (pathname2) => {
+        return [
+          ...pathname2.split("/").filter((pathSegment) => !!pathSegment).map((pathSegment) => `/${pathSegment}`)
+        ];
+      };
+      const getPathRoute = (pathname2) => {
+        const pathSegments = getPathSegments(pathname2);
+        const getTargetRouteGuide = (pathSegments2, routeGuide) => {
+          const pathSegment = pathSegments2.shift();
+          if (!pathSegment)
+            return routeGuide;
+          const childrenSegments = Object.keys(routeGuide.children);
+          const matchingPathSegment = childrenSegments.find((segment) => segment === pathSegment);
+          const paramSegment = childrenSegments.find((segment) => segment.startsWith("/:"));
+          const childRouteGuide = matchingPathSegment ? routeGuide.children[pathSegment] : paramSegment ? routeGuide.children[paramSegment] : null;
+          if (!childRouteGuide)
+            throw new Error("404");
+          return getTargetRouteGuide(pathSegments2, childRouteGuide);
+        };
+        const targetRouteGuide = getTargetRouteGuide(pathSegments, rootRouteGuide);
+        const pathRoute2 = targetRouteGuide.pathRoute;
+        if (!pathRoute2) {
+          window.location.assign("/404");
+          throw new Error("404");
+        }
+        return pathRoute2;
+      };
+      const getParams = (pathname2, pathRoute2) => {
+        const pathSegments = getPathSegments(pathname2);
+        return pathRoute2.pathSegments.reduce((params2, pathSegment, idx) => {
+          if (pathSegment.startsWith("/:"))
+            params2[pathSegment.slice(2)] = pathSegments[idx - 1].slice(1);
+          return params2;
+        }, {});
+      };
+      const getSearchParams = (search2) => {
+        return [...new URLSearchParams(search2).entries()].reduce(
+          (params2, [key, value]) => {
+            params2[key] = params2[key] ? [...Array.isArray(params2[key]) ? params2[key] : [params2[key]], value] : value;
+            return params2;
+          },
+          {}
+        );
+      };
+      const [pathname, search] = href.split("?");
+      const pathRoute = getPathRoute(pathname);
+      const params = getParams(pathname, pathRoute);
+      const searchParams = getSearchParams(search);
+      return { pathname, search, params, searchParams, pathRoute };
+    }, []);
+    return { getLocation };
+  };
+
+  // pkgs/@akanjs/next/src/useCsrValues.ts
+  var useNoneTrans = ({ clientHeight, location: location2, prevLocation }) => {
+    const transDirection = "none";
+    const transUnit = (0, import_web.useSpringValue)(0, { config: { clamp: true } });
+    const transUnitRange = (0, import_react9.useMemo)(() => [0, 0], []);
+    const transProgress = transUnit.to((unit) => 1);
+    const transPercent = transUnit.to((unit) => 100);
+    const pageState = location2.pathRoute.pageState;
+    const prevPageState = prevLocation?.pathRoute.pageState ?? defaultPageState;
+    const csrTranstionStyles = {
+      topSafeArea: {
+        containerStyle: {
+          height: pageState.topSafeArea
+        }
+      },
+      bottomSafeArea: {
+        containerStyle: {
+          top: clientHeight - pageState.bottomSafeArea,
+          height: pageState.bottomSafeArea
+        }
+      },
+      page: {
+        containerStyle: {},
+        contentStyle: {
+          paddingTop: pageState.topSafeArea + pageState.topInset,
+          paddingBottom: pageState.bottomInset + pageState.bottomSafeArea,
+          height: clientHeight
+        }
+      },
+      prevPage: {
+        containerStyle: {
+          paddingTop: prevPageState.topSafeArea + prevPageState.topInset
+        },
+        contentStyle: { opacity: 0 }
+      },
+      topInset: {
+        containerStyle: {
+          top: pageState.topSafeArea,
+          height: pageState.topInset
+        },
+        contentStyle: { opacity: 1 },
+        prevContentStyle: { opacity: 0 }
+      },
+      topLeftAction: {
+        containerStyle: {
+          top: pageState.topSafeArea,
+          height: pageState.topInset
+        },
+        contentStyle: { opacity: 1 },
+        prevContentStyle: { opacity: 0 }
+      },
+      bottomInset: {
+        containerStyle: {
+          height: pageState.bottomInset,
+          top: clientHeight - pageState.bottomInset - pageState.bottomSafeArea
+        },
+        contentStyle: { opacity: 1 },
+        prevContentStyle: { opacity: 0 }
+      }
+    };
+    const useCsrTransition = {
+      ...csrTranstionStyles,
+      pageBind: () => ({}),
+      pageClassName: "touch-pan-y",
+      transDirection,
+      transUnitRange,
+      transUnit,
+      transPercent,
+      transProgress
+    };
+    return useCsrTransition;
+  };
+  var useFadeTrans = ({ clientHeight, location: location2, prevLocation, onBack, history }) => {
+    const transDirection = "none";
+    const transUnit = (0, import_web.useSpringValue)(1, { config: { clamp: true } });
+    const transUnitRange = (0, import_react9.useMemo)(() => [0, 1], []);
+    const transProgress = transUnit.to((unit) => unit);
+    const transPercent = transUnit.to([0, 1], [0, 100], "clamp");
+    const pageState = location2.pathRoute.pageState;
+    const prevPageState = prevLocation?.pathRoute.pageState ?? defaultPageState;
+    (0, import_react9.useEffect)(() => {
+      onBack.current.fade = async () => {
+        await transUnit.start(transUnitRange[0]);
+      };
+    }, []);
+    (0, import_react9.useEffect)(() => {
+      if (history.current.type === "forward") {
+        void transUnit.start(transUnitRange[0], { immediate: true });
+        void transUnit.start(transUnitRange[1], { config: { duration: 150 } });
+      } else {
+        void transUnit.start(transUnitRange[1], { immediate: true });
+        return;
+      }
+    }, [location2.pathname]);
+    const csrTranstionStyles = {
+      topSafeArea: {
+        containerStyle: {
+          height: transProgress.to([0, 1], [prevPageState.topSafeArea, pageState.topSafeArea])
+        }
+      },
+      bottomSafeArea: {
+        containerStyle: {
+          top: transProgress.to(
+            [0, 1],
+            [clientHeight - prevPageState.bottomSafeArea, clientHeight - pageState.bottomSafeArea]
+          ),
+          height: transProgress.to([0, 1], [prevPageState.bottomSafeArea, pageState.bottomSafeArea])
+        }
+      },
+      page: {
+        containerStyle: {},
+        contentStyle: {
+          paddingTop: pageState.topSafeArea + pageState.topInset,
+          paddingBottom: pageState.bottomInset + pageState.bottomSafeArea,
+          opacity: transUnit,
+          height: clientHeight
+        }
+      },
+      prevPage: {
+        containerStyle: {
+          paddingTop: prevPageState.topSafeArea + prevPageState.topInset,
+          opacity: transProgress.to((progress) => 1 - progress)
+        },
+        contentStyle: {}
+      },
+      topInset: {
+        containerStyle: {
+          top: transProgress.to([0, 1], [prevPageState.topSafeArea, pageState.topSafeArea]),
+          height: transProgress.to([0, 1], [prevPageState.topInset, pageState.topInset])
+        },
+        contentStyle: {
+          opacity: transProgress
+        },
+        prevContentStyle: {
+          opacity: transProgress.to((progress) => 1 - progress)
+        }
+      },
+      topLeftAction: {
+        containerStyle: {
+          top: transProgress.to([0, 1], [prevPageState.topSafeArea, pageState.topSafeArea]),
+          height: transProgress.to([0, 1], [prevPageState.topInset, pageState.topInset])
+        },
+        contentStyle: {
+          opacity: transProgress.to((progress) => progress)
+        },
+        prevContentStyle: {
+          opacity: transProgress.to((progress) => 1 - progress)
+        }
+      },
+      bottomInset: {
+        containerStyle: {
+          height: transProgress.to([0, 1], [prevPageState.bottomInset, pageState.bottomInset]),
+          top: transProgress.to(
+            [0, 1],
+            [
+              clientHeight - prevPageState.bottomInset - prevPageState.bottomSafeArea,
+              clientHeight - pageState.bottomInset - pageState.bottomSafeArea
+            ]
+          )
+        },
+        contentStyle: {
+          top: transProgress.to([0, 1], [0, -(pageState.bottomInset - prevPageState.bottomInset) * 2]),
+          opacity: transProgress.to((progress) => progress)
+        },
+        prevContentStyle: {
+          top: transProgress.to([0, 1], [0, -(pageState.bottomInset - prevPageState.bottomInset) * 2]),
+          opacity: transProgress.to((progress) => 1 - progress)
+        }
+      }
+    };
+    const useCsrTransition = {
+      ...csrTranstionStyles,
+      pageBind: () => ({}),
+      pageClassName: "",
+      transDirection,
+      transUnitRange,
+      transUnit,
+      transPercent,
+      transProgress
+    };
+    return useCsrTransition;
+  };
+  var useStackTrans = ({
+    clientWidth,
+    clientHeight,
+    location: location2,
+    prevLocation,
+    history,
+    onBack
+  }) => {
+    const transDirection = "horizontal";
+    const transUnit = (0, import_web.useSpringValue)(0, { config: { clamp: true } });
+    const transUnitRange = (0, import_react9.useMemo)(() => [clientWidth, 0], []);
+    const transUnitReversed = transUnit.to((unit) => transUnitRange[0] - unit);
+    const transUnitRangeReversed = (0, import_react9.useMemo)(() => [0, clientWidth], []);
+    const transProgress = transUnitReversed.to(transUnitRangeReversed, [0, 1], "clamp");
+    const transPercent = transUnitReversed.to(transUnitRangeReversed, [0, 100], "clamp");
+    const initThreshold = (0, import_react9.useMemo)(() => Math.floor(clientWidth), []);
+    const threshold = (0, import_react9.useMemo)(() => Math.floor(clientWidth / 3), []);
+    const pageState = location2.pathRoute.pageState;
+    const prevPageState = prevLocation?.pathRoute.pageState ?? defaultPageState;
+    const pageClassName = "touch-pan-y";
+    (0, import_react9.useEffect)(() => {
+      onBack.current.stack = async () => {
+        await transUnit.start(transUnitRange[0]);
+      };
+    }, []);
+    (0, import_react9.useEffect)(() => {
+      if (history.current.type === "forward") {
+        void transUnit.start(transUnitRange[0], { immediate: true });
+        void transUnit.start(transUnitRange[1], { config: { duration: 150 } });
+      } else {
+        void transUnit.start(transUnitRange[1], { immediate: true });
+        return;
+      }
+    }, [location2.pathname]);
+    const pageBind = (0, import_react8.useDrag)(
+      ({ first, down, last, movement: [mx], initial: [ix], cancel }) => {
+        if (first)
+          void device.hideKeyboard();
+        if (ix > initThreshold) {
+          cancel();
+          return;
+        }
+        if (mx < transUnitRange[1])
+          void transUnit.start(transUnitRange[1], { immediate: true });
+        else if (mx > transUnitRange[0])
+          void transUnit.start(transUnitRange[0], { immediate: true });
+        else if (!last)
+          void transUnit.start(mx, { immediate: true });
+        else if (mx < threshold)
+          void transUnit.start(transUnitRange[1]);
+        if (last && mx > threshold)
+          router.back();
+      },
+      { axis: "x", filterTaps: true }
+    );
+    const csrTranstionStyles = {
+      topSafeArea: {
+        containerStyle: {
+          height: transProgress.to([0, 1], [prevPageState.topSafeArea, pageState.topSafeArea])
+        }
+      },
+      bottomSafeArea: {
+        containerStyle: {
+          top: transProgress.to(
+            [0, 1],
+            [clientHeight - prevPageState.bottomSafeArea, clientHeight - pageState.bottomSafeArea]
+          ),
+          height: transProgress.to([0, 1], [prevPageState.bottomSafeArea, pageState.bottomSafeArea])
+        }
+      },
+      page: {
+        containerStyle: {},
+        contentStyle: {
+          paddingTop: pageState.topSafeArea + pageState.topInset,
+          paddingBottom: pageState.bottomInset + pageState.bottomSafeArea,
+          translateX: transUnit,
+          height: clientHeight
+        }
+      },
+      prevPage: {
+        containerStyle: {
+          paddingTop: prevPageState.topSafeArea + prevPageState.topInset,
+          translateX: transUnit.to((unit) => (unit - clientWidth) / 5)
+        },
+        contentStyle: {
+          opacity: transProgress.to((progress) => 1 - progress / 2)
+        }
+      },
+      topInset: {
+        containerStyle: {
+          top: transProgress.to([0, 1], [prevPageState.topSafeArea, pageState.topSafeArea]),
+          height: transProgress.to([0, 1], [prevPageState.topInset, pageState.topInset])
+        },
+        contentStyle: {
+          opacity: transProgress.to((progress) => progress),
+          translateX: transProgress.to([0, 1], [clientWidth / 5, 0])
+        },
+        prevContentStyle: {
+          opacity: transProgress.to((progress) => 1 - progress),
+          translateX: transProgress.to([0, 1], [0, -clientWidth / 5])
+        }
+      },
+      topLeftAction: {
+        containerStyle: {
+          top: transProgress.to([0, 1], [prevPageState.topSafeArea, pageState.topSafeArea]),
+          height: transProgress.to([0, 1], [prevPageState.topInset, pageState.topInset]),
+          minWidth: transProgress.to([0, 1], [prevPageState.topInset, pageState.topInset])
+        },
+        contentStyle: {
+          opacity: transProgress.to((progress) => progress)
+        },
+        prevContentStyle: {
+          opacity: transProgress.to((progress) => 1 - progress)
+        }
+      },
+      bottomInset: {
+        containerStyle: {
+          height: transProgress.to([0, 1], [prevPageState.bottomInset, pageState.bottomInset]),
+          top: transProgress.to(
+            [0, 1],
+            [
+              clientHeight - prevPageState.bottomInset - prevPageState.bottomSafeArea,
+              clientHeight - pageState.bottomInset - pageState.bottomSafeArea
+            ]
+          )
+        },
+        contentStyle: {
+          top: transProgress.to([0, 1], [0, -(pageState.bottomInset - prevPageState.bottomInset) * 2]),
+          opacity: transProgress.to((progress) => progress)
+        },
+        prevContentStyle: {
+          top: transProgress.to([0, 1], [0, -(pageState.bottomInset - prevPageState.bottomInset) * 2]),
+          opacity: transProgress.to((progress) => 1 - progress)
+        }
+      }
+    };
+    const useCsrTransition = {
+      ...csrTranstionStyles,
+      pageBind,
+      pageClassName,
+      transDirection,
+      transUnitRange,
+      transUnit,
+      transPercent,
+      transProgress
+    };
+    return useCsrTransition;
+  };
+  var useBottomUpTrans = ({
+    clientWidth,
+    clientHeight,
+    history,
+    location: location2,
+    prevLocation,
+    onBack
+  }) => {
+    const transDirection = "vertical";
+    const transUnit = (0, import_web.useSpringValue)(0, { config: { clamp: true } });
+    const transUnitRange = (0, import_react9.useMemo)(() => [clientHeight, 0], []);
+    const transUnitReversed = transUnit.to((unit) => transUnitRange[0] - unit);
+    const transUnitRangeReversed = (0, import_react9.useMemo)(() => [0, clientWidth], []);
+    const transProgress = transUnitReversed.to(transUnitRangeReversed, [0, 1], "clamp");
+    const transPercent = transUnitReversed.to(transUnitRangeReversed, [0, 100], "clamp");
+    const initThreshold = (0, import_react9.useMemo)(() => Math.floor(clientWidth / 3), []);
+    const threshold = (0, import_react9.useMemo)(() => Math.floor(clientWidth / 2), []);
+    const pageState = location2.pathRoute.pageState;
+    const prevPageState = prevLocation?.pathRoute.pageState ?? defaultPageState;
+    (0, import_react9.useEffect)(() => {
+      onBack.current.bottomUp = async () => {
+        await transUnit.start(transUnitRange[0]);
+      };
+    }, []);
+    (0, import_react9.useEffect)(() => {
+      if (history.current.type === "forward") {
+        void transUnit.start(transUnitRange[0], { immediate: true });
+        void transUnit.start(transUnitRange[1], { config: { duration: 150 } });
+      } else {
+        void transUnit.start(transUnitRange[1], { immediate: true });
+        return;
+      }
+    }, [location2.pathname]);
+    const pageBind = (0, import_react8.useDrag)(
+      ({ first, last, movement: [, my], initial: [, iy], cancel }) => {
+        if (first)
+          void device.hideKeyboard();
+        if (iy > initThreshold) {
+          cancel();
+          return;
+        }
+        if (my < transUnitRange[1])
+          void transUnit.start(transUnitRange[1], { immediate: true });
+        else if (my > transUnitRange[0])
+          void transUnit.start(transUnitRange[0], { immediate: true });
+        else if (!last)
+          void transUnit.start(my, { immediate: true });
+        else if (my < threshold)
+          void transUnit.start(transUnitRange[1]);
+        if (last && my > threshold)
+          router.back();
+      },
+      { axis: "y", filterTaps: true, threshold: 10 }
+    );
+    const csrTranstionStyles = {
+      topSafeArea: {
+        containerStyle: {
+          height: transProgress.to([0, 1], [prevPageState.topSafeArea, pageState.topSafeArea])
+        }
+      },
+      bottomSafeArea: {
+        containerStyle: {
+          top: transProgress.to(
+            [0, 1],
+            [clientHeight - prevPageState.bottomSafeArea, clientHeight - pageState.bottomSafeArea]
+          ),
+          height: transProgress.to([0, 1], [prevPageState.bottomSafeArea, pageState.bottomSafeArea])
+        }
+      },
+      page: {
+        containerStyle: {},
+        contentStyle: {
+          paddingTop: pageState.topSafeArea + pageState.topInset,
+          paddingBottom: pageState.bottomInset + pageState.bottomSafeArea,
+          translateY: transUnit,
+          height: clientHeight
+        }
+      },
+      prevPage: {
+        containerStyle: {
+          paddingTop: prevPageState.topSafeArea + prevPageState.topInset,
+          translateY: 0
+        },
+        contentStyle: {
+          opacity: transProgress.to((progress) => 1 - progress / 2)
+        }
+      },
+      topInset: {
+        containerStyle: {
+          top: transProgress.to([0, 1], [prevPageState.topSafeArea, pageState.topSafeArea]),
+          height: transProgress.to([0, 1], [prevPageState.topInset, pageState.topInset])
+        },
+        contentStyle: {
+          opacity: transProgress.to((progress) => progress)
+          // translateX: transProgress.to([0, 1], [clientWidth / 5, 0]),
+        },
+        prevContentStyle: {
+          opacity: transProgress.to((progress) => 1 - progress)
+          // translateX: transProgress.to([0, 1], [0, -clientWidth / 5]),
+        }
+      },
+      topLeftAction: {
+        containerStyle: {
+          top: transProgress.to([0, 1], [prevPageState.topSafeArea, pageState.topSafeArea]),
+          height: transProgress.to([0, 1], [prevPageState.topInset, pageState.topInset])
+        },
+        contentStyle: {
+          opacity: transProgress.to((progress) => progress)
+        },
+        prevContentStyle: {
+          opacity: transProgress.to((progress) => 1 - progress)
+        }
+      },
+      bottomInset: {
+        containerStyle: {
+          height: transProgress.to([0, 1], [prevPageState.bottomInset, pageState.bottomInset]),
+          top: transProgress.to(
+            [0, 1],
+            [
+              clientHeight - prevPageState.bottomInset - prevPageState.bottomSafeArea,
+              clientHeight - pageState.bottomInset - pageState.bottomSafeArea
+            ]
+          )
+        },
+        contentStyle: {
+          top: transProgress.to([0, 1], [0, -(pageState.bottomInset - prevPageState.bottomInset) * 2]),
+          opacity: transProgress.to((progress) => progress)
+        },
+        prevContentStyle: {
+          top: transProgress.to([0, 1], [0, -(pageState.bottomInset - prevPageState.bottomInset) * 2]),
+          opacity: transProgress.to((progress) => 1 - progress)
+        }
+      }
+    };
+    const useCsrTransition = {
+      ...csrTranstionStyles,
+      pageBind,
+      pageClassName: "touch-pan-x",
+      transDirection,
+      transUnitRange,
+      transUnit,
+      transPercent,
+      transProgress
+    };
+    return useCsrTransition;
+  };
+  var useCsrValues = (rootRouteGuide, pathRoutes) => {
+    const clientWidth = (0, import_react9.useRef)(window.innerWidth);
+    const clientHeight = (0, import_react9.useRef)(window.innerHeight);
+    const topSafeAreaRef = (0, import_react9.useRef)(null);
+    const bottomSafeAreaRef = (0, import_react9.useRef)(null);
+    const pageContentRef = (0, import_react9.useRef)(null);
+    const prevPageContentRef = (0, import_react9.useRef)(null);
+    const onBack = (0, import_react9.useRef)({});
+    const frameRootRef = (0, import_react9.useRef)(null);
+    const { getLocation } = useLocation({ rootRouteGuide });
+    const { history, setHistoryForward, setHistoryBack, getCurrentLocation, getPrevLocation, getScrollTop } = useHistory([
+      getLocation(window.location.pathname)
+    ]);
+    const [{ location: location2, prevLocation }, setLocationState] = (0, import_react9.useState)({
+      location: getCurrentLocation(),
+      prevLocation: getPrevLocation()
+    });
+    const getRouter = (0, import_react9.useCallback)(() => {
+      const router3 = {
+        push: (href) => {
+          const location3 = getCurrentLocation();
+          const scrollTop = pageContentRef.current?.scrollTop ?? 0;
+          setHistoryForward({ type: "push", location: getLocation(href), scrollTop });
+          setLocationState({ location: getCurrentLocation(), prevLocation: location3 });
+          window.history.pushState({}, "", href);
+        },
+        replace: (href) => {
+          const scrollTop = pageContentRef.current?.scrollTop ?? 0;
+          setHistoryForward({ type: "replace", location: getLocation(href), scrollTop });
+          setLocationState({ location: getCurrentLocation(), prevLocation });
+          window.history.replaceState({}, "", href);
+        },
+        refresh: () => {
+          window.location.reload();
+        },
+        back: async () => {
+          const location3 = getCurrentLocation();
+          await onBack.current[location3.pathRoute.pageState.transition]?.();
+          const scrollTop = pageContentRef.current?.scrollTop ?? 0;
+          setHistoryBack({ type: "back", location: location3, scrollTop });
+          setLocationState({ location: getCurrentLocation(), prevLocation: getPrevLocation() });
+          window.history.back();
+        }
+      };
+      window.onpopstate = async (ev) => {
+        const routeType = window.location.pathname === getCurrentLocation().pathname && history.current.type !== "back" ? "forward" : window.location.pathname === getPrevLocation()?.pathname ? "back" : null;
+        const scrollTop = pageContentRef.current?.scrollTop ?? 0;
+        if (!routeType)
+          return;
+        if (routeType === "forward") {
+          const location3 = getCurrentLocation();
+          setHistoryForward({ type: "popForward", location: location3, scrollTop });
+          setLocationState({ location: getCurrentLocation(), prevLocation: location3 });
+        } else {
+          const location3 = getCurrentLocation();
+          await onBack.current[location3.pathRoute.pageState.transition]?.();
+          setHistoryBack({ type: "popBack", location: location3, scrollTop });
+          setLocationState({ location: getCurrentLocation(), prevLocation: getPrevLocation() });
+        }
+      };
+      return router3;
+    }, [location2]);
+    const router2 = getRouter();
+    const routeState = {
+      clientWidth: clientWidth.current,
+      clientHeight: clientHeight.current,
+      location: location2,
+      prevLocation,
+      history,
+      topSafeAreaRef,
+      bottomSafeAreaRef,
+      prevPageContentRef,
+      pageContentRef,
+      frameRootRef,
+      onBack,
+      router: router2,
+      pathRoutes
+    };
+    const useNonTransition = useNoneTrans(routeState);
+    const useFadeTransition = useFadeTrans(routeState);
+    const useStackTransition = useStackTrans(routeState);
+    const useBottomUpTransition = useBottomUpTrans(routeState);
+    const useCsrTransitionMap = {
+      none: useNonTransition,
+      fade: useFadeTransition,
+      stack: useStackTransition,
+      bottomUp: useBottomUpTransition,
+      scaleOut: useNonTransition
+    };
+    (0, import_react9.useEffect)(() => {
+      if (pageContentRef.current)
+        pageContentRef.current.scrollTop = getScrollTop(location2.pathname);
+      if (prevPageContentRef.current)
+        prevPageContentRef.current.scrollTop = prevLocation ? getScrollTop(prevLocation.pathname) : 0;
+      void import_app.App.addListener("backButton", () => {
+        router2.back();
+      });
+      return () => {
+        void import_app.App.removeAllListeners();
+      };
+    }, [location2.pathname]);
+    return {
+      ...routeState,
+      ...useCsrTransitionMap[location2.pathRoute.pageState.transition]
+    };
+  };
+
+  // pkgs/@akanjs/next/src/bootCsr.tsx
+  var supportLanguages = ["en", "ko"];
+  var bootCsr = async (context, rootPath, entryPath = "/route") => {
+    const [, jwt] = await Promise.all([device.init({ supportLanguages }), storage.getItem("jwt")]);
+    if (jwt)
+      initAuth({ jwt });
+    Logger.verbose(`Set default language: ${device.lang}`);
+    const pages = {};
+    await Promise.all(
+      Object.entries(context).map(async ([key, value]) => {
+        pages[key] = await value();
+      })
+    );
+    const getPageState = (csrConfig) => {
+      const { transition, safeArea, topInset, bottomInset, gesture, cache } = csrConfig ?? {};
+      const pageState = {
+        transition: transition ?? "none",
+        topSafeArea: safeArea === false ? 0 : device.topSafeArea,
+        bottomSafeArea: safeArea === false ? 0 : device.bottomSafeArea,
+        // topSafeArea: safeArea === false || device.info.platform === "android" ? 0 : device.topSafeArea,
+        // bottomSafeArea: safeArea === false || device.info.platform === "android" ? 0 : device.bottomSafeArea,
+        topInset: topInset === true ? DEFAULT_TOP_INSET : topInset === false ? 0 : topInset ?? 0,
+        bottomInset: bottomInset === true ? DEFAULT_BOTTOM_INSET : bottomInset === false ? 0 : bottomInset ?? 0,
+        gesture: gesture ?? true,
+        cache: cache ?? false
+      };
+      return pageState;
+    };
+    const routeMap = /* @__PURE__ */ new Map();
+    routeMap.set("/", { path: "/", children: /* @__PURE__ */ new Map() });
+    for (const filePath of Object.keys(pages)) {
+      const fileName = /\.\/(.*)\.tsx$/.exec(filePath)?.[1];
+      if (!fileName)
+        continue;
+      const fileType = fileName.endsWith("page") ? "page" : fileName.endsWith("layout") ? "layout" : null;
+      if (!fileType)
+        continue;
+      const pathSegments = [
+        "/",
+        ...fileName.split("/").slice(0, -1).map((segment) => `/${segment.replace(/\[(.*?)\]/g, ":$1")}`)
+      ];
+      const targetRouteMap = pathSegments.slice(0, -1).reduce((rMap, path) => {
+        if (!rMap.has(path))
+          rMap.set(path, { path, children: /* @__PURE__ */ new Map() });
+        return rMap.get(path)?.children;
+      }, routeMap);
+      if (!targetRouteMap)
+        continue;
+      const targetPath = pathSegments[pathSegments.length - 1];
+      targetRouteMap.set(targetPath, {
+        // action: pages[path]?.action,
+        // ErrorBoundary: pages[path]?.ErrorBoundary,
+        ...targetRouteMap.get(targetPath) ?? { path: targetPath, children: /* @__PURE__ */ new Map() },
+        ...fileType === "layout" ? { Layout: pages[filePath].default } : {
+          Page: pages[filePath].default,
+          pageState: getPageState(pages[filePath].default.csrConfig),
+          csrConfig: pages[filePath].default.csrConfig
+        }
+      });
+    }
+    const pathname = window.location.pathname;
+    const initialPath = device.lang + entryPath;
+    window.document.body.style.overflow = "hidden";
+    const getPathRoutes = (route, parentRootLayouts = [], parentLayouts = [], parentPaths = []) => {
+      const parentPath = parentPaths.filter((path2) => path2 !== "/").join("");
+      const currentPathSegment = /^\/\(.*\)$/.test(route.path) ? "" : route.path;
+      const isRoot = ["/", "/:lang"].includes(parentPath + currentPathSegment) && parentRootLayouts.length < 2;
+      const path = parentPath + currentPathSegment;
+      const pathSegments = [...parentPaths, ...currentPathSegment ? [currentPathSegment] : []];
+      const RootLayouts = [...parentRootLayouts, ...isRoot && route.Layout ? [route.Layout] : []];
+      const Layouts = [...parentLayouts, ...!isRoot && route.Layout ? [route.Layout] : []];
+      return [
+        ...route.Page ? [
+          {
+            path,
+            pathSegments,
+            Page: route.Page,
+            RootLayouts,
+            Layouts,
+            pageState: route.pageState ?? defaultPageState
+          }
+        ] : [],
+        ...route.children.size ? [...route.children.values()].flatMap((child) => getPathRoutes(child, RootLayouts, Layouts, pathSegments)) : []
+      ];
+    };
+    const rootRoute = routeMap.get("/");
+    if (!rootRoute)
+      throw new Error("No root route");
+    const pathRoutes = getPathRoutes(rootRoute);
+    const routeGuide = { pathSegment: "/", children: {} };
+    pathRoutes.forEach((pathRoute) => {
+      const pathSegments = pathRoute.pathSegments.slice(1);
+      pathSegments.reduce((routeGuide2, pathSegment, index) => {
+        const child = routeGuide2.children[pathSegment];
+        routeGuide2.children[pathSegment] = {
+          ...child ?? {},
+          pathSegment,
+          ...index === pathSegments.length - 1 ? { pathRoute } : {},
+          children: child?.children ?? {}
+        };
+        return routeGuide2.children[pathSegment];
+      }, routeGuide);
+    });
+    const RouterProvider = () => {
+      const csrValues = useCsrValues(routeGuide, pathRoutes);
+      const { location: location2 } = csrValues;
+      return /* @__PURE__ */ import_react10.default.createElement(csrContext.Provider, { value: csrValues }, location2.pathRoute.RootLayouts.reduceRight(
+        (children, Layout) => {
+          return /* @__PURE__ */ import_react10.default.createElement(Layout, { params: location2.params, searchParams: location2.searchParams }, children);
+        },
+        /* @__PURE__ */ import_react10.default.createElement(import_react10.default.Fragment, null)
+      ));
+    };
+    if (pathname !== `/${initialPath}`) {
+      window.location.replace(initialPath);
+      return;
+    } else {
+      const el = document.getElementById("root");
+      if (!el)
+        throw new Error("No root element");
+      const root = ReactDOM.createRoot(el);
+      root.render(/* @__PURE__ */ import_react10.default.createElement(RouterProvider, null));
+    }
+  };
+
+  // pkgs/@akanjs/next/src/useCamera.tsx
+  var import_camera = __require("@capacitor/camera");
+  var import_react11 = __require("react");
+  var useCamera = () => {
+    const [permissions, setPermissions] = (0, import_react11.useState)({ camera: "prompt", photos: "prompt" });
+    const checkPermission = async (type) => {
+      try {
+        if (type === "photos") {
+          if (permissions.photos === "prompt") {
+            const { photos } = await import_camera.Camera.requestPermissions();
+            setPermissions((prev) => ({ ...prev, photos }));
+          } else if (permissions.photos === "denied") {
+            location.assign("app-settings:");
+            return;
+          }
+        } else if (type === "camera") {
+          if (permissions.camera === "prompt") {
+            const { camera } = await import_camera.Camera.requestPermissions();
+            setPermissions((prev) => ({ ...prev, camera }));
+          } else if (permissions.camera === "denied") {
+            location.assign("app-settings:");
+            return;
+          }
+        } else {
+          if (permissions.camera === "prompt" || permissions.photos === "prompt") {
+            const permissions2 = await import_camera.Camera.requestPermissions();
+            setPermissions(permissions2);
+          } else if (permissions.camera === "denied" || permissions.photos === "denied") {
+            location.assign("app-settings:");
+            return;
+          }
+        }
+      } catch (e) {
+      }
+    };
+    const getPhoto = async (src = "prompt") => {
+      const source = device.info.platform !== "web" ? src === "prompt" ? import_camera.CameraSource.Prompt : src === "camera" ? import_camera.CameraSource.Camera : import_camera.CameraSource.Photos : import_camera.CameraSource.Photos;
+      const permission = src === "prompt" ? "all" : src === "camera" ? "camera" : "photos";
+      void checkPermission(permission);
+      try {
+        const photo = await import_camera.Camera.getPhoto({
+          quality: 100,
+          source,
+          allowEditing: false,
+          resultType: import_camera.CameraResultType.DataUrl,
+          promptLabelHeader: "\uD504\uB85C\uD544 \uC0AC\uC9C4\uC744 \uC62C\uB824\uC8FC\uC138\uC694",
+          promptLabelPhoto: "\uC568\uBC94\uC5D0\uC11C \uC120\uD0DD\uD558\uAE30",
+          promptLabelPicture: "\uC0AC\uC9C4 \uCC0D\uAE30",
+          promptLabelCancel: "\uCDE8\uC18C"
+        });
+        return photo;
+      } catch (e) {
+        if (e === "User cancelled photos app")
+          return;
+      }
+    };
+    const pickImage = async () => {
+      void checkPermission("photos");
+      const photo = await import_camera.Camera.pickImages({
+        quality: 90
+      });
+      return photo;
+    };
+    (0, import_react11.useEffect)(() => {
+      void (async () => {
+        if (device.info.platform !== "web") {
+          const permissions2 = await import_camera.Camera.checkPermissions();
+          setPermissions(permissions2);
+        }
+      })();
+    }, []);
+    return { permissions, getPhoto, pickImage, checkPermission };
+  };
+
+  // pkgs/@akanjs/next/src/useContact.tsx
+  var import_contacts = __require("@capacitor-community/contacts");
+  var import_react12 = __require("react");
+  var useContact = () => {
+    const [permissions, setPermissions] = (0, import_react12.useState)({ contacts: "prompt" });
+    const checkPermission = async () => {
+      try {
+        if (permissions.contacts === "prompt") {
+          const { contacts } = await import_contacts.Contacts.requestPermissions();
+          setPermissions((prev) => ({ ...prev, contacts }));
+        } else if (permissions.contacts === "denied") {
+          location.assign("app-settings:");
+          return;
+        }
+      } catch (e) {
+      }
+    };
+    const getContacts = async () => {
+      await checkPermission();
+      const { contacts } = await import_contacts.Contacts.getContacts({ projection: { name: true, phones: true } });
+      return contacts;
+    };
+    (0, import_react12.useEffect)(() => {
+      void (async () => {
+        if (device.info.platform === "web")
+          return;
+        const permissions2 = await import_contacts.Contacts.checkPermissions();
+        setPermissions(permissions2);
+      })();
+    }, []);
+    return { permissions, getContacts, checkPermission };
+  };
+
+  // pkgs/@akanjs/next/src/usePushNoti.tsx
+  var import_device2 = __require("@capacitor/device");
+  var import_push_notifications = __require("@capacitor/push-notifications");
+  var import_fcm = __require("@capacitor-community/fcm");
+  var usePushNoti = () => {
+    const init = async () => {
+      const device2 = await import_device2.Device.getInfo();
+      if (device2.platform === "web")
+        return;
+      void import_fcm.FCM.setAutoInit({ enabled: true });
+      void import_push_notifications.PushNotifications.requestPermissions().then(async (result) => {
+        if (result.receive === "granted") {
+          await import_push_notifications.PushNotifications.register();
+        }
+      });
+    };
+    const checkPermission = async () => {
+      const { receive } = await import_push_notifications.PushNotifications.checkPermissions();
+      return receive === "granted";
+    };
+    const register = async () => {
+      const device2 = await import_device2.Device.getInfo();
+      if (device2.platform === "web")
+        return;
+      const { receive } = await import_push_notifications.PushNotifications.checkPermissions();
+      if (receive === "denied")
+        location.assign("app-settings:");
+      else
+        await import_push_notifications.PushNotifications.register();
+    };
+    const getToken = async () => {
+      const device2 = await import_device2.Device.getInfo();
+      if (device2.platform === "web")
+        return;
+      const { token } = await import_fcm.FCM.getToken();
+      return token;
+    };
+    return { init, checkPermission, register, getToken };
+  };
+
+  // pkgs/@akanjs/next/src/useGeoLocation.tsx
+  var import_geolocation = __require("@capacitor/geolocation");
+  var useGeoLocation = () => {
+    const checkPermission = async () => {
+      const { location: geolocation, coarseLocation } = await import_geolocation.Geolocation.requestPermissions();
+      return { geolocation, coarseLocation };
+    };
+    const getPosition = async () => {
+      const { geolocation, coarseLocation } = await checkPermission();
+      if (geolocation === "denied" || coarseLocation === "denied") {
+        location.assign("app-settings:");
+        return;
+      }
+      const coordinates = await import_geolocation.Geolocation.getCurrentPosition();
+      return coordinates;
+    };
+    return { checkPermission, getPosition };
+  };
+
+  // pkgs/@akanjs/next/src/useCodepush.tsx
+  var import_app2 = __require("@capacitor/app");
+  var import_device3 = __require("@capacitor/device");
+  var import_capacitor_updater = __require("@capgo/capacitor-updater");
+  var import_axios = __toESM(__require("axios"));
+  var import_react13 = __require("react");
+  var useCodepush = ({ serverUrl, branch }) => {
+    const [update, setUpdate] = (0, import_react13.useState)(false);
+    const [version2, setVersion] = (0, import_react13.useState)("");
+    const initialize = async () => {
+      await import_capacitor_updater.CapacitorUpdater.notifyAppReady();
+    };
+    const checkNewRelease = async () => {
+      const info = await import_device3.Device.getInfo();
+      const app = await import_app2.App.getInfo();
+      const pluginVersion = await import_capacitor_updater.CapacitorUpdater.getPluginVersion();
+      const { deviceId } = await import_capacitor_updater.CapacitorUpdater.getDeviceId();
+      const { bundle: version3, native } = await import_capacitor_updater.CapacitorUpdater.current();
+      const builtInversion = await import_capacitor_updater.CapacitorUpdater.getBuiltinVersion();
+      const appId = app.id;
+      const platform = info.platform;
+      window.alert(
+        `getBuildinVersion:${builtInversion.version}
+current.bundle:${version3.version}
+currennt.native:${native}`
+      );
+      const { major, minor, patch } = splitVersion(version3.version === "builtin" ? app.version : version3.version);
+      const appName2 = process.env.NEXT_PUBLIC_APP_NAME ?? "";
+      const appInfo = {
+        appId,
+        appName: appName2,
+        deviceId,
+        platform,
+        branch,
+        isEmulator: info.isVirtual,
+        major: parseInt(major),
+        minor: parseInt(minor),
+        patch: parseInt(patch),
+        buildNum: app.build,
+        //앱내 빌드시 버전 횟수 모르면 고한테 물어보기
+        versionOs: info.osVersion
+      };
+      const url = serverUrl.replace("lu", "akasys");
+      const release = (await import_axios.default.post(`${url}/release/codepush`, {
+        data: { ...appInfo }
+      })).data;
+      if (!release)
+        return;
+      const file = (await import_axios.default.get(`${url}/file/file/${release.appBuild}`)).data;
+      return { release, bundleFile: file };
+    };
+    const codepush = async () => {
+      const isNewRelease = await checkNewRelease();
+      if (!isNewRelease)
+        return;
+      const { release, bundleFile } = isNewRelease;
+      setUpdate(true);
+      const bundle = await import_capacitor_updater.CapacitorUpdater.download({
+        url: bundleFile.url,
+        version: mergeVersion(release.major, release.minor, release.patch)
+      });
+      await import_capacitor_updater.CapacitorUpdater.set(bundle);
+    };
+    const getVersion = async () => {
+      return await import_capacitor_updater.CapacitorUpdater.getBuiltinVersion();
+    };
+    const statManager = async () => {
+    };
+    return { update, version: version2, initialize, checkNewRelease, codepush, statManager };
+  };
+
+  // pkgs/@akanjs/next/src/usePurchase.tsx
+  var import_store = __require("cordova-plugin-purchase/www/store");
+  var import_app3 = __require("@capacitor/app");
+  var import_react14 = __require("react");
+  var usePurchase = ({
+    platform,
+    productInfo,
+    url,
+    onPay,
+    onSubscribe
+  }) => {
+    const [isLoading, setIsLoading] = (0, import_react14.useState)(true);
+    const billingRef = (0, import_react14.useRef)();
+    (0, import_react14.useEffect)(() => {
+      const init = async () => {
+        if (CdvPurchase.store.isReady) {
+          setIsLoading(false);
+          return;
+        }
+        const app = await import_app3.App.getInfo();
+        if (platform === "all")
+          CdvPurchase.store.register([
+            ...productInfo.map((prouct) => ({
+              id: prouct.id,
+              platform: CdvPurchase.Platform.GOOGLE_PLAY,
+              type: CdvPurchase.ProductType[prouct.type]
+            })),
+            ...productInfo.map((prouct) => ({
+              id: prouct.id,
+              platform: CdvPurchase.Platform.APPLE_APPSTORE,
+              type: CdvPurchase.ProductType[prouct.type]
+            }))
+          ]);
+        else
+          CdvPurchase.store.register(
+            productInfo.map((product) => ({
+              id: product.id,
+              platform: platform === "android" ? CdvPurchase.Platform.GOOGLE_PLAY : CdvPurchase.Platform.APPLE_APPSTORE,
+              type: CdvPurchase.ProductType[product.type]
+            }))
+          );
+        await CdvPurchase.store.initialize([
+          { platform: CdvPurchase.Platform.APPLE_APPSTORE, options: { needAppReceipt: false } },
+          { platform: CdvPurchase.Platform.GOOGLE_PLAY }
+        ]);
+        await CdvPurchase.store.update();
+        await CdvPurchase.store.restorePurchases();
+        CdvPurchase.store.validator = async (request, callback) => {
+          const transactionId = request.transaction.id;
+          const transactions = CdvPurchase.store.localTransactions;
+          const verifingTransaction = transactions.find((transaction) => transaction.transactionId === transactionId);
+          if (verifingTransaction?.state !== "approved")
+            return;
+          const billing = await fetch(`${url}/billing/verifyBilling`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+              data: {
+                platform: verifingTransaction.platform === CdvPurchase.Platform.GOOGLE_PLAY ? "google" : "apple",
+                packageName: app.id,
+                productId: verifingTransaction.products[0].id,
+                receipt: verifingTransaction.platform === CdvPurchase.Platform.GOOGLE_PLAY ? request.transaction.purchaseToken : request.transaction.appStoreReceipt,
+                transactionId: verifingTransaction.transactionId
+              }
+            })
+          });
+          billingRef.current = billing.json();
+          callback({
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            ok: billing ? true : false,
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            data: { id: request.id, latest_receipt: true, transaction: request.transaction }
+          });
+        };
+        if (CdvPurchase.store.localReceipts.length > 0) {
+          CdvPurchase.store.localReceipts.forEach((receipt) => {
+            if (receipt.platform === CdvPurchase.Platform.GOOGLE_PLAY)
+              if (receipt.transactions[0].state === CdvPurchase.TransactionState.APPROVED)
+                void receipt.transactions[0].verify();
+              else
+                void receipt.transactions[0].finish();
+          });
+        }
+        CdvPurchase.store.when().approved((transaction) => {
+          void transaction.verify();
+        }).verified((receipt) => {
+          void receipt.finish();
+        }).finished((transaction) => {
+          void inAppPurchase(transaction);
+        });
+        setIsLoading(false);
+      };
+      void init();
+    }, []);
+    const purchaseProduct = async (product) => {
+      await product.getOffer()?.order();
+    };
+    const restorePurchases = async () => {
+      await CdvPurchase.store.restorePurchases();
+    };
+    const inAppPurchase = async (transaction) => {
+      const product = CdvPurchase.store.get(transaction.products[0].id);
+      if (product?.type === "consumable")
+        await onPay?.(transaction);
+      else
+        await onSubscribe?.(transaction);
+      await transaction.finish();
+    };
+    return {
+      isLoading,
+      products: CdvPurchase.store.products,
+      purchaseProduct,
+      restorePurchases
+    };
+  };
+
+  // pkgs/@akanjs/next/src/createRobotPage.ts
+  var createRobotPage = (clientHttpUri2, config) => {
+    return {
+      ...config ?? {},
+      rules: {
+        userAgent: "*",
+        allow: "/",
+        disallow: "/admin/",
+        ...config?.rules ?? {}
+      },
+      sitemap: `${clientHttpUri2}/sitemap.xml`
+    };
+  };
+
+  // pkgs/@akanjs/next/src/createSitemapPage.ts
+  var lastModified = /* @__PURE__ */ new Date();
+  var createSitemapPage = (clientHttpUri2, paths) => {
+    return paths.map((path) => ({ url: `${clientHttpUri2}${path}`, lastModified }));
+  };
+
+  // pkgs/@akanjs/next/src/createNextMiddleware.ts
+  var import_intl_localematcher = __require("@formatjs/intl-localematcher");
+  var import_negotiator = __toESM(__require("negotiator"));
+  var import_server = __require("next/server");
+  var i18n = { defaultLocale: "en", locales: ["en", "ko"] };
+  var basePaths = process.env.basePaths ? process.env.basePaths.split(",") : [];
+  function getLocale(request) {
+    if (!request.headers.get("accept-language"))
+      return i18n.defaultLocale;
+    const negotiatorHeaders = {};
+    request.headers.forEach((value, key) => negotiatorHeaders[key] = value);
+    try {
+      const languages = new import_negotiator.default({ headers: negotiatorHeaders }).languages();
+      return (0, import_intl_localematcher.match)(languages, i18n.locales, i18n.defaultLocale);
+    } catch (e) {
+      return i18n.defaultLocale;
+    }
   }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var next_exports = {};
-module.exports = __toCommonJS(next_exports);
-__reExport(next_exports, require("./src"), module.exports);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ...require("./src")
-});
+  var createNextMiddleware = () => {
+    Logger.rawLog(logo, "console");
+    const middleware = (request) => {
+      const pathname = request.nextUrl.pathname;
+      const pathnameIsMissingLocale = i18n.locales.every(
+        (locale2) => !pathname.startsWith(`/${locale2}/`) && pathname !== `/${locale2}`
+      );
+      if (pathnameIsMissingLocale)
+        return import_server.NextResponse.redirect(
+          new URL(`/${getLocale(request)}/${request.nextUrl.href.split("/").slice(3).join("/")}`, request.url)
+        );
+      const splits = pathname.split("/");
+      const locale = splits[1];
+      const basePath = basePaths.includes(splits[2]) ? splits[2] : null;
+      const headers2 = new Headers(request.headers);
+      const searchParams = new URLSearchParams(request.nextUrl.search);
+      const searchParamJwt = searchParams.get("jwt");
+      headers2.set("x-locale", locale);
+      headers2.set("x-path", "/" + splits.slice(2).join("/"));
+      if (basePath)
+        headers2.set("x-base-path", basePath);
+      if (searchParamJwt)
+        headers2.set("jwt", searchParamJwt);
+      return import_server.NextResponse.next({ request: { headers: headers2 } });
+    };
+    return middleware;
+  };
+
+  // pkgs/@akanjs/next/src/useThrottle.ts
+  var import_react15 = __require("react");
+  var useThrottle = (func, delay = 200, deps = []) => {
+    const throttleSeed = (0, import_react15.useRef)(null);
+    const throttleFunction = (0, import_react15.useCallback)(
+      (...args) => {
+        if (throttleSeed.current)
+          return;
+        func(...args);
+        throttleSeed.current = setTimeout(() => {
+          throttleSeed.current = null;
+        }, delay);
+      },
+      [func, delay, ...deps]
+    );
+    return throttleFunction;
+  };
+})();
+//! next build를 위해서 lint 무시
+//! Nextjs는 환경변수를 build time에 그냥 하드코딩으로 값을 넣어버림. operationMode같은것들 잘 동작안할 수 있음. 추후 수정 필요.
+//! PageAgent csr에서 말썽 일으킨다