@prismer/sdk 2.0.7 → 2.2.55

package/node_modules/@prismer/aip-sdk/dist/index.d.ts

@@ -0,0 +1,174 @@
+/**
+ * AIPIdentity — standalone DID identity class (no platform dependency)
+ */
+interface DIDDocument {
+    '@context': string[];
+    id: string;
+    controller: string;
+    verificationMethod: {
+        id: string;
+        type: string;
+        controller: string;
+        publicKeyMultibase: string;
+    }[];
+    authentication: string[];
+    assertionMethod: string[];
+    capabilityDelegation: string[];
+    capabilityInvocation: string[];
+    service?: {
+        id: string;
+        type: string;
+        serviceEndpoint: string;
+    }[];
+    'aip:capabilities'?: string[];
+    created: string;
+    updated: string;
+}
+interface SignedPayload {
+    senderDid: string;
+    signature: string;
+    payload: Uint8Array;
+}
+declare class AIPIdentity {
+    readonly did: string;
+    readonly publicKey: Uint8Array;
+    private readonly privateKey;
+    private constructor();
+    static create(): Promise<AIPIdentity>;
+    /**
+     * @deprecated Compatibility derivation for existing Prismer Cloud identities.
+     * New applications should create and persist a random identity with create().
+     * The deterministic output remains unchanged throughout the 2.x release line.
+     */
+    static fromApiKey(apiKey: string): Promise<AIPIdentity>;
+    static fromPrivateKey(key: Uint8Array): Promise<AIPIdentity>;
+    get publicKeyBase64(): string;
+    sign(data: Uint8Array): Promise<string>;
+    static verify(data: Uint8Array, sigB64: string, signerDid: string): Promise<boolean>;
+    getDIDDocument(params?: {
+        services?: {
+            type: string;
+            endpoint: string;
+        }[];
+        capabilities?: string[];
+    }): DIDDocument;
+    exportPrivateKey(): string;
+}
+
+/**
+ * Verifiable Credentials and Presentations (W3C VC Data Model v2)
+ */
+
+interface VerifiableCredential {
+    '@context': string[];
+    type: string[];
+    issuer: string;
+    validFrom: string;
+    credentialSubject: {
+        id: string;
+        [key: string]: any;
+    };
+    proof: {
+        type: string;
+        verificationMethod: string;
+        proofPurpose: string;
+        created: string;
+        proofValue: string;
+    };
+}
+interface VerifiablePresentation {
+    '@context': string[];
+    type: string[];
+    holder: string;
+    verifiableCredential: VerifiableCredential[];
+    proof: {
+        type: string;
+        verificationMethod: string;
+        challenge: string;
+        proofValue: string;
+    };
+}
+declare function buildCredential(params: {
+    issuer: AIPIdentity;
+    holderDid: string;
+    type: string;
+    claims: Record<string, any>;
+}): Promise<VerifiableCredential>;
+declare function buildPresentation(params: {
+    holder: AIPIdentity;
+    credentials: VerifiableCredential[];
+    challenge: string;
+}): Promise<VerifiablePresentation>;
+declare function verifyCredential(vc: VerifiableCredential): Promise<boolean>;
+declare function verifyPresentation(vp: VerifiablePresentation, expectedChallenge: string): Promise<boolean>;
+
+/**
+ * Verifiable and Ephemeral Delegations
+ */
+
+interface VerifiableDelegation {
+    '@context': string[];
+    type: string[];
+    issuer: string;
+    validFrom: string;
+    validUntil?: string;
+    credentialSubject: {
+        id: string;
+        'aip:scope': string[];
+        'aip:role'?: string;
+    };
+    proof: {
+        type: string;
+        verificationMethod: string;
+        proofPurpose: string;
+        created: string;
+        proofValue: string;
+    };
+}
+interface EphemeralDelegation {
+    type: 'EphemeralDelegation';
+    parentDid: string;
+    sessionId: string;
+    scope: string[];
+    validFrom: string;
+    validUntil: string;
+    nonce: string;
+    proof: {
+        type: string;
+        verificationMethod: string;
+        proofValue: string;
+    };
+}
+declare function buildDelegation(params: {
+    issuer: AIPIdentity;
+    subjectDid: string;
+    scope: string[];
+    role?: string;
+    validDays?: number;
+}): Promise<VerifiableDelegation>;
+declare function buildEphemeralDelegation(params: {
+    parent: AIPIdentity;
+    scope: string[];
+    ttlSeconds: number;
+}): Promise<EphemeralDelegation>;
+declare function verifyDelegation(delegation: VerifiableDelegation): Promise<boolean>;
+declare function verifyEphemeralDelegation(token: EphemeralDelegation): Promise<boolean>;
+
+declare function publicKeyToDIDKey(pubBytes: Uint8Array): string;
+declare function didKeyToPublicKey(did: string): Uint8Array;
+declare function validateDIDKey(did: string): boolean;
+
+/**
+ * DID Resolver — resolve did:key locally, did:web via HTTPS
+ */
+interface DIDResolver {
+    resolve(did: string): Promise<any>;
+}
+/**
+ * KeyResolver — resolves did:key locally (no network).
+ */
+declare class KeyResolver implements DIDResolver {
+    resolve(did: string): Promise<any>;
+}
+
+export { AIPIdentity, type DIDDocument, type DIDResolver, type EphemeralDelegation, KeyResolver, type SignedPayload, type VerifiableCredential, type VerifiableDelegation, type VerifiablePresentation, buildCredential, buildDelegation, buildEphemeralDelegation, buildPresentation, didKeyToPublicKey, publicKeyToDIDKey, validateDIDKey, verifyCredential, verifyDelegation, verifyEphemeralDelegation, verifyPresentation };

