@vibe-agent-toolkit/utils 0.2.0-rc.2 → 0.2.0-rc.4

package/dist/testing.d.ts

@@ -1,8 +1,78 @@
 /**
- * @vibe-agent-toolkit/utils/testing
+ * Fixture primitives shared by suites in more than one package.
  *
- * Isolated temp-directory helpers for test suites. Node-only. Intended for
- * a consumer's test code — not for their shipped runtime.
+ * Deliberately framework-free: nothing here imports `vitest`, so this module
+ * stays a plain function library rather than something that registers hooks as a
+ * side effect of being imported. Each suite owns its own `beforeEach`/
+ * `afterEach` and calls these from inside them — two lines, which is below
+ * anything worth sharing, while the part that is genuinely identical (mkdtemp,
+ * write the literal, remove the tree) lives here once.
+ *
+ * It earned a home in `utils` the ordinary way: two packages needed it, not one
+ * package speculating that a second might.
+ *
+ * ⛔ **Do not import `vitest` here to share the hook wrapper itself.**
+ * `subpath-purity.test.ts` pins this entry at an EMPTY third-party set, and that
+ * pin is load-bearing: `./testing` is a published subpath, so a test framework
+ * reached from it becomes a runtime requirement for every adopter who imports
+ * it. {@link replantableCorpus} exists precisely so the per-test wrapper each
+ * suite still writes is three lines rather than twelve.
  */
 export * from './test-helpers.js';
+/** A planted fixture tree and the means to remove it. */
+export interface TempCorpus {
+    /** Absolute path to the tree's root. */
+    root: string;
+    /** Remove the tree. Safe to call when it is already gone. */
+    cleanup: () => void;
+}
+/**
+ * Write a literal corpus into a fresh temp directory.
+ *
+ * 🪤 Fixture files must NOT be byte-identical to each other when the suite is
+ * about content-addressed behaviour: VAT's blobs are keyed on their bytes plus
+ * the parser kind, so two files with the same content collapse into ONE blob and
+ * assertions then describe whichever path sorted first. Give each fixture a
+ * distinguishing marker line.
+ *
+ * ⚠️ The root is minted per call, so a suite that plants per test must call this
+ * per test — a root captured once and reused across tests survives its own
+ * `cleanup`.
+ *
+ * @param prefix - `mkdtemp` prefix, so a leaked directory names its own suite
+ * @param corpus - Fixture name to file content; written verbatim as UTF-8.
+ *   Names may include forward-slash subpaths only if their parents already exist
+ * @returns The tree's root and its teardown
+ */
+export declare function createTempCorpus(prefix: string, corpus: Readonly<Record<string, string>>): TempCorpus;
+/** A corpus that can be planted and cleared repeatedly — one tree per test. */
+export interface ReplantableCorpus {
+    /** Plant a fresh tree. Drive from the suite's `beforeEach`. */
+    plant: () => void;
+    /** Remove the current tree, if any. Drive from the suite's `afterEach`. */
+    clear: () => void;
+    /** The root minted by the most recent {@link plant}. */
+    root: () => string;
+}
+/**
+ * Hold a per-test corpus root, so a suite's hook wrapper is three lines.
+ *
+ * ⚠️ **The root comes back through a GETTER, never as a value.** A per-test
+ * fixture is reminted for every test, so a root captured at registration time is
+ * `undefined` in the first test and stale in every one after it. That mistake is
+ * the reason this holder exists rather than each suite keeping its own `let`.
+ *
+ * ⭐ Framework-free on purpose: it takes no hooks and registers none, so the
+ * suite still owns its own `beforeEach`/`afterEach` and this module keeps the
+ * empty third-party set its purity pin asserts. See the module docstring.
+ *
+ * 🪤 `root()` before the first `plant()` THROWS by name. The shape it replaced
+ * read an uninitialised `let` and raised `Cannot read properties of undefined`
+ * from inside the fixture, which names neither the suite nor the missing hook.
+ *
+ * @param prefix - `mkdtemp` prefix, so a leaked directory names its own suite
+ * @param corpus - Fixture name to file content, as {@link createTempCorpus} takes it
+ * @returns Plant/clear/root, to be driven from the caller's own hooks
+ */
+export declare function replantableCorpus(prefix: string, corpus: Readonly<Record<string, string>>): ReplantableCorpus;
 //# sourceMappingURL=testing.d.ts.map

