linked-rolls 0.56.0 → 0.58.0

package/lib/ops/forget.js

@@ -0,0 +1,110 @@
+import { isCommand, placementRelations } from "../model/Symbol.js";
+import { editsOf } from "../model/Version.js";
+import { featuresOf, statesNothing } from "../model/RollCopy.js";
+import { idOf } from "../model/Assumption.js";
+import { withBorneFeatures } from "../model/Feature.js";
+import { stateOf, droppedIds, insertedIn, edited } from "./draft.js";
+import { without, mapped, pruned, replacing, deeply, writeInto } from "./immutable.js";
+/** The ids of every feature the copy bears, those a patch bears among them. */
+export const featureIdsOf = (copy) => new Set(featuresOf(copy).flatMap(withBorneFeatures).map(feature => feature.id));
+/**
+ * A symbol every carrier of which lies among the features loses its
+ * evidence with them. A symbol without carriers, such as a label,
+ * stands on its own.
+ */
+export const carriedOnlyOn = (features) => (symbol) => symbol.carriers.length > 0 && symbol.carriers.every(carrier => features.has(idOf(carrier)));
+const references = [...placementRelations, 'pairedWith'];
+/** The command without its references to the dropped symbols, or the very same one where it makes none. */
+const forgettingReferences = (command, dropped) => {
+    const stale = references.filter(relation => {
+        const reference = command[relation];
+        return reference !== undefined && dropped.has(idOf(reference));
+    });
+    if (stale.length === 0)
+        return command;
+    const kept = { ...command };
+    stale.forEach(relation => { delete kept[relation]; });
+    return kept;
+};
+/** The symbol without the features among its carriers, and without references to what went with them. */
+const forgettingCarriers = (features, dropped) => (symbol) => {
+    const carriers = without(symbol.carriers, carrier => features.has(idOf(carrier)));
+    const relieved = carriers === symbol.carriers ? symbol : { ...symbol, carriers };
+    return isCommand(relieved) ? forgettingReferences(relieved, dropped) : relieved;
+};
+/** The edit without the dropped symbols and the features, or the very same edit where it had none of them. */
+const forgettingFeatures = (features, dropped) => {
+    const forgetCarriers = forgettingCarriers(features, dropped);
+    return (edit) => {
+        const insert = edit.insert && mapped(without(edit.insert, symbol => dropped.has(symbol.id)), forgetCarriers);
+        const deleted = edit.delete && without(edit.delete, id => dropped.has(id));
+        if (insert === edit.insert && deleted === edit.delete)
+            return edit;
+        return { ...edit, ...(insert && { insert }), ...(deleted && { delete: deleted }) };
+    };
+};
+const isCopy = (record) => 'type' in record && record.type === 'RollCopy';
+const isBelief = (record) => 'type' in record && record.type === 'belief';
+const isComprehension = (reason) => reason.type === 'meaningComprehension';
+const comprehendsNothing = (reason) => isComprehension(reason) && reason.comprehends.length === 0;
+/**
+ * The modification with what it names rewritten, or the very same one
+ * where that leaves it as it was. Only a removal names anything by id:
+ * what an act produced or glued on it states itself.
+ */
+const renamingMembers = (rename) => (modification) => modification.type === 'Removal'
+    ? replacing(modification, 'removed', rename(modification.removed))
+    : modification;
+/** The reason with what a comprehension comprehends rewritten; any other reason names nothing of the kind. */
+const renamingComprehended = (rename) => (reason) => isComprehension(reason) ? replacing(reason, 'comprehends', rename(reason.comprehends)) : reason;
+/**
+ * The record with the ids it names rewritten: what a copy's removals
+ * removed, and what the comprehensions among a belief's reasons
+ * comprehend. A removal or a comprehension the rewriting emptied goes
+ * with what it named; one that named nothing before stays, as an edit
+ * that was empty before it does.
+ */
+const renaming = (rename) => (record) => {
+    if (isCopy(record)) {
+        return replacing(record, 'modifications', pruned(record.modifications, renamingMembers(rename), statesNothing));
+    }
+    if (isBelief(record)) {
+        return replacing(record, 'reasons', pruned(record.reasons, renamingComprehended(rename), comprehendsNothing));
+    }
+    return record;
+};
+/**
+ * Rewrites the ids by which the edition names features and symbols
+ * outside the versions. A belief is annotatable anywhere, so the whole
+ * edition is read; what the rewriting leaves alone is left the very
+ * object it was.
+ */
+export const renameReferences = (draft, rename) => {
+    const before = stateOf(draft);
+    const after = deeply(renaming(rename))(before);
+    if (after !== before)
+        writeInto(draft, before, after);
+};
+/**
+ * Strikes the features from the edition: their carriers go, a symbol
+ * that had no other carrier goes with them, an edit left exchanging
+ * nothing goes as well, and so does every reference the versions, the
+ * modifications of the copies and the comprehensions made to what went.
+ */
+export const forgetFeatures = (draft, features) => {
+    const versions = stateOf(draft.versions);
+    const dropped = new Set(insertedIn(versions).filter(carriedOnlyOn(features)).map(symbol => symbol.id));
+    const forget = forgettingFeatures(features, dropped);
+    const edits = versions.map(version => version.edits && edited(version.edits, forget));
+    const gone = new Set([
+        ...features,
+        ...dropped,
+        ...versions.flatMap((version, i) => droppedIds(editsOf(version), edits[i] ?? []))
+    ]);
+    renameReferences(draft, ids => without(ids, id => gone.has(id)));
+    draft.versions.forEach((version, i) => {
+        const stated = edits[i];
+        if (stated)
+            version.edits = stated;
+    });
+};

