linked-rolls 0.0.1 → 0.1.1

package/lib/RollCopy.js

@@ -1,11 +1,17 @@
 import { AtonParser } from "./aton/AtonParser";
 import { v4 } from "uuid";
-import { assign, flat } from "./EditorialAssumption";
 import { read } from "midifile-ts";
 import { asSpans } from "./asMIDISpans";
-import { KinematicConversion } from "./PlaceTimeConversion";
-import { WelteT100 } from "./TrackerBar";
-const applyShift = (shift, to) => {
+import { welteT100 } from "./TrackerBar";
+import { assignReference, idsOf } from "./Assumption";
+export const rollConditions = [
+    'general',
+    'paper-stretch'
+];
+export const applyShift = (shift, copy) => {
+    if (copy.ops.includes('shifted'))
+        return;
+    const to = copy.features;
     for (const event of to) {
         event.horizontal.from += shift.horizontal;
         if (event.horizontal.to) {
@@ -16,255 +22,310 @@ const applyShift = (shift, to) => {
             event.vertical.to += shift.vertical;
         }
     }
+    copy.ops = [...copy.ops, 'shifted'];
+    copy.measurements.shift = shift;
 };
-const applyStretch = (stretch, to) => {
+export const applyStretch = (paperStretch, copy) => {
+    if (copy.ops.includes('stretched'))
+        return;
+    const stretch = paperStretch.factor;
+    const to = copy.features;
     for (const event of to) {
         event.horizontal.from *= stretch;
         if (event.horizontal.to) {
             event.horizontal.to *= stretch;
         }
     }
+    copy.ops = [...copy.ops, 'stretched'];
+    copy.conditions.push(paperStretch);
 };
-export class RollCopy {
-    constructor() {
-        Object.defineProperty(this, "type", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'RollCopy'
-        });
-        Object.defineProperty(this, "id", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: v4()
-        });
-        Object.defineProperty(this, "measurements", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: {}
-        });
-        Object.defineProperty(this, "productionEvent", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "conditions", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        Object.defineProperty(this, "location", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ''
-        });
-        /**
-         * Provides a reconstructed version of the roll,
-         * with shift, stretch and emendations already
-         * taken into account. This property will not be
-         * exported in the final JSON.
-         */
-        Object.defineProperty(this, "features", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        Object.defineProperty(this, "scan", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        }); // P138i has representation => IIIF Image Link
-    }
-    insertFeature(feature) {
-        this.measurements.shift && applyShift(this.measurements.shift, [feature]);
-        const stretch = flat(this.conditions)
-            .find(state => state.type === 'paper-stretch');
-        if (stretch) {
-            applyStretch(stretch.factor, [feature]);
-        }
-        this.features.push(feature);
-    }
-    setShift(shift) {
-        this.measurements.shift = shift;
-        applyShift(shift, this.features);
-    }
-    setStretch(stretch) {
-        this.conditions.push(stretch);
-        applyStretch(flat(stretch).factor, this.features);
-    }
-    shallowClone() {
-        const copy = new RollCopy();
-        copy.id = this.id;
-        copy.measurements = { ...this.measurements };
-        copy.productionEvent = this.productionEvent;
-        copy.location = this.location;
-        copy.conditions = [...this.conditions];
-        copy.scan = this.scan;
-        copy.features = [...this.features];
-        return copy;
-    }
+/**
+ * Reads the features of a copy as the tracker bar would read them.
+ * Holes on a position the bar does not read carry no symbol and are
+ * dropped, which is what happens physically as well.
+ */
+export function asSymbols(features, bar = welteT100) {
+    return features
+        .filter(feature => feature.type === 'Hole')
+        .flatMap((feature) => {
+        const meaning = bar.meaningOf(feature.vertical.from);
+        if (!meaning)
+            return [];
+        return [{
+                id: `symbol_${v4()}`,
+                ...meaning,
+                carriers: [assignReference(feature.id)]
+            }];
+    });
 }
-export function asSymbols(features) {
-    return features.map((feature) => {
-        return {
-            id: `symbol_${v4()}`,
-            ...new WelteT100().meaningOf(feature.vertical.from),
-            carriers: [assign('carrierAssignment', feature)]
-        };
+/**
+ * The tracks a copy carries holes on that the tracker bar does not read.
+ * A non-empty result usually means the scan is calibrated wrongly.
+ */
+export function unreadTracks(features, bar = welteT100) {
+    const counts = new Map();
+    features
+        .filter(feature => feature.type === 'Hole')
+        .filter(feature => !bar.meaningOf(feature.vertical.from))
+        .forEach(feature => {
+        const track = feature.vertical.from;
+        counts.set(track, (counts.get(track) || 0) + 1);
     });
+    return counts;
 }
-export function readFromStanfordAton(atonString, adjustByRewind = true, shift = 0) {
-    function pixelsToMillimeters(pixels, dpi) {
-        return pixels / dpi * 25.4;
+/**
+ * Falls back to the way the scan geometry was reconstructed before the
+ * calibration was recorded: the bass hard margin stood in for the phase
+ * of the tracker grid, with a constant making up most of the difference.
+ *
+ * The constant of one and a half tracks is the one the facsimile tiles
+ * were laid out with, and on the rolls measured so far it comes within
+ * about a quarter of a track. It is kept for copies imported before the
+ * calibration was written down; anything read since carries its own.
+ */
+export const calibrationOf = (copy) => {
+    if (copy.measurements.trackCalibration) {
+        return copy.measurements.trackCalibration;
     }
+    const separation = copy.measurements.holeSeparation?.value;
+    const bassMargin = copy.measurements.margins?.bass;
+    if (separation === undefined || bassMargin === undefined)
+        return undefined;
+    return {
+        unit: 'px',
+        offset: bassMargin + 1.5 * separation,
+        separation,
+        shift: 0
+    };
+};
+/** Values in these files carry their unit as a suffix, e.g. "37.7646px". */
+const px = (value) => parseFloat(value);
+/** The parser writes one record as an object and several as an array. */
+const listOf = (value) => value === undefined ? [] : Array.isArray(value) ? value : [value];
+/**
+ * Holes the parser set aside as suspicious after it had already chained
+ * them into a note: the head of such a chain is usually a punch that
+ * came out a little short, and leaving it out would lose the whole
+ * chain. They carry no track number of their own, so the column says
+ * which track they sit on.
+ */
+const chainedBadHoles = (holes, calibration) => holes
+    .filter(hole => hole.NOTE_ATTACK && hole.OFF_TIME)
+    .map(hole => ({
+    ...hole,
+    TRACKER_HOLE: `${Math.round((px(hole.CENTROID_COL) - calibration.offset) / calibration.separation)}`
+}));
+const millimeters = (pixels, dpi) => pixels / dpi * 25.4;
+const median = (values) => {
+    const sorted = [...values].sort((a, b) => a - b);
+    const middle = Math.floor(sorted.length / 2);
+    return sorted.length % 2 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
+};
+const mostFrequent = (values) => {
+    const counts = values.reduce((acc, value) => acc.set(value, (acc.get(value) || 0) + 1), new Map());
+    return [...counts].sort(([, a], [, b]) => b - a)[0]?.[0];
+};
+/**
+ * Only the first hole of a chain carries an attack and an off time;
+ * the rest continue it. The rewind perforation carries neither, and it
+ * is the last thing punched on the roll, so whatever the holes past the
+ * final musical attack sit on is the rewind track.
+ */
+const rewindTrackIn = (holes) => {
+    const lastMusical = holes.findLastIndex(hole => hole.NOTE_ATTACK);
+    const trailing = holes.slice(lastMusical + 1).map(hole => +hole.TRACKER_HOLE);
+    return mostFrequent(trailing);
+};
+/**
+ * The phase of the tracker grid within the image. The analysis file
+ * usually states it; where it does not, the holes themselves give it away,
+ * since each sits close to the centre of its column.
+ */
+const gridOffsetOf = (holes, separation, stated) => {
+    if (stated !== undefined)
+        return px(stated);
+    return median(holes.map(hole => px(hole.CENTROID_COL) - +hole.TRACKER_HOLE * separation));
+};
+const punchDiameterOf = (holes, dpi) => {
+    const circular = holes
+        .filter(hole => px(hole.CIRCULARITY) > 0.95)
+        .map(hole => millimeters(px(hole.PERIMETER), dpi) / Math.PI);
+    if (!circular.length)
+        return undefined;
+    return circular.reduce((sum, diameter) => sum + diameter, 0) / circular.length;
+};
+/**
+ * The image service Stanford keeps for a scan, and a crop of a
+ * feature from it.
+ */
+const stanfordScan = (druid) => ({
+    scan: `https://stacks.stanford.edu/image/iiif/${druid}%2F${druid}_0001/`,
+    depictionOf: (column, row, width, height) => `https://stacks.stanford.edu/image/iiif/${druid}/${druid}_0001/${column},${row},${width},${height}/128,/270/default.jpg`
+});
+/**
+ * The software behind an analysis and when it was run, as the
+ * analysis file states them.
+ */
+const measuredByOf = (rollinfo) => {
+    const date = new Date(rollinfo.ANALYSIS_DATE);
+    if (!rollinfo.HOLE_SOFTWARE || isNaN(date.getTime()))
+        return undefined;
+    return {
+        software: rollinfo.HOLE_SOFTWARE,
+        version: rollinfo.SOFTWARE_DATE ?? '',
+        date
+    };
+};
+export function readFromStanfordAton(atonString, { trackShift, bar = welteT100, scan } = {}) {
     const parser = new AtonParser();
     const json = parser.parse(atonString);
     const holes = json.ROLLINFO.HOLES.HOLE;
     const druid = json.ROLLINFO.DRUID;
-    const holeSeparation = parseFloat(json.ROLLINFO.HOLE_SEPARATION.replace('px'));
-    const hardMarginBass = parseFloat(json.ROLLINFO.HARD_MARGIN_BASS.replace('px'));
-    const hardMarginTreble = parseFloat(json.ROLLINFO.HARD_MARGIN_TREBLE.replace('px'));
-    const dpi = parseFloat(json.ROLLINFO.LENGTH_DPI.replace('ppi'));
-    const rollWidth = parseFloat(json.ROLLINFO.ROLL_WIDTH.replace('px')) / dpi * 25.4;
-    const rollHeight = parseFloat(json.ROLLINFO.IMAGE_LENGTH.replace('px')) / dpi * 25.4;
-    let averagePunchDiameter = -1;
-    const lastHole = +holes[holes.length - 1].TRACKER_HOLE;
-    const rewindShift = adjustByRewind ? 91 - lastHole : shift;
-    const copy = new RollCopy();
-    copy.measurements = {
-        dimensions: {
-            width: rollWidth,
-            height: rollHeight,
-            unit: 'mm'
-        },
-        punchDiameter: {
-            value: averagePunchDiameter,
-            unit: 'mm'
-        },
-        holeSeparation: {
-            value: holeSeparation,
-            unit: 'px'
-        },
-        margins: {
-            treble: hardMarginTreble,
-            bass: hardMarginBass,
-            unit: 'px'
-        },
-        // todo
-        shift: {
-            horizontal: 0,
-            vertical: 0
-        }
+    const stanford = druid ? stanfordScan(druid) : undefined;
+    const separation = px(json.ROLLINFO.HOLE_SEPARATION);
+    const dpi = parseFloat(json.ROLLINFO.LENGTH_DPI);
+    const measuredBy = measuredByOf(json.ROLLINFO);
+    const rewindTrack = rewindTrackIn(holes);
+    const shift = trackShift
+        ?? (rewindTrack === undefined ? 0 : bar.rewindTrack - rewindTrack);
+    const calibration = {
+        unit: 'px',
+        offset: gridOffsetOf(holes, separation, json.ROLLINFO.HOLE_OFFSET),
+        separation,
+        shift
     };
-    let circularPunches = 0;
-    const features = [];
-    for (let i = 0; i < holes.length; i++) {
-        const hole = holes[i];
-        const circularity = +hole.CIRCULARITY.replace('px', '');
-        if (circularity > 0.95) {
-            const perimeterInMM = pixelsToMillimeters(+hole.PERIMETER.replace('px', ''), dpi);
-            averagePunchDiameter += perimeterInMM;
-            circularPunches += 1;
-        }
-        if (!hole.NOTE_ATTACK || !hole.OFF_TIME)
-            continue;
-        const trackerHole = +hole.TRACKER_HOLE + rewindShift;
-        const noteAttack = +hole.NOTE_ATTACK.replace('px', '');
-        const offset = +hole.OFF_TIME.replace('px', '');
-        const height = offset - noteAttack;
-        const column = +hole.ORIGIN_COL.replace('px', '');
-        const columnWidth = +hole.WIDTH_COL.replace('px', '');
-        const annotates = `https://stacks.stanford.edu/image/iiif/${druid}/${druid}_0001/${column},${noteAttack},${columnWidth},${height}/128,/270/default.jpg`;
-        const feature = {
+    const punchDiameter = punchDiameterOf(holes, dpi);
+    const chains = [...holes, ...chainedBadHoles(listOf(json.ROLLINFO.BADHOLES?.HOLE), calibration)]
+        .filter(hole => hole.NOTE_ATTACK && hole.OFF_TIME)
+        .sort((a, b) => px(a.NOTE_ATTACK) - px(b.NOTE_ATTACK));
+    const features = chains
+        .map((hole) => {
+        const attack = px(hole.NOTE_ATTACK);
+        const release = px(hole.OFF_TIME);
+        const column = px(hole.ORIGIN_COL);
+        const columnWidth = px(hole.WIDTH_COL);
+        return {
+            type: 'Hole',
             id: v4(),
-            annotates,
+            ...(stanford && {
+                depiction: stanford.depictionOf(column, attack, columnWidth, release - attack)
+            }),
             vertical: {
-                from: trackerHole,
+                from: +hole.TRACKER_HOLE + shift,
                 unit: 'track'
             },
             horizontal: {
                 unit: 'mm',
-                from: pixelsToMillimeters(noteAttack, dpi),
-                to: pixelsToMillimeters(offset, dpi)
+                from: millimeters(attack, dpi),
+                to: millimeters(release, dpi)
             }
         };
-        features.push(feature);
-    }
-    averagePunchDiameter /= circularPunches;
-    averagePunchDiameter /= Math.PI;
-    copy.scan = `https://stacks.stanford.edu/image/iiif/${druid}%2F${druid}_0001/`;
-    copy.features = features;
-    return copy;
+    });
+    return {
+        type: 'RollCopy',
+        id: v4(),
+        ops: [],
+        conditions: [],
+        location: '',
+        modifications: [],
+        ...((scan ?? stanford) && { scan: scan ?? stanford?.scan }),
+        measurements: {
+            dimensions: {
+                width: millimeters(px(json.ROLLINFO.ROLL_WIDTH), dpi),
+                height: millimeters(px(json.ROLLINFO.IMAGE_LENGTH), dpi),
+                unit: 'mm'
+            },
+            ...(punchDiameter !== undefined && {
+                punchDiameter: { value: punchDiameter, unit: 'mm' }
+            }),
+            holeSeparation: {
+                value: separation,
+                unit: 'px'
+            },
+            margins: {
+                treble: px(json.ROLLINFO.HARD_MARGIN_TREBLE),
+                bass: px(json.ROLLINFO.HARD_MARGIN_BASS),
+                unit: 'px'
+            },
+            trackCalibration: calibration,
+            ...(measuredBy && { measuredBy })
+        },
+        features
+    };
 }
 /**
- * Spencer Chase's rolls seem to be scanned at a roll speed of
- * 83 (=8.3 feet per minute).
+ * How a MIDI key number in one of Spencer Chase's roll files names a
+ * tracker bar track.
  *
- * @param midiBuffer
- * @param conversion
+ * The note block follows the obvious rule, `pitch - 13`, which puts
+ * track 11 on MIDI 24 as the T100 compass requires. The bass expression
+ * block does not: it reads two tracks high, and subtracting two is what
+ * has made these files come out right so far.
+ *
+ * The boundary between the two rules is unresolved. Taken literally the
+ * rules leave tracks 8 and 9 unreachable and jump from track 7 to track 10,
+ * which no lateral offset can produce, so at least one of them is
+ * approximate. Settling it needs a Spencer file whose expression holes
+ * can be checked against the roll, hence the option to override.
  */
-export function readFromSpencerMIDI(midiBuffer, conversion = new KinematicConversion(8.3)) {
-    const midi = read(midiBuffer);
-    const features = [];
-    const copy = new RollCopy();
-    const spans = asSpans(midi);
-    for (const span of spans) {
-        const left = conversion.timeToPlace(span.onsetMs / 1000) * 10;
-        const right = conversion.timeToPlace(span.offsetMs / 1000) * 10;
-        const horizontalDimension = {
-            from: left,
-            to: right,
+export const spencerTrackOf = (pitch) => {
+    const track = pitch - 13;
+    return track < 10 ? track - 2 : track;
+};
+const MM_PER_FOOT = 304.8;
+/**
+ * Spencer Chase's rolls seem to be scanned at a roll speed of
+ * 83 (=8.3 feet per minute). A scanner feeds the paper at one
+ * speed, so time in his files is proportional to place.
+ */
+export const SPENCER_FEET_PER_MINUTE = 8.3;
+/** Place on the roll in mm after `seconds` at a constant `feetPerMinute`. */
+export const atConstantSpeed = (feetPerMinute) => (seconds) => feetPerMinute * MM_PER_FOOT / 60 * seconds;
+export function readFromSpencerMIDI(midiBuffer, placeAt = atConstantSpeed(SPENCER_FEET_PER_MINUTE), trackOf = spencerTrackOf) {
+    const features = asSpans(read(midiBuffer))
+        .filter(span => span.type === 'note')
+        .map((span) => ({
+        type: 'Hole',
+        id: v4(),
+        vertical: {
+            from: trackOf(span.pitch),
+            unit: 'track'
+        },
+        horizontal: {
+            from: placeAt(span.onsetMs / 1000),
+            to: placeAt(span.offsetMs / 1000),
             unit: 'mm'
-        };
-        if (span.type !== 'note')
-            continue;
-        const midiShift = 13;
-        let trackerHole = span.pitch - midiShift;
-        // for whatever reasons, the expression tracks
-        // of the Spencer Chase's MIDI rolls are off
-        // by two on the bass-side.
-        if (trackerHole < 10) {
-            trackerHole -= 2;
         }
-        const feature = {
-            vertical: {
-                from: trackerHole,
-                unit: 'track'
-            },
-            horizontal: horizontalDimension,
-            id: v4()
-        };
-        features.push(feature);
-    }
-    copy.features = features;
-    return copy;
+    }));
+    return {
+        type: 'RollCopy',
+        id: v4(),
+        ops: [],
+        conditions: [],
+        location: '',
+        measurements: {},
+        modifications: [],
+        features
+    };
 }
+/**
+ * Moves features across the tracker bar. What the new position means is
+ * left to the tracker bar to say, since meaning belongs to the symbols
+ * read off a copy rather than to the holes themselves.
+ */
 export function shiftVertically(features, amount) {
-    for (const event of features) {
-        event.vertical.from += amount;
-        try {
-            const newEvent = new WelteT100().meaningOf(event.vertical.from);
-            for (const key in newEvent) {
-                event[key] = newEvent[key];
-            }
-        }
-        catch (e) {
-            console.error(e);
+    features.forEach(feature => {
+        feature.vertical.from += amount;
+        if (feature.vertical.to !== undefined) {
+            feature.vertical.to += amount;
         }
-    }
+    });
 }
 export const findCopiesCarrying = (sources, symbol) => {
     const result = new Set();
-    for (const feature of flat(symbol.carriers)) {
+    for (const feature of idsOf(symbol.carriers)) {
         for (const copy of sources) {
-            if (copy.features.includes(feature)) {
+            if (copy.features.findIndex(f => f.id === feature)) {
                 result.add(copy.id);
             }
         }

package/lib/Symbol.d.ts

@@ -1,62 +1,95 @@
-import { EditorialAssumption } from "./EditorialAssumption";
-import { HorizontalSpan, RollFeature, VerticalSpan } from "./Feature";
-import { WithId } from "./WithId";
+import { ReferenceAssumption, ValueAssumption } from "./Assumption";
+import { WithId } from "./utils";
 /**
- * @todo Should this be called Transcription?
+ * A symbol is an abstract musical or textual entity carried by one or more
+ * physical features on the roll. Symbols are the result of interpreting
+ * the physical features (holes, writings, etc.) on the roll copies.
  */
-export type CarrierAssignment = EditorialAssumption<'carrierAssignment', RollFeature>;
 export interface Symbol<T extends string> extends WithId {
     type: T;
-    carriers: CarrierAssignment[];
+    /**
+     * References to the physical features (e.g. holes) on the roll copies
+     * that carry this symbol. Since the association might be debatable,
+     * it can be annotated. There might be e.g. doubts about the meaning
+     * and correct transcription of a feature on a physical roll.
+     * This points to a feature by its `@id`.
+     * @see crm:P128i is carried by
+     */
+    carriers: ReferenceAssumption[];
 }
 export declare const isSymbol: (object: any) => object is AnySymbol;
+/**
+ * A perforation is a symbol that is typically encoded as a single punched
+ * hole or a group of punched holes in the physical carrier.
+ * However, it might also have different physical appearences.
+ * @see reo:C5 Perforation
+ */
 export interface Perforation<T extends string> extends Symbol<T> {
-    accelerating?: boolean;
+    /**
+     * In piano rolls, perforations are often aligned with other
+     * perforations, e.g. a "crescendo off" might be logically
+     * aligned to the start of a note perforation.
+     * @see reo:P3 aligned with
+     */
+    alignedWith?: ValueAssumption<string>;
 }
+/**
+ * A note symbol, representing a single pitched musical event on the roll.
+ * The pitch is encoded via the tracker bar position (track number).
+ * @see reo:P6 Note
+ */
 export interface Note extends Perforation<'note'> {
+    /**
+     * The MIDI pitch number of the note (e.g. 60 for middle C).
+     * @see reo:P5 has pitch
+     */
     pitch: number;
 }
+/**
+ * The scope of an expression perforation, indicating whether it
+ * applies to the bass or treble register of the piano.
+ * @see reo:P6 has scope
+ */
 export type ExpressionScope = 'bass' | 'treble';
+/**
+ * The type of expression encoded by a perforation on the roll,
+ * e.g. "crescendo on", "crescendo off", etc. on Welte T-100
+ * rolls.
+ * @see crm:P2 has type
+ */
 export type ExpressionType = 'SustainPedalOn' | 'SustainPedalOff' | 'SoftPedalOn' | 'SoftPedalOff' | 'MezzoforteOff' | 'MezzoforteOn' | 'SlowCrescendoOn' | 'SlowCrescendoOff' | 'ForzandoOn' | 'ForzandoOff' | 'MotorOff' | 'MotorOn' | 'Rewind' | 'ElectricCutOff';
+/**
+ * An expression symbol, representing a perforation on the roll
+ * that governs dynamics, pedaling, or mechanical functions of the
+ * reproducing piano. Each expression has a scope (bass or treble)
+ * and a specific expression type.
+ * @see reo:C7 Expression
+ */
 export interface Expression extends Perforation<'expression'> {
+    /**
+     * Whether this expression applies to the bass or treble register.
+     * @see reo:P6 has scope
+     */
     scope: ExpressionScope;
+    /**
+     * The specific type of expression (e.g. sustain pedal, forzando, etc.).
+     * @see crm:P2 has type
+     */
     expressionType: ExpressionType;
 }
 /**
- * This denotes perforations that are covered by an editor.
- * The covered perforation is not considered to be part
- * of the original note or expression hole anymore.
+ * A textual symbol, e.g. a label or annotation found on the roll.
+ * @see crm:E33 Linguistic Object
  */
-export interface Cover extends Symbol<'cover'> {
+export interface Text extends Symbol<'text'> {
     /**
-     * This property can be used to indicate e.g. the
-     * color or material of the cover.
+     * The text content of the symbol.
+     * @see crm:P3 has note
      */
-    note?: string;
-}
-export interface Text<T extends string> extends Symbol<T> {
     text: string;
-    rotation?: number;
-}
-/**
- * For handwritten insertions like e. g. the
- * perforation date in the end of a roll.
- */
-export interface HandwrittenText extends Text<'handwrittenText'> {
-    pen?: 'ink' | 'pencil' | 'crayon';
 }
 /**
- * This type can be used to indicate stamps like e. g. the
- * "controlliert" stamp in the beginning of rolls or the
- * date at the end of (later) Welte rolls.
+ * A symbol can be either a note, an expression, or a text.
+ * Notes and expressions are perforations; texts are carried by writings.
  */
-export interface Stamp extends Text<'stamp'> {
-}
-export interface RollLabel extends Text<'rollLabel'> {
-    signed: boolean;
-}
-export type AnySymbol = Note | Expression | HandwrittenText | Stamp | Cover | RollLabel;
-export declare const dimensionOf: (symbol: AnySymbol) => {
-    horizontal: HorizontalSpan;
-    vertical: VerticalSpan;
-};
+export type AnySymbol = Note | Expression | Text;