@stepcode/codemirror 2.0.0

package/dist/index.js

@@ -0,0 +1,1722 @@
+import { Language, LanguageSupport, bracketMatching, defineLanguageFacet, foldGutter, foldNodeProp, indentNodeProp, indentOnInput, languageDataProp, syntaxTree } from "@codemirror/language";
+import { Decoration, EditorView, GutterMarker, gutter, hoverTooltip, keymap, showTooltip } from "@codemirror/view";
+import { autocompletion, snippetCompletion } from "@codemirror/autocomplete";
+import { BUILTIN_KEYS, KEYWORD_KEYS, TYPE_KEYS } from "@stepcode/profiles";
+import { BUILTIN_SIGNATURES, LineMap, UNKNOWN, arrayOf, childrenOf, compile, formatDiagnostic, scalar, typeToString } from "stepcode";
+import { NodeProp, NodeSet, NodeType, Parser, Tree } from "@lezer/common";
+import { styleTags, tags } from "@lezer/highlight";
+import { EditorState, MapMode, RangeSet, RangeSetBuilder, StateEffect, StateField } from "@codemirror/state";
+import { linter } from "@codemirror/lint";
+//#region src/arrow.ts
+const ARROW = "←";
+/** The two nodes whose text is prose, where `<-` is just two characters (spec §4.3). */
+const LITERAL_NODES = /* @__PURE__ */ new Set(["String", "Comment"]);
+function inLiteral(state, at) {
+	let node = syntaxTree(state).resolveInner(at, -1);
+	for (;;) {
+		if (LITERAL_NODES.has(node.name)) return true;
+		const parent = node.parent;
+		if (parent === null) return false;
+		node = parent;
+	}
+}
+/**
+* Spec §5.11: typing the second character of `<-` writes `←` instead, so the document keeps the
+* spelling the profile prints while the keyboard keeps the one it can reach. Off for a profile
+* that does not spell the arrow, or that assigns with `=`.
+*/
+function arrowInput(profile) {
+	if (profile.options.assignWithEquals) return [];
+	if (!profile.operators.assign.includes(ARROW)) return [];
+	return EditorView.inputHandler.of((view, from, to, text) => {
+		if (text !== "-" || from !== to || from === 0) return false;
+		if (view.state.selection.ranges.length > 1 || view.composing) return false;
+		if (view.state.sliceDoc(from - 1, from) !== "<") return false;
+		if (inLiteral(view.state, from)) return false;
+		view.dispatch({
+			changes: {
+				from: from - 1,
+				to,
+				insert: ARROW
+			},
+			selection: { anchor: from },
+			userEvent: "input.type",
+			scrollIntoView: true
+		});
+		return true;
+	});
+}
+//#endregion
+//#region src/nodes.ts
+/** One node per AST kind, plus the two plain records the tree keeps as nodes (spec §4.2). */
+const STRUCTURE_NAMES = [
+	"Program",
+	"MainBlock",
+	"SubprogramDecl",
+	"Param",
+	"TypeRef",
+	"DefineStmt",
+	"DimensionStmt",
+	"DimensionItem",
+	"ConstantStmt",
+	"AssignStmt",
+	"WriteStmt",
+	"ReadStmt",
+	"IfStmt",
+	"SwitchStmt",
+	"SwitchCase",
+	"WhileStmt",
+	"RepeatStmt",
+	"ForStmt",
+	"BreakStmt",
+	"ContinueStmt",
+	"ReturnStmt",
+	"CallStmt",
+	"ClearStmt",
+	"WaitStmt",
+	"WaitKeyStmt",
+	"ErrorStmt",
+	"Index",
+	"Call",
+	"BuiltinCall",
+	"Unary",
+	"Binary",
+	"ErrorExpr"
+];
+/** The identifier roles, all leaves (spec §4.3 rule 2). */
+const IDENTIFIER_NAMES = [
+	"Identifier",
+	"VariableDefinition",
+	"SubprogramName",
+	"CallName"
+];
+/** Every leaf type that is not a keyword. */
+const LEAF_NAMES = [
+	...IDENTIFIER_NAMES,
+	"Number",
+	"String",
+	"Boolean",
+	"TypeName",
+	"BuiltinName",
+	"AssignOp",
+	"CompareOp",
+	"ArithOp",
+	"OpenParen",
+	"CloseParen",
+	"OpenBracket",
+	"CloseBracket",
+	"Punct",
+	"Comment",
+	"Error"
+];
+/** `if` → `IfKeyword`, `writeNoNewline` → `WriteNoNewlineKeyword`. */
+function keywordNodeName(key) {
+	return `${key.charAt(0).toUpperCase()}${key.slice(1)}Keyword`;
+}
+/** Opener ↔ closer, the pairs the bracket matcher and the fold rule know (spec §4.2). */
+const MATCHING_PAIRS = [
+	["if", "endIf"],
+	["switch", "endSwitch"],
+	["while", "endWhile"],
+	["for", "endFor"],
+	["repeat", "until"],
+	["procedure", "endProcedure"],
+	["function", "endFunction"],
+	["program", "endProgram"]
+];
+/**
+* Opener ↔ closer punctuation node names (spec §4.2). The stock bracket matcher's text
+* fallback only pairs characters whose tree nodes share one type, and ours are distinct types
+* by design, so these get the same `closedBy`/`openedBy` treatment as the keyword pairs.
+*/
+const PUNCT_MATCHING_PAIRS = [["OpenParen", "CloseParen"], ["OpenBracket", "CloseBracket"]];
+const NODE_NAMES = [
+	...STRUCTURE_NAMES,
+	...LEAF_NAMES,
+	...KEYWORD_KEYS.map(keywordNodeName)
+];
+const ids = new Map(NODE_NAMES.map((name, id) => [name, id]));
+/** The id of a node type in `nodeSet`; unknown names are a programming error. */
+function nodeId(name) {
+	const id = ids.get(name);
+	if (id === void 0) throw new Error(`unknown node type: ${name}`);
+	return id;
+}
+const ERROR_NAMES = /* @__PURE__ */ new Set([
+	"Error",
+	"ErrorStmt",
+	"ErrorExpr"
+]);
+const closers = new Map([...MATCHING_PAIRS.map(([open, close]) => [keywordNodeName(open), keywordNodeName(close)]), ...PUNCT_MATCHING_PAIRS.map(([open, close]) => [open, close])]);
+const openers = new Map([...MATCHING_PAIRS.map(([open, close]) => [keywordNodeName(close), keywordNodeName(open)]), ...PUNCT_MATCHING_PAIRS.map(([open, close]) => [close, open])]);
+function propsFor(name) {
+	const closer = closers.get(name);
+	if (closer !== void 0) return [[NodeProp.closedBy, [closer]]];
+	const opener = openers.get(name);
+	if (opener !== void 0) return [[NodeProp.openedBy, [opener]]];
+	return [];
+}
+const keywords = (keys) => keys.map(keywordNodeName).join(" ");
+const CONTROL = [
+	"if",
+	"then",
+	"elseIf",
+	"else",
+	"endIf",
+	"switch",
+	"case",
+	"otherwise",
+	"endSwitch",
+	"while",
+	"do",
+	"endWhile",
+	"for",
+	"to",
+	"step",
+	"endFor",
+	"repeat",
+	"until",
+	"break",
+	"continue",
+	"return"
+];
+const DEFINITION = [
+	"program",
+	"endProgram",
+	"define",
+	"as",
+	"constant",
+	"dimension",
+	"procedure",
+	"endProcedure",
+	"function",
+	"endFunction",
+	"byRef",
+	"byValue"
+];
+const OPERATOR = [
+	"and",
+	"or",
+	"not",
+	"mod",
+	"div"
+];
+const IO = [
+	"write",
+	"writeNoNewline",
+	"read",
+	"clearScreen",
+	"wait",
+	"waitKey"
+];
+/** Spec §5.1, as one `styleTags` source. `true`/`false` only appear inside `Boolean` leaves. */
+const highlighting = styleTags({
+	[keywords(CONTROL)]: tags.controlKeyword,
+	[keywords(DEFINITION)]: tags.definitionKeyword,
+	[keywords(OPERATOR)]: tags.operatorKeyword,
+	[keywords(IO)]: tags.keyword,
+	[keywords(["true", "false"])]: tags.bool,
+	TypeName: tags.typeName,
+	BuiltinName: tags.function(tags.standard(tags.variableName)),
+	AssignOp: tags.definitionOperator,
+	CompareOp: tags.compareOperator,
+	ArithOp: tags.arithmeticOperator,
+	Number: tags.number,
+	String: tags.string,
+	Boolean: tags.bool,
+	Comment: tags.lineComment,
+	Identifier: tags.variableName,
+	VariableDefinition: tags.definition(tags.variableName),
+	SubprogramName: tags.function(tags.definition(tags.variableName)),
+	CallName: tags.function(tags.variableName),
+	"OpenParen CloseParen": tags.paren,
+	"OpenBracket CloseBracket": tags.squareBracket,
+	Punct: tags.separator,
+	"Error ErrorStmt ErrorExpr": tags.invalid
+});
+/**
+* The one node set. Built once at module load; `stepcodeLanguage` extends it per profile with
+* the language data prop on `Program`, which changes no id or name.
+*/
+const nodeSet = new NodeSet(NODE_NAMES.map((name, id) => NodeType.define({
+	id,
+	name,
+	top: name === "Program",
+	error: ERROR_NAMES.has(name),
+	props: propsFor(name)
+}))).extend(highlighting);
+//#endregion
+//#region src/blocks.ts
+const BLOCK_NAMES = [
+	"IfStmt",
+	"SwitchStmt",
+	"SwitchCase",
+	"WhileStmt",
+	"RepeatStmt",
+	"ForStmt",
+	"SubprogramDecl",
+	"MainBlock"
+];
+/** The keyword leaf that closes each block, when it has one. */
+const CLOSERS = {
+	IfStmt: ["endIf"],
+	SwitchStmt: ["endSwitch"],
+	SwitchCase: [],
+	WhileStmt: ["endWhile"],
+	RepeatStmt: ["until", "while"],
+	ForStmt: ["endFor"],
+	SubprogramDecl: ["endProcedure", "endFunction"],
+	MainBlock: ["endProgram"]
+};
+/** Lines that sit at the block's own column (spec §5.4). `SwitchStmt` handles its own. */
+const DEDENT = {
+	IfStmt: [
+		"elseIf",
+		"else",
+		"endIf"
+	],
+	SwitchStmt: ["endSwitch"],
+	SwitchCase: ["otherwise", "endSwitch"],
+	WhileStmt: ["endWhile"],
+	RepeatStmt: ["until"],
+	ForStmt: ["endFor"],
+	SubprogramDecl: ["endProcedure", "endFunction"],
+	MainBlock: ["endProgram"]
+};
+const ALL_DEDENT_KEYS = [...new Set(Object.values(DEDENT).flat())];
+/** `valor:` on its own — a case line under `Segun` (plan deviation 4). */
+const CASE_LINE = /^\s*[^:\s][^:]*:\s*$/;
+/** The closer keyword leaf of a block node, or null when it is missing or the block has none. */
+function closerOf(node) {
+	const closers = CLOSERS[node.name] ?? [];
+	for (const key of closers) {
+		const found = node.getChild(keywordNodeName(key));
+		if (found !== null) return found;
+	}
+	return null;
+}
+/** Spec §5.3. */
+function foldBlock(node, state) {
+	const from = state.doc.lineAt(node.from).to;
+	const closer = closerOf(node);
+	const to = closer === null ? node.to : closer.from;
+	return from < to ? {
+		from,
+		to
+	} : null;
+}
+/**
+* Does `text` start with one of `keys`, spelled per `profile`? Longest phrase first, up to the
+* profile's longest keyword, so `Sino Si` beats `Sino`; a trailing colon is ignored.
+*/
+function startsWithKeyword(profile, text, keys) {
+	const words = text.trim().split(/\s+/).filter((word) => word.length > 0);
+	for (let count = Math.min(profile.maxWords, words.length); count >= 1; count--) {
+		const phrase = words.slice(0, count).join(" ").replace(/:$/, "");
+		const entry = profile.lookup.get(profile.normalize(phrase));
+		if (entry?.kind === "keyword") return keys.includes(entry.key);
+	}
+	return false;
+}
+/** The end of the last non-blank text before `upto`, or null when there is none. */
+function lastTextBefore(context, upto) {
+	const doc = context.state.doc;
+	let pos = upto;
+	while (pos > 0) {
+		const line = doc.lineAt(pos - 1);
+		const text = doc.sliceString(line.from, Math.min(line.to, pos)).trimEnd();
+		if (text.length > 0) return line.from + text.length;
+		pos = line.from;
+	}
+	return null;
+}
+/** The direct child of `block` that contains the previous non-blank line's end, if any. */
+function previousChild(context, block) {
+	const end = lastTextBefore(context, context.lineAt(context.pos, -1).from);
+	if (end === null) return null;
+	let node = syntaxTree(context.state).resolveInner(end, -1);
+	while (node !== null) {
+		const parent = node.parent;
+		if (parent === null) return null;
+		if (parent.from === block.from && parent.name === block.name) return node;
+		node = parent;
+	}
+	return null;
+}
+function indentSwitch(context, profile) {
+	const text = context.textAfter;
+	const base = context.baseIndent;
+	if (startsWithKeyword(profile, text, ["endSwitch"])) return base;
+	if (startsWithKeyword(profile, text, ["otherwise"]) || CASE_LINE.test(text)) return base + context.unit;
+	const previous = previousChild(context, context.node);
+	if (previous === null) return base + context.unit;
+	if (previous.name === "SwitchCase") return context.lineIndent(previous.from) + context.unit;
+	const otherwise = context.node.getChild(keywordNodeName("otherwise"));
+	if (otherwise !== null && previous.from >= otherwise.from && previous.name !== keywordNodeName("endSwitch")) return base + 2 * context.unit;
+	return base + context.unit;
+}
+function indentCase(context, profile) {
+	const text = context.textAfter;
+	if (startsWithKeyword(profile, text, DEDENT.SwitchCase) || CASE_LINE.test(text)) return context.continue();
+	return context.baseIndent + context.unit;
+}
+const BLOCK_NAME_SET = new Set(BLOCK_NAMES);
+/**
+* A nested block that ends on the previous non-blank line without its closer: error recovery
+* cut it short (`Segun x Hacer` with no case yet), so the line being indented is still its body.
+*/
+function unclosedOpenerBefore(context, block) {
+	const previous = previousChild(context, block);
+	if (previous === null || !BLOCK_NAME_SET.has(previous.name)) return null;
+	return closerOf(previous) === null ? previous : null;
+}
+/**
+* The indentation of a line that follows `block`'s body without being part of `block` in the tree:
+* its own column for a line that closes it (or, under a case, opens the next one), one unit past
+* that column otherwise.
+*/
+function indentAfterBlock(context, profile, block) {
+	const column = context.lineIndent(block.from);
+	const name = block.name;
+	if (startsWithKeyword(profile, context.textAfter, DEDENT[name])) return column;
+	if (name === "SwitchCase" && CASE_LINE.test(context.textAfter)) return column;
+	return column + context.unit;
+}
+function indentBlock(context, profile) {
+	const name = context.node.name;
+	if (name === "SwitchStmt") return indentSwitch(context, profile);
+	if (name === "SwitchCase") return indentCase(context, profile);
+	if (startsWithKeyword(profile, context.textAfter, DEDENT[name])) return context.baseIndent;
+	const opener = unclosedOpenerBefore(context, context.node);
+	if (opener !== null) return indentAfterBlock(context, profile, opener);
+	return context.baseIndent + context.unit;
+}
+/** The innermost block still waiting for its closer at the last non-blank text before `context.pos`. */
+function openBlockBefore(context) {
+	const end = lastTextBefore(context, context.lineAt(context.pos, -1).from);
+	if (end === null) return null;
+	let node = syntaxTree(context.state).resolveInner(end, -1);
+	while (node !== null) {
+		if (BLOCK_NAME_SET.has(node.name) && closerOf(node) === null) return node;
+		node = node.parent;
+	}
+	return null;
+}
+/**
+* `Program` always covers the position, so this rule catches the line being typed under a block
+* whose closer does not exist yet: the tree stops at the last text, leaving no block node over the
+* new line. Indent it as the open block above it would (spec §5.4).
+*/
+function indentProgram(context, profile) {
+	const block = openBlockBefore(context);
+	return block === null ? 0 : indentAfterBlock(context, profile, block);
+}
+/** The fold and indent props for every block node, bound to one profile's spellings. */
+function blockProps(profile) {
+	const fold = {};
+	const indent = {};
+	for (const name of BLOCK_NAMES) {
+		fold[name] = foldBlock;
+		indent[name] = (context) => indentBlock(context, profile);
+	}
+	indent.Program = (context) => indentProgram(context, profile);
+	return [foldNodeProp.add(fold), indentNodeProp.add(indent)];
+}
+const escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/**
+* Spec §5.4: re-indent a line once it reads as a dedent keyword (every spelling of every
+* dedent key, longest first) or as a case line.
+*/
+function indentOnInputPatterns(profile) {
+	const spellings = [...new Set(ALL_DEDENT_KEYS.flatMap((key) => profile.keywords[key] ?? []))].sort((a, b) => b.length - a.length).map(escapeRegExp);
+	const flags = profile.options.caseSensitive ? "" : "i";
+	const alternation = spellings.length === 0 ? "(?!)" : `(?:${spellings.join("|")})`;
+	return [new RegExp(`^\\s*${alternation}$`, flags), /^\s*[^:\s][^:]*:$/];
+}
+//#endregion
+//#region src/tree.ts
+const compileProp = new NodeProp({ perNode: true });
+const isNode = (one) => "kind" in one;
+const recordName = (one) => "values" in one ? "SwitchCase" : "DimensionItem";
+const bySource = (list) => list.sort((a, b) => a.tokens[0] - b.tokens[0]);
+/** `childrenOf`, except that switch cases and dimension items stay whole (spec §4.3 rule 1). */
+function childrenFor(one) {
+	if (!isNode(one)) return "values" in one ? [...one.values, ...one.body] : [one.name, ...one.sizes];
+	switch (one.kind) {
+		case "SwitchStmt": return bySource([
+			one.selector,
+			...one.cases,
+			...one.otherwise ?? []
+		]);
+		case "DimensionStmt": return [...one.items];
+		default: return childrenOf(one);
+	}
+}
+/** Spec §4.3 rule 2: the leaf name of an identifier, from the field its parent holds it in. */
+function identifierRole(id, parent) {
+	if (parent === null) return "Identifier";
+	if (!isNode(parent)) return !("values" in parent) && parent.name === id ? "VariableDefinition" : "Identifier";
+	switch (parent.kind) {
+		case "MainBlock": return parent.name === id ? "SubprogramName" : "Identifier";
+		case "SubprogramDecl":
+			if (parent.name === id) return "SubprogramName";
+			return parent.returnName === id ? "VariableDefinition" : "Identifier";
+		case "Param":
+		case "ConstantStmt": return parent.name === id ? "VariableDefinition" : "Identifier";
+		case "DefineStmt": return parent.names.includes(id) ? "VariableDefinition" : "Identifier";
+		case "Call": return parent.callee === id ? "CallName" : "Identifier";
+		default: return "Identifier";
+	}
+}
+function literalLeaf(literal) {
+	switch (literal.type) {
+		case "string": return "String";
+		case "boolean": return "Boolean";
+		default: return "Number";
+	}
+}
+const COMPARE = /* @__PURE__ */ new Set([
+	"equal",
+	"notEqual",
+	"lt",
+	"le",
+	"gt",
+	"ge"
+]);
+const PUNCT = /* @__PURE__ */ new Map([
+	["(", "OpenParen"],
+	[")", "CloseParen"],
+	["[", "OpenBracket"],
+	["]", "CloseBracket"]
+]);
+/** The leaf type of a token, or `null` for the trivia the tree drops (spec §4.2). */
+function tokenLeaf(token) {
+	switch (token.kind) {
+		case "keyword": return keywordNodeName(token.value);
+		case "type": return "TypeName";
+		case "builtin": return "BuiltinName";
+		case "operator": {
+			const key = token.value;
+			if (key === "assign") return "AssignOp";
+			return COMPARE.has(key) ? "CompareOp" : "ArithOp";
+		}
+		case "identifier": return "Identifier";
+		case "integer":
+		case "real": return "Number";
+		case "string": return "String";
+		case "punct": return PUNCT.get(token.text) ?? "Punct";
+		case "comment": return "Comment";
+		case "error": return "Error";
+		default: return null;
+	}
+}
+/**
+* Emits the postfix buffer `Tree.build` wants: every child before its parent, four numbers
+* per node. Recursive over the AST; a program deep enough to matter here is not one an
+* editor shows.
+*/
+var Builder = class {
+	tokens;
+	buffer = [];
+	identifiers = /* @__PURE__ */ new Map();
+	calls = /* @__PURE__ */ new Map();
+	constructor(tokens) {
+		this.tokens = tokens;
+	}
+	leaf(name, start, end) {
+		this.buffer.push(nodeId(name), start, end, 4);
+	}
+	/** Leaves for the tokens `first..last` (inclusive) that no child claimed. */
+	tokensBetween(first, last) {
+		for (let index = first; index <= last; index++) {
+			const token = this.tokens[index];
+			if (token === void 0) continue;
+			const name = tokenLeaf(token);
+			if (name !== null) this.leaf(name, token.span.start, token.span.end);
+		}
+	}
+	/**
+	* The children and loose tokens of `one`, without `one` itself. `range` defaults to the
+	* node's own token range; the top level passes the whole stream, so a comment written
+	* before the program or after it still becomes a leaf under `Program`.
+	*/
+	emitChildren(one, range = one.tokens) {
+		const [first, last] = range;
+		let next = first;
+		for (const child of childrenFor(one)) {
+			const [childFirst, childLast] = child.tokens;
+			this.tokensBetween(next, childFirst - 1);
+			this.emit(child, one);
+			next = Math.max(next, childLast + 1);
+		}
+		this.tokensBetween(next, last);
+	}
+	emit(one, parent) {
+		if (isNode(one)) {
+			if (one.kind === "Identifier") {
+				if (one.missing === true) return;
+				this.identifiers.set(one.span.start, one);
+				this.leaf(identifierRole(one, parent), one.span.start, one.span.end);
+				return;
+			}
+			if (one.kind === "Literal") {
+				this.leaf(literalLeaf(one), one.span.start, one.span.end);
+				return;
+			}
+			if (one.kind === "Call" || one.kind === "BuiltinCall") this.calls.set(one.span.start, one);
+		}
+		const start = this.buffer.length;
+		this.emitChildren(one);
+		const name = isNode(one) ? one.kind : recordName(one);
+		this.buffer.push(nodeId(name), one.span.start, one.span.end, this.buffer.length - start + 4);
+	}
+};
+/**
+* The Lezer tree for one compile result. `set` is the node set to build with — the base set,
+* or a language's extension of it; ids are the same either way.
+*/
+function buildTree(result, set = nodeSet) {
+	const builder = new Builder(result.tokens);
+	builder.emitChildren(result.ast, [0, result.tokens.length - 1]);
+	const built = Tree.build({
+		buffer: builder.buffer,
+		nodeSet: set,
+		topID: nodeId("Program"),
+		length: result.source.length
+	});
+	const data = {
+		result,
+		identifiers: builder.identifiers,
+		calls: builder.calls
+	};
+	return new Tree(built.type, built.children, built.positions, built.length, [[compileProp, data]]);
+}
+//#endregion
+//#region src/parser.ts
+/**
+* Spec §4.1: one `advance()` compiles the whole input and returns its tree. Not incremental;
+* `fragments` and `ranges` are accepted and ignored, `stopAt` is recorded and ignored.
+*/
+var StepcodeParser = class extends Parser {
+	profile;
+	set;
+	constructor(profile, set) {
+		super();
+		this.profile = profile;
+		this.set = set;
+	}
+	createParse(input, _fragments, _ranges) {
+		const profile = this.profile;
+		const set = this.set;
+		let parsedPos = 0;
+		let stoppedAt = null;
+		return {
+			get parsedPos() {
+				return parsedPos;
+			},
+			get stoppedAt() {
+				return stoppedAt;
+			},
+			stopAt(pos) {
+				stoppedAt = pos;
+			},
+			advance() {
+				const tree = buildTree(compile(input.read(0, input.length), { profile }), set);
+				parsedPos = input.length;
+				return tree;
+			}
+		};
+	}
+};
+/** The language data for a profile: comment tokens only. */
+function languageData(profile) {
+	return { commentTokens: { line: profile.operators.comment[0] ?? "//" } };
+}
+const languages = /* @__PURE__ */ new WeakMap();
+/**
+* One `Language` per profile object, cached: `stepcodeCompletion` registers through its data
+* facet, so every extension built for a profile must see the same instance.
+*
+* The cache keys on object identity (a `WeakMap`), so a profile must not be mutated after it is
+* first passed here — a later mutation would silently apply to the cached `Language` too.
+*/
+function stepcodeLanguage(profile) {
+	const cached = languages.get(profile);
+	if (cached !== void 0) return cached;
+	const data = defineLanguageFacet(languageData(profile));
+	const set = nodeSet.extend(languageDataProp.add({ Program: data }), ...blockProps(profile));
+	const rules = indentOnInputPatterns(profile).map((pattern) => data.of({ indentOnInput: pattern }));
+	const language = new Language(data, new StepcodeParser(profile, set), rules, "stepcode");
+	languages.set(profile, language);
+	return language;
+}
+/** The data on the current tree, or `null` before a parse has produced one. */
+function treeDataAt(state) {
+	return syntaxTree(state).prop(compileProp) ?? null;
+}
+function compileResultAt(state) {
+	return treeDataAt(state)?.result ?? null;
+}
+//#endregion
+//#region src/snippets.ts
+const CURSOR = "${}";
+const field = (name) => `\${${name}}`;
+/**
+* The templates, spelled per profile. Body lines start with a tab, which the snippet library
+* turns into one indent unit relative to the line the snippet lands on.
+*/
+function blockTemplates(profile, strings) {
+	const kw = (key) => profile.keywords[key]?.[0] ?? key;
+	const assign = profile.options.assignWithEquals ? "=" : profile.operators.assign[0] ?? "<-";
+	const p = strings.placeholders;
+	const lines = (...parts) => parts.join("\n");
+	return /* @__PURE__ */ new Map([
+		["if", lines(`${kw("if")} ${field(p.condition)} ${kw("then")}`, `\t${CURSOR}`, kw("endIf"))],
+		["while", lines(`${kw("while")} ${field(p.condition)} ${kw("do")}`, `\t${CURSOR}`, kw("endWhile"))],
+		["for", lines(`${kw("for")} ${field(p.counter)} ${assign} ${field(p.start)} ${kw("to")} ${field(p.limit)} ${kw("do")}`, `\t${CURSOR}`, kw("endFor"))],
+		["repeat", lines(kw("repeat"), `\t${CURSOR}`, `${kw("until")} ${field(p.condition)}`)],
+		["switch", lines(`${kw("switch")} ${field(p.value)} ${kw("do")}`, `\t${field(p.case)}:`, `\t\t${CURSOR}`, `\t${kw("otherwise")}:`, "		", kw("endSwitch"))],
+		["function", lines(`${kw("function")} ${field(p.result)} ${assign} ${field(p.name)}(${field(p.parameters)})`, `\t${CURSOR}`, kw("endFunction"))],
+		["procedure", lines(`${kw("procedure")} ${field(p.name)}(${field(p.parameters)})`, `\t${CURSOR}`, kw("endProcedure"))],
+		["program", lines(`${kw("program")} ${field(p.name)}`, `\t${CURSOR}`, kw("endProgram"))]
+	]);
+}
+/**
+* The one-line statements, spelled per profile. The trailing `;` is written only where the
+* profile requires terminators, so a PSeInt-style program never gains one it would reject.
+*/
+function statementTemplates(profile, strings) {
+	const kw = (key) => profile.keywords[key]?.[0] ?? key;
+	const p = strings.placeholders;
+	const end = profile.options.requireSemicolons ? ";" : "";
+	const stmt = (text) => `${text}${end}${CURSOR}`;
+	return /* @__PURE__ */ new Map([
+		["define", stmt(`${kw("define")} ${field(p.variable)} ${kw("as")} ${field(p.type)}`)],
+		["dimension", stmt(`${kw("dimension")} ${field(p.variable)}[${field(p.size)}]`)],
+		["write", stmt(`${kw("write")} ${field(p.message)}`)],
+		["writeNoNewline", stmt(`${kw("writeNoNewline")} ${field(p.message)}`)],
+		["read", stmt(`${kw("read")} ${field(p.variable)}`)],
+		["return", stmt(`${kw("return")} ${field(p.value)}`)],
+		["break", stmt(kw("break"))],
+		["continue", stmt(kw("continue"))],
+		["else", `${kw("else")}\n\t${CURSOR}`],
+		["elseIf", `${kw("elseIf")} ${field(p.condition)} ${kw("then")}\n\t${CURSOR}`]
+	]);
+}
+/** One keyword completion per opener, applying its template. */
+function blockSnippets(profile, strings) {
+	const out = /* @__PURE__ */ new Map();
+	for (const [key, template] of blockTemplates(profile, strings)) {
+		const label = profile.keywords[key]?.[0];
+		if (label === void 0 || label.length === 0) continue;
+		out.set(key, snippetCompletion(template, {
+			label,
+			type: "keyword",
+			info: strings.descriptions.keywords[key],
+			boost: 0
+		}));
+	}
+	return out;
+}
+/** Every keyword whose completion applies a template: the block openers and the statements. */
+function keywordSnippets(profile, strings) {
+	const out = new Map(blockSnippets(profile, strings));
+	for (const [key, template] of statementTemplates(profile, strings)) {
+		const label = profile.keywords[key]?.[0];
+		if (label === void 0 || label.length === 0) continue;
+		out.set(key, snippetCompletion(template, {
+			label,
+			type: "keyword",
+			info: strings.descriptions.keywords[key],
+			boost: 0
+		}));
+	}
+	return out;
+}
+//#endregion
+//#region src/strings.ts
+const es = {
+	kinds: {
+		variable: "variable",
+		parameter: "parámetro",
+		result: "resultado",
+		constant: "constante",
+		counter: "contador",
+		subprogram: "subprograma"
+	},
+	procedure: "procedimiento",
+	function: "función",
+	byReference: "por referencia",
+	declaredAt: (line) => `declarada en la línea ${line}`,
+	replaceWith: (name) => `Cambiar a «${name}»`,
+	operandClass: {
+		numeric: "número",
+		text: "texto",
+		boolean: "lógico",
+		integer: "entero",
+		scalar: "valor"
+	},
+	same: "igual al argumento",
+	placeholders: {
+		condition: "condicion",
+		value: "valor",
+		name: "nombre",
+		parameters: "parametros",
+		result: "resultado",
+		counter: "contador",
+		start: "inicio",
+		limit: "limite",
+		case: "caso",
+		variable: "variable",
+		type: "tipo",
+		message: "mensaje",
+		size: "tamano"
+	},
+	descriptions: {
+		keywords: {
+			program: "Marca donde empieza el programa principal.",
+			endProgram: "Marca donde termina el programa principal.",
+			define: "Crea una variable nueva y dice de qué tipo es.",
+			as: "Une el nombre de la variable con su tipo.",
+			constant: "Crea un valor con nombre que nunca cambia.",
+			dimension: "Crea un arreglo con la cantidad de casillas que indiques.",
+			if: "Ejecuta unas instrucciones solo si la condición se cumple.",
+			then: "Empieza las instrucciones que se ejecutan cuando la condición se cumple.",
+			elseIf: "Prueba otra condición cuando la anterior no se cumplió.",
+			else: "Ejecuta estas instrucciones cuando ninguna condición se cumplió.",
+			endIf: "Cierra la instrucción condicional.",
+			switch: "Elige un camino comparando un valor con varios casos.",
+			case: "Empieza el camino que corresponde a un valor concreto.",
+			otherwise: "Empieza el camino que se toma cuando ningún caso coincide.",
+			endSwitch: "Cierra la selección por casos.",
+			while: "Repite instrucciones mientras la condición siga cumpliéndose.",
+			do: "Empieza el cuerpo que se repite.",
+			endWhile: "Cierra el ciclo que repite mientras se cumple una condición.",
+			for: "Repite instrucciones contando desde un valor hasta otro.",
+			to: "Indica el valor hasta el que cuenta el ciclo.",
+			step: "Indica de cuánto en cuánto avanza el contador.",
+			endFor: "Cierra el ciclo que cuenta.",
+			repeat: "Repite instrucciones al menos una vez y prueba la condición al final.",
+			until: "Indica la condición que detiene el ciclo.",
+			break: "Sale del ciclo de inmediato.",
+			continue: "Salta al siguiente turno del ciclo.",
+			procedure: "Define un grupo de instrucciones con nombre que no devuelve un valor.",
+			endProcedure: "Cierra la definición del subproceso.",
+			function: "Define un grupo de instrucciones con nombre que devuelve un valor.",
+			endFunction: "Cierra la definición de la función.",
+			return: "Termina el subprograma y devuelve un valor.",
+			byRef: "Hace que el parámetro comparta la variable de quien llama.",
+			byValue: "Hace que el parámetro reciba una copia del valor.",
+			write: "Muestra un valor en la consola.",
+			writeNoNewline: "Muestra un valor en la consola sin pasar a la línea siguiente.",
+			read: "Lee un valor escrito por el usuario y lo guarda en la variable.",
+			clearScreen: "Borra todo lo que hay escrito en la consola.",
+			wait: "Detiene el programa durante el tiempo indicado.",
+			waitKey: "Detiene el programa hasta que el usuario presione una tecla.",
+			and: "Es verdadero solo si las dos condiciones son verdaderas.",
+			or: "Es verdadero si al menos una de las dos condiciones es verdadera.",
+			not: "Invierte una condición: lo verdadero pasa a falso.",
+			mod: "Da el residuo de una división entera.",
+			div: "Da el cociente entero de una división.",
+			true: "El valor lógico verdadero.",
+			false: "El valor lógico falso."
+		},
+		types: {
+			integer: "Números sin decimales.",
+			real: "Números con decimales.",
+			string: "Texto: una serie de caracteres entre comillas.",
+			char: "Un solo carácter.",
+			boolean: "Solo dos valores posibles: verdadero o falso."
+		},
+		builtins: {
+			abs: "Da el valor de un número sin su signo.",
+			sqrt: "Da la raíz cuadrada de un número.",
+			ln: "Da el logaritmo natural de un número.",
+			exp: "Eleva el número e a la potencia indicada.",
+			sin: "Da el seno de un ángulo medido en radianes.",
+			cos: "Da el coseno de un ángulo medido en radianes.",
+			tan: "Da la tangente de un ángulo medido en radianes.",
+			asin: "Da el ángulo en radianes cuyo seno es el valor dado.",
+			acos: "Da el ángulo en radianes cuyo coseno es el valor dado.",
+			atan: "Da el ángulo en radianes cuya tangente es el valor dado.",
+			trunc: "Quita los decimales de un número.",
+			round: "Redondea un número al entero más cercano.",
+			random: "Da un número al azar entre 0 y 1.",
+			randomBetween: "Da un número entero al azar dentro del rango indicado.",
+			pi: "El valor de pi.",
+			length: "Da cuántos caracteres tiene un texto.",
+			upper: "Convierte un texto a mayúsculas.",
+			lower: "Convierte un texto a minúsculas.",
+			substring: "Da el trozo de texto que hay entre dos posiciones.",
+			concat: "Une dos textos en uno solo.",
+			toNumber: "Convierte un texto en número.",
+			toText: "Convierte un número en texto."
+		}
+	}
+};
+const en = {
+	kinds: {
+		variable: "variable",
+		parameter: "parameter",
+		result: "result",
+		constant: "constant",
+		counter: "counter",
+		subprogram: "subprogram"
+	},
+	procedure: "procedure",
+	function: "function",
+	byReference: "by reference",
+	declaredAt: (line) => `declared on line ${line}`,
+	replaceWith: (name) => `Replace with "${name}"`,
+	operandClass: {
+		numeric: "number",
+		text: "text",
+		boolean: "boolean",
+		integer: "integer",
+		scalar: "value"
+	},
+	same: "same as the argument",
+	placeholders: {
+		condition: "condition",
+		value: "value",
+		name: "name",
+		parameters: "parameters",
+		result: "result",
+		counter: "counter",
+		start: "start",
+		limit: "limit",
+		case: "case",
+		variable: "variable",
+		type: "type",
+		message: "message",
+		size: "size"
+	},
+	descriptions: {
+		keywords: {
+			program: "Marks where the main program starts.",
+			endProgram: "Marks where the main program ends.",
+			define: "Creates a new variable and says what type it holds.",
+			as: "Joins a variable name to its type.",
+			constant: "Creates a named value that never changes.",
+			dimension: "Creates an array with as many slots as you ask for.",
+			if: "Runs some instructions only when the condition holds.",
+			then: "Starts the instructions that run when the condition holds.",
+			elseIf: "Tries another condition when the previous one did not hold.",
+			else: "Runs these instructions when no condition held.",
+			endIf: "Closes the conditional instruction.",
+			switch: "Picks one path by comparing a value against several cases.",
+			case: "Starts the path for one particular value.",
+			otherwise: "Starts the path taken when no case matches.",
+			endSwitch: "Closes the selection by cases.",
+			while: "Repeats instructions while the condition keeps holding.",
+			do: "Starts the body that repeats.",
+			endWhile: "Closes the loop that repeats while a condition holds.",
+			for: "Repeats instructions counting from one value up to another.",
+			to: "Gives the value the loop counts up to.",
+			step: "Gives how much the counter advances each turn.",
+			endFor: "Closes the counting loop.",
+			repeat: "Repeats instructions at least once and tests the condition at the end.",
+			until: "Gives the condition that stops the loop.",
+			break: "Leaves the loop right away.",
+			continue: "Jumps to the next turn of the loop.",
+			procedure: "Defines a named group of instructions that returns no value.",
+			endProcedure: "Closes the procedure definition.",
+			function: "Defines a named group of instructions that returns a value.",
+			endFunction: "Closes the function definition.",
+			return: "Ends the subprogram and hands a value back.",
+			byRef: "Makes the parameter share the caller variable.",
+			byValue: "Makes the parameter receive a copy of the value.",
+			write: "Shows a value in the console.",
+			writeNoNewline: "Shows a value in the console without moving to the next line.",
+			read: "Reads a value typed by the user and stores it in the variable.",
+			clearScreen: "Erases everything written in the console.",
+			wait: "Pauses the program for the time given.",
+			waitKey: "Pauses the program until the user presses a key.",
+			and: "True only when both conditions are true.",
+			or: "True when at least one of the two conditions is true.",
+			not: "Flips a condition: what was true becomes false.",
+			mod: "Gives the remainder of an integer division.",
+			div: "Gives the whole-number quotient of a division.",
+			true: "The boolean value true.",
+			false: "The boolean value false."
+		},
+		types: {
+			integer: "Numbers with no decimals.",
+			real: "Numbers with decimals.",
+			string: "Text: a run of characters between quotes.",
+			char: "A single character.",
+			boolean: "Only two possible values: true or false."
+		},
+		builtins: {
+			abs: "Gives a number without its sign.",
+			sqrt: "Gives the square root of a number.",
+			ln: "Gives the natural logarithm of a number.",
+			exp: "Raises the number e to the given power.",
+			sin: "Gives the sine of an angle measured in radians.",
+			cos: "Gives the cosine of an angle measured in radians.",
+			tan: "Gives the tangent of an angle measured in radians.",
+			asin: "Gives the angle in radians whose sine is the given value.",
+			acos: "Gives the angle in radians whose cosine is the given value.",
+			atan: "Gives the angle in radians whose tangent is the given value.",
+			trunc: "Drops the decimals of a number.",
+			round: "Rounds a number to the nearest whole number.",
+			random: "Gives a random number between 0 and 1.",
+			randomBetween: "Gives a random whole number inside the given range.",
+			pi: "The value of pi.",
+			length: "Gives how many characters a text has.",
+			upper: "Turns a text into upper case.",
+			lower: "Turns a text into lower case.",
+			substring: "Gives the piece of text between two positions.",
+			concat: "Joins two texts into one.",
+			toNumber: "Turns a text into a number.",
+			toText: "Turns a number into text."
+		}
+	}
+};
+const TABLES = {
+	es,
+	en
+};
+/** The table for a BCP-47 tag: exact, then primary subtag (`es-MX` → `es`), then `en`. */
+function stringsFor(locale) {
+	const exact = TABLES[locale];
+	if (exact !== void 0) return exact;
+	const primary = locale.split("-")[0] ?? "";
+	return TABLES[primary] ?? en;
+}
+//#endregion
+//#region src/symbols.ts
+const IDENTIFIERS = new Set(IDENTIFIER_NAMES);
+/**
+* The identifier leaf ending at `pos` (side -1), starting at it (side 1), or either (0, the
+* leaf ending there first) — a cursor touches a word from both sides.
+*/
+function identifierLeafAt(state, pos, side = 0) {
+	const tree = syntaxTree(state);
+	const sides = side === 0 ? [-1, 1] : [side];
+	for (const one of sides) {
+		const node = tree.resolveInner(pos, one);
+		if (IDENTIFIERS.has(node.name)) return node;
+	}
+	return null;
+}
+/** The leaf at `pos` and the checker symbol it resolved to, or null. */
+function symbolAt(state, pos, side = 0) {
+	const leaf = identifierLeafAt(state, pos, side);
+	const data = treeDataAt(state);
+	if (leaf === null || data === null) return null;
+	const identifier = data.identifiers.get(leaf.from);
+	if (identifier === void 0) return null;
+	const symbol = data.result.symbols.get(identifier);
+	return symbol === void 0 ? null : {
+		leaf,
+		symbol
+	};
+}
+/**
+* The innermost body scope whose owner contains `pos`, else the program scope. Bodies do nest:
+* a subprogram written inside another one (E2015) keeps its place in the source, so its span
+* lies inside the enclosing body's. `scopes` is build order, not nesting order, so the
+* narrowest containing owner wins rather than the first one listed.
+*/
+function scopeAt(result, pos) {
+	const program = result.scopes[0];
+	if (program === void 0) throw new Error("a compile result always has a program scope");
+	let innermost = program;
+	let width = Number.POSITIVE_INFINITY;
+	for (const scope of result.scopes) {
+		if (scope.kind !== "body") continue;
+		const { span } = scope.owner;
+		if (span.start > pos || pos > span.end || span.end - span.start >= width) continue;
+		innermost = scope;
+		width = span.end - span.start;
+	}
+	return innermost;
+}
+/**
+* Spec §5.6: the symbols usable at `pos` — the scope chain from the innermost, a name once,
+* declarations after the cursor excluded except subprograms, recovery symbols never.
+*/
+function visibleSymbols(result, pos) {
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (let scope = scopeAt(result, pos); scope !== null; scope = scope.parent) for (const symbol of scope.order) {
+		if (seen.has(symbol.name) || symbol.recovered === true) continue;
+		if (symbol.kind !== "subprogram" && symbol.declaredAt.span.start >= pos) continue;
+		seen.add(symbol.name);
+		out.push(symbol);
+	}
+	return out;
+}
+/** The name as the declaration wrote it; a result variable's from the header. */
+function symbolLabel(symbol) {
+	const at = symbol.declaredAt;
+	if (at.kind === "Identifier") return at.text;
+	if (at.kind === "SubprogramDecl" && at.returnName !== void 0) return at.returnName.text;
+	return symbol.name;
+}
+/** The builtin a spelling names under `profile`, or null. */
+function builtinKeyAt(profile, text) {
+	const entry = profile.lookup.get(profile.normalize(text));
+	return entry?.kind === "builtin" ? entry.key : null;
+}
+/** `Name(p1, p2) : result`, spec §5.6, with the parameter at `activeIndex` flagged. */
+function builtinSignatureParts(key, profile, strings, activeIndex = -1) {
+	const signature = BUILTIN_SIGNATURES[key];
+	const parts = [{
+		text: `${profile.builtins[key]?.[0] ?? key}(`,
+		active: false
+	}];
+	signature.params.forEach((operand, index) => {
+		if (index > 0) parts.push({
+			text: ", ",
+			active: false
+		});
+		parts.push({
+			text: strings.operandClass[operand],
+			active: index === activeIndex
+		});
+	});
+	const result = signature.result === "same" ? strings.same : typeToString(signature.result, profile);
+	parts.push({
+		text: `) : ${result}`,
+		active: false
+	});
+	return parts;
+}
+const signatureText = (parts) => parts.map((part) => part.text).join("");
+//#endregion
+//#region src/completion.ts
+const WORD = /[\p{L}_][\p{L}\p{N}_]*$/u;
+const VALID = /^[\p{L}_][\p{L}\p{N}_]*$/u;
+const BOOST = {
+	symbol: 3,
+	builtin: 2,
+	type: 1,
+	keyword: 0
+};
+/** `name(<cursor>)` for a callable with parameters, `name()<cursor>` without. */
+function callCompletion(label, hasParams, completion) {
+	return snippetCompletion(hasParams ? `${label}(\${})` : `${label}()\${}`, completion);
+}
+function symbolCompletions(result, pos, profile, strings) {
+	return visibleSymbols(result, pos).map((symbol) => {
+		const label = symbolLabel(symbol);
+		if (symbol.kind === "subprogram") {
+			const decl = symbol.decl;
+			return callCompletion(label, decl !== void 0 && decl.params.length > 0, {
+				label,
+				type: "function",
+				detail: decl?.form === "function" ? strings.function : strings.procedure,
+				boost: BOOST.symbol
+			});
+		}
+		return {
+			label,
+			type: symbol.kind === "constant" ? "constant" : "variable",
+			detail: typeToString(symbol.type, profile),
+			boost: BOOST.symbol
+		};
+	});
+}
+function builtinCompletions(profile, strings) {
+	const out = [];
+	for (const key of BUILTIN_KEYS) {
+		const label = profile.builtins[key]?.[0];
+		if (label === void 0) continue;
+		const detail = signatureText(builtinSignatureParts(key, profile, strings)).slice(label.length);
+		out.push(callCompletion(label, BUILTIN_SIGNATURES[key].params.length > 0, {
+			label,
+			type: "function",
+			detail,
+			info: strings.descriptions.builtins[key],
+			boost: BOOST.builtin
+		}));
+	}
+	return out;
+}
+function typeCompletions(profile, strings) {
+	const out = [];
+	for (const key of TYPE_KEYS) {
+		const label = profile.types[key]?.[0];
+		if (label !== void 0) out.push({
+			label,
+			type: "type",
+			info: strings.descriptions.types[key],
+			boost: BOOST.type
+		});
+	}
+	return out;
+}
+/** Every keyword with a spelling; the block openers apply their snippet (spec §5.7). */
+function keywordCompletions(profile, strings) {
+	const snippets = keywordSnippets(profile, strings);
+	const out = [];
+	for (const key of KEYWORD_KEYS) {
+		const label = profile.keywords[key]?.[0];
+		if (label === void 0 || label.length === 0) continue;
+		const snippet = snippets.get(key);
+		out.push(snippet ?? {
+			label,
+			type: "keyword",
+			info: strings.descriptions.keywords[key],
+			boost: BOOST.keyword
+		});
+	}
+	return out;
+}
+/** Spec §5.6. */
+function completionSourceFor(options) {
+	const { profile } = options;
+	const strings = stringsFor(options.locale);
+	const fixed = [
+		...builtinCompletions(profile, strings),
+		...typeCompletions(profile, strings),
+		...keywordCompletions(profile, strings)
+	];
+	return (context) => {
+		const word = context.matchBefore(WORD);
+		if (word === null && !context.explicit) return null;
+		const node = syntaxTree(context.state).resolveInner(context.pos, -1);
+		if (node.name === "Comment" || node.name === "String") return null;
+		const data = treeDataAt(context.state);
+		const symbols = data === null ? [] : symbolCompletions(data.result, context.pos, profile, strings);
+		return {
+			from: word?.from ?? context.pos,
+			options: [...symbols, ...fixed],
+			validFor: VALID
+		};
+	};
+}
+/** The source, registered through the language's data so `autocompletion()` picks it up. */
+function stepcodeCompletion(options) {
+	return stepcodeLanguage(options.profile).data.of({ autocomplete: completionSourceFor(options) });
+}
+//#endregion
+//#region src/theme.ts
+/** Spec §8: class hooks with a minimal look; hosts restyle by class. */
+const stepcodeBaseTheme = EditorView.baseTheme({
+	".cm-gutter.cm-stepcode-breakpoints": {
+		minWidth: "1.4em",
+		cursor: "pointer"
+	},
+	".cm-stepcode-breakpoints .cm-gutterElement": {
+		display: "flex",
+		alignItems: "center",
+		justifyContent: "center",
+		gap: "0.1em"
+	},
+	".cm-stepcode-breakpoint, .cm-stepcode-breakpoint-spacer": {
+		width: "0.7em",
+		height: "0.7em",
+		borderRadius: "50%"
+	},
+	".cm-stepcode-breakpoint": { backgroundColor: "#d33" },
+	".cm-stepcode-current-line-marker": {
+		width: "0",
+		height: "0",
+		borderTop: "0.4em solid transparent",
+		borderBottom: "0.4em solid transparent",
+		borderLeft: "0.6em solid #d9a400"
+	},
+	"&light .cm-stepcode-current-line": { backgroundColor: "rgba(255, 220, 0, 0.25)" },
+	"&dark .cm-stepcode-current-line": { backgroundColor: "rgba(255, 220, 0, 0.15)" },
+	".cm-tooltip .cm-stepcode-hover, .cm-tooltip .cm-stepcode-signature": {
+		padding: "0.3em 0.5em",
+		fontFamily: "monospace"
+	},
+	".cm-stepcode-signature-active": { fontWeight: "bold" },
+	"&light .cm-matchingBracket, &dark .cm-matchingBracket": {
+		backgroundColor: "transparent",
+		outline: "1px solid #4a8"
+	},
+	"&light .cm-nonmatchingBracket, &dark .cm-nonmatchingBracket": {
+		backgroundColor: "transparent",
+		outline: "1px solid #c44"
+	}
+});
+//#endregion
+//#region src/debug.ts
+const toggleBreakpoint = StateEffect.define();
+const setBreakpoints = StateEffect.define();
+const setCurrentLine = StateEffect.define();
+var BreakpointMarker = class BreakpointMarker extends GutterMarker {
+	toDOM() {
+		const dom = document.createElement("div");
+		dom.className = "cm-stepcode-breakpoint";
+		return dom;
+	}
+	eq(other) {
+		return other instanceof BreakpointMarker;
+	}
+};
+var CurrentLineMarker = class CurrentLineMarker extends GutterMarker {
+	toDOM() {
+		const dom = document.createElement("div");
+		dom.className = "cm-stepcode-current-line-marker";
+		return dom;
+	}
+	eq(other) {
+		return other instanceof CurrentLineMarker;
+	}
+};
+/**
+* Sizes the gutter for a breakpoint dot without rendering one: the gutter keeps this marker's
+* DOM permanently mounted (hidden) for width measurement, so it must not share the
+* `.cm-stepcode-breakpoint` class or it would inflate any count of real markers.
+*/
+var SpacerMarker = class SpacerMarker extends GutterMarker {
+	toDOM() {
+		const dom = document.createElement("div");
+		dom.className = "cm-stepcode-breakpoint-spacer";
+		return dom;
+	}
+	eq(other) {
+		return other instanceof SpacerMarker;
+	}
+};
+const breakpointMarker = new BreakpointMarker();
+const currentLineMarker = new CurrentLineMarker();
+const spacerMarker = new SpacerMarker();
+/**
+* Where the start of the line at `lineFrom` lands after `changes`, or null when the line is
+* gone: its whole content was deleted, or — for an empty line — its line break was.
+*/
+function mapLineStart(changes, oldDoc, lineFrom) {
+	const line = oldDoc.lineAt(lineFrom);
+	if (line.length === 0) return changes.mapPos(line.from, -1, MapMode.TrackAfter);
+	const from = changes.mapPos(line.from, -1);
+	return from === changes.mapPos(line.to, 1) ? null : from;
+}
+function markersAt(positions) {
+	const builder = new RangeSetBuilder();
+	let last = -1;
+	for (const pos of [...positions].sort((a, b) => a - b)) {
+		if (pos === last) continue;
+		builder.add(pos, pos, breakpointMarker);
+		last = pos;
+	}
+	return builder.finish();
+}
+function positionsOf(set) {
+	const out = [];
+	for (const cursor = set.iter(); cursor.value !== null; cursor.next()) out.push(cursor.from);
+	return out;
+}
+function lineStart(state, line) {
+	return line >= 1 && line <= state.doc.lines ? state.doc.line(line).from : null;
+}
+function remap(set, tr) {
+	const positions = [];
+	for (const pos of positionsOf(set)) {
+		const mapped = mapLineStart(tr.changes, tr.startState.doc, pos);
+		if (mapped !== null) positions.push(tr.state.doc.lineAt(mapped).from);
+	}
+	return markersAt(positions);
+}
+const breakpointField = StateField.define({
+	create: () => RangeSet.empty,
+	update(value, tr) {
+		let set = tr.docChanged ? remap(value, tr) : value;
+		for (const effect of tr.effects) if (effect.is(toggleBreakpoint)) {
+			const from = lineStart(tr.state, effect.value.line);
+			if (from === null) continue;
+			const positions = positionsOf(set);
+			set = markersAt(positions.includes(from) ? positions.filter((pos) => pos !== from) : [...positions, from]);
+		} else if (effect.is(setBreakpoints)) set = markersAt(effect.value.map((line) => lineStart(tr.state, line)).filter((pos) => pos !== null));
+		return set;
+	}
+});
+const currentLineDecoration = Decoration.line({ class: "cm-stepcode-current-line" });
+/** The start offset of the current line, or null. */
+const currentLineField = StateField.define({
+	create: () => null,
+	update(value, tr) {
+		let next = value;
+		if (next !== null && tr.docChanged) {
+			const mapped = mapLineStart(tr.changes, tr.startState.doc, next);
+			next = mapped === null ? null : tr.state.doc.lineAt(mapped).from;
+		}
+		for (const effect of tr.effects) if (effect.is(setCurrentLine)) next = effect.value === null ? null : lineStart(tr.state, effect.value);
+		return next;
+	},
+	provide: (field) => EditorView.decorations.from(field, (value) => value === null ? Decoration.none : Decoration.set(currentLineDecoration.range(value)))
+});
+/** Spec §6.2: setting a line also scrolls it into view. */
+const scrollToCurrentLine = EditorState.transactionExtender.of((tr) => {
+	for (const effect of tr.effects) {
+		if (!effect.is(setCurrentLine) || effect.value === null) continue;
+		const line = effect.value;
+		if (line < 1 || line > tr.newDoc.lines) continue;
+		return { effects: EditorView.scrollIntoView(tr.newDoc.line(line).from, { y: "nearest" }) };
+	}
+	return null;
+});
+/** One gutter for both: breakpoint markers and the current-line arrow (spec §6.1). */
+const debugGutter = gutter({
+	class: "cm-stepcode-breakpoints",
+	markers: (view) => view.state.field(breakpointField, false) ?? RangeSet.empty,
+	lineMarker: (view, line) => {
+		const current = view.state.field(currentLineField, false);
+		return current !== void 0 && current !== null && current === line.from ? currentLineMarker : null;
+	},
+	lineMarkerChange: (update) => update.startState.field(currentLineField, false) !== update.state.field(currentLineField, false),
+	initialSpacer: () => spacerMarker,
+	domEventHandlers: { mousedown: toggleOnMouseDown }
+});
+/** Spec §6.1: only the primary (left) button toggles a breakpoint. */
+function toggleOnMouseDown(view, line, event) {
+	if (event.button !== 0) return false;
+	view.dispatch({ effects: toggleBreakpoint.of({ line: view.state.doc.lineAt(line.from).number }) });
+	return true;
+}
+/**
+* Renders standalone: `stepcodeBaseTheme` rides along so its markers are visible even without
+* `stepcode()`. `EditorState` dedupes identical extension values by identity, so combining this
+* with `stepcode()` still installs the theme once.
+*/
+function breakpoints() {
+	return [
+		breakpointField,
+		debugGutter,
+		stepcodeBaseTheme
+	];
+}
+/** Renders standalone; see `breakpoints()` on why `stepcodeBaseTheme` is included here too. */
+function currentLine() {
+	return [
+		currentLineField,
+		scrollToCurrentLine,
+		debugGutter,
+		stepcodeBaseTheme
+	];
+}
+function debug() {
+	return [breakpoints(), currentLine()];
+}
+/** 1-based, ascending; empty without the extension. */
+function breakpointLines(state) {
+	const set = state.field(breakpointField, false);
+	if (set === void 0) return [];
+	return positionsOf(set).map((pos) => state.doc.lineAt(pos).number);
+}
+/** True when the update changed the breakpoint set — the host's cue to resend it. */
+function breakpointsChanged(update) {
+	return update.startState.field(breakpointField, false) !== update.state.field(breakpointField, false);
+}
+/** 1-based, or null. */
+function currentLineOf(state) {
+	const pos = state.field(currentLineField, false);
+	return pos === void 0 || pos === null ? null : state.doc.lineAt(pos).number;
+}
+//#endregion
+//#region src/definition.ts
+/** The start of the declaration of the name at `pos`, or null (spec §5.10). */
+function definitionAt(state, pos) {
+	const found = symbolAt(state, pos, 0);
+	if (found === null || found.symbol.recovered === true) return null;
+	return found.symbol.declaredAt.span.start;
+}
+const goToDefinition = (view) => {
+	const target = definitionAt(view.state, view.state.selection.main.head);
+	if (target === null) return false;
+	view.dispatch({
+		selection: { anchor: target },
+		effects: EditorView.scrollIntoView(target, { y: "center" })
+	});
+	return true;
+};
+/** F12 only; a mouse gesture is the host's choice (spec §5.10). */
+const stepcodeKeymap = [{
+	key: "F12",
+	run: goToDefinition
+}];
+//#endregion
+//#region src/hover.ts
+const KEYWORD_BY_NODE = new Map(KEYWORD_KEYS.map((key) => [keywordNodeName(key), key]));
+/**
+* What a function returns. The subprogram symbol itself is never typed — the checker types the
+* result variable the header names, and type inference writes the inferred type there — so read
+* that symbol, falling back to the declared return type of the `f(): T` form.
+*/
+function resultType(decl, result) {
+	const named = decl.returnName === void 0 ? void 0 : result.symbols.get(decl.returnName);
+	if (named !== void 0) return named.type;
+	const ref = decl.returnType;
+	if (ref === void 0) return UNKNOWN;
+	return ref.dimensions.length === 0 ? scalar(ref.base) : arrayOf(ref.base, ref.dimensions.length);
+}
+/** `<kind> <name>: <type> (por referencia)` — the first hover line (spec §5.9). */
+function describe(symbol, result, options, strings) {
+	const name = symbolLabel(symbol);
+	const decl = symbol.decl;
+	if (symbol.kind === "subprogram") {
+		if (decl === void 0 || decl.form !== "function") return `${strings.procedure} ${name}`;
+		return `${strings.function} ${name}: ${typeToString(resultType(decl, result), options.profile)}`;
+	}
+	const byRef = symbol.byRef === true ? ` (${strings.byReference})` : "";
+	const type = typeToString(symbol.type, options.profile);
+	return `${strings.kinds[symbol.kind]} ${name}: ${type}${byRef}`;
+}
+function hoverInfoAt(state, pos, side, options) {
+	const strings = stringsFor(options.locale);
+	const found = symbolAt(state, pos, side);
+	if (found !== null) {
+		const data = treeDataAt(state);
+		if (data === null || found.symbol.recovered === true) return null;
+		const line = new LineMap(data.result.source).positionAt(found.symbol.declaredAt.span.start).line;
+		return {
+			from: found.leaf.from,
+			to: found.leaf.to,
+			lines: [describe(found.symbol, data.result, options, strings), strings.declaredAt(line)]
+		};
+	}
+	const node = syntaxTree(state).resolveInner(pos, side);
+	const keyword = KEYWORD_BY_NODE.get(node.name);
+	if (keyword !== void 0) return {
+		from: node.from,
+		to: node.to,
+		lines: [state.doc.sliceString(node.from, node.to), strings.descriptions.keywords[keyword]]
+	};
+	if (node.name !== "BuiltinName") return null;
+	const key = builtinKeyAt(options.profile, state.doc.sliceString(node.from, node.to));
+	if (key === null) return null;
+	const parts = builtinSignatureParts(key, options.profile, strings);
+	return {
+		from: node.from,
+		to: node.to,
+		lines: [signatureText(parts), strings.descriptions.builtins[key]]
+	};
+}
+function hoverSource(options) {
+	return (view, pos, side) => {
+		const info = hoverInfoAt(view.state, pos, side, options);
+		if (info === null) return null;
+		return {
+			pos: info.from,
+			end: info.to,
+			above: true,
+			create: () => {
+				const dom = document.createElement("div");
+				dom.className = "cm-stepcode-hover";
+				for (const line of info.lines) {
+					const row = document.createElement("div");
+					row.textContent = line;
+					dom.appendChild(row);
+				}
+				return { dom };
+			}
+		};
+	};
+}
+/** Spec §5.9. */
+function stepcodeHover(options) {
+	return hoverTooltip(hoverSource(options));
+}
+//#endregion
+//#region src/lint.ts
+/**
+* Spec §5.2: a zero-width span is widened one character to the right, or to the left at the
+* end of its line, so the squiggle is visible; an empty line or document stays empty.
+*/
+function widen(state, span) {
+	if (span.end > span.start) return {
+		from: span.start,
+		to: span.end
+	};
+	const line = state.doc.lineAt(span.start);
+	if (span.start < line.to) return {
+		from: span.start,
+		to: span.start + 1
+	};
+	if (span.start > line.from) return {
+		from: span.start - 1,
+		to: span.start
+	};
+	return {
+		from: span.start,
+		to: span.start
+	};
+}
+/** The tree's compile diagnostics as CodeMirror diagnostics; empty before the first parse. */
+function stepcodeDiagnostics(state, options) {
+	const data = treeDataAt(state);
+	if (data === null) return [];
+	const strings = stringsFor(options.locale);
+	return data.result.diagnostics.map((diagnostic) => {
+		const { from, to } = widen(state, diagnostic.span);
+		const base = {
+			from,
+			to,
+			severity: diagnostic.severity,
+			source: diagnostic.code,
+			message: formatDiagnostic(diagnostic, options.locale, options.profile)
+		};
+		const suggestion = diagnostic.data.suggestion;
+		if (typeof suggestion !== "string") return base;
+		return {
+			...base,
+			actions: [{
+				name: strings.replaceWith(suggestion),
+				apply: (view, actionFrom, actionTo) => {
+					view.dispatch({ changes: {
+						from: actionFrom,
+						to: actionTo,
+						insert: suggestion
+					} });
+				}
+			}]
+		};
+	});
+}
+/** Lint from the tree, re-run after every completed parse. */
+function stepcodeLint(options) {
+	return linter((view) => stepcodeDiagnostics(view.state, options), {
+		delay: 250,
+		needsRefresh: (update) => syntaxTree(update.state) !== syntaxTree(update.startState)
+	});
+}
+//#endregion
+//#region src/matching.ts
+/**
+* Spec §5.5: the stock matcher. Keyword, parenthesis, and bracket pairs all come from the
+* `closedBy` / `openedBy` props on the leaves (spec §4.2); the `brackets` text config stays as
+* the fallback for text the tree does not type.
+*/
+function stepcodeBlockMatching() {
+	return bracketMatching({ brackets: "()[]" });
+}
+//#endregion
+//#region src/signature.ts
+/** The innermost call whose argument list contains `pos` (spec §5.8), with its parenthesis. */
+function callAround(state, pos) {
+	for (let node = syntaxTree(state).resolveInner(pos, -1); node !== null; node = node.parent) {
+		if (node.name !== "Call" && node.name !== "BuiltinCall") continue;
+		const open = node.getChild("OpenParen");
+		if (open === null || open.to > pos) continue;
+		const close = node.getChild("CloseParen");
+		if (close !== null && pos > close.from) continue;
+		return {
+			node,
+			open
+		};
+	}
+	return null;
+}
+/** The number of argument separators of `call` that end at or before `pos`. */
+function activeArgument(state, call, pos) {
+	let count = 0;
+	for (const punct of call.getChildren("Punct")) if (punct.to <= pos && state.doc.sliceString(punct.from, punct.to) === ",") count++;
+	return count;
+}
+/**
+* Where a header stops: after its parameter list's closing parenthesis. The search stays on
+* the line the parameters end on, and a declaration written without a parameter list at all
+* ends at its name — otherwise a parenthesis in the body would be taken for the list's.
+*/
+function headerEnd(decl, source) {
+	const last = decl.params[decl.params.length - 1];
+	const paramsEnd = last === void 0 ? decl.name.span.end : last.span.end;
+	const newline = source.indexOf("\n", paramsEnd);
+	const rest = source.slice(paramsEnd, newline < 0 ? source.length : newline);
+	if (last === void 0 && !rest.trimStart().startsWith("(")) return paramsEnd;
+	const closeParen = rest.indexOf(")");
+	return closeParen < 0 ? paramsEnd : paramsEnd + closeParen + 1;
+}
+/** The header of a declaration, its parameters split out so one can be marked active. */
+function headerParts(decl, source, active) {
+	const end = headerEnd(decl, source);
+	const parts = [];
+	let cursor = decl.span.start;
+	decl.params.forEach((param, index) => {
+		if (param.span.start > cursor) parts.push({
+			text: source.slice(cursor, param.span.start),
+			active: false
+		});
+		parts.push({
+			text: source.slice(param.span.start, param.span.end),
+			active: index === active
+		});
+		cursor = param.span.end;
+	});
+	parts.push({
+		text: source.slice(cursor, end),
+		active: false
+	});
+	return parts;
+}
+function signatureAt(state, pos, options) {
+	const data = treeDataAt(state);
+	const found = callAround(state, pos);
+	if (data === null || found === null) return null;
+	const call = data.calls.get(found.node.from);
+	if (call === void 0) return null;
+	const active = activeArgument(state, found.node, pos);
+	if (call.kind === "BuiltinCall") {
+		const parts = builtinSignatureParts(call.key, options.profile, stringsFor(options.locale), active);
+		return {
+			pos: found.open.from,
+			parts
+		};
+	}
+	const decl = data.result.calls.get(call);
+	if (decl === void 0) return null;
+	return {
+		pos: found.open.from,
+		parts: headerParts(decl, data.result.source, active)
+	};
+}
+function tooltipsFor(state, options) {
+	const signature = signatureAt(state, state.selection.main.head, options);
+	if (signature === null) return [];
+	return [{
+		pos: signature.pos,
+		above: true,
+		create: () => {
+			const dom = document.createElement("div");
+			dom.className = "cm-stepcode-signature";
+			for (const part of signature.parts) {
+				const span = document.createElement("span");
+				if (part.active) span.className = "cm-stepcode-signature-active";
+				span.textContent = part.text;
+				dom.appendChild(span);
+			}
+			return { dom };
+		}
+	}];
+}
+/** Spec §5.8: a tooltip field recomputed on selection, document and tree changes. */
+function stepcodeSignatureHelp(options) {
+	return StateField.define({
+		create: (state) => tooltipsFor(state, options),
+		update: (value, tr) => tr.docChanged || tr.selection !== void 0 || syntaxTree(tr.state) !== syntaxTree(tr.startState) ? tooltipsFor(tr.state, options) : value,
+		provide: (field) => showTooltip.computeN([field], (state) => state.field(field))
+	});
+}
+//#endregion
+//#region src/stepcode.ts
+/**
+* Spec §7: everything for one profile. Deliberately absent: a highlight style, the lint
+* gutter, line numbers, history and the default keymap — those are the host's.
+*/
+function stepcode(options) {
+	const resolved = {
+		profile: options.profile,
+		locale: options.locale ?? options.profile.locale
+	};
+	return new LanguageSupport(stepcodeLanguage(resolved.profile), [
+		stepcodeLint(resolved),
+		stepcodeCompletion(resolved),
+		stepcodeSignatureHelp(resolved),
+		stepcodeHover(resolved),
+		stepcodeBlockMatching(),
+		...options.completion === false ? [] : [autocompletion()],
+		...options.arrow === false ? [] : [arrowInput(resolved.profile)],
+		indentOnInput(),
+		foldGutter(),
+		keymap.of(stepcodeKeymap),
+		stepcodeBaseTheme
+	]);
+}
+//#endregion
+export { arrowInput, breakpointLines, breakpoints, breakpointsChanged, compileResultAt, currentLine, currentLineOf, debug, goToDefinition, setBreakpoints, setCurrentLine, stepcode, stepcodeBlockMatching, stepcodeCompletion, stepcodeDiagnostics, stepcodeHover, stepcodeKeymap, stepcodeLanguage, stepcodeLint, stepcodeSignatureHelp, toggleBreakpoint, treeDataAt };