@hanseltime/template-repo-sync 1.0.1

package/lib/cjs/merge-file.d.ts

@@ -0,0 +1,29 @@
+import { Config } from "./types";
+import { Change } from "diff";
+interface MergeFileOptions {
+    localTemplateSyncConfig: Config;
+    templateSyncConfig: Config;
+    tempCloneDir: string;
+    cwd: string;
+}
+interface MergeFileReturn {
+    /**
+     * If the file was ignored due to the local config
+     */
+    ignoredDueToLocal: boolean;
+    /**
+     * Only available if the file wasn't ignored, this is a list of lineDiffs
+     * from the the diff library that were applied to what would've been removed
+     */
+    localChanges?: Change[];
+}
+/**
+ * Applies the merge to a file according to the context information.
+ *
+ * Returns true if merged and false if skipped
+ * @param relPath
+ * @param context
+ * @returns
+ */
+export declare function mergeFile(relPath: string, context: MergeFileOptions): Promise<MergeFileReturn>;
+export {};

package/lib/cjs/merge-file.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeFile = void 0;
+const micromatch_1 = require("micromatch");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const load_plugin_1 = require("./load-plugin");
+const diff_1 = require("diff");
+const fs_extra_1 = require("fs-extra");
+/**
+ * Applies the merge to a file according to the context information.
+ *
+ * Returns true if merged and false if skipped
+ * @param relPath
+ * @param context
+ * @returns
+ */
+async function mergeFile(relPath, context) {
+    const { localTemplateSyncConfig, templateSyncConfig, tempCloneDir, cwd } = context;
+    if ((0, micromatch_1.some)(relPath, localTemplateSyncConfig.ignore)) {
+        return {
+            ignoredDueToLocal: true,
+        };
+    }
+    const ext = (0, path_1.extname)(relPath);
+    const filePath = (0, path_1.join)(cwd, relPath);
+    const templatePath = (0, path_1.join)(tempCloneDir, relPath);
+    const mergeConfig = templateSyncConfig.merge?.[ext];
+    const localMergeConfig = localTemplateSyncConfig.merge?.[ext];
+    // Either write the merge or write
+    let fileContents;
+    const localChanges = [];
+    if ((0, fs_1.existsSync)(filePath) && (mergeConfig || localMergeConfig)) {
+        const originalCurrentFile = (await (0, promises_1.readFile)(filePath)).toString();
+        if (mergeConfig) {
+            // Apply the template's most recent merges
+            const handler = await (0, load_plugin_1.loadPlugin)(mergeConfig, ext, tempCloneDir);
+            const mergeOptions = mergeConfig.rules.find((rule) => {
+                return (0, micromatch_1.isMatch)(relPath, rule.glob);
+            });
+            if (mergeOptions) {
+                fileContents = await safeMerge(handler, mergeConfig.plugin ?? `default for ${ext}`, originalCurrentFile, (await (0, promises_1.readFile)(templatePath)).toString(), {
+                    relFilePath: relPath,
+                    mergeArguments: mergeOptions.options,
+                    isLocalOptions: true,
+                });
+            }
+            else {
+                // Apply overwrite if we didn't set up merge
+                fileContents = (await (0, promises_1.readFile)(templatePath)).toString();
+            }
+        }
+        else {
+            // Apply overwrite if we didn't set up merge
+            fileContents = (await (0, promises_1.readFile)(templatePath)).toString();
+        }
+        // We apply the localMerge Config to the fileContent output by the template merge
+        if (localMergeConfig) {
+            const handler = await (0, load_plugin_1.loadPlugin)(localMergeConfig, ext, cwd);
+            const mergeOptions = localMergeConfig.rules.find((rule) => {
+                return (0, micromatch_1.isMatch)(relPath, rule.glob);
+            });
+            if (mergeOptions) {
+                const localContents = await safeMerge(handler, localMergeConfig.plugin ?? `default for ${ext}`, originalCurrentFile, fileContents, {
+                    relFilePath: relPath,
+                    mergeArguments: mergeOptions.options,
+                    isLocalOptions: true,
+                });
+                localChanges.push(...(0, diff_1.diffLines)(fileContents, localContents));
+                fileContents = localContents;
+            }
+        }
+    }
+    else {
+        // Just perform simple overwrite
+        fileContents = (await (0, promises_1.readFile)(templatePath)).toString();
+    }
+    await (0, fs_extra_1.outputFile)(filePath, fileContents);
+    return {
+        ignoredDueToLocal: false,
+        localChanges,
+    };
+}
+exports.mergeFile = mergeFile;
+/**
+ * Simple helper function to ensure that we don't let bad plugins corrupt the call flow
+ * @param plugin
+ */
+async function safeMerge(plugin, pluginPath, current, fromTemplate, context) {
+    const ret = await plugin.merge(current, fromTemplate, context);
+    if (typeof ret !== "string") {
+        throw new Error(`Plugin ${pluginPath} did not return string for merge function!  This is not allowed!`);
+    }
+    if (!ret) {
+        throw new Error(`Plugin ${pluginPath} should not make a merge be an empty string!`);
+    }
+    return ret;
+}

