@openpkg-ts/react 0.2.0

package/dist/styled.js

@@ -0,0 +1,4719 @@
+"use client";
+import {
+  CollapsibleMethod,
+  ExampleBlock,
+  ExpandableProperty,
+  MemberRow,
+  MembersTable,
+  NestedProperty,
+  ParamRow,
+  ParamTable,
+  Signature,
+  TypeTable,
+  __commonJS,
+  __toESM,
+  cleanCode,
+  getExampleCode,
+  getExampleLanguage,
+  getExampleTitle,
+  groupMembersByKind
+} from "./shared/chunk-0h2j0jvb.js";
+
+// ../../node_modules/@swc/helpers/cjs/_interop_require_wildcard.cjs
+var require__interop_require_wildcard = __commonJS((exports) => {
+  function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function")
+      return null;
+    var cacheBabelInterop = new WeakMap;
+    var cacheNodeInterop = new WeakMap;
+    return (_getRequireWildcardCache = function(nodeInterop2) {
+      return nodeInterop2 ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+  }
+  function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule)
+      return obj;
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function")
+      return { default: obj };
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj))
+      return cache.get(obj);
+    var newObj = { __proto__: null };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for (var key in obj) {
+      if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+        var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+        if (desc && (desc.get || desc.set))
+          Object.defineProperty(newObj, key, desc);
+        else
+          newObj[key] = obj[key];
+      }
+    }
+    newObj.default = obj;
+    if (cache)
+      cache.set(obj, newObj);
+    return newObj;
+  }
+  exports._ = _interop_require_wildcard;
+});
+
+// ../../node_modules/next/dist/shared/lib/router/utils/querystring.js
+var require_querystring = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  function _export(target, all) {
+    for (var name in all)
+      Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+  }
+  _export(exports, {
+    assign: function() {
+      return assign;
+    },
+    searchParamsToUrlQuery: function() {
+      return searchParamsToUrlQuery;
+    },
+    urlQueryToSearchParams: function() {
+      return urlQueryToSearchParams;
+    }
+  });
+  function searchParamsToUrlQuery(searchParams) {
+    const query = {};
+    for (const [key, value] of searchParams.entries()) {
+      const existing = query[key];
+      if (typeof existing === "undefined") {
+        query[key] = value;
+      } else if (Array.isArray(existing)) {
+        existing.push(value);
+      } else {
+        query[key] = [
+          existing,
+          value
+        ];
+      }
+    }
+    return query;
+  }
+  function stringifyUrlQueryParam(param) {
+    if (typeof param === "string") {
+      return param;
+    }
+    if (typeof param === "number" && !isNaN(param) || typeof param === "boolean") {
+      return String(param);
+    } else {
+      return "";
+    }
+  }
+  function urlQueryToSearchParams(query) {
+    const searchParams = new URLSearchParams;
+    for (const [key, value] of Object.entries(query)) {
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          searchParams.append(key, stringifyUrlQueryParam(item));
+        }
+      } else {
+        searchParams.set(key, stringifyUrlQueryParam(value));
+      }
+    }
+    return searchParams;
+  }
+  function assign(target) {
+    for (var _len = arguments.length, searchParamsList = new Array(_len > 1 ? _len - 1 : 0), _key = 1;_key < _len; _key++) {
+      searchParamsList[_key - 1] = arguments[_key];
+    }
+    for (const searchParams of searchParamsList) {
+      for (const key of searchParams.keys()) {
+        target.delete(key);
+      }
+      for (const [key, value] of searchParams.entries()) {
+        target.append(key, value);
+      }
+    }
+    return target;
+  }
+});
+
+// ../../node_modules/next/dist/shared/lib/router/utils/format-url.js
+var require_format_url = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  function _export(target, all) {
+    for (var name in all)
+      Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+  }
+  _export(exports, {
+    formatUrl: function() {
+      return formatUrl;
+    },
+    formatWithValidation: function() {
+      return formatWithValidation;
+    },
+    urlObjectKeys: function() {
+      return urlObjectKeys;
+    }
+  });
+  var _interop_require_wildcard = require__interop_require_wildcard();
+  var _querystring = /* @__PURE__ */ _interop_require_wildcard._(require_querystring());
+  var slashedProtocols = /https?|ftp|gopher|file/;
+  function formatUrl(urlObj) {
+    let { auth, hostname } = urlObj;
+    let protocol = urlObj.protocol || "";
+    let pathname = urlObj.pathname || "";
+    let hash = urlObj.hash || "";
+    let query = urlObj.query || "";
+    let host = false;
+    auth = auth ? encodeURIComponent(auth).replace(/%3A/i, ":") + "@" : "";
+    if (urlObj.host) {
+      host = auth + urlObj.host;
+    } else if (hostname) {
+      host = auth + (~hostname.indexOf(":") ? "[" + hostname + "]" : hostname);
+      if (urlObj.port) {
+        host += ":" + urlObj.port;
+      }
+    }
+    if (query && typeof query === "object") {
+      query = String(_querystring.urlQueryToSearchParams(query));
+    }
+    let search = urlObj.search || query && "?" + query || "";
+    if (protocol && !protocol.endsWith(":"))
+      protocol += ":";
+    if (urlObj.slashes || (!protocol || slashedProtocols.test(protocol)) && host !== false) {
+      host = "//" + (host || "");
+      if (pathname && pathname[0] !== "/")
+        pathname = "/" + pathname;
+    } else if (!host) {
+      host = "";
+    }
+    if (hash && hash[0] !== "#")
+      hash = "#" + hash;
+    if (search && search[0] !== "?")
+      search = "?" + search;
+    pathname = pathname.replace(/[?#]/g, encodeURIComponent);
+    search = search.replace("#", "%23");
+    return "" + protocol + host + pathname + search + hash;
+  }
+  var urlObjectKeys = [
+    "auth",
+    "hash",
+    "host",
+    "hostname",
+    "href",
+    "path",
+    "pathname",
+    "port",
+    "protocol",
+    "query",
+    "search",
+    "slashes"
+  ];
+  function formatWithValidation(url) {
+    if (false) {}
+    return formatUrl(url);
+  }
+});
+
+// ../../node_modules/next/dist/shared/lib/router/utils/omit.js
+var require_omit = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  Object.defineProperty(exports, "omit", {
+    enumerable: true,
+    get: function() {
+      return omit;
+    }
+  });
+  function omit(object, keys) {
+    const omitted = {};
+    Object.keys(object).forEach((key) => {
+      if (!keys.includes(key)) {
+        omitted[key] = object[key];
+      }
+    });
+    return omitted;
+  }
+});
+
+// ../../node_modules/next/dist/shared/lib/utils.js
+var require_utils = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  function _export(target, all) {
+    for (var name in all)
+      Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+  }
+  _export(exports, {
+    DecodeError: function() {
+      return DecodeError;
+    },
+    MiddlewareNotFoundError: function() {
+      return MiddlewareNotFoundError;
+    },
+    MissingStaticPage: function() {
+      return MissingStaticPage;
+    },
+    NormalizeError: function() {
+      return NormalizeError;
+    },
+    PageNotFoundError: function() {
+      return PageNotFoundError;
+    },
+    SP: function() {
+      return SP;
+    },
+    ST: function() {
+      return ST;
+    },
+    WEB_VITALS: function() {
+      return WEB_VITALS;
+    },
+    execOnce: function() {
+      return execOnce;
+    },
+    getDisplayName: function() {
+      return getDisplayName;
+    },
+    getLocationOrigin: function() {
+      return getLocationOrigin;
+    },
+    getURL: function() {
+      return getURL;
+    },
+    isAbsoluteUrl: function() {
+      return isAbsoluteUrl;
+    },
+    isResSent: function() {
+      return isResSent;
+    },
+    loadGetInitialProps: function() {
+      return loadGetInitialProps;
+    },
+    normalizeRepeatedSlashes: function() {
+      return normalizeRepeatedSlashes;
+    },
+    stringifyError: function() {
+      return stringifyError;
+    }
+  });
+  var WEB_VITALS = [
+    "CLS",
+    "FCP",
+    "FID",
+    "INP",
+    "LCP",
+    "TTFB"
+  ];
+  function execOnce(fn) {
+    let used = false;
+    let result;
+    return function() {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0;_key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      if (!used) {
+        used = true;
+        result = fn(...args);
+      }
+      return result;
+    };
+  }
+  var ABSOLUTE_URL_REGEX = /^[a-zA-Z][a-zA-Z\d+\-.]*?:/;
+  var isAbsoluteUrl = (url) => ABSOLUTE_URL_REGEX.test(url);
+  function getLocationOrigin() {
+    const { protocol, hostname, port } = window.location;
+    return protocol + "//" + hostname + (port ? ":" + port : "");
+  }
+  function getURL() {
+    const { href } = window.location;
+    const origin = getLocationOrigin();
+    return href.substring(origin.length);
+  }
+  function getDisplayName(Component) {
+    return typeof Component === "string" ? Component : Component.displayName || Component.name || "Unknown";
+  }
+  function isResSent(res) {
+    return res.finished || res.headersSent;
+  }
+  function normalizeRepeatedSlashes(url) {
+    const urlParts = url.split("?");
+    const urlNoQuery = urlParts[0];
+    return urlNoQuery.replace(/\\/g, "/").replace(/\/\/+/g, "/") + (urlParts[1] ? "?" + urlParts.slice(1).join("?") : "");
+  }
+  async function loadGetInitialProps(App, ctx) {
+    if (false) {
+      var _App_prototype;
+    }
+    const res = ctx.res || ctx.ctx && ctx.ctx.res;
+    if (!App.getInitialProps) {
+      if (ctx.ctx && ctx.Component) {
+        return {
+          pageProps: await loadGetInitialProps(ctx.Component, ctx.ctx)
+        };
+      }
+      return {};
+    }
+    const props = await App.getInitialProps(ctx);
+    if (res && isResSent(res)) {
+      return props;
+    }
+    if (!props) {
+      const message = '"' + getDisplayName(App) + '.getInitialProps()" should resolve to an object. But found "' + props + '" instead.';
+      throw Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+        value: "E394",
+        enumerable: false,
+        configurable: true
+      });
+    }
+    if (false) {}
+    return props;
+  }
+  var SP = typeof performance !== "undefined";
+  var ST = SP && [
+    "mark",
+    "measure",
+    "getEntriesByName"
+  ].every((method) => typeof performance[method] === "function");
+
+  class DecodeError extends Error {
+  }
+
+  class NormalizeError extends Error {
+  }
+
+  class PageNotFoundError extends Error {
+    constructor(page) {
+      super();
+      this.code = "ENOENT";
+      this.name = "PageNotFoundError";
+      this.message = "Cannot find module for page: " + page;
+    }
+  }
+
+  class MissingStaticPage extends Error {
+    constructor(page, message) {
+      super();
+      this.message = "Failed to load static file for page: " + page + " " + message;
+    }
+  }
+
+  class MiddlewareNotFoundError extends Error {
+    constructor() {
+      super();
+      this.code = "ENOENT";
+      this.message = "Cannot find the middleware module";
+    }
+  }
+  function stringifyError(error) {
+    return JSON.stringify({
+      message: error.message,
+      stack: error.stack
+    });
+  }
+});
+
+// ../../node_modules/next/dist/shared/lib/router/utils/remove-trailing-slash.js
+var require_remove_trailing_slash = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  Object.defineProperty(exports, "removeTrailingSlash", {
+    enumerable: true,
+    get: function() {
+      return removeTrailingSlash;
+    }
+  });
+  function removeTrailingSlash(route) {
+    return route.replace(/\/$/, "") || "/";
+  }
+});
+
+// ../../node_modules/next/dist/shared/lib/router/utils/parse-path.js
+var require_parse_path = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  Object.defineProperty(exports, "parsePath", {
+    enumerable: true,
+    get: function() {
+      return parsePath;
+    }
+  });
+  function parsePath(path) {
+    const hashIndex = path.indexOf("#");
+    const queryIndex = path.indexOf("?");
+    const hasQuery = queryIndex > -1 && (hashIndex < 0 || queryIndex < hashIndex);
+    if (hasQuery || hashIndex > -1) {
+      return {
+        pathname: path.substring(0, hasQuery ? queryIndex : hashIndex),
+        query: hasQuery ? path.substring(queryIndex, hashIndex > -1 ? hashIndex : undefined) : "",
+        hash: hashIndex > -1 ? path.slice(hashIndex) : ""
+      };
+    }
+    return {
+      pathname: path,
+      query: "",
+      hash: ""
+    };
+  }
+});
+
+// ../../node_modules/next/dist/client/normalize-trailing-slash.js
+var require_normalize_trailing_slash = __commonJS((exports, module) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  Object.defineProperty(exports, "normalizePathTrailingSlash", {
+    enumerable: true,
+    get: function() {
+      return normalizePathTrailingSlash;
+    }
+  });
+  var _removetrailingslash = require_remove_trailing_slash();
+  var _parsepath = require_parse_path();
+  var normalizePathTrailingSlash = (path) => {
+    if (!path.startsWith("/") || process.env.__NEXT_MANUAL_TRAILING_SLASH) {
+      return path;
+    }
+    const { pathname, query, hash } = (0, _parsepath.parsePath)(path);
+    if (process.env.__NEXT_TRAILING_SLASH) {
+      if (/\.[^/]+\/?$/.test(pathname)) {
+        return "" + (0, _removetrailingslash.removeTrailingSlash)(pathname) + query + hash;
+      } else if (pathname.endsWith("/")) {
+        return "" + pathname + query + hash;
+      } else {
+        return pathname + "/" + query + hash;
+      }
+    }
+    return "" + (0, _removetrailingslash.removeTrailingSlash)(pathname) + query + hash;
+  };
+  if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
+    Object.defineProperty(exports.default, "__esModule", { value: true });
+    Object.assign(exports.default, exports);
+    module.exports = exports.default;
+  }
+});
+
+// ../../node_modules/next/dist/shared/lib/router/utils/path-has-prefix.js
+var require_path_has_prefix = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  Object.defineProperty(exports, "pathHasPrefix", {
+    enumerable: true,
+    get: function() {
+      return pathHasPrefix;
+    }
+  });
+  var _parsepath = require_parse_path();
+  function pathHasPrefix(path, prefix) {
+    if (typeof path !== "string") {
+      return false;
+    }
+    const { pathname } = (0, _parsepath.parsePath)(path);
+    return pathname === prefix || pathname.startsWith(prefix + "/");
+  }
+});
+
+// ../../node_modules/next/dist/client/has-base-path.js
+var require_has_base_path = __commonJS((exports, module) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  Object.defineProperty(exports, "hasBasePath", {
+    enumerable: true,
+    get: function() {
+      return hasBasePath;
+    }
+  });
+  var _pathhasprefix = require_path_has_prefix();
+  var basePath = process.env.__NEXT_ROUTER_BASEPATH || "";
+  function hasBasePath(path) {
+    return (0, _pathhasprefix.pathHasPrefix)(path, basePath);
+  }
+  if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
+    Object.defineProperty(exports.default, "__esModule", { value: true });
+    Object.assign(exports.default, exports);
+    module.exports = exports.default;
+  }
+});
+
+// ../../node_modules/next/dist/shared/lib/router/utils/is-local-url.js
+var require_is_local_url = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  Object.defineProperty(exports, "isLocalURL", {
+    enumerable: true,
+    get: function() {
+      return isLocalURL;
+    }
+  });
+  var _utils = require_utils();
+  var _hasbasepath = require_has_base_path();
+  function isLocalURL(url) {
+    if (!(0, _utils.isAbsoluteUrl)(url))
+      return true;
+    try {
+      const locationOrigin = (0, _utils.getLocationOrigin)();
+      const resolved = new URL(url, locationOrigin);
+      return resolved.origin === locationOrigin && (0, _hasbasepath.hasBasePath)(resolved.pathname);
+    } catch (_) {
+      return false;
+    }
+  }
+});
+
+// ../../node_modules/next/dist/shared/lib/router/utils/sorted-routes.js
+var require_sorted_routes = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  function _export(target, all) {
+    for (var name in all)
+      Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+  }
+  _export(exports, {
+    getSortedRouteObjects: function() {
+      return getSortedRouteObjects;
+    },
+    getSortedRoutes: function() {
+      return getSortedRoutes;
+    }
+  });
+
+  class UrlNode {
+    insert(urlPath) {
+      this._insert(urlPath.split("/").filter(Boolean), [], false);
+    }
+    smoosh() {
+      return this._smoosh();
+    }
+    _smoosh(prefix) {
+      if (prefix === undefined)
+        prefix = "/";
+      const childrenPaths = [
+        ...this.children.keys()
+      ].sort();
+      if (this.slugName !== null) {
+        childrenPaths.splice(childrenPaths.indexOf("[]"), 1);
+      }
+      if (this.restSlugName !== null) {
+        childrenPaths.splice(childrenPaths.indexOf("[...]"), 1);
+      }
+      if (this.optionalRestSlugName !== null) {
+        childrenPaths.splice(childrenPaths.indexOf("[[...]]"), 1);
+      }
+      const routes = childrenPaths.map((c) => this.children.get(c)._smoosh("" + prefix + c + "/")).reduce((prev, curr) => [
+        ...prev,
+        ...curr
+      ], []);
+      if (this.slugName !== null) {
+        routes.push(...this.children.get("[]")._smoosh(prefix + "[" + this.slugName + "]/"));
+      }
+      if (!this.placeholder) {
+        const r = prefix === "/" ? "/" : prefix.slice(0, -1);
+        if (this.optionalRestSlugName != null) {
+          throw Object.defineProperty(new Error('You cannot define a route with the same specificity as a optional catch-all route ("' + r + '" and "' + r + "[[..." + this.optionalRestSlugName + ']]").'), "__NEXT_ERROR_CODE", {
+            value: "E458",
+            enumerable: false,
+            configurable: true
+          });
+        }
+        routes.unshift(r);
+      }
+      if (this.restSlugName !== null) {
+        routes.push(...this.children.get("[...]")._smoosh(prefix + "[..." + this.restSlugName + "]/"));
+      }
+      if (this.optionalRestSlugName !== null) {
+        routes.push(...this.children.get("[[...]]")._smoosh(prefix + "[[..." + this.optionalRestSlugName + "]]/"));
+      }
+      return routes;
+    }
+    _insert(urlPaths, slugNames, isCatchAll) {
+      if (urlPaths.length === 0) {
+        this.placeholder = false;
+        return;
+      }
+      if (isCatchAll) {
+        throw Object.defineProperty(new Error("Catch-all must be the last part of the URL."), "__NEXT_ERROR_CODE", {
+          value: "E392",
+          enumerable: false,
+          configurable: true
+        });
+      }
+      let nextSegment = urlPaths[0];
+      if (nextSegment.startsWith("[") && nextSegment.endsWith("]")) {
+        let handleSlug = function(previousSlug, nextSlug) {
+          if (previousSlug !== null) {
+            if (previousSlug !== nextSlug) {
+              throw Object.defineProperty(new Error("You cannot use different slug names for the same dynamic path ('" + previousSlug + "' !== '" + nextSlug + "')."), "__NEXT_ERROR_CODE", {
+                value: "E337",
+                enumerable: false,
+                configurable: true
+              });
+            }
+          }
+          slugNames.forEach((slug) => {
+            if (slug === nextSlug) {
+              throw Object.defineProperty(new Error('You cannot have the same slug name "' + nextSlug + '" repeat within a single dynamic path'), "__NEXT_ERROR_CODE", {
+                value: "E247",
+                enumerable: false,
+                configurable: true
+              });
+            }
+            if (slug.replace(/\W/g, "") === nextSegment.replace(/\W/g, "")) {
+              throw Object.defineProperty(new Error('You cannot have the slug names "' + slug + '" and "' + nextSlug + '" differ only by non-word symbols within a single dynamic path'), "__NEXT_ERROR_CODE", {
+                value: "E499",
+                enumerable: false,
+                configurable: true
+              });
+            }
+          });
+          slugNames.push(nextSlug);
+        };
+        let segmentName = nextSegment.slice(1, -1);
+        let isOptional = false;
+        if (segmentName.startsWith("[") && segmentName.endsWith("]")) {
+          segmentName = segmentName.slice(1, -1);
+          isOptional = true;
+        }
+        if (segmentName.startsWith("…")) {
+          throw Object.defineProperty(new Error("Detected a three-dot character ('…') at ('" + segmentName + "'). Did you mean ('...')?"), "__NEXT_ERROR_CODE", {
+            value: "E147",
+            enumerable: false,
+            configurable: true
+          });
+        }
+        if (segmentName.startsWith("...")) {
+          segmentName = segmentName.substring(3);
+          isCatchAll = true;
+        }
+        if (segmentName.startsWith("[") || segmentName.endsWith("]")) {
+          throw Object.defineProperty(new Error("Segment names may not start or end with extra brackets ('" + segmentName + "')."), "__NEXT_ERROR_CODE", {
+            value: "E421",
+            enumerable: false,
+            configurable: true
+          });
+        }
+        if (segmentName.startsWith(".")) {
+          throw Object.defineProperty(new Error("Segment names may not start with erroneous periods ('" + segmentName + "')."), "__NEXT_ERROR_CODE", {
+            value: "E288",
+            enumerable: false,
+            configurable: true
+          });
+        }
+        if (isCatchAll) {
+          if (isOptional) {
+            if (this.restSlugName != null) {
+              throw Object.defineProperty(new Error('You cannot use both an required and optional catch-all route at the same level ("[...' + this.restSlugName + ']" and "' + urlPaths[0] + '" ).'), "__NEXT_ERROR_CODE", {
+                value: "E299",
+                enumerable: false,
+                configurable: true
+              });
+            }
+            handleSlug(this.optionalRestSlugName, segmentName);
+            this.optionalRestSlugName = segmentName;
+            nextSegment = "[[...]]";
+          } else {
+            if (this.optionalRestSlugName != null) {
+              throw Object.defineProperty(new Error('You cannot use both an optional and required catch-all route at the same level ("[[...' + this.optionalRestSlugName + ']]" and "' + urlPaths[0] + '").'), "__NEXT_ERROR_CODE", {
+                value: "E300",
+                enumerable: false,
+                configurable: true
+              });
+            }
+            handleSlug(this.restSlugName, segmentName);
+            this.restSlugName = segmentName;
+            nextSegment = "[...]";
+          }
+        } else {
+          if (isOptional) {
+            throw Object.defineProperty(new Error('Optional route parameters are not yet supported ("' + urlPaths[0] + '").'), "__NEXT_ERROR_CODE", {
+              value: "E435",
+              enumerable: false,
+              configurable: true
+            });
+          }
+          handleSlug(this.slugName, segmentName);
+          this.slugName = segmentName;
+          nextSegment = "[]";
+        }
+      }
+      if (!this.children.has(nextSegment)) {
+        this.children.set(nextSegment, new UrlNode);
+      }
+      this.children.get(nextSegment)._insert(urlPaths.slice(1), slugNames, isCatchAll);
+    }
+    constructor() {
+      this.placeholder = true;
+      this.children = new Map;
+      this.slugName = null;
+      this.restSlugName = null;
+      this.optionalRestSlugName = null;
+    }
+  }
+  function getSortedRoutes(normalizedPages) {
+    const root = new UrlNode;
+    normalizedPages.forEach((pagePath) => root.insert(pagePath));
+    return root.smoosh();
+  }
+  function getSortedRouteObjects(objects, getter) {
+    const indexes = {};
+    const pathnames = [];
+    for (let i = 0;i < objects.length; i++) {
+      const pathname = getter(objects[i]);
+      indexes[pathname] = i;
+      pathnames[i] = pathname;
+    }
+    const sorted = getSortedRoutes(pathnames);
+    return sorted.map((pathname) => objects[indexes[pathname]]);
+  }
+});
+
+// ../../node_modules/next/dist/shared/lib/page-path/ensure-leading-slash.js
+var require_ensure_leading_slash = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  Object.defineProperty(exports, "ensureLeadingSlash", {
+    enumerable: true,
+    get: function() {
+      return ensureLeadingSlash;
+    }
+  });
+  function ensureLeadingSlash(path) {
+    return path.startsWith("/") ? path : "/" + path;
+  }
+});
+
+// ../../node_modules/next/dist/shared/lib/segment.js
+var require_segment = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  function _export(target, all) {
+    for (var name in all)
+      Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+  }
+  _export(exports, {
+    DEFAULT_SEGMENT_KEY: function() {
+      return DEFAULT_SEGMENT_KEY;
+    },
+    PAGE_SEGMENT_KEY: function() {
+      return PAGE_SEGMENT_KEY;
+    },
+    addSearchParamsIfPageSegment: function() {
+      return addSearchParamsIfPageSegment;
+    },
+    isGroupSegment: function() {
+      return isGroupSegment;
+    },
+    isParallelRouteSegment: function() {
+      return isParallelRouteSegment;
+    }
+  });
+  function isGroupSegment(segment) {
+    return segment[0] === "(" && segment.endsWith(")");
+  }
+  function isParallelRouteSegment(segment) {
+    return segment.startsWith("@") && segment !== "@children";
+  }
+  function addSearchParamsIfPageSegment(segment, searchParams) {
+    const isPageSegment = segment.includes(PAGE_SEGMENT_KEY);
+    if (isPageSegment) {
+      const stringifiedQuery = JSON.stringify(searchParams);
+      return stringifiedQuery !== "{}" ? PAGE_SEGMENT_KEY + "?" + stringifiedQuery : PAGE_SEGMENT_KEY;
+    }
+    return segment;
+  }
+  var PAGE_SEGMENT_KEY = "__PAGE__";
+  var DEFAULT_SEGMENT_KEY = "__DEFAULT__";
+});
+
+// ../../node_modules/next/dist/shared/lib/router/utils/app-paths.js
+var require_app_paths = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  function _export(target, all) {
+    for (var name in all)
+      Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+  }
+  _export(exports, {
+    normalizeAppPath: function() {
+      return normalizeAppPath;
+    },
+    normalizeRscURL: function() {
+      return normalizeRscURL;
+    }
+  });
+  var _ensureleadingslash = require_ensure_leading_slash();
+  var _segment = require_segment();
+  function normalizeAppPath(route) {
+    return (0, _ensureleadingslash.ensureLeadingSlash)(route.split("/").reduce((pathname, segment, index, segments) => {
+      if (!segment) {
+        return pathname;
+      }
+      if ((0, _segment.isGroupSegment)(segment)) {
+        return pathname;
+      }
+      if (segment[0] === "@") {
+        return pathname;
+      }
+      if ((segment === "page" || segment === "route") && index === segments.length - 1) {
+        return pathname;
+      }
+      return pathname + "/" + segment;
+    }, ""));
+  }
+  function normalizeRscURL(url) {
+    return url.replace(/\.rsc($|\?)/, "$1");
+  }
+});
+
+// ../../node_modules/next/dist/shared/lib/router/utils/interception-routes.js
+var require_interception_routes = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  function _export(target, all) {
+    for (var name in all)
+      Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+  }
+  _export(exports, {
+    INTERCEPTION_ROUTE_MARKERS: function() {
+      return INTERCEPTION_ROUTE_MARKERS;
+    },
+    extractInterceptionRouteInformation: function() {
+      return extractInterceptionRouteInformation;
+    },
+    isInterceptionRouteAppPath: function() {
+      return isInterceptionRouteAppPath;
+    }
+  });
+  var _apppaths = require_app_paths();
+  var INTERCEPTION_ROUTE_MARKERS = [
+    "(..)(..)",
+    "(.)",
+    "(..)",
+    "(...)"
+  ];
+  function isInterceptionRouteAppPath(path) {
+    return path.split("/").find((segment) => INTERCEPTION_ROUTE_MARKERS.find((m) => segment.startsWith(m))) !== undefined;
+  }
+  function extractInterceptionRouteInformation(path) {
+    let interceptingRoute, marker, interceptedRoute;
+    for (const segment of path.split("/")) {
+      marker = INTERCEPTION_ROUTE_MARKERS.find((m) => segment.startsWith(m));
+      if (marker) {
+        [interceptingRoute, interceptedRoute] = path.split(marker, 2);
+        break;
+      }
+    }
+    if (!interceptingRoute || !marker || !interceptedRoute) {
+      throw Object.defineProperty(new Error("Invalid interception route: " + path + ". Must be in the format /<intercepting route>/(..|...|..)(..)/<intercepted route>"), "__NEXT_ERROR_CODE", {
+        value: "E269",
+        enumerable: false,
+        configurable: true
+      });
+    }
+    interceptingRoute = (0, _apppaths.normalizeAppPath)(interceptingRoute);
+    switch (marker) {
+      case "(.)":
+        if (interceptingRoute === "/") {
+          interceptedRoute = "/" + interceptedRoute;
+        } else {
+          interceptedRoute = interceptingRoute + "/" + interceptedRoute;
+        }
+        break;
+      case "(..)":
+        if (interceptingRoute === "/") {
+          throw Object.defineProperty(new Error("Invalid interception route: " + path + ". Cannot use (..) marker at the root level, use (.) instead."), "__NEXT_ERROR_CODE", {
+            value: "E207",
+            enumerable: false,
+            configurable: true
+          });
+        }
+        interceptedRoute = interceptingRoute.split("/").slice(0, -1).concat(interceptedRoute).join("/");
+        break;
+      case "(...)":
+        interceptedRoute = "/" + interceptedRoute;
+        break;
+      case "(..)(..)":
+        const splitInterceptingRoute = interceptingRoute.split("/");
+        if (splitInterceptingRoute.length <= 2) {
+          throw Object.defineProperty(new Error("Invalid interception route: " + path + ". Cannot use (..)(..) marker at the root level or one level up."), "__NEXT_ERROR_CODE", {
+            value: "E486",
+            enumerable: false,
+            configurable: true
+          });
+        }
+        interceptedRoute = splitInterceptingRoute.slice(0, -2).concat(interceptedRoute).join("/");
+        break;
+      default:
+        throw Object.defineProperty(new Error("Invariant: unexpected marker"), "__NEXT_ERROR_CODE", {
+          value: "E112",
+          enumerable: false,
+          configurable: true
+        });
+    }
+    return {
+      interceptingRoute,
+      interceptedRoute
+    };
+  }
+});
+
+// ../../node_modules/next/dist/shared/lib/router/utils/is-dynamic.js
+var require_is_dynamic = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  Object.defineProperty(exports, "isDynamicRoute", {
+    enumerable: true,
+    get: function() {
+      return isDynamicRoute;
+    }
+  });
+  var _interceptionroutes = require_interception_routes();
+  var TEST_ROUTE = /\/[^/]*\[[^/]+\][^/]*(?=\/|$)/;
+  var TEST_STRICT_ROUTE = /\/\[[^/]+\](?=\/|$)/;
+  function isDynamicRoute(route, strict) {
+    if (strict === undefined)
+      strict = true;
+    if ((0, _interceptionroutes.isInterceptionRouteAppPath)(route)) {
+      route = (0, _interceptionroutes.extractInterceptionRouteInformation)(route).interceptedRoute;
+    }
+    if (strict) {
+      return TEST_STRICT_ROUTE.test(route);
+    }
+    return TEST_ROUTE.test(route);
+  }
+});
+
+// ../../node_modules/next/dist/shared/lib/router/utils/index.js
+var require_utils2 = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  function _export(target, all) {
+    for (var name in all)
+      Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+  }
+  _export(exports, {
+    getSortedRouteObjects: function() {
+      return _sortedroutes.getSortedRouteObjects;
+    },
+    getSortedRoutes: function() {
+      return _sortedroutes.getSortedRoutes;
+    },
+    isDynamicRoute: function() {
+      return _isdynamic.isDynamicRoute;
+    }
+  });
+  var _sortedroutes = require_sorted_routes();
+  var _isdynamic = require_is_dynamic();
+});
+
+// ../../node_modules/next/dist/compiled/path-to-regexp/index.js
+var require_path_to_regexp = __commonJS((exports, module) => {
+  var __dirname = "/Users/ryanwaits/Code/projects/openpkg-ts/node_modules/next/dist/compiled/path-to-regexp";
+  (() => {
+    if (typeof __nccwpck_require__ !== "undefined")
+      __nccwpck_require__.ab = __dirname + "/";
+    var e = {};
+    (() => {
+      var n = e;
+      Object.defineProperty(n, "__esModule", { value: true });
+      n.pathToRegexp = n.tokensToRegexp = n.regexpToFunction = n.match = n.tokensToFunction = n.compile = n.parse = undefined;
+      function lexer(e2) {
+        var n2 = [];
+        var r = 0;
+        while (r < e2.length) {
+          var t = e2[r];
+          if (t === "*" || t === "+" || t === "?") {
+            n2.push({ type: "MODIFIER", index: r, value: e2[r++] });
+            continue;
+          }
+          if (t === "\\") {
+            n2.push({ type: "ESCAPED_CHAR", index: r++, value: e2[r++] });
+            continue;
+          }
+          if (t === "{") {
+            n2.push({ type: "OPEN", index: r, value: e2[r++] });
+            continue;
+          }
+          if (t === "}") {
+            n2.push({ type: "CLOSE", index: r, value: e2[r++] });
+            continue;
+          }
+          if (t === ":") {
+            var a = "";
+            var i = r + 1;
+            while (i < e2.length) {
+              var o = e2.charCodeAt(i);
+              if (o >= 48 && o <= 57 || o >= 65 && o <= 90 || o >= 97 && o <= 122 || o === 95) {
+                a += e2[i++];
+                continue;
+              }
+              break;
+            }
+            if (!a)
+              throw new TypeError("Missing parameter name at ".concat(r));
+            n2.push({ type: "NAME", index: r, value: a });
+            r = i;
+            continue;
+          }
+          if (t === "(") {
+            var c = 1;
+            var f = "";
+            var i = r + 1;
+            if (e2[i] === "?") {
+              throw new TypeError('Pattern cannot start with "?" at '.concat(i));
+            }
+            while (i < e2.length) {
+              if (e2[i] === "\\") {
+                f += e2[i++] + e2[i++];
+                continue;
+              }
+              if (e2[i] === ")") {
+                c--;
+                if (c === 0) {
+                  i++;
+                  break;
+                }
+              } else if (e2[i] === "(") {
+                c++;
+                if (e2[i + 1] !== "?") {
+                  throw new TypeError("Capturing groups are not allowed at ".concat(i));
+                }
+              }
+              f += e2[i++];
+            }
+            if (c)
+              throw new TypeError("Unbalanced pattern at ".concat(r));
+            if (!f)
+              throw new TypeError("Missing pattern at ".concat(r));
+            n2.push({ type: "PATTERN", index: r, value: f });
+            r = i;
+            continue;
+          }
+          n2.push({ type: "CHAR", index: r, value: e2[r++] });
+        }
+        n2.push({ type: "END", index: r, value: "" });
+        return n2;
+      }
+      function parse(e2, n2) {
+        if (n2 === undefined) {
+          n2 = {};
+        }
+        var r = lexer(e2);
+        var t = n2.prefixes, a = t === undefined ? "./" : t, i = n2.delimiter, o = i === undefined ? "/#?" : i;
+        var c = [];
+        var f = 0;
+        var u = 0;
+        var p = "";
+        var tryConsume = function(e3) {
+          if (u < r.length && r[u].type === e3)
+            return r[u++].value;
+        };
+        var mustConsume = function(e3) {
+          var n3 = tryConsume(e3);
+          if (n3 !== undefined)
+            return n3;
+          var t2 = r[u], a2 = t2.type, i2 = t2.index;
+          throw new TypeError("Unexpected ".concat(a2, " at ").concat(i2, ", expected ").concat(e3));
+        };
+        var consumeText = function() {
+          var e3 = "";
+          var n3;
+          while (n3 = tryConsume("CHAR") || tryConsume("ESCAPED_CHAR")) {
+            e3 += n3;
+          }
+          return e3;
+        };
+        var isSafe = function(e3) {
+          for (var n3 = 0, r2 = o;n3 < r2.length; n3++) {
+            var t2 = r2[n3];
+            if (e3.indexOf(t2) > -1)
+              return true;
+          }
+          return false;
+        };
+        var safePattern = function(e3) {
+          var n3 = c[c.length - 1];
+          var r2 = e3 || (n3 && typeof n3 === "string" ? n3 : "");
+          if (n3 && !r2) {
+            throw new TypeError('Must have text between two parameters, missing text after "'.concat(n3.name, '"'));
+          }
+          if (!r2 || isSafe(r2))
+            return "[^".concat(escapeString(o), "]+?");
+          return "(?:(?!".concat(escapeString(r2), ")[^").concat(escapeString(o), "])+?");
+        };
+        while (u < r.length) {
+          var v = tryConsume("CHAR");
+          var s = tryConsume("NAME");
+          var d = tryConsume("PATTERN");
+          if (s || d) {
+            var g = v || "";
+            if (a.indexOf(g) === -1) {
+              p += g;
+              g = "";
+            }
+            if (p) {
+              c.push(p);
+              p = "";
+            }
+            c.push({ name: s || f++, prefix: g, suffix: "", pattern: d || safePattern(g), modifier: tryConsume("MODIFIER") || "" });
+            continue;
+          }
+          var x = v || tryConsume("ESCAPED_CHAR");
+          if (x) {
+            p += x;
+            continue;
+          }
+          if (p) {
+            c.push(p);
+            p = "";
+          }
+          var h = tryConsume("OPEN");
+          if (h) {
+            var g = consumeText();
+            var l = tryConsume("NAME") || "";
+            var m = tryConsume("PATTERN") || "";
+            var T = consumeText();
+            mustConsume("CLOSE");
+            c.push({ name: l || (m ? f++ : ""), pattern: l && !m ? safePattern(g) : m, prefix: g, suffix: T, modifier: tryConsume("MODIFIER") || "" });
+            continue;
+          }
+          mustConsume("END");
+        }
+        return c;
+      }
+      n.parse = parse;
+      function compile(e2, n2) {
+        return tokensToFunction(parse(e2, n2), n2);
+      }
+      n.compile = compile;
+      function tokensToFunction(e2, n2) {
+        if (n2 === undefined) {
+          n2 = {};
+        }
+        var r = flags(n2);
+        var t = n2.encode, a = t === undefined ? function(e3) {
+          return e3;
+        } : t, i = n2.validate, o = i === undefined ? true : i;
+        var c = e2.map(function(e3) {
+          if (typeof e3 === "object") {
+            return new RegExp("^(?:".concat(e3.pattern, ")$"), r);
+          }
+        });
+        return function(n3) {
+          var r2 = "";
+          for (var t2 = 0;t2 < e2.length; t2++) {
+            var i2 = e2[t2];
+            if (typeof i2 === "string") {
+              r2 += i2;
+              continue;
+            }
+            var f = n3 ? n3[i2.name] : undefined;
+            var u = i2.modifier === "?" || i2.modifier === "*";
+            var p = i2.modifier === "*" || i2.modifier === "+";
+            if (Array.isArray(f)) {
+              if (!p) {
+                throw new TypeError('Expected "'.concat(i2.name, '" to not repeat, but got an array'));
+              }
+              if (f.length === 0) {
+                if (u)
+                  continue;
+                throw new TypeError('Expected "'.concat(i2.name, '" to not be empty'));
+              }
+              for (var v = 0;v < f.length; v++) {
+                var s = a(f[v], i2);
+                if (o && !c[t2].test(s)) {
+                  throw new TypeError('Expected all "'.concat(i2.name, '" to match "').concat(i2.pattern, '", but got "').concat(s, '"'));
+                }
+                r2 += i2.prefix + s + i2.suffix;
+              }
+              continue;
+            }
+            if (typeof f === "string" || typeof f === "number") {
+              var s = a(String(f), i2);
+              if (o && !c[t2].test(s)) {
+                throw new TypeError('Expected "'.concat(i2.name, '" to match "').concat(i2.pattern, '", but got "').concat(s, '"'));
+              }
+              r2 += i2.prefix + s + i2.suffix;
+              continue;
+            }
+            if (u)
+              continue;
+            var d = p ? "an array" : "a string";
+            throw new TypeError('Expected "'.concat(i2.name, '" to be ').concat(d));
+          }
+          return r2;
+        };
+      }
+      n.tokensToFunction = tokensToFunction;
+      function match(e2, n2) {
+        var r = [];
+        var t = pathToRegexp(e2, r, n2);
+        return regexpToFunction(t, r, n2);
+      }
+      n.match = match;
+      function regexpToFunction(e2, n2, r) {
+        if (r === undefined) {
+          r = {};
+        }
+        var t = r.decode, a = t === undefined ? function(e3) {
+          return e3;
+        } : t;
+        return function(r2) {
+          var t2 = e2.exec(r2);
+          if (!t2)
+            return false;
+          var i = t2[0], o = t2.index;
+          var c = Object.create(null);
+          var _loop_1 = function(e3) {
+            if (t2[e3] === undefined)
+              return "continue";
+            var r3 = n2[e3 - 1];
+            if (r3.modifier === "*" || r3.modifier === "+") {
+              c[r3.name] = t2[e3].split(r3.prefix + r3.suffix).map(function(e4) {
+                return a(e4, r3);
+              });
+            } else {
+              c[r3.name] = a(t2[e3], r3);
+            }
+          };
+          for (var f = 1;f < t2.length; f++) {
+            _loop_1(f);
+          }
+          return { path: i, index: o, params: c };
+        };
+      }
+      n.regexpToFunction = regexpToFunction;
+      function escapeString(e2) {
+        return e2.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");
+      }
+      function flags(e2) {
+        return e2 && e2.sensitive ? "" : "i";
+      }
+      function regexpToRegexp(e2, n2) {
+        if (!n2)
+          return e2;
+        var r = /\((?:\?<(.*?)>)?(?!\?)/g;
+        var t = 0;
+        var a = r.exec(e2.source);
+        while (a) {
+          n2.push({ name: a[1] || t++, prefix: "", suffix: "", modifier: "", pattern: "" });
+          a = r.exec(e2.source);
+        }
+        return e2;
+      }
+      function arrayToRegexp(e2, n2, r) {
+        var t = e2.map(function(e3) {
+          return pathToRegexp(e3, n2, r).source;
+        });
+        return new RegExp("(?:".concat(t.join("|"), ")"), flags(r));
+      }
+      function stringToRegexp(e2, n2, r) {
+        return tokensToRegexp(parse(e2, r), n2, r);
+      }
+      function tokensToRegexp(e2, n2, r) {
+        if (r === undefined) {
+          r = {};
+        }
+        var t = r.strict, a = t === undefined ? false : t, i = r.start, o = i === undefined ? true : i, c = r.end, f = c === undefined ? true : c, u = r.encode, p = u === undefined ? function(e3) {
+          return e3;
+        } : u, v = r.delimiter, s = v === undefined ? "/#?" : v, d = r.endsWith, g = d === undefined ? "" : d;
+        var x = "[".concat(escapeString(g), "]|$");
+        var h = "[".concat(escapeString(s), "]");
+        var l = o ? "^" : "";
+        for (var m = 0, T = e2;m < T.length; m++) {
+          var E = T[m];
+          if (typeof E === "string") {
+            l += escapeString(p(E));
+          } else {
+            var w = escapeString(p(E.prefix));
+            var y = escapeString(p(E.suffix));
+            if (E.pattern) {
+              if (n2)
+                n2.push(E);
+              if (w || y) {
+                if (E.modifier === "+" || E.modifier === "*") {
+                  var R = E.modifier === "*" ? "?" : "";
+                  l += "(?:".concat(w, "((?:").concat(E.pattern, ")(?:").concat(y).concat(w, "(?:").concat(E.pattern, "))*)").concat(y, ")").concat(R);
+                } else {
+                  l += "(?:".concat(w, "(").concat(E.pattern, ")").concat(y, ")").concat(E.modifier);
+                }
+              } else {
+                if (E.modifier === "+" || E.modifier === "*") {
+                  throw new TypeError('Can not repeat "'.concat(E.name, '" without a prefix and suffix'));
+                }
+                l += "(".concat(E.pattern, ")").concat(E.modifier);
+              }
+            } else {
+              l += "(?:".concat(w).concat(y, ")").concat(E.modifier);
+            }
+          }
+        }
+        if (f) {
+          if (!a)
+            l += "".concat(h, "?");
+          l += !r.endsWith ? "$" : "(?=".concat(x, ")");
+        } else {
+          var A = e2[e2.length - 1];
+          var _ = typeof A === "string" ? h.indexOf(A[A.length - 1]) > -1 : A === undefined;
+          if (!a) {
+            l += "(?:".concat(h, "(?=").concat(x, "))?");
+          }
+          if (!_) {
+            l += "(?=".concat(h, "|").concat(x, ")");
+          }
+        }
+        return new RegExp(l, flags(r));
+      }
+      n.tokensToRegexp = tokensToRegexp;
+      function pathToRegexp(e2, n2, r) {
+        if (e2 instanceof RegExp)
+          return regexpToRegexp(e2, n2);
+        if (Array.isArray(e2))
+          return arrayToRegexp(e2, n2, r);
+        return stringToRegexp(e2, n2, r);
+      }
+      n.pathToRegexp = pathToRegexp;
+    })();
+    module.exports = e;
+  })();
+});
+
+// ../../node_modules/next/dist/lib/route-pattern-normalizer.js
+var require_route_pattern_normalizer = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  function _export(target, all) {
+    for (var name in all)
+      Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+  }
+  _export(exports, {
+    hasAdjacentParameterIssues: function() {
+      return hasAdjacentParameterIssues;
+    },
+    normalizeAdjacentParameters: function() {
+      return normalizeAdjacentParameters;
+    },
+    normalizeTokensForRegexp: function() {
+      return normalizeTokensForRegexp;
+    },
+    stripParameterSeparators: function() {
+      return stripParameterSeparators;
+    }
+  });
+  var PARAM_SEPARATOR = "_NEXTSEP_";
+  function hasAdjacentParameterIssues(route) {
+    if (typeof route !== "string")
+      return false;
+    if (/\/\(\.{1,3}\):[^/\s]+/.test(route)) {
+      return true;
+    }
+    if (/:[a-zA-Z_][a-zA-Z0-9_]*:[a-zA-Z_][a-zA-Z0-9_]*/.test(route)) {
+      return true;
+    }
+    return false;
+  }
+  function normalizeAdjacentParameters(route) {
+    let normalized = route;
+    normalized = normalized.replace(/(\([^)]*\)):([^/\s]+)/g, `$1${PARAM_SEPARATOR}:$2`);
+    normalized = normalized.replace(/:([^:/\s)]+)(?=:)/g, `:$1${PARAM_SEPARATOR}`);
+    return normalized;
+  }
+  function normalizeTokensForRegexp(tokens) {
+    return tokens.map((token) => {
+      if (typeof token === "object" && token !== null && "modifier" in token && (token.modifier === "*" || token.modifier === "+") && "prefix" in token && "suffix" in token && token.prefix === "" && token.suffix === "") {
+        return {
+          ...token,
+          prefix: "/"
+        };
+      }
+      return token;
+    });
+  }
+  function stripParameterSeparators(params) {
+    const cleaned = {};
+    for (const [key, value] of Object.entries(params)) {
+      if (typeof value === "string") {
+        cleaned[key] = value.replace(new RegExp(`^${PARAM_SEPARATOR}`), "");
+      } else if (Array.isArray(value)) {
+        cleaned[key] = value.map((item) => typeof item === "string" ? item.replace(new RegExp(`^${PARAM_SEPARATOR}`), "") : item);
+      } else {
+        cleaned[key] = value;
+      }
+    }
+    return cleaned;
+  }
+});
+
+// ../../node_modules/next/dist/shared/lib/router/utils/route-match-utils.js
+var require_route_match_utils = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  function _export(target, all) {
+    for (var name in all)
+      Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+  }
+  _export(exports, {
+    safeCompile: function() {
+      return safeCompile;
+    },
+    safePathToRegexp: function() {
+      return safePathToRegexp;
+    },
+    safeRegexpToFunction: function() {
+      return safeRegexpToFunction;
+    },
+    safeRouteMatcher: function() {
+      return safeRouteMatcher;
+    }
+  });
+  var _pathtoregexp = require_path_to_regexp();
+  var _routepatternnormalizer = require_route_pattern_normalizer();
+  function safePathToRegexp(route, keys, options) {
+    if (typeof route !== "string") {
+      return (0, _pathtoregexp.pathToRegexp)(route, keys, options);
+    }
+    const needsNormalization = (0, _routepatternnormalizer.hasAdjacentParameterIssues)(route);
+    const routeToUse = needsNormalization ? (0, _routepatternnormalizer.normalizeAdjacentParameters)(route) : route;
+    try {
+      return (0, _pathtoregexp.pathToRegexp)(routeToUse, keys, options);
+    } catch (error) {
+      if (!needsNormalization) {
+        try {
+          const normalizedRoute = (0, _routepatternnormalizer.normalizeAdjacentParameters)(route);
+          return (0, _pathtoregexp.pathToRegexp)(normalizedRoute, keys, options);
+        } catch (retryError) {
+          throw error;
+        }
+      }
+      throw error;
+    }
+  }
+  function safeCompile(route, options) {
+    const needsNormalization = (0, _routepatternnormalizer.hasAdjacentParameterIssues)(route);
+    const routeToUse = needsNormalization ? (0, _routepatternnormalizer.normalizeAdjacentParameters)(route) : route;
+    try {
+      return (0, _pathtoregexp.compile)(routeToUse, options);
+    } catch (error) {
+      if (!needsNormalization) {
+        try {
+          const normalizedRoute = (0, _routepatternnormalizer.normalizeAdjacentParameters)(route);
+          return (0, _pathtoregexp.compile)(normalizedRoute, options);
+        } catch (retryError) {
+          throw error;
+        }
+      }
+      throw error;
+    }
+  }
+  function safeRegexpToFunction(regexp, keys) {
+    const originalMatcher = (0, _pathtoregexp.regexpToFunction)(regexp, keys || []);
+    return (pathname) => {
+      const result = originalMatcher(pathname);
+      if (!result)
+        return false;
+      return {
+        ...result,
+        params: (0, _routepatternnormalizer.stripParameterSeparators)(result.params)
+      };
+    };
+  }
+  function safeRouteMatcher(matcherFn) {
+    return (pathname) => {
+      const result = matcherFn(pathname);
+      if (!result)
+        return false;
+      return (0, _routepatternnormalizer.stripParameterSeparators)(result);
+    };
+  }
+});
+
+// ../../node_modules/next/dist/shared/lib/router/utils/route-matcher.js
+var require_route_matcher = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  Object.defineProperty(exports, "getRouteMatcher", {
+    enumerable: true,
+    get: function() {
+      return getRouteMatcher;
+    }
+  });
+  var _utils = require_utils();
+  var _routematchutils = require_route_match_utils();
+  function getRouteMatcher(param) {
+    let { re, groups } = param;
+    const rawMatcher = (pathname) => {
+      const routeMatch = re.exec(pathname);
+      if (!routeMatch)
+        return false;
+      const decode = (param2) => {
+        try {
+          return decodeURIComponent(param2);
+        } catch (e) {
+          throw Object.defineProperty(new _utils.DecodeError("failed to decode param"), "__NEXT_ERROR_CODE", {
+            value: "E528",
+            enumerable: false,
+            configurable: true
+          });
+        }
+      };
+      const params = {};
+      for (const [key, group] of Object.entries(groups)) {
+        const match = routeMatch[group.pos];
+        if (match !== undefined) {
+          if (group.repeat) {
+            params[key] = match.split("/").map((entry) => decode(entry));
+          } else {
+            params[key] = decode(match);
+          }
+        }
+      }
+      return params;
+    };
+    return (0, _routematchutils.safeRouteMatcher)(rawMatcher);
+  }
+});
+
+// ../../node_modules/next/dist/lib/constants.js
+var require_constants = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  function _export(target, all) {
+    for (var name in all)
+      Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+  }
+  _export(exports, {
+    ACTION_SUFFIX: function() {
+      return ACTION_SUFFIX;
+    },
+    APP_DIR_ALIAS: function() {
+      return APP_DIR_ALIAS;
+    },
+    CACHE_ONE_YEAR: function() {
+      return CACHE_ONE_YEAR;
+    },
+    DOT_NEXT_ALIAS: function() {
+      return DOT_NEXT_ALIAS;
+    },
+    ESLINT_DEFAULT_DIRS: function() {
+      return ESLINT_DEFAULT_DIRS;
+    },
+    GSP_NO_RETURNED_VALUE: function() {
+      return GSP_NO_RETURNED_VALUE;
+    },
+    GSSP_COMPONENT_MEMBER_ERROR: function() {
+      return GSSP_COMPONENT_MEMBER_ERROR;
+    },
+    GSSP_NO_RETURNED_VALUE: function() {
+      return GSSP_NO_RETURNED_VALUE;
+    },
+    HTML_CONTENT_TYPE_HEADER: function() {
+      return HTML_CONTENT_TYPE_HEADER;
+    },
+    INFINITE_CACHE: function() {
+      return INFINITE_CACHE;
+    },
+    INSTRUMENTATION_HOOK_FILENAME: function() {
+      return INSTRUMENTATION_HOOK_FILENAME;
+    },
+    JSON_CONTENT_TYPE_HEADER: function() {
+      return JSON_CONTENT_TYPE_HEADER;
+    },
+    MATCHED_PATH_HEADER: function() {
+      return MATCHED_PATH_HEADER;
+    },
+    MIDDLEWARE_FILENAME: function() {
+      return MIDDLEWARE_FILENAME;
+    },
+    MIDDLEWARE_LOCATION_REGEXP: function() {
+      return MIDDLEWARE_LOCATION_REGEXP;
+    },
+    NEXT_BODY_SUFFIX: function() {
+      return NEXT_BODY_SUFFIX;
+    },
+    NEXT_CACHE_IMPLICIT_TAG_ID: function() {
+      return NEXT_CACHE_IMPLICIT_TAG_ID;
+    },
+    NEXT_CACHE_REVALIDATED_TAGS_HEADER: function() {
+      return NEXT_CACHE_REVALIDATED_TAGS_HEADER;
+    },
+    NEXT_CACHE_REVALIDATE_TAG_TOKEN_HEADER: function() {
+      return NEXT_CACHE_REVALIDATE_TAG_TOKEN_HEADER;
+    },
+    NEXT_CACHE_SOFT_TAG_MAX_LENGTH: function() {
+      return NEXT_CACHE_SOFT_TAG_MAX_LENGTH;
+    },
+    NEXT_CACHE_TAGS_HEADER: function() {
+      return NEXT_CACHE_TAGS_HEADER;
+    },
+    NEXT_CACHE_TAG_MAX_ITEMS: function() {
+      return NEXT_CACHE_TAG_MAX_ITEMS;
+    },
+    NEXT_CACHE_TAG_MAX_LENGTH: function() {
+      return NEXT_CACHE_TAG_MAX_LENGTH;
+    },
+    NEXT_DATA_SUFFIX: function() {
+      return NEXT_DATA_SUFFIX;
+    },
+    NEXT_INTERCEPTION_MARKER_PREFIX: function() {
+      return NEXT_INTERCEPTION_MARKER_PREFIX;
+    },
+    NEXT_META_SUFFIX: function() {
+      return NEXT_META_SUFFIX;
+    },
+    NEXT_QUERY_PARAM_PREFIX: function() {
+      return NEXT_QUERY_PARAM_PREFIX;
+    },
+    NEXT_RESUME_HEADER: function() {
+      return NEXT_RESUME_HEADER;
+    },
+    NON_STANDARD_NODE_ENV: function() {
+      return NON_STANDARD_NODE_ENV;
+    },
+    PAGES_DIR_ALIAS: function() {
+      return PAGES_DIR_ALIAS;
+    },
+    PRERENDER_REVALIDATE_HEADER: function() {
+      return PRERENDER_REVALIDATE_HEADER;
+    },
+    PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER: function() {
+      return PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER;
+    },
+    PUBLIC_DIR_MIDDLEWARE_CONFLICT: function() {
+      return PUBLIC_DIR_MIDDLEWARE_CONFLICT;
+    },
+    ROOT_DIR_ALIAS: function() {
+      return ROOT_DIR_ALIAS;
+    },
+    RSC_ACTION_CLIENT_WRAPPER_ALIAS: function() {
+      return RSC_ACTION_CLIENT_WRAPPER_ALIAS;
+    },
+    RSC_ACTION_ENCRYPTION_ALIAS: function() {
+      return RSC_ACTION_ENCRYPTION_ALIAS;
+    },
+    RSC_ACTION_PROXY_ALIAS: function() {
+      return RSC_ACTION_PROXY_ALIAS;
+    },
+    RSC_ACTION_VALIDATE_ALIAS: function() {
+      return RSC_ACTION_VALIDATE_ALIAS;
+    },
+    RSC_CACHE_WRAPPER_ALIAS: function() {
+      return RSC_CACHE_WRAPPER_ALIAS;
+    },
+    RSC_DYNAMIC_IMPORT_WRAPPER_ALIAS: function() {
+      return RSC_DYNAMIC_IMPORT_WRAPPER_ALIAS;
+    },
+    RSC_MOD_REF_PROXY_ALIAS: function() {
+      return RSC_MOD_REF_PROXY_ALIAS;
+    },
+    RSC_PREFETCH_SUFFIX: function() {
+      return RSC_PREFETCH_SUFFIX;
+    },
+    RSC_SEGMENTS_DIR_SUFFIX: function() {
+      return RSC_SEGMENTS_DIR_SUFFIX;
+    },
+    RSC_SEGMENT_SUFFIX: function() {
+      return RSC_SEGMENT_SUFFIX;
+    },
+    RSC_SUFFIX: function() {
+      return RSC_SUFFIX;
+    },
+    SERVER_PROPS_EXPORT_ERROR: function() {
+      return SERVER_PROPS_EXPORT_ERROR;
+    },
+    SERVER_PROPS_GET_INIT_PROPS_CONFLICT: function() {
+      return SERVER_PROPS_GET_INIT_PROPS_CONFLICT;
+    },
+    SERVER_PROPS_SSG_CONFLICT: function() {
+      return SERVER_PROPS_SSG_CONFLICT;
+    },
+    SERVER_RUNTIME: function() {
+      return SERVER_RUNTIME;
+    },
+    SSG_FALLBACK_EXPORT_ERROR: function() {
+      return SSG_FALLBACK_EXPORT_ERROR;
+    },
+    SSG_GET_INITIAL_PROPS_CONFLICT: function() {
+      return SSG_GET_INITIAL_PROPS_CONFLICT;
+    },
+    STATIC_STATUS_PAGE_GET_INITIAL_PROPS_ERROR: function() {
+      return STATIC_STATUS_PAGE_GET_INITIAL_PROPS_ERROR;
+    },
+    TEXT_PLAIN_CONTENT_TYPE_HEADER: function() {
+      return TEXT_PLAIN_CONTENT_TYPE_HEADER;
+    },
+    UNSTABLE_REVALIDATE_RENAME_ERROR: function() {
+      return UNSTABLE_REVALIDATE_RENAME_ERROR;
+    },
+    WEBPACK_LAYERS: function() {
+      return WEBPACK_LAYERS;
+    },
+    WEBPACK_RESOURCE_QUERIES: function() {
+      return WEBPACK_RESOURCE_QUERIES;
+    }
+  });
+  var TEXT_PLAIN_CONTENT_TYPE_HEADER = "text/plain";
+  var HTML_CONTENT_TYPE_HEADER = "text/html; charset=utf-8";
+  var JSON_CONTENT_TYPE_HEADER = "application/json; charset=utf-8";
+  var NEXT_QUERY_PARAM_PREFIX = "nxtP";
+  var NEXT_INTERCEPTION_MARKER_PREFIX = "nxtI";
+  var MATCHED_PATH_HEADER = "x-matched-path";
+  var PRERENDER_REVALIDATE_HEADER = "x-prerender-revalidate";
+  var PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER = "x-prerender-revalidate-if-generated";
+  var RSC_PREFETCH_SUFFIX = ".prefetch.rsc";
+  var RSC_SEGMENTS_DIR_SUFFIX = ".segments";
+  var RSC_SEGMENT_SUFFIX = ".segment.rsc";
+  var RSC_SUFFIX = ".rsc";
+  var ACTION_SUFFIX = ".action";
+  var NEXT_DATA_SUFFIX = ".json";
+  var NEXT_META_SUFFIX = ".meta";
+  var NEXT_BODY_SUFFIX = ".body";
+  var NEXT_CACHE_TAGS_HEADER = "x-next-cache-tags";
+  var NEXT_CACHE_REVALIDATED_TAGS_HEADER = "x-next-revalidated-tags";
+  var NEXT_CACHE_REVALIDATE_TAG_TOKEN_HEADER = "x-next-revalidate-tag-token";
+  var NEXT_RESUME_HEADER = "next-resume";
+  var NEXT_CACHE_TAG_MAX_ITEMS = 128;
+  var NEXT_CACHE_TAG_MAX_LENGTH = 256;
+  var NEXT_CACHE_SOFT_TAG_MAX_LENGTH = 1024;
+  var NEXT_CACHE_IMPLICIT_TAG_ID = "_N_T_";
+  var CACHE_ONE_YEAR = 31536000;
+  var INFINITE_CACHE = 4294967294;
+  var MIDDLEWARE_FILENAME = "middleware";
+  var MIDDLEWARE_LOCATION_REGEXP = `(?:src/)?${MIDDLEWARE_FILENAME}`;
+  var INSTRUMENTATION_HOOK_FILENAME = "instrumentation";
+  var PAGES_DIR_ALIAS = "private-next-pages";
+  var DOT_NEXT_ALIAS = "private-dot-next";
+  var ROOT_DIR_ALIAS = "private-next-root-dir";
+  var APP_DIR_ALIAS = "private-next-app-dir";
+  var RSC_MOD_REF_PROXY_ALIAS = "private-next-rsc-mod-ref-proxy";
+  var RSC_ACTION_VALIDATE_ALIAS = "private-next-rsc-action-validate";
+  var RSC_ACTION_PROXY_ALIAS = "private-next-rsc-server-reference";
+  var RSC_CACHE_WRAPPER_ALIAS = "private-next-rsc-cache-wrapper";
+  var RSC_DYNAMIC_IMPORT_WRAPPER_ALIAS = "private-next-rsc-track-dynamic-import";
+  var RSC_ACTION_ENCRYPTION_ALIAS = "private-next-rsc-action-encryption";
+  var RSC_ACTION_CLIENT_WRAPPER_ALIAS = "private-next-rsc-action-client-wrapper";
+  var PUBLIC_DIR_MIDDLEWARE_CONFLICT = `You can not have a '_next' folder inside of your public folder. This conflicts with the internal '/_next' route. https://nextjs.org/docs/messages/public-next-folder-conflict`;
+  var SSG_GET_INITIAL_PROPS_CONFLICT = `You can not use getInitialProps with getStaticProps. To use SSG, please remove your getInitialProps`;
+  var SERVER_PROPS_GET_INIT_PROPS_CONFLICT = `You can not use getInitialProps with getServerSideProps. Please remove getInitialProps.`;
+  var SERVER_PROPS_SSG_CONFLICT = `You can not use getStaticProps or getStaticPaths with getServerSideProps. To use SSG, please remove getServerSideProps`;
+  var STATIC_STATUS_PAGE_GET_INITIAL_PROPS_ERROR = `can not have getInitialProps/getServerSideProps, https://nextjs.org/docs/messages/404-get-initial-props`;
+  var SERVER_PROPS_EXPORT_ERROR = `pages with \`getServerSideProps\` can not be exported. See more info here: https://nextjs.org/docs/messages/gssp-export`;
+  var GSP_NO_RETURNED_VALUE = "Your `getStaticProps` function did not return an object. Did you forget to add a `return`?";
+  var GSSP_NO_RETURNED_VALUE = "Your `getServerSideProps` function did not return an object. Did you forget to add a `return`?";
+  var UNSTABLE_REVALIDATE_RENAME_ERROR = "The `unstable_revalidate` property is available for general use.\n" + "Please use `revalidate` instead.";
+  var GSSP_COMPONENT_MEMBER_ERROR = `can not be attached to a page's component and must be exported from the page. See more info here: https://nextjs.org/docs/messages/gssp-component-member`;
+  var NON_STANDARD_NODE_ENV = `You are using a non-standard "NODE_ENV" value in your environment. This creates inconsistencies in the project and is strongly advised against. Read more: https://nextjs.org/docs/messages/non-standard-node-env`;
+  var SSG_FALLBACK_EXPORT_ERROR = `Pages with \`fallback\` enabled in \`getStaticPaths\` can not be exported. See more info here: https://nextjs.org/docs/messages/ssg-fallback-true-export`;
+  var ESLINT_DEFAULT_DIRS = [
+    "app",
+    "pages",
+    "components",
+    "lib",
+    "src"
+  ];
+  var SERVER_RUNTIME = {
+    edge: "edge",
+    experimentalEdge: "experimental-edge",
+    nodejs: "nodejs"
+  };
+  var WEBPACK_LAYERS_NAMES = {
+    shared: "shared",
+    reactServerComponents: "rsc",
+    serverSideRendering: "ssr",
+    actionBrowser: "action-browser",
+    apiNode: "api-node",
+    apiEdge: "api-edge",
+    middleware: "middleware",
+    instrument: "instrument",
+    edgeAsset: "edge-asset",
+    appPagesBrowser: "app-pages-browser",
+    pagesDirBrowser: "pages-dir-browser",
+    pagesDirEdge: "pages-dir-edge",
+    pagesDirNode: "pages-dir-node"
+  };
+  var WEBPACK_LAYERS = {
+    ...WEBPACK_LAYERS_NAMES,
+    GROUP: {
+      builtinReact: [
+        WEBPACK_LAYERS_NAMES.reactServerComponents,
+        WEBPACK_LAYERS_NAMES.actionBrowser
+      ],
+      serverOnly: [
+        WEBPACK_LAYERS_NAMES.reactServerComponents,
+        WEBPACK_LAYERS_NAMES.actionBrowser,
+        WEBPACK_LAYERS_NAMES.instrument,
+        WEBPACK_LAYERS_NAMES.middleware
+      ],
+      neutralTarget: [
+        WEBPACK_LAYERS_NAMES.apiNode,
+        WEBPACK_LAYERS_NAMES.apiEdge
+      ],
+      clientOnly: [
+        WEBPACK_LAYERS_NAMES.serverSideRendering,
+        WEBPACK_LAYERS_NAMES.appPagesBrowser
+      ],
+      bundled: [
+        WEBPACK_LAYERS_NAMES.reactServerComponents,
+        WEBPACK_LAYERS_NAMES.actionBrowser,
+        WEBPACK_LAYERS_NAMES.serverSideRendering,
+        WEBPACK_LAYERS_NAMES.appPagesBrowser,
+        WEBPACK_LAYERS_NAMES.shared,
+        WEBPACK_LAYERS_NAMES.instrument,
+        WEBPACK_LAYERS_NAMES.middleware
+      ],
+      appPages: [
+        WEBPACK_LAYERS_NAMES.reactServerComponents,
+        WEBPACK_LAYERS_NAMES.serverSideRendering,
+        WEBPACK_LAYERS_NAMES.appPagesBrowser,
+        WEBPACK_LAYERS_NAMES.actionBrowser
+      ]
+    }
+  };
+  var WEBPACK_RESOURCE_QUERIES = {
+    edgeSSREntry: "__next_edge_ssr_entry__",
+    metadata: "__next_metadata__",
+    metadataRoute: "__next_metadata_route__",
+    metadataImageMeta: "__next_metadata_image_meta__"
+  };
+});
+
+// ../../node_modules/next/dist/shared/lib/escape-regexp.js
+var require_escape_regexp = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  Object.defineProperty(exports, "escapeStringRegexp", {
+    enumerable: true,
+    get: function() {
+      return escapeStringRegexp;
+    }
+  });
+  var reHasRegExp = /[|\\{}()[\]^$+*?.-]/;
+  var reReplaceRegExp = /[|\\{}()[\]^$+*?.-]/g;
+  function escapeStringRegexp(str) {
+    if (reHasRegExp.test(str)) {
+      return str.replace(reReplaceRegExp, "\\$&");
+    }
+    return str;
+  }
+});
+
+// ../../node_modules/next/dist/shared/lib/router/utils/get-dynamic-param.js
+var require_get_dynamic_param = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  function _export(target, all) {
+    for (var name in all)
+      Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+  }
+  _export(exports, {
+    PARAMETER_PATTERN: function() {
+      return PARAMETER_PATTERN;
+    },
+    getDynamicParam: function() {
+      return getDynamicParam;
+    },
+    parseMatchedParameter: function() {
+      return parseMatchedParameter;
+    },
+    parseParameter: function() {
+      return parseParameter;
+    }
+  });
+  function getDynamicParam(params, segmentKey, dynamicParamType, pagePath, fallbackRouteParams) {
+    let value = params[segmentKey];
+    if (fallbackRouteParams && fallbackRouteParams.has(segmentKey)) {
+      value = fallbackRouteParams.get(segmentKey);
+    } else if (Array.isArray(value)) {
+      value = value.map((i) => encodeURIComponent(i));
+    } else if (typeof value === "string") {
+      value = encodeURIComponent(value);
+    }
+    if (!value) {
+      const isCatchall = dynamicParamType === "c";
+      const isOptionalCatchall = dynamicParamType === "oc";
+      if (isCatchall || isOptionalCatchall) {
+        if (isOptionalCatchall) {
+          return {
+            param: segmentKey,
+            value: null,
+            type: dynamicParamType,
+            treeSegment: [
+              segmentKey,
+              "",
+              dynamicParamType
+            ]
+          };
+        }
+        value = pagePath.split("/").slice(1).flatMap((pathSegment) => {
+          const param = parseParameter(pathSegment);
+          var _params_param_key;
+          return (_params_param_key = params[param.key]) != null ? _params_param_key : param.key;
+        });
+        return {
+          param: segmentKey,
+          value,
+          type: dynamicParamType,
+          treeSegment: [
+            segmentKey,
+            value.join("/"),
+            dynamicParamType
+          ]
+        };
+      }
+    }
+    return {
+      param: segmentKey,
+      value,
+      treeSegment: [
+        segmentKey,
+        Array.isArray(value) ? value.join("/") : value,
+        dynamicParamType
+      ],
+      type: dynamicParamType
+    };
+  }
+  var PARAMETER_PATTERN = /^([^[]*)\[((?:\[[^\]]*\])|[^\]]+)\](.*)$/;
+  function parseParameter(param) {
+    const match = param.match(PARAMETER_PATTERN);
+    if (!match) {
+      return parseMatchedParameter(param);
+    }
+    return parseMatchedParameter(match[2]);
+  }
+  function parseMatchedParameter(param) {
+    const optional = param.startsWith("[") && param.endsWith("]");
+    if (optional) {
+      param = param.slice(1, -1);
+    }
+    const repeat = param.startsWith("...");
+    if (repeat) {
+      param = param.slice(3);
+    }
+    return {
+      key: param,
+      repeat,
+      optional
+    };
+  }
+});
+
+// ../../node_modules/next/dist/shared/lib/router/utils/route-regex.js
+var require_route_regex = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  function _export(target, all) {
+    for (var name in all)
+      Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+  }
+  _export(exports, {
+    getNamedMiddlewareRegex: function() {
+      return getNamedMiddlewareRegex;
+    },
+    getNamedRouteRegex: function() {
+      return getNamedRouteRegex;
+    },
+    getRouteRegex: function() {
+      return getRouteRegex;
+    }
+  });
+  var _constants = require_constants();
+  var _interceptionroutes = require_interception_routes();
+  var _escaperegexp = require_escape_regexp();
+  var _removetrailingslash = require_remove_trailing_slash();
+  var _getdynamicparam = require_get_dynamic_param();
+  function getParametrizedRoute(route, includeSuffix, includePrefix) {
+    const groups = {};
+    let groupIndex = 1;
+    const segments = [];
+    for (const segment of (0, _removetrailingslash.removeTrailingSlash)(route).slice(1).split("/")) {
+      const markerMatch = _interceptionroutes.INTERCEPTION_ROUTE_MARKERS.find((m) => segment.startsWith(m));
+      const paramMatches = segment.match(_getdynamicparam.PARAMETER_PATTERN);
+      if (markerMatch && paramMatches && paramMatches[2]) {
+        const { key, optional, repeat } = (0, _getdynamicparam.parseMatchedParameter)(paramMatches[2]);
+        groups[key] = {
+          pos: groupIndex++,
+          repeat,
+          optional
+        };
+        segments.push("/" + (0, _escaperegexp.escapeStringRegexp)(markerMatch) + "([^/]+?)");
+      } else if (paramMatches && paramMatches[2]) {
+        const { key, repeat, optional } = (0, _getdynamicparam.parseMatchedParameter)(paramMatches[2]);
+        groups[key] = {
+          pos: groupIndex++,
+          repeat,
+          optional
+        };
+        if (includePrefix && paramMatches[1]) {
+          segments.push("/" + (0, _escaperegexp.escapeStringRegexp)(paramMatches[1]));
+        }
+        let s = repeat ? optional ? "(?:/(.+?))?" : "/(.+?)" : "/([^/]+?)";
+        if (includePrefix && paramMatches[1]) {
+          s = s.substring(1);
+        }
+        segments.push(s);
+      } else {
+        segments.push("/" + (0, _escaperegexp.escapeStringRegexp)(segment));
+      }
+      if (includeSuffix && paramMatches && paramMatches[3]) {
+        segments.push((0, _escaperegexp.escapeStringRegexp)(paramMatches[3]));
+      }
+    }
+    return {
+      parameterizedRoute: segments.join(""),
+      groups
+    };
+  }
+  function getRouteRegex(normalizedRoute, param) {
+    let { includeSuffix = false, includePrefix = false, excludeOptionalTrailingSlash = false } = param === undefined ? {} : param;
+    const { parameterizedRoute, groups } = getParametrizedRoute(normalizedRoute, includeSuffix, includePrefix);
+    let re = parameterizedRoute;
+    if (!excludeOptionalTrailingSlash) {
+      re += "(?:/)?";
+    }
+    return {
+      re: new RegExp("^" + re + "$"),
+      groups
+    };
+  }
+  function buildGetSafeRouteKey() {
+    let i = 0;
+    return () => {
+      let routeKey = "";
+      let j = ++i;
+      while (j > 0) {
+        routeKey += String.fromCharCode(97 + (j - 1) % 26);
+        j = Math.floor((j - 1) / 26);
+      }
+      return routeKey;
+    };
+  }
+  function getSafeKeyFromSegment(param) {
+    let { interceptionMarker, getSafeRouteKey, segment, routeKeys, keyPrefix, backreferenceDuplicateKeys } = param;
+    const { key, optional, repeat } = (0, _getdynamicparam.parseMatchedParameter)(segment);
+    let cleanedKey = key.replace(/\W/g, "");
+    if (keyPrefix) {
+      cleanedKey = "" + keyPrefix + cleanedKey;
+    }
+    let invalidKey = false;
+    if (cleanedKey.length === 0 || cleanedKey.length > 30) {
+      invalidKey = true;
+    }
+    if (!isNaN(parseInt(cleanedKey.slice(0, 1)))) {
+      invalidKey = true;
+    }
+    if (invalidKey) {
+      cleanedKey = getSafeRouteKey();
+    }
+    const duplicateKey = cleanedKey in routeKeys;
+    if (keyPrefix) {
+      routeKeys[cleanedKey] = "" + keyPrefix + key;
+    } else {
+      routeKeys[cleanedKey] = key;
+    }
+    const interceptionPrefix = interceptionMarker ? (0, _escaperegexp.escapeStringRegexp)(interceptionMarker) : "";
+    let pattern;
+    if (duplicateKey && backreferenceDuplicateKeys) {
+      pattern = "\\k<" + cleanedKey + ">";
+    } else if (repeat) {
+      pattern = "(?<" + cleanedKey + ">.+?)";
+    } else {
+      pattern = "(?<" + cleanedKey + ">[^/]+?)";
+    }
+    return optional ? "(?:/" + interceptionPrefix + pattern + ")?" : "/" + interceptionPrefix + pattern;
+  }
+  function getNamedParametrizedRoute(route, prefixRouteKeys, includeSuffix, includePrefix, backreferenceDuplicateKeys) {
+    const getSafeRouteKey = buildGetSafeRouteKey();
+    const routeKeys = {};
+    const segments = [];
+    for (const segment of (0, _removetrailingslash.removeTrailingSlash)(route).slice(1).split("/")) {
+      const hasInterceptionMarker = _interceptionroutes.INTERCEPTION_ROUTE_MARKERS.some((m) => segment.startsWith(m));
+      const paramMatches = segment.match(_getdynamicparam.PARAMETER_PATTERN);
+      if (hasInterceptionMarker && paramMatches && paramMatches[2]) {
+        segments.push(getSafeKeyFromSegment({
+          getSafeRouteKey,
+          interceptionMarker: paramMatches[1],
+          segment: paramMatches[2],
+          routeKeys,
+          keyPrefix: prefixRouteKeys ? _constants.NEXT_INTERCEPTION_MARKER_PREFIX : undefined,
+          backreferenceDuplicateKeys
+        }));
+      } else if (paramMatches && paramMatches[2]) {
+        if (includePrefix && paramMatches[1]) {
+          segments.push("/" + (0, _escaperegexp.escapeStringRegexp)(paramMatches[1]));
+        }
+        let s = getSafeKeyFromSegment({
+          getSafeRouteKey,
+          segment: paramMatches[2],
+          routeKeys,
+          keyPrefix: prefixRouteKeys ? _constants.NEXT_QUERY_PARAM_PREFIX : undefined,
+          backreferenceDuplicateKeys
+        });
+        if (includePrefix && paramMatches[1]) {
+          s = s.substring(1);
+        }
+        segments.push(s);
+      } else {
+        segments.push("/" + (0, _escaperegexp.escapeStringRegexp)(segment));
+      }
+      if (includeSuffix && paramMatches && paramMatches[3]) {
+        segments.push((0, _escaperegexp.escapeStringRegexp)(paramMatches[3]));
+      }
+    }
+    return {
+      namedParameterizedRoute: segments.join(""),
+      routeKeys
+    };
+  }
+  function getNamedRouteRegex(normalizedRoute, options) {
+    var _options_includeSuffix, _options_includePrefix, _options_backreferenceDuplicateKeys;
+    const result = getNamedParametrizedRoute(normalizedRoute, options.prefixRouteKeys, (_options_includeSuffix = options.includeSuffix) != null ? _options_includeSuffix : false, (_options_includePrefix = options.includePrefix) != null ? _options_includePrefix : false, (_options_backreferenceDuplicateKeys = options.backreferenceDuplicateKeys) != null ? _options_backreferenceDuplicateKeys : false);
+    let namedRegex = result.namedParameterizedRoute;
+    if (!options.excludeOptionalTrailingSlash) {
+      namedRegex += "(?:/)?";
+    }
+    return {
+      ...getRouteRegex(normalizedRoute, options),
+      namedRegex: "^" + namedRegex + "$",
+      routeKeys: result.routeKeys
+    };
+  }
+  function getNamedMiddlewareRegex(normalizedRoute, options) {
+    const { parameterizedRoute } = getParametrizedRoute(normalizedRoute, false, false);
+    const { catchAll = true } = options;
+    if (parameterizedRoute === "/") {
+      let catchAllRegex = catchAll ? ".*" : "";
+      return {
+        namedRegex: "^/" + catchAllRegex + "$"
+      };
+    }
+    const { namedParameterizedRoute } = getNamedParametrizedRoute(normalizedRoute, false, false, false, false);
+    let catchAllGroupedRegex = catchAll ? "(?:(/.*)?)" : "";
+    return {
+      namedRegex: "^" + namedParameterizedRoute + catchAllGroupedRegex + "$"
+    };
+  }
+});
+
+// ../../node_modules/next/dist/shared/lib/router/utils/interpolate-as.js
+var require_interpolate_as = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  Object.defineProperty(exports, "interpolateAs", {
+    enumerable: true,
+    get: function() {
+      return interpolateAs;
+    }
+  });
+  var _routematcher = require_route_matcher();
+  var _routeregex = require_route_regex();
+  function interpolateAs(route, asPathname, query) {
+    let interpolatedRoute = "";
+    const dynamicRegex = (0, _routeregex.getRouteRegex)(route);
+    const dynamicGroups = dynamicRegex.groups;
+    const dynamicMatches = (asPathname !== route ? (0, _routematcher.getRouteMatcher)(dynamicRegex)(asPathname) : "") || query;
+    interpolatedRoute = route;
+    const params = Object.keys(dynamicGroups);
+    if (!params.every((param) => {
+      let value = dynamicMatches[param] || "";
+      const { repeat, optional } = dynamicGroups[param];
+      let replaced = "[" + (repeat ? "..." : "") + param + "]";
+      if (optional) {
+        replaced = (!value ? "/" : "") + "[" + replaced + "]";
+      }
+      if (repeat && !Array.isArray(value))
+        value = [
+          value
+        ];
+      return (optional || (param in dynamicMatches)) && (interpolatedRoute = interpolatedRoute.replace(replaced, repeat ? value.map((segment) => encodeURIComponent(segment)).join("/") : encodeURIComponent(value)) || "/");
+    })) {
+      interpolatedRoute = "";
+    }
+    return {
+      params,
+      result: interpolatedRoute
+    };
+  }
+});
+
+// ../../node_modules/next/dist/client/resolve-href.js
+var require_resolve_href = __commonJS((exports, module) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  Object.defineProperty(exports, "resolveHref", {
+    enumerable: true,
+    get: function() {
+      return resolveHref;
+    }
+  });
+  var _querystring = require_querystring();
+  var _formaturl = require_format_url();
+  var _omit = require_omit();
+  var _utils = require_utils();
+  var _normalizetrailingslash = require_normalize_trailing_slash();
+  var _islocalurl = require_is_local_url();
+  var _utils1 = require_utils2();
+  var _interpolateas = require_interpolate_as();
+  var _routeregex = require_route_regex();
+  var _routematcher = require_route_matcher();
+  function resolveHref(router, href, resolveAs) {
+    let base;
+    let urlAsString = typeof href === "string" ? href : (0, _formaturl.formatWithValidation)(href);
+    const urlProtoMatch = urlAsString.match(/^[a-z][a-z0-9+.-]*:\/\//i);
+    const urlAsStringNoProto = urlProtoMatch ? urlAsString.slice(urlProtoMatch[0].length) : urlAsString;
+    const urlParts = urlAsStringNoProto.split("?", 1);
+    if ((urlParts[0] || "").match(/(\/\/|\\)/)) {
+      console.error("Invalid href '" + urlAsString + "' passed to next/router in page: '" + router.pathname + "'. Repeated forward-slashes (//) or backslashes \\ are not valid in the href.");
+      const normalizedUrl = (0, _utils.normalizeRepeatedSlashes)(urlAsStringNoProto);
+      urlAsString = (urlProtoMatch ? urlProtoMatch[0] : "") + normalizedUrl;
+    }
+    if (!(0, _islocalurl.isLocalURL)(urlAsString)) {
+      return resolveAs ? [
+        urlAsString
+      ] : urlAsString;
+    }
+    try {
+      let baseBase = urlAsString.startsWith("#") ? router.asPath : router.pathname;
+      if (urlAsString.startsWith("?")) {
+        baseBase = router.asPath;
+        if ((0, _utils1.isDynamicRoute)(router.pathname)) {
+          baseBase = router.pathname;
+          const routeRegex = (0, _routeregex.getRouteRegex)(router.pathname);
+          const match = (0, _routematcher.getRouteMatcher)(routeRegex)(router.asPath);
+          if (!match) {
+            baseBase = router.asPath;
+          }
+        }
+      }
+      base = new URL(baseBase, "http://n");
+    } catch (_) {
+      base = new URL("/", "http://n");
+    }
+    try {
+      const finalUrl = new URL(urlAsString, base);
+      finalUrl.pathname = (0, _normalizetrailingslash.normalizePathTrailingSlash)(finalUrl.pathname);
+      let interpolatedAs = "";
+      if ((0, _utils1.isDynamicRoute)(finalUrl.pathname) && finalUrl.searchParams && resolveAs) {
+        const query = (0, _querystring.searchParamsToUrlQuery)(finalUrl.searchParams);
+        const { result, params } = (0, _interpolateas.interpolateAs)(finalUrl.pathname, finalUrl.pathname, query);
+        if (result) {
+          interpolatedAs = (0, _formaturl.formatWithValidation)({
+            pathname: result,
+            hash: finalUrl.hash,
+            query: (0, _omit.omit)(query, params)
+          });
+        }
+      }
+      const resolvedHref = finalUrl.origin === base.origin ? finalUrl.href.slice(finalUrl.origin.length) : finalUrl.href;
+      return resolveAs ? [
+        resolvedHref,
+        interpolatedAs || resolvedHref
+      ] : resolvedHref;
+    } catch (_) {
+      return resolveAs ? [
+        urlAsString
+      ] : urlAsString;
+    }
+  }
+  if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
+    Object.defineProperty(exports.default, "__esModule", { value: true });
+    Object.assign(exports.default, exports);
+    module.exports = exports.default;
+  }
+});
+
+// ../../node_modules/next/dist/shared/lib/router/utils/add-path-prefix.js
+var require_add_path_prefix = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  Object.defineProperty(exports, "addPathPrefix", {
+    enumerable: true,
+    get: function() {
+      return addPathPrefix;
+    }
+  });
+  var _parsepath = require_parse_path();
+  function addPathPrefix(path, prefix) {
+    if (!path.startsWith("/") || !prefix) {
+      return path;
+    }
+    const { pathname, query, hash } = (0, _parsepath.parsePath)(path);
+    return "" + prefix + pathname + query + hash;
+  }
+});
+
+// ../../node_modules/next/dist/shared/lib/router/utils/add-locale.js
+var require_add_locale = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  Object.defineProperty(exports, "addLocale", {
+    enumerable: true,
+    get: function() {
+      return addLocale;
+    }
+  });
+  var _addpathprefix = require_add_path_prefix();
+  var _pathhasprefix = require_path_has_prefix();
+  function addLocale(path, locale, defaultLocale, ignorePrefix) {
+    if (!locale || locale === defaultLocale)
+      return path;
+    const lower = path.toLowerCase();
+    if (!ignorePrefix) {
+      if ((0, _pathhasprefix.pathHasPrefix)(lower, "/api"))
+        return path;
+      if ((0, _pathhasprefix.pathHasPrefix)(lower, "/" + locale.toLowerCase()))
+        return path;
+    }
+    return (0, _addpathprefix.addPathPrefix)(path, "/" + locale);
+  }
+});
+
+// ../../node_modules/next/dist/client/add-locale.js
+var require_add_locale2 = __commonJS((exports, module) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  Object.defineProperty(exports, "addLocale", {
+    enumerable: true,
+    get: function() {
+      return addLocale;
+    }
+  });
+  var _normalizetrailingslash = require_normalize_trailing_slash();
+  var addLocale = function(path) {
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1;_key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+    if (process.env.__NEXT_I18N_SUPPORT) {
+      return (0, _normalizetrailingslash.normalizePathTrailingSlash)(require_add_locale().addLocale(path, ...args));
+    }
+    return path;
+  };
+  if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
+    Object.defineProperty(exports.default, "__esModule", { value: true });
+    Object.assign(exports.default, exports);
+    module.exports = exports.default;
+  }
+});
+
+// ../../node_modules/@swc/helpers/cjs/_interop_require_default.cjs
+var require__interop_require_default = __commonJS((exports) => {
+  function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : { default: obj };
+  }
+  exports._ = _interop_require_default;
+});
+
+// ../../node_modules/next/dist/shared/lib/router-context.shared-runtime.js
+import * as react from "react";
+var require_router_context_shared_runtime = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  Object.defineProperty(exports, "RouterContext", {
+    enumerable: true,
+    get: function() {
+      return RouterContext;
+    }
+  });
+  var _interop_require_default = require__interop_require_default();
+  var _react = /* @__PURE__ */ _interop_require_default._(react);
+  var RouterContext = _react.default.createContext(null);
+  if (false) {}
+});
+
+// ../../node_modules/next/dist/client/request-idle-callback.js
+var require_request_idle_callback = __commonJS((exports, module) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  function _export(target, all) {
+    for (var name in all)
+      Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+  }
+  _export(exports, {
+    cancelIdleCallback: function() {
+      return cancelIdleCallback;
+    },
+    requestIdleCallback: function() {
+      return requestIdleCallback;
+    }
+  });
+  var requestIdleCallback = typeof self !== "undefined" && self.requestIdleCallback && self.requestIdleCallback.bind(window) || function(cb) {
+    let start = Date.now();
+    return self.setTimeout(function() {
+      cb({
+        didTimeout: false,
+        timeRemaining: function() {
+          return Math.max(0, 50 - (Date.now() - start));
+        }
+      });
+    }, 1);
+  };
+  var cancelIdleCallback = typeof self !== "undefined" && self.cancelIdleCallback && self.cancelIdleCallback.bind(window) || function(id) {
+    return clearTimeout(id);
+  };
+  if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
+    Object.defineProperty(exports.default, "__esModule", { value: true });
+    Object.assign(exports.default, exports);
+    module.exports = exports.default;
+  }
+});
+
+// ../../node_modules/next/dist/client/use-intersection.js
+import * as _react from "react";
+var require_use_intersection = __commonJS((exports, module) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  Object.defineProperty(exports, "useIntersection", {
+    enumerable: true,
+    get: function() {
+      return useIntersection;
+    }
+  });
+  var _requestidlecallback = require_request_idle_callback();
+  var hasIntersectionObserver = typeof IntersectionObserver === "function";
+  var observers = new Map;
+  var idList = [];
+  function createObserver(options) {
+    const id = {
+      root: options.root || null,
+      margin: options.rootMargin || ""
+    };
+    const existing = idList.find((obj) => obj.root === id.root && obj.margin === id.margin);
+    let instance;
+    if (existing) {
+      instance = observers.get(existing);
+      if (instance) {
+        return instance;
+      }
+    }
+    const elements = new Map;
+    const observer = new IntersectionObserver((entries) => {
+      entries.forEach((entry) => {
+        const callback = elements.get(entry.target);
+        const isVisible = entry.isIntersecting || entry.intersectionRatio > 0;
+        if (callback && isVisible) {
+          callback(isVisible);
+        }
+      });
+    }, options);
+    instance = {
+      id,
+      observer,
+      elements
+    };
+    idList.push(id);
+    observers.set(id, instance);
+    return instance;
+  }
+  function observe(element, callback, options) {
+    const { id, observer, elements } = createObserver(options);
+    elements.set(element, callback);
+    observer.observe(element);
+    return function unobserve() {
+      elements.delete(element);
+      observer.unobserve(element);
+      if (elements.size === 0) {
+        observer.disconnect();
+        observers.delete(id);
+        const index = idList.findIndex((obj) => obj.root === id.root && obj.margin === id.margin);
+        if (index > -1) {
+          idList.splice(index, 1);
+        }
+      }
+    };
+  }
+  function useIntersection(param) {
+    let { rootRef, rootMargin, disabled } = param;
+    const isDisabled = disabled || !hasIntersectionObserver;
+    const [visible, setVisible] = (0, _react.useState)(false);
+    const elementRef = (0, _react.useRef)(null);
+    const setElement = (0, _react.useCallback)((element) => {
+      elementRef.current = element;
+    }, []);
+    (0, _react.useEffect)(() => {
+      if (hasIntersectionObserver) {
+        if (isDisabled || visible)
+          return;
+        const element = elementRef.current;
+        if (element && element.tagName) {
+          const unobserve = observe(element, (isVisible) => isVisible && setVisible(isVisible), {
+            root: rootRef == null ? undefined : rootRef.current,
+            rootMargin
+          });
+          return unobserve;
+        }
+      } else {
+        if (!visible) {
+          const idleCallback = (0, _requestidlecallback.requestIdleCallback)(() => setVisible(true));
+          return () => (0, _requestidlecallback.cancelIdleCallback)(idleCallback);
+        }
+      }
+    }, [
+      isDisabled,
+      rootMargin,
+      rootRef,
+      visible,
+      elementRef.current
+    ]);
+    const resetVisible = (0, _react.useCallback)(() => {
+      setVisible(false);
+    }, []);
+    return [
+      setElement,
+      visible,
+      resetVisible
+    ];
+  }
+  if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
+    Object.defineProperty(exports.default, "__esModule", { value: true });
+    Object.assign(exports.default, exports);
+    module.exports = exports.default;
+  }
+});
+
+// ../../node_modules/next/dist/shared/lib/i18n/normalize-locale-path.js
+var require_normalize_locale_path = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  Object.defineProperty(exports, "normalizeLocalePath", {
+    enumerable: true,
+    get: function() {
+      return normalizeLocalePath;
+    }
+  });
+  var cache = new WeakMap;
+  function normalizeLocalePath(pathname, locales) {
+    if (!locales)
+      return {
+        pathname
+      };
+    let lowercasedLocales = cache.get(locales);
+    if (!lowercasedLocales) {
+      lowercasedLocales = locales.map((locale) => locale.toLowerCase());
+      cache.set(locales, lowercasedLocales);
+    }
+    let detectedLocale;
+    const segments = pathname.split("/", 2);
+    if (!segments[1])
+      return {
+        pathname
+      };
+    const segment = segments[1].toLowerCase();
+    const index = lowercasedLocales.indexOf(segment);
+    if (index < 0)
+      return {
+        pathname
+      };
+    detectedLocale = locales[index];
+    pathname = pathname.slice(detectedLocale.length + 1) || "/";
+    return {
+      pathname,
+      detectedLocale
+    };
+  }
+});
+
+// ../../node_modules/next/dist/client/normalize-locale-path.js
+var require_normalize_locale_path2 = __commonJS((exports, module) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  Object.defineProperty(exports, "normalizeLocalePath", {
+    enumerable: true,
+    get: function() {
+      return normalizeLocalePath;
+    }
+  });
+  var normalizeLocalePath = (pathname, locales) => {
+    if (process.env.__NEXT_I18N_SUPPORT) {
+      return require_normalize_locale_path().normalizeLocalePath(pathname, locales);
+    }
+    return {
+      pathname,
+      detectedLocale: undefined
+    };
+  };
+  if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
+    Object.defineProperty(exports.default, "__esModule", { value: true });
+    Object.assign(exports.default, exports);
+    module.exports = exports.default;
+  }
+});
+
+// ../../node_modules/next/dist/shared/lib/i18n/detect-domain-locale.js
+var require_detect_domain_locale = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  Object.defineProperty(exports, "detectDomainLocale", {
+    enumerable: true,
+    get: function() {
+      return detectDomainLocale;
+    }
+  });
+  function detectDomainLocale(domainItems, hostname, detectedLocale) {
+    if (!domainItems)
+      return;
+    if (detectedLocale) {
+      detectedLocale = detectedLocale.toLowerCase();
+    }
+    for (const item of domainItems) {
+      var _item_domain, _item_locales;
+      const domainHostname = (_item_domain = item.domain) == null ? undefined : _item_domain.split(":", 1)[0].toLowerCase();
+      if (hostname === domainHostname || detectedLocale === item.defaultLocale.toLowerCase() || ((_item_locales = item.locales) == null ? undefined : _item_locales.some((locale) => locale.toLowerCase() === detectedLocale))) {
+        return item;
+      }
+    }
+  }
+});
+
+// ../../node_modules/next/dist/client/detect-domain-locale.js
+var require_detect_domain_locale2 = __commonJS((exports, module) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  Object.defineProperty(exports, "detectDomainLocale", {
+    enumerable: true,
+    get: function() {
+      return detectDomainLocale;
+    }
+  });
+  var detectDomainLocale = function() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0;_key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    if (process.env.__NEXT_I18N_SUPPORT) {
+      return require_detect_domain_locale().detectDomainLocale(...args);
+    }
+  };
+  if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
+    Object.defineProperty(exports.default, "__esModule", { value: true });
+    Object.assign(exports.default, exports);
+    module.exports = exports.default;
+  }
+});
+
+// ../../node_modules/next/dist/client/get-domain-locale.js
+var require_get_domain_locale = __commonJS((exports, module) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  Object.defineProperty(exports, "getDomainLocale", {
+    enumerable: true,
+    get: function() {
+      return getDomainLocale;
+    }
+  });
+  var _normalizetrailingslash = require_normalize_trailing_slash();
+  var basePath = process.env.__NEXT_ROUTER_BASEPATH || "";
+  function getDomainLocale(path, locale, locales, domainLocales) {
+    if (process.env.__NEXT_I18N_SUPPORT) {
+      const normalizeLocalePath = require_normalize_locale_path2().normalizeLocalePath;
+      const detectDomainLocale = require_detect_domain_locale2().detectDomainLocale;
+      const target = locale || normalizeLocalePath(path, locales).detectedLocale;
+      const domain = detectDomainLocale(domainLocales, undefined, target);
+      if (domain) {
+        const proto = "http" + (domain.http ? "" : "s") + "://";
+        const finalLocale = target === domain.defaultLocale ? "" : "/" + target;
+        return "" + proto + domain.domain + (0, _normalizetrailingslash.normalizePathTrailingSlash)("" + basePath + finalLocale + path);
+      }
+      return false;
+    } else {
+      return false;
+    }
+  }
+  if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
+    Object.defineProperty(exports.default, "__esModule", { value: true });
+    Object.assign(exports.default, exports);
+    module.exports = exports.default;
+  }
+});
+
+// ../../node_modules/next/dist/client/add-base-path.js
+var require_add_base_path = __commonJS((exports, module) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  Object.defineProperty(exports, "addBasePath", {
+    enumerable: true,
+    get: function() {
+      return addBasePath;
+    }
+  });
+  var _addpathprefix = require_add_path_prefix();
+  var _normalizetrailingslash = require_normalize_trailing_slash();
+  var basePath = process.env.__NEXT_ROUTER_BASEPATH || "";
+  function addBasePath(path, required) {
+    return (0, _normalizetrailingslash.normalizePathTrailingSlash)(process.env.__NEXT_MANUAL_CLIENT_BASE_PATH && !required ? path : (0, _addpathprefix.addPathPrefix)(path, basePath));
+  }
+  if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
+    Object.defineProperty(exports.default, "__esModule", { value: true });
+    Object.assign(exports.default, exports);
+    module.exports = exports.default;
+  }
+});
+
+// ../../node_modules/next/dist/client/use-merged-ref.js
+import * as _react2 from "react";
+var require_use_merged_ref = __commonJS((exports, module) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  Object.defineProperty(exports, "useMergedRef", {
+    enumerable: true,
+    get: function() {
+      return useMergedRef;
+    }
+  });
+  function useMergedRef(refA, refB) {
+    const cleanupA = (0, _react2.useRef)(null);
+    const cleanupB = (0, _react2.useRef)(null);
+    return (0, _react2.useCallback)((current) => {
+      if (current === null) {
+        const cleanupFnA = cleanupA.current;
+        if (cleanupFnA) {
+          cleanupA.current = null;
+          cleanupFnA();
+        }
+        const cleanupFnB = cleanupB.current;
+        if (cleanupFnB) {
+          cleanupB.current = null;
+          cleanupFnB();
+        }
+      } else {
+        if (refA) {
+          cleanupA.current = applyRef(refA, current);
+        }
+        if (refB) {
+          cleanupB.current = applyRef(refB, current);
+        }
+      }
+    }, [
+      refA,
+      refB
+    ]);
+  }
+  function applyRef(refA, current) {
+    if (typeof refA === "function") {
+      const cleanup = refA(current);
+      if (typeof cleanup === "function") {
+        return cleanup;
+      } else {
+        return () => refA(null);
+      }
+    } else {
+      refA.current = current;
+      return () => {
+        refA.current = null;
+      };
+    }
+  }
+  if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
+    Object.defineProperty(exports.default, "__esModule", { value: true });
+    Object.assign(exports.default, exports);
+    module.exports = exports.default;
+  }
+});
+
+// ../../node_modules/next/dist/shared/lib/utils/error-once.js
+var require_error_once = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  Object.defineProperty(exports, "errorOnce", {
+    enumerable: true,
+    get: function() {
+      return errorOnce;
+    }
+  });
+  var errorOnce = (_) => {};
+  if (false) {}
+});
+
+// ../../node_modules/next/dist/client/link.js
+import * as _jsxruntime from "react/jsx-runtime";
+import * as react2 from "react";
+var require_link = __commonJS((exports, module) => {
+  
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  function _export(target, all) {
+    for (var name in all)
+      Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+  }
+  _export(exports, {
+    default: function() {
+      return _default;
+    },
+    useLinkStatus: function() {
+      return useLinkStatus;
+    }
+  });
+  var _interop_require_wildcard = require__interop_require_wildcard();
+  var _react3 = /* @__PURE__ */ _interop_require_wildcard._(react2);
+  var _resolvehref = require_resolve_href();
+  var _islocalurl = require_is_local_url();
+  var _formaturl = require_format_url();
+  var _utils = require_utils();
+  var _addlocale = require_add_locale2();
+  var _routercontextsharedruntime = require_router_context_shared_runtime();
+  var _useintersection = require_use_intersection();
+  var _getdomainlocale = require_get_domain_locale();
+  var _addbasepath = require_add_base_path();
+  var _usemergedref = require_use_merged_ref();
+  var _erroronce = require_error_once();
+  var prefetched = new Set;
+  function prefetch(router, href, as, options) {
+    if (typeof window === "undefined") {
+      return;
+    }
+    if (!(0, _islocalurl.isLocalURL)(href)) {
+      return;
+    }
+    if (!options.bypassPrefetchedCheck) {
+      const locale = typeof options.locale !== "undefined" ? options.locale : ("locale" in router) ? router.locale : undefined;
+      const prefetchedKey = href + "%" + as + "%" + locale;
+      if (prefetched.has(prefetchedKey)) {
+        return;
+      }
+      prefetched.add(prefetchedKey);
+    }
+    router.prefetch(href, as, options).catch((err) => {
+      if (false) {}
+    });
+  }
+  function isModifiedEvent(event) {
+    const eventTarget = event.currentTarget;
+    const target = eventTarget.getAttribute("target");
+    return target && target !== "_self" || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey || event.nativeEvent && event.nativeEvent.which === 2;
+  }
+  function linkClicked(e, router, href, as, replace, shallow, scroll, locale, onNavigate) {
+    const { nodeName } = e.currentTarget;
+    const isAnchorNodeName = nodeName.toUpperCase() === "A";
+    if (isAnchorNodeName && isModifiedEvent(e) || e.currentTarget.hasAttribute("download")) {
+      return;
+    }
+    if (!(0, _islocalurl.isLocalURL)(href)) {
+      if (replace) {
+        e.preventDefault();
+        location.replace(href);
+      }
+      return;
+    }
+    e.preventDefault();
+    const navigate = () => {
+      if (onNavigate) {
+        let isDefaultPrevented = false;
+        onNavigate({
+          preventDefault: () => {
+            isDefaultPrevented = true;
+          }
+        });
+        if (isDefaultPrevented) {
+          return;
+        }
+      }
+      const routerScroll = scroll != null ? scroll : true;
+      if ("beforePopState" in router) {
+        router[replace ? "replace" : "push"](href, as, {
+          shallow,
+          locale,
+          scroll: routerScroll
+        });
+      } else {
+        router[replace ? "replace" : "push"](as || href, {
+          scroll: routerScroll
+        });
+      }
+    };
+    navigate();
+  }
+  function formatStringOrUrl(urlObjOrString) {
+    if (typeof urlObjOrString === "string") {
+      return urlObjOrString;
+    }
+    return (0, _formaturl.formatUrl)(urlObjOrString);
+  }
+  var Link = /* @__PURE__ */ _react3.default.forwardRef(function LinkComponent(props, forwardedRef) {
+    let children;
+    const { href: hrefProp, as: asProp, children: childrenProp, prefetch: prefetchProp = null, passHref, replace, shallow, scroll, locale, onClick, onNavigate, onMouseEnter: onMouseEnterProp, onTouchStart: onTouchStartProp, legacyBehavior = false, ...restProps } = props;
+    children = childrenProp;
+    if (legacyBehavior && (typeof children === "string" || typeof children === "number")) {
+      children = /* @__PURE__ */ (0, _jsxruntime.jsx)("a", {
+        children
+      });
+    }
+    const router = _react3.default.useContext(_routercontextsharedruntime.RouterContext);
+    const prefetchEnabled = prefetchProp !== false;
+    if (false) {
+      let createPropError = function(args) {};
+    }
+    const { href, as } = _react3.default.useMemo(() => {
+      if (!router) {
+        const resolvedHref2 = formatStringOrUrl(hrefProp);
+        return {
+          href: resolvedHref2,
+          as: asProp ? formatStringOrUrl(asProp) : resolvedHref2
+        };
+      }
+      const [resolvedHref, resolvedAs] = (0, _resolvehref.resolveHref)(router, hrefProp, true);
+      return {
+        href: resolvedHref,
+        as: asProp ? (0, _resolvehref.resolveHref)(router, asProp) : resolvedAs || resolvedHref
+      };
+    }, [
+      router,
+      hrefProp,
+      asProp
+    ]);
+    const previousHref = _react3.default.useRef(href);
+    const previousAs = _react3.default.useRef(as);
+    let child;
+    if (legacyBehavior) {
+      if (false) {} else {
+        child = _react3.default.Children.only(children);
+      }
+    } else {
+      if (false) {}
+    }
+    const childRef = legacyBehavior ? child && typeof child === "object" && child.ref : forwardedRef;
+    const [setIntersectionRef, isVisible, resetVisible] = (0, _useintersection.useIntersection)({
+      rootMargin: "200px"
+    });
+    const setIntersectionWithResetRef = _react3.default.useCallback((el) => {
+      if (previousAs.current !== as || previousHref.current !== href) {
+        resetVisible();
+        previousAs.current = as;
+        previousHref.current = href;
+      }
+      setIntersectionRef(el);
+    }, [
+      as,
+      href,
+      resetVisible,
+      setIntersectionRef
+    ]);
+    const setRef = (0, _usemergedref.useMergedRef)(setIntersectionWithResetRef, childRef);
+    _react3.default.useEffect(() => {
+      if (false) {}
+      if (!router) {
+        return;
+      }
+      if (!isVisible || !prefetchEnabled) {
+        return;
+      }
+      prefetch(router, href, as, {
+        locale
+      });
+    }, [
+      as,
+      href,
+      isVisible,
+      locale,
+      prefetchEnabled,
+      router == null ? undefined : router.locale,
+      router
+    ]);
+    const childProps = {
+      ref: setRef,
+      onClick(e) {
+        if (false) {}
+        if (!legacyBehavior && typeof onClick === "function") {
+          onClick(e);
+        }
+        if (legacyBehavior && child.props && typeof child.props.onClick === "function") {
+          child.props.onClick(e);
+        }
+        if (!router) {
+          return;
+        }
+        if (e.defaultPrevented) {
+          return;
+        }
+        linkClicked(e, router, href, as, replace, shallow, scroll, locale, onNavigate);
+      },
+      onMouseEnter(e) {
+        if (!legacyBehavior && typeof onMouseEnterProp === "function") {
+          onMouseEnterProp(e);
+        }
+        if (legacyBehavior && child.props && typeof child.props.onMouseEnter === "function") {
+          child.props.onMouseEnter(e);
+        }
+        if (!router) {
+          return;
+        }
+        prefetch(router, href, as, {
+          locale,
+          priority: true,
+          bypassPrefetchedCheck: true
+        });
+      },
+      onTouchStart: process.env.__NEXT_LINK_NO_TOUCH_START ? undefined : function onTouchStart(e) {
+        if (!legacyBehavior && typeof onTouchStartProp === "function") {
+          onTouchStartProp(e);
+        }
+        if (legacyBehavior && child.props && typeof child.props.onTouchStart === "function") {
+          child.props.onTouchStart(e);
+        }
+        if (!router) {
+          return;
+        }
+        prefetch(router, href, as, {
+          locale,
+          priority: true,
+          bypassPrefetchedCheck: true
+        });
+      }
+    };
+    if ((0, _utils.isAbsoluteUrl)(as)) {
+      childProps.href = as;
+    } else if (!legacyBehavior || passHref || child.type === "a" && !("href" in child.props)) {
+      const curLocale = typeof locale !== "undefined" ? locale : router == null ? undefined : router.locale;
+      const localeDomain = (router == null ? undefined : router.isLocaleDomain) && (0, _getdomainlocale.getDomainLocale)(as, curLocale, router == null ? undefined : router.locales, router == null ? undefined : router.domainLocales);
+      childProps.href = localeDomain || (0, _addbasepath.addBasePath)((0, _addlocale.addLocale)(as, curLocale, router == null ? undefined : router.defaultLocale));
+    }
+    if (legacyBehavior) {
+      if (false) {}
+      return /* @__PURE__ */ _react3.default.cloneElement(child, childProps);
+    }
+    return /* @__PURE__ */ (0, _jsxruntime.jsx)("a", {
+      ...restProps,
+      ...childProps,
+      children
+    });
+  });
+  var LinkStatusContext = /* @__PURE__ */ (0, _react3.createContext)({
+    pending: false
+  });
+  var useLinkStatus = () => {
+    return (0, _react3.useContext)(LinkStatusContext);
+  };
+  var _default = Link;
+  if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
+    Object.defineProperty(exports.default, "__esModule", { value: true });
+    Object.assign(exports.default, exports);
+    module.exports = exports.default;
+  }
+});
+// src/components/styled/index.ts
+import {
+  CodeTabs,
+  ImportSection
+} from "@openpkg-ts/ui/api";
+
+// src/components/styled/sections/ClassSection.tsx
+import { APIParameterItem, APISection, ParameterList } from "@openpkg-ts/ui/docskit";
+
+// src/adapters/spec-to-docskit.ts
+import { formatSchema } from "@openpkg-ts/sdk";
+function specSchemaToAPISchema(schema) {
+  if (!schema || typeof schema !== "object")
+    return;
+  const s = schema;
+  const result = {};
+  result.type = formatSchema(schema);
+  result.typeString = result.type;
+  if (typeof s.description === "string") {
+    result.description = s.description;
+  }
+  if (s.type === "object" && s.properties && typeof s.properties === "object") {
+    result.properties = {};
+    for (const [key, value] of Object.entries(s.properties)) {
+      const nestedSchema = specSchemaToAPISchema(value);
+      if (nestedSchema) {
+        result.properties[key] = nestedSchema;
+      }
+    }
+    if (Array.isArray(s.required)) {
+      result.required = s.required;
+    }
+  }
+  return result;
+}
+function specParamToAPIParam(param) {
+  const type = formatSchema(param.schema);
+  const children = specSchemaToAPISchema(param.schema);
+  const hasNestedProperties = children?.properties && Object.keys(children.properties).length > 0;
+  return {
+    name: param.name ?? "unknown",
+    type,
+    required: param.required !== false,
+    description: param.description,
+    children: hasNestedProperties ? children : undefined
+  };
+}
+function specExamplesToCodeExamples(examples, defaultLang = "typescript") {
+  if (!examples?.length)
+    return [];
+  return examples.map((example) => {
+    if (typeof example === "string") {
+      return {
+        languageId: defaultLang,
+        code: example,
+        highlightLang: getLangForHighlight(defaultLang)
+      };
+    }
+    return {
+      languageId: example.language || defaultLang,
+      code: example.code,
+      highlightLang: getLangForHighlight(example.language || defaultLang)
+    };
+  });
+}
+function getLangForHighlight(lang) {
+  const langMap = {
+    typescript: "ts",
+    javascript: "js",
+    ts: "ts",
+    js: "js",
+    tsx: "tsx",
+    jsx: "jsx",
+    bash: "bash",
+    shell: "bash",
+    sh: "bash",
+    curl: "bash",
+    json: "json",
+    python: "python",
+    py: "python",
+    go: "go",
+    rust: "rust",
+    ruby: "ruby"
+  };
+  return langMap[lang.toLowerCase()] || lang;
+}
+function getLanguagesFromExamples(examples) {
+  if (!examples?.length)
+    return [];
+  const langSet = new Set;
+  const languages = [];
+  for (const example of examples) {
+    const lang = typeof example === "string" ? "typescript" : example.language || "typescript";
+    if (!langSet.has(lang)) {
+      langSet.add(lang);
+      languages.push({
+        id: lang,
+        label: getLanguageLabel(lang)
+      });
+    }
+  }
+  return languages;
+}
+function getLanguageLabel(lang) {
+  const labels = {
+    typescript: "TypeScript",
+    javascript: "JavaScript",
+    ts: "TypeScript",
+    js: "JavaScript",
+    tsx: "TSX",
+    jsx: "JSX",
+    bash: "Bash",
+    shell: "Shell",
+    sh: "Shell",
+    curl: "cURL",
+    json: "JSON",
+    python: "Python",
+    py: "Python",
+    go: "Go",
+    rust: "Rust",
+    ruby: "Ruby",
+    node: "Node.js"
+  };
+  return labels[lang.toLowerCase()] || lang;
+}
+function buildImportStatement(exp, spec) {
+  const packageName = spec.meta?.name || "package";
+  const presentation = spec.extensions?.presentation?.[exp.id];
+  const importPath = presentation?.importPath || packageName;
+  const alias = presentation?.alias || exp.name;
+  if (exp.kind === "type" || exp.kind === "interface") {
+    return `import type { ${alias} } from '${importPath}'`;
+  }
+  return `import { ${alias} } from '${importPath}'`;
+}
+
+// src/components/styled/sections/ClassSection.tsx
+import { formatSchema as formatSchema2 } from "@openpkg-ts/sdk";
+import { jsx, jsxs } from "react/jsx-runtime";
+
+function formatMethodSignature(member) {
+  const sig = member.signatures?.[0];
+  const params = sig?.parameters ?? [];
+  const returnType = formatSchema2(sig?.returns?.schema);
+  const paramStr = params.map((p) => `${p.name}${p.required === false ? "?" : ""}: ${formatSchema2(p.schema)}`).join(", ");
+  return `(${paramStr}): ${returnType}`;
+}
+function getMemberBadges(member) {
+  const badges = [];
+  const flags = member.flags;
+  if (member.visibility && member.visibility !== "public") {
+    badges.push(member.visibility);
+  }
+  if (flags?.static)
+    badges.push("static");
+  if (flags?.readonly)
+    badges.push("readonly");
+  if (flags?.async)
+    badges.push("async");
+  if (flags?.abstract)
+    badges.push("abstract");
+  return badges;
+}
+function formatDecorators(decorators) {
+  if (!decorators?.length)
+    return "";
+  return decorators.map((d) => {
+    const args = d.argumentsText?.length ? `(${d.argumentsText.join(", ")})` : "";
+    return `@${d.name}${args}`;
+  }).join(" ");
+}
+function buildMemberDescription(member) {
+  const parts = [];
+  const decoratorsStr = formatDecorators(member.decorators);
+  if (decoratorsStr)
+    parts.push(decoratorsStr);
+  if ("inheritedFrom" in member && member.inheritedFrom) {
+    parts.push(`Inherited from ${member.inheritedFrom}`);
+  }
+  if (member.description)
+    parts.push(member.description);
+  return parts.length > 0 ? parts.join(" • ") : undefined;
+}
+function ClassSection({ export: exp, spec }) {
+  const constructors = exp.members?.filter((m) => m.kind === "constructor") ?? [];
+  const properties = exp.members?.filter((m) => m.kind === "property" || m.kind === "field") ?? [];
+  const methods = exp.members?.filter((m) => m.kind === "method") ?? [];
+  const staticProperties = properties.filter((m) => m.flags?.static);
+  const instanceProperties = properties.filter((m) => !m.flags?.static);
+  const staticMethods = methods.filter((m) => m.flags?.static);
+  const instanceMethods = methods.filter((m) => !m.flags?.static);
+  const constructorSig = constructors[0]?.signatures?.[0];
+  const constructorParams = constructorSig?.parameters ?? [];
+  const languages = getLanguagesFromExamples(exp.examples);
+  const examples = specExamplesToCodeExamples(exp.examples);
+  const importStatement = buildImportStatement(exp, spec);
+  const displayExamples = examples.length > 0 ? examples : [
+    {
+      languageId: "typescript",
+      code: `${importStatement}
+
+const instance = new ${exp.name}(${constructorParams.map((p) => p.name).join(", ")});`,
+      highlightLang: "ts"
+    }
+  ];
+  const displayLanguages = languages.length > 0 ? languages : [{ id: "typescript", label: "TypeScript" }];
+  const inheritance = [
+    exp.extends && `extends ${exp.extends}`,
+    exp.implements?.length && `implements ${exp.implements.join(", ")}`
+  ].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsxs(APISection, {
+    id: exp.id || exp.name,
+    title: `class ${exp.name}`,
+    description: /* @__PURE__ */ jsxs("div", {
+      className: "space-y-3",
+      children: [
+        inheritance && /* @__PURE__ */ jsx("p", {
+          className: "font-mono text-sm text-muted-foreground",
+          children: inheritance
+        }),
+        exp.description && /* @__PURE__ */ jsx("p", {
+          children: exp.description
+        }),
+        /* @__PURE__ */ jsx("code", {
+          className: "text-sm font-mono bg-muted px-2 py-1 rounded inline-block",
+          children: importStatement
+        })
+      ]
+    }),
+    languages: displayLanguages,
+    examples: displayExamples,
+    codePanelTitle: `new ${exp.name}()`,
+    children: [
+      constructorParams.length > 0 && /* @__PURE__ */ jsx(ParameterList, {
+        title: "Constructor",
+        children: constructorParams.map((param, index) => {
+          const apiParam = specParamToAPIParam(param);
+          return /* @__PURE__ */ jsx(APIParameterItem, {
+            name: apiParam.name,
+            type: apiParam.type,
+            required: apiParam.required,
+            description: apiParam.description,
+            children: apiParam.children
+          }, param.name ?? index);
+        })
+      }),
+      (staticProperties.length > 0 || staticMethods.length > 0) && /* @__PURE__ */ jsxs(ParameterList, {
+        title: "Static Members",
+        className: "mt-6",
+        children: [
+          staticProperties.map((member) => {
+            const badges = getMemberBadges(member);
+            const desc = buildMemberDescription(member);
+            return /* @__PURE__ */ jsx(APIParameterItem, {
+              name: member.name,
+              type: formatSchema2(member.schema),
+              description: badges.length > 0 ? `[${badges.join(", ")}] ${desc || ""}` : desc
+            }, member.name);
+          }),
+          staticMethods.map((member) => {
+            const badges = getMemberBadges(member);
+            const desc = buildMemberDescription(member);
+            return /* @__PURE__ */ jsx(APIParameterItem, {
+              name: `${member.name}()`,
+              type: formatMethodSignature(member),
+              description: badges.length > 0 ? `[${badges.join(", ")}] ${desc || ""}` : desc
+            }, member.name);
+          })
+        ]
+      }),
+      instanceMethods.length > 0 && /* @__PURE__ */ jsx(ParameterList, {
+        title: "Methods",
+        className: "mt-6",
+        children: instanceMethods.map((member) => {
+          const badges = getMemberBadges(member);
+          const desc = buildMemberDescription(member);
+          return /* @__PURE__ */ jsx(APIParameterItem, {
+            name: `${member.name}()`,
+            type: formatMethodSignature(member),
+            description: badges.length > 0 ? `[${badges.join(", ")}] ${desc || ""}` : desc
+          }, member.name);
+        })
+      }),
+      instanceProperties.length > 0 && /* @__PURE__ */ jsx(ParameterList, {
+        title: "Properties",
+        className: "mt-6",
+        children: instanceProperties.map((member) => {
+          const badges = getMemberBadges(member);
+          const desc = buildMemberDescription(member);
+          return /* @__PURE__ */ jsx(APIParameterItem, {
+            name: member.name,
+            type: formatSchema2(member.schema),
+            description: badges.length > 0 ? `[${badges.join(", ")}] ${desc || ""}` : desc
+          }, member.name);
+        })
+      })
+    ]
+  });
+}
+
+// src/components/styled/ClassPage.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+
+function ClassPage({ export: exp, spec }) {
+  return /* @__PURE__ */ jsx2("div", {
+    className: "doccov-class-page not-prose",
+    children: /* @__PURE__ */ jsx2(ClassSection, {
+      export: exp,
+      spec
+    })
+  });
+}
+
+// src/components/styled/sections/EnumSection.tsx
+import { APIParameterItem as APIParameterItem2, APISection as APISection2, ParameterList as ParameterList2 } from "@openpkg-ts/ui/docskit";
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+
+function EnumSection({ export: exp, spec }) {
+  const members = exp.members ?? [];
+  const languages = getLanguagesFromExamples(exp.examples);
+  const examples = specExamplesToCodeExamples(exp.examples);
+  const importStatement = buildImportStatement(exp, spec);
+  const enumDefinition = members.length > 0 ? `enum ${exp.name} {
+${members.map((m) => {
+    const value = m.schema !== undefined ? typeof m.schema === "object" && m.schema !== null ? m.schema.const ?? m.schema.default : m.schema : undefined;
+    return `  ${m.name}${value !== undefined ? ` = ${JSON.stringify(value)}` : ""},`;
+  }).join(`
+`)}
+}` : `enum ${exp.name} { }`;
+  const displayExamples = examples.length > 0 ? examples : [
+    {
+      languageId: "typescript",
+      code: `${importStatement}
+
+${enumDefinition}`,
+      highlightLang: "ts"
+    }
+  ];
+  const displayLanguages = languages.length > 0 ? languages : [{ id: "typescript", label: "TypeScript" }];
+  return /* @__PURE__ */ jsx3(APISection2, {
+    id: exp.id || exp.name,
+    title: `enum ${exp.name}`,
+    description: /* @__PURE__ */ jsxs2("div", {
+      className: "space-y-3",
+      children: [
+        exp.description && /* @__PURE__ */ jsx3("p", {
+          children: exp.description
+        }),
+        exp.deprecated && /* @__PURE__ */ jsxs2("div", {
+          className: "rounded-md bg-yellow-500/10 border border-yellow-500/20 px-3 py-2 text-sm text-yellow-600 dark:text-yellow-400",
+          children: [
+            /* @__PURE__ */ jsx3("strong", {
+              children: "Deprecated:"
+            }),
+            " This export is deprecated."
+          ]
+        }),
+        /* @__PURE__ */ jsx3("code", {
+          className: "text-sm font-mono bg-muted px-2 py-1 rounded inline-block",
+          children: importStatement
+        })
+      ]
+    }),
+    languages: displayLanguages,
+    examples: displayExamples,
+    codePanelTitle: exp.name,
+    children: members.length > 0 && /* @__PURE__ */ jsx3(ParameterList2, {
+      title: "Members",
+      children: members.map((member, index) => {
+        const value = member.schema !== undefined ? typeof member.schema === "object" && member.schema !== null ? member.schema.const ?? member.schema.default ?? undefined : member.schema : undefined;
+        return /* @__PURE__ */ jsx3(APIParameterItem2, {
+          name: member.name,
+          type: value !== undefined ? String(value) : "auto",
+          description: member.description
+        }, member.name ?? index);
+      })
+    })
+  });
+}
+
+// src/components/styled/EnumPage.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+
+function EnumPage({ export: exp, spec }) {
+  return /* @__PURE__ */ jsx4("div", {
+    className: "doccov-enum-page not-prose",
+    children: /* @__PURE__ */ jsx4(EnumSection, {
+      export: exp,
+      spec
+    })
+  });
+}
+
+// src/components/styled/ExportIndexPage.tsx
+import { cn as cn2 } from "@openpkg-ts/ui/lib/utils";
+import { Search } from "lucide-react";
+import { useMemo, useState } from "react";
+
+// src/components/styled/ExportCard.tsx
+var import_link = __toESM(require_link(), 1);
+import { cn } from "@openpkg-ts/ui/lib/utils";
+import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+
+var KIND_COLORS = {
+  function: "group-hover:text-blue-600 dark:group-hover:text-blue-400",
+  class: "group-hover:text-purple-600 dark:group-hover:text-purple-400",
+  interface: "group-hover:text-green-600 dark:group-hover:text-green-400",
+  type: "group-hover:text-amber-600 dark:group-hover:text-amber-400",
+  enum: "group-hover:text-rose-600 dark:group-hover:text-rose-400",
+  variable: "group-hover:text-cyan-600 dark:group-hover:text-cyan-400"
+};
+var KIND_BADGE_COLORS = {
+  function: "bg-blue-500/10 text-blue-600 dark:text-blue-400",
+  class: "bg-purple-500/10 text-purple-600 dark:text-purple-400",
+  interface: "bg-green-500/10 text-green-600 dark:text-green-400",
+  type: "bg-amber-500/10 text-amber-600 dark:text-amber-400",
+  enum: "bg-rose-500/10 text-rose-600 dark:text-rose-400",
+  variable: "bg-cyan-500/10 text-cyan-600 dark:text-cyan-400"
+};
+function ExportCard({
+  name,
+  description,
+  href,
+  kind = "function",
+  className
+}) {
+  const isFunction = kind === "function";
+  const hoverColor = KIND_COLORS[kind];
+  const badgeColor = KIND_BADGE_COLORS[kind];
+  return /* @__PURE__ */ jsxs3(import_link.default, {
+    href,
+    className: cn("group block rounded-lg border border-border bg-card/50 p-4", "transition-all duration-200 ease-out", "hover:border-primary/30 hover:bg-card hover:shadow-lg hover:shadow-primary/5", "hover:-translate-y-1", "focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring", className),
+    children: [
+      /* @__PURE__ */ jsxs3("div", {
+        className: "flex items-center gap-2 mb-2",
+        children: [
+          /* @__PURE__ */ jsx5("span", {
+            className: cn("font-mono text-base font-medium text-foreground transition-colors duration-200", hoverColor),
+            children: name
+          }),
+          isFunction && /* @__PURE__ */ jsx5("span", {
+            className: "font-mono text-base text-muted-foreground",
+            children: "()"
+          }),
+          /* @__PURE__ */ jsx5("span", {
+            className: cn("ml-auto text-xs px-2 py-0.5 rounded-full font-medium", badgeColor),
+            children: kind
+          })
+        ]
+      }),
+      description && /* @__PURE__ */ jsx5("p", {
+        className: "text-sm text-muted-foreground line-clamp-2 leading-relaxed group-hover:text-muted-foreground/80 transition-colors",
+        children: description
+      })
+    ]
+  });
+}
+
+// src/components/styled/ExportIndexPage.tsx
+import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+
+var KIND_ORDER = ["function", "class", "interface", "type", "enum", "variable"];
+var KIND_LABELS = {
+  function: "Functions",
+  class: "Classes",
+  interface: "Interfaces",
+  type: "Types",
+  enum: "Enums",
+  variable: "Variables"
+};
+var KIND_SLUGS = {
+  function: "functions",
+  class: "classes",
+  interface: "interfaces",
+  type: "types",
+  enum: "enums",
+  variable: "variables"
+};
+function groupByKind(exports) {
+  const groups = new Map;
+  for (const exp of exports) {
+    const kind = exp.kind || "variable";
+    const normalizedKind = KIND_ORDER.includes(kind) ? kind : "variable";
+    const list = groups.get(normalizedKind) || [];
+    list.push(exp);
+    groups.set(normalizedKind, list);
+  }
+  return KIND_ORDER.filter((kind) => groups.has(kind)).map((kind) => ({
+    kind,
+    label: KIND_LABELS[kind],
+    exports: groups.get(kind).sort((a, b) => a.name.localeCompare(b.name))
+  }));
+}
+function ExportIndexPage({
+  spec,
+  baseHref,
+  description,
+  className,
+  showSearch = true,
+  showFilters = true
+}) {
+  const [searchQuery, setSearchQuery] = useState("");
+  const [activeFilter, setActiveFilter] = useState("all");
+  if (false) {}
+  const allGroups = useMemo(() => groupByKind(spec.exports), [spec.exports]);
+  const filteredGroups = useMemo(() => {
+    const query = searchQuery.toLowerCase().trim();
+    return allGroups.filter((group) => activeFilter === "all" || group.kind === activeFilter).map((group) => ({
+      ...group,
+      exports: group.exports.filter((exp) => {
+        if (!query)
+          return true;
+        return exp.name.toLowerCase().includes(query) || exp.description?.toLowerCase().includes(query);
+      })
+    })).filter((group) => group.exports.length > 0);
+  }, [allGroups, searchQuery, activeFilter]);
+  const availableKinds = useMemo(() => allGroups.map((g) => g.kind), [allGroups]);
+  const totalExports = filteredGroups.reduce((sum, g) => sum + g.exports.length, 0);
+  return /* @__PURE__ */ jsxs4("div", {
+    className: cn2("doccov-index-page space-y-8 not-prose", className),
+    children: [
+      /* @__PURE__ */ jsxs4("div", {
+        children: [
+          /* @__PURE__ */ jsx6("h1", {
+            className: "text-3xl font-bold text-foreground mb-3",
+            children: spec.meta.name || "API Reference"
+          }),
+          (description || spec.meta.description) && /* @__PURE__ */ jsx6("p", {
+            className: "text-muted-foreground text-lg leading-relaxed max-w-3xl",
+            children: description || spec.meta.description
+          })
+        ]
+      }),
+      (showSearch || showFilters) && /* @__PURE__ */ jsxs4("div", {
+        className: "space-y-4",
+        children: [
+          showSearch && /* @__PURE__ */ jsxs4("div", {
+            className: "relative max-w-md",
+            children: [
+              /* @__PURE__ */ jsx6(Search, {
+                size: 18,
+                className: "absolute left-3 top-1/2 -translate-y-1/2 text-muted-foreground"
+              }),
+              /* @__PURE__ */ jsx6("input", {
+                type: "text",
+                placeholder: "Search exports...",
+                value: searchQuery,
+                onChange: (e) => setSearchQuery(e.target.value),
+                className: cn2("w-full pl-10 pr-4 py-2 rounded-lg", "border border-border bg-background", "text-sm text-foreground placeholder:text-muted-foreground", "focus:outline-none focus:ring-2 focus:ring-ring focus:border-transparent", "transition-shadow")
+              })
+            ]
+          }),
+          showFilters && availableKinds.length > 1 && /* @__PURE__ */ jsxs4("div", {
+            className: "flex flex-wrap gap-2",
+            children: [
+              /* @__PURE__ */ jsx6("button", {
+                type: "button",
+                onClick: () => setActiveFilter("all"),
+                className: cn2("px-3 py-1.5 text-sm rounded-md transition-all cursor-pointer", activeFilter === "all" ? "bg-primary text-primary-foreground font-medium" : "bg-muted text-muted-foreground hover:bg-muted/80 hover:text-foreground"),
+                children: "All"
+              }),
+              availableKinds.map((kind) => /* @__PURE__ */ jsx6("button", {
+                type: "button",
+                onClick: () => setActiveFilter(kind),
+                className: cn2("px-3 py-1.5 text-sm rounded-md transition-all cursor-pointer", activeFilter === kind ? "bg-primary text-primary-foreground font-medium" : "bg-muted text-muted-foreground hover:bg-muted/80 hover:text-foreground"),
+                children: KIND_LABELS[kind]
+              }, kind))
+            ]
+          })
+        ]
+      }),
+      (searchQuery || activeFilter !== "all") && /* @__PURE__ */ jsxs4("p", {
+        className: "text-sm text-muted-foreground",
+        children: [
+          totalExports,
+          " ",
+          totalExports === 1 ? "result" : "results",
+          searchQuery && ` for "${searchQuery}"`
+        ]
+      }),
+      filteredGroups.map((group) => /* @__PURE__ */ jsxs4("section", {
+        children: [
+          /* @__PURE__ */ jsx6("h2", {
+            className: "text-sm font-semibold uppercase tracking-wide text-muted-foreground mb-4",
+            children: group.label
+          }),
+          /* @__PURE__ */ jsx6("div", {
+            className: "grid grid-cols-1 md:grid-cols-2 gap-4",
+            children: group.exports.map((exp) => /* @__PURE__ */ jsx6(ExportCard, {
+              name: exp.name,
+              description: exp.description,
+              href: `${baseHref}/${KIND_SLUGS[group.kind]}/${exp.id}`,
+              kind: exp.kind
+            }, exp.id))
+          })
+        ]
+      }, group.kind)),
+      filteredGroups.length === 0 && /* @__PURE__ */ jsxs4("div", {
+        className: "rounded-lg border border-border bg-card/50 p-8 text-center",
+        children: [
+          /* @__PURE__ */ jsx6("p", {
+            className: "text-muted-foreground",
+            children: searchQuery || activeFilter !== "all" ? "No exports match your search." : "No exports found in this package."
+          }),
+          (searchQuery || activeFilter !== "all") && /* @__PURE__ */ jsx6("button", {
+            type: "button",
+            onClick: () => {
+              setSearchQuery("");
+              setActiveFilter("all");
+            },
+            className: "mt-3 text-sm text-primary hover:underline cursor-pointer",
+            children: "Clear filters"
+          })
+        ]
+      })
+    ]
+  });
+}
+
+// src/components/styled/sections/FunctionSection.tsx
+import { APIParameterItem as APIParameterItem3, APISection as APISection3, ParameterList as ParameterList3, ResponseBlock } from "@openpkg-ts/ui/docskit";
+import { formatSchema as formatSchema3 } from "@openpkg-ts/sdk";
+import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+
+function FunctionSection({ export: exp, spec }) {
+  const sig = exp.signatures?.[0];
+  const hasParams = sig?.parameters && sig.parameters.length > 0;
+  const languages = getLanguagesFromExamples(exp.examples);
+  const examples = specExamplesToCodeExamples(exp.examples);
+  const importStatement = buildImportStatement(exp, spec);
+  const displayExamples = examples.length > 0 ? examples : [
+    {
+      languageId: "typescript",
+      code: `${importStatement}
+
+// Usage
+${exp.name}(${sig?.parameters?.map((p) => p.name).join(", ") || ""})`,
+      highlightLang: "ts"
+    }
+  ];
+  const displayLanguages = languages.length > 0 ? languages : [{ id: "typescript", label: "TypeScript" }];
+  return /* @__PURE__ */ jsxs5(APISection3, {
+    id: exp.id || exp.name,
+    title: `${exp.name}()`,
+    description: /* @__PURE__ */ jsxs5("div", {
+      className: "space-y-3",
+      children: [
+        exp.description && /* @__PURE__ */ jsx7("p", {
+          children: exp.description
+        }),
+        /* @__PURE__ */ jsx7("code", {
+          className: "text-sm font-mono bg-muted px-2 py-1 rounded inline-block",
+          children: importStatement
+        })
+      ]
+    }),
+    languages: displayLanguages,
+    examples: displayExamples,
+    codePanelTitle: `${exp.name}()`,
+    children: [
+      hasParams && /* @__PURE__ */ jsx7(ParameterList3, {
+        title: "Parameters",
+        children: sig.parameters.map((param, index) => {
+          const apiParam = specParamToAPIParam(param);
+          return /* @__PURE__ */ jsx7(APIParameterItem3, {
+            name: apiParam.name,
+            type: apiParam.type,
+            required: apiParam.required,
+            description: apiParam.description,
+            children: apiParam.children
+          }, param.name ?? index);
+        })
+      }),
+      sig?.returns && /* @__PURE__ */ jsx7(ResponseBlock, {
+        description: /* @__PURE__ */ jsxs5("span", {
+          children: [
+            /* @__PURE__ */ jsx7("span", {
+              className: "font-mono text-sm font-medium",
+              children: formatSchema3(sig.returns.schema)
+            }),
+            sig.returns.description && /* @__PURE__ */ jsx7("span", {
+              className: "ml-2 text-muted-foreground",
+              children: sig.returns.description
+            })
+          ]
+        }),
+        className: "mt-6"
+      }),
+      sig?.throws && sig.throws.length > 0 && /* @__PURE__ */ jsxs5("div", {
+        className: "mt-6 rounded-md bg-destructive/10 border border-destructive/20 p-4",
+        children: [
+          /* @__PURE__ */ jsx7("h4", {
+            className: "text-xs font-semibold uppercase tracking-wide text-destructive mb-2",
+            children: "Throws"
+          }),
+          /* @__PURE__ */ jsx7("div", {
+            className: "space-y-1",
+            children: sig.throws.map((t, i) => /* @__PURE__ */ jsxs5("div", {
+              className: "text-sm",
+              children: [
+                t.type && /* @__PURE__ */ jsx7("code", {
+                  className: "font-mono text-destructive",
+                  children: t.type
+                }),
+                t.type && t.description && /* @__PURE__ */ jsx7("span", {
+                  className: "mx-1",
+                  children: "—"
+                }),
+                t.description && /* @__PURE__ */ jsx7("span", {
+                  className: "text-muted-foreground",
+                  children: t.description
+                })
+              ]
+            }, i))
+          })
+        ]
+      }),
+      exp.typeParameters && exp.typeParameters.length > 0 && /* @__PURE__ */ jsx7(ParameterList3, {
+        title: "Type Parameters",
+        className: "mt-6",
+        children: exp.typeParameters.map((tp) => /* @__PURE__ */ jsx7(APIParameterItem3, {
+          name: tp.name,
+          type: tp.constraint || "unknown",
+          description: tp.default ? `Default: ${tp.default}` : undefined
+        }, tp.name))
+      })
+    ]
+  });
+}
+
+// src/components/styled/FunctionPage.tsx
+import { jsx as jsx8 } from "react/jsx-runtime";
+
+function FunctionPage({ export: exp, spec }) {
+  return /* @__PURE__ */ jsx8("div", {
+    className: "doccov-function-page not-prose",
+    children: /* @__PURE__ */ jsx8(FunctionSection, {
+      export: exp,
+      spec
+    })
+  });
+}
+
+// src/components/styled/sections/InterfaceSection.tsx
+import { APIParameterItem as APIParameterItem4, APISection as APISection4, ParameterList as ParameterList4 } from "@openpkg-ts/ui/docskit";
+import { formatSchema as formatSchema4 } from "@openpkg-ts/sdk";
+import { jsx as jsx9, jsxs as jsxs6 } from "react/jsx-runtime";
+
+function formatMethodSignature2(member) {
+  const sig = member.signatures?.[0];
+  const params = sig?.parameters ?? [];
+  const returnType = formatSchema4(sig?.returns?.schema);
+  const paramStr = params.map((p) => `${p.name}${p.required === false ? "?" : ""}: ${formatSchema4(p.schema)}`).join(", ");
+  return `(${paramStr}): ${returnType}`;
+}
+function formatDecorators2(decorators) {
+  if (!decorators?.length)
+    return "";
+  return decorators.map((d) => {
+    const args = d.argumentsText?.length ? `(${d.argumentsText.join(", ")})` : "";
+    return `@${d.name}${args}`;
+  }).join(" ");
+}
+function buildMemberDescription2(member) {
+  const parts = [];
+  const decoratorsStr = formatDecorators2(member.decorators);
+  if (decoratorsStr)
+    parts.push(decoratorsStr);
+  if (member.description)
+    parts.push(member.description);
+  return parts.length > 0 ? parts.join(" • ") : undefined;
+}
+function InterfaceSection({ export: exp, spec }) {
+  const properties = exp.members?.filter((m) => m.kind === "property" || m.kind === "field" || !m.kind) ?? [];
+  const methods = exp.members?.filter((m) => m.kind === "method" || m.kind === "function") ?? [];
+  const languages = getLanguagesFromExamples(exp.examples);
+  const examples = specExamplesToCodeExamples(exp.examples);
+  const importStatement = buildImportStatement(exp, spec);
+  const typeDefinition = properties.length > 0 ? `${exp.kind === "type" ? "type" : "interface"} ${exp.name} {
+${properties.map((p) => `  ${p.name}${p.required === false ? "?" : ""}: ${formatSchema4(p.schema)};`).join(`
+`)}
+}` : `${exp.kind === "type" ? "type" : "interface"} ${exp.name} { }`;
+  const displayExamples = examples.length > 0 ? examples : [
+    {
+      languageId: "typescript",
+      code: `${importStatement}
+
+${typeDefinition}`,
+      highlightLang: "ts"
+    }
+  ];
+  const displayLanguages = languages.length > 0 ? languages : [{ id: "typescript", label: "TypeScript" }];
+  const kindLabel = exp.kind === "type" ? "type" : "interface";
+  return /* @__PURE__ */ jsxs6(APISection4, {
+    id: exp.id || exp.name,
+    title: `${kindLabel} ${exp.name}`,
+    description: /* @__PURE__ */ jsxs6("div", {
+      className: "space-y-3",
+      children: [
+        exp.extends && /* @__PURE__ */ jsxs6("p", {
+          className: "font-mono text-sm text-muted-foreground",
+          children: [
+            "extends ",
+            exp.extends
+          ]
+        }),
+        exp.description && /* @__PURE__ */ jsx9("p", {
+          children: exp.description
+        }),
+        exp.deprecated && /* @__PURE__ */ jsxs6("div", {
+          className: "rounded-md bg-yellow-500/10 border border-yellow-500/20 px-3 py-2 text-sm text-yellow-600 dark:text-yellow-400",
+          children: [
+            /* @__PURE__ */ jsx9("strong", {
+              children: "Deprecated:"
+            }),
+            " This export is deprecated."
+          ]
+        }),
+        /* @__PURE__ */ jsx9("code", {
+          className: "text-sm font-mono bg-muted px-2 py-1 rounded inline-block",
+          children: importStatement
+        })
+      ]
+    }),
+    languages: displayLanguages,
+    examples: displayExamples,
+    codePanelTitle: exp.name,
+    children: [
+      properties.length > 0 && /* @__PURE__ */ jsx9(ParameterList4, {
+        title: "Properties",
+        children: properties.map((prop, index) => {
+          const type = formatSchema4(prop.schema);
+          const children = specSchemaToAPISchema(prop.schema);
+          const hasNestedProperties = children?.properties && Object.keys(children.properties).length > 0;
+          return /* @__PURE__ */ jsx9(APIParameterItem4, {
+            name: prop.name,
+            type,
+            description: buildMemberDescription2(prop),
+            children: hasNestedProperties ? children : undefined
+          }, prop.name ?? index);
+        })
+      }),
+      methods.length > 0 && /* @__PURE__ */ jsx9(ParameterList4, {
+        title: "Methods",
+        className: "mt-6",
+        children: methods.map((method, index) => /* @__PURE__ */ jsx9(APIParameterItem4, {
+          name: `${method.name}()`,
+          type: formatMethodSignature2(method),
+          description: buildMemberDescription2(method)
+        }, method.name ?? index))
+      })
+    ]
+  });
+}
+
+// src/components/styled/InterfacePage.tsx
+import { jsx as jsx10 } from "react/jsx-runtime";
+
+function InterfacePage({ export: exp, spec }) {
+  return /* @__PURE__ */ jsx10("div", {
+    className: "doccov-interface-page not-prose",
+    children: /* @__PURE__ */ jsx10(InterfaceSection, {
+      export: exp,
+      spec
+    })
+  });
+}
+
+// src/components/styled/sections/VariableSection.tsx
+import { APIParameterItem as APIParameterItem5, APISection as APISection5, ParameterList as ParameterList5 } from "@openpkg-ts/ui/docskit";
+import { formatSchema as formatSchema5 } from "@openpkg-ts/sdk";
+import { jsx as jsx11, jsxs as jsxs7 } from "react/jsx-runtime";
+
+function VariableSection({ export: exp, spec }) {
+  const typeValue = typeof exp.type === "string" ? exp.type : formatSchema5(exp.schema);
+  const languages = getLanguagesFromExamples(exp.examples);
+  const examples = specExamplesToCodeExamples(exp.examples);
+  const importStatement = buildImportStatement(exp, spec);
+  const constValue = exp.schema && typeof exp.schema === "object" ? exp.schema.const : undefined;
+  const displayExamples = examples.length > 0 ? examples : [
+    {
+      languageId: "typescript",
+      code: `${importStatement}
+
+console.log(${exp.name}); // ${constValue !== undefined ? JSON.stringify(constValue) : typeValue}`,
+      highlightLang: "ts"
+    }
+  ];
+  const displayLanguages = languages.length > 0 ? languages : [{ id: "typescript", label: "TypeScript" }];
+  return /* @__PURE__ */ jsx11(APISection5, {
+    id: exp.id || exp.name,
+    title: `const ${exp.name}`,
+    description: /* @__PURE__ */ jsxs7("div", {
+      className: "space-y-3",
+      children: [
+        exp.description && /* @__PURE__ */ jsx11("p", {
+          children: exp.description
+        }),
+        exp.deprecated && /* @__PURE__ */ jsxs7("div", {
+          className: "rounded-md bg-yellow-500/10 border border-yellow-500/20 px-3 py-2 text-sm text-yellow-600 dark:text-yellow-400",
+          children: [
+            /* @__PURE__ */ jsx11("strong", {
+              children: "Deprecated:"
+            }),
+            " This export is deprecated."
+          ]
+        }),
+        /* @__PURE__ */ jsx11("code", {
+          className: "text-sm font-mono bg-muted px-2 py-1 rounded inline-block",
+          children: importStatement
+        })
+      ]
+    }),
+    languages: displayLanguages,
+    examples: displayExamples,
+    codePanelTitle: exp.name,
+    children: /* @__PURE__ */ jsx11(ParameterList5, {
+      title: "Type",
+      children: /* @__PURE__ */ jsx11(APIParameterItem5, {
+        name: exp.name,
+        type: typeValue,
+        description: constValue !== undefined ? `Value: ${JSON.stringify(constValue)}` : undefined
+      })
+    })
+  });
+}
+
+// src/components/styled/VariablePage.tsx
+import { jsx as jsx12 } from "react/jsx-runtime";
+
+function VariablePage({ export: exp, spec }) {
+  return /* @__PURE__ */ jsx12("div", {
+    className: "doccov-variable-page not-prose",
+    children: /* @__PURE__ */ jsx12(VariableSection, {
+      export: exp,
+      spec
+    })
+  });
+}
+
+// src/components/styled/APIPage.tsx
+import { jsx as jsx13, jsxs as jsxs8 } from "react/jsx-runtime";
+
+function NotFound({ id }) {
+  return /* @__PURE__ */ jsx13("div", {
+    className: "rounded-lg border border-border bg-card p-6 text-center",
+    children: /* @__PURE__ */ jsxs8("p", {
+      className: "text-muted-foreground",
+      children: [
+        "Export ",
+        /* @__PURE__ */ jsx13("code", {
+          className: "font-mono text-primary",
+          children: id
+        }),
+        " not found in spec."
+      ]
+    })
+  });
+}
+function NoSpec() {
+  return /* @__PURE__ */ jsx13("div", {
+    className: "rounded-lg border border-red-500/20 bg-red-500/10 p-6 text-center",
+    children: /* @__PURE__ */ jsxs8("p", {
+      className: "text-red-600 dark:text-red-400",
+      children: [
+        "No spec provided. Pass either ",
+        /* @__PURE__ */ jsx13("code", {
+          children: "spec"
+        }),
+        " or ",
+        /* @__PURE__ */ jsx13("code", {
+          children: "instance"
+        }),
+        " prop."
+      ]
+    })
+  });
+}
+function APIPage({
+  spec,
+  instance,
+  id,
+  baseHref = "",
+  description,
+  renderExample
+}) {
+  const resolvedSpec = spec ?? instance?.spec;
+  if (!resolvedSpec) {
+    return /* @__PURE__ */ jsx13(NoSpec, {});
+  }
+  if (!id) {
+    return /* @__PURE__ */ jsx13(ExportIndexPage, {
+      spec: resolvedSpec,
+      baseHref,
+      description
+    });
+  }
+  const exp = resolvedSpec.exports.find((e) => e.id === id);
+  if (!exp) {
+    return /* @__PURE__ */ jsx13(NotFound, {
+      id
+    });
+  }
+  const pageProps = { export: exp, spec: resolvedSpec, renderExample };
+  switch (exp.kind) {
+    case "function":
+      return /* @__PURE__ */ jsx13(FunctionPage, {
+        ...pageProps
+      });
+    case "class":
+      return /* @__PURE__ */ jsx13(ClassPage, {
+        ...pageProps
+      });
+    case "interface":
+    case "type":
+      return /* @__PURE__ */ jsx13(InterfacePage, {
+        ...pageProps
+      });
+    case "enum":
+      return /* @__PURE__ */ jsx13(EnumPage, {
+        ...pageProps
+      });
+    default:
+      return /* @__PURE__ */ jsx13(VariablePage, {
+        ...pageProps
+      });
+  }
+}
+// src/components/styled/FullAPIReferencePage.tsx
+import { APIReferencePage } from "@openpkg-ts/ui/docskit";
+import { cn as cn3 } from "@openpkg-ts/ui/lib/utils";
+import { useCallback, useEffect, useMemo as useMemo2, useRef, useState as useState2 } from "react";
+
+// src/components/styled/sections/ExportSection.tsx
+import { jsx as jsx14 } from "react/jsx-runtime";
+
+function ExportSection({ export: exp, spec }) {
+  const props = { export: exp, spec };
+  switch (exp.kind) {
+    case "function":
+      return /* @__PURE__ */ jsx14(FunctionSection, {
+        ...props
+      });
+    case "class":
+      return /* @__PURE__ */ jsx14(ClassSection, {
+        ...props
+      });
+    case "interface":
+    case "type":
+      return /* @__PURE__ */ jsx14(InterfaceSection, {
+        ...props
+      });
+    case "enum":
+      return /* @__PURE__ */ jsx14(EnumSection, {
+        ...props
+      });
+    default:
+      return /* @__PURE__ */ jsx14(VariableSection, {
+        ...props
+      });
+  }
+}
+
+// src/components/styled/FullAPIReferencePage.tsx
+import { jsx as jsx15, jsxs as jsxs9 } from "react/jsx-runtime";
+
+var KIND_ORDER2 = ["function", "class", "interface", "type", "enum", "variable"];
+var KIND_LABELS2 = {
+  function: "Functions",
+  class: "Classes",
+  interface: "Interfaces",
+  type: "Types",
+  enum: "Enums",
+  variable: "Variables"
+};
+function getExportTitle(exp) {
+  switch (exp.kind) {
+    case "function":
+      return `${exp.name}()`;
+    case "class":
+      return `class ${exp.name}`;
+    case "interface":
+    case "type":
+      return exp.name;
+    case "enum":
+      return `enum ${exp.name}`;
+    default:
+      return exp.name;
+  }
+}
+function FullAPIReferencePage({
+  spec,
+  kinds,
+  showFilters = true,
+  showTOC = false,
+  title,
+  description,
+  className
+}) {
+  const [activeFilter, setActiveFilter] = useState2("all");
+  const [activeSection, setActiveSection] = useState2(null);
+  const isScrollingRef = useRef(false);
+  const availableKinds = useMemo2(() => {
+    const kindSet = new Set;
+    for (const exp of spec.exports) {
+      const kind = exp.kind;
+      if (KIND_ORDER2.includes(kind)) {
+        kindSet.add(kind);
+      }
+    }
+    return KIND_ORDER2.filter((k) => kindSet.has(k));
+  }, [spec.exports]);
+  const filteredExports = useMemo2(() => {
+    let exports = spec.exports;
+    if (kinds?.length) {
+      exports = exports.filter((e) => kinds.includes(e.kind));
+    }
+    if (activeFilter !== "all") {
+      exports = exports.filter((e) => e.kind === activeFilter);
+    }
+    return exports.sort((a, b) => {
+      const kindOrderA = KIND_ORDER2.indexOf(a.kind);
+      const kindOrderB = KIND_ORDER2.indexOf(b.kind);
+      if (kindOrderA !== kindOrderB) {
+        return kindOrderA - kindOrderB;
+      }
+      return a.name.localeCompare(b.name);
+    });
+  }, [spec.exports, kinds, activeFilter]);
+  const groupedExports = useMemo2(() => {
+    const groups = new Map;
+    for (const exp of filteredExports) {
+      const kind = exp.kind;
+      if (!groups.has(kind)) {
+        groups.set(kind, []);
+      }
+      groups.get(kind).push(exp);
+    }
+    return groups;
+  }, [filteredExports]);
+  useEffect(() => {
+    if (typeof window === "undefined")
+      return;
+    const hash = window.location.hash.slice(1);
+    if (hash) {
+      const timer = setTimeout(() => {
+        const element = document.getElementById(hash);
+        if (element) {
+          isScrollingRef.current = true;
+          element.scrollIntoView({ behavior: "smooth" });
+          setActiveSection(hash);
+          setTimeout(() => {
+            isScrollingRef.current = false;
+          }, 1000);
+        }
+      }, 100);
+      return () => clearTimeout(timer);
+    }
+  }, []);
+  useEffect(() => {
+    if (!showTOC || typeof window === "undefined")
+      return;
+    const sectionIds = filteredExports.map((exp) => exp.id || exp.name);
+    const _observers = [];
+    const handleIntersect = (entries) => {
+      if (isScrollingRef.current)
+        return;
+      for (const entry of entries) {
+        if (entry.isIntersecting && entry.intersectionRatio > 0) {
+          const id = entry.target.id;
+          setActiveSection(id);
+          if (typeof window !== "undefined") {
+            window.history.replaceState(null, "", `#${id}`);
+          }
+          break;
+        }
+      }
+    };
+    const observer = new IntersectionObserver(handleIntersect, {
+      rootMargin: "-20% 0px -70% 0px",
+      threshold: 0
+    });
+    for (const id of sectionIds) {
+      const element = document.getElementById(id);
+      if (element) {
+        observer.observe(element);
+      }
+    }
+    return () => {
+      observer.disconnect();
+    };
+  }, [showTOC, filteredExports]);
+  const handleTOCClick = useCallback((id) => {
+    const element = document.getElementById(id);
+    if (element) {
+      isScrollingRef.current = true;
+      element.scrollIntoView({ behavior: "smooth" });
+      setActiveSection(id);
+      window.history.replaceState(null, "", `#${id}`);
+      setTimeout(() => {
+        isScrollingRef.current = false;
+      }, 1000);
+    }
+  }, []);
+  const defaultDescription = /* @__PURE__ */ jsxs9("div", {
+    children: [
+      spec.meta.description && /* @__PURE__ */ jsx15("p", {
+        children: spec.meta.description
+      }),
+      spec.meta.version && /* @__PURE__ */ jsxs9("p", {
+        className: "text-sm text-muted-foreground mt-2",
+        children: [
+          "Version ",
+          spec.meta.version
+        ]
+      })
+    ]
+  });
+  const shouldShowFilters = showFilters && !kinds?.length && availableKinds.length > 1;
+  return /* @__PURE__ */ jsxs9("div", {
+    className: cn3("doccov-full-reference-page not-prose", showTOC && "lg:grid lg:grid-cols-[220px_1fr] lg:gap-8", className),
+    children: [
+      showTOC && /* @__PURE__ */ jsx15("aside", {
+        className: "hidden lg:block",
+        children: /* @__PURE__ */ jsxs9("nav", {
+          className: "sticky top-20 max-h-[calc(100vh-6rem)] overflow-y-auto pr-4",
+          children: [
+            /* @__PURE__ */ jsx15("h4", {
+              className: "text-sm font-semibold text-foreground mb-3",
+              children: "On this page"
+            }),
+            /* @__PURE__ */ jsx15("div", {
+              className: "space-y-4",
+              children: KIND_ORDER2.map((kind) => {
+                const exports = groupedExports.get(kind);
+                if (!exports?.length)
+                  return null;
+                return /* @__PURE__ */ jsxs9("div", {
+                  children: [
+                    /* @__PURE__ */ jsx15("h5", {
+                      className: "text-xs font-medium text-muted-foreground uppercase tracking-wide mb-2",
+                      children: KIND_LABELS2[kind]
+                    }),
+                    /* @__PURE__ */ jsx15("ul", {
+                      className: "space-y-1",
+                      children: exports.map((exp) => {
+                        const id = exp.id || exp.name;
+                        const isActive = activeSection === id;
+                        return /* @__PURE__ */ jsx15("li", {
+                          children: /* @__PURE__ */ jsx15("button", {
+                            type: "button",
+                            onClick: () => handleTOCClick(id),
+                            className: cn3("block w-full text-left text-sm py-1 px-2 rounded-md transition-colors cursor-pointer truncate", isActive ? "bg-primary/10 text-primary font-medium" : "text-muted-foreground hover:text-foreground hover:bg-muted/50"),
+                            title: getExportTitle(exp),
+                            children: getExportTitle(exp)
+                          })
+                        }, id);
+                      })
+                    })
+                  ]
+                }, kind);
+              })
+            })
+          ]
+        })
+      }),
+      /* @__PURE__ */ jsx15("div", {
+        children: /* @__PURE__ */ jsxs9(APIReferencePage, {
+          title: title || spec.meta.name || "API Reference",
+          description: description || defaultDescription,
+          children: [
+            shouldShowFilters && /* @__PURE__ */ jsxs9("div", {
+              className: "flex flex-wrap gap-2 mb-8 -mt-4",
+              children: [
+                /* @__PURE__ */ jsx15("button", {
+                  type: "button",
+                  onClick: () => setActiveFilter("all"),
+                  className: cn3("px-3 py-1.5 text-sm rounded-md transition-all cursor-pointer", activeFilter === "all" ? "bg-primary text-primary-foreground font-medium" : "bg-muted text-muted-foreground hover:bg-muted/80 hover:text-foreground"),
+                  children: "All"
+                }),
+                availableKinds.map((kind) => /* @__PURE__ */ jsx15("button", {
+                  type: "button",
+                  onClick: () => setActiveFilter(kind),
+                  className: cn3("px-3 py-1.5 text-sm rounded-md transition-all cursor-pointer", activeFilter === kind ? "bg-primary text-primary-foreground font-medium" : "bg-muted text-muted-foreground hover:bg-muted/80 hover:text-foreground"),
+                  children: KIND_LABELS2[kind]
+                }, kind))
+              ]
+            }),
+            filteredExports.map((exp) => /* @__PURE__ */ jsx15(ExportSection, {
+              export: exp,
+              spec
+            }, exp.id || exp.name)),
+            filteredExports.length === 0 && /* @__PURE__ */ jsxs9("div", {
+              className: "rounded-lg border border-border bg-card/50 p-8 text-center",
+              children: [
+                /* @__PURE__ */ jsx15("p", {
+                  className: "text-muted-foreground",
+                  children: activeFilter !== "all" ? `No ${KIND_LABELS2[activeFilter].toLowerCase()} found.` : "No exports found in this package."
+                }),
+                activeFilter !== "all" && /* @__PURE__ */ jsx15("button", {
+                  type: "button",
+                  onClick: () => setActiveFilter("all"),
+                  className: "mt-3 text-sm text-primary hover:underline cursor-pointer",
+                  children: "Show all exports"
+                })
+              ]
+            })
+          ]
+        })
+      })
+    ]
+  });
+}
+// src/components/styled/ParameterItem.tsx
+import { cn as cn4 } from "@openpkg-ts/ui/lib/utils";
+import { ChevronRight } from "lucide-react";
+import { useState as useState3 } from "react";
+import { formatSchema as formatSchema6 } from "@openpkg-ts/sdk";
+import { jsx as jsx16, jsxs as jsxs10 } from "react/jsx-runtime";
+
+function getNestedProperties(schema) {
+  if (!schema || typeof schema !== "object")
+    return null;
+  const s = schema;
+  if (s.type === "object" && s.properties && typeof s.properties === "object") {
+    return s.properties;
+  }
+  return null;
+}
+function getRequiredFields(schema) {
+  if (!schema || typeof schema !== "object")
+    return [];
+  const s = schema;
+  if (Array.isArray(s.required)) {
+    return s.required;
+  }
+  return [];
+}
+function countProperties(schema) {
+  const props = getNestedProperties(schema);
+  return props ? Object.keys(props).length : 0;
+}
+function NestedPropertyItem({
+  name,
+  schema,
+  required = false,
+  depth = 0
+}) {
+  const [expanded, setExpanded] = useState3(false);
+  const type = formatSchema6(schema);
+  const nestedProps = getNestedProperties(schema);
+  const nestedCount = countProperties(schema);
+  const hasNested = nestedCount > 0;
+  const schemaObj = schema;
+  const description = schemaObj?.description;
+  return /* @__PURE__ */ jsxs10("div", {
+    className: cn4("border-t border-border first:border-t-0", depth > 0 && "ml-4"),
+    children: [
+      /* @__PURE__ */ jsx16("div", {
+        className: "py-3",
+        children: /* @__PURE__ */ jsxs10("div", {
+          className: "flex items-start gap-2",
+          children: [
+            hasNested && /* @__PURE__ */ jsx16("button", {
+              type: "button",
+              onClick: () => setExpanded(!expanded),
+              className: "mt-0.5 p-0.5 text-muted-foreground hover:text-foreground transition-colors cursor-pointer",
+              "aria-label": expanded ? "Collapse" : "Expand",
+              children: /* @__PURE__ */ jsx16(ChevronRight, {
+                size: 14,
+                className: cn4("transition-transform duration-200", expanded && "rotate-90")
+              })
+            }),
+            !hasNested && /* @__PURE__ */ jsx16("div", {
+              className: "w-5"
+            }),
+            /* @__PURE__ */ jsxs10("div", {
+              className: "flex-1 min-w-0",
+              children: [
+                /* @__PURE__ */ jsxs10("div", {
+                  className: "flex items-baseline gap-2 flex-wrap",
+                  children: [
+                    /* @__PURE__ */ jsxs10("span", {
+                      className: "font-mono text-sm text-foreground",
+                      children: [
+                        name,
+                        !required && /* @__PURE__ */ jsx16("span", {
+                          className: "text-muted-foreground",
+                          children: "?"
+                        })
+                      ]
+                    }),
+                    /* @__PURE__ */ jsx16("span", {
+                      className: "font-mono text-sm text-muted-foreground",
+                      children: hasNested ? "object" : type
+                    }),
+                    hasNested && /* @__PURE__ */ jsxs10("button", {
+                      type: "button",
+                      onClick: () => setExpanded(!expanded),
+                      className: "text-xs text-primary hover:underline cursor-pointer",
+                      children: [
+                        nestedCount,
+                        " ",
+                        nestedCount === 1 ? "property" : "properties"
+                      ]
+                    })
+                  ]
+                }),
+                description && /* @__PURE__ */ jsx16("p", {
+                  className: "text-sm text-muted-foreground mt-1",
+                  children: description
+                })
+              ]
+            })
+          ]
+        })
+      }),
+      hasNested && expanded && nestedProps && /* @__PURE__ */ jsx16("div", {
+        className: "border-l border-border ml-2",
+        children: Object.entries(nestedProps).map(([propName, propSchema]) => /* @__PURE__ */ jsx16(NestedPropertyItem, {
+          name: propName,
+          schema: propSchema,
+          required: getRequiredFields(schema).includes(propName),
+          depth: depth + 1
+        }, propName))
+      })
+    ]
+  });
+}
+function ParameterItem({
+  param,
+  depth = 0,
+  className
+}) {
+  const [expanded, setExpanded] = useState3(false);
+  const type = formatSchema6(param.schema);
+  const isRequired = param.required !== false;
+  const nestedProps = getNestedProperties(param.schema);
+  const nestedCount = countProperties(param.schema);
+  const hasNested = nestedCount > 0;
+  return /* @__PURE__ */ jsxs10("div", {
+    className: cn4("border-b border-border last:border-b-0", className),
+    children: [
+      /* @__PURE__ */ jsx16("div", {
+        className: "py-3",
+        children: /* @__PURE__ */ jsxs10("div", {
+          className: "flex items-start gap-2",
+          children: [
+            hasNested && /* @__PURE__ */ jsx16("button", {
+              type: "button",
+              onClick: () => setExpanded(!expanded),
+              className: "mt-0.5 p-0.5 text-muted-foreground hover:text-foreground transition-colors cursor-pointer",
+              "aria-label": expanded ? "Collapse" : "Expand",
+              children: /* @__PURE__ */ jsx16(ChevronRight, {
+                size: 14,
+                className: cn4("transition-transform duration-200", expanded && "rotate-90")
+              })
+            }),
+            !hasNested && /* @__PURE__ */ jsx16("div", {
+              className: "w-5"
+            }),
+            /* @__PURE__ */ jsxs10("div", {
+              className: "flex-1 min-w-0",
+              children: [
+                /* @__PURE__ */ jsxs10("div", {
+                  className: "flex items-baseline gap-2 flex-wrap",
+                  children: [
+                    /* @__PURE__ */ jsx16("span", {
+                      className: "font-mono text-sm font-medium text-foreground",
+                      children: param.name
+                    }),
+                    isRequired && /* @__PURE__ */ jsx16("span", {
+                      className: "text-[10px] font-semibold px-1.5 py-0.5 rounded border border-border bg-muted text-muted-foreground uppercase tracking-wide",
+                      children: "Required"
+                    }),
+                    /* @__PURE__ */ jsx16("span", {
+                      className: "font-mono text-sm text-muted-foreground",
+                      children: hasNested ? "object" : type
+                    }),
+                    hasNested && /* @__PURE__ */ jsxs10("button", {
+                      type: "button",
+                      onClick: () => setExpanded(!expanded),
+                      className: "text-xs text-primary hover:underline cursor-pointer",
+                      children: [
+                        nestedCount,
+                        " ",
+                        nestedCount === 1 ? "property" : "properties"
+                      ]
+                    })
+                  ]
+                }),
+                param.description && /* @__PURE__ */ jsx16("p", {
+                  className: "text-sm text-muted-foreground mt-1",
+                  children: param.description
+                })
+              ]
+            })
+          ]
+        })
+      }),
+      hasNested && expanded && nestedProps && /* @__PURE__ */ jsx16("div", {
+        className: "border-l border-border ml-2 mb-3",
+        children: Object.entries(nestedProps).map(([propName, propSchema]) => /* @__PURE__ */ jsx16(NestedPropertyItem, {
+          name: propName,
+          schema: propSchema,
+          required: getRequiredFields(param.schema).includes(propName),
+          depth: depth + 1
+        }, propName))
+      })
+    ]
+  });
+}
+export {
+  specSchemaToAPISchema,
+  specParamToAPIParam,
+  specExamplesToCodeExamples,
+  groupMembersByKind,
+  getLanguagesFromExamples,
+  getExampleTitle,
+  getExampleLanguage,
+  getExampleCode,
+  cleanCode,
+  buildImportStatement,
+  VariableSection,
+  VariablePage,
+  TypeTable,
+  Signature,
+  ParameterItem,
+  ParamTable,
+  ParamRow,
+  NestedProperty,
+  MembersTable,
+  MemberRow,
+  InterfaceSection,
+  InterfacePage,
+  ImportSection,
+  FunctionSection,
+  FunctionPage,
+  FullAPIReferencePage,
+  ExportSection,
+  ExportIndexPage,
+  ExportCard,
+  ExpandableProperty,
+  ExampleBlock,
+  EnumSection,
+  EnumPage,
+  CollapsibleMethod,
+  CodeTabs,
+  ClassSection,
+  ClassPage,
+  APIPage
+};