@stainless-api/docs-ui 0.1.0-beta.24 → 0.1.0-beta.26

package/dist/md-Dg8aOyMA.js

@@ -0,0 +1,41 @@
+import Markdoc from "@markdoc/markdoc";
+
+//#region src/markdown/md.ts
+function heading(level, children) {
+	const content = inline(...typeof children === "string" ? [text(children)] : children);
+	return new Markdoc.Ast.Node("heading", { level }, [content]);
+}
+function text(content) {
+	return new Markdoc.Ast.Node("text", { content });
+}
+function code(content) {
+	return new Markdoc.Ast.Node("code", { content });
+}
+function paragraph(...children) {
+	const inline$1 = new Markdoc.Ast.Node("inline", {}, children);
+	return new Markdoc.Ast.Node("paragraph", {}, [inline$1]);
+}
+function list(...children) {
+	return new Markdoc.Ast.Node("list", { ordered: false }, children);
+}
+function item(...children) {
+	return new Markdoc.Ast.Node("item", {}, children);
+}
+function strong(...children) {
+	return new Markdoc.Ast.Node("strong", {}, children);
+}
+function inline(...children) {
+	return new Markdoc.Ast.Node("inline", {}, children);
+}
+function fence(language, content) {
+	return new Markdoc.Ast.Node("fence", {
+		language,
+		content
+	});
+}
+function parse(content) {
+	return Markdoc.parse(content).children;
+}
+
+//#endregion
+export { item as a, parse as c, inline as i, strong as l, fence as n, list as o, heading as r, paragraph as s, code as t, text as u };

package/dist/method-c3XDArUn.d.ts

@@ -0,0 +1,70 @@
+import * as React$1 from "react";
+import { ReactNode } from "react";
+import { LucideIcon } from "lucide-react";
+
+//#region src/components/method.d.ts
+declare const HttpMethods: string[];
+type HTTPMethod = (typeof HttpMethods)[number];
+declare const HttpMethodIcons: Record<HTTPMethod, LucideIcon>;
+type MethodIconProps = {
+  httpMethod?: string;
+  showName?: boolean;
+};
+declare function MethodIconBadge({
+  httpMethod,
+  showName
+}: MethodIconProps): React$1.JSX.Element | null;
+type MethodHeaderProps = {
+  title: ReactNode;
+  level?: 'h1' | 'h2' | 'h3' | 'h4' | 'h5';
+  signature?: ReactNode;
+  badges?: ReactNode;
+  children?: ReactNode;
+};
+declare function MethodHeader({
+  title,
+  badges,
+  signature,
+  children,
+  level
+}: MethodHeaderProps): React$1.JSX.Element;
+type MethodRouteProps = {
+  httpMethod?: string;
+  endpoint?: string | ReactNode;
+  iconOnly?: boolean;
+};
+declare function MethodRoute({
+  httpMethod,
+  endpoint,
+  iconOnly
+}: MethodRouteProps): React$1.JSX.Element;
+type MethodDescriptionProps = {
+  description?: string;
+};
+declare function MethodDescription({
+  description
+}: MethodDescriptionProps): React$1.JSX.Element | undefined;
+type MethodInfoProps = {
+  children?: ReactNode;
+  parameters?: ReactNode;
+  returns?: ReactNode;
+};
+declare function MethodInfo({
+  children,
+  parameters,
+  returns
+}: MethodInfoProps): React$1.JSX.Element;
+type MethodProps = {
+  id?: string;
+  header?: ReactNode;
+  children?: ReactNode;
+} & React$1.HTMLProps<HTMLDivElement>;
+declare function Method({
+  id,
+  header,
+  children,
+  className,
+  ...props
+}: MethodProps): React$1.JSX.Element;
+//#endregion
+export { MethodDescription as a, MethodHeaderProps as c, MethodInfo as d, MethodInfoProps as f, MethodRouteProps as h, Method as i, MethodIconBadge as l, MethodRoute as m, HttpMethodIcons as n, MethodDescriptionProps as o, MethodProps as p, HttpMethods as r, MethodHeader as s, HTTPMethod as t, MethodIconProps as u };

package/dist/navigation-BSn6PX-7.d.ts

