smoosic 1.0.24 → 1.0.26

package/types/src/render/sui/formatter.d.ts

@@ -1,151 +1,151 @@
-import { SmoLyric } from '../../smo/data/noteModifiers';
-import { SmoNote } from '../../smo/data/note';
-import { SmoScore } from '../../smo/data/score';
-import { ScaledPageLayout } from '../../smo/data/scoreModifiers';
-import { SmoMeasure, ISmoBeamGroup } from '../../smo/data/measure';
-import { TimeSignature, SmoTempoText } from '../../smo/data//measureModifiers';
-import { SvgPageMap } from './svgPageMap';
-import { TextFormatter } from '../../common/textformatter';
-/**
- * @category SuiRender
- */
-export interface SuiTickContext {
-    widths: number[];
-    tickCounts: number[];
-}
-/**
- * Estimated x, y position of the measure
- * @category SuiRender
- */
-export interface MeasureEstimate {
-    measures: SmoMeasure[];
-    x: number;
-    y: number;
-}
-/**
- * @category SuiRender
- */
-export interface LineRender {
-    systems: Record<number, SmoMeasure[]>;
-}
-/**
- * Keep track of start/end measures on a page.  If the page
- * content doesn't change, and the measures don't change, we don't
- * need to re-render the content
- * @category SuiRender
- */
-export interface RenderedPage {
-    startMeasure: number;
-    endMeasure: number;
-}
-/**
- * Utilities for estimating measure/system/page width and height
- * @category SuiRender
- */
-export declare class SuiLayoutFormatter {
-    score: SmoScore;
-    systems: Record<number, LineRender>;
-    columnMeasureMap: Record<number, SmoMeasure[]>;
-    currentPage: number;
-    svg: SvgPageMap;
-    renderedPages: Record<number, RenderedPage | null>;
-    lines: number[];
-    constructor(score: SmoScore, svg: SvgPageMap, renderedPages: Record<number, RenderedPage | null>);
-    /**
-     * Once we know which line a measure is going on, make a map for it for easy
-     * looking during rendering
-     * @param measures
-     * @param lineIndex
-     * @param systemIndex
-     */
-    updateSystemMap(measures: SmoMeasure[], lineIndex: number, systemIndex: number): void;
-    trimPages(startPageCount: number): boolean;
-    /**
-     * see if page breaks this boundary.  If it does, bump the current page and move the system down
-     * to the new page
-     * @param scoreLayout
-     * @param currentLine
-     * @param bottomMeasure
-     * @returns
-     */
-    checkPageBreak(scoreLayout: ScaledPageLayout, currentLine: SmoMeasure[], bottomMeasure: SmoMeasure): ScaledPageLayout;
-    measureToLeft(measure: SmoMeasure): SmoMeasure;
-    measureAbove(measure: SmoMeasure): SmoMeasure;
-    /**
-     * Estimate the dimensions of a column when it's rendered.
-     * @param scoreLayout
-     * @param measureIx
-     * @param systemIndex
-     * @param lineIndex
-     * @param x
-     * @param y
-     * @returns { MeasureEstimate } - the measures in the column and the x, y location
-     */
-    estimateColumn(scoreLayout: ScaledPageLayout, measureIx: number, systemIndex: number, lineIndex: number, x: number, y: number): MeasureEstimate;
-    /**
-     * return true if this is the last measure, taking into account multimeasure rest
-     * @param measureIx
-     * @returns
-     */
-    isLastVisibleMeasure(measureIx: number): boolean;
-    /**
-     * Calculate the geometry for the entire score, based on estimated measure width and height.
-     * @returns
-     */
-    layout(): void;
-    static estimateMusicWidth(smoMeasure: SmoMeasure, tickContexts: Record<number, SuiTickContext>): number;
-    static estimateStartSymbolWidth(smoMeasure: SmoMeasure): number;
-    static estimateEndSymbolWidth(smoMeasure: SmoMeasure): number;
-    estimateMeasureWidth(measure: SmoMeasure, scoreLayout: ScaledPageLayout, tickContexts: Record<number, SuiTickContext>): void;
-    static _beamGroupForNote(measure: SmoMeasure, note: SmoNote): ISmoBeamGroup | null;
-    /**
-     * Format a full system:
-     * 1.  Lop the last measure off the end and move it to the first measure of the
-     * next system, if it doesn't fit
-     * 2. Justify the measures vertically
-     * 3. Justify the columns horizontally
-     * 4. Hide lines if they don't contain music
-     * @param scoreLayout
-     * @param measureEstimate
-     * @param currentLine
-     * @param columnCount
-     * @param lastSystem
-     */
-    justifyY(scoreLayout: ScaledPageLayout, rowCount: number, currentLine: SmoMeasure[], lastSystem: boolean): void;
-    /**
-     * highest value is actually the one lowest on the page
-     * @param measure
-     * @param note
-     * @returns
-     */
-    static _highestLowestHead(measure: SmoMeasure, note: SmoNote): {
-        hi: number;
-        lo: number;
-    };
-    static textFont(lyric: SmoLyric): TextFormatter;
-    /**
-     * Calculate the dimensions of symbols based on where in a system we are, like whether we need to show
-     * the key signature, clef etc.
-     * @param systemIndex
-     * @param measure
-     * @param clefLast
-     * @param keySigLast
-     * @param timeSigLast
-     * @param tempoLast
-     * @param score
-     */
-    calculateBeginningSymbols(systemIndex: number, measure: SmoMeasure, clefLast: string, keySigLast: string, timeSigLast: TimeSignature, tempoLast: SmoTempoText): void;
-    /**
-     * The baseline is the top line of the staff.  aboveBaseline is a negative number
-     * that indicates how high above the baseline the measure goes.  belowBaseline
-     * is a positive number that indicates how far below the baseline the measure goes.
-     * the height of the measure is below-above.  Vex always renders a staff such that
-     * the y coordinate passed in for the stave is on the baseline.
-     *
-     * Note to past self: this was a really useful comment.  Thank you.
-     * **/
-    estimateMeasureHeight(measure: SmoMeasure): {
-        aboveBaseline: number;
-        belowBaseline: number;
-    };
-}
+import { SmoLyric } from '../../smo/data/noteModifiers';
+import { SmoNote } from '../../smo/data/note';
+import { SmoScore } from '../../smo/data/score';
+import { ScaledPageLayout } from '../../smo/data/scoreModifiers';
+import { SmoMeasure, ISmoBeamGroup } from '../../smo/data/measure';
+import { TimeSignature, SmoTempoText } from '../../smo/data//measureModifiers';
+import { SvgPageMap } from './svgPageMap';
+import { TextFormatter } from '../../common/textformatter';
+/**
+ * @category SuiRender
+ */
+export interface SuiTickContext {
+    widths: number[];
+    tickCounts: number[];
+}
+/**
+ * Estimated x, y position of the measure
+ * @category SuiRender
+ */
+export interface MeasureEstimate {
+    measures: SmoMeasure[];
+    x: number;
+    y: number;
+}
+/**
+ * @category SuiRender
+ */
+export interface LineRender {
+    systems: Record<number, SmoMeasure[]>;
+}
+/**
+ * Keep track of start/end measures on a page.  If the page
+ * content doesn't change, and the measures don't change, we don't
+ * need to re-render the content
+ * @category SuiRender
+ */
+export interface RenderedPage {
+    startMeasure: number;
+    endMeasure: number;
+}
+/**
+ * Utilities for estimating measure/system/page width and height
+ * @category SuiRender
+ */
+export declare class SuiLayoutFormatter {
+    score: SmoScore;
+    systems: Record<number, LineRender>;
+    columnMeasureMap: Record<number, SmoMeasure[]>;
+    currentPage: number;
+    svg: SvgPageMap;
+    renderedPages: Record<number, RenderedPage | null>;
+    lines: number[];
+    constructor(score: SmoScore, svg: SvgPageMap, renderedPages: Record<number, RenderedPage | null>);
+    /**
+     * Once we know which line a measure is going on, make a map for it for easy
+     * looking during rendering
+     * @param measures
+     * @param lineIndex
+     * @param systemIndex
+     */
+    updateSystemMap(measures: SmoMeasure[], lineIndex: number, systemIndex: number): void;
+    trimPages(startPageCount: number): boolean;
+    /**
+     * see if page breaks this boundary.  If it does, bump the current page and move the system down
+     * to the new page
+     * @param scoreLayout
+     * @param currentLine
+     * @param bottomMeasure
+     * @returns
+     */
+    checkPageBreak(scoreLayout: ScaledPageLayout, currentLine: SmoMeasure[], bottomMeasure: SmoMeasure): ScaledPageLayout;
+    measureToLeft(measure: SmoMeasure): SmoMeasure;
+    measureAbove(measure: SmoMeasure): SmoMeasure;
+    /**
+     * Estimate the dimensions of a column when it's rendered.
+     * @param scoreLayout
+     * @param measureIx
+     * @param systemIndex
+     * @param lineIndex
+     * @param x
+     * @param y
+     * @returns { MeasureEstimate } - the measures in the column and the x, y location
+     */
+    estimateColumn(scoreLayout: ScaledPageLayout, measureIx: number, systemIndex: number, lineIndex: number, x: number, y: number): MeasureEstimate;
+    /**
+     * return true if this is the last measure, taking into account multimeasure rest
+     * @param measureIx
+     * @returns
+     */
+    isLastVisibleMeasure(measureIx: number): boolean;
+    /**
+     * Calculate the geometry for the entire score, based on estimated measure width and height.
+     * @returns
+     */
+    layout(): void;
+    static estimateMusicWidth(smoMeasure: SmoMeasure, tickContexts: Record<number, SuiTickContext>): number;
+    static estimateStartSymbolWidth(smoMeasure: SmoMeasure): number;
+    static estimateEndSymbolWidth(smoMeasure: SmoMeasure): number;
+    estimateMeasureWidth(measure: SmoMeasure, scoreLayout: ScaledPageLayout, tickContexts: Record<number, SuiTickContext>): void;
+    static _beamGroupForNote(measure: SmoMeasure, note: SmoNote): ISmoBeamGroup | null;
+    /**
+     * Format a full system:
+     * 1.  Lop the last measure off the end and move it to the first measure of the
+     * next system, if it doesn't fit
+     * 2. Justify the measures vertically
+     * 3. Justify the columns horizontally
+     * 4. Hide lines if they don't contain music
+     * @param scoreLayout
+     * @param measureEstimate
+     * @param currentLine
+     * @param columnCount
+     * @param lastSystem
+     */
+    justifyY(scoreLayout: ScaledPageLayout, rowCount: number, currentLine: SmoMeasure[], lastSystem: boolean): void;
+    /**
+     * highest value is actually the one lowest on the page
+     * @param measure
+     * @param note
+     * @returns
+     */
+    static _highestLowestHead(measure: SmoMeasure, note: SmoNote): {
+        hi: number;
+        lo: number;
+    };
+    static textFont(lyric: SmoLyric): TextFormatter;
+    /**
+     * Calculate the dimensions of symbols based on where in a system we are, like whether we need to show
+     * the key signature, clef etc.
+     * @param systemIndex
+     * @param measure
+     * @param clefLast
+     * @param keySigLast
+     * @param timeSigLast
+     * @param tempoLast
+     * @param score
+     */
+    calculateBeginningSymbols(systemIndex: number, measure: SmoMeasure, clefLast: string, keySigLast: string, timeSigLast: TimeSignature, tempoLast: SmoTempoText): void;
+    /**
+     * The baseline is the top line of the staff.  aboveBaseline is a negative number
+     * that indicates how high above the baseline the measure goes.  belowBaseline
+     * is a positive number that indicates how far below the baseline the measure goes.
+     * the height of the measure is below-above.  Vex always renders a staff such that
+     * the y coordinate passed in for the stave is on the baseline.
+     *
+     * Note to past self: this was a really useful comment.  Thank you.
+     * **/
+    estimateMeasureHeight(measure: SmoMeasure): {
+        aboveBaseline: number;
+        belowBaseline: number;
+    };
+}

