sh-ast 0.0.0 → 0.1.0

package/dist/analyze/node-helpers.d.ts

@@ -0,0 +1,28 @@
+import type { ShNode } from '../types.js';
+/**
+ * True iff `value` has the minimal shape every normalized {@link ShNode}
+ * carries (an object, not an array, with a string `type` field). Used to
+ * narrow `unknown` field values discovered while walking a node's own
+ * properties — every node field on {@link ShNode} is typed `unknown` (see
+ * its index signature), so any code that inspects a specific field's value
+ * needs this runtime check before treating it as a child node.
+ *
+ * @internal
+ */
+export declare function isShNodeShape(value: unknown): value is ShNode;
+/**
+ * Filters `value` down to the {@link ShNode} elements of an array-shaped
+ * field, discarding anything else — and returning `[]` for a non-array or
+ * `undefined` field, so callers never need a separate `Array.isArray` guard.
+ *
+ * @internal
+ */
+export declare function nodeArray(value: unknown): readonly ShNode[];
+/**
+ * Reads `node[field]` as a string, defaulting to `''` for any other shape
+ * (missing field, non-string value).
+ *
+ * @internal
+ */
+export declare function stringField(node: ShNode, field: string): string;
+//# sourceMappingURL=node-helpers.d.ts.map

package/dist/analyze/node-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-helpers.d.ts","sourceRoot":"","sources":["../../src/analyze/node-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAO7D;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,MAAM,EAAE,CAE3D;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAG/D"}

package/dist/analyze/node-helpers.js

@@ -0,0 +1,37 @@
+/**
+ * True iff `value` has the minimal shape every normalized {@link ShNode}
+ * carries (an object, not an array, with a string `type` field). Used to
+ * narrow `unknown` field values discovered while walking a node's own
+ * properties — every node field on {@link ShNode} is typed `unknown` (see
+ * its index signature), so any code that inspects a specific field's value
+ * needs this runtime check before treating it as a child node.
+ *
+ * @internal
+ */
+export function isShNodeShape(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        !Array.isArray(value) &&
+        typeof value.type === 'string');
+}
+/**
+ * Filters `value` down to the {@link ShNode} elements of an array-shaped
+ * field, discarding anything else — and returning `[]` for a non-array or
+ * `undefined` field, so callers never need a separate `Array.isArray` guard.
+ *
+ * @internal
+ */
+export function nodeArray(value) {
+    return Array.isArray(value) ? value.filter(isShNodeShape) : [];
+}
+/**
+ * Reads `node[field]` as a string, defaulting to `''` for any other shape
+ * (missing field, non-string value).
+ *
+ * @internal
+ */
+export function stringField(node, field) {
+    const value = node[field];
+    return typeof value === 'string' ? value : '';
+}
+//# sourceMappingURL=node-helpers.js.map

package/dist/analyze/node-helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-helpers.js","sourceRoot":"","sources":["../../src/analyze/node-helpers.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,MAAM,UAAU,aAAa,CAAC,KAAc;IAC1C,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,KAAK,IAAI;QACd,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QACrB,OAAQ,KAA4B,CAAC,IAAI,KAAK,QAAQ,CACvD,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,SAAS,CAAC,KAAc;IACtC,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;AACjE,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CAAC,IAAY,EAAE,KAAa;IACrD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC;IAC1B,OAAO,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;AAChD,CAAC"}

package/dist/analyze/resolve-word.d.ts

