@highstate/designer 0.4.5 → 0.4.6

package/.output/server/node_modules/@grpc/grpc-js/build/src/compression-filter.js

@@ -1,295 +0,0 @@
-"use strict";
-/*
- * Copyright 2019 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompressionFilterFactory = exports.CompressionFilter = void 0;
-const zlib = require("zlib");
-const compression_algorithms_1 = require("./compression-algorithms");
-const constants_1 = require("./constants");
-const filter_1 = require("./filter");
-const logging = require("./logging");
-const isCompressionAlgorithmKey = (key) => {
-    return (typeof key === 'number' && typeof compression_algorithms_1.CompressionAlgorithms[key] === 'string');
-};
-class CompressionHandler {
-    /**
-     * @param message Raw uncompressed message bytes
-     * @param compress Indicates whether the message should be compressed
-     * @return Framed message, compressed if applicable
-     */
-    async writeMessage(message, compress) {
-        let messageBuffer = message;
-        if (compress) {
-            messageBuffer = await this.compressMessage(messageBuffer);
-        }
-        const output = Buffer.allocUnsafe(messageBuffer.length + 5);
-        output.writeUInt8(compress ? 1 : 0, 0);
-        output.writeUInt32BE(messageBuffer.length, 1);
-        messageBuffer.copy(output, 5);
-        return output;
-    }
-    /**
-     * @param data Framed message, possibly compressed
-     * @return Uncompressed message
-     */
-    async readMessage(data) {
-        const compressed = data.readUInt8(0) === 1;
-        let messageBuffer = data.slice(5);
-        if (compressed) {
-            messageBuffer = await this.decompressMessage(messageBuffer);
-        }
-        return messageBuffer;
-    }
-}
-class IdentityHandler extends CompressionHandler {
-    async compressMessage(message) {
-        return message;
-    }
-    async writeMessage(message, compress) {
-        const output = Buffer.allocUnsafe(message.length + 5);
-        /* With "identity" compression, messages should always be marked as
-         * uncompressed */
-        output.writeUInt8(0, 0);
-        output.writeUInt32BE(message.length, 1);
-        message.copy(output, 5);
-        return output;
-    }
-    decompressMessage(message) {
-        return Promise.reject(new Error('Received compressed message but "grpc-encoding" header was identity'));
-    }
-}
-class DeflateHandler extends CompressionHandler {
-    constructor(maxRecvMessageLength) {
-        super();
-        this.maxRecvMessageLength = maxRecvMessageLength;
-    }
-    compressMessage(message) {
-        return new Promise((resolve, reject) => {
-            zlib.deflate(message, (err, output) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve(output);
-                }
-            });
-        });
-    }
-    decompressMessage(message) {
-        return new Promise((resolve, reject) => {
-            let totalLength = 0;
-            const messageParts = [];
-            const decompresser = zlib.createInflate();
-            decompresser.on('data', (chunk) => {
-                messageParts.push(chunk);
-                totalLength += chunk.byteLength;
-                if (this.maxRecvMessageLength !== -1 && totalLength > this.maxRecvMessageLength) {
-                    decompresser.destroy();
-                    reject({
-                        code: constants_1.Status.RESOURCE_EXHAUSTED,
-                        details: `Received message that decompresses to a size larger than ${this.maxRecvMessageLength}`
-                    });
-                }
-            });
-            decompresser.on('end', () => {
-                resolve(Buffer.concat(messageParts));
-            });
-            decompresser.write(message);
-            decompresser.end();
-        });
-    }
-}
-class GzipHandler extends CompressionHandler {
-    constructor(maxRecvMessageLength) {
-        super();
-        this.maxRecvMessageLength = maxRecvMessageLength;
-    }
-    compressMessage(message) {
-        return new Promise((resolve, reject) => {
-            zlib.gzip(message, (err, output) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve(output);
-                }
-            });
-        });
-    }
-    decompressMessage(message) {
-        return new Promise((resolve, reject) => {
-            let totalLength = 0;
-            const messageParts = [];
-            const decompresser = zlib.createGunzip();
-            decompresser.on('data', (chunk) => {
-                messageParts.push(chunk);
-                totalLength += chunk.byteLength;
-                if (this.maxRecvMessageLength !== -1 && totalLength > this.maxRecvMessageLength) {
-                    decompresser.destroy();
-                    reject({
-                        code: constants_1.Status.RESOURCE_EXHAUSTED,
-                        details: `Received message that decompresses to a size larger than ${this.maxRecvMessageLength}`
-                    });
-                }
-            });
-            decompresser.on('end', () => {
-                resolve(Buffer.concat(messageParts));
-            });
-            decompresser.write(message);
-            decompresser.end();
-        });
-    }
-}
-class UnknownHandler extends CompressionHandler {
-    constructor(compressionName) {
-        super();
-        this.compressionName = compressionName;
-    }
-    compressMessage(message) {
-        return Promise.reject(new Error(`Received message compressed with unsupported compression method ${this.compressionName}`));
-    }
-    decompressMessage(message) {
-        // This should be unreachable
-        return Promise.reject(new Error(`Compression method not supported: ${this.compressionName}`));
-    }
-}
-function getCompressionHandler(compressionName, maxReceiveMessageSize) {
-    switch (compressionName) {
-        case 'identity':
-            return new IdentityHandler();
-        case 'deflate':
-            return new DeflateHandler(maxReceiveMessageSize);
-        case 'gzip':
-            return new GzipHandler(maxReceiveMessageSize);
-        default:
-            return new UnknownHandler(compressionName);
-    }
-}
-class CompressionFilter extends filter_1.BaseFilter {
-    constructor(channelOptions, sharedFilterConfig) {
-        var _a, _b, _c;
-        super();
-        this.sharedFilterConfig = sharedFilterConfig;
-        this.sendCompression = new IdentityHandler();
-        this.receiveCompression = new IdentityHandler();
-        this.currentCompressionAlgorithm = 'identity';
-        const compressionAlgorithmKey = channelOptions['grpc.default_compression_algorithm'];
-        this.maxReceiveMessageLength = (_a = channelOptions['grpc.max_receive_message_length']) !== null && _a !== void 0 ? _a : constants_1.DEFAULT_MAX_RECEIVE_MESSAGE_LENGTH;
-        this.maxSendMessageLength = (_b = channelOptions['grpc.max_send_message_length']) !== null && _b !== void 0 ? _b : constants_1.DEFAULT_MAX_SEND_MESSAGE_LENGTH;
-        if (compressionAlgorithmKey !== undefined) {
-            if (isCompressionAlgorithmKey(compressionAlgorithmKey)) {
-                const clientSelectedEncoding = compression_algorithms_1.CompressionAlgorithms[compressionAlgorithmKey];
-                const serverSupportedEncodings = (_c = sharedFilterConfig.serverSupportedEncodingHeader) === null || _c === void 0 ? void 0 : _c.split(',');
-                /**
-                 * There are two possible situations here:
-                 * 1) We don't have any info yet from the server about what compression it supports
-                 *    In that case we should just use what the client tells us to use
-                 * 2) We've previously received a response from the server including a grpc-accept-encoding header
-                 *    In that case we only want to use the encoding chosen by the client if the server supports it
-                 */
-                if (!serverSupportedEncodings ||
-                    serverSupportedEncodings.includes(clientSelectedEncoding)) {
-                    this.currentCompressionAlgorithm = clientSelectedEncoding;
-                    this.sendCompression = getCompressionHandler(this.currentCompressionAlgorithm, -1);
-                }
-            }
-            else {
-                logging.log(constants_1.LogVerbosity.ERROR, `Invalid value provided for grpc.default_compression_algorithm option: ${compressionAlgorithmKey}`);
-            }
-        }
-    }
-    async sendMetadata(metadata) {
-        const headers = await metadata;
-        headers.set('grpc-accept-encoding', 'identity,deflate,gzip');
-        headers.set('accept-encoding', 'identity');
-        // No need to send the header if it's "identity" -  behavior is identical; save the bandwidth
-        if (this.currentCompressionAlgorithm === 'identity') {
-            headers.remove('grpc-encoding');
-        }
-        else {
-            headers.set('grpc-encoding', this.currentCompressionAlgorithm);
-        }
-        return headers;
-    }
-    receiveMetadata(metadata) {
-        const receiveEncoding = metadata.get('grpc-encoding');
-        if (receiveEncoding.length > 0) {
-            const encoding = receiveEncoding[0];
-            if (typeof encoding === 'string') {
-                this.receiveCompression = getCompressionHandler(encoding, this.maxReceiveMessageLength);
-            }
-        }
-        metadata.remove('grpc-encoding');
-        /* Check to see if the compression we're using to send messages is supported by the server
-         * If not, reset the sendCompression filter and have it use the default IdentityHandler */
-        const serverSupportedEncodingsHeader = metadata.get('grpc-accept-encoding')[0];
-        if (serverSupportedEncodingsHeader) {
-            this.sharedFilterConfig.serverSupportedEncodingHeader =
-                serverSupportedEncodingsHeader;
-            const serverSupportedEncodings = serverSupportedEncodingsHeader.split(',');
-            if (!serverSupportedEncodings.includes(this.currentCompressionAlgorithm)) {
-                this.sendCompression = new IdentityHandler();
-                this.currentCompressionAlgorithm = 'identity';
-            }
-        }
-        metadata.remove('grpc-accept-encoding');
-        return metadata;
-    }
-    async sendMessage(message) {
-        var _a;
-        /* This filter is special. The input message is the bare message bytes,
-         * and the output is a framed and possibly compressed message. For this
-         * reason, this filter should be at the bottom of the filter stack */
-        const resolvedMessage = await message;
-        if (this.maxSendMessageLength !== -1 && resolvedMessage.message.length > this.maxSendMessageLength) {
-            throw {
-                code: constants_1.Status.RESOURCE_EXHAUSTED,
-                details: `Attempted to send message with a size larger than ${this.maxSendMessageLength}`
-            };
-        }
-        let compress;
-        if (this.sendCompression instanceof IdentityHandler) {
-            compress = false;
-        }
-        else {
-            compress = (((_a = resolvedMessage.flags) !== null && _a !== void 0 ? _a : 0) & 2 /* WriteFlags.NoCompress */) === 0;
-        }
-        return {
-            message: await this.sendCompression.writeMessage(resolvedMessage.message, compress),
-            flags: resolvedMessage.flags,
-        };
-    }
-    async receiveMessage(message) {
-        /* This filter is also special. The input message is framed and possibly
-         * compressed, and the output message is deframed and uncompressed. So
-         * this is another reason that this filter should be at the bottom of the
-         * filter stack. */
-        return this.receiveCompression.readMessage(await message);
-    }
-}
-exports.CompressionFilter = CompressionFilter;
-class CompressionFilterFactory {
-    constructor(channel, options) {
-        this.options = options;
-        this.sharedFilterConfig = {};
-    }
-    createFilter() {
-        return new CompressionFilter(this.options, this.sharedFilterConfig);
-    }
-}
-exports.CompressionFilterFactory = CompressionFilterFactory;
-//# sourceMappingURL=compression-filter.js.map

