@atproto/lex-data 0.0.8 → 0.0.9

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @atproto/lex-data
 
+## 0.0.9
+
+### Patch Changes
+
+- [#4562](https://github.com/bluesky-social/atproto/pull/4562) [`7310b97`](https://github.com/bluesky-social/atproto/commit/7310b9704de678a3b389a741784d58bb7f79b10b) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Add `ifUint8Array` utility function
+
+- [#4571](https://github.com/bluesky-social/atproto/pull/4571) [`99963d0`](https://github.com/bluesky-social/atproto/commit/99963d002a9e030e79aed5fba700e0a68f31e101) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Rename `isLanguageString` to `validateLanguage`
+
+- [#4571](https://github.com/bluesky-social/atproto/pull/4571) [`99963d0`](https://github.com/bluesky-social/atproto/commit/99963d002a9e030e79aed5fba700e0a68f31e101) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Improve code coverage of tests
+
 ## 0.0.8
 
 ### Patch Changes

package/LICENSE.txt

@@ -1,6 +1,6 @@
 Dual MIT/Apache-2.0 License
 
-Copyright (c) 2022-2025 Bluesky Social PBC, and Contributors
+Copyright (c) 2022-2026 Bluesky Social PBC, and Contributors
 
 Except as otherwise noted in individual files, this software is licensed under the MIT license (<http://opensource.org/licenses/MIT>), or the Apache License, Version 2.0 (<http://www.apache.org/licenses/LICENSE-2.0>).
 

package/dist/index.d.ts

@@ -1,6 +1,5 @@
 export * from './blob.js';
 export * from './cid.js';
-export * from './language.js';
 export * from './lex-equals.js';
 export * from './lex-error.js';
 export * from './lex.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAA;AACzB,cAAc,UAAU,CAAA;AACxB,cAAc,eAAe,CAAA;AAC7B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,UAAU,CAAA;AACxB,cAAc,aAAa,CAAA;AAC3B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,WAAW,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAA;AACzB,cAAc,UAAU,CAAA;AACxB,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,UAAU,CAAA;AACxB,cAAc,aAAa,CAAA;AAC3B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,WAAW,CAAA"}

package/dist/index.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./blob.js"), exports);
 tslib_1.__exportStar(require("./cid.js"), exports);
-tslib_1.__exportStar(require("./language.js"), exports);
 tslib_1.__exportStar(require("./lex-equals.js"), exports);
 tslib_1.__exportStar(require("./lex-error.js"), exports);
 tslib_1.__exportStar(require("./lex.js"), exports);

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,oDAAyB;AACzB,mDAAwB;AACxB,wDAA6B;AAC7B,0DAA+B;AAC/B,yDAA8B;AAC9B,mDAAwB;AACxB,sDAA2B;AAC3B,0DAA+B;AAC/B,oDAAyB","sourcesContent":["export * from './blob.js'\nexport * from './cid.js'\nexport * from './language.js'\nexport * from './lex-equals.js'\nexport * from './lex-error.js'\nexport * from './lex.js'\nexport * from './object.js'\nexport * from './uint8array.js'\nexport * from './utf8.js'\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,oDAAyB;AACzB,mDAAwB;AACxB,0DAA+B;AAC/B,yDAA8B;AAC9B,mDAAwB;AACxB,sDAA2B;AAC3B,0DAA+B;AAC/B,oDAAyB","sourcesContent":["export * from './blob.js'\nexport * from './cid.js'\nexport * from './lex-equals.js'\nexport * from './lex-error.js'\nexport * from './lex.js'\nexport * from './object.js'\nexport * from './uint8array.js'\nexport * from './utf8.js'\n"]}

package/dist/uint8array.d.ts

@@ -14,6 +14,7 @@ export declare const toBase64: (bytes: Uint8Array, alphabet?: Base64Alphabet) =>
  * @throws If the input is not a valid base64 string
  */
 export declare const fromBase64: (b64: string, alphabet?: Base64Alphabet) => Uint8Array;
+export declare function ifUint8Array(input: unknown): Uint8Array | undefined;
 /**
  * Coerces various binary data representations into a Uint8Array.
  *

package/dist/uint8array.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"uint8array.d.ts","sourceRoot":"","sources":["../src/uint8array.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAavD,YAAY,EAAE,cAAc,EAAE,CAAA;AAO9B;;;;GAIG;AACH,eAAO,MAAM,QAAQ,EAAE,CACrB,KAAK,EAAE,UAAU,EACjB,QAAQ,CAAC,EAAE,cAAc,KACtB,MAG+C,CAAA;AAEpD;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,EAAE,CACvB,GAAG,EAAE,MAAM,EACX,QAAQ,CAAC,EAAE,cAAc,KACtB,UAGiD,CAAA;AAUtD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,CAkBnE;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,OAAO,CAY/D;AAED,eAAO,MAAM,SAAS,8CAE+B,CAAA"}
+{"version":3,"file":"uint8array.d.ts","sourceRoot":"","sources":["../src/uint8array.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAavD,YAAY,EAAE,cAAc,EAAE,CAAA;AAO9B;;;;GAIG;AACH,eAAO,MAAM,QAAQ,EAAE,CACrB,KAAK,EAAE,UAAU,EACjB,QAAQ,CAAC,EAAE,cAAc,KACtB,MAGa,CAAA;AAElB;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,EAAE,CACvB,GAAG,EAAE,MAAM,EACX,QAAQ,CAAC,EAAE,cAAc,KACtB,UAGe,CAAA;AAUpB,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,CAMnE;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,CAkBnE;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,OAAO,CAY/D;AAED,eAAO,MAAM,SAAS,8CACgD,CAAA"}

package/dist/uint8array.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ui8Concat = exports.fromBase64 = exports.toBase64 = void 0;
+exports.ifUint8Array = ifUint8Array;
 exports.asUint8Array = asUint8Array;
 exports.ui8Equals = ui8Equals;
 const uint8array_concat_js_1 = require("./uint8array-concat.js");
@@ -17,8 +18,8 @@ const uint8array_to_base64_js_1 = require("./uint8array-to-base64.js");
  */
 exports.toBase64 = 
 /* v8 ignore next -- @preserve */ uint8array_to_base64_js_1.toBase64Native ??
-    /* v8 ignore next -- @preserve */ uint8array_to_base64_js_1.toBase64Node ??
-    /* v8 ignore next -- @preserve */ uint8array_to_base64_js_1.toBase64Ponyfill;
+    uint8array_to_base64_js_1.toBase64Node ??
+    uint8array_to_base64_js_1.toBase64Ponyfill;
 /**
  * Decodes a base64 string into a Uint8Array. This function supports both padded
  * and unpadded base64 strings.
@@ -28,13 +29,19 @@ exports.toBase64 =
  */
 exports.fromBase64 = 
 /* v8 ignore next -- @preserve */ uint8array_from_base64_js_1.fromBase64Native ??
-    /* v8 ignore next -- @preserve */ uint8array_from_base64_js_1.fromBase64Node ??
-    /* v8 ignore next -- @preserve */ uint8array_from_base64_js_1.fromBase64Ponyfill;
+    uint8array_from_base64_js_1.fromBase64Node ??
+    uint8array_from_base64_js_1.fromBase64Ponyfill;
 /* v8 ignore next -- @preserve */
 if (exports.toBase64 === uint8array_to_base64_js_1.toBase64Ponyfill || exports.fromBase64 === uint8array_from_base64_js_1.fromBase64Ponyfill) {
     /*#__PURE__*/
     console.warn('[@atproto/lex-data]: Uint8Array.fromBase64 / Uint8Array.prototype.toBase64 not available in this environment. Falling back to ponyfill implementation.');
 }
+function ifUint8Array(input) {
+    if (input instanceof Uint8Array) {
+        return input;
+    }
+    return undefined;
+}
 /**
  * Coerces various binary data representations into a Uint8Array.
  *
@@ -64,6 +71,5 @@ function ui8Equals(a, b) {
     return true;
 }
 exports.ui8Concat = 
-/* v8 ignore next -- @preserve */ uint8array_concat_js_1.ui8ConcatNode ??
-    /* v8 ignore next -- @preserve */ uint8array_concat_js_1.ui8ConcatPonyfill;
+/* v8 ignore next -- @preserve */ uint8array_concat_js_1.ui8ConcatNode ?? uint8array_concat_js_1.ui8ConcatPonyfill;
 //# sourceMappingURL=uint8array.js.map

package/dist/uint8array.js.map

@@ -1 +1 @@
-{"version":3,"file":"uint8array.js","sourceRoot":"","sources":["../src/uint8array.ts"],"names":[],"mappings":";;;AA6DA,oCAkBC;AAED,8BAYC;AA5FD,iEAAyE;AACzE,2EAIoC;AACpC,uEAIkC;AAIlC,4EAA4E;AAC5E,2EAA2E;AAC3E,2EAA2E;AAC3E,0CAA0C;AAE1C;;;;GAIG;AACU,QAAA,QAAQ;AAInB,iCAAiC,CAAC,wCAAc;IAChD,iCAAiC,CAAC,sCAAY;IAC9C,iCAAiC,CAAC,0CAAgB,CAAA;AAEpD;;;;;;GAMG;AACU,QAAA,UAAU;AAIrB,iCAAiC,CAAC,4CAAgB;IAClD,iCAAiC,CAAC,0CAAc;IAChD,iCAAiC,CAAC,8CAAkB,CAAA;AAEtD,iCAAiC;AACjC,IAAI,gBAAQ,KAAK,0CAAgB,IAAI,kBAAU,KAAK,8CAAkB,EAAE,CAAC;IACvE,aAAa;IACb,OAAO,CAAC,IAAI,CACV,wJAAwJ,CACzJ,CAAA;AACH,CAAC;AAED;;;;GAIG;AACH,SAAgB,YAAY,CAAC,KAAc;IACzC,IAAI,KAAK,YAAY,UAAU,EAAE,CAAC;QAChC,OAAO,KAAK,CAAA;IACd,CAAC;IAED,IAAI,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;QAC9B,OAAO,IAAI,UAAU,CACnB,KAAK,CAAC,MAAM,EACZ,KAAK,CAAC,UAAU,EAChB,KAAK,CAAC,UAAU,GAAG,UAAU,CAAC,iBAAiB,CAChD,CAAA;IACH,CAAC;IAED,IAAI,KAAK,YAAY,WAAW,EAAE,CAAC;QACjC,OAAO,IAAI,UAAU,CAAC,KAAK,CAAC,CAAA;IAC9B,CAAC;IAED,OAAO,SAAS,CAAA;AAClB,CAAC;AAED,SAAgB,SAAS,CAAC,CAAa,EAAE,CAAa;IACpD,IAAI,CAAC,CAAC,UAAU,KAAK,CAAC,CAAC,UAAU,EAAE,CAAC;QAClC,OAAO,KAAK,CAAA;IACd,CAAC;IAED,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,UAAU,EAAE,CAAC,EAAE,EAAE,CAAC;QACtC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAClB,OAAO,KAAK,CAAA;QACd,CAAC;IACH,CAAC;IAED,OAAO,IAAI,CAAA;AACb,CAAC;AAEY,QAAA,SAAS;AACpB,iCAAiC,CAAC,oCAAa;IAC/C,iCAAiC,CAAC,wCAAiB,CAAA","sourcesContent":["import { Base64Alphabet } from './uint8array-base64.js'\nimport { ui8ConcatNode, ui8ConcatPonyfill } from './uint8array-concat.js'\nimport {\n  fromBase64Native,\n  fromBase64Node,\n  fromBase64Ponyfill,\n} from './uint8array-from-base64.js'\nimport {\n  toBase64Native,\n  toBase64Node,\n  toBase64Ponyfill,\n} from './uint8array-to-base64.js'\n\nexport type { Base64Alphabet }\n\n// @TODO drop dependency on uint8arrays package once Uint8Array.fromBase64 /\n// Uint8Array.prototype.toBase64 is widely supported, and mark fromBase64 /\n// toBase64 as deprecated. We can also drop NodeJS specific implementations\n// once NodeJS <24 is no longer supported.\n\n/**\n * Encodes a Uint8Array into a base64 string.\n *\n * @returns The base64 encoded string\n */\nexport const toBase64: (\n  bytes: Uint8Array,\n  alphabet?: Base64Alphabet,\n) => string =\n  /* v8 ignore next -- @preserve */ toBase64Native ??\n  /* v8 ignore next -- @preserve */ toBase64Node ??\n  /* v8 ignore next -- @preserve */ toBase64Ponyfill\n\n/**\n * Decodes a base64 string into a Uint8Array. This function supports both padded\n * and unpadded base64 strings.\n *\n * @returns The decoded {@link Uint8Array}\n * @throws If the input is not a valid base64 string\n */\nexport const fromBase64: (\n  b64: string,\n  alphabet?: Base64Alphabet,\n) => Uint8Array =\n  /* v8 ignore next -- @preserve */ fromBase64Native ??\n  /* v8 ignore next -- @preserve */ fromBase64Node ??\n  /* v8 ignore next -- @preserve */ fromBase64Ponyfill\n\n/* v8 ignore next -- @preserve */\nif (toBase64 === toBase64Ponyfill || fromBase64 === fromBase64Ponyfill) {\n  /*#__PURE__*/\n  console.warn(\n    '[@atproto/lex-data]: Uint8Array.fromBase64 / Uint8Array.prototype.toBase64 not available in this environment. Falling back to ponyfill implementation.',\n  )\n}\n\n/**\n * Coerces various binary data representations into a Uint8Array.\n *\n * @return `undefined` if the input could not be coerced into a {@link Uint8Array}.\n */\nexport function asUint8Array(input: unknown): Uint8Array | undefined {\n  if (input instanceof Uint8Array) {\n    return input\n  }\n\n  if (ArrayBuffer.isView(input)) {\n    return new Uint8Array(\n      input.buffer,\n      input.byteOffset,\n      input.byteLength / Uint8Array.BYTES_PER_ELEMENT,\n    )\n  }\n\n  if (input instanceof ArrayBuffer) {\n    return new Uint8Array(input)\n  }\n\n  return undefined\n}\n\nexport function ui8Equals(a: Uint8Array, b: Uint8Array): boolean {\n  if (a.byteLength !== b.byteLength) {\n    return false\n  }\n\n  for (let i = 0; i < a.byteLength; i++) {\n    if (a[i] !== b[i]) {\n      return false\n    }\n  }\n\n  return true\n}\n\nexport const ui8Concat =\n  /* v8 ignore next -- @preserve */ ui8ConcatNode ??\n  /* v8 ignore next -- @preserve */ ui8ConcatPonyfill\n"]}
+{"version":3,"file":"uint8array.js","sourceRoot":"","sources":["../src/uint8array.ts"],"names":[],"mappings":";;;AAwDA,oCAMC;AAOD,oCAkBC;AAED,8BAYC;AApGD,iEAAyE;AACzE,2EAIoC;AACpC,uEAIkC;AAIlC,4EAA4E;AAC5E,2EAA2E;AAC3E,2EAA2E;AAC3E,0CAA0C;AAE1C;;;;GAIG;AACU,QAAA,QAAQ;AAInB,iCAAiC,CAAC,wCAAc;IAChD,sCAAY;IACZ,0CAAgB,CAAA;AAElB;;;;;;GAMG;AACU,QAAA,UAAU;AAIrB,iCAAiC,CAAC,4CAAgB;IAClD,0CAAc;IACd,8CAAkB,CAAA;AAEpB,iCAAiC;AACjC,IAAI,gBAAQ,KAAK,0CAAgB,IAAI,kBAAU,KAAK,8CAAkB,EAAE,CAAC;IACvE,aAAa;IACb,OAAO,CAAC,IAAI,CACV,wJAAwJ,CACzJ,CAAA;AACH,CAAC;AAED,SAAgB,YAAY,CAAC,KAAc;IACzC,IAAI,KAAK,YAAY,UAAU,EAAE,CAAC;QAChC,OAAO,KAAK,CAAA;IACd,CAAC;IAED,OAAO,SAAS,CAAA;AAClB,CAAC;AAED;;;;GAIG;AACH,SAAgB,YAAY,CAAC,KAAc;IACzC,IAAI,KAAK,YAAY,UAAU,EAAE,CAAC;QAChC,OAAO,KAAK,CAAA;IACd,CAAC;IAED,IAAI,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;QAC9B,OAAO,IAAI,UAAU,CACnB,KAAK,CAAC,MAAM,EACZ,KAAK,CAAC,UAAU,EAChB,KAAK,CAAC,UAAU,GAAG,UAAU,CAAC,iBAAiB,CAChD,CAAA;IACH,CAAC;IAED,IAAI,KAAK,YAAY,WAAW,EAAE,CAAC;QACjC,OAAO,IAAI,UAAU,CAAC,KAAK,CAAC,CAAA;IAC9B,CAAC;IAED,OAAO,SAAS,CAAA;AAClB,CAAC;AAED,SAAgB,SAAS,CAAC,CAAa,EAAE,CAAa;IACpD,IAAI,CAAC,CAAC,UAAU,KAAK,CAAC,CAAC,UAAU,EAAE,CAAC;QAClC,OAAO,KAAK,CAAA;IACd,CAAC;IAED,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,UAAU,EAAE,CAAC,EAAE,EAAE,CAAC;QACtC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAClB,OAAO,KAAK,CAAA;QACd,CAAC;IACH,CAAC;IAED,OAAO,IAAI,CAAA;AACb,CAAC;AAEY,QAAA,SAAS;AACpB,iCAAiC,CAAC,oCAAa,IAAI,wCAAiB,CAAA","sourcesContent":["import { Base64Alphabet } from './uint8array-base64.js'\nimport { ui8ConcatNode, ui8ConcatPonyfill } from './uint8array-concat.js'\nimport {\n  fromBase64Native,\n  fromBase64Node,\n  fromBase64Ponyfill,\n} from './uint8array-from-base64.js'\nimport {\n  toBase64Native,\n  toBase64Node,\n  toBase64Ponyfill,\n} from './uint8array-to-base64.js'\n\nexport type { Base64Alphabet }\n\n// @TODO drop dependency on uint8arrays package once Uint8Array.fromBase64 /\n// Uint8Array.prototype.toBase64 is widely supported, and mark fromBase64 /\n// toBase64 as deprecated. We can also drop NodeJS specific implementations\n// once NodeJS <24 is no longer supported.\n\n/**\n * Encodes a Uint8Array into a base64 string.\n *\n * @returns The base64 encoded string\n */\nexport const toBase64: (\n  bytes: Uint8Array,\n  alphabet?: Base64Alphabet,\n) => string =\n  /* v8 ignore next -- @preserve */ toBase64Native ??\n  toBase64Node ??\n  toBase64Ponyfill\n\n/**\n * Decodes a base64 string into a Uint8Array. This function supports both padded\n * and unpadded base64 strings.\n *\n * @returns The decoded {@link Uint8Array}\n * @throws If the input is not a valid base64 string\n */\nexport const fromBase64: (\n  b64: string,\n  alphabet?: Base64Alphabet,\n) => Uint8Array =\n  /* v8 ignore next -- @preserve */ fromBase64Native ??\n  fromBase64Node ??\n  fromBase64Ponyfill\n\n/* v8 ignore next -- @preserve */\nif (toBase64 === toBase64Ponyfill || fromBase64 === fromBase64Ponyfill) {\n  /*#__PURE__*/\n  console.warn(\n    '[@atproto/lex-data]: Uint8Array.fromBase64 / Uint8Array.prototype.toBase64 not available in this environment. Falling back to ponyfill implementation.',\n  )\n}\n\nexport function ifUint8Array(input: unknown): Uint8Array | undefined {\n  if (input instanceof Uint8Array) {\n    return input\n  }\n\n  return undefined\n}\n\n/**\n * Coerces various binary data representations into a Uint8Array.\n *\n * @return `undefined` if the input could not be coerced into a {@link Uint8Array}.\n */\nexport function asUint8Array(input: unknown): Uint8Array | undefined {\n  if (input instanceof Uint8Array) {\n    return input\n  }\n\n  if (ArrayBuffer.isView(input)) {\n    return new Uint8Array(\n      input.buffer,\n      input.byteOffset,\n      input.byteLength / Uint8Array.BYTES_PER_ELEMENT,\n    )\n  }\n\n  if (input instanceof ArrayBuffer) {\n    return new Uint8Array(input)\n  }\n\n  return undefined\n}\n\nexport function ui8Equals(a: Uint8Array, b: Uint8Array): boolean {\n  if (a.byteLength !== b.byteLength) {\n    return false\n  }\n\n  for (let i = 0; i < a.byteLength; i++) {\n    if (a[i] !== b[i]) {\n      return false\n    }\n  }\n\n  return true\n}\n\nexport const ui8Concat =\n  /* v8 ignore next -- @preserve */ ui8ConcatNode ?? ui8ConcatPonyfill\n"]}

package/dist/utf8.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utf8.d.ts","sourceRoot":"","sources":["../src/utf8.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAShD,eAAO,MAAM,WAAW,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAEY,CAAA;AAUvD,eAAO,MAAM,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAEQ,CAAA;AAElD,eAAO,MAAM,YAAY,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,cAAc,KAAK,MAEf,CAAA;AAExD,eAAO,MAAM,cAAc,EAAE,CAC3B,GAAG,EAAE,MAAM,EACX,QAAQ,CAAC,EAAE,cAAc,KACtB,MAEqD,CAAA"}
+{"version":3,"file":"utf8.d.ts","sourceRoot":"","sources":["../src/utf8.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAShD,eAAO,MAAM,WAAW,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MACiC,CAAA;AAU5E,eAAO,MAAM,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MACuB,CAAA;AAEjE,eAAO,MAAM,YAAY,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,cAAc,KAAK,MACK,CAAA;AAE5E,eAAO,MAAM,cAAc,EAAE,CAC3B,GAAG,EAAE,MAAM,EACX,QAAQ,CAAC,EAAE,cAAc,KACtB,MAC2E,CAAA"}

package/dist/utf8.js

@@ -6,20 +6,16 @@ const utf8_grapheme_len_js_1 = require("./utf8-grapheme-len.js");
 const utf8_len_js_1 = require("./utf8-len.js");
 const utf8_to_base64_js_1 = require("./utf8-to-base64.js");
 exports.graphemeLen = 
-/* v8 ignore next -- @preserve */ utf8_grapheme_len_js_1.graphemeLenNative ??
-    /* v8 ignore next -- @preserve */ utf8_grapheme_len_js_1.graphemeLenPonyfill;
+/* v8 ignore next -- @preserve */ utf8_grapheme_len_js_1.graphemeLenNative ?? utf8_grapheme_len_js_1.graphemeLenPonyfill;
 /* v8 ignore next -- @preserve */
 if (exports.graphemeLen === utf8_grapheme_len_js_1.graphemeLenPonyfill) {
     /*#__PURE__*/
     console.warn('[@atproto/lex-data]: Intl.Segmenter is not available in this environment. Falling back to ponyfill implementation.');
 }
 exports.utf8Len = 
-/* v8 ignore next -- @preserve */ utf8_len_js_1.utf8LenNode ??
-    /* v8 ignore next -- @preserve */ utf8_len_js_1.utf8LenCompute;
+/* v8 ignore next -- @preserve */ utf8_len_js_1.utf8LenNode ?? utf8_len_js_1.utf8LenCompute;
 exports.utf8ToBase64 = 
-/* v8 ignore next -- @preserve */ utf8_to_base64_js_1.utf8ToBase64Node ??
-    /* v8 ignore next -- @preserve */ utf8_to_base64_js_1.utf8ToBase64Ponyfill;
+/* v8 ignore next -- @preserve */ utf8_to_base64_js_1.utf8ToBase64Node ?? utf8_to_base64_js_1.utf8ToBase64Ponyfill;
 exports.utf8FromBase64 = 
-/* v8 ignore next -- @preserve */ utf8_from_base64_js_1.utf8FromBase64Node ??
-    /* v8 ignore next -- @preserve */ utf8_from_base64_js_1.utf8FromBase64Ponyfill;
+/* v8 ignore next -- @preserve */ utf8_from_base64_js_1.utf8FromBase64Node ?? utf8_from_base64_js_1.utf8FromBase64Ponyfill;
 //# sourceMappingURL=utf8.js.map

package/dist/utf8.js.map

@@ -1 +1 @@
-{"version":3,"file":"utf8.js","sourceRoot":"","sources":["../src/utf8.ts"],"names":[],"mappings":";;;AACA,+DAG8B;AAC9B,iEAA+E;AAC/E,+CAA2D;AAC3D,2DAA4E;AAE/D,QAAA,WAAW;AACtB,iCAAiC,CAAC,wCAAiB;IACnD,iCAAiC,CAAC,0CAAmB,CAAA;AAEvD,iCAAiC;AACjC,IAAI,mBAAW,KAAK,0CAAmB,EAAE,CAAC;IACxC,aAAa;IACb,OAAO,CAAC,IAAI,CACV,oHAAoH,CACrH,CAAA;AACH,CAAC;AAEY,QAAA,OAAO;AAClB,iCAAiC,CAAC,yBAAW;IAC7C,iCAAiC,CAAC,4BAAc,CAAA;AAErC,QAAA,YAAY;AACvB,iCAAiC,CAAC,oCAAgB;IAClD,iCAAiC,CAAC,wCAAoB,CAAA;AAE3C,QAAA,cAAc;AAIzB,iCAAiC,CAAC,wCAAkB;IACpD,iCAAiC,CAAC,4CAAsB,CAAA","sourcesContent":["import { Base64Alphabet } from './uint8array.js'\nimport {\n  utf8FromBase64Node,\n  utf8FromBase64Ponyfill,\n} from './utf8-from-base64.js'\nimport { graphemeLenNative, graphemeLenPonyfill } from './utf8-grapheme-len.js'\nimport { utf8LenCompute, utf8LenNode } from './utf8-len.js'\nimport { utf8ToBase64Node, utf8ToBase64Ponyfill } from './utf8-to-base64.js'\n\nexport const graphemeLen: (str: string) => number =\n  /* v8 ignore next -- @preserve */ graphemeLenNative ??\n  /* v8 ignore next -- @preserve */ graphemeLenPonyfill\n\n/* v8 ignore next -- @preserve */\nif (graphemeLen === graphemeLenPonyfill) {\n  /*#__PURE__*/\n  console.warn(\n    '[@atproto/lex-data]: Intl.Segmenter is not available in this environment. Falling back to ponyfill implementation.',\n  )\n}\n\nexport const utf8Len: (string: string) => number =\n  /* v8 ignore next -- @preserve */ utf8LenNode ??\n  /* v8 ignore next -- @preserve */ utf8LenCompute\n\nexport const utf8ToBase64: (str: string, alphabet?: Base64Alphabet) => string =\n  /* v8 ignore next -- @preserve */ utf8ToBase64Node ??\n  /* v8 ignore next -- @preserve */ utf8ToBase64Ponyfill\n\nexport const utf8FromBase64: (\n  b64: string,\n  alphabet?: Base64Alphabet,\n) => string =\n  /* v8 ignore next -- @preserve */ utf8FromBase64Node ??\n  /* v8 ignore next -- @preserve */ utf8FromBase64Ponyfill\n"]}
+{"version":3,"file":"utf8.js","sourceRoot":"","sources":["../src/utf8.ts"],"names":[],"mappings":";;;AACA,+DAG8B;AAC9B,iEAA+E;AAC/E,+CAA2D;AAC3D,2DAA4E;AAE/D,QAAA,WAAW;AACtB,iCAAiC,CAAC,wCAAiB,IAAI,0CAAmB,CAAA;AAE5E,iCAAiC;AACjC,IAAI,mBAAW,KAAK,0CAAmB,EAAE,CAAC;IACxC,aAAa;IACb,OAAO,CAAC,IAAI,CACV,oHAAoH,CACrH,CAAA;AACH,CAAC;AAEY,QAAA,OAAO;AAClB,iCAAiC,CAAC,yBAAW,IAAI,4BAAc,CAAA;AAEpD,QAAA,YAAY;AACvB,iCAAiC,CAAC,oCAAgB,IAAI,wCAAoB,CAAA;AAE/D,QAAA,cAAc;AAIzB,iCAAiC,CAAC,wCAAkB,IAAI,4CAAsB,CAAA","sourcesContent":["import { Base64Alphabet } from './uint8array.js'\nimport {\n  utf8FromBase64Node,\n  utf8FromBase64Ponyfill,\n} from './utf8-from-base64.js'\nimport { graphemeLenNative, graphemeLenPonyfill } from './utf8-grapheme-len.js'\nimport { utf8LenCompute, utf8LenNode } from './utf8-len.js'\nimport { utf8ToBase64Node, utf8ToBase64Ponyfill } from './utf8-to-base64.js'\n\nexport const graphemeLen: (str: string) => number =\n  /* v8 ignore next -- @preserve */ graphemeLenNative ?? graphemeLenPonyfill\n\n/* v8 ignore next -- @preserve */\nif (graphemeLen === graphemeLenPonyfill) {\n  /*#__PURE__*/\n  console.warn(\n    '[@atproto/lex-data]: Intl.Segmenter is not available in this environment. Falling back to ponyfill implementation.',\n  )\n}\n\nexport const utf8Len: (string: string) => number =\n  /* v8 ignore next -- @preserve */ utf8LenNode ?? utf8LenCompute\n\nexport const utf8ToBase64: (str: string, alphabet?: Base64Alphabet) => string =\n  /* v8 ignore next -- @preserve */ utf8ToBase64Node ?? utf8ToBase64Ponyfill\n\nexport const utf8FromBase64: (\n  b64: string,\n  alphabet?: Base64Alphabet,\n) => string =\n  /* v8 ignore next -- @preserve */ utf8FromBase64Node ?? utf8FromBase64Ponyfill\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/lex-data",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "license": "MIT",
   "description": "Core utilities for AT Lexicons",
   "keywords": [
@@ -38,8 +38,7 @@
     "multiformats": "^9.9.0",
     "tslib": "^2.8.1",
     "uint8arrays": "3.0.0",
-    "unicode-segmenter": "^0.14.0",
-    "@atproto/syntax": "0.4.2"
+    "unicode-segmenter": "^0.14.0"
   },
   "devDependencies": {
     "core-js": "^3",

package/src/cid.test.ts

@@ -14,6 +14,7 @@ import {
   decodeCid,
   ensureValidCidString,
   isCid,
+  isCidForBytes,
   parseCid,
   parseCidSafe,
 } from './cid.js'
@@ -27,13 +28,13 @@ const cborCid = parseCid(cborCidStr, { flavor: 'cbor' })
 const rawCidStr = 'bafkreifjjcie6lypi6ny7amxnfftagclbuxndqonfipmb64f2km2devei4'
 const rawCid = parseCid(rawCidStr, { flavor: 'raw' })
 
-const rawCidCustom: Cid = createCustomCid(
+const rawCidLike: Cid = createCustomCid(
   1,
   RAW_MULTICODEC,
   SHA256_MULTIHASH,
   rawCid.multihash.digest,
 )
-const rawCidCustomBytes = new BytesCid(rawCid.bytes)
+const rawBytesCid = new BytesCid(rawCid.bytes)
 
 describe(isCid, () => {
   describe('non-strict mode', () => {
@@ -43,8 +44,8 @@ describe(isCid, () => {
     })
 
     it('returns true for custom compatible CID implementations', () => {
-      expect(isCid(rawCidCustom)).toBe(true)
-      expect(isCid(rawCidCustomBytes)).toBe(true)
+      expect(isCid(rawCidLike)).toBe(true)
+      expect(isCid(rawBytesCid)).toBe(true)
     })
 
     it('returns true for CID v0 and v1', async () => {
@@ -118,50 +119,125 @@ describe(isCid, () => {
 
   describe('alternative cid implementations', () => {
     it('accepts compatible CID implementations', () => {
-      expect(isCid(rawCidCustom)).toBe(true)
+      expect(isCid(rawCidLike)).toBe(true)
     })
 
     it('rejects non-matching version', () => {
-      expect(isCid({ ...rawCidCustom, version: 0 })).toBe(false)
+      expect(isCid({ ...rawCidLike, version: 0 })).toBe(false)
     })
 
     it('rejects non-matching code', () => {
-      expect(isCid({ ...rawCidCustom, code: 0 })).toBe(false)
+      expect(isCid({ ...rawCidLike, code: -1 })).toBe(false)
+      expect(isCid({ ...rawCidLike, code: 0 })).toBe(false)
+      expect(isCid({ ...rawCidLike, code: 256 })).toBe(false)
     })
 
-    it('rejects non-matching multihash code', () => {
-      expect(
-        isCid({
-          ...rawCidCustom,
-          multihash: { ...rawCidCustom.multihash, code: 0 },
-        }),
-      ).toBe(false)
-    })
+    it('rejects invalid bytes property', () => {
+      expect(isCid({ ...rawCidLike, bytes: undefined })).toBe(false)
+      expect(isCid({ ...rawCidLike, bytes: 12 })).toBe(false)
+      expect(isCid({ ...rawCidLike, bytes: {} })).toBe(false)
+      expect(isCid({ ...rawCidLike, bytes: [] })).toBe(false)
 
-    it('rejects non-matching multihash digest', () => {
-      const differentDigest = new Uint8Array(32)
-      differentDigest[0] = 1
       expect(
         isCid({
-          ...rawCidCustom,
-          multihash: { ...rawCidCustom.multihash, digest: differentDigest },
+          ...rawCidLike,
+          bytes: rawCidLike.bytes.subarray(0, rawCidLike.bytes.length - 1),
         }),
       ).toBe(false)
+
+      const bytes = new Uint8Array(rawCidLike.bytes.length)
+
+      bytes.set(rawCidLike.bytes)
+      expect(isCid({ ...rawCidLike, bytes })).toBe(true)
+
+      bytes[0] = bytes[0] ^ 0xff
+      expect(isCid({ ...rawCidLike, bytes })).toBe(false)
+      bytes.set(rawCidLike.bytes)
+
+      bytes[3] = bytes[3] ^ 0xff
+      expect(isCid({ ...rawCidLike, bytes })).toBe(false)
+      bytes.set(rawCidLike.bytes)
+
+      bytes[6] = bytes[6] ^ 0xff
+      expect(isCid({ ...rawCidLike, bytes })).toBe(false)
+      bytes.set(rawCidLike.bytes)
     })
 
-    it('rejects objects without equals method', () => {
-      expect(isCid({ ...rawCidCustom, equals: undefined })).toBe(false)
+    describe('multihash property', () => {
+      it('rejects non-matching object', () => {
+        expect(isCid({ ...rawCidLike, multihash: undefined })).toBe(false)
+        expect(isCid({ ...rawCidLike, multihash: 12 })).toBe(false)
+        expect(isCid({ ...rawCidLike, multihash: {} })).toBe(false)
+        expect(isCid({ ...rawCidLike, multihash: [] })).toBe(false)
+      })
+
+      it('rejects non-matching code', () => {
+        expect(
+          isCid({
+            ...rawCidLike,
+            multihash: { ...rawCidLike.multihash, code: -1 },
+          }),
+        ).toBe(false)
+        expect(
+          isCid({
+            ...rawCidLike,
+            multihash: { ...rawCidLike.multihash, code: 0 },
+          }),
+        ).toBe(false)
+        expect(
+          isCid({
+            ...rawCidLike,
+            multihash: { ...rawCidLike.multihash, code: 256 },
+          }),
+        ).toBe(false)
+      })
+
+      it('rejects non Uint8Array digest', () => {
+        expect(
+          isCid({
+            ...rawCidLike,
+            multihash: { ...rawCidLike.multihash, digest: new Array(32) },
+          }),
+        ).toBe(false)
+      })
+
+      it('rejects non Uint8Array digest', () => {
+        expect(
+          isCid({
+            ...rawCidLike,
+            multihash: { ...rawCidLike.multihash, digest: new Array(32) },
+          }),
+        ).toBe(false)
+      })
+
+      it('rejects non-matching digest', () => {
+        const differentDigest = new Uint8Array(32)
+        differentDigest[0] = 1
+        expect(
+          isCid({
+            ...rawCidLike,
+            multihash: { ...rawCidLike.multihash, digest: differentDigest },
+          }),
+        ).toBe(false)
+      })
     })
 
-    it('rejects object with throwing equals method', () => {
-      expect(
-        isCid({
-          ...rawCidCustom,
-          equals: () => {
-            throw new Error('fail')
-          },
-        }),
-      ).toBe(false)
+    describe('equals() method', () => {
+      it('rejects objects without equals method', () => {
+        expect(isCid({ ...rawCidLike, equals: undefined })).toBe(false)
+        expect(isCid({ ...rawCidLike, equals: () => false })).toBe(false)
+      })
+
+      it('rejects object with throwing equals method', () => {
+        expect(
+          isCid({
+            ...rawCidLike,
+            equals: () => {
+              throw new Error('fail')
+            },
+          }),
+        ).toBe(false)
+      })
     })
   })
 })
@@ -186,6 +262,37 @@ describe(parseCid, () => {
   })
 })
 
+describe(isCidForBytes, () => {
+  describe('raw', () => {
+    it('returns true for valid raw CID bytes', async () => {
+      for (const hasher of [sha256, sha512]) {
+        const data = new TextEncoder().encode('hello world')
+        const digest = await hasher.digest(data)
+        const cid = CID.createV1(RAW_MULTICODEC, digest)
+        expect(await isCidForBytes(cid, data)).toBe(true)
+
+        data[0] = data[0] ^ 0xff
+        expect(await isCidForBytes(cid, data)).toBe(false)
+      }
+    })
+  })
+
+  describe('cbor', () => {
+    it('returns true for valid cbor CID bytes', async () => {
+      for (const hasher of [sha256, sha512]) {
+        // @NOTE this is not valid CBOR, but sufficient for testing the hash
+        const data = new TextEncoder().encode('hello world')
+        const digest = await hasher.digest(data)
+        const cid = CID.createV1(DAG_CBOR_MULTICODEC, digest)
+        expect(await isCidForBytes(cid, data)).toBe(true)
+
+        data[0] = data[0] ^ 0xff
+        expect(await isCidForBytes(cid, data)).toBe(false)
+      }
+    })
+  })
+})
+
 describe(parseCidSafe, () => {
   it('parses valid CIDs', () => {
     expect(parseCidSafe(cborCidStr)?.toString()).toBe(cborCidStr)
@@ -230,7 +337,7 @@ describe(cidForRawHash, () => {
 
 describe(asMultiformatsCID, () => {
   it('converts compatible CID to multiformats CID', () => {
-    for (const cid of [cborCid, rawCid, rawCidCustom, rawCidCustomBytes]) {
+    for (const cid of [cborCid, rawCid, rawCidLike, rawBytesCid]) {
       expect(asMultiformatsCID(cid)).toBeInstanceOf(CID)
       expect(asMultiformatsCID(cid)).toMatchObject({
         version: cid.version,

package/src/index.ts

@@ -1,6 +1,5 @@
 export * from './blob.js'
 export * from './cid.js'
-export * from './language.js'
 export * from './lex-equals.js'
 export * from './lex-error.js'
 export * from './lex.js'

package/src/uint8array.test.ts

@@ -5,12 +5,13 @@ import { describe, expect, it } from 'vitest'
 import {
   asUint8Array,
   fromBase64,
+  ifUint8Array,
   toBase64,
   ui8Concat,
   ui8Equals,
 } from './uint8array.js'
 
-describe('toBase64', () => {
+describe(toBase64, () => {
   it('encodes empty Uint8Array', () => {
     const encoded = toBase64(new Uint8Array(0))
     expect(typeof encoded).toBe('string')
@@ -49,7 +50,7 @@ describe('toBase64', () => {
   })
 })
 
-describe('fromBase64', () => {
+describe(fromBase64, () => {
   it('decodes empty string', () => {
     const decoded = fromBase64('')
     expect(decoded).toBeInstanceOf(Uint8Array)
@@ -133,7 +134,7 @@ describe('roundtrip toBase64 <-> fromBase64', () => {
   })
 })
 
-describe('asUint8Array', () => {
+describe(asUint8Array, () => {
   describe('Uint8Array input', () => {
     it('returns same Uint8Array instance', () => {
       const input = new Uint8Array([1, 2, 3])
@@ -294,7 +295,7 @@ describe('asUint8Array', () => {
   })
 })
 
-describe('ui8Equals', () => {
+describe(ui8Equals, () => {
   describe('equal arrays', () => {
     it('returns true for identical arrays', () => {
       const a = new Uint8Array([1, 2, 3])
@@ -434,7 +435,25 @@ describe('ui8Equals', () => {
   })
 })
 
-describe('ui8Concat', () => {
+describe(ifUint8Array, () => {
+  it('returns the input if it is a Uint8Array', () => {
+    const input = new Uint8Array([1, 2, 3])
+    const result = ifUint8Array(input)
+    expect(result).toBe(input)
+  })
+
+  it('returns undefined for non-Uint8Array inputs', () => {
+    expect(ifUint8Array(null)).toBeUndefined()
+    expect(ifUint8Array(undefined)).toBeUndefined()
+    expect(ifUint8Array({})).toBeUndefined()
+    expect(ifUint8Array([])).toBeUndefined()
+    expect(ifUint8Array('string')).toBeUndefined()
+    expect(ifUint8Array(123)).toBeUndefined()
+    expect(ifUint8Array(true)).toBeUndefined()
+  })
+})
+
+describe(ui8Concat, () => {
   it('concatenates empty array', () => {
     const result = ui8Concat([])
     expect(result).toBeInstanceOf(Uint8Array)

package/src/uint8array.ts

@@ -28,8 +28,8 @@ export const toBase64: (
   alphabet?: Base64Alphabet,
 ) => string =
   /* v8 ignore next -- @preserve */ toBase64Native ??
-  /* v8 ignore next -- @preserve */ toBase64Node ??
-  /* v8 ignore next -- @preserve */ toBase64Ponyfill
+  toBase64Node ??
+  toBase64Ponyfill
 
 /**
  * Decodes a base64 string into a Uint8Array. This function supports both padded
@@ -43,8 +43,8 @@ export const fromBase64: (
   alphabet?: Base64Alphabet,
 ) => Uint8Array =
   /* v8 ignore next -- @preserve */ fromBase64Native ??
-  /* v8 ignore next -- @preserve */ fromBase64Node ??
-  /* v8 ignore next -- @preserve */ fromBase64Ponyfill
+  fromBase64Node ??
+  fromBase64Ponyfill
 
 /* v8 ignore next -- @preserve */
 if (toBase64 === toBase64Ponyfill || fromBase64 === fromBase64Ponyfill) {
@@ -54,6 +54,14 @@ if (toBase64 === toBase64Ponyfill || fromBase64 === fromBase64Ponyfill) {
   )
 }
 
+export function ifUint8Array(input: unknown): Uint8Array | undefined {
+  if (input instanceof Uint8Array) {
+    return input
+  }
+
+  return undefined
+}
+
 /**
  * Coerces various binary data representations into a Uint8Array.
  *
@@ -94,5 +102,4 @@ export function ui8Equals(a: Uint8Array, b: Uint8Array): boolean {
 }
 
 export const ui8Concat =
-  /* v8 ignore next -- @preserve */ ui8ConcatNode ??
-  /* v8 ignore next -- @preserve */ ui8ConcatPonyfill
+  /* v8 ignore next -- @preserve */ ui8ConcatNode ?? ui8ConcatPonyfill

package/src/utf8-len.test.ts

@@ -1,32 +1,23 @@
 import { describe, expect, it } from 'vitest'
 import { utf8LenCompute, utf8LenNode } from './utf8-len.js'
 
-describe(utf8LenNode!, () => {
-  it('computes utf8 string length', () => {
-    expect(utf8LenNode!('a')).toBe(1)
-    expect(utf8LenNode!('~')).toBe(1)
-    expect(utf8LenNode!('ö')).toBe(2)
-    expect(utf8LenNode!('ñ')).toBe(2)
-    expect(utf8LenNode!('©')).toBe(2)
-    expect(utf8LenNode!('⽘')).toBe(3)
-    expect(utf8LenNode!('☎')).toBe(3)
-    expect(utf8LenNode!('𓋓')).toBe(4)
-    expect(utf8LenNode!('😀')).toBe(4)
-    expect(utf8LenNode!('👨‍👩‍👧‍👧')).toBe(25)
+for (const utf8Len of [utf8LenNode!, utf8LenCompute!] as const) {
+  describe(utf8Len, () => {
+    it('computes utf8 string length', () => {
+      expect(utf8Len('a')).toBe(1)
+      expect(utf8Len('~')).toBe(1)
+      expect(utf8Len('ö')).toBe(2)
+      expect(utf8Len('ñ')).toBe(2)
+      expect(utf8Len('©')).toBe(2)
+      expect(utf8Len('⽘')).toBe(3)
+      expect(utf8Len('☎')).toBe(3)
+      expect(utf8Len('𓋓')).toBe(4)
+      expect(utf8Len('😀')).toBe(4)
+      expect(utf8Len('👨‍👩‍👧‍👧')).toBe(25)
+      // high surrogate with no low surrogate
+      expect(utf8Len('\uD83D')).toBe(3)
+      // low surrogate with no high surrogate
+      expect(utf8Len('\uDC00')).toBe(3)
+    })
   })
-})
-
-describe(utf8LenCompute, () => {
-  it('computes utf8 string length', () => {
-    expect(utf8LenCompute('a')).toBe(1)
-    expect(utf8LenCompute('~')).toBe(1)
-    expect(utf8LenCompute('ö')).toBe(2)
-    expect(utf8LenCompute('ñ')).toBe(2)
-    expect(utf8LenCompute('©')).toBe(2)
-    expect(utf8LenCompute('⽘')).toBe(3)
-    expect(utf8LenCompute('☎')).toBe(3)
-    expect(utf8LenCompute('𓋓')).toBe(4)
-    expect(utf8LenCompute('😀')).toBe(4)
-    expect(utf8LenCompute('👨‍👩‍👧‍👧')).toBe(25)
-  })
-})
+}

package/src/utf8.ts

@@ -8,8 +8,7 @@ import { utf8LenCompute, utf8LenNode } from './utf8-len.js'
 import { utf8ToBase64Node, utf8ToBase64Ponyfill } from './utf8-to-base64.js'
 
 export const graphemeLen: (str: string) => number =
-  /* v8 ignore next -- @preserve */ graphemeLenNative ??
-  /* v8 ignore next -- @preserve */ graphemeLenPonyfill
+  /* v8 ignore next -- @preserve */ graphemeLenNative ?? graphemeLenPonyfill
 
 /* v8 ignore next -- @preserve */
 if (graphemeLen === graphemeLenPonyfill) {
@@ -20,16 +19,13 @@ if (graphemeLen === graphemeLenPonyfill) {
 }
 
 export const utf8Len: (string: string) => number =
-  /* v8 ignore next -- @preserve */ utf8LenNode ??
-  /* v8 ignore next -- @preserve */ utf8LenCompute
+  /* v8 ignore next -- @preserve */ utf8LenNode ?? utf8LenCompute
 
 export const utf8ToBase64: (str: string, alphabet?: Base64Alphabet) => string =
-  /* v8 ignore next -- @preserve */ utf8ToBase64Node ??
-  /* v8 ignore next -- @preserve */ utf8ToBase64Ponyfill
+  /* v8 ignore next -- @preserve */ utf8ToBase64Node ?? utf8ToBase64Ponyfill
 
 export const utf8FromBase64: (
   b64: string,
   alphabet?: Base64Alphabet,
 ) => string =
-  /* v8 ignore next -- @preserve */ utf8FromBase64Node ??
-  /* v8 ignore next -- @preserve */ utf8FromBase64Ponyfill
+  /* v8 ignore next -- @preserve */ utf8FromBase64Node ?? utf8FromBase64Ponyfill

package/dist/language.d.ts

@@ -1,18 +0,0 @@
-export type LanguageTag = {
-    grandfathered?: string;
-    language?: string;
-    extlang?: string;
-    script?: string;
-    region?: string;
-    variant?: string;
-    extension?: string;
-    privateUse?: string;
-};
-export declare function parseLanguageString(input: string): LanguageTag | null;
-/**
- * Validates well-formed BCP 47 syntax
- *
- * @see {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.1}
- */
-export declare function isLanguageString(input: string): boolean;
-//# sourceMappingURL=language.d.ts.map

package/dist/language.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"language.d.ts","sourceRoot":"","sources":["../src/language.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,WAAW,GAAG;IACxB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAerE;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEvD"}

package/dist/language.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseLanguageString = parseLanguageString;
-exports.isLanguageString = isLanguageString;
-const BCP47_REGEXP = /^((?<grandfathered>(en-GB-oed|i-ami|i-bnn|i-default|i-enochian|i-hak|i-klingon|i-lux|i-mingo|i-navajo|i-pwn|i-tao|i-tay|i-tsu|sgn-BE-FR|sgn-BE-NL|sgn-CH-DE)|(art-lojban|cel-gaulish|no-bok|no-nyn|zh-guoyu|zh-hakka|zh-min|zh-min-nan|zh-xiang))|((?<language>([A-Za-z]{2,3}(-(?<extlang>[A-Za-z]{3}(-[A-Za-z]{3}){0,2}))?)|[A-Za-z]{4}|[A-Za-z]{5,8})(-(?<script>[A-Za-z]{4}))?(-(?<region>[A-Za-z]{2}|[0-9]{3}))?(-(?<variant>[A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3}))*(-(?<extension>[0-9A-WY-Za-wy-z](-[A-Za-z0-9]{2,8})+))*(-(?<privateUseA>x(-[A-Za-z0-9]{1,8})+))?)|(?<privateUseB>x(-[A-Za-z0-9]{1,8})+))$/;
-function parseLanguageString(input) {
-    const parsed = input.match(BCP47_REGEXP);
-    if (!parsed?.groups)
-        return null;
-    const { groups } = parsed;
-    return {
-        grandfathered: groups.grandfathered,
-        language: groups.language,
-        extlang: groups.extlang,
-        script: groups.script,
-        region: groups.region,
-        variant: groups.variant,
-        extension: groups.extension,
-        privateUse: groups.privateUseA || groups.privateUseB,
-    };
-}
-/**
- * Validates well-formed BCP 47 syntax
- *
- * @see {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.1}
- */
-function isLanguageString(input) {
-    return BCP47_REGEXP.test(input);
-}
-//# sourceMappingURL=language.js.map

package/dist/language.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"language.js","sourceRoot":"","sources":["../src/language.ts"],"names":[],"mappings":";;AAcA,kDAeC;AAOD,4CAEC;AAtCD,MAAM,YAAY,GAChB,mlBAAmlB,CAAA;AAarlB,SAAgB,mBAAmB,CAAC,KAAa;IAC/C,MAAM,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC,YAAY,CAAC,CAAA;IACxC,IAAI,CAAC,MAAM,EAAE,MAAM;QAAE,OAAO,IAAI,CAAA;IAEhC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAAA;IACzB,OAAO;QACL,aAAa,EAAE,MAAM,CAAC,aAAa;QACnC,QAAQ,EAAE,MAAM,CAAC,QAAQ;QACzB,OAAO,EAAE,MAAM,CAAC,OAAO;QACvB,MAAM,EAAE,MAAM,CAAC,MAAM;QACrB,MAAM,EAAE,MAAM,CAAC,MAAM;QACrB,OAAO,EAAE,MAAM,CAAC,OAAO;QACvB,SAAS,EAAE,MAAM,CAAC,SAAS;QAC3B,UAAU,EAAE,MAAM,CAAC,WAAW,IAAI,MAAM,CAAC,WAAW;KACrD,CAAA;AACH,CAAC;AAED;;;;GAIG;AACH,SAAgB,gBAAgB,CAAC,KAAa;IAC5C,OAAO,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;AACjC,CAAC","sourcesContent":["const BCP47_REGEXP =\n  /^((?<grandfathered>(en-GB-oed|i-ami|i-bnn|i-default|i-enochian|i-hak|i-klingon|i-lux|i-mingo|i-navajo|i-pwn|i-tao|i-tay|i-tsu|sgn-BE-FR|sgn-BE-NL|sgn-CH-DE)|(art-lojban|cel-gaulish|no-bok|no-nyn|zh-guoyu|zh-hakka|zh-min|zh-min-nan|zh-xiang))|((?<language>([A-Za-z]{2,3}(-(?<extlang>[A-Za-z]{3}(-[A-Za-z]{3}){0,2}))?)|[A-Za-z]{4}|[A-Za-z]{5,8})(-(?<script>[A-Za-z]{4}))?(-(?<region>[A-Za-z]{2}|[0-9]{3}))?(-(?<variant>[A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3}))*(-(?<extension>[0-9A-WY-Za-wy-z](-[A-Za-z0-9]{2,8})+))*(-(?<privateUseA>x(-[A-Za-z0-9]{1,8})+))?)|(?<privateUseB>x(-[A-Za-z0-9]{1,8})+))$/\n\nexport type LanguageTag = {\n  grandfathered?: string\n  language?: string\n  extlang?: string\n  script?: string\n  region?: string\n  variant?: string\n  extension?: string\n  privateUse?: string\n}\n\nexport function parseLanguageString(input: string): LanguageTag | null {\n  const parsed = input.match(BCP47_REGEXP)\n  if (!parsed?.groups) return null\n\n  const { groups } = parsed\n  return {\n    grandfathered: groups.grandfathered,\n    language: groups.language,\n    extlang: groups.extlang,\n    script: groups.script,\n    region: groups.region,\n    variant: groups.variant,\n    extension: groups.extension,\n    privateUse: groups.privateUseA || groups.privateUseB,\n  }\n}\n\n/**\n * Validates well-formed BCP 47 syntax\n *\n * @see {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.1}\n */\nexport function isLanguageString(input: string): boolean {\n  return BCP47_REGEXP.test(input)\n}\n"]}

package/src/language.test.ts

@@ -1,88 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { isLanguageString, parseLanguageString } from './language'
-
-describe('string', () => {
-  describe('languages', () => {
-    it('validates BCP 47', () => {
-      // valid
-      expect(isLanguageString('de')).toEqual(true)
-      expect(isLanguageString('de-CH')).toEqual(true)
-      expect(isLanguageString('de-DE-1901')).toEqual(true)
-      expect(isLanguageString('es-419')).toEqual(true)
-      expect(isLanguageString('sl-IT-nedis')).toEqual(true)
-      expect(isLanguageString('mn-Cyrl-MN')).toEqual(true)
-      expect(isLanguageString('x-fr-CH')).toEqual(true)
-      expect(
-        isLanguageString('en-GB-boont-r-extended-sequence-x-private'),
-      ).toEqual(true)
-      expect(isLanguageString('sr-Cyrl')).toEqual(true)
-      expect(isLanguageString('hy-Latn-IT-arevela')).toEqual(true)
-      expect(isLanguageString('i-klingon')).toEqual(true)
-      // invalid
-      expect(isLanguageString('')).toEqual(false)
-      expect(isLanguageString('x')).toEqual(false)
-      expect(isLanguageString('de-CH-')).toEqual(false)
-      expect(isLanguageString('i-bad-grandfathered')).toEqual(false)
-    })
-
-    it('parses BCP 47', () => {
-      // valid
-      expect(parseLanguageString('de')).toEqual({
-        language: 'de',
-      })
-      expect(parseLanguageString('de-CH')).toEqual({
-        language: 'de',
-        region: 'CH',
-      })
-      expect(parseLanguageString('de-DE-1901')).toEqual({
-        language: 'de',
-        region: 'DE',
-        variant: '1901',
-      })
-      expect(parseLanguageString('es-419')).toEqual({
-        language: 'es',
-        region: '419',
-      })
-      expect(parseLanguageString('sl-IT-nedis')).toEqual({
-        language: 'sl',
-        region: 'IT',
-        variant: 'nedis',
-      })
-      expect(parseLanguageString('mn-Cyrl-MN')).toEqual({
-        language: 'mn',
-        script: 'Cyrl',
-        region: 'MN',
-      })
-      expect(parseLanguageString('x-fr-CH')).toEqual({
-        privateUse: 'x-fr-CH',
-      })
-      expect(
-        parseLanguageString('en-GB-boont-r-extended-sequence-x-private'),
-      ).toEqual({
-        language: 'en',
-        region: 'GB',
-        variant: 'boont',
-        extension: 'r-extended-sequence',
-        privateUse: 'x-private',
-      })
-      expect(parseLanguageString('sr-Cyrl')).toEqual({
-        language: 'sr',
-        script: 'Cyrl',
-      })
-      expect(parseLanguageString('hy-Latn-IT-arevela')).toEqual({
-        language: 'hy',
-        script: 'Latn',
-        region: 'IT',
-        variant: 'arevela',
-      })
-      expect(parseLanguageString('i-klingon')).toEqual({
-        grandfathered: 'i-klingon',
-      })
-      // invalid
-      expect(parseLanguageString('')).toEqual(null)
-      expect(parseLanguageString('x')).toEqual(null)
-      expect(parseLanguageString('de-CH-')).toEqual(null)
-      expect(parseLanguageString('i-bad-grandfathered')).toEqual(null)
-    })
-  })
-})

package/src/language.ts

@@ -1,39 +0,0 @@
-const BCP47_REGEXP =
-  /^((?<grandfathered>(en-GB-oed|i-ami|i-bnn|i-default|i-enochian|i-hak|i-klingon|i-lux|i-mingo|i-navajo|i-pwn|i-tao|i-tay|i-tsu|sgn-BE-FR|sgn-BE-NL|sgn-CH-DE)|(art-lojban|cel-gaulish|no-bok|no-nyn|zh-guoyu|zh-hakka|zh-min|zh-min-nan|zh-xiang))|((?<language>([A-Za-z]{2,3}(-(?<extlang>[A-Za-z]{3}(-[A-Za-z]{3}){0,2}))?)|[A-Za-z]{4}|[A-Za-z]{5,8})(-(?<script>[A-Za-z]{4}))?(-(?<region>[A-Za-z]{2}|[0-9]{3}))?(-(?<variant>[A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3}))*(-(?<extension>[0-9A-WY-Za-wy-z](-[A-Za-z0-9]{2,8})+))*(-(?<privateUseA>x(-[A-Za-z0-9]{1,8})+))?)|(?<privateUseB>x(-[A-Za-z0-9]{1,8})+))$/
-
-export type LanguageTag = {
-  grandfathered?: string
-  language?: string
-  extlang?: string
-  script?: string
-  region?: string
-  variant?: string
-  extension?: string
-  privateUse?: string
-}
-
-export function parseLanguageString(input: string): LanguageTag | null {
-  const parsed = input.match(BCP47_REGEXP)
-  if (!parsed?.groups) return null
-
-  const { groups } = parsed
-  return {
-    grandfathered: groups.grandfathered,
-    language: groups.language,
-    extlang: groups.extlang,
-    script: groups.script,
-    region: groups.region,
-    variant: groups.variant,
-    extension: groups.extension,
-    privateUse: groups.privateUseA || groups.privateUseB,
-  }
-}
-
-/**
- * Validates well-formed BCP 47 syntax
- *
- * @see {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.1}
- */
-export function isLanguageString(input: string): boolean {
-  return BCP47_REGEXP.test(input)
-}