@@ -0,0 +1,146 @@
+import type { ShNode } from '../types.js';
+/**
+ * Why a {@link resolveWord} result is `static: false`: the word's exact
+ * text cannot be determined from source alone.
+ *
+ * - `'expansion'` — the word contains a `ParamExp` (`$x`, `${x}`), a
+ *   `CmdSubst` (command substitution, either `$(...)` or backtick form), an
+ *   `ArithmExp` (`$((expr))`), or a `ProcSubst` (`<(cmd)`/`>(cmd)`) part:
+ *   its value depends on program state (variables, command output, process
+ *   substitution) that only exists at run time.
+ * - `'tilde'` — an unquoted, unescaped `~` triggers Bash tilde expansion
+ *   (Bash Reference Manual §3.5.2, "Tilde Expansion") at the start of the
+ *   word, or — when `resolveWord`'s `context` option is `'assignment-value'`
+ *   or omitted — immediately after an unquoted `:` anywhere in the word too
+ *   (§3.5.2 also documents this for assignment-statement values, e.g.
+ *   `PATH=/foo:~/bar`). Either way: statically shaped, but its value
+ *   depends on the filesystem/environment (`$HOME`, NSS user database
+ *   lookups) at run time. See `resolveWord`'s `context` parameter doc for
+ *   the full command-argument-vs-assignment-value distinction.
+ * - `'glob'` — the word contains an unquoted, unescaped glob metacharacter
+ *   (`*`/`?`), an unquoted bracket expression (`[...]` — an unquoted `[`
+ *   with a later unquoted `]` in the same word, POSIX 2.13.1 / Bash
+ *   Reference Manual §3.5.8.1, "Pattern Matching"), or an `ExtGlob` part
+ *   (Bash Reference Manual §3.5.8, "Filename Expansion"): its value depends
+ *   on which filesystem entries exist at run time.
+ * - `'brace'` — the word contains a `BraceExp` part (`{a,b}`/`{1..10}`,
+ *   Bash Reference Manual §3.5.1, "Brace Expansion"). mvdan/sh v3.13.1 only
+ *   ever produces this node type when its caller applies `syntax.SplitBraces`
+ *   to the parsed tree; this bridge's shim does not call it, so today a
+ *   brace expression like `{a,b}` reaches {@link resolveWord} as an
+ *   ordinary `Lit` (indistinguishable, in the AST this bridge produces,
+ *   from literal `{`/`,`/`}` characters) rather than as a `BraceExp` part.
+ *   This reason is handled here for forward-compatibility with that node
+ *   type and is not reachable through {@link resolveWord} today.
+ * - `'locale'` — the word contains a `$"..."` locale-translated string
+ *   (Bash Reference Manual §3.1.2.5, "Locale-Specific Translation"): its
+ *   value is looked up in the current locale's translation catalog at run
+ *   time via `gettext`, regardless of whether its contents also contain an
+ *   expansion. `'locale'` takes precedence over any `'expansion'` a
+ *   `$"..."` word's *contents* would otherwise report — the `DblQuoted`
+ *   node's own `dollar` flag is checked before its children are visited at
+ *   all, so e.g. `$"hi $x"` reports `'locale'`, never `'expansion'`.
+ * - `'unsupported'` — the word contains a `$'...'` (ANSI-C quoted) `\u`/`\U`
+ *   escape whose value has no corresponding Unicode character (greater than
+ *   `U+10FFFF`, e.g. `$'\UFFFFFFFF'`): real bash's output for this case is
+ *   an undocumented, non-UTF-8 byte sequence with no exact representation
+ *   as a JavaScript string (see `ansi-c-escapes.ts`'s
+ *   `MAX_UNICODE_CODE_POINT` doc comment for the empirical detail) — this
+ *   package declines to claim a `static: true` text bash never actually
+ *   produces.
+ *
+ * This union may grow in a **minor** release — new mvdan/sh word-part node
+ * types, or new statically-shaped-but-dynamic categories, can add new reason
+ * strings without that being a breaking change. It is deliberately not
+ * sealed against extension elsewhere in the codebase. A reason string this
+ * version of the package doesn't yet know about only ever accompanies
+ * `static: false`, never changes the meaning of `static: true`, so runtime
+ * consumers that only branch on `.static` are safe by construction across
+ * such additions; an exhaustive compile-time `switch` over `.reason` should
+ * still include a `default` case to stay forward-compatible.
+ *
+ * @public
+ */
+export type WordResolutionReason = 'expansion' | 'tilde' | 'glob' | 'brace' | 'locale' | 'unsupported';
+/**
+ * The result of statically resolving a `Word` node's text. Reports facts
+ * only — never a safety verdict, never a hardcoded command/wrapper list.
+ * `static: false` ("unknowable") is a first-class, valid result, not an
+ * error condition.
+ *
+ * @public
+ */
+export type WordResolution = {
+    /** The word is a compile-time-known string. */
+    readonly static: true;
+    /** The word's exact resolved text (quotes and escapes removed). */
+    readonly text: string;
+} | {
+    /** The word's value depends on program state, the environment, or the filesystem. */
+    readonly static: false;
+    /** Why this word cannot be statically resolved. */
+    readonly reason: WordResolutionReason;
+};
+/**
+ * Options controlling {@link resolveWord}'s tilde-expansion detection.
+ *
+ * @public
+ */
+export interface ResolveWordOptions {
+    /**
+     * Which Bash grammar position `word` occupies — the two positions Bash
+     * §3.5.2 ("Tilde Expansion") documents distinct tilde-expansion triggers
+     * for:
+     *
+     * - `'command-argument'` — an ordinary simple-command argument word (e.g.
+     *   `echo <word>`). Only a *word-initial* unquoted `~` triggers tilde
+     *   expansion; an unquoted `~` elsewhere in the word (including right
+     *   after a `:`) is an ordinary character (`echo a:~b` prints `a:~b`
+     *   literally in real bash).
+     * - `'assignment-value'` — the value side of a shell assignment (e.g.
+     *   `PATH=<word>`, an `Assign` node's `value`). Bash additionally
+     *   tilde-expands an unquoted `~` immediately following an unquoted `:`
+     *   anywhere in the value (`PATH=/foo:~/bar` expands the `~/bar`
+     *   segment) — this is documented for `PATH`-like colon-separated
+     *   assignment values specifically.
+     *
+     * **Default: `'assignment-value'` semantics apply whenever this option is
+     * omitted.** `resolveWord` takes a bare `Word` node with no grammar
+     * context attached, so it cannot see whether its caller extracted that
+     * word from a command argument or an assignment value — omitting this
+     * option is deliberately treated as the *more conservative* of the two
+     * (the one that reports `'tilde'` in more cases), so a caller that
+     * doesn't know or care about the distinction never under-reports a real
+     * tilde-expansion site. Pass `'command-argument'` explicitly to opt into
+     * the narrower, word-initial-only check that matches real bash's
+     * behavior for ordinary arguments.
+     *
+     * @see https://www.gnu.org/software/bash/manual/bash.html#Tilde-Expansion
+     */
+    readonly context?: 'command-argument' | 'assignment-value';
+}
+/**
+ * Determines whether a `Word` node is statically a known string, and if
+ * so, what that string is — the atom of shell-AST static analysis (e.g.
+ * "is this word literally `rm`"). A word is static iff every part is a
+ * literal after shell unquoting: a bare `Lit` (backslash escapes
+ * processed), a `SglQuoted` (including `$'...'` ANSI-C escapes decoded),
+ * or a `DblQuoted` containing only literal parts (and not itself a
+ * `$"..."` locale translation) — including concatenations of these (`'r'm`
+ * resolves to `"rm"`). A word containing any expansion (`ParamExp`,
+ * `CmdSubst`, `ArithmExp`, `ProcSubst`), a triggering unquoted `~` (see
+ * `options.context`), an unquoted glob metacharacter/bracket
+ * expression/`ExtGlob`, a `$"..."` locale translation, or an unrepresentable
+ * `$'\U...'` escape is `static: false` with a reason — never an error, and
+ * never a safety judgment (see {@link WordResolution}).
+ *
+ * @param word - A `Word` node, e.g. `parseSync(...).stmts[0].cmd.args[0]`.
+ * @param options - See {@link ResolveWordOptions}.
+ * @throws TypeError if `word.type` is not `"Word"` — a programmer-error
+ * misuse of the API, not a "malformed shell source" case (well-formed
+ * shell source, however dynamic, never throws; see {@link WordResolution}).
+ *
+ * @public
+ */
+export declare function resolveWord(word: ShNode, options?: ResolveWordOptions): WordResolution;
+//# sourceMappingURL=resolve-word.d.ts.map

