@vesk/runtime 0.0.1

package/dist/resource.js

@@ -0,0 +1,502 @@
+import { tracked, get, set, scope, on_destroy } from '@vesk/runtime/src/ripple-runtime';
+import { is_destroyed } from '@vesk/runtime/src/ripple-blocks';
+export class HttpError extends Error {
+    status;
+    constructor(status, statusText) {
+        super(`HTTP ${status}: ${statusText}`);
+        this.status = status;
+        this.name = 'HttpError';
+    }
+}
+export class TimeoutError extends Error {
+    constructor(timeout) {
+        super(`Request timed out after ${timeout}ms`);
+        this.name = 'TimeoutError';
+    }
+}
+const g = () => globalThis;
+const isServer = () => !!g().__vsk_ssr;
+let ssrSink = null;
+export function setSsrSink(sink) {
+    ssrSink = sink;
+}
+function getClientCache() {
+    const value = g().__vsk_fetch_cache;
+    if (value)
+        return value;
+    const map = new Map();
+    g().__vsk_fetch_cache = map;
+    return map;
+}
+function getInflight() {
+    const value = g().__vsk_fetch_inflight;
+    if (value)
+        return value;
+    const map = new Map();
+    g().__vsk_fetch_inflight = map;
+    return map;
+}
+function getRegistry() {
+    const value = g().__vsk_fetch_registry;
+    if (value)
+        return value;
+    const map = new Map();
+    g().__vsk_fetch_registry = map;
+    return map;
+}
+function getSsrData(key) {
+    const sink = ssrSink;
+    if (sink)
+        return sink.get(key);
+    const store = g().__vsk_ssr_data;
+    if (!store)
+        return undefined;
+    return store[key];
+}
+export function setSsrData(key, value) {
+    const sink = ssrSink;
+    if (sink) {
+        sink.set(key, value);
+        return;
+    }
+    if (!g().__vsk_ssr_data)
+        g().__vsk_ssr_data = {};
+    g().__vsk_ssr_data[key] = value;
+}
+export function clearSsrData() {
+    const sink = ssrSink;
+    if (sink) {
+        sink.clear();
+        return;
+    }
+    delete g().__vsk_ssr_data;
+}
+function setInto(into, data) {
+    if (into && typeof into === 'object' && typeof into.f === 'number') {
+        set(into, data);
+    }
+}
+function isAbortError(error) {
+    if (typeof DOMException !== 'undefined' && error instanceof DOMException && error.name === 'AbortError') {
+        return true;
+    }
+    return error instanceof Error && error.name === 'AbortError';
+}
+function makeAbortError() {
+    if (typeof DOMException !== 'undefined')
+        return new DOMException('aborted', 'AbortError');
+    const error = new Error('aborted');
+    error.name = 'AbortError';
+    return error;
+}
+function normalizeHeaders(headers) {
+    const out = {};
+    if (!headers)
+        return out;
+    if (typeof Headers !== 'undefined' && headers instanceof Headers) {
+        headers.forEach((value, key) => (out[key] = value));
+    }
+    else if (Array.isArray(headers)) {
+        for (const [key, value] of headers)
+            out[key] = value;
+    }
+    else {
+        Object.assign(out, headers);
+    }
+    return out;
+}
+function prepareBody(body, headers) {
+    if (body === undefined || body === null)
+        return { headers };
+    if (typeof body === 'string' ||
+        typeof body === 'boolean' ||
+        typeof body === 'number' ||
+        (typeof FormData !== 'undefined' && body instanceof FormData) ||
+        (typeof URLSearchParams !== 'undefined' && body instanceof URLSearchParams) ||
+        (typeof Blob !== 'undefined' && body instanceof Blob) ||
+        (typeof ArrayBuffer !== 'undefined' && (body instanceof ArrayBuffer || ArrayBuffer.isView(body)))) {
+        return { body: body, headers };
+    }
+    if (!headers['content-type'] && !headers['Content-Type']) {
+        headers['Content-Type'] = 'application/json';
+    }
+    return { body: JSON.stringify(body), headers };
+}
+function buildRequestInit(options) {
+    const { method, credentials, cache, mode, redirect, referrer, referrerPolicy, integrity, keepalive, } = options;
+    const init = { method, credentials, cache, mode, redirect, referrer, referrerPolicy, integrity, keepalive };
+    const prepared = prepareBody(options.body, normalizeHeaders(options.headers));
+    init.headers = prepared.headers;
+    if (prepared.body !== undefined)
+        init.body = prepared.body;
+    return init;
+}
+function resolveFetchUrl(url) {
+    if (/^[a-z][a-z0-9+.-]*:/i.test(url) || url.startsWith('//'))
+        return url;
+    const reqUrl = g().__vesk_request?.url;
+    const base = typeof reqUrl === 'string' && /^https?:\/\//i.test(reqUrl)
+        ? reqUrl
+        : g().__vesk_ssr_base_url || '';
+    if (base)
+        return new URL(url, base).href;
+    return url;
+}
+function doFetch(url, init) {
+    const hook = g().__vesk_ssr_fetch;
+    if (isServer() && typeof hook === 'function') {
+        return hook(url, init);
+    }
+    return fetch(url, init);
+}
+function createFetcher(url, options) {
+    const init = buildRequestInit(options);
+    return async (signal) => {
+        const res = await doFetch(resolveFetchUrl(url), signal ? { ...init, signal } : init);
+        if (!res.ok)
+            throw new HttpError(res.status, res.statusText);
+        return res.json();
+    };
+}
+function linkSignal(userSignal, controller) {
+    if (!userSignal)
+        return;
+    if (userSignal.aborted)
+        controller.abort();
+    else
+        userSignal.addEventListener('abort', () => controller.abort(), { once: true });
+}
+async function runFetcher(handle, timeout) {
+    const { retry = 0, retryDelay = 1000, method, signal } = handle.options;
+    const maxAttempts = retry + 1;
+    const canRetry = !method || method.toUpperCase() === 'GET';
+    let attempt = 0;
+    let lastError;
+    while (true) {
+        if (handle.block !== null && is_destroyed(handle.block))
+            throw makeAbortError();
+        const controller = new AbortController();
+        handle.controller = controller;
+        linkSignal(signal, controller);
+        let timer = null;
+        const timeoutPromise = new Promise((_, reject) => {
+            if (timeout <= 0)
+                return;
+            timer = setTimeout(() => {
+                controller.abort();
+                reject(new TimeoutError(timeout));
+            }, timeout);
+        });
+        try {
+            const result = await Promise.race([handle.fetcher(controller.signal), timeoutPromise]);
+            return result;
+        }
+        catch (error) {
+            if (isAbortError(error))
+                throw error;
+            lastError = error;
+            const retriable = canRetry &&
+                attempt < maxAttempts - 1 &&
+                !(error instanceof HttpError && error.status >= 400 && error.status < 500);
+            if (!retriable)
+                throw error;
+            if (retryDelay > 0)
+                await sleep(retryDelay * (isServer() ? 1 : Math.pow(2, attempt)));
+            attempt++;
+        }
+        finally {
+            if (timer !== null)
+                clearTimeout(timer);
+            if (handle.controller === controller)
+                handle.controller = null;
+        }
+    }
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+function settle(handle, data) {
+    if (handle.block !== null && is_destroyed(handle.block))
+        return;
+    if (handle.into)
+        setInto(handle.into, data);
+    const current = get(handle.state);
+    if (!(current.data === data && !current.loading && current.error === null)) {
+        set(handle.state, { loading: false, error: null, data });
+    }
+    handle.settleNotify();
+}
+function settleError(handle, error) {
+    if (handle.block !== null && is_destroyed(handle.block))
+        return;
+    if (isAbortError(error)) {
+        if (handle.controller !== null)
+            return;
+        const current = get(handle.state);
+        if (current.loading)
+            set(handle.state, { loading: false, error: null, data: current.data });
+        handle.settleNotify();
+        return;
+    }
+    const current = get(handle.state);
+    set(handle.state, { loading: false, error, data: current.data });
+    handle.settleNotify();
+}
+function markRefetching(handle) {
+    const current = get(handle.state);
+    if (current.loading)
+        return;
+    set(handle.state, {
+        loading: true,
+        error: null,
+        data: handle.options.keepPreviousData ? current.data : undefined,
+    });
+}
+function attachSettle(handle, promise) {
+    promise.then(data => settle(handle, data), error => settleError(handle, error));
+}
+function writeCache(key, data) {
+    if (isServer())
+        return;
+    const entry = getClientCache().get(key);
+    if (!entry || entry.data !== data)
+        getClientCache().set(key, { data, fetchedAt: Date.now() });
+}
+function trackSsrPromise(promise) {
+    const tk = g().__vsk_ssr_token || '';
+    const promisesKey = tk ? `__vsk_ssr_promises_${tk}` : '__vsk_ssr_promises';
+    if (!g()[promisesKey])
+        g()[promisesKey] = [];
+    g()[promisesKey].push(promise);
+}
+function registerDestroyAbort(handle) {
+    if (isServer() || handle.block === null)
+        return;
+    on_destroy(() => {
+        if (is_destroyed(handle.block)) {
+            handle.controller?.abort();
+            const registry = getRegistry().get(handle.key);
+            if (registry)
+                registry.delete(handle);
+        }
+    });
+}
+function startRequest(handle, skipCache) {
+    const key = handle.key;
+    const options = handle.options;
+    if (isServer()) {
+        const existing = getInflight().get(key);
+        const prom = existing ?? runFetcher(handle, options.timeout || 0);
+        if (!existing) {
+            getInflight().set(key, prom);
+            prom.then(data => {
+                setSsrData(key, data);
+                settle(handle, data);
+            }, error => settleError(handle, error)).finally(() => {
+                if (getInflight().get(key) === prom)
+                    getInflight().delete(key);
+            });
+        }
+        else {
+            attachSettle(handle, prom);
+        }
+        trackSsrPromise(prom);
+        return prom;
+    }
+    if (!skipCache && options.staleTime && options.staleTime > 0) {
+        const entry = getClientCache().get(key);
+        if (entry && Date.now() - entry.fetchedAt < options.staleTime) {
+            settle(handle, entry.data);
+            return Promise.resolve(entry.data);
+        }
+    }
+    if (options.dedupe !== false) {
+        const existing = getInflight().get(key);
+        if (existing) {
+            attachSettle(handle, existing);
+            return existing;
+        }
+    }
+    markRefetching(handle);
+    const controller = new AbortController();
+    handle.controller = controller;
+    linkSignal(options.signal, controller);
+    const prom = runFetcher(handle, options.timeout || 0);
+    prom.then(data => {
+        writeCache(key, data);
+        settle(handle, data);
+    }, error => settleError(handle, error)).finally(() => {
+        if (options.dedupe !== false && getInflight().get(key) === prom)
+            getInflight().delete(key);
+    });
+    if (options.dedupe !== false)
+        getInflight().set(key, prom);
+    registerDestroyAbort(handle);
+    return prom;
+}
+function revalidate(handle) {
+    if (!isServer()) {
+        const registry = getRegistry().get(handle.key);
+        if (registry && registry.size > 0) {
+            const prev = getInflight().get(handle.key);
+            if (prev) {
+                getInflight().delete(handle.key);
+                registry.forEach(h => h.controller?.abort());
+            }
+            registry.forEach(h => startRequest(h, true));
+            return;
+        }
+    }
+    const prev = getInflight().get(handle.key);
+    if (prev)
+        getInflight().delete(handle.key);
+    handle.controller?.abort();
+    startRequest(handle, true);
+}
+export function mutate(key, data) {
+    if (isServer())
+        return;
+    const registry = getRegistry().get(key);
+    const prev = getInflight().get(key);
+    if (data !== undefined) {
+        getClientCache().set(key, { data, fetchedAt: Date.now() });
+        if (prev) {
+            getInflight().delete(key);
+            if (registry)
+                registry.forEach(h => h.controller?.abort());
+        }
+        if (registry) {
+            registry.forEach(h => {
+                if (h.into)
+                    setInto(h.into, data);
+                set(h.state, { loading: false, error: null, data });
+            });
+        }
+        return;
+    }
+    if (registry && registry.size > 0) {
+        if (prev) {
+            getInflight().delete(key);
+            registry.forEach(h => h.controller?.abort());
+        }
+        registry.forEach(h => startRequest(h, true));
+    }
+}
+function createResourceAccessor(handle) {
+    const state = handle.state;
+    const accessor = {};
+    Object.defineProperty(accessor, 'loading', {
+        get() { return get(state).loading; },
+    });
+    Object.defineProperty(accessor, 'error', {
+        get() { return get(state).error; },
+    });
+    Object.defineProperty(accessor, 'data', {
+        get() { return get(state).data; },
+    });
+    accessor._state = state;
+    const toData = async () => {
+        for (;;) {
+            const s = get(state);
+            if (!s.loading) {
+                if (s.error)
+                    throw s.error;
+                return s.data;
+            }
+            await handle.settled;
+        }
+    };
+    accessor.then = (onFulfilled, onRejected) => toData().then(onFulfilled, onRejected);
+    accessor.catch = (onRejected) => toData().catch(onRejected);
+    accessor.finally = (onFinally) => toData().finally(onFinally);
+    accessor.refresh = () => revalidate(handle);
+    accessor.abort = () => {
+        if (!isServer())
+            handle.controller?.abort();
+    };
+    return accessor;
+}
+export function createResource(fn, key, into, options = {}) {
+    const resourceKey = key || options.key || fn._ssrKey || fn.toString().slice(0, 64);
+    let notify = () => { };
+    const handle = {
+        key: resourceKey,
+        state: tracked({ loading: true, error: null, data: undefined }),
+        into,
+        fetcher: fn,
+        options,
+        block: scope(),
+        controller: null,
+        settled: new Promise((res) => { notify = res; }),
+        settleNotify: () => {
+            notify();
+            handle.settled = new Promise((res) => { notify = res; });
+        },
+    };
+    const accessor = createResourceAccessor(handle);
+    accessor.refresh = () => revalidate(handle);
+    accessor.abort = () => {
+        if (!isServer())
+            handle.controller?.abort();
+    };
+    if (options.enabled === false) {
+        set(handle.state, { loading: false, error: null, data: undefined });
+        return accessor;
+    }
+    if (!isServer()) {
+        const registry = getRegistry();
+        const set = registry.get(resourceKey) ?? new Set();
+        set.add(handle);
+        registry.set(resourceKey, set);
+        if (handle.block !== null) {
+            on_destroy(() => {
+                if (is_destroyed(handle.block)) {
+                    handle.controller?.abort();
+                    const current = getRegistry().get(resourceKey);
+                    if (current)
+                        current.delete(handle);
+                }
+            });
+        }
+    }
+    const ssrData = getSsrData(resourceKey);
+    if (ssrData !== undefined) {
+        settle(handle, ssrData);
+        writeCache(resourceKey, ssrData);
+        return accessor;
+    }
+    startRequest(handle, false);
+    return accessor;
+}
+export function useFetch(urlOrFn, options = {}) {
+    const fetcher = typeof urlOrFn === 'function'
+        ? urlOrFn
+        : createFetcher(urlOrFn, options);
+    const key = options.key || (typeof urlOrFn === 'string' ? urlOrFn : undefined);
+    const resource = createResource(fetcher, key, options.into, options);
+    return resource;
+}
+useFetch.text = (url, options) => useFetch(() => doFetch(resolveFetchUrl(url), buildRequestInit(options ?? {})).then(r => r.text()), {
+    ...options,
+    key: options?.key ?? url,
+});
+useFetch.json = (url, options) => useFetch(() => doFetch(resolveFetchUrl(url), buildRequestInit(options ?? {})).then(r => r.json()), {
+    ...options,
+    key: options?.key ?? url,
+});
+useFetch.arrayBuffer = (url, options) => useFetch(() => doFetch(resolveFetchUrl(url), buildRequestInit(options ?? {})).then(r => r.arrayBuffer()), {
+    ...options,
+    key: options?.key ?? url,
+});
+export async function resolveSsrResources() {
+    const sink = ssrSink;
+    if (sink)
+        return { ...sink.snapshot() };
+    const promises = (g().__vsk_ssr_promises || []);
+    if (promises.length === 0)
+        return {};
+    await Promise.allSettled(promises);
+    const data = (g().__vsk_ssr_data || {});
+    delete g().__vsk_ssr_promises;
+    return data;
+}

package/dist/ripple-blocks.d.ts

@@ -0,0 +1,18 @@
+import type { Block, Component } from '@vesk/runtime/src/ripple-runtime';
+export declare function user_effect(fn: () => void): Block | void;
+export declare function effect(fn: () => void): Block;
+export declare function pre_effect(fn: () => void): Block;
+export declare function render(fn: (state: unknown) => unknown, state?: unknown, flags?: number): Block;
+export declare function branch(fn: (state: unknown) => unknown, flags?: number, state?: unknown): Block;
+export declare function root(fn: () => void | (() => void)): Block;
+export declare function create_try_block(fn: (state: unknown) => unknown, state?: unknown): Block;
+export declare function boundary_fn_running_block(fn: (state: unknown) => unknown, flags?: number, state?: unknown): Block;
+export declare function block(flags: number, fn: (state: unknown) => unknown, state?: unknown, co?: Component): Block;
+export declare function destroy_block_children(parent: Block, remove_dom?: boolean): void;
+export declare function destroy_non_branch_children(parent: Block, remove_dom?: boolean): void;
+export declare function unlink_block(block: Block): void;
+export declare function pause_block(block: Block): void;
+export declare function resume_block(block: Block): void;
+export declare function is_destroyed(target_block: Block): boolean;
+export declare function destroy_block(block: Block, remove_dom?: boolean): void;
+//# sourceMappingURL=ripple-blocks.d.ts.map

package/dist/ripple-blocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ripple-blocks.d.ts","sourceRoot":"","sources":["../src/ripple-blocks.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAW,MAAM,kCAAkC,CAAC;AAGlF,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,KAAK,GAAG,IAAI,CAoBxD;AAED,wBAAgB,MAAM,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,KAAK,CAE5C;AAED,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,KAAK,CAEhD;AAED,wBAAgB,MAAM,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,KAAK,SAAI,GAAG,KAAK,CAEzF;AAED,wBAAgB,MAAM,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,EAAE,KAAK,SAAI,EAAE,KAAK,GAAE,OAAc,GAAG,KAAK,CAE/F;AAED,wBAAgB,IAAI,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG,KAAK,CAEzD;AAED,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,KAAK,CAExF;AAED,wBAAgB,yBAAyB,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,EAAE,KAAK,SAAI,EAAE,KAAK,GAAE,OAAc,GAAG,KAAK,CAElH;AAkBD,wBAAgB,KAAK,CACpB,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,EAC/B,KAAK,GAAE,OAAc,EACrB,EAAE,CAAC,EAAE,SAAS,GACZ,KAAK,CAgCP;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,KAAK,EAAE,UAAU,UAAQ,GAAG,IAAI,CAW9E;AAED,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,KAAK,EAAE,UAAU,UAAQ,GAAG,IAAI,CAkBnF;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAY/C;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAe9C;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAiB/C;AAED,wBAAgB,YAAY,CAAC,YAAY,EAAE,KAAK,GAAG,OAAO,CAezD;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU,UAAO,GAAG,IAAI,CA2BnE"}

package/dist/ripple-blocks.js

@@ -0,0 +1,184 @@
+import { BLOCK_HAS_RUN, BRANCH_BLOCK, DERIVED, CONTAINS_TEARDOWN, DESTROYED, EFFECT_BLOCK, PAUSED, PRE_EFFECT_BLOCK, RENDER_BLOCK, ROOT_BLOCK, TRY_BLOCK, HEAD_BLOCK, DIRECT_CHILD_BLOCK, } from '@vesk/runtime/src/ripple-constants';
+import { active_block, active_component, active_reaction, create_component_ctx, is_block_dirty, run_block, run_teardown, schedule_update, } from '@vesk/runtime/src/ripple-runtime';
+export function user_effect(fn) {
+    if (active_block === null) {
+        throw new Error('effect() must be called within an active context, such as a component or effect');
+    }
+    const component = active_component;
+    if (component !== null && !component.m) {
+        const e = (component.e ??= []);
+        e.push({
+            b: active_block,
+            fn,
+            r: active_reaction,
+        });
+        return;
+    }
+    return block(EFFECT_BLOCK, fn);
+}
+export function effect(fn) {
+    return block(EFFECT_BLOCK, fn);
+}
+export function pre_effect(fn) {
+    return block(PRE_EFFECT_BLOCK, fn);
+}
+export function render(fn, state, flags = 0) {
+    return block(RENDER_BLOCK | flags, fn, state);
+}
+export function branch(fn, flags = 0, state = null) {
+    return block(BRANCH_BLOCK | flags, fn, state);
+}
+export function root(fn) {
+    return block(ROOT_BLOCK, fn, { start: null, end: null }, create_component_ctx());
+}
+export function create_try_block(fn, state) {
+    return block(TRY_BLOCK, fn, state);
+}
+export function boundary_fn_running_block(fn, flags = 0, state = null) {
+    return branch(fn, DIRECT_CHILD_BLOCK | flags, state);
+}
+function push_block(block, parent_block) {
+    const parent_last = parent_block.last;
+    if (parent_last === null) {
+        parent_block.last = parent_block.first = block;
+    }
+    else {
+        parent_last.next = block;
+        block.prev = parent_last;
+        parent_block.last = block;
+    }
+}
+export function block(flags, fn, state = null, co) {
+    const newBlock = {
+        co: co || active_component,
+        d: null,
+        first: null,
+        f: flags,
+        fn,
+        last: null,
+        next: null,
+        p: active_block,
+        prev: null,
+        s: state,
+        t: null,
+        tc: null,
+    };
+    if (active_reaction !== null && (active_reaction.f & DERIVED) !== 0) {
+        (active_reaction.blocks ??= []).push(newBlock);
+    }
+    if (active_block !== null) {
+        push_block(newBlock, active_block);
+    }
+    if ((flags & EFFECT_BLOCK) !== 0) {
+        schedule_update(newBlock);
+    }
+    else {
+        run_block(newBlock);
+        newBlock.f ^= BLOCK_HAS_RUN;
+    }
+    return newBlock;
+}
+export function destroy_block_children(parent, remove_dom = false) {
+    let block = parent.first;
+    parent.first = parent.last = null;
+    if (remove_dom || (parent.f & CONTAINS_TEARDOWN) !== 0) {
+        while (block !== null) {
+            const next = block.next;
+            destroy_block(block, remove_dom);
+            block = next;
+        }
+    }
+}
+export function destroy_non_branch_children(parent, remove_dom = false) {
+    let block = parent.first;
+    if ((parent.f & CONTAINS_TEARDOWN) === 0 &&
+        parent.first !== null &&
+        (parent.first.f & BRANCH_BLOCK) === 0) {
+        parent.first = parent.last = null;
+    }
+    else {
+        while (block !== null) {
+            const next = block.next;
+            if ((block.f & BRANCH_BLOCK) === 0) {
+                destroy_block(block, remove_dom);
+            }
+            block = next;
+        }
+    }
+}
+export function unlink_block(block) {
+    const parent = block.p;
+    const prev = block.prev;
+    const next = block.next;
+    if (prev !== null)
+        prev.next = next;
+    if (next !== null)
+        next.prev = prev;
+    if (parent !== null) {
+        if (parent.first === block)
+            parent.first = next;
+        if (parent.last === block)
+            parent.last = prev;
+    }
+}
+export function pause_block(block) {
+    if ((block.f & PAUSED) !== 0) {
+        return;
+    }
+    block.f ^= PAUSED;
+    let child = block.first;
+    while (child !== null) {
+        const next = child.next;
+        pause_block(child);
+        child = next;
+    }
+    run_teardown(block);
+}
+export function resume_block(block) {
+    if ((block.f & PAUSED) === 0) {
+        return;
+    }
+    block.f ^= PAUSED;
+    if (is_block_dirty(block)) {
+        schedule_update(block);
+    }
+    let child = block.first;
+    while (child !== null) {
+        const next = child.next;
+        resume_block(child);
+        child = next;
+    }
+}
+export function is_destroyed(target_block) {
+    let block = target_block;
+    while (block !== null) {
+        const flags = block.f;
+        if ((flags & DESTROYED) !== 0) {
+            return true;
+        }
+        if ((flags & ROOT_BLOCK) !== 0) {
+            return false;
+        }
+        block = block.p;
+    }
+    return true;
+}
+export function destroy_block(block, remove_dom = true) {
+    block.f ^= DESTROYED;
+    let removed = false;
+    const f = block.f;
+    if ((remove_dom && (f & (BRANCH_BLOCK | ROOT_BLOCK)) !== 0 && (f & TRY_BLOCK) === 0) ||
+        (f & HEAD_BLOCK) !== 0) {
+        const s = block.s;
+        if (s !== null && s.start !== null) {
+            removed = true;
+        }
+    }
+    destroy_block_children(block, remove_dom && !removed);
+    run_teardown(block);
+    const parent = block.p;
+    if (parent !== null && parent.first !== null) {
+        unlink_block(block);
+    }
+    block.fn = block.s = block.d = block.p = block.co = block.t = null;
+}