package/.output/server/node_modules/@grpc/grpc-js/build/src/connectivity-state.js

@@ -1,28 +0,0 @@
-"use strict";
-/*
- * Copyright 2021 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConnectivityState = void 0;
-var ConnectivityState;
-(function (ConnectivityState) {
-    ConnectivityState[ConnectivityState["IDLE"] = 0] = "IDLE";
-    ConnectivityState[ConnectivityState["CONNECTING"] = 1] = "CONNECTING";
-    ConnectivityState[ConnectivityState["READY"] = 2] = "READY";
-    ConnectivityState[ConnectivityState["TRANSIENT_FAILURE"] = 3] = "TRANSIENT_FAILURE";
-    ConnectivityState[ConnectivityState["SHUTDOWN"] = 4] = "SHUTDOWN";
-})(ConnectivityState || (exports.ConnectivityState = ConnectivityState = {}));
-//# sourceMappingURL=connectivity-state.js.map

package/.output/server/node_modules/@grpc/grpc-js/build/src/constants.js

@@ -1,64 +0,0 @@
-"use strict";
-/*
- * Copyright 2019 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_MAX_RECEIVE_MESSAGE_LENGTH = exports.DEFAULT_MAX_SEND_MESSAGE_LENGTH = exports.Propagate = exports.LogVerbosity = exports.Status = void 0;
-var Status;
-(function (Status) {
-    Status[Status["OK"] = 0] = "OK";
-    Status[Status["CANCELLED"] = 1] = "CANCELLED";
-    Status[Status["UNKNOWN"] = 2] = "UNKNOWN";
-    Status[Status["INVALID_ARGUMENT"] = 3] = "INVALID_ARGUMENT";
-    Status[Status["DEADLINE_EXCEEDED"] = 4] = "DEADLINE_EXCEEDED";
-    Status[Status["NOT_FOUND"] = 5] = "NOT_FOUND";
-    Status[Status["ALREADY_EXISTS"] = 6] = "ALREADY_EXISTS";
-    Status[Status["PERMISSION_DENIED"] = 7] = "PERMISSION_DENIED";
-    Status[Status["RESOURCE_EXHAUSTED"] = 8] = "RESOURCE_EXHAUSTED";
-    Status[Status["FAILED_PRECONDITION"] = 9] = "FAILED_PRECONDITION";
-    Status[Status["ABORTED"] = 10] = "ABORTED";
-    Status[Status["OUT_OF_RANGE"] = 11] = "OUT_OF_RANGE";
-    Status[Status["UNIMPLEMENTED"] = 12] = "UNIMPLEMENTED";
-    Status[Status["INTERNAL"] = 13] = "INTERNAL";
-    Status[Status["UNAVAILABLE"] = 14] = "UNAVAILABLE";
-    Status[Status["DATA_LOSS"] = 15] = "DATA_LOSS";
-    Status[Status["UNAUTHENTICATED"] = 16] = "UNAUTHENTICATED";
-})(Status || (exports.Status = Status = {}));
-var LogVerbosity;
-(function (LogVerbosity) {
-    LogVerbosity[LogVerbosity["DEBUG"] = 0] = "DEBUG";
-    LogVerbosity[LogVerbosity["INFO"] = 1] = "INFO";
-    LogVerbosity[LogVerbosity["ERROR"] = 2] = "ERROR";
-    LogVerbosity[LogVerbosity["NONE"] = 3] = "NONE";
-})(LogVerbosity || (exports.LogVerbosity = LogVerbosity = {}));
-/**
- * NOTE: This enum is not currently used in any implemented API in this
- * library. It is included only for type parity with the other implementation.
- */
-var Propagate;
-(function (Propagate) {
-    Propagate[Propagate["DEADLINE"] = 1] = "DEADLINE";
-    Propagate[Propagate["CENSUS_STATS_CONTEXT"] = 2] = "CENSUS_STATS_CONTEXT";
-    Propagate[Propagate["CENSUS_TRACING_CONTEXT"] = 4] = "CENSUS_TRACING_CONTEXT";
-    Propagate[Propagate["CANCELLATION"] = 8] = "CANCELLATION";
-    // https://github.com/grpc/grpc/blob/master/include/grpc/impl/codegen/propagation_bits.h#L43
-    Propagate[Propagate["DEFAULTS"] = 65535] = "DEFAULTS";
-})(Propagate || (exports.Propagate = Propagate = {}));
-// -1 means unlimited
-exports.DEFAULT_MAX_SEND_MESSAGE_LENGTH = -1;
-// 4 MB default
-exports.DEFAULT_MAX_RECEIVE_MESSAGE_LENGTH = 4 * 1024 * 1024;
-//# sourceMappingURL=constants.js.map

package/.output/server/node_modules/@grpc/grpc-js/build/src/control-plane-status.js

@@ -1,42 +0,0 @@
-"use strict";
-/*
- * Copyright 2022 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.restrictControlPlaneStatusCode = restrictControlPlaneStatusCode;
-const constants_1 = require("./constants");
-const INAPPROPRIATE_CONTROL_PLANE_CODES = [
-    constants_1.Status.OK,
-    constants_1.Status.INVALID_ARGUMENT,
-    constants_1.Status.NOT_FOUND,
-    constants_1.Status.ALREADY_EXISTS,
-    constants_1.Status.FAILED_PRECONDITION,
-    constants_1.Status.ABORTED,
-    constants_1.Status.OUT_OF_RANGE,
-    constants_1.Status.DATA_LOSS,
-];
-function restrictControlPlaneStatusCode(code, details) {
-    if (INAPPROPRIATE_CONTROL_PLANE_CODES.includes(code)) {
-        return {
-            code: constants_1.Status.INTERNAL,
-            details: `Invalid status from control plane: ${code} ${constants_1.Status[code]} ${details}`,
-        };
-    }
-    else {
-        return { code, details };
-    }
-}
-//# sourceMappingURL=control-plane-status.js.map

package/.output/server/node_modules/@grpc/grpc-js/build/src/deadline.js

@@ -1,108 +0,0 @@
-"use strict";
-/*
- * Copyright 2019 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.minDeadline = minDeadline;
-exports.getDeadlineTimeoutString = getDeadlineTimeoutString;
-exports.getRelativeTimeout = getRelativeTimeout;
-exports.deadlineToString = deadlineToString;
-exports.formatDateDifference = formatDateDifference;
-function minDeadline(...deadlineList) {
-    let minValue = Infinity;
-    for (const deadline of deadlineList) {
-        const deadlineMsecs = deadline instanceof Date ? deadline.getTime() : deadline;
-        if (deadlineMsecs < minValue) {
-            minValue = deadlineMsecs;
-        }
-    }
-    return minValue;
-}
-const units = [
-    ['m', 1],
-    ['S', 1000],
-    ['M', 60 * 1000],
-    ['H', 60 * 60 * 1000],
-];
-function getDeadlineTimeoutString(deadline) {
-    const now = new Date().getTime();
-    if (deadline instanceof Date) {
-        deadline = deadline.getTime();
-    }
-    const timeoutMs = Math.max(deadline - now, 0);
-    for (const [unit, factor] of units) {
-        const amount = timeoutMs / factor;
-        if (amount < 1e8) {
-            return String(Math.ceil(amount)) + unit;
-        }
-    }
-    throw new Error('Deadline is too far in the future');
-}
-/**
- * See https://nodejs.org/api/timers.html#settimeoutcallback-delay-args
- * In particular, "When delay is larger than 2147483647 or less than 1, the
- * delay will be set to 1. Non-integer delays are truncated to an integer."
- * This number of milliseconds is almost 25 days.
- */
-const MAX_TIMEOUT_TIME = 2147483647;
-/**
- * Get the timeout value that should be passed to setTimeout now for the timer
- * to end at the deadline. For any deadline before now, the timer should end
- * immediately, represented by a value of 0. For any deadline more than
- * MAX_TIMEOUT_TIME milliseconds in the future, a timer cannot be set that will
- * end at that time, so it is treated as infinitely far in the future.
- * @param deadline
- * @returns
- */
-function getRelativeTimeout(deadline) {
-    const deadlineMs = deadline instanceof Date ? deadline.getTime() : deadline;
-    const now = new Date().getTime();
-    const timeout = deadlineMs - now;
-    if (timeout < 0) {
-        return 0;
-    }
-    else if (timeout > MAX_TIMEOUT_TIME) {
-        return Infinity;
-    }
-    else {
-        return timeout;
-    }
-}
-function deadlineToString(deadline) {
-    if (deadline instanceof Date) {
-        return deadline.toISOString();
-    }
-    else {
-        const dateDeadline = new Date(deadline);
-        if (Number.isNaN(dateDeadline.getTime())) {
-            return '' + deadline;
-        }
-        else {
-            return dateDeadline.toISOString();
-        }
-    }
-}
-/**
- * Calculate the difference between two dates as a number of seconds and format
- * it as a string.
- * @param startDate
- * @param endDate
- * @returns
- */
-function formatDateDifference(startDate, endDate) {
-    return ((endDate.getTime() - startDate.getTime()) / 1000).toFixed(3) + 's';
-}
-//# sourceMappingURL=deadline.js.map