package/lib/cjs/plugins/index.d.ts

@@ -0,0 +1,4 @@
+import { JsonFileMergeOptions, MergePlugin } from "../types";
+export declare const defaultExtensionMap: {
+    [ext: string]: MergePlugin<JsonFileMergeOptions>;
+};

package/lib/cjs/plugins/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultExtensionMap = void 0;
+const json_merge_1 = require("./json-merge");
+exports.defaultExtensionMap = {
+    ".json": {
+        merge: json_merge_1.merge,
+        validate: json_merge_1.validate,
+    },
+};

package/lib/cjs/plugins/json-merge.d.ts

@@ -0,0 +1,3 @@
+import { MergeContext, JsonFileMergeOptions } from "../types";
+export declare function validate(options: unknown): string[];
+export declare function merge(current: string, fromTemplateRepo: string, context: MergeContext<JsonFileMergeOptions>): Promise<string>;

package/lib/cjs/plugins/json-merge.js

@@ -0,0 +1,185 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.merge = exports.validate = void 0;
+const lodash_merge_1 = __importDefault(require("lodash.merge"));
+const lodash_clonedeep_1 = __importDefault(require("lodash.clonedeep"));
+const jsonpath_1 = __importDefault(require("jsonpath"));
+const infer_json_indent_1 = require("../formatting/infer-json-indent");
+function stringOptionError(value) {
+    if (value === "overwrite" ||
+        value === "merge-template" ||
+        value === "merge-current") {
+        return;
+    }
+    return `${value} must be one of type overwrite, merge-template, or merge-current`;
+}
+function validate(options) {
+    const errors = [];
+    // check for flat options
+    if (typeof options === "string") {
+        const errMsg = stringOptionError(options);
+        if (errMsg) {
+            errors.push(errMsg);
+        }
+        return errors;
+    }
+    else {
+        if (typeof options !== "object") {
+            errors.push(`Options must be an object and not ${typeof options}`);
+            return errors;
+        }
+        if (Array.isArray(options)) {
+            errors.push(`Options must be an object and not Array`);
+            return errors;
+        }
+        if (options === null) {
+            errors.push("Options cannot be null");
+            return errors;
+        }
+    }
+    const optionsCast = options;
+    const optionKeys = Object.keys(optionsCast);
+    optionKeys.forEach((k) => {
+        if (k === "paths") {
+            optionsCast.paths.forEach((pathObj) => {
+                const [jsonPath, options] = pathObj;
+                if (jsonPath.startsWith("$.")) {
+                    try {
+                        jsonpath_1.default.parse(jsonPath);
+                    }
+                    catch (err) {
+                        errors.push(`Invalid jsonpath key: ${err}`);
+                        return;
+                    }
+                    const errMsg = stringOptionError(options);
+                    if (errMsg) {
+                        errors.push(`jsonpath ${jsonPath}: ${errMsg}`);
+                    }
+                }
+                else {
+                    errors.push(`Unrecognized jsonpath syntax: ${jsonPath}`);
+                }
+            });
+        }
+        else {
+            if (k === "ignoreNewProperties" || k === "missingIsDelete") {
+                return;
+            }
+            errors.push(`Unrecognized key: ${k}`);
+        }
+    });
+    return errors;
+}
+exports.validate = validate;
+async function merge(current, fromTemplateRepo, context) {
+    if (context.mergeArguments === "overwrite") {
+        return fromTemplateRepo;
+    }
+    const currentJson = JSON.parse(current);
+    const fromTemplateJson = JSON.parse(fromTemplateRepo);
+    if (context.mergeArguments === "merge-current") {
+        // Performs Lodash Merge with current as the override
+        return JSON.stringify((0, lodash_merge_1.default)(fromTemplateJson, currentJson), null, 4);
+    }
+    if (context.mergeArguments === "merge-template") {
+        // Performs Lodash Merge with current as the override
+        return JSON.stringify((0, lodash_merge_1.default)(currentJson, fromTemplateJson), null, 4);
+    }
+    const { missingIsDelete, ignoreNewProperties, paths } = context.mergeArguments;
+    const returnJson = (0, lodash_clonedeep_1.default)(currentJson);
+    paths.forEach((p) => {
+        const [jPath, overrideType] = p;
+        const fromTemplatePaths = new Map();
+        if (overrideType === "merge-template") {
+            // We want to make sure there aren't extra paths from the template that didn't get added
+            jsonpath_1.default.nodes(fromTemplateJson, jPath).forEach((n) => {
+                fromTemplatePaths.set(jsonpath_1.default.stringify(n.path), n.path);
+            });
+        }
+        jsonpath_1.default.nodes(currentJson, jPath).forEach(({ path, value }) => {
+            // This solves for wildcard operators
+            const fullPath = jsonpath_1.default.stringify(path);
+            // track the paths in the template we've walked
+            fromTemplatePaths.delete(fullPath);
+            jsonpath_1.default.apply(returnJson, fullPath, () => {
+                const templateValue = jsonpath_1.default.value(fromTemplateJson, fullPath);
+                if (overrideType === "merge-template") {
+                    if (templateValue === undefined) {
+                        if (missingIsDelete) {
+                            return templateValue;
+                        }
+                    }
+                    else {
+                        return applyValueMerge(value, templateValue);
+                    }
+                }
+                else if (overrideType === "merge-current") {
+                    return applyValueMerge(templateValue, value);
+                }
+                else if (overrideType === "overwrite") {
+                    if (templateValue !== undefined || missingIsDelete) {
+                        return templateValue;
+                    }
+                }
+                else {
+                    throw new Error(`Unexpected JsonPath merge value ${overrideType}`);
+                }
+                return value;
+            });
+        });
+        if (!ignoreNewProperties) {
+            for (const fromTemplatePath of fromTemplatePaths.values()) {
+                applyPerPath(fromTemplatePath, returnJson, fromTemplateJson);
+            }
+        }
+    });
+    if (!ignoreNewProperties) {
+        Object.keys(fromTemplateJson).forEach((key) => {
+            if (!returnJson[key]) {
+                returnJson[key] = fromTemplateJson[key];
+            }
+        });
+    }
+    return JSON.stringify(returnJson, null, (0, infer_json_indent_1.inferJSONIndent)(current));
+}
+exports.merge = merge;
+/**
+ * A merge from a template to template perspective is either melding objects
+ * or completely overwriting primitive types
+ */
+function applyValueMerge(base, toMerge) {
+    if (typeof base === "object" && typeof toMerge === "object") {
+        return (0, lodash_merge_1.default)(base, toMerge);
+    }
+    else {
+        return toMerge;
+    }
+}
+/**
+ * Given a nodePath on the "map" tree, this will go to the first missing element
+ * and copy that node onto the object
+ *
+ * @param nodePath
+ * @param onto
+ * @param map
+ * @param forIdx
+ */
+function applyPerPath(nodePath, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+onto, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+map, forIdx = 0) {
+    if (nodePath[forIdx] === "$") {
+        applyPerPath(nodePath, onto, map, forIdx + 1);
+        return;
+    }
+    const selector = nodePath[forIdx];
+    if (onto[selector]) {
+        applyPerPath(nodePath, onto[selector], map[selector], forIdx + 1);
+        return;
+    }
+    onto[selector] = map[selector];
+}

