openalgo-script 0.2.0 → 0.4.0

package/dist/editor/signature.js

@@ -0,0 +1,112 @@
+/**
+ * `signature`: the call being written, and which parameter the cursor is in.
+ *
+ * The call is found from the brackets rather than from the tree, because a call
+ * being written has no finished tree node: `ema(close, ` is the state every call
+ * is in while somebody types one, and that is exactly when this is asked.
+ * `site.ts` does that part.
+ *
+ * ## The default shown is the default the compiler applies
+ *
+ * This is the trap worth naming, because getting it wrong produces a tooltip
+ * that is confidently wrong rather than absent. `stdlib.md` states a default for
+ * every optional argument, and `scripts/check-defaults.mjs` already holds the
+ * compiler to those: a value the surface carries that the specification does not
+ * state fails the build, and so does one the specification states that the
+ * compiler does not apply.
+ *
+ * So this reads the same two places that check reads, through `parametersOf`:
+ * the library manifest for an ordinary call, and the emitter for the eight
+ * declaration calls whose optional arguments become fields of a declaration
+ * rather than arguments. A number shown here therefore cannot differ from the
+ * number the compiler fills in; if it ever does, the defaults check fails before
+ * anybody sees the tooltip.
+ *
+ * A writer's own function is answered too, from the checker's record of it. Its
+ * parameter types are the ones the checker worked out, and a default it declares
+ * is quoted from the source text rather than printed from the tree, because the
+ * text is what the writer wrote.
+ */
+import { endOffset, entryFor, fillTemplate, proseFor, typeText } from '../core/index.js';
+import { entryAt, parametersOf, signatureTextOf } from './manifest.js';
+import { readChecked } from './reading.js';
+import { siteAt } from './site.js';
+/** Which parameter a position in the argument list means. */
+function activeIn(parameters, call) {
+    if (call.label !== undefined) {
+        return parameters.findIndex((one) => one.name === call.label);
+    }
+    return call.argument < parameters.length ? call.argument : -1;
+}
+/**
+ * A function the file declares, as the checker recorded it.
+ *
+ * `language.md` 11.1 lets a parameter carry a default, and the text of that
+ * default is quoted from the source rather than printed back from the tree: the
+ * tree holds an expression and printing one would be a second formatter, while
+ * the source holds what the writer typed.
+ */
+function declaredSignature(checked, text, call) {
+    const held = checked.functions.find((one) => one.declaration.name.text === call.name);
+    if (held === undefined)
+        return undefined;
+    const parameters = held.declaration.parameters.map((one, index) => {
+        const value = one.defaultValue;
+        const binding = held.parameters[index];
+        return {
+            name: one.name.text,
+            type: binding === undefined ? 'unknown' : typeText(binding.type),
+            required: value === undefined,
+            defaultText: value === undefined ? undefined : text.slice(value.span.offset, endOffset(value.span)),
+            values: [],
+        };
+    });
+    const written = parameters.map((one) => {
+        const head = `${one.name}${one.required ? '' : '?'}: ${one.type}`;
+        return one.defaultText === undefined ? head : `${head} = ${one.defaultText}`;
+    });
+    return {
+        name: call.name,
+        of: 'declared',
+        signature: `fn ${call.name}(${written.join(', ')})`,
+        parameters,
+        active: activeIn(parameters, call),
+        summary: undefined,
+        planned: false,
+        refusal: undefined,
+        span: call.nameSpan,
+    };
+}
+/**
+ * The call the cursor is inside, or nothing where it is inside none.
+ *
+ * Nothing is the answer for a cursor outside every bracket, and for one inside a
+ * bracket whose callee the language does not have: a name that resolves to
+ * neither the library nor the file is OS2001, and `diagnose` is what says so.
+ * A tooltip that invented a signature for it would be a second opinion about
+ * what the file declares.
+ */
+export function signature(source, offset) {
+    const { file, tokens, checked } = readChecked(source);
+    const call = siteAt(file, tokens, offset).call;
+    if (call === undefined)
+        return undefined;
+    const entry = entryAt(call.name, call.argument + 1);
+    if (entry === undefined)
+        return declaredSignature(checked, file.text, call);
+    const parameters = parametersOf(entry);
+    return {
+        name: call.name,
+        of: 'library',
+        signature: signatureTextOf(entry),
+        parameters,
+        active: activeIn(parameters, call),
+        summary: proseFor(call.name)?.summary,
+        planned: entry.planned,
+        refusal: entry.planned
+            ? fillTemplate(entryFor('OS2020').message, { name: call.name })
+            : undefined,
+        span: call.nameSpan,
+    };
+}
+//# sourceMappingURL=signature.js.map

