blockly 8.20220331.0-beta.0 → 9.0.0-beta.1

package/core/positionable_helpers.d.ts

@@ -0,0 +1,96 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { UiMetrics } from './metrics_manager.js';
+import { Rect } from './utils/rect.js';
+import type { Size } from './utils/size.js';
+import type { WorkspaceSvg } from './workspace_svg.js';
+/**
+ * Enum for vertical positioning.
+ *
+ * @alias Blockly.uiPosition.verticalPosition
+ * @internal
+ */
+export declare enum verticalPosition {
+    TOP = 0,
+    BOTTOM = 1
+}
+/**
+ * Enum for horizontal positioning.
+ *
+ * @alias Blockly.uiPosition.horizontalPosition
+ * @internal
+ */
+export declare enum horizontalPosition {
+    LEFT = 0,
+    RIGHT = 1
+}
+/**
+ * An object defining a horizontal and vertical positioning.
+ *
+ * @alias Blockly.uiPosition.Position
+ * @internal
+ */
+export interface Position {
+    horizontal: horizontalPosition;
+    vertical: verticalPosition;
+}
+/**
+ * Enum for bump rules to use for dealing with collisions.
+ *
+ * @alias Blockly.uiPosition.bumpDirection
+ * @internal
+ */
+export declare enum bumpDirection {
+    UP = 0,
+    DOWN = 1
+}
+/**
+ * Returns a rectangle representing reasonable position for where to place a UI
+ * element of the specified size given the restraints and locations of the
+ * scrollbars. This method does not take into account any already placed UI
+ * elements.
+ *
+ * @param position The starting horizontal and vertical position.
+ * @param size the size of the UI element to get a start position for.
+ * @param horizontalPadding The horizontal padding to use.
+ * @param verticalPadding The vertical padding to use.
+ * @param metrics The workspace UI metrics.
+ * @param workspace The workspace.
+ * @returns The suggested start position.
+ * @alias Blockly.uiPosition.getStartPositionRect
+ * @internal
+ */
+export declare function getStartPositionRect(position: Position, size: Size, horizontalPadding: number, verticalPadding: number, metrics: UiMetrics, workspace: WorkspaceSvg): Rect;
+/**
+ * Returns a corner position that is on the opposite side of the workspace from
+ * the toolbox.
+ * If in horizontal orientation, defaults to the bottom corner. If in vertical
+ * orientation, defaults to the right corner.
+ *
+ * @param workspace The workspace.
+ * @param metrics The workspace metrics.
+ * @returns The suggested corner position.
+ * @alias Blockly.uiPosition.getCornerOppositeToolbox
+ * @internal
+ */
+export declare function getCornerOppositeToolbox(workspace: WorkspaceSvg, metrics: UiMetrics): Position;
+/**
+ * Returns a position Rect based on a starting position that is bumped
+ * so that it doesn't intersect with any of the provided savedPositions. This
+ * method does not check that the bumped position is still within bounds.
+ *
+ * @param startRect The starting position to use.
+ * @param margin The margin to use between elements when bumping.
+ * @param bumpDir The direction to bump if there is a collision with an existing
+ *     UI element.
+ * @param savedPositions List of rectangles that represent the positions of UI
+ *     elements already placed.
+ * @returns The suggested position rectangle.
+ * @alias Blockly.uiPosition.bumpPositionRect
+ * @internal
+ */
+export declare function bumpPositionRect(startRect: Rect, margin: number, bumpDir: bumpDirection, savedPositions: Rect[]): Rect;
+//# sourceMappingURL=positionable_helpers.d.ts.map

package/core/procedures.d.ts

