diff --git a/README.md b/README.md
index 9ff6b34..d582369 100644
--- a/README.md
+++ b/README.md
@@ -54,9 +54,6 @@ export default defineConfig({
 
 ## Known limitations
 
-- For now, the SRI hashes calculation is done only for inlined resources. This
-  will be solved in future releases.
-
 - For now, this integration only works for generated static content (the
   exported subresource integrity hashes could be used in dynamic contexts, but
   that does not cover the whole SSG use case)
@@ -65,6 +62,14 @@ export default defineConfig({
   that if you need them to be up to date when you run `astro dev`, then you will
   have to manually run `astro build`.
 
+- It seems that when a script is loaded with a _static_ import rather than
+  directly included with a `<script>` tag, having its hash present in the
+  `script-src` directive is not enough to ensure that the browser will accept
+  it.
+  
+  This means that, for now, it is advisable to add `'self'` to the `script-src`
+  directive (adding `'strict-dynamic'` does not help either).
+
 ## License
 
 This library is released under [MIT License](LICENSE).
diff --git a/main.mjs b/main.mjs
index e622f91..f553ff7 100644
--- a/main.mjs
+++ b/main.mjs
@@ -10,127 +10,236 @@ import { extname, resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
 
 /**
- * @param {string} data
+ * @param {string | ArrayBuffer | Buffer} data
  * @returns {string}
  */
 const generateSRIHash = data => {
 	const hash = createHash('sha256')
-	hash.update(data, 'utf8')
+	if (data instanceof ArrayBuffer) {
+		hash.update(Buffer.from(data))
+	} else if (data instanceof Buffer) {
+		hash.update(data)
+	} else {
+		hash.update(data, 'utf8')
+	}
 	return `sha256-${hash.digest('base64')}`
 }
 
 /**
- * @param {string} filePath
+ * @param {RegExp} elemRegex
+ * @param {string} content
+ * @param {Set<string>} inlineHashes
  */
-const processHTMLFile = async filePath => {
-	const content = await readFile(filePath, 'utf8')
-
+const extractKnownSriHashes = (elemRegex, content, inlineHashes) => {
 	let match
-	let updatedContent = content
-
-	const inlineScriptHashes = /** @type {Set<string>} */ (new Set())
-	const inlineStyleHashes = /** @type {Set<string>} */ (new Set())
-
-	// Extracting current inline script SRI hashes
-	{
-		const scriptRegex = /<script integrity="([^"]+)">/g
 
-		// biome-ignore lint/suspicious/noAssignInExpressions: safe
-		while ((match = scriptRegex.exec(content)) !== null) {
-			const sriHash = match[1]
-			if (sriHash) {
-				inlineScriptHashes.add(sriHash)
-			}
+	// biome-ignore lint/suspicious/noAssignInExpressions: safe
+	while ((match = elemRegex.exec(content)) !== null) {
+		const sriHash = match[1]
+		if (sriHash) {
+			inlineHashes.add(sriHash)
 		}
 	}
+}
 
-	// Extracting current inline style SRI hashes
-	{
-		const styleRegex = /<style integrity="([^"]+)">/g
+/**
+ * @param {'script' | 'style'} elemType
+ * @param {string} content
+ * @param {Set<string>} inlineHashes
+ * @returns {string}
+ */
+const updateInlineSriHashes = (elemType, content, inlineHashes) => {
+	let updatedContent = content
+	let match
 
-		// biome-ignore lint/suspicious/noAssignInExpressions: safe
-		while ((match = styleRegex.exec(content)) !== null) {
-			const sriHash = match[1]
-			if (sriHash) {
-				inlineStyleHashes.add(sriHash)
-			}
+	const elemRegex = new RegExp(`<${elemType}>([\\s\\S]*?)<\\/${elemType}>`, 'g')
+
+	// biome-ignore lint/suspicious/noAssignInExpressions: safe
+	while ((match = elemRegex.exec(content)) !== null) {
+		const elemContent = match[1]?.trim()
+
+		if (elemContent) {
+			const sriHash = generateSRIHash(elemContent)
+			updatedContent = updatedContent.replace(
+				match[0],
+				`<${elemType} integrity="${sriHash}">${elemContent}</${elemType}>`,
+			)
+			inlineHashes.add(sriHash)
 		}
 	}
 
-	// Computing hashes for inline scripts without SRI hash
-	{
-		// Stateful object => we can use it to iterate over matches
-		const scriptRegex = /<script>([\s\S]*?)<\/script>/g
+	return updatedContent
+}
 
-		// biome-ignore lint/suspicious/noAssignInExpressions: safe
-		while ((match = scriptRegex.exec(content)) !== null) {
-			const scriptContent = match[1]?.trim()
+/**
+ * @param {import('astro').AstroIntegrationLogger} logger
+ * @param {string} distDir
+ * @param {'script' | 'style'} elemType
+ * @param {string} content
+ * @param {Set<string>} extHashes
+ * @returns {Promise<string>}
+ */
+const updateExternalSriHashes = async (
+	logger,
+	distDir,
+	elemType,
+	content,
+	extHashes,
+) => {
+	let updatedContent = content
+	let match
 
-			if (scriptContent) {
-				const sriHash = generateSRIHash(scriptContent)
-				updatedContent = updatedContent.replace(
-					match[0],
-					`<script integrity="${sriHash}">${scriptContent}</script>`,
-				)
-				inlineScriptHashes.add(sriHash)
-			}
+	const elemRegex =
+		elemType === 'script'
+			? /<script(?<attrs>\s+(type="module"\s+src="(?<href1>[\s\S]*?)"|src="(?<href2>[\s\S]*?)"\s+type="module"|src="(?<href3>[\s\S]*?)"))\s*(\/>|><\/script>)/gi
+			: /<link(?<attrs>\s+(rel="stylesheet"\s+href="(?<href1>[\s\S]*?)"|href="(?<href2>[\s\S]*?)"\s+rel="stylesheet"))\s*\/>/gi
+
+	// biome-ignore lint/suspicious/noAssignInExpressions: safe
+	while ((match = elemRegex.exec(content)) !== null) {
+		const attrs = match.groups?.attrs
+		const href =
+			match.groups?.href1 ??
+			match.groups?.href2 ??
+			match.groups?.href3
+		if (!attrs || !href) {
+			continue
+		}
+
+		/** @type {string | ArrayBuffer | Buffer} */
+		let resourceContent
+		if (href.startsWith('/')) {
+			const resourcePath = resolve(distDir, `.${href}`)
+			resourceContent = await readFile(resourcePath)
+		} else if (href.startsWith('http')) {
+			const resourceResponse = await fetch(href, { method: 'GET' })
+			resourceContent = await resourceResponse.arrayBuffer()
+		} else {
+			logger.warn(`Unable to process external resource: "${href}"`)
+			continue
 		}
+
+		const sriHash = generateSRIHash(resourceContent)
+		updatedContent = updatedContent.replace(
+			match[0],
+			elemType === 'script'
+				? `<script${attrs} integrity="${sriHash}" crossorigin="anonymous"></script>`
+				: `<link${attrs} integrity="${sriHash}" crossorigin="anonymous"/>`,
+		)
+		extHashes.add(sriHash)
 	}
 
-	// Computing hashes for inline styles without SRI hash
-	{
-		// Stateful object => we can use it to iterate over matches
-		const styleRegex = /<style>([\s\S]*?)<\/style>/g
+	return updatedContent
+}
 
-		// biome-ignore lint/suspicious/noAssignInExpressions: safe
-		while ((match = styleRegex.exec(content)) !== null) {
-			const styleContent = match[1]?.trim()
+/**
+ * @param {import('astro').AstroIntegrationLogger} logger
+ * @param {string} filePath
+ * @param {string} distDir
+ */
+const processHTMLFile = async (logger, filePath, distDir) => {
+	const content = await readFile(filePath, 'utf8')
 
-			if (styleContent) {
-				const sriHash = generateSRIHash(styleContent)
-				updatedContent = updatedContent.replace(
-					match[0],
-					`<style integrity="${sriHash}">${styleContent}</style>`,
-				)
-				inlineStyleHashes.add(sriHash)
-			}
-		}
-	}
+	const inlineScriptHashes = /** @type {Set<string>} */ (new Set())
+	const inlineStyleHashes = /** @type {Set<string>} */ (new Set())
+	const extScriptHashes = /** @type {Set<string>} */ (new Set())
+	const extStyleHashes = /** @type {Set<string>} */ (new Set())
+
+	// Known Inline Resources (just a precaution)
+	extractKnownSriHashes(
+		/<script integrity="([^"]+)">/g,
+		content,
+		inlineScriptHashes,
+	)
+	extractKnownSriHashes(
+		/<style integrity="([^"]+)">/g,
+		content,
+		inlineStyleHashes,
+	)
+
+	// Inline Resources
+	let updatedContent = updateInlineSriHashes(
+		'script',
+		content,
+		inlineScriptHashes,
+	)
+	updatedContent = updateInlineSriHashes(
+		'style',
+		updatedContent,
+		inlineStyleHashes,
+	)
+
+	// External Resources
+	updatedContent = await updateExternalSriHashes(
+		logger,
+		distDir,
+		'script',
+		updatedContent,
+		extScriptHashes,
+	)
+	updatedContent = await updateExternalSriHashes(
+		logger,
+		distDir,
+		'style',
+		updatedContent,
+		extStyleHashes,
+	)
 
 	if (updatedContent !== content) {
 		await writeFile(filePath, updatedContent)
 	}
 
-	return { inlineScriptHashes, inlineStyleHashes }
+	return {
+		inlineScriptHashes,
+		inlineStyleHashes,
+		extScriptHashes,
+		extStyleHashes,
+	}
 }
 
-/** @param {string} dirPath */
-const scanDirectory = async dirPath => {
+/**
+ * @param {import('astro').AstroIntegrationLogger} logger
+ * @param {string} dirPath
+ * @param {string} distDir
+ */
+const scanDirectory = async (logger, dirPath, distDir) => {
 	const inlineScriptHashes = /** @type {Set<string>} */ (new Set())
 	const inlineStyleHashes = /** @type {Set<string>} */ (new Set())
+	const extScriptHashes = /** @type {Set<string>} */ (new Set())
+	const extStyleHashes = /** @type {Set<string>} */ (new Set())
 
 	for (const file of await readdir(dirPath)) {
 		const filePath = resolve(dirPath, file)
 		const stats = await stat(filePath)
 
 		const hashes = stats.isDirectory()
-			? await scanDirectory(filePath)
+			? await scanDirectory(logger, filePath, distDir)
 			: stats.isFile() && extname(file) === '.html'
-			  ? await processHTMLFile(filePath)
+			  ? await processHTMLFile(logger, filePath, distDir)
 			  : undefined
 
 		// We don't have union :(, yet
 		if (hashes !== undefined) {
-			for (const hash of hashes.inlineScriptHashes) {
+			for (const hash of hashes.inlineScriptHashes ?? []) {
 				inlineScriptHashes.add(hash)
 			}
-			for (const hash of hashes.inlineStyleHashes) {
+			for (const hash of hashes.inlineStyleHashes ?? []) {
 				inlineStyleHashes.add(hash)
 			}
+			for (const hash of hashes.extScriptHashes ?? []) {
+				extScriptHashes.add(hash)
+			}
+			for (const hash of hashes.extStyleHashes ?? []) {
+				extStyleHashes.add(hash)
+			}
 		}
 	}
 
-	return { inlineScriptHashes, inlineStyleHashes }
+	return {
+		inlineScriptHashes,
+		inlineStyleHashes,
+		extScriptHashes,
+		extStyleHashes,
+	}
 }
 
 /**
@@ -169,13 +278,46 @@ const arraysEqual = (a, b) => {
 }
 
 /**
+ * This is a hack to scan for nested scripts in the `_astro` directory, but they
+ * should be detected in a recursive way, when we process the JS files that are
+ * being directly imported in the HTML files.
+ *
+ * TODO: Remove this function and implement the recursive scan.
+ *
+ * @param {string} dirPath
+ * @param {Set<string>} extScriptHashes
+ */
+const scanForNestedScripts = async (dirPath, extScriptHashes) => {
+	const nestedScriptsDir = resolve(dirPath, '_astro')
+
+	if (!(await doesFileExist(nestedScriptsDir))) {
+		return
+	}
+
+	for (const file of await readdir(nestedScriptsDir)) {
+		const filePath = resolve(nestedScriptsDir, file)
+
+		if ((await stat(filePath)).isFile() && (['.js', '.mjs'].includes(extname(file)))) {
+			const sriHash = generateSRIHash(await readFile(filePath))
+			extScriptHashes.add(sriHash)
+		}
+	}
+}
+
+/**
+ * @param {import('astro').AstroIntegrationLogger} logger
  * @param {import('./main.d.ts').StrictSriCspOptions} sriCspOptions
  */
-const generateSRIHashes = async ({ distDir, sriHashesModule }) => {
-	const hashes = await scanDirectory(distDir)
+const generateSRIHashes = async (logger, { distDir, sriHashesModule }) => {
+	const hashes = await scanDirectory(logger, distDir, distDir)
+
+	// TODO: Remove temporary hack
+	await scanForNestedScripts(distDir, hashes.extScriptHashes)
 
 	const inlineScriptHashes = Array.from(hashes.inlineScriptHashes).sort()
 	const inlineStyleHashes = Array.from(hashes.inlineStyleHashes).sort()
+	const extScriptHashes = Array.from(hashes.extScriptHashes).sort()
+	const extStyleHashes = Array.from(hashes.extStyleHashes).sort()
 
 	if (!sriHashesModule) {
 		return
@@ -187,22 +329,32 @@ const generateSRIHashes = async ({ distDir, sriHashesModule }) => {
 		const hashesModule = /** @type {{
 			inlineScriptHashes?: string[] | undefined
 			inlineStyleHashes?: string[] | undefined
+			extScriptHashes?: string[] | undefined
+			extStyleHashes?: string[] | undefined
 		}} */ (await import(sriHashesModule))
 
 		persistHashes =
 			!arraysEqual(inlineScriptHashes, hashesModule.inlineScriptHashes ?? []) ||
-			!arraysEqual(inlineStyleHashes, hashesModule.inlineStyleHashes ?? [])
+			!arraysEqual(inlineStyleHashes, hashesModule.inlineStyleHashes ?? []) ||
+			!arraysEqual(extScriptHashes, hashesModule.extScriptHashes ?? []) ||
+			!arraysEqual(extStyleHashes, hashesModule.extStyleHashes ?? [])
 	} else {
 		persistHashes = true
 	}
 
 	if (persistHashes) {
 		let hashesFileContent = '// Do not edit this file manually\n\n'
-		hashesFileContent += `export const inlineScriptHashes = /** @type {const} */ (${JSON.stringify(
+		hashesFileContent += `export const inlineScriptHashes = /** @type {string[]} */ (${JSON.stringify(
 			inlineScriptHashes,
 		)})\n\n`
-		hashesFileContent += `export const inlineStyleHashes = /** @type {const} */ (${JSON.stringify(
+		hashesFileContent += `export const inlineStyleHashes = /** @type {string[]} */ (${JSON.stringify(
 			inlineStyleHashes,
+		)})\n\n`
+		hashesFileContent += `export const extScriptHashes = /** @type {string[]} */ (${JSON.stringify(
+			extScriptHashes,
+		)})\n\n`
+		hashesFileContent += `export const extStyleHashes = /** @type {string[]} */ (${JSON.stringify(
+			extStyleHashes,
 		)})\n`
 
 		await writeFile(sriHashesModule, hashesFileContent)
@@ -217,8 +369,8 @@ export const sriCSP = sriCspOptions =>
 	/** @type {import('astro').AstroIntegration} */ ({
 		name: 'scp-sri-postbuild',
 		hooks: {
-			'astro:build:done': async ({ dir }) =>
-				await generateSRIHashes({
+			'astro:build:done': async ({ dir, logger }) =>
+				await generateSRIHashes(logger, {
 					distDir: fileURLToPath(dir),
 					sriHashesModule: sriCspOptions.sriHashesModule,
 				}),
diff --git a/package.json b/package.json
index 83381e2..4286f7d 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
 	"name": "@kindspells/astro-sri-csp",
-	"version": "0.2.1",
+	"version": "0.3.0",
 	"description": "An Astro plugin to compute and inject SRI hashes for script and style tags",
 	"private": false,
 	"type": "module",
diff --git a/tsconfig.json b/tsconfig.json
index 21e9859..8bb8601 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -28,7 +28,7 @@
 		"exactOptionalPropertyTypes": true,
 		"noUncheckedIndexedAccess": true,
 		"noImplicitOverride": true,
-		"noPropertyAccessFromIndexSignature": true,
+		"noPropertyAccessFromIndexSignature": false,
 
 		"skipLibCheck": true
 	},