@serviceme/devtools-shared 0.4.11 → 0.4.12

package/dist/index.js

@@ -1619,8 +1619,115 @@ var CERTIFICATE_BUNDLE_FORMATS = [
   }
 ];
 
+// ../../node_modules/.pnpm/js-sha256@1.0.0/node_modules/js-sha256/src/node.mjs
+var import_crypto = require("crypto");
+
+// ../../node_modules/.pnpm/js-sha256@1.0.0/node_modules/js-sha256/src/shared.mjs
+var INPUT_ERROR = "input is invalid type";
+var FINALIZE_ERROR = "finalize already called";
+var ARRAY_BUFFER = typeof ArrayBuffer !== "undefined";
+var formatMessage = function(message) {
+  var type = typeof message;
+  if (type === "string") {
+    return [message, true];
+  }
+  if (Array.isArray(message)) {
+    return [message, false];
+  }
+  if (ARRAY_BUFFER && message) {
+    if (message.constructor === ArrayBuffer) {
+      return [new Uint8Array(message), false];
+    } else if (ArrayBuffer.isView(message)) {
+      return [message, false];
+    }
+  }
+  throw new Error(INPUT_ERROR);
+};
+
+// ../../node_modules/.pnpm/js-sha256@1.0.0/node_modules/js-sha256/src/node.mjs
+function toNodeInput(message) {
+  const [msg, isString] = formatMessage(message);
+  return isString ? Buffer.from(msg, "utf8") : Buffer.from(msg);
+}
+var NodeHasher = class {
+  constructor(hash) {
+    this.hash = hash;
+    this.result = void 0;
+  }
+  update(message) {
+    if (this.result) {
+      throw new Error(FINALIZE_ERROR);
+    }
+    this.hash.update(toNodeInput(message));
+    return this;
+  }
+  finalize() {
+    if (!this.result) {
+      this.result = this.hash.digest();
+      this.hash = void 0;
+    }
+  }
+  hex() {
+    this.finalize();
+    return this.result.toString("hex");
+  }
+  toString() {
+    return this.hex();
+  }
+  array() {
+    this.finalize();
+    return Array.from(this.result);
+  }
+  digest() {
+    return this.array();
+  }
+  arrayBuffer() {
+    return Uint8Array.from(this.array()).buffer;
+  }
+};
+function addOutputMethods(method, createHasher) {
+  method.hex = method;
+  method.array = function(...args) {
+    return createHasher(...args.slice(0, -1)).update(args[args.length - 1]).array();
+  };
+  method.digest = method.array;
+  method.arrayBuffer = function(...args) {
+    return createHasher(...args.slice(0, -1)).update(args[args.length - 1]).arrayBuffer();
+  };
+  return method;
+}
+function createNodeMethod(algorithm) {
+  const createHasher = () => new NodeHasher((0, import_crypto.createHash)(algorithm));
+  const method = function(message) {
+    return createHasher().update(message).hex();
+  };
+  addOutputMethods(method, createHasher);
+  method.create = createHasher;
+  method.update = function(message) {
+    return method.create().update(message);
+  };
+  return method;
+}
+function createNodeHmacMethod(algorithm) {
+  const createHasher = (key) => new NodeHasher((0, import_crypto.createHmac)(algorithm, toNodeInput(key)));
+  const method = function(key, message) {
+    return createHasher(key).update(message).hex();
+  };
+  addOutputMethods(method, createHasher);
+  method.create = createHasher;
+  method.update = function(key, message) {
+    return method.create(key).update(message);
+  };
+  return method;
+}
+var sha256 = createNodeMethod("sha256");
+var sha224 = createNodeMethod("sha224");
+sha256.sha256 = sha256;
+sha256.sha224 = sha224;
+sha256.hmac = createNodeHmacMethod("sha256");
+sha224.hmac = createNodeHmacMethod("sha224");
+
 // src/device-auth.ts
-var import_js_sha256 = require("js-sha256");
 var DeviceAuthHeaders = {
   deviceId: "x-ms-device-id",
   deviceSecret: "x-ms-device-secret",
@@ -1636,7 +1743,7 @@ function createDeviceRequestSignature(params) {
     params.body,
     params.secret
   ].join("\n");
-  return (0, import_js_sha256.sha256)(basis);
+  return sha256(basis);
 }
 
 // src/git-utils.ts

package/dist/index.mjs

@@ -1540,8 +1540,115 @@ var CERTIFICATE_BUNDLE_FORMATS = [
   }
 ];
 