@@ -0,0 +1,28 @@
+import { t as DocsLanguage } from "./routing-BE6Vrs-z.js";
+import * as React$1 from "react";
+
+//#region src/contexts/navigation.d.ts
+type NavigationHandler = (ev: React$1.MouseEvent | null, opts: {
+  href: string;
+  language: DocsLanguage;
+  stainlessPath: string;
+  scroll: boolean;
+}) => void;
+type NavigationContextType = {
+  basePath?: string;
+  selectedPath?: string;
+  navigationPath?: string[];
+  onNavigate?: NavigationHandler;
+};
+declare function useNavigation(): NavigationContextType;
+type NavigationProviderProps = NavigationContextType & {
+  children: React$1.ReactNode;
+};
+declare function NavigationProvider({
+  basePath,
+  selectedPath,
+  onNavigate,
+  children
+}: NavigationProviderProps): React$1.JSX.Element;
+//#endregion
+export { useNavigation as a, NavigationProviderProps as i, NavigationHandler as n, NavigationProvider as r, NavigationContextType as t };

package/dist/navigation-CuCg3le8.js

@@ -0,0 +1,20 @@
+import * as React$1 from "react";
+
+//#region src/contexts/navigation.tsx
+const Defaults = { basePath: "/" };
+const NavigationContext = React$1.createContext(Defaults);
+function useNavigation() {
+	return React$1.useContext(NavigationContext);
+}
+function NavigationProvider({ basePath, selectedPath, onNavigate, children }) {
+	const value = {
+		...Defaults,
+		onNavigate,
+		basePath,
+		selectedPath
+	};
+	return <NavigationContext.Provider value={value}>{children}</NavigationContext.Provider>;
+}
+
+//#endregion
+export { useNavigation as n, NavigationProvider as t };

package/dist/overview-D21weqVJ.d.ts

@@ -0,0 +1,39 @@
+import * as React$1 from "react";
+import * as SDKJSON from "@stainless/sdk-json";
+
+//#region src/components/overview.d.ts
+type SDKResourceProps = {
+  resource: SDKJSON.Resource;
+  parents?: SDKJSON.Resource[];
+};
+declare function SDKResourceHeader({
+  resource,
+  parents
+}: SDKResourceProps): React$1.JSX.Element | null;
+type SDKMethodSummaryProps = {
+  method: SDKJSON.Method;
+};
+declare function SDKMethodSummary({
+  method
+}: SDKMethodSummaryProps): React$1.JSX.Element;
+declare function SDKResource({
+  resource,
+  parents,
+  showModels
+}: SDKResourceProps & {
+  showModels?: boolean;
+}): React$1.JSX.Element;
+type SDKOverviewProps = {
+  resource: SDKJSON.Resource;
+};
+declare function SDKOverview({
+  resource
+}: SDKOverviewProps): React$1.JSX.Element;
+type SDKRootProps = {
+  stainlessPath: string;
+};
+declare function SDKRoot({
+  stainlessPath
+}: SDKRootProps): React$1.JSX.Element | null;
+//#endregion
+export { SDKResource as a, SDKRoot as c, SDKOverviewProps as i, SDKRootProps as l, SDKMethodSummaryProps as n, SDKResourceHeader as o, SDKOverview as r, SDKResourceProps as s, SDKMethodSummary as t };

package/dist/pagefind-ChrPfuVv.js

@@ -0,0 +1,15 @@
+//#region src/search/providers/pagefind.ts
+async function loadPagefind(path) {
+	return await import(new URL(path, import.meta.url).href);
+}
+async function guideSearch(loadPath, query, limit) {
+	const response = await (await loadPagefind(loadPath)).search(query);
+	const items = limit ? response.results.slice(0, limit) : response.results;
+	return Promise.all(items.map((result) => result.data().then((data) => ({
+		...result,
+		data
+	}))));
+}
+
+//#endregion
+export { guideSearch as t };

package/dist/primitives-iB9fIrMF.d.ts

