create-yoya-ui 0.2.2 → 0.2.3

package/templates/admin/node_modules/typescript/vendor/vscode-jsonrpc/lib/common/sharedArrayCancellation.js

@@ -1,77 +0,0 @@
-"use strict";
-/* --------------------------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License. See License.txt in the project root for license information.
- * ------------------------------------------------------------------------------------------ */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SharedArrayReceiverStrategy = exports.SharedArraySenderStrategy = void 0;
-const cancellation_1 = require("./cancellation");
-var CancellationState;
-(function (CancellationState) {
-    CancellationState.Continue = 0;
-    CancellationState.Cancelled = 1;
-})(CancellationState || (CancellationState = {}));
-class SharedArraySenderStrategy {
-    buffers;
-    constructor() {
-        this.buffers = new Map();
-    }
-    enableCancellation(request) {
-        if (request.id === null) {
-            return;
-        }
-        const buffer = new SharedArrayBuffer(4);
-        const data = new Int32Array(buffer, 0, 1);
-        data[0] = CancellationState.Continue;
-        this.buffers.set(request.id, buffer);
-        request.$cancellationData = buffer;
-    }
-    async sendCancellation(_conn, id) {
-        const buffer = this.buffers.get(id);
-        if (buffer === undefined) {
-            return;
-        }
-        const data = new Int32Array(buffer, 0, 1);
-        Atomics.store(data, 0, CancellationState.Cancelled);
-    }
-    cleanup(id) {
-        this.buffers.delete(id);
-    }
-    dispose() {
-        this.buffers.clear();
-    }
-}
-exports.SharedArraySenderStrategy = SharedArraySenderStrategy;
-class SharedArrayBufferCancellationToken {
-    data;
-    constructor(buffer) {
-        this.data = new Int32Array(buffer, 0, 1);
-    }
-    get isCancellationRequested() {
-        return Atomics.load(this.data, 0) === CancellationState.Cancelled;
-    }
-    get onCancellationRequested() {
-        throw new Error(`Cancellation over SharedArrayBuffer doesn't support cancellation events`);
-    }
-}
-class SharedArrayBufferCancellationTokenSource {
-    token;
-    constructor(buffer) {
-        this.token = new SharedArrayBufferCancellationToken(buffer);
-    }
-    cancel() {
-    }
-    dispose() {
-    }
-}
-class SharedArrayReceiverStrategy {
-    kind = 'request';
-    createCancellationTokenSource(request) {
-        const buffer = request.$cancellationData;
-        if (buffer === undefined) {
-            return new cancellation_1.CancellationTokenSource();
-        }
-        return new SharedArrayBufferCancellationTokenSource(buffer);
-    }
-}
-exports.SharedArrayReceiverStrategy = SharedArrayReceiverStrategy;

package/templates/admin/node_modules/typescript/vendor/vscode-jsonrpc/lib/node/main.d.ts

