semantifold 0.1.0

package/build/src/backends/typescript.js

@@ -0,0 +1,160 @@
+// @ts-check
+import { emitExpression, requiresCanonicalZeroRendering } from "./shared.js";
+import { emitScalarType } from "./scalars.js";
+/**
+ * Emits an independently executable TypeScript program through the source-aware writer.
+ * @param {import("../semantic/types.js").SemanticModule} module - Semantic module.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @returns {void}
+ */
+export function generateTypeScript(module, writer) {
+    const canonicalizeZero = requiresCanonicalZeroRendering(module);
+    module.functions.forEach((declaration, functionIndex) => {
+        if (functionIndex > 0)
+            writer.synthetic("\n\n", "declaration separator", [declaration]);
+        writer.mapped("function", { 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, index) => {
+            const parameterPath = `/functions/${functionIndex}/parameters/${index}`;
+            if (index > 0)
+                writer.synthetic(", ", "parameter separator", [declaration]);
+            writer.mapped(parameter.name, { mappingKind: "exact", node: parameter, path: parameterPath, role: "name" });
+            writer.synthetic(": ", "type separator", [parameter], [parameterPath]);
+            writer.mapped(emitScalarType("typescript", parameter.type), {
+                mappingKind: "exact",
+                node: parameter.type,
+                path: `${parameterPath}/type`,
+                role: "type"
+            });
+        });
+        writer.mapped(")", { mappingKind: "anchor", node: declaration });
+        writer.synthetic(": ", "return type separator", [declaration]);
+        writer.mapped(emitScalarType("typescript", declaration.returnType), {
+            mappingKind: "exact",
+            node: declaration.returnType,
+            path: `/functions/${functionIndex}/returnType`,
+            role: "type"
+        });
+        writer.synthetic(" ", "function spacing", [declaration]);
+        writer.mapped("{", { mappingKind: "anchor", node: declaration });
+        writer.synthetic("\n", "line break", [declaration]);
+        emitBlock(writer, declaration.body, "  ", `/functions/${functionIndex}/body`, canonicalizeZero);
+        writer.mapped("}", { mappingKind: "anchor", node: declaration });
+    });
+    writer.synthetic("\n\n", "entry-point separator", [module.entryPoint]);
+    emitBlock(writer, module.entryPoint.body, "", "/entryPoint/body", canonicalizeZero);
+}
+/**
+ * Emits one ordered TypeScript block body.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @param {import("../semantic/types.js").Block} block - Semantic block.
+ * @param {string} indent - Indentation.
+ * @param {string} path - Exact block path.
+ * @param {boolean} canonicalizeZero - Whether printed integer zero must be canonicalized.
+ * @returns {void}
+ */
+function emitBlock(writer, block, indent, path, canonicalizeZero) {
+    block.statements.forEach((statement, index) => emitStatement(writer, statement, indent, `${path}/statements/${index}`, canonicalizeZero));
+}
+/**
+ * Emits one TypeScript statement.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @param {import("../semantic/types.js").Statement} statement - Semantic statement.
+ * @param {string} indent - Indentation.
+ * @param {string} path - Exact statement path.
+ * @param {boolean} canonicalizeZero - Whether printed integer zero must be canonicalized.
+ * @returns {void}
+ */
+function emitStatement(writer, statement, indent, path, canonicalizeZero) {
+    if (statement.kind == "LocalDeclaration" || statement.kind == "AssignmentStatement") {
+        emitLocal(writer, statement, indent, path);
+        writer.synthetic("\n", "line break", [statement], [path]);
+        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`, "typescript", identity);
+        writer.synthetic("\n", "line break", [statement], [path]);
+        return;
+    }
+    if (statement.kind == "PrintStatement") {
+        writer.mapped("console.log", { mappingKind: "anchor", node: statement, path });
+        writer.mapped("(", { mappingKind: "anchor", node: statement, path });
+        if (canonicalizeZero)
+            writer.synthetic("(", "canonical integer output", [statement], [path]);
+        emitExpression(writer, statement.expression, `${path}/expression`, "typescript", identity);
+        if (canonicalizeZero)
+            writer.synthetic(").toString()", "canonical integer output", [statement], [path]);
+        writer.mapped(")", { mappingKind: "anchor", node: statement, path });
+        writer.synthetic("\n", "line break", [statement], [path]);
+        return;
+    }
+    writer.mapped("if", { mappingKind: "anchor", node: statement, path });
+    writer.synthetic(" ", "conditional spacing", [statement], [path]);
+    writer.mapped("(", { mappingKind: "anchor", node: statement, path });
+    emitExpression(writer, statement.condition, `${path}/condition`, "typescript", identity);
+    writer.mapped(")", { mappingKind: "anchor", node: statement, path });
+    writer.synthetic(" ", "conditional spacing", [statement], [path]);
+    writer.mapped("{", { mappingKind: "anchor", node: statement.consequent, path: `${path}/consequent` });
+    writer.synthetic("\n", "line break", [statement], [path]);
+    emitBlock(writer, statement.consequent, `${indent}  `, `${path}/consequent`, canonicalizeZero);
+    writer.synthetic(indent, "indentation", [statement], [path]);
+    writer.mapped("}", { mappingKind: "anchor", node: statement.consequent, path: `${path}/consequent` });
+    if (statement.alternate) {
+        writer.synthetic(" ", "conditional spacing", [statement], [path]);
+        writer.mapped("else", { mappingKind: "anchor", node: statement, path });
+        writer.synthetic(" ", "conditional spacing", [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`, canonicalizeZero);
+        writer.synthetic(indent, "indentation", [statement], [path]);
+        writer.mapped("}", { mappingKind: "anchor", node: statement.alternate, path: `${path}/alternate` });
+    }
+    writer.synthetic("\n", "line break", [statement], [path]);
+}
+/**
+ * Emits one TypeScript local statement.
+ * @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} statementPath - Exact JSON Pointer for this statement occurrence.
+ * @returns {void}
+ */
+function emitLocal(writer, statement, indent, statementPath) {
+    writer.synthetic(indent, "indentation", [statement], [statementPath]);
+    if (statement.kind == "AssignmentStatement") {
+        writer.mapped(statement.target.name, { mappingKind: "exact", node: statement.target, path: `${statementPath}/target`, role: "name" });
+        writer.synthetic(" ", "assignment spacing", [statement], [statementPath]);
+        writer.mapped("=", { mappingKind: "exact", node: statement, path: statementPath, role: "operator" });
+        writer.synthetic(" ", "assignment spacing", [statement], [statementPath]);
+        emitExpression(writer, statement.expression, `${statementPath}/expression`, "typescript", identity);
+        return;
+    }
+    writer.mapped(statement.mutable ? "let" : "const", { mappingKind: "anchor", node: statement, path: statementPath });
+    writer.synthetic(" ", "declaration spacing", [statement], [statementPath]);
+    writer.mapped(statement.name, { mappingKind: "exact", node: statement, path: statementPath, role: "name" });
+    writer.synthetic(": ", "type separator", [statement], [statementPath]);
+    writer.mapped(emitScalarType("typescript", statement.type), {
+        mappingKind: "exact",
+        node: statement.type,
+        path: `${statementPath}/type`,
+        role: "type"
+    });
+    writer.synthetic(" ", "assignment spacing", [statement], [statementPath]);
+    writer.mapped("=", { mappingKind: "exact", node: statement, path: statementPath, role: "operator" });
+    writer.synthetic(" ", "assignment spacing", [statement], [statementPath]);
+    emitExpression(writer, statement.initializer, `${statementPath}/initializer`, "typescript", identity);
+}
+/**
+ * Returns an unchanged TypeScript identifier.
+ * @param {string} name - Identifier.
+ * @returns {string} Identifier.
+ */
+function identity(name) {
+    return name;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"typescript.js","sourceRoot":"","sources":["../../../src/backends/typescript.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {emitExpression, requiresCanonicalZeroRendering} from \"./shared.js\"\nimport {emitScalarType} from \"./scalars.js\"\n\n/**\n * Emits an independently executable TypeScript program through the source-aware writer.\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 generateTypeScript(module, writer) {\n  const canonicalizeZero = requiresCanonicalZeroRendering(module)\n\n  module.functions.forEach((declaration, functionIndex) => {\n    if (functionIndex > 0) writer.synthetic(\"\\n\\n\", \"declaration separator\", [declaration])\n\n    writer.mapped(\"function\", {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, index) => {\n      const parameterPath = `/functions/${functionIndex}/parameters/${index}`\n\n      if (index > 0) writer.synthetic(\", \", \"parameter separator\", [declaration])\n      writer.mapped(parameter.name, {mappingKind: \"exact\", node: parameter, path: parameterPath, role: \"name\"})\n      writer.synthetic(\": \", \"type separator\", [parameter], [parameterPath])\n      writer.mapped(emitScalarType(\"typescript\", 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(\": \", \"return type separator\", [declaration])\n    writer.mapped(emitScalarType(\"typescript\", declaration.returnType), {\n      mappingKind: \"exact\",\n      node: declaration.returnType,\n      path: `/functions/${functionIndex}/returnType`,\n      role: \"type\"\n    })\n    writer.synthetic(\" \", \"function spacing\", [declaration])\n    writer.mapped(\"{\", {mappingKind: \"anchor\", node: declaration})\n    writer.synthetic(\"\\n\", \"line break\", [declaration])\n\n    emitBlock(writer, declaration.body, \"  \", `/functions/${functionIndex}/body`, canonicalizeZero)\n    writer.mapped(\"}\", {mappingKind: \"anchor\", node: declaration})\n  })\n\n  writer.synthetic(\"\\n\\n\", \"entry-point separator\", [module.entryPoint])\n  emitBlock(writer, module.entryPoint.body, \"\", \"/entryPoint/body\", canonicalizeZero)\n}\n\n/**\n * Emits one ordered TypeScript block body.\n * @param {import(\"./writer.js\").SourceWriter} writer - Source-aware writer.\n * @param {import(\"../semantic/types.js\").Block} block - Semantic block.\n * @param {string} indent - Indentation.\n * @param {string} path - Exact block path.\n * @param {boolean} canonicalizeZero - Whether printed integer zero must be canonicalized.\n * @returns {void}\n */\nfunction emitBlock(writer, block, indent, path, canonicalizeZero) {\n  block.statements.forEach((statement, index) => emitStatement(writer, statement, indent, `${path}/statements/${index}`, canonicalizeZero))\n}\n\n/**\n * Emits one TypeScript 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 - Indentation.\n * @param {string} path - Exact statement path.\n * @param {boolean} canonicalizeZero - Whether printed integer zero must be canonicalized.\n * @returns {void}\n */\nfunction emitStatement(writer, statement, indent, path, canonicalizeZero) {\n  if (statement.kind == \"LocalDeclaration\" || statement.kind == \"AssignmentStatement\") {\n    emitLocal(writer, statement, indent, path)\n    writer.synthetic(\"\\n\", \"line break\", [statement], [path])\n    return\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`, \"typescript\", identity)\n    writer.synthetic(\"\\n\", \"line break\", [statement], [path])\n    return\n  }\n  if (statement.kind == \"PrintStatement\") {\n    writer.mapped(\"console.log\", {mappingKind: \"anchor\", node: statement, path})\n    writer.mapped(\"(\", {mappingKind: \"anchor\", node: statement, path})\n    if (canonicalizeZero) writer.synthetic(\"(\", \"canonical integer output\", [statement], [path])\n    emitExpression(writer, statement.expression, `${path}/expression`, \"typescript\", identity)\n    if (canonicalizeZero) writer.synthetic(\").toString()\", \"canonical integer output\", [statement], [path])\n    writer.mapped(\")\", {mappingKind: \"anchor\", node: statement, path})\n    writer.synthetic(\"\\n\", \"line break\", [statement], [path])\n    return\n  }\n  writer.mapped(\"if\", {mappingKind: \"anchor\", node: statement, path})\n  writer.synthetic(\" \", \"conditional spacing\", [statement], [path])\n  writer.mapped(\"(\", {mappingKind: \"anchor\", node: statement, path})\n  emitExpression(writer, statement.condition, `${path}/condition`, \"typescript\", identity)\n  writer.mapped(\")\", {mappingKind: \"anchor\", node: statement, path})\n  writer.synthetic(\" \", \"conditional spacing\", [statement], [path])\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`, canonicalizeZero)\n  writer.synthetic(indent, \"indentation\", [statement], [path])\n  writer.mapped(\"}\", {mappingKind: \"anchor\", node: statement.consequent, path: `${path}/consequent`})\n  if (statement.alternate) {\n    writer.synthetic(\" \", \"conditional spacing\", [statement], [path])\n    writer.mapped(\"else\", {mappingKind: \"anchor\", node: statement, path})\n    writer.synthetic(\" \", \"conditional spacing\", [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`, canonicalizeZero)\n    writer.synthetic(indent, \"indentation\", [statement], [path])\n    writer.mapped(\"}\", {mappingKind: \"anchor\", node: statement.alternate, path: `${path}/alternate`})\n  }\n  writer.synthetic(\"\\n\", \"line break\", [statement], [path])\n}\n\n/**\n * Emits one TypeScript local statement.\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} statementPath - Exact JSON Pointer for this statement occurrence.\n * @returns {void}\n */\nfunction emitLocal(writer, statement, indent, statementPath) {\n  writer.synthetic(indent, \"indentation\", [statement], [statementPath])\n\n  if (statement.kind == \"AssignmentStatement\") {\n    writer.mapped(statement.target.name, {mappingKind: \"exact\", node: statement.target, path: `${statementPath}/target`, role: \"name\"})\n    writer.synthetic(\" \", \"assignment spacing\", [statement], [statementPath])\n    writer.mapped(\"=\", {mappingKind: \"exact\", node: statement, path: statementPath, role: \"operator\"})\n    writer.synthetic(\" \", \"assignment spacing\", [statement], [statementPath])\n    emitExpression(writer, statement.expression, `${statementPath}/expression`, \"typescript\", identity)\n    return\n  }\n\n  writer.mapped(statement.mutable ? \"let\" : \"const\", {mappingKind: \"anchor\", node: statement, path: statementPath})\n  writer.synthetic(\" \", \"declaration spacing\", [statement], [statementPath])\n  writer.mapped(statement.name, {mappingKind: \"exact\", node: statement, path: statementPath, role: \"name\"})\n  writer.synthetic(\": \", \"type separator\", [statement], [statementPath])\n  writer.mapped(emitScalarType(\"typescript\", statement.type), {\n    mappingKind: \"exact\",\n    node: statement.type,\n    path: `${statementPath}/type`,\n    role: \"type\"\n  })\n  writer.synthetic(\" \", \"assignment spacing\", [statement], [statementPath])\n  writer.mapped(\"=\", {mappingKind: \"exact\", node: statement, path: statementPath, role: \"operator\"})\n  writer.synthetic(\" \", \"assignment spacing\", [statement], [statementPath])\n  emitExpression(writer, statement.initializer, `${statementPath}/initializer`, \"typescript\", identity)\n}\n\n/**\n * Returns an unchanged TypeScript identifier.\n * @param {string} name - Identifier.\n * @returns {string} Identifier.\n */\nfunction identity(name) {\n  return name\n}\n"]}

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

