@diister/quick-permission 0.9.0-beta.5

package/permission.ts

@@ -0,0 +1,88 @@
+/**
+ * Builder de permission pour resource-pipe.
+ *
+ * API en deux étapes (`permission(opts).rules([])`), même justification que
+ * `library/permission.ts` (cf. RFC declarative §"Décision two-call").
+ *
+ * Différence majeure vs l'API declarative actuelle : pas de slot `fetch` au
+ * niveau permission. Les fetches sont déclarés au niveau des `Resource`s
+ * que les rules consomment via `needs`.
+ */
+
+import type { AnyTarget, Grant, Permission, Rule } from "./types.ts";
+
+export type PermissionConfig<TMeta> = {
+  readonly metadata?: TMeta;
+  readonly target: AnyTarget;
+};
+
+export type PermissionBuilder<TMeta> = {
+  rules(rules: readonly Rule[]): Permission<TMeta>;
+};
+
+/**
+ * Déclare une permission "feuille" (vérifiable directement via `can()`).
+ *
+ * @example
+ *   "users.read": permission({
+ *     metadata: { description: "Lire un user" },
+ *     target: target.required("user"),
+ *   }).rules([
+ *     userOf.match(),
+ *     userOf.filter(),
+ *   ]),
+ */
+export function permission<TMeta = unknown>(
+  config: PermissionConfig<TMeta>,
+): PermissionBuilder<TMeta> {
+  return {
+    rules(rules) {
+      return {
+        metadata: config.metadata,
+        target: config.target,
+        rules,
+      };
+    },
+  };
+}
+
+export type IntermediateConfig<TMeta> = {
+  readonly metadata?: TMeta;
+  readonly target: AnyTarget;
+  /** Expand un grant sur cette intermediate en N grants sur les enfants. */
+  readonly expandsTo: (grant: Grant) => readonly Grant[];
+};
+
+export type IntermediateBuilder<TMeta> = {
+  /** Optionnellement attacher des rules au niveau intermediate. */
+  rules(rules: readonly Rule[]): Permission<TMeta>;
+};
+
+/**
+ * Déclare une permission "intermediate" (macro qui s'expand en grants
+ * enfants au moment du check).
+ *
+ * @example
+ *   "users.manage": intermediate({
+ *     target: target.required("user"),
+ *     expandsTo: (grant) => [
+ *       { ...grant, key: "users.read" },
+ *       { ...grant, key: "users.update" },
+ *       { ...grant, key: "users.delete" },
+ *     ],
+ *   }).rules([]),
+ */
+export function intermediate<TMeta = unknown>(
+  config: IntermediateConfig<TMeta>,
+): IntermediateBuilder<TMeta> {
+  return {
+    rules(rules) {
+      return {
+        metadata: config.metadata,
+        target: config.target,
+        rules,
+        expandsTo: config.expandsTo,
+      };
+    },
+  };
+}

package/resource.ts

