website-vue/.nuxt/prerender/chunks/build/server.mjs

import { shallowReactive, reactive, effectScope, getCurrentScope, hasInjectionContext, getCurrentInstance, toRef, inject, shallowRef, isReadonly, isRef, isShallow, isReactive, toRaw, defineAsyncComponent, defineComponent, computed, unref, ref, h, Suspense, nextTick, mergeProps, provide, Fragment, useSSRContext, withCtx, createVNode, onErrorCaptured, onServerPrefetch, resolveDynamicComponent, createApp } from 'file://D:/doc/workspace/web3/node_modules/vue/index.mjs';
import { createHooks } from 'file://D:/doc/workspace/web3/node_modules/hookable/dist/index.mjs';
import { getContext, executeAsync } from 'file://D:/doc/workspace/web3/node_modules/unctx/dist/index.mjs';
import { createError as createError$1, sanitizeStatusCode, appendHeader } from 'file://D:/doc/workspace/web3/node_modules/h3/dist/index.mjs';
import { START_LOCATION, createMemoryHistory, createRouter as createRouter$1, useRoute as useRoute$1, RouterView } from 'file://D:/doc/workspace/web3/node_modules/vue-router/dist/vue-router.node.mjs';
import { toRouteMatcher, createRouter } from 'file://D:/doc/workspace/web3/node_modules/radix3/dist/index.mjs';
import { defu } from 'file://D:/doc/workspace/web3/node_modules/defu/dist/defu.mjs';
import { hasProtocol, joinURL, withQuery, isScriptProtocol } from 'file://D:/doc/workspace/web3/node_modules/ufo/dist/index.mjs';
import { createI18n } from 'file://D:/doc/workspace/web3/node_modules/vue-i18n/dist/vue-i18n.mjs';
import { ssrRenderComponent, ssrRenderSuspense, ssrRenderVNode } from 'file://D:/doc/workspace/web3/node_modules/vue/server-renderer/index.mjs';

const appLayoutTransition = false;
const appPageTransition = false;
const nuxtLinkDefaults = { "componentName": "NuxtLink" };
const appId = "nuxt-app";

function getNuxtAppCtx(id = appId) {
  return getContext(id, {
    asyncContext: false
  });
}
const NuxtPluginIndicator = "__nuxt_plugin";
function createNuxtApp(options) {
  var _a;
  let hydratingCount = 0;
  const nuxtApp = {
    _id: options.id || appId || "nuxt-app",
    _scope: effectScope(),
    provide: void 0,
    globalName: "nuxt",
    versions: {
      get nuxt() {
        return "3.16.2";
      },
      get vue() {
        return nuxtApp.vueApp.version;
      }
    },
    payload: shallowReactive({
      ...((_a = options.ssrContext) == null ? void 0 : _a.payload) || {},
      data: shallowReactive({}),
      state: reactive({}),
      once: /* @__PURE__ */ new Set(),
      _errors: shallowReactive({})
    }),
    static: {
      data: {}
    },
    runWithContext(fn) {
      if (nuxtApp._scope.active && !getCurrentScope()) {
        return nuxtApp._scope.run(() => callWithNuxt(nuxtApp, fn));
      }
      return callWithNuxt(nuxtApp, fn);
    },
    isHydrating: false,
    deferHydration() {
      if (!nuxtApp.isHydrating) {
        return () => {
        };
      }
      hydratingCount++;
      let called = false;
      return () => {
        if (called) {
          return;
        }
        called = true;
        hydratingCount--;
        if (hydratingCount === 0) {
          nuxtApp.isHydrating = false;
          return nuxtApp.callHook("app:suspense:resolve");
        }
      };
    },
    _asyncDataPromises: {},
    _asyncData: shallowReactive({}),
    _payloadRevivers: {},
    ...options
  };
  {
    nuxtApp.payload.serverRendered = true;
  }
  if (nuxtApp.ssrContext) {
    nuxtApp.payload.path = nuxtApp.ssrContext.url;
    nuxtApp.ssrContext.nuxt = nuxtApp;
    nuxtApp.ssrContext.payload = nuxtApp.payload;
    nuxtApp.ssrContext.config = {
      public: nuxtApp.ssrContext.runtimeConfig.public,
      app: nuxtApp.ssrContext.runtimeConfig.app
    };
  }
  nuxtApp.hooks = createHooks();
  nuxtApp.hook = nuxtApp.hooks.hook;
  {
    const contextCaller = async function(hooks, args) {
      for (const hook of hooks) {
        await nuxtApp.runWithContext(() => hook(...args));
      }
    };
    nuxtApp.hooks.callHook = (name, ...args) => nuxtApp.hooks.callHookWith(contextCaller, name, ...args);
  }
  nuxtApp.callHook = nuxtApp.hooks.callHook;
  nuxtApp.provide = (name, value) => {
    const $name = "$" + name;
    defineGetter(nuxtApp, $name, value);
    defineGetter(nuxtApp.vueApp.config.globalProperties, $name, value);
  };
  defineGetter(nuxtApp.vueApp, "$nuxt", nuxtApp);
  defineGetter(nuxtApp.vueApp.config.globalProperties, "$nuxt", nuxtApp);
  const runtimeConfig = options.ssrContext.runtimeConfig;
  nuxtApp.provide("config", runtimeConfig);
  return nuxtApp;
}
function registerPluginHooks(nuxtApp, plugin) {
  if (plugin.hooks) {
    nuxtApp.hooks.addHooks(plugin.hooks);
  }
}
async function applyPlugin(nuxtApp, plugin) {
  if (typeof plugin === "function") {
    const { provide } = await nuxtApp.runWithContext(() => plugin(nuxtApp)) || {};
    if (provide && typeof provide === "object") {
      for (const key in provide) {
        nuxtApp.provide(key, provide[key]);
      }
    }
  }
}
async function applyPlugins(nuxtApp, plugins) {
  var _a, _b, _c, _d;
  const resolvedPlugins = [];
  const unresolvedPlugins = [];
  const parallels = [];
  const errors = [];
  let promiseDepth = 0;
  async function executePlugin(plugin) {
    var _a2;
    const unresolvedPluginsForThisPlugin = ((_a2 = plugin.dependsOn) == null ? void 0 : _a2.filter((name) => plugins.some((p) => p._name === name) && !resolvedPlugins.includes(name))) ?? [];
    if (unresolvedPluginsForThisPlugin.length > 0) {
      unresolvedPlugins.push([new Set(unresolvedPluginsForThisPlugin), plugin]);
    } else {
      const promise = applyPlugin(nuxtApp, plugin).then(async () => {
        if (plugin._name) {
          resolvedPlugins.push(plugin._name);
          await Promise.all(unresolvedPlugins.map(async ([dependsOn, unexecutedPlugin]) => {
            if (dependsOn.has(plugin._name)) {
              dependsOn.delete(plugin._name);
              if (dependsOn.size === 0) {
                promiseDepth++;
                await executePlugin(unexecutedPlugin);
              }
            }
          }));
        }
      });
      if (plugin.parallel) {
        parallels.push(promise.catch((e) => errors.push(e)));
      } else {
        await promise;
      }
    }
  }
  for (const plugin of plugins) {
    if (((_a = nuxtApp.ssrContext) == null ? void 0 : _a.islandContext) && ((_b = plugin.env) == null ? void 0 : _b.islands) === false) {
      continue;
    }
    registerPluginHooks(nuxtApp, plugin);
  }
  for (const plugin of plugins) {
    if (((_c = nuxtApp.ssrContext) == null ? void 0 : _c.islandContext) && ((_d = plugin.env) == null ? void 0 : _d.islands) === false) {
      continue;
    }
    await executePlugin(plugin);
  }
  await Promise.all(parallels);
  if (promiseDepth) {
    for (let i = 0; i < promiseDepth; i++) {
      await Promise.all(parallels);
    }
  }
  if (errors.length) {
    throw errors[0];
  }
}
// @__NO_SIDE_EFFECTS__
function defineNuxtPlugin(plugin) {
  if (typeof plugin === "function") {
    return plugin;
  }
  const _name = plugin._name || plugin.name;
  delete plugin.name;
  return Object.assign(plugin.setup || (() => {
  }), plugin, { [NuxtPluginIndicator]: true, _name });
}
function callWithNuxt(nuxt, setup, args) {
  const fn = () => setup();
  const nuxtAppCtx = getNuxtAppCtx(nuxt._id);
  {
    return nuxt.vueApp.runWithContext(() => nuxtAppCtx.callAsync(nuxt, fn));
  }
}
function tryUseNuxtApp(id) {
  var _a;
  let nuxtAppInstance;
  if (hasInjectionContext()) {
    nuxtAppInstance = (_a = getCurrentInstance()) == null ? void 0 : _a.appContext.app.$nuxt;
  }
  nuxtAppInstance || (nuxtAppInstance = getNuxtAppCtx(id).tryUse());
  return nuxtAppInstance || null;
}
function useNuxtApp(id) {
  const nuxtAppInstance = tryUseNuxtApp(id);
  if (!nuxtAppInstance) {
    {
      throw new Error("[nuxt] instance unavailable");
    }
  }
  return nuxtAppInstance;
}
// @__NO_SIDE_EFFECTS__
function useRuntimeConfig(_event) {
  return useNuxtApp().$config;
}
function defineGetter(obj, key, val) {
  Object.defineProperty(obj, key, { get: () => val });
}

const NUXT_ERROR_SIGNATURE = "__nuxt_error";
const useError = () => toRef(useNuxtApp().payload, "error");
const showError = (error) => {
  const nuxtError = createError(error);
  try {
    const nuxtApp = useNuxtApp();
    const error2 = useError();
    if (false) ;
    error2.value || (error2.value = nuxtError);
  } catch {
    throw nuxtError;
  }
  return nuxtError;
};
const isNuxtError = (error) => !!error && typeof error === "object" && NUXT_ERROR_SIGNATURE in error;
const createError = (error) => {
  const nuxtError = createError$1(error);
  Object.defineProperty(nuxtError, NUXT_ERROR_SIGNATURE, {
    value: true,
    configurable: false,
    writable: false
  });
  return nuxtError;
};

const unhead_k2P3m_ZDyjlr2mMYnoDPwavjsDN8hBlk9cFai0bbopU = defineNuxtPlugin({
  name: "nuxt:head",
  enforce: "pre",
  setup(nuxtApp) {
    const head = nuxtApp.ssrContext.head;
    nuxtApp.vueApp.use(head);
  }
});

function toArray$1(value) {
  return Array.isArray(value) ? value : [value];
}

async function getRouteRules(arg) {
  const path = typeof arg === "string" ? arg : arg.path;
  {
    useNuxtApp().ssrContext._preloadManifest = true;
    const _routeRulesMatcher = toRouteMatcher(
      createRouter({ routes: useRuntimeConfig().nitro.routeRules })
    );
    return defu({}, ..._routeRulesMatcher.matchAll(path).reverse());
  }
}

const LayoutMetaSymbol = Symbol("layout-meta");
const PageRouteSymbol = Symbol("route");

