zapo-js 0.3.0 → 1.0.1

package/dist/message/WaMessageClient.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WaMessageClient = void 0;
-const ack_1 = require("./ack");
+const ack_1 = require("./primitives/ack");
 const constants_1 = require("../protocol/constants");
 const global_1 = require("../transport/node/builders/global");
 const async_1 = require("../util/async");
@@ -14,6 +14,11 @@ class MessagePublishNackError extends Error {
         this.retryable = retryable;
     }
 }
+/**
+ * Low-level message-publishing client. Sends pre-built message/receipt nodes,
+ * handles ack timeouts and retry on negative-ack failures, and is the
+ * transport hook used by {@link WaMessageCoordinator}.
+ */
 class WaMessageClient {
     constructor(options) {
         this.logger = options.logger;
@@ -23,6 +28,11 @@ class WaMessageClient {
         this.defaultMaxAttempts = options.defaultMaxAttempts ?? constants_1.WA_DEFAULTS.MESSAGE_MAX_ATTEMPTS;
         this.defaultRetryDelayMs = options.defaultRetryDelayMs ?? constants_1.WA_DEFAULTS.MESSAGE_RETRY_DELAY_MS;
     }
+    /**
+     * Publishes a `<message>` stanza and awaits its ack/receipt, retrying on
+     * retryable negative-ack errors up to `maxAttempts`. Returns the ack
+     * metadata extracted from the server response.
+     */
     async publishNode(node, options = {}) {
         if (node.tag !== constants_1.WA_MESSAGE_TAGS.MESSAGE) {
             throw new Error(`invalid node tag for message publish: ${node.tag}`);
@@ -54,14 +64,25 @@ class WaMessageClient {
                 if ((0, ack_1.isNegativeAckNode)(ackNode)) {
                     throw new MessagePublishNackError(`negative publish ack: ${(0, ack_1.describeAckNode)(ackNode)}`, (0, ack_1.isRetryableNegativeAck)(ackNode));
                 }
-                this.logger.info('message publish acknowledged', {
-                    id,
-                    tag: ackNode.tag,
-                    type: ackNode.attrs.type,
-                    phash: ackNode.attrs.phash,
-                    addressingMode: ackNode.attrs.addressing_mode,
-                    attempts: attempt
-                });
+                if (attempt > 1) {
+                    this.logger.info('message publish acknowledged after retry', {
+                        id,
+                        tag: ackNode.tag,
+                        type: ackNode.attrs.type,
+                        phash: ackNode.attrs.phash,
+                        addressingMode: ackNode.attrs.addressing_mode,
+                        attempts: attempt
+                    });
+                }
+                else {
+                    this.logger.trace('message publish acknowledged', {
+                        id,
+                        tag: ackNode.tag,
+                        type: ackNode.attrs.type,
+                        phash: ackNode.attrs.phash,
+                        addressingMode: ackNode.attrs.addressing_mode
+                    });
+                }
                 return {
                     id,
                     attempts: attempt,
@@ -74,25 +95,33 @@ class WaMessageClient {
                 const nackRetryable = error instanceof MessagePublishNackError ? error.retryable : false;
                 const canRetry = attempt < maxAttempts &&
                     (this.isRetryablePublishError(lastError) || nackRetryable);
+                if (canRetry) {
+                    this.logger.debug('message publish attempt failed, will retry', {
+                        attempt,
+                        maxAttempts,
+                        nackRetryable,
+                        message: lastError.message
+                    });
+                    await (0, async_1.delay)(retryDelayMs * attempt);
+                    continue;
+                }
                 this.logger.warn('message publish attempt failed', {
                     attempt,
                     maxAttempts,
-                    canRetry,
                     nackRetryable,
                     message: lastError.message
                 });
-                if (!canRetry) {
-                    throw lastError;
-                }
-                await (0, async_1.delay)(retryDelayMs * attempt);
+                throw lastError;
             }
         }
         throw lastError ?? new Error('message publish failed');
     }
+    /** Builds the encrypted message envelope from `input` and publishes it via {@link publishNode}. */
     async publishEncrypted(input, options = {}) {
         const node = this.buildEncryptedMessageNode(input);
         return this.publishNode(node, options);
     }
+    /** Fire-and-forget variant: sends a `<message>` stanza without awaiting an ack. */
     async sendMessageNode(node) {
         if (node.tag !== constants_1.WA_MESSAGE_TAGS.MESSAGE) {
             throw new Error(`invalid node tag for message send: ${node.tag}`);
@@ -104,6 +133,7 @@ class WaMessageClient {
         });
         await this.sendNode(node);
     }
+    /** Builds and sends an encrypted message envelope without awaiting an ack. */
     async sendEncrypted(input) {
         const node = this.buildEncryptedMessageNode(input);
         await this.sendMessageNode(node);
@@ -168,12 +198,13 @@ class WaMessageClient {
         };
         return node;
     }
+    /** Builds and sends a `<receipt>` stanza (delivery/read/played/etc.). */
     async sendReceipt(input) {
         const node = (0, global_1.buildReceiptNode)({
             kind: 'outbound',
             to: input.to,
             id: input.id,
-            type: input.type ?? 'read',
+            type: input.type ?? constants_1.WA_MESSAGE_TYPES.RECEIPT_TYPE_READ,
             participant: input.participant,
             recipient: input.recipient,
             category: input.category,

package/dist/message/addons/link-preview/builder.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildExtendedTextWithPreview = buildExtendedTextWithPreview;
+function buildExtendedTextWithPreview(text, resolved, thumbnailFields) {
+    const message = {
+        text,
+        matchedText: resolved.matchedText,
+        previewType: resolved.previewType
+    };
+    if (resolved.title !== undefined)
+        message.title = resolved.title;
+    if (resolved.description !== undefined)
+        message.description = resolved.description;
+    if (thumbnailFields.jpegThumbnail !== undefined) {
+        message.jpegThumbnail = thumbnailFields.jpegThumbnail;
+    }
+    if (thumbnailFields.thumbnailDirectPath !== undefined) {
+        message.thumbnailDirectPath = thumbnailFields.thumbnailDirectPath;
+    }
+    if (thumbnailFields.thumbnailSha256 !== undefined) {
+        message.thumbnailSha256 = thumbnailFields.thumbnailSha256;
+    }
+    if (thumbnailFields.thumbnailEncSha256 !== undefined) {
+        message.thumbnailEncSha256 = thumbnailFields.thumbnailEncSha256;
+    }
+    if (thumbnailFields.mediaKey !== undefined) {
+        message.mediaKey = thumbnailFields.mediaKey;
+    }
+    if (thumbnailFields.mediaKeyTimestamp !== undefined) {
+        message.mediaKeyTimestamp = thumbnailFields.mediaKeyTimestamp;
+    }
+    if (thumbnailFields.thumbnailWidth !== undefined) {
+        message.thumbnailWidth = thumbnailFields.thumbnailWidth;
+    }
+    if (thumbnailFields.thumbnailHeight !== undefined) {
+        message.thumbnailHeight = thumbnailFields.thumbnailHeight;
+    }
+    return { extendedTextMessage: message };
+}

package/dist/message/addons/link-preview/detect.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findFirstLink = findFirstLink;
+const URL_REGEX = /\bhttps?:\/\/\S+/i;
+const TRAILING_PUNCT = '.,;:!?\'"»›>';
+const WRAPPER_PAIRS = Object.freeze({
+    ')': '(',
+    ']': '[',
+    '}': '{'
+});
+function findFirstLink(text) {
+    const match = URL_REGEX.exec(text);
+    if (!match)
+        return null;
+    const raw = stripTrailing(match[0]);
+    if (raw.length === 0)
+        return null;
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        return null;
+    }
+    if (url.protocol !== 'http:' && url.protocol !== 'https:')
+        return null;
+    return { matchedText: raw, url };
+}
+function stripTrailing(raw) {
+    let s = raw;
+    while (s.length > 0) {
+        const last = s[s.length - 1] ?? '';
+        if (TRAILING_PUNCT.includes(last)) {
+            s = s.slice(0, -1);
+            continue;
+        }
+        const opener = WRAPPER_PAIRS[last];
+        if (opener === undefined)
+            break;
+        // Only strip the closing wrapper if it's unbalanced (no matching opener
+        // inside the candidate URL). Keeps URLs like `/a_(b)` intact while
+        // still trimming `(see https://x.com)` → `https://x.com`.
+        if (countChar(s, last) > countChar(s, opener)) {
+            s = s.slice(0, -1);
+            continue;
+        }
+        break;
+    }
+    return s;
+}
+function countChar(s, ch) {
+    let n = 0;
+    for (let i = 0; i < s.length; i++) {
+        if (s[i] === ch)
+            n++;
+    }
+    return n;
+}

package/dist/message/addons/link-preview/fetcher.js

@@ -0,0 +1,394 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefaultLinkPreviewFetcher = createDefaultLinkPreviewFetcher;
+const _proto_1 = require("../../../proto");
+const proxy_1 = require("../../../transport/proxy");
+const bytes_1 = require("../../../util/bytes");
+const primitives_1 = require("../../../util/primitives");
+const DEFAULT_USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';
+const DEFAULT_TIMEOUT_MS = 3000;
+const DEFAULT_HTML_BYTES = 65536;
+const DEFAULT_THUMBNAIL_BYTES = 262144;
+const INLINE_THUMBNAIL_MAX_BYTES = 64 * 1024;
+const MAX_REDIRECTS = 5;
+function createDefaultLinkPreviewFetcher(options) {
+    const userAgent = options.userAgent ?? DEFAULT_USER_AGENT;
+    const fetchTimeoutMs = options.fetchTimeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const maxHtmlBytes = options.maxHtmlBytes ?? DEFAULT_HTML_BYTES;
+    const maxThumbnailBytes = options.maxThumbnailBytes ?? DEFAULT_THUMBNAIL_BYTES;
+    const allowPrivateHosts = options.allowPrivateHosts === true;
+    const agent = (0, proxy_1.toProxyAgent)(options.proxy);
+    const mediaTransfer = options.mediaTransfer;
+    return {
+        async fetch(input) {
+            if (!allowPrivateHosts && isPrivateHost(input.url.hostname)) {
+                input.logger.warn('link preview blocked: private host', {
+                    hostname: input.url.hostname
+                });
+                return null;
+            }
+            const minimal = {
+                matchedText: input.matchedText,
+                title: input.url.hostname,
+                previewType: _proto_1.proto.Message.ExtendedTextMessage.PreviewType.NONE
+            };
+            let html;
+            try {
+                html = await fetchHtml(input.url, {
+                    mediaTransfer,
+                    agent,
+                    userAgent,
+                    timeoutMs: fetchTimeoutMs,
+                    maxBytes: maxHtmlBytes,
+                    signal: input.signal,
+                    allowPrivateHosts
+                });
+            }
+            catch (error) {
+                input.logger.warn('link preview html fetch failed', {
+                    url: input.url.toString(),
+                    message: (0, primitives_1.toError)(error).message
+                });
+                return minimal;
+            }
+            if (html.length === 0)
+                return minimal;
+            const parsed = parseHtmlMeta(html, input.url);
+            let thumbnail;
+            if (parsed.imageUrl !== undefined) {
+                const fetched = await fetchThumbnail(parsed.imageUrl, {
+                    mediaTransfer,
+                    agent,
+                    userAgent,
+                    timeoutMs: fetchTimeoutMs,
+                    maxBytes: maxThumbnailBytes,
+                    allowPrivateHosts,
+                    signal: input.signal,
+                    logger: input.logger
+                });
+                if (fetched !== undefined) {
+                    thumbnail = {
+                        ...fetched,
+                        ...(parsed.imageWidth !== undefined ? { width: parsed.imageWidth } : {}),
+                        ...(parsed.imageHeight !== undefined ? { height: parsed.imageHeight } : {})
+                    };
+                }
+            }
+            return {
+                matchedText: input.matchedText,
+                title: parsed.title ?? input.url.hostname,
+                previewType: parsed.hasVideo
+                    ? _proto_1.proto.Message.ExtendedTextMessage.PreviewType.VIDEO
+                    : _proto_1.proto.Message.ExtendedTextMessage.PreviewType.NONE,
+                ...(parsed.description !== undefined ? { description: parsed.description } : {}),
+                ...(thumbnail !== undefined ? { thumbnail } : {})
+            };
+        }
+    };
+}
+function parseHtmlMeta(html, base) {
+    const head = extractHeadSection(html);
+    const ogTitle = extractMetaContent(head, 'property', 'og:title');
+    const twitterTitle = extractMetaContent(head, 'name', 'twitter:title');
+    const titleTag = extractTitleTag(head);
+    const ogDesc = extractMetaContent(head, 'property', 'og:description');
+    const twitterDesc = extractMetaContent(head, 'name', 'twitter:description');
+    const metaDesc = extractMetaContent(head, 'name', 'description');
+    const ogImage = extractMetaContent(head, 'property', 'og:image:secure_url') ??
+        extractMetaContent(head, 'property', 'og:image:url') ??
+        extractMetaContent(head, 'property', 'og:image') ??
+        extractMetaContent(head, 'name', 'twitter:image');
+    const ogImageWidth = (0, primitives_1.parseOptionalInt)(extractMetaContent(head, 'property', 'og:image:width'));
+    const ogImageHeight = (0, primitives_1.parseOptionalInt)(extractMetaContent(head, 'property', 'og:image:height'));
+    const ogVideo = extractMetaContent(head, 'property', 'og:video:secure_url') ??
+        extractMetaContent(head, 'property', 'og:video:url') ??
+        extractMetaContent(head, 'property', 'og:video');
+    return {
+        title: cleanText(ogTitle ?? twitterTitle ?? titleTag),
+        description: cleanText(ogDesc ?? twitterDesc ?? metaDesc),
+        imageUrl: ogImage ? toAbsoluteUrl(ogImage, base) : undefined,
+        imageWidth: ogImageWidth,
+        imageHeight: ogImageHeight,
+        hasVideo: ogVideo !== undefined
+    };
+}
+function extractHeadSection(html) {
+    const closeIdx = html.search(/<\/head\s*>/i);
+    if (closeIdx === -1)
+        return html;
+    return html.slice(0, closeIdx);
+}
+function extractMetaContent(html, attr, key) {
+    const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const re1 = new RegExp(`<meta\\b[^>]*?\\b${attr}\\s*=\\s*["']${escaped}["'][^>]*?\\bcontent\\s*=\\s*["']([^"']*)["']`, 'i');
+    const re2 = new RegExp(`<meta\\b[^>]*?\\bcontent\\s*=\\s*["']([^"']*)["'][^>]*?\\b${attr}\\s*=\\s*["']${escaped}["']`, 'i');
+    const m = re1.exec(html) ?? re2.exec(html);
+    return m?.[1];
+}
+function extractTitleTag(html) {
+    const m = /<title[^>]*>([\s\S]*?)<\/title>/i.exec(html);
+    return m?.[1];
+}
+function cleanText(s) {
+    if (s === undefined)
+        return undefined;
+    const decoded = decodeHtmlEntities(s.replace(/\s+/g, ' ').trim());
+    return decoded.length === 0 ? undefined : decoded;
+}
+function decodeHtmlEntities(s) {
+    return s
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&apos;/g, "'")
+        .replace(/&nbsp;/g, ' ')
+        .replace(/&#(\d+);/g, (_, n) => safeCodePoint(Number(n)))
+        .replace(/&#x([0-9a-f]+);/gi, (_, hex) => safeCodePoint(Number.parseInt(hex, 16)))
+        .replace(/&amp;/g, '&');
+}
+function safeCodePoint(cp) {
+    if (!Number.isFinite(cp) || cp < 0 || cp > 0x10ffff)
+        return '';
+    return String.fromCodePoint(cp);
+}
+function toAbsoluteUrl(raw, base) {
+    try {
+        return new URL(raw, base).toString();
+    }
+    catch {
+        return undefined;
+    }
+}
+async function fetchHtml(url, opts) {
+    const result = await httpGetWithRedirects({
+        url,
+        mediaTransfer: opts.mediaTransfer,
+        agent: opts.agent,
+        userAgent: opts.userAgent,
+        accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+        timeoutMs: opts.timeoutMs,
+        maxBytes: opts.maxBytes,
+        signal: opts.signal,
+        allowPrivateHosts: opts.allowPrivateHosts
+    });
+    if (result.status < 200 || result.status >= 300) {
+        throw new Error(`http ${result.status}`);
+    }
+    if (!/text\/html|application\/xhtml/i.test(result.contentType)) {
+        return '';
+    }
+    // HTML truncation is tolerable: the regex meta parser only needs the
+    // <head> section, which fits well below maxHtmlBytes for realistic pages.
+    return bytes_1.TEXT_DECODER.decode(result.bytes);
+}
+async function fetchThumbnail(url, opts) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return undefined;
+    }
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:')
+        return undefined;
+    if (!opts.allowPrivateHosts && isPrivateHost(parsed.hostname)) {
+        opts.logger.warn('link preview thumbnail blocked: private host', {
+            hostname: parsed.hostname
+        });
+        return undefined;
+    }
+    try {
+        const streamResult = await httpGetStreamWithRedirects({
+            url: parsed,
+            mediaTransfer: opts.mediaTransfer,
+            agent: opts.agent,
+            userAgent: opts.userAgent,
+            accept: 'image/jpeg,image/*;q=0.8',
+            timeoutMs: opts.timeoutMs,
+            signal: opts.signal,
+            allowPrivateHosts: opts.allowPrivateHosts
+        });
+        if (streamResult.status < 200 || streamResult.status >= 300) {
+            streamResult.body?.destroy();
+            return undefined;
+        }
+        if (!/^image\//i.test(streamResult.contentType)) {
+            streamResult.body?.destroy();
+            return undefined;
+        }
+        if (!streamResult.body)
+            return undefined;
+        if (streamResult.contentLength !== undefined &&
+            streamResult.contentLength > opts.maxBytes) {
+            streamResult.body.destroy();
+            return undefined;
+        }
+        if (streamResult.contentLength !== undefined &&
+            streamResult.contentLength > INLINE_THUMBNAIL_MAX_BYTES) {
+            return { stream: streamResult.body, contentLength: streamResult.contentLength };
+        }
+        const capped = await readBodyCapped(streamResult.body, opts.maxBytes);
+        if (capped.bytes.byteLength === 0)
+            return undefined;
+        // If we capped without knowing the real size, the bytes are an
+        // arbitrary prefix of the original image (corrupt JPEG/PNG). Drop it.
+        if (capped.truncated && streamResult.contentLength === undefined) {
+            opts.logger.warn('link preview thumbnail dropped: truncated without content-length', {
+                url: parsed.toString()
+            });
+            return undefined;
+        }
+        return { bytes: capped.bytes };
+    }
+    catch (error) {
+        opts.logger.warn('link preview thumbnail fetch failed', {
+            url: parsed.toString(),
+            message: (0, primitives_1.toError)(error).message
+        });
+        return undefined;
+    }
+}
+async function httpGetWithRedirects(opts) {
+    const streamResult = await httpGetStreamWithRedirects({
+        url: opts.url,
+        mediaTransfer: opts.mediaTransfer,
+        agent: opts.agent,
+        userAgent: opts.userAgent,
+        accept: opts.accept,
+        timeoutMs: opts.timeoutMs,
+        signal: opts.signal,
+        allowPrivateHosts: opts.allowPrivateHosts
+    });
+    const capped = await readBodyCapped(streamResult.body, opts.maxBytes);
+    return {
+        status: streamResult.status,
+        contentType: streamResult.contentType,
+        bytes: capped.bytes
+    };
+}
+async function httpGetStreamWithRedirects(opts) {
+    let currentUrl = opts.url;
+    for (let redirects = 0; redirects <= MAX_REDIRECTS; redirects++) {
+        if (!opts.allowPrivateHosts && isPrivateHost(currentUrl.hostname)) {
+            throw new Error(`redirect to private host blocked: ${currentUrl.hostname}`);
+        }
+        const response = await opts.mediaTransfer.downloadStream({
+            url: currentUrl.toString(),
+            agent: opts.agent,
+            headers: {
+                'user-agent': opts.userAgent,
+                accept: opts.accept
+            },
+            timeoutMs: opts.timeoutMs,
+            signal: opts.signal
+        });
+        const contentType = response.headers['content-type'] ?? '';
+        if (response.status >= 300 && response.status < 400) {
+            const location = response.headers['location'];
+            response.body?.destroy();
+            if (typeof location !== 'string' || location.length === 0) {
+                return {
+                    status: response.status,
+                    contentType,
+                    contentLength: undefined,
+                    body: null
+                };
+            }
+            try {
+                currentUrl = new URL(location, currentUrl);
+            }
+            catch {
+                return {
+                    status: response.status,
+                    contentType,
+                    contentLength: undefined,
+                    body: null
+                };
+            }
+            continue;
+        }
+        const contentLengthHeader = response.headers['content-length'];
+        const contentLength = (0, primitives_1.parseOptionalInt)(contentLengthHeader);
+        return {
+            status: response.status,
+            contentType,
+            contentLength,
+            body: response.body
+        };
+    }
+    throw new Error(`too many redirects (>${MAX_REDIRECTS})`);
+}
+async function readBodyCapped(body, maxBytes) {
+    if (!body)
+        return { bytes: new Uint8Array(0), truncated: false };
+    const chunks = [];
+    let total = 0;
+    let truncated = false;
+    try {
+        for await (const chunk of body) {
+            const view = chunk;
+            const room = maxBytes - total;
+            if (room <= 0) {
+                truncated = true;
+                break;
+            }
+            if (view.byteLength <= room) {
+                chunks.push(view);
+                total += view.byteLength;
+            }
+            else {
+                chunks.push(view.subarray(0, room));
+                total = maxBytes;
+                truncated = true;
+                break;
+            }
+        }
+    }
+    finally {
+        body.destroy();
+    }
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        out.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return { bytes: out, truncated };
+}
+const PRIVATE_IPV4 = [
+    /^127\./,
+    /^10\./,
+    /^192\.168\./,
+    /^172\.(1[6-9]|2\d|3[01])\./,
+    /^169\.254\./,
+    /^0\./
+];
+function isPrivateHost(hostname) {
+    const lower = hostname.toLowerCase();
+    // RFC 6761 §6.3: any name in the .localhost domain resolves to loopback.
+    if (lower === 'localhost' || lower.endsWith('.localhost'))
+        return true;
+    // URL.hostname strips brackets for IPv6, but tolerate either form.
+    const bare = lower.startsWith('[') && lower.endsWith(']') ? lower.slice(1, -1) : lower;
+    if (bare === '::1' || bare === '0:0:0:0:0:0:0:1' || bare === '::')
+        return true;
+    if (bare.startsWith('::ffff:')) {
+        return isPrivateHost(bare.slice('::ffff:'.length));
+    }
+    if (PRIVATE_IPV4.some((re) => re.test(bare)))
+        return true;
+    // IPv6: presence of ':' indicates an address. Match link-local (fe80::/10)
+    // and unique-local (fc00::/7) prefixes.
+    if (bare.includes(':')) {
+        if (bare.startsWith('fc') || bare.startsWith('fd'))
+            return true;
+        if (bare.startsWith('fe8') ||
+            bare.startsWith('fe9') ||
+            bare.startsWith('fea') ||
+            bare.startsWith('feb')) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/message/addons/link-preview/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });