@contractual/differs.core 0.1.0-dev.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (C) 2025 Omer Morad
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/assemble.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Result assembly — classify, format, summarize, and compute suggestedBump
+ */
+import type { RawChange, ChangeSeverity, DiffResult } from '@contractual/types';
+export interface AssembleOptions {
+    contract?: string;
+    classifyFn?: (change: RawChange, newSchema: unknown) => ChangeSeverity;
+}
+export declare function assembleResult(rawChanges: RawChange[], resolvedNewSchema: unknown, options?: AssembleOptions): DiffResult;
+//# sourceMappingURL=assemble.d.ts.map

package/dist/assemble.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assemble.d.ts","sourceRoot":"","sources":["../src/assemble.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAU,cAAc,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAIxF,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,OAAO,KAAK,cAAc,CAAC;CACxE;AAED,wBAAgB,cAAc,CAC5B,UAAU,EAAE,SAAS,EAAE,EACvB,iBAAiB,EAAE,OAAO,EAC1B,OAAO,CAAC,EAAE,eAAe,GACxB,UAAU,CAkCZ"}

package/dist/assemble.js

@@ -0,0 +1,42 @@
+/**
+ * Result assembly — classify, format, summarize, and compute suggestedBump
+ */
+import { classify, classifyPropertyAdded } from './classifiers.js';
+import { formatChangeMessage } from './format.js';
+export function assembleResult(rawChanges, resolvedNewSchema, options) {
+    const classifyChange = options?.classifyFn ?? defaultClassify;
+    const changes = rawChanges.map((raw) => ({
+        path: raw.path,
+        severity: classifyChange(raw, resolvedNewSchema),
+        category: raw.type,
+        message: formatChangeMessage(raw),
+        oldValue: raw.oldValue,
+        newValue: raw.newValue,
+    }));
+    const summary = {
+        breaking: changes.filter((c) => c.severity === 'breaking').length,
+        nonBreaking: changes.filter((c) => c.severity === 'non-breaking').length,
+        patch: changes.filter((c) => c.severity === 'patch').length,
+        unknown: changes.filter((c) => c.severity === 'unknown').length,
+    };
+    const suggestedBump = summary.breaking > 0
+        ? 'major'
+        : summary.nonBreaking > 0
+            ? 'minor'
+            : summary.patch > 0
+                ? 'patch'
+                : 'none';
+    return {
+        contract: options?.contract ?? '',
+        changes,
+        summary,
+        suggestedBump,
+    };
+}
+function defaultClassify(change, newSchema) {
+    if (change.type === 'property-added') {
+        return classifyPropertyAdded(change, newSchema);
+    }
+    return classify(change);
+}
+//# sourceMappingURL=assemble.js.map

package/dist/assemble.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assemble.js","sourceRoot":"","sources":["../src/assemble.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,QAAQ,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AACnE,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAOlD,MAAM,UAAU,cAAc,CAC5B,UAAuB,EACvB,iBAA0B,EAC1B,OAAyB;IAEzB,MAAM,cAAc,GAAG,OAAO,EAAE,UAAU,IAAI,eAAe,CAAC;IAE9D,MAAM,OAAO,GAAa,UAAU,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;QACjD,IAAI,EAAE,GAAG,CAAC,IAAI;QACd,QAAQ,EAAE,cAAc,CAAC,GAAG,EAAE,iBAAiB,CAAC;QAChD,QAAQ,EAAE,GAAG,CAAC,IAAI;QAClB,OAAO,EAAE,mBAAmB,CAAC,GAAG,CAAC;QACjC,QAAQ,EAAE,GAAG,CAAC,QAAQ;QACtB,QAAQ,EAAE,GAAG,CAAC,QAAQ;KACvB,CAAC,CAAC,CAAC;IAEJ,MAAM,OAAO,GAAG;QACd,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,UAAU,CAAC,CAAC,MAAM;QACjE,WAAW,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,cAAc,CAAC,CAAC,MAAM;QACxE,KAAK,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAC,MAAM;QAC3D,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,MAAM;KAChE,CAAC;IAEF,MAAM,aAAa,GACjB,OAAO,CAAC,QAAQ,GAAG,CAAC;QAClB,CAAC,CAAC,OAAO;QACT,CAAC,CAAC,OAAO,CAAC,WAAW,GAAG,CAAC;YACvB,CAAC,CAAC,OAAO;YACT,CAAC,CAAC,OAAO,CAAC,KAAK,GAAG,CAAC;gBACjB,CAAC,CAAC,OAAO;gBACT,CAAC,CAAC,MAAM,CAAC;IAEjB,OAAO;QACL,QAAQ,EAAE,OAAO,EAAE,QAAQ,IAAI,EAAE;QACjC,OAAO;QACP,OAAO;QACP,aAAa;KACd,CAAC;AACJ,CAAC;AAED,SAAS,eAAe,CAAC,MAAiB,EAAE,SAAkB;IAC5D,IAAI,MAAM,CAAC,IAAI,KAAK,gBAAgB,EAAE,CAAC;QACrC,OAAO,qBAAqB,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAClD,CAAC;IACD,OAAO,QAAQ,CAAC,MAAM,CAAC,CAAC;AAC1B,CAAC"}

