Lacspace
Loading
Free, open-source TypeScript libraries from Lacspace — a full Security Kit (AES, hashing, JWT, 2FA, passkeys, MFA, lockout), an SEO Kit (JSON-LD, sitemaps, robots, llms.txt, feeds), the WebKit / StockKit / MailKit toolkits, the platform SDK, plus Bikram Sambat dates, Nepal utilities and React hooks. Zero dependencies, isomorphic, fully typed.
$ npm install @lacspace/sdk*No third-party runtime dependencies. A few packages build on another @lacspace package.
create-lacspace-appscaffolds a real Next.js 15 + Tailwind app from a polished template — pre-wired with Lacspace SEO, security headers, sitemap and robots. Pick your kind of site and you're running in seconds.
Talk to the Lacspace platform from any JavaScript runtime.
The all-in-one client · api · auth · analytics
Bundles api + auth + analytics behind one client that shares a single connection — a login token instantly applies everywhere — plus e-commerce helpers. Start here.
$ npm install @lacspace/sdkZero-dependency HTTP client · zero dependencies
The foundation everything is built on. Typed requests, predictable errors, automatic retries with backoff, request/response interceptors, query params, in-flight de-duping, response caching and cursor pagination — built on the platform fetch. A tiny axios / ky alternative that runs on Node, browsers, edge and React Native.
$ npm install @lacspace/apiAuthentication flows · built on @lacspace/api
Login, register, current user, logout and token refresh — with the bearer token applied automatically after sign-in. Plus auto-refresh (401 → refresh → retry, deduped), pluggable token storage (memory / localStorage) and auth-change subscriptions.
$ npm install @lacspace/authThe suite that powers StockYatra. Everything a trading, charting or algo app re-implements — done once, done right.
Streaming technical indicators · zero dependencies
RSI, MACD, EMA, Bollinger, ATR, VWAP, Stochastic, Supertrend, ADX — with an incremental O(1) API. Push one live LTP tick and the indicator updates without recomputing the whole series. Plus a tick→OHLC candle aggregator and candlestick pattern detection (doji, hammer, engulfing, harami…).
$ npm install @lacspace/indicatorsMoney & mechanics · zero dependencies
P&L, returns, CAGR, XIRR, position sizing, tick-size rounding and circuit limits — plus a real Indian brokerage & charges calculator (STT, GST, SEBI, stamp) with discount-broker presets. Now with Black-Scholes options pricing & greeks, implied volatility, and portfolio analytics (Sharpe, Sortino, max drawdown).
$ npm install @lacspace/marketTrading hours & holidays · zero dependencies
Is the market open right now? When does it next open or close? A holiday-aware, timezone-correct trading clock with NSE/BSE presets — or bring your own exchange spec.
$ npm install @lacspace/market-clockPaper-trading engine · zero dependencies
The simulator core behind StockYatra. A virtual wallet, market/limit/stop orders that fill against live prices, positions, holdings and live mark-to-market P&L. Now with a per-fill charges hook (pair it with @lacspace/market for net P&L) and backtest-style stats — win rate, profit factor, avg win/loss. Drop it into any app.
$ npm install @lacspace/paper-tradeEverything a backend needs to send, compose and validate email. Send with one line; compose bulletproof HTML; catch bad addresses before they cost you.
Zero-dependency SMTP client · zero dependencies · Node
Send email over raw Node net/tls — STARTTLS, AUTH, MIME with attachments — with no npm dependencies. Provider presets make Hostinger, Gmail, Outlook, Zoho & more a one-liner. Node only.
$ npm install @lacspace/mailerResponsive HTML emails · zero dependencies
Compose bulletproof, dark-mode-aware HTML emails from simple blocks (button, OTP code, invoice table) — no more <table> soup. Ships OTP/welcome/alert/invoice templates. A tiny MJML alternative.
$ npm install @lacspace/email-templatesValidation beyond regex · zero dependencies
Syntax + disposable/temp-mail detection, role & free-provider flags, Gmail normalization, and 'did you mean?' typo suggestions (gmial.com → gmail.com). Store the normalized form to de-dupe users.
$ npm install @lacspace/email-validateDeliverability checks · MX + SMTP · Node
Resolve a domain's MX records and optionally run a real SMTP RCPT probe to check a mailbox exists — without sending anything. Best-effort (servers greylist/catch-all), great for catching dead domains. Node only.
$ npm install @lacspace/email-verifyGenerate every file and tag search engines and AI crawlers look for — metadata, JSON-LD, sitemaps, robots.txt, llms.txt, feeds and more. All typed and dependency-free.
SEO Autopilot & CI gate · zero dependencies
SEO Autopilot: defineSite() once, then site.meta()/article()/product()/faq() auto-fill Metadata AND JSON-LD — title template, canonical, OpenGraph, Twitter, auto description and dynamic OG image. Plus 19 schema.org builders, a @graph composer, content helpers (excerpt, reading time), and a built-in auditor with a CI sitemap crawler — `npx @lacspace/seo crawl <site> --min-grade A` fails your build the moment SEO regresses. Stop writing SEO by hand.
$ npm install @lacspace/seositemap.xml + index · zero dependencies
URL entries with lastmod/changefreq/priority, image/video/news extensions and hreflang alternates. Auto-splits past 50,000 URLs into an index. Emits XML and Next.js sitemap.ts objects.
$ npm install @lacspace/sitemaprobots.txt + AI blocking · zero dependencies
Typed per-user-agent rules, sitemap refs, a parser, framework presets (Next.js, WordPress, Shopify) and an isAllowed() crawlability matcher — plus a one-liner to block AI crawlers (GPTBot, ClaudeBot, CCBot, Google-Extended and 14 more).
$ npm install @lacspace/robotsllms.txt / llms-full.txt · zero dependencies
Generate and parse llms.txt and llms-full.txt — the emerging llmstxt.org standard that gives LLMs a curated, Markdown map of your site — or build one straight from your sitemap entries. The SEO layer for the AI era.
$ npm install @lacspace/llms-txtSearch-engine verification · zero dependencies
Verification meta tags, Next.js verification metadata and file tokens for Google Search Console, Bing Webmaster, Yandex, Baidu, Pinterest, Ahrefs, Facebook and more — no more hunting for the right meta name.
$ npm install @lacspace/site-verifyRSS / Atom / JSON feeds · zero dependencies
Define your feed and items once, emit valid RSS 2.0, Atom 1.0 or JSON Feed 1.1 — with CDATA content, categories, authors and podcast enclosures. Great for blogs, changelogs and news.
$ npm install @lacspace/rssSEO URL slugs · zero dependencies
Turn any text into a clean, SEO-friendly URL slug — transliterates diacritics, collapses separators, truncates on word boundaries, and guarantees uniqueness against an existing set.
$ npm install @lacspace/slugifyReal security primitives built on vetted crypto (Web Crypto — never hand-rolled): AES, password hashing, tokens, API keys, 2FA/3FA, passkeys, account lockout, hardened headers and log redaction. For web, backend, mobile, AWS/S3 and Mongo.
AES-256-GCM encryption · zero dependencies · isomorphic
Authenticated AES-256-GCM encrypt/decrypt (with AAD), PBKDF2 & HKDF key derivation, SHA-2, HMAC, secure random and constant-time compare — a thin, correct layer over Web Crypto. Plus a versioned Keyring for envelope encryption & key rotation. Encrypt Mongo fields, S3 payloads and cookies.
$ npm install @lacspace/cryptoPassword hashing · zero dependencies · isomorphic
Hash & verify with PBKDF2-HMAC-SHA256 (600k iterations per OWASP) in a portable PHC string, constant-time verify, rehash detection and a strength estimator. Never store plaintext.
$ npm install @lacspace/passwordJWTs & tokens · zero dependencies · isomorphic
Sign & verify JWTs — symmetric HS256/384/512 and asymmetric RS256/ES256 — with strict expiry/issuer/audience checks over Web Crypto, so it runs on edge and workers. Plus remote JWKS verification, refresh-token rotation with reuse detection, and opaque & CSRF tokens. A tiny jose alternative.
$ npm install @lacspace/jwtAPI keys · zero dependencies · isomorphic
Issue prefixed, high-entropy keys (lac_live_…), store only the SHA-256 hash, show the last 4, and verify in constant time — exactly how Stripe/GitHub-style keys work.
$ npm install @lacspace/apikeyTOTP / HOTP 2FA · zero dependencies · isomorphic
Google Authenticator-compatible two-factor auth over Web Crypto — runs on Node, edge and browser. Generate secrets, verify codes with drift tolerance and replay protection, build otpauth:// URIs, and issue single-use hashed backup/recovery codes. A tiny speakeasy alternative, verified against the RFC test vectors.
$ npm install @lacspace/otpPasskeys / biometric · zero dependencies · isomorphic
FaceID, fingerprint and security keys via WebAuthn — browser ceremony helpers plus server challenge, options and real ES256/RS256 assertion verification (CBOR/COSE parse, DER handling) over Web Crypto.
$ npm install @lacspace/webauthn2FA / 3FA orchestration · zero dependencies · isomorphic
Combine password + TOTP + passkey into 2FA/3FA step-up flows with NIST assurance levels (AAL1–3). Track which factors are cleared and decide when a policy is satisfied.
$ npm install @lacspace/mfaAccount lockout · zero dependencies · isomorphic
Server-side brute-force protection: track failed attempts per user/IP, lock after N strikes with exponential backoff, auto-expire the window, reset on success. Pluggable store (Redis-ready).
$ npm install @lacspace/lockSecure headers + CSP · zero dependencies · isomorphic
A tiny framework-agnostic Helmet: strict security response headers (HSTS, X-Frame-Options, Referrer-Policy, COOP) and a typed Content-Security-Policy builder. Works everywhere + Next.js.
$ npm install @lacspace/headersLog redaction · zero dependencies · isomorphic
Mask secrets & PII before they reach your logs — by sensitive key name (password, token, authorization…) and by pattern (JWTs, API keys, emails, cards, IPs). Deep, on strings and objects.
$ npm install @lacspace/redactThe things every backend re-implements — signed links and PDF documents — done once, zero-dependency, isomorphic. A new kit, growing.
Signed & expiring URLs / tokens · built on @lacspace/crypto
HMAC-signed, expiring URLs and tokens over Web Crypto — magic-login links, secure download links, unsubscribe links and one-time actions. Tamper-proof, timing-safe, with magicLink() / signUrl() helpers. Fills a real gap: no self-hosted, zero-dep option existed.
$ npm install @lacspace/signed-urlPDF invoices, receipts & docs · zero dependencies · isomorphic
Generate real PDFs with zero dependencies and no headless browser — pdfkit is heavy and node-only, puppeteer spins up Chromium. Batteries-included invoice() & receipt() plus a document builder (tables, auto page-breaks). Runs on Node, edge and the browser.
$ npm install @lacspace/pdfSign, verify & deliver webhooks · built on @lacspace/crypto
Both directions: sign & deliver outgoing webhooks with retries + backoff, and verify incoming ones (timing-safe, replay-protected) with ready-made Stripe / GitHub / Shopify presets — plus event ids & idempotency for exactly-once handlers. A zero-dep alternative to hosted svix.
$ npm install @lacspace/webhooksExactly-once operations · zero dependencies · isomorphic
The 'don't double-charge, don't send twice' primitive. Run any operation at-most-once per idempotency key and replay the stored result on retries — concurrency-safe (in-flight de-dupe + atomic create), with request fingerprinting and a pluggable store. Framework-agnostic (every other lib is Hono/AWS-locked).
$ npm install @lacspace/idempotencyGet data in and out — real Excel files and correct CSV — with no heavy libraries and no headless browser.
Excel export, zero-dep · zero dependencies · isomorphic
Write real .xlsx files with zero dependencies and no headless browser — a spreadsheet is just a ZIP of XML, so we build the bytes directly (same trick as @lacspace/pdf). Objects or arrays, correct types incl. real Excel dates, bold headers, column widths and multiple sheets. SheetJS/exceljs are heavy; this is tiny and isomorphic.
$ npm install @lacspace/xlsxRFC 4180 CSV done right · zero dependencies · isomorphic
CSV looks trivial until commas-in-quotes, quotes-in-quotes, newlines-in-cells and CRLF. This handles the RFC 4180 edge cases correctly, returns typed row objects, stringifies with minimal quoting, and auto-detects comma/tab/semicolon — in a few hundred bytes.
$ npm install @lacspace/csvThe small helpers every UI rebuilds — human-readable formatting and colour maths — as tiny, typed, dependency-free packages.
Human-readable formatting · zero dependencies · isomorphic
Bytes (1.5 KB), durations (1d 1h), relative time (3 hours ago), ordinals (21st), compact numbers (1.2M), pluralize, grammatical lists and truncation — one tiny typed package instead of installing five (pretty-bytes + ms + humanize-duration + …).
$ npm install @lacspace/humanizeColour maths + WCAG contrast · zero dependencies · isomorphic
Parse hex/rgb/hsl, convert between them, lighten/darken/mix/alpha/rotate — and, crucially, check WCAG contrast so your UI is actually readable (isReadable, readableTextColor). The colour toolkit every app rebuilds, dependency-free.
$ npm install @lacspace/colorMoney without float bugs · zero dependencies · isomorphic
0.1 + 0.2 !== 0.3 — so never store money as a float. Keeps amounts as integer minor units, refuses to add different currencies, splits a bill without losing a cent (allocate), handles zero- and three-decimal currencies, and formats with Intl. Immutable, typed.
$ npm install @lacspace/moneyThe tiny helpers every project reaches for — unique IDs, resilient calls and string-case conversion — typed and dependency-free.
UUID v4/v7, Nano-ID & short · zero dependencies · isomorphic
Every ID kind in one package — classic UUID v4, the time-sortable UUID v7 (a superb index-friendly database key), Nano-ID-style and short URL-safe codes, plus prefixed ids like user_9f8c…. Cryptographically random (Web Crypto), monotonic within a millisecond.
$ npm install @lacspace/idRetry, timeout, circuit breaker · zero dependencies · isomorphic
Resilience for flaky calls: retry() with exponential backoff + full jitter (shouldRetry/onRetry/AbortSignal), withTimeout() that cancels slow work, and a CircuitBreaker that fails fast while a dependency is down then recovers. Wrap any fetch / DB / queue call.
$ npm install @lacspace/retryString-case conversion · zero dependencies · isomorphic
camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE, Title Case, Sentence case — correct on the tricky inputs (acronyms like XMLHttpRequest, numbers like v2, mixed separators). One tiny typed package with a shared words() splitter.
$ npm install @lacspace/caseLRU + TTL + stale-while-revalidate · zero dependencies · isomorphic
An in-memory cache that does the three things you actually want — bound the size (LRU), expire entries (TTL) and hide latency (stale-while-revalidate) — plus wrap()/memoize() that cache any async function and de-duplicate concurrent in-flight calls. 100 callers, one fetch.
$ npm install @lacspace/cacheThe pieces every product app needs — schema validation, spam-proof forms, dynamic social images and a lively UI — powering create-lacspace-app out of the box.
Zod's ergonomics, zero deps · zero dependencies · isomorphic
parse / safeParse, objects, arrays, enums, unions and full type inference — plus coercion ("42" → 42, "true" → true) so one schema validates a JSON body and an HTML form. Field errors flatten() straight into a form. The validation you reach for, small enough to drop into any edge function.
$ npm install @lacspace/validateTyped forms + spam guard · zero dependencies · isomorphic
Turn a FormData into typed, validated data with a honeypot + timing spam guard, and get back either your data or per-field errors ready to re-render. createForm().action matches Next.js useActionState, so a full contact form is a few lines. Framework-agnostic, zero-dep.
$ npm install @lacspace/formDynamic OG share images · zero dependencies · isomorphic
A share-card design system you configure once and call per page — auto-fitting titles, eyebrows, badges, logos and gradients. Renders two ways from the same options: a next/og element tree (real PNG) and a zero-dependency SVG for previews, emails and icons.
$ npm install @lacspace/ogReact kit that feels alive · React peer dep · nothing else
Scroll reveals, animated counters, gradient text, tilt cards, marquees, a typewriter and a ⌘K command palette — no animation library, no CSS import. Every component respects prefers-reduced-motion and takes a className, so it drops into any Tailwind + Next.js app. React is the only peer dependency.
$ npm install @lacspace/uiMarkdown → HTML, safe · zero dependencies · isomorphic
Everything a blog or docs page needs — headings with anchor ids, nested & task lists, fenced code, blockquotes, GFM tables, images and links — rendering to clean HTML with source HTML escaped by default. Includes extractHeadings() for a table of contents. It's what the blog template in create-lacspace-app uses.
$ npm install @lacspace/markdownCookieless analytics · zero dependencies · isomorphic
Privacy-first page views + custom events sent to your own endpoint — no cookies, no localStorage IDs, no cross-site tracking, so no consent banner. Respects Do-Not-Track, auto-tracks SPA navigation, and uses sendBeacon so events survive page unload. Sends only a path, referrer host and an ephemeral per-load id.
$ npm install @lacspace/analytics-liteThe utilities every web app and backend re-implements — config, rate limiting, feature flags and Next.js — done once, typed, and dependency-free.
Feature flags & A/B — no SaaS · zero dependencies · isomorphic
Feature flags and A/B experiments with no vendor and no infrastructure: you own the config, this evaluates it. Deterministic bucketing (same user always gets the same result), percentage rollouts, targeting rules and weighted variants. Synchronous — evaluate right in render.
$ npm install @lacspace/flagsTyped env variables · zero dependencies
Declare a schema, validate process.env once at boot, and get a typed frozen object. Missing or malformed vars throw one clear error before the app serves traffic. A zero-dep t3-env / envalid alternative.
$ npm install @lacspace/envRate limiting · zero dependencies
Fixed-window, sliding-window and token-bucket algorithms over a pluggable store (in-memory built in; bring your own Redis). Standard RateLimit-* headers. Drop into any API route, middleware or edge function.
$ npm install @lacspace/rate-limitNext.js App Router integration · built on @lacspace/sdk
The server-side companion to @lacspace/react: an authenticated SDK client from cookies, Route Handler & Server Action wrappers, cookie helpers, a one-line middleware auth guard and double-submit CSRF protection. Next.js 14 & 15.
$ npm install @lacspace/nextBatteries-included helpers for building Nepal-facing apps.
Bikram Sambat ↔ Gregorian · zero dependencies
Convert between BS and AD dates with Devanagari formatting. Range BS 1970–2086, cross-checked against established datasets across 42,000+ conversions.
$ npm install @lacspace/nepali-dateEveryday Nepal helpers · zero dependencies
NPR currency formatting (lakh/crore grouping), Devanagari numerals, amount-in-words for invoices, phone carrier detection & validators, all 77 districts by province, and a land-area converter (ropani-aana-paisa ↔ bigha-kattha-dhur ↔ m²/ft²).
$ npm install @lacspace/nepali-utilsA complete React layer that pairs with any app: essential hooks, tiny global state, data fetching, theming, keyboard shortcuts and list virtualization — all zero-dependency and SSR-safe.
24+ essential hooks · zero deps · react 18+
The hooks you reach for on every project — useLocalStorage, useDebounce, useMediaQuery, useOnClickOutside, useCopyToClipboard, useInterval, useIntersectionObserver and 20 more. Every one SSR-safe, fully typed and tree-shakeable.
$ npm install @lacspace/hooksGlobal state in ~1 KB · zero deps · react 18+
Create a store, use selectors, no provider — built on useSyncExternalStore with a persist middleware and shallow equality. A Zustand-lite that also works outside React.
$ npm install @lacspace/storeData fetching & cache · zero deps · react 18+
useQuery + useMutation with a shared cache, request de-duplication, stale-while-revalidate and focus/reconnect revalidation — an SWR-lite in ~2 KB.
$ npm install @lacspace/queryDark / light / system · zero deps · react 18+
A tiny ThemeProvider (with a built-in no-flash script), a useTheme hook and getThemeScript(). Persists to storage, follows the OS, toggles a class or data-attribute — a framework-agnostic next-themes-lite.
$ npm install @lacspace/themeThe packages are small on purpose — they get powerful when you combine them. No config files, no interactive prompts, no import-time surprises. Just import and go.
import { verify } from "@lacspace/password";
import { verifyTotp } from "@lacspace/otp";
import { sign } from "@lacspace/jwt";
import { lockout } from "@lacspace/lock";
const guard = lockout({ maxAttempts: 5, baseDelayMs: 60_000 });
async function login(email: string, pw: string, code: string) {
if ((await guard.check(email)).locked) throw new Error("Too many attempts");
const user = await db.users.findOne({ email });
const okPw = user && (await verify(pw, user.passwordHash));
const ok2fa = okPw && (await verifyTotp(code, user.totpSecret)) !== null;
if (!ok2fa) { await guard.record(email); throw new Error("Invalid credentials"); }
await guard.reset(email);
return sign({ sub: user.id, role: user.role }, process.env.JWT_SECRET!, { expiresIn: 3600 });
}import { encrypt, decrypt } from "@lacspace/crypto";
import { redact } from "@lacspace/redact";
const KEY = process.env.DATA_KEY!; // 256-bit base64url key
// store encrypted — authenticated AES-256-GCM
await db.users.updateOne({ _id }, { $set: { pan: await encrypt(pan, KEY) } });
// read it back
const pan = await decrypt(user.pan, KEY);
// never leak secrets into logs
logger.info(redact({ user: user.email, token, pan })); // → maskedimport { defineSite, jsonLdScript } from "@lacspace/seo";
import { robotsForSite } from "@lacspace/robots";
import { sitemapForSite } from "@lacspace/sitemap";
// lib/site.ts — your brand, declared ONCE
export const site = defineSite({
name: "Acme", url: "https://acme.com",
logo: "/logo.png", twitter: "acmehq", ogImage: "/og",
});
// app/blog/[slug]/page.tsx — metadata + BlogPosting + Breadcrumb in one call
const { metadata, jsonLd } = site.article({
title: post.title, path: `/blog/${post.slug}`,
datePublished: post.date, author: "Lumi AI", content: post.body, // description auto-derived
});
export { metadata };
// app/robots.ts & app/sitemap.ts — from the same config
export const robots = () => robotsForSite(site.config, { blockAi: true });
export const sitemap = () => sitemapForSite(site.config, ["/", "/pricing", "/blog"]);import { RSI } from "@lacspace/indicators";
import { charges } from "@lacspace/market";
import { MarketClock, NSE } from "@lacspace/market-clock";
const rsi = new RSI(14);
socket.on("ltp", (price) => {
const value = rsi.next(price); // O(1) per tick — no array recompute
if (value !== null && value > 70) flag("overbought", value);
});
new MarketClock(NSE).isOpen(); // is NSE trading right now?
charges({ segment: "intraday", buy: 100, sell: 102, qty: 500 }).netPnl; // 946.34create-lacspace-seo scaffolds a Next.js app's robots.txt, sitemap.xml, feed.xml, llms.txt and a dynamic OG-image route — all wired to one defineSite() config. No boilerplate, no copywriting.
Whether you're hardening an API, doing on-page SEO, building a trading screen or a Nepal-facing app, it's the same story: import a tiny, typed function, get a correct result. Written against standard web APIs, so the same code runs across every JavaScript runtime.
The same standards we hold our own products to — applied to the tools we give away.
The core packages ship with no runtime dependencies — built on the platform fetch. Your node_modules stays tiny and your supply chain stays clean.
The same code runs on a server, in a browser, on the edge, or in React Native. No polyfills, no environment branching.
Full TypeScript definitions, shipped as both ESM and CommonJS with a proper exports map. Great DX in any modern toolchain.
Published under the Lacspace Free Licence — MIT-equivalent freedoms. Use them in personal and commercial projects, no strings attached.
Everything you'd want to know before adding an @lacspace package.
Yes — the packages have no third-party runtime dependencies. A few build on another Lacspace package (for example @lacspace/password uses @lacspace/crypto, and the security packages use the platform's Web Crypto), but there are no external npm dependencies pulled into your node_modules. That keeps installs tiny and your supply chain clean.
Most do. The packages are isomorphic — written against standard web APIs like fetch and Web Crypto — so the same code runs on Node 18+, in browsers, on edge runtimes and workers, and in React Native. A few are server-only by nature (for example @lacspace/mailer and @lacspace/email-verify open TCP sockets, and @lacspace/next targets the Next.js server); each README states its runtime clearly.
No hand-rolled crypto. The Security Kit is a thin, correct layer over the Web Crypto API — AES-256-GCM, PBKDF2, HMAC, ECDSA/RSA verification. We test against known vectors (for example TOTP against RFC 6238 and SHA-256 against the NIST test vector) before every release.
Yes. Every package is published under the Lacspace Free Licence — a free, permissive licence with MIT-equivalent freedoms — so you can use them in personal and commercial projects with no strings attached. Read the full licence at lacspace.com/licenses. (Lacspace's products are proprietary; the npm packages are the part we give away.)
Install with your package manager of choice — npm install @lacspace/<name>, or pnpm/yarn/bun. Every package ships full TypeScript definitions and is published as both ESM and CommonJS with a proper exports map, so it works in any modern toolchain with editor autocomplete out of the box.
All 35 packages live in one open monorepo at github.com/lacspace/npm-packages under the Lacspace Free Licence. Issues and pull requests are welcome — and if there's a package you wish existed, open an issue and tell us.
A free, permissive licence with MIT-equivalent freedoms — one licence for every open Lacspace package, across every language. Use it in personal and commercial projects at no cost.
All the source lives in one open monorepo. Issues and pull requests welcome — and if there's a package you wish existed, tell us.