semantifold 0.1.0

package/build/src/frontends/javascript-typescript.js

@@ -0,0 +1,633 @@
+// @ts-check
+import { parse as parseBabel } from "@babel/parser";
+import { parse as parseComment } from "comment-parser";
+import { missingType, parseFailure, unsupportedSyntax } from "../diagnostic.js";
+import { locationFromOffsets, moduleLocation } from "../semantic/location.js";
+import { withAdaptedOperation } from "../semantic/operators.js";
+import { withParserRanges } from "../semantic/provenance.js";
+import { hasOnlyUnicodeScalars } from "../semantic/scalars.js";
+import { requireSourceScalarType } from "./scalars.js";
+/** @typedef {NonNullable<import("@babel/parser").ParseResult<import("@babel/types").File>["tokens"]>[number]} BabelToken */
+/** @typedef {{byStart: Map<number, BabelToken>, tokens: BabelToken[]}} BabelTokenIndex */
+/** @type {WeakMap<object, BabelTokenIndex>} */
+const nodeTokens = new WeakMap();
+const babelBinaryOperations = new Map([
+    ["+", "Add"],
+    ["-", "Subtract"],
+    ["*", "Multiply"],
+    ["===", "Equal"],
+    ["!==", "NotEqual"],
+    ["<", "LessThan"],
+    ["<=", "LessThanOrEqual"],
+    [">", "GreaterThan"],
+    [">=", "GreaterThanOrEqual"]
+]);
+/**
+ * Returns a source location for a Babel node.
+ * @param {import("@babel/types").Node} node - Babel node.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").SourceLocation} Normalized location.
+ */
+function nodeLocation(node, filename, source) {
+    if (typeof node.start != "number" || typeof node.end != "number") {
+        throw new Error(`Babel omitted source offsets for ${node.type}.`);
+    }
+    return locationFromOffsets(filename, source, node.start, node.end);
+}
+/**
+ * Returns the identifier spelling rather than a trailing TypeScript annotation.
+ * @param {import("@babel/types").Identifier} node - Parser identifier.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").SourceLocation} Identifier location.
+ */
+function identifierLocation(node, filename, source) {
+    if (typeof node.start != "number")
+        throw new Error("Babel omitted an identifier start offset.");
+    const token = nodeTokens.get(node)?.byStart.get(node.start);
+    if (!token || token.type.label != "name")
+        throw new Error(`Babel omitted the identifier token for '${node.name}'.`);
+    return locationFromOffsets(filename, source, token.start, token.end);
+}
+/**
+ * Locates one Babel token within parser-node boundaries.
+ * @param {import("@babel/types").Node} owner - Token-owning parser node.
+ * @param {string} value - Exact token spelling.
+ * @param {number} startOffset - Inclusive boundary.
+ * @param {number} endOffset - Exclusive boundary.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").SourceLocation} Exact token location.
+ */
+function tokenLocation(owner, value, startOffset, endOffset, filename, source) {
+    const tokens = nodeTokens.get(owner)?.tokens ?? [];
+    let low = 0;
+    let high = tokens.length;
+    while (low < high) {
+        const middle = Math.floor((low + high) / 2);
+        if (tokens[middle].start < startOffset)
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    let token;
+    for (let index = low; index < tokens.length && tokens[index].start < endOffset; index++) {
+        const candidate = tokens[index];
+        if (candidate.end <= endOffset && (candidate.value == value || candidate.type.label == value)) {
+            token = candidate;
+            break;
+        }
+    }
+    if (!token)
+        throw new Error(`Babel omitted token '${value}' between ${startOffset} and ${endOffset}.`);
+    return locationFromOffsets(filename, source, token.start, token.end);
+}
+/**
+ * Locates a comment-parser token inside a Babel-owned doc comment.
+ * @param {import("@babel/types").CommentBlock} comment - Babel doc comment.
+ * @param {import("comment-parser").Spec} tag - Parsed doc tag.
+ * @param {"name" | "type"} field - Token field.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").SourceLocation} Exact token location.
+ */
+function commentTagLocation(comment, tag, field, filename, source) {
+    const line = tag.source[0];
+    if (typeof comment.start != "number" || !line)
+        throw new Error(`Comment parser omitted the @${tag.tag} source token.`);
+    let lineStart = comment.start;
+    for (let lineNumber = 0; lineNumber < line.number; lineNumber++) {
+        while (lineStart < source.length && source[lineStart] != "\r" && source[lineStart] != "\n")
+            lineStart++;
+        if (source[lineStart] == "\r" && source[lineStart + 1] == "\n")
+            lineStart += 2;
+        else
+            lineStart++;
+    }
+    const orderedFields = ["start", "delimiter", "postDelimiter", "tag", "postTag", "type", "postType", "name"];
+    const fieldIndex = orderedFields.indexOf(field);
+    const start = lineStart + orderedFields.slice(0, fieldIndex).reduce((length, key) => length + line.tokens[ /** @type {keyof typeof line.tokens} */(key)].length, 0);
+    const token = line.tokens[field];
+    return locationFromOffsets(filename, source, start, start + token.length);
+}
+/**
+ * Converts a supported Babel expression.
+ * @param {import("@babel/types").Expression} node - Babel expression.
+ * @param {"javascript" | "typescript"} language - Frontend language.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").Expression} Semantic expression.
+ */
+function convertExpression(node, language, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    if (node.type == "Identifier") {
+        return withParserRanges({ kind: /** @type {const} */ ("IdentifierExpression"), location, name: node.name }, {
+            name: identifierLocation(node, filename, source)
+        });
+    }
+    if (node.type == "NumericLiteral") {
+        if (!Number.isSafeInteger(node.value))
+            return unsupportedSyntax(language, "non-safe integer literal", location);
+        return withParserRanges({ kind: /** @type {const} */ ("IntegerLiteral"), location, value: node.value }, { literal: location });
+    }
+    if (node.type == "BooleanLiteral") {
+        if (typeof node.value != "boolean")
+            return unsupportedSyntax(language, "invalid boolean literal value", location);
+        return withParserRanges({ kind: /** @type {const} */ ("BooleanLiteral"), location, value: node.value }, { literal: location });
+    }
+    if (node.type == "StringLiteral") {
+        if (typeof node.value != "string" || !hasOnlyUnicodeScalars(node.value)) {
+            return unsupportedSyntax(language, "invalid Unicode string literal", location);
+        }
+        return withParserRanges({ kind: /** @type {const} */ ("StringLiteral"), location, value: node.value }, { literal: location });
+    }
+    if (node.type == "TemplateLiteral") {
+        if (node.expressions.length > 0)
+            return unsupportedSyntax(language, "interpolated string", location);
+        const quasi = node.quasis[0];
+        if (typeof quasi.value.cooked != "string" || !hasOnlyUnicodeScalars(quasi.value.cooked)) {
+            return unsupportedSyntax(language, "invalid Unicode string literal", location);
+        }
+        return withParserRanges({ kind: /** @type {const} */ ("StringLiteral"), location, value: quasi.value.cooked }, { literal: location });
+    }
+    if (node.type == "UnaryExpression" && ["!", "-"].includes(node.operator)) {
+        const operand = convertExpression(node.argument, language, filename, source);
+        const semantic = withAdaptedOperation(withParserRanges({
+            kind: "UnaryExpression",
+            location,
+            operand
+        }, {
+            operator: tokenLocation(node, node.operator, node.start ?? 0, node.argument.start ?? node.end ?? source.length, filename, source)
+        }), node.operator == "!" ? "Not" : "Negate");
+        return /** @type {import("../semantic/types.js").Expression} */ ( /** @type {unknown} */(semantic));
+    }
+    if (node.type == "LogicalExpression" && ["&&", "||"].includes(node.operator)) {
+        const semantic = withAdaptedOperation(withParserRanges({
+            kind: "BinaryExpression",
+            left: convertExpression(node.left, language, filename, source),
+            location,
+            right: convertExpression(node.right, language, filename, source)
+        }, {
+            operator: tokenLocation(node, node.operator, node.left.end ?? node.start ?? 0, node.right.start ?? node.end ?? source.length, filename, source)
+        }), node.operator == "&&" ? "And" : "Or");
+        return /** @type {import("../semantic/types.js").Expression} */ ( /** @type {unknown} */(semantic));
+    }
+    if (node.type == "BinaryExpression" && babelBinaryOperations.has(node.operator)) {
+        if (node.left.type == "PrivateName")
+            unsupportedSyntax(language, node.left.type, location);
+        const left = convertExpression(node.left, language, filename, source);
+        const right = convertExpression(node.right, language, filename, source);
+        const semantic = withAdaptedOperation(withParserRanges({
+            kind: "BinaryExpression",
+            left,
+            location,
+            right
+        }, {
+            operator: tokenLocation(node, node.operator, node.left.end ?? node.start ?? 0, node.right.start ?? node.end ?? source.length, filename, source)
+        }), /** @type {import("../semantic/operators.js").AdaptedOperation} */ (babelBinaryOperations.get(node.operator)));
+        return /** @type {import("../semantic/types.js").Expression} */ ( /** @type {unknown} */(semantic));
+    }
+    if (node.type == "BinaryExpression" && ["==", "!="].includes(node.operator)) {
+        return unsupportedSyntax(language, `coercive equality ${node.operator}`, location);
+    }
+    if (node.type == "CallExpression" && node.callee.type == "Identifier") {
+        const arguments_ = node.arguments.map((argument) => {
+            if (argument.type == "SpreadElement" || argument.type == "ArgumentPlaceholder") {
+                return unsupportedSyntax(language, argument.type, nodeLocation(argument, filename, source));
+            }
+            return convertExpression(argument, language, filename, source);
+        });
+        return withParserRanges({ arguments: arguments_, callee: node.callee.name, kind: /** @type {const} */ ("CallExpression"), location }, {
+            callee: identifierLocation(node.callee, filename, source)
+        });
+    }
+    return unsupportedSyntax(language, node.type, location);
+}
+/**
+ * Converts a supported return statement.
+ * @param {import("@babel/types").Statement} node - Babel statement.
+ * @param {"javascript" | "typescript"} language - Frontend language.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").ReturnStatement} Semantic return.
+ */
+function convertReturn(node, language, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    if (node.type != "ReturnStatement" || !node.argument)
+        return unsupportedSyntax(language, node.type, location);
+    return { expression: convertExpression(node.argument, language, filename, source), kind: "ReturnStatement", location };
+}
+/**
+ * Converts one supported local declaration or assignment.
+ * @param {import("@babel/types").Statement} node - Babel statement.
+ * @param {"javascript" | "typescript"} language - Frontend language.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").LocalStatement} Semantic local statement.
+ */
+function convertLocalStatement(node, language, filename, source) {
+    const location = nodeLocation(node, filename, source);
+    if (node.type == "VariableDeclaration") {
+        if (!["let", "const"].includes(node.kind) || node.declarations.length != 1) {
+            return unsupportedSyntax(language, `${node.kind} declaration`, location);
+        }
+        const declarator = node.declarations[0];
+        const declaratorLocation = nodeLocation(declarator, filename, source);
+        if (declarator.id.type != "Identifier")
+            return unsupportedSyntax(language, declarator.id.type, declaratorLocation);
+        if (!declarator.init)
+            return unsupportedSyntax(language, "uninitialized declaration", declaratorLocation);
+        const type = language == "typescript"
+            ? convertTypeScriptType(declarator.id.typeAnnotation, `Local '${declarator.id.name}'`, declaratorLocation, filename, source)
+            : localJavaScriptType(node, declarator.id.name, filename, source);
+        return withParserRanges({
+            initializer: convertExpression(declarator.init, language, filename, source),
+            kind: "LocalDeclaration",
+            location,
+            mutable: node.kind == "let",
+            name: declarator.id.name,
+            type
+        }, {
+            name: identifierLocation(declarator.id, filename, source),
+            operator: tokenLocation(declarator, "=", declarator.id.end ?? declarator.start ?? 0, declarator.init.start ?? declarator.end ?? source.length, filename, source)
+        });
+    }
+    if (node.type == "ExpressionStatement" && node.expression.type == "AssignmentExpression") {
+        const assignment = node.expression;
+        const targetLocation = nodeLocation(assignment.left, filename, source);
+        if (assignment.operator != "=")
+            return unsupportedSyntax(language, `assignment ${assignment.operator}`, location);
+        if (assignment.left.type != "Identifier")
+            return unsupportedSyntax(language, assignment.left.type, targetLocation);
+        const target = withParserRanges({ kind: /** @type {const} */ ("IdentifierExpression"), location: targetLocation, name: assignment.left.name }, {
+            name: identifierLocation(assignment.left, filename, source)
+        });
+        return withParserRanges({
+            expression: convertExpression(assignment.right, language, filename, source),
+            kind: "AssignmentStatement",
+            location,
+            target
+        }, {
+            operator: tokenLocation(assignment, "=", assignment.left.end ?? assignment.start ?? 0, assignment.right.start ?? assignment.end ?? source.length, filename, source)
+        });
+    }
+    return unsupportedSyntax(language, node.type, location);
+}
+/**
+ * Reads an immediately associated JavaScript local `@type` tag.
+ * @param {import("@babel/types").VariableDeclaration} node - Local declaration.
+ * @param {string} name - Local name.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").TypeReference} Semantic type.
+ */
+function localJavaScriptType(node, name, filename, source) {
+    const comment = node.leadingComments?.at(-1);
+    const location = nodeLocation(node, filename, source);
+    if (!comment || comment.type != "CommentBlock" || !comment.value.startsWith("*")) {
+        return missingType("javascript", `Local '${name}'`, location);
+    }
+    const gap = source.slice(comment.end ?? 0, node.start ?? 0);
+    if (!/^\s*$/u.test(gap) || (gap.match(/\n/gu)?.length ?? 0) > 1) {
+        return missingType("javascript", `Local '${name}'`, location);
+    }
+    const block = parseComment(`/*${comment.value}*/`)[0];
+    const tags = block?.tags.filter((tag) => tag.tag == "type") ?? [];
+    const tag = tags.length == 1 ? tags[0] : undefined;
+    return convertType(tag?.type, "javascript", `Local '${name}'`, location, tag ? commentTagLocation(comment, tag, "type", filename, source) : location);
+}
+/**
+ * Converts one exhaustive Babel statement.
+ * @param {import("@babel/types").Statement} node - Babel statement.
+ * @param {"javascript" | "typescript"} language - Frontend language.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @param {boolean} canonicalZeroRequired - Whether generated scalar output may contain signed zero.
+ * @returns {import("../semantic/types.js").Statement} Semantic statement.
+ */
+function convertStatement(node, language, filename, source, canonicalZeroRequired) {
+    if (node.type == "ReturnStatement")
+        return convertReturn(node, language, filename, source);
+    if (node.type == "IfStatement")
+        return convertIf(node, language, filename, source, canonicalZeroRequired);
+    if (node.type == "VariableDeclaration" || node.type == "ExpressionStatement" && node.expression.type == "AssignmentExpression") {
+        return convertLocalStatement(node, language, filename, source);
+    }
+    if (node.type == "ExpressionStatement")
+        return convertPrint(node, language, filename, source, canonicalZeroRequired);
+    return unsupportedSyntax(language, node.type, nodeLocation(node, filename, source));
+}
+/**
+ * Converts one Babel block or normalized single-statement body.
+ * @param {import("@babel/types").BlockStatement | import("@babel/types").Statement[]} input - Parser block or statements.
+ * @param {"javascript" | "typescript"} language - Frontend language.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @param {boolean} canonicalZeroRequired - Whether generated scalar output may contain signed zero.
+ * @param {import("../semantic/types.js").SourceLocation} [location] - Location for a statement-array block.
+ * @returns {import("../semantic/types.js").Block} Semantic block.
+ */
+function convertBlock(input, language, filename, source, canonicalZeroRequired, location) {
+    const statements = Array.isArray(input) ? input : input.body;
+    const directives = Array.isArray(input) ? [] : input.directives;
+    const blockLocation = location ?? nodeLocation(/** @type {import("@babel/types").BlockStatement} */ (input), filename, source);
+    if (directives.length > 0) {
+        return unsupportedSyntax(language, "directive", nodeLocation(directives[0], filename, source));
+    }
+    return {
+        kind: "Block",
+        location: blockLocation,
+        statements: statements.map((statement) => convertStatement(statement, language, filename, source, canonicalZeroRequired))
+    };
+}
+/**
+ * Reads JavaScript JSDoc types from a function.
+ * @param {import("@babel/types").FunctionDeclaration} node - Babel function node.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {{parameters: Map<string, {location: import("../semantic/types.js").SourceLocation, sourceType: string}>, returnType: {location: import("../semantic/types.js").SourceLocation, sourceType: string} | undefined}} Parsed types.
+ */
+function jsdocTypes(node, filename, source) {
+    const comment = node.leadingComments?.find((candidate) => candidate.type == "CommentBlock" && candidate.value.startsWith("*"));
+    if (!comment)
+        missingType("javascript", `Function '${node.id?.name ?? "anonymous"}'`, nodeLocation(node, filename, source));
+    const commentBlock = /** @type {import("@babel/types").CommentBlock} */ (comment);
+    const block = parseComment(`/*${commentBlock.value}*/`)[0];
+    const parameters = new Map(block.tags.filter((tag) => tag.tag == "param").map((tag) => [tag.name, {
+            location: commentTagLocation(commentBlock, tag, "type", filename, source),
+            sourceType: tag.type
+        }]));
+    const returnTag = block.tags.find((tag) => tag.tag == "returns" || tag.tag == "return");
+    return {
+        parameters,
+        returnType: returnTag ? { location: commentTagLocation(commentBlock, returnTag, "type", filename, source), sourceType: returnTag.type } : undefined
+    };
+}
+/**
+ * Requires a supported JavaScript JSDoc scalar type spelling.
+ * @param {string | undefined} sourceType - Source-language type.
+ * @param {"javascript" | "typescript"} language - Frontend language.
+ * @param {string} subject - Typed subject.
+ * @param {import("../semantic/types.js").SourceLocation} location - Source location.
+ * @param {import("../semantic/types.js").SourceLocation} [typeLocation] - Exact type token location.
+ * @returns {import("../semantic/types.js").TypeReference} Semantic type.
+ */
+function convertType(sourceType, language, subject, location, typeLocation = location) {
+    return requireSourceScalarType(language, sourceType, subject, location, typeLocation);
+}
+/**
+ * Converts one exact TypeScript scalar keyword annotation.
+ * @param {import("@babel/types").TypeAnnotation | import("@babel/types").TSTypeAnnotation | import("@babel/types").Noop | null | undefined} annotation - Type annotation.
+ * @param {string} subject - Typed subject.
+ * @param {import("../semantic/types.js").SourceLocation} ownerLocation - Owning declaration location.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @returns {import("../semantic/types.js").TypeReference} Semantic scalar type.
+ */
+function convertTypeScriptType(annotation, subject, ownerLocation, filename, source) {
+    if (!annotation)
+        return missingType("typescript", subject, ownerLocation);
+    if (annotation.type != "TSTypeAnnotation") {
+        return unsupportedSyntax("typescript", "unsupported scalar type", nodeLocation(annotation, filename, source));
+    }
+    const typeNode = annotation.typeAnnotation;
+    const sourceType = typeNode.type == "TSNumberKeyword"
+        ? "number"
+        : typeNode.type == "TSBooleanKeyword"
+            ? "boolean"
+            : typeNode.type == "TSStringKeyword" ? "string" : undefined;
+    if (!sourceType) {
+        return unsupportedSyntax("typescript", "unsupported scalar type", nodeLocation(typeNode, filename, source));
+    }
+    return requireSourceScalarType("typescript", sourceType, subject, ownerLocation, nodeLocation(typeNode, filename, source));
+}
+/**
+ * Converts a supported function declaration.
+ * @param {import("@babel/types").FunctionDeclaration} node - Babel function.
+ * @param {"javascript" | "typescript"} language - Frontend language.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @param {boolean} canonicalZeroRequired - Whether generated scalar output may contain signed zero.
+ * @returns {import("../semantic/types.js").FunctionDeclaration} Semantic function.
+ */
+function convertFunction(node, language, filename, source, canonicalZeroRequired) {
+    const location = nodeLocation(node, filename, source);
+    if (!node.id)
+        return unsupportedSyntax(language, "anonymous function", location);
+    if (node.async)
+        return unsupportedSyntax(language, "async function", location);
+    if (node.generator)
+        return unsupportedSyntax(language, "generator function", location);
+    const documentedTypes = language == "javascript" ? jsdocTypes(node, filename, source) : undefined;
+    const parameters = node.params.map((parameter) => {
+        const parameterLocation = nodeLocation(parameter, filename, source);
+        if (parameter.type != "Identifier")
+            return unsupportedSyntax(language, parameter.type, parameterLocation);
+        const documentedType = documentedTypes?.parameters.get(parameter.name);
+        const type = language == "javascript"
+            ? convertType(documentedType?.sourceType, language, `Parameter '${parameter.name}'`, parameterLocation, documentedType?.location)
+            : convertTypeScriptType(parameter.typeAnnotation, `Parameter '${parameter.name}'`, parameterLocation, filename, source);
+        return withParserRanges({
+            kind: /** @type {const} */ ("Parameter"),
+            location: parameterLocation,
+            name: parameter.name,
+            type
+        }, { name: identifierLocation(parameter, filename, source) });
+    });
+    const returnAnnotation = node.returnType;
+    const returnType = language == "javascript"
+        ? convertType(documentedTypes?.returnType?.sourceType, language, `Function '${node.id.name}' return`, location, documentedTypes?.returnType?.location)
+        : convertTypeScriptType(returnAnnotation, `Function '${node.id.name}' return`, location, filename, source);
+    const body = convertBlock(node.body, language, filename, source, canonicalZeroRequired);
+    return withParserRanges({
+        body,
+        kind: "FunctionDeclaration",
+        location,
+        name: node.id.name,
+        parameters,
+        returnType
+    }, { name: identifierLocation(node.id, filename, source) });
+}
+/**
+ * Converts the existing exact if/else terminal shape.
+ * @param {import("@babel/types").IfStatement} node - Babel if statement.
+ * @param {"javascript" | "typescript"} language - Frontend language.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @param {boolean} canonicalZeroRequired - Whether generated scalar output may contain signed zero.
+ * @returns {import("../semantic/types.js").IfStatement} Semantic branch.
+ */
+function convertIf(node, language, filename, source, canonicalZeroRequired) {
+    const location = nodeLocation(node, filename, source);
+    const consequent = node.consequent.type == "BlockStatement"
+        ? convertBlock(node.consequent, language, filename, source, canonicalZeroRequired)
+        : convertBlock([node.consequent], language, filename, source, canonicalZeroRequired, nodeLocation(node.consequent, filename, source));
+    const alternate = node.alternate
+        ? node.alternate.type == "BlockStatement"
+            ? convertBlock(node.alternate, language, filename, source, canonicalZeroRequired)
+            : convertBlock([node.alternate], language, filename, source, canonicalZeroRequired, nodeLocation(node.alternate, filename, source))
+        : undefined;
+    return {
+        ...(alternate ? { alternate } : {}),
+        condition: convertExpression(node.test, language, filename, source),
+        consequent,
+        kind: "IfStatement",
+        location
+    };
+}
+/**
+ * Reports whether Babel parsed an operation that makes generated JavaScript-family scalar output require zero canonicalization.
+ * @param {unknown} value - Babel parser subtree.
+ * @param {WeakSet<object>} [visited] - Cycle protection.
+ * @returns {boolean} Whether the subtree contains integer negation or multiplication syntax.
+ */
+function parserTreeRequiresCanonicalZero(value, visited = new WeakSet()) {
+    if (!value || typeof value != "object")
+        return false;
+    if (visited.has(value))
+        return false;
+    visited.add(value);
+    if (Reflect.get(value, "type") == "UnaryExpression" && Reflect.get(value, "operator") == "-")
+        return true;
+    if (Reflect.get(value, "type") == "BinaryExpression" && Reflect.get(value, "operator") == "*")
+        return true;
+    return Object.entries(value).some(([key, child]) => !["extra", "innerComments", "leadingComments", "loc", "trailingComments"].includes(key) &&
+        (Array.isArray(child)
+            ? child.some((item) => parserTreeRequiresCanonicalZero(item, visited))
+            : parserTreeRequiresCanonicalZero(child, visited)));
+}
+/**
+ * Recognizes the parser-owned receiver parentheses emitted only for canonical integer output.
+ * @param {import("@babel/types").Expression | import("@babel/types").Super} receiver - Qualified-call receiver.
+ * @param {import("@babel/types").CallExpression} call - Outer `toString` call.
+ * @returns {boolean} Whether the receiver has the generated wrapper shape.
+ */
+function hasCanonicalZeroReceiverWrapper(receiver, call) {
+    const extra = Reflect.get(receiver, "extra");
+    const expressionParentheses = ["BinaryExpression", "LogicalExpression", "UnaryExpression"].includes(receiver.type) ? 1 : 0;
+    const wrapperParentheses = expressionParentheses + 1;
+    const property = call.callee.type == "MemberExpression" ? call.callee.property : undefined;
+    return Boolean(extra) && typeof extra == "object" && Reflect.get(extra, "parenthesized") === true &&
+        Reflect.get(extra, "parenStart") === call.start && typeof call.start == "number" && typeof call.end == "number" &&
+        typeof receiver.start == "number" && typeof receiver.end == "number" && property?.type == "Identifier" &&
+        typeof property.start == "number" && typeof property.end == "number" && call.callee.start === call.start &&
+        receiver.start == call.start + wrapperParentheses && property.start == receiver.end + wrapperParentheses + 1 &&
+        property.end == property.start + "toString".length && call.end == property.end + 2;
+}
+/**
+ * Converts a console.log entry-point call.
+ * @param {import("@babel/types").Statement} node - Babel statement.
+ * @param {"javascript" | "typescript"} language - Frontend language.
+ * @param {string} filename - Source filename.
+ * @param {string} source - Complete source.
+ * @param {boolean} canonicalZeroRequired - Whether this parsed module contains a sign-producing integer operation.
+ * @returns {import("../semantic/types.js").PrintStatement} Print statement.
+ */
+function convertPrint(node, language, filename, source, canonicalZeroRequired) {
+    const location = nodeLocation(node, filename, source);
+    if (node.type != "ExpressionStatement" || node.expression.type != "CallExpression") {
+        return unsupportedSyntax(language, node.type, location);
+    }
+    const call = node.expression;
+    const callee = call.callee;
+    if (callee.type != "MemberExpression" || callee.computed || callee.object.type != "Identifier" ||
+        callee.object.name != "console" || callee.property.type != "Identifier" || callee.property.name != "log" ||
+        call.arguments.length != 1) {
+        return unsupportedSyntax(language, "entry-point expression", location);
+    }
+    let argument = call.arguments[0];
+    if (argument.type == "SpreadElement" || argument.type == "ArgumentPlaceholder") {
+        return unsupportedSyntax(language, argument.type, nodeLocation(argument, filename, source));
+    }
+    if (argument.type == "CallExpression" && argument.callee.type == "MemberExpression" && !argument.callee.computed &&
+        !argument.callee.optional && argument.callee.object.type != "Super" && argument.callee.property.type == "Identifier" &&
+        argument.callee.property.name == "toString" && !argument.optional && !argument.typeArguments &&
+        !argument.typeParameters && argument.arguments.length == 0) {
+        if (!canonicalZeroRequired || !hasCanonicalZeroReceiverWrapper(argument.callee.object, argument)) {
+            return unsupportedSyntax(language, "entry-point qualified call", nodeLocation(argument.callee.property, filename, source));
+        }
+        argument = argument.callee.object;
+    }
+    return { expression: convertExpression(argument, language, filename, source), kind: "PrintStatement", location };
+}
+/**
+ * Parses JavaScript or TypeScript into the shared semantic module.
+ * @param {object} input - Parser input.
+ * @param {string} input.filename - Source filename.
+ * @param {"javascript" | "typescript"} input.language - Frontend language.
+ * @param {string} input.source - Source text.
+ * @returns {import("../semantic/types.js").SemanticModule} Semantic module.
+ */
+export function parseJavaScriptTypeScript({ filename, language, source }) {
+    const file = parseBabelSource({ filename, language, source });
+    const tokens = file.tokens ?? [];
+    const tokenIndex = { byStart: new Map(tokens.map((token) => [token.start, token])), tokens };
+    const canonicalZeroRequired = parserTreeRequiresCanonicalZero(file.program);
+    rememberTokens(file, tokenIndex);
+    if (file.program.directives.length > 0) {
+        return unsupportedSyntax(language, "top-level directive", nodeLocation(file.program.directives[0], filename, source));
+    }
+    const functions = file.program.body.filter((node) => node.type == "FunctionDeclaration")
+        .map((node) => convertFunction(node, language, filename, source, canonicalZeroRequired));
+    const entryNodes = file.program.body.filter((node) => node.type != "FunctionDeclaration");
+    const location = moduleLocation(filename, source);
+    if (functions.length == 0)
+        return unsupportedSyntax(language, "module without a function", location);
+    const entryLocation = entryNodes.length == 0 ? location : locationFromOffsets(filename, source, entryNodes[0].start ?? 0, entryNodes.at(-1)?.end ?? source.length);
+    const entryBlock = convertBlock(entryNodes, language, filename, source, canonicalZeroRequired, entryLocation);
+    return {
+        entryPoint: {
+            body: entryBlock,
+            kind: "EntryPoint",
+            location: entryLocation
+        },
+        functions,
+        kind: "Module",
+        location
+    };
+}
+/**
+ * Invokes Babel and normalizes syntax failures.
+ * @param {object} input - Parser input.
+ * @param {string} input.filename - Source filename.
+ * @param {"javascript" | "typescript"} input.language - Frontend language.
+ * @param {string} input.source - Source text.
+ * @returns {import("@babel/parser").ParseResult<import("@babel/types").File>} Babel file.
+ */
+function parseBabelSource({ filename, language, source }) {
+    try {
+        return parseBabel(source, {
+            plugins: language == "typescript" ? ["typescript"] : [],
+            sourceFilename: filename,
+            sourceType: "script",
+            tokens: true
+        });
+    }
+    catch (error) {
+        return parseFailure(language, error);
+    }
+}
+/**
+ * Associates Babel nodes with their parser token stream without leaking it into semantic values.
+ * @param {object} value - Current parser value.
+ * @param {BabelTokenIndex} tokens - Indexed parser tokens.
+ * @param {WeakSet<object>} [visited] - Cycle protection.
+ * @returns {void}
+ */
+function rememberTokens(value, tokens, visited = new WeakSet()) {
+    if (visited.has(value))
+        return;
+    visited.add(value);
+    nodeTokens.set(value, tokens);
+    for (const child of Object.values(value)) {
+        if (Array.isArray(child)) {
+            for (const item of child)
+                if (item && typeof item == "object")
+                    rememberTokens(item, tokens, visited);
+        }
+        else if (child && typeof child == "object")
+            rememberTokens(child, tokens, visited);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"javascript-typescript.js","sourceRoot":"","sources":["../../../src/frontends/javascript-typescript.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {parse as parseBabel} from \"@babel/parser\"\nimport {parse as parseComment} from \"comment-parser\"\nimport {missingType, parseFailure, unsupportedSyntax} from \"../diagnostic.js\"\nimport {locationFromOffsets, moduleLocation} from \"../semantic/location.js\"\nimport {withAdaptedOperation} from \"../semantic/operators.js\"\nimport {withParserRanges} from \"../semantic/provenance.js\"\nimport {hasOnlyUnicodeScalars} from \"../semantic/scalars.js\"\nimport {requireSourceScalarType} from \"./scalars.js\"\n\n/** @typedef {NonNullable<import(\"@babel/parser\").ParseResult<import(\"@babel/types\").File>[\"tokens\"]>[number]} BabelToken */\n/** @typedef {{byStart: Map<number, BabelToken>, tokens: BabelToken[]}} BabelTokenIndex */\n\n/** @type {WeakMap<object, BabelTokenIndex>} */\nconst nodeTokens = new WeakMap()\nconst babelBinaryOperations = new Map([\n  [\"+\", \"Add\"],\n  [\"-\", \"Subtract\"],\n  [\"*\", \"Multiply\"],\n  [\"===\", \"Equal\"],\n  [\"!==\", \"NotEqual\"],\n  [\"<\", \"LessThan\"],\n  [\"<=\", \"LessThanOrEqual\"],\n  [\">\", \"GreaterThan\"],\n  [\">=\", \"GreaterThanOrEqual\"]\n])\n\n/**\n * Returns a source location for a Babel node.\n * @param {import(\"@babel/types\").Node} node - Babel node.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").SourceLocation} Normalized location.\n */\nfunction nodeLocation(node, filename, source) {\n  if (typeof node.start != \"number\" || typeof node.end != \"number\") {\n    throw new Error(`Babel omitted source offsets for ${node.type}.`)\n  }\n\n  return locationFromOffsets(filename, source, node.start, node.end)\n}\n\n/**\n * Returns the identifier spelling rather than a trailing TypeScript annotation.\n * @param {import(\"@babel/types\").Identifier} node - Parser identifier.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").SourceLocation} Identifier location.\n */\nfunction identifierLocation(node, filename, source) {\n  if (typeof node.start != \"number\") throw new Error(\"Babel omitted an identifier start offset.\")\n  const token = nodeTokens.get(node)?.byStart.get(node.start)\n\n  if (!token || token.type.label != \"name\") throw new Error(`Babel omitted the identifier token for '${node.name}'.`)\n\n  return locationFromOffsets(filename, source, token.start, token.end)\n}\n\n/**\n * Locates one Babel token within parser-node boundaries.\n * @param {import(\"@babel/types\").Node} owner - Token-owning parser node.\n * @param {string} value - Exact token spelling.\n * @param {number} startOffset - Inclusive boundary.\n * @param {number} endOffset - Exclusive boundary.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").SourceLocation} Exact token location.\n */\nfunction tokenLocation(owner, value, startOffset, endOffset, filename, source) {\n  const tokens = nodeTokens.get(owner)?.tokens ?? []\n  let low = 0\n  let high = tokens.length\n\n  while (low < high) {\n    const middle = Math.floor((low + high) / 2)\n\n    if (tokens[middle].start < startOffset) low = middle + 1\n    else high = middle\n  }\n  let token\n\n  for (let index = low; index < tokens.length && tokens[index].start < endOffset; index++) {\n    const candidate = tokens[index]\n\n    if (candidate.end <= endOffset && (candidate.value == value || candidate.type.label == value)) {\n      token = candidate\n      break\n    }\n  }\n\n  if (!token) throw new Error(`Babel omitted token '${value}' between ${startOffset} and ${endOffset}.`)\n\n  return locationFromOffsets(filename, source, token.start, token.end)\n}\n\n/**\n * Locates a comment-parser token inside a Babel-owned doc comment.\n * @param {import(\"@babel/types\").CommentBlock} comment - Babel doc comment.\n * @param {import(\"comment-parser\").Spec} tag - Parsed doc tag.\n * @param {\"name\" | \"type\"} field - Token field.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").SourceLocation} Exact token location.\n */\nfunction commentTagLocation(comment, tag, field, filename, source) {\n  const line = tag.source[0]\n\n  if (typeof comment.start != \"number\" || !line) throw new Error(`Comment parser omitted the @${tag.tag} source token.`)\n\n  let lineStart = comment.start\n\n  for (let lineNumber = 0; lineNumber < line.number; lineNumber++) {\n    while (lineStart < source.length && source[lineStart] != \"\\r\" && source[lineStart] != \"\\n\") lineStart++\n    if (source[lineStart] == \"\\r\" && source[lineStart + 1] == \"\\n\") lineStart += 2\n    else lineStart++\n  }\n\n  const orderedFields = [\"start\", \"delimiter\", \"postDelimiter\", \"tag\", \"postTag\", \"type\", \"postType\", \"name\"]\n  const fieldIndex = orderedFields.indexOf(field)\n  const start = lineStart + orderedFields.slice(0, fieldIndex).reduce((length, key) =>\n    length + line.tokens[/** @type {keyof typeof line.tokens} */ (key)].length, 0)\n  const token = line.tokens[field]\n\n  return locationFromOffsets(filename, source, start, start + token.length)\n}\n\n/**\n * Converts a supported Babel expression.\n * @param {import(\"@babel/types\").Expression} node - Babel expression.\n * @param {\"javascript\" | \"typescript\"} language - Frontend language.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").Expression} Semantic expression.\n */\nfunction convertExpression(node, language, filename, source) {\n  const location = nodeLocation(node, filename, source)\n\n  if (node.type == \"Identifier\") {\n    return withParserRanges({kind: /** @type {const} */ (\"IdentifierExpression\"), location, name: node.name}, {\n      name: identifierLocation(node, filename, source)\n    })\n  }\n\n  if (node.type == \"NumericLiteral\") {\n    if (!Number.isSafeInteger(node.value)) return unsupportedSyntax(language, \"non-safe integer literal\", location)\n\n    return withParserRanges({kind: /** @type {const} */ (\"IntegerLiteral\"), location, value: node.value}, {literal: location})\n  }\n\n  if (node.type == \"BooleanLiteral\") {\n    if (typeof node.value != \"boolean\") return unsupportedSyntax(language, \"invalid boolean literal value\", location)\n\n    return withParserRanges({kind: /** @type {const} */ (\"BooleanLiteral\"), location, value: node.value}, {literal: location})\n  }\n\n  if (node.type == \"StringLiteral\") {\n    if (typeof node.value != \"string\" || !hasOnlyUnicodeScalars(node.value)) {\n      return unsupportedSyntax(language, \"invalid Unicode string literal\", location)\n    }\n\n    return withParserRanges({kind: /** @type {const} */ (\"StringLiteral\"), location, value: node.value}, {literal: location})\n  }\n\n  if (node.type == \"TemplateLiteral\") {\n    if (node.expressions.length > 0) return unsupportedSyntax(language, \"interpolated string\", location)\n\n    const quasi = node.quasis[0]\n\n    if (typeof quasi.value.cooked != \"string\" || !hasOnlyUnicodeScalars(quasi.value.cooked)) {\n      return unsupportedSyntax(language, \"invalid Unicode string literal\", location)\n    }\n\n    return withParserRanges({kind: /** @type {const} */ (\"StringLiteral\"), location, value: quasi.value.cooked}, {literal: location})\n  }\n\n  if (node.type == \"UnaryExpression\" && [\"!\", \"-\"].includes(node.operator)) {\n    const operand = convertExpression(node.argument, language, filename, source)\n    const semantic = withAdaptedOperation(withParserRanges({\n      kind: \"UnaryExpression\",\n      location,\n      operand\n    }, {\n      operator: tokenLocation(node, node.operator, node.start ?? 0, node.argument.start ?? node.end ?? source.length, filename, source)\n    }), node.operator == \"!\" ? \"Not\" : \"Negate\")\n\n    return /** @type {import(\"../semantic/types.js\").Expression} */ (/** @type {unknown} */ (semantic))\n  }\n\n  if (node.type == \"LogicalExpression\" && [\"&&\", \"||\"].includes(node.operator)) {\n    const semantic = withAdaptedOperation(withParserRanges({\n      kind: \"BinaryExpression\",\n      left: convertExpression(node.left, language, filename, source),\n      location,\n      right: convertExpression(node.right, language, filename, source)\n    }, {\n      operator: tokenLocation(node, node.operator, node.left.end ?? node.start ?? 0, node.right.start ?? node.end ?? source.length, filename, source)\n    }), node.operator == \"&&\" ? \"And\" : \"Or\")\n\n    return /** @type {import(\"../semantic/types.js\").Expression} */ (/** @type {unknown} */ (semantic))\n  }\n\n  if (node.type == \"BinaryExpression\" && babelBinaryOperations.has(node.operator)) {\n    if (node.left.type == \"PrivateName\") unsupportedSyntax(language, node.left.type, location)\n\n    const left = convertExpression(node.left, language, filename, source)\n    const right = convertExpression(node.right, language, filename, source)\n\n    const semantic = withAdaptedOperation(withParserRanges({\n      kind: \"BinaryExpression\",\n      left,\n      location,\n      right\n    }, {\n      operator: tokenLocation(node, node.operator, node.left.end ?? node.start ?? 0, node.right.start ?? node.end ?? source.length, filename, source)\n    }), /** @type {import(\"../semantic/operators.js\").AdaptedOperation} */ (babelBinaryOperations.get(node.operator)))\n\n    return /** @type {import(\"../semantic/types.js\").Expression} */ (/** @type {unknown} */ (semantic))\n  }\n\n  if (node.type == \"BinaryExpression\" && [\"==\", \"!=\"].includes(node.operator)) {\n    return unsupportedSyntax(language, `coercive equality ${node.operator}`, location)\n  }\n\n  if (node.type == \"CallExpression\" && node.callee.type == \"Identifier\") {\n    const arguments_ = node.arguments.map((argument) => {\n      if (argument.type == \"SpreadElement\" || argument.type == \"ArgumentPlaceholder\") {\n        return unsupportedSyntax(language, argument.type, nodeLocation(argument, filename, source))\n      }\n\n      return convertExpression(argument, language, filename, source)\n    })\n\n    return withParserRanges({arguments: arguments_, callee: node.callee.name, kind: /** @type {const} */ (\"CallExpression\"), location}, {\n      callee: identifierLocation(node.callee, filename, source)\n    })\n  }\n\n  return unsupportedSyntax(language, node.type, location)\n}\n\n/**\n * Converts a supported return statement.\n * @param {import(\"@babel/types\").Statement} node - Babel statement.\n * @param {\"javascript\" | \"typescript\"} language - Frontend language.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").ReturnStatement} Semantic return.\n */\nfunction convertReturn(node, language, filename, source) {\n  const location = nodeLocation(node, filename, source)\n\n  if (node.type != \"ReturnStatement\" || !node.argument) return unsupportedSyntax(language, node.type, location)\n\n  return {expression: convertExpression(node.argument, language, filename, source), kind: \"ReturnStatement\", location}\n}\n\n/**\n * Converts one supported local declaration or assignment.\n * @param {import(\"@babel/types\").Statement} node - Babel statement.\n * @param {\"javascript\" | \"typescript\"} language - Frontend language.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").LocalStatement} Semantic local statement.\n */\nfunction convertLocalStatement(node, language, filename, source) {\n  const location = nodeLocation(node, filename, source)\n\n  if (node.type == \"VariableDeclaration\") {\n    if (![\"let\", \"const\"].includes(node.kind) || node.declarations.length != 1) {\n      return unsupportedSyntax(language, `${node.kind} declaration`, location)\n    }\n\n    const declarator = node.declarations[0]\n    const declaratorLocation = nodeLocation(declarator, filename, source)\n\n    if (declarator.id.type != \"Identifier\") return unsupportedSyntax(language, declarator.id.type, declaratorLocation)\n    if (!declarator.init) return unsupportedSyntax(language, \"uninitialized declaration\", declaratorLocation)\n\n    const type = language == \"typescript\"\n      ? convertTypeScriptType(declarator.id.typeAnnotation, `Local '${declarator.id.name}'`, declaratorLocation, filename, source)\n      : localJavaScriptType(node, declarator.id.name, filename, source)\n\n    return withParserRanges({\n      initializer: convertExpression(declarator.init, language, filename, source),\n      kind: \"LocalDeclaration\",\n      location,\n      mutable: node.kind == \"let\",\n      name: declarator.id.name,\n      type\n    }, {\n      name: identifierLocation(declarator.id, filename, source),\n      operator: tokenLocation(declarator, \"=\", declarator.id.end ?? declarator.start ?? 0, declarator.init.start ?? declarator.end ?? source.length, filename, source)\n    })\n  }\n\n  if (node.type == \"ExpressionStatement\" && node.expression.type == \"AssignmentExpression\") {\n    const assignment = node.expression\n    const targetLocation = nodeLocation(assignment.left, filename, source)\n\n    if (assignment.operator != \"=\") return unsupportedSyntax(language, `assignment ${assignment.operator}`, location)\n    if (assignment.left.type != \"Identifier\") return unsupportedSyntax(language, assignment.left.type, targetLocation)\n\n    const target = withParserRanges({kind: /** @type {const} */ (\"IdentifierExpression\"), location: targetLocation, name: assignment.left.name}, {\n      name: identifierLocation(assignment.left, filename, source)\n    })\n\n    return withParserRanges({\n      expression: convertExpression(assignment.right, language, filename, source),\n      kind: \"AssignmentStatement\",\n      location,\n      target\n    }, {\n      operator: tokenLocation(assignment, \"=\", assignment.left.end ?? assignment.start ?? 0, assignment.right.start ?? assignment.end ?? source.length, filename, source)\n    })\n  }\n\n  return unsupportedSyntax(language, node.type, location)\n}\n\n/**\n * Reads an immediately associated JavaScript local `@type` tag.\n * @param {import(\"@babel/types\").VariableDeclaration} node - Local declaration.\n * @param {string} name - Local name.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").TypeReference} Semantic type.\n */\nfunction localJavaScriptType(node, name, filename, source) {\n  const comment = node.leadingComments?.at(-1)\n  const location = nodeLocation(node, filename, source)\n\n  if (!comment || comment.type != \"CommentBlock\" || !comment.value.startsWith(\"*\")) {\n    return missingType(\"javascript\", `Local '${name}'`, location)\n  }\n\n  const gap = source.slice(comment.end ?? 0, node.start ?? 0)\n\n  if (!/^\\s*$/u.test(gap) || (gap.match(/\\n/gu)?.length ?? 0) > 1) {\n    return missingType(\"javascript\", `Local '${name}'`, location)\n  }\n\n  const block = parseComment(`/*${comment.value}*/`)[0]\n  const tags = block?.tags.filter((tag) => tag.tag == \"type\") ?? []\n\n  const tag = tags.length == 1 ? tags[0] : undefined\n\n  return convertType(\n    tag?.type,\n    \"javascript\",\n    `Local '${name}'`,\n    location,\n    tag ? commentTagLocation(comment, tag, \"type\", filename, source) : location\n  )\n}\n\n/**\n * Converts one exhaustive Babel statement.\n * @param {import(\"@babel/types\").Statement} node - Babel statement.\n * @param {\"javascript\" | \"typescript\"} language - Frontend language.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @param {boolean} canonicalZeroRequired - Whether generated scalar output may contain signed zero.\n * @returns {import(\"../semantic/types.js\").Statement} Semantic statement.\n */\nfunction convertStatement(node, language, filename, source, canonicalZeroRequired) {\n  if (node.type == \"ReturnStatement\") return convertReturn(node, language, filename, source)\n  if (node.type == \"IfStatement\") return convertIf(node, language, filename, source, canonicalZeroRequired)\n  if (node.type == \"VariableDeclaration\" || node.type == \"ExpressionStatement\" && node.expression.type == \"AssignmentExpression\") {\n    return convertLocalStatement(node, language, filename, source)\n  }\n  if (node.type == \"ExpressionStatement\") return convertPrint(node, language, filename, source, canonicalZeroRequired)\n\n  return unsupportedSyntax(language, node.type, nodeLocation(node, filename, source))\n}\n\n/**\n * Converts one Babel block or normalized single-statement body.\n * @param {import(\"@babel/types\").BlockStatement | import(\"@babel/types\").Statement[]} input - Parser block or statements.\n * @param {\"javascript\" | \"typescript\"} language - Frontend language.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @param {boolean} canonicalZeroRequired - Whether generated scalar output may contain signed zero.\n * @param {import(\"../semantic/types.js\").SourceLocation} [location] - Location for a statement-array block.\n * @returns {import(\"../semantic/types.js\").Block} Semantic block.\n */\nfunction convertBlock(input, language, filename, source, canonicalZeroRequired, location) {\n  const statements = Array.isArray(input) ? input : input.body\n  const directives = Array.isArray(input) ? [] : input.directives\n  const blockLocation = location ?? nodeLocation(/** @type {import(\"@babel/types\").BlockStatement} */ (input), filename, source)\n\n  if (directives.length > 0) {\n    return unsupportedSyntax(language, \"directive\", nodeLocation(directives[0], filename, source))\n  }\n\n  return {\n    kind: \"Block\",\n    location: blockLocation,\n    statements: statements.map((statement) => convertStatement(statement, language, filename, source, canonicalZeroRequired))\n  }\n}\n\n/**\n * Reads JavaScript JSDoc types from a function.\n * @param {import(\"@babel/types\").FunctionDeclaration} node - Babel function node.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {{parameters: Map<string, {location: import(\"../semantic/types.js\").SourceLocation, sourceType: string}>, returnType: {location: import(\"../semantic/types.js\").SourceLocation, sourceType: string} | undefined}} Parsed types.\n */\nfunction jsdocTypes(node, filename, source) {\n  const comment = node.leadingComments?.find((candidate) => candidate.type == \"CommentBlock\" && candidate.value.startsWith(\"*\"))\n\n  if (!comment) missingType(\"javascript\", `Function '${node.id?.name ?? \"anonymous\"}'`, nodeLocation(node, filename, source))\n\n  const commentBlock = /** @type {import(\"@babel/types\").CommentBlock} */ (comment)\n  const block = parseComment(`/*${commentBlock.value}*/`)[0]\n  const parameters = new Map(block.tags.filter((tag) => tag.tag == \"param\").map((tag) => [tag.name, {\n    location: commentTagLocation(commentBlock, tag, \"type\", filename, source),\n    sourceType: tag.type\n  }]))\n  const returnTag = block.tags.find((tag) => tag.tag == \"returns\" || tag.tag == \"return\")\n\n  return {\n    parameters,\n    returnType: returnTag ? {location: commentTagLocation(commentBlock, returnTag, \"type\", filename, source), sourceType: returnTag.type} : undefined\n  }\n}\n\n/**\n * Requires a supported JavaScript JSDoc scalar type spelling.\n * @param {string | undefined} sourceType - Source-language type.\n * @param {\"javascript\" | \"typescript\"} language - Frontend language.\n * @param {string} subject - Typed subject.\n * @param {import(\"../semantic/types.js\").SourceLocation} location - Source location.\n * @param {import(\"../semantic/types.js\").SourceLocation} [typeLocation] - Exact type token location.\n * @returns {import(\"../semantic/types.js\").TypeReference} Semantic type.\n */\nfunction convertType(sourceType, language, subject, location, typeLocation = location) {\n  return requireSourceScalarType(language, sourceType, subject, location, typeLocation)\n}\n\n/**\n * Converts one exact TypeScript scalar keyword annotation.\n * @param {import(\"@babel/types\").TypeAnnotation | import(\"@babel/types\").TSTypeAnnotation | import(\"@babel/types\").Noop | null | undefined} annotation - Type annotation.\n * @param {string} subject - Typed subject.\n * @param {import(\"../semantic/types.js\").SourceLocation} ownerLocation - Owning declaration location.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @returns {import(\"../semantic/types.js\").TypeReference} Semantic scalar type.\n */\nfunction convertTypeScriptType(annotation, subject, ownerLocation, filename, source) {\n  if (!annotation) return missingType(\"typescript\", subject, ownerLocation)\n  if (annotation.type != \"TSTypeAnnotation\") {\n    return unsupportedSyntax(\"typescript\", \"unsupported scalar type\", nodeLocation(annotation, filename, source))\n  }\n\n  const typeNode = annotation.typeAnnotation\n  const sourceType = typeNode.type == \"TSNumberKeyword\"\n    ? \"number\"\n    : typeNode.type == \"TSBooleanKeyword\"\n      ? \"boolean\"\n      : typeNode.type == \"TSStringKeyword\" ? \"string\" : undefined\n\n  if (!sourceType) {\n    return unsupportedSyntax(\"typescript\", \"unsupported scalar type\", nodeLocation(typeNode, filename, source))\n  }\n\n  return requireSourceScalarType(\"typescript\", sourceType, subject, ownerLocation, nodeLocation(typeNode, filename, source))\n}\n\n/**\n * Converts a supported function declaration.\n * @param {import(\"@babel/types\").FunctionDeclaration} node - Babel function.\n * @param {\"javascript\" | \"typescript\"} language - Frontend language.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @param {boolean} canonicalZeroRequired - Whether generated scalar output may contain signed zero.\n * @returns {import(\"../semantic/types.js\").FunctionDeclaration} Semantic function.\n */\nfunction convertFunction(node, language, filename, source, canonicalZeroRequired) {\n  const location = nodeLocation(node, filename, source)\n\n  if (!node.id) return unsupportedSyntax(language, \"anonymous function\", location)\n  if (node.async) return unsupportedSyntax(language, \"async function\", location)\n  if (node.generator) return unsupportedSyntax(language, \"generator function\", location)\n\n  const documentedTypes = language == \"javascript\" ? jsdocTypes(node, filename, source) : undefined\n  const parameters = node.params.map((parameter) => {\n    const parameterLocation = nodeLocation(parameter, filename, source)\n\n    if (parameter.type != \"Identifier\") return unsupportedSyntax(language, parameter.type, parameterLocation)\n\n    const documentedType = documentedTypes?.parameters.get(parameter.name)\n    const type = language == \"javascript\"\n      ? convertType(documentedType?.sourceType, language, `Parameter '${parameter.name}'`, parameterLocation, documentedType?.location)\n      : convertTypeScriptType(parameter.typeAnnotation, `Parameter '${parameter.name}'`, parameterLocation, filename, source)\n\n    return withParserRanges({\n      kind: /** @type {const} */ (\"Parameter\"),\n      location: parameterLocation,\n      name: parameter.name,\n      type\n    }, {name: identifierLocation(parameter, filename, source)})\n  })\n  const returnAnnotation = node.returnType\n  const returnType = language == \"javascript\"\n    ? convertType(documentedTypes?.returnType?.sourceType, language, `Function '${node.id.name}' return`, location, documentedTypes?.returnType?.location)\n    : convertTypeScriptType(returnAnnotation, `Function '${node.id.name}' return`, location, filename, source)\n  const body = convertBlock(node.body, language, filename, source, canonicalZeroRequired)\n\n  return withParserRanges({\n    body,\n    kind: \"FunctionDeclaration\",\n    location,\n    name: node.id.name,\n    parameters,\n    returnType\n  }, {name: identifierLocation(node.id, filename, source)})\n}\n\n/**\n * Converts the existing exact if/else terminal shape.\n * @param {import(\"@babel/types\").IfStatement} node - Babel if statement.\n * @param {\"javascript\" | \"typescript\"} language - Frontend language.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @param {boolean} canonicalZeroRequired - Whether generated scalar output may contain signed zero.\n * @returns {import(\"../semantic/types.js\").IfStatement} Semantic branch.\n */\nfunction convertIf(node, language, filename, source, canonicalZeroRequired) {\n  const location = nodeLocation(node, filename, source)\n  const consequent = node.consequent.type == \"BlockStatement\"\n    ? convertBlock(node.consequent, language, filename, source, canonicalZeroRequired)\n    : convertBlock([node.consequent], language, filename, source, canonicalZeroRequired, nodeLocation(node.consequent, filename, source))\n  const alternate = node.alternate\n    ? node.alternate.type == \"BlockStatement\"\n      ? convertBlock(node.alternate, language, filename, source, canonicalZeroRequired)\n      : convertBlock([node.alternate], language, filename, source, canonicalZeroRequired, nodeLocation(node.alternate, filename, source))\n    : undefined\n\n  return {\n    ...(alternate ? {alternate} : {}),\n    condition: convertExpression(node.test, language, filename, source),\n    consequent,\n    kind: \"IfStatement\",\n    location\n  }\n}\n\n/**\n * Reports whether Babel parsed an operation that makes generated JavaScript-family scalar output require zero canonicalization.\n * @param {unknown} value - Babel parser subtree.\n * @param {WeakSet<object>} [visited] - Cycle protection.\n * @returns {boolean} Whether the subtree contains integer negation or multiplication syntax.\n */\nfunction parserTreeRequiresCanonicalZero(value, visited = new WeakSet()) {\n  if (!value || typeof value != \"object\") return false\n  if (visited.has(value)) return false\n\n  visited.add(value)\n  if (Reflect.get(value, \"type\") == \"UnaryExpression\" && Reflect.get(value, \"operator\") == \"-\") return true\n  if (Reflect.get(value, \"type\") == \"BinaryExpression\" && Reflect.get(value, \"operator\") == \"*\") return true\n\n  return Object.entries(value).some(([key, child]) =>\n    ![\"extra\", \"innerComments\", \"leadingComments\", \"loc\", \"trailingComments\"].includes(key) &&\n    (Array.isArray(child)\n      ? child.some((item) => parserTreeRequiresCanonicalZero(item, visited))\n      : parserTreeRequiresCanonicalZero(child, visited)))\n}\n\n/**\n * Recognizes the parser-owned receiver parentheses emitted only for canonical integer output.\n * @param {import(\"@babel/types\").Expression | import(\"@babel/types\").Super} receiver - Qualified-call receiver.\n * @param {import(\"@babel/types\").CallExpression} call - Outer `toString` call.\n * @returns {boolean} Whether the receiver has the generated wrapper shape.\n */\nfunction hasCanonicalZeroReceiverWrapper(receiver, call) {\n  const extra = Reflect.get(receiver, \"extra\")\n  const expressionParentheses = [\"BinaryExpression\", \"LogicalExpression\", \"UnaryExpression\"].includes(receiver.type) ? 1 : 0\n  const wrapperParentheses = expressionParentheses + 1\n  const property = call.callee.type == \"MemberExpression\" ? call.callee.property : undefined\n\n  return Boolean(extra) && typeof extra == \"object\" && Reflect.get(extra, \"parenthesized\") === true &&\n    Reflect.get(extra, \"parenStart\") === call.start && typeof call.start == \"number\" && typeof call.end == \"number\" &&\n    typeof receiver.start == \"number\" && typeof receiver.end == \"number\" && property?.type == \"Identifier\" &&\n    typeof property.start == \"number\" && typeof property.end == \"number\" && call.callee.start === call.start &&\n    receiver.start == call.start + wrapperParentheses && property.start == receiver.end + wrapperParentheses + 1 &&\n    property.end == property.start + \"toString\".length && call.end == property.end + 2\n}\n\n/**\n * Converts a console.log entry-point call.\n * @param {import(\"@babel/types\").Statement} node - Babel statement.\n * @param {\"javascript\" | \"typescript\"} language - Frontend language.\n * @param {string} filename - Source filename.\n * @param {string} source - Complete source.\n * @param {boolean} canonicalZeroRequired - Whether this parsed module contains a sign-producing integer operation.\n * @returns {import(\"../semantic/types.js\").PrintStatement} Print statement.\n */\nfunction convertPrint(node, language, filename, source, canonicalZeroRequired) {\n  const location = nodeLocation(node, filename, source)\n\n  if (node.type != \"ExpressionStatement\" || node.expression.type != \"CallExpression\") {\n    return unsupportedSyntax(language, node.type, location)\n  }\n\n  const call = node.expression\n  const callee = call.callee\n\n  if (callee.type != \"MemberExpression\" || callee.computed || callee.object.type != \"Identifier\" ||\n    callee.object.name != \"console\" || callee.property.type != \"Identifier\" || callee.property.name != \"log\" ||\n    call.arguments.length != 1) {\n    return unsupportedSyntax(language, \"entry-point expression\", location)\n  }\n\n  let argument = call.arguments[0]\n\n  if (argument.type == \"SpreadElement\" || argument.type == \"ArgumentPlaceholder\") {\n    return unsupportedSyntax(language, argument.type, nodeLocation(argument, filename, source))\n  }\n\n  if (argument.type == \"CallExpression\" && argument.callee.type == \"MemberExpression\" && !argument.callee.computed &&\n    !argument.callee.optional && argument.callee.object.type != \"Super\" && argument.callee.property.type == \"Identifier\" &&\n    argument.callee.property.name == \"toString\" && !argument.optional && !argument.typeArguments &&\n    !argument.typeParameters && argument.arguments.length == 0) {\n    if (!canonicalZeroRequired || !hasCanonicalZeroReceiverWrapper(argument.callee.object, argument)) {\n      return unsupportedSyntax(language, \"entry-point qualified call\", nodeLocation(argument.callee.property, filename, source))\n    }\n    argument = argument.callee.object\n  }\n\n  return {expression: convertExpression(argument, language, filename, source), kind: \"PrintStatement\", location}\n}\n\n/**\n * Parses JavaScript or TypeScript into the shared semantic module.\n * @param {object} input - Parser input.\n * @param {string} input.filename - Source filename.\n * @param {\"javascript\" | \"typescript\"} input.language - Frontend language.\n * @param {string} input.source - Source text.\n * @returns {import(\"../semantic/types.js\").SemanticModule} Semantic module.\n */\nexport function parseJavaScriptTypeScript({filename, language, source}) {\n  const file = parseBabelSource({filename, language, source})\n  const tokens = file.tokens ?? []\n  const tokenIndex = {byStart: new Map(tokens.map((token) => [token.start, token])), tokens}\n  const canonicalZeroRequired = parserTreeRequiresCanonicalZero(file.program)\n\n  rememberTokens(file, tokenIndex)\n  if (file.program.directives.length > 0) {\n    return unsupportedSyntax(language, \"top-level directive\", nodeLocation(file.program.directives[0], filename, source))\n  }\n  const functions = file.program.body.filter((node) => node.type == \"FunctionDeclaration\")\n    .map((node) => convertFunction(node, language, filename, source, canonicalZeroRequired))\n  const entryNodes = file.program.body.filter((node) => node.type != \"FunctionDeclaration\")\n  const location = moduleLocation(filename, source)\n\n  if (functions.length == 0) return unsupportedSyntax(language, \"module without a function\", location)\n  const entryLocation = entryNodes.length == 0 ? location : locationFromOffsets(\n    filename,\n    source,\n    entryNodes[0].start ?? 0,\n    entryNodes.at(-1)?.end ?? source.length\n  )\n  const entryBlock = convertBlock(entryNodes, language, filename, source, canonicalZeroRequired, entryLocation)\n\n  return {\n    entryPoint: {\n      body: entryBlock,\n      kind: \"EntryPoint\",\n      location: entryLocation\n    },\n    functions,\n    kind: \"Module\",\n    location\n  }\n}\n\n/**\n * Invokes Babel and normalizes syntax failures.\n * @param {object} input - Parser input.\n * @param {string} input.filename - Source filename.\n * @param {\"javascript\" | \"typescript\"} input.language - Frontend language.\n * @param {string} input.source - Source text.\n * @returns {import(\"@babel/parser\").ParseResult<import(\"@babel/types\").File>} Babel file.\n */\nfunction parseBabelSource({filename, language, source}) {\n  try {\n    return parseBabel(source, {\n      plugins: language == \"typescript\" ? [\"typescript\"] : [],\n      sourceFilename: filename,\n      sourceType: \"script\",\n      tokens: true\n    })\n  } catch (error) {\n    return parseFailure(language, error)\n  }\n}\n\n/**\n * Associates Babel nodes with their parser token stream without leaking it into semantic values.\n * @param {object} value - Current parser value.\n * @param {BabelTokenIndex} tokens - Indexed parser tokens.\n * @param {WeakSet<object>} [visited] - Cycle protection.\n * @returns {void}\n */\nfunction rememberTokens(value, tokens, visited = new WeakSet()) {\n  if (visited.has(value)) return\n\n  visited.add(value)\n  nodeTokens.set(value, tokens)\n\n  for (const child of Object.values(value)) {\n    if (Array.isArray(child)) {\n      for (const item of child) if (item && typeof item == \"object\") rememberTokens(item, tokens, visited)\n    } else if (child && typeof child == \"object\") rememberTokens(child, tokens, visited)\n  }\n}\n"]}