sb-edit-custom 0.15.0

package/lib/io/sb3/toSb3.js

@@ -0,0 +1,851 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var Block_1 = require("../../Block");
+var sb3 = __importStar(require("./interfaces"));
+var OpCode_1 = require("../../OpCode");
+var BIS = sb3.BlockInputStatus;
+function toSb3(project, options) {
+    // Serialize a project. Returns an object containing the text to be stored
+    // in the caller's project.json output file. toSb3 should be bound or applied
+    // so that 'this' refers to the Project object to be serialized.
+    if (options === void 0) { options = {}; }
+    var warn = function () { return undefined; };
+    if (options.warn) {
+        warn = options.warn;
+    }
+    function serializeInputsToFields(inputs, fieldEntries) {
+        // Serialize provided inputs into a "fields" mapping that can be stored
+        // on a serialized block.
+        //
+        // Where the Scratch 3.0 term "input" refers to a slot that accepts blocks,
+        // the term "field" is any user-interactive slot that cannot be obscured as
+        // such. Fields are also the interactive element within any shadow block,
+        // making their presence key to nearly all inputs.
+        //
+        // While inputs are fairly complex to serialize, fields are comparatively
+        // simple. A field always contains only its selected or entered value, so
+        // it's not concerned with a variety of structures like an input is.
+        // The format for a field mapping looks something like this:
+        //
+        //   {
+        //     VARIABLE: ["my variable", "theVariablesId"]
+        //   }
+        //
+        // Some fields take an ID; some don't. Here's another example:
+        //
+        //   {
+        //     DISTANCETOMENU: ["_mouse_"]
+        //   }
+        //
+        // The important thing to remember with fields during serialization is that
+        // they refer to slots that don't accept blocks: non-droppable menus,
+        // primarily, but the value in a (non-compressed) shadow input too.
+        var fields = {};
+        if (!fieldEntries) {
+            return fields;
+        }
+        for (var _i = 0, _a = Object.keys(fieldEntries); _i < _a.length; _i++) {
+            var key = _a[_i];
+            // TODO: remove type assertion
+            var input = inputs[key];
+            // Fields are stored as a plain [value, id?] pair.
+            var valueOrName = void 0;
+            var id = void 0;
+            switch (input.type) {
+                case "variable":
+                case "list":
+                    valueOrName = input.value.name;
+                    id = input.value.id;
+                    break;
+                default:
+                    valueOrName = input.value;
+                    id = null;
+                    break;
+            }
+            fields[key] = [valueOrName, id];
+        }
+        return fields;
+    }
+    function serializeInputShadow(value, options) {
+        // Serialize the shadow block representing a provided value and type.
+        //
+        // To gather an understanding of what shadow blocks are used for, have
+        // a look at serializeInputsToInputs; the gist is that they represent the
+        // actual place in which you type a value or select an option from a
+        // dropdown menu, and they can be obscured by having a block placed in
+        // their place.
+        //
+        // A shadow block's only concerns are with revealing an interactive field
+        // to the user. They exist so that inputs can let a non-shadow block stand
+        // in place of that field.
+        //
+        // There are two forms in which a shadow block can be serialized. The rarer
+        // structure, though the more basic one, is simply that of a typical block,
+        // only with the "shadow: true" flag set. A shadow block contains a single
+        // field; this field is stored the same as in any non-shadow block. Such a
+        // serialized shadow block might look like this:
+        //
+        //   {
+        //     opcode: "math_number",
+        //     shadow: true,
+        //     parent: "someBlockId",
+        //     fields: {
+        //       NUM: [50]
+        //     }
+        //   }
+        //
+        // The second form contains essentially the same data, but in a more
+        // "compressed" form. In this form, the shadow block is stored as a simple
+        // [type, value] pair, where the type is a constant representing the opcode
+        // and field name in which the value should be placed when deserializing.
+        // Because it's so much more concise than the non-compressed form, most
+        // inputs are serialized in this way. The same input above in compressed
+        // form would look like this:
+        //
+        //   [4, 50]
+        //
+        // As described in serializeInputsToInputs, compressed shadow blocks are
+        // stored inline with the input they correspond to, not as separate blocks
+        // with IDs.
+        //
+        // Within this code, we use the primimtiveOrOpCode option to determine how
+        // the shadow should be serialized. If it is a number, it's referring to a
+        // "primitive", the term uses for shadows when they are in the compressed
+        // form. If it's a string, it is a (shadow) block opcode, and should be
+        // serialized in the expanded form.
+        var _a;
+        var blockData = options.blockData, parentId = options.parentId, primitiveOrOpCode = options.primitiveOrOpCode, shadowId = options.shadowId;
+        var shadowValue = null;
+        if (primitiveOrOpCode === BIS.BROADCAST_PRIMITIVE) {
+            // Broadcast primitives, unlike all other primitives, expect two values:
+            // the broadcast name and its ID. We just reuse the name for its ID;
+            // after all, the name is the unique identifier sb-edit uses to refer to
+            // the broadcast.
+            shadowValue = [BIS.BROADCAST_PRIMITIVE, value, value];
+        }
+        else if (primitiveOrOpCode === BIS.COLOR_PICKER_PRIMITIVE) {
+            // Color primitive. Convert the {r, g, b} object into hex form.
+            // TODO: remove type assertion and actually check if the value is an RGB literal
+            var hex = function (k) {
+                return (value || { r: 0, g: 0, b: 0 })[k].toString(16).padStart(2, "0");
+            };
+            shadowValue = [BIS.COLOR_PICKER_PRIMITIVE, "#" + hex("r") + hex("g") + hex("b")];
+        }
+        else if (typeof primitiveOrOpCode === "number") {
+            // Primitive shadow, can be stored in compressed form.
+            shadowValue = [primitiveOrOpCode, String(value)];
+        }
+        else {
+            // Note: Only 1-field shadow blocks are supported.
+            var shadowOpCode = primitiveOrOpCode;
+            var fieldEntries = sb3.fieldTypeMap[shadowOpCode];
+            if (fieldEntries) {
+                var fieldKey = Object.keys(fieldEntries)[0];
+                var fields = (_a = {}, _a[fieldKey] = [value], _a);
+                blockData[shadowId] = {
+                    opcode: shadowOpCode,
+                    next: null,
+                    parent: parentId,
+                    fields: fields,
+                    inputs: {},
+                    mutation: undefined,
+                    shadow: true,
+                    topLevel: false
+                };
+                shadowValue = shadowId;
+            }
+        }
+        return shadowValue;
+    }
+    function serializeInputsToInputs(inputs, options) {
+        // Serialize provided inputs into an "inputs" mapping that can be stored
+        // on a serialized block.
+        //
+        // In any Scratch block, the majority of behavior configuration is provided
+        // by setting values for fields and inputs. In Scratch 3.0, the term
+        // "input" refers to any slot in a block where a block may be placed.
+        // (Fields are slots which don't accept blocks - non-droppable dropdown
+        // menus, most of the time.)
+        //
+        // During serialization, there are three fundamental ways to describe an
+        // input, each associated with a particular constant numeral. They're all
+        // based on the concept of a "shadow block", which is a representation of
+        // the non-block contents of an input. They're described in the following
+        // list, and are detailed further in serializeInputShadow.
+        //
+        // (1) INPUT_SAME_BLOCK_SHADOW:
+        //   The input contains only a shadow block - no non-shadow. Take the
+        //   number input (612), for example. The element you type in to change
+        //   that value is the shadow block. Because there is nothing obscuring
+        //   the shadow block, the input is serialized as INPUT_SAME_BLOCK_SHADOW.
+        // (2) INPUT_BLOCK_NO_SHADOW:
+        //   The input contains a non-shadow block - but no shadow. These are
+        //   relatively rare, since most inputs contain a shadow block (even when
+        //   obscured - see (3) below). Examples of inputs that don't are boolean
+        //   and substack slots, both prominent in blocks in the Control category.
+        // (3) INPUT_DIFF_BLOCK_SHADOW:
+        //   The input contains a non-shadow block - and a shadow block, too.
+        //   This is the case when you've placed an ordinary Scratch block into the
+        //   input, obscuring the shadow block in its place. It's worth noting that
+        //   Scratch 3.0 remembers the type and value of an obscured shadow: if you
+        //   place a block ((4) * (13)) into that number input (612), and later
+        //   remove it, Scratch will reveal the (612) shadow again.
+        //
+        // There is one other way an input may be serialized, which is simply not
+        // storing it at all. This occurs when an input contains neither a shadow
+        // nor a non-shadow, as in INPUT_BLOCK_NO_SHADOW (2) but with the block
+        // removed. (It's technically also valid to output null as the ID of the
+        // block inside an INPUT_BLOCK_NO_SHADOW to represent such inputs. In this
+        // code we choose not to store them at all.)
+        //
+        // When all is said and done, a block's inputs are stored as a mapping of
+        // each input's ID to an array whose first item is one of the constants
+        // described above, and whose following items depend on which constant.
+        // For the block "go to x: (50) y: ((x position) of (dog))", that mapping
+        // might look something like this:
+        //
+        //   inputs: {
+        //     X: [INPUT_SAME_BLOCK_SHADOW, [4, 50]],
+        //     Y: [INPUT_DIFF_BLOCK_SHADOW, "some block id", [4, -50]]
+        //   }
+        //
+        // The arrays [4, 50] and [4, -50] represent the two shadow blocks these
+        // inputs hold (the latter obscured by the "of" block). The value 4 is a
+        // constant referring to a "math_number" - essentially, it is the type of
+        // the shadow contained within that input.
+        //
+        // It's worth noting that some shadows are serialized as
+        // actual blocks on the target's "blocks" dictionary, and referred to by
+        // ID; the inputs in "switch to costume (item (random) of (costumes))"
+        // follow this structure:
+        //
+        //   inputs: {
+        //     COSTUME: [INPUT_DIFF_BLOCK_SHADOW, "id 1", "id 2"]
+        //   }
+        //
+        // ...where id 2 is the ID of the obscured shadow block. Specific details
+        // on how shadow blocks are serialized and whether they're stored as
+        // arrays or referenced by block ID is described in serializeInputShadow.
+        // As far as the input mapping is concerned, all that matters is that the
+        // two formats may be interchanged with one another.
+        //
+        // Also note that there are a couple blocks (specifically the variable and
+        // list-contents getters) which are serialized altogether in the compressed
+        // much the same as a compressed shadow, irregardless of the type of the
+        // input they've been placed inside. This is because they're so common in
+        // a project, and do not have any inputs of their own - only a field to
+        // identify which variable or list the block corresponds to. The input
+        // mapping for the block "set x to (spawn x)" would look something like
+        // this:
+        //
+        //   inputs: {
+        //     X: [INPUT_DIFF_BLOCK_SHADOW, [12, "spawn x", "someId"], [4, 0]]
+        //   }
+        //
+        // ...where someId is the ID of the variable, and [4, 0] is the obscured
+        // shadow block, as usual.
+        var block = options.block, blockData = options.blockData, initialBroadcastName = options.initialBroadcastName, customBlockDataMap = options.customBlockDataMap, initialValues = options.initialValues, inputEntries = options.inputEntries, target = options.target;
+        var resultInputs = {};
+        for (var _i = 0, _a = Object.entries(inputEntries); _i < _a.length; _i++) {
+            var _b = _a[_i], key = _b[0], entry = _b[1];
+            var input = inputs[key];
+            if (entry === sb3.BooleanOrSubstackInputStatus) {
+                var blockId = null;
+                if (input) {
+                    var options_1 = {
+                        target: target,
+                        blockData: blockData,
+                        initialBroadcastName: initialBroadcastName,
+                        customBlockDataMap: customBlockDataMap,
+                        parent: block
+                    };
+                    switch (input.type) {
+                        case "blocks":
+                            if (input.value !== null)
+                                blockId = serializeBlockStack(input.value, options_1);
+                            break;
+                        case "block":
+                            blockId = serializeBlock(input.value, options_1);
+                            break;
+                    }
+                }
+                if (blockId) {
+                    resultInputs[key] = [BIS.INPUT_BLOCK_NO_SHADOW, blockId];
+                }
+            }
+            else {
+                var valueForShadow = void 0;
+                if (input.type === "block") {
+                    valueForShadow = initialValues[key];
+                    // Special-case some input opcodes for more realistic initial values.
+                    switch (entry) {
+                        case OpCode_1.OpCode.looks_costume:
+                            if (target.costumes[0]) {
+                                valueForShadow = target.costumes[0].name;
+                            }
+                            break;
+                        case OpCode_1.OpCode.sound_sounds_menu:
+                            if (target.sounds[0]) {
+                                valueForShadow = target.sounds[0].name;
+                            }
+                            break;
+                        case OpCode_1.OpCode.event_broadcast_menu:
+                            valueForShadow = initialBroadcastName;
+                            break;
+                    }
+                }
+                else {
+                    valueForShadow = input.value;
+                }
+                var shadowValue = serializeInputShadow(valueForShadow, {
+                    blockData: blockData,
+                    parentId: block.id,
+                    shadowId: block.id + "-" + key,
+                    primitiveOrOpCode: entry
+                });
+                if (input.type === "block") {
+                    var obscuringBlockValue = void 0;
+                    switch (input.value.opcode) {
+                        case OpCode_1.OpCode.data_variable: {
+                            var _c = input.value.inputs.VARIABLE.value, variableId = _c.id, variableName = _c.name;
+                            obscuringBlockValue = [BIS.VAR_PRIMITIVE, variableName, variableId];
+                            break;
+                        }
+                        case OpCode_1.OpCode.data_listcontents: {
+                            var _d = input.value.inputs.LIST.value, listId = _d.id, listName = _d.name;
+                            obscuringBlockValue = [BIS.LIST_PRIMITIVE, listName, listId];
+                            break;
+                        }
+                        default: {
+                            obscuringBlockValue = serializeBlock(input.value, {
+                                blockData: blockData,
+                                initialBroadcastName: initialBroadcastName,
+                                customBlockDataMap: customBlockDataMap,
+                                parent: block,
+                                target: target
+                            });
+                            break;
+                        }
+                    }
+                    if (shadowValue) {
+                        resultInputs[key] = [BIS.INPUT_DIFF_BLOCK_SHADOW, obscuringBlockValue, shadowValue];
+                    }
+                    else {
+                        resultInputs[key] = [BIS.INPUT_BLOCK_NO_SHADOW, obscuringBlockValue];
+                    }
+                }
+                else {
+                    resultInputs[key] = [BIS.INPUT_SAME_BLOCK_SHADOW, shadowValue];
+                }
+            }
+        }
+        return resultInputs;
+    }
+    function serializeInputs(block, options) {
+        // Serialize a block's inputs, returning the data which should be stored on
+        // the serialized block, as well as any associated blockData.
+        //
+        // This function looks more intimidating than it ought to; most of the meat
+        // here is related to serializing specific blocks whose resultant data must
+        // be generated differently than other blocks. (Custom blocks are related
+        // the main ones to blame.)
+        //
+        // serializeInputs is in charge of converting the inputs on the provided
+        // block into the structures that Scratch 3.0 expects. There are (usually)
+        // two mappings into which inputs are stored: fields and inputs. Specific
+        // details on how these are serialized is discussed in their corresponding
+        // functions (which serializeInputs defers to for most blocks), but the
+        // gist is:
+        //
+        // * Fields store actual data, while inputs refer to shadow blocks.
+        //   (Each shadow block contains a field for storing the value of that
+        //    input, though often they are serialized as a "compressed" form that
+        //    doesn't explicitly label that field. See serializeInputsToInputs.)
+        // * Reporter blocks can be placed only into inputs - not fields.
+        //   (In actuality, the input is not replaced by a block; rather, the way
+        //    it is stored is changed to refer to the ID of the placed block, and
+        //    the shadow block contianing the field value is maintained, "obscured"
+        //    but able to be recovered if the obscuring block is moved elsewhere.)
+        //
+        // Blocks may also have a "mutation" field. This is an XML attribute
+        // mapping containing data specific to a particular instance of a block
+        // that wouldn't fit on the block's input and field mappings. Specific
+        // details may vary greatly based on the opcode.
+        var blockData = options.blockData, target = options.target, initialBroadcastName = options.initialBroadcastName, customBlockDataMap = options.customBlockDataMap;
+        var fields = serializeInputsToFields(block.inputs, sb3.fieldTypeMap[block.opcode]);
+        var inputs = {};
+        var mutation;
+        if (block.isKnownBlock()) {
+            switch (block.opcode) {
+                case OpCode_1.OpCode.procedures_definition: {
+                    var prototypeId = block.id + "-prototype";
+                    var _a = customBlockDataMap[block.inputs.PROCCODE.value], args = _a.args, warp = _a.warp;
+                    var prototypeInputs = {};
+                    for (var _i = 0, args_1 = args; _i < args_1.length; _i++) {
+                        var arg = args_1[_i];
+                        var shadowId = arg.id + "-prototype-shadow";
+                        blockData[shadowId] = {
+                            opcode: {
+                                boolean: OpCode_1.OpCode.argument_reporter_boolean,
+                                numberOrString: OpCode_1.OpCode.argument_reporter_string_number
+                            }[arg.type],
+                            next: null,
+                            parent: prototypeId,
+                            inputs: {},
+                            fields: {
+                                VALUE: [arg.name]
+                            },
+                            mutation: undefined,
+                            shadow: true,
+                            topLevel: false
+                        };
+                        prototypeInputs[arg.id] = [BIS.INPUT_SAME_BLOCK_SHADOW, shadowId];
+                    }
+                    blockData[prototypeId] = {
+                        opcode: OpCode_1.OpCode.procedures_prototype,
+                        next: null,
+                        parent: block.id,
+                        inputs: prototypeInputs,
+                        fields: {},
+                        shadow: true,
+                        topLevel: false,
+                        mutation: {
+                            tagName: "mutation",
+                            children: [],
+                            proccode: block.inputs.PROCCODE.value,
+                            argumentids: JSON.stringify(args.map(function (arg) { return arg.id; })),
+                            argumentnames: JSON.stringify(args.map(function (arg) { return arg.name; })),
+                            argumentdefaults: JSON.stringify(args.map(function (arg) { return arg.default; })),
+                            warp: JSON.stringify(warp)
+                        }
+                    };
+                    inputs.custom_block = [BIS.INPUT_SAME_BLOCK_SHADOW, prototypeId];
+                    break;
+                }
+                case OpCode_1.OpCode.procedures_call: {
+                    var proccode = block.inputs.PROCCODE.value;
+                    var customBlockData = customBlockDataMap[proccode];
+                    if (!customBlockData) {
+                        warn("Missing custom block prototype for proccode ".concat(proccode, " (").concat(block.id, " in ").concat(target.name, "); skipping this block"));
+                        return null;
+                    }
+                    var args = customBlockData.args, warp = customBlockData.warp;
+                    mutation = {
+                        tagName: "mutation",
+                        children: [],
+                        proccode: proccode,
+                        argumentids: JSON.stringify(args.map(function (arg) { return arg.id; })),
+                        warp: JSON.stringify(warp)
+                    };
+                    var inputEntries = {};
+                    var constructedInputs = {};
+                    var initialValues = {};
+                    for (var i = 0; i < args.length; i++) {
+                        var _b = args[i], type = _b.type, id = _b.id;
+                        switch (type) {
+                            case "boolean":
+                                inputEntries[id] = sb3.BooleanOrSubstackInputStatus;
+                                // A boolean input's initialValues entry will never be
+                                // referenced (because empty boolean inputs don't contain
+                                // shadow blocks), so there's no need to set it.
+                                break;
+                            case "numberOrString":
+                                inputEntries[id] = BIS.TEXT_PRIMITIVE;
+                                initialValues[id] = "";
+                                break;
+                        }
+                        constructedInputs[id] = block.inputs.INPUTS.value[i];
+                    }
+                    inputs = serializeInputsToInputs(constructedInputs, {
+                        target: target,
+                        blockData: blockData,
+                        initialBroadcastName: initialBroadcastName,
+                        customBlockDataMap: customBlockDataMap,
+                        block: block,
+                        initialValues: initialValues,
+                        inputEntries: inputEntries
+                    });
+                    break;
+                }
+                default: {
+                    var inputEntries = sb3.inputPrimitiveOrShadowMap[block.opcode];
+                    var initialValues = {};
+                    for (var _c = 0, _d = Object.keys(inputEntries); _c < _d.length; _c++) {
+                        var key = _d[_c];
+                        var defaultInput = Block_1.BlockBase.getDefaultInput(block.opcode, key);
+                        if (defaultInput) {
+                            initialValues[key] = defaultInput.initial;
+                        }
+                    }
+                    inputs = serializeInputsToInputs(block.inputs, {
+                        target: target,
+                        blockData: blockData,
+                        initialBroadcastName: initialBroadcastName,
+                        customBlockDataMap: customBlockDataMap,
+                        block: block,
+                        initialValues: initialValues,
+                        inputEntries: inputEntries
+                    });
+                    break;
+                }
+            }
+        }
+        return { inputs: inputs, fields: fields, mutation: mutation };
+    }
+    function serializeBlock(block, options) {
+        // Serialize a block, mutating the passed block data and returning the
+        // ID which should be used when referring to this block, or null if no
+        // such block could be serialized.
+        //
+        // As discussed in serializeTarget, blocks are serialized into a single
+        // flat dictionary (per target), rather than an abstract syntax tree.
+        // Within a serialized block, it's common to find reference to another
+        // block by its ID. This is seen in linking to the next and parent blocks,
+        // and to inputs.
+        //
+        // In Scratch 3.0 (contrasting with 2.0 as well as the intermediate format
+        // created for sb-edit), "inputs" are stored in not one but two containers
+        // per block: inputs, and fields. The difference is discussed in their
+        // corresponding functions. Blocks may also carry a mutation, a mapping of
+        // XML property names and values, for use in some blocks (notably those
+        // associated with custom blocks). All this data is serialized and detailed
+        // in serializeInputs.
+        //
+        // serializeBlock is in charge of serializing an individual block, as well
+        // as its following block, and building the links between it and its parent
+        // and siblings. As with other block-related functions, data is collected
+        // into a flat mapping of IDs to their associated serialized block.
+        //
+        // It's possible for a block to be skipped altogether during serialization,
+        // because it referred to some value which could not be converted into
+        // valid SB3 data. For reporters, this means leaving an empty input; for
+        // stack blocks, it means skipping to the next block in the sibling array
+        // (or leaving an empty connection if there is none). It's up to the caller
+        // to handle serializeBlock returning a null blockId usefully.
+        //
+        // Note that while serializeBlock will recursively serialize input blocks,
+        // it will not serialize the following sibling block. As such, the
+        // serialized block will always contain {next: null}. The caller is
+        // responsible for updating this and setting it to the following block ID.
+        // (The function serializeBlockStack is generally where this happens.)
+        var blockData = options.blockData, initialBroadcastName = options.initialBroadcastName, customBlockDataMap = options.customBlockDataMap, parent = options.parent, target = options.target;
+        var serializeInputsResult = serializeInputs(block, {
+            target: target,
+            blockData: blockData,
+            initialBroadcastName: initialBroadcastName,
+            customBlockDataMap: customBlockDataMap
+        });
+        if (!serializeInputsResult) {
+            return null;
+        }
+        var inputs = serializeInputsResult.inputs, fields = serializeInputsResult.fields, mutation = serializeInputsResult.mutation;
+        var obj = {
+            opcode: block.opcode,
+            parent: parent ? parent.id : null,
+            next: null,
+            topLevel: !parent,
+            inputs: inputs,
+            fields: fields,
+            mutation: mutation,
+            shadow: false
+        };
+        if (obj.topLevel) {
+            obj.x = options.x;
+            obj.y = options.y;
+        }
+        var blockId = block.id;
+        blockData[blockId] = obj;
+        return blockId;
+    }
+    function serializeBlockStack(blocks, options) {
+        // Serialize a stack of blocks, returning the ID of the first successfully
+        // serialized block, or null if there is none.
+        //
+        // When serializing a block returns null, there is an expectation that the
+        // block should be "skipped" by the caller. When dealing with stack blocks,
+        // that means making a connection between the previous block and the first
+        // successfully successfully serialized following block. This function
+        // handles that case, as well as building the connections between stack
+        // blocks in general.
+        //
+        // Note that the passed options object will be mutated, to change the
+        // parent block to the previous block in the stack.
+        var blockData = options.blockData;
+        var previousBlockId = null;
+        var firstBlockId = null;
+        for (var _i = 0, blocks_1 = blocks; _i < blocks_1.length; _i++) {
+            var block = blocks_1[_i];
+            var blockId = serializeBlock(block, options);
+            if (!blockId) {
+                continue;
+            }
+            if (!firstBlockId) {
+                firstBlockId = blockId;
+            }
+            if (previousBlockId) {
+                blockData[previousBlockId].next = blockId;
+            }
+            previousBlockId = blockId;
+            options.parent = block;
+        }
+        return firstBlockId;
+    }
+    function collectCustomBlockData(target) {
+        // Parse the scripts in a target, collecting metadata about each custom
+        // block's arguments and other info, and return a mapping of proccode to
+        // the associated data.
+        //
+        // It's necesary to collect this data prior to serializing any associated
+        // procedures_call blocks, because they require access to data only found
+        // on the associated procedures_definition. (Specifically, the types of
+        // each input on the custom block, since those will influence the initial
+        // value & shadow type in the serialized caller block's inputs.)
+        var data = {};
+        for (var _i = 0, _a = target.scripts; _i < _a.length; _i++) {
+            var script = _a[_i];
+            var block = script.blocks[0];
+            if (block.opcode !== OpCode_1.OpCode.procedures_definition) {
+                continue;
+            }
+            var proccode = block.inputs.PROCCODE.value;
+            var warp = block.inputs.WARP.value;
+            var args = [];
+            var argData = block.inputs.ARGUMENTS.value;
+            for (var i = 0; i < argData.length; i++) {
+                var _b = argData[i], name_1 = _b.name, type = _b.type;
+                if (type === "label") {
+                    continue;
+                }
+                var id = "".concat(block.id, "-argument-").concat(i);
+                args.push({
+                    id: id,
+                    name: name_1,
+                    type: type,
+                    default: {
+                        boolean: "false",
+                        numberOrString: ""
+                    }[type]
+                });
+            }
+            data[proccode] = { args: args, warp: warp };
+        }
+        return data;
+    }
+    function serializeTarget(target, options) {
+        // Serialize a target. This function typically isn't used on its own, in
+        // favor of the specialized functions for sprites and stage. It contains
+        // the base code shared across all targets - sounds and costumes, variables
+        // and lists, and, of course, blocks, for example.
+        //
+        // In Scratch 3.0, the representation for the code in a sprite is a flat,
+        // one-dimensional mapping of block ID to block data. To identify which
+        // blocks are the first block in a "script", a topLevel flag is used.
+        // This differs considerably from 2.0, where the scripts property of any
+        // target contained an AST (abstract syntax tree) representation.
+        //
+        // When a block is serialized, a flat block mapping is returned, and this
+        // is combined into the mapping of whatever is consuming the serialized
+        // data. Eventually, all blocks (and their subblocks, inputs, etc) have
+        // been serialized, and the collected data is stored on the target.
+        //
+        // serializeTarget also handles converting costumes, sounds, variables,
+        // etc into the structures Scratch 3.0 expects.
+        function mapToIdObject(values, fn) {
+            // Map an Array of objects with an "id` property
+            // (e.g [{id: 1, prop: "val"}, ...])
+            // into an object whose keys are the `id` property,
+            // and whose values are the passed objects transformed by `fn`.
+            var ret = {};
+            for (var _i = 0, values_1 = values; _i < values_1.length; _i++) {
+                var object = values_1[_i];
+                ret[object.id] = fn(object);
+            }
+            return ret;
+        }
+        var broadcasts = options.broadcasts, initialBroadcastName = options.initialBroadcastName;
+        var blockData = {};
+        var customBlockDataMap = collectCustomBlockData(target);
+        for (var _i = 0, _a = target.scripts; _i < _a.length; _i++) {
+            var script = _a[_i];
+            serializeBlockStack(script.blocks, {
+                target: target,
+                blockData: blockData,
+                initialBroadcastName: initialBroadcastName,
+                customBlockDataMap: customBlockDataMap,
+                x: script.x,
+                y: script.y
+            });
+        }
+        return {
+            name: target.name,
+            isStage: target.isStage,
+            currentCostume: target.costumeNumber,
+            layerOrder: target.layerOrder,
+            volume: target.volume,
+            blocks: blockData,
+            broadcasts: broadcasts,
+            // @todo sb-edit doesn't support comments (as of feb 12, 2020)
+            comments: {},
+            sounds: target.sounds.map(function (sound) {
+                var _a, _b;
+                return ({
+                    name: sound.name,
+                    dataFormat: sound.ext,
+                    assetId: sound.md5,
+                    md5ext: sound.md5 + "." + sound.ext,
+                    sampleCount: (_a = sound.sampleCount) !== null && _a !== void 0 ? _a : undefined,
+                    rate: (_b = sound.sampleRate) !== null && _b !== void 0 ? _b : undefined
+                });
+            }),
+            costumes: target.costumes.map(function (costume) {
+                var _a, _b;
+                return ({
+                    name: costume.name,
+                    assetId: costume.md5,
+                    md5ext: costume.md5 + "." + costume.ext,
+                    bitmapResolution: costume.bitmapResolution,
+                    dataFormat: costume.ext,
+                    rotationCenterX: (_a = costume.centerX) !== null && _a !== void 0 ? _a : undefined,
+                    rotationCenterY: (_b = costume.centerY) !== null && _b !== void 0 ? _b : undefined
+                });
+            }),
+            variables: mapToIdObject(target.variables, function (_a) {
+                var name = _a.name, value = _a.value, cloud = _a.cloud;
+                if (cloud) {
+                    return [name, value, cloud];
+                }
+                else {
+                    return [name, value];
+                }
+            }),
+            lists: mapToIdObject(target.lists, function (_a) {
+                var name = _a.name, value = _a.value;
+                return [name, value];
+            })
+        };
+    }
+    var rotationStyleMap = {
+        normal: "all around",
+        leftRight: "left-right",
+        none: "don't rotate"
+    };
+    function serializeSprite(sprite, options) {
+        // Serialize a sprite. Extending from a serialized target, sprites carry
+        // a variety of properties for their on-screen position and appearance.
+        var initialBroadcastName = options.initialBroadcastName;
+        return __assign(__assign({}, serializeTarget(sprite, {
+            initialBroadcastName: initialBroadcastName,
+            // Broadcasts are stored on the stage, not on any sprite.
+            broadcasts: {}
+        })), { isStage: false, x: sprite.x, y: sprite.y, size: sprite.size, direction: sprite.direction, rotationStyle: rotationStyleMap[sprite.rotationStyle], draggable: sprite.isDraggable, visible: sprite.visible });
+    }
+    function serializeStage(stage, options) {
+        // Serialize a stage. Extending from a serialized target, the stage carries
+        // additional properties for values shared across the project - notably,
+        // the broadcast dictionary, as well as values for some extensions.
+        var broadcasts = options.broadcasts, initialBroadcastName = options.initialBroadcastName;
+        return __assign(__assign({}, serializeTarget(stage, { broadcasts: broadcasts, initialBroadcastName: initialBroadcastName })), { isStage: true, tempo: options.tempo, textToSpeechLanguage: options.textToSpeechLanguage, videoState: options.videoState, videoTransparency: options.videoTransparency });
+    }
+    function serializeProject(project) {
+        // Serialize a project. This is the master function used when project.toSb3
+        // is called. The main purpose of serializeProject is to serialize each
+        // target (sprite or stage) and collect them together in the final output
+        // format. It also provides utility functions shared across every target's
+        // serialization, e.g. broadcast utilities.
+        // Set the broadcast name used in obscured broadcast inputs to the first
+        // sorted-alphabetically broadcast's name. While we're parsing through
+        // all the broadcast names in the project, also store them on a simple
+        // mapping of (name -> name), to be stored on the stage. (toSb3 uses a
+        // broadcast's name as its ID.)
+        var lowestName;
+        var broadcasts = {};
+        for (var _i = 0, _a = __spreadArray([project.stage], project.sprites, true); _i < _a.length; _i++) {
+            var target = _a[_i];
+            for (var _b = 0, _c = target.blocks; _b < _c.length; _b++) {
+                var block = _c[_b];
+                if (block.opcode === OpCode_1.OpCode.event_whenbroadcastreceived ||
+                    block.opcode === OpCode_1.OpCode.event_broadcast ||
+                    block.opcode === OpCode_1.OpCode.event_broadcastandwait) {
+                    var broadcastInput = block.opcode === OpCode_1.OpCode.event_whenbroadcastreceived
+                        ? block.inputs.BROADCAST_OPTION
+                        : block.inputs.BROADCAST_INPUT;
+                    if (broadcastInput.type === "broadcast") {
+                        var currentName = broadcastInput.value;
+                        if (typeof lowestName === "undefined" || currentName < lowestName) {
+                            lowestName = currentName;
+                        }
+                        broadcasts[currentName] = currentName;
+                    }
+                }
+            }
+        }
+        var initialBroadcastName = lowestName || "message1";
+        return {
+            targets: __spreadArray([
+                serializeStage(project.stage, {
+                    initialBroadcastName: initialBroadcastName,
+                    broadcasts: broadcasts,
+                    tempo: project.tempo,
+                    textToSpeechLanguage: project.textToSpeechLanguage,
+                    videoState: project.videoOn ? "on" : "off",
+                    videoTransparency: project.videoAlpha
+                })
+            ], project.sprites.map(function (sprite) {
+                return serializeSprite(sprite, {
+                    initialBroadcastName: initialBroadcastName
+                });
+            }), true),
+            meta: {
+                semver: "3.0.0"
+            }
+        };
+    }
+    return {
+        json: JSON.stringify(serializeProject(project))
+    };
+}
+exports.default = toSb3;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"toSb3.js","sourceRoot":"","sources":["../../../src/io/sb3/toSb3.ts"],"names":[],"mappings":"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"}