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

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,17 @@
-import type { ApplyResult, Change, Document, Link, ParseResult } from './types.js';
+import { type Definition } from './definition.js';
+import type { ApplyResult, Change, Document, Link, ParseResult, Refusal } from './types.js';
+import { type YamlMap } from './yaml.js';
 export declare function parse(content: string, file?: string): ParseResult;
+export declare function relativize(document: Document, file: string, handle: string, definition?: Definition): ApplyResult;
+export declare function relativizeBody(body: string, file: string, handle: string): {
+    readonly outcome: 'applied';
+    readonly body: string;
+} | {
+    readonly outcome: 'refuse';
+    readonly refusal: Refusal;
+};
 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":"AAAA,OAAO,EAAgC,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAMhF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5F,OAAO,EAYL,KAAK,OAAO,EAEb,MAAM,WAAW,CAAC;AAwCnB,wBAAgB,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,SAAK,GAAG,WAAW,CAkD7D;AA2KD,wBAAgB,UAAU,CACxB,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,UAAU,GACtB,WAAW,CAYb;AAED,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,GAEZ;IAAE,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACtD;IAAE,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAO5D;AAED,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,CAerE;AAED,wBAAgB,SAAS,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAEpD;AAED,wBAAgB,WAAW,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,GAAG,IAAI,CAE9D"}