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

package/dist/cjs/data/codec.js

@@ -0,0 +1,168 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    DATA_CODEC: ()=>DATA_CODEC,
+    DataProtocolError: ()=>DataProtocolError,
+    MAX_DATA_BYTES: ()=>MAX_DATA_BYTES,
+    assertPublicData: ()=>assertPublicData,
+    escapeInlineDataJSON: ()=>escapeInlineDataJSON,
+    parsePublicData: ()=>parsePublicData,
+    serializePublicData: ()=>serializePublicData
+});
+const external_seroval_namespaceObject = require("seroval");
+const external_tree_js_namespaceObject = require("./tree.js");
+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: (0, external_seroval_namespaceObject.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 {
+        (0, external_tree_js_namespaceObject.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');
+        (0, external_tree_js_namespaceObject.validateSerializedData)(record.data);
+        const result = (0, external_seroval_namespaceObject.fromJSON)(record.data);
+        assertPublicData(result);
+        return result;
+    } catch (error) {
+        if (error instanceof DataProtocolError) throw error;
+        throw new DataProtocolError('Malformed public data payload');
+    }
+}
+exports.DATA_CODEC = __webpack_exports__.DATA_CODEC;
+exports.DataProtocolError = __webpack_exports__.DataProtocolError;
+exports.MAX_DATA_BYTES = __webpack_exports__.MAX_DATA_BYTES;
+exports.assertPublicData = __webpack_exports__.assertPublicData;
+exports.escapeInlineDataJSON = __webpack_exports__.escapeInlineDataJSON;
+exports.parsePublicData = __webpack_exports__.parsePublicData;
+exports.serializePublicData = __webpack_exports__.serializePublicData;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DATA_CODEC",
+    "DataProtocolError",
+    "MAX_DATA_BYTES",
+    "assertPublicData",
+    "escapeInlineDataJSON",
+    "parsePublicData",
+    "serializePublicData"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/data/index.js

@@ -0,0 +1,125 @@
+"use strict";
+var __webpack_modules__ = {
+    "./client" (module) {
+        module.exports = require("./client.js");
+    },
+    "./codec" (module) {
+        module.exports = require("./codec.js");
+    },
+    "./private" (module) {
+        module.exports = require("./private.js");
+    },
+    "./routes" (module) {
+        module.exports = require("./routes.js");
+    },
+    "./server" (module) {
+        module.exports = require("./server.js");
+    },
+    "./static" (module) {
+        module.exports = require("./static.js");
+    },
+    "./types" (module) {
+        module.exports = require("./types.js");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    var _client__rspack_import_0 = __webpack_require__("./client");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _client__rspack_import_0)if ([
+        "createRequestDataPolicy",
+        "default"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_client__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _codec__rspack_import_1 = __webpack_require__("./codec");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _codec__rspack_import_1)if ([
+        "createRequestDataPolicy",
+        "default"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_codec__rspack_import_1[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _private__rspack_import_2 = __webpack_require__("./private");
+    var _routes__rspack_import_3 = __webpack_require__("./routes");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _routes__rspack_import_3)if ([
+        "createRequestDataPolicy",
+        "default"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_routes__rspack_import_3[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _server__rspack_import_4 = __webpack_require__("./server");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _server__rspack_import_4)if ([
+        "createRequestDataPolicy",
+        "default"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_server__rspack_import_4[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _static__rspack_import_5 = __webpack_require__("./static");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _static__rspack_import_5)if ([
+        "createRequestDataPolicy",
+        "default"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_static__rspack_import_5[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _types__rspack_import_6 = __webpack_require__("./types");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _types__rspack_import_6)if ([
+        "createRequestDataPolicy",
+        "default"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_types__rspack_import_6[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    __webpack_require__.d(__webpack_exports__, {
+        createRequestDataPolicy: ()=>_private__rspack_import_2.createRequestDataPolicy
+    });
+})();
+exports.createRequestDataPolicy = __webpack_exports__.createRequestDataPolicy;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRequestDataPolicy"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/data/private.js

@@ -0,0 +1,77 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createRequestDataPolicy: ()=>createRequestDataPolicy
+});
+const external_codec_js_namespaceObject = require("./codec.js");
+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 external_codec_js_namespaceObject.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 external_codec_js_namespaceObject.DataProtocolError('Request-private context cannot be transferred as public data');
+        },
+        assertValue (value) {
+            refresh();
+            (0, external_codec_js_namespaceObject.assertPublicData)(value, {
+                privateReferences: references
+            });
+        }
+    };
+}
+exports.createRequestDataPolicy = __webpack_exports__.createRequestDataPolicy;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRequestDataPolicy"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/data/routes.js

@@ -0,0 +1,149 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+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('/');
+}
+__webpack_require__.d(__webpack_exports__, {
+    projectFileSystemRoutes: ()=>projectFileSystemRoutes,
+    toTanstackPath: ()=>toTanstackPath
+});
+exports.projectFileSystemRoutes = __webpack_exports__.projectFileSystemRoutes;
+exports.toTanstackPath = __webpack_exports__.toTanstackPath;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "projectFileSystemRoutes",
+    "toTanstackPath"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});