efficient-easel 0.0.0 → 0.97.0

package/dist/icons/index.js

@@ -0,0 +1 @@
+export{AccentIcon,AccountIcon,AddIcon,AlignCenterIcon,AlignLeftIcon,AlignRightIcon,AlignSeparateIcon,AnchorIcon,AnimationIcon,BackgroundIcon,BellIcon,BlackAndWhiteIcon,BlockBadgeIcon,BlockBannerIcon,BlockBoxIcon,BlockButtonIcon,BlockColumnIcon,BlockCouponIcon,BlockDividerIcon,BlockFooterIcon,BlockHeadingIcon,BlockIncludedListIcon,BlockLayeredImagesIcon,BlockProductIcon,BlockSectionIcon,BlockSocialIcon,BlockSpacerIcon,BlockTextIcon,BlockVideoIcon,BlogPostIcon,BoldIcon,BreadcrumbIcon,ButtonArrowIcon,ButtonIcon,CarIcon,CartIcon,CaseIcon,CategoryIcon,ChatIcon,CheckIcon,ChevronIcon,ClearMarksIcon,ClockIcon,CloseIcon,ColumnGapIcon,ColumnWidthsIcon,ColumnsIcon,ContrastIcon,CopyIcon,CopyStyleIcon,CopyToPageIcon,CornerIcon,DesktopIcon,DiagramIcon,DirectionDownIcon,DirectionIcon,DirectionLeftIcon,DirectionRightIcon,DirectionUpIcon,DollarIcon,DragIcon,DropIcon,DuplicateIcon,EmphasisIcon,ExternalIcon,EyeIcon,EyeOffIcon,FinishIcon,FullWidthIcon,GapIcon,GlobeIcon,GridIcon,GroundIcon,HashIcon,HeadquartersIcon,HeightIcon,HoverIcon,ImageIcon,ItalicIcon,LayersIcon,LayoutIcon,LetterSpacingIcon,LineBetweenIcon,LineStyleIcon,LinkIcon,ListIcon,LocationIcon,LockIcon,LogoIcon,MediaIcon,MenuIcon,MetaIcon,MoveDownIcon,MoveUpIcon,NoteIcon,NudgeIcon,OpacityIcon,OwnTextIcon,PaddingBottomIcon,PaddingLeftIcon,PaddingRightIcon,PaddingTopIcon,PaddingXIcon,PaddingYIcon,PageIcon,PasteIcon,PasteStyleIcon,PhoneIcon,PlacementIcon,PlayIcon,PlusMinusIcon,ProductFieldIcon,ProductSizeIcon,QuietIcon,RadiusIcon,RedoIcon,RenameIcon,RevertIcon,RotateIcon,ScrollPointIcon,SearchIcon,SendIcon,SettingsIcon,ShadowIcon,SitemapIcon,SortIcon,SpecTableIcon,SquareIcon,StateIcon,StickyIcon,StrikeIcon,StylesIcon,TabletIcon,TabsIcon,TagIcon,TemplateIcon,TextColorIcon,TextLinesIcon,TextSizeIcon,TextSmallIcon,ThemeIcon,TitleIcon,TrashIcon,TriggerIcon,TypeIcon,UnderlineIcon,UndoIcon,VAlignIcon,WarningIcon,WeightIcon,WheelIcon,WidthIcon,WordsFromIcon,WrapIcon,iconMeanings}from"../chunk-YNZZYHA4.js";

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { EditorRail, EditorRailButton, RailTokens, railCssVars, railTokens } from './rail/index.js';
+export { AddIcon, LayersIcon, MediaIcon, PageIcon as PagesIcon, IconProps as RailIconProps, SitemapIcon, StylesIcon } from './icons/index.js';
+export { W as WordFit } from './wordFit-9B9nqyf3.js';
+export { E as EditorRailButtonProps, a as EditorRailItem, b as EditorRailOrientation, c as EditorRailProps } from './types-DNrn_w4V.js';
+export { ShellTokens, shellCssVars, shellTokens } from './shell/index.js';
+import 'react';

package/dist/index.js

@@ -0,0 +1 @@
+import"./chunk-OWBO4WKA.js";export{shellCssVars,shellTokens}from"./chunk-FI23ALVJ.js";export{EditorRail,EditorRailButton,railCssVars,railTokens}from"./chunk-YIMRTIBN.js";import"./chunk-2OAZYSWJ.js";import"./chunk-BZ5ASXOL.js";export{AddIcon,LayersIcon,MediaIcon,PageIcon as PagesIcon,SitemapIcon,StylesIcon}from"./chunk-YNZZYHA4.js";

package/dist/markup/index.d.ts