package/dist/testing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAUH,cAAc,mBAAmB,CAAC;AAElC,yDAAyD;AACzD,MAAM,WAAW,UAAU;IACzB,wCAAwC;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,6DAA6D;IAC7D,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GACvC,UAAU,CAOZ;AAED,+EAA+E;AAC/E,MAAM,WAAW,iBAAiB;IAChC,+DAA+D;IAC/D,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,2EAA2E;IAC3E,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,wDAAwD;IACxD,IAAI,EAAE,MAAM,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GACvC,iBAAiB,CAyBnB"}

package/dist/testing.js

@@ -1,8 +1,98 @@
 /**
- * @vibe-agent-toolkit/utils/testing
+ * Fixture primitives shared by suites in more than one package.
  *
- * Isolated temp-directory helpers for test suites. Node-only. Intended for
- * a consumer's test code — not for their shipped runtime.
+ * Deliberately framework-free: nothing here imports `vitest`, so this module
+ * stays a plain function library rather than something that registers hooks as a
+ * side effect of being imported. Each suite owns its own `beforeEach`/
+ * `afterEach` and calls these from inside them — two lines, which is below
+ * anything worth sharing, while the part that is genuinely identical (mkdtemp,
+ * write the literal, remove the tree) lives here once.
+ *
+ * It earned a home in `utils` the ordinary way: two packages needed it, not one
+ * package speculating that a second might.
+ *
+ * ⛔ **Do not import `vitest` here to share the hook wrapper itself.**
+ * `subpath-purity.test.ts` pins this entry at an EMPTY third-party set, and that
+ * pin is load-bearing: `./testing` is a published subpath, so a test framework
+ * reached from it becomes a runtime requirement for every adopter who imports
+ * it. {@link replantableCorpus} exists precisely so the per-test wrapper each
+ * suite still writes is three lines rather than twelve.
  */
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { normalizedTmpdir, safePath } from './path-utils.js';
+// The rest of the testing surface. ⚠️ This re-export is the ENTIRETY of what
+// `./testing` used to be, and dropping it silently removed `detachGitEnv`,
+// `setupSyncTempDirSuite` and every sibling from a published subpath. A module
+// that is both a definition site and a barrel loses the barrel first.
 export * from './test-helpers.js';
