@lp-labs/assignment-optimizer 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,101 @@
-# Temporary Holding Version
+# @lp-labs/assignment-optimizer
 
-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.
+Exact bounded unit-task assignment maximizing coverage then minimizing preference and convex load costs.
+
+Original independent MIT TypeScript implementation with **zero runtime or peer dependencies**. ESM/CommonJS with separate declarations; Node 18+ and compatible browser runtimes. No external code is downloaded or service started at import. TypeScript/Prettier are development-only tools.
+
+## Install
+
+```sh
+npm install @lp-labs/assignment-optimizer
+```
+
+## Working example
+
+```js
+import assert from 'node:assert/strict';
+import { optimizeAssignments, AssignmentError } from '@lp-labs/assignment-optimizer';
+const plan = optimizeAssignments(
+  [
+    { id: 'general', requires: [] },
+    { id: 'special', requires: ['sql'] },
+  ],
+  [
+    { id: 'expert', capacity: 1, skills: ['sql'] },
+    { id: 'generalist', capacity: 1, skills: [] },
+  ],
+);
+assert.equal(plan.assignments.length, 2);
+assert.equal(plan.assignments.find((item) => item.task === 'special').worker, 'expert');
+assert.equal(plan.unassigned.length, 0);
+assert.equal(plan.objective, plan.cost + plan.fairnessCost);
+```
+
+CommonJS: `const api = require('@lp-labs/assignment-optimizer')`. Use type-only imports for exported interfaces in TypeScript.
+
+## Behavior, customization, limits and performance
+
+Real successive-shortest-augmenting-path min-cost maximum-flow optimizer for UNIT tasks. It maximizes assignment count FIRST, then minimizes sum(task-worker preference cost) + fairnessWeight * sum(afterLoad² - beforeLoad²). Defaults fairnessWeight1; integer0..1,000,000. More expensive feasible work is still assigned because coverage is primary. Existing load consumes capacity. Workers <=50, tasks<=100, capacity<=10,000, skills/requires <=64 unique strings each; preference costs0..1,000,000 for known workers, omitted costs0. Eligibility requires ALL declared skills, even when remaining capacity is zero. Unassigned reason no-eligible-worker vs capacity is explicit.
+
+This is not a heuristic greedy planner: reverse residual edges can reroute previous assignments to satisfy constrained tasks. Bellman-Ford handles reverse negative edges; at most100 unit augmentations. Input order deterministically breaks equal-cost path ties, but equal-objective assignments have no fairness guarantee beyond the declared quadratic cost. Worst-case O(tasks * vertices * residualEdges), bounded for small interactive planning, not millions of tasks. Plan is pure, detached, safe-integer objective checked; no scheduling time, indivisible multi-unit demand, legal labor rules, priority tiers, reservations, worker execution or distributed locking. Skills supplied by caller, not inferred or verified credentials. Use the complete declared workload/availability snapshot and atomically reserve separately.
+
+## Errors and application integration
+
+Use the exported error class and its documented code (where present); invalid structural input throws rather than silently defaulting. Await async methods and handle rejections. Trusted adapters/callbacks must meet documented ownership and isolation requirements. Hostile proxies and custom prototype objects are outside the contract; ordinary data properties are required. No runtime network/worker/database dependency is hidden behind the API. Examples use Node assertions for reproducible outcomes, not as package dependencies. The declared bounded subset is the supported functionality, not a claim of complete compatibility with another library.
+
+## Complete API and customization contract
+
+The public declaration below specifies all exported functions, field names, options, return shapes and error codes. Configure explicit limits and supply callbacks/adapters through these interfaces; do not modify package internals. Optional fields follow the defaults and missing-data policies above. TypeScript consumers receive this same contract through both ESM and CommonJS exports.
+
+```ts
+export interface AssignmentWorker {
+  id: string;
+  capacity: number;
+  load?: number;
+  skills: readonly string[];
+}
+export interface AssignmentTask {
+  id: string;
+  requires: readonly string[];
+  costs?: Readonly<Record<string, number>>;
+}
+export interface AssignmentOptions {
+  fairnessWeight?: number;
+}
+export interface AssignmentPlan {
+  assignments: {
+    task: string;
+    worker: string;
+    cost: number;
+  }[];
+  unassigned: {
+    task: string;
+    reason: 'no-eligible-worker' | 'capacity';
+  }[];
+  loads: {
+    worker: string;
+    before: number;
+    after: number;
+  }[];
+  objective: number;
+  cost: number;
+  fairnessCost: number;
+}
+export declare class AssignmentError extends Error {
+  readonly code: 'invalid' | 'limit' | 'overflow';
+  constructor(code: 'invalid' | 'limit' | 'overflow', message: string);
+}
+export declare function optimizeAssignments(
+  tasks: readonly AssignmentTask[],
+  workers: readonly AssignmentWorker[],
+  options?: AssignmentOptions,
+): AssignmentPlan;
+```
+
+## 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,38 @@
+export interface AssignmentWorker {
+    id: string;
+    capacity: number;
+    load?: number;
+    skills: readonly string[];
+}
+export interface AssignmentTask {
+    id: string;
+    requires: readonly string[];
+    costs?: Readonly<Record<string, number>>;
+}
+export interface AssignmentOptions {
+    fairnessWeight?: number;
+}
+export interface AssignmentPlan {
+    assignments: {
+        task: string;
+        worker: string;
+        cost: number;
+    }[];
+    unassigned: {
+        task: string;
+        reason: 'no-eligible-worker' | 'capacity';
+    }[];
+    loads: {
+        worker: string;
+        before: number;
+        after: number;
+    }[];
+    objective: number;
+    cost: number;
+    fairnessCost: number;
+}
+export declare class AssignmentError extends Error {
+    readonly code: 'invalid' | 'limit' | 'overflow';
+    constructor(code: 'invalid' | 'limit' | 'overflow', message: string);
+}
+export declare function optimizeAssignments(tasks: readonly AssignmentTask[], workers: readonly AssignmentWorker[], options?: AssignmentOptions): AssignmentPlan;

