@ac-kit/core 0.2.0 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,70 @@
 # @ac-kit/core
 
+## 0.4.0
+
+### Minor Changes
+
+- aca1cb1: `decodeText` also reads `"windows-1252"` and `"shift_jis"`, the two legacy
+  encodings named by the new `TextDecodingName`; `encodeText` cannot write them.
+  `isValidText` tells whether bytes are valid text in an encoding, to test
+  candidate encodings without keeping the decoded string.
+
+## 0.3.0
+
+### Minor Changes
+
+- a5c4d66: **Breaking:** `bigIntToBytesBe` and `bigIntFromBytesBe` move from
+  `@ac-kit/math-integer` to `@ac-kit/core`. Update the import specifier; the
+  behaviour is unchanged.
+  
+  They are a wire encoding rather than arithmetic — X.690 §8.3 for an ASN.1
+  INTEGER, and what `BigInteger.toByteArray` and `int.to_bytes` produce — and
+  their callers need no integer theory at all, while `math-integer` sits too high
+  in the dependency graph for some of them to reach it.
+  
+  New in `@ac-kit/core`: `bigIntToBytesLe` and `bigIntFromBytesLe`, the same
+  two's-complement, minimal-or-fixed-width encoding with the least significant
+  byte first.
+  
+  `@ac-kit/format-asn1` no longer depends on `@ac-kit/math-integer`.
+- a5c4d66: - **Breaking:** `InetAddress`, `InetEndpoint` and `composeInetAddress` are gone,
+    and so are `EPHEMERAL_PORT_MIN_VALUE`, `EPHEMERAL_PORT_MAX_VALUE` and
+    `getRandomEphemeralPort`. `core` holds language extensions and wrappers over
+    simple Web APIs, and `ARCHITECTURE.md` §3 names IP addressing as the example
+    of something pure that is nonetheless domain knowledge. The first three are
+    now `@ac-kit/node`'s, where `composeInetAddress` is spelled `toInetAddress`;
+    the ephemeral port range is `@ac-kit/net-address`'s, beside the rest of the
+    RFC 6335 port semantics. No compatibility re-export is left behind.
+  - New `flattenRecord(source, options)` and `unflattenRecord(source, options)`,
+    collapsing a nested record to delimiter-joined keys and back. A multi-segment
+    path can never reach `__proto__`, `constructor` or `prototype`; a
+    single-segment key is a leaf and is kept as one, because a record of
+    environment variables should still be able to hold one called `constructor`.
+    An array is a leaf value by default rather than being numbered, since an index
+    is the one segment a flattened key cannot tell apart from an ordinary key
+    spelled `"0"`. A key that itself contains the delimiter is not escaped and the
+    delimiter wins on the way back, so the round trip holds exactly for keys that
+    do not contain one.
+  - New `bytesMap(bytes, map)` and `bytesCombine(a, b, combine)`, applying a
+    function to every octet of one array or to every octet pair of two. Both mask
+    the callback's result to a single octet, so `~byte` and `left & right` read as
+    the bitwise operations they are rather than trailing an `& 0xff` that is easy
+    to forget and silent when it is. `bytesCombine` throws on mismatched lengths
+    instead of pairing up to the shorter array: a bitwise operation over two
+    different widths has no meaning, and truncating to the shorter one turns that
+    into a wrong answer rather than an error.
+  - New `nextUtf8Boundary(bytes, index)`, the first UTF-8 character boundary at or
+    after `index`. Slicing a UTF-8 buffer at an arbitrary offset — a tail, a
+    window, a chunk handed to `decodeText` — can land inside a multi-byte
+    sequence, whose orphaned tail decodes to a leading U+FFFD; aligning the offset
+    forward drops the partial character instead.
+  - Five more ASCII predicates: `isAsciiControl`, `isAsciiGraphic`,
+    `isAsciiPrintable`, `isAsciiPunctuation` and `isAsciiBlank` — C's `iscntrl`,
+    `isgraph`, `isprint`, `ispunct` and `isblank`, joining the `isalpha`/`isdigit`
+    family already here. Where `punct` stops and `graph` starts is exactly the kind
+    of boundary a hand-written range table gets subtly wrong, and every copy of it
+    gets it wrong differently.
+
 ## 0.2.0
 
 ### Minor Changes

package/README.md

@@ -35,5 +35,5 @@ Portable: no Node.js built-ins, so it runs unchanged in browsers, Deno, Bun and
 edge runtimes. The host-bound counterpart is `@ac-kit/node`.
 
 See the
