workstar-compiler 0.1.0 → 0.2.0-beta.0

package/dist/src/react-compat.js

@@ -0,0 +1,369 @@
+import ts from 'typescript';
+import { pathExpression, reject } from './compat-rules.js';
+const voidTags = new Set([
+    'area',
+    'base',
+    'br',
+    'col',
+    'embed',
+    'hr',
+    'img',
+    'input',
+    'link',
+    'meta',
+    'param',
+    'source',
+    'track',
+    'wbr',
+]);
+const nativeEvents = new Map([
+    ['onBlur', 'blur'],
+    ['onClick', 'click'],
+    ['onDoubleClick', 'dblclick'],
+    ['onFocus', 'focus'],
+    ['onInput', 'input'],
+    ['onKeyDown', 'keydown'],
+    ['onKeyUp', 'keyup'],
+    ['onMouseEnter', 'mouseenter'],
+    ['onMouseLeave', 'mouseleave'],
+    ['onPointerDown', 'pointerdown'],
+    ['onPointerMove', 'pointermove'],
+    ['onPointerUp', 'pointerup'],
+    ['onSubmit', 'submit'],
+    ['onTouchEnd', 'touchend'],
+    ['onTouchMove', 'touchmove'],
+    ['onTouchStart', 'touchstart'],
+]);
+function expression(node, file, filename, setup, defaults) {
+    const value = node.getText(file);
+    if (pathExpression.test(value) && defaults.length === 0)
+        return '{' + value + '}';
+    if (!isStatelessExpression(node))
+        reject(filename, 'expression ' + value);
+    const name = `__workstarExpression${setup.length}`;
+    const bindings = defaults.map((element) => element.getText(file)).join(', ');
+    const argumentsList = defaults
+        .map((element) => element.name.getText(file))
+        .join(', ');
+    const computed = defaults.length
+        ? `((${bindings}) => (${value}))(${argumentsList})`
+        : value;
+    setup.push(`const ${name} = ${computed};`);
+    return '{' + name + '}';
+}
+function isStatelessExpression(node) {
+    if (ts.isIdentifier(node) ||
+        ts.isStringLiteral(node) ||
+        ts.isNumericLiteral(node) ||
+        node.kind === ts.SyntaxKind.TrueKeyword ||
+        node.kind === ts.SyntaxKind.FalseKeyword)
+        return true;
+    if (ts.isParenthesizedExpression(node))
+        return isStatelessExpression(node.expression);
+    if (ts.isPropertyAccessExpression(node))
+        return isStatelessExpression(node.expression);
+    if (ts.isTemplateExpression(node))
+        return node.templateSpans.every((span) => isStatelessExpression(span.expression));
+    if (ts.isNoSubstitutionTemplateLiteral(node))
+        return true;
+    if (ts.isBinaryExpression(node) &&
+        node.operatorToken.kind === ts.SyntaxKind.PlusToken)
+        return (isStatelessExpression(node.left) && isStatelessExpression(node.right));
+    return (ts.isCallExpression(node) &&
+        ts.isPropertyAccessExpression(node.expression) &&
+        node.expression.name.text === 'trim' &&
+        node.arguments.length === 0 &&
+        isStatelessExpression(node.expression.expression));
+}
+function attributeName(original, filename) {
+    if (original === 'className')
+        return 'class';
+    if (original === 'htmlFor')
+        return 'for';
+    if (/^on[A-Z]/.test(original)) {
+        const event = nativeEvents.get(original);
+        if (!event)
+            reject(filename, 'event ' + original);
+        return 'on:' + event;
+    }
+    return original;
+}
+function attributes(input, file, filename, setup, defaults, component = false, restName) {
+    let output = '';
+    for (const attribute of input.properties) {
+        if (ts.isJsxSpreadAttribute(attribute)) {
+            if (component ||
+                !restName ||
+                !ts.isIdentifier(attribute.expression) ||
+                attribute.expression.text !== restName)
+                reject(filename, 'spread attribute');
+            output += ' bind:attrs={__workstarRest}';
+            continue;
+        }
+        if (!ts.isIdentifier(attribute.name))
+            reject(filename, 'namespaced JSX attribute');
+        const original = attribute.name.text;
+        if (['style', 'ref', 'key', 'dangerouslySetInnerHTML'].includes(original) ||
+            (!component && original === 'onChange')) {
+            reject(filename, 'attribute ' + original);
+        }
+        const name = component ? original : attributeName(original, filename);
+        if (!/^[a-z][a-z0-9:._-]*$/i.test(name))
+            reject(filename, 'attribute ' + original);
+        if (component && !/^[A-Za-z_$][\w$]*$/.test(name))
+            reject(filename, 'component prop ' + original);
+        if (!attribute.initializer) {
+            output += ' ' + name + (component ? '' : '=""');
+        }
+        else if (ts.isStringLiteral(attribute.initializer)) {
+            output +=
+                ' ' +
+                    name +
+                    '="' +
+                    attribute.initializer.text
+                        .replace(/&/g, '&')
+                        .replace(/"/g, '"') +
+                    '"';
+        }
+        else if (ts.isJsxExpression(attribute.initializer) &&
+            attribute.initializer.expression) {
+            output +=
+                ' ' +
+                    name +
+                    '=' +
+                    expression(attribute.initializer.expression, file, filename, setup, defaults);
+        }
+        else {
+            reject(filename, 'attribute ' + original);
+        }
+    }
+    return output;
+}
+function jsx(node, file, filename, setup, defaults, components, restName) {
+    if (ts.isJsxText(node)) {
+        const value = node.getText(file);
+        if (/[{}]/.test(value))
+            reject(filename, 'literal JSX braces');
+        return value;
+    }
+    if (ts.isJsxExpression(node)) {
+        if (!node.expression)
+            reject(filename, 'empty JSX expression');
+        return expression(node.expression, file, filename, setup, defaults);
+    }
+    if (ts.isJsxFragment(node))
+        return node.children
+            .map((child) => jsx(child, file, filename, setup, defaults, components, restName))
+            .join('');
+    const opening = ts.isJsxElement(node) ? node.openingElement : node;
+    const tag = opening.tagName.getText(file);
+    const component = components.has(tag);
+    if (!component && !/^[a-z][a-z0-9-]*$/.test(tag))
+        reject(filename, 'component or tag ' + tag);
+    const start = (component ? `<Use component={${tag}}` : `<${tag}`) +
+        attributes(opening.attributes, file, filename, setup, defaults, component, restName) +
+        '>';
+    if (voidTags.has(tag)) {
+        if (ts.isJsxElement(node))
+            reject(filename, 'children of ' + tag);
+        return start;
+    }
+    const children = ts.isJsxElement(node)
+        ? node.children
+            .map((child) => jsx(child, file, filename, setup, defaults, components, restName))
+            .join('')
+        : '';
+    return start + children + (component ? '</Use>' : `</${tag}>`);
+}
+function exportedComponent(file, filename) {
+    const components = file.statements.filter((statement) => ts.isFunctionDeclaration(statement) &&
+        statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword) === true);
+    if (components.length !== 1 || !components[0]?.body)
+        reject(filename, 'one exported function component');
+    return components[0];
+}
+/** The source export used by a named TSX import; undefined means default export. */
+export function reactComponentExportName(source, filename = 'Component.tsx') {
+    const file = ts.createSourceFile(filename, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+    const component = exportedComponent(file, filename);
+    return component.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.DefaultKeyword)
+        ? undefined
+        : component.name?.text;
+}
+/** Converts one typed, stateless exported function component; unsupported behavior fails closed. */
+export function convertReactComponent(source, filename = 'Component.tsx', options = {}) {
+    const diagnostics = ts.transpileModule(source, {
+        fileName: filename,
+        reportDiagnostics: true,
+        compilerOptions: { jsx: ts.JsxEmit.Preserve },
+    }).diagnostics ?? [];
+    if (diagnostics.some((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error)) {
+        reject(filename, 'invalid TSX syntax');
+    }
+    const file = ts.createSourceFile(filename, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+    const component = exportedComponent(file, filename);
+    if (!component.body)
+        reject(filename, 'component body');
+    if (component.asteriskToken ||
+        component.modifiers?.some((modifier) => ![ts.SyntaxKind.ExportKeyword, ts.SyntaxKind.DefaultKeyword].includes(modifier.kind)))
+        reject(filename, 'async or generator component');
+    const declarations = file.statements.filter((statement) => statement !== component);
+    const imports = [];
+    const components = new Set();
+    const reactTypes = new Set();
+    for (const statement of declarations) {
+        if (!ts.isImportDeclaration(statement))
+            continue;
+        const original = ts.isStringLiteral(statement.moduleSpecifier)
+            ? statement.moduleSpecifier.text
+            : '';
+        const clause = statement.importClause;
+        if (original === 'react' && clause?.isTypeOnly) {
+            if (!clause.namedBindings || !ts.isNamedImports(clause.namedBindings))
+                reject(filename, 'React type import');
+            for (const binding of clause.namedBindings.elements) {
+                reactTypes.add(binding.name.text);
+            }
+            imports.push(statement.getText(file));
+            continue;
+        }
+        const rewritten = options.resolveReactImport?.(original) ??
+            (original.endsWith('.tsx?workstar') ? original : undefined);
+        if (!rewritten || !clause || clause.isTypeOnly)
+            reject(filename, 'imports or module statements');
+        if (clause.name)
+            components.add(clause.name.text);
+        if (clause.namedBindings) {
+            if (!ts.isNamedImports(clause.namedBindings))
+                reject(filename, 'namespace component import');
+            for (const binding of clause.namedBindings.elements) {
+                if (!binding.isTypeOnly)
+                    components.add(binding.name.text);
+            }
+        }
+        const text = statement.getText(file);
+        const start = statement.moduleSpecifier.getStart(file) - statement.getStart(file);
+        const end = statement.moduleSpecifier.getEnd() - statement.getStart(file);
+        imports.push(text.slice(0, start) + JSON.stringify(rewritten) + text.slice(end));
+    }
+    const typeDeclarations = declarations.filter((statement) => !ts.isImportDeclaration(statement));
+    if (typeDeclarations.some((statement) => !ts.isInterfaceDeclaration(statement) &&
+        !ts.isTypeAliasDeclaration(statement))) {
+        reject(filename, 'imports or module statements');
+    }
+    if (component.parameters.length > 1)
+        reject(filename, 'multiple component parameters');
+    const parameter = component.parameters[0];
+    let props = '';
+    const declaredProps = new Set();
+    if (parameter) {
+        if (!ts.isObjectBindingPattern(parameter.name) || !parameter.type)
+            reject(filename, 'typed destructured props');
+        const binding = parameter.name;
+        if (binding.elements.some((element) => !ts.isIdentifier(element.name) ||
+            Boolean(element.propertyName) ||
+            (Boolean(element.dotDotDotToken) &&
+                element !== binding.elements.at(-1)) ||
+            (element.initializer !== undefined &&
+                !isLiteralDefault(element.initializer))))
+            reject(filename, 'renamed, defaulted, or rest props');
+        if (ts.isTypeLiteralNode(parameter.type)) {
+            props = 'export type Props = ' + parameter.type.getText(file) + ';';
+            for (const member of parameter.type.members) {
+                if (ts.isPropertySignature(member) && ts.isIdentifier(member.name))
+                    declaredProps.add(member.name.text);
+            }
+        }
+        else if (ts.isTypeReferenceNode(parameter.type) &&
+            ts.isIdentifier(parameter.type.typeName)) {
+            const typeName = parameter.type.typeName.text;
+            const declaration = typeDeclarations.find((statement) => (ts.isInterfaceDeclaration(statement) ||
+                ts.isTypeAliasDeclaration(statement)) &&
+                statement.name.text === typeName);
+            if (!declaration ||
+                (!ts.isInterfaceDeclaration(declaration) &&
+                    !ts.isTypeAliasDeclaration(declaration)))
+                reject(filename, 'Props declaration');
+            if ((ts.isInterfaceDeclaration(declaration) &&
+                declaration.heritageClauses?.some((clause) => clause.types.some((type) => !ts.isIdentifier(type.expression) ||
+                    !reactTypes.has(type.expression.text) ||
+                    type.expression.text !== 'HTMLAttributes'))) ||
+                (ts.isTypeAliasDeclaration(declaration) &&
+                    !ts.isTypeLiteralNode(declaration.type))) {
+                reject(filename, 'inherited or non-literal Props');
+            }
+            const members = ts.isInterfaceDeclaration(declaration)
+                ? declaration.members
+                : ts.isTypeAliasDeclaration(declaration) &&
+                    ts.isTypeLiteralNode(declaration.type)
+                    ? declaration.type.members
+                    : [];
+            for (const member of members) {
+                if (ts.isPropertySignature(member) && ts.isIdentifier(member.name))
+                    declaredProps.add(member.name.text);
+            }
+            const declarationText = declaration.getText(file);
+            const nameStart = declaration.name.getStart(file) - declaration.getStart(file);
+            const nameEnd = declaration.name.getEnd() - declaration.getStart(file);
+            props =
+                (declaration.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)
+                    ? ''
+                    : 'export ') +
+                    declarationText.slice(0, nameStart) +
+                    'Props' +
+                    declarationText.slice(nameEnd);
+        }
+        else {
+            reject(filename, 'Props type');
+        }
+    }
+    else if (typeDeclarations.length) {
+        reject(filename, 'unused module declarations');
+    }
+    const onlyStatement = component.body.statements[0];
+    if (component.body.statements.length !== 1 ||
+        !onlyStatement ||
+        !ts.isReturnStatement(onlyStatement) ||
+        !onlyStatement.expression)
+        reject(filename, 'component logic');
+    let view = onlyStatement.expression;
+    while (ts.isParenthesizedExpression(view))
+        view = view.expression;
+    if (!ts.isJsxElement(view) &&
+        !ts.isJsxSelfClosingElement(view) &&
+        !ts.isJsxFragment(view)) {
+        reject(filename, 'non-JSX return');
+    }
+    const setup = [];
+    const defaults = parameter && ts.isObjectBindingPattern(parameter.name)
+        ? parameter.name.elements.filter((element) => element.initializer !== undefined)
+        : [];
+    const elements = parameter && ts.isObjectBindingPattern(parameter.name)
+        ? parameter.name.elements
+        : [];
+    const rest = elements.find((element) => element.dotDotDotToken);
+    const restName = rest && ts.isIdentifier(rest.name) ? rest.name.text : undefined;
+    const additionalBindings = elements
+        .filter((element) => !element.dotDotDotToken &&
+        ts.isIdentifier(element.name) &&
+        !declaredProps.has(element.name.text))
+        .map((element) => element.name.getText(file));
+    if (additionalBindings.length)
+        setup.push(`const { ${additionalBindings.join(', ')} } = props;`);
+    if (restName) {
+        if (restName === '__workstarRest')
+            reject(filename, 'reserved rest prop name');
+        setup.push(`const __workstarRest = ((${parameter.name.getText(file)}: Props) => ${restName})(props);`);
+    }
+    const markup = jsx(view, file, filename, setup, defaults, components, restName);
+    const script = [...imports, props, ...setup].filter(Boolean).join('\n');
+    return ((script ? '<script lang="ts">\n' + script + '\n</script>\n' : '') +
+        markup +
+        '\n');
+}
+function isLiteralDefault(node) {
+    return (ts.isStringLiteral(node) ||
+        ts.isNumericLiteral(node) ||
+        node.kind === ts.SyntaxKind.TrueKeyword ||
+        node.kind === ts.SyntaxKind.FalseKeyword);
+}

package/dist/src/react-entry-compat.d.ts

@@ -0,0 +1,2 @@
+/** Replace the conventional createRoot entry with a Workstar mount. */
+export declare function convertReactRootEntry(source: string, filename: string): string | undefined;

package/dist/src/react-entry-compat.js

@@ -0,0 +1,105 @@
+import ts from 'typescript';
+import { reject } from './compat-rules.js';
+function importedNames(statement) {
+    if (statement.importClause?.isTypeOnly || statement.importClause?.name)
+        return [];
+    const bindings = statement.importClause?.namedBindings;
+    if (!bindings || !ts.isNamedImports(bindings))
+        return [];
+    if (bindings.elements.some((element) => element.isTypeOnly || element.propertyName))
+        return [];
+    return bindings.elements.map((element) => element.name.text);
+}
+function containsUnsupportedEntrySyntax(node) {
+    if (ts.isJsxElement(node) ||
+        ts.isJsxSelfClosingElement(node) ||
+        ts.isJsxFragment(node) ||
+        (ts.isIdentifier(node) &&
+            (node.text === 'createRoot' || node.text === 'StrictMode')))
+        return true;
+    return ts.forEachChild(node, containsUnsupportedEntrySyntax) === true;
+}
+function singleComponent(node, strictMode, filename) {
+    let element = node;
+    if (ts.isJsxElement(element)) {
+        if (!strictMode ||
+            element.openingElement.tagName.getText() !== 'StrictMode' ||
+            element.closingElement.tagName.getText() !== 'StrictMode')
+            reject(filename, 'React root entry');
+        const children = element.children.filter((child) => !ts.isJsxText(child) || child.getText().trim() !== '');
+        if (children.length !== 1)
+            reject(filename, 'React root entry');
+        element = children[0];
+    }
+    if (!ts.isJsxSelfClosingElement(element) ||
+        element.attributes.properties.length !== 0 ||
+        !ts.isIdentifier(element.tagName))
+        reject(filename, 'React root entry');
+    return element.tagName.text;
+}
+/** Replace the conventional createRoot entry with a Workstar mount. */
+export function convertReactRootEntry(source, filename) {
+    const file = ts.createSourceFile(filename, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+    const imports = file.statements.filter(ts.isImportDeclaration);
+    const rootImport = imports.find((statement) => ts.isStringLiteral(statement.moduleSpecifier) &&
+        statement.moduleSpecifier.text === 'react-dom/client');
+    if (!rootImport)
+        return undefined;
+    const reactImport = imports.find((statement) => ts.isStringLiteral(statement.moduleSpecifier) &&
+        statement.moduleSpecifier.text === 'react');
+    const strictMode = reactImport !== undefined;
+    if (imports.filter((entry) => ts.isStringLiteral(entry.moduleSpecifier) &&
+        entry.moduleSpecifier.text === 'react-dom/client').length !== 1 ||
+        imports.filter((entry) => ts.isStringLiteral(entry.moduleSpecifier) &&
+            entry.moduleSpecifier.text === 'react').length > 1 ||
+        importedNames(rootImport).join(',') !== 'createRoot' ||
+        (reactImport && importedNames(reactImport).join(',') !== 'StrictMode'))
+        reject(filename, 'React root imports');
+    const statement = file.statements.at(-1);
+    if (!statement || !ts.isExpressionStatement(statement))
+        reject(filename, 'React root entry');
+    const renderCall = statement.expression;
+    if (!ts.isCallExpression(renderCall) ||
+        !ts.isPropertyAccessExpression(renderCall.expression) ||
+        renderCall.expression.name.text !== 'render' ||
+        renderCall.arguments.length !== 1)
+        reject(filename, 'React root entry');
+    const createCall = renderCall.expression.expression;
+    if (!ts.isCallExpression(createCall) ||
+        !ts.isIdentifier(createCall.expression) ||
+        createCall.expression.text !== 'createRoot' ||
+        createCall.arguments.length !== 1 ||
+        !ts.isIdentifier(createCall.arguments[0]))
+        reject(filename, 'React root entry');
+    const component = singleComponent(renderCall.arguments[0], strictMode, filename);
+    if (!imports.some((entry) => ts.isStringLiteral(entry.moduleSpecifier) &&
+        entry.moduleSpecifier.text.startsWith('.') &&
+        importedNames(entry).includes(component)))
+        reject(filename, 'local root component import');
+    if (file.statements.some((entry) => entry !== statement &&
+        !ts.isImportDeclaration(entry) &&
+        containsUnsupportedEntrySyntax(entry)))
+        reject(filename, 'extra React entry syntax');
+    const edits = [
+        { start: rootImport.getStart(file), end: rootImport.getEnd(), text: '' },
+        ...(reactImport
+            ? [
+                {
+                    start: reactImport.getStart(file),
+                    end: reactImport.getEnd(),
+                    text: '',
+                },
+            ]
+            : []),
+        {
+            start: statement.getStart(file),
+            end: statement.getEnd(),
+            text: `mount(${createCall.arguments[0].getText(file)}, ${component}({}));`,
+        },
+    ];
+    let output = source;
+    for (const edit of edits.sort((left, right) => right.start - left.start)) {
+        output = output.slice(0, edit.start) + edit.text + output.slice(edit.end);
+    }
+    return `import { mount } from 'workstar';\n${output}`;
+}

package/dist/src/react-import-resolution.d.ts

@@ -0,0 +1,2 @@
+/** Resolve a local TSX component to an explicit opt-in compatibility import. */
+export declare function resolveReactComponentImport(filename: string, specifier: string): string | undefined;

package/dist/src/react-import-resolution.js

@@ -0,0 +1,15 @@
+import { existsSync } from 'node:fs';
+import { dirname, extname, resolve } from 'node:path';
+/** Resolve a local TSX component to an explicit opt-in compatibility import. */
+export function resolveReactComponentImport(filename, specifier) {
+    if (!specifier.startsWith('.'))
+        return undefined;
+    const candidate = specifier.endsWith('.tsx')
+        ? specifier
+        : extname(specifier) === ''
+            ? `${specifier}.tsx`
+            : undefined;
+    if (!candidate || !existsSync(resolve(dirname(filename), candidate)))
+        return undefined;
+    return `${candidate}?workstar`;
+}

package/dist/src/source-map.d.ts

@@ -0,0 +1,7 @@
+import { type RawSourceMap } from 'source-map-js';
+import type { SourceOrigin } from './source-origin.js';
+/** Keep authored script locations while lowering generated TypeScript to Vite JavaScript. */
+export declare function transpileComponent(generated: string, authored: string, filename: string, origins: readonly SourceOrigin[]): {
+    code: string;
+    map: RawSourceMap;
+};

package/dist/src/source-map.js

@@ -0,0 +1,50 @@
+import { basename } from 'node:path';
+import { SourceMapConsumer, SourceMapGenerator, } from 'source-map-js';
+import ts from 'typescript';
+function positionAt(source, offset) {
+    const before = source.slice(0, offset);
+    const newline = before.lastIndexOf('\n');
+    return {
+        line: before.split('\n').length,
+        column: offset - newline - 1,
+    };
+}
+function componentSourceMap(authored, generated, sourceName, intermediateName, origins) {
+    const map = new SourceMapGenerator({ file: intermediateName });
+    for (const origin of origins) {
+        map.addMapping({
+            generated: positionAt(generated, origin.generatedOffset),
+            original: positionAt(authored, origin.authoredOffset),
+            source: sourceName,
+        });
+    }
+    map.setSourceContent(sourceName, authored);
+    return map.toJSON();
+}
+/** Keep authored script locations while lowering generated TypeScript to Vite JavaScript. */
+export function transpileComponent(generated, authored, filename, origins) {
+    const intermediateName = `${basename(filename)}.generated.ts`;
+    const output = ts.transpileModule(generated, {
+        fileName: intermediateName,
+        compilerOptions: {
+            module: ts.ModuleKind.ESNext,
+            target: ts.ScriptTarget.ES2022,
+            sourceMap: true,
+            inlineSources: true,
+        },
+    });
+    if (!output.sourceMapText)
+        throw new Error('TypeScript did not emit a source map.');
+    const typescriptMap = JSON.parse(output.sourceMapText);
+    const intermediateSource = typescriptMap.sources[0];
+    if (!intermediateSource)
+        throw new Error('TypeScript emitted an empty source map.');
+    const authoredMap = componentSourceMap(authored, generated, filename, intermediateName, origins);
+    const composed = SourceMapGenerator.fromSourceMap(new SourceMapConsumer(typescriptMap));
+    composed.applySourceMap(new SourceMapConsumer(authoredMap), intermediateSource);
+    composed.setSourceContent(filename, authored);
+    return {
+        code: output.outputText.replace(/^\/\/# sourceMappingURL=.*\n?/m, ''),
+        map: composed.toJSON(),
+    };
+}

package/dist/src/source-origin.d.ts

@@ -0,0 +1,14 @@
+import type { ScriptStatement } from './component-script.js';
+export interface SourceOrigin {
+    readonly generatedOffset: number;
+    readonly authoredOffset: number;
+}
+/** Records provenance while assembling the generated TypeScript module. */
+export declare class ComponentCode {
+    private readonly parts;
+    private length;
+    readonly origins: SourceOrigin[];
+    append(code: string, authoredOffset?: number, exact?: boolean): void;
+    appendStatements(statements: readonly ScriptStatement[], sourceOffset: (offset: number) => number): void;
+    toString(): string;
+}

package/dist/src/source-origin.js

@@ -0,0 +1,41 @@
+/** Records provenance while assembling the generated TypeScript module. */
+export class ComponentCode {
+    parts = [];
+    length = 0;
+    origins = [];
+    append(code, authoredOffset, exact = false) {
+        if (authoredOffset !== undefined) {
+            this.origins.push({
+                generatedOffset: this.length,
+                authoredOffset,
+            });
+            if (exact) {
+                for (const match of code.matchAll(/\n([^\n]*)/g)) {
+                    const line = match[1] ?? '';
+                    const firstToken = /\S/.exec(line)?.index;
+                    if (firstToken === undefined)
+                        continue;
+                    const offset = match.index + 1 + firstToken;
+                    this.origins.push({
+                        generatedOffset: this.length + offset,
+                        authoredOffset: authoredOffset + offset,
+                    });
+                }
+            }
+        }
+        this.parts.push(code);
+        this.length += code.length;
+    }
+    appendStatements(statements, sourceOffset) {
+        statements.forEach((statement, index) => {
+            if (index > 0)
+                this.append('\n');
+            this.append(statement.code, statement.sourceOffset === undefined
+                ? undefined
+                : sourceOffset(statement.sourceOffset), statement.exact);
+        });
+    }
+    toString() {
+        return this.parts.join('');
+    }
+}

package/dist/src/styles.d.ts

@@ -2,5 +2,10 @@ export interface CompiledStyle {
     css: string;
     scopeAttribute?: string;
 }
+export declare class StyleCompileError extends Error {
+    readonly line: number;
+    readonly column: number;
+    constructor(message: string, line: number, column: number);
+}
 /** Compile CSS at build time; styles never depend on client hydration. */
 export declare function compileStyle(css: string, filename: string, global?: boolean): CompiledStyle;