+// ../../node_modules/.pnpm/js-sha256@1.0.0/node_modules/js-sha256/src/node.mjs
+import { createHash, createHmac } from "crypto";
+
+// ../../node_modules/.pnpm/js-sha256@1.0.0/node_modules/js-sha256/src/shared.mjs
+var INPUT_ERROR = "input is invalid type";
+var FINALIZE_ERROR = "finalize already called";
+var ARRAY_BUFFER = typeof ArrayBuffer !== "undefined";
+var formatMessage = function(message) {
+  var type = typeof message;
+  if (type === "string") {
+    return [message, true];
+  }
+  if (Array.isArray(message)) {
+    return [message, false];
+  }
+  if (ARRAY_BUFFER && message) {
+    if (message.constructor === ArrayBuffer) {
+      return [new Uint8Array(message), false];
+    } else if (ArrayBuffer.isView(message)) {
+      return [message, false];
+    }
+  }
+  throw new Error(INPUT_ERROR);
+};
+
+// ../../node_modules/.pnpm/js-sha256@1.0.0/node_modules/js-sha256/src/node.mjs
+function toNodeInput(message) {
+  const [msg, isString] = formatMessage(message);
+  return isString ? Buffer.from(msg, "utf8") : Buffer.from(msg);
+}
+var NodeHasher = class {
+  constructor(hash) {
+    this.hash = hash;
+    this.result = void 0;
+  }
+  update(message) {
+    if (this.result) {
+      throw new Error(FINALIZE_ERROR);
+    }
+    this.hash.update(toNodeInput(message));
+    return this;
+  }
+  finalize() {
+    if (!this.result) {
+      this.result = this.hash.digest();
+      this.hash = void 0;
+    }
+  }
+  hex() {
+    this.finalize();
+    return this.result.toString("hex");
+  }
+  toString() {
+    return this.hex();
+  }
+  array() {
+    this.finalize();
+    return Array.from(this.result);
+  }
+  digest() {
+    return this.array();
+  }
+  arrayBuffer() {
+    return Uint8Array.from(this.array()).buffer;
+  }
+};
+function addOutputMethods(method, createHasher) {
+  method.hex = method;
+  method.array = function(...args) {
+    return createHasher(...args.slice(0, -1)).update(args[args.length - 1]).array();
+  };
+  method.digest = method.array;
+  method.arrayBuffer = function(...args) {
+    return createHasher(...args.slice(0, -1)).update(args[args.length - 1]).arrayBuffer();
+  };
+  return method;
+}
+function createNodeMethod(algorithm) {
+  const createHasher = () => new NodeHasher(createHash(algorithm));
+  const method = function(message) {
+    return createHasher().update(message).hex();
+  };
+  addOutputMethods(method, createHasher);
+  method.create = createHasher;
+  method.update = function(message) {
+    return method.create().update(message);
+  };
+  return method;
+}
+function createNodeHmacMethod(algorithm) {
+  const createHasher = (key) => new NodeHasher(createHmac(algorithm, toNodeInput(key)));
+  const method = function(key, message) {
+    return createHasher(key).update(message).hex();
+  };
+  addOutputMethods(method, createHasher);
+  method.create = createHasher;
+  method.update = function(key, message) {
+    return method.create(key).update(message);
+  };
+  return method;
+}
+var sha256 = createNodeMethod("sha256");
+var sha224 = createNodeMethod("sha224");
+sha256.sha256 = sha256;
+sha256.sha224 = sha224;
+sha256.hmac = createNodeHmacMethod("sha256");
+sha224.hmac = createNodeHmacMethod("sha224");
+
 // src/device-auth.ts
-import { sha256 } from "js-sha256";
 var DeviceAuthHeaders = {
   deviceId: "x-ms-device-id",
   deviceSecret: "x-ms-device-secret",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serviceme/devtools-shared",
-  "version": "0.4.11",
+  "version": "0.4.12",
   "description": "Shared webview↔extension message contracts and cross-package data models used by SERVICEME.",
   "license": "SEE LICENSE IN LICENSE.md",
   "repository": {
@@ -46,8 +46,8 @@
     "lint": "biome check src test",
     "format": "biome check --write src test",
     "typecheck": "tsc --noEmit",
-    "test": "pnpm run build && node --test test/*.test.mjs",
-    "release:check": "pnpm run test && npm pack --dry-run",
+    "test": "pnpm run build && node scripts/check-bundle-deps.mjs && node --test test/*.test.mjs",
+    "release:check": "pnpm run test && node scripts/check-bundle-deps.mjs && npm pack --dry-run",
     "pack": "npm pack",
     "publish:npm": "pnpm publish --access public --no-git-checks"
   }