knitting 0.1.46

package/src/api.d.ts

@@ -0,0 +1,55 @@
+import { endpointSymbol } from "./common/task-symbol.js";
+import type { Args, AbortSignalConfig, AbortSignalOption, AbortSignalToolkit, CreatePool, FixPoint, MaybePromise, Pool, TaskInput, ReturnFixed, ImportTaskOptions, TaskTimeout, tasks } from "./types.js";
+type ToListAndIds = {
+    list: string[];
+    ids: number[];
+    at: number[];
+};
+type ToListAndIdsFn = (args: tasks) => ToListAndIds;
+type CreatePoolFactory = (options: CreatePool) => <T extends tasks>(tasks: T) => Pool<T>;
+type InferredTaskFunction = (...args: any[]) => MaybePromise<Args>;
+type InferredTaskInput<F extends InferredTaskFunction, AS extends AbortSignalOption> = Parameters<F> extends [] ? void : AS extends undefined ? Parameters<F> extends [infer A] ? A extends TaskInput ? A : never : never : Parameters<F> extends [infer A] ? A extends TaskInput ? A : never : Parameters<F> extends [infer A, AbortSignalToolkit<AS>] ? A extends TaskInput ? A : never : never;
+type InferredTaskOutput<F extends InferredTaskFunction> = Awaited<ReturnType<F>> extends infer R ? R extends Blob ? never : R extends Args ? R : never : never;
+type InferredTaskShape<F extends InferredTaskFunction, AS extends AbortSignalOption> = [
+    InferredTaskInput<F, AS>
+] extends [never] ? never : [InferredTaskOutput<F>] extends [never] ? never : {
+    readonly f: F;
+    readonly timeout?: TaskTimeout;
+} & (AS extends undefined ? {
+    readonly abortSignal?: undefined;
+} : {
+    readonly abortSignal: AS;
+});
+export declare const isMain: boolean;
+export { endpointSymbol as endpointSymbol };
+/**
+ *  With this information we can recreate the logical order of
+ *  relevant exported functions from a file, also it helps to
+ *  track a task before naming, ` export ` elements have to be declared
+ *  at top level and without branching, we take advantage of this to
+ *  correctly map them.
+ *
+ */
+export declare const toListAndIds: ToListAndIdsFn;
+export declare const createPool: CreatePoolFactory;
+/**
+ * Define a worker task.
+ *
+ * Input may be a direct value or a native Promise of that value.
+ * Thenables/PromiseLike values are treated as plain values.
+ */
+export declare function task<F extends InferredTaskFunction>(I: InferredTaskShape<F, undefined>): ReturnFixed<InferredTaskInput<F, undefined>, InferredTaskOutput<F>, undefined>;
+export declare function task<F extends InferredTaskFunction>(I: InferredTaskShape<F, true>): ReturnFixed<InferredTaskInput<F, true>, InferredTaskOutput<F>, true>;
+export declare function task<AS extends AbortSignalConfig, F extends InferredTaskFunction>(I: InferredTaskShape<F, AS>): ReturnFixed<InferredTaskInput<F, AS>, InferredTaskOutput<F>, AS>;
+export declare function task<A extends TaskInput = void, B extends Args = void>(I: FixPoint<A, B, true>): ReturnFixed<A, B, true>;
+export declare function task<A extends TaskInput = void, B extends Args = void, AS extends AbortSignalConfig = AbortSignalConfig>(I: FixPoint<A, B, AS>): ReturnFixed<A, B, AS>;
+export declare function task<A extends TaskInput = void, B extends Args = void>(I: FixPoint<A, B, undefined>): ReturnFixed<A, B, undefined>;
+/**
+ * Define a task whose worker-side function is imported dynamically from `href`.
+ *
+ * This keeps module import/evaluation inside the worker, so worker permission
+ * policies apply to that import path.
+ */
+export declare function importTask<A extends TaskInput = void, B extends Args = void>(options: ImportTaskOptions<A, B, true>): ReturnFixed<A, B, true>;
+export declare function importTask<A extends TaskInput = void, B extends Args = void, AS extends AbortSignalConfig = AbortSignalConfig>(options: ImportTaskOptions<A, B, AS>): ReturnFixed<A, B, AS>;
+export declare function importTask<A extends TaskInput = void, B extends Args = void>(options: ImportTaskOptions<A, B, undefined>): ReturnFixed<A, B, undefined>;

