@cp949/phyx-blockly 12.5.1-p1

package/core/positionable_helpers.d.ts

@@ -0,0 +1,89 @@
+/**
+ * @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.
+ *
+ * @internal
+ */
+export declare enum verticalPosition {
+    TOP = 0,
+    BOTTOM = 1
+}
+/**
+ * Enum for horizontal positioning.
+ *
+ * @internal
+ */
+export declare enum horizontalPosition {
+    LEFT = 0,
+    RIGHT = 1
+}
+/**
+ * An object defining a horizontal and vertical positioning.
+ *
+ * @internal
+ */
+export interface Position {
+    horizontal: horizontalPosition;
+    vertical: verticalPosition;
+}
+/**
+ * Enum for bump rules to use for dealing with collisions.
+ *
+ * @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.
+ * @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.
+ * @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.
+ * @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,108 @@
+/**
+ * @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 { Field } from './field.js';
+import { ProcedureTuple } from './interfaces/i_legacy_procedure_blocks.js';
+import { IParameterModel } from './interfaces/i_parameter_model.js';
+import { IProcedureBlock, isProcedureBlock } from './interfaces/i_procedure_block.js';
+import { IProcedureMap } from './interfaces/i_procedure_map.js';
+import { IProcedureModel } from './interfaces/i_procedure_model.js';
+import { ObservableProcedureMap } from './observable_procedure_map.js';
+import type { FlyoutItemInfo } from './utils/toolbox.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.
+ */
+export declare const CATEGORY_NAME = "PROCEDURE";
+/**
+ * The default argument for a procedures_mutatorarg block.
+ */
+export declare const DEFAULT_ARG = "x";
+/**
+ * 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.
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+export declare function rename(this: Field, name: string): string;
+/**
+ * Internal wrapper that returns the contents of the procedure category.
+ *
+ * @internal
+ * @param workspace The workspace to populate procedure blocks for.
+ */
+export declare function internalFlyoutCategory(workspace: WorkspaceSvg): FlyoutItemInfo[];
+export declare function flyoutCategory(workspace: WorkspaceSvg, useXml: true): Element[];
+export declare function flyoutCategory(workspace: WorkspaceSvg, useXml: false): FlyoutItemInfo[];
+/**
+ * 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.
+ * @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.
+ */
+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.
+ */
+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.
+ */
+export declare function getDefinition(name: string, workspace: Workspace): Block | null;
+export { IParameterModel, IProcedureBlock, IProcedureMap, IProcedureModel, isProcedureBlock, ObservableProcedureMap, ProcedureTuple, };
+//# sourceMappingURL=procedures.d.ts.map

package/core/registry.d.ts

@@ -0,0 +1,158 @@
+/**
+ * @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 { Input } from './inputs/input.js';
+import type { IConnectionChecker } from './interfaces/i_connection_checker.js';
+import type { IConnectionPreviewer } from './interfaces/i_connection_previewer.js';
+import type { ICopyable } from './interfaces/i_copyable.js';
+import type { IDragger } from './interfaces/i_dragger.js';
+import type { IFlyout } from './interfaces/i_flyout.js';
+import type { IFlyoutInflater } from './interfaces/i_flyout_inflater.js';
+import type { IIcon } from './interfaces/i_icon.js';
+import type { IMetricsManager } from './interfaces/i_metrics_manager.js';
+import type { IPaster } from './interfaces/i_paster.js';
+import type { ISerializer } from './interfaces/i_serializer.js';
+import type { IToolbox } from './interfaces/i_toolbox.js';
+import type { IVariableMap } from './interfaces/i_variable_map.js';
+import type { IVariableModel, IVariableModelStatic, IVariableState } from './interfaces/i_variable_model.js';
+import type { LineCursor } from './keyboard_nav/line_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.
+ */
+export declare const DEFAULT = "default";
+/**
+ * A name with the type of the element stored in the generic.
+ */
+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 CONNECTION_PREVIEWER: Type<IConnectionPreviewer>;
+    static CURSOR: Type<LineCursor>;
+    static EVENT: Type<Abstract>;
+    static FIELD: Type<Field<any>>;
+    static INPUT: Type<Input>;
+    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 FLYOUT_INFLATER: Type<IFlyoutInflater>;
+    static METRICS_MANAGER: Type<IMetricsManager>;
+    /**
+     * Type for an IDragger. Formerly behavior was mostly covered by
+     * BlockDraggeers, which is why the name is inaccurate.
+     */
+    static BLOCK_DRAGGER: Type<IDragger>;
+    /** @internal */
+    static SERIALIZER: Type<ISerializer>;
+    /** @internal */
+    static ICON: Type<IIcon>;
+    /** @internal */
+    static PASTER: Type<IPaster<ICopyable.ICopyData, ICopyable<ICopyable.ICopyData>>>;
+    static VARIABLE_MODEL: Type<IVariableModelStatic<IVariableState> & IVariableModel<IVariableState>>;
+    static VARIABLE_MAP: Type<IVariableMap<IVariableModel<IVariableState>>>;
+}
+/**
+ * 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.
+ */
+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)
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+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/render_management.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BlockSvg } from './block_svg.js';
+import type { WorkspaceSvg } from './workspace_svg.js';
+/**
+ * Registers that the given block and all of its parents need to be rerendered,
+ * and registers a callback to do so after a delay, to allowf or batching.
+ *
+ * @param block The block to rerender.
+ * @returns A promise that resolves after the currently queued renders have been
+ *     completed. Used for triggering other behavior that relies on updated
+ *     size/position location for the block.
+ * @internal
+ */
+export declare function queueRender(block: BlockSvg): Promise<void>;
+/**
+ * @returns A promise that resolves after the currently queued renders have
+ *     been completed.
+ */
+export declare function finishQueuedRenders(): Promise<void>;
+/**
+ * Triggers an immediate render of all queued renders. Should only be used in
+ * cases where queueing renders breaks functionality + backwards compatibility
+ * (such as rendering icons).
+ *
+ * @param workspace If provided, only rerender blocks in this workspace.
+ *
+ * @internal
+ */
+export declare function triggerQueuedRenders(workspace?: WorkspaceSvg): void;
+//# sourceMappingURL=render_management.d.ts.map

