@atlaskit/editor-plugin-autocomplete 8.0.0 → 9.1.0

package/dist/esm/pm-plugins/canonical-lm-scoring.js

@@ -0,0 +1,364 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+var createTokenTrieNode = function createTokenTrieNode() {
+  return {
+    children: new Map()
+  };
+};
+
+/**
+ * Token trie for the producer's canonical leading-space token sequences.
+ * It lets the scorer expand a shared token prefix once for every surface below
+ * that node (`root cause`, `root directory`, ...), rather than guessing two
+ * arbitrary full surfaces from a broad one-character string prefix.
+ */
+export var CanonicalSurfaceTokenTrie = /*#__PURE__*/function () {
+  function CanonicalSurfaceTokenTrie() {
+    var entries = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    _classCallCheck(this, CanonicalSurfaceTokenTrie);
+    _defineProperty(this, "root", createTokenTrieNode());
+    _defineProperty(this, "tokenIdsBySurface", new Map());
+    var _iterator = _createForOfIteratorHelper(entries),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var _step$value = _slicedToArray(_step.value, 2),
+          surface = _step$value[0],
+          tokenIds = _step$value[1];
+        this.insert(surface, tokenIds);
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+  return _createClass(CanonicalSurfaceTokenTrie, [{
+    key: "insert",
+    value: function insert(surface, tokenIds) {
+      if (tokenIds.length === 0) {
+        return;
+      }
+      var normalizedSurface = surface.toLowerCase();
+      this.tokenIdsBySurface.set(normalizedSurface, _toConsumableArray(tokenIds));
+      var node = this.root;
+      var _iterator2 = _createForOfIteratorHelper(tokenIds),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var tokenId = _step2.value;
+          var child = node.children.get(tokenId);
+          if (!child) {
+            child = createTokenTrieNode();
+            node.children.set(tokenId, child);
+          }
+          node = child;
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+    }
+  }, {
+    key: "getTokenIds",
+    value: function getTokenIds(surface) {
+      var tokenIds = this.tokenIdsBySurface.get(surface.toLowerCase());
+      return tokenIds ? _toConsumableArray(tokenIds) : null;
+    }
+  }, {
+    key: "groupByScoredPrefix",
+    value: function groupByScoredPrefix(candidates) {
+      var groups = new Map();
+      var _iterator3 = _createForOfIteratorHelper(candidates),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var _groups$get;
+          var candidate = _step3.value;
+          if (candidate.scoredTokenCount <= 0 || candidate.scoredTokenCount >= candidate.tokenIds.length) {
+            continue;
+          }
+          var tokenPrefix = candidate.tokenIds.slice(0, candidate.scoredTokenCount);
+          var node = this.root;
+          var _iterator4 = _createForOfIteratorHelper(tokenPrefix),
+            _step4;
+          try {
+            for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+              var tokenId = _step4.value;
+              node = node.children.get(tokenId);
+              if (!node) {
+                break;
+              }
+            }
+          } catch (err) {
+            _iterator4.e(err);
+          } finally {
+            _iterator4.f();
+          }
+          if (!node) {
+            continue;
+          }
+          var key = tokenPrefix.join(',');
+          var group = (_groups$get = groups.get(key)) !== null && _groups$get !== void 0 ? _groups$get : {
+            surfaces: [],
+            tokenPrefix: tokenPrefix
+          };
+          group.surfaces.push(candidate.surface);
+          groups.set(key, group);
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+      return Array.from(groups.values());
+    }
+  }]);
+}();
+var WHITESPACE_REGEX = /[\t-\r \xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF]/;
+var makeContextKey = function makeContextKey(prompt, separatorKind) {
+  return "".concat(separatorKind, "\0").concat(prompt);
+};
+
+/** The part of a candidate's context that depends only on where its surface starts. */
+
+/**
+ * Per-pass store for the position-derived half of a candidate's context.
+ *
+ * Every unigram candidate for a keystroke shares one surface start, and the
+ * phrase candidates share a handful more, so without this the same slice,
+ * `trimEnd` and context key are rebuilt for each of the couple of hundred
+ * candidates. Valid only for a single `textBeforeCursor`.
+ */
+
+export var createCanonicalContextPositionCache = function createCanonicalContextPositionCache() {
+  return new Map();
+};
+
+/**
+ * Derive the causal prompt and artifact eligibility from the exact, untrimmed
+ * pre-cursor text. The shipped artifact contains only tokenizations of
+ * `" " + surface`, so it is valid only when the surface is actually preceded
+ * by whitespace.
+ */
+export var deriveCanonicalCandidateContext = function deriveCanonicalCandidateContext(textBeforeCursor, matchedPrefixLen, surface, getTokenIds, surfaceStartOverride, positionCache) {
+  var derivedSurfaceStart = textBeforeCursor.length - matchedPrefixLen;
+  var surfaceStart = Math.max(0, Math.min(textBeforeCursor.length, surfaceStartOverride !== null && surfaceStartOverride !== void 0 ? surfaceStartOverride : derivedSurfaceStart));
+  var position = positionCache === null || positionCache === void 0 ? void 0 : positionCache.get(surfaceStart);
+  if (position === undefined) {
+    var precedingChar = surfaceStart > 0 ? textBeforeCursor[surfaceStart - 1] : null;
+    var separatorKind = precedingChar === null ? 'document-start' : WHITESPACE_REGEX.test(precedingChar) ? 'whitespace' : 'non-space';
+    var contextBeforeSurface = textBeforeCursor.slice(0, surfaceStart).trimEnd();
+    position = {
+      contextBeforeSurface: contextBeforeSurface,
+      contextKey: makeContextKey(contextBeforeSurface, separatorKind),
+      separatorKind: separatorKind,
+      surfaceStart: surfaceStart
+    };
+    positionCache === null || positionCache === void 0 || positionCache.set(surfaceStart, position);
+  }
+  return _objectSpread(_objectSpread({}, position), {}, {
+    canonicalTokenIds: position.separatorKind === 'whitespace' ? getTokenIds(surface) : null
+  });
+};
+
+/**
+ * Derive the next surface's leading-space context at an actual word boundary.
+ * This lets the local LM start its one-token prime on the space keystroke,
+ * before the user has typed the first character of the next word.
+ */
+export var deriveWhitespaceBoundaryContext = function deriveWhitespaceBoundaryContext(textBeforeCursor) {
+  var _textBeforeCursor$at;
+  if (textBeforeCursor.length === 0 || !WHITESPACE_REGEX.test((_textBeforeCursor$at = textBeforeCursor.at(-1)) !== null && _textBeforeCursor$at !== void 0 ? _textBeforeCursor$at : '')) {
+    return null;
+  }
+  var prompt = textBeforeCursor.trimEnd();
+  if (prompt.length === 0) {
+    return null;
+  }
+  return {
+    contextKey: makeContextKey(prompt, 'whitespace'),
+    prompt: prompt
+  };
+};
+
+/**
+ * Return one prime per exact context, ordered from the latest surface start
+ * (normally the unigram window) to wider phrase windows.
+ */
+export var selectBoundaryPrimeRequests = function selectBoundaryPrimeRequests(familyKey, candidates, maxPrimes) {
+  var byContext = new Map();
+  var _iterator5 = _createForOfIteratorHelper(candidates),
+    _step5;
+  try {
+    for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+      var candidate = _step5.value;
+      if (candidate.canonicalTokenIds === null) {
+        continue;
+      }
+      var current = byContext.get(candidate.contextKey);
+      if (!current || candidate.surfaceStart > current.surfaceStart) {
+        byContext.set(candidate.contextKey, candidate);
+      }
+    }
+  } catch (err) {
+    _iterator5.e(err);
+  } finally {
+    _iterator5.f();
+  }
+  return Array.from(byContext.values()).sort(function (a, b) {
+    return b.surfaceStart - a.surfaceStart;
+  }).slice(0, Math.max(0, maxPrimes)).map(function (candidate, priority) {
+    return {
+      familyKey: familyKey,
+      contextKey: candidate.contextKey,
+      prompt: candidate.contextBeforeSurface,
+      priority: priority
+    };
+  });
+};
+
+/**
+ * `log(sum(exp(values)))`, shifted by the maximum so the sum cannot overflow or
+ * underflow to zero for the sequence log-likelihoods this is called with.
+ *
+ * Returns `-Infinity` for an empty or wholly non-finite input, which makes
+ * `exp(value - logSumExp(values))` evaluate to zero rather than `NaN`.
+ */
+export var logSumExp = function logSumExp(values) {
+  var max = -Infinity;
+  var _iterator6 = _createForOfIteratorHelper(values),
+    _step6;
+  try {
+    for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+      var value = _step6.value;
+      if (Number.isFinite(value) && value > max) {
+        max = value;
+      }
+    }
+  } catch (err) {
+    _iterator6.e(err);
+  } finally {
+    _iterator6.f();
+  }
+  if (!Number.isFinite(max)) {
+    return -Infinity;
+  }
+  var sumExp = 0;
+  var _iterator7 = _createForOfIteratorHelper(values),
+    _step7;
+  try {
+    for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+      var _value = _step7.value;
+      if (Number.isFinite(_value)) {
+        sumExp += Math.exp(_value - max);
+      }
+    }
+  } catch (err) {
+    _iterator7.e(err);
+  } finally {
+    _iterator7.f();
+  }
+  return sumExp > 0 ? max + Math.log(sumExp) : -Infinity;
+};
+
+/** The two shift-and-sum terms of a distribution's log-partition. */
+
+/**
+ * The log-partition depends only on the buffer, but scoring reads the same
+ * buffer once per candidate — so without this the two full-vocabulary passes
+ * below run N times per boundary for an answer that cannot change.
+ *
+ * Keying on the buffer itself is safe because captured logits are never
+ * written to again (see `CanonicalLogitProcessor.processLogits`, which copies
+ * out of WebLLM's reused buffer), and the weak reference lets a retired
+ * boundary's entry go with it.
+ */
+var logPartitionTermsCache = new WeakMap();
+var getLogPartitionTerms = function getLogPartitionTerms(logits) {
+  var cached = logPartitionTermsCache.get(logits);
+  if (cached !== undefined) {
+    return cached;
+  }
+  var maxLogit = -Infinity;
+  for (var i = 0; i < logits.length; i++) {
+    if (logits[i] > maxLogit) {
+      maxLogit = logits[i];
+    }
+  }
+  var terms = null;
+  if (Number.isFinite(maxLogit)) {
+    var sumExp = 0;
+    for (var _i = 0; _i < logits.length; _i++) {
+      sumExp += Math.exp(logits[_i] - maxLogit);
+    }
+    if (sumExp > 0) {
+      terms = {
+        maxLogit: maxLogit,
+        logSumTerm: Math.log(sumExp)
+      };
+    }
+  }
+  logPartitionTermsCache.set(logits, terms);
+  return terms;
+};
+export var logSoftmaxAt = function logSoftmaxAt(logits, target) {
+  if (target < 0 || target >= logits.length) {
+    return -Infinity;
+  }
+  var terms = getLogPartitionTerms(logits);
+  if (terms === null) {
+    return -Infinity;
+  }
+  return logits[target] - terms.maxLogit - terms.logSumTerm;
+};
+
+/**
+ * One processor is registered for the causal model so the scheduler can read
+ * the next-token distribution off any forward pass.
+ *
+ * The scheduler drives decoding token by token — it prefills a prompt, then
+ * feeds each continuation token itself — so the processor never has to force
+ * the model onto a target path. It only has to hand back the distribution the
+ * forward pass produced, which it does without altering the logits.
+ */
+export var CanonicalLogitProcessor = /*#__PURE__*/_createClass(function CanonicalLogitProcessor() {
+  var _this = this;
+  _classCallCheck(this, CanonicalLogitProcessor);
+  _defineProperty(this, "captured", null);
+  _defineProperty(this, "processLogits", function (logits) {
+    // WebLLM reuses its logits buffer between forwards, so keep a private copy.
+    _this.captured = new Float32Array(logits);
+    return logits;
+  });
+  _defineProperty(this, "processSampledToken", function () {
+    // The scheduler chooses the next token; WebLLM's sample is discarded.
+  });
+  _defineProperty(this, "resetState", function () {
+    // WebLLM resets the processor after the caller has armed a capture and
+    // immediately before it prefills a completion prompt, so this only ever
+    // clears a stale reading from the previous run.
+    _this.captured = null;
+  });
+  _defineProperty(this, "startCapture", function () {
+    _this.captured = null;
+  });
+  /**
+   * The captured distribution, or null when the forward pass never ran.
+   *
+   * `processLogits` already copied it, and every capture allocates afresh, so
+   * the buffer handed out here is never written to again.
+   */
+  _defineProperty(this, "getCapturedLogits", function () {
+    return _this.captured;
+  });
+});

