@esportsplus/reactivity 0.37.2 → 0.38.1

package/build/compiler/array.d.ts

@@ -1,5 +1,12 @@
 import { ts } from '@esportsplus/typescript';
 import type { ReplacementIntent } from '@esportsplus/typescript/compiler';
 import type { Bindings, IsReactiveCall } from './types.js';
+import type { Failure } from './primitives.js';
+type ArrayTransformResult = {
+    failures: Failure[];
+    namespaced: boolean;
+    reactive: ts.Expression[];
+    replacements: ReplacementIntent[];
+};
 export default _default;
-declare function _default(sourceFile: ts.SourceFile, bindings: Bindings, isReactiveCall: IsReactiveCall): ReplacementIntent[];
+declare function _default(sourceFile: ts.SourceFile, bindings: Bindings, isReactiveCall: IsReactiveCall): ArrayTransformResult;

package/build/compiler/array.js

@@ -1,6 +1,24 @@
 import { ts } from '@esportsplus/typescript';
-import { COMPOUND_OPERATORS, NAMESPACE, TYPES } from './constants.js';
+import { COMPOUND_OPERATORS, NAMESPACE } from './constants.js';
 import scope from './bindings.js';
+function collect(node, candidates) {
+    if (ts.isTypeNode(node)) {
+        return;
+    }
+    if (ts.isPropertyAccessExpression(node) && node.name.text === 'length') {
+        candidates.lengths.push(node);
+    }
+    else if (ts.isElementAccessExpression(node) && isWritten(node)) {
+        candidates.writes.push(node);
+    }
+    else if (ts.isBinaryExpression(node) &&
+        node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+        ts.isIdentifier(node.left) &&
+        ts.isArrayLiteralExpression(scope.unwrap(node.right))) {
+        candidates.reassignments.push(node);
+    }
+    node.forEachChild(child => collect(child, candidates));
+}
 function declare(ctx, node) {
     if (ctx.isReactiveCall(node) && node.arguments.length > 0) {
         let arg = node.arguments[0], expression = ts.isAsExpression(arg) ? arg.expression : arg;
@@ -12,9 +30,6 @@ function declare(ctx, node) {
             else if (node.parent && ts.isVariableDeclaration(node.parent) && node.parent.type) {
                 elementType = getElementTypeText(node.parent.type, ctx.sourceFile);
             }
-            if (node.parent && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
-                scope.declare(ctx.bindings, node.parent.name, TYPES.Array);
-            }
             let typeParam = elementType ? `<${elementType}>` : '';
             ctx.replacements.push({
                 node,
@@ -24,25 +39,6 @@ function declare(ctx, node) {
             });
         }
     }
-    if (ts.isVariableDeclaration(node) &&
-        ts.isIdentifier(node.name) &&
-        node.initializer &&
-        (ts.isIdentifier(node.initializer) || ts.isPropertyAccessExpression(node.initializer)) &&
-        scope.isArray(ctx.bindings, node.initializer)) {
-        scope.declare(ctx.bindings, node.name, TYPES.Array);
-    }
-    if ((ts.isFunctionDeclaration(node) || ts.isArrowFunction(node)) && node.parameters) {
-        for (let i = 0, n = node.parameters.length; i < n; i++) {
-            let param = node.parameters[i];
-            if (ts.isIdentifier(param.name) &&
-                param.type &&
-                ts.isTypeReferenceNode(param.type) &&
-                ts.isIdentifier(param.type.typeName) &&
-                param.type.typeName.text === 'ReactiveArray') {
-                scope.declare(ctx.bindings, param.name, TYPES.Array);
-            }
-        }
-    }
     node.forEachChild(child => declare(ctx, child));
 }
 function getElementTypeText(typeNode, sourceFile) {
@@ -58,82 +54,104 @@ function getElementTypeText(typeNode, sourceFile) {
     }
     return null;
 }
-function rewrite(ctx, node) {
-    if (ts.isTypeNode(node)) {
-        return;
+function isWritten(access) {
+    let parent = access.parent;
+    if (!parent) {
+        return false;
     }
-    if (ts.isPropertyAccessExpression(node) && node.name.text === 'length' && scope.isArray(ctx.bindings, node.expression)) {
-        let expr = node.expression, parent = node.parent;
-        if (parent && ts.isBinaryExpression(parent) && parent.left === node && (parent.operatorToken.kind === ts.SyntaxKind.EqualsToken || COMPOUND_OPERATORS.has(parent.operatorToken.kind))) {
-            let op = COMPOUND_OPERATORS.get(parent.operatorToken.kind);
-            if (op === undefined) {
-                ctx.replacements.push({
-                    node: parent,
-                    generate: (sf) => `${expr.getText(sf)}.$length = ${parent.right.getText(sf)}`
-                });
-            }
-            else {
-                ctx.replacements.push({
-                    node: parent,
-                    generate: (sf) => `${expr.getText(sf)}.$length = ${expr.getText(sf)}.length ${op} ${parent.right.getText(sf)}`
-                });
-            }
-        }
-        else if (parent && (ts.isPostfixUnaryExpression(parent) || ts.isPrefixUnaryExpression(parent))) {
-            let op = parent.operator === ts.SyntaxKind.PlusPlusToken ? '+' : '-';
-            ctx.replacements.push({
-                node: parent,
-                generate: (sf) => `${expr.getText(sf)}.$length = ${expr.getText(sf)}.length ${op} 1`
-            });
-        }
-        else {
-            ctx.replacements.push({
-                node,
-                generate: (sf) => `${expr.getText(sf)}.$length`
-            });
-        }
+    if (ts.isBinaryExpression(parent)) {
+        let op = parent.operatorToken.kind;
+        return parent.left === access && (op === ts.SyntaxKind.EqualsToken || COMPOUND_OPERATORS.has(op));
     }
-    if (ts.isBinaryExpression(node) &&
-        node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
-        ts.isElementAccessExpression(node.left) &&
-        scope.isArray(ctx.bindings, node.left.expression)) {
-        let element = node.left;
+    if (ts.isPostfixUnaryExpression(parent) || ts.isPrefixUnaryExpression(parent)) {
+        return parent.operator === ts.SyntaxKind.PlusPlusToken || parent.operator === ts.SyntaxKind.MinusMinusToken;
+    }
+    return ts.isDeleteExpression(parent);
+}
+function length(access, replacements) {
+    let expr = access.expression, parent = access.parent;
+    if (parent && ts.isBinaryExpression(parent) && parent.left === access && (parent.operatorToken.kind === ts.SyntaxKind.EqualsToken || COMPOUND_OPERATORS.has(parent.operatorToken.kind))) {
+        let op = COMPOUND_OPERATORS.get(parent.operatorToken.kind);
+        replacements.push({
+            node: parent,
+            generate: (sf) => op === undefined
+                ? `${expr.getText(sf)}.$length = ${parent.right.getText(sf)}`
+                : `${expr.getText(sf)}.$length = ${expr.getText(sf)}.length ${op} ${parent.right.getText(sf)}`
+        });
+    }
+    else if (parent &&
+        (ts.isPostfixUnaryExpression(parent) || ts.isPrefixUnaryExpression(parent)) &&
+        (parent.operator === ts.SyntaxKind.PlusPlusToken || parent.operator === ts.SyntaxKind.MinusMinusToken)) {
+        let op = parent.operator === ts.SyntaxKind.PlusPlusToken ? '+' : '-';
+        replacements.push({
+            node: parent,
+            generate: (sf) => `${expr.getText(sf)}.$length = ${expr.getText(sf)}.length ${op} 1`
+        });
+    }
+    else {
+        replacements.push({
+            node: access,
+            generate: (sf) => `${expr.getText(sf)}.$length`
+        });
+    }
+}
+function write(access, ctx) {
+    let parent = access.parent, array = (sf) => access.expression.getText(sf), index = (sf) => access.argumentExpression.getText(sf);
+    if (ts.isDeleteExpression(parent)) {
+        ctx.failures.push({ message: 'an element of a reactive array cannot be deleted; use splice()', node: parent });
+        return;
+    }
+    if (ts.isBinaryExpression(parent)) {
+        let op = COMPOUND_OPERATORS.get(parent.operatorToken.kind), right = parent.right;
         ctx.replacements.push({
-            node,
-            generate: (sf) => `${element.expression.getText(sf)}.$set(
-                    ${element.argumentExpression.getText(sf)},
-                    ${node.right.getText(sf)}
-                )`
+            node: parent,
+            generate: (sf) => op === undefined
+                ? `${array(sf)}.$set(${index(sf)}, ${right.getText(sf)})`
+                : `((_a, _k) => _a.$set(_k, _a[_k] ${op} (${right.getText(sf)})))(${array(sf)}, ${index(sf)})`
         });
+        return;
     }
-    if (ts.isBinaryExpression(node) &&
-        node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
-        ts.isIdentifier(node.left) &&
-        scope.isArray(ctx.bindings, node.left)) {
-        let name = node.left.text, right = node.right;
-        while (ts.isAsExpression(right) || ts.isTypeAssertion(right)) {
-            right = right.expression;
+    let unary = parent, op = unary.operator === ts.SyntaxKind.PlusPlusToken ? '+' : '-';
+    ctx.replacements.push({
+        node: unary,
+        generate: (sf) => ts.isPrefixUnaryExpression(unary)
+            ? `((_a, _k) => (_a.$set(_k, _a[_k] ${op} 1), _a[_k]))(${array(sf)}, ${index(sf)})`
+            : `((_a, _k, _v) => (_a.$set(_k, _v ${op} 1), _v))(${array(sf)}, ${index(sf)}, ${array(sf)}[${index(sf)}])`
+    });
+}
+export default (sourceFile, bindings, isReactiveCall) => {
+    let candidates = { lengths: [], reassignments: [], writes: [] }, result = { failures: [], namespaced: false, reactive: [], replacements: [] };
+    declare({ isReactiveCall, replacements: result.replacements, sourceFile }, sourceFile);
+    result.namespaced = result.replacements.length > 0;
+    collect(sourceFile, candidates);
+    let reactive = scope.arrays(bindings, [
+        ...candidates.lengths.map(access => access.expression),
+        ...candidates.reassignments.map(assignment => assignment.left),
+        ...candidates.writes.map(access => access.expression)
+    ]);
+    result.reactive = [...reactive];
+    for (let i = 0, n = candidates.lengths.length; i < n; i++) {
+        if (reactive.has(candidates.lengths[i].expression)) {
+            length(candidates.lengths[i], result.replacements);
         }
-        if (ts.isArrayLiteralExpression(right)) {
-            let elements = right;
-            ctx.replacements.push({
-                node,
-                generate: (sf) => elements.elements.length > 0
-                    ? `${name}.splice(0, ${name}.length, ...${elements.getText(sf)})`
-                    : `${name}.splice(0, ${name}.length)`
-            });
+    }
+    for (let i = 0, n = candidates.writes.length; i < n; i++) {
+        if (reactive.has(candidates.writes[i].expression)) {
+            write(candidates.writes[i], result);
         }
     }
-    node.forEachChild(child => rewrite(ctx, child));
-}
-export default (sourceFile, bindings, isReactiveCall) => {
-    let ctx = {
-        bindings,
-        isReactiveCall,
-        replacements: [],
-        sourceFile
-    };
-    declare(ctx, sourceFile);
-    rewrite(ctx, sourceFile);
-    return ctx.replacements;
+    for (let i = 0, n = candidates.reassignments.length; i < n; i++) {
+        let assignment = candidates.reassignments[i];
+        if (!reactive.has(assignment.left) || isReactiveCall(scope.unwrap(assignment.right))) {
+            continue;
+        }
+        let name = assignment.left.text, elements = scope.unwrap(assignment.right);
+        result.replacements.push({
+            node: assignment,
+            generate: (sf) => elements.elements.length > 0
+                ? `${name}.splice(0, ${name}.length, ...${elements.getText(sf)})`
+                : `${name}.splice(0, ${name}.length)`
+        });
+    }
+    return result;
 };

package/build/compiler/bindings.d.ts

@@ -1,19 +1,25 @@
 import { ts } from '@esportsplus/typescript';
+import type { Origin } from '@esportsplus/typescript/compiler';
 import { TYPES } from './constants.js';
 import type { Bindings } from './types.js';
-declare const create: (checker: ts.Checker) => Bindings;
-declare const declare: (bindings: Bindings, identifier: ts.Identifier, type: TYPES) => void;
-declare const declarePath: (bindings: Bindings, identifier: ts.Identifier, path: string) => void;
-declare const isArray: (bindings: Bindings, expression: ts.Expression) => boolean;
-declare const resolve: (bindings: Bindings, identifier: ts.Identifier) => {
-    symbol: ts.Symbol;
-    type: TYPES;
-} | null;
+declare const arrays: (bindings: Bindings, nodes: ts.Node[]) => Set<ts.Node>;
+declare const classify: (bindings: Bindings, call: ts.CallExpression) => TYPES | null;
+declare const create: (checker: ts.Checker, program: ts.Program, sourceFile: ts.SourceFile) => Bindings;
+declare const denotes: (bindings: Bindings, expression: ts.Expression) => boolean;
+declare const holds: (bindings: Bindings, found: Origin | null) => boolean;
+declare const isReactiveCall: (bindings: Bindings, node: ts.Node) => node is ts.CallExpression;
+declare const kind: (bindings: Bindings, found: Origin | null) => TYPES | null;
+declare const origin: (bindings: Bindings, node: ts.Node) => Origin | null;
+declare const unwrap: (expression: ts.Expression) => ts.Expression;
 declare const _default: {
+    arrays: typeof arrays;
+    classify: typeof classify;
     create: typeof create;
-    declare: typeof declare;
-    declarePath: typeof declarePath;
-    isArray: typeof isArray;
-    resolve: typeof resolve;
+    denotes: typeof denotes;
+    holds: typeof holds;
+    isReactiveCall: typeof isReactiveCall;
+    kind: typeof kind;
+    origin: typeof origin;
+    unwrap: typeof unwrap;
 };
 export default _default;

package/build/compiler/bindings.js

@@ -1,65 +1,185 @@
 import { ts } from '@esportsplus/typescript';
-import { TYPES } from './constants.js';
-function root(expression) {
-    let parts = [];
-    while (ts.isPropertyAccessExpression(expression)) {
-        parts.push(expression.name.text);
-        expression = expression.expression;
-    }
-    if (!ts.isIdentifier(expression) || parts.length === 0) {
-        return null;
+import { references } from '@esportsplus/typescript/compiler';
+import { ENTRYPOINT, PACKAGE_NAME, TYPES } from './constants.js';
+const ARRAY_BRAND = 'once';
+const REACTIVE_ARRAY = 'ReactiveArray';
+let caches = new WeakMap();
+function assignments(bindings, file) {
+    let cache = cachesOf(bindings.program).assignments, found = cache.get(file.fileName);
+    if (found) {
+        return found;
     }
-    return { path: parts.reverse().join('.'), root: expression };
+    let result = new Map(), visit = (node) => {
+        if (ts.isBinaryExpression(node) &&
+            node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+            ts.isIdentifier(node.left)) {
+            let call = unwrap(node.right);
+            if (ts.isCallExpression(call)) {
+                let list = result.get(node.left.text);
+                if (!list) {
+                    list = [];
+                    result.set(node.left.text, list);
+                }
+                list.push({ call, target: node.left });
+            }
+        }
+        node.forEachChild(visit);
+    };
+    visit(file);
+    cache.set(file.fileName, result);
+    return result;
 }
-function symbolOf(bindings, identifier) {
-    let parent = identifier.parent;
-    if (parent && ts.isShorthandPropertyAssignment(parent) && parent.name === identifier) {
-        return bindings.checker.getShorthandAssignmentValueSymbol(parent);
+function cachesOf(program) {
+    let found = caches.get(program);
+    if (!found) {
+        found = { arrays: new Map(), assignments: new Map(), kinds: new Map() };
+        caches.set(program, found);
     }
-    return bindings.checker.getSymbolAtLocation(identifier);
+    return found;
 }
-const create = (checker) => ({
-    checker,
-    names: new Set(),
-    paths: new Map(),
-    symbols: new Map()
-});
-const declare = (bindings, identifier, type) => {
-    let symbol = bindings.checker.getSymbolAtLocation(identifier);
-    if (symbol) {
-        bindings.names.add(identifier.text);
-        bindings.symbols.set(symbol, type);
+function kindOf(checker, type) {
+    let members = (type.flags & ts.TypeFlags.Union) !== 0 ? type.getTypes() : [type], result = null;
+    for (let i = 0, n = members.length; i < n; i++) {
+        let kind = kindOfType(checker, members[i]);
+        if (kind === null || (result !== null && result !== kind)) {
+            return null;
+        }
+        result = kind;
     }
+    return result;
+}
+function kindOfType(checker, type) {
+    if ((type.flags & ts.TypeFlags.TypeParameter) !== 0) {
+        let constraint = checker.getBaseConstraintOfType(type);
+        return constraint && constraint !== type ? kindOf(checker, constraint) : null;
+    }
+    if ((type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Never | ts.TypeFlags.Unknown)) !== 0) {
+        return null;
+    }
+    if ((type.flags & (ts.TypeFlags.BigIntLike |
+        ts.TypeFlags.BooleanLike |
+        ts.TypeFlags.EnumLike |
+        ts.TypeFlags.ESSymbolLike |
+        ts.TypeFlags.Null |
+        ts.TypeFlags.NumberLike |
+        ts.TypeFlags.StringLike |
+        ts.TypeFlags.TemplateLiteral |
+        ts.TypeFlags.Undefined |
+        ts.TypeFlags.Void)) !== 0) {
+        return TYPES.Signal;
+    }
+    if (checker.isArrayType(type) || checker.isTupleType(type)) {
+        return TYPES.Array;
+    }
+    if (checker.getSignaturesOfType(type, ts.SignatureKind.Call).length > 0) {
+        return TYPES.Computed;
+    }
+    return (type.flags & (ts.TypeFlags.Intersection | ts.TypeFlags.NonPrimitive | ts.TypeFlags.Object)) !== 0 ? TYPES.Object : null;
+}
+const arrays = (bindings, nodes) => {
+    let result = new Set();
+    if (nodes.length === 0) {
+        return result;
+    }
+    let files = new Set(references.exported(bindings.checker, bindings.program, PACKAGE_NAME, REACTIVE_ARRAY).map(declaration => declaration.path));
+    if (files.size === 0) {
+        return result;
+    }
+    let cache = cachesOf(bindings.program).arrays, types = bindings.checker.getTypeAtLocation(nodes);
+    for (let i = 0, n = nodes.length; i < n; i++) {
+        let type = types[i];
+        if (!type) {
+            continue;
+        }
+        let branded = cache.get(type.id);
+        if (branded === undefined) {
+            let property = bindings.checker.getPropertyOfType(bindings.checker.getNonNullableType(type) ?? type, ARRAY_BRAND);
+            branded = property?.declarations?.some(declaration => files.has(declaration.path)) === true;
+            cache.set(type.id, branded);
+        }
+        if (branded) {
+            result.add(nodes[i]);
+        }
+    }
+    return result;
 };
-const declarePath = (bindings, identifier, path) => {
-    let symbol = bindings.checker.getSymbolAtLocation(identifier);
-    if (!symbol) {
-        return;
-    }
-    let paths = bindings.paths.get(symbol);
-    if (!paths) {
-        paths = new Set();
-        bindings.paths.set(symbol, paths);
-    }
-    bindings.names.add(identifier.text);
-    paths.add(path);
-};
-const isArray = (bindings, expression) => {
-    if (ts.isIdentifier(expression)) {
-        return resolve(bindings, expression)?.type === TYPES.Array;
+const classify = (bindings, call) => {
+    let arg = call.arguments[0];
+    if (!arg || call.arguments.length !== 1 || ts.isSpreadElement(arg)) {
+        return null;
+    }
+    let value = unwrap(arg);
+    if (ts.isArrowFunction(value) || ts.isFunctionExpression(value)) {
+        return TYPES.Computed;
     }
-    let access = root(expression);
-    if (!access || !bindings.names.has(access.root.text)) {
-        return false;
+    if (ts.isArrayLiteralExpression(value)) {
+        return TYPES.Array;
     }
-    let symbol = symbolOf(bindings, access.root);
-    return symbol !== undefined && bindings.paths.get(symbol)?.has(access.path) === true;
+    if (ts.isObjectLiteralExpression(value)) {
+        return TYPES.Object;
+    }
+    let type = bindings.checker.getTypeAtLocation(arg);
+    return type ? kindOf(bindings.checker, type) : null;
+};
+const create = (checker, program, sourceFile) => ({
+    checker,
+    entries: new Set(references.exported(checker, program, PACKAGE_NAME, ENTRYPOINT).map(references.key)),
+    origins: references.origins(checker, program, sourceFile),
+    program,
+    sourceFile
+});
+const denotes = (bindings, expression) => {
+    return references.denotes(bindings.checker, bindings.program, expression, bindings.entries);
+};
+const holds = (bindings, found) => {
+    return references.holds(bindings.checker, bindings.program, found, bindings.entries);
+};
+const isReactiveCall = (bindings, node) => {
+    return ts.isCallExpression(node) && denotes(bindings, node.expression);
 };
-const resolve = (bindings, identifier) => {
-    if (!bindings.names.has(identifier.text)) {
+const kind = (bindings, found) => {
+    if (!found) {
         return null;
     }
-    let symbol = symbolOf(bindings, identifier), type = symbol && bindings.symbols.get(symbol);
-    return symbol && type !== undefined ? { symbol, type } : null;
+    let declaration = found.declaration;
+    if ((declaration.kind !== ts.SyntaxKind.VariableDeclaration && declaration.kind !== ts.SyntaxKind.ExportAssignment) ||
+        declaration.path.endsWith('.d.ts')) {
+        return null;
+    }
+    let cache = cachesOf(bindings.program).kinds, key = references.key(declaration), known = cache.get(key);
+    if (known !== undefined) {
+        return known;
+    }
+    cache.set(key, null);
+    let node = declaration.resolve(), result = null;
+    if (node && ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
+        let initializer = node.initializer && unwrap(node.initializer);
+        if (initializer && isReactiveCall(bindings, initializer)) {
+            result = classify(bindings, initializer);
+        }
+        else {
+            let candidates = assignments(bindings, node.getSourceFile()).get(node.name.text) ?? [];
+            for (let i = 0, n = candidates.length; i < n && result === null; i++) {
+                let { call, target } = candidates[i], assigned = origin(bindings, target);
+                if (assigned && references.key(assigned.declaration) === key && isReactiveCall(bindings, call)) {
+                    result = classify(bindings, call);
+                }
+            }
+        }
+    }
+    else if (node && ts.isExportAssignment(node)) {
+        let expression = unwrap(node.expression);
+        if (isReactiveCall(bindings, expression)) {
+            result = classify(bindings, expression);
+        }
+    }
+    cache.set(key, result);
+    return result;
+};
+const origin = (bindings, node) => {
+    return bindings.origins.get(node) ?? references.origin(bindings.checker, bindings.program, node);
+};
+const unwrap = (expression) => {
+    return references.unwrap(expression);
 };
-export default { create, declare, declarePath, isArray, resolve };
+export default { arrays, classify, create, denotes, holds, isReactiveCall, kind, origin, unwrap };

package/build/compiler/constants.d.ts

@@ -5,6 +5,7 @@ declare const NAMESPACE: string;
 declare const TYPES: {
     readonly Array: 0;
     readonly Computed: 1;
+    readonly Object: 3;
     readonly Signal: 2;
 };
 type TYPES = typeof TYPES[keyof typeof TYPES];

package/build/compiler/constants.js

@@ -22,6 +22,7 @@ const NAMESPACE = uid('reactivity');
 const TYPES = {
     Array: 0,
     Computed: 1,
+    Object: 3,
     Signal: 2
 };
 export { COMPOUND_OPERATORS, ENTRYPOINT, NAMESPACE, TYPES };

package/build/compiler/index.d.ts

@@ -1,6 +1,14 @@
-import type { TransformContext } from '@esportsplus/typescript/compiler';
+import type { ImportIntent, ReplacementIntent, TransformContext } from '@esportsplus/typescript/compiler';
 declare const _default: {
-    patterns: string[];
-    transform: (ctx: TransformContext) => {};
+    transform: (ctx: TransformContext) => {
+        dependencies: string[];
+    } | {
+        dependencies?: undefined;
+    } | {
+        imports: ImportIntent[];
+        prepend: string[];
+        replacements: ReplacementIntent[];
+        dependencies: string[];
+    };
 };
 export default _default;