@@ -0,0 +1,98 @@
+import * as React$1 from "react";
+import { ReactNode } from "react";
+
+//#region src/components/primitives.d.ts
+type JoinProps = {
+  items: ReactNode[];
+  limit?: number;
+  children: ReactNode;
+};
+declare function Join({
+  items,
+  limit,
+  children
+}: JoinProps): React$1.JSX.Element[];
+type ExpanderProps = {
+  id?: string;
+  open?: boolean;
+  summary: ReactNode;
+  virtual?: boolean;
+  muted?: boolean;
+  children?: ReactNode;
+};
+declare function Expander({
+  id,
+  open,
+  summary,
+  virtual,
+  muted,
+  children
+}: ExpanderProps): React$1.JSX.Element;
+declare function VirtualExpander({
+  id,
+  open: isOpen,
+  muted,
+  summary,
+  children
+}: Omit<ExpanderProps, 'virtual'>): React$1.JSX.Element;
+declare function Markdown({
+  content
+}: {
+  content: string;
+}): "" | React$1.JSX.Element | undefined;
+type BadgeProps = {
+  id: string;
+  children?: ReactNode;
+};
+declare function Badge({
+  id,
+  children
+}: BadgeProps): React$1.JSX.Element;
+type TooltipProps = {
+  content: ReactNode;
+  children: ReactNode;
+};
+declare function Tooltip({
+  content,
+  children
+}: TooltipProps): string | number | bigint | boolean | Iterable<React$1.ReactNode> | Promise<string | number | bigint | boolean | React$1.ReactPortal | React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | Iterable<React$1.ReactNode> | null | undefined> | React$1.JSX.Element | null | undefined;
+type LinkProps = {
+  stainlessPath: string;
+  scroll?: boolean;
+  children?: ReactNode;
+} & React$1.HTMLProps<HTMLAnchorElement>;
+declare function Link({
+  stainlessPath,
+  scroll,
+  children,
+  ...props
+}: LinkProps): string | number | bigint | boolean | Iterable<React$1.ReactNode> | Promise<string | number | bigint | boolean | React$1.ReactPortal | React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | Iterable<React$1.ReactNode> | null | undefined> | React$1.JSX.Element | null | undefined;
+type InputProps = {
+  left?: ReactNode;
+  right?: ReactNode;
+} & React$1.InputHTMLAttributes<HTMLInputElement>;
+declare const Input: React$1.ForwardRefExoticComponent<{
+  left?: ReactNode;
+  right?: ReactNode;
+} & React$1.InputHTMLAttributes<HTMLInputElement> & React$1.RefAttributes<HTMLInputElement>>;
+type ToggleButtonProps = {
+  children?: ReactNode;
+  selected?: boolean;
+} & React$1.ButtonHTMLAttributes<HTMLButtonElement>;
+declare const ToggleButton: React$1.ForwardRefExoticComponent<{
+  children?: ReactNode;
+  selected?: boolean;
+} & React$1.ButtonHTMLAttributes<HTMLButtonElement> & React$1.RefAttributes<HTMLButtonElement>>;
+type ListViewProps<TItem> = {
+  items: Array<TItem>;
+  itemDelegate: (item: TItem, selected: boolean) => React$1.ReactNode;
+  onSelectListItem?: (item: TItem) => void;
+} & React$1.HTMLAttributes<HTMLDivElement>;
+declare function ListView<TItem>({
+  items,
+  itemDelegate,
+  onSelectListItem,
+  ...rest
+}: ListViewProps<TItem>): React$1.JSX.Element;
+//#endregion
+export { Join as a, ListViewProps as c, ToggleButtonProps as d, Tooltip as f, InputProps as i, Markdown as l, Expander as n, Link as o, VirtualExpander as p, Input as r, ListView as s, Badge as t, ToggleButton as u };

package/dist/properties-Ba6F_GGj.d.ts

@@ -0,0 +1,46 @@
+import * as react0 from "react";
+import { ReactNode } from "react";
+
+//#region src/components/properties.d.ts
+type PropertyToggleProps = {
+  target: string;
+};
+declare function PropertyToggle({
+  target
+}: PropertyToggleProps): react0.JSX.Element;
+type PropertyDescriptionProps = {
+  description?: string;
+};
+declare function PropertyDescription({
+  description
+}: PropertyDescriptionProps): react0.JSX.Element | undefined;
+type PropertyProps = {
+  id?: string;
+  name?: ReactNode;
+  typeName?: ReactNode;
+  badges?: ReactNode;
+  type?: ReactNode;
+  description?: string;
+  expand?: boolean;
+  deprecated?: boolean | string;
+  additional?: ReactNode;
+  declaration?: ReactNode;
+  constraints?: ReactNode;
+  children?: ReactNode;
+};
+declare function Property({
+  id,
+  name,
+  typeName,
+  badges,
+  type,
+  declaration,
+  description,
+  deprecated,
+  expand,
+  additional,
+  constraints,
+  children
+}: PropertyProps): react0.JSX.Element;
+//#endregion
+export { PropertyToggle as a, PropertyProps as i, PropertyDescription as n, PropertyToggleProps as o, PropertyDescriptionProps as r, Property as t };

