@primate/core 0.1.10 → 0.2.1

package/lib/private/wasm/encode-string-map.js

@@ -0,0 +1,14 @@
+import encodeString from "#wasm/encode-string";
+const encodeStringMap = (map, view) => {
+    // only "set" entries are allowed
+    const entries = Object.entries(map)
+        .filter(([, value]) => value && value.length > 0);
+    const count = entries.length;
+    view.writeU32(count);
+    for (const [key, value] of entries) {
+        encodeString(key, view);
+        encodeString(value, view);
+    }
+};
+export default encodeStringMap;
+//# sourceMappingURL=encode-string-map.js.map

package/lib/private/wasm/encode-string.d.ts

@@ -0,0 +1,13 @@
+import type BufferView from "@rcompat/bufferview";
+/**
+ * Encoding a string has the following format:
+ * - I32: length
+ * - U8[length]: bytes
+ *
+ * @param string - The string to encode
+ * @param offset - The offset to encode the string at.
+ * @param view - The buffer view to encode the string into.
+ * @returns The next offset.
+ */
+export default function encodeString(string: string, view: BufferView): void;
+//# sourceMappingURL=encode-string.d.ts.map

package/lib/private/wasm/encode-string.js

@@ -0,0 +1,17 @@
+import utf8size from "@rcompat/string/utf8size";
+/**
+ * Encoding a string has the following format:
+ * - I32: length
+ * - U8[length]: bytes
+ *
+ * @param string - The string to encode
+ * @param offset - The offset to encode the string at.
+ * @param view - The buffer view to encode the string into.
+ * @returns The next offset.
+ */
+export default function encodeString(string, view) {
+    view.writeU32(utf8size(string))
+        .write(string);
+}
+;
+//# sourceMappingURL=encode-string.js.map

package/lib/private/wasm/encode-url.d.ts

@@ -0,0 +1,11 @@
+import type BufferView from "@rcompat/bufferview";
+/**
+ * Encode a url as a string into a bufferView.
+ *
+ * @param url - The url to encode.
+ * @param offset - The offset to encode the url at.
+ * @param view - The buffer view to encode the url into.
+ * @returns The next offset.
+ */
+export default function encodeURL(url: URL, view: BufferView): void;
+//# sourceMappingURL=encode-url.d.ts.map

package/lib/private/wasm/encode-url.js

@@ -0,0 +1,14 @@
+import encodeString from "#wasm/encode-string";
+/**
+ * Encode a url as a string into a bufferView.
+ *
+ * @param url - The url to encode.
+ * @param offset - The offset to encode the url at.
+ * @param view - The buffer view to encode the url into.
+ * @returns The next offset.
+ */
+export default function encodeURL(url, view) {
+    return encodeString(url.toString(), view);
+}
+;
+//# sourceMappingURL=encode-url.js.map

package/lib/private/wasm/encode-websocket-close.d.ts

@@ -0,0 +1,2 @@
+export default function encodeWebsocketClose(id: bigint): Uint8Array<ArrayBuffer>;
+//# sourceMappingURL=encode-websocket-close.d.ts.map

package/lib/private/wasm/encode-websocket-close.js

@@ -0,0 +1,7 @@
+export default function encodeWebsocketClose(id) {
+    const buffer = new BigUint64Array(1);
+    buffer[0] = id;
+    return new Uint8Array(buffer.buffer);
+}
+;
+//# sourceMappingURL=encode-websocket-close.js.map

package/lib/private/wasm/encode-websocket-message.d.ts

@@ -0,0 +1,4 @@
+type Message = string | Uint8Array;
+export default function encodeWebsocketMessage(id: bigint, message: Message): Uint8Array<ArrayBuffer>;
+export {};
+//# sourceMappingURL=encode-websocket-message.d.ts.map

package/lib/private/wasm/encode-websocket-message.js

