semantifold 0.1.1 → 0.3.0

package/build/src/backends/ordered-expressions.js

@@ -0,0 +1,159 @@
+// @ts-check
+import { createHash } from "node:crypto";
+import { unsupportedCapability } from "../diagnostic.js";
+/** @typedef {import("../semantic/types.js").Expression} Expression */
+/** @typedef {import("../semantic/types.js").SemanticTypeName} Scalar */
+/** @typedef {{expression: Expression, path: string, type: Scalar, name?: string}} PlannedValue */
+/** @typedef {{result: PlannedValue, operands: PlannedValue[], rightSteps?: PlannedStep[]}} PlannedStep */
+/** @typedef {Array<string | number | boolean | Signature>} Signature */
+/** Private occurrence-based native expression sequencer; it never rewrites the IR. */
+export class OrderedExpressionPlanner {
+    /**
+     * Indexes already validated callable return types.
+     * @param {import("../semantic/types.js").SemanticModule} module - Validated module.
+     * @param {"c" | "cpp"} [language] - Owning backend diagnostic language.
+     */
+    constructor(module, language = "c") {
+        this.language = language;
+        this.functions = new Map(module.functions.map((declaration) => [declaration.name, declaration.returnType.name]));
+        this.nextTemporary = 1;
+    }
+    /**
+     * Resolves an expression type from the validated lexical environment.
+     * @param {Expression} expression - Semantic expression.
+     * @param {Map<string, Scalar>} bindings - Lexical scalar types.
+     * @returns {Scalar} Exact semantic result type.
+     */
+    type(expression, bindings) {
+        if (expression.kind == "IntegerLiteral")
+            return "integer";
+        if (expression.kind == "BooleanLiteral")
+            return "boolean";
+        if (expression.kind == "StringLiteral")
+            return "string";
+        if (expression.kind == "UnaryExpression" || expression.kind == "BinaryExpression")
+            return expression.type;
+        const type = expression.kind == "CallExpression" ? this.functions.get(expression.callee) : bindings.get(expression.name);
+        if (!type)
+            return unsupportedCapability(this.language, "unresolved expression type", expression.location);
+        return type;
+    }
+    /**
+     * Plans one expression in semantic order, keeping the short-circuit RHS conditional.
+     * @param {Expression} expression - Original occurrence.
+     * @param {string} path - Occurrence path.
+     * @param {Map<string, Scalar>} bindings - Lexical types.
+     * @param {PlannedStep[]} steps - Enclosing ordered prelude.
+     * @returns {PlannedValue} Pure final value.
+     */
+    plan(expression, path, bindings, steps) {
+        const result = { expression, path, type: this.type(expression, bindings) };
+        if (!["CallExpression", "UnaryExpression", "BinaryExpression"].includes(expression.kind))
+            return result;
+        const operands = [];
+        /** @type {PlannedStep[] | undefined} */
+        let rightSteps;
+        if (expression.kind == "CallExpression") {
+            for (const [index, argument] of expression.arguments.entries())
+                operands.push(this.plan(argument, `${path}/arguments/${index}`, bindings, steps));
+        }
+        else if (expression.kind == "UnaryExpression")
+            operands.push(this.plan(expression.operand, `${path}/operand`, bindings, steps));
+        else if (expression.kind == "BinaryExpression") {
+            operands.push(this.plan(expression.left, `${path}/left`, bindings, steps));
+            if (expression.operation == "BooleanAnd" || expression.operation == "BooleanOr") {
+                const planned = { ...result, name: this.allocate(expression) };
+                rightSteps = [];
+                operands.push(this.plan(expression.right, `${path}/right`, bindings, rightSteps));
+                steps.push({ operands, result: planned, rightSteps });
+                return planned;
+            }
+            operands.push(this.plan(expression.right, `${path}/right`, bindings, steps));
+        }
+        const planned = { ...result, name: this.allocate(expression) };
+        steps.push({ operands, result: planned });
+        return planned;
+    }
+    /**
+     * Allocates one bounded deterministic occurrence name.
+     * @param {Expression} expression - Related expression.
+     * @returns {string} Reserved temporary name.
+     */
+    allocate(expression) {
+        if (this.nextTemporary > 999999)
+            return unsupportedCapability(this.language, "ordered-expression occurrence limit", expression.location);
+        return `semantifold_ordered_${String(this.nextTemporary++).padStart(6, "0")}`;
+    }
+}
+/**
+ * Binds a region marker to its semantic consumer and expression, independently of locations.
+ * The digest detects edits; structural CST validation remains mandatory and authoritative.
+ * @param {import("../semantic/types.js").Statement} statement - Reconstructed or original statement.
+ * @returns {string} Stable SHA-256 profile signature.
+ */
+export function statementSignature(statement) {
+    const consumer = statement.kind == "LocalDeclaration" ? [statement.kind, statement.name, statement.type.name, statement.mutable] :
+        statement.kind == "AssignmentStatement" ? [statement.kind, statement.target.name] : [statement.kind];
+    const expression = statement.kind == "IfStatement" ? statement.condition : statement.kind == "LocalDeclaration" ? statement.initializer : statement.expression;
+    return createHash("sha256").update(JSON.stringify([consumer, expressionSignature(expression)])).digest("hex");
+}
+/**
+ * Serializes only the closed semantic expression fields.
+ * @param {Expression} expression - Expression occurrence.
+ * @returns {Signature} Signature data.
+ */
+function expressionSignature(expression) {
+    if (expression.kind == "IdentifierExpression")
+        return [expression.kind, expression.name];
+    if (expression.kind == "IntegerLiteral" || expression.kind == "BooleanLiteral" || expression.kind == "StringLiteral")
+        return [expression.kind, expression.value];
+    if (expression.kind == "CallExpression")
+        return [expression.kind, expression.callee, ...expression.arguments.map(expressionSignature)];
+    if (expression.kind == "UnaryExpression")
+        return [expression.kind, expression.operation, expression.type, expressionSignature(expression.operand)];
+    return [expression.kind, expression.operation, expression.type, expressionSignature(expression.left), expressionSignature(expression.right)];
+}
+/** @typedef {{id: string, steps: PlannedStep[], value: PlannedValue}} StatementPlan */
+/**
+ * Plans every occurrence before constructing a writer or exposing either artifact.
+ * @param {import("../semantic/types.js").SemanticModule} module - Validated module.
+ * @param {"c" | "cpp"} [language] - Native diagnostic owner.
+ * @returns {Map<string, StatementPlan>} Plans indexed by semantic occurrence path.
+ */
+export function planNativeModule(module, language = "c") {
+    const planner = new OrderedExpressionPlanner(module, language);
+    /** @type {Map<string, StatementPlan>} */
+    const plans = new Map();
+    /**
+     * Plans one lexical block with independent branch environments.
+     * @param {import("../semantic/types.js").Block} block - Semantic block.
+     * @param {string} path - Occurrence path.
+     * @param {Map<string, import("../semantic/types.js").SemanticTypeName>} inherited - Visible types.
+     * @returns {void}
+     */
+    function visit(block, path, inherited) {
+        const bindings = new Map(inherited);
+        block.statements.forEach((statement, index) => {
+            const statementPath = `${path}/statements/${index}`;
+            const field = statement.kind == "IfStatement" ? "condition" : statement.kind == "LocalDeclaration" ? "initializer" : "expression";
+            const expression = statement.kind == "IfStatement" ? statement.condition : statement.kind == "LocalDeclaration" ? statement.initializer : statement.expression;
+            /** @type {PlannedStep[]} */
+            const steps = [];
+            const value = planner.plan(expression, `${statementPath}/${field}`, bindings, steps);
+            if (plans.size >= 999999)
+                unsupportedCapability(language, "ordered statement limit", statement.location);
+            plans.set(statementPath, { id: String(plans.size + 1).padStart(6, "0"), steps, value });
+            if (statement.kind == "LocalDeclaration")
+                bindings.set(statement.name, statement.type.name);
+            if (statement.kind == "IfStatement") {
+                visit(statement.consequent, `${statementPath}/consequent`, bindings);
+                if (statement.alternate)
+                    visit(statement.alternate, `${statementPath}/alternate`, bindings);
+            }
+        });
+    }
+    module.functions.forEach((declaration, index) => visit(declaration.body, `/functions/${index}/body`, new Map(declaration.parameters.map((parameter) => [parameter.name, parameter.type.name]))));
+    visit(module.entryPoint.body, "/entryPoint/body", new Map());
+    return plans;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ordered-expressions.js","sourceRoot":"","sources":["../../../src/backends/ordered-expressions.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {createHash} from \"node:crypto\"\nimport {unsupportedCapability} from \"../diagnostic.js\"\n\n/** @typedef {import(\"../semantic/types.js\").Expression} Expression */\n/** @typedef {import(\"../semantic/types.js\").SemanticTypeName} Scalar */\n/** @typedef {{expression: Expression, path: string, type: Scalar, name?: string}} PlannedValue */\n/** @typedef {{result: PlannedValue, operands: PlannedValue[], rightSteps?: PlannedStep[]}} PlannedStep */\n/** @typedef {Array<string | number | boolean | Signature>} Signature */\n\n/** Private occurrence-based native expression sequencer; it never rewrites the IR. */\nexport class OrderedExpressionPlanner {\n  /**\n   * Indexes already validated callable return types.\n   * @param {import(\"../semantic/types.js\").SemanticModule} module - Validated module.\n   * @param {\"c\" | \"cpp\"} [language] - Owning backend diagnostic language.\n   */\n  constructor(module, language = \"c\") {\n    this.language = language\n    this.functions = new Map(module.functions.map((declaration) => [declaration.name, declaration.returnType.name]))\n    this.nextTemporary = 1\n  }\n\n  /**\n   * Resolves an expression type from the validated lexical environment.\n   * @param {Expression} expression - Semantic expression.\n   * @param {Map<string, Scalar>} bindings - Lexical scalar types.\n   * @returns {Scalar} Exact semantic result type.\n   */\n  type(expression, bindings) {\n    if (expression.kind == \"IntegerLiteral\") return \"integer\"\n    if (expression.kind == \"BooleanLiteral\") return \"boolean\"\n    if (expression.kind == \"StringLiteral\") return \"string\"\n    if (expression.kind == \"UnaryExpression\" || expression.kind == \"BinaryExpression\") return expression.type\n    const type = expression.kind == \"CallExpression\" ? this.functions.get(expression.callee) : bindings.get(expression.name)\n\n    if (!type) return unsupportedCapability(this.language, \"unresolved expression type\", expression.location)\n    return type\n  }\n\n  /**\n   * Plans one expression in semantic order, keeping the short-circuit RHS conditional.\n   * @param {Expression} expression - Original occurrence.\n   * @param {string} path - Occurrence path.\n   * @param {Map<string, Scalar>} bindings - Lexical types.\n   * @param {PlannedStep[]} steps - Enclosing ordered prelude.\n   * @returns {PlannedValue} Pure final value.\n   */\n  plan(expression, path, bindings, steps) {\n    const result = {expression, path, type: this.type(expression, bindings)}\n\n    if (![\"CallExpression\", \"UnaryExpression\", \"BinaryExpression\"].includes(expression.kind)) return result\n    const operands = []\n    /** @type {PlannedStep[] | undefined} */\n    let rightSteps\n\n    if (expression.kind == \"CallExpression\") {\n      for (const [index, argument] of expression.arguments.entries()) operands.push(this.plan(argument, `${path}/arguments/${index}`, bindings, steps))\n    } else if (expression.kind == \"UnaryExpression\") operands.push(this.plan(expression.operand, `${path}/operand`, bindings, steps))\n    else if (expression.kind == \"BinaryExpression\") {\n      operands.push(this.plan(expression.left, `${path}/left`, bindings, steps))\n      if (expression.operation == \"BooleanAnd\" || expression.operation == \"BooleanOr\") {\n        const planned = {...result, name: this.allocate(expression)}\n\n        rightSteps = []\n        operands.push(this.plan(expression.right, `${path}/right`, bindings, rightSteps))\n        steps.push({operands, result: planned, rightSteps})\n        return planned\n      }\n      operands.push(this.plan(expression.right, `${path}/right`, bindings, steps))\n    }\n    const planned = {...result, name: this.allocate(expression)}\n\n    steps.push({operands, result: planned})\n    return planned\n  }\n\n  /**\n   * Allocates one bounded deterministic occurrence name.\n   * @param {Expression} expression - Related expression.\n   * @returns {string} Reserved temporary name.\n   */\n  allocate(expression) {\n    if (this.nextTemporary > 999999) return unsupportedCapability(this.language, \"ordered-expression occurrence limit\", expression.location)\n    return `semantifold_ordered_${String(this.nextTemporary++).padStart(6, \"0\")}`\n  }\n}\n\n/**\n * Binds a region marker to its semantic consumer and expression, independently of locations.\n * The digest detects edits; structural CST validation remains mandatory and authoritative.\n * @param {import(\"../semantic/types.js\").Statement} statement - Reconstructed or original statement.\n * @returns {string} Stable SHA-256 profile signature.\n */\nexport function statementSignature(statement) {\n  const consumer = statement.kind == \"LocalDeclaration\" ? [statement.kind, statement.name, statement.type.name, statement.mutable] :\n    statement.kind == \"AssignmentStatement\" ? [statement.kind, statement.target.name] : [statement.kind]\n  const expression = statement.kind == \"IfStatement\" ? statement.condition : statement.kind == \"LocalDeclaration\" ? statement.initializer : statement.expression\n\n  return createHash(\"sha256\").update(JSON.stringify([consumer, expressionSignature(expression)])).digest(\"hex\")\n}\n\n/**\n * Serializes only the closed semantic expression fields.\n * @param {Expression} expression - Expression occurrence.\n * @returns {Signature} Signature data.\n */\nfunction expressionSignature(expression) {\n  if (expression.kind == \"IdentifierExpression\") return [expression.kind, expression.name]\n  if (expression.kind == \"IntegerLiteral\" || expression.kind == \"BooleanLiteral\" || expression.kind == \"StringLiteral\") return [expression.kind, expression.value]\n  if (expression.kind == \"CallExpression\") return [expression.kind, expression.callee, ...expression.arguments.map(expressionSignature)]\n  if (expression.kind == \"UnaryExpression\") return [expression.kind, expression.operation, expression.type, expressionSignature(expression.operand)]\n  return [expression.kind, expression.operation, expression.type, expressionSignature(expression.left), expressionSignature(expression.right)]\n}\n\n/** @typedef {{id: string, steps: PlannedStep[], value: PlannedValue}} StatementPlan */\n/**\n * Plans every occurrence before constructing a writer or exposing either artifact.\n * @param {import(\"../semantic/types.js\").SemanticModule} module - Validated module.\n * @param {\"c\" | \"cpp\"} [language] - Native diagnostic owner.\n * @returns {Map<string, StatementPlan>} Plans indexed by semantic occurrence path.\n */\nexport function planNativeModule(module, language = \"c\") {\n  const planner = new OrderedExpressionPlanner(module, language)\n  /** @type {Map<string, StatementPlan>} */\n  const plans = new Map()\n\n  /**\n   * Plans one lexical block with independent branch environments.\n   * @param {import(\"../semantic/types.js\").Block} block - Semantic block.\n   * @param {string} path - Occurrence path.\n   * @param {Map<string, import(\"../semantic/types.js\").SemanticTypeName>} inherited - Visible types.\n   * @returns {void}\n   */\n  function visit(block, path, inherited) {\n    const bindings = new Map(inherited)\n\n    block.statements.forEach((statement, index) => {\n      const statementPath = `${path}/statements/${index}`\n      const field = statement.kind == \"IfStatement\" ? \"condition\" : statement.kind == \"LocalDeclaration\" ? \"initializer\" : \"expression\"\n      const expression = statement.kind == \"IfStatement\" ? statement.condition : statement.kind == \"LocalDeclaration\" ? statement.initializer : statement.expression\n      /** @type {PlannedStep[]} */\n      const steps = []\n      const value = planner.plan(expression, `${statementPath}/${field}`, bindings, steps)\n\n      if (plans.size >= 999999) unsupportedCapability(language, \"ordered statement limit\", statement.location)\n      plans.set(statementPath, {id: String(plans.size + 1).padStart(6, \"0\"), steps, value})\n      if (statement.kind == \"LocalDeclaration\") bindings.set(statement.name, statement.type.name)\n      if (statement.kind == \"IfStatement\") {\n        visit(statement.consequent, `${statementPath}/consequent`, bindings)\n        if (statement.alternate) visit(statement.alternate, `${statementPath}/alternate`, bindings)\n      }\n    })\n  }\n\n  module.functions.forEach((declaration, index) => visit(declaration.body, `/functions/${index}/body`,\n    new Map(declaration.parameters.map((parameter) => [parameter.name, parameter.type.name]))))\n  visit(module.entryPoint.body, \"/entryPoint/body\", new Map())\n  return plans\n}\n"]}

