supaschema 0.1.0-rc.1

package/dist/planner.js

@@ -0,0 +1,385 @@
+import { resolveConfig } from "./config.js";
+import { diagnostic } from "./diagnostics.js";
+import { sha256, stableJson } from "./hash.js";
+import { sortOperations } from "./plan-order.js";
+import { isDestructiveAllowed, refineReplaceOperation } from "./planner-replace.js";
+import { makeTableAlterOperation } from "./planner-table.js";
+export function planSchemaDiff(from, to, options = {}) {
+    const config = resolveConfig(options.config);
+    const operations = [];
+    const diagnostics = [...from.diagnostics, ...to.diagnostics];
+    const fromMap = objectMap(from.objects);
+    const toMap = objectMap(to.objects);
+    const consumedFrom = new Set();
+    const consumedTo = new Set();
+    if (config.renameDetection === "hints-only") {
+        for (const hint of config.hints.renames ?? []) {
+            const before = fromMap.get(hint.from);
+            const after = toMap.get(hint.to);
+            if (!before || !after) {
+                diagnostics.push(diagnostic("SUPA_PLAN_RENAME_HINT_UNMATCHED", "error", "rename hint does not match both source and target objects", {
+                    hint: `from=${hint.from} to=${hint.to}`,
+                }));
+                continue;
+            }
+            const operation = makeRenameOperation(before, after);
+            operations.push(operation);
+            consumedFrom.add(before.key);
+            consumedTo.add(after.key);
+        }
+    }
+    for (const [key, before] of fromMap) {
+        if (consumedFrom.has(key)) {
+            continue;
+        }
+        const after = toMap.get(key);
+        if (!after) {
+            operations.push(makeOperation("drop", key, before, undefined, config));
+            continue;
+        }
+        if (before.hash !== after.hash) {
+            operations.push(makeEnumAddValuesOperation(before, after) ??
+                makeTableAlterOperation(before, after, config) ??
+                refineReplaceOperation(makeOperation("replace", key, before, after, config), config));
+        }
+    }
+    for (const [key, after] of toMap) {
+        if (consumedTo.has(key)) {
+            continue;
+        }
+        if (!fromMap.has(key)) {
+            operations.push(makeOperation("create", key, undefined, after, config));
+        }
+    }
+    appendReplacedRelationDependents(operations, to, config);
+    const sortedOperations = sortOperations(operations, diagnostics);
+    for (const operation of operations) {
+        diagnostics.push(...operation.diagnostics);
+    }
+    if (sortedOperations.length === 0 && from.fingerprint !== to.fingerprint) {
+        diagnostics.push(emptyPlanDriftDiagnostic(fromMap, toMap, from, to));
+    }
+    return {
+        diagnostics,
+        fingerprint: sha256(stableJson({
+            from: from.fingerprint,
+            operations: sortedOperations.map((operation) => ({
+                key: operation.key,
+                kind: operation.kind,
+            })),
+            to: to.fingerprint,
+        })),
+        from: from.source,
+        fromFingerprint: from.fingerprint,
+        operations: sortedOperations,
+        to: to.source,
+        toFingerprint: to.fingerprint,
+    };
+}
+function objectMap(objects) {
+    return new Map(objects.map((object) => [object.key, object]));
+}
+const replacedRelationKinds = new Set(["table", "materialized-view"]);
+const relationDependentKinds = new Set([
+    "constraint",
+    "index",
+    "rls",
+    "policy",
+    "trigger",
+]);
+/**
+ * A relation replace renders DROP + CREATE, which destroys every dependent
+ * object in the target database even when that dependent is unchanged
+ * between the two models (equal hashes produce no operation). Re-create the
+ * to-state dependents alongside the replace so the rebuilt relation keeps
+ * its constraints, indexes, RLS state, policies, triggers, and grants.
+ */
+function appendReplacedRelationDependents(operations, to, config) {
+    const replacedRelations = operations
+        .filter((operation) => operation.kind === "replace" && replacedRelationKinds.has(operation.ref.kind))
+        .map((operation) => operation.ref);
+    if (replacedRelations.length === 0) {
+        return;
+    }
+    const operationKeys = new Set(operations.map((operation) => operation.key));
+    for (const relation of replacedRelations) {
+        for (const object of to.objects) {
+            if (operationKeys.has(object.key) || !isRelationDependent(object, relation)) {
+                continue;
+            }
+            operations.push(makeOperation("create", object.key, undefined, object, config));
+            operationKeys.add(object.key);
+        }
+    }
+}
+function isRelationDependent(object, relation) {
+    const schema = relation.schema ?? "public";
+    if (relationDependentKinds.has(object.ref.kind) &&
+        object.ref.table === relation.name &&
+        (object.ref.schema ?? "public") === schema) {
+        return true;
+    }
+    return (object.ref.kind === "grant" &&
+        typeof object.metadata.targetIdentity === "string" &&
+        object.metadata.targetIdentity === `${schema}.${relation.name}`);
+}
+/**
+ * A diff engine's worst failure mode is an empty plan over states that
+ * actually differ. Zero operations must imply equal model fingerprints; when
+ * it does not, fail loud with the divergence instead of rendering a no-op.
+ */
+function emptyPlanDriftDiagnostic(fromMap, toMap, from, to) {
+    const differing = [];
+    for (const [key, before] of fromMap) {
+        const after = toMap.get(key);
+        if (!after) {
+            differing.push(`missing in target: ${key}`);
+        }
+        else if (before.hash !== after.hash) {
+            differing.push(`hash drift: ${key}`);
+        }
+    }
+    for (const key of toMap.keys()) {
+        if (!fromMap.has(key)) {
+            differing.push(`missing in source: ${key}`);
+        }
+    }
+    const sample = differing.slice(0, 12).join("; ");
+    return diagnostic("SUPA_PLAN_EMPTY_WITH_DRIFT", "error", "plan contains no operations but the model fingerprints differ", {
+        hint: differing.length > 0
+            ? `${differing.length} differing object(s): ${sample}`
+            : `object sets are identical; fingerprint basis differs (from=${from.fingerprint} to=${to.fingerprint}) — check model format versions`,
+    });
+}
+function makeOperation(kind, key, before, after, config) {
+    const object = after ?? before;
+    if (!object) {
+        throw new Error(`operation ${kind} for ${key} has no object`);
+    }
+    const diagnostics = [];
+    const destructive = isDestructive(kind, object.ref.kind);
+    let blocked = false;
+    if (destructive && !isDestructiveAllowed(key, config)) {
+        blocked = true;
+        const difference = kind === "replace" ? describeReplaceDifference(before, after) : undefined;
+        diagnostics.push(diagnostic("SUPA_PLAN_DESTRUCTIVE_HINT_REQUIRED", "error", `${kind} of ${object.ref.kind} requires an explicit destructive-change hint${difference ? ` — ${difference}` : ""}`, {
+            hint: `Add "${key}" to hints.destructive only after reviewing the migration.`,
+            ref: object.ref,
+        }));
+    }
+    if (kind === "replace" && object.ref.kind === "view") {
+        diagnostics.push(diagnostic("SUPA_PLAN_VIEW_REPLACE_VERIFY_REQUIRED", "warning", "PostgreSQL only permits CREATE OR REPLACE VIEW when the replacement shape is compatible", {
+            hint: "Run supaschema verify against a disposable PostgreSQL database before release.",
+            ref: object.ref,
+        }));
+    }
+    if ((kind === "create" || kind === "replace") &&
+        object.ref.kind === "index" &&
+        object.metadata.concurrent === true &&
+        config.adapter === "supabase-auto") {
+        blocked = true;
+        diagnostics.push(diagnostic("SUPA_PLAN_CONCURRENT_INDEX_UNSUPPORTED", "error", "CREATE INDEX CONCURRENTLY cannot run inside the transaction Supabase db push uses", {
+            hint: "Create the index without CONCURRENTLY, or run it through an explicit out-of-transaction operational lane.",
+            ref: object.ref,
+        }));
+    }
+    const operation = {
+        blocked,
+        destructive,
+        diagnostics,
+        key,
+        kind,
+        metadata: {},
+        ref: object.ref,
+    };
+    if (before) {
+        operation.before = before;
+    }
+    if (after) {
+        operation.after = after;
+    }
+    return operation;
+}
+function makeRenameOperation(before, after) {
+    const diagnostics = [];
+    let blocked = false;
+    if (before.ref.kind !== after.ref.kind) {
+        blocked = true;
+        diagnostics.push(diagnostic("SUPA_PLAN_RENAME_KIND_MISMATCH", "error", "rename hint changes object kind", {
+            hint: `${before.key} -> ${after.key}`,
+            ref: after.ref,
+        }));
+    }
+    if (!isSupportedRenameKind(after.ref.kind)) {
+        blocked = true;
+        diagnostics.push(diagnostic("SUPA_PLAN_RENAME_UNSUPPORTED", "error", `${after.ref.kind} renames are not yet rendered safely`, {
+            hint: "Keep this change hand-authored or model it as an explicit create/drop with hints.",
+            ref: after.ref,
+        }));
+    }
+    if (!sameRenameNamespace(before.ref, after.ref)) {
+        blocked = true;
+        diagnostics.push(diagnostic("SUPA_PLAN_RENAME_SET_SCHEMA_UNSUPPORTED", "error", "rename hints cannot move an object between schemas", {
+            hint: `${before.key} -> ${after.key}`,
+            ref: after.ref,
+        }));
+    }
+    diagnostics.push(diagnostic("SUPA_PLAN_RENAME_VERIFY_REQUIRED", "warning", "explicit rename hints must be verified against a disposable PostgreSQL database", {
+        hint: `${before.key} -> ${after.key}`,
+        ref: after.ref,
+    }));
+    return {
+        after,
+        before,
+        blocked,
+        destructive: false,
+        diagnostics,
+        key: `${before.key}->${after.key}`,
+        kind: "rename",
+        metadata: {},
+        ref: after.ref,
+    };
+}
+function makeEnumAddValuesOperation(before, after) {
+    if (before.ref.kind !== "enum" || after.ref.kind !== "enum") {
+        return undefined;
+    }
+    const beforeValues = enumValues(before);
+    const afterValues = enumValues(after);
+    if (!beforeValues || !afterValues || afterValues.length <= beforeValues.length) {
+        return undefined;
+    }
+    const isPrefix = beforeValues.every((value, index) => afterValues[index] === value);
+    if (!isPrefix) {
+        return undefined;
+    }
+    return {
+        after,
+        before,
+        blocked: false,
+        destructive: false,
+        diagnostics: [],
+        key: after.key,
+        kind: "alter",
+        metadata: { addEnumValues: afterValues.slice(beforeValues.length) },
+        ref: after.ref,
+    };
+}
+function enumValues(object) {
+    const values = object.metadata.values;
+    if (!Array.isArray(values)) {
+        return undefined;
+    }
+    const strings = values.filter((value) => typeof value === "string");
+    return strings.length === values.length ? strings : undefined;
+}
+/**
+ * Names what actually differs between the two definitions so a gated replace
+ * is reviewable without manually diffing SQL. Tables get a per-column report
+ * from their canonical shapes; other kinds report a definition change.
+ */
+function describeReplaceDifference(before, after) {
+    if (!before || !after) {
+        return undefined;
+    }
+    const beforeShape = asShape(before.metadata.canonicalShape);
+    const afterShape = asShape(after.metadata.canonicalShape);
+    if (!beforeShape || !afterShape) {
+        return "definition differs";
+    }
+    const parts = [];
+    const beforeColumns = shapeColumns(beforeShape);
+    const afterColumns = shapeColumns(afterShape);
+    for (const [name, column] of beforeColumns) {
+        const other = afterColumns.get(name);
+        if (!other) {
+            parts.push(`column "${name}" only in current state`);
+            continue;
+        }
+        if (stableJson(column) !== stableJson(other)) {
+            const changed = Object.keys({ ...column, ...other }).filter((field) => stableJson(column[field]) !== stableJson(other[field]));
+            parts.push(`column "${name}" differs (${changed.join(", ")})`);
+        }
+    }
+    for (const name of afterColumns.keys()) {
+        if (!beforeColumns.has(name)) {
+            parts.push(`column "${name}" only in target state`);
+        }
+    }
+    const beforeRest = stableJson({ ...beforeShape, columns: undefined });
+    const afterRest = stableJson({ ...afterShape, columns: undefined });
+    if (beforeRest !== afterRest) {
+        const keys = new Set([...Object.keys(beforeShape), ...Object.keys(afterShape)]);
+        keys.delete("columns");
+        const changed = [...keys].filter((field) => stableJson(beforeShape[field]) !== stableJson(afterShape[field]));
+        parts.push(`table options differ (${changed.join(", ")})`);
+    }
+    return parts.length > 0 ? parts.join("; ") : "definition differs";
+}
+function asShape(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function shapeColumns(shape) {
+    const columns = Array.isArray(shape.columns) ? shape.columns : [];
+    const byName = new Map();
+    for (const column of columns) {
+        const record = asShape(column);
+        if (record && typeof record.name === "string") {
+            byName.set(record.name, record);
+        }
+    }
+    return byName;
+}
+function isDestructive(kind, objectKind) {
+    if (kind === "alter" || kind === "create" || kind === "rename") {
+        return false;
+    }
+    if (kind === "drop") {
+        return [
+            "schema",
+            "table",
+            "foreign-data-wrapper",
+            "foreign-server",
+            "foreign-table",
+            "type",
+            "domain",
+            "enum",
+            "sequence",
+            "materialized-view",
+            "grant",
+            "default-privilege",
+            "rls",
+        ].includes(objectKind);
+    }
+    return [
+        "table",
+        "foreign-data-wrapper",
+        "foreign-server",
+        "foreign-table",
+        "type",
+        "domain",
+        "enum",
+        "materialized-view",
+        "rls",
+    ].includes(objectKind);
+}
+function isSupportedRenameKind(kind) {
+    return [
+        "schema",
+        "table",
+        "sequence",
+        "index",
+        "function",
+        "procedure",
+        "view",
+        "materialized-view",
+    ].includes(kind);
+}
+function sameRenameNamespace(before, after) {
+    if (before.kind === "schema" && after.kind === "schema") {
+        return true;
+    }
+    return (before.schema ?? "public") === (after.schema ?? "public");
+}

package/dist/render-guards.d.ts

@@ -0,0 +1,12 @@
+import type { MigrationOperation, ObjectRef, SchemaObject } from "./core.js";
+export declare function ensureSemicolon(sql: string): string;
+export declare function quoteLiteral(value: string): string;
+export declare function qualifiedRef(ref: ObjectRef): string;
+export declare function qualifiedTableRef(ref: ObjectRef): string;
+export declare function renderRename(operation: MigrationOperation): string;
+export declare function renderTypeGuard(object: SchemaObject): string;
+export declare function renderFdwGuard(object: SchemaObject): string;
+export declare function renderConstraintGuard(object: SchemaObject): string;
+export declare function renderGrantDrop(object: SchemaObject): string;
+export declare function renderDefaultPrivilegeDrop(object: SchemaObject): string;
+//# sourceMappingURL=render-guards.d.ts.map

package/dist/render-guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-guards.d.ts","sourceRoot":"","sources":["../src/render-guards.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAG7E,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAGnD;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAElD;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,SAAS,GAAG,MAAM,CAEnD;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,SAAS,GAAG,MAAM,CAExD;AAED,wBAAgB,YAAY,CAAC,SAAS,EAAE,kBAAkB,GAAG,MAAM,CAkBlE;AAsCD,wBAAgB,eAAe,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAW5D;AAID,wBAAgB,cAAc,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAS3D;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAmBlE;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAiB5D;AAED,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAuBvE"}

package/dist/render-guards.js

@@ -0,0 +1,159 @@
+import { formatQualifiedName, quoteIdent } from "./sql/identifiers.js";
+export function ensureSemicolon(sql) {
+    const trimmed = sql.trim();
+    return trimmed.endsWith(";") ? trimmed : `${trimmed};`;
+}
+export function quoteLiteral(value) {
+    return `'${value.replaceAll("'", "''")}'`;
+}
+export function qualifiedRef(ref) {
+    return formatQualifiedName(ref.schema, ref.name);
+}
+export function qualifiedTableRef(ref) {
+    return formatQualifiedName(ref.schema, ref.table ?? ref.name);
+}
+export function renderRename(operation) {
+    const before = requiredBefore(operation);
+    const after = requiredAfter(operation);
+    const oldExists = existsExpression(before);
+    const newExists = existsExpression(after);
+    const renameSql = renderRenameStatement(before.ref, after.ref);
+    const conflict = quoteLiteral(`supaschema rename conflict: both ${before.key} and ${after.key} exist`);
+    return `DO $supaschema$
+BEGIN
+  IF ${oldExists} AND ${newExists} THEN
+    RAISE EXCEPTION ${conflict};
+  ELSIF ${oldExists} THEN
+    ${renameSql}
+  END IF;
+END
+$supaschema$;`;
+}
+function renderRenameStatement(before, after) {
+    switch (after.kind) {
+        case "schema":
+            return `ALTER SCHEMA ${quoteIdent(before.name)} RENAME TO ${quoteIdent(after.name)};`;
+        case "table":
+            return `ALTER TABLE ${qualifiedRef(before)} RENAME TO ${quoteIdent(after.name)};`;
+        case "sequence":
+            return `ALTER SEQUENCE ${qualifiedRef(before)} RENAME TO ${quoteIdent(after.name)};`;
+        case "index":
+            return `ALTER INDEX ${qualifiedRef(before)} RENAME TO ${quoteIdent(after.name)};`;
+        case "view":
+            return `ALTER VIEW ${qualifiedRef(before)} RENAME TO ${quoteIdent(after.name)};`;
+        case "materialized-view":
+            return `ALTER MATERIALIZED VIEW ${qualifiedRef(before)} RENAME TO ${quoteIdent(after.name)};`;
+        case "function":
+            return `ALTER FUNCTION ${qualifiedRef(before)}(${before.signature ?? ""}) RENAME TO ${quoteIdent(after.name)};`;
+        case "procedure":
+            return `ALTER PROCEDURE ${qualifiedRef(before)}(${before.signature ?? ""}) RENAME TO ${quoteIdent(after.name)};`;
+        default:
+            throw new Error(`unsupported rename operation for ${after.kind}`);
+    }
+}
+// Guard bodies schema-qualify every catalog reference so a hostile or
+// unusual search_path cannot redirect the existence check.
+function existsExpression(object) {
+    const ref = object.ref;
+    if (ref.kind === "schema") {
+        return `EXISTS (SELECT 1 FROM pg_catalog.pg_namespace WHERE nspname = ${quoteLiteral(ref.name)})`;
+    }
+    if (ref.kind === "function" || ref.kind === "procedure") {
+        return `pg_catalog.to_regprocedure(${quoteLiteral(`${qualifiedRef(ref)}(${ref.signature ?? ""})`)}) IS NOT NULL`;
+    }
+    return `pg_catalog.to_regclass(${quoteLiteral(qualifiedRef(ref))}) IS NOT NULL`;
+}
+export function renderTypeGuard(object) {
+    const schema = object.ref.schema ?? "public";
+    const name = object.ref.name;
+    const catalogCheck = `SELECT 1 FROM pg_catalog.pg_type t JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace WHERE n.nspname = ${quoteLiteral(schema)} AND t.typname = ${quoteLiteral(name)}`;
+    return `DO $supaschema$
+BEGIN
+  IF NOT EXISTS (${catalogCheck}) THEN
+    ${ensureSemicolon(object.sql)}
+  END IF;
+END
+$supaschema$;`;
+}
+// CREATE FOREIGN DATA WRAPPER has no IF NOT EXISTS form, so replay safety
+// comes from a catalog-guarded DO block like types use.
+export function renderFdwGuard(object) {
+    const catalogCheck = `SELECT 1 FROM pg_catalog.pg_foreign_data_wrapper WHERE fdwname = ${quoteLiteral(object.ref.name)}`;
+    return `DO $supaschema$
+BEGIN
+  IF NOT EXISTS (${catalogCheck}) THEN
+    ${ensureSemicolon(object.sql)}
+  END IF;
+END
+$supaschema$;`;
+}
+export function renderConstraintGuard(object) {
+    const schema = object.ref.schema ?? "public";
+    const table = object.ref.table ?? object.ref.name;
+    const name = object.ref.name;
+    return `DO $supaschema$
+BEGIN
+  IF NOT EXISTS (
+    SELECT 1
+    FROM pg_catalog.pg_constraint c
+    JOIN pg_catalog.pg_class r ON r.oid = c.conrelid
+    JOIN pg_catalog.pg_namespace n ON n.oid = r.relnamespace
+    WHERE n.nspname = ${quoteLiteral(schema)}
+      AND r.relname = ${quoteLiteral(table)}
+      AND c.conname = ${quoteLiteral(name)}
+  ) THEN
+    ${ensureSemicolon(object.sql)}
+  END IF;
+END
+$supaschema$;`;
+}
+export function renderGrantDrop(object) {
+    const verb = object.metadata.verb;
+    const privileges = object.metadata.privileges;
+    const kindPhrase = object.metadata.kindPhrase;
+    const target = object.metadata.target;
+    const grantee = object.metadata.grantee;
+    if (verb !== "GRANT" ||
+        !Array.isArray(privileges) ||
+        typeof kindPhrase !== "string" ||
+        typeof target !== "string" ||
+        typeof grantee !== "string") {
+        return `-- Manual privilege removal required for ${object.key}`;
+    }
+    const role = grantee === "PUBLIC" ? "PUBLIC" : quoteIdent(grantee);
+    return `REVOKE ${privileges.map(String).join(", ")} ON ${kindPhrase} ${target} FROM ${role};`;
+}
+export function renderDefaultPrivilegeDrop(object) {
+    const verb = object.metadata.verb;
+    const privileges = object.metadata.privileges;
+    const objectType = object.metadata.objectType;
+    const grantee = object.metadata.grantee;
+    if (verb !== "GRANT" ||
+        !Array.isArray(privileges) ||
+        typeof objectType !== "string" ||
+        typeof grantee !== "string") {
+        return `-- Manual privilege removal required for ${object.key}`;
+    }
+    const forRole = typeof object.metadata.forRole === "string" ? object.metadata.forRole : undefined;
+    const schema = typeof object.metadata.schema === "string" ? object.metadata.schema : undefined;
+    const role = grantee === "PUBLIC" ? "PUBLIC" : quoteIdent(grantee);
+    const clauses = [
+        "ALTER DEFAULT PRIVILEGES",
+        forRole ? `FOR ROLE ${quoteIdent(forRole)}` : "",
+        schema ? `IN SCHEMA ${quoteIdent(schema)}` : "",
+        `REVOKE ${privileges.map(String).join(", ")} ON ${objectType} FROM ${role}`,
+    ].filter(Boolean);
+    return `${clauses.join(" ")};`;
+}
+function requiredBefore(operation) {
+    if (!operation.before) {
+        throw new Error(`operation ${operation.key} has no before object`);
+    }
+    return operation.before;
+}
+function requiredAfter(operation) {
+    if (!operation.after) {
+        throw new Error(`operation ${operation.key} has no after object`);
+    }
+    return operation.after;
+}

package/dist/render.d.ts

@@ -0,0 +1,7 @@
+import type { MigrationPlan, RenderOptions } from "./core.js";
+export declare function renderMigrationSplit(plan: MigrationPlan, options?: RenderOptions): {
+    concurrentSql?: string;
+    sql: string;
+};
+export declare function renderMigration(plan: MigrationPlan, options?: RenderOptions): string;
+//# sourceMappingURL=render.d.ts.map

package/dist/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../src/render.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAGV,aAAa,EACb,aAAa,EAId,MAAM,WAAW,CAAC;AAgBnB,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,aAAa,EACnB,OAAO,GAAE,aAAkB,GAC1B;IAAE,aAAa,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAezC;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,EAAE,OAAO,GAAE,aAAkB,GAAG,MAAM,CAcxF"}