@helpers4/license 3.1.1-alpha.0

package/LICENSE.md

@@ -0,0 +1,160 @@
+### GNU LESSER GENERAL PUBLIC LICENSE
+
+Version 3, 29 June 2007
+
+Copyright (C) 2007 Free Software Foundation, Inc.
+<https://fsf.org/\>
+
+Everyone is permitted to copy and distribute verbatim copies of this
+license document, but changing it is not allowed.
+
+This version of the GNU Lesser General Public License incorporates the
+terms and conditions of version 3 of the GNU General Public License,
+supplemented by the additional permissions listed below.
+
+#### 0. Additional Definitions.
+
+As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the
+GNU General Public License.
+
+"The Library" refers to a covered work governed by this License, other
+than an Application or a Combined Work as defined below.
+
+An "Application" is any work that makes use of an interface provided by
+the Library, but which is not otherwise based on the Library. Defining a
+subclass of a class defined by the Library is deemed a mode of using an
+interface provided by the Library.
+
+A "Combined Work" is a work produced by combining or linking an
+Application with the Library. The particular version of the Library with
+which the Combined Work was made is also called the "Linked Version".
+
+The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+#### 1. Exception to Section 3 of the GNU GPL.
+
+You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+#### 2. Conveying Modified Versions.
+
+If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified version:
+
+- **a)** under this License, provided that you make a good faith effort
+  to ensure that, in the event an Application does not supply the
+  function or data, the facility still operates, and performs whatever
+  part of its purpose remains meaningful, or
+
+- **b)** under the GNU GPL, with none of the additional permissions of
+  this License applicable to that copy.
+
+#### 3. Object Code Incorporating Material from Library Header Files.
+
+The object code form of an Application may incorporate material from a
+header file that is part of the Library. You may convey such object code
+under terms of your choice, provided that, if the incorporated material
+is not limited to numerical parameters, data structure layouts and
+accessors, or small macros, inline functions and templates (ten or fewer
+lines in length), you do both of the following:
+
+- **a)** Give prominent notice with each copy of the object code that
+  the Library is used in it and that the Library and its use are covered
+  by this License.
+
+- **b)** Accompany the object code with a copy of the GNU GPL and this
+  license document.
+
+#### 4. Combined Works.
+
+You may convey a Combined Work under terms of your choice that, taken
+together, effectively do not restrict modification of the portions of
+the Library contained in the Combined Work and reverse engineering for
+debugging such modifications, if you also do each of the following:
+
+- **a)** Give prominent notice with each copy of the Combined Work that
+  the Library is used in it and that the Library and its use are covered
+  by this License.
+
+- **b)** Accompany the Combined Work with a copy of the GNU GPL and
+  this license document.
+
+- **c)** For a Combined Work that displays copyright notices during
+  execution, include the copyright notice for the Library among these
+  notices, as well as a reference directing the user to the copies of
+  the GNU GPL and this license document.
+
+- **d)** Do one of the following:
+
+  - **0)** Convey the Minimal Corresponding Source under the terms of
+    this License, and the Corresponding Application Code in a form
+    suitable for, and under terms that permit, the user to recombine or
+    relink the Application with a modified version of the Linked Version
+    to produce a modified Combined Work, in the manner specified by
+    section 6 of the GNU GPL for conveying Corresponding Source.
+
+  - **1)** Use a suitable shared library mechanism for linking with the
+    Library. A suitable mechanism is one that (a) uses at run time a copy
+    of the Library already present on the user's computer system, and (b)
+    will operate properly with a modified version of the Library that is
+    interface-compatible with the Linked Version.
+
+- **e)** Provide Installation Information, but only if you would
+  otherwise be required to provide such information under section 6 of
+  the GNU GPL, and only to the extent that such information is necessary
+  to install and execute a modified version of the Combined Work produced
+  by recombining or relinking the Application with a modified version of
+  the Linked Version. (If you use option 4d0, the Installation
+  Information must accompany the Minimal Corresponding Source and
+  Corresponding Application Code. If you use option 4d1, you must
+  provide the Installation Information in the manner specified by
+  section 6 of the GNU GPL for conveying Corresponding Source.)
+
+#### 5. Combined Libraries.
+
+You may place library facilities that are a work based on the Library
+side by side in a single library together with other library facilities
+that are not Applications and are not covered by this License, and
+convey such a combined library under terms of your choice, if you do
+both of the following:
+
+- **a)** Accompany the combined library with a copy of the same work
+  based on the Library, uncombined with any other library facilities,
+  conveyed under the terms of this License.
+
+- **b)** Give prominent notice with the combined library that part of
+  it is a work based on the Library, and explaining where to find the
+  accompanying uncombined form of the same work.
+
+#### 6. Revised Versions of the GNU Lesser General Public License.
+
+The Free Software Foundation may publish revised and/or new versions of
+the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Library as
+you received it specifies that a certain numbered version of the GNU
+Lesser General Public License "or any later version" applies to it, you
+have the option of following the terms and conditions either of that
+published version or of any later version published by the Free Software
+Foundation. If the Library as you received it does not specify a version
+number of the GNU Lesser General Public License, you may choose any
+version of the GNU Lesser General Public License ever published by the
+Free Software Foundation.
+
+If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the Library.

package/README.md

