Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

stagehand

Package Overview
Dependencies
Maintainers
1
Versions
2
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

stagehand - npm Package Compare versions

Comparing version 1.0.0 to 1.0.1

.github/workflows/ci.yml

22

.eslintrc.js

@@ -0,14 +1,18 @@

/* eslint-env node */
module.exports = {
extends: ['eslint:recommended', 'plugin:prettier/recommended'],
parser: 'typescript-eslint-parser',
extends: ['eslint:recommended', 'plugin:@typescript-eslint/recommended'],
parser: '@typescript-eslint/parser',
plugins: ['@typescript-eslint'],
parserOptions: {
sourceType: 'module'
sourceType: 'module',
},
rules: {
// Handled by TS
'no-undef': 'off',
'no-unused-vars': 'off',
'no-dupe-class-members': 'off',
'no-redeclare': 'off'
}
'prefer-const': 'off',
'@typescript-eslint/ban-types': 'off',
'@typescript-eslint/no-empty-function': 'off',
'@typescript-eslint/no-empty-interface': 'off',
'@typescript-eslint/no-explicit-any': 'off',
'@typescript-eslint/no-non-null-assertion': 'off',
'@typescript-eslint/no-unused-vars': 'off',
},
};

3

.prettierrc.js
module.exports = {
printWidth: 120,
parser: 'typescript',
singleQuote: true
singleQuote: true,
};

2

lib/adapters/child-process.d.ts
/// <reference types="node" />
import { MessageEndpoint, Implementation } from '..';
import { ChildProcess } from 'child_process';
export declare function launch<T>(handler: Implementation<T>): Promise<import("../stagehand").default>;
export declare function launch<T>(handler: Implementation<T>): Promise<import("../stagehand").default<T>>;
export declare function connect<T>(child: ChildProcess): Promise<import("..").Remote<T>>;
export declare function endpointForParentProcess(): MessageEndpoint;
export declare function endpointForChildProcess(child: ChildProcess): MessageEndpoint;

17

lib/adapters/child-process.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.endpointForChildProcess = exports.endpointForParentProcess = exports.connect = exports.launch = void 0;
const __1 = require("..");
function launch(handler) {
return __1.launch(endpointForParentProcess(), handler);
return (0, __1.launch)(endpointForParentProcess(), handler);
}
exports.launch = launch;
function connect(child) {
return __1.connect(endpointForChildProcess(child));
return (0, __1.connect)(endpointForChildProcess(child));
}

@@ -17,4 +18,4 @@ exports.connect = connect;

return {
onMessage: callback => process.addListener('message', callback),
sendMessage: message => process.send(message),
onMessage: (callback) => process.addListener('message', callback),
sendMessage: (message) => process.send(message),
disconnect: () => {

@@ -24,3 +25,3 @@ if (process.connected) {

}
}
},
};

@@ -31,4 +32,4 @@ }

return {
onMessage: callback => child.addListener('message', callback),
sendMessage: message => child.send(message),
onMessage: (callback) => child.addListener('message', callback),
sendMessage: (message) => child.send(message),
disconnect: () => {

@@ -38,5 +39,5 @@ if (child.connected) {

}
}
},
};
}
exports.endpointForChildProcess = endpointForChildProcess;

8

lib/adapters/in-memory.js
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());

@@ -11,2 +12,3 @@ });

Object.defineProperty(exports, "__esModule", { value: true });
exports.endpointPair = exports.connectLocal = void 0;
const __1 = require("..");

@@ -16,4 +18,4 @@ function connectLocal(handler) {

let [one, two] = endpointPair();
__1.launch(one, handler);
return __1.connect(two);
(0, __1.launch)(one, handler);
return (0, __1.connect)(two);
});

@@ -20,0 +22,0 @@ }

2

lib/adapters/web-worker.d.ts
import { MessageEndpoint, Implementation } from '..';
export declare function launch<T>(implementation: Implementation<T>): Promise<import("../stagehand").default>;
export declare function launch<T>(implementation: Implementation<T>): Promise<import("../stagehand").default<T>>;
export declare function connect<T>(worker: Worker): Promise<import("..").Remote<T>>;
export declare function endpointForWorker(worker: Worker): MessageEndpoint;
export declare function endpointForParent(): MessageEndpoint;

17

