pickier 0.1.21 → 0.1.23

package/dist/rules/general/_template-tracking.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Compute, for each line of a TS/JS source, whether the line begins inside
+ * a template-literal body (i.e. between an unclosed backtick and its
+ * matching close).
+ *
+ * Used by rules like `prefer-const` and `pickier/no-unused-vars` to skip
+ * generated code embedded in template strings — declarations and function
+ * bodies inside a `\`<script>...\`` blob aren't real top-level code, and
+ * applying lint rules to them produces false positives that fixers will
+ * happily turn into broken runtime code.
+ *
+ * Tracks: single-quoted strings, double-quoted strings, template-literal
+ * bodies + their `${}` expressions (with brace depth), regex literals
+ * (with character-class awareness), line and block comments.
+ *
+ * Regex-vs-division disambiguation uses the previous "significant"
+ * character on the logical statement: `/` after operators / punctuation
+ * starts a regex; `/` after an identifier or closing bracket is division.
+ */
+export declare function computeLineStartsInTemplate(text: string): boolean[];
+/**
+ * On a single line, return [start, end] ranges of characters that fall
+ * inside a backtick-bounded template literal. If a backtick opens but
+ * doesn't close on this line, the range extends to the line's end (it's
+ * the first line of a multi-line template).
+ *
+ * Used by per-line fixers to refuse to rewrite identifiers that fall
+ * inside an embedded code blob whose other usages live in the same
+ * template string and aren't visible to the syntactic rename.
+ */
+export declare function backtickRangesOnLine(line: string): Array<[number, number]>;

package/dist/rules/markdown/_fence-tracking.d.ts

@@ -0,0 +1,32 @@
+/**
+ * CommonMark-compliant code-block detection for markdown.
+ *
+ * Returns a Set of 0-indexed line numbers that are inside any code block —
+ * fenced (` ``` ... ``` ` / `~~~ ... ~~~`) or indented (4-space prefix). The
+ * fence boundary lines themselves are also included.
+ *
+ * Per the CommonMark spec, a fenced code block:
+ *  - Opens with at least 3 backticks or tildes, optionally followed by an
+ *    "info string" (e.g. ` ```js `).
+ *  - Closes only with the SAME fence character, AT LEAST as many of them
+ *    as the opener, and an EMPTY info string (just the run of backticks
+ *    or tildes plus optional trailing whitespace).
+ *  - Anything else inside the block — including ` ```js ` lines — is
+ *    content, not a fence boundary.
+ *
+ * The naive tracker that toggles on every `^`{3,}|~{3,}` confuses
+ * `` ```js `` with a close and corrupts state for the rest of the file.
+ * Use this helper instead.
+ *
+ * Indented code blocks: a line is treated as inside an indented code block
+ * when it has 4+ leading spaces and the previous non-blank line is also
+ * indented (or blank with another indented line above it). Lines inside a
+ * fenced block don't double-count as indented.
+ */
+export declare function getCodeBlockLines(lines: string[]): Set<number>;
+/**
+ * Like `getCodeBlockLines` but returns whether a single line index is
+ * inside ANY kind of code block — handy for one-shot checks where you
+ * don't already have the set computed.
+ */
+export declare function isInsideCodeBlock(lines: string[], targetIdx: number): boolean;

package/dist/rules/markdown/_shared.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Identify genuine GFM table rows in a markdown document. A row counts as
+ * a table row when it is part of a block that includes a separator row of
+ * the form `|---|---|` (pipes + dashes, optional colons for alignment).
+ * Stray `|` characters inside paragraphs are ignored. Lines inside fenced
+ * or indented code blocks are ignored — `| Foo | Bar |` lines inside a
+ * `` ```markdown `` example are content, not real tables.
+ */
+export declare function findTableRows(lines: string[]): Set<number>;