@@ -0,0 +1,87 @@
+# @helpers4
+
+The `@helpers4` are a collection of helper functions for use in any project, whatever the framework.
+Every helper is a standalone module and supports tree-shaking, so you can use only the helpers you need without embedding the whole library.
+
+## @helpers4/license
+
+A set of helpers for working with URLs.
+
+## Documentation
+
+[https://helpers4.dev/typescript/categories/license/](https://helpers4.dev/typescript/categories/license/)
+
+<!-- AUTOMATIC-METHODS -->
+- agree
+- families
+- isKnown
+<!-- /AUTOMATIC-METHODS -->
+
+## See
+
+<!-- AUTOMATIC-SIBLINGS -->
+- [array](../array)
+- [ci](../ci)
+- [color](../color)
+- [commit](../commit)
+- [date](../date)
+- [function](../function)
+- [guard](../guard)
+- [id](../id)
+- [map](../map)
+- [markdown](../markdown)
+- [node](../node)
+- [number](../number)
+- [object](../object)
+- [observable](../observable)
+- [promise](../promise)
+- [set](../set)
+- [string](../string)
+- [structure](../structure)
+- [type](../type)
+- [url](../url)
+- [version](../version)
+<!-- /AUTOMATIC-SIBLINGS -->
+
+## All Available Packages
+
+<!-- AUTOMATIC-CATEGORIES-TABLE -->
+| Name | Package | Source Code | Description |
+|------|---------|-------------|-------------|
+| array | [@helpers4/array](https://www.npmjs.com/package/@helpers4/array) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/array) | Array manipulation utilities |
+| ci | [@helpers4/ci](https://www.npmjs.com/package/@helpers4/ci) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/ci) | CI/CD workflow status utilities |
+| color | [@helpers4/color](https://www.npmjs.com/package/@helpers4/color) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/color) | Color conversion and validation utilities |
+| commit | [@helpers4/commit](https://www.npmjs.com/package/@helpers4/commit) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/commit) | Conventional Commits parsing and analysis |
+| date | [@helpers4/date](https://www.npmjs.com/package/@helpers4/date) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/date) | Date and time utility functions |
+| function | [@helpers4/function](https://www.npmjs.com/package/@helpers4/function) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/function) | Function utilities and type guards |
+| guard | [@helpers4/guard](https://www.npmjs.com/package/@helpers4/guard) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/guard) | Runtime type guard utilities |
+| id | [@helpers4/id](https://www.npmjs.com/package/@helpers4/id) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/id) | Unique identifier generation utilities |
+| license | [@helpers4/license](https://www.npmjs.com/package/@helpers4/license) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/license) | License string classification and comparison |
+| map | [@helpers4/map](https://www.npmjs.com/package/@helpers4/map) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/map) | Native Map manipulation utilities |
+| markdown | [@helpers4/markdown](https://www.npmjs.com/package/@helpers4/markdown) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/markdown) | Markdown formatting and escaping utilities |
+| node | [@helpers4/node](https://www.npmjs.com/package/@helpers4/node) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/node) | Node.js-specific utilities |
+| number | [@helpers4/number](https://www.npmjs.com/package/@helpers4/number) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/number) | Number utility functions and validation |
+| object | [@helpers4/object](https://www.npmjs.com/package/@helpers4/object) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/object) | Object manipulation utilities |
+| observable | [@helpers4/observable](https://www.npmjs.com/package/@helpers4/observable) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/observable) | Observable utilities and combinators |
+| promise | [@helpers4/promise](https://www.npmjs.com/package/@helpers4/promise) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/promise) | Promise utilities and error handling |
+| set | [@helpers4/set](https://www.npmjs.com/package/@helpers4/set) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/set) | Native Set manipulation utilities |
+| string | [@helpers4/string](https://www.npmjs.com/package/@helpers4/string) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/string) | String manipulation and formatting utilities |
+| structure | [@helpers4/structure](https://www.npmjs.com/package/@helpers4/structure) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/structure) | Generic, domain-agnostic data structures |
+| type | [@helpers4/type](https://www.npmjs.com/package/@helpers4/type) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/type) | Compile-time TypeScript utility types |
+| url | [@helpers4/url](https://www.npmjs.com/package/@helpers4/url) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/url) | URL parsing and manipulation utilities |
+| version | [@helpers4/version](https://www.npmjs.com/package/@helpers4/version) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/version) | Version string manipulation utilities |
+<!-- /AUTOMATIC-CATEGORIES-TABLE -->
+
+## Contributors
+
+<table>
+<tr>
+    <td align="center" style="word-wrap: break-word; width: 150.0; height: 150.0">
+        <a href=https://github.com/baxyz>
+            <img src=https://avatars.githubusercontent.com/u/7852177?v=4 width="100;" alt=baxyz/>
+            <br />
+            <sub style="font-size:14px"><b>baxyz</b></sub>
+        </a>
+    </td>
+</tr>
+</table>

package/lib/index.d.ts

@@ -0,0 +1,78 @@
+/**
+ * This file is part of helpers4.
+ * Copyright (C) 2025 baxyz
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+/**
+ * Whether two raw license strings agree closely enough to count as "no real conflict" — true
+ * when their family sets share at least one real (known) family, or when either side is entirely
+ * unknown (e.g. `"custom"`/`"unknown"`) — a vague claim is never itself evidence of disagreement.
+ * Only two *different*, both-known family sets (e.g. `bsd` vs `apache`) count as a real conflict.
+ * @param a - The first raw license string
+ * @param b - The second raw license string
+ * @returns `true` when the two strings can be treated as the same license (or too vague to tell), `false` on a real family conflict
+ * @example
+ * agree('GPL3', 'GPL-3.0-or-later')
+ * // => true
+ * @example
+ * agree('BSD-2-Clause', 'Apache-2.0')
+ * // => false
+ * @example
+ * agree('custom', 'MIT')
+ * // => true (a vague claim is never itself a conflict)
+ * @since next
+ */
+declare function agree(a: string, b: string): boolean;
+
+/**
+ * This file is part of helpers4.
+ * Copyright (C) 2025 baxyz
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+/**
+ * Groups a raw, possibly compound license string into its coarse family set — e.g.
+ * `"GPL-3.0-or-later AND LGPL-3.0-or-later"` yields `{"gpl", "lgpl"}`. Two sources reporting the
+ * same real license under different notation (`"GPL3"` vs `"GPL-3.0-or-later"`, `"GPL"` vs
+ * `"GPL2"`) yield the same family, so they read as agreeing rather than conflicting.
+ *
+ * Proprietary/custom/unknown tokens all collapse to a single shared unknown-family sentinel
+ * rather than each becoming their own one-off family, so a batch of otherwise-identical
+ * `"custom:<vendor>"` strings don't look like dozens of distinct disagreeing licenses. Use
+ * {@link isKnown} to check whether any real (non-sentinel) family was found.
+ * @param raw - A raw license string, single (`"MIT"`) or compound (`"GPL-3.0+ AND LGPL-3.0+"`)
+ * @returns The set of families found; empty only when `raw` has no tokens at all (e.g. an empty string)
+ * @example
+ * families('GPL3')
+ * // => Set(1) { 'gpl' }
+ * @example
+ * families('GPL-3.0-or-later AND LGPL-3.0-or-later')
+ * // => Set(2) { 'gpl', 'lgpl' }
+ * @example
+ * families('custom:Acme End User License')
+ * // => Set(1) { 'unknown' }
+ * @since next
+ */
+declare function families(raw: string): Set<string>;
+
+/**
+ * This file is part of helpers4.
+ * Copyright (C) 2025 baxyz
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+/**
+ * Whether a raw license string resolves to at least one recognized family — `false` for an
+ * empty string, a purely non-informative claim (`"custom"`, `"unknown"`, `"LicenseRef-EULA"`,
+ * ...), or a compound expression where every token is non-informative.
+ * @param raw - The raw license string to check
+ * @returns `true` if at least one token in `raw` resolves to a real family
+ * @example
+ * isKnown('GPL-3.0-or-later')
+ * // => true
+ * @example
+ * isKnown('custom:Acme End User License')
+ * // => false
+ * @since next
+ */
+declare function isKnown(raw: string): boolean;
+
+export { agree, families, isKnown };

package/lib/index.js

@@ -0,0 +1,234 @@
+//#region helpers/license/_unknownFamily.ts
+/**
+* This file is part of helpers4.
+* Copyright (C) 2025 baxyz
+* SPDX-License-Identifier: LGPL-3.0-or-later
+*/
+/**
+* Sentinel family for a license token that carries no comparable content — `custom`, a bare
+* vendor name inside `custom:<...>`/`LicenseRef-<...>`, or an explicit "we don't know". Two
+* unknown tokens are never treated as either agreeing or conflicting with each other, since
+* neither is a real claim to compare against the other.
+*
+* Not exported from the package — `families()`, `agree()` and `isKnown()` already fully
+* encapsulate this concept; a consumer never needs the sentinel's actual value.
+* @ignore
+*/
+var UNKNOWN_FAMILY = "unknown";
+//#endregion
+//#region helpers/license/families.ts
+/**
+* This file is part of helpers4.
+* Copyright (C) 2025 baxyz
+* SPDX-License-Identifier: LGPL-3.0-or-later
+*/
+var FAMILY_ALIASES = {
+	mit: ["mit-0", "mit"],
+	gpl: [
+		"gpl-3.0-or-later",
+		"gpl-3.0-only",
+		"gpl-2.0-or-later",
+		"gpl-2.0-only",
+		"gpl-1.0-or-later",
+		"gpl-3.0+",
+		"gpl-2.0+",
+		"gpl-3.0",
+		"gpl-2.0",
+		"gplv3",
+		"gplv2",
+		"gpl3+",
+		"gpl3",
+		"gpl2",
+		"gpl-3",
+		"gpl-2",
+		"gpl"
+	],
+	lgpl: [
+		"lgpl-3.0-or-later",
+		"lgpl-3.0-only",
+		"lgpl-2.1-or-later",
+		"lgpl-2.1-only",
+		"lgpl-2.0-or-later",
+		"lgpl-2.0-only",
+		"lgpl-3.0+",
+		"lgpl-2.1+",
+		"lgpl-3.0",
+		"lgpl-2.1",
+		"lgplv3",
+		"lgplv2.1",
+		"lgpl3",
+		"lgpl2.1",
+		"lgpl2",
+		"lgpl"
+	],
+	agpl: [
+		"agpl-3.0-or-later",
+		"agpl-3.0-only",
+		"agpl-3.0",
+		"agplv3",
+		"agpl3",
+		"agpl"
+	],
+	bsd: [
+		"bsd-3-clause",
+		"bsd-2-clause",
+		"0bsd",
+		"bsd3",
+		"bsd 3-clause",
+		"bsd 2-clause",
+		"bsd-3",
+		"bsd"
+	],
+	apache: [
+		"apache-2.0",
+		"apache license 2.0",
+		"apache license, version 2.0",
+		"apache2",
+		"apache 2.0",
+		"apache"
+	],
+	mpl: [
+		"mpl-2.0",
+		"mpl2",
+		"mpl"
+	],
+	artistic: [
+		"artistic-2.0",
+		"artistic2.0",
+		"perlartistic",
+		"artistic"
+	],
+	isc: ["isc"],
+	unlicense: ["unlicense"],
+	zlib: ["zlib"],
+	wtfpl: ["wtfpl"],
+	php: ["php"],
+	epl: ["epl"],
+	cc: [
+		"cc0-1.0",
+		"cc0",
+		"cc-by-sa-4.0",
+		"cc-by-nc-sa-4.0",
+		"cc-by-sa",
+		"ccpl"
+	],
+	"public-domain": ["public domain"],
+	boost: ["bsl-1.0", "boost"],
+	eupl: ["eupl-1.2", "eupl"],
+	postgresql: ["postgresql"],
+	psf: ["psf-2.0", "psf"],
+	gfdl: ["gfdl-1.3", "gfdl"],
+	sspl: ["sspl-1.0", "sspl"],
+	busl: ["busl-1.1", "busl"]
+};
+var UNKNOWN_PATTERNS = [
+	/^custom\b/,
+	/^licenseref-/,
+	/unknown/,
+	/^none$/,
+	/^various$/,
+	/^unknow$/
+];
+function matchAlias(normalized) {
+	for (const [family, aliases] of Object.entries(FAMILY_ALIASES)) if (aliases.includes(normalized)) return family;
+}
+function splitTokens(raw) {
+	return raw.split(/\s+(?:and|or)\s+/i).map((token) => token.split(/\s+with\s+/i)[0].trim()).filter((token) => token.length > 0);
+}
+/**
+* Groups a raw, possibly compound license string into its coarse family set — e.g.
+* `"GPL-3.0-or-later AND LGPL-3.0-or-later"` yields `{"gpl", "lgpl"}`. Two sources reporting the
+* same real license under different notation (`"GPL3"` vs `"GPL-3.0-or-later"`, `"GPL"` vs
+* `"GPL2"`) yield the same family, so they read as agreeing rather than conflicting.
+*
+* Proprietary/custom/unknown tokens all collapse to a single shared unknown-family sentinel
+* rather than each becoming their own one-off family, so a batch of otherwise-identical
+* `"custom:<vendor>"` strings don't look like dozens of distinct disagreeing licenses. Use
+* {@link isKnown} to check whether any real (non-sentinel) family was found.
+* @param raw - A raw license string, single (`"MIT"`) or compound (`"GPL-3.0+ AND LGPL-3.0+"`)
+* @returns The set of families found; empty only when `raw` has no tokens at all (e.g. an empty string)
+* @example
+* families('GPL3')
+* // => Set(1) { 'gpl' }
+* @example
+* families('GPL-3.0-or-later AND LGPL-3.0-or-later')
+* // => Set(2) { 'gpl', 'lgpl' }
+* @example
+* families('custom:Acme End User License')
+* // => Set(1) { 'unknown' }
+* @since next
+*/
+function families(raw) {
+	const result = /* @__PURE__ */ new Set();
+	for (const token of splitTokens(raw)) {
+		const normalized = token.toLowerCase();
+		if (UNKNOWN_PATTERNS.some((pattern) => pattern.test(normalized))) {
+			result.add(UNKNOWN_FAMILY);
+			continue;
+		}
+		result.add(matchAlias(normalized) ?? "unknown");
+	}
+	return result;
+}
+//#endregion
+//#region helpers/license/agree.ts
+/**
+* This file is part of helpers4.
+* Copyright (C) 2025 baxyz
+* SPDX-License-Identifier: LGPL-3.0-or-later
+*/
+/**
+* Whether two raw license strings agree closely enough to count as "no real conflict" — true
+* when their family sets share at least one real (known) family, or when either side is entirely
+* unknown (e.g. `"custom"`/`"unknown"`) — a vague claim is never itself evidence of disagreement.
+* Only two *different*, both-known family sets (e.g. `bsd` vs `apache`) count as a real conflict.
+* @param a - The first raw license string
+* @param b - The second raw license string
+* @returns `true` when the two strings can be treated as the same license (or too vague to tell), `false` on a real family conflict
+* @example
+* agree('GPL3', 'GPL-3.0-or-later')
+* // => true
+* @example
+* agree('BSD-2-Clause', 'Apache-2.0')
+* // => false
+* @example
+* agree('custom', 'MIT')
+* // => true (a vague claim is never itself a conflict)
+* @since next
+*/
+function agree(a, b) {
+	const knownA = new Set([...families(a)].filter((f) => f !== UNKNOWN_FAMILY));
+	const knownB = new Set([...families(b)].filter((f) => f !== UNKNOWN_FAMILY));
+	if (knownA.size === 0 || knownB.size === 0) return true;
+	for (const family of knownA) if (knownB.has(family)) return true;
+	return false;
+}
+//#endregion
+//#region helpers/license/isKnown.ts
+/**
+* This file is part of helpers4.
+* Copyright (C) 2025 baxyz
+* SPDX-License-Identifier: LGPL-3.0-or-later
+*/
+/**
+* Whether a raw license string resolves to at least one recognized family — `false` for an
+* empty string, a purely non-informative claim (`"custom"`, `"unknown"`, `"LicenseRef-EULA"`,
+* ...), or a compound expression where every token is non-informative.
+* @param raw - The raw license string to check
+* @returns `true` if at least one token in `raw` resolves to a real family
+* @example
+* isKnown('GPL-3.0-or-later')
+* // => true
+* @example
+* isKnown('custom:Acme End User License')
+* // => false
+* @since next
+*/
+function isKnown(raw) {
+	for (const family of families(raw)) if (family !== "unknown") return true;
+	return false;
+}
+//#endregion
+export { agree, families, isKnown };
+
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../helpers/license/_unknownFamily.ts","../../../helpers/license/families.ts","../../../helpers/license/agree.ts","../../../helpers/license/isKnown.ts"],"sourcesContent":["/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Sentinel family for a license token that carries no comparable content — `custom`, a bare\n * vendor name inside `custom:<...>`/`LicenseRef-<...>`, or an explicit \"we don't know\". Two\n * unknown tokens are never treated as either agreeing or conflicting with each other, since\n * neither is a real claim to compare against the other.\n *\n * Not exported from the package — `families()`, `agree()` and `isKnown()` already fully\n * encapsulate this concept; a consumer never needs the sentinel's actual value.\n * @ignore\n */\nexport const UNKNOWN_FAMILY = 'unknown';\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\nimport { UNKNOWN_FAMILY } from './_unknownFamily';\n\n// Longest/most specific alias keys first within a family so a substring match never lets a\n// shorter, less specific alias shadow a longer one that also matches the same input.\nconst FAMILY_ALIASES: Record<string, readonly string[]> = {\n  mit: ['mit-0', 'mit'],\n  gpl: [\n    'gpl-3.0-or-later', 'gpl-3.0-only', 'gpl-2.0-or-later', 'gpl-2.0-only',\n    'gpl-1.0-or-later', 'gpl-3.0+', 'gpl-2.0+', 'gpl-3.0', 'gpl-2.0',\n    'gplv3', 'gplv2', 'gpl3+', 'gpl3', 'gpl2', 'gpl-3', 'gpl-2', 'gpl',\n  ],\n  lgpl: [\n    'lgpl-3.0-or-later', 'lgpl-3.0-only', 'lgpl-2.1-or-later', 'lgpl-2.1-only',\n    'lgpl-2.0-or-later', 'lgpl-2.0-only', 'lgpl-3.0+', 'lgpl-2.1+', 'lgpl-3.0', 'lgpl-2.1',\n    'lgplv3', 'lgplv2.1', 'lgpl3', 'lgpl2.1', 'lgpl2', 'lgpl',\n  ],\n  agpl: ['agpl-3.0-or-later', 'agpl-3.0-only', 'agpl-3.0', 'agplv3', 'agpl3', 'agpl'],\n  bsd: [\n    'bsd-3-clause', 'bsd-2-clause', '0bsd', 'bsd3', 'bsd 3-clause',\n    'bsd 2-clause', 'bsd-3', 'bsd',\n  ],\n  apache: ['apache-2.0', 'apache license 2.0', 'apache license, version 2.0', 'apache2', 'apache 2.0', 'apache'],\n  mpl: ['mpl-2.0', 'mpl2', 'mpl'],\n  artistic: ['artistic-2.0', 'artistic2.0', 'perlartistic', 'artistic'],\n  isc: ['isc'],\n  unlicense: ['unlicense'],\n  zlib: ['zlib'],\n  wtfpl: ['wtfpl'],\n  php: ['php'],\n  epl: ['epl'],\n  cc: ['cc0-1.0', 'cc0', 'cc-by-sa-4.0', 'cc-by-nc-sa-4.0', 'cc-by-sa', 'ccpl'],\n  'public-domain': ['public domain'],\n  boost: ['bsl-1.0', 'boost'],\n  eupl: ['eupl-1.2', 'eupl'],\n  postgresql: ['postgresql'],\n  psf: ['psf-2.0', 'psf'],\n  gfdl: ['gfdl-1.3', 'gfdl'],\n  sspl: ['sspl-1.0', 'sspl'],\n  busl: ['busl-1.1', 'busl'],\n};\n\n// Non-informative tokens — a real license claim was made, but it carries no comparable content\n// (\"custom\", a bare vendor name inside `custom:<...>`/`LicenseRef-<...>`, or an explicit \"we\n// don't know\"). Checked first, before the alias table, so e.g. \"custom:MIT\" reads as\n// UNKNOWN_FAMILY rather than incorrectly matching MIT's alias substring — a `custom:<...>`\n// convention names the *vendor's own license text*, not necessarily the SPDX license the name\n// resembles.\nconst UNKNOWN_PATTERNS = [/^custom\\b/, /^licenseref-/, /unknown/, /^none$/, /^various$/, /^unknow$/];\n\nfunction matchAlias(normalized: string): string | undefined {\n  for (const [family, aliases] of Object.entries(FAMILY_ALIASES)) {\n    if (aliases.includes(normalized)) return family;\n  }\n  return undefined;\n}\n\n// Splits an SPDX-ish compound expression (\"GPL-3.0+ AND LGPL-3.0+\", or a lowercase \"GPL-2.0+ and\n// GFDL-1.3\") into its individual license tokens. `WITH` exceptions (\"Apache-2.0 WITH\n// LLVM-exception\") are dropped entirely — the exception clause never itself resembles a distinct\n// license family, so it would otherwise either land in UNKNOWN_FAMILY for no reason or dilute the\n// comparison with a token that isn't really a separate license claim.\nfunction splitTokens(raw: string): string[] {\n  return raw\n    .split(/\\s+(?:and|or)\\s+/i)\n    .map((token) => token.split(/\\s+with\\s+/i)[0].trim())\n    .filter((token) => token.length > 0);\n}\n\n/**\n * Groups a raw, possibly compound license string into its coarse family set — e.g.\n * `\"GPL-3.0-or-later AND LGPL-3.0-or-later\"` yields `{\"gpl\", \"lgpl\"}`. Two sources reporting the\n * same real license under different notation (`\"GPL3\"` vs `\"GPL-3.0-or-later\"`, `\"GPL\"` vs\n * `\"GPL2\"`) yield the same family, so they read as agreeing rather than conflicting.\n *\n * Proprietary/custom/unknown tokens all collapse to a single shared unknown-family sentinel\n * rather than each becoming their own one-off family, so a batch of otherwise-identical\n * `\"custom:<vendor>\"` strings don't look like dozens of distinct disagreeing licenses. Use\n * {@link isKnown} to check whether any real (non-sentinel) family was found.\n * @param raw - A raw license string, single (`\"MIT\"`) or compound (`\"GPL-3.0+ AND LGPL-3.0+\"`)\n * @returns The set of families found; empty only when `raw` has no tokens at all (e.g. an empty string)\n * @example\n * families('GPL3')\n * // => Set(1) { 'gpl' }\n * @example\n * families('GPL-3.0-or-later AND LGPL-3.0-or-later')\n * // => Set(2) { 'gpl', 'lgpl' }\n * @example\n * families('custom:Acme End User License')\n * // => Set(1) { 'unknown' }\n * @since next\n */\nexport function families(raw: string): Set<string> {\n  const result = new Set<string>();\n  for (const token of splitTokens(raw)) {\n    const normalized = token.toLowerCase();\n    if (UNKNOWN_PATTERNS.some((pattern) => pattern.test(normalized))) {\n      result.add(UNKNOWN_FAMILY);\n      continue;\n    }\n    result.add(matchAlias(normalized) ?? UNKNOWN_FAMILY);\n  }\n  return result;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\nimport { UNKNOWN_FAMILY } from './_unknownFamily';\nimport { families } from './families';\n\n/**\n * Whether two raw license strings agree closely enough to count as \"no real conflict\" — true\n * when their family sets share at least one real (known) family, or when either side is entirely\n * unknown (e.g. `\"custom\"`/`\"unknown\"`) — a vague claim is never itself evidence of disagreement.\n * Only two *different*, both-known family sets (e.g. `bsd` vs `apache`) count as a real conflict.\n * @param a - The first raw license string\n * @param b - The second raw license string\n * @returns `true` when the two strings can be treated as the same license (or too vague to tell), `false` on a real family conflict\n * @example\n * agree('GPL3', 'GPL-3.0-or-later')\n * // => true\n * @example\n * agree('BSD-2-Clause', 'Apache-2.0')\n * // => false\n * @example\n * agree('custom', 'MIT')\n * // => true (a vague claim is never itself a conflict)\n * @since next\n */\nexport function agree(a: string, b: string): boolean {\n  const knownA = new Set([...families(a)].filter((f) => f !== UNKNOWN_FAMILY));\n  const knownB = new Set([...families(b)].filter((f) => f !== UNKNOWN_FAMILY));\n\n  if (knownA.size === 0 || knownB.size === 0) return true;\n  for (const family of knownA) if (knownB.has(family)) return true;\n  return false;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\nimport { UNKNOWN_FAMILY } from './_unknownFamily';\nimport { families } from './families';\n\n/**\n * Whether a raw license string resolves to at least one recognized family — `false` for an\n * empty string, a purely non-informative claim (`\"custom\"`, `\"unknown\"`, `\"LicenseRef-EULA\"`,\n * ...), or a compound expression where every token is non-informative.\n * @param raw - The raw license string to check\n * @returns `true` if at least one token in `raw` resolves to a real family\n * @example\n * isKnown('GPL-3.0-or-later')\n * // => true\n * @example\n * isKnown('custom:Acme End User License')\n * // => false\n * @since next\n */\nexport function isKnown(raw: string): boolean {\n  for (const family of families(raw)) {\n    if (family !== UNKNOWN_FAMILY) return true;\n  }\n  return false;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAgBA,IAAa,iBAAiB;;;;;;;;ACN9B,IAAM,iBAAoD;CACxD,KAAK,CAAC,SAAS,KAAK;CACpB,KAAK;EACH;EAAoB;EAAgB;EAAoB;EACxD;EAAoB;EAAY;EAAY;EAAW;EACvD;EAAS;EAAS;EAAS;EAAQ;EAAQ;EAAS;EAAS;CAC/D;CACA,MAAM;EACJ;EAAqB;EAAiB;EAAqB;EAC3D;EAAqB;EAAiB;EAAa;EAAa;EAAY;EAC5E;EAAU;EAAY;EAAS;EAAW;EAAS;CACrD;CACA,MAAM;EAAC;EAAqB;EAAiB;EAAY;EAAU;EAAS;CAAM;CAClF,KAAK;EACH;EAAgB;EAAgB;EAAQ;EAAQ;EAChD;EAAgB;EAAS;CAC3B;CACA,QAAQ;EAAC;EAAc;EAAsB;EAA+B;EAAW;EAAc;CAAQ;CAC7G,KAAK;EAAC;EAAW;EAAQ;CAAK;CAC9B,UAAU;EAAC;EAAgB;EAAe;EAAgB;CAAU;CACpE,KAAK,CAAC,KAAK;CACX,WAAW,CAAC,WAAW;CACvB,MAAM,CAAC,MAAM;CACb,OAAO,CAAC,OAAO;CACf,KAAK,CAAC,KAAK;CACX,KAAK,CAAC,KAAK;CACX,IAAI;EAAC;EAAW;EAAO;EAAgB;EAAmB;EAAY;CAAM;CAC5E,iBAAiB,CAAC,eAAe;CACjC,OAAO,CAAC,WAAW,OAAO;CAC1B,MAAM,CAAC,YAAY,MAAM;CACzB,YAAY,CAAC,YAAY;CACzB,KAAK,CAAC,WAAW,KAAK;CACtB,MAAM,CAAC,YAAY,MAAM;CACzB,MAAM,CAAC,YAAY,MAAM;CACzB,MAAM,CAAC,YAAY,MAAM;AAC3B;AAQA,IAAM,mBAAmB;CAAC;CAAa;CAAgB;CAAW;CAAU;CAAa;AAAU;AAEnG,SAAS,WAAW,YAAwC;CAC1D,KAAK,MAAM,CAAC,QAAQ,YAAY,OAAO,QAAQ,cAAc,GAC3D,IAAI,QAAQ,SAAS,UAAU,GAAG,OAAO;AAG7C;AAOA,SAAS,YAAY,KAAuB;CAC1C,OAAO,IACJ,MAAM,mBAAmB,CAAC,CAC1B,KAAK,UAAU,MAAM,MAAM,aAAa,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CACpD,QAAQ,UAAU,MAAM,SAAS,CAAC;AACvC;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,SAAgB,SAAS,KAA0B;CACjD,MAAM,yBAAS,IAAI,IAAY;CAC/B,KAAK,MAAM,SAAS,YAAY,GAAG,GAAG;EACpC,MAAM,aAAa,MAAM,YAAY;EACrC,IAAI,iBAAiB,MAAM,YAAY,QAAQ,KAAK,UAAU,CAAC,GAAG;GAChE,OAAO,IAAI,cAAc;GACzB;EACF;EACA,OAAO,IAAI,WAAW,UAAU,KAAA,SAAmB;CACrD;CACA,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;;;;AChFA,SAAgB,MAAM,GAAW,GAAoB;CACnD,MAAM,SAAS,IAAI,IAAI,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,QAAQ,MAAM,MAAM,cAAc,CAAC;CAC3E,MAAM,SAAS,IAAI,IAAI,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,QAAQ,MAAM,MAAM,cAAc,CAAC;CAE3E,IAAI,OAAO,SAAS,KAAK,OAAO,SAAS,GAAG,OAAO;CACnD,KAAK,MAAM,UAAU,QAAQ,IAAI,OAAO,IAAI,MAAM,GAAG,OAAO;CAC5D,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;ACZA,SAAgB,QAAQ,KAAsB;CAC5C,KAAK,MAAM,UAAU,SAAS,GAAG,GAC/B,IAAI,WAAA,WAA2B,OAAO;CAExC,OAAO;AACT"}

package/meta/api.json

@@ -0,0 +1,129 @@
+{
+  "category": "license",
+  "version": "3.1.1",
+  "functions": [
+    {
+      "name": "agree",
+      "kind": "function",
+      "description": "Whether two raw license strings agree closely enough to count as \"no real conflict\" — true\nwhen their family sets share at least one real (known) family, or when either side is entirely\nunknown (e.g. `\"custom\"`/`\"unknown\"`) — a vague claim is never itself evidence of disagreement.\nOnly two *different*, both-known family sets (e.g. `bsd` vs `apache`) count as a real conflict.",
+      "since": "next",
+      "signatures": [
+        {
+          "signature": "agree(a: string, b: string): boolean",
+          "description": "Whether two raw license strings agree closely enough to count as \"no real conflict\" — true\nwhen their family sets share at least one real (known) family, or when either side is entirely\nunknown (e.g. `\"custom\"`/`\"unknown\"`) — a vague claim is never itself evidence of disagreement.\nOnly two *different*, both-known family sets (e.g. `bsd` vs `apache`) count as a real conflict.",
+          "params": [
+            {
+              "name": "a",
+              "type": "string",
+              "description": "The first raw license string"
+            },
+            {
+              "name": "b",
+              "type": "string",
+              "description": "The second raw license string"
+            }
+          ],
+          "returns": {
+            "type": "boolean",
+            "description": "`true` when the two strings can be treated as the same license (or too vague to tell), `false` on a real family conflict"
+          }
+        }
+      ],
+      "examples": [
+        {
+          "title": "Reconcile notation drift across sources",
+          "description": "Two package sources reporting the same real license under different notation.",
+          "code": "agree('GPL3', 'GPL-3.0-or-later')\n// => true"
+        },
+        {
+          "title": "Flag a real license conflict",
+          "description": "Two sources genuinely disagreeing on the license family — a real data-quality signal.",
+          "code": "agree('BSD-2-Clause', 'Apache-2.0')\n// => false"
+        },
+        {
+          "title": "A vague claim is never itself a conflict",
+          "description": "When either side is non-informative (\"custom\", \"unknown\", ...), there is nothing real to disagree with.",
+          "code": "agree('custom', 'MIT')\n// => true"
+        }
+      ],
+      "sourceFile": "agree.ts"
+    },
+    {
+      "name": "families",
+      "kind": "function",
+      "description": "Groups a raw, possibly compound license string into its coarse family set — e.g.\n`\"GPL-3.0-or-later AND LGPL-3.0-or-later\"` yields `{\"gpl\", \"lgpl\"}`. Two sources reporting the\nsame real license under different notation (`\"GPL3\"` vs `\"GPL-3.0-or-later\"`, `\"GPL\"` vs\n`\"GPL2\"`) yield the same family, so they read as agreeing rather than conflicting.\n\nProprietary/custom/unknown tokens all collapse to a single shared unknown-family sentinel\nrather than each becoming their own one-off family, so a batch of otherwise-identical\n`\"custom:<vendor>\"` strings don't look like dozens of distinct disagreeing licenses. Use\nisKnown to check whether any real (non-sentinel) family was found.",
+      "since": "next",
+      "signatures": [
+        {
+          "signature": "families(raw: string): Set<string>",
+          "description": "Groups a raw, possibly compound license string into its coarse family set — e.g.\n`\"GPL-3.0-or-later AND LGPL-3.0-or-later\"` yields `{\"gpl\", \"lgpl\"}`. Two sources reporting the\nsame real license under different notation (`\"GPL3\"` vs `\"GPL-3.0-or-later\"`, `\"GPL\"` vs\n`\"GPL2\"`) yield the same family, so they read as agreeing rather than conflicting.\n\nProprietary/custom/unknown tokens all collapse to a single shared unknown-family sentinel\nrather than each becoming their own one-off family, so a batch of otherwise-identical\n`\"custom:<vendor>\"` strings don't look like dozens of distinct disagreeing licenses. Use\nisKnown to check whether any real (non-sentinel) family was found.",
+          "params": [
+            {
+              "name": "raw",
+              "type": "string",
+              "description": "A raw license string, single (`\"MIT\"`) or compound (`\"GPL-3.0+ AND LGPL-3.0+\"`)"
+            }
+          ],
+          "returns": {
+            "type": "Set<string>",
+            "description": "The set of families found; empty only when `raw` has no tokens at all (e.g. an empty string)"
+          }
+        }
+      ],
+      "examples": [
+        {
+          "title": "Collapse notation drift into one family",
+          "description": "\"GPL3\" and \"GPL-3.0-or-later\" are the same real license, reported differently by two sources.",
+          "code": "families('GPL3')\n// => Set(1) { 'gpl' }"
+        },
+        {
+          "title": "Split a compound SPDX expression",
+          "description": "\"AND\"/\"OR\" (any case) separate multiple license claims; \"WITH\" exception clauses are dropped.",
+          "code": "families('GPL-3.0-or-later AND LGPL-3.0-or-later')\n// => Set(2) { 'gpl', 'lgpl' }"
+        },
+        {
+          "title": "Non-informative claims collapse to one shared \"unknown\" family",
+          "description": "A batch of different custom:<vendor> strings all read the same way — none of them is real evidence either way.",
+          "code": "families('custom:Acme End User License')\n// => Set(1) { 'unknown' }"
+        }
+      ],
+      "sourceFile": "families.ts"
+    },
+    {
+      "name": "isKnown",
+      "kind": "function",
+      "description": "Whether a raw license string resolves to at least one recognized family — `false` for an\nempty string, a purely non-informative claim (`\"custom\"`, `\"unknown\"`, `\"LicenseRef-EULA\"`,\n...), or a compound expression where every token is non-informative.",
+      "since": "next",
+      "signatures": [
+        {
+          "signature": "isKnown(raw: string): boolean",
+          "description": "Whether a raw license string resolves to at least one recognized family — `false` for an\nempty string, a purely non-informative claim (`\"custom\"`, `\"unknown\"`, `\"LicenseRef-EULA\"`,\n...), or a compound expression where every token is non-informative.",
+          "params": [
+            {
+              "name": "raw",
+              "type": "string",
+              "description": "The raw license string to check"
+            }
+          ],
+          "returns": {
+            "type": "boolean",
+            "description": "`true` if at least one token in `raw` resolves to a real family"
+          }
+        }
+      ],
+      "examples": [
+        {
+          "title": "Filter out entries with no real license information",
+          "description": "Handy for flagging catalog entries whose license field is not actually usable.",
+          "code": "['MIT', 'custom:Acme EULA', 'unknown'].filter(isKnown)\n// => ['MIT']"
+        },
+        {
+          "title": "A vendor-specific EULA is not a recognized family",
+          "description": "\"custom:<vendor>\" names the vendor's own license text, not a known open-source family.",
+          "code": "isKnown('custom:Acme End User License')\n// => false"
+        }
+      ],
+      "sourceFile": "isKnown.ts"
+    }
+  ]
+}

package/meta/category.json

@@ -0,0 +1,6 @@
+{
+  "category": "license",
+  "label": "License",
+  "smallDescription": "License string classification and comparison",
+  "description": "Groups real-world, SPDX-ish license strings into coarse families (MIT, GPL, LGPL, BSD, Apache, ...) so notation drift across sources (\"GPL3\" vs \"GPL-3.0-or-later\") doesn't read as a conflict. Not an SPDX validator or a full SPDX-expression parser, and never used to pick or display a license — only to compare two reported strings for \"same family\"."
+}

package/meta/examples.json

@@ -0,0 +1,60 @@
+{
+  "category": "license",
+  "functions": [
+    {
+      "name": "agree",
+      "examples": [
+        {
+          "title": "Reconcile notation drift across sources",
+          "description": "Two package sources reporting the same real license under different notation.",
+          "code": "agree('GPL3', 'GPL-3.0-or-later')\n// => true"
+        },
+        {
+          "title": "Flag a real license conflict",
+          "description": "Two sources genuinely disagreeing on the license family — a real data-quality signal.",
+          "code": "agree('BSD-2-Clause', 'Apache-2.0')\n// => false"
+        },
+        {
+          "title": "A vague claim is never itself a conflict",
+          "description": "When either side is non-informative (\"custom\", \"unknown\", ...), there is nothing real to disagree with.",
+          "code": "agree('custom', 'MIT')\n// => true"
+        }
+      ]
+    },
+    {
+      "name": "families",
+      "examples": [
+        {
+          "title": "Collapse notation drift into one family",
+          "description": "\"GPL3\" and \"GPL-3.0-or-later\" are the same real license, reported differently by two sources.",
+          "code": "families('GPL3')\n// => Set(1) { 'gpl' }"
+        },
+        {
+          "title": "Split a compound SPDX expression",
+          "description": "\"AND\"/\"OR\" (any case) separate multiple license claims; \"WITH\" exception clauses are dropped.",
+          "code": "families('GPL-3.0-or-later AND LGPL-3.0-or-later')\n// => Set(2) { 'gpl', 'lgpl' }"
+        },
+        {
+          "title": "Non-informative claims collapse to one shared \"unknown\" family",
+          "description": "A batch of different custom:<vendor> strings all read the same way — none of them is real evidence either way.",
+          "code": "families('custom:Acme End User License')\n// => Set(1) { 'unknown' }"
+        }
+      ]
+    },
+    {
+      "name": "isKnown",
+      "examples": [
+        {
+          "title": "Filter out entries with no real license information",
+          "description": "Handy for flagging catalog entries whose license field is not actually usable.",
+          "code": "['MIT', 'custom:Acme EULA', 'unknown'].filter(isKnown)\n// => ['MIT']"
+        },
+        {
+          "title": "A vendor-specific EULA is not a recognized family",
+          "description": "\"custom:<vendor>\" names the vendor's own license text, not a known open-source family.",
+          "code": "isKnown('custom:Acme End User License')\n// => false"
+        }
+      ]
+    }
+  ]
+}

package/meta/licenses.json

@@ -0,0 +1,4 @@
+{
+  "category": "license",
+  "dependencies": []
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@helpers4/license",
+  "version": "3.1.1-alpha.0",
+  "description": "A set of helpers in TS/JS, compatible with tree-shaking, for license.",
+  "author": "baxyz <craft@baxyz.dev>",
+  "license": "LGPL-3.0",
+  "homepage": "https://helpers4.dev/typescript/categories/license/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/helpers4/typescript.git"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.js"
+    },
+    "./meta/api.json": "./meta/api.json",
+    "./meta/examples.json": "./meta/examples.json",
+    "./meta/licenses.json": "./meta/licenses.json",
+    "./llms.txt": "./llms.txt",
+    "./package.json": "./package.json"
+  },
+  "keywords": [
+    "helpers",
+    "license",
+    "agree",
+    "families",
+    "isKnown"
+  ],
+  "files": [
+    "lib/index.js",
+    "lib/index.d.ts",
+    "lib/index.js.map",
+    "meta/",
+    "llms.txt",
+    "LICENSE.md",
+    "package.json",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=26.0.0"
+  }
+}