package/dist/esm/pm-plugins/debug-mode.js

@@ -16,16 +16,84 @@
  * block uncategorized localStorage/sessionStorage/cookie writes in some products.
  */
 
-var hasUrlDebugFlag = function hasUrlDebugFlag() {
+/**
+ * Shared `%c` styles for all CTC console output, so every log — lifecycle,
+ * async signals, and per-prediction groups — reads consistently.
+ */
+export var CTC_STYLES = {
+  brand: 'color: #00b8d9; font-weight: bold;',
+  section: 'color: #9c27b0; font-weight: bold;',
+  dim: 'color: #888; font-style: italic;',
+  good: 'color: #4caf50; font-weight: bold;',
+  warn: 'color: #ff9800; font-weight: bold;',
+  bad: 'color: #f44336; font-weight: bold;',
+  cold: 'color: #9e9e9e; font-weight: bold;',
+  lm: 'color: #e83e8c; font-weight: bold;',
+  body: 'color: inherit; font-weight: normal;'
+};
+
+/**
+ * Log one aligned section line inside a per-prediction group, e.g.
+ * `INPUT      raw: "…"`. Label is padded so the bodies line up. No-ops unless
+ * debug is enabled, so callers don't need to guard.
+ */
+export var ctcSection = function ctcSection(label, body) {
+  if (!isAutocompleteDebugEnabled()) {
+    return;
+  }
+  // eslint-disable-next-line no-console
+  console.log("%c".concat(label.padEnd(10), "%c").concat(body), CTC_STYLES.section, CTC_STYLES.body);
+};
+
+/**
+ * Log a lifecycle / async-signal line (outside the per-prediction groups),
+ * tagged `[CTC:<tag>]`. No-ops unless debug is enabled, so callers don't need to
+ * guard. Use tags like `init` (loads) and `signal` (slow-lane arrivals).
+ */
+export var ctcTag = function ctcTag(tag, body) {
+  var tagStyle = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : CTC_STYLES.brand;
+  if (!isAutocompleteDebugEnabled()) {
+    return;
+  }
+  // eslint-disable-next-line no-console
+  console.log("%c[CTC:".concat(tag, "]%c ").concat(body), tagStyle, CTC_STYLES.body);
+};
+var readUrlDebugFlag = function readUrlDebugFlag() {
   if (typeof window === 'undefined') {
-    return false;
+    return {
+      enabled: false,
+      verbose: false
+    };
   }
   try {
-    return new URLSearchParams(window.location.search).get('atlCtcDebug') === '1';
+    var value = new URLSearchParams(window.location.search).get('atlCtcDebug');
+    return {
+      enabled: value === '1' || value === 'verbose',
+      verbose: value === 'verbose'
+    };
   } catch (_unused) {
-    return false;
+    return {
+      enabled: false,
+      verbose: false
+    };
   }
 };
+var printLegend = function printLegend(verbose) {
+  // eslint-disable-next-line no-console
+  console.groupCollapsed("%c[CTC]%c debug enabled".concat(verbose ? ' (verbose)' : '', " \u2014 Contextual Typeahead Completion"), CTC_STYLES.brand, CTC_STYLES.body);
+  // eslint-disable-next-line no-console
+  console.log('%cPipeline%c  INPUT → SIGNALS → CANONICAL → GENERATE → SCORE → ARBITRATE → STABILIZE → CANDIDATES', CTC_STYLES.section, CTC_STYLES.body);
+  // eslint-disable-next-line no-console
+  console.log('%cEvidence%c  Tier A = exact-context first token · prefix = one more decoded token · exact = every token of the surface scored · absent = Stage 1', CTC_STYLES.section, CTC_STYLES.body);
+  // eslint-disable-next-line no-console
+  console.log('%cLM queue%c  one serialised GPU queue drains both: prompt prefills and single-token decode steps', CTC_STYLES.section, CTC_STYLES.body);
+  // eslint-disable-next-line no-console
+  console.log('%cPlanes%c    [CTC:init] loads · [CTC:signal] semantic/network · [CTC:model] primes/exact · [CTC:model-cost] prefill/decode · [CTC:readiness] deadline progress', CTC_STYLES.section, CTC_STYLES.body);
+  // eslint-disable-next-line no-console
+  console.log('%cInspect%c   __atlCtcDebug__.enable("verbose") · .disable() · .session() (L1 boosts, narrow to a family with .session("poll"))', CTC_STYLES.section, CTC_STYLES.body);
+  // eslint-disable-next-line no-console
+  console.groupEnd();
+};
 
 // State lives on the window object (not a module closure) so duplicate copies of this
 // module across separate bundles/realms share one source of truth and the console API
@@ -35,16 +103,27 @@ var getDebugApi = function getDebugApi() {
     return undefined;
   }
   if (!window.__atlCtcDebug__) {
-    var debugEnabled = hasUrlDebugFlag();
+    var initial = readUrlDebugFlag();
+    var debugEnabled = initial.enabled;
+    var debugVerbose = initial.verbose;
+    if (debugEnabled) {
+      printLegend(debugVerbose);
+    }
     window.__atlCtcDebug__ = {
-      enable: function enable() {
+      enable: function enable(level) {
         debugEnabled = true;
+        debugVerbose = level === 'verbose';
+        printLegend(debugVerbose);
       },
       disable: function disable() {
         debugEnabled = false;
+        debugVerbose = false;
       },
       isEnabled: function isEnabled() {
         return debugEnabled;
+      },
+      isVerbose: function isVerbose() {
+        return debugEnabled && debugVerbose;
       }
     };
   }
@@ -54,6 +133,25 @@ export var isAutocompleteDebugEnabled = function isAutocompleteDebugEnabled() {
   var _getDebugApi$isEnable, _getDebugApi;
   return (_getDebugApi$isEnable = (_getDebugApi = getDebugApi()) === null || _getDebugApi === void 0 ? void 0 : _getDebugApi.isEnabled()) !== null && _getDebugApi$isEnable !== void 0 ? _getDebugApi$isEnable : false;
 };
+export var isAutocompleteDebugVerbose = function isAutocompleteDebugVerbose() {
+  var _getDebugApi$isVerbos, _getDebugApi2;
+  return (_getDebugApi$isVerbos = (_getDebugApi2 = getDebugApi()) === null || _getDebugApi2 === void 0 ? void 0 : _getDebugApi2.isVerbose()) !== null && _getDebugApi$isVerbos !== void 0 ? _getDebugApi$isVerbos : false;
+};
+
+/**
+ * Hang the L1 session-boost snapshot off the console API.
+ *
+ * Unlike the log helpers this is available whether or not debug is enabled:
+ * inspecting state on demand is not logging, and asking someone to turn on
+ * logging and retype to find out what the session already holds defeats the
+ * point of being able to ask.
+ */
+export var registerCtcSessionInspector = function registerCtcSessionInspector(inspect) {
+  var api = getDebugApi();
+  if (api) {
+    api.session = inspect;
+  }
+};
 
 // Eagerly install so the console API is available on load, regardless of call order.
 getDebugApi();

package/dist/esm/pm-plugins/ghost-text-decoration.js

@@ -4,8 +4,11 @@ var GHOST_TEXT_CLASS = 'autocomplete-ghost-text';
 /**
  * Creates a DecorationSet containing a ghost text widget at the given position.
  * The ghost text is rendered as a styled <span> that appears after the cursor.
+ *
+ * Takes the document rather than the whole state so it can also be called from
+ * `apply`, where only the post-transaction doc exists.
  */
-export var createGhostTextDecorationSet = function createGhostTextDecorationSet(state, position, text) {
+export var createGhostTextDecorationSet = function createGhostTextDecorationSet(doc, position, text) {
   if (!text) {
     return DecorationSet.empty;
   }
@@ -30,7 +33,13 @@ export var createGhostTextDecorationSet = function createGhostTextDecorationSet(
   }, {
     side: 1,
     // Render after content at this position
-    key: 'autocomplete-ghost-text'
+    // A matching key short-circuits `WidgetType.eq`, so ProseMirror reuses
+    // the rendered node and never calls `toDOM` again. Keying on the text
+    // keeps that reuse when nothing changed while still forcing a redraw
+    // when the ghost advances through a keystroke that confirmed it —
+    // otherwise the stale tail stays on screen and Tab inserts a
+    // character the user already typed.
+    key: "autocomplete-ghost-text:".concat(text)
   });
-  return DecorationSet.create(state.doc, [decoration]);
+  return DecorationSet.create(doc, [decoration]);
 };