rooklang 0.0.0-stage → 0.3.0

package/dist/css/selectors.js

@@ -0,0 +1,168 @@
+// Selectors: split into compound selectors, given the class of a component, with the classes of
+// a CSS module renamed, or read for what elements they ask for. `:global(...)` keeps what is
+// inside it as it is.
+/** A selector list split at the commas outside brackets. */
+export function splitList(selector) {
+    return splitTopLevel(selector, (c) => c === ',').map((part) => part.trim());
+}
+/**
+ * A complex selector as compound selectors and the combinators between them:
+ * `ul > li.item a` → ["ul", " > ", "li.item", " ", "a"]. A relative selector starts with a
+ * combinator: `> a` → ["", "> ", "a"].
+ */
+export function splitComplex(selector) {
+    const parts = [];
+    let current = '';
+    let depth = 0;
+    for (let i = 0; i < selector.length; i++) {
+        const c = selector[i];
+        if (c === '(' || c === '[')
+            depth++;
+        if (c === ')' || c === ']')
+            depth--;
+        if (depth === 0 &&
+            (c === ' ' || c === '>' || c === '+' || c === '~') &&
+            !escaped(selector, i)) {
+            let combinator = '';
+            while (i < selector.length && /[\s>+~]/.test(selector[i]))
+                combinator += selector[i++];
+            i--;
+            parts.push(current, combinator.trim() === '' ? ' ' : ` ${combinator.trim()} `);
+            current = '';
+        }
+        else {
+            current += c;
+        }
+    }
+    parts.push(current);
+    return parts;
+}
+/**
+ * Gives every compound selector the class of a component, before its pseudo-elements, so that the
+ * rule applies only to its elements. Compounds with `&` refer to the rule around them, and those
+ * in `:global(...)` are left to the page.
+ */
+export function scopeSelector(selector, scope) {
+    return splitList(selector)
+        .map((complex) => splitComplex(complex)
+        .map((part, i) => (i % 2 === 1 || part === '' ? part : scopeCompound(part, scope)))
+        .join('')
+        .trim())
+        .join(', ');
+}
+function scopeCompound(compound, scope) {
+    if (compound.includes(':global('))
+        return unwrapGlobal(compound);
+    if (compound.includes('&'))
+        return compound;
+    const pseudo = pseudoElementStart(compound);
+    return `${compound.slice(0, pseudo)}.${scope}${compound.slice(pseudo)}`;
+}
+/** Where the pseudo-element of a compound starts: `a::before` → 1, or its length if none. */
+function pseudoElementStart(compound) {
+    let depth = 0;
+    for (let i = 0; i < compound.length; i++) {
+        const c = compound[i];
+        if (c === '(' || c === '[')
+            depth++;
+        if (c === ')' || c === ']')
+            depth--;
+        if (depth === 0 && c === ':' && LEGACY_PSEUDO_ELEMENT.test(compound.slice(i)))
+            return i;
+    }
+    return compound.length;
+}
+/** `::before`, and the pseudo-elements that may be written with one colon. */
+const LEGACY_PSEUDO_ELEMENT = /^(?:::|:(?:before|after|first-line|first-letter)(?![\w-]))/;
+/** `:global(.a) .b` → `.a .b`. */
+export function unwrapGlobal(selector) {
+    let result = selector;
+    while (true) {
+        const start = result.indexOf(':global(');
+        if (start === -1)
+            return result;
+        const close = matchingParen(result, start + ':global'.length);
+        result =
+            result.slice(0, start) +
+                result.slice(start + ':global('.length, close) +
+                result.slice(close + 1);
+    }
+}
+/**
+ * The classes of a CSS module get its names: `.button:hover` → `.button_k3f9:hover`. Classes in
+ * `:global(...)` keep their names. Calls `found` for every local class.
+ */
+export function renameClasses(selector, rename, found) {
+    let result = '';
+    let i = 0;
+    while (i < selector.length) {
+        if (selector.startsWith(':global(', i)) {
+            const close = matchingParen(selector, i + ':global'.length);
+            result += selector.slice(i + ':global('.length, close);
+            i = close + 1;
+        }
+        else if (selector[i] === '[' || selector[i] === '"' || selector[i] === "'") {
+            // Attribute selectors and strings are not classes: `[class~="a"]`.
+            const end = selector[i] === '[' ? selector.indexOf(']', i) : selector.indexOf(selector[i], i + 1);
+            const stop = end === -1 ? selector.length : end + 1;
+            result += selector.slice(i, stop);
+            i = stop;
+        }
+        else if (selector[i] === '.' &&
+            !escaped(selector, i) &&
+            /[\w-]/.test(selector[i + 1] ?? '')) {
+            const name = /^[\w-]+/.exec(selector.slice(i + 1))[0];
+            found(name);
+            result += `.${rename(name)}`;
+            i += name.length + 1;
+        }
+        else {
+            result += selector[i];
+            i++;
+        }
+    }
+    return result;
+}
+/** The tag, classes and ids a compound requires; those inside `:not(...)` and others are not. */
+export function requirements(compound) {
+    const outside = compound.replace(/\([^)]*\)/g, '()').replace(/\[[^\]]*\]/g, '[]');
+    const tag = /^[a-zA-Z][\w-]*|^\*/.exec(outside)?.[0] ?? null;
+    return {
+        tag: tag === '*' ? null : tag,
+        classes: [...outside.matchAll(/\.([\w-]+)/g)].map((match) => match[1]),
+        ids: [...outside.matchAll(/#([\w-]+)/g)].map((match) => match[1]),
+    };
+}
+function splitTopLevel(text, at) {
+    const parts = [];
+    let current = '';
+    let depth = 0;
+    for (const c of text) {
+        if (c === '(' || c === '[')
+            depth++;
+        if (c === ')' || c === ']')
+            depth--;
+        if (depth === 0 && at(c)) {
+            parts.push(current);
+            current = '';
+        }
+        else {
+            current += c;
+        }
+    }
+    parts.push(current);
+    return parts;
+}
+function matchingParen(text, open) {
+    let depth = 0;
+    for (let i = open; i < text.length; i++) {
+        if (text[i] === '(')
+            depth++;
+        if (text[i] === ')' && --depth === 0)
+            return i;
+    }
+    return text.length;
+}
+function escaped(text, i) {
+    return i > 0 && text[i - 1] === '\\';
+}

package/dist/declarations.d.ts

@@ -0,0 +1,3 @@
+import type * as ast from './ast.ts';
+import type { CheckResult } from './checker/checker.ts';
+export declare function printDeclarations(program: ast.Program, checked: CheckResult): string;

package/dist/declarations.js

@@ -0,0 +1,207 @@
+import { JS_RESERVED } from "./codegen/syntax.js";
+import { generatorType, property, resultType, tsType } from "./ts-types.js";
+// A TypeScript declaration file (`.d.ts`) for a compiled module, so that TypeScript code can use
+// it with types. Parameter names come from the code, types from the type checker:
+//
+//   number, string, bool   → number, string, boolean
+//   ?T, error              → T | null, Error | null
+//   []T                    → T[]
+//   (A, B) results         → [A, B], the array that the JS function returns
+//
+// Interfaces, type aliases and classes are declared even when they are not exported, since the
+// exported declarations may use them. Components exist only at compile time and are left out.
+export function printDeclarations(program, checked) {
+    const printer = new DeclarationPrinter(checked);
+    return printer.print(program);
+}
+class DeclarationPrinter {
+    checked;
+    lines = [];
+    constructor(checked) {
+        this.checked = checked;
+    }
+    print(program) {
+        let exports = false;
+        for (const statement of program.body) {
+            if ('exported' in statement && statement.exported)
+                exports = true;
+            switch (statement.kind) {
+                case 'ImportDeclaration':
+                    this.importDeclaration(statement);
+                    break;
+                case 'FuncDeclaration':
+                    if (statement.exported)
+                        this.functionDeclaration(statement);
+                    break;
+                case 'VariableDeclaration':
+                    if (statement.exported)
+                        this.variableDeclaration(statement);
+                    break;
+                case 'ClassDeclaration':
+                    this.classDeclaration(statement);
+                    break;
+                case 'InterfaceDeclaration':
+                    this.interfaceDeclaration(statement);
+                    break;
+                case 'TypeAliasDeclaration':
+                    this.typeAlias(statement);
+                    break;
+                default:
+                    break;
+            }
+        }
+        // A declaration file without imports or exports would declare global names.
+        if (!exports)
+            this.lines.push('export {};');
+        return this.lines.join('\n') + '\n';
+    }
+    /** Imports are repeated, so that the names they bring can be used in types. */
+    importDeclaration(node) {
+        const parts = [];
+        if (node.defaultImport)
+            parts.push(node.defaultImport.name);
+        if (node.namespaceImport)
+            parts.push(`* as ${node.namespaceImport.name}`);
+        if (node.namedImports.length > 0) {
+            const names = node.namedImports.map((specifier) => specifier.imported.name === specifier.local.name
+                ? specifier.local.name
+                : `${specifier.imported.name} as ${specifier.local.name}`);
+            parts.push(`{ ${names.join(', ')} }`);
+        }
+        if (parts.length === 0)
+            return;
+        const source = node.source.value.replace(/\.rk$/, '.js');
+        this.lines.push(`import ${parts.join(', ')} from ${JSON.stringify(source)};`);
+    }
+    functionDeclaration(node) {
+        const type = this.checked.declarations.values.get(node.name.name);
+        if (type?.kind !== 'function')
+            return;
+        const name = jsName(node.name.name);
+        this.lines.push(`export declare function ${name}${this.typeParams(type.typeParams)}${this.signature(node.params, type)};`);
+    }
+    variableDeclaration(node) {
+        const keyword = node.keyword === 'let' ? 'let' : 'const';
+        for (const name of node.names) {
+            if (name.name === '_')
+                continue;
+            const type = this.checked.declarations.values.get(name.name);
+            this.lines.push(`export declare ${keyword} ${jsName(name.name)}: ${type ? tsType(type) : 'any'};`);
+        }
+    }
+    interfaceDeclaration(node) {
+        const type = this.checked.declarations.types.get(node.name.name);
+        if (type?.kind !== 'object')
+            return;
+        const exported = node.exported ? 'export ' : '';
+        this.lines.push(`${exported}interface ${node.name.name}${this.typeParams(type.typeParams ?? [])} {`, ...this.objectMembers(node.members, type).map((line) => `    ${line}`), '}');
+    }
+    typeAlias(node) {
+        const type = this.checked.declarations.types.get(node.name.name);
+        if (!type)
+            return;
+        const exported = node.exported ? 'export ' : '';
+        const params = this.typeParams(type.kind === 'object' ? (type.typeParams ?? []) : []);
+        // `type Pair<A, B any> { ... }` names an object type; other aliases are another name.
+        if (node.type.kind === 'ObjectType' && type.kind === 'object') {
+            const members = this.objectMembers(node.type.members, type);
+            this.lines.push(`${exported}type ${node.name.name}${params} = {`, ...members.map((line) => `    ${line}`), '};');
+            return;
+        }
+        this.lines.push(`${exported}type ${node.name.name}${params} = ${tsType(type, true)};`);
+    }
+    /** Members of an interface or an object type, with the parameter names of its methods. */
+    objectMembers(members, type) {
+        return members.map((member) => {
+            if (member.kind === 'IndexSignature') {
+                return `[key: string]: ${type.index ? tsType(type.index, false) : 'any'};`;
+            }
+            const name = member.name.name;
+            const memberType = type.members.get(name)?.type;
+            if (member.kind === 'MethodSignature' && memberType?.kind === 'function') {
+                return `${name}${this.signature(member.params, memberType)};`;
+            }
+            return memberType ? property(name, memberType) : `${name}: any;`;
+        });
+    }
+    classDeclaration(node) {
+        const instance = this.checked.declarations.types.get(node.name.name);
+        if (instance?.kind !== 'class')
+            return;
+        const { info } = instance;
+        const exported = node.exported ? 'export ' : '';
+        const base = node.superClass && expressionName(node.superClass);
+        const heritage = base ? ` extends ${base}` : '';
+        const lines = [];
+        for (const member of node.members) {
+            switch (member.kind) {
+                case 'FieldDeclaration': {
+                    const found = (member.isStatic ? info.statics : info.members).get(member.name.name);
+                    const modifiers = this.modifiers(member.visibility, member.isStatic);
+                    // As in the declaration files TypeScript writes, private members have no type.
+                    if (member.visibility === 'private')
+                        lines.push(`${modifiers}${member.name.name};`);
+                    else if (found)
+                        lines.push(`${modifiers}${member.name.name}: ${tsType(found.type)};`);
+                    break;
+                }
+                case 'ConstructorDeclaration': {
+                    const modifiers = this.modifiers(member.visibility, false);
+                    if (info.ctor) {
+                        lines.push(`${modifiers}constructor${parameters(member.params, info.ctor)};`);
+                    }
+                    break;
+                }
+                case 'MethodDeclaration': {
+                    const found = (member.isStatic ? info.statics : info.members).get(member.name.name);
+                    const modifiers = this.modifiers(member.visibility, member.isStatic);
+                    if (member.visibility === 'private')
+                        lines.push(`${modifiers}${member.name.name}();`);
+                    else if (found?.type.kind === 'function') {
+                        lines.push(`${modifiers}${member.name.name}${this.signature(member.params, found.type)};`);
+                    }
+                    break;
+                }
+            }
+        }
+        this.lines.push(`${exported}declare class ${jsName(node.name.name)}${this.typeParams(info.typeParams)}${heritage} {`, ...lines.map((line) => `    ${line}`), '}');
+    }
+    modifiers(visibility, isStatic) {
+        return `${visibility === 'public' ? '' : `${visibility} `}${isStatic ? 'static ' : ''}`;
+    }
+    /** `<T, U extends Shape>` */
+    typeParams(params) {
+        if (params.length === 0)
+            return '';
+        const list = params.map((param) => param.constraint ? `${param.name} extends ${tsType(param.constraint)}` : param.name);
+        return `<${list.join(', ')}>`;
+    }
+    /** `(a: number, b?: string): R` with the names of the parameters in the code. */
+    signature(params, type) {
+        // An iterator is a generator function: it takes no function and gives the generator.
+        if (type.iterator)
+            return `(): ${generatorType(type)}`;
+        return `${parameters(params, type)}: ${resultType(type.results)}`;
+    }
+}
+function parameters(params, type) {
+    const list = type.params.map((param, i) => {
+        const name = params[i] ? jsName(params[i].name.name) : `arg${i + 1}`;
+        return `${name}${i < type.required ? '' : '?'}: ${tsType(param)}`;
+    });
+    return `(${list.join(', ')})`;
+}
+/** `Base` or `events.EventEmitter` in `extends`; other expressions cannot be written in types. */
+function expressionName(node) {
+    if (node.kind === 'Identifier')
+        return node.name;
+    if (node.kind === 'MemberExpression') {
+        const object = expressionName(node.object);
+        return object && `${object}.${node.property.name}`;
+    }
+    return null;
+}
+/** Names that are reserved in JS get `$`, as in the generated code. */
+function jsName(name) {
+    return JS_RESERVED.has(name) ? `${name}$` : name;
+}

package/dist/decorator-copy.d.ts

@@ -0,0 +1,18 @@
+import type * as ast from './ast.ts';
+/** Called with each copy of a node, so that the generator keeps the types of the originals. */
+export type CopyListener = (copy: ast.Node, original: ast.Node) => void;
+/** The node in the code as written that `node` is a copy of, through copies of copies. */
+export declare function originOf(node: ast.Node): ast.Node;
+/**
+ * Renames of the names that are not values: tags of components, `<Icon />`, and decorators,
+ * `get(@visible.shown)`. Code of another module refers to those of its own module.
+ */
+export interface OtherNames {
+    tags?: ReadonlyMap<string, string>;
+    decorators?: ReadonlyMap<string, string>;
+}
+/**
+ * Copies nodes, renaming names where a local declaration does not hide them. Names of properties,
+ * attributes and types are left as they are, and so are tags and decorators without `other`.
+ */
+export declare function renamer(renames: ReadonlyMap<string, string>, copied: CopyListener | undefined, other?: OtherNames): <T extends ast.Node>(node: T, hidden: ReadonlySet<string>) => T;

package/dist/decorator-copy.js

@@ -0,0 +1,158 @@
+import { declaredIn } from "./names.js";
+/** The node each copy was made from. */
+const origins = new WeakMap();
+/** The node in the code as written that `node` is a copy of, through copies of copies. */
+export function originOf(node) {
+    let current = node;
+    while (true) {
+        const origin = origins.get(current);
+        if (!origin)
+            return current;
+        current = origin;
+    }
+}
+const TYPE_NODES = new Set([
+    'TypeReference',
+    'ArrayType',
+    'NullableType',
+    'FuncType',
+    'ComponentType',
+    'ObjectType',
+    'UnionType',
+    'LiteralType',
+    'TypeParameter',
+    'PropertySignature',
+    'MethodSignature',
+    'IndexSignature',
+]);
+function isNode(value) {
+    return typeof value === 'object' && value !== null && 'kind' in value;
+}
+/**
+ * Copies nodes, renaming names where a local declaration does not hide them. Names of properties,
+ * attributes and types are left as they are, and so are tags and decorators without `other`.
+ */
+export function renamer(renames, copied, other = {}) {
+    const done = (copy, original) => {
+        origins.set(copy, original);
+        copied?.(copy, original);
+        return copy;
+    };
+    const statements = (list, hidden) => {
+        const inner = new Set([...hidden, ...declaredIn(list)]);
+        return list.map((statement) => copy(statement, inner));
+    };
+    const scoped = (names, hidden) => new Set([...hidden, ...names]);
+    const paramNames = (params) => params.map((param) => param.name.name);
+    const generic = (node, hidden) => {
+        const result = {};
+        for (const [key, value] of Object.entries(node)) {
+            if (Array.isArray(value)) {
+                result[key] = value.map((item) => (isNode(item) ? copy(item, hidden) : item));
+            }
+            else {
+                result[key] = isNode(value) ? copy(value, hidden) : value;
+            }
+        }
+        return done(result, node);
+    };
+    const copy = (original, hidden) => {
+        const node = original;
+        if (TYPE_NODES.has(node.kind))
+            return original;
+        switch (node.kind) {
+            // The names of `@cart.count` are the other decorator's.
+            case 'DecoratorMember': {
+                const name = other.decorators?.get(node.decorator.name);
+                return name === undefined
+                    ? original
+                    : done({ ...node, decorator: { ...node.decorator, name } }, node);
+            }
+            case 'Identifier': {
+                const name = hidden.has(node.name) ? undefined : renames.get(node.name);
+                return name === undefined ? original : done({ ...node, name }, node);
+            }
+            case 'MemberExpression':
+                return done({ ...node, object: copy(node.object, hidden) }, node);
+            case 'Property': {
+                const value = copy(node.value, hidden);
+                // `{ shown }` becomes `{ shown: $$visible$shown }`.
+                const shorthand = node.shorthand && value === node.value;
+                return done({ ...node, value, shorthand }, node);
+            }
+            case 'JsxAttribute':
+                return done({ ...node, value: node.value && copy(node.value, hidden) }, node);
+            case 'ElementExpression': {
+                const name = node.tag && other.tags?.get(node.tag.name);
+                // `<Page />` with a variable `Page`: a renamed variable becomes the value of the tag.
+                const variable = node.tag && name === undefined && /^[A-Z]/.test(node.tag.name)
+                    ? copy(node.tag, hidden)
+                    : null;
+                const value = node.value
+                    ? copy(node.value, hidden)
+                    : variable !== node.tag
+                        ? variable
+                        : null;
+                return done({
+                    ...node,
+                    tag: name ? { ...node.tag, name } : node.tag,
+                    value,
+                    attributes: node.attributes.map((attribute) => copy(attribute, hidden)),
+                    children: node.children.map((child) => copy(child, hidden)),
+                }, node);
+            }
+            case 'MethodDeclaration': {
+                const inner = scoped(paramNames(node.params), hidden);
+                return done({
+                    ...node,
+                    params: node.params.map((param) => copy(param, inner)),
+                    body: copy(node.body, inner),
+                }, node);
+            }
+            case 'FieldDeclaration':
+                return done({ ...node, value: node.value && copy(node.value, hidden) }, node);
+            case 'FuncDeclaration':
+            case 'FuncExpression':
+            case 'ArrowFunction':
+            case 'ConstructorDeclaration': {
+                const inner = scoped(paramNames(node.params), hidden);
+                const renamed = generic(node, inner);
+                // The name of a declared function is in the enclosing scope.
+                if (node.kind === 'FuncDeclaration') {
+                    renamed.name = copy(node.name, hidden);
+                }
+                return renamed;
+            }
+            case 'Parameter':
+                return done({ ...node, defaultValue: node.defaultValue && copy(node.defaultValue, hidden) }, node);
+            case 'BlockStatement':
+                return done({ ...node, body: statements(node.body, hidden) }, node);
+            case 'SwitchCase':
+                return done({
+                    ...node,
+                    tests: node.tests.map((test) => copy(test, hidden)),
+                    body: statements(node.body, hidden),
+                }, node);
+            case 'EventHandler':
+                return done({ ...node, body: statements(node.body, scoped(['event'], hidden)) }, node);
+            case 'ForInStatement': {
+                const names = [node.value.name, ...(node.key ? [node.key.name] : [])];
+                return done({
+                    ...node,
+                    iterable: copy(node.iterable, hidden),
+                    body: copy(node.body, scoped(names, hidden)),
+                }, node);
+            }
+            case 'ForStatement':
+                return generic(node, scoped(node.init ? declaredIn([node.init]) : [], hidden));
+            case 'CatchClause':
+                return done({
+                    ...node,
+                    body: copy(node.body, scoped(node.param ? [node.param.name] : [], hidden)),
+                }, node);
+            default:
+                return generic(original, hidden);
+        }
+    };
+    return copy;
+}

package/dist/decorators.d.ts

@@ -0,0 +1,61 @@
+import type * as ast from './ast.ts';
+import { type CopyListener } from './decorator-copy.ts';
+/** The JS name of a member or a parameter of a decorator, in the components it is applied to. */
+export declare function decoratedName(decorator: string, member: string): string;
+/**
+ * Whether a declaration of an applied component gets an argument of a decorator. When the
+ * argument reads the component's properties, the declaration is a `state` that the properties
+ * set again.
+ */
+export declare function isDecoratorArgument(node: ast.Statement): node is ast.VariableDeclaration;
+/**
+ * Whether markup is what a component returns to the wrapper of a decorator, as in
+ * `const $$visible$content = <section>...</section>`: it updates like returned markup.
+ */
+export declare function isWrappedContent(node: ast.Expression): boolean;
+/** The markup that an applied component gives to the wrappers, whichever `return` it takes. */
+export declare function wrappedMarkup(component: ast.ComponentDeclaration): ast.Expression[];
+/** `return (content Element) => ...` at the end of a decorator's body. */
+export interface Wrapper {
+    fn: ast.ArrowFunction | ast.FuncExpression;
+    param: ast.Parameter;
+}
+/** The wrapper of a decorator, when it returns a function literal with one parameter. */
+export declare function wrapperOf(decorator: ast.DecoratorDeclaration): Wrapper | null;
+/** The statements of a wrapper; an expression body is what it returns. */
+export declare function wrapperBody(fn: ast.ArrowFunction | ast.FuncExpression): ast.Statement[];
+/** The parameter of a wrapper and its declarations, which go into the component's body too. */
+export declare function wrapperNames(wrapper: Wrapper): string[];
+/**
+ * A decorator that components can apply. One from another module uses the names of its own module
+ * through hidden exports, `$$visible$log`, so its code gets them renamed.
+ */
+export interface DecoratorSource {
+    node: ast.DecoratorDeclaration;
+    moduleNames: readonly string[];
+    /** For one of another module: the tags here of the components of that module its code uses. */
+    tags?: ReadonlyMap<string, string> | undefined;
+}
+/**
+ * The names of its module that a decorator's code uses. Other modules that apply it get them
+ * through hidden exports: `export { log as $$visible$log }`.
+ */
+export declare function moduleNamesOf(decorator: ast.DecoratorDeclaration, program: ast.Program): string[];
+/**
+ * The component with its decorators applied. Its body first declares the arguments of each
+ * decorator and runs its body, from the top decorator down, then runs the component's own body.
+ * The names of a decorator get its prefix, `$$visible$shown`, so they clash neither with each other
+ * nor with the component's names, and `get(@visible.shown)` reads that variable. The `mount()` of
+ * the decorators runs after the component's own, from the inside out, so it goes before every
+ * `return` of the component's body.
+ *
+ * A wrapper is inlined at every `return` too: `return <section />` becomes
+ * `const $$visible$content = <section />`, then the body of the wrapper, whose `return` is the
+ * component's. The wrappers apply from the bottom decorator up.
+ *
+ * `prefixes` replace the names of decorators in the prefixes: a module that inlines a component of
+ * another one keeps the decorators of that module apart from its own, `$$Card$visible$shown`.
+ */
+export declare function decorate(component: ast.ComponentDeclaration, decorators: ReadonlyMap<string, DecoratorSource>, copied?: CopyListener, prefixes?: ReadonlyMap<string, string>): ast.ComponentDeclaration;
+/** The parameters of a decorator and the declarations of its body: the names it renames. */
+export declare function decoratorNames(decorator: ast.DecoratorDeclaration): Set<string>;