@agentshouse/mdmodel 0.1.0-alpha.8 → 0.1.0-c83456e1cebfb

package/dist/definition.js

@@ -1,165 +1,180 @@
-import { typeNameFromPath } from './paths.js';
-import { refusal } from './refuse.js';
-function refuse(file, rule, location) {
-    return location === undefined ? refusal(file, rule) : refusal(file, rule, {
-        location
-    });
+import { jsValue, parseYamlMapping, YamlError } from './yaml.js';
+function refuse(rule, location) {
+    return location === undefined ? { rule } : { rule, location };
 }
 function isRecord(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
 function requiredFlag(value) {
-    if (value === undefined) return false;
-    if (typeof value === 'boolean') return value;
+    if (value === undefined)
+        return false;
+    if (typeof value === 'boolean')
+        return value;
     return undefined;
 }
 function stringList(value) {
-    if (!Array.isArray(value) || value.length === 0) return undefined;
-    if (!value.every((item)=>typeof item === 'string' && item !== '')) return undefined;
-    return value;
+    if (!Array.isArray(value) || value.length === 0)
+        return undefined;
+    if (!value.every((item) => typeof item === 'string' && item !== ''))
+        return undefined;
+    return [...value];
 }
-const SCALAR_KINDS = new Set([
-    'string',
-    'number',
-    'date',
-    'enum',
-    'reference'
-]);
-function parseScalar(file, location, spec, required) {
+const SCALAR_KINDS = new Set(['text', 'string', 'number', 'date', 'enum', 'reference']);
+function parseScalar(names, location, spec, required) {
     const kind = spec.kind;
-    if (kind === 'string') return {
-        kind: 'string',
-        required
-    };
-    if (kind === 'number') return {
-        kind: 'number',
-        required
-    };
-    if (kind === 'date') return {
-        kind: 'date',
-        required
-    };
+    if (kind === 'text')
+        return { kind: 'text', required };
+    if (kind === 'string')
+        return { kind: 'string', required };
+    if (kind === 'number')
+        return { kind: 'number', required };
+    if (kind === 'date')
+        return { kind: 'date', required };
     if (kind === 'enum') {
         const values = stringList(spec.values);
-        if (values === undefined) return refuse(file, 'definition-enum-values', location);
-        return {
-            kind: 'enum',
-            required,
-            values
-        };
+        if (values === undefined)
+            return refuse('definition-enum-values', location);
+        return { kind: 'enum', required, values };
     }
     if (kind === 'reference') {
-        if (typeof spec.to !== 'string' || spec.to === '') return refuse(file, 'definition-reference-to', location);
-        return {
-            kind: 'reference',
-            required,
-            to: spec.to
-        };
+        if (typeof spec.to !== 'string' || (spec.to !== 'any' && !names.has(spec.to)))
+            return refuse('definition-reference-to', location);
+        return { kind: 'reference', required, to: spec.to };
     }
-    return refuse(file, 'definition-field-kind', location);
+    return refuse('definition-field-kind', location);
 }
 function extraKeys(spec, allowed) {
-    return Object.keys(spec).some((key)=>!allowed.includes(key));
+    return Object.keys(spec).some((key) => !allowed.includes(key));
 }
-function parseField(file, location, value) {
-    if (!isRecord(value) || typeof value.kind !== 'string') return refuse(file, 'definition-field', location);
-    const required = requiredFlag(value.required);
-    if (required === undefined) return refuse(file, 'definition-field', location);
-    if (value.kind === 'list') {
-        if (typeof value.of !== 'string' || !SCALAR_KINDS.has(value.of)) {
-            return refuse(file, 'definition-list-of', location);
-        }
-        const allowed = value.of === 'enum' ? [
-            'kind',
-            'required',
-            'of',
-            'values'
-        ] : value.of === 'reference' ? [
-            'kind',
-            'required',
-            'of',
-            'to'
-        ] : [
-            'kind',
-            'required',
-            'of'
-        ];
-        if (extraKeys(value, allowed)) return refuse(file, 'definition-field', location);
-        const inner = parseScalar(file, location, {
-            ...value,
-            kind: value.of
-        }, false);
-        if ('rule' in inner) return inner;
-        return {
-            kind: 'list',
-            required,
-            of: inner
-        };
+function parseList(names, location, spec, required, malformed) {
+    if (typeof spec.of !== 'string' || !SCALAR_KINDS.has(spec.of)) {
+        return refuse('definition-list-of', location);
     }
-    const allowed = value.kind === 'enum' ? [
-        'kind',
-        'required',
-        'values'
-    ] : value.kind === 'reference' ? [
-        'kind',
-        'required',
-        'to'
-    ] : [
-        'kind',
-        'required'
-    ];
-    if (extraKeys(value, allowed)) return refuse(file, 'definition-field', location);
-    return parseScalar(file, location, value, required);
+    const allowed = spec.of === 'enum'
+        ? ['kind', 'required', 'of', 'values']
+        : spec.of === 'reference'
+            ? ['kind', 'required', 'of', 'to']
+            : ['kind', 'required', 'of'];
+    if (extraKeys(spec, allowed))
+        return refuse(malformed, location);
+    const inner = parseScalar(names, location, { ...spec, kind: spec.of }, false);
+    if ('rule' in inner)
+        return inner;
+    return { kind: 'list', required, of: inner };
 }
-function parseSection(file, location, value) {
-    if (!isRecord(value) || value.kind !== 'text' && value.kind !== 'list') {
-        return refuse(file, 'definition-section-kind', location);
-    }
+function parseField(names, location, value) {
+    if (!isRecord(value) || typeof value.kind !== 'string')
+        return refuse('definition-field', location);
     const required = requiredFlag(value.required);
-    if (required === undefined || extraKeys(value, [
-        'kind',
-        'required'
-    ])) {
-        return refuse(file, 'definition-section', location);
+    if (required === undefined)
+        return refuse('definition-field', location);
+    if (value.kind === 'list')
+        return parseList(names, location, value, required, 'definition-field');
+    const allowed = value.kind === 'enum'
+        ? ['kind', 'required', 'values']
+        : value.kind === 'reference'
+            ? ['kind', 'required', 'to']
+            : ['kind', 'required'];
+    if (extraKeys(value, allowed))
+        return refuse('definition-field', location);
+    return parseScalar(names, location, value, required);
+}
+function parseSection(names, location, value) {
+    if (!isRecord(value) || (value.kind !== 'text' && value.kind !== 'list')) {
+        return refuse('definition-section-kind', location);
     }
-    return {
-        kind: value.kind,
-        required
-    };
+    const required = requiredFlag(value.required);
+    if (required === undefined)
+        return refuse('definition-section', location);
+    if (value.kind === 'list')
+        return parseList(names, location, value, required, 'definition-section');
+    if (extraKeys(value, ['kind', 'required']))
+        return refuse('definition-section', location);
+    return { kind: 'text', required };
 }
-export function readDefinition(file, document) {
-    if (document.type !== 'definition') return refuse(file, 'definition-type');
-    const name = typeNameFromPath(file);
-    if (name === '') return refuse(file, 'definition-type');
-    for (const key of Object.keys(document.fields)){
-        if (key !== 'type' && key !== 'fields' && key !== 'sections') {
-            return refuse(file, 'definition-shape', key);
+function readType(names, name, value) {
+    const location = `types.${name}`;
+    if (!isRecord(value))
+        return refuse('definition-shape', location);
+    for (const key of Object.keys(value)) {
+        if (key !== 'fields' && key !== 'sections' && key !== 'member_document') {
+            return refuse('definition-shape', `${location}.${key}`);
         }
     }
-    const fieldsValue = document.fields.fields;
-    const sectionsValue = document.fields.sections;
-    if (fieldsValue !== undefined && !isRecord(fieldsValue)) return refuse(file, 'definition-fields', 'fields');
+    const mark = value.member_document === undefined ? false : value.member_document;
+    if (typeof mark !== 'boolean')
+        return refuse('definition-shape', `${location}.member_document`);
+    const fieldsValue = value.fields;
+    const sectionsValue = value.sections;
+    if (fieldsValue !== undefined && !isRecord(fieldsValue))
+        return refuse('definition-fields', `${location}.fields`);
     if (sectionsValue !== undefined && !isRecord(sectionsValue)) {
-        return refuse(file, 'definition-sections', 'sections');
+        return refuse('definition-sections', `${location}.sections`);
     }
-    const fields = {};
-    for (const [fieldName, spec] of Object.entries(fieldsValue ?? {})){
-        const parsed = parseField(file, fieldName, spec);
-        if ('rule' in parsed) return parsed;
+    const fields = Object.create(null);
+    for (const [fieldName, spec] of Object.entries(fieldsValue ?? {})) {
+        const parsed = parseField(names, `${location}.fields.${fieldName}`, spec);
+        if ('rule' in parsed)
+            return parsed;
         fields[fieldName] = parsed;
     }
-    const sections = {};
-    for (const [sectionName, spec] of Object.entries(sectionsValue ?? {})){
-        const parsed = parseSection(file, sectionName, spec);
-        if ('rule' in parsed) return parsed;
+    const sections = Object.create(null);
+    for (const [sectionName, spec] of Object.entries(sectionsValue ?? {})) {
+        const parsed = parseSection(names, `${location}.sections.${sectionName}`, spec);
+        if ('rule' in parsed)
+            return parsed;
         sections[sectionName] = parsed;
     }
-    return {
-        name,
-        file,
-        fields,
-        sections
-    };
+    return { name, memberDocument: mark, fields, sections };
+}
+function freezeSpec(spec) {
+    if (spec.kind === 'list')
+        freezeSpec(spec.of);
+    if (spec.kind === 'enum')
+        Object.freeze(spec.values);
+    Object.freeze(spec);
+}
+function lineAt(text, offset) {
+    return text.slice(0, offset).split(/\r\n|\r|\n/).length;
+}
+export function readSchema(text) {
+    let root;
+    try {
+        root = jsValue(parseYamlMapping(text, 0, text.length));
+    }
+    catch (error) {
+        if (error instanceof YamlError)
+            return refuse('schema-yaml', `line ${lineAt(text, error.offset)}`);
+        throw error;
+    }
+    const schema = root;
+    for (const key of Object.keys(schema)) {
+        if (key !== 'types')
+            return refuse('schema-shape', key);
+    }
+    if (!isRecord(schema.types))
+        return refuse('schema-shape', 'types');
+    const names = new Set(Object.keys(schema.types));
+    if (names.has(''))
+        return refuse('schema-shape', 'types');
+    const types = Object.create(null);
+    let marked = false;
+    for (const [name, value] of Object.entries(schema.types)) {
+        const definition = readType(names, name, value);
+        if ('rule' in definition)
+            return definition;
+        if (definition.memberDocument) {
+            if (marked)
+                return refuse('schema-member-document', `types.${name}.member_document`);
+            marked = true;
+        }
+        for (const spec of Object.values(definition.fields))
+            freezeSpec(spec);
+        for (const spec of Object.values(definition.sections))
+            freezeSpec(spec);
+        Object.freeze(definition.fields);
+        Object.freeze(definition.sections);
+        types[name] = Object.freeze(definition);
+    }
+    return Object.freeze({ types: Object.freeze(types) });
 }
-
-//# sourceMappingURL=definition.js.map

package/dist/divide.d.ts

@@ -0,0 +1,3 @@
+import type { Division, DivisionContext, Document } from './types.js';
+export declare function divide(document: Document, file: string, context: DivisionContext): Division;
+//# sourceMappingURL=divide.d.ts.map

package/dist/divide.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"divide.d.ts","sourceRoot":"","sources":["../src/divide.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,eAAe,EAAE,QAAQ,EAAgB,MAAM,YAAY,CAAC;AA4WpF,wBAAgB,MAAM,CAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,QAAQ,CAc3F"}

package/dist/divide.js

@@ -0,0 +1,310 @@
+import { blockRanges, headingLines } from './blocks.js';
+import { projectionInput, rangeText } from './project.js';
+import { refusal } from './refuse.js';
+const SMALLEST_BUDGET = 2;
+function node(draft) {
+    return {
+        start: draft.start,
+        end: draft.end,
+        bodyStart: draft.bodyStart,
+        heading: draft.heading,
+        children: draft.children.map(node),
+    };
+}
+function forest(state, range) {
+    const content = state.content;
+    const headings = headingLines(content, range.start, range.end);
+    const roots = [];
+    const open = [];
+    const first = headings[0]?.start ?? range.end;
+    if (first > range.start) {
+        roots.push({
+            level: 0,
+            start: range.start,
+            end: first,
+            bodyStart: range.start,
+            heading: '',
+            children: [],
+        });
+    }
+    for (const heading of headings) {
+        while ((open[open.length - 1]?.level ?? 0) >= heading.level) {
+            open.pop().end = heading.start;
+        }
+        const draft = {
+            level: heading.level,
+            start: heading.start,
+            end: range.end,
+            bodyStart: heading.next,
+            heading: `${textOf(state, { start: heading.start, end: heading.textEnd })}\n\n`,
+            children: [],
+        };
+        (open[open.length - 1]?.children ?? roots).push(draft);
+        open.push(draft);
+    }
+    return roots.map(node);
+}
+function isSpace(character) {
+    return character === ' ' || character === '\t' || character === '\n' || character === '\r';
+}
+const TERMINATORS = new Set(['.', '!', '?', '…', '。', '！', '？']);
+function isTerminator(character) {
+    return TERMINATORS.has(character);
+}
+const CLOSERS = new Set(['"', "'", ')', ']', '»', '”']);
+function isCloser(character) {
+    return CLOSERS.has(character);
+}
+function sentenceBounds(text) {
+    const bounds = [0];
+    let i = 0;
+    while (i < text.length) {
+        if (!isTerminator(text[i])) {
+            i += 1;
+            continue;
+        }
+        let after = i + 1;
+        while (after < text.length && isCloser(text[after]))
+            after += 1;
+        if (after >= text.length || !isSpace(text[after])) {
+            i = after + 1;
+            continue;
+        }
+        while (after < text.length && isSpace(text[after]))
+            after += 1;
+        if (after < text.length)
+            bounds.push(after);
+        i = after;
+    }
+    bounds.push(text.length);
+    return bounds;
+}
+function isTrailingSurrogate(text, index) {
+    const code = text.charCodeAt(index);
+    return code >= 0xdc00 && code <= 0xdfff;
+}
+function characterLength(text, index) {
+    return isTrailingSurrogate(text, index + 1) ? 2 : 1;
+}
+function boundOf(cutting, from, to, budget) {
+    const limit = from + budget;
+    if (limit >= to)
+        return to;
+    for (let index = limit; index > from + 1; index -= 1) {
+        if (isSpace(cutting.text[index]))
+            return index;
+    }
+    const inside = cutting.masks.find((mask) => limit > mask.start && limit < mask.end);
+    if (inside !== undefined)
+        return inside.start > from ? inside.start : Math.min(inside.end, to);
+    return isTrailingSurrogate(cutting.text, limit) ? limit - 1 : limit;
+}
+function utf8Size(code) {
+    if (code < 0x80)
+        return 1;
+    if (code < 0x800)
+        return 2;
+    if (code < 0x10000)
+        return 3;
+    return 4;
+}
+function byteBounds(content, spans) {
+    const marks = [...new Set(spans.flatMap((span) => [span.start, span.end]))].sort((left, right) => left - right);
+    const bytes = new Map();
+    let index = 0;
+    let count = 0;
+    for (const mark of marks) {
+        while (index < mark) {
+            const code = content.codePointAt(index);
+            count += utf8Size(code);
+            index += code > 0xffff ? 2 : 1;
+        }
+        bytes.set(mark, count);
+    }
+    return spans.map((span) => ({
+        ...span,
+        start: bytes.get(span.start),
+        end: bytes.get(span.end),
+    }));
+}
+function textOf(state, extent) {
+    return rangeText(state.content, extent, state.edits);
+}
+function sourceCutting(state, extent) {
+    let text = state.content.slice(extent.start, extent.end);
+    const masks = [];
+    for (const edit of state.edits) {
+        if (edit.start < extent.start || edit.end > extent.end)
+            continue;
+        const from = edit.start - extent.start;
+        const to = edit.end - extent.start;
+        text = `${text.slice(0, from)}${'x'.repeat(to - from)}${text.slice(to)}`;
+        masks.push({ start: from, end: to });
+    }
+    return {
+        text,
+        masks,
+        piece: (from, to) => {
+            const cut = { start: extent.start + from, end: extent.start + to };
+            return { ...cut, text: textOf(state, cut) };
+        },
+    };
+}
+function valueCutting(value) {
+    return {
+        text: value.text,
+        masks: [],
+        piece: (from, to) => ({ start: value.start, end: value.end, text: value.text.slice(from, to) }),
+    };
+}
+function prefixOf(state, body) {
+    if (body.emitted === 0 || body.heading.length >= state.budget)
+        return '';
+    return body.heading;
+}
+function available(state, body) {
+    return state.budget - prefixOf(state, body).length;
+}
+function emit(state, body, piece, bare = false) {
+    if (piece.text.trim() === '')
+        return;
+    const text = (bare ? '' : prefixOf(state, body)) + piece.text;
+    state.spans.push({ start: piece.start, end: piece.end, text });
+    body.emitted += 1;
+}
+function merge(run) {
+    return {
+        start: Math.min(...run.map((unit) => unit.start)),
+        end: Math.max(...run.map((unit) => unit.end)),
+        text: run.map((unit) => unit.text).join(''),
+    };
+}
+function divideUnits(state, body, units) {
+    let run = [];
+    let length = 0;
+    const flush = () => {
+        if (run.length === 0)
+            return;
+        emit(state, body, merge(run));
+        run = [];
+        length = 0;
+    };
+    for (const unit of units) {
+        if (run.length > 0 && length + unit.text.length > available(state, body))
+            flush();
+        if (unit.text.length > available(state, body)) {
+            flush();
+            unit.descend();
+            continue;
+        }
+        run.push(unit);
+        length += unit.text.length;
+    }
+    flush();
+}
+function divideBound(state, body, cutting, range) {
+    let start = range.start;
+    while (start < range.end) {
+        const bare = available(state, body) < characterLength(cutting.text, start);
+        const room = bare ? state.budget : available(state, body);
+        const stop = boundOf(cutting, start, range.end, room);
+        const piece = cutting.piece(start, stop);
+        if (cutting.masks.length === 0 || piece.text.length <= room) {
+            emit(state, body, piece, bare);
+        }
+        else {
+            divideBound(state, body, valueCutting(piece), { start: 0, end: piece.text.length });
+        }
+        start = stop;
+    }
+}
+function divideSentences(state, body, cutting) {
+    const cut = cutting.piece;
+    const bounds = sentenceBounds(cutting.text);
+    let index = 0;
+    while (index + 1 < bounds.length) {
+        const alone = { start: bounds[index], end: bounds[index + 1] };
+        if (cut(alone.start, alone.end).text.length > available(state, body)) {
+            divideBound(state, body, cutting, alone);
+            index += 1;
+            continue;
+        }
+        const carried = bounds[Math.max(index - 1, 0)];
+        const from = cut(carried, alone.end).text.length <= available(state, body) ? carried : alone.start;
+        let last = index;
+        while (last + 2 < bounds.length &&
+            cut(from, bounds[last + 2]).text.length <= available(state, body)) {
+            last += 1;
+        }
+        emit(state, body, cut(from, bounds[last + 1]));
+        index = last + 1;
+    }
+}
+function blockUnit(state, body, block) {
+    return {
+        start: block.start,
+        end: block.end,
+        text: textOf(state, block),
+        descend: () => divideSentences(state, body, sourceCutting(state, block)),
+    };
+}
+function valueUnit(state, body, value) {
+    return {
+        start: value.start,
+        end: value.end,
+        text: value.text,
+        descend: () => divideSentences(state, body, valueCutting(value)),
+    };
+}
+function nodeUnit(state, subject) {
+    return {
+        start: subject.start,
+        end: subject.end,
+        text: textOf(state, subject),
+        descend: () => divideNode(state, subject),
+    };
+}
+function ownBlocks(subject, end, blocks) {
+    const first = blocks[0];
+    return first === undefined
+        ? [{ start: subject.start, end }]
+        : [{ start: subject.start, end: first.end }, ...blocks.slice(1)];
+}
+function divideNode(state, subject) {
+    const end = subject.children[0]?.start ?? subject.end;
+    const blocks = blockRanges(state.content, subject.bodyStart, end);
+    const children = { heading: '', emitted: 0 };
+    if (blocks.length === 0 && subject.children.length > 0) {
+        const [first, ...rest] = subject.children;
+        const led = [{ ...first, start: subject.start }, ...rest];
+        divideUnits(state, children, led.map((child) => nodeUnit(state, child)));
+        return;
+    }
+    const body = { heading: subject.heading, emitted: 0 };
+    const own = ownBlocks(subject, end, blocks);
+    divideUnits(state, body, own.map((block) => blockUnit(state, body, block)));
+    divideUnits(state, children, subject.children.map((child) => nodeUnit(state, child)));
+}
+function divideInput(state, input) {
+    const body = { heading: '', emitted: 0 };
+    divideUnits(state, body, [
+        ...input.values.map((value) => valueUnit(state, body, value)),
+        ...input.ranges.flatMap((range) => forest(state, range).map((subject) => nodeUnit(state, subject))),
+    ]);
+}
+export function divide(document, file, context) {
+    if (!Number.isInteger(context.budget) || context.budget < SMALLEST_BUDGET) {
+        return { ok: false, refusal: refusal(file, 'division-budget') };
+    }
+    const result = projectionInput(document, file, context);
+    if (!result.ok)
+        return { ok: false, refusal: result.refusal };
+    const state = {
+        content: document.content,
+        edits: result.input.edits,
+        budget: context.budget,
+        spans: [],
+    };
+    divideInput(state, result.input);
+    return { ok: true, spans: byteBounds(document.content, state.spans) };
+}

package/dist/document.d.ts

@@ -1,6 +1,8 @@
 import type { ApplyResult, Change, Document, Link, ParseResult } from './types.js';
+import { type YamlMap } from './yaml.js';
 export declare function parse(content: string, file?: string): ParseResult;
 export declare function links(document: Document, file: string): readonly Link[];
 export declare function apply(document: Document, change: Change): ApplyResult;
 export declare function serialize(document: Document): string;
+export declare function frontmatter(document: Document): YamlMap | null;
 //# sourceMappingURL=document.d.ts.map

package/dist/document.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"document.d.ts","sourceRoot":"","sources":["../src/document.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAsDnF,wBAAgB,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,SAAK,GAAG,WAAW,CAkD7D;AAyGD,wBAAgB,KAAK,CAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,IAAI,EAAE,CAWvE;AAED,wBAAgB,KAAK,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,WAAW,CAarE;AAED,wBAAgB,SAAS,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAEpD"}
+{"version":3,"file":"document.d.ts","sourceRoot":"","sources":["../src/document.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACnF,OAAO,EAYL,KAAK,OAAO,EACb,MAAM,WAAW,CAAC;AAwCnB,wBAAgB,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,SAAK,GAAG,WAAW,CAkD7D;AAkHD,wBAAgB,KAAK,CAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,IAAI,EAAE,CAWvE;AAED,wBAAgB,KAAK,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,WAAW,CAarE;AAED,wBAAgB,SAAS,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAEpD;AAED,wBAAgB,WAAW,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,GAAG,IAAI,CAE9D"}