package/.output/server/node_modules/@grpc/grpc-js/build/src/duration.js

@@ -1,46 +0,0 @@
-"use strict";
-/*
- * Copyright 2022 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.msToDuration = msToDuration;
-exports.durationToMs = durationToMs;
-exports.isDuration = isDuration;
-exports.parseDuration = parseDuration;
-function msToDuration(millis) {
-    return {
-        seconds: (millis / 1000) | 0,
-        nanos: ((millis % 1000) * 1000000) | 0,
-    };
-}
-function durationToMs(duration) {
-    return (duration.seconds * 1000 + duration.nanos / 1000000) | 0;
-}
-function isDuration(value) {
-    return typeof value.seconds === 'number' && typeof value.nanos === 'number';
-}
-const durationRegex = /^(\d+)(?:\.(\d+))?s$/;
-function parseDuration(value) {
-    const match = value.match(durationRegex);
-    if (!match) {
-        return null;
-    }
-    return {
-        seconds: Number.parseInt(match[1], 10),
-        nanos: match[2] ? Number.parseInt(match[2].padEnd(9, '0'), 10) : 0
-    };
-}
-//# sourceMappingURL=duration.js.map

package/.output/server/node_modules/@grpc/grpc-js/build/src/environment.js

@@ -1,22 +0,0 @@
-"use strict";
-/*
- * Copyright 2024 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GRPC_NODE_USE_ALTERNATIVE_RESOLVER = void 0;
-exports.GRPC_NODE_USE_ALTERNATIVE_RESOLVER = ((_a = process.env.GRPC_NODE_USE_ALTERNATIVE_RESOLVER) !== null && _a !== void 0 ? _a : 'false') === 'true';
-//# sourceMappingURL=environment.js.map

package/.output/server/node_modules/@grpc/grpc-js/build/src/error.js

@@ -1,40 +0,0 @@
-"use strict";
-/*
- * Copyright 2022 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getErrorMessage = getErrorMessage;
-exports.getErrorCode = getErrorCode;
-function getErrorMessage(error) {
-    if (error instanceof Error) {
-        return error.message;
-    }
-    else {
-        return String(error);
-    }
-}
-function getErrorCode(error) {
-    if (typeof error === 'object' &&
-        error !== null &&
-        'code' in error &&
-        typeof error.code === 'number') {
-        return error.code;
-    }
-    else {
-        return null;
-    }
-}
-//# sourceMappingURL=error.js.map