wherdr 0.0.0-stage → 1.3.0

package/.output/server/node_modules/vue-bundle-renderer/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "vue-bundle-renderer",
+  "version": "2.4.0",
+  "description": "Bundle Renderer for Vue 3.0",
+  "repository": {
+    "type": "git",
+    "url": "nuxt-contrib/vue-bundle-renderer"
+  },
+  "license": "MIT",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./runtime": {
+      "types": "./dist/runtime.d.mts",
+      "import": "./dist/runtime.mjs",
+      "require": "./dist/runtime.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist",
+    "runtime.d.ts"
+  ],
+  "dependencies": {
+    "ufo": "^1.6.4"
+  },
+  "devDependencies": {
+    "@codspeed/vitest-plugin": "^5.7.1",
+    "@nuxt/eslint-config": "^1.17.0",
+    "@types/node": "^24.13.4",
+    "@vitest/coverage-v8": "^4.1.11",
+    "eslint": "^10.10.0",
+    "pkg-pr-new": "^0.0.88",
+    "std-env": "^4.2.0",
+    "tsdown": "0.23.0",
+    "typescript": "^6.0.3",
+    "vite": "^8.3.0",
+    "vitest": "4.1.11",
+    "vue": "3.5.42"
+  },
+  "devEngines": {
+    "runtime": {
+      "name": "node",
+      "version": "^24.0.0",
+      "onFail": "download"
+    },
+    "packageManager": {
+      "name": "pnpm",
+      "version": "12.3.4",
+      "onFail": "download"
+    }
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "vitest",
+    "lint": "eslint src",
+    "test": "pnpm lint && pnpm vitest run --coverage && tsc --noEmit",
+    "bench": "vitest bench"
+  }
+}

package/.output/server/node_modules/web-push/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "web-push",
+  "version": "3.6.7",
+  "description": "Web Push library for Node.js",
+  "main": "src/index.js",
+  "bin": {
+    "web-push": "src/cli.js"
+  },
+  "scripts": {
+    "download-browser": "node --harmony ./test/helpers/download-test-browsers.js",
+    "lint": "node ./node_modules/eslint/bin/eslint --ignore-path .gitignore '.'",
+    "pretest": "npm run lint && npm run download-browser",
+    "test": "nyc --reporter=lcov --reporter=text mocha -- --ui tdd test/test*"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/web-push-libs/web-push.git"
+  },
+  "keywords": [
+    "web push",
+    "push",
+    "notifications",
+    "push notifications"
+  ],
+  "author": "Marco Castelluccio",
+  "license": "MPL-2.0",
+  "bugs": {
+    "url": "https://github.com/web-push-libs/web-push/issues"
+  },
+  "homepage": "https://github.com/web-push-libs/web-push#readme",
+  "dependencies": {
+    "asn1.js": "^5.3.0",
+    "http_ece": "1.2.0",
+    "https-proxy-agent": "^7.0.0",
+    "jws": "^4.0.0",
+    "minimist": "^1.2.5"
+  },
+  "devDependencies": {
+    "chromedriver": "120.0.1",
+    "del": "6.0.0",
+    "eslint": "8.56.0",
+    "eslint-config-airbnb": "19.0.4",
+    "eslint-plugin-import": "2.29.1",
+    "geckodriver": "4.3.0",
+    "nyc": "15.1.0",
+    "mkdirp": "3.0.1",
+    "mocha": "10.2.0",
+    "portfinder": "1.0.32",
+    "selenium-assistant": "5.4.0",
+    "sinon": "17.0.1"
+  },
+  "engines": {
+    "node": ">= 16"
+  }
+}