package/lib/cjs/template-sync.d.ts

@@ -0,0 +1,40 @@
+import { Change } from "diff";
+import { TemplateCloneDriverFn } from "./clone-drivers";
+import { TemplateDiffDriverFn } from "./diff-drivers";
+export interface TemplateSyncOptions {
+    repoUrl: string;
+    /**
+     * The directory for cloning our template repo into via the cloneDriver
+     */
+    tmpCloneDir: string;
+    /**
+     * The repo directory path that we are going to merge toward
+     */
+    repoDir: string;
+    /**
+     * Defaults to using git clone
+     */
+    cloneDriver?: TemplateCloneDriverFn;
+    /**
+     * Defaults to using git diff
+     */
+    diffDriver?: TemplateDiffDriverFn;
+}
+export interface TemplateSyncReturn {
+    /**
+     * An array of files that were skipped outright due to a templatesync.local ignore glob
+     */
+    localSkipFiles: string[];
+    /**
+     * An object mapping all file paths to any merge rules that would've overridden the merge rules
+     * of the template sync file.
+     *
+     * Note: right now, this shows non-changed diffs as well so you have to look for added or removed
+     */
+    localFileChanges: {
+        [filePath: string]: Change[];
+    };
+}
+export declare const TEMPLATE_SYNC_CONFIG = "templatesync";
+export declare const TEMPLATE_SYNC_LOCAL_CONFIG = "templatesync.local";
+export declare function templateSync(options: TemplateSyncOptions): Promise<TemplateSyncReturn>;