-[generated API docs](https://anthochamp.github.io/node-essentials/api/core/)
+[generated API docs](https://anthochamp.pages.grenadine.io/node-essentials/api/core/)
 for the full reference.

package/dist/big-int/from-bytes-be.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Decodes two's complement, big-endian bytes back into a `bigint` — the inverse
+ * of {@link bigIntToBytesBe}.
+ *
+ * The high bit of the first byte is the sign, so any width round-trips: `0xff`
+ * and `0xff_ff` both decode to `-1`. Reach for {@link bigIntFromBytesLe} when
+ * the least significant byte comes first.
+ *
+ * Time complexity: O(n) in the byte count.
+ *
+ * @param bytes - The encoding. An empty input decodes to zero.
+ */
+export declare function bigIntFromBytesBe(bytes: Uint8Array): bigint;
+//# sourceMappingURL=from-bytes-be.d.ts.map

package/dist/big-int/from-bytes-be.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"from-bytes-be.d.ts","sourceRoot":"","sources":["../../src/big-int/from-bytes-be.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAQ3D"}

package/dist/big-int/from-bytes-be.js

@@ -0,0 +1,20 @@
+/**
+ * Decodes two's complement, big-endian bytes back into a `bigint` — the inverse
+ * of {@link bigIntToBytesBe}.
+ *
+ * The high bit of the first byte is the sign, so any width round-trips: `0xff`
+ * and `0xff_ff` both decode to `-1`. Reach for {@link bigIntFromBytesLe} when
+ * the least significant byte comes first.
+ *
+ * Time complexity: O(n) in the byte count.
+ *
+ * @param bytes - The encoding. An empty input decodes to zero.
+ */
+export function bigIntFromBytesBe(bytes) {
+    let value = 0n;
+    for (let index = 0; index < bytes.length; index++) {
+        value = (value << 8n) | BigInt(bytes[index]);
+    }
+    return BigInt.asIntN(bytes.length * 8, value);
+}
+//# sourceMappingURL=from-bytes-be.js.map

package/dist/big-int/from-bytes-be.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"from-bytes-be.js","sourceRoot":"","sources":["../../src/big-int/from-bytes-be.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAAiB;IAClD,IAAI,KAAK,GAAG,EAAE,CAAC;IAEf,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;QACnD,KAAK,GAAG,CAAC,KAAK,IAAI,EAAE,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,KAAK,CAAE,CAAC,CAAC;IAC/C,CAAC;IAED,OAAO,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC;AAC/C,CAAC"}

package/dist/big-int/from-bytes-le.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Decodes two's complement, little-endian bytes back into a `bigint` — the
+ * inverse of {@link bigIntToBytesLe}.
+ *
+ * The high bit of the _last_ byte is the sign, so any width round-trips: `0xff`
+ * and `0xff_ff` both decode to `-1`. Reach for {@link bigIntFromBytesBe} when
+ * the most significant byte comes first, which is what wire formats usually
+ * specify.
+ *
+ * Time complexity: O(n) in the byte count.
+ *
+ * @param bytes - The encoding. An empty input decodes to zero.
+ */
+export declare function bigIntFromBytesLe(bytes: Uint8Array): bigint;
+//# sourceMappingURL=from-bytes-le.d.ts.map

package/dist/big-int/from-bytes-le.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"from-bytes-le.d.ts","sourceRoot":"","sources":["../../src/big-int/from-bytes-le.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAQ3D"}

package/dist/big-int/from-bytes-le.js

@@ -0,0 +1,21 @@
+/**
+ * Decodes two's complement, little-endian bytes back into a `bigint` — the
+ * inverse of {@link bigIntToBytesLe}.
+ *
+ * The high bit of the _last_ byte is the sign, so any width round-trips: `0xff`
+ * and `0xff_ff` both decode to `-1`. Reach for {@link bigIntFromBytesBe} when
+ * the most significant byte comes first, which is what wire formats usually
+ * specify.
+ *
+ * Time complexity: O(n) in the byte count.
+ *
+ * @param bytes - The encoding. An empty input decodes to zero.
+ */
+export function bigIntFromBytesLe(bytes) {
+    let value = 0n;
+    for (let index = bytes.length - 1; index >= 0; index--) {
+        value = (value << 8n) | BigInt(bytes[index]);
+    }
+    return BigInt.asIntN(bytes.length * 8, value);
+}
+//# sourceMappingURL=from-bytes-le.js.map

package/dist/big-int/from-bytes-le.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"from-bytes-le.js","sourceRoot":"","sources":["../../src/big-int/from-bytes-le.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAAiB;IAClD,IAAI,KAAK,GAAG,EAAE,CAAC;IAEf,KAAK,IAAI,KAAK,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC;QACxD,KAAK,GAAG,CAAC,KAAK,IAAI,EAAE,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,KAAK,CAAE,CAAC,CAAC;IAC/C,CAAC;IAED,OAAO,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC;AAC/C,CAAC"}

package/dist/big-int/to-bytes-be.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Encodes a `bigint` as two's complement, big-endian bytes.
+ *
+ * What Java's `BigInteger.toByteArray` and Python's `int.to_bytes` produce.
+ * Reach for {@link bigIntToBytesLe} when the least significant byte comes
+ * first, and for `@ac-kit/math-integer`'s `limb32`/`limb64` families when the
+ * digits feed arithmetic rather than a wire: those are little-endian, unsigned,
+ * and of fixed width.
+ *
+ * Time complexity: O(n) in the byte count.
+ *
+ * @param value - The value to encode. Zero encodes as a single `0x00`.
+ * @param byteLength - Fixed output width, sign-extended to fit. Omit for the
+ *   minimal encoding.
+ * @returns A fresh buffer, never empty.
+ * @throws {RangeError} When `byteLength` is too small to hold `value`.
+ */
+export declare function bigIntToBytesBe(value: bigint, byteLength?: number): Uint8Array<ArrayBuffer>;
+//# sourceMappingURL=to-bytes-be.d.ts.map

package/dist/big-int/to-bytes-be.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-bytes-be.d.ts","sourceRoot":"","sources":["../../src/big-int/to-bytes-be.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,eAAe,CAC9B,KAAK,EAAE,MAAM,EACb,UAAU,CAAC,EAAE,MAAM,GACjB,UAAU,CAAC,WAAW,CAAC,CAqBzB"}

package/dist/big-int/to-bytes-be.js

@@ -0,0 +1,60 @@
+/**
+ * Encodes a `bigint` as two's complement, big-endian bytes.
+ *
+ * What Java's `BigInteger.toByteArray` and Python's `int.to_bytes` produce.
+ * Reach for {@link bigIntToBytesLe} when the least significant byte comes
+ * first, and for `@ac-kit/math-integer`'s `limb32`/`limb64` families when the
+ * digits feed arithmetic rather than a wire: those are little-endian, unsigned,
+ * and of fixed width.
+ *
+ * Time complexity: O(n) in the byte count.
+ *
+ * @param value - The value to encode. Zero encodes as a single `0x00`.
+ * @param byteLength - Fixed output width, sign-extended to fit. Omit for the
+ *   minimal encoding.
+ * @returns A fresh buffer, never empty.
+ * @throws {RangeError} When `byteLength` is too small to hold `value`.
+ */
+export function bigIntToBytesBe(value, byteLength) {
+    const minimal = toMinimalBytes(value);
+    if (byteLength === undefined) {
+        return minimal;
+    }
+    if (minimal.length > byteLength) {
+        throw new RangeError(`bigIntToBytesBe: ${value} needs ${minimal.length} bytes, not ${byteLength}`);
+    }
+    const out = new Uint8Array(byteLength);
+    const padding = byteLength - minimal.length;
+    // Sign extension, not zero padding: a negative value's high bytes are 0xff.
+    out.fill(value < 0n ? 0xff : 0x00, 0, padding);
+    out.set(minimal, padding);
+    return out;
+}
+function toMinimalBytes(value) {
+    if (value === 0n) {
+        return new Uint8Array([0x00]);
+    }
+    const negative = value < 0n;
+    // For a negative, encode |value| - 1 and invert: that is two's complement
+    // without ever needing to know the final width up front.
+    let remaining = negative ? -value - 1n : value;
+    const digits = [];
+    while (remaining > 0n) {
+        digits.unshift(Number(remaining & 0xffn));
+        remaining >>= 8n;
+    }
+    if (negative) {
+        for (let index = 0; index < digits.length; index++) {
+            digits[index] = ~digits[index] & 0xff;
+        }
+        // A leading byte without its high bit set would read back as positive.
+        if (digits.length === 0 || (digits[0] & 0x80) === 0) {
+            digits.unshift(0xff);
+        }
+    }
+    else if ((digits[0] & 0x80) !== 0) {
+        digits.unshift(0x00);
+    }
+    return new Uint8Array(digits);
+}
+//# sourceMappingURL=to-bytes-be.js.map

package/dist/big-int/to-bytes-be.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-bytes-be.js","sourceRoot":"","sources":["../../src/big-int/to-bytes-be.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,eAAe,CAC9B,KAAa,EACb,UAAmB;IAEnB,MAAM,OAAO,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;IAEtC,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;QAC9B,OAAO,OAAO,CAAC;IAChB,CAAC;IAED,IAAI,OAAO,CAAC,MAAM,GAAG,UAAU,EAAE,CAAC;QACjC,MAAM,IAAI,UAAU,CACnB,oBAAoB,KAAK,UAAU,OAAO,CAAC,MAAM,eAAe,UAAU,EAAE,CAC5E,CAAC;IACH,CAAC;IAED,MAAM,GAAG,GAAG,IAAI,UAAU,CAAC,UAAU,CAAC,CAAC;IACvC,MAAM,OAAO,GAAG,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC;IAE5C,4EAA4E;IAC5E,GAAG,CAAC,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC;IAC/C,GAAG,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAE1B,OAAO,GAAG,CAAC;AACZ,CAAC;AAED,SAAS,cAAc,CAAC,KAAa;IACpC,IAAI,KAAK,KAAK,EAAE,EAAE,CAAC;QAClB,OAAO,IAAI,UAAU,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;IAC/B,CAAC;IAED,MAAM,QAAQ,GAAG,KAAK,GAAG,EAAE,CAAC;IAC5B,0EAA0E;IAC1E,yDAAyD;IACzD,IAAI,SAAS,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;IAC/C,MAAM,MAAM,GAAa,EAAE,CAAC;IAE5B,OAAO,SAAS,GAAG,EAAE,EAAE,CAAC;QACvB,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC;QAC1C,SAAS,KAAK,EAAE,CAAC;IAClB,CAAC;IAED,IAAI,QAAQ,EAAE,CAAC;QACd,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;YACpD,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,CAAE,GAAG,IAAI,CAAC;QACxC,CAAC;QAED,uEAAuE;QACvE,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAE,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;YACtD,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACtB,CAAC;IACF,CAAC;SAAM,IAAI,CAAC,MAAM,CAAC,CAAC,CAAE,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QACtC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,CAAC;IAED,OAAO,IAAI,UAAU,CAAC,MAAM,CAAC,CAAC;AAC/B,CAAC"}

package/dist/big-int/to-bytes-le.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Encodes a `bigint` as two's complement, little-endian bytes.
+ *
+ * The byte order native to x86 and ARM, and what Python's `int.to_bytes(…,
+ * "little")` produces. Reach for {@link bigIntToBytesBe} when the most
+ * significant byte comes first, which is what wire formats usually specify, and
+ * for `@ac-kit/math-integer`'s `limb32`/`limb64` families when the digits feed
+ * arithmetic rather than a buffer: those are wider, unsigned, and of fixed
+ * width.
+ *
+ * Time complexity: O(n) in the byte count.
+ *
+ * @param value - The value to encode. Zero encodes as a single `0x00`. @param
+ *   byteLength - Fixed output width, sign-extended to fit. Omit for the minimal
+ *   encoding. @returns A fresh buffer, never empty. @throws {RangeError} When
+ *   `byteLength` is too small to hold `value`.
+ */
+export declare function bigIntToBytesLe(value: bigint, byteLength?: number): Uint8Array<ArrayBuffer>;
+//# sourceMappingURL=to-bytes-le.d.ts.map

package/dist/big-int/to-bytes-le.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-bytes-le.d.ts","sourceRoot":"","sources":["../../src/big-int/to-bytes-le.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,eAAe,CAC9B,KAAK,EAAE,MAAM,EACb,UAAU,CAAC,EAAE,MAAM,GACjB,UAAU,CAAC,WAAW,CAAC,CAEzB"}

package/dist/big-int/to-bytes-le.js

@@ -0,0 +1,22 @@
+import { bigIntToBytesBe } from "./to-bytes-be.js";
+/**
+ * Encodes a `bigint` as two's complement, little-endian bytes.
+ *
+ * The byte order native to x86 and ARM, and what Python's `int.to_bytes(…,
+ * "little")` produces. Reach for {@link bigIntToBytesBe} when the most
+ * significant byte comes first, which is what wire formats usually specify, and
+ * for `@ac-kit/math-integer`'s `limb32`/`limb64` families when the digits feed
+ * arithmetic rather than a buffer: those are wider, unsigned, and of fixed
+ * width.
+ *
+ * Time complexity: O(n) in the byte count.
+ *
+ * @param value - The value to encode. Zero encodes as a single `0x00`. @param
+ *   byteLength - Fixed output width, sign-extended to fit. Omit for the minimal
+ *   encoding. @returns A fresh buffer, never empty. @throws {RangeError} When
+ *   `byteLength` is too small to hold `value`.
+ */
+export function bigIntToBytesLe(value, byteLength) {
+    return bigIntToBytesBe(value, byteLength).reverse();
+}
+//# sourceMappingURL=to-bytes-le.js.map

package/dist/big-int/to-bytes-le.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-bytes-le.js","sourceRoot":"","sources":["../../src/big-int/to-bytes-le.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAEnD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,eAAe,CAC9B,KAAa,EACb,UAAmB;IAEnB,OAAO,eAAe,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC,OAAO,EAAE,CAAC;AACrD,CAAC"}

package/dist/buffer/bytes-combine.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Applies `combine` to each octet pair of two equal-length arrays.
+ *
+ * The result of `combine` is masked to one octet. Pairing stops at the shorter
+ * array only when lengths are allowed to differ, which they are not here: a
+ * bitwise operation over mismatched widths has no meaning, so it throws rather
+ * than silently truncating.
+ *
+ * Complexity: O(n) time and O(n) memory in the input length.
+ *
+ * @param a The left octets.
+ * @param b The right octets.
+ * @param combine Called with each octet pair and its index.
+ * @returns A new array of the same length.
+ * @throws RangeError When the two arrays differ in length.
+ */
+export declare function bytesCombine(a: Uint8Array, b: Uint8Array, combine: (left: number, right: number, index: number) => number): Uint8Array<ArrayBuffer>;
+//# sourceMappingURL=bytes-combine.d.ts.map

package/dist/buffer/bytes-combine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes-combine.d.ts","sourceRoot":"","sources":["../../src/buffer/bytes-combine.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAC3B,CAAC,EAAE,UAAU,EACb,CAAC,EAAE,UAAU,EACb,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,GAC7D,UAAU,CAAC,WAAW,CAAC,CASzB"}

package/dist/buffer/bytes-combine.js

@@ -0,0 +1,25 @@
+import { bytesMap } from "./bytes-map.js";
+/**
+ * Applies `combine` to each octet pair of two equal-length arrays.
+ *
+ * The result of `combine` is masked to one octet. Pairing stops at the shorter
+ * array only when lengths are allowed to differ, which they are not here: a
+ * bitwise operation over mismatched widths has no meaning, so it throws rather
+ * than silently truncating.
+ *
+ * Complexity: O(n) time and O(n) memory in the input length.
+ *
+ * @param a The left octets.
+ * @param b The right octets.
+ * @param combine Called with each octet pair and its index.
+ * @returns A new array of the same length.
+ * @throws RangeError When the two arrays differ in length.
+ */
+export function bytesCombine(a, b, combine) {
+    if (a.length !== b.length) {
+        throw new RangeError(`cannot combine ${a.length} octets with ${b.length} octets`);
+    }
+    // Non-null: `index` runs over `a`'s length, and `b` has been checked equal.
+    return bytesMap(a, (byte, index) => combine(byte, b[index], index));
+}
+//# sourceMappingURL=bytes-combine.js.map

package/dist/buffer/bytes-combine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes-combine.js","sourceRoot":"","sources":["../../src/buffer/bytes-combine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,YAAY,CAC3B,CAAa,EACb,CAAa,EACb,OAA+D;IAE/D,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM,EAAE,CAAC;QAC3B,MAAM,IAAI,UAAU,CACnB,kBAAkB,CAAC,CAAC,MAAM,gBAAgB,CAAC,CAAC,MAAM,SAAS,CAC3D,CAAC;IACH,CAAC;IAED,4EAA4E;IAC5E,OAAO,QAAQ,CAAC,CAAC,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAE,EAAE,KAAK,CAAC,CAAC,CAAC;AACtE,CAAC"}

package/dist/buffer/bytes-map.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Applies `map` to every octet of `bytes`, returning a new array.
+ *
+ * The result of `map` is masked to one octet, so a caller may write `~byte`
+ * without restating `& 0xff`.
+ *
+ * Complexity: O(n) time and O(n) memory in the input length.
+ *
+ * @param bytes The source octets.
+ * @param map Called with each octet and its index.
+ * @returns A new array of the same length.
+ */
+export declare function bytesMap(bytes: Uint8Array, map: (byte: number, index: number) => number): Uint8Array<ArrayBuffer>;
+//# sourceMappingURL=bytes-map.d.ts.map

package/dist/buffer/bytes-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes-map.d.ts","sourceRoot":"","sources":["../../src/buffer/bytes-map.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CACvB,KAAK,EAAE,UAAU,EACjB,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,GAC1C,UAAU,CAAC,WAAW,CAAC,CASzB"}

package/dist/buffer/bytes-map.js

@@ -0,0 +1,21 @@
+/**
+ * Applies `map` to every octet of `bytes`, returning a new array.
+ *
+ * The result of `map` is masked to one octet, so a caller may write `~byte`
+ * without restating `& 0xff`.
+ *
+ * Complexity: O(n) time and O(n) memory in the input length.
+ *
+ * @param bytes The source octets.
+ * @param map Called with each octet and its index.
+ * @returns A new array of the same length.
+ */
+export function bytesMap(bytes, map) {
+    const result = new Uint8Array(bytes.length);
+    for (let index = 0; index < bytes.length; index++) {
+        // Non-null: `index` runs over the source array's own length.
+        result[index] = map(bytes[index], index) & 0xff;
+    }
+    return result;
+}
+//# sourceMappingURL=bytes-map.js.map

package/dist/buffer/bytes-map.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes-map.js","sourceRoot":"","sources":["../../src/buffer/bytes-map.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,QAAQ,CACvB,KAAiB,EACjB,GAA4C;IAE5C,MAAM,MAAM,GAAG,IAAI,UAAU,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IAE5C,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;QACnD,6DAA6D;QAC7D,MAAM,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,KAAK,CAAE,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC;IAClD,CAAC;IAED,OAAO,MAAM,CAAC;AACf,CAAC"}

package/dist/buffer/text/decode-text.d.ts

@@ -1,4 +1,4 @@
-import type { TextEncodingName } from "./text-encoding-name.js";
+import type { TextDecodingName } from "./text-encoding-name.js";
 /**
  * Options mirroring `TextDecoderOptions` (see `TextDecoder`).
  *
@@ -17,6 +17,11 @@ import type { TextEncodingName } from "./text-encoding-name.js";
  * `"utf-32be"` ignores `ignoreBOM` (no byte order mark exists for a
  * 4-byte-per-code-point scheme) but honors `fatal`, since a 4-byte group can
  * still decode to a surrogate or an out-of-range value.
+ *
+ * `"windows-1252"` and `"shift_jis"` are decoded by a real `TextDecoder` too:
+ * they honor `fatal` and ignore `ignoreBOM`, which the standard defines for
+ * Unicode encodings only. Every windows-1252 byte decodes, so `fatal` never
+ * throws for it.
  */
 export type DecodeTextOptions = {
     /**
@@ -39,8 +44,12 @@ export type DecodeTextOptions = {
  * @param options - See {@link DecodeTextOptions}.
  * @returns The decoded string.
  * @throws {TypeError} When `options.fatal` is `true` and `bytes` is not valid
- *   for `encoding`. Never thrown for `"latin1"`/`"ascii"`, for which every byte
- *   is valid.
+ *   for `encoding`. Never thrown for `"latin1"`, `"ascii"` and
+ *   `"windows-1252"`, for which every byte is valid.
+ * @throws {RangeError} For `"shift_jis"` where the runtime's `TextDecoder`
+ *   lacks it.
+ * @see {@link isValidText} to test validity without decoding into a string
+ *   the caller does not need.
  */
-export declare function decodeText(bytes: Uint8Array, encoding: TextEncodingName, options?: DecodeTextOptions): string;
+export declare function decodeText(bytes: Uint8Array, encoding: TextDecodingName, options?: DecodeTextOptions): string;
 //# sourceMappingURL=decode-text.d.ts.map

package/dist/buffer/text/decode-text.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decode-text.d.ts","sourceRoot":"","sources":["../../../src/buffer/text/decode-text.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC/B;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAyBF;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CACzB,KAAK,EAAE,UAAU,EACjB,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,CAAC,EAAE,iBAAiB,GACzB,MAAM,CAwDR"}
+{"version":3,"file":"decode-text.d.ts","sourceRoot":"","sources":["../../../src/buffer/text/decode-text.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC/B;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAuBF;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,UAAU,CACzB,KAAK,EAAE,UAAU,EACjB,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,CAAC,EAAE,iBAAiB,GACzB,MAAM,CAkDR"}

package/dist/buffer/text/decode-text.js

@@ -1,14 +1,13 @@
-const utf8Decoders = new Map();
-const utf16BeDecoders = new Map();
+const decoders = new Map();
 // `TextDecoder` construction is not free; a decoder only depends on
 // (label, fatal, ignoreBOM), so one instance per combination is reused across
 // every call instead of rebuilding it per call.
-function getCachedDecoder(cache, label, fatal, ignoreBOM) {
-    const key = `${fatal}:${ignoreBOM}`;
-    let decoder = cache.get(key);
+function getCachedDecoder(label, fatal, ignoreBOM) {
+    const key = `${label}:${fatal}:${ignoreBOM}`;
+    let decoder = decoders.get(key);
     if (!decoder) {
         decoder = new TextDecoder(label, { fatal, ignoreBOM });
-        cache.set(key, decoder);
+        decoders.set(key, decoder);
     }
     return decoder;
 }
@@ -20,17 +19,21 @@ function getCachedDecoder(cache, label, fatal, ignoreBOM) {
  * @param options - See {@link DecodeTextOptions}.
  * @returns The decoded string.
  * @throws {TypeError} When `options.fatal` is `true` and `bytes` is not valid
- *   for `encoding`. Never thrown for `"latin1"`/`"ascii"`, for which every byte
- *   is valid.
+ *   for `encoding`. Never thrown for `"latin1"`, `"ascii"` and
+ *   `"windows-1252"`, for which every byte is valid.
+ * @throws {RangeError} For `"shift_jis"` where the runtime's `TextDecoder`
+ *   lacks it.
+ * @see {@link isValidText} to test validity without decoding into a string
+ *   the caller does not need.
  */
 export function decodeText(bytes, encoding, options) {
     const fatal = options?.fatal ?? false;
     const ignoreBOM = options?.ignoreBOM ?? false;
-    if (encoding === "utf-8") {
-        return getCachedDecoder(utf8Decoders, "utf-8", fatal, ignoreBOM).decode(bytes);
-    }
-    if (encoding === "utf-16be") {
-        return getCachedDecoder(utf16BeDecoders, "utf-16be", fatal, ignoreBOM).decode(bytes);
+    if (encoding === "utf-8" ||
+        encoding === "utf-16be" ||
+        encoding === "windows-1252" ||
+        encoding === "shift_jis") {
+        return getCachedDecoder(encoding, fatal, ignoreBOM).decode(bytes);
     }
     if (encoding === "utf-32be") {
         let out = "";

package/dist/buffer/text/decode-text.js.map

@@ -1 +1 @@
-{"version":3,"file":"decode-text.js","sourceRoot":"","sources":["../../../src/buffer/text/decode-text.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"decode-text.js","sourceRoot":"","sources":["../../../src/buffer/text/decode-text.ts"],"names":[],"mappings":"AAyCA,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAuB,CAAC;AAEhD,oEAAoE;AACpE,8EAA8E;AAC9E,gDAAgD;AAChD,SAAS,gBAAgB,CACxB,KAAa,EACb,KAAc,EACd,SAAkB;IAElB,MAAM,GAAG,GAAG,GAAG,KAAK,IAAI,KAAK,IAAI,SAAS,EAAE,CAAC;IAC7C,IAAI,OAAO,GAAG,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAEhC,IAAI,CAAC,OAAO,EAAE,CAAC;QACd,OAAO,GAAG,IAAI,WAAW,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC;QACvD,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;IAC5B,CAAC;IAED,OAAO,OAAO,CAAC;AAChB,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,UAAU,CACzB,KAAiB,EACjB,QAA0B,EAC1B,OAA2B;IAE3B,MAAM,KAAK,GAAG,OAAO,EAAE,KAAK,IAAI,KAAK,CAAC;IACtC,MAAM,SAAS,GAAG,OAAO,EAAE,SAAS,IAAI,KAAK,CAAC;IAE9C,IACC,QAAQ,KAAK,OAAO;QACpB,QAAQ,KAAK,UAAU;QACvB,QAAQ,KAAK,cAAc;QAC3B,QAAQ,KAAK,WAAW,EACvB,CAAC;QACF,OAAO,gBAAgB,CAAC,QAAQ,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACnE,CAAC;IAED,IAAI,QAAQ,KAAK,UAAU,EAAE,CAAC;QAC7B,IAAI,GAAG,GAAG,EAAE,CAAC;QACb,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC;YAC1D,MAAM,SAAS,GACd,CAAC,CAAC,KAAK,CAAC,KAAK,CAAE,IAAI,EAAE,CAAC;gBACrB,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,CAAE,IAAI,EAAE,CAAC;gBACzB,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,CAAE,IAAI,CAAC,CAAC;gBACxB,KAAK,CAAC,KAAK,GAAG,CAAC,CAAE,CAAC;gBACnB,CAAC,CAAC;YAEH,IACC,SAAS,GAAG,QAAQ;gBACpB,CAAC,SAAS,IAAI,MAAM,IAAI,SAAS,IAAI,MAAM,CAAC,EAC3C,CAAC;gBACF,IAAI,KAAK,EAAE,CAAC;oBACX,MAAM,IAAI,SAAS,CAClB,6CAA6C,SAAS,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,CACrE,CAAC;gBACH,CAAC;gBACD,GAAG,IAAI,QAAQ,CAAC;gBAChB,SAAS;YACV,CAAC;YAED,GAAG,IAAI,MAAM,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;QACxC,CAAC;QACD,OAAO,GAAG,CAAC;IACZ,CAAC;IAED,6EAA6E;IAC7E,wEAAwE;IACxE,0EAA0E;IAC1E,MAAM,IAAI,GAAG,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC;IAChD,IAAI,GAAG,GAAG,EAAE,CAAC;IACb,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;QACnD,GAAG,IAAI,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,KAAK,CAAE,GAAG,IAAI,CAAC,CAAC;IAClD,CAAC;IACD,OAAO,GAAG,CAAC;AACZ,CAAC"}

package/dist/buffer/text/is-valid-text.d.ts

@@ -0,0 +1,25 @@
+import type { TextDecodingName } from "./text-encoding-name.js";
+/**
+ * Whether `bytes` is valid text in `encoding`: whether decoding it would
+ * succeed without a single replacement character.
+ *
+ * Use it to test candidate encodings when guessing which one a byte string
+ * uses; use {@link decodeText} with `fatal` when the text itself is wanted.
+ * Always `true` for `"latin1"`, `"ascii"` and `"windows-1252"`, where every
+ * byte decodes.
+ *
+ * Time complexity: O(n) in `bytes.length`. Memory: O(n) for the decoded string,
+ * discarded.
+ *
+ * @example
+ * 	isValidText(new Uint8Array([0xc3, 0xa9]), "utf-8"); // true
+ * 	isValidText(new Uint8Array([0xe9]), "utf-8"); // false
+ *
+ * @param bytes - The bytes to test.
+ * @param encoding - The candidate encoding.
+ * @returns Whether every byte decodes.
+ * @throws {RangeError} For `"shift_jis"` where the runtime's `TextDecoder`
+ *   lacks it.
+ */
+export declare function isValidText(bytes: Uint8Array, encoding: TextDecodingName): boolean;
+//# sourceMappingURL=is-valid-text.d.ts.map

package/dist/buffer/text/is-valid-text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-valid-text.d.ts","sourceRoot":"","sources":["../../../src/buffer/text/is-valid-text.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,WAAW,CAC1B,KAAK,EAAE,UAAU,EACjB,QAAQ,EAAE,gBAAgB,GACxB,OAAO,CAWT"}

package/dist/buffer/text/is-valid-text.js

@@ -0,0 +1,36 @@
+import { decodeText } from "./decode-text.js";
+/**
+ * Whether `bytes` is valid text in `encoding`: whether decoding it would
+ * succeed without a single replacement character.
+ *
+ * Use it to test candidate encodings when guessing which one a byte string
+ * uses; use {@link decodeText} with `fatal` when the text itself is wanted.
+ * Always `true` for `"latin1"`, `"ascii"` and `"windows-1252"`, where every
+ * byte decodes.
+ *
+ * Time complexity: O(n) in `bytes.length`. Memory: O(n) for the decoded string,
+ * discarded.
+ *
+ * @example
+ * 	isValidText(new Uint8Array([0xc3, 0xa9]), "utf-8"); // true
+ * 	isValidText(new Uint8Array([0xe9]), "utf-8"); // false
+ *
+ * @param bytes - The bytes to test.
+ * @param encoding - The candidate encoding.
+ * @returns Whether every byte decodes.
+ * @throws {RangeError} For `"shift_jis"` where the runtime's `TextDecoder`
+ *   lacks it.
+ */
+export function isValidText(bytes, encoding) {
+    try {
+        decodeText(bytes, encoding, { fatal: true });
+        return true;
+    }
+    catch (error) {
+        if (error instanceof TypeError) {
+            return false;
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=is-valid-text.js.map

package/dist/buffer/text/is-valid-text.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-valid-text.js","sourceRoot":"","sources":["../../../src/buffer/text/is-valid-text.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAG9C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,WAAW,CAC1B,KAAiB,EACjB,QAA0B;IAE1B,IAAI,CAAC;QACJ,UAAU,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;QAE7C,OAAO,IAAI,CAAC;IACb,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QAChB,IAAI,KAAK,YAAY,SAAS,EAAE,CAAC;YAChC,OAAO,KAAK,CAAC;QACd,CAAC;QACD,MAAM,KAAK,CAAC;IACb,CAAC;AACF,CAAC"}

package/dist/buffer/text/next-utf8-boundary.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Index of the first UTF-8 character boundary at or after `index`.
+ *
+ * Slicing a UTF-8 buffer at an arbitrary offset can land inside a multi-byte
+ * sequence, whose orphaned tail decodes to a leading U+FFFD. Moving the offset
+ * forward to a boundary drops the partial character instead.
+ *
+ * Runs in O(1) on valid input — a sequence is at most four bytes long, so at
+ * most three continuation bytes are skipped — and in O(n) on the length of a
+ * malformed continuation run. Allocates nothing.
+ *
+ * @param bytes - UTF-8 encoded bytes.
+ * @param index - Offset to align. Negative values align to `0`.
+ * @returns The aligned offset, within `[0, bytes.length]`.
+ */
+export declare function nextUtf8Boundary(bytes: Uint8Array, index: number): number;
+//# sourceMappingURL=next-utf8-boundary.d.ts.map

package/dist/buffer/text/next-utf8-boundary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"next-utf8-boundary.d.ts","sourceRoot":"","sources":["../../../src/buffer/text/next-utf8-boundary.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAWzE"}