@wallarm-org/design-system 1.30.0 → 1.31.0

package/dist/components/CodeEditor/engine/schema/hover.js

@@ -0,0 +1,73 @@
+import { hoverTooltip } from "@codemirror/view";
+import { getJsonPointers, readRegionData } from "../languages/jsonPointers.js";
+import { getCompiledSchema } from "./loadSchema.js";
+const CONTAINER_START = /^[[{]/;
+const hoverTargetAt = (state, pos, region)=>{
+    let best = null;
+    const consider = (candidate)=>{
+        if (pos < candidate.from || pos > candidate.to) return;
+        if (!best || candidate.to - candidate.from < best.to - best.from) best = candidate;
+    };
+    for (const entry of getJsonPointers(state, region).values()){
+        if (void 0 !== entry.keyFrom && void 0 !== entry.keyTo) consider({
+            pointer: entry.pointer,
+            from: entry.keyFrom,
+            to: entry.keyTo
+        });
+        const isContainer = CONTAINER_START.test(state.sliceDoc(entry.valueFrom, entry.valueFrom + 1));
+        if (!isContainer) consider({
+            pointer: entry.pointer,
+            from: entry.valueFrom,
+            to: entry.valueTo
+        });
+    }
+    return best;
+};
+const textOf = (value)=>'string' == typeof value && '' !== value.trim() ? value : void 0;
+const renderHover = (title, description)=>{
+    const dom = document.createElement('div');
+    dom.className = 'flex max-w-[320px] flex-col gap-4 px-8 py-4 text-xs text-text-primary-alt';
+    dom.setAttribute('data-schema-hover', '');
+    if (title) {
+        const heading = document.createElement('div');
+        heading.className = 'font-medium';
+        heading.textContent = title;
+        dom.append(heading);
+    }
+    if (description) {
+        const body = document.createElement('div');
+        body.className = 'whitespace-pre-wrap text-text-primary-alt';
+        body.textContent = description;
+        dom.append(body);
+    }
+    return dom;
+};
+const hoverFor = async (state, pos, getRegion, schema)=>{
+    const region = getRegion(state);
+    if (!region || pos < region.from || pos > region.to) return null;
+    const target = hoverTargetAt(state, pos, region);
+    if (!target) return null;
+    const root = await getCompiledSchema(schema);
+    const { node } = root.getNode(target.pointer, readRegionData(state, region));
+    if (!node) return null;
+    const title = textOf(node.schema.title);
+    const description = textOf(node.schema.description);
+    if (!title && !description) return null;
+    return {
+        pos: target.from,
+        end: target.to,
+        above: true,
+        create: ()=>({
+                dom: renderHover(title, description)
+            })
+    };
+};
+const schemaHoverSource = (getSchema, getRegion)=>(view, pos)=>{
+        const schema = getSchema();
+        if (void 0 === schema) return Promise.resolve(null);
+        return hoverFor(view.state, pos, getRegion, schema).catch(()=>null);
+    };
+const schemaHover = (getSchema, getRegion)=>[
+        hoverTooltip(schemaHoverSource(getSchema, getRegion))
+    ];
+export { schemaHover, schemaHoverSource };

package/dist/components/CodeEditor/engine/schema/loadSchema.d.ts

@@ -0,0 +1,19 @@
+import type { SchemaNode } from 'json-schema-library';
+import type { JsonSchema } from '../../types';
+/** Library types for the other schema modules, so this file stays the single import site. */
+export type { JsonError, JsonSchema as LibraryJsonSchema, SchemaNode, } from 'json-schema-library';
+type SchemaLibrary = typeof import('json-schema-library');
+/**
+ * The only place `json-schema-library` is imported (spec D8): a separate chunk that
+ * loads on first use. The promise is cached; a failed load is retried on the next call.
+ */
+export declare const loadSchemaLibrary: () => Promise<SchemaLibrary>;
+/** `compileSchema(schema)` from the lazily loaded library, cached per schema identity. */
+export declare const getCompiledSchema: (schema: JsonSchema) => Promise<SchemaNode>;
+/** `JSON.parse` without throwing: `{ ok: false }` for invalid JSON. */
+export declare const parseJson: (text: string) => {
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+};

package/dist/components/CodeEditor/engine/schema/loadSchema.js

@@ -0,0 +1,32 @@
+let libraryPromise = null;
+const loadSchemaLibrary = ()=>{
+    libraryPromise ??= import("json-schema-library").catch((error)=>{
+        libraryPromise = null;
+        throw error;
+    });
+    return libraryPromise;
+};
+const compiledObjects = new WeakMap();
+const compiledBooleans = new Map();
+const getCompiledSchema = async (schema)=>{
+    const cached = 'boolean' == typeof schema ? compiledBooleans.get(schema) : compiledObjects.get(schema);
+    if (cached) return cached;
+    const { compileSchema } = await loadSchemaLibrary();
+    const node = compileSchema(schema);
+    if ('boolean' == typeof schema) compiledBooleans.set(schema, node);
+    else compiledObjects.set(schema, node);
+    return node;
+};
+const parseJson = (text)=>{
+    try {
+        return {
+            ok: true,
+            value: JSON.parse(text)
+        };
+    } catch  {
+        return {
+            ok: false
+        };
+    }
+};
+export { getCompiledSchema, loadSchemaLibrary, parseJson };

package/dist/components/CodeEditor/engine/schema/validate.d.ts

@@ -0,0 +1,9 @@
+import type { Diagnostic } from '@codemirror/lint';
+import type { EditorState } from '@codemirror/state';
+import type { JsonSchema } from '../../types';
+import { type JsonRegion } from '../languages/jsonPointers';
+/**
+ * JSON Schema errors for the JSON in `region` (spec §7.13). Returns `[]` when the slice
+ * is not valid JSON — syntax errors are reported by the syntax source (Task 12).
+ */
+export declare const validateAgainstSchema: (state: EditorState, region: JsonRegion, schema: JsonSchema) => Promise<Diagnostic[]>;

package/dist/components/CodeEditor/engine/schema/validate.js

@@ -0,0 +1,67 @@
+import { getJsonPointers } from "../languages/jsonPointers.js";
+import { getCompiledSchema, parseJson } from "./loadSchema.js";
+const REQUIRED_ERROR = 'required-property-error';
+const ADDITIONAL_PROPERTY_ERROR = 'no-additional-properties-error';
+const normalizeLibraryPointer = (pointer)=>pointer.startsWith('#') ? pointer.slice(1) : pointer;
+const unescapeSegment = (segment)=>segment.replaceAll('~1', '/').replaceAll('~0', '~');
+const toUnescapedPointer = (pointer)=>pointer.split('/').map(unescapeSegment).join('/');
+const parentPointer = (pointer)=>{
+    const slash = pointer.lastIndexOf('/');
+    return slash < 0 ? null : pointer.slice(0, slash);
+};
+const findEntry = (pointers, unescaped, libraryPointer)=>{
+    for(let pointer = normalizeLibraryPointer(libraryPointer); null !== pointer; pointer = parentPointer(pointer)){
+        const entry = pointers.get(pointer) ?? unescaped.get(pointer);
+        if (entry) return entry;
+    }
+};
+const rangeFor = (error, entry, region)=>{
+    if (!entry) return {
+        from: region.from,
+        to: Math.min(region.from + 1, region.to)
+    };
+    if (error.code === REQUIRED_ERROR) return {
+        from: entry.valueFrom,
+        to: entry.valueFrom + 1
+    };
+    if (error.code === ADDITIONAL_PROPERTY_ERROR && void 0 !== entry.keyFrom && void 0 !== entry.keyTo) return {
+        from: entry.keyFrom,
+        to: entry.keyTo
+    };
+    if (entry.valueTo > entry.valueFrom) return {
+        from: entry.valueFrom,
+        to: entry.valueTo
+    };
+    if (void 0 !== entry.keyFrom && void 0 !== entry.keyTo) return {
+        from: entry.keyFrom,
+        to: entry.keyTo
+    };
+    return {
+        from: region.from,
+        to: Math.min(region.from + 1, region.to)
+    };
+};
+const validateAgainstSchema = async (state, region, schema)=>{
+    const parsed = parseJson(state.sliceDoc(region.from, region.to));
+    if (!parsed.ok) return [];
+    const node = await getCompiledSchema(schema);
+    const { errors } = node.validate(parsed.value);
+    if (0 === errors.length) return [];
+    const pointers = getJsonPointers(state, region);
+    const unescaped = new Map();
+    for (const [pointer, entry] of pointers){
+        const key = toUnescapedPointer(pointer);
+        if (!unescaped.has(key)) unescaped.set(key, entry);
+    }
+    return errors.map((error)=>{
+        const { from, to } = rangeFor(error, findEntry(pointers, unescaped, error.data.pointer), region);
+        return {
+            from,
+            to,
+            severity: 'error',
+            source: 'schema',
+            message: error.message
+        };
+    });
+};
+export { validateAgainstSchema };

package/dist/components/CodeEditor/engine/search.d.ts

@@ -0,0 +1,13 @@
+import { type Extension, Facet } from '@codemirror/state';
+import type { PortalRegistry } from '../lib/portalRegistry';
+/**
+ * `true` once a search extension is configured. `api.openSearch` checks it so
+ * `openSearchPanel` never falls back to CodeMirror's own un-themed panel.
+ */
+export declare const searchConfigured: Facet<boolean, boolean>;
+/** Find / replace panel (spec §7.11): DS components rendered into CodeMirror's top panel via portals. */
+export declare const searchExtension: (config: {
+    portals: PortalRegistry;
+    readOnly: boolean;
+    testId: string | undefined;
+}) => Extension;

package/dist/components/CodeEditor/engine/search.js

@@ -0,0 +1,84 @@
+import { createElement } from "react";
+import { getSearchQuery, gotoLine, search, searchKeymap } from "@codemirror/search";
+import { EditorState, Facet } from "@codemirror/state";
+import { EditorView, keymap } from "@codemirror/view";
+import { SearchPanel } from "./SearchPanel.js";
+import { countMatches } from "./searchMatches.js";
+const searchConfigured = Facet.define({
+    combine: (values)=>values.some(Boolean)
+});
+const searchPanelConfig = Facet.define({
+    combine: (values)=>values[0] ?? null
+});
+const renderPanel = (view, state, config)=>{
+    const query = getSearchQuery(state);
+    return createElement(SearchPanel, {
+        view,
+        query,
+        matchCount: query.valid ? countMatches(state, query) : null,
+        readOnly: config.readOnly || state.readOnly,
+        testId: config.testId
+    });
+};
+const needsRender = (update)=>update.docChanged || update.state.readOnly !== update.startState.readOnly || update.state.facet(searchPanelConfig) !== update.startState.facet(searchPanelConfig) || !getSearchQuery(update.state).eq(getSearchQuery(update.startState));
+const createSearchPanel = (view)=>{
+    const dom = document.createElement('div');
+    let registered = null;
+    return {
+        dom,
+        top: true,
+        mount () {
+            const config = view.state.facet(searchPanelConfig);
+            if (!config) return;
+            registered = {
+                id: config.portals.register(dom, renderPanel(view, view.state, config)),
+                portals: config.portals
+            };
+        },
+        update (update) {
+            const config = update.state.facet(searchPanelConfig);
+            if (!registered || !config || !needsRender(update)) return;
+            registered.portals.update(registered.id, renderPanel(view, update.state, config));
+        },
+        destroy () {
+            registered?.portals.unregister(registered.id);
+            registered = null;
+        }
+    };
+};
+const SEARCH_PHRASES = {
+    'replaced $ matches': 'Occurrences replaced: $'
+};
+const dsSearchKeymap = searchKeymap.filter((binding)=>binding.run !== gotoLine);
+const searchTheme = EditorView.theme({
+    '.cm-panels': {
+        backgroundColor: 'transparent',
+        color: 'inherit'
+    },
+    '.cm-panels.cm-panels-top': {
+        borderBottom: 'none'
+    },
+    '.cm-searchMatch': {
+        backgroundColor: 'color-mix(in oklab, var(--color-syntax-highlight-warning-indicator) 24%, transparent)'
+    },
+    '.cm-searchMatch.cm-searchMatch-selected': {
+        backgroundColor: 'color-mix(in oklab, var(--color-syntax-highlight-warning-indicator) 48%, transparent)',
+        outline: '1px solid var(--color-syntax-highlight-warning-indicator)'
+    }
+});
+const searchExtension = (config)=>[
+        search({
+            top: true,
+            createPanel: createSearchPanel
+        }),
+        searchPanelConfig.of({
+            portals: config.portals,
+            readOnly: config.readOnly,
+            testId: config.testId
+        }),
+        searchConfigured.of(true),
+        keymap.of(dsSearchKeymap),
+        EditorState.phrases.of(SEARCH_PHRASES),
+        searchTheme
+    ];
+export { searchConfigured, searchExtension };

package/dist/components/CodeEditor/engine/searchMatches.d.ts

@@ -0,0 +1,8 @@
+import type { SearchQuery } from '@codemirror/search';
+import type { EditorState } from '@codemirror/state';
+/** Match counting stops here; the panel then shows `1000+ matches`. */
+export declare const MATCH_COUNT_LIMIT = 1000;
+/** Number of matches of `query` in the document, capped at `MATCH_COUNT_LIMIT + 1`. */
+export declare const countMatches: (state: EditorState, query: SearchQuery) => number;
+/** Screen-reader and visible text for a match count. */
+export declare const matchCountMessage: (count: number) => string;

package/dist/components/CodeEditor/engine/searchMatches.js

@@ -0,0 +1,15 @@
+const MATCH_COUNT_LIMIT = 1000;
+const countMatches = (state, query)=>{
+    if (!query.valid) return 0;
+    const cursor = query.getCursor(state);
+    let count = 0;
+    while(count <= MATCH_COUNT_LIMIT && !cursor.next().done)count++;
+    return count;
+};
+const matchCountMessage = (count)=>{
+    if (0 === count) return 'No matches';
+    if (1 === count) return '1 match';
+    if (count > MATCH_COUNT_LIMIT) return `${MATCH_COUNT_LIMIT}+ matches`;
+    return `${count} matches`;
+};
+export { MATCH_COUNT_LIMIT, countMatches, matchCountMessage };

package/dist/components/CodeEditor/engine/theme.d.ts

@@ -0,0 +1,8 @@
+import type { Extension } from '@codemirror/state';
+export declare const editorTheme: Extension;
+/**
+ * Height clamp for maxLines / Show more (spec §7.8); `null` = no clamp. Memoised by height:
+ * every `EditorView.theme` call mounts a new style module, so toggling the clamp would
+ * otherwise pile up CSS rules.
+ */
+export declare const maxHeightTheme: (maxHeight: number | null) => Extension;

package/dist/components/CodeEditor/engine/theme.js

@@ -0,0 +1,89 @@
+import { Decoration, EditorView, ViewPlugin } from "@codemirror/view";
+const CODE_SNIPPET_BG = 'linear-gradient(var(--color-component-code-snippet-bg), var(--color-component-code-snippet-bg)), var(--color-bg-page-bg)';
+const snippetTheme = EditorView.theme({
+    '&': {
+        color: 'var(--color-syntax-no-syntax)',
+        backgroundColor: 'transparent'
+    },
+    '&.cm-focused': {
+        outline: 'none'
+    },
+    '.cm-scroller': {
+        fontFamily: 'inherit',
+        lineHeight: '20px'
+    },
+    '.cm-content': {
+        padding: '8px 0',
+        caretColor: 'var(--color-syntax-no-syntax)'
+    },
+    '.cm-line': {
+        padding: '0 12px'
+    },
+    '&:has(.cm-gutters) .cm-line': {
+        paddingLeft: '8px'
+    },
+    '.cm-lineWrapping': {
+        wordBreak: 'break-all'
+    },
+    '.cm-gutters': {
+        background: CODE_SNIPPET_BG,
+        color: 'inherit',
+        border: 'none'
+    },
+    '.cm-gutters.cm-gutters-before': {
+        borderRightWidth: '0'
+    },
+    '.cm-cursor, .cm-dropCursor': {
+        borderLeftColor: 'var(--color-syntax-no-syntax)'
+    },
+    '.cm-selectionBackground': {
+        background: 'var(--color-syntax-highlight-selected-highlight)'
+    },
+    '&.cm-focused > .cm-scroller > .cm-selectionLayer .cm-selectionBackground': {
+        background: 'var(--color-syntax-highlight-selected-highlight)'
+    },
+    '.cm-matchingBracket': {
+        backgroundColor: 'var(--color-syntax-highlight-neutral-highlight)'
+    },
+    '&.cm-focused .cm-matchingBracket': {
+        backgroundColor: 'var(--color-syntax-highlight-neutral-highlight)'
+    },
+    '&.cm-focused .cm-nonmatchingBracket': {
+        backgroundColor: 'var(--color-syntax-highlight-error-highlight)'
+    }
+});
+const selectedTextMark = Decoration.mark({
+    class: 'text-syntax-highlight-selected-code! [&_*]:text-syntax-highlight-selected-code!'
+});
+const buildSelectedText = (state)=>Decoration.set(state.selection.ranges.filter((range)=>!range.empty).map((range)=>selectedTextMark.range(range.from, range.to)), true);
+const selectedTextColor = ViewPlugin.fromClass(class {
+    decorations;
+    constructor(view){
+        this.decorations = buildSelectedText(view.state);
+    }
+    update(update) {
+        if (update.selectionSet || update.docChanged) this.decorations = buildSelectedText(update.state);
+    }
+}, {
+    decorations: (plugin)=>plugin.decorations
+});
+const editorTheme = [
+    snippetTheme,
+    selectedTextColor
+];
+const maxHeightThemes = new Map();
+const maxHeightTheme = (maxHeight)=>{
+    if (null === maxHeight) return [];
+    let theme = maxHeightThemes.get(maxHeight);
+    if (!theme) {
+        theme = EditorView.theme({
+            '.cm-scroller': {
+                maxHeight: `${maxHeight}px`,
+                overflowY: 'auto'
+            }
+        });
+        maxHeightThemes.set(maxHeight, theme);
+    }
+    return theme;
+};
+export { editorTheme, maxHeightTheme };

package/dist/components/CodeEditor/engine/types.d.ts

@@ -0,0 +1,44 @@
+import type { EditorView } from '@codemirror/view';
+import type { SyntaxAdapter } from '../../CodeSnippet/adapters/types';
+import type { LineConfig } from '../../CodeSnippet/CodeSnippetContext';
+import type { PortalRegistry } from '../lib/portalRegistry';
+import type { CodeEditorApi, CodeEditorCompletionSource, CodeEditorDiagnostic, CodeEditorFolds, CodeEditorLanguage, JsonSchema } from '../types';
+/** Everything the engine needs to build or reconfigure an editor. Plain data, no CM types. */
+export interface EngineOptions {
+    value: string;
+    documentId: string | undefined;
+    language: CodeEditorLanguage;
+    readOnly: boolean;
+    wrapLines: boolean;
+    startingLineNumber: number;
+    lineNumbers: boolean;
+    lines: Record<number, LineConfig>;
+    folds: CodeEditorFolds | undefined;
+    adapter: SyntaxAdapter<string>;
+    original: string | undefined;
+    schema: JsonSchema | undefined;
+    completions: readonly CodeEditorCompletionSource[];
+    diagnostics: readonly CodeEditorDiagnostic[];
+    contentAttributes: Record<string, string>;
+    /** Root data-testid base; engine derives `${testId}--editor`, `--gutter`, `--search`, `--fold-toggle`, `--fold-summary` */
+    testId: string | undefined;
+    cspNonce: string | undefined;
+    /** px, null = no clamp */
+    maxHeight: number | null;
+}
+/** Callbacks from the engine back into React. */
+export interface EngineCallbacks {
+    onChange: (value: string) => void;
+    onDiagnosticsChange: (diagnostics: CodeEditorDiagnostic[]) => void;
+    onVisibleRowCountChange: (rows: number) => void;
+    portals: PortalRegistry;
+}
+/** Returned by `createEditor()`. */
+export interface EditorHandle {
+    /** Compares with previous options, reconfigures changed compartments, syncs value/documentId */
+    update: (options: EngineOptions) => void;
+    api: CodeEditorApi;
+    /** For tests only */
+    view: EditorView;
+    destroy: () => void;
+}

package/dist/components/CodeEditor/hooks/useCodeEditor.d.ts

@@ -0,0 +1,6 @@
+import type { CodeEditorApi } from '../types';
+/**
+ * Returns the editor's imperative API from inside `CodeEditorRoot`
+ * (e.g. in custom header actions). Same object as `apiRef`.
+ */
+export declare const useCodeEditor: () => CodeEditorApi;

package/dist/components/CodeEditor/hooks/useCodeEditor.js

@@ -0,0 +1,3 @@
+import { useCodeEditorContext } from "../CodeEditorContext.js";
+const useCodeEditor = ()=>useCodeEditorContext().api;
+export { useCodeEditor };

package/dist/components/CodeEditor/index.d.ts

@@ -0,0 +1,6 @@
+export { CodeEditorContent, type CodeEditorContentProps } from './CodeEditorContent';
+export { CodeEditorRoot, type CodeEditorRootProps, type CodeEditorRootProps as CodeEditorProps, } from './CodeEditorRoot';
+export { useCodeEditor } from './hooks/useCodeEditor';
+export { httpCompletions } from './lib/httpCompletions';
+export { CODE_EDITOR_KEYBOARD_HINT } from './lib/keyboardHint';
+export type { CodeEditorApi, CodeEditorCompletion, CodeEditorCompletionContext, CodeEditorCompletionSource, CodeEditorDiagnostic, CodeEditorFolds, CodeEditorHttpContext, CodeEditorLanguage, CodeEditorPosition, JsonSchema, } from './types';

package/dist/components/CodeEditor/index.js

@@ -0,0 +1,5 @@
+export { CodeEditorContent } from "./CodeEditorContent.js";
+export { CodeEditorRoot } from "./CodeEditorRoot.js";
+export { useCodeEditor } from "./hooks/useCodeEditor.js";
+export { httpCompletions } from "./lib/httpCompletions.js";
+export { CODE_EDITOR_KEYBOARD_HINT } from "./lib/keyboardHint.js";

package/dist/components/CodeEditor/lib/PortalOutlet.d.ts

@@ -0,0 +1,11 @@
+import type { FC } from 'react';
+import type { PortalRegistry } from './portalRegistry';
+export interface PortalOutletProps {
+    registry: PortalRegistry;
+}
+/**
+ * Renders every registry entry into its engine-owned host with `createPortal`.
+ * Renders no DOM of its own (so no `data-slot`); portals keep React context,
+ * so DS components inside hosts see the surrounding providers.
+ */
+export declare const PortalOutlet: FC<PortalOutletProps>;

package/dist/components/CodeEditor/lib/PortalOutlet.js

@@ -0,0 +1,11 @@
+import { Fragment, jsx } from "react/jsx-runtime";
+import { useSyncExternalStore } from "react";
+import { createPortal } from "react-dom";
+const PortalOutlet = ({ registry })=>{
+    const entries = useSyncExternalStore(registry.subscribe, registry.getSnapshot, registry.getSnapshot);
+    return /*#__PURE__*/ jsx(Fragment, {
+        children: entries.map((entry)=>/*#__PURE__*/ createPortal(entry.node, entry.host, String(entry.id)))
+    });
+};
+PortalOutlet.displayName = 'PortalOutlet';
+export { PortalOutlet };

package/dist/components/CodeEditor/lib/httpCompletions.d.ts

@@ -0,0 +1,7 @@
+import type { CodeEditorCompletionSource } from '../types';
+/**
+ * Built-in HTTP completion source (spec §7.14): methods and versions on the start line,
+ * header names on header lines, common values for well-known headers. Pure — reads only
+ * the `CodeEditorCompletionContext`, so consumers can wrap or filter it.
+ */
+export declare const httpCompletions: CodeEditorCompletionSource;

package/dist/components/CodeEditor/lib/httpCompletions.js

@@ -0,0 +1,102 @@
+import { HTTP_COMPLETION_METHODS, HTTP_HEADERS, HTTP_HEADER_VALUES, HTTP_MEDIA_TYPE_PARAMETERS, HTTP_VERSIONS } from "./httpCompletionsData.js";
+const BLANK_LINE = /^[ \t]*$/;
+const WHITESPACE = /[ \t]+/;
+const MEDIA_TYPE_HEADERS = new Set([
+    'content-type',
+    'accept'
+]);
+const DIRECTION_DETAIL = {
+    request: 'request header',
+    response: 'response header',
+    both: 'header'
+};
+const textBeforeCursor = (ctx)=>ctx.lineText.slice(0, Math.max(0, ctx.position.column - 1));
+const headerNameOf = (line)=>{
+    const colon = line.indexOf(':');
+    return (colon < 0 ? line : line.slice(0, colon)).trim().toLowerCase();
+};
+const countHeaderNames = (value)=>{
+    const counts = new Map();
+    const lines = value.split('\n');
+    for(let index = 1; index < lines.length; index++){
+        const line = lines[index] ?? '';
+        if (BLANK_LINE.test(line)) break;
+        const name = headerNameOf(line);
+        if (name) counts.set(name, (counts.get(name) ?? 0) + 1);
+    }
+    return counts;
+};
+const methodCompletions = ()=>HTTP_COMPLETION_METHODS.map((method)=>({
+            label: method,
+            apply: `${method} `,
+            kind: 'method'
+        }));
+const versionCompletions = (suffix)=>HTTP_VERSIONS.map((version)=>({
+            label: version,
+            apply: `${version}${suffix}`,
+            kind: 'keyword'
+        }));
+const valueCompletions = (values)=>values.map(({ label, apply, info })=>({
+            label,
+            ...void 0 === apply ? {} : {
+                apply
+            },
+            ...void 0 === info ? {} : {
+                info
+            },
+            kind: 'value'
+        }));
+const startLineCompletions = (ctx, http)=>{
+    const before = textBeforeCursor(ctx);
+    if (WHITESPACE.test(before.charAt(0))) return null;
+    const tokenIndex = before.split(WHITESPACE).length - 1;
+    if (0 === tokenIndex) {
+        if (!ctx.explicit && '' === ctx.word.text) return null;
+        return [
+            ...methodCompletions(),
+            ...versionCompletions(' ')
+        ];
+    }
+    if (2 === tokenIndex && 'request' === http.messageKind) return versionCompletions('');
+    return null;
+};
+const headerNameCompletions = (ctx, http)=>{
+    if (textBeforeCursor(ctx) !== ctx.word.text) return null;
+    if (!ctx.explicit && '' === ctx.word.text) return null;
+    const present = countHeaderNames(ctx.value);
+    const current = headerNameOf(ctx.lineText);
+    const currentCount = present.get(current);
+    if (void 0 !== currentCount) present.set(current, currentCount - 1);
+    return HTTP_HEADERS.filter((header)=>('both' === header.direction || header.direction === http.messageKind) && (true === header.repeatable || (present.get(header.name.toLowerCase()) ?? 0) === 0)).map((header)=>({
+            label: header.name,
+            apply: `${header.name}: `,
+            detail: DIRECTION_DETAIL[header.direction],
+            info: header.description,
+            kind: 'header'
+        }));
+};
+const headerValueCompletions = (ctx, http)=>{
+    if (ctx.word.text.includes(':')) return null;
+    const name = http.headerName?.trim().toLowerCase() ?? '';
+    const values = HTTP_HEADER_VALUES[name];
+    if (!values) return null;
+    const before = textBeforeCursor(ctx);
+    const valueSoFar = before.slice(before.indexOf(':') + 1);
+    const typedBeforeWord = valueSoFar.slice(0, valueSoFar.length - ctx.word.text.length);
+    if (before.slice(0, before.length - ctx.word.text.length).endsWith('=')) return null;
+    if (MEDIA_TYPE_HEADERS.has(name) && typedBeforeWord.includes(';')) {
+        if (/;\s*charset\s*=/i.test(typedBeforeWord)) return null;
+        return valueCompletions(HTTP_MEDIA_TYPE_PARAMETERS);
+    }
+    if ('' !== typedBeforeWord.trim()) return ctx.explicit ? valueCompletions(values) : null;
+    return valueCompletions(values);
+};
+const httpCompletions = (ctx)=>{
+    const { http } = ctx;
+    if (!http) return null;
+    if ('start-line' === http.section) return startLineCompletions(ctx, http);
+    if ('header-name' === http.section) return headerNameCompletions(ctx, http);
+    if ('header-value' === http.section) return headerValueCompletions(ctx, http);
+    return null;
+};
+export { httpCompletions };