@azure/cosmos 4.9.2 → 4.9.3

package/dist/commonjs/session/VectorSessionToken.js

@@ -39,6 +39,10 @@ class VectorSessionToken {
       }
     }
   }
+  version;
+  globalLsn;
+  localLsnByregion;
+  sessionToken;
   static SEGMENT_SEPARATOR = "#";
   static REGION_PROGRESS_SEPARATOR = "=";
   static create(sessionToken) {
@@ -133,3 +137,4 @@ function max(int1, int2) {
 0 && (module.exports = {
   VectorSessionToken
 });
+//# sourceMappingURL=VectorSessionToken.js.map

package/dist/commonjs/session/VectorSessionToken.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
-  "sources": ["/mnt/vss/_work/1/s/sdk/cosmosdb/cosmos/src/session/VectorSessionToken.ts"],
+  "sources": ["../../../src/session/VectorSessionToken.ts"],
   "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n/**\n * Models vector clock bases session token. Session token has the following format:\n * `{Version}#{GlobalLSN}#{RegionId1}={LocalLsn1}#{RegionId2}={LocalLsn2}....#{RegionIdN}={LocalLsnN}`\n * 'Version' captures the configuration number of the partition which returned this session token.\n * 'Version' is incremented everytime topology of the partition is updated (say due to Add/Remove/Failover).\n *\n * The choice of separators '#' and '=' is important. Separators ';' and ',' are used to delimit\n * per-partitionKeyRange session token\n * @hidden\n *\n */\nexport class VectorSessionToken {\n  private static readonly SEGMENT_SEPARATOR = \"#\";\n  private static readonly REGION_PROGRESS_SEPARATOR = \"=\";\n\n  constructor(\n    private readonly version: number,\n    private readonly globalLsn: number,\n    private readonly localLsnByregion: Map<number, string>,\n    private readonly sessionToken?: string,\n  ) {\n    if (!this.sessionToken) {\n      const regionAndLocalLsn = [];\n      for (const [key, value] of this.localLsnByregion.entries()) {\n        regionAndLocalLsn.push(`${key}${VectorSessionToken.REGION_PROGRESS_SEPARATOR}${value}`);\n      }\n      const regionProgress = regionAndLocalLsn.join(VectorSessionToken.SEGMENT_SEPARATOR);\n      if (regionProgress === \"\") {\n        this.sessionToken = `${this.version}${VectorSessionToken.SEGMENT_SEPARATOR}${this.globalLsn}`;\n      } else {\n        this.sessionToken = `${this.version}${VectorSessionToken.SEGMENT_SEPARATOR}${this.globalLsn}${VectorSessionToken.SEGMENT_SEPARATOR}${regionProgress}`;\n      }\n    }\n  }\n\n  public static create(sessionToken: string): VectorSessionToken | null {\n    const [versionStr, globalLsnStr, ...regionSegments] = sessionToken.split(\n      VectorSessionToken.SEGMENT_SEPARATOR,\n    );\n\n    const version = parseInt(versionStr, 10);\n    const globalLsn = parseFloat(globalLsnStr);\n\n    if (typeof version !== \"number\" || typeof globalLsn !== \"number\") {\n      return null;\n    }\n\n    const lsnByRegion = new Map<number, string>();\n    for (const regionSegment of regionSegments) {\n      const [regionIdStr, localLsnStr] = regionSegment.split(\n        VectorSessionToken.REGION_PROGRESS_SEPARATOR,\n      );\n\n      if (!regionIdStr || !localLsnStr) {\n        return null;\n      }\n\n      const regionId = parseInt(regionIdStr, 10);\n      let localLsn: string;\n      try {\n        localLsn = localLsnStr;\n      } catch (err: any) {\n        // TODO: log error\n        return null;\n      }\n      if (typeof regionId !== \"number\") {\n        return null;\n      }\n\n      lsnByRegion.set(regionId, localLsn);\n    }\n\n    return new VectorSessionToken(version, globalLsn, lsnByRegion, sessionToken);\n  }\n\n  public equals(other: VectorSessionToken): boolean {\n    return !other\n      ? false\n      : this.version === other.version &&\n          this.globalLsn === other.globalLsn &&\n          this.areRegionProgressEqual(other.localLsnByregion);\n  }\n\n  public merge(other: VectorSessionToken): VectorSessionToken {\n    if (other == null) {\n      throw new Error(\"other (Vector Session Token) must not be null\");\n    }\n\n    if (\n      this.version === other.version &&\n      this.localLsnByregion.size !== other.localLsnByregion.size\n    ) {\n      throw new Error(\n        `Compared session tokens ${this.sessionToken} and ${other.sessionToken} have unexpected regions`,\n      );\n    }\n\n    const [higherVersionSessionToken, lowerVersionSessionToken]: [\n      VectorSessionToken,\n      VectorSessionToken,\n    ] = this.version < other.version ? [other, this] : [this, other];\n\n    const highestLocalLsnByRegion = new Map<number, string>();\n\n    for (const [regionId, highLocalLsn] of higherVersionSessionToken.localLsnByregion.entries()) {\n      const lowLocalLsn = lowerVersionSessionToken.localLsnByregion.get(regionId);\n      if (lowLocalLsn) {\n        highestLocalLsnByRegion.set(regionId, max(highLocalLsn, lowLocalLsn));\n      } else if (this.version === other.version) {\n        throw new Error(\n          `Compared session tokens have unexpected regions. Session 1: ${this.sessionToken} - Session 2: ${this.sessionToken}`,\n        );\n      } else {\n        highestLocalLsnByRegion.set(regionId, highLocalLsn);\n      }\n    }\n\n    return new VectorSessionToken(\n      Math.max(this.version, other.version),\n      Math.max(this.globalLsn, other.globalLsn),\n      highestLocalLsnByRegion,\n    );\n  }\n\n  public toString(): string | undefined {\n    return this.sessionToken;\n  }\n\n  private areRegionProgressEqual(other: Map<number, string>): boolean {\n    if (this.localLsnByregion.size !== other.size) {\n      return false;\n    }\n\n    for (const [regionId, localLsn] of this.localLsnByregion.entries()) {\n      const otherLocalLsn = other.get(regionId);\n\n      if (localLsn !== otherLocalLsn) {\n        return false;\n      }\n    }\n    return true;\n  }\n}\n\n/**\n * @hidden\n */\nfunction max(int1: string, int2: string): string {\n  // NOTE: This only works for positive numbers\n  if (int1.length === int2.length) {\n    return int1 > int2 ? int1 : int2;\n  } else if (int1.length > int2.length) {\n    return int1;\n  } else {\n    return int2;\n  }\n}\n"],
-  "mappings": "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",
+  "mappings": "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",
   "names": []
 }

package/dist/commonjs/session/sessionContainer.js

@@ -38,6 +38,8 @@ class SessionContainer {
     this.collectionNameToCollectionResourceId = collectionNameToCollectionResourceId;
     this.collectionResourceIdToSessionTokens = collectionResourceIdToSessionTokens;
   }
+  collectionNameToCollectionResourceId;
+  collectionResourceIdToSessionTokens;
   static EMPTY_SESSION_TOKEN = "";
   static SESSION_TOKEN_SEPARATOR = ",";
   static SESSION_TOKEN_PARTITION_SPLITTER = ":";
@@ -142,3 +144,4 @@ class SessionContainer {
 0 && (module.exports = {
   SessionContainer
 });
+//# sourceMappingURL=sessionContainer.js.map

package/dist/commonjs/session/sessionContainer.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
-  "sources": ["/mnt/vss/_work/1/s/sdk/cosmosdb/cosmos/src/session/sessionContainer.ts"],
+  "sources": ["../../../src/session/sessionContainer.ts"],
   "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\nimport atob from \"../utils/atob.js\";\nimport type { ResourceType } from \"../common/index.js\";\nimport { Constants, getContainerLink, OperationType, trimSlashes } from \"../common/index.js\";\nimport type { CosmosHeaders } from \"../queryExecutionContext/index.js\";\nimport type { SessionContext } from \"./SessionContext.js\";\nimport { VectorSessionToken } from \"./VectorSessionToken.js\";\n\n/** @hidden */\nexport class SessionContainer {\n  private static readonly EMPTY_SESSION_TOKEN = \"\";\n  private static readonly SESSION_TOKEN_SEPARATOR = \",\";\n  private static readonly SESSION_TOKEN_PARTITION_SPLITTER = \":\";\n  constructor(\n    private collectionNameToCollectionResourceId = new Map<string, string>(),\n    private collectionResourceIdToSessionTokens = new Map<\n      string,\n      Map<string, VectorSessionToken>\n    >(),\n  ) {}\n\n  public get(request: SessionContext): string {\n    if (!request) {\n      throw new Error(\"request cannot be null\");\n    }\n    const collectionName = getContainerLink(trimSlashes(request.resourceAddress));\n    const rangeIdToTokenMap = this.getPartitionKeyRangeIdToTokenMap(collectionName);\n    return SessionContainer.getCombinedSessionTokenString(rangeIdToTokenMap);\n  }\n\n  public remove(request: SessionContext): void {\n    let collectionResourceId: string;\n    const resourceAddress = trimSlashes(request.resourceAddress);\n    const collectionName = getContainerLink(resourceAddress);\n    if (collectionName) {\n      collectionResourceId = this.collectionNameToCollectionResourceId.get(collectionName);\n      this.collectionNameToCollectionResourceId.delete(collectionName);\n    }\n    if (collectionResourceId !== undefined) {\n      this.collectionResourceIdToSessionTokens.delete(collectionResourceId);\n    }\n  }\n\n  public set(request: SessionContext, resHeaders: CosmosHeaders): void {\n    // TODO: we check the master logic a few different places. Might not need it.\n    if (\n      !resHeaders ||\n      SessionContainer.isReadingFromMaster(request.resourceType, request.operationType)\n    ) {\n      return;\n    }\n\n    const sessionTokenString = resHeaders[Constants.HttpHeaders.SessionToken];\n    if (!sessionTokenString) {\n      return;\n    }\n\n    const containerName = this.getContainerName(request, resHeaders);\n\n    const ownerId = !request.isNameBased\n      ? request.resourceId\n      : resHeaders[Constants.HttpHeaders.OwnerId] || request.resourceId;\n\n    if (!ownerId) {\n      return;\n    }\n\n    if (containerName && this.validateOwnerID(ownerId)) {\n      if (!this.collectionResourceIdToSessionTokens.has(ownerId)) {\n        this.collectionResourceIdToSessionTokens.set(ownerId, new Map());\n      }\n\n      if (!this.collectionNameToCollectionResourceId.has(containerName)) {\n        this.collectionNameToCollectionResourceId.set(containerName, ownerId);\n      }\n\n      const containerSessionContainer = this.collectionResourceIdToSessionTokens.get(ownerId);\n      SessionContainer.compareAndSetToken(sessionTokenString, containerSessionContainer);\n    }\n  }\n\n  private validateOwnerID(ownerId: string): boolean {\n    // If ownerId contains exactly 8 bytes it represents a unique database+collection identifier. Otherwise it represents another resource\n    // The first 4 bytes are the database. The last 4 bytes are the collection.\n    // Cosmos rids potentially contain \"-\" which is an invalid character in the browser atob implementation\n    // See https://en.wikipedia.org/wiki/Base64#Filenames\n    return atob(ownerId.replace(/-/g, \"/\")).length === 8;\n  }\n\n  private getPartitionKeyRangeIdToTokenMap(\n    collectionName: string,\n  ): Map<string, VectorSessionToken> {\n    let rangeIdToTokenMap: Map<string, VectorSessionToken> = null;\n    if (collectionName && this.collectionNameToCollectionResourceId.has(collectionName)) {\n      rangeIdToTokenMap = this.collectionResourceIdToSessionTokens.get(\n        this.collectionNameToCollectionResourceId.get(collectionName),\n      );\n    }\n\n    return rangeIdToTokenMap;\n  }\n\n  private static getCombinedSessionTokenString(tokens: Map<string, VectorSessionToken>): string {\n    if (!tokens || tokens.size === 0) {\n      return SessionContainer.EMPTY_SESSION_TOKEN;\n    }\n\n    let result = \"\";\n    for (const [range, token] of tokens.entries()) {\n      result +=\n        range +\n        SessionContainer.SESSION_TOKEN_PARTITION_SPLITTER +\n        token.toString() +\n        SessionContainer.SESSION_TOKEN_SEPARATOR;\n    }\n    return result.slice(0, -1);\n  }\n\n  private static compareAndSetToken(\n    newTokenString: string,\n    containerSessionTokens: Map<string, VectorSessionToken>,\n  ): void {\n    if (!newTokenString) {\n      return;\n    }\n\n    const partitionsParts = newTokenString.split(SessionContainer.SESSION_TOKEN_SEPARATOR);\n    for (const partitionPart of partitionsParts) {\n      const newTokenParts = partitionPart.split(SessionContainer.SESSION_TOKEN_PARTITION_SPLITTER);\n      if (newTokenParts.length !== 2) {\n        return;\n      }\n\n      const range = newTokenParts[0];\n      const newToken = VectorSessionToken.create(newTokenParts[1]);\n      const tokenForRange = !containerSessionTokens.get(range)\n        ? newToken\n        : containerSessionTokens.get(range).merge(newToken);\n      containerSessionTokens.set(range, tokenForRange);\n    }\n  }\n\n  // TODO: have a assert if the type doesn't mastch known types\n  private static isReadingFromMaster(\n    resourceType: ResourceType,\n    operationType: OperationType,\n  ): boolean {\n    if (\n      resourceType === Constants.Path.OffersPathSegment ||\n      resourceType === Constants.Path.DatabasesPathSegment ||\n      resourceType === Constants.Path.UsersPathSegment ||\n      resourceType === Constants.Path.PermissionsPathSegment ||\n      resourceType === Constants.Path.TopologyPathSegment ||\n      resourceType === Constants.Path.DatabaseAccountPathSegment ||\n      resourceType === Constants.Path.PartitionKeyRangesPathSegment ||\n      (resourceType === Constants.Path.CollectionsPathSegment &&\n        operationType === OperationType.Query)\n    ) {\n      return true;\n    }\n\n    return false;\n  }\n\n  private getContainerName(request: SessionContext, headers: CosmosHeaders): string {\n    let ownerFullName = headers[Constants.HttpHeaders.OwnerFullName];\n    if (!ownerFullName) {\n      ownerFullName = trimSlashes(request.resourceAddress);\n    }\n\n    return getContainerLink(ownerFullName as string);\n  }\n}\n"],
