@abide/abide 0.48.0 → 0.50.0

package/src/lib/server/runtime/devHotModuleResponse.ts

@@ -1,41 +0,0 @@
-import { resolve } from 'node:path'
-import { NO_STORE } from '../../shared/CACHE_CONTROL_VALUES.ts'
-import { isLayoutFile } from '../../shared/isLayoutFile.ts'
-import { compileModule } from '../../ui/compile/compileModule.ts'
-
-// Reused across requests — strips the embedded author TypeScript to browser JS.
-const TRANSPILER = new Bun.Transpiler({ loader: 'ts' })
-
-/*
-Serves one edited `.abide`'s hot module (dev component HMR). Compiles it in hot
-mode — runtime sourced from `window.__abide`, self-invoking `hotReplace` — and
-transpiles the embedded author TypeScript to plain JS the browser can import
-directly (the normal pipeline relies on the bundler's `ts` loader for this). The
-browser imports this in place of a reload; on load it swaps the component's live
-instances. The id is guarded as a project-relative `.abide` under cwd; a bad
-module ID returns 400; a missing file 404s so the client falls back to a reload.
-*/
-export async function devHotModuleResponse(moduleId: string): Promise<Response> {
-    const root = process.cwd()
-    const path = resolve(root, moduleId)
-    if (!moduleId.endsWith('.abide') || !path.startsWith(`${root}/`)) {
-        return new Response('bad request', { status: 400 })
-    }
-    const source = await Bun.file(path)
-        .text()
-        .catch(() => undefined)
-    if (source === undefined) {
-        return new Response('not found', { status: 404 })
-    }
-    const { code } = compileModule(source, {
-        isLayout: isLayoutFile(moduleId),
-        moduleId,
-        hot: true,
-    })
-    return new Response(TRANSPILER.transformSync(code), {
-        headers: {
-            'Content-Type': 'application/javascript; charset=utf-8',
-            'Cache-Control': NO_STORE,
-        },
-    })
-}

package/src/lib/shared/DEV_HOT_PREFIX.ts

@@ -1,7 +0,0 @@
-/*
-Path prefix of the dev-only component hot-module endpoint (`/__abide/hot/<moduleId>`).
-The browser imports `<prefix><moduleId>?v=<hash>` to fetch one edited component's
-hot module instead of reloading. Shared so the server route (createServer) and the
-live-reload client (DEV_RELOAD_CLIENT_SCRIPT) agree.
-*/
-export const DEV_HOT_PREFIX = '/__abide/hot/'

package/src/lib/shared/UNREACHABLE_STATUSES.ts

@@ -1,13 +0,0 @@
-/*
-HTTP statuses that mean "the server didn't process this request" — the gateway /
-availability family. A response with one of these is treated like a transport failure
-by a durable RPC: the call still throws (the error framework is unchanged), and the
-request is parked for replay on recovery. Everything else (4xx, 500, …) means the
-server received and handled it — that flows to the error framework, never the outbox.
-
-  502 Bad Gateway · 503 Service Unavailable · 504 Gateway Timeout (abide's own client
-  timeout surfaces here too) · 520–527, 530 — Cloudflare/CDN origin-unreachable.
-*/
-export const UNREACHABLE_STATUSES: ReadonlySet<number> = new Set([
-    502, 503, 504, 520, 521, 522, 523, 524, 525, 526, 527, 530,
-])

package/src/lib/shared/hasReplayableRequest.ts

@@ -1,17 +0,0 @@
-import { isReplayableMethod } from './isReplayableMethod.ts'
-import type { CacheEntry } from './types/CacheEntry.ts'
-
-/*
-Whether a cache entry carries a wire request that can be replayed from a warm
-snapshot — a replayable (GET-only) method, so the seed never re-fires a write or
-loses a body. Producer entries (no request) and write methods fail it.
-
-The request half of snapshot shippability, factored out so the two gates that
-need it cannot drift: `snapshotShippable` composes it with `settled` for the
-store-filter sites, and `snapshotEntryFromCache` calls it alone — its
-streaming-drain caller hands it still-pending entries it then awaits, so it can't
-require `settled` up front.
-*/
-export function hasReplayableRequest(entry: CacheEntry): boolean {
-    return entry.request !== undefined && isReplayableMethod(entry.request.method.toUpperCase())
-}

