openalgo-script 0.1.0-alpha.1 → 0.4.0

package/dist/editor/hover.js

@@ -0,0 +1,147 @@
+/**
+ * `hover`: what the thing under the pointer is.
+ *
+ * Three answers, and the difference between them is what the compiler says the
+ * word is rather than anything guessed from its spelling:
+ *
+ *     a library name    its signatures from the manifest, the line the
+ *                       specification gives it, the first bar its own row
+ *                       promises a value on, and the channels of a named colour
+ *     a declared name   the type the checker worked out, how it is held between
+ *                       bars, and where in the file it was declared
+ *     a reserved word   that it is one, and nothing else. See below
+ *
+ * ## What a hover wants and cannot have, said plainly
+ *
+ * **There is no per-word explanation of a keyword in a machine readable form.**
+ * `language.md` 3.4 reserves the words in one block and explains each one in the
+ * prose of the section that uses it, which is a page rather than a field. So a
+ * hover over `var` says it is a reserved word and stops. The alternative was to
+ * type thirty-five sentences into this file, and that is the copy that drifts:
+ * it would be right today, the specification would improve next month, and the
+ * only copy a writer ever reads would be the stale one. A host that wants more
+ * links the word to the specification, which is one page and stays current.
+ *
+ * **A name with several signatures has one description.** The specification
+ * gives every signature its own row, and the map read here is keyed by name, so
+ * `close` is described by its bar series row rather than by the order function's.
+ * Every signature is still listed: it is the sentence beside them that is the
+ * first row's.
+ *
+ * **A parameter has no description of its own anywhere.** `stdlib.md` describes
+ * a call in one line and names its parameters in the signature; only section
+ * 13's shared input arguments have a table with a meaning per argument. So
+ * `signature` shows a parameter's name, type, default and accepted values, which
+ * are facts, and no sentence, which would have to be invented.
+ *
+ * Each of those is recorded in `spec/editor-narrowings.json` beside what the
+ * adapter narrows, so a host reads them in one place rather than discovering
+ * them.
+ */
+import { endOffset, entryFor, fillTemplate, isNamespace, libraryEntries, namedColour, proseFor, typeText, } from '../core/index.js';
+import { isReserved } from './kinds.js';
+import { signatureTextOf } from './manifest.js';
+import { readChecked } from './reading.js';
+import { bindingNamed } from './scope.js';
+import { tokenOn } from './site.js';
+/**
+ * The name a word is part of, which is the dotted one when it is half of one.
+ *
+ * Pointing at `box` in `draw.box` is pointing at `draw.box`: the member on its
+ * own is an ordinary name the library does not have, and a hover that said so
+ * would be wrong about the word under the pointer.
+ */
+function nameAt(file, tokens, token) {
+    const index = tokens.indexOf(token);
+    const dot = tokens[index - 1];
+    const namespace = tokens[index - 2];
+    if (dot?.kind === '.' && namespace?.kind === 'identifier' && isNamespace(namespace.text)) {
+        return {
+            name: `${namespace.text}.${token.text}`,
+            span: file.spanAt(namespace.span.offset, endOffset(token.span) - namespace.span.offset),
+        };
+    }
+    // A namespace with a member after it is pointed at as the whole name too, so
+    // that hovering either half of `draw.box` says the same thing.
+    const next = tokens[index + 1];
+    const member = tokens[index + 2];
+    if (isNamespace(token.text) &&
+        next?.kind === '.' &&
+        member?.kind === 'identifier' &&
+        libraryEntries(`${token.text}.${member.text}`).length > 0) {
+        return {
+            name: `${token.text}.${member.text}`,
+            span: file.spanAt(token.span.offset, endOffset(member.span) - token.span.offset),
+        };
+    }
+    return { name: file.text.slice(token.span.offset, endOffset(token.span)), span: token.span };
+}
+const NOTHING = {
+    summary: undefined,
+    warmup: undefined,
+    type: undefined,
+    declaredAt: undefined,
+    colour: undefined,
+    planned: false,
+    refusal: undefined,
+};
+/**
+ * What the word at an offset is, or nothing where the offset is not on a word.
+ *
+ * A pointer over a space, a bracket, a number or a string gets nothing: those
+ * are not names, and a tooltip that appeared over a comma would be in the way
+ * rather than useful. A host that wants a literal's value has it in the text.
+ */
+export function hover(source, offset) {
+    const { file, tokens, checked } = readChecked(source);
+    const token = tokenOn(tokens, offset);
+    if (token === undefined)
+        return undefined;
+    if (isReserved(token.kind)) {
+        // A reserved word, and every one of them is also a word a script may not
+        // declare. What it means is the specification's, and there is no per-word
+        // field to read it from, which the file header states and the narrowings
+        // record.
+        return { kind: 'keyword', span: token.span, name: token.text, signatures: [], ...NOTHING };
+    }
+    if (token.kind !== 'identifier')
+        return undefined;
+    const { name, span } = nameAt(file, tokens, token);
+    const binding = bindingNamed(checked, name, offset);
+    if (binding !== undefined) {
+        const persistence = binding.persistence === 'none' ? '' : `${binding.persistence} `;
+        return {
+            kind: 'declared',
+            span,
+            name,
+            signatures: [`${persistence}${name}: ${typeText(binding.type)}`],
+            summary: undefined,
+            warmup: undefined,
+            type: typeText(binding.type),
+            declaredAt: binding.declaredAt,
+            colour: undefined,
+            planned: false,
+            refusal: undefined,
+        };
+    }
+    const entries = libraryEntries(name);
+    const first = entries[0];
+    if (first === undefined)
+        return undefined;
+    const prose = proseFor(name);
+    const planned = entries.every((one) => one.planned);
+    return {
+        kind: 'library',
+        span,
+        name,
+        signatures: entries.map(signatureTextOf),
+        summary: prose?.summary,
+        warmup: prose?.warmup,
+        type: typeText(first.returns),
+        declaredAt: undefined,
+        colour: namedColour(name),
+        planned,
+        refusal: planned ? fillTemplate(entryFor('OS2020').message, { name }) : undefined,
+    };
+}
+//# sourceMappingURL=hover.js.map

