@agentshouse/mdmodel 0.1.0-alpha.9 → 0.1.0-c04c0d681d2d4

package/dist/yaml.js

@@ -1,7 +1,8 @@
 export class YamlError extends Error {
     offset;
-    constructor(offset){
-        super('yaml'), this.offset = offset;
+    constructor(offset) {
+        super('yaml');
+        this.offset = offset;
         this.name = 'YamlError';
     }
 }
@@ -9,20 +10,26 @@ function peek(c) {
     return c.i < c.end ? c.text[c.i] : '';
 }
 function skipEol(c) {
-    if (peek(c) === '\r') c.i += 1;
-    if (peek(c) === '\n') c.i += 1;
+    if (peek(c) === '\r')
+        c.i += 1;
+    if (peek(c) === '\n')
+        c.i += 1;
 }
 function skipSpaces(c) {
-    while(peek(c) === ' ')c.i += 1;
-    if (peek(c) === '\t') throw new YamlError(c.i);
+    while (peek(c) === ' ')
+        c.i += 1;
+    if (peek(c) === '\t')
+        throw new YamlError(c.i);
 }
 function skipToEol(c) {
-    while(c.i < c.end && peek(c) !== '\n' && peek(c) !== '\r')c.i += 1;
+    while (c.i < c.end && peek(c) !== '\n' && peek(c) !== '\r')
+        c.i += 1;
 }
 function skipBlankAndComments(c) {
-    while(c.i < c.end){
+    while (c.i < c.end) {
         skipSpaces(c);
-        if (peek(c) === '#') skipToEol(c);
+        if (peek(c) === '#')
+            skipToEol(c);
         if (peek(c) === '\r' || peek(c) === '\n') {
             skipEol(c);
             continue;
@@ -31,7 +38,7 @@ function skipBlankAndComments(c) {
     }
 }
 function skipFlowSpace(c) {
-    while(c.i < c.end){
+    while (c.i < c.end) {
         const ch = peek(c);
         if (ch === ' ' || ch === '\n' || ch === '\r') {
             c.i += 1;
@@ -41,64 +48,86 @@ function skipFlowSpace(c) {
             skipToEol(c);
             continue;
         }
-        if (ch === '\t') throw new YamlError(c.i);
+        if (ch === '\t')
+            throw new YamlError(c.i);
         break;
     }
 }
 function indentAt(c) {
     let j = c.i;
-    while(j > 0 && c.text[j - 1] !== '\n')j -= 1;
+    while (j > 0 && c.text[j - 1] !== '\n' && c.text[j - 1] !== '\r')
+        j -= 1;
     let n = 0;
-    while(j < c.i){
+    while (j < c.i) {
         const ch = c.text[j];
-        if (ch === ' ') n += 1;
-        else if (ch === '\t') throw new YamlError(j);
-        else break;
+        if (ch === ' ')
+            n += 1;
+        else if (ch === '\t')
+            throw new YamlError(j);
+        else
+            break;
         j += 1;
     }
     return n;
 }
 function scalar(value, start, end) {
-    return {
-        kind: 'scalar',
-        value,
-        start,
-        end
-    };
-}
-function interpretPlain(text) {
-    if (text === 'true') return true;
-    if (text === 'false') return false;
-    if (text === 'null' || text === '') return null;
-    if (/^-?(0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?$/.test(text)) return Number(text);
+    return { kind: 'scalar', value, start, end };
+}
+export function interpretPlain(text) {
+    if (text === 'true')
+        return true;
+    if (text === 'false')
+        return false;
+    if (text === 'null' || text === '')
+        return null;
+    if (/^-?(0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?$/.test(text))
+        return Number(text);
     return text;
 }
+const ESCAPES = {
+    b: '\b',
+    f: '\f',
+    n: '\n',
+    r: '\r',
+    t: '\t',
+    '"': '"',
+    '/': '/',
+    '\\': '\\',
+};
+function parseEscape(c) {
+    c.i += 1;
+    const escaped = peek(c);
+    const held = ESCAPES[escaped];
+    if (held !== undefined) {
+        c.i += 1;
+        return held;
+    }
+    const hex = c.text.slice(c.i + 1, c.i + 5);
+    if (escaped !== 'u' || c.i + 5 > c.end || !/^[0-9A-Fa-f]{4}$/.test(hex))
+        throw new YamlError(c.i);
+    c.i += 5;
+    return String.fromCharCode(Number.parseInt(hex, 16));
+}
 function parseQuoted(c) {
     const quote = peek(c);
     const start = c.i;
     c.i += 1;
     let out = '';
-    while(c.i < c.end){
+    while (c.i < c.end) {
         const ch = peek(c);
-        if (ch === quote) {
-            c.i += 1;
-            return scalar(out, start, c.i);
-        }
-        if (ch === '\n' || ch === '\r') throw new YamlError(c.i);
-        if (quote === "'" && ch === "'" && c.text[c.i + 1] === "'") {
+        if (quote === "'" && ch === "'" && c.i + 1 < c.end && c.text[c.i + 1] === "'") {
             out += "'";
             c.i += 2;
             continue;
         }
-        if (quote === '"' && ch === '\\') {
-            c.i += 1;
-            const escaped = peek(c);
-            if (escaped === 'n') out += '\n';
-            else if (escaped === 't') out += '\t';
-            else if (escaped === '"') out += '"';
-            else if (escaped === '\\') out += '\\';
-            else throw new YamlError(c.i);
+        if (ch === quote) {
             c.i += 1;
+            return scalar(out, start, c.i);
+        }
+        if (ch === '\n' || ch === '\r')
+            throw new YamlError(c.i);
+        if (quote === '"' && ch === '\\') {
+            out += parseEscape(c);
             continue;
         }
         out += ch;
@@ -108,90 +137,95 @@ function parseQuoted(c) {
 }
 function parsePlain(c, flow) {
     const start = c.i;
-    while(c.i < c.end){
+    while (c.i < c.end) {
         const ch = peek(c);
-        if (flow && (ch === ',' || ch === ']' || ch === '}')) break;
-        if (ch === '\n' || ch === '\r') break;
-        if (ch === '#' && (c.i === start || c.text[c.i - 1] === ' ' || c.text[c.i - 1] === '\t')) break;
+        if (flow && (ch === ',' || ch === ']' || ch === '}'))
+            break;
+        if (ch === '\n' || ch === '\r')
+            break;
+        if (ch === '#' && (c.i === start || c.text[c.i - 1] === ' ' || c.text[c.i - 1] === '\t'))
+            break;
         c.i += 1;
     }
-    if (c.i === start) throw new YamlError(c.i);
+    if (c.i === start)
+        throw new YamlError(c.i);
     const raw = c.text.slice(start, c.i);
     const trimmed = raw.trimEnd();
     return scalar(interpretPlain(trimmed), start, start + trimmed.length);
 }
 function parseScalar(c, flow) {
     const ch = peek(c);
-    if (ch === '"' || ch === "'") return parseQuoted(c);
+    if (ch === '"' || ch === "'")
+        return parseQuoted(c);
     return parsePlain(c, flow);
 }
 function parseKey(c) {
     const start = c.i;
     if (peek(c) === '"' || peek(c) === "'") {
         const quoted = parseQuoted(c);
-        if (typeof quoted.value !== 'string') throw new YamlError(start);
-        return {
-            name: quoted.value,
-            start,
-            end: c.i
-        };
+        if (typeof quoted.value !== 'string')
+            throw new YamlError(start);
+        return { name: quoted.value, start, end: c.i };
     }
     let end = c.i;
-    while(c.i < c.end){
+    while (c.i < c.end) {
         const ch = peek(c);
-        if (ch === ':' || ch === '\n' || ch === '\r' || ch === ',' || ch === '}' || ch === ']' || ch === '#' || ch === '{' || ch === '[') {
+        if (ch === ':' ||
+            ch === '\n' ||
+            ch === '\r' ||
+            ch === ',' ||
+            ch === '}' ||
+            ch === ']' ||
+            ch === '#' ||
+            ch === '{' ||
+            ch === '[') {
             break;
         }
         c.i += 1;
-        if (ch !== ' ' && ch !== '\t') end = c.i;
+        if (ch !== ' ' && ch !== '\t')
+            end = c.i;
     }
-    if (end === start) throw new YamlError(c.i);
+    if (end === start)
+        throw new YamlError(c.i);
     c.i = end;
-    return {
-        name: c.text.slice(start, end),
-        start,
-        end
-    };
+    return { name: c.text.slice(start, end), start, end };
 }
 function parseFlowValue(c) {
     skipFlowSpace(c);
     const ch = peek(c);
-    if (ch === '{') return parseFlowMap(c);
-    if (ch === '[') return parseFlowSeq(c);
-    if (ch === '|' || ch === '>') throw new YamlError(c.i);
+    if (ch === '{')
+        return parseFlowMap(c);
+    if (ch === '[')
+        return parseFlowSeq(c);
+    if (ch === '|' || ch === '>')
+        throw new YamlError(c.i);
     return parseScalar(c, true);
 }
 function parseFlowMap(c) {
     const start = c.i;
-    if (peek(c) !== '{') throw new YamlError(c.i);
+    if (peek(c) !== '{')
+        throw new YamlError(c.i);
     c.i += 1;
     skipFlowSpace(c);
     const entries = [];
     const seen = new Set();
     if (peek(c) === '}') {
         c.i += 1;
-        return {
-            kind: 'map',
-            entries,
-            start,
-            end: c.i
-        };
+        return { kind: 'map', entries, start, end: c.i };
     }
-    while(c.i < c.end){
+    while (c.i < c.end) {
         skipFlowSpace(c);
         const key = parseKey(c);
         skipFlowSpace(c);
-        if (peek(c) !== ':') throw new YamlError(c.i);
+        if (peek(c) !== ':')
+            throw new YamlError(c.i);
         c.i += 1;
+        const after = c.i;
         const value = parseFlowValue(c);
-        if (seen.has(key.name)) throw new YamlError(key.start);
+        if (seen.has(key.name))
+            throw new YamlError(key.start);
         seen.add(key.name);
-        entries.push({
-            key: key.name,
-            keyStart: key.start,
-            keyEnd: key.end,
-            value
-        });
+        entries.push({ key: key.name, after, value });
         skipFlowSpace(c);
         if (peek(c) === ',') {
             c.i += 1;
@@ -199,12 +233,7 @@ function parseFlowMap(c) {
         }
         if (peek(c) === '}') {
             c.i += 1;
-            return {
-                kind: 'map',
-                entries,
-                start,
-                end: c.i
-            };
+            return { kind: 'map', entries, start, end: c.i };
         }
         throw new YamlError(c.i);
     }
@@ -212,20 +241,16 @@ function parseFlowMap(c) {
 }
 function parseFlowSeq(c) {
     const start = c.i;
-    if (peek(c) !== '[') throw new YamlError(c.i);
+    if (peek(c) !== '[')
+        throw new YamlError(c.i);
     c.i += 1;
     skipFlowSpace(c);
     const items = [];
     if (peek(c) === ']') {
         c.i += 1;
-        return {
-            kind: 'seq',
-            items,
-            start,
-            end: c.i
-        };
+        return { kind: 'seq', items, start, end: c.i };
     }
-    while(c.i < c.end){
+    while (c.i < c.end) {
         items.push(parseFlowValue(c));
         skipFlowSpace(c);
         if (peek(c) === ',') {
@@ -235,138 +260,213 @@ function parseFlowSeq(c) {
         }
         if (peek(c) === ']') {
             c.i += 1;
-            return {
-                kind: 'seq',
-                items,
-                start,
-                end: c.i
-            };
+            return { kind: 'seq', items, start, end: c.i };
         }
         throw new YamlError(c.i);
     }
     throw new YamlError(c.i);
 }
 function parseValue(c, parentKeyIndent) {
+    const at = c.i;
     skipSpaces(c);
-    if (peek(c) === '#') skipToEol(c);
+    if (peek(c) === '#')
+        skipToEol(c);
     const ch = peek(c);
     if (ch === '' || ch === '\n' || ch === '\r') {
         skipEol(c);
         skipBlankAndComments(c);
-        if (c.i >= c.end) return scalar(null, c.i, c.i);
+        if (c.i >= c.end)
+            return scalar(null, at, at);
         const nextIndent = indentAt(c);
-        if (nextIndent <= parentKeyIndent) return scalar(null, c.i, c.i);
-        if (peek(c) === '-') return parseBlockSeq(c, nextIndent);
-        if (peek(c) === '[') return parseFlowSeq(c);
-        if (peek(c) === '{') return parseFlowMap(c);
+        if (nextIndent === parentKeyIndent && seqAhead(c))
+            return parseBlockSeq(c, nextIndent);
+        if (nextIndent <= parentKeyIndent)
+            return scalar(null, at, at);
+        if (peek(c) === '-')
+            return parseBlockSeq(c, nextIndent);
+        if (peek(c) === '[')
+            return parseFlowSeq(c);
+        if (peek(c) === '{')
+            return parseFlowMap(c);
         return parseBlockMap(c, nextIndent);
     }
-    if (ch === '{') return parseFlowMap(c);
-    if (ch === '[') return parseFlowSeq(c);
-    if (ch === '|' || ch === '>') throw new YamlError(c.i);
+    if (ch === '{')
+        return parseFlowMap(c);
+    if (ch === '[')
+        return parseFlowSeq(c);
+    if (ch === '|' || ch === '>')
+        throw new YamlError(c.i);
     return parseScalar(c, false);
 }
+function seqAhead(c) {
+    const next = c.text[c.i + 1];
+    return peek(c) === '-' && (next === ' ' || next === '\n' || next === '\r' || c.i + 1 >= c.end);
+}
+function mappingAhead(c) {
+    const start = c.i;
+    try {
+        if (peek(c) === '{' || peek(c) === '[')
+            return false;
+        parseKey(c);
+        skipSpaces(c);
+        if (peek(c) !== ':')
+            return false;
+        const next = c.text[c.i + 1];
+        return next === ' ' || next === '\n' || next === '\r' || c.i + 1 >= c.end;
+    }
+    catch (error) {
+        if (error instanceof YamlError)
+            return false;
+        throw error;
+    }
+    finally {
+        c.i = start;
+    }
+}
+function lineStartOf(c) {
+    let j = c.i;
+    while (j > 0 && c.text[j - 1] !== '\n' && c.text[j - 1] !== '\r')
+        j -= 1;
+    return j;
+}
+function parseSeqItem(c, indent) {
+    skipSpaces(c);
+    if (peek(c) !== '#' && peek(c) !== '\n' && peek(c) !== '\r' && c.i < c.end && mappingAhead(c))
+        return parseBlockMap(c, c.i - lineStartOf(c), true);
+    return parseValue(c, indent);
+}
 function parseBlockSeq(c, indent) {
     const start = c.i;
     const items = [];
     let end = start;
-    while(c.i < c.end){
+    while (c.i < c.end) {
         skipBlankAndComments(c);
-        if (c.i >= c.end) break;
-        if (indentAt(c) !== indent) break;
-        if (peek(c) !== '-') break;
+        if (c.i >= c.end)
+            break;
+        if (indentAt(c) !== indent)
+            break;
+        if (peek(c) !== '-')
+            break;
         c.i += 1;
-        items.push(parseValue(c, indent));
-        end = c.i;
+        const item = parseSeqItem(c, indent);
+        items.push(item);
+        end = item.end;
     }
-    return {
-        kind: 'seq',
-        items,
-        start,
-        end
-    };
-}
-function parseBlockMap(c, indent) {
+    return { kind: 'seq', items, start, end };
+}
+function parseBlockMap(c, indent, inline = false) {
     const start = c.i;
     const entries = [];
     const seen = new Set();
     let end = start;
-    while(c.i < c.end){
-        skipBlankAndComments(c);
-        if (c.i >= c.end) break;
-        if (indentAt(c) < indent) break;
-        if (indentAt(c) > indent) throw new YamlError(c.i);
+    let first = inline;
+    while (c.i < c.end) {
+        if (!first) {
+            skipBlankAndComments(c);
+            if (c.i >= c.end)
+                break;
+            if (indentAt(c) < indent)
+                break;
+            if (indentAt(c) > indent)
+                throw new YamlError(c.i);
+        }
+        first = false;
         const key = parseKey(c);
         skipSpaces(c);
-        if (peek(c) !== ':') throw new YamlError(c.i);
+        if (peek(c) !== ':')
+            throw new YamlError(c.i);
         c.i += 1;
+        const after = c.i;
         const value = parseValue(c, indent);
-        if (seen.has(key.name)) throw new YamlError(key.start);
+        if (seen.has(key.name))
+            throw new YamlError(key.start);
         seen.add(key.name);
-        entries.push({
-            key: key.name,
-            keyStart: key.start,
-            keyEnd: key.end,
-            value
-        });
-        end = c.i;
+        entries.push({ key: key.name, after, value });
+        end = value.end;
     }
-    return {
-        kind: 'map',
-        entries,
-        start,
-        end
-    };
+    return { kind: 'map', entries, start, end };
 }
 export function parseYamlMapping(text, start, end) {
-    const c = {
-        text,
-        i: start,
-        end
-    };
+    const c = { text, i: start, end };
     skipBlankAndComments(c);
-    if (c.i >= end) return {
-        kind: 'map',
-        entries: [],
-        start,
-        end
-    };
+    if (c.i >= end)
+        return { kind: 'map', entries: [], start, end };
     if (peek(c) === '{') {
         const mapped = parseFlowMap(c);
         skipBlankAndComments(c);
-        if (c.i < end) throw new YamlError(c.i);
+        if (c.i < end)
+            throw new YamlError(c.i);
         return mapped;
     }
     const mapped = parseBlockMap(c, indentAt(c));
     skipBlankAndComments(c);
-    if (c.i < end) throw new YamlError(c.i);
+    if (c.i < end)
+        throw new YamlError(c.i);
     return mapped;
 }
 export function jsValue(node) {
-    if (node.kind === 'scalar') return node.value;
-    if (node.kind === 'seq') return node.items.map(jsValue);
+    if (node.kind === 'scalar')
+        return node.value;
+    if (node.kind === 'seq')
+        return node.items.map(jsValue);
     const record = Object.create(null);
-    for (const entry of node.entries)record[entry.key] = jsValue(entry.value);
+    for (const entry of node.entries)
+        record[entry.key] = jsValue(entry.value);
     return record;
 }
 export function mapEntry(map, key) {
-    return map.entries.find((entry)=>entry.key === key);
+    return map.entries.find((entry) => entry.key === key);
 }
 export function isPlainSafe(text) {
-    if (text === '' || text === 'true' || text === 'false' || text === 'null') return false;
-    if (/[\s#:{}[\],&*!|>'"%@`]/.test(text)) return false;
-    if (text.startsWith('-') || text.startsWith('?') || text.startsWith(':')) return false;
-    if (/^-?(0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?$/.test(text)) return false;
+    if (text === '' || text === 'true' || text === 'false' || text === 'null')
+        return false;
+    if (/[\s#:{}[\],&*!|>'"%@`]/.test(text))
+        return false;
+    if (text.startsWith('-') || text.startsWith('?') || text.startsWith(':'))
+        return false;
+    if (/^-?(0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?$/.test(text))
+        return false;
     return true;
 }
+export function plain(value) {
+    if (!isRecord(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function listed(value) {
+    const keys = Object.keys(value);
+    return keys.length === value.length && keys.every((key, index) => key === String(index));
+}
+function heldWithin(value, within) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean')
+        return true;
+    if (typeof value === 'number')
+        return Number.isFinite(value);
+    if (typeof value !== 'object' || within.includes(value))
+        return false;
+    const path = [...within, value];
+    const held = (item) => heldWithin(item, path);
+    if (Array.isArray(value))
+        return listed(value) && value.every(held);
+    return plain(value) && Object.values(value).every(held);
+}
+export function frontmatterValue(value) {
+    return heldWithin(value, []);
+}
 export function serializeJs(value) {
-    if (value === null) return 'null';
-    if (value === true) return 'true';
-    if (value === false) return 'false';
-    if (typeof value === 'number' && Number.isFinite(value)) return JSON.stringify(value);
-    if (typeof value === 'string') return isPlainSafe(value) ? value : JSON.stringify(value);
-    if (Array.isArray(value)) return `[${value.map(serializeJs).join(', ')}]`;
-    throw new YamlError(0);
+    if (typeof value === 'string')
+        return isPlainSafe(value) ? value : JSON.stringify(value);
+    if (value === null || typeof value !== 'object')
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(serializeJs).join(', ')}]`;
+    return `{${Object.entries(value)
+        .map(([key, held]) => `${serializeKey(key)}: ${serializeJs(held)}`)
+        .join(', ')}}`;
+}
+export function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
 export function serializeKey(name) {
     return isPlainSafe(name) || /^[A-Za-z][A-Za-z0-9_-]*$/.test(name) ? name : JSON.stringify(name);
@@ -383,47 +483,46 @@ export function bodyAfterFrontmatter(content) {
     return content.slice(bodyStartOf(content));
 }
 export function extractFrontmatter(content) {
-    if (!content.startsWith('---')) return {
-        kind: 'none'
-    };
+    if (!content.startsWith('---'))
+        return { kind: 'none' };
     const firstNl = content.indexOf('\n');
-    const firstLine = firstNl === -1 ? content : content.slice(0, content[firstNl - 1] === '\r' ? firstNl - 1 : firstNl);
-    if (!/^---[ \t]*$/.test(firstLine)) return {
-        kind: 'none'
-    };
-    if (firstNl === -1) return {
-        kind: 'unclosed'
-    };
+    const firstLine = firstNl === -1
+        ? content
+        : content.slice(0, content[firstNl - 1] === '\r' ? firstNl - 1 : firstNl);
+    if (!/^---[ \t]*$/.test(firstLine))
+        return { kind: 'none' };
+    if (firstNl === -1)
+        return { kind: 'unclosed' };
     const yamlStart = firstNl + 1;
     let i = yamlStart;
-    while(i <= content.length){
+    while (i <= content.length) {
         const nl = content.indexOf('\n', i);
         const lineEnd = nl === -1 ? content.length : nl;
         let line = content.slice(i, lineEnd);
-        if (line.endsWith('\r')) line = line.slice(0, -1);
-        if (/^---[ \t]*$/.test(line)) return {
-            kind: 'ok',
-            yamlStart,
-            yamlEnd: i
-        };
-        if (nl === -1) return {
-            kind: 'unclosed'
-        };
+        if (line.endsWith('\r'))
+            line = line.slice(0, -1);
+        if (/^---[ \t]*$/.test(line))
+            return { kind: 'ok', yamlStart, yamlEnd: i };
+        if (nl === -1)
+            return { kind: 'unclosed' };
         i = nl + 1;
     }
-    return {
-        kind: 'unclosed'
-    };
+    return { kind: 'unclosed' };
 }
 export function equalValue(left, right) {
-    if (left === right) return true;
+    if (left === right)
+        return true;
     if (Array.isArray(left) && Array.isArray(right)) {
-        return left.length === right.length && left.every((item, index)=>equalValue(item, right[index]));
+        return (left.length === right.length &&
+            Array.from(left).every((item, index) => equalValue(item, right[index])));
+    }
+    if (isRecord(left) && isRecord(right)) {
+        const keys = Object.keys(left);
+        return (keys.length === Object.keys(right).length &&
+            keys.every((key) => Object.hasOwn(right, key) && equalValue(left[key], right[key])));
     }
     return false;
 }
 export function lineEnding(content) {
     return content.includes('\r\n') ? '\r\n' : '\n';
 }
-
-//# sourceMappingURL=yaml.js.map