@ringozz/godot 4.7.2-614 → 4.7.2-616

package/src/preload.ts

@@ -1,253 +1,253 @@
-/**********************************************************************
- Copyright (c) Vladimir Davidovich. All rights reserved.
-***********************************************************************/
-
-import { existsSync, readFileSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-import { plugin } from 'bun';
-import type { BunPlugin } from 'bun';
-
-// Registers the godot-assets plugin: imports of Godot source assets become
-// virtual modules (namespace `godot`) that call `loadAsset` (`@ringozz/godot/load`)
-// and export the resulting `materialize` (own + deps' files) and load promise.
-// `loadAsset` checks the engine's `ResourceCache` once; when the asset is
-// already loaded (e.g. a re-evaluated module under web HMR) the load resolves to
-// the cached instance and `materialize` short-circuits, skipping file staging
-// and the threaded load. The load promise persists on the module's
-// `import.meta.hot.data` (per-module state carried across hot replacements), so
-// HMR re-evaluations return the *same* fulfilled promise object — React's `use()`
-// keeps its tracked status and never re-suspends (no Suspense fallback flash); a
-// rejected load is evicted from `data` so the next evaluation retries; on
-// desktop `data` is `{}` and modules evaluate once. Dependencies are generated
-// modules too, so a dep's load starts at module evaluation while the parent only
-// waits for dep *files*. The default export is the single plugin — registered
-// globally via bunfig preload and loaded by `[serve.static] plugins` for
-// `Bun.serve` HTML routes.
-
-const ROOT = process.cwd();
-const NS = 'godot';
-
-/** Format metadata: `cls` = Godot class (importable), `scan` = scan text refs, `native` = no `.import` sidecar. */
-const FORMATS: Record<string, { cls?: string; scan?: boolean; native?: boolean }> = {
-	gltf: { cls: 'PackedScene', scan: true },
-	tscn: { cls: 'PackedScene', scan: true, native: true },
-	obj: { cls: 'PackedScene', scan: true },
-	gd: { cls: 'GDScript', scan: true, native: true },
-	jpg: { cls: 'CompressedTexture2D' },
-	jpeg: { cls: 'CompressedTexture2D' },
-	png: { cls: 'CompressedTexture2D' },
-	webp: { cls: 'CompressedTexture2D' },
-	svg: { cls: 'CompressedTexture2D' },
-	exr: { cls: 'TextureLayered' },
-	hdr: { cls: 'TextureLayered' },
-	wav: { cls: 'AudioStreamWAV' },
-	ogg: { cls: 'AudioStreamOggVorbis' },
-	mp3: { cls: 'AudioStreamMP3' },
-	tres: { cls: 'Resource', scan: true, native: true },
-	po: { cls: 'Translation', native: true },
-	ttf: { cls: 'FontFile' },
-	otf: { cls: 'FontFile' },
-	mtl: { scan: true },
-};
-
-const ASSET_RE = new RegExp(
-	`\\.(${Object.entries(FORMATS).filter(([, f]) => f.cls).map(([k]) => k).join('|')})$`,
-	'i',
-);
-const CLASS_BY_EXT: Record<string, string> = Object.fromEntries(
-	Object.entries(FORMATS).filter(([, f]) => f.cls).map(([k, f]) => [k, f.cls!]),
-);
-const SCANNED = new Set(Object.entries(FORMATS).filter(([, f]) => f.scan).map(([k]) => k));
-const NATIVE = new Set(Object.entries(FORMATS).filter(([, f]) => f.native).map(([k]) => k));
-
-const extOf = (abs: string) => abs.slice(abs.lastIndexOf('.') + 1).toLowerCase();
-const resOf = (abs: string) => 'res://' + abs.slice(ROOT.length + 1).replaceAll('\\', '/');
-const isScannableText = (abs: string) => SCANNED.has(extOf(abs));
-const isNativeText = (abs: string) => NATIVE.has(extOf(abs));
-const isSourceAsset = (abs: string) => existsSync(abs + '.import') || isNativeText(abs);
-
-/** Reads the imported destination (`dest_files`) out of an `.import` sidecar. */
-function parseSidecarDest(text: string): string | null {
-	const deps = text.match(/^dest_files=\[([^\]]*)\]/m);
-	if (deps) {
-		const first = deps[1].match(/"([^"]+)"/);
-		if (first) {
-			return first[1];
-		}
-	}
-	const remap = text.match(/^path="([^"]+)"/m);
-	return remap ? remap[1] : null;
-}
-
-// Reference extraction for text-based source assets: absolute `res://` paths
-// (Godot scenes/resources) and relative path tokens ending in a known asset
-// extension (glTF uris, OBJ/MTL textures). The literal dot before the extension
-// avoids matching MIME types inside `data:` URIs. Regexes are built fresh per
-// call: a `/g` instance is stateful, and reusing one module-level regex across
-// many files misbehaves under the dev server's bundler (a stale lastIndex
-// shifted a scan's results). The `//` fragment right after `res:` is a mere
-// path remainder of the `res://` match, not a real relative ref, so it's
-// skipped (otherwise it mis-resolves as a Windows UNC `\\…` path).
-//
-// The extension must TERMINATE a token: `(?![\w.])` rejects matches where the
-// extension is only the head of a longer identifier or a dotted sub-field, e.g.
-// `X.po` in `X.position`, `foo.gd` in `foo.gd.position`, or `scene.tscn2`. A
-// real relative ref (`foo.po`, `x.gd`, `ui/scene.tscn`) always ends its token.
-// `String.raw` keeps the `\w` escapes intact — a plain template literal would
-// drop the backslashes, turning `\w` into `w` (a wrong guard `(?![w.])`).
-const REL_TERM = String.raw`(?![\w.])`;
-const REL_PATTERN = String.raw`([\w./\\-]+\.(?:` + Object.keys(FORMATS).join('|') + `))` + REL_TERM;
-function extractRefs(text: string): string[] {
-	const refs: string[] = [];
-	for (const m of text.matchAll(/res:\/\/[\w./\\-]+/g)) refs.push(m[0]);
-	const rel = new RegExp(REL_PATTERN, 'g');
-	for (const m of text.matchAll(rel)) if (!m[1].startsWith('/')) refs.push(m[1]);
-	return refs;
-}
-
-/**
- * Adds a source asset's own files to `files`: imported assets contribute their
- * `.import` sidecar (text) + imported product (file); native text formats
- * (tscn/tres/po/gd) contribute the file itself (text).
- */
-function addSource(srcAbs: string, files: Map<string, 'text' | 'file'>): void {
-	const impAbs = srcAbs + '.import';
-	if (existsSync(impAbs)) {
-		files.set(resOf(srcAbs) + '.import', 'text');
-		const dest = parseSidecarDest(readFileSync(impAbs, 'utf8'));
-		if (dest) {
-			files.set(dest, 'file');
-		}
-	} else if (isNativeText(srcAbs)) {
-		stageNativeText(srcAbs, files);
-	}
-}
-
-/** Stages a native text source (`res://` path → `text`) so web staging + inlining picks it up. */
-function stageNativeText(srcAbs: string, files: Map<string, 'text' | 'file'>): void {
-	files.set(resOf(srcAbs), 'text');
-}
-
-/**
- * Collects the referenced source assets (deps) of a text source: every referenced
- * source asset is staged (native text → `files`, products → dep modules), and
- * loadable source assets also become dep modules so their own files + transitive
- * deps are handled. Raw text formats without a sidecar (`.mtl`) are recursed into.
- * Buffers (`.bin`) are skipped.
- */
-function collectDeps(abs: string, visited: Set<string>, deps: string[], files: Map<string, 'text' | 'file'>): void {
-	if (visited.has(abs)) {
-		return;
-	}
-	visited.add(abs);
-	if (!isScannableText(abs)) {
-		return;
-	}
-	for (const ref of extractRefs(readFileSync(abs, 'utf8'))) {
-		const refAbs = ref.startsWith('res://')
-			? resolve(ROOT, ref.slice('res://'.length))
-			: resolve(dirname(abs), ref);
-		if (visited.has(refAbs)) {
-			continue;
-		}
-		// Stage native text (e.g. `.gd`, nested `.tscn`) so the engine loads it
-		// by `res://` on web (idempotent); loadable assets also become dep
-		// modules for their own files + transitive deps.
-		if (isSourceAsset(refAbs)) {
-			if (isNativeText(refAbs)) {
-				visited.add(refAbs);
-				stageNativeText(refAbs, files);
-			}
-			if (CLASS_BY_EXT[extOf(refAbs)]) {
-				deps.push(refAbs);
-			}
-		}
-		// Any scannable ref (a source's own text, or a raw leaf like `.mtl`) is
-		// recursed into so its internal `res://` refs are traced/staged too.
-		if (isScannableText(refAbs)) {
-			collectDeps(refAbs, visited, deps, files);
-		}
-	}
-}
-
-function analyze(abs: string): { files: Map<string, 'text' | 'file'>; deps: string[] } {
-	const files = new Map<string, 'text' | 'file'>();
-	const deps: string[] = [];
-	addSource(abs, files);
-	collectDeps(abs, new Set(), deps, files);
-	return { files, deps };
-}
-
-function ensureModule(abs: string): string {
-	const res = resOf(abs);
-	const cls = CLASS_BY_EXT[extOf(abs)] ?? 'Resource';
-	const { files, deps } = analyze(abs);
-
-	const imports = [
-		`import { loadAsset } from '@ringozz/godot/load';`,
-		`import { ${cls} } from '@ringozz/godot/${cls}';`,
-	];
-	const map: string[] = [];
-	let fi = 0;
-	// Text files (own `.tscn`/`.tres`/`.po`, `.import` sidecars, staged `.gd`
-	// leaves) are inlined as string literals — Bun's `with { type: 'text' }`
-	// import resolves to a null/default under the dev server's HMR wrapper for
-	// a module's own path; products (`.scn`/`.ctex`) are fetched by path.
-	for (const [resPath, kind] of files) {
-		const absP = resolve(ROOT, resPath.slice('res://'.length));
-		if (kind === 'text') {
-			map.push(`  ${JSON.stringify(resPath)}: { content: ${JSON.stringify(readFileSync(absP, 'utf8'))} },`);
-			continue;
-		}
-		const v = `f${fi++}`;
-		imports.push(`import ${v} from ${JSON.stringify(absP)} with { type: 'file' };`);
-		map.push(`  ${JSON.stringify(resPath)}: { path: ${v} },`);
-	}
-	deps.forEach((dep, i) => imports.push(`import * as dep${i} from ${JSON.stringify(dep)};`));
-
-	const filesVar = files.size ? `const files = {\n${map.join('\n')}\n};` : `const files = {};`;
-	const loadAsset = `const { materialize, load } = loadAsset(${JSON.stringify(res)}, ${cls}, files, [${deps.map((_, i) => `dep${i}`).join(', ')}], import.meta.hot.data);`;
-	return imports.join('\n') + '\n' + filesVar + '\n' + loadAsset + '\n' + `export { materialize, load as default };` + '\n';
-}
-
-const assetPlugin: BunPlugin = {
-	name: 'godot-assets',
-	setup(build) {
-		build.onResolve({ filter: ASSET_RE }, (args) => {
-			// Only JS module imports of Godot source assets become `godot`
-			// modules. `Bun.build` reports JS imports as `import-statement`
-			// (and `dynamic-import`/`require-*`) but HTML asset references
-			// (<link>/<img>) and CSS url() refs as `internal`/`url-token` —
-			// those fall through so Bun copies/hashes the file normally. The
-			// runtime preload (bun run / bun test) reports JS imports with no
-			// kind (`undefined`), so treat that as a JS import too.
-			if (
-				args.kind !== undefined &&
-				args.kind !== 'import-statement' &&
-				args.kind !== 'dynamic-import' &&
-				args.kind !== 'require-call' &&
-				args.kind !== 'require-resolve'
-			) {
-				return;
-			}
-			const importerAbs = args.importer?.startsWith(`${NS}:`)
-				? args.importer.slice(NS.length + 1)
-				: args.importer;
-			const base = importerAbs ? dirname(importerAbs) : (args.resolveDir ?? ROOT);
-			const abs = resolve(base, args.path);
-			// A module's own native-text source (e.g. `.tscn`) self-imports the
-			// same path — let it load as a real file.
-			if (abs === importerAbs) {
-				return;
-			}
-			return { path: abs, namespace: NS };
-		});
-		build.onLoad({ filter: /.*/, namespace: NS }, (args) => ({
-			contents: ensureModule(args.path),
-			loader: 'js',
-		}));
-	},
-};
-
-export default assetPlugin;
-plugin(assetPlugin);
+/**********************************************************************
+ Copyright (c) Vladimir Davidovich. All rights reserved.
+***********************************************************************/
+
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { plugin } from 'bun';
+import type { BunPlugin } from 'bun';
+
+// Registers the godot-assets plugin: imports of Godot source assets become
+// virtual modules (namespace `godot`) that call `loadAsset` (`@ringozz/godot/load`)
+// and export the resulting `materialize` (own + deps' files) and load promise.
+// `loadAsset` checks the engine's `ResourceCache` once; when the asset is
+// already loaded (e.g. a re-evaluated module under web HMR) the load resolves to
+// the cached instance and `materialize` short-circuits, skipping file staging
+// and the threaded load. The load promise persists on the module's
+// `import.meta.hot.data` (per-module state carried across hot replacements), so
+// HMR re-evaluations return the *same* fulfilled promise object — React's `use()`
+// keeps its tracked status and never re-suspends (no Suspense fallback flash); a
+// rejected load is evicted from `data` so the next evaluation retries; on
+// desktop `data` is `{}` and modules evaluate once. Dependencies are generated
+// modules too, so a dep's load starts at module evaluation while the parent only
+// waits for dep *files*. The default export is the single plugin — registered
+// globally via bunfig preload and loaded by `[serve.static] plugins` for
+// `Bun.serve` HTML routes.
+
+const ROOT = process.cwd();
+const NS = 'godot';
+
+/** Format metadata: `cls` = Godot class (importable), `scan` = scan text refs, `native` = no `.import` sidecar. */
+const FORMATS: Record<string, { cls?: string; scan?: boolean; native?: boolean }> = {
+	gltf: { cls: 'PackedScene', scan: true },
+	tscn: { cls: 'PackedScene', scan: true, native: true },
+	obj: { cls: 'PackedScene', scan: true },
+	gd: { cls: 'GDScript', scan: true, native: true },
+	jpg: { cls: 'CompressedTexture2D' },
+	jpeg: { cls: 'CompressedTexture2D' },
+	png: { cls: 'CompressedTexture2D' },
+	webp: { cls: 'CompressedTexture2D' },
+	svg: { cls: 'CompressedTexture2D' },
+	exr: { cls: 'TextureLayered' },
+	hdr: { cls: 'TextureLayered' },
+	wav: { cls: 'AudioStreamWAV' },
+	ogg: { cls: 'AudioStreamOggVorbis' },
+	mp3: { cls: 'AudioStreamMP3' },
+	tres: { cls: 'Resource', scan: true, native: true },
+	po: { cls: 'Translation', native: true },
+	ttf: { cls: 'FontFile' },
+	otf: { cls: 'FontFile' },
+	mtl: { scan: true },
+};
+
+const ASSET_RE = new RegExp(
+	`\\.(${Object.entries(FORMATS).filter(([, f]) => f.cls).map(([k]) => k).join('|')})$`,
+	'i',
+);
+const CLASS_BY_EXT: Record<string, string> = Object.fromEntries(
+	Object.entries(FORMATS).filter(([, f]) => f.cls).map(([k, f]) => [k, f.cls!]),
+);
+const SCANNED = new Set(Object.entries(FORMATS).filter(([, f]) => f.scan).map(([k]) => k));
+const NATIVE = new Set(Object.entries(FORMATS).filter(([, f]) => f.native).map(([k]) => k));
+
+const extOf = (abs: string) => abs.slice(abs.lastIndexOf('.') + 1).toLowerCase();
+const resOf = (abs: string) => 'res://' + abs.slice(ROOT.length + 1).replaceAll('\\', '/');
+const isScannableText = (abs: string) => SCANNED.has(extOf(abs));
+const isNativeText = (abs: string) => NATIVE.has(extOf(abs));
+const isSourceAsset = (abs: string) => existsSync(abs + '.import') || isNativeText(abs);
+
+/** Reads the imported destination (`dest_files`) out of an `.import` sidecar. */
+function parseSidecarDest(text: string): string | null {
+	const deps = text.match(/^dest_files=\[([^\]]*)\]/m);
+	if (deps) {
+		const first = deps[1].match(/"([^"]+)"/);
+		if (first) {
+			return first[1];
+		}
+	}
+	const remap = text.match(/^path="([^"]+)"/m);
+	return remap ? remap[1] : null;
+}
+
+// Reference extraction for text-based source assets: absolute `res://` paths
+// (Godot scenes/resources) and relative path tokens ending in a known asset
+// extension (glTF uris, OBJ/MTL textures). The literal dot before the extension
+// avoids matching MIME types inside `data:` URIs. Regexes are built fresh per
+// call: a `/g` instance is stateful, and reusing one module-level regex across
+// many files misbehaves under the dev server's bundler (a stale lastIndex
+// shifted a scan's results). The `//` fragment right after `res:` is a mere
+// path remainder of the `res://` match, not a real relative ref, so it's
+// skipped (otherwise it mis-resolves as a Windows UNC `\\…` path).
+//
+// The extension must TERMINATE a token: `(?![\w.])` rejects matches where the
+// extension is only the head of a longer identifier or a dotted sub-field, e.g.
+// `X.po` in `X.position`, `foo.gd` in `foo.gd.position`, or `scene.tscn2`. A
+// real relative ref (`foo.po`, `x.gd`, `ui/scene.tscn`) always ends its token.
+// `String.raw` keeps the `\w` escapes intact — a plain template literal would
+// drop the backslashes, turning `\w` into `w` (a wrong guard `(?![w.])`).
+const REL_TERM = String.raw`(?![\w.])`;
+const REL_PATTERN = String.raw`([\w./\\-]+\.(?:` + Object.keys(FORMATS).join('|') + `))` + REL_TERM;
+function extractRefs(text: string): string[] {
+	const refs: string[] = [];
+	for (const m of text.matchAll(/res:\/\/[\w./\\-]+/g)) refs.push(m[0]);
+	const rel = new RegExp(REL_PATTERN, 'g');
+	for (const m of text.matchAll(rel)) if (!m[1].startsWith('/')) refs.push(m[1]);
+	return refs;
+}
+
+/**
+ * Adds a source asset's own files to `files`: imported assets contribute their
+ * `.import` sidecar (text) + imported product (file); native text formats
+ * (tscn/tres/po/gd) contribute the file itself (text).
+ */
+function addSource(srcAbs: string, files: Map<string, 'text' | 'file'>): void {
+	const impAbs = srcAbs + '.import';
+	if (existsSync(impAbs)) {
+		files.set(resOf(srcAbs) + '.import', 'text');
+		const dest = parseSidecarDest(readFileSync(impAbs, 'utf8'));
+		if (dest) {
+			files.set(dest, 'file');
+		}
+	} else if (isNativeText(srcAbs)) {
+		stageNativeText(srcAbs, files);
+	}
+}
+
+/** Stages a native text source (`res://` path → `text`) so web staging + inlining picks it up. */
+function stageNativeText(srcAbs: string, files: Map<string, 'text' | 'file'>): void {
+	files.set(resOf(srcAbs), 'text');
+}
+
+/**
+ * Collects the referenced source assets (deps) of a text source: every referenced
+ * source asset is staged (native text → `files`, products → dep modules), and
+ * loadable source assets also become dep modules so their own files + transitive
+ * deps are handled. Raw text formats without a sidecar (`.mtl`) are recursed into.
+ * Buffers (`.bin`) are skipped.
+ */
+function collectDeps(abs: string, visited: Set<string>, deps: string[], files: Map<string, 'text' | 'file'>): void {
+	if (visited.has(abs)) {
+		return;
+	}
+	visited.add(abs);
+	if (!isScannableText(abs)) {
+		return;
+	}
+	for (const ref of extractRefs(readFileSync(abs, 'utf8'))) {
+		const refAbs = ref.startsWith('res://')
+			? resolve(ROOT, ref.slice('res://'.length))
+			: resolve(dirname(abs), ref);
+		if (visited.has(refAbs)) {
+			continue;
+		}
+		// Stage native text (e.g. `.gd`, nested `.tscn`) so the engine loads it
+		// by `res://` on web (idempotent); loadable assets also become dep
+		// modules for their own files + transitive deps.
+		if (isSourceAsset(refAbs)) {
+			if (isNativeText(refAbs)) {
+				visited.add(refAbs);
+				stageNativeText(refAbs, files);
+			}
+			if (CLASS_BY_EXT[extOf(refAbs)]) {
+				deps.push(refAbs);
+			}
+		}
+		// Any scannable ref (a source's own text, or a raw leaf like `.mtl`) is
+		// recursed into so its internal `res://` refs are traced/staged too.
+		if (isScannableText(refAbs)) {
+			collectDeps(refAbs, visited, deps, files);
+		}
+	}
+}
+
+function analyze(abs: string): { files: Map<string, 'text' | 'file'>; deps: string[] } {
+	const files = new Map<string, 'text' | 'file'>();
+	const deps: string[] = [];
+	addSource(abs, files);
+	collectDeps(abs, new Set(), deps, files);
+	return { files, deps };
+}
+
+function ensureModule(abs: string): string {
+	const res = resOf(abs);
+	const cls = CLASS_BY_EXT[extOf(abs)] ?? 'Resource';
+	const { files, deps } = analyze(abs);
+
+	const imports = [
+		`import { loadAsset } from '@ringozz/godot/load';`,
+		`import { ${cls} } from '@ringozz/godot/${cls}';`,
+	];
+	const map: string[] = [];
+	let fi = 0;
+	// Text files (own `.tscn`/`.tres`/`.po`, `.import` sidecars, staged `.gd`
+	// leaves) are inlined as string literals — Bun's `with { type: 'text' }`
+	// import resolves to a null/default under the dev server's HMR wrapper for
+	// a module's own path; products (`.scn`/`.ctex`) are fetched by path.
+	for (const [resPath, kind] of files) {
+		const absP = resolve(ROOT, resPath.slice('res://'.length));
+		if (kind === 'text') {
+			map.push(`  ${JSON.stringify(resPath)}: { content: ${JSON.stringify(readFileSync(absP, 'utf8'))} },`);
+			continue;
+		}
+		const v = `f${fi++}`;
+		imports.push(`import ${v} from ${JSON.stringify(absP)} with { type: 'file' };`);
+		map.push(`  ${JSON.stringify(resPath)}: { path: ${v} },`);
+	}
+	deps.forEach((dep, i) => imports.push(`import * as dep${i} from ${JSON.stringify(dep)};`));
+
+	const filesVar = files.size ? `const files = {\n${map.join('\n')}\n};` : `const files = {};`;
+	const loadAsset = `const { materialize, load } = loadAsset(${JSON.stringify(res)}, ${cls}, files, [${deps.map((_, i) => `dep${i}`).join(', ')}], import.meta.hot.data);`;
+	return imports.join('\n') + '\n' + filesVar + '\n' + loadAsset + '\n' + `export { materialize, load as default };` + '\n';
+}
+
+const assetPlugin: BunPlugin = {
+	name: 'godot-assets',
+	setup(build) {
+		build.onResolve({ filter: ASSET_RE }, (args) => {
+			// Only JS module imports of Godot source assets become `godot`
+			// modules. `Bun.build` reports JS imports as `import-statement`
+			// (and `dynamic-import`/`require-*`) but HTML asset references
+			// (<link>/<img>) and CSS url() refs as `internal`/`url-token` —
+			// those fall through so Bun copies/hashes the file normally. The
+			// runtime preload (bun run / bun test) reports JS imports with no
+			// kind (`undefined`), so treat that as a JS import too.
+			if (
+				args.kind !== undefined &&
+				args.kind !== 'import-statement' &&
+				args.kind !== 'dynamic-import' &&
+				args.kind !== 'require-call' &&
+				args.kind !== 'require-resolve'
+			) {
+				return;
+			}
+			const importerAbs = args.importer?.startsWith(`${NS}:`)
+				? args.importer.slice(NS.length + 1)
+				: args.importer;
+			const base = importerAbs ? dirname(importerAbs) : (args.resolveDir ?? ROOT);
+			const abs = resolve(base, args.path);
+			// A module's own native-text source (e.g. `.tscn`) self-imports the
+			// same path — let it load as a real file.
+			if (abs === importerAbs) {
+				return;
+			}
+			return { path: abs, namespace: NS };
+		});
+		build.onLoad({ filter: /.*/, namespace: NS }, (args) => ({
+			contents: ensureModule(args.path),
+			loader: 'js',
+		}));
+	},
+};
+
+export default assetPlugin;
+plugin(assetPlugin);