package/types/src/render/sui/layoutDebug.d.ts

@@ -1,43 +1,43 @@
-import { SvgBox, SvgPoint } from '../../smo/data/common';
-import { SmoMeasure } from '../../smo/data/measure';
-import { SmoSelector } from '../../smo/xform/selections';
-/**
- * SuiRender
- * @internal
- */
-export interface CodeRegion {
-    time: number;
-    percent: number;
-}
-/**
- * @category SuiRender
- */
-export declare class layoutDebug {
-    static get values(): Record<string, number>;
-    static get classes(): Record<number, string>;
-    static get codeRegions(): Record<string, number>;
-    static testThrow: boolean;
-    static get codeRegionStrings(): string[];
-    static mask: number;
-    static _textDebug: number[];
-    static timestampHash: Record<number, number>;
-    static _dialogEvents: string[];
-    static clearTimestamps(): void;
-    static setTimestamp(region: number, millis: number): void;
-    static printTimeReport(): void;
-    static flagSet(value: number): number;
-    static clearAll(): void;
-    static setAll(): void;
-    static setRenderFlags(): void;
-    static clearDebugBoxes(value: number): void;
-    static debugBox(svg: SVGSVGElement, box: SvgBox | null, flag: number): void;
-    static setFlag(value: number): void;
-    static setFlagDivs(): void;
-    static updateScrollDebug(point: SvgPoint): void;
-    static updateMouseDebug(client: SvgPoint, logical: SvgPoint, offset: SvgPoint): void;
-    static updateDragDebug(client: SvgPoint, logical: SvgPoint, state: string): void;
-    static updatePlayDebug(selector: SmoSelector, logical: SvgBox): void;
-    static addTextDebug(value: number): void;
-    static addDialogDebug(value: string): void;
-    static measureHistory(measure: SmoMeasure, oldVal: string, newVal: any, description: string): void;
-}
+import { SvgBox, SvgPoint } from '../../smo/data/common';
+import { SmoMeasure } from '../../smo/data/measure';
+import { SmoSelector } from '../../smo/xform/selections';
+/**
+ * SuiRender
+ * @internal
+ */
+export interface CodeRegion {
+    time: number;
+    percent: number;
+}
+/**
+ * @category SuiRender
+ */
+export declare class layoutDebug {
+    static get values(): Record<string, number>;
+    static get classes(): Record<number, string>;
+    static get codeRegions(): Record<string, number>;
+    static testThrow: boolean;
+    static get codeRegionStrings(): string[];
+    static mask: number;
+    static _textDebug: number[];
+    static timestampHash: Record<number, number>;
+    static _dialogEvents: string[];
+    static clearTimestamps(): void;
+    static setTimestamp(region: number, millis: number): void;
+    static printTimeReport(): void;
+    static flagSet(value: number): number;
+    static clearAll(): void;
+    static setAll(): void;
+    static setRenderFlags(): void;
+    static clearDebugBoxes(value: number): void;
+    static debugBox(svg: SVGSVGElement, box: SvgBox | null, flag: number): void;
+    static setFlag(value: number): void;
+    static setFlagDivs(): void;
+    static updateScrollDebug(point: SvgPoint): void;
+    static updateMouseDebug(client: SvgPoint, logical: SvgPoint, offset: SvgPoint): void;
+    static updateDragDebug(client: SvgPoint, logical: SvgPoint, state: string): void;
+    static updatePlayDebug(selector: SmoSelector, logical: SvgBox): void;
+    static addTextDebug(value: number): void;
+    static addDialogDebug(value: string): void;
+    static measureHistory(measure: SmoMeasure, oldVal: string, newVal: any, description: string): void;
+}