package/src/lib/shared/hydratingSlot.ts

@@ -1,12 +0,0 @@
-/*
-Set true only while the client adopts the server-rendered DOM (the hydration
-render pass — see the router's hydrate branch and `hydrate`). Read by `peek`: the
-server materializes no cache value (materializeRetained/cacheEntryFromSnapshot are
-client-only), so server-side peek is uniformly undefined and the SSR render always
-shows the fallback. A snapshot-seeded warm value surfacing DURING hydration would
-diverge from that server text and corrupt the claimed text node, so peek withholds
-it until the pass ends — `wakeHydrationPeeks` then re-runs the scope on the now-
-congruent value. A plain boolean, save/restore-nested so a child hydrate can't clear
-an outer pass early; false on the server (no hydration) and after boot.
-*/
-export const hydratingSlot: { active: boolean } = { active: false }

package/src/lib/shared/outboxProbeSlot.ts

@@ -1,20 +0,0 @@
-/*
-Internal slot the browser outbox registry registers its prober into, so the
-shared pending() probe can count parked durable-rpc writes without shared/
-importing browser/. Mirrors tailProbeSlot. The prober reads the doc-backed
-queue entries (reactive inside scope().computed() / scope().effect()) and reports whether any
-undelivered entry matches the selector: a durable rpc selector (carries a
-`url`) narrows to its own queue, the bare form spans every registered queue,
-optional args narrow to one parked call by structural compare. Outbox state is
-pending-only — a parked write has no value, so it never contributes to
-refreshing(); probeRegistries reads this slot only on its `field === 'pending'`
-branch, which is why the slot mirrors tailProbeSlot but reports a bare boolean
-rather than a { pending, refreshing } pair. When no prober is registered (server
-render, or no durable rpc was ever used) pending() sees no parked writes,
-exactly as on the server where there are no client queues.
-*/
-export const outboxProbeSlot: {
-    probe: ((selector: unknown, args: unknown) => boolean) | undefined
-} = {
-    probe: undefined,
-}

package/src/lib/shared/types/Outbox.ts

@@ -1,9 +0,0 @@
-import type { OutboxEntry } from './OutboxEntry.ts'
-
-/*
-The `.outbox` face on a durable RPC's client proxy: callable to read the reactive list
-of undelivered entries (`rpc.outbox()`), with an awaitable `retry()` that drains the whole
-queue and resolves when the replay settles. Server-side there is no client queue, so the
-face is absent.
-*/
-export type Outbox<Args> = (() => OutboxEntry<Args>[]) & { retry: () => Promise<void> }

package/src/lib/shared/types/OutboxEntry.ts

@@ -1,27 +0,0 @@
-/* The lifecycle status of a parked mutation: waiting to (re)send, or currently sending.
-   A write lives in the outbox ONLY while it can't reach the server; the instant the server
-   responds at all — a 2xx OR a real 4xx/500 — the entry leaves the queue, so there is no
-   terminal `error` state. Only the unreachable family (transport failure / 502/503/504/52x)
-   keeps it `queued`. */
-export type OutboxStatus = 'queued' | 'sending'
-
-/* One durable, replayable mutation in an RPC's outbox — parked because the original
-   call couldn't reach the server (transport failure, or a 502/503/504/52x). `controller`
-   is the entry's own abort handle (cancel = `controller.abort()`); `request` is the
-   synthesized, persisted Request the drain re-sends; `args` is the typed input (for
-   rendering); `error` is why it's parked (the `kind: 'queued'` HttpError from the
-   unreachable attempt); `retry()` kicks a FIFO drain. `settled` is the eventual outcome
-   of THIS write as if the original call had reached the server — it resolves with the
-   decoded result on delivery and rejects with the real HttpError on a server refusal (or
-   an AbortError on cancel). It may stay pending indefinitely if the write is never
-   replayed; reading it is what arms it (a never-read `settled` never rejects). */
-export type OutboxEntry<Args> = {
-    id: string
-    controller: AbortController
-    request: Request
-    args: Args
-    status: OutboxStatus
-    error?: unknown
-    retry: () => Promise<void>
-    settled: Promise<unknown>
-}