package/dist/editor/signature.js.map

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

package/dist/editor/site.d.ts

@@ -0,0 +1,46 @@
+import type { SourceFile, Span, Token } from '../core/index.js';
+/** The call the cursor is inside, as far as the brackets say. */
+export interface CallSite {
+    /** The callee as written, with its namespace: `ema`, `draw.box`. */
+    readonly name: string;
+    readonly nameSpan: Span;
+    /** Which argument the cursor is in, counting from zero. */
+    readonly argument: number;
+    /** The label written for this argument, when it was written as `name = ...`. */
+    readonly label: string | undefined;
+    /** Every label already written in this call, so a completion can drop them. */
+    readonly labels: readonly string[];
+    /** The bracket that opened it, which is what a host anchors a tooltip to. */
+    readonly open: Span;
+}
+/** What the cursor is on, and what it is inside. */
+export interface Site {
+    /** The word being typed, when the cursor is in or at the end of one. */
+    readonly word: string;
+    /** Where it sits, so a host replaces the word rather than inserting into it. */
+    readonly replace: Span;
+    /** The namespace the word follows, when it was written as `draw.` */
+    readonly namespace: string | undefined;
+    /** Whether the cursor sits after a dot, where only members may be written. */
+    readonly afterDot: boolean;
+    readonly call: CallSite | undefined;
+}
+/**
+ * Everything the two functions need to know about a position.
+ *
+ * The word is the token the offset is inside or immediately after, which is
+ * what a writer half way through typing a name has. A cursor sitting on a space
+ * has no word and an empty replacement span at the cursor, so a host inserts
+ * there rather than overwriting whatever is to the left.
+ */
+export declare function siteAt(file: SourceFile, tokens: readonly Token[], offset: number): Site;
+/**
+ * The token an offset is inside, for a hover, which is not the same question.
+ *
+ * A completion is about what is being typed, so the token that ends at the
+ * cursor is the word. A hover is about what is under the pointer, so the token
+ * that contains the offset is the answer and one that merely ends there is not:
+ * pointing at the space after `ema` is not pointing at `ema`.
+ */
+export declare function tokenOn(tokens: readonly Token[], offset: number): Token | undefined;
+//# sourceMappingURL=site.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"site.d.ts","sourceRoot":"","sources":["../../src/editor/site.ts"],"names":[],"mappings":"AA+BA,OAAO,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAGhE,iEAAiE;AACjE,MAAM,WAAW,QAAQ;IACvB,oEAAoE;IACpE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC;IACxB,2DAA2D;IAC3D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,gFAAgF;IAChF,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,+EAA+E;IAC/E,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,6EAA6E;IAC7E,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;CACrB;AAED,oDAAoD;AACpD,MAAM,WAAW,IAAI;IACnB,wEAAwE;IACxE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,gFAAgF;IAChF,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC;IACvB,qEAAqE;IACrE,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC,8EAA8E;IAC9E,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,CAAC;CACrC;AA4HD;;;;;;;GAOG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,SAAS,KAAK,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAyBvF;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS,CAKnF"}

package/dist/editor/site.js