@@ -0,0 +1,87 @@
+/** Source-aware deterministic generated-output builder. */
+export declare class SourceWriter {
+    #private;
+    filename: string;
+    language: import("../semantic/types.js").SemanticLanguage;
+    index: {
+        provenance: import("../semantic/types.js").SemanticProvenance;
+        recordFor: (node: import("../semantic/types.js").SemanticNode, path?: string) => import("../semantic/types.js").SemanticNodeProvenance;
+    };
+    /** @type {string[]} */
+    parts: string[];
+    /** @type {import("../semantic/types.js").SemantifoldMappingSpan[]} */
+    spans: import("../semantic/types.js").SemantifoldMappingSpan[];
+    offset: number;
+    line: number;
+    column: number;
+    /**
+     * Creates a source-aware writer.
+     * @param {object} options - Writer options.
+     * @param {string} options.filename - Output filename.
+     * @param {import("../semantic/types.js").SemanticLanguage} options.language - Output language.
+     * @param {import("../semantic/types.js").SemanticModule} options.module - Semantic module.
+     * @param {{filename: string, content: string, language?: import("../semantic/types.js").SemanticLanguage}[]} [options.sources] - Caller-provided sources.
+     */
+    constructor({ filename, language, module, sources }: {
+        filename: string;
+        language: import("../semantic/types.js").SemanticLanguage;
+        module: import("../semantic/types.js").SemanticModule;
+        sources?: {
+            filename: string;
+            content: string;
+            language?: import("../semantic/types.js").SemanticLanguage;
+        }[];
+    });
+    /**
+     * Returns generated content so far.
+     * @returns {string} Generated content.
+     */
+    get code(): string;
+    /**
+     * Returns the current JSON Pointer for one unambiguous semantic occurrence.
+     * @param {import("../semantic/types.js").SemanticNode} node - Semantic node occurrence.
+     * @returns {string} Current occurrence path.
+     */
+    occurrencePath(node: import("../semantic/types.js").SemanticNode): string;
+    /**
+     * Reports whether an exact parser-owned role range is available.
+     * @param {import("../semantic/types.js").SemanticNode} node - Semantic node occurrence.
+     * @param {string} path - JSON Pointer for a shared node occurrence.
+     * @param {string} role - Semantic token role.
+     * @returns {boolean} Whether the role has an exact source range.
+     */
+    hasRange(node: import("../semantic/types.js").SemanticNode, path: string, role: string): boolean;
+    /**
+     * Writes text mapped to a semantic node.
+     * @param {string} text - Generated text.
+     * @param {object} annotation - Mapping annotation.
+     * @param {import("../semantic/types.js").SemanticNode} annotation.node - Semantic node.
+     * @param {"exact" | "anchor"} annotation.mappingKind - Mapping precision.
+     * @param {string} [annotation.role] - Semantic token role.
+     * @param {string} [annotation.name] - Source Map name.
+     * @param {string} [annotation.path] - JSON Pointer for a shared node occurrence.
+     * @returns {void}
+     */
+    mapped(text: string, { mappingKind, name, node, path, role }: {
+        node: import("../semantic/types.js").SemanticNode;
+        mappingKind: "exact" | "anchor";
+        role?: string;
+        name?: string;
+        path?: string;
+    }): void;
+    /**
+     * Writes source-free scaffolding with optional semantic context.
+     * @param {string} text - Generated text.
+     * @param {string} reason - Stable reason.
+     * @param {import("../semantic/types.js").SemanticNode[]} [relatedNodes] - Related nodes.
+     * @param {(string | undefined)[]} [relatedPaths] - Occurrence paths for shared related nodes.
+     * @returns {void}
+     */
+    synthetic(text: string, reason: string, relatedNodes?: import("../semantic/types.js").SemanticNode[], relatedPaths?: (string | undefined)[]): void;
+    /**
+     * Returns the authoritative rich map for the current content.
+     * @returns {import("../semantic/types.js").SemantifoldMapping} Mapping.
+     */
+    finish(): import("../semantic/types.js").SemantifoldMapping;
+}
+//# sourceMappingURL=writer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"writer.d.ts","sourceRoot":"","sources":["../../../src/backends/writer.js"],"names":[],"mappings":"AAIA,2DAA2D;AAC3D,qBAAa,YAAY;;IAYhB,QAAQ;IACR,QAAQ;IACR,KAAK;;;;IACV,uBAAuB;IAClB,KAAK,EADC,MAAM,EAAE;IAEnB,sEAAsE;IACjE,KAAK,EADC,OAAO,sBAAsB,EAAE,sBAAsB,EAAE;IAE7D,MAAM;IACN,IAAI;IACJ,MAAM;IApBb;;;;;;;OAOG;IACH,YAAY,EAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAC,EAL9C;QAAwB,QAAQ,EAAxB,MAAM,CACd;QAAiE,QAAQ,EAAjE,OAAO,sBAAsB,EAAE,gBAAgB,CACvD;QAA+D,MAAM,EAA7D,OAAO,sBAAsB,EAAE,cAAc,CACrD;QAAoH,OAAO,AAA3H,CACF,EADU;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,EAAE,OAAO,sBAAsB,EAAE,gBAAgB,CAAA;SAAC,EAAE,CAC3G;KACgD,EAahD;IAED;;;OAGG;IACH,IAAI,IAAI,IAFK,MAAM,CAIlB;IAED;;;;OAIG;IACH,cAAc,CAAC,IAAI,EAHR,OAAO,sBAAsB,EAAE,YAGvB,GAFN,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,EALF,OAAO,sBAAsB,EAAE,YAK7B,EAAE,IAAI,EAJR,MAIQ,EAAE,IAAI,EAHd,MAGc,GAFZ,OAAO,CAInB;IAED;;;;;;;;;;OAUG;IACH,MAAM,CAAC,IAAI,EATA,MASA,EAAE,EAAC,WAAW,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAC,EAP/C;QAAgE,IAAI,EAA5D,OAAO,sBAAsB,EAAE,YAAY,CACnD;QAAuC,WAAW,EAA1C,OAAO,GAAG,QAAQ,CAC1B;QAA4B,IAAI,AAAhC,CACA,EADQ,MAAM,CACd;QAA4B,IAAI,AAAhC,CACA,EADQ,MAAM,CACd;QAA4B,IAAI,AAAhC,CACA,EADQ,MAAM,CACd;KAE+C,GAFrC,IAAI,CAqBhB;IAED;;;;;;;OAOG;IACH,SAAS,CAAC,IAAI,EANH,MAMG,EAAE,MAAM,EALX,MAKW,EAAE,YAAY,AAJjC,CACA,EADQ,OAAO,sBAAsB,EAAE,YAAY,EAIb,EAAE,YAAY,AAHpD,CACA,EADQ,CAAC,MAAM,GAAG,SAAS,CAAC,EAG6B,GAF/C,IAAI,CA0BhB;IAED;;;OAGG;IACH,MAAM,IAFO,OAAO,sBAAsB,EAAE,kBAAkB,CAa7D;CAwDF"}

