@fluid-internal/client-utils 3.6.0 → 3.7.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # @fluid-internal/client-utils
 
+## 3.7.0
+
+Dependency updates only.
+
 ## 3.6.0
 
 Dependency updates only.

package/dist/bufferShared.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bufferShared.d.ts","sourceRoot":"","sources":["../src/bufferShared.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;GAUG;AACH,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,eAAe,GAAG,WAAW,CASjF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,2BAA2B,CAAC,YAAY,SAAS,eAAe,EAC/E,KAAK,EAAE,UAAU,CAAC,YAAY,CAAC,GAC7B,YAAY,CAWd;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,CAgBzE"}
+{"version":3,"file":"bufferShared.d.ts","sourceRoot":"","sources":["../src/bufferShared.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;GAUG;AACH,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,eAAe,GAAG,WAAW,CASjF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,2BAA2B,CAAC,YAAY,SAAS,eAAe,EAC/E,KAAK,EAAE,UAAU,CAAC,YAAY,CAAC,GAC7B,YAAY,CAWd;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,CAmBzE"}

package/dist/bufferShared.js

@@ -72,12 +72,15 @@ function AnyUint8ArrayToArrayBuffer(array) {
         array.buffer instanceof ArrayBuffer) {
         return array.buffer;
     }
-    // .slice is used to ensure underlying buffer is:
+    // Copy into a new `Uint8Array` so that the result's underlying buffer is:
     //  1. ArrayBuffer
     //  2. the complete data (no offset, full length)
-    // Cloning specified per https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
-    // and ECMAScript https://tc39.es/ecma262/multipage/indexed-collections.html#sec-%typedarray%.prototype.slice.
-    // eslint-disable-next-line unicorn/prefer-spread -- spread is not the same as slice for `Uint8Array`
-    return array.slice().buffer;
+    // Constructing from a typed array always allocates a fresh `ArrayBuffer` of exactly
+    // `array.byteLength` bytes. See ECMAScript https://tc39.es/ecma262/multipage/indexed-collections.html#sec-initializetypedarrayfromtypedarray.
+    //
+    // `array.slice()` must not be used here: Node.js `Buffer` extends Uint8Array and overrides `slice` to
+    // return a view over the same memory (like `subarray`) rather than a copy, so `.buffer` of the result
+    // would be the entire (possibly pooled) backing buffer, including bytes outside the input view.
+    return new Uint8Array(array).buffer;
 }
 //# sourceMappingURL=bufferShared.js.map

package/dist/bufferShared.js.map