-  "mappings": "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",
+  "mappings": "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",
   "names": ["atob"]
 }

package/dist/commonjs/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.57.6"
+      "packageVersion": "7.58.2"
     }
   ]
 }

package/dist/commonjs/utils/SasToken.js

@@ -107,3 +107,4 @@ function utcsecondsSinceEpoch(date) {
   createAuthorizationSasToken,
   utcsecondsSinceEpoch
 });
+//# sourceMappingURL=SasToken.js.map

package/dist/commonjs/utils/SasToken.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["/mnt/vss/_work/1/s/sdk/cosmosdb/cosmos/src/utils/SasToken.ts"],
+  "sources": ["../../../src/utils/SasToken.ts"],
   "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { SasTokenProperties } from \"../client/SasToken/SasTokenProperties.js\";\nimport { Constants, CosmosKeyType, SasTokenPermissionKind } from \"../common/index.js\";\nimport { encodeUTF8 } from \"./encode.js\";\nimport { hmac } from \"./hmac.js\";\n\n/**\n * Experimental internal only\n * Generates the payload representing the permission configuration for the sas token.\n */\n\nexport async function createAuthorizationSasToken(\n  masterKey: string,\n  sasTokenProperties: SasTokenProperties,\n): Promise<string> {\n  let resourcePrefixPath = \"\";\n  if (\n    typeof sasTokenProperties.databaseName === \"string\" &&\n    sasTokenProperties.databaseName !== \"\"\n  ) {\n    resourcePrefixPath += `/${Constants.Path.DatabasesPathSegment}/${sasTokenProperties.databaseName}`;\n  }\n\n  if (\n    typeof sasTokenProperties.containerName === \"string\" &&\n    sasTokenProperties.containerName !== \"\"\n  ) {\n    if (sasTokenProperties.databaseName === \"\") {\n      throw new Error(`illegalArgumentException : ${sasTokenProperties.databaseName} \\\n                          is an invalid database name`);\n    }\n    resourcePrefixPath += `/${Constants.Path.CollectionsPathSegment}/${sasTokenProperties.containerName}`;\n  }\n\n  if (\n    typeof sasTokenProperties.resourceName === \"string\" &&\n    sasTokenProperties.resourceName !== \"\"\n  ) {\n    if (sasTokenProperties.containerName === \"\") {\n      throw new Error(`illegalArgumentException : ${sasTokenProperties.containerName} \\\n                          is an invalid container name`);\n    }\n    switch (sasTokenProperties.resourceKind) {\n      case \"ITEM\":\n        resourcePrefixPath += `${Constants.Path.Root}${Constants.Path.DocumentsPathSegment}`;\n        break;\n      case \"STORED_PROCEDURE\":\n        resourcePrefixPath += `${Constants.Path.Root}${Constants.Path.StoredProceduresPathSegment}`;\n        break;\n      case \"USER_DEFINED_FUNCTION\":\n        resourcePrefixPath += `${Constants.Path.Root}${Constants.Path.UserDefinedFunctionsPathSegment}`;\n        break;\n      case \"TRIGGER\":\n        resourcePrefixPath += `${Constants.Path.Root}${Constants.Path.TriggersPathSegment}`;\n        break;\n      default:\n        throw new Error(`illegalArgumentException : ${sasTokenProperties.resourceKind} \\\n                          is an invalid resource kind`);\n        break;\n    }\n    resourcePrefixPath += `${Constants.Path.Root}${sasTokenProperties.resourceName}${Constants.Path.Root}`;\n  }\n  sasTokenProperties.resourcePath = resourcePrefixPath.toString();\n\n  let partitionRanges = \"\";\n\n  if (\n    sasTokenProperties.partitionKeyValueRanges !== undefined &&\n    sasTokenProperties.partitionKeyValueRanges.length > 0\n  ) {\n    if (\n      typeof sasTokenProperties.resourceKind !== \"string\" &&\n      sasTokenProperties.resourceKind !== \"ITEM\"\n    ) {\n      throw new Error(`illegalArgumentException : ${sasTokenProperties.resourceKind} \\\n                          is an invalid partition key value range`);\n    }\n    sasTokenProperties.partitionKeyValueRanges.forEach((range) => {\n      partitionRanges += `${encodeUTF8(range)},`;\n    });\n  }\n\n  if (sasTokenProperties.controlPlaneReaderScope === 0) {\n    sasTokenProperties.controlPlaneReaderScope += SasTokenPermissionKind.ContainerReadAny;\n    sasTokenProperties.controlPlaneWriterScope += SasTokenPermissionKind.ContainerReadAny;\n  }\n\n  if (\n    sasTokenProperties.dataPlaneReaderScope === 0 &&\n    sasTokenProperties.dataPlaneWriterScope === 0\n  ) {\n    sasTokenProperties.dataPlaneReaderScope = SasTokenPermissionKind.ContainerFullAccess;\n    sasTokenProperties.dataPlaneWriterScope = SasTokenPermissionKind.ContainerFullAccess;\n  }\n\n  if (\n    typeof sasTokenProperties.keyType !== \"number\" ||\n    typeof sasTokenProperties.keyType === \"undefined\"\n  ) {\n    switch (sasTokenProperties.keyType) {\n      case CosmosKeyType.PrimaryMaster:\n        sasTokenProperties.keyType = 1;\n        break;\n      case CosmosKeyType.SecondaryMaster:\n        sasTokenProperties.keyType = 2;\n        break;\n      case CosmosKeyType.PrimaryReadOnly:\n        sasTokenProperties.keyType = 3;\n        break;\n      case CosmosKeyType.SecondaryReadOnly:\n        sasTokenProperties.keyType = 4;\n        break;\n      default:\n        throw new Error(`illegalArgumentException : ${sasTokenProperties.keyType} \\\n                          is an invalid key type`);\n        break;\n    }\n  }\n\n  const payload =\n    sasTokenProperties.user +\n    \"\\n\" +\n    sasTokenProperties.userTag +\n    \"\\n\" +\n    sasTokenProperties.resourcePath +\n    \"\\n\" +\n    partitionRanges +\n    \"\\n\" +\n    utcsecondsSinceEpoch(sasTokenProperties.startTime).toString(16) +\n    \"\\n\" +\n    utcsecondsSinceEpoch(sasTokenProperties.expiryTime).toString(16) +\n    \"\\n\" +\n    sasTokenProperties.keyType +\n    \"\\n\" +\n    sasTokenProperties.controlPlaneReaderScope.toString(16) +\n    \"\\n\" +\n    sasTokenProperties.controlPlaneWriterScope.toString(16) +\n    \"\\n\" +\n    sasTokenProperties.dataPlaneReaderScope.toString(16) +\n    \"\\n\" +\n    sasTokenProperties.dataPlaneWriterScope.toString(16) +\n    \"\\n\";\n\n  const signedPayload = await hmac(masterKey, Buffer.from(payload).toString(\"base64\"));\n  return \"type=sas&ver=1.0&sig=\" + signedPayload + \";\" + Buffer.from(payload).toString(\"base64\");\n}\n/**\n * @hidden\n */\n// TODO: utcMilllisecondsSinceEpoch\nexport function utcsecondsSinceEpoch(date: Date): number {\n  return Math.round(date.getTime() / 1000);\n}\n"],
   "mappings": "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",
   "names": []

package/dist/commonjs/utils/atob.js

@@ -23,3 +23,4 @@ module.exports = __toCommonJS(atob_exports);
 function atob(str) {
   return Buffer.from(str, "base64").toString("binary");
 }
+//# sourceMappingURL=atob.js.map

package/dist/commonjs/utils/atob.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["/mnt/vss/_work/1/s/sdk/cosmosdb/cosmos/src/utils/atob.ts"],
+  "sources": ["../../../src/utils/atob.ts"],
   "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nexport default function atob(str: string): string {\n  return Buffer.from(str, \"base64\").toString(\"binary\");\n}\n"],
   "mappings": ";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGe,SAAR,KAAsB,KAAqB;AAChD,SAAO,OAAO,KAAK,KAAK,QAAQ,EAAE,SAAS,QAAQ;AACrD;",
   "names": []

package/dist/commonjs/utils/batch.js

@@ -223,3 +223,4 @@ async function encryptOperationInput(encryptionProcessor, operation, totalProper
   prepareOperations,
   splitBatchBasedOnBodySize
 });
+//# sourceMappingURL=batch.js.map