@@ -0,0 +1,125 @@
+/**
+ * @license
+ * Copyright 2012 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import './events/events_block_change.js';
+import type { Block } from './block.js';
+import type { Abstract } from './events/events_abstract.js';
+import type { Field } from './field.js';
+import type { Workspace } from './workspace.js';
+import type { WorkspaceSvg } from './workspace_svg.js';
+/**
+ * String for use in the "custom" attribute of a category in toolbox XML.
+ * This string indicates that the category should be dynamically populated with
+ * procedure blocks.
+ * See also Blockly.Variables.CATEGORY_NAME and
+ * Blockly.VariablesDynamic.CATEGORY_NAME.
+ *
+ * @alias Blockly.Procedures.CATEGORY_NAME
+ */
+export declare const CATEGORY_NAME = "PROCEDURE";
+/**
+ * The default argument for a procedures_mutatorarg block.
+ *
+ * @alias Blockly.Procedures.DEFAULT_ARG
+ */
+export declare const DEFAULT_ARG = "x";
+export declare type ProcedureTuple = [string, string[], boolean];
+/**
+ * Procedure block type.
+ *
+ * @alias Blockly.Procedures.ProcedureBlock
+ */
+export interface ProcedureBlock {
+    getProcedureCall: () => string;
+    renameProcedure: (p1: string, p2: string) => void;
+    getProcedureDef: () => ProcedureTuple;
+}
+/**
+ * Find all user-created procedure definitions in a workspace.
+ *
+ * @param root Root workspace.
+ * @returns Pair of arrays, the first contains procedures without return
+ *     variables, the second with. Each procedure is defined by a three-element
+ *     list of name, parameter list, and return value boolean.
+ * @alias Blockly.Procedures.allProcedures
+ */
+export declare function allProcedures(root: Workspace): [
+    ProcedureTuple[],
+    ProcedureTuple[]
+];
+/**
+ * Ensure two identically-named procedures don't exist.
+ * Take the proposed procedure name, and return a legal name i.e. one that
+ * is not empty and doesn't collide with other procedures.
+ *
+ * @param name Proposed procedure name.
+ * @param block Block to disambiguate.
+ * @returns Non-colliding name.
+ * @alias Blockly.Procedures.findLegalName
+ */
+export declare function findLegalName(name: string, block: Block): string;
+/**
+ * Return if the given name is already a procedure name.
+ *
+ * @param name The questionable name.
+ * @param workspace The workspace to scan for collisions.
+ * @param opt_exclude Optional block to exclude from comparisons (one doesn't
+ *     want to collide with oneself).
+ * @returns True if the name is used, otherwise return false.
+ * @alias Blockly.Procedures.isNameUsed
+ */
+export declare function isNameUsed(name: string, workspace: Workspace, opt_exclude?: Block): boolean;
+/**
+ * Rename a procedure.  Called by the editable field.
+ *
+ * @param name The proposed new name.
+ * @returns The accepted name.
+ * @alias Blockly.Procedures.rename
+ */
+export declare function rename(this: Field, name: string): string;
+/**
+ * Construct the blocks required by the flyout for the procedure category.
+ *
+ * @param workspace The workspace containing procedures.
+ * @returns Array of XML block elements.
+ * @alias Blockly.Procedures.flyoutCategory
+ */
+export declare function flyoutCategory(workspace: WorkspaceSvg): Element[];
+/**
+ * Listens for when a procedure mutator is opened. Then it triggers a flyout
+ * update and adds a mutator change listener to the mutator workspace.
+ *
+ * @param e The event that triggered this listener.
+ * @alias Blockly.Procedures.mutatorOpenListener
+ * @internal
+ */
+export declare function mutatorOpenListener(e: Abstract): void;
+/**
+ * Find all the callers of a named procedure.
+ *
+ * @param name Name of procedure.
+ * @param workspace The workspace to find callers in.
+ * @returns Array of caller blocks.
+ * @alias Blockly.Procedures.getCallers
+ */
+export declare function getCallers(name: string, workspace: Workspace): Block[];
+/**
+ * When a procedure definition changes its parameters, find and edit all its
+ * callers.
+ *
+ * @param defBlock Procedure definition block.
+ * @alias Blockly.Procedures.mutateCallers
+ */
+export declare function mutateCallers(defBlock: Block): void;
+/**
+ * Find the definition block for the named procedure.
+ *
+ * @param name Name of procedure.
+ * @param workspace The workspace to search.
+ * @returns The procedure definition block, or null not found.
+ * @alias Blockly.Procedures.getDefinition
+ */
+export declare function getDefinition(name: string, workspace: Workspace): Block | null;
+//# sourceMappingURL=procedures.d.ts.map

package/core/registry.d.ts

