@celestial-community/baileys 0.0.1-security → 1.0.0

package/lib/Utils/stealth-connect.js

@@ -0,0 +1,124 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.rampPresenceAfterConnect =
+    exports.getStealthSocketConfig =
+    exports.AbortError =
+    exports.STEALTH_BROWSER_POOL =
+        void 0
+
+/**
+ * @file stealth-connect.js
+ * @description Reduce ban signal on socket connect + presence ramp.
+ *   Inspired by GOWA's --presence-on-connect=unavailable flag.
+ *   Bots that snap online immediately and start blasting messages look
+ *   suspicious to WA's anti-spam classifier.
+ *
+ *   - getStealthSocketConfig() — disables markOnlineOnConnect, randomizes browser fingerprint
+ *   - rampPresenceAfterConnect() — waits random delay then sets presence to available
+ *
+ *   Usage:
+ *     const { getStealthSocketConfig, rampPresenceAfterConnect } = require('@whiskeysockets/baileys')
+ *     const sock = makeWASocket({ ...getStealthSocketConfig(), auth: state })
+ *     await rampPresenceAfterConnect(sock)
+ *
+ *   Ported from baileys-antiban to CJS for bilis.
+ * @author Denzy ZeroDay (port), Kobus Wentzel (original)
+ */
+
+const STEALTH_BROWSER_POOL = Object.freeze([
+    ['Mac OS', 'Chrome', '120.0.6099.109'],
+    ['Mac OS', 'Safari', '17.2.1'],
+    ['Windows', 'Chrome', '121.0.6167.85'],
+    ['Windows', 'Firefox', '122.0'],
+    ['Windows', 'Edge', '120.0.2210.144'],
+    ['Linux', 'Chrome', '120.0.6099.109'],
+    ['Linux', 'Firefox', '122.0'],
+    ['Ubuntu', 'Chrome', '121.0.6167.85']
+])
+exports.STEALTH_BROWSER_POOL = STEALTH_BROWSER_POOL
+
+class AbortError extends Error {
+    constructor(message = 'rampPresenceAfterConnect aborted') {
+        super(message)
+        this.name = 'AbortError'
+    }
+}
+exports.AbortError = AbortError
+
+/**
+ * Returns a partial Baileys socket config tuned for stealth connect.
+ * - markOnlineOnConnect: false — joins without broadcasting 'available'
+ * - browser: randomized realistic tuple from STEALTH_BROWSER_POOL
+ *
+ * @param {object} opts
+ * @param {string} opts.os - Override OS name slot
+ * @param {Array} opts.browser - Explicit browser tuple [os, browser, version]
+ * @param {function} opts.random - Custom RNG (default: Math.random)
+ * @returns {{ markOnlineOnConnect: boolean, browser: Array }}
+ */
+const getStealthSocketConfig = (opts = {}) => {
+    const random = opts.random ?? Math.random
+    let browser
+
+    if (opts.browser) {
+        browser = opts.browser
+    } else {
+        const pick = STEALTH_BROWSER_POOL[Math.floor(random() * STEALTH_BROWSER_POOL.length)]
+        browser = opts.os ? [opts.os, pick[1], pick[2]] : [...pick]
+    }
+
+    return {
+        markOnlineOnConnect: false,
+        browser
+    }
+}
+exports.getStealthSocketConfig = getStealthSocketConfig
+
+/**
+ * Waits a randomized delay then calls sock.sendPresenceUpdate(targetState).
+ * Supports AbortSignal — abort during delay cancels timer and rejects with AbortError.
+ *
+ * @param {object} sock - Baileys WASocket (needs sendPresenceUpdate)
+ * @param {object} opts
+ * @param {number} opts.minDelayMs - Min delay ms (default: 30000)
+ * @param {number} opts.maxDelayMs - Max delay ms (default: 90000)
+ * @param {string} opts.targetState - Presence state (default: 'available')
+ * @param {AbortSignal} opts.signal - Optional AbortSignal to cancel
+ * @param {function} opts.random - Custom RNG
+ */
+const rampPresenceAfterConnect = async (sock, opts = {}) => {
+    const minDelayMs = opts.minDelayMs ?? 30000
+    const maxDelayMs = opts.maxDelayMs ?? 90000
+    const targetState = opts.targetState ?? 'available'
+    const random = opts.random ?? Math.random
+    const signal = opts.signal
+
+    if (signal?.aborted) throw new AbortError()
+
+    const range = Math.max(0, maxDelayMs - minDelayMs)
+    const delayMs = Math.floor(random() * (range + 1)) + minDelayMs
+
+    await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            if (signal) signal.removeEventListener('abort', onAbort)
+            resolve()
+        }, delayMs)
+
+        const onAbort = () => {
+            clearTimeout(timer)
+            reject(new AbortError())
+        }
+
+        if (signal) signal.addEventListener('abort', onAbort, { once: true })
+    })
+
+    await sock.sendPresenceUpdate(targetState, undefined)
+}
+exports.rampPresenceAfterConnect = rampPresenceAfterConnect
+
+module.exports = {
+    STEALTH_BROWSER_POOL,
+    AbortError,
+    getStealthSocketConfig,
+    rampPresenceAfterConnect
+}