package/.output/server/node_modules/web-push/src/encryption-helper.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const crypto = require('crypto');
+const ece = require('http_ece');
+
+const encrypt = function(userPublicKey, userAuth, payload, contentEncoding) {
+  if (!userPublicKey) {
+    throw new Error('No user public key provided for encryption.');
+  }
+
+  if (typeof userPublicKey !== 'string') {
+    throw new Error('The subscription p256dh value must be a string.');
+  }
+
+  if (Buffer.from(userPublicKey, 'base64url').length !== 65) {
+    throw new Error('The subscription p256dh value should be 65 bytes long.');
+  }
+
+  if (!userAuth) {
+    throw new Error('No user auth provided for encryption.');
+  }
+
+  if (typeof userAuth !== 'string') {
+    throw new Error('The subscription auth key must be a string.');
+  }
+
+  if (Buffer.from(userAuth, 'base64url').length < 16) {
+    throw new Error('The subscription auth key should be at least 16 '
+    + 'bytes long');
+  }
+
+  if (typeof payload !== 'string' && !Buffer.isBuffer(payload)) {
+    throw new Error('Payload must be either a string or a Node Buffer.');
+  }
+
+  if (typeof payload === 'string' || payload instanceof String) {
+    payload = Buffer.from(payload);
+  }
+
+  const localCurve = crypto.createECDH('prime256v1');
+  const localPublicKey = localCurve.generateKeys();
+
+  const salt = crypto.randomBytes(16).toString('base64url');
+
+  const cipherText = ece.encrypt(payload, {
+    version: contentEncoding,
+    dh: userPublicKey,
+    privateKey: localCurve,
+    salt: salt,
+    authSecret: userAuth
+  });
+
+  return {
+    localPublicKey: localPublicKey,
+    salt: salt,
+    cipherText: cipherText
+  };
+};
+
+module.exports = {
+  encrypt: encrypt
+};

package/.output/server/node_modules/web-push/src/index.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const vapidHelper = require('./vapid-helper.js');
+const encryptionHelper = require('./encryption-helper.js');
+const WebPushLib = require('./web-push-lib.js');
+const WebPushError = require('./web-push-error.js');
+const WebPushConstants = require('./web-push-constants.js');
+
+const webPush = new WebPushLib();
+
+module.exports = {
+  WebPushError: WebPushError,
+  supportedContentEncodings: WebPushConstants.supportedContentEncodings,
+  encrypt: encryptionHelper.encrypt,
+  getVapidHeaders: vapidHelper.getVapidHeaders,
+  generateVAPIDKeys: vapidHelper.generateVAPIDKeys,
+  setGCMAPIKey: webPush.setGCMAPIKey,
+  setVapidDetails: webPush.setVapidDetails,
+  generateRequestDetails: webPush.generateRequestDetails,
+  sendNotification: webPush.sendNotification.bind(webPush)
+};

package/.output/server/node_modules/web-push/src/urlsafe-base64-helper.js

@@ -0,0 +1,13 @@
+'use strict';
+
+/**
+ * @param {string} base64
+ * @returns {boolean}
+ */
+function validate(base64) {
+  return /^[A-Za-z0-9\-_]+$/.test(base64);
+}
+
+module.exports = {
+  validate: validate
+};

package/.output/server/node_modules/web-push/src/vapid-helper.js

