@lvce-editor/editor-worker 15.1.0 → 16.0.0

package/dist/editorWorkerMain.js

@@ -474,7 +474,7 @@ const getFirstEvent = (eventEmitter, eventMap) => {
   return promise;
 };
 const Message$1 = 3;
-const create$5$2 = async ({
+const create$5$1 = async ({
   isMessagePortOpen,
   messagePort
 }) => {
@@ -525,61 +525,19 @@ const wrap$5 = messagePort => {
 };
 const IpcParentWithMessagePort$1 = {
   __proto__: null,
-  create: create$5$2,
+  create: create$5$1,
   signal: signal$1,
   wrap: wrap$5
 };
 
-const Two = '2.0';
-const create$4$2 = (method, params) => {
-  return {
-    jsonrpc: Two,
-    method,
-    params
-  };
-};
+const Two$1 = '2.0';
 const callbacks = Object.create(null);
-const set$d = (id, fn) => {
-  callbacks[id] = fn;
-};
 const get$8 = id => {
   return callbacks[id];
 };
 const remove$9 = id => {
   delete callbacks[id];
 };
-let id = 0;
-const create$3$2 = () => {
-  return ++id;
-};
-const registerPromise = () => {
-  const id = create$3$2();
-  const {
-    resolve,
-    promise
-  } = Promise.withResolvers();
-  set$d(id, resolve);
-  return {
-    id,
-    promise
-  };
-};
-const create$2$1 = (method, params) => {
-  const {
-    id,
-    promise
-  } = registerPromise();
-  const message = {
-    jsonrpc: Two,
-    method,
-    params,
-    id
-  };
-  return {
-    message,
-    promise
-  };
-};
 class JsonRpcError extends Error {
   constructor(message) {
     super(message);
@@ -773,9 +731,9 @@ const getErrorProperty = (error, prettyError) => {
     }
   };
 };
-const create$1$1 = (id, error) => {
+const create$1$2 = (id, error) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id,
     error
   };
@@ -784,22 +742,22 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const prettyError = preparePrettyError(error);
   logError(error, prettyError);
   const errorProperty = getErrorProperty(error, prettyError);
-  return create$1$1(id, errorProperty);
+  return create$1$2(id, errorProperty);
 };
-const create$b = (message, result) => {
+const create$a = (message, result) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id: message.id,
     result: result ?? null
   };
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$b(message, resultProperty);
+  return create$a(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id,
     error: {
       code: Custom,
@@ -886,29 +844,6 @@ const handleJsonRpcMessage = async (...args) => {
   }
   throw new JsonRpcError('unexpected message');
 };
-const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
-  const {
-    message,
-    promise
-  } = create$2$1(method, params);
-  if (useSendAndTransfer && ipc.sendAndTransfer) {
-    ipc.sendAndTransfer(message);
-  } else {
-    ipc.send(message);
-  }
-  const responseMessage = await promise;
-  return unwrapJsonRpcResult(responseMessage);
-};
-const send$1 = (transport, method, ...params) => {
-  const message = create$4$2(method, params);
-  transport.send(message);
-};
-const invoke$e = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, false);
-};
-const invokeAndTransfer$3 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, true);
-};
 
 class CommandNotFoundError extends Error {
   constructor(command) {
@@ -931,24 +866,87 @@ const execute$1 = (command, ...args) => {
   return fn(...args);
 };
 
+const Two = '2.0';
+const create$s = (method, params) => {
+  return {
+    jsonrpc: Two,
+    method,
+    params
+  };
+};
+const create$r = (id, method, params) => {
+  const message = {
+    id,
+    jsonrpc: Two,
+    method,
+    params
+  };
+  return message;
+};
+let id = 0;
+const create$q = () => {
+  return ++id;
+};
+
+/* eslint-disable n/no-unsupported-features/es-syntax */
+
+const registerPromise = map => {
+  const id = create$q();
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  map[id] = resolve;
+  return {
+    id,
+    promise
+  };
+};
+
+// @ts-ignore
+const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
+  const {
+    id,
+    promise
+  } = registerPromise(callbacks);
+  const message = create$r(id, method, params);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
+  }
+  const responseMessage = await promise;
+  return unwrapJsonRpcResult(responseMessage);
+};
 const createRpc = ipc => {
+  const callbacks = Object.create(null);
+  ipc._resolve = (id, response) => {
+    const fn = callbacks[id];
+    if (!fn) {
+      console.warn(`callback ${id} may already be disposed`);
+      return;
+    }
+    fn(response);
+    delete callbacks[id];
+  };
   const rpc = {
+    async dispose() {
+      await ipc?.dispose();
+    },
+    invoke(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, false);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, true);
+    },
     // @ts-ignore
     ipc,
     /**
      * @deprecated
      */
     send(method, ...params) {
-      send$1(ipc, method, ...params);
-    },
-    invoke(method, ...params) {
-      return invoke$e(ipc, method, ...params);
-    },
-    invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer$3(ipc, method, ...params);
-    },
-    async dispose() {
-      await ipc?.dispose();
+      const message = create$s(method, params);
+      ipc.send(message);
     }
   };
   return rpc;