@@ -0,0 +1,148 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Abstract } from './events/events_abstract.js';
+import type { Field } from './field.js';
+import type { IBlockDragger } from './interfaces/i_block_dragger.js';
+import type { IConnectionChecker } from './interfaces/i_connection_checker.js';
+import type { IFlyout } from './interfaces/i_flyout.js';
+import type { IMetricsManager } from './interfaces/i_metrics_manager.js';
+import type { ISerializer } from './interfaces/i_serializer.js';
+import type { IToolbox } from './interfaces/i_toolbox.js';
+import type { Cursor } from './keyboard_nav/cursor.js';
+import type { Options } from './options.js';
+import type { Renderer } from './renderers/common/renderer.js';
+import type { Theme } from './theme.js';
+import type { ToolboxItem } from './toolbox/toolbox_item.js';
+export declare const TEST_ONLY: {
+    typeMap: {
+        [key: string]: {
+            [key: string]: any;
+        };
+    };
+};
+/**
+ * The string used to register the default class for a type of plugin.
+ *
+ * @alias Blockly.registry.DEFAULT
+ */
+export declare const DEFAULT = "default";
+/**
+ * A name with the type of the element stored in the generic.
+ *
+ * @alias Blockly.registry.Type
+ */
+export declare class Type<_T> {
+    private readonly name;
+    /** @param name The name of the registry type. */
+    constructor(name: string);
+    /**
+     * Returns the name of the type.
+     *
+     * @returns The name.
+     */
+    toString(): string;
+    static CONNECTION_CHECKER: Type<IConnectionChecker>;
+    static CURSOR: Type<Cursor>;
+    static EVENT: Type<Abstract>;
+    static FIELD: Type<Field>;
+    static RENDERER: Type<Renderer>;
+    static TOOLBOX: Type<IToolbox>;
+    static THEME: Type<Theme>;
+    static TOOLBOX_ITEM: Type<ToolboxItem>;
+    static FLYOUTS_VERTICAL_TOOLBOX: Type<IFlyout>;
+    static FLYOUTS_HORIZONTAL_TOOLBOX: Type<IFlyout>;
+    static METRICS_MANAGER: Type<IMetricsManager>;
+    static BLOCK_DRAGGER: Type<IBlockDragger>;
+    /** @internal */
+    static SERIALIZER: Type<ISerializer>;
+}
+/**
+ * Registers a class based on a type and name.
+ *
+ * @param type The type of the plugin.
+ *     (e.g. Field, Renderer)
+ * @param name The plugin's name. (Ex. field_angle, geras)
+ * @param registryItem The class or object to register.
+ * @param opt_allowOverrides True to prevent an error when overriding an already
+ *     registered item.
+ * @throws {Error} if the type or name is empty, a name with the given type has
+ *     already been registered, or if the given class or object is not valid for
+ *     its type.
+ * @alias Blockly.registry.register
+ */
+export declare function register<T>(type: string | Type<T>, name: string, registryItem: (new (...p1: any[]) => T) | null | any, opt_allowOverrides?: boolean): void;
+/**
+ * Unregisters the registry item with the given type and name.
+ *
+ * @param type The type of the plugin.
+ *     (e.g. Field, Renderer)
+ * @param name The plugin's name. (Ex. field_angle, geras)
+ * @alias Blockly.registry.unregister
+ */
+export declare function unregister<T>(type: string | Type<T>, name: string): void;
+/**
+ * Returns whether or not the registry contains an item with the given type and
+ * name.
+ *
+ * @param type The type of the plugin.
+ *     (e.g. Field, Renderer)
+ * @param name The plugin's name. (Ex. field_angle, geras)
+ * @returns True if the registry has an item with the given type and name, false
+ *     otherwise.
+ * @alias Blockly.registry.hasItem
+ */
+export declare function hasItem<T>(type: string | Type<T>, name: string): boolean;
+/**
+ * Gets the class for the given name and type.
+ *
+ * @param type The type of the plugin.
+ *     (e.g. Field, Renderer)
+ * @param name The plugin's name. (Ex. field_angle, geras)
+ * @param opt_throwIfMissing Whether or not to throw an error if we are unable
+ *     to find the plugin.
+ * @returns The class with the given name and type or null if none exists.
+ * @alias Blockly.registry.getClass
+ */
+export declare function getClass<T>(type: string | Type<T>, name: string, opt_throwIfMissing?: boolean): (new (...p1: any[]) => T) | null;
+/**
+ * Gets the object for the given name and type.
+ *
+ * @param type The type of the plugin.
+ *     (e.g. Category)
+ * @param name The plugin's name. (Ex. logic_category)
+ * @param opt_throwIfMissing Whether or not to throw an error if we are unable
+ *     to find the object.
+ * @returns The object with the given name and type or null if none exists.
+ * @alias Blockly.registry.getObject
+ */
+export declare function getObject<T>(type: string | Type<T>, name: string, opt_throwIfMissing?: boolean): T | null;
+/**
+ * Returns a map of items registered with the given type.
+ *
+ * @param type The type of the plugin. (e.g. Category)
+ * @param opt_cased Whether or not to return a map with cased keys (rather than
+ *     caseless keys). False by default.
+ * @param opt_throwIfMissing Whether or not to throw an error if we are unable
+ *     to find the object. False by default.
+ * @returns A map of objects with the given type, or null if none exists.
+ * @alias Blockly.registry.getAllItems
+ */
+export declare function getAllItems<T>(type: string | Type<T>, opt_cased?: boolean, opt_throwIfMissing?: boolean): {
+    [key: string]: T | null | (new (...p1: any[]) => T);
+} | null;
+/**
+ * Gets the class from Blockly options for the given type.
+ * This is used for plugins that override a built in feature. (e.g. Toolbox)
+ *
+ * @param type The type of the plugin.
+ * @param options The option object to check for the given plugin.
+ * @param opt_throwIfMissing Whether or not to throw an error if we are unable
+ *     to find the plugin.
+ * @returns The class for the plugin.
+ * @alias Blockly.registry.getClassFromOptions
+ */
+export declare function getClassFromOptions<T>(type: Type<T>, options: Options, opt_throwIfMissing?: boolean): (new (...p1: any[]) => T) | null;
+//# sourceMappingURL=registry.d.ts.map