const useRouter = () => {
  var _a;
  return (_a = useNuxtApp()) == null ? void 0 : _a.$router;
};
const useRoute = () => {
  if (hasInjectionContext()) {
    return inject(PageRouteSymbol, useNuxtApp()._route);
  }
  return useNuxtApp()._route;
};
// @__NO_SIDE_EFFECTS__
function defineNuxtRouteMiddleware(middleware) {
  return middleware;
}
const isProcessingMiddleware = () => {
  try {
    if (useNuxtApp()._processingMiddleware) {
      return true;
    }
  } catch {
    return false;
  }
  return false;
};
const URL_QUOTE_RE = /"/g;
const navigateTo = (to, options) => {
  to || (to = "/");
  const toPath = typeof to === "string" ? to : "path" in to ? resolveRouteObject(to) : useRouter().resolve(to).href;
  const isExternalHost = hasProtocol(toPath, { acceptRelative: true });
  const isExternal = (options == null ? void 0 : options.external) || isExternalHost;
  if (isExternal) {
    if (!(options == null ? void 0 : options.external)) {
      throw new Error("Navigating to an external URL is not allowed by default. Use `navigateTo(url, { external: true })`.");
    }
    const { protocol } = new URL(toPath, "http://localhost");
    if (protocol && isScriptProtocol(protocol)) {
      throw new Error(`Cannot navigate to a URL with '${protocol}' protocol.`);
    }
  }
  const inMiddleware = isProcessingMiddleware();
  const router = useRouter();
  const nuxtApp = useNuxtApp();
  {
    if (nuxtApp.ssrContext) {
      const fullPath = typeof to === "string" || isExternal ? toPath : router.resolve(to).fullPath || "/";
      const location2 = isExternal ? toPath : joinURL(useRuntimeConfig().app.baseURL, fullPath);
      const redirect = async function(response) {
        await nuxtApp.callHook("app:redirected");
        const encodedLoc = location2.replace(URL_QUOTE_RE, "%22");
        const encodedHeader = encodeURL(location2, isExternalHost);
        nuxtApp.ssrContext._renderResponse = {
          statusCode: sanitizeStatusCode((options == null ? void 0 : options.redirectCode) || 302, 302),
          body: `<!DOCTYPE html><html><head><meta http-equiv="refresh" content="0; url=${encodedLoc}"></head></html>`,
          headers: { location: encodedHeader }
        };
        return response;
      };
      if (!isExternal && inMiddleware) {
        router.afterEach((final) => final.fullPath === fullPath ? redirect(false) : void 0);
        return to;
      }
      return redirect(!inMiddleware ? void 0 : (
        /* abort route navigation */
        false
      ));
    }
  }
  if (isExternal) {
    nuxtApp._scope.stop();
    if (options == null ? void 0 : options.replace) {
      (void 0).replace(toPath);
    } else {
      (void 0).href = toPath;
    }
    if (inMiddleware) {
      if (!nuxtApp.isHydrating) {
        return false;
      }
      return new Promise(() => {
      });
    }
    return Promise.resolve();
  }
  return (options == null ? void 0 : options.replace) ? router.replace(to) : router.push(to);
};
function resolveRouteObject(to) {
  return withQuery(to.path || "", to.query || {}) + (to.hash || "");
}
function encodeURL(location2, isExternalHost = false) {
  const url = new URL(location2, "http://localhost");
  if (!isExternalHost) {
    return url.pathname + url.search + url.hash;
  }
  if (location2.startsWith("//")) {
    return url.toString().replace(url.protocol, "");
  }
  return url.toString();
}

function handleHotUpdate(_router, _generateRoutes) {
}
const _routes = [
  {
    name: "about",
    path: "/about",
    component: () => import('./about.vue.mjs')
  },
  {
    name: "cases",
    path: "/cases",
    component: () => import('./cases.vue.mjs')
  },
  {
    name: "index",
    path: "/",
    component: () => import('./index.vue.mjs')
  },
  {
    name: "contact",
    path: "/contact",
    component: () => import('./contact.vue.mjs')
  },
  {
    name: "products",
    path: "/products",
    component: () => import('./products.vue.mjs')
  },
  {
    name: "solutions",
    path: "/solutions",
    component: () => import('./solutions.vue.mjs')
  }
];

const _wrapInTransition = (props, children) => {
  return { default: () => {
    var _a;
    return (_a = children.default) == null ? void 0 : _a.call(children);
  } };
};
const ROUTE_KEY_PARENTHESES_RE = /(:\w+)\([^)]+\)/g;
const ROUTE_KEY_SYMBOLS_RE = /(:\w+)[?+*]/g;
const ROUTE_KEY_NORMAL_RE = /:\w+/g;
function generateRouteKey(route) {
  const source = (route == null ? void 0 : route.meta.key) ?? route.path.replace(ROUTE_KEY_PARENTHESES_RE, "$1").replace(ROUTE_KEY_SYMBOLS_RE, "$1").replace(ROUTE_KEY_NORMAL_RE, (r) => {
    var _a;
    return ((_a = route.params[r.slice(1)]) == null ? void 0 : _a.toString()) || "";
  });
  return typeof source === "function" ? source(route) : source;
}
function isChangingPage(to, from) {
  if (to === from || from === START_LOCATION) {
    return false;
  }
  if (generateRouteKey(to) !== generateRouteKey(from)) {
    return true;
  }
  const areComponentsSame = to.matched.every(
    (comp, index) => {
      var _a, _b;
      return comp.components && comp.components.default === ((_b = (_a = from.matched[index]) == null ? void 0 : _a.components) == null ? void 0 : _b.default);
    }
  );
  if (areComponentsSame) {
    return false;
  }
  return true;
}

const routerOptions0 = {
  scrollBehavior(to, from, savedPosition) {
    var _a;
    const nuxtApp = useNuxtApp();
    const behavior = ((_a = useRouter().options) == null ? void 0 : _a.scrollBehaviorType) ?? "auto";
    let position = savedPosition || void 0;
    const routeAllowsScrollToTop = typeof to.meta.scrollToTop === "function" ? to.meta.scrollToTop(to, from) : to.meta.scrollToTop;
    if (!position && from && to && routeAllowsScrollToTop !== false && isChangingPage(to, from)) {
      position = { left: 0, top: 0 };
    }
    if (to.path === from.path) {
      if (from.hash && !to.hash) {
        return { left: 0, top: 0 };
      }
      if (to.hash) {
        return { el: to.hash, top: _getHashElementScrollMarginTop(to.hash), behavior };
      }
      return false;
    }
    const hasTransition = (route) => !!(route.meta.pageTransition ?? appPageTransition);
    const hookToWait = hasTransition(from) && hasTransition(to) ? "page:transition:finish" : "page:loading:end";
    return new Promise((resolve) => {
      nuxtApp.hooks.hookOnce(hookToWait, () => {
        requestAnimationFrame(() => resolve(_calculatePosition(to, "instant", position)));
      });
    });
  }
};
function _getHashElementScrollMarginTop(selector) {
  try {
    const elem = (void 0).querySelector(selector);
    if (elem) {
      return (Number.parseFloat(getComputedStyle(elem).scrollMarginTop) || 0) + (Number.parseFloat(getComputedStyle((void 0).documentElement).scrollPaddingTop) || 0);
    }
  } catch {
  }
  return 0;
}
function _calculatePosition(to, scrollBehaviorType, position) {
  if (position) {
    return position;
  }
  if (to.hash) {
    return {
      el: to.hash,
      top: _getHashElementScrollMarginTop(to.hash),
      behavior: scrollBehaviorType
    };
  }
  return { left: 0, top: 0, behavior: scrollBehaviorType };
}

const configRouterOptions = {
  hashMode: false,
  scrollBehaviorType: "auto"
};
const routerOptions = {
  ...configRouterOptions,
  ...routerOptions0
};

const validate = defineNuxtRouteMiddleware(async (to) => {
  var _a;
  let __temp, __restore;
  if (!((_a = to.meta) == null ? void 0 : _a.validate)) {
    return;
  }
  const nuxtApp = useNuxtApp();
  const router = useRouter();
  const result = ([__temp, __restore] = executeAsync(() => Promise.resolve(to.meta.validate(to))), __temp = await __temp, __restore(), __temp);
  if (result === true) {
    return;
  }
  const error = createError({
    statusCode: result && result.statusCode || 404,
    statusMessage: result && result.statusMessage || `Page Not Found: ${to.fullPath}`,
    data: {
      path: to.fullPath
    }
  });
  const unsub = router.beforeResolve((final) => {
    unsub();
    if (final === to) {
      const unsub2 = router.afterEach(async () => {
        unsub2();
        await nuxtApp.runWithContext(() => showError(error));
      });
      return false;
    }
  });
});

const manifest_45route_45rule = defineNuxtRouteMiddleware(async (to) => {
  {
    return;
  }
});

const globalMiddleware = [
  validate,
  manifest_45route_45rule
];
const namedMiddleware = {};

