@vesk/compiler 0.0.1

package/dist/ssr-store.d.ts

@@ -0,0 +1,4 @@
+import { type SsrDataSink } from '@vesk/runtime/src/index-server';
+export declare function withSsrStore<T>(fn: () => T): T;
+export declare const ssrSink: SsrDataSink;
+//# sourceMappingURL=ssr-store.d.ts.map

package/dist/ssr-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssr-store.d.ts","sourceRoot":"","sources":["../src/ssr-store.ts"],"names":[],"mappings":"AACA,OAAO,EAAc,KAAK,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAI9E,wBAAgB,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAI9C;AAED,eAAO,MAAM,OAAO,EAAE,WAgBrB,CAAC"}

package/dist/ssr-store.js

@@ -0,0 +1,29 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { setSsrSink } from '@vesk/runtime/src/index-server';
+const storage = new AsyncLocalStorage();
+export function withSsrStore(fn) {
+    const existing = storage.getStore();
+    if (existing)
+        return fn();
+    return storage.run({}, fn);
+}
+export const ssrSink = {
+    set: (key, value) => {
+        const store = storage.getStore();
+        if (store)
+            store[key] = value;
+    },
+    get: (key) => {
+        const store = storage.getStore();
+        return store ? store[key] : undefined;
+    },
+    snapshot: () => ({ ...(storage.getStore() ?? {}) }),
+    clear: () => {
+        const store = storage.getStore();
+        if (store) {
+            for (const key of Object.keys(store))
+                delete store[key];
+        }
+    },
+};
+setSsrSink(ssrSink);

package/dist/strip-ts.d.ts

@@ -0,0 +1,25 @@
+/** True when the AST contains any TypeScript-only node. */
+export declare function hasTsSyntax(ast: any): boolean;
+/** True when a Program-body statement is type-only (safe to drop from emitted JS). */
+export declare function isTypeOnlyStatement(node: any): boolean;
+/**
+ * Removes TypeScript-only syntax from an estree AST:
+ * - type annotations on declarators, params, return types and class fields
+ * - `as` / `satisfies` / `!` / `<T>expr` / generic-call wrappers, replaced by
+ *   their inner expression
+ * - type arguments on call/new expressions and type parameter declarations
+ * - whole type-only statements (interfaces, type aliases, declare/abstract
+ *   members), replaced by null entries
+ *
+ * Returns a new tree (zimmerframe walks are immutable); callers must use the
+ * return value.
+ */
+export declare function stripTsTypes(ast: any): any;
+/**
+ * Strips TypeScript-only syntax from a plain-JS source snippet (a top-level
+ * function like `load`/`getStaticProps`, or an action block). Returns the
+ * original source untouched when there is no TS syntax or the reprint fails,
+ * so byte-identical fast paths stay intact.
+ */
+export declare function stripCodeTypes(code: string): string;
+//# sourceMappingURL=strip-ts.d.ts.map

package/dist/strip-ts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strip-ts.d.ts","sourceRoot":"","sources":["../src/strip-ts.ts"],"names":[],"mappings":"AAwBA,2DAA2D;AAC3D,wBAAgB,WAAW,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAY7C;AAYD,sFAAsF;AACtF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO,CAMtD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,CA6D1C;AAWD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAiBnD"}

package/dist/strip-ts.js