package/dist/commonjs/utils/batch.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["/mnt/vss/_work/1/s/sdk/cosmosdb/cosmos/src/utils/batch.ts"],
+  "sources": ["../../../src/utils/batch.ts"],
   "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { JSONObject } from \"../queryExecutionContext/index.js\";\nimport { extractPartitionKeys, undefinedPartitionKey } from \"../extractPartitionKey.js\";\nimport type {\n  CosmosDiagnostics,\n  CosmosHeaders,\n  DiagnosticNodeInternal,\n  ErrorResponse,\n  RequestOptions,\n  StatusCode,\n} from \"../index.js\";\nimport type {\n  PartitionKey,\n  PartitionKeyDefinition,\n  PrimitivePartitionKeyValue,\n} from \"../documents/index.js\";\nimport { NonePartitionKeyLiteral, convertToInternalPartitionKey } from \"../documents/index.js\";\nimport type { PatchRequestBody } from \"./patch.js\";\nimport { assertNotUndefined } from \"./typeChecks.js\";\nimport { bodyFromData } from \"../request/request.js\";\nimport { Constants } from \"../common/constants.js\";\nimport { randomUUID } from \"@azure/core-util\";\nimport type { ItemOperation } from \"../bulk/ItemOperation.js\";\nimport type { BulkResponse } from \"../bulk/index.js\";\nimport type { EncryptionProcessor } from \"../encryption/EncryptionProcessor.js\";\n\nexport type Operation =\n  | CreateOperation\n  | UpsertOperation\n  | ReadOperation\n  | DeleteOperation\n  | ReplaceOperation\n  | BulkPatchOperation;\n\nexport interface Batch {\n  min: string;\n  max: string;\n  rangeId: string;\n  indexes: number[];\n  operations: Operation[];\n}\n\nexport type BulkOperationResponse = OperationResponse[] & { diagnostics: CosmosDiagnostics };\n\n/**\n * represents response for an operation in bulk with executeBulkOperations API\n */\nexport interface BulkOperationResult {\n  /** the original operation input passed */\n  operationInput: OperationInput;\n  /** response from the backend for the item operation  */\n  response?: ExtendedOperationResponse;\n  /** any exceptions are captured here */\n  error?: ErrorResponse;\n}\n\n/**\n * response for a successful operation in bulk with executeBulkOperations API\n */\nexport interface ExtendedOperationResponse extends OperationResponse {\n  /** activity id related to the operation */\n  activityId?: string;\n  /** session Token assigned to the result */\n  sessionToken?: string;\n  /** headers associated with the operation */\n  headers?: CosmosHeaders;\n  /** diagnostic details associated with operation */\n  diagnostics: CosmosDiagnostics;\n}\n\nexport interface OperationResponse {\n  statusCode: number;\n  requestCharge: number;\n  eTag?: string;\n  resourceBody?: JSONObject;\n}\n\n/**\n * Options object used to modify bulk execution.\n * continueOnError (Default value: false) - Continues bulk execution when an operation fails ** NOTE THIS WILL DEFAULT TO TRUE IN the 4.0 RELEASE\n */\nexport interface BulkOptions {\n  continueOnError?: boolean;\n}\n\nexport function isKeyInRange(min: string, max: string, key: string): boolean {\n  const isAfterMinInclusive = key.localeCompare(min) >= 0;\n  const isBeforeMax = key.localeCompare(max) < 0;\n  return isAfterMinInclusive && isBeforeMax;\n}\n\nexport interface OperationBase {\n  partitionKey?: string;\n  ifMatch?: string;\n  ifNoneMatch?: string;\n}\n\nexport const BulkOperationType = {\n  Create: \"Create\",\n  Upsert: \"Upsert\",\n  Read: \"Read\",\n  Delete: \"Delete\",\n  Replace: \"Replace\",\n  Patch: \"Patch\",\n} as const;\n\nexport type OperationInput =\n  | CreateOperationInput\n  | UpsertOperationInput\n  | ReadOperationInput\n  | DeleteOperationInput\n  | ReplaceOperationInput\n  | PatchOperationInput;\n\nexport interface CreateOperationInput {\n  partitionKey?: PartitionKey;\n  ifMatch?: string;\n  ifNoneMatch?: string;\n  operationType: typeof BulkOperationType.Create;\n  resourceBody: JSONObject;\n}\n\nexport interface UpsertOperationInput {\n  partitionKey?: PartitionKey;\n  ifMatch?: string;\n  ifNoneMatch?: string;\n  operationType: typeof BulkOperationType.Upsert;\n  resourceBody: JSONObject;\n}\n\nexport interface ReadOperationInput {\n  partitionKey?: PartitionKey;\n  operationType: typeof BulkOperationType.Read;\n  id: string;\n}\n\nexport interface DeleteOperationInput {\n  partitionKey?: PartitionKey;\n  operationType: typeof BulkOperationType.Delete;\n  id: string;\n}\n\nexport interface ReplaceOperationInput {\n  partitionKey?: PartitionKey;\n  ifMatch?: string;\n  ifNoneMatch?: string;\n  operationType: typeof BulkOperationType.Replace;\n  resourceBody: JSONObject;\n  id: string;\n}\n\nexport interface PatchOperationInput {\n  partitionKey?: PartitionKey;\n  ifMatch?: string;\n  ifNoneMatch?: string;\n  operationType: typeof BulkOperationType.Patch;\n  resourceBody: PatchRequestBody;\n  id: string;\n}\n\nexport type OperationWithItem = OperationBase & {\n  resourceBody: JSONObject;\n};\n\nexport type CreateOperation = OperationWithItem & {\n  operationType: typeof BulkOperationType.Create;\n};\n\nexport type UpsertOperation = OperationWithItem & {\n  operationType: typeof BulkOperationType.Upsert;\n};\n\nexport type ReadOperation = OperationBase & {\n  operationType: typeof BulkOperationType.Read;\n  id: string;\n};\n\nexport type DeleteOperation = OperationBase & {\n  operationType: typeof BulkOperationType.Delete;\n  id: string;\n};\n\nexport type ReplaceOperation = OperationWithItem & {\n  operationType: typeof BulkOperationType.Replace;\n  id: string;\n};\n\nexport type BulkPatchOperation = OperationBase & {\n  operationType: typeof BulkOperationType.Patch;\n  id: string;\n};\n\nexport function hasResource(\n  operation: Operation,\n): operation is CreateOperation | UpsertOperation | ReplaceOperation {\n  return (\n    operation.operationType !== \"Patch\" &&\n    (operation as OperationWithItem).resourceBody !== undefined\n  );\n}\n/**\n * Maps OperationInput to Operation by\n * - generating Ids if needed.\n * - choosing partitionKey which can be used to choose which batch this\n * operation should be part of. The order is -\n *   1. If the operationInput itself has partitionKey field set it is used.\n *   2. Other wise for create/replace/upsert it is extracted from resource body.\n *   3. For read/delete/patch type operations undefined partitionKey is used.\n * - Here one nuance is that, the partitionKey field inside Operation needs to\n *  be serialized as a JSON string.\n * @param operationInput - OperationInput\n * @param definition - PartitionKeyDefinition\n * @param options - RequestOptions\n * @returns\n */\nexport function prepareOperations(\n  operationInput: OperationInput,\n  definition: PartitionKeyDefinition,\n  options: RequestOptions = {},\n): {\n  operation: Operation;\n  partitionKey: PrimitivePartitionKeyValue[];\n} {\n  populateIdsIfNeeded(operationInput, options);\n\n  let partitionKey: PrimitivePartitionKeyValue[];\n  if (Object.prototype.hasOwnProperty.call(operationInput, \"partitionKey\")) {\n    if (operationInput.partitionKey === undefined) {\n      partitionKey = definition.paths.map(() => NonePartitionKeyLiteral);\n    } else {\n      partitionKey = convertToInternalPartitionKey(operationInput.partitionKey);\n    }\n  } else {\n    switch (operationInput.operationType) {\n      case BulkOperationType.Create:\n      case BulkOperationType.Replace:\n      case BulkOperationType.Upsert:\n        partitionKey = assertNotUndefined(\n          extractPartitionKeys(operationInput.resourceBody, definition),\n          \"Unexpected undefined Partition Key Found.\",\n        );\n        break;\n      case BulkOperationType.Read:\n      case BulkOperationType.Delete:\n      case BulkOperationType.Patch:\n        partitionKey = undefinedPartitionKey(definition);\n        break;\n    }\n  }\n  return {\n    operation: { ...operationInput, partitionKey: JSON.stringify(partitionKey) } as Operation,\n    partitionKey,\n  };\n}\n\n/**\n * For operations requiring Id genrate random uuids.\n * @param operationInput - OperationInput to be checked.\n * @param options - RequestOptions\n */\nfunction populateIdsIfNeeded(operationInput: OperationInput, options: RequestOptions) {\n  if (\n    operationInput.operationType === BulkOperationType.Create ||\n    operationInput.operationType === BulkOperationType.Upsert\n  ) {\n    if (\n      (operationInput.resourceBody.id === undefined || operationInput.resourceBody.id === \"\") &&\n      !options.disableAutomaticIdGeneration\n    ) {\n      operationInput.resourceBody.id = randomUUID();\n    }\n  }\n}\n\n/**\n * Splits a batch into array of batches based on cumulative size of its operations by making sure\n * cumulative size of an individual batch is not larger than {@link Constants.DefaultMaxBulkRequestBodySizeInBytes}.\n * If a single operation itself is larger than {@link Constants.DefaultMaxBulkRequestBodySizeInBytes}, that\n * operation would be moved into a batch containing only that operation.\n * @param originalBatch - A batch of operations needed to be checked.\n * @returns\n * @hidden\n */\nexport function splitBatchBasedOnBodySize(originalBatch: Batch): Batch[] {\n  if (originalBatch?.operations === undefined || originalBatch.operations.length < 1) return [];\n  let currentBatchSize = calculateObjectSizeInBytes(originalBatch.operations[0]);\n  let currentBatch: Batch = {\n    ...originalBatch,\n    operations: [originalBatch.operations[0]],\n    indexes: [originalBatch.indexes[0]],\n  };\n  const processedBatches: Batch[] = [];\n  processedBatches.push(currentBatch);\n\n  for (let index = 1; index < originalBatch.operations.length; index++) {\n    const operation = originalBatch.operations[index];\n    const currentOpSize = calculateObjectSizeInBytes(operation);\n    if (currentBatchSize + currentOpSize > Constants.DefaultMaxBulkRequestBodySizeInBytes) {\n      currentBatch = {\n        ...originalBatch,\n        operations: [],\n        indexes: [],\n      };\n      processedBatches.push(currentBatch);\n      currentBatchSize = 0;\n    }\n    currentBatch.operations.push(operation);\n    currentBatch.indexes.push(originalBatch.indexes[index]);\n    currentBatchSize += currentOpSize;\n  }\n  return processedBatches;\n}\n\n/**\n * Calculates size of an JSON object in bytes with utf-8 encoding.\n * @hidden\n */\nexport function calculateObjectSizeInBytes(obj: unknown): number {\n  return new TextEncoder().encode(bodyFromData(obj as any)).length;\n}\n\nexport function decorateBatchOperation(\n  operation: OperationInput,\n  options: RequestOptions = {},\n): Operation {\n  if (\n    operation.operationType === BulkOperationType.Create ||\n    operation.operationType === BulkOperationType.Upsert\n  ) {\n    if (\n      (operation.resourceBody.id === undefined || operation.resourceBody.id === \"\") &&\n      !options.disableAutomaticIdGeneration\n    ) {\n      operation.resourceBody.id = randomUUID();\n    }\n  }\n  return operation as Operation;\n}\n\nexport function isSuccessStatusCode(statusCode: StatusCode): boolean {\n  return statusCode >= 200 && statusCode <= 299;\n}\n\nexport type ExecuteCallback = (\n  operations: ItemOperation[],\n  diagnosticNode: DiagnosticNodeInternal,\n) => Promise<BulkResponse>;\nexport type RetryCallback = (\n  operation: ItemOperation,\n  diagnosticNode: DiagnosticNodeInternal,\n) => Promise<void>;\n\nexport class TaskCompletionSource<T> {\n  private readonly promise: Promise<T>;\n  private resolveFn!: (value: T) => void;\n  private rejectFn!: (reason?: any) => void;\n\n  constructor() {\n    this.promise = new Promise<T>((resolve, reject) => {\n      this.resolveFn = resolve;\n      this.rejectFn = reject;\n    });\n  }\n\n  public get task(): Promise<T> {\n    return this.promise;\n  }\n\n  public setResult(value: T): void {\n    this.resolveFn(value);\n  }\n\n  public setException(error: Error): void {\n    this.rejectFn(error);\n  }\n}\n\nexport async function encryptOperationInput(\n  encryptionProcessor: EncryptionProcessor,\n  operation: OperationInput,\n  totalPropertiesEncryptedCount: number,\n): Promise<{ operation: OperationInput; totalPropertiesEncryptedCount: number }> {\n  if (Object.prototype.hasOwnProperty.call(operation, \"partitionKey\")) {\n    const partitionKeyInternal = convertToInternalPartitionKey(operation.partitionKey);\n    const { partitionKeyList, encryptedCount } =\n      await encryptionProcessor.getEncryptedPartitionKeyValue(partitionKeyInternal);\n    operation.partitionKey = partitionKeyList;\n    totalPropertiesEncryptedCount += encryptedCount;\n  }\n  switch (operation.operationType) {\n    case BulkOperationType.Create:\n    case BulkOperationType.Upsert: {\n      const { body, propertiesEncryptedCount } = await encryptionProcessor.encrypt(\n        operation.resourceBody,\n      );\n      operation.resourceBody = body;\n      totalPropertiesEncryptedCount += propertiesEncryptedCount;\n      break;\n    }\n    case BulkOperationType.Read:\n    case BulkOperationType.Delete:\n      if (await encryptionProcessor.isPathEncrypted(\"/id\")) {\n        operation.id = await encryptionProcessor.getEncryptedId(operation.id);\n        totalPropertiesEncryptedCount++;\n      }\n      break;\n    case BulkOperationType.Replace: {\n      if (await encryptionProcessor.isPathEncrypted(\"/id\")) {\n        operation.id = await encryptionProcessor.getEncryptedId(operation.id);\n        totalPropertiesEncryptedCount++;\n      }\n      const { body, propertiesEncryptedCount } = await encryptionProcessor.encrypt(\n        operation.resourceBody,\n      );\n      operation.resourceBody = body;\n      totalPropertiesEncryptedCount += propertiesEncryptedCount;\n      break;\n    }\n    case BulkOperationType.Patch: {\n      if (await encryptionProcessor.isPathEncrypted(\"/id\")) {\n        operation.id = await encryptionProcessor.getEncryptedId(operation.id);\n        totalPropertiesEncryptedCount++;\n      }\n      const body = operation.resourceBody;\n      const patchRequestBody = Array.isArray(body) ? body : body.operations;\n      for (const patchOperation of patchRequestBody) {\n        if (\"value\" in patchOperation) {\n          if (await encryptionProcessor.isPathEncrypted(patchOperation.path)) {\n            patchOperation.value = await encryptionProcessor.encryptProperty(\n              patchOperation.path,\n              patchOperation.value,\n            );\n            totalPropertiesEncryptedCount++;\n          }\n        }\n      }\n      break;\n    }\n  }\n  return { operation, totalPropertiesEncryptedCount };\n}\n"],
   "mappings": "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",
   "names": []

package/dist/commonjs/utils/cachedClient.js

@@ -32,3 +32,4 @@ function getCachedDefaultHttpClient() {
 0 && (module.exports = {
   getCachedDefaultHttpClient
 });
+//# sourceMappingURL=cachedClient.js.map

package/dist/commonjs/utils/cachedClient.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["/mnt/vss/_work/1/s/sdk/cosmosdb/cosmos/src/utils/cachedClient.ts"],
+  "sources": ["../../../src/utils/cachedClient.ts"],
   "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { HttpClient } from \"@azure/core-rest-pipeline\";\nimport { createDefaultHttpClient } from \"@azure/core-rest-pipeline\";\n\nlet cachedHttpClient: HttpClient | undefined;\n\nexport function getCachedDefaultHttpClient(): HttpClient {\n  if (!cachedHttpClient) {\n    cachedHttpClient = createDefaultHttpClient();\n  }\n\n  return cachedHttpClient;\n}\n"],
   "mappings": ";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,gCAAwC;AAExC,IAAI;AAEG,SAAS,6BAAyC;AACvD,MAAI,CAAC,kBAAkB;AACrB,2BAAmB,mDAAwB;AAAA,EAC7C;AAEA,SAAO;AACT;",
   "names": []

package/dist/commonjs/utils/checkURL.js

@@ -37,3 +37,4 @@ function normalizeEndpoint(endpoint) {
   normalizeEndpoint,
   sanitizeEndpoint
 });
+//# sourceMappingURL=checkURL.js.map

package/dist/commonjs/utils/checkURL.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["/mnt/vss/_work/1/s/sdk/cosmosdb/cosmos/src/utils/checkURL.ts"],
+  "sources": ["../../../src/utils/checkURL.ts"],
   "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nexport function checkURL(testString: string): URL {\n  return new URL(testString);\n}\n\nexport function sanitizeEndpoint(url: string): string {\n  return new URL(url).href.replace(/\\/$/, \"\");\n}\n\n/**\n * @internal\n */\nexport function normalizeEndpoint(endpoint: string): string {\n  return endpoint.replace(/\\s+/g, \"\").toLowerCase();\n}\n"],
   "mappings": ";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGO,SAAS,SAAS,YAAyB;AAChD,SAAO,IAAI,IAAI,UAAU;AAC3B;AAEO,SAAS,iBAAiB,KAAqB;AACpD,SAAO,IAAI,IAAI,GAAG,EAAE,KAAK,QAAQ,OAAO,EAAE;AAC5C;AAKO,SAAS,kBAAkB,UAA0B;AAC1D,SAAO,SAAS,QAAQ,QAAQ,EAAE,EAAE,YAAY;AAClD;",
   "names": []

package/dist/commonjs/utils/diagnostics.js