package/node_modules/@prismer/aip-sdk/dist/index.js

@@ -0,0 +1,322 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+
+// src/did.ts
+var ED25519_MULTICODEC = new Uint8Array([237, 1]);
+var B58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function base58Encode(bytes) {
+  const digits = [0];
+  for (const byte of bytes) {
+    let carry = byte;
+    for (let j = 0; j < digits.length; j++) {
+      carry += digits[j] << 8;
+      digits[j] = carry % 58;
+      carry = carry / 58 | 0;
+    }
+    while (carry > 0) {
+      digits.push(carry % 58);
+      carry = carry / 58 | 0;
+    }
+  }
+  let output = "";
+  for (const byte of bytes) {
+    if (byte === 0) output += "1";
+    else break;
+  }
+  for (let i = digits.length - 1; i >= 0; i--) {
+    output += B58_ALPHABET[digits[i]];
+  }
+  return output;
+}
+function base58Decode(str) {
+  const bytes = [0];
+  for (const char of str) {
+    const index = B58_ALPHABET.indexOf(char);
+    if (index < 0) throw new Error(`Invalid base58 character: ${char}`);
+    let carry = index;
+    for (let j = 0; j < bytes.length; j++) {
+      carry += bytes[j] * 58;
+      bytes[j] = carry & 255;
+      carry >>= 8;
+    }
+    while (carry > 0) {
+      bytes.push(carry & 255);
+      carry >>= 8;
+    }
+  }
+  for (const char of str) {
+    if (char === "1") bytes.push(0);
+    else break;
+  }
+  return new Uint8Array(bytes.reverse());
+}
+function publicKeyToDIDKey(pubBytes) {
+  if (pubBytes.length !== 32) throw new Error(`Expected 32 bytes, got ${pubBytes.length}`);
+  const mc = new Uint8Array(34);
+  mc.set(ED25519_MULTICODEC, 0);
+  mc.set(pubBytes, 2);
+  return `did:key:z${base58Encode(mc)}`;
+}
+function didKeyToPublicKey(did) {
+  if (!did.startsWith("did:key:z")) throw new Error("Invalid did:key format");
+  const decoded = base58Decode(did.slice(9));
+  if (decoded.length !== 34 || decoded[0] !== 237 || decoded[1] !== 1) {
+    throw new Error("Invalid did:key: wrong prefix or length");
+  }
+  return decoded.slice(2);
+}
+function validateDIDKey(did) {
+  try {
+    didKeyToPublicKey(did);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+// src/identity.ts
+var _ed25519 = null;
+async function getEd25519() {
+  if (_ed25519) return _ed25519;
+  const mod = await import("@noble/curves/ed25519.js");
+  _ed25519 = mod.ed25519;
+  return _ed25519;
+}
+var AIPIdentity = class _AIPIdentity {
+  constructor(priv, pub, did) {
+    this.privateKey = priv;
+    this.publicKey = pub;
+    this.did = did;
+  }
+  static async create() {
+    const ed = await getEd25519();
+    const priv = ed.utils.randomSecretKey();
+    const pub = ed.getPublicKey(priv);
+    return new _AIPIdentity(priv, pub, publicKeyToDIDKey(pub));
+  }
+  /**
+   * @deprecated Compatibility derivation for existing Prismer Cloud identities.
+   * New applications should create and persist a random identity with create().
+   * The deterministic output remains unchanged throughout the 2.x release line.
+   */
+  static async fromApiKey(apiKey) {
+    const ed = await getEd25519();
+    const keyBytes = new TextEncoder().encode(apiKey);
+    const hashBuffer = await crypto.subtle.digest("SHA-256", keyBytes);
+    const seed = new Uint8Array(hashBuffer);
+    const pub = ed.getPublicKey(seed);
+    return new _AIPIdentity(seed, pub, publicKeyToDIDKey(pub));
+  }
+  static async fromPrivateKey(key) {
+    const ed = await getEd25519();
+    const pub = ed.getPublicKey(key);
+    return new _AIPIdentity(key, pub, publicKeyToDIDKey(pub));
+  }
+  get publicKeyBase64() {
+    return typeof Buffer !== "undefined" ? Buffer.from(this.publicKey).toString("base64") : btoa(String.fromCharCode(...this.publicKey));
+  }
+  async sign(data) {
+    const ed = await getEd25519();
+    const sig = ed.sign(data, this.privateKey);
+    return typeof Buffer !== "undefined" ? Buffer.from(sig).toString("base64") : btoa(String.fromCharCode(...sig));
+  }
+  static async verify(data, sigB64, signerDid) {
+    try {
+      const ed = await getEd25519();
+      const pub = didKeyToPublicKey(signerDid);
+      const sig = typeof Buffer !== "undefined" ? new Uint8Array(Buffer.from(sigB64, "base64")) : new Uint8Array(
+        atob(sigB64).split("").map((c) => c.charCodeAt(0))
+      );
+      return ed.verify(sig, data, pub);
+    } catch (e) {
+      return false;
+    }
+  }
+  getDIDDocument(params) {
+    var _a, _b;
+    const keyId = `${this.did}#keys-1`;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const doc = {
+      "@context": ["https://www.w3.org/ns/did/v1", "https://w3id.org/security/suites/ed25519-2020/v1"],
+      id: this.did,
+      controller: this.did,
+      verificationMethod: [
+        { id: keyId, type: "Ed25519VerificationKey2020", controller: this.did, publicKeyMultibase: this.did.slice(8) }
+      ],
+      authentication: [keyId],
+      assertionMethod: [keyId],
+      capabilityDelegation: [keyId],
+      capabilityInvocation: [keyId],
+      created: now,
+      updated: now
+    };
+    if ((_a = params == null ? void 0 : params.services) == null ? void 0 : _a.length) {
+      doc.service = params.services.map((s, i) => ({
+        id: `${this.did}#service-${i}`,
+        type: s.type,
+        serviceEndpoint: s.endpoint
+      }));
+    }
+    if ((_b = params == null ? void 0 : params.capabilities) == null ? void 0 : _b.length) doc["aip:capabilities"] = params.capabilities;
+    return doc;
+  }
+  exportPrivateKey() {
+    return typeof Buffer !== "undefined" ? Buffer.from(this.privateKey).toString("base64") : btoa(String.fromCharCode(...this.privateKey));
+  }
+};
+
+// src/credentials.ts
+async function buildCredential(params) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const body = {
+    "@context": ["https://www.w3.org/ns/credentials/v2"],
+    type: ["VerifiableCredential", params.type],
+    issuer: params.issuer.did,
+    validFrom: now,
+    credentialSubject: __spreadValues({ id: params.holderDid }, params.claims)
+  };
+  const data = new TextEncoder().encode(JSON.stringify(body));
+  const proofValue = await params.issuer.sign(data);
+  return __spreadProps(__spreadValues({}, body), { proof: { type: "Ed25519Signature2020", verificationMethod: `${params.issuer.did}#keys-1`, proofPurpose: "assertionMethod", created: now, proofValue } });
+}
+async function buildPresentation(params) {
+  const body = {
+    "@context": ["https://www.w3.org/ns/credentials/v2"],
+    type: ["VerifiablePresentation"],
+    holder: params.holder.did,
+    verifiableCredential: params.credentials
+  };
+  const data = new TextEncoder().encode(JSON.stringify(body) + params.challenge);
+  const proofValue = await params.holder.sign(data);
+  return __spreadProps(__spreadValues({}, body), { proof: { type: "Ed25519Signature2020", verificationMethod: `${params.holder.did}#keys-1`, challenge: params.challenge, proofValue } });
+}
+async function verifyCredential(vc) {
+  const _a = vc, { proof } = _a, body = __objRest(_a, ["proof"]);
+  const data = new TextEncoder().encode(JSON.stringify(body));
+  return AIPIdentity.verify(data, proof.proofValue, vc.issuer);
+}
+async function verifyPresentation(vp, expectedChallenge) {
+  if (vp.proof.challenge !== expectedChallenge) return false;
+  const _a = vp, { proof } = _a, body = __objRest(_a, ["proof"]);
+  const data = new TextEncoder().encode(JSON.stringify(body) + expectedChallenge);
+  const holderValid = await AIPIdentity.verify(data, proof.proofValue, vp.holder);
+  if (!holderValid) return false;
+  for (const vc of vp.verifiableCredential) {
+    if (!await verifyCredential(vc)) return false;
+  }
+  return true;
+}
+
+// src/delegation.ts
+async function buildDelegation(params) {
+  const now = /* @__PURE__ */ new Date();
+  const validUntil = params.validDays ? new Date(now.getTime() + params.validDays * 864e5) : void 0;
+  const body = __spreadProps(__spreadValues({
+    "@context": ["https://www.w3.org/ns/credentials/v2"],
+    type: ["VerifiableCredential", "AgentDelegation"],
+    issuer: params.issuer.did,
+    validFrom: now.toISOString()
+  }, validUntil && { validUntil: validUntil.toISOString() }), {
+    credentialSubject: __spreadValues({
+      id: params.subjectDid,
+      "aip:scope": params.scope
+    }, params.role && { "aip:role": params.role })
+  });
+  const data = new TextEncoder().encode(JSON.stringify(body));
+  const proofValue = await params.issuer.sign(data);
+  return __spreadProps(__spreadValues({}, body), { proof: { type: "Ed25519Signature2020", verificationMethod: `${params.issuer.did}#keys-1`, proofPurpose: "assertionMethod", created: now.toISOString(), proofValue } });
+}
+async function buildEphemeralDelegation(params) {
+  const now = /* @__PURE__ */ new Date();
+  const validUntil = new Date(now.getTime() + params.ttlSeconds * 1e3);
+  const nonce = Array.from(crypto.getRandomValues(new Uint8Array(16)), (b) => b.toString(16).padStart(2, "0")).join("");
+  const body = {
+    type: "EphemeralDelegation",
+    parentDid: params.parent.did,
+    sessionId: `sub_${nonce.slice(0, 8)}`,
+    scope: params.scope,
+    validFrom: now.toISOString(),
+    validUntil: validUntil.toISOString(),
+    nonce
+  };
+  const data = new TextEncoder().encode(JSON.stringify(body));
+  const proofValue = await params.parent.sign(data);
+  return __spreadProps(__spreadValues({}, body), { proof: { type: "Ed25519Signature2020", verificationMethod: `${params.parent.did}#keys-1`, proofValue } });
+}
+async function verifyDelegation(delegation) {
+  if (new Date(delegation.validFrom) > /* @__PURE__ */ new Date()) return false;
+  if (delegation.validUntil && new Date(delegation.validUntil) < /* @__PURE__ */ new Date()) return false;
+  const _a = delegation, { proof } = _a, body = __objRest(_a, ["proof"]);
+  const data = new TextEncoder().encode(JSON.stringify(body));
+  return AIPIdentity.verify(data, proof.proofValue, delegation.issuer);
+}
+async function verifyEphemeralDelegation(token) {
+  if (new Date(token.validUntil) < /* @__PURE__ */ new Date()) return false;
+  const _a = token, { proof } = _a, body = __objRest(_a, ["proof"]);
+  const data = new TextEncoder().encode(JSON.stringify(body));
+  return AIPIdentity.verify(data, proof.proofValue, token.parentDid);
+}
+
+// src/resolver.ts
+var KeyResolver = class {
+  async resolve(did) {
+    if (!did.startsWith("did:key:")) {
+      throw new Error(`KeyResolver only supports did:key, got: ${did}`);
+    }
+    const pubBytes = didKeyToPublicKey(did);
+    const keyId = `${did}#keys-1`;
+    const multibase = did.slice(8);
+    return {
+      "@context": ["https://www.w3.org/ns/did/v1"],
+      id: did,
+      controller: did,
+      verificationMethod: [{ id: keyId, type: "Ed25519VerificationKey2020", controller: did, publicKeyMultibase: multibase }],
+      authentication: [keyId],
+      assertionMethod: [keyId]
+    };
+  }
+};
+export {
+  AIPIdentity,
+  KeyResolver,
+  buildCredential,
+  buildDelegation,
+  buildEphemeralDelegation,
+  buildPresentation,
+  didKeyToPublicKey,
+  publicKeyToDIDKey,
+  validateDIDKey,
+  verifyCredential,
+  verifyDelegation,
+  verifyEphemeralDelegation,
+  verifyPresentation
+};

package/node_modules/@prismer/aip-sdk/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@prismer/aip-sdk",
+  "version": "2.2.55",
+  "description": "Agent Identity Protocol (AIP) — standalone DID-based identity for AI Agents",
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "aip": "./dist/cli/index.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts && tsup src/cli/index.ts --format esm --out-dir dist/cli",
+    "test": "tsx test/aip.test.ts && tsx test/conformance.test.ts"
+  },
+  "peerDependencies": {
+    "@noble/curves": ">=1.0.0"
+  },
+  "devDependencies": {
+    "@noble/curves": "^2.0.1",
+    "@types/node": "^20.0.0",
+    "tsup": "^8.5.1",
+    "tsx": "^4.20.6",
+    "typescript": "^5.9.2"
+  },
+  "keywords": [
+    "aip",
+    "did",
+    "agent",
+    "identity",
+    "ed25519",
+    "verifiable-credentials"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nicepkg/prismer-aip-sdk"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  }
+}

package/node_modules/ansi-regex/index.d.ts

@@ -0,0 +1,37 @@
+declare namespace ansiRegex {
+	interface Options {
+		/**
+		Match only the first ANSI escape.
+
+		@default false
+		*/
+		onlyFirst: boolean;
+	}
+}
+
+/**
+Regular expression for matching ANSI escape codes.
+
+@example
+```
+import ansiRegex = require('ansi-regex');
+
+ansiRegex().test('\u001B[4mcake\u001B[0m');
+//=> true
+
+ansiRegex().test('cake');
+//=> false
+
+'\u001B[4mcake\u001B[0m'.match(ansiRegex());
+//=> ['\u001B[4m', '\u001B[0m']
+
+'\u001B[4mcake\u001B[0m'.match(ansiRegex({onlyFirst: true}));
+//=> ['\u001B[4m']
+
+'\u001B]8;;https://github.com\u0007click\u001B]8;;\u0007'.match(ansiRegex());
+//=> ['\u001B]8;;https://github.com\u0007', '\u001B]8;;\u0007']
+```
+*/
+declare function ansiRegex(options?: ansiRegex.Options): RegExp;
+
+export = ansiRegex;

package/node_modules/ansi-regex/index.js

@@ -0,0 +1,10 @@
+'use strict';
+
+module.exports = ({onlyFirst = false} = {}) => {
+	const pattern = [
+		'[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
+		'(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))'
+	].join('|');
+
+	return new RegExp(pattern, onlyFirst ? undefined : 'g');
+};