package/build/src/backends/writer.js

@@ -0,0 +1,207 @@
+// @ts-check
+import { createGenerationIndex } from "../semantic/provenance.js";
+/** Source-aware deterministic generated-output builder. */
+export class SourceWriter {
+    /**
+     * Creates a source-aware writer.
+     * @param {object} options - Writer options.
+     * @param {string} options.filename - Output filename.
+     * @param {import("../semantic/types.js").SemanticLanguage} options.language - Output language.
+     * @param {import("../semantic/types.js").SemanticModule} options.module - Semantic module.
+     * @param {{filename: string, content: string, language?: import("../semantic/types.js").SemanticLanguage}[]} [options.sources] - Caller-provided sources.
+     */
+    constructor({ filename, language, module, sources }) {
+        const index = createGenerationIndex(module, sources);
+        this.filename = filename;
+        this.language = language;
+        this.index = index;
+        /** @type {string[]} */
+        this.parts = [];
+        /** @type {import("../semantic/types.js").SemantifoldMappingSpan[]} */
+        this.spans = [];
+        this.offset = 0;
+        this.line = 1;
+        this.column = 1;
+    }
+    /**
+     * Returns generated content so far.
+     * @returns {string} Generated content.
+     */
+    get code() {
+        return this.parts.join("");
+    }
+    /**
+     * Returns the current JSON Pointer for one unambiguous semantic occurrence.
+     * @param {import("../semantic/types.js").SemanticNode} node - Semantic node occurrence.
+     * @returns {string} Current occurrence path.
+     */
+    occurrencePath(node) {
+        return this.index.recordFor(node).path;
+    }
+    /**
+     * Reports whether an exact parser-owned role range is available.
+     * @param {import("../semantic/types.js").SemanticNode} node - Semantic node occurrence.
+     * @param {string} path - JSON Pointer for a shared node occurrence.
+     * @param {string} role - Semantic token role.
+     * @returns {boolean} Whether the role has an exact source range.
+     */
+    hasRange(node, path, role) {
+        return this.index.recordFor(node, path).ranges[role] !== undefined;
+    }
+    /**
+     * Writes text mapped to a semantic node.
+     * @param {string} text - Generated text.
+     * @param {object} annotation - Mapping annotation.
+     * @param {import("../semantic/types.js").SemanticNode} annotation.node - Semantic node.
+     * @param {"exact" | "anchor"} annotation.mappingKind - Mapping precision.
+     * @param {string} [annotation.role] - Semantic token role.
+     * @param {string} [annotation.name] - Source Map name.
+     * @param {string} [annotation.path] - JSON Pointer for a shared node occurrence.
+     * @returns {void}
+     */
+    mapped(text, { mappingKind, name, node, path, role }) {
+        if (text.length == 0)
+            return;
+        const record = this.index.recordFor(node, path);
+        const roleLocation = role ? record.ranges[role] : undefined;
+        const origin = roleLocation ? this.#sourceOrigin(roleLocation, record.origin) : record.origin;
+        const precision = mappingKind == "exact" && role && !roleLocation ? "anchor" : mappingKind;
+        const symbol = record.symbolId
+            ? this.index.provenance.symbols.find((candidate) => candidate.id == record.symbolId)
+            : undefined;
+        this.#append(text, {
+            mappingKind: precision,
+            name: name ?? symbol?.name,
+            nodeId: record.id,
+            origin,
+            role,
+            symbolId: record.symbolId
+        });
+    }
+    /**
+     * Writes source-free scaffolding with optional semantic context.
+     * @param {string} text - Generated text.
+     * @param {string} reason - Stable reason.
+     * @param {import("../semantic/types.js").SemanticNode[]} [relatedNodes] - Related nodes.
+     * @param {(string | undefined)[]} [relatedPaths] - Occurrence paths for shared related nodes.
+     * @returns {void}
+     */
+    synthetic(text, reason, relatedNodes = [], relatedPaths = []) {
+        if (text.length == 0)
+            return;
+        /** @type {Set<string>} */
+        const seen = new Set();
+        const relatedOrigins = relatedNodes.flatMap((node, index) => {
+            const record = this.index.recordFor(node, relatedPaths[index]);
+            return relatedOriginsFor(record.origin).flatMap((related) => {
+                const contextual = {
+                    ...related,
+                    nodeId: related.nodeId ?? record.id,
+                    role: related.role ?? "context"
+                };
+                const key = relatedOriginKey(contextual);
+                if (seen.has(key))
+                    return [];
+                seen.add(key);
+                return [contextual];
+            });
+        });
+        this.#append(text, { mappingKind: "synthetic", origin: { kind: "synthetic", reason, relatedOrigins } });
+    }
+    /**
+     * Returns the authoritative rich map for the current content.
+     * @returns {import("../semantic/types.js").SemantifoldMapping} Mapping.
+     */
+    finish() {
+        return {
+            coordinateSystem: "utf16",
+            generated: { content: this.code, filename: this.filename, language: this.language },
+            nodes: [...this.index.provenance.nodes],
+            schema: "SemantifoldMapping",
+            sources: [...this.index.provenance.sources],
+            spans: [...this.spans],
+            symbols: [...this.index.provenance.symbols],
+            version: 1
+        };
+    }
+    /**
+     * Appends one mapped span.
+     * @param {string} text - Generated text.
+     * @param {Omit<import("../semantic/types.js").SemantifoldMappingSpan, "generated">} annotation - Span annotation.
+     * @returns {void}
+     */
+    #append(text, annotation) {
+        if (text.includes("\r"))
+            throw new TypeError("Generated output must use deterministic LF line endings.");
+        const start = { column: this.column, line: this.line, offset: this.offset };
+        this.parts.push(text);
+        for (let index = 0; index < text.length; index++) {
+            this.offset++;
+            if (text[index] == "\n") {
+                this.line++;
+                this.column = 1;
+            }
+            else
+                this.column++;
+        }
+        const compact = /** @type {Omit<import("../semantic/types.js").SemantifoldMappingSpan, "generated">} */ (Object.fromEntries(Object.entries(annotation).filter(([, value]) => value !== undefined)));
+        this.spans.push({
+            ...compact,
+            generated: {
+                end: { column: this.column, line: this.line, offset: this.offset },
+                filename: this.filename,
+                start
+            }
+        });
+    }
+    /**
+     * Creates a direct role origin using canonical source identities.
+     * @param {import("../semantic/types.js").SourceLocation} location - Exact role range.
+     * @param {import("../semantic/types.js").SemanticOrigin} fallback - Owning origin.
+     * @returns {import("../semantic/types.js").SemanticOrigin} Role origin.
+     */
+    #sourceOrigin(location, fallback) {
+        /** @type {string | undefined} */
+        let fallbackSourceId;
+        if (fallback.kind == "source" && fallback.location.filename == location.filename)
+            fallbackSourceId = fallback.sourceId;
+        else if (fallback.kind == "derived") {
+            fallbackSourceId = fallback.origins.find((origin) => origin.location.filename == location.filename)?.sourceId;
+        }
+        else if (fallback.kind == "synthetic") {
+            fallbackSourceId = fallback.relatedOrigins.find((origin) => origin.location.filename == location.filename)?.sourceId;
+        }
+        const source = this.index.provenance.sources.find((candidate) => candidate.id == fallbackSourceId) ??
+            this.index.provenance.sources.find((candidate) => candidate.filename == location.filename);
+        return source ? { kind: "source", location, sourceId: source.id } : fallback;
+    }
+}
+/**
+ * Expands every closed provenance range in semantic order.
+ * @param {import("../semantic/types.js").SemanticOrigin} origin - Closed provenance.
+ * @returns {import("../semantic/types.js").RelatedOrigin[]} Related ranges.
+ */
+function relatedOriginsFor(origin) {
+    if (origin.kind == "source")
+        return [{ location: origin.location, sourceId: origin.sourceId }];
+    if (origin.kind == "derived")
+        return origin.origins;
+    return origin.relatedOrigins;
+}
+/**
+ * Builds a deterministic identity for one contextual related origin.
+ * @param {import("../semantic/types.js").RelatedOrigin} origin - Related origin.
+ * @returns {string} Stable identity.
+ */
+function relatedOriginKey(origin) {
+    return JSON.stringify([
+        origin.sourceId,
+        origin.location.filename,
+        origin.location.start.offset,
+        origin.location.end.offset,
+        origin.nodeId ?? null,
+        origin.symbolId ?? null,
+        origin.role ?? null
+    ]);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"writer.js","sourceRoot":"","sources":["../../../src/backends/writer.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {createGenerationIndex} from \"../semantic/provenance.js\"\n\n/** Source-aware deterministic generated-output builder. */\nexport class SourceWriter {\n  /**\n   * Creates a source-aware writer.\n   * @param {object} options - Writer options.\n   * @param {string} options.filename - Output filename.\n   * @param {import(\"../semantic/types.js\").SemanticLanguage} options.language - Output language.\n   * @param {import(\"../semantic/types.js\").SemanticModule} options.module - Semantic module.\n   * @param {{filename: string, content: string, language?: import(\"../semantic/types.js\").SemanticLanguage}[]} [options.sources] - Caller-provided sources.\n   */\n  constructor({filename, language, module, sources}) {\n    const index = createGenerationIndex(module, sources)\n\n    this.filename = filename\n    this.language = language\n    this.index = index\n    /** @type {string[]} */\n    this.parts = []\n    /** @type {import(\"../semantic/types.js\").SemantifoldMappingSpan[]} */\n    this.spans = []\n    this.offset = 0\n    this.line = 1\n    this.column = 1\n  }\n\n  /**\n   * Returns generated content so far.\n   * @returns {string} Generated content.\n   */\n  get code() {\n    return this.parts.join(\"\")\n  }\n\n  /**\n   * Returns the current JSON Pointer for one unambiguous semantic occurrence.\n   * @param {import(\"../semantic/types.js\").SemanticNode} node - Semantic node occurrence.\n   * @returns {string} Current occurrence path.\n   */\n  occurrencePath(node) {\n    return this.index.recordFor(node).path\n  }\n\n  /**\n   * Reports whether an exact parser-owned role range is available.\n   * @param {import(\"../semantic/types.js\").SemanticNode} node - Semantic node occurrence.\n   * @param {string} path - JSON Pointer for a shared node occurrence.\n   * @param {string} role - Semantic token role.\n   * @returns {boolean} Whether the role has an exact source range.\n   */\n  hasRange(node, path, role) {\n    return this.index.recordFor(node, path).ranges[role] !== undefined\n  }\n\n  /**\n   * Writes text mapped to a semantic node.\n   * @param {string} text - Generated text.\n   * @param {object} annotation - Mapping annotation.\n   * @param {import(\"../semantic/types.js\").SemanticNode} annotation.node - Semantic node.\n   * @param {\"exact\" | \"anchor\"} annotation.mappingKind - Mapping precision.\n   * @param {string} [annotation.role] - Semantic token role.\n   * @param {string} [annotation.name] - Source Map name.\n   * @param {string} [annotation.path] - JSON Pointer for a shared node occurrence.\n   * @returns {void}\n   */\n  mapped(text, {mappingKind, name, node, path, role}) {\n    if (text.length == 0) return\n\n    const record = this.index.recordFor(node, path)\n    const roleLocation = role ? record.ranges[role] : undefined\n    const origin = roleLocation ? this.#sourceOrigin(roleLocation, record.origin) : record.origin\n    const precision = mappingKind == \"exact\" && role && !roleLocation ? \"anchor\" : mappingKind\n    const symbol = record.symbolId\n      ? this.index.provenance.symbols.find((candidate) => candidate.id == record.symbolId)\n      : undefined\n\n    this.#append(text, {\n      mappingKind: precision,\n      name: name ?? symbol?.name,\n      nodeId: record.id,\n      origin,\n      role,\n      symbolId: record.symbolId\n    })\n  }\n\n  /**\n   * Writes source-free scaffolding with optional semantic context.\n   * @param {string} text - Generated text.\n   * @param {string} reason - Stable reason.\n   * @param {import(\"../semantic/types.js\").SemanticNode[]} [relatedNodes] - Related nodes.\n   * @param {(string | undefined)[]} [relatedPaths] - Occurrence paths for shared related nodes.\n   * @returns {void}\n   */\n  synthetic(text, reason, relatedNodes = [], relatedPaths = []) {\n    if (text.length == 0) return\n\n    /** @type {Set<string>} */\n    const seen = new Set()\n    const relatedOrigins = relatedNodes.flatMap((node, index) => {\n      const record = this.index.recordFor(node, relatedPaths[index])\n\n      return relatedOriginsFor(record.origin).flatMap((related) => {\n        const contextual = {\n          ...related,\n          nodeId: related.nodeId ?? record.id,\n          role: related.role ?? \"context\"\n        }\n        const key = relatedOriginKey(contextual)\n\n        if (seen.has(key)) return []\n        seen.add(key)\n\n        return [contextual]\n      })\n    })\n\n    this.#append(text, {mappingKind: \"synthetic\", origin: {kind: \"synthetic\", reason, relatedOrigins}})\n  }\n\n  /**\n   * Returns the authoritative rich map for the current content.\n   * @returns {import(\"../semantic/types.js\").SemantifoldMapping} Mapping.\n   */\n  finish() {\n    return {\n      coordinateSystem: \"utf16\",\n      generated: {content: this.code, filename: this.filename, language: this.language},\n      nodes: [...this.index.provenance.nodes],\n      schema: \"SemantifoldMapping\",\n      sources: [...this.index.provenance.sources],\n      spans: [...this.spans],\n      symbols: [...this.index.provenance.symbols],\n      version: 1\n    }\n  }\n\n  /**\n   * Appends one mapped span.\n   * @param {string} text - Generated text.\n   * @param {Omit<import(\"../semantic/types.js\").SemantifoldMappingSpan, \"generated\">} annotation - Span annotation.\n   * @returns {void}\n   */\n  #append(text, annotation) {\n    if (text.includes(\"\\r\")) throw new TypeError(\"Generated output must use deterministic LF line endings.\")\n\n    const start = {column: this.column, line: this.line, offset: this.offset}\n\n    this.parts.push(text)\n    for (let index = 0; index < text.length; index++) {\n      this.offset++\n      if (text[index] == \"\\n\") {\n        this.line++\n        this.column = 1\n      } else this.column++\n    }\n    const compact = /** @type {Omit<import(\"../semantic/types.js\").SemantifoldMappingSpan, \"generated\">} */ (\n      Object.fromEntries(Object.entries(annotation).filter(([, value]) => value !== undefined))\n    )\n\n    this.spans.push({\n      ...compact,\n      generated: {\n        end: {column: this.column, line: this.line, offset: this.offset},\n        filename: this.filename,\n        start\n      }\n    })\n  }\n\n  /**\n   * Creates a direct role origin using canonical source identities.\n   * @param {import(\"../semantic/types.js\").SourceLocation} location - Exact role range.\n   * @param {import(\"../semantic/types.js\").SemanticOrigin} fallback - Owning origin.\n   * @returns {import(\"../semantic/types.js\").SemanticOrigin} Role origin.\n   */\n  #sourceOrigin(location, fallback) {\n    /** @type {string | undefined} */\n    let fallbackSourceId\n\n    if (fallback.kind == \"source\" && fallback.location.filename == location.filename) fallbackSourceId = fallback.sourceId\n    else if (fallback.kind == \"derived\") {\n      fallbackSourceId = fallback.origins.find((origin) => origin.location.filename == location.filename)?.sourceId\n    } else if (fallback.kind == \"synthetic\") {\n      fallbackSourceId = fallback.relatedOrigins.find((origin) => origin.location.filename == location.filename)?.sourceId\n    }\n    const source = this.index.provenance.sources.find((candidate) => candidate.id == fallbackSourceId) ??\n      this.index.provenance.sources.find((candidate) => candidate.filename == location.filename)\n\n    return source ? {kind: \"source\", location, sourceId: source.id} : fallback\n  }\n}\n\n/**\n * Expands every closed provenance range in semantic order.\n * @param {import(\"../semantic/types.js\").SemanticOrigin} origin - Closed provenance.\n * @returns {import(\"../semantic/types.js\").RelatedOrigin[]} Related ranges.\n */\nfunction relatedOriginsFor(origin) {\n  if (origin.kind == \"source\") return [{location: origin.location, sourceId: origin.sourceId}]\n  if (origin.kind == \"derived\") return origin.origins\n\n  return origin.relatedOrigins\n}\n\n/**\n * Builds a deterministic identity for one contextual related origin.\n * @param {import(\"../semantic/types.js\").RelatedOrigin} origin - Related origin.\n * @returns {string} Stable identity.\n */\nfunction relatedOriginKey(origin) {\n  return JSON.stringify([\n    origin.sourceId,\n    origin.location.filename,\n    origin.location.start.offset,\n    origin.location.end.offset,\n    origin.nodeId ?? null,\n    origin.symbolId ?? null,\n    origin.role ?? null\n  ])\n}\n"]}

