sass-embedded-go 1.104.0-alpha0

package/lib/src/packet-transformer.js

@@ -0,0 +1,171 @@
+"use strict";
+// Copyright 2020 Google Inc. Use of this source code is governed by an
+// MIT-style license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PacketTransformer = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+/**
+ * Decodes arbitrarily-chunked buffers, for example
+ *   [ 0 1 2 3 4 5 6 7 ... ],
+ * into packets of set length in the form
+ *   +---------+------------- ...
+ *   | 0 1 2 3 | 4 5 6 7 ...
+ *   +---------+------------- ...
+ *   | HEADER  | PAYLOAD (PROTOBUF)
+ *   +---------+------------- ...
+ * and emits the payload of each packet.
+ *
+ * Encodes packets by attaching a header to a protobuf that describes the
+ * protobuf's length.
+ */
+class PacketTransformer {
+    outboundBuffers$;
+    writeInboundBuffer;
+    // The packet that is actively being decoded as buffers come in.
+    packet = new Packet();
+    // The decoded protobufs are written to this Subject. It is publicly exposed
+    // as a readonly Observable.
+    outboundProtobufsInternal$ = new rxjs_1.Subject();
+    /**
+     * The fully-decoded, outbound protobufs. If any errors are encountered
+     * during encoding/decoding, this Observable will error out.
+     */
+    outboundProtobufs$ = this.outboundProtobufsInternal$.pipe();
+    constructor(outboundBuffers$, writeInboundBuffer) {
+        this.outboundBuffers$ = outboundBuffers$;
+        this.writeInboundBuffer = writeInboundBuffer;
+        this.outboundBuffers$
+            .pipe((0, operators_1.mergeMap)(buffer => this.decode(buffer)))
+            .subscribe(this.outboundProtobufsInternal$);
+    }
+    /**
+     * Encodes a packet by pre-fixing `protobuf` with a header that describes its
+     * length.
+     */
+    writeInboundProtobuf(protobuf) {
+        try {
+            let length = protobuf.length;
+            if (length === 0) {
+                this.writeInboundBuffer(Buffer.alloc(1));
+                return;
+            }
+            // Write the length in varint format, 7 bits at a time from least to most
+            // significant.
+            const header = Buffer.alloc(8);
+            let offset = 0;
+            while (length > 0) {
+                // The highest-order bit indicates whether more bytes are necessary to
+                // fully express the number. The lower 7 bits indicate the number's
+                // value.
+                header.writeUInt8((length > 0x7f ? 0x80 : 0) | (length & 0x7f), offset);
+                offset++;
+                length >>= 7;
+            }
+            const packet = Buffer.alloc(offset + protobuf.length);
+            header.copy(packet, 0, 0, offset);
+            packet.set(protobuf, offset);
+            this.writeInboundBuffer(packet);
+        }
+        catch (error) {
+            this.outboundProtobufsInternal$.error(error);
+        }
+    }
+    // Decodes a buffer, filling up the packet that is actively being decoded.
+    // Returns a list of decoded payloads.
+    decode(buffer) {
+        const payloads = [];
+        let decodedBytes = 0;
+        while (decodedBytes < buffer.length) {
+            decodedBytes += this.packet.write(buffer.slice(decodedBytes));
+            if (this.packet.isComplete && this.packet.payload) {
+                payloads.push(this.packet.payload);
+                this.packet = new Packet();
+            }
+        }
+        return payloads;
+    }
+}
+exports.PacketTransformer = PacketTransformer;
+/** A length-delimited packet comprised of a header and payload. */
+class Packet {
+    // The number of bits we've consumed so far to fill out `payloadLength`.
+    payloadLengthBits = 0;
+    // The length of the next message, in bytes.
+    //
+    // This is built up from a [varint]. Once it's fully consumed, `payload` is
+    // initialized and this is reset to 0.
+    //
+    // [varint]: https://developers.google.com/protocol-buffers/docs/encoding#varints
+    payloadLength = 0;
+    /**
+     * The packet's payload. Constructed by calls to write().
+     * @see write
+     */
+    payload;
+    // The offset in [payload] that should be written to next time data arrives.
+    payloadOffset = 0;
+    /** Whether the packet construction is complete. */
+    get isComplete() {
+        return !!(this.payload && this.payloadOffset >= this.payloadLength);
+    }
+    /**
+     * Takes arbitrary binary input and slots it into the header and payload
+     * appropriately. Returns the number of bytes that were written into the
+     * packet. This method can be called repeatedly, incrementally building
+     * up the packet until it is complete.
+     */
+    write(source) {
+        if (this.isComplete) {
+            throw Error('Cannot write to a completed Packet.');
+        }
+        // The index of the next byte to read from [source]. We have to track this
+        // because the source may contain the length *and* the message.
+        let i = 0;
+        // We can be in one of two states here:
+        //
+        // * [payload] is `null`, in which case we're adding data to [payloadLength]
+        //   until we reach a byte with its most significant bit set to 0.
+        //
+        // * [payload] is not `null`, in which case we're waiting for
+        //   [payloadOffset] to reach [payloadLength] bytes in it so this packet is
+        //   complete.
+        if (!this.payload) {
+            for (;;) {
+                const byte = source[i];
+                // Varints encode data in the 7 lower bits of each byte, which we access
+                // by masking with 0x7f = 0b01111111.
+                this.payloadLength += (byte & 0x7f) << this.payloadLengthBits;
+                this.payloadLengthBits += 7;
+                i++;
+                if (byte <= 0x7f) {
+                    // If the byte is lower than 0x7f = 0b01111111, that means its high
+                    // bit is unset which and we now know the full message length and can
+                    // initialize [this.payload].
+                    this.payload = Buffer.alloc(this.payloadLength);
+                    break;
+                }
+                else if (i === source.length) {
+                    // If we've hit the end of the source chunk, we need to wait for the
+                    // next chunk to arrive. Just return the number of bytes we've
+                    // consumed so far.
+                    return i;
+                }
+                else {
+                    // Otherwise, we continue reading bytes from the source data to fill
+                    // in [this.payloadLength].
+                }
+            }
+        }
+        // Copy as many bytes as we can from [source] to [payload], making sure not
+        // to try to copy more than the payload can hold (if the source has another
+        // message after the current one) or more than the source has available (if
+        // the current message is split across multiple chunks).
+        const bytesToWrite = Math.min(this.payload.length - this.payloadOffset, source.length - i);
+        this.payload.set(source.subarray(i, i + bytesToWrite), this.payloadOffset);
+        this.payloadOffset += bytesToWrite;
+        return i + bytesToWrite;
+    }
+}
+//# sourceMappingURL=packet-transformer.js.map