const plugin = defineNuxtPlugin({
  name: "nuxt:router",
  enforce: "pre",
  async setup(nuxtApp) {
    var _a, _b, _c, _d;
    let __temp, __restore;
    let routerBase = useRuntimeConfig().app.baseURL;
    const history = ((_b = (_a = routerOptions).history) == null ? void 0 : _b.call(_a, routerBase)) ?? createMemoryHistory(routerBase);
    const routes = routerOptions.routes ? ([__temp, __restore] = executeAsync(() => routerOptions.routes(_routes)), __temp = await __temp, __restore(), __temp) ?? _routes : _routes;
    let startPosition;
    const router = createRouter$1({
      ...routerOptions,
      scrollBehavior: (to, from, savedPosition) => {
        if (from === START_LOCATION) {
          startPosition = savedPosition;
          return;
        }
        if (routerOptions.scrollBehavior) {
          router.options.scrollBehavior = routerOptions.scrollBehavior;
          if ("scrollRestoration" in (void 0).history) {
            const unsub = router.beforeEach(() => {
              unsub();
              (void 0).history.scrollRestoration = "manual";
            });
          }
          return routerOptions.scrollBehavior(to, START_LOCATION, startPosition || savedPosition);
        }
      },
      history,
      routes
    });
    handleHotUpdate(router, routerOptions.routes ? routerOptions.routes : (routes2) => routes2);
    nuxtApp.vueApp.use(router);
    const previousRoute = shallowRef(router.currentRoute.value);
    router.afterEach((_to, from) => {
      previousRoute.value = from;
    });
    Object.defineProperty(nuxtApp.vueApp.config.globalProperties, "previousRoute", {
      get: () => previousRoute.value
    });
    const initialURL = nuxtApp.ssrContext.url;
    const _route = shallowRef(router.currentRoute.value);
    const syncCurrentRoute = () => {
      _route.value = router.currentRoute.value;
    };
    nuxtApp.hook("page:finish", syncCurrentRoute);
    router.afterEach((to, from) => {
      var _a2, _b2, _c2, _d2;
      if (((_b2 = (_a2 = to.matched[0]) == null ? void 0 : _a2.components) == null ? void 0 : _b2.default) === ((_d2 = (_c2 = from.matched[0]) == null ? void 0 : _c2.components) == null ? void 0 : _d2.default)) {
        syncCurrentRoute();
      }
    });
    const route = {};
    for (const key in _route.value) {
      Object.defineProperty(route, key, {
        get: () => _route.value[key],
        enumerable: true
      });
    }
    nuxtApp._route = shallowReactive(route);
    nuxtApp._middleware || (nuxtApp._middleware = {
      global: [],
      named: {}
    });
    useError();
    if (!((_c = nuxtApp.ssrContext) == null ? void 0 : _c.islandContext)) {
      router.afterEach(async (to, _from, failure) => {
        delete nuxtApp._processingMiddleware;
        if (failure) {
          await nuxtApp.callHook("page:loading:end");
        }
        if ((failure == null ? void 0 : failure.type) === 4) {
          return;
        }
        if (to.redirectedFrom && to.fullPath !== initialURL) {
          await nuxtApp.runWithContext(() => navigateTo(to.fullPath || "/"));
        }
      });
    }
    try {
      if (true) {
        ;
        [__temp, __restore] = executeAsync(() => router.push(initialURL)), await __temp, __restore();
        ;
      }
      ;
      [__temp, __restore] = executeAsync(() => router.isReady()), await __temp, __restore();
      ;
    } catch (error2) {
      [__temp, __restore] = executeAsync(() => nuxtApp.runWithContext(() => showError(error2))), await __temp, __restore();
    }
    const resolvedInitialRoute = router.currentRoute.value;
    syncCurrentRoute();
    if ((_d = nuxtApp.ssrContext) == null ? void 0 : _d.islandContext) {
      return { provide: { router } };
    }
    const initialLayout = nuxtApp.payload.state._layout;
    router.beforeEach(async (to, from) => {
      var _a2, _b2, _c2;
      await nuxtApp.callHook("page:loading:start");
      to.meta = reactive(to.meta);
      if (nuxtApp.isHydrating && initialLayout && !isReadonly(to.meta.layout)) {
        to.meta.layout = initialLayout;
      }
      nuxtApp._processingMiddleware = true;
      if (!((_a2 = nuxtApp.ssrContext) == null ? void 0 : _a2.islandContext)) {
        const middlewareEntries = /* @__PURE__ */ new Set([...globalMiddleware, ...nuxtApp._middleware.global]);
        for (const component of to.matched) {
          const componentMiddleware = component.meta.middleware;
          if (!componentMiddleware) {
            continue;
          }
          for (const entry of toArray$1(componentMiddleware)) {
            middlewareEntries.add(entry);
          }
        }
        {
          const routeRules = await nuxtApp.runWithContext(() => getRouteRules({ path: to.path }));
          if (routeRules.appMiddleware) {
            for (const key in routeRules.appMiddleware) {
              if (routeRules.appMiddleware[key]) {
                middlewareEntries.add(key);
              } else {
                middlewareEntries.delete(key);
              }
            }
          }
        }
        for (const entry of middlewareEntries) {
          const middleware = typeof entry === "string" ? nuxtApp._middleware.named[entry] || await ((_c2 = (_b2 = namedMiddleware)[entry]) == null ? void 0 : _c2.call(_b2).then((r) => r.default || r)) : entry;
          if (!middleware) {
            throw new Error(`Unknown route middleware: '${entry}'.`);
          }
          try {
            const result = await nuxtApp.runWithContext(() => middleware(to, from));
            if (true) {
              if (result === false || result instanceof Error) {
                const error2 = result || createError$1({
                  statusCode: 404,
                  statusMessage: `Page Not Found: ${initialURL}`
                });
                await nuxtApp.runWithContext(() => showError(error2));
                return false;
              }
            }
            if (result === true) {
              continue;
            }
            if (result === false) {
              return result;
            }
            if (result) {
              if (isNuxtError(result) && result.fatal) {
                await nuxtApp.runWithContext(() => showError(result));
              }
              return result;
            }
          } catch (err) {
            const error2 = createError$1(err);
            if (error2.fatal) {
              await nuxtApp.runWithContext(() => showError(error2));
            }
            return error2;
          }
        }
      }
    });
    router.onError(async () => {
      delete nuxtApp._processingMiddleware;
      await nuxtApp.callHook("page:loading:end");
    });
    router.afterEach(async (to, _from) => {
      if (to.matched.length === 0) {
        await nuxtApp.runWithContext(() => showError(createError$1({
          statusCode: 404,
          fatal: false,
          statusMessage: `Page not found: ${to.fullPath}`,
          data: {
            path: to.fullPath
          }
        })));
      }
    });
    nuxtApp.hooks.hookOnce("app:created", async () => {
      try {
        if ("name" in resolvedInitialRoute) {
          resolvedInitialRoute.name = void 0;
        }
        await router.replace({
          ...resolvedInitialRoute,
          force: true
        });
        router.options.scrollBehavior = routerOptions.scrollBehavior;
      } catch (error2) {
        await nuxtApp.runWithContext(() => showError(error2));
      }
    });
    return { provide: { router } };
  }
});

function definePayloadReducer(name, reduce) {
  {
    useNuxtApp().ssrContext._payloadReducers[name] = reduce;
  }
}

const reducers = [
  ["NuxtError", (data) => isNuxtError(data) && data.toJSON()],
  ["EmptyShallowRef", (data) => isRef(data) && isShallow(data) && !data.value && (typeof data.value === "bigint" ? "0n" : JSON.stringify(data.value) || "_")],
  ["EmptyRef", (data) => isRef(data) && !data.value && (typeof data.value === "bigint" ? "0n" : JSON.stringify(data.value) || "_")],
  ["ShallowRef", (data) => isRef(data) && isShallow(data) && data.value],
  ["ShallowReactive", (data) => isReactive(data) && isShallow(data) && toRaw(data)],
  ["Ref", (data) => isRef(data) && data.value],
  ["Reactive", (data) => isReactive(data) && toRaw(data)]
];
const revive_payload_server_MVtmlZaQpj6ApFmshWfUWl5PehCebzaBf2NuRMiIbms = defineNuxtPlugin({
  name: "nuxt:revive-payload:server",
  setup() {
    for (const [reducer, fn] of reducers) {
      definePayloadReducer(reducer, fn);
    }
  }
});

const components_plugin_z4hgvsiddfKkfXTP6M8M4zG5Cb7sGnDhcryKVM45Di4 = defineNuxtPlugin({
  name: "nuxt:global-components"
});