package/lib/Utils/sync-action-utils.js

@@ -0,0 +1,55 @@
+const { proto } = require('../../WAProto')
+const { isLidUser, isPnUser } = require('../WABinary')
+/**
+ * Process contactAction and return events to emit.
+ * Pure function - no side effects.
+ */
+const processContactAction = (action, id, logger) => {
+    const results = []
+    if (!id) {
+        logger?.warn(
+            {
+                hasFullName: !!action.fullName,
+                hasLidJid: !!action.lidJid,
+                hasPnJid: !!action.pnJid
+            },
+            'contactAction sync: missing id in index'
+        )
+        return results
+    }
+    const lidJid = action.lidJid
+    const idIsPn = isPnUser(id)
+    // PN is in index[1], not in contactAction.pnJid which is usually null
+    const phoneNumber = idIsPn ? id : action.pnJid || undefined
+    // Always emit contacts.upsert
+    results.push({
+        event: 'contacts.upsert',
+        data: [
+            {
+                id,
+                name: action.fullName || action.firstName || action.username || undefined,
+                username: action.username || undefined,
+                lid: lidJid || undefined,
+                phoneNumber
+            }
+        ]
+    })
+    // Emit lid-mapping.update if we have valid LID-PN pair
+    if (lidJid && isLidUser(lidJid) && idIsPn) {
+        results.push({
+            event: 'lid-mapping.update',
+            data: { lid: lidJid, pn: id }
+        })
+    }
+    return results
+}
+const emitSyncActionResults = (ev, results) => {
+    for (const result of results) {
+        if (result.event === 'contacts.upsert') {
+            ev.emit('contacts.upsert', result.data)
+        } else {
+            ev.emit('lid-mapping.update', result.data)
+        }
+    }
+}
+//# sourceMappingURL=sync-action-utils.js.map

package/lib/Utils/tc-token-utils.js