@@ -112,3 +112,4 @@ async function withDiagnostics(callback, clientContext, type = import_Diagnostic
   withDiagnostics,
   withMetadataDiagnostics
 });
+//# sourceMappingURL=diagnostics.js.map

package/dist/commonjs/utils/diagnostics.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["/mnt/vss/_work/1/s/sdk/cosmosdb/cosmos/src/utils/diagnostics.ts"],
+  "sources": ["../../../src/utils/diagnostics.ts"],
   "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { MetadataLookUpType } from \"../CosmosDiagnostics.js\";\nimport { CosmosDiagnostics } from \"../CosmosDiagnostics.js\";\nimport type { DiagnosticDataValue } from \"../diagnostics/DiagnosticNodeInternal.js\";\nimport {\n  DiagnosticNodeInternal,\n  DiagnosticNodeType,\n} from \"../diagnostics/DiagnosticNodeInternal.js\";\nimport type { ClientContext } from \"../ClientContext.js\";\nimport { getCurrentTimestampInMs } from \"./time.js\";\nimport { CosmosDbDiagnosticLevel } from \"../diagnostics/CosmosDbDiagnosticLevel.js\";\nimport { randomUUID } from \"@azure/core-util\";\n\n/**\n * @hidden\n * Utility function to create an Empty CosmosDiagnostic object.\n */\nexport function getEmptyCosmosDiagnostics(): CosmosDiagnostics {\n  return new CosmosDiagnostics(\n    {\n      requestDurationInMs: 0,\n      requestStartTimeUTCInMs: getCurrentTimestampInMs(),\n      totalRequestPayloadLengthInBytes: 0,\n      totalResponsePayloadLengthInBytes: 0,\n      locationEndpointsContacted: [],\n      retryDiagnostics: {\n        failedAttempts: [],\n      },\n      metadataDiagnostics: {\n        metadataLookups: [],\n      },\n      gatewayStatistics: [],\n    },\n    {\n      id: randomUUID(),\n      nodeType: DiagnosticNodeType.CLIENT_REQUEST_NODE,\n      children: [],\n      data: {},\n      startTimeUTCInMs: getCurrentTimestampInMs(),\n      durationInMs: 0,\n    },\n  );\n}\n\n/**\n * @hidden\n */\nexport type ExtractPromise<T> = T extends Promise<infer U> ? U : never;\n\n/**\n * A supporting utility wrapper function, to be used inside a diagnostic session started\n * by `withDiagnostics` function.\n * Created a Diagnostic node and add it as a child to existing diagnostic session.\n * @hidden\n */\nexport async function addDiagnosticChild<\n  Callback extends (node: DiagnosticNodeInternal) => Promise<any>,\n>(\n  callback: Callback,\n  node: DiagnosticNodeInternal,\n  type: DiagnosticNodeType,\n  data: Partial<DiagnosticDataValue> = {},\n): Promise<ExtractPromise<ReturnType<Callback>>> {\n  const childNode = node.initializeChildNode(type, CosmosDbDiagnosticLevel.debug, data);\n  try {\n    const response = await callback(childNode);\n    childNode.updateTimestamp();\n    return response;\n  } catch (e: any) {\n    childNode.addData({\n      failure: true,\n    });\n    childNode.updateTimestamp();\n    throw e;\n  }\n}\n\n/**\n * A supporting utility wrapper function, to be used inside a diagnostic session started\n * by `withDiagnostics` function.\n * Treats requests originating in  provided `callback` as metadata calls.\n * To realize this, starts a temporary diagnostic session, after execution of callback is\n * finished. Merges this temporary diagnostic session to the original diagnostic session\n * represented by the input parameter `node`.\n * @hidden\n */\nexport async function withMetadataDiagnostics<\n  Callback extends (node: DiagnosticNodeInternal) => Promise<any>,\n>(\n  callback: Callback,\n  node: DiagnosticNodeInternal,\n  type: MetadataLookUpType,\n): Promise<ExtractPromise<ReturnType<Callback>>> {\n  const diagnosticNodeForMetadataCall = new DiagnosticNodeInternal(\n    node.diagnosticLevel,\n    DiagnosticNodeType.METADATA_REQUEST_NODE,\n    null,\n  );\n  try {\n    const response: any = await callback(diagnosticNodeForMetadataCall);\n    node.addChildNode(diagnosticNodeForMetadataCall, CosmosDbDiagnosticLevel.debug, type);\n    return response;\n  } catch (e) {\n    node.addChildNode(diagnosticNodeForMetadataCall, CosmosDbDiagnosticLevel.debug, type);\n    throw e;\n  }\n}\n\n/**\n * Utility wrapper function to managed lifecycle of a Diagnostic session.\n * Meant to be used at the root of the client operation. i.e. item.read(),\n * queryIterator.fetchAll().\n *\n * This utility starts a new diagnostic session. So using it any where else\n * other than start of operation, will result is different diagnostic sessions.\n *\n * Workings :\n * 1. Takes a callback function as input.\n * 2. Creates a new instance of DiagnosticNodeInternal, which can be though as starting\n * a new diagnostic session.\n * 3. Executes the callback function.\n * 4. If execution was successful. Converts DiagnosticNodeInternal to CosmosDiagnostics\n * and injects it to the response object and returns this object.\n * 5. If execution threw an exception. Sill converts DiagnosticNodeInternal to CosmosDiagnostics\n * and injects it to the Error object, and rethrows the Error object.\n *\n * @hidden\n */\nexport async function withDiagnostics<\n  Callback extends (node: DiagnosticNodeInternal) => Promise<any>,\n>(\n  callback: Callback,\n  clientContext: ClientContext,\n  type: DiagnosticNodeType = DiagnosticNodeType.CLIENT_REQUEST_NODE,\n): Promise<ExtractPromise<ReturnType<Callback>>> {\n  const diagnosticNode = new DiagnosticNodeInternal(clientContext.diagnosticLevel, type, null);\n  try {\n    const response: any = await callback(diagnosticNode);\n    diagnosticNode.updateTimestamp();\n    const diagnostics = diagnosticNode.toDiagnostic(clientContext.getClientConfig());\n    if (typeof response === \"object\" && response !== null) {\n      (response as any).diagnostics = diagnostics;\n    }\n    clientContext.recordDiagnostics(diagnostics);\n    return response;\n  } catch (e: any) {\n    diagnosticNode.updateTimestamp();\n    diagnosticNode.addData({\n      failure: true,\n    });\n    const diagnostics = diagnosticNode.toDiagnostic(clientContext.getClientConfig());\n    e.diagnostics = diagnostics;\n    clientContext.recordDiagnostics(diagnostics);\n    throw e;\n  }\n}\n"],
   "mappings": ";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,+BAAkC;AAElC,oCAGO;AAEP,kBAAwC;AACxC,qCAAwC;AACxC,uBAA2B;AAMpB,SAAS,4BAA+C;AAC7D,SAAO,IAAI;AAAA,IACT;AAAA,MACE,qBAAqB;AAAA,MACrB,6BAAyB,qCAAwB;AAAA,MACjD,kCAAkC;AAAA,MAClC,mCAAmC;AAAA,MACnC,4BAA4B,CAAC;AAAA,MAC7B,kBAAkB;AAAA,QAChB,gBAAgB,CAAC;AAAA,MACnB;AAAA,MACA,qBAAqB;AAAA,QACnB,iBAAiB,CAAC;AAAA,MACpB;AAAA,MACA,mBAAmB,CAAC;AAAA,IACtB;AAAA,IACA;AAAA,MACE,QAAI,6BAAW;AAAA,MACf,UAAU,iDAAmB;AAAA,MAC7B,UAAU,CAAC;AAAA,MACX,MAAM,CAAC;AAAA,MACP,sBAAkB,qCAAwB;AAAA,MAC1C,cAAc;AAAA,IAChB;AAAA,EACF;AACF;AAaA,eAAsB,mBAGpB,UACA,MACA,MACA,OAAqC,CAAC,GACS;AAC/C,QAAM,YAAY,KAAK,oBAAoB,MAAM,uDAAwB,OAAO,IAAI;AACpF,MAAI;AACF,UAAM,WAAW,MAAM,SAAS,SAAS;AACzC,cAAU,gBAAgB;AAC1B,WAAO;AAAA,EACT,SAAS,GAAQ;AACf,cAAU,QAAQ;AAAA,MAChB,SAAS;AAAA,IACX,CAAC;AACD,cAAU,gBAAgB;AAC1B,UAAM;AAAA,EACR;AACF;AAWA,eAAsB,wBAGpB,UACA,MACA,MAC+C;AAC/C,QAAM,gCAAgC,IAAI;AAAA,IACxC,KAAK;AAAA,IACL,iDAAmB;AAAA,IACnB;AAAA,EACF;AACA,MAAI;AACF,UAAM,WAAgB,MAAM,SAAS,6BAA6B;AAClE,SAAK,aAAa,+BAA+B,uDAAwB,OAAO,IAAI;AACpF,WAAO;AAAA,EACT,SAAS,GAAG;AACV,SAAK,aAAa,+BAA+B,uDAAwB,OAAO,IAAI;AACpF,UAAM;AAAA,EACR;AACF;AAsBA,eAAsB,gBAGpB,UACA,eACA,OAA2B,iDAAmB,qBACC;AAC/C,QAAM,iBAAiB,IAAI,qDAAuB,cAAc,iBAAiB,MAAM,IAAI;AAC3F,MAAI;AACF,UAAM,WAAgB,MAAM,SAAS,cAAc;AACnD,mBAAe,gBAAgB;AAC/B,UAAM,cAAc,eAAe,aAAa,cAAc,gBAAgB,CAAC;AAC/E,QAAI,OAAO,aAAa,YAAY,aAAa,MAAM;AACrD,MAAC,SAAiB,cAAc;AAAA,IAClC;AACA,kBAAc,kBAAkB,WAAW;AAC3C,WAAO;AAAA,EACT,SAAS,GAAQ;AACf,mBAAe,gBAAgB;AAC/B,mBAAe,QAAQ;AAAA,MACrB,SAAS;AAAA,IACX,CAAC;AACD,UAAM,cAAc,eAAe,aAAa,cAAc,gBAAgB,CAAC;AAC/E,MAAE,cAAc;AAChB,kBAAc,kBAAkB,WAAW;AAC3C,UAAM;AAAA,EACR;AACF;",
   "names": []

package/dist/commonjs/utils/digest.js

@@ -30,3 +30,4 @@ async function digest(str) {
 0 && (module.exports = {
   digest
 });
+//# sourceMappingURL=digest.js.map

package/dist/commonjs/utils/digest.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["/mnt/vss/_work/1/s/sdk/cosmosdb/cosmos/src/utils/digest.ts"],
+  "sources": ["../../../src/utils/digest.ts"],
   "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport { createHash } from \"node:crypto\";\n\nexport async function digest(str: string): Promise<string> {\n  const hash = createHash(\"sha256\");\n  hash.update(str, \"utf8\");\n  return hash.digest(\"hex\");\n}\n"],
   "mappings": ";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,yBAA2B;AAE3B,eAAsB,OAAO,KAA8B;AACzD,QAAM,WAAO,+BAAW,QAAQ;AAChC,OAAK,OAAO,KAAK,MAAM;AACvB,SAAO,KAAK,OAAO,KAAK;AAC1B;",
   "names": []

package/dist/commonjs/utils/encode.js

@@ -45,3 +45,4 @@ function encodeBase64(value) {
   encodeBase64,
   encodeUTF8
 });
+//# sourceMappingURL=encode.js.map

package/dist/commonjs/utils/encode.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["/mnt/vss/_work/1/s/sdk/cosmosdb/cosmos/src/utils/encode.ts"],
+  "sources": ["../../../src/utils/encode.ts"],
   "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\n/// <reference lib=\"dom\"/>\n\nexport function encodeUTF8(str: string): Uint8Array<ArrayBuffer> {\n  const bytes = new Uint8Array(str.length);\n  for (let i = 0; i < str.length; i++) {\n    bytes[i] = str.charCodeAt(i);\n  }\n  return bytes;\n}\n\nexport function encodeBase64(value: ArrayBuffer): string {\n  if (\"function\" !== typeof btoa) {\n    throw new Error(\"Your browser environment is missing the global `btoa` function\");\n  }\n\n  let binary = \"\";\n  const bytes = new Uint8Array(value);\n  const len = bytes.byteLength;\n  for (let i = 0; i < len; i++) {\n    binary += String.fromCharCode(bytes[i]);\n  }\n  return btoa(binary);\n}\n"],
   "mappings": ";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAKO,SAAS,WAAW,KAAsC;AAC/D,QAAM,QAAQ,IAAI,WAAW,IAAI,MAAM;AACvC,WAAS,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK;AACnC,UAAM,CAAC,IAAI,IAAI,WAAW,CAAC;AAAA,EAC7B;AACA,SAAO;AACT;AAEO,SAAS,aAAa,OAA4B;AACvD,MAAI,eAAe,OAAO,MAAM;AAC9B,UAAM,IAAI,MAAM,gEAAgE;AAAA,EAClF;AAEA,MAAI,SAAS;AACb,QAAM,QAAQ,IAAI,WAAW,KAAK;AAClC,QAAM,MAAM,MAAM;AAClB,WAAS,IAAI,GAAG,IAAI,KAAK,KAAK;AAC5B,cAAU,OAAO,aAAa,MAAM,CAAC,CAAC;AAAA,EACxC;AACA,SAAO,KAAK,MAAM;AACpB;",
   "names": []

package/dist/commonjs/utils/envUtils.js