@@ -0,0 +1,184 @@
+/**
+ * Where the cursor is, in the language's own terms.
+ *
+ * `complete` and `signature` both need the same three answers: what word is
+ * being typed, whether it follows a namespace and a dot, and which argument of
+ * which call it sits in. They are worked out once, here, because two copies of
+ * this would disagree on the day somebody fixes one of them.
+ *
+ * ## It reads tokens, not the tree
+ *
+ * A file being typed into is a file that does not parse: `ema(close, ` is the
+ * state a call is in for as long as it takes to write one, and it has no
+ * complete tree node for the parser to hand back. The tokens, on the other hand,
+ * are exactly what the writer has typed so far, and the real lexer produced
+ * them. So the enclosing call is found by walking bracket depth backwards over
+ * the token stream rather than by looking for a `Call` node that is not there
+ * yet.
+ *
+ * This is not a second parser. It asks one question the grammar already fixes,
+ * which bracket is still open, and it answers nothing else: what the call means,
+ * whether its arguments type check and whether the name exists are the checker's
+ * and are asked of the checker.
+ *
+ * **An unclosed bracket swallows the rest of the file**, and that is the
+ * compiler's reading too: a call opened on line 5 and never closed makes every
+ * line below it part of one unfinished statement, which is what the parser
+ * reports and what `diagnose-typing` in the benchmark suite measures. A special
+ * case here that stopped at the end of a line would give a writer a different
+ * answer from the diagnostics beside them.
+ */
+import { endOffset } from '../core/index.js';
+import { isReserved } from './kinds.js';
+const OPENERS = new Set(['(', '[']);
+const CLOSERS = new Set([')', ']']);
+/** Whether a token is a word: a name, or a reserved word, which is also a word. */
+function isWord(token) {
+    return token !== undefined && (token.kind === 'identifier' || isReserved(token.kind));
+}
+/**
+ * The tokens that end at or before an offset, and the one the offset is inside.
+ *
+ * A layout token is skipped: an `indent` covers a line's leading spaces and a
+ * `dedent` and the end of the file cover nothing, so none of them is ever the
+ * word somebody is typing, and a bracket scan that counted them would still be
+ * correct but a word scan that returned one would not.
+ */
+function before(tokens, offset) {
+    const taken = [];
+    for (const token of tokens) {
+        if (token.span.offset >= offset)
+            break;
+        if (token.kind === 'newline' || token.kind === 'indent')
+            continue;
+        if (token.kind === 'dedent' || token.kind === 'endOfFile')
+            continue;
+        taken.push(token);
+    }
+    return taken;
+}
+/**
+ * The call whose bracket is still open at the cursor, and where in it.
+ *
+ * Walked forwards with a stack rather than backwards with a counter, because
+ * the answer wanted is the innermost frame that is still open and a stack is
+ * what that is. A square bracket counts too: `f(a[1], b` has the cursor in `f`'s
+ * second argument, and a scan that only knew round brackets would put it in the
+ * first.
+ */
+function callAt(tokens, text) {
+    const stack = [];
+    for (let i = 0; i < tokens.length; i += 1) {
+        const token = tokens[i];
+        if (token === undefined)
+            continue;
+        if (OPENERS.has(token.kind)) {
+            stack.push({
+                open: token,
+                callee: calleeOf(tokens, i),
+                commas: 0,
+                label: undefined,
+                labels: [],
+            });
+            continue;
+        }
+        if (CLOSERS.has(token.kind)) {
+            stack.pop();
+            continue;
+        }
+        const frame = stack[stack.length - 1];
+        if (frame === undefined)
+            continue;
+        if (token.kind === ',') {
+            frame.commas += 1;
+            frame.label = undefined;
+            continue;
+        }
+        // `name =` is a label, and `name ==` is a comparison. The lexer has already
+        // told the two apart: they are different tokens.
+        if (token.kind === '=' && isWord(tokens[i - 1])) {
+            const label = tokens[i - 1];
+            if (label !== undefined) {
+                frame.label = label.text;
+                frame.labels.push(label.text);
+            }
+        }
+    }
+    const frame = stack[stack.length - 1];
+    if (frame === undefined || frame.open.kind !== '(' || frame.callee.length === 0) {
+        return undefined;
+    }
+    const first = frame.callee[0];
+    const last = frame.callee[frame.callee.length - 1];
+    if (first === undefined || last === undefined)
+        return undefined;
+    return {
+        name: text.slice(first.span.offset, endOffset(last.span)),
+        nameSpan: first.span,
+        argument: frame.commas,
+        label: frame.label,
+        labels: frame.labels,
+        open: frame.open.span,
+    };
+}
+/**
+ * The name in front of a bracket, as one or three tokens.
+ *
+ * A dotted name is `identifier . identifier` to the lexer, so a call to
+ * `draw.box` is found by reading back over the dot. A bracket with no name in
+ * front of it is a grouping or an array literal rather than a call, and this
+ * returns nothing for it.
+ */
+function calleeOf(tokens, open) {
+    const name = tokens[open - 1];
+    if (!isWord(name) || name === undefined)
+        return [];
+    const dot = tokens[open - 2];
+    const namespace = tokens[open - 3];
+    if (dot?.kind === '.' && isWord(namespace) && namespace !== undefined) {
+        return [namespace, dot, name];
+    }
+    return [name];
+}
+/**
+ * Everything the two functions need to know about a position.
+ *
+ * The word is the token the offset is inside or immediately after, which is
+ * what a writer half way through typing a name has. A cursor sitting on a space
+ * has no word and an empty replacement span at the cursor, so a host inserts
+ * there rather than overwriting whatever is to the left.
+ */
+export function siteAt(file, tokens, offset) {
+    const text = file.text;
+    const at = Math.min(Math.max(Math.trunc(offset), 0), text.length);
+    const taken = before(tokens, at);
+    const last = taken[taken.length - 1];
+    const touching = last !== undefined && endOffset(last.span) === at;
+    const word = touching && isWord(last) ? last : undefined;
+    // The dot is the token before the word being typed, or the last token when
+    // nothing has been typed after it yet.
+    const dot = word === undefined ? last : taken[taken.length - 2];
+    const holder = word === undefined ? taken[taken.length - 2] : taken[taken.length - 3];
+    const afterDot = dot?.kind === '.' && (word !== undefined || touching);
+    const namespace = afterDot && isWord(holder) ? holder?.text : undefined;
+    const scanned = word === undefined ? taken : taken.slice(0, -1);
+    return {
+        word: word?.text ?? '',
+        replace: word?.span ?? file.spanAt(at, 0),
+        namespace,
+        afterDot: afterDot === true,
+        call: callAt(scanned, text),
+    };
+}
+/**
+ * The token an offset is inside, for a hover, which is not the same question.
+ *
+ * A completion is about what is being typed, so the token that ends at the
+ * cursor is the word. A hover is about what is under the pointer, so the token
+ * that contains the offset is the answer and one that merely ends there is not:
+ * pointing at the space after `ema` is not pointing at `ema`.
+ */
+export function tokenOn(tokens, offset) {
+    return tokens.find((token) => token.span.length > 0 && offset >= token.span.offset && offset < endOffset(token.span));
+}
+//# sourceMappingURL=site.js.map