package/dist/classifiers.d.ts

@@ -0,0 +1,87 @@
+/**
+ * JSON Schema Change Classifiers
+ *
+ * Classifies raw structural changes into severity levels for semantic versioning.
+ * Follows API compatibility principles where breaking changes require major bumps,
+ * additive changes require minor bumps, and metadata changes are patches.
+ */
+import type { RawChange, ChangeType, ChangeSeverity } from '@contractual/types';
+/**
+ * Export classification sets for external analysis
+ */
+export declare const CLASSIFICATION_SETS: {
+    readonly breaking: ReadonlySet<ChangeType>;
+    readonly nonBreaking: ReadonlySet<ChangeType>;
+    readonly patch: ReadonlySet<ChangeType>;
+    readonly unknown: ReadonlySet<ChangeType>;
+};
+/**
+ * Classify a raw change into a severity level
+ *
+ * Uses the Strands API classification rules where:
+ * - Breaking changes require major version bump
+ * - Non-breaking changes require minor version bump
+ * - Patch changes are metadata/annotation only
+ * - Unknown changes require manual review
+ *
+ * @param change - The raw change to classify
+ * @returns The severity classification
+ *
+ * @example
+ * ```typescript
+ * const change: RawChange = {
+ *   path: '/properties/name',
+ *   type: 'property-removed',
+ *   oldValue: { type: 'string' },
+ * };
+ * const severity = classify(change);
+ * // severity === 'breaking'
+ * ```
+ */
+export declare function classify(change: RawChange): ChangeSeverity;
+/**
+ * Classify a property-added change with schema context
+ *
+ * Property additions are breaking if the property is required,
+ * otherwise they are non-breaking (additive).
+ *
+ * @param change - The property-added change
+ * @param newSchema - The new schema for context (to check required array)
+ * @returns The severity classification
+ *
+ * @example
+ * ```typescript
+ * const change: RawChange = {
+ *   path: '/properties/email',
+ *   type: 'property-added',
+ *   newValue: { type: 'string', format: 'email' },
+ * };
+ *
+ * const schema = {
+ *   type: 'object',
+ *   properties: { email: { type: 'string', format: 'email' } },
+ *   required: ['email'], // email is required!
+ * };
+ *
+ * const severity = classifyPropertyAdded(change, schema);
+ * // severity === 'breaking' (because email is in required[])
+ * ```
+ */
+export declare function classifyPropertyAdded(change: RawChange, newSchema: unknown): ChangeSeverity;
+/**
+ * Batch classify multiple changes
+ *
+ * @param changes - Array of raw changes
+ * @param newSchema - Optional schema for context-aware classification
+ * @returns Map of change to severity
+ */
+export declare function classifyAll(changes: readonly RawChange[], newSchema?: unknown): Map<RawChange, ChangeSeverity>;
+/**
+ * Get a human-readable message for a classified change
+ *
+ * @param change - The raw change
+ * @param severity - The classified severity
+ * @returns Human-readable description
+ */
+export declare function getChangeMessage(change: RawChange, severity: ChangeSeverity): string;
+//# sourceMappingURL=classifiers.d.ts.map

