@wallarm-org/design-system 1.30.0 → 1.31.0

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

@@ -0,0 +1,387 @@
+import { closeBrackets, closeBracketsKeymap } from "@codemirror/autocomplete";
+import { defaultKeymap, history as commands_history, historyKeymap, indentWithTab } from "@codemirror/commands";
+import { bracketMatching, indentOnInput } from "@codemirror/language";
+import { openSearchPanel } from "@codemirror/search";
+import { Annotation, Compartment, EditorState, Transaction } from "@codemirror/state";
+import { EditorView, ViewPlugin, crosshairCursor, drawSelection, dropCursor, keymap, rectangularSelection } from "@codemirror/view";
+import { adapterPainter } from "./adapterPainter.js";
+import { completionExtension } from "./completion.js";
+import { sanitizeContentAttributes } from "./contentAttributes.js";
+import { diagnosticsExtension, jsonRegion } from "./diagnostics.js";
+import { diffDeletedRowCount, diffExtension } from "./diff.js";
+import { foldAllRegions, foldsExtension, getCollapsedRanges, getVisibleRowCount, unfoldAllRegions } from "./folds.js";
+import { guttersExtension } from "./gutters.js";
+import { isLazyLanguage, languageExtension, loadLanguageExtension } from "./languages/index.js";
+import { linesExtension } from "./lines.js";
+import { schemaHover } from "./schema/hover.js";
+import { validateAgainstSchema } from "./schema/validate.js";
+import { searchConfigured, searchExtension } from "./search.js";
+import { editorTheme, maxHeightTheme } from "./theme.js";
+const externalChange = Annotation.define();
+const isHighSurrogate = (code)=>code >= 0xd800 && code <= 0xdbff;
+const isLowSurrogate = (code)=>code >= 0xdc00 && code <= 0xdfff;
+const minimalChange = (from, to)=>{
+    if (from === to) return null;
+    const max = Math.min(from.length, to.length);
+    let prefix = 0;
+    while(prefix < max && from.charCodeAt(prefix) === to.charCodeAt(prefix))prefix++;
+    if (prefix > 0 && isHighSurrogate(from.charCodeAt(prefix - 1))) prefix--;
+    let suffix = 0;
+    while(suffix < max - prefix && from.charCodeAt(from.length - 1 - suffix) === to.charCodeAt(to.length - 1 - suffix))suffix++;
+    if (suffix > 0 && isLowSurrogate(from.charCodeAt(from.length - suffix))) suffix--;
+    return {
+        from: prefix,
+        to: from.length - suffix,
+        insert: to.slice(prefix, to.length - suffix)
+    };
+};
+const CORE_KEYS = [
+    'language',
+    'readOnly',
+    'wrap',
+    'maxHeight',
+    'contentAttributes',
+    'cspNonce'
+];
+const FEATURE_KEYS = [
+    'painter',
+    'lines',
+    'folds',
+    'search',
+    'diagnostics',
+    'completion',
+    'diff'
+];
+const TAIL_KEYS = [
+    'gutterTestId',
+    'gutterAria'
+];
+const SLOT_KEYS = [
+    ...CORE_KEYS,
+    ...FEATURE_KEYS,
+    ...TAIL_KEYS
+];
+const DERIVED_DEPS = {
+    diffEnabled: (o)=>void 0 !== o.original
+};
+const SLOT_DEPS = {
+    language: [
+        'language'
+    ],
+    readOnly: [
+        'readOnly'
+    ],
+    wrap: [
+        'wrapLines'
+    ],
+    maxHeight: [
+        'maxHeight'
+    ],
+    contentAttributes: [
+        'contentAttributes',
+        'testId'
+    ],
+    cspNonce: [
+        'cspNonce'
+    ],
+    painter: [
+        'adapter',
+        'language'
+    ],
+    lines: [
+        'lines',
+        'startingLineNumber',
+        'lineNumbers',
+        'testId',
+        'folds',
+        'diffEnabled'
+    ],
+    folds: [
+        'folds',
+        'startingLineNumber',
+        'testId'
+    ],
+    search: [
+        'readOnly',
+        'testId'
+    ],
+    diagnostics: [
+        'language',
+        'schema',
+        'diagnostics',
+        'startingLineNumber'
+    ],
+    completion: [
+        'language',
+        'schema',
+        'completions',
+        'startingLineNumber'
+    ],
+    diff: [
+        'original'
+    ],
+    gutterTestId: [
+        'testId'
+    ],
+    gutterAria: []
+};
+const buildFolds = (o, portals)=>foldsExtension({
+        folds: o.folds,
+        startingLineNumber: o.startingLineNumber,
+        portals,
+        testId: o.testId
+    });
+const featureExtensions = (options, callbacks)=>({
+        painter: ()=>adapterPainter({
+                adapter: options.adapter,
+                language: options.language
+            }),
+        lines: ()=>[
+                linesExtension({
+                    lines: options.lines,
+                    startingLineNumber: options.startingLineNumber
+                }),
+                guttersExtension({
+                    lines: options.lines,
+                    startingLineNumber: options.startingLineNumber,
+                    lineNumbers: options.lineNumbers,
+                    foldGutter: buildFolds(options, callbacks.portals).gutter,
+                    portals: callbacks.portals,
+                    testId: options.testId,
+                    diff: DERIVED_DEPS.diffEnabled(options)
+                })
+            ],
+        folds: ()=>buildFolds(options, callbacks.portals).extension,
+        search: ()=>searchExtension({
+                portals: callbacks.portals,
+                readOnly: options.readOnly,
+                testId: options.testId
+            }),
+        diagnostics: ()=>{
+            const { schema } = options;
+            return [
+                diagnosticsExtension({
+                    language: options.language,
+                    schema,
+                    external: options.diagnostics,
+                    startingLineNumber: options.startingLineNumber,
+                    onChange: callbacks.onDiagnosticsChange,
+                    schemaSource: void 0 === schema ? void 0 : (state, region)=>validateAgainstSchema(state, region, schema)
+                }),
+                void 0 === schema ? [] : schemaHover(()=>schema, (state)=>jsonRegion(state, options.language))
+            ];
+        },
+        completion: ()=>completionExtension({
+                language: options.language,
+                schema: options.schema,
+                sources: options.completions,
+                startingLineNumber: options.startingLineNumber
+            }),
+        diff: ()=>void 0 === options.original ? [] : diffExtension({
+                original: options.original,
+                portals: callbacks.portals
+            })
+    });
+const contentAttributesFor = (options)=>{
+    const attrs = sanitizeContentAttributes(options.contentAttributes);
+    if (options.testId) attrs['data-testid'] = `${options.testId}--editor`;
+    return attrs;
+};
+const gutterTestId = (testId)=>{
+    if (!testId) return [];
+    const id = `${testId}--gutter`;
+    const apply = (view)=>{
+        const gutters = view.scrollDOM.querySelector(':scope > .cm-gutters');
+        if (gutters && gutters.getAttribute('data-testid') !== id) gutters.setAttribute('data-testid', id);
+    };
+    return [
+        ViewPlugin.define((view)=>{
+            apply(view);
+            return {};
+        }),
+        EditorView.updateListener.of((update)=>apply(update.view))
+    ];
+};
+const syncGutterAria = (view)=>{
+    for (const container of view.scrollDOM.querySelectorAll(':scope > .cm-gutters')){
+        const columns = Array.from(container.querySelectorAll(':scope > .cm-gutter'));
+        const hasFolds = columns.some((column)=>column.classList.contains('cm-ds-fold-gutter'));
+        if (!hasFolds) {
+            if ('true' !== container.getAttribute('aria-hidden')) container.setAttribute('aria-hidden', 'true');
+            continue;
+        }
+        if (container.hasAttribute('aria-hidden')) container.removeAttribute('aria-hidden');
+        for (const column of columns)if (column.classList.contains('cm-ds-fold-gutter')) {
+            if (column.hasAttribute('aria-hidden')) column.removeAttribute('aria-hidden');
+        } else if ('true' !== column.getAttribute('aria-hidden')) column.setAttribute('aria-hidden', 'true');
+    }
+};
+const gutterAria = [
+    ViewPlugin.define((view)=>{
+        syncGutterAria(view);
+        return {};
+    }),
+    EditorView.updateListener.of((update)=>syncGutterAria(update.view))
+];
+const slotExtensions = (options, callbacks)=>({
+        language: ()=>languageExtension(options.language),
+        readOnly: ()=>EditorState.readOnly.of(options.readOnly),
+        wrap: ()=>options.wrapLines ? EditorView.lineWrapping : [],
+        maxHeight: ()=>maxHeightTheme(options.maxHeight),
+        contentAttributes: ()=>EditorView.contentAttributes.of(contentAttributesFor(options)),
+        cspNonce: ()=>options.cspNonce ? EditorView.cspNonce.of(options.cspNonce) : [],
+        ...featureExtensions(options, callbacks),
+        gutterTestId: ()=>gutterTestId(options.testId),
+        gutterAria: ()=>gutterAria
+    });
+const shallowEqualRecord = (a, b)=>{
+    const aKeys = Object.keys(a);
+    if (aKeys.length !== Object.keys(b).length) return false;
+    return aKeys.every((key)=>Object.hasOwn(b, key) && a[key] === b[key]);
+};
+const changedOptionKeys = (prev, next)=>{
+    const changed = new Set();
+    for (const key of Object.keys(DERIVED_DEPS))if (DERIVED_DEPS[key](prev) !== DERIVED_DEPS[key](next)) changed.add(key);
+    for (const key of Object.keys(next))if ('contentAttributes' === key) {
+        if (!shallowEqualRecord(prev.contentAttributes, next.contentAttributes)) changed.add(key);
+    } else if (prev[key] !== next[key]) changed.add(key);
+    return changed;
+};
+const visibleRowCount = (state)=>getVisibleRowCount(state) + diffDeletedRowCount(state, getCollapsedRanges(state));
+const createEditor = (parent, initialOptions, callbacks)=>{
+    const compartments = {};
+    for (const key of SLOT_KEYS)compartments[key] = new Compartment();
+    const cache = new Map();
+    let options = initialOptions;
+    let lastRowCount = -1;
+    let destroyed = false;
+    const reportRowCount = (state)=>{
+        const rows = visibleRowCount(state);
+        if (rows === lastRowCount) return;
+        lastRowCount = rows;
+        callbacks.onVisibleRowCountChange(rows);
+    };
+    const listener = EditorView.updateListener.of((update)=>{
+        if (update.docChanged && !update.transactions.some((tr)=>true === tr.annotation(externalChange))) callbacks.onChange(update.state.doc.toString());
+        if (update.docChanged || update.selectionSet || update.transactions.some((tr)=>tr.effects.length > 0)) reportRowCount(update.state);
+    });
+    const baseExtensions = [
+        commands_history(),
+        drawSelection(),
+        dropCursor(),
+        EditorState.allowMultipleSelections.of(true),
+        rectangularSelection(),
+        crosshairCursor(),
+        indentOnInput(),
+        bracketMatching(),
+        closeBrackets(),
+        keymap.of([
+            ...closeBracketsKeymap,
+            ...defaultKeymap,
+            ...historyKeymap,
+            indentWithTab
+        ]),
+        editorTheme,
+        listener
+    ];
+    const createState = (doc, opts)=>{
+        const builders = slotExtensions(opts, callbacks);
+        return EditorState.create({
+            doc,
+            extensions: [
+                baseExtensions,
+                ...SLOT_KEYS.map((key)=>compartments[key].of(builders[key]()))
+            ]
+        });
+    };
+    const view = new EditorView({
+        state: createState(initialOptions.value, initialOptions),
+        parent
+    });
+    const ensureLazyLanguage = (lang)=>{
+        if (!isLazyLanguage(lang)) return;
+        loadLanguageExtension(lang).then((extension)=>{
+            if (destroyed || options.language !== lang) return;
+            view.dispatch({
+                effects: compartments.language.reconfigure(extension)
+            });
+        }, (error)=>{
+            console.error(`[CodeEditor] failed to load the ${lang} parser`, error);
+        });
+    };
+    ensureLazyLanguage(initialOptions.language);
+    const reconfigure = (prev, next)=>{
+        const changed = changedOptionKeys(prev, next);
+        const builders = slotExtensions(next, callbacks);
+        const effects = SLOT_KEYS.filter((key)=>SLOT_DEPS[key].some((dep)=>changed.has(dep))).map((key)=>compartments[key].reconfigure(builders[key]()));
+        if (effects.length > 0) view.dispatch({
+            effects
+        });
+    };
+    const syncValue = (value)=>{
+        const changes = minimalChange(view.state.doc.toString(), value);
+        if (!changes) return;
+        view.dispatch({
+            changes,
+            annotations: [
+                externalChange.of(true),
+                Transaction.addToHistory.of(false)
+            ]
+        });
+    };
+    const swapDocument = (prev, next)=>{
+        if (void 0 !== prev.documentId) cache.set(prev.documentId, {
+            state: view.state,
+            options: prev
+        });
+        const cached = void 0 === next.documentId ? void 0 : cache.get(next.documentId);
+        if (cached) {
+            view.setState(cached.state);
+            reconfigure(cached.options, next);
+            syncValue(next.value);
+        } else view.setState(createState(next.value, next));
+        reportRowCount(view.state);
+        ensureLazyLanguage(next.language);
+    };
+    const update = (next)=>{
+        const prev = options;
+        options = next;
+        if (next.documentId !== prev.documentId) return void swapDocument(prev, next);
+        reconfigure(prev, next);
+        if (next.language !== prev.language) ensureLazyLanguage(next.language);
+        syncValue(next.value);
+    };
+    const api = {
+        focus: ()=>view.focus(),
+        getValue: ()=>view.state.doc.toString(),
+        insertText: (text)=>{
+            if (view.state.readOnly) return;
+            view.dispatch({
+                ...view.state.replaceSelection(text),
+                userEvent: 'input',
+                scrollIntoView: true
+            });
+        },
+        openSearch: ()=>{
+            if (view.state.facet(searchConfigured)) openSearchPanel(view);
+        },
+        foldAll: ()=>{
+            foldAllRegions(view);
+        },
+        unfoldAll: ()=>{
+            unfoldAllRegions(view);
+        }
+    };
+    reportRowCount(view.state);
+    return {
+        update,
+        api,
+        view,
+        destroy: ()=>{
+            destroyed = true;
+            cache.clear();
+            view.destroy();
+        }
+    };
+};
+export { createEditor, externalChange, minimalChange, searchConfigured };