package/dist/editor/site.js.map

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

package/dist/editor/spacing.d.ts

@@ -0,0 +1,29 @@
+import type { Script, Token } from '../core/index.js';
+/** The three questions the tree answers, as sets of source offsets. */
+export interface Shapes {
+    /** Where a `+` or a `-` is a sign rather than an operator between two values. */
+    readonly signs: ReadonlySet<number>;
+    /** Where a `(` groups an expression, or a `[` opens an array literal. */
+    readonly grouped: ReadonlySet<number>;
+    /** Where a `:` separates the two arms of a ternary. */
+    readonly arms: ReadonlySet<number>;
+}
+/**
+ * Reads the three from a tree.
+ *
+ * A tree from a file that did not parse is not passed here: the formatter
+ * refuses such a file before this is reached, because a tree with recovery in it
+ * describes a program nobody wrote.
+ */
+export declare function shapesOf(script: Script, tokens: readonly Token[]): Shapes;
+/**
+ * Whether a space goes between two tokens that are printed on one line.
+ *
+ * The default is a space, and every rule below takes one away. That direction is
+ * deliberate: a missing space is almost always harmless to read and never
+ * changes what the lexer sees, and an added space between two marks that have to
+ * touch is the one mistake that changes a program. The arrow above is the only
+ * case where that could happen, and it is refused first.
+ */
+export declare function spaceBetween(left: Token, right: Token, shapes: Shapes): boolean;
+//# sourceMappingURL=spacing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"spacing.d.ts","sourceRoot":"","sources":["../../src/editor/spacing.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEtD,uEAAuE;AACvE,MAAM,WAAW,MAAM;IACrB,iFAAiF;IACjF,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACpC,yEAAyE;IACzE,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACtC,uDAAuD;IACvD,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACpC;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,KAAK,EAAE,GAAG,MAAM,CA6BzE;AAmBD;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CA4B/E"}