package/dist/classifiers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classifiers.d.ts","sourceRoot":"","sources":["../src/classifiers.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AA+IhF;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;CAKtB,CAAC;AAEX;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,cAAc,CAsB1D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,OAAO,GAAG,cAAc,CA6B3F;AAgGD;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,SAAS,SAAS,EAAE,EAC7B,SAAS,CAAC,EAAE,OAAO,GAClB,GAAG,CAAC,SAAS,EAAE,cAAc,CAAC,CAYhC;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,cAAc,GAAG,MAAM,CAapF"}

package/dist/classifiers.js

@@ -0,0 +1,375 @@
+/**
+ * JSON Schema Change Classifiers
+ *
+ * Classifies raw structural changes into severity levels for semantic versioning.
+ * Follows API compatibility principles where breaking changes require major bumps,
+ * additive changes require minor bumps, and metadata changes are patches.
+ */
+/**
+ * Change types that are always breaking (require major version bump)
+ *
+ * These changes can break existing consumers:
+ * - Removing properties removes data they may depend on
+ * - Adding required fields forces consumers to provide new data
+ * - Type changes can break parsing/validation
+ * - Enum removals can invalidate existing data
+ * - Tightened constraints can reject previously valid data
+ * - Composition option additions can change validation semantics
+ *
+ * Aligned with Strands API classification rules.
+ */
+const BREAKING_CHANGES = new Set([
+    'property-removed',
+    'required-added',
+    'type-changed',
+    'type-narrowed',
+    'enum-value-removed',
+    'enum-added',
+    'constraint-tightened',
+    'additional-properties-denied',
+    'items-changed',
+    'min-items-increased',
+    'max-items-decreased',
+    'ref-target-changed',
+    'dependent-required-added',
+    // Composition breaking changes (per Strands API)
+    'anyof-option-added',
+    'oneof-option-added',
+    'allof-member-added',
+    'not-schema-changed',
+    // OpenAPI structural breaking changes
+    'path-removed',
+    'operation-removed',
+    'parameter-added',
+    'parameter-removed',
+    'parameter-required-changed',
+    'request-body-added',
+    'response-removed',
+    'security-changed',
+]);
+/**
+ * Change types that are non-breaking (require minor version bump)
+ *
+ * These changes are backward compatible additions/relaxations:
+ * - Adding optional properties extends the schema without breaking
+ * - Removing required constraints makes the schema more permissive
+ * - Type widening accepts more values
+ * - Loosened constraints accept more values
+ * - Composition option removals make schema less restrictive
+ *
+ * Aligned with Strands API classification rules.
+ */
+const NON_BREAKING_CHANGES = new Set([
+    'property-added',
+    'required-removed',
+    'type-widened',
+    'enum-value-added',
+    'enum-removed',
+    'constraint-loosened',
+    'additional-properties-allowed',
+    'additional-properties-changed',
+    'dependent-required-removed',
+    // Composition non-breaking changes (per Strands API)
+    'anyof-option-removed',
+    'oneof-option-removed',
+    'allof-member-removed',
+    // OpenAPI structural non-breaking changes
+    'path-added',
+    'operation-added',
+    'request-body-removed',
+    'response-added',
+    'server-changed',
+]);
+/**
+ * Change types that are patches (documentation/metadata only)
+ *
+ * These changes don't affect validation behavior:
+ * - Description changes are documentation only
+ * - Title changes are display metadata
+ * - Default/example changes don't affect validation
+ * - Format is an annotation (per Strands API) - doesn't affect validation
+ * - Annotation keywords (deprecated, readOnly, writeOnly)
+ * - Content keywords (contentEncoding, contentMediaType, contentSchema)
+ *
+ * Aligned with Strands API classification rules.
+ */
+const PATCH_CHANGES = new Set([
+    // Metadata changes
+    'description-changed',
+    'title-changed',
+    'default-changed',
+    'examples-changed',
+    // Format is annotation (patch per Strands API)
+    'format-added',
+    'format-removed',
+    'format-changed',
+    // Annotation keywords (Draft 2019-09+)
+    'deprecated-changed',
+    'read-only-changed',
+    'write-only-changed',
+    // Content keywords
+    'content-encoding-changed',
+    'content-media-type-changed',
+    'content-schema-changed',
+]);
+/**
+ * Change types that require manual review
+ *
+ * These changes are too complex to classify automatically:
+ * - Generic composition changes require semantic analysis
+ * - Complex keywords (propertyNames, dependentSchemas, unevaluated*)
+ * - Conditional schema changes (if/then/else)
+ * - Unknown changes need human evaluation
+ *
+ * Aligned with Strands API classification rules.
+ */
+const UNKNOWN_CHANGES = new Set([
+    // Complex object keywords
+    'property-names-changed',
+    'dependent-schemas-changed',
+    'unevaluated-properties-changed',
+    // Complex array keywords
+    'unevaluated-items-changed',
+    'min-contains-changed',
+    'max-contains-changed',
+    // Conditional schema
+    'if-then-else-changed',
+    // Legacy/generic composition
+    'composition-changed',
+    // OpenAPI context-dependent (schema-level changes handled by walker)
+    'parameter-schema-changed',
+    'response-schema-changed',
+    // Catch-all
+    'unknown-change',
+]);
+/**
+ * Export classification sets for external analysis
+ */
+export const CLASSIFICATION_SETS = {
+    breaking: BREAKING_CHANGES,
+    nonBreaking: NON_BREAKING_CHANGES,
+    patch: PATCH_CHANGES,
+    unknown: UNKNOWN_CHANGES,
+};
+/**
+ * Classify a raw change into a severity level
+ *
+ * Uses the Strands API classification rules where:
+ * - Breaking changes require major version bump
+ * - Non-breaking changes require minor version bump
+ * - Patch changes are metadata/annotation only
+ * - Unknown changes require manual review
+ *
+ * @param change - The raw change to classify
+ * @returns The severity classification
+ *
+ * @example
+ * ```typescript
+ * const change: RawChange = {
+ *   path: '/properties/name',
+ *   type: 'property-removed',
+ *   oldValue: { type: 'string' },
+ * };
+ * const severity = classify(change);
+ * // severity === 'breaking'
+ * ```
+ */
+export function classify(change) {
+    const { type } = change;
+    // Check each category in order of specificity
+    if (BREAKING_CHANGES.has(type)) {
+        return 'breaking';
+    }
+    if (NON_BREAKING_CHANGES.has(type)) {
+        return 'non-breaking';
+    }
+    if (PATCH_CHANGES.has(type)) {
+        return 'patch';
+    }
+    if (UNKNOWN_CHANGES.has(type)) {
+        return 'unknown';
+    }
+    // Defensive: any unhandled type is unknown
+    return 'unknown';
+}
+/**
+ * Classify a property-added change with schema context
+ *
+ * Property additions are breaking if the property is required,
+ * otherwise they are non-breaking (additive).
+ *
+ * @param change - The property-added change
+ * @param newSchema - The new schema for context (to check required array)
+ * @returns The severity classification
+ *
+ * @example
+ * ```typescript
+ * const change: RawChange = {
+ *   path: '/properties/email',
+ *   type: 'property-added',
+ *   newValue: { type: 'string', format: 'email' },
+ * };
+ *
+ * const schema = {
+ *   type: 'object',
+ *   properties: { email: { type: 'string', format: 'email' } },
+ *   required: ['email'], // email is required!
+ * };
+ *
+ * const severity = classifyPropertyAdded(change, schema);
+ * // severity === 'breaking' (because email is in required[])
+ * ```
+ */
+export function classifyPropertyAdded(change, newSchema) {
+    // Validate change type
+    if (change.type !== 'property-added') {
+        return classify(change);
+    }
+    // Extract property name from path
+    const propertyName = extractPropertyName(change.path);
+    if (!propertyName) {
+        // Cannot determine property name, fall back to non-breaking
+        return 'non-breaking';
+    }
+    // Find the parent schema containing this property
+    const parentSchema = findParentSchema(change.path, newSchema);
+    if (!parentSchema) {
+        // Cannot find parent schema, fall back to non-breaking
+        return 'non-breaking';
+    }
+    // Check if property is in the required array
+    const required = getRequiredArray(parentSchema);
+    if (required.includes(propertyName)) {
+        // Adding a required property is breaking
+        return 'breaking';
+    }
+    // Adding an optional property is non-breaking
+    return 'non-breaking';
+}
+/**
+ * Extract the property name from a JSON Pointer path
+ *
+ * @param path - JSON Pointer path (e.g., '/properties/name' or '/properties/user/properties/email')
+ * @returns The property name or null if not found
+ */
+function extractPropertyName(path) {
+    // Match the last /properties/NAME segment
+    const match = path.match(/\/properties\/([^/]+)$/);
+    if (match?.[1] !== undefined) {
+        return decodeJsonPointerSegment(match[1]);
+    }
+    return null;
+}
+/**
+ * Decode a JSON Pointer segment (handles ~0 and ~1 escapes)
+ *
+ * @param segment - The encoded segment
+ * @returns The decoded segment
+ */
+function decodeJsonPointerSegment(segment) {
+    return segment.replace(/~1/g, '/').replace(/~0/g, '~');
+}
+/**
+ * Find the parent schema containing a property
+ *
+ * @param path - JSON Pointer path to the property
+ * @param schema - The root schema
+ * @returns The parent schema or null if not found
+ */
+function findParentSchema(path, schema) {
+    if (!isObject(schema)) {
+        return null;
+    }
+    // Remove the last segment to get parent path
+    // e.g., '/properties/name' -> '' (root)
+    // e.g., '/properties/user/properties/email' -> '/properties/user'
+    const segments = path.split('/').filter(Boolean);
+    // We need to navigate to the schema containing /properties/NAME
+    // So we remove 'properties' and 'NAME' from the end
+    if (segments.length < 2) {
+        // Path is too short, parent is root
+        return schema;
+    }
+    // Remove 'NAME' and 'properties' from the end
+    const parentSegments = segments.slice(0, -2);
+    // Navigate to parent
+    let current = schema;
+    for (const segment of parentSegments) {
+        if (!isObject(current)) {
+            return null;
+        }
+        const decoded = decodeJsonPointerSegment(segment);
+        current = current[decoded];
+    }
+    return current;
+}
+/**
+ * Get the required array from a schema object
+ *
+ * @param schema - The schema object
+ * @returns Array of required property names
+ */
+function getRequiredArray(schema) {
+    if (!isObject(schema)) {
+        return [];
+    }
+    const obj = schema;
+    const required = obj['required'];
+    if (!Array.isArray(required)) {
+        return [];
+    }
+    return required.filter((item) => typeof item === 'string');
+}
+/**
+ * Type guard for objects
+ */
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * Batch classify multiple changes
+ *
+ * @param changes - Array of raw changes
+ * @param newSchema - Optional schema for context-aware classification
+ * @returns Map of change to severity
+ */
+export function classifyAll(changes, newSchema) {
+    const results = new Map();
+    for (const change of changes) {
+        if (change.type === 'property-added' && newSchema !== undefined) {
+            results.set(change, classifyPropertyAdded(change, newSchema));
+        }
+        else {
+            results.set(change, classify(change));
+        }
+    }
+    return results;
+}
+/**
+ * Get a human-readable message for a classified change
+ *
+ * @param change - The raw change
+ * @param severity - The classified severity
+ * @returns Human-readable description
+ */
+export function getChangeMessage(change, severity) {
+    const severityLabel = severity === 'breaking'
+        ? 'BREAKING'
+        : severity === 'non-breaking'
+            ? 'Non-breaking'
+            : severity === 'patch'
+                ? 'Patch'
+                : 'Unknown';
+    const typeLabel = formatChangeType(change.type);
+    return `[${severityLabel}] ${typeLabel} at ${change.path}`;
+}
+/**
+ * Format a change type into a human-readable label
+ */
+function formatChangeType(type) {
+    return type
+        .split('-')
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ');
+}
+//# sourceMappingURL=classifiers.js.map

package/dist/classifiers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"classifiers.js","sourceRoot":"","sources":["../src/classifiers.ts"],"names":[],"mappings":"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"}

package/dist/format.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Human-readable message formatting for raw changes
+ */
+import type { RawChange } from '@contractual/types';
+/**
+ * Format a human-readable message for a change
+ *
+ * @param change - The raw change to format
+ * @returns Human-readable message describing the change
+ */
+export declare function formatChangeMessage(change: RawChange): string;
+//# sourceMappingURL=format.d.ts.map

package/dist/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../src/format.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,CA4F7D"}