@@ -37,3 +37,4 @@ const diagnosticLevelFromEnv = import_node_process.default.env[import_constants.
 0 && (module.exports = {
   diagnosticLevelFromEnv
 });
+//# sourceMappingURL=envUtils.js.map

package/dist/commonjs/utils/envUtils.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["/mnt/vss/_work/1/s/sdk/cosmosdb/cosmos/src/utils/envUtils.ts"],
+  "sources": ["../../../src/utils/envUtils.ts"],
   "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport process from \"node:process\";\nimport { Constants } from \"../common/constants.js\";\n\nexport const diagnosticLevelFromEnv: string | undefined =\n  process.env[Constants.CosmosDbDiagnosticLevelEnvVarName];\n"],
   "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,0BAAoB;AACpB,uBAA0B;AAEnB,MAAM,yBACX,oBAAAA,QAAQ,IAAI,2BAAU,iCAAiC;",
   "names": ["process"]

package/dist/commonjs/utils/fixedSizePriorityQueue.js

@@ -88,3 +88,4 @@ class FixedSizePriorityQueue {
 0 && (module.exports = {
   FixedSizePriorityQueue
 });
+//# sourceMappingURL=fixedSizePriorityQueue.js.map

package/dist/commonjs/utils/fixedSizePriorityQueue.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["/mnt/vss/_work/1/s/sdk/cosmosdb/cosmos/src/utils/fixedSizePriorityQueue.ts"],
+  "sources": ["../../../src/utils/fixedSizePriorityQueue.ts"],
   "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\nimport PriorityQueue from \"priorityqueuejs\";\n\nexport class FixedSizePriorityQueue<T> {\n  private pq: PriorityQueue<T>;\n  // The compare function should return a positive number if a is greater than b, a negative number if a is less than b, and 0 if a is equal to b.\n  private compareFn: (a: T, b: T) => number;\n  private pqMaxSize: number;\n\n  constructor(compareFn: (a: T, b: T) => number, pqMaxSize: number) {\n    this.compareFn = compareFn;\n    this.pq = new PriorityQueue<T>(this.compareFn);\n    this.pqMaxSize = pqMaxSize;\n  }\n\n  public enqueue(item: T): void {\n    if (this.pq.size() < this.pqMaxSize) {\n      this.pq.enq(item);\n    } else {\n      const topItem = this.pq.peek();\n      if (this.compareFn(topItem, item) > 0) {\n        this.pq.deq();\n        this.pq.enq(item);\n      }\n    }\n  }\n\n  public dequeue(): T {\n    return this.pq.deq();\n  }\n\n  public size(): number {\n    return this.pq.size();\n  }\n\n  public isEmpty(): boolean {\n    return this.pq.isEmpty();\n  }\n\n  public peek(): T {\n    return this.pq.peek();\n  }\n\n  public getTopElements(): T[] {\n    const elements: T[] = [];\n    while (!this.pq.isEmpty()) {\n      elements.unshift(this.pq.deq());\n    }\n    return elements;\n  }\n\n  // Create a new instance of FixedSizePriorityQueue with a reversed compare function and the same maximum size.\n  // Enqueue all elements from the current priority queue into the reverse priority queue.\n  public reverse(): FixedSizePriorityQueue<T> {\n    const reversePQ = new FixedSizePriorityQueue<T>(\n      (a: T, b: T) => -this.compareFn(a, b),\n      this.pqMaxSize,\n    );\n    while (!this.pq.isEmpty()) {\n      reversePQ.enqueue(this.pq.deq());\n    }\n    return reversePQ;\n  }\n}\n"],
   "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,6BAA0B;AAEnB,MAAM,uBAA0B;AAAA,EAC7B;AAAA;AAAA,EAEA;AAAA,EACA;AAAA,EAER,YAAY,WAAmC,WAAmB;AAChE,SAAK,YAAY;AACjB,SAAK,KAAK,IAAI,uBAAAA,QAAiB,KAAK,SAAS;AAC7C,SAAK,YAAY;AAAA,EACnB;AAAA,EAEO,QAAQ,MAAe;AAC5B,QAAI,KAAK,GAAG,KAAK,IAAI,KAAK,WAAW;AACnC,WAAK,GAAG,IAAI,IAAI;AAAA,IAClB,OAAO;AACL,YAAM,UAAU,KAAK,GAAG,KAAK;AAC7B,UAAI,KAAK,UAAU,SAAS,IAAI,IAAI,GAAG;AACrC,aAAK,GAAG,IAAI;AACZ,aAAK,GAAG,IAAI,IAAI;AAAA,MAClB;AAAA,IACF;AAAA,EACF;AAAA,EAEO,UAAa;AAClB,WAAO,KAAK,GAAG,IAAI;AAAA,EACrB;AAAA,EAEO,OAAe;AACpB,WAAO,KAAK,GAAG,KAAK;AAAA,EACtB;AAAA,EAEO,UAAmB;AACxB,WAAO,KAAK,GAAG,QAAQ;AAAA,EACzB;AAAA,EAEO,OAAU;AACf,WAAO,KAAK,GAAG,KAAK;AAAA,EACtB;AAAA,EAEO,iBAAsB;AAC3B,UAAM,WAAgB,CAAC;AACvB,WAAO,CAAC,KAAK,GAAG,QAAQ,GAAG;AACzB,eAAS,QAAQ,KAAK,GAAG,IAAI,CAAC;AAAA,IAChC;AACA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA,EAIO,UAAqC;AAC1C,UAAM,YAAY,IAAI;AAAA,MACpB,CAAC,GAAM,MAAS,CAAC,KAAK,UAAU,GAAG,CAAC;AAAA,MACpC,KAAK;AAAA,IACP;AACA,WAAO,CAAC,KAAK,GAAG,QAAQ,GAAG;AACzB,gBAAU,QAAQ,KAAK,GAAG,IAAI,CAAC;AAAA,IACjC;AACA,WAAO;AAAA,EACT;AACF;",
   "names": ["PriorityQueue"]

package/dist/commonjs/utils/globalCrypto.js

@@ -32,3 +32,4 @@ if (!globalCrypto || !globalCrypto.subtle) {
 0 && (module.exports = {
   globalCrypto
 });
+//# sourceMappingURL=globalCrypto.js.map

package/dist/commonjs/utils/globalCrypto.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["/mnt/vss/_work/1/s/sdk/cosmosdb/cosmos/src/utils/globalCrypto.ts"],
+  "sources": ["../../../src/utils/globalCrypto.ts"],
   "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\n// eslint-disable-next-line @azure/azure-sdk/ts-no-window\nconst globalRef: any = typeof self === \"undefined\" ? window : self;\n\nif (!globalRef) {\n  throw new Error(\"Could not find global\");\n}\n\nconst globalCrypto: Crypto = globalRef.crypto || globalRef.msCrypto;\n\nif (!globalCrypto || !globalCrypto.subtle) {\n  throw new Error(\"Browser does not support cryptography functions\");\n}\n\nexport { globalCrypto };\n"],
   "mappings": ";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,MAAM,YAAiB,OAAO,SAAS,cAAc,SAAS;AAE9D,IAAI,CAAC,WAAW;AACd,QAAM,IAAI,MAAM,uBAAuB;AACzC;AAEA,MAAM,eAAuB,UAAU,UAAU,UAAU;AAE3D,IAAI,CAAC,gBAAgB,CAAC,aAAa,QAAQ;AACzC,QAAM,IAAI,MAAM,iDAAiD;AACnE;",
   "names": []

package/dist/commonjs/utils/hashObject.js

@@ -40,3 +40,4 @@ async function hashObject(object) {
 0 && (module.exports = {
   hashObject
 });
+//# sourceMappingURL=hashObject.js.map

package/dist/commonjs/utils/hashObject.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["/mnt/vss/_work/1/s/sdk/cosmosdb/cosmos/src/utils/hashObject.ts"],
+  "sources": ["../../../src/utils/hashObject.ts"],
   "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport { digest } from \"./digest.js\";\nimport stableStringify from \"fast-json-stable-stringify\";\n\nexport async function hashObject(object: unknown): Promise<string> {\n  const stringifiedObject = stableStringify(object);\n  return digest(stringifiedObject);\n}\n"],
   "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,oBAAuB;AACvB,wCAA4B;AAE5B,eAAsB,WAAW,QAAkC;AACjE,QAAM,wBAAoB,kCAAAA,SAAgB,MAAM;AAChD,aAAO,sBAAO,iBAAiB;AACjC;",
   "names": ["stableStringify"]

package/dist/commonjs/utils/hashing/encoding/number.js

@@ -81,3 +81,4 @@ function doubleToByteArrayBigInt(double) {
   doubleToByteArrayBigInt,
   writeNumberForBinaryEncodingBigInt
 });
+//# sourceMappingURL=number.js.map

package/dist/commonjs/utils/hashing/encoding/number.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["/mnt/vss/_work/1/s/sdk/cosmosdb/cosmos/src/utils/hashing/encoding/number.ts"],
+  "sources": ["../../../../../src/utils/hashing/encoding/number.ts"],
   "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport { concatUint8Arrays, hexStringToUint8Array } from \"../../uint8.js\";\nimport { BytePrefix } from \"./prefix.js\";\n\nexport function writeNumberForBinaryEncodingBigInt(hash: number): Uint8Array {\n  let payload = encodeNumberAsUInt64BigInt(hash);\n  // Convert the BytePrefix.Number hex string to Uint8Array.\n  let outputStream = hexStringToUint8Array(BytePrefix.Number);\n\n  const firstChunk = (payload >> BigInt(56)) & BigInt(0xff);\n  outputStream = concatUint8Arrays([\n    outputStream,\n    hexStringToUint8Array(firstChunk.toString(16).padStart(2, \"0\")),\n  ]);\n\n  payload = (payload << BigInt(8)) & BigInt(\"0xffffffffffffffff\");\n\n  let byteToWrite = BigInt(0);\n  let firstIteration = true;\n\n  do {\n    if (!firstIteration) {\n      const padded = byteToWrite.toString(16).padStart(2, \"0\");\n      if (padded !== \"00\") {\n        outputStream = concatUint8Arrays([outputStream, hexStringToUint8Array(padded)]);\n      }\n    } else {\n      firstIteration = false;\n    }\n\n    const shifted = (payload >> BigInt(56)) & BigInt(0xff);\n    byteToWrite = shifted | BigInt(0x01);\n    payload = (payload << BigInt(7)) & BigInt(\"0xffffffffffffffff\");\n  } while (payload !== BigInt(0));\n\n  const lastChunk = byteToWrite & BigInt(0xfe);\n  const padded = lastChunk.toString(16).padStart(2, \"0\");\n  if (padded !== \"00\") {\n    outputStream = concatUint8Arrays([outputStream, hexStringToUint8Array(padded)]);\n  }\n\n  return outputStream;\n}\n\nfunction encodeNumberAsUInt64BigInt(value: number): bigint {\n  const rawValueBits = getRawBitsBigInt(value);\n  const mask = BigInt(\"0x8000000000000000\");\n  return mask > rawValueBits ? rawValueBits ^ mask : ~rawValueBits + BigInt(1);\n}\n\nfunction getRawBitsBigInt(value: number): bigint {\n  const buffer = new ArrayBuffer(8);\n  const view = new DataView(buffer);\n  view.setFloat64(0, value);\n  // Convert the underlying bytes to a hex string.\n  return BigInt(\"0x\" + buf2hex(new Uint8Array(buffer)));\n}\n\nfunction buf2hex(arr: Uint8Array): string {\n  return Array.from(arr)\n    .map((x) => x.toString(16).padStart(2, \"0\"))\n    .join(\"\");\n}\n\nexport function doubleToByteArrayBigInt(double: number): Uint8Array {\n  const output = new Uint8Array(8);\n  const lng = getRawBitsBigInt(double);\n  for (let i = 0; i < 8; i++) {\n    output[i] = Number((lng >> BigInt(i * 8)) & BigInt(0xff));\n  }\n  return output;\n}\n"],
   "mappings": ";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,mBAAyD;AACzD,oBAA2B;AAEpB,SAAS,mCAAmC,MAA0B;AAC3E,MAAI,UAAU,2BAA2B,IAAI;AAE7C,MAAI,mBAAe,oCAAsB,yBAAW,MAAM;AAE1D,QAAM,aAAc,WAAW,OAAO,EAAE,IAAK,OAAO,GAAI;AACxD,qBAAe,gCAAkB;AAAA,IAC/B;AAAA,QACA,oCAAsB,WAAW,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC;AAAA,EAChE,CAAC;AAED,YAAW,WAAW,OAAO,CAAC,IAAK,OAAO,oBAAoB;AAE9D,MAAI,cAAc,OAAO,CAAC;AAC1B,MAAI,iBAAiB;AAErB,KAAG;AACD,QAAI,CAAC,gBAAgB;AACnB,YAAMA,UAAS,YAAY,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG;AACvD,UAAIA,YAAW,MAAM;AACnB,2BAAe,gCAAkB,CAAC,kBAAc,oCAAsBA,OAAM,CAAC,CAAC;AAAA,MAChF;AAAA,IACF,OAAO;AACL,uBAAiB;AAAA,IACnB;AAEA,UAAM,UAAW,WAAW,OAAO,EAAE,IAAK,OAAO,GAAI;AACrD,kBAAc,UAAU,OAAO,CAAI;AACnC,cAAW,WAAW,OAAO,CAAC,IAAK,OAAO,oBAAoB;AAAA,EAChE,SAAS,YAAY,OAAO,CAAC;AAE7B,QAAM,YAAY,cAAc,OAAO,GAAI;AAC3C,QAAM,SAAS,UAAU,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG;AACrD,MAAI,WAAW,MAAM;AACnB,uBAAe,gCAAkB,CAAC,kBAAc,oCAAsB,MAAM,CAAC,CAAC;AAAA,EAChF;AAEA,SAAO;AACT;AAEA,SAAS,2BAA2B,OAAuB;AACzD,QAAM,eAAe,iBAAiB,KAAK;AAC3C,QAAM,OAAO,OAAO,oBAAoB;AACxC,SAAO,OAAO,eAAe,eAAe,OAAO,CAAC,eAAe,OAAO,CAAC;AAC7E;AAEA,SAAS,iBAAiB,OAAuB;AAC/C,QAAM,SAAS,IAAI,YAAY,CAAC;AAChC,QAAM,OAAO,IAAI,SAAS,MAAM;AAChC,OAAK,WAAW,GAAG,KAAK;AAExB,SAAO,OAAO,OAAO,QAAQ,IAAI,WAAW,MAAM,CAAC,CAAC;AACtD;AAEA,SAAS,QAAQ,KAAyB;AACxC,SAAO,MAAM,KAAK,GAAG,EAClB,IAAI,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC,EAC1C,KAAK,EAAE;AACZ;AAEO,SAAS,wBAAwB,QAA4B;AAClE,QAAM,SAAS,IAAI,WAAW,CAAC;AAC/B,QAAM,MAAM,iBAAiB,MAAM;AACnC,WAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AAC1B,WAAO,CAAC,IAAI,OAAQ,OAAO,OAAO,IAAI,CAAC,IAAK,OAAO,GAAI,CAAC;AAAA,EAC1D;AACA,SAAO;AACT;",
   "names": ["padded"]