@@ -0,0 +1,171 @@
+const {
+    getBinaryNodeChild,
+    getBinaryNodeChildren,
+    isHostedLidUser,
+    isHostedPnUser,
+    isJidMetaAI,
+    isLidUser,
+    isPnUser,
+    jidNormalizedUser
+} = require('../WABinary')
+// Same phone-number pattern as WABinary's isJidBot, applied against the user
+// part so the check is invariant to @c.us ↔ @s.whatsapp.net normalization.
+const BOT_PHONE_REGEX = /^1313555\d{4}$|^131655500\d{2}$/
+/**
+ * Mirrors WA Web's `Wid.isRegularUser()` (user ∧ ¬PSA ∧ ¬Bot). Used to gate tctoken
+ * storage against malformed notifications — WA Web filters server-side but we
+ * defend here for parity with `WAWebSetTcTokenChatAction.handleIncomingTcToken`.
+ * Works for both pre- and post-normalized JIDs (`@c.us` vs `@s.whatsapp.net`).
+ */
+function isRegularUser(jid) {
+    if (!jid) return false
+    const user = jid.split('@')[0] ?? ''
+    if (user === '0') return false // PSA
+    if (BOT_PHONE_REGEX.test(user)) return false // Bot by phone pattern
+    if (isJidMetaAI(jid)) return false // MetaAI (@bot server)
+    return !!(
+        isPnUser(jid) ||
+        isLidUser(jid) ||
+        isHostedPnUser(jid) ||
+        isHostedLidUser(jid) ||
+        jid.endsWith('@c.us')
+    )
+}
+const TC_TOKEN_BUCKET_DURATION = 604800 // 7 days
+const TC_TOKEN_NUM_BUCKETS = 4 // ~28-day rolling window
+/** Sentinel key under `tctoken` store holding a JSON array of tracked storage JIDs for cross-session pruning. */
+const TC_TOKEN_INDEX_KEY = '__index'
+/** Read the persisted tctoken JID index and return its entries (never contains the sentinel key itself). */
+export async function readTcTokenIndex(keys) {
+    const data = await keys.get('tctoken', [TC_TOKEN_INDEX_KEY])
+    const entry = data[TC_TOKEN_INDEX_KEY]
+    if (!entry?.token?.length) return []
+    try {
+        const parsed = JSON.parse(Buffer.from(entry.token).toString())
+        if (!Array.isArray(parsed)) return []
+        return parsed.filter(
+            (j) => typeof j === 'string' && j.length > 0 && j !== TC_TOKEN_INDEX_KEY
+        )
+    } catch {
+        return []
+    }
+}
+/** Build a SignalDataSet fragment that writes the merged index (persisted ∪ added) under the sentinel key. */
+export async function buildMergedTcTokenIndexWrite(keys, addedJids) {
+    const persisted = await readTcTokenIndex(keys)
+    const merged = new Set(persisted)
+    for (const jid of addedJids) {
+        if (jid && jid !== TC_TOKEN_INDEX_KEY) merged.add(jid)
+    }
+    return {
+        [TC_TOKEN_INDEX_KEY]: { token: Buffer.from(JSON.stringify([...merged])) }
+    }
+}
+// WA Web has separate sender/receiver AB props for these but they're identical today
+export function isTcTokenExpired(timestamp) {
+    if (timestamp === null || timestamp === undefined) return true
+    const ts = typeof timestamp === 'string' ? parseInt(timestamp) : timestamp
+    if (isNaN(ts)) return true
+    const now = Math.floor(Date.now() / 1000)
+    const currentBucket = Math.floor(now / TC_TOKEN_BUCKET_DURATION)
+    const cutoffBucket = currentBucket - (TC_TOKEN_NUM_BUCKETS - 1)
+    const cutoffTimestamp = cutoffBucket * TC_TOKEN_BUCKET_DURATION
+    return ts < cutoffTimestamp
+}
+export function shouldSendNewTcToken(senderTimestamp) {
+    if (senderTimestamp === undefined) return true
+    const now = Math.floor(Date.now() / 1000)
+    const currentBucket = Math.floor(now / TC_TOKEN_BUCKET_DURATION)
+    const senderBucket = Math.floor(senderTimestamp / TC_TOKEN_BUCKET_DURATION)
+    return currentBucket > senderBucket
+}
+/** Resolve JID to LID for tctoken storage (WA Web stores under LID) */
+export async function resolveTcTokenJid(jid, getLIDForPN) {
+    if (isLidUser(jid)) return jid
+    const lid = await getLIDForPN(jid)
+    return lid ?? jid
+}
+/** Resolve target JID for issuing privacy token based on AB prop 14303 */
+export async function resolveIssuanceJid(jid, issueToLid, getLIDForPN, getPNForLID) {
+    if (issueToLid) {
+        if (isLidUser(jid)) return jid
+        const lid = await getLIDForPN(jid)
+        return lid ?? jid
+    }
+    if (!isLidUser(jid)) return jid
+    if (getPNForLID) {
+        const pn = await getPNForLID(jid)
+        return pn ?? jid
+    }
+    return jid
+}
+export async function buildTcTokenFromJid({ authState, jid, baseContent = [], getLIDForPN }) {
+    try {
+        const storageJid = await resolveTcTokenJid(jid, getLIDForPN)
+        const tcTokenData = await authState.keys.get('tctoken', [storageJid])
+        const entry = tcTokenData?.[storageJid]
+        const tcTokenBuffer = entry?.token
+        if (!tcTokenBuffer?.length || isTcTokenExpired(entry?.timestamp)) {
+            if (tcTokenBuffer) {
+                // Preserve senderTimestamp so shouldSendNewTcToken() keeps its dedupe state
+                // after we drop the unusable peer token. Only wipe the record entirely when
+                // there's nothing worth keeping.
+                const cleared =
+                    entry?.senderTimestamp !== undefined
+                        ? { token: Buffer.alloc(0), senderTimestamp: entry.senderTimestamp }
+                        : null
+                await authState.keys.set({ tctoken: { [storageJid]: cleared } })
+            }
+            return baseContent.length > 0 ? baseContent : undefined
+        }
+        baseContent.push({
+            tag: 'tctoken',
+            attrs: {},
+            content: tcTokenBuffer
+        })
+        return baseContent
+    } catch (error) {
+        return baseContent.length > 0 ? baseContent : undefined
+    }
+}
+export async function storeTcTokensFromIqResult({
+    result,
+    fallbackJid,
+    keys,
+    getLIDForPN,
+    onNewJidStored
+}) {
+    const tokensNode = getBinaryNodeChild(result, 'tokens')
+    if (!tokensNode) return
+    const tokenNodes = getBinaryNodeChildren(tokensNode, 'token')
+    for (const tokenNode of tokenNodes) {
+        if (
+            tokenNode.attrs.type !== 'trusted_contact' ||
+            !(tokenNode.content instanceof Uint8Array)
+        ) {
+            continue
+        }
+        // In notifications tokenNode.attrs.jid is your own device JID, not the sender's
+        const rawJid = jidNormalizedUser(fallbackJid || tokenNode.attrs.jid)
+        if (!isRegularUser(rawJid)) continue
+        const storageJid = await resolveTcTokenJid(rawJid, getLIDForPN)
+        const existingTcData = await keys.get('tctoken', [storageJid])
+        const existingEntry = existingTcData[storageJid]
+        const existingTs = existingEntry?.timestamp ? Number(existingEntry.timestamp) : 0
+        const incomingTs = tokenNode.attrs.t ? Number(tokenNode.attrs.t) : 0
+        // timestamp-less tokens would be immediately expired
+        if (!incomingTs) continue
+        if (existingTs > 0 && existingTs > incomingTs) continue
+        await keys.set({
+            tctoken: {
+                [storageJid]: {
+                    ...existingEntry,
+                    token: Buffer.from(tokenNode.content),
+                    timestamp: tokenNode.attrs.t
+                }
+            }
+        })
+        onNewJidStored?.(storageJid)
+    }
+}
+//# sourceMappingURL=tc-token-utils.js.map

