@bleedingdev/modern-js-renderer-core 0.0.0-bootstrap → 3.9.3-ultramodern.1

package/dist/esm-node/data/client.mjs

@@ -0,0 +1,369 @@
+import "node:module";
+import { untilAborted } from "../abort.mjs";
+import { assertRendererIdentity } from "../identity.mjs";
+import { readBoundedDataText } from "./body.mjs";
+import { DataProtocolError, MAX_DATA_BYTES, parsePublicData } from "./codec.mjs";
+import { STATIC_DATA_PAYLOAD_MAX_BYTES, isPrerenderedDocument, isStaticDataPayload, staticDataPayloadPath } from "./static.mjs";
+import { DATA_CONTENT_TYPE, DATA_PROTOCOL_VERSION, DATA_STREAM_CONTENT_TYPE, DIRECT_PARAM, LOADER_ID_PARAM } from "./types.mjs";
+const isRecord = (value)=>null !== value && 'object' == typeof value && !Array.isArray(value);
+function assertKeys(record, keys, required = []) {
+    if (Object.keys(record).some((key)=>!keys.includes(key))) throw new DataProtocolError('Unknown data protocol field');
+    if (required.some((key)=>!Object.hasOwn(record, key))) throw new DataProtocolError('Missing data protocol field');
+}
+function assertError(value) {
+    if (!isRecord(value)) throw new DataProtocolError('Malformed public error');
+    assertKeys(value, [
+        'name',
+        'message',
+        'stack'
+    ]);
+    if ('string' != typeof value['name'] || 'string' != typeof value['message'] || Object.hasOwn(value, 'stack') && 'string' != typeof value['stack']) throw new DataProtocolError('Malformed public error');
+}
+function assertEnvelope(value, expected) {
+    if (!isRecord(value) || value['version'] !== DATA_PROTOCOL_VERSION || value['routeId'] !== expected.routeId || value['operation'] !== expected.operation || !isRecord(value['identity']) || !isRecord(value['outcome'])) throw new DataProtocolError('Data protocol or route identity mismatch');
+    assertKeys(value, [
+        'version',
+        'identity',
+        'routeId',
+        'operation',
+        'outcome',
+        'deferredKeys'
+    ]);
+    assertKeys(value['identity'], [
+        'renderer',
+        'appId',
+        'entryName',
+        'protocolVersion',
+        'buildId'
+    ]);
+    try {
+        assertRendererIdentity(value['identity'], expected.identity);
+    } catch  {
+        throw new DataProtocolError('Data renderer or build identity mismatch');
+    }
+    const outcome = value['outcome'];
+    if (!Number.isInteger(outcome['status']) || outcome['status'] < 200 || outcome['status'] > 599) throw new DataProtocolError('Malformed data response status');
+    switch(outcome['kind']){
+        case 'success':
+            assertKeys(outcome, [
+                'kind',
+                'value',
+                'status'
+            ], [
+                'value'
+            ]);
+            break;
+        case 'redirect':
+            assertKeys(outcome, [
+                'kind',
+                'location',
+                'status'
+            ]);
+            if ('string' != typeof outcome['location'] || ![
+                301,
+                302,
+                303,
+                307,
+                308
+            ].includes(outcome['status'])) throw new DataProtocolError('Malformed data redirect');
+            break;
+        case 'not-found':
+            assertKeys(outcome, [
+                'kind',
+                'value',
+                'thrown',
+                'status'
+            ], [
+                'value'
+            ]);
+            if (404 !== outcome['status'] || 'boolean' != typeof outcome['thrown']) throw new DataProtocolError('Malformed not-found outcome');
+            break;
+        case 'error':
+            assertKeys(outcome, [
+                'kind',
+                'error',
+                'data',
+                'thrown',
+                'status'
+            ]);
+            assertError(outcome['error']);
+            if ('boolean' != typeof outcome['thrown']) throw new DataProtocolError('Malformed error outcome');
+            break;
+        default:
+            throw new DataProtocolError('Unknown data outcome');
+    }
+    if (Object.hasOwn(value, 'deferredKeys')) {
+        if (!Array.isArray(value['deferredKeys']) || value['deferredKeys'].some((key)=>'string' != typeof key) || new Set(value['deferredKeys']).size !== value['deferredKeys'].length || 'success' !== outcome['kind'] || !isRecord(outcome['value']) || value['deferredKeys'].some((key)=>Object.hasOwn(outcome['value'], key))) throw new DataProtocolError('Malformed deferred data keys');
+    }
+}
+function dataError(error) {
+    const result = new Error(error.message);
+    result.name = error.name;
+    if (void 0 !== error.stack) result.stack = error.stack;
+    else delete result.stack;
+    return result;
+}
+async function readDeferredResponse(response, expected, signal) {
+    if (!response.body) throw new DataProtocolError('Missing deferred data body');
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder('utf-8', {
+        fatal: true
+    });
+    let buffer = '';
+    let initialized = false;
+    let completed = false;
+    let initialResolve;
+    let initialReject;
+    const initial = new Promise((resolve, reject)=>{
+        initialResolve = resolve;
+        initialReject = reject;
+    });
+    let completionResolve;
+    let completionReject;
+    const completion = new Promise((resolve, reject)=>{
+        completionResolve = resolve;
+        completionReject = reject;
+    });
+    completion.catch(()=>void 0);
+    const pending = new Map();
+    const reject = (error)=>{
+        completionReject(error);
+        if (!initialized) initialReject(error);
+        for (const promise of pending.values())promise.reject(error);
+        pending.clear();
+    };
+    const abort = ()=>{
+        const reason = signal?.reason ?? new DOMException('The data request was aborted', 'AbortError');
+        reject(reason);
+        reader.cancel(reason).catch(()=>void 0);
+    };
+    if (signal?.aborted) abort();
+    else signal?.addEventListener('abort', abort, {
+        once: true
+    });
+    const consume = (text)=>{
+        if (completed) throw new DataProtocolError('Data frames follow stream completion');
+        const frame = parsePublicData(text);
+        if (!isRecord(frame)) throw new DataProtocolError('Malformed data stream frame');
+        if ('initial' === frame['type']) {
+            assertKeys(frame, [
+                'type',
+                'envelope'
+            ]);
+            if (initialized) throw new DataProtocolError('Duplicate initial data frame');
+            assertEnvelope(frame['envelope'], expected);
+            const envelope = frame['envelope'];
+            if (!Array.isArray(envelope.deferredKeys) || 'success' !== envelope.outcome.kind) throw new DataProtocolError('Initial stream frame needs deferred keys');
+            const value = envelope.outcome.value;
+            for (const key of envelope.deferredKeys){
+                const promise = new Promise((resolve, rejectPromise)=>{
+                    pending.set(key, {
+                        resolve,
+                        reject: rejectPromise
+                    });
+                });
+                promise.catch(()=>void 0);
+                Object.defineProperty(value, key, {
+                    value: promise,
+                    writable: true,
+                    enumerable: true,
+                    configurable: true
+                });
+            }
+            initialized = true;
+            const outcome = {
+                ...envelope.outcome,
+                value
+            };
+            Object.defineProperty(outcome, 'completion', {
+                value: completion
+            });
+            initialResolve(outcome);
+            return;
+        }
+        if (!initialized) throw new DataProtocolError('Deferred data arrived before the initial frame');
+        if ('complete' === frame['type']) {
+            assertKeys(frame, [
+                'type'
+            ]);
+            if (0 !== pending.size) throw new DataProtocolError('Deferred stream completed with unresolved values');
+            completed = true;
+            return;
+        }
+        if ('resolve' !== frame['type'] && 'reject' !== frame['type']) throw new DataProtocolError('Unknown data stream frame');
+        'resolve' === frame['type'] ? assertKeys(frame, [
+            'type',
+            'key',
+            'value'
+        ], [
+            'value'
+        ]) : assertKeys(frame, [
+            'type',
+            'key',
+            'error'
+        ]);
+        if ('string' != typeof frame['key'] || !pending.has(frame['key'])) throw new DataProtocolError('Unknown or duplicate deferred data key');
+        const promise = pending.get(frame['key']);
+        if ('resolve' === frame['type']) promise.resolve(frame['value']);
+        else {
+            assertError(frame['error']);
+            promise.reject(dataError(frame['error']));
+        }
+        pending.delete(frame['key']);
+    };
+    const append = (text)=>{
+        buffer += text;
+        let lineEnd = buffer.indexOf('\n');
+        while(-1 !== lineEnd){
+            const line = buffer.slice(0, lineEnd);
+            buffer = buffer.slice(lineEnd + 1);
+            if (!line) throw new DataProtocolError('Empty data stream frame');
+            consume(line);
+            lineEnd = buffer.indexOf('\n');
+        }
+        if (new TextEncoder().encode(buffer).byteLength > MAX_DATA_BYTES) throw new DataProtocolError('Deferred data frame exceeds its size limit');
+    };
+    (async ()=>{
+        try {
+            while(true){
+                const chunk = await reader.read();
+                if (chunk.done) {
+                    append(decoder.decode());
+                    break;
+                }
+                for(let offset = 0; offset < chunk.value.byteLength; offset += 65536)append(decoder.decode(chunk.value.subarray(offset, offset + 65536), {
+                    stream: true
+                }));
+            }
+            if ('' !== buffer || !completed) throw new DataProtocolError('Truncated deferred data stream');
+            completionResolve();
+        } catch (error) {
+            reject(error);
+            reader.cancel(error).catch(()=>void 0);
+        } finally{
+            signal?.removeEventListener('abort', abort);
+            reader.releaseLock();
+        }
+    })();
+    return initial;
+}
+async function readDataResponse(response, expected, signal) {
+    const discard = (reason)=>{
+        response.body?.cancel(reason).catch(()=>void 0);
+    };
+    if (signal?.aborted) {
+        discard(signal.reason);
+        signal.throwIfAborted();
+    }
+    const contentType = response.headers.get('content-type')?.split(';')[0]?.trim();
+    if (contentType === DATA_STREAM_CONTENT_TYPE) return readDeferredResponse(response, expected, signal);
+    if (contentType !== DATA_CONTENT_TYPE) {
+        const error = new DataProtocolError(`Expected an UltraModern data response, received HTTP ${response.status}`);
+        discard(error);
+        throw error;
+    }
+    const value = parsePublicData(await readBoundedDataText(response, signal));
+    signal?.throwIfAborted();
+    assertEnvelope(value, expected);
+    if (Object.hasOwn(value, 'deferredKeys')) throw new DataProtocolError('Deferred values require the stream protocol');
+    return value.outcome;
+}
+async function readStaticPayload(url, routeId, fetchData, request) {
+    if (url.search || !isPrerenderedDocument()) return;
+    let response;
+    try {
+        response = await untilAborted(fetchData(new URL(staticDataPayloadPath(url.pathname, routeId), url), {
+            credentials: 'same-origin',
+            signal: request.signal
+        }), request.signal);
+    } catch  {
+        request.signal.throwIfAborted();
+        return;
+    }
+    if (!response.ok) return void response.body?.cancel().catch(()=>void 0);
+    let payload;
+    try {
+        payload = JSON.parse(await readBoundedDataText(response, request.signal, STATIC_DATA_PAYLOAD_MAX_BYTES));
+    } catch  {
+        request.signal.throwIfAborted();
+        return;
+    }
+    if (!isStaticDataPayload(payload)) return;
+    return new Response(payload.body, {
+        status: payload.status,
+        headers: {
+            'content-type': payload.contentType
+        }
+    });
+}
+async function bufferRequestBody(request) {
+    if (!request.body) return null;
+    const { signal } = request;
+    if (/^multipart\/form-data\b/iu.test(request.headers.get('content-type') ?? '')) return untilAborted(request.blob(), signal);
+    const reader = request.body.getReader();
+    const cancel = ()=>{
+        reader.cancel(signal.reason).catch(()=>{});
+    };
+    signal.addEventListener('abort', cancel, {
+        once: true
+    });
+    try {
+        const chunks = [];
+        for(;;){
+            const part = await reader.read();
+            signal.throwIfAborted();
+            if (part.done) break;
+            chunks.push(part.value);
+        }
+        return new Blob(chunks, {
+            type: request.headers.get('content-type') ?? ''
+        });
+    } finally{
+        signal.removeEventListener('abort', cancel);
+    }
+}
+function createDataClient(routeId, identity, options = {}) {
+    if (!routeId) throw new DataProtocolError('A data client requires a route ID');
+    const fetchData = options.fetch ?? globalThis.fetch;
+    const execute = async (operation, input)=>{
+        const request = input.request;
+        request.signal.throwIfAborted();
+        if ('loader' === operation && 'GET' !== request.method) throw new DataProtocolError('A loader client needs a GET Request');
+        if ('action' === operation && [
+            'GET',
+            'HEAD'
+        ].includes(request.method)) throw new DataProtocolError('An action client needs a mutation Request');
+        const url = new URL(request.url);
+        if ('loader' === operation) {
+            const replayed = await readStaticPayload(url, routeId, fetchData, request);
+            if (replayed) return readDataResponse(replayed, {
+                identity,
+                routeId,
+                operation
+            }, request.signal);
+        }
+        url.searchParams.set(LOADER_ID_PARAM, routeId);
+        url.searchParams.set(DIRECT_PARAM, 'true');
+        const proxyRequest = new Request(url, {
+            method: request.method,
+            headers: request.headers,
+            body: 'action' === operation ? await bufferRequestBody(request) : null,
+            signal: request.signal
+        });
+        const response = await untilAborted(fetchData(proxyRequest, {
+            credentials: 'same-origin',
+            redirect: 'manual',
+            signal: request.signal
+        }), request.signal);
+        return readDataResponse(response, {
+            identity,
+            routeId,
+            operation
+        }, request.signal);
+    };
+    return {
+        loader: (input)=>execute('loader', input),
+        action: (input)=>execute('action', input)
+    };
+}
+export { createDataClient, readDataResponse };