package/dist/editor/spacing.js

@@ -0,0 +1,116 @@
+/**
+ * What goes between two tokens on a line, and how each rule is decided.
+ *
+ * A formatter's spacing is where a language tool usually starts guessing. The
+ * classic guess is the one every reprinter makes about a minus sign: it looks at
+ * the token before it and decides from a list of what can precede a binary
+ * operator. That list is a second, smaller grammar, it is wrong in a case
+ * nobody thought of, and being wrong means printing `a - -b` as `a--b` or
+ * `dir == -1` as `dir == - 1`.
+ *
+ * Nothing here guesses. Three questions cannot be answered by looking at two
+ * tokens, and all three are put to the parser, which has already answered them
+ * to build the tree:
+ *
+ *   - **Is this minus a sign or a subtraction?** A `unary` node begins at its
+ *     operator, so the tree names the offset of every sign in the file.
+ *   - **Does this bracket open a call or group an expression?** A `grouping`
+ *     node begins at its `(` and an `arrayLiteral` at its `[`. Every other
+ *     bracket is an argument list, a parameter list or an index, which are the
+ *     brackets that touch the name in front of them.
+ *   - **Is this colon a ternary's or a type annotation's?** A `ternary` node
+ *     carries the span of the arm before the colon, so the colon is the first
+ *     one after it. Every other colon introduces a type.
+ *
+ * The rest is a table of marks, and it is small because the language is small.
+ */
+import { endOffset, walk } from '../core/index.js';
+/**
+ * Reads the three from a tree.
+ *
+ * A tree from a file that did not parse is not passed here: the formatter
+ * refuses such a file before this is reached, because a tree with recovery in it
+ * describes a program nobody wrote.
+ */
+export function shapesOf(script, tokens) {
+    const colons = tokens.filter((token) => token.kind === ':').map((token) => token.span.offset);
+    const signs = new Set();
+    const grouped = new Set();
+    const arms = new Set();
+    walk(script, {
+        enter(node) {
+            switch (node.kind) {
+                case 'unary':
+                    signs.add(node.span.offset);
+                    return;
+                case 'grouping':
+                case 'arrayLiteral':
+                    grouped.add(node.span.offset);
+                    return;
+                case 'ternary': {
+                    const after = endOffset(node.whenTrue.span);
+                    const colon = colons.find((offset) => offset >= after);
+                    if (colon !== undefined)
+                        arms.add(colon);
+                    return;
+                }
+                default:
+                    return;
+            }
+        },
+    });
+    return { signs, grouped, arms };
+}
+/**
+ * Whether the arrow of a single-line `fn` is being written.
+ *
+ * `=>` is not one token. The punctuation table has `=` and `>` and no arrow, and
+ * the lexer reads the pair as one only while the two touch, which is why the
+ * form is recognised by the two tokens being adjacent rather than by a mark. A
+ * space between them turns a function declaration into an assignment followed by
+ * a comparison, so this is the one place a formatter may not insert one.
+ */
+function isArrow(left, right) {
+    return (left.kind === '=' &&
+        right.kind === '>' &&
+        endOffset(left.span) === right.span.offset);
+}
+/**
+ * Whether a space goes between two tokens that are printed on one line.
+ *
+ * The default is a space, and every rule below takes one away. That direction is
+ * deliberate: a missing space is almost always harmless to read and never
+ * changes what the lexer sees, and an added space between two marks that have to
+ * touch is the one mistake that changes a program. The arrow above is the only
+ * case where that could happen, and it is refused first.
+ */
+export function spaceBetween(left, right, shapes) {
+    if (isArrow(left, right))
+        return false;
+    // A sign belongs to the value it signs. `not` is a word and keeps its space:
+    // taking it away would spell a different name.
+    if (shapes.signs.has(left.span.offset) && (left.kind === '-' || left.kind === '+'))
+        return false;
+    // Inside a bracket, against the bracket.
+    if (left.kind === '(' || left.kind === '[')
+        return false;
+    if (right.kind === ')' || right.kind === ']')
+        return false;
+    // A comma belongs to the item before it.
+    if (right.kind === ',')
+        return false;
+    // A dotted name is one name to read, so it is printed as one.
+    if (left.kind === '.' || right.kind === '.')
+        return false;
+    // A bracket that is not grouping an expression is an argument list, a
+    // parameter list or an index, and all three touch what they are applied to.
+    if ((right.kind === '(' || right.kind === '[') && !shapes.grouped.has(right.span.offset)) {
+        return false;
+    }
+    // A type annotation's colon belongs to the name it follows. A ternary's has a
+    // space on both sides, which is what the default already gives it.
+    if (right.kind === ':' && !shapes.arms.has(right.span.offset))
+        return false;
+    return true;
+}
+//# sourceMappingURL=spacing.js.map