package/dist/routing-BE6Vrs-z.d.ts

@@ -0,0 +1,54 @@
+import * as SDKJSON from "@stainless/sdk-json";
+
+//#region src/routing.d.ts
+declare namespace routing_d_exports {
+  export { DocsLanguage, LanguageNames, Languages, ParsedStainlessPath, RouteEntry, SpecTreeEntry, SupportedLanguageSyntaxes, expandToElement, findNavigationPath, generateRoute, generateRouteList, getLanguageSnippet, getResource, isSupportedLanguage, parseRoute, parseStainlessPath, scrollToPath, trimStainlessPath, updateHistory, walkTree };
+}
+declare const Languages: readonly ["http", "node", "python", "go", "typescript", "terraform", "ruby", "java", "kotlin"];
+declare const SupportedLanguageSyntaxes: string[];
+type DocsLanguage = (typeof Languages)[number];
+declare const LanguageNames: Record<DocsLanguage, string>;
+declare function getLanguageSnippet(language: DocsLanguage): "node.default" | "go.default" | "python.default" | "terraform.default" | "http.curl" | "typescript.default" | "ruby.default" | "java.default" | "kotlin.default";
+declare function isSupportedLanguage(language: string): language is DocsLanguage;
+type ParsedStainlessPath = ReturnType<typeof parseStainlessPath>;
+declare function parseStainlessPath(stainlessPath: string): {
+  resource: string[] | null;
+  method: string | null;
+  model: string | null;
+  routable: string | undefined;
+} | null;
+declare function trimStainlessPath(stainlessPath: string): string;
+declare function getResource(stainlessPath: string): string | undefined;
+declare function parseRoute(basePath: string, route: string): {
+  stainlessPath: string;
+  language: DocsLanguage;
+};
+declare function generateRoute(basePath: string, language: string, stainlessPath: string): string | null;
+type SpecTreeEntry = {
+  data: SDKJSON.Method | SDKJSON.Resource | SDKJSON.Model;
+  path: string[];
+};
+declare function walkTree(spec: SDKJSON.Spec, includeModels?: boolean): Generator<SpecTreeEntry, void, any>;
+type RouteEntry = {
+  title: string;
+  kind: SpecTreeEntry['data']['kind'];
+  language: DocsLanguage;
+  stainlessPath: string;
+  slug: string;
+};
+declare function generateRouteList({
+  spec,
+  languages,
+  excludeLanguages
+}: {
+  spec: SDKJSON.Spec;
+  languages?: DocsLanguage[];
+  excludeLanguages?: DocsLanguage[];
+}): RouteEntry[];
+type ResourceOrMethod = SDKJSON.Resource | SDKJSON.Method;
+declare function findNavigationPath(items: ResourceOrMethod[], target: string): string[] | undefined;
+declare function expandToElement(el: HTMLElement | null): void;
+declare function scrollToPath(stainlessPath: string): void;
+declare function updateHistory(basePath: string, language: DocsLanguage, stainlessPath: string): void;
+//#endregion
+export { routing_d_exports as _, RouteEntry as a, updateHistory as b, expandToElement as c, generateRouteList as d, getLanguageSnippet as f, parseStainlessPath as g, parseRoute as h, ParsedStainlessPath as i, findNavigationPath as l, isSupportedLanguage as m, LanguageNames as n, SpecTreeEntry as o, getResource as p, Languages as r, SupportedLanguageSyntaxes as s, DocsLanguage as t, generateRoute as u, scrollToPath as v, walkTree as x, trimStainlessPath as y };

package/dist/routing-C8oZYLsf.js