@@ -0,0 +1,255 @@
+'use strict';
+
+const crypto = require('crypto');
+const asn1 = require('asn1.js');
+const jws = require('jws');
+const { URL } = require('url');
+
+const WebPushConstants = require('./web-push-constants.js');
+const urlBase64Helper = require('./urlsafe-base64-helper');
+
+/**
+ * DEFAULT_EXPIRATION is set to seconds in 12 hours
+ */
+const DEFAULT_EXPIRATION_SECONDS = 12 * 60 * 60;
+
+// Maximum expiration is 24 hours according. (See VAPID spec)
+const MAX_EXPIRATION_SECONDS = 24 * 60 * 60;
+
+const ECPrivateKeyASN = asn1.define('ECPrivateKey', function() {
+  this.seq().obj(
+    this.key('version').int(),
+    this.key('privateKey').octstr(),
+    this.key('parameters').explicit(0).objid()
+      .optional(),
+    this.key('publicKey').explicit(1).bitstr()
+      .optional()
+  );
+});
+
+function toPEM(key) {
+  return ECPrivateKeyASN.encode({
+    version: 1,
+    privateKey: key,
+    parameters: [1, 2, 840, 10045, 3, 1, 7] // prime256v1
+  }, 'pem', {
+    label: 'EC PRIVATE KEY'
+  });
+}
+
+function generateVAPIDKeys() {
+  const curve = crypto.createECDH('prime256v1');
+  curve.generateKeys();
+
+  let publicKeyBuffer = curve.getPublicKey();
+  let privateKeyBuffer = curve.getPrivateKey();
+
+  // Occassionally the keys will not be padded to the correct lengh resulting
+  // in errors, hence this padding.
+  // See https://github.com/web-push-libs/web-push/issues/295 for history.
+  if (privateKeyBuffer.length < 32) {
+    const padding = Buffer.alloc(32 - privateKeyBuffer.length);
+    padding.fill(0);
+    privateKeyBuffer = Buffer.concat([padding, privateKeyBuffer]);
+  }
+
+  if (publicKeyBuffer.length < 65) {
+    const padding = Buffer.alloc(65 - publicKeyBuffer.length);
+    padding.fill(0);
+    publicKeyBuffer = Buffer.concat([padding, publicKeyBuffer]);
+  }
+
+  return {
+    publicKey: publicKeyBuffer.toString('base64url'),
+    privateKey: privateKeyBuffer.toString('base64url')
+  };
+}
+
+function validateSubject(subject) {
+  if (!subject) {
+    throw new Error('No subject set in vapidDetails.subject.');
+  }
+
+  if (typeof subject !== 'string' || subject.length === 0) {
+    throw new Error('The subject value must be a string containing an https: URL or '
+    + 'mailto: address. ' + subject);
+  }
+
+  let subjectParseResult = null;
+  try {
+    subjectParseResult = new URL(subject);
+  } catch (err) {
+    throw new Error('Vapid subject is not a valid URL. ' + subject);
+  }
+  if (!['https:', 'mailto:'].includes(subjectParseResult.protocol)) {
+    throw new Error('Vapid subject is not an https: or mailto: URL. ' + subject);
+  }
+  if (subjectParseResult.hostname === 'localhost') {
+    console.warn('Vapid subject points to a localhost web URI, which is unsupported by '
+      + 'Apple\'s push notification server and will result in a BadJwtToken error when '
+      + 'sending notifications.');
+    }
+}
+
+function validatePublicKey(publicKey) {
+  if (!publicKey) {
+    throw new Error('No key set vapidDetails.publicKey');
+  }
+
+  if (typeof publicKey !== 'string') {
+    throw new Error('Vapid public key is must be a URL safe Base 64 '
+    + 'encoded string.');
+  }
+
+  if (!urlBase64Helper.validate(publicKey)) {
+    throw new Error('Vapid public key must be a URL safe Base 64 (without "=")');
+  }
+
+  publicKey = Buffer.from(publicKey, 'base64url');
+
+  if (publicKey.length !== 65) {
+    throw new Error('Vapid public key should be 65 bytes long when decoded.');
+  }
+}
+
+function validatePrivateKey(privateKey) {
+  if (!privateKey) {
+    throw new Error('No key set in vapidDetails.privateKey');
+  }
+
+  if (typeof privateKey !== 'string') {
+    throw new Error('Vapid private key must be a URL safe Base 64 '
+    + 'encoded string.');
+  }
+
+  if (!urlBase64Helper.validate(privateKey)) {
+    throw new Error('Vapid private key must be a URL safe Base 64 (without "=")');
+  }
+
+  privateKey = Buffer.from(privateKey, 'base64url');
+
+  if (privateKey.length !== 32) {
+    throw new Error('Vapid private key should be 32 bytes long when decoded.');
+  }
+}
+
+/**
+ * Given the number of seconds calculates
+ * the expiration in the future by adding the passed `numSeconds`
+ * with the current seconds from Unix Epoch
+ *
+ * @param {Number} numSeconds Number of seconds to be added
+ * @return {Number} Future expiration in seconds
+ */
+function getFutureExpirationTimestamp(numSeconds) {
+  const futureExp = new Date();
+  futureExp.setSeconds(futureExp.getSeconds() + numSeconds);
+  return Math.floor(futureExp.getTime() / 1000);
+}
+
+/**
+ * Validates the Expiration Header based on the VAPID Spec
+ * Throws error of type `Error` if the expiration is not validated
+ *
+ * @param {Number} expiration Expiration seconds from Epoch to be validated
+ */
+function validateExpiration(expiration) {
+  if (!Number.isInteger(expiration)) {
+    throw new Error('`expiration` value must be a number');
+  }
+
+  if (expiration < 0) {
+    throw new Error('`expiration` must be a positive integer');
+  }
+
+  // Roughly checks the time of expiration, since the max expiration can be ahead
+  // of the time than at the moment the expiration was generated
+  const maxExpirationTimestamp = getFutureExpirationTimestamp(MAX_EXPIRATION_SECONDS);
+
+  if (expiration >= maxExpirationTimestamp) {
+    throw new Error('`expiration` value is greater than maximum of 24 hours');
+  }
+}
+
+/**
+ * This method takes the required VAPID parameters and returns the required
+ * header to be added to a Web Push Protocol Request.
+ * @param  {string} audience        This must be the origin of the push service.
+ * @param  {string} subject         This should be a URL or a 'mailto:' email
+ * address.
+ * @param  {string} publicKey       The VAPID public key.
+ * @param  {string} privateKey      The VAPID private key.
+ * @param  {string} contentEncoding The contentEncoding type.
+ * @param  {integer} [expiration]   The expiration of the VAPID JWT.
+ * @return {Object}                 Returns an Object with the Authorization and
+ * 'Crypto-Key' values to be used as headers.
+ */
+function getVapidHeaders(audience, subject, publicKey, privateKey, contentEncoding, expiration) {
+  if (!audience) {
+    throw new Error('No audience could be generated for VAPID.');
+  }
+
+  if (typeof audience !== 'string' || audience.length === 0) {
+    throw new Error('The audience value must be a string containing the '
+    + 'origin of a push service. ' + audience);
+  }
+
+  try {
+    new URL(audience); // eslint-disable-line no-new
+  } catch (err) {
+    throw new Error('VAPID audience is not a url. ' + audience);
+  }
+
+  validateSubject(subject);
+  validatePublicKey(publicKey);
+  validatePrivateKey(privateKey);
+
+  privateKey = Buffer.from(privateKey, 'base64url');
+
+  if (expiration) {
+    validateExpiration(expiration);
+  } else {
+    expiration = getFutureExpirationTimestamp(DEFAULT_EXPIRATION_SECONDS);
+  }
+
+  const header = {
+    typ: 'JWT',
+    alg: 'ES256'
+  };
+
+  const jwtPayload = {
+    aud: audience,
+    exp: expiration,
+    sub: subject
+  };
+
+  const jwt = jws.sign({
+    header: header,
+    payload: jwtPayload,
+    privateKey: toPEM(privateKey)
+  });
+
+  if (contentEncoding === WebPushConstants.supportedContentEncodings.AES_128_GCM) {
+    return {
+      Authorization: 'vapid t=' + jwt + ', k=' + publicKey
+    };
+  }
+  if (contentEncoding === WebPushConstants.supportedContentEncodings.AES_GCM) {
+    return {
+      Authorization: 'WebPush ' + jwt,
+      'Crypto-Key': 'p256ecdsa=' + publicKey
+    };
+  }
+
+  throw new Error('Unsupported encoding type specified.');
+}
+
+module.exports = {
+  generateVAPIDKeys: generateVAPIDKeys,
+  getFutureExpirationTimestamp: getFutureExpirationTimestamp,
+  getVapidHeaders: getVapidHeaders,
+  validateSubject: validateSubject,
+  validatePublicKey: validatePublicKey,
+  validatePrivateKey: validatePrivateKey,
+  validateExpiration: validateExpiration
+};

package/.output/server/node_modules/web-push/src/web-push-constants.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const WebPushConstants = {};
+
+WebPushConstants.supportedContentEncodings = {
+  AES_GCM: 'aesgcm',
+  AES_128_GCM: 'aes128gcm'
+};
+
+WebPushConstants.supportedUrgency = {
+  VERY_LOW: 'very-low',
+  LOW: 'low',
+  NORMAL: 'normal',
+  HIGH: 'high'
+};
+
+module.exports = WebPushConstants;

package/.output/server/node_modules/web-push/src/web-push-error.js

@@ -0,0 +1,16 @@
+'use strict';
+
+function WebPushError(message, statusCode, headers, body, endpoint) {
+  Error.captureStackTrace(this, this.constructor);
+
+  this.name = this.constructor.name;
+  this.message = message;
+  this.statusCode = statusCode;
+  this.headers = headers;
+  this.body = body;
+  this.endpoint = endpoint;
+}
+
+require('util').inherits(WebPushError, Error);
+
+module.exports = WebPushError;