@lp-labs/template-document 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Libin Prasanth
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,64 @@
-# Temporary Holding Version
+# @lp-labs/template-document
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A bounded renderer for plain-text templates with own-property paths, simple conditionals, and
+array loops. There is no expression evaluator, function invocation, or HTML escaping.
+
+## Install
+
+```sh
+npm install @lp-labs/template-document
+```
+
+```js
+import { renderTemplate } from '@lp-labs/template-document';
+
+const text = renderTemplate(
+  'Hello {{user.name}}!{{#if user.active}} Active.{{else}} Inactive.{{/if}} {{#each user.tags as tag}}#{{tag}} {{/each}}',
+  { user: { name: 'Ada', active: true, tags: ['math', 'history'] } },
+);
+console.log(text); // Hello Ada! Active. #math #history
+```
+
+## Syntax and API
+
+- `{{user.name}}` reads a safe dotted path. Missing or null values render as an empty string.
+- `{{#if path}}...{{else}}...{{/if}}` selects a branch. `else` is optional.
+- `{{#each path as item}}...{{/each}}` iterates an array and exposes the current item through
+  `item`, including safe paths such as `item.name`. Loops can be nested.
+- `compileTemplate(source, limits?)` validates and returns a reusable `TemplateProgram`.
+- `renderTemplate(sourceOrProgram, data, limits?)` compiles string input or renders a compiled
+  program.
+- `TemplateProgram` and `TemplateLimits` are exported types.
+
+Only own data properties are traversed; accessors are not invoked. Unsafe path segments such as
+`constructor`, `prototype`, and `__proto__` are rejected. Interpolations allow finite numbers,
+booleans, strings, null, and missing values; objects/arrays cannot be stringified implicitly.
+Conditions use a small truthiness rule:
+false, zero, empty string, null/missing, and empty arrays are false; other values are true.
+Conditions do not parse comparisons or expressions.
+
+Default limits: 100,000 source characters, nesting depth 32, 1,000,000 output characters, 100,000
+render operations, and 10,000 total loop iterations. Each may be lowered with a positive integer.
+Malformed tags, unsafe paths, non-array loop values, object interpolation, and exceeded limits fail
+with `SyntaxError`, `TypeError`, or `RangeError`.
+
+**Output is plain text.** Substitution is not HTML-escaped. Do not insert this output into HTML,
+JavaScript, CSS, URLs, or other interpreted contexts without applying that context's escaping and
+validation in the consuming application.
+
+## Module formats and customization
+
+ESM, CommonJS, and TypeScript declarations are included. CommonJS:
+`const { renderTemplate } = require('@lp-labs/template-document')`. Add application-specific
+formatting only through trusted preprocessed data or a separate renderer; templates cannot call
+code or helper functions.
+
+There are no runtime or peer dependencies. TypeScript and Prettier are development-only.
+
+## Support
+
+If this library is useful to you, consider supporting its maintenance with a [donation via PayPal](https://www.paypal.me/LibinPrasanth).
+
+## Author
+
+Created by [Libin Prasanth](https://www.linkedin.com/in/libinprasanth/). Connect on LinkedIn for updates and discussion.

package/dist/cjs/index.d.ts

@@ -0,0 +1,12 @@
+export interface TemplateProgram {
+    readonly source: string;
+}
+export interface TemplateLimits {
+    maxSourceLength?: number;
+    maxDepth?: number;
+    maxOutputLength?: number;
+    maxOperations?: number;
+    maxIterations?: number;
+}
+export declare function compileTemplate(source: string, limits?: TemplateLimits): TemplateProgram;
+export declare function renderTemplate(template: string | TemplateProgram, data: unknown, limits?: TemplateLimits): string;

package/dist/cjs/index.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileTemplate = compileTemplate;
+exports.renderTemplate = renderTemplate;
+const MAX_SOURCE = 100_000;
+const MAX_DEPTH = 32;
+const MAX_OUTPUT = 1_000_000;
+const MAX_OPERATIONS = 100_000;
+const MAX_ITERATIONS = 10_000;
+const compiled = new WeakMap();
+const forbiddenKeys = new Set(['__proto__', 'prototype', 'constructor']);
+function configuredLimit(value, fallback, name) {
+    const result = value ?? fallback;
+    if (!Number.isSafeInteger(result) || result < 1 || result > fallback) {
+        throw new RangeError(`${name} must be an integer from 1 to ${fallback}.`);
+    }
+    return result;
+}
+function parsePath(value) {
+    const path = value.trim().split('.');
+    if (path.length === 0 || path.length > 32)
+        throw new SyntaxError('Template path is invalid.');
+    for (const part of path) {
+        if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(part) || forbiddenKeys.has(part)) {
+            throw new SyntaxError(`Unsafe or invalid template path segment: ${part}`);
+        }
+    }
+    return path;
+}
+function tokenize(source) {
+    const tokens = [];
+    let cursor = 0;
+    while (cursor < source.length) {
+        const opening = source.indexOf('{{', cursor);
+        const strayClosing = source.indexOf('}}', cursor);
+        if (strayClosing >= 0 && (opening < 0 || strayClosing < opening)) {
+            throw new SyntaxError('Unexpected closing template tag.');
+        }
+        if (opening < 0) {
+            tokens.push({ value: source.slice(cursor) });
+            break;
+        }
+        if (opening > cursor) {
+            tokens.push({ value: source.slice(cursor, opening) });
+        }
+        const closing = source.indexOf('}}', opening + 2);
+        if (closing < 0)
+            throw new SyntaxError('Unclosed template tag.');
+        tokens.push({
+            value: `\u0000${source.slice(opening + 2, closing).trim()}`,
+        });
+        cursor = closing + 2;
+    }
+    return tokens;
+}
+function parseNodes(tokens, cursor, limits, depth, stop = []) {
+    if (depth > configuredLimit(limits.maxDepth, MAX_DEPTH, 'maxDepth')) {
+        throw new RangeError('Template nesting limit exceeded.');
+    }
+    const nodes = [];
+    while (cursor.index < tokens.length) {
+        const token = tokens[cursor.index++];
+        if (!token.value.startsWith('\u0000')) {
+            if (token.value)
+                nodes.push({ kind: 'text', value: token.value });
+            continue;
+        }
+        const tag = token.value.slice(1);
+        if (stop.includes(tag))
+            return { nodes, stop: tag };
+        if (tag.startsWith('#if ')) {
+            const path = parsePath(tag.slice(4));
+            const yes = parseNodes(tokens, cursor, limits, depth + 1, ['else', '/if']);
+            let no = [];
+            if (yes.stop === 'else') {
+                const result = parseNodes(tokens, cursor, limits, depth + 1, ['/if']);
+                if (result.stop !== '/if')
+                    throw new SyntaxError('Missing {{/if}}.');
+                no = result.nodes;
+            }
+            else if (yes.stop !== '/if') {
+                throw new SyntaxError('Missing {{/if}}.');
+            }
+            nodes.push({ kind: 'if', path, yes: yes.nodes, no });
+        }
+        else if (tag.startsWith('#each ')) {
+            const match = /^#each\s+(.+?)\s+as\s+([A-Za-z_$][A-Za-z0-9_$]*)$/.exec(tag);
+            if (!match)
+                throw new SyntaxError('Each syntax is {{#each path as name}}.');
+            if (forbiddenKeys.has(match[2]))
+                throw new SyntaxError('Unsafe loop alias.');
+            const parsed = parseNodes(tokens, cursor, limits, depth + 1, ['/each']);
+            if (parsed.stop !== '/each')
+                throw new SyntaxError('Missing {{/each}}.');
+            nodes.push({
+                kind: 'each',
+                path: parsePath(match[1]),
+                alias: match[2],
+                body: parsed.nodes,
+            });
+        }
+        else if (tag.startsWith('/') || tag === 'else') {
+            throw new SyntaxError(`Unexpected template control tag: ${tag}`);
+        }
+        else {
+            nodes.push({ kind: 'value', path: parsePath(tag) });
+        }
+    }
+    return { nodes };
+}
+function compileTemplate(source, limits = {}) {
+    if (typeof source !== 'string')
+        throw new TypeError('Template source must be a string.');
+    const maxSourceLength = configuredLimit(limits.maxSourceLength, MAX_SOURCE, 'maxSourceLength');
+    if (source.length > maxSourceLength)
+        throw new RangeError('Template source capacity exceeded.');
+    const tokens = tokenize(source);
+    const parsed = parseNodes(tokens, { index: 0 }, limits, 0);
+    if (parsed.stop)
+        throw new SyntaxError(`Unexpected template control tag: ${parsed.stop}`);
+    const program = Object.freeze({ source });
+    compiled.set(program, parsed.nodes);
+    return program;
+}
+function resolve(root, scopes, path) {
+    let current;
+    let offset = 0;
+    const scope = [...scopes].reverse().find((item) => item.alias === path[0]);
+    if (scope) {
+        current = scope.value;
+        offset = 1;
+    }
+    else {
+        current = root;
+    }
+    for (let index = offset; index < path.length; index += 1) {
+        const part = path[index];
+        if (current === null || typeof current !== 'object' || !Object.hasOwn(current, part))
+            return undefined;
+        const descriptor = Object.getOwnPropertyDescriptor(current, part);
+        if (!descriptor || !Object.hasOwn(descriptor, 'value'))
+            return undefined;
+        current = descriptor.value;
+    }
+    return current;
+}
+function asText(value, path) {
+    if (value === undefined || value === null)
+        return '';
+    if (typeof value === 'string' || typeof value === 'boolean')
+        return String(value);
+    if (typeof value === 'number' && Number.isFinite(value))
+        return String(value);
+    throw new TypeError(`Template value ${path.join('.')} must resolve to a scalar.`);
+}
+function truthy(value) {
+    if (value === null || value === undefined || value === false || value === 0 || value === '')
+        return false;
+    if (Array.isArray(value))
+        return value.length > 0;
+    return true;
+}
+function renderTemplate(template, data, limits = {}) {
+    const program = typeof template === 'string' ? compileTemplate(template, limits) : template;
+    const nodes = program && typeof program === 'object' ? compiled.get(program) : undefined;
+    if (!nodes)
+        throw new TypeError('Template program was not created by compileTemplate.');
+    const maxOutputLength = configuredLimit(limits.maxOutputLength, MAX_OUTPUT, 'maxOutputLength');
+    const maxOperations = configuredLimit(limits.maxOperations, MAX_OPERATIONS, 'maxOperations');
+    const maxIterations = configuredLimit(limits.maxIterations, MAX_ITERATIONS, 'maxIterations');
+    let operations = 0;
+    let iterations = 0;
+    let outputLength = 0;
+    const chunks = [];
+    const scopes = [];
+    const render = (items) => {
+        for (const node of items) {
+            operations += 1;
+            if (operations > maxOperations)
+                throw new RangeError('Template operation limit exceeded.');
+            if (node.kind === 'text') {
+                chunks.push(node.value);
+                outputLength += node.value.length;
+            }
+            else if (node.kind === 'value') {
+                const value = asText(resolve(data, scopes, node.path), node.path);
+                chunks.push(value);
+                outputLength += value.length;
+            }
+            else if (node.kind === 'if') {
+                render(truthy(resolve(data, scopes, node.path)) ? node.yes : node.no);
+            }
+            else {
+                const value = resolve(data, scopes, node.path);
+                if (value !== undefined && value !== null && !Array.isArray(value)) {
+                    throw new TypeError(`Loop value ${node.path.join('.')} must be an array.`);
+                }
+                const array = (value ?? []);
+                for (let index = 0; index < array.length; index += 1) {
+                    iterations += 1;
+                    if (iterations > maxIterations)
+                        throw new RangeError('Template iteration limit exceeded.');
+                    const descriptor = Object.getOwnPropertyDescriptor(array, String(index));
+                    const item = descriptor && Object.hasOwn(descriptor, 'value') ? descriptor.value : undefined;
+                    scopes.push({ alias: node.alias, value: item });
+                    render(node.body);
+                    scopes.pop();
+                }
+            }
+            if (outputLength > maxOutputLength)
+                throw new RangeError('Template output capacity exceeded.');
+        }
+    };
+    render(nodes);
+    return chunks.join('');
+}

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/esm/index.d.ts

@@ -0,0 +1,12 @@
+export interface TemplateProgram {
+    readonly source: string;
+}
+export interface TemplateLimits {
+    maxSourceLength?: number;
+    maxDepth?: number;
+    maxOutputLength?: number;
+    maxOperations?: number;
+    maxIterations?: number;
+}
+export declare function compileTemplate(source: string, limits?: TemplateLimits): TemplateProgram;
+export declare function renderTemplate(template: string | TemplateProgram, data: unknown, limits?: TemplateLimits): string;

package/dist/esm/index.js

@@ -0,0 +1,212 @@
+const MAX_SOURCE = 100_000;
+const MAX_DEPTH = 32;
+const MAX_OUTPUT = 1_000_000;
+const MAX_OPERATIONS = 100_000;
+const MAX_ITERATIONS = 10_000;
+const compiled = new WeakMap();
+const forbiddenKeys = new Set(['__proto__', 'prototype', 'constructor']);
+function configuredLimit(value, fallback, name) {
+    const result = value ?? fallback;
+    if (!Number.isSafeInteger(result) || result < 1 || result > fallback) {
+        throw new RangeError(`${name} must be an integer from 1 to ${fallback}.`);
+    }
+    return result;
+}
+function parsePath(value) {
+    const path = value.trim().split('.');
+    if (path.length === 0 || path.length > 32)
+        throw new SyntaxError('Template path is invalid.');
+    for (const part of path) {
+        if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(part) || forbiddenKeys.has(part)) {
+            throw new SyntaxError(`Unsafe or invalid template path segment: ${part}`);
+        }
+    }
+    return path;
+}
+function tokenize(source) {
+    const tokens = [];
+    let cursor = 0;
+    while (cursor < source.length) {
+        const opening = source.indexOf('{{', cursor);
+        const strayClosing = source.indexOf('}}', cursor);
+        if (strayClosing >= 0 && (opening < 0 || strayClosing < opening)) {
+            throw new SyntaxError('Unexpected closing template tag.');
+        }
+        if (opening < 0) {
+            tokens.push({ value: source.slice(cursor) });
+            break;
+        }
+        if (opening > cursor) {
+            tokens.push({ value: source.slice(cursor, opening) });
+        }
+        const closing = source.indexOf('}}', opening + 2);
+        if (closing < 0)
+            throw new SyntaxError('Unclosed template tag.');
+        tokens.push({
+            value: `\u0000${source.slice(opening + 2, closing).trim()}`,
+        });
+        cursor = closing + 2;
+    }
+    return tokens;
+}
+function parseNodes(tokens, cursor, limits, depth, stop = []) {
+    if (depth > configuredLimit(limits.maxDepth, MAX_DEPTH, 'maxDepth')) {
+        throw new RangeError('Template nesting limit exceeded.');
+    }
+    const nodes = [];
+    while (cursor.index < tokens.length) {
+        const token = tokens[cursor.index++];
+        if (!token.value.startsWith('\u0000')) {
+            if (token.value)
+                nodes.push({ kind: 'text', value: token.value });
+            continue;
+        }
+        const tag = token.value.slice(1);
+        if (stop.includes(tag))
+            return { nodes, stop: tag };
+        if (tag.startsWith('#if ')) {
+            const path = parsePath(tag.slice(4));
+            const yes = parseNodes(tokens, cursor, limits, depth + 1, ['else', '/if']);
+            let no = [];
+            if (yes.stop === 'else') {
+                const result = parseNodes(tokens, cursor, limits, depth + 1, ['/if']);
+                if (result.stop !== '/if')
+                    throw new SyntaxError('Missing {{/if}}.');
+                no = result.nodes;
+            }
+            else if (yes.stop !== '/if') {
+                throw new SyntaxError('Missing {{/if}}.');
+            }
+            nodes.push({ kind: 'if', path, yes: yes.nodes, no });
+        }
+        else if (tag.startsWith('#each ')) {
+            const match = /^#each\s+(.+?)\s+as\s+([A-Za-z_$][A-Za-z0-9_$]*)$/.exec(tag);
+            if (!match)
+                throw new SyntaxError('Each syntax is {{#each path as name}}.');
+            if (forbiddenKeys.has(match[2]))
+                throw new SyntaxError('Unsafe loop alias.');
+            const parsed = parseNodes(tokens, cursor, limits, depth + 1, ['/each']);
+            if (parsed.stop !== '/each')
+                throw new SyntaxError('Missing {{/each}}.');
+            nodes.push({
+                kind: 'each',
+                path: parsePath(match[1]),
+                alias: match[2],
+                body: parsed.nodes,
+            });
+        }
+        else if (tag.startsWith('/') || tag === 'else') {
+            throw new SyntaxError(`Unexpected template control tag: ${tag}`);
+        }
+        else {
+            nodes.push({ kind: 'value', path: parsePath(tag) });
+        }
+    }
+    return { nodes };
+}
+export function compileTemplate(source, limits = {}) {
+    if (typeof source !== 'string')
+        throw new TypeError('Template source must be a string.');
+    const maxSourceLength = configuredLimit(limits.maxSourceLength, MAX_SOURCE, 'maxSourceLength');
+    if (source.length > maxSourceLength)
+        throw new RangeError('Template source capacity exceeded.');
+    const tokens = tokenize(source);
+    const parsed = parseNodes(tokens, { index: 0 }, limits, 0);
+    if (parsed.stop)
+        throw new SyntaxError(`Unexpected template control tag: ${parsed.stop}`);
+    const program = Object.freeze({ source });
+    compiled.set(program, parsed.nodes);
+    return program;
+}
+function resolve(root, scopes, path) {
+    let current;
+    let offset = 0;
+    const scope = [...scopes].reverse().find((item) => item.alias === path[0]);
+    if (scope) {
+        current = scope.value;
+        offset = 1;
+    }
+    else {
+        current = root;
+    }
+    for (let index = offset; index < path.length; index += 1) {
+        const part = path[index];
+        if (current === null || typeof current !== 'object' || !Object.hasOwn(current, part))
+            return undefined;
+        const descriptor = Object.getOwnPropertyDescriptor(current, part);
+        if (!descriptor || !Object.hasOwn(descriptor, 'value'))
+            return undefined;
+        current = descriptor.value;
+    }
+    return current;
+}
+function asText(value, path) {
+    if (value === undefined || value === null)
+        return '';
+    if (typeof value === 'string' || typeof value === 'boolean')
+        return String(value);
+    if (typeof value === 'number' && Number.isFinite(value))
+        return String(value);
+    throw new TypeError(`Template value ${path.join('.')} must resolve to a scalar.`);
+}
+function truthy(value) {
+    if (value === null || value === undefined || value === false || value === 0 || value === '')
+        return false;
+    if (Array.isArray(value))
+        return value.length > 0;
+    return true;
+}
+export function renderTemplate(template, data, limits = {}) {
+    const program = typeof template === 'string' ? compileTemplate(template, limits) : template;
+    const nodes = program && typeof program === 'object' ? compiled.get(program) : undefined;
+    if (!nodes)
+        throw new TypeError('Template program was not created by compileTemplate.');
+    const maxOutputLength = configuredLimit(limits.maxOutputLength, MAX_OUTPUT, 'maxOutputLength');
+    const maxOperations = configuredLimit(limits.maxOperations, MAX_OPERATIONS, 'maxOperations');
+    const maxIterations = configuredLimit(limits.maxIterations, MAX_ITERATIONS, 'maxIterations');
+    let operations = 0;
+    let iterations = 0;
+    let outputLength = 0;
+    const chunks = [];
+    const scopes = [];
+    const render = (items) => {
+        for (const node of items) {
+            operations += 1;
+            if (operations > maxOperations)
+                throw new RangeError('Template operation limit exceeded.');
+            if (node.kind === 'text') {
+                chunks.push(node.value);
+                outputLength += node.value.length;
+            }
+            else if (node.kind === 'value') {
+                const value = asText(resolve(data, scopes, node.path), node.path);
+                chunks.push(value);
+                outputLength += value.length;
+            }
+            else if (node.kind === 'if') {
+                render(truthy(resolve(data, scopes, node.path)) ? node.yes : node.no);
+            }
+            else {
+                const value = resolve(data, scopes, node.path);
+                if (value !== undefined && value !== null && !Array.isArray(value)) {
+                    throw new TypeError(`Loop value ${node.path.join('.')} must be an array.`);
+                }
+                const array = (value ?? []);
+                for (let index = 0; index < array.length; index += 1) {
+                    iterations += 1;
+                    if (iterations > maxIterations)
+                        throw new RangeError('Template iteration limit exceeded.');
+                    const descriptor = Object.getOwnPropertyDescriptor(array, String(index));
+                    const item = descriptor && Object.hasOwn(descriptor, 'value') ? descriptor.value : undefined;
+                    scopes.push({ alias: node.alias, value: item });
+                    render(node.body);
+                    scopes.pop();
+                }
+            }
+            if (outputLength > maxOutputLength)
+                throw new RangeError('Template output capacity exceeded.');
+        }
+    };
+    render(nodes);
+    return chunks.join('');
+}

package/package.json

@@ -1,6 +1,63 @@
 {
   "name": "@lp-labs/template-document",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Bounded safe-path text templates with loops and conditions.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/esm/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": "\u003e=18"
+  },
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "typecheck": "npm run build \u0026\u0026 node scripts/check-types.mjs",
+    "test": "npm run build \u0026\u0026 node --test tests/*.test.mjs",
+    "format": "prettier --write src scripts tests *.json README.md",
+    "format:check": "prettier --check src scripts tests *.json README.md",
+    "prepack": "npm run build"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3",
+    "prettier": "^3.6.2"
+  },
+  "prettier": {
+    "singleQuote": true,
+    "semi": true,
+    "trailingComma": "all",
+    "printWidth": 100,
+    "endOfLine": "lf"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "author": {
+    "name": "Libin Prasanth",
+    "url": "https://www.linkedin.com/in/libinprasanth/"
+  },
+  "funding": {
+    "type": "paypal",
+    "url": "https://www.paypal.me/LibinPrasanth"
+  }
+}