package/dist/commonjs/utils/hashing/encoding/prefix.js

@@ -48,3 +48,4 @@ const BytePrefix = {
 0 && (module.exports = {
   BytePrefix
 });
+//# sourceMappingURL=prefix.js.map

package/dist/commonjs/utils/hashing/encoding/prefix.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["/mnt/vss/_work/1/s/sdk/cosmosdb/cosmos/src/utils/hashing/encoding/prefix.ts"],
+  "sources": ["../../../../../src/utils/hashing/encoding/prefix.ts"],
   "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nexport const BytePrefix = {\n  Undefined: \"00\",\n  Null: \"01\",\n  False: \"02\",\n  True: \"03\",\n  MinNumber: \"04\",\n  Number: \"05\",\n  MaxNumber: \"06\",\n  MinString: \"07\",\n  String: \"08\",\n  MaxString: \"09\",\n  Int64: \"0a\",\n  Int32: \"0b\",\n  Int16: \"0c\",\n  Int8: \"0d\",\n  Uint64: \"0e\",\n  Uint32: \"0f\",\n  Uint16: \"10\",\n  Uint8: \"11\",\n  Binary: \"12\",\n  Guid: \"13\",\n  Float: \"14\",\n  Infinity: \"FF\",\n};\n"],
   "mappings": ";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGO,MAAM,aAAa;AAAA,EACxB,WAAW;AAAA,EACX,MAAM;AAAA,EACN,OAAO;AAAA,EACP,MAAM;AAAA,EACN,WAAW;AAAA,EACX,QAAQ;AAAA,EACR,WAAW;AAAA,EACX,WAAW;AAAA,EACX,QAAQ;AAAA,EACR,WAAW;AAAA,EACX,OAAO;AAAA,EACP,OAAO;AAAA,EACP,OAAO;AAAA,EACP,MAAM;AAAA,EACN,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,OAAO;AAAA,EACP,QAAQ;AAAA,EACR,MAAM;AAAA,EACN,OAAO;AAAA,EACP,UAAU;AACZ;",
   "names": []

package/dist/commonjs/utils/hashing/encoding/string.js

@@ -45,3 +45,4 @@ function writeStringForBinaryEncoding(payload) {
 0 && (module.exports = {
   writeStringForBinaryEncoding
 });
+//# sourceMappingURL=string.js.map

package/dist/commonjs/utils/hashing/encoding/string.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["/mnt/vss/_work/1/s/sdk/cosmosdb/cosmos/src/utils/hashing/encoding/string.ts"],
+  "sources": ["../../../../../src/utils/hashing/encoding/string.ts"],
   "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport { BytePrefix } from \"./prefix.js\";\nimport { hexStringToUint8Array, concatUint8Arrays } from \"../../uint8.js\";\n\nexport function writeStringForBinaryEncoding(payload: string): Uint8Array {\n  // Convert the BytePrefix.String hex into a Uint8Array.\n  const outputStream = hexStringToUint8Array(BytePrefix.String);\n  const MAX_STRING_BYTES_TO_APPEND = 100;\n  // Use TextEncoder to get a UTF-8 byte array from the payload.\n  const byteArray = new TextEncoder().encode(payload);\n\n  const isShortString = payload.length <= MAX_STRING_BYTES_TO_APPEND;\n\n  let finalStream = outputStream;\n  for (\n    let index = 0;\n    index < (isShortString ? byteArray.length : MAX_STRING_BYTES_TO_APPEND + 1);\n    index++\n  ) {\n    let charByte = byteArray[index];\n    if (charByte < 0xff) {\n      charByte++;\n    }\n    // Convert the byte value to a 2-digit hex string.\n    const hexRep = charByte.toString(16).padStart(2, \"0\");\n    finalStream = concatUint8Arrays([finalStream, hexStringToUint8Array(hexRep)]);\n  }\n\n  if (isShortString) {\n    finalStream = concatUint8Arrays([finalStream, hexStringToUint8Array(BytePrefix.Undefined)]);\n  }\n  return finalStream;\n}\n"],
   "mappings": ";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,oBAA2B;AAC3B,mBAAyD;AAElD,SAAS,6BAA6B,SAA6B;AAExE,QAAM,mBAAe,oCAAsB,yBAAW,MAAM;AAC5D,QAAM,6BAA6B;AAEnC,QAAM,YAAY,IAAI,YAAY,EAAE,OAAO,OAAO;AAElD,QAAM,gBAAgB,QAAQ,UAAU;AAExC,MAAI,cAAc;AAClB,WACM,QAAQ,GACZ,SAAS,gBAAgB,UAAU,SAAS,6BAA6B,IACzE,SACA;AACA,QAAI,WAAW,UAAU,KAAK;AAC9B,QAAI,WAAW,KAAM;AACnB;AAAA,IACF;AAEA,UAAM,SAAS,SAAS,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG;AACpD,sBAAc,gCAAkB,CAAC,iBAAa,oCAAsB,MAAM,CAAC,CAAC;AAAA,EAC9E;AAEA,MAAI,eAAe;AACjB,sBAAc,gCAAkB,CAAC,iBAAa,oCAAsB,yBAAW,SAAS,CAAC,CAAC;AAAA,EAC5F;AACA,SAAO;AACT;",
   "names": []

package/dist/commonjs/utils/hashing/hash.js

@@ -57,3 +57,4 @@ function binarySearchOnPartitionKeyRanges(partitionKeyRanges, hashedPartitionKey
   binarySearchOnPartitionKeyRanges,
   hashPartitionKey
 });
+//# sourceMappingURL=hash.js.map

package/dist/commonjs/utils/hashing/hash.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["/mnt/vss/_work/1/s/sdk/cosmosdb/cosmos/src/utils/hashing/hash.ts"],
+  "sources": ["../../../../src/utils/hashing/hash.ts"],
   "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { PartitionKeyRange } from \"../../client/index.js\";\nimport type { PartitionKeyDefinition, PrimitivePartitionKeyValue } from \"../../documents/index.js\";\nimport { PartitionKeyDefinitionVersion, PartitionKeyKind } from \"../../documents/index.js\";\nimport { isKeyInRange } from \"../batch.js\";\nimport { hashMultiHashPartitionKey } from \"./multiHash.js\";\nimport { hashV1PartitionKey } from \"./v1.js\";\nimport { hashV2PartitionKey } from \"./v2.js\";\n\n/**\n * Generate hash of a PartitonKey based on it PartitionKeyDefinition.\n * @param partitionKey - to be hashed.\n * @param partitionDefinition - container's partitionKey definition\n * @returns\n */\nexport function hashPartitionKey(\n  partitionKey: PrimitivePartitionKeyValue[],\n  partitionDefinition: PartitionKeyDefinition,\n): string {\n  const kind: PartitionKeyKind = partitionDefinition?.kind || PartitionKeyKind.Hash; // Default value.\n  const isV2 =\n    partitionDefinition &&\n    partitionDefinition.version &&\n    partitionDefinition.version === PartitionKeyDefinitionVersion.V2;\n  switch (kind) {\n    case PartitionKeyKind.Hash:\n      return isV2 ? hashV2PartitionKey(partitionKey) : hashV1PartitionKey(partitionKey);\n    case PartitionKeyKind.MultiHash:\n      return hashMultiHashPartitionKey(partitionKey);\n  }\n}\n\nexport function binarySearchOnPartitionKeyRanges(\n  partitionKeyRanges: PartitionKeyRange[],\n  hashedPartitionKey: string,\n): string | undefined {\n  let low = 0;\n  let high = partitionKeyRanges.length - 1;\n\n  while (low <= high) {\n    const mid = Math.floor((low + high) / 2);\n    const range = partitionKeyRanges[mid];\n\n    if (isKeyInRange(range.minInclusive, range.maxExclusive, hashedPartitionKey)) {\n      return range.id;\n    } else if (hashedPartitionKey.localeCompare(range.minInclusive) < 0) {\n      high = mid - 1;\n    } else {\n      low = mid + 1;\n    }\n  }\n  return undefined;\n}\n"],
   "mappings": ";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,uBAAgE;AAChE,mBAA6B;AAC7B,uBAA0C;AAC1C,gBAAmC;AACnC,gBAAmC;AAQ5B,SAAS,iBACd,cACA,qBACQ;AACR,QAAM,OAAyB,qBAAqB,QAAQ,kCAAiB;AAC7E,QAAM,OACJ,uBACA,oBAAoB,WACpB,oBAAoB,YAAY,+CAA8B;AAChE,UAAQ,MAAM;AAAA,IACZ,KAAK,kCAAiB;AACpB,aAAO,WAAO,8BAAmB,YAAY,QAAI,8BAAmB,YAAY;AAAA,IAClF,KAAK,kCAAiB;AACpB,iBAAO,4CAA0B,YAAY;AAAA,EACjD;AACF;AAEO,SAAS,iCACd,oBACA,oBACoB;AACpB,MAAI,MAAM;AACV,MAAI,OAAO,mBAAmB,SAAS;AAEvC,SAAO,OAAO,MAAM;AAClB,UAAM,MAAM,KAAK,OAAO,MAAM,QAAQ,CAAC;AACvC,UAAM,QAAQ,mBAAmB,GAAG;AAEpC,YAAI,2BAAa,MAAM,cAAc,MAAM,cAAc,kBAAkB,GAAG;AAC5E,aAAO,MAAM;AAAA,IACf,WAAW,mBAAmB,cAAc,MAAM,YAAY,IAAI,GAAG;AACnE,aAAO,MAAM;AAAA,IACf,OAAO;AACL,YAAM,MAAM;AAAA,IACd;AAAA,EACF;AACA,SAAO;AACT;",
   "names": []

package/dist/commonjs/utils/hashing/multiHash.js

@@ -28,3 +28,4 @@ function hashMultiHashPartitionKey(partitionKey) {
 0 && (module.exports = {
   hashMultiHashPartitionKey
 });
+//# sourceMappingURL=multiHash.js.map

package/dist/commonjs/utils/hashing/multiHash.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["/mnt/vss/_work/1/s/sdk/cosmosdb/cosmos/src/utils/hashing/multiHash.ts"],
+  "sources": ["../../../../src/utils/hashing/multiHash.ts"],
   "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\nimport type { PrimitivePartitionKeyValue } from \"../../documents/index.js\";\nimport { hashV2PartitionKey } from \"./v2.js\";\n\n/**\n * Generate Hash for a `Multi Hash` type partition.\n * @param partitionKey - to be hashed.\n * @returns\n */\nexport function hashMultiHashPartitionKey(partitionKey: PrimitivePartitionKeyValue[]): string {\n  return partitionKey.map((keys) => hashV2PartitionKey([keys])).join(\"\");\n}\n"],
   "mappings": ";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,gBAAmC;AAO5B,SAAS,0BAA0B,cAAoD;AAC5F,SAAO,aAAa,IAAI,CAAC,aAAS,8BAAmB,CAAC,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE;AACvE;",
   "names": []

package/dist/commonjs/utils/hashing/murmurHash.js

