raffel 1.0.15-next.239a2ec → 1.0.17-next.f28271f

package/dist/client/browser.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Raffel WebSocket Client SDK — Browser entry point
+ *
+ * Uses the native browser WebSocket API. No `ws` dependency needed.
+ *
+ * @example
+ * ```typescript
+ * import { createRaffelClient } from 'raffel/client/browser'
+ *
+ * const client = createRaffelClient({ url: 'wss://api.example.com/ws', token: 'xxx' })
+ *
+ * // RPC
+ * const user = await client.call('users.get', { id: '123' })
+ *
+ * // Channels
+ * const channel = client.subscribe('orders')
+ * channel.on('created', (data) => console.log(data))
+ *
+ * // Streams
+ * for await (const chunk of client.stream('logs.tail')) {
+ *   console.log(chunk)
+ * }
+ * ```
+ */
+export { createRaffelClient } from './create.js';
+export type { RaffelClientOptions, RaffelClient, ClientStream, CallOptions, ClientChannel, ClientChannelMember, } from './types.js';
+export { createReconnectController, getReconnectDelay } from './reconnect.js';
+export type { ReconnectConfig, ReconnectState } from './reconnect.js';
+export type { WebSocketLike, WebSocketConstructor } from './create.js';
+//# sourceMappingURL=browser.d.ts.map

package/dist/client/browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../../src/client/browser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAChD,YAAY,EACV,mBAAmB,EACnB,YAAY,EACZ,YAAY,EACZ,WAAW,EACX,aAAa,EACb,mBAAmB,GACpB,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,yBAAyB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AAC7E,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AACrE,YAAY,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA"}

package/dist/client/browser.js

@@ -0,0 +1,27 @@
+/**
+ * Raffel WebSocket Client SDK — Browser entry point
+ *
+ * Uses the native browser WebSocket API. No `ws` dependency needed.
+ *
+ * @example
+ * ```typescript
+ * import { createRaffelClient } from 'raffel/client/browser'
+ *
+ * const client = createRaffelClient({ url: 'wss://api.example.com/ws', token: 'xxx' })
+ *
+ * // RPC
+ * const user = await client.call('users.get', { id: '123' })
+ *
+ * // Channels
+ * const channel = client.subscribe('orders')
+ * channel.on('created', (data) => console.log(data))
+ *
+ * // Streams
+ * for await (const chunk of client.stream('logs.tail')) {
+ *   console.log(chunk)
+ * }
+ * ```
+ */
+export { createRaffelClient } from './create.js';
+export { createReconnectController, getReconnectDelay } from './reconnect.js';
+//# sourceMappingURL=browser.js.map

package/dist/client/browser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.js","sourceRoot":"","sources":["../../src/client/browser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAShD,OAAO,EAAE,yBAAyB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAA"}

package/dist/client/create.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Raffel WebSocket Client SDK — Universal (Browser + Node.js)
+ *
+ * This is the core client implementation that works in both environments.
+ * It uses the standard WebSocket API (addEventListener) which is supported
+ * by both native browser WebSocket and the `ws` npm package.
+ *
+ * @example Browser
+ * ```typescript
+ * import { createRaffelClient } from 'raffel/client/browser'
+ * const client = createRaffelClient({ url: 'wss://api.example.com/ws' })
+ * ```
+ *
+ * @example Node.js
+ * ```typescript
+ * import { createRaffelClient } from 'raffel/client'
+ * const client = createRaffelClient({ url: 'ws://localhost:3000/ws' })
+ * ```
+ */
+import type { RaffelClientOptions, RaffelClient } from './types.js';
+export type { RaffelClientOptions, RaffelClient, ClientStream, CallOptions, ClientChannel, ClientChannelMember, } from './types.js';
+export { createReconnectController, getReconnectDelay } from './reconnect.js';
+export type { ReconnectConfig, ReconnectState } from './reconnect.js';
+/**
+ * Minimal WebSocket interface that both browser native and `ws` package satisfy.
+ */
+export interface WebSocketLike {
+    readonly readyState: number;
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+    addEventListener(type: string, listener: (event: any) => void): void;
+}
+/**
+ * Constructor type for WebSocket-like objects.
+ */
+export interface WebSocketConstructor {
+    new (url: string, protocols?: string | string[]): WebSocketLike;
+    readonly CONNECTING: number;
+    readonly OPEN: number;
+}
+/**
+ * Create a Raffel WebSocket client (universal — works in browser and Node.js)
+ *
+ * @param options - Client configuration (url is required)
+ * @returns RaffelClient instance
+ */
+export declare function createRaffelClient(options: RaffelClientOptions): RaffelClient;
+export declare function createRaffelClient(url: string): RaffelClient;
+//# sourceMappingURL=create.d.ts.map