package/dist/editor/hover.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hover.js","sourceRoot":"","sources":["../../src/editor/hover.ts"],"names":[],"mappings":"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"}

package/dist/editor/index.d.ts

@@ -0,0 +1,60 @@
+/**
+ * OpenScript, the language intelligence, headless.
+ *
+ * Six pure functions, text in and data out: highlight, complete, diagnose,
+ * hover, signature, format. Three of them are here. No DOM anywhere, no package,
+ * no browser global, and nothing on screen: a host supplies the text component,
+ * the panel, the apply button, saving and revisions, and keeps its own design
+ * system. `scripts/check-layering.mjs` fails the build if this tier so much as
+ * mentions a document object, because an editor half that reaches for one is the
+ * thing that stops a platform embedding it.
+ *
+ * **None of it is hand written.** That is the whole reason it is worth shipping
+ * rather than leaving to each host, and it is a property of how each function is
+ * built rather than an intention:
+ *
+ *     highlight    the real lexer, and the language's own tables of words and
+ *                  marks decide what each token is painted as
+ *     diagnose     the whole compiler, and every message and fix comes from the
+ *                  error catalogue the documentation is generated from
+ *     format       the real lexer for the tokens and the real parser for the
+ *                  three questions spacing cannot answer without a tree
+ *
+ * A hand written version of any of them drifts from the language and nobody
+ * notices for a release: a word is added and stays grey, a diagnostic's wording
+ * improves in one place. The editor is the compiler wearing a different hat, not
+ * a second implementation to keep in step.
+ *
+ *     complete     the standard library manifest, the checker's bindings for
+ *                  what the file itself declares, and the error catalogue for
+ *                  what a planned call would be refused with
+ *     hover        the manifest again, and the specification's own tables, read
+ *                  at build time rather than retyped here
+ *     signature    the manifest and the emitter, which between them are where
+ *                  every default the compiler applies lives
+ *
+ * All six exist, so `openalgo-script/editor` is an entry point in the package's
+ * export map. It was not one while three of them were missing, because an entry
+ * point that resolves to half a tier fails at a consumer's run time rather than
+ * honestly at install.
+ *
+ * What a host loses by taking the drop-in adapter beside this rather than
+ * calling these six itself, and the three places a hover has no sentence to show
+ * because none exists in a machine readable form, are recorded together in
+ * `spec/editor-narrowings.json`.
+ */
+export type { Diagnostic, Span } from '../core/index.js';
+export type { HighlightKind } from './kinds.js';
+export type { Highlight } from './scan.js';
+export type { HighlightedLine } from './highlight.js';
+export { highlight, highlightLines } from './highlight.js';
+export { diagnose } from './diagnose.js';
+export { format } from './format.js';
+export type { Completion, CompletionKind } from './complete.js';
+export { complete } from './complete.js';
+export type { Hover, HoverKind } from './hover.js';
+export { hover } from './hover.js';
+export type { Parameter } from './manifest.js';
+export type { SignatureHelp } from './signature.js';
+export { signature } from './signature.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/editor/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/editor/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,YAAY,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAEzD,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAChD,YAAY,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAC3C,YAAY,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAE3D,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,YAAY,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAChE,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC,YAAY,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACnD,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,YAAY,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,YAAY,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/editor/index.js