package/lib/Utils/templates.d.ts

@@ -0,0 +1,54 @@
+export interface TemplateVariable {
+    name: string
+    defaultValue?: string
+    required?: boolean
+}
+
+export interface MessageTemplate {
+    id: string
+    name: string
+    description?: string
+    content: string
+    variables: TemplateVariable[]
+    category?: string
+    createdAt: Date
+    updatedAt: Date
+}
+
+export interface TemplateData {
+    [key: string]: string | number | undefined
+}
+
+export declare class TemplateManager {
+    private templates
+    constructor()
+    private generateId
+    private extractVariables
+    create(options: {
+        name: string
+        content: string
+        description?: string
+        category?: string
+        id?: string
+    }): MessageTemplate
+    get(id: string): MessageTemplate | undefined
+    getByName(name: string): MessageTemplate | undefined
+    getAll(): MessageTemplate[]
+    getByCategory(category: string): MessageTemplate[]
+    update(id: string, updates: Partial<Omit<MessageTemplate, 'id' | 'createdAt'>>): MessageTemplate | undefined
+    delete(id: string): boolean
+    render(id: string, data?: TemplateData): string
+    renderContent(content: string, data?: TemplateData): string
+    validate(id: string, data: TemplateData): {
+        valid: boolean
+        missing: string[]
+    }
+    export(): string
+    import(json: string, overwrite?: boolean): number
+}
+
+export declare const PRESET_TEMPLATES: Record<string, Omit<MessageTemplate, 'id' | 'createdAt' | 'updatedAt' | 'variables'>>
+
+export declare const createTemplateManager: (includePresets?: boolean) => TemplateManager
+
+export declare const renderTemplate: (content: string, data?: TemplateData) => string

package/lib/Utils/templates.js