const nav$1 = { "home": "首页", "products": "AWS产品", "solutions": "解决方案", "cases": "客户案例", "about": "关于我们", "contact": "联系我们" };
const common$1 = { "appName": "云服务专家", "switchLanguage": "Language", "loading": "加载中...", "readMore": "了解更多", "contactUs": "联系我们", "contactAdvisor": "联系顾问", "learnMore": "了解详情", "viewDetails": "查看详情", "close": "关闭" };
const home$1 = { "hero": { "title": "AWS云服务器专业代理商", "subtitle": "为您的企业提供专业的AWS云服务解决方案，助力数字化转型", "learnButton": "了解AWS优势", "contactButton": "联系顾问" }, "features": { "title": "AWS产品与服务", "subtitle": "全面的云计算产品线，满足您的各种业务需求", "description": "作为AWS授权代理商，我们提供全系列AWS产品和服务，并为您提供专业的咨询和支持，帮助您选择最适合的产品组合。", "security": { "title": "安全可靠", "description": "AWS提供业界领先的安全服务，包括加密、防火墙和身份验证，保障您的数据安全" }, "performance": { "title": "高性能", "description": "全球数据中心网络，低延迟高带宽，确保您的应用程序高效运行" }, "cost": { "title": "成本优化", "description": "按需付费模式，无需前期投资，降低IT运营成本" } }, "services": { "title": "我们的服务优势", "subtitle": "作为AWS授权合作伙伴，我们提供全方位的专业服务", "official": { "title": "官方授权", "description": "我们是AWS官方授权的合作伙伴，可提供正规授权和发票" }, "price": { "title": "价格优势", "description": "相比直接采购，我们能提供更具竞争力的价格和灵活的付款方式" }, "support": { "title": "技术支持", "description": "专业的技术团队提供咨询、部署和运维服务，解决您的技术难题" }, "training": { "title": "培训服务", "description": "为您的团队提供专业的AWS技术培训，提升技术能力" } }, "products": { "title": "AWS核心产品服务", "subtitle": "全面的云服务产品线，满足各种业务需求", "viewAll": "查看全部AWS产品", "detail": "了解详情", "ec2": { "title": "EC2 云服务器", "description": "可扩展的计算能力，适用于各种工作负载，从小型网站到企业级应用" }, "s3": { "title": "S3 对象存储", "description": "安全、可靠的对象存储服务，适用于备份、归档和数据湖等场景" }, "rds": { "title": "RDS 关系型数据库", "description": "易于部署和管理的关系型数据库服务，支持多种主流数据库引擎" } }, "cases": { "title": "成功客户案例", "subtitle": "看看其他企业如何利用AWS云服务提升业务价值", "readMore": "阅读详情", "fintech": { "title": "某金融科技公司", "description": "通过迁移到AWS云服务，该公司将应用响应时间缩短了40%，并节省了30%的IT运营成本" }, "ecommerce": { "title": "某电商平台", "description": "利用AWS弹性伸缩服务，轻松应对销售高峰期流量，提高了用户体验和订单转化率" } } };
const footer$1 = { "description": "专业的AWS云服务解决方案提供商，致力于帮助企业实现数字化转型", "products": "AWS产品", "solutions": "解决方案", "contactUs": "联系我们", "address": "北京市朝阳区某某大厦10层", "phone": "400-123-4567", "email": "contact@example.com", "allRightsReserved": "保留所有权利", "productLinks": { "ec2": "EC2 云服务器", "s3": "S3 对象存储", "rds": "RDS 数据库服务", "lambda": "Lambda 无服务器", "more": "更多产品..." }, "solutionLinks": { "web": "网站托管", "enterprise": "企业上云", "disaster": "灾备方案", "bigdata": "大数据分析", "microservice": "微服务架构" } };
const about$1 = { "hero": { "title": "关于我们", "subtitle": "专业的AWS云服务解决方案提供商，助力企业数字化转型" }, "company": { "title": "公司简介", "description1": "云服务专家成立于2018年，是AWS授权的云服务解决方案提供商。我们致力于为企业提供专业的云计算咨询、迁移、运维和优化服务。", "description2": "作为AWS高级合作伙伴，我们拥有丰富的云服务实施经验和专业的技术团队，已成功帮助数百家企业完成云上转型。" }, "achievements": { "item1": "AWS高级合作伙伴认证", "item2": "100+成功案例", "item3": "50+AWS认证工程师" }, "advantages": { "title": "我们的优势", "subtitle": "专业技术团队，丰富项目经验", "certification": { "title": "专业认证", "description": "AWS官方认证的高级合作伙伴，拥有多项专业认证" }, "team": { "title": "专业团队", "description": "50+位AWS认证工程师，平均5年以上云服务经验" }, "technical": { "title": "技术实力", "description": "掌握AWS全线产品，具备丰富的实施和运维经验" }, "service": { "title": "服务保障", "description": "7x24小时技术支持，确保客户业务稳定运行" } }, "culture": { "title": "企业文化", "subtitle": "以客户为中心，追求卓越服务", "mission": { "title": "企业使命", "description": "助力企业数字化转型，提供专业可靠的云计算服务" }, "vision": { "title": "企业愿景", "description": "成为中国最值得信赖的云服务解决方案提供商" }, "values": { "title": "核心价值观", "description": "专业、创新、诚信、共赢" } }, "history": { "title": "发展历程", "subtitle": "见证我们的成长与进步", "year2023": { "year": "2023年", "description": "成为AWS高级合作伙伴，服务客户数量突破500家" }, "year2021": { "year": "2021年", "description": "获得AWS标准合作伙伴认证，团队规模扩大到50人" }, "year2018": { "year": "2018年", "description": "公司成立，开始提供AWS云服务解决方案" } }, "contact": { "title": "想了解更多关于我们?", "subtitle": "欢迎联系我们，了解更多公司信息和服务详情", "button": "联系我们" } };
const products$1 = { "hero": { "title": "AWS产品", "subtitle": "全面的云计算产品线，满足您的各种业务需求" }, "categories": { "title": "AWS全线产品", "subtitle": "覆盖计算、存储、数据库、网络、安全等多个领域", "compute": { "name": "计算服务", "description": "包括EC2、Lambda等，提供灵活的计算能力" }, "storage": { "name": "存储服务", "description": "包括S3、EBS等，提供可靠的数据存储解决方案" }, "network": { "name": "网络服务", "description": "包括VPC、Route 53等，提供安全灵活的网络管理" }, "security": { "name": "安全与身份", "description": "包括IAM、GuardDuty等，提供全面的安全防护" }, "monitoring": { "name": "监控与管理", "description": "包括CloudWatch、Systems Manager等，提供全面的监控和管理工具" }, "ai": { "name": "人工智能", "description": "包括SageMaker、Rekognition等，提供先进的AI服务" }, "viewProducts": "查看产品" }, "productList": { "title": "热门产品服务", "subtitle": "AWS核心产品详细介绍", "advantages": "产品优势", "pricing": "价格", "inquiry": "咨询详情", "ec2": { "name": "Amazon EC2", "description": "Amazon Elastic Compute Cloud (EC2) 是一种提供可扩展计算能力的网络服务，专为云端计算设计。使用 EC2 可消除前期硬件投资，因此您能够更快地开发和部署应用程序。", "features": ["灵活选择实例类型，适应不同应用场景", "按秒计费，降低运营成本", "自动扩展，应对业务峰值", "高可用性和可靠性保障"], "pricing": "按需付费，起价低至¥0.1/小时" }, "s3": { "name": "Amazon S3", "description": "Amazon Simple Storage Service (S3) 是一种对象存储服务，提供行业领先的可扩展性、数据可用性、安全性和性能。这意味着任何规模的企业都可以存储和保护任意数量的数据。", "features": ["无限容量扩展，适合任何规模的数据存储", "99.999999999% 的数据持久性", "多种存储类别，优化成本", "强大的访问控制和加密功能"], "pricing": "按存储量和请求数付费，起价低至¥0.2/GB/月" }, "rds": { "name": "Amazon RDS", "description": "Amazon Relational Database Service (RDS) 使在云中设置、操作和扩展关系数据库变得简单。它提供经济高效且可调整容量的容量，同时自动执行耗时的管理任务。", "features": ["支持多种数据库引擎：MySQL、PostgreSQL、Oracle等", "自动备份和恢复功能", "高可用性主备部署", "自动软件更新和维护"], "pricing": "按实例类型计费，起价低至¥0.5/小时" } }, "advantages": { "title": "我们的优势", "subtitle": "作为AWS授权合作伙伴，我们提供专业的AWS产品咨询和部署服务", "deployment": { "title": "快速部署", "description": "专业的团队帮助您快速部署AWS产品，缩短上线时间" }, "cost": { "title": "成本优化", "description": "根据业务需求，为您定制最优成本方案，避免资源浪费" }, "security": { "title": "安全保障", "description": "提供全面的安全评估和最佳实践，保障业务安全" }, "support": { "title": "专业支持", "description": "7*24小时技术支持，解决您使用过程中的各种问题" } }, "contact": { "title": "想了解更多产品信息?", "subtitle": "我们的AWS产品专家将为您提供详细的产品介绍和价格咨询", "button": "联系产品顾问" } };
const solutions$1 = { "hero": { "title": "解决方案", "subtitle": "针对不同行业和业务场景的专业AWS云服务解决方案" }, "categories": { "title": "AWS云解决方案", "subtitle": "基于AWS云服务，为不同行业提供专业解决方案", "viewDetails": "查看详情" }, "solutionItems": { "webHosting": { "title": "网站托管", "description": "高性能、高可用的网站托管解决方案，适用于各类网站和Web应用", "icon": "fas fa-globe" }, "cloudMigration": { "title": "企业上云", "description": "安全、平稳的企业IT系统云迁移方案，最小化业务中断风险", "icon": "fas fa-cloud-upload-alt" }, "disasterRecovery": { "title": "灾备方案", "description": "构建可靠的灾难恢复系统，保障业务连续性和数据安全", "icon": "fas fa-shield-alt" }, "bigData": { "title": "大数据分析", "description": "基于AWS大数据服务的数据处理和分析解决方案", "icon": "fas fa-chart-pie" }, "microservices": { "title": "微服务架构", "description": "基于容器和无服务器技术的现代应用架构解决方案", "icon": "fas fa-cubes" }, "aiMl": { "title": "AI/机器学习", "description": "利用AWS AI/ML服务快速构建智能应用的解决方案", "icon": "fas fa-brain" } }, "solutionDetails": { "advantages": "解决方案优势", "industries": "适用行业", "inquiry": "咨询方案", "webHosting": { "title": "网站托管解决方案", "description": "基于AWS云服务的高性能、高可用、安全的网站托管解决方案，适用于企业官网、电子商务网站、内容管理系统等各类Web应用。利用AWS全球基础设施和CDN服务，为全球用户提供低延迟的访问体验。", "benefits": ["高可用性架构，99.99%服务可用性保障", "自动扩展能力，应对流量峰值", "CDN加速，全球用户低延迟访问", "完善的安全防护，包括WAF、DDoS防护等", "按需付费，降低运营成本"], "industries": ["电子商务", "媒体", "教育", "企业服务"] }, "cloudMigration": { "title": "企业上云解决方案", "description": "为传统IT基础设施提供安全、可靠的云迁移路径，帮助企业实现从本地数据中心到AWS云的平稳过渡。我们的解决方案涵盖评估、规划、迁移和优化的全过程，最大限度地减少业务中断和迁移风险。", "benefits": ["专业的迁移评估和规划服务", "多种迁移策略：重新托管、重新平台化、重构等", "数据安全迁移，确保零数据丢失", "迁移过程中的业务连续性保障", "迁移后的性能优化和成本控制"], "industries": ["金融", "制造", "零售", "医疗", "政府"] }, "disasterRecovery": { "title": "灾备解决方案", "description": "基于AWS云服务构建可靠的灾难恢复系统，帮助企业应对各种灾难情况下的业务连续性挑战。我们提供从灾备规划到实施、测试和运维的一站式服务，保障企业数据安全和业务连续性。", "benefits": ["多区域架构，提供地理级别的灾难恢复能力", "灵活的恢复点目标(RPO)和恢复时间目标(RTO)选项", "自动化的灾难恢复流程，减少人为错误", "定期的灾备演练和测试服务", "成本优化的灾备架构设计"], "industries": ["金融", "医疗", "能源", "电信", "政府"] }, "bigData": { "title": "大数据分析解决方案", "description": "利用AWS丰富的大数据服务，构建高效、可扩展的数据处理和分析平台。我们的解决方案可以帮助企业从海量数据中提取价值，支持数据仓库、实时分析、机器学习等多种大数据应用场景。", "benefits": ["高性能的数据处理能力，处理PB级数据", "灵活的存储选项，优化成本和性能", "实时数据处理和分析能力", "与机器学习服务的无缝集成", "可视化的数据分析工具"], "industries": ["金融", "零售", "医疗", "制造", "物流"] } }, "implementation": { "title": "解决方案实施流程", "subtitle": "专业、高效的项目实施流程，确保方案平稳落地", "steps": { "step1": { "title": "需求分析", "description": "深入了解客户业务需求和技术环境，确定解决方案目标和范围" }, "step2": { "title": "方案设计", "description": "根据需求分析结果，设计定制化的AWS云解决方案架构" }, "step3": { "title": "实施部署", "description": "专业团队按计划实施解决方案，确保系统稳定可靠" }, "step4": { "title": "测试验收", "description": "全面测试系统功能和性能，确保满足业务需求" }, "step5": { "title": "上线运维", "description": "系统正式上线，并提供持续的运维和优化服务" } } }, "cases": { "title": "客户成功案例", "subtitle": "我们的解决方案已成功应用于众多行业", "viewDetails": "查看详情" }, "contact": { "title": "需要定制化解决方案?", "subtitle": "联系我们的解决方案专家，获取专业的AWS云服务解决方案建议", "button": "联系解决方案专家" } };
const cases$1 = { "hero": { "title": "客户案例", "subtitle": "看看其他企业如何利用AWS云服务提升业务价值" }, "filter": { "byIndustry": "按行业筛选：", "all": "全部", "sortBy": "排序方式：", "latest": "最新案例", "default": "默认排序" }, "industries": { "finance": "金融", "ecommerce": "电子商务", "manufacturing": "制造业", "healthcare": "医疗健康", "education": "教育", "government": "政府", "media": "媒体", "logistics": "物流" }, "caseStudies": { "ecommerce": { "industry": "电子商务", "title": "电子商务平台云转型", "summary": "一家领先的电子商务平台通过AWS云架构实现了网站性能提升60%，成本降低40%", "background": "一家拥有超过1000万月活跃用户的大型电子商务平台在传统基础设施上面临性能瓶颈和可扩展性挑战，尤其是在促销期间。", "challenges": ["传统基础设施无法应对促销活动期间的流量峰值", "高维护成本但资源利用率低", "部署周期长，影响业务敏捷性", "安全隐患和合规要求日益增加"], "solution": "我们设计并实施了一个全面的AWS云架构，利用EC2自动扩展、Amazon RDS、ElastiCache、CloudFront CDN和S3进行静态内容存储。解决方案包括使用ECS容器化其应用程序，并实施CI/CD流水线以实现快速部署。", "results": ["整体网站性能提升60%", "促销期间轻松应对10倍流量峰值", "基础设施成本降低40%", "部署时间从数天缩短至数分钟", "通过实施AWS Shield和WAF增强安全性"] }, "finance": { "industry": "金融", "title": "金融服务提供商的安全云迁移", "summary": "一家金融服务公司成功将核心系统迁移到AWS云，提高了安全性并实现了99.99%的可用性", "background": "一家中型金融服务提供商需要现代化其基础设施，同时满足严格的监管要求，确保其服务具有最高水平的安全性和可用性。", "challenges": ["严格的监管合规要求(PCI DSS、SOX)", "迁移期间零停机时间的要求", "高度敏感的金融数据安全顾虑", "复杂的遗留系统集成"], "solution": "我们实施了一个安全、合规的AWS架构，利用专用VPC与私有子网、静态和传输中的加密、全面的IAM策略和多层安全控制。迁移采用了分阶段方法，并进行了全面测试以确保业务连续性。", "results": ["零停机时间成功迁移", "实现99.99%的服务可用性", "完全符合金融行业法规", "运营成本降低35%", "灾难恢复能力增强，RTO降至15分钟"] }, "healthcare": { "industry": "医疗健康", "title": "医疗机构的数据平台现代化", "summary": "一家医疗机构在AWS上构建了符合HIPAA的数据分析平台，改善了患者护理和运营效率", "background": "一家拥有多个设施的医疗提供商需要整合并分析其组织内的患者和运营数据，同时确保符合医疗法规。", "challenges": ["不同部门和设施之间的数据孤岛", "严格的HIPAA合规要求", "临床决策支持需要实时分析", "遗留系统集成能力有限"], "solution": "我们使用AWS的S3、Glue、Lambda和QuickSight设计了符合HIPAA的数据湖和分析平台。该解决方案包括安全的ETL流程、数据加密、全面的访问控制和审计跟踪，以确保合规性和数据安全性。", "results": ["所有设施的患者数据整合视图", "报告生成时间减少50%", "通过实时分析改善临床决策", "完全HIPAA合规，具有全面的审计跟踪", "通过流程优化减少30%的管理成本"] }, "manufacturing": { "industry": "制造业", "title": "制造公司的物联网实施", "summary": "一家制造公司实施AWS物联网解决方案，实现生产力提升25%和预测性维护能力", "background": "一家拥有多个生产设施的制造公司希望利用物联网技术监控设备性能、预测维护需求并优化生产流程。", "challenges": ["对各设施设备性能的可见性有限", "反应式维护导致计划外停机", "资源分配和生产调度效率低下", "遗留设备连接选项有限"], "solution": "我们使用AWS的IoT Core、Greengrass、SiteWise和Kinesis实施了全面的物联网解决方案，用于数据采集和处理。该解决方案包括为遗留设备定制网关、实时仪表板和用于预测性维护的机器学习模型。", "results": ["整体设备效率提高25%", "通过预测性维护减少45%的计划外停机时间", "生产吞吐量增加15%", "实时查看所有设施的运营情况", "数据驱动决策用于资源分配和调度"] }, "logistics": { "industry": "物流", "title": "物流公司的供应链优化", "summary": "一家物流公司通过基于AWS的供应链管理平台精简了运营并降低了30%的成本", "background": "一家物流和供应链公司需要优化其覆盖多个国家的配送网络，改进跟踪能力，并提高其运营的整体效率。", "challenges": ["全球供应链网络可见性有限", "路线规划和资源分配效率低下", "手动流程导致延误和错误", "缺乏客户实时跟踪和状态更新"], "solution": "我们使用基于ECS、API Gateway、DynamoDB和AWS IoT的微服务架构在AWS上开发了全面的供应链管理平台。该解决方案包括用于需求预测和路线优化的机器学习模型。", "results": ["运营成本降低30%", "准时交付性能提升22%", "整个供应链的实时跟踪和可见性", "通过自动化减少40%的手动流程", "通过自助跟踪门户提升客户满意度"] }, "education": { "industry": "教育", "title": "教育机构的数字学习平台", "summary": "一家教育机构在AWS上构建了可扩展的数字学习平台，为5万多名学生提供服务，可用性达99.9%", "background": "一家大型教育机构需要开发全面的数字学习平台，以支持远程教育、内容交付和跨多个校区的学生协作。", "challenges": ["需要在高峰期支持5万多名同时在线用户", "教育资源和个人信息的安全访问", "与现有学生管理系统集成", "大型教育内容的成本效益存储和交付"], "solution": "我们使用EC2、ECS、S3、CloudFront和RDS组合在AWS上设计了可扩展的数字学习平台。该解决方案包括单点登录集成、内容管理系统、视频流功能和用于交互式学习的协作工具。", "results": ["成功支持5万多名并发用户，可用性达99.9%", "通过CloudFront将内容交付时间减少70%", "通过全面身份验证安全访问资源", "与现有学生信息系统无缝集成", "与传统基础设施相比成本降低40%"] }, "government": { "industry": "政府", "title": "政府机构的数字化转型", "summary": "一家政府机构通过AWS云实现了IT系统现代化，提高了公共服务效率并节省了45%的成本", "background": "一家大型政府机构需要更新过时的IT系统，以提高服务交付效率、降低运营成本并改善公民服务体验。", "challenges": ["陈旧的遗留系统导致维护成本高昂", "公民服务数字化交付能力有限", "安全和合规要求日益严格", "IT资源分配效率低下"], "solution": "我们设计并实施了一个全面的AWS云迁移策略，采用分阶段方法将关键系统迁移到AWS。解决方案包括现代化的应用程序架构、自动化部署和严格的安全控制，以满足政府标准。", "results": ["IT基础设施总成本降低45%", "公民服务数字化交付提高60%", "系统可用性从95%提升至99.9%", "新服务部署时间从数月减少到数周", "全面符合政府安全和合规标准"] }, "media": { "industry": "媒体", "title": "媒体公司的内容交付平台", "summary": "一家媒体公司在AWS上构建了可扩展的内容交付平台，支持数百万用户并降低了50%的交付成本", "background": "一家媒体和内容创作公司需要一个可靠、高性能的平台来存储、处理和交付其全球观众的视频和其他媒体内容。", "challenges": ["需要支持全球数百万并发用户", "处理和转码大量4K视频内容", "高昂的内容分发成本", "复杂的数字版权管理需求"], "solution": "我们在AWS上设计了一个基于S3、MediaConvert、CloudFront、Lambda和DynamoDB的全面内容交付平台。该解决方案包括自动转码工作流、全球内容交付网络和强大的用户认证系统。", "results": ["成功支持全球200万并发用户", "内容交付成本降低50%", "视频转码时间减少70%", "通过CloudFront实现全球内容低延迟交付", "全面保护数字版权和内容安全"] } }, "noResults": { "text": "没有找到符合条件的案例", "clearFilters": "清除筛选条件" }, "caseDetail": { "readDetails": "阅读详情", "background": "客户背景", "challenges": "面临挑战", "solution": "解决方案", "results": "业务成果", "close": "关闭" }, "contact": { "title": "想了解更多客户案例?", "subtitle": "联系我们获取更多行业相关的AWS云服务成功案例", "button": "联系我们" } };
const contact$1 = { "hero": { "title": "联系我们", "subtitle": "随时欢迎您的咨询，我们将为您提供专业的云服务解决方案" }, "methods": { "phone": { "title": "电话咨询", "subtitle": "周一至周日 9:00-21:00", "content": "400-123-4567" }, "email": { "title": "邮件咨询", "subtitle": "7*24小时邮件支持", "content": "contact@example.com" }, "wechat": { "title": "微信咨询", "subtitle": "扫描下方二维码" } }, "form": { "title": "在线咨询", "name": "姓名", "company": "公司名称", "email": "邮箱", "phone": "电话", "service": "咨询服务", "message": "咨询内容", "required": "必填", "placeholders": { "selectService": "请选择咨询服务" }, "serviceOptions": { "cloud": "云服务咨询", "migration": "上云迁移", "solution": "解决方案咨询", "price": "价格咨询", "other": "其他" }, "submit": "提交咨询", "submitting": "提交中..." }, "companyInfo": { "title": "公司地址", "beijing": { "title": "北京总部", "content": "北京市朝阳区某某大厦10层" }, "transport": { "title": "交通方式", "content": "地铁6号线某某站A出口步行5分钟" }, "hours": { "title": "办公时间", "content": "周一至周五: 9:00-18:00" } }, "faq": { "title": "常见问题", "subtitle": "解答您最关心的问题", "items": { "q1": { "question": "如何开始使用AWS云服务？", "answer": "您可以通过我们的咨询服务，获取专业的AWS云服务解决方案建议。我们的团队将根据您的具体需求，为您提供最适合的云服务方案。" }, "q2": { "question": "如何获取技术支持？", "answer": "我们提供7*24小时技术支持服务，您可以通过电话、邮件或在线咨询等方式联系我们的技术支持团队。" }, "q3": { "question": "如何计算使用成本？", "answer": "我们提供详细的成本评估服务，可以根据您的具体使用场景和需求，为您提供准确的成本预估和优化建议。" }, "q4": { "question": "如何申请试用服务？", "answer": "您可以通过在线咨询或直接联系我们的销售团队，申请AWS云服务的试用。我们将为您提供专业的试用方案和技术支持。" } } } };
const zh = {
  nav: nav$1,
  common: common$1,
  home: home$1,
  footer: footer$1,
  about: about$1,
  products: products$1,
  solutions: solutions$1,
  cases: cases$1,
  contact: contact$1
};

