@hanseltime/template-repo-sync 2.2.1 → 2.4.0-alpha.0

package/dist/esm/plugins/json-merge.spec.mjs

@@ -0,0 +1,469 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */ import * as commentJson from "comment-json";
+import { merge, validate } from "./json-merge.mjs";
+const testFileJson = {
+    here: "here",
+    another: 23,
+    inner: {
+        el1: "el1",
+        arr1: [
+            "a1",
+            "a2"
+        ],
+        nested: {
+            final: "final",
+            final2: "final2"
+        }
+    }
+};
+const templateFileJson = {
+    here: "heretemplate",
+    extra: "extra",
+    inner: {
+        arr1: [
+            "b1",
+            "b2"
+        ],
+        extra2: "extra2"
+    }
+};
+const testCommentJson = `{
+  // This is a top comment
+  "here": "here",
+  "another": 23, // this is inline
+  "inner": {
+    "el1": "el1",
+    "arr1": ["a1", "a2"],
+    "nested": {
+      // Upper comment
+      "final": "final", // Inline commment
+      "final2": "final2",
+    },
+  },
+}`;
+describe("merge", ()=>{
+    it("performs overwrite when specified", async ()=>{
+        const fromTemplateJson = {
+            fullOverride: true
+        };
+        expect(JSON.parse(await merge(JSON.stringify(testFileJson), JSON.stringify(fromTemplateJson), {
+            relFilePath: "somepath",
+            mergeArguments: "overwrite"
+        }))).toEqual(fromTemplateJson);
+    });
+    it("performs lodash merge-template when specified", async ()=>{
+        expect(JSON.parse(await merge(JSON.stringify(testFileJson), JSON.stringify(templateFileJson), {
+            relFilePath: "somepath",
+            mergeArguments: "merge-template"
+        }))).toEqual({
+            here: "heretemplate",
+            extra: "extra",
+            another: 23,
+            inner: {
+                el1: "el1",
+                arr1: [
+                    "b1",
+                    "b2"
+                ],
+                extra2: "extra2",
+                nested: {
+                    final: "final",
+                    final2: "final2"
+                }
+            }
+        });
+    });
+    it("performs lodash merge-current when specified", async ()=>{
+        expect(JSON.parse(await merge(JSON.stringify(testFileJson), JSON.stringify(templateFileJson), {
+            relFilePath: "somepath",
+            mergeArguments: "merge-current"
+        }))).toEqual({
+            here: "here",
+            extra: "extra",
+            another: 23,
+            inner: {
+                el1: "el1",
+                arr1: [
+                    "a1",
+                    "a2"
+                ],
+                extra2: "extra2",
+                nested: {
+                    final: "final",
+                    final2: "final2"
+                }
+            }
+        });
+    });
+    it("performs pathjson merges with default non-path values", async ()=>{
+        expect(JSON.parse(await merge(JSON.stringify(testFileJson), JSON.stringify(templateFileJson), {
+            relFilePath: "somepath",
+            mergeArguments: {
+                paths: [
+                    [
+                        "$.here",
+                        "merge-template"
+                    ],
+                    [
+                        "$.inner.arr1",
+                        "merge-template"
+                    ],
+                    [
+                        "$.inner.el1",
+                        "overwrite"
+                    ]
+                ]
+            }
+        }))).toEqual({
+            here: "heretemplate",
+            // This is the extra here since we add missing
+            extra: "extra",
+            another: 23,
+            inner: {
+                // This will stay here
+                el1: "el1",
+                arr1: [
+                    "b1",
+                    "b2"
+                ],
+                // extra2 doesn't show up since we didn't dictate it
+                nested: {
+                    final: "final",
+                    final2: "final2"
+                }
+            }
+        });
+    });
+    it("performs pathjson merges with missing deletions", async ()=>{
+        expect(JSON.parse(await merge(JSON.stringify(testFileJson), JSON.stringify(templateFileJson), {
+            relFilePath: "somepath",
+            mergeArguments: {
+                missingIsDelete: true,
+                paths: [
+                    [
+                        "$.here",
+                        "merge-template"
+                    ],
+                    [
+                        "$.inner.nested",
+                        "overwrite"
+                    ]
+                ]
+            }
+        }))).toEqual({
+            here: "heretemplate",
+            extra: "extra",
+            another: 23,
+            inner: {
+                el1: "el1",
+                arr1: [
+                    "a1",
+                    "a2"
+                ]
+            }
+        });
+    });
+    it("performs pathjson merges with ignore new", async ()=>{
+        expect(JSON.parse(await merge(JSON.stringify(testFileJson), JSON.stringify(templateFileJson), {
+            relFilePath: "somepath",
+            mergeArguments: {
+                ignoreNewProperties: true,
+                paths: [
+                    [
+                        "$.here",
+                        "merge-template"
+                    ],
+                    [
+                        "$.inner.arr1",
+                        "merge-template"
+                    ]
+                ]
+            }
+        }))).toEqual({
+            here: "heretemplate",
+            //  extra: 'extra', - not added
+            another: 23,
+            inner: {
+                el1: "el1",
+                arr1: [
+                    "b1",
+                    "b2"
+                ],
+                nested: {
+                    final: "final",
+                    final2: "final2"
+                }
+            }
+        });
+    });
+    it("performs pathjson merges with no missing delete", async ()=>{
+        expect(JSON.parse(await merge(JSON.stringify(testFileJson), JSON.stringify(templateFileJson), {
+            relFilePath: "somepath",
+            mergeArguments: {
+                paths: [
+                    [
+                        "$.here",
+                        "merge-template"
+                    ],
+                    [
+                        "$.inner.nested",
+                        "merge-template"
+                    ]
+                ]
+            }
+        }))).toEqual({
+            here: "heretemplate",
+            extra: "extra",
+            another: 23,
+            inner: {
+                el1: "el1",
+                arr1: [
+                    "a1",
+                    "a2"
+                ],
+                nested: {
+                    final: "final",
+                    final2: "final2"
+                }
+            }
+        });
+    });
+    it("performs pathjson merges on multipath selection", async ()=>{
+        const template = {
+            ...templateFileJson
+        };
+        template.inner.nested = {
+            final: {
+                something: 44
+            },
+            newThing: "this"
+        };
+        expect(JSON.parse(await merge(JSON.stringify(testFileJson), JSON.stringify(template), {
+            relFilePath: "somepath",
+            mergeArguments: {
+                paths: [
+                    [
+                        "$.here",
+                        "merge-template"
+                    ],
+                    [
+                        "$.inner.nested.*",
+                        "merge-template"
+                    ]
+                ]
+            }
+        }))).toEqual({
+            here: "heretemplate",
+            extra: "extra",
+            another: 23,
+            inner: {
+                el1: "el1",
+                arr1: [
+                    "a1",
+                    "a2"
+                ],
+                nested: {
+                    final: {
+                        something: 44
+                    },
+                    final2: "final2",
+                    newThing: "this"
+                }
+            }
+        });
+    });
+    it("performs pathjson merges on stacked selections", async ()=>{
+        const template = {
+            ...templateFileJson
+        };
+        template.inner.nested = {
+            final: {
+                something: 44
+            },
+            newThing: "this"
+        };
+        expect(JSON.parse(await merge(JSON.stringify(testFileJson), JSON.stringify(template), {
+            relFilePath: "somepath",
+            mergeArguments: {
+                paths: [
+                    [
+                        "$.here",
+                        "merge-template"
+                    ],
+                    [
+                        "$.inner.nested.*",
+                        "merge-template"
+                    ],
+                    [
+                        "$.inner.nested.final",
+                        "merge-current"
+                    ]
+                ]
+            }
+        }))).toEqual({
+            here: "heretemplate",
+            extra: "extra",
+            another: 23,
+            inner: {
+                el1: "el1",
+                arr1: [
+                    "a1",
+                    "a2"
+                ],
+                nested: {
+                    final: "final",
+                    final2: "final2",
+                    // We only added the newThing
+                    newThing: "this"
+                }
+            }
+        });
+    });
+    it("performs pathjson merges on comment json", async ()=>{
+        const template = {
+            ...templateFileJson
+        };
+        template.inner.nested = {
+            final: {
+                something: 44
+            },
+            newThing: "this"
+        };
+        const testTemplateCommentJson = `{
+      "here": "heretemplate",
+      /** New comment explaining extra **/
+      "extra": "extra",
+      "inner": {
+        "arr1": ["b1", "b2"],
+        "extra2": "extra2",
+        "nested": {
+          "final": {
+            // New comment explaining final
+            "something": 44,
+          },
+          "newThing": {
+            // new thing comment
+            "this": 23,
+          },
+        }
+      },
+    }`;
+        expect(commentJson.stringify(commentJson.parse(await merge(testCommentJson, testTemplateCommentJson, {
+            relFilePath: "somepath",
+            mergeArguments: {
+                paths: [
+                    [
+                        "$.here",
+                        "merge-template"
+                    ],
+                    [
+                        "$.inner.nested.*",
+                        "merge-template"
+                    ],
+                    [
+                        "$.inner.nested.final",
+                        "merge-current"
+                    ]
+                ]
+            }
+        })), null, 4)).toEqual(commentJson.stringify(commentJson.parse(`{
+        // This is a top comment
+        "here": "heretemplate",
+        "another": 23, // this is inline
+        "inner": {
+          "el1": "el1",
+          "arr1": ["a1", "a2"],
+          "nested": {
+            // Upper comment
+            "final": "final", // Inline commment
+            "final2": "final2",
+            "newThing": {
+              // new thing comment
+              "this": 23,
+            },
+          },
+        },
+        "extra": "extra",
+      }`), null, 4));
+    });
+});
+describe("validate", ()=>{
+    it("passes correct flat mapped values", ()=>{
+        expect(validate("merge-template")).toEqual([]);
+    });
+    it("passes correct options object", ()=>{
+        expect(validate({
+            ignoreNewProperties: true,
+            missingIsDelete: false,
+            paths: [
+                [
+                    "$.something",
+                    "merge-current"
+                ],
+                [
+                    "$.something[*].values",
+                    "merge-current"
+                ]
+            ]
+        })).toEqual([]);
+    });
+    it("returns an error if a flat map value is not correct", ()=>{
+        expect(validate("bad-merge-options")).toEqual([
+            "bad-merge-options must be one of type overwrite, merge-template, or merge-current"
+        ]);
+    });
+    it("returns an unknown key exits in options object", ()=>{
+        expect(validate({
+            unknownKey: "something",
+            paths: [
+                [
+                    "$.here",
+                    "merge-template"
+                ],
+                [
+                    "$.inner.nested.*",
+                    "merge-template"
+                ],
+                [
+                    "$.inner.nested.final",
+                    "merge-current"
+                ]
+            ]
+        })).toEqual([
+            "Unrecognized key: unknownKey"
+        ]);
+    });
+    it("returns a type error if the options object is an array", ()=>{
+        expect(validate([])).toEqual([
+            "Options must be an object and not Array"
+        ]);
+    });
+    it("returns a type error if the options object is  null", ()=>{
+        expect(validate(null)).toEqual([
+            "Options cannot be null"
+        ]);
+    });
+    it("returns a type error for each path that is invalid", ()=>{
+        expect(validate({
+            paths: [
+                [
+                    "$.badc/value",
+                    "merge-template"
+                ],
+                [
+                    "no$",
+                    "merge-template"
+                ],
+                [
+                    "$.something",
+                    "not a value"
+                ]
+            ]
+        })).toEqual([
+            "Invalid jsonpath key: Error: Lexical error on line 1. Unrecognized text.\n$.badc/value\n------^",
+            "Unrecognized jsonpath syntax: no$",
+            "jsonpath $.something: not a value must be one of type overwrite, merge-template, or merge-current"
+        ]);
+    });
+});
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/plugins/json-merge.spec.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport * as commentJson from \"comment-json\";\nimport type { JsonPathOverrides } from \"../types\";\nimport { merge, validate } from \"./json-merge\";\n\nconst testFileJson = {\n\there: \"here\",\n\tanother: 23,\n\tinner: {\n\t\tel1: \"el1\",\n\t\tarr1: [\"a1\", \"a2\"],\n\t\tnested: {\n\t\t\tfinal: \"final\",\n\t\t\tfinal2: \"final2\",\n\t\t},\n\t},\n};\n\nconst templateFileJson = {\n\there: \"heretemplate\",\n\textra: \"extra\",\n\tinner: {\n\t\tarr1: [\"b1\", \"b2\"],\n\t\textra2: \"extra2\",\n\t},\n};\n\nconst testCommentJson = `{\n  // This is a top comment\n  \"here\": \"here\",\n  \"another\": 23, // this is inline\n  \"inner\": {\n    \"el1\": \"el1\",\n    \"arr1\": [\"a1\", \"a2\"],\n    \"nested\": {\n      // Upper comment\n      \"final\": \"final\", // Inline commment\n      \"final2\": \"final2\",\n    },\n  },\n}`;\n\ndescribe(\"merge\", () => {\n\tit(\"performs overwrite when specified\", async () => {\n\t\tconst fromTemplateJson = {\n\t\t\tfullOverride: true,\n\t\t};\n\t\texpect(\n\t\t\tJSON.parse(\n\t\t\t\tawait merge(\n\t\t\t\t\tJSON.stringify(testFileJson),\n\t\t\t\t\tJSON.stringify(fromTemplateJson),\n\t\t\t\t\t{\n\t\t\t\t\t\trelFilePath: \"somepath\",\n\t\t\t\t\t\tmergeArguments: \"overwrite\",\n\t\t\t\t\t},\n\t\t\t\t),\n\t\t\t),\n\t\t).toEqual(fromTemplateJson);\n\t});\n\tit(\"performs lodash merge-template when specified\", async () => {\n\t\texpect(\n\t\t\tJSON.parse(\n\t\t\t\tawait merge(\n\t\t\t\t\tJSON.stringify(testFileJson),\n\t\t\t\t\tJSON.stringify(templateFileJson),\n\t\t\t\t\t{\n\t\t\t\t\t\trelFilePath: \"somepath\",\n\t\t\t\t\t\tmergeArguments: \"merge-template\",\n\t\t\t\t\t},\n\t\t\t\t),\n\t\t\t),\n\t\t).toEqual({\n\t\t\there: \"heretemplate\",\n\t\t\textra: \"extra\",\n\t\t\tanother: 23,\n\t\t\tinner: {\n\t\t\t\tel1: \"el1\",\n\t\t\t\tarr1: [\"b1\", \"b2\"],\n\t\t\t\textra2: \"extra2\",\n\t\t\t\tnested: {\n\t\t\t\t\tfinal: \"final\",\n\t\t\t\t\tfinal2: \"final2\",\n\t\t\t\t},\n\t\t\t},\n\t\t});\n\t});\n\tit(\"performs lodash merge-current when specified\", async () => {\n\t\texpect(\n\t\t\tJSON.parse(\n\t\t\t\tawait merge(\n\t\t\t\t\tJSON.stringify(testFileJson),\n\t\t\t\t\tJSON.stringify(templateFileJson),\n\t\t\t\t\t{\n\t\t\t\t\t\trelFilePath: \"somepath\",\n\t\t\t\t\t\tmergeArguments: \"merge-current\",\n\t\t\t\t\t},\n\t\t\t\t),\n\t\t\t),\n\t\t).toEqual({\n\t\t\there: \"here\",\n\t\t\textra: \"extra\",\n\t\t\tanother: 23,\n\t\t\tinner: {\n\t\t\t\tel1: \"el1\",\n\t\t\t\tarr1: [\"a1\", \"a2\"],\n\t\t\t\textra2: \"extra2\",\n\t\t\t\tnested: {\n\t\t\t\t\tfinal: \"final\",\n\t\t\t\t\tfinal2: \"final2\",\n\t\t\t\t},\n\t\t\t},\n\t\t});\n\t});\n\tit(\"performs pathjson merges with default non-path values\", async () => {\n\t\texpect(\n\t\t\tJSON.parse(\n\t\t\t\tawait merge(\n\t\t\t\t\tJSON.stringify(testFileJson),\n\t\t\t\t\tJSON.stringify(templateFileJson),\n\t\t\t\t\t{\n\t\t\t\t\t\trelFilePath: \"somepath\",\n\t\t\t\t\t\tmergeArguments: {\n\t\t\t\t\t\t\tpaths: [\n\t\t\t\t\t\t\t\t[\"$.here\", \"merge-template\"],\n\t\t\t\t\t\t\t\t[\"$.inner.arr1\", \"merge-template\"],\n\t\t\t\t\t\t\t\t[\"$.inner.el1\", \"overwrite\"],\n\t\t\t\t\t\t\t],\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t),\n\t\t\t),\n\t\t).toEqual({\n\t\t\there: \"heretemplate\",\n\t\t\t// This is the extra here since we add missing\n\t\t\textra: \"extra\",\n\t\t\tanother: 23,\n\t\t\tinner: {\n\t\t\t\t// This will stay here\n\t\t\t\tel1: \"el1\",\n\t\t\t\tarr1: [\"b1\", \"b2\"],\n\t\t\t\t// extra2 doesn't show up since we didn't dictate it\n\t\t\t\tnested: {\n\t\t\t\t\tfinal: \"final\",\n\t\t\t\t\tfinal2: \"final2\",\n\t\t\t\t},\n\t\t\t},\n\t\t});\n\t});\n\tit(\"performs pathjson merges with missing deletions\", async () => {\n\t\texpect(\n\t\t\tJSON.parse(\n\t\t\t\tawait merge(\n\t\t\t\t\tJSON.stringify(testFileJson),\n\t\t\t\t\tJSON.stringify(templateFileJson),\n\t\t\t\t\t{\n\t\t\t\t\t\trelFilePath: \"somepath\",\n\t\t\t\t\t\tmergeArguments: {\n\t\t\t\t\t\t\tmissingIsDelete: true,\n\t\t\t\t\t\t\tpaths: [\n\t\t\t\t\t\t\t\t[\"$.here\", \"merge-template\"],\n\t\t\t\t\t\t\t\t[\"$.inner.nested\", \"overwrite\"],\n\t\t\t\t\t\t\t],\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t),\n\t\t\t),\n\t\t).toEqual({\n\t\t\there: \"heretemplate\",\n\t\t\textra: \"extra\",\n\t\t\tanother: 23,\n\t\t\tinner: {\n\t\t\t\tel1: \"el1\",\n\t\t\t\tarr1: [\"a1\", \"a2\"],\n\t\t\t\t// nested is gone because it was undefined\n\t\t\t},\n\t\t});\n\t});\n\tit(\"performs pathjson merges with ignore new\", async () => {\n\t\texpect(\n\t\t\tJSON.parse(\n\t\t\t\tawait merge(\n\t\t\t\t\tJSON.stringify(testFileJson),\n\t\t\t\t\tJSON.stringify(templateFileJson),\n\t\t\t\t\t{\n\t\t\t\t\t\trelFilePath: \"somepath\",\n\t\t\t\t\t\tmergeArguments: {\n\t\t\t\t\t\t\tignoreNewProperties: true,\n\t\t\t\t\t\t\tpaths: [\n\t\t\t\t\t\t\t\t[\"$.here\", \"merge-template\"],\n\t\t\t\t\t\t\t\t[\"$.inner.arr1\", \"merge-template\"],\n\t\t\t\t\t\t\t],\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t),\n\t\t\t),\n\t\t).toEqual({\n\t\t\there: \"heretemplate\",\n\t\t\t//  extra: 'extra', - not added\n\t\t\tanother: 23,\n\t\t\tinner: {\n\t\t\t\tel1: \"el1\",\n\t\t\t\tarr1: [\"b1\", \"b2\"],\n\t\t\t\tnested: {\n\t\t\t\t\tfinal: \"final\",\n\t\t\t\t\tfinal2: \"final2\",\n\t\t\t\t},\n\t\t\t},\n\t\t});\n\t});\n\tit(\"performs pathjson merges with no missing delete\", async () => {\n\t\texpect(\n\t\t\tJSON.parse(\n\t\t\t\tawait merge(\n\t\t\t\t\tJSON.stringify(testFileJson),\n\t\t\t\t\tJSON.stringify(templateFileJson),\n\t\t\t\t\t{\n\t\t\t\t\t\trelFilePath: \"somepath\",\n\t\t\t\t\t\tmergeArguments: {\n\t\t\t\t\t\t\tpaths: [\n\t\t\t\t\t\t\t\t[\"$.here\", \"merge-template\"],\n\t\t\t\t\t\t\t\t[\"$.inner.nested\", \"merge-template\"],\n\t\t\t\t\t\t\t],\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t),\n\t\t\t),\n\t\t).toEqual({\n\t\t\there: \"heretemplate\",\n\t\t\textra: \"extra\",\n\t\t\tanother: 23,\n\t\t\tinner: {\n\t\t\t\tel1: \"el1\",\n\t\t\t\tarr1: [\"a1\", \"a2\"],\n\t\t\t\tnested: {\n\t\t\t\t\tfinal: \"final\",\n\t\t\t\t\tfinal2: \"final2\",\n\t\t\t\t},\n\t\t\t},\n\t\t});\n\t});\n\tit(\"performs pathjson merges on multipath selection\", async () => {\n\t\tconst template = { ...templateFileJson };\n\t\t(template.inner as any).nested = {\n\t\t\tfinal: { something: 44 },\n\t\t\tnewThing: \"this\",\n\t\t};\n\t\texpect(\n\t\t\tJSON.parse(\n\t\t\t\tawait merge(JSON.stringify(testFileJson), JSON.stringify(template), {\n\t\t\t\t\trelFilePath: \"somepath\",\n\t\t\t\t\tmergeArguments: {\n\t\t\t\t\t\tpaths: [\n\t\t\t\t\t\t\t[\"$.here\", \"merge-template\"],\n\t\t\t\t\t\t\t[\"$.inner.nested.*\", \"merge-template\"],\n\t\t\t\t\t\t],\n\t\t\t\t\t},\n\t\t\t\t}),\n\t\t\t),\n\t\t).toEqual({\n\t\t\there: \"heretemplate\",\n\t\t\textra: \"extra\",\n\t\t\tanother: 23,\n\t\t\tinner: {\n\t\t\t\tel1: \"el1\",\n\t\t\t\tarr1: [\"a1\", \"a2\"],\n\t\t\t\tnested: {\n\t\t\t\t\tfinal: { something: 44 },\n\t\t\t\t\tfinal2: \"final2\",\n\t\t\t\t\tnewThing: \"this\",\n\t\t\t\t},\n\t\t\t},\n\t\t});\n\t});\n\tit(\"performs pathjson merges on stacked selections\", async () => {\n\t\tconst template = { ...templateFileJson };\n\t\t(template.inner as any).nested = {\n\t\t\tfinal: { something: 44 },\n\t\t\tnewThing: \"this\",\n\t\t};\n\t\texpect(\n\t\t\tJSON.parse(\n\t\t\t\tawait merge(JSON.stringify(testFileJson), JSON.stringify(template), {\n\t\t\t\t\trelFilePath: \"somepath\",\n\t\t\t\t\tmergeArguments: {\n\t\t\t\t\t\tpaths: [\n\t\t\t\t\t\t\t[\"$.here\", \"merge-template\"],\n\t\t\t\t\t\t\t[\"$.inner.nested.*\", \"merge-template\"],\n\t\t\t\t\t\t\t[\"$.inner.nested.final\", \"merge-current\"],\n\t\t\t\t\t\t],\n\t\t\t\t\t},\n\t\t\t\t}),\n\t\t\t),\n\t\t).toEqual({\n\t\t\there: \"heretemplate\",\n\t\t\textra: \"extra\",\n\t\t\tanother: 23,\n\t\t\tinner: {\n\t\t\t\tel1: \"el1\",\n\t\t\t\tarr1: [\"a1\", \"a2\"],\n\t\t\t\tnested: {\n\t\t\t\t\tfinal: \"final\",\n\t\t\t\t\tfinal2: \"final2\",\n\t\t\t\t\t// We only added the newThing\n\t\t\t\t\tnewThing: \"this\",\n\t\t\t\t},\n\t\t\t},\n\t\t});\n\t});\n\tit(\"performs pathjson merges on comment json\", async () => {\n\t\tconst template = { ...templateFileJson };\n\t\t(template.inner as any).nested = {\n\t\t\tfinal: { something: 44 },\n\t\t\tnewThing: \"this\",\n\t\t};\n\n\t\tconst testTemplateCommentJson = `{\n      \"here\": \"heretemplate\",\n      /** New comment explaining extra **/\n      \"extra\": \"extra\",\n      \"inner\": {\n        \"arr1\": [\"b1\", \"b2\"],\n        \"extra2\": \"extra2\",\n        \"nested\": {\n          \"final\": {\n            // New comment explaining final\n            \"something\": 44,\n          },\n          \"newThing\": {\n            // new thing comment\n            \"this\": 23,\n          },\n        }\n      },\n    }`;\n\n\t\texpect(\n\t\t\tcommentJson.stringify(\n\t\t\t\tcommentJson.parse(\n\t\t\t\t\tawait merge(testCommentJson, testTemplateCommentJson, {\n\t\t\t\t\t\trelFilePath: \"somepath\",\n\t\t\t\t\t\tmergeArguments: {\n\t\t\t\t\t\t\tpaths: [\n\t\t\t\t\t\t\t\t[\"$.here\", \"merge-template\"],\n\t\t\t\t\t\t\t\t[\"$.inner.nested.*\", \"merge-template\"],\n\t\t\t\t\t\t\t\t[\"$.inner.nested.final\", \"merge-current\"],\n\t\t\t\t\t\t\t],\n\t\t\t\t\t\t},\n\t\t\t\t\t}),\n\t\t\t\t),\n\t\t\t\tnull,\n\t\t\t\t4,\n\t\t\t),\n\t\t).toEqual(\n\t\t\tcommentJson.stringify(\n\t\t\t\tcommentJson.parse(`{\n        // This is a top comment\n        \"here\": \"heretemplate\",\n        \"another\": 23, // this is inline\n        \"inner\": {\n          \"el1\": \"el1\",\n          \"arr1\": [\"a1\", \"a2\"],\n          \"nested\": {\n            // Upper comment\n            \"final\": \"final\", // Inline commment\n            \"final2\": \"final2\",\n            \"newThing\": {\n              // new thing comment\n              \"this\": 23,\n            },\n          },\n        },\n        \"extra\": \"extra\",\n      }`),\n\t\t\t\tnull,\n\t\t\t\t4,\n\t\t\t),\n\t\t);\n\t});\n});\n\ndescribe(\"validate\", () => {\n\tit(\"passes correct flat mapped values\", () => {\n\t\texpect(validate(\"merge-template\")).toEqual([]);\n\t});\n\tit(\"passes correct options object\", () => {\n\t\texpect(\n\t\t\tvalidate({\n\t\t\t\tignoreNewProperties: true,\n\t\t\t\tmissingIsDelete: false,\n\t\t\t\tpaths: [\n\t\t\t\t\t[\"$.something\", \"merge-current\"],\n\t\t\t\t\t[\"$.something[*].values\", \"merge-current\"],\n\t\t\t\t],\n\t\t\t} as JsonPathOverrides),\n\t\t).toEqual([]);\n\t});\n\tit(\"returns an error if a flat map value is not correct\", () => {\n\t\texpect(validate(\"bad-merge-options\")).toEqual([\n\t\t\t\"bad-merge-options must be one of type overwrite, merge-template, or merge-current\",\n\t\t]);\n\t});\n\tit(\"returns an unknown key exits in options object\", () => {\n\t\texpect(\n\t\t\tvalidate({\n\t\t\t\tunknownKey: \"something\",\n\t\t\t\tpaths: [\n\t\t\t\t\t[\"$.here\", \"merge-template\"],\n\t\t\t\t\t[\"$.inner.nested.*\", \"merge-template\"],\n\t\t\t\t\t[\"$.inner.nested.final\", \"merge-current\"],\n\t\t\t\t],\n\t\t\t}),\n\t\t).toEqual([\"Unrecognized key: unknownKey\"]);\n\t});\n\tit(\"returns a type error if the options object is an array\", () => {\n\t\texpect(validate([])).toEqual([\"Options must be an object and not Array\"]);\n\t});\n\tit(\"returns a type error if the options object is  null\", () => {\n\t\texpect(validate(null)).toEqual([\"Options cannot be null\"]);\n\t});\n\tit(\"returns a type error for each path that is invalid\", () => {\n\t\texpect(\n\t\t\tvalidate({\n\t\t\t\tpaths: [\n\t\t\t\t\t[\"$.badc/value\", \"merge-template\"],\n\t\t\t\t\t[\"no$\", \"merge-template\"],\n\t\t\t\t\t[\"$.something\", \"not a value\"],\n\t\t\t\t],\n\t\t\t}),\n\t\t).toEqual([\n\t\t\t\"Invalid jsonpath key: Error: Lexical error on line 1. Unrecognized text.\\n$.badc/value\\n------^\",\n\t\t\t\"Unrecognized jsonpath syntax: no$\",\n\t\t\t\"jsonpath $.something: not a value must be one of type overwrite, merge-template, or merge-current\",\n\t\t]);\n\t});\n});\n"],"names":["commentJson","merge","validate","testFileJson","here","another","inner","el1","arr1","nested","final","final2","templateFileJson","extra","extra2","testCommentJson","describe","it","fromTemplateJson","fullOverride","expect","JSON","parse","stringify","relFilePath","mergeArguments","toEqual","paths","missingIsDelete","ignoreNewProperties","template","something","newThing","testTemplateCommentJson","unknownKey"],"mappings":"AAAA,qDAAqD,GAErD,YAAYA,iBAAiB,eAAe;AAE5C,SAASC,KAAK,EAAEC,QAAQ,QAAQ,mBAAe;AAE/C,MAAMC,eAAe;IACpBC,MAAM;IACNC,SAAS;IACTC,OAAO;QACNC,KAAK;QACLC,MAAM;YAAC;YAAM;SAAK;QAClBC,QAAQ;YACPC,OAAO;YACPC,QAAQ;QACT;IACD;AACD;AAEA,MAAMC,mBAAmB;IACxBR,MAAM;IACNS,OAAO;IACPP,OAAO;QACNE,MAAM;YAAC;YAAM;SAAK;QAClBM,QAAQ;IACT;AACD;AAEA,MAAMC,kBAAkB,CAAC;;;;;;;;;;;;;CAaxB,CAAC;AAEFC,SAAS,SAAS;IACjBC,GAAG,qCAAqC;QACvC,MAAMC,mBAAmB;YACxBC,cAAc;QACf;QACAC,OACCC,KAAKC,KAAK,CACT,MAAMrB,MACLoB,KAAKE,SAAS,CAACpB,eACfkB,KAAKE,SAAS,CAACL,mBACf;YACCM,aAAa;YACbC,gBAAgB;QACjB,KAGDC,OAAO,CAACR;IACX;IACAD,GAAG,iDAAiD;QACnDG,OACCC,KAAKC,KAAK,CACT,MAAMrB,MACLoB,KAAKE,SAAS,CAACpB,eACfkB,KAAKE,SAAS,CAACX,mBACf;YACCY,aAAa;YACbC,gBAAgB;QACjB,KAGDC,OAAO,CAAC;YACTtB,MAAM;YACNS,OAAO;YACPR,SAAS;YACTC,OAAO;gBACNC,KAAK;gBACLC,MAAM;oBAAC;oBAAM;iBAAK;gBAClBM,QAAQ;gBACRL,QAAQ;oBACPC,OAAO;oBACPC,QAAQ;gBACT;YACD;QACD;IACD;IACAM,GAAG,gDAAgD;QAClDG,OACCC,KAAKC,KAAK,CACT,MAAMrB,MACLoB,KAAKE,SAAS,CAACpB,eACfkB,KAAKE,SAAS,CAACX,mBACf;YACCY,aAAa;YACbC,gBAAgB;QACjB,KAGDC,OAAO,CAAC;YACTtB,MAAM;YACNS,OAAO;YACPR,SAAS;YACTC,OAAO;gBACNC,KAAK;gBACLC,MAAM;oBAAC;oBAAM;iBAAK;gBAClBM,QAAQ;gBACRL,QAAQ;oBACPC,OAAO;oBACPC,QAAQ;gBACT;YACD;QACD;IACD;IACAM,GAAG,yDAAyD;QAC3DG,OACCC,KAAKC,KAAK,CACT,MAAMrB,MACLoB,KAAKE,SAAS,CAACpB,eACfkB,KAAKE,SAAS,CAACX,mBACf;YACCY,aAAa;YACbC,gBAAgB;gBACfE,OAAO;oBACN;wBAAC;wBAAU;qBAAiB;oBAC5B;wBAAC;wBAAgB;qBAAiB;oBAClC;wBAAC;wBAAe;qBAAY;iBAC5B;YACF;QACD,KAGDD,OAAO,CAAC;YACTtB,MAAM;YACN,8CAA8C;YAC9CS,OAAO;YACPR,SAAS;YACTC,OAAO;gBACN,sBAAsB;gBACtBC,KAAK;gBACLC,MAAM;oBAAC;oBAAM;iBAAK;gBAClB,oDAAoD;gBACpDC,QAAQ;oBACPC,OAAO;oBACPC,QAAQ;gBACT;YACD;QACD;IACD;IACAM,GAAG,mDAAmD;QACrDG,OACCC,KAAKC,KAAK,CACT,MAAMrB,MACLoB,KAAKE,SAAS,CAACpB,eACfkB,KAAKE,SAAS,CAACX,mBACf;YACCY,aAAa;YACbC,gBAAgB;gBACfG,iBAAiB;gBACjBD,OAAO;oBACN;wBAAC;wBAAU;qBAAiB;oBAC5B;wBAAC;wBAAkB;qBAAY;iBAC/B;YACF;QACD,KAGDD,OAAO,CAAC;YACTtB,MAAM;YACNS,OAAO;YACPR,SAAS;YACTC,OAAO;gBACNC,KAAK;gBACLC,MAAM;oBAAC;oBAAM;iBAAK;YAEnB;QACD;IACD;IACAS,GAAG,4CAA4C;QAC9CG,OACCC,KAAKC,KAAK,CACT,MAAMrB,MACLoB,KAAKE,SAAS,CAACpB,eACfkB,KAAKE,SAAS,CAACX,mBACf;YACCY,aAAa;YACbC,gBAAgB;gBACfI,qBAAqB;gBACrBF,OAAO;oBACN;wBAAC;wBAAU;qBAAiB;oBAC5B;wBAAC;wBAAgB;qBAAiB;iBAClC;YACF;QACD,KAGDD,OAAO,CAAC;YACTtB,MAAM;YACN,+BAA+B;YAC/BC,SAAS;YACTC,OAAO;gBACNC,KAAK;gBACLC,MAAM;oBAAC;oBAAM;iBAAK;gBAClBC,QAAQ;oBACPC,OAAO;oBACPC,QAAQ;gBACT;YACD;QACD;IACD;IACAM,GAAG,mDAAmD;QACrDG,OACCC,KAAKC,KAAK,CACT,MAAMrB,MACLoB,KAAKE,SAAS,CAACpB,eACfkB,KAAKE,SAAS,CAACX,mBACf;YACCY,aAAa;YACbC,gBAAgB;gBACfE,OAAO;oBACN;wBAAC;wBAAU;qBAAiB;oBAC5B;wBAAC;wBAAkB;qBAAiB;iBACpC;YACF;QACD,KAGDD,OAAO,CAAC;YACTtB,MAAM;YACNS,OAAO;YACPR,SAAS;YACTC,OAAO;gBACNC,KAAK;gBACLC,MAAM;oBAAC;oBAAM;iBAAK;gBAClBC,QAAQ;oBACPC,OAAO;oBACPC,QAAQ;gBACT;YACD;QACD;IACD;IACAM,GAAG,mDAAmD;QACrD,MAAMa,WAAW;YAAE,GAAGlB,gBAAgB;QAAC;QACtCkB,SAASxB,KAAK,CAASG,MAAM,GAAG;YAChCC,OAAO;gBAAEqB,WAAW;YAAG;YACvBC,UAAU;QACX;QACAZ,OACCC,KAAKC,KAAK,CACT,MAAMrB,MAAMoB,KAAKE,SAAS,CAACpB,eAAekB,KAAKE,SAAS,CAACO,WAAW;YACnEN,aAAa;YACbC,gBAAgB;gBACfE,OAAO;oBACN;wBAAC;wBAAU;qBAAiB;oBAC5B;wBAAC;wBAAoB;qBAAiB;iBACtC;YACF;QACD,KAEAD,OAAO,CAAC;YACTtB,MAAM;YACNS,OAAO;YACPR,SAAS;YACTC,OAAO;gBACNC,KAAK;gBACLC,MAAM;oBAAC;oBAAM;iBAAK;gBAClBC,QAAQ;oBACPC,OAAO;wBAAEqB,WAAW;oBAAG;oBACvBpB,QAAQ;oBACRqB,UAAU;gBACX;YACD;QACD;IACD;IACAf,GAAG,kDAAkD;QACpD,MAAMa,WAAW;YAAE,GAAGlB,gBAAgB;QAAC;QACtCkB,SAASxB,KAAK,CAASG,MAAM,GAAG;YAChCC,OAAO;gBAAEqB,WAAW;YAAG;YACvBC,UAAU;QACX;QACAZ,OACCC,KAAKC,KAAK,CACT,MAAMrB,MAAMoB,KAAKE,SAAS,CAACpB,eAAekB,KAAKE,SAAS,CAACO,WAAW;YACnEN,aAAa;YACbC,gBAAgB;gBACfE,OAAO;oBACN;wBAAC;wBAAU;qBAAiB;oBAC5B;wBAAC;wBAAoB;qBAAiB;oBACtC;wBAAC;wBAAwB;qBAAgB;iBACzC;YACF;QACD,KAEAD,OAAO,CAAC;YACTtB,MAAM;YACNS,OAAO;YACPR,SAAS;YACTC,OAAO;gBACNC,KAAK;gBACLC,MAAM;oBAAC;oBAAM;iBAAK;gBAClBC,QAAQ;oBACPC,OAAO;oBACPC,QAAQ;oBACR,6BAA6B;oBAC7BqB,UAAU;gBACX;YACD;QACD;IACD;IACAf,GAAG,4CAA4C;QAC9C,MAAMa,WAAW;YAAE,GAAGlB,gBAAgB;QAAC;QACtCkB,SAASxB,KAAK,CAASG,MAAM,GAAG;YAChCC,OAAO;gBAAEqB,WAAW;YAAG;YACvBC,UAAU;QACX;QAEA,MAAMC,0BAA0B,CAAC;;;;;;;;;;;;;;;;;;KAkB9B,CAAC;QAEJb,OACCpB,YAAYuB,SAAS,CACpBvB,YAAYsB,KAAK,CAChB,MAAMrB,MAAMc,iBAAiBkB,yBAAyB;YACrDT,aAAa;YACbC,gBAAgB;gBACfE,OAAO;oBACN;wBAAC;wBAAU;qBAAiB;oBAC5B;wBAAC;wBAAoB;qBAAiB;oBACtC;wBAAC;wBAAwB;qBAAgB;iBACzC;YACF;QACD,KAED,MACA,IAEAD,OAAO,CACR1B,YAAYuB,SAAS,CACpBvB,YAAYsB,KAAK,CAAC,CAAC;;;;;;;;;;;;;;;;;;OAkBhB,CAAC,GACJ,MACA;IAGH;AACD;AAEAN,SAAS,YAAY;IACpBC,GAAG,qCAAqC;QACvCG,OAAOlB,SAAS,mBAAmBwB,OAAO,CAAC,EAAE;IAC9C;IACAT,GAAG,iCAAiC;QACnCG,OACClB,SAAS;YACR2B,qBAAqB;YACrBD,iBAAiB;YACjBD,OAAO;gBACN;oBAAC;oBAAe;iBAAgB;gBAChC;oBAAC;oBAAyB;iBAAgB;aAC1C;QACF,IACCD,OAAO,CAAC,EAAE;IACb;IACAT,GAAG,uDAAuD;QACzDG,OAAOlB,SAAS,sBAAsBwB,OAAO,CAAC;YAC7C;SACA;IACF;IACAT,GAAG,kDAAkD;QACpDG,OACClB,SAAS;YACRgC,YAAY;YACZP,OAAO;gBACN;oBAAC;oBAAU;iBAAiB;gBAC5B;oBAAC;oBAAoB;iBAAiB;gBACtC;oBAAC;oBAAwB;iBAAgB;aACzC;QACF,IACCD,OAAO,CAAC;YAAC;SAA+B;IAC3C;IACAT,GAAG,0DAA0D;QAC5DG,OAAOlB,SAAS,EAAE,GAAGwB,OAAO,CAAC;YAAC;SAA0C;IACzE;IACAT,GAAG,uDAAuD;QACzDG,OAAOlB,SAAS,OAAOwB,OAAO,CAAC;YAAC;SAAyB;IAC1D;IACAT,GAAG,sDAAsD;QACxDG,OACClB,SAAS;YACRyB,OAAO;gBACN;oBAAC;oBAAgB;iBAAiB;gBAClC;oBAAC;oBAAO;iBAAiB;gBACzB;oBAAC;oBAAe;iBAAc;aAC9B;QACF,IACCD,OAAO,CAAC;YACT;YACA;YACA;SACA;IACF;AACD"}

