apiuikit 0.5.0 → 1.0.0

package/dist/go-CkZ9_bn0.js

@@ -0,0 +1,151 @@
+function c(e) {
+  const n = {
+    keyword: [
+      "break",
+      "case",
+      "chan",
+      "const",
+      "continue",
+      "default",
+      "defer",
+      "else",
+      "fallthrough",
+      "for",
+      "func",
+      "go",
+      "goto",
+      "if",
+      "import",
+      "interface",
+      "map",
+      "package",
+      "range",
+      "return",
+      "select",
+      "struct",
+      "switch",
+      "type",
+      "var"
+    ],
+    type: [
+      "bool",
+      "byte",
+      "complex64",
+      "complex128",
+      "error",
+      "float32",
+      "float64",
+      "int8",
+      "int16",
+      "int32",
+      "int64",
+      "string",
+      "uint8",
+      "uint16",
+      "uint32",
+      "uint64",
+      "int",
+      "uint",
+      "uintptr",
+      "rune"
+    ],
+    literal: [
+      "true",
+      "false",
+      "iota",
+      "nil"
+    ],
+    built_in: [
+      "append",
+      "cap",
+      "close",
+      "complex",
+      "copy",
+      "imag",
+      "len",
+      "make",
+      "new",
+      "panic",
+      "print",
+      "println",
+      "real",
+      "recover",
+      "delete"
+    ]
+  };
+  return {
+    name: "Go",
+    aliases: ["golang"],
+    keywords: n,
+    illegal: "</",
+    contains: [
+      e.C_LINE_COMMENT_MODE,
+      e.C_BLOCK_COMMENT_MODE,
+      {
+        className: "string",
+        variants: [
+          e.QUOTE_STRING_MODE,
+          e.APOS_STRING_MODE,
+          {
+            begin: "`",
+            end: "`"
+          }
+        ]
+      },
+      {
+        className: "number",
+        variants: [
+          {
+            match: /-?\b0[xX]\.[a-fA-F0-9](_?[a-fA-F0-9])*[pP][+-]?\d(_?\d)*i?/,
+            // hex without a present digit before . (making a digit afterwards required)
+            relevance: 0
+          },
+          {
+            match: /-?\b0[xX](_?[a-fA-F0-9])+((\.([a-fA-F0-9](_?[a-fA-F0-9])*)?)?[pP][+-]?\d(_?\d)*)?i?/,
+            // hex with a present digit before . (making a digit afterwards optional)
+            relevance: 0
+          },
+          {
+            match: /-?\b0[oO](_?[0-7])*i?/,
+            // leading 0o octal
+            relevance: 0
+          },
+          {
+            match: /-?\.\d(_?\d)*([eE][+-]?\d(_?\d)*)?i?/,
+            // decimal without a present digit before . (making a digit afterwards required)
+            relevance: 0
+          },
+          {
+            match: /-?\b\d(_?\d)*(\.(\d(_?\d)*)?)?([eE][+-]?\d(_?\d)*)?i?/,
+            // decimal with a present digit before . (making a digit afterwards optional)
+            relevance: 0
+          }
+        ]
+      },
+      {
+        begin: /:=/
+        // relevance booster
+      },
+      {
+        className: "function",
+        beginKeywords: "func",
+        end: "\\s*(\\{|$)",
+        excludeEnd: !0,
+        contains: [
+          e.TITLE_MODE,
+          {
+            className: "params",
+            begin: /\(/,
+            end: /\)/,
+            endsParent: !0,
+            keywords: n,
+            illegal: /["']/
+          }
+        ]
+      }
+    ]
+  };
+}
+export {
+  c as default
+};

package/dist/helpers/codeSamples.d.ts

@@ -0,0 +1,92 @@
+import { availableTargets } from '@readme/httpsnippet';
+import { HttpMethod, OpenAPIParameterData, OpenAPIRequestBodyData, OpenAPISecuritySchemeData, OpenAPIServerData } from '../types/openapi';
+export declare const DEFAULT_CODE_SAMPLE_TARGET = "shell";
+export declare const DEFAULT_CODE_SAMPLE_CLIENT = "curl";
+export type AvailableCodeSampleTarget = ReturnType<typeof availableTargets>[number];
+/** Every target/client @readme/httpsnippet knows how to generate (curl,
+ * fetch, axios, Python requests, Go, Rust, ...), grouped by target — this is
+ * the data source for the language/library dropdown. Pure passthrough kept
+ * here so `@readme/httpsnippet` stays imported in one place. */
+export declare function getAvailableCodeSampleTargets(): AvailableCodeSampleTarget[];
+interface HarNameValue {
+    name: string;
+    value: string;
+}
+/** Loosely-typed HAR request we build ourselves — @readme/httpsnippet's own
+ * `HarRequest` type (from @types/har-format) declares several fields as
+ * required that its `init()` step actually defaults for us at runtime
+ * (httpVersion, headers, cookies, queryString, postData.mimeType). We build
+ * only what we need and cast at the single call site in `generateSnippet`. */
+export interface CodeSampleHarRequest {
+    method: string;
+    url: string;
+    httpVersion: string;
+    headers: HarNameValue[];
+    queryString: HarNameValue[];
+    cookies: HarNameValue[];
+    postData?: {
+        mimeType: string;
+        text: string;
+    };
+}
+interface ResolvedAuthPlaceholder {
+    location: "header" | "query" | "cookie";
+    name: string;
+    value: string;
+}
+interface ResolvedRequestBodyMedia {
+    contentType: string;
+    schema?: unknown;
+    authorExample?: unknown;
+}
+/** Substitutes each `{var}` in a server URL template with its declared
+ * default (or first enum value, or the literal token as a last resort).
+ * Falls back to a placeholder host when the operation has no server at all,
+ * since HTTPSnippet's clients require an absolute URL. */
+export declare function resolveServerBaseUrl(servers?: OpenAPIServerData[]): string;
+/** Precedence: `param.example` → first `param.examples[...].value` →
+ * `schema.example` → first `schema.enum` value → a literal `{name}` token as
+ * a last-resort placeholder, so an undocumented parameter still produces a
+ * valid, copyable (if not runnable as-is) sample. */
+export declare function resolveParamExampleValue(param: OpenAPIParameterData): string;
+/** Substitutes `{token}` path placeholders using the matching `in: "path"`
+ * parameter's example value. Falls back to the literal token when no
+ * matching parameter is supplied — this is what keeps the sample valid even
+ * for operations whose path parameter is only declared at the path-item
+ * level (not merged into `op.parameters` today). */
+export declare function buildRequestUrl(baseUrl: string, path: string, parameters: OpenAPIParameterData[]): string;
+/** Resolves the first `security`/`globalSecurity` OR-alternative against
+ * `components.securitySchemes` into placeholder auth values, routed by
+ * location (header/query/cookie) so the caller can feed them into the
+ * matching HAR array. First code in the library to actually resolve a
+ * security requirement against its scheme definition. */
+export declare function resolveAuthPlaceholders(security: Array<Record<string, string[]>>, securitySchemes?: Record<string, OpenAPISecuritySchemeData>): ResolvedAuthPlaceholder[];
+/** Picks the request body media type to sample: prefers `application/json`,
+ * else the first declared content type. Surfaces the author-supplied
+ * `example`/`examples` value (never read anywhere else in the codebase
+ * today) so the caller can prefer it over a schema-faker-generated one. */
+export declare function pickRequestBodyMedia(requestBody?: OpenAPIRequestBodyData): ResolvedRequestBodyMedia | null;
+interface BuildHarRequestInput {
+    method: HttpMethod;
+    path: string;
+    servers?: OpenAPIServerData[];
+    parameters: OpenAPIParameterData[];
+    security: Array<Record<string, string[]>>;
+    securitySchemes?: Record<string, OpenAPISecuritySchemeData>;
+    media: ResolvedRequestBodyMedia | null;
+    resolvedBodyValue: unknown;
+}
+/** Assembles a HAR request object from a resolved operation — the input to
+ * `generateSnippet`/`@readme/httpsnippet`. Query parameters are supplied only
+ * via the `queryString` array (not appended to `url`); HTTPSnippet's own
+ * `prepare()` step reconstructs and encodes the final URL from that array. */
+export declare function buildHarRequest(input: BuildHarRequestInput): CodeSampleHarRequest;
+/** Generates a single target/client code sample for a resolved HAR request
+ * via @readme/httpsnippet. Fails soft: an unsupported target/client pair or a
+ * malformed request resolves to an empty string rather than throwing, so one
+ * bad operation (or a stale dropdown selection) can't crash the panel.
+ * `target`/`client` come from `getAvailableCodeSampleTargets()`'s own keys, so
+ * they're always valid at the httpsnippet level — the cast below only works
+ * around TargetId/ClientId not being exported types we can name directly. */
+export declare function generateSnippet(harRequest: CodeSampleHarRequest, target: string, client: string): string;
+export {};

package/dist/helpers/exampleSchema.d.ts

@@ -0,0 +1,19 @@
+export type JsonSchema = Record<string, unknown>;
+export declare function includesType(schema: JsonSchema, type: string): boolean;
+/**
+ * Prepares a schema for json-schema-faker's `generate()` so the Example tab
+ * shows something plausible and consistent with the Schema tab:
+ *
+ * - Leftover `$ref` nodes (resolveDocument's cycle cut-points) are unrolled
+ *   exactly one level via `deref`, so a recursive schema's example shows one
+ *   real nested occurrence. The second occurrence of the same ref on a path
+ *   is cut to `{ type: "null" }` when the target allows null, else `{}`.
+ *   Without this, generate() would throw on the unresolvable pointer and the
+ *   tab would silently render nothing.
+ * - `oneOf`/`anyOf` collapse to their first branch, matching the case
+ *   SchemaTree shows by default, instead of letting generate() pick an
+ *   unrelated-looking one.
+ * - Plain string fields get placeholder examples (and `*id` fields a uuid
+ *   format) instead of random character noise.
+ */
+export declare function extendExampleSchema(schema: JsonSchema, deref?: (ref: string) => unknown, active?: Set<object>, refStack?: ReadonlySet<string>): JsonSchema;

package/dist/helpers/hljsLanguages.d.ts

@@ -0,0 +1,6 @@
+export declare function hljsLanguageForTarget(target: string): string;
+export declare function isHljsLanguageReady(hljsName: string): boolean;
+/** Registers a highlight.js grammar on first use. No-op if already
+ * registered, if it's "plaintext" (needs no registration), or if there's no
+ * loader for it (CodeBlock falls back to unhighlighted text in that case). */
+export declare function ensureHljsLanguage(hljsName: string): Promise<void>;

package/dist/helpers/openapiParser.d.ts

@@ -0,0 +1,10 @@
+import { OpenAPIDocumentData } from '../types/openapi';
+import { ConfigInterface } from '../config/config';
+export declare function parseDocument(raw: string): Promise<{
+    diagnostics: unknown[];
+    document: OpenAPIDocumentData | null;
+}>;
+export declare function parseAndRender(raw: string, config?: ConfigInterface): Promise<{
+    diagnostics: unknown[];
+    view: import("react").JSX.Element | null;
+}>;

package/dist/helpers/openapiSearchIndex.d.ts

@@ -0,0 +1,3 @@
+import { OpenAPIDocumentData } from '../types/openapi';
+import { SearchEntry } from './searchIndex';
+export declare function buildOpenAPISearchIndex(openapi: OpenAPIDocumentData): SearchEntry[];

package/dist/helpers/resolveDocument.d.ts

@@ -1 +1,9 @@
+/**
+ * Read-only scan for `$ref` nodes only (not cycles). Used to verify a
+ * caller's `kind="resolved"` promise: leftover refs mean their upstream
+ * resolution isn't doing what they think, while object cycles are a normal
+ * property of parser output and no broken promise. Terminates on cyclic
+ * input via the visited set.
+ */
+export declare const containsRefs: (value: unknown, visited?: Set<object>) => boolean;
 export declare function resolveDocument<T>(doc: T): T;

package/dist/helpers/runtimeExpression.d.ts

@@ -0,0 +1,15 @@
+/**
+ * OpenAPI runtime expressions (`$response.body#/id`) appear in response
+ * `links` parameters and in `callbacks` URL keys. They're written with a `$`
+ * sigil and a JSON Pointer (`#/a/b`), which is precise but hard to read mid
+ * sentence, so both places show them as a plain dotted path instead.
+ */
+/** `$response.body#/data/id` reads as `response.body.data.id`. Non-expressions are left alone. */
+export declare function readableExpression(value: unknown): string;
+/**
+ * A callback's key is a URL template that embeds expressions in braces, and
+ * may wrap them in literal URL text: `{$request.body#/callbackUrl}` or
+ * `https://example.com/{$request.body#/id}/events`. Only the embedded
+ * expressions are rewritten; the braces stay, since they mark the placeholder.
+ */
+export declare function readableCallbackUrl(url: string): string;

package/dist/helpers/schemaExample.d.ts

@@ -0,0 +1,9 @@
+export type JsonSchema = Record<string, unknown>;
+export declare function extendExampleSchema(schema: JsonSchema, active?: Set<object>): JsonSchema;
+/**
+ * Generates a synthetic example value from a JSON Schema via json-schema-faker.
+ * Fails soft: circular or otherwise ungenerable schemas resolve to `undefined`
+ * rather than throwing/rejecting, since callers render "no example" instead of
+ * crashing.
+ */
+export declare function generateSchemaExample(schema: JsonSchema): Promise<unknown>;

package/dist/helpers/searchIndex.d.ts

@@ -1,6 +1,6 @@
 import { AsyncAPIDocumentData } from '../types/schema';
-export type SearchTab = "operations" | "messages" | "schemas" | "info" | "servers";
-export type SearchType = "operation" | "message" | "schema" | "info" | "server";
+export type SearchTab = "operations" | "messages" | "schemas" | "info" | "servers" | "endpoints" | "webhooks";
+export type SearchType = "operation" | "message" | "schema" | "info" | "server" | "endpoint" | "webhook";
 export interface SearchEntry {
     id: string;
     targetId: string;
@@ -15,4 +15,7 @@ export interface SearchEntry {
     focusSection?: string;
     schemaFocusTokens?: string[];
 }
+export declare const normalizeString: (value: unknown) => string;
+/** Walks a single JSON Schema node into flat search entries — spec-agnostic (AsyncAPI and OpenAPI schemas share the same shape), reused by openapiSearchIndex.ts. */
+export declare const addSchemaEntries: (entries: SearchEntry[], schema: unknown, schemaKey: string, schemaName: string) => void;
 export declare function buildSearchIndex(asyncapi: AsyncAPIDocumentData): SearchEntry[];

package/dist/helpers/tests/codeSamples.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helpers/tests/exampleSchema.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helpers/tests/openapiSearchIndex.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helpers/tests/toMarkdown.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helpers/toMarkdown.d.ts

@@ -0,0 +1,20 @@
+import { AsyncAPIDocumentData } from '../types/schema';
+import { HttpMethod, OpenAPIDocumentData } from '../types/openapi';
+type Deref = (ref: string) => unknown;
+export declare function asyncApiToMarkdown(doc: AsyncAPIDocumentData, deref: Deref): string;
+/** Builds a self-contained Markdown snippet for a single AsyncAPI operation:
+ * doc info + servers, followed by that one operation's section (see
+ * `operationSectionToMarkdown`). Used by the per-operation copy button, as
+ * opposed to `asyncApiToMarkdown`'s whole-document export. */
+export declare function asyncApiOperationToMarkdown(doc: AsyncAPIDocumentData, key: string, deref: Deref): string;
+export declare function openApiToMarkdown(doc: OpenAPIDocumentData, deref: Deref): string;
+/**
+ * Builds a self-contained Markdown snippet for a single OpenAPI endpoint:
+ * doc info + servers (so the snippet stands alone without the rest of the
+ * document) followed by that one endpoint's fully-dereferenced parameters,
+ * request body, and responses. Used by the per-endpoint copy button in the
+ * Endpoints side panel (Paths.tsx), as opposed to `openApiToMarkdown`'s
+ * whole-document export.
+ */
+export declare function openApiEndpointToMarkdown(doc: OpenAPIDocumentData, method: HttpMethod, path: string, deref: Deref): string;
+export {};

package/dist/hooks/useDocumentProviderValue.d.ts

@@ -0,0 +1,27 @@
+import { ConfigInterface } from '../config';
+import { SpecType } from '../contexts';
+/**
+ * Builds the shared DocumentContext value (deref resolver, portal/root refs,
+ * theme-derived settings) plus the CSS custom properties for the theme,
+ * used by both AsyncAPIDocumentProvider and OpenAPIDocumentProvider, which
+ * differ only in the spec type they declare and the portal element's
+ * className. Generic so the returned contextValue keeps the caller's literal
+ * `specType` and document type, and thus lands as the right member of the
+ * DocumentContextValue union.
+ */
+export declare function useDocumentProviderValue<S extends SpecType, D extends object>(specType: S, document: D, config?: ConfigInterface): {
+    contextValue: {
+        specType: S;
+        document: D;
+        deref: (refPath: string) => unknown;
+        portalHost: HTMLDivElement | null;
+        rootElement: HTMLDivElement | null;
+        defaultSchemaExpanded: boolean;
+        depthColors: string[];
+        showExtensions: boolean;
+        showCodeSamples: boolean;
+    };
+    themeVars: Record<string, string>;
+    setPortalHost: import('react').Dispatch<import('react').SetStateAction<HTMLDivElement | null>>;
+    setRootElement: import('react').Dispatch<import('react').SetStateAction<HTMLDivElement | null>>;
+};

package/dist/hooks/useFuseSearch.d.ts

@@ -0,0 +1,14 @@
+import { SearchEntry } from '../helpers/searchIndex';
+export interface UseSpecSearchOptions {
+    threshold?: number;
+    limit?: number;
+    /** Delay before a query change triggers a search, in ms. Defaults to 150. */
+    debounceMs?: number;
+}
+/** Shared debounce + Fuse setup behind useSpecSearch (AsyncAPI) and useOpenAPISearch — only the index-builder differs between specs. */
+export declare function useFuseSearch<T>(document: T, buildIndex: (document: T) => SearchEntry[], options?: UseSpecSearchOptions): {
+    query: string;
+    setQuery: import('react').Dispatch<import('react').SetStateAction<string>>;
+    results: SearchEntry[];
+    searchIndex: SearchEntry[];
+};

package/dist/hooks/useOpenAPISearch.d.ts

@@ -0,0 +1,9 @@
+import { OpenAPIDocumentData } from '../types/openapi';
+import { UseSpecSearchOptions } from './useFuseSearch';
+/** Mirrors useSpecSearch (AsyncAPI), built on buildOpenAPISearchIndex instead. */
+export declare function useOpenAPISearch(openapi: OpenAPIDocumentData, options?: UseSpecSearchOptions): {
+    query: string;
+    setQuery: import('react').Dispatch<import('react').SetStateAction<string>>;
+    results: import('../helpers/searchIndex').SearchEntry[];
+    searchIndex: import('../helpers/searchIndex').SearchEntry[];
+};

package/dist/hooks/useSearchResultFocus.d.ts

@@ -0,0 +1,18 @@
+export interface ActiveHighlight {
+    targetId: string;
+    query: string;
+    highlight: boolean;
+}
+/**
+ * Scrolls to and highlights a search result's target element once it exists
+ * in the DOM, retrying since the target may not be rendered yet (e.g. the tab
+ * holding it just changed). Shared behind both AsyncAPI/Layout.tsx and
+ * OpenAPI/Layout.tsx, which otherwise duplicated this effect verbatim.
+ *
+ * `deps` should list every piece of state that changes which DOM subtree is
+ * currently rendered (active tab, selected item keys, focus targets, ...) —
+ * anything that could change whether `activeHighlight.targetId` already
+ * exists in the DOM. Its length must stay constant across renders for a given
+ * call site, same as any other hook dependency list.
+ */
+export declare function useSearchResultFocus(activeHighlight: ActiveHighlight | null, deps: readonly unknown[]): void;

package/dist/hooks/useSpecLayoutController.d.ts

@@ -0,0 +1,51 @@
+import { ContentTabItem } from '../components/ContentTab';
+import { SearchEntry } from '../helpers/searchIndex';
+export interface SchemaFocusTarget {
+    tokens: string[];
+    id: string;
+}
+export interface LayoutSection<TabKey extends string> {
+    id: TabKey | "servers";
+    /** Config `show` flag for this section: a hidden section reads back a null selection. */
+    visible: boolean;
+}
+export interface SpecLayoutControllerOptions<TabKey extends string> {
+    /** Content tabs currently visible (already filtered by config.show). */
+    tabs: ContentTabItem[];
+    /** Tab to fall back to when no tabs are visible or the stored tab gets hidden. */
+    defaultTab: TabKey;
+    isTabKey: (value: string) => value is TabKey;
+    /**
+     * Selectable sections in nav priority order: the tab keys, then "servers".
+     * Must keep a constant length across renders (it feeds a hook dependency list).
+     */
+    sections: readonly LayoutSection<TabKey>[];
+    /** Current search input, used to tag highlights and clear them when it empties. */
+    searchQuery: string;
+}
+/**
+ * Owns the tab/selection/search-focus state machine shared by the AsyncAPI and
+ * OpenAPI layouts, which previously duplicated it verbatim. Each layout
+ * supplies only its tab definitions, section visibility, and content
+ * renderers; everything about "what is selected where, and what should scroll
+ * into view" lives here.
+ */
+export declare function useSpecLayoutController<TabKey extends string>({ tabs, defaultTab, isTabKey, sections, searchQuery, }: SpecLayoutControllerOptions<TabKey>): {
+    effectiveTab: TabKey;
+    focusTab: (tab: TabKey) => void;
+    /** What the sidebar nav should show as active: the focused section, falling back to the content tab. */
+    navActiveSection: "servers" | TabKey;
+    /** Per-section selections, clamped to visible sections. */
+    selected: Record<"servers" | TabKey, string | null>;
+    setSelectedKey: (section: "servers" | TabKey, key: string | null) => void;
+    selectedNavItem: {
+        tab: "servers" | TabKey;
+        key: NonNullable<Record<"servers" | TabKey, string | null>["servers" | TabKey]>;
+    } | null;
+    handleSearchSelect: (entry: SearchEntry) => void;
+    handleNavItemSelect: (tab: TabKey, key: string) => void;
+    handleNavServerSelect: (key: string) => void;
+    handleContentTabChange: (id: string) => void;
+    focusSection: string | null;
+    schemaFocusTarget: SchemaFocusTarget | null;
+};

package/dist/hooks/useSpecSearch.d.ts

@@ -1,10 +1,6 @@
 import { AsyncAPIDocumentData } from '../types/schema';
-export interface UseSpecSearchOptions {
-    threshold?: number;
-    limit?: number;
-    /** Delay before a query change triggers a search, in ms. Defaults to 150. */
-    debounceMs?: number;
-}
+import { UseSpecSearchOptions } from './useFuseSearch';
+export type { UseSpecSearchOptions };
 export declare function useSpecSearch(asyncapi: AsyncAPIDocumentData, options?: UseSpecSearchOptions): {
     query: string;
     setQuery: import('react').Dispatch<import('react').SetStateAction<string>>;

package/dist/http--XH4hLDt.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function c(n){const s=n.regex,e="HTTP/([32]|1\\.[01])",i=/[A-Za-z][A-Za-z0-9-]*/,t={className:"attribute",begin:s.concat("^",i,"(?=\\:\\s)"),starts:{contains:[{className:"punctuation",begin:/: /,relevance:0,starts:{end:"$",relevance:0}}]}},a=[t,{begin:"\\n\\n",starts:{subLanguage:[],endsWithParent:!0}}];return{name:"HTTP",aliases:["https"],illegal:/\S/,contains:[{begin:"^(?="+e+" \\d{3})",end:/$/,contains:[{className:"meta",begin:e},{className:"number",begin:"\\b\\d{3}\\b"}],starts:{end:/\b\B/,illegal:/\S/,contains:a}},{begin:"(?=^[A-Z]+ (.*?) "+e+"$)",end:/$/,contains:[{className:"string",begin:" ",end:" ",excludeBegin:!0,excludeEnd:!0},{className:"meta",begin:e},{className:"keyword",begin:"[A-Z]+"}],starts:{end:/\b\B/,illegal:/\S/,contains:a}},n.inherit(t,{relevance:0})]}}exports.default=c;

package/dist/http-DKeNlJKS.js

@@ -0,0 +1,85 @@
+function c(n) {
+  const s = n.regex, e = "HTTP/([32]|1\\.[01])", i = /[A-Za-z][A-Za-z0-9-]*/, a = {
+    className: "attribute",
+    begin: s.concat("^", i, "(?=\\:\\s)"),
+    starts: { contains: [
+      {
+        className: "punctuation",
+        begin: /: /,
+        relevance: 0,
+        starts: {
+          end: "$",
+          relevance: 0
+        }
+      }
+    ] }
+  }, t = [
+    a,
+    {
+      begin: "\\n\\n",
+      starts: {
+        subLanguage: [],
+        endsWithParent: !0
+      }
+    }
+  ];
+  return {
+    name: "HTTP",
+    aliases: ["https"],
+    illegal: /\S/,
+    contains: [
+      // response
+      {
+        begin: "^(?=" + e + " \\d{3})",
+        end: /$/,
+        contains: [
+          {
+            className: "meta",
+            begin: e
+          },
+          {
+            className: "number",
+            begin: "\\b\\d{3}\\b"
+          }
+        ],
+        starts: {
+          end: /\b\B/,
+          illegal: /\S/,
+          contains: t
+        }
+      },
+      // request
+      {
+        begin: "(?=^[A-Z]+ (.*?) " + e + "$)",
+        end: /$/,
+        contains: [
+          {
+            className: "string",
+            begin: " ",
+            end: " ",
+            excludeBegin: !0,
+            excludeEnd: !0
+          },
+          {
+            className: "meta",
+            begin: e
+          },
+          {
+            className: "keyword",
+            begin: "[A-Z]+"
+          }
+        ],
+        starts: {
+          end: /\b\B/,
+          illegal: /\S/,
+          contains: t
+        }
+      },
+      // to allow headers to work even without a preamble
+      n.inherit(a, { relevance: 0 })
+    ]
+  };
+}
+export {
+  c as default
+};

package/dist/icons/Copy.d.ts

@@ -0,0 +1,6 @@
+interface IconCopyProps {
+    className?: string;
+}
+/** The two-overlapping-sheets copy glyph, as distinct from Clipboard's clipboard-and-clip. */
+export default function IconCopy({ className }: IconCopyProps): import("react").JSX.Element;
+export {};

package/dist/icons/Info.d.ts

@@ -0,0 +1,5 @@
+interface IconInfoProps {
+    className?: string;
+}
+export default function IconInfo({ className }: IconInfoProps): import("react").JSX.Element;
+export {};