const nav = { "home": "Home", "products": "AWS Products", "solutions": "Solutions", "cases": "Case Studies", "about": "About Us", "contact": "Contact Us" };
const common = { "appName": "Cloud Service Expert", "switchLanguage": "语言", "loading": "Loading...", "readMore": "Read More", "contactUs": "Contact Us", "contactAdvisor": "Contact Advisor", "learnMore": "Learn More", "viewDetails": "View Details", "close": "Close" };
const home = { "hero": { "title": "AWS Cloud Service Professional Agent", "subtitle": "Providing professional AWS cloud service solutions for your enterprise to assist digital transformation", "learnButton": "Learn AWS Advantages", "contactButton": "Contact Consultant" }, "features": { "title": "AWS Products & Services", "subtitle": "Comprehensive cloud computing product line to meet your various business needs", "description": "As an authorized AWS agent, we provide a full range of AWS products and services, along with professional consultation and support to help you choose the most suitable product combination.", "security": { "title": "Security & Reliability", "description": "AWS provides industry-leading security services including encryption, firewalls, and authentication to protect your data" }, "performance": { "title": "High Performance", "description": "Global data center network with low latency and high bandwidth ensures your applications run efficiently" }, "cost": { "title": "Cost Optimization", "description": "Pay-as-you-go model with no upfront investment, reducing IT operational costs" } }, "services": { "title": "Our Service Advantages", "subtitle": "As an authorized AWS partner, we provide comprehensive professional services", "official": { "title": "Official Authorization", "description": "We are an officially authorized AWS partner, able to provide formal authorization and invoices" }, "price": { "title": "Price Advantage", "description": "Compared to direct procurement, we can offer more competitive prices and flexible payment methods" }, "support": { "title": "Technical Support", "description": "Our professional technical team provides consulting, deployment, and operation services to solve your technical challenges" }, "training": { "title": "Training Services", "description": "We provide professional AWS technical training for your team to enhance their technical capabilities" } }, "products": { "title": "AWS Core Product Services", "subtitle": "Comprehensive cloud service product line to meet various business needs", "viewAll": "View All AWS Products", "detail": "Learn More", "ec2": { "title": "EC2 Cloud Server", "description": "Scalable computing capacity suitable for various workloads, from small websites to enterprise applications" }, "s3": { "title": "S3 Object Storage", "description": "Secure, reliable object storage service suitable for backup, archiving, and data lake scenarios" }, "rds": { "title": "RDS Relational Database", "description": "Easy-to-deploy and manage relational database service supporting multiple mainstream database engines" } }, "cases": { "title": "Successful Customer Cases", "subtitle": "See how other businesses leverage AWS cloud services to enhance business value", "readMore": "Read More", "fintech": { "title": "A FinTech Company", "description": "By migrating to AWS cloud services, the company reduced application response time by 40% and saved 30% in IT operational costs" }, "ecommerce": { "title": "An E-commerce Platform", "description": "Using AWS elastic scaling services, they easily handled peak sales traffic, improving user experience and order conversion rates" } } };
const footer = { "description": "Professional AWS cloud service solution provider dedicated to helping enterprises achieve digital transformation", "products": "AWS Products", "solutions": "Solutions", "contactUs": "Contact Us", "address": "10th Floor, Building, Chaoyang District, Beijing", "phone": "400-123-4567", "email": "contact@example.com", "allRightsReserved": "All Rights Reserved", "productLinks": { "ec2": "EC2 Cloud Server", "s3": "S3 Object Storage", "rds": "RDS Database Service", "lambda": "Lambda Serverless", "more": "More Products..." }, "solutionLinks": { "web": "Website Hosting", "enterprise": "Enterprise Cloud Migration", "disaster": "Disaster Recovery", "bigdata": "Big Data Analytics", "microservice": "Microservices Architecture" } };
const about = { "hero": { "title": "About Us", "subtitle": "Professional AWS cloud service solution provider helping enterprises with digital transformation" }, "company": { "title": "Company Profile", "description1": "Cloud Service Expert was established in 2018 as an authorized AWS cloud service solution provider. We are dedicated to providing professional cloud computing consulting, migration, operation, and optimization services.", "description2": "As an AWS Advanced Partner, we have rich cloud service implementation experience and a professional technical team, having successfully helped hundreds of enterprises complete cloud transformation." }, "achievements": { "item1": "AWS Advanced Partner Certification", "item2": "100+ Successful Cases", "item3": "50+ AWS Certified Engineers" }, "advantages": { "title": "Our Advantages", "subtitle": "Professional technical team with rich project experience", "certification": { "title": "Professional Certification", "description": "AWS officially certified advanced partner with multiple professional certifications" }, "team": { "title": "Expert Team", "description": "50+ AWS certified engineers with an average of 5+ years of cloud service experience" }, "technical": { "title": "Technical Strength", "description": "Mastery of the full range of AWS products with extensive implementation and operation experience" }, "service": { "title": "Service Guarantee", "description": "24/7 technical support ensuring stable operation of customer businesses" } }, "culture": { "title": "Corporate Culture", "subtitle": "Customer-centric, pursuing excellence in service", "mission": { "title": "Corporate Mission", "description": "Enable enterprise digital transformation by providing professional and reliable cloud computing services" }, "vision": { "title": "Corporate Vision", "description": "To become China's most trusted cloud service solution provider" }, "values": { "title": "Core Values", "description": "Professionalism, Innovation, Integrity, Win-Win" } }, "history": { "title": "Development History", "subtitle": "Witness our growth and progress", "year2023": { "year": "2023", "description": "Became an AWS Advanced Partner with over 500 customers served" }, "year2021": { "year": "2021", "description": "Obtained AWS Standard Partner certification with team expansion to 50 people" }, "year2018": { "year": "2018", "description": "Company founded, began providing AWS cloud service solutions" } }, "contact": { "title": "Want to learn more about us?", "subtitle": "Welcome to contact us for more company information and service details", "button": "Contact Us" } };
const products = { "hero": { "title": "AWS Products", "subtitle": "Comprehensive cloud computing product line to meet your various business needs" }, "categories": { "title": "Full Range of AWS Products", "subtitle": "Covering computing, storage, database, networking, security, and more", "compute": { "name": "Computing Services", "description": "Including EC2, Lambda, etc., providing flexible computing capabilities" }, "storage": { "name": "Storage Services", "description": "Including S3, EBS, etc., providing reliable data storage solutions" }, "network": { "name": "Network Services", "description": "Including VPC, Route 53, etc., providing secure and flexible network management" }, "security": { "name": "Security & Identity", "description": "Including IAM, GuardDuty, etc., providing comprehensive security protection" }, "monitoring": { "name": "Monitoring & Management", "description": "Including CloudWatch, Systems Manager, etc., providing comprehensive monitoring and management tools" }, "ai": { "name": "Artificial Intelligence", "description": "Including SageMaker, Rekognition, etc., providing advanced AI services" }, "viewProducts": "View Products" }, "productList": { "title": "Popular Product Services", "subtitle": "AWS core products detailed introduction", "advantages": "Product Advantages", "pricing": "Pricing", "inquiry": "Inquire Details", "ec2": { "name": "Amazon EC2", "description": "Amazon Elastic Compute Cloud (EC2) is a web service that provides scalable computing capacity, designed for cloud computing. Using EC2 eliminates upfront hardware investment, allowing you to develop and deploy applications faster.", "features": ["Flexible instance type selection, adapting to different application scenarios", "Per-second billing, reducing operational costs", "Auto scaling to handle business peaks", "High availability and reliability guarantee"], "pricing": "Pay-as-you-go, starting from ¥0.1/hour" }, "s3": { "name": "Amazon S3", "description": "Amazon Simple Storage Service (S3) is an object storage service offering industry-leading scalability, data availability, security, and performance. This means businesses of any size can store and protect any amount of data.", "features": ["Unlimited capacity expansion, suitable for data storage of any scale", "99.999999999% data durability", "Multiple storage classes to optimize costs", "Powerful access control and encryption features"], "pricing": "Pay by storage and request volume, starting from ¥0.2/GB/month" }, "rds": { "name": "Amazon RDS", "description": "Amazon Relational Database Service (RDS) makes it simple to set up, operate, and scale a relational database in the cloud. It provides cost-efficient and resizable capacity while automating time-consuming administration tasks.", "features": ["Supports multiple database engines: MySQL, PostgreSQL, Oracle, etc.", "Automatic backup and recovery functionality", "High availability with primary-standby deployment", "Automatic software updates and maintenance"], "pricing": "Billed by instance type, starting from ¥0.5/hour" } }, "advantages": { "title": "Our Advantages", "subtitle": "As an authorized AWS partner, we provide professional AWS product consulting and deployment services", "deployment": { "title": "Rapid Deployment", "description": "Professional team helps you quickly deploy AWS products, shortening time to market" }, "cost": { "title": "Cost Optimization", "description": "Customize optimal cost solutions based on business needs, avoiding resource waste" }, "security": { "title": "Security Assurance", "description": "Provide comprehensive security assessments and best practices to ensure business security" }, "support": { "title": "Expert Support", "description": "24/7 technical support, solving various issues during your usage" } }, "contact": { "title": "Want to learn more about our products?", "subtitle": "Our AWS product experts will provide detailed product introductions and pricing consultations", "button": "Contact Product Advisor" } };
const solutions = { "hero": { "title": "Solutions", "subtitle": "Professional AWS cloud service solutions for different industries and business scenarios" }, "categories": { "title": "AWS Cloud Solutions", "subtitle": "Based on AWS cloud services, providing professional solutions for different industries", "viewDetails": "View Details" }, "solutionItems": { "webHosting": { "title": "Website Hosting", "description": "High-performance, highly available website hosting solutions for various websites and web applications", "icon": "fas fa-globe" }, "cloudMigration": { "title": "Enterprise Cloud Migration", "description": "Secure, smooth enterprise IT system cloud migration solutions, minimizing business disruption risks", "icon": "fas fa-cloud-upload-alt" }, "disasterRecovery": { "title": "Disaster Recovery", "description": "Building reliable disaster recovery systems to ensure business continuity and data security", "icon": "fas fa-shield-alt" }, "bigData": { "title": "Big Data Analytics", "description": "Data processing and analytics solutions based on AWS big data services", "icon": "fas fa-chart-pie" }, "microservices": { "title": "Microservices Architecture", "description": "Modern application architecture solutions based on containers and serverless technologies", "icon": "fas fa-cubes" }, "aiMl": { "title": "AI/Machine Learning", "description": "Solutions for quickly building intelligent applications using AWS AI/ML services", "icon": "fas fa-brain" } }, "solutionDetails": { "advantages": "Solution Advantages", "industries": "Applicable Industries", "inquiry": "Inquire Solution", "webHosting": { "title": "Website Hosting Solution", "description": "AWS cloud-based high-performance, highly available, secure website hosting solution suitable for corporate websites, e-commerce sites, content management systems, and various web applications. Utilizing AWS global infrastructure and CDN services to provide low-latency access experience for global users.", "benefits": ["High availability architecture with 99.99% service availability guarantee", "Auto scaling capability to handle traffic peaks", "CDN acceleration for low-latency access by global users", "Comprehensive security protection including WAF, DDoS protection, etc.", "Pay-as-you-go to reduce operational costs"], "industries": ["E-commerce", "Media", "Education", "Enterprise Services"] }, "cloudMigration": { "title": "Enterprise Cloud Migration Solution", "description": "Providing secure, reliable cloud migration paths for traditional IT infrastructure, helping enterprises achieve smooth transition from on-premises data centers to AWS cloud. Our solution covers the entire process of assessment, planning, migration, and optimization, minimizing business disruption and migration risks.", "benefits": ["Professional migration assessment and planning services", "Multiple migration strategies: rehosting, replatforming, refactoring, etc.", "Secure data migration ensuring zero data loss", "Business continuity assurance during migration", "Post-migration performance optimization and cost control"], "industries": ["Finance", "Manufacturing", "Retail", "Healthcare", "Government"] }, "disasterRecovery": { "title": "Disaster Recovery Solution", "description": "Building reliable disaster recovery systems based on AWS cloud services to help enterprises address business continuity challenges under various disaster scenarios. We provide one-stop services from disaster recovery planning to implementation, testing, and operation, ensuring enterprise data security and business continuity.", "benefits": ["Multi-region architecture providing geographic-level disaster recovery capability", "Flexible Recovery Point Objective (RPO) and Recovery Time Objective (RTO) options", "Automated disaster recovery processes reducing human errors", "Regular disaster recovery drill and testing services", "Cost-optimized disaster recovery architecture design"], "industries": ["Finance", "Healthcare", "Energy", "Telecommunications", "Government"] }, "bigData": { "title": "Big Data Analytics Solution", "description": "Utilizing AWS's rich big data services to build efficient, scalable data processing and analytics platforms. Our solution can help enterprises extract value from massive data, supporting various big data application scenarios such as data warehousing, real-time analytics, and machine learning.", "benefits": ["High-performance data processing capability handling PB-level data", "Flexible storage options optimizing cost and performance", "Real-time data processing and analytics capability", "Seamless integration with machine learning services", "Visualization data analytics tools"], "industries": ["Finance", "Retail", "Healthcare", "Manufacturing", "Logistics"] } }, "implementation": { "title": "Solution Implementation Process", "subtitle": "Professional, efficient project implementation process ensuring smooth solution deployment", "steps": { "step1": { "title": "Requirements Analysis", "description": "Deep understanding of customer business needs and technical environment, determining solution goals and scope" }, "step2": { "title": "Solution Design", "description": "Designing customized AWS cloud solution architecture based on requirements analysis results" }, "step3": { "title": "Implementation", "description": "Professional team implements the solution according to plan, ensuring system stability and reliability" }, "step4": { "title": "Testing & Acceptance", "description": "Comprehensive testing of system functionality and performance, ensuring business requirements are met" }, "step5": { "title": "Launch & Operations", "description": "System goes live with continuous operation and optimization services" } } }, "cases": { "title": "Customer Success Cases", "subtitle": "Our solutions have been successfully applied in numerous industries", "viewDetails": "View Details" }, "contact": { "title": "Need a customized solution?", "subtitle": "Contact our solution experts for professional AWS cloud service solution recommendations", "button": "Contact Solution Expert" } };
const cases = { "hero": { "title": "Case Studies", "subtitle": "See how other businesses leverage AWS cloud services to enhance business value" }, "filter": { "byIndustry": "Filter by industry:", "all": "All", "sortBy": "Sort by:", "latest": "Latest Cases", "default": "Default Order" }, "industries": { "finance": "Finance", "ecommerce": "E-commerce", "manufacturing": "Manufacturing", "healthcare": "Healthcare", "education": "Education", "government": "Government", "media": "Media", "logistics": "Logistics" }, "caseStudies": { "ecommerce": { "industry": "E-commerce", "title": "E-commerce Platform Cloud Transformation", "summary": "A leading e-commerce platform achieved 60% improvement in website performance and 40% cost reduction through AWS cloud architecture", "background": "A large e-commerce platform with over 10 million monthly active users was facing performance bottlenecks and scalability challenges with their traditional infrastructure, especially during promotional periods.", "challenges": ["Traditional infrastructure couldn't handle traffic spikes during promotional campaigns", "High maintenance costs with low resource utilization", "Long deployment cycles affecting business agility", "Increasing security concerns and compliance requirements"], "solution": "We designed and implemented a comprehensive AWS cloud architecture utilizing EC2 Auto Scaling, Amazon RDS, ElastiCache, CloudFront CDN, and S3 for static content. The solution included containerization of their applications with ECS and implementation of CI/CD pipelines for rapid deployment.", "results": ["60% improvement in overall website performance", "Seamless handling of 10x traffic spikes during promotions", "40% reduction in infrastructure costs", "Deployment time reduced from days to minutes", "Enhanced security with AWS Shield and WAF implementation"] }, "finance": { "industry": "Finance", "title": "Financial Service Provider's Secure Cloud Migration", "summary": "A financial service company successfully migrated core systems to AWS cloud with enhanced security and 99.99% availability", "background": "A mid-sized financial service provider needed to modernize their infrastructure while meeting strict regulatory requirements and ensuring the highest level of security and availability for their services.", "challenges": ["Stringent regulatory compliance requirements (PCI DSS, SOX)", "Zero downtime requirement during migration", "Highly sensitive financial data security concerns", "Legacy systems integration complexity"], "solution": "We implemented a secure, compliant AWS architecture utilizing dedicated VPC with private subnets, encryption at rest and in transit, comprehensive IAM policies, and multi-layer security controls. The migration followed a phased approach with extensive testing to ensure business continuity.", "results": ["Successful migration with zero downtime", "Achieved 99.99% service availability", "Full compliance with financial industry regulations", "35% reduction in operational costs", "Enhanced disaster recovery capabilities with 15-minute RTO"] }, "healthcare": { "industry": "Healthcare", "title": "Healthcare Provider's Data Platform Modernization", "summary": "A healthcare organization built a HIPAA-compliant data analytics platform on AWS, improving patient care and operational efficiency", "background": "A healthcare provider with multiple facilities needed to consolidate and analyze patient and operational data across their organization while ensuring compliance with healthcare regulations.", "challenges": ["Data silos across different departments and facilities", "Strict HIPAA compliance requirements", "Need for real-time analytics for clinical decision support", "Legacy systems with limited integration capabilities"], "solution": "We designed a HIPAA-compliant data lake and analytics platform on AWS using S3, Glue, Lambda, and QuickSight. The solution included secure ETL processes, data encryption, comprehensive access controls, and audit trails to ensure compliance and data security.", "results": ["Consolidated view of patient data across all facilities", "50% reduction in report generation time", "Improved clinical decision-making with real-time analytics", "Full HIPAA compliance with comprehensive audit trails", "30% reduction in administrative costs through process optimization"] }, "manufacturing": { "industry": "Manufacturing", "title": "Manufacturing Company's IoT Implementation", "summary": "A manufacturing company implemented AWS IoT solution, achieving 25% productivity improvement and predictive maintenance capabilities", "background": "A manufacturing company with multiple production facilities wanted to leverage IoT technology to monitor equipment performance, predict maintenance needs, and optimize production processes.", "challenges": ["Limited visibility into equipment performance across facilities", "Reactive maintenance leading to unplanned downtime", "Inefficient resource allocation and production scheduling", "Legacy equipment with limited connectivity options"], "solution": "We implemented a comprehensive IoT solution on AWS using IoT Core, Greengrass, SiteWise, and Kinesis for data ingestion and processing. The solution included custom gateways for legacy equipment, real-time dashboards, and machine learning models for predictive maintenance.", "results": ["25% improvement in overall equipment effectiveness", "45% reduction in unplanned downtime through predictive maintenance", "15% increase in production throughput", "Real-time visibility into operations across all facilities", "Data-driven decision making for resource allocation and scheduling"] }, "logistics": { "industry": "Logistics", "title": "Logistics Company's Supply Chain Optimization", "summary": "A logistics company streamlined operations and reduced costs by 30% with AWS-based supply chain management platform", "background": "A logistics and supply chain company needed to optimize their delivery network, improve tracking capabilities, and enhance overall efficiency in their operations spanning multiple countries.", "challenges": ["Limited visibility across the global supply chain network", "Inefficient route planning and resource allocation", "Manual processes causing delays and errors", "Lack of real-time tracking and status updates for customers"], "solution": "We developed a comprehensive supply chain management platform on AWS using microservices architecture with ECS, API Gateway, DynamoDB, and AWS IoT for tracking. The solution included machine learning models for demand forecasting and route optimization.", "results": ["30% reduction in operational costs", "22% improvement in on-time delivery performance", "Real-time tracking and visibility across the entire supply chain", "40% reduction in manual processes through automation", "Enhanced customer satisfaction with self-service tracking portal"] }, "education": { "industry": "Education", "title": "Educational Institution's Digital Learning Platform", "summary": "An educational institution built a scalable digital learning platform on AWS, serving 50,000+ students with 99.9% availability", "background": "A large educational institution needed to develop a comprehensive digital learning platform to support remote education, content delivery, and student collaboration across multiple campuses.", "challenges": ["Need to support 50,000+ simultaneous users during peak periods", "Secure access to educational resources and personal information", "Integration with existing student management systems", "Cost-effective storage and delivery of large educational content"], "solution": "We designed a scalable digital learning platform on AWS using a combination of EC2, ECS, S3, CloudFront, and RDS. The solution included single sign-on integration, content management system, video streaming capabilities, and collaborative tools for interactive learning.", "results": ["Successfully supports 50,000+ concurrent users with 99.9% availability", "70% reduction in content delivery time through CloudFront", "Secure access to resources with comprehensive authentication", "Seamless integration with existing student information systems", "40% cost reduction compared to traditional infrastructure"] } }, "noResults": { "text": "No matching cases found", "clearFilters": "Clear filters" }, "caseDetail": { "readDetails": "Read Details", "background": "Customer Background", "challenges": "Challenges", "solution": "Solution", "results": "Business Results", "close": "Close" }, "contact": { "title": "Want to learn more about customer cases?", "subtitle": "Contact us for more industry-related AWS cloud service success stories", "button": "Contact Us" } };
const contact = { "hero": { "title": "Contact Us", "subtitle": "Welcome to inquire at any time, we will provide you with professional cloud service solutions" }, "methods": { "phone": { "title": "Phone Consultation", "subtitle": "Monday to Sunday 9:00-21:00", "content": "400-123-4567" }, "email": { "title": "Email Consultation", "subtitle": "24/7 Email Support", "content": "contact@example.com" }, "wechat": { "title": "WeChat Consultation", "subtitle": "Scan the QR code below" } }, "form": { "title": "Online Inquiry", "name": "Name", "company": "Company Name", "email": "Email", "phone": "Phone", "service": "Service Inquiry", "message": "Message", "required": "Required", "placeholders": { "selectService": "Please select a service" }, "serviceOptions": { "cloud": "Cloud Service Consultation", "migration": "Cloud Migration", "solution": "Solution Consultation", "price": "Pricing Inquiry", "other": "Other" }, "submit": "Submit Inquiry", "submitting": "Submitting..." }, "companyInfo": { "title": "Company Address", "beijing": { "title": "Beijing Headquarters", "content": "10th Floor, Building, Chaoyang District, Beijing" }, "transport": { "title": "Transportation", "content": "5-minute walk from Exit A of Subway Line 6 Station" }, "hours": { "title": "Office Hours", "content": "Monday to Friday: 9:00-18:00" } }, "faq": { "title": "Frequently Asked Questions", "subtitle": "Answering your most concerned questions", "items": { "q1": { "question": "How to start using AWS cloud services?", "answer": "You can get professional AWS cloud service solution recommendations through our consultation services. Our team will provide the most suitable cloud service solution based on your specific needs." }, "q2": { "question": "How to get technical support?", "answer": "We provide 24/7 technical support services. You can contact our technical support team via phone, email, or online consultation." }, "q3": { "question": "How to calculate usage costs?", "answer": "We provide detailed cost assessment services and can provide accurate cost estimates and optimization suggestions based on your specific usage scenarios and requirements." }, "q4": { "question": "How to apply for trial services?", "answer": "You can apply for AWS cloud service trials through online consultation or by directly contacting our sales team. We will provide professional trial solutions and technical support." } } } };
const en = {
  nav,
  common,
  home,
  footer,
  about,
  products,
  solutions,
  cases,
  contact
};