package/core/rendered_connection.d.ts

@@ -0,0 +1,262 @@
+/**
+ * @license
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Components for creating connections between blocks.
+ *
+ * @class
+ */
+import type { BlockSvg } from './block_svg.js';
+import { Connection } from './connection.js';
+import { IContextMenu } from './interfaces/i_contextmenu.js';
+import type { IFocusableNode } from './interfaces/i_focusable_node.js';
+import type { IFocusableTree } from './interfaces/i_focusable_tree.js';
+import { Coordinate } from './utils/coordinate.js';
+/**
+ * Class for a connection between blocks that may be rendered on screen.
+ */
+export declare class RenderedConnection extends Connection implements IContextMenu, IFocusableNode {
+    sourceBlock_: BlockSvg;
+    private readonly db;
+    private readonly dbOpposite;
+    private readonly offsetInBlock;
+    private trackedState;
+    private highlighted;
+    /** 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 superiorConnection The connection to move away from. The provided
+     *     connection should be the superior connection and should not be
+     *     connected to this connection.
+     * @param initiatedByThis Whether or not the block group that was manipulated
+     *     recently causing bump checks is associated with the inferior
+     *     connection. Defaults to false.
+     * @internal
+     */
+    bumpAwayFrom(superiorConnection: RenderedConnection, initiatedByThis?: boolean): void;
+    /**
+     * Change the connection's coordinates.
+     *
+     * @param x New absolute x coordinate, in workspace coordinates.
+     * @param y New absolute y coordinate, in workspace coordinates.
+     * @returns True if the position of the connection in the connection db
+     *     was updated.
+     */
+    moveTo(x: number, y: number): boolean;
+    /**
+     * Change the connection's coordinates.
+     *
+     * @param dx Change to x coordinate, in workspace units.
+     * @param dy Change to y coordinate, in workspace units.
+     * @returns True if the position of the connection in the connection db
+     *     was updated.
+     */
+    moveBy(dx: number, dy: number): boolean;
+    /**
+     * 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.
+     * @returns True if the position of the connection in the connection db
+     *     was updated.
+     */
+    moveToOffset(blockTL: Coordinate): boolean;
+    /**
+     * 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.
+     */
+    getOffsetInBlock(): Coordinate;
+    /**
+     * Moves the blocks on either side of this connection right next to
+     * each other, based on their local offsets, not global positions.
+     *
+     * @internal
+     */
+    tightenEfficiently(): 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;
+    /** Returns true if this connection is highlighted, false otherwise. */
+    isHighlighted(): boolean;
+    /**
+     * 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(): BlockSvg[];
+    /**
+     * Behaviour after a connection attempt fails.
+     * Bumps this connection away from the other connection. Called when an
+     * attempted connection fails.
+     *
+     * @param superiorConnection Connection that this connection failed to connect
+     *     to. The provided connection should be the superior connection.
+     * @internal
+     */
+    onFailedConnect(superiorConnection: Connection): void;
+    /**
+     * Disconnect two blocks that are connected by this connection.
+     *
+     * @param setParent Whether to set the parent of the disconnected block or
+     *     not, defaults to true.
+     *     If you do not set the parent, ensure that a subsequent action does,
+     *     otherwise the view and model will be out of sync.
+     */
+    disconnectInternal(setParent?: boolean): 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): RenderedConnection[];
+    /**
+     * 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;
+    /**
+     * Change a connection's compatibility.
+     * Rerender blocks as needed.
+     *
+     * @param check Compatible value type or list of value types. Null if all
+     *     types are compatible.
+     * @returns The connection being modified (to allow chaining).
+     */
+    setCheck(check: string | string[] | null): RenderedConnection;
+    /**
+     * Handles showing the context menu when it is opened on a connection.
+     * Note that typically the context menu can't be opened with the mouse
+     * on a connection, because you can't select a connection. But keyboard
+     * users may open the context menu with a keyboard shortcut.
+     *
+     * @param e Event that triggered the opening of the context menu.
+     */
+    showContextMenu(e: Event): void;
+    /** See IFocusableNode.getFocusableElement. */
+    getFocusableElement(): HTMLElement | SVGElement;
+    /** See IFocusableNode.getFocusableTree. */
+    getFocusableTree(): IFocusableTree;
+    /** See IFocusableNode.onNodeFocus. */
+    onNodeFocus(): void;
+    /** See IFocusableNode.onNodeBlur. */
+    onNodeBlur(): void;
+    /** See IFocusableNode.canBeFocused. */
+    canBeFocused(): boolean;
+    private findHighlightSvg;
+}
+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 type TrackedState = RenderedConnection.TrackedState;
+export declare const TrackedState: typeof RenderedConnection.TrackedState;
+//# sourceMappingURL=rendered_connection.d.ts.map