package/src/api.js

@@ -0,0 +1,384 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { getCallerFilePath } from "./common/task-source.js";
+import { genTaskID } from "./common/task-source.js";
+import { toModuleUrl } from "./common/module-url.js";
+import { endpointSymbol } from "./common/task-symbol.js";
+import { spawnWorkerContext } from "./runtime/pool.js";
+import { RUNTIME_IS_MAIN_THREAD, RUNTIME_WORKER_DATA, } from "./common/worker-runtime.js";
+import { resolvePermissionProtocol, toRuntimePermissionFlags, } from "./permission/index.js";
+import { getNodeProcess } from "./common/node-compat.js";
+import { managerMethod } from "./runtime/balancer.js";
+import { createInlineExecutor } from "./runtime/inline-executor.js";
+const MAX_FUNCTION_ID = 0xFFFF;
+const MAX_FUNCTION_COUNT = MAX_FUNCTION_ID + 1;
+export const isMain = RUNTIME_IS_MAIN_THREAD;
+export { endpointSymbol as endpointSymbol };
+/**
+ *  With this information we can recreate the logical order of
+ *  relevant exported functions from a file, also it helps to
+ *  track a task before naming, ` export ` elements have to be declared
+ *  at top level and without branching, we take advantage of this to
+ *  correctly map them.
+ *
+ */
+export const toListAndIds = (args) => {
+    const result = Object.values(args)
+        .reduce((acc, v) => (acc[0].add(v.importedFrom),
+        acc[1].add(v.id),
+        acc[2].add(v.at),
+        acc), [
+        new Set(),
+        new Set(),
+        new Set()
+    ]);
+    return {
+        list: [...result[0]],
+        ids: [...result[1]],
+        at: [...result[2]],
+    };
+};
+export const createPool = ({ threads, debug, inliner, balancer, payload, payloadInitialBytes, payloadMaxBytes, bufferMode, maxPayloadBytes, abortSignalCapacity, source, worker, workerExecArgv, permission, dispatcher, host, }) => (tasks) => {
+    /**
+     *  This functions is only available in the main thread.
+     *  Also triggers when debug extra is enabled.
+     */
+    if (RUNTIME_IS_MAIN_THREAD === false) {
+        if ((debug?.extras === true)) {
+            console.warn("createPool has been called with : " + JSON.stringify(RUNTIME_WORKER_DATA));
+        }
+        const notMainThreadError = () => {
+            throw new Error("createPool can only be called in the main thread.");
+        };
+        const throwingProxyTarget = function () {
+            return notMainThreadError();
+        };
+        const throwingProxyHandler = {
+            get: function () {
+                return notMainThreadError;
+            },
+        };
+        const mainThreadOnlyProxy = new Proxy(throwingProxyTarget, throwingProxyHandler);
+        //@ts-ignore
+        return {
+            shutdown: mainThreadOnlyProxy,
+            call: mainThreadOnlyProxy,
+        };
+    }
+    const { list, ids, at } = toListAndIds(tasks), listOfFunctions = Object.entries(tasks).map(([k, v]) => ({
+        ...v,
+        name: k,
+    }))
+        .sort((a, b) => a.name.localeCompare(b.name));
+    if (listOfFunctions.length > MAX_FUNCTION_COUNT) {
+        throw new RangeError(`Too many tasks: received ${listOfFunctions.length}. ` +
+            `Maximum is ${MAX_FUNCTION_COUNT} (Uint16 function IDs: 0..${MAX_FUNCTION_ID}).`);
+    }
+    const usingInliner = typeof inliner === "object" && inliner != null;
+    const totalNumberOfThread = (threads ?? 1) +
+        (usingInliner ? 1 : 0);
+    const permissionProtocol = resolvePermissionProtocol({
+        permission: permission ?? {
+            mode: "strict",
+            allowImport: true,
+        },
+        modules: list,
+    });
+    const permissionExecArgv = toRuntimePermissionFlags(permissionProtocol);
+    const nodeProcess = getNodeProcess();
+    const allowedFlags = nodeProcess?.allowedNodeEnvironmentFlags ?? null;
+    const isNodePermissionFlag = (flag) => {
+        const key = flag.split("=", 1)[0];
+        return key === "--permission" ||
+            key === "--experimental-permission" ||
+            key === "--allow-fs-read" ||
+            key === "--allow-fs-write" ||
+            key === "--allow-worker" ||
+            key === "--allow-child-process" ||
+            key === "--allow-addons" ||
+            key === "--allow-wasi";
+    };
+    const stripNodePermissionFlags = (flags) => flags?.filter((flag) => !isNodePermissionFlag(flag));
+    const dedupeFlags = (flags) => {
+        const out = [];
+        const seen = new Set();
+        for (const flag of flags) {
+            if (seen.has(flag))
+                continue;
+            seen.add(flag);
+            out.push(flag);
+        }
+        return out;
+    };
+    const sanitizeExecArgv = (flags) => {
+        if (!flags || flags.length === 0)
+            return undefined;
+        if (!allowedFlags)
+            return flags;
+        const filtered = flags.filter((flag) => {
+            const key = flag.split("=", 1)[0];
+            return allowedFlags.has(key);
+        });
+        return filtered.length > 0 ? filtered : undefined;
+    };
+    const inheritedExecArgv = Array.isArray(nodeProcess?.execArgv)
+        ? nodeProcess.execArgv
+        : undefined;
+    const defaultExecArgvCandidate = workerExecArgv ??
+        (inheritedExecArgv
+            ? (allowedFlags?.has("--expose-gc") === true
+                ? (inheritedExecArgv.includes("--expose-gc")
+                    ? inheritedExecArgv
+                    : [...inheritedExecArgv, "--expose-gc"])
+                : inheritedExecArgv)
+            : undefined);
+    const defaultExecArgv = permissionProtocol?.unsafe === true
+        ? stripNodePermissionFlags(defaultExecArgvCandidate)
+        : defaultExecArgvCandidate;
+    const combinedExecArgv = dedupeFlags([
+        ...permissionExecArgv,
+        ...(defaultExecArgv ?? []),
+    ]);
+    const execArgv = sanitizeExecArgv(combinedExecArgv.length > 0 ? combinedExecArgv : undefined);
+    const hostDispatcher = host ?? dispatcher;
+    const usesAbortSignal = listOfFunctions.some((fn) => fn.abortSignal !== undefined);
+    const hardTimeoutMs = Number.isFinite(worker?.hardTimeoutMs)
+        ? Math.max(1, Math.floor(worker?.hardTimeoutMs))
+        : undefined;
+    let workers = Array.from({
+        length: threads ?? 1,
+    }).map((_, thread) => spawnWorkerContext({
+        list,
+        ids,
+        at,
+        thread,
+        debug,
+        totalNumberOfThread,
+        source,
+        workerOptions: worker,
+        workerExecArgv: execArgv,
+        host: hostDispatcher,
+        payload,
+        payloadInitialBytes,
+        payloadMaxBytes,
+        bufferMode,
+        maxPayloadBytes,
+        abortSignalCapacity,
+        usesAbortSignal,
+        permission: permissionProtocol,
+    }));
+    if (usingInliner) {
+        const mainThread = createInlineExecutor({
+            tasks,
+            genTaskID,
+            batchSize: inliner?.batchSize ?? 1,
+        });
+        if (inliner?.position === "first") {
+            workers = [
+                //@ts-ignore
+                mainThread,
+                ...workers,
+            ];
+        }
+        else {
+            workers.push(
+            //@ts-ignore
+            mainThread);
+        }
+    }
+    const inlinerIndex = usingInliner
+        ? (inliner?.position === "first" ? 0 : workers.length - 1)
+        : -1;
+    const inlinerDispatchThreshold = Number.isFinite(inliner?.dispatchThreshold)
+        ? Math.max(1, Math.floor(inliner?.dispatchThreshold ?? 1))
+        : 1;
+    let closing = false;
+    let closePromise;
+    let shutdownPromise;
+    const closePoolNow = () => {
+        if (closePromise)
+            return closePromise;
+        closing = true;
+        closePromise = Promise.allSettled(workers.map((context) => context.kills()))
+            .then(() => undefined);
+        return closePromise;
+    };
+    const wrapGuardedInvoke = ({ invoke, taskName, }) => (args) => {
+        if (closing) {
+            return Promise.reject(new Error("Pool is shut down"));
+        }
+        const pending = invoke(args);
+        if (!hardTimeoutMs)
+            return pending;
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const timeoutId = setTimeout(() => {
+                if (settled)
+                    return;
+                settled = true;
+                reject(new Error(`Task hard timeout after ${hardTimeoutMs}ms (${taskName}); pool force-shutdown`));
+                void closePoolNow();
+            }, hardTimeoutMs);
+            pending.then((value) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timeoutId);
+                resolve(value);
+            }, (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timeoutId);
+                reject(error);
+            });
+        });
+    };
+    const shutdownWithDelay = (delayMs) => {
+        if (closePromise)
+            return closePromise;
+        if (shutdownPromise)
+            return shutdownPromise;
+        const ms = Number.isFinite(delayMs)
+            ? Math.max(0, Math.floor(delayMs))
+            : 0;
+        shutdownPromise = (async () => {
+            if (closePromise)
+                return await closePromise;
+            if (ms > 0) {
+                await new Promise((resolve) => setTimeout(resolve, ms));
+            }
+            if (closePromise)
+                return await closePromise;
+            await closePoolNow();
+        })();
+        return shutdownPromise;
+    };
+    const indexedFunctions = listOfFunctions.map((fn, index) => ({
+        name: fn.name,
+        index,
+        timeout: fn.timeout,
+        abortSignal: fn.abortSignal,
+    }));
+    const callHandlers = new Map();
+    for (const { name } of indexedFunctions) {
+        callHandlers.set(name, []);
+    }
+    for (const worker of workers) {
+        for (const { name, index, timeout, abortSignal } of indexedFunctions) {
+            callHandlers.get(name).push(wrapGuardedInvoke({
+                taskName: name,
+                invoke: worker.call({
+                    fnNumber: index,
+                    timeout,
+                    abortSignal,
+                }),
+            }));
+        }
+    }
+    const useDirectHandler = (threads ?? 1) === 1 && !usingInliner;
+    const buildInvoker = (handlers) => useDirectHandler
+        ? handlers[0]
+        : managerMethod({
+            contexts: workers,
+            balancer,
+            handlers,
+            inlinerGate: usingInliner
+                ? {
+                    index: inlinerIndex,
+                    threshold: inlinerDispatchThreshold,
+                }
+                : undefined,
+        });
+    const callEntries = Array.from(callHandlers.entries(), ([name, handlers]) => [name, buildInvoker(handlers)]);
+    return {
+        shutdown: shutdownWithDelay,
+        call: Object.fromEntries(callEntries),
+    };
+};
+const SINGLE_TASK_KEY = "__task__";
+const DEFAULT_IMPORT_EXPORT_NAME = "default";
+const createSingleTaskPool = (single, options) => {
+    const pool = createPool(options ?? {})({
+        [SINGLE_TASK_KEY]: single,
+    });
+    return {
+        call: pool.call[SINGLE_TASK_KEY],
+        shutdown: pool.shutdown,
+    };
+};
+const buildTaskDefinitionFromCaller = (input, callerHref, at) => {
+    const importedFrom = new URL(callerHref).href;
+    const out = ({
+        ...input,
+        id: genTaskID(),
+        importedFrom,
+        at,
+        [endpointSymbol]: true,
+    });
+    out.createPool = (options) => {
+        if (RUNTIME_IS_MAIN_THREAD === false) {
+            return out;
+        }
+        return createSingleTaskPool(out, options);
+    };
+    return out;
+};
+const buildTaskDefinition = (input, callerOffset) => {
+    const [href, at] = getCallerFilePath(callerOffset);
+    return buildTaskDefinitionFromCaller(input, href, at);
+};
+const resolveImportHref = (href, callerHref) => {
+    try {
+        return new URL(href, callerHref).href;
+    }
+    catch {
+        return toModuleUrl(href);
+    }
+};
+const createImportedTaskFn = (href, exportName) => {
+    let cachedFn;
+    let cachedLoad;
+    const loadFn = async () => {
+        if (cachedFn)
+            return cachedFn;
+        if (!cachedLoad) {
+            cachedLoad = import(__rewriteRelativeImportExtension(href)).then((module) => {
+                const record = module;
+                const selected = exportName === DEFAULT_IMPORT_EXPORT_NAME
+                    ? record.default
+                    : record[exportName];
+                if (typeof selected !== "function") {
+                    const available = Object.keys(record).join(", ");
+                    throw new TypeError(`importTask expected export "${exportName}" from "${href}" to be a function.` +
+                        ` Available exports: ${available || "(none)"}`);
+                }
+                cachedFn = selected;
+                return cachedFn;
+            });
+        }
+        return cachedLoad;
+    };
+    return (async (...args) => {
+        const fn = await loadFn();
+        return fn(...args);
+    });
+};
+export function task(I) {
+    return buildTaskDefinition(I, 4);
+}
+export function importTask(options) {
+    const [callerHref, at] = getCallerFilePath(3);
+    const { href, name = DEFAULT_IMPORT_EXPORT_NAME, ...rest } = options;
+    const resolvedHref = resolveImportHref(href, callerHref);
+    return buildTaskDefinitionFromCaller({
+        ...rest,
+        f: createImportedTaskFn(resolvedHref, name),
+    }, callerHref, at);
+}