package/src/lib/shared/types/SmartReadOptions.ts

@@ -1,36 +0,0 @@
-/*
-Second-argument options for the smart bare rpc call (`getFoo(args, opts)`). The
-call is cached/coalesced/reactive with SWR always on for replayable reads, so
-these govern retention and the refetch clock — NOT transport. Per-call transport
-options (signal/keepalive/priority/cache/headers) live on `.raw(args, init)`.
-
-Fetch reads:
-- `ttl` — retention/staleness in ms. Default: 0 on the server (coalesce-only —
-  the request is the atomic unit, nothing is retained past it), Infinity on the
-  client (retain until invalidate/refresh — the tab is the atomic unit). On the
-  client, N ms marks a staleness deadline: the retained value goes stale after N
-  ms and the next access triggers a background revalidation (stale stays visible,
-  `refreshing()` true); the display value is never dropped. On the server, N ms
-  is a plain expiry and only takes effect in the shared store (pair with `shared`).
-- `tags` — free-form invalidation-group labels (see the selector grammar).
-- `throttle` / `debounce` — rate-limit the background refetch clock (set one, not
-  both). Leading-edge-then-coalesce, or fire-after-quiet respectively.
-- `shared` — opts the entry into the process-level store instead of the default
-  request-scoped one (server) — a store that outlives every request. It selects
-  the store only; it does NOT retain (pair it with `ttl` to memoise across
-  requests). The shared store is keyed by method+url+args, never by user, so do
-  not put per-user data in it — it would be served to other users. Omit `shared`
-  for per-request data. Write only `shared: true`; there is no `false` form. On
-  the client there is a single tab store, so the flag is a no-op there.
-
-Streaming reads (jsonl/sse):
-- `n` — how many retained frames to replay before going live.
-*/
-export type SmartReadOptions = {
-    ttl?: number
-    tags?: string[]
-    throttle?: number
-    debounce?: number
-    shared?: boolean
-    n?: number
-}

package/src/lib/shared/wakeHydrationPeeks.ts

@@ -1,20 +0,0 @@
-import { cacheStores } from './cacheStores.ts'
-
-/*
-Fired once when the outermost hydration pass ends (see the router's hydrate branch
-and `hydrate`). During the pass `peek` withheld every snapshot-seeded warm value
-for SSR congruence (see hydratingSlot); now that the pass is over those values are
-congruent to show, so re-run the scopes that read them. A peek scope taps the exact
-call key's lifecycle channel (peek's trackLifecycle), so marking every live entry's
-key wakes them — cheap, one-time, and harmless for non-peek lifecycle readers (they
-recompute the same value). Marks by key, not the bare store-wide channel, because a
-peek(fn, args) scope taps the per-key prefix channel, which a keyless mark misses.
-*/
-export function wakeHydrationPeeks(): void {
-    const stores = cacheStores()
-    for (const store of stores) {
-        for (const key of store.entries.keys()) {
-            store.markLifecycle(key)
-        }
-    }
-}

package/src/lib/ui/COMPONENT_WRAPPER_PREFIX.ts

@@ -1,5 +0,0 @@
-/* The `abide-` tag prefix on framework-owned custom elements (the router's
-   `abide-outlet`, the streaming `abide-resolve`/`abide-cache` fragments). `scopeLabel`
-   strips it to derive the bare name from a framework-owned host tag (e.g. `abide-resolve` → `resolve`). Child components no longer mount into
-   an `abide-<name>` wrapper — they build as marker ranges (see `mountRange`). */
-export const COMPONENT_WRAPPER_PREFIX = 'abide-'