package/node_modules/ansi-regex/license

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

package/node_modules/ansi-regex/package.json

@@ -0,0 +1,55 @@
+{
+	"name": "ansi-regex",
+	"version": "5.0.1",
+	"description": "Regular expression for matching ANSI escape codes",
+	"license": "MIT",
+	"repository": "chalk/ansi-regex",
+	"author": {
+		"name": "Sindre Sorhus",
+		"email": "sindresorhus@gmail.com",
+		"url": "sindresorhus.com"
+	},
+	"engines": {
+		"node": ">=8"
+	},
+	"scripts": {
+		"test": "xo && ava && tsd",
+		"view-supported": "node fixtures/view-codes.js"
+	},
+	"files": [
+		"index.js",
+		"index.d.ts"
+	],
+	"keywords": [
+		"ansi",
+		"styles",
+		"color",
+		"colour",
+		"colors",
+		"terminal",
+		"console",
+		"cli",
+		"string",
+		"tty",
+		"escape",
+		"formatting",
+		"rgb",
+		"256",
+		"shell",
+		"xterm",
+		"command-line",
+		"text",
+		"regex",
+		"regexp",
+		"re",
+		"match",
+		"test",
+		"find",
+		"pattern"
+	],
+	"devDependencies": {
+		"ava": "^2.4.0",
+		"tsd": "^0.9.0",
+		"xo": "^0.25.3"
+	}
+}