package/dist/esm-node/data/codec.mjs

@@ -0,0 +1,113 @@
+import "node:module";
+import { fromJSON, toJSON } from "seroval";
+import { validateSerializedData } from "./tree.mjs";
+const DATA_CODEC = 'seroval-json@1.6.8';
+const MAX_DATA_BYTES = 1048576;
+const MAX_DEPTH = 100;
+const MAX_NODES = 20000;
+class DataProtocolError extends Error {
+    constructor(message){
+        super(message);
+        this.name = 'DataProtocolError';
+    }
+}
+function assertPublicData(value, options = {}) {
+    const seen = new WeakSet();
+    let count = 0;
+    const visit = (current, depth)=>{
+        if (++count > MAX_NODES || depth > MAX_DEPTH) throw new DataProtocolError('Public data exceeds its size or depth limit');
+        if (null == current) return;
+        const type = typeof current;
+        if (('object' === type || 'function' === type) && options.privateReferences?.has(current)) throw new DataProtocolError('Request-private context cannot be transferred as public data');
+        if ('string' === type || 'boolean' === type || 'number' === type || 'bigint' === type) return;
+        if ('object' !== type) throw new DataProtocolError(`Unsupported public data type: ${type}`);
+        const object = current;
+        if (seen.has(object)) return;
+        seen.add(object);
+        const prototype = Object.getPrototypeOf(object);
+        if (prototype !== Object.prototype && null !== prototype && prototype !== Array.prototype && prototype !== Date.prototype && prototype !== RegExp.prototype && prototype !== Map.prototype && prototype !== Set.prototype) throw new DataProtocolError('Public data must not contain native views, request context or class instances');
+        const ownKeys = Reflect.ownKeys(object);
+        const descriptors = [];
+        let hidden;
+        for (const key of ownKeys){
+            const descriptor = Object.getOwnPropertyDescriptor(object, key);
+            if ('symbol' == typeof key || descriptor.get || descriptor.set) throw new DataProtocolError('Public data must not contain symbols or accessors');
+            if (!descriptor.enumerable && (prototype === Object.prototype || null === prototype)) hidden ??= key;
+            descriptors.push(descriptor);
+        }
+        if (prototype === Array.prototype && ownKeys.some((key)=>'length' !== key && ('string' != typeof key || !/^(?:0|[1-9]\d*)$/.test(key) || Number(key) >= 0xffffffff))) throw new DataProtocolError('Public data arrays must contain only length and canonical index properties');
+        if (prototype === Array.prototype) {
+            const length = Object.getOwnPropertyDescriptor(object, 'length')?.value;
+            if ('number' == typeof length) count += length - (ownKeys.length - 1);
+            if (count > MAX_NODES) throw new DataProtocolError('Public data exceeds its size or depth limit');
+        }
+        for (const descriptor of descriptors)visit(descriptor.value, depth + 1);
+        if (void 0 !== hidden) throw new DataProtocolError(`Public data must not contain non-enumerable properties (${hidden})`);
+        try {
+            if (prototype === Array.prototype && !Array.isArray(object)) throw new TypeError('Missing native array slots');
+            if (prototype === Date.prototype) Date.prototype.valueOf.call(object);
+            if (prototype === RegExp.prototype) Object.getOwnPropertyDescriptor(RegExp.prototype, 'source').get.call(object);
+            if (prototype === Map.prototype) Map.prototype.has.call(object, void 0);
+            if (prototype === Set.prototype) Set.prototype.has.call(object, void 0);
+        } catch  {
+            throw new DataProtocolError('Public data requires valid native container values');
+        }
+        if ((prototype === Date.prototype || prototype === Map.prototype || prototype === Set.prototype) && ownKeys.length > 0 || prototype === RegExp.prototype && ownKeys.some((key)=>'lastIndex' !== key)) throw new DataProtocolError('Public data native containers must not override their built-in properties');
+        if (prototype === RegExp.prototype && Object.getOwnPropertyDescriptor(object, 'lastIndex')?.value !== 0) throw new DataProtocolError('Public data RegExp values must have lastIndex 0');
+        if (prototype === Map.prototype) for (const [key, entry] of Map.prototype.entries.call(object)){
+            visit(key, depth + 1);
+            visit(entry, depth + 1);
+        }
+        else if (prototype === Set.prototype) for (const entry of Set.prototype.values.call(object))visit(entry, depth + 1);
+    };
+    visit(value, 0);
+}
+function escapeInlineDataJSON(text) {
+    return text.replace(/[<>&\u2028\u2029]/gu, (character)=>{
+        switch(character){
+            case '<':
+                return '\\u003C';
+            case '>':
+                return '\\u003E';
+            case '&':
+                return '\\u0026';
+            case '\u2028':
+                return '\\u2028';
+            default:
+                return '\\u2029';
+        }
+    });
+}
+function serializePublicData(value) {
+    assertPublicData(value);
+    const text = JSON.stringify({
+        codec: DATA_CODEC,
+        data: toJSON(value, {
+            depthLimit: MAX_DEPTH
+        })
+    });
+    if (new TextEncoder().encode(escapeInlineDataJSON(text)).byteLength > MAX_DATA_BYTES) throw new DataProtocolError('Public data exceeds its byte limit');
+    try {
+        validateSerializedData(JSON.parse(text).data);
+    } catch  {
+        throw new DataProtocolError('Public data exceeds the supported codec limits');
+    }
+    return text;
+}
+function parsePublicData(text) {
+    if (new TextEncoder().encode(escapeInlineDataJSON(text)).byteLength > MAX_DATA_BYTES) throw new DataProtocolError('Public data exceeds its byte limit');
+    try {
+        const envelope = JSON.parse(text);
+        if (!envelope || 'object' != typeof envelope || Array.isArray(envelope)) throw new DataProtocolError('Malformed public data envelope');
+        const record = envelope;
+        if (2 !== Object.keys(record).length || record.codec !== DATA_CODEC || !Object.hasOwn(record, 'data')) throw new DataProtocolError('Unsupported public data codec');
+        validateSerializedData(record.data);
+        const result = fromJSON(record.data);
+        assertPublicData(result);
+        return result;
+    } catch (error) {
+        if (error instanceof DataProtocolError) throw error;
+        throw new DataProtocolError('Malformed public data payload');
+    }
+}
+export { DATA_CODEC, DataProtocolError, MAX_DATA_BYTES, assertPublicData, escapeInlineDataJSON, parsePublicData, serializePublicData };