package/lib/ops/immutable.d.ts

@@ -0,0 +1,16 @@
+/** Rewritings that return the very object they were given wherever they change nothing, so that an immer draft is left untouched there. */
+/** The items that do not match, or the very same array when none does, so that a draft stays untouched. */
+export declare const without: <T>(items: T[], matches: (item: T) => boolean) => T[];
+/** The items each changed, or the very same array when the change left every one as it was. */
+export declare const mapped: <T>(items: T[], change: (item: T) => T) => T[];
+/** The items each changed, less those the change emptied; the very same array where it changed none. */
+export declare const pruned: <T>(items: T[], change: (item: T) => T, emptied: (item: T) => boolean) => T[];
+/** The record with the field replaced, or the very same record where that is what stood there. */
+export declare const replacing: <T extends object, K extends keyof T>(record: T, key: K, value: T[K]) => T;
+/** A record of the edition, as the walk over it sees one. */
+export type Node = Record<string, unknown>;
+export declare const isRecord: (value: unknown) => value is Node;
+/** The value with the change applied to every record within it and then to itself, innermost first. */
+export declare const deeply: (change: (record: object) => object) => (value: unknown) => unknown;
+/** Writes onto the draft what the rewriting changed, as deep as the change reaches. */
+export declare const writeInto: (draft: Node, before: Node, after: Node) => void;

package/lib/ops/immutable.js

@@ -0,0 +1,46 @@
+/** Rewritings that return the very object they were given wherever they change nothing, so that an immer draft is left untouched there. */
+/** The items that do not match, or the very same array when none does, so that a draft stays untouched. */
+export const without = (items, matches) => items.some(matches) ? items.filter(item => !matches(item)) : items;
+/** The items each changed, or the very same array when the change left every one as it was. */
+export const mapped = (items, change) => {
+    const changed = items.map(change);
+    return changed.every((item, i) => item === items[i]) ? items : changed;
+};
+/** The items each changed, less those the change emptied; the very same array where it changed none. */
+export const pruned = (items, change, emptied) => {
+    const changed = mapped(items, change);
+    return changed === items ? items : changed.filter((item, i) => item === items[i] || !emptied(item));
+};
+/** The record with the field replaced, or the very same record where that is what stood there. */
+export const replacing = (record, key, value) => record[key] === value ? record : { ...record, [key]: value };
+export const isRecord = (value) => typeof value === 'object' && value !== null;
+/** The record's values each changed, or the very same record where the change left every one as it was. */
+const withValues = (record, change) => {
+    const entries = Object.entries(record);
+    const changed = entries.map(([key, value]) => [key, change(value)]);
+    return changed.every(([, value], i) => value === entries[i][1]) ? record : Object.fromEntries(changed);
+};
+/** The value with the change applied to every record within it and then to itself, innermost first. */
+export const deeply = (change) => {
+    const changed = (value) => Array.isArray(value) ? mapped(value, changed)
+        : isRecord(value) ? change(withValues(value, changed))
+            : value;
+    return changed;
+};
+/** Whether the two stand alike, so that what differs within them can be written where it lies. */
+const alike = (before, after) => {
+    if (!isRecord(before) || !isRecord(after))
+        return false;
+    if (Array.isArray(before))
+        return Array.isArray(after) && before.length === after.length;
+    return !Array.isArray(after);
+};
+/** Writes onto the draft what the rewriting changed, as deep as the change reaches. */
+export const writeInto = (draft, before, after) => Object.entries(after).forEach(([key, value]) => {
+    if (value === before[key])
+        return;
+    if (alike(before[key], value))
+        writeInto(draft[key], before[key], value);
+    else
+        draft[key] = value;
+});