package/dist/cjs/index.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssignmentError = void 0;
+exports.optimizeAssignments = optimizeAssignments;
+class AssignmentError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'AssignmentError';
+    }
+}
+exports.AssignmentError = AssignmentError;
+function names(values) {
+    if (!Array.isArray(values) ||
+        values.length > 64 ||
+        values.some((value) => typeof value !== 'string' || !value || value.length > 128) ||
+        new Set(values).size !== values.length)
+        throw new AssignmentError('invalid', 'Invalid skills.');
+    return new Set(values);
+}
+function optimizeAssignments(tasks, workers, options = {}) {
+    if (!Array.isArray(tasks) || !Array.isArray(workers) || tasks.length > 100 || workers.length > 50)
+        throw new AssignmentError('limit', 'At most 100 unit tasks and 50 workers supported.');
+    const fairnessWeight = options.fairnessWeight ?? 1;
+    if (!Number.isSafeInteger(fairnessWeight) || fairnessWeight < 0 || fairnessWeight > 1000000)
+        throw new AssignmentError('invalid', 'fairnessWeight must be an integer from 0 to 1000000.');
+    const ids = new Set();
+    const team = workers.map((worker) => {
+        if (!worker ||
+            typeof worker.id !== 'string' ||
+            !worker.id ||
+            worker.id.length > 256 ||
+            ids.has(worker.id) ||
+            !Number.isSafeInteger(worker.capacity) ||
+            worker.capacity < 0 ||
+            worker.capacity > 10000 ||
+            !Number.isSafeInteger(worker.load ?? 0) ||
+            (worker.load ?? 0) < 0 ||
+            (worker.load ?? 0) > worker.capacity)
+            throw new AssignmentError('invalid', 'Invalid worker/duplicate ID.');
+        ids.add(worker.id);
+        return {
+            id: worker.id,
+            capacity: worker.capacity,
+            load: worker.load ?? 0,
+            skills: names(worker.skills),
+        };
+    });
+    ids.clear();
+    const work = tasks.map((task) => {
+        if (!task ||
+            typeof task.id !== 'string' ||
+            !task.id ||
+            task.id.length > 256 ||
+            ids.has(task.id))
+            throw new AssignmentError('invalid', 'Invalid task/duplicate ID.');
+        ids.add(task.id);
+        const required = names(task.requires);
+        const costs = new Map();
+        if (task.costs !== undefined) {
+            if (!task.costs ||
+                Object.getPrototypeOf(task.costs) !== Object.prototype ||
+                Object.getOwnPropertySymbols(task.costs).length ||
+                Object.keys(task.costs).length > 50)
+                throw new AssignmentError('invalid', 'Invalid cost data.');
+            for (const id of Object.keys(task.costs)) {
+                const descriptor = Object.getOwnPropertyDescriptor(task.costs, id);
+                if (!team.some((worker) => worker.id === id) ||
+                    !('value' in descriptor) ||
+                    !Number.isSafeInteger(descriptor.value) ||
+                    descriptor.value < 0 ||
+                    descriptor.value > 1000000)
+                    throw new AssignmentError('invalid', 'Cost must reference a known worker and be 0..1000000.');
+                costs.set(id, descriptor.value);
+            }
+        }
+        return { id: task.id, required, costs };
+    });
+    const source = 0, taskStart = 1, workerStart = taskStart + work.length, sink = workerStart + team.length;
+    const graph = Array.from({ length: sink + 1 }, () => []);
+    const add = (from, to, cost) => {
+        const forward = { to, reverse: graph[to].length, capacity: 1, cost };
+        const backward = { to: from, reverse: graph[from].length, capacity: 0, cost: -cost };
+        graph[from].push(forward);
+        graph[to].push(backward);
+        return forward;
+    };
+    const pairs = [];
+    const eligible = work.map(() => 0);
+    work.forEach((task, i) => {
+        add(source, taskStart + i, 0);
+        team.forEach((worker, j) => {
+            if ([...task.required].every((skill) => worker.skills.has(skill))) {
+                eligible[i] = eligible[i] + 1;
+                const cost = task.costs.get(worker.id) ?? 0;
+                pairs.push({ task: i, worker: j, edge: add(taskStart + i, workerStart + j, cost), cost });
+            }
+        });
+    });
+    team.forEach((worker, j) => {
+        const slots = Math.min(work.length, worker.capacity - worker.load);
+        for (let slot = 1; slot <= slots; slot++)
+            add(workerStart + j, sink, fairnessWeight * (2 * (worker.load + slot) - 1));
+    });
+    let objective = 0;
+    // Successive shortest augmenting paths retain reverse edges, so earlier assignments can be rerouted.
+    while (true) {
+        const distance = Array(graph.length).fill(Infinity);
+        const previous = Array.from({
+            length: graph.length,
+        });
+        distance[source] = 0;
+        for (let pass = 0; pass < graph.length - 1; pass++) {
+            let changed = false;
+            for (let from = 0; from < graph.length; from++) {
+                if (!Number.isFinite(distance[from]))
+                    continue;
+                graph[from].forEach((edge, index) => {
+                    const candidate = distance[from] + edge.cost;
+                    if (edge.capacity && candidate < distance[edge.to]) {
+                        distance[edge.to] = candidate;
+                        previous[edge.to] = { node: from, edge: index };
+                        changed = true;
+                    }
+                });
+            }
+            if (!changed)
+                break;
+        }
+        if (!Number.isFinite(distance[sink]))
+            break;
+        objective += distance[sink];
+        if (!Number.isSafeInteger(objective))
+            throw new AssignmentError('overflow', 'Objective overflow.');
+        for (let node = sink; node !== source;) {
+            const step = previous[node];
+            if (!step)
+                throw new AssignmentError('invalid', 'Residual path invariant failed.');
+            const edge = graph[step.node][step.edge];
+            edge.capacity--;
+            graph[node][edge.reverse].capacity++;
+            node = step.node;
+        }
+    }
+    const assignments = [];
+    const assigned = new Set();
+    const counts = team.map(() => 0);
+    let cost = 0;
+    for (const pair of pairs)
+        if (pair.edge.capacity === 0) {
+            assignments.push({
+                task: work[pair.task].id,
+                worker: team[pair.worker].id,
+                cost: pair.cost,
+            });
+            assigned.add(pair.task);
+            counts[pair.worker] = counts[pair.worker] + 1;
+            cost += pair.cost;
+        }
+    const loads = team.map((worker, index) => ({
+        worker: worker.id,
+        before: worker.load,
+        after: worker.load + counts[index],
+    }));
+    const fairnessCost = loads.reduce((sum, item) => sum + fairnessWeight * (item.after ** 2 - item.before ** 2), 0);
+    if (cost + fairnessCost !== objective)
+        throw new AssignmentError('invalid', 'Objective accounting invariant failed.');
+    return {
+        assignments,
+        unassigned: work.flatMap((task, index) => assigned.has(index)
+            ? []
+            : [
+                {
+                    task: task.id,
+                    reason: eligible[index] === 0 ? 'no-eligible-worker' : 'capacity',
+                },
+            ]),
+        loads,
+        objective,
+        cost,
+        fairnessCost,
+    };
+}