@@ -1,58 +0,0 @@
-import { ChildProcess } from 'child_process';
-import { Socket } from 'net';
-import { MessagePort, Worker } from 'worker_threads';
-import { RAL, AbstractMessageReader, DataCallback, AbstractMessageWriter, Message, ReadableStreamMessageReader, WriteableStreamMessageWriter, MessageWriterOptions, MessageReaderOptions, MessageReader, MessageWriter, ConnectionStrategy, ConnectionOptions, MessageConnection, Logger, Disposable } from '../common/api';
-export * from '../common/api';
-export declare class IPCMessageReader extends AbstractMessageReader {
-    private process;
-    constructor(process: NodeJS.Process | ChildProcess);
-    listen(callback: DataCallback): Disposable;
-}
-export declare class IPCMessageWriter extends AbstractMessageWriter implements MessageWriter {
-    private readonly process;
-    private errorCount;
-    constructor(process: NodeJS.Process | ChildProcess);
-    write(msg: Message): Promise<void>;
-    private handleError;
-    end(): void;
-}
-export declare class PortMessageReader extends AbstractMessageReader implements MessageReader {
-    private onData;
-    constructor(port: MessagePort | Worker);
-    listen(callback: DataCallback): Disposable;
-}
-export declare class PortMessageWriter extends AbstractMessageWriter implements MessageWriter {
-    private readonly port;
-    private errorCount;
-    constructor(port: MessagePort | Worker);
-    write(msg: Message): Promise<void>;
-    private handleError;
-    end(): void;
-}
-export declare class SocketMessageReader extends ReadableStreamMessageReader {
-    constructor(socket: Socket, encoding?: RAL.MessageBufferEncoding);
-}
-export declare class SocketMessageWriter extends WriteableStreamMessageWriter {
-    private socket;
-    constructor(socket: Socket, options?: RAL.MessageBufferEncoding | MessageWriterOptions);
-    dispose(): void;
-}
-export declare class StreamMessageReader extends ReadableStreamMessageReader {
-    constructor(readable: NodeJS.ReadableStream, encoding?: RAL.MessageBufferEncoding | MessageReaderOptions);
-}
-export declare class StreamMessageWriter extends WriteableStreamMessageWriter {
-    constructor(writable: NodeJS.WritableStream, options?: RAL.MessageBufferEncoding | MessageWriterOptions);
-}
-export declare function generateRandomPipeName(): string;
-export interface PipeTransport {
-    onConnected(): Promise<[MessageReader, MessageWriter]>;
-}
-export declare function createClientPipeTransport(pipeName: string, encoding?: RAL.MessageBufferEncoding): Promise<PipeTransport>;
-export declare function createServerPipeTransport(pipeName: string, encoding?: RAL.MessageBufferEncoding): [MessageReader, MessageWriter];
-export interface SocketTransport {
-    onConnected(): Promise<[MessageReader, MessageWriter]>;
-}
-export declare function createClientSocketTransport(port: number, encoding?: RAL.MessageBufferEncoding): Promise<SocketTransport>;
-export declare function createServerSocketTransport(port: number, encoding?: RAL.MessageBufferEncoding): [MessageReader, MessageWriter];
-export declare function createMessageConnection(reader: MessageReader, writer: MessageWriter, logger?: Logger, options?: ConnectionStrategy | ConnectionOptions): MessageConnection;
-export declare function createMessageConnection(inputStream: NodeJS.ReadableStream, outputStream: NodeJS.WritableStream, logger?: Logger, options?: ConnectionStrategy | ConnectionOptions): MessageConnection;

package/templates/admin/node_modules/typescript/vendor/vscode-jsonrpc/lib/node/main.js