package/lib/cjs/template-sync.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.templateSync = exports.TEMPLATE_SYNC_LOCAL_CONFIG = exports.TEMPLATE_SYNC_CONFIG = void 0;
+const path_1 = require("path");
+const fs_1 = require("fs");
+const match_1 = require("./match");
+const merge_file_1 = require("./merge-file");
+const git_clone_1 = require("./clone-drivers/git-clone");
+const diff_drivers_1 = require("./diff-drivers");
+exports.TEMPLATE_SYNC_CONFIG = "templatesync";
+exports.TEMPLATE_SYNC_LOCAL_CONFIG = "templatesync.local";
+async function templateSync(options) {
+    const cloneDriver = options.cloneDriver ?? git_clone_1.gitClone;
+    const diffDriver = options.diffDriver ?? diff_drivers_1.gitDiff;
+    const tempCloneDir = await cloneDriver(options.tmpCloneDir, options.repoUrl);
+    // Get the clone Config
+    const cloneConfigPath = (0, path_1.join)(tempCloneDir, `${exports.TEMPLATE_SYNC_CONFIG}.json`);
+    const templateSyncConfig = (0, fs_1.existsSync)(cloneConfigPath)
+        ? JSON.parse((0, fs_1.readFileSync)(cloneConfigPath).toString())
+        : {};
+    const localConfigPath = (0, path_1.join)(options.repoDir, `${exports.TEMPLATE_SYNC_LOCAL_CONFIG}.json`);
+    const localTemplateSyncConfig = (0, fs_1.existsSync)(localConfigPath)
+        ? JSON.parse((0, fs_1.readFileSync)(localConfigPath).toString())
+        : {};
+    let filesToSync;
+    if (localTemplateSyncConfig.afterRef) {
+        filesToSync = await diffDriver(tempCloneDir, localTemplateSyncConfig.afterRef);
+    }
+    else {
+        filesToSync = (0, match_1.getAllFilesInDir)(tempCloneDir, [
+            ...templateSyncConfig.ignore,
+            ".git/**",
+        ]);
+    }
+    const localSkipFiles = [];
+    const localFileChanges = {};
+    await Promise.all(filesToSync.map(async (f) => {
+        const result = await (0, merge_file_1.mergeFile)(f, {
+            localTemplateSyncConfig,
+            templateSyncConfig,
+            tempCloneDir,
+            cwd: options.repoDir,
+        });
+        if (result.ignoredDueToLocal) {
+            localSkipFiles.push(f);
+        }
+        else if (result?.localChanges && result.localChanges.length > 0) {
+            localFileChanges[f] = result.localChanges;
+        }
+    }));
+    return {
+        localSkipFiles,
+        localFileChanges,
+    };
+}
+exports.templateSync = templateSync;

package/lib/cjs/test-utils/index.d.ts

@@ -0,0 +1,2 @@
+export declare const TEST_FIXTURES_DIR: string;
+export declare function tempDir(): string;

package/lib/cjs/test-utils/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tempDir = exports.TEST_FIXTURES_DIR = void 0;
+const path_1 = require("path");
+const os_1 = require("os");
+exports.TEST_FIXTURES_DIR = (0, path_1.resolve)(__dirname, "..", "..", "test-fixtures");
+function tempDir() {
+    return process.env.RUNNER_TEMP ?? (0, os_1.tmpdir)();
+}
+exports.tempDir = tempDir;

package/lib/cjs/types.d.ts