package/build/src/backends/python.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Emits one deterministic standalone Python program.
+ * @param {import("../semantic/types.js").SemanticModule} module - Semantic module.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @returns {void}
+ */
+export declare function generatePython(module: import("../semantic/types.js").SemanticModule, writer: import("./writer.js").SourceWriter): void;
+//# sourceMappingURL=python.d.ts.map

package/build/src/backends/python.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"python.d.ts","sourceRoot":"","sources":["../../../src/backends/python.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAJ1B,OAAO,sBAAsB,EAAE,cAIL,EAAE,MAAM,EAHlC,OAAO,aAAa,EAAE,YAGY,GAFhC,IAAI,CAsChB"}

package/build/src/backends/python.js

@@ -0,0 +1,162 @@
+// @ts-check
+import { emitExpression } from "./shared.js";
+import { emitScalarType } from "./scalars.js";
+/**
+ * Emits one deterministic standalone Python program.
+ * @param {import("../semantic/types.js").SemanticModule} module - Semantic module.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @returns {void}
+ */
+export function generatePython(module, writer) {
+    module.functions.forEach((declaration, functionIndex) => {
+        if (functionIndex > 0)
+            writer.synthetic("\n\n", "declaration separator", [declaration]);
+        writer.mapped("def", { mappingKind: "anchor", node: declaration });
+        writer.synthetic(" ", "function spacing", [declaration]);
+        writer.mapped(declaration.name, { mappingKind: "exact", node: declaration, role: "name" });
+        writer.mapped("(", { mappingKind: "anchor", node: declaration });
+        declaration.parameters.forEach((parameter, parameterIndex) => {
+            const parameterPath = `/functions/${functionIndex}/parameters/${parameterIndex}`;
+            if (parameterIndex > 0)
+                writer.synthetic(", ", "parameter separator", [declaration]);
+            writer.mapped(parameter.name, { mappingKind: "exact", node: parameter, path: parameterPath, role: "name" });
+            writer.synthetic(": ", "Python annotation separator", [parameter], [parameterPath]);
+            writer.mapped(emitScalarType("python", parameter.type), {
+                mappingKind: "exact",
+                node: parameter.type,
+                path: `${parameterPath}/type`,
+                role: "type"
+            });
+        });
+        writer.mapped(")", { mappingKind: "anchor", node: declaration });
+        writer.synthetic(" -> ", "Python return annotation separator", [declaration]);
+        writer.mapped(emitScalarType("python", declaration.returnType), {
+            mappingKind: "exact",
+            node: declaration.returnType,
+            path: `/functions/${functionIndex}/returnType`,
+            role: "type"
+        });
+        writer.mapped(":", { mappingKind: "anchor", node: declaration });
+        writer.synthetic("\n", "line break", [declaration]);
+        emitBlock(writer, declaration.body, "    ", `/functions/${functionIndex}/body`);
+    });
+    writer.synthetic("\n\n", "entry-point separator", [module.entryPoint]);
+    emitBlock(writer, module.entryPoint.body, "", "/entryPoint/body");
+}
+/**
+ * Emits one Python indentation block, using pass only for an empty semantic block.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @param {import("../semantic/types.js").Block} block - Semantic block.
+ * @param {string} indent - Leading indentation.
+ * @param {string} path - Exact block path.
+ * @returns {void}
+ */
+function emitBlock(writer, block, indent, path) {
+    if (block.statements.length == 0) {
+        writer.synthetic(`${indent}pass\n`, "Python empty block", [block], [path]);
+        return;
+    }
+    block.statements.forEach((statement, index) => emitStatement(writer, statement, indent, `${path}/statements/${index}`));
+}
+/**
+ * Emits one supported Python statement.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @param {import("../semantic/types.js").Statement} statement - Semantic statement.
+ * @param {string} indent - Leading indentation.
+ * @param {string} path - Exact statement path.
+ * @returns {void}
+ */
+function emitStatement(writer, statement, indent, path) {
+    if (statement.kind == "LocalDeclaration" || statement.kind == "AssignmentStatement") {
+        emitLocal(writer, statement, indent, path);
+        return;
+    }
+    if (statement.kind == "IfStatement") {
+        emitIf(writer, statement, indent, path, "if");
+        return;
+    }
+    writer.synthetic(indent, "indentation", [statement], [path]);
+    if (statement.kind == "ReturnStatement") {
+        writer.mapped("return", { mappingKind: "anchor", node: statement, path });
+        writer.synthetic(" ", "return spacing", [statement], [path]);
+        emitExpression(writer, statement.expression, `${path}/expression`, "python", identity);
+        writer.synthetic("\n", "line break", [statement], [path]);
+        return;
+    }
+    writer.mapped("print", { mappingKind: "anchor", node: statement, path });
+    writer.mapped("(", { mappingKind: "anchor", node: statement, path });
+    emitExpression(writer, statement.expression, `${path}/expression`, "python", identity);
+    writer.mapped(")", { mappingKind: "anchor", node: statement, path });
+    writer.synthetic("\n", "line break", [statement], [path]);
+}
+/**
+ * Emits a Python if or elif and its optional alternative.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @param {import("../semantic/types.js").IfStatement} statement - Branch.
+ * @param {string} indent - Leading indentation.
+ * @param {string} path - Exact branch path.
+ * @param {"if" | "elif"} keyword - Branch keyword.
+ * @returns {void}
+ */
+function emitIf(writer, statement, indent, path, keyword) {
+    writer.synthetic(indent, "indentation", [statement], [path]);
+    writer.mapped(keyword, { mappingKind: "anchor", node: statement, path });
+    writer.synthetic(" ", "conditional spacing", [statement], [path]);
+    emitExpression(writer, statement.condition, `${path}/condition`, "python", identity);
+    writer.mapped(":", { mappingKind: "anchor", node: statement.consequent, path: `${path}/consequent` });
+    writer.synthetic("\n", "line break", [statement], [path]);
+    emitBlock(writer, statement.consequent, `${indent}    `, `${path}/consequent`);
+    if (!statement.alternate)
+        return;
+    if (statement.alternate.statements.length == 1 && statement.alternate.statements[0].kind == "IfStatement") {
+        emitIf(writer, statement.alternate.statements[0], indent, `${path}/alternate/statements/0`, "elif");
+        return;
+    }
+    writer.synthetic(indent, "indentation", [statement], [path]);
+    writer.mapped("else", { mappingKind: "anchor", node: statement, path });
+    writer.mapped(":", { mappingKind: "anchor", node: statement.alternate, path: `${path}/alternate` });
+    writer.synthetic("\n", "line break", [statement], [path]);
+    emitBlock(writer, statement.alternate, `${indent}    `, `${path}/alternate`);
+}
+/**
+ * Emits one annotated local declaration or plain assignment.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @param {import("../semantic/types.js").LocalStatement} statement - Local statement.
+ * @param {string} indent - Leading indentation.
+ * @param {string} path - Exact statement path.
+ * @returns {void}
+ */
+function emitLocal(writer, statement, indent, path) {
+    if (statement.kind == "LocalDeclaration" && !statement.mutable) {
+        writer.synthetic(`${indent}# @semantifold-immutable\n`, "Python immutable local carrier", [statement], [path]);
+    }
+    writer.synthetic(indent, "indentation", [statement], [path]);
+    if (statement.kind == "AssignmentStatement") {
+        writer.mapped(statement.target.name, { mappingKind: "exact", node: statement.target, path: `${path}/target`, role: "name" });
+        writer.synthetic(" ", "assignment spacing", [statement], [path]);
+        writer.mapped("=", { mappingKind: "exact", node: statement, path, role: "operator" });
+        writer.synthetic(" ", "assignment spacing", [statement], [path]);
+        emitExpression(writer, statement.expression, `${path}/expression`, "python", identity);
+        writer.synthetic("\n", "line break", [statement], [path]);
+        return;
+    }
+    writer.mapped(statement.name, { mappingKind: "exact", node: statement, path, role: "name" });
+    writer.synthetic(": ", "Python annotation separator", [statement], [path]);
+    writer.mapped(emitScalarType("python", statement.type), {
+        mappingKind: "exact", node: statement.type, path: `${path}/type`, role: "type"
+    });
+    writer.synthetic(" ", "assignment spacing", [statement], [path]);
+    writer.mapped("=", { mappingKind: "exact", node: statement, path, role: "operator" });
+    writer.synthetic(" ", "assignment spacing", [statement], [path]);
+    emitExpression(writer, statement.initializer, `${path}/initializer`, "python", identity);
+    writer.synthetic("\n", "line break", [statement], [path]);
+}
+/**
+ * Returns one unchanged Python identifier.
+ * @param {string} name - Semantic identifier.
+ * @returns {string} Unchanged Python identifier.
+ */
+function identity(name) {
+    return name;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"python.js","sourceRoot":"","sources":["../../../src/backends/python.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {emitExpression} from \"./shared.js\"\nimport {emitScalarType} from \"./scalars.js\"\n\n/**\n * Emits one deterministic standalone Python program.\n * @param {import(\"../semantic/types.js\").SemanticModule} module - Semantic module.\n * @param {import(\"./writer.js\").SourceWriter} writer - Source-aware writer.\n * @returns {void}\n */\nexport function generatePython(module, writer) {\n  module.functions.forEach((declaration, functionIndex) => {\n    if (functionIndex > 0) writer.synthetic(\"\\n\\n\", \"declaration separator\", [declaration])\n\n    writer.mapped(\"def\", {mappingKind: \"anchor\", node: declaration})\n    writer.synthetic(\" \", \"function spacing\", [declaration])\n    writer.mapped(declaration.name, {mappingKind: \"exact\", node: declaration, role: \"name\"})\n    writer.mapped(\"(\", {mappingKind: \"anchor\", node: declaration})\n    declaration.parameters.forEach((parameter, parameterIndex) => {\n      const parameterPath = `/functions/${functionIndex}/parameters/${parameterIndex}`\n\n      if (parameterIndex > 0) writer.synthetic(\", \", \"parameter separator\", [declaration])\n      writer.mapped(parameter.name, {mappingKind: \"exact\", node: parameter, path: parameterPath, role: \"name\"})\n      writer.synthetic(\": \", \"Python annotation separator\", [parameter], [parameterPath])\n      writer.mapped(emitScalarType(\"python\", parameter.type), {\n        mappingKind: \"exact\",\n        node: parameter.type,\n        path: `${parameterPath}/type`,\n        role: \"type\"\n      })\n    })\n    writer.mapped(\")\", {mappingKind: \"anchor\", node: declaration})\n    writer.synthetic(\" -> \", \"Python return annotation separator\", [declaration])\n    writer.mapped(emitScalarType(\"python\", declaration.returnType), {\n      mappingKind: \"exact\",\n      node: declaration.returnType,\n      path: `/functions/${functionIndex}/returnType`,\n      role: \"type\"\n    })\n    writer.mapped(\":\", {mappingKind: \"anchor\", node: declaration})\n    writer.synthetic(\"\\n\", \"line break\", [declaration])\n    emitBlock(writer, declaration.body, \"    \", `/functions/${functionIndex}/body`)\n  })\n\n  writer.synthetic(\"\\n\\n\", \"entry-point separator\", [module.entryPoint])\n  emitBlock(writer, module.entryPoint.body, \"\", \"/entryPoint/body\")\n}\n\n/**\n * Emits one Python indentation block, using pass only for an empty semantic block.\n * @param {import(\"./writer.js\").SourceWriter} writer - Source-aware writer.\n * @param {import(\"../semantic/types.js\").Block} block - Semantic block.\n * @param {string} indent - Leading indentation.\n * @param {string} path - Exact block path.\n * @returns {void}\n */\nfunction emitBlock(writer, block, indent, path) {\n  if (block.statements.length == 0) {\n    writer.synthetic(`${indent}pass\\n`, \"Python empty block\", [block], [path])\n    return\n  }\n\n  block.statements.forEach((statement, index) => emitStatement(writer, statement, indent, `${path}/statements/${index}`))\n}\n\n/**\n * Emits one supported Python statement.\n * @param {import(\"./writer.js\").SourceWriter} writer - Source-aware writer.\n * @param {import(\"../semantic/types.js\").Statement} statement - Semantic statement.\n * @param {string} indent - Leading indentation.\n * @param {string} path - Exact statement path.\n * @returns {void}\n */\nfunction emitStatement(writer, statement, indent, path) {\n  if (statement.kind == \"LocalDeclaration\" || statement.kind == \"AssignmentStatement\") {\n    emitLocal(writer, statement, indent, path)\n    return\n  }\n  if (statement.kind == \"IfStatement\") {\n    emitIf(writer, statement, indent, path, \"if\")\n    return\n  }\n\n  writer.synthetic(indent, \"indentation\", [statement], [path])\n  if (statement.kind == \"ReturnStatement\") {\n    writer.mapped(\"return\", {mappingKind: \"anchor\", node: statement, path})\n    writer.synthetic(\" \", \"return spacing\", [statement], [path])\n    emitExpression(writer, statement.expression, `${path}/expression`, \"python\", identity)\n    writer.synthetic(\"\\n\", \"line break\", [statement], [path])\n    return\n  }\n\n  writer.mapped(\"print\", {mappingKind: \"anchor\", node: statement, path})\n  writer.mapped(\"(\", {mappingKind: \"anchor\", node: statement, path})\n  emitExpression(writer, statement.expression, `${path}/expression`, \"python\", identity)\n  writer.mapped(\")\", {mappingKind: \"anchor\", node: statement, path})\n  writer.synthetic(\"\\n\", \"line break\", [statement], [path])\n}\n\n/**\n * Emits a Python if or elif and its optional alternative.\n * @param {import(\"./writer.js\").SourceWriter} writer - Source-aware writer.\n * @param {import(\"../semantic/types.js\").IfStatement} statement - Branch.\n * @param {string} indent - Leading indentation.\n * @param {string} path - Exact branch path.\n * @param {\"if\" | \"elif\"} keyword - Branch keyword.\n * @returns {void}\n */\nfunction emitIf(writer, statement, indent, path, keyword) {\n  writer.synthetic(indent, \"indentation\", [statement], [path])\n  writer.mapped(keyword, {mappingKind: \"anchor\", node: statement, path})\n  writer.synthetic(\" \", \"conditional spacing\", [statement], [path])\n  emitExpression(writer, statement.condition, `${path}/condition`, \"python\", identity)\n  writer.mapped(\":\", {mappingKind: \"anchor\", node: statement.consequent, path: `${path}/consequent`})\n  writer.synthetic(\"\\n\", \"line break\", [statement], [path])\n  emitBlock(writer, statement.consequent, `${indent}    `, `${path}/consequent`)\n\n  if (!statement.alternate) return\n  if (statement.alternate.statements.length == 1 && statement.alternate.statements[0].kind == \"IfStatement\") {\n    emitIf(writer, statement.alternate.statements[0], indent, `${path}/alternate/statements/0`, \"elif\")\n    return\n  }\n\n  writer.synthetic(indent, \"indentation\", [statement], [path])\n  writer.mapped(\"else\", {mappingKind: \"anchor\", node: statement, path})\n  writer.mapped(\":\", {mappingKind: \"anchor\", node: statement.alternate, path: `${path}/alternate`})\n  writer.synthetic(\"\\n\", \"line break\", [statement], [path])\n  emitBlock(writer, statement.alternate, `${indent}    `, `${path}/alternate`)\n}\n\n/**\n * Emits one annotated local declaration or plain assignment.\n * @param {import(\"./writer.js\").SourceWriter} writer - Source-aware writer.\n * @param {import(\"../semantic/types.js\").LocalStatement} statement - Local statement.\n * @param {string} indent - Leading indentation.\n * @param {string} path - Exact statement path.\n * @returns {void}\n */\nfunction emitLocal(writer, statement, indent, path) {\n  if (statement.kind == \"LocalDeclaration\" && !statement.mutable) {\n    writer.synthetic(`${indent}# @semantifold-immutable\\n`, \"Python immutable local carrier\", [statement], [path])\n  }\n  writer.synthetic(indent, \"indentation\", [statement], [path])\n\n  if (statement.kind == \"AssignmentStatement\") {\n    writer.mapped(statement.target.name, {mappingKind: \"exact\", node: statement.target, path: `${path}/target`, role: \"name\"})\n    writer.synthetic(\" \", \"assignment spacing\", [statement], [path])\n    writer.mapped(\"=\", {mappingKind: \"exact\", node: statement, path, role: \"operator\"})\n    writer.synthetic(\" \", \"assignment spacing\", [statement], [path])\n    emitExpression(writer, statement.expression, `${path}/expression`, \"python\", identity)\n    writer.synthetic(\"\\n\", \"line break\", [statement], [path])\n    return\n  }\n\n  writer.mapped(statement.name, {mappingKind: \"exact\", node: statement, path, role: \"name\"})\n  writer.synthetic(\": \", \"Python annotation separator\", [statement], [path])\n  writer.mapped(emitScalarType(\"python\", statement.type), {\n    mappingKind: \"exact\", node: statement.type, path: `${path}/type`, role: \"type\"\n  })\n  writer.synthetic(\" \", \"assignment spacing\", [statement], [path])\n  writer.mapped(\"=\", {mappingKind: \"exact\", node: statement, path, role: \"operator\"})\n  writer.synthetic(\" \", \"assignment spacing\", [statement], [path])\n  emitExpression(writer, statement.initializer, `${path}/initializer`, \"python\", identity)\n  writer.synthetic(\"\\n\", \"line break\", [statement], [path])\n}\n\n/**\n * Returns one unchanged Python identifier.\n * @param {string} name - Semantic identifier.\n * @returns {string} Unchanged Python identifier.\n */\nfunction identity(name) {\n  return name\n}\n"]}

