diff --git a/src/commands/commands.ts b/src/commands/commands.ts
index b58e2bff..ed9dae38 100644
--- a/src/commands/commands.ts
+++ b/src/commands/commands.ts
@@ -7,13 +7,13 @@ import openReferenceBeside from './openReferenceBeside';
 import openDailyNote from './openDailyNote';
 import pasteHtmlAsMarkdown from './pasteHtmlAsMarkdown';
 import extractRangeToNewNote from './extractRangeToNewNote';
-import { cacheWorkspace, cleanWorkspaceCache, getWorkspaceCache } from '../utils';
+import { cache } from '../workspace';
 
 const commands = [
   vscode.commands.registerCommand('_memo.openDocumentByReference', openDocumentByReference),
-  vscode.commands.registerCommand('_memo.cacheWorkspace', cacheWorkspace),
-  vscode.commands.registerCommand('_memo.cleanWorkspaceCache', cleanWorkspaceCache),
-  vscode.commands.registerCommand('_memo.getWorkspaceCache', getWorkspaceCache),
+  vscode.commands.registerCommand('_memo.cacheWorkspace', cache.cacheWorkspace),
+  vscode.commands.registerCommand('_memo.cleanWorkspaceCache', cache.cleanWorkspaceCache),
+  vscode.commands.registerCommand('_memo.getWorkspaceCache', cache.getWorkspaceCache),
   vscode.commands.registerCommand('memo.openRandomNote', openRandomNote),
   vscode.commands.registerCommand('memo.openDailyNote', openDailyNote),
   vscode.commands.registerCommand('memo.openReferenceInDefaultApp', openReferenceInDefaultApp),
diff --git a/src/commands/openDocumentByReference.ts b/src/commands/openDocumentByReference.ts
index 1d5de863..52634444 100644
--- a/src/commands/openDocumentByReference.ts
+++ b/src/commands/openDocumentByReference.ts
@@ -2,8 +2,8 @@ import vscode from 'vscode';
 import fs from 'fs';
 import path from 'path';
 
+import { cache } from '../workspace';
 import {
-  getWorkspaceCache,
   findUriByRef,
   ensureDirectoryExists,
   parseRef,
@@ -21,7 +21,7 @@ const openDocumentByReference = async ({
 }) => {
   const { ref } = parseRef(reference);
 
-  const uri = findUriByRef(getWorkspaceCache().allUris, ref);
+  const uri = findUriByRef(cache.getWorkspaceCache().allUris, ref);
 
   if (uri) {
     await vscode.commands.executeCommand('vscode.open', uri, showOption);
diff --git a/src/commands/openRandomNote.ts b/src/commands/openRandomNote.ts
index 28bfc611..f19ca08a 100644
--- a/src/commands/openRandomNote.ts
+++ b/src/commands/openRandomNote.ts
@@ -1,13 +1,13 @@
 import { commands, workspace } from 'vscode';
 import fs from 'fs';
 
-import { getWorkspaceCache } from '../utils';
+import { cache } from '../workspace';
 
 const openRandomNote = async () => {
   const openedFileNames = workspace.textDocuments.map((d) => d.fileName);
-  const markdownUris = getWorkspaceCache().markdownUris.filter(
-    ({ fsPath }) => !openedFileNames.includes(fsPath),
-  );
+  const markdownUris = cache
+    .getWorkspaceCache()
+    .markdownUris.filter(({ fsPath }) => !openedFileNames.includes(fsPath));
   const randomUriIndex = Math.floor(Math.random() * markdownUris.length);
   const randomUri = markdownUris[randomUriIndex];
 
diff --git a/src/commands/openReferenceInDefaultApp.ts b/src/commands/openReferenceInDefaultApp.ts
index ddf8ab46..fa0e2f18 100644
--- a/src/commands/openReferenceInDefaultApp.ts
+++ b/src/commands/openReferenceInDefaultApp.ts
@@ -1,7 +1,8 @@
 import open from 'open';
 import * as vscode from 'vscode';
 
-import { getWorkspaceCache, getReferenceAtPosition, findUriByRef } from '../utils';
+import { cache } from '../workspace';
+import { getReferenceAtPosition, findUriByRef } from '../utils';
 
 const openReferenceInDefaultApp = async () => {
   const activeTextEditor = vscode.window.activeTextEditor;
@@ -13,7 +14,7 @@ const openReferenceInDefaultApp = async () => {
     );
 
     if (refAtPos) {
-      const uri = findUriByRef(getWorkspaceCache().allUris, refAtPos.ref);
+      const uri = findUriByRef(cache.getWorkspaceCache().allUris, refAtPos.ref);
 
       if (uri) {
         await open(uri.fsPath);
diff --git a/src/extension.ts b/src/extension.ts
index 6d141e56..ca5341f6 100644
--- a/src/extension.ts
+++ b/src/extension.ts
@@ -1,6 +1,6 @@
 import * as vscode from 'vscode';
 
-import { fileWatcher } from './workspace';
+import { fileWatcher, cache } from './workspace';
 import {
   syntaxDecorations,
   referenceContextWatcher,
@@ -16,7 +16,7 @@ import {
 } from './features';
 import commands from './commands';
 import logger from './logger';
-import { cacheWorkspace, getMemoConfigProperty, MemoBoolConfigProp, isDefined } from './utils';
+import { getMemoConfigProperty, MemoBoolConfigProp, isDefined } from './utils';
 
 const mdLangSelector = { language: 'markdown', scheme: '*' };
 
@@ -38,7 +38,7 @@ export const activate = async (
 
   referenceContextWatcher.activate(context);
 
-  await cacheWorkspace();
+  await cache.cacheWorkspace();
 
   context.subscriptions.push(logger.logger);
 
@@ -47,7 +47,7 @@ export const activate = async (
     vscode.languages.registerCodeActionsProvider(mdLangSelector, codeActionProvider),
     vscode.workspace.onDidChangeConfiguration(async (configChangeEvent) => {
       if (configChangeEvent.affectsConfiguration('search.exclude')) {
-        await cacheWorkspace();
+        await cache.cacheWorkspace();
       }
     }),
     ...[
diff --git a/src/features/BacklinksTreeDataProvider.ts b/src/features/BacklinksTreeDataProvider.ts
index bad34d2a..451ae52c 100644
--- a/src/features/BacklinksTreeDataProvider.ts
+++ b/src/features/BacklinksTreeDataProvider.ts
@@ -2,8 +2,8 @@ import vscode, { workspace } from 'vscode';
 import path from 'path';
 import groupBy from 'lodash.groupby';
 
+import { cache } from '../workspace';
 import {
-  getWorkspaceCache,
   containsMarkdownExt,
   findReferences,
   trimSlashes,
@@ -69,7 +69,7 @@ export default class BacklinksTreeDataProvider implements vscode.TreeDataProvide
         return [];
       }
 
-      const urisByPathBasename = groupBy(getWorkspaceCache().markdownUris, ({ fsPath }) =>
+      const urisByPathBasename = groupBy(cache.getWorkspaceCache().markdownUris, ({ fsPath }) =>
         path.basename(fsPath).toLowerCase(),
       );
 
diff --git a/src/features/ReferenceHoverProvider.ts b/src/features/ReferenceHoverProvider.ts
index 5490c863..949f06ed 100644
--- a/src/features/ReferenceHoverProvider.ts
+++ b/src/features/ReferenceHoverProvider.ts
@@ -2,11 +2,11 @@ import vscode from 'vscode';
 import fs from 'fs';
 import path from 'path';
 
+import { cache } from '../workspace';
 import {
   containsImageExt,
   containsUnknownExt,
   containsOtherKnownExts,
-  getWorkspaceCache,
   getMemoConfigProperty,
   getReferenceAtPosition,
   isUncPath,
@@ -25,7 +25,7 @@ export default class ReferenceHoverProvider implements vscode.HoverProvider {
         new vscode.Position(range.end.line, range.end.character - 2),
       );
 
-      const uris = getWorkspaceCache().allUris;
+      const uris = cache.getWorkspaceCache().allUris;
       const foundUri = findUriByRef(uris, ref);
 
       if (!foundUri && containsUnknownExt(ref)) {
diff --git a/src/features/ReferenceRenameProvider.ts b/src/features/ReferenceRenameProvider.ts
index 6a4f73b1..d251ae98 100644
--- a/src/features/ReferenceRenameProvider.ts
+++ b/src/features/ReferenceRenameProvider.ts
@@ -1,10 +1,10 @@
 import { RenameProvider, TextDocument, Position, Range, WorkspaceEdit, Uri } from 'vscode';
 import path from 'path';
 
+import { cache } from '../workspace';
 import {
   getReferenceAtPosition,
   findUriByRef,
-  getWorkspaceCache,
   isLongRef,
   getWorkspaceFolder,
   containsMarkdownExt,
@@ -33,11 +33,11 @@ export default class ReferenceRenameProvider implements RenameProvider {
       const unknownUris = containsUnknownExt(ref) ? await findFilesByExts([extractExt(ref)]) : [];
 
       const augmentedUris = unknownUris.length
-        ? sortPaths([...getWorkspaceCache().allUris, ...unknownUris], {
+        ? sortPaths([...cache.getWorkspaceCache().allUris, ...unknownUris], {
             pathKey: 'path',
             shallowFirst: true,
           })
-        : getWorkspaceCache().allUris;
+        : cache.getWorkspaceCache().allUris;
 
       if (!findUriByRef(augmentedUris, ref)) {
         throw new Error(
@@ -69,11 +69,11 @@ export default class ReferenceRenameProvider implements RenameProvider {
       const unknownUris = containsUnknownExt(ref) ? await findFilesByExts([extractExt(ref)]) : [];
 
       const augmentedUris = unknownUris.length
-        ? sortPaths([...getWorkspaceCache().allUris, ...unknownUris], {
+        ? sortPaths([...cache.getWorkspaceCache().allUris, ...unknownUris], {
             pathKey: 'path',
             shallowFirst: true,
           })
-        : getWorkspaceCache().allUris;
+        : cache.getWorkspaceCache().allUris;
 
       const fsPath = findUriByRef(augmentedUris, ref)?.fsPath;
 
diff --git a/src/features/completionProvider.ts b/src/features/completionProvider.ts
index efc2b0ed..bd93df1d 100644
--- a/src/features/completionProvider.ts
+++ b/src/features/completionProvider.ts
@@ -14,8 +14,8 @@ import path from 'path';
 import groupBy from 'lodash.groupby';
 import fs from 'fs';
 
+import { cache } from '../workspace';
 import {
-  getWorkspaceCache,
   fsPathToRef,
   containsMarkdownExt,
   containsImageExt,
@@ -46,13 +46,13 @@ export const provideCompletionItems = (document: TextDocument, position: Positio
 
   const uris: Uri[] = [
     ...(isResourceAutocomplete
-      ? [...getWorkspaceCache().imageUris, ...getWorkspaceCache().markdownUris]
+      ? [...cache.getWorkspaceCache().imageUris, ...cache.getWorkspaceCache().markdownUris]
       : []),
     ...(!isResourceAutocomplete
       ? [
-          ...getWorkspaceCache().markdownUris,
-          ...getWorkspaceCache().imageUris,
-          ...getWorkspaceCache().otherUris,
+          ...cache.getWorkspaceCache().markdownUris,
+          ...cache.getWorkspaceCache().imageUris,
+          ...cache.getWorkspaceCache().otherUris,
         ]
       : []),
   ];
@@ -100,7 +100,7 @@ export const provideCompletionItems = (document: TextDocument, position: Positio
     completionItems.push(item);
   });
 
-  const danglingRefs = getWorkspaceCache().danglingRefs;
+  const danglingRefs = cache.getWorkspaceCache().danglingRefs;
 
   const completionItemsLength = completionItems.length;
 
diff --git a/src/features/extendMarkdownIt.ts b/src/features/extendMarkdownIt.ts
index a433f493..49b1e17a 100644
--- a/src/features/extendMarkdownIt.ts
+++ b/src/features/extendMarkdownIt.ts
@@ -3,8 +3,8 @@ import markdownItRegex from 'markdown-it-regex';
 import path from 'path';
 import fs from 'fs';
 
+import { cache } from '../workspace';
 import {
-  getWorkspaceCache,
   getImgUrlForMarkdownPreview,
   getFileUrlForMarkdownPreview,
   containsImageExt,
@@ -37,7 +37,7 @@ const extendMarkdownIt = (md: MarkdownIt) => {
         const { ref, label } = parseRef(rawRef);
 
         if (containsImageExt(ref)) {
-          const imagePath = findUriByRef(getWorkspaceCache().imageUris, ref)?.fsPath;
+          const imagePath = findUriByRef(cache.getWorkspaceCache().imageUris, ref)?.fsPath;
 
           if (imagePath) {
             return `<div><img src="${getImgUrlForMarkdownPreview(
@@ -48,7 +48,7 @@ const extendMarkdownIt = (md: MarkdownIt) => {
           }
         }
 
-        const fsPath = findUriByRef(getWorkspaceCache().markdownUris, ref)?.fsPath;
+        const fsPath = findUriByRef(cache.getWorkspaceCache().markdownUris, ref)?.fsPath;
 
         if (!fsPath && containsUnknownExt(ref)) {
           return getUnknownExtRefAnchor(label || ref, ref);
@@ -100,7 +100,7 @@ const extendMarkdownIt = (md: MarkdownIt) => {
       replace: (rawRef: string) => {
         const { ref, label } = parseRef(rawRef);
 
-        const fsPath = findUriByRef(getWorkspaceCache().allUris, ref)?.fsPath;
+        const fsPath = findUriByRef(cache.getWorkspaceCache().allUris, ref)?.fsPath;
 
         if (!fsPath && containsUnknownExt(ref)) {
           return getUnknownExtRefAnchor(label || ref, ref);
diff --git a/src/test/testUtils.ts b/src/test/testUtils.ts
index 3f6b4c45..56a6a981 100644
--- a/src/test/testUtils.ts
+++ b/src/test/testUtils.ts
@@ -4,6 +4,7 @@ import path from 'path';
 import { workspace, Uri, commands, ConfigurationTarget } from 'vscode';
 export { default as waitForExpect } from 'wait-for-expect';
 
+import { cache } from '../workspace';
 import * as utils from '../utils';
 import { WorkspaceCache } from '../types';
 
@@ -35,12 +36,12 @@ export const cleanWorkspace = () => {
 };
 
 export const cacheWorkspace = async () => {
-  await utils.cacheWorkspace();
+  await cache.cacheWorkspace();
   await commands.executeCommand('_memo.cacheWorkspace');
 };
 
 export const cleanWorkspaceCache = async () => {
-  utils.cleanWorkspaceCache();
+  cache.cleanWorkspaceCache();
   await commands.executeCommand('_memo.cleanWorkspaceCache');
 };
 
diff --git a/src/utils/createDailyQuickPick.ts b/src/utils/createDailyQuickPick.ts
index adf9d544..9b8c3178 100644
--- a/src/utils/createDailyQuickPick.ts
+++ b/src/utils/createDailyQuickPick.ts
@@ -3,7 +3,8 @@ import range from 'lodash.range';
 import path from 'path';
 import { window } from 'vscode';
 
-import { findUriByRef, getWorkspaceCache } from './utils';
+import { findUriByRef } from './utils';
+import { cache } from '../workspace';
 
 const toOffsetLabel = (dayOffset: number) => {
   if (dayOffset === -1) {
@@ -21,7 +22,8 @@ const yyyymmddRegExp = /([12]\d{3}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01]))/;
 
 const createDailyQuickPick = () => {
   const now = moment().startOf('day');
-  const allDailyDates = getWorkspaceCache()
+  const allDailyDates = cache
+    .getWorkspaceCache()
     .markdownUris.map((uri) => path.parse(uri.fsPath).name)
     .filter((name) => yyyymmddRegExp.exec(name) && moment(name).isValid());
   const existingDayOffsets = allDailyDates.map((dateStr) =>
@@ -51,7 +53,7 @@ const createDailyQuickPick = () => {
   quickPick.items = dayOffsets.map((dayOffset) => {
     const date = now.clone().add(dayOffset, 'day');
     const dateYYYYMMDD = date.format('YYYY-MM-DD');
-    const ref = findUriByRef(getWorkspaceCache().markdownUris, dateYYYYMMDD);
+    const ref = findUriByRef(cache.getWorkspaceCache().markdownUris, dateYYYYMMDD);
 
     return {
       label: `${ref ? '✓' : '✕'} ${toOffsetLabel(dayOffset)} | ${date.format(
diff --git a/src/utils/index.ts b/src/utils/index.ts
index a6fdd82b..882abb28 100644
--- a/src/utils/index.ts
+++ b/src/utils/index.ts
@@ -1,3 +1,10 @@
+import { sort as sortPaths } from 'cross-path-sort';
+
+import { default as createDailyQuickPick } from './createDailyQuickPick';
+import { readClipboard } from './clipboardUtils';
+
+export { sortPaths, createDailyQuickPick, readClipboard };
+
 export * from './utils';
 export * from './externalUtils';
 export * from './replaceUtils';
diff --git a/src/utils/replaceUtils.ts b/src/utils/replaceUtils.ts
index 0a795abe..58dd367e 100644
--- a/src/utils/replaceUtils.ts
+++ b/src/utils/replaceUtils.ts
@@ -1,15 +1,15 @@
 import path from 'path';
 import { Uri, TextDocument } from 'vscode';
 import groupBy from 'lodash.groupby';
+import { sort as sortPaths } from 'cross-path-sort';
 
+import { cache } from '../workspace';
 import {
   fsPathToRef,
   getWorkspaceFolder,
   containsMarkdownExt,
   isDefined,
   getMemoConfigProperty,
-  sortPaths,
-  getWorkspaceCache,
   findAllUrisWithUnknownExts,
   escapeForRegExp,
 } from './utils';
@@ -46,7 +46,7 @@ export const resolveRefsReplaceMap = async (
   const oldUrisGroupedByBasename = groupBy(
     sortPaths(
       [
-        ...getWorkspaceCache().allUris.filter((uri) => !oldFsPaths.includes(uri.fsPath)),
+        ...cache.getWorkspaceCache().allUris.filter((uri) => !oldFsPaths.includes(uri.fsPath)),
         ...renamedFiles.map(({ oldUri }) => oldUri),
       ],
       {
@@ -60,7 +60,7 @@ export const resolveRefsReplaceMap = async (
   const newFsPaths = renamedFiles.map(({ newUri }) => newUri.fsPath);
 
   const allUris = [
-    ...getWorkspaceCache().allUris.filter((uri) => !newFsPaths.includes(uri.fsPath)),
+    ...cache.getWorkspaceCache().allUris.filter((uri) => !newFsPaths.includes(uri.fsPath)),
     ...renamedFiles.map(({ newUri }) => newUri),
   ];
 
diff --git a/src/utils/utils.spec.ts b/src/utils/utils.spec.ts
index c51c7efb..74b05430 100644
--- a/src/utils/utils.spec.ts
+++ b/src/utils/utils.spec.ts
@@ -2,22 +2,8 @@ import { Position, Range, Selection, Uri, window, workspace } from 'vscode';
 import fs from 'fs';
 import path from 'path';
 
-import {
-  cleanWorkspace,
-  closeEditorsAndCleanWorkspace,
-  createFile,
-  openTextDocument,
-  rndName,
-  toPlainObject,
-  updateConfigProperty,
-} from '../test/testUtils';
 import * as utils from './utils';
 import {
-  addCachedRefs,
-  cacheRefs,
-  cacheUris,
-  cacheWorkspace,
-  cleanWorkspaceCache,
   containsImageExt,
   containsMarkdownExt,
   containsOtherKnownExts,
@@ -40,20 +26,27 @@ import {
   getMemoConfigProperty,
   getReferenceAtPosition,
   getRefUriUnderCursor,
-  getWorkspaceCache,
   getWorkspaceFolder,
   isLongRef,
   isUncPath,
   matchAll,
   normalizeSlashes,
   parseRef,
-  removeCachedRefs,
   trimLeadingSlash,
   trimSlashes,
   trimTrailingSlash,
   getDirRelativeToWorkspace,
   extractRefsFromText,
 } from './utils';
+import { cache } from '../workspace';
+import {
+  closeEditorsAndCleanWorkspace,
+  createFile,
+  openTextDocument,
+  rndName,
+  toPlainObject,
+  updateConfigProperty,
+} from '../test/testUtils';
 
 describe('containsImageExt()', () => {
   test.each(['png', 'jpg', 'jpeg', 'gif'])(
@@ -187,329 +180,6 @@ describe('fsPathToRef()', () => {
   });
 });
 
-describe('cacheWorkspace()', () => {
-  beforeEach(closeEditorsAndCleanWorkspace);
-
-  afterEach(closeEditorsAndCleanWorkspace);
-
-  it('should work with empty workspace', async () => {
-    await cacheWorkspace();
-
-    expect([...getWorkspaceCache().markdownUris, ...getWorkspaceCache().imageUris]).toHaveLength(0);
-  });
-
-  it('should cache workspace', async () => {
-    const noteFilename = `${rndName()}.md`;
-    const imageFilename = `${rndName()}.png`;
-    const otherFilename = `${rndName()}.txt`;
-
-    await createFile(
-      noteFilename,
-      `
-    [[dangling-ref]]
-    [[dangling-ref]]
-    [[dangling-ref2|Test Label]]
-    [[folder1/long-dangling-ref]]
-    ![[dangling-ref3]]
-    \`[[dangling-ref-within-code-span]]\`
-    \`\`\`
-    Preceding text
-    [[dangling-ref-within-fenced-code-block]]
-    Following text
-    \`\`\`
-    [[${imageFilename}]]
-    `,
-      false,
-    );
-    await createFile(imageFilename, '', false);
-    await createFile(otherFilename, '', false);
-
-    await cacheWorkspace();
-
-    expect(
-      [
-        ...getWorkspaceCache().markdownUris,
-        ...getWorkspaceCache().imageUris,
-        ...getWorkspaceCache().otherUris,
-      ].map(({ fsPath }) => path.basename(fsPath)),
-    ).toEqual([noteFilename, imageFilename, otherFilename]);
-
-    expect(Object.values(getWorkspaceCache().danglingRefsByFsPath)).toEqual([
-      ['dangling-ref', 'dangling-ref2', 'folder1/long-dangling-ref', 'dangling-ref3'],
-    ]);
-    expect(getWorkspaceCache().danglingRefs).toEqual([
-      'dangling-ref',
-      'dangling-ref2',
-      'dangling-ref3',
-      'folder1/long-dangling-ref',
-    ]);
-  });
-});
-
-describe('cacheUris()', () => {
-  beforeEach(closeEditorsAndCleanWorkspace);
-
-  afterEach(closeEditorsAndCleanWorkspace);
-
-  it('should work with empty workspace', async () => {
-    await cacheUris();
-
-    expect([...getWorkspaceCache().markdownUris, ...getWorkspaceCache().imageUris]).toHaveLength(0);
-  });
-
-  it('should cache uris', async () => {
-    const noteFilename = `${rndName()}.md`;
-    const imageFilename = `${rndName()}.png`;
-    const otherFilename = `${rndName()}.txt`;
-
-    await createFile(noteFilename, ``, false);
-    await createFile(imageFilename, '', false);
-    await createFile(otherFilename, '', false);
-
-    await cacheUris();
-
-    expect(
-      [
-        ...getWorkspaceCache().markdownUris,
-        ...getWorkspaceCache().imageUris,
-        ...getWorkspaceCache().otherUris,
-      ].map(({ fsPath }) => path.basename(fsPath)),
-    ).toEqual([noteFilename, imageFilename, otherFilename]);
-  });
-});
-
-describe('cacheRefs()', () => {
-  beforeEach(closeEditorsAndCleanWorkspace);
-
-  afterEach(closeEditorsAndCleanWorkspace);
-
-  it('should work with empty workspace', async () => {
-    await cacheRefs();
-
-    expect(getWorkspaceCache().danglingRefsByFsPath).toEqual({});
-    expect(getWorkspaceCache().danglingRefs).toEqual([]);
-  });
-
-  it('should cache refs', async () => {
-    const noteFilename = `${rndName()}.md`;
-    const imageFilename = `${rndName()}.png`;
-
-    await createFile(
-      noteFilename,
-      `
-    [[dangling-ref]]
-    [[dangling-ref]]
-    [[dangling-ref2|Test Label]]
-    [[folder1/long-dangling-ref]]
-    ![[dangling-ref3]]
-    \`[[dangling-ref-within-code-span]]\`
-    \`\`\`
-    Preceding text
-    [[dangling-ref-within-fenced-code-block]]
-    Following text
-    \`\`\`
-    [[${imageFilename}]]
-    `,
-    );
-    await createFile(imageFilename);
-
-    await cacheRefs();
-
-    expect(Object.values(getWorkspaceCache().danglingRefsByFsPath)).toEqual([
-      ['dangling-ref', 'dangling-ref2', 'folder1/long-dangling-ref', 'dangling-ref3'],
-    ]);
-    expect(getWorkspaceCache().danglingRefs).toEqual([
-      'dangling-ref',
-      'dangling-ref2',
-      'dangling-ref3',
-      'folder1/long-dangling-ref',
-    ]);
-
-    cleanWorkspaceCache();
-
-    expect(getWorkspaceCache().danglingRefsByFsPath).toEqual({});
-    expect(getWorkspaceCache().danglingRefs).toEqual([]);
-  });
-});
-
-describe('addCachedRefs', () => {
-  beforeEach(closeEditorsAndCleanWorkspace);
-
-  afterEach(closeEditorsAndCleanWorkspace);
-
-  it('should not fail without parameters', () => {
-    expect(addCachedRefs([])).resolves.toBeUndefined();
-  });
-
-  it('should not fail with non-existing uri', () => {
-    expect(addCachedRefs([Uri.file('/unknown')])).resolves.toBeUndefined();
-  });
-
-  it('should add cached refs', async () => {
-    const name = rndName();
-
-    expect(getWorkspaceCache().danglingRefsByFsPath).toEqual({});
-    expect(getWorkspaceCache().danglingRefs).toEqual([]);
-
-    await createFile(`${name}.md`, '[[dangling-ref]]');
-
-    await addCachedRefs([Uri.file(path.join(getWorkspaceFolder()!, `${name}.md`))]);
-
-    expect(Object.values(getWorkspaceCache().danglingRefsByFsPath)).toEqual([['dangling-ref']]);
-    expect(getWorkspaceCache().danglingRefs).toEqual(['dangling-ref']);
-  });
-
-  it('should add cached refs on top of existing', async () => {
-    const name = rndName();
-
-    await createFile(`${name}.md`, '[[dangling-ref]]');
-
-    await addCachedRefs([Uri.file(path.join(getWorkspaceFolder()!, `${name}.md`))]);
-
-    expect(Object.values(getWorkspaceCache().danglingRefsByFsPath)).toEqual([['dangling-ref']]);
-    expect(getWorkspaceCache().danglingRefs).toEqual(['dangling-ref']);
-
-    await createFile(`${name}.md`, '[[dangling-ref]] [[dangling-ref2]]');
-
-    await addCachedRefs([Uri.file(path.join(getWorkspaceFolder()!, `${name}.md`))]);
-
-    expect(Object.values(getWorkspaceCache().danglingRefsByFsPath)).toEqual([
-      ['dangling-ref', 'dangling-ref2'],
-    ]);
-    expect(getWorkspaceCache().danglingRefs).toEqual(['dangling-ref', 'dangling-ref2']);
-  });
-});
-
-describe('removeCachedRefs()', () => {
-  beforeEach(closeEditorsAndCleanWorkspace);
-
-  afterEach(closeEditorsAndCleanWorkspace);
-
-  it('should not fail with non-existing uri', () => {
-    expect(() => removeCachedRefs([])).not.toThrow();
-  });
-
-  it('should not fail if there is nothing to remove', () => {
-    expect(() => removeCachedRefs([Uri.file('/unknown')])).not.toThrow();
-  });
-
-  it('should remove cached refs', async () => {
-    const name = rndName();
-
-    await createFile(`${name}.md`, '[[dangling-ref]]');
-
-    await addCachedRefs([Uri.file(path.join(getWorkspaceFolder()!, `${name}.md`))]);
-
-    expect(Object.values(getWorkspaceCache().danglingRefsByFsPath)).toEqual([['dangling-ref']]);
-    expect(getWorkspaceCache().danglingRefs).toEqual(['dangling-ref']);
-
-    await removeCachedRefs([Uri.file(path.join(getWorkspaceFolder()!, `${name}.md`))]);
-
-    expect(getWorkspaceCache().danglingRefsByFsPath).toEqual({});
-    expect(getWorkspaceCache().danglingRefs).toEqual([]);
-  });
-});
-
-describe('cleanWorkspaceCache()', () => {
-  beforeEach(closeEditorsAndCleanWorkspace);
-
-  afterEach(closeEditorsAndCleanWorkspace);
-
-  it('should work with empty workspace', async () => {
-    await cleanWorkspaceCache();
-
-    expect([
-      ...getWorkspaceCache().markdownUris,
-      ...getWorkspaceCache().imageUris,
-      ...getWorkspaceCache().otherUris,
-    ]).toHaveLength(0);
-  });
-
-  it('should clean workspace cache', async () => {
-    const noteFilename = `${rndName()}.md`;
-    const imageFilename = `${rndName()}.png`;
-    const otherFilename = `${rndName()}.txt`;
-
-    await createFile(
-      noteFilename,
-      `
-    [[dangling-ref]]
-    [[dangling-ref]]
-    [[dangling-ref2|Test Label]]
-    [[folder1/long-dangling-ref]]
-    ![[dangling-ref3]]
-    \`[[dangling-ref-within-code-span]]\`
-    \`\`\`
-    Preceding text
-    [[dangling-ref-within-fenced-code-block]]
-    Following text
-    \`\`\`
-    [[${imageFilename}]]
-    `,
-    );
-    await createFile(imageFilename);
-    await createFile(otherFilename);
-
-    await cacheWorkspace();
-
-    expect(
-      [
-        ...getWorkspaceCache().markdownUris,
-        ...getWorkspaceCache().imageUris,
-        ...getWorkspaceCache().otherUris,
-      ].map(({ fsPath }) => path.basename(fsPath)),
-    ).toEqual([noteFilename, imageFilename, otherFilename]);
-
-    expect(Object.values(getWorkspaceCache().danglingRefsByFsPath)).toEqual([
-      ['dangling-ref', 'dangling-ref2', 'folder1/long-dangling-ref', 'dangling-ref3'],
-    ]);
-    expect(getWorkspaceCache().danglingRefs).toEqual([
-      'dangling-ref',
-      'dangling-ref2',
-      'dangling-ref3',
-      'folder1/long-dangling-ref',
-    ]);
-
-    cleanWorkspaceCache();
-
-    expect([
-      ...getWorkspaceCache().markdownUris,
-      ...getWorkspaceCache().imageUris,
-      ...getWorkspaceCache().otherUris,
-    ]).toHaveLength(0);
-    expect(getWorkspaceCache().danglingRefsByFsPath).toEqual({});
-    expect(getWorkspaceCache().danglingRefs).toEqual([]);
-  });
-});
-
-describe('getWorkspaceCache()', () => {
-  beforeEach(closeEditorsAndCleanWorkspace);
-
-  afterEach(closeEditorsAndCleanWorkspace);
-
-  it('should work with empty workspace', () => {
-    cleanWorkspace();
-    cleanWorkspaceCache();
-
-    expect([...getWorkspaceCache().markdownUris, ...getWorkspaceCache().imageUris]).toHaveLength(0);
-  });
-
-  it('should get workspace cache', async () => {
-    const noteFilename = `${rndName()}.md`;
-    const imageFilename = `${rndName()}.png`;
-
-    await createFile(noteFilename);
-    await createFile(imageFilename);
-
-    await cacheWorkspace();
-
-    const uris = [...getWorkspaceCache().markdownUris, ...getWorkspaceCache().imageUris];
-
-    expect(uris).toHaveLength(2);
-    expect(uris.map(({ fsPath }) => path.basename(fsPath))).toEqual([noteFilename, imageFilename]);
-  });
-});
-
 describe('getRefUriUnderCursor()', () => {
   beforeEach(closeEditorsAndCleanWorkspace);
 
@@ -1435,7 +1105,7 @@ describe('findDanglingRefsByFsPath()', () => {
     );
     await createFile(`${name1}.md`);
 
-    const refsByFsPath = await findDanglingRefsByFsPath(getWorkspaceCache().markdownUris);
+    const refsByFsPath = await findDanglingRefsByFsPath(cache.getWorkspaceCache().markdownUris);
 
     expect(Object.keys(refsByFsPath)).toHaveLength(1);
     expect(Object.values(refsByFsPath)[0]).toEqual([
@@ -1455,21 +1125,21 @@ describe('findDanglingRefsByFsPath()', () => {
 
     const editor = await window.showTextDocument(doc);
 
-    const refsByFsPath = await findDanglingRefsByFsPath(getWorkspaceCache().markdownUris);
+    const refsByFsPath = await findDanglingRefsByFsPath(cache.getWorkspaceCache().markdownUris);
 
     expect(Object.keys(refsByFsPath)).toHaveLength(1);
     expect(Object.values(refsByFsPath)[0]).toEqual(['dangling-ref']);
 
     await editor.edit((edit) => edit.insert(new Position(1, 0), '[[dangling-ref2]]'));
 
-    const refsByFsPath2 = await findDanglingRefsByFsPath(getWorkspaceCache().markdownUris);
+    const refsByFsPath2 = await findDanglingRefsByFsPath(cache.getWorkspaceCache().markdownUris);
 
     expect(Object.keys(refsByFsPath2)).toHaveLength(1);
     expect(Object.values(refsByFsPath2)[0]).toEqual(['dangling-ref', 'dangling-ref2']);
 
     await editor.edit((edit) => edit.delete(new Range(new Position(0, 0), new Position(2, 0))));
 
-    expect(await findDanglingRefsByFsPath(getWorkspaceCache().markdownUris)).toEqual({});
+    expect(await findDanglingRefsByFsPath(cache.getWorkspaceCache().markdownUris)).toEqual({});
   });
 });
 
diff --git a/src/utils/utils.ts b/src/utils/utils.ts
index 93f000ba..431c4c81 100644
--- a/src/utils/utils.ts
+++ b/src/utils/utils.ts
@@ -1,14 +1,10 @@
 import vscode, { CancellationToken, GlobPattern, Uri, workspace } from 'vscode';
 import path from 'path';
-import { sort as sortPaths } from 'cross-path-sort';
 import fs from 'fs';
 
-import { WorkspaceCache, RefT, FoundRefT, LinkRuleT, ExtractedRefT } from '../types';
+import { RefT, FoundRefT, LinkRuleT, ExtractedRefT } from '../types';
+import { cache } from '../workspace';
 import { isInCodeSpan, isInFencedCodeBlock } from './externalUtils';
-import { default as createDailyQuickPick } from './createDailyQuickPick';
-import { readClipboard } from './clipboardUtils';
-
-export { sortPaths, createDailyQuickPick, readClipboard };
 
 const markdownExtRegex = /\.md$/i;
 
@@ -113,7 +109,7 @@ export const extractDanglingRefs = (content: string) => {
 
         const { ref } = parseRef(reference);
 
-        if (!findUriByRef(getWorkspaceCache().allUris, ref)) {
+        if (!findUriByRef(cache.getWorkspaceCache().allUris, ref)) {
           refs.push(ref);
         }
       }
@@ -147,88 +143,6 @@ export const findDanglingRefsByFsPath = async (uris: vscode.Uri[]) => {
   return refsByFsPath;
 };
 
-const workspaceCache: WorkspaceCache = {
-  imageUris: [],
-  markdownUris: [],
-  otherUris: [],
-  allUris: [],
-  danglingRefsByFsPath: {},
-  danglingRefs: [],
-};
-
-export const getWorkspaceCache = (): WorkspaceCache => workspaceCache;
-
-export const cacheUris = async () => {
-  const markdownUris = await findNonIgnoredFiles('**/*.md');
-  const imageUris = await findNonIgnoredFiles(`**/*.{${imageExts.join(',')}}`);
-  const otherUris = await findNonIgnoredFiles(`**/*.{${otherExts.join(',')}}`);
-
-  workspaceCache.markdownUris = sortPaths(markdownUris, { pathKey: 'path', shallowFirst: true });
-  workspaceCache.imageUris = sortPaths(imageUris, { pathKey: 'path', shallowFirst: true });
-  workspaceCache.otherUris = sortPaths(otherUris, { pathKey: 'path', shallowFirst: true });
-  workspaceCache.allUris = sortPaths([...markdownUris, ...imageUris, ...otherUris], {
-    pathKey: 'path',
-    shallowFirst: true,
-  });
-};
-
-export const cacheRefs = async () => {
-  workspaceCache.danglingRefsByFsPath = await findDanglingRefsByFsPath(workspaceCache.markdownUris);
-  workspaceCache.danglingRefs = sortPaths(
-    Array.from(new Set(Object.values(workspaceCache.danglingRefsByFsPath).flatMap((refs) => refs))),
-    { shallowFirst: true },
-  );
-};
-
-export const addCachedRefs = async (uris: vscode.Uri[]) => {
-  const danglingRefsByFsPath = await findDanglingRefsByFsPath(uris);
-
-  workspaceCache.danglingRefsByFsPath = {
-    ...workspaceCache.danglingRefsByFsPath,
-    ...danglingRefsByFsPath,
-  };
-
-  workspaceCache.danglingRefs = sortPaths(
-    Array.from(new Set(Object.values(workspaceCache.danglingRefsByFsPath).flatMap((refs) => refs))),
-    { shallowFirst: true },
-  );
-};
-
-export const removeCachedRefs = async (uris: vscode.Uri[]) => {
-  const fsPaths = uris.map(({ fsPath }) => fsPath);
-
-  workspaceCache.danglingRefsByFsPath = Object.entries(workspaceCache.danglingRefsByFsPath).reduce<{
-    [key: string]: string[];
-  }>((refsByFsPath, [fsPath, refs]) => {
-    if (fsPaths.some((p) => fsPath.startsWith(p))) {
-      return refsByFsPath;
-    }
-
-    refsByFsPath[fsPath] = refs;
-
-    return refsByFsPath;
-  }, {});
-
-  workspaceCache.danglingRefs = sortPaths(
-    Array.from(new Set(Object.values(workspaceCache.danglingRefsByFsPath).flatMap((refs) => refs))),
-    { shallowFirst: true },
-  );
-};
-
-export const cacheWorkspace = async () => {
-  await cacheUris();
-  await cacheRefs();
-};
-
-export const cleanWorkspaceCache = () => {
-  workspaceCache.imageUris = [];
-  workspaceCache.markdownUris = [];
-  workspaceCache.otherUris = [];
-  workspaceCache.allUris = [];
-  workspaceCache.danglingRefsByFsPath = {};
-  workspaceCache.danglingRefs = [];
-};
-
 export const getWorkspaceFolder = (): string | undefined =>
   vscode.workspace.workspaceFolders && vscode.workspace.workspaceFolders[0].uri.fsPath;
 
@@ -375,7 +289,7 @@ export const findReferences = async (
 ): Promise<FoundRefT[]> => {
   const foundRefs: FoundRefT[] = [];
 
-  for (const { fsPath } of workspaceCache.markdownUris) {
+  for (const { fsPath } of cache.getWorkspaceCache().markdownUris) {
     if (excludePaths.includes(fsPath) || !fs.existsSync(fsPath)) {
       continue;
     }
@@ -484,7 +398,7 @@ export const getRefUnderCursor = ():
 export const getRefUriUnderCursor = (): vscode.Uri | null | undefined => {
   const refAtPos = getRefUnderCursor();
 
-  return refAtPos && findUriByRef(getWorkspaceCache().allUris, refAtPos.ref);
+  return refAtPos && findUriByRef(cache.getWorkspaceCache().allUris, refAtPos.ref);
 };
 
 export const parseRef = (rawRef: string): RefT => {
diff --git a/src/workspace/cache/cache.spec.ts b/src/workspace/cache/cache.spec.ts
new file mode 100644
index 00000000..74c32b29
--- /dev/null
+++ b/src/workspace/cache/cache.spec.ts
@@ -0,0 +1,342 @@
+import path from 'path';
+import { Uri } from 'vscode';
+
+import {
+  cacheWorkspace,
+  cacheUris,
+  cacheRefs,
+  addCachedRefs,
+  removeCachedRefs,
+  getWorkspaceCache,
+  cleanWorkspaceCache,
+} from './cache';
+import { getWorkspaceFolder } from '../../utils';
+import {
+  cleanWorkspace,
+  closeEditorsAndCleanWorkspace,
+  createFile,
+  rndName,
+} from '../../test/testUtils';
+
+describe('cacheWorkspace()', () => {
+  beforeEach(closeEditorsAndCleanWorkspace);
+
+  afterEach(closeEditorsAndCleanWorkspace);
+
+  it('should work with empty workspace', async () => {
+    await cacheWorkspace();
+
+    expect([...getWorkspaceCache().markdownUris, ...getWorkspaceCache().imageUris]).toHaveLength(0);
+  });
+
+  it('should cache workspace', async () => {
+    const noteFilename = `${rndName()}.md`;
+    const imageFilename = `${rndName()}.png`;
+    const otherFilename = `${rndName()}.txt`;
+
+    await createFile(
+      noteFilename,
+      `
+    [[dangling-ref]]
+    [[dangling-ref]]
+    [[dangling-ref2|Test Label]]
+    [[folder1/long-dangling-ref]]
+    ![[dangling-ref3]]
+    \`[[dangling-ref-within-code-span]]\`
+    \`\`\`
+    Preceding text
+    [[dangling-ref-within-fenced-code-block]]
+    Following text
+    \`\`\`
+    [[${imageFilename}]]
+    `,
+      false,
+    );
+    await createFile(imageFilename, '', false);
+    await createFile(otherFilename, '', false);
+
+    await cacheWorkspace();
+
+    expect(
+      [
+        ...getWorkspaceCache().markdownUris,
+        ...getWorkspaceCache().imageUris,
+        ...getWorkspaceCache().otherUris,
+      ].map(({ fsPath }) => path.basename(fsPath)),
+    ).toEqual([noteFilename, imageFilename, otherFilename]);
+
+    expect(Object.values(getWorkspaceCache().danglingRefsByFsPath)).toEqual([
+      ['dangling-ref', 'dangling-ref2', 'folder1/long-dangling-ref', 'dangling-ref3'],
+    ]);
+    expect(getWorkspaceCache().danglingRefs).toEqual([
+      'dangling-ref',
+      'dangling-ref2',
+      'dangling-ref3',
+      'folder1/long-dangling-ref',
+    ]);
+  });
+});
+
+describe('cacheUris()', () => {
+  beforeEach(closeEditorsAndCleanWorkspace);
+
+  afterEach(closeEditorsAndCleanWorkspace);
+
+  it('should work with empty workspace', async () => {
+    await cacheUris();
+
+    expect([...getWorkspaceCache().markdownUris, ...getWorkspaceCache().imageUris]).toHaveLength(0);
+  });
+
+  it('should cache uris', async () => {
+    const noteFilename = `${rndName()}.md`;
+    const imageFilename = `${rndName()}.png`;
+    const otherFilename = `${rndName()}.txt`;
+
+    await createFile(noteFilename, ``, false);
+    await createFile(imageFilename, '', false);
+    await createFile(otherFilename, '', false);
+
+    await cacheUris();
+
+    expect(
+      [
+        ...getWorkspaceCache().markdownUris,
+        ...getWorkspaceCache().imageUris,
+        ...getWorkspaceCache().otherUris,
+      ].map(({ fsPath }) => path.basename(fsPath)),
+    ).toEqual([noteFilename, imageFilename, otherFilename]);
+  });
+});
+
+describe('cacheRefs()', () => {
+  beforeEach(closeEditorsAndCleanWorkspace);
+
+  afterEach(closeEditorsAndCleanWorkspace);
+
+  it('should work with empty workspace', async () => {
+    await cacheRefs();
+
+    expect(getWorkspaceCache().danglingRefsByFsPath).toEqual({});
+    expect(getWorkspaceCache().danglingRefs).toEqual([]);
+  });
+
+  it('should cache refs', async () => {
+    const noteFilename = `${rndName()}.md`;
+    const imageFilename = `${rndName()}.png`;
+
+    await createFile(
+      noteFilename,
+      `
+    [[dangling-ref]]
+    [[dangling-ref]]
+    [[dangling-ref2|Test Label]]
+    [[folder1/long-dangling-ref]]
+    ![[dangling-ref3]]
+    \`[[dangling-ref-within-code-span]]\`
+    \`\`\`
+    Preceding text
+    [[dangling-ref-within-fenced-code-block]]
+    Following text
+    \`\`\`
+    [[${imageFilename}]]
+    `,
+    );
+    await createFile(imageFilename);
+
+    await cacheRefs();
+
+    expect(Object.values(getWorkspaceCache().danglingRefsByFsPath)).toEqual([
+      ['dangling-ref', 'dangling-ref2', 'folder1/long-dangling-ref', 'dangling-ref3'],
+    ]);
+    expect(getWorkspaceCache().danglingRefs).toEqual([
+      'dangling-ref',
+      'dangling-ref2',
+      'dangling-ref3',
+      'folder1/long-dangling-ref',
+    ]);
+
+    cleanWorkspaceCache();
+
+    expect(getWorkspaceCache().danglingRefsByFsPath).toEqual({});
+    expect(getWorkspaceCache().danglingRefs).toEqual([]);
+  });
+});
+
+describe('addCachedRefs', () => {
+  beforeEach(closeEditorsAndCleanWorkspace);
+
+  afterEach(closeEditorsAndCleanWorkspace);
+
+  it('should not fail without parameters', () => {
+    expect(addCachedRefs([])).resolves.toBeUndefined();
+  });
+
+  it('should not fail with non-existing uri', () => {
+    expect(addCachedRefs([Uri.file('/unknown')])).resolves.toBeUndefined();
+  });
+
+  it('should add cached refs', async () => {
+    const name = rndName();
+
+    expect(getWorkspaceCache().danglingRefsByFsPath).toEqual({});
+    expect(getWorkspaceCache().danglingRefs).toEqual([]);
+
+    await createFile(`${name}.md`, '[[dangling-ref]]');
+
+    await addCachedRefs([Uri.file(path.join(getWorkspaceFolder()!, `${name}.md`))]);
+
+    expect(Object.values(getWorkspaceCache().danglingRefsByFsPath)).toEqual([['dangling-ref']]);
+    expect(getWorkspaceCache().danglingRefs).toEqual(['dangling-ref']);
+  });
+
+  it('should add cached refs on top of existing', async () => {
+    const name = rndName();
+
+    await createFile(`${name}.md`, '[[dangling-ref]]');
+
+    await addCachedRefs([Uri.file(path.join(getWorkspaceFolder()!, `${name}.md`))]);
+
+    expect(Object.values(getWorkspaceCache().danglingRefsByFsPath)).toEqual([['dangling-ref']]);
+    expect(getWorkspaceCache().danglingRefs).toEqual(['dangling-ref']);
+
+    await createFile(`${name}.md`, '[[dangling-ref]] [[dangling-ref2]]');
+
+    await addCachedRefs([Uri.file(path.join(getWorkspaceFolder()!, `${name}.md`))]);
+
+    expect(Object.values(getWorkspaceCache().danglingRefsByFsPath)).toEqual([
+      ['dangling-ref', 'dangling-ref2'],
+    ]);
+    expect(getWorkspaceCache().danglingRefs).toEqual(['dangling-ref', 'dangling-ref2']);
+  });
+});
+
+describe('removeCachedRefs()', () => {
+  beforeEach(closeEditorsAndCleanWorkspace);
+
+  afterEach(closeEditorsAndCleanWorkspace);
+
+  it('should not fail with non-existing uri', () => {
+    expect(() => removeCachedRefs([])).not.toThrow();
+  });
+
+  it('should not fail if there is nothing to remove', () => {
+    expect(() => removeCachedRefs([Uri.file('/unknown')])).not.toThrow();
+  });
+
+  it('should remove cached refs', async () => {
+    const name = rndName();
+
+    await createFile(`${name}.md`, '[[dangling-ref]]');
+
+    await addCachedRefs([Uri.file(path.join(getWorkspaceFolder()!, `${name}.md`))]);
+
+    expect(Object.values(getWorkspaceCache().danglingRefsByFsPath)).toEqual([['dangling-ref']]);
+    expect(getWorkspaceCache().danglingRefs).toEqual(['dangling-ref']);
+
+    await removeCachedRefs([Uri.file(path.join(getWorkspaceFolder()!, `${name}.md`))]);
+
+    expect(getWorkspaceCache().danglingRefsByFsPath).toEqual({});
+    expect(getWorkspaceCache().danglingRefs).toEqual([]);
+  });
+});
+
+describe('cleanWorkspaceCache()', () => {
+  beforeEach(closeEditorsAndCleanWorkspace);
+
+  afterEach(closeEditorsAndCleanWorkspace);
+
+  it('should work with empty workspace', async () => {
+    await cleanWorkspaceCache();
+
+    expect([
+      ...getWorkspaceCache().markdownUris,
+      ...getWorkspaceCache().imageUris,
+      ...getWorkspaceCache().otherUris,
+    ]).toHaveLength(0);
+  });
+
+  it('should clean workspace cache', async () => {
+    const noteFilename = `${rndName()}.md`;
+    const imageFilename = `${rndName()}.png`;
+    const otherFilename = `${rndName()}.txt`;
+
+    await createFile(
+      noteFilename,
+      `
+    [[dangling-ref]]
+    [[dangling-ref]]
+    [[dangling-ref2|Test Label]]
+    [[folder1/long-dangling-ref]]
+    ![[dangling-ref3]]
+    \`[[dangling-ref-within-code-span]]\`
+    \`\`\`
+    Preceding text
+    [[dangling-ref-within-fenced-code-block]]
+    Following text
+    \`\`\`
+    [[${imageFilename}]]
+    `,
+    );
+    await createFile(imageFilename);
+    await createFile(otherFilename);
+
+    await cacheWorkspace();
+
+    expect(
+      [
+        ...getWorkspaceCache().markdownUris,
+        ...getWorkspaceCache().imageUris,
+        ...getWorkspaceCache().otherUris,
+      ].map(({ fsPath }) => path.basename(fsPath)),
+    ).toEqual([noteFilename, imageFilename, otherFilename]);
+
+    expect(Object.values(getWorkspaceCache().danglingRefsByFsPath)).toEqual([
+      ['dangling-ref', 'dangling-ref2', 'folder1/long-dangling-ref', 'dangling-ref3'],
+    ]);
+    expect(getWorkspaceCache().danglingRefs).toEqual([
+      'dangling-ref',
+      'dangling-ref2',
+      'dangling-ref3',
+      'folder1/long-dangling-ref',
+    ]);
+
+    cleanWorkspaceCache();
+
+    expect([
+      ...getWorkspaceCache().markdownUris,
+      ...getWorkspaceCache().imageUris,
+      ...getWorkspaceCache().otherUris,
+    ]).toHaveLength(0);
+    expect(getWorkspaceCache().danglingRefsByFsPath).toEqual({});
+    expect(getWorkspaceCache().danglingRefs).toEqual([]);
+  });
+});
+
+describe('getWorkspaceCache()', () => {
+  beforeEach(closeEditorsAndCleanWorkspace);
+
+  afterEach(closeEditorsAndCleanWorkspace);
+
+  it('should work with empty workspace', () => {
+    cleanWorkspace();
+    cleanWorkspaceCache();
+
+    expect([...getWorkspaceCache().markdownUris, ...getWorkspaceCache().imageUris]).toHaveLength(0);
+  });
+
+  it('should get workspace cache', async () => {
+    const noteFilename = `${rndName()}.md`;
+    const imageFilename = `${rndName()}.png`;
+
+    await createFile(noteFilename);
+    await createFile(imageFilename);
+
+    await cacheWorkspace();
+
+    const uris = [...getWorkspaceCache().markdownUris, ...getWorkspaceCache().imageUris];
+
+    expect(uris).toHaveLength(2);
+    expect(uris.map(({ fsPath }) => path.basename(fsPath))).toEqual([noteFilename, imageFilename]);
+  });
+});
diff --git a/src/workspace/cache/cache.ts b/src/workspace/cache/cache.ts
new file mode 100644
index 00000000..3ee74a78
--- /dev/null
+++ b/src/workspace/cache/cache.ts
@@ -0,0 +1,96 @@
+import { sort as sortPaths } from 'cross-path-sort';
+import vscode from 'vscode';
+
+import { WorkspaceCache } from '../../types';
+
+const workspaceCache: WorkspaceCache = {
+  imageUris: [],
+  markdownUris: [],
+  otherUris: [],
+  allUris: [],
+  danglingRefsByFsPath: {},
+  danglingRefs: [],
+};
+
+// lazy require avoids cyclic dependencies between utils and cache
+const utils = () => require('../../utils');
+
+// private methods (not exported via workspace/index.ts and should not be used outside of workspace folder)
+
+export const cacheRefs = async () => {
+  workspaceCache.danglingRefsByFsPath = await utils().findDanglingRefsByFsPath(
+    workspaceCache.markdownUris,
+  );
+  workspaceCache.danglingRefs = sortPaths(
+    Array.from(new Set(Object.values(workspaceCache.danglingRefsByFsPath).flatMap((refs) => refs))),
+    { shallowFirst: true },
+  );
+};
+
+export const addCachedRefs = async (uris: vscode.Uri[]) => {
+  const danglingRefsByFsPath = await utils().findDanglingRefsByFsPath(uris);
+
+  workspaceCache.danglingRefsByFsPath = {
+    ...workspaceCache.danglingRefsByFsPath,
+    ...danglingRefsByFsPath,
+  };
+
+  workspaceCache.danglingRefs = sortPaths(
+    Array.from(new Set(Object.values(workspaceCache.danglingRefsByFsPath).flatMap((refs) => refs))),
+    { shallowFirst: true },
+  );
+};
+
+export const removeCachedRefs = async (uris: vscode.Uri[]) => {
+  const fsPaths = uris.map(({ fsPath }) => fsPath);
+
+  workspaceCache.danglingRefsByFsPath = Object.entries(workspaceCache.danglingRefsByFsPath).reduce<{
+    [key: string]: string[];
+  }>((refsByFsPath, [fsPath, refs]) => {
+    if (fsPaths.some((p) => fsPath.startsWith(p))) {
+      return refsByFsPath;
+    }
+
+    refsByFsPath[fsPath] = refs;
+
+    return refsByFsPath;
+  }, {});
+
+  workspaceCache.danglingRefs = sortPaths(
+    Array.from(new Set(Object.values(workspaceCache.danglingRefsByFsPath).flatMap((refs) => refs))),
+    { shallowFirst: true },
+  );
+};
+
+// public methods (exported via workspace/index.ts)
+
+export const getWorkspaceCache = (): WorkspaceCache => workspaceCache;
+
+export const cacheWorkspace = async () => {
+  await cacheUris();
+  await cacheRefs();
+};
+
+export const cleanWorkspaceCache = () => {
+  workspaceCache.imageUris = [];
+  workspaceCache.markdownUris = [];
+  workspaceCache.otherUris = [];
+  workspaceCache.allUris = [];
+  workspaceCache.danglingRefsByFsPath = {};
+  workspaceCache.danglingRefs = [];
+};
+
+export const cacheUris = async () => {
+  const { findNonIgnoredFiles, imageExts, otherExts } = utils();
+  const markdownUris = await findNonIgnoredFiles('**/*.md');
+  const imageUris = await findNonIgnoredFiles(`**/*.{${imageExts.join(',')}}`);
+  const otherUris = await findNonIgnoredFiles(`**/*.{${otherExts.join(',')}}`);
+
+  workspaceCache.markdownUris = sortPaths(markdownUris, { pathKey: 'path', shallowFirst: true });
+  workspaceCache.imageUris = sortPaths(imageUris, { pathKey: 'path', shallowFirst: true });
+  workspaceCache.otherUris = sortPaths(otherUris, { pathKey: 'path', shallowFirst: true });
+  workspaceCache.allUris = sortPaths([...markdownUris, ...imageUris, ...otherUris], {
+    pathKey: 'path',
+    shallowFirst: true,
+  });
+};
diff --git a/src/workspace/cache/index.ts b/src/workspace/cache/index.ts
new file mode 100644
index 00000000..77e55d4e
--- /dev/null
+++ b/src/workspace/cache/index.ts
@@ -0,0 +1 @@
+export * from './cache';
diff --git a/src/workspace/file-watcher/fileWatcher.spec.ts b/src/workspace/file-watcher/fileWatcher.spec.ts
index a0660d27..b31ff47c 100644
--- a/src/workspace/file-watcher/fileWatcher.spec.ts
+++ b/src/workspace/file-watcher/fileWatcher.spec.ts
@@ -2,7 +2,7 @@ import { WorkspaceEdit, Uri, workspace, ExtensionContext, window, Range, Positio
 import path from 'path';
 
 import * as fileWatcher from './fileWatcher';
-import * as utils from '../../utils';
+import * as cache from '../cache';
 import {
   createFile,
   removeFile,
@@ -326,7 +326,7 @@ describe('fileWatcher', () => {
     await createFile(`${imageName}.md`, '', false);
 
     await waitForExpect(async () => {
-      const workspaceCache = await utils.getWorkspaceCache();
+      const workspaceCache = await cache.getWorkspaceCache();
 
       expect([...workspaceCache.markdownUris, ...workspaceCache.imageUris]).toHaveLength(2);
       expect(
@@ -340,14 +340,14 @@ describe('fileWatcher', () => {
   it('should add new dangling refs to cache on file create', async () => {
     const noteName = rndName();
 
-    expect(utils.getWorkspaceCache().danglingRefs).toEqual([]);
-    expect(utils.getWorkspaceCache().danglingRefsByFsPath).toEqual({});
+    expect(cache.getWorkspaceCache().danglingRefs).toEqual([]);
+    expect(cache.getWorkspaceCache().danglingRefsByFsPath).toEqual({});
 
     await createFile(`${noteName}.md`, '[[dangling-ref]] [[dangling-ref2]]', false);
 
     await waitForExpect(() => {
-      expect(utils.getWorkspaceCache().danglingRefs).toEqual(['dangling-ref', 'dangling-ref2']);
-      expect(Object.values(utils.getWorkspaceCache().danglingRefsByFsPath)).toEqual([
+      expect(cache.getWorkspaceCache().danglingRefs).toEqual(['dangling-ref', 'dangling-ref2']);
+      expect(Object.values(cache.getWorkspaceCache().danglingRefsByFsPath)).toEqual([
         ['dangling-ref', 'dangling-ref2'],
       ]);
     });
@@ -359,8 +359,8 @@ describe('fileWatcher', () => {
     await createFile(`${noteName}.md`, '[[dangling-ref]] [[dangling-ref2]]', false);
 
     await waitForExpect(() => {
-      expect(utils.getWorkspaceCache().danglingRefs).toEqual(['dangling-ref', 'dangling-ref2']);
-      expect(Object.values(utils.getWorkspaceCache().danglingRefsByFsPath)).toEqual([
+      expect(cache.getWorkspaceCache().danglingRefs).toEqual(['dangling-ref', 'dangling-ref2']);
+      expect(Object.values(cache.getWorkspaceCache().danglingRefsByFsPath)).toEqual([
         ['dangling-ref', 'dangling-ref2'],
       ]);
     });
@@ -368,8 +368,8 @@ describe('fileWatcher', () => {
     await removeFile(`${noteName}.md`);
 
     await waitForExpect(() => {
-      expect(utils.getWorkspaceCache().danglingRefs).toEqual([]);
-      expect(utils.getWorkspaceCache().danglingRefsByFsPath).toEqual({});
+      expect(cache.getWorkspaceCache().danglingRefs).toEqual([]);
+      expect(cache.getWorkspaceCache().danglingRefsByFsPath).toEqual({});
     });
   });
 
@@ -379,8 +379,8 @@ describe('fileWatcher', () => {
     await createFile(`${noteName}.md`, '[[dangling-ref]]', false);
 
     await waitForExpect(() => {
-      expect(utils.getWorkspaceCache().danglingRefs).toEqual(['dangling-ref']);
-      expect(Object.values(utils.getWorkspaceCache().danglingRefsByFsPath)).toEqual([
+      expect(cache.getWorkspaceCache().danglingRefs).toEqual(['dangling-ref']);
+      expect(Object.values(cache.getWorkspaceCache().danglingRefsByFsPath)).toEqual([
         ['dangling-ref'],
       ]);
     });
@@ -392,8 +392,8 @@ describe('fileWatcher', () => {
     await editor.edit((edit) => edit.insert(new Position(1, 0), '\n[[he]]'));
 
     await waitForExpect(() => {
-      expect(utils.getWorkspaceCache().danglingRefs).toEqual(['dangling-ref', 'he']);
-      expect(Object.values(utils.getWorkspaceCache().danglingRefsByFsPath)).toEqual([
+      expect(cache.getWorkspaceCache().danglingRefs).toEqual(['dangling-ref', 'he']);
+      expect(Object.values(cache.getWorkspaceCache().danglingRefsByFsPath)).toEqual([
         ['dangling-ref', 'he'],
       ]);
     });
@@ -404,8 +404,8 @@ describe('fileWatcher', () => {
     });
 
     await waitForExpect(() => {
-      expect(utils.getWorkspaceCache().danglingRefs).toEqual(['dangling-ref', 'hello']);
-      expect(Object.values(utils.getWorkspaceCache().danglingRefsByFsPath)).toEqual([
+      expect(cache.getWorkspaceCache().danglingRefs).toEqual(['dangling-ref', 'hello']);
+      expect(Object.values(cache.getWorkspaceCache().danglingRefsByFsPath)).toEqual([
         ['dangling-ref', 'hello'],
       ]);
     });
@@ -417,7 +417,7 @@ describe('fileWatcher', () => {
     await createFile(`${noteName}.md`, '', false);
 
     await waitForExpect(async () => {
-      const workspaceCache = await utils.getWorkspaceCache();
+      const workspaceCache = await cache.getWorkspaceCache();
 
       expect([...workspaceCache.markdownUris, ...workspaceCache.imageUris]).toHaveLength(1);
       expect(
@@ -430,7 +430,7 @@ describe('fileWatcher', () => {
     removeFile(`${noteName}.md`);
 
     await waitForExpect(async () => {
-      const workspaceCache = await utils.getWorkspaceCache();
+      const workspaceCache = await cache.getWorkspaceCache();
 
       expect([...workspaceCache.markdownUris, ...workspaceCache.imageUris]).toHaveLength(0);
       expect(
diff --git a/src/workspace/file-watcher/fileWatcher.ts b/src/workspace/file-watcher/fileWatcher.ts
index c86a8382..672d197e 100644
--- a/src/workspace/file-watcher/fileWatcher.ts
+++ b/src/workspace/file-watcher/fileWatcher.ts
@@ -2,7 +2,7 @@ import { workspace, ExtensionContext } from 'vscode';
 import debounce from 'lodash.debounce';
 
 import { handleFileCreate, handleFileDelete, handleDocChange, handleFilesRename } from './handlers';
-import { cacheUris } from '../../utils';
+import * as cache from '../cache';
 
 export const activate = (
   context: ExtensionContext,
@@ -10,7 +10,7 @@ export const activate = (
 ) => {
   const { uriCachingDelay = 1000, documentChangeDelay = 500 } = options;
 
-  const cacheUrisDebounced = debounce(cacheUris, uriCachingDelay);
+  const cacheUrisDebounced = debounce(cache.cacheUris, uriCachingDelay);
   const handleDocChangeDebounced = debounce(handleDocChange, documentChangeDelay);
 
   const fileWatcher = workspace.createFileSystemWatcher('**/*');
diff --git a/src/workspace/file-watcher/handlers.ts b/src/workspace/file-watcher/handlers.ts
index 57368b9d..f824ee79 100644
--- a/src/workspace/file-watcher/handlers.ts
+++ b/src/workspace/file-watcher/handlers.ts
@@ -1,40 +1,38 @@
 import fs from 'fs';
 import { FileRenameEvent, TextDocument, Uri, window, workspace } from 'vscode';
 
+import * as cache from '../cache';
 import {
-  addCachedRefs,
-  cacheUris,
   containsMarkdownExt,
   getMemoConfigProperty,
-  removeCachedRefs,
   replaceRefsInDoc,
   resolveRefsReplaceMap,
 } from '../../utils';
 
 export const handleFileCreate = async (
   newUri: Uri,
-  cacheUrisFn: () => Promise<void> = cacheUris,
+  cacheUrisFn: () => Promise<void> = cache.cacheUris,
 ) => {
   await cacheUrisFn();
-  await addCachedRefs([newUri]);
+  await cache.addCachedRefs([newUri]);
 };
 
 export const handleFileDelete = async (
   removedUri: Uri,
-  cacheUrisFn: () => Promise<void> = cacheUris,
+  cacheUrisFn: () => Promise<void> = cache.cacheUris,
 ) => {
   await cacheUrisFn();
-  await removeCachedRefs([removedUri]);
+  await cache.removeCachedRefs([removedUri]);
 };
 
 export const handleDocChange = async ({ uri }: TextDocument) => {
   if (containsMarkdownExt(uri.fsPath)) {
-    await addCachedRefs([uri]);
+    await cache.addCachedRefs([uri]);
   }
 };
 
 export const handleFilesRename = async ({ files }: FileRenameEvent) => {
-  await cacheUris();
+  await cache.cacheUris();
 
   if (!getMemoConfigProperty('links.sync.enabled', true)) {
     return;
diff --git a/src/workspace/index.ts b/src/workspace/index.ts
index c2f79e71..f1b91c67 100644
--- a/src/workspace/index.ts
+++ b/src/workspace/index.ts
@@ -1 +1,10 @@
+import { cacheWorkspace, getWorkspaceCache, cleanWorkspaceCache } from './cache';
+
 export * as fileWatcher from './file-watcher';
+
+// public cache interface
+export const cache = {
+  cacheWorkspace,
+  getWorkspaceCache,
+  cleanWorkspaceCache,
+};