@@ -1,289 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StreamMessageWriter = exports.StreamMessageReader = exports.SocketMessageWriter = exports.SocketMessageReader = exports.PortMessageWriter = exports.PortMessageReader = exports.IPCMessageWriter = exports.IPCMessageReader = void 0;
-exports.generateRandomPipeName = generateRandomPipeName;
-exports.createClientPipeTransport = createClientPipeTransport;
-exports.createServerPipeTransport = createServerPipeTransport;
-exports.createClientSocketTransport = createClientSocketTransport;
-exports.createServerSocketTransport = createServerSocketTransport;
-exports.createMessageConnection = createMessageConnection;
-/* --------------------------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License. See License.txt in the project root for license information.
- * ----------------------------------------------------------------------------------------- */
-const ril_1 = __importDefault(require("./ril"));
-// Install the node runtime abstract.
-ril_1.default.install();
-const path = __importStar(require("path"));
-const os = __importStar(require("os"));
-const fs = __importStar(require("fs"));
-const crypto_1 = require("crypto");
-const net_1 = require("net");
-const api_1 = require("../common/api");
-__exportStar(require("../common/api"), exports);
-class IPCMessageReader extends api_1.AbstractMessageReader {
-    process;
-    constructor(process) {
-        super();
-        this.process = process;
-        const eventEmitter = this.process;
-        eventEmitter.on('error', (error) => this.fireError(error));
-        eventEmitter.on('close', () => this.fireClose());
-    }
-    listen(callback) {
-        this.process.on('message', callback);
-        return api_1.Disposable.create(() => this.process.off('message', callback));
-    }
-}
-exports.IPCMessageReader = IPCMessageReader;
-class IPCMessageWriter extends api_1.AbstractMessageWriter {
-    process;
-    errorCount;
-    constructor(process) {
-        super();
-        this.process = process;
-        this.errorCount = 0;
-        const eventEmitter = this.process;
-        eventEmitter.on('error', (error) => this.fireError(error));
-        eventEmitter.on('close', () => this.fireClose);
-    }
-    write(msg) {
-        try {
-            if (typeof this.process.send === 'function') {
-                this.process.send(msg, undefined, undefined, (error) => {
-                    if (error) {
-                        this.errorCount++;
-                        this.handleError(error, msg);
-                    }
-                    else {
-                        this.errorCount = 0;
-                    }
-                });
-            }
-            return Promise.resolve();
-        }
-        catch (error) {
-            this.handleError(error, msg);
-            return Promise.reject(error);
-        }
-    }
-    handleError(error, msg) {
-        this.errorCount++;
-        this.fireError(error, msg, this.errorCount);
-    }
-    end() {
-    }
-}
-exports.IPCMessageWriter = IPCMessageWriter;
-class PortMessageReader extends api_1.AbstractMessageReader {
-    onData;
-    constructor(port) {
-        super();
-        this.onData = new api_1.Emitter;
-        port.on('close', () => this.fireClose);
-        port.on('error', (error) => this.fireError(error));
-        port.on('message', (message) => {
-            this.onData.fire(message);
-        });
-    }
-    listen(callback) {
-        return this.onData.event(callback);
-    }
-}
-exports.PortMessageReader = PortMessageReader;
-class PortMessageWriter extends api_1.AbstractMessageWriter {
-    port;
-    errorCount;
-    constructor(port) {
-        super();
-        this.port = port;
-        this.errorCount = 0;
-        port.on('close', () => this.fireClose());
-        port.on('error', (error) => this.fireError(error));
-    }
-    write(msg) {
-        try {
-            this.port.postMessage(msg);
-            return Promise.resolve();
-        }
-        catch (error) {
-            this.handleError(error, msg);
-            return Promise.reject(error);
-        }
-    }
-    handleError(error, msg) {
-        this.errorCount++;
-        this.fireError(error, msg, this.errorCount);
-    }
-    end() {
-    }
-}
-exports.PortMessageWriter = PortMessageWriter;
-class SocketMessageReader extends api_1.ReadableStreamMessageReader {
-    constructor(socket, encoding = 'utf-8') {
-        super((0, ril_1.default)().stream.asReadableStream(socket), encoding);
-    }
-}
-exports.SocketMessageReader = SocketMessageReader;
-class SocketMessageWriter extends api_1.WriteableStreamMessageWriter {
-    socket;
-    constructor(socket, options) {
-        super((0, ril_1.default)().stream.asWritableStream(socket), options);
-        this.socket = socket;
-    }
-    dispose() {
-        super.dispose();
-        this.socket.destroy();
-    }
-}
-exports.SocketMessageWriter = SocketMessageWriter;
-class StreamMessageReader extends api_1.ReadableStreamMessageReader {
-    constructor(readable, encoding) {
-        super((0, ril_1.default)().stream.asReadableStream(readable), encoding);
-    }
-}
-exports.StreamMessageReader = StreamMessageReader;
-class StreamMessageWriter extends api_1.WriteableStreamMessageWriter {
-    constructor(writable, options) {
-        super((0, ril_1.default)().stream.asWritableStream(writable), options);
-    }
-}
-exports.StreamMessageWriter = StreamMessageWriter;
-const XDG_RUNTIME_DIR = process.env['XDG_RUNTIME_DIR'];
-const safeIpcPathLengths = new Map([
-    ['linux', 107],
-    ['darwin', 103]
-]);
-function generateRandomPipeName() {
-    if (process.platform === 'win32') {
-        return `\\\\.\\pipe\\lsp-${(0, crypto_1.randomBytes)(16).toString('hex')}-sock`;
-    }
-    let randomLength = 32;
-    const fixedLength = '/lsp-.sock'.length;
-    const tmpDir = fs.realpathSync(XDG_RUNTIME_DIR ?? os.tmpdir());
-    const limit = safeIpcPathLengths.get(process.platform);
-    if (limit !== undefined) {
-        randomLength = Math.min(limit - tmpDir.length - fixedLength, randomLength);
-    }
-    if (randomLength < 16) {
-        throw new Error(`Unable to generate a random pipe name with ${randomLength} characters.`);
-    }
-    const randomSuffix = (0, crypto_1.randomBytes)(Math.floor(randomLength / 2)).toString('hex');
-    return path.join(tmpDir, `lsp-${randomSuffix}.sock`);
-}
-function createClientPipeTransport(pipeName, encoding = 'utf-8') {
-    let connectResolve;
-    const connected = new Promise((resolve, _reject) => {
-        connectResolve = resolve;
-    });
-    return new Promise((resolve, reject) => {
-        const server = (0, net_1.createServer)((socket) => {
-            server.close();
-            connectResolve([
-                new SocketMessageReader(socket, encoding),
-                new SocketMessageWriter(socket, encoding)
-            ]);
-        });
-        server.on('error', reject);
-        server.listen(pipeName, () => {
-            server.removeListener('error', reject);
-            resolve({
-                onConnected: () => { return connected; }
-            });
-        });
-    });
-}
-function createServerPipeTransport(pipeName, encoding = 'utf-8') {
-    const socket = (0, net_1.createConnection)(pipeName);
-    return [
-        new SocketMessageReader(socket, encoding),
-        new SocketMessageWriter(socket, encoding)
-    ];
-}
-function createClientSocketTransport(port, encoding = 'utf-8') {
-    let connectResolve;
-    const connected = new Promise((resolve, _reject) => {
-        connectResolve = resolve;
-    });
-    return new Promise((resolve, reject) => {
-        const server = (0, net_1.createServer)((socket) => {
-            server.close();
-            connectResolve([
-                new SocketMessageReader(socket, encoding),
-                new SocketMessageWriter(socket, encoding)
-            ]);
-        });
-        server.on('error', reject);
-        server.listen(port, '127.0.0.1', () => {
-            server.removeListener('error', reject);
-            resolve({
-                onConnected: () => { return connected; }
-            });
-        });
-    });
-}
-function createServerSocketTransport(port, encoding = 'utf-8') {
-    const socket = (0, net_1.createConnection)(port, '127.0.0.1');
-    return [
-        new SocketMessageReader(socket, encoding),
-        new SocketMessageWriter(socket, encoding)
-    ];
-}
-function isReadableStream(value) {
-    const candidate = value;
-    return candidate.read !== undefined && candidate.addListener !== undefined;
-}
-function isWritableStream(value) {
-    const candidate = value;
-    return candidate.write !== undefined && candidate.addListener !== undefined;
-}
-function createMessageConnection(input, output, logger, options) {
-    if (!logger) {
-        logger = api_1.NullLogger;
-    }
-    const reader = isReadableStream(input) ? new StreamMessageReader(input) : input;
-    const writer = isWritableStream(output) ? new StreamMessageWriter(output) : output;
-    if (api_1.ConnectionStrategy.is(options)) {
-        options = { connectionStrategy: options };
-    }
-    return (0, api_1.createMessageConnection)(reader, writer, logger, options);
-}