package/core/rendered_connection.d.ts

@@ -0,0 +1,212 @@
+/**
+ * @license
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Block } from './block.js';
+import type { BlockSvg } from './block_svg.js';
+import { Connection } from './connection.js';
+import { Coordinate } from './utils/coordinate.js';
+/**
+ * Class for a connection between blocks that may be rendered on screen.
+ *
+ * @alias Blockly.RenderedConnection
+ */
+export declare class RenderedConnection extends Connection {
+    sourceBlock_: BlockSvg;
+    private readonly db_;
+    private readonly dbOpposite_;
+    private readonly offsetInBlock_;
+    private trackedState_;
+    /** Connection this connection connects to.  Null if not connected. */
+    targetConnection: RenderedConnection | null;
+    /**
+     * @param source The block establishing this connection.
+     * @param type The type of the connection.
+     */
+    constructor(source: BlockSvg, type: number);
+    /**
+     * Dispose of this connection. Remove it from the database (if it is
+     * tracked) and call the super-function to deal with connected blocks.
+     *
+     * @internal
+     */
+    dispose(): void;
+    /**
+     * Get the source block for this connection.
+     *
+     * @returns The source block.
+     */
+    getSourceBlock(): BlockSvg;
+    /**
+     * Returns the block that this connection connects to.
+     *
+     * @returns The connected block or null if none is connected.
+     */
+    targetBlock(): BlockSvg | null;
+    /**
+     * Returns the distance between this connection and another connection in
+     * workspace units.
+     *
+     * @param otherConnection The other connection to measure the distance to.
+     * @returns The distance between connections, in workspace units.
+     */
+    distanceFrom(otherConnection: Connection): number;
+    /**
+     * Move the block(s) belonging to the connection to a point where they don't
+     * visually interfere with the specified connection.
+     *
+     * @param staticConnection The connection to move away from.
+     * @internal
+     */
+    bumpAwayFrom(staticConnection: RenderedConnection): void;
+    /**
+     * Change the connection's coordinates.
+     *
+     * @param x New absolute x coordinate, in workspace coordinates.
+     * @param y New absolute y coordinate, in workspace coordinates.
+     */
+    moveTo(x: number, y: number): void;
+    /**
+     * Change the connection's coordinates.
+     *
+     * @param dx Change to x coordinate, in workspace units.
+     * @param dy Change to y coordinate, in workspace units.
+     */
+    moveBy(dx: number, dy: number): void;
+    /**
+     * Move this connection to the location given by its offset within the block
+     * and the location of the block's top left corner.
+     *
+     * @param blockTL The location of the top left corner of the block, in
+     *     workspace coordinates.
+     */
+    moveToOffset(blockTL: Coordinate): void;
+    /**
+     * Set the offset of this connection relative to the top left of its block.
+     *
+     * @param x The new relative x, in workspace units.
+     * @param y The new relative y, in workspace units.
+     */
+    setOffsetInBlock(x: number, y: number): void;
+    /**
+     * Get the offset of this connection relative to the top left of its block.
+     *
+     * @returns The offset of the connection.
+     * @internal
+     */
+    getOffsetInBlock(): Coordinate;
+    /**
+     * Move the blocks on either side of this connection right next to each other.
+     *
+     * @internal
+     */
+    tighten(): void;
+    /**
+     * Find the closest compatible connection to this connection.
+     * All parameters are in workspace units.
+     *
+     * @param maxLimit The maximum radius to another connection.
+     * @param dxy Offset between this connection's location in the database and
+     *     the current location (as a result of dragging).
+     * @returns Contains two properties: 'connection' which is either another
+     *     connection or null, and 'radius' which is the distance.
+     */
+    closest(maxLimit: number, dxy: Coordinate): {
+        connection: RenderedConnection | null;
+        radius: number;
+    };
+    /** Add highlighting around this connection. */
+    highlight(): void;
+    /** Remove the highlighting around this connection. */
+    unhighlight(): void;
+    /**
+     * Set whether this connections is tracked in the database or not.
+     *
+     * @param doTracking If true, start tracking. If false, stop tracking.
+     * @internal
+     */
+    setTracking(doTracking: boolean): void;
+    /**
+     * Stop tracking this connection, as well as all down-stream connections on
+     * any block attached to this connection. This happens when a block is
+     * collapsed.
+     *
+     * Also closes down-stream icons/bubbles.
+     *
+     * @internal
+     */
+    stopTrackingAll(): void;
+    /**
+     * Start tracking this connection, as well as all down-stream connections on
+     * any block attached to this connection. This happens when a block is
+     * expanded.
+     *
+     * @returns List of blocks to render.
+     */
+    startTrackingAll(): Block[];
+    /**
+     * Behavior after a connection attempt fails.
+     * Bumps this connection away from the other connection. Called when an
+     * attempted connection fails.
+     *
+     * @param otherConnection Connection that this connection failed to connect
+     *     to.
+     * @internal
+     */
+    onFailedConnect(otherConnection: Connection): void;
+    /**
+     * Disconnect two blocks that are connected by this connection.
+     *
+     * @param parentBlock The superior block.
+     * @param childBlock The inferior block.
+     */
+    protected disconnectInternal_(parentBlock: Block, childBlock: Block): void;
+    /**
+     * Respawn the shadow block if there was one connected to the this connection.
+     * Render/rerender blocks as needed.
+     */
+    protected respawnShadow_(): void;
+    /**
+     * Find all nearby compatible connections to this connection.
+     * Type checking does not apply, since this function is used for bumping.
+     *
+     * @param maxLimit The maximum radius to another connection, in workspace
+     *     units.
+     * @returns List of connections.
+     * @internal
+     */
+    neighbours(maxLimit: number): Connection[];
+    /**
+     * Connect two connections together.  This is the connection on the superior
+     * block.  Rerender blocks as needed.
+     *
+     * @param childConnection Connection on inferior block.
+     */
+    protected connect_(childConnection: Connection): void;
+    /**
+     * Function to be called when this connection's compatible types have changed.
+     */
+    protected onCheckChanged_(): void;
+}
+export declare namespace RenderedConnection {
+    /**
+     * Enum for different kinds of tracked states.
+     *
+     * WILL_TRACK means that this connection will add itself to
+     * the db on the next moveTo call it receives.
+     *
+     * UNTRACKED means that this connection will not add
+     * itself to the database until setTracking(true) is explicitly called.
+     *
+     * TRACKED means that this connection is currently being tracked.
+     */
+    enum TrackedState {
+        WILL_TRACK = -1,
+        UNTRACKED = 0,
+        TRACKED = 1
+    }
+}
+export declare type TrackedState = RenderedConnection.TrackedState;
+export declare const TrackedState: typeof RenderedConnection.TrackedState;
+//# sourceMappingURL=rendered_connection.d.ts.map