@@ -0,0 +1,189 @@
+import { t as __export } from "./chunk-Bp6m_JJh.js";
+
+//#region src/routing.ts
+var routing_exports = /* @__PURE__ */ __export({
+	LanguageNames: () => LanguageNames,
+	Languages: () => Languages,
+	SupportedLanguageSyntaxes: () => SupportedLanguageSyntaxes,
+	expandToElement: () => expandToElement,
+	findNavigationPath: () => findNavigationPath,
+	generateRoute: () => generateRoute,
+	generateRouteList: () => generateRouteList,
+	getLanguageSnippet: () => getLanguageSnippet,
+	getResource: () => getResource,
+	isSupportedLanguage: () => isSupportedLanguage,
+	parseRoute: () => parseRoute,
+	parseStainlessPath: () => parseStainlessPath,
+	scrollToPath: () => scrollToPath,
+	trimStainlessPath: () => trimStainlessPath,
+	updateHistory: () => updateHistory,
+	walkTree: () => walkTree
+});
+const Languages = [
+	"http",
+	"node",
+	"python",
+	"go",
+	"typescript",
+	"terraform",
+	"ruby",
+	"java",
+	"kotlin"
+];
+const SupportedLanguageSyntaxes = [
+	"http",
+	"javascript",
+	"python",
+	"go",
+	"typescript",
+	"terraform",
+	"ruby",
+	"java",
+	"kotlin"
+];
+const LanguageNames = {
+	http: "HTTP",
+	node: "TypeScript",
+	typescript: "TypeScript",
+	python: "Python",
+	go: "Go",
+	ruby: "Ruby",
+	java: "Java",
+	kotlin: "Kotlin",
+	terraform: "Terraform"
+};
+function getLanguageSnippet(language) {
+	return language === "http" ? "http.curl" : `${language}.default`;
+}
+function isSupportedLanguage(language) {
+	return Languages.includes(language);
+}
+const DefaultLanguage = "http";
+const StainlessPathPattern = /(\(resource\) (?<resource>[^\s]+))( > (\(method\) (?<method>[^\s]+)|\(model\) (?<model>[^\s]+))?)?/;
+function parseStainlessPath(stainlessPath) {
+	const match = stainlessPath.match(StainlessPathPattern);
+	if (!match?.groups) return null;
+	return {
+		resource: match.groups.resource?.split(".") ?? null,
+		method: match.groups.method ?? null,
+		model: match.groups.model ?? null,
+		routable: match.groups.model ? match[1] : match[0]
+	};
+}
+function trimStainlessPath(stainlessPath) {
+	return stainlessPath.replace(/ > \([^\s]+\)$/, "");
+}
+function getResource(stainlessPath) {
+	return parseStainlessPath(stainlessPath)?.resource?.[0];
+}
+function parseRoute(basePath, route) {
+	if (!route.startsWith(basePath)) return {
+		stainlessPath: "",
+		language: DefaultLanguage
+	};
+	if (basePath && route.startsWith(basePath)) route = route.slice(basePath.length);
+	let stainlessPath = "";
+	let elements = route.slice(1).split("/");
+	let language = DefaultLanguage;
+	if (elements[0] && Languages.includes(elements[0])) {
+		language = elements[0];
+		elements = elements.slice(1);
+	}
+	while (elements.length > 0) switch (elements.shift()) {
+		case "resources":
+			stainlessPath += `(resource) ${elements.shift()}`;
+			break;
+		case "subresources":
+			stainlessPath += `.${elements.shift()}`;
+			break;
+		case "methods":
+			stainlessPath += ` > (method) ${elements.shift()}`;
+			break;
+	}
+	return {
+		stainlessPath,
+		language
+	};
+}
+function generateRoute(basePath, language, stainlessPath) {
+	const parsedPath = parseStainlessPath(stainlessPath);
+	if (!parsedPath) return null;
+	const path = [basePath.endsWith("/") ? basePath.slice(0, -1) : basePath];
+	if (language && language !== DefaultLanguage) path.push(language);
+	const resources = parsedPath.resource.flatMap((name, index) => [index > 0 ? "subresources" : "resources", name]);
+	const resourcePath = parsedPath.model ? resources.slice(0, 2) : resources;
+	path.push(...resourcePath);
+	if (parsedPath.method) path.push("methods", parsedPath.method);
+	return stainlessPath.length > parsedPath.routable.length ? `${path.join("/")}#${encodeURIComponent(stainlessPath)}` : path.join("/");
+}
+function* walkResource(resource, path, includeModels) {
+	yield {
+		data: resource,
+		path
+	};
+	for (const data of Object.values(resource.methods)) yield {
+		data,
+		path: [
+			...path,
+			"methods",
+			data.name
+		]
+	};
+	if (includeModels) for (const data of Object.values(resource.models)) yield {
+		data,
+		path: [
+			...path,
+			"models",
+			data.name
+		]
+	};
+	for (const data of Object.values(resource.subresources ?? {})) yield* walkResource(data, [
+		...path,
+		"subresources",
+		data.name
+	]);
+}
+function* walkTree(spec, includeModels) {
+	for (const data of Object.values(spec.resources)) yield* walkResource(data, ["resources", data.name], includeModels);
+}
+function generateRouteList({ spec, languages, excludeLanguages = [] }) {
+	const entries = Array.from(walkTree(spec));
+	return (languages ?? spec.docs?.languages ?? ["http"]).filter((lang) => Languages.includes(lang) && lang !== "terraform").filter((lang) => !excludeLanguages?.includes(lang)).flatMap((language) => entries.map(({ path, data: { title, kind, stainlessPath } }) => ({
+		title,
+		kind,
+		language,
+		stainlessPath,
+		slug: (language === "http" ? path : [language, ...path]).join("/")
+	})));
+}
+function findNavigationPath(items, target) {
+	for (const item of Object.values(items)) {
+		if (item.stainlessPath === target) return [item.stainlessPath];
+		if (item.kind === "http_method") continue;
+		const path = findNavigationPath([...Object.values(item.methods ?? {}), ...Object.values(item.subresources ?? {})], target);
+		if (path) return [item.stainlessPath, ...path];
+	}
+}
+function expandToElement(el) {
+	while (el) {
+		if (el instanceof HTMLDetailsElement) el.open = true;
+		el = el.parentElement;
+	}
+}
+function scrollToPath(stainlessPath) {
+	const el = document.getElementById(stainlessPath);
+	if (el) {
+		expandToElement(el);
+		el.scrollIntoView({ behavior: "smooth" });
+	}
+}
+function updateHistory(basePath, language, stainlessPath) {
+	const path = generateRoute(basePath, language, stainlessPath);
+	window.history.pushState({
+		stainlessPath,
+		language
+	}, "", path);
+}
+
+//#endregion
+export { walkTree as _, findNavigationPath as a, getLanguageSnippet as c, parseRoute as d, parseStainlessPath as f, updateHistory as g, trimStainlessPath as h, expandToElement as i, getResource as l, scrollToPath as m, Languages as n, generateRoute as o, routing_exports as p, SupportedLanguageSyntaxes as r, generateRouteList as s, LanguageNames as t, isSupportedLanguage as u };