package/templates/admin/node_modules/typescript/vendor/vscode-jsonrpc/lib/node/ril.d.ts

@@ -1,12 +0,0 @@
-import { RAL } from '../common/api';
-interface RIL extends RAL {
-    readonly stream: {
-        readonly asReadableStream: (stream: NodeJS.ReadableStream) => RAL.ReadableStream;
-        readonly asWritableStream: (stream: NodeJS.WritableStream) => RAL.WritableStream;
-    };
-}
-declare function RIL(): RIL;
-declare namespace RIL {
-    function install(): void;
-}
-export default RIL;

package/templates/admin/node_modules/typescript/vendor/vscode-jsonrpc/lib/node/ril.js

@@ -1,163 +0,0 @@
-"use strict";
-/* --------------------------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License. See License.txt in the project root for license information.
- * ------------------------------------------------------------------------------------------ */
-Object.defineProperty(exports, "__esModule", { value: true });
-const util_1 = require("util");
-const api_1 = require("../common/api");
-class MessageBuffer extends api_1.AbstractMessageBuffer {
-    static emptyBuffer = Buffer.allocUnsafe(0);
-    constructor(encoding = 'utf-8') {
-        super(encoding);
-    }
-    emptyBuffer() {
-        return MessageBuffer.emptyBuffer;
-    }
-    fromString(value, encoding) {
-        return Buffer.from(value, encoding);
-    }
-    toString(value, encoding) {
-        if (value instanceof Buffer) {
-            return value.toString(encoding);
-        }
-        else {
-            return new util_1.TextDecoder(encoding).decode(value);
-        }
-    }
-    asNative(buffer, length) {
-        if (length === undefined) {
-            return buffer instanceof Buffer ? buffer : Buffer.from(buffer);
-        }
-        else {
-            return buffer instanceof Buffer ? buffer.slice(0, length) : Buffer.from(buffer, 0, length);
-        }
-    }
-    allocNative(length) {
-        return Buffer.allocUnsafe(length);
-    }
-}
-class ReadableStreamWrapper {
-    stream;
-    constructor(stream) {
-        this.stream = stream;
-    }
-    onClose(listener) {
-        this.stream.on('close', listener);
-        return api_1.Disposable.create(() => this.stream.off('close', listener));
-    }
-    onError(listener) {
-        this.stream.on('error', listener);
-        return api_1.Disposable.create(() => this.stream.off('error', listener));
-    }
-    onEnd(listener) {
-        this.stream.on('end', listener);
-        return api_1.Disposable.create(() => this.stream.off('end', listener));
-    }
-    onData(listener) {
-        this.stream.on('data', listener);
-        return api_1.Disposable.create(() => this.stream.off('data', listener));
-    }
-}
-class WritableStreamWrapper {
-    stream;
-    constructor(stream) {
-        this.stream = stream;
-    }
-    onClose(listener) {
-        this.stream.on('close', listener);
-        return api_1.Disposable.create(() => this.stream.off('close', listener));
-    }
-    onError(listener) {
-        this.stream.on('error', listener);
-        return api_1.Disposable.create(() => this.stream.off('error', listener));
-    }
-    onEnd(listener) {
-        this.stream.on('end', listener);
-        return api_1.Disposable.create(() => this.stream.off('end', listener));
-    }
-    write(data, encoding) {
-        return new Promise((resolve, reject) => {
-            const callback = (error) => {
-                if (error === undefined || error === null) {
-                    resolve();
-                }
-                else {
-                    reject(error);
-                }
-            };
-            if (typeof data === 'string') {
-                this.stream.write(data, encoding, callback);
-            }
-            else {
-                this.stream.write(data, callback);
-            }
-        });
-    }
-    end() {
-        this.stream.end();
-    }
-}
-const _ril = Object.freeze({
-    messageBuffer: Object.freeze({
-        create: (encoding) => new MessageBuffer(encoding)
-    }),
-    applicationJson: Object.freeze({
-        encoder: Object.freeze({
-            name: 'application/json',
-            encode: (msg, options) => {
-                try {
-                    return Promise.resolve(Buffer.from(JSON.stringify(msg, undefined, 0), options.charset));
-                }
-                catch (err) {
-                    return Promise.reject(err);
-                }
-            }
-        }),
-        decoder: Object.freeze({
-            name: 'application/json',
-            decode: (buffer, options) => {
-                try {
-                    if (buffer instanceof Buffer) {
-                        return Promise.resolve(JSON.parse(buffer.toString(options.charset)));
-                    }
-                    else {
-                        return Promise.resolve(JSON.parse(new util_1.TextDecoder(options.charset).decode(buffer)));
-                    }
-                }
-                catch (err) {
-                    return Promise.reject(err);
-                }
-            }
-        })
-    }),
-    stream: Object.freeze({
-        asReadableStream: (stream) => new ReadableStreamWrapper(stream),
-        asWritableStream: (stream) => new WritableStreamWrapper(stream)
-    }),
-    console: console,
-    timer: Object.freeze({
-        setTimeout(callback, ms, ...args) {
-            const handle = setTimeout(callback, ms, ...args);
-            return { dispose: () => clearTimeout(handle) };
-        },
-        setImmediate(callback, ...args) {
-            const handle = setImmediate(callback, ...args);
-            return { dispose: () => clearImmediate(handle) };
-        },
-        setInterval(callback, ms, ...args) {
-            const handle = setInterval(callback, ms, ...args);
-            return { dispose: () => clearInterval(handle) };
-        }
-    })
-});
-function RIL() {
-    return _ril;
-}
-(function (RIL) {
-    function install() {
-        api_1.RAL.install(_ril);
-    }
-    RIL.install = install;
-})(RIL || (RIL = {}));
-exports.default = RIL;

