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

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":"AAUA,OAAO,KAAK,EAAE,QAAQ,EAAE,eAAe,EAAE,QAAQ,EAAgB,MAAM,YAAY,CAAC;AAwXpF,wBAAgB,MAAM,CAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,QAAQ,CAc3F"}

package/dist/divide.js

@@ -0,0 +1,320 @@
+import { blockRanges, headingLines } from './blocks.js';
+import { firstEditFrom, projectionInput, rangeText, } from './project.js';
+import { refusal } from './refuse.js';
+const SMALLEST_BOUND = 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, bound) {
+    const limit = from + bound;
+    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) {
+    const source = state.content.slice(extent.start, extent.end);
+    const masks = [];
+    for (let index = firstEditFrom(state.edits, extent.start); index < state.edits.length; index += 1) {
+        const edit = state.edits[index];
+        if (edit.start > extent.end)
+            break;
+        if (edit.end > extent.end)
+            continue;
+        masks.push({ start: edit.start - extent.start, end: edit.end - extent.start });
+    }
+    let text = '';
+    let cursor = 0;
+    for (const mask of masks) {
+        if (mask.end <= cursor)
+            continue;
+        const from = Math.max(mask.start, cursor);
+        text += `${source.slice(cursor, from)}${'x'.repeat(mask.end - from)}`;
+        cursor = mask.end;
+    }
+    text += source.slice(cursor);
+    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.bound)
+        return '';
+    return body.heading;
+}
+function available(state, body) {
+    return state.bound - 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.bound : 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.bound) || context.bound < SMALLEST_BOUND) {
+        return { ok: false, refusal: refusal(file, 'division-bound') };
+    }
+    const result = projectionInput(document, file, context);
+    if (!result.ok)
+        return { ok: false, refusal: result.refusal };
+    const state = {
+        content: document.content,
+        edits: result.input.edits,
+        bound: context.bound,
+        spans: [],
+    };
+    divideInput(state, result.input);
+    return { ok: true, spans: byteBounds(document.content, state.spans) };
+}

package/dist/document.d.ts

@@ -1,6 +1,16 @@
-import type { ApplyResult, Change, Document, Link, ParseResult } from './types.js';
+import { type Definition } from './definition.js';
+import { type LinkInventory } from './links.js';
+import type { ApplyResult, BodyResult, FrontmatterResult, Change, Document, Link, ParseResult } from './types.js';
+import { type YamlMap } from './yaml.js';
+export declare function inventoryOf(document: Document): LinkInventory;
+export declare function parseFrontmatter(content: string, file?: string): FrontmatterResult;
 export declare function parse(content: string, file?: string): ParseResult;
+export declare function relativize(document: Document, file: string, handle: string, definition?: Definition, kept?: ReadonlySet<string>): ApplyResult;
+export declare function relativizeBody(body: string, file: string, handle: string): BodyResult;
+export declare function relinkBody(body: string, file: string, moves: ReadonlyMap<string, string>): BodyResult;
 export declare function links(document: Document, file: string): readonly Link[];
-export declare function apply(document: Document, change: Change): ApplyResult;
+export declare function bodyLinks(body: string, file: string): readonly Link[];
+export declare function apply(document: Document, changes: readonly 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;AAChF,OAAO,EAKL,KAAK,aAAa,EACnB,MAAM,YAAY,CAAC;AAcpB,OAAO,KAAK,EACV,WAAW,EACX,UAAU,EACV,iBAAiB,EACjB,MAAM,EACN,QAAQ,EACR,IAAI,EACJ,WAAW,EAEZ,MAAM,YAAY,CAAC;AACpB,OAAO,EAcL,KAAK,OAAO,EAEb,MAAM,WAAW,CAAC;AAYnB,wBAAgB,WAAW,CAAC,QAAQ,EAAE,QAAQ,GAAG,aAAa,CAM7D;AA2DD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,SAAK,GAAG,iBAAiB,CAW9E;AAED,wBAAgB,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,SAAK,GAAG,WAAW,CAgB7D;AAmED,wBAAgB,UAAU,CACxB,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,UAAU,EACvB,IAAI,GAAE,WAAW,CAAC,MAAM,CAAa,GACpC,WAAW,CAuBb;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,UAAU,CAUrF;AAED,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GACjC,UAAU,CAkBZ;AAeD,wBAAgB,KAAK,CAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,IAAI,EAAE,CAEvE;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,IAAI,EAAE,CAErE;AA4LD,wBAAgB,KAAK,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,WAAW,CA4CjF;AAED,wBAAgB,SAAS,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAEpD;AAED,wBAAgB,WAAW,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,GAAG,IAAI,CAE9D"}