@@ -0,0 +1,171 @@
+import { walk } from 'zimmerframe';
+import { print } from 'esrap';
+import ts from 'esrap/languages/ts';
+import { parse } from '@vesk/compiler/src/parser';
+const TS_NODE_TYPES = new Set([
+    'TSAsExpression',
+    'TSSatisfiesExpression',
+    'TSNonNullExpression',
+    'TSTypeAssertion',
+    'TSInstantiationExpression',
+    'TSTypeAnnotation',
+    'TSTypeParameterDeclaration',
+    'TSTypeParameterInstantiation',
+    'TSInterfaceDeclaration',
+    'TSTypeAliasDeclaration',
+    'TSDeclareFunction',
+    'TSDeclareStatement',
+    'TSEnumDeclaration',
+    'TSModuleDeclaration',
+    'TSImportEqualsDeclaration',
+    'TSParameterProperty',
+]);
+/** True when the AST contains any TypeScript-only node. */
+export function hasTsSyntax(ast) {
+    let found = false;
+    walk(ast, null, {
+        _(node, context) {
+            if (TS_NODE_TYPES.has(node.type)) {
+                found = true;
+                return;
+            }
+            return context.next();
+        },
+    });
+    return found;
+}
+const TYPE_ONLY_STATEMENTS = new Set([
+    'TSInterfaceDeclaration',
+    'TSTypeAliasDeclaration',
+    'TSDeclareFunction',
+    'TSDeclareStatement',
+    'TSEnumDeclaration',
+    'TSModuleDeclaration',
+    'TSImportEqualsDeclaration',
+]);
+/** True when a Program-body statement is type-only (safe to drop from emitted JS). */
+export function isTypeOnlyStatement(node) {
+    if (!node)
+        return true;
+    if (node.type === 'ExportNamedDeclaration' || node.type === 'ExportDefaultDeclaration') {
+        return !!node.declaration && isTypeOnlyStatement(node.declaration);
+    }
+    return TYPE_ONLY_STATEMENTS.has(node.type);
+}
+/**
+ * Removes TypeScript-only syntax from an estree AST:
+ * - type annotations on declarators, params, return types and class fields
+ * - `as` / `satisfies` / `!` / `<T>expr` / generic-call wrappers, replaced by
+ *   their inner expression
+ * - type arguments on call/new expressions and type parameter declarations
+ * - whole type-only statements (interfaces, type aliases, declare/abstract
+ *   members), replaced by null entries
+ *
+ * Returns a new tree (zimmerframe walks are immutable); callers must use the
+ * return value.
+ */
+export function stripTsTypes(ast) {
+    return walk(ast, null, {
+        TSAsExpression(node, context) {
+            return context.visit(node.expression);
+        },
+        TSSatisfiesExpression(node, context) {
+            return context.visit(node.expression);
+        },
+        TSNonNullExpression(node, context) {
+            return context.visit(node.expression);
+        },
+        TSTypeAssertion(node, context) {
+            return context.visit(node.expression);
+        },
+        TSInstantiationExpression(node, context) {
+            return context.visit(node.expression);
+        },
+        VariableDeclarator(node, context) {
+            if (node.id && node.id.typeAnnotation)
+                node.id.typeAnnotation = null;
+            return context.next();
+        },
+        FunctionDeclaration(node, context) {
+            stripFunctionTypes(node);
+            return context.next();
+        },
+        FunctionExpression(node, context) {
+            stripFunctionTypes(node);
+            return context.next();
+        },
+        ArrowFunctionExpression(node, context) {
+            stripFunctionTypes(node);
+            return context.next();
+        },
+        CallExpression(node, context) {
+            if (node.typeArguments)
+                node.typeArguments = null;
+            return context.next();
+        },
+        NewExpression(node, context) {
+            if (node.typeArguments)
+                node.typeArguments = null;
+            return context.next();
+        },
+        PropertyDefinition(node, context) {
+            if (node.typeAnnotation)
+                node.typeAnnotation = null;
+            return context.next();
+        },
+        TSInterfaceDeclaration(node) {
+            return null;
+        },
+        TSTypeAliasDeclaration(node) {
+            return null;
+        },
+        TSDeclareFunction(node) {
+            return null;
+        },
+        TSEnumDeclaration(node) {
+            return null;
+        },
+        TSTypeParameterDeclaration(node) {
+            return null;
+        },
+    });
+}
+function stripFunctionTypes(node) {
+    if (node.returnType)
+        node.returnType = null;
+    if (node.typeParameters)
+        node.typeParameters = null;
+    for (const p of node.params || []) {
+        if (p.typeAnnotation)
+            p.typeAnnotation = null;
+        if (p.optional)
+            p.optional = false;
+    }
+}
+/**
+ * Strips TypeScript-only syntax from a plain-JS source snippet (a top-level
+ * function like `load`/`getStaticProps`, or an action block). Returns the
+ * original source untouched when there is no TS syntax or the reprint fails,
+ * so byte-identical fast paths stay intact.
+ */
+export function stripCodeTypes(code) {
+    let ast;
+    try {
+        ast = parse(code);
+    }
+    catch {
+        return code;
+    }
+    if (!hasTsSyntax(ast))
+        return code;
+    const stripped = stripTsTypes(ast);
+    if (stripped.type === 'Program' && Array.isArray(stripped.body)) {
+        stripped.body = stripped.body.filter((n) => !isTypeOnlyStatement(n));
+    }
+    try {
+        return print(stripped, ts()).code;
+    }
+    catch {
+        return code;
+    }
+}

