@triiiceratops/plugin-annotation-editor 1.0.0-rc.7 → 1.0.0

package/dist/editableShape.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Reading a persisted annotation's geometry back out for editing, and writing
+ * an edited geometry back in — the inverse of the target the drawing layer
+ * builds when it commits a new shape.
+ *
+ * Pure functions over the W3C structure, so the round trip is asserted without
+ * a browser. Everything is CANVAS space, the space the store deals in.
+ */
+import type { W3CAnnotation, W3CSelector } from './adapters/types';
+import { type Point, type Rect } from './geometry';
+/**
+ * The geometry a shape edits as. A rectangle, a polygon and a point are the
+ * three this editor writes: an ellipse is drawn as a bounding box and persisted
+ * as a polygon, so it comes back as the polygon it is and edits by its
+ * vertices.
+ */
+export type EditableGeometry = {
+    kind: 'rect';
+    rect: Rect;
+} | {
+    kind: 'polygon';
+    points: Point[];
+} | {
+    kind: 'point';
+    point: Point;
+};
+/** A persisted shape reduced to the canvas it is on and its canvas-space geometry. */
+export interface EditableShape {
+    canvasId: string;
+    geometry: EditableGeometry;
+}
+/**
+ * The geometry to open for editing, or `null` when this annotation has none
+ * this editor can offer control points on — a whole-canvas target, which has no
+ * geometry at all, or a shape whose target it does not model.
+ *
+ * `null` is load-bearing rather than merely defensive: the caller suppresses
+ * core's own rendering of whatever it opens, so an annotation it cannot draw
+ * must not be opened at all — suppressed and undrawn reads to the reader as
+ * data loss.
+ */
+export declare function editableShape(annotation: W3CAnnotation): EditableShape | null;
+/**
+ * The same annotation with its geometry replaced. Every other field — bodies,
+ * host-specific properties, the selector's own extra keys — is carried through,
+ * because an edit to the geometry must not be a rewrite of the record.
+ *
+ * The selector KIND is carried through too: an edited rectangle stays a
+ * fragment and an edited polygon stays an `SvgSelector`, so nothing changes
+ * representation behind the reader's back.
+ */
+export declare function withEditedGeometry(annotation: W3CAnnotation, geometry: EditableGeometry): W3CAnnotation;
+/**
+ * The selector a geometry is persisted as — the write half of
+ * {@link readGeometry}, and the one place a NEW annotation's target kind is
+ * decided.
+ *
+ * The geometry's kind is the whole decision: a box is a media fragment, an
+ * outline is an `SvgSelector`, a point is a `PointSelector`. An ellipse has
+ * already become the polygon inscribed in its box by the time it arrives here,
+ * which is why there is no fourth arm (ADR 0022).
+ */
+export declare function selectorForGeometry(geometry: EditableGeometry): W3CSelector;
+/**
+ * Whether a geometry is large enough to persist — the minimum-size guard on a
+ * COMMITTED shape, applied to whatever box the geometry spans. A point is
+ * exempt: it has no extent to fall below the threshold.
+ */
+export declare function isCommittableGeometry(geometry: EditableGeometry): boolean;

package/dist/geometry.d.ts