package/src/lib/ui/compile/REACTIVE_CALLEES.ts

@@ -1,11 +0,0 @@
-/* The author-facing reactive primitive names (`state`, `state.linked`, `state.computed`,
-   and the destructuring `const {…} = props()`). The compiler no longer reads this —
-   recognition is import-resolved (see `resolveReactiveExport.ts`). It remains the canonical
-   inventory the docs surface-weighting tool enumerates (`scripts/surfaceWeight.ts`), so the
-   grammar's "primitives" bucket stays in sync with the language without hardcoding a list. */
-export const REACTIVE_CALLEES: ReadonlySet<string> = new Set([
-    'state',
-    'linked',
-    'computed',
-    'props',
-])

package/src/lib/ui/compile/assertRuntimeHelpersBound.ts

@@ -1,80 +0,0 @@
-import ts from 'typescript'
-import { UI_RUNTIME_IMPORTS } from './UI_RUNTIME_IMPORTS.ts'
-
-/*
-Independent backstop on the per-component dead-import filter (`compileModule`). The filter
-decides which runtime helpers to import by reading the generated output's identifiers; if it
-ever undercounts — as a raw token scan once did, mis-reading the tail of a module after a
-`${…}` template substitution — a helper gets CALLED but never imported, and the bundle throws
-`ReferenceError` the instant `build()` runs. The router escalates that into a reload loop, so
-the failure is both opaque and unrecoverable.
-
-This re-derives the same question a DIFFERENT way (so it can't share the filter's blind spot):
-walk the final module's AST, find every call whose callee is a bare runtime-helper identifier,
-and require that name to be imported or locally bound. A helper name inside a string / template /
-comment is not a `CallExpression` callee, so a docs component quoting framework code
-(`mount(...)` in a snippet) never false-positives. Compile-time only; never on the hot path.
-*/
-/* `module` is either the source string (standalone use — parsed here) or the already-parsed
-   tree of the bodies WITHOUT the prepended import block (compile pipeline — shares the one
-   parse the dead-import filter made). In the latter case the import block's bindings aren't in
-   the tree, so `importedHelpers` supplies the helper names that block will bind. */
-export function assertRuntimeHelpersBound(
-    module: string | ts.SourceFile,
-    importedHelpers: Set<string>,
-    context: string,
-): void {
-    /* The EMITTED local names (the `$$` alias when set) — codegen calls those, and the
-       aliased import binds them, so the bound/called check must use the same form. */
-    const helperNames = new Set(UI_RUNTIME_IMPORTS.map((entry) => entry.alias ?? entry.name))
-    const source =
-        typeof module === 'string'
-            ? ts.createSourceFile(
-                  'module.ts',
-                  module,
-                  ts.ScriptTarget.Latest,
-                  /* setParentNodes */ true,
-              )
-            : module
-    /* Names a bare call can resolve to: the import block's helper bindings (supplied when the
-       tree omits them) plus every import binding and declared name in the tree. Collected
-       generously (any identifier in a binding position) — over-approximating the bound set only
-       risks missing a defect, never raising a false alarm on valid output. */
-    const bound = new Set<string>(importedHelpers)
-    const calledHelpers: { name: string; position: number }[] = []
-    const visit = (node: ts.Node): void => {
-        if (
-            (ts.isVariableDeclaration(node) ||
-                ts.isFunctionDeclaration(node) ||
-                ts.isParameter(node) ||
-                ts.isBindingElement(node) ||
-                ts.isImportSpecifier(node) ||
-                ts.isImportClause(node) ||
-                ts.isNamespaceImport(node)) &&
-            node.name !== undefined &&
-            ts.isIdentifier(node.name)
-        ) {
-            bound.add(node.name.text)
-        }
-        if (
-            ts.isCallExpression(node) &&
-            ts.isIdentifier(node.expression) &&
-            helperNames.has(node.expression.text)
-        ) {
-            calledHelpers.push({
-                name: node.expression.text,
-                position: node.expression.getStart(source),
-            })
-        }
-        node.forEachChild(visit)
-    }
-    visit(source)
-
-    const unbound = calledHelpers.find((call) => !bound.has(call.name))
-    if (unbound !== undefined) {
-        const { line, character } = source.getLineAndCharacterOfPosition(unbound.position)
-        throw new Error(
-            `[abide] ${context} calls runtime helper \`${unbound.name}\` at line ${line + 1}:${character + 1} but never imports it — the dead-import filter dropped it. Please report this with the component source.\nOutput:\n${source.text}`,
-        )
-    }
-}

