@stratusagent/channel-slack 0.11.4 → 0.11.6

package/dist/mrkdwn.js

@@ -0,0 +1,1081 @@
+/**
+ * Markdown as a model writes it, in the spelling Slack actually renders.
+ *
+ * Slack's mrkdwn is not Markdown, and the gap is not cosmetic: `**bold**`
+ * reaches a reader as four literal asterisks, and `## Heading` as a line
+ * that starts with two hashes. Models write Markdown because that is what
+ * every other surface here renders, and a soul should not have to know
+ * which channel is carrying it, so the translation happens at the edge that
+ * does know.
+ *
+ * This reads the reply once into tokens and renders from those. It replaced
+ * a chain of regexes over the text, which was correct in the end and got
+ * there the hard way: nine rounds of review, four of them the same defect —
+ * a character disappearing from inside a code span — reached from four
+ * unrelated directions. Nothing in a chain of rewrites holds a model of
+ * what is code, so every rule had to rediscover it, and each could be wrong
+ * on its own; one pair of rules in one commit turned out to disagree about
+ * whether Slack pairs backticks across a newline. Deciding that once, here,
+ * is the whole point of the shape.
+ *
+ * Three properties fall out of it rather than being enforced by a rule
+ * each, and they are the ones every one of those defects violated:
+ *
+ * - **A code run is one token.** Nothing below can see inside it, rewrite
+ *   part of it, or cut a line out of it — the newlines in a fence are not
+ *   line breaks in this stream, so a `#` on a line of somebody's shell
+ *   script is not a heading to be found.
+ * - **A delimiter is matched to its partner, not to a pattern.** An
+ *   emphasis run pairs across whatever sits between it and its closer, code
+ *   included, so ``**the `fs.read` tool**`` is one bold run rather than two
+ *   halves that never meet.
+ * - **A wrapper is emitted only when its own character is not already loose
+ *   in what it wraps.** Slack has one delimiter per style and no way to
+ *   nest it, so `*a *b* c*` renders as neither bold nor text. One rule
+ *   covers the heading that already contains bold, the bold run with a
+ *   stray asterisk in it, and every pairing of the two.
+ *
+ * Only what differs is touched. Lists, block quotes, and inline code
+ * already mean in mrkdwn what they mean in Markdown; rewriting them would
+ * add ways to be wrong and fix nothing.
+ */
+/**
+ * The delimiters worth reading, and how many of each a style can spend.
+ *
+ * `least` is the shortest run that means anything. Two of them start at
+ * two: a single `_` is already italic to Slack, and a single `~` is not a
+ * delimiter to either dialect, so a run of one is text in both cases —
+ * converting it could only change what a reader sees. A single `*` is the
+ * one that has to move, since Markdown reads it as italic and Slack as
+ * bold, so leaving it alone is the one thing that is certainly wrong.
+ *
+ * `most` is where the styles stop. Asterisks and underscores reach three,
+ * which is bold and italic together; tildes have only the one style and
+ * stop at two. Spending more than a style has is how characters go
+ * missing: read as three, `~~~obsolete~~~` had two of its tildes charged
+ * to a style that does not exist and simply vanished.
+ */
+const DELIMITERS = {
+    '*': { least: 1, most: 3 },
+    _: { least: 2, most: 3 },
+    '~': { least: 2, most: 2 },
+};
+/** Where a link's two halves begin and end. Nothing else reads brackets. */
+const BRACKETS = new Set(['[', ']', '(', ')']);
+/**
+ * A destination Slack will make a link of: a scheme it follows, and no
+ * whitespace or parenthesis to end it early. A bare `[1](2)` in prose is
+ * not a link anybody meant to follow.
+ */
+const LINK_DESTINATION = /^(?:https?:\/\/|mailto:)[^\s()]+$/;
+/**
+ * A heading's opening syntax: up to three spaces, its hashes, then air.
+ *
+ * What follows the air is deliberately not this pattern's business. The
+ * text token holding the hashes ends wherever the first marker or snippet
+ * begins, so `## **Title**` has nothing after the space to look at, and a
+ * pattern that demanded some would read that line as prose. Whether a
+ * heading has any content is asked later, of the rendered line, where the
+ * answer does not depend on which token the content landed in.
+ */
+const HEADING_OPENER = /^ {0,3}#{1,6}[ \t]+/;
+/**
+ * A heading's closing hashes, which Markdown allows and mrkdwn has no use
+ * for. They only count as syntax when spaced off the text — without that,
+ * `# C#` is a heading whose name loses its last character.
+ */
+const HEADING_CLOSER = /(?:[ \t]+#+)?\s*$/;
+/** The characters a token was written with, whatever it came to mean. */
+const sourceOf = (token) => {
+    switch (token.kind) {
+        case 'run':
+            return token.char.repeat(token.length);
+        case 'break':
+            return '\n';
+        default:
+            return token.text;
+    }
+};
+/**
+ * Where the run of exactly `length` backticks that closes an open one
+ * begins, or -1. Exactly: a longer run is not a closer, which is the whole
+ * point of writing a span as ``code with a ` in it`` and a fence as ````
+ * when the block itself contains ```.
+ */
+const closingBacktickRun = (text, from, length) => {
+    const run = '`'.repeat(length);
+    for (let at = text.indexOf(run, from); at !== -1; at = text.indexOf(run, at + 1)) {
+        if (text[at - 1] !== '`' && text[at + length] !== '`') {
+            return at;
+        }
+    }
+    return -1;
+};
+/**
+ * The reply as tokens.
+ *
+ * A code run may close on a later line and is one token the whole way.
+ * That looks wasteful — two stray backticks paragraphs apart become one
+ * long "span" whose contents go unconverted — and it was once changed to
+ * end a span at its line for exactly that reason. That was wrong, and the
+ * reason is the rule this file answers to: what Slack does with the message
+ * decides, not what Markdown says. Slack pairs those backticks too, so the
+ * text between them is what it renders as code, and rewriting a `**bold**`
+ * in there would alter the contents of somebody's snippet. Prose left
+ * unconverted is a cosmetic loss; code whose contents change is not, so the
+ * doubt resolves toward protecting more.
+ *
+ * A run of three or more with no closer takes the rest of the reply, which
+ * is what a fence still being streamed looks like on every edit before its
+ * last. One or two unmatched backticks are the opposite case — text, since
+ * "use the ` character" must not swallow what follows.
+ */
+const scan = (text) => {
+    const tokens = [];
+    let plain = '';
+    const flush = () => {
+        if (plain.length > 0) {
+            tokens.push({ kind: 'text', text: plain });
+            plain = '';
+        }
+    };
+    let at = 0;
+    while (at < text.length) {
+        const char = text[at] ?? '';
+        if (char === '`') {
+            let length = 1;
+            while (text[at + length] === '`') {
+                length += 1;
+            }
+            const close = closingBacktickRun(text, at + length, length);
+            if (close === -1 && length < 3) {
+                plain += '`'.repeat(length);
+                at += length;
+                continue;
+            }
+            flush();
+            if (close === -1) {
+                tokens.push({ kind: 'code', text: text.slice(at), closed: false });
+                return tokens;
+            }
+            tokens.push({ kind: 'code', text: text.slice(at, close + length), closed: true });
+            at = close + length;
+            continue;
+        }
+        if (char === '\n') {
+            flush();
+            tokens.push({ kind: 'break' });
+            at += 1;
+            continue;
+        }
+        const delimiter = DELIMITERS[char];
+        if (delimiter !== undefined) {
+            let length = 1;
+            while (text[at + length] === char) {
+                length += 1;
+            }
+            const before = text[at - 1];
+            const after = text[at + length];
+            // A delimiter has to hug what it marks: `3 * 4 * 5` is arithmetic.
+            // An underscore has to stand clear of a word as well, so that
+            // `snake_case_name` is a name — which is why the two are separate
+            // questions rather than one, since `a**b**c` is bold in Markdown and
+            // reads that way in Slack too.
+            const tight = length >= delimiter.least;
+            const inWord = (side) => side !== undefined && /[\p{L}\p{N}]/u.test(side);
+            flush();
+            tokens.push({
+                kind: 'run',
+                char,
+                length,
+                opens: tight && after !== undefined && !/\s/.test(after) && (char !== '_' || !inWord(before)),
+                closes: tight && before !== undefined && !/\s/.test(before) && (char !== '_' || !inWord(after)),
+            });
+            at += length;
+            continue;
+        }
+        if (BRACKETS.has(char)) {
+            flush();
+            tokens.push({ kind: 'punct', text: char });
+            at += 1;
+            continue;
+        }
+        plain += char;
+        at += 1;
+    }
+    flush();
+    return tokens;
+};
+/**
+ * Each closing run matched to the nearest opener still standing.
+ *
+ * A break clears the openers because emphasis does not cross a line in
+ * either dialect — one stray marker at the end of a paragraph must not
+ * italicize the next one. Nothing else clears them, and code in particular
+ * does not: a run reaches its partner across a snippet, which is the
+ * difference between ``**the `fs.read` tool**`` arriving as bold and
+ * arriving as four asterisks.
+ *
+ * `inert` holds the characters of a link's destination, which are no more
+ * markup than a snippet's are. A URL is written to be followed, and a `*`
+ * in a path is part of the path: left pairable, the one in
+ * `**[files](https://host/files/*.txt)**` closed the bold run that opened
+ * before the link, and the address arrived as `/files/_.txt` — a URL
+ * altered, which is the same defect as a snippet altered and was missed in
+ * the same place, by not asking whether anything else in a reply is as
+ * literal as code.
+ */
+const pairEmphasis = (tokens, inert, labelled) => {
+    // In creation order, which is innermost first at any run they share: a
+    // closer answers the nearest opener before it reaches the one further
+    // out, and an opener is spent from the end nearest what it marks.
+    const made = [];
+    // What each run has left to spend. A run is not one marker but a purse:
+    // `**bold and *italic***` ends on three asterisks that have two jobs, and
+    // answering only the nearest opener left the outer `**` unanswered and
+    // its asterisks on the line.
+    const left = new Map();
+    // One stack per delimiter character rather than one for all of them. A
+    // closer only ever answers an opener spelled the same way, so a single
+    // stack means walking past every opener that is not: 32 000 asterisks
+    // followed by 32 000 `~~` spent ten seconds discovering, each time, that
+    // none of them was a tilde. Each stack is in position order, so its last
+    // entry is the nearest opener of that character, and everything the
+    // closer invalidates is at the end of some stack.
+    const openers = new Map(Object.keys(DELIMITERS).map((char) => [char, []]));
+    // How far down a closer of a given kind still has to look. A closer that
+    // found nothing tells every later closer of its kind that there is
+    // nothing below it either, because the stack under it only ever shrinks
+    // — without which the rule below would put back the walk over every
+    // standing opener that the one-stack-per-character change took out.
+    const floor = new Map();
+    tokens.forEach((token, index) => {
+        if (token.kind === 'break') {
+            for (const stack of openers.values()) {
+                stack.length = 0;
+            }
+            return;
+        }
+        if (token.kind !== 'run' || inert.has(index)) {
+            return;
+        }
+        const own = openers.get(token.char);
+        const least = DELIMITERS[token.char]?.least ?? 1;
+        const most = DELIMITERS[token.char]?.most ?? 1;
+        let purse = token.length;
+        let spent = false;
+        // Each opener answers this closer at most once. Without that, a run
+        // with characters to spare pairs with itself again — `****quad****`
+        // would buy a second style with the asterisks it could not spend the
+        // first time, where today they stay on the line as written.
+        let ceiling = tokens.length;
+        if (token.closes && own !== undefined) {
+            while (purse >= least) {
+                // Markdown's rule of three: where either half could face both ways,
+                // runs whose lengths add to a multiple of three do not pair, unless
+                // both are multiples of three. It is what keeps the `*` in
+                // `**cost 2*3**` a multiplication sign — answered by the `**` before
+                // it, it italicised `cost 2`, text the reply never marked at all, and
+                // left the closing `**` with nothing.
+                const kind = `${token.char}${token.length % 3}${token.opens ? 'o' : ''}`;
+                const bottom = floor.get(kind) ?? -1;
+                let candidate = -1;
+                for (let slot = own.length - 1; slot >= 0; slot -= 1) {
+                    const standing = own[slot];
+                    if (standing === undefined || standing <= bottom) {
+                        break;
+                    }
+                    if (standing >= ceiling) {
+                        continue;
+                    }
+                    // A pair lies wholly inside a link's label or wholly outside it,
+                    // never half of each. There is no way to render one that straddles
+                    // the boundary — the label is written as `<url|label>`, so a
+                    // wrapper cannot begin outside it and end inside — and every
+                    // attempt to leaves characters behind: `*a [**b***](https://x)`
+                    // lost the link outright, and `*a [**b](https://x)***` lost the
+                    // asterisks the unrenderable pair had claimed.
+                    if (labelled[standing] !== labelled[index]) {
+                        continue;
+                    }
+                    const waiting = tokens[standing];
+                    if (waiting?.kind !== 'run') {
+                        continue;
+                    }
+                    const faces = token.opens || waiting.closes;
+                    const thirds = (waiting.length + token.length) % 3 === 0;
+                    const both = waiting.length % 3 === 0 && token.length % 3 === 0;
+                    if (!(faces && thirds && !both)) {
+                        candidate = standing;
+                        break;
+                    }
+                }
+                if (candidate === -1) {
+                    // Everything *before* this closer, not including it: a closer the
+                    // rule turned away is still an opener for what comes after, and
+                    // shutting the door on itself is what stopped `2*3 and 4*5`
+                    // pairing. Only worth recording while nothing has been spent —
+                    // once it has, this closer is not the one a later one can learn
+                    // from, because what it could not reach it never looked for.
+                    if (!spent) {
+                        floor.set(kind, index - 1);
+                    }
+                    break;
+                }
+                const purseOfOpener = left.get(candidate) ?? 0;
+                const use = Math.min(purseOfOpener, purse, most);
+                if (use < least) {
+                    break;
+                }
+                made.push({ open: candidate, close: index, use });
+                left.set(candidate, purseOfOpener - use);
+                purse -= use;
+                spent = true;
+                ceiling = candidate;
+                // Everything opened inside the pair and never closed is text —
+                // including whatever the rule above stepped over, which sits above
+                // this one. The opener itself stays only while it has something
+                // left to spend on a closer further along. Each entry is dropped
+                // once however many closers pass over it, so the pass stays linear.
+                for (const stack of openers.values()) {
+                    while (stack.length > 0 && (stack[stack.length - 1] ?? -1) > candidate) {
+                        stack.pop();
+                    }
+                }
+                if ((left.get(candidate) ?? 0) < least && own[own.length - 1] === candidate) {
+                    own.pop();
+                }
+            }
+        }
+        left.set(index, purse);
+        // A run that spent anything closing does not go on to open: the
+        // renderer enters a pair at its opening run and leaves past its
+        // closing one, so a run that is both would have to be stopped at
+        // twice, and the second stop is the one that does not exist yet.
+        // `**bold***italic*` is bold then italic in Markdown and comes out as
+        // two bold runs here, as it did before this branch.
+        if (!spent && token.opens) {
+            own?.push(index);
+        }
+    });
+    // What is left of a run is text, and belongs to the outermost pair that
+    // touches it — the last one made there, since pairs are made from the
+    // inside out.
+    const pairs = new Map();
+    const outermost = new Map();
+    made.forEach((entry, at) => {
+        outermost.set(entry.open, at);
+        outermost.set(entry.close, at);
+    });
+    made.forEach((entry, at) => {
+        const pair = {
+            open: entry.open,
+            close: entry.close,
+            use: entry.use,
+            before: outermost.get(entry.open) === at ? left.get(entry.open) ?? 0 : 0,
+            after: outermost.get(entry.close) === at ? left.get(entry.close) ?? 0 : 0,
+        };
+        const opening = pairs.get(entry.open);
+        if (opening === undefined) {
+            pairs.set(entry.open, [pair]);
+        }
+        else {
+            // Outermost first, so the range it covers is entered before the ones
+            // inside it and its markup is written to the outside of theirs.
+            opening.unshift(pair);
+        }
+    });
+    return pairs;
+};
+/**
+ * `[label](destination)`, the one construct Slack spells backwards.
+ *
+ * The destination is read as the characters it was written with, so a
+ * snippet inside one is judged by what it says: `https://host/`a b`` has a
+ * space in it and is not a destination, while `https://host/`b`` is. The
+ * old rewrite could not see either — it matched a masked stand-in and had
+ * to be told separately whether the thing behind it held whitespace.
+ *
+ * `<url|label>` is one line's worth of markup, so a link is one line. A
+ * break between the brackets already ends the search, and a snippet with a
+ * newline inside it has to as well: the newline is hidden in a single
+ * token there, which is exactly what makes it easy to miss.
+ */
+const findLinks = (tokens) => {
+    const links = new Map();
+    // Where the `)` that could close a destination starting here is, and how
+    // many snippets with a newline in them have been passed. Both were walked
+    // per candidate, and a reply can hold a great many candidates that come to
+    // nothing: `[x](` sixteen thousand times sent every one of them looking
+    // through the whole of the rest for a `)` that is not there.
+    //
+    // The scan stops at whitespace and at a `(` as well as at a break, because
+    // a destination holds none of the three — reaching a `)` past one of them
+    // only builds a string for the pattern below to reject, and building it is
+    // the expensive half: `[x](a` eight thousand times, with a single `)` at
+    // the end, had every candidate reach that `)` and join the whole remainder
+    // into a destination before throwing it away.
+    const closeFrom = new Array(tokens.length + 1).fill(-1);
+    const wrapped = new Array(tokens.length + 1).fill(0);
+    for (let at = tokens.length - 1; at >= 0; at -= 1) {
+        const token = tokens[at];
+        const opens = token?.kind === 'punct' && token.text === '(';
+        const stops = token === undefined || token.kind === 'break' || opens || /\s/.test(sourceOf(token));
+        const closes = token?.kind === 'punct' && token.text === ')';
+        closeFrom[at] = closes ? at : (stops ? -1 : (closeFrom[at + 1] ?? -1));
+        wrapped[at] = (wrapped[at + 1] ?? 0) + (token?.kind === 'code' && token.text.includes('\n') ? 1 : 0);
+    }
+    let opener = -1;
+    for (let at = 0; at < tokens.length; at += 1) {
+        const token = tokens[at];
+        if (token?.kind === 'break') {
+            opener = -1;
+            continue;
+        }
+        if (token?.kind !== 'punct') {
+            continue;
+        }
+        if (token.text === '[') {
+            opener = at;
+            continue;
+        }
+        if (token.text !== ']') {
+            continue;
+        }
+        // A closing bracket spends its opener whether or not a destination
+        // follows, the way Markdown's own does. Kept, it would let a `](…)`
+        // further along the line reach back past the bracket that already
+        // answered it: `[not a link] text](https://example.com)` became one
+        // link over the lot, hiding the text in between inside a label.
+        const candidate = opener;
+        opener = -1;
+        const after = tokens[at + 1];
+        if (candidate === -1 || after?.kind !== 'punct' || after.text !== '(') {
+            continue;
+        }
+        // Markdown allows an empty label; Slack's spelling has nowhere to put
+        // one. `[](https://example.com)` became `<https://example.com|>`, which
+        // is a link with no text for the reader to see or click, so the line
+        // stays as it was written and the address stays visible in it.
+        if (candidate + 1 === at) {
+            continue;
+        }
+        const close = closeFrom[at + 2] ?? -1;
+        if (close === -1) {
+            continue;
+        }
+        if ((wrapped[candidate + 1] ?? 0) - (wrapped[close] ?? 0) > 0) {
+            continue;
+        }
+        const destination = tokens.slice(at + 2, close).map(sourceOf).join('');
+        if (!LINK_DESTINATION.test(destination)) {
+            continue;
+        }
+        links.set(candidate, { label: [candidate + 1, at], destination, through: close });
+        at = close;
+    }
+    return links;
+};
+/** What each style is spelled with once it is Slack's. */
+const wrapperFor = (char, use) => {
+    if (char === '~') {
+        return ['~', '~'];
+    }
+    // Three is both styles at once, for either character that reaches it —
+    // read as bold alone, `___important___` lost the italic half it asked
+    // for while `***important***` kept it.
+    if (use >= 3) {
+        return ['*_', '_*'];
+    }
+    return char === '_' || use === 2 ? ['*', '*'] : ['_', '_'];
+};
+/**
+ * The tokens from `from` to `to`, rendered.
+ *
+ * What a pair encloses is a range in its own right, and so is a link's
+ * label, which reads as recursion and was written that way. It cannot be:
+ * nesting deep enough — a few thousand pairs one inside the next, which is
+ * a runaway model or a pasted file, not a person — exhausted the call stack
+ * and threw, and the throw lands in the edit timer, evaluated synchronously
+ * outside anything catching, so the reply took the adapter down with it.
+ * The depth lives in this array instead, where it costs an entry.
+ *
+ * Every range writes into one chunk list and nothing re-reads what it
+ * wrote. Collecting each range's text and joining it into its enclosing
+ * range copies everything below once per level, which is quadratic in the
+ * nesting depth — 80 000 pairs took forty seconds of the adapter's event
+ * loop, and the converter this replaced took milliseconds. A range reserves
+ * its opening chunk before it starts and fills it in when it ends, so the
+ * markup reaches the front of the range without moving what follows.
+ */
+const renderRange = (context, from, to) => {
+    const chunks = [];
+    const stack = [{ kind: 'range', to, loose: new Set(), unclosed: false, wraps: false }];
+    let at = from;
+    /** Text that is prose: it contributes whatever delimiters stand in it. */
+    const write = (frame, text) => {
+        chunks.push(text);
+        for (const char of text) {
+            if (char in DELIMITERS) {
+                frame.loose.add(char);
+            }
+        }
+    };
+    for (;;) {
+        const frame = stack[stack.length - 1];
+        if (frame === undefined) {
+            return { text: '', loose: new Set(), unclosed: false, wraps: false };
+        }
+        const token = at < frame.to ? context.tokens[at] : undefined;
+        if (token === undefined) {
+            stack.pop();
+            const parent = stack[stack.length - 1];
+            // Only the range this call was asked for has nothing around it.
+            if (frame.kind === 'range' || parent === undefined) {
+                return { text: chunks.join(''), loose: frame.loose, unclosed: frame.unclosed, wraps: frame.wraps };
+            }
+            if (frame.kind === 'pair') {
+                const [open, close] = wrapperFor(frame.open.char, frame.use);
+                // The characters of a run nothing spent are text, and stay on the
+                // outside of the pair where they were written. A run two pairs
+                // share hands them to the outer one, so they are counted here
+                // rather than taken from the run's own length.
+                const before = frame.open.char.repeat(frame.spare[0]);
+                const after = frame.close.char.repeat(frame.spare[1]);
+                // Every character the wrapper is spelled with, not just its first:
+                // `***both***` is written `*_…_*`, and an underscore already loose
+                // inside it would break the italic half exactly as a stray asterisk
+                // breaks the bold one.
+                const nests = [...open].some((char) => frame.loose.has(char)) || frame.unclosed;
+                // Only what this pair spends, for the same reason: the run may have
+                // written the other half of somebody else's markup already.
+                const kept = frame.open.char.repeat(frame.use);
+                chunks[frame.slot] = nests ? before + kept : before + open;
+                // Both halves are prose to whatever encloses this, wrappers this
+                // pass emitted included — which is why a heading that already holds
+                // bold is not bolded again.
+                write(parent, nests ? frame.close.char.repeat(frame.use) + after : close + after);
+                for (const char of chunks[frame.slot] ?? '') {
+                    if (char in DELIMITERS) {
+                        parent.loose.add(char);
+                    }
+                }
+            }
+            else {
+                chunks[frame.slot] = `<${frame.link.destination}|`;
+                chunks.push('>');
+                // The destination is an address rather than markup, so its
+                // delimiters pair with nothing — but they are still standing there,
+                // and a wrapper spelled with one of them would break on them.
+                for (const char of frame.link.destination) {
+                    if (char in DELIMITERS) {
+                        parent.loose.add(char);
+                    }
+                }
+            }
+            for (const char of frame.loose) {
+                parent.loose.add(char);
+            }
+            parent.unclosed = parent.unclosed || frame.unclosed;
+            parent.wraps = parent.wraps || frame.wraps;
+            at = frame.after;
+            continue;
+        }
+        const link = context.links.get(at);
+        if (link !== undefined && link.through < frame.to) {
+            chunks.push('');
+            stack.push({
+                kind: 'label',
+                to: link.label[1],
+                loose: new Set(),
+                unclosed: false,
+                wraps: false,
+                slot: chunks.length - 1,
+                after: link.through + 1,
+                link,
+            });
+            at = link.label[0];
+            continue;
+        }
+        if (token.kind === 'run') {
+            // Every pair this run opens, outermost first, so each is entered
+            // before the ones it contains. A run can open more than one: the
+            // three asterisks of `***a** b*` buy an italic that ends at the last
+            // one and a bold that ends before it.
+            // `<=`, not `<`: a pair inside another that ends on the same run
+            // closes where its parent does. Nothing is expected to be filtered
+            // out here — a pair never crosses a line, never leaves the pair
+            // around it, and since pairing kept them out of link labels, never
+            // leaves one of those either — but a pair dropped here would take
+            // the characters it had claimed with it, so the condition earns its
+            // place by making that impossible rather than by catching it.
+            const here = (context.pairs.get(at) ?? []).filter((pair) => {
+                const closer = context.tokens[pair.close];
+                return pair.close <= frame.to && closer?.kind === 'run';
+            });
+            if (here.length > 0) {
+                for (const pair of here) {
+                    const closer = context.tokens[pair.close];
+                    if (closer?.kind !== 'run') {
+                        continue;
+                    }
+                    chunks.push('');
+                    stack.push({
+                        kind: 'pair',
+                        to: pair.close,
+                        loose: new Set(),
+                        unclosed: false,
+                        wraps: false,
+                        slot: chunks.length - 1,
+                        // Past the closing run for every pair that ends on it, the
+                        // ones inside included: whatever encloses a pair sharing a run
+                        // ends on that same run, so it is finished either way and takes
+                        // its closing markup from the frame rather than from the token.
+                        after: pair.close + 1,
+                        open: token,
+                        close: closer,
+                        use: pair.use,
+                        spare: [pair.before, pair.after],
+                    });
+                }
+                at += 1;
+                continue;
+            }
+            write(frame, sourceOf(token));
+            at += 1;
+            continue;
+        }
+        if (token.kind === 'code') {
+            // Not through `write`: what stands in a snippet is not markup.
+            chunks.push(token.text);
+            frame.unclosed = frame.unclosed || !token.closed;
+            frame.wraps = frame.wraps || token.text.includes('\n');
+            at += 1;
+            continue;
+        }
+        write(frame, context.edits.get(at) ?? sourceOf(token));
+        at += 1;
+    }
+};
+/**
+ * One line, as a heading if it is one.
+ *
+ * A line here is what a reader sees, which is why the hashes inside a fence
+ * were never a question: the fence is a single token and its newlines are
+ * not breaks, so those lines do not exist to be mistaken for headings.
+ *
+ * The syntax is shed from the text tokens that actually hold it — the
+ * opening hashes from the first, the closing ones from the last. When the
+ * line ends inside a code run there is no last text token to take them
+ * from, and nothing is taken: the `#` at the end of `` # show `value # ``
+ * belongs to whoever wrote the snippet, and so does the whitespace beside
+ * it. That is a property of where the characters are rather than a rule
+ * about which of them are safe, which is what the rewrite it replaced kept
+ * getting wrong — it measured the strip with a pattern that knew `[ \t]`
+ * while the trim it guarded took a no-break space too.
+ *
+ * Bolding is the wrapper rule and two refusals of its own: a line that runs
+ * past its own end, through a snippet with a newline in it, is no longer
+ * the one line a heading is; and a line holding a fence nobody closed has
+ * no prose left at its end to put the closing marker in.
+ */
+const renderLine = (context, from, to) => {
+    const first = context.tokens[from];
+    if (first?.kind !== 'text') {
+        return renderRange(context, from, to).text;
+    }
+    const opener = HEADING_OPENER.exec(first.text);
+    if (opener === null) {
+        return renderRange(context, from, to).text;
+    }
+    const edits = new Map(context.edits);
+    edits.set(from, first.text.slice(opener[0].length));
+    const last = to - 1;
+    const tail = last > from ? context.tokens[last] : undefined;
+    if (last === from) {
+        edits.set(from, (edits.get(from) ?? '').replace(HEADING_CLOSER, ''));
+    }
+    else if (tail?.kind === 'text') {
+        edits.set(last, tail.text.replace(HEADING_CLOSER, ''));
+    }
+    const heading = renderRange({ ...context, edits }, from, to);
+    if (heading.text.length === 0) {
+        return renderRange(context, from, to).text;
+    }
+    const plain = !heading.loose.has('*') && !heading.unclosed && !heading.wraps;
+    return plain ? `*${heading.text}*` : heading.text;
+};
+/**
+ * Whether two lines are the header and rule `renderTable` writes: a rule of
+ * `─` crossed by `┼`, and a header whose `│` separators stand in exactly
+ * those columns. The shape, not a single box-drawing line, because a log
+ * that opens with a title and a `────` underline is somebody's text, and
+ * repeating its first lines on every part would change it.
+ */
+const isGridHeader = (header, rule) => {
+    if (!/^─[─┼]*─$/.test(rule) || !rule.includes('┼')) {
+        return false;
+    }
+    // In display columns, the unit the grid was padded in: counted any other
+    // way, an emoji or a CJK character before a separator moved it.
+    const crossings = columnsOf(rule, '┼');
+    const separators = columnsOf(header, '│');
+    return crossings.length === separators.length && crossings.every((column, index) => separators[index] === column);
+};
+/**
+ * A fence's first line — and, for a table grid, the header and rule after
+ * it, so a grid split across messages names its columns in every part
+ * rather than leaving the later ones as rows nobody can read. A grid always
+ * has two columns or more (see `renderTable`), so its rule always has a `┼`.
+ */
+const fenceOpener = (source, lineEnd) => {
+    const headerEnd = source.indexOf('\n', lineEnd + 1);
+    const ruleEnd = headerEnd === -1 ? -1 : source.indexOf('\n', headerEnd + 1);
+    const rule = ruleEnd === -1 ? '' : source.slice(headerEnd + 1, ruleEnd);
+    const header = headerEnd === -1 ? '' : source.slice(lineEnd + 1, headerEnd);
+    return isGridHeader(header, rule) ? source.slice(0, ruleEnd + 1) : source.slice(0, lineEnd + 1);
+};
+/**
+ * Where the code runs sit in already-converted text, read by the same scan
+ * that converts it — so the splitter agrees with the converter about what
+ * is code, rather than keeping a second idea of it that drifts. Conversion
+ * never touches a code token, so the runs of its output are the runs of its
+ * input, and scanning it again finds them where they are.
+ */
+export const codeRunsOf = (text) => {
+    const runs = [];
+    let at = 0;
+    for (const token of scan(text)) {
+        const source = sourceOf(token);
+        if (token.kind === 'code') {
+            let ticks = 0;
+            while (source[ticks] === '`') {
+                ticks += 1;
+            }
+            const fence = '`'.repeat(ticks);
+            const lineEnd = source.indexOf('\n');
+            runs.push(ticks >= 3 && lineEnd !== -1
+                ? { start: at, end: at + source.length, opener: fenceOpener(source, lineEnd), closer: `\n${fence}` }
+                : { start: at, end: at + source.length, opener: fence, closer: fence });
+        }
+        at += source.length;
+    }
+    return runs;
+};
+/**
+ * Slack's mrkdwn has no tables, so a GFM pipe table reached a thread as rows
+ * of literal `|` and a `|---|---|` line (#217). A table becomes a code block
+ * with its columns padded to line up — monospace reads as a grid in every
+ * client — or, when that grid is wider than a phone shows without wrapping,
+ * one line per row naming each value by its header.
+ */
+const TABLE_MAX_WIDTH = 60;
+/**
+ * A row's cells: outer pipes dropped, split on the pipes that are not
+ * escaped. Read a character at a time, because escaping is a matter of
+ * parity: in `a\\|b` the backslashes escape each other and the pipe
+ * separates, which no single-character lookbehind can see.
+ */
+const readRow = (line) => {
+    const row = line.trim();
+    const cells = [];
+    let cell = '';
+    let separated = false;
+    let endedOnSeparator = false;
+    for (let at = 0; at < row.length; at += 1) {
+        const char = row[at] ?? '';
+        endedOnSeparator = false;
+        if (char === '\\' && at + 1 < row.length) {
+            const next = row[at + 1] ?? '';
+            cell += next === '|' ? '|' : `${char}${next}`;
+            at += 1;
+            continue;
+        }
+        if (char === '|') {
+            cells.push(cell.trim());
+            cell = '';
+            separated = true;
+            endedOnSeparator = true;
+            continue;
+        }
+        cell += char;
+    }
+    if (!endedOnSeparator) {
+        cells.push(cell.trim());
+    }
+    if (row.startsWith('|')) {
+        cells.shift();
+    }
+    return { cells, separated };
+};
+const tableCells = (line) => readRow(line).cells;
+/**
+ * Whether a line has a pipe the row reader splits on. A line whose only
+ * pipe is escaped is prose, whatever follows it: `a\|b` over a `---`
+ * underline is a sentence, not a one-column table.
+ */
+const isTableRow = (line) => readRow(line).separated;
+/** The delimiter row's alignments, or nothing when the line is not one. */
+const tableAlignments = (line) => {
+    if (!line.includes('-')) {
+        return undefined;
+    }
+    const cells = tableCells(line);
+    if (!cells.every((cell) => /^:?-+:?$/.test(cell))) {
+        return undefined;
+    }
+    return cells.map((cell) => (cell.startsWith(':') && cell.endsWith(':') ? 'center' : cell.endsWith(':') ? 'right' : 'left'));
+};
+/**
+ * A cell as the grid shows it. Inside a code block Slack renders nothing,
+ * so the emphasis and code markers a model wraps a cell in would show as
+ * characters; they are dropped, and the words they marked stay. Which
+ * markers are emphasis is the converter's own reading (`readEmphasis`), not
+ * a second one: patterns written here missed italics and `***both***`, and
+ * then stripped `2 ** 3 ** 4`, each a rule the converter already had.
+ */
+const plainCell = (cell) => {
+    const tokens = scan(cell);
+    const spent = new Map();
+    for (const pairs of readEmphasis(tokens).pairs.values()) {
+        for (const pair of pairs) {
+            spent.set(pair.open, (spent.get(pair.open) ?? 0) + pair.use);
+            spent.set(pair.close, (spent.get(pair.close) ?? 0) + pair.use);
+        }
+    }
+    return tokens
+        .map((token, index) => {
+        if (token.kind === 'run') {
+            return token.char.repeat(token.length - (spent.get(index) ?? 0));
+        }
+        if (token.kind === 'code' && token.closed) {
+            let ticks = 0;
+            while (token.text[ticks] === '`') {
+                ticks += 1;
+            }
+            // CommonMark's rule, not a trim: one space comes off each side when
+            // both sides have one and the code is not all spaces, so `  a  `
+            // keeps the ` a ` it was written to show.
+            const code = token.text.slice(ticks, -ticks);
+            return code.startsWith(' ') && code.endsWith(' ') && code.trim().length > 0 ? code.slice(1, -1) : code;
+        }
+        return sourceOf(token);
+    })
+        .join('')
+        // The one italic the converter leaves alone, because Slack already
+        // reads `_x_` as italic outside code — inside the grid it would show.
+        // Same hugging and word-boundary rule the converter applies to runs.
+        .replace(/(?<![\p{L}\p{N}_])_(?=[^\s_])(.*?[^\s_])_(?![\p{L}\p{N}_])/gu, '$1');
+};
+/**
+ * How many monospace columns text takes, counted per displayed character
+ * (grapheme cluster): two for wide East Asian characters and any emoji —
+ * `👨‍👩‍👧‍👦` is one glyph, not four — none for a stray combining mark, one
+ * for the rest. A grid
+ * padded by UTF-16 length put `漢` in one column and drew two, and every
+ * separator after it moved. An approximation of Unicode's width tables,
+ * which Slack's own font does not follow exactly either.
+ */
+const graphemes = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+/** One displayed character's columns: what its first code point takes, or two for any emoji. */
+const clusterWidth = (cluster) => {
+    // Flags (regional-indicator pairs), keycaps, and anything asking for
+    // emoji presentation are emoji too, though none of them is pictographic.
+    if (/[\p{Extended_Pictographic}\u{1f1e6}-\u{1f1ff}\u20e3\ufe0f]/u.test(cluster)) {
+        return 2;
+    }
+    const code = cluster.codePointAt(0) ?? 0;
+    if (/^[\p{Mn}\p{Me}\u200b-\u200f\ufe00-\ufe0f]/u.test(cluster)) {
+        return 0;
+    }
+    const wide = (code >= 0x1100 && code <= 0x115f)
+        || (code >= 0x2e80 && code <= 0x303e)
+        || (code >= 0x3041 && code <= 0x33ff)
+        || (code >= 0x3400 && code <= 0x4dbf)
+        || (code >= 0x4e00 && code <= 0x9fff)
+        || (code >= 0xa000 && code <= 0xa4cf)
+        || (code >= 0xac00 && code <= 0xd7a3)
+        || (code >= 0xf900 && code <= 0xfaff)
+        || (code >= 0xfe30 && code <= 0xfe4f)
+        || (code >= 0xff00 && code <= 0xff60)
+        || (code >= 0xffe0 && code <= 0xffe6)
+        || (code >= 0x20000 && code <= 0x3fffd);
+    return wide ? 2 : 1;
+};
+const displayWidth = (text) => {
+    let width = 0;
+    for (const { segment } of graphemes.segment(text)) {
+        width += clusterWidth(segment);
+    }
+    return width;
+};
+/** The display columns at which `mark` stands in a line. */
+const columnsOf = (line, mark) => {
+    const columns = [];
+    let column = 0;
+    for (const { segment } of graphemes.segment(line)) {
+        if (segment === mark) {
+            columns.push(column);
+        }
+        column += clusterWidth(segment);
+    }
+    return columns;
+};
+const pad = (text, width, alignment) => {
+    const gap = width - displayWidth(text);
+    if (alignment === 'right') {
+        return `${' '.repeat(gap)}${text}`;
+    }
+    if (alignment === 'center') {
+        const left = Math.floor(gap / 2);
+        return `${' '.repeat(left)}${text}${' '.repeat(gap - left)}`;
+    }
+    return `${text}${' '.repeat(gap)}`;
+};
+/**
+ * A header as a label in the list and one-column forms, which mrkdwn reads
+ * like prose. Bold only when it holds no marker character at all — the
+ * heading renderer's rule, since a loose `*` in `glob *.ts` pairs with the
+ * wrapper's own; otherwise the
+ * header goes as written, so its own markup is converted rather than
+ * unwrapped — a header showing ``` in a code span kept only the three
+ * backticks, and they opened a fence that ran to the end of the reply.
+ */
+const tableLabel = (header) => header.length === 0 ? '' : /[*_~`]/.test(header) ? header : `**${header}**`;
+const renderTable = (header, alignments, rows) => {
+    const columns = header.length;
+    const fit = (row) => Array.from({ length: columns }, (_, index) => row[index] ?? '');
+    // One column has nothing to line up, so it is a list under its header.
+    // It is also what keeps every grid recognisable when split: a grid always
+    // has a `┼` in its rule, which a log's `────` underline never does.
+    if (columns === 1) {
+        const label = tableLabel(header[0] ?? '');
+        const items = rows.map((row) => row[0] ?? '').filter((cell) => cell.length > 0).map((cell) => `• ${cell}`);
+        return [...(label.length > 0 ? [label] : []), ...items].join('\n');
+    }
+    const grid = [header, ...rows.map(fit)].map((row) => row.map(plainCell));
+    const widths = Array.from({ length: columns }, (_, index) => Math.max(...grid.map((row) => displayWidth(row[index] ?? ''))));
+    const width = widths.reduce((sum, each) => sum + each, 0) + (columns - 1) * 3;
+    // A backtick run in a cell could close the fence early, and a link inside
+    // a code block is its source text rather than something to click — so a
+    // table with either takes the list form, where mrkdwn reads the cells as
+    // it reads prose. Links are found by the converter's own reader.
+    // A bare address counts too, and so does Slack's own markup — `<@U…>`,
+    // `<#C…>`, `<!here>`: Slack acts on all of them in prose and on none of
+    // them inside a code block.
+    const linked = [header, ...rows].some((row) => row.some((cell) => readEmphasis(scan(cell)).links.size > 0
+        || /\b(?:https?:\/\/|mailto:)\S|<[a-z][a-z0-9+.-]*:[^>\s]+>|<[@#!][^>\s]+>/i.test(cell)));
+    if (width <= TABLE_MAX_WIDTH && !linked && !grid.some((row) => row.some((cell) => cell.includes('```')))) {
+        const line = (row) => row.map((cell, index) => pad(cell, widths[index] ?? 0, alignments[index] ?? 'left')).join(' │ ').trimEnd();
+        const rule = widths.map((each) => '─'.repeat(each)).join('─┼─');
+        return ['```', line(grid[0] ?? []), rule, ...grid.slice(1).map(line), '```'].join('\n');
+    }
+    // The list form names each value by its header, so a table with no rows
+    // has nothing to name; its header is what it says, and it stays said.
+    const headerOnly = header.map(tableLabel).filter((label) => label.length > 0).join(' · ');
+    if (rows.length === 0) {
+        return headerOnly;
+    }
+    const listed = rows
+        .map(fit)
+        .map((row) => row
+        .map((cell, index) => ({ label: tableLabel(header[index] ?? ''), cell }))
+        .filter(({ cell }) => cell.length > 0)
+        .map(({ label, cell }) => (label.length > 0 ? `${label}: ${cell}` : cell))
+        .join(' · '))
+        .filter((line) => line.length > 0);
+    return listed.length > 0 ? listed.join('\n') : headerOnly;
+};
+/** Four spaces or a tab: an indented code block, which no table row may be. */
+const isIndentedCode = (line) => /^(?: {4,}|\t)/.test(line);
+/**
+ * The reply with every pipe table outside code rendered for Slack. A table
+ * inside a fence is somebody's text and stays as written — found by the
+ * converter's own scan, so this agrees with it about what is code.
+ */
+const renderTables = (text) => {
+    // Only a run that spans lines hides a table; an inline span in a cell is
+    // part of the row, the way GFM reads it.
+    const code = codeRunsOf(text).filter((run) => text.slice(run.start, run.end).includes('\n'));
+    const lines = text.split('\n');
+    // Runs and lines are both in order, so one pointer walks the runs: asking
+    // every run about every line was quadratic in a reply of many snippets.
+    const inCode = [];
+    let offset = 0;
+    let next = 0;
+    for (const line of lines) {
+        const start = offset;
+        const end = offset + line.length;
+        while (next < code.length && (code[next]?.end ?? 0) <= start) {
+            next += 1;
+        }
+        const run = code[next];
+        inCode.push(run !== undefined && run.start < end + 1 && start < run.end);
+        offset = end + 1;
+    }
+    const out = [];
+    let at = 0;
+    while (at < lines.length) {
+        const headerLine = lines[at] ?? '';
+        const alignments = inCode[at] || inCode[at + 1] ? undefined : tableAlignments(lines[at + 1] ?? '');
+        const header = tableCells(headerLine);
+        // Four spaces or a tab of indentation is an indented code block, not a
+        // table — GFM allows a table at most three.
+        const indented = isIndentedCode(headerLine) || isIndentedCode(lines[at + 1] ?? '');
+        if (alignments === undefined || indented || !isTableRow(headerLine) || header.length !== alignments.length) {
+            out.push(headerLine);
+            at += 1;
+            continue;
+        }
+        const rows = [];
+        let next = at + 2;
+        while (next < lines.length && !inCode[next] && !isIndentedCode(lines[next] ?? '') && isTableRow(lines[next] ?? '')) {
+            rows.push(tableCells(lines[next] ?? ''));
+            next += 1;
+        }
+        out.push(renderTable(header, alignments, rows));
+        at = next;
+    }
+    return out.join('\n');
+};
+/**
+ * The links in a token stream and the emphasis pairs around them — the one
+ * reading of emphasis, shared by conversion and by a table cell shedding its
+ * markers, so the two cannot disagree about what a `*` is.
+ */
+const readEmphasis = (tokens) => {
+    // Links are found before emphasis is paired, because what they turn out
+    // to cover decides what is left for a delimiter to pair with: the
+    // characters of a destination are the address, not markup.
+    const links = findLinks(tokens);
+    const inert = new Set();
+    for (const link of links.values()) {
+        for (let at = link.label[1] + 2; at < link.through; at += 1) {
+            inert.add(at);
+        }
+    }
+    // Where the label each token sits in begins, so pairing can tell that
+    // reaching further back would cross out of a link.
+    const labelled = new Array(tokens.length).fill(-1);
+    for (const [opener, link] of links) {
+        for (let at = link.label[0]; at < link.label[1]; at += 1) {
+            labelled[at] = opener;
+        }
+    }
+    return { links, pairs: pairEmphasis(tokens, inert, labelled) };
+};
+export const toSlackMrkdwn = (text) => {
+    const tokens = scan(renderTables(text));
+    const { links, pairs } = readEmphasis(tokens);
+    const context = { tokens, pairs, links, edits: new Map() };
+    const lines = [];
+    let start = 0;
+    for (let at = 0; at <= tokens.length; at += 1) {
+        if (at === tokens.length || tokens[at]?.kind === 'break') {
+            lines.push(renderLine(context, start, at));
+            start = at + 1;
+        }
+    }
+    return lines.join('\n');
+};
+//# sourceMappingURL=mrkdwn.js.map