@@ -0,0 +1,7 @@
+export { highlight, highlightLines } from './highlight.js';
+export { diagnose } from './diagnose.js';
+export { format } from './format.js';
+export { complete } from './complete.js';
+export { hover } from './hover.js';
+export { signature } from './signature.js';
+//# sourceMappingURL=index.js.map

package/dist/editor/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/editor/index.ts"],"names":[],"mappings":"AAkDA,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAE3D,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAGrC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAGzC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAInC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/editor/kinds.d.ts

@@ -0,0 +1,27 @@
+import type { Token, TokenKind } from '../core/index.js';
+/**
+ * What a span of source is, for the purpose of giving it a colour.
+ *
+ * Eleven kinds, and the set is closed: a host writes eleven theme rules once and
+ * never has to add a twelfth, because a new word in the language arrives as one
+ * of these rather than as a kind nobody has a colour for.
+ *
+ * `whitespace` and `unknown` exist because every character of the file is
+ * covered exactly once (see `scan.ts`), so the spaces between tokens have to be
+ * something. `unknown` is source the lexer took no token from and that is not a
+ * space or a comment: a character the language does not have, a region somebody
+ * meant as a block comment, or a line continuation backslash. It does not mean
+ * "wrong": `diagnose` says what is wrong, and a highlighter that had a second
+ * opinion about it would be a second opinion about the language.
+ */
+export type HighlightKind = 'keyword' | 'builtin' | 'name' | 'number' | 'string' | 'color' | 'comment' | 'operator' | 'punctuation' | 'whitespace' | 'unknown';
+/** Whether a token's kind is a reserved word of language.md 3.4. */
+export declare function isReserved(kind: TokenKind): boolean;
+/**
+ * The kind a token is painted as, given the tokens before it.
+ *
+ * The tokens before it are needed for exactly one question, the dotted name
+ * above. Everything else is decided by the token alone.
+ */
+export declare function kindOf(token: Token, before: readonly Token[]): HighlightKind;
+//# sourceMappingURL=kinds.d.ts.map

package/dist/editor/kinds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kinds.d.ts","sourceRoot":"","sources":["../../src/editor/kinds.ts"],"names":[],"mappings":"AAwCA,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAEzD;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,aAAa,GACrB,SAAS,GACT,SAAS,GACT,MAAM,GACN,QAAQ,GACR,QAAQ,GACR,OAAO,GACP,SAAS,GACT,UAAU,GACV,aAAa,GACb,YAAY,GACZ,SAAS,CAAC;AA0Bd,oEAAoE;AACpE,wBAAgB,UAAU,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAEnD;AA6BD;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,KAAK,EAAE,GAAG,aAAa,CAwB5E"}

package/dist/editor/kinds.js