package/build/src/backends/scalars.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scalars.d.ts","sourceRoot":"","sources":["../../../src/backends/scalars.js"],"names":[],"mappings":"AAWA;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAJ5B,OAAO,sBAAsB,EAAE,gBAIH,EAAE,IAAI,EAHlC,OAAO,sBAAsB,EAAE,aAGG,GAFhC,MAAM,CAIlB;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAJ/B,OAAO,sBAAsB,EAAE,gBAIA,EAAE,KAAK,EAHtC,MAGsC,GAFpC,MAAM,CAYlB"}
+{"version":3,"file":"scalars.d.ts","sourceRoot":"","sources":["../../../src/backends/scalars.js"],"names":[],"mappings":"AAgBA;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAJ5B,OAAO,sBAAsB,EAAE,gBAIH,EAAE,IAAI,EAHlC,OAAO,sBAAsB,EAAE,aAGG,GAFhC,MAAM,CAIlB;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAJ/B,OAAO,sBAAsB,EAAE,gBAIA,EAAE,KAAK,EAHtC,MAGsC,GAFpC,MAAM,CAclB"}

package/build/src/backends/scalars.js

@@ -1,9 +1,14 @@
 // @ts-check
 /** @type {Readonly<Record<import("../semantic/types.js").SemanticLanguage, Readonly<Record<import("../semantic/types.js").SemanticTypeName, string>>>>} */
 const targetScalarTypes = Object.freeze({
+    cpp: Object.freeze({ boolean: "bool", integer: "std::int64_t", string: "std::string" }),
+    c: Object.freeze({ boolean: "bool", integer: "int64_t", string: "SemantifoldString" }),
+    csharp: Object.freeze({ boolean: "bool", integer: "long", string: "string" }),
+    go: Object.freeze({ boolean: "bool", integer: "int64", string: "string" }),
     java: Object.freeze({ boolean: "boolean", integer: "int", string: "String" }),
     javascript: Object.freeze({ boolean: "boolean", integer: "number", string: "string" }),
     php: Object.freeze({ boolean: "bool", integer: "int", string: "string" }),
+    python: Object.freeze({ boolean: "bool", integer: "int", string: "str" }),
     ruby: Object.freeze({ boolean: "bool", integer: "Integer", string: "String" }),
     typescript: Object.freeze({ boolean: "boolean", integer: "number", string: "string" })
 });