package/lib/ops/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The operations on an edition, each written onto an immer draft of it.
+ * They are grouped by what they change under `ops/`; this module names
+ * the ones the library offers.
+ */
+export type { EditionOp } from "./draft.js";
+export { createVersion, addCopy, alignCopy, unalignCopy, shortenCopy, unshortenCopy, stateSource, clearSource, nameCopy, stateCarriage, clearCarriage, addGeneralCondition, symbolsCarriedOnlyBy, removeCopy } from "./copies.js";
+export { stateFeatureCondition, addFeature, addBorneFeature, removeFeatures, mergeObstacle, mergeObstacleIn, mergeFeatures, type FeatureAct, type MergeObstacle } from "./features.js";
+export { detachVersion, removeVersion, removeSymbols, deriveVersion, stateDerivation, clearDerivation } from "./versions.js";
+export { connectVersions, collateSymbols, separateReadings } from "./collation.js";
+export { mergeEdits, splitEdit } from "./edits.js";
+export { placeCommand, unplaceCommand, pairCommands, unpairCommand } from "./commands.js";
+export { createBelief, clearBelief, setCertainty, addReason, removeReason } from "./beliefs.js";

package/lib/ops/index.js

@@ -0,0 +1,7 @@
+export { createVersion, addCopy, alignCopy, unalignCopy, shortenCopy, unshortenCopy, stateSource, clearSource, nameCopy, stateCarriage, clearCarriage, addGeneralCondition, symbolsCarriedOnlyBy, removeCopy } from "./copies.js";
+export { stateFeatureCondition, addFeature, addBorneFeature, removeFeatures, mergeObstacle, mergeObstacleIn, mergeFeatures } from "./features.js";
+export { detachVersion, removeVersion, removeSymbols, deriveVersion, stateDerivation, clearDerivation } from "./versions.js";
+export { connectVersions, collateSymbols, separateReadings } from "./collation.js";
+export { mergeEdits, splitEdit } from "./edits.js";
+export { placeCommand, unplaceCommand, pairCommands, unpairCommand } from "./commands.js";
+export { createBelief, clearBelief, setCertainty, addReason, removeReason } from "./beliefs.js";

package/lib/ops/versions.d.ts

@@ -0,0 +1,33 @@
+import { EditionView } from "../view/EditionView.js";
+import { Derivation, Version } from "../model/Version.js";
+import { Belief } from "../model/Assumption.js";
+import { EditionOp } from "./draft.js";
+/** The derivations the version states beside its principal one, less any naming the parent. */
+export declare const hypothesesBeside: (version: Readonly<Version>, parentId: string) => Derivation[];
+/**
+ * Makes the version stand on its own: what it inherited becomes its
+ * own insertions, and its derivations go, the hypotheses among them,
+ * with the motivations that belonged to them.
+ */
+export declare const detachVersion: (given: EditionView, versionId: string) => EditionOp;
+/**
+ * Takes the version out. Whatever read its text against it comes to
+ * stand on its own, a hypothesis that something derives from it goes,
+ * and so does a copy's statement that it carries the version.
+ */
+export declare const removeVersion: (given: EditionView, versionId: string) => EditionOp;
+/** Takes the symbols out of the version's own insertions, and the edits that had nothing else. */
+export declare const removeSymbols: (versionId: string, symbolIds: readonly string[]) => EditionOp;
+/** Moves the edits into a new version based on this one. */
+export declare const deriveVersion: (versionId: string, editIds: readonly string[]) => EditionOp;
+/**
+ * States that the version may also derive from the parent, beside what
+ * it derives from already: a hypothesis, such as a contamination, under
+ * the belief given. The text stays read against the principal derivation
+ * unless the belief holds this one more certain. A version derives from
+ * itself, twice from one parent, or from one of its own descendants in
+ * no statement.
+ */
+export declare const stateDerivation: (versionId: string, parentId: string, belief?: Belief) => EditionOp;
+/** Takes back the hypothesis that the version derives from the parent; the principal derivation goes with `detachVersion`. */
+export declare const clearDerivation: (versionId: string, parentId: string) => EditionOp;