package/dist/editor/spacing.js.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openalgo-script",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "An open trading language. Write a study or a strategy once, plot it, backtest it, trade it.",
   "keywords": [
     "trading",
@@ -26,10 +26,18 @@
       "types": "./dist/core/index.d.ts",
       "import": "./dist/core/index.js"
     },
+    "./editor": {
+      "types": "./dist/editor/index.d.ts",
+      "import": "./dist/editor/index.js"
+    },
     "./adapters/charts": {
       "types": "./dist/adapters/charts/index.d.ts",
       "import": "./dist/adapters/charts/index.js"
     },
+    "./adapters/codemirror": {
+      "types": "./dist/adapters/codemirror/index.d.ts",
+      "import": "./dist/adapters/codemirror/index.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [
@@ -51,8 +59,10 @@
     "check:raises": "node --disallow-code-generation-from-strings scripts/check-raises.mjs",
     "check:defaults": "npm run build && node --disallow-code-generation-from-strings scripts/check-defaults.mjs",
     "check:chart": "npm run build && node --disallow-code-generation-from-strings scripts/check-chart-surface.mjs",
+    "check:reproducible": "npm run build && node --disallow-code-generation-from-strings scripts/check-reproducible.mjs",
     "check:section-20": "node --disallow-code-generation-from-strings scripts/check-section-20.mjs",
-    "test": "node --disallow-code-generation-from-strings scripts/check-duplication.mjs && node --disallow-code-generation-from-strings scripts/check-error-codes.mjs && node --disallow-code-generation-from-strings scripts/check-examples.mjs && node --disallow-code-generation-from-strings scripts/check-catalogue-tests.mjs && node --disallow-code-generation-from-strings scripts/check-layering.mjs && node --disallow-code-generation-from-strings scripts/check-limits.mjs && node --disallow-code-generation-from-strings scripts/check-modularity.mjs && node --disallow-code-generation-from-strings scripts/check-names.mjs && node --disallow-code-generation-from-strings scripts/check-raises.mjs && node --disallow-code-generation-from-strings scripts/check-section-20.mjs && npm run build && node --disallow-code-generation-from-strings scripts/check-defaults.mjs && node --disallow-code-generation-from-strings scripts/check-chart-surface.mjs && npm run test:unit && node --disallow-code-generation-from-strings scripts/check-examples-compile.mjs && node --disallow-code-generation-from-strings scripts/check-no-eval.mjs && npm run bench",
+    "check:entry-points": "npm run build && node --disallow-code-generation-from-strings scripts/check-entry-points.mjs",
+    "test": "node --disallow-code-generation-from-strings scripts/check-duplication.mjs && node --disallow-code-generation-from-strings scripts/check-error-codes.mjs && node --disallow-code-generation-from-strings scripts/check-examples.mjs && node --disallow-code-generation-from-strings scripts/check-catalogue-tests.mjs && node --disallow-code-generation-from-strings scripts/check-layering.mjs && node --disallow-code-generation-from-strings scripts/check-limits.mjs && node --disallow-code-generation-from-strings scripts/check-modularity.mjs && node --disallow-code-generation-from-strings scripts/check-names.mjs && node --disallow-code-generation-from-strings scripts/check-raises.mjs && node --disallow-code-generation-from-strings scripts/check-section-20.mjs && npm run build && node --disallow-code-generation-from-strings scripts/check-defaults.mjs && node --disallow-code-generation-from-strings scripts/check-entry-points.mjs && node --disallow-code-generation-from-strings scripts/check-chart-surface.mjs && npm run test:unit && node --disallow-code-generation-from-strings scripts/check-reproducible.mjs && node --disallow-code-generation-from-strings scripts/check-examples-compile.mjs && node --disallow-code-generation-from-strings scripts/check-no-eval.mjs && npm run bench",
     "test:unit": "npm run build:test && node --disallow-code-generation-from-strings scripts/run-tests.mjs",
     "check:layering": "node --disallow-code-generation-from-strings scripts/check-layering.mjs",
     "check:duplication": "node --disallow-code-generation-from-strings scripts/check-duplication.mjs",
@@ -64,7 +74,8 @@
     "build:test": "npm run generate && node --disallow-code-generation-from-strings scripts/clean-output.mjs tsconfig.test.json && tsc -p tsconfig.test.json",
     "prepack": "npm run build",
     "generate:version": "node --disallow-code-generation-from-strings scripts/generate-version.mjs",
-    "generate": "npm run generate:errors && npm run generate:version",
+    "generate:library": "node --disallow-code-generation-from-strings scripts/generate-library-prose.mjs",
+    "generate": "npm run generate:errors && npm run generate:version && npm run generate:library",
     "check:changelog": "node --disallow-code-generation-from-strings scripts/check-changelog.mjs",
     "bench": "node --disallow-code-generation-from-strings scripts/bench.mjs",
     "bench:record": "node --disallow-code-generation-from-strings scripts/bench.mjs --record"
@@ -74,9 +85,25 @@
   },
   "dependencies": {},
   "peerDependencies": {
+    "@codemirror/autocomplete": ">=6.0.0",
+    "@codemirror/language": ">=6.0.0",
+    "@codemirror/lint": ">=6.0.0",
+    "@codemirror/view": ">=6.0.0",
     "openalgo-charts": ">=2.4.0"
   },
   "peerDependenciesMeta": {
+    "@codemirror/autocomplete": {
+      "optional": true
+    },
+    "@codemirror/language": {
+      "optional": true
+    },
+    "@codemirror/lint": {
+      "optional": true
+    },
+    "@codemirror/view": {
+      "optional": true
+    },
     "openalgo-charts": {
       "optional": true
     }