package/dist/client/create.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../src/client/create.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,KAAK,EACV,mBAAmB,EACnB,YAAY,EAKb,MAAM,YAAY,CAAA;AAEnB,YAAY,EACV,mBAAmB,EACnB,YAAY,EACZ,YAAY,EACZ,WAAW,EACX,aAAa,EACb,mBAAmB,GACpB,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,yBAAyB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AAC7E,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAoBrE;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3C,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,GAAG,IAAI,CAAA;CACrE;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,KAAI,GAAG,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,aAAa,CAAA;IAC9D,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAiCD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,mBAAmB,GAAG,YAAY,CAAA;AAC9E,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAAA"}

package/dist/client/create.js

@@ -0,0 +1,543 @@
+/**
+ * Raffel WebSocket Client SDK — Universal (Browser + Node.js)
+ *
+ * This is the core client implementation that works in both environments.
+ * It uses the standard WebSocket API (addEventListener) which is supported
+ * by both native browser WebSocket and the `ws` npm package.
+ *
+ * @example Browser
+ * ```typescript
+ * import { createRaffelClient } from 'raffel/client/browser'
+ * const client = createRaffelClient({ url: 'wss://api.example.com/ws' })
+ * ```
+ *
+ * @example Node.js
+ * ```typescript
+ * import { createRaffelClient } from 'raffel/client'
+ * const client = createRaffelClient({ url: 'ws://localhost:3000/ws' })
+ * ```
+ */
+import { createReconnectController } from './reconnect.js';
+export { createReconnectController, getReconnectDelay } from './reconnect.js';
+let idCounter = 0;
+function nextId() {
+    return `c_${++idCounter}_${Date.now().toString(36)}`;
+}
+/** WebSocket readyState constants (same in both browser and ws) */
+const WS_CONNECTING = 0;
+const WS_OPEN = 1;
+/**
+ * Resolve the WebSocket constructor to use.
+ * Priority: explicit option > globalThis.WebSocket
+ */
+function resolveWebSocket(explicit) {
+    const WS = explicit
+        ?? (typeof globalThis !== 'undefined' && globalThis.WebSocket);
+    if (!WS) {
+        throw new Error('No WebSocket implementation available. ' +
+            'In Node.js < 21, pass { WebSocket } from the "ws" package. ' +
+            'In browser, globalThis.WebSocket is used automatically.');
+    }
+    // WS is already a constructor — just attach constants if missing
+    const result = WS;
+    if (typeof result.CONNECTING !== 'number') {
+        Object.defineProperty(result, 'CONNECTING', { value: WS_CONNECTING });
+    }
+    if (typeof result.OPEN !== 'number') {
+        Object.defineProperty(result, 'OPEN', { value: WS_OPEN });
+    }
+    return result;
+}
+export function createRaffelClient(urlOrOptions) {
+    const opts = typeof urlOrOptions === 'string'
+        ? { url: urlOrOptions }
+        : urlOrOptions;
+    const { url, reconnect: autoReconnect = true, maxReconnectAttempts = Infinity, reconnectDelay = 1000, maxReconnectDelay = 30000, reconnectBackoff = 2, connectTimeout = 10000, requestTimeout = 30000, token, protocols, onConnect, onDisconnect, onReconnect, onError, } = opts;
+    const WS = resolveWebSocket(opts.WebSocket);
+    let ws = null;
+    let connected = false;
+    let intentionalClose = false;
+    const pendingRequests = new Map();
+    const pendingStreams = new Map();
+    const channelSubs = new Map();
+    // Build URL with token if provided
+    const wsUrl = token
+        ? `${url}${url.includes('?') ? '&' : '?'}token=${encodeURIComponent(token)}`
+        : url;
+    const reconnectController = createReconnectController({
+        maxAttempts: maxReconnectAttempts,
+        initialDelay: reconnectDelay,
+        maxDelay: maxReconnectDelay,
+        backoff: reconnectBackoff,
+    }, () => connect(), onReconnect);
+    function connect() {
+        if (ws && (ws.readyState === WS.CONNECTING || ws.readyState === WS.OPEN)) {
+            return;
+        }
+        const connectTimer = setTimeout(() => {
+            if (ws && ws.readyState === WS.CONNECTING) {
+                ws.close();
+            }
+        }, connectTimeout);
+        ws = new WS(wsUrl, protocols);
+        ws.addEventListener('open', () => {
+            clearTimeout(connectTimer);
+            connected = true;
+            reconnectController.reset();
+            onConnect?.();
+        });
+        ws.addEventListener('message', (event) => {
+            const data = event.data;
+            handleMessage(typeof data === 'string' ? data : String(data));
+        });
+        ws.addEventListener('close', (event) => {
+            clearTimeout(connectTimer);
+            connected = false;
+            const code = event.code ?? 1006;
+            const reasonStr = event.reason ?? '';
+            // Reject all pending requests
+            for (const [id, pending] of pendingRequests) {
+                if (pending.timer)
+                    clearTimeout(pending.timer);
+                pending.reject(new Error(`Connection closed: ${code} ${reasonStr}`));
+                pendingRequests.delete(id);
+            }
+            // Complete all pending streams with error
+            for (const [id, stream] of pendingStreams) {
+                stream.error = new Error(`Connection closed: ${code} ${reasonStr}`);
+                stream.done = true;
+                stream.notify?.();
+                stream.notify = null;
+                pendingStreams.delete(id);
+            }
+            onDisconnect?.(code, reasonStr);
+            // Auto-reconnect
+            if (!intentionalClose && autoReconnect) {
+                reconnectController.schedule();
+            }
+        });
+        ws.addEventListener('error', (event) => {
+            clearTimeout(connectTimer);
+            const error = event.error ?? event.message ?? 'WebSocket error';
+            onError?.(error instanceof Error ? error : new Error(String(error)));
+        });
+    }
+    /**
+     * Extract the base stream ID from compound IDs.
+     * Router generates IDs like `{baseId}:stream:data:{timestamp}`, `{baseId}:stream:end`, etc.
+     */
+    function extractBaseStreamId(id) {
+        const streamIdx = id.indexOf(':stream:');
+        if (streamIdx === -1)
+            return undefined;
+        return id.slice(0, streamIdx);
+    }
+    function handleMessage(raw) {
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            return; // Ignore unparseable messages
+        }
+        const type = parsed.type;
+        // --- Channel Messages ---
+        if (type === 'event' && parsed.channel) {
+            const channelName = parsed.channel;
+            const eventName = parsed.event;
+            const sub = channelSubs.get(channelName);
+            if (sub) {
+                // Update members for presence events
+                if (eventName === 'member_added' && parsed.data) {
+                    const memberData = parsed.data;
+                    sub.members.push(memberData);
+                }
+                else if (eventName === 'member_removed' && parsed.data) {
+                    const memberData = parsed.data;
+                    sub.members = sub.members.filter((m) => m.id !== memberData.id);
+                }
+                const handlers = sub.listeners.get(eventName);
+                if (handlers) {
+                    for (const handler of handlers) {
+                        handler(parsed.data);
+                    }
+                }
+                // Also fire wildcard '*' listeners
+                const wildcardHandlers = sub.listeners.get('*');
+                if (wildcardHandlers) {
+                    for (const handler of wildcardHandlers) {
+                        handler({ event: eventName, data: parsed.data });
+                    }
+                }
+            }
+            return;
+        }
+        // Handle subscribed response
+        if (type === 'subscribed') {
+            const channelName = parsed.channel;
+            const sub = channelSubs.get(channelName);
+            if (sub && parsed.members) {
+                sub.members = parsed.members;
+            }
+            const id = parsed.id;
+            if (id) {
+                const pending = pendingRequests.get(id);
+                if (pending) {
+                    if (pending.timer)
+                        clearTimeout(pending.timer);
+                    pending.resolve(parsed);
+                    pendingRequests.delete(id);
+                }
+            }
+            return;
+        }
+        // Handle subscribed:batch response
+        if (type === 'subscribed:batch') {
+            const id = parsed.id;
+            if (id) {
+                const pending = pendingRequests.get(id);
+                if (pending) {
+                    if (pending.timer)
+                        clearTimeout(pending.timer);
+                    pending.resolve(parsed);
+                    pendingRequests.delete(id);
+                }
+            }
+            return;
+        }
+        // Handle unsubscribed response
+        if (type === 'unsubscribed') {
+            const id = parsed.id;
+            if (id) {
+                const pending = pendingRequests.get(id);
+                if (pending) {
+                    if (pending.timer)
+                        clearTimeout(pending.timer);
+                    pending.resolve(parsed);
+                    pendingRequests.delete(id);
+                }
+            }
+            return;
+        }
+        // Handle auth:refreshed response
+        if (type === 'auth:refreshed') {
+            const id = parsed.id;
+            if (id) {
+                const pending = pendingRequests.get(id);
+                if (pending) {
+                    if (pending.timer)
+                        clearTimeout(pending.timer);
+                    pending.resolve(parsed);
+                    pendingRequests.delete(id);
+                }
+            }
+            return;
+        }
+        // --- Envelope Messages ---
+        const id = parsed.id;
+        if (!id)
+            return;
+        // Handle channel-level errors (with id)
+        if (type === 'error' && (parsed.code || parsed.status)) {
+            const pending = pendingRequests.get(id);
+            if (pending) {
+                if (pending.timer)
+                    clearTimeout(pending.timer);
+                const error = new Error(parsed.message ?? 'Unknown error');
+                error.code = parsed.code;
+                error.status = parsed.status;
+                pending.reject(error);
+                pendingRequests.delete(id);
+                return;
+            }
+        }
+        // Check if this is a stream chunk
+        if (type === 'stream:data' || type === 'stream:chunk') {
+            const baseId = extractBaseStreamId(id);
+            const stream = pendingStreams.get(id) ?? (baseId ? pendingStreams.get(baseId) : undefined);
+            if (stream) {
+                stream.queue.push(parsed.payload);
+                stream.notify?.();
+                stream.notify = null;
+            }
+            return;
+        }
+        // Stream start (ack from server)
+        if (type === 'stream:start') {
+            return;
+        }
+        // Stream end
+        if (type === 'stream:end') {
+            const baseId = extractBaseStreamId(id);
+            const stream = pendingStreams.get(id) ?? (baseId ? pendingStreams.get(baseId) : undefined);
+            if (stream) {
+                stream.done = true;
+                stream.notify?.();
+                stream.notify = null;
+                pendingStreams.delete(id);
+                if (baseId)
+                    pendingStreams.delete(baseId);
+            }
+            return;
+        }
+        // Stream error
+        if (type === 'stream:error') {
+            const baseId = extractBaseStreamId(id);
+            const stream = pendingStreams.get(id) ?? (baseId ? pendingStreams.get(baseId) : undefined);
+            if (stream) {
+                const payload = parsed.payload;
+                stream.error = new Error(payload?.message ?? 'Stream error');
+                stream.done = true;
+                stream.notify?.();
+                stream.notify = null;
+                pendingStreams.delete(id);
+                if (baseId)
+                    pendingStreams.delete(baseId);
+            }
+            return;
+        }
+        // Error response
+        if (type === 'error') {
+            const baseId = id.endsWith(':error') ? id.slice(0, -6) : id;
+            const pending = pendingRequests.get(baseId) ?? pendingRequests.get(id);
+            if (pending) {
+                if (pending.timer)
+                    clearTimeout(pending.timer);
+                const payload = parsed.payload;
+                const error = new Error(payload?.message ?? 'Unknown error');
+                error.code = payload?.code;
+                pending.reject(error);
+                pendingRequests.delete(baseId);
+                pendingRequests.delete(id);
+            }
+            return;
+        }
+        // Response (procedure result)
+        if (type === 'response') {
+            const baseId = id.endsWith(':response') ? id.slice(0, -9) : id;
+            const pending = pendingRequests.get(baseId) ?? pendingRequests.get(id);
+            if (pending) {
+                if (pending.timer)
+                    clearTimeout(pending.timer);
+                pending.resolve(parsed.payload);
+                pendingRequests.delete(baseId);
+                pendingRequests.delete(id);
+            }
+            return;
+        }
+    }
+    function send(message) {
+        if (!ws || ws.readyState !== WS.OPEN) {
+            throw new Error('Not connected');
+        }
+        ws.send(JSON.stringify(message));
+    }
+    // Connect immediately
+    connect();
+    const client = {
+        call(procedure, payload, callOptions) {
+            return new Promise((resolve, reject) => {
+                if (!ws || ws.readyState !== WS.OPEN) {
+                    reject(new Error('Not connected'));
+                    return;
+                }
+                const id = nextId();
+                const timeout = callOptions?.timeout ?? requestTimeout;
+                const timer = timeout > 0
+                    ? setTimeout(() => {
+                        pendingRequests.delete(id);
+                        reject(new Error(`Request timeout: ${procedure}`));
+                    }, timeout)
+                    : undefined;
+                pendingRequests.set(id, {
+                    resolve: resolve,
+                    reject,
+                    timer,
+                });
+                try {
+                    send({
+                        id,
+                        procedure,
+                        type: 'request',
+                        payload: payload ?? {},
+                        metadata: callOptions?.metadata ?? {},
+                    });
+                }
+                catch (err) {
+                    if (timer)
+                        clearTimeout(timer);
+                    pendingRequests.delete(id);
+                    reject(err);
+                }
+            });
+        },
+        stream(procedure, payload, callOptions) {
+            const id = nextId();
+            const streamState = {
+                queue: [],
+                notify: null,
+                done: false,
+            };
+            pendingStreams.set(id, streamState);
+            // Send the stream request
+            try {
+                send({
+                    id,
+                    procedure,
+                    type: 'stream:start',
+                    payload: payload ?? {},
+                    metadata: callOptions?.metadata ?? {},
+                });
+            }
+            catch (err) {
+                streamState.error = err;
+                streamState.done = true;
+                pendingStreams.delete(id);
+            }
+            const iterator = {
+                async next() {
+                    while (true) {
+                        if (streamState.queue.length > 0) {
+                            return { value: streamState.queue.shift(), done: false };
+                        }
+                        if (streamState.done) {
+                            if (streamState.error)
+                                throw streamState.error;
+                            return { value: undefined, done: true };
+                        }
+                        await new Promise((r) => { streamState.notify = r; });
+                    }
+                },
+            };
+            return {
+                [Symbol.asyncIterator]() {
+                    return iterator;
+                },
+                cancel() {
+                    streamState.done = true;
+                    streamState.notify?.();
+                    streamState.notify = null;
+                    pendingStreams.delete(id);
+                    try {
+                        send({ id, type: 'cancel' });
+                    }
+                    catch {
+                        // Ignore send errors on cancel
+                    }
+                },
+            };
+        },
+        subscribe(channel, since) {
+            const sub = {
+                listeners: new Map(),
+                members: [],
+            };
+            channelSubs.set(channel, sub);
+            const msgId = nextId();
+            try {
+                send({
+                    id: msgId,
+                    type: 'subscribe',
+                    channel,
+                    ...(since ? { since } : {}),
+                });
+            }
+            catch {
+                // Will be handled by reconnection
+            }
+            const clientChannel = {
+                on(event, handler) {
+                    let handlers = sub.listeners.get(event);
+                    if (!handlers) {
+                        handlers = new Set();
+                        sub.listeners.set(event, handlers);
+                    }
+                    handlers.add(handler);
+                },
+                off(event, handler) {
+                    const handlers = sub.listeners.get(event);
+                    if (handlers) {
+                        handlers.delete(handler);
+                        if (handlers.size === 0)
+                            sub.listeners.delete(event);
+                    }
+                },
+                unsubscribe() {
+                    client.unsubscribe(channel);
+                },
+                get name() {
+                    return channel;
+                },
+                get members() {
+                    return sub.members;
+                },
+            };
+            return clientChannel;
+        },
+        unsubscribe(channel) {
+            channelSubs.delete(channel);
+            const msgId = nextId();
+            try {
+                send({
+                    id: msgId,
+                    type: 'unsubscribe',
+                    channel,
+                });
+            }
+            catch {
+                // Ignore send errors on unsubscribe
+            }
+        },
+        publish(channel, event, data) {
+            const msgId = nextId();
+            send({
+                id: msgId,
+                type: 'publish',
+                channel,
+                event,
+                data,
+            });
+        },
+        async refreshAuth(newToken) {
+            return new Promise((resolve, reject) => {
+                if (!ws || ws.readyState !== WS.OPEN) {
+                    reject(new Error('Not connected'));
+                    return;
+                }
+                const id = nextId();
+                const timer = setTimeout(() => {
+                    pendingRequests.delete(id);
+                    reject(new Error('Auth refresh timeout'));
+                }, requestTimeout);
+                pendingRequests.set(id, {
+                    resolve: () => resolve(),
+                    reject,
+                    timer,
+                });
+                try {
+                    send({ id, type: 'auth:refresh', token: newToken });
+                }
+                catch (err) {
+                    clearTimeout(timer);
+                    pendingRequests.delete(id);
+                    reject(err);
+                }
+            });
+        },
+        close() {
+            intentionalClose = true;
+            reconnectController.stop();
+            if (ws) {
+                ws.close(1000, 'Client closing');
+                ws = null;
+            }
+            connected = false;
+            channelSubs.clear();
+        },
+        get connected() {
+            return connected;
+        },
+    };
+    return client;
+}
+//# sourceMappingURL=create.js.map