package/lib/src/packet-transformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"packet-transformer.js","sourceRoot":"","sources":["../../../lib/src/packet-transformer.ts"],"names":[],"mappings":"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"}

package/lib/src/protofier.js

@@ -0,0 +1,492 @@
+"use strict";
+// Copyright 2021 Google Inc. Use of this source code is governed by an
+// MIT-style license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Protofier = void 0;
+const immutable_1 = require("immutable");
+const protobuf_1 = require("@bufbuild/protobuf");
+const proto = __importStar(require("./vendor/embedded_sass_pb"));
+const utils = __importStar(require("./utils"));
+const argument_list_1 = require("./value/argument-list");
+const color_1 = require("./value/color");
+const function_1 = require("./value/function");
+const list_1 = require("./value/list");
+const map_1 = require("./value/map");
+const number_1 = require("./value/number");
+const string_1 = require("./value/string");
+const null_1 = require("./value/null");
+const boolean_1 = require("./value/boolean");
+const calculations_1 = require("./value/calculations");
+const mixin_1 = require("./value/mixin");
+/**
+ * A class that converts [Value] objects into protobufs.
+ *
+ * A given [Protofier] instance is valid only within the scope of a single
+ * custom function call.
+ */
+class Protofier {
+    functions;
+    /** All the argument lists returned by `deprotofy()`. */
+    argumentLists = [];
+    /**
+     * Returns IDs of all argument lists passed to `deprotofy()` whose keywords
+     * have been accessed.
+     */
+    get accessedArgumentLists() {
+        return this.argumentLists
+            .filter(list => list.keywordsAccessed)
+            .map(list => list.id);
+    }
+    constructor(
+    /**
+     * The registry of custom functions that can be invoked by the compiler.
+     * This is used to register first-class functions so that the compiler may
+     * invoke them.
+     */
+    functions) {
+        this.functions = functions;
+    }
+    /** Converts `value` to its protocol buffer representation. */
+    protofy(value) {
+        const result = (0, protobuf_1.create)(proto.ValueSchema, {});
+        if (value instanceof string_1.SassString) {
+            const string = (0, protobuf_1.create)(proto.Value_StringSchema, {
+                text: value.text,
+                quoted: value.hasQuotes,
+            });
+            result.value = { case: 'string', value: string };
+        }
+        else if (value instanceof number_1.SassNumber) {
+            result.value = { case: 'number', value: this.protofyNumber(value) };
+        }
+        else if (value instanceof color_1.SassColor) {
+            const channels = value.channelsOrNull;
+            const color = (0, protobuf_1.create)(proto.Value_ColorSchema, {
+                channel1: channels.get(0),
+                channel2: channels.get(1),
+                channel3: channels.get(2),
+                alpha: value.isChannelMissing('alpha') ? undefined : value.alpha,
+                space: value.space,
+            });
+            result.value = { case: 'color', value: color };
+        }
+        else if (value instanceof list_1.SassList) {
+            const list = (0, protobuf_1.create)(proto.Value_ListSchema, {
+                separator: this.protofySeparator(value.separator),
+                hasBrackets: value.hasBrackets,
+                contents: value.asList.map(element => this.protofy(element)).toArray(),
+            });
+            result.value = { case: 'list', value: list };
+        }
+        else if (value instanceof argument_list_1.SassArgumentList) {
+            if (value.compileContext === this.functions.compileContext) {
+                const list = (0, protobuf_1.create)(proto.Value_ArgumentListSchema, { id: value.id });
+                result.value = { case: 'argumentList', value: list };
+            }
+            else {
+                const list = (0, protobuf_1.create)(proto.Value_ArgumentListSchema, {
+                    separator: this.protofySeparator(value.separator),
+                    contents: value.asList
+                        .map(element => this.protofy(element))
+                        .toArray(),
+                });
+                for (const [key, mapValue] of value.keywordsInternal) {
+                    list.keywords[key] = this.protofy(mapValue);
+                }
+                result.value = { case: 'argumentList', value: list };
+            }
+        }
+        else if (value instanceof map_1.SassMap) {
+            const map = (0, protobuf_1.create)(proto.Value_MapSchema, {
+                entries: value.contents.toArray().map(([key, value]) => ({
+                    key: this.protofy(key),
+                    value: this.protofy(value),
+                })),
+            });
+            result.value = { case: 'map', value: map };
+        }
+        else if (value instanceof function_1.SassFunction) {
+            if (value.id !== undefined) {
+                if (value.compileContext !== this.functions.compileContext) {
+                    throw utils.compilerError(`Value ${value} does not belong to this compilation`);
+                }
+                const fn = (0, protobuf_1.create)(proto.Value_CompilerFunctionSchema, value);
+                result.value = { case: 'compilerFunction', value: fn };
+            }
+            else {
+                const fn = (0, protobuf_1.create)(proto.Value_HostFunctionSchema, {
+                    id: this.functions.register(value.callback),
+                    signature: value.signature,
+                });
+                result.value = { case: 'hostFunction', value: fn };
+            }
+        }
+        else if (value instanceof mixin_1.SassMixin) {
+            if (value.compileContext !== this.functions.compileContext) {
+                throw utils.compilerError(`Value ${value} does not belong to this compilation`);
+            }
+            const mixin = (0, protobuf_1.create)(proto.Value_CompilerMixinSchema, value);
+            result.value = { case: 'compilerMixin', value: mixin };
+        }
+        else if (value instanceof calculations_1.SassCalculation) {
+            result.value = {
+                case: 'calculation',
+                value: this.protofyCalculation(value),
+            };
+        }
+        else if (value === boolean_1.sassTrue) {
+            result.value = { case: 'singleton', value: proto.SingletonValue.TRUE };
+        }
+        else if (value === boolean_1.sassFalse) {
+            result.value = { case: 'singleton', value: proto.SingletonValue.FALSE };
+        }
+        else if (value === null_1.sassNull) {
+            result.value = { case: 'singleton', value: proto.SingletonValue.NULL };
+        }
+        else {
+            throw utils.compilerError(`Unknown Value ${value}`);
+        }
+        return result;
+    }
+    /** Converts `number` to its protocol buffer representation. */
+    protofyNumber(number) {
+        return (0, protobuf_1.create)(proto.Value_NumberSchema, {
+            value: number.value,
+            numerators: number.numeratorUnits.toArray(),
+            denominators: number.denominatorUnits.toArray(),
+        });
+    }
+    /** Converts `separator` to its protocol buffer representation. */
+    protofySeparator(separator) {
+        switch (separator) {
+            case ',':
+                return proto.ListSeparator.COMMA;
+            case ' ':
+                return proto.ListSeparator.SPACE;
+            case '/':
+                return proto.ListSeparator.SLASH;
+            case null:
+                return proto.ListSeparator.UNDECIDED;
+            default:
+                throw utils.compilerError(`Unknown ListSeparator ${separator}`);
+        }
+    }
+    /** Converts `calculation` to its protocol buffer representation. */
+    protofyCalculation(calculation) {
+        return (0, protobuf_1.create)(proto.Value_CalculationSchema, {
+            name: calculation.name,
+            arguments: calculation.arguments
+                .map(this.protofyCalculationValue.bind(this))
+                .toArray(),
+        });
+    }
+    /** Converts a CalculationValue that appears within a `SassCalculation` to
+     * its protocol buffer representation. */
+    protofyCalculationValue(value) {
+        const result = (0, protobuf_1.create)(proto.Value_Calculation_CalculationValueSchema, {});
+        if (value instanceof calculations_1.SassCalculation) {
+            result.value = {
+                case: 'calculation',
+                value: this.protofyCalculation(value),
+            };
+        }
+        else if (value instanceof calculations_1.CalculationOperation) {
+            result.value = {
+                case: 'operation',
+                value: (0, protobuf_1.create)(proto.Value_Calculation_CalculationOperationSchema, {
+                    operator: this.protofyCalculationOperator(value.operator),
+                    left: this.protofyCalculationValue(value.left),
+                    right: this.protofyCalculationValue(value.right),
+                }),
+            };
+        }
+        else if (value instanceof calculations_1.CalculationInterpolation) {
+            result.value = { case: 'interpolation', value: value.value };
+        }
+        else if (value instanceof string_1.SassString) {
+            result.value = { case: 'string', value: value.text };
+        }
+        else if (value instanceof number_1.SassNumber) {
+            result.value = { case: 'number', value: this.protofyNumber(value) };
+        }
+        else {
+            throw utils.compilerError(`Unknown CalculationValue ${value}`);
+        }
+        return result;
+    }
+    /** Converts `operator` to its protocol buffer representation. */
+    protofyCalculationOperator(operator) {
+        switch (operator) {
+            case '+':
+                return proto.CalculationOperator.PLUS;
+            case '-':
+                return proto.CalculationOperator.MINUS;
+            case '*':
+                return proto.CalculationOperator.TIMES;
+            case '/':
+                return proto.CalculationOperator.DIVIDE;
+            default:
+                throw utils.compilerError(`Unknown CalculationOperator ${operator}`);
+        }
+    }
+    /** Converts `value` to its JS representation. */
+    deprotofy(value) {
+        switch (value.value.case) {
+            case 'string': {
+                const string = value.value.value;
+                return string.text.length === 0
+                    ? string_1.SassString.empty({ quotes: string.quoted })
+                    : new string_1.SassString(string.text, { quotes: string.quoted });
+            }
+            case 'number': {
+                return this.deprotofyNumber(value.value.value);
+            }
+            case 'color': {
+                const color = value.value.value;
+                const channel1 = color.channel1 ?? null;
+                const channel2 = color.channel2 ?? null;
+                const channel3 = color.channel3 ?? null;
+                const alpha = color.alpha ?? null;
+                const space = color.space;
+                switch (color.space.toLowerCase()) {
+                    case 'rgb':
+                    case 'srgb':
+                    case 'srgb-linear':
+                    case 'display-p3':
+                    case 'display-p3-linear':
+                    case 'a98-rgb':
+                    case 'prophoto-rgb':
+                    case 'rec2020':
+                        return new color_1.SassColor({
+                            red: channel1,
+                            green: channel2,
+                            blue: channel3,
+                            alpha,
+                            space,
+                        });
+                    case 'hsl':
+                        return new color_1.SassColor({
+                            hue: channel1,
+                            saturation: channel2,
+                            lightness: channel3,
+                            alpha,
+                            space,
+                        });
+                    case 'hwb':
+                        return new color_1.SassColor({
+                            hue: channel1,
+                            whiteness: channel2,
+                            blackness: channel3,
+                            alpha,
+                            space,
+                        });
+                    case 'lab':
+                    case 'oklab':
+                        return new color_1.SassColor({
+                            lightness: channel1,
+                            a: channel2,
+                            b: channel3,
+                            alpha,
+                            space,
+                        });
+                    case 'lch':
+                    case 'oklch':
+                        return new color_1.SassColor({
+                            lightness: channel1,
+                            chroma: channel2,
+                            hue: channel3,
+                            alpha,
+                            space,
+                        });
+                    case 'xyz':
+                    case 'xyz-d65':
+                    case 'xyz-d50':
+                        return new color_1.SassColor({
+                            x: channel1,
+                            y: channel2,
+                            z: channel3,
+                            alpha,
+                            space,
+                        });
+                    default:
+                        throw utils.compilerError(`Unknown color space "${color.space}"`);
+                }
+            }
+            case 'list': {
+                const list = value.value.value;
+                const separator = this.deprotofySeparator(list.separator);
+                if (separator === null && list.contents.length > 1) {
+                    throw utils.compilerError(`Value.List ${list} can't have an undecided separator because it ` +
+                        `has ${list.contents.length} elements`);
+                }
+                return new list_1.SassList(list.contents.map(element => this.deprotofy(element)), { separator, brackets: list.hasBrackets });
+            }
+            case 'argumentList': {
+                const list = value.value.value;
+                const separator = this.deprotofySeparator(list.separator);
+                if (separator === null && list.contents.length > 1) {
+                    throw utils.compilerError(`Value.List ${list} can't have an undecided separator because it ` +
+                        `has ${list.contents.length} elements`);
+                }
+                const result = new argument_list_1.SassArgumentList(list.contents.map(element => this.deprotofy(element)), (0, immutable_1.OrderedMap)(Object.entries(list.keywords).map(([key, value]) => [
+                    key,
+                    this.deprotofy(value),
+                ])), separator, list.id, this.functions.compileContext);
+                this.argumentLists.push(result);
+                return result;
+            }
+            case 'map':
+                return new map_1.SassMap((0, immutable_1.OrderedMap)(value.value.value.entries.map(entry => {
+                    const key = entry.key;
+                    if (!key)
+                        throw utils.mandatoryError('Value.Map.Entry.key');
+                    const value = entry.value;
+                    if (!value)
+                        throw utils.mandatoryError('Value.Map.Entry.value');
+                    return [this.deprotofy(key), this.deprotofy(value)];
+                })));
+            case 'compilerFunction':
+                return new function_1.SassFunction(value.value.value.id, this.functions.compileContext);
+            case 'hostFunction':
+                throw utils.compilerError('The compiler may not send Value.host_function');
+            case 'compilerMixin':
+                return new mixin_1.SassMixin(value.value.value.id, this.functions.compileContext);
+            case 'calculation':
+                return this.deprotofyCalculation(value.value.value);
+            case 'singleton':
+                switch (value.value.value) {
+                    case proto.SingletonValue.TRUE:
+                        return boolean_1.sassTrue;
+                    case proto.SingletonValue.FALSE:
+                        return boolean_1.sassFalse;
+                    case proto.SingletonValue.NULL:
+                        return null_1.sassNull;
+                }
+            // eslint-disable-next-line no-fallthrough
+            default:
+                throw utils.mandatoryError('Value.value');
+        }
+    }
+    /** Converts `number` to its JS representation. */
+    deprotofyNumber(number) {
+        return new number_1.SassNumber(number.value, {
+            numeratorUnits: number.numerators,
+            denominatorUnits: number.denominators,
+        });
+    }
+    /** Converts `separator` to its JS representation. */
+    deprotofySeparator(separator) {
+        switch (separator) {
+            case proto.ListSeparator.COMMA:
+                return ',';
+            case proto.ListSeparator.SPACE:
+                return ' ';
+            case proto.ListSeparator.SLASH:
+                return '/';
+            case proto.ListSeparator.UNDECIDED:
+                return null;
+            default:
+                throw utils.compilerError(`Unknown separator ${separator}`);
+        }
+    }
+    /** Converts `calculation` to its Sass representation. */
+    deprotofyCalculation(calculation) {
+        switch (calculation.name) {
+            case 'calc':
+                if (calculation.arguments.length !== 1) {
+                    throw utils.compilerError('Value.Calculation.arguments must have exactly one argument for calc()');
+                }
+                return calculations_1.SassCalculation.calc(this.deprotofyCalculationValue(calculation.arguments[0]));
+            case 'clamp':
+                if (calculation.arguments.length === 0 ||
+                    calculation.arguments.length > 3) {
+                    throw utils.compilerError('Value.Calculation.arguments must have 1 to 3 arguments for clamp()');
+                }
+                return calculations_1.SassCalculation.clamp(this.deprotofyCalculationValue(calculation.arguments[0]), calculation.arguments.length > 1
+                    ? this.deprotofyCalculationValue(calculation.arguments[1])
+                    : undefined, calculation.arguments.length > 2
+                    ? this.deprotofyCalculationValue(calculation.arguments[2])
+                    : undefined);
+            case 'min':
+                if (calculation.arguments.length === 0) {
+                    throw utils.compilerError('Value.Calculation.arguments must have at least 1 argument for min()');
+                }
+                return calculations_1.SassCalculation.min(calculation.arguments.map(this.deprotofyCalculationValue));
+            case 'max':
+                if (calculation.arguments.length === 0) {
+                    throw utils.compilerError('Value.Calculation.arguments must have at least 1 argument for max()');
+                }
+                return calculations_1.SassCalculation.max(calculation.arguments.map(this.deprotofyCalculationValue));
+            default:
+                throw utils.compilerError(`Value.Calculation.name "${calculation.name}" is not a recognized calculation type`);
+        }
+    }
+    /** Converts `value` to its Sass representation. */
+    deprotofyCalculationValue(value) {
+        switch (value.value.case) {
+            case 'number':
+                return this.deprotofyNumber(value.value.value);
+            case 'calculation':
+                return this.deprotofyCalculation(value.value.value);
+            case 'string':
+                return new string_1.SassString(value.value.value, { quotes: false });
+            case 'operation':
+                return new calculations_1.CalculationOperation(this.deprotofyCalculationOperator(value.value.value.operator), this.deprotofyCalculationValue(value.value.value.left), this.deprotofyCalculationValue(value.value.value.right));
+            case 'interpolation':
+                return new calculations_1.CalculationInterpolation(value.value.value);
+            default:
+                throw utils.mandatoryError('Calculation.CalculationValue.value');
+        }
+    }
+    /** Converts `operator` to its Sass representation. */
+    deprotofyCalculationOperator(operator) {
+        switch (operator) {
+            case proto.CalculationOperator.PLUS:
+                return '+';
+            case proto.CalculationOperator.MINUS:
+                return '-';
+            case proto.CalculationOperator.TIMES:
+                return '*';
+            case proto.CalculationOperator.DIVIDE:
+                return '/';
+            default:
+                throw utils.compilerError(`Unknown CalculationOperator ${operator}`);
+        }
+    }
+}
+exports.Protofier = Protofier;
+//# sourceMappingURL=protofier.js.map