lib/adapters/web-worker.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.endpointForParent = exports.endpointForWorker = exports.connect = exports.launch = void 0;
const __1 = require("..");
function launch(implementation) {
return __1.launch(endpointForParent(), implementation);
return (0, __1.launch)(endpointForParent(), implementation);
}
exports.launch = launch;
function connect(worker) {
return __1.connect(endpointForWorker(worker));
return (0, __1.connect)(endpointForWorker(worker));
}

@@ -14,5 +15,5 @@ exports.connect = connect;

return {
onMessage: callback => worker.addEventListener('message', event => callback(event.data)),
sendMessage: message => worker.postMessage(message),
disconnect: () => worker.terminate()
onMessage: (callback) => worker.addEventListener('message', (event) => callback(event.data)),
sendMessage: (message) => worker.postMessage(message),
disconnect: () => worker.terminate(),
};

@@ -23,7 +24,7 @@ }

return {
onMessage: callback => addEventListener('message', event => callback(event.data)),
sendMessage: message => postMessage(message),
disconnect: () => close()
onMessage: (callback) => addEventListener('message', (event) => callback(event.data)),
sendMessage: (message) => postMessage(message),
disconnect: () => close(),
};
}
exports.endpointForParent = endpointForParent;

5

lib/command-coordinator.d.ts

@@ -20,8 +20,7 @@ import FunctionHandleRegistry from './function-handle-registry';

private sendMessage;
private pendingDeferred;
private isResponse;
private isCommand;
}
declare type CommandParams<T> = T extends (...params: infer Params) => any ? Params : never;
declare type CommandReturn<T> = T extends (...params: any[]) => infer Return ? Return : never;
type CommandParams<T> = T extends (...params: infer Params) => any ? Params : never;
type CommandReturn<T> = T extends (...params: any[]) => infer Return ? Return : never;
export {};

14

lib/command-coordinator.js
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());

@@ -16,3 +17,3 @@ });

