@yorkie-js/sdk 0.7.6 → 0.7.8

package/dist/yorkie-js-sdk.js

@@ -362,7 +362,7 @@
     }
   }
   const IMPLICIT$3 = 2;
-  const unsafeLocal = Symbol.for("reflect unsafe local");
+  const unsafeLocal = /* @__PURE__ */ Symbol.for("reflect unsafe local");
   function unsafeOneofCase(target, oneof) {
     const c = target[oneof.localName].case;
     if (c === void 0) {
@@ -588,7 +588,7 @@
     }
     return ret;
   }
-  const tokenZeroMessageField = Symbol();
+  const tokenZeroMessageField = /* @__PURE__ */ Symbol();
   const messagePrototypes = /* @__PURE__ */ new WeakMap();
   function createZeroMessage(desc) {
     let msg;
@@ -690,7 +690,7 @@
   function isFieldError(arg) {
     return arg instanceof Error && errorNames.includes(arg.name) && "field" in arg && typeof arg.field == "function";
   }
-  const symbol = Symbol.for("@bufbuild/protobuf/text-encoding");
+  const symbol = /* @__PURE__ */ Symbol.for("@bufbuild/protobuf/text-encoding");
   function getTextEncoding() {
     if (globalThis[symbol] == void 0) {
       const te = new globalThis.TextEncoder();
@@ -4058,7 +4058,7 @@
       msg.set(field, scalarValue);
     }
   }
-  const tokenIgnoredUnknownEnum = Symbol();
+  const tokenIgnoredUnknownEnum = /* @__PURE__ */ Symbol();
   function readEnum(desc, json, ignoreUnknownFields, nullAsZeroValue) {
     if (json === null) {
       if (desc.typeName == "google.protobuf.NullValue") {
@@ -4084,7 +4084,7 @@
     }
     throw new Error(`cannot decode ${desc} from JSON: ${formatVal(json)}`);
   }
-  const tokenNull = Symbol();
+  const tokenNull = /* @__PURE__ */ Symbol();
   function scalarFromJson(field, json, nullAsZeroValue) {
     if (json === null) {
       if (nullAsZeroValue) {
@@ -5905,6 +5905,8 @@
       this.message = message;
       this.toString = () => `[code=${this.code}]: ${this.message}`;
     }
+    code;
+    message;
     name = "YorkieError";
     stack;
   }
@@ -11134,6 +11136,32 @@
         }
         actualRight.push(child);
       }
+      if (versionVector) {
+        const movedToLeft = [];
+        const remaining = [];
+        let boundaryReached = false;
+        for (const child of actualRight) {
+          if (!boundaryReached) {
+            if (child.insPrevID !== void 0 && !child.isText) {
+              remaining.push(child);
+              continue;
+            }
+            const actorID = child.id.getCreatedAt().getActorID();
+            const knownLamport = versionVector.get(actorID);
+            if (knownLamport === void 0 || knownLamport < child.id.getCreatedAt().getLamport()) {
+              movedToLeft.push(child);
+              continue;
+            }
+          }
+          boundaryReached = true;
+          remaining.push(child);
+        }
+        if (movedToLeft.length > 0) {
+          left.push(...movedToLeft);
+          actualRight.length = 0;
+          actualRight.push(...remaining);
+        }
+      }
       this._children = left;
       clone._children = actualRight;
       this.visibleSize = this._children.reduce(
@@ -11910,8 +11938,14 @@
         split.insPrevID = this.id;
         if (this.insNextID) {
           const insNext = tree.findFloorNode(this.insNextID);
-          insNext.insPrevID = split.id;
           split.insNextID = this.insNextID;
+          if (insNext) {
+            insNext.insPrevID = split.id;
+            if (!this.isText && insNext.parent && !insNext.isRemoved && insNext.parent !== split.parent && split.allChildren.length === 0) {
+              split.parent.detachChild(split);
+              insNext.parent.insertBefore(split, insNext);
+            }
+          }
         }
         this.insNextID = split.id;
         tree.registerNode(split);
@@ -12135,7 +12169,7 @@
      * given node, advancing past element-type split siblings that the editing
      * client did not know about (not in versionVector).
      */
-    advancePastUnknownSplitSiblings(node, versionVector) {
+    advancePastUnknownSplitSiblings(node, versionVector, relaxParentCheck = false, skipActorID) {
       if (!versionVector || !node) {
         return node;
       }
@@ -12145,10 +12179,13 @@
         if (!next || next.isText) {
           break;
         }
-        if (next.parent !== current.parent) {
+        if (!relaxParentCheck && next.parent !== current.parent) {
           break;
         }
         const actorID = next.id.getCreatedAt().getActorID();
+        if (skipActorID !== void 0 && actorID === skipActorID) {
+          break;
+        }
         const knownLamport = versionVector.get(actorID);
         if (knownLamport !== void 0 && knownLamport >= next.id.getCreatedAt().getLamport()) {
           break;
@@ -12489,6 +12526,25 @@
       addDataSizes(diff, diffTo, diffFrom);
       const fromLeft = fromLeftRaw !== fromParent ? this.advancePastUnknownSplitSiblings(fromLeftRaw, versionVector) : fromLeftRaw;
       const toLeft = toLeftRaw !== toParent ? this.advancePastUnknownSplitSiblings(toLeftRaw, versionVector) : toLeftRaw;
+      let collectFromParent = fromParent;
+      let collectFromLeft = fromLeft;
+      if (fromLeft !== fromParent && fromParent !== toParent) {
+        let current = fromLeft;
+        while (current.insNextID) {
+          const next = this.findFloorNode(current.insNextID);
+          if (!next || next.isText) {
+            break;
+          }
+          if (next.parent && next.parent === toParent) {
+            if (toLeft !== toParent) {
+              collectFromLeft = next;
+              collectFromParent = toParent;
+            }
+            break;
+          }
+          current = next;
+        }
+      }
       const fromIdx = this.toIndex(fromParent, fromLeft);
       const fromPath = this.toPath(fromParent, fromLeft);
       const nodesToBeRemoved = [];
@@ -12497,8 +12553,8 @@
       const toBeMergedNodes = [];
       const preTombstoned = /* @__PURE__ */ new Set();
       this.traverseInPosRange(
-        fromParent,
-        fromLeft,
+        collectFromParent,
+        collectFromLeft,
         toParent,
         toLeft,
         ([node, tokenType], ended) => {
@@ -12546,6 +12602,7 @@
         tokensToBeRemoved,
         editedAt
       );
+      const mergeLevel = toBeMergedNodes.length;
       const pairs = [];
       for (const node of nodesToBeRemoved) {
         if (node.remove(editedAt)) {
@@ -12602,9 +12659,20 @@
         let parent = fromParent;
         let left = fromLeft;
         while (splitCount < splitLevel) {
+          if (left !== parent) {
+            left = this.advancePastUnknownSplitSiblings(
+              left,
+              versionVector,
+              true,
+              editedAt.getActorID()
+            );
+            if (left.parent && left.parent !== parent) {
+              parent = left.parent;
+            }
+          }
           parent.split(
             this,
-            parent.findOffset(left, true) + 1,
+            left !== parent ? parent.findOffset(left, true) + 1 : 0,
             issueTimeTicket,
             versionVector
           );
@@ -12661,7 +12729,15 @@
           }
         }
       }
-      return [changes, pairs, diff, nodesToBeRemoved, fromIdx];
+      return [
+        changes,
+        pairs,
+        diff,
+        nodesToBeRemoved,
+        fromIdx,
+        mergeLevel,
+        preTombstoned
+      ];
     }
     /**
      * `editT` edits the given range with the given value.
@@ -13102,11 +13178,35 @@
       return [prev, prev.isText ? TokenType.Text : TokenType.End];
     }
   }
-  function clearRemovedAt(node) {
-    traverseAll(node, (n) => {
+  function cloneAndDropPreTombstoned(node, preTombstoned) {
+    const clone = node.deepcopy();
+    filterChildren(clone, preTombstoned);
+    traverseAll(clone, (n) => {
       n.removedAt = void 0;
-      n.visibleSize = n.totalSize;
+      if (n.isText) {
+        n.visibleSize = n.value.length;
+        n.totalSize = n.value.length;
+        return;
+      }
+      let size = 0;
+      for (const child of n._children) size += child.paddedSize();
+      n.visibleSize = size;
+      n.totalSize = size;
     });
+    return clone;
+  }
+  function filterChildren(node, preTombstoned) {
+    const all = node._children;
+    if (!all) return;
+    const kept = [];
+    for (const child of all) {
+      if (preTombstoned.has(child.id.toIDString())) {
+        continue;
+      }
+      filterChildren(child, preTombstoned);
+      kept.push(child);
+    }
+    node._children = kept;
   }
   class TreeEditOperation extends Operation {
     fromPos;
@@ -13178,7 +13278,15 @@
           this.toPos = tree.findPos(this.toIdx);
         }
       }
-      const [changes, pairs, diff, removedNodes, preEditFromIdx] = tree.edit(
+      const [
+        changes,
+        pairs,
+        diff,
+        removedNodes,
+        preEditFromIdx,
+        mergeLevel,
+        preTombstoned
+      ] = tree.edit(
         [this.fromPos, this.toPos],
         this.contents?.map((content) => content.deepcopy()),
         this.splitLevel,
@@ -13211,10 +13319,16 @@
       );
       this.lastToIdx = preEditFromIdx + removedSize;
       let reverseOp;
-      const isPureL1Split = this.splitLevel === 1 && !this.contents?.length && removedNodes.length === 0;
+      const isPureSplit = this.splitLevel > 0 && !this.contents?.length && removedNodes.length === 0;
       if (this.splitLevel === 0) {
-        reverseOp = this.toReverseOperation(tree, removedNodes, preEditFromIdx);
-      } else if (isPureL1Split) {
+        reverseOp = this.toReverseOperation(
+          tree,
+          removedNodes,
+          preEditFromIdx,
+          preTombstoned,
+          mergeLevel
+        );
+      } else if (isPureSplit) {
         reverseOp = this.toSplitReverseOperation(tree, preEditFromIdx);
       }
       root.acc(diff);
@@ -13251,7 +13365,7 @@
      * @param removedNodes - Nodes that were removed by this edit
      * @param preEditFromIdx - The from index captured BEFORE the edit
      */
-    toReverseOperation(tree, removedNodes, preEditFromIdx) {
+    toReverseOperation(tree, removedNodes, preEditFromIdx, preTombstoned, mergeLevel) {
       if (this.redoSplitLevel !== void 0 && this.redoSplitLevel > 0) {
         const splitRedoFromPos = tree.findPos(preEditFromIdx);
         const splitRedoOp = TreeEditOperation.create(
@@ -13270,19 +13384,36 @@
         );
         return splitRedoOp;
       }
+      if (mergeLevel && mergeLevel > 0) {
+        const splitFromPos = tree.findPos(preEditFromIdx);
+        const splitUndoOp = TreeEditOperation.create(
+          this.getParentCreatedAt(),
+          splitFromPos,
+          splitFromPos,
+          void 0,
+          // no inserted content — split creates boundaries
+          mergeLevel,
+          // splitLevel = number of merged boundaries
+          void 0,
+          // executedAt assigned at undo time
+          true,
+          // isUndoOp
+          preEditFromIdx,
+          preEditFromIdx
+        );
+        return splitUndoOp;
+      }
       const insertedContentSize = this.contents ? this.contents.reduce((sum, node) => sum + node.paddedSize(), 0) : 0;
       const maxNeededIdx = preEditFromIdx + insertedContentSize;
       if (maxNeededIdx > tree.getSize()) {
         return void 0;
       }
       const topLevelRemoved = removedNodes.filter(
-        (node) => !node.parent || !removedNodes.includes(node.parent)
+        (node) => !preTombstoned.has(node.id.toIDString()) && (!node.parent || !removedNodes.includes(node.parent))
       );
-      const reverseContents = topLevelRemoved.length > 0 ? topLevelRemoved.map((n) => {
-        const clone = n.deepcopy();
-        clearRemovedAt(clone);
-        return clone;
-      }) : void 0;
+      const reverseContents = topLevelRemoved.length > 0 ? topLevelRemoved.map(
+        (n) => cloneAndDropPreTombstoned(n, preTombstoned)
+      ) : void 0;
       const reverseFromPos = tree.findPos(preEditFromIdx);
       let reverseToPos;
       if (insertedContentSize > 0) {
@@ -20101,6 +20232,11 @@
         }
       ]);
     }
+    /**
+     * `clearHistory` flushes both undo and redo stacks. This is used
+     * after applying a snapshot or initialRoot so that setup operations
+     * are not reachable via undo.
+     */
     clearHistory() {
       this.internalHistory.clearRedo();
       this.internalHistory.clearUndo();
@@ -20560,10 +20696,7 @@
       }
       const ops = isUndo ? this.internalHistory.popUndo() : this.internalHistory.popRedo();
       if (!ops) {
-        throw new YorkieError(
-          Code.ErrRefused,
-          `There is no operation to be ${isUndo ? "undone" : "redone"}`
-        );
+        return;
       }
       this.ensureClone();
       const ctx = ChangeContext.create(
@@ -20656,6 +20789,8 @@
     syncMode;
     changeEventReceived;
     lastHeartbeatTime;
+    pollInterval;
+    pollIntervalPinned;
     reconnectStreamDelay;
     cancelled;
     watchStream;
@@ -20663,13 +20798,15 @@
     watchAbortController;
     syncPromise;
     _detaching = false;
-    constructor(reconnectStreamDelay, resource, resourceID, syncMode) {
+    constructor(reconnectStreamDelay, resource, resourceID, syncMode, pollInterval = 0, pollIntervalPinned = false) {
       this.reconnectStreamDelay = reconnectStreamDelay;
       this.resource = resource;
       this.resourceID = resourceID;
       this.syncMode = syncMode;
       this.changeEventReceived = syncMode !== void 0 ? false : void 0;
       this.lastHeartbeatTime = Date.now();
+      this.pollInterval = pollInterval;
+      this.pollIntervalPinned = pollIntervalPinned;
       this.cancelled = false;
     }
     /**
@@ -20689,6 +20826,9 @@
       if (this.syncMode === SyncMode.RealtimePushOnly) {
         return this.resource.hasLocalChanges();
       }
+      if (this.syncMode === SyncMode.Polling) {
+        return Date.now() - this.lastHeartbeatTime >= this.pollInterval;
+      }
       return this.syncMode !== SyncMode.Manual && (this.resource.hasLocalChanges() || (this.changeEventReceived ?? false));
     }
     /**
@@ -20702,7 +20842,8 @@
       if (this.syncMode === SyncMode.Manual) {
         return false;
       }
-      return Date.now() - this.lastHeartbeatTime >= heartbeatInterval;
+      const interval = this.pollInterval > 0 ? this.pollInterval : heartbeatInterval;
+      return Date.now() - this.lastHeartbeatTime >= interval;
     }
     /**
      * `updateHeartbeatTime` updates the last heartbeat time.
@@ -20781,6 +20922,16 @@
         }
       }
     }
+    /**
+     * `resetCancelled` clears the cancelled flag so the watch loop can run again
+     * after a previous cancellation (e.g., after changeSyncMode back to Realtime).
+     * Caller must invoke `runWatchLoop` immediately after to claim the stream slot;
+     * `doLoop`'s `if (this.watchStream)` guard prevents double-stream creation if a
+     * delayed `onDisconnect` callback from the previously-cancelled stream races.
+     */
+    resetCancelled() {
+      this.cancelled = false;
+    }
     /**
      * `cancelWatchStream` cancels the watch stream.
      */
@@ -20815,7 +20966,7 @@
     };
   }
   const name = "@yorkie-js/sdk";
-  const version = "0.7.6";
+  const version = "0.7.8";
   const pkg = {
     name,
     version
@@ -21098,6 +21249,7 @@
     SyncMode2["Realtime"] = "realtime";
     SyncMode2["RealtimePushOnly"] = "realtime-pushonly";
     SyncMode2["RealtimeSyncOff"] = "realtime-syncoff";
+    SyncMode2["Polling"] = "polling";
     return SyncMode2;
   })(SyncMode || {});
   var ClientStatus = /* @__PURE__ */ ((ClientStatus2) => {
@@ -21110,6 +21262,7 @@
     ClientCondition2["WatchLoop"] = "WatchLoop";
     return ClientCondition2;
   })(ClientCondition || {});
+  const DefaultPollingIntervalMs = 3e3;
   const DefaultClientOptions = {
     rpcAddr: "https://api.yorkie.dev",
     syncLoopDuration: 50,
@@ -21305,6 +21458,14 @@
       doc.setActor(this.id);
       doc.update((_, p) => p.set(opts.initialPresence || {}));
       const syncMode = opts.syncMode ?? "realtime";
+      if (opts.documentPollInterval !== void 0 && opts.documentPollInterval <= 0) {
+        throw new YorkieError(
+          Code.ErrInvalidArgument,
+          "documentPollInterval must be greater than 0"
+        );
+      }
+      const pollIntervalPinned = opts.documentPollInterval !== void 0;
+      const pollInterval = pollIntervalPinned ? opts.documentPollInterval : syncMode === "polling" ? DefaultPollingIntervalMs : 0;
       return this.enqueueTask(async () => {
         try {
           const res = await this.rpcClient.attachDocument(
@@ -21334,10 +21495,12 @@
               this.reconnectStreamDelay,
               doc,
               res.documentId,
-              syncMode
+              syncMode,
+              pollInterval,
+              pollIntervalPinned
             )
           );
-          if (syncMode !== "manual") {
+          if (syncMode !== "manual" && syncMode !== "polling") {
             await this.runWatchLoop(doc.getKey());
           }
           logger.info(`[AD] c:"${this.getKey()}" attaches d:"${doc.getKey()}"`);
@@ -21353,6 +21516,7 @@
               }
             });
           }
+          doc.clearHistory();
           return doc;
         } catch (err) {
           logger.error(`[AD] c:"${this.getKey()}" err :`, err);
@@ -21463,12 +21627,23 @@
           channel.setSessionID(res.sessionId);
           channel.updateSessionCount(Number(res.sessionCount), 0);
           channel.applyStatus(ChannelStatus.Attached);
-          const syncMode = opts.isRealtime !== false ? "realtime" : "manual";
+          const syncMode = opts.syncMode ?? "realtime";
+          this.assertValidChannelSyncMode(syncMode);
+          if (opts.channelHeartbeatInterval !== void 0 && opts.channelHeartbeatInterval <= 0) {
+            throw new YorkieError(
+              Code.ErrInvalidArgument,
+              "channelHeartbeatInterval must be greater than 0"
+            );
+          }
+          const pollIntervalPinned = opts.channelHeartbeatInterval !== void 0;
+          const pollInterval = pollIntervalPinned ? opts.channelHeartbeatInterval : syncMode === "polling" ? DefaultPollingIntervalMs : this.channelHeartbeatInterval;
           const attachment = new Attachment(
             this.reconnectStreamDelay,
             channel,
             res.sessionId,
-            syncMode
+            syncMode,
+            pollInterval,
+            pollIntervalPinned
           );
           channel.subscribe("local-broadcast", (event) => {
             const { topic, payload, options } = event;
@@ -21544,9 +21719,17 @@
       return this.enqueueTask(task);
     }
     /**
-     * `changeSyncMode` changes the synchronization mode of the given document.
+     * `changeSyncMode` changes the synchronization mode of the given resource.
      */
-    async changeSyncMode(doc, syncMode) {
+    async changeSyncMode(resource, syncMode) {
+      return this.enqueueTask(async () => {
+        if (resource instanceof Channel) {
+          return this.changeChannelSyncMode(resource, syncMode);
+        }
+        return this.changeDocumentSyncMode(resource, syncMode);
+      });
+    }
+    async changeDocumentSyncMode(doc, syncMode) {
       if (!this.isActive()) {
         throw new YorkieError(
           Code.ErrClientNotActivated,
@@ -21564,19 +21747,66 @@
       if (prevSyncMode === syncMode) {
         return doc;
       }
-      attachment.changeSyncMode(syncMode);
-      if (syncMode === "manual") {
+      if (syncMode === "manual" || syncMode === "polling") {
         attachment.cancelWatchStream();
-        return doc;
       }
+      attachment.changeSyncMode(syncMode);
       if (syncMode === "realtime") {
         attachment.changeEventReceived = true;
       }
-      if (prevSyncMode === "manual") {
+      if (!attachment.pollIntervalPinned) {
+        attachment.pollInterval = syncMode === "polling" ? DefaultPollingIntervalMs : 0;
+      }
+      if ((prevSyncMode === "manual" || prevSyncMode === "polling") && syncMode !== "manual" && syncMode !== "polling") {
+        attachment.resetCancelled();
         await this.runWatchLoop(doc.getKey());
       }
       return doc;
     }
+    /**
+     * `assertValidChannelSyncMode` rejects sync modes that are not valid for
+     * channels. `RealtimePushOnly` and `RealtimeSyncOff` are document-only.
+     */
+    assertValidChannelSyncMode(syncMode) {
+      if (syncMode !== "manual" && syncMode !== "realtime" && syncMode !== "polling") {
+        throw new YorkieError(
+          Code.ErrInvalidArgument,
+          `invalid channel sync mode: ${syncMode}`
+        );
+      }
+    }
+    async changeChannelSyncMode(channel, syncMode) {
+      if (!this.isActive()) {
+        throw new YorkieError(
+          Code.ErrClientNotActivated,
+          `${this.key} is not active`
+        );
+      }
+      const attachment = this.attachmentMap.get(channel.getKey());
+      if (!attachment) {
+        throw new YorkieError(
+          Code.ErrNotAttached,
+          `${channel.getKey()} is not attached`
+        );
+      }
+      const prevSyncMode = attachment.syncMode;
+      if (prevSyncMode === syncMode) {
+        return channel;
+      }
+      this.assertValidChannelSyncMode(syncMode);
+      if (prevSyncMode === "realtime") {
+        attachment.cancelWatchStream();
+      }
+      attachment.changeSyncMode(syncMode);
+      if (!attachment.pollIntervalPinned) {
+        attachment.pollInterval = syncMode === "polling" ? DefaultPollingIntervalMs : syncMode === "realtime" ? this.channelHeartbeatInterval : 0;
+      }
+      if (syncMode === "realtime") {
+        attachment.resetCancelled();
+        await this.runWatchLoop(channel.getKey());
+      }
+      return channel;
+    }
     /**
      * `sync` implementation that handles both Document and Channel.
      */
@@ -22421,6 +22651,7 @@
           return doc;
         }
         doc.applyChangePack(respPack);
+        attachment.updateHeartbeatTime();
         attachment.resource.publish([
           {
             type: DocEventType.SyncStatusChanged,
@@ -22531,8 +22762,11 @@
   function isCounter(value) {
     return typeof value === "object" && value !== null && value.type === "Counter" && typeof value.value === "object";
   }
+  function isDedupCounter(value) {
+    return typeof value === "object" && value !== null && value.type === "DedupCounter" && typeof value.value === "object" && typeof value.registers === "string";
+  }
   function isObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value) && !isText(value) && !isTree(value) && !isInt(value) && !isLong(value) && !isDate(value) && !isBinData(value) && !isCounter(value);
+    return typeof value === "object" && value !== null && !Array.isArray(value) && !isText(value) && !isTree(value) && !isInt(value) && !isLong(value) && !isDate(value) && !isBinData(value) && !isCounter(value) && !isDedupCounter(value);
   }
   function parse(yson) {
     try {
@@ -22548,6 +22782,12 @@
   }
   function preprocessYSON(yson) {
     let result = yson;
+    result = result.replace(
+      /DedupCounter\(Int\((-?\d+)\),"([^"]+)"\)/g,
+      (_, value, registers) => {
+        return `{"__yson_type":"DedupCounter","__yson_data":{"__yson_type":"Int","__yson_data":${value}},"__yson_registers":"${registers}"}`;
+      }
+    );
     result = result.replace(
       /Counter\((Int|Long)\((-?\d+)\)\)/g,
       (_, type, value) => {
@@ -22608,6 +22848,20 @@
         value: value.__yson_data
       };
     }
+    if (value.__yson_type === "DedupCounter" && typeof value.__yson_data === "object" && typeof value.__yson_registers === "string") {
+      const counterValue = postprocessValue(value.__yson_data);
+      if (typeof counterValue === "object" && counterValue !== null && "type" in counterValue && counterValue.type === "Int") {
+        return {
+          type: "DedupCounter",
+          value: counterValue,
+          registers: value.__yson_registers
+        };
+      }
+      throw new YorkieError(
+        Code.ErrInvalidArgument,
+        "DedupCounter must contain Int"
+      );
+    }
     if (value.__yson_type === "Counter" && typeof value.__yson_data === "object") {
       const counterValue = postprocessValue(value.__yson_data);
       if (typeof counterValue === "object" && counterValue !== null && "type" in counterValue && (counterValue.type === "Int" || counterValue.type === "Long")) {
@@ -22696,6 +22950,7 @@
     isBinData,
     isCounter,
     isDate,
+    isDedupCounter,
     isInt,
     isLong,
     isObject,