@@ -0,0 +1,30 @@
+import buffersize from "#wasm/buffersize";
+import encodeBuffer from "#wasm/encode-buffer";
+import encodeString from "#wasm/encode-string";
+import I32_SIZE from "#wasm/I32_SIZE";
+import stringSize from "#wasm/stringsize";
+import BufferView from "@rcompat/bufferview";
+const SIZE_I64 = BigInt64Array.BYTES_PER_ELEMENT;
+const WEBSOCKET_MESSAGE_KIND_STRING = 0;
+const WEBSOCKET_MESSAGE_KIND_BYTES = 1;
+export default function encodeWebsocketMessage(id, message) {
+    const size = SIZE_I64 // WebsocketID
+        + I32_SIZE // Kind
+        + (typeof message === "string"
+            ? stringSize(message)
+            : buffersize(message));
+    const output = new Uint8Array(size);
+    const bufferView = new BufferView(output);
+    bufferView.writeU64(id);
+    if (typeof message === "string") {
+        bufferView.writeU32(WEBSOCKET_MESSAGE_KIND_STRING);
+        encodeString(message, bufferView);
+    }
+    else {
+        bufferView.writeU32(WEBSOCKET_MESSAGE_KIND_BYTES);
+        encodeBuffer(message, bufferView);
+    }
+    return output;
+}
+;
+//# sourceMappingURL=encode-websocket-message.js.map

package/lib/private/wasm/encode-websocket-open.d.ts

@@ -0,0 +1,2 @@
+export default function encodeWebsocketOpen(id: bigint): Uint8Array<ArrayBuffer>;
+//# sourceMappingURL=encode-websocket-open.d.ts.map

package/lib/private/wasm/encode-websocket-open.js

@@ -0,0 +1,7 @@
+export default function encodeWebsocketOpen(id) {
+    const buffer = new BigUint64Array(1);
+    buffer[0] = id;
+    return new Uint8Array(buffer.buffer);
+}
+;
+//# sourceMappingURL=encode-websocket-open.js.map

package/lib/private/wasm/filesize.d.ts

@@ -0,0 +1,2 @@
+export default function filesize(file: File): number;
+//# sourceMappingURL=filesize.d.ts.map

package/lib/private/wasm/filesize.js

@@ -0,0 +1,8 @@
+import I32_SIZE from "#wasm/I32_SIZE";
+import stringSize from "./stringsize.js";
+export default function filesize(file) {
+    return stringSize(file.name)
+        + stringSize(file.type)
+        + I32_SIZE + file.size;
+}
+//# sourceMappingURL=filesize.js.map

package/lib/private/wasm/instantiate.d.ts

@@ -0,0 +1,37 @@
+import type DatabaseStore from "#database/Store";
+import type API from "#wasm/API";
+import type Instantiation from "#wasm/Instantiation";
+import type Tagged from "#wasm/Tagged";
+import MaybePromise from "@rcompat/type/MaybePromise";
+import StoreSchema from "pema/StoreSchema";
+type Init = {
+    filename: string;
+    imports?: WebAssembly.Imports;
+    stores: Record<string, DatabaseStore<StoreSchema>>;
+};
+export type { API };
+export type AnyWasmValue = number | bigint | Tagged<"Request", number>;
+export type AnyWasmReturnValue = MaybePromise<AnyWasmValue | undefined | void>;
+export type AnyWasmFunction<Args extends readonly AnyWasmValue[], R extends AnyWasmReturnValue> = (...args: Args) => R;
+export declare const wrapPromising: <Args extends readonly AnyWasmValue[], R extends AnyWasmReturnValue>(fn: AnyWasmFunction<Args, R>) => AnyWasmFunction<Args, R>;
+export declare const wrapSuspending: <Args extends readonly AnyWasmValue[], R extends AnyWasmReturnValue>(fn: AnyWasmFunction<Args, R>, alt: AnyWasmFunction<Args, R>) => WebAssembly.ImportValue;
+declare global {
+    namespace WebAssembly {
+        const promising: undefined | (<Args extends readonly AnyWasmValue[], R extends AnyWasmReturnValue>(fn: AnyWasmFunction<Args, R>) => AnyWasmFunction<Args, R>);
+        class Suspending<T> {
+            constructor(fn: T);
+        }
+    }
+}
+/**
+ * Instantiate a WASM module from a file reference and the given web assembly
+ * imports.
+ *
+ * @param ref The file reference to the WASM module.
+ * @param imports The imports to pass to the WASM module when instantiating it.
+ * @returns The instantiated WASM module, its exports, and the API that Primate
+ * exposes to the WASM module.
+ */
+declare const instantiate: (args: Init) => Promise<Instantiation<number, number>>;
+export default instantiate;
+//# sourceMappingURL=instantiate.d.ts.map

package/lib/private/wasm/instantiate.js

