@rs-x/compiler 2.0.0-next.0

package/dist/index.js

@@ -0,0 +1,2272 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// lib/compiler/expression-aot-generator.ts
+import { CompiledExpressionCompiler, JsExpressionAstParser } from "@rs-x/expression-parser";
+
+// lib/compiler/expression-site-detector.ts
+import ts from "typescript";
+function detectExpressionSites(program) {
+  const checker = program.getTypeChecker();
+  const detections = [];
+  for (const sourceFile of program.getSourceFiles()) {
+    if (sourceFile.isDeclarationFile) {
+      continue;
+    }
+    detections.push(...detectExpressionSitesInSourceFile(sourceFile, checker));
+  }
+  return detections;
+}
+__name(detectExpressionSites, "detectExpressionSites");
+function detectExpressionSitesInSourceFile(sourceFile, checker) {
+  const detections = [];
+  const visit = /* @__PURE__ */ __name((node) => {
+    if (ts.isCallExpression(node)) {
+      const rsxDetection = tryDetectRsxEntryPoint(node, checker);
+      if (rsxDetection) {
+        detections.push(rsxDetection);
+      }
+      const factoryDetection = tryDetectFactoryEntryPoint(node, checker);
+      if (factoryDetection) {
+        detections.push(factoryDetection);
+      }
+    }
+    ts.forEachChild(node, visit);
+  }, "visit");
+  visit(sourceFile);
+  return detections;
+}
+__name(detectExpressionSitesInSourceFile, "detectExpressionSitesInSourceFile");
+function tryDetectRsxEntryPoint(callExpression, checker) {
+  if (!ts.isCallExpression(callExpression.expression)) {
+    return null;
+  }
+  const rsxInvocation = callExpression.expression;
+  if (rsxInvocation.arguments.length < 1 || rsxInvocation.arguments.length > 2) {
+    return null;
+  }
+  const expressionLiteral = resolveStaticExpressionLiteral(rsxInvocation.arguments[0]);
+  if (!expressionLiteral) {
+    return null;
+  }
+  if (!isRsxCallee(rsxInvocation.expression, checker)) {
+    return null;
+  }
+  const rsxOptions = resolveRsxOptions(rsxInvocation.arguments[1]);
+  return {
+    kind: "rsx",
+    expression: expressionLiteral.text,
+    preparse: rsxOptions.preparse,
+    lazy: rsxOptions.lazy,
+    compiled: rsxOptions.compiled,
+    expressionLiteral,
+    callExpression,
+    sourceFile: callExpression.getSourceFile()
+  };
+}
+__name(tryDetectRsxEntryPoint, "tryDetectRsxEntryPoint");
+function isRsxCallee(expression, checker) {
+  const symbol = checker.getSymbolAtLocation(expression);
+  if (!symbol) {
+    return false;
+  }
+  if (isAliasImportedFromExpressionParser(symbol, checker)) {
+    return true;
+  }
+  const resolvedSymbol = symbol.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+  if (resolvedSymbol.getName() !== "rsx") {
+    return false;
+  }
+  const declarations = resolvedSymbol.declarations ?? [];
+  return declarations.some((declaration) => {
+    const sourcePath = declaration.getSourceFile().fileName.replace(/\\/gu, "/");
+    return sourcePath.includes("/rs-x-expression-parser/") || sourcePath.includes("/@rs-x/expression-parser/");
+  });
+}
+__name(isRsxCallee, "isRsxCallee");
+function isAliasImportedFromExpressionParser(symbol, checker, seenSymbols = /* @__PURE__ */ new Set()) {
+  if (seenSymbols.has(symbol)) {
+    return false;
+  }
+  seenSymbols.add(symbol);
+  if ((symbol.flags & ts.SymbolFlags.Alias) === 0) {
+    const declarations2 = symbol.declarations ?? [];
+    for (const declaration of declarations2) {
+      if (!ts.isVariableDeclaration(declaration) || !declaration.initializer) {
+        continue;
+      }
+      const initializerSymbol = checker.getSymbolAtLocation(declaration.initializer);
+      if (initializerSymbol && isAliasImportedFromExpressionParser(initializerSymbol, checker, seenSymbols)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  const declarations = symbol.declarations ?? [];
+  return declarations.some((declaration) => {
+    if (!ts.isImportSpecifier(declaration)) {
+      return false;
+    }
+    let current = declaration;
+    while (current && !ts.isImportDeclaration(current)) {
+      current = current.parent;
+    }
+    if (!current) {
+      return false;
+    }
+    const moduleSpecifier = current.moduleSpecifier;
+    if (!ts.isStringLiteral(moduleSpecifier)) {
+      return false;
+    }
+    return moduleSpecifier.text === "@rs-x/expression-parser";
+  });
+}
+__name(isAliasImportedFromExpressionParser, "isAliasImportedFromExpressionParser");
+function tryDetectFactoryEntryPoint(callExpression, checker) {
+  if (!ts.isPropertyAccessExpression(callExpression.expression)) {
+    return null;
+  }
+  if (callExpression.expression.name.text !== "create") {
+    return null;
+  }
+  if (callExpression.arguments.length < 2) {
+    return null;
+  }
+  const expressionLiteral = resolveStaticExpressionLiteral(callExpression.arguments[1]);
+  if (!expressionLiteral) {
+    return null;
+  }
+  const factoryType = checker.getTypeAtLocation(callExpression.expression.expression);
+  if (!isExpressionFactoryType(factoryType, checker, /* @__PURE__ */ new Set())) {
+    return null;
+  }
+  return {
+    kind: "factory-create",
+    expression: expressionLiteral.text,
+    preparse: true,
+    lazy: false,
+    compiled: true,
+    expressionLiteral,
+    callExpression,
+    sourceFile: callExpression.getSourceFile()
+  };
+}
+__name(tryDetectFactoryEntryPoint, "tryDetectFactoryEntryPoint");
+function resolveRsxOptions(optionArgument) {
+  let preparse = true;
+  let lazy = false;
+  let compiled = true;
+  if (!optionArgument || !ts.isObjectLiteralExpression(optionArgument)) {
+    return {
+      preparse,
+      lazy,
+      compiled
+    };
+  }
+  for (let i = 0; i < optionArgument.properties.length; i += 1) {
+    const property = optionArgument.properties[i];
+    if (!ts.isPropertyAssignment(property)) {
+      continue;
+    }
+    if (isPropertyName(property.name, "preparse")) {
+      if (property.initializer.kind === ts.SyntaxKind.FalseKeyword) {
+        preparse = false;
+      }
+      if (property.initializer.kind === ts.SyntaxKind.TrueKeyword) {
+        preparse = true;
+      }
+      continue;
+    }
+    if (isPropertyName(property.name, "lazy")) {
+      if (property.initializer.kind === ts.SyntaxKind.TrueKeyword) {
+        lazy = true;
+      }
+      if (property.initializer.kind === ts.SyntaxKind.FalseKeyword) {
+        lazy = false;
+      }
+      continue;
+    }
+    if (isPropertyName(property.name, "compiled")) {
+      if (property.initializer.kind === ts.SyntaxKind.TrueKeyword) {
+        compiled = true;
+      }
+      if (property.initializer.kind === ts.SyntaxKind.FalseKeyword) {
+        compiled = false;
+      }
+    }
+  }
+  return {
+    preparse,
+    lazy,
+    compiled
+  };
+}
+__name(resolveRsxOptions, "resolveRsxOptions");
+function isPropertyName(propertyName, expectedName) {
+  if (ts.isIdentifier(propertyName)) {
+    return propertyName.text === expectedName;
+  }
+  if (ts.isStringLiteral(propertyName)) {
+    return propertyName.text === expectedName;
+  }
+  return false;
+}
+__name(isPropertyName, "isPropertyName");
+function resolveStaticExpressionLiteral(node) {
+  if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+    return node;
+  }
+  return null;
+}
+__name(resolveStaticExpressionLiteral, "resolveStaticExpressionLiteral");
+function isExpressionFactoryType(type, checker, seenTypes) {
+  if (seenTypes.has(type)) {
+    return false;
+  }
+  seenTypes.add(type);
+  const symbolName = type.getSymbol()?.getName();
+  if (symbolName === "IExpressionFactory") {
+    return true;
+  }
+  if (type.isUnionOrIntersection()) {
+    return type.types.some((unionType) => isExpressionFactoryType(unionType, checker, seenTypes));
+  }
+  if (isExpressionFactoryByCreateSignature(type, checker)) {
+    return true;
+  }
+  const baseTypes = getBaseTypes(type);
+  return baseTypes.some((baseType) => isExpressionFactoryType(baseType, checker, seenTypes));
+}
+__name(isExpressionFactoryType, "isExpressionFactoryType");
+function getBaseTypes(type) {
+  if (!("getBaseTypes" in type)) {
+    return [];
+  }
+  const baseTypes = type.getBaseTypes?.();
+  return baseTypes ?? [];
+}
+__name(getBaseTypes, "getBaseTypes");
+function isExpressionFactoryByCreateSignature(type, checker) {
+  const createProperty = type.getProperty("create");
+  if (!createProperty) {
+    return false;
+  }
+  const declaration = createProperty.valueDeclaration ?? createProperty.declarations?.[0];
+  if (!declaration) {
+    return false;
+  }
+  const createType = checker.getTypeOfSymbolAtLocation(createProperty, declaration);
+  const signatures = createType.getCallSignatures();
+  if (signatures.length === 0) {
+    return false;
+  }
+  return signatures.some((signature) => {
+    const secondParameter = signature.parameters[1];
+    if (!secondParameter) {
+      return false;
+    }
+    const parameterDeclaration = secondParameter.valueDeclaration ?? secondParameter.declarations?.[0];
+    if (!parameterDeclaration) {
+      return false;
+    }
+    const secondParameterType = checker.getTypeOfSymbolAtLocation(secondParameter, parameterDeclaration);
+    const secondParameterIsString = (secondParameterType.flags & ts.TypeFlags.StringLike) !== 0;
+    if (!secondParameterIsString) {
+      return false;
+    }
+    const returnType = signature.getReturnType();
+    return isExpressionLikeReturnType(returnType);
+  });
+}
+__name(isExpressionFactoryByCreateSignature, "isExpressionFactoryByCreateSignature");
+function isExpressionLikeReturnType(type) {
+  const hasExpressionString = Boolean(type.getProperty("expressionString"));
+  const hasType = Boolean(type.getProperty("type"));
+  return hasExpressionString && hasType;
+}
+__name(isExpressionLikeReturnType, "isExpressionLikeReturnType");
+
+// lib/compiler/expression-aot-generator.ts
+function generateAotCompiledExpressionsModule(program, options = {}) {
+  const includeResolvedEvaluator = options.includeResolvedEvaluator === true;
+  const detections = detectExpressionSites(program);
+  const uniqueExpressions = [
+    ...new Set(detections.filter((detection) => detection.preparse && !detection.lazy && detection.compiled).map((detection) => detection.expression))
+  ];
+  uniqueExpressions.sort();
+  const compiler = new CompiledExpressionCompiler(new JsExpressionAstParser());
+  const compiledPlans = [];
+  const skippedExpressions = [];
+  for (let i = 0; i < uniqueExpressions.length; i++) {
+    const expression = uniqueExpressions[i];
+    const plan = compiler.tryCompile(expression);
+    if (!plan) {
+      skippedExpressions.push(expression);
+      continue;
+    }
+    compiledPlans.push({
+      expression,
+      plan
+    });
+  }
+  const compactEntries = compiledPlans.map(({ plan }) => serializeCompactPlanEntry(plan, {
+    includeResolvedEvaluator
+  })).join(",\n");
+  const code = [
+    "import { registerCompiledExpressionPlansInExpressionCache } from '@rs-x/expression-parser';",
+    "",
+    "const compactPlans = [",
+    compactEntries,
+    "];",
+    "",
+    "function deserializeMemberChain(memberChain) {",
+    "  if (!memberChain) return undefined;",
+    "  const segments = new Array(memberChain[1].length);",
+    "  for (let i = 0; i < memberChain[1].length; i += 1) {",
+    "    const segment = memberChain[1][i];",
+    '    if (segment[0] === "s") {',
+    '      segments[i] = { kind: "static", key: segment[1] };',
+    "      continue;",
+    "    }",
+    "    segments[i] = {",
+    '      kind: "computed",',
+    "      key: undefined,",
+    "      expressionString: segment[1],",
+    "      dependencyNames: segment[2],",
+    "      evaluateIndex: segment[3],",
+    "      evaluateIndexByOwnDependencies: segment[4],",
+    "    };",
+    "  }",
+    "  return { rootIdentifier: memberChain[0], segments };",
+    "}",
+    "",
+    "function deserializeSequenceOperands(sequenceOperands) {",
+    "  if (!sequenceOperands) return undefined;",
+    "  const operands = new Array(sequenceOperands.length);",
+    "  for (let i = 0; i < sequenceOperands.length; i += 1) {",
+    "    const operand = sequenceOperands[i];",
+    "    operands[i] = {",
+    "      expressionString: operand[0],",
+    "      dependencyNames: operand[1],",
+    "      evaluate: operand[2],",
+    "    };",
+    "  }",
+    "  return operands;",
+    "}",
+    "",
+    "function expandCompiledPlans(compact, includeResolvedEvaluator) {",
+    "  const expanded = {};",
+    "  for (let i = 0; i < compact.length; i += 1) {",
+    "    const entry = compact[i];",
+    "    const expressionString = entry[0];",
+    "    const watchDependenciesCompact = entry[2];",
+    "    const watchDependencies = new Array(watchDependenciesCompact.length);",
+    "    for (let j = 0; j < watchDependenciesCompact.length; j += 1) {",
+    "      const watchDependency = watchDependenciesCompact[j];",
+    "      watchDependencies[j] = {",
+    "        name: watchDependency[0],",
+    "        ownerPath: watchDependency[1],",
+    "        isLeaf: watchDependency[2],",
+    "        isMemberExpressionSegment: watchDependency[3],",
+    "      };",
+    "    }",
+    "    const expandedPlan = {",
+    "      expressionString,",
+    "      dependencyNames: entry[1],",
+    "      watchDependencies,",
+    "      expressionType: entry[3],",
+    "      hasHiddenArgumentArray: entry[4],",
+    "      memberChain: deserializeMemberChain(entry[5]),",
+    "      sequenceOperands: deserializeSequenceOperands(entry[6]),",
+    "      evaluate: entry[7],",
+    "    };",
+    "    if (includeResolvedEvaluator && entry[8]) {",
+    "      expandedPlan.evaluateResolvedDependencies = entry[8];",
+    "    }",
+    "    expanded[expressionString] = expandedPlan;",
+    "  }",
+    "  return expanded;",
+    "}",
+    "",
+    "export function registerRsxAotCompiledExpressions(): void {",
+    `  registerCompiledExpressionPlansInExpressionCache(expandCompiledPlans(compactPlans, ${String(includeResolvedEvaluator)}));`,
+    "}",
+    ""
+  ].join("\n");
+  return {
+    code,
+    expressions: compiledPlans.map((item) => item.expression),
+    skippedExpressions
+  };
+}
+__name(generateAotCompiledExpressionsModule, "generateAotCompiledExpressionsModule");
+function generateAotParsedExpressionCacheModule(program) {
+  const detections = detectExpressionSites(program);
+  const uniqueExpressions = [
+    ...new Set(detections.filter((detection) => detection.preparse && !detection.lazy).map((detection) => detection.expression))
+  ];
+  uniqueExpressions.sort();
+  const parser2 = new JsExpressionAstParser();
+  const parsedExpressions = [];
+  const skippedExpressions = [];
+  for (let i = 0; i < uniqueExpressions.length; i++) {
+    const expression = uniqueExpressions[i];
+    try {
+      const expressionAst = parser2.parse(expression);
+      parsedExpressions.push({
+        expression,
+        expressionAst
+      });
+    } catch {
+      skippedExpressions.push(expression);
+    }
+  }
+  const astObject = parsedExpressions.map(({ expression, expressionAst }) => `${JSON.stringify(expression)}: ${JSON.stringify(expressionAst)}`).join(",\n");
+  const code = [
+    "import {",
+    "  registerPreparsedExpressionAsts,",
+    "} from '@rs-x/expression-parser';",
+    "",
+    "const preparsedExpressionAsts: Record<string, unknown> = {",
+    astObject,
+    "};",
+    "",
+    "export function registerRsxAotParsedExpressionCache(): void {",
+    "  registerPreparsedExpressionAsts(preparsedExpressionAsts as any);",
+    "}",
+    ""
+  ].join("\n");
+  return {
+    code,
+    expressions: parsedExpressions.map((item) => item.expression),
+    skippedExpressions
+  };
+}
+__name(generateAotParsedExpressionCacheModule, "generateAotParsedExpressionCacheModule");
+function generateAotLazyExpressionPreloadManifestModule(program) {
+  const detections = detectExpressionSites(program);
+  const uniqueExpressions = [
+    ...new Set(detections.filter((detection) => detection.preparse && detection.lazy).map((detection) => detection.expression))
+  ];
+  uniqueExpressions.sort();
+  const manifestObject = uniqueExpressions.map((expression) => `${JSON.stringify(expression)}: true`).join(",\n");
+  const code = [
+    "import { registerLazyExpressionPreloader } from '@rs-x/expression-parser';",
+    "",
+    `export const rsxAotLazyExpressionManifest: Record<string, true> = {${manifestObject ? `
+${manifestObject}
+` : ""}};`,
+    "",
+    "export function registerRsxAotLazyExpressionPreloaders(",
+    "  loadExpressionByString: (expressionString: string) => void | Promise<void>,",
+    "): void {",
+    "  for (const expressionString of Object.keys(rsxAotLazyExpressionManifest)) {",
+    "    registerLazyExpressionPreloader(expressionString, () =>",
+    "      loadExpressionByString(expressionString),",
+    "    );",
+    "  }",
+    "}",
+    ""
+  ].join("\n");
+  return {
+    code,
+    expressions: uniqueExpressions
+  };
+}
+__name(generateAotLazyExpressionPreloadManifestModule, "generateAotLazyExpressionPreloadManifestModule");
+function serializeCompactPlanEntry(plan, options) {
+  return `[${[
+    JSON.stringify(plan.expressionString),
+    serializeStringArray(plan.dependencyNames),
+    serializeCompactWatchDependencies(plan.watchDependencies),
+    JSON.stringify(plan.expressionType),
+    String(plan.hasHiddenArgumentArray),
+    serializeCompactMemberChain(plan.memberChain),
+    serializeCompactSequenceOperands(plan.sequenceOperands),
+    serializeFunction(plan.evaluate),
+    options.includeResolvedEvaluator && plan.evaluateResolvedDependencies ? serializeFunction(plan.evaluateResolvedDependencies) : "undefined"
+  ].join(",")}]`;
+}
+__name(serializeCompactPlanEntry, "serializeCompactPlanEntry");
+function serializeCompactWatchDependencies(dependencies) {
+  return `[${dependencies.map((dependency) => `[${JSON.stringify(dependency.name)},${serializeStringArray(dependency.ownerPath)},${String(dependency.isLeaf)},${String(dependency.isMemberExpressionSegment)}]`).join(",")}]`;
+}
+__name(serializeCompactWatchDependencies, "serializeCompactWatchDependencies");
+function serializeCompactMemberChain(plan) {
+  if (!plan) {
+    return "null";
+  }
+  return `[${JSON.stringify(plan.rootIdentifier)},[${plan.segments.map((segment) => serializeCompactMemberSegment(segment)).join(",")}]]`;
+}
+__name(serializeCompactMemberChain, "serializeCompactMemberChain");
+function serializeCompactMemberSegment(segment) {
+  if (segment.kind === "static") {
+    return `["s",${JSON.stringify(segment.key)}]`;
+  }
+  return `["c",${JSON.stringify(segment.expressionString)},${serializeStringArray(segment.dependencyNames ?? [])},${segment.evaluateIndex ? serializeFunction(segment.evaluateIndex) : "undefined"},${segment.evaluateIndexByOwnDependencies ? serializeFunction(segment.evaluateIndexByOwnDependencies) : "undefined"}]`;
+}
+__name(serializeCompactMemberSegment, "serializeCompactMemberSegment");
+function serializeCompactSequenceOperands(operands) {
+  if (!operands || operands.length === 0) {
+    return "null";
+  }
+  return `[${operands.map((operand) => `[${JSON.stringify(operand.expressionString)},${serializeStringArray(operand.dependencyNames)},${serializeFunction(operand.evaluate)}]`).join(",")}]`;
+}
+__name(serializeCompactSequenceOperands, "serializeCompactSequenceOperands");
+function serializeStringArray(values) {
+  return `[${values.map((value) => JSON.stringify(value)).join(",")}]`;
+}
+__name(serializeStringArray, "serializeStringArray");
+function serializeFunction(fn) {
+  return `(${fn.toString()})`;
+}
+__name(serializeFunction, "serializeFunction");
+
+// lib/compiler/expression-site-validator.ts
+import ts2 from "typescript";
+import { ExpressionType, GlobalIdentifierOwnerResolver, JsEspreeExpressionParser, JsExpressionAstParser as JsExpressionAstParser3 } from "@rs-x/expression-parser";
+
+// lib/diagnostics/expression-diagnostics.ts
+import { JsExpressionAstParser as JsExpressionAstParser2, JsExpressionParser } from "@rs-x/expression-parser";
+var parser = new JsExpressionParser(new JsExpressionAstParser2());
+var trailingOperators = [
+  "instanceof",
+  ">>>",
+  ">>",
+  "<<",
+  "===",
+  "!==",
+  "==",
+  "!=",
+  ">=",
+  "<=",
+  "&&",
+  "||",
+  "??",
+  "**",
+  "+",
+  "-",
+  "*",
+  "/",
+  "%",
+  "&",
+  "|",
+  "^",
+  ">",
+  "<",
+  "in",
+  "?"
+];
+function parseExpressionDiagnostic(expression) {
+  try {
+    parser.parse(expression);
+    return null;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown parser error";
+    return classifyParserError(expression, message);
+  }
+}
+__name(parseExpressionDiagnostic, "parseExpressionDiagnostic");
+function classifyParserError(expression, parserMessage) {
+  const normalizedExpression = expression.trim();
+  if (isUnsupportedMessage(parserMessage)) {
+    return {
+      category: "unsupported",
+      message: extractUnsupportedMessage(parserMessage)
+    };
+  }
+  const missingOperand = tryCreateMissingOperandMessage(normalizedExpression);
+  if (missingOperand) {
+    return {
+      category: "syntax",
+      message: missingOperand
+    };
+  }
+  const unterminatedLiteral = tryCreateUnterminatedLiteralMessage(normalizedExpression);
+  if (unterminatedLiteral) {
+    return {
+      category: "syntax",
+      message: unterminatedLiteral
+    };
+  }
+  const missingRightOperand = tryCreateMissingRightOperandMessage(normalizedExpression);
+  if (missingRightOperand) {
+    return {
+      category: "syntax",
+      message: missingRightOperand
+    };
+  }
+  const unclosedToken = tryCreateUnclosedTokenMessage(normalizedExpression, parserMessage);
+  if (unclosedToken) {
+    return {
+      category: "syntax",
+      message: unclosedToken
+    };
+  }
+  return {
+    category: "syntax",
+    message: `Syntax error in expression '${normalizedExpression}'.`
+  };
+}
+__name(classifyParserError, "classifyParserError");
+function isUnsupportedMessage(message) {
+  return message.includes("not supported") || message.includes("Unsupported expression type") || message.includes("Unsupported");
+}
+__name(isUnsupportedMessage, "isUnsupportedMessage");
+function sanitizeParserMessage(message) {
+  return message.replace(/^Line \d+:\s*/u, "").trim();
+}
+__name(sanitizeParserMessage, "sanitizeParserMessage");
+function tryCreateMissingRightOperandMessage(normalizedExpression) {
+  for (const operator of trailingOperators) {
+    if (endsWithOperator(normalizedExpression, operator)) {
+      return `Missing right operand for '${normalizedExpression}'.`;
+    }
+  }
+  if (normalizedExpression.endsWith(":")) {
+    return `Missing right operand for '${normalizedExpression}'.`;
+  }
+  return null;
+}
+__name(tryCreateMissingRightOperandMessage, "tryCreateMissingRightOperandMessage");
+function tryCreateMissingOperandMessage(normalizedExpression) {
+  if (normalizedExpression === "!" || normalizedExpression === "~" || normalizedExpression === "+" || normalizedExpression === "-" || normalizedExpression === "typeof" || normalizedExpression === "new") {
+    return `Missing operand for '${normalizedExpression}'.`;
+  }
+  return null;
+}
+__name(tryCreateMissingOperandMessage, "tryCreateMissingOperandMessage");
+function tryCreateUnterminatedLiteralMessage(normalizedExpression) {
+  if (hasUnterminatedQuotedLiteral(normalizedExpression, '"')) {
+    return `Unterminated string literal in '${normalizedExpression}'.`;
+  }
+  if (hasUnterminatedQuotedLiteral(normalizedExpression, "'")) {
+    return `Unterminated string literal in '${normalizedExpression}'.`;
+  }
+  if (normalizedExpression.startsWith("`") && !normalizedExpression.endsWith("`")) {
+    return `Unterminated template literal in '${normalizedExpression}'.`;
+  }
+  if (normalizedExpression.startsWith("/") && normalizedExpression.length > 1 && normalizedExpression.lastIndexOf("/") === 0) {
+    return `Unterminated regular expression literal in '${normalizedExpression}'.`;
+  }
+  return null;
+}
+__name(tryCreateUnterminatedLiteralMessage, "tryCreateUnterminatedLiteralMessage");
+function hasUnterminatedQuotedLiteral(expression, quoteCharacter) {
+  if (!expression.startsWith(quoteCharacter)) {
+    return false;
+  }
+  return countUnescapedCharacter(expression, quoteCharacter) % 2 !== 0;
+}
+__name(hasUnterminatedQuotedLiteral, "hasUnterminatedQuotedLiteral");
+function countUnescapedCharacter(expression, character) {
+  let count = 0;
+  for (let index = 0; index < expression.length; index += 1) {
+    if (expression[index] !== character) {
+      continue;
+    }
+    const previous = expression[index - 1];
+    if (previous !== "\\") {
+      count += 1;
+    }
+  }
+  return count;
+}
+__name(countUnescapedCharacter, "countUnescapedCharacter");
+function tryCreateUnclosedTokenMessage(normalizedExpression, parserMessage) {
+  if (!hasUnclosedTokenSignal(normalizedExpression, parserMessage)) {
+    return null;
+  }
+  return `Unclosed token in '${normalizedExpression}'.`;
+}
+__name(tryCreateUnclosedTokenMessage, "tryCreateUnclosedTokenMessage");
+function hasUnclosedTokenSignal(normalizedExpression, parserMessage) {
+  const message = sanitizeParserMessage(parserMessage).toLowerCase();
+  if (message.includes("unexpected end of input") || message.includes("unterminated")) {
+    return true;
+  }
+  return hasUnbalancedDelimiters(normalizedExpression);
+}
+__name(hasUnclosedTokenSignal, "hasUnclosedTokenSignal");
+function extractUnsupportedMessage(parserMessage) {
+  const sanitizedMessage = sanitizeParserMessage(parserMessage);
+  const unsupportedMatch = sanitizedMessage.match(/([^.]*not supported[^.]*)/iu);
+  if (!unsupportedMatch) {
+    return sanitizedMessage;
+  }
+  return unsupportedMatch[1].trim();
+}
+__name(extractUnsupportedMessage, "extractUnsupportedMessage");
+function endsWithOperator(expression, operator) {
+  if ((operator === "+" || operator === "-") && /(?:\d+(?:\.\d+)?)[eE][+-]$/u.test(expression)) {
+    return false;
+  }
+  const escapedOperator = operator.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+  const operatorPattern = operator === "instanceof" || operator === "in" ? `\\b${escapedOperator}\\s*$` : `${escapedOperator}\\s*$`;
+  return new RegExp(operatorPattern, "u").test(expression);
+}
+__name(endsWithOperator, "endsWithOperator");
+function hasUnbalancedDelimiters(expression) {
+  let roundDepth = 0;
+  let squareDepth = 0;
+  let curlyDepth = 0;
+  for (const character of expression) {
+    if (character === "(") {
+      roundDepth += 1;
+    } else if (character === ")") {
+      roundDepth -= 1;
+    } else if (character === "[") {
+      squareDepth += 1;
+    } else if (character === "]") {
+      squareDepth -= 1;
+    } else if (character === "{") {
+      curlyDepth += 1;
+    } else if (character === "}") {
+      curlyDepth -= 1;
+    }
+  }
+  return roundDepth !== 0 || squareDepth !== 0 || curlyDepth !== 0;
+}
+__name(hasUnbalancedDelimiters, "hasUnbalancedDelimiters");
+
+// lib/compiler/expression-site-validator.ts
+var globalIdentifierOwnerResolver = new GlobalIdentifierOwnerResolver();
+var supportedDateProperties = /* @__PURE__ */ new Set([
+  "year",
+  "utcYear",
+  "month",
+  "utcMonth",
+  "date",
+  "utcDate",
+  "hours",
+  "utcHours",
+  "minutes",
+  "utcMinutes",
+  "seconds",
+  "utcSeconds",
+  "milliseconds",
+  "utcMilliseconds",
+  "time"
+]);
+function validateExpressionSites(program) {
+  const checker = program.getTypeChecker();
+  const parser2 = new JsEspreeExpressionParser(new JsExpressionAstParser3());
+  return detectExpressionSites(program).map((site) => validateExpressionSite(site, checker, parser2));
+}
+__name(validateExpressionSites, "validateExpressionSites");
+function validateExpressionSite(site, checker, parser2 = new JsEspreeExpressionParser(new JsExpressionAstParser3())) {
+  const diagnostics = [];
+  const modelType = resolveModelType(site, checker);
+  if (!modelType) {
+    diagnostics.push({
+      category: "semantic",
+      message: "Could not resolve model type for expression entry point."
+    });
+    return {
+      ...site,
+      diagnostics
+    };
+  }
+  let parsedExpression;
+  try {
+    parsedExpression = parser2.parse(site.expression);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown parser error";
+    diagnostics.push(classifyParserError(site.expression, message));
+    return {
+      ...site,
+      diagnostics
+    };
+  }
+  resolveExpressionType(parsedExpression, modelType, modelType, checker, diagnostics);
+  return {
+    ...site,
+    diagnostics
+  };
+}
+__name(validateExpressionSite, "validateExpressionSite");
+function resolveModelType(site, checker) {
+  const modelArgument = site.callExpression.arguments[0];
+  if (!modelArgument) {
+    return null;
+  }
+  return checker.getTypeAtLocation(modelArgument);
+}
+__name(resolveModelType, "resolveModelType");
+function resolveExpressionType(expression, currentContextType, rootModelType, checker, diagnostics) {
+  switch (expression.type) {
+    case ExpressionType.Identifier:
+      return resolveIdentifierType(expression.expressionString, currentContextType, checker, diagnostics);
+    case ExpressionType.Member:
+      return resolveMemberType(expression, currentContextType, rootModelType, checker, diagnostics);
+    case ExpressionType.Function:
+      return resolveFunctionType(expression, currentContextType, rootModelType, checker, diagnostics);
+    case ExpressionType.Number:
+      return {
+        primitive: "number"
+      };
+    case ExpressionType.String:
+      return {
+        primitive: "string"
+      };
+    case ExpressionType.Boolean:
+      return {
+        primitive: "boolean"
+      };
+    case ExpressionType.BigInt:
+      return {
+        primitive: "bigint"
+      };
+    case ExpressionType.Null:
+      return {
+        primitive: "null"
+      };
+    case ExpressionType.Multiplication:
+      return resolveNumericBinaryType(expression, currentContextType, rootModelType, checker, diagnostics, "*");
+    case ExpressionType.Subtraction:
+      return resolveNumericBinaryType(expression, currentContextType, rootModelType, checker, diagnostics, "-");
+    case ExpressionType.Division:
+      return resolveNumericBinaryType(expression, currentContextType, rootModelType, checker, diagnostics, "/");
+    case ExpressionType.Remainder:
+      return resolveNumericBinaryType(expression, currentContextType, rootModelType, checker, diagnostics, "%");
+    case ExpressionType.Exponentiation:
+      return resolveNumericBinaryType(expression, currentContextType, rootModelType, checker, diagnostics, "**");
+    case ExpressionType.Addition:
+      return resolveAdditionType(expression, currentContextType, rootModelType, checker, diagnostics);
+    case ExpressionType.UnaryPlus:
+    case ExpressionType.UnaryNegation:
+      return resolveNumericUnaryType(expression, currentContextType, rootModelType, checker, diagnostics);
+    default:
+      return resolveNestedExpressionType(expression, currentContextType, rootModelType, checker, diagnostics);
+  }
+}
+__name(resolveExpressionType, "resolveExpressionType");
+function resolveIdentifierType(identifier, contextType, checker, diagnostics) {
+  const normalizedIdentifier = String(identifier);
+  contextType = checker.getNonNullableType(unwrapRsxExpressionType(contextType, checker));
+  if (contextType.flags & (ts2.TypeFlags.Any | ts2.TypeFlags.Unknown)) {
+    return {};
+  }
+  const property = contextType.getProperty(normalizedIdentifier);
+  if (!property) {
+    const mapValueType = resolveMapValueType(contextType, checker);
+    if (mapValueType) {
+      return mapValueType;
+    }
+    if (supportedDateProperties.has(normalizedIdentifier) && isDateLikeType(contextType, checker)) {
+      return {
+        primitive: "number"
+      };
+    }
+    const indexedType = resolveIdentifierAsIndexedAccess(normalizedIdentifier, contextType, checker);
+    if (indexedType) {
+      return indexedType;
+    }
+    if (isAllowedGlobalIdentifier(normalizedIdentifier)) {
+      return {};
+    }
+    diagnostics.push({
+      category: "semantic",
+      message: `Identifier '${normalizedIdentifier}' does not exist on model type.`,
+      token: normalizedIdentifier
+    });
+    return {};
+  }
+  const declaration = property.valueDeclaration ?? property.declarations?.[0];
+  if (!declaration) {
+    return {};
+  }
+  return {
+    tsType: unwrapRsxExpressionType(checker.getTypeOfSymbolAtLocation(property, declaration), checker)
+  };
+}
+__name(resolveIdentifierType, "resolveIdentifierType");
+function resolveIdentifierAsIndexedAccess(identifier, contextType, checker) {
+  const numericIdentifier = Number(identifier);
+  const isCanonicalNumberIdentifier = Number.isInteger(numericIdentifier) && String(numericIdentifier) === identifier;
+  if (isCanonicalNumberIdentifier) {
+    const numberIndexType = contextType.getNumberIndexType();
+    if (numberIndexType) {
+      return {
+        tsType: unwrapRsxExpressionType(numberIndexType, checker)
+      };
+    }
+  }
+  const stringIndexType = contextType.getStringIndexType();
+  if (stringIndexType) {
+    return {
+      tsType: unwrapRsxExpressionType(stringIndexType, checker)
+    };
+  }
+  return null;
+}
+__name(resolveIdentifierAsIndexedAccess, "resolveIdentifierAsIndexedAccess");
+function isAllowedGlobalIdentifier(identifier) {
+  return globalIdentifierOwnerResolver.resolve(identifier) !== null;
+}
+__name(isAllowedGlobalIdentifier, "isAllowedGlobalIdentifier");
+function isDateLikeType(type, checker) {
+  type = unwrapRsxExpressionType(type, checker);
+  if (type.isUnionOrIntersection()) {
+    return type.types.some((memberType) => isDateLikeType(memberType, checker));
+  }
+  return Boolean(type.getProperty("getFullYear") && type.getProperty("setFullYear") && type.getProperty("getTime") && type.getProperty("setTime"));
+}
+__name(isDateLikeType, "isDateLikeType");
+function resolveMapValueType(type, checker) {
+  type = unwrapRsxExpressionType(type, checker);
+  if (type.isUnionOrIntersection()) {
+    for (const memberType of type.types) {
+      const memberMapValueType = resolveMapValueType(memberType, checker);
+      if (memberMapValueType) {
+        return memberMapValueType;
+      }
+    }
+    return null;
+  }
+  const symbolName = (type.aliasSymbol ?? type.getSymbol())?.getName();
+  if (symbolName !== "Map") {
+    return null;
+  }
+  const typeArguments = checker.getTypeArguments(type);
+  if (typeArguments.length < 2) {
+    return {};
+  }
+  return {
+    tsType: unwrapRsxExpressionType(typeArguments[1], checker)
+  };
+}
+__name(resolveMapValueType, "resolveMapValueType");
+function resolveSetValueType(type, checker) {
+  type = unwrapRsxExpressionType(type, checker);
+  if (type.isUnionOrIntersection()) {
+    for (const memberType of type.types) {
+      const memberSetValueType = resolveSetValueType(memberType, checker);
+      if (memberSetValueType) {
+        return memberSetValueType;
+      }
+    }
+    return null;
+  }
+  const symbolName = (type.aliasSymbol ?? type.getSymbol())?.getName();
+  if (symbolName !== "Set") {
+    return null;
+  }
+  const typeArguments = checker.getTypeArguments(type);
+  if (typeArguments.length < 1) {
+    return {};
+  }
+  return {
+    tsType: unwrapRsxExpressionType(typeArguments[0], checker)
+  };
+}
+__name(resolveSetValueType, "resolveSetValueType");
+function resolveMemberType(memberExpression, contextType, rootModelType, checker, diagnostics) {
+  const segments = memberExpression.childExpressions;
+  if (segments.length === 0) {
+    return {};
+  }
+  let currentType = resolveExpressionType(segments[0], contextType, rootModelType, checker, diagnostics);
+  for (let i = 1; i < segments.length; i++) {
+    const segment = segments[i];
+    if (!currentType.tsType) {
+      return {};
+    }
+    const currentTsType = unwrapRsxExpressionType(currentType.tsType, checker);
+    if (segment.type === ExpressionType.Identifier) {
+      currentType = resolveIdentifierType(segment.expressionString, currentTsType, checker, diagnostics);
+      continue;
+    }
+    if (segment.type === ExpressionType.ComputedIndex) {
+      const indexExpression = segment.childExpressions[0];
+      const resolvedIndexType = resolveExpressionType(indexExpression, rootModelType, rootModelType, checker, diagnostics);
+      currentType = resolveIndexedType(currentTsType, resolvedIndexType, checker, diagnostics);
+      continue;
+    }
+    if (segment.type === ExpressionType.Function) {
+      currentType = resolveFunctionTypeFromKnownContext(segment, currentTsType, rootModelType, checker, diagnostics);
+      continue;
+    }
+    currentType = resolveExpressionType(segment, currentTsType, rootModelType, checker, diagnostics);
+  }
+  return currentType;
+}
+__name(resolveMemberType, "resolveMemberType");
+function resolveIndexedType(targetType, indexType, checker, diagnostics) {
+  targetType = unwrapRsxExpressionType(targetType, checker);
+  const mapValueType = resolveMapValueType(targetType, checker);
+  if (mapValueType) {
+    return mapValueType;
+  }
+  const setValueType = resolveSetValueType(targetType, checker);
+  if (setValueType) {
+    return setValueType;
+  }
+  const isNumberIndexType = indexType.primitive === "number" || (indexType.tsType ? tsTypeMatches(indexType.tsType, ts2.TypeFlags.NumberLike, checker) : false);
+  if (isNumberIndexType) {
+    const numberIndexType = targetType.getNumberIndexType();
+    if (!numberIndexType) {
+      diagnostics.push({
+        category: "semantic",
+        message: "Index access with number is not valid for this type."
+      });
+      return {};
+    }
+    return {
+      tsType: numberIndexType
+    };
+  }
+  if (indexType.primitive === "string") {
+    return {};
+  }
+  const stringIndexType = targetType.getStringIndexType();
+  if (!stringIndexType) {
+    diagnostics.push({
+      category: "semantic",
+      message: "Index access is not valid for this type."
+    });
+    return {};
+  }
+  return {
+    tsType: stringIndexType
+  };
+}
+__name(resolveIndexedType, "resolveIndexedType");
+function resolveFunctionType(functionExpression, contextType, rootModelType, checker, diagnostics) {
+  const objectExpression = functionExpression.childExpressions[0];
+  const functionNameExpression = functionExpression.childExpressions[1];
+  const objectType = objectExpression.type === ExpressionType.Null ? {
+    tsType: contextType
+  } : resolveExpressionType(objectExpression, contextType, rootModelType, checker, diagnostics);
+  if (!objectType.tsType) {
+    return {};
+  }
+  return resolveFunctionTypeFromKnownContext(functionExpression, objectType.tsType, rootModelType, checker, diagnostics, functionNameExpression);
+}
+__name(resolveFunctionType, "resolveFunctionType");
+function resolveFunctionTypeFromKnownContext(functionExpression, objectType, rootModelType, checker, diagnostics, functionNameExpression) {
+  objectType = unwrapRsxExpressionType(objectType, checker);
+  if (objectType.flags & (ts2.TypeFlags.Any | ts2.TypeFlags.Unknown)) {
+    return {};
+  }
+  const fnExpression = functionNameExpression ?? functionExpression.childExpressions[1];
+  const argsContainer = functionExpression.childExpressions[2];
+  const argumentExpressions = argsContainer?.childExpressions ?? [];
+  const functionName = fnExpression.expressionString;
+  const functionProperty = objectType.getProperty(functionName);
+  if (!functionProperty) {
+    diagnostics.push({
+      category: "semantic",
+      message: `Function '${functionName}' does not exist on target type.`,
+      token: functionName
+    });
+    return {};
+  }
+  const declaration = functionProperty.valueDeclaration ?? functionProperty.declarations?.[0];
+  if (!declaration) {
+    return {};
+  }
+  const functionType = checker.getTypeOfSymbolAtLocation(functionProperty, declaration);
+  const signatures = functionType.getCallSignatures();
+  if (signatures.length === 0) {
+    diagnostics.push({
+      category: "semantic",
+      message: `'${functionName}' is not callable.`,
+      token: functionName
+    });
+    return {};
+  }
+  const resolvedArguments = argumentExpressions.map((argumentExpression) => resolveExpressionType(argumentExpression, rootModelType, rootModelType, checker, diagnostics));
+  const matchingSignature = signatures.find((signature) => doesArgumentListMatchSignature(resolvedArguments, signature, checker));
+  if (!matchingSignature) {
+    diagnostics.push({
+      category: "semantic",
+      message: `Arguments for '${functionName}' do not match any call signature.`,
+      token: functionName
+    });
+    return {};
+  }
+  return {
+    tsType: matchingSignature.getReturnType()
+  };
+}
+__name(resolveFunctionTypeFromKnownContext, "resolveFunctionTypeFromKnownContext");
+function doesArgumentListMatchSignature(resolvedArguments, signature, checker) {
+  const parameters = signature.getParameters();
+  if (resolvedArguments.length < getRequiredParameterCount(parameters)) {
+    return false;
+  }
+  if (resolvedArguments.length > parameters.length) {
+    return false;
+  }
+  for (let i = 0; i < resolvedArguments.length; i++) {
+    const parameter = parameters[i];
+    if (!parameter) {
+      return false;
+    }
+    const declaration = parameter.valueDeclaration ?? parameter.declarations?.[0];
+    if (!declaration) {
+      return false;
+    }
+    const parameterType = checker.getTypeOfSymbolAtLocation(parameter, declaration);
+    if (!isAssignableToParameter(resolvedArguments[i], parameterType, checker)) {
+      return false;
+    }
+  }
+  return true;
+}
+__name(doesArgumentListMatchSignature, "doesArgumentListMatchSignature");
+function getRequiredParameterCount(parameters) {
+  return parameters.filter((parameter) => {
+    const declaration = parameter.valueDeclaration;
+    return !declaration?.questionToken && !declaration?.initializer;
+  }).length;
+}
+__name(getRequiredParameterCount, "getRequiredParameterCount");
+function isAssignableToParameter(argumentType, parameterType, checker) {
+  if (argumentType.tsType) {
+    return checker.isTypeAssignableTo(unwrapRsxExpressionType(argumentType.tsType, checker), parameterType);
+  }
+  if (!argumentType.primitive) {
+    return false;
+  }
+  return isPrimitiveAssignable(argumentType.primitive, parameterType);
+}
+__name(isAssignableToParameter, "isAssignableToParameter");
+function isPrimitiveAssignable(primitive, parameterType) {
+  if (!primitive) {
+    return false;
+  }
+  if (parameterType.isUnionOrIntersection()) {
+    return parameterType.types.some((type) => isPrimitiveAssignable(primitive, type));
+  }
+  switch (primitive) {
+    case "string":
+      return (parameterType.flags & ts2.TypeFlags.StringLike) !== 0;
+    case "number":
+      return (parameterType.flags & ts2.TypeFlags.NumberLike) !== 0;
+    case "boolean":
+      return (parameterType.flags & ts2.TypeFlags.BooleanLike) !== 0;
+    case "bigint":
+      return (parameterType.flags & ts2.TypeFlags.BigIntLike) !== 0;
+    case "null":
+      return (parameterType.flags & ts2.TypeFlags.Null) !== 0;
+    default:
+      return false;
+  }
+}
+__name(isPrimitiveAssignable, "isPrimitiveAssignable");
+function resolveNumericBinaryType(expression, contextType, rootModelType, checker, diagnostics, operator) {
+  const leftExpression = expression.childExpressions[0];
+  const rightExpression = expression.childExpressions[1];
+  const leftType = resolveExpressionType(leftExpression, contextType, rootModelType, checker, diagnostics);
+  const rightType = resolveExpressionType(rightExpression, contextType, rootModelType, checker, diagnostics);
+  if (!isNumberLike(leftType, checker) || !isNumberLike(rightType, checker)) {
+    const token = pickIncompatibleOperandToken({
+      leftExpression,
+      leftType,
+      rightExpression,
+      rightType,
+      checker
+    });
+    diagnostics.push({
+      category: "semantic",
+      message: `Operator "${operator}" requires both left and right operands to be number-compatible.`,
+      token
+    });
+  }
+  return {
+    primitive: "number"
+  };
+}
+__name(resolveNumericBinaryType, "resolveNumericBinaryType");
+function resolveAdditionType(expression, contextType, rootModelType, checker, diagnostics) {
+  const leftExpression = expression.childExpressions[0];
+  const rightExpression = expression.childExpressions[1];
+  const leftType = resolveExpressionType(leftExpression, contextType, rootModelType, checker, diagnostics);
+  const rightType = resolveExpressionType(rightExpression, contextType, rootModelType, checker, diagnostics);
+  if (isStringLike(leftType, checker) || isStringLike(rightType, checker)) {
+    return {
+      primitive: "string"
+    };
+  }
+  if (isNumberLike(leftType, checker) && isNumberLike(rightType, checker)) {
+    return {
+      primitive: "number"
+    };
+  }
+  if (hasMissingIdentifierDiagnostic(leftExpression, diagnostics) || hasMissingIdentifierDiagnostic(rightExpression, diagnostics)) {
+    return {};
+  }
+  const token = pickIncompatibleOperandToken({
+    leftExpression,
+    leftType,
+    rightExpression,
+    rightType,
+    checker
+  });
+  diagnostics.push({
+    category: "semantic",
+    message: 'Operator "+" requires compatible operands (both number-like or at least one string-like).',
+    token
+  });
+  return {};
+}
+__name(resolveAdditionType, "resolveAdditionType");
+function hasMissingIdentifierDiagnostic(expression, diagnostics) {
+  if (expression.type !== ExpressionType.Identifier) {
+    return false;
+  }
+  const identifier = expression.expressionString;
+  const expectedMessage = `Identifier '${identifier}' does not exist on model type.`;
+  return diagnostics.some((diagnostic) => diagnostic.category === "semantic" && diagnostic.message === expectedMessage);
+}
+__name(hasMissingIdentifierDiagnostic, "hasMissingIdentifierDiagnostic");
+function resolveNumericUnaryType(expression, contextType, rootModelType, checker, diagnostics) {
+  const operandExpression = expression.childExpressions[0];
+  const operandType = resolveExpressionType(operandExpression, contextType, rootModelType, checker, diagnostics);
+  if (!isNumberLike(operandType, checker)) {
+    diagnostics.push({
+      category: "semantic",
+      message: "Unary numeric operator requires a number-compatible operand.",
+      token: operandExpression.type === ExpressionType.Identifier ? operandExpression.expressionString : void 0
+    });
+  }
+  return {
+    primitive: "number"
+  };
+}
+__name(resolveNumericUnaryType, "resolveNumericUnaryType");
+function isNumberLike(type, checker) {
+  if (type.primitive === "number") {
+    return true;
+  }
+  if (!type.tsType) {
+    return false;
+  }
+  const unwrappedType = unwrapRsxExpressionType(type.tsType, checker);
+  if ((unwrappedType.flags & ts2.TypeFlags.Any) !== 0) {
+    return true;
+  }
+  return tsTypeMatches(unwrappedType, ts2.TypeFlags.NumberLike, checker);
+}
+__name(isNumberLike, "isNumberLike");
+function isStringLike(type, checker) {
+  if (type.primitive === "string") {
+    return true;
+  }
+  if (!type.tsType) {
+    return false;
+  }
+  const unwrappedType = unwrapRsxExpressionType(type.tsType, checker);
+  if ((unwrappedType.flags & ts2.TypeFlags.Any) !== 0) {
+    return true;
+  }
+  return tsTypeMatches(unwrappedType, ts2.TypeFlags.StringLike, checker);
+}
+__name(isStringLike, "isStringLike");
+function pickIncompatibleOperandToken(args) {
+  const { leftExpression, leftType, rightExpression, rightType, checker } = args;
+  const leftCompatible = isNumberLike(leftType, checker) || isStringLike(leftType, checker);
+  const rightCompatible = isNumberLike(rightType, checker) || isStringLike(rightType, checker);
+  if (!leftCompatible && leftExpression.type === ExpressionType.Identifier) {
+    return leftExpression.expressionString;
+  }
+  if (!rightCompatible && rightExpression.type === ExpressionType.Identifier) {
+    return rightExpression.expressionString;
+  }
+  return void 0;
+}
+__name(pickIncompatibleOperandToken, "pickIncompatibleOperandToken");
+function resolveNestedExpressionType(expression, currentContextType, rootModelType, checker, diagnostics) {
+  const childExpressions = expression.childExpressions;
+  if (childExpressions.length === 0) {
+    return {};
+  }
+  const resolvedChildren = childExpressions.map((childExpression) => resolveExpressionType(childExpression, currentContextType, rootModelType, checker, diagnostics));
+  if (resolvedChildren.length === 1) {
+    return resolvedChildren[0] ?? {};
+  }
+  return {};
+}
+__name(resolveNestedExpressionType, "resolveNestedExpressionType");
+function tsTypeMatches(type, mask, checker) {
+  type = unwrapRsxExpressionType(type, checker);
+  if ((type.flags & mask) !== 0) {
+    return true;
+  }
+  if (type.isUnionOrIntersection()) {
+    return type.types.some((memberType) => tsTypeMatches(memberType, mask, checker));
+  }
+  return false;
+}
+__name(tsTypeMatches, "tsTypeMatches");
+function unwrapRsxExpressionType(type, checker) {
+  let currentType = type;
+  while (true) {
+    const unwrappedType = tryUnwrapRsxExpressionType(currentType, checker);
+    if (!unwrappedType || unwrappedType === currentType) {
+      break;
+    }
+    currentType = unwrappedType;
+  }
+  return currentType;
+}
+__name(unwrapRsxExpressionType, "unwrapRsxExpressionType");
+function tryUnwrapRsxExpressionType(type, checker) {
+  const symbol = type.aliasSymbol ?? type.getSymbol();
+  const symbolName = symbol?.getName();
+  const typeArguments = checker.getTypeArguments(type);
+  const hasThen = Boolean(type.getProperty("then"));
+  const hasSubscribe = Boolean(type.getProperty("subscribe"));
+  const isKnownExpressionWrapper = symbolName === "IExpression" || symbolName === "Promise" || symbolName === "Observable" || symbolName === "Subject" || symbolName === "BehaviorSubject";
+  const isThenableLike = hasThen;
+  const isObservableLike = hasSubscribe;
+  if (typeArguments.length > 0 && (isKnownExpressionWrapper || isThenableLike || isObservableLike)) {
+    return typeArguments[0];
+  }
+  if (isKnownExpressionWrapper || isObservableLike) {
+    const valueLikeType = tryResolveValuePropertyType(type, checker) ?? tryResolveGetValueReturnType(type, checker);
+    if (valueLikeType) {
+      return valueLikeType;
+    }
+  }
+  const hasExpressionShape = type.getProperty("value") && type.getProperty("expressionString") && type.getProperty("childExpressions") && type.getProperty("changed");
+  if (!hasExpressionShape) {
+    return null;
+  }
+  const valueProperty = type.getProperty("value");
+  const declaration = valueProperty?.valueDeclaration ?? valueProperty?.declarations?.[0];
+  if (!valueProperty || !declaration) {
+    return null;
+  }
+  return checker.getTypeOfSymbolAtLocation(valueProperty, declaration);
+}
+__name(tryUnwrapRsxExpressionType, "tryUnwrapRsxExpressionType");
+function tryResolveValuePropertyType(type, checker) {
+  const valueProperty = type.getProperty("value");
+  const declaration = valueProperty?.valueDeclaration ?? valueProperty?.declarations?.[0];
+  if (!valueProperty || !declaration) {
+    return null;
+  }
+  return checker.getTypeOfSymbolAtLocation(valueProperty, declaration);
+}
+__name(tryResolveValuePropertyType, "tryResolveValuePropertyType");
+function tryResolveGetValueReturnType(type, checker) {
+  const getValueSymbol = type.getProperty("getValue");
+  const declaration = getValueSymbol?.valueDeclaration ?? getValueSymbol?.declarations?.[0];
+  if (!getValueSymbol || !declaration) {
+    return null;
+  }
+  const getValueType = checker.getTypeOfSymbolAtLocation(getValueSymbol, declaration);
+  const signatures = getValueType.getCallSignatures();
+  if (signatures.length === 0) {
+    return null;
+  }
+  return signatures[0].getReturnType();
+}
+__name(tryResolveGetValueReturnType, "tryResolveGetValueReturnType");
+
+// lib/compiler/index.ts
+function createCompilerScaffold() {
+  return {
+    phase: 0,
+    scope: "project-setup",
+    packageName: "@rs-x/compiler"
+  };
+}
+__name(createCompilerScaffold, "createCompilerScaffold");
+
+// lib/diagnostics/index.ts
+function createDiagnosticsScaffold() {
+  return {
+    folder: "diagnostics",
+    categories: [
+      "syntax",
+      "semantic",
+      "unsupported"
+    ]
+  };
+}
+__name(createDiagnosticsScaffold, "createDiagnosticsScaffold");
+
+// lib/language-service/rsx-expression-lexing.ts
+var RSX_KEYWORDS = /* @__PURE__ */ new Set([
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "new",
+  "typeof",
+  "instanceof",
+  "in",
+  "void",
+  "delete",
+  "this"
+]);
+var OPERATOR_HEAD = /* @__PURE__ */ new Set([
+  "+",
+  "-",
+  "*",
+  "/",
+  "%",
+  "=",
+  "!",
+  "<",
+  ">",
+  "&",
+  "|",
+  "^",
+  "~",
+  "?"
+]);
+var OPERATORS = [
+  ">>>",
+  "===",
+  "!==",
+  "<<=",
+  ">>=",
+  "&&",
+  "||",
+  "??",
+  "==",
+  "!=",
+  "<=",
+  ">=",
+  "=>",
+  "<<",
+  ">>",
+  "**",
+  "?.",
+  "+=",
+  "-=",
+  "*=",
+  "/=",
+  "%=",
+  "&=",
+  "|=",
+  "^=",
+  "++",
+  "--"
+];
+var PUNCTUATION = /* @__PURE__ */ new Set([
+  "(",
+  ")",
+  "[",
+  "]",
+  "{",
+  "}",
+  ".",
+  ",",
+  ":",
+  ";"
+]);
+function isWhitespace(char) {
+  return /\s/u.test(char);
+}
+__name(isWhitespace, "isWhitespace");
+function isIdentifierStart(char) {
+  return /[A-Za-z_$]/u.test(char);
+}
+__name(isIdentifierStart, "isIdentifierStart");
+function isIdentifierPart(char) {
+  return /[A-Za-z0-9_$]/u.test(char);
+}
+__name(isIdentifierPart, "isIdentifierPart");
+function consumeIdentifier(text, start) {
+  let end = start + 1;
+  while (end < text.length && isIdentifierPart(text[end])) {
+    end++;
+  }
+  return end;
+}
+__name(consumeIdentifier, "consumeIdentifier");
+function isNumberStart(text, index) {
+  const char = text[index];
+  const next = text[index + 1];
+  if (/\d/u.test(char)) {
+    return true;
+  }
+  return char === "." && /\d/u.test(next);
+}
+__name(isNumberStart, "isNumberStart");
+function consumeNumber(text, start) {
+  let index = start;
+  if (text[index] === "0" && index + 1 < text.length) {
+    const marker = text[index + 1];
+    if (marker === "x" || marker === "X") {
+      index += 2;
+      while (index < text.length && /[0-9A-Fa-f_]/u.test(text[index])) {
+        index++;
+      }
+      return index;
+    }
+    if (marker === "b" || marker === "B") {
+      index += 2;
+      while (index < text.length && /[01_]/u.test(text[index])) {
+        index++;
+      }
+      return index;
+    }
+    if (marker === "o" || marker === "O") {
+      index += 2;
+      while (index < text.length && /[0-7_]/u.test(text[index])) {
+        index++;
+      }
+      return index;
+    }
+  }
+  while (index < text.length && /[0-9_]/u.test(text[index])) {
+    index++;
+  }
+  if (text[index] === ".") {
+    index++;
+    while (index < text.length && /[0-9_]/u.test(text[index])) {
+      index++;
+    }
+  }
+  if (text[index] === "e" || text[index] === "E") {
+    const exponentStart = index;
+    index++;
+    if (text[index] === "+" || text[index] === "-") {
+      index++;
+    }
+    const digitsStart = index;
+    while (index < text.length && /[0-9_]/u.test(text[index])) {
+      index++;
+    }
+    if (digitsStart === index) {
+      return exponentStart;
+    }
+  }
+  if (text[index] === "n") {
+    index++;
+  }
+  return index;
+}
+__name(consumeNumber, "consumeNumber");
+function isQuote(char) {
+  return char === "'" || char === '"' || char === "`";
+}
+__name(isQuote, "isQuote");
+function consumeQuoted(text, start, quote) {
+  let index = start + 1;
+  while (index < text.length) {
+    const char = text[index];
+    if (char === "\\") {
+      index += 2;
+      continue;
+    }
+    index++;
+    if (char === quote) {
+      return index;
+    }
+  }
+  return text.length;
+}
+__name(consumeQuoted, "consumeQuoted");
+function matchOperator(text, index) {
+  for (const op of OPERATORS) {
+    if (text.startsWith(op, index)) {
+      return op;
+    }
+  }
+  return null;
+}
+__name(matchOperator, "matchOperator");
+function tokenizeRsxExpression(text) {
+  const tokens = [];
+  let index = 0;
+  while (index < text.length) {
+    const char = text[index];
+    if (isWhitespace(char)) {
+      index++;
+      continue;
+    }
+    if (isQuote(char)) {
+      const end = consumeQuoted(text, index, char);
+      tokens.push({
+        start: index,
+        end,
+        kind: "string"
+      });
+      index = end;
+      continue;
+    }
+    if (isNumberStart(text, index)) {
+      const end = consumeNumber(text, index);
+      tokens.push({
+        start: index,
+        end,
+        kind: "number"
+      });
+      index = end;
+      continue;
+    }
+    if (isIdentifierStart(char)) {
+      const end = consumeIdentifier(text, index);
+      const value = text.slice(index, end);
+      tokens.push({
+        start: index,
+        end,
+        kind: RSX_KEYWORDS.has(value) ? "keyword" : "identifier"
+      });
+      index = end;
+      continue;
+    }
+    const operator = matchOperator(text, index);
+    if (operator) {
+      tokens.push({
+        start: index,
+        end: index + operator.length,
+        kind: "operator"
+      });
+      index += operator.length;
+      continue;
+    }
+    if (PUNCTUATION.has(char)) {
+      tokens.push({
+        start: index,
+        end: index + 1,
+        kind: "punctuation"
+      });
+      index += 1;
+      continue;
+    }
+    if (OPERATOR_HEAD.has(char)) {
+      tokens.push({
+        start: index,
+        end: index + 1,
+        kind: "operator"
+      });
+      index += 1;
+      continue;
+    }
+    index += 1;
+  }
+  return tokens;
+}
+__name(tokenizeRsxExpression, "tokenizeRsxExpression");
+function consumeUntilMatchingQuote(args) {
+  const { text, start, quote } = args;
+  let index = start;
+  while (index < text.length) {
+    const char = text[index];
+    if (char === "\\") {
+      index += 2;
+      continue;
+    }
+    if (char === quote) {
+      return index;
+    }
+    index++;
+  }
+  return -1;
+}
+__name(consumeUntilMatchingQuote, "consumeUntilMatchingQuote");
+function findRsxExpressionLiteralRanges(sourceText) {
+  const ranges = [];
+  let cursor = 0;
+  while (cursor < sourceText.length) {
+    const rsxCallStart = sourceText.indexOf("rsx", cursor);
+    if (rsxCallStart === -1) {
+      break;
+    }
+    let index = rsxCallStart + 3;
+    while (index < sourceText.length && /\s/u.test(sourceText[index])) {
+      index++;
+    }
+    if (sourceText[index] !== "(") {
+      cursor = rsxCallStart + 3;
+      continue;
+    }
+    index++;
+    while (index < sourceText.length && /\s/u.test(sourceText[index])) {
+      index++;
+    }
+    const quote = sourceText[index];
+    if (quote !== "'" && quote !== '"' && quote !== "`") {
+      cursor = rsxCallStart + 3;
+      continue;
+    }
+    const contentStart = index + 1;
+    const quoteEnd = consumeUntilMatchingQuote({
+      text: sourceText,
+      start: contentStart,
+      quote
+    });
+    if (quoteEnd === -1) {
+      break;
+    }
+    ranges.push({
+      start: contentStart,
+      end: quoteEnd,
+      expression: sourceText.slice(contentStart, quoteEnd)
+    });
+    cursor = quoteEnd + 1;
+  }
+  return ranges;
+}
+__name(findRsxExpressionLiteralRanges, "findRsxExpressionLiteralRanges");
+
+// lib/language-service/rsx-language-service.ts
+import ts3 from "typescript";
+function findRsxExpressionRegionAtPosition(program, fileName, position) {
+  const context = resolveExpressionContext(program, fileName, position);
+  if (!context) {
+    return null;
+  }
+  return {
+    expression: context.expression,
+    start: context.expressionStart,
+    end: context.expressionEnd
+  };
+}
+__name(findRsxExpressionRegionAtPosition, "findRsxExpressionRegionAtPosition");
+function getRsxCompletionsAtPosition(program, fileName, position) {
+  const context = resolveExpressionContext(program, fileName, position);
+  if (!context) {
+    return [];
+  }
+  const expressionOffset = position - context.expressionStart;
+  const prefixSource = context.expression.slice(0, expressionOffset);
+  const constructorPrefix = resolveConstructorCompletionPrefix(prefixSource);
+  if (constructorPrefix !== null) {
+    return resolveConstructorCompletions(context, constructorPrefix);
+  }
+  const completionTarget = resolveCompletionTarget(prefixSource);
+  const targetType = completionTarget.chain.length ? resolveChainType(context.modelType, completionTarget.chain, context.checker) : context.modelType;
+  if (!targetType) {
+    return [];
+  }
+  if (isDateLikeType(targetType, context.checker)) {
+    const names2 = [
+      ...supportedDateProperties
+    ].filter((name) => name.startsWith(completionTarget.prefix)).sort();
+    return names2.map((name) => ({
+      name,
+      kind: "property"
+    }));
+  }
+  const names = targetType.getProperties().map((propertySymbol) => propertySymbol.getName()).filter((name) => name.startsWith(completionTarget.prefix)).filter((name, index, collection) => collection.indexOf(name) === index).sort();
+  return names.map((name) => ({
+    name,
+    kind: isCallableProperty(targetType, name, context.checker) ? "method" : "property"
+  }));
+}
+__name(getRsxCompletionsAtPosition, "getRsxCompletionsAtPosition");
+function getRsxDiagnosticsForFile(program, fileName) {
+  const sourceFile = program.getSourceFile(fileName);
+  if (!sourceFile) {
+    return [];
+  }
+  const checker = program.getTypeChecker();
+  const sites = detectExpressionSitesInSourceFile(sourceFile, checker);
+  return sites.flatMap((site) => {
+    const result = validateExpressionSite(site, checker);
+    const literalStart = site.expressionLiteral.getStart(sourceFile) + 1;
+    const literalEnd = site.expressionLiteral.getEnd() - 1;
+    const expressionText = site.expression;
+    return result.diagnostics.map((diagnostic) => {
+      const tokenRange = resolveDiagnosticTokenRangeInExpression({
+        expression: expressionText,
+        token: diagnostic.token
+      });
+      const start = tokenRange === null ? literalStart : literalStart + tokenRange.start;
+      const end = tokenRange === null ? literalEnd : literalStart + tokenRange.end;
+      return {
+        category: diagnostic.category,
+        message: diagnostic.message,
+        start,
+        end
+      };
+    });
+  });
+}
+__name(getRsxDiagnosticsForFile, "getRsxDiagnosticsForFile");
+function resolveDiagnosticTokenRangeInExpression(args) {
+  const { expression, token } = args;
+  if (!token) {
+    return null;
+  }
+  const escapedToken = token.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+  const pattern = new RegExp(`\\b${escapedToken}\\b`, "u");
+  const match = pattern.exec(expression);
+  if (!match || typeof match.index !== "number") {
+    return null;
+  }
+  return {
+    start: match.index,
+    end: match.index + token.length
+  };
+}
+__name(resolveDiagnosticTokenRangeInExpression, "resolveDiagnosticTokenRangeInExpression");
+function getRsxHoverAtPosition(program, fileName, position) {
+  const context = resolveExpressionContext(program, fileName, position);
+  if (!context) {
+    return null;
+  }
+  const expressionOffset = position - context.expressionStart;
+  const tokenRange = resolveIdentifierTokenRange(context.expression, expressionOffset);
+  if (!tokenRange) {
+    return null;
+  }
+  const textToTokenEnd = context.expression.slice(0, tokenRange.end);
+  const chain = resolveChainFromSuffix(textToTokenEnd);
+  if (!chain.length) {
+    return null;
+  }
+  const resolvedType = resolveChainType(context.modelType, chain, context.checker);
+  if (!resolvedType) {
+    return null;
+  }
+  return {
+    text: context.checker.typeToString(resolvedType),
+    start: context.expressionStart + tokenRange.start,
+    end: context.expressionStart + tokenRange.end
+  };
+}
+__name(getRsxHoverAtPosition, "getRsxHoverAtPosition");
+function getRsxSignatureHelpAtPosition(program, fileName, position) {
+  const context = resolveExpressionContext(program, fileName, position);
+  if (!context) {
+    return null;
+  }
+  const expressionOffset = position - context.expressionStart;
+  const prefixSource = context.expression.slice(0, expressionOffset);
+  const activeCall = resolveActiveCallContext(prefixSource);
+  if (!activeCall) {
+    return null;
+  }
+  const callableType = resolveCallableType(context.modelType, activeCall.chain, context.sourceFile, context.checker, activeCall.isConstructorCall);
+  if (!callableType) {
+    return null;
+  }
+  const signatures = activeCall.isConstructorCall ? callableType.getConstructSignatures() : callableType.getCallSignatures();
+  if (signatures.length === 0) {
+    return null;
+  }
+  const items = signatures.map((signature) => {
+    const parameters = signature.getParameters().map((parameter) => {
+      const declaration = parameter.valueDeclaration ?? parameter.declarations?.[0];
+      const typeText = declaration ? context.checker.typeToString(context.checker.getTypeOfSymbolAtLocation(parameter, declaration)) : "unknown";
+      const declarations = parameter.declarations ?? [];
+      const isOptionalByDeclaration = declarations.some((node) => ts3.isParameter(node) && (Boolean(node.questionToken) || Boolean(node.initializer)));
+      const isRest = declarations.some((node) => ts3.isParameter(node) && Boolean(node.dotDotDotToken));
+      return {
+        name: parameter.getName(),
+        typeText,
+        isOptional: (parameter.flags & ts3.SymbolFlags.Optional) !== 0 || isOptionalByDeclaration,
+        isRest
+      };
+    });
+    return {
+      parameters,
+      returnTypeText: context.checker.typeToString(signature.getReturnType())
+    };
+  });
+  return {
+    items,
+    argumentIndex: activeCall.argumentIndex,
+    argumentCount: activeCall.argumentCount,
+    applicableStart: context.expressionStart + activeCall.applicableStartOffset,
+    applicableEnd: context.expressionStart + activeCall.applicableEndOffset
+  };
+}
+__name(getRsxSignatureHelpAtPosition, "getRsxSignatureHelpAtPosition");
+function resolveExpressionContext(program, fileName, position) {
+  const sourceFile = program.getSourceFile(fileName);
+  if (!sourceFile) {
+    return null;
+  }
+  const checker = program.getTypeChecker();
+  const sites = detectExpressionSitesInSourceFile(sourceFile, checker);
+  for (const site of sites) {
+    const expressionStart = site.expressionLiteral.getStart(sourceFile) + 1;
+    const expressionEnd = site.expressionLiteral.getEnd() - 1;
+    if (position < expressionStart || position > expressionEnd) {
+      continue;
+    }
+    const modelNode = site.callExpression.arguments[0];
+    if (!modelNode) {
+      return null;
+    }
+    return {
+      sourceFile,
+      expression: site.expression,
+      expressionStart,
+      expressionEnd,
+      modelType: checker.getTypeAtLocation(modelNode),
+      checker
+    };
+  }
+  return null;
+}
+__name(resolveExpressionContext, "resolveExpressionContext");
+function resolveCompletionTarget(prefixSource) {
+  const chainMatch = prefixSource.match(/([A-Za-z_$][\w$]*(?:(?:\(\))|(?:\[\d+\]))?(?:\.[A-Za-z_$][\w$]*(?:(?:\(\))|(?:\[\d+\]))?)*)\.([A-Za-z_$][\w$]*)?$/u);
+  if (chainMatch) {
+    return {
+      chain: splitChain(chainMatch[1]),
+      prefix: chainMatch[2] ?? ""
+    };
+  }
+  const trailingDotChainMatch = prefixSource.match(/([A-Za-z_$][\w$]*(?:(?:\(\))|(?:\[\d+\]))?(?:\.[A-Za-z_$][\w$]*(?:(?:\(\))|(?:\[\d+\]))?)*)\.$/u);
+  if (trailingDotChainMatch) {
+    return {
+      chain: splitChain(trailingDotChainMatch[1]),
+      prefix: ""
+    };
+  }
+  const rootPrefixMatch = prefixSource.match(/([A-Za-z_$][\w$]*)$/u);
+  return {
+    chain: [],
+    prefix: rootPrefixMatch?.[1] ?? ""
+  };
+}
+__name(resolveCompletionTarget, "resolveCompletionTarget");
+function resolveIdentifierTokenRange(expression, offset) {
+  const isIdentifierChar = /* @__PURE__ */ __name((char) => /[A-Za-z0-9_$]/u.test(char), "isIdentifierChar");
+  if (offset < 0 || offset > expression.length) {
+    return null;
+  }
+  let start = offset;
+  let end = offset;
+  if (offset < expression.length && isIdentifierChar(expression[offset])) {
+    start = offset;
+    end = offset + 1;
+  } else if (offset > 0 && isIdentifierChar(expression[offset - 1])) {
+    start = offset - 1;
+    end = offset;
+  } else {
+    return null;
+  }
+  while (start > 0 && isIdentifierChar(expression[start - 1])) {
+    start -= 1;
+  }
+  while (end < expression.length && isIdentifierChar(expression[end])) {
+    end += 1;
+  }
+  return {
+    start,
+    end
+  };
+}
+__name(resolveIdentifierTokenRange, "resolveIdentifierTokenRange");
+function resolveChainFromSuffix(prefix) {
+  const chainMatch = prefix.match(/([A-Za-z_$][\w$]*(?:\(\))?(?:\.[A-Za-z_$][\w$]*(?:\(\))?)*)$/u);
+  if (!chainMatch) {
+    return [];
+  }
+  return splitChain(chainMatch[1]);
+}
+__name(resolveChainFromSuffix, "resolveChainFromSuffix");
+function splitChain(chainText) {
+  return chainText.split(".").filter(Boolean);
+}
+__name(splitChain, "splitChain");
+function resolveChainType(modelType, chain, checker) {
+  let currentType = modelType;
+  for (const segment of chain) {
+    if (!currentType) {
+      return null;
+    }
+    currentType = unwrapRsxExpressionType2(currentType, checker);
+    const arrayIndexMatch = segment.match(/^([A-Za-z_$][\w$]*)?\[(\d+)\]$/u);
+    if (arrayIndexMatch) {
+      const propName = arrayIndexMatch[1];
+      let typeToIndex = currentType;
+      if (propName) {
+        const property2 = typeToIndex.getProperty(propName);
+        if (!property2) return null;
+        const declaration2 = property2.valueDeclaration ?? property2.declarations?.[0];
+        if (!declaration2) return null;
+        typeToIndex = checker.getNonNullableType(unwrapRsxExpressionType2(checker.getTypeOfSymbolAtLocation(property2, declaration2), checker));
+      }
+      const numberIndexType = typeToIndex.getNumberIndexType();
+      if (numberIndexType) {
+        currentType = checker.getNonNullableType(unwrapRsxExpressionType2(numberIndexType, checker));
+      } else {
+        const typeArgs = checker.getTypeArguments(typeToIndex);
+        if (typeArgs.length > 0 && typeArgs[0]) {
+          currentType = checker.getNonNullableType(unwrapRsxExpressionType2(typeArgs[0], checker));
+        } else {
+          return null;
+        }
+      }
+      continue;
+    }
+    const isMethodCall = segment.endsWith("()");
+    const name = isMethodCall ? segment.slice(0, -2) : segment;
+    const property = currentType.getProperty(name);
+    if (!property) {
+      return null;
+    }
+    const declaration = property.valueDeclaration ?? property.declarations?.[0];
+    if (!declaration) {
+      return null;
+    }
+    const propertyType = checker.getTypeOfSymbolAtLocation(property, declaration);
+    if (!isMethodCall) {
+      currentType = checker.getNonNullableType(unwrapRsxExpressionType2(propertyType, checker));
+      continue;
+    }
+    const signatures = propertyType.getCallSignatures();
+    if (signatures.length === 0) {
+      return null;
+    }
+    currentType = checker.getNonNullableType(unwrapRsxExpressionType2(signatures[0].getReturnType(), checker));
+  }
+  return currentType;
+}
+__name(resolveChainType, "resolveChainType");
+function resolveCallableType(modelType, chain, sourceFile, checker, isConstructorCall) {
+  if (chain.length === 0) {
+    return null;
+  }
+  if (isConstructorCall) {
+    return resolveConstructorType(chain, sourceFile, checker);
+  }
+  const containerChain = chain.slice(0, -1);
+  const callableName = chain[chain.length - 1];
+  if (!callableName || callableName.endsWith("()")) {
+    return null;
+  }
+  const containerType = containerChain.length ? resolveChainType(modelType, containerChain, checker) : modelType;
+  if (!containerType) {
+    return null;
+  }
+  const callableProperty = containerType.getProperty(callableName);
+  if (!callableProperty) {
+    return null;
+  }
+  const declaration = callableProperty.valueDeclaration ?? callableProperty.declarations?.[0];
+  if (!declaration) {
+    return null;
+  }
+  return unwrapRsxExpressionType2(checker.getTypeOfSymbolAtLocation(callableProperty, declaration), checker);
+}
+__name(resolveCallableType, "resolveCallableType");
+function resolveActiveCallContext(prefixSource) {
+  const callStack = [];
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  let inTemplate = false;
+  let escaped = false;
+  for (let index = 0; index < prefixSource.length; index += 1) {
+    const char = prefixSource[index];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (inSingleQuote) {
+      if (char === "\\") {
+        escaped = true;
+      } else if (char === "'") {
+        inSingleQuote = false;
+      }
+      continue;
+    }
+    if (inDoubleQuote) {
+      if (char === "\\") {
+        escaped = true;
+      } else if (char === '"') {
+        inDoubleQuote = false;
+      }
+      continue;
+    }
+    if (inTemplate) {
+      if (char === "\\") {
+        escaped = true;
+      } else if (char === "`") {
+        inTemplate = false;
+      }
+      continue;
+    }
+    if (char === "'") {
+      inSingleQuote = true;
+      continue;
+    }
+    if (char === '"') {
+      inDoubleQuote = true;
+      continue;
+    }
+    if (char === "`") {
+      inTemplate = true;
+      continue;
+    }
+    if (char === "(") {
+      callStack.push({
+        openOffset: index,
+        commaCount: 0
+      });
+      continue;
+    }
+    if (char === ")") {
+      if (callStack.length > 0) {
+        callStack.pop();
+      }
+      continue;
+    }
+    if (char === "," && callStack.length > 0) {
+      const activeCall2 = callStack[callStack.length - 1];
+      activeCall2.commaCount += 1;
+    }
+  }
+  if (callStack.length === 0) {
+    return null;
+  }
+  const activeCall = callStack[callStack.length - 1];
+  const callTargetSource = prefixSource.slice(0, activeCall.openOffset).trimEnd();
+  const chainMatch = callTargetSource.match(/([A-Za-z_$][\w$]*(?:\(\))?(?:\.[A-Za-z_$][\w$]*(?:\(\))?)*)$/u);
+  if (!chainMatch) {
+    return null;
+  }
+  const chain = splitChain(chainMatch[1]);
+  const constructorMatch = callTargetSource.match(/(?:^|[^\w$])new\s+([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)$/u);
+  const hasArgumentText = prefixSource.slice(activeCall.openOffset + 1).trim().length > 0;
+  return {
+    chain,
+    isConstructorCall: Boolean(constructorMatch) && constructorMatch?.[1] === chainMatch[1],
+    argumentIndex: activeCall.commaCount,
+    argumentCount: hasArgumentText ? activeCall.commaCount + 1 : 0,
+    applicableStartOffset: activeCall.openOffset + 1,
+    applicableEndOffset: prefixSource.length
+  };
+}
+__name(resolveActiveCallContext, "resolveActiveCallContext");
+function resolveConstructorCompletionPrefix(prefixSource) {
+  const constructorPrefixMatch = prefixSource.match(/(?:^|[^\w$])new\s+([A-Za-z_$][\w$]*)?$/u);
+  if (!constructorPrefixMatch) {
+    return null;
+  }
+  return constructorPrefixMatch[1] ?? "";
+}
+__name(resolveConstructorCompletionPrefix, "resolveConstructorCompletionPrefix");
+function resolveConstructorCompletions(context, prefix) {
+  const constructableNames = context.checker.getSymbolsInScope(context.sourceFile, ts3.SymbolFlags.Value | ts3.SymbolFlags.Type | ts3.SymbolFlags.Namespace | ts3.SymbolFlags.Alias).filter((symbol) => !symbol.getName().startsWith("__")).filter((symbol) => symbol.getName().startsWith(prefix)).filter((symbol) => resolveConstructableTypeFromSymbol(symbol, context.sourceFile, context.checker) !== null).map((symbol) => symbol.getName()).filter((name, index, collection) => collection.indexOf(name) === index).sort();
+  return constructableNames.map((name) => ({
+    name,
+    kind: "constructor"
+  }));
+}
+__name(resolveConstructorCompletions, "resolveConstructorCompletions");
+function resolveConstructorType(chain, sourceFile, checker) {
+  const [rootName, ...rest] = chain;
+  if (!rootName) {
+    return null;
+  }
+  const rootSymbol = checker.getSymbolsInScope(sourceFile, ts3.SymbolFlags.Value | ts3.SymbolFlags.Type | ts3.SymbolFlags.Namespace | ts3.SymbolFlags.Alias).find((symbol) => symbol.getName() === rootName);
+  if (!rootSymbol) {
+    return null;
+  }
+  const rootType = resolveConstructableTypeFromSymbol(rootSymbol, sourceFile, checker);
+  if (!rootType) {
+    return null;
+  }
+  if (rest.length === 0) {
+    return rootType;
+  }
+  let currentType = rootType;
+  for (const segment of rest) {
+    if (!currentType) {
+      return null;
+    }
+    const property = currentType.getProperty(segment);
+    if (!property) {
+      return null;
+    }
+    const declaration = property.valueDeclaration ?? property.declarations?.[0];
+    if (!declaration) {
+      return null;
+    }
+    currentType = checker.getTypeOfSymbolAtLocation(property, declaration);
+  }
+  return currentType;
+}
+__name(resolveConstructorType, "resolveConstructorType");
+function resolveConstructableTypeFromSymbol(symbol, sourceFile, checker) {
+  const resolvedSymbol = symbol.flags & ts3.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+  const declaration = resolvedSymbol.valueDeclaration ?? resolvedSymbol.declarations?.[0] ?? symbol.valueDeclaration ?? symbol.declarations?.[0] ?? sourceFile;
+  const symbolType = checker.getTypeOfSymbolAtLocation(resolvedSymbol, declaration);
+  if (symbolType.getConstructSignatures().length > 0) {
+    return symbolType;
+  }
+  return null;
+}
+__name(resolveConstructableTypeFromSymbol, "resolveConstructableTypeFromSymbol");
+function isCallableProperty(targetType, name, checker) {
+  const property = targetType.getProperty(name);
+  if (!property) {
+    return false;
+  }
+  const declaration = property.valueDeclaration ?? property.declarations?.[0];
+  if (!declaration) {
+    return false;
+  }
+  const propertyType = unwrapRsxExpressionType2(checker.getTypeOfSymbolAtLocation(property, declaration), checker);
+  return propertyType.getCallSignatures().length > 0;
+}
+__name(isCallableProperty, "isCallableProperty");
+function unwrapRsxExpressionType2(type, checker) {
+  const symbol = type.aliasSymbol ?? type.getSymbol();
+  if (symbol?.getName() === "IExpression") {
+    const typeArguments = checker.getTypeArguments(type);
+    if (typeArguments.length > 0) {
+      return typeArguments[0];
+    }
+  }
+  const hasExpressionShape = type.getProperty("value") && type.getProperty("expressionString") && type.getProperty("childExpressions") && type.getProperty("changed");
+  if (!hasExpressionShape) {
+    return type;
+  }
+  const valueProperty = type.getProperty("value");
+  const declaration = valueProperty?.valueDeclaration ?? valueProperty?.declarations?.[0];
+  if (!valueProperty || !declaration) {
+    return type;
+  }
+  return checker.getTypeOfSymbolAtLocation(valueProperty, declaration);
+}
+__name(unwrapRsxExpressionType2, "unwrapRsxExpressionType");
+
+// lib/language-service/index.ts
+function createLanguageServiceScaffold() {
+  return {
+    folder: "language-service",
+    supportsIntelliSense: true
+  };
+}
+__name(createLanguageServiceScaffold, "createLanguageServiceScaffold");
+
+// lib/transformer/index.ts
+function createTransformerScaffold() {
+  return {
+    folder: "transformer",
+    enabled: false
+  };
+}
+__name(createTransformerScaffold, "createTransformerScaffold");
+export {
+  classifyParserError,
+  createCompilerScaffold,
+  createDiagnosticsScaffold,
+  createLanguageServiceScaffold,
+  createTransformerScaffold,
+  detectExpressionSites,
+  detectExpressionSitesInSourceFile,
+  findRsxExpressionLiteralRanges,
+  findRsxExpressionRegionAtPosition,
+  generateAotCompiledExpressionsModule,
+  generateAotLazyExpressionPreloadManifestModule,
+  generateAotParsedExpressionCacheModule,
+  getRsxCompletionsAtPosition,
+  getRsxDiagnosticsForFile,
+  getRsxHoverAtPosition,
+  getRsxSignatureHelpAtPosition,
+  isDateLikeType,
+  parseExpressionDiagnostic,
+  supportedDateProperties,
+  tokenizeRsxExpression,
+  validateExpressionSite,
+  validateExpressionSites
+};