serverless-spy 2.2.3 → 2.2.5

package/node_modules/run-applescript/index.d.ts

@@ -1,3 +1,24 @@
+export type Options = {
+	/**
+	Change the output style.
+
+	When `false`, returns the value in a [recompilable source form](https://ss64.com/osx/osascript.html).
+
+	@default true
+
+	@example
+	```
+	import {runAppleScript} from 'run-applescript';
+
+	const result = await runAppleScript('return "unicorn"', {humanReadableOutput: false});
+
+	console.log(result);
+	//=> '"unicorn"'
+	```
+	*/
+	readonly humanReadableOutput?: boolean;
+};
+
 /**
 Run AppleScript asynchronously.
 
@@ -6,15 +27,18 @@ Run AppleScript asynchronously.
 
 @example
 ```
-import {runAppleScriptAsync} from 'run-applescript';
+import {runAppleScript} from 'run-applescript';
 
-const result = await runAppleScriptAsync('return "unicorn"');
+const result = await runAppleScript('return "unicorn"');
 
 console.log(result);
 //=> 'unicorn'
 ```
 */
-export function runAppleScriptAsync(script: string): Promise<string>;
+export function runAppleScript(
+	script: string,
+	options?: Options
+): Promise<string>;
 
 /**
 Run AppleScript synchronously.
@@ -32,4 +56,4 @@ console.log(result);
 //=> 'unicorn'
 ```
 */
-export function runAppleScriptSync(script: string): string;
+export function runAppleScriptSync(script: string, options?: Options): string;

package/node_modules/run-applescript/index.js

@@ -1,19 +1,32 @@
-import execa from 'execa';
+import process from 'node:process';
+import {promisify} from 'node:util';
+import {execFile, execFileSync} from 'node:child_process';
 
-export async function runAppleScriptAsync(script) {
+const execFileAsync = promisify(execFile);
+
+export async function runAppleScript(script, {humanReadableOutput = true} = {}) {
 	if (process.platform !== 'darwin') {
 		throw new Error('macOS only');
 	}
 
-	const {stdout} = await execa('osascript', ['-e', script]);
-	return stdout;
+	const outputArguments = humanReadableOutput ? [] : ['-ss'];
+
+	const {stdout} = await execFileAsync('osascript', ['-e', script, outputArguments]);
+	return stdout.trim();
 }
 
-export function runAppleScriptSync(script) {
+export function runAppleScriptSync(script, {humanReadableOutput = true} = {}) {
 	if (process.platform !== 'darwin') {
 		throw new Error('macOS only');
 	}
 
-	const {stdout} = execa.sync('osascript', ['-e', script]);
-	return stdout;
+	const outputArguments = humanReadableOutput ? [] : ['-ss'];
+
+	const stdout = execFileSync('osascript', ['-e', script, ...outputArguments], {
+		encoding: 'utf8',
+		stdio: ['ignore', 'pipe', 'ignore'],
+		timeout: 500,
+	});
+
+	return stdout.trim();
 }

package/node_modules/run-applescript/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "run-applescript",
-	"version": "5.0.0",
+	"version": "7.0.0",
 	"description": "Run AppleScript and get the result",
 	"license": "MIT",
 	"repository": "sindresorhus/run-applescript",
@@ -11,9 +11,13 @@
 		"url": "https://sindresorhus.com"
 	},
 	"type": "module",
-	"exports": "./index.js",
+	"exports": {
+		"types": "./index.d.ts",
+		"default": "./index.js"
+	},
+	"sideEffects": false,
 	"engines": {
-		"node": ">=12"
+		"node": ">=18"
 	},
 	"scripts": {
 		"test": "xo && ava && tsd"
@@ -30,12 +34,9 @@
 		"run",
 		"execute"
 	],
-	"dependencies": {
-		"execa": "^5.0.0"
-	},
 	"devDependencies": {
-		"ava": "^3.15.0",
-		"tsd": "^0.14.0",
-		"xo": "^0.38.2"
+		"ava": "^6.0.1",
+		"tsd": "^0.30.0",
+		"xo": "^0.56.0"
 	}
 }

package/node_modules/run-applescript/readme.md

@@ -4,16 +4,16 @@
 
 ## Install
 
-```
-$ npm install run-applescript
+```sh
+npm install run-applescript
 ```
 
 ## Usage
 
 ```js
