@invariant-ui/cli 0.0.0-stage → 0.1.0

package/dist/compiler-angular/declared.js

@@ -0,0 +1,285 @@
+import { collapse, declarationOf, externalBases, hasModifier, isProjectNode, lineOf, relativeFileOf, resolveSymbol, typeReferenceInfo } from "../compiler-core/index.js";
+import ts from "typescript";
+import { typeInfoOf } from "./classes.js";
+import { slotName } from "./template.js";
+const DECLARATIONS = {
+    ɵɵComponentDeclaration: "component",
+    ɵɵDirectiveDeclaration: "directive",
+    ɵɵNgModuleDeclaration: "module"
+};
+const MARKERS = new Set(["ɵcmp", "ɵdir", "ɵmod"]);
+/** Positions of `ɵɵComponentDeclaration<T, Selector, ExportAs, Inputs, Outputs, Queries, NgContent, Standalone, HostDirectives>`. */
+const SELECTOR = 1;
+const EXPORT_AS = 2;
+const INPUTS = 3;
+const OUTPUTS = 4;
+const NG_CONTENT = 6;
+const STANDALONE = 7;
+const HOST_DIRECTIVES = 8;
+const SIGNAL_INPUTS = {
+    InputSignal: "signal-input",
+    InputSignalWithTransform: "signal-input",
+    ModelSignal: "model"
+};
+/**
+ * Reads a class of a declaration file the way the Angular compiler wrote it. A published library has no
+ * decorators left: ng-packagr emits `static ɵcmp: ɵɵComponentDeclaration<Button, "ui-button", never, { "variant":
+ * { "alias": "variant"; "required": false } }, { "clicked": "clicked" }, never, ["*"], true>` for a component
+ * (`ɵdir` for a directive, `ɵmod` for an NgModule). That type is the compiled metadata: selector, public input and
+ * output names, projection slots and standalone. Property types come from the class members. Nothing is executed.
+ */
+export function readDeclaredClass(analysis, node, seen = new Set()) {
+    if (!node.name || !node.getSourceFile().isDeclarationFile || seen.has(node))
+        return undefined;
+    seen.add(node);
+    const file = relativeFileOf(analysis, node);
+    const marker = node.members.find((m) => ts.isPropertyDeclaration(m) &&
+        hasModifier(m, ts.SyntaxKind.StaticKeyword) &&
+        ts.isIdentifier(m.name) &&
+        MARKERS.has(m.name.text));
+    const ref = marker?.type ? typeReferenceInfo(marker.type) : undefined;
+    const kind = ref ? DECLARATIONS[ref.name] : undefined;
+    if (!file || !ref || !kind)
+        return undefined;
+    const out = {
+        node,
+        name: node.name.text,
+        file,
+        line: lineOf(node),
+        kind,
+        imports: [],
+        declarations: [],
+        exports: [],
+        styles: [],
+        styleUrls: [],
+        host: {},
+        hostDirectives: [],
+        metadataInputs: [],
+        metadataOutputs: [],
+        inputs: [],
+        outputs: [],
+        hostListeners: [],
+        hostBindings: [],
+        queries: [],
+        inheritsFrom: [],
+        notes: []
+    };
+    const arg = (i) => ref.typeArguments[i];
+    if (kind === "module") {
+        out.declarations = namesOf(analysis, arg(1));
+        out.imports = namesOf(analysis, arg(2));
+        out.exports = namesOf(analysis, arg(3));
+        return out;
+    }
+    const selector = stringOf(arg(SELECTOR));
+    if (selector !== undefined)
+        out.selector = selector;
+    const standalone = arg(STANDALONE)?.getText();
+    if (standalone === "true" || standalone === "false")
+        out.standalone = standalone === "true";
+    const exportAs = tupleOf(arg(EXPORT_AS))[0];
+    if (exportAs !== undefined)
+        out.exportAs = exportAs;
+    out.hostDirectives = hostDirectivesOf(arg(HOST_DIRECTIVES));
+    const used = new Set();
+    out.projection = tupleOf(arg(NG_CONTENT)).map((select) => {
+        let name = select === "*" ? "default" : slotName(select);
+        for (let n = 2; used.has(name); n++)
+            name = `${select === "*" ? "default" : slotName(select)}_${n}`;
+        used.add(name);
+        return { name, ...(select === "*" ? {} : { select }) };
+    });
+    const members = membersOf(node);
+    for (const [property, spec] of inputMap(arg(INPUTS))) {
+        out.inputs.push(inputOf(analysis, members, property, spec, node));
+    }
+    for (const [property, alias] of outputMap(arg(OUTPUTS))) {
+        out.outputs.push(outputOf(analysis, members, out.inputs, property, alias, node));
+    }
+    const base = node.heritageClauses?.find((h) => h.token === ts.SyntaxKind.ExtendsKeyword)?.types[0];
+    if (base) {
+        const target = declarationOf(resolveSymbol(analysis.checker, analysis.checker.getSymbolAtLocation(base.expression)));
+        const parent = target && ts.isClassDeclaration(target) && isProjectNode(analysis, target)
+            ? readDeclaredClass(analysis, target, seen)
+            : undefined;
+        if (parent) {
+            for (const i of parent.inputs)
+                if (!out.inputs.some((x) => x.name === i.name))
+                    out.inputs.push({ ...i, inheritedFrom: i.inheritedFrom ?? parent.name });
+            for (const o of parent.outputs)
+                if (!out.outputs.some((x) => x.name === o.name))
+                    out.outputs.push({ ...o, inheritedFrom: o.inheritedFrom ?? parent.name });
+            out.inheritsFrom.push(...parent.inheritsFrom);
+        }
+        else
+            out.inheritsFrom.push(...externalBases(analysis, base));
+    }
+    return out;
+}
+function unparen(type) {
+    return ts.isParenthesizedTypeNode(type) ? unparen(type.type) : type;
+}
+/** `"ui-button"`; `never` and anything else is undefined. */
+function stringOf(type) {
+    const t = type ? unparen(type) : undefined;
+    return t && ts.isLiteralTypeNode(t) && ts.isStringLiteralLike(t.literal) ? t.literal.text : undefined;
+}
+/** `["*", "[header]"]`; `never` is the empty list. */
+function tupleOf(type) {
+    const t = type ? unparen(type) : undefined;
+    return t && ts.isTupleTypeNode(t) ? t.elements.flatMap((e) => stringOf(e) ?? []) : [];
+}
+function keyOf(member) {
+    return member.name && (ts.isIdentifier(member.name) || ts.isStringLiteralLike(member.name))
+        ? member.name.text
+        : undefined;
+}
+/** `{ "variant": { "alias": "variant"; "required": false; "isSignal": true } }`, or the older `{ "variant": "alias" }`. */
+function inputMap(type) {
+    const t = type ? unparen(type) : undefined;
+    if (!t || !ts.isTypeLiteralNode(t))
+        return [];
+    const out = [];
+    for (const member of t.members) {
+        const property = keyOf(member);
+        if (property === undefined || !ts.isPropertySignature(member) || !member.type)
+            continue;
+        const value = unparen(member.type);
+        const alias = stringOf(value);
+        if (alias !== undefined) {
+            out.push([property, { alias, required: false, isSignal: false }]);
+            continue;
+        }
+        if (!ts.isTypeLiteralNode(value))
+            continue;
+        const field = (key) => value.members.find((m) => ts.isPropertySignature(m) && keyOf(m) === key)
+            ?.type;
+        out.push([
+            property,
+            {
+                alias: stringOf(field("alias")) ?? property,
+                required: field("required")?.getText() === "true",
+                isSignal: field("isSignal")?.getText() === "true"
+            }
+        ]);
+    }
+    return out;
+}
+/** `{ "clicked": "clicked" }`: class property to public event name. */
+function outputMap(type) {
+    const t = type ? unparen(type) : undefined;
+    if (!t || !ts.isTypeLiteralNode(t))
+        return [];
+    return t.members.flatMap((member) => {
+        const property = keyOf(member);
+        const alias = ts.isPropertySignature(member) ? stringOf(member.type) : undefined;
+        return property !== undefined && alias !== undefined ? [[property, alias]] : [];
+    });
+}
+function hostDirectivesOf(type) {
+    const t = type ? unparen(type) : undefined;
+    if (!t || !ts.isTupleTypeNode(t))
+        return [];
+    return t.elements.flatMap((e) => {
+        const literal = ts.isTypeLiteralNode(unparen(e)) ? unparen(e) : undefined;
+        const directive = literal?.members.find((m) => ts.isPropertySignature(m) && keyOf(m) === "directive")?.type;
+        return directive && ts.isTypeQueryNode(directive) ? [collapse(directive.exprName.getText())] : [];
+    });
+}
+function namesOf(analysis, type) {
+    const t = type ? unparen(type) : undefined;
+    if (!t || !ts.isTupleTypeNode(t))
+        return [];
+    return t.elements.map((element) => {
+        const e = unparen(element);
+        if (!ts.isTypeQueryNode(e))
+            return { name: collapse(e.getText()) };
+        const target = declarationOf(resolveSymbol(analysis.checker, analysis.checker.getSymbolAtLocation(e.exprName)));
+        const file = target && isProjectNode(analysis, target) ? relativeFileOf(analysis, target) : undefined;
+        const localName = target && "name" in target && target.name && ts.isIdentifier(target.name)
+            ? target.name.text
+            : undefined;
+        return {
+            name: collapse(e.exprName.getText()),
+            ...(file ? { file } : {}),
+            ...(file && localName ? { localName } : {})
+        };
+    });
+}
+/** Property types by name; a setter's parameter type wins over the getter's, as it is what an input accepts. */
+function membersOf(node) {
+    const out = new Map();
+    for (const member of node.members) {
+        if (!member.name || !(ts.isIdentifier(member.name) || ts.isStringLiteralLike(member.name)))
+            continue;
+        const name = member.name.text;
+        if (ts.isSetAccessorDeclaration(member))
+            out.set(name, {
+                node: member,
+                ...(member.parameters[0]?.type ? { type: member.parameters[0].type } : {})
+            });
+        else if (ts.isPropertyDeclaration(member) || ts.isGetAccessorDeclaration(member)) {
+            if (!out.has(name) || !ts.isSetAccessorDeclaration(out.get(name)?.node))
+                out.set(name, { node: member, ...(member.type ? { type: member.type } : {}) });
+        }
+    }
+    return out;
+}
+function docOf(analysis, member) {
+    const symbol = member?.name ? analysis.checker.getSymbolAtLocation(member.name) : undefined;
+    if (!symbol)
+        return {};
+    const doc = ts.displayPartsToString(symbol.getDocumentationComment(analysis.checker)).trim();
+    const tag = symbol.getJsDocTags(analysis.checker).find((t) => t.name === "deprecated");
+    const reason = tag ? ts.displayPartsToString(tag.text).trim() : "";
+    return {
+        ...(doc ? { description: doc } : {}),
+        ...(tag ? { deprecated: reason ? { reason } : {} } : {})
+    };
+}
+function inputOf(analysis, members, property, spec, cls) {
+    const member = members.get(property);
+    const ref = member?.type ? typeReferenceInfo(member.type) : undefined;
+    const signalKind = ref ? SIGNAL_INPUTS[ref.name] : undefined;
+    const kind = signalKind ?? (spec.isSignal ? "signal-input" : "input");
+    // `InputSignal<T>` and `ModelSignal<T>` wrap the value type; `InputSignalWithTransform<T, W>` also names what is written.
+    const valueType = signalKind ? ref?.typeArguments[0] : member?.type;
+    const info = valueType
+        ? typeInfoOf(analysis, valueType)
+        : { text: "unknown", kind: "unknown", allowedValues: undefined };
+    const accepted = cls.members.find((m) => ts.isPropertyDeclaration(m) &&
+        ts.isIdentifier(m.name) &&
+        m.name.text === `ngAcceptInputType_${property}`)?.type;
+    const writeType = ref?.typeArguments[1] ?? accepted;
+    return {
+        name: spec.alias,
+        property,
+        kind,
+        typeText: info.text,
+        typeKind: info.kind,
+        required: spec.required,
+        ...(info.allowedValues ? { allowedValues: info.allowedValues } : {}),
+        ...(spec.alias !== property ? { alias: spec.alias } : {}),
+        ...(writeType ? { writeType: collapse(writeType.getText()) } : {}),
+        ...docOf(analysis, member?.node),
+        node: member?.node ?? cls
+    };
+}
+function outputOf(analysis, members, inputs, property, alias, cls) {
+    const member = members.get(property);
+    const ref = member?.type ? typeReferenceInfo(member.type) : undefined;
+    const payload = ref?.typeArguments[0] ? collapse(ref.typeArguments[0].getText()) : undefined;
+    // A `model()` declares an input and a `<name>Change` output with no class member of its own.
+    const model = member ? undefined : inputs.find((i) => i.kind === "model" && `${i.name}Change` === alias);
+    const { description } = docOf(analysis, member?.node);
+    return {
+        name: alias,
+        property,
+        kind: model ? "model" : ref?.name === "OutputEmitterRef" ? "signal-output" : "output",
+        ...(model ? { payloadText: model.typeText } : payload ? { payloadText: payload } : {}),
+        ...(alias !== property ? { alias } : {}),
+        ...(description ? { description } : {}),
+        node: member?.node ?? model?.node ?? cls
+    };
+}
+//# sourceMappingURL=declared.js.map