@@ -0,0 +1,452 @@
+/**
+ * The editorial markup rule — ONE grammar, shared by every product that lets a
+ * human type formatted copy into a plain text box.
+ *
+ * WHO OWNS IT. This package does (efficient-easel; `efficient-editor` until 0.95.0, `editor-shell` until 0.66.0), since 2026-09-28. Until then the rule lived in
+ * `efficient-shell/markup`, a package Victor owns, and this package only imported
+ * it. Lewis decided to keep our own copy rather than wait on upstream for the
+ * rich text box: "Two copies is fine. We use our own independent one." This
+ * file started from efficient-shell 4.121.0 (the same file as the 4.101.0 and
+ * 4.120.0 the apps pin, bar one spelling) and grows here from now on. The two
+ * copies are expected to drift; nothing in either product reads both.
+ *
+ * FRAMEWORK-FREE, behind its own subpath (`efficient-easel/markup`): no React, no
+ * JSX, no DOM, no imports at all. The public storefront reads it, and the
+ * backend's banner renderer may one day port it, so it must stay a few hundred
+ * bytes of plain code that any bundler or resolver can load.
+ *
+ * WHAT IS SHARED IS THE RULE, NOT THE RENDERING. Each product renders the tree
+ * its own way, because it must: the web uses CSS classes bound to theme tokens,
+ * email must inline every style (mail clients drop classes). Two renderers, one
+ * grammar, one writer ({@link applyMark}) — so a toolbar button and a parser
+ * can never disagree about what a delimiter means.
+ *
+ * ## The delimiters
+ *
+ * Standard markdown, in every product:
+ *
+ *   **phrase**   bold
+ *   _phrase_     italic
+ *   ~~phrase~~   strikethrough
+ *   ==phrase==   highlight — the brand accent colour, applied to a selection
+ *   ^^phrase^^   quiet — smaller and softer
+ *
+ * THE THREE NAMES a merchant sees ({@link MARK_NAMES}, owner-approved
+ * 2026-09-28) sit on these marks: Strong is `**`, Emphasis is `==`, Quiet is
+ * `^^`. The storefront once had separate word-style marks for Emphasis and
+ * Strong, `@@phrase@@` and `++phrase++`. Production holds none of them, and no
+ * button writes them any more, but they are still READ — as Emphasis and Strong
+ * — so a string somebody pasted never prints its delimiters.
+ *
+ * And, read by {@link parseMarkup} (the tree a rich text box and a renderer
+ * use), in every product:
+ *
+ *   [words](href)  a link — safe addresses only ({@link isSafeLinkHref})
+ *   - words        a bullet line, one level
+ *   **a _b_ a**    one run inside another, one level
+ *
+ * EVERY READING IS LINE BY LINE: a run never crosses a line break. The email
+ * always read this way; the editor's painter and the storefront used to read
+ * the whole string, so the same saved text drew differently in each.
+ *
+ * Plus a per-product LEGACY set ({@link STOREFRONT_MARKUP} /
+ * {@link CAMPAIGN_MARKUP}) that keeps already-published copy rendering exactly
+ * as it does today. Those legacy rules are the only part of this grammar that is
+ * meant to be deleted: once stored content has been converted, drop the rule
+ * from the product's rule list and nothing else changes.
+ *
+ * ## Two deliberate delimiter choices
+ *
+ * 1. ITALIC IS `_phrase_`, NOT `*phrase*`. In the storefront and the campaign
+ *    designer a single asterisk already means the ACCENT colour, on 704 live
+ *    instances. Standard markdown says italic. Both cannot be true, so the
+ *    asterisk keeps its existing meaning and italic takes markdown's OTHER
+ *    italic marker. Nothing published moves.
+ * 2. `_` NEVER FIRES INSIDE A WORD. Without that guard, a mail merge line
+ *    holding `{{first_name}}` and `{{last_name}}` would italicise everything
+ *    between the two underscores. The guard is CommonMark's own rule for `_`
+ *    (an intraword underscore is literal) and it is checked with plain character
+ *    tests rather than a lookbehind, because a lookbehind is a parse error on
+ *    Safari below 16.4 and this code ships to a public storefront.
+ *
+ * ## One KNOWN divergence from the standard named above
+ *
+ * `__phrase__` IS ITALIC HERE. CommonMark reads a doubled underscore as STRONG;
+ * this grammar has a single `_` rule, so the outer pair matches, the inner
+ * underscores are ordinary characters, and `__all__` comes back as `_all_`.
+ *
+ * Left alone deliberately, and recorded rather than fixed. A census of stored
+ * copy found 14 rows in this shape and every one of them is the literal link
+ * key `__all__`, which no renderer is handed — so nothing published is being
+ * mis-drawn today. Adding a `__` rule to buy CommonMark parity would change how
+ * a stored `_` pair parses for the benefit of no existing string, and this
+ * module's promise is that the grammar grows while nothing published moves.
+ * Bold is `**phrase**` in every product; that is the form the toolbar writes
+ * and the form to reach for. Pinned by a test, so it stays a decision rather
+ * than becoming a discovery.
+ */
+/** A style a toolbar button can apply. The first six are inline marks; then
+ *  the composer-only affordances (a link and the three line prefixes), which
+ *  only a renderer that draws block content can honour; and `clear`, which
+ *  writes no mark at all — it takes them off ({@link clearMarks}). */
+type MarkStyle = 'bold' | 'italic' | 'strike' | 'code' | 'highlight' | 'quiet' | 'link' | 'bullet' | 'number' | 'quote' | 'clear';
+/** What a parsed run MEANS. `accent` is the storefront/campaign brand colour —
+ *  the legacy `*phrase*` — and `highlight` is its standard-markdown successor;
+ *  both resolve to the same paint, which is what makes converting stored copy
+ *  from one to the other invisible. */
+type InlineKind = 'text' | 'bold' | 'italic' | 'strike' | 'code' | 'highlight' | 'accent' | 'quiet';
+/**
+ * The words a press WRITES when nothing is selected — `**bold text**`, left
+ * selected so the next keystroke replaces it. English unless the caller of
+ * {@link applyMark} hands in its own (0.95.0: a host in another language).
+ * They are words put in the box, not rules: nothing here changes what parses.
+ */
+type MarkPlaceholders = Record<'bold' | 'italic' | 'strike' | 'code' | 'highlight' | 'quiet' | 'link', string>;
+declare const MARK_PLACEHOLDERS: MarkPlaceholders;
+interface WrapResult {
+    text: string;
+    /** Where the caret should land — inside the new marks, or after them. */
+    selectionStart: number;
+    selectionEnd: number;
+}
+/**
+ * Apply a style to `text[start:end]`, returning the new text and where the
+ * selection should sit. Toggling is deliberate: pressing Bold on already-bold
+ * text unwraps it, so the shortcut behaves like every other editor.
+ *
+ * Unwrapping only ever recognises the style's OWN fence. An italic button that
+ * also unwrapped `*phrase*` would silently strip an accent run in the storefront
+ * and the campaign designer, where the asterisk means colour, not slant.
+ */
+declare function applyMark(text: string, start: number, end: number, style: MarkStyle, rules?: readonly InlineRule[], placeholders?: MarkPlaceholders): WrapResult;
+/**
+ * True when `text[start:end]` is ALREADY wrapped in `style`'s own fence — the
+ * very test {@link applyMark} uses to decide that a press unwraps. So a button
+ * drawn as pressed is exactly a button whose press takes the mark off; the two
+ * cannot disagree. False for a style with no fence (a link, a line prefix).
+ */
+declare function markedAt(text: string, start: number, end: number, style: MarkStyle): boolean;
+/** A link as it sits in authored text: where it starts and ends, its words and
+ *  its address. */
+interface LinkSpan {
+    start: number;
+    end: number;
+    label: string;
+    href: string;
+}
+/**
+ * The link the caret or selection sits in — `[words](href)` covering all of
+ * `start..end` — or null. What the link button opens on: inside a link it edits
+ * that link, anywhere else it makes a new one.
+ *
+ * Read with the parser's own rule ({@link linkAt}), so a span this returns is
+ * exactly one the renderers draw as a link — an unsafe address is not a link
+ * and is not offered for editing as one.
+ */
+declare function findLink(text: string, start: number, end: number): LinkSpan | null;
+/**
+ * Make `text[start:end]` a link to `href`, or re-point the link it sits in.
+ * The caret lands after the link, selecting nothing: the link is finished.
+ *
+ * The words are the selection, or — with nothing selected — the address
+ * itself, so a merchant who pastes an address and presses Apply gets a link
+ * that reads as that address rather than a placeholder to type over.
+ *
+ * ⚠️ The address is the CALLER'S to check ({@link isSafeLinkHref}): one that
+ * fails would be written as plain text the renderers never draw as a link.
+ */
+declare function writeLink(text: string, start: number, end: number, href: string): WrapResult;
+/** Take a link off, keeping its words — selected, so a second press of the
+ *  link button puts it straight back. */
+declare function removeLink(text: string, link: LinkSpan): WrapResult;
+/**
+ * One toolbar button.
+ *
+ * - `label` is a text glyph, never a word, for a host that draws type (the
+ *   message composer). The copy box draws the icon set's glyph instead.
+ * - `name` is what the button is CALLED: its accessible name, and the first
+ *   word of its tooltip. Approved 2026-10-02: no word is drawn ON a button,
+ *   so a name lives here and in `title` and nowhere a merchant reads it as
+ *   part of the bar.
+ * - `title` is the tooltip: the name, what the mark writes, and the shortcut.
+ * - `shortcut` is the key the host combines with its platform modifier: a bare
+ *   letter (`'b'`), or `'shift+'` and a letter.
+ */
+interface MarkupTool {
+    style: MarkStyle;
+    label: string;
+    title: string;
+    name?: string;
+    shortcut?: string;
+}
+/** Every button, in the order a writer reaches for them. Clear is last: it
+ *  acts on every mark before it. */
+declare const MARKUP_TOOLS: readonly MarkupTool[];
+/**
+ * The names a merchant sees for the three styles that carry one, in both
+ * editors (owner-approved 2026-09-28). One word per idea: Strong IS bold
+ * (`**`, ⌘B) and Emphasis IS the highlight (`==`), so a toolbar that shows the
+ * names shows no separate B or ◆ beside them.
+ */
+declare const MARK_NAMES: {
+    readonly bold: "Strong";
+    readonly highlight: "Emphasis";
+    readonly quiet: "Quiet";
+};
+/** The tools a host shows, resolved to descriptors in {@link MARKUP_TOOLS}
+ *  order. Keeps a host from hand-rebuilding a descriptor (and drifting on a
+ *  tooltip) just to pick a subset. */
+declare function markupTools(styles: readonly MarkStyle[]): MarkupTool[];
+/**
+ * One delimited run. `open`/`close` are literal strings; a run's inner text may
+ * never contain the first character of `close`, which is what keeps this
+ * equivalent to the "asterisk, run of non-asterisks, asterisk" regexes the
+ * products used before — the same leftmost match, the same single close
+ * candidate, so today's stored copy parses exactly as it always has.
+ */
+interface InlineRule {
+    readonly open: string;
+    readonly close: string;
+    readonly kind: Exclude<InlineKind, 'text'>;
+    /** CommonMark's `_` rule: neither delimiter may touch a word character, so
+     *  `snake_case` and `{{first_name}}` stay literal. */
+    readonly wordBoundary?: boolean;
+    /**
+     * Characters that may not FOLLOW the close. A run whose closing delimiter
+     * butts up against one of these does not fire, and both delimiters stay
+     * literal.
+     *
+     * Two legacy rules need it, for the same reason: a delimiter that is also
+     * ordinary punctuation will otherwise claim text that was never markup. `#`
+     * must not pair across rank markers ("Ranked #1 and #2"), and `[` must not
+     * claim the label of a markdown link ("[terms](https://…)"), where the URL
+     * would be stranded outside the run and printed to the reader.
+     *
+     * A character SET rather than a flag per case, so the next collision is one
+     * more rule field and no new branch in {@link tokenizeInline}.
+     */
+    readonly notBefore?: string;
+}
+/**
+ * The standard-markdown marks, shared by every product.
+ *
+ * `**` and `*` cannot collide even though they share a prefix: a `*` followed
+ * immediately by another `*` is an EMPTY accent run, which no rule matches, so
+ * at any one position exactly one of the two can fire. Order between them is
+ * therefore not observable — which is worth stating, because the obvious
+ * assumption ("longest delimiter must be listed first") would make a future
+ * reader think this array's order is load-bearing when the empty-run rule is
+ * what actually does the work.
+ */
+declare const STANDARD_MARKUP: readonly InlineRule[];
+/**
+ * The buttons a COPY FIELD offers — a storefront section's copy box and a
+ * campaign block's copy box show exactly these, so a merchant meets one toolbar
+ * wherever they type.
+ *
+ * DERIVED, not listed. A copy field renders inline runs only — no lists, no
+ * block quote, no anchor — so the set it may advertise is precisely the tools
+ * whose output this grammar parses back. Writing that as a literal list was the
+ * bug's hiding place: the list and the grammar were two hand-maintained facts
+ * that agreed by luck, and nothing failed when a tool wrote a delimiter the
+ * parser read as something else. Now a style with no rule cannot appear here,
+ * whatever anyone types into the array.
+ *
+ * It resolves to bold, italic, strike, highlight and quiet. `code` is the one that
+ * surprises: it is an inline mark and it has a fence, but no rule reads a
+ * backtick, so a copy field would print `` `word` `` verbatim — and a button
+ * whose output the renderer draws as literal text is worse than no button.
+ *
+ * Declared here, below the rules, because it now depends on them.
+ */
+declare const COPY_FIELD_TOOLS: readonly MarkStyle[];
+/**
+ * The storefront's rule set: standard markdown plus the ONE legacy run it has
+ * published — `*phrase*` in the theme accent. Delete that last entry once
+ * stored copy has been converted to `==phrase==`; both kinds already paint the
+ * same, so the deletion is invisible.
+ */
+declare const STOREFRONT_MARKUP: readonly InlineRule[];
+/**
+ * The campaign designer's rule set: standard markdown plus its three legacy
+ * runs — `#phrase#` bold, `*phrase*` accent, `[phrase]` italic. The bold guard
+ * is the one the email parser already carried: a `#` followed by a digit does
+ * not close a run, so "Ranked #1 and #2" is literal while "Save #20%#" bolds.
+ *
+ * The italic guard exists because `[phrase]` collides with the one piece of
+ * markdown syntax every writer already knows. Without it, "Read [our
+ * terms](https://…) first" italicises the label AND prints the bare URL to the
+ * reader — the words come back wearing a mark nobody chose. It is not a
+ * toolbar problem: a merchant typing an ordinary link into a copy box hits it,
+ * which is why the guard is on the RULE and not on which buttons a field
+ * offers. `[phrase]` on its own is untouched, so every published line still
+ * reads exactly as it did.
+ */
+declare const CAMPAIGN_MARKUP: readonly InlineRule[];
+/** A parsed run. `text` is the inner text with the delimiters removed, so a
+ *  caller that only wants words ({@link stripInline}) joins the texts and a
+ *  caller that paints ({@link InlineKind}) switches on the kind. */
+interface InlineToken {
+    kind: InlineKind;
+    text: string;
+}
+/**
+ * Split authored text into its runs.
+ *
+ * The returned tokens ALTERNATE, starting and ending with a `text` token that
+ * may be empty — exactly the shape `String.split` with one capture group
+ * produced in the parsers this replaces. That contract is load-bearing, not
+ * cosmetic: the storefront wraps every segment (including the empty ones) in a
+ * `<span>`, so preserving the empty tokens is what keeps a published page's
+ * markup byte-for-byte identical.
+ *
+ * A lone delimiter with no partner stays literal — the products' copy contains
+ * real stray asterisks, and swallowing one would silently eat a word.
+ */
+declare function tokenizeInline(value: string, rules: readonly InlineRule[]): InlineToken[];
+/**
+ * The plain words of an authored string — every paired run unwrapped to its
+ * inner text, every unpaired delimiter left alone.
+ *
+ * This is the ONLY correct way to fill an `alt`, an `aria-label` or a
+ * structured-data field from authored copy. Deleting a delimiter character by
+ * hand — "replace every asterisk with nothing" — breaks the moment the grammar
+ * grows a marker, and it disagrees with the renderer about a stray asterisk,
+ * which matters: search engines expect structured data to match the text a
+ * visitor actually sees.
+ */
+declare function stripInline(value: string, rules: readonly InlineRule[]): string;
+/** Plain words. */
+interface MarkupText {
+    kind: 'text';
+    text: string;
+}
+/** A delimited run. `open` and `close` are the delimiters that were actually
+ *  saved — `#` for a legacy campaign bold, `**` for the standard one — so the
+ *  tree writes back the same bytes it was read from. */
+interface MarkupRun {
+    kind: InlineRule['kind'];
+    open: string;
+    close: string;
+    children: MarkupNode[];
+}
+/** `[words](href)`. Only made when {@link isSafeLinkHref} passes. */
+interface MarkupLink {
+    kind: 'link';
+    href: string;
+    children: MarkupNode[];
+}
+type MarkupNode = MarkupText | MarkupRun | MarkupLink;
+/** One line of the saved string. `bullet` means it was saved as `- words`;
+ *  `children` hold what follows the `- `. */
+interface MarkupLine {
+    bullet: boolean;
+    children: MarkupNode[];
+}
+/**
+ * True for an address a link may carry: `http`, `https`, `mailto` or `tel`, or
+ * one with no scheme at all (`/tyres`, `#top`, `terms.html`, `//cdn…`).
+ * Anything else — `javascript:`, `data:`, `file:` — is refused, and so is an
+ * address with any space or control character in it, because browsers drop
+ * those before they read the scheme (`java\tscript:` runs as `javascript:`).
+ *
+ * Renderers call this too, before they write an `href`, so the rule has one
+ * home.
+ */
+declare function isSafeLinkHref(href: string): boolean;
+/**
+ * Read authored text into lines of nodes — the whole grammar, for a rich text
+ * box and for the renderers that draw links and bullets.
+ *
+ * - A run never crosses a line break.
+ * - A line that starts with `- ` and has words after it is a bullet. One level
+ *   only: an indented `  - ` is plain text.
+ * - `[words](href)` is a link when {@link isSafeLinkHref} passes; otherwise the
+ *   whole thing stays plain text.
+ * - A run's words are read once more, so `**bold _with italic_**` is italic
+ *   inside bold. One level only: a third level stays as typed.
+ *
+ * Nothing is lost: {@link serializeMarkup} writes back the exact bytes.
+ */
+declare function parseMarkup(value: string, rules: readonly InlineRule[]): MarkupLine[];
+/** Write lines back to authored text: the inverse of {@link parseMarkup}. */
+declare function serializeMarkup(lines: readonly MarkupLine[]): string;
+/**
+ * One run a character sits in. `id` says WHICH run: two characters with the
+ * same id are in one run, so `**a****b**` (two bold runs, back to back) is told
+ * apart from `**ab**` (one) and is written back as it was saved.
+ *
+ * `open` and `close` are the delimiters that were saved (`#` for a legacy
+ * campaign bold), or, for a run made in the editor, the toolbar's own fence.
+ * A link's `close` is `](href)`.
+ */
+interface MarkSpan {
+    id: number;
+    kind: InlineRule['kind'] | 'link';
+    open: string;
+    close: string;
+    href?: string;
+}
+/**
+ * A NEW run, as the toolbar writes it: `**` for bold, `_` for italic, and so on
+ * ({@link applyMark}'s own fences), or a link to `href`. Null for a style that
+ * writes no run (a line prefix, clear). A paste filter or an editor making a
+ * run asks here, so no delimiter is spelled outside this module (E8).
+ */
+declare function spanFor(id: number, style: MarkStyle, href?: string): MarkSpan | null;
+/** One character of the words — never a delimiter — with the runs it sits in,
+ *  outside first, and its offset in the saved string. */
+interface MarkedChar {
+    ch: string;
+    marks: readonly MarkSpan[];
+    at: number;
+}
+/** One line: its bullet flag (the `- ` is not a character) and its words. */
+interface MarkedLine {
+    bullet: boolean;
+    chars: MarkedChar[];
+}
+/**
+ * Read authored text as characters, each carrying its runs — what an editor
+ * that hides the delimiters edits, and what {@link clearMarks} splits runs on.
+ *
+ * Built on {@link parseMarkup}, so it is the same reading, character by
+ * character. A character is a code point (an emoji is one, two UTF-16 units
+ * long); `at` counts UTF-16 units, as a text box's selection does.
+ *
+ * {@link writeMarkedLines} writes it back byte for byte.
+ */
+declare function markedLines(value: string, rules: readonly InlineRule[]): MarkedLine[];
+/**
+ * Write characters back to authored text: the inverse of {@link markedLines}.
+ * Returns where each character landed (`at[line][char]`), so a selection can be
+ * carried across the write.
+ *
+ * Runs are opened and closed as the characters ask: a character outside a run
+ * that its neighbours are in closes it, and the run's next character opens it
+ * again. That is how a run is SPLIT — clear the middle of `**abcd**` and it is
+ * written `**a**bc**d**`. Whether the result reads back as written is the
+ * caller's to check ({@link sameMarks}): `_` cannot close against a letter.
+ */
+declare function writeMarkedLines(lines: readonly MarkedLine[]): {
+    text: string;
+    at: number[][];
+};
+/** True when two readings hold the same words wearing the same marks — the
+ *  kinds and addresses, not which run or which delimiter. */
+declare function sameMarks(a: readonly MarkedLine[], b: readonly MarkedLine[]): boolean;
+/**
+ * Take every mark off `text[start:end]`, keeping the words and any link (a
+ * link has its own Remove). A run the selection only partly covers is split,
+ * so the rest of it keeps its mark. Bullets stay: they are lines, not marks.
+ *
+ * With nothing selected, the runs the caret touches — the characters either
+ * side of it — come off whole.
+ *
+ * A split the grammar cannot hold comes off whole instead: the middle of
+ * `_word_` would leave an underscore against a letter, which reads as a
+ * literal underscore. And if even that would not read back, nothing changes.
+ */
+declare function clearMarks(text: string, start: number, end: number, rules?: readonly InlineRule[]): WrapResult;
+
+export { CAMPAIGN_MARKUP, COPY_FIELD_TOOLS, type InlineKind, type InlineRule, type InlineToken, type LinkSpan, MARKUP_TOOLS, MARK_NAMES, MARK_PLACEHOLDERS, type MarkPlaceholders, type MarkSpan, type MarkStyle, type MarkedChar, type MarkedLine, type MarkupLine, type MarkupLink, type MarkupNode, type MarkupRun, type MarkupText, type MarkupTool, STANDARD_MARKUP, STOREFRONT_MARKUP, type WrapResult, applyMark, clearMarks, findLink, isSafeLinkHref, markedAt, markedLines, markupTools, parseMarkup, removeLink, sameMarks, serializeMarkup, spanFor, stripInline, tokenizeInline, writeLink, writeMarkedLines };

