perttool 0.1.0-alpha.2

package/dist/parser/document-parser.js

@@ -0,0 +1,735 @@
+import { countDiagnostics, limitDiagnostics, normalizeMaxDiagnostics, sortDiagnostics, } from "../model/diagnostics.js";
+const identifierPattern = /^[A-Za-z][A-Za-z0-9_-]*$/;
+const declarationKinds = new Set([
+    "project",
+    "resource",
+    "milestone",
+    "task",
+    "gate",
+]);
+const allowedFields = {
+    project: new Set([
+        "version",
+        "title",
+        "description",
+        "as_of",
+        "duration_unit",
+        "velocity",
+        "finish",
+        "critical_epsilon",
+        "target_duration",
+    ]),
+    resource: new Set(["title", "description", "capacity", "tags"]),
+    milestone: new Set(["title", "description", "state", "tags"]),
+    task: new Set([
+        "title",
+        "description",
+        "duration",
+        "estimate",
+        "status",
+        "priority",
+        "requires",
+        "owner",
+        "tags",
+        "blocked_reason",
+        "source",
+    ]),
+    gate: new Set(["reason"]),
+};
+function splitLines(text) {
+    if (text.length === 0)
+        return [];
+    const lines = [];
+    let offset = 0;
+    let lineNumber = 0;
+    while (offset < text.length) {
+        const newline = text.indexOf("\n", offset);
+        const rawEnd = newline === -1 ? text.length : newline;
+        const contentEnd = rawEnd > offset && text[rawEnd - 1] === "\r" ? rawEnd - 1 : rawEnd;
+        const prefixLength = lineNumber === 0 && text[offset] === "\uFEFF" ? 1 : 0;
+        lines.push({
+            text: text.slice(offset + prefixLength, contentEnd),
+            start: offset,
+            end: contentEnd,
+            line: lineNumber,
+            prefixLength,
+        });
+        if (newline === -1)
+            break;
+        offset = newline + 1;
+        lineNumber += 1;
+    }
+    return lines;
+}
+function position(line, column) {
+    const adjusted = line.prefixLength + column;
+    return {
+        offset: line.start + adjusted,
+        line: line.line,
+        column: adjusted,
+    };
+}
+function span(line, start, end) {
+    return { start: position(line, start), end: position(line, end) };
+}
+function lineSpan(line) {
+    return span(line, 0, line.text.length);
+}
+function joinSpan(start, end) {
+    return { start: start.start, end: end.end };
+}
+function leadingIndent(line) {
+    let indent = 0;
+    let hasTab = false;
+    for (const character of line.text) {
+        if (character === " ") {
+            indent += 1;
+            continue;
+        }
+        if (character === "\t") {
+            hasTab = true;
+            indent += 1;
+            continue;
+        }
+        break;
+    }
+    return { indent, hasTab };
+}
+function leadingSpaces(line) {
+    let spaces = 0;
+    while (line.text[spaces] === " ")
+        spaces += 1;
+    return spaces;
+}
+function diagnostic(code, message, diagnosticSpan, helpTopic, entityId) {
+    return {
+        code,
+        severity: "error",
+        message,
+        span: diagnosticSpan,
+        helpTopic,
+        ...(entityId === undefined ? {} : { entityId }),
+    };
+}
+function parseDuration(raw) {
+    const match = /^([0-9]+)(?:\.([0-9]+))?([dhp])$/.exec(raw);
+    if (match === null)
+        return undefined;
+    const whole = match[1];
+    if (whole === undefined)
+        return undefined;
+    const fraction = match[2] ?? "";
+    const suffix = match[3];
+    if (suffix !== "d" && suffix !== "h" && suffix !== "p")
+        return undefined;
+    return {
+        text: raw,
+        digits: BigInt(`${whole}${fraction}`),
+        scale: fraction.length,
+        suffix,
+    };
+}
+function parseVelocity(raw) {
+    const match = /^([0-9]+(?:\.[0-9]+)?p)\/([0-9]+(?:\.[0-9]+)?[dh])$/.exec(raw);
+    if (match === null)
+        return undefined;
+    const points = parseDuration(match[1]);
+    const period = parseDuration(match[2]);
+    if (points?.suffix !== "p" || (period?.suffix !== "d" && period?.suffix !== "h")) {
+        return undefined;
+    }
+    return {
+        text: raw,
+        points: points,
+        period: period,
+    };
+}
+function parseInteger(raw) {
+    if (!/^[0-9]+$/.test(raw))
+        return undefined;
+    const value = Number(raw);
+    return Number.isSafeInteger(value) && value <= 2_147_483_647 ? value : undefined;
+}
+function parseString(raw) {
+    if (!raw.startsWith('"') || !raw.endsWith('"'))
+        return undefined;
+    try {
+        const value = JSON.parse(raw);
+        return typeof value === "string" ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function findInlineCommentStart(text) {
+    let quoted = false;
+    let escaped = false;
+    for (let index = 0; index < text.length; index += 1) {
+        const character = text[index];
+        if (quoted) {
+            if (escaped) {
+                escaped = false;
+            }
+            else if (character === "\\") {
+                escaped = true;
+            }
+            else if (character === '"') {
+                quoted = false;
+            }
+            continue;
+        }
+        if (character === '"') {
+            quoted = true;
+        }
+        else if (character === "#") {
+            return index;
+        }
+    }
+    return undefined;
+}
+function inlineCommentDiagnostic(line, start, entityId) {
+    return diagnostic("PTDSL-011", "inline commentは使用できません", span(line, start, line.text.length), "syntax.comments", entityId);
+}
+function splitTagItems(raw) {
+    if (!raw.startsWith("[") || !raw.endsWith("]"))
+        return undefined;
+    const body = raw.slice(1, -1).trim();
+    if (body === "")
+        return [];
+    const items = [];
+    let start = 0;
+    let quoted = false;
+    let escaped = false;
+    for (let index = 0; index <= body.length; index += 1) {
+        const character = body[index];
+        if (index === body.length || (character === "," && !quoted)) {
+            const item = body.slice(start, index).trim();
+            if (item === "")
+                return undefined;
+            const stringValue = item.startsWith('"') ? parseString(item) : undefined;
+            if (stringValue !== undefined)
+                items.push(stringValue);
+            else if (identifierPattern.test(item))
+                items.push(item);
+            else
+                return undefined;
+            start = index + 1;
+            continue;
+        }
+        if (character === "\\" && quoted && !escaped) {
+            escaped = true;
+            continue;
+        }
+        if (character === '"' && !escaped)
+            quoted = !quoted;
+        escaped = false;
+    }
+    return quoted ? undefined : items;
+}
+function scalarFieldValue(name, rawValue) {
+    if (["title", "owner", "source"].includes(name)) {
+        const value = parseString(rawValue);
+        return value === undefined
+            ? { value: rawValue, code: "PTDSL-006", topic: "syntax.string" }
+            : { value };
+    }
+    if (["description", "blocked_reason", "reason"].includes(name)) {
+        const value = parseString(rawValue);
+        return value === undefined
+            ? { value: rawValue, code: "PTDSL-006", topic: "syntax.text" }
+            : { value };
+    }
+    if (["version", "capacity", "priority"].includes(name)) {
+        const value = parseInteger(rawValue);
+        return value === undefined
+            ? { value: rawValue, code: "PTDSL-012", topic: "syntax" }
+            : { value };
+    }
+    if (["duration", "critical_epsilon", "target_duration"].includes(name)) {
+        const value = parseDuration(rawValue);
+        return value === undefined
+            ? { value: rawValue, code: "PTDSL-007", topic: "syntax.duration" }
+            : { value };
+    }
+    if (name === "velocity") {
+        const value = parseVelocity(rawValue);
+        return value === undefined
+            ? { value: rawValue, code: "PTDSL-007", topic: "syntax.velocity" }
+            : { value };
+    }
+    if (name === "finish") {
+        return identifierPattern.test(rawValue)
+            ? { value: rawValue }
+            : { value: rawValue, code: "PTDSL-004", topic: "syntax.project" };
+    }
+    if (name === "duration_unit") {
+        return rawValue === "day" || rawValue === "hour" || rawValue === "point"
+            ? { value: rawValue }
+            : { value: rawValue, code: "PTDSL-012", topic: "syntax.duration" };
+    }
+    if (name === "state") {
+        return rawValue === "planned" || rawValue === "reached"
+            ? { value: rawValue }
+            : { value: rawValue, code: "PTDSL-012", topic: "syntax.milestone" };
+    }
+    if (name === "status") {
+        return ["planned", "active", "blocked", "done"].includes(rawValue)
+            ? { value: rawValue }
+            : { value: rawValue, code: "PTDSL-012", topic: "syntax.task" };
+    }
+    if (name === "tags") {
+        const value = splitTagItems(rawValue);
+        return value === undefined
+            ? { value: rawValue, code: "PTDSL-009", topic: "syntax.tags" }
+            : { value };
+    }
+    if (name === "as_of")
+        return { value: rawValue };
+    return { value: rawValue };
+}
+function parseNestedEstimate(lines, startIndex, diagnostics, trivia) {
+    const children = [];
+    let index = startIndex;
+    let endSpan = lineSpan(lines[startIndex - 1]);
+    while (index < lines.length) {
+        const line = lines[index];
+        const trimmed = line.text.trim();
+        if (trimmed === "" || trimmed.startsWith("#")) {
+            trivia.push({
+                kind: trimmed === "" ? "blank" : "comment",
+                text: line.text,
+                span: lineSpan(line),
+            });
+            endSpan = lineSpan(line);
+            index += 1;
+            continue;
+        }
+        const { indent, hasTab } = leadingIndent(line);
+        if (indent <= 2)
+            break;
+        if (hasTab || indent !== 4) {
+            diagnostics.push(diagnostic(hasTab ? "PTDSL-001" : "PTDSL-002", "estimate blockは4 spacesでindentしてください", span(line, 0, indent), "syntax.indentation"));
+            index += 1;
+            if (indent > 4)
+                index = skipIndentedRegion(lines, index, 4);
+            continue;
+        }
+        const content = line.text.slice(4).trimEnd();
+        const inlineCommentStart = findInlineCommentStart(content);
+        if (inlineCommentStart !== undefined) {
+            diagnostics.push(inlineCommentDiagnostic(line, 4 + inlineCommentStart));
+            index += 1;
+            continue;
+        }
+        const match = /^(optimistic|most_likely|pessimistic) +(.+)$/.exec(content);
+        if (match === null) {
+            diagnostics.push(diagnostic("PTDSL-005", "estimate blockのfieldが不正です", lineSpan(line), "syntax.estimate"));
+            index += 1;
+            continue;
+        }
+        const name = match[1];
+        const rawValue = match[2];
+        const valueOffset = line.text.indexOf(rawValue, 4 + name.length);
+        const valueSpan = span(line, valueOffset, valueOffset + rawValue.length);
+        const value = parseDuration(rawValue);
+        if (value === undefined) {
+            diagnostics.push(diagnostic("PTDSL-007", `${name}のdurationが不正です`, valueSpan, "syntax.duration"));
+        }
+        children.push({
+            name,
+            rawValue,
+            value: value ?? rawValue,
+            span: lineSpan(line),
+            valueSpan,
+        });
+        endSpan = lineSpan(line);
+        index += 1;
+    }
+    return { children, nextIndex: index, endSpan };
+}
+function parseNestedRequirements(lines, startIndex, diagnostics, trivia) {
+    const requirements = [];
+    let index = startIndex;
+    let endSpan = lineSpan(lines[startIndex - 1]);
+    while (index < lines.length) {
+        const line = lines[index];
+        const trimmed = line.text.trim();
+        if (trimmed === "" || trimmed.startsWith("#")) {
+            trivia.push({
+                kind: trimmed === "" ? "blank" : "comment",
+                text: line.text,
+                span: lineSpan(line),
+            });
+            endSpan = lineSpan(line);
+            index += 1;
+            continue;
+        }
+        const { indent, hasTab } = leadingIndent(line);
+        if (indent <= 2)
+            break;
+        if (hasTab || indent !== 4) {
+            diagnostics.push(diagnostic(hasTab ? "PTDSL-001" : "PTDSL-002", "requires blockは4 spacesでindentしてください", span(line, 0, indent), "syntax.indentation"));
+            index += 1;
+            if (indent > 4)
+                index = skipIndentedRegion(lines, index, 4);
+            continue;
+        }
+        const content = line.text.slice(4).trimEnd();
+        const inlineCommentStart = findInlineCommentStart(content);
+        if (inlineCommentStart !== undefined) {
+            diagnostics.push(inlineCommentDiagnostic(line, 4 + inlineCommentStart));
+            index += 1;
+            continue;
+        }
+        const match = /^([A-Za-z][A-Za-z0-9_-]*) +([0-9]+)$/.exec(content);
+        if (match === null) {
+            diagnostics.push(diagnostic("PTDSL-005", "resource requirementは`RESOURCE_ID units`で記述してください", lineSpan(line), "syntax.task"));
+            index += 1;
+            continue;
+        }
+        const resourceId = match[1];
+        const unitsRaw = match[2];
+        const units = parseInteger(unitsRaw);
+        const resourceOffset = line.text.indexOf(resourceId, 4);
+        const unitsOffset = line.text.lastIndexOf(unitsRaw);
+        const requirementSpan = lineSpan(line);
+        if (units === undefined) {
+            diagnostics.push(diagnostic("PTSEM-109", "resource requirement unitsが範囲外です", span(line, unitsOffset, unitsOffset + unitsRaw.length), "syntax.resource"));
+        }
+        else {
+            requirements.push({
+                resourceId,
+                units,
+                span: requirementSpan,
+                resourceSpan: span(line, resourceOffset, resourceOffset + resourceId.length),
+                unitsSpan: span(line, unitsOffset, unitsOffset + unitsRaw.length),
+            });
+        }
+        endSpan = requirementSpan;
+        index += 1;
+    }
+    return { requirements, nextIndex: index, endSpan };
+}
+function parseBlockText(lines, startIndex, diagnostics) {
+    const markerSpan = lineSpan(lines[startIndex - 1]);
+    const blockLines = [];
+    let index = startIndex;
+    let errorEndSpan;
+    while (index < lines.length) {
+        const line = lines[index];
+        if (line.text.trim() === "") {
+            blockLines.push({ line, sourceIndex: index, spaces: undefined });
+            index += 1;
+            continue;
+        }
+        const spaces = leadingSpaces(line);
+        const tabBeforeContent = line.text[spaces] === "\t" && spaces < 4;
+        if (!tabBeforeContent && spaces <= 2)
+            break;
+        if (tabBeforeContent || spaces < 4) {
+            diagnostics.push(diagnostic(tabBeforeContent ? "PTDSL-001" : "PTDSL-010", "block textはfieldより1 level以上深くindentしてください", span(line, 0, Math.max(spaces + (tabBeforeContent ? 1 : 0), 1)), "syntax.text"));
+            errorEndSpan = lineSpan(line);
+            index = skipIndentedRegion(lines, index + 1, 2);
+            break;
+        }
+        blockLines.push({ line, sourceIndex: index, spaces });
+        index += 1;
+    }
+    const firstContentIndex = blockLines.findIndex(({ spaces }) => spaces !== undefined);
+    const lastContentIndex = blockLines.findLastIndex(({ spaces }) => spaces !== undefined);
+    const leadingTrivia = blockLines
+        .slice(0, firstContentIndex === -1 ? blockLines.length : firstContentIndex)
+        .map(({ line }) => ({
+        kind: "blank",
+        text: line.text,
+        span: lineSpan(line),
+    }));
+    if (firstContentIndex === -1 || lastContentIndex === -1) {
+        if (errorEndSpan === undefined) {
+            diagnostics.push(diagnostic("PTDSL-010", "block textは1行以上のnonblank contentを必要とします", markerSpan, "syntax.text"));
+        }
+        return {
+            value: "",
+            nextIndex: index,
+            endSpan: errorEndSpan ?? markerSpan,
+            leadingTrivia,
+        };
+    }
+    const contentRegion = blockLines.slice(firstContentIndex, lastContentIndex + 1);
+    const commonIndent = Math.min(...contentRegion.flatMap(({ spaces }) => (spaces === undefined ? [] : [spaces])));
+    const firstContentLine = blockLines[firstContentIndex].line;
+    const lastContent = blockLines[lastContentIndex];
+    const contentSpan = {
+        start: position(firstContentLine, commonIndent),
+        end: position(lastContent.line, lastContent.line.text.length),
+    };
+    return {
+        value: contentRegion
+            .map(({ line, spaces }) => (spaces === undefined ? "" : line.text.slice(commonIndent)))
+            .join("\n"),
+        nextIndex: errorEndSpan === undefined ? lastContent.sourceIndex + 1 : index,
+        endSpan: errorEndSpan ?? lineSpan(lastContent.line),
+        contentSpan,
+        leadingTrivia,
+    };
+}
+function skipIndentedRegion(lines, startIndex, parentIndent) {
+    let index = startIndex;
+    while (index < lines.length) {
+        const line = lines[index];
+        if (line.text.trim() === "") {
+            index += 1;
+            continue;
+        }
+        if (leadingIndent(line).indent <= parentIndent)
+            break;
+        index += 1;
+    }
+    return index;
+}
+function isKnownDeclarationHeader(text) {
+    const normalized = text.trimEnd();
+    return (/^(?:project|resource|milestone) +[A-Za-z][A-Za-z0-9_-]*:$/.test(normalized) ||
+        /^(?:task|gate) +[A-Za-z][A-Za-z0-9_-]* +[A-Za-z][A-Za-z0-9_-]* +-> +[A-Za-z][A-Za-z0-9_-]*:$/.test(normalized));
+}
+function skipInvalidTopLevelRegion(lines, startIndex, trivia) {
+    let index = startIndex;
+    while (index < lines.length) {
+        const line = lines[index];
+        const trimmed = line.text.trim();
+        if (trimmed === "" || trimmed.startsWith("#")) {
+            trivia.push({
+                kind: trimmed === "" ? "blank" : "comment",
+                text: line.text,
+                span: lineSpan(line),
+            });
+            index += 1;
+            continue;
+        }
+        const indentation = leadingIndent(line);
+        if (indentation.indent === 0 && isKnownDeclarationHeader(line.text))
+            break;
+        index += 1;
+    }
+    return index;
+}
+function parseDeclarationHeader(line, diagnostics) {
+    const normalized = line.text.trimEnd();
+    const edge = /^(task|gate) +([A-Za-z][A-Za-z0-9_-]*) +([A-Za-z][A-Za-z0-9_-]*) +-> +([A-Za-z][A-Za-z0-9_-]*):$/.exec(normalized);
+    if (edge !== null) {
+        const kind = edge[1];
+        const id = edge[2];
+        const from = edge[3];
+        const to = edge[4];
+        const idStart = line.text.indexOf(id, kind.length + 1);
+        const fromStart = line.text.indexOf(from, idStart + id.length);
+        const arrowStart = line.text.indexOf("->", fromStart + from.length);
+        const toStart = line.text.indexOf(to, arrowStart + 2);
+        return {
+            kind,
+            id,
+            idSpan: span(line, idStart, idStart + id.length),
+            headerSpan: lineSpan(line),
+            from,
+            fromSpan: span(line, fromStart, fromStart + from.length),
+            to,
+            toSpan: span(line, toStart, toStart + to.length),
+            arrowSpan: span(line, arrowStart, arrowStart + 2),
+        };
+    }
+    const simple = /^(project|resource|milestone) +([A-Za-z][A-Za-z0-9_-]*):$/.exec(normalized);
+    if (simple !== null) {
+        const kind = simple[1];
+        const id = simple[2];
+        const idStart = line.text.indexOf(id, kind.length + 1);
+        return {
+            kind,
+            id,
+            idSpan: span(line, idStart, idStart + id.length),
+            headerSpan: lineSpan(line),
+        };
+    }
+    const firstWord = line.text.trim().split(/\s+/, 1)[0] ?? "";
+    diagnostics.push(diagnostic(declarationKinds.has(firstWord) ? "PTDSL-004" : "PTDSL-003", "top-level declaration headerが不正です", lineSpan(line), "syntax.top-level"));
+    return undefined;
+}
+export function parseDocument(text, options = {}) {
+    const maxDiagnostics = normalizeMaxDiagnostics(options.maxDiagnostics);
+    const diagnostics = [];
+    const declarations = [];
+    const trivia = [];
+    const lines = splitLines(text);
+    let index = 0;
+    while (index < lines.length) {
+        const headerLine = lines[index];
+        const trimmed = headerLine.text.trim();
+        if (trimmed === "" || trimmed.startsWith("#")) {
+            trivia.push({
+                kind: trimmed === "" ? "blank" : "comment",
+                text: headerLine.text,
+                span: lineSpan(headerLine),
+            });
+            index += 1;
+            continue;
+        }
+        const { indent, hasTab } = leadingIndent(headerLine);
+        if (hasTab || indent !== 0) {
+            diagnostics.push(diagnostic(hasTab ? "PTDSL-001" : "PTDSL-002", "top-level declarationはcolumn 0から開始してください", span(headerLine, 0, indent), "syntax.indentation"));
+            index += 1;
+            continue;
+        }
+        const headerInlineCommentStart = findInlineCommentStart(headerLine.text);
+        if (headerInlineCommentStart !== undefined) {
+            diagnostics.push(inlineCommentDiagnostic(headerLine, headerInlineCommentStart));
+            index += 1;
+            index = skipInvalidTopLevelRegion(lines, index, trivia);
+            continue;
+        }
+        const header = parseDeclarationHeader(headerLine, diagnostics);
+        index += 1;
+        if (header === undefined) {
+            index = skipInvalidTopLevelRegion(lines, index, trivia);
+            continue;
+        }
+        const fields = [];
+        let declarationEnd = header.headerSpan;
+        while (index < lines.length) {
+            const line = lines[index];
+            const bodyTrimmed = line.text.trim();
+            if (bodyTrimmed === "" || bodyTrimmed.startsWith("#")) {
+                trivia.push({
+                    kind: bodyTrimmed === "" ? "blank" : "comment",
+                    text: line.text,
+                    span: lineSpan(line),
+                });
+                declarationEnd = lineSpan(line);
+                index += 1;
+                continue;
+            }
+            const indentation = leadingIndent(line);
+            if (indentation.indent === 0)
+                break;
+            if (indentation.hasTab || indentation.indent !== 2) {
+                diagnostics.push(diagnostic(indentation.hasTab ? "PTDSL-001" : "PTDSL-002", "declaration fieldは2 spacesでindentしてください", span(line, 0, indentation.indent), "syntax.indentation", header.id));
+                index += 1;
+                if (indentation.indent > 2) {
+                    index = skipIndentedRegion(lines, index, 2);
+                }
+                continue;
+            }
+            const content = line.text.slice(2).trimEnd();
+            const inlineCommentStart = findInlineCommentStart(content);
+            if (inlineCommentStart !== undefined) {
+                diagnostics.push(inlineCommentDiagnostic(line, 2 + inlineCommentStart, header.id));
+                index += 1;
+                continue;
+            }
+            const blockMatch = /^([a-z_]+):$/.exec(content);
+            if (blockMatch !== null) {
+                const name = blockMatch[1];
+                const isKnownBlock = name === "estimate" || name === "requires";
+                if (!isKnownBlock || !allowedFields[header.kind].has(name)) {
+                    diagnostics.push(diagnostic("PTDSL-005", `${header.kind}にunknown block field ${name}があります`, span(line, 2, 2 + name.length), `syntax.${header.kind}`, header.id));
+                    index += 1;
+                    index = skipIndentedRegion(lines, index, 2);
+                    continue;
+                }
+                const keywordStart = 2;
+                if (name === "estimate") {
+                    const parsed = parseNestedEstimate(lines, index + 1, diagnostics, trivia);
+                    fields.push({
+                        name,
+                        rawValue: "",
+                        value: Object.fromEntries(parsed.children.map((child) => [child.name, child.value])),
+                        span: joinSpan(lineSpan(line), parsed.endSpan),
+                        valueSpan: span(line, keywordStart, keywordStart + name.length),
+                        children: parsed.children,
+                    });
+                    declarationEnd = parsed.endSpan;
+                    index = parsed.nextIndex;
+                    continue;
+                }
+                const parsed = parseNestedRequirements(lines, index + 1, diagnostics, trivia);
+                fields.push({
+                    name,
+                    rawValue: "",
+                    value: parsed.requirements,
+                    span: joinSpan(lineSpan(line), parsed.endSpan),
+                    valueSpan: span(line, keywordStart, keywordStart + name.length),
+                });
+                declarationEnd = parsed.endSpan;
+                index = parsed.nextIndex;
+                continue;
+            }
+            const textBlockMatch = /^(description|blocked_reason|reason) +\|$/.exec(content);
+            if (textBlockMatch !== null) {
+                const name = textBlockMatch[1];
+                if (!allowedFields[header.kind].has(name)) {
+                    diagnostics.push(diagnostic("PTDSL-005", `${header.kind}に${name} fieldは使用できません`, lineSpan(line), `syntax.${header.kind}`, header.id));
+                    index += 1;
+                    continue;
+                }
+                const parsed = parseBlockText(lines, index + 1, diagnostics);
+                const valueStart = line.text.lastIndexOf("|");
+                trivia.push(...parsed.leadingTrivia);
+                fields.push({
+                    name,
+                    rawValue: "|",
+                    value: parsed.value,
+                    span: joinSpan(lineSpan(line), parsed.endSpan),
+                    valueSpan: span(line, valueStart, valueStart + 1),
+                    ...(parsed.contentSpan === undefined ? {} : { contentSpan: parsed.contentSpan }),
+                });
+                declarationEnd = parsed.endSpan;
+                index = parsed.nextIndex;
+                continue;
+            }
+            const scalar = /^([a-z_]+) +(.+)$/.exec(content);
+            if (scalar === null) {
+                diagnostics.push(diagnostic("PTDSL-004", "field syntaxが不正です", lineSpan(line), `syntax.${header.kind}`, header.id));
+                index += 1;
+                continue;
+            }
+            const name = scalar[1];
+            const rawValue = scalar[2];
+            const nameStart = 2;
+            const valueStart = line.text.indexOf(rawValue, nameStart + name.length);
+            const valueSpan = span(line, valueStart, valueStart + rawValue.length);
+            if (!allowedFields[header.kind].has(name)) {
+                diagnostics.push(diagnostic("PTDSL-005", `${header.kind}にunknown field ${name}があります`, span(line, nameStart, nameStart + name.length), `syntax.${header.kind}`, header.id));
+                index += 1;
+                if (rawValue === "|")
+                    index = skipIndentedRegion(lines, index, 2);
+                continue;
+            }
+            const parsed = scalarFieldValue(name, rawValue);
+            if (parsed.code !== undefined) {
+                diagnostics.push(diagnostic(parsed.code, `${name}の値が不正です`, valueSpan, parsed.topic ?? "syntax", header.id));
+            }
+            fields.push({
+                name,
+                rawValue,
+                value: parsed.value,
+                span: lineSpan(line),
+                valueSpan,
+            });
+            declarationEnd = lineSpan(line);
+            index += 1;
+        }
+        declarations.push({
+            ...header,
+            fields,
+            span: joinSpan(header.headerSpan, declarationEnd),
+        });
+    }
+    const document = { text, declarations, trivia };
+    const sortedDiagnostics = sortDiagnostics(diagnostics);
+    const limited = limitDiagnostics(sortedDiagnostics, maxDiagnostics);
+    return {
+        document,
+        diagnostics: limited.diagnostics,
+        diagnosticCounts: countDiagnostics(sortedDiagnostics),
+        diagnosticsTruncated: limited.truncated,
+    };
+}
+//# sourceMappingURL=document-parser.js.map