-import {runAppleScriptAsync} from 'run-applescript';
+import {runAppleScript} from 'run-applescript';
 
-const result = await runAppleScriptAsync('return "unicorn"');
+const result = await runAppleScript('return "unicorn"');
 
 console.log(result);
 //=> 'unicorn'
@@ -21,14 +21,52 @@ console.log(result);
 
 ## API
 
-### runAppleScriptAsync(script)
+### runAppleScript(script, options?)
 
 Returns a `Promise<string>` with the script result.
 
-### runAppleScriptSync(script)
+#### script
+
+Type: `string`
+
+The script to run.
+
+#### options
+
+Type: `object`
+
+##### humanReadableOutput
+
+Type: `boolean`\
+Default: `true`
+
+Change the output style.
+
+When `false`, returns the value in a [recompilable source form](https://ss64.com/osx/osascript.html).
+
+### runAppleScriptSync(script, options?)
 
 Returns a `string` with the script result.
 
+#### script
+
+Type: `string`
+
+The script to run.
+
+#### options
+
+Type: `object`
+
+##### humanReadableOutput
+
+Type: `boolean`\
+Default: `true`
+
+Change the output style.
+
+When `false`, returns the value in a [recompilable source form](https://ss64.com/osx/osascript.html).
+
 ## Related
 
 - [run-jxa](https://github.com/sindresorhus/run-jxa) - Run JXA code and get the result

package/node_modules/ws/README.md

@@ -11,8 +11,8 @@ Passes the quite extensive Autobahn test suite: [server][server-report],
 [client][client-report].
 
 **Note**: This module does not work in the browser. The client in the docs is a
-reference to a back end with the role of a client in the WebSocket
-communication. Browser clients must use the native
+reference to a backend with the role of a client in the WebSocket communication.
+Browser clients must use the native
 [`WebSocket`](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket)
 object. To make the same code work seamlessly on Node.js and the browser, you
 can use one of the many wrappers available on npm, like
@@ -87,7 +87,7 @@ npm install --save-optional utf-8-validate
 
 This contains a binary polyfill for [`buffer.isUtf8()`][].
 
-To force ws to not use utf-8-validate, use the
+To force ws not to use utf-8-validate, use the
 [`WS_NO_UTF_8_VALIDATE`](./doc/ws.md#ws_no_utf_8_validate) environment variable.
 
 ## API docs
@@ -146,7 +146,7 @@ const wss = new WebSocketServer({
 ```
 
 The client will only use the extension if it is supported and enabled on the
-server. To always disable the extension on the client set the
+server. To always disable the extension on the client, set the
 `perMessageDeflate` option to `false`.
 
 ```js
@@ -245,7 +245,6 @@ server.listen(8080);
 
 ```js
 import { createServer } from 'http';
-import { parse } from 'url';
 import { WebSocketServer } from 'ws';
 
 const server = createServer();
@@ -265,7 +264,7 @@ wss2.on('connection', function connection(ws) {
 });
 
 server.on('upgrade', function upgrade(request, socket, head) {
-  const { pathname } = parse(request.url);
+  const { pathname } = new URL(request.url, 'wss://base.url');
 
   if (pathname === '/foo') {
     wss1.handleUpgrade(request, socket, head, function done(ws) {
@@ -452,11 +451,11 @@ wss.on('connection', function connection(ws, req) {
 
 ### How to detect and close broken connections?
 
-Sometimes the link between the server and the client can be interrupted in a way
-that keeps both the server and the client unaware of the broken state of the
+Sometimes, the link between the server and the client can be interrupted in a
+way that keeps both the server and the client unaware of the broken state of the
 connection (e.g. when pulling the cord).
 
-In these cases ping messages can be used as a means to verify that the remote
+In these cases, ping messages can be used as a means to verify that the remote
 endpoint is still responsive.
 
 ```js
@@ -491,7 +490,7 @@ wss.on('close', function close() {
 Pong messages are automatically sent in response to ping messages as required by
 the spec.
 
-Just like the server example above your clients might as well lose connection
+Just like the server example above, your clients might as well lose connection
 without knowing it. You might want to add a ping listener on your clients to
 prevent that. A simple implementation would be:
 

package/node_modules/ws/lib/constants.js

@@ -1,9 +1,15 @@
 'use strict';
 
+const BINARY_TYPES = ['nodebuffer', 'arraybuffer', 'fragments'];
+const hasBlob = typeof Blob !== 'undefined';
+
+if (hasBlob) BINARY_TYPES.push('blob');
+
 module.exports = {
-  BINARY_TYPES: ['nodebuffer', 'arraybuffer', 'fragments'],
+  BINARY_TYPES,
   EMPTY_BUFFER: Buffer.alloc(0),
   GUID: '258EAFA5-E914-47DA-95CA-C5AB0DC85B11',
+  hasBlob,
   kForOnEventAttribute: Symbol('kIsForOnEventAttribute'),
   kListener: Symbol('kListener'),
   kStatusCode: Symbol('status-code'),

package/node_modules/ws/lib/receiver.js

@@ -13,13 +13,6 @@ const { concat, toArrayBuffer, unmask } = require('./buffer-util');
 const { isValidStatusCode, isValidUTF8 } = require('./validation');
 
 const FastBuffer = Buffer[Symbol.species];
-const promise = Promise.resolve();
-
-//
-// `queueMicrotask()` is not available in Node.js < 11.
-//
-const queueTask =
-  typeof queueMicrotask === 'function' ? queueMicrotask : queueMicrotaskShim;
 
 const GET_INFO = 0;
 const GET_PAYLOAD_LENGTH_16 = 1;
@@ -39,7 +32,7 @@ class Receiver extends Writable {
    * Creates a Receiver instance.
    *
    * @param {Object} [options] Options object
-   * @param {Boolean} [options.allowSynchronousEvents=false] Specifies whether
+   * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether
    *     any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
    *     multiple times in the same tick
    * @param {String} [options.binaryType=nodebuffer] The type for binary data
@@ -54,7 +47,10 @@ class Receiver extends Writable {
   constructor(options = {}) {
     super();
 
-    this._allowSynchronousEvents = !!options.allowSynchronousEvents;
+    this._allowSynchronousEvents =
+      options.allowSynchronousEvents !== undefined
+        ? options.allowSynchronousEvents
+        : true;
     this._binaryType = options.binaryType || BINARY_TYPES[0];
     this._extensions = options.extensions || {};
     this._isServer = !!options.isServer;
@@ -563,21 +559,18 @@ class Receiver extends Writable {
         data = concat(fragments, messageLength);
       } else if (this._binaryType === 'arraybuffer') {
         data = toArrayBuffer(concat(fragments, messageLength));
+      } else if (this._binaryType === 'blob') {
+        data = new Blob(fragments);
       } else {
         data = fragments;
       }
 
-      //
-      // If the state is `INFLATING`, it means that the frame data was
-      // decompressed asynchronously, so there is no need to defer the event
-      // as it will be emitted asynchronously anyway.
-      //
-      if (this._state === INFLATING || this._allowSynchronousEvents) {
+      if (this._allowSynchronousEvents) {
         this.emit('message', data, true);
         this._state = GET_INFO;
       } else {
         this._state = DEFER_EVENT;
-        queueTask(() => {
+        setImmediate(() => {
           this.emit('message', data, true);
           this._state = GET_INFO;
           this.startLoop(cb);
@@ -604,7 +597,7 @@ class Receiver extends Writable {
         this._state = GET_INFO;
       } else {
         this._state = DEFER_EVENT;
-        queueTask(() => {
+        setImmediate(() => {
           this.emit('message', buf, false);
           this._state = GET_INFO;
           this.startLoop(cb);
@@ -675,7 +668,7 @@ class Receiver extends Writable {
       this._state = GET_INFO;
     } else {
       this._state = DEFER_EVENT;
-      queueTask(() => {
+      setImmediate(() => {
         this.emit(this._opcode === 0x09 ? 'ping' : 'pong', data);
         this._state = GET_INFO;
         this.startLoop(cb);
@@ -711,32 +704,3 @@ class Receiver extends Writable {
 }
 
 module.exports = Receiver;
-
-/**
- * A shim for `queueMicrotask()`.
- *
- * @param {Function} cb Callback
- */
-function queueMicrotaskShim(cb) {
-  promise.then(cb).catch(throwErrorNextTick);
-}
-
-/**
- * Throws an error.
- *
- * @param {Error} err The error to throw
- * @private
- */
-function throwError(err) {
-  throw err;
-}
-
-/**
- * Throws an error in the next tick.
- *
- * @param {Error} err The error to throw
- * @private
- */
-function throwErrorNextTick(err) {
-  process.nextTick(throwError, err);
-}