+/**
+ * Write a literal corpus into a fresh temp directory.
+ *
+ * 🪤 Fixture files must NOT be byte-identical to each other when the suite is
+ * about content-addressed behaviour: VAT's blobs are keyed on their bytes plus
+ * the parser kind, so two files with the same content collapse into ONE blob and
+ * assertions then describe whichever path sorted first. Give each fixture a
+ * distinguishing marker line.
+ *
+ * ⚠️ The root is minted per call, so a suite that plants per test must call this
+ * per test — a root captured once and reused across tests survives its own
+ * `cleanup`.
+ *
+ * @param prefix - `mkdtemp` prefix, so a leaked directory names its own suite
+ * @param corpus - Fixture name to file content; written verbatim as UTF-8.
+ *   Names may include forward-slash subpaths only if their parents already exist
+ * @returns The tree's root and its teardown
+ */
+export function createTempCorpus(prefix, corpus) {
+    const root = mkdtempSync(safePath.join(normalizedTmpdir(), prefix));
+    for (const [name, content] of Object.entries(corpus)) {
+        // eslint-disable-next-line security/detect-non-literal-fs-filename -- a fixture name from the caller's own literal corpus, under this call's fresh mkdtemp root
+        writeFileSync(safePath.join(root, name), content, 'utf8');
+    }
+    return { root, cleanup: () => rmSync(root, { recursive: true, force: true }) };
+}
+/**
+ * Hold a per-test corpus root, so a suite's hook wrapper is three lines.
+ *
+ * ⚠️ **The root comes back through a GETTER, never as a value.** A per-test
+ * fixture is reminted for every test, so a root captured at registration time is
+ * `undefined` in the first test and stale in every one after it. That mistake is
+ * the reason this holder exists rather than each suite keeping its own `let`.
+ *
+ * ⭐ Framework-free on purpose: it takes no hooks and registers none, so the
+ * suite still owns its own `beforeEach`/`afterEach` and this module keeps the
+ * empty third-party set its purity pin asserts. See the module docstring.
+ *
+ * 🪤 `root()` before the first `plant()` THROWS by name. The shape it replaced
+ * read an uninitialised `let` and raised `Cannot read properties of undefined`
+ * from inside the fixture, which names neither the suite nor the missing hook.
+ *
+ * @param prefix - `mkdtemp` prefix, so a leaked directory names its own suite
+ * @param corpus - Fixture name to file content, as {@link createTempCorpus} takes it
+ * @returns Plant/clear/root, to be driven from the caller's own hooks
+ */
+export function replantableCorpus(prefix, corpus) {
+    let planted;
+    return {
+        plant: () => {
+            // 🪤 Removes any tree still standing FIRST. Nested `describe` blocks each
+            // get their own `beforeEach` and vitest runs outer-then-inner before a
+            // single `afterEach`, so a double plant is ordinary rather than exotic.
+            // Overwriting the handle without this would leak the first tree for the
+            // process's lifetime, silently and only on the suites that nest.
+            planted?.cleanup();
+            planted = createTempCorpus(prefix, corpus);
+        },
+        clear: () => {
+            planted?.cleanup();
+            planted = undefined;
+        },
+        root: () => {
+            if (planted === undefined) {
+                throw new Error(`replantableCorpus('${prefix}'): root() before plant() — the suite is missing its beforeEach`);
+            }
+            return planted.root;
+        },
+    };
+}
 //# sourceMappingURL=testing.js.map

package/dist/testing.js.map

