@coldsmirk/inkstone-elasticsearch 0.22.0

package/dist/markers-DBJshw-Y.js

@@ -0,0 +1,1241 @@
+//#region src/api.ts
+const API_ENDPOINTS = [
+	{
+		path: "/",
+		methods: ["GET"],
+		summary: "The cluster's name, its version and its tagline."
+	},
+	{
+		path: "/_search",
+		methods: ["GET", "POST"],
+		summary: "Search every index; the query in the body."
+	},
+	{
+		path: "/{index}/_search",
+		methods: ["GET", "POST"],
+		summary: "Search the index (a pattern, a list, an alias); the query in the body."
+	},
+	{
+		path: "/_count",
+		methods: ["GET", "POST"],
+		summary: "Count the documents a query matches, across every index."
+	},
+	{
+		path: "/{index}/_count",
+		methods: ["GET", "POST"],
+		summary: "Count the documents a query matches in the index."
+	},
+	{
+		path: "/_msearch",
+		methods: ["GET", "POST"],
+		summary: "Several searches in one request: a header line and a body line per search, newline-delimited."
+	},
+	{
+		path: "/{index}/_msearch",
+		methods: ["GET", "POST"],
+		summary: "Several searches of the index in one request, newline-delimited."
+	},
+	{
+		path: "/_bulk",
+		methods: ["POST", "PUT"],
+		summary: "Index, create, update and delete in one request: an action line and a document line each, newline-delimited."
+	},
+	{
+		path: "/{index}/_bulk",
+		methods: ["POST", "PUT"],
+		summary: "Bulk actions on the index, newline-delimited."
+	},
+	{
+		path: "/_sql",
+		methods: ["GET", "POST"],
+		summary: "Run an SQL query over indices."
+	},
+	{
+		path: "/{index}",
+		methods: [
+			"GET",
+			"PUT",
+			"DELETE",
+			"HEAD"
+		],
+		summary: "The index whole: read it, create it (settings, mappings, aliases in the body), delete it, or ask whether it exists."
+	},
+	{
+		path: "/{index}/_mapping",
+		methods: ["GET", "PUT"],
+		summary: "The index's field mappings; PUT adds fields."
+	},
+	{
+		path: "/{index}/_settings",
+		methods: ["GET", "PUT"],
+		summary: "The index's settings; PUT changes the dynamic ones."
+	},
+	{
+		path: "/{index}/_doc",
+		methods: ["POST"],
+		summary: "Index a document under a generated id."
+	},
+	{
+		path: "/{index}/_doc/{id}",
+		methods: [
+			"GET",
+			"PUT",
+			"DELETE",
+			"HEAD"
+		],
+		summary: "One document by id: read, index (create or replace), delete, or ask whether it exists."
+	},
+	{
+		path: "/{index}/_create/{id}",
+		methods: ["PUT", "POST"],
+		summary: "Index a document only where no document has the id."
+	},
+	{
+		path: "/{index}/_update/{id}",
+		methods: ["POST"],
+		summary: "Update a document in place: a partial `doc`, or a `script`."
+	},
+	{
+		path: "/{index}/_source/{id}",
+		methods: ["GET", "HEAD"],
+		summary: "A document's source alone."
+	},
+	{
+		path: "/{index}/_mget",
+		methods: ["GET", "POST"],
+		summary: "Several documents by id."
+	},
+	{
+		path: "/_mget",
+		methods: ["GET", "POST"],
+		summary: "Several documents by index and id."
+	},
+	{
+		path: "/{index}/_update_by_query",
+		methods: ["POST"],
+		summary: "Update every document a query matches, with a script."
+	},
+	{
+		path: "/{index}/_delete_by_query",
+		methods: ["POST"],
+		summary: "Delete every document a query matches."
+	},
+	{
+		path: "/_reindex",
+		methods: ["POST"],
+		summary: "Copy documents from one index into another."
+	},
+	{
+		path: "/{index}/_refresh",
+		methods: ["GET", "POST"],
+		summary: "Make the index's recent writes searchable now."
+	},
+	{
+		path: "/_refresh",
+		methods: ["GET", "POST"],
+		summary: "Refresh every index."
+	},
+	{
+		path: "/{index}/_stats",
+		methods: ["GET"],
+		summary: "The index's statistics: documents, store, indexing, search."
+	},
+	{
+		path: "/_stats",
+		methods: ["GET"],
+		summary: "Every index's statistics."
+	},
+	{
+		path: "/{index}/_analyze",
+		methods: ["GET", "POST"],
+		summary: "Run the index's analyzer over a text and see the tokens."
+	},
+	{
+		path: "/_analyze",
+		methods: ["GET", "POST"],
+		summary: "Run an analyzer over a text and see the tokens."
+	},
+	{
+		path: "/{index}/_explain/{id}",
+		methods: ["GET", "POST"],
+		summary: "Why a document scores as it does under a query."
+	},
+	{
+		path: "/{index}/_field_caps",
+		methods: ["GET", "POST"],
+		summary: "The fields of the index and their types across indices."
+	},
+	{
+		path: "/{index}/_termvectors/{id}",
+		methods: ["GET", "POST"],
+		summary: "The terms of a document's fields, with their statistics."
+	},
+	{
+		path: "/{index}/_open",
+		methods: ["POST"],
+		summary: "Open a closed index."
+	},
+	{
+		path: "/{index}/_close",
+		methods: ["POST"],
+		summary: "Close the index."
+	},
+	{
+		path: "/{index}/_forcemerge",
+		methods: ["POST"],
+		summary: "Merge the index's segments."
+	},
+	{
+		path: "/{index}/_cache/clear",
+		methods: ["POST"],
+		summary: "Clear the index's caches."
+	},
+	{
+		path: "/{index}/_alias/{name}",
+		methods: [
+			"GET",
+			"PUT",
+			"DELETE",
+			"HEAD"
+		],
+		summary: "One alias of the index."
+	},
+	{
+		path: "/_alias",
+		methods: ["GET"],
+		summary: "Every alias."
+	},
+	{
+		path: "/_aliases",
+		methods: ["POST"],
+		summary: "Add and remove aliases in one atomic step: `actions` in the body."
+	},
+	{
+		path: "/_cat/indices",
+		methods: ["GET"],
+		summary: "The indices as a table: health, status, documents, size (`?v` for headers, `?format=json`)."
+	},
+	{
+		path: "/_cat/aliases",
+		methods: ["GET"],
+		summary: "The aliases as a table."
+	},
+	{
+		path: "/_cat/health",
+		methods: ["GET"],
+		summary: "The cluster's health as a row."
+	},
+	{
+		path: "/_cat/nodes",
+		methods: ["GET"],
+		summary: "The nodes as a table: load, heap, roles."
+	},
+	{
+		path: "/_cat/shards",
+		methods: ["GET"],
+		summary: "Every shard as a row: index, state, node."
+	},
+	{
+		path: "/_cat/count",
+		methods: ["GET"],
+		summary: "The document count of the cluster, or of an index after it."
+	},
+	{
+		path: "/_cluster/health",
+		methods: ["GET"],
+		summary: "The cluster's health: status, nodes, shards."
+	},
+	{
+		path: "/_cluster/stats",
+		methods: ["GET"],
+		summary: "The cluster's statistics."
+	},
+	{
+		path: "/_cluster/settings",
+		methods: ["GET", "PUT"],
+		summary: "The cluster's settings; PUT changes `persistent` or `transient` ones."
+	},
+	{
+		path: "/_cluster/state",
+		methods: ["GET"],
+		summary: "The cluster's state whole."
+	},
+	{
+		path: "/_nodes",
+		methods: ["GET"],
+		summary: "The nodes and their settings."
+	},
+	{
+		path: "/_nodes/stats",
+		methods: ["GET"],
+		summary: "The nodes' statistics."
+	},
+	{
+		path: "/_tasks",
+		methods: ["GET"],
+		summary: "The tasks running on the cluster."
+	},
+	{
+		path: "/_index_template/{name}",
+		methods: [
+			"GET",
+			"PUT",
+			"DELETE",
+			"HEAD"
+		],
+		summary: "An index template: patterns, settings, mappings for indices to come."
+	},
+	{
+		path: "/_index_template",
+		methods: ["GET"],
+		summary: "Every index template."
+	},
+	{
+		path: "/_component_template/{name}",
+		methods: [
+			"GET",
+			"PUT",
+			"DELETE"
+		],
+		summary: "A component template for index templates to compose."
+	},
+	{
+		path: "/_ingest/pipeline/{id}",
+		methods: [
+			"GET",
+			"PUT",
+			"DELETE"
+		],
+		summary: "An ingest pipeline: processors run on documents as they are indexed."
+	},
+	{
+		path: "/_ingest/pipeline",
+		methods: ["GET"],
+		summary: "Every ingest pipeline."
+	},
+	{
+		path: "/_scripts/{id}",
+		methods: [
+			"GET",
+			"PUT",
+			"DELETE"
+		],
+		summary: "A stored script."
+	},
+	{
+		path: "/_data_stream/{name}",
+		methods: [
+			"GET",
+			"PUT",
+			"DELETE"
+		],
+		summary: "A data stream."
+	},
+	{
+		path: "/_snapshot",
+		methods: ["GET"],
+		summary: "The snapshot repositories."
+	},
+	{
+		path: "/_license",
+		methods: ["GET"],
+		summary: "The licence the cluster runs under."
+	},
+	{
+		path: "/_xpack",
+		methods: ["GET"],
+		summary: "The features the build carries and which are enabled."
+	}
+];
+function endpointOf(path) {
+	const [pathname] = path.split("?");
+	const segments = pathname.split("/").filter((segment) => segment !== "");
+	for (const endpoint of API_ENDPOINTS) {
+		const pattern = endpoint.path.split("/").filter((segment) => segment !== "");
+		if (pattern.length === segments.length && pattern.every((part, index) => part.startsWith("{") || part === segments[index])) return endpoint;
+	}
+	return null;
+}
+function bodyKindOf(method, path) {
+	const [pathname] = path.split("?");
+	const segments = pathname.split("/").filter((segment) => segment !== "");
+	const last = segments.at(-1) ?? "";
+	if (last === "_search" || last === "_msearch") return "search";
+	if (last === "_count" || last === "_delete_by_query") return "count";
+	if (last === "_update_by_query") return "update-by-query";
+	if (segments[1] === "_explain") return "explain";
+	if (last === "_mget") return "mget";
+	if (segments[1] === "_update") return "update";
+	if (segments[1] === "_doc" || segments[1] === "_create") return "document";
+	if (last === "_mapping") return "mapping";
+	if (last === "_settings" && segments.length === 2) return "settings";
+	const first = segments[0] ?? "";
+	if (first === "_reindex") return "reindex";
+	if (first === "_aliases") return "aliases";
+	if (last === "_analyze") return "analyze";
+	if (first === "_sql") return "sql";
+	if (first === "_cluster" && last === "settings") return "cluster-settings";
+	if (first === "_index_template" || first === "_component_template") return "template";
+	if (segments.length === 1 && !first.startsWith("_") && method === "PUT") return "index";
+	return "other";
+}
+const TOP_LEVEL = {
+	search: [
+		"query",
+		"aggs",
+		"size",
+		"from",
+		"sort",
+		"_source",
+		"track_total_hits",
+		"highlight",
+		"timeout",
+		"min_score",
+		"post_filter",
+		"collapse",
+		"search_after",
+		"pit",
+		"suggest",
+		"explain",
+		"profile",
+		"stored_fields",
+		"docvalue_fields",
+		"script_fields",
+		"runtime_mappings",
+		"knn",
+		"rescore",
+		"terminate_after",
+		"version",
+		"seq_no_primary_term",
+		"indices_boost",
+		"track_scores"
+	],
+	count: ["query"],
+	index: [
+		"settings",
+		"mappings",
+		"aliases"
+	],
+	mapping: [
+		"properties",
+		"dynamic",
+		"_source",
+		"_routing",
+		"_meta",
+		"dynamic_templates",
+		"runtime"
+	],
+	settings: [
+		"index",
+		"number_of_replicas",
+		"refresh_interval",
+		"analysis"
+	],
+	document: [],
+	update: [
+		"doc",
+		"script",
+		"upsert",
+		"doc_as_upsert",
+		"scripted_upsert",
+		"detect_noop",
+		"_source"
+	],
+	"update-by-query": [
+		"query",
+		"script",
+		"conflicts",
+		"max_docs"
+	],
+	reindex: [
+		"source",
+		"dest",
+		"conflicts",
+		"script",
+		"max_docs"
+	],
+	aliases: ["actions"],
+	analyze: [
+		"analyzer",
+		"text",
+		"tokenizer",
+		"filter",
+		"char_filter",
+		"field",
+		"explain",
+		"normalizer"
+	],
+	sql: [
+		"query",
+		"fetch_size",
+		"filter",
+		"params",
+		"field_multi_value_leniency",
+		"time_zone"
+	],
+	"cluster-settings": ["persistent", "transient"],
+	template: [
+		"index_patterns",
+		"template",
+		"priority",
+		"composed_of",
+		"version",
+		"_meta",
+		"data_stream"
+	],
+	explain: ["query"],
+	mget: ["docs", "ids"],
+	other: []
+};
+const QUERY_CLAUSES = [
+	"match",
+	"match_all",
+	"match_none",
+	"match_phrase",
+	"match_phrase_prefix",
+	"multi_match",
+	"term",
+	"terms",
+	"terms_set",
+	"range",
+	"exists",
+	"prefix",
+	"wildcard",
+	"regexp",
+	"fuzzy",
+	"ids",
+	"bool",
+	"boosting",
+	"constant_score",
+	"dis_max",
+	"function_score",
+	"nested",
+	"has_child",
+	"has_parent",
+	"parent_id",
+	"query_string",
+	"simple_query_string",
+	"combined_fields",
+	"intervals",
+	"span_near",
+	"span_term",
+	"geo_distance",
+	"geo_bounding_box",
+	"geo_shape",
+	"script",
+	"script_score",
+	"knn",
+	"semantic",
+	"sparse_vector",
+	"text_expansion",
+	"percolate",
+	"more_like_this",
+	"rank_feature",
+	"distance_feature",
+	"pinned",
+	"wrapper"
+];
+const BOOL_KEYS = [
+	"must",
+	"should",
+	"must_not",
+	"filter",
+	"minimum_should_match",
+	"boost",
+	"_name"
+];
+const AGG_TYPES = [
+	"terms",
+	"avg",
+	"sum",
+	"min",
+	"max",
+	"cardinality",
+	"value_count",
+	"stats",
+	"extended_stats",
+	"percentiles",
+	"percentile_ranks",
+	"date_histogram",
+	"histogram",
+	"range",
+	"date_range",
+	"ip_range",
+	"filter",
+	"filters",
+	"nested",
+	"reverse_nested",
+	"top_hits",
+	"composite",
+	"missing",
+	"significant_terms",
+	"significant_text",
+	"rare_terms",
+	"multi_terms",
+	"auto_date_histogram",
+	"variable_width_histogram",
+	"geo_distance",
+	"geohash_grid",
+	"geotile_grid",
+	"global",
+	"sampler",
+	"diversified_sampler",
+	"scripted_metric",
+	"bucket_sort",
+	"bucket_selector",
+	"bucket_script",
+	"cumulative_sum",
+	"derivative",
+	"moving_fn",
+	"serial_diff",
+	"sum_bucket",
+	"avg_bucket",
+	"min_bucket",
+	"max_bucket",
+	"stats_bucket",
+	"aggs",
+	"meta"
+];
+const FIELD_KEYS = [
+	"type",
+	"properties",
+	"fields",
+	"analyzer",
+	"search_analyzer",
+	"format",
+	"index",
+	"doc_values",
+	"store",
+	"ignore_above",
+	"null_value",
+	"copy_to",
+	"dynamic",
+	"enabled",
+	"normalizer",
+	"coerce",
+	"ignore_malformed",
+	"boost",
+	"similarity",
+	"term_vector",
+	"norms",
+	"index_options",
+	"eager_global_ordinals",
+	"meta",
+	"dims",
+	"element_type",
+	"index_options"
+];
+const CLAUSE_KEYS = {
+	bool: BOOL_KEYS,
+	multi_match: [
+		"query",
+		"fields",
+		"type",
+		"operator",
+		"fuzziness",
+		"tie_breaker",
+		"minimum_should_match",
+		"analyzer",
+		"boost"
+	],
+	query_string: [
+		"query",
+		"default_field",
+		"fields",
+		"default_operator",
+		"analyze_wildcard",
+		"fuzziness",
+		"lenient",
+		"boost"
+	],
+	simple_query_string: [
+		"query",
+		"fields",
+		"default_operator",
+		"analyzer",
+		"flags",
+		"fuzzy_max_expansions",
+		"lenient"
+	],
+	combined_fields: [
+		"query",
+		"fields",
+		"operator",
+		"minimum_should_match",
+		"zero_terms_query"
+	],
+	exists: ["field"],
+	ids: ["values"],
+	nested: [
+		"path",
+		"query",
+		"score_mode",
+		"ignore_unmapped",
+		"inner_hits"
+	],
+	has_child: [
+		"type",
+		"query",
+		"score_mode",
+		"min_children",
+		"max_children",
+		"inner_hits"
+	],
+	has_parent: [
+		"parent_type",
+		"query",
+		"score",
+		"inner_hits"
+	],
+	boosting: [
+		"positive",
+		"negative",
+		"negative_boost"
+	],
+	constant_score: ["filter", "boost"],
+	dis_max: ["queries", "tie_breaker"],
+	function_score: [
+		"query",
+		"functions",
+		"score_mode",
+		"boost_mode",
+		"max_boost",
+		"min_score",
+		"boost",
+		"field_value_factor",
+		"random_score",
+		"script_score",
+		"weight"
+	],
+	script: ["script"],
+	script_score: [
+		"query",
+		"script",
+		"min_score"
+	],
+	knn: [
+		"field",
+		"query_vector",
+		"k",
+		"num_candidates",
+		"filter",
+		"similarity",
+		"boost"
+	],
+	more_like_this: [
+		"fields",
+		"like",
+		"unlike",
+		"min_term_freq",
+		"max_query_terms",
+		"min_doc_freq"
+	],
+	pinned: [
+		"ids",
+		"docs",
+		"organic"
+	],
+	match_all: ["boost"],
+	match_none: [],
+	geo_distance: [
+		"distance",
+		"distance_type",
+		"validation_method"
+	],
+	span_near: [
+		"clauses",
+		"slop",
+		"in_order"
+	],
+	percolate: [
+		"field",
+		"document",
+		"documents",
+		"index",
+		"id"
+	],
+	wrapper: ["query"],
+	intervals: []
+};
+const FIELD_CLAUSE_OPTIONS = {
+	match: [
+		"query",
+		"operator",
+		"fuzziness",
+		"analyzer",
+		"minimum_should_match",
+		"boost",
+		"prefix_length",
+		"max_expansions",
+		"zero_terms_query",
+		"lenient"
+	],
+	match_phrase: [
+		"query",
+		"analyzer",
+		"slop",
+		"zero_terms_query",
+		"boost"
+	],
+	match_phrase_prefix: [
+		"query",
+		"analyzer",
+		"slop",
+		"max_expansions",
+		"zero_terms_query",
+		"boost"
+	],
+	term: [
+		"value",
+		"boost",
+		"case_insensitive"
+	],
+	terms: ["boost"],
+	terms_set: [
+		"terms",
+		"minimum_should_match_field",
+		"minimum_should_match_script",
+		"boost"
+	],
+	range: [
+		"gte",
+		"gt",
+		"lte",
+		"lt",
+		"format",
+		"time_zone",
+		"relation",
+		"boost"
+	],
+	prefix: [
+		"value",
+		"boost",
+		"rewrite",
+		"case_insensitive"
+	],
+	wildcard: [
+		"value",
+		"boost",
+		"rewrite",
+		"case_insensitive"
+	],
+	regexp: [
+		"value",
+		"flags",
+		"max_determinized_states",
+		"rewrite",
+		"case_insensitive",
+		"boost"
+	],
+	fuzzy: [
+		"value",
+		"fuzziness",
+		"max_expansions",
+		"prefix_length",
+		"transpositions",
+		"rewrite",
+		"boost"
+	],
+	rank_feature: [
+		"saturation",
+		"log",
+		"sigmoid",
+		"linear",
+		"boost"
+	],
+	distance_feature: [
+		"origin",
+		"pivot",
+		"boost"
+	],
+	span_term: ["value", "boost"],
+	sparse_vector: [
+		"inference_id",
+		"query",
+		"query_vector",
+		"prune"
+	],
+	semantic: ["query", "boost"],
+	text_expansion: [
+		"model_id",
+		"model_text",
+		"pruning_config"
+	]
+};
+const QUERY_HOLDERS = /* @__PURE__ */ new Set([
+	"query",
+	"must",
+	"should",
+	"must_not",
+	"filter",
+	"post_filter",
+	"positive",
+	"negative",
+	"queries",
+	"organic",
+	"rescore_query",
+	"clauses"
+]);
+function keysUnder(last, kind) {
+	if (QUERY_HOLDERS.has(last)) return QUERY_CLAUSES;
+	if (last === "aggs" || last === "aggregations" || last === "properties") return [];
+	switch (last) {
+		case "highlight": return [
+			"fields",
+			"pre_tags",
+			"post_tags",
+			"fragment_size",
+			"number_of_fragments",
+			"type",
+			"require_field_match",
+			"order",
+			"encoder"
+		];
+		case "_source": return ["includes", "excludes"];
+		case "collapse": return [
+			"field",
+			"inner_hits",
+			"max_concurrent_group_searches"
+		];
+		case "inner_hits": return [
+			"name",
+			"size",
+			"from",
+			"sort",
+			"_source",
+			"highlight"
+		];
+		case "mappings": return TOP_LEVEL.mapping;
+		case "settings": return TOP_LEVEL.settings;
+		case "analysis": return [
+			"analyzer",
+			"tokenizer",
+			"filter",
+			"char_filter",
+			"normalizer"
+		];
+		case "template": return [
+			"settings",
+			"mappings",
+			"aliases",
+			"lifecycle"
+		];
+		case "script": return [
+			"source",
+			"id",
+			"lang",
+			"params"
+		];
+		case "sort": return ["_score", "_doc"];
+		case "source": return kind === "reindex" ? [
+			"index",
+			"query",
+			"size",
+			"_source",
+			"remote",
+			"slice"
+		] : null;
+		case "dest": return kind === "reindex" ? [
+			"index",
+			"op_type",
+			"pipeline",
+			"routing",
+			"version_type"
+		] : null;
+		default: return CLAUSE_KEYS[last] ?? null;
+	}
+}
+function bodyKeys(kind, path) {
+	const last = path.at(-1);
+	if (last === void 0) return TOP_LEVEL[kind];
+	const under = keysUnder(last, kind);
+	if (under !== null) return under;
+	const parent = path.at(-2);
+	if (parent === "aggs" || parent === "aggregations") return AGG_TYPES;
+	if (parent === "properties") return FIELD_KEYS;
+	if (last === "index" && parent === "settings") return [
+		"number_of_shards",
+		"number_of_replicas",
+		"refresh_interval",
+		"analysis",
+		"max_result_window",
+		"codec",
+		"lifecycle",
+		"routing"
+	];
+	return (parent === void 0 ? void 0 : FIELD_CLAUSE_OPTIONS[parent]) ?? [];
+}
+//#endregion
+//#region src/request.ts
+const REQUEST_METHODS = [
+	"GET",
+	"POST",
+	"PUT",
+	"DELETE",
+	"HEAD",
+	"PATCH"
+];
+const METHOD_SET = new Set(REQUEST_METHODS);
+function takesLines(path) {
+	return path.includes("/_bulk") || path.includes("/_msearch");
+}
+function readRequest(text) {
+	const start = text.length - text.trimStart().length;
+	const end = text.trimEnd().length;
+	if (start >= end) return {
+		method: "",
+		path: "",
+		body: "",
+		bodyKind: "none",
+		line: {
+			from: start,
+			to: start
+		},
+		bodySpan: null,
+		refusal: "empty"
+	};
+	const stripped = text.slice(start, end);
+	const lineBreak = stripped.indexOf("\n");
+	const lineText = (lineBreak === -1 ? stripped : stripped.slice(0, lineBreak)).trimEnd();
+	const line = {
+		from: start,
+		to: start + lineText.length
+	};
+	const rest = lineBreak === -1 ? "" : stripped.slice(lineBreak + 1);
+	const bodyStart = rest.length - rest.trimStart().length;
+	const body = rest.trim();
+	const bodySpan = body === "" ? null : {
+		from: start + lineBreak + 1 + bodyStart,
+		to: start + lineBreak + 1 + bodyStart + body.length
+	};
+	const blank = lineText.search(/\s/u);
+	const method = (blank === -1 ? lineText : lineText.slice(0, blank)).toUpperCase();
+	const path = blank === -1 ? "" : lineText.slice(blank).trim();
+	const bodyKind = body === "" ? "none" : takesLines(path) ? "ndjson" : "json";
+	let refusal = null;
+	if (path === "") refusal = "no-request-line";
+	else if (!METHOD_SET.has(method)) refusal = "unknown-method";
+	else if (!path.startsWith("/")) refusal = "path-without-slash";
+	return {
+		method,
+		path,
+		body,
+		bodyKind,
+		line,
+		bodySpan,
+		refusal
+	};
+}
+const REQUEST_LINE = /^\s*[a-z]+\s+\S/iu;
+function requestStarts(text) {
+	const starts = [];
+	let lineStart = 0;
+	for (const line of text.split("\n")) {
+		if (REQUEST_LINE.test(line)) starts.push(lineStart);
+		lineStart += line.length + 1;
+	}
+	return starts;
+}
+function requestSpans(text) {
+	const starts = requestStarts(text);
+	if (starts.length === 0) return [trimmed(text, 0, text.length)];
+	return starts.map((start, index) => trimmed(text, start, starts[index + 1] ?? text.length));
+}
+function requestAt(text, offset) {
+	const spans = requestSpans(text);
+	const lineStart = text.lastIndexOf("\n", offset - 1) + 1;
+	return spans.findLast((span) => span.from <= lineStart) ?? spans[0];
+}
+function runnableRequest(text, from, to) {
+	const span = from < to ? trimmed(text, from, to) : requestAt(text, from);
+	return span.from >= span.to ? { kind: "none" } : {
+		kind: "one",
+		text: text.slice(span.from, span.to),
+		...span
+	};
+}
+function trimmed(text, from, to) {
+	const span = text.slice(from, to);
+	return {
+		from: from + (span.length - span.trimStart().length),
+		to: to - (span.length - span.trimEnd().length)
+	};
+}
+function caretContext(text, offset) {
+	const span = requestAt(text, offset);
+	const request = readRequest(text.slice(span.from, span.to));
+	const lineFrom = span.from + request.line.from;
+	const lineTo = span.from + request.line.to;
+	if (offset >= lineFrom && offset <= lineTo) {
+		const before = text.slice(lineFrom, offset);
+		const blank = before.search(/\s/u);
+		if (blank === -1) return {
+			kind: "method",
+			typed: before
+		};
+		const pathTyped = before.slice(blank).trimStart();
+		if (!pathTyped.startsWith("/") || pathTyped.includes("?") || /\s/u.test(pathTyped)) return { kind: "none" };
+		const segments = pathTyped.slice(1).split("/");
+		return {
+			kind: "path",
+			segments: segments.slice(0, -1),
+			typed: segments.at(-1)
+		};
+	}
+	if (request.refusal !== null) return { kind: "none" };
+	if (request.bodySpan === null || offset < request.bodySpan.from + span.from) return offset > lineTo ? {
+		kind: "body-key",
+		path: [],
+		request,
+		typed: "",
+		quoted: false
+	} : { kind: "none" };
+	const bodyFrom = span.from + request.bodySpan.from;
+	const position = keyPosition(text.slice(bodyFrom, offset));
+	return position === null ? { kind: "none" } : {
+		kind: "body-key",
+		request,
+		...position
+	};
+}
+function structure(frames, character, pending) {
+	const top = frames.at(-1);
+	if (character === "}" || character === "]") {
+		frames.pop();
+		return;
+	}
+	switch (character) {
+		case "{":
+			frames.push({
+				array: false,
+				key: null,
+				expectingKey: true
+			});
+			break;
+		case "[":
+			frames.push({
+				array: true,
+				key: null,
+				expectingKey: false
+			});
+			break;
+		case ":":
+			if (top !== void 0 && !top.array) {
+				top.key = pending;
+				top.expectingKey = false;
+			}
+			break;
+		case ",": if (top !== void 0 && !top.array) {
+			top.key = null;
+			top.expectingKey = true;
+		}
+	}
+}
+function atKey(frames) {
+	const top = frames.at(-1);
+	return top !== void 0 && !top.array && top.expectingKey;
+}
+function keyPosition(body) {
+	const frames = [];
+	let i = 0;
+	let pending = "";
+	while (i < body.length) {
+		const c = body[i];
+		if (c === "\"") {
+			const end = closingQuote(body, i + 1);
+			if (end === -1) return atKey(frames) ? {
+				path: pathOf(frames),
+				typed: body.slice(i + 1),
+				quoted: true
+			} : null;
+			pending = body.slice(i + 1, end);
+			i = end + 1;
+			continue;
+		}
+		structure(frames, c, pending);
+		i++;
+	}
+	return atKey(frames) ? {
+		path: pathOf(frames),
+		typed: "",
+		quoted: false
+	} : null;
+}
+function closingQuote(body, from) {
+	let i = from;
+	while (i < body.length) {
+		if (body[i] === "\\") {
+			i += 2;
+			continue;
+		}
+		if (body[i] === "\"") return i;
+		i++;
+	}
+	return -1;
+}
+function pathOf(frames) {
+	const path = [];
+	const enclosing = frames.slice(0, -1);
+	for (const frame of enclosing) if (!frame.array && frame.key !== null) path.push(frame.key);
+	return path;
+}
+//#endregion
+//#region src/markers.ts
+function isJson(text) {
+	try {
+		JSON.parse(text);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function requestMarkers(text) {
+	const markers = [];
+	for (const span of requestSpans(text)) {
+		const request = readRequest(text.slice(span.from, span.to));
+		if (request.refusal === "empty") continue;
+		const lineFrom = span.from + request.line.from;
+		const lineTo = span.from + request.line.to;
+		if (request.refusal !== null) {
+			markers.push({
+				from: lineFrom,
+				to: lineTo,
+				code: request.refusal,
+				severity: "error"
+			});
+			continue;
+		}
+		const endpoint = endpointOf(request.path);
+		if (endpoint !== null && !endpoint.methods.includes(request.method)) markers.push({
+			from: lineFrom,
+			to: lineFrom + request.method.length,
+			code: "method-not-taken",
+			severity: "hint"
+		});
+		if (request.bodySpan === null) continue;
+		const bodyFrom = span.from + request.bodySpan.from;
+		if (request.bodyKind === "json") {
+			if (!isJson(request.body)) markers.push({
+				from: bodyFrom,
+				to: span.from + request.bodySpan.to,
+				code: "body-not-json",
+				severity: "warning"
+			});
+			continue;
+		}
+		let at = bodyFrom;
+		for (const raw of request.body.split("\n")) {
+			const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+			if (line.trim() !== "" && !isJson(line)) markers.push({
+				from: at,
+				to: at + line.length,
+				code: "body-not-json",
+				severity: "warning"
+			});
+			at += raw.length + 1;
+		}
+	}
+	return markers;
+}
+//#endregion
+export { requestAt as a, takesLines as c, bodyKindOf as d, endpointOf as f, readRequest as i, API_ENDPOINTS as l, REQUEST_METHODS as n, requestSpans as o, caretContext as r, runnableRequest as s, requestMarkers as t, bodyKeys as u };