package/dist/components/CodeEditor/engine/languages/http/index.d.ts

@@ -0,0 +1,20 @@
+import { LanguageSupport, LRLanguage } from '@codemirror/language';
+import type { EditorState } from '@codemirror/state';
+import type { CodeEditorHttpContext } from '../../../types';
+/** HTTP/1.x message language: start line, headers, body; JSON bodies get a nested JSON tree. */
+export declare const httpLanguage: LRLanguage;
+export declare const http: () => LanguageSupport;
+/**
+ * Range of the HTTP body that is parsed as JSON (the mounted `JsonText` node), or `null`
+ * when the state is not HTTP or the body is absent / not JSON.
+ */
+export declare const findJsonBodyRange: (state: EditorState) => {
+    from: number;
+    to: number;
+} | null;
+/**
+ * Where `pos` sits in an HTTP message. Line-based, with the same rules as the grammar and
+ * getHttpFolds, so it is exact even while the tree is still being parsed.
+ * Returns `undefined` when the state's language is not HTTP.
+ */
+export declare const httpContextAt: (state: EditorState, pos: number) => CodeEditorHttpContext | undefined;

package/dist/components/CodeEditor/engine/languages/http/index.js

@@ -0,0 +1,69 @@
+import { LRLanguage, LanguageSupport, ensureSyntaxTree, language, syntaxTree } from "@codemirror/language";
+import { parseMixed } from "@lezer/common";
+import { jsonEditorLanguage } from "../json.js";
+import { parser } from "./parser.js";
+import { Body, Header, HeaderName, HeaderValue } from "./parser.terms.js";
+const BLANK_LINE = /^[ \t]*$/;
+const JSON_MEDIA_TYPE = /^[\w.+-]+\/(?:[\w.!#$&^-]+\+)?json$/i;
+const JSON_START = /^\s*[[{]/;
+const RESPONSE_START_LINE = /^HTTP\//;
+const ENSURE_TREE_TIMEOUT = 200;
+const readNode = (node, input)=>node ? input.read(node.from, node.to) : '';
+const isJsonBody = (body, input)=>{
+    const message = body.parent;
+    if (message) for (const header of message.getChildren(Header)){
+        const name = readNode(header.getChild(HeaderName), input).trim().toLowerCase();
+        if ('content-type' !== name) continue;
+        const mediaType = readNode(header.getChild(HeaderValue), input).split(';')[0] ?? '';
+        return JSON_MEDIA_TYPE.test(mediaType.trim());
+    }
+    return JSON_START.test(input.read(body.from, body.to));
+};
+const mountJsonBody = parseMixed((node, input)=>{
+    if (node.type.id !== Body) return null;
+    return isJsonBody(node.node, input) ? {
+        parser: jsonEditorLanguage.parser
+    } : null;
+});
+const httpLanguage = LRLanguage.define({
+    name: 'http',
+    parser: parser.configure({
+        wrap: mountJsonBody
+    })
+});
+const http = ()=>new LanguageSupport(httpLanguage);
+const isHttpState = (state)=>state.facet(language) === httpLanguage;
+const findJsonBodyRange = (state)=>{
+    if (!isHttpState(state)) return null;
+    const tree = ensureSyntaxTree(state, state.doc.length, ENSURE_TREE_TIMEOUT) ?? syntaxTree(state);
+    for(let child = tree.topNode.firstChild; child; child = child.nextSibling)if ('JsonText' === child.name) return {
+        from: child.from,
+        to: child.to
+    };
+    return null;
+};
+const httpContextAt = (state, pos)=>{
+    if (!isHttpState(state)) return;
+    const { doc } = state;
+    const messageKind = RESPONSE_START_LINE.test(doc.line(1).text) ? 'response' : 'request';
+    const line = doc.lineAt(pos);
+    if (1 === line.number) return {
+        section: 'start-line',
+        messageKind
+    };
+    for(let n = 2; n < line.number; n++)if (BLANK_LINE.test(doc.line(n).text)) return {
+        section: 'body',
+        messageKind
+    };
+    const colon = line.text.indexOf(':');
+    if (colon < 0 || pos - line.from <= colon) return {
+        section: 'header-name',
+        messageKind
+    };
+    return {
+        section: 'header-value',
+        headerName: line.text.slice(0, colon).trim(),
+        messageKind
+    };
+};
+export { findJsonBodyRange, http, httpContextAt, httpLanguage };

package/dist/components/CodeEditor/engine/languages/http/parser.d.ts

@@ -0,0 +1,2 @@
+import { LRParser } from "@lezer/lr";
+export declare const parser: LRParser;

package/dist/components/CodeEditor/engine/languages/http/parser.js

@@ -0,0 +1,31 @@
+import { LRParser } from "@lezer/lr";
+const parser = LRParser.deserialize({
+    version: 14,
+    states: "%WOQOPOOOcOQO'#C_OhOQO'#CcOOOO'#C^'#C^QmOPOOOrOQO,58yOwOSO,58}Q|OWO'#ClQmOPOOO![OQO1G.eO!gOQO1G.iO!rOWO'#CgO!}O`O'#CgO#YOWO'#CjOOOO,59W,59WQ#hOpOOQ#mOPOOOOOO-E6j-E6jO#rOPO7+$PO#}O!bO7+$TO$YO`O,59ROOOO,59R,59RO$eOWO,59RQOOOOOP$pOWO'#ClO${OQO<<GkOOOO<<Go<<GoOOOO1G.m1G.mO%WO`O1G.mP%cOWO'#CgOOOOAN=VAN=VOOOO7+$X7+$X",
+    stateData: "%q~OSPOUQOYROaQPcQP~ObTO~ObUO~OcVO~OTXO~OWYO~O[ZOc_Od]Oe[O~ObbOaRicRi~ObcOaVicVi~OedOaZXcZX~O]eOaZXcZX~O[fOedOa^Xc^X~O_gO~Oc_O~OUiOaRqcRq~OXjOaVqcVq~O]kOaZacZa~OelOaZacZa~O[ZOdmOe[O~ObnOaRycRy~O]oOaZicZi~O[fOedO~OUSd[Y~",
+    goto: "uaPPbePPPePPPhPPlPoRSORROT^VhR`VQWSRaW",
+    nodeNames: "⚠ Message StartLine RequestLine Method Target Version StatusLine StatusCode ReasonPhrase StartLineText Header HeaderName HeaderValue BlankLine Body",
+    maxTerm: 21,
+    skippedNodes: [
+        0
+    ],
+    repeatNodeCount: 1,
+    tokenData: "2b#sR^OX}XY&TYZ'UZp}pq&Tq![}![!]'f!]!c}!c!j(a!j!k)v!k!}(a!};'S};'S;=`%}<%lO}#s!`Y_p]`X!bWSTQ[WYPOX}XY#OYZ#rZp}pq#Oq![}![!]%O!];'S};'S;=`%}<%lO}#m#]V_p]`X!b[WYPOY#OYZ#rZ![#O![!]$W!];'S#O;'S;=`$x<%lO#Op#wR_pO;'S#r;'S;=`$Q<%lO#rp$TP;=`<%l#r#e$cT_p]`X!bYPOY$WYZ#rZ;'S$W;'S;=`$r<%lO$W#e$uP;=`<%l$W#m${P;=`<%l#O#k%_W_p]`X!bWSTQYPOX%OXY$WYZ#rZp%Opq$Wq;'S%O;'S;=`%w<%lO%O#k%zP;=`<%l%O#s&QP;=`<%l}#o&fY_p]`X!bbQdW[WYPOX#OXY&TYZ#rZp#Opq&Tq![#O![!]$W!];'S#O;'S;=`$x<%lO#O#o']R_pc!}O;'S#r;'S;=`$Q<%lO#r#s'wWeW_p]`X!bWSTQYPOX%OXY$WYZ#rZp%Opq$Wq;'S%O;'S;=`%w<%lO%O#s(t`_p]`X!bWSTQSP[WYPOX}XY#OYZ#rZp}pq#Oq}}}!O(a!O![}![!]%O!]!c}!c!}(a!}#R}#R#S(a#S;'S};'S;=`%}<%lO}#s*Zb_p]`X!bWSTQSP[WYPOX}XY#OYZ#rZp}pq#Oq}}}!O(a!O![}![!]%O!]!c}!c!v(a!v!w+c!w!}(a!}#R}#R#S(a#S;'S};'S;=`%}<%lO}#s+vb_p]`X!bWSTQSP[WYPOX}XY#OYZ#rZp}pq#Oq}}}!O(a!O![}![!]%O!]!c}!c!v(a!v!w-O!w!}(a!}#R}#R#S(a#S;'S};'S;=`%}<%lO}#s-cb_p]`X!bWSTQSP[WYPOX}XY#OYZ#rZp}pq#Oq}}}!O(a!O![}![!]%O!]!c}!c!r(a!r!s.k!s!}(a!}#R}#R#S(a#S;'S};'S;=`%}<%lO}#s/Ob_p]`X!bWSTQSP[WYPOX}XY#OYZ#rZp}pq#Oq}}}!O(a!O!P}!P!Q0W!Q![}![!]%O!]!c}!c!}(a!}#R}#R#S(a#S;'S};'S;=`%}<%lO}#s0kY_p]`X!bWSTQUP[WYPOX0WXY#OYZ#rZp0Wpq#Oq![0W![!]1Z!];'S0W;'S;=`2[<%lO0W#k1lW_p]`X!bWSTQUPYPOX1ZXY$WYZ#rZp1Zpq$Wq;'S1Z;'S;=`2U<%lO1Z#k2XP;=`<%l1Z#s2_P;=`<%l0W",
+    tokenizers: [
+        0,
+        1,
+        2,
+        3,
+        4,
+        5,
+        6
+    ],
+    topRules: {
+        Message: [
+            0,
+            1
+        ]
+    },
+    tokenPrec: 211
+});
+export { parser };

package/dist/components/CodeEditor/engine/languages/http/parser.terms.d.ts

@@ -0,0 +1 @@
+export declare const Message = 1, StartLine = 2, RequestLine = 3, Method = 4, Target = 5, Version = 6, StatusLine = 7, StatusCode = 8, ReasonPhrase = 9, StartLineText = 10, Header = 11, HeaderName = 12, HeaderValue = 13, BlankLine = 14, Body = 15;

package/dist/components/CodeEditor/engine/languages/http/parser.terms.js

@@ -0,0 +1,2 @@
+const Message = 1, StartLine = 2, RequestLine = 3, Method = 4, Target = 5, Version = 6, StatusLine = 7, StatusCode = 8, ReasonPhrase = 9, StartLineText = 10, Header = 11, HeaderName = 12, HeaderValue = 13, BlankLine = 14, Body = 15;
+export { BlankLine, Body, Header, HeaderName, HeaderValue, Message, Method, ReasonPhrase, RequestLine, StartLine, StartLineText, StatusCode, StatusLine, Target, Version };

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

@@ -0,0 +1,8 @@
+import type { Extension } from '@codemirror/state';
+import type { CodeEditorLanguage } from '../../types';
+export { findJsonBodyRange, http, httpContextAt, httpLanguage } from './http';
+/** CodeMirror language support for a CodeEditor `language`. `bash` and `text` have no structure parser. */
+export declare const languageExtension: (language: CodeEditorLanguage) => Extension;
+export declare const isLazyLanguage: (language: CodeEditorLanguage) => boolean;
+/** Loads the parser for a lazy language (cached). Resolves [] for languages that are available synchronously. */
+export declare const loadLanguageExtension: (language: CodeEditorLanguage) => Promise<Extension>;

package/dist/components/CodeEditor/engine/languages/index.js

@@ -0,0 +1,41 @@
+import { StreamLanguage } from "@codemirror/language";
+import { findJsonBodyRange, http, httpContextAt, httpLanguage } from "./http/index.js";
+import { json } from "./json.js";
+import { yaml } from "./yaml.js";
+const noLanguage = ()=>[];
+const LANGUAGE_EXTENSIONS = {
+    http: http,
+    json: json,
+    yaml: yaml,
+    bash: noLanguage,
+    text: noLanguage,
+    javascript: noLanguage,
+    typescript: noLanguage,
+    python: noLanguage,
+    lua: noLanguage
+};
+const LAZY_LANGUAGES = {
+    javascript: ()=>import("@codemirror/lang-javascript").then((m)=>m.javascript()),
+    typescript: ()=>import("@codemirror/lang-javascript").then((m)=>m.javascript({
+                typescript: true
+            })),
+    python: ()=>import("@codemirror/lang-python").then((m)=>m.python()),
+    lua: ()=>import("@codemirror/legacy-modes/mode/lua").then((m)=>StreamLanguage.define(m.lua))
+};
+const lazyCache = new Map();
+const languageExtension = (language)=>LANGUAGE_EXTENSIONS[language]();
+const isLazyLanguage = (language)=>language in LAZY_LANGUAGES;
+const loadLanguageExtension = (language)=>{
+    const load = LAZY_LANGUAGES[language];
+    if (!load) return Promise.resolve([]);
+    let pending = lazyCache.get(language);
+    if (!pending) {
+        pending = load().catch((error)=>{
+            lazyCache.delete(language);
+            throw error;
+        });
+        lazyCache.set(language, pending);
+    }
+    return pending;
+};
+export { findJsonBodyRange, http, httpContextAt, httpLanguage, isLazyLanguage, languageExtension, loadLanguageExtension };

package/dist/components/CodeEditor/engine/languages/json.d.ts

@@ -0,0 +1,8 @@
+import { LanguageSupport, type LRLanguage } from '@codemirror/language';
+/**
+ * lang-json's JSON language with its Object/Array syntax folds switched off.
+ * CodeSnippet folds only what the `folds` prop describes, so CodeEditor does the same (spec §7.4).
+ * Indentation, bracket and language data are kept.
+ */
+export declare const jsonEditorLanguage: LRLanguage;
+export declare const json: () => LanguageSupport;

package/dist/components/CodeEditor/engine/languages/json.js

@@ -0,0 +1,11 @@
+import { jsonLanguage } from "@codemirror/lang-json";
+import { LanguageSupport, foldNodeProp } from "@codemirror/language";
+const jsonEditorLanguage = jsonLanguage.configure({
+    props: [
+        foldNodeProp.add({
+            'Object Array': ()=>null
+        })
+    ]
+});
+const json = ()=>new LanguageSupport(jsonEditorLanguage);
+export { json, jsonEditorLanguage };

package/dist/components/CodeEditor/engine/languages/jsonPointers.d.ts

@@ -0,0 +1,47 @@
+import type { EditorState } from '@codemirror/state';
+import type { SyntaxNode } from '@lezer/common';
+/** Absolute document offsets of one JSON value (and of its key, for object members). */
+export interface JsonPointerEntry {
+    pointer: string;
+    keyFrom?: number;
+    keyTo?: number;
+    valueFrom: number;
+    valueTo: number;
+}
+/** A range of the document that holds one JSON text (the whole doc, or an http body). */
+export interface JsonRegion {
+    from: number;
+    to: number;
+}
+/** Lezer JSON node names that are complete values (error nodes `⚠` are not). */
+export declare const VALUE_NODE_NAMES: ReadonlySet<string>;
+/** Upper bound for the parse work a pointer lookup may force, in ms. */
+export declare const ENSURE_TREE_TIMEOUT = 200;
+/** RFC 6901 reference-token escaping: `~` → `~0`, `/` → `~1`. */
+export declare const escapePointerSegment: (segment: string) => string;
+export declare const isValueNode: (node: SyntaxNode) => boolean;
+/** Decoded text of a `PropertyName` / `String` node; the raw inner text when it is not valid JSON. */
+export declare const readJsonKey: (state: EditorState, node: SyntaxNode) => string;
+/**
+ * The `JsonText` node of the region: the whole tree for `json`, the `parseMixed`
+ * mount for an `http` body. `null` when the region holds no JSON tree.
+ */
+export declare const findJsonText: (state: EditorState, region: JsonRegion) => SyntaxNode | null;
+/**
+ * RFC 6901 pointer (`''` = root, `/a/0/b`, `~0`/`~1` escaped) → absolute key/value ranges,
+ * built from the Lezer JSON tree inside `region`. Unfinished members (no value yet) are skipped.
+ */
+export declare const getJsonPointers: (state: EditorState, region: JsonRegion) => Map<string, JsonPointerEntry>;
+/**
+ * Pointer of the innermost key or value that contains `pos` (a key counts as its member).
+ * `undefined` outside the JSON value.
+ */
+export declare const pointerAt: (state: EditorState, pos: number, region: JsonRegion) => string | undefined;
+/**
+ * Best-effort data for a value node of a possibly unfinished document: complete members
+ * and items are kept, unfinished ones (no value yet, error nodes) are dropped. Used to
+ * reduce `oneOf` / `if` schemas while the text is not valid JSON yet.
+ */
+export declare const readPartialJson: (state: EditorState, value: SyntaxNode) => unknown;
+/** `JSON.parse` of the region when valid, otherwise {@link readPartialJson} of its root value. */
+export declare const readRegionData: (state: EditorState, region: JsonRegion) => unknown;