package/templates/admin/node_modules/typescript/vendor/vscode-jsonrpc/package.json

@@ -1,54 +0,0 @@
-{
-	"name": "vscode-jsonrpc",
-	"description": "A json rpc implementation over streams",
-	"version": "9.0.0",
-	"author": "Microsoft Corporation",
-	"license": "MIT",
-	"repository": {
-		"type": "git",
-		"url": "https://github.com/Microsoft/vscode-languageserver-node.git",
-		"directory": "jsonrpc"
-	},
-	"bugs": {
-		"url": "https://github.com/Microsoft/vscode-languageserver-node/issues"
-	},
-	"engines": {
-		"node": ">=14.0.0"
-	},
-	"exports": {
-		".": {
-			"types": "./lib/common/api.d.ts",
-			"default": "./lib/common/api.js"
-		},
-		"./node": {
-			"types": "./lib/node/main.d.ts",
-			"node": "./lib/node/main.js"
-		},
-		"./browser": {
-			"types": "./lib/browser/main.d.ts",
-			"browser": "./lib/browser/main.js"
-		}
-	},
-	"devDependencies": {
-		"@types/msgpack-lite": "^0.1.12",
-		"msgpack-lite": "^0.1.26"
-	},
-	"scripts": {
-		"prepublishOnly": "echo \"⛔ Can only publish from a secure pipeline ⛔\" && node ../build/npm/fail",
-		"prepack": "npm run all:publish",
-		"preversion": "npm test",
-		"compile": "tsc -b ./tsconfig.json",
-		"watch": "tsc -b ./tsconfig.watch.json -w",
-		"clean": "rimraf lib && rimraf dist",
-		"lint": "eslint src",
-		"test": "npm run test:node && npm run test:browser",
-		"test:node": "node ../node_modules/mocha/bin/_mocha",
-		"test:browser": "npm run webpack:test:silent && node ../build/bin/runBrowserTests.js  http://127.0.0.1:8080/jsonrpc/src/browser/test/",
-		"webpack": "node ../build/bin/webpack  --mode none --config ./webpack.config.js",
-		"webpack:test": "node ../build/bin/webpack --mode none --config ./src/browser/test/webpack.config.js",
-		"webpack:test:silent": "node ../build/bin/webpack --no-stats --mode none --config ./src/browser/test/webpack.config.js",
-		"all": "npm run clean && npm run compile && npm run lint && npm run test",
-		"compile:publish": "tsc -b ./tsconfig.publish.json",
-		"all:publish": "git clean -xfd . && npm install && npm run compile:publish && npm run lint && npm run test"
-	}
-}

package/templates/admin/node_modules/typescript/vendor/vscode-jsonrpc/typings/thenable.d.ts

@@ -1,5 +0,0 @@
-/* --------------------------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License. See License.txt in the project root for license information.
- * ------------------------------------------------------------------------------------------ */
-interface Thenable<T> extends PromiseLike<T> { }