package/src/common/envelope.d.ts

@@ -0,0 +1,11 @@
+type EnvelopeHeaderPrimitive = string | number | boolean | null;
+type EnvelopeHeaderValue = EnvelopeHeaderPrimitive | EnvelopeHeaderValue[] | {
+    [key: string]: EnvelopeHeaderValue;
+};
+export type EnvelopeHeader = EnvelopeHeaderValue;
+export declare class Envelope<H extends EnvelopeHeader = EnvelopeHeader> {
+    readonly header: H;
+    readonly payload: ArrayBuffer;
+    constructor(header: H, payload: ArrayBuffer);
+}
+export {};

package/src/common/envelope.js

@@ -0,0 +1,8 @@
+export class Envelope {
+    header;
+    payload;
+    constructor(header, payload) {
+        this.header = header;
+        this.payload = payload;
+    }
+}

package/src/common/module-url.d.ts

@@ -0,0 +1 @@
+export declare const toModuleUrl: (specifier: string) => string;

package/src/common/module-url.js

@@ -0,0 +1,24 @@
+import { pathToFileURL } from "node:url";
+const WINDOWS_DRIVE_PATH = /^[A-Za-z]:[\\/]/;
+const WINDOWS_UNC_PATH = /^\\\\[^\\/?]+\\[^\\/?]+/;
+const encodeFilePath = (path) => encodeURI(path)
+    .replace(/\?/g, "%3F")
+    .replace(/#/g, "%23");
+export const toModuleUrl = (specifier) => {
+    if (WINDOWS_DRIVE_PATH.test(specifier)) {
+        const normalized = specifier.replace(/\\/g, "/");
+        return `file:///${encodeFilePath(normalized)}`;
+    }
+    if (WINDOWS_UNC_PATH.test(specifier)) {
+        const normalized = specifier
+            .replace(/^\\\\+/, "")
+            .replace(/\\/g, "/");
+        return `file://${encodeFilePath(normalized)}`;
+    }
+    try {
+        return new URL(specifier).href;
+    }
+    catch {
+        return pathToFileURL(specifier).href;
+    }
+};

package/src/common/node-compat.d.ts

@@ -0,0 +1,20 @@
+export type NodeProcessLike = {
+    getBuiltinModule?: (id: string) => unknown;
+    versions?: {
+        node?: string;
+    };
+    platform?: string;
+    allowedNodeEnvironmentFlags?: ReadonlySet<string>;
+    execArgv?: string[];
+    execPath?: string;
+    cwd?: () => string;
+    env?: Record<string, string | undefined>;
+    on?: (event: string, handler: (...args: unknown[]) => void) => unknown;
+};
+export type NodeCallSiteLike = {
+    getFileName?: () => string | null | undefined;
+    getFunctionName?: () => string | null | undefined;
+    getMethodName?: () => string | null | undefined;
+};
+export declare const getNodeProcess: () => NodeProcessLike | undefined;
+export declare const getNodeBuiltinModule: <T>(specifier: string) => T | undefined;

package/src/common/node-compat.js

@@ -0,0 +1,24 @@
+const nodeProcess = (() => {
+    const candidate = globalThis
+        .process;
+    return typeof candidate?.versions?.node === "string" ? candidate : undefined;
+})();
+export const getNodeProcess = () => nodeProcess;
+export const getNodeBuiltinModule = (specifier) => {
+    const getter = nodeProcess?.getBuiltinModule;
+    if (typeof getter !== "function")
+        return undefined;
+    try {
+        return getter.call(nodeProcess, specifier);
+    }
+    catch {
+    }
+    if (!specifier.startsWith("node:"))
+        return undefined;
+    try {
+        return getter.call(nodeProcess, specifier.slice(5));
+    }
+    catch {
+        return undefined;
+    }
+};

package/src/common/path-canonical.d.ts

@@ -0,0 +1,6 @@
+type CanonicalPathFsApi = {
+    existsSync?: (candidate: string) => boolean;
+    realpathSync?: (candidate: string) => string;
+};
+export declare const toCanonicalPath: (candidate: string, fsApi?: CanonicalPathFsApi) => string;
+export {};

package/src/common/path-canonical.js

@@ -0,0 +1,41 @@
+import { existsSync, realpathSync, } from "node:fs";
+import { basename as pathBasename, dirname as pathDirname, join as pathJoin, resolve as pathResolve, } from "node:path";
+export const toCanonicalPath = (candidate, fsApi = {
+    existsSync,
+    realpathSync: realpathSync.native ?? realpathSync,
+}) => {
+    const absolute = pathResolve(candidate);
+    const { existsSync, realpathSync } = fsApi;
+    if (typeof realpathSync === "function") {
+        try {
+            return pathResolve(realpathSync(absolute));
+        }
+        catch {
+        }
+    }
+    else {
+        return absolute;
+    }
+    if (typeof existsSync !== "function")
+        return absolute;
+    const missingSegments = [];
+    let cursor = absolute;
+    while (!existsSync(cursor)) {
+        const parent = pathDirname(cursor);
+        if (parent === cursor)
+            return absolute;
+        missingSegments.push(pathBasename(cursor));
+        cursor = parent;
+    }
+    let base = cursor;
+    try {
+        base = realpathSync(cursor);
+    }
+    catch {
+    }
+    let rebuilt = base;
+    for (let i = missingSegments.length - 1; i >= 0; i--) {
+        rebuilt = pathJoin(rebuilt, missingSegments[i]);
+    }
+    return pathResolve(rebuilt);
+};

package/src/common/runtime.d.ts

@@ -0,0 +1,15 @@
+type RuntimeName = "deno" | "bun" | "node" | "unknown";
+export declare const IS_DENO: boolean;
+export declare const IS_BUN: boolean;
+export declare const IS_NODE: boolean;
+export declare const RUNTIME: RuntimeName;
+export declare const SET_IMMEDIATE: typeof setImmediate & ((cb: () => void) => void);
+export declare const HAS_SHARED_WASM_MEMORY: boolean;
+export declare const createWasmSharedArrayBuffer: (byteLength: number, maxByteLength?: number) => SharedArrayBuffer;
+export declare const HAS_SAB_GROW: boolean;
+export declare const createSharedArrayBuffer: (byteLength: number, maxByteLength?: number) => SharedArrayBuffer;
+export declare const isWasmSharedArrayBuffer: (sab: SharedArrayBuffer) => boolean;
+export declare const isGrowableSharedArrayBuffer: (sab: SharedArrayBuffer) => boolean;
+export declare const sharedArrayBufferMaxByteLength: (sab: SharedArrayBuffer) => number;
+export declare const growSharedArrayBuffer: (sab: SharedArrayBuffer, byteLength: number) => SharedArrayBuffer;
+export {};