@ryanatkn/gro 0.133.5 → 0.133.6

package/dist/gro.js

@@ -15,5 +15,5 @@ const invoke_path = resolve_gro_module_path('invoke.js');
 const loader_path = join(invoke_path, '../loader.js');
 const spawned = await spawn_with_loader(loader_path, invoke_path, process.argv.slice(2));
 if (!spawned.ok) {
-    process.exit(spawned.code || 1); // eslint-disable-line @typescript-eslint/prefer-nullish-coalescing
+    process.exitCode = spawned.code || 1; // eslint-disable-line @typescript-eslint/prefer-nullish-coalescing
 }

package/dist/loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loader.d.ts","sourceRoot":"../src/lib/","sources":["loader.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,QAAQ,EAAE,WAAW,EAAC,MAAM,aAAa,CAAC;AA+EvD,eAAO,MAAM,IAAI,EAAE,QAsFlB,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,WAoDrB,CAAC"}
+{"version":3,"file":"loader.d.ts","sourceRoot":"../src/lib/","sources":["loader.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,QAAQ,EAAE,WAAW,EAAC,MAAM,aAAa,CAAC;AA+EvD,eAAO,MAAM,IAAI,EAAE,QAwFlB,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,WA4DrB,CAAC"}

package/dist/loader.js

@@ -3,6 +3,7 @@ import { compile, compileModule, preprocess } from 'svelte/compiler';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { dirname, join } from 'node:path';
 import { escape_regexp } from '@ryanatkn/belt/regexp.js';
+import { readFileSync } from 'node:fs';
 import { render_env_shim_module } from './sveltekit_shim_env.js';
 import { render_sveltekit_shim_app_environment, render_sveltekit_shim_app_paths, SVELTEKIT_SHIM_APP_ENVIRONMENT_MATCHER, SVELTEKIT_SHIM_APP_PATHS_MATCHER, sveltekit_shim_app_specifiers, } from './sveltekit_shim_app.js';
 import { default_sveltekit_config } from './sveltekit_config.js';
@@ -35,8 +36,7 @@ node --import 'data:text/javascript,import {register} from "node:module"; import
 TODO how to improve that gnarly import line? was originally designed for the now-deprecated `--loader`
 
 */
-// TODO support `?raw` import variants
-// TODO sourcemaps for svelte and the svelte preprocessors
+// TODO sourcemaps for the svelte preprocessors
 // TODO `import.meta.resolve` wasn't available in loaders when this was first implemented, but might be now
 // dev is always true in the loader
 const dev = true;
@@ -48,7 +48,7 @@ const ts_transform_options = {
     sourcemap: 'inline',
 };
 const aliases = Object.entries({ $lib: 'src/lib', ...alias });
-const NOOP_MATCHER = /\.(css|svg)$/; // TODO others? configurable?
+const RAW_MATCHER = /(%3Fraw|\.css|\.svg)$/; // TODO others? configurable?
 const ENV_MATCHER = /src\/lib\/\$env\/(static|dynamic)\/(public|private)$/;
 const NODE_MODULES_MATCHER = new RegExp(escape_regexp('/' + NODE_MODULES_DIRNAME + '/'), 'u');
 const package_json_cache = {};
@@ -89,10 +89,9 @@ export const load = async (url, context, nextLoad) => {
     }
     else if (SVELTE_MATCHER.test(url)) {
         // Svelte
-        // TODO support sourcemaps
         const loaded = await nextLoad(url, context.format === 'module' ? context : { ...context, format: 'module' });
-        const filename = fileURLToPath(url);
         const raw_source = loaded.source.toString(); // eslint-disable-line @typescript-eslint/no-base-to-string
+        const filename = fileURLToPath(url);
         const preprocessed = svelte_preprocessors // TODO @many use sourcemaps (and diagnostics?)
             ? await preprocess(raw_source, svelte_preprocessors, { filename })
             : null;
@@ -108,9 +107,11 @@ export const load = async (url, context, nextLoad) => {
         const source = `export default ` + raw_source;
         return { format: 'module', shortCircuit: true, source };
     }
-    else if (NOOP_MATCHER.test(url)) {
-        // no-ops like `.css` and `.svg`
-        const source = `export default 'no-op import from ${url}'`;
+    else if (RAW_MATCHER.test(url)) {
+        // raw text imports like `?raw`, `.css`, `.svg`
+        const filename = fileURLToPath(url.endsWith('%3Fraw') ? url.substring(0, url.length - 6) : url);
+        const raw_source = readFileSync(filename, 'utf8');
+        const source = 'export default `' + raw_source.replaceAll('\\', '\\\\').replaceAll('`', '\\`') + '`;';
         return { format: 'module', shortCircuit: true, source };
     }
     else {
@@ -163,14 +164,22 @@ export const resolve = async (specifier, context, nextResolve) => {
         // Resolve to `node_modules`.
         if (SVELTE_MATCHER.test(path) || JSON_MATCHER.test(path)) {
             // Match the behavior of Vite and esbuild for Svelte and JSON imports.
-            // TODO maybe `.ts` too
-            const path_id = resolve_node_specifier(path, dir, parent_url, package_json_cache);
-            return { url: pathToFileURL(path_id).href, format: 'module', shortCircuit: true };
+            // TODO `.ts` too
+            const resolved = resolve_node_specifier(path, dir, parent_url, package_json_cache);
+            return {
+                url: pathToFileURL(resolved.path_id_with_querystring).href,
+                format: 'module',
+                shortCircuit: true,
+            };
         }
         else {
             return nextResolve(path, context);
         }
     }
-    const { path_id } = resolve_specifier(path, dirname(fileURLToPath(parent_url)));
-    return { url: pathToFileURL(path_id).href, format: 'module', shortCircuit: true };
+    const resolved = resolve_specifier(path, dirname(fileURLToPath(parent_url)));
+    return {
+        url: pathToFileURL(resolved.path_id_with_querystring).href,
+        format: 'module',
+        shortCircuit: true,
+    };
 };

package/dist/package.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"package.d.ts","sourceRoot":"../src/lib/","sources":["package.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqQD,CAAC;AAEzB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyuBD,CAAC"}
+{"version":3,"file":"package.d.ts","sourceRoot":"../src/lib/","sources":["package.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqQD,CAAC;AAEzB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAquBD,CAAC"}

package/dist/package.js

@@ -1,7 +1,7 @@
 // generated by src/lib/package.gen.ts
 export const package_json = {
     name: '@ryanatkn/gro',
-    version: '0.133.5',
+    version: '0.133.6',
     description: 'task runner and toolkit extending SvelteKit',
     motto: 'generate, run, optimize',
     glyph: '🌰',
@@ -56,18 +56,18 @@ export const package_json = {
         '@changesets/changelog-git': '^0.2.0',
         '@changesets/types': '^6.0.0',
         '@ryanatkn/eslint-config': '^0.4.2',
-        '@ryanatkn/fuz': '^0.118.2',
-        '@ryanatkn/moss': '^0.11.1',
+        '@ryanatkn/fuz': '^0.119.0',
+        '@ryanatkn/moss': '^0.12.0',
         '@sveltejs/adapter-static': '^3.0.2',
         '@sveltejs/kit': '^2.5.18',
         '@sveltejs/package': '^2.3.2',
         '@sveltejs/vite-plugin-svelte': '^3.1.1',
         '@types/fs-extra': '^11.0.4',
-        '@types/node': '^20.14.11',
+        '@types/node': '^20.14.12',
         esbuild: '^0.21.5',
         eslint: '^9.7.0',
         'eslint-plugin-svelte': '^2.43.0',
-        svelte: '^5.0.0-next.195',
+        svelte: '^5.0.0-next.197',
         'svelte-check': '^3.8.4',
         typescript: '^5.5.4',
         'typescript-eslint': '^8.0.0-alpha.44',
@@ -262,7 +262,7 @@ export const package_json = {
 };
 export const src_json = {
     name: '@ryanatkn/gro',
-    version: '0.133.5',
+    version: '0.133.6',
     modules: {
         '.': {
             path: 'index.ts',
@@ -775,11 +775,7 @@ export const src_json = {
         },
         './resolve_node_specifier.js': {
             path: 'resolve_node_specifier.ts',
-            declarations: [
-                { name: 'resolve_node_specifier', kind: 'function' },
-                { name: 'Parsed_Node_Specifier', kind: 'type' },
-                { name: 'parse_node_specifier', kind: 'function' },
-            ],
+            declarations: [{ name: 'resolve_node_specifier', kind: 'function' }],
         },
         './resolve_specifier.js': {
             path: 'resolve_specifier.ts',

package/dist/resolve_node_specifier.d.ts

@@ -1,9 +1,4 @@
 import { Package_Json } from './package_json.js';
-import type { Path_Id } from './path.js';
-export declare const resolve_node_specifier: (specifier: string, dir?: string, parent_url?: string, cache?: Record<string, Package_Json>, exports_key?: string) => Path_Id;
-export interface Parsed_Node_Specifier {
-    name: string;
-    path: string;
-}
-export declare const parse_node_specifier: (specifier: string) => Parsed_Node_Specifier;
+import type { Resolved_Specifier } from './resolve_specifier.js';
+export declare const resolve_node_specifier: (specifier: string, dir?: string, parent_url?: string, cache?: Record<string, Package_Json>, exports_key?: string) => Resolved_Specifier;
 //# sourceMappingURL=resolve_node_specifier.d.ts.map

package/dist/resolve_node_specifier.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolve_node_specifier.d.ts","sourceRoot":"../src/lib/","sources":["resolve_node_specifier.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,YAAY,EAAoB,MAAM,mBAAmB,CAAC;AAClE,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,WAAW,CAAC;AAIvC,eAAO,MAAM,sBAAsB,cACvB,MAAM,6BAEJ,MAAM,UACX,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,2BAElC,OAeF,CAAC;AAEF,MAAM,WAAW,qBAAqB;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACb;AAED,eAAO,MAAM,oBAAoB,cAAe,MAAM,KAAG,qBAmBxD,CAAC"}
+{"version":3,"file":"resolve_node_specifier.d.ts","sourceRoot":"../src/lib/","sources":["resolve_node_specifier.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,YAAY,EAAoB,MAAM,mBAAmB,CAAC;AAGlE,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,wBAAwB,CAAC;AAE/D,eAAO,MAAM,sBAAsB,cACvB,MAAM,6BAEJ,MAAM,UACX,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,2BAElC,kBA0CF,CAAC"}

package/dist/resolve_node_specifier.js

@@ -3,26 +3,14 @@ import { Package_Json, load_package_json } from './package_json.js';
 import { paths } from './paths.js';
 import { NODE_MODULES_DIRNAME } from './path_constants.js';
 export const resolve_node_specifier = (specifier, dir = paths.root, parent_url, cache, exports_key = specifier.endsWith('.svelte') ? 'svelte' : 'default') => {
-    const parsed = parse_node_specifier(specifier);
-    const subpath = './' + parsed.path;
-    const package_dir = join(dir, NODE_MODULES_DIRNAME, parsed.name);
-    const package_json = load_package_json(package_dir, cache);
-    const exported = package_json.exports?.[subpath];
-    if (!exported) {
-        // same error message as Node
-        throw Error(`[ERR_PACKAGE_PATH_NOT_EXPORTED]: Package subpath '${subpath}' is not defined by "exports" in ${package_dir}/package.json` +
-            (parent_url ? ` imported from ${parent_url}` : ''));
-    }
-    const path_id = join(package_dir, exported[exports_key]);
-    return path_id;
-};
-export const parse_node_specifier = (specifier) => {
+    const raw = specifier.endsWith('?raw');
+    const mapped_specifier = raw ? specifier.substring(0, specifier.length - 4) : specifier;
     let idx;
-    if (specifier[0] === '@') {
+    if (mapped_specifier[0] === '@') {
         // get the index of the second `/`
         let count = 0;
-        for (let i = 0; i < specifier.length; i++) {
-            if (specifier[i] === '/')
+        for (let i = 0; i < mapped_specifier.length; i++) {
+            if (mapped_specifier[i] === '/')
                 count++;
             if (count === 2) {
                 idx = i;
@@ -31,10 +19,26 @@ export const parse_node_specifier = (specifier) => {
         }
     }
     else {
-        idx = specifier.indexOf('/');
+        idx = mapped_specifier.indexOf('/');
     }
+    const name = mapped_specifier.substring(0, idx);
+    const path = mapped_specifier.substring(idx + 1);
+    const subpath = './' + path;
+    const package_dir = join(dir, NODE_MODULES_DIRNAME, name);
+    const package_json = load_package_json(package_dir, cache);
+    const exported = package_json.exports?.[subpath];
+    if (!exported) {
+        // same error message as Node
+        throw Error(`[ERR_PACKAGE_PATH_NOT_EXPORTED]: Package subpath '${subpath}' is not defined by "exports" in ${package_dir}/package.json` +
+            (parent_url ? ` imported from ${parent_url}` : ''));
+    }
+    const path_id = join(package_dir, exported[exports_key]);
     return {
-        name: specifier.substring(0, idx),
-        path: specifier.substring(idx + 1),
+        path_id,
+        path_id_with_querystring: raw ? path_id + '?raw' : path_id,
+        raw,
+        specifier,
+        mapped_specifier,
+        namespace: undefined,
     };
 };

package/dist/resolve_specifier.d.ts

@@ -1,17 +1,26 @@
 import type { Path_Id } from './path.js';
 export interface Resolved_Specifier {
-    specifier: string;
+    /**
+     * The resolved filesystem path for the specifier.
+     */
     path_id: Path_Id;
+    /**
+     * Same as `path_id` but includes `?raw` and other querystrings. (currently none)
+     */
+    path_id_with_querystring: string;
+    specifier: string;
+    mapped_specifier: string;
     namespace: undefined | 'sveltekit_local_imports_ts' | 'sveltekit_local_imports_js';
+    raw: boolean;
 }
 /**
  * Maps a `path` import specifier relative to the `importer`,
  * and infer the correct extension following Vite conventions.
  * If no `.js` file is found for the `path` on the filesystem, it assumes `.ts`.
- * @param path
+ * @param specifier
  * @param dir - if defined, enables relative importers like from esbuild plugins
  * @param passthrough_extensions - used to support specifiers that have no file extention, which Vite supports, so we do our best effort
  * @returns
  */
-export declare const resolve_specifier: (path: string, dir: string) => Resolved_Specifier;
+export declare const resolve_specifier: (specifier: string, dir: string) => Resolved_Specifier;
 //# sourceMappingURL=resolve_specifier.d.ts.map

package/dist/resolve_specifier.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolve_specifier.d.ts","sourceRoot":"../src/lib/","sources":["resolve_specifier.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,WAAW,CAAC;AAEvC,MAAM,WAAW,kBAAkB;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,SAAS,GAAG,4BAA4B,GAAG,4BAA4B,CAAC;CACnF;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,SAAU,MAAM,OAAO,MAAM,KAAG,kBAuC7D,CAAC"}
+{"version":3,"file":"resolve_specifier.d.ts","sourceRoot":"../src/lib/","sources":["resolve_specifier.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,WAAW,CAAC;AAEvC,MAAM,WAAW,kBAAkB;IAClC;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;OAEG;IACH,wBAAwB,EAAE,MAAM,CAAC;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;IACzB,SAAS,EAAE,SAAS,GAAG,4BAA4B,GAAG,4BAA4B,CAAC;IACnF,GAAG,EAAE,OAAO,CAAC;CACb;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,cAAe,MAAM,OAAO,MAAM,KAAG,kBAgDlE,CAAC"}

package/dist/resolve_specifier.js

@@ -5,13 +5,15 @@ import { replace_extension } from './paths.js';
  * Maps a `path` import specifier relative to the `importer`,
  * and infer the correct extension following Vite conventions.
  * If no `.js` file is found for the `path` on the filesystem, it assumes `.ts`.
- * @param path
+ * @param specifier
  * @param dir - if defined, enables relative importers like from esbuild plugins
  * @param passthrough_extensions - used to support specifiers that have no file extention, which Vite supports, so we do our best effort
  * @returns
  */
-export const resolve_specifier = (path, dir) => {
-    const absolute_path = isAbsolute(path) ? path : join(dir, path);
+export const resolve_specifier = (specifier, dir) => {
+    const raw = specifier.endsWith('?raw');
+    const final_specifier = raw ? specifier.substring(0, specifier.length - 4) : specifier;
+    const absolute_path = isAbsolute(final_specifier) ? final_specifier : join(dir, final_specifier);
     let mapped_path;
     let path_id;
     let namespace;
@@ -44,8 +46,15 @@ export const resolve_specifier = (path, dir) => {
             namespace = 'sveltekit_local_imports_ts';
         }
     }
-    let specifier = relative(dir, mapped_path);
-    if (specifier[0] !== '.')
-        specifier = './' + specifier;
-    return { specifier, path_id, namespace };
+    let mapped_specifier = relative(dir, mapped_path);
+    if (mapped_specifier[0] !== '.')
+        mapped_specifier = './' + mapped_specifier;
+    return {
+        path_id,
+        path_id_with_querystring: raw ? path_id + '?raw' : path_id,
+        raw,
+        specifier,
+        mapped_specifier,
+        namespace,
+    };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryanatkn/gro",
-  "version": "0.133.5",
+  "version": "0.133.6",
   "description": "task runner and toolkit extending SvelteKit",
   "motto": "generate, run, optimize",
   "glyph": "🌰",
@@ -69,18 +69,18 @@
     "@changesets/changelog-git": "^0.2.0",
     "@changesets/types": "^6.0.0",
     "@ryanatkn/eslint-config": "^0.4.2",
-    "@ryanatkn/fuz": "^0.118.2",
-    "@ryanatkn/moss": "^0.11.1",
+    "@ryanatkn/fuz": "^0.119.0",
+    "@ryanatkn/moss": "^0.12.0",
     "@sveltejs/adapter-static": "^3.0.2",
     "@sveltejs/kit": "^2.5.18",
     "@sveltejs/package": "^2.3.2",
     "@sveltejs/vite-plugin-svelte": "^3.1.1",
     "@types/fs-extra": "^11.0.4",
-    "@types/node": "^20.14.11",
+    "@types/node": "^20.14.12",
     "esbuild": "^0.21.5",
     "eslint": "^9.7.0",
     "eslint-plugin-svelte": "^2.43.0",
-    "svelte": "^5.0.0-next.195",
+    "svelte": "^5.0.0-next.197",
     "svelte-check": "^3.8.4",
     "typescript": "^5.5.4",
     "typescript-eslint": "^8.0.0-alpha.44",

package/src/lib/gro.ts

@@ -21,5 +21,5 @@ const loader_path = join(invoke_path, '../loader.js');
 
 const spawned = await spawn_with_loader(loader_path, invoke_path, process.argv.slice(2));
 if (!spawned.ok) {
-	process.exit(spawned.code || 1); // eslint-disable-line @typescript-eslint/prefer-nullish-coalescing
+	process.exitCode = spawned.code || 1; // eslint-disable-line @typescript-eslint/prefer-nullish-coalescing
 }

package/src/lib/loader.ts

@@ -4,6 +4,7 @@ import {fileURLToPath, pathToFileURL} from 'node:url';
 import {dirname, join} from 'node:path';
 import type {LoadHook, ResolveHook} from 'node:module';
 import {escape_regexp} from '@ryanatkn/belt/regexp.js';
+import {readFileSync} from 'node:fs';
 
 import {render_env_shim_module} from './sveltekit_shim_env.js';
 import {
@@ -46,8 +47,7 @@ TODO how to improve that gnarly import line? was originally designed for the now
 
 */
 
-// TODO support `?raw` import variants
-// TODO sourcemaps for svelte and the svelte preprocessors
+// TODO sourcemaps for the svelte preprocessors
 // TODO `import.meta.resolve` wasn't available in loaders when this was first implemented, but might be now
 
 // dev is always true in the loader
@@ -75,7 +75,7 @@ const ts_transform_options: esbuild.TransformOptions = {
 
 const aliases = Object.entries({$lib: 'src/lib', ...alias});
 
-const NOOP_MATCHER = /\.(css|svg)$/; // TODO others? configurable?
+const RAW_MATCHER = /(%3Fraw|\.css|\.svg)$/; // TODO others? configurable?
 const ENV_MATCHER = /src\/lib\/\$env\/(static|dynamic)\/(public|private)$/;
 const NODE_MODULES_MATCHER = new RegExp(escape_regexp('/' + NODE_MODULES_DIRNAME + '/'), 'u');
 
@@ -120,13 +120,12 @@ export const load: LoadHook = async (url, context, nextLoad) => {
 		return {format: 'module', shortCircuit: true, source: transformed.code};
 	} else if (SVELTE_MATCHER.test(url)) {
 		// Svelte
-		// TODO support sourcemaps
 		const loaded = await nextLoad(
 			url,
 			context.format === 'module' ? context : {...context, format: 'module'}, // TODO dunno why this is needed, specifically with tests
 		);
-		const filename = fileURLToPath(url);
 		const raw_source = loaded.source!.toString(); // eslint-disable-line @typescript-eslint/no-base-to-string
+		const filename = fileURLToPath(url);
 		const preprocessed = svelte_preprocessors // TODO @many use sourcemaps (and diagnostics?)
 			? await preprocess(raw_source, svelte_preprocessors, {filename})
 			: null;
@@ -140,9 +139,12 @@ export const load: LoadHook = async (url, context, nextLoad) => {
 		const raw_source = loaded.source!.toString(); // eslint-disable-line @typescript-eslint/no-base-to-string
 		const source = `export default ` + raw_source;
 		return {format: 'module', shortCircuit: true, source};
-	} else if (NOOP_MATCHER.test(url)) {
-		// no-ops like `.css` and `.svg`
-		const source = `export default 'no-op import from ${url}'`;
+	} else if (RAW_MATCHER.test(url)) {
+		// raw text imports like `?raw`, `.css`, `.svg`
+		const filename = fileURLToPath(url.endsWith('%3Fraw') ? url.substring(0, url.length - 6) : url);
+		const raw_source = readFileSync(filename, 'utf8');
+		const source =
+			'export default `' + raw_source.replaceAll('\\', '\\\\').replaceAll('`', '\\`') + '`;';
 		return {format: 'module', shortCircuit: true, source};
 	} else {
 		const matched_env = ENV_MATCHER.exec(url);
@@ -210,15 +212,23 @@ export const resolve: ResolveHook = async (specifier, context, nextResolve) => {
 		// Resolve to `node_modules`.
 		if (SVELTE_MATCHER.test(path) || JSON_MATCHER.test(path)) {
 			// Match the behavior of Vite and esbuild for Svelte and JSON imports.
-			// TODO maybe `.ts` too
-			const path_id = resolve_node_specifier(path, dir, parent_url, package_json_cache);
-			return {url: pathToFileURL(path_id).href, format: 'module', shortCircuit: true};
+			// TODO `.ts` too
+			const resolved = resolve_node_specifier(path, dir, parent_url, package_json_cache);
+			return {
+				url: pathToFileURL(resolved.path_id_with_querystring).href,
+				format: 'module',
+				shortCircuit: true,
+			};
 		} else {
 			return nextResolve(path, context);
 		}
 	}
 
-	const {path_id} = resolve_specifier(path, dirname(fileURLToPath(parent_url)));
+	const resolved = resolve_specifier(path, dirname(fileURLToPath(parent_url)));
 
-	return {url: pathToFileURL(path_id).href, format: 'module', shortCircuit: true};
+	return {
+		url: pathToFileURL(resolved.path_id_with_querystring).href,
+		format: 'module',
+		shortCircuit: true,
+	};
 };

package/src/lib/package.ts

@@ -5,7 +5,7 @@ import type {Src_Json} from './src_json.js';
 
 export const package_json = {
 	name: '@ryanatkn/gro',
-	version: '0.133.5',
+	version: '0.133.6',
 	description: 'task runner and toolkit extending SvelteKit',
 	motto: 'generate, run, optimize',
 	glyph: '🌰',
@@ -61,18 +61,18 @@ export const package_json = {
 		'@changesets/changelog-git': '^0.2.0',
 		'@changesets/types': '^6.0.0',
 		'@ryanatkn/eslint-config': '^0.4.2',
-		'@ryanatkn/fuz': '^0.118.2',
-		'@ryanatkn/moss': '^0.11.1',
+		'@ryanatkn/fuz': '^0.119.0',
+		'@ryanatkn/moss': '^0.12.0',
 		'@sveltejs/adapter-static': '^3.0.2',
 		'@sveltejs/kit': '^2.5.18',
 		'@sveltejs/package': '^2.3.2',
 		'@sveltejs/vite-plugin-svelte': '^3.1.1',
 		'@types/fs-extra': '^11.0.4',
-		'@types/node': '^20.14.11',
+		'@types/node': '^20.14.12',
 		esbuild: '^0.21.5',
 		eslint: '^9.7.0',
 		'eslint-plugin-svelte': '^2.43.0',
-		svelte: '^5.0.0-next.195',
+		svelte: '^5.0.0-next.197',
 		'svelte-check': '^3.8.4',
 		typescript: '^5.5.4',
 		'typescript-eslint': '^8.0.0-alpha.44',
@@ -268,7 +268,7 @@ export const package_json = {
 
 export const src_json = {
 	name: '@ryanatkn/gro',
-	version: '0.133.5',
+	version: '0.133.6',
 	modules: {
 		'.': {
 			path: 'index.ts',
@@ -781,11 +781,7 @@ export const src_json = {
 		},
 		'./resolve_node_specifier.js': {
 			path: 'resolve_node_specifier.ts',
-			declarations: [
-				{name: 'resolve_node_specifier', kind: 'function'},
-				{name: 'Parsed_Node_Specifier', kind: 'type'},
-				{name: 'parse_node_specifier', kind: 'function'},
-			],
+			declarations: [{name: 'resolve_node_specifier', kind: 'function'}],
 		},
 		'./resolve_specifier.js': {
 			path: 'resolve_specifier.ts',

package/src/lib/resolve_node_specifier.ts

@@ -1,9 +1,9 @@
 import {join} from 'node:path';
 
 import {Package_Json, load_package_json} from './package_json.js';
-import type {Path_Id} from './path.js';
 import {paths} from './paths.js';
 import {NODE_MODULES_DIRNAME} from './path_constants.js';
+import type {Resolved_Specifier} from './resolve_specifier.js';
 
 export const resolve_node_specifier = (
 	specifier: string,
@@ -11,45 +11,46 @@ export const resolve_node_specifier = (
 	parent_url?: string,
 	cache?: Record<string, Package_Json>,
 	exports_key = specifier.endsWith('.svelte') ? 'svelte' : 'default',
-): Path_Id => {
-	const parsed = parse_node_specifier(specifier);
-	const subpath = './' + parsed.path;
-	const package_dir = join(dir, NODE_MODULES_DIRNAME, parsed.name);
-	const package_json = load_package_json(package_dir, cache);
-	const exported = package_json.exports?.[subpath];
-	if (!exported) {
-		// same error message as Node
-		throw Error(
-			`[ERR_PACKAGE_PATH_NOT_EXPORTED]: Package subpath '${subpath}' is not defined by "exports" in ${package_dir}/package.json` +
-				(parent_url ? ` imported from ${parent_url}` : ''),
-		);
-	}
-	const path_id = join(package_dir, exported[exports_key]);
-	return path_id;
-};
-
-export interface Parsed_Node_Specifier {
-	name: string;
-	path: string;
-}
+): Resolved_Specifier => {
+	const raw = specifier.endsWith('?raw');
+	const mapped_specifier = raw ? specifier.substring(0, specifier.length - 4) : specifier;
 
-export const parse_node_specifier = (specifier: string): Parsed_Node_Specifier => {
 	let idx!: number;
-	if (specifier[0] === '@') {
+	if (mapped_specifier[0] === '@') {
 		// get the index of the second `/`
 		let count = 0;
-		for (let i = 0; i < specifier.length; i++) {
-			if (specifier[i] === '/') count++;
+		for (let i = 0; i < mapped_specifier.length; i++) {
+			if (mapped_specifier[i] === '/') count++;
 			if (count === 2) {
 				idx = i;
 				break;
 			}
 		}
 	} else {
-		idx = specifier.indexOf('/');
+		idx = mapped_specifier.indexOf('/');
 	}
+	const name = mapped_specifier.substring(0, idx);
+	const path = mapped_specifier.substring(idx + 1);
+
+	const subpath = './' + path;
+	const package_dir = join(dir, NODE_MODULES_DIRNAME, name);
+	const package_json = load_package_json(package_dir, cache);
+	const exported = package_json.exports?.[subpath];
+	if (!exported) {
+		// same error message as Node
+		throw Error(
+			`[ERR_PACKAGE_PATH_NOT_EXPORTED]: Package subpath '${subpath}' is not defined by "exports" in ${package_dir}/package.json` +
+				(parent_url ? ` imported from ${parent_url}` : ''),
+		);
+	}
+	const path_id = join(package_dir, exported[exports_key]);
+
 	return {
-		name: specifier.substring(0, idx),
-		path: specifier.substring(idx + 1),
+		path_id,
+		path_id_with_querystring: raw ? path_id + '?raw' : path_id,
+		raw,
+		specifier,
+		mapped_specifier,
+		namespace: undefined,
 	};
 };

package/src/lib/resolve_specifier.ts

@@ -5,22 +5,33 @@ import {replace_extension} from './paths.js';
 import type {Path_Id} from './path.js';
 
 export interface Resolved_Specifier {
-	specifier: string;
+	/**
+	 * The resolved filesystem path for the specifier.
+	 */
 	path_id: Path_Id;
+	/**
+	 * Same as `path_id` but includes `?raw` and other querystrings. (currently none)
+	 */
+	path_id_with_querystring: string;
+	specifier: string;
+	mapped_specifier: string;
 	namespace: undefined | 'sveltekit_local_imports_ts' | 'sveltekit_local_imports_js';
+	raw: boolean;
 }
 
 /**
  * Maps a `path` import specifier relative to the `importer`,
  * and infer the correct extension following Vite conventions.
  * If no `.js` file is found for the `path` on the filesystem, it assumes `.ts`.
- * @param path
+ * @param specifier
  * @param dir - if defined, enables relative importers like from esbuild plugins
  * @param passthrough_extensions - used to support specifiers that have no file extention, which Vite supports, so we do our best effort
  * @returns
  */
-export const resolve_specifier = (path: string, dir: string): Resolved_Specifier => {
-	const absolute_path = isAbsolute(path) ? path : join(dir, path);
+export const resolve_specifier = (specifier: string, dir: string): Resolved_Specifier => {
+	const raw = specifier.endsWith('?raw');
+	const final_specifier = raw ? specifier.substring(0, specifier.length - 4) : specifier;
+	const absolute_path = isAbsolute(final_specifier) ? final_specifier : join(dir, final_specifier);
 
 	let mapped_path;
 	let path_id;
@@ -54,8 +65,15 @@ export const resolve_specifier = (path: string, dir: string): Resolved_Specifier
 		}
 	}
 
-	let specifier = relative(dir, mapped_path);
-	if (specifier[0] !== '.') specifier = './' + specifier;
+	let mapped_specifier = relative(dir, mapped_path);
+	if (mapped_specifier[0] !== '.') mapped_specifier = './' + mapped_specifier;
 
-	return {specifier, path_id, namespace};
+	return {
+		path_id,
+		path_id_with_querystring: raw ? path_id + '?raw' : path_id,
+		raw,
+		specifier,
+		mapped_specifier,
+		namespace,
+	};
 };