@@ -1 +1 @@
-{"version":3,"file":"bufferShared.js","sourceRoot":"","sources":["../src/bufferShared.ts"],"names":[],"mappings":";AAAA;;;GAGG;;AAaH,oEASC;AAeD,kEAaC;AAiBD,gEAgBC;AAjFD;;;;;;;;;;GAUG;AACH,SAAgB,4BAA4B,CAAC,MAAuB;IACnE,IAAI,MAAM,YAAY,WAAW,EAAE,CAAC;QACnC,OAAO,MAAM,CAAC;IACf,CAAC;IACD,gEAAgE;IAChE,uEAAuE;IACvE,0EAA0E;IAC1E,qGAAqG;IACrG,OAAO,IAAI,UAAU,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,CAAC,MAAM,CAAC;AAC9C,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,2BAA2B,CAC1C,KAA+B;IAE/B,IAAI,KAAK,CAAC,UAAU,KAAK,CAAC,IAAI,KAAK,CAAC,UAAU,KAAK,KAAK,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;QAC5E,OAAO,KAAK,CAAC,MAAM,CAAC;IACrB,CAAC;IACD,6EAA6E;IAC7E,yEAAyE;IACzE,+DAA+D;IAC/D,OAAO,KAAK,CAAC,MAAM,CAAC,KAAK,CACxB,KAAK,CAAC,UAAU,EAChB,KAAK,CAAC,UAAU,GAAG,KAAK,CAAC,UAAU,CACnB,CAAC;AACnB,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,0BAA0B,CAAC,KAAiB;IAC3D,8DAA8D;IAC9D,IACC,KAAK,CAAC,UAAU,KAAK,CAAC;QACtB,KAAK,CAAC,UAAU,KAAK,KAAK,CAAC,MAAM,CAAC,UAAU;QAC5C,KAAK,CAAC,MAAM,YAAY,WAAW,EAClC,CAAC;QACF,OAAO,KAAK,CAAC,MAAM,CAAC;IACrB,CAAC;IACD,iDAAiD;IACjD,kBAAkB;IAClB,iDAAiD;IACjD,0HAA0H;IAC1H,8GAA8G;IAC9G,qGAAqG;IACrG,OAAO,KAAK,CAAC,KAAK,EAAE,CAAC,MAAM,CAAC;AAC7B,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * Distills an `ArrayBuffer` from an `ArrayBufferLike` or creates one from `SharedArrayBuffer` if needed.\n *\n * @param buffer - `ArrayBuffer` or any `ArrayBufferLike` to convert to `ArrayBuffer`.\n *\n * @remarks The returned buffer may be the input array's backing buffer or a copy of its bytes.\n * Callers should not mutate the returned buffer unless they own the input array and its backing\n * storage, and should not rely on mutations being reflected in the input array.\n *\n * @internal\n */\nexport function ArrayBufferLikeToArrayBuffer(buffer: ArrayBufferLike): ArrayBuffer {\n\tif (buffer instanceof ArrayBuffer) {\n\t\treturn buffer;\n\t}\n\t// Use .slice to get `ArrayBuffer` backing that `Blob` requires.\n\t// Note that `buffer.slice` preserves the underlying buffer type, so we\n\t// need to use .slice on a `Uint8Array` to ensure we get an `ArrayBuffer`.\n\t// eslint-disable-next-line unicorn/prefer-spread -- spread is not the same as slice for `Uint8Array`\n\treturn new Uint8Array(buffer).slice().buffer;\n}\n\n/**\n * Distills a `Uint8Array` array to an `ArrayBuffer | SharedArrayBuffer` copying\n * data as needed per the array's `byteOffset` and `byteLength` to have a full\n * buffer (no offset and entire length).\n *\n * @param array - Array to extract buffer from.\n *\n * @remarks The returned buffer may be the input array's backing buffer or a copy of its bytes.\n * Callers should not mutate the returned buffer unless they own the input array and its backing\n * storage, and should not rely on mutations being reflected in the input array.\n *\n * @internal\n */\nexport function Uint8ArrayToArrayBufferLike<TArrayBuffer extends ArrayBufferLike>(\n\tarray: Uint8Array<TArrayBuffer>,\n): TArrayBuffer {\n\tif (array.byteOffset === 0 && array.byteLength === array.buffer.byteLength) {\n\t\treturn array.buffer;\n\t}\n\t// Both ArrayBuffer and SharedArrayBuffer have a slice method and will return\n\t// their same type, but TypeScript does not correctly determine that will\n\t// satisfy TArrayBuffer. Cast to TArrayBuffer to indicate that.\n\treturn array.buffer.slice(\n\t\tarray.byteOffset,\n\t\tarray.byteOffset + array.byteLength,\n\t) as TArrayBuffer;\n}\n\n/**\n * Distills a `Uint8Array` array to an `ArrayBuffer` copying data as needed per the array's\n * `byteOffset` and `byteLength` or if underlying buffer is not `ArrayBuffer`.\n *\n * @param array - Array to convert to `ArrayBuffer`.\n *\n * @remarks The returned buffer may be the input array's backing buffer or a copy of its bytes.\n * Callers should not mutate the returned buffer unless they own the input array and its backing\n * storage, and should not rely on mutations being reflected in the input array.\n *\n * Prefer to use {@link Uint8ArrayToArrayBufferLike} if the call site doesn't require\n * an explicit `ArrayBuffer` (can also handle `SharedArrayBuffer`).\n *\n * @internal\n */\nexport function AnyUint8ArrayToArrayBuffer(array: Uint8Array): ArrayBuffer {\n\t// Shortcut to provider underlying buffer as-is when possible.\n\tif (\n\t\tarray.byteOffset === 0 &&\n\t\tarray.byteLength === array.buffer.byteLength &&\n\t\tarray.buffer instanceof ArrayBuffer\n\t) {\n\t\treturn array.buffer;\n\t}\n\t// .slice is used to ensure underlying buffer is:\n\t//  1. ArrayBuffer\n\t//  2. the complete data (no offset, full length)\n\t// Cloning specified per https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice\n\t// and ECMAScript https://tc39.es/ecma262/multipage/indexed-collections.html#sec-%typedarray%.prototype.slice.\n\t// eslint-disable-next-line unicorn/prefer-spread -- spread is not the same as slice for `Uint8Array`\n\treturn array.slice().buffer;\n}\n"]}
+{"version":3,"file":"bufferShared.js","sourceRoot":"","sources":["../src/bufferShared.ts"],"names":[],"mappings":";AAAA;;;GAGG;;AAaH,oEASC;AAeD,kEAaC;AAiBD,gEAmBC;AApFD;;;;;;;;;;GAUG;AACH,SAAgB,4BAA4B,CAAC,MAAuB;IACnE,IAAI,MAAM,YAAY,WAAW,EAAE,CAAC;QACnC,OAAO,MAAM,CAAC;IACf,CAAC;IACD,gEAAgE;IAChE,uEAAuE;IACvE,0EAA0E;IAC1E,qGAAqG;IACrG,OAAO,IAAI,UAAU,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,CAAC,MAAM,CAAC;AAC9C,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,2BAA2B,CAC1C,KAA+B;IAE/B,IAAI,KAAK,CAAC,UAAU,KAAK,CAAC,IAAI,KAAK,CAAC,UAAU,KAAK,KAAK,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;QAC5E,OAAO,KAAK,CAAC,MAAM,CAAC;IACrB,CAAC;IACD,6EAA6E;IAC7E,yEAAyE;IACzE,+DAA+D;IAC/D,OAAO,KAAK,CAAC,MAAM,CAAC,KAAK,CACxB,KAAK,CAAC,UAAU,EAChB,KAAK,CAAC,UAAU,GAAG,KAAK,CAAC,UAAU,CACnB,CAAC;AACnB,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,0BAA0B,CAAC,KAAiB;IAC3D,8DAA8D;IAC9D,IACC,KAAK,CAAC,UAAU,KAAK,CAAC;QACtB,KAAK,CAAC,UAAU,KAAK,KAAK,CAAC,MAAM,CAAC,UAAU;QAC5C,KAAK,CAAC,MAAM,YAAY,WAAW,EAClC,CAAC;QACF,OAAO,KAAK,CAAC,MAAM,CAAC;IACrB,CAAC;IACD,0EAA0E;IAC1E,kBAAkB;IAClB,iDAAiD;IACjD,oFAAoF;IACpF,8IAA8I;IAC9I,EAAE;IACF,sGAAsG;IACtG,sGAAsG;IACtG,gGAAgG;IAChG,OAAO,IAAI,UAAU,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC;AACrC,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * Distills an `ArrayBuffer` from an `ArrayBufferLike` or creates one from `SharedArrayBuffer` if needed.\n *\n * @param buffer - `ArrayBuffer` or any `ArrayBufferLike` to convert to `ArrayBuffer`.\n *\n * @remarks The returned buffer may be the input array's backing buffer or a copy of its bytes.\n * Callers should not mutate the returned buffer unless they own the input array and its backing\n * storage, and should not rely on mutations being reflected in the input array.\n *\n * @internal\n */\nexport function ArrayBufferLikeToArrayBuffer(buffer: ArrayBufferLike): ArrayBuffer {\n\tif (buffer instanceof ArrayBuffer) {\n\t\treturn buffer;\n\t}\n\t// Use .slice to get `ArrayBuffer` backing that `Blob` requires.\n\t// Note that `buffer.slice` preserves the underlying buffer type, so we\n\t// need to use .slice on a `Uint8Array` to ensure we get an `ArrayBuffer`.\n\t// eslint-disable-next-line unicorn/prefer-spread -- spread is not the same as slice for `Uint8Array`\n\treturn new Uint8Array(buffer).slice().buffer;\n}\n\n/**\n * Distills a `Uint8Array` array to an `ArrayBuffer | SharedArrayBuffer` copying\n * data as needed per the array's `byteOffset` and `byteLength` to have a full\n * buffer (no offset and entire length).\n *\n * @param array - Array to extract buffer from.\n *\n * @remarks The returned buffer may be the input array's backing buffer or a copy of its bytes.\n * Callers should not mutate the returned buffer unless they own the input array and its backing\n * storage, and should not rely on mutations being reflected in the input array.\n *\n * @internal\n */\nexport function Uint8ArrayToArrayBufferLike<TArrayBuffer extends ArrayBufferLike>(\n\tarray: Uint8Array<TArrayBuffer>,\n): TArrayBuffer {\n\tif (array.byteOffset === 0 && array.byteLength === array.buffer.byteLength) {\n\t\treturn array.buffer;\n\t}\n\t// Both ArrayBuffer and SharedArrayBuffer have a slice method and will return\n\t// their same type, but TypeScript does not correctly determine that will\n\t// satisfy TArrayBuffer. Cast to TArrayBuffer to indicate that.\n\treturn array.buffer.slice(\n\t\tarray.byteOffset,\n\t\tarray.byteOffset + array.byteLength,\n\t) as TArrayBuffer;\n}\n\n/**\n * Distills a `Uint8Array` array to an `ArrayBuffer` copying data as needed per the array's\n * `byteOffset` and `byteLength` or if underlying buffer is not `ArrayBuffer`.\n *\n * @param array - Array to convert to `ArrayBuffer`.\n *\n * @remarks The returned buffer may be the input array's backing buffer or a copy of its bytes.\n * Callers should not mutate the returned buffer unless they own the input array and its backing\n * storage, and should not rely on mutations being reflected in the input array.\n *\n * Prefer to use {@link Uint8ArrayToArrayBufferLike} if the call site doesn't require\n * an explicit `ArrayBuffer` (can also handle `SharedArrayBuffer`).\n *\n * @internal\n */\nexport function AnyUint8ArrayToArrayBuffer(array: Uint8Array): ArrayBuffer {\n\t// Shortcut to provider underlying buffer as-is when possible.\n\tif (\n\t\tarray.byteOffset === 0 &&\n\t\tarray.byteLength === array.buffer.byteLength &&\n\t\tarray.buffer instanceof ArrayBuffer\n\t) {\n\t\treturn array.buffer;\n\t}\n\t// Copy into a new `Uint8Array` so that the result's underlying buffer is:\n\t//  1. ArrayBuffer\n\t//  2. the complete data (no offset, full length)\n\t// Constructing from a typed array always allocates a fresh `ArrayBuffer` of exactly\n\t// `array.byteLength` bytes. See ECMAScript https://tc39.es/ecma262/multipage/indexed-collections.html#sec-initializetypedarrayfromtypedarray.\n\t//\n\t// `array.slice()` must not be used here: Node.js `Buffer` extends Uint8Array and overrides `slice` to\n\t// return a view over the same memory (like `subarray`) rather than a copy, so `.buffer` of the result\n\t// would be the entire (possibly pooled) backing buffer, including bytes outside the input view.\n\treturn new Uint8Array(array).buffer;\n}\n"]}