@@ -390,3 +390,4 @@ var murmurHash_default = {
 0 && (module.exports = {
   reverse
 });
+//# sourceMappingURL=murmurHash.js.map

package/dist/commonjs/utils/hashing/murmurHash.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["/mnt/vss/_work/1/s/sdk/cosmosdb/cosmos/src/utils/hashing/murmurHash.ts"],
+  "sources": ["../../../../src/utils/hashing/murmurHash.ts"],
   "sourcesContent": ["// +----------------------------------------------------------------------+\n// | murmurHash3js.js v3.0.1 // https://github.com/pid/murmurHash3js\n// | A javascript implementation of MurmurHash3's x86 hashing algorithms. |\n// |----------------------------------------------------------------------|\n// | Copyright (c) 2012-2015 Karan Lyons                                       |\n// | https://github.com/karanlyons/murmurHash3.js/blob/c1778f75792abef7bdd74bc85d2d4e1a3d25cfe9/murmurHash3.js |\n// | Freely distributable under the MIT license.                          |\n// +----------------------------------------------------------------------+\n\n// PRIVATE FUNCTIONS\n// -----------------\nimport { hexStringToUint8Array, uint8ArrayToHex } from \"../uint8.js\";\nfunction _x86Multiply(m: number, n: number) {\n  //\n  // Given two 32bit ints, returns the two multiplied together as a\n  // 32bit int.\n  //\n\n  return (m & 0xffff) * n + ((((m >>> 16) * n) & 0xffff) << 16);\n}\n\nfunction _x86Rotl(m: number, n: number) {\n  //\n  // Given a 32bit int and an int representing a number of bit positions,\n  // returns the 32bit int rotated left by that number of positions.\n  //\n\n  return (m << n) | (m >>> (32 - n));\n}\n\nfunction _x86Fmix(h: number) {\n  //\n  // Given a block, returns murmurHash3's final x86 mix of that block.\n  //\n\n  h ^= h >>> 16;\n  h = _x86Multiply(h, 0x85ebca6b);\n  h ^= h >>> 13;\n  h = _x86Multiply(h, 0xc2b2ae35);\n  h ^= h >>> 16;\n\n  return h;\n}\n\nfunction _x64Add(m: number[], n: number[]) {\n  //\n  // Given two 64bit ints (as an array of two 32bit ints) returns the two\n  // added together as a 64bit int (as an array of two 32bit ints).\n  //\n\n  m = [m[0] >>> 16, m[0] & 0xffff, m[1] >>> 16, m[1] & 0xffff];\n  n = [n[0] >>> 16, n[0] & 0xffff, n[1] >>> 16, n[1] & 0xffff];\n  const o = [0, 0, 0, 0];\n\n  o[3] += m[3] + n[3];\n  o[2] += o[3] >>> 16;\n  o[3] &= 0xffff;\n\n  o[2] += m[2] + n[2];\n  o[1] += o[2] >>> 16;\n  o[2] &= 0xffff;\n\n  o[1] += m[1] + n[1];\n  o[0] += o[1] >>> 16;\n  o[1] &= 0xffff;\n\n  o[0] += m[0] + n[0];\n  o[0] &= 0xffff;\n\n  return [(o[0] << 16) | o[1], (o[2] << 16) | o[3]];\n}\n\nfunction _x64Multiply(m: number[], n: number[]) {\n  //\n  // Given two 64bit ints (as an array of two 32bit ints) returns the two\n  // multiplied together as a 64bit int (as an array of two 32bit ints).\n  //\n\n  m = [m[0] >>> 16, m[0] & 0xffff, m[1] >>> 16, m[1] & 0xffff];\n  n = [n[0] >>> 16, n[0] & 0xffff, n[1] >>> 16, n[1] & 0xffff];\n  const o = [0, 0, 0, 0];\n\n  o[3] += m[3] * n[3];\n  o[2] += o[3] >>> 16;\n  o[3] &= 0xffff;\n\n  o[2] += m[2] * n[3];\n  o[1] += o[2] >>> 16;\n  o[2] &= 0xffff;\n\n  o[2] += m[3] * n[2];\n  o[1] += o[2] >>> 16;\n  o[2] &= 0xffff;\n\n  o[1] += m[1] * n[3];\n  o[0] += o[1] >>> 16;\n  o[1] &= 0xffff;\n\n  o[1] += m[2] * n[2];\n  o[0] += o[1] >>> 16;\n  o[1] &= 0xffff;\n\n  o[1] += m[3] * n[1];\n  o[0] += o[1] >>> 16;\n  o[1] &= 0xffff;\n\n  o[0] += m[0] * n[3] + m[1] * n[2] + m[2] * n[1] + m[3] * n[0];\n  o[0] &= 0xffff;\n\n  return [(o[0] << 16) | o[1], (o[2] << 16) | o[3]];\n}\n\nfunction _x64Rotl(m: number[], n: number) {\n  //\n  // Given a 64bit int (as an array of two 32bit ints) and an int\n  // representing a number of bit positions, returns the 64bit int (as an\n  // array of two 32bit ints) rotated left by that number of positions.\n  //\n\n  n %= 64;\n\n  if (n === 32) {\n    return [m[1], m[0]];\n  } else if (n < 32) {\n    return [(m[0] << n) | (m[1] >>> (32 - n)), (m[1] << n) | (m[0] >>> (32 - n))];\n  } else {\n    n -= 32;\n    return [(m[1] << n) | (m[0] >>> (32 - n)), (m[0] << n) | (m[1] >>> (32 - n))];\n  }\n}\n\nfunction _x64LeftShift(m: number[], n: number) {\n  //\n  // Given a 64bit int (as an array of two 32bit ints) and an int\n  // representing a number of bit positions, returns the 64bit int (as an\n  // array of two 32bit ints) shifted left by that number of positions.\n  //\n\n  n %= 64;\n\n  if (n === 0) {\n    return m;\n  } else if (n < 32) {\n    return [(m[0] << n) | (m[1] >>> (32 - n)), m[1] << n];\n  } else {\n    return [m[1] << (n - 32), 0];\n  }\n}\n\nfunction _x64Xor(m: number[], n: number[]) {\n  //\n  // Given two 64bit ints (as an array of two 32bit ints) returns the two\n  // xored together as a 64bit int (as an array of two 32bit ints).\n  //\n\n  return [m[0] ^ n[0], m[1] ^ n[1]];\n}\n\nfunction _x64Fmix(h: number[]) {\n  //\n  // Given a block, returns murmurHash3's final x64 mix of that block.\n  // (`[0, h[0] >>> 1]` is a 33 bit unsigned right shift. This is the\n  // only place where we need to right shift 64bit ints.)\n  //\n\n  h = _x64Xor(h, [0, h[0] >>> 1]);\n  h = _x64Multiply(h, [0xff51afd7, 0xed558ccd]);\n  h = _x64Xor(h, [0, h[0] >>> 1]);\n  h = _x64Multiply(h, [0xc4ceb9fe, 0x1a85ec53]);\n  h = _x64Xor(h, [0, h[0] >>> 1]);\n\n  return h;\n}\n\n// PUBLIC FUNCTIONS\n// ----------------\n\nfunction x86Hash32(bytes: Uint8Array, seed?: number) {\n  //\n  // Given a string and an optional seed as an int, returns a 32 bit hash\n  // using the x86 flavor of MurmurHash3, as an unsigned int.\n  //\n  seed = seed || 0;\n\n  const remainder = bytes.length % 4;\n  const blocks = bytes.length - remainder;\n\n  let h1 = seed;\n\n  let k1 = 0;\n\n  const c1 = 0xcc9e2d51;\n  const c2 = 0x1b873593;\n  let j = 0;\n\n  for (let i = 0; i < blocks; i = i + 4) {\n    k1 = bytes[i] | (bytes[i + 1] << 8) | (bytes[i + 2] << 16) | (bytes[i + 3] << 24);\n\n    k1 = _x86Multiply(k1, c1);\n    k1 = _x86Rotl(k1, 15);\n    k1 = _x86Multiply(k1, c2);\n\n    h1 ^= k1;\n    h1 = _x86Rotl(h1, 13);\n    h1 = _x86Multiply(h1, 5) + 0xe6546b64;\n    j = i + 4;\n  }\n\n  k1 = 0;\n\n  switch (remainder) {\n    case 3:\n      k1 ^= bytes[j + 2] << 16;\n\n    case 2:\n      k1 ^= bytes[j + 1] << 8;\n\n    case 1:\n      k1 ^= bytes[j];\n      k1 = _x86Multiply(k1, c1);\n      k1 = _x86Rotl(k1, 15);\n      k1 = _x86Multiply(k1, c2);\n      h1 ^= k1;\n  }\n\n  h1 ^= bytes.length;\n  h1 = _x86Fmix(h1);\n\n  return h1 >>> 0;\n}\n\nfunction x86Hash128(bytes: Uint8Array, seed?: number) {\n  //\n  // Given a string and an optional seed as an int, returns a 128 bit\n  // hash using the x86 flavor of MurmurHash3, as an unsigned hex.\n  //\n\n  seed = seed || 0;\n  const remainder = bytes.length % 16;\n  const blocks = bytes.length - remainder;\n\n  let h1 = seed;\n  let h2 = seed;\n  let h3 = seed;\n  let h4 = seed;\n\n  let k1 = 0;\n  let k2 = 0;\n  let k3 = 0;\n  let k4 = 0;\n\n  const c1 = 0x239b961b;\n  const c2 = 0xab0e9789;\n  const c3 = 0x38b34ae5;\n  const c4 = 0xa1e38b93;\n  let j = 0;\n\n  for (let i = 0; i < blocks; i = i + 16) {\n    k1 = bytes[i] | (bytes[i + 1] << 8) | (bytes[i + 2] << 16) | (bytes[i + 3] << 24);\n    k2 = bytes[i + 4] | (bytes[i + 5] << 8) | (bytes[i + 6] << 16) | (bytes[i + 7] << 24);\n    k3 = bytes[i + 8] | (bytes[i + 9] << 8) | (bytes[i + 10] << 16) | (bytes[i + 11] << 24);\n    k4 = bytes[i + 12] | (bytes[i + 13] << 8) | (bytes[i + 14] << 16) | (bytes[i + 15] << 24);\n\n    k1 = _x86Multiply(k1, c1);\n    k1 = _x86Rotl(k1, 15);\n    k1 = _x86Multiply(k1, c2);\n    h1 ^= k1;\n\n    h1 = _x86Rotl(h1, 19);\n    h1 += h2;\n    h1 = _x86Multiply(h1, 5) + 0x561ccd1b;\n\n    k2 = _x86Multiply(k2, c2);\n    k2 = _x86Rotl(k2, 16);\n    k2 = _x86Multiply(k2, c3);\n    h2 ^= k2;\n\n    h2 = _x86Rotl(h2, 17);\n    h2 += h3;\n    h2 = _x86Multiply(h2, 5) + 0x0bcaa747;\n\n    k3 = _x86Multiply(k3, c3);\n    k3 = _x86Rotl(k3, 17);\n    k3 = _x86Multiply(k3, c4);\n    h3 ^= k3;\n\n    h3 = _x86Rotl(h3, 15);\n    h3 += h4;\n    h3 = _x86Multiply(h3, 5) + 0x96cd1c35;\n\n    k4 = _x86Multiply(k4, c4);\n    k4 = _x86Rotl(k4, 18);\n    k4 = _x86Multiply(k4, c1);\n    h4 ^= k4;\n\n    h4 = _x86Rotl(h4, 13);\n    h4 += h1;\n    h4 = _x86Multiply(h4, 5) + 0x32ac3b17;\n    j = i + 16;\n  }\n\n  k1 = 0;\n  k2 = 0;\n  k3 = 0;\n  k4 = 0;\n\n  switch (remainder) {\n    case 15:\n      k4 ^= bytes[j + 14] << 16;\n\n    case 14:\n      k4 ^= bytes[j + 13] << 8;\n\n    case 13:\n      k4 ^= bytes[j + 12];\n      k4 = _x86Multiply(k4, c4);\n      k4 = _x86Rotl(k4, 18);\n      k4 = _x86Multiply(k4, c1);\n      h4 ^= k4;\n\n    case 12:\n      k3 ^= bytes[j + 11] << 24;\n\n    case 11:\n      k3 ^= bytes[j + 10] << 16;\n\n    case 10:\n      k3 ^= bytes[j + 9] << 8;\n\n    case 9:\n      k3 ^= bytes[j + 8];\n      k3 = _x86Multiply(k3, c3);\n      k3 = _x86Rotl(k3, 17);\n      k3 = _x86Multiply(k3, c4);\n      h3 ^= k3;\n\n    case 8:\n      k2 ^= bytes[j + 7] << 24;\n\n    case 7:\n      k2 ^= bytes[j + 6] << 16;\n\n    case 6:\n      k2 ^= bytes[j + 5] << 8;\n\n    case 5:\n      k2 ^= bytes[j + 4];\n      k2 = _x86Multiply(k2, c2);\n      k2 = _x86Rotl(k2, 16);\n      k2 = _x86Multiply(k2, c3);\n      h2 ^= k2;\n\n    case 4:\n      k1 ^= bytes[j + 3] << 24;\n\n    case 3:\n      k1 ^= bytes[j + 2] << 16;\n\n    case 2:\n      k1 ^= bytes[j + 1] << 8;\n\n    case 1:\n      k1 ^= bytes[j];\n      k1 = _x86Multiply(k1, c1);\n      k1 = _x86Rotl(k1, 15);\n      k1 = _x86Multiply(k1, c2);\n      h1 ^= k1;\n  }\n\n  h1 ^= bytes.length;\n  h2 ^= bytes.length;\n  h3 ^= bytes.length;\n  h4 ^= bytes.length;\n\n  h1 += h2;\n  h1 += h3;\n  h1 += h4;\n  h2 += h1;\n  h3 += h1;\n  h4 += h1;\n\n  h1 = _x86Fmix(h1);\n  h2 = _x86Fmix(h2);\n  h3 = _x86Fmix(h3);\n  h4 = _x86Fmix(h4);\n\n  h1 += h2;\n  h1 += h3;\n  h1 += h4;\n  h2 += h1;\n  h3 += h1;\n  h4 += h1;\n\n  return (\n    (\"00000000\" + (h1 >>> 0).toString(16)).slice(-8) +\n    (\"00000000\" + (h2 >>> 0).toString(16)).slice(-8) +\n    (\"00000000\" + (h3 >>> 0).toString(16)).slice(-8) +\n    (\"00000000\" + (h4 >>> 0).toString(16)).slice(-8)\n  );\n}\n\nfunction x64Hash128(bytes: Uint8Array, seed?: number) {\n  //\n  // Given a string and an optional seed as an int, returns a 128 bit\n  // hash using the x64 flavor of MurmurHash3, as an unsigned hex.\n  //\n  seed = seed || 0;\n\n  const remainder = bytes.length % 16;\n  const blocks = bytes.length - remainder;\n\n  let h1 = [0, seed];\n  let h2 = [0, seed];\n\n  let k1 = [0, 0];\n  let k2 = [0, 0];\n\n  const c1 = [0x87c37b91, 0x114253d5];\n  const c2 = [0x4cf5ad43, 0x2745937f];\n  let j = 0;\n\n  for (let i = 0; i < blocks; i = i + 16) {\n    k1 = [\n      bytes[i + 4] | (bytes[i + 5] << 8) | (bytes[i + 6] << 16) | (bytes[i + 7] << 24),\n      bytes[i] | (bytes[i + 1] << 8) | (bytes[i + 2] << 16) | (bytes[i + 3] << 24),\n    ];\n    k2 = [\n      bytes[i + 12] | (bytes[i + 13] << 8) | (bytes[i + 14] << 16) | (bytes[i + 15] << 24),\n      bytes[i + 8] | (bytes[i + 9] << 8) | (bytes[i + 10] << 16) | (bytes[i + 11] << 24),\n    ];\n\n    k1 = _x64Multiply(k1, c1);\n    k1 = _x64Rotl(k1, 31);\n    k1 = _x64Multiply(k1, c2);\n    h1 = _x64Xor(h1, k1);\n\n    h1 = _x64Rotl(h1, 27);\n    h1 = _x64Add(h1, h2);\n    h1 = _x64Add(_x64Multiply(h1, [0, 5]), [0, 0x52dce729]);\n\n    k2 = _x64Multiply(k2, c2);\n    k2 = _x64Rotl(k2, 33);\n    k2 = _x64Multiply(k2, c1);\n    h2 = _x64Xor(h2, k2);\n\n    h2 = _x64Rotl(h2, 31);\n    h2 = _x64Add(h2, h1);\n    h2 = _x64Add(_x64Multiply(h2, [0, 5]), [0, 0x38495ab5]);\n    j = i + 16;\n  }\n\n  k1 = [0, 0];\n  k2 = [0, 0];\n\n  switch (remainder) {\n    case 15:\n      k2 = _x64Xor(k2, _x64LeftShift([0, bytes[j + 14]], 48));\n\n    case 14:\n      k2 = _x64Xor(k2, _x64LeftShift([0, bytes[j + 13]], 40));\n\n    case 13:\n      k2 = _x64Xor(k2, _x64LeftShift([0, bytes[j + 12]], 32));\n\n    case 12:\n      k2 = _x64Xor(k2, _x64LeftShift([0, bytes[j + 11]], 24));\n\n    case 11:\n      k2 = _x64Xor(k2, _x64LeftShift([0, bytes[j + 10]], 16));\n\n    case 10:\n      k2 = _x64Xor(k2, _x64LeftShift([0, bytes[j + 9]], 8));\n\n    case 9:\n      k2 = _x64Xor(k2, [0, bytes[j + 8]]);\n      k2 = _x64Multiply(k2, c2);\n      k2 = _x64Rotl(k2, 33);\n      k2 = _x64Multiply(k2, c1);\n      h2 = _x64Xor(h2, k2);\n\n    case 8:\n      k1 = _x64Xor(k1, _x64LeftShift([0, bytes[j + 7]], 56));\n\n    case 7:\n      k1 = _x64Xor(k1, _x64LeftShift([0, bytes[j + 6]], 48));\n\n    case 6:\n      k1 = _x64Xor(k1, _x64LeftShift([0, bytes[j + 5]], 40));\n\n    case 5:\n      k1 = _x64Xor(k1, _x64LeftShift([0, bytes[j + 4]], 32));\n\n    case 4:\n      k1 = _x64Xor(k1, _x64LeftShift([0, bytes[j + 3]], 24));\n\n    case 3:\n      k1 = _x64Xor(k1, _x64LeftShift([0, bytes[j + 2]], 16));\n\n    case 2:\n      k1 = _x64Xor(k1, _x64LeftShift([0, bytes[j + 1]], 8));\n\n    case 1:\n      k1 = _x64Xor(k1, [0, bytes[j]]);\n      k1 = _x64Multiply(k1, c1);\n      k1 = _x64Rotl(k1, 31);\n      k1 = _x64Multiply(k1, c2);\n      h1 = _x64Xor(h1, k1);\n  }\n\n  h1 = _x64Xor(h1, [0, bytes.length]);\n  h2 = _x64Xor(h2, [0, bytes.length]);\n\n  h1 = _x64Add(h1, h2);\n  h2 = _x64Add(h2, h1);\n\n  h1 = _x64Fmix(h1);\n  h2 = _x64Fmix(h2);\n\n  h1 = _x64Add(h1, h2);\n  h2 = _x64Add(h2, h1);\n\n  // Here we reverse h1 and h2 in Cosmos\n  // This is an implementation detail and not part of the public spec\n  // Convert h1 to hex string and then to Uint8Array.\n  const h1Hex =\n    (\"00000000\" + (h1[0] >>> 0).toString(16)).slice(-8) +\n    (\"00000000\" + (h1[1] >>> 0).toString(16)).slice(-8);\n  const h1Buff = hexStringToUint8Array(h1Hex);\n  const h1Reversed = uint8ArrayToHex(reverse(h1Buff));\n\n  const h2Hex =\n    (\"00000000\" + (h2[0] >>> 0).toString(16)).slice(-8) +\n    (\"00000000\" + (h2[1] >>> 0).toString(16)).slice(-8);\n  const h2Buff = hexStringToUint8Array(h2Hex);\n  const h2Reversed = uint8ArrayToHex(reverse(h2Buff));\n  return h1Reversed + h2Reversed;\n}\n\nexport function reverse(buff: Uint8Array) {\n  const uint8array = new Uint8Array(buff.length);\n\n  for (let i = 0, j = buff.length - 1; i <= j; ++i, --j) {\n    uint8array[i] = buff[j];\n    uint8array[j] = buff[i];\n  }\n  return uint8array;\n}\n\nexport default {\n  version: \"3.0.0\",\n  x86: {\n    hash32: x86Hash32,\n    hash128: x86Hash128,\n  },\n  x64: {\n    hash128: x64Hash128,\n  },\n  inputValidation: true,\n};\n"],
   "mappings": "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",
   "names": []

package/dist/commonjs/utils/hashing/v1.js

@@ -107,3 +107,4 @@ function encodeByType(key) {
 0 && (module.exports = {
   hashV1PartitionKey
 });
+//# sourceMappingURL=v1.js.map

package/dist/commonjs/utils/hashing/v1.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["/mnt/vss/_work/1/s/sdk/cosmosdb/cosmos/src/utils/hashing/v1.ts"],
+  "sources": ["../../../../src/utils/hashing/v1.ts"],
   "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport { doubleToByteArrayBigInt, writeNumberForBinaryEncodingBigInt } from \"./encoding/number.js\";\nimport { writeStringForBinaryEncoding } from \"./encoding/string.js\";\nimport { BytePrefix } from \"./encoding/prefix.js\";\nimport MurmurHash from \"./murmurHash.js\";\nimport type { PrimitivePartitionKeyValue } from \"../../documents/index.js\";\nimport { concatUint8Arrays, hexStringToUint8Array, uint8ArrayToHex } from \"../uint8.js\";\n\nconst MAX_STRING_CHARS = 100;\n\nexport function hashV1PartitionKey(partitionKey: PrimitivePartitionKeyValue[]): string {\n  const key = partitionKey[0];\n  const toHash = prefixKeyByType(key);\n  const hash = MurmurHash.x86.hash32(toHash);\n  const encodedJSBI = writeNumberForBinaryEncodingBigInt(hash);\n  const encodedValue = encodeByType(key);\n  const finalHash = uint8ArrayToHex(concatUint8Arrays([encodedJSBI, encodedValue])).toUpperCase();\n  return finalHash;\n}\n\nfunction prefixKeyByType(key: PrimitivePartitionKeyValue): Uint8Array {\n  let bytes: Uint8Array;\n  switch (typeof key) {\n    case \"string\": {\n      const truncated = key.substr(0, MAX_STRING_CHARS);\n      bytes = concatUint8Arrays([\n        hexStringToUint8Array(BytePrefix.String),\n        new TextEncoder().encode(truncated),\n        hexStringToUint8Array(BytePrefix.Undefined),\n      ]);\n      return bytes;\n    }\n    case \"number\": {\n      const numberBytes = doubleToByteArrayBigInt(key);\n      bytes = concatUint8Arrays([hexStringToUint8Array(BytePrefix.Number), numberBytes]);\n      return bytes;\n    }\n    case \"boolean\": {\n      const prefix = key ? BytePrefix.True : BytePrefix.False;\n      return hexStringToUint8Array(prefix);\n    }\n    case \"object\": {\n      if (key === null) {\n        return hexStringToUint8Array(BytePrefix.Null);\n      }\n      return hexStringToUint8Array(BytePrefix.Undefined);\n    }\n    case \"undefined\": {\n      return hexStringToUint8Array(BytePrefix.Undefined);\n    }\n    default:\n      throw new Error(`Unexpected type: ${typeof key}`);\n  }\n}\n\nfunction encodeByType(key: PrimitivePartitionKeyValue): Uint8Array {\n  switch (typeof key) {\n    case \"string\": {\n      const truncated = key.substring(0, MAX_STRING_CHARS);\n      return writeStringForBinaryEncoding(truncated);\n    }\n    case \"number\": {\n      return writeNumberForBinaryEncodingBigInt(key);\n    }\n    case \"boolean\": {\n      const prefix = key ? BytePrefix.True : BytePrefix.False;\n      return hexStringToUint8Array(prefix);\n    }\n    case \"object\":\n      if (key === null) {\n        return hexStringToUint8Array(BytePrefix.Null);\n      }\n      return hexStringToUint8Array(BytePrefix.Undefined);\n    case \"undefined\":\n      return hexStringToUint8Array(BytePrefix.Undefined);\n    default:\n      throw new Error(`Unexpected type: ${typeof key}`);\n  }\n}\n"],
   "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,oBAA4E;AAC5E,oBAA6C;AAC7C,oBAA2B;AAC3B,wBAAuB;AAEvB,mBAA0E;AAE1E,MAAM,mBAAmB;AAElB,SAAS,mBAAmB,cAAoD;AACrF,QAAM,MAAM,aAAa,CAAC;AAC1B,QAAM,SAAS,gBAAgB,GAAG;AAClC,QAAM,OAAO,kBAAAA,QAAW,IAAI,OAAO,MAAM;AACzC,QAAM,kBAAc,kDAAmC,IAAI;AAC3D,QAAM,eAAe,aAAa,GAAG;AACrC,QAAM,gBAAY,kCAAgB,gCAAkB,CAAC,aAAa,YAAY,CAAC,CAAC,EAAE,YAAY;AAC9F,SAAO;AACT;AAEA,SAAS,gBAAgB,KAA6C;AACpE,MAAI;AACJ,UAAQ,OAAO,KAAK;AAAA,IAClB,KAAK,UAAU;AACb,YAAM,YAAY,IAAI,OAAO,GAAG,gBAAgB;AAChD,kBAAQ,gCAAkB;AAAA,YACxB,oCAAsB,yBAAW,MAAM;AAAA,QACvC,IAAI,YAAY,EAAE,OAAO,SAAS;AAAA,YAClC,oCAAsB,yBAAW,SAAS;AAAA,MAC5C,CAAC;AACD,aAAO;AAAA,IACT;AAAA,IACA,KAAK,UAAU;AACb,YAAM,kBAAc,uCAAwB,GAAG;AAC/C,kBAAQ,gCAAkB,KAAC,oCAAsB,yBAAW,MAAM,GAAG,WAAW,CAAC;AACjF,aAAO;AAAA,IACT;AAAA,IACA,KAAK,WAAW;AACd,YAAM,SAAS,MAAM,yBAAW,OAAO,yBAAW;AAClD,iBAAO,oCAAsB,MAAM;AAAA,IACrC;AAAA,IACA,KAAK,UAAU;AACb,UAAI,QAAQ,MAAM;AAChB,mBAAO,oCAAsB,yBAAW,IAAI;AAAA,MAC9C;AACA,iBAAO,oCAAsB,yBAAW,SAAS;AAAA,IACnD;AAAA,IACA,KAAK,aAAa;AAChB,iBAAO,oCAAsB,yBAAW,SAAS;AAAA,IACnD;AAAA,IACA;AACE,YAAM,IAAI,MAAM,oBAAoB,OAAO,GAAG,EAAE;AAAA,EACpD;AACF;AAEA,SAAS,aAAa,KAA6C;AACjE,UAAQ,OAAO,KAAK;AAAA,IAClB,KAAK,UAAU;AACb,YAAM,YAAY,IAAI,UAAU,GAAG,gBAAgB;AACnD,iBAAO,4CAA6B,SAAS;AAAA,IAC/C;AAAA,IACA,KAAK,UAAU;AACb,iBAAO,kDAAmC,GAAG;AAAA,IAC/C;AAAA,IACA,KAAK,WAAW;AACd,YAAM,SAAS,MAAM,yBAAW,OAAO,yBAAW;AAClD,iBAAO,oCAAsB,MAAM;AAAA,IACrC;AAAA,IACA,KAAK;AACH,UAAI,QAAQ,MAAM;AAChB,mBAAO,oCAAsB,yBAAW,IAAI;AAAA,MAC9C;AACA,iBAAO,oCAAsB,yBAAW,SAAS;AAAA,IACnD,KAAK;AACH,iBAAO,oCAAsB,yBAAW,SAAS;AAAA,IACnD;AACE,YAAM,IAAI,MAAM,oBAAoB,OAAO,GAAG,EAAE;AAAA,EACpD;AACF;",
   "names": ["MurmurHash"]