package/lib/ops/versions.js

@@ -0,0 +1,95 @@
+import { v4 } from "uuid";
+import { derivesFrom, editsOf, principalDerivationOf } from "../model/Version.js";
+import { assignReference, idOf } from "../model/Assumption.js";
+import { onVersion, stateOf, insertion, dropInsertions, referenceHeld, withoutReferences, reading } from "./draft.js";
+import { without } from "./immutable.js";
+import { dropStatements } from "./copies.js";
+/** Whether the version's text is read against the parent, its principal derivation naming it. */
+const readsAgainst = (version, parentId) => {
+    const principal = principalDerivationOf(version);
+    return principal !== undefined && idOf(principal) === parentId;
+};
+/** The derivations the version states beside its principal one, less any naming the parent. */
+export const hypothesesBeside = (version, parentId) => {
+    const principal = principalDerivationOf(version);
+    return (version.basedOn ?? []).filter(derivation => derivation !== principal && idOf(derivation) !== parentId);
+};
+/** Takes out the derivations that match, and the list itself where none is left. */
+const dropDerivations = (version, matches) => {
+    const derivations = stateOf(version).basedOn;
+    if (!derivations?.some(matches))
+        return;
+    const kept = withoutReferences(derivations, matches);
+    if (kept)
+        version.basedOn = kept;
+    else
+        delete version.basedOn;
+};
+/**
+ * Makes the version stand on its own: what it inherited becomes its
+ * own insertions, and its derivations go, the hypotheses among them,
+ * with the motivations that belonged to them.
+ */
+export const detachVersion = (given, versionId) => reading(given, view => {
+    const edits = view.snapshot(versionId).map(insertion);
+    return onVersion(versionId, version => {
+        version.edits = edits;
+        delete version.basedOn;
+        version.motivations = [];
+    });
+});
+/**
+ * Takes the version out. Whatever read its text against it comes to
+ * stand on its own, a hypothesis that something derives from it goes,
+ * and so does a copy's statement that it carries the version.
+ */
+export const removeVersion = (given, versionId) => reading(given, view => {
+    const detachments = view.edition.versions
+        .filter(version => readsAgainst(version, versionId))
+        .map(version => detachVersion(view, version.id));
+    const namesIt = (reference) => idOf(reference) === versionId;
+    return draft => {
+        detachments.forEach(detach => detach(draft));
+        draft.versions.forEach(version => dropDerivations(version, namesIt));
+        draft.copies.forEach(copy => dropStatements(copy, namesIt));
+        draft.versions = without(draft.versions, version => version.id === versionId);
+    };
+});
+/** Takes the symbols out of the version's own insertions, and the edits that had nothing else. */
+export const removeSymbols = (versionId, symbolIds) => onVersion(versionId, version => dropInsertions(version, new Set(symbolIds)));
+/** Moves the edits into a new version based on this one. */
+export const deriveVersion = (versionId, editIds) => onVersion(versionId, (version, draft) => {
+    const chosen = new Set(editIds);
+    const moved = editsOf(version).filter(edit => chosen.has(edit.id));
+    if (version.edits)
+        version.edits = without(version.edits, edit => chosen.has(edit.id));
+    draft.versions.push({
+        id: v4(),
+        system: stateOf(version).system,
+        basedOn: [assignReference(versionId)],
+        edits: moved,
+        motivations: []
+    });
+});
+/**
+ * States that the version may also derive from the parent, beside what
+ * it derives from already: a hypothesis, such as a contamination, under
+ * the belief given. The text stays read against the principal derivation
+ * unless the belief holds this one more certain. A version derives from
+ * itself, twice from one parent, or from one of its own descendants in
+ * no statement.
+ */
+export const stateDerivation = (versionId, parentId, belief) => onVersion(versionId, (version, draft) => {
+    const derivations = stateOf(version).basedOn ?? [];
+    if (parentId === versionId || derivations.some(derivation => idOf(derivation) === parentId))
+        return;
+    if (derivesFrom(stateOf(draft.versions), parentId, versionId))
+        return;
+    version.basedOn = [...derivations, referenceHeld(parentId, belief)];
+});
+/** Takes back the hypothesis that the version derives from the parent; the principal derivation goes with `detachVersion`. */
+export const clearDerivation = (versionId, parentId) => onVersion(versionId, version => {
+    if (readsAgainst(stateOf(version), parentId))
+        return;
+    dropDerivations(version, derivation => idOf(derivation) === parentId);
+});