package/dist/esm-node/data/index.mjs

@@ -0,0 +1,8 @@
+import "node:module";
+export * from "./client.mjs";
+export * from "./codec.mjs";
+export * from "./routes.mjs";
+export * from "./server.mjs";
+export * from "./static.mjs";
+export * from "./types.mjs";
+export { createRequestDataPolicy } from "./private.mjs";

package/dist/esm-node/data/private.mjs

@@ -0,0 +1,40 @@
+import "node:module";
+import { DataProtocolError, assertPublicData } from "./codec.mjs";
+function createRequestDataPolicy(roots) {
+    const references = new WeakSet();
+    const refresh = ()=>{
+        const seen = new WeakSet();
+        let count = 0;
+        const visit = (value, depth)=>{
+            if (null === value || 'object' != typeof value && 'function' != typeof value) return;
+            if (seen.has(value)) return;
+            if (++count > 20000 || depth > 100) throw new DataProtocolError('Private request context exceeds its size or depth limit');
+            seen.add(value);
+            references.add(value);
+            for (const key of Reflect.ownKeys(value)){
+                const descriptor = Object.getOwnPropertyDescriptor(value, key);
+                if (!descriptor.get && !descriptor.set) visit(descriptor.value, depth + 1);
+            }
+            if (value instanceof Map) for (const [key, entry] of Map.prototype.entries.call(value)){
+                visit(key, depth + 1);
+                visit(entry, depth + 1);
+            }
+            else if (value instanceof Set) for (const entry of Set.prototype.values.call(value))visit(entry, depth + 1);
+        };
+        for (const root of roots)visit(root, 0);
+    };
+    refresh();
+    return {
+        assertRoot (value) {
+            refresh();
+            if (null !== value && ('object' == typeof value || 'function' == typeof value) && references.has(value)) throw new DataProtocolError('Request-private context cannot be transferred as public data');
+        },
+        assertValue (value) {
+            refresh();
+            assertPublicData(value, {
+                privateReferences: references
+            });
+        }
+    };
+}
+export { createRequestDataPolicy };