@@ -0,0 +1,118 @@
+/**
+ * What a host paints, and where each kind comes from.
+ *
+ * A highlighter is the one part of a language tool that is always written twice:
+ * once in the compiler, where the vocabulary is decided, and once in a theme
+ * file, where somebody types the words out again from memory. The second copy is
+ * wrong from the day a word is added to the language, and nobody notices, because
+ * an unpainted keyword still compiles.
+ *
+ * So nothing below is a list of words. Every kind is decided by asking the
+ * compiler a question it already answers:
+ *
+ *     keyword      the token's kind is in the language's reserved word table
+ *     builtin      the standard library manifest has an entry for the name
+ *     operator     the mark is in one of the language's operator tables
+ *     punctuation  a mark the grammar has that no operator table claims
+ *
+ * A word added to `RESERVED_WORDS`, a function added to the manifest and a mark
+ * added to `PUNCTUATORS` are each painted the day they lex, without this file
+ * being edited.
+ *
+ * ## Why `reserved` is a question and not a comparison
+ *
+ * A token's kind is its own text for a keyword and for a punctuation mark, which
+ * is what lets a parser read `token.kind === 'if'`. A consuming platform read
+ * that as "a reserved word is a token whose kind equals its text", which is true
+ * and is folklore: it is nowhere in the token vocabulary, it silently takes in
+ * every punctuation mark as well, and it would stop being true the first time a
+ * kind and a spelling came apart. `kindOf` answers the question instead, from
+ * the same table the lexer classifies with.
+ */
+import { PUNCTUATORS, RESERVED_WORDS } from '../core/index.js';
+import { ARITHMETIC_OPERATORS, ASSIGNMENT_OPERATORS, COMPARISON_OPERATORS, EQUALITY_OPERATORS, isLibraryName, isNamespace, } from '../core/index.js';
+const RESERVED = new Set(RESERVED_WORDS);
+/**
+ * The marks that compute something, as against the marks that group and
+ * separate.
+ *
+ * Built from the language's own operator tables rather than by dividing the
+ * punctuation list by hand, so that an operator added to the language is painted
+ * as one. The tables of words, `and` and `or` and `not`, are reserved words and
+ * are painted as keywords, which is what they are to the lexer.
+ *
+ * What is left over is punctuation: the brackets, the comma, the dot, and the
+ * two marks of the ternary. They group and separate rather than compute, and a
+ * theme that wants them dimmer than the arithmetic can have that.
+ */
+const OPERATORS = new Set([
+    ...ARITHMETIC_OPERATORS,
+    ...COMPARISON_OPERATORS,
+    ...EQUALITY_OPERATORS,
+    ...ASSIGNMENT_OPERATORS,
+]);
+const PUNCTUATION = new Set(PUNCTUATORS);
+/** Whether a token's kind is a reserved word of language.md 3.4. */
+export function isReserved(kind) {
+    return RESERVED.has(kind);
+}
+/**
+ * Whether a name is one the standard library already has.
+ *
+ * The manifest is the same index the checker resolves against and the same one
+ * the example check reads its globals from, so a function added to the library
+ * is painted as a built-in on the day it is added. A namespace is included
+ * because `draw` on its own is not a value a script can hold: it is half of a
+ * dotted name, and `dotted` below finishes the question for the other half.
+ */
+function isBuiltin(name) {
+    return isLibraryName(name) || isNamespace(name);
+}
+/**
+ * The member half of a namespaced name, which is only a built-in in company.
+ *
+ * `box` is an ordinary name, and `draw.box` is a library entry. The manifest is
+ * asked about the dotted spelling, so nothing here decides what a namespace
+ * holds: `language.md` 15.2 and the manifest do.
+ */
+function dotted(before, name) {
+    const dot = before[before.length - 1];
+    const namespace = before[before.length - 2];
+    if (dot?.kind !== '.' || namespace?.kind !== 'identifier')
+        return false;
+    return isNamespace(namespace.text) && isLibraryName(`${namespace.text}.${name}`);
+}
+/**
+ * The kind a token is painted as, given the tokens before it.
+ *
+ * The tokens before it are needed for exactly one question, the dotted name
+ * above. Everything else is decided by the token alone.
+ */
+export function kindOf(token, before) {
+    switch (token.kind) {
+        case 'numberLiteral':
+            return 'number';
+        case 'stringLiteral':
+            return 'string';
+        case 'hexColor':
+            // The language's own spelling of the type is `color`, so that is the kind
+            // a host matches on, whatever the prose around it calls the thing.
+            return 'color';
+        case 'identifier':
+            return isBuiltin(token.text) || dotted(before, token.text) ? 'builtin' : 'name';
+        case 'newline':
+        case 'indent':
+        case 'dedent':
+        case 'endOfFile':
+            // Layout is the file's shape rather than something to read, and an indent
+            // token's span is the leading spaces of its line, which are spaces.
+            return 'whitespace';
+        default:
+            if (isReserved(token.kind))
+                return 'keyword';
+            if (OPERATORS.has(token.kind))
+                return 'operator';
+            return PUNCTUATION.has(token.kind) ? 'punctuation' : 'unknown';
+    }
+}
+//# sourceMappingURL=kinds.js.map