package/core/renderers/common/block_rendering.d.ts

@@ -0,0 +1,121 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Theme } from '../../theme.js';
+import { Measurable } from '../measurables/base.js';
+import { BottomRow } from '../measurables/bottom_row.js';
+import { Connection } from '../measurables/connection.js';
+import { ExternalValueInput } from '../measurables/external_value_input.js';
+import { Field } from '../measurables/field.js';
+import { Hat } from '../measurables/hat.js';
+import { Icon } from '../measurables/icon.js';
+import { InRowSpacer } from '../measurables/in_row_spacer.js';
+import { InlineInput } from '../measurables/inline_input.js';
+import { InputConnection } from '../measurables/input_connection.js';
+import { InputRow } from '../measurables/input_row.js';
+import { JaggedEdge } from '../measurables/jagged_edge.js';
+import { NextConnection } from '../measurables/next_connection.js';
+import { OutputConnection } from '../measurables/output_connection.js';
+import { PreviousConnection } from '../measurables/previous_connection.js';
+import { RoundCorner } from '../measurables/round_corner.js';
+import { Row } from '../measurables/row.js';
+import { SpacerRow } from '../measurables/spacer_row.js';
+import { SquareCorner } from '../measurables/square_corner.js';
+import { StatementInput } from '../measurables/statement_input.js';
+import { TopRow } from '../measurables/top_row.js';
+import { Types } from '../measurables/types.js';
+import { ConstantProvider } from './constants.js';
+import { Debug } from './debugger.js';
+import { Drawer } from './drawer.js';
+import type { IPathObject } from './i_path_object.js';
+import { RenderInfo } from './info.js';
+import { MarkerSvg } from './marker_svg.js';
+import { PathObject } from './path_object.js';
+import { Renderer } from './renderer.js';
+/**
+ * Returns whether the debugger is turned on.
+ *
+ * @returns Whether the debugger is turned on.
+ * @alias Blockly.blockRendering.isDebuggerEnabled
+ * @deprecated
+ * @internal
+ */
+export declare function isDebuggerEnabled(): boolean;
+/**
+ * Registers a new renderer.
+ *
+ * @param name The name of the renderer.
+ * @param rendererClass The new renderer class to register.
+ * @throws {Error} if a renderer with the same name has already been registered.
+ */
+export declare function register(name: string, rendererClass: Function): void;
+/**
+ * Unregisters the renderer registered with the given name.
+ *
+ * @param name The name of the renderer.
+ * @alias Blockly.blockRendering.unregister
+ */
+export declare function unregister(name: string): void;
+/**
+ * Turn on the blocks debugger.
+ *
+ * @alias Blockly.blockRendering.startDebugger
+ * @deprecated
+ * @internal
+ */
+export declare function startDebugger(): void;
+/**
+ * Turn off the blocks debugger.
+ *
+ * @alias Blockly.blockRendering.stopDebugger
+ * @deprecated
+ * @internal
+ */
+export declare function stopDebugger(): void;
+/**
+ * Initialize anything needed for rendering (constants, etc).
+ *
+ * @param name Name of the renderer to initialize.
+ * @param theme The workspace theme object.
+ * @param opt_rendererOverrides Rendering constant overrides.
+ * @returns The new instance of a renderer.
+ *     Already initialized.
+ * @alias Blockly.blockRendering.init
+ * @internal
+ */
+export declare function init(name: string, theme: Theme, opt_rendererOverrides?: {
+    [rendererConstant: string]: any;
+}): Renderer;
+export { BottomRow };
+export { Connection };
+export { ConstantProvider };
+export { Debug };
+export { Drawer };
+export { ExternalValueInput };
+export { Field };
+export { Hat };
+export { Icon };
+export { InRowSpacer };
+export { InlineInput };
+export { InputConnection };
+export { InputRow };
+export { IPathObject };
+export { JaggedEdge };
+export { MarkerSvg };
+export { Measurable };
+export { NextConnection };
+export { OutputConnection };
+export { PathObject };
+export { PreviousConnection };
+export { Renderer };
+export { RenderInfo };
+export { RoundCorner };
+export { Row };
+export { SpacerRow };
+export { SquareCorner };
+export { StatementInput };
+export { TopRow };
+export { Types };
+//# sourceMappingURL=block_rendering.d.ts.map