@@ -0,0 +1,113 @@
+/**
+ * How we want to merge json
+ *
+ * overwrite - the template sync overwrites completely
+ * merge-template - we merge template into the current json with overrides on matching values happening from the template
+ * merge-current - we merge the current json into the template json with overrides on matching values happening from the current json
+ */
+export type BaseJsonMergeOptions = "overwrite" | "merge-template" | "merge-current";
+export interface JsonPathOverrides {
+    /**
+     * If set to true, this means we won't add new properties from the template
+     */
+    ignoreNewProperties?: boolean;
+    /**
+     * If set to true, overwrite will apply undefined values as deleted for the jsonpaths
+     * or for values that are supposed to be merged on top of other values
+     */
+    missingIsDelete?: boolean;
+    /**
+     * Note, if multiple json paths match a rule, we pick the first one in the list that matches
+     */
+    paths: [
+        jsonPath: `$.${string}`,
+        options: BaseJsonMergeOptions
+    ][];
+}
+export type JsonFileMergeOptions = BaseJsonMergeOptions | JsonPathOverrides;
+type MergePluginOptions = JsonFileMergeOptions;
+/**
+ * Configuration object for a given file type merge configuration
+ */
+export interface MergeConfig<T> {
+    /**
+     * The node module, available on the calling node context, that you want to run.
+     * If not provided, we try to use any built-in merge plugins.
+     */
+    plugin?: string;
+    /**
+     * An array of first match file globs that will
+     */
+    rules: {
+        glob: string;
+        options: MergePluginOptions | T;
+    }[];
+}
+/**
+ * The shape of a template sync config file
+ */
+export interface Config<T = unknown> {
+    ignore: string[];
+    /**
+     * If there is no merge config, then we will always just overwrite the file for the diff
+     */
+    merge?: {
+        [fileExt: string]: MergeConfig<T>;
+    };
+}
+/**
+ * The shape of a local template sync config file that overrides the root template repo
+ */
+export interface LocalConfig<T = unknown> {
+    /**
+     * This is the ref that we compare against.  If empty, we use all files that have changed since the
+     * beginning of the template repo.
+     */
+    afterRef?: string;
+    ignore: string[];
+    /**
+     * If there is no merge config, then we will always just overwrite the file for the diff
+     */
+    merge?: {
+        [fileExt: string]: MergeConfig<T>;
+    };
+}
+/**
+ * Information around the file we are trying to merge and that arguments for that merge
+ * from matching a merge configuration
+ */
+export interface MergeContext<PluginOptions = unknown> {
+    relFilePath: string;
+    /**
+     * If you have provided a custom merge plugin, this will be the "options" section of
+     * the matching glob
+     */
+    mergeArguments: PluginOptions;
+    /**
+     * If this run is for the local config.  Keep in mind that any local config overrides will
+     * be run after the template sync options and we would like to report any changes that
+     * are done
+     */
+    isLocalOptions?: boolean;
+}
+export interface MergePlugin<PluginOptions> {
+    /**
+     * This method will be called when a file from the template and it's analog in the downstream repo
+     * have some differences.  The plugin must perform the merge and return the appropriate file contents
+     * as a string
+     *
+     * TODO: we may create a V2 plugin that could deal with large files and not pass around strings in memory,
+     * but for now, this is the current implementation
+     *
+     * @param current - The downstream repos current file contents
+     * @param fromTemplateRepo - the current
+     * @param context - an object defining the context around the file and the specific options
+     */
+    merge(current: string, fromTemplateRepo: string, context: MergeContext<PluginOptions>): Promise<string>;
+    /**
+     * Given an options object for the merge, this validates the options object and returns error messages if there is anything wrong.
+     * @param options any json value that the user provided - must be validated against the expected options
+     */
+    validate(options: unknown): string[] | undefined;
+}
+export {};

package/lib/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/esm/clone-drivers/git-clone.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gitClone = void 0;
+const child_process_1 = require("child_process");
+const path_1 = require("path");
+const CLONE_DIR = "cloned_repo";
+async function gitClone(tmpDir, repoUrl) {
+    (0, child_process_1.execSync)(`git clone ${repoUrl} ${CLONE_DIR}`, {
+        cwd: tmpDir,
+        env: process.env,
+    });
+    return (0, path_1.resolve)(tmpDir, CLONE_DIR);
+}
+exports.gitClone = gitClone;

package/lib/esm/clone-drivers/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./git-clone"), exports);

package/lib/esm/clone-drivers/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/esm/diff-drivers/git-diff.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gitDiff = void 0;
+const child_process_1 = require("child_process");
+async function gitDiff(gitDir, afterRef) {
+    const diffFilesStr = (0, child_process_1.execSync)(`git diff ${afterRef}.. --name-only`, {
+        cwd: gitDir,
+    })
+        .toString()
+        .trim();
+    return diffFilesStr.split("\n");
+}
+exports.gitDiff = gitDiff;

package/lib/esm/diff-drivers/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./git-diff"), exports);

package/lib/esm/diff-drivers/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/esm/formatting/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./sync-results-to-md"), exports);
+__exportStar(require("./infer-json-indent"), exports);