@@ -1 +1 @@
-{"version":3,"file":"testing.js","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"testing.js","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7D,OAAO,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAE7D,6EAA6E;AAC7E,2EAA2E;AAC3E,+EAA+E;AAC/E,sEAAsE;AACtE,cAAc,mBAAmB,CAAC;AAUlC;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,gBAAgB,CAC9B,MAAc,EACd,MAAwC;IAExC,MAAM,IAAI,GAAG,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC,gBAAgB,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC;IACpE,KAAK,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;QACrD,gKAAgK;QAChK,aAAa,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;IAC5D,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC;AACjF,CAAC;AAYD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,iBAAiB,CAC/B,MAAc,EACd,MAAwC;IAExC,IAAI,OAA+B,CAAC;IACpC,OAAO;QACL,KAAK,EAAE,GAAG,EAAE;YACV,0EAA0E;YAC1E,uEAAuE;YACvE,wEAAwE;YACxE,wEAAwE;YACxE,iEAAiE;YACjE,OAAO,EAAE,OAAO,EAAE,CAAC;YACnB,OAAO,GAAG,gBAAgB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAC7C,CAAC;QACD,KAAK,EAAE,GAAG,EAAE;YACV,OAAO,EAAE,OAAO,EAAE,CAAC;YACnB,OAAO,GAAG,SAAS,CAAC;QACtB,CAAC;QACD,IAAI,EAAE,GAAG,EAAE;YACT,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;gBAC1B,MAAM,IAAI,KAAK,CACb,sBAAsB,MAAM,iEAAiE,CAC9F,CAAC;YACJ,CAAC;YACD,OAAO,OAAO,CAAC,IAAI,CAAC;QACtB,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/text-content.d.ts

@@ -0,0 +1,197 @@
+/**
+ * **The one way VAT turns file bytes into text.**
+ *
+ * `local/no-raw-text-decode` enforces that — but only where it is registered,
+ * which today is `packages/utils/src` and `packages/resources/src`. Those two
+ * own the seam and every corpus-document read; the rest of the repo is a
+ * migration ledger, not a covered claim, and `eslint.config.js` carries it in
+ * cost order. Do not read this docstring as "nothing else in the repo decodes".
+ *
+ * ## Where this lives, and why it is a `utils` primitive
+ *
+ * Bytes-to-text is a pure function of its argument. It knows nothing about
+ * content keys, parse caches or the projection — `readContentWithKey` in
+ * `@vibe-agent-toolkit/resources` *composes* this with a raw-bytes content key,
+ * and the key is the projection concept, not the decode.
+ *
+ * It has to live here for a harder reason than tidiness. `resources` depends on
+ * `utils` and `utils` must never depend on `resources`, so a seam in `resources`
+ * with a lint rule shipped from `utils` would flag `utils`' own reads
+ * (`gitignore-checker.ts` reads an adopter's `.gitignore`; `project-utils.ts`
+ * reads an adopter's `package.json`) while giving them no legal way to comply.
+ * The rule would then be widened with exemptions until it meant nothing. Placing
+ * the primitive at the bottom of the arrow is what makes the guardrail
+ * enforceable.
+ *
+ * `./text` is also deliberately **pure** — no `node:*` import at all — so bytes
+ * from a git blob, an HTTP body or a zip entry decode through the same function
+ * as bytes from disk. The file-reading half is in `./fs` (`readTextContent`),
+ * where everything that touches `node:fs` lives.
+ *
+ * ## The defect this exists for
+ *
+ * `readContentWithKey` (in `@vibe-agent-toolkit/resources`) used to call
+ * `bytes.toString('utf-8')` unconditionally. Measured end to end, on a real
+ * `working-tree-encoding=UTF-16` checkout (see `resources`'
+ * `test/system/git-hostile-config.system.test.ts`):
+ *
+ * ```text
+ * bytes on disk   40 B, BOM fe ff, UTF-16BE
+ * decoded         "��# \0D\0o\0c\0…"   NUL-interleaved mojibake
+ * looksBinary     true  — the decoded string carries NULs
+ * projection      BLOB_NOT_TEXT, no blob row, 0 sections, 0 references
+ * the same doc    1 heading, 1 link, from its UTF-8 bytes
+ * ```
+ *
+ * So VAT could not read a UTF-16 document *at all*, and the reason it matters is
+ * not exotic: **PowerShell 5.1's `Out-File` and `>` write UTF-16LE by default**,
+ * so a Windows-authored document lands squarely in that hole.
+ *
+ * ## What is a fact here, and what is an assumption
+ *
+ * The distinction is carried in the result ({@link TextProvenance.encodingSource})
+ * rather than left to prose, because the two are not the same kind of claim:
+ *
+ * | input | encoding | encodingSource | why |
+ * |---|---|---|---|
+ * | leading `ef bb bf` | `utf-8` | `bom` | the bytes say so |
+ * | leading `ff fe` (not `ff fe 00 00`) | `utf-16le` | `bom` | the bytes say so |
+ * | leading `fe ff` | `utf-16be` | `bom` | the bytes say so |
+ * | leading `ff fe 00 00` | `utf-32le` | `bom` | the bytes say so |
+ * | leading `00 00 fe ff` | `utf-32be` | `bom` | the bytes say so |
+ * | anything else | `utf-8` | `assumed` | the defensible default |
+ *
+ * ## And what proves the assumption WRONG
+ *
+ * `encoding` says what was guessed; {@link TextProvenance.replacementCharacters}
+ * is what the guess cost. A malformed sequence decodes to U+FFFD instead of
+ * throwing, so a mis-decoded document arrives as a well-formed JS string full of
+ * garbage — and a byte-level BPE tokenizer has no out-of-vocabulary concept, so
+ * it embeds and indexes that garbage without erroring anywhere. Counting the
+ * substitutions is what turns "we assumed UTF-8" into "we assumed UTF-8 and were
+ * demonstrably wrong 3,200 times in this file".
+ *
+ * It is counted **without paying for it on the clean path**. Every decode runs
+ * first through a `fatal: true` decoder, which throws on the first malformed
+ * sequence rather than substituting; a file that decodes cleanly — nearly every
+ * file — costs exactly one decode and no scan at all. Only a file that actually
+ * threw is decoded a second time in substituting mode and scanned for U+FFFD, so
+ * the O(n) scan is charged entirely to broken input.
+ *
+ * That ordering also buys a correctness property a scan alone cannot have: a
+ * document that *legitimately contains* U+FFFD is valid input, so the fatal
+ * decoder does not throw and it is reported as **0** replacements rather than
+ * accused of a bad decode. A bare scan would count its own content against it.
+ *
+ * 🪤 **The UTF-32LE BOM starts with the UTF-16LE BOM.** `ff fe 00 00` matches
+ * `ff fe`, so a table tested shortest-first decodes every UTF-32LE document as
+ * NUL-interleaved UTF-16 — the same bug this module exists to fix, one encoding
+ * further down. {@link BOMS} is therefore ordered longest-first and the test
+ * suite pins that ordering directly.
+ *
+ * ## The two limitations, recorded rather than guessed around
+ *
+ * - **BOM-less UTF-16 is not detected.** It is undecidable from bytes alone: the
+ *   same byte string is a legal, different UTF-8 document. A NUL-density
+ *   heuristic would decide it *usually* correctly and silently wrongly the rest
+ *   of the time, and "silently wrongly" is the failure class this whole module
+ *   is a reaction to. BOM-less input is UTF-8.
+ * - **Latin charsets are not detected either, and there is no windows-1252
+ *   fallback.** "These bytes are not valid UTF-8" is a fact; "therefore they are
+ *   latin-1" is a guess, and it is equally consistent with a UTF-8 document
+ *   carrying one corrupt byte. Malformed input gets U+FFFD. In practice the
+ *   Latin family costs little: every ASCII byte string is valid UTF-8 and
+ *   decodes correctly, so only high bytes are affected.
+ *
+ * Both are pinned as tests that state what is given up, so adding a heuristic
+ * later has to edit an assertion rather than quietly widen a claim.
+ *
+ * ## Why `TextDecoder` for three encodings and hand-rolled code for two
+ *
+ * `TextDecoder` implements the WHATWG Encoding Standard, which **deliberately
+ * omits UTF-32** — no engine offers it. Node's `Buffer` is narrower still:
+ * `utf8`, `utf16le`/`ucs2`, `latin1`, `ascii` and the binary-to-text codecs, with
+ * **no UTF-16BE at all** (the encoding a round trip through git's
+ * `working-tree-encoding=UTF-16` actually produces). So `TextDecoder` carries
+ * utf-8/utf-16le/utf-16be, and UTF-32 is converted here.
+ *
+ * Refusing UTF-32 loudly was the alternative, and it was rejected for one
+ * reason: the BOM has to be *recognised* regardless (see the trap above), so the
+ * choice was never "detect it or not" — only "having detected it, decode it or
+ * throw". Decoding is ~20 lines and leaves no hole.
+ *
+ * ## The BOM is stripped, and that is load-bearing in both directions
+ *
+ * A surviving leading U+FEFF stops `# Heading` from parsing as a heading. And
+ * every offset downstream is a **character** offset over this decoded string —
+ * `lineStartOffsets` in `resources`' `projection/blob-sections.ts` derives them
+ * from `content.split('\n')`, and `parseMarkdownContent` takes remark's own
+ * character positions — so stripping shifts all of them consistently. What must
+ * NOT shift is the content key, which is computed over the raw bytes; see
+ * `resources`' `content-key.ts`.
+ */
+/** An encoding this module can decode. */
+export type TextEncoding = 'utf-8' | 'utf-16le' | 'utf-16be' | 'utf-32le' | 'utf-32be';
+/**
+ * How the encoding was arrived at.
+ *
+ * `'bom'` is a fact about the bytes. `'assumed'` is a default, and the honest
+ * name for it: BOM-less UTF-16 and BOM-less latin-1 both land here and both
+ * decode as UTF-8.
+ */
+export type EncodingSource = 'bom' | 'assumed';
+/**
+ * Everything the decode knew, guessed, and lost — the text itself excluded.
+ *
+ * Split out from {@link DecodedText} so a consumer that must carry the decode's
+ * provenance alongside *other* facts about the same bytes — `KeyedContent` in
+ * `@vibe-agent-toolkit/resources` carries it beside a content key and a byte
+ * length — can hold exactly these three fields without also re-holding the
+ * content, and without restating them one by one at every layer they cross.
+ */
+export interface TextProvenance {
+    /** The encoding used. */
+    readonly encoding: TextEncoding;
+    /** Whether {@link encoding} was read off a BOM or assumed. */
+    readonly encodingSource: EncodingSource;
+    /**
+     * How many U+FFFD REPLACEMENT CHARACTERs the decode produced.
+     *
+     * Zero for a document that decodes cleanly, **including one whose own content
+     * legitimately contains U+FFFD** — see the module docstring for why the
+     * fatal-first ordering is what makes those two cases distinguishable. A
+     * non-zero value is proof, not suspicion: these bytes are not valid in the
+     * encoding they were read as.
+     */
+    readonly replacementCharacters: number;
+}
+/** Text decoded from bytes, and what it was decoded as. */
+export interface DecodedText extends TextProvenance {
+    /** The decoded content, BOM removed, exactly as a parser should receive it. */
+    readonly text: string;
+}
+/**
+ * **The canonical content-decoding seam.** Turn file bytes into the text a
+ * parser should see.
+ *
+ * Takes bytes rather than a path so that a caller which must also key, hash or
+ * measure the raw bytes reads the file exactly once — `readContentWithKey` in
+ * `@vibe-agent-toolkit/resources` is that caller, and its key must stay over the
+ * raw byte preimage whatever this function decides the characters are. For the
+ * ordinary "read a file, give me its text" case use `readTextContent` from
+ * `@vibe-agent-toolkit/utils/fs`.
+ *
+ * @param bytes - The exact bytes read from disk
+ * @returns The decoded text, the encoding used, whether that was a fact, and how
+ *   many characters the decode had to replace
+ *
+ * @example
+ * ```typescript
+ * const bytes = await readFile(path);
+ * const { text, encoding, encodingSource, replacementCharacters } = decodeTextContent(bytes);
+ * // UTF-16BE file: encoding 'utf-16be', encodingSource 'bom', 0 replacements,
+ * // text with no BOM and no NULs
+ * ```
+ */
+export declare function decodeTextContent(bytes: Uint8Array): DecodedText;
+//# sourceMappingURL=text-content.d.ts.map

package/dist/text-content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-content.d.ts","sourceRoot":"","sources":["../src/text-content.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmIG;AAEH,0CAA0C;AAC1C,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,UAAU,GAAG,UAAU,GAAG,UAAU,GAAG,UAAU,CAAC;AAEvF;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,SAAS,CAAC;AAE/C;;;;;;;;GAQG;AACH,MAAM,WAAW,cAAc;IAC7B,yBAAyB;IACzB,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;IAChC,8DAA8D;IAC9D,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAC;IACxC;;;;;;;;OAQG;IACH,QAAQ,CAAC,qBAAqB,EAAE,MAAM,CAAC;CACxC;AAED,2DAA2D;AAC3D,MAAM,WAAW,WAAY,SAAQ,cAAc;IACjD,+EAA+E;IAC/E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAkLD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,CA4BhE"}