@timiagama/ecr 0.0.1 → 0.1.0

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAS5D,OAAO,EAAE,oBAAoB,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AAQ9F,OAAO,EAAE,oBAAoB,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AAM9F,OAAO,EAAE,qBAAqB,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AASjG,OAAO,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAU3F,OAAO,EACL,kBAAkB,EAClB,2BAA2B,EAC3B,yBAAyB,GAC1B,MAAM,2BAA2B,CAAC;AAKnC,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAExD,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAG/B,OAAO,EAAE,kBAAkB,EAAE,2BAA2B,EAAE,MAAM,qBAAqB,CAAC;AACtF,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/inline-reference-rule.d.ts

@@ -0,0 +1,557 @@
+/**
+ * Inline Reference Rule (ECR104)
+ *
+ * Detects and validates inline references in document prose as defined
+ * in the ECR specification:
+ *   - 1#9.5 -- Inline Reference Rules
+ *   - 1#10.7 -- InlineReferenceEdge
+ *   - 1#6.3 -- Inline References (overview)
+ *
+ * This rule operates on text node data supplied by the document visitor.
+ * The visitor handles AST filtering (code blocks, inline code,
+ * HTML, link URLs) and heading context tracking. This rule receives only
+ * text nodes that are valid for inline reference detection, along with
+ * the current section context.
+ *
+ * The rule detects `see TargetID` and `per TargetID` forms where:
+ *   - The keyword (`see` or `per`) is preceded by a word boundary
+ *     (start of string, whitespace, or punctuation such as `(`)
+ *   - The keyword's first letter may be capitalised (`see`, `See`, `per`, `Per`)
+ *   - TargetID is a DocID, optionally followed by `#` and a section path
+ *   - TargetID is maximally matched and terminated by a non-digit/non-dot
+ *     character or end of string (a period followed by a non-digit is
+ *     treated as punctuation, not part of the TargetID)
+ *
+ * For each valid inline reference, the rule checks that the TargetID's
+ * parent DocID (or the TargetID itself, if it is a DocID) is declared
+ * in the References section or is a self-reference to the document's
+ * own DocID. An undeclared SectionID target (`per 3.1#2`) is an error: the
+ * `#` form never occurs in prose. An undeclared DocID target is only a
+ * warning, because on its own a document cannot tell `per 3.1` (a reference
+ * someone forgot to declare) from `per 60 seconds` (ordinary prose). The
+ * corpus validator, which knows which documents exist, raises the former to
+ * an error.
+ *
+ * Extracted artefacts:
+ *   - {@link InlineReferenceEdge} for each valid inline reference whose
+ *     parent DocID is declared or is a self-reference
+ */
+import type { DocID, SectionID, Diagnostic, DiagnosticSeverity, InlineReferenceEdge, InlineReferenceKind, PositionRange } from './types.js';
+import type { IdentifierGrammar } from './identifier-grammar.js';
+/**
+ * Canonical rule identifier for the Inline Reference Rule.
+ *
+ * Referenced as [ECR104] in the ECR specification (1#9.5).
+ */
+export declare const INLINE_REFERENCE_RULE_ID: string;
+/**
+ * Data extracted from a single text AST node, provided by the document
+ * visitor/traversal layer.
+ *
+ * The visitor filters out text nodes inside code blocks, inline code,
+ * HTML elements, and link URL portions before passing data to this rule.
+ * This rule only receives text nodes that are valid candidates for
+ * inline reference detection.
+ */
+export interface TextNodeData {
+    /**
+     * Plain text content of the text node.
+     *
+     * @example "Guardrail requirements are enforced per 3.1#2."
+     */
+    readonly text: string;
+    /**
+     * Positional range of the text node within the source document.
+     * Optional; depends on whether the Markdown parser provides positional metadata.
+     */
+    readonly range?: PositionRange;
+}
+/**
+ * How a piece of an inline run takes part in recognition (1#9.5 rule 1).
+ *
+ * - `text`: a parsed text node. Keywords and candidates may be recognised in
+ *   it, and only text can be literal in the source.
+ * - `code`: inline code. It may continue a candidate, but neither a keyword
+ *   nor a candidate is ever recognised as starting inside it.
+ * - `break`: a hard break, an image, a `<br>` tag -- anything a reader sees
+ *   as separating the words either side. Its text is a single space.
+ */
+export type InlineSegmentKind = 'text' | 'code' | 'break';
+/**
+ * One piece of the text a reader sees in an inline run: a paragraph, or
+ * anything else whose children are inline content.
+ *
+ * A Markdown text node ends wherever formatting begins, which is not where a
+ * word or an identifier ends. Recognising citations one text node at a time
+ * therefore missed or misread every citation that crossed formatting:
+ * `per 60**s**` became a reference, and `see <span>8.1#3</span>` vanished
+ * without a diagnostic. The run is scanned as a whole instead, and each
+ * segment records where its characters came from.
+ *
+ * Inline HTML other than a line break is transparent, so it contributes no
+ * segment at all.
+ */
+export interface InlineSegment {
+    /** How the segment takes part in recognition. */
+    readonly kind: InlineSegmentKind;
+    /** The characters a reader sees. */
+    readonly text: string;
+    /** Position of the parsed text node, for a `text` segment. */
+    readonly range?: PositionRange;
+    /** MDAST types of the formatting spans enclosing it, outermost first. */
+    readonly wrappers: readonly string[];
+}
+/**
+ * The complete result produced by finalising the Inline Reference Rule
+ * after all text nodes have been evaluated.
+ *
+ * Contains zero or more diagnostics and the list of successfully extracted
+ * inline reference edges.
+ */
+export interface InlineReferenceRuleResult {
+    /** Diagnostics emitted during evaluation (errors for undeclared references). */
+    readonly diagnostics: readonly Diagnostic[];
+    /**
+     * Inline reference edges extracted from valid `see`/`per` forms,
+     * in document traversal order.
+     *
+     * Each edge represents a section-attributed relationship from the
+     * current section context to the referenced TargetID.
+     */
+    readonly inlineReferences: readonly InlineReferenceEdge[];
+}
+/**
+ * Configuration options for constructing an {@link InlineReferenceRule} instance.
+ */
+export interface InlineReferenceRuleOptions {
+    /**
+     * The opaque, host-provided URI identifying the document being validated.
+     * Attached to all emitted diagnostics.
+     */
+    readonly uri: string;
+    /**
+     * The DocID established by the Document Identity Rule for this document.
+     * Used for self-reference detection: an inline reference whose target
+     * DocID (the TargetID itself, or the text before its `#`) equals this
+     * DocID needs no declaration in the References section.
+     */
+    readonly docId: DocID;
+    /**
+     * The {@link IdentifierGrammar} instance used for TargetID validation.
+     */
+    readonly grammar: IdentifierGrammar;
+    /**
+     * The set of DocIDs declared in the References section (the References Section Rule's output).
+     *
+     * Used to determine whether an inline reference's parent DocID has been
+     * declared. If a TargetID's parent DocID is not in this set and is not
+     * a self-reference, an undeclared-reference diagnostic is emitted.
+     */
+    readonly declaredDocIds: ReadonlySet<DocID>;
+    /**
+     * The document's raw Markdown source.
+     *
+     * 1#9.11 is the one rule stated over source rather than over the parsed
+     * tree, because a search reads the file and the parser does not. A citation
+     * written `see 8\\.1#3` parses to `see 8.1#3` and is invisible to every
+     * recipe; only the source shows the difference.
+     */
+    readonly sourceText: string;
+}
+/**
+ * The severity of Inline Reference Rule diagnostics about targets that may be
+ * ordinary prose.
+ *
+ * Per 1#9.5, an undeclared DocID target (`per 60`, `see 8.1`) is a warning at
+ * document level: `see`/`per` followed by a number also occurs in ordinary
+ * prose. The corpus validator reports an error when the target turns out to be
+ * a real document. A wrapped reference is likewise a warning.
+ */
+export declare const INLINE_REFERENCE_DIAGNOSTIC_SEVERITY: DiagnosticSeverity;
+/**
+ * The severity of an undeclared SectionID target (`see 8.1#3`).
+ *
+ * The `#` form never occurs in prose, so such a target is certainly a
+ * reference, and an undeclared one is an error without consulting the corpus.
+ */
+export declare const UNDECLARED_SECTION_TARGET_SEVERITY: DiagnosticSeverity;
+/**
+ * The `data.reason` carried by an undeclared-target diagnostic, which the
+ * corpus validator uses to find the warnings it must check against the index.
+ */
+export declare const UNDECLARED_TARGET_REASON: string;
+/**
+ * The `data.cause` carried by a citation whose candidate is not a complete,
+ * conforming token and contains a `#` (1#9.5 rule 1).
+ */
+export declare const MALFORMED_TARGET_CAUSE: string;
+/**
+ * The `data.cause` carried by a citation whose keyword and identifier are not
+ * adjacent literal text on one source line (1#9.11 rule 2).
+ */
+export declare const CITATION_SOURCE_FORM_CAUSE: string;
+/**
+ * Represents a single inline reference match detected within a text node.
+ *
+ * This is an intermediate type used internally during evaluation. It holds
+ * the parsed components of a detected `see`/`per` form before they are
+ * validated against the declared References set and assembled into an
+ * {@link InlineReferenceEdge}.
+ */
+export interface DetectedInlineReference {
+    /**
+     * The keyword form that introduced this inline reference,
+     * normalised to lowercase.
+     */
+    readonly kind: InlineReferenceKind;
+    /**
+     * The TargetID extracted from the text, maximally matched.
+     * A DocID (`8.1`) or a SectionID (`8.1#3.2`).
+     */
+    readonly targetId: string;
+    /** The keyword exactly as written, preserving its capitalisation. */
+    readonly keyword: string;
+    /**
+     * The candidate run of identifier characters, before conformance is tested.
+     *
+     * Held separately from {@link targetId} because a candidate that fails is
+     * never shortened into one that passes: `1#1#9` does not become `1#1`.
+     */
+    readonly candidate: string;
+    /** Whether the candidate conforms, once a single trailing `.` is allowed for. */
+    readonly conforms: boolean;
+    /** The whitespace between the keyword and the candidate, exactly as written. */
+    readonly gap: string;
+    /**
+     * Offset of the keyword's first character within the parsed text node.
+     *
+     * This is what ties a citation to its own source characters. Every approach
+     * that tried to avoid carrying it -- searching for matching text, counting
+     * occurrences, comparing lists of targets -- could be defeated by another
+     * citation, or by raw text that merely resembled one.
+     */
+    readonly index: number;
+}
+/**
+ * Detects and validates inline `see` and `per` references in document
+ * prose as defined in the ECR specification (1#9.5, 1#10.7).
+ *
+ * The rule enforces that:
+ * - Inline references use the `see TargetID` or `per TargetID` keyword forms
+ * - The keyword is preceded by a word boundary (start of string, whitespace,
+ *   or punctuation) to prevent false positives from words like "oversee"
+ *   or "hyperparameter"
+ * - The keyword's first letter may be capitalised (`See`, `Per`); the
+ *   `kind` field normalises to lowercase
+ * - TargetID conforms to the identifier grammar and is maximally matched
+ * - The parent DocID of the TargetID is declared in the References section,
+ *   or the TargetID is a self-reference to the document's own DocID
+ *
+ * For each valid inline reference whose parent DocID is declared (or is a
+ * self-reference), the rule extracts an {@link InlineReferenceEdge} with
+ * `fromId` set to the section context passed per call and `kind` normalised
+ * to lowercase.
+ *
+ * For undeclared references, the rule emits a warning diagnostic and does
+ * not extract an edge.
+ *
+ * Usage:
+ * 1. Construct a rule instance with the document URI, established DocID,
+ *    grammar instance, and the set of declared DocIDs from the References section.
+ * 2. Call {@link evaluateTextNode} for every text node encountered during
+ *    AST traversal (after the visitor has filtered out code/inlineCode/HTML/link
+ *    URL contexts), passing the current section context.
+ * 3. Call {@link finalise} after all text nodes have been evaluated to obtain
+ *    the complete result.
+ *
+ * @example
+ * ```ts
+ * const grammar = new IdentifierGrammar();
+ * const rule = new InlineReferenceRule({
+ *   uri: 'file:///doc.md',
+ *   docId: '5.1',
+ *   grammar,
+ *   declaredDocIds: new Set(['3.1', '8.1']),
+ * });
+ *
+ * rule.evaluateTextNode(
+ *   { text: 'Guardrail logic per 3.1#2 and retry semantics see 8.1.' },
+ *   '5.1#1',
+ * );
+ *
+ * const result: InlineReferenceRuleResult = rule.finalise();
+ * // result.inlineReferences has two edges:
+ * //   { fromId: '5.1#1', toId: '3.1#2', kind: 'per' }
+ * //   { fromId: '5.1#1', toId: '8.1', kind: 'see' }
+ * ```
+ */
+export declare class InlineReferenceRule {
+    /** The opaque, host-provided URI identifying the document being validated. */
+    private readonly uri;
+    /** The established DocID for this document, used for self-reference detection. */
+    private readonly docId;
+    /** The grammar instance used for TargetID validation. */
+    private readonly grammar;
+    /** The set of DocIDs declared in the References section. */
+    private readonly declaredDocIds;
+    /** Diagnostics accumulated during evaluation. */
+    private readonly collectedDiagnostics;
+    /** Inline reference edges extracted from valid forms, in traversal order. */
+    private readonly collectedInlineReferences;
+    /** The document's raw source, for the source-form checks of 1#9.11. */
+    private readonly sourceText;
+    /** Absolute offset at which each source line begins. */
+    private readonly lineStarts;
+    /**
+     * Constructs a new Inline Reference Rule evaluator.
+     *
+     * @param options - Configuration including the document URI, established DocID,
+     *                  grammar instance, and declared DocIDs from the References section
+     */
+    constructor(options: InlineReferenceRuleOptions);
+    /**
+     * Evaluates a single text node for inline `see`/`per` references.
+     *
+     * Scans the text for all occurrences of `see TargetID` or `per TargetID`
+     * where the keyword is preceded by a word boundary. For each detected
+     * inline reference:
+     *
+     * 1. Validates that the TargetID conforms to the identifier grammar
+     * 2. Determines the parent DocID of the TargetID
+     * 3. Checks whether the parent DocID is declared in the References section
+     *    or is a self-reference to the document's own DocID
+     * 4. If declared or self-referencing, extracts an {@link InlineReferenceEdge}
+     *    with `fromId` set to the provided `sectionContext`
+     * 5. If undeclared, emits a warning diagnostic and does not extract an edge
+     *
+     * Multiple inline references within a single text node are all independently
+     * detected and validated. Duplicate references are not deduplicated (that is
+     * a downstream concern).
+     *
+     * @param textNodeData - Data extracted from a text AST node
+     * @param sectionContext - The current heading identifier (DocID or SectionID)
+     *                         at the point where this text node appears in the document.
+     *                         Used as the `fromId` for any extracted edges.
+     */
+    evaluateTextNode(textNodeData: TextNodeData, sectionContext: DocID | SectionID): void;
+    /**
+     * Evaluates one inline run -- a paragraph, say -- for inline references.
+     *
+     * Recognition reads the run as a reader sees it, across every node boundary
+     * (1#9.5 rule 1). Only then is the source consulted: a citation extracts an
+     * edge only when its keyword, space and identifier all lie in one text
+     * segment and are literal in the source there (1#9.11 rule 2). One that
+     * spans segments -- split by formatting, inline HTML, code or a break -- is
+     * reported, never passed over.
+     *
+     * @param segments - The run's visible text, in order, per {@link InlineSegment}
+     * @param sectionContext - Section the run belongs to, used as `fromId`
+     */
+    evaluateInlineRun(segments: readonly InlineSegment[], sectionContext: DocID | SectionID): void;
+    /**
+     * Records which segment each character of a run's visible text came from.
+     *
+     * @param segments - The run's segments
+     * @returns For each visible offset, the index of its segment
+     */
+    private static indexSegmentOwners;
+    /**
+     * Records where each segment begins in a run's visible text.
+     *
+     * @param segments - The run's segments
+     * @returns The visible offset of each segment's first character
+     */
+    private static indexSegmentStarts;
+    /**
+     * Says what split a citation across segments, for its diagnostic.
+     *
+     * Formatting is named when it is what differs: `see **8.1#3**` is split by
+     * bold text. Otherwise the kind of segment in the way is named, and where
+     * two text segments meet with nothing visible between them, only inline
+     * HTML can have separated them.
+     *
+     * @param segments - The run's segments
+     * @param first - Index of the segment holding the keyword
+     * @param last - Index of the segment holding the identifier's end
+     * @returns The phrase for the message, and any data it adds
+     */
+    private static describeSplit;
+    /**
+     * Reports whether this citation is written literally at its own position.
+     *
+     * Only the keyword, the single space and the identifier are required to be
+     * literal. What follows them is not: a citation may be terminated by a
+     * character reference (`see 1#1&nbsp;here`) and remain perfectly findable,
+     * because a search stops at the identifier. Applying the parsed token's
+     * terminator rules to raw characters rejected exactly those documents.
+     *
+     * @param detected - The citation under test
+     * @param range - The node's range, absent in unit tests that supply bare text
+     * @param source - The node's raw source, when it could be located
+     * @param offsets - Parsed-to-source offset map, when alignment succeeded
+     * @returns `true` when the source carries this citation literally
+     */
+    private tellCitationIsLiteral;
+    /**
+     * Reports whether the published recipes accept the characters either side
+     * of a citation in the source (1#9.11).
+     *
+     * Before the keyword, the recipes accept a word boundary or `_`: `_` is a
+     * word character to both engines, and `_see 8.1_` is ordinary emphasis.
+     * After the identifier they accept anything but an ASCII letter or digit.
+     * After a bare DocID a `#` is refused too, and a `.` is allowed only as the
+     * end of a sentence -- not before a letter, digit, `.` or `#` -- so that
+     * `8.1` is not found inside `8.1#3`, `8.1.2` or `8.1..2`; after a SectionID
+     * a `.` is allowed, since the recipe finds a section and those below it.
+     *
+     * The whole source is read, not the node's slice: a citation at the start
+     * of a node is preceded by whatever came before the node.
+     *
+     * @param start - Absolute source offset of the keyword
+     * @param detected - The citation, known to be literal at `start`
+     * @returns `true` when the recipe for this target would match here
+     */
+    private tellRecipeBoundsCitation;
+    /**
+     * Reports a candidate that is not a complete, conforming identifier.
+     *
+     * The `#` decides whether anything is reported at all. Ordinary writing
+     * produces numbers after `see` and `per` constantly -- `per 60s`,
+     * `see 1..2` -- and never produces `1#1`. So a failed candidate carrying a
+     * separator was certainly meant as an identifier and is an error, while one
+     * without is prose and is passed over in silence.
+     *
+     * @param detected - The candidate that failed
+     * @param sectionContext - Section the text belongs to
+     * @param range - Positional range of the text node
+     */
+    private reportNonConformingCandidate;
+    /**
+     * Reports a citation whose source form no search can find (1#9.11 rule 2).
+     *
+     * Severity follows the same test as an undeclared target: an identifiable
+     * target -- a SectionID, a declared DocID, or the document's own -- was
+     * certainly meant as a citation, so an unfindable one is an error. A bare
+     * number naming nothing known cannot be told from emphasised prose, so it
+     * warns, and corpus validation raises it if the document turns out to exist.
+     *
+     * @param detected - The citation that is not literal in the source
+     * @param sectionContext - Section the text belongs to
+     * @param range - Positional range of the text node
+     * @param split - What split it, when it spans segments, e.g. `is split by bold text`
+     * @param extra - Data the diagnostic carries in addition
+     */
+    private reportUnnavigableCitation;
+    /**
+     * Reports a conforming, navigable citation whose DocID is not declared.
+     *
+     * @param detected - The citation
+     * @param sectionContext - Section the text belongs to
+     * @param range - Positional range of the text node
+     */
+    private reportUndeclaredTarget;
+    /**
+     * Finalises the rule evaluation and produces the complete result.
+     *
+     * This method must be called after all text nodes have been supplied
+     * via {@link evaluateTextNode}. It returns the accumulated diagnostics
+     * and extracted inline reference edges.
+     *
+     * @returns The complete rule result including all diagnostics and
+     *          extracted inline reference edges
+     */
+    finalise(): InlineReferenceRuleResult;
+    /**
+     * Finds every `see`/`per` citation candidate in a run's visible text.
+     *
+     * A keyword is recognised where a word boundary precedes it in the text a
+     * reader sees, and a candidate where digits follow it after whitespace.
+     * Neither is recognised when it starts inside inline code or a break: code
+     * may continue a candidate, but an author never cites through it (1#9.5).
+     *
+     * @param visible - The run's visible text
+     * @param segments - The run's segments
+     * @param owners - For each visible offset, the index of its segment
+     * @returns The candidates, in order of occurrence, indexed into `visible`
+     */
+    private detectInlineReferences;
+    /**
+     * Reads the candidate identifier that follows a keyword, if there is one.
+     *
+     * The candidate is the maximal run of identifier characters, taken whole
+     * before it is tested. Taking it whole is what stops a malformed identifier
+     * decaying into a shorter valid one: `1#1#9` fails, rather than passing as
+     * `1#1`.
+     *
+     * @param text - The run's visible text
+     * @param keywordIndex - Index of the keyword's first character
+     * @param keyword - The keyword exactly as written
+     * @returns The candidate, or `undefined` when no digits follow the keyword
+     */
+    private readCandidate;
+    /**
+     * Reports whether a keyword at `index` stands at a word boundary.
+     *
+     * Reads whole code points: `charAt` would return half of a supplementary
+     * character and misjudge it.
+     *
+     * @param text - The text being scanned
+     * @param index - Index of the keyword's first character
+     * @returns `true` when nothing word-like immediately precedes the keyword
+     */
+    private tellAtWordBoundary;
+    /**
+     * Returns the raw source belonging to a node, when its range is known.
+     *
+     * @param range - The node's positional range
+     * @returns The source slice, or `undefined` when no range was supplied
+     */
+    private sliceSource;
+    /**
+     * Converts a line/character position into an absolute source offset.
+     *
+     * @param position - A position within the document
+     * @returns The offset, or `undefined` when the line is out of range
+     */
+    private offsetOf;
+    /**
+     * Determines whether a TargetID's parent DocID is declared in the
+     * References section or is a self-reference to the document's own DocID.
+     *
+     * The target's DocID is read directly — the TargetID itself, or the text
+     * before its `#` — and compared exactly with the document's own DocID and
+     * the declared set. No prefix matching is involved, so `8.1.3` is not
+     * covered by a declaration of `8.1`.
+     *
+     * @param targetId - The TargetID to check
+     * @returns `true` if the TargetID is declared or is a self-reference,
+     *          `false` if it is an undeclared reference
+     */
+    private tellTargetIdDeclared;
+    /**
+     * Extracts the DocID a TargetID refers to.
+     *
+     * This needs no inference: everything before the `#` separator is the
+     * DocID, and an identifier with no separator is itself a DocID. The
+     * separator removes the ambiguity a dotted-only grammar would have to
+     * resolve by guessing.
+     *
+     * @param targetId - A DocID or SectionID as written in an inline reference
+     * @returns The DocID portion of the identifier
+     */
+    private showTargetDocId;
+    /**
+     * Creates a diagnostic object for the Inline Reference Rule.
+     *
+     * All diagnostics share the same rule ID ({@link INLINE_REFERENCE_RULE_ID})
+     * and document URI.
+     *
+     * @param message - Human-readable description of the issue
+     * @param range - Optional positional range within the source document
+     * @param data - Optional structured detail
+     * @param severity - Defaults to {@link INLINE_REFERENCE_DIAGNOSTIC_SEVERITY}
+     * @returns A fully populated diagnostic object
+     */
+    private createDiagnostic;
+}
+//# sourceMappingURL=inline-reference-rule.d.ts.map

package/dist/inline-reference-rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-reference-rule.d.ts","sourceRoot":"","sources":["../src/inline-reference-rule.ts"],"names":[],"mappings":"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"}