@@ -32,7 +37,8 @@ export function emitStringLiteral(language, value) {
     const literal = JSON.stringify(value);
     if (typeof literal != "string")
         throw new TypeError("A validated semantic string did not serialize.");
-    return literal.replaceAll("\u2028", "\\u2028").replaceAll("\u2029", "\\u2029");
+    const escapedLineSeparators = literal.replaceAll("\u2028", "\\u2028").replaceAll("\u2029", "\\u2029");
+    return language == "csharp" ? escapedLineSeparators.replaceAll("\u0085", "\\u0085") : escapedLineSeparators;
 }
 /**
  * Emits a PHP double-quoted string while preventing interpolation.
@@ -135,4 +141,4 @@ function emitJavaString(value) {
     }
     return `${emitted}"`;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scalars.js","sourceRoot":"","sources":["../../../src/backends/scalars.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\n/** @type {Readonly<Record<import(\"../semantic/types.js\").SemanticLanguage, Readonly<Record<import(\"../semantic/types.js\").SemanticTypeName, string>>>>} */\nconst targetScalarTypes = Object.freeze({\n  java: Object.freeze({boolean: \"boolean\", integer: \"int\", string: \"String\"}),\n  javascript: Object.freeze({boolean: \"boolean\", integer: \"number\", string: \"string\"}),\n  php: Object.freeze({boolean: \"bool\", integer: \"int\", string: \"string\"}),\n  ruby: Object.freeze({boolean: \"bool\", integer: \"Integer\", string: \"String\"}),\n  typescript: Object.freeze({boolean: \"boolean\", integer: \"number\", string: \"string\"})\n})\n\n/**\n * Emits one target-language scalar type spelling.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} language - Target language.\n * @param {import(\"../semantic/types.js\").TypeReference} type - Semantic scalar type.\n * @returns {string} Target type spelling.\n */\nexport function emitScalarType(language, type) {\n  return targetScalarTypes[language][type.name]\n}\n\n/**\n * Emits a safely escaped target-language string literal.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} language - Target language.\n * @param {string} value - Valid Unicode scalar string.\n * @returns {string} Target string literal.\n */\nexport function emitStringLiteral(language, value) {\n  if (language == \"php\") return emitPhpString(value)\n  if (language == \"ruby\") return emitRubyString(value)\n  if (language == \"java\") return emitJavaString(value)\n\n  const literal = JSON.stringify(value)\n\n  if (typeof literal != \"string\") throw new TypeError(\"A validated semantic string did not serialize.\")\n\n  return literal.replaceAll(\"\\u2028\", \"\\\\u2028\").replaceAll(\"\\u2029\", \"\\\\u2029\")\n}\n\n/**\n * Emits a PHP double-quoted string while preventing interpolation.\n * @param {string} value - Valid Unicode scalar string.\n * @returns {string} PHP string literal.\n */\nfunction emitPhpString(value) {\n  let emitted = \"\\\"\"\n\n  for (const character of value) {\n    const codePoint = character.codePointAt(0)\n\n    if (character == \"\\\"\") emitted += \"\\\\\\\"\"\n    else if (character == \"\\\\\") emitted += \"\\\\\\\\\"\n    else if (character == \"$\") emitted += \"\\\\$\"\n    else if (character == \"\\n\") emitted += \"\\\\n\"\n    else if (character == \"\\r\") emitted += \"\\\\r\"\n    else if (character == \"\\t\") emitted += \"\\\\t\"\n    else if (character == \"\\f\") emitted += \"\\\\f\"\n    else if (character == \"\\v\") emitted += \"\\\\v\"\n    else if (codePoint == 27) emitted += \"\\\\e\"\n    else if (codePoint !== undefined && (codePoint < 32 || codePoint == 127)) {\n      emitted += `\\\\x${codePoint.toString(16).padStart(2, \"0\")}`\n    } else emitted += character\n  }\n\n  return `${emitted}\"`\n}\n\n/**\n * Emits a Ruby double-quoted string while preventing interpolation.\n * @param {string} value - Valid Unicode scalar string.\n * @returns {string} Ruby string literal.\n */\nfunction emitRubyString(value) {\n  let emitted = \"\\\"\"\n\n  for (const character of value) {\n    const codePoint = character.codePointAt(0)\n\n    if (character == \"\\\"\") emitted += \"\\\\\\\"\"\n    else if (character == \"\\\\\") emitted += \"\\\\\\\\\"\n    else if (character == \"#\") emitted += \"\\\\#\"\n    else if (character == \"\\n\") emitted += \"\\\\n\"\n    else if (character == \"\\r\") emitted += \"\\\\r\"\n    else if (character == \"\\t\") emitted += \"\\\\t\"\n    else if (character == \"\\f\") emitted += \"\\\\f\"\n    else if (character == \"\\v\") emitted += \"\\\\v\"\n    else if (codePoint == 27) emitted += \"\\\\e\"\n    else if (codePoint !== undefined && (codePoint < 32 || codePoint == 127)) {\n      emitted += `\\\\u{${codePoint.toString(16)}}`\n    } else emitted += character\n  }\n\n  return `${emitted}\"`\n}\n\n/**\n * Emits a Java string using standard or fixed-width octal control escapes.\n * @param {string} value - Valid Unicode scalar string.\n * @returns {string} Java string literal.\n */\nfunction emitJavaString(value) {\n  let emitted = \"\\\"\"\n\n  for (const character of value) {\n    const codePoint = character.codePointAt(0)\n\n    if (character == \"\\\"\") emitted += \"\\\\\\\"\"\n    else if (character == \"\\\\\") emitted += \"\\\\\\\\\"\n    else if (character == \"\\b\") emitted += \"\\\\b\"\n    else if (character == \"\\t\") emitted += \"\\\\t\"\n    else if (character == \"\\n\") emitted += \"\\\\n\"\n    else if (character == \"\\f\") emitted += \"\\\\f\"\n    else if (character == \"\\r\") emitted += \"\\\\r\"\n    else if (codePoint !== undefined && (codePoint < 32 || codePoint == 127)) {\n      emitted += `\\\\${codePoint.toString(8).padStart(3, \"0\")}`\n    } else emitted += character\n  }\n\n  return `${emitted}\"`\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scalars.js","sourceRoot":"","sources":["../../../src/backends/scalars.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\n/** @type {Readonly<Record<import(\"../semantic/types.js\").SemanticLanguage, Readonly<Record<import(\"../semantic/types.js\").SemanticTypeName, string>>>>} */\nconst targetScalarTypes = Object.freeze({\n  cpp: Object.freeze({boolean: \"bool\", integer: \"std::int64_t\", string: \"std::string\"}),\n  c: Object.freeze({boolean: \"bool\", integer: \"int64_t\", string: \"SemantifoldString\"}),\n  csharp: Object.freeze({boolean: \"bool\", integer: \"long\", string: \"string\"}),\n  go: Object.freeze({boolean: \"bool\", integer: \"int64\", string: \"string\"}),\n  java: Object.freeze({boolean: \"boolean\", integer: \"int\", string: \"String\"}),\n  javascript: Object.freeze({boolean: \"boolean\", integer: \"number\", string: \"string\"}),\n  php: Object.freeze({boolean: \"bool\", integer: \"int\", string: \"string\"}),\n  python: Object.freeze({boolean: \"bool\", integer: \"int\", string: \"str\"}),\n  ruby: Object.freeze({boolean: \"bool\", integer: \"Integer\", string: \"String\"}),\n  typescript: Object.freeze({boolean: \"boolean\", integer: \"number\", string: \"string\"})\n})\n\n/**\n * Emits one target-language scalar type spelling.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} language - Target language.\n * @param {import(\"../semantic/types.js\").TypeReference} type - Semantic scalar type.\n * @returns {string} Target type spelling.\n */\nexport function emitScalarType(language, type) {\n  return targetScalarTypes[language][type.name]\n}\n\n/**\n * Emits a safely escaped target-language string literal.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} language - Target language.\n * @param {string} value - Valid Unicode scalar string.\n * @returns {string} Target string literal.\n */\nexport function emitStringLiteral(language, value) {\n  if (language == \"php\") return emitPhpString(value)\n  if (language == \"ruby\") return emitRubyString(value)\n  if (language == \"java\") return emitJavaString(value)\n\n  const literal = JSON.stringify(value)\n\n  if (typeof literal != \"string\") throw new TypeError(\"A validated semantic string did not serialize.\")\n\n  const escapedLineSeparators = literal.replaceAll(\"\\u2028\", \"\\\\u2028\").replaceAll(\"\\u2029\", \"\\\\u2029\")\n\n  return language == \"csharp\" ? escapedLineSeparators.replaceAll(\"\\u0085\", \"\\\\u0085\") : escapedLineSeparators\n}\n\n/**\n * Emits a PHP double-quoted string while preventing interpolation.\n * @param {string} value - Valid Unicode scalar string.\n * @returns {string} PHP string literal.\n */\nfunction emitPhpString(value) {\n  let emitted = \"\\\"\"\n\n  for (const character of value) {\n    const codePoint = character.codePointAt(0)\n\n    if (character == \"\\\"\") emitted += \"\\\\\\\"\"\n    else if (character == \"\\\\\") emitted += \"\\\\\\\\\"\n    else if (character == \"$\") emitted += \"\\\\$\"\n    else if (character == \"\\n\") emitted += \"\\\\n\"\n    else if (character == \"\\r\") emitted += \"\\\\r\"\n    else if (character == \"\\t\") emitted += \"\\\\t\"\n    else if (character == \"\\f\") emitted += \"\\\\f\"\n    else if (character == \"\\v\") emitted += \"\\\\v\"\n    else if (codePoint == 27) emitted += \"\\\\e\"\n    else if (codePoint !== undefined && (codePoint < 32 || codePoint == 127)) {\n      emitted += `\\\\x${codePoint.toString(16).padStart(2, \"0\")}`\n    } else emitted += character\n  }\n\n  return `${emitted}\"`\n}\n\n/**\n * Emits a Ruby double-quoted string while preventing interpolation.\n * @param {string} value - Valid Unicode scalar string.\n * @returns {string} Ruby string literal.\n */\nfunction emitRubyString(value) {\n  let emitted = \"\\\"\"\n\n  for (const character of value) {\n    const codePoint = character.codePointAt(0)\n\n    if (character == \"\\\"\") emitted += \"\\\\\\\"\"\n    else if (character == \"\\\\\") emitted += \"\\\\\\\\\"\n    else if (character == \"#\") emitted += \"\\\\#\"\n    else if (character == \"\\n\") emitted += \"\\\\n\"\n    else if (character == \"\\r\") emitted += \"\\\\r\"\n    else if (character == \"\\t\") emitted += \"\\\\t\"\n    else if (character == \"\\f\") emitted += \"\\\\f\"\n    else if (character == \"\\v\") emitted += \"\\\\v\"\n    else if (codePoint == 27) emitted += \"\\\\e\"\n    else if (codePoint !== undefined && (codePoint < 32 || codePoint == 127)) {\n      emitted += `\\\\u{${codePoint.toString(16)}}`\n    } else emitted += character\n  }\n\n  return `${emitted}\"`\n}\n\n/**\n * Emits a Java string using standard or fixed-width octal control escapes.\n * @param {string} value - Valid Unicode scalar string.\n * @returns {string} Java string literal.\n */\nfunction emitJavaString(value) {\n  let emitted = \"\\\"\"\n\n  for (const character of value) {\n    const codePoint = character.codePointAt(0)\n\n    if (character == \"\\\"\") emitted += \"\\\\\\\"\"\n    else if (character == \"\\\\\") emitted += \"\\\\\\\\\"\n    else if (character == \"\\b\") emitted += \"\\\\b\"\n    else if (character == \"\\t\") emitted += \"\\\\t\"\n    else if (character == \"\\n\") emitted += \"\\\\n\"\n    else if (character == \"\\f\") emitted += \"\\\\f\"\n    else if (character == \"\\r\") emitted += \"\\\\r\"\n    else if (codePoint !== undefined && (codePoint < 32 || codePoint == 127)) {\n      emitted += `\\\\${codePoint.toString(8).padStart(3, \"0\")}`\n    } else emitted += character\n  }\n\n  return `${emitted}\"`\n}\n"]}

package/build/src/backends/shared.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../src/backends/shared.js"],"names":[],"mappings":"AA6BA;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAJjC,OAAO,sBAAsB,EAAE,cAIE,EAAE,QAAQ,EAH3C,OAAO,sBAAsB,EAAE,gBAGY,GAFzC,IAAI,CAuBhB;AA4PD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAP1B,OAAO,aAAa,EAAE,YAOI,EAAE,UAAU,EANtC,OAAO,sBAAsB,EAAE,UAMO,EAAE,IAAI,EAL5C,MAK4C,EAAE,QAAQ,EAJtD,OAAO,sBAAsB,EAAE,gBAIuB,EAAE,cAAc,EAHtE,CAAC,IAAI,EAAE,MAAM,KAAK,MAGoD,GAFpE,IAAI,CAwEhB;AAED;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAAC,MAAM,EAH1C,OAAO,sBAAsB,EAAE,cAGW,GAFxC,OAAO,CAKnB"}
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../src/backends/shared.js"],"names":[],"mappings":"AA6BA;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAJjC,OAAO,sBAAsB,EAAE,cAIE,EAAE,QAAQ,EAH3C,OAAO,sBAAsB,EAAE,gBAGY,GAFzC,IAAI,CAiChB;AAwQD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAP1B,OAAO,aAAa,EAAE,YAOI,EAAE,UAAU,EANtC,OAAO,sBAAsB,EAAE,UAMO,EAAE,IAAI,EAL5C,MAK4C,EAAE,QAAQ,EAJtD,OAAO,sBAAsB,EAAE,gBAIuB,EAAE,cAAc,EAHtE,CAAC,IAAI,EAAE,MAAM,KAAK,MAGoD,GAFpE,IAAI,CAgGhB;AAED;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAAC,MAAM,EAH1C,OAAO,sBAAsB,EAAE,cAGW,GAFxC,OAAO,CAKnB"}