@@ -0,0 +1,352 @@
+/**
+ * `Resource` : source de donnée fetchable, dédupliquée par contexte.
+ *
+ * Une Resource est conçue pour être déclarée une fois dans son domaine
+ * (`userOf`, `expositionInfoOf`, etc.) et réutilisée entre permissions.
+ * Le moteur dédup les fetches au sein d'un context via `(id, dedupKey)`.
+ *
+ * Les méthodes `match`/`filter`/`includes`/`require*` sont du sucre :
+ * elles produisent des Rule via `defineRule`, avec la resource comme need.
+ *
+ * ─── Capability-mode contract ────────────────────────────────────────────
+ * A request target containing a wildcard (`"*"` or `"xxx:*"`) is a capability
+ * query — "can the subject act on ANY resource of this shape?". The engine
+ * skips resource fetches in this mode (no concrete resource to fetch). Each
+ * rule must declare what it does when its data is unavailable:
+ *
+ *   match           : silent-pass (cannot verify spec against absent data),
+ *                     but exposes the spec as a constraint for DB pushdown.
+ *   filter          : silent-pass — no projection happens; `output.data`
+ *                     stays undefined.
+ *   includes        : deny — membership cannot be checked without the resource.
+ *   requireTruthy   : deny — no value to test for truthiness.
+ *   requireOwner    : deny — no owner field to compare.
+ *   requireMembership: deny — no membership list to scan.
+ *   requireCustom   : deny — predicate cannot run without `data`.
+ *
+ * Pure rules (no `needs`) like `matchPath` and `requireSelf` are unaffected:
+ * they read `ctx.target` / `ctx.subject` only.
+ */
+
+import type { FetchCtx, Grant, Resource, Rule } from "./types.ts";
+import { deepEqual, defineRule } from "./rules.ts";
+import { evaluateSpec, validateSpec } from "./mongo-query.ts";
+
+class ResourceImpl<T> implements Resource<T> {
+  // Spelled out rather than declared as constructor parameter properties:
+  // those are the one TypeScript-only construct Node's type stripping cannot
+  // erase, so they made this file unloadable as raw `.ts` there.
+  public readonly id: string;
+  public readonly fetcher: (ctx: FetchCtx) => T | Promise<T>;
+  public readonly activator?: (grant: Grant) => boolean;
+  public readonly dedupKey?: (ctx: FetchCtx) => string;
+
+  constructor(
+    id: string,
+    fetcher: (ctx: FetchCtx) => T | Promise<T>,
+    activator?: (grant: Grant) => boolean,
+    dedupKey?: (ctx: FetchCtx) => string,
+  ) {
+    this.id = id;
+    this.fetcher = fetcher;
+    this.activator = activator;
+    this.dedupKey = dedupKey;
+  }
+
+  isActiveFor(grant: Grant): boolean {
+    return this.activator ? this.activator(grant) : true;
+  }
+
+  computeDedupKey(ctx: FetchCtx): string {
+    if (this.dedupKey) return `${this.id}::${this.dedupKey(ctx)}`;
+    // Default safe : hash de tous les inputs (subject + target + grant.with).
+    // Jamais de fausse dedup, mais peut être sous-optimal — d'où l'incitation
+    // à fournir un dedupKey explicite quand on connaît les params pertinents.
+    return `${this.id}::${ctx.subject.id}::${JSON.stringify(
+      ctx.target,
+    )}::${JSON.stringify(ctx.grant.with ?? {})}`;
+  }
+
+  cacheKeyForTarget(target: readonly unknown[]): string {
+    // Build a synthetic FetchCtx (target-only). For `preseed()`, the
+    // caller knows the target shape but neither subject nor grant. We
+    // assume `dedupKey` only reads `target` (the recommended pattern)
+    // — if a resource's dedupKey reaches into subject/grant, `preseed`
+    // will produce a key that won't match runtime `computeDedupKey`,
+    // and the cache will silently miss. Document this limit.
+    const syntheticCtx: FetchCtx = {
+      subject: { id: "__preseed__" },
+      target,
+      grant: { key: "__preseed__" },
+      capability: false,
+    };
+    if (this.dedupKey) return `${this.id}::${this.dedupKey(syntheticCtx)}`;
+    return `${this.id}::${syntheticCtx.subject.id}::${JSON.stringify(
+      target,
+    )}::${JSON.stringify({})}`;
+  }
+
+  // ─── Méthodes de sucre — toutes produites via defineRule ─────────────
+
+  match(extractor?: (data: T) => unknown): Rule {
+    const id = this.id;
+    const project = extractor ?? ((d: T) => d);
+    return defineRule({
+      kind: "match",
+      needs: [this] as const,
+      check: ([data], _payload, ctx) => {
+        const spec = ctx.grant.with?.[id];
+        if (spec === undefined) return { ok: true };
+
+        if (typeof spec === "object" && spec !== null) {
+          validateSpec(spec);
+        }
+
+        // Cap-mode without fetched data: silent-pass + expose spec as
+        // constraint (legacy behaviour — pushdown to DB for resources
+        // that ARE the listed collection).
+        //
+        // When `data` is present in cap-mode it means the resource was
+        // fetched anyway (because `Resource.targetSegment` was concrete
+        // — see system.ts collection logic). In that case we evaluate
+        // the spec like in concrete mode and DON'T emit a constraint :
+        // the check is fully resolved and the (potentially inappropriate)
+        // constraint would pollute the listed collection's `find()`.
+        if (ctx.capability && data === undefined) {
+          if (
+            typeof spec === "object" &&
+            spec !== null &&
+            !Array.isArray(spec)
+          ) {
+            return { ok: true, constraint: spec as Record<string, unknown> };
+          }
+          return { ok: true };
+        }
+
+        const actual = project(data as T);
+        if (spec === null || typeof spec !== "object" || Array.isArray(spec)) {
+          return deepEqual(spec, actual)
+            ? { ok: true }
+            : { ok: false, reason: `match[${id}] mismatch` };
+        }
+        const passes = evaluateSpec(spec as Record<string, unknown>, actual);
+        if (!passes) {
+          return { ok: false, reason: `match[${id}] mismatch` };
+        }
+        // Concrete mode (or cap-mode w/ fetched data): the rule resolved
+        // fully via `evaluateSpec`. Emitting `constraint: spec` here is
+        // safe ONLY when the resource id matches the listed collection
+        // — for foreign resources it would push a wrong filter. Conservative
+        // choice : emit only in legacy concrete mode (preserves existing
+        // listWithPermission semantics for self-referencing resources like
+        // `users.read` + `userOf.match`).
+        if (!ctx.capability) {
+          return { ok: true, constraint: spec as Record<string, unknown> };
+        }
+        return { ok: true };
+      },
+    });
+  }
+
+  filter(extractor?: (data: T) => unknown): Rule {
+    const project = extractor ?? ((d: T) => d);
+    return defineRule({
+      kind: "filter",
+      needs: [this] as const,
+      check: ([data], _payload, ctx) => {
+        if (ctx.capability) return { ok: true };
+        const sub = project(data as T);
+        const filter = ctx.grant.filter;
+        // No filter on this grant → expose `null` spec so the system can
+        // collapse the cross-grant union to "all fields".
+        if (
+          !filter ||
+          sub === null ||
+          typeof sub !== "object" ||
+          Array.isArray(sub)
+        ) {
+          return { ok: true, data: sub, filter: { source: sub, spec: null } };
+        }
+        const out: Record<string, unknown> = {};
+        for (const [k, v] of Object.entries(filter)) {
+          if (v === true && k in (sub as Record<string, unknown>)) {
+            out[k] = (sub as Record<string, unknown>)[k];
+          }
+        }
+        return {
+          ok: true,
+          data: out,
+          filter: { source: sub, spec: filter },
+        };
+      },
+    });
+  }
+
+  includes(
+    grantField: string,
+    extractor: (data: T) => readonly unknown[],
+  ): Rule {
+    return defineRule({
+      kind: "includes",
+      needs: [this] as const,
+      // Lazy : skip si pas de spec dans le grant.
+      activeWhen: (grant) => grant.with?.[grantField] !== undefined,
+      describe: () => ({ grantField }),
+      check: ([data], _payload, ctx) => {
+        // Capability : ressource non fetchée, on ne peut pas vérifier
+        // l'inclusion concrète → deny.
+        if (ctx.capability) {
+          return {
+            ok: false,
+            reason: `includes[${grantField}] cannot be verified in capability query`,
+          };
+        }
+        const required = ctx.grant.with![grantField];
+        const list = extractor(data as T);
+        if (Array.isArray(required)) {
+          return required.some((r) => list.includes(r))
+            ? { ok: true }
+            : {
+                ok: false,
+                reason: `includes[${grantField}] none of ${JSON.stringify(
+                  required,
+                )} present`,
+              };
+        }
+        return list.includes(required)
+          ? { ok: true }
+          : {
+              ok: false,
+              reason: `includes[${grantField}] ${String(required)} absent`,
+            };
+      },
+    });
+  }
+
+  requireTruthy(): Rule {
+    const id = this.id;
+    return defineRule({
+      kind: "require-truthy",
+      needs: [this] as const,
+      check: ([data], _payload, ctx) => {
+        if (ctx.capability) {
+          return {
+            ok: false,
+            reason: `require-truthy[${id}] cannot be verified in capability query`,
+          };
+        }
+        return data
+          ? { ok: true }
+          : { ok: false, reason: `require-truthy[${id}] is falsy` };
+      },
+    });
+  }
+
+  requireOwner(
+    getter: (data: T) => string | undefined,
+    opts: { readonly flag: string },
+  ): Rule {
+    const id = this.id;
+    return defineRule({
+      kind: "require-owner",
+      needs: [this] as const,
+      flag: opts.flag,
+      check: ([data], _payload, ctx) => {
+        if (ctx.capability) {
+          return {
+            ok: false,
+            reason: `require-owner[${id}] cannot be verified in capability query`,
+          };
+        }
+        return getter(data as T) === ctx.subject.id
+          ? { ok: true }
+          : {
+              ok: false,
+              reason: `not owner of ${id} (flag: ${opts.flag})`,
+            };
+      },
+    });
+  }
+
+  requireMembership(
+    getter: (data: T) => readonly string[],
+    opts: { readonly flag: string },
+  ): Rule {
+    const id = this.id;
+    return defineRule({
+      kind: "require-membership",
+      needs: [this] as const,
+      flag: opts.flag,
+      check: ([data], _payload, ctx) => {
+        if (ctx.capability) {
+          return {
+            ok: false,
+            reason: `require-membership[${id}] cannot be verified in capability query`,
+          };
+        }
+        const list = getter(data as T);
+        return list.includes(ctx.subject.id)
+          ? { ok: true }
+          : {
+              ok: false,
+              reason: `subject not member of ${id} (flag: ${opts.flag})`,
+            };
+      },
+    });
+  }
+
+  requireCustom(
+    predicate: (data: T, ctx: FetchCtx) => boolean,
+    opts: {
+      readonly flag: string;
+      readonly descriptor?: Readonly<Record<string, unknown>>;
+    },
+  ): Rule {
+    const id = this.id;
+    return defineRule({
+      kind: "require-custom",
+      needs: [this] as const,
+      flag: opts.flag,
+      describe: opts.descriptor ? () => opts.descriptor! : undefined,
+      check: ([data], _payload, ctx) => {
+        if (ctx.capability) {
+          return {
+            ok: false,
+            reason: `require-custom[${id}] cannot be verified in capability query`,
+          };
+        }
+        return predicate(data as T, ctx)
+          ? { ok: true }
+          : {
+              ok: false,
+              reason: `require-custom[${id}] denied (flag: ${opts.flag})`,
+            };
+      },
+    });
+  }
+}
+
+/**
+ * Crée une Resource. À utiliser une fois par entité de domaine, partagée
+ * entre toutes les permissions qui la consomment.
+ *
+ * @example
+ *   const userOf = resource({
+ *     id: "user",
+ *     fetch: ({ target }) => usersRepo.findById(target[0] as string),
+ *     dedupKey: ({ target }) => target[0] as string,
+ *   });
+ */
+export function resource<T>(opts: {
+  readonly id: string;
+  readonly fetch: (ctx: FetchCtx) => T | Promise<T>;
+  readonly activeWhen?: (grant: Grant) => boolean;
+  readonly dedupKey?: (ctx: FetchCtx) => string;
+}): Resource<T> {
+  return new ResourceImpl<T>(
+    opts.id,
+    opts.fetch,
+    opts.activeWhen,
+    opts.dedupKey,
+  );
+}