const i18n_M6WuPocwmDZfR2LKAqoIP7SPPiCebMfT5sB7ls3Be_c = defineNuxtPlugin(({ vueApp }) => {
  const i18n = createI18n({
    legacy: false,
    globalInjection: true,
    locale: "zh",
    messages: {
      zh,
      en
    }
  });
  vueApp.use(i18n);
});

function toArray(value) {
  return Array.isArray(value) ? value : [value];
}

function useRequestEvent(nuxtApp) {
  var _a;
  nuxtApp || (nuxtApp = useNuxtApp());
  return (_a = nuxtApp.ssrContext) == null ? void 0 : _a.event;
}
function prerenderRoutes(path) {
  const paths = toArray(path);
  appendHeader(useRequestEvent(), "x-nitro-prerender", paths.map((p) => encodeURIComponent(p)).join(", "));
}

let routes;
const prerender_server_sqIxOBipVr4FbVMA9kqWL0wT8FPop6sKAXLVfifsJzk = defineNuxtPlugin(async () => {
  let __temp, __restore;
  if (routes && !routes.length) {
    return;
  }
  useRuntimeConfig().nitro.routeRules;
  routes || (routes = Array.from(processRoutes(([__temp, __restore] = executeAsync(() => {
    var _a, _b;
    return (_b = (_a = routerOptions).routes) == null ? void 0 : _b.call(_a, _routes);
  }), __temp = await __temp, __restore(), __temp) ?? _routes)));
  const batch = routes.splice(0, 10);
  prerenderRoutes(batch);
});
const OPTIONAL_PARAM_RE = /^\/?:.*(?:\?|\(\.\*\)\*)$/;
function shouldPrerender(path) {
  return true;
}
function processRoutes(routes2, currentPath = "/", routesToPrerender = /* @__PURE__ */ new Set()) {
  var _a;
  for (const route of routes2) {
    if (OPTIONAL_PARAM_RE.test(route.path) && !((_a = route.children) == null ? void 0 : _a.length) && shouldPrerender()) {
      routesToPrerender.add(currentPath);
    }
    if (route.path.includes(":")) {
      continue;
    }
    const fullPath = joinURL(currentPath, route.path);
    {
      routesToPrerender.add(fullPath);
    }
    if (route.children) {
      processRoutes(route.children, fullPath, routesToPrerender);
    }
  }
  return routesToPrerender;
}