package/dist/markup/index.js

@@ -0,0 +1 @@
+export{CAMPAIGN_MARKUP,COPY_FIELD_TOOLS,MARKUP_TOOLS,MARK_NAMES,MARK_PLACEHOLDERS,STANDARD_MARKUP,STOREFRONT_MARKUP,applyMark,clearMarks,findLink,isSafeLinkHref,markedAt,markedLines,markupTools,parseMarkup,removeLink,sameMarks,serializeMarkup,spanFor,stripInline,tokenizeInline,writeLink,writeMarkedLines}from"../chunk-6OPSJGAI.js";

package/dist/menu/index.d.ts

@@ -0,0 +1,49 @@
+import * as react from 'react';
+import { a as EditorContextMenuProps, b as EditorContextMenuSkin } from '../types-pGBXevBU.js';
+export { E as EditorContextMenuItem } from '../types-pGBXevBU.js';
+
+/**
+ * The right-click menu box, shared by both editors (card 66400.d).
+ *
+ * MOVED HERE, NOT WRITTEN HERE. This is `efficient-admin-portal`'s
+ * `src/components/RowContextMenu.tsx` — portal placement, viewport edge-flip,
+ * a one-level submenu with ticks, focus move-in and restore, Escape and
+ * outside-click — which had been in front of real users on three surfaces
+ * (price sheets, the goods-issue dialog, the campaign canvas) before the
+ * storefront editor needed the same affordance. The alternative was those same
+ * 230 lines written a second time.
+ *
+ * ONE THING CHANGED IN THE MOVE, and it is the reason the move is worth doing:
+ * the box no longer knows what it looks like. The admin version hard-coded ONE
+ * editor's surface — `glassStyle()` from efficient-shell, plus that portal's
+ * Tailwind palette — into the only box both editors were ever going to share.
+ * Here the look is a {@link EditorContextMenuSkin}, the default is the
+ * storefront's approved one, and the admin passes its own strings in. So this
+ * module imports nothing but React (`tests/menu-leaf-safety.test.ts`), and the
+ * admin's rendered markup is byte-identical to what shipped
+ * (`tests/menu-layer.test.tsx` (e)).
+ *
+ * A CLIENT LEAF, like the gold layer and unlike the rail: it portals, it
+ * measures and it moves focus, so it has hooks and touches the DOM. A Next-16
+ * server component may import the module and must render it inside the host's
+ * client boundary.
+ */
+declare function EditorContextMenu({ x, y, items, onClose, maxHeight, skin, portalTo, }: EditorContextMenuProps): react.ReactPortal | null;
+
+/**
+ * The default skin — the storefront editor's approved look, in classes that
+ * `efficient-easel/menu.css` dresses.
+ *
+ * ⚠️ `es-editor` IS LOAD-BEARING AND IS NOT DECORATION. `shell.css` declares
+ * every `--es-*` on `.es-editor`, deliberately never on `:root`, so importing it
+ * themes an editor root and leaks nothing into the host page — the campaign
+ * designer renders INSIDE the admin DOM. The box is portalled to
+ * `document.body`, which is OUTSIDE that root, so without the class here every
+ * `var(--es-*)` in `menu.css` resolves to nothing: the background collapses to
+ * transparent and the border to `currentColor`. The result is markup that is
+ * present, answers every query a test can ask, and cannot be seen. Pinned by
+ * `tests/menu-layer.test.tsx` (f).
+ */
+declare const ES_MENU_SKIN: EditorContextMenuSkin;
+
+export { ES_MENU_SKIN, EditorContextMenu, EditorContextMenuProps, EditorContextMenuSkin };