package/lib/readers/AtonParser.js

@@ -70,13 +70,13 @@ export class AtonParser {
             // Ignore unassociated text.
             return;
         }
-        else if (matches = line.match(/^@@[^@ ]/)) {
+        else if ((matches = line.match(/^@@[^@ ]/))) {
             // Control message.
             // End current property.
             this.cleanParameter(state);
             state.curkey = undefined;
             state.ocurkey = undefined;
-            if (matches = line.match(/^@@(BEGIN|START)\s*:\s*(.*)\s*$/i)) {
+            if ((matches = line.match(/^@@(BEGIN|START)\s*:\s*(.*)\s*$/i))) {
                 state.label = matches[2];
                 //console.log(state.label)
                 if (typeof state.curobj[state.label] === 'undefined') {
@@ -107,7 +107,7 @@ export class AtonParser {
                     state.curobj = state.curobj[state.label][state.curobj[state.label].length - 1];
                 }
             }
-            else if (matches = line.match(/^@@(END|STOP)\s*:?\s*(.*)\s*$/i)) {
+            else if ((matches = line.match(/^@@(END|STOP)\s*:?\s*(.*)\s*$/i))) {
                 // End an object, so go back to the parent.
                 if (typeof state.curkey !== 'undefined') {
                     // clean whitespace of last read property:
@@ -121,8 +121,6 @@ export class AtonParser {
                 if (typeof state.node[state.node.length - 1].startline === 'undefined') {
                     throw new Error('No start for ' + state.action + ' tag on line '
                         + state.node[state.node.length - 1].startline + ': ' + line);
-                    state.output = {};
-                    // return v.output;
                 }
                 if (typeof state.labelend !== 'undefined') {
                     // ensure that the v.label begin/end tags match
@@ -144,12 +142,12 @@ export class AtonParser {
                         obj[x.label][x.index] : obj[x.label];
                 }, state.output);
             }
-            else if (matches = line.match(/^@@TYPE\s*:\s*([^:]+)\s*:\s*(.*)\s*$/i)) {
+            else if ((matches = line.match(/^@@TYPE\s*:\s*([^:]+)\s*:\s*(.*)\s*$/i))) {
                 // Automatic property value conversion.
                 state.typer[matches[1]] = matches[2];
             }
         }
-        else if (matches = line.match(/^@([^\s:@][^:]*)\s*:\s*(.*)\s*$/)) {
+        else if ((matches = line.match(/^@([^\s:@][^:]*)\s*:\s*(.*)\s*$/))) {
             // New property
             state.newkey = matches[1];
             state.onewkey = state.newkey;

package/lib/readers/phillipsEroll.d.ts

@@ -1,6 +1,6 @@
-import { RollCopy } from "../RollCopy.js";
-import { TrackerBar } from "../TrackerBar.js";
-import { Millimeters, Seconds } from "../Quantity.js";
+import { RollCopy } from "../model/RollCopy.js";
+import { TrackerBar } from "../systems/TrackerBar.js";
+import { Millimeters, Seconds } from "../model/Quantity.js";
 /**
  * Peter Phillips's "e-roll" file, the unprocessed output of his
  * pneumatic roll reader (thesis pp. 182–196): the roll runs over a

package/lib/readers/phillipsEroll.js

@@ -1,11 +1,11 @@
 import { read } from "midifile-ts";
 import { v4 } from "uuid";
-import { assignObject } from "../Assumption.js";
-import { systemOf } from "../TrackerBar.js";
-import { shortenChains } from "../alignment.js";
+import { assignObject } from "../model/Assumption.js";
+import { systemOf } from "../systems/TrackerBar.js";
+import { shortenChains } from "../collation/alignment.js";
 import { welteT100 } from "../systems/welteT100/bar.js";
 import { welteLicensee } from "../systems/welteLicensee/bar.js";
-import { inMetersPerMinute, mm, seconds, track } from "../Quantity.js";
+import { inMetersPerMinute, mm, seconds, track } from "../model/Quantity.js";
 /**
  * Peter Phillips's "e-roll" file, the unprocessed output of his
  * pneumatic roll reader (thesis pp. 182–196): the roll runs over a
@@ -166,7 +166,6 @@ export function readFromPhillipsEroll(buffer, { system = welteT100, controlOffse
     const copy = {
         type: 'RollCopy',
         id: v4(),
-        ops: [],
         conditions: [],
         measurements: {},
         production: { system: systemOf(system), produced: features },

package/lib/readers/spencerBar.d.ts

@@ -1,5 +1,5 @@
-import { PaperSpeed, RollCopy } from "../RollCopy.js";
-import { TrackerBar } from "../TrackerBar.js";
+import { PaperSpeed, RollCopy } from "../model/RollCopy.js";
+import { TrackerBar } from "../systems/TrackerBar.js";
 /**
  * Rows of the image on an inch of paper. The player reads eight rows a
  * second per unit of roll tempo (tempo 80 comes with a sample rate of

package/lib/readers/spencerBar.js

@@ -1,7 +1,7 @@
 import { v4 } from "uuid";
-import { systemOf } from "../TrackerBar.js";
+import { systemOf } from "../systems/TrackerBar.js";
 import { welteLicensee } from "../systems/welteLicensee/bar.js";
-import { feetPerMinute, inMillimeters, px, track } from "../Quantity.js";
+import { feetPerMinute, inMillimeters, px, track } from "../model/Quantity.js";
 /**
  * Spencer Chase's e-roll file (`.bar`, "eRoll Tracker Bar Image") holds
  * a roll as a list of events: a distance in rows of the scanned image,
@@ -111,7 +111,6 @@ export function readFromSpencerBar(buffer, { rowsPerInch = SPENCER_ROWS_PER_INCH
     return {
         type: 'RollCopy',
         id: v4(),
-        ops: [],
         conditions: [],
         measurements: {},
         production: { system: systemOf(system), produced: features },

package/lib/readers/stanfordAton.d.ts

@@ -1,6 +1,6 @@
-import { RollCopy } from "../RollCopy.js";
-import { TrackerBar } from "../TrackerBar.js";
-import { Track } from "../Quantity.js";
+import { RollCopy } from "../model/RollCopy.js";
+import { TrackerBar } from "../systems/TrackerBar.js";
+import { Track } from "../model/Quantity.js";
 export interface StanfordAtonOptions {
     /**
      * Added to the scanning software's hole numbering to reach the

package/lib/readers/stanfordAton.js

@@ -1,8 +1,8 @@
 import { v4 } from "uuid";
 import { AtonParser } from "./AtonParser.js";
-import { systemOf } from "../TrackerBar.js";
+import { systemOf } from "../systems/TrackerBar.js";
 import { welteT100 } from "../systems/welteT100/bar.js";
-import { inMillimeters, mean, mm, pixelsPerInch, px, subtract, track } from "../Quantity.js";
+import { inMillimeters, mean, mm, pixelsPerInch, px, subtract, track } from "../model/Quantity.js";
 /** Values in these files carry their unit as a suffix, e.g. "37.7646px". */
 const readPx = (value) => px(parseFloat(value));
 /** The parser writes one record as an object and several as an array. */
@@ -155,7 +155,6 @@ export function readFromStanfordAton(atonString, { trackShift, system = welteT10
     return {
         type: 'RollCopy',
         id: v4(),
-        ops: [],
         conditions: [],
         production: {
             system: systemOf(system),
@@ -164,7 +163,6 @@ export function readFromStanfordAton(atonString, { trackShift, system = welteT10
                     type: 'Perforator',
                     id: `perforator_${v4()}`,
                     condition: {
-                        type: 'ConditionState',
                         conditionType: 'setting',
                         punchDiameter: { value: punchDiameter, unit: 'mm' }
                     }