package/dist/compiler-angular/emit.js

@@ -0,0 +1,183 @@
+import { ComponentFacts, excerpt, variantsFromProps } from "../compiler-core/index.js";
+export const CAPABILITIES = [
+    "name",
+    "implementations.*",
+    "props.*",
+    "events.*",
+    "slots.*",
+    "variants.*",
+    "accessibility.*",
+    "styling.*",
+    "composition.*",
+    "module.*"
+];
+/** Writes one component or directive with the neutral fact paths shared with the other framework adapters. */
+export function emitComponent(builder, c, pkg) {
+    const { meta } = c;
+    const ref = builder.entity(c.ref, "component", meta.name);
+    const facts = new ComponentFacts(builder, ref, "angular");
+    const atNode = (node, method = "ast") => builder.evidence({
+        sourceRef: `${meta.file}#${meta.name}`,
+        location: {
+            type: "file",
+            path: node.getSourceFile().fileName.replace(/^\//, ""),
+            line: node.getSourceFile().getLineAndCharacterOfPosition(node.getStart()).line + 1
+        },
+        method,
+        original: excerpt(node)
+    });
+    const atLine = (file, line, original) => builder.evidence({
+        sourceRef: `${file}#${meta.name}`,
+        location: { type: "file", path: file, line },
+        method: "ast",
+        ...(original ? { original } : {})
+    });
+    const decl = atNode(meta.node);
+    facts.put("name", meta.name, decl);
+    facts.link(meta.file, meta.name, decl);
+    if (pkg.name)
+        facts.put("implementations.angular.packageName", pkg.name, decl);
+    const primary = [...c.exports].sort((a, b) => (a.subpath === "." ? 0 : 1) - (b.subpath === "." ? 0 : 1) || (a.name < b.name ? -1 : 1))[0];
+    if (primary) {
+        facts.put("implementations.angular.exportName", primary.name, decl);
+        if (pkg.name)
+            facts.put("implementations.angular.importPath", primary.subpath === "." ? pkg.name : `${pkg.name}/${primary.subpath.replace(/^\.\//, "")}`, decl);
+    }
+    facts.ext("kind", meta.kind, decl);
+    facts.ext("exports", c.exports, decl);
+    facts.ext("propsComplete", c.propsComplete, decl);
+    if (meta.selector)
+        facts.ext("selector", meta.selector, decl);
+    // `standalone` is recorded only when it is written: its default depends on the Angular version.
+    if (meta.standalone !== undefined)
+        facts.ext("standalone", meta.standalone, decl);
+    if (meta.imports.length > 0)
+        facts.ext("imports", meta.imports, decl);
+    if (meta.exportAs)
+        facts.ext("exportAs", meta.exportAs, decl);
+    if (meta.changeDetection)
+        facts.ext("changeDetection", meta.changeDetection, decl);
+    if (meta.encapsulation)
+        facts.ext("encapsulation", meta.encapsulation, decl);
+    if (meta.hostDirectives.length > 0)
+        facts.ext("hostDirectives", meta.hostDirectives, decl);
+    if (meta.inheritsFrom.length > 0)
+        facts.ext("inheritedPropsFrom", [...new Set(meta.inheritsFrom)].sort(), decl);
+    if (c.template)
+        facts.ext("templateSource", c.template.source === "inline" ? "inline" : c.template.file, decl);
+    if (c.modules.declaredIn.length > 0)
+        facts.ext("declaredIn", c.modules.declaredIn, decl);
+    if (c.modules.exportedBy.length > 0)
+        facts.ext("exportedBy", c.modules.exportedBy, decl);
+    if (meta.queries.length > 0)
+        facts.ext("queries", meta.queries, decl);
+    const hostListeners = [
+        ...meta.hostListeners,
+        ...Object.keys(meta.host)
+            .filter((k) => /^\(.+\)$/.test(k))
+            .map((k) => k.slice(1, -1))
+    ].sort();
+    const hostBindings = [
+        ...meta.hostBindings,
+        ...Object.keys(meta.host)
+            .filter((k) => /^\[.+\]$/.test(k))
+            .map((k) => k.slice(1, -1))
+    ].sort();
+    if (hostListeners.length > 0)
+        facts.ext("host.listeners", hostListeners, decl);
+    if (hostBindings.length > 0)
+        facts.ext("host.bindings", hostBindings, decl);
+    const specs = c.inputs.map((p) => ({
+        name: p.name,
+        typeText: p.typeText,
+        kind: p.typeKind,
+        required: p.required,
+        ...(p.default !== undefined ? { default: p.default } : {}),
+        ...(p.defaultExpression !== undefined ? { defaultExpression: p.defaultExpression } : {}),
+        ...(p.allowedValues ? { allowedValues: p.allowedValues } : {}),
+        ...(p.description ? { description: p.description } : {}),
+        ...(p.deprecated ? { deprecated: p.deprecated } : {}),
+        extensions: {
+            kind: p.kind,
+            property: p.property,
+            ...(p.alias ? { alias: p.alias } : {}),
+            ...(p.transform ? { transform: p.transform } : {}),
+            ...(p.writeType ? { writeType: p.writeType } : {}),
+            ...(p.typeInferred ? { typeInferred: true } : {}),
+            ...(p.inheritedFrom ? { inheritedFrom: p.inheritedFrom } : {})
+        }
+    }));
+    for (const [i, p] of c.inputs.entries()) {
+        facts.prop(specs[i], atNode(p.node, p.kind === "input" ? "compiler-api" : "ast"));
+    }
+    for (const o of c.outputs) {
+        facts.event({
+            name: o.name,
+            ...(o.payloadText ? { payloadText: o.payloadText } : {}),
+            ...(o.description ? { description: o.description } : {}),
+            extensions: {
+                kind: o.kind,
+                property: o.property,
+                ...(o.alias ? { alias: o.alias } : {}),
+                ...(o.inheritedFrom ? { inheritedFrom: o.inheritedFrom } : {})
+            }
+        }, atNode(o.node));
+    }
+    if (c.template) {
+        for (const s of c.template.info.slots) {
+            facts.slot({
+                name: s.name,
+                extensions: { source: "ng-content", ...(s.select !== undefined ? { select: s.select } : {}) }
+            }, atLine(c.template.file, s.line));
+        }
+    }
+    for (const s of meta.projection ?? []) {
+        facts.slot({
+            name: s.name,
+            extensions: { source: "ng-content", ...(s.select !== undefined ? { select: s.select } : {}) }
+        }, decl);
+    }
+    for (const v of variantsFromProps(specs)) {
+        const input = c.inputs.find((p) => p.name === v.name);
+        facts.variant({ ...v, extensions: { source: "prop-union" } }, input ? atNode(input.node) : decl);
+    }
+    if (c.template && (c.accessibility.roles.length > 0 || c.accessibility.attributes.length > 0)) {
+        facts.accessibility({
+            ...(c.accessibility.roles.length === 1 ? { role: c.accessibility.roles[0] } : {}),
+            attributes: c.accessibility.attributes
+        }, atLine(c.template.file, c.template.line));
+    }
+    const s = c.styling;
+    if (s.files.length > 0)
+        facts.put("styling.cssFiles", s.files, decl);
+    if (s.variables.length > 0) {
+        facts.put("styling.cssVariables", s.variables.map((v) => v.name), s.variables.map((v) => builder.evidence({
+            sourceRef: `${v.file}#${v.name}`,
+            location: { type: "file", path: v.file, line: v.line },
+            method: "structured-parse",
+            original: `var(${v.name})`
+        })));
+    }
+    if (s.preprocessors.length > 0)
+        facts.put("styling.preprocessors", s.preprocessors, decl);
+    if (c.renders.length > 0)
+        facts.put("composition.renders", c.renders, c.template ? atLine(c.template.file, c.template.line) : decl);
+}
+/** An NgModule: what it declares, imports and exports. Names are kept as written. */
+export function emitModule(builder, m) {
+    const ref = builder.entity(m.ref, "module", m.meta.name);
+    const evidence = builder.evidence({
+        sourceRef: `${m.meta.file}#${m.meta.name}`,
+        location: { type: "file", path: m.meta.file, line: m.meta.line },
+        method: "ast",
+        original: excerpt(m.meta.node)
+    });
+    const put = (path, value) => builder.fact(ref, path, value, evidence, { origin: "extracted" });
+    put("module.name", m.meta.name);
+    put("module.file", m.meta.file);
+    put("module.public", m.public);
+    put("module.declarations", m.meta.declarations);
+    put("module.imports", m.meta.imports);
+    put("module.exports", m.meta.exports);
+}
+//# sourceMappingURL=emit.js.map

package/dist/compiler-angular/index.js

@@ -0,0 +1,4 @@
+export { ADAPTER_ID, ADAPTER_VERSION, angularAdapter } from "./adapter.js";
+export { readClass } from "./classes.js";
+export { matchesSelector, parseSelector, scanTemplate, slotName } from "./template.js";
+//# sourceMappingURL=index.js.map

package/dist/compiler-angular/template.js

@@ -0,0 +1,142 @@
+/**
+ * Tolerant scanner for Angular templates: finds element start tags with their attributes, and the
+ * `<ng-content>` projection slots. It respects quoted attribute values, skips comments and `{{ }}`
+ * interpolations, and ignores control-flow blocks (`@if`, `@for`) because they are not tags. It does
+ * not build a DOM and does not evaluate expressions.
+ */
+export function scanTemplate(text, firstLine) {
+    const elements = [];
+    let i = 0;
+    let line = firstLine;
+    const advance = (to) => {
+        for (; i < to; i++)
+            if (text[i] === "\n")
+                line++;
+    };
+    while (i < text.length) {
+        const c = text[i];
+        if (c === "{" && text[i + 1] === "{") {
+            const end = text.indexOf("}}", i + 2);
+            advance(end < 0 ? text.length : end + 2);
+        }
+        else if (c === "@" && CONTROL_FLOW.test(text.slice(i, i + 24))) {
+            // `@if (a<b) {`: the condition is an expression, not markup, so skip its balanced parentheses.
+            advance(skipParentheses(text, text.indexOf("(", i)));
+        }
+        else if (c === "<" && text.startsWith("<!--", i)) {
+            const end = text.indexOf("-->", i + 4);
+            advance(end < 0 ? text.length : end + 3);
+        }
+        else if (c === "<" && /[A-Za-z]/.test(text[i + 1] ?? "")) {
+            const start = line;
+            const tag = /^[A-Za-z][\w:.-]*/.exec(text.slice(i + 1))?.[0] ?? "";
+            let j = i + 1 + tag.length;
+            const attributes = [];
+            while (j < text.length && text[j] !== ">") {
+                if (/\s|\//.test(text[j])) {
+                    j++;
+                    continue;
+                }
+                const name = /^[^\s=/>]+/.exec(text.slice(j))?.[0] ?? "";
+                j += name.length;
+                let value;
+                if (text[j] === "=") {
+                    j++;
+                    const quote = text[j];
+                    if (quote === '"' || quote === "'") {
+                        const end = text.indexOf(quote, j + 1);
+                        value = text.slice(j + 1, end < 0 ? text.length : end);
+                        j = end < 0 ? text.length : end + 1;
+                    }
+                    else {
+                        const unquoted = /^[^\s>]+/.exec(text.slice(j))?.[0] ?? "";
+                        value = unquoted;
+                        j += unquoted.length;
+                    }
+                }
+                if (name)
+                    attributes.push({ ...normalize(name), ...(value !== undefined ? { value } : {}) });
+            }
+            elements.push({ tag, line: start, attributes });
+            advance(Math.min(j + 1, text.length));
+        }
+        else
+            advance(i + 1);
+    }
+    return { elements, slots: slotsOf(elements) };
+}
+const CONTROL_FLOW = /^@(?:else\s+if|if|for|switch|case|defer)\s*\(/;
+/** Index just past the parenthesis that closes the one at `open`, honoring quotes. */
+function skipParentheses(text, open) {
+    let depth = 0;
+    for (let i = open; i < text.length; i++) {
+        const c = text[i];
+        if (c === '"' || c === "'" || c === "`") {
+            const end = text.indexOf(c, i + 1);
+            if (end < 0)
+                return text.length;
+            i = end;
+        }
+        else if (c === "(")
+            depth++;
+        else if (c === ")" && --depth === 0)
+            return i + 1;
+    }
+    return text.length;
+}
+function normalize(raw) {
+    const wrapped = /^\[\(?(.+?)\)?\]$/.exec(raw) ?? /^\((.+)\)$/.exec(raw);
+    if (wrapped)
+        return { name: wrapped[1].replace(/^attr\./, ""), bound: true };
+    if (raw.startsWith("*"))
+        return { name: raw.slice(1), bound: true };
+    const prefixed = /^(?:bind|on|bindon)-(.+)$/.exec(raw);
+    if (prefixed)
+        return { name: prefixed[1], bound: true };
+    return { name: raw, bound: false };
+}
+function slotsOf(elements) {
+    const used = new Set();
+    const out = [];
+    for (const e of elements) {
+        if (e.tag !== "ng-content")
+            continue;
+        const select = e.attributes.find((a) => a.name === "select" && !a.bound)?.value;
+        let name = select === undefined ? "default" : slotName(select);
+        for (let n = 2; used.has(name); n++)
+            name = `${slotName(select ?? "default")}_${n}`;
+        used.add(name);
+        out.push({ name, ...(select !== undefined ? { select } : {}), line: e.line });
+    }
+    return out;
+}
+/** `[slot=icon]` and `icon` and `[icon]` and `.icon` all name the slot `icon`; anything else is sanitized. */
+export function slotName(select) {
+    const trimmed = select.trim();
+    const attrValue = /^\[[\w-]*slot[\w-]*=["']?([\w-]+)["']?\]$/.exec(trimmed);
+    if (attrValue)
+        return attrValue[1];
+    const simple = /^(?:\[([\w-]+)\]|\.([\w-]+)|([A-Za-z][\w-]*))$/.exec(trimmed);
+    if (simple)
+        return (simple[1] ?? simple[2] ?? simple[3]);
+    return trimmed.replace(/[^A-Za-z0-9_-]+/g, "_").replace(/^_+|_+$/g, "") || "slot";
+}
+/** Element and attribute parts of a component selector. Class, `:not()` and complex selectors are ignored. */
+export function parseSelector(selector) {
+    const out = [];
+    for (const alternative of selector.split(",")) {
+        const text = alternative.trim();
+        if (!text || text.includes(":not(") || text.includes(" ") || text.includes(">"))
+            continue;
+        const element = /^[A-Za-z][\w-]*/.exec(text)?.[0];
+        const attributes = [...text.matchAll(/\[([\w-]+)(?:=[^\]]*)?\]/g)].map((m) => m[1]);
+        if (element || attributes.length > 0)
+            out.push({ ...(element ? { element } : {}), attributes });
+    }
+    return out;
+}
+export function matchesSelector(element, selectors) {
+    const names = new Set(element.attributes.map((a) => a.name));
+    return selectors.some((s) => (s.element === undefined || s.element === element.tag) && s.attributes.every((a) => names.has(a)));
+}
+//# sourceMappingURL=template.js.map

package/dist/compiler-core/adapter.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=adapter.js.map