package/types/src/render/sui/mapper.d.ts

@@ -1,116 +1,116 @@
-import { SmoSelector, SmoSelection, ModifierTab } from '../../smo/xform/selections';
-import { OutlineInfo } from './svgHelpers';
-import { SuiScroller } from './scroller';
-import { SmoSystemStaff } from '../../smo/data/systemStaff';
-import { SmoMeasure } from '../../smo/data/measure';
-import { SmoNoteModifierBase } from '../../smo/data/noteModifiers';
-import { SvgBox } from '../../smo/data/common';
-import { SmoScore } from '../../smo/data/score';
-import { SvgPageMap } from './svgPageMap';
-/**
- * DI information about renderer, so we can notify renderer and it can contain
- * a tracker object
- * @param pageMap {@link SvgPageMap}: SvgPageMap - container of SVG elements and vex renderers
- * @param score {@link SmoScore}
- * @param dirty lets the caller know the display needs update
- * @param passState state machine in rendering part/all of the score
- * @param renderPromise awaits on render all
- * @param addToReplaceQueue adds a measure to the quick update queue
- * @param renderElement a little redundant with svg
- * @category SuiRender
- */
-export interface SuiRendererBase {
-    pageMap: SvgPageMap;
-    score: SmoScore | null;
-    dirty: boolean;
-    passState: number;
-    renderPromise(): Promise<any>;
-    addToReplaceQueue(mm: SmoSelection[]): void;
-    renderElement: Element;
-}
-/**
- * used to perform highlights in the backgroundd
- * @category SuiRender
- */
-export interface HighlightQueue {
-    selectionCount: number;
-    deferred: boolean;
-}
-/**
- * Map the notes in the svg so they can respond to events and interact
- * with the mouse/keyboard
- * @category SuiRender
- */
-export declare abstract class SuiMapper {
-    renderer: SuiRendererBase;
-    scroller: SuiScroller;
-    measureNoteMap: Record<string | number, SmoSelection>;
-    modifierSelections: ModifierTab[];
-    selections: SmoSelection[];
-    localModifiers: ModifierTab[];
-    modifierIndex: number;
-    modifierSuggestion: ModifierTab | null;
-    pitchIndex: number;
-    deferHighlightMode: boolean;
-    suggestion: SmoSelection | null;
-    highlightQueue: HighlightQueue;
-    mouseHintBox: OutlineInfo | null;
-    selectionRects: Record<number, OutlineInfo[]>;
-    outlines: Record<string, OutlineInfo>;
-    mapping: boolean;
-    constructor(renderer: SuiRendererBase, scroller: SuiScroller);
-    abstract highlightSelection(): void;
-    abstract _growSelectionRight(hold?: boolean): number;
-    abstract _setModifierAsSuggestion(sel: ModifierTab): void;
-    abstract _setArtifactAsSuggestion(sel: SmoSelection): void;
-    abstract getIdleTime(): number;
-    updateHighlight(): void;
-    deferHighlight(): void;
-    _createLocalModifiersList(): void;
-    /**
-     * When a modifier is selected graphically, update the selection list
-     * and create a local modifier list
-     * @param modifierTabs
-     */
-    createLocalModifiersFromModifierTabs(modifierTabs: ModifierTab[]): void;
-    removeModifierSelectionBox(): void;
-    clearModifierSelections(): void;
-    loadScore(): void;
-    clearMeasureMap(measure: SmoMeasure): void;
-    _copySelectionsByMeasure(staffIndex: number, measureIndex: number): {
-        ticks: number;
-        selectors: SmoSelector[];
-    };
-    deleteMeasure(selection: SmoSelection): void;
-    _updateNoteModifier(selection: SmoSelection, modMap: Record<string, boolean>, modifier: SmoNoteModifierBase, ix: number): number;
-    _updateModifiers(): void;
-    _getClosestTick(selector: SmoSelector): SmoSelection;
-    _setModifierBoxes(measure: SmoMeasure): void;
-    /**
-     * returns true of the selections are adjacent
-     * @param s1 a selections
-     * @param s2 another election
-     * @returns
-     */
-    isAdjacentSelection(s1: SmoSelection, s2: SmoSelection): boolean;
-    areSelectionsAdjacent(): boolean;
-    /**
-     * This is the logic that stores the screen location of music after it's rendered
-     */
-    mapMeasure(staff: SmoSystemStaff, measure: SmoMeasure, printing: boolean): void;
-    _getTicksFromSelections(): number;
-    _copySelections(): SmoSelector[];
-    getExtremeSelection(sign: number): SmoSelection;
-    _selectClosest(selector: SmoSelector): void;
-    updateMap(): void;
-    createMousePositionBox(logicalBox: SvgBox): void;
-    eraseMousePositionBox(): void;
-    /**
-     * Find any musical elements at the supplied screen coordinates and set them as the selection
-     * @param bb
-     * @returns
-     */
-    intersectingArtifact(bb: SvgBox): void;
-    _getRectangleChain(selection: SmoSelection): number[];
-    _updateMeasureNoteMap(artifact: SmoSelection, printing: boolean): void;
-}
+import { SmoSelector, SmoSelection, ModifierTab } from '../../smo/xform/selections';
+import { OutlineInfo } from './svgHelpers';
+import { SuiScroller } from './scroller';
+import { SmoSystemStaff } from '../../smo/data/systemStaff';
+import { SmoMeasure } from '../../smo/data/measure';
+import { SmoNoteModifierBase } from '../../smo/data/noteModifiers';
+import { SvgBox } from '../../smo/data/common';
+import { SmoScore } from '../../smo/data/score';
+import { SvgPageMap } from './svgPageMap';
+/**
+ * DI information about renderer, so we can notify renderer and it can contain
+ * a tracker object
+ * @param pageMap {@link SvgPageMap}: SvgPageMap - container of SVG elements and vex renderers
+ * @param score {@link SmoScore}
+ * @param dirty lets the caller know the display needs update
+ * @param passState state machine in rendering part/all of the score
+ * @param renderPromise awaits on render all
+ * @param addToReplaceQueue adds a measure to the quick update queue
+ * @param renderElement a little redundant with svg
+ * @category SuiRender
+ */
+export interface SuiRendererBase {
+    pageMap: SvgPageMap;
+    score: SmoScore | null;
+    dirty: boolean;
+    passState: number;
+    renderPromise(): Promise<any>;
+    addToReplaceQueue(mm: SmoSelection[]): void;
+    renderElement: Element;
+}
+/**
+ * used to perform highlights in the backgroundd
+ * @category SuiRender
+ */
+export interface HighlightQueue {
+    selectionCount: number;
+    deferred: boolean;
+}
+/**
+ * Map the notes in the svg so they can respond to events and interact
+ * with the mouse/keyboard
+ * @category SuiRender
+ */
+export declare abstract class SuiMapper {
+    renderer: SuiRendererBase;
+    scroller: SuiScroller;
+    measureNoteMap: Record<string | number, SmoSelection>;
+    modifierSelections: ModifierTab[];
+    selections: SmoSelection[];
+    localModifiers: ModifierTab[];
+    modifierIndex: number;
+    modifierSuggestion: ModifierTab | null;
+    pitchIndex: number;
+    deferHighlightMode: boolean;
+    suggestion: SmoSelection | null;
+    highlightQueue: HighlightQueue;
+    mouseHintBox: OutlineInfo | null;
+    selectionRects: Record<number, OutlineInfo[]>;
+    outlines: Record<string, OutlineInfo>;
+    mapping: boolean;
+    constructor(renderer: SuiRendererBase, scroller: SuiScroller);
+    abstract highlightSelection(): void;
+    abstract _growSelectionRight(hold?: boolean): number;
+    abstract _setModifierAsSuggestion(sel: ModifierTab): void;
+    abstract _setArtifactAsSuggestion(sel: SmoSelection): void;
+    abstract getIdleTime(): number;
+    updateHighlight(): void;
+    deferHighlight(): void;
+    _createLocalModifiersList(): void;
+    /**
+     * When a modifier is selected graphically, update the selection list
+     * and create a local modifier list
+     * @param modifierTabs
+     */
+    createLocalModifiersFromModifierTabs(modifierTabs: ModifierTab[]): void;
+    removeModifierSelectionBox(): void;
+    clearModifierSelections(): void;
+    loadScore(): void;
+    clearMeasureMap(measure: SmoMeasure): void;
+    _copySelectionsByMeasure(staffIndex: number, measureIndex: number): {
+        ticks: number;
+        selectors: SmoSelector[];
+    };
+    deleteMeasure(selection: SmoSelection): void;
+    _updateNoteModifier(selection: SmoSelection, modMap: Record<string, boolean>, modifier: SmoNoteModifierBase, ix: number): number;
+    _updateModifiers(): void;
+    _getClosestTick(selector: SmoSelector): SmoSelection;
+    _setModifierBoxes(measure: SmoMeasure): void;
+    /**
+     * returns true of the selections are adjacent
+     * @param s1 a selections
+     * @param s2 another election
+     * @returns
+     */
+    isAdjacentSelection(s1: SmoSelection, s2: SmoSelection): boolean;
+    areSelectionsAdjacent(): boolean;
+    /**
+     * This is the logic that stores the screen location of music after it's rendered
+     */
+    mapMeasure(staff: SmoSystemStaff, measure: SmoMeasure, printing: boolean): void;
+    _getTicksFromSelections(): number;
+    _copySelections(): SmoSelector[];
+    getExtremeSelection(sign: number): SmoSelection;
+    _selectClosest(selector: SmoSelector): void;
+    updateMap(): void;
+    createMousePositionBox(logicalBox: SvgBox): void;
+    eraseMousePositionBox(): void;
+    /**
+     * Find any musical elements at the supplied screen coordinates and set them as the selection
+     * @param bb
+     * @returns
+     */
+    intersectingArtifact(bb: SvgBox): void;
+    _getRectangleChain(selection: SmoSelection): number[];
+    _updateMeasureNoteMap(artifact: SmoSelection, printing: boolean): void;
+}