package/lib/bufferShared.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bufferShared.d.ts","sourceRoot":"","sources":["../src/bufferShared.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;GAUG;AACH,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,eAAe,GAAG,WAAW,CASjF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,2BAA2B,CAAC,YAAY,SAAS,eAAe,EAC/E,KAAK,EAAE,UAAU,CAAC,YAAY,CAAC,GAC7B,YAAY,CAWd;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,CAgBzE"}
+{"version":3,"file":"bufferShared.d.ts","sourceRoot":"","sources":["../src/bufferShared.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;GAUG;AACH,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,eAAe,GAAG,WAAW,CASjF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,2BAA2B,CAAC,YAAY,SAAS,eAAe,EAC/E,KAAK,EAAE,UAAU,CAAC,YAAY,CAAC,GAC7B,YAAY,CAWd;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,CAmBzE"}

package/lib/bufferShared.js

@@ -67,12 +67,15 @@ export function AnyUint8ArrayToArrayBuffer(array) {
         array.buffer instanceof ArrayBuffer) {
         return array.buffer;
     }
-    // .slice is used to ensure underlying buffer is:
+    // Copy into a new `Uint8Array` so that the result's underlying buffer is:
     //  1. ArrayBuffer
     //  2. the complete data (no offset, full length)
-    // Cloning specified per https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
-    // and ECMAScript https://tc39.es/ecma262/multipage/indexed-collections.html#sec-%typedarray%.prototype.slice.
-    // eslint-disable-next-line unicorn/prefer-spread -- spread is not the same as slice for `Uint8Array`
-    return array.slice().buffer;
+    // Constructing from a typed array always allocates a fresh `ArrayBuffer` of exactly
+    // `array.byteLength` bytes. See ECMAScript https://tc39.es/ecma262/multipage/indexed-collections.html#sec-initializetypedarrayfromtypedarray.
+    //
+    // `array.slice()` must not be used here: Node.js `Buffer` extends Uint8Array and overrides `slice` to
+    // return a view over the same memory (like `subarray`) rather than a copy, so `.buffer` of the result
+    // would be the entire (possibly pooled) backing buffer, including bytes outside the input view.
+    return new Uint8Array(array).buffer;
 }
 //# sourceMappingURL=bufferShared.js.map