package/dist/analyze/resolve-word.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-word.d.ts","sourceRoot":"","sources":["../../src/analyze/resolve-word.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAK1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,MAAM,MAAM,oBAAoB,GAC9B,WAAW,GAAG,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,aAAa,CAAC;AAEtE;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,GACtB;IACE,+CAA+C;IAC/C,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;IACtB,mEAAmE;IACnE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB,GACD;IACE,qFAAqF;IACrF,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC;IACvB,mDAAmD;IACnD,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAC;CACvC,CAAC;AAEN;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG,kBAAkB,CAAC;CAC5D;AA6JD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,cAAc,CA4BtF"}

package/dist/analyze/resolve-word.js

@@ -0,0 +1,202 @@
+import { decodeAnsiCString } from './ansi-c-escapes.js';
+import { decodeDblQuotedLit, decodeUnquotedLit } from './decode-lit.js';
+import { nodeArray, stringField } from './node-helpers.js';
+/**
+ * True iff `raw` (a `Lit` part's *undecoded* value) begins with a literal
+ * `~` character. Only meaningful when checked against a `Word`'s very
+ * first part: Bash tilde expansion (§3.5.2) triggers only at the start of
+ * a word, so `a~b` (mid-word) and `\~foo` (escaped — `raw` starts with a
+ * backslash, not `~`) are correctly excluded, while `~"foo"` (a leading
+ * unquoted `~` followed by a separately-quoted part) is correctly
+ * included, since it is still a distinct first `Lit` part starting with an
+ * unquoted `~`.
+ */
+function startsWithUnescapedTilde(raw) {
+    return raw.startsWith('~');
+}
+/**
+ * True iff an unquoted, unescaped `~` immediately follows an unquoted,
+ * unescaped `:` anywhere across `parts` — Bash §3.5.2's assignment-value
+ * tilde-expansion trigger (e.g. the `~/bar` in `PATH=/foo:~/bar`).
+ *
+ * Only a `Word`'s top-level `Lit` parts carry unquoted text; any other
+ * part type (`SglQuoted`, `DblQuoted`, `ParamExp`, …) breaks adjacency —
+ * whatever text or expansion it represents sits between the `:` and any
+ * following `~`, so they are no longer *immediately* adjacent. `:`/`~`
+ * adjacency is tracked across concatenated `Lit` parts (state carried
+ * between loop iterations), since concatenation joins parts with no
+ * grammar-level separator between them.
+ */
+function hasUnquotedColonTilde(parts) {
+    let prevWasUnescapedColon = false;
+    for (const part of parts) {
+        if (part.type !== 'Lit') {
+            prevWasUnescapedColon = false;
+            continue;
+        }
+        const raw = stringField(part, 'value');
+        let i = 0;
+        while (i < raw.length) {
+            const ch = raw[i];
+            if (ch === '\\' && i + 1 < raw.length) {
+                // An escaped character (whatever it is) is never an unescaped `:`
+                // or `~`, and breaks adjacency for the purposes of this scan.
+                prevWasUnescapedColon = false;
+                i += 2;
+                continue;
+            }
+            if (prevWasUnescapedColon && ch === '~') {
+                return true;
+            }
+            prevWasUnescapedColon = ch === ':';
+            i += 1;
+        }
+    }
+    return false;
+}
+/**
+ * True iff `parts` contains an unquoted bracket expression: an unescaped
+ * `[` with a later unescaped `]` anywhere in the same word (POSIX 2.13.1 /
+ * Bash Reference Manual §3.5.8.1, "Pattern Matching"). `a[bc` (no closing
+ * bracket) is a *literal* filename in Bash; `a[bc]d` is a pattern. The
+ * closing `]` may live in a different, concatenated `Lit` part than the
+ * opening `[` (`decodeUnquotedLit`'s `brackets` output is concatenated,
+ * in part order, across every top-level `Lit` part first) — and content
+ * *between* the two, even if it came from an unquoted or quoted part, does
+ * not prevent them from forming a bracket expression (`a["b"]` matches
+ * real bash's file `ab`, verified empirically: quoting `"b"` doesn't
+ * suppress the surrounding unquoted `[`/`]`). Only `Lit` parts contribute
+ * to the scan — `SglQuoted`/`DblQuoted` text is fully quoted and never
+ * glob-significant (`a'['bc']'d`'s brackets are both quoted, so it stays
+ * literal).
+ */
+function hasUnquotedBracketExpression(parts) {
+    let brackets = '';
+    for (const part of parts) {
+        if (part.type !== 'Lit')
+            continue;
+        brackets += decodeUnquotedLit(stringField(part, 'value')).brackets;
+    }
+    const openIndex = brackets.indexOf('[');
+    if (openIndex === -1)
+        return false;
+    return brackets.includes(']', openIndex + 1);
+}
+function resolvePart(part, quoting) {
+    switch (part.type) {
+        case 'Lit': {
+            const raw = stringField(part, 'value');
+            if (quoting === 'dblquoted') {
+                return { ok: true, text: decodeDblQuotedLit(raw) };
+            }
+            const { text, hasGlob } = decodeUnquotedLit(raw);
+            if (hasGlob)
+                return { ok: false, reason: 'glob' };
+            return { ok: true, text };
+        }
+        case 'SglQuoted': {
+            const raw = stringField(part, 'value');
+            // ANSI-C quoting ($'...') is flagged by SglQuoted.Dollar (mvdan/sh
+            // v3.13.1's `syntax.SglQuoted.Dollar bool`); plain single-quoted
+            // text ('...') never has any escapes interpreted at all.
+            if (part.dollar === true) {
+                const decoded = decodeAnsiCString(raw);
+                if (!decoded.ok)
+                    return { ok: false, reason: 'unsupported' };
+                return { ok: true, text: decoded.text };
+            }
+            return { ok: true, text: raw };
+        }
+        case 'DblQuoted': {
+            // Locale translation ($"...") is flagged by DblQuoted.Dollar
+            // (mvdan/sh v3.13.1's `syntax.DblQuoted.Dollar bool`) and is checked
+            // before descending into this node's children: the whole construct
+            // is locale-dependent regardless of its contents (Bash Reference
+            // Manual §3.1.2.5), so 'locale' deterministically takes precedence
+            // over any 'expansion' (or other reason) its contents would
+            // otherwise report — see WordResolutionReason's 'locale' doc.
+            if (part.dollar === true) {
+                return { ok: false, reason: 'locale' };
+            }
+            let text = '';
+            for (const inner of nodeArray(part.parts)) {
+                const result = resolvePart(inner, 'dblquoted');
+                if (!result.ok)
+                    return result;
+                text += result.text;
+            }
+            return { ok: true, text };
+        }
+        case 'ParamExp':
+        case 'CmdSubst':
+        case 'ArithmExp':
+        case 'ProcSubst':
+            return { ok: false, reason: 'expansion' };
+        case 'ExtGlob':
+            return { ok: false, reason: 'glob' };
+        case 'BraceExp':
+            // See WordResolutionReason's 'brace' doc: unreachable via this
+            // bridge's parser today, handled for forward-compatibility.
+            return { ok: false, reason: 'brace' };
+        default:
+            // Any word-part node type this module doesn't specifically know
+            // about. "Unknowable" must stay a first-class result for well-formed
+            // input rather than a thrown error — 'expansion' is the closest
+            // neutral bucket (some run-time-dependent mechanism) until the type
+            // is specifically handled.
+            return { ok: false, reason: 'expansion' };
+    }
+}
+/**
+ * Determines whether a `Word` node is statically a known string, and if
+ * so, what that string is — the atom of shell-AST static analysis (e.g.
+ * "is this word literally `rm`"). A word is static iff every part is a
+ * literal after shell unquoting: a bare `Lit` (backslash escapes
+ * processed), a `SglQuoted` (including `$'...'` ANSI-C escapes decoded),
+ * or a `DblQuoted` containing only literal parts (and not itself a
+ * `$"..."` locale translation) — including concatenations of these (`'r'm`
+ * resolves to `"rm"`). A word containing any expansion (`ParamExp`,
+ * `CmdSubst`, `ArithmExp`, `ProcSubst`), a triggering unquoted `~` (see
+ * `options.context`), an unquoted glob metacharacter/bracket
+ * expression/`ExtGlob`, a `$"..."` locale translation, or an unrepresentable
+ * `$'\U...'` escape is `static: false` with a reason — never an error, and
+ * never a safety judgment (see {@link WordResolution}).
+ *
+ * @param word - A `Word` node, e.g. `parseSync(...).stmts[0].cmd.args[0]`.
+ * @param options - See {@link ResolveWordOptions}.
+ * @throws TypeError if `word.type` is not `"Word"` — a programmer-error
+ * misuse of the API, not a "malformed shell source" case (well-formed
+ * shell source, however dynamic, never throws; see {@link WordResolution}).
+ *
+ * @public
+ */
+export function resolveWord(word, options) {
+    if (word.type !== 'Word') {
+        throw new TypeError(`resolveWord expects a "Word" node, got "${word.type}"`);
+    }
+    const parts = nodeArray(word.parts);
+    if (parts.length === 0) {
+        return { static: true, text: '' };
+    }
+    // `parts.length === 0` returned above, so `parts[0]` is a real element.
+    const first = parts[0];
+    if (first.type === 'Lit' && startsWithUnescapedTilde(stringField(first, 'value'))) {
+        return { static: false, reason: 'tilde' };
+    }
+    if (options?.context !== 'command-argument' && hasUnquotedColonTilde(parts)) {
+        return { static: false, reason: 'tilde' };
+    }
+    if (hasUnquotedBracketExpression(parts)) {
+        return { static: false, reason: 'glob' };
+    }
+    let text = '';
+    for (const part of parts) {
+        const result = resolvePart(part, 'unquoted');
+        if (!result.ok) {
+            return { static: false, reason: result.reason };
+        }
+        text += result.text;
+    }
+    return { static: true, text };
+}
+//# sourceMappingURL=resolve-word.js.map

package/dist/analyze/resolve-word.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-word.js","sourceRoot":"","sources":["../../src/analyze/resolve-word.ts"],"names":[],"mappings":"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"}