package/dist/esm/ref-drivers/git-current-ref.mjs

@@ -0,0 +1,8 @@
+import { execSync } from "child_process";
+export async function gitCurrentRef(options) {
+    return execSync(`git rev-parse HEAD`, {
+        cwd: options.rootDir
+    }).toString().trim();
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9yZWYtZHJpdmVycy9naXQtY3VycmVudC1yZWYudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZXhlY1N5bmMgfSBmcm9tIFwiY2hpbGRfcHJvY2Vzc1wiO1xuXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gZ2l0Q3VycmVudFJlZihvcHRpb25zOiB7IHJvb3REaXI6IHN0cmluZyB9KSB7XG5cdHJldHVybiBleGVjU3luYyhgZ2l0IHJldi1wYXJzZSBIRUFEYCwge1xuXHRcdGN3ZDogb3B0aW9ucy5yb290RGlyLFxuXHR9KVxuXHRcdC50b1N0cmluZygpXG5cdFx0LnRyaW0oKTtcbn1cbiJdLCJuYW1lcyI6WyJleGVjU3luYyIsImdpdEN1cnJlbnRSZWYiLCJvcHRpb25zIiwiY3dkIiwicm9vdERpciIsInRvU3RyaW5nIiwidHJpbSJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0EsUUFBUSxRQUFRLGdCQUFnQjtBQUV6QyxPQUFPLGVBQWVDLGNBQWNDLE9BQTRCO0lBQy9ELE9BQU9GLFNBQVMsQ0FBQyxrQkFBa0IsQ0FBQyxFQUFFO1FBQ3JDRyxLQUFLRCxRQUFRRSxPQUFPO0lBQ3JCLEdBQ0VDLFFBQVEsR0FDUkMsSUFBSTtBQUNQIn0=

package/dist/esm/ref-drivers/git-current-ref.spec.mjs

@@ -0,0 +1,11 @@
+import { execSync } from "child_process";
+import { gitCurrentRef } from "./git-current-ref.mjs";
+describe("getCurrentRef", ()=>{
+    it("gets the current sha", async ()=>{
+        expect(await gitCurrentRef({
+            rootDir: process.cwd()
+        })).toEqual(execSync("git rev-parse HEAD").toString().trim());
+    });
+});
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9yZWYtZHJpdmVycy9naXQtY3VycmVudC1yZWYuc3BlYy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBleGVjU3luYyB9IGZyb20gXCJjaGlsZF9wcm9jZXNzXCI7XG5pbXBvcnQgeyBnaXRDdXJyZW50UmVmIH0gZnJvbSBcIi4vZ2l0LWN1cnJlbnQtcmVmXCI7XG5cbmRlc2NyaWJlKFwiZ2V0Q3VycmVudFJlZlwiLCAoKSA9PiB7XG5cdGl0KFwiZ2V0cyB0aGUgY3VycmVudCBzaGFcIiwgYXN5bmMgKCkgPT4ge1xuXHRcdGV4cGVjdChcblx0XHRcdGF3YWl0IGdpdEN1cnJlbnRSZWYoe1xuXHRcdFx0XHRyb290RGlyOiBwcm9jZXNzLmN3ZCgpLFxuXHRcdFx0fSksXG5cdFx0KS50b0VxdWFsKGV4ZWNTeW5jKFwiZ2l0IHJldi1wYXJzZSBIRUFEXCIpLnRvU3RyaW5nKCkudHJpbSgpKTtcblx0fSk7XG59KTtcbiJdLCJuYW1lcyI6WyJleGVjU3luYyIsImdpdEN1cnJlbnRSZWYiLCJkZXNjcmliZSIsIml0IiwiZXhwZWN0Iiwicm9vdERpciIsInByb2Nlc3MiLCJjd2QiLCJ0b0VxdWFsIiwidG9TdHJpbmciLCJ0cmltIl0sIm1hcHBpbmdzIjoiQUFBQSxTQUFTQSxRQUFRLFFBQVEsZ0JBQWdCO0FBQ3pDLFNBQVNDLGFBQWEsUUFBUSx3QkFBb0I7QUFFbERDLFNBQVMsaUJBQWlCO0lBQ3pCQyxHQUFHLHdCQUF3QjtRQUMxQkMsT0FDQyxNQUFNSCxjQUFjO1lBQ25CSSxTQUFTQyxRQUFRQyxHQUFHO1FBQ3JCLElBQ0NDLE9BQU8sQ0FBQ1IsU0FBUyxzQkFBc0JTLFFBQVEsR0FBR0MsSUFBSTtJQUN6RDtBQUNEIn0=

package/dist/esm/ref-drivers/index.mjs

@@ -0,0 +1,3 @@
+export * from "./git-current-ref.mjs";
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9yZWYtZHJpdmVycy9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9naXQtY3VycmVudC1yZWZcIjtcbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHdCQUFvQiJ9

package/dist/esm/ref-drivers/types.mjs

@@ -0,0 +1,8 @@
+/**
+ * A function that operates within the root dir and returns the
+ * current ref for its state.  This abstracts the idea of getting
+ * the current commit sha, so that things like other custom templating
+ * frameworks can provide their own ref
+ */ export { };
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9yZWYtZHJpdmVycy90eXBlcy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEEgZnVuY3Rpb24gdGhhdCBvcGVyYXRlcyB3aXRoaW4gdGhlIHJvb3QgZGlyIGFuZCByZXR1cm5zIHRoZVxuICogY3VycmVudCByZWYgZm9yIGl0cyBzdGF0ZS4gIFRoaXMgYWJzdHJhY3RzIHRoZSBpZGVhIG9mIGdldHRpbmdcbiAqIHRoZSBjdXJyZW50IGNvbW1pdCBzaGEsIHNvIHRoYXQgdGhpbmdzIGxpa2Ugb3RoZXIgY3VzdG9tIHRlbXBsYXRpbmdcbiAqIGZyYW1ld29ya3MgY2FuIHByb3ZpZGUgdGhlaXIgb3duIHJlZlxuICovXG5leHBvcnQgdHlwZSBUZW1wbGF0ZVJlZkRyaXZlckZuID0gKG9wdGlvbnM6IHtcblx0LyoqIFRoZSByb290IGRpciB3aGVyZSB3ZSB3YW50IHRvIGdldCB0aGUgXCJjdXJyZW50XCIgcmVmICovXG5cdHJvb3REaXI6IHN0cmluZztcbn0pID0+IFByb21pc2U8c3RyaW5nPjtcbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Q0FLQyxHQUNELFdBR3NCIn0=