@@ -0,0 +1,408 @@
+import verbs from "#request/verbs";
+import text from "#response/text";
+import session from "#session/index";
+import decodeJson from "#wasm/decode-json";
+import decodeResponse from "#wasm/decode-response";
+import decodeWebsocketClose from "#wasm/decode-websocket-close";
+import decodeWebsocketSendMessage from "#wasm/decode-websocket-send";
+import encodeRequest from "#wasm/encode-request";
+import encodeSession from "#wasm/encode-session";
+import assert from "@rcompat/assert";
+import BufferView from "@rcompat/bufferview";
+import FileRef from "@rcompat/fs/FileRef";
+import { WASI } from "node:wasi";
+import encodeString from "./encode-string.js";
+import utf8size from "@rcompat/string/utf8size";
+import decodeString from "./decode-string.js";
+export const wrapPromising = (fn) => typeof WebAssembly.promising === "function"
+    ? WebAssembly.promising(fn)
+    : fn;
+export const wrapSuspending = (fn, alt) => typeof WebAssembly.Suspending === "function"
+    ? new WebAssembly.Suspending(fn)
+    : alt;
+const STORE_OPERATION_SUCCESS = 0;
+const STORE_NOT_FOUND_ERROR = 1;
+const STORE_RECORD_NOT_FOUND_ERROR = 2;
+const STORE_UNKNOWN_ERROR_OCCURRED = 3;
+const STORE_SCHEMA_INVALID_RECORD_ERROR = 4;
+const STORE_OPERATION_NOT_SUPPORTED = 5;
+/**
+ * Instantiate a WASM module from a file reference and the given web assembly
+ * imports.
+ *
+ * @param ref The file reference to the WASM module.
+ * @param imports The imports to pass to the WASM module when instantiating it.
+ * @returns The instantiated WASM module, its exports, and the API that Primate
+ * exposes to the WASM module.
+ */
+const instantiate = async (args) => {
+    const wasmFileRef = new FileRef(args.filename);
+    const wasmImports = args.imports ?? {};
+    const storesByName = args.stores;
+    const storeIdsByName = new Map(Object.keys(storesByName).map((e, i) => [e, i]));
+    const stores = new Map(Array.from(storeIdsByName.entries())
+        .map(([name, id]) => [id, storesByName[name]]));
+    // default payload is set to an empty buffer via setPayloadBuffer
+    let payload = new Uint8Array(0);
+    let received = new Uint8Array(0);
+    const setPayload = (value) => {
+        payload = value;
+    };
+    const sockets = new Map();
+    /**
+     * Get the current session and set it as the payload. This method should
+     * only be called after a JSON payload has been received via the `send`
+     * function.
+     */
+    const sessionGet = () => {
+        payload = encodeSession(session());
+    };
+    /**
+     * Create a new session and set it as the current session. This method
+     * should only be called after a JSON payload has been received via the
+     * `send` function.
+     *
+     * Once the session has been created, the `payload` should be set to the
+     * encoded session, and then `payloadByteLength` and `receive` should be
+     * called to send the payload to the WASM module.
+     */
+    const sessionNew = () => {
+        const data = decodeJson.from(received);
+        session().create(data);
+        payload = encodeSession(session());
+    };
+    /**
+     * Check to see if a session exists.
+     *
+     * @returns {1 | 0}
+     */
+    const sessionExists = () => {
+        return session().exists ? 1 : 0;
+    };
+    /**
+     * Set the current session.
+     */
+    const sessionSet = () => {
+        const data = decodeJson.from(received);
+        session().set(data);
+    };
+    /**
+     * Get the length of the current active payload.
+     *
+     * @returns The length of the payload.
+     */
+    const payloadByteLength = () => {
+        return payload.byteLength;
+    };
+    /**
+     * Send the current active payload to the WASM module.
+     *
+     * @param ptr The pointer to where the payload should be written into the
+     * WASM linear memory space.
+     * @param length The length of the payload. This must match the actual
+     * payload length, otherwise an exception will be thrown.
+     */
+    const receive = (ptr, length) => {
+        assert(payload.length === length, "Payload length mismatch");
+        const wasmBuffer = new Uint8Array(memory.buffer, ptr, length);
+        wasmBuffer.set(payload);
+    };
+    /**
+     * Send a payload from the WASM module to Primate.
+     *
+     * @param ptr The pointer to the payload in the WASM linear memory space.
+     * @param length The length of the payload.
+     */
+    const send = (ptr, length) => {
+        const wasmBuffer = new Uint8Array(memory.buffer, ptr, length);
+        const output = new Uint8Array(length);
+        output.set(wasmBuffer);
+        received = output;
+    };
+    /**
+     * Close a WebSocket.
+     */
+    const websocketClose = () => {
+        const { id } = decodeWebsocketClose(payload);
+        assert(sockets.has(id), "Invalid socket id. Was the socket already closed?");
+        const socket = sockets.get(id);
+        socket.close();
+        sockets.delete(id);
+    };
+    /**
+     * Send a WebSocket message to a given socket by it's id.
+     */
+    const websocketSend = () => {
+        const { id, message } = decodeWebsocketSendMessage(payload);
+        assert(sockets.has(id), `Invalid socket id ${id}. Was the socket already closed?`);
+        const socket = sockets.get(id);
+        socket.send(message);
+    };
+    /** Default Store operation for when Suspending isn't supported. */
+    const storeOperationNotSupported = (_id) => STORE_OPERATION_NOT_SUPPORTED;
+    /**
+     * Count the number of records that match the query.
+     *
+     * @param {StoreID} id - The ID of the store.
+     * @returns {STORE_OPERATION_RESULT}
+     */
+    const storeCount = wrapSuspending(async (id) => {
+        if (!stores.has(id))
+            return STORE_NOT_FOUND_ERROR;
+        const store = stores.get(id);
+        const criteria = decodeJson(new BufferView(received));
+        const count = await store.count(criteria);
+        payload = new Uint8Array(4);
+        new DataView(payload.buffer).setUint32(0, count, true);
+        return STORE_OPERATION_SUCCESS;
+    }, storeOperationNotSupported);
+    /**
+     * Delete a record by it's id.
+     *
+     * @param {StoreID} id - The ID of the store.
+     * @returns {STORE_OPERATION_RESULT}
+     */
+    const storeDelete = wrapSuspending(async (id) => {
+        if (!stores.has(id))
+            return STORE_NOT_FOUND_ERROR;
+        const store = stores.get(id);
+        try {
+            const id = decodeJson(new BufferView(received));
+            await store.delete(id);
+            return STORE_OPERATION_SUCCESS;
+        }
+        catch (ex) {
+            return STORE_RECORD_NOT_FOUND_ERROR;
+        }
+    }, storeOperationNotSupported);
+    /**
+     * Get a store by it's "import", and return it to wasm.
+     *
+     * @returns {STORE_OPERATION_RESULT}
+     */
+    const storeImport = () => {
+        const storeName = decodeString(new BufferView(received));
+        if (storeIdsByName.has(storeName)) {
+            payload = new Uint8Array(4);
+            new DataView(payload.buffer).setUint32(0, storeIdsByName.get(storeName), true);
+            return STORE_OPERATION_SUCCESS;
+        }
+        return STORE_NOT_FOUND_ERROR;
+    };
+    /**
+     * Find records in a store.
+     *
+     * @param {StoreID} id - The id of the store.
+     * @returns {STORE_OPERATION_RESULT}
+     */
+    const storeFind = wrapSuspending(async (id) => {
+        if (!stores.has(id))
+            return STORE_NOT_FOUND_ERROR;
+        const store = stores.get(id);
+        const query = decodeJson(new BufferView(received));
+        try {
+            const records = await store.find(query);
+            const recordsPayload = JSON.stringify(records);
+            payload = new Uint8Array(utf8size(recordsPayload) + 4);
+            encodeString(recordsPayload, new BufferView(payload));
+            return STORE_OPERATION_SUCCESS;
+        }
+        catch (ex) {
+            return STORE_UNKNOWN_ERROR_OCCURRED;
+        }
+    }, storeOperationNotSupported);
+    /**
+     * Get a record by it's id.
+     *
+     * @param {StoreID} id - The id of the store.
+     * @returns {STORE_OPERATION_RESULT}
+     */
+    const storeGet = wrapSuspending(async (id) => {
+        if (!stores.has(id))
+            return STORE_NOT_FOUND_ERROR;
+        const store = stores.get(id);
+        const recordId = decodeString(new BufferView(received));
+        const record = await store.try(recordId);
+        if (record) {
+            const recordPayload = JSON.stringify(record);
+            payload = new Uint8Array(utf8size(recordPayload) + 4);
+            encodeString(recordPayload, new BufferView(payload));
+            return STORE_OPERATION_SUCCESS;
+        }
+        else {
+            return STORE_RECORD_NOT_FOUND_ERROR;
+        }
+    }, storeOperationNotSupported);
+    /**
+     * Check if a record exists based on a record id.
+     *
+     * @param {StoreID} id - The id of the store.
+     * @returns {STORE_OPERATION_RESULT}
+     */
+    const storeHas = wrapSuspending(async (id) => {
+        if (!stores.has(id))
+            return STORE_NOT_FOUND_ERROR;
+        const store = stores.get(id);
+        const recordId = decodeString(new BufferView(received));
+        if (await store.has(recordId)) {
+            payload = new Uint8Array(4);
+            payload[0] = 1;
+        }
+        else {
+            payload = new Uint8Array(4);
+        }
+        return STORE_OPERATION_SUCCESS;
+    }, storeOperationNotSupported);
+    /**
+     * Insert a record into a store.
+     *
+     * @param {StoreID} id - The id of the store.
+     * @returns {STORE_OPERATION_RESULT}
+     */
+    const storeInsert = wrapSuspending(async (id) => {
+        if (!stores.has(id))
+            return STORE_NOT_FOUND_ERROR;
+        const store = stores.get(id);
+        try {
+            const record = decodeJson(new BufferView(received));
+            const result = JSON.stringify(await store.insert(record));
+            payload = new Uint8Array(utf8size(result) + 4);
+            encodeString(result, new BufferView(payload));
+            return STORE_OPERATION_SUCCESS;
+        }
+        catch (ex) {
+            return STORE_SCHEMA_INVALID_RECORD_ERROR;
+        }
+    }, storeOperationNotSupported);
+    /**
+     * Update a record in a store by it's id.
+     *
+     * @param {StoreID} id - The id of the store.
+     * @returns {STORE_OPERATION_RESULT}
+     */
+    const storeUpdate = wrapSuspending(async (id) => {
+        if (!stores.has(id))
+            return STORE_NOT_FOUND_ERROR;
+        const store = stores.get(id);
+        try {
+            const view = new BufferView(received);
+            const id = decodeString(view);
+            const changes = decodeJson(view);
+            await store.update(id, changes);
+            return STORE_OPERATION_SUCCESS;
+        }
+        catch (ex) {
+            return STORE_SCHEMA_INVALID_RECORD_ERROR;
+        }
+    }, storeOperationNotSupported);
+    const storeClear = wrapSuspending(async (id) => {
+        if (!stores.has(id))
+            return STORE_NOT_FOUND_ERROR;
+        const store = stores.get(id);
+        await store.schema.delete();
+        await store.schema.create();
+        return STORE_OPERATION_SUCCESS;
+    }, storeOperationNotSupported);
+    /**
+     * The imports that Primate provides to the WASM module. This follows the
+     * Primate WASM ABI convention.
+     */
+    const primateImports = {
+        payloadByteLength,
+        receive,
+        send,
+        sessionExists,
+        sessionGet,
+        sessionNew,
+        sessionSet,
+        storeClear,
+        storeCount,
+        storeDelete,
+        storeFind,
+        storeGet,
+        storeHas,
+        storeImport,
+        storeInsert,
+        storeUpdate,
+        websocketClose,
+        websocketSend,
+    };
+    const bytes = await wasmFileRef.arrayBuffer();
+    const memory = new WebAssembly.Memory({ initial: 64 });
+    const instantiateDeno = async () => {
+        // @ts-expect-error: for deno, need to implement the std lib implementation
+        const Context = await import("https://deno.land/std@0.92.0/wasi/snapshot_preview1.ts");
+        const context = new Context({
+            args: Deno.args,
+            env: Deno.env.toObject(),
+            preopens: { "./": "./" },
+        });
+        const instance = await WebAssembly.instantiate(bytes, {
+            ...wasmImports,
+            "env": { memory },
+            "primate": primateImports,
+            "wasi_snapshot_preview1": context.exports,
+        });
+        return instance;
+    };
+    const defaultInstantiate = async () => {
+        const wasiSnapshotPreview1 = new WASI({ version: "preview1" });
+        const wasm = await WebAssembly.instantiate(bytes, {
+            ...wasmImports,
+            "env": { memory },
+            "primate": primateImports,
+            "wasi_snapshot_preview1": wasiSnapshotPreview1.wasiImport,
+        });
+        // start the wasi instance
+        wasiSnapshotPreview1.start(wasm.instance);
+        return wasm;
+    };
+    const wasm = typeof Deno !== "undefined"
+        ? await instantiateDeno()
+        : await defaultInstantiate();
+    const exports = wasm.instance.exports;
+    const api = {};
+    const instance = {
+        api,
+        exports,
+        memory,
+        setPayload,
+        sockets,
+    };
+    for (const method of verbs) {
+        if (method in exports && typeof exports[method] === "function") {
+            const methodFunc = wrapPromising(exports[method]);
+            api[method] = async (request) => {
+                // payload is now set
+                payload = await encodeRequest(request);
+                // immediately tell the wasm module to obtain the payload and create a
+                // request
+                const wasmRequest = exports.newRequest();
+                // call the http method and obtain the response, finalizing the request
+                const wasmResponse = await methodFunc(wasmRequest);
+                exports.finalizeRequest(wasmRequest);
+                // send the response to the wasm module and decode the response,
+                // finalizing the response
+                exports.sendResponse(wasmResponse);
+                const bufferView = new BufferView(received);
+                const response = decodeResponse(bufferView);
+                exports.finalizeResponse(wasmResponse);
+                if (response.type === "web_socket_upgrade") {
+                    // the callback encloses over the response websocket id provided by
+                    // the module.
+                    return response.callback(instance);
+                }
+                if (response.type === "text") {
+                    return text(response.text, {
+                        headers: response.headers,
+                        status: response.status,
+                    });
+                }
+                return response.value;
+            };
+        }
+    }
+    return instance;
+};
+export default instantiate;
+//# sourceMappingURL=instantiate.js.map

