@fluidframework/tree 2.74.0-370705 → 2.80.0

package/lib/feature-libraries/sequence-field/sequenceFieldCodecV2.js

@@ -4,15 +4,98 @@
  */
 import { assert, unreachableCase, fail } from "@fluidframework/core-utils/internal";
 import { DiscriminatedUnionDispatcher, } from "../../codec/index.js";
-import { areEqualChangeAtomIds, } from "../../core/index.js";
 import { brand } from "../../util/index.js";
 import { makeChangeAtomIdCodec } from "../changeAtomIdCodec.js";
-import { EncodedNodeChangeset, getFromChangeAtomIdMap, rangeQueryChangeAtomIdMap, } from "../modular-schema/index.js";
+import { EncodedNodeChangeset, } from "../modular-schema/index.js";
 import { Changeset as ChangesetSchema } from "./formatV2.js";
 import { NoopMarkType, } from "./types.js";
-import { getAttachedRootId, getDetachedRootId, isNoopMark, splitMark } from "./utils.js";
+import { isNoopMark, normalizeCellRename } from "./utils.js";
 export function makeV2CodecHelpers(revisionTagCodec) {
     const changeAtomIdCodec = makeChangeAtomIdCodec(revisionTagCodec);
+    const markEffectCodec = {
+        encode(effect, context) {
+            function encodeRevision(revision) {
+                if (revision === undefined || revision === context.revision) {
+                    return undefined;
+                }
+                return revisionTagCodec.encode(revision, context);
+            }
+            const type = effect.type;
+            switch (type) {
+                case "MoveIn": {
+                    return {
+                        moveIn: {
+                            revision: encodeRevision(effect.revision),
+                            finalEndpoint: effect.finalEndpoint === undefined
+                                ? undefined
+                                : changeAtomIdCodec.encode(effect.finalEndpoint, context),
+                            id: effect.id,
+                        },
+                    };
+                }
+                case "Insert": {
+                    return {
+                        insert: {
+                            revision: encodeRevision(effect.revision),
+                            id: effect.id,
+                        },
+                    };
+                }
+                case "Remove": {
+                    return {
+                        remove: {
+                            revision: encodeRevision(effect.revision),
+                            idOverride: effect.idOverride === undefined
+                                ? undefined
+                                : changeAtomIdCodec.encode(effect.idOverride, context),
+                            id: effect.id,
+                        },
+                    };
+                }
+                case "MoveOut": {
+                    return {
+                        moveOut: {
+                            revision: encodeRevision(effect.revision),
+                            finalEndpoint: effect.finalEndpoint === undefined
+                                ? undefined
+                                : changeAtomIdCodec.encode(effect.finalEndpoint, context),
+                            idOverride: effect.idOverride === undefined
+                                ? undefined
+                                : changeAtomIdCodec.encode(effect.idOverride, context),
+                            id: effect.id,
+                        },
+                    };
+                }
+                case "AttachAndDetach": {
+                    return {
+                        attachAndDetach: {
+                            attach: markEffectCodec.encode(effect.attach, context),
+                            detach: markEffectCodec.encode(effect.detach, context),
+                        },
+                    };
+                }
+                case "Rename": {
+                    // In documents generated by clients on release >=2.2 (i.e., running the code from the PR that added this comment),
+                    // renames are encoded as AttachAndDetach with a special id.
+                    // This ensures forward-compatibility of clients on release <=2.1 with documents/ops generated by clients on release >=2.2.
+                    return markEffectCodec.encode({
+                        type: "AttachAndDetach",
+                        attach: { type: "MoveIn", id: renameLocalId },
+                        detach: { type: "MoveOut", id: renameLocalId, idOverride: effect.idOverride },
+                    }, context);
+                }
+                case NoopMarkType: {
+                    fail(0xb2c /* Mark type: NoopMarkType should not be encoded. */);
+                }
+                default: {
+                    unreachableCase(type);
+                }
+            }
+        },
+        decode(encoded, context) {
+            return decoderDispatcher.dispatch(encoded, context);
+        },
+    };
     function decodeRevision(encodedRevision, context) {
         if (encodedRevision === undefined) {
             assert(context.revision !== undefined, 0x996 /* Implicit revision should be provided */);
@@ -20,388 +103,138 @@ export function makeV2CodecHelpers(revisionTagCodec) {
         }
         return revisionTagCodec.decode(encodedRevision, context);
     }
-    const decoderLibrary = makeMarkEffectDecoder(changeAtomIdCodec, decodeRevision);
-    const decoderDispatcher = new DiscriminatedUnionDispatcher(decoderLibrary);
-    return {
-        changeAtomIdCodec,
-        decoderLibrary,
-        encodeMarkEffect(mark, context) {
-            return encodeMarkEffectV2(mark, context, (revision) => encodeRevisionWithContext(revision, context.baseContext, revisionTagCodec), changeAtomIdCodec);
-        },
-        decodeRevision: (encoded, context) => encoded !== undefined
-            ? revisionTagCodec.decode(encoded, context)
-            : (context.revision ?? fail("Expected a default revision")),
-        decodeMarkEffect: (encoded, count, cellId, context) => {
-            return decoderDispatcher.dispatch(encoded, count, cellId, context);
-        },
-    };
-}
-export function decodeSequenceChangeset(changeset, context, changeAtomIdCodec, decodeMarkEffect) {
-    const marks = [];
-    for (const mark of changeset) {
-        const decodedMark = {
-            count: mark.count,
-        };
-        if (mark.cellId !== undefined) {
-            decodedMark.cellId = changeAtomIdCodec.decode(mark.cellId, context.baseContext);
-        }
-        if (mark.effect !== undefined) {
-            Object.assign(decodedMark, decodeMarkEffect(mark.effect, mark.count, decodedMark.cellId, context));
-        }
-        if (mark.changes !== undefined) {
-            if (decodedMark.cellId !== undefined) {
-                context.decodeRootNodeChange(decodedMark.cellId, mark.changes);
-            }
-            else {
-                decodedMark.changes = context.decodeNode(mark.changes);
-            }
-        }
-        marks.push(decodedMark);
-    }
-    return marks;
-}
-function makeMarkEffectDecoder(changeAtomIdCodec, decodeRevision) {
-    function decodeMoveIn(encoded, context) {
-        const { id, revision } = encoded;
-        const endpoint = encoded.finalEndpoint !== undefined
-            ? changeAtomIdCodec.decode(encoded.finalEndpoint, context.baseContext)
-            : undefined;
-        const mark = {
-            type: "Insert",
-            id: endpoint?.localId ?? id,
-            revision: endpoint?.revision ?? decodeRevision(revision, context.baseContext),
-        };
-        return mark;
-    }
     const decoderLibrary = {
-        moveIn(encoded, count, cellId, context) {
-            return decodeMoveIn(encoded, context);
+        moveIn(encoded, context) {
+            const { id, finalEndpoint, revision } = encoded;
+            const mark = {
+                type: "MoveIn",
+                id,
+            };
+            mark.revision = decodeRevision(revision, context);
+            if (finalEndpoint !== undefined) {
+                mark.finalEndpoint = changeAtomIdCodec.decode(finalEndpoint, context);
+            }
+            return mark;
         },
-        insert(encoded, count, cellId, context) {
+        insert(encoded, context) {
             const { id, revision } = encoded;
             const mark = {
                 type: "Insert",
                 id,
             };
-            mark.revision = decodeRevision(revision, context.baseContext);
-            const attachId = getAttachedRootId(mark);
-            if (cellId !== undefined && !areEqualChangeAtomIds(cellId, attachId)) {
-                context.decodeRootRename(cellId, attachId, count);
-            }
+            mark.revision = decodeRevision(revision, context);
             return mark;
         },
-        remove(encoded, count, cellId, context) {
+        remove(encoded, context) {
             const { id, revision, idOverride } = encoded;
-            const cellRename = idOverride !== undefined
-                ? changeAtomIdCodec.decode(idOverride, context.baseContext)
-                : undefined;
-            return decodeDetach(cellId, count, decodeRevision(revision, context.baseContext), id, cellRename, undefined, context);
+            const mark = {
+                type: "Remove",
+                id,
+            };
+            mark.revision = decodeRevision(revision, context);
+            if (idOverride !== undefined) {
+                mark.idOverride = changeAtomIdCodec.decode(idOverride, context);
+            }
+            return mark;
         },
-        moveOut(encoded, count, cellId, context) {
-            const { id, idOverride, revision, finalEndpoint } = encoded;
-            const cellRename = idOverride !== undefined
-                ? changeAtomIdCodec.decode(idOverride, context.baseContext)
-                : undefined;
-            const decodedRevision = decodeRevision(revision, context.baseContext);
+        moveOut(encoded, context) {
+            const { id, finalEndpoint, idOverride, revision } = encoded;
+            const mark = {
+                type: "MoveOut",
+                id,
+            };
+            mark.revision = decodeRevision(revision, context);
             if (finalEndpoint !== undefined) {
-                const decodedEndpoint = changeAtomIdCodec.decode(finalEndpoint, context.baseContext);
-                return decodeDetach(cellId, count, decodedEndpoint.revision ?? fail("Revision should be defined"), decodedEndpoint.localId, cellRename, { revision: decodedRevision, localId: id }, context);
+                mark.finalEndpoint = changeAtomIdCodec.decode(finalEndpoint, context);
             }
-            return decodeDetach(cellId, count, decodedRevision, id, cellRename, undefined, context);
+            if (idOverride !== undefined) {
+                mark.idOverride = changeAtomIdCodec.decode(idOverride, context);
+            }
+            return mark;
         },
-        attachAndDetach(encoded, count, cellId, context) {
+        attachAndDetach(encoded, context) {
+            const attach = decoderDispatcher.dispatch(encoded.attach, context);
+            const detach = decoderDispatcher.dispatch(encoded.detach, context);
             // In documents generated by clients on release >=2.2 (i.e., running the code from the PR that added this comment),
             // renames are encoded as AttachAndDetach with a special id.
             // This ensures forward-compatibility of clients on release <=2.1 with documents/ops generated by clients on release >=2.2.
-            const encodedRenameId = tryGetEncodedCellRenameFromAttachAndDetach(encoded);
-            if (encodedRenameId !== undefined) {
+            if (attach.id === renameLocalId) {
+                assert(detach.idOverride !== undefined, 0x9f8 /* Rename must have idOverride */);
                 return {
                     type: "Rename",
-                    idOverride: changeAtomIdCodec.decode(encodedRenameId, context.baseContext),
+                    idOverride: detach.idOverride,
                 };
             }
-            assert(encoded.detach.remove !== undefined, "Attach and detach should always contains a remove");
-            const detachId = encoded.detach.remove.idOverride !== undefined
-                ? changeAtomIdCodec.decode(encoded.detach.remove.idOverride, context.baseContext)
-                : {
-                    revision: decodeRevision(encoded.detach.remove.revision, context.baseContext),
-                    localId: encoded.detach.remove.id,
-                };
-            assert(cellId !== undefined, "Attach and detach should target an empty cell");
-            if (encoded.attach.moveIn !== undefined) {
-                context.decodeMoveAndDetach(detachId, count);
-            }
-            else {
-                context.decodeRootRename(cellId, detachId, count);
-            }
             return {
-                type: "Rename",
-                idOverride: detachId,
+                type: "AttachAndDetach",
+                attach,
+                detach,
             };
         },
     };
-    return decoderLibrary;
-}
-function decodeDetach(cellId, count, revision, localId, cellRename, detachCellId, context) {
-    const detachId = { revision, localId };
-    if (cellId !== undefined) {
-        context.decodeRootRename(cellId, detachId, count);
-        return {
-            type: "Rename",
-            idOverride: cellRename ?? detachId,
-        };
-    }
-    const mark = {
-        type: "Remove",
-        revision,
-        id: localId,
-    };
-    if (cellRename !== undefined) {
-        mark.cellRename = cellRename;
-    }
-    if (detachCellId !== undefined) {
-        mark.detachCellId = detachCellId;
-    }
-    return mark;
-}
-export function makeV2Codec(revisionTagCodec) {
-    const { decodeMarkEffect, changeAtomIdCodec } = makeV2CodecHelpers(revisionTagCodec);
+    const decoderDispatcher = new DiscriminatedUnionDispatcher(decoderLibrary);
     return {
-        encode: (changeset, context) => encodeSequenceChangeset(changeset, context, (revision) => encodeRevisionWithContext(revision, context.baseContext, revisionTagCodec), changeAtomIdCodec, encodeMarkEffectV2),
-        decode: (changeset, context) => decodeSequenceChangeset(changeset, context, changeAtomIdCodec, decodeMarkEffect),
-        encodedSchema: ChangesetSchema(EncodedNodeChangeset),
+        changeAtomIdCodec,
+        markEffectCodec,
+        decoderLibrary,
+        decodeRevision,
     };
 }
-export function encodeSequenceChangeset(changeset, context, encodeRevision, changeAtomIdCodec, encodeMarkEffect) {
-    const jsonMarks = [];
-    for (const mark of changeset) {
-        jsonMarks.push(...encodeMark(mark, context, encodeRevision, changeAtomIdCodec, encodeMarkEffect));
-    }
-    return jsonMarks;
-}
-function encodeMark(mark, context, encodeRevision, changeAtomIdCodec, encodeMarkEffect) {
-    const splitLength = getLengthToSplitMark(mark, context);
-    if (splitLength < mark.count) {
-        const [mark1, mark2] = splitMark(mark, splitLength);
-        return [
-            encodeSplitMark(mark1, context, encodeRevision, changeAtomIdCodec, encodeMarkEffect),
-            ...encodeMark(mark2, context, encodeRevision, changeAtomIdCodec, encodeMarkEffect),
-        ];
-    }
-    return [encodeSplitMark(mark, context, encodeRevision, changeAtomIdCodec, encodeMarkEffect)];
-}
-function encodeRename(mark, context, changeAtomIdCodec, encodeRevision) {
-    assert(mark.cellId !== undefined, "Rename should target empty cell");
-    const inputDetachId = context.getInputRootId(mark.idOverride, mark.count).value;
-    const isMoveInAndDetach = !context.isAttachId(mark.idOverride, mark.count).value &&
-        (context.isDetachId(mark.idOverride, mark.count).value ||
-            (inputDetachId !== undefined && !areEqualChangeAtomIds(inputDetachId, mark.cellId)));
-    if (isMoveInAndDetach) {
-        // These cells are the final detach location of moved nodes.
-        const encodedRevision = encodeRevision(mark.idOverride.revision);
-        // XXX: Use finalEndpoint if there is an associated cellDetachId.
-        return {
-            attachAndDetach: {
-                attach: {
-                    moveIn: {
-                        revision: encodedRevision,
-                        id: mark.idOverride.localId,
-                    },
-                },
-                detach: {
-                    remove: {
-                        revision: encodedRevision,
-                        id: mark.idOverride.localId,
-                    },
-                },
-            },
-        };
-    }
-    const renamedRootId = context.rootRenames.getFirst(mark.cellId, mark.count).value;
-    const outputRootId = renamedRootId ?? mark.cellId;
-    const isMoveOutAndAttach = context.isAttachId(outputRootId, mark.count).value;
-    const isMoveOutAndDetach = renamedRootId !== undefined && !areEqualChangeAtomIds(renamedRootId, mark.idOverride);
-    if (isMoveOutAndAttach || isMoveOutAndDetach) {
-        // Detached nodes which were last at this cell location have been moved.
-        // XXX: mark.idOverride represents detachCellId, so we should represent it using the moveOut's ID and use outputRootId as the finalDetachId.
-        // Is that always true?
-        return {
-            moveOut: {
-                revision: encodeRevision(outputRootId.revision),
-                id: outputRootId.localId,
-                idOverride: changeAtomIdCodec.encode(mark.idOverride, context.baseContext),
-            },
-        };
-    }
-    if (renamedRootId !== undefined) {
-        return {
-            remove: {
-                revision: encodeRevision(outputRootId.revision),
-                id: outputRootId.localId,
-            },
-        };
-    }
-    // In documents generated by clients on release >=2.2 (i.e., running the code from the PR that added this comment),
-    // renames are encoded as AttachAndDetach with a special id.
-    // This ensures forward-compatibility of clients on release <=2.1 with documents/ops generated by clients on release >=2.2.
+export function makeV2Codec(revisionTagCodec) {
+    const { markEffectCodec, changeAtomIdCodec } = makeV2CodecHelpers(revisionTagCodec);
     return {
-        attachAndDetach: {
-            attach: { insert: { id: renameLocalId } },
-            detach: {
-                remove: {
-                    id: renameLocalId,
-                    idOverride: changeAtomIdCodec.encode(mark.idOverride, context.baseContext),
-                },
-            },
-        },
-    };
-}
-function getLengthToSplitMark(mark, context) {
-    let count = mark.cellId !== undefined
-        ? rangeQueryChangeAtomIdMap(context.rootNodeChanges, mark.cellId, mark.count).length
-        : mark.count;
-    if (mark.cellId !== undefined) {
-        count = context.getInputRootId(mark.cellId, count).length;
-    }
-    switch (mark.type) {
-        case "Insert":
-            count = context.isDetachId(getAttachedRootId(mark), count).length;
-            break;
-        case "Remove":
-            count = context.isAttachId(getDetachedRootId(mark), count).length;
-            break;
-        case "Rename": {
-            count = context.getInputRootId(mark.idOverride, count).length;
-            count = context.isAttachId(mark.idOverride, count).length;
-            count = context.isDetachId(mark.idOverride, count).length;
-            const cellId = mark.cellId ?? fail("Rename should have cell ID");
-            const renameEntry = context.rootRenames.getFirst(cellId, count);
-            count = renameEntry.length;
-            count = context.isAttachId(renameEntry.value ?? cellId, count).length;
-            break;
-        }
-        default:
-            break;
-    }
-    return count;
-}
-function encodeSplitMark(mark, context, encodeRevision, changeAtomIdCodec, encodeMarkEffect) {
-    const encodedMark = {
-        count: mark.count,
-    };
-    if (!isNoopMark(mark)) {
-        encodedMark.effect = encodeMarkEffect(mark, context, encodeRevision, changeAtomIdCodec);
-    }
-    if (mark.cellId !== undefined) {
-        assert(mark.changes === undefined, "Empty cells should not have node changes");
-        encodedMark.cellId = changeAtomIdCodec.encode(mark.cellId, context.baseContext);
-        const nodeId = getFromChangeAtomIdMap(context.rootNodeChanges, mark.cellId);
-        if (nodeId !== undefined) {
-            encodedMark.changes = context.encodeNode(nodeId);
-        }
-    }
-    else if (mark.changes !== undefined) {
-        encodedMark.changes = context.encodeNode(mark.changes);
-    }
-    return encodedMark;
-}
-function encodeMarkEffectV2(mark, context, encodeRevision, changeAtomIdCodec) {
-    const type = mark.type;
-    switch (type) {
-        case "Insert": {
-            const attachId = getAttachedRootId(mark);
-            const isMove = context.isDetachId(attachId, 1).value;
-            // If the input context ID for these nodes is not the cell ID,
-            // then these nodes are being moved from the location at which they were last detached.
-            const inputId = context.getInputRootId(attachId, mark.count).value ?? attachId;
-            const isInitialAttachLocation = mark.cellId === undefined || areEqualChangeAtomIds(mark.cellId, inputId);
-            return isMove || !isInitialAttachLocation
-                ? {
-                    moveIn: { revision: encodeRevision(mark.revision), id: mark.id },
-                }
-                : {
-                    insert: {
-                        revision: encodeRevision(mark.revision),
-                        id: mark.id,
-                    },
+        encode: (changeset, context) => {
+            const jsonMarks = [];
+            for (const mark of changeset) {
+                const encodedMark = {
+                    count: mark.count,
                 };
-        }
-        case "Remove": {
-            const encodedIdOverride = mark.cellRename !== undefined
-                ? changeAtomIdCodec.encode(mark.cellRename, context.baseContext)
-                : undefined;
-            const detachId = getDetachedRootId(mark);
-            const isMove = context.isAttachId(detachId, 1).value;
-            const outputCellId = mark.cellRename ?? mark.detachCellId ?? detachId;
-            // If the final detach location for the nodes were here,
-            // then the output cell ID would be the same as the detach ID.
-            // So if the cell ID is different from the detach ID, the nodes must have been moved.
-            const isFinalDetachLocation = areEqualChangeAtomIds(detachId, outputCellId);
-            const isMoveOrDetachedMove = isMove || !isFinalDetachLocation;
-            if (mark.detachCellId !== undefined) {
-                assert(isMoveOrDetachedMove, "Only detaches representing a move out should specify a detach cell ID");
-                // XXX: Set final endpoint on the move in.
-                return {
-                    moveOut: {
-                        revision: encodeRevision(mark.detachCellId.revision),
-                        id: mark.detachCellId.localId,
-                        idOverride: encodedIdOverride,
-                        finalEndpoint: changeAtomIdCodec.encode({ revision: mark.revision, localId: mark.id }, context.baseContext),
-                    },
-                };
-            }
-            const encodedRevision = encodeRevision(mark.revision);
-            return isMoveOrDetachedMove
-                ? {
-                    moveOut: {
-                        revision: encodedRevision,
-                        id: mark.id,
-                        idOverride: encodedIdOverride,
-                    },
+                if (!isNoopMark(mark)) {
+                    encodedMark.effect = markEffectCodec.encode(mark, context.baseContext);
+                }
+                if (mark.cellId !== undefined) {
+                    encodedMark.cellId = changeAtomIdCodec.encode(mark.cellId, context.baseContext);
                 }
-                : {
-                    remove: {
-                        revision: encodedRevision,
-                        idOverride: encodedIdOverride,
-                        id: mark.id,
-                    },
+                if (mark.changes !== undefined) {
+                    encodedMark.changes = context.encodeNode(mark.changes);
+                }
+                jsonMarks.push(encodedMark);
+            }
+            return jsonMarks;
+        },
+        decode: (changeset, context) => {
+            const marks = [];
+            for (const mark of changeset) {
+                const decodedMark = {
+                    count: mark.count,
                 };
-        }
-        case "Rename":
-            return encodeRename(mark, context, changeAtomIdCodec, encodeRevision);
-        case NoopMarkType:
-            fail(0xb2c /* Mark type: NoopMarkType should not be encoded. */);
-        default:
-            unreachableCase(type);
-    }
-}
-export function encodeRevisionWithContext(revision, context, revisionTagCodec) {
-    return revision === undefined || revision === context.revision
-        ? undefined
-        : revisionTagCodec.encode(revision, context);
+                if (mark.effect !== undefined) {
+                    Object.assign(decodedMark, markEffectCodec.decode(mark.effect, context.baseContext));
+                }
+                if (mark.cellId !== undefined) {
+                    decodedMark.cellId = changeAtomIdCodec.decode(mark.cellId, context.baseContext);
+                }
+                // Type deduction wrongly narrows the type of `decodedMark` to `NoopMark & HasMarkFields`.
+                // We declare a new casted copy of `decodedMark` to recover the correct type.
+                let decodedMark2 = decodedMark;
+                if (decodedMark2.cellId !== undefined && decodedMark2.type === "AttachAndDetach") {
+                    // In documents generated by clients on release <=2.1 (i.e., not running the code from the PR that added this comment),
+                    // rename-like AttachAndDetach marks are not normalized to Rename marks thus requiring this normalization step.
+                    // This ensures backward compatibility with documents generated by clients on release <=2.1.
+                    decodedMark2 = normalizeCellRename(decodedMark2.cellId, decodedMark2.count, decodedMark2.attach, decodedMark2.detach);
+                }
+                if (mark.changes !== undefined) {
+                    decodedMark2.changes = context.decodeNode(mark.changes);
+                }
+                marks.push(decodedMark2);
+            }
+            return marks;
+        },
+        encodedSchema: ChangesetSchema(EncodedNodeChangeset),
+    };
 }
 /**
  * Arbitrary ID that is used to indicate a Rename effect.
  */
 const renameLocalId = brand(-1);
-/**
- * If the encoded mark effect represents a simple cell rename (with no effect on root nodes),
- * returns the encoded form of the ID the cell is being renamed to,
- * and otherwise returns undefined.
- */
-export function tryGetEncodedCellRename(encoded) {
-    const attachAndDetach = encoded.attachAndDetach;
-    if (attachAndDetach === undefined) {
-        return undefined;
-    }
-}
-function tryGetEncodedCellRenameFromAttachAndDetach(encoded) {
-    // In documents generated by clients on release >=2.2 (i.e., running the code from the PR that added this comment),
-    // renames are encoded as AttachAndDetach with a special id.
-    // This ensures forward-compatibility of clients on release <=2.1 with documents/ops generated by clients on release >=2.2.
-    if (encoded.attach.insert?.id === renameLocalId) {
-        assert(encoded.detach.remove?.idOverride !== undefined, 0x9f8 /* Rename must have idOverride */);
-        return encoded.detach.remove.idOverride;
-    }
-}
 //# sourceMappingURL=sequenceFieldCodecV2.js.map