package/dist/routing.d.ts

@@ -0,0 +1,2 @@
+import { a as RouteEntry, b as updateHistory, c as expandToElement, d as generateRouteList, f as getLanguageSnippet, g as parseStainlessPath, h as parseRoute, i as ParsedStainlessPath, l as findNavigationPath, m as isSupportedLanguage, n as LanguageNames, o as SpecTreeEntry, p as getResource, r as Languages, s as SupportedLanguageSyntaxes, t as DocsLanguage, u as generateRoute, v as scrollToPath, x as walkTree, y as trimStainlessPath } from "./routing-BE6Vrs-z.js";
+export { DocsLanguage, LanguageNames, Languages, ParsedStainlessPath, RouteEntry, SpecTreeEntry, SupportedLanguageSyntaxes, expandToElement, findNavigationPath, generateRoute, generateRouteList, getLanguageSnippet, getResource, isSupportedLanguage, parseRoute, parseStainlessPath, scrollToPath, trimStainlessPath, updateHistory, walkTree };

package/dist/routing.js

@@ -42,9 +42,9 @@ var DefaultLanguage = "http";
 var StainlessPathPattern = /(\(resource\) (?<resource>[^\s]+))( > (\(method\) (?<method>[^\s]+)|\(model\) (?<model>[^\s]+))?)?/;
 function parseStainlessPath(stainlessPath) {
   const match = stainlessPath.match(StainlessPathPattern);
-  if (!match) return null;
+  if (!match?.groups) return null;
   return {
-    resource: match.groups.resource.split("."),
+    resource: match.groups.resource?.split(".") ?? null,
     method: match.groups.method ?? null,
     model: match.groups.model ?? null,
     routable: match.groups.model ? match[1] : match[0]
@@ -55,7 +55,7 @@ function trimStainlessPath(stainlessPath) {
 }
 function getResource(stainlessPath) {
   const parsed = parseStainlessPath(stainlessPath);
-  return parsed?.resource[0];
+  return parsed?.resource?.[0];
 }
 function parseRoute(basePath, route) {
   if (!route.startsWith(basePath)) return { stainlessPath: "", language: DefaultLanguage };
@@ -145,7 +145,7 @@ function findNavigationPath(items, target) {
 }
 function expandToElement(el) {
   while (el) {
-    if (el.tagName === "DETAILS") el["open"] = true;
+    if (el instanceof HTMLDetailsElement) el.open = true;
     el = el.parentElement;
   }
 }