@@ -0,0 +1,244 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.renderTemplate =
+    exports.createTemplateManager =
+    exports.PRESET_TEMPLATES =
+    exports.TemplateManager =
+        void 0
+
+/**
+ * Message Templates System
+ * Ported from Baileys-Joss
+ */
+
+class TemplateManager {
+    constructor() {
+        this.templates = new Map()
+    }
+
+    generateId() {
+        return `tpl_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`
+    }
+
+    extractVariables(content) {
+        const regex = /\{\{(\w+)(?::([^}]*))?\}\}/g
+        const variables = []
+        const seen = new Set()
+        let match
+
+        while ((match = regex.exec(content)) !== null) {
+            const name = match[1]
+            if (!name) continue
+            const defaultValue = match[2]
+
+            if (!seen.has(name)) {
+                seen.add(name)
+                variables.push({
+                    name,
+                    defaultValue,
+                    required: !defaultValue
+                })
+            }
+        }
+
+        return variables
+    }
+
+    create(options) {
+        const template = {
+            id: options.id ?? this.generateId(),
+            name: options.name,
+            content: options.content,
+            description: options.description,
+            category: options.category,
+            variables: this.extractVariables(options.content),
+            createdAt: new Date(),
+            updatedAt: new Date()
+        }
+
+        this.templates.set(template.id, template)
+        return template
+    }
+
+    get(id) {
+        return this.templates.get(id)
+    }
+
+    getByName(name) {
+        return Array.from(this.templates.values()).find((t) => t.name === name)
+    }
+
+    getAll() {
+        return Array.from(this.templates.values())
+    }
+
+    getByCategory(category) {
+        return Array.from(this.templates.values()).filter((t) => t.category === category)
+    }
+
+    update(id, updates) {
+        const template = this.templates.get(id)
+        if (!template) return undefined
+
+        if (updates.content) {
+            updates.variables = this.extractVariables(updates.content)
+        }
+
+        const updated = {
+            ...template,
+            ...updates,
+            updatedAt: new Date()
+        }
+
+        this.templates.set(id, updated)
+        return updated
+    }
+
+    delete(id) {
+        return this.templates.delete(id)
+    }
+
+    render(id, data = {}) {
+        const template = this.templates.get(id)
+        if (!template) {
+            throw new Error(`Template not found: ${id}`)
+        }
+
+        return this.renderContent(template.content, data)
+    }
+
+    renderContent(content, data = {}) {
+        return content.replace(/\{\{(\w+)(?::([^}]*))?\}\}/g, (match, name, defaultValue) => {
+            const value = data[name]
+            if (value !== undefined && value !== null) {
+                return String(value)
+            }
+            if (defaultValue !== undefined) {
+                return defaultValue
+            }
+            return match
+        })
+    }
+
+    validate(id, data) {
+        const template = this.templates.get(id)
+        if (!template) {
+            throw new Error(`Template not found: ${id}`)
+        }
+
+        const missing = []
+        for (const variable of template.variables) {
+            if (variable.required && !(variable.name in data)) {
+                missing.push(variable.name)
+            }
+        }
+
+        return {
+            valid: missing.length === 0,
+            missing
+        }
+    }
+
+    export() {
+        return JSON.stringify(Array.from(this.templates.values()), null, 2)
+    }
+
+    import(json, overwrite = false) {
+        const templates = JSON.parse(json)
+        let imported = 0
+
+        for (const template of templates) {
+            if (!overwrite && this.templates.has(template.id)) {
+                continue
+            }
+            this.templates.set(template.id, {
+                ...template,
+                createdAt: new Date(template.createdAt),
+                updatedAt: new Date(template.updatedAt)
+            })
+            imported++
+        }
+
+        return imported
+    }
+}
+exports.TemplateManager = TemplateManager
+
+exports.PRESET_TEMPLATES = {
+    ORDER_CONFIRMATION: {
+        name: 'Order Confirmation',
+        category: 'order',
+        content: `✅ *Order Confirmed!*\n\nOrder ID: #{{orderId}}\nCustomer: {{customerName}}\nDate: {{orderDate}}\n\n📦 *Items:*\n{{items}}\n\n💰 *Total: Rp {{total}}*\n\nThank you for your order! 🙏`
+    },
+    ORDER_SHIPPED: {
+        name: 'Order Shipped',
+        category: 'order',
+        content: `📦 *Your Order is On The Way!*\n\nOrder ID: #{{orderId}}\nTracking: {{trackingNumber}}\nCourier: {{courier}}\n\nEstimated delivery: {{estimatedDate}}\n\nTrack your package: {{trackingUrl:}}`
+    },
+    INVOICE: {
+        name: 'Invoice',
+        category: 'invoice',
+        content: `📄 *INVOICE*\n\nInvoice #: {{invoiceNumber}}\nDate: {{invoiceDate}}\nDue Date: {{dueDate}}\n\n*Bill To:*\n{{customerName}}\n{{customerAddress:}}\n\n*Items:*\n{{items}}\n\nSubtotal: Rp {{subtotal}}\nTax ({{taxRate:11}}%): Rp {{tax}}\n*Total: Rp {{total}}*\n\nPayment Method: {{paymentMethod:Transfer Bank}}\nAccount: {{bankAccount:}}`
+    },
+    WELCOME: {
+        name: 'Welcome Message',
+        category: 'greeting',
+        content: `👋 *Welcome, {{name}}!*\n\nThank you for joining {{companyName:us}}! \n\nWe're excited to have you. Here's what you can do:\n{{features:- Explore our products\n- Get exclusive offers\n- 24/7 support}}\n\nNeed help? Just reply to this message!`
+    },
+    BIRTHDAY: {
+        name: 'Birthday Wishes',
+        category: 'greeting',
+        content: `🎂 *Happy Birthday, {{name}}!* 🎉\n\nWishing you a wonderful day filled with joy and happiness!\n\n🎁 As a special gift, here's {{discount:10}}% off your next purchase!\nUse code: {{code:BIRTHDAY{{year}}}}\n\nHave a great celebration! 🥳`
+    },
+    REMINDER: {
+        name: 'Reminder',
+        category: 'notification',
+        content: `⏰ *Reminder*\n\nHi {{name}},\n\nThis is a friendly reminder about:\n📋 {{subject}}\n\n📅 Date: {{date}}\n🕐 Time: {{time}}\n📍 Location: {{location:TBD}}\n\n{{notes:}}\n\nDon't forget! 🙏`
+    },
+    APPOINTMENT: {
+        name: 'Appointment Confirmation',
+        category: 'notification',
+        content: `📅 *Appointment Confirmed*\n\nHi {{name}},\n\nYour appointment has been scheduled:\n\n📋 Service: {{service}}\n📅 Date: {{date}}\n🕐 Time: {{time}}\n📍 Location: {{location}}\n\nPlease arrive 10 minutes early.\n\nNeed to reschedule? Reply to this message.`
+    },
+    SUPPORT_TICKET: {
+        name: 'Support Ticket',
+        category: 'support',
+        content: `🎫 *Support Ticket Created*\n\nTicket #: {{ticketId}}\nSubject: {{subject}}\nPriority: {{priority:Normal}}\n\nHi {{name}},\n\nWe've received your request and our team is working on it.\n\nExpected response time: {{responseTime:24 hours}}\n\nThank you for your patience! 🙏`
+    },
+    SUPPORT_RESOLVED: {
+        name: 'Support Resolved',
+        category: 'support',
+        content: `✅ *Issue Resolved*\n\nTicket #: {{ticketId}}\n\nHi {{name}},\n\nYour issue has been resolved:\n\n*Solution:*\n{{solution}}\n\nIf you need further assistance, please reply to this message.\n\nThank you! 🙏`
+    }
+}
+
+const createTemplateManager = (includePresets = true) => {
+    const manager = new TemplateManager()
+
+    if (includePresets) {
+        for (const [key, template] of Object.entries(exports.PRESET_TEMPLATES)) {
+            manager.create({
+                ...template,
+                id: key.toLowerCase()
+            })
+        }
+    }
+
+    return manager
+}
+exports.createTemplateManager = createTemplateManager
+
+const renderTemplate = (content, data = {}) => {
+    return content.replace(/\{\{(\w+)(?::([^}]*))?\}\}/g, (match, name, defaultValue) => {
+        const value = data[name]
+        if (value !== undefined && value !== null) {
+            return String(value)
+        }
+        if (defaultValue !== undefined) {
+            return defaultValue
+        }
+        return match
+    })
+}
+exports.renderTemplate = renderTemplate