package/dist/editor/kinds.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kinds.js","sourceRoot":"","sources":["../../src/editor/kinds.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAC/D,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACpB,oBAAoB,EACpB,kBAAkB,EAClB,aAAa,EACb,WAAW,GACZ,MAAM,kBAAkB,CAAC;AA+B1B,MAAM,QAAQ,GAAwB,IAAI,GAAG,CAAS,cAAc,CAAC,CAAC;AAEtE;;;;;;;;;;;;GAYG;AACH,MAAM,SAAS,GAAwB,IAAI,GAAG,CAAS;IACrD,GAAG,oBAAoB;IACvB,GAAG,oBAAoB;IACvB,GAAG,kBAAkB;IACrB,GAAG,oBAAoB;CACxB,CAAC,CAAC;AAEH,MAAM,WAAW,GAAwB,IAAI,GAAG,CAAS,WAAW,CAAC,CAAC;AAEtE,oEAAoE;AACpE,MAAM,UAAU,UAAU,CAAC,IAAe;IACxC,OAAO,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;AAC5B,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,SAAS,CAAC,IAAY;IAC7B,OAAO,aAAa,CAAC,IAAI,CAAC,IAAI,WAAW,CAAC,IAAI,CAAC,CAAC;AAClD,CAAC;AAED;;;;;;GAMG;AACH,SAAS,MAAM,CAAC,MAAwB,EAAE,IAAY;IACpD,MAAM,GAAG,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACtC,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAC5C,IAAI,GAAG,EAAE,IAAI,KAAK,GAAG,IAAI,SAAS,EAAE,IAAI,KAAK,YAAY;QAAE,OAAO,KAAK,CAAC;IACxE,OAAO,WAAW,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,aAAa,CAAC,GAAG,SAAS,CAAC,IAAI,IAAI,IAAI,EAAE,CAAC,CAAC;AACnF,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,MAAM,CAAC,KAAY,EAAE,MAAwB;IAC3D,QAAQ,KAAK,CAAC,IAAI,EAAE,CAAC;QACnB,KAAK,eAAe;YAClB,OAAO,QAAQ,CAAC;QAClB,KAAK,eAAe;YAClB,OAAO,QAAQ,CAAC;QAClB,KAAK,UAAU;YACb,0EAA0E;YAC1E,mEAAmE;YACnE,OAAO,OAAO,CAAC;QACjB,KAAK,YAAY;YACf,OAAO,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC;QAClF,KAAK,SAAS,CAAC;QACf,KAAK,QAAQ,CAAC;QACd,KAAK,QAAQ,CAAC;QACd,KAAK,WAAW;YACd,0EAA0E;YAC1E,oEAAoE;YACpE,OAAO,YAAY,CAAC;QACtB;YACE,IAAI,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC;gBAAE,OAAO,SAAS,CAAC;YAC7C,IAAI,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC;gBAAE,OAAO,UAAU,CAAC;YACjD,OAAO,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,SAAS,CAAC;IACnE,CAAC;AACH,CAAC"}

package/dist/editor/layout.d.ts

@@ -0,0 +1,47 @@
+/**
+ * The canonical layout of a file, line by line.
+ *
+ * `language.md` 3.13 states the rules; this applies them. The two halves are
+ * separate because the specification is what another implementation writes a
+ * formatter from, and a rule that lived only here would be a rule only this
+ * formatter has.
+ *
+ * ## What is preserved, and why that is the safe direction
+ *
+ * The writer's line breaks are kept. A formatter that joined a call spanning
+ * four lines into one would be correct and unusable: it would take the layout
+ * somebody chose to make a long argument list readable and hand back a line
+ * nobody can read. So this decides indentation and spacing, which have one right
+ * answer, and leaves the choice of where to break a long statement to the person
+ * writing it, which does not.
+ *
+ * It is also the safe direction. A break that was there before is a break the
+ * lexer already accepted, so preserving them cannot turn a legal file into an
+ * illegal one, while inventing or removing one can: a statement continues onto
+ * the next line only under the three conditions of 3.11, and a formatter that
+ * moved a break would have to know them, which is the language's rule
+ * implemented twice.
+ *
+ * ## Comments
+ *
+ * A comment on a line of its own takes the indentation of the next line that
+ * carries a token, so a commented-out statement sits with the block it belongs
+ * to. This is safe for a reason worth stating: such a line produces no token at
+ * all, so its indentation says nothing about block structure and cannot open or
+ * close one (3.10). A comment after code stays where it is, two spaces clear of
+ * the code.
+ */
+import type { SourceFile, Token } from '../core/index.js';
+import type { Highlight } from './scan.js';
+import type { Shapes } from './spacing.js';
+/**
+ * The whole file, laid out.
+ *
+ * The pieces are the covering scan, which is where the comments come from and
+ * where a line continuation backslash is found. A backslash is kept wherever it
+ * was written rather than worked out again: whether a statement needs one is the
+ * lexer's rule, and the file in front of this one has already been through the
+ * lexer with it in place.
+ */
+export declare function layOut(file: SourceFile, tokens: readonly Token[], pieces: readonly Highlight[], shapes: Shapes): string;
+//# sourceMappingURL=layout.d.ts.map