package/build/src/diagnostic.d.ts

@@ -0,0 +1,67 @@
+/** A clear parser, semantic, or backend capability diagnostic. */
+export declare class SemantifoldDiagnostic extends Error {
+    code: string;
+    detail: string;
+    generatedLocation: import("./semantic/types.js").SourceLocation | undefined;
+    language: import("./semantic/types.js").SemanticLanguage;
+    location: import("./semantic/types.js").SourceLocation | undefined;
+    /**
+     * Creates a diagnostic.
+     * @param {object} options - Diagnostic fields.
+     * @param {string} options.code - Stable diagnostic code.
+     * @param {string} options.message - Human-readable message.
+     * @param {import("./semantic/types.js").SemanticLanguage} options.language - Related language.
+     * @param {import("./semantic/types.js").SourceLocation | undefined} [options.location] - Related location.
+     * @param {import("./semantic/types.js").SourceLocation | undefined} [options.generatedLocation] - Pre-remapping generated location.
+     * @param {Error | undefined} [options.cause] - Preserved parser error.
+     */
+    constructor({ cause, code, generatedLocation, language, location, message }: {
+        code: string;
+        message: string;
+        language: import("./semantic/types.js").SemanticLanguage;
+        location?: import("./semantic/types.js").SourceLocation | undefined;
+        generatedLocation?: import("./semantic/types.js").SourceLocation | undefined;
+        cause?: Error | undefined;
+    });
+}
+/**
+ * Throws a normalized parser diagnostic while preserving the parser error.
+ * @param {import("./semantic/types.js").SemanticLanguage} language - Frontend language.
+ * @param {unknown} error - Opaque parser error, narrowed immediately.
+ * @returns {never} Always throws.
+ */
+export declare function parseFailure(language: import("./semantic/types.js").SemanticLanguage, error: unknown): never;
+/**
+ * Throws an unsupported-syntax diagnostic.
+ * @param {import("./semantic/types.js").SemanticLanguage} language - Frontend language.
+ * @param {string} syntax - Parser syntax kind.
+ * @param {import("./semantic/types.js").SourceLocation | undefined} location - Source location.
+ * @returns {never} Always throws.
+ */
+export declare function unsupportedSyntax(language: import("./semantic/types.js").SemanticLanguage, syntax: string, location: import("./semantic/types.js").SourceLocation | undefined): never;
+/**
+ * Throws a missing-type diagnostic.
+ * @param {import("./semantic/types.js").SemanticLanguage} language - Frontend language.
+ * @param {string} subject - Untyped subject.
+ * @param {import("./semantic/types.js").SourceLocation | undefined} location - Source location.
+ * @returns {never} Always throws.
+ */
+export declare function missingType(language: import("./semantic/types.js").SemanticLanguage, subject: string, location: import("./semantic/types.js").SourceLocation | undefined): never;
+/**
+ * Throws a language-neutral semantic diagnostic discovered after adaptation.
+ * @param {import("./semantic/types.js").SemanticLanguage} language - Source language.
+ * @param {string} code - Stable semantic diagnostic code.
+ * @param {string} detail - Human-readable semantic failure.
+ * @param {import("./semantic/types.js").SourceLocation | undefined} location - Source location.
+ * @returns {never} Always throws.
+ */
+export declare function semanticFailure(language: import("./semantic/types.js").SemanticLanguage, code: string, detail: string, location: import("./semantic/types.js").SourceLocation | undefined): never;
+/**
+ * Throws an unsupported backend-capability diagnostic.
+ * @param {import("./semantic/types.js").SemanticLanguage} language - Backend language.
+ * @param {string} capability - Unsupported semantic capability.
+ * @param {import("./semantic/types.js").SourceLocation | undefined} location - Semantic source location.
+ * @returns {never} Always throws.
+ */
+export declare function unsupportedCapability(language: import("./semantic/types.js").SemanticLanguage, capability: string, location: import("./semantic/types.js").SourceLocation | undefined): never;
+//# sourceMappingURL=diagnostic.d.ts.map