package/lib/private/wasm/open-websocket.d.ts

@@ -0,0 +1,4 @@
+import type Instantiation from "#wasm/Instantiation";
+declare const _default: (websocketId: bigint) => (api: Instantiation) => import("../response/ResponseFunction.js").default;
+export default _default;
+//# sourceMappingURL=open-websocket.d.ts.map

package/lib/private/wasm/open-websocket.js

@@ -0,0 +1,26 @@
+import websocket from "#response/ws";
+import encodeWebsocketClose from "#wasm/encode-websocket-close";
+import encodeWebsocketMessage from "#wasm/encode-websocket-message";
+import encodeWebsocketOpen from "#wasm/encode-websocket-open";
+export default (websocketId) => (api) => {
+    return websocket({
+        close(_socket) {
+            const socketClosePayload = encodeWebsocketClose(websocketId);
+            api.sockets.delete(websocketId);
+            api.setPayload(socketClosePayload);
+            api.exports.websocketClose();
+        },
+        message(_socket, message) {
+            const socketMessagePayload = encodeWebsocketMessage(websocketId, message);
+            api.setPayload(socketMessagePayload);
+            api.exports.websocketMessage();
+        },
+        open(socket) {
+            const socketOpenPayload = encodeWebsocketOpen(websocketId);
+            api.sockets.set(websocketId, socket);
+            api.setPayload(socketOpenPayload);
+            api.exports.websocketOpen();
+        },
+    });
+};
+//# sourceMappingURL=open-websocket.js.map