package/dist/tokens.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Token-based syntax analysis built on the acorn tokenizer (via the Vesk
+ * TS/JSX parser). The tokenizer understands generics, JSX, template
+ * literals and the `&[...]` track-declaration sugar, so identifier-call
+ * detection and import parsing no longer need regexes. Every helper falls
+ * back to a character-level scan when the input cannot be tokenized (e.g.
+ * mid-edit content or partial fragments), so callers never crash on
+ * unparsable text.
+ */
+export interface CodeToken {
+    label: string;
+    value: string;
+    start: number;
+    end: number;
+}
+/**
+ * Tokenizes `code` with the Vesk parser's tokenizer. Returns an array of
+ * tokens (excluding EOF), or `null` when the input cannot be tokenized.
+ * `value` holds identifier/keyword/string text; punctuation tokens expose
+ * their span so callers can read the actual character via `code[start]`.
+ */
+export declare function tokenizeCode(code: string): CodeToken[] | null;
+/**
+ * Returns the set of identifiers in `code` that are called — an identifier
+ * token immediately followed by `(` or by a `<...>` generic clause and then
+ * `(`. Member accesses (`obj.fn(`, `obj?.fn(`) are excluded so methods are
+ * not mistaken for imported runtime functions.
+ */
+export declare function collectCalledIdentifiers(code: string): Set<string>;
+/**
+ * True when `code` contains the identifier `name` (as a plain identifier or
+ * a JSX name), outside strings and comments.
+ */
+export declare function containsIdentifier(code: string, name: string): boolean;
+/**
+ * True when an `import` statement in `code` imports the name `name`.
+ */
+export declare function isIdentifierImported(code: string, name: string): boolean;
+/**
+ * Extracts the locally-bound names from a single import statement
+ * (`import { a as b, type C } from 'm'` → `['b']`; `import X from 'm'` and
+ * `import * as X from 'm'` → `['X']`). Type-only specifiers are dropped.
+ */
+export declare function extractImportNames(importText: string): string[];
+/**
+ * Returns the module specifier of an import statement — the string literal
+ * after `from` (or the bare side-effect string). `null` when none found.
+ */
+export declare function importModuleTarget(importText: string): string | null;
+//# sourceMappingURL=tokens.d.ts.map

package/dist/tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../src/tokens.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAYH,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE,GAAG,IAAI,CAqB7D;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAiBlE;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAStE;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAqBxE;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CAuC/D;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAOpE"}

package/dist/tokens.js

