@sneat/structured-data 0.0.0-stage → 0.27.29

package/fesm2022/sneat-structured-data-core.mjs

@@ -0,0 +1,692 @@
+import { parseTree } from 'jsonc-parser';
+import { parseDocument, isAlias, isScalar, isSeq, isMap } from 'yaml';
+
+const DEFAULT_LIMITS = {
+    maxSourceBytes: 2_000_000,
+    maxNodes: 30_000,
+    maxDepth: 64,
+    maxRows: 2_000,
+    maxConfigBytes: 64_000,
+    maxRules: 100,
+    maxSections: 300,
+    maxSelectorLength: 256,
+    maxSelectorDepth: 16,
+    maxYamlAliases: 0,
+    timeoutMs: 2_000,
+};
+function effectiveLimits(overrides) {
+    const result = { ...DEFAULT_LIMITS };
+    if (overrides) {
+        for (const key of Object.keys(DEFAULT_LIMITS)) {
+            const value = overrides[key];
+            if (value !== undefined) {
+                if (!Number.isSafeInteger(value) || value < 0 || value > DEFAULT_LIMITS[key]) {
+                    throw new Error(`Invalid ${key} limit`);
+                }
+                result[key] = value;
+            }
+        }
+    }
+    return result;
+}
+function sourceByteLength(text) {
+    return new TextEncoder().encode(text).length;
+}
+function exceedsSourceLimit(text, maxBytes) {
+    return text.length > maxBytes || sourceByteLength(text) > maxBytes;
+}
+function diagnostic(code, message, range, source) {
+    return { code, message, severity: 'error', ...(range ? { range } : {}), ...(source ? { source } : {}) };
+}
+/** Tree-sitter and JS parser offsets are UTF-16 code-unit offsets. */
+class SourceLocator {
+    constructor(source) {
+        this.source = source;
+        this.lineStarts = [0];
+        for (let index = 0; index < source.length; index++) {
+            if (source[index] === '\r') {
+                if (source[index + 1] === '\n')
+                    index++;
+                this.lineStarts.push(index + 1);
+            }
+            else if (source[index] === '\n') {
+                this.lineStarts.push(index + 1);
+            }
+        }
+    }
+    range(startOffset, endOffset) {
+        return {
+            startOffset,
+            endOffset,
+            start: this.position(startOffset),
+            end: this.position(endOffset),
+        };
+    }
+    position(offset) {
+        let low = 0;
+        let high = this.lineStarts.length;
+        while (low + 1 < high) {
+            const middle = (low + high) >>> 1;
+            if (this.lineStarts[middle] <= offset)
+                low = middle;
+            else
+                high = middle;
+        }
+        return { line: low, column: offset - this.lineStarts[low] };
+    }
+}
+
+function parseJsonText(sourceText, limits) {
+    let bounded;
+    try {
+        bounded = effectiveLimits(limits);
+    }
+    catch (error) {
+        return { ok: false, diagnostics: [diagnostic('limit_exceeded', String(error))] };
+    }
+    if (exceedsSourceLimit(sourceText, bounded.maxSourceBytes)) {
+        return { ok: false, diagnostics: [diagnostic('limit_exceeded', `JSON source exceeds ${bounded.maxSourceBytes} bytes`)] };
+    }
+    const errors = [];
+    let root;
+    try {
+        root = parseTree(sourceText, errors, { disallowComments: true, allowTrailingComma: false });
+    }
+    catch {
+        return { ok: false, diagnostics: [diagnostic('limit_exceeded', 'JSON parser could not process this source safely')] };
+    }
+    const locator = new SourceLocator(sourceText);
+    if (!root || errors.length) {
+        return { ok: false, diagnostics: errors.length
+                ? errors.map(error => diagnostic('invalid_syntax', `Invalid JSON (${error.error})`, locator.range(error.offset, error.offset + error.length)))
+                : [diagnostic('invalid_syntax', 'JSON document is empty')] };
+    }
+    let count = 0;
+    try {
+        const convert = (node, depth) => {
+            if (++count > bounded.maxNodes || depth > bounded.maxDepth)
+                throw new Error('JSON node or depth limit exceeded');
+            const range = locator.range(node.offset, node.offset + node.length);
+            switch (node.type) {
+                case 'null': return { kind: 'null', range };
+                case 'boolean': return { kind: 'boolean', value: node.value, range };
+                case 'string': return { kind: 'string', value: node.value, range };
+                case 'number': {
+                    const sourceNumber = sourceText.slice(node.offset, node.offset + node.length);
+                    const parsedNumber = Number(sourceNumber);
+                    const losslessInteger = !Number.isInteger(parsedNumber) || Number.isSafeInteger(parsedNumber);
+                    return { kind: 'number', sourceText: sourceNumber,
+                        ...(Number.isFinite(parsedNumber) && losslessInteger ? { value: parsedNumber } : {}), range };
+                }
+                case 'array': return { kind: 'array', items: (node.children ?? []).map(child => convert(child, depth + 1)), range };
+                case 'object': {
+                    const entries = [];
+                    const seen = new Set();
+                    for (const property of node.children ?? []) {
+                        const keyNode = property.children?.[0];
+                        const valueNode = property.children?.[1];
+                        if (!keyNode || !valueNode || typeof keyNode.value !== 'string')
+                            throw new Error('Invalid JSON property');
+                        const key = keyNode.value;
+                        if (seen.has(key))
+                            throw new Error(`Duplicate JSON key: ${key}`);
+                        seen.add(key);
+                        entries.push({ key, value: convert(valueNode, depth + 1), range: locator.range(property.offset, property.offset + property.length) });
+                    }
+                    return { kind: 'object', entries, range };
+                }
+                default: throw new Error(`Unsupported JSON node: ${node.type}`);
+            }
+        };
+        return { ok: true, document: { format: 'json', root: convert(root, 0), sourceText }, diagnostics: [] };
+    }
+    catch (error) {
+        const message = String(error);
+        return { ok: false, diagnostics: [diagnostic(message.includes('limit') ? 'limit_exceeded' : 'invalid_syntax', message)] };
+    }
+}
+
+function parseYamlText(sourceText, limits) {
+    let bounded;
+    try {
+        bounded = effectiveLimits(limits);
+    }
+    catch (error) {
+        return { ok: false, diagnostics: [diagnostic('limit_exceeded', String(error))] };
+    }
+    if (exceedsSourceLimit(sourceText, bounded.maxSourceBytes)) {
+        return { ok: false, diagnostics: [diagnostic('limit_exceeded', `YAML source exceeds ${bounded.maxSourceBytes} bytes`)] };
+    }
+    const locator = new SourceLocator(sourceText);
+    let yaml;
+    try {
+        yaml = parseDocument(sourceText, { uniqueKeys: true, strict: true });
+    }
+    catch {
+        return { ok: false, diagnostics: [diagnostic('limit_exceeded', 'YAML parser could not process this source safely')] };
+    }
+    if (yaml.errors.length) {
+        return { ok: false, diagnostics: yaml.errors.map(error => diagnostic('invalid_syntax', error.message, error.pos ? locator.range(error.pos[0], error.pos[1]) : undefined)) };
+    }
+    let count = 0;
+    const rangeOf = (node) => node?.range
+        ? locator.range(node.range[0], node.range[1]) : undefined;
+    try {
+        const convert = (node, depth) => {
+            if (++count > bounded.maxNodes || depth > bounded.maxDepth)
+                throw new Error('YAML node or depth limit exceeded');
+            if (node === null)
+                return { kind: 'null' };
+            if (isAlias(node))
+                throw new Error('YAML aliases are unsupported in structured view');
+            if (node.tag && !node.tag.startsWith('tag:yaml.org,2002:'))
+                throw new Error(`Unsupported YAML tag: ${node.tag}`);
+            const range = rangeOf(node);
+            if (isScalar(node)) {
+                const value = node.value;
+                if (value === null || value === undefined)
+                    return { kind: 'null', range };
+                if (typeof value === 'boolean')
+                    return { kind: 'boolean', value, range };
+                if (typeof value === 'number') {
+                    const sourceNumber = range ? sourceText.slice(range.startOffset, range.endOffset) : String(value);
+                    return { kind: 'number', sourceText: sourceNumber,
+                        ...(Number.isFinite(value) && (!Number.isInteger(value) || Number.isSafeInteger(value)) ? { value } : {}), range };
+                }
+                if (typeof value === 'string')
+                    return { kind: 'string', value, range };
+                throw new Error('Unsupported YAML scalar');
+            }
+            if (isSeq(node))
+                return { kind: 'array', items: node.items.map(item => convert(item, depth + 1)), range };
+            if (isMap(node)) {
+                const entries = [];
+                const seen = new Set();
+                for (const pair of node.items) {
+                    if (!isScalar(pair.key) || typeof pair.key.value !== 'string')
+                        throw new Error('YAML mapping keys must be strings');
+                    const key = pair.key.value;
+                    if (seen.has(key))
+                        throw new Error(`Duplicate YAML key: ${key}`);
+                    seen.add(key);
+                    entries.push({ key, value: convert(pair.value, depth + 1), range: rangeOf(pair.key) });
+                }
+                return { kind: 'object', entries, range };
+            }
+            throw new Error('Unsupported YAML node');
+        };
+        return { ok: true, document: { format: 'yaml', root: convert(yaml.contents, 0), sourceText }, diagnostics: [] };
+    }
+    catch (error) {
+        const message = String(error);
+        const code = message.includes('limit') ? 'limit_exceeded' : 'unsupported_construct';
+        return { ok: false, diagnostics: [diagnostic(code, message)] };
+    }
+}
+
+/** Loads only same-origin packaged assets, and only when invoked in a browser. */
+async function parseHclText(sourceText, limits) {
+    let bounded;
+    try {
+        bounded = effectiveLimits(limits);
+    }
+    catch (error) {
+        return { ok: false, diagnostics: [diagnostic('limit_exceeded', String(error))] };
+    }
+    if (exceedsSourceLimit(sourceText, bounded.maxSourceBytes)) {
+        return { ok: false, diagnostics: [diagnostic('limit_exceeded', `HCL source exceeds ${bounded.maxSourceBytes} bytes`)] };
+    }
+    if (typeof Worker === 'undefined') {
+        return { ok: false, diagnostics: [diagnostic('parser_unavailable', 'HCL parsing requires a browser Worker')] };
+    }
+    let worker;
+    try {
+        worker = new Worker(new URL('../assets/hcl-worker.mjs', import.meta.url), { type: 'module' });
+    }
+    catch (error) {
+        return { ok: false, diagnostics: [diagnostic('parser_unavailable', `HCL Worker could not start: ${String(error)}`)] };
+    }
+    return new Promise(resolve => {
+        let settled = false;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            worker.terminate();
+            resolve(result);
+        };
+        const timer = setTimeout(() => finish({ ok: false,
+            diagnostics: [diagnostic('limit_exceeded', 'HCL parsing exceeded its hard deadline')] }), bounded.timeoutMs + 1_000);
+        worker.onmessage = (event) => {
+            const reply = event.data;
+            if (!reply || reply.id !== 1)
+                return;
+            if (reply.ok && reply.root)
+                finish({ ok: true,
+                    document: { format: 'hcl', root: reply.root, sourceText }, diagnostics: [] });
+            else
+                finish({ ok: false, diagnostics: reply.diagnostics?.length
+                        ? reply.diagnostics : [diagnostic('invalid_syntax', 'HCL parser returned no document')] });
+        };
+        worker.onerror = () => finish({ ok: false,
+            diagnostics: [diagnostic('parser_unavailable', 'HCL Worker failed to load its packaged assets')] });
+        worker.postMessage({ id: 1, sourceText, limits: bounded });
+    });
+}
+
+/** RFC 6901 without wildcards, evaluation, or prototype traversal. */
+function parseRelativePointer(pointer, maxLength = DEFAULT_LIMITS.maxSelectorLength, maxDepth = DEFAULT_LIMITS.maxSelectorDepth) {
+    if (pointer === '')
+        return [];
+    if (!pointer.startsWith('/') || pointer.length > maxLength)
+        return null;
+    const parts = pointer.slice(1).split('/');
+    if (parts.length > maxDepth)
+        return null;
+    const decoded = [];
+    for (const part of parts) {
+        if (/~(?![01])/.test(part))
+            return null;
+        const value = part.replace(/~1/g, '/').replace(/~0/g, '~');
+        if (value === '__proto__' || value === 'prototype' || value === 'constructor')
+            return null;
+        decoded.push(value);
+    }
+    return decoded;
+}
+const missing = { found: false };
+function selectRelative(node, pointer) {
+    const parts = parseRelativePointer(pointer);
+    if (parts === null)
+        return missing;
+    let current = node;
+    for (let index = 0; index < parts.length; index++) {
+        const part = parts[index];
+        if (current.kind === 'hcl-block')
+            current = current.body;
+        if (current.kind === 'hcl-attribute')
+            current = current.value;
+        if (current.kind === 'hcl-body') {
+            const body = current;
+            if (part === 'attributes' && index + 1 < parts.length) {
+                const name = parts[++index];
+                const found = body.members.find(member => member.kind === 'hcl-attribute' && member.name === name);
+                if (!found || found.kind !== 'hcl-attribute')
+                    return missing;
+                current = found.value;
+                continue;
+            }
+            if (part === 'blocks' && index + 1 < parts.length) {
+                const position = Number(parts[++index]);
+                if (!Number.isSafeInteger(position) || position < 0 || String(position) !== parts[index])
+                    return missing;
+                const found = body.members.filter(member => member.kind === 'hcl-block')[position];
+                if (!found)
+                    return missing;
+                current = found;
+                continue;
+            }
+            return missing;
+        }
+        if (current.kind === 'object') {
+            const found = current.entries.find(entry => entry.key === part);
+            if (!found)
+                return missing;
+            current = found.value;
+            continue;
+        }
+        if (current.kind === 'array') {
+            const position = Number(part);
+            if (!Number.isSafeInteger(position) || position < 0 || String(position) !== part)
+                return missing;
+            const found = current.items[position];
+            if (!found)
+                return missing;
+            current = found;
+            continue;
+        }
+        return missing;
+    }
+    return { found: true, value: current };
+}
+function selectViewPath(context, path) {
+    if (path === '$key')
+        return context.key === undefined ? missing
+            : { found: true, value: { kind: 'string', value: context.key } };
+    if (path.startsWith('$label/')) {
+        const position = Number(path.slice('$label/'.length));
+        if (!Number.isSafeInteger(position) || position < 0 || String(position) !== path.slice('$label/'.length))
+            return missing;
+        const value = context.labels?.[position];
+        return value === undefined ? missing : { found: true, value: { kind: 'string', value } };
+    }
+    return selectRelative(context.node, path);
+}
+
+function record(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return null;
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null)
+        return null;
+    for (const property of Object.values(Object.getOwnPropertyDescriptors(value))) {
+        if (!('value' in property))
+            return null;
+    }
+    return value;
+}
+function exactKeys(value, allowed) {
+    return Object.keys(value).every(key => allowed.includes(key));
+}
+function text(value, max = 256) {
+    return typeof value === 'string' && value.length > 0 && value.length <= max;
+}
+function pointer(value, limits, allowSpecial = false) {
+    if (typeof value !== 'string')
+        return false;
+    if (allowSpecial && (value === '$key' || /^\$label\/(0|[1-9]\d{0,2})$/.test(value)))
+        return true;
+    return parseRelativePointer(value, limits.maxSelectorLength, limits.maxSelectorDepth) !== null;
+}
+function safeGlob(value, limits) {
+    return text(value, limits.maxSelectorLength) && !value.startsWith('/') && !value.includes('..')
+        && /^[A-Za-z0-9_./*?@-]+$/.test(value);
+}
+function parseTitle(value, limits) {
+    const source = record(value);
+    if (!source || !exactKeys(source, ['label', 'path']) || !text(source['label']) || !pointer(source['path'], limits))
+        return null;
+    return { label: source['label'], path: source['path'] };
+}
+function parseFields(value, limits) {
+    if (!Array.isArray(value) || value.length > 64)
+        return null;
+    const result = [];
+    for (const item of value) {
+        const field = record(item);
+        if (!field || !exactKeys(field, ['label', 'path', 'scalarListLayout']) || !text(field['label'])
+            || !pointer(field['path'], limits) || (field['scalarListLayout'] !== undefined
+            && field['scalarListLayout'] !== 'inline' && field['scalarListLayout'] !== 'list'))
+            return null;
+        result.push({ label: field['label'], path: field['path'],
+            ...(field['scalarListLayout'] ? { scalarListLayout: field['scalarListLayout'] } : {}) });
+    }
+    return result;
+}
+function parseColumns(value, limits) {
+    if (!Array.isArray(value) || value.length === 0 || value.length > 64)
+        return null;
+    const result = [];
+    for (const item of value) {
+        const column = record(item);
+        if (!column || !exactKeys(column, ['label', 'path']) || !text(column['label'])
+            || !pointer(column['path'], limits, true))
+            return null;
+        result.push({ label: column['label'], path: column['path'] });
+    }
+    return result;
+}
+function parseSections(value, limits, counter, depth = 0) {
+    if (!Array.isArray(value) || depth > limits.maxDepth || value.length > limits.maxSections)
+        return null;
+    const result = [];
+    const ids = new Set();
+    for (const item of value) {
+        if (++counter.count > limits.maxSections)
+            return null;
+        const section = record(item);
+        if (!section || !text(section['id'], 100) || !/^[A-Za-z0-9_-]+$/.test(section['id'])
+            || ids.has(section['id']) || !text(section['title']) || !pointer(section['path'], limits))
+            return null;
+        ids.add(section['id']);
+        const base = { id: section['id'], title: section['title'], path: section['path'] };
+        if (section['kind'] === 'fields') {
+            if (!exactKeys(section, ['id', 'title', 'kind', 'path', 'fields']))
+                return null;
+            const fields = parseFields(section['fields'], limits);
+            if (!fields)
+                return null;
+            result.push({ ...base, kind: 'fields', fields });
+            continue;
+        }
+        if (section['kind'] === 'value') {
+            if (!exactKeys(section, ['id', 'title', 'kind', 'path', 'scalarListLayout'])
+                || (section['scalarListLayout'] !== undefined && section['scalarListLayout'] !== 'inline'
+                    && section['scalarListLayout'] !== 'list'))
+                return null;
+            result.push({ ...base, kind: 'value',
+                ...(section['scalarListLayout'] ? { scalarListLayout: section['scalarListLayout'] } : {}) });
+            continue;
+        }
+        if (section['kind'] === 'table') {
+            if (!exactKeys(section, ['id', 'title', 'kind', 'path', 'rows', 'blockType', 'columns'])
+                || !['dictionary', 'list', 'blocks'].includes(String(section['rows']))
+                || (section['blockType'] !== undefined && !text(section['blockType'], 100)))
+                return null;
+            const columns = parseColumns(section['columns'], limits);
+            if (!columns)
+                return null;
+            result.push({ ...base, kind: 'table', rows: section['rows'], columns,
+                ...(section['blockType'] ? { blockType: section['blockType'] } : {}) });
+            continue;
+        }
+        if (section['kind'] === 'entries' || section['kind'] === 'blocks') {
+            const blocks = section['kind'] === 'blocks';
+            if (!exactKeys(section, blocks
+                ? ['id', 'title', 'kind', 'path', 'blockType', 'presentation', 'allowLayoutSwitch', 'initiallyExpanded', 'entry']
+                : ['id', 'title', 'kind', 'path', 'presentation', 'allowLayoutSwitch', 'initiallyExpanded', 'entry']))
+                return null;
+            if (blocks && !text(section['blockType'], 100))
+                return null;
+            if (section['presentation'] !== undefined && section['presentation'] !== 'list' && section['presentation'] !== 'accordion')
+                return null;
+            if (section['allowLayoutSwitch'] !== undefined && typeof section['allowLayoutSwitch'] !== 'boolean')
+                return null;
+            if (section['initiallyExpanded'] !== undefined && !['first', 'all', 'none'].includes(String(section['initiallyExpanded'])))
+                return null;
+            let entry;
+            if (section['entry'] !== undefined) {
+                const rawEntry = record(section['entry']);
+                if (!rawEntry || !exactKeys(rawEntry, ['heading', 'sections']) || !text(rawEntry['heading'])
+                    || !pointer(rawEntry['heading'], limits, true))
+                    return null;
+                const nested = rawEntry['sections'] === undefined ? undefined
+                    : parseSections(rawEntry['sections'], limits, counter, depth + 1);
+                if (rawEntry['sections'] !== undefined && !nested)
+                    return null;
+                entry = { heading: rawEntry['heading'], ...(nested ? { sections: nested } : {}) };
+            }
+            const common = { ...base,
+                ...(section['presentation'] ? { presentation: section['presentation'] } : {}),
+                ...(section['allowLayoutSwitch'] !== undefined ? { allowLayoutSwitch: section['allowLayoutSwitch'] } : {}),
+                ...(section['initiallyExpanded'] ? { initiallyExpanded: section['initiallyExpanded'] } : {}),
+                ...(entry ? { entry } : {}) };
+            result.push(blocks ? { ...common, kind: 'blocks', blockType: section['blockType'] }
+                : { ...common, kind: 'entries' });
+            continue;
+        }
+        return null;
+    }
+    return result;
+}
+function validateViewConfig(input, limits) {
+    let bounded;
+    try {
+        bounded = effectiveLimits(limits);
+    }
+    catch (error) {
+        return { ok: false, diagnostics: [diagnostic('limit_exceeded', String(error))] };
+    }
+    const source = record(input);
+    if (!source || !exactKeys(source, ['version', 'rules']) || source['version'] !== 1
+        || !Array.isArray(source['rules']) || source['rules'].length > bounded.maxRules) {
+        return { ok: false, diagnostics: [diagnostic('invalid_config', 'Expected version 1 and a bounded rules array')] };
+    }
+    const rules = [];
+    const ids = new Set();
+    const counter = { count: 0 };
+    for (const item of source['rules']) {
+        const rule = record(item);
+        if (!rule || !exactKeys(rule, ['id', 'match', 'parser', 'title', 'sections']) || !text(rule['id'], 100)
+            || !/^[A-Za-z0-9_-]+$/.test(rule['id']) || ids.has(rule['id'])
+            || !safeGlob(rule['match'], bounded) || !['json', 'yaml', 'hcl'].includes(String(rule['parser']))) {
+            return { ok: false, diagnostics: [diagnostic('invalid_config', 'Invalid or duplicate view rule')] };
+        }
+        ids.add(rule['id']);
+        const title = rule['title'] === undefined ? undefined : parseTitle(rule['title'], bounded);
+        if (rule['title'] !== undefined && !title)
+            return { ok: false, diagnostics: [diagnostic('invalid_config', `Invalid title in ${rule['id']}`)] };
+        const sections = rule['sections'] === undefined ? undefined : parseSections(rule['sections'], bounded, counter);
+        if (rule['sections'] !== undefined && !sections)
+            return { ok: false, diagnostics: [diagnostic('invalid_config', `Invalid sections in ${rule['id']}`)] };
+        rules.push({ id: rule['id'], match: rule['match'], parser: rule['parser'],
+            ...(title ? { title } : {}), ...(sections ? { sections } : {}) });
+    }
+    return { ok: true, config: { version: 1, rules } };
+}
+function plain(node) {
+    switch (node.kind) {
+        case 'null': return null;
+        case 'boolean':
+        case 'string': return node.value;
+        case 'number': return node.value ?? Number(node.sourceText);
+        case 'array': return node.items.map(plain);
+        case 'object': return Object.fromEntries(node.entries.map(entry => [entry.key, plain(entry.value)]));
+        default: throw new Error('Configuration cannot contain HCL or expressions');
+    }
+}
+function parseViewConfigText(textSource, format, sourcePath, limits) {
+    let bounded;
+    try {
+        bounded = effectiveLimits(limits);
+    }
+    catch (error) {
+        return { ok: false, diagnostics: [diagnostic('limit_exceeded', String(error))] };
+    }
+    if (exceedsSourceLimit(textSource, bounded.maxConfigBytes)) {
+        return { ok: false, diagnostics: [diagnostic('limit_exceeded', `View config exceeds ${bounded.maxConfigBytes} bytes`, undefined, sourcePath)] };
+    }
+    const parsed = format === 'json' ? parseJsonText(textSource, { ...bounded, maxSourceBytes: bounded.maxConfigBytes })
+        : parseYamlText(textSource, { ...bounded, maxSourceBytes: bounded.maxConfigBytes });
+    if (!parsed.ok)
+        return { ok: false, diagnostics: parsed.diagnostics.map(item => ({ ...item, source: sourcePath })) };
+    try {
+        return validateViewConfig(plain(parsed.document.root), bounded);
+    }
+    catch (error) {
+        return { ok: false, diagnostics: [diagnostic('invalid_config', String(error), undefined, sourcePath)] };
+    }
+}
+function matchGlob(glob, path) {
+    if (path.length > 4_096)
+        return false;
+    const width = path.length + 1;
+    const table = new Uint8Array((glob.length + 1) * width);
+    const at = (pattern, position) => table[pattern * width + position];
+    table[glob.length * width + path.length] = 1;
+    for (let pattern = glob.length - 1; pattern >= 0; pattern--) {
+        let consumedDirectory = false;
+        for (let position = path.length; position >= 0; position--) {
+            const character = glob[pattern];
+            const remaining = position < path.length;
+            let matches = false;
+            if (character === '*' && glob[pattern + 1] === '*' && glob[pattern + 2] === '/') {
+                consumedDirectory = remaining && ((path[position] === '/' && !!at(pattern + 3, position + 1)) || consumedDirectory);
+                matches = !!at(pattern + 3, position) || consumedDirectory;
+            }
+            else if (character === '*' && glob[pattern + 1] === '*') {
+                matches = !!at(pattern + 2, position) || (remaining && !!at(pattern, position + 1));
+            }
+            else if (character === '*') {
+                matches = !!at(pattern + 1, position) || (remaining && path[position] !== '/' && !!at(pattern, position + 1));
+            }
+            else if (character === '?') {
+                matches = remaining && path[position] !== '/' && !!at(pattern + 1, position + 1);
+            }
+            else {
+                matches = remaining && character === path[position] && !!at(pattern + 1, position + 1);
+            }
+            table[pattern * width + position] = matches ? 1 : 0;
+        }
+    }
+    return !!at(0, 0);
+}
+function resolveViewRule(options) {
+    let bounded;
+    try {
+        bounded = effectiveLimits(options.limits);
+    }
+    catch (error) {
+        return { status: 'error', diagnostics: [diagnostic('limit_exceeded', String(error))] };
+    }
+    const pathSegments = options.repositoryPath.split('/');
+    if (options.repositoryPath.length > 4_096 || options.repositoryPath.startsWith('/')
+        || options.repositoryPath.includes('\\')
+        || [...options.repositoryPath].some(character => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127)
+        || pathSegments.some(segment => segment === '.' || segment === '..' || segment === '')) {
+        return { status: 'error', diagnostics: [diagnostic('invalid_config', 'Invalid repository path for view resolution')] };
+    }
+    const limits = options.limits;
+    const merged = [];
+    const append = (rule) => {
+        const previous = merged.findIndex(candidate => candidate.id === rule.id);
+        if (previous >= 0)
+            merged.splice(previous, 1);
+        merged.push(rule);
+    };
+    if (options.builtInRules?.length) {
+        const checked = validateViewConfig({ version: 1, rules: options.builtInRules }, limits);
+        if (!checked.ok)
+            return { status: 'error', diagnostics: checked.diagnostics };
+        checked.config.rules.forEach(append);
+        if (merged.length > bounded.maxRules) {
+            return { status: 'error', diagnostics: [diagnostic('limit_exceeded', 'Too many combined view rules')] };
+        }
+    }
+    const levels = new Set();
+    for (const document of options.orderedDocuments) {
+        const level = document.sourcePath.replace(/\/[^/]+$/, '');
+        if (levels.has(level))
+            return { status: 'error', diagnostics: [diagnostic('invalid_config', `Multiple view config files at ${level}`)] };
+        levels.add(level);
+        const checked = validateViewConfig(document.config, limits);
+        if (!checked.ok)
+            return { status: 'error', diagnostics: checked.diagnostics.map(item => ({ ...item, source: document.sourcePath })) };
+        checked.config.rules.forEach(append);
+        if (merged.length > bounded.maxRules) {
+            return { status: 'error', diagnostics: [diagnostic('limit_exceeded', 'Too many combined view rules')] };
+        }
+    }
+    const path = options.repositoryPath.replace(/^\/+/, '');
+    let matchingWork = 0;
+    for (let index = merged.length - 1; index >= 0; index--) {
+        matchingWork += (merged[index].match.length + 1) * (path.length + 1);
+        if (matchingWork > 8_000_000) {
+            return { status: 'error', diagnostics: [diagnostic('limit_exceeded', 'View rule matching work limit exceeded')] };
+        }
+        if (matchGlob(merged[index].match, path))
+            return { status: 'matched', parser: merged[index].parser, view: merged[index] };
+    }
+    const suffix = path.toLowerCase().split('.').pop();
+    if (suffix === 'json' || suffix === 'yaml' || suffix === 'hcl')
+        return { status: 'generic', parser: suffix };
+    if (suffix === 'yml')
+        return { status: 'generic', parser: 'yaml' };
+    return { status: 'unsupported', diagnostics: [diagnostic('unsupported_format', 'No JSON, YAML, or HCL view applies')] };
+}
+
+function parseStructuredText(sourceText, format, limits) {
+    if (format === 'json')
+        return Promise.resolve(parseJsonText(sourceText, limits));
+    if (format === 'yaml')
+        return Promise.resolve(parseYamlText(sourceText, limits));
+    return parseHclText(sourceText, limits);
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { DEFAULT_LIMITS, parseHclText, parseJsonText, parseRelativePointer, parseStructuredText, parseViewConfigText, parseYamlText, resolveViewRule, selectRelative, selectViewPath, validateViewConfig };
+//# sourceMappingURL=sneat-structured-data-core.mjs.map