@@ -0,0 +1,310 @@
+/**
+ * Projection between the viewer's screen space and a canvas's own coordinate
+ * space, for the shapes the drawing layer commits.
+ *
+ * Pure functions only — no Svelte, no DOM. The caller supplies the projection
+ * as a callback (core's `screenToCanvas` / `canvasToScreen` bound to a canvas
+ * id), so every geometric claim here is asserted without a browser (story 42).
+ */
+import type { EditableGeometry } from './editableShape';
+export interface Point {
+    x: number;
+    y: number;
+}
+export interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * Maps a point from one space to the other, or `null` when the viewer cannot
+ * answer for the canvas asked about — core's coordinate helpers return `null`
+ * rather than a point belonging to a different canvas.
+ */
+export type ProjectPoint = (point: Point) => Point | null;
+/**
+ * The smallest region, in CANVAS pixels, that may become an annotation.
+ *
+ * Canvas pixels rather than screen pixels because the shape is persisted in
+ * canvas space: the same drag at 8× zoom and at fit zoom must be judged the same
+ * way, and only the canvas-space extent is invariant across the zoom the reader
+ * happens to be at. Four is above the two-pixel hand jitter this guard exists to
+ * discard (story 7), and far below any region a reader would deliberately draw
+ * on a folio-sized canvas — a IIIF canvas of a manuscript page runs to thousands
+ * of units across, so four of them are a smudge, not a feature.
+ */
+export declare const MIN_SHAPE_SIZE_CANVAS_PX = 4;
+/** The media-fragment profile a `FragmentSelector`'s `xywh=` conforms to. */
+export declare const MEDIA_FRAGMENT_CONFORMS_TO = "http://www.w3.org/TR/media-frags/";
+/**
+ * The axis-aligned box two corners span, in whichever order they were given —
+ * a drag up-and-left describes the same region as the same drag reversed.
+ */
+export declare function normaliseRect(from: Point, to: Point): Rect;
+/**
+ * The canvas-space box a screen-space drag describes.
+ *
+ * Both corners are projected before they are normalised, so the result is the
+ * box in the canvas's own coordinates whatever the viewport's zoom and pan are.
+ * `null` when either corner does not project — the drag then belongs to no
+ * canvas and nothing may be committed from it.
+ */
+export declare function screenDragToCanvasRect(from: Point, to: Point, toCanvas: ProjectPoint): Rect | null;
+/**
+ * Whether a committed region is large enough to persist
+ * ({@link MIN_SHAPE_SIZE_CANVAS_PX}). A validity check on a finished shape, not
+ * gesture recognition: the armed tool already decided the gesture was a drag.
+ */
+export declare function isDrawableRect(rect: Rect): boolean;
+/**
+ * A canvas-space rect as a media-fragment `xywh=` value.
+ *
+ * Rounded to whole canvas pixels — the unit a IIIF canvas is expressed in, and
+ * what every reader of the fragment (core's own target parser included) treats
+ * the numbers as. Edges are rounded rather than origin-plus-size so a rect never
+ * grows or shrinks by a pixel more than the rounding of its own edges.
+ */
+export declare function fragmentSelectorValue(rect: Rect): string;
+/**
+ * A canvas-space point snapped to whole canvas pixels — the unit a
+ * `PointSelector`'s `x`/`y` are written in (ADR 0004). Floats were rejected as
+ * spurious precision that diffs noisily and diverges from the published IIIF
+ * examples, so this is the only rounding a point ever gets.
+ */
+export declare function canvasPixelPoint(point: Point): Point;
+/**
+ * The canvas pixel a screen point names — the point tool's ENTIRE geometry, a
+ * single click with no extent and so no minimum-size guard to pass.
+ *
+ * The rounding happens once, here, on the projected canvas point. Rounding an
+ * intermediate space instead — the screen point the pointer reported, or an
+ * image-space step on the way — lands on a different canvas pixel wherever the
+ * canvas is larger in its own coordinates than it is on screen, which is every
+ * zoom below 1:1. `null` when the point projects to no canvas.
+ */
+export declare function screenPointToCanvasPixel(point: Point, toCanvas: ProjectPoint): Point | null;
+/**
+ * The screen-space box a canvas-space rect currently occupies, for the live
+ * preview — recomputed whenever the viewport moves. `null` when the rect's
+ * canvas is not one the renderer is placing.
+ */
+export declare function canvasRectToScreenRect(rect: Rect, toScreen: ProjectPoint): Rect | null;
+/** Whether a rect contains a point, edges included. */
+export declare function rectContainsPoint(rect: Rect, point: Point): boolean;
+/**
+ * The control points a bounding-box shape offers: four corners and four edge
+ * midpoints, named by compass direction so a handle's id says which edges it
+ * moves — `'nw'` moves the north and west edges, `'n'` only the north one.
+ *
+ * A polygon's control points are its vertices instead, identified by index, so
+ * a handle's id is whatever names the thing it moves.
+ */
+export type HandleId = 'nw' | 'n' | 'ne' | 'e' | 'se' | 's' | 'sw' | 'w';
+/**
+ * The one control point a point annotation offers. Editing a point is moving
+ * it, so its handle and its geometry are the same thing — but it goes through
+ * the same {@link handleAtPoint} test as every other control point rather than
+ * being a parallel mechanism.
+ */
+export declare const POINT_HANDLE_ID = "point";
+export type PointHandleId = typeof POINT_HANDLE_ID;
+export declare const HANDLE_IDS: readonly HandleId[];
+/**
+ * Whether a control-point id names a bounding box's compass edge, as opposed to
+ * a polygon vertex's index or a point's single handle. The three share one drag
+ * and one hit test, so the id is what says which shape's maths to run.
+ */
+export declare function isHandleId(id: unknown): id is HandleId;
+/**
+ * How far, in SCREEN pixels, a pointer may be from a handle's centre and still
+ * reach it — half of a comfortable touch target rather than the handle's drawn
+ * size, so a handle is grabbable slightly beyond the dot the reader sees.
+ *
+ * Screen pixels because it describes the reader's aim, which does not change
+ * with the zoom: the same finger has to hit the same handle at fit zoom and at
+ * 8×.
+ */
+export declare const HANDLE_HIT_RADIUS = 12;
+/**
+ * A control point on screen. Generic over what identifies it: a compass edge
+ * for a bounding box, a vertex index for a polygon. Both go through the same
+ * hit test, so nearest-centre-wins is decided in one place for every shape.
+ */
+export interface Handle<Id = HandleId> {
+    id: Id;
+    x: number;
+    y: number;
+}
+/** The eight control points of a rect, in whatever space the rect is in. */
+export declare function rectHandles(rect: Rect): Handle[];
+/**
+ * The handle a screen point reaches, or `null` when it reaches none.
+ *
+ * Nearest centre wins rather than first match, which is the whole reason this
+ * is a function and not the DOM's own hit testing: on a small shape the corner
+ * and edge handles overlap, and document order would answer with whichever was
+ * rendered last rather than with the one under the pointer. Handles are still
+ * real focusable elements — they simply do not take the pointer events, so that
+ * this decision is made in one place and can be asserted without a browser.
+ */
+export declare function handleAtPoint<Id>(handles: readonly Handle<Id>[], point: Point, radius?: number): Id | null;
+/**
+ * The rect a handle dragged to `to` describes. The dragged handle's own edges
+ * follow the pointer and the opposite ones stay put; a drag past the opposite
+ * edge flips the rect rather than producing a negative extent.
+ */
+export declare function resizeRect(rect: Rect, handle: HandleId, to: Point): Rect;
+/** The same rect translated — a move never changes width or height. */
+export declare function moveRect(rect: Rect, delta: Point): Rect;
+/** A rect grown by `by` on every side, for a box that must contain its handles. */
+export declare function inflateRect(rect: Rect, by: number): Rect;
+/**
+ * The rect a media-fragment `xywh=` value names — the read half of
+ * {@link fragmentSelectorValue}. `null` for anything that is not a spatial
+ * fragment, a temporal `t=` included.
+ */
+export declare function parseFragmentRect(value: unknown): Rect | null;
+/**
+ * How many vertices an ellipse's inscribed polygon carries.
+ *
+ * 64 rather than the more common 32 because this viewer is a deep-zoom one: at
+ * the magnifications a reader reaches on a folio, a 32-gon's facets are visibly
+ * flat straight edges rather than a curve. Do not lower it — the cost is 64
+ * coordinate pairs in a selector, and the benefit is the shape still reading as
+ * an ellipse at 8×.
+ */
+export declare const ELLIPSE_VERTEX_COUNT = 64;
+/** The fewest vertices a closed region can have. */
+export declare const MIN_POLYGON_VERTICES = 3;
+/**
+ * The polygon inscribed in a bounding box: {@link ELLIPSE_VERTEX_COUNT} vertices
+ * on the ellipse the box circumscribes, starting due east and winding clockwise
+ * on screen (y grows downward).
+ *
+ * This is the ellipse tool's ENTIRE output. Nothing downstream records that the
+ * polygon was drawn as an ellipse: core's projector has three geometries and its
+ * SVG parser already degrades `<ellipse>` into points on read, so an ellipse
+ * that persisted as one would lose fidelity on every round trip.
+ */
+export declare function ellipseVertices(rect: Rect): Point[];
+/** The axis-aligned box a set of points spans; `null` for no points. */
+export declare function polygonBounds(points: readonly Point[]): Rect | null;
+/**
+ * A closed polygon as an `SvgSelector` value, in the canvas's own coordinates.
+ *
+ * `<polygon>` inside a root `<svg>`, which is what core's selector parser reads
+ * — it runs `DOMParser` over the value and collects `points` attributes, so a
+ * bare `<polygon>` with no root element would not parse.
+ */
+export declare function svgPolygonValue(points: readonly Point[]): string;
+/**
+ * The vertices an `SvgSelector` value names — the read half of
+ * {@link svgPolygonValue}. `null` for anything this editor did not write:
+ * curves, multiple shapes, or too few points to close a region.
+ *
+ * Deliberately narrower than core's parser, which approximates `<circle>`,
+ * `<rect>` and `<path>` too. Core degrades those to draw them; this editor
+ * would have to WRITE the degraded form back, silently replacing the author's
+ * shape, so it declines to open them at all.
+ */
+export declare function parseSvgPolygon(value: unknown): Point[] | null;
+/** A point's single handle, at the point itself. */
+export declare function pointHandles(point: Point): Handle<PointHandleId>[];
+/** The polygon's vertices as handles, each identified by its own index. */
+export declare function polygonHandles(points: readonly Point[]): Handle<number>[];
+/** The same polygon with one vertex moved; every other vertex stays put. */
+export declare function moveVertex(points: readonly Point[], index: number, to: Point): Point[];
+/** The same polygon translated — a move never reshapes the outline. */
+export declare function movePolygon(points: readonly Point[], delta: Point): Point[];
+/** The same polygon with `at` spliced in before vertex `index`. */
+export declare function insertVertex(points: readonly Point[], index: number, at: Point): Point[];
+/**
+ * The same polygon without vertex `index`, or `null` when removing it would
+ * leave fewer than {@link MIN_POLYGON_VERTICES} — a two-vertex ring is a line
+ * segment, which is not a region and which core's parser would close into one
+ * anyway.
+ */
+export declare function removeVertex(points: readonly Point[], index: number): Point[] | null;
+/**
+ * Where a new vertex belongs for a point pressed on the outline: the index to
+ * insert BEFORE, chosen as the end of the closest edge, so the inserted vertex
+ * lands between the two it was dragged out from.
+ */
+export declare function nearestEdgeInsertIndex(points: readonly Point[], point: Point): number;
+/**
+ * Whether a point is inside a closed polygon, by crossing count. Used to decide
+ * whether a press moves the whole shape, so a press in the concave notch of an
+ * outline must not count as inside it — which is exactly what testing the
+ * bounding box instead would get wrong.
+ */
+export declare function polygonContainsPoint(points: readonly Point[], point: Point): boolean;
+/**
+ * The two nudge steps, in CANVAS pixels.
+ *
+ * Canvas space rather than screen space so a nudge means the same thing at
+ * every zoom: a reader who moves a vertex one step at fit zoom and one step at
+ * 8× has moved it the same distance across the folio, which is the distance the
+ * annotation records. A step in screen pixels would shrink as the reader zoomed
+ * in — the opposite of what precision work wants.
+ *
+ * One canvas pixel is the finest adjustment a canvas-space geometry can carry;
+ * ten crosses a folio-sized canvas in a few hundred presses rather than a few
+ * thousand.
+ */
+export declare const NUDGE_STEP_CANVAS_PX = 1;
+export declare const NUDGE_LARGE_STEP_CANVAS_PX = 10;
+/**
+ * The canvas-space delta an arrow key describes, or `null` for a key that is
+ * not an arrow — which is what tells the caller to leave the event alone so it
+ * reaches whatever else wants it.
+ */
+export declare function nudgeDelta(key: string, large: boolean): Point | null;
+export declare function translatePoint(point: Point, delta: Point): Point;
+/**
+ * How much of the visible box a keyboard-placed default shape spans.
+ *
+ * A fraction of the CURRENT view rather than a fixed canvas-space size: a
+ * default shape has to be visible and grabbable at whatever zoom the reader is
+ * at, and a fixed canvas extent is either a speck at fit zoom or larger than
+ * the screen at 8×. The reader then sizes it with the ordinary nudge verbs,
+ * which are in canvas space because they are adjustments to a stored geometry.
+ */
+export declare const DEFAULT_SHAPE_VIEW_FRACTION = 0.25;
+/** The box of the given extent centred on a point. */
+export declare function centredRect(centre: Point, width: number, height: number): Rect;
+/**
+ * The default triangle inscribed in a box: apex at the top edge's midpoint,
+ * then the two bottom corners, winding clockwise on screen like
+ * {@link ellipseVertices}.
+ *
+ * The polygon tool's keyboard start. Three vertices because that is the fewest
+ * a region can have ({@link MIN_POLYGON_VERTICES}), so every vertex the reader
+ * then adds is one they asked for.
+ */
+export declare function triangleVertices(rect: Rect): Point[];
+/**
+ * The same polygon with a vertex added just after `index`, at the midpoint of
+ * the edge running from it to the next one — so the new vertex is on the
+ * outline the reader can see, and lands at `index + 1`.
+ *
+ * The keyboard's counterpart to the pointer's insert, which takes the position
+ * from where the reader double-clicked. A keyboard user has no such position,
+ * so the edge's midpoint is the one unambiguous point on it.
+ */
+export declare function insertVertexAfter(points: readonly Point[], index: number): Point[] | null;
+/**
+ * Whether two geometries name the same shape, so a commit can refuse to write
+ * one that has not changed.
+ *
+ * Kinds never compare equal across each other: an edit cannot turn a rect into
+ * a polygon, so a mismatch here is two different shapes rather than two
+ * spellings of one.
+ *
+ * A point compares at whole canvas pixels, because that IS a point's geometry
+ * — {@link canvasPixelPoint} is the only resolution a `PointSelector` is ever
+ * written at (ADR 0004), and the raw projection of a pointer resting on a
+ * stored point lands somewhere inside the pixel it already occupies. Rects and
+ * polygons compare exactly, on the coordinates the caller holds.
+ */
+export declare function geometriesEqual(a: EditableGeometry, b: EditableGeometry): boolean;