@@ -965,7 +963,7 @@ const logError$1 = () => {
 const handleMessage = event => {
   const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
   const actualExecute = event?.target?.execute || execute$1;
-  return handleJsonRpcMessage(event.target, event.data, actualExecute, resolve, preparePrettyError, logError$1, actualRequiresSocket);
+  return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError$1, actualRequiresSocket);
 };
 const handleIpc = ipc => {
   if ('addEventListener' in ipc) {
@@ -983,35 +981,63 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$e = async ({
+
+/* eslint-disable @typescript-eslint/no-misused-promises */
+
+const createSharedLazyRpc = factory => {
+  let rpcPromise;
+  const getOrCreate = () => {
+    if (!rpcPromise) {
+      rpcPromise = factory();
+    }
+    return rpcPromise;
+  };
+  return {
+    async dispose() {
+      const rpc = await getOrCreate();
+      await rpc.dispose();
+    },
+    async invoke(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invoke(method, ...params);
+    },
+    async invokeAndTransfer(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    async send(method, ...params) {
+      const rpc = await getOrCreate();
+      rpc.send(method, ...params);
+    }
+  };
+};
+const create$i = async ({
   commandMap,
-  messagePort,
-  isMessagePortOpen
+  isMessagePortOpen,
+  send
 }) => {
-  // TODO create a commandMap per rpc instance
-  register(commandMap);
-  const rawIpc = await IpcParentWithMessagePort$1.create({
-    messagePort,
-    isMessagePortOpen
+  return createSharedLazyRpc(() => {
+    return create$2$1({
+      commandMap,
+      isMessagePortOpen,
+      send
+    });
   });
-  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
-  handleIpc(ipc);
-  const rpc = createRpc(ipc);
-  return rpc;
 };
-const MessagePortRpcParent = {
+const LazyTransferMessagePortRpcParent = {
   __proto__: null,
-  create: create$e
+  create: create$i
 };
-const create$5$1 = async ({
+const create$4$1 = async ({
   commandMap,
+  isMessagePortOpen = true,
   messagePort
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
   const rawIpc = await IpcParentWithMessagePort$1.create({
-    messagePort,
-    isMessagePortOpen: true
+    isMessagePortOpen,
+    messagePort
   });
   const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
   handleIpc(ipc);
@@ -1019,21 +1045,22 @@ const create$5$1 = async ({
   messagePort.start();
   return rpc;
 };
-const create$4$1 = async ({
+const create$3$1 = async ({
   commandMap,
   messagePort
 }) => {
-  return create$5$1({
+  return create$4$1({
     commandMap,
     messagePort
   });
 };
 const PlainMessagePortRpcParent = {
   __proto__: null,
-  create: create$4$1
+  create: create$3$1
 };
-const create$3$1 = async ({
+const create$2$1 = async ({
   commandMap,
+  isMessagePortOpen,
   send
 }) => {
   const {
@@ -1041,16 +1068,17 @@ const create$3$1 = async ({
     port2
   } = new MessageChannel();
   await send(port1);
-  return create$5$1({
+  return create$4$1({
     commandMap,
+    isMessagePortOpen,
     messagePort: port2
   });
 };
 const TransferMessagePortRpcParent = {
   __proto__: null,
-  create: create$3$1
+  create: create$2$1
 };
-const create$a = async ({
+const create$1$1 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1062,7 +1090,7 @@ const create$a = async ({
 };
 const WebWorkerRpcClient = {
   __proto__: null,
-  create: create$a
+  create: create$1$1
 };
 const createMockRpc = ({
   commandMap
@@ -1077,9 +1105,9 @@ const createMockRpc = ({
     return command(...params);
   };
   const mockRpc = {
+    invocations,
     invoke,
-    invokeAndTransfer: invoke,
-    invocations
+    invokeAndTransfer: invoke
   };
   return mockRpc;
 };
@@ -1141,14 +1169,15 @@ const DebugWorker = 55;
 const EditorWorker = 99;
 const ExtensionHostWorker = 44;
 const ExtensionManagementWorker = 9006;
+const IconThemeWorker = 7009;
 const MarkdownWorker = 300;
-const RendererWorker = 1;
+const RendererWorker$1 = 1;
 const TextMeasurementWorker = 7011;
 
 const FocusEditorText$1 = 12;
 
 const rpcs = Object.create(null);
-const set$c = (id, rpc) => {
+const set$d = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get$7 = id => {
@@ -1158,6 +1187,7 @@ const remove$8 = id => {
   delete rpcs[id];
 };
 
+/* eslint-disable  @typescript-eslint/explicit-function-return-type */
 const create$9 = rpcId => {
   return {
     async dispose() {
@@ -1176,8 +1206,20 @@ const create$9 = rpcId => {
       // @ts-ignore
       return rpc.invokeAndTransfer(method, ...params);
     },
+    registerMockRpc(commandMap) {
+      const mockRpc = createMockRpc({
+        commandMap
+      });
+      set$d(rpcId, mockRpc);
+      // @ts-ignore
+      mockRpc[Symbol.dispose] = () => {
+        remove$8(rpcId);
+      };
+      // @ts-ignore
+      return mockRpc;
+    },
     set(rpc) {
-      set$c(rpcId, rpc);
+      set$d(rpcId, rpc);
     }
   };
 };
@@ -1186,7 +1228,8 @@ const {
   dispose: dispose$2,
   invoke: invoke$d,
   invokeAndTransfer: invokeAndTransfer$2,
-  set: set$b
+  registerMockRpc,
+  set: set$c
 } = create$9(ExtensionHostWorker);
 const executeReferenceProvider = async (id, offset) => {
   // @ts-ignore
@@ -1200,12 +1243,9 @@ const getRuntimeStatus = async extensionId => {
   // @ts-ignore
   return invoke$d('ExtensionHost.getRuntimeStatus', extensionId);
 };
-const registerMockRpc = commandMap => {
-  const mockRpc = createMockRpc({
-    commandMap
-  });
-  set$b(mockRpc);
-  return mockRpc;
+const getEnabledOutputProviderIds = async () => {
+  const channels = await invoke$d('Output.getEnabledProviders');
+  return channels;
 };
 
 const ExtensionHost = {
@@ -1213,23 +1253,24 @@ const ExtensionHost = {
   dispose: dispose$2,
   executeFileReferenceProvider,
   executeReferenceProvider,
+  getEnabledOutputProviderIds,
   getRuntimeStatus,
   invoke: invoke$d,
   invokeAndTransfer: invokeAndTransfer$2,
   registerMockRpc,
-  set: set$b
+  set: set$c
 };
 
 const {
   invoke: invoke$c,
-  set: set$a
+  set: set$b
 } = create$9(ExtensionManagementWorker);
 
 const {
   invoke: invoke$b,
   invokeAndTransfer: invokeAndTransfer$1,
-  set: set$9
-} = create$9(RendererWorker);
+  set: set$a
+} = create$9(RendererWorker$1);
 const showContextMenu2 = async (uid, menuId, x, y, args) => {
   number(uid);
   number(menuId);
@@ -1248,6 +1289,10 @@ const sendMessagePortToExtensionManagementWorker = async (port, rpcId) => {
   await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionManagementWorker', port, command, rpcId);
 };
 
+const {
+  set: set$9
+} = create$9(IconThemeWorker);
+
 const {
   dispose: dispose$1,
   invoke: invoke$a,
@@ -1268,7 +1313,7 @@ const createLazyRpc = rpcId => {
   let factory;
   const createRpc = async () => {
     const rpc = await factory();
-    set$c(rpcId, rpc);
+    set$d(rpcId, rpc);
   };
   const ensureRpc = async () => {
     if (!rpcPromise) {
@@ -1296,8 +1341,8 @@ const createLazyRpc = rpcId => {
 // TODO add tests for this
 const activateByEvent = async (event, assetDir, platform) => {
   string(event);
-  string(assetDir);
-  number(platform);
+  // Assert.string(assetDir)
+  // Assert.number(platform)
   await invoke$b('ExtensionHostManagement.activateByEvent', event, assetDir, platform);
 };
 
@@ -1306,39 +1351,22 @@ const codeGeneratorAccept = state => {
   return state;
 };
 
-const getPortTuple = () => {
-  const {
-    port1,
-    port2
-  } = new MessageChannel();
-  return {
-    port1,
-    port2
-  };
-};
-
 const ModuleWorkerAndWorkaroundForChromeDevtoolsBug = 6;
 
 const launchWorker = async (name, url, intializeCommand) => {
-  // TODO use transferMessagePortRpc
-  const {
-    port1,
-    port2
-  } = getPortTuple();
-  // @ts-ignore
-  await invokeAndTransfer$1('IpcParent.create', {
-    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
-    name: name,
-    port: port1,
-    raw: true,
-    url
-  });
-  const rpc = await MessagePortRpcParent.create({
+  const rpc = await TransferMessagePortRpcParent.create({
     commandMap: {},
     isMessagePortOpen: true,
-    messagePort: port2
+    async send(port) {
+      await invokeAndTransfer$1('IpcParent.create', {
+        method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
+        name,
+        port,
+        raw: true,
+        url
+      });
+    }
   });
-  port2.start();
   if (intializeCommand) {
     await rpc.invoke(intializeCommand);
   }
@@ -2142,8 +2170,29 @@ const getStartDefaults = (tokens, minOffset) => {
     startIndex
   };
 };
-const getLineInfoEmbeddedFull = (embeddedResults, tokenResults, line, normalize, tabSize, width, deltaX, averageCharWidth, minOffset, maxOffset) => {
+const getLineInfoEmbeddedFull = (embeddedResults, tokenResults, line, decorations, lineOffset, normalize, tabSize, width, deltaX, averageCharWidth, minOffset, maxOffset) => {
   const lineInfo = [];
+
+  // Build decoration map for this line (position -> decoration class)
+  const decorationMap = new Map();
+  for (let j = 0; j < decorations.length; j += 4) {
+    const decorationOffset = decorations[j];
+    const decorationLength = decorations[j + 1];
+    const decorationType = decorations[j + 2];
+    const relativeStart = decorationOffset - lineOffset;
+    const relativeEnd = relativeStart + decorationLength;
+
+    // Only include decorations that overlap with this line
+    if (relativeStart < line.length && relativeEnd > 0) {
+      const decorationClassName = getDecorationClassName(decorationType);
+      if (decorationClassName) {
+        decorationMap.set(Math.max(0, relativeStart), {
+          className: decorationClassName,
+          end: Math.min(line.length, relativeEnd)
+        });
+      }
+    }
+  }
   const embeddedResult = embeddedResults[tokenResults.embeddedResultIndex];
   const embeddedTokens = embeddedResult.result.tokens;
   const embeddedTokenMap = embeddedResult.TokenMap;
@@ -2157,12 +2206,66 @@ const getLineInfoEmbeddedFull = (embeddedResults, tokenResults, line, normalize,
   for (let i = startIndex; i < tokensLength; i += 2) {
     const tokenType = embeddedTokens[i];
     const tokenLength = embeddedTokens[i + 1];
-    end += tokenLength;
-    const className = `Token ${embeddedTokenMap[tokenType] || 'Unknown'}`;
-    const text = line.slice(start, end);
-    const normalizedText = normalizeText(text, normalize, tabSize);
-    lineInfo.push(normalizedText, className);
-    start = end;
+    const tokenEnd = start + tokenLength;
+
+    // Check if any decorations overlap with this token
+    let hasOverlap = false;
+    for (const [decorationStart, {
+      end: decorationEnd
+    }] of decorationMap) {
+      if (decorationStart < tokenEnd && decorationEnd > start) {
+        hasOverlap = true;
+        break;
+      }
+    }
+    if (hasOverlap) {
+      // Token has decoration overlap - split into parts
+      let currentPos = start;
+      while (currentPos < tokenEnd) {
+        // Find if current position is inside a decoration
+        let activeDecoration = null;
+        for (const [decorationStart, decoration] of decorationMap) {
+          if (decorationStart <= currentPos && decoration.end > currentPos) {
+            activeDecoration = decoration;
+            break;
+          }
+        }
+        if (activeDecoration) {
+          // Render decorated part
+          const partEnd = Math.min(tokenEnd, activeDecoration.end);
+          const text = line.slice(currentPos, partEnd);
+          const baseTokenClass = embeddedTokenMap[tokenType] || 'Unknown';
+          const className = `Token ${baseTokenClass} ${activeDecoration.className}`;
+          const normalizedText = normalizeText(text, normalize, tabSize);
+          lineInfo.push(normalizedText, className);
+          currentPos = partEnd;
+        } else {
+          // Find next decoration start or token end
+          let nextDecorationStart = tokenEnd;
+          for (const [decorationStart] of decorationMap) {
+            if (decorationStart > currentPos && decorationStart < tokenEnd) {
+              nextDecorationStart = Math.min(nextDecorationStart, decorationStart);
+            }
+          }
+
+          // Render non-decorated part
+          const partEnd = nextDecorationStart;
+          const text = line.slice(currentPos, partEnd);
+          const className = `Token ${embeddedTokenMap[tokenType] || 'Unknown'}`;
+          const normalizedText = normalizeText(text, normalize, tabSize);
+          lineInfo.push(normalizedText, className);
+          currentPos = partEnd;
+        }
+      }
+    } else {
+      // No decoration overlap - render token normally
+      const text = line.slice(start, tokenEnd);
+      const className = `Token ${embeddedTokenMap[tokenType] || 'Unknown'}`;
+      const normalizedText = normalizeText(text, normalize, tabSize);
+      lineInfo.push(normalizedText, className);
+    }
+    start = tokenEnd;
+    end = tokenEnd;
     if (end >= maxOffset) {
       break;
     }
@@ -2195,11 +2298,25 @@ const getDifference = (start, averageCharWidth, deltaX) => {
 };
 const getLineInfoDefault = (line, tokenResults, embeddedResults, decorations, TokenMap, lineOffset, normalize, tabSize, width, deltaX, averageCharWidth, minOffset, maxOffset) => {
   const lineInfo = [];
-  let decorationIndex = 0;
-  for (; decorationIndex < decorations.length; decorationIndex += 3) {
-    const decorationOffset = decorations[decorationIndex];
-    if (decorationOffset >= lineOffset) {
-      break;
+
+  // Build decoration map for this line (position -> decoration class)
+  const decorationMap = new Map();
+  for (let j = 0; j < decorations.length; j += 4) {
+    const decorationOffset = decorations[j];
+    const decorationLength = decorations[j + 1];
+    const decorationType = decorations[j + 2];
+    const relativeStart = decorationOffset - lineOffset;
+    const relativeEnd = relativeStart + decorationLength;
+
+    // Only include decorations that overlap with this line
+    if (relativeStart < line.length && relativeEnd > 0) {
+      const decorationClassName = getDecorationClassName(decorationType);
+      if (decorationClassName) {
+        decorationMap.set(Math.max(0, relativeStart), {
+          className: decorationClassName,
+          end: Math.min(line.length, relativeEnd)
+        });
+      }
     }
   }
   const {
@@ -2215,27 +2332,66 @@ const getLineInfoDefault = (line, tokenResults, embeddedResults, decorations, To
   for (let i = startIndex; i < tokensLength; i += 2) {
     const tokenType = tokens[i];
     const tokenLength = tokens[i + 1];
-    const decorationOffset = decorations[decorationIndex];
-    let extraClassName = '';
-    if (decorationOffset !== undefined && decorationOffset - lineOffset === start) {
-      // @ts-ignore
-      decorations[++decorationIndex];
-      const decorationType = decorations[++decorationIndex];
-      // @ts-ignore
-      decorations[++decorationIndex];
-      //   decorationIndex,
-      //   decorationLength,
-      //   decorationType,
-      //   decorationModifiers,
-      // })
-      extraClassName = getDecorationClassName(decorationType);
+    const tokenEnd = start + tokenLength;
+
+    // Check if any decorations overlap with this token
+    let hasOverlap = false;
+    for (const [decorationStart, {
+      end: decorationEnd
+    }] of decorationMap) {
+      if (decorationStart < tokenEnd && decorationEnd > start) {
+        hasOverlap = true;
+        break;
+      }
     }
-    end += tokenLength;
-    const text = line.slice(start, end);
-    const className = `Token ${extraClassName || TokenMap[tokenType] || 'Unknown'}`;
-    const normalizedText = normalizeText(text, normalize, tabSize);
-    lineInfo.push(normalizedText, className);
-    start = end;
+    if (hasOverlap) {
+      // Token has decoration overlap - split into parts
+      let currentPos = start;
+      while (currentPos < tokenEnd) {
+        // Find if current position is inside a decoration
+        let activeDecoration = null;
+        for (const [decorationStart, decoration] of decorationMap) {
+          if (decorationStart <= currentPos && decoration.end > currentPos) {
+            activeDecoration = decoration;
+            break;
+          }
+        }
+        if (activeDecoration) {
+          // Render decorated part
+          const partEnd = Math.min(tokenEnd, activeDecoration.end);
+          const text = line.slice(currentPos, partEnd);
+          const baseTokenClass = TokenMap[tokenType] || 'Unknown';
+          const className = `Token ${baseTokenClass} ${activeDecoration.className}`;
+          const normalizedText = normalizeText(text, normalize, tabSize);
+          lineInfo.push(normalizedText, className);
+          currentPos = partEnd;
+        } else {
+          // Find next decoration start or token end
+          let nextDecorationStart = tokenEnd;
+          for (const [decorationStart] of decorationMap) {
+            if (decorationStart > currentPos && decorationStart < tokenEnd) {
+              nextDecorationStart = Math.min(nextDecorationStart, decorationStart);
+            }
+          }
+
+          // Render non-decorated part
+          const partEnd = nextDecorationStart;
+          const text = line.slice(currentPos, partEnd);
+          const className = `Token ${TokenMap[tokenType] || 'Unknown'}`;
+          const normalizedText = normalizeText(text, normalize, tabSize);
+          lineInfo.push(normalizedText, className);
+          currentPos = partEnd;
+        }
+      }
+    } else {
+      // No decoration overlap - render token normally
+      const text = line.slice(start, tokenEnd);
+      const className = `Token ${TokenMap[tokenType] || 'Unknown'}`;
+      const normalizedText = normalizeText(text, normalize, tabSize);
+      lineInfo.push(normalizedText, className);
+    }
+    start = tokenEnd;
+    end = tokenEnd;
     if (end >= maxOffset) {
       break;
     }
@@ -2253,7 +2409,7 @@ const getLineInfo$1 = (line, tokenResults, embeddedResults, decorations, TokenMa
   if (embeddedResults.length > 0 && tokenResults.embeddedResultIndex !== undefined) {
     const embeddedResult = embeddedResults[tokenResults.embeddedResultIndex];
     if (embeddedResult?.isFull) {
-      return getLineInfoEmbeddedFull(embeddedResults, tokenResults, line, normalize, tabSize, width, deltaX, averageCharWidth, minOffset, maxOffset);
+      return getLineInfoEmbeddedFull(embeddedResults, tokenResults, line, decorations, lineOffset, normalize, tabSize, width, deltaX, averageCharWidth, minOffset, maxOffset);
     }
   }
   return getLineInfoDefault(line, tokenResults, embeddedResults, decorations, TokenMap, lineOffset, normalize, tabSize, width, deltaX, averageCharWidth, minOffset, maxOffset);
@@ -2274,10 +2430,25 @@ const getLineInfosViewport = (editor, tokens, embeddedResults, minLineY, maxLine
   for (let i = minLineY; i < maxLineY; i++) {
     const line = lines[i];
     const normalize = shouldNormalizeText(line);
+
+    // Use decorations that were pre-computed (includes links and diagnostics)
+    // Filter decorations to only include those for this line
+    const lineDecorations = [];
+    for (let j = 0; j < decorations.length; j += 4) {
+      const decorationOffset = decorations[j];
+      const decorationLength = decorations[j + 1];
+      const decorationType = decorations[j + 2];
+      const decorationModifiers = decorations[j + 3];
+
+      // Include decoration if it starts within this line
+      if (decorationOffset >= offset && decorationOffset < offset + line.length) {
+        lineDecorations.push(decorationOffset, decorationLength, decorationType, decorationModifiers);
+      }
+    }
     const {
       difference,
       lineInfo
-    } = getLineInfo$1(line, tokens[i - minLineY], embeddedResults, decorations, tokenMap, offset, normalize, tabSize, width, deltaX, averageCharWidth);
+    } = getLineInfo$1(line, tokens[i - minLineY], embeddedResults, lineDecorations, tokenMap, offset, normalize, tabSize, width, deltaX, averageCharWidth);
     result.push(lineInfo);
     differences.push(difference);
     offset += line.length + 1;
@@ -2308,7 +2479,7 @@ const getVisible$1 = async (editor, syncIncremental) => {
     tokenizersToLoad,
     tokens
   } = await getTokensViewport2(editor, minLineY, maxLineY, syncIncremental);
-  const minLineOffset = offsetAtSync(editor, minLineY, 0);
+  const minLineOffset = await offsetAtSync(editor, minLineY, 0);
   const averageCharWidth = charWidth;
   const {
     differences,
@@ -3137,6 +3308,71 @@ const getLanguages = async (platform, assetDir) => {
   return languages;
 };
 
+/**
+ * Gets all regex matches for a given text and regex pattern
+ * @param text The text to match against
+ * @param regex The regex pattern to use (should have global flag)
+ * @returns Array of regex matches
+ */
+const getRegexMatches = (text, regex) => {
+  return [...text.matchAll(regex)];
+};
+
+// URL matching regex pattern - matches common URL schemes
+// Supports: http://, https://, ftp://, ftps://, file://
+// Also matches URLs without explicit scheme (www.example.com)
+const URL_PATTERN = /(?:(?:https?|ftp|ftps|file):\/\/)?(?:www\.)?(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?\.)+[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?(?:\/[^\s]*)?/g;
+
+// Regex to check if URL has a scheme (http://, https://, ftp://, etc.)
+const HAS_SCHEME_PATTERN = /^(?:https?|ftp|ftps|file):\/\//;
+
+// Regex to check if URL starts with www.
+const HAS_WWW_PATTERN = /^www\./;
+
+/**
+ * Detects links in a given text and returns their positions
+ * @param text The text to scan for links
+ * @returns Array of links with their start position and length
+ */
+const detectLinks = text => {
+  const matches = getRegexMatches(text, URL_PATTERN);
+  const links = [];
+  for (const match of matches) {
+    const url = match[0];
+    // Only consider as link if it has a scheme or starts with www.
+    if (HAS_SCHEME_PATTERN.test(url) || HAS_WWW_PATTERN.test(url)) {
+      links.push({
+        length: url.length,
+        start: match.index ?? 0
+      });
+    }
+  }
+  return links;
+};
+
+/**
+ * Detects all links in an editor and returns them as decorations
+ * @param editor The editor containing lines to scan
+ * @returns Flat array of decorations in format [offset, length, type, modifiers, ...]
+ */
+const detectAllLinksAsDecorations = editor => {
+  const decorations = [];
+  const {
+    lines
+  } = editor;
+  let offset = 0;
+  for (const line of lines) {
+    const links = detectLinks(line);
+    for (const link of links) {
+      const linkOffset = offset + link.start;
+      // Add link decoration: offset, length, type, modifiers
+      decorations.push(linkOffset, link.length, Link, 0);
+    }
+    offset += line.length + 1; // +1 for newline
+  }
+  return decorations;
+};
+
 const measureCharacterWidth = async (fontWeight, fontSize, fontFamily, letterSpacing) => {
   return await measureTextWidth('a', fontWeight, fontSize, fontFamily, letterSpacing, false, 0);
 };
@@ -3243,11 +3479,15 @@ const updateDiagnostics = async newState => {
     if (!latest) {
       return newState;
     }
-    const decorations = await getVisibleDiagnostics(latest.newState, diagnostics);
+    const visualDecorations = await getVisibleDiagnostics(latest.newState, diagnostics);
+    // Re-detect link decorations after text changes
+    const linkDecorations = detectAllLinksAsDecorations(latest.newState);
     const newEditor = {
       ...latest.newState,
-      decorations,
-      diagnostics
+      decorations: linkDecorations,
+      // Text-level decorations (flat array) for CSS classes
+      diagnostics,
+      visualDecorations // Visual decorations (objects with x, y, width, height) for squiggly underlines
     };
     set$6(newState.id, latest.oldState, newEditor);
     // @ts-ignore
@@ -3376,18 +3616,28 @@ const createEditor = async ({
   } else {
     newEditor3 = await setDeltaY$2(newEditor2, 0);
   }
+
+  // Detect links and initialize decorations
+  const linkDecorations = detectAllLinksAsDecorations(newEditor3);
+  const newEditor3WithLinks = {
+    ...newEditor3,
+    decorations: linkDecorations
+  };
   const syncIncremental = getEnabled();
   const {
     differences,
     textInfos
-  } = await getVisible$1(newEditor3, syncIncremental);
+  } = await getVisible$1(newEditor3WithLinks, syncIncremental);
   const newEditor4 = {
-    ...newEditor3,
+    ...newEditor3WithLinks,
     differences,
     focus: FocusEditorText$1,
     focused: true,
     textInfos
   };
+  console.error({
+    newEditor4
+  });
   set$6(id, emptyEditor, newEditor4);
 
   // TODO only sync when needed
@@ -5280,7 +5530,7 @@ const handleContextMenu = async (editor, button, x, y) => {
   const {
     uid
   } = editor;
-  await showContextMenu2(uid, Editor, /* x */x, /* y */y, {
+  await showContextMenu2(uid, Editor, x, y, {
     menuId: Editor
   });
   return editor;
@@ -6301,7 +6551,7 @@ const launch = async () => {
     return;
   }
   const rpc = await launchFindWidgetWorker();
-  set$c(rpcId, rpc);
+  set$d(rpcId, rpc);
 };
 const invoke$3 = async (method, ...params) => {
   const rpc = get$7(rpcId);
@@ -8591,6 +8841,9 @@ const getLineInfos = (lines, tokenizer, languageId) => {
     lineInfos.push(lineInfo);
     currentLineState = result;
   }
+  console.error({
+    lineInfos
+  });
   return lineInfos;
 };
 
@@ -9796,7 +10049,7 @@ const handleMessagePort = async (port, rpcId) => {
     messagePort: port
   });
   if (rpcId) {
-    set$c(rpcId, rpc);
+    set$d(rpcId, rpc);
   }
 };
 
@@ -9945,7 +10198,7 @@ const createExtensionManagementWorkerRpc = async () => {
 const initializeExtensionManagementWorker = async () => {
   try {
     const rpc = await createExtensionManagementWorkerRpc();
-    set$a(rpc);
+    set$b(rpc);
   } catch {
     // ignore
   }
@@ -9986,6 +10239,22 @@ const initializeSyntaxHighlighting = async (syntaxHighlightingEnabled, syncIncre
   }
 };
 
+const send$1 = port => {
+  // @ts-ignore
+  return RendererWorker.sendMessagePortToTextMeasurementWorker(port);
+};
+const initializeTextMeasurementWorker = async () => {
+  try {
+    const rpc = await LazyTransferMessagePortRpcParent.create({
+      commandMap: {},
+      send: send$1
+    });
+    set$9(rpc);
+  } catch {
+    // ignore
+  }
+};
+
 const launchCompletionWorker = async () => {
   const name = 'Completion Worker';
   const url = 'completionWorkerMain.js';
@@ -9996,7 +10265,7 @@ const launchCompletionWorker = async () => {
 
 const intialize = async (syntaxHighlightingEnabled, syncIncremental) => {
   setFactory(launchCompletionWorker);
-  await Promise.all([initializeSyntaxHighlighting(syntaxHighlightingEnabled, syncIncremental), initializeExtensionHost(), initializeExtensionManagementWorker()]);
+  await Promise.all([initializeSyntaxHighlighting(syntaxHighlightingEnabled, syncIncremental), initializeExtensionHost(), initializeExtensionManagementWorker(), initializeTextMeasurementWorker()]);
 };
 
 // TODO move cursor
@@ -10210,6 +10479,9 @@ const renderLines = {
     } = newState;
     const relativeLine = highlightedLine - minLineY;
     const dom = getEditorRowsVirtualDom(textInfos, differences, true, relativeLine);
+    console.error({
+      dom
+    });
     return [/* method */'setText', dom];
   },
   isEqual(oldState, newState) {
@@ -10280,11 +10552,11 @@ const renderAdditionalFocusContext = {
 };
 const renderDecorations = {
   apply(oldState, newState) {
-    const dom = getDiagnosticsVirtualDom(newState.decorations);
+    const dom = getDiagnosticsVirtualDom(newState.visualDecorations || []);
     return ['setDecorationsDom', dom];
   },
   isEqual(oldState, newState) {
-    return oldState.decorations === newState.decorations;
+    return oldState.visualDecorations === newState.visualDecorations;
   }
 };
 const renderGutterInfo = {
@@ -10465,7 +10737,7 @@ const updateDebugInfo = async debugId => {
   await invoke$b('Editor.rerender', key);
 };
 
-const keep = ['ActivateByEvent.activateByEvent', 'ExtensionHostManagement.activateByEvent', 'Editor.applyEdit2', 'Editor.applyEdits2', 'Editor.closeFind2', 'Editor.closeWidget2', 'Editor.create', 'Editor.getKeyBindings', 'Editor.getSourceActions', 'Editor.getLines2', 'Editor.getPositionAtCursor', 'Editor.getOffsetAtCursor', 'Editor.getQuickPickMenuEntries', 'Editor.getSelections', 'Editor.hotReload', 'Editor.getSelections2', 'Editor.getDiagnostics', 'Editor.getText', 'Editor.getWordAt', 'Editor.getWordAt2', 'Editor.getWordAtOffset2', 'Editor.getUri', 'Editor.getWordBefore', 'Editor.getWordBefore2', 'Editor.offsetAt', 'Editor.render', 'Editor.setSelections2', 'Editor.updateDebugInfo', 'Editor.getLanguageId', 'Editor.getProblems', 'Editor.getKeys', 'Editor.getMenuIds', 'Font.ensure', 'HandleMessagePort.handleMessagePort', 'Hover.getHoverInfo', 'Hover.handleSashPointerDown', 'Hover.handleSashPointerMove', 'Hover.handleSashPointerUp', 'Hover.loadContent', 'Hover.render', 'Initialize.initialize', 'SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker'
+const keep = ['ActivateByEvent.activateByEvent', 'ExtensionHostManagement.activateByEvent', 'Editor.applyEdit2', 'Editor.applyEdits2', 'Editor.closeFind2', 'Editor.closeWidget2', 'Editor.create', 'Editor.getKeyBindings', 'Editor.getSourceActions', 'Editor.getLines2', 'Editor.getPositionAtCursor', 'Editor.getOffsetAtCursor', 'Editor.getQuickPickMenuEntries', 'Editor.getSelections', 'Editor.hotReload', 'Editor.getSelections2', 'Editor.getDiagnostics', 'Editor.getText', 'Editor.getWordAt', 'Editor.getWordAt2', 'Editor.getWordAtOffset2', 'Editor.getUri', 'Editor.getWordBefore', 'Editor.getWordBefore2', 'Editor.offsetAt', 'Editor.render', 'Editor.setSelections2', 'Editor.updateDebugInfo', 'Editor.getLanguageId', 'Editor.getProblems', 'Editor.getKeys', 'Editor.getMenuIds', 'Editor.getMenuEntries', 'Editor.getMenuEntries2', 'Font.ensure', 'HandleMessagePort.handleMessagePort', 'Hover.getHoverInfo', 'Hover.handleSashPointerDown', 'Hover.handleSashPointerMove', 'Hover.handleSashPointerUp', 'Hover.loadContent', 'Hover.render', 'Initialize.initialize', 'SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker'
 // 'ColorPicker.handleSliderPointerDown',
 // 'ColorPicker.handleSliderPointerMove',
 // 'ColorPicker.loadContent',
@@ -10787,7 +11059,7 @@ const listen = async () => {
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMap
   });
-  set$9(rpc);
+  set$a(rpc);
 };
 
 const CodeGeneratorInput = 'CodeGeneratorInput';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/editor-worker",
-  "version": "15.1.0",
+  "version": "16.0.0",
   "repository": {
     "type": "git",
     "url": "git@github.com:lvce-editor/editor-worker.git"