const defer_1 = require("./utils/defer");
const debug = debug_1.default('stagehand:command-coordinator');
const debug = (0, debug_1.default)('stagehand:command-coordinator');
/**

@@ -34,3 +35,3 @@ * Coordinates command/response pairs across a given `MessageEndpoint`, returning

let seq = this.nextSeq++;
let dfd = defer_1.defer();
let dfd = (0, defer_1.defer)();
let command = { [COMMAND]: seq, name, args: this.handleRegistry.dehydrate(args) };

@@ -53,4 +54,6 @@ this.pendingCommands.set(seq, dfd);

dispatchResponse(response) {
let pending = this.pendingDeferred(response);
let key = response[RESPONSE];
let pending = this.pendingCommands.get(key);
if (pending !== undefined) {
this.pendingCommands.delete(key);
if (response.error) {

@@ -86,5 +89,2 @@ pending.reject(typeof response.value === 'string' ? new Error(response.value) : response.value);

}
pendingDeferred(response) {
return this.pendingCommands.get(response[RESPONSE]);
}
isResponse(message) {

@@ -91,0 +91,0 @@ return message && typeof message[RESPONSE] === 'number';

6

lib/function-handle-registry.d.ts
declare const DEHYDRATED: unique symbol;
declare const HANDLE: unique symbol;
export declare type Hydrated<T extends Dehydrated<any>> = T extends Dehydrated<infer U> ? U : never;
export declare type Dehydrated<T> = {
export type Hydrated<T extends Dehydrated<any>> = T extends Dehydrated<infer U> ? U : never;
export type Dehydrated<T> = {
[DEHYDRATED]: T;
};
declare const HANDLE_KEY = "--stagehand-function-handle";
export declare type Handle = typeof HANDLE;
export type Handle = typeof HANDLE;
export interface DehydratedHandle {

@@ -10,0 +10,0 @@ [HANDLE_KEY]: Handle;

6

lib/function-handle-registry.js

@@ -12,3 +12,3 @@ "use strict";

dehydrate(root) {
return walk(root, obj => {
return walk(root, (obj) => {
if (typeof obj === 'function') {

@@ -20,3 +20,3 @@ return dehydrateHandle(this.lookupOrGenerateHandle(obj));

rehydrate(root) {
return walk(root, obj => {
return walk(root, (obj) => {
if (isDehydratedHandle(obj)) {

@@ -73,3 +73,3 @@ return this.hydrateRemoteFunction(obj[HANDLE_KEY]);

if (Array.isArray(obj)) {
return obj.map(el => walk(el, handler));
return obj.map((el) => walk(el, handler));
}

@@ -76,0 +76,0 @@ if (typeof obj === 'object' && obj) {

8

lib/index.d.ts

@@ -8,4 +8,4 @@ import Stagehand from './stagehand';

*/
export declare type Remote<T> = RemoteType<MethodsOnly<T>> & {
[STAGEHAND_INSTANCE]: Stagehand;
export type Remote<T> = RemoteType<MethodsOnly<T>> & {
[STAGEHAND_INSTANCE]: Stagehand<T>;
};

@@ -18,3 +18,3 @@ /**

*/
export declare type Implementation<T> = HandlerType<T>;
export type Implementation<T> = HandlerType<T>;
/**

@@ -35,3 +35,3 @@ * The minimal interface needed for stagehand communication. The `adapters` directory contains

*/
export declare function launch<T>(endpoint: MessageEndpoint, implementation: Implementation<T>): Promise<Stagehand>;
export declare function launch<T>(endpoint: MessageEndpoint, implementation: Implementation<T>): Promise<Stagehand<T>>;
/**

@@ -38,0 +38,0 @@ * Given a message endpoint (and typically an explicit type parameter indicating the interface of

6

lib/index.js
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());

@@ -14,2 +15,3 @@ });

Object.defineProperty(exports, "__esModule", { value: true });
exports.disconnect = exports.connect = exports.launch = void 0;
const stagehand_1 = __importDefault(require("./stagehand"));

@@ -46,3 +48,3 @@ const STAGEHAND_INSTANCE = '--stagehand-instance';

Object.defineProperty(StagehandRemote.prototype, method, {
value: (...args) => stagehand.call(method, args)
value: (...args) => stagehand.call(method, args),
});

@@ -49,0 +51,0 @@ }

6

lib/stagehand.d.ts

@@ -1,3 +0,3 @@

import { MessageEndpoint } from './index';
export default class Stagehand {
import { Implementation, MessageEndpoint } from './index';
export default class Stagehand<T> {
private endpoint?;

@@ -7,3 +7,3 @@ private commandCoordinator?;

private implementation?;
constructor(implementation?: {});
constructor(implementation?: Implementation<T>);
isConnected(): boolean;

@@ -10,0 +10,0 @@ listen(endpoint: MessageEndpoint): Promise<void>;

7

lib/stagehand.js
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());

@@ -62,5 +63,5 @@ });

setTimeout(() => this.shutdown());
}
},
};
this.implementation = implementation;
this.implementation = implementation !== null && implementation !== void 0 ? implementation : null;
this.handleRegistry = new function_handle_registry_1.default(this.rehydrateRemoteFunction);

@@ -67,0 +68,0 @@ }

2

lib/utils/defer.d.ts

@@ -1,2 +0,2 @@

export declare type DeferredState = 'pending' | 'resolved' | 'rejected';
export type DeferredState = 'pending' | 'resolved' | 'rejected';
export interface Deferred<T> {

@@ -3,0 +3,0 @@ promise: Promise<T>;

1

lib/utils/defer.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.defer = void 0;
function defer() {

@@ -4,0 +5,0 @@ let dfd = {};

20

lib/utils/types.d.ts

@@ -1,10 +0,10 @@

export declare type Awaited<T> = T extends PromiseLike<infer TResult> ? TResult : T;
export declare type Omit<Obj, Keys> = Pick<Obj, Exclude<keyof Obj, Keys>>;
export declare type Values<T> = T[keyof T];
export declare type PropertiesAssignableToType<T, U> = Values<{
export type Awaited<T> = T extends PromiseLike<infer TResult> ? TResult : T;
export type Omit<Obj, Keys> = Pick<Obj, Exclude<keyof Obj, Keys>>;
export type Values<T> = T[keyof T];
export type PropertiesAssignableToType<T, U> = Values<{
[K in keyof T]: T[K] extends U ? K : never;
}>;
export declare type MethodsOnly<T> = Pick<T, PropertiesAssignableToType<T, Function>>;
export declare type MaybePromise<T> = T | Promise<T>;
declare type RemoteFunctionArgs<T extends any[]> = {
export type MethodsOnly<T> = Pick<T, PropertiesAssignableToType<T, Function>>;
export type MaybePromise<T> = T | Promise<T>;
type RemoteFunctionArgs<T extends any[]> = {
[K in keyof T]: HandlerType<T[K]>;

@@ -14,3 +14,3 @@ };

}
export declare type RemoteType<T> = T extends (...args: infer Args) => infer Return ? (...args: RemoteFunctionArgs<Args>) => Promise<RemoteType<Awaited<Return>>> : T extends Array<infer El> ? RemoteArray<El> : T extends Record<string, any> ? {
export type RemoteType<T> = T extends (...args: infer Args) => infer Return ? (...args: RemoteFunctionArgs<Args>) => Promise<RemoteType<Awaited<Return>>> : T extends Array<infer El> ? RemoteArray<El> : T extends Record<string, any> ? {
[K in keyof T]: RemoteType<T[K]>;

@@ -20,3 +20,3 @@ } : T extends any[] ? {

} : T;
declare type HandlerFunctionArgs<T extends any[]> = {
type HandlerFunctionArgs<T extends any[]> = {
[K in keyof T]: RemoteType<T[K]>;

@@ -26,3 +26,3 @@ };

}
export declare type HandlerType<T> = T extends (...args: infer Args) => infer Return ? (...args: HandlerFunctionArgs<Args>) => MaybePromise<HandlerType<Awaited<Return>>> : T extends Array<infer El> ? HandlerArray<El> : T extends Record<string, any> ? {
export type HandlerType<T> = T extends (...args: infer Args) => infer Return ? (...args: HandlerFunctionArgs<Args>) => MaybePromise<HandlerType<Awaited<Return>>> : T extends Array<infer El> ? HandlerArray<El> : T extends Record<string, any> ? {
[K in keyof T]: HandlerType<T[K]>;

@@ -29,0 +29,0 @@ } : T extends any[] ? {

23

package.json
{
"name": "stagehand",
"version": "1.0.0",
"version": "1.0.1",
"description": "A type-safe library for communicating between JS processes, workers, or other message-passing boundaries.",

@@ -11,4 +11,4 @@ "main": "lib/index.js",

"scripts": {
"lint": "eslint --ext ts,js .",
"test": "mocha -r ts-node/register 'tests/**/*.ts'",
"lint": "prettier --check . && eslint .",
"test": "mocha --expose-gc -r ts-node/register 'tests/**/*.ts'",
"test:watch": "mocha --watch --watch-extensions ts -r ts-node/register 'tests/**/*.ts'",

@@ -25,17 +25,20 @@ "prepublishOnly": "tsc -p tsconfig.publish.json",

"@types/mocha": "^5.2.5",
"@types/node": "^10.11.7",
"@types/node": "^12.0.0",
"@typescript-eslint/eslint-plugin": "^5.48.0",
"@typescript-eslint/parser": "^5.48.0",
"chai": "^4.2.0",
"eslint": "^5.6.1",
"eslint-config-prettier": "^3.1.0",
"eslint-plugin-prettier": "^3.0.0",
"eslint": "^8.31.0",
"mocha": "^5.2.0",
"prettier": "^1.14.3",
"prettier": "^2.8.1",
"rimraf": "^2.6.2",
"ts-node": "^7.0.1",
"typescript": "^3.1.3",
"typescript-eslint-parser": "^20.0.0"
"typescript": "^4.9.4"
},
"dependencies": {
"debug": "^4.1.0"
},
"volta": {
"node": "12.22.12",
"yarn": "1.22.19"
}
}