package/lib/bufferShared.js.map

@@ -1 +1 @@
-{"version":3,"file":"bufferShared.js","sourceRoot":"","sources":["../src/bufferShared.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;GAUG;AACH,MAAM,UAAU,4BAA4B,CAAC,MAAuB;IACnE,IAAI,MAAM,YAAY,WAAW,EAAE,CAAC;QACnC,OAAO,MAAM,CAAC;IACf,CAAC;IACD,gEAAgE;IAChE,uEAAuE;IACvE,0EAA0E;IAC1E,qGAAqG;IACrG,OAAO,IAAI,UAAU,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,CAAC,MAAM,CAAC;AAC9C,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,2BAA2B,CAC1C,KAA+B;IAE/B,IAAI,KAAK,CAAC,UAAU,KAAK,CAAC,IAAI,KAAK,CAAC,UAAU,KAAK,KAAK,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;QAC5E,OAAO,KAAK,CAAC,MAAM,CAAC;IACrB,CAAC;IACD,6EAA6E;IAC7E,yEAAyE;IACzE,+DAA+D;IAC/D,OAAO,KAAK,CAAC,MAAM,CAAC,KAAK,CACxB,KAAK,CAAC,UAAU,EAChB,KAAK,CAAC,UAAU,GAAG,KAAK,CAAC,UAAU,CACnB,CAAC;AACnB,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,0BAA0B,CAAC,KAAiB;IAC3D,8DAA8D;IAC9D,IACC,KAAK,CAAC,UAAU,KAAK,CAAC;QACtB,KAAK,CAAC,UAAU,KAAK,KAAK,CAAC,MAAM,CAAC,UAAU;QAC5C,KAAK,CAAC,MAAM,YAAY,WAAW,EAClC,CAAC;QACF,OAAO,KAAK,CAAC,MAAM,CAAC;IACrB,CAAC;IACD,iDAAiD;IACjD,kBAAkB;IAClB,iDAAiD;IACjD,0HAA0H;IAC1H,8GAA8G;IAC9G,qGAAqG;IACrG,OAAO,KAAK,CAAC,KAAK,EAAE,CAAC,MAAM,CAAC;AAC7B,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * Distills an `ArrayBuffer` from an `ArrayBufferLike` or creates one from `SharedArrayBuffer` if needed.\n *\n * @param buffer - `ArrayBuffer` or any `ArrayBufferLike` to convert to `ArrayBuffer`.\n *\n * @remarks The returned buffer may be the input array's backing buffer or a copy of its bytes.\n * Callers should not mutate the returned buffer unless they own the input array and its backing\n * storage, and should not rely on mutations being reflected in the input array.\n *\n * @internal\n */\nexport function ArrayBufferLikeToArrayBuffer(buffer: ArrayBufferLike): ArrayBuffer {\n\tif (buffer instanceof ArrayBuffer) {\n\t\treturn buffer;\n\t}\n\t// Use .slice to get `ArrayBuffer` backing that `Blob` requires.\n\t// Note that `buffer.slice` preserves the underlying buffer type, so we\n\t// need to use .slice on a `Uint8Array` to ensure we get an `ArrayBuffer`.\n\t// eslint-disable-next-line unicorn/prefer-spread -- spread is not the same as slice for `Uint8Array`\n\treturn new Uint8Array(buffer).slice().buffer;\n}\n\n/**\n * Distills a `Uint8Array` array to an `ArrayBuffer | SharedArrayBuffer` copying\n * data as needed per the array's `byteOffset` and `byteLength` to have a full\n * buffer (no offset and entire length).\n *\n * @param array - Array to extract buffer from.\n *\n * @remarks The returned buffer may be the input array's backing buffer or a copy of its bytes.\n * Callers should not mutate the returned buffer unless they own the input array and its backing\n * storage, and should not rely on mutations being reflected in the input array.\n *\n * @internal\n */\nexport function Uint8ArrayToArrayBufferLike<TArrayBuffer extends ArrayBufferLike>(\n\tarray: Uint8Array<TArrayBuffer>,\n): TArrayBuffer {\n\tif (array.byteOffset === 0 && array.byteLength === array.buffer.byteLength) {\n\t\treturn array.buffer;\n\t}\n\t// Both ArrayBuffer and SharedArrayBuffer have a slice method and will return\n\t// their same type, but TypeScript does not correctly determine that will\n\t// satisfy TArrayBuffer. Cast to TArrayBuffer to indicate that.\n\treturn array.buffer.slice(\n\t\tarray.byteOffset,\n\t\tarray.byteOffset + array.byteLength,\n\t) as TArrayBuffer;\n}\n\n/**\n * Distills a `Uint8Array` array to an `ArrayBuffer` copying data as needed per the array's\n * `byteOffset` and `byteLength` or if underlying buffer is not `ArrayBuffer`.\n *\n * @param array - Array to convert to `ArrayBuffer`.\n *\n * @remarks The returned buffer may be the input array's backing buffer or a copy of its bytes.\n * Callers should not mutate the returned buffer unless they own the input array and its backing\n * storage, and should not rely on mutations being reflected in the input array.\n *\n * Prefer to use {@link Uint8ArrayToArrayBufferLike} if the call site doesn't require\n * an explicit `ArrayBuffer` (can also handle `SharedArrayBuffer`).\n *\n * @internal\n */\nexport function AnyUint8ArrayToArrayBuffer(array: Uint8Array): ArrayBuffer {\n\t// Shortcut to provider underlying buffer as-is when possible.\n\tif (\n\t\tarray.byteOffset === 0 &&\n\t\tarray.byteLength === array.buffer.byteLength &&\n\t\tarray.buffer instanceof ArrayBuffer\n\t) {\n\t\treturn array.buffer;\n\t}\n\t// .slice is used to ensure underlying buffer is:\n\t//  1. ArrayBuffer\n\t//  2. the complete data (no offset, full length)\n\t// Cloning specified per https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice\n\t// and ECMAScript https://tc39.es/ecma262/multipage/indexed-collections.html#sec-%typedarray%.prototype.slice.\n\t// eslint-disable-next-line unicorn/prefer-spread -- spread is not the same as slice for `Uint8Array`\n\treturn array.slice().buffer;\n}\n"]}
+{"version":3,"file":"bufferShared.js","sourceRoot":"","sources":["../src/bufferShared.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;GAUG;AACH,MAAM,UAAU,4BAA4B,CAAC,MAAuB;IACnE,IAAI,MAAM,YAAY,WAAW,EAAE,CAAC;QACnC,OAAO,MAAM,CAAC;IACf,CAAC;IACD,gEAAgE;IAChE,uEAAuE;IACvE,0EAA0E;IAC1E,qGAAqG;IACrG,OAAO,IAAI,UAAU,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,CAAC,MAAM,CAAC;AAC9C,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,2BAA2B,CAC1C,KAA+B;IAE/B,IAAI,KAAK,CAAC,UAAU,KAAK,CAAC,IAAI,KAAK,CAAC,UAAU,KAAK,KAAK,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;QAC5E,OAAO,KAAK,CAAC,MAAM,CAAC;IACrB,CAAC;IACD,6EAA6E;IAC7E,yEAAyE;IACzE,+DAA+D;IAC/D,OAAO,KAAK,CAAC,MAAM,CAAC,KAAK,CACxB,KAAK,CAAC,UAAU,EAChB,KAAK,CAAC,UAAU,GAAG,KAAK,CAAC,UAAU,CACnB,CAAC;AACnB,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,0BAA0B,CAAC,KAAiB;IAC3D,8DAA8D;IAC9D,IACC,KAAK,CAAC,UAAU,KAAK,CAAC;QACtB,KAAK,CAAC,UAAU,KAAK,KAAK,CAAC,MAAM,CAAC,UAAU;QAC5C,KAAK,CAAC,MAAM,YAAY,WAAW,EAClC,CAAC;QACF,OAAO,KAAK,CAAC,MAAM,CAAC;IACrB,CAAC;IACD,0EAA0E;IAC1E,kBAAkB;IAClB,iDAAiD;IACjD,oFAAoF;IACpF,8IAA8I;IAC9I,EAAE;IACF,sGAAsG;IACtG,sGAAsG;IACtG,gGAAgG;IAChG,OAAO,IAAI,UAAU,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC;AACrC,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * Distills an `ArrayBuffer` from an `ArrayBufferLike` or creates one from `SharedArrayBuffer` if needed.\n *\n * @param buffer - `ArrayBuffer` or any `ArrayBufferLike` to convert to `ArrayBuffer`.\n *\n * @remarks The returned buffer may be the input array's backing buffer or a copy of its bytes.\n * Callers should not mutate the returned buffer unless they own the input array and its backing\n * storage, and should not rely on mutations being reflected in the input array.\n *\n * @internal\n */\nexport function ArrayBufferLikeToArrayBuffer(buffer: ArrayBufferLike): ArrayBuffer {\n\tif (buffer instanceof ArrayBuffer) {\n\t\treturn buffer;\n\t}\n\t// Use .slice to get `ArrayBuffer` backing that `Blob` requires.\n\t// Note that `buffer.slice` preserves the underlying buffer type, so we\n\t// need to use .slice on a `Uint8Array` to ensure we get an `ArrayBuffer`.\n\t// eslint-disable-next-line unicorn/prefer-spread -- spread is not the same as slice for `Uint8Array`\n\treturn new Uint8Array(buffer).slice().buffer;\n}\n\n/**\n * Distills a `Uint8Array` array to an `ArrayBuffer | SharedArrayBuffer` copying\n * data as needed per the array's `byteOffset` and `byteLength` to have a full\n * buffer (no offset and entire length).\n *\n * @param array - Array to extract buffer from.\n *\n * @remarks The returned buffer may be the input array's backing buffer or a copy of its bytes.\n * Callers should not mutate the returned buffer unless they own the input array and its backing\n * storage, and should not rely on mutations being reflected in the input array.\n *\n * @internal\n */\nexport function Uint8ArrayToArrayBufferLike<TArrayBuffer extends ArrayBufferLike>(\n\tarray: Uint8Array<TArrayBuffer>,\n): TArrayBuffer {\n\tif (array.byteOffset === 0 && array.byteLength === array.buffer.byteLength) {\n\t\treturn array.buffer;\n\t}\n\t// Both ArrayBuffer and SharedArrayBuffer have a slice method and will return\n\t// their same type, but TypeScript does not correctly determine that will\n\t// satisfy TArrayBuffer. Cast to TArrayBuffer to indicate that.\n\treturn array.buffer.slice(\n\t\tarray.byteOffset,\n\t\tarray.byteOffset + array.byteLength,\n\t) as TArrayBuffer;\n}\n\n/**\n * Distills a `Uint8Array` array to an `ArrayBuffer` copying data as needed per the array's\n * `byteOffset` and `byteLength` or if underlying buffer is not `ArrayBuffer`.\n *\n * @param array - Array to convert to `ArrayBuffer`.\n *\n * @remarks The returned buffer may be the input array's backing buffer or a copy of its bytes.\n * Callers should not mutate the returned buffer unless they own the input array and its backing\n * storage, and should not rely on mutations being reflected in the input array.\n *\n * Prefer to use {@link Uint8ArrayToArrayBufferLike} if the call site doesn't require\n * an explicit `ArrayBuffer` (can also handle `SharedArrayBuffer`).\n *\n * @internal\n */\nexport function AnyUint8ArrayToArrayBuffer(array: Uint8Array): ArrayBuffer {\n\t// Shortcut to provider underlying buffer as-is when possible.\n\tif (\n\t\tarray.byteOffset === 0 &&\n\t\tarray.byteLength === array.buffer.byteLength &&\n\t\tarray.buffer instanceof ArrayBuffer\n\t) {\n\t\treturn array.buffer;\n\t}\n\t// Copy into a new `Uint8Array` so that the result's underlying buffer is:\n\t//  1. ArrayBuffer\n\t//  2. the complete data (no offset, full length)\n\t// Constructing from a typed array always allocates a fresh `ArrayBuffer` of exactly\n\t// `array.byteLength` bytes. See ECMAScript https://tc39.es/ecma262/multipage/indexed-collections.html#sec-initializetypedarrayfromtypedarray.\n\t//\n\t// `array.slice()` must not be used here: Node.js `Buffer` extends Uint8Array and overrides `slice` to\n\t// return a view over the same memory (like `subarray`) rather than a copy, so `.buffer` of the result\n\t// would be the entire (possibly pooled) backing buffer, including bytes outside the input view.\n\treturn new Uint8Array(array).buffer;\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluid-internal/client-utils",
-  "version": "3.6.0",
+  "version": "3.7.0",
   "description": "Not intended for use outside the Fluid Framework.",
   "homepage": "https://fluidframework.com",
   "repository": {
@@ -63,7 +63,7 @@
     "temp-directory": "nyc/.nyc_output"
   },
   "dependencies": {
-    "@fluidframework/core-interfaces": "~3.6.0",
+    "@fluidframework/core-interfaces": "~3.7.0",
     "@types/events_pkg": "npm:@types/events@^3.0.0",
     "base64-js": "^1.5.1",
     "buffer": "^6.0.3",
@@ -73,8 +73,8 @@
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.18.5",
     "@biomejs/biome": "~2.4.5",
-    "@fluid-internal/client-utils-previous": "npm:@fluid-internal/client-utils@3.5.0",
-    "@fluid-internal/mocha-test-setup": "~3.6.0",
+    "@fluid-internal/client-utils-previous": "npm:@fluid-internal/client-utils@3.6.0",
+    "@fluid-internal/mocha-test-setup": "~3.7.0",
     "@fluid-tools/build-cli": "^0.68.0",
     "@fluidframework/build-common": "^2.0.3",
     "@fluidframework/build-tools": "^0.68.0",

package/src/bufferShared.ts

@@ -77,11 +77,14 @@ export function AnyUint8ArrayToArrayBuffer(array: Uint8Array): ArrayBuffer {
 	) {
 		return array.buffer;
 	}
-	// .slice is used to ensure underlying buffer is:
+	// Copy into a new `Uint8Array` so that the result's underlying buffer is:
 	//  1. ArrayBuffer
 	//  2. the complete data (no offset, full length)
-	// Cloning specified per https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
-	// and ECMAScript https://tc39.es/ecma262/multipage/indexed-collections.html#sec-%typedarray%.prototype.slice.
-	// eslint-disable-next-line unicorn/prefer-spread -- spread is not the same as slice for `Uint8Array`
-	return array.slice().buffer;
+	// Constructing from a typed array always allocates a fresh `ArrayBuffer` of exactly
+	// `array.byteLength` bytes. See ECMAScript https://tc39.es/ecma262/multipage/indexed-collections.html#sec-initializetypedarrayfromtypedarray.
+	//
+	// `array.slice()` must not be used here: Node.js `Buffer` extends Uint8Array and overrides `slice` to
+	// return a view over the same memory (like `subarray`) rather than a copy, so `.buffer` of the result
+	// would be the entire (possibly pooled) backing buffer, including bytes outside the input view.
+	return new Uint8Array(array).buffer;
 }