package/lib/private/wasm/stringsize.d.ts

@@ -0,0 +1,3 @@
+declare const stringSize: (string: string) => number;
+export default stringSize;
+//# sourceMappingURL=stringsize.d.ts.map

package/lib/private/wasm/stringsize.js

@@ -0,0 +1,5 @@
+import I32_SIZE from "#wasm/I32_SIZE";
+import utf8size from "@rcompat/string/utf8size";
+const stringSize = (string) => utf8size(string) + I32_SIZE;
+export default stringSize;
+//# sourceMappingURL=stringsize.js.map

package/lib/private/wasm/urlsize.d.ts

@@ -0,0 +1,2 @@
+export default function urlsize(url: URL): number;
+//# sourceMappingURL=urlsize.d.ts.map

package/lib/private/wasm/urlsize.js

@@ -0,0 +1,5 @@
+import stringSize from "#wasm/stringsize";
+export default function urlsize(url) {
+    return stringSize(url.toString());
+}
+//# sourceMappingURL=urlsize.js.map

package/lib/public/App.d.ts

@@ -0,0 +1,2 @@
+export { default } from "#App";
+//# sourceMappingURL=App.d.ts.map

package/lib/public/App.js

@@ -0,0 +1,2 @@
+export { default } from "#App";
+//# sourceMappingURL=App.js.map

package/lib/public/AppError.d.ts

@@ -0,0 +1,2 @@
+export { default } from "#AppError";
+//# sourceMappingURL=AppError.d.ts.map

package/lib/public/AppError.js

@@ -0,0 +1,2 @@
+export { default } from "#AppError";
+//# sourceMappingURL=AppError.js.map

package/lib/public/BuildApp.d.ts

@@ -0,0 +1,2 @@
+export { default } from "#BuildApp";
+//# sourceMappingURL=BuildApp.d.ts.map