package/src/lib/ui/compile/markupTokens.ts

@@ -1,313 +0,0 @@
-import type { SemanticToken } from './types/SemanticToken.ts'
-
-/*
-Lexical highlighting for the HTML-shaped markup of a `.abide` component — element
-and component tag names, attribute names and string values, comments, and the
-`<`/`>`/`=` punctuation. A pure scan of raw source (independent of a successful
-parse, so it survives mid-edit), it exists so the LSP owns the *structure* too,
-not just `{…}` interiors: editors reuse tree-sitter-html as the grammar of record,
-which has no production for abide's `attr={expr}` values — a multiline
-template-literal attribute (`code={`…`}`) drops it into error recovery that never
-re-syncs, miscoloring every element below. Emitting these tokens overrides that
-broken parse wherever real structure sits.
-
-`{…}` expression regions (attribute values, interpolations, `{#…}` block heads) and
-the raw bodies of `<script>`/`<style>` are skipped here — those are the shadow
-type-checker's and the structural block tokenizer's jobs. Lowercase tags get the
-`tag` type, uppercase (components) get `type` (a constructor), mirroring the
-tree-sitter highlight split.
-*/
-
-/* Raw-text elements whose body is JS/CSS, not markup, so the scan jumps past it. */
-const RAW_ELEMENTS = new Set(['script', 'style'])
-
-const operator = (start: number, length: number): SemanticToken => ({
-    start,
-    length,
-    type: 'operator',
-    modifiers: [],
-})
-
-const isNameStart = (char: string): boolean => /[A-Za-z]/.test(char)
-
-/* Characters that end a tag or attribute name. */
-const isNameBreak = (char: string): boolean => /[\s=/>{}"'<]/.test(char)
-
-export function markupTokens(source: string): SemanticToken[] {
-    const tokens: SemanticToken[] = []
-    let cursor = 0
-    while (cursor < source.length) {
-        const char = source.charAt(cursor)
-        /* An expression region — interiors are the shadow classifier's job. */
-        if (char === '{') {
-            cursor = skipExpression(source, cursor)
-            continue
-        }
-        if (char === '<') {
-            if (source.startsWith('<!--', cursor)) {
-                const end = source.indexOf('-->', cursor + 4)
-                const close = end === -1 ? source.length : end + 3
-                tokens.push({
-                    start: cursor,
-                    length: close - cursor,
-                    type: 'comment',
-                    modifiers: [],
-                })
-                cursor = close
-                continue
-            }
-            const isClose = source.charAt(cursor + 1) === '/'
-            const nameStart = cursor + (isClose ? 2 : 1)
-            if (isNameStart(source.charAt(nameStart))) {
-                tokens.push(operator(cursor, isClose ? 2 : 1))
-                const name = readName(source, nameStart)
-                const type = /[A-Z]/.test(name.charAt(0)) ? 'type' : 'tag'
-                tokens.push({ start: nameStart, length: name.length, type, modifiers: [] })
-                const afterName = nameStart + name.length
-                if (isClose) {
-                    cursor = scanToClose(source, afterName, tokens)
-                    continue
-                }
-                const { end, selfClosed } = scanAttributes(source, afterName, tokens)
-                cursor =
-                    RAW_ELEMENTS.has(name) && !selfClosed ? skipRawBody(source, end, name) : end
-                continue
-            }
-        }
-        cursor += 1
-    }
-    return tokens
-}
-
-/* Reads a tag/element name from `start` (letters, digits, `-`, `_`). */
-function readName(source: string, start: number): string {
-    let cursor = start
-    while (cursor < source.length && /[A-Za-z0-9_-]/.test(source.charAt(cursor))) {
-        cursor += 1
-    }
-    return source.slice(start, cursor)
-}
-
-/* From after a close tag's name, emits the `>` operator and returns past it. */
-function scanToClose(source: string, from: number, tokens: SemanticToken[]): number {
-    let cursor = from
-    while (cursor < source.length && source.charAt(cursor) !== '>') {
-        cursor += 1
-    }
-    if (cursor < source.length) {
-        tokens.push(operator(cursor, 1))
-        return cursor + 1
-    }
-    return cursor
-}
-
-/* Scans an open tag's attributes from after its name to the closing `>`/`/>`,
-   emitting an `attribute` token per name, `operator` for `=`, and string tokens
-   for quoted values; `{…}` values and spreads are left to the shadow. */
-function scanAttributes(
-    source: string,
-    from: number,
-    tokens: SemanticToken[],
-): { end: number; selfClosed: boolean } {
-    let cursor = from
-    while (cursor < source.length) {
-        const char = source.charAt(cursor)
-        if (/\s/.test(char)) {
-            cursor += 1
-            continue
-        }
-        if (char === '>') {
-            tokens.push(operator(cursor, 1))
-            return { end: cursor + 1, selfClosed: false }
-        }
-        if (char === '/' && source.charAt(cursor + 1) === '>') {
-            tokens.push(operator(cursor, 2))
-            return { end: cursor + 2, selfClosed: true }
-        }
-        /* `{…code}` spread / expression attribute — shadow's job. */
-        if (char === '{') {
-            cursor = skipExpression(source, cursor)
-            continue
-        }
-        const nameStart = cursor
-        while (cursor < source.length && !isNameBreak(source.charAt(cursor))) {
-            cursor += 1
-        }
-        if (cursor === nameStart) {
-            /* No progress on a stray delimiter — advance to avoid a stall. */
-            cursor += 1
-            continue
-        }
-        tokens.push({
-            start: nameStart,
-            length: cursor - nameStart,
-            type: 'attribute',
-            modifiers: [],
-        })
-        let eq = cursor
-        while (eq < source.length && /\s/.test(source.charAt(eq))) {
-            eq += 1
-        }
-        if (source.charAt(eq) === '=') {
-            tokens.push(operator(eq, 1))
-            eq += 1
-            while (eq < source.length && /\s/.test(source.charAt(eq))) {
-                eq += 1
-            }
-            cursor = scanAttributeValue(source, eq, tokens)
-        } else {
-            cursor = eq
-        }
-    }
-    return { end: cursor, selfClosed: false }
-}
-
-/* Scans an attribute value: a `{…}` expression (skipped), a quoted string (split
-   around any `{…}` interpolations), or a bare unquoted run. Returns past it. */
-function scanAttributeValue(source: string, from: number, tokens: SemanticToken[]): number {
-    const char = source.charAt(from)
-    if (char === '{') {
-        return skipExpression(source, from)
-    }
-    if (char === '"' || char === "'") {
-        return scanQuotedValue(source, from, tokens)
-    }
-    let cursor = from
-    /* Unquoted values run to whitespace or `>`; a `/` is part of the value (a URL)
-       UNLESS it's the self-close `/>`, so stop before that `/` and leave it for the
-       attribute scanner to read as the self-close marker. */
-    while (cursor < source.length) {
-        const valueChar = source.charAt(cursor)
-        if (/[\s>]/.test(valueChar) || (valueChar === '/' && source.charAt(cursor + 1) === '>')) {
-            break
-        }
-        cursor += 1
-    }
-    if (cursor > from) {
-        tokens.push({ start: from, length: cursor - from, type: 'string', modifiers: [] })
-    }
-    return cursor
-}
-
-/* Emits string tokens for the literal runs of a quoted value (delimiters
-   included), skipping `{…}` interpolations so the shadow colors their interiors. */
-function scanQuotedValue(source: string, start: number, tokens: SemanticToken[]): number {
-    const quote = source.charAt(start)
-    let segmentStart = start
-    let cursor = start + 1
-    const flush = (end: number): void => {
-        if (end > segmentStart) {
-            tokens.push({
-                start: segmentStart,
-                length: end - segmentStart,
-                type: 'string',
-                modifiers: [],
-            })
-        }
-    }
-    while (cursor < source.length) {
-        const char = source.charAt(cursor)
-        if (char === quote) {
-            flush(cursor + 1)
-            return cursor + 1
-        }
-        if (char === '{') {
-            flush(cursor)
-            cursor = skipExpression(source, cursor)
-            segmentStart = cursor
-            continue
-        }
-        cursor += 1
-    }
-    flush(cursor)
-    return cursor
-}
-
-/* From the close `>` of a raw-text element's open tag, returns the index of its
-   `</tag` so the close tag is scanned as markup but the body is left untouched. */
-function skipRawBody(source: string, from: number, tag: string): number {
-    const close = source.indexOf(`</${tag}`, from)
-    return close === -1 ? source.length : close
-}
-
-/* From the opening `{` at `start`, returns the index past the matching `}`,
-   tracking nested braces and skipping strings, template literals (with `${…}`),
-   and JS comments so their contents never sway the depth. A regex literal holding
-   an unbalanced brace is the one unhandled case — rare, accepted for a highlighter. */
-function skipExpression(source: string, start: number): number {
-    let depth = 0
-    let cursor = start
-    while (cursor < source.length) {
-        const char = source.charAt(cursor)
-        if (char === '"' || char === "'") {
-            cursor = skipString(source, cursor)
-            continue
-        }
-        if (char === '`') {
-            cursor = skipTemplate(source, cursor)
-            continue
-        }
-        if (char === '/' && source.charAt(cursor + 1) === '/') {
-            const newline = source.indexOf('\n', cursor)
-            cursor = newline === -1 ? source.length : newline
-            continue
-        }
-        if (char === '/' && source.charAt(cursor + 1) === '*') {
-            const end = source.indexOf('*/', cursor + 2)
-            cursor = end === -1 ? source.length : end + 2
-            continue
-        }
-        if (char === '{') {
-            depth += 1
-        } else if (char === '}') {
-            depth -= 1
-            if (depth === 0) {
-                return cursor + 1
-            }
-        }
-        cursor += 1
-    }
-    return cursor
-}
-
-/* From the opening quote at `start`, returns the index past the matching quote;
-   a backslash escapes the next character. */
-function skipString(source: string, start: number): number {
-    const quote = source.charAt(start)
-    let cursor = start + 1
-    while (cursor < source.length) {
-        const char = source.charAt(cursor)
-        if (char === '\\') {
-            cursor += 2
-            continue
-        }
-        if (char === quote) {
-            return cursor + 1
-        }
-        cursor += 1
-    }
-    return cursor
-}
-
-/* From the opening backtick at `start`, returns the index past the matching
-   backtick. `${…}` re-enters expression scanning so its inner braces balance;
-   braces in the literal text are ignored. */
-function skipTemplate(source: string, start: number): number {
-    let cursor = start + 1
-    while (cursor < source.length) {
-        const char = source.charAt(cursor)
-        if (char === '\\') {
-            cursor += 2
-            continue
-        }
-        if (char === '`') {
-            return cursor + 1
-        }
-        if (char === '$' && source.charAt(cursor + 1) === '{') {
-            cursor = skipExpression(source, cursor + 1)
-            continue
-        }
-        cursor += 1
-    }
-    return cursor
-}