package/build/src/diagnostic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostic.d.ts","sourceRoot":"","sources":["../../src/diagnostic.js"],"names":[],"mappings":"AAEA,kEAAkE;AAClE,qBAAa,qBAAsB,SAAQ,KAAK;IAgBvC,IAAI;IACJ,MAAM;IACN,iBAAiB;IACjB,QAAQ;IACR,QAAQ;IAnBf;;;;;;;;;OASG;IACH,YAAY,EAAC,KAAK,EAAE,IAAI,EAAE,iBAAiB,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAC,EAPtE;QAAwB,IAAI,EAApB,MAAM,CACd;QAAwB,OAAO,EAAvB,MAAM,CACd;QAAgE,QAAQ,EAAhE,OAAO,qBAAqB,EAAE,gBAAgB,CACtD;QAA2E,QAAQ,AAAnF,CACA,EADQ,OAAO,qBAAqB,EAAE,cAAc,GAAG,SAAS,CAChE;QAA2E,iBAAiB,AAA5F,CACA,EADQ,OAAO,qBAAqB,EAAE,cAAc,GAAG,SAAS,CAChE;QAAoC,KAAK,AAAzC,CACF,EADU,KAAK,GAAG,SAAS,CAC3B;KACwE,EAUxE;CACF;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAJ1B,OAAO,qBAAqB,EAAE,gBAIJ,EAAE,KAAK,EAHjC,OAGiC,GAF/B,KAAK,CAWjB;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAL/B,OAAO,qBAAqB,EAAE,gBAKC,EAAE,MAAM,EAJvC,MAIuC,EAAE,QAAQ,EAHjD,OAAO,qBAAqB,EAAE,cAAc,GAAG,SAGE,GAF/C,KAAK,CASjB;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EALzB,OAAO,qBAAqB,EAAE,gBAKL,EAAE,OAAO,EAJlC,MAIkC,EAAE,QAAQ,EAH5C,OAAO,qBAAqB,EAAE,cAAc,GAAG,SAGH,GAF1C,KAAK,CASjB;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAN7B,OAAO,qBAAqB,EAAE,gBAMD,EAAE,IAAI,EALnC,MAKmC,EAAE,MAAM,EAJ3C,MAI2C,EAAE,QAAQ,EAHrD,OAAO,qBAAqB,EAAE,cAAc,GAAG,SAGM,GAFnD,KAAK,CAIjB;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EALnC,OAAO,qBAAqB,EAAE,gBAKK,EAAE,UAAU,EAJ/C,MAI+C,EAAE,QAAQ,EAHzD,OAAO,qBAAqB,EAAE,cAAc,GAAG,SAGU,GAFvD,KAAK,CASjB"}