@happyvertical/smrt-core 0.30.0

package/dist/migrations/differ.js

@@ -0,0 +1,601 @@
+import { createLogger } from "@happyvertical/logger";
+import { detectEngine, getDDLStrategy } from "../schema/ddl/index.js";
+import "../registry.js";
+import "../utils.js";
+import { isJsonPathIndex, renderIndexTarget } from "../schema/index-utils.js";
+const logger = createLogger({ level: "info" });
+const VALID_SQL_DATA_TYPES = /* @__PURE__ */ new Set([
+  "TEXT",
+  "INTEGER",
+  "REAL",
+  "BLOB",
+  "BOOLEAN",
+  "JSON",
+  "TIMESTAMP",
+  "UUID"
+]);
+function isValidSQLDataType(type) {
+  return VALID_SQL_DATA_TYPES.has(type);
+}
+const PROTECTED_INDEX_SUFFIXES = ["_pkey", "_key"];
+function isProtectedDbIndexName(name) {
+  return PROTECTED_INDEX_SUFFIXES.some((suffix) => name.endsWith(suffix));
+}
+function resolveDatabaseUrl(db) {
+  const dbWithConfig = db;
+  return db.url || dbWithConfig.config?.url || "";
+}
+class SchemaComparer {
+  db;
+  options;
+  engine;
+  ddlStrategy;
+  constructor(db, options = {}) {
+    this.db = db;
+    this.options = {
+      includeDroppedTables: false,
+      includeDroppedColumns: false,
+      includeDroppedIndexes: false,
+      ignoreTypeMismatches: false,
+      ...options
+    };
+    this.engine = typeof this.db.exportTable === "function" ? "json" : detectEngine(resolveDatabaseUrl(this.db), this.options.engineHint);
+    this.ddlStrategy = getDDLStrategy(this.engine);
+  }
+  /**
+   * Compare manifest schemas to database and return differences
+   */
+  async compare(manifestSchemas) {
+    const diff = {
+      added_tables: [],
+      dropped_tables: [],
+      changes: [],
+      has_changes: false
+    };
+    const existingTables = await this.getExistingTables();
+    for (const [tableName, schema] of Object.entries(manifestSchemas)) {
+      if (!existingTables.has(tableName)) {
+        diff.added_tables.push(schema);
+        diff.has_changes = true;
+      } else {
+        const tableChanges = await this.compareTable(tableName, schema);
+        if (tableChanges.length > 0) {
+          diff.changes.push(...tableChanges);
+          diff.has_changes = true;
+        }
+      }
+    }
+    if (this.options.includeDroppedTables) {
+      for (const tableName of existingTables) {
+        if (tableName.startsWith("_smrt_") || tableName.startsWith("sqlite_")) {
+          continue;
+        }
+        if (!manifestSchemas[tableName]) {
+          diff.dropped_tables.push(tableName);
+          diff.has_changes = true;
+        }
+      }
+    }
+    return diff;
+  }
+  /**
+   * Compare a single table's schema to manifest
+   */
+  async compareTable(tableName, manifest) {
+    const changes = [];
+    const dbSchema = await this.db.getTableSchema?.(tableName);
+    if (!dbSchema) {
+      return changes;
+    }
+    const columnChanges = this.compareColumns(tableName, manifest, dbSchema);
+    changes.push(...columnChanges);
+    const indexChanges = this.compareIndexes(tableName, manifest, dbSchema);
+    changes.push(...indexChanges);
+    return changes;
+  }
+  /**
+   * Compare columns between manifest and database
+   */
+  compareColumns(tableName, manifest, dbSchema) {
+    const changes = [];
+    const dbColumnNames = new Set(Object.keys(dbSchema.columns));
+    for (const [colName, colDef] of Object.entries(manifest.columns)) {
+      if (!dbColumnNames.has(colName)) {
+        changes.push({
+          type: "add_column",
+          table: tableName,
+          name: colName,
+          column: colDef,
+          sql: this.generateAddColumnSQL(tableName, colName, colDef)
+        });
+      } else {
+        const dbCol = dbSchema.columns[colName];
+        const manifestType = colDef.type;
+        if (!isValidSQLDataType(manifestType)) {
+          logger.warn(
+            `[SchemaComparer] Invalid manifest type "${manifestType}" for ${tableName}.${colName}, treating as TEXT`
+          );
+        }
+        const validatedType = isValidSQLDataType(manifestType) ? manifestType : "TEXT";
+        const expectedEngineType = this.ddlStrategy.mapType(validatedType);
+        const normalizedExpected = this.normalizeType(expectedEngineType);
+        const normalizedActual = this.normalizeType(dbCol.type);
+        const isUuidTextEquivalent = this.isUuidTextEquivalentColumn(
+          colName,
+          colDef,
+          normalizedExpected,
+          normalizedActual
+        );
+        const isJsonTextEquivalent = normalizedExpected === "JSON" && normalizedActual === "TEXT" || normalizedExpected === "TEXT" && normalizedActual === "JSON";
+        if (normalizedExpected !== normalizedActual && !isUuidTextEquivalent && !isJsonTextEquivalent) {
+          if (this.isCompatibleTypeUpgrade(colDef.type, dbCol.type)) {
+            const generatedSQL = this.generateTypeUpgradeSQL(
+              tableName,
+              colName,
+              colDef,
+              dbCol.type
+            );
+            changes.push({
+              type: "type_upgrade",
+              table: tableName,
+              name: colName,
+              column: colDef,
+              mismatch: {
+                expected: colDef.type,
+                actual: dbCol.type
+              },
+              sql: generatedSQL.sql,
+              ...generatedSQL.statements ? { sqlStatements: generatedSQL.statements } : {}
+            });
+          } else if (!this.options.ignoreTypeMismatches) {
+            changes.push({
+              type: "type_mismatch",
+              table: tableName,
+              name: colName,
+              mismatch: {
+                expected: colDef.type,
+                actual: dbCol.type
+              }
+            });
+          }
+        }
+      }
+    }
+    if (this.options.includeDroppedColumns) {
+      const manifestColumnNames = new Set(Object.keys(manifest.columns));
+      for (const colName of dbColumnNames) {
+        if (!manifestColumnNames.has(colName)) {
+          changes.push({
+            type: "drop_column",
+            table: tableName,
+            name: colName,
+            sql: this.generateDropColumnSQL(tableName, colName)
+          });
+        }
+      }
+    }
+    return changes;
+  }
+  isUuidTextEquivalentColumn(columnName, colDef, normalizedExpected, normalizedActual) {
+    const expectedUuidActualText = normalizedExpected === "UUID" && normalizedActual === "TEXT";
+    const expectedTextActualUuid = normalizedExpected === "TEXT" && normalizedActual === "UUID";
+    if (!expectedUuidActualText && !expectedTextActualUuid) {
+      return false;
+    }
+    return this.isStructuralUuidCompatibleColumn(columnName, colDef);
+  }
+  isStructuralUuidCompatibleColumn(columnName, colDef) {
+    return colDef.primaryKey === true || Boolean(colDef.foreignKey) || colDef.referenceKind === "id" || colDef.referenceKind === "foreignKey" || colDef.referenceKind === "crossPackageRef" || colDef.referenceKind === "tenantId" || columnName === "id" && colDef.type === "TEXT";
+  }
+  /**
+   * Compare indexes between manifest and database
+   *
+   * Three classes of drift the differ now detects:
+   *
+   * 1. **Missing index** — manifest has an index neither the DB has by name
+   *    nor any equivalent-by-signature. Emit `add_index`. (Issue #741: the
+   *    signature check protects against creating duplicates when STI child
+   *    classes register indexes with different name prefixes.)
+   *
+   * 2. **Same-name shape drift** — DB has an index with the manifest's name,
+   *    but its columns or uniqueness flag differ. This is the failure mode
+   *    in issue #1165: `tenants_slug_context_meta_type_idx` exists but is
+   *    non-unique, while the manifest declares it unique. Emit
+   *    `drop_index` + `add_index` so the next migrate cycle recreates it
+   *    with the correct shape.
+   *
+   * 3. **Orphan in DB** — DB has an index with no manifest counterpart by
+   *    name and no signature equivalent. Emit `drop_index` *only* when the
+   *    caller opts in via `includeDroppedIndexes`, and even then never for
+   *    PostgreSQL implicit indexes (`*_pkey`, `*_key`) — those are owned by
+   *    table-level constraints and need a separate `DROP CONSTRAINT` path
+   *    that the differ does not emit yet.
+   */
+  compareIndexes(tableName, manifest, dbSchema) {
+    const changes = [];
+    const dbIndexesByName = /* @__PURE__ */ new Map();
+    const dbIndexSignatures = /* @__PURE__ */ new Map();
+    for (const idx of dbSchema.indexes) {
+      const unique = idx.unique ?? false;
+      dbIndexesByName.set(idx.name, { columns: idx.columns, unique });
+      const signature = this.getIndexSignature(idx.columns, unique);
+      let bucket = dbIndexSignatures.get(signature);
+      if (!bucket) {
+        bucket = /* @__PURE__ */ new Set();
+        dbIndexSignatures.set(signature, bucket);
+      }
+      bucket.add(idx.name);
+    }
+    const manifestSignatureSet = /* @__PURE__ */ new Set();
+    for (const idx of manifest.indexes) {
+      manifestSignatureSet.add(this.getIndexSignature(idx));
+    }
+    const claimedDbIndexes = /* @__PURE__ */ new Set();
+    for (const idx of manifest.indexes) {
+      const manifestSignature = this.getIndexSignature(idx);
+      const dbByName = dbIndexesByName.get(idx.name);
+      if (dbByName) {
+        claimedDbIndexes.add(idx.name);
+        if (isJsonPathIndex(idx)) {
+          continue;
+        }
+        const dbSignature = this.getIndexSignature(
+          dbByName.columns,
+          dbByName.unique
+        );
+        if (dbSignature === manifestSignature) {
+          continue;
+        }
+        changes.push({
+          type: "drop_index",
+          table: tableName,
+          name: idx.name,
+          sql: this.generateDropIndexSQL(idx.name)
+        });
+        changes.push({
+          type: "add_index",
+          table: tableName,
+          name: idx.name,
+          index: idx,
+          sql: this.generateAddIndexSQL(tableName, idx)
+        });
+        continue;
+      }
+      const equivalentIndexNames = dbIndexSignatures.get(manifestSignature);
+      if (equivalentIndexNames && equivalentIndexNames.size > 0) {
+        for (const name of equivalentIndexNames) {
+          claimedDbIndexes.add(name);
+        }
+        continue;
+      }
+      changes.push({
+        type: "add_index",
+        table: tableName,
+        name: idx.name,
+        index: idx,
+        sql: this.generateAddIndexSQL(tableName, idx)
+      });
+    }
+    if (this.options.includeDroppedIndexes) {
+      for (const idx of dbSchema.indexes) {
+        if (claimedDbIndexes.has(idx.name)) continue;
+        if (isProtectedDbIndexName(idx.name)) continue;
+        const idxSignature = this.getIndexSignature(
+          idx.columns,
+          idx.unique ?? false
+        );
+        if (manifestSignatureSet.has(idxSignature)) continue;
+        changes.push({
+          type: "drop_index",
+          table: tableName,
+          name: idx.name,
+          sql: this.generateDropIndexSQL(idx.name)
+        });
+      }
+    }
+    return changes;
+  }
+  /**
+   * Generate a signature for an index based on its columns and uniqueness.
+   * Used for functional equivalence checking (Issue #741).
+   *
+   * Note: Column order is preserved because it is semantically significant for
+   * composite indexes. An index on (a, b) is NOT equivalent to (b, a) - they
+   * have different query performance characteristics.
+   *
+   * Limitation: Partial indexes (with WHERE clauses) are not fully supported.
+   * The database introspection layer doesn't provide WHERE clause information,
+   * so two partial indexes with the same columns but different WHERE clauses
+   * cannot be distinguished and may be incorrectly treated as equivalent.
+   *
+   * For JSON-path indexes (`@meta({ indexed: true })`) the signature is
+   * derived from the JSON path instead of an empty column list, so the
+   * differ can distinguish two jsonPath indexes against different paths.
+   *
+   * @param idxOrColumns - Either an IndexDefinition or a column array (legacy)
+   * @param uniqueArg - Unique flag (used when first arg is a column array)
+   * @returns Signature string
+   */
+  getIndexSignature(idxOrColumns, uniqueArg) {
+    if (Array.isArray(idxOrColumns)) {
+      return `${idxOrColumns.join(",")}:${Boolean(uniqueArg)}`;
+    }
+    const idx = idxOrColumns;
+    if (isJsonPathIndex(idx) && idx.jsonPath) {
+      return `json:${idx.jsonPath.column}.${idx.jsonPath.path}:${Boolean(idx.unique)}`;
+    }
+    return `${(idx.columns ?? []).join(",")}:${Boolean(idx.unique)}`;
+  }
+  /**
+   * Get list of existing tables from database
+   */
+  async getExistingTables() {
+    let query;
+    if (this.engine === "postgres") {
+      query = `SELECT table_name FROM information_schema.tables WHERE table_schema = 'public'`;
+    } else {
+      query = `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'`;
+    }
+    const result = await this.db.query(query);
+    const rows = result.rows;
+    return new Set(
+      rows.map((r) => r.name || r.table_name || "").filter(Boolean)
+    );
+  }
+  /**
+   * Normalize SQL types for comparison
+   */
+  normalizeType(type) {
+    const upper = type.toUpperCase().trim();
+    if (/^(INTEGER|INT|BIGINT|SMALLINT|TINYINT)$/i.test(upper)) {
+      return "INTEGER";
+    }
+    if (/^(TEXT|CLOB|STRING|VARCHAR|CHAR)/i.test(upper)) {
+      return "TEXT";
+    }
+    if (/^UUID$/i.test(upper)) {
+      return "UUID";
+    }
+    if (/^(REAL|FLOAT|DOUBLE|DECIMAL|NUMERIC|NUMBER)/i.test(upper)) {
+      return "REAL";
+    }
+    if (/^(BOOLEAN|BOOL)/i.test(upper)) {
+      return "BOOLEAN";
+    }
+    if (/^(DATETIME|TIMESTAMP|DATE|TIME)/i.test(upper)) {
+      return "TIMESTAMP";
+    }
+    if (/^(BLOB|BINARY|BYTEA)/i.test(upper)) {
+      return "BLOB";
+    }
+    if (/^(JSON|JSONB)/i.test(upper)) {
+      return "JSON";
+    }
+    return upper;
+  }
+  /**
+   * Check if a type change is a safe upgrade that can be auto-migrated.
+   *
+   * SMRT controls the data lifecycle for these columns, so we know:
+   * - TEXT→JSON: The column stores JSON data serialized as text (arrays, objects)
+   * - TEXT/JSON→TIMESTAMP: Legacy system columns stored timestamp strings
+   *   before newer manifests normalized the column type.
+   * - INTEGER→REAL: Safe widening of integer to floating point
+   * - TEXT/REAL→INTEGER on PostgreSQL: explicit data-checked repairs for
+   *   legacy integer columns that were previously stored as text/real.
+   *
+   * @param manifestType - The abstract type from the manifest (e.g., 'JSON')
+   * @param dbType - The actual type in the database (e.g., 'TEXT')
+   * @returns true if the change from dbType to manifestType is a safe upgrade
+   */
+  isCompatibleTypeUpgrade(manifestType, dbType) {
+    const manifest = this.normalizeType(manifestType);
+    const db = this.normalizeType(dbType);
+    if (manifest === "JSON" && db === "TEXT") {
+      return true;
+    }
+    if (manifest === "TEXT" && db === "JSON") {
+      return true;
+    }
+    if (manifest === "TEXT" && db === "UUID") {
+      return true;
+    }
+    if (manifest === "REAL" && db === "INTEGER") {
+      return true;
+    }
+    if (this.engine === "postgres" && manifest === "INTEGER" && (db === "TEXT" || db === "REAL")) {
+      return true;
+    }
+    if (manifest === "TIMESTAMP" && (db === "TEXT" || db === "JSON")) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Generate SQL for a type upgrade migration.
+   *
+   * Engine-specific SQL:
+   * - SQLite: TEXT and JSON are equivalent, no-op or comment
+   * - DuckDB: ALTER COLUMN TYPE (native type conversion)
+   * - PostgreSQL: ALTER COLUMN TYPE with USING clause
+   */
+  generateTypeUpgradeSQL(tableName, colName, colDef, dbType) {
+    const quotedTable = this.quoteIdentifier(tableName);
+    const quotedCol = this.quoteIdentifier(colName);
+    const manifestType = colDef.type;
+    const validatedType = isValidSQLDataType(manifestType) ? manifestType : "TEXT";
+    const targetType = this.ddlStrategy.mapType(validatedType);
+    switch (this.engine) {
+      case "sqlite":
+        if (this.normalizeType(manifestType) === "JSON" && this.normalizeType(dbType) === "TEXT") {
+          return {
+            sql: `-- SQLite: ${quotedCol} already stores JSON as TEXT (no change needed)`
+          };
+        }
+        return {
+          sql: `-- SQLite: Type upgrade for ${quotedCol} requires table recreation`
+        };
+      case "postgres": {
+        const manifestNormalized = this.normalizeType(manifestType);
+        const dbNormalized = this.normalizeType(dbType);
+        const preflightSQL = manifestNormalized === "INTEGER" && (dbNormalized === "TEXT" || dbNormalized === "REAL") ? this.generatePostgresIntegerPreflightSQL(
+          quotedTable,
+          quotedCol,
+          tableName,
+          colName,
+          dbNormalized
+        ) : null;
+        const clauses = [];
+        if (colDef.defaultValue !== void 0) {
+          clauses.push(`ALTER COLUMN ${quotedCol} DROP DEFAULT`);
+        }
+        let typeClause = `ALTER COLUMN ${quotedCol} TYPE ${targetType}`;
+        if (manifestNormalized === "JSON" && dbNormalized === "TEXT") {
+          typeClause += ` USING to_jsonb(${quotedCol})`;
+        } else if (manifestNormalized === "TEXT" && dbNormalized === "JSON") {
+          typeClause += ` USING ${quotedCol}::text`;
+        } else if (manifestNormalized === "TEXT" && dbNormalized === "UUID") {
+          typeClause += ` USING ${quotedCol}::text`;
+        } else if (manifestNormalized === "INTEGER" && dbNormalized === "TEXT") {
+          typeClause += ` USING trim(${quotedCol}::text)::integer`;
+        } else if (manifestNormalized === "INTEGER" && dbNormalized === "REAL") {
+          typeClause += ` USING ${quotedCol}::integer`;
+        } else if (manifestNormalized === "TIMESTAMP" && (dbNormalized === "TEXT" || dbNormalized === "JSON")) {
+          typeClause += ` USING NULLIF(NULLIF(trim(both '"' from ${quotedCol}::text), ''), 'null')::timestamp`;
+        }
+        clauses.push(typeClause);
+        if (colDef.defaultValue !== void 0) {
+          const formattedDefault = this.ddlStrategy.formatDefaultValue(
+            colDef.defaultValue,
+            validatedType
+          );
+          const defaultSql = manifestNormalized === "JSON" ? `${formattedDefault}::${targetType.toLowerCase()}` : formattedDefault;
+          clauses.push(`ALTER COLUMN ${quotedCol} SET DEFAULT ${defaultSql}`);
+        }
+        const alterSql = `ALTER TABLE ${quotedTable} ${clauses.join(", ")}`;
+        return preflightSQL ? { sql: alterSql, statements: [preflightSQL, alterSql] } : { sql: alterSql };
+      }
+      case "duckdb":
+        return {
+          sql: `ALTER TABLE ${quotedTable} ALTER COLUMN ${quotedCol} TYPE ${targetType}`
+        };
+      default: {
+        const safeDbType = dbType.replace(/[^\w]/g, "_");
+        const safeManifestType = manifestType.replace(/[^\w]/g, "_");
+        return {
+          sql: `-- Type upgrade for ${quotedCol}: ${safeDbType} → ${safeManifestType}`
+        };
+      }
+    }
+  }
+  /**
+   * Quote a SQL identifier
+   */
+  quoteIdentifier(name) {
+    return `"${name.replace(/"/g, '""')}"`;
+  }
+  /**
+   * Generate a PostgreSQL preflight guard for narrowing legacy columns to
+   * INTEGER. PostgreSQL's REAL→INTEGER cast rounds fractional values, so the
+   * generated migration must fail before the ALTER can silently change data.
+   */
+  generatePostgresIntegerPreflightSQL(quotedTable, quotedCol, tableName, colName, dbNormalized) {
+    const invalidCondition = dbNormalized === "REAL" ? `${quotedCol} IS NOT NULL AND ${quotedCol} <> trunc(${quotedCol})` : `${quotedCol} IS NOT NULL AND trim(${quotedCol}::text) !~ '^[+-]?[0-9]+$'`;
+    const message = `Cannot convert ${tableName}.${colName} to INTEGER: found non-integer values`;
+    return `DO $$ BEGIN IF EXISTS (SELECT 1 FROM ${quotedTable} WHERE ${invalidCondition}) THEN RAISE EXCEPTION ${this.quoteLiteral(message)}; END IF; END $$`;
+  }
+  quoteLiteral(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+  }
+  /**
+   * Generate SQL for adding a column
+   */
+  generateAddColumnSQL(tableName, colName, colDef) {
+    const validatedType = isValidSQLDataType(colDef.type) ? colDef.type : "TEXT";
+    if (!isValidSQLDataType(colDef.type)) {
+      logger.warn(
+        `[SchemaComparer] Invalid manifest type "${colDef.type}" for ${tableName}.${colName}, treating as TEXT`
+      );
+    }
+    const parts = [
+      this.quoteIdentifier(colName),
+      this.ddlStrategy.mapType(validatedType)
+    ];
+    if (colDef.notNull) {
+      parts.push("NOT NULL");
+    }
+    if (colDef.unique) {
+      parts.push("UNIQUE");
+    }
+    if (colDef.defaultValue !== void 0) {
+      const defaultVal = this.ddlStrategy.formatDefaultValue(
+        colDef.defaultValue,
+        validatedType
+      );
+      parts.push(`DEFAULT ${defaultVal}`);
+    }
+    if (colDef.check) {
+      parts.push(`CHECK (${colDef.check})`);
+    }
+    const columnDefinition = parts.join(" ");
+    return `ALTER TABLE ${this.quoteIdentifier(tableName)} ADD COLUMN ${columnDefinition}`;
+  }
+  /**
+   * Generate SQL for dropping a column
+   */
+  generateDropColumnSQL(tableName, colName) {
+    return `ALTER TABLE ${this.quoteIdentifier(tableName)} DROP COLUMN ${this.quoteIdentifier(colName)}`;
+  }
+  /**
+   * Generate SQL for adding an index
+   */
+  generateAddIndexSQL(tableName, idx) {
+    const uniqueStr = idx.unique ? "UNIQUE " : "";
+    const target = renderIndexTarget(idx, this.engine);
+    return `CREATE ${uniqueStr}INDEX ${this.quoteIdentifier(idx.name)} ON ${this.quoteIdentifier(tableName)} (${target})`;
+  }
+  /**
+   * Generate SQL for dropping an index.
+   *
+   * This SQL is consumed by the manifest-driven execution path:
+   *
+   * - `db:migrate` runs the SQL we put in `change.sql` directly, with the
+   *   tracker's `executePostgresStatements` adding CONCURRENTLY when
+   *   `--postgres-safe` is on.
+   *
+   * PostgreSQL ends up with `CONCURRENTLY` when it should.
+   * Keeping this method engine-agnostic also means the diff preview text
+   * stays readable (no engine-specific noise) for engines like SQLite
+   * where CONCURRENTLY isn't a thing.
+   */
+  generateDropIndexSQL(indexName) {
+    return `DROP INDEX IF EXISTS ${this.quoteIdentifier(indexName)}`;
+  }
+}
+async function generateSchemaDiff(db, manifestSchemas, options = {}) {
+  const comparer = new SchemaComparer(db, options);
+  return comparer.compare(manifestSchemas);
+}
+function hasActionableChanges(diff) {
+  if (diff.added_tables.length > 0) return true;
+  if (diff.dropped_tables.length > 0) return true;
+  return diff.changes.some((c) => c.type !== "type_mismatch");
+}
+function getSQLFromDiff(diff) {
+  const statements = [];
+  for (const change of diff.changes) {
+    if (change.type !== "type_mismatch") {
+      statements.push(
+        ...change.sqlStatements ?? (change.sql ? [change.sql] : [])
+      );
+    }
+  }
+  return statements;
+}
+export {
+  SchemaComparer,
+  generateSchemaDiff,
+  getSQLFromDiff,
+  hasActionableChanges
+};
+//# sourceMappingURL=differ.js.map