package/dist/menu/index.js

@@ -0,0 +1,15 @@
+import{useRef as e,useState as n,useLayoutEffect as t,useEffect as l}from"react";import{createPortal as r}from"react-dom";import{jsxs as i,Fragment as a,jsx as o}from"react/jsx-runtime";var c={menu:"es-editor es-menu",menuSub:"es-editor es-menu",item:"es-menu-item",itemDanger:"es-menu-item is-danger",divider:"es-menu-divider",header:"es-menu-header",icon:"es-menu-icon",shortcut:"es-menu-shortcut",label:"es-menu-label",labelSub:"es-menu-label es-menu-label-sub",chevron:"es-menu-chevron",tick:"es-menu-tick"};function u({x:u,y:s,items:d,onClose:m,maxHeight:h,skin:b,portalTo:y}){const p=e(null),g=e(null),[f,w]=n(null),[v,x]=n({x:u,y:s}),[N,k]=n({x:u,y:s});if(N.x===u&&N.y===s||(k({x:u,y:s}),x({x:u,y:s})),t(()=>{const e=p.current;if(!e)return;const{width:n,height:t}=e.getBoundingClientRect(),l=window.innerWidth,r=window.innerHeight;let i=s;s+t>r-8&&(i=s-t>=8?s-t:Math.max(8,r-t-8));let a=u;u+n>l-8&&(a=u-n>=8?u-n:Math.max(8,l-n-8)),a===v.x&&i===v.y||x({x:a,y:i})},[u,s,d,v.x,v.y]),l(()=>{const e=document.activeElement;return p.current?.querySelector('[role="menuitem"]')?.focus(),()=>e?.focus?.()},[]),l(()=>{const e=e=>{const n=e.target;g.current?.contains(n)||p.current&&!p.current.contains(n)&&m()},n=e=>{"Escape"===e.key&&m()},t=setTimeout(()=>{window.addEventListener("mousedown",e),window.addEventListener("contextmenu",e),window.addEventListener("keydown",n)},0);return()=>{clearTimeout(t),window.removeEventListener("mousedown",e),window.removeEventListener("contextmenu",e),window.removeEventListener("keydown",n)}},[m]),0===d.length)return null;const C=b??c,E=e=>e.danger?C.itemDanger:C.item,S=({on:e})=>/* @__PURE__ */o("span",{className:C.tick,"aria-hidden":"true",children:e?"✓":""}),L=({of:e})=>null==e.icon?null:/* @__PURE__ */o("span",{className:C.icon,"aria-hidden":"true",children:e.icon}),T=({of:e})=>null==e.shortcut?null:/* @__PURE__ */o("span",{className:C.shortcut,"aria-hidden":"true",children:e.shortcut}),B=e=>null!=e.icon||null!=e.shortcut,M=(e,n,t)=>{if(!e.children?.length)return void w(null);const l=t.getBoundingClientRect(),r=p.current,i=r?parseFloat(getComputedStyle(r).minWidth):NaN,a=Number.isFinite(i)&&i>0?i:r?.getBoundingClientRect().width??0,o=l.right+a>window.innerWidth-8?l.left-a:l.right;w({i:n,x:Math.max(8,o),y:l.top})},F=f?d[f.i]:null,H=e=>({...C.surface,...e});return r(
+/* @__PURE__ */i(a,{children:[
+/* @__PURE__ */o("div",{ref:p,"data-es-menu":"",role:"menu","aria-label":d.find(e=>e.header)?.label,className:C.menu,style:H({left:v.x,top:v.y,maxHeight:h||void 0}),children:d.map((e,n)=>"—"===e.label?
+/* @__PURE__ */o("div",{role:"separator",className:C.divider},n):e.header?/* @__PURE__ */o("div",{className:C.header,children:e.label},n):e.children?.length?/* @__PURE__ */i("button",{type:"button",role:"menuitem","aria-haspopup":"menu","aria-expanded":f?.i===n,onMouseEnter:t=>M(e,n,t.currentTarget),onFocus:t=>M(e,n,t.currentTarget),onClick:t=>M(e,n,t.currentTarget),className:E(e),style:C.itemStyle,children:[
+/* @__PURE__ */o(L,{of:e}),
+/* @__PURE__ */o("span",{className:C.label,children:e.label}),
+/* @__PURE__ */o(T,{of:e}),
+/* @__PURE__ */o("span",{"aria-hidden":"true",className:C.chevron,children:"›"})]},n):/* @__PURE__ */o("button",{type:"button",role:"menuitem",onMouseEnter:()=>w(null),onClick:()=>{e.onClick(),m()},className:E(e),style:C.itemStyle,children:B(e)?/* @__PURE__ */i(a,{children:[
+/* @__PURE__ */o(L,{of:e}),
+/* @__PURE__ */o("span",{className:C.label,children:e.label}),
+/* @__PURE__ */o(T,{of:e})]}):e.label},n))}),F?.children?.length&&f?/* @__PURE__ */o("div",{ref:g,"data-es-menu":"",role:"menu","aria-label":F.label,className:C.menuSub??C.menu,style:H({left:f.x,top:f.y}),children:F.children.map((e,n)=>/* @__PURE__ */i("button",{type:"button",role:"menuitemradio","aria-checked":Boolean(e.checked),onClick:()=>{e.onClick(),m()},className:E(e),style:C.itemStyle,children:[
+/* @__PURE__ */o(S,{on:Boolean(e.checked)}),
+/* @__PURE__ */o(L,{of:e}),
+/* @__PURE__ */o("span",{className:C.labelSub??C.label,children:e.label}),
+/* @__PURE__ */o(T,{of:e})]},n))}):null]}),y??document.body)}export{c as ES_MENU_SKIN,u as EditorContextMenu};