package/rules.ts

@@ -0,0 +1,241 @@
+/**
+ * `defineRule` — primitive unique de fabrication de rule.
+ *
+ * Toutes les rules de la lib (match, filter, includes, requireXxx) sont du
+ * sucre par-dessus cette fonction. Les devs en aval l'utilisent aussi pour
+ * écrire leurs rules métier réutilisables (cf. RFC §"Le rôle des devs").
+ */
+
+import type {
+  FetchCtx,
+  Grant,
+  Resource,
+  ResourcesData,
+  Rule,
+  RuleResult,
+} from "./types.ts";
+import { evaluateSpec, validateSpec } from "./mongo-query.ts";
+
+export type DefineRuleOpts<RS extends readonly Resource<unknown>[], P> = {
+  /** Identifiant de famille de rule (matrix UI). */
+  readonly kind: string;
+  /**
+   * Resources à fetcher avant le check. L'ordre détermine l'ordre du tuple
+   * passé à `check`. Tableau vide = rule pure (ex: requireSelf).
+   */
+  readonly needs?: RS;
+  /**
+   * Sucre opt-in : la rule est active ssi `grant.flags?.[flag] === true`.
+   * Mutuellement exclusif avec `activeWhen`.
+   */
+  readonly flag?: string;
+  /**
+   * Escape hatch d'activation. Si retourne false, la rule est skip et ses
+   * needs ne sont pas fetchées.
+   */
+  readonly activeWhen?: (grant: Grant) => boolean;
+  /**
+   * Métadonnées additionnelles fusionnées dans le `descriptor` (matrix UI).
+   * Ne doit pas inclure les champs gérés automatiquement (kind/source/sources/flag).
+   */
+  readonly describe?: () => Readonly<Record<string, unknown>>;
+  /**
+   * Logique d'évaluation. `data` est un tuple aligné sur `needs`. `payload`
+   * est un alias de `ctx.grant.payload` casté au type générique P.
+   * Retourne soit un boolean (true = ok, false = deny avec raison auto),
+   * soit un RuleResult complet pour propager `data` ou un message custom.
+   */
+  readonly check: (
+    data: ResourcesData<RS>,
+    payload: P,
+    ctx: FetchCtx,
+  ) => boolean | RuleResult;
+};
+
+/**
+ * Fabrique une rule à partir d'une définition déclarative.
+ */
+export function defineRule<
+  const RS extends readonly Resource<unknown>[],
+  P = unknown,
+>(opts: DefineRuleOpts<RS, P>): Rule {
+  if (opts.flag !== undefined && opts.activeWhen !== undefined) {
+    throw new Error(
+      `defineRule(${opts.kind}): cannot specify both 'flag' and 'activeWhen'`,
+    );
+  }
+
+  const needs = (opts.needs ?? []) as readonly Resource<unknown>[];
+  const flag = opts.flag;
+  const activeWhen =
+    flag !== undefined
+      ? (grant: Grant) => grant.flags?.[flag] === true
+      : opts.activeWhen;
+
+  const descriptor: Record<string, unknown> = { kind: opts.kind };
+  if (needs.length === 1) descriptor.source = needs[0].id;
+  if (needs.length > 1) descriptor.sources = needs.map((n) => n.id);
+  if (flag !== undefined) descriptor.flag = flag;
+  if (opts.describe) {
+    const extra = opts.describe();
+    for (const [k, v] of Object.entries(extra)) {
+      // Les champs auto ne peuvent pas être écrasés.
+      if (k === "kind" || k === "source" || k === "sources" || k === "flag") {
+        continue;
+      }
+      descriptor[k] = v;
+    }
+  }
+
+  return {
+    descriptor: descriptor as Rule["descriptor"],
+    needs,
+    activeWhen,
+    check: (data, ctx) => {
+      const payload = ctx.grant.payload as P;
+      const result = opts.check(data as ResourcesData<RS>, payload, ctx);
+      if (typeof result === "boolean") {
+        return result
+          ? { ok: true }
+          : { ok: false, reason: `${opts.kind} denied` };
+      }
+      return result;
+    },
+  };
+}
+
+/**
+ * Rule pure (pas de needs) : compare un segment du target à `subject.id`.
+ * Opt-in via flag.
+ *
+ * @example
+ *   "users.update": permission({...}).rules([
+ *     userOf.match(),
+ *     requireSelf({ flag: "selfOnly" }),
+ *   ]),
+ *
+ *   // Grant d'admin (no flag) → silent pass
+ *   { key: "users.update", target: ["user:*"] }
+ *   // Grant self-only (flag activé) → check target[0] === subject.id
+ *   { key: "users.update", target: ["user:*"], flags: { selfOnly: true } }
+ */
+/**
+ * Translates a grant's `target[segment]` to a Mongo `{[field]: value}`
+ * constraint, exposed via the rule's `constraint` for cross-grant OR
+ * aggregation and DB pushdown. Wildcard segments (`*` or `xxx:*`) emit
+ * no constraint (= no restriction).
+ *
+ * Common case for resources stored in MongoDB by `_id`:
+ *
+ *   matchPath()                          // {_id: target[0]}
+ *   matchPath({ field: "userId" })       // {userId: target[0]}
+ *   matchPath({ segment: 1 })            // {_id: target[1]}  (e.g., target.path)
+ */
+export function matchPath(
+  opts: { readonly field?: string; readonly segment?: number } = {},
+): Rule {
+  const field = opts.field ?? "_id";
+  const segment = opts.segment ?? 0;
+  return defineRule({
+    kind: "match-path",
+    needs: [] as const,
+    describe: () => ({ field, segment }),
+    check: (_data, _payload, ctx) => {
+      const target = ctx.grant.target;
+      if (!target || !Array.isArray(target)) return { ok: true };
+      const value = target[segment];
+      if (typeof value !== "string") return { ok: true };
+      if (value === "*" || value.endsWith("*")) return { ok: true };
+      return { ok: true, constraint: { [field]: value } };
+    },
+  });
+}
+
+/**
+ * Validates `ctx.input` against `grant.inputWith` (Mongo spec). Distinct
+ * slot from `grant.with` so payload-shaped specs don't collide with
+ * resource-shaped specs in the same grant.
+ *
+ * Per-grant:
+ *  - no `inputWith`     → ok (unconditional grant)
+ *  - `inputWith` + input → `evaluateSpec(inputWith, input)`
+ *  - `inputWith` + no input → deny (cannot verify)
+ *
+ * Cross-grant OR aggregation: a single unconditional grant lets every check
+ * through (broadest wins); a UI capability check with no input only passes
+ * if at least one unconditional grant exists.
+ *
+ * @example
+ *   "invitations.create": permission({
+ *     target: target.path("exposition", "expo_organization"),
+ *   }).rules([inputMatch()])
+ *
+ *   { key: "invitations.create",
+ *     target: [expoId, orgId],
+ *     inputWith: { flowId: "flow:abc" } }
+ *
+ *   await ctx.can("invitations.create", [expoId, orgId], { input: body })
+ */
+export function inputMatch(): Rule {
+  return defineRule({
+    kind: "input-match",
+    needs: [] as const,
+    check: (_data, _payload, ctx) => {
+      const spec = ctx.grant.inputWith;
+      if (spec === undefined || Object.keys(spec).length === 0) {
+        return { ok: true };
+      }
+      if (ctx.input === undefined) {
+        return { ok: false, reason: "input-match: input required" };
+      }
+      validateSpec(spec);
+      return evaluateSpec(spec as Record<string, unknown>, ctx.input)
+        ? { ok: true }
+        : { ok: false, reason: "input-match: mismatch" };
+    },
+  });
+}
+
+export function requireSelf(opts: {
+  readonly flag: string;
+  readonly segment?: number;
+}): Rule {
+  const segment = opts.segment ?? 0;
+  return defineRule({
+    kind: "require-self",
+    needs: [] as const,
+    flag: opts.flag,
+    describe: () => ({ segment }),
+    check: (_data, _payload, ctx) =>
+      ctx.target[segment] === ctx.subject.id
+        ? { ok: true }
+        : {
+            ok: false,
+            reason: `target[${segment}] is not self (flag: ${opts.flag})`,
+          },
+  });
+}
+
+// ─────────────────────────────────────────────────────────────────────────
+// Helpers internes (utilisés par les méthodes resource dans resource.ts)
+// ─────────────────────────────────────────────────────────────────────────
+
+export function deepEqual(a: unknown, b: unknown): boolean {
+  if (a === b) return true;
+  if (typeof a !== typeof b) return false;
+  if (a === null || b === null) return false;
+  if (typeof a !== "object") return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length === b.length && a.every((x, i) => deepEqual(x, b[i]));
+  }
+  const aKeys = Object.keys(a as object);
+  const bKeys = Object.keys(b as object);
+  if (aKeys.length !== bKeys.length) return false;
+  return aKeys.every((k) =>
+    deepEqual(
+      (a as Record<string, unknown>)[k],
+      (b as Record<string, unknown>)[k],
+    ),
+  );
+}

package/sift/MIT-LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2015 Craig Condon
+
+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.