@wrtnlabs/evidence 0.0.0

package/lib/adapters/dart/DartLibraries.js

@@ -0,0 +1,228 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DartLibraries = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * Resolves selected Dart library ownership and export aliases without executing package tooling.
+ *
+ * Physical scans cannot decide whether a part belongs to a library or whether an
+ * exported spelling denotes an existing unit, so this pass establishes those
+ * relationships before inventory publication and documentation attachment.
+ */
+var DartLibraries;
+(function (DartLibraries) {
+    /**
+     * Validates reciprocal part ownership and retains missing URI paths for watch invalidation.
+     *
+     * A missing or conflicting part makes the analysis incomplete because treating
+     * it as absent could remove public declarations from the coverage denominator.
+     */
+    function resolve(analyses, inventory) {
+        const files = new Map();
+        for (const analysis of analyses)
+            for (const name of [
+                analysis.source.physicalPath,
+                ...analysis.source.addresses.map((address) => address.absolute),
+            ])
+                files.set(normalize(name), analysis);
+        for (const analysis of analyses)
+            for (const directive of analysis.directives) {
+                if (directive.named) {
+                    const matches = analyses.filter((candidate) => candidate.libraryName === directive.target &&
+                        !candidate.directives.some((item) => item.kind === "part-of"));
+                    if (matches.length === 1 && matches[0] !== undefined)
+                        directive.resolved = matches[0].source.physicalPath;
+                    else
+                        problem(analysis, "part-owner", `Named part library '${directive.target}' is missing or ambiguous in the selected snapshot.`);
+                    continue;
+                }
+                if (/^[A-Za-z][A-Za-z0-9+.-]*:|[?#%\\]/u.test(directive.target) ||
+                    directive.target.startsWith("/")) {
+                    problem(analysis, "external-uri", `Library URI '${directive.target}' requires package, SDK, or non-relative URI resolution. Use selected relative library source or implement URI resolution.`);
+                    continue;
+                }
+                const locations = [
+                    ...new Set([
+                        analysis.source.physicalPath,
+                        ...analysis.source.addresses.map((address) => address.absolute),
+                    ].map((file) => node_path_1.default.posix.join(node_path_1.default.posix.dirname(normalize(file)), directive.target))),
+                ];
+                for (const location of locations)
+                    if (!inventory.dependencies.some((dependency) => dependency.path === location && !dependency.recursive))
+                        inventory.dependencies.push({ path: location, recursive: false });
+                const matches = [
+                    ...new Set(locations.flatMap((location) => {
+                        const match = files.get(location);
+                        return match === undefined ? [] : [match];
+                    })),
+                ];
+                if (matches.length === 1 && matches[0] !== undefined)
+                    directive.resolved = matches[0].source.physicalPath;
+                else
+                    problem(analysis, "unresolved-library", `Library URI '${directive.target}' is missing or ambiguous in the selected snapshot. Include the referenced Dart file in this population.`);
+            }
+        for (const analysis of analyses) {
+            const owners = analysis.directives.filter((directive) => directive.kind === "part-of");
+            if (owners.length === 0)
+                continue;
+            const owner = analyses.find((candidate) => candidate.source.physicalPath === owners[0]?.resolved);
+            if (owners.length !== 1 ||
+                owner === undefined ||
+                owner === analysis ||
+                owner.directives.some((directive) => directive.kind === "part-of") ||
+                !owner.directives.some((directive) => directive.kind === "part" &&
+                    directive.resolved === analysis.source.physicalPath)) {
+                problem(analysis, "part-owner", "A part must name exactly one selected defining library whose part directive includes this file.");
+                continue;
+            }
+            if (analysis.libraryName !== undefined ||
+                analysis.directives.some((directive) => directive.kind !== "part-of"))
+                problem(analysis, "part-directives", "A part cannot define a library, export another library, or include parts.");
+            analysis.library = owner.source.physicalPath;
+        }
+        for (const analysis of analyses)
+            for (const directive of analysis.directives) {
+                const target = analyses.find((candidate) => candidate.source.physicalPath === directive.resolved);
+                if (target === undefined)
+                    continue;
+                if (directive.kind === "part" &&
+                    (target === analysis ||
+                        target.library !== analysis.source.physicalPath ||
+                        !target.directives.some((item) => item.kind === "part-of")))
+                    problem(analysis, "part-owner", `Part '${directive.target}' does not reciprocally belong to this defining library.`);
+                if (directive.kind === "export" &&
+                    target.directives.some((item) => item.kind === "part-of"))
+                    problem(analysis, "export-part", "A part file cannot be exported as a standalone library; export its defining library.");
+            }
+        const declarations = new Map();
+        for (const analysis of analyses)
+            for (const declaration of analysis.declarations) {
+                declaration.library = analysis.library;
+                const key = JSON.stringify([analysis.library, declaration.address]);
+                const previous = declarations.get(key) ?? [];
+                if (previous.length !== 0 &&
+                    !(previous.length === 1 &&
+                        previous[0]?.symbol === "property" &&
+                        declaration.symbol === "property" &&
+                        ((previous[0].role === "getter" && declaration.role === "setter") ||
+                            (previous[0].role === "setter" && declaration.role === "getter"))))
+                    problem(analysis, "declaration-conflict", `Library declaration '${declaration.address.join(".")}' has conflicting selected definitions.`);
+                previous.push(declaration);
+                declarations.set(key, previous);
+            }
+    }
+    DartLibraries.resolve = resolve;
+    /**
+     * Projects library and transitive show or hide export addresses without duplicating semantic units.
+     *
+     * One declaration can have several public paths while retaining a single unit identity.
+     */
+    function publish(analyses, inventory, published) {
+        const surfaces = new Map();
+        const localNames = new Map();
+        for (const analysis of analyses) {
+            const surface = surfaces.get(analysis.library) ?? new Set();
+            const names = localNames.get(analysis.library) ?? new Set();
+            for (const declaration of analysis.declarations) {
+                const id = published.get(declaration.id);
+                if (id !== undefined)
+                    surface.add(id);
+                if (declaration.address.length === 1)
+                    names.add(declaration.name);
+            }
+            surfaces.set(analysis.library, surface);
+            localNames.set(analysis.library, names);
+        }
+        const units = new Map(inventory.units.map((unit) => [unit.id, unit]));
+        let changed = true;
+        while (changed) {
+            changed = false;
+            for (const analysis of analyses)
+                for (const directive of analysis.directives.filter((item) => item.kind === "export")) {
+                    const target = analyses.find((candidate) => candidate.source.physicalPath === directive.resolved);
+                    const destination = surfaces.get(analysis.library);
+                    if (target === undefined || destination === undefined)
+                        continue;
+                    for (const id of surfaces.get(target.library) ?? []) {
+                        const name = units.get(id)?.identity?.[0];
+                        const locals = localNames.get(analysis.library);
+                        if (name === undefined ||
+                            (locals !== undefined && locals.has(name)) ||
+                            !allowed(directive, name) ||
+                            destination.has(id))
+                            continue;
+                        destination.add(id);
+                        changed = true;
+                    }
+                }
+        }
+        const addresses = new Set(inventory.addresses.map((address) => JSON.stringify(address)));
+        for (const analysis of analyses) {
+            const roots = new Map();
+            for (const id of surfaces.get(analysis.library) ?? []) {
+                const unit = units.get(id);
+                if (unit === undefined)
+                    continue;
+                if (unit.identity.length === 1) {
+                    const ids = roots.get(unit.name) ?? new Set();
+                    ids.add(unit.id);
+                    roots.set(unit.name, ids);
+                }
+                for (const file of analysis.source.addresses) {
+                    const address = {
+                        unitId: id,
+                        file: file.absolute,
+                        segments: unit.identity,
+                    };
+                    const key = JSON.stringify(address);
+                    if (addresses.has(key))
+                        continue;
+                    addresses.add(key);
+                    inventory.addresses.push(address);
+                }
+            }
+            if ([...roots.values()].some((ids) => ids.size > 1)) {
+                problem(analysis, "export-conflict", "Multiple exported libraries expose distinct declarations with the same name. Resolve the ambiguity with show/hide combinators.");
+                inventory.complete = false;
+                inventory.diagnostics.push(...analysis.diagnostics.filter((diagnostic) => diagnostic.code === "dart-export-conflict"));
+            }
+        }
+    }
+    DartLibraries.publish = publish;
+    /**
+     * Applies sequential Dart combinators to one root name.
+     *
+     * Source order determines whether a later show or hide filter keeps the export.
+     */
+    function allowed(directive, name) {
+        return directive.filters.every((filter) => filter.kind === "show"
+            ? filter.names.includes(name)
+            : !filter.names.includes(name));
+    }
+    /**
+     * Makes source path separators portable without filesystem access.
+     *
+     * Static URI topology must compare the same way on Windows and POSIX hosts.
+     */
+    function normalize(file) {
+        return node_path_1.default.posix.normalize(file.replaceAll("\\", "/"));
+    }
+    /**
+     * Records a library topology failure on its source analysis.
+     *
+     * The affected analysis remains incomplete until its URI relationship is repaired.
+     */
+    function problem(analysis, code, message) {
+        analysis.complete = false;
+        analysis.diagnostics.push({
+            code: `dart-${code}`,
+            severity: "error",
+            message,
+            repair: "Select an unambiguous complete Dart library graph or implement the reported URI boundary before checking coverage.",
+            location: { file: analysis.source.physicalPath },
+        });
+    }
+})(DartLibraries || (exports.DartLibraries = DartLibraries = {}));

package/lib/adapters/dart/EvidenceDartAdapter.d.ts

@@ -0,0 +1,15 @@
+import { DartAdapter } from "./DartAdapter";
+/**
+ * Extracts Dart public declarations across defining libraries, parts, and static exports.
+ *
+ * Library resolution checks reciprocal part ownership before publishing aliases.
+ * Supported show/hide exports project public paths without changing the defining
+ * declaration's semantic identity. Attached Dart documentation remains associated
+ * with its original declaration site through these projections.
+ *
+ * Package and SDK export URIs, conditional exports, augmentation, and members
+ * absent from selected source are outside this boundary. Missing part dependencies
+ * remain observable so watch can recover when their source appears.
+ */
+export declare class EvidenceDartAdapter extends DartAdapter {
+}

package/lib/adapters/dart/EvidenceDartAdapter.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceDartAdapter = void 0;
+const DartAdapter_1 = require("./DartAdapter");
+/**
+ * Extracts Dart public declarations across defining libraries, parts, and static exports.
+ *
+ * Library resolution checks reciprocal part ownership before publishing aliases.
+ * Supported show/hide exports project public paths without changing the defining
+ * declaration's semantic identity. Attached Dart documentation remains associated
+ * with its original declaration site through these projections.
+ *
+ * Package and SDK export URIs, conditional exports, augmentation, and members
+ * absent from selected source are outside this boundary. Missing part dependencies
+ * remain observable so watch can recover when their source appears.
+ */
+class EvidenceDartAdapter extends DartAdapter_1.DartAdapter {
+}
+exports.EvidenceDartAdapter = EvidenceDartAdapter;

package/lib/adapters/dart/IDartDeclaration.d.ts

@@ -0,0 +1,69 @@
+import type { IEvidenceUnitSite } from "../../structures/IEvidenceUnitSite";
+import type { EvidenceProgrammingSymbol } from "../../typings/EvidenceProgrammingSymbol";
+/**
+ * Represents one physical Dart declaration before library identity reconciliation.
+ *
+ * The scanner deliberately retains private and part-file declarations here: the
+ * library resolver needs their lexical ownership before it can decide which
+ * declarations form the selected public surface.
+ */
+export interface IDartDeclaration {
+    /**
+     * Identifies this physical extraction record within its source snapshot.
+     *
+     * This is not a public address: one semantic unit can collect several such
+     * records through parts and complementary accessors.
+     */
+    id: string;
+    /** Gives the declared name or explicit constructor or operator segment.
+     *
+     * The scanner combines this with `identity` and `address`; it is unqualified so diagnostics can retain the source spelling.
+     */
+    name: string;
+    /** Classifies the declaration in Evidence's language-independent selector vocabulary.
+     *
+     * Materialization preserves this category while it reconciles declarations with the same Dart name.
+     */
+    symbol: EvidenceProgrammingSymbol;
+    /**
+     * Distinguishes declaration forms that share a Dart name.
+     *
+     * In particular, getter and setter roles must remain separate until unit
+     * materialization can merge their complementary public accessors.
+     */
+    role: string;
+    /**
+     * Names the defining library after `part` ownership is resolved.
+     *
+     * Unit identity uses this path so a declaration from a part cannot be
+     * mistaken for an independent declaration in the part's physical file.
+     */
+    library: string;
+    /** Lists the lexical segments that establish the declaration's semantic identity.
+     *
+     * Library reconciliation prefixes this path with the defining library so parts share their owner's identity.
+     */
+    identity: string[];
+    /** Lists the public accessor segments used in a selected source address.
+     *
+     * This may differ from `identity` after library exports project a declaration through another file.
+     */
+    address: string[];
+    /** Retains the physical declaration range and content used by hosts and fingerprints.
+     *
+     * A reconciled unit can collect multiple sites from parts or complementary accessors.
+     */
+    site: IEvidenceUnitSite;
+    /** States whether this declaration and every lexical owner are publicly visible.
+     *
+     * The adapter excludes private declarations from publication while retaining them for ownership and boundary diagnostics.
+     */
+    public: boolean;
+    /**
+     * Identifies the physical lexical owner when this is a member.
+     *
+     * The adapter maps this record to the owner's published unit only after it
+     * knows whether both declarations are public.
+     */
+    ownerDeclarationId?: string;
+}

package/lib/adapters/dart/IDartDeclaration.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/adapters/dart/IDartDirective.d.ts

@@ -0,0 +1,53 @@
+import type { IDartExportFilter } from "./IDartExportFilter";
+import type { IEvidenceSourceRange } from "../../structures/IEvidenceSourceRange";
+/**
+ * Records one static Dart library-topology directive.
+ *
+ * DartFileScanner retains this source-level relationship for DartLibraries,
+ * which resolves selected files, validates part ownership, and projects exports
+ * into the public inventory without evaluating Dart.
+ */
+export interface IDartDirective {
+    /**
+     * Identifies the library relationship expressed by this directive.
+     *
+     * DartLibraries uses `part` and `part-of` to establish a shared library and
+     * applies export projection only for `export`.
+     */
+    kind: "part" | "part-of" | "export";
+    /**
+     * Names the decoded URI target or named `part of` library.
+     *
+     * Its interpretation depends on {@link named}: URI targets are resolved
+     * against selected source locations, while named libraries match declarations.
+     */
+    target: string;
+    /**
+     * Distinguishes a named `part of` library from a URI target.
+     *
+     * This preserves the grammar-level target form so resolution does not treat a
+     * dotted library name as a physical file address.
+     */
+    named: boolean;
+    /**
+     * Gives the selected physical file resolved from a URI target.
+     *
+     * Omission means the target is named or URI resolution did not produce one
+     * unambiguous selected file; the library pass reports the latter condition.
+     */
+    resolved?: string;
+    /**
+     * Retains export combinators in their source order.
+     *
+     * DartLibraries applies each filter to a candidate exported declaration, so a
+     * `show` intersects the population and a `hide` subtracts from it.
+     */
+    filters: IDartExportFilter[];
+    /**
+     * Locates the complete directive in the original source.
+     *
+     * Resolution and topology diagnostics cite this half-open UTF-16 range rather
+     * than a synthesized library relationship.
+     */
+    range: IEvidenceSourceRange;
+}

package/lib/adapters/dart/IDartDirective.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/adapters/dart/IDartDocumentation.d.ts

@@ -0,0 +1,31 @@
+import type { IEvidenceCommentSyntax } from "../../structures/IEvidenceCommentSyntax";
+import type { IEvidenceSourceRange } from "../../structures/IEvidenceSourceRange";
+import type { IDartDocumentationAttachment } from "./IDartDocumentationAttachment";
+/**
+ * Represents a Dart documentation carrier or tag-bearing unsupported carrier.
+ *
+ * The scanner preserves unsupported tagged text as well as attached DartDoc so
+ * the adapter can report a misplaced annotation instead of silently ignoring it.
+ */
+export interface IDartDocumentation {
+    /** Identifies this physical documentation carrier within the scanned source.
+     *
+     * Attachments and generated hosts use this scanner-local identity; it does not name a semantic declaration.
+     */
+    id: string;
+    /** Locates the carrier's original half-open UTF-16 source span.
+     *
+     * The adapter preserves this position for diagnostics and annotation-range exclusion.
+     */
+    range: IEvidenceSourceRange;
+    /** Defines the delimiters and annotation-reading rules for this carrier.
+     *
+     * Documentation parsing uses this syntax instead of reinterpreting raw Dart source text.
+     */
+    syntax: IEvidenceCommentSyntax;
+    /** Lists supported declaration sites that accept this carrier as documentation.
+     *
+     * Attachments are established by source adjacency before library and unit reconciliation.
+     */
+    attachments: IDartDocumentationAttachment[];
+}

package/lib/adapters/dart/IDartDocumentation.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/adapters/dart/IDartDocumentationAttachment.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Connects a DartDoc carrier to one extracted declaration site.
+ *
+ * DartFileScanner records source-adjacent attachments here, allowing the
+ * documentation pass to evaluate one carrier against each declaration site it
+ * governs without making the comment itself own a semantic unit.
+ */
+export interface IDartDocumentationAttachment {
+    /**
+     * Identifies the declaration extraction record that receives the DartDoc.
+     *
+     * Consumers use this stable scanner-local ID to find the declaration before
+     * evaluating its annotation against the declaration's semantic unit.
+     */
+    declarationId: string;
+    /**
+     * Identifies the physical declaration site covered by the DartDoc.
+     *
+     * A semantic unit can have multiple sites, so this keeps attachment scoped to
+     * the adjacent source occurrence instead of every site with the same unit ID.
+     */
+    siteId: string;
+}

package/lib/adapters/dart/IDartDocumentationAttachment.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/adapters/dart/IDartExportFilter.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Represents one Dart export combinator retained from source order.
+ *
+ * An {@link IDartDirective} owns these filters, and DartLibraries applies them
+ * in sequence while deciding whether each exported top-level name is public.
+ */
+export interface IDartExportFilter {
+    /**
+     * Selects whether this combinator keeps or removes its listed names.
+     *
+     * A `show` filter admits only listed candidates at its position, while a
+     * `hide` filter removes listed candidates that earlier filters permitted.
+     */
+    kind: "show" | "hide";
+    /**
+     * Lists literal top-level declaration names affected by this combinator.
+     *
+     * The names preserve source spelling and are compared with the candidate
+     * export name; they are not paths or resolved declaration identities.
+     */
+    names: string[];
+}

package/lib/adapters/dart/IDartExportFilter.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/adapters/dart/IDartFileAnalysis.d.ts

@@ -0,0 +1,55 @@
+import type { IEvidenceDiagnostic } from "../../structures/IEvidenceDiagnostic";
+import type { IEvidenceSourceFile } from "../../structures/IEvidenceSourceFile";
+import type { IDartDirective } from "./IDartDirective";
+import type { IDartDeclaration } from "./IDartDeclaration";
+import type { IDartDocumentation } from "./IDartDocumentation";
+/**
+ * Holds the node-free Dart extraction retained after a parse session closes.
+ *
+ * Library resolution consumes this intermediate record across every selected
+ * file, so parser nodes cannot be retained and physical source remains explicit.
+ */
+export interface IDartFileAnalysis {
+    /** Gives the selected physical path of the defining library.
+     *
+     * Part files adopt this owner during topology resolution instead of becoming independent public files.
+     */
+    library: string;
+    /** Gives the optional named library declaration or `part of` name.
+     *
+     * Omission denotes an unnamed library; named values let topology resolution match named part owners.
+     */
+    libraryName?: string;
+    /** Lists library topology directives retained for snapshot-wide resolution.
+     *
+     * `DartLibraries` consumes parts and exports to establish ownership and projected public addresses.
+     */
+    directives: IDartDirective[];
+    /** Retains the selected source file that produced this analysis.
+     *
+     * Its physical identity and configured addresses are used when units and documentation hosts are materialized.
+     */
+    source: IEvidenceSourceFile;
+    /** Lists extracted declarations, including non-public ownership boundaries.
+     *
+     * Topology resolution consumes these physical records before selecting public units.
+     */
+    declarations: IDartDeclaration[];
+    /** Lists classified DartDoc and unsupported annotation carriers in this file.
+     *
+     * The adapter keeps tagged unsupported carriers so they can produce diagnostics rather than disappear.
+     */
+    documentation: IDartDocumentation[];
+    /** Lists failures encountered while establishing this file's public surface.
+     *
+     * The adapter forwards them into the inventory alongside the `complete` boundary.
+     */
+    diagnostics: IEvidenceDiagnostic[];
+    /**
+     * States whether scanning classified every surface-affecting form.
+     *
+     * A false value survives topology resolution and prevents missing syntax from
+     * reducing the population used to evaluate coverage.
+     */
+    complete: boolean;
+}

package/lib/adapters/dart/IDartFileAnalysis.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/adapters/dbml/DbmlDocumentation.d.ts

@@ -0,0 +1,15 @@
+import type { IEvidenceDocumentation } from "../../structures/IEvidenceDocumentation";
+import type { IDbmlDocumentation } from "./IDbmlDocumentation";
+/**
+ * Decodes DBML note escapes without losing original UTF-16 annotation positions.
+ *
+ * The adapter uses mapped positions to attach Evidence tags to original source text.
+ */
+export declare namespace DbmlDocumentation {
+    /**
+     * Reads established comment or note ownership and preserves mapped decoded characters.
+     *
+     * Callers provide a scanner-created carrier after structural ownership is known.
+     */
+    function read(content: string, hostId: string, documentation: IDbmlDocumentation): IEvidenceDocumentation;
+}

package/lib/adapters/dbml/DbmlDocumentation.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbmlDocumentation = void 0;
+const EvidenceDocumentation_1 = require("../../parsers/EvidenceDocumentation");
+/**
+ * Decodes DBML note escapes without losing original UTF-16 annotation positions.
+ *
+ * The adapter uses mapped positions to attach Evidence tags to original source text.
+ */
+var DbmlDocumentation;
+(function (DbmlDocumentation) {
+    /**
+     * Reads established comment or note ownership and preserves mapped decoded characters.
+     *
+     * Callers provide a scanner-created carrier after structural ownership is known.
+     */
+    function read(content, hostId, documentation) {
+        const parsed = EvidenceDocumentation_1.EvidenceDocumentation.read(content, hostId, documentation.range, documentation.syntax);
+        if (!documentation.syntax.opening.startsWith("'"))
+            return parsed;
+        const offsets = [];
+        const ends = [];
+        let text = "";
+        for (let index = 0; index < parsed.text.length; ++index) {
+            let character = parsed.text[index] ?? "";
+            const start = parsed.offsets[index];
+            if (character === "\\" && index + 1 < parsed.text.length) {
+                character = parsed.text[++index] ?? "";
+                character =
+                    character === "n"
+                        ? "\n"
+                        : character === "r"
+                            ? "\r"
+                            : character === "t"
+                                ? "\t"
+                                : character;
+            }
+            const end = parsed.ends[index];
+            if (start === undefined || end === undefined)
+                throw new Error("A DBML note lost its original source mapping.");
+            text += character;
+            offsets.push(start);
+            ends.push(end);
+        }
+        offsets.push(parsed.offsets.at(-1) ?? documentation.range.end.offset);
+        return { ...parsed, text, offsets, ends };
+    }
+    DbmlDocumentation.read = read;
+})(DbmlDocumentation || (exports.DbmlDocumentation = DbmlDocumentation = {}));