package/dist/cjs/package.json

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

package/dist/esm/index.d.ts

@@ -0,0 +1,38 @@
+export interface AssignmentWorker {
+    id: string;
+    capacity: number;
+    load?: number;
+    skills: readonly string[];
+}
+export interface AssignmentTask {
+    id: string;
+    requires: readonly string[];
+    costs?: Readonly<Record<string, number>>;
+}
+export interface AssignmentOptions {
+    fairnessWeight?: number;
+}
+export interface AssignmentPlan {
+    assignments: {
+        task: string;
+        worker: string;
+        cost: number;
+    }[];
+    unassigned: {
+        task: string;
+        reason: 'no-eligible-worker' | 'capacity';
+    }[];
+    loads: {
+        worker: string;
+        before: number;
+        after: number;
+    }[];
+    objective: number;
+    cost: number;
+    fairnessCost: number;
+}
+export declare class AssignmentError extends Error {
+    readonly code: 'invalid' | 'limit' | 'overflow';
+    constructor(code: 'invalid' | 'limit' | 'overflow', message: string);
+}
+export declare function optimizeAssignments(tasks: readonly AssignmentTask[], workers: readonly AssignmentWorker[], options?: AssignmentOptions): AssignmentPlan;

package/dist/esm/index.js

@@ -0,0 +1,179 @@
+export class AssignmentError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'AssignmentError';
+    }
+}
+function names(values) {
+    if (!Array.isArray(values) ||
+        values.length > 64 ||
+        values.some((value) => typeof value !== 'string' || !value || value.length > 128) ||
+        new Set(values).size !== values.length)
+        throw new AssignmentError('invalid', 'Invalid skills.');
+    return new Set(values);
+}
+export function optimizeAssignments(tasks, workers, options = {}) {
+    if (!Array.isArray(tasks) || !Array.isArray(workers) || tasks.length > 100 || workers.length > 50)
+        throw new AssignmentError('limit', 'At most 100 unit tasks and 50 workers supported.');
+    const fairnessWeight = options.fairnessWeight ?? 1;
+    if (!Number.isSafeInteger(fairnessWeight) || fairnessWeight < 0 || fairnessWeight > 1000000)
+        throw new AssignmentError('invalid', 'fairnessWeight must be an integer from 0 to 1000000.');
+    const ids = new Set();
+    const team = workers.map((worker) => {
+        if (!worker ||
+            typeof worker.id !== 'string' ||
+            !worker.id ||
+            worker.id.length > 256 ||
+            ids.has(worker.id) ||
+            !Number.isSafeInteger(worker.capacity) ||
+            worker.capacity < 0 ||
+            worker.capacity > 10000 ||
+            !Number.isSafeInteger(worker.load ?? 0) ||
+            (worker.load ?? 0) < 0 ||
+            (worker.load ?? 0) > worker.capacity)
+            throw new AssignmentError('invalid', 'Invalid worker/duplicate ID.');
+        ids.add(worker.id);
+        return {
+            id: worker.id,
+            capacity: worker.capacity,
+            load: worker.load ?? 0,
+            skills: names(worker.skills),
+        };
+    });
+    ids.clear();
+    const work = tasks.map((task) => {
+        if (!task ||
+            typeof task.id !== 'string' ||
+            !task.id ||
+            task.id.length > 256 ||
+            ids.has(task.id))
+            throw new AssignmentError('invalid', 'Invalid task/duplicate ID.');
+        ids.add(task.id);
+        const required = names(task.requires);
+        const costs = new Map();
+        if (task.costs !== undefined) {
+            if (!task.costs ||
+                Object.getPrototypeOf(task.costs) !== Object.prototype ||
+                Object.getOwnPropertySymbols(task.costs).length ||
+                Object.keys(task.costs).length > 50)
+                throw new AssignmentError('invalid', 'Invalid cost data.');
+            for (const id of Object.keys(task.costs)) {
+                const descriptor = Object.getOwnPropertyDescriptor(task.costs, id);
+                if (!team.some((worker) => worker.id === id) ||
+                    !('value' in descriptor) ||
+                    !Number.isSafeInteger(descriptor.value) ||
+                    descriptor.value < 0 ||
+                    descriptor.value > 1000000)
+                    throw new AssignmentError('invalid', 'Cost must reference a known worker and be 0..1000000.');
+                costs.set(id, descriptor.value);
+            }
+        }
+        return { id: task.id, required, costs };
+    });
+    const source = 0, taskStart = 1, workerStart = taskStart + work.length, sink = workerStart + team.length;
+    const graph = Array.from({ length: sink + 1 }, () => []);
+    const add = (from, to, cost) => {
+        const forward = { to, reverse: graph[to].length, capacity: 1, cost };
+        const backward = { to: from, reverse: graph[from].length, capacity: 0, cost: -cost };
+        graph[from].push(forward);
+        graph[to].push(backward);
+        return forward;
+    };
+    const pairs = [];
+    const eligible = work.map(() => 0);
+    work.forEach((task, i) => {
+        add(source, taskStart + i, 0);
+        team.forEach((worker, j) => {
+            if ([...task.required].every((skill) => worker.skills.has(skill))) {
+                eligible[i] = eligible[i] + 1;
+                const cost = task.costs.get(worker.id) ?? 0;
+                pairs.push({ task: i, worker: j, edge: add(taskStart + i, workerStart + j, cost), cost });
+            }
+        });
+    });
+    team.forEach((worker, j) => {
+        const slots = Math.min(work.length, worker.capacity - worker.load);
+        for (let slot = 1; slot <= slots; slot++)
+            add(workerStart + j, sink, fairnessWeight * (2 * (worker.load + slot) - 1));
+    });
+    let objective = 0;
+    // Successive shortest augmenting paths retain reverse edges, so earlier assignments can be rerouted.
+    while (true) {
+        const distance = Array(graph.length).fill(Infinity);
+        const previous = Array.from({
+            length: graph.length,
+        });
+        distance[source] = 0;
+        for (let pass = 0; pass < graph.length - 1; pass++) {
+            let changed = false;
+            for (let from = 0; from < graph.length; from++) {
+                if (!Number.isFinite(distance[from]))
+                    continue;
+                graph[from].forEach((edge, index) => {
+                    const candidate = distance[from] + edge.cost;
+                    if (edge.capacity && candidate < distance[edge.to]) {
+                        distance[edge.to] = candidate;
+                        previous[edge.to] = { node: from, edge: index };
+                        changed = true;
+                    }
+                });
+            }
+            if (!changed)
+                break;
+        }
+        if (!Number.isFinite(distance[sink]))
+            break;
+        objective += distance[sink];
+        if (!Number.isSafeInteger(objective))
+            throw new AssignmentError('overflow', 'Objective overflow.');
+        for (let node = sink; node !== source;) {
+            const step = previous[node];
+            if (!step)
+                throw new AssignmentError('invalid', 'Residual path invariant failed.');
+            const edge = graph[step.node][step.edge];
+            edge.capacity--;
+            graph[node][edge.reverse].capacity++;
+            node = step.node;
+        }
+    }
+    const assignments = [];
+    const assigned = new Set();
+    const counts = team.map(() => 0);
+    let cost = 0;
+    for (const pair of pairs)
+        if (pair.edge.capacity === 0) {
+            assignments.push({
+                task: work[pair.task].id,
+                worker: team[pair.worker].id,
+                cost: pair.cost,
+            });
+            assigned.add(pair.task);
+            counts[pair.worker] = counts[pair.worker] + 1;
+            cost += pair.cost;
+        }
+    const loads = team.map((worker, index) => ({
+        worker: worker.id,
+        before: worker.load,
+        after: worker.load + counts[index],
+    }));
+    const fairnessCost = loads.reduce((sum, item) => sum + fairnessWeight * (item.after ** 2 - item.before ** 2), 0);
+    if (cost + fairnessCost !== objective)
+        throw new AssignmentError('invalid', 'Objective accounting invariant failed.');
+    return {
+        assignments,
+        unassigned: work.flatMap((task, index) => assigned.has(index)
+            ? []
+            : [
+                {
+                    task: task.id,
+                    reason: eligible[index] === 0 ? 'no-eligible-worker' : 'capacity',
+                },
+            ]),
+        loads,
+        objective,
+        cost,
+        fairnessCost,
+    };
+}

package/package.json

@@ -1,6 +1,63 @@
 {
   "name": "@lp-labs/assignment-optimizer",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Exact bounded unit-task assignment maximizing coverage then minimizing preference and convex load costs.",
+  "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": ">=18"
+  },
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "typecheck": "npm run build && node scripts/check-types.mjs",
+    "test": "npm run build && 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"
+  }
+}