21

README.md

@@ -1,2 +0,2 @@

# Stagehand [![Build Status](https://travis-ci.com/dfreeman/stagehand.svg?branch=master)](https://travis-ci.com/dfreeman/stagehand)
# Stagehand [![CI](https://github.com/dfreeman/stagehand/workflows/CI/badge.svg)](https://github.com/dfreeman/stagehand/actions?query=workflow%3ACI)

@@ -53,3 +53,3 @@ Stagehand provides a type-safe means of coordinating communication across an evented message-passing boundary, such as a web worker or a Node.js child process.

// called in order to get the return value
}
},
});

@@ -62,3 +62,3 @@

// from the function originally passed on the parent side
}
},
});

@@ -80,12 +80,13 @@ ```

A `MessageEndpoint` is any object with the following three methods:
- `onMessage(callback: (message: unknown) => void): void`
- `sendMessage(message: unknown): void`
- `disconnect(): void`
- `onMessage(callback: (message: unknown) => void): void`
- `sendMessage(message: unknown): void`
- `disconnect(): void`
Several adapters for converting common communication objects to this type are included in this library:
- `stagehand/lib/adapters/child-process` creates endpoints for communicating to/from processes spawned with Node.js's [`fork`](https://nodejs.org/api/child_process.html#child_process_child_process_fork_modulepath_args_options) (see the example above)
- `stagehand/lib/adapters/web-worker` creates endpoints for communicating to /from [web workers](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API)
- `stagehand/lib/adapters/in-memory` create endpoints from scratch that both exist within the same process (mostly useful for testing)
- `stagehand/lib/adapters/child-process` creates endpoints for communicating to/from processes spawned with Node.js's [`fork`](https://nodejs.org/api/child_process.html#child_process_child_process_fork_modulepath_args_options) (see the example above)
- `stagehand/lib/adapters/web-worker` creates endpoints for communicating to /from [web workers](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API)
- `stagehand/lib/adapters/in-memory` create endpoints from scratch that both exist within the same process (mostly useful for testing)
These adapter modules also generally expose specialized versions of `launch` and `connect` that accept appropriate objects for the domain they deal with and internally convert them using the endpoint adapters also defined there.

61

tsconfig.json
{
"compilerOptions": {
/* Basic Options */
"target": "es2016", /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017','ES2018' or 'ESNEXT'. */
"module": "commonjs", /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */
"lib": ["es2016", "webworker"], /* Specify library files to be included in the compilation. */
// "allowJs": true, /* Allow javascript files to be compiled. */
// "checkJs": true, /* Report errors in .js files. */
// "jsx": "preserve", /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */
"declaration": true, /* Generates corresponding '.d.ts' file. */
// "declarationMap": true, /* Generates a sourcemap for each corresponding '.d.ts' file. */
// "sourceMap": true, /* Generates corresponding '.map' file. */
// "outFile": "./", /* Concatenate and emit output to single file. */
// "outDir": "./", /* Redirect output structure to the directory. */
// "rootDir": "./", /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
// "composite": true, /* Enable project compilation */
// "removeComments": true, /* Do not emit comments to output. */
// "noEmit": true, /* Do not emit outputs. */
// "importHelpers": true, /* Import emit helpers from 'tslib'. */
// "downlevelIteration": true, /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
// "isolatedModules": true, /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
/* Strict Type-Checking Options */
"strict": true, /* Enable all strict type-checking options. */
// "noImplicitAny": true, /* Raise error on expressions and declarations with an implied 'any' type. */
// "strictNullChecks": true, /* Enable strict null checks. */
// "strictFunctionTypes": true, /* Enable strict checking of function types. */
// "strictPropertyInitialization": true, /* Enable strict checking of property initialization in classes. */
// "noImplicitThis": true, /* Raise error on 'this' expressions with an implied 'any' type. */
// "alwaysStrict": true, /* Parse in strict mode and emit "use strict" for each source file. */
/* Additional Checks */
"noUnusedLocals": true, /* Report errors on unused locals. */
"noUnusedParameters": true, /* Report errors on unused parameters. */
// "noImplicitReturns": true, /* Report error when not all code paths in function return a value. */
"noFallthroughCasesInSwitch": true, /* Report errors for fallthrough cases in switch statement. */
/* Module Resolution Options */
// "moduleResolution": "node", /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
// "baseUrl": "./", /* Base directory to resolve non-absolute module names. */
// "paths": {}, /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
// "rootDirs": [], /* List of root folders whose combined content represents the structure of the project at runtime. */
// "typeRoots": [], /* List of folders to include type definitions from. */
// "types": [], /* Type declaration files to be included in compilation. */
// "allowSyntheticDefaultImports": true, /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
"esModuleInterop": true /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
// "preserveSymlinks": true, /* Do not resolve the real path of symlinks. */
/* Source Map Options */
// "sourceRoot": "", /* Specify the location where debugger should locate TypeScript files instead of source locations. */
// "mapRoot": "", /* Specify the location where debugger should locate map files instead of generated locations. */
// "inlineSourceMap": true, /* Emit a single file with source maps instead of having a separate file. */
// "inlineSources": true, /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
/* Experimental Options */
// "experimentalDecorators": true, /* Enables experimental support for ES7 decorators. */
// "emitDecoratorMetadata": true, /* Enables experimental support for emitting type metadata for decorators. */
"target": "es2016",
"module": "commonjs",
"lib": ["es2016", "webworker"],
"declaration": true,
"strict": true,
"esModuleInterop": true
},
"include": ["src", "tests"]
}
.travis.yml
.vscode/settings.json
lib/adapters/node.d.ts
lib/adapters/node.js
lib/serializer.d.ts
lib/serializer.js
SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc