ifc-expressions 2.3.0 → 3.0.0-beta.2

package/dist/mjs/autocomplete/IfcExpressionAutocomplete.js

@@ -0,0 +1,650 @@
+import { CharStream, CommonTokenStream, ParserRuleContext, Token, } from "antlr4ng";
+import { CodeCompletionCore, } from "antlr4-c3";
+import { BuiltinVariableRegistry, } from "../builtin/BuiltinVariableRegistry.js";
+import { IfcExpressionLexer } from "../gen/parser/IfcExpressionLexer.js";
+import { IfcExpressionParser, MethodCallChainEndContext, MethodCallChainInnerContext, MethodFunctionCallContext, MethodPropertyAccessContext, SEMethodCallContext, SEParenthesisContext, SEVariableRefContext, } from "../gen/parser/IfcExpressionParser.js";
+import { IfcExpressionFunctions } from "../expression/function/IfcExpressionFunctions.js";
+import { ContextObjectType } from "../type/ContextObjectType.js";
+import { resolveLocalizedText, } from "../documentation/Documentation.js";
+function isIdentifierChar(char) {
+    return typeof char === "string" && /[a-zA-Z0-9_\-$&]/.test(char);
+}
+function toBuiltinLabel(name) {
+    return name.startsWith("$") ? name : `$${name}`;
+}
+function normalizeForMatch(value) {
+    return value.toUpperCase();
+}
+function toCompletionTypeName(type) {
+    return type.getName().replace(/^\$/, "");
+}
+function isChainableType(type) {
+    return type instanceof ContextObjectType;
+}
+const unsupportedPrimitiveMethodFunctionNames = new Set([
+    "NAME",
+    "GUID",
+    "IFCCLASS",
+    "DESCRIPTION",
+    "VALUE",
+]);
+const preferredMethodLabels = new Map([
+    ["MAP", "map"],
+    ["CHOOSE", "choose"],
+    ["AT", "at"],
+    ["IF", "if"],
+    ["ROUND", "round"],
+    ["NAME", "name"],
+    ["GUID", "guid"],
+    ["IFCCLASS", "ifcClass"],
+    ["DESCRIPTION", "description"],
+    ["VALUE", "value"],
+    ["PROPERTYSET", "propertySet"],
+    ["PROPERTY", "property"],
+    ["TYPE", "type"],
+    ["NOT", "not"],
+    ["TOSTRING", "toString"],
+    ["TONUMERIC", "toNumeric"],
+    ["TONUMBER", "toNumber"],
+    ["TOBOOLEAN", "toBoolean"],
+    ["TOLOGICAL", "toLogical"],
+    ["NOTFOUNDASUNKNOWN", "notFoundAsUnknown"],
+    ["TOIFCDATE", "toIfcDate"],
+    ["TOIFCTIME", "toIfcTime"],
+    ["TOIFCDATETIME", "toIfcDateTime"],
+    ["TOIFCDURATION", "toIfcDuration"],
+    ["TOIFCTIMESTAMP", "toIfcTimeStamp"],
+    ["ADDDURATION", "addDuration"],
+    ["TOLOWERCASE", "toLowerCase"],
+    ["TOUPPERCASE", "toUpperCase"],
+    ["SUBSTRING", "substring"],
+    ["SPLIT", "split"],
+    ["EXISTS", "exists"],
+    ["AND", "and"],
+    ["OR", "or"],
+    ["XOR", "xor"],
+    ["IMPLIES", "implies"],
+    ["EQUALS", "equals"],
+    ["GREATERTHAN", "greaterThan"],
+    ["GREATERTHANOREQUAL", "greaterThanOrEqual"],
+    ["LESSTHAN", "lessThan"],
+    ["LESSTHANOREQUAL", "lessThanOrEqual"],
+    ["CONTAINS", "contains"],
+    ["MATCHES", "matches"],
+    ["REGEXCONTAINS", "regexContains"],
+    ["REGEXMATCHES", "regexMatches"],
+    ["REPLACE", "replace"],
+    ["REGEXREPLACE", "regexReplace"],
+]);
+const emptyExpressionStarterFunctionNames = [
+    "IF",
+    "EXISTS",
+    "ROUND",
+    "CONTAINS",
+    "MATCHES",
+    "REPLACE",
+    "TOSTRING",
+    "TONUMERIC",
+    "TOBOOLEAN",
+];
+function isExtendableTokenType(tokenType) {
+    return tokenType === IfcExpressionParser.IDENTIFIER;
+}
+function findCaretTokenIndex(tokens, cursorOffset) {
+    if (tokens.length === 0) {
+        return 0;
+    }
+    const cursor = Math.max(0, cursorOffset);
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        if (token.type === Token.EOF) {
+            return token.tokenIndex;
+        }
+        if (cursor < token.start) {
+            return token.tokenIndex;
+        }
+        if (cursor <= token.stop) {
+            return token.tokenIndex;
+        }
+        if (cursor === token.stop + 1) {
+            if (isExtendableTokenType(token.type)) {
+                return token.tokenIndex;
+            }
+            const nextToken = tokens[i + 1];
+            return nextToken?.tokenIndex ?? token.tokenIndex;
+        }
+    }
+    return tokens[tokens.length - 1].tokenIndex;
+}
+function parseAutocompleteInput(input, cursorOffset) {
+    const chars = CharStream.fromString(input);
+    const lexer = new IfcExpressionLexer(chars);
+    const tokenStream = new CommonTokenStream(lexer);
+    const parser = new IfcExpressionParser(tokenStream);
+    lexer.removeErrorListeners();
+    parser.removeErrorListeners();
+    const parseTree = parser.expr();
+    tokenStream.fill();
+    const tokens = tokenStream.getTokens();
+    return {
+        parser,
+        parseTree,
+        tokens,
+        caretTokenIndex: findCaretTokenIndex(tokens, cursorOffset),
+    };
+}
+function findBuiltinRootReplaceRange(input, cursorOffset) {
+    const cursor = Math.max(0, Math.min(cursorOffset, input.length));
+    let i = cursor - 1;
+    while (i >= 0 && isIdentifierChar(input[i]) && input[i] !== "$") {
+        i--;
+    }
+    if (i >= 0 && input[i] === "$") {
+        return { from: i, to: cursor };
+    }
+    return undefined;
+}
+function findIdentifierReplaceRange(input, cursorOffset) {
+    const cursor = Math.max(0, Math.min(cursorOffset, input.length));
+    let from = cursor;
+    while (from > 0 && isIdentifierChar(input[from - 1])) {
+        from--;
+    }
+    return {
+        from,
+        to: cursor,
+    };
+}
+function findMemberReplaceRange(input, cursorOffset) {
+    const range = findIdentifierReplaceRange(input, cursorOffset);
+    if (range.from === 0 || input[range.from - 1] !== ".") {
+        return undefined;
+    }
+    return range;
+}
+function findFunctionReplaceRange(input, cursorOffset) {
+    const range = findIdentifierReplaceRange(input, cursorOffset);
+    const prefixChar = range.from > 0 ? input[range.from - 1] : undefined;
+    const hasIdentifierFragment = range.from < range.to || isIdentifierChar(input[Math.max(0, range.to)]);
+    if (!hasIdentifierFragment || prefixChar === "." || prefixChar === "$") {
+        return undefined;
+    }
+    return range;
+}
+function countExprListArguments(exprList) {
+    if (!exprList) {
+        return 0;
+    }
+    const rest = exprList.exprList();
+    return 1 + (rest ? countExprListArguments(rest) : 0);
+}
+function toMethodAccessorStep(methodAccessor) {
+    if (methodAccessor instanceof MethodPropertyAccessContext) {
+        const identifier = methodAccessor.IDENTIFIER()?.getText();
+        if (!identifier) {
+            return undefined;
+        }
+        return {
+            name: identifier,
+            kind: "property",
+            startTokenIndex: methodAccessor.start?.tokenIndex ?? -1,
+        };
+    }
+    if (methodAccessor instanceof MethodFunctionCallContext) {
+        const functionCall = methodAccessor.functionCall();
+        const name = functionCall.IDENTIFIER()?.getText();
+        if (!name) {
+            return undefined;
+        }
+        return {
+            name,
+            kind: "function",
+            argumentCount: countExprListArguments(functionCall.exprList()),
+            startTokenIndex: functionCall.start?.tokenIndex ?? -1,
+        };
+    }
+    return undefined;
+}
+function collectMethodCallChainSteps(methodCallChain) {
+    if (methodCallChain instanceof MethodCallChainInnerContext) {
+        const current = toMethodAccessorStep(methodCallChain.methodAccessor());
+        const rest = collectMethodCallChainSteps(methodCallChain.methodCallChain());
+        if (!current || !rest) {
+            return undefined;
+        }
+        return [current, ...rest];
+    }
+    if (methodCallChain instanceof MethodCallChainEndContext) {
+        const current = toMethodAccessorStep(methodCallChain.methodAccessor());
+        return current ? [current] : undefined;
+    }
+    const dot = methodCallChain.getToken(IfcExpressionParser.DOT, 0);
+    if (dot) {
+        return [
+            {
+                kind: "incomplete",
+                startTokenIndex: dot.symbol.tokenIndex + 1,
+            },
+        ];
+    }
+    return [];
+}
+function getMemberResultType(definition) {
+    return definition.kind === "property"
+        ? definition.valueType
+        : definition.returnType;
+}
+function resolveCompletedAccessorStep(currentType, step) {
+    if (!(currentType instanceof ContextObjectType)) {
+        return undefined;
+    }
+    const memberDefinition = currentType.getMemberDefinition(step.name);
+    if (!memberDefinition) {
+        return undefined;
+    }
+    if (step.kind === "property") {
+        return memberDefinition.kind === "property"
+            ? memberDefinition.valueType
+            : undefined;
+    }
+    if (memberDefinition.kind !== "function") {
+        return undefined;
+    }
+    if (memberDefinition.argumentTypes.length !== step.argumentCount) {
+        return undefined;
+    }
+    return memberDefinition.returnType;
+}
+function resolveSingleExprType(singleExpr, builtinVariableRegistry) {
+    if (singleExpr instanceof SEVariableRefContext) {
+        const identifier = singleExpr.variableRef()?.IDENTIFIER()?.getText();
+        return identifier
+            ? builtinVariableRegistry.getDefinition(`$${identifier}`)?.type
+            : undefined;
+    }
+    if (singleExpr instanceof SEParenthesisContext) {
+        return resolveSingleExprType(singleExpr.singleExpr(), builtinVariableRegistry);
+    }
+    if (singleExpr instanceof SEMethodCallContext) {
+        const baseType = resolveSingleExprType(singleExpr.singleExpr(), builtinVariableRegistry);
+        const steps = collectMethodCallChainSteps(singleExpr.methodCallChain());
+        if (!baseType || !steps) {
+            return undefined;
+        }
+        let currentType = baseType;
+        for (const step of steps) {
+            if (step.kind === "incomplete") {
+                return undefined;
+            }
+            currentType = resolveCompletedAccessorStep(currentType, step);
+            if (!currentType) {
+                return undefined;
+            }
+        }
+        return currentType;
+    }
+    return undefined;
+}
+function findReceiverTypeForMemberSlot(node, startTokenIndex, builtinVariableRegistry) {
+    if (node instanceof SEMethodCallContext) {
+        const steps = collectMethodCallChainSteps(node.methodCallChain());
+        if (steps) {
+            const slotIndex = steps.findIndex((step) => step.startTokenIndex === startTokenIndex);
+            if (slotIndex >= 0) {
+                let currentType = resolveSingleExprType(node.singleExpr(), builtinVariableRegistry);
+                for (const step of steps.slice(0, slotIndex)) {
+                    if (!currentType || step.kind === "incomplete") {
+                        return undefined;
+                    }
+                    currentType = resolveCompletedAccessorStep(currentType, step);
+                }
+                return currentType;
+            }
+        }
+    }
+    for (let i = 0; i < node.getChildCount(); i++) {
+        const child = node.getChild(i);
+        if (child instanceof ParserRuleContext) {
+            const receiverType = findReceiverTypeForMemberSlot(child, startTokenIndex, builtinVariableRegistry);
+            if (receiverType) {
+                return receiverType;
+            }
+        }
+    }
+    return undefined;
+}
+function isEmptyExpressionInput(input) {
+    return input.trim().length === 0;
+}
+function toFunctionInsertText(name) {
+    return `${name}()`;
+}
+function buildSignatureLabel(name, argumentLabels) {
+    return `${name}(${argumentLabels.join(", ")})`;
+}
+function buildFunctionDocumentation(name, localizer, displayName = name) {
+    const func = IfcExpressionFunctions.getFunction(name);
+    const documentation = func?.getDocumentation();
+    if (!func || !documentation) {
+        return undefined;
+    }
+    const fallback = `${func.getSignatureLabel(displayName)}: ${documentation.fallback}`;
+    return localizer ? localizer.t(documentation.key, fallback) : fallback;
+}
+function buildMemberDocumentation(definition, localizer) {
+    if (!definition.documentation) {
+        return undefined;
+    }
+    const fallback = definition.kind === "property"
+        ? `${definition.name}: ${definition.documentation.fallback}`
+        : `${buildSignatureLabel(definition.name, (definition.argumentDocumentation ?? []).map((argument, index) => argument.label.fallback ?? `arg${index}`))}: ${definition.documentation.fallback}`;
+    return localizer
+        ? localizer.t(definition.documentation.key, fallback)
+        : fallback;
+}
+function buildRootDocumentation(name, documentation, localizer) {
+    const key = documentation?.key ?? `builtin.${name}.summary`;
+    const fallback = documentation?.fallback ??
+        `${name}: built-in value from the evaluation context`;
+    return localizer ? localizer.t(key, fallback) : fallback;
+}
+function findActiveCallFrame(tokens, cursorOffset) {
+    const stack = [];
+    let previousSignificantToken;
+    for (const token of tokens) {
+        if (token.type === Token.EOF || token.start >= cursorOffset) {
+            break;
+        }
+        if (token.type === IfcExpressionParser.WS ||
+            token.type === IfcExpressionParser.NEWLINE) {
+            continue;
+        }
+        if (token.type === IfcExpressionParser.T__1) {
+            stack.push(previousSignificantToken?.type === IfcExpressionParser.IDENTIFIER
+                ? {
+                    kind: "function",
+                    name: previousSignificantToken.text ?? undefined,
+                    argumentIndex: 0,
+                    startTokenIndex: previousSignificantToken.tokenIndex,
+                }
+                : { kind: "group", argumentIndex: 0 });
+        }
+        else if (token.type === IfcExpressionParser.T__10) {
+            stack.push({ kind: "array", argumentIndex: 0 });
+        }
+        else if (token.type === IfcExpressionParser.T__2 ||
+            token.type === IfcExpressionParser.T__11) {
+            stack.pop();
+        }
+        else if (token.type === IfcExpressionParser.T__9) {
+            const currentFrame = stack[stack.length - 1];
+            if (currentFrame?.kind === "function") {
+                currentFrame.argumentIndex += 1;
+            }
+        }
+        previousSignificantToken = token;
+    }
+    for (let i = stack.length - 1; i >= 0; i--) {
+        if (stack[i].kind === "function") {
+            return stack[i];
+        }
+    }
+    return undefined;
+}
+function buildMemberSignatureLabel(definition) {
+    return buildSignatureLabel(definition.name, (definition.argumentDocumentation ?? []).map((argument, index) => argument.label.fallback ?? `arg${index}`));
+}
+function buildActiveMemberHelp(parseTree, builtinVariableRegistry, activeFrame, localizer) {
+    if (activeFrame.startTokenIndex === undefined || !activeFrame.name) {
+        return undefined;
+    }
+    const receiverType = findReceiverTypeForMemberSlot(parseTree, activeFrame.startTokenIndex, builtinVariableRegistry);
+    if (!(receiverType instanceof ContextObjectType)) {
+        return undefined;
+    }
+    const memberDefinition = receiverType.getMemberDefinition(activeFrame.name);
+    if (memberDefinition?.kind !== "function" ||
+        !memberDefinition.documentation) {
+        return undefined;
+    }
+    const label = buildMemberSignatureLabel(memberDefinition);
+    const fallback = memberDefinition.documentation.fallback.startsWith(`${label}: `)
+        ? memberDefinition.documentation.fallback
+        : `${label}: ${memberDefinition.documentation.fallback}`;
+    const activeArgument = memberDefinition.argumentDocumentation?.[activeFrame.argumentIndex];
+    return {
+        label,
+        documentation: localizer
+            ? localizer.t(memberDefinition.documentation.key, fallback)
+            : fallback,
+        activeParameterIndex: activeFrame.argumentIndex,
+        activeParameterLabel: activeArgument
+            ? resolveLocalizedText(activeArgument.label, localizer) ??
+                activeArgument.label.fallback
+            : undefined,
+        activeParameterDocumentation: activeArgument
+            ? resolveLocalizedText(activeArgument.documentation, localizer)
+            : undefined,
+    };
+}
+function buildActiveHelp(parseTree, builtinVariableRegistry, tokens, cursorOffset, localizer) {
+    const activeFrame = findActiveCallFrame(tokens, cursorOffset);
+    if (!activeFrame?.name) {
+        return undefined;
+    }
+    const memberHelp = buildActiveMemberHelp(parseTree, builtinVariableRegistry, activeFrame, localizer);
+    if (memberHelp) {
+        return memberHelp;
+    }
+    const func = IfcExpressionFunctions.getFunction(activeFrame.name);
+    const documentation = func?.getDocumentation();
+    if (!func || !documentation) {
+        return undefined;
+    }
+    const activeArgument = func.getFormalArguments()[activeFrame.argumentIndex];
+    const label = func.getSignatureLabel(activeFrame.name);
+    const fallback = `${label}: ${documentation.fallback}`;
+    return {
+        label,
+        documentation: localizer
+            ? localizer.t(documentation.key, fallback)
+            : fallback,
+        activeParameterIndex: activeFrame.argumentIndex,
+        activeParameterLabel: activeArgument
+            ? resolveLocalizedText(activeArgument.displayLabel, localizer) ??
+                activeArgument.displayLabel?.fallback ??
+                activeArgument.name
+            : undefined,
+        activeParameterDocumentation: activeArgument
+            ? resolveLocalizedText(activeArgument.documentation, localizer)
+            : undefined,
+    };
+}
+function toFunctionItem(name, localizer, label = name) {
+    const insertText = toFunctionInsertText(label);
+    return {
+        kind: "builtinFunction",
+        label,
+        insertText,
+        cursorOffset: insertText.length - 1,
+        documentation: buildFunctionDocumentation(name, localizer, label),
+    };
+}
+function getPreferredMethodLabel(name) {
+    return preferredMethodLabels.get(name) ?? name;
+}
+function isApplicablePrimitiveMethodFunction(name, receiverType) {
+    if (unsupportedPrimitiveMethodFunctionNames.has(name)) {
+        return false;
+    }
+    const func = IfcExpressionFunctions.getFunction(name);
+    const firstArgument = func?.getFormalArguments()[0];
+    if (!func || !firstArgument) {
+        return false;
+    }
+    const firstArgumentType = firstArgument.getType();
+    return (firstArgumentType.isAssignableFrom(receiverType) ||
+        firstArgumentType.overlapsWith(receiverType));
+}
+function getPrimitiveMethodItems(receiverType, localizer) {
+    return IfcExpressionFunctions.getBuiltinFunctionNames()
+        .filter((name) => isApplicablePrimitiveMethodFunction(name, receiverType))
+        .map((name) => toFunctionItem(name, localizer, getPreferredMethodLabel(name)));
+}
+function toBuiltinRootItem(name, builtinVariableRegistry, localizer) {
+    const normalizedName = name.startsWith("$") ? name : `${name}`;
+    const definition = builtinVariableRegistry.getDefinition(normalizedName);
+    if (!definition) {
+        return undefined;
+    }
+    return {
+        kind: "builtinRoot",
+        label: toBuiltinLabel(definition.name),
+        documentation: buildRootDocumentation(definition.name, definition.documentation, localizer),
+    };
+}
+function toEmptyExpressionStarterItem(name, builtinVariableRegistry, localizer) {
+    if (name.startsWith("$")) {
+        return toBuiltinRootItem(name, builtinVariableRegistry, localizer);
+    }
+    return IfcExpressionFunctions.getFunction(name)
+        ? toFunctionItem(name, localizer)
+        : undefined;
+}
+function getEmptyExpressionStarterItems(builtinVariableRegistry, localizer, starterNames = [
+    ...builtinVariableRegistry
+        .getDefinitions()
+        .map((definition) => toBuiltinLabel(definition.name)),
+    ...emptyExpressionStarterFunctionNames,
+]) {
+    return starterNames
+        .map((name) => toEmptyExpressionStarterItem(name, builtinVariableRegistry, localizer))
+        .filter((item) => item !== undefined);
+}
+function toMemberItem(definition, localizer) {
+    if (definition.kind === "property") {
+        return {
+            kind: "builtinMemberProperty",
+            label: definition.name,
+            returnTypeName: toCompletionTypeName(definition.valueType),
+            chainable: isChainableType(definition.valueType),
+            documentation: buildMemberDocumentation(definition, localizer),
+        };
+    }
+    const insertText = toFunctionInsertText(definition.name);
+    return {
+        kind: "builtinMemberFunction",
+        label: definition.name,
+        insertText,
+        cursorOffset: insertText.length - 1,
+        argumentTypeNames: definition.argumentTypes.map((type) => type.getName()),
+        returnTypeName: toCompletionTypeName(definition.returnType),
+        chainable: isChainableType(definition.returnType),
+        documentation: buildMemberDocumentation(definition, localizer),
+    };
+}
+function collectRuleCandidates(parser, caretTokenIndex, parseTree) {
+    const completionCore = new CodeCompletionCore(parser);
+    completionCore.preferredRules = new Set([
+        IfcExpressionParser.RULE_variableRef,
+        IfcExpressionParser.RULE_methodAccessor,
+    ]);
+    return completionCore.collectCandidates(caretTokenIndex, parseTree);
+}
+function getMemberRuleCandidate(ruleCandidates) {
+    return ruleCandidates.get(IfcExpressionParser.RULE_methodAccessor);
+}
+function hasBuiltinRootRuleCandidate(ruleCandidates) {
+    return ruleCandidates.has(IfcExpressionParser.RULE_variableRef);
+}
+function hasIdentifierTokenCandidate(tokenCandidates) {
+    return tokenCandidates.has(IfcExpressionParser.IDENTIFIER);
+}
+export class IfcExpressionAutocomplete {
+    static complete(input, cursorOffset, options = {}) {
+        const builtinVariableRegistry = options.builtinVariableRegistry ??
+            BuiltinVariableRegistry.getDefaultRegistry();
+        if (isEmptyExpressionInput(input)) {
+            return {
+                items: getEmptyExpressionStarterItems(builtinVariableRegistry, options.localizer, options.emptyExpressionStarters),
+                replaceFrom: 0,
+                replaceTo: input.length,
+            };
+        }
+        const parsed = parseAutocompleteInput(input, cursorOffset);
+        const candidates = collectRuleCandidates(parsed.parser, parsed.caretTokenIndex, parsed.parseTree);
+        const ruleCandidates = candidates.rules;
+        const activeHelp = buildActiveHelp(parsed.parseTree, builtinVariableRegistry, parsed.tokens, cursorOffset, options.localizer);
+        const memberCandidate = getMemberRuleCandidate(ruleCandidates);
+        if (memberCandidate) {
+            const range = findMemberReplaceRange(input, cursorOffset);
+            if (!range) {
+                return {
+                    items: [],
+                    replaceFrom: cursorOffset,
+                    replaceTo: cursorOffset,
+                    activeHelp,
+                };
+            }
+            const receiverType = findReceiverTypeForMemberSlot(parsed.parseTree, memberCandidate.startTokenIndex, builtinVariableRegistry);
+            const typedPrefix = normalizeForMatch(input.slice(range.from, range.to));
+            const items = (receiverType instanceof ContextObjectType
+                ? receiverType
+                    .getMemberDefinitions()
+                    .map((definition) => toMemberItem(definition, options.localizer))
+                : receiverType
+                    ? getPrimitiveMethodItems(receiverType, options.localizer)
+                    : [])
+                .filter((item) => normalizeForMatch(item.label).startsWith(typedPrefix))
+                .sort((left, right) => left.label.localeCompare(right.label));
+            return {
+                items,
+                replaceFrom: range.from,
+                replaceTo: range.to,
+                activeHelp,
+            };
+        }
+        const functionRange = findFunctionReplaceRange(input, cursorOffset);
+        if (functionRange && hasIdentifierTokenCandidate(candidates.tokens)) {
+            const typedPrefix = normalizeForMatch(input.slice(functionRange.from, functionRange.to));
+            const items = IfcExpressionFunctions.getBuiltinFunctionNames()
+                .map((name) => toFunctionItem(name, options.localizer))
+                .filter((item) => normalizeForMatch(item.label).startsWith(typedPrefix))
+                .sort((left, right) => left.label.localeCompare(right.label));
+            if (items.length > 0) {
+                return {
+                    items,
+                    replaceFrom: functionRange.from,
+                    replaceTo: functionRange.to,
+                    activeHelp,
+                };
+            }
+        }
+        const range = findBuiltinRootReplaceRange(input, cursorOffset);
+        if (!range || !hasBuiltinRootRuleCandidate(ruleCandidates)) {
+            return {
+                items: [],
+                replaceFrom: cursorOffset,
+                replaceTo: cursorOffset,
+                activeHelp,
+            };
+        }
+        const typedPrefix = normalizeForMatch(input.slice(range.from, range.to));
+        const items = builtinVariableRegistry
+            .getDefinitions()
+            .map((definition) => ({
+            kind: "builtinRoot",
+            label: toBuiltinLabel(definition.name),
+            documentation: buildRootDocumentation(definition.name, definition.documentation, options.localizer),
+        }))
+            .filter((item) => normalizeForMatch(item.label).startsWith(typedPrefix))
+            .sort((left, right) => left.label.localeCompare(right.label));
+        return {
+            items,
+            replaceFrom: range.from,
+            replaceTo: range.to,
+            activeHelp,
+        };
+    }
+}
+//# sourceMappingURL=IfcExpressionAutocomplete.js.map