const plugins = [
  unhead_k2P3m_ZDyjlr2mMYnoDPwavjsDN8hBlk9cFai0bbopU,
  plugin,
  revive_payload_server_MVtmlZaQpj6ApFmshWfUWl5PehCebzaBf2NuRMiIbms,
  components_plugin_z4hgvsiddfKkfXTP6M8M4zG5Cb7sGnDhcryKVM45Di4,
  i18n_M6WuPocwmDZfR2LKAqoIP7SPPiCebMfT5sB7ls3Be_c,
  prerender_server_sqIxOBipVr4FbVMA9kqWL0wT8FPop6sKAXLVfifsJzk
];

const layouts = {
  default: defineAsyncComponent(() => import('./default.vue.mjs').then((m) => m.default || m))
};

const LayoutLoader = defineComponent({
  name: "LayoutLoader",
  inheritAttrs: false,
  props: {
    name: String,
    layoutProps: Object
  },
  setup(props, context) {
    return () => h(layouts[props.name], props.layoutProps, context.slots);
  }
});
const nuxtLayoutProps = {
  name: {
    type: [String, Boolean, Object],
    default: null
  },
  fallback: {
    type: [String, Object],
    default: null
  }
};
const __nuxt_component_0 = defineComponent({
  name: "NuxtLayout",
  inheritAttrs: false,
  props: nuxtLayoutProps,
  setup(props, context) {
    const nuxtApp = useNuxtApp();
    const injectedRoute = inject(PageRouteSymbol);
    const route = injectedRoute === useRoute() ? useRoute$1() : injectedRoute;
    const layout = computed(() => {
      let layout2 = unref(props.name) ?? route.meta.layout ?? "default";
      if (layout2 && !(layout2 in layouts)) {
        if (props.fallback) {
          layout2 = unref(props.fallback);
        }
      }
      return layout2;
    });
    const layoutRef = ref();
    context.expose({ layoutRef });
    const done = nuxtApp.deferHydration();
    return () => {
      const hasLayout = layout.value && layout.value in layouts;
      const transitionProps = route.meta.layoutTransition ?? appLayoutTransition;
      return _wrapInTransition(hasLayout && transitionProps, {
        default: () => h(Suspense, { suspensible: true, onResolve: () => {
          nextTick(done);
        } }, {
          default: () => h(
            LayoutProvider,
            {
              layoutProps: mergeProps(context.attrs, { ref: layoutRef }),
              key: layout.value || void 0,
              name: layout.value,
              shouldProvide: !props.name,
              hasTransition: !!transitionProps
            },
            context.slots
          )
        })
      }).default();
    };
  }
});
const LayoutProvider = defineComponent({
  name: "NuxtLayoutProvider",
  inheritAttrs: false,
  props: {
    name: {
      type: [String, Boolean]
    },
    layoutProps: {
      type: Object
    },
    hasTransition: {
      type: Boolean
    },
    shouldProvide: {
      type: Boolean
    }
  },
  setup(props, context) {
    const name = props.name;
    if (props.shouldProvide) {
      provide(LayoutMetaSymbol, {
        isCurrent: (route) => name === (route.meta.layout ?? "default")
      });
    }
    return () => {
      var _a, _b;
      if (!name || typeof name === "string" && !(name in layouts)) {
        return (_b = (_a = context.slots).default) == null ? void 0 : _b.call(_a);
      }
      return h(
        LayoutLoader,
        { key: name, layoutProps: props.layoutProps, name },
        context.slots
      );
    };
  }
});