@@ -0,0 +1,334 @@
+/**
+ * Token-based syntax analysis built on the acorn tokenizer (via the Vesk
+ * TS/JSX parser). The tokenizer understands generics, JSX, template
+ * literals and the `&[...]` track-declaration sugar, so identifier-call
+ * detection and import parsing no longer need regexes. Every helper falls
+ * back to a character-level scan when the input cannot be tokenized (e.g.
+ * mid-edit content or partial fragments), so callers never crash on
+ * unparsable text.
+ */
+import { createBaseParser } from '@vesk/compiler/src/parser';
+import { skipString, skipComment, skipWhitespace, skipTrackGeneric, isIdentStart, isIdentChar, } from '@vesk/compiler/src/scan';
+/**
+ * Tokenizes `code` with the Vesk parser's tokenizer. Returns an array of
+ * tokens (excluding EOF), or `null` when the input cannot be tokenized.
+ * `value` holds identifier/keyword/string text; punctuation tokens expose
+ * their span so callers can read the actual character via `code[start]`.
+ */
+export function tokenizeCode(code) {
+    try {
+        const ParserClass = createBaseParser();
+        const tok = ParserClass.tokenizer(code, {
+            ecmaVersion: 'latest',
+            sourceType: 'module',
+        });
+        const out = [];
+        let t;
+        while ((t = tok.getToken()) && t.type && t.type.label !== 'eof') {
+            out.push({
+                label: t.type.label,
+                value: typeof t.value === 'string' ? t.value : '',
+                start: t.start,
+                end: t.end,
+            });
+        }
+        return out;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Returns the set of identifiers in `code` that are called — an identifier
+ * token immediately followed by `(` or by a `<...>` generic clause and then
+ * `(`. Member accesses (`obj.fn(`, `obj?.fn(`) are excluded so methods are
+ * not mistaken for imported runtime functions.
+ */
+export function collectCalledIdentifiers(code) {
+    const tokens = tokenizeCode(code);
+    if (tokens !== null) {
+        const result = new Set();
+        for (let i = 0; i < tokens.length; i++) {
+            const t = tokens[i];
+            if (t.label !== 'name')
+                continue;
+            const prev = i > 0 ? tokens[i - 1] : null;
+            if (prev && (prev.label === '.' || prev.label === '?.'))
+                continue;
+            const next = tokens[i + 1];
+            if (!next)
+                continue;
+            const nextCh = code[next.start];
+            if (nextCh === '(' || nextCh === '<')
+                result.add(t.value);
+        }
+        return result;
+    }
+    return manualCollectCalledIdentifiers(code);
+}
+/**
+ * True when `code` contains the identifier `name` (as a plain identifier or
+ * a JSX name), outside strings and comments.
+ */
+export function containsIdentifier(code, name) {
+    const tokens = tokenizeCode(code);
+    if (tokens !== null) {
+        for (const t of tokens) {
+            if ((t.label === 'name' || t.label === 'jsxName') && t.value === name)
+                return true;
+        }
+        return false;
+    }
+    return manualContainsIdentifier(code, name);
+}
+/**
+ * True when an `import` statement in `code` imports the name `name`.
+ */
+export function isIdentifierImported(code, name) {
+    const tokens = tokenizeCode(code);
+    if (tokens !== null) {
+        for (let i = 0; i < tokens.length; i++) {
+            if (tokens[i].label !== 'import')
+                continue;
+            let j = i + 1;
+            while (j < tokens.length &&
+                tokens[j].label !== ';' &&
+                !(tokens[j].label === 'name' && tokens[j].value === 'from')) {
+                j++;
+            }
+            for (let k = i + 1; k < j; k++) {
+                if ((tokens[k].label === 'name' || tokens[k].label === 'jsxName') && tokens[k].value === name)
+                    return true;
+            }
+            i = j;
+        }
+        return false;
+    }
+    return manualIsIdentifierImported(code, name);
+}
+/**
+ * Extracts the locally-bound names from a single import statement
+ * (`import { a as b, type C } from 'm'` → `['b']`; `import X from 'm'` and
+ * `import * as X from 'm'` → `['X']`). Type-only specifiers are dropped.
+ */
+export function extractImportNames(importText) {
+    const tokens = tokenizeCode(importText);
+    if (tokens !== null) {
+        const names = [];
+        let i = 0;
+        while (i < tokens.length && tokens[i].label !== 'import')
+            i++;
+        if (i >= tokens.length)
+            return names;
+        i++;
+        if (i < tokens.length && tokens[i].label === 'name' && tokens[i].value === 'type')
+            i++;
+        if (i < tokens.length && tokens[i].label === '{') {
+            i++;
+            while (i < tokens.length && tokens[i].label !== '}') {
+                const t = tokens[i];
+                if (t.label === 'name') {
+                    if (t.value === 'type' || t.value === 'typeof') {
+                        i++;
+                        continue;
+                    }
+                    let name = t.value;
+                    if (i + 2 < tokens.length &&
+                        tokens[i + 1].label === 'name' && tokens[i + 1].value === 'as' &&
+                        tokens[i + 2].label === 'name') {
+                        name = tokens[i + 2].value;
+                        i += 2;
+                    }
+                    names.push(name);
+                }
+                i++;
+            }
+            return names;
+        }
+        if (i < tokens.length && tokens[i].label === '*') {
+            while (i < tokens.length && tokens[i].label !== 'name')
+                i++;
+            if (i < tokens.length)
+                names.push(tokens[i].value);
+        }
+        else if (i < tokens.length && tokens[i].label === 'name') {
+            names.push(tokens[i].value);
+        }
+        return names;
+    }
+    return manualExtractImportNames(importText);
+}
+/**
+ * Returns the module specifier of an import statement — the string literal
+ * after `from` (or the bare side-effect string). `null` when none found.
+ */
+export function importModuleTarget(importText) {
+    const tokens = tokenizeCode(importText);
+    if (tokens === null)
+        return null;
+    for (let i = tokens.length - 1; i >= 0; i--) {
+        if (tokens[i].label === 'string')
+            return tokens[i].value;
+    }
+    return null;
+}
+function manualCollectCalledIdentifiers(code) {
+    const result = new Set();
+    let i = 0;
+    while (i < code.length) {
+        const c = code[i];
+        if (c === '"' || c === "'" || c === '`') {
+            i = skipString(code, i);
+            continue;
+        }
+        if (c === '/' && (code[i + 1] === '/' || code[i + 1] === '*')) {
+            i = skipComment(code, i);
+            continue;
+        }
+        if (isIdentStart(c)) {
+            let j = i + 1;
+            while (j < code.length && isIdentChar(code[j]))
+                j++;
+            const before = i === 0 ? '' : code[i - 1];
+            if (before !== '.' && !isIdentChar(before)) {
+                let k = skipWhitespace(code, j);
+                if (code[k] === '<')
+                    k = skipTrackGeneric(code, k);
+                if (code[k] === '(')
+                    result.add(code.slice(i, j));
+            }
+            i = j;
+            continue;
+        }
+        i++;
+    }
+    return result;
+}
+function manualContainsIdentifier(code, name) {
+    let i = 0;
+    while (i < code.length) {
+        const c = code[i];
+        if (c === '"' || c === "'" || c === '`') {
+            i = skipString(code, i);
+            continue;
+        }
+        if (c === '/' && (code[i + 1] === '/' || code[i + 1] === '*')) {
+            i = skipComment(code, i);
+            continue;
+        }
+        if (isIdentStart(c) && code.slice(i, i + name.length) === name) {
+            const after = i + name.length;
+            if ((after >= code.length || !isIdentChar(code[after])) && (i === 0 || !isIdentChar(code[i - 1])))
+                return true;
+        }
+        i++;
+    }
+    return false;
+}
+function manualIsIdentifierImported(code, name) {
+    let i = 0;
+    while (i < code.length) {
+        const c = code[i];
+        if (c === '"' || c === "'" || c === '`') {
+            i = skipString(code, i);
+            continue;
+        }
+        if (c === '/' && (code[i + 1] === '/' || code[i + 1] === '*')) {
+            i = skipComment(code, i);
+            continue;
+        }
+        if (isIdentStart(c)) {
+            let j = i + 1;
+            while (j < code.length && isIdentChar(code[j]))
+                j++;
+            const word = code.slice(i, j);
+            if (word === 'import') {
+                let k = j;
+                while (k < code.length) {
+                    if (code[k] === ';' || code[k] === '\n')
+                        break;
+                    if (code[k] === '"' || code[k] === "'" || code[k] === '`') {
+                        k = skipString(code, k);
+                        continue;
+                    }
+                    if (isIdentStart(code[k]) && code.slice(k, k + name.length) === name) {
+                        const a = k + name.length;
+                        if ((a >= code.length || !isIdentChar(code[a])) && (k === 0 || !isIdentChar(code[k - 1])))
+                            return true;
+                    }
+                    k++;
+                }
+            }
+            i = j;
+            continue;
+        }
+        i++;
+    }
+    return false;
+}
+function manualExtractImportNames(importText) {
+    const names = [];
+    const open = importText.indexOf('{');
+    if (open !== -1) {
+        const close = importText.indexOf('}', open + 1);
+        if (close !== -1) {
+            let i = open + 1;
+            while (i < close) {
+                const c = importText[i];
+                if (c === '"' || c === "'" || c === '`') {
+                    i = skipString(importText, i);
+                    continue;
+                }
+                if (isIdentStart(c)) {
+                    let j = i + 1;
+                    while (j < close && isIdentChar(importText[j]))
+                        j++;
+                    let word = importText.slice(i, j);
+                    if (word === 'type' || word === 'typeof') {
+                        i = j;
+                        continue;
+                    }
+                    let k = skipWhitespace(importText, j);
+                    if (importText.slice(k, k + 2) === 'as' && !isIdentChar(importText[k + 2])) {
+                        let m = skipWhitespace(importText, k + 2);
+                        if (isIdentStart(importText[m])) {
+                            let n = m + 1;
+                            while (n < close && isIdentChar(importText[n]))
+                                n++;
+                            word = importText.slice(m, n);
+                        }
+                    }
+                    names.push(word);
+                    i = j;
+                    continue;
+                }
+                i++;
+            }
+            return names;
+        }
+    }
+    let i = 0;
+    while (i < importText.length && !isIdentStart(importText[i]))
+        i++;
+    while (i < importText.length && isIdentChar(importText[i]))
+        i++;
+    i = skipWhitespace(importText, i);
+    if (importText[i] === '*') {
+        i = skipWhitespace(importText, i + 1);
+        if (importText.slice(i, i + 2) === 'as')
+            i = skipWhitespace(importText, i + 2);
+        if (isIdentStart(importText[i])) {
+            let j = i + 1;
+            while (j < importText.length && isIdentChar(importText[j]))
+                j++;
+            names.push(importText.slice(i, j));
+        }
+    }
+    else if (isIdentStart(importText[i])) {
+        let j = i + 1;
+        while (j < importText.length && isIdentChar(importText[j]))
+            j++;
+        names.push(importText.slice(i, j));
+    }
+    return names;
+}

package/dist/typecheck.d.ts

@@ -0,0 +1,19 @@
+export interface TypecheckOptions {
+    strict?: boolean;
+    appDir?: string;
+}
+export interface TypecheckError {
+    file: string;
+    line: number;
+    column: number;
+    code: string;
+    message: string;
+}
+export interface TypecheckResult {
+    errors: TypecheckError[];
+    warnings: TypecheckError[];
+}
+export declare function typecheckProject(projectRoot: string, opts?: TypecheckOptions): TypecheckResult;
+export declare function formatTypecheckErrors(errors: TypecheckError[]): string;
+export declare function formatTypecheckWarnings(warnings: TypecheckError[]): string;
+//# sourceMappingURL=typecheck.d.ts.map

package/dist/typecheck.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typecheck.d.ts","sourceRoot":"","sources":["../src/typecheck.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,gBAAgB;IAC/B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAmQD,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,cAAc,EAAE,CAAC;IACzB,QAAQ,EAAE,cAAc,EAAE,CAAC;CAC5B;AAED,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,GAAE,gBAAqB,GAAG,eAAe,CA0FlG;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,cAAc,EAAE,GAAG,MAAM,CAItE;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,cAAc,EAAE,GAAG,MAAM,CAI1E"}