package/dist/esm-node/data/routes.mjs

@@ -0,0 +1,109 @@
+import "node:module";
+const moduleFields = [
+    'data',
+    'clientData',
+    'loading',
+    'error',
+    'search',
+    'head',
+    'notFound'
+];
+const viewFields = [
+    'file',
+    '_component',
+    'component',
+    'filename'
+];
+function routeRecord(value, location) {
+    if (null === value || 'object' != typeof value || Object.getPrototypeOf(value) !== Object.prototype && null !== Object.getPrototypeOf(value)) throw new TypeError(`${location} must be a plain route object`);
+    return value;
+}
+function routeField(record, key, location) {
+    const descriptor = Object.getOwnPropertyDescriptor(record, key);
+    if (descriptor && !('value' in descriptor)) throw new TypeError(`${location}.${key} must be a value, not an accessor`);
+    return descriptor?.value;
+}
+function optionalString(record, key, location, allowEmpty = false) {
+    const value = routeField(record, key, location);
+    if (void 0 === value) return;
+    if ('string' != typeof value || !allowEmpty && 0 === value.trim().length) throw new TypeError(`${location}.${key} must be ${allowEmpty ? 'a' : 'a non-empty'} string`);
+    return value;
+}
+function optionalBoolean(record, key, location) {
+    const value = routeField(record, key, location);
+    if (void 0 === value) return;
+    if ('boolean' != typeof value) throw new TypeError(`${location}.${key} must be a boolean`);
+    return value;
+}
+function projectFileSystemRoutes(routes) {
+    if (!Array.isArray(routes)) throw new TypeError('routes must be an array');
+    const ids = new Set();
+    const ancestors = new Set();
+    const project = (value, coordinates)=>{
+        const location = `routes[${coordinates.join('].children[')}]`;
+        if (coordinates.length > 256) throw new TypeError(`${location} exceeds the maximum route depth`);
+        const record = routeRecord(value, location);
+        if (ancestors.has(record)) throw new TypeError(`${location} contains a route cycle`);
+        let file;
+        for (const key of viewFields){
+            const reference = optionalString(record, key, location);
+            file ??= reference;
+        }
+        const id = optionalString(record, 'id', location) ?? file ?? `route-${coordinates.join('.')}`;
+        if (ids.has(id)) throw new TypeError(`${location} duplicates route id "${id}"`);
+        ids.add(id);
+        const path = optionalString(record, 'path', location, true);
+        const index = optionalBoolean(record, 'index', location);
+        const isRoot = optionalBoolean(record, 'isRoot', location);
+        const children = routeField(record, 'children', location);
+        if (void 0 !== children && !Array.isArray(children)) throw new TypeError(`${location}.children must be an array`);
+        if (true === index && (children?.length || true === isRoot)) throw new TypeError(`${location} index routes cannot have children or be root routes`);
+        const modules = {};
+        for (const key of moduleFields){
+            const reference = optionalString(record, key, location);
+            if (void 0 !== reference) modules[key] = reference;
+        }
+        ancestors.add(record);
+        const projectedChildren = (children ?? []).map((child, position)=>project(child, [
+                ...coordinates,
+                position
+            ]));
+        ancestors.delete(record);
+        return {
+            id,
+            ...void 0 === file ? {} : {
+                file
+            },
+            ...void 0 === path ? {} : {
+                path
+            },
+            ...void 0 === index ? {} : {
+                index
+            },
+            ...void 0 === isRoot ? {} : {
+                isRoot
+            },
+            ...0 === Object.keys(modules).length ? {} : {
+                modules
+            },
+            children: projectedChildren
+        };
+    };
+    return routes.map((route, position)=>project(route, [
+            position
+        ]));
+}
+function toTanstackPath(pathname) {
+    if ('string' != typeof pathname) throw new TypeError('route path must be a string');
+    return pathname.split('/').map((segment)=>{
+        if ('*' === segment) return '$';
+        if (segment.startsWith(':')) {
+            const optional = segment.endsWith('?');
+            const name = segment.slice(1, optional ? -1 : void 0);
+            if (!name || /[:?*]/.test(name)) throw new TypeError(`Invalid route parameter "${segment}"`);
+            return optional ? `{-$${name}}` : `$${name}`;
+        }
+        return segment;
+    }).join('/');
+}
+export { projectFileSystemRoutes, toTanstackPath };