const defineRouteProvider = (name = "RouteProvider") => defineComponent({
  name,
  props: {
    vnode: {
      type: Object,
      required: true
    },
    route: {
      type: Object,
      required: true
    },
    vnodeRef: Object,
    renderKey: String,
    trackRootNodes: Boolean
  },
  setup(props) {
    const previousKey = props.renderKey;
    const previousRoute = props.route;
    const route = {};
    for (const key in props.route) {
      Object.defineProperty(route, key, {
        get: () => previousKey === props.renderKey ? props.route[key] : previousRoute[key],
        enumerable: true
      });
    }
    provide(PageRouteSymbol, shallowReactive(route));
    return () => {
      return h(props.vnode, { ref: props.vnodeRef });
    };
  }
});
const RouteProvider = defineRouteProvider();

const __nuxt_component_1 = defineComponent({
  name: "NuxtPage",
  inheritAttrs: false,
  props: {
    name: {
      type: String
    },
    transition: {
      type: [Boolean, Object],
      default: void 0
    },
    keepalive: {
      type: [Boolean, Object],
      default: void 0
    },
    route: {
      type: Object
    },
    pageKey: {
      type: [Function, String],
      default: null
    }
  },
  setup(props, { attrs, slots, expose }) {
    const nuxtApp = useNuxtApp();
    const pageRef = ref();
    inject(PageRouteSymbol, null);
    expose({ pageRef });
    inject(LayoutMetaSymbol, null);
    nuxtApp.deferHydration();
    return () => {
      return h(RouterView, { name: props.name, route: props.route, ...attrs }, {
        default: (routeProps) => {
          return h(Suspense, { suspensible: true }, {
            default() {
              return h(RouteProvider, {
                vnode: slots.default ? normalizeSlot(slots.default, routeProps) : routeProps.Component,
                route: routeProps.route,
                vnodeRef: pageRef
              });
            }
          });
        }
      });
    };
  }
});
function normalizeSlot(slot, data) {
  const slotContent = slot(data);
  return slotContent.length === 1 ? h(slotContent[0]) : h(Fragment, void 0, slotContent);
}

const _export_sfc = (sfc, props) => {
  const target = sfc.__vccOpts || sfc;
  for (const [key, val] of props) {
    target[key] = val;
  }
  return target;
};

const _sfc_main$2 = {};
function _sfc_ssrRender(_ctx, _push, _parent, _attrs) {
  const _component_NuxtLayout = __nuxt_component_0;
  const _component_NuxtPage = __nuxt_component_1;
  _push(ssrRenderComponent(_component_NuxtLayout, _attrs, {
    default: withCtx((_, _push2, _parent2, _scopeId) => {
      if (_push2) {
        _push2(ssrRenderComponent(_component_NuxtPage, null, null, _parent2, _scopeId));
      } else {
        return [
          createVNode(_component_NuxtPage)
        ];
      }
    }),
    _: 1
  }, _parent));
}
const _sfc_setup$2 = _sfc_main$2.setup;
_sfc_main$2.setup = (props, ctx) => {
  const ssrContext = useSSRContext();
  (ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add("app.vue");
  return _sfc_setup$2 ? _sfc_setup$2(props, ctx) : void 0;
};
const AppComponent = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["ssrRender", _sfc_ssrRender]]);

const _sfc_main$1 = {
  __name: "nuxt-error-page",
  __ssrInlineRender: true,
  props: {
    error: Object
  },
  setup(__props) {
    const props = __props;
    const _error = props.error;
    _error.stack ? _error.stack.split("\n").splice(1).map((line) => {
      const text = line.replace("webpack:/", "").replace(".vue", ".js").trim();
      return {
        text,
        internal: line.includes("node_modules") && !line.includes(".cache") || line.includes("internal") || line.includes("new Promise")
      };
    }).map((i) => `<span class="stack${i.internal ? " internal" : ""}">${i.text}</span>`).join("\n") : "";
    const statusCode = Number(_error.statusCode || 500);
    const is404 = statusCode === 404;
    const statusMessage = _error.statusMessage ?? (is404 ? "Page Not Found" : "Internal Server Error");
    const description = _error.message || _error.toString();
    const stack = void 0;
    const _Error404 = defineAsyncComponent(() => import('./error-404.vue.mjs'));
    const _Error = defineAsyncComponent(() => import('./error-500.vue.mjs'));
    const ErrorTemplate = is404 ? _Error404 : _Error;
    return (_ctx, _push, _parent, _attrs) => {
      _push(ssrRenderComponent(unref(ErrorTemplate), mergeProps({ statusCode: unref(statusCode), statusMessage: unref(statusMessage), description: unref(description), stack: unref(stack) }, _attrs), null, _parent));
    };
  }
};
const _sfc_setup$1 = _sfc_main$1.setup;
_sfc_main$1.setup = (props, ctx) => {
  const ssrContext = useSSRContext();
  (ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add("node_modules/nuxt/dist/app/components/nuxt-error-page.vue");
  return _sfc_setup$1 ? _sfc_setup$1(props, ctx) : void 0;
};

const _sfc_main = {
  __name: "nuxt-root",
  __ssrInlineRender: true,
  setup(__props) {
    const IslandRenderer = () => null;
    const nuxtApp = useNuxtApp();
    nuxtApp.deferHydration();
    nuxtApp.ssrContext.url;
    const SingleRenderer = false;
    provide(PageRouteSymbol, useRoute());
    nuxtApp.hooks.callHookWith((hooks) => hooks.map((hook) => hook()), "vue:setup");
    const error = useError();
    const abortRender = error.value && !nuxtApp.ssrContext.error;
    onErrorCaptured((err, target, info) => {
      nuxtApp.hooks.callHook("vue:error", err, target, info).catch((hookError) => console.error("[nuxt] Error in `vue:error` hook", hookError));
      {
        const p = nuxtApp.runWithContext(() => showError(err));
        onServerPrefetch(() => p);
        return false;
      }
    });
    const islandContext = nuxtApp.ssrContext.islandContext;
    return (_ctx, _push, _parent, _attrs) => {
      ssrRenderSuspense(_push, {
        default: () => {
          if (unref(abortRender)) {
            _push(`<div></div>`);
          } else if (unref(error)) {
            _push(ssrRenderComponent(unref(_sfc_main$1), { error: unref(error) }, null, _parent));
          } else if (unref(islandContext)) {
            _push(ssrRenderComponent(unref(IslandRenderer), { context: unref(islandContext) }, null, _parent));
          } else if (unref(SingleRenderer)) {
            ssrRenderVNode(_push, createVNode(resolveDynamicComponent(unref(SingleRenderer)), null, null), _parent);
          } else {
            _push(ssrRenderComponent(unref(AppComponent), null, null, _parent));
          }
        },
        _: 1
      });
    };
  }
};
const _sfc_setup = _sfc_main.setup;
_sfc_main.setup = (props, ctx) => {
  const ssrContext = useSSRContext();
  (ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add("node_modules/nuxt/dist/app/components/nuxt-root.vue");
  return _sfc_setup ? _sfc_setup(props, ctx) : void 0;
};

let entry;
{
  entry = async function createNuxtAppServer(ssrContext) {
    var _a;
    const vueApp = createApp(_sfc_main);
    const nuxt = createNuxtApp({ vueApp, ssrContext });
    try {
      await applyPlugins(nuxt, plugins);
      await nuxt.hooks.callHook("app:created", vueApp);
    } catch (error) {
      await nuxt.hooks.callHook("app:error", error);
      (_a = nuxt.payload).error || (_a.error = createError(error));
    }
    if (ssrContext == null ? void 0 : ssrContext._renderResponse) {
      throw new Error("skipping render");
    }
    return vueApp;
  };
}
const entry$1 = (ssrContext) => entry(ssrContext);

const server = /*#__PURE__*/Object.freeze({
  __proto__: null,
  default: entry$1
});

export { _export_sfc as _, useNuxtApp as a, useRuntimeConfig as b, nuxtLinkDefaults as c, navigateTo as n, resolveRouteObject as r, server as s, tryUseNuxtApp as t, useRouter as u };
//# sourceMappingURL=server.mjs.map