package/dist/icons.d.ts

@@ -3,9 +3,8 @@
  *
  * `ICON` is the toolbar glyph descriptor produced by the SDK's `svgIcon` — core
  * owns the rendered `<svg>` wrapper (sizing, `currentColor`, a11y). `GLYPHS` are
- * the raw inner-SVG strings the Svelte panel renders inline via `{@html}` (the
- * panel used core's internal `Icon` component before the migration; the glyphs
- * are the same @phosphor-icons/core paths, on the 256×256 viewBox).
+ * the raw inner-SVG strings the Svelte panel renders inline via `{@html}`
+ * (@phosphor-icons/core paths, on the 256×256 viewBox).
  */
 import { type IconDescriptor } from '@triiiceratops/plugin-sdk';
 /** Shared phosphor viewBox for every glyph below. */
@@ -16,11 +15,13 @@ export declare const GLYPHS: {
     readonly Warning: "<path d=\"M236.8,188.09,149.35,36.22h0a24.76,24.76,0,0,0-42.7,0L19.2,188.09a23.51,23.51,0,0,0,0,23.72A24.35,24.35,0,0,0,40.55,224h174.9a24.35,24.35,0,0,0,21.33-12.19A23.51,23.51,0,0,0,236.8,188.09ZM222.93,203.8a8.5,8.5,0,0,1-7.48,4.2H40.55a8.5,8.5,0,0,1-7.48-4.2,7.59,7.59,0,0,1,0-7.72L120.52,44.21a8.75,8.75,0,0,1,15,0l87.45,151.87A7.59,7.59,0,0,1,222.93,203.8ZM120,144V104a8,8,0,0,1,16,0v40a8,8,0,0,1-16,0Zm20,36a12,12,0,1,1-12-12A12,12,0,0,1,140,180Z\"/>";
     readonly X: "<path d=\"M205.66,194.34a8,8,0,0,1-11.32,11.32L128,139.31,61.66,205.66a8,8,0,0,1-11.32-11.32L116.69,128,50.34,61.66A8,8,0,0,1,61.66,50.34L128,116.69l66.34-66.35a8,8,0,0,1,11.32,11.32L139.31,128Z\"/>";
     readonly Rectangle: "<path d=\"M216,40H40A16,16,0,0,0,24,56V200a16,16,0,0,0,16,16H216a16,16,0,0,0,16-16V56A16,16,0,0,0,216,40Zm0,160H40V56H216V200Z\"/>";
+    readonly Ellipse: "<path d=\"M128,40c-30.63,0-59.4,7.3-81,20.56C24.05,74.7,11.42,94.06,11.42,115.2v25.6c0,21.14,12.63,40.5,35.58,54.64C68.6,208.7,97.37,216,128,216s59.4-7.3,81-20.56c22.95-14.14,35.58-33.5,35.58-54.64V115.2c0-21.14-12.63-40.5-35.58-54.64C187.4,47.3,158.63,40,128,40Zm0,16c56.24,0,100.58,27.1,100.58,59.2S184.24,174.4,128,174.4,27.42,147.3,27.42,115.2,71.76,56,128,56Z\"/>";
     readonly Polygon: "<path d=\"M230.64,49.36a32,32,0,0,0-45.26,0h0a31.9,31.9,0,0,0-5.16,6.76L152,48.42A32,32,0,0,0,97.37,25.36h0a32.06,32.06,0,0,0-5.76,37.41L57.67,93.32a32.05,32.05,0,0,0-40.31,4.05h0a32,32,0,0,0,42.89,47.41l70,51.36a32,32,0,1,0,47.57-14.69l27.39-77.59q1.38.12,2.76.12a32,32,0,0,0,22.63-54.62Zm-122-12.69h0a16,16,0,1,1,0,22.64A16,16,0,0,1,108.68,36.67Zm-80,94.65a16,16,0,0,1,0-22.64h0a16,16,0,1,1,0,22.64Zm142.65,88a16,16,0,0,1-22.63-22.63h0a16,16,0,1,1,22.63,22.63Zm-8.55-43.18a32,32,0,0,0-23,7.08l-70-51.36a32.17,32.17,0,0,0-1.34-26.65l33.95-30.55a32,32,0,0,0,45.47-10.81L176,71.56a32,32,0,0,0,14.12,27Zm56.56-92.84A16,16,0,1,1,196.7,60.68h0a16,16,0,0,1,22.63,22.63Z\"/>";
     readonly Target: "<path d=\"M221.87,83.16A104.1,104.1,0,1,1,195.67,49l22.67-22.68a8,8,0,0,1,11.32,11.32l-96,96a8,8,0,0,1-11.32-11.32l27.72-27.72a40,40,0,1,0,17.87,31.09,8,8,0,1,1,16-.9,56,56,0,1,1-22.38-41.65L184.3,60.39a87.88,87.88,0,1,0,23.13,29.67,8,8,0,0,1,14.44-6.9Z\"/>";
     readonly ArrowCounterClockwise: "<path d=\"M224,128a96,96,0,0,1-94.71,96H128A95.38,95.38,0,0,1,62.1,197.8a8,8,0,0,1,11-11.63A80,80,0,1,0,71.43,71.39a3.07,3.07,0,0,1-.26.25L44.59,96H72a8,8,0,0,1,0,16H24a8,8,0,0,1-8-8V56a8,8,0,0,1,16,0V85.8L60.25,60A96,96,0,0,1,224,128Z\"/>";
     readonly ArrowClockwise: "<path d=\"M240,56v48a8,8,0,0,1-8,8H184a8,8,0,0,1,0-16H211.4L184.81,71.64l-.25-.24a80,80,0,1,0-1.67,114.78,8,8,0,0,1,11,11.63A95.44,95.44,0,0,1,128,224h-1.32A96,96,0,1,1,195.75,60L224,85.8V56a8,8,0,1,1,16,0Z\"/>";
     readonly Trash: "<path d=\"M216,48H176V40a24,24,0,0,0-24-24H104A24,24,0,0,0,80,40v8H40a8,8,0,0,0,0,16h8V208a16,16,0,0,0,16,16H192a16,16,0,0,0,16-16V64h8a8,8,0,0,0,0-16ZM96,40a8,8,0,0,1,8-8h48a8,8,0,0,1,8,8v8H96Zm96,168H64V64H192ZM112,104v64a8,8,0,0,1-16,0V104a8,8,0,0,1,16,0Zm48,0v64a8,8,0,0,1-16,0V104a8,8,0,0,1,16,0Z\"/>";
+    readonly WholeCanvas: "<path d=\"M216,40H40A16,16,0,0,0,24,56V200a16,16,0,0,0,16,16H216a16,16,0,0,0,16-16V56A16,16,0,0,0,216,40Zm0,160H40V56H216V200ZM168,112a8,8,0,0,1-8,8H96a8,8,0,0,1,0-16h64A8,8,0,0,1,168,112Zm0,32a8,8,0,0,1-8,8H96a8,8,0,0,1,0-16h64A8,8,0,0,1,168,144Z\"/>";
     readonly Plus: "<path d=\"M224,128a8,8,0,0,1-8,8H136v80a8,8,0,0,1-16,0V136H40a8,8,0,0,1,0-16h80V40a8,8,0,0,1,16,0v80h80A8,8,0,0,1,224,128Z\"/>";
     readonly Check: "<path d=\"M229.66,77.66l-128,128a8,8,0,0,1-11.32,0l-56-56a8,8,0,0,1,11.32-11.32L96,188.69,218.34,66.34a8,8,0,0,1,11.32,11.32Z\"/>";
 };

package/dist/identity.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This plugin's identity, in one place.
+ *
+ * The version reaches consumers as the plugin's declared identity, and writing
+ * it out at the `definePlugin` site is how it drifted from the package.
+ */
+export declare const PLUGIN_META: {
+    readonly name: "@triiiceratops/plugin-annotation-editor";
+    readonly version: "1.0.0";
+};