package/dist/editor/layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout.d.ts","sourceRoot":"","sources":["../../src/editor/layout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC1D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AA+G3C;;;;;;;;GAQG;AACH,wBAAgB,MAAM,CACpB,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,SAAS,KAAK,EAAE,EACxB,MAAM,EAAE,SAAS,SAAS,EAAE,EAC5B,MAAM,EAAE,MAAM,GACb,MAAM,CA2BR"}

package/dist/editor/layout.js

@@ -0,0 +1,135 @@
+import { spaceBetween } from './spacing.js';
+/** One level of block, `language.md` 3.13. */
+const INDENT = '    ';
+/**
+ * What a continuation line is indented past the line that began its statement.
+ *
+ * Eight rather than four so that a continuation can never be read as the body of
+ * the header above it. `if crossUp(fast,` with its second half indented four
+ * would sit exactly where the block's first statement sits, which is legal and
+ * unreadable.
+ */
+const CONTINUATION = '        ';
+/** Two, so a trailing comment is visibly not part of the code it follows. */
+const BEFORE_COMMENT = '  ';
+const BACKSLASH = '\\';
+/**
+ * The code lines of a file, each with the indentation the canonical layout gives
+ * it.
+ *
+ * Depth comes from the lexer's own indent and dedent tokens rather than from
+ * counting spaces, so the blocks this prints are the blocks the compiler read. A
+ * line that begins a statement is indented by its depth; a line that continues
+ * one is indented past the line that began it.
+ */
+function codeLines(tokens) {
+    const lines = new Map();
+    let depth = 0;
+    let starting = true;
+    for (const token of tokens) {
+        switch (token.kind) {
+            case 'indent':
+                depth += 1;
+                continue;
+            case 'dedent':
+                depth -= 1;
+                continue;
+            case 'newline':
+                starting = true;
+                continue;
+            case 'endOfFile':
+                continue;
+            default:
+                break;
+        }
+        let line = lines.get(token.span.line);
+        if (line === undefined) {
+            const body = INDENT.repeat(Math.max(depth, 0));
+            line = { tokens: [], indent: starting ? body : body + CONTINUATION };
+            lines.set(token.span.line, line);
+        }
+        line.tokens.push(token);
+        starting = false;
+    }
+    return lines;
+}
+/** One code line as text: its indentation, then its tokens with their spacing. */
+function printCode(file, line, shapes) {
+    let text = line.indent;
+    for (const [at, token] of line.tokens.entries()) {
+        const before = line.tokens[at - 1];
+        if (before !== undefined && spaceBetween(before, token, shapes))
+            text += ' ';
+        text += file.text.slice(token.span.offset, token.span.offset + token.span.length);
+    }
+    return text;
+}
+/** The indentation of the next line that carries a token, for a comment to take. */
+function indentBelow(lines, from, last) {
+    for (let line = from + 1; line <= last; line += 1) {
+        const found = lines.get(line);
+        if (found !== undefined)
+            return found.indent;
+    }
+    return '';
+}
+/**
+ * Blank lines, as the canonical layout has them: never two in a row, never
+ * before the first line, and one line ending at the end of the file.
+ *
+ * A blank line between two paragraphs of a script is the writer's, and it is
+ * kept. A run of four is a file that has been edited for a year, and one of them
+ * says everything the four said.
+ */
+function joinLines(printed) {
+    const kept = [];
+    for (const line of printed) {
+        if (line !== undefined) {
+            kept.push(line);
+            continue;
+        }
+        if (kept.length === 0 || kept[kept.length - 1] === '')
+            continue;
+        kept.push('');
+    }
+    while (kept.length > 0 && kept[kept.length - 1] === '')
+        kept.pop();
+    return kept.length === 0 ? '' : `${kept.join('\n')}\n`;
+}
+/**
+ * The whole file, laid out.
+ *
+ * The pieces are the covering scan, which is where the comments come from and
+ * where a line continuation backslash is found. A backslash is kept wherever it
+ * was written rather than worked out again: whether a statement needs one is the
+ * lexer's rule, and the file in front of this one has already been through the
+ * lexer with it in place.
+ */
+export function layOut(file, tokens, pieces, shapes) {
+    const lines = codeLines(tokens);
+    const comments = new Map();
+    const continued = new Set();
+    for (const piece of pieces) {
+        if (piece.kind === 'comment')
+            comments.set(piece.span.line, piece.text.trimEnd());
+        else if (piece.kind === 'unknown' && piece.text === BACKSLASH)
+            continued.add(piece.span.line);
+    }
+    const printed = [];
+    for (let line = 1; line <= file.lineCount; line += 1) {
+        const code = lines.get(line);
+        const comment = comments.get(line);
+        if (code === undefined) {
+            printed.push(comment === undefined ? undefined : indentBelow(lines, line, file.lineCount) + comment);
+            continue;
+        }
+        let text = printCode(file, code, shapes);
+        if (continued.has(line))
+            text += ` ${BACKSLASH}`;
+        if (comment !== undefined)
+            text += BEFORE_COMMENT + comment;
+        printed.push(text);
+    }
+    return joinLines(printed);
+}
+//# sourceMappingURL=layout.js.map

package/dist/editor/layout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout.js","sourceRoot":"","sources":["../../src/editor/layout.ts"],"names":[],"mappings":"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"}

package/dist/editor/manifest.d.ts

@@ -0,0 +1,47 @@
+import type { LibraryEntry } from '../core/index.js';
+/** One parameter of a call, with everything a writer is shown about it. */
+export interface Parameter {
+    readonly name: string;
+    /** The type as the checker spells it: `series number`, `array<line>`. */
+    readonly type: string;
+    /** Whether the call is refused without it, which is OS3012. */
+    readonly required: boolean;
+    /**
+     * What an omitted argument resolves to, as the specification prints it.
+     *
+     * Nothing where the specification states no value: `spec/default-exceptions.json`
+     * records those and why each one has none, and a number invented to fill the
+     * gap would be the defect that file exists to keep out.
+     */
+    readonly defaultText: string | undefined;
+    /** The closed set of strings it accepts, where the library fixes one: OS3008. */
+    readonly values: readonly string[];
+}
+/** Every parameter of one signature, with the defaults from both homes. */
+export declare function parametersOf(entry: LibraryEntry): readonly Parameter[];
+/**
+ * One signature, written out the way the specification's tables write one.
+ *
+ * `ema(src: series number, len: number) -> series number`. The parameter names,
+ * the types and the defaults are the manifest's; nothing about the spelling is
+ * decided here except the punctuation between them.
+ */
+export declare function signatureTextOf(entry: LibraryEntry): string;
+/**
+ * The signature a half written call means, chosen by the rule that can be
+ * applied to a half written call.
+ *
+ * `stdlib.md` 2.2 resolves an overload by arity first and by argument type
+ * second, and the checker does exactly that. The second rule needs a type for
+ * every argument, which needs a tree, which a call that is still being typed has
+ * not got: `clear(` is two signatures until the argument arrives. So only the
+ * first rule is applied here, and where it leaves more than one candidate the
+ * first is taken, which is the order `stdlib.md` states them in.
+ *
+ * That is a narrowing of the checker's answer rather than a second opinion about
+ * it: the tooltip may show the array signature of `clear` while the writer meant
+ * the grid one, and the moment the argument is written the checker settles it
+ * and `diagnose` is what says so. It is recorded in `spec/editor-narrowings.json`.
+ */
+export declare function entryAt(name: string, given: number): LibraryEntry | undefined;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/editor/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../src/editor/manifest.ts"],"names":[],"mappings":"AAyCA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD,2EAA2E;AAC3E,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,yEAAyE;IACzE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,+DAA+D;IAC/D,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B;;;;;;OAMG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IACzC,iFAAiF;IACjF,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC;AAED,2EAA2E;AAC3E,wBAAgB,YAAY,CAAC,KAAK,EAAE,YAAY,GAAG,SAAS,SAAS,EAAE,CAWtE;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAO3D;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAU7E"}