glow.ts 1.0.3 → 1.1.1

package/dist/index.d.ts

@@ -0,0 +1,544 @@
+declare type Base64 = string;
+
+export declare class CryptoStorage {
+    private static storageDriver;
+    private driver?;
+    private id?;
+    private storageKey?;
+    private nacl;
+    private constructor();
+    static new(id: string): Promise<CryptoStorage>;
+    static getStorageDriver(): StorageDriver;
+    static setDefaultStorageDriver(): boolean;
+    static setStorageDriver(driver: StorageDriver): boolean;
+    save(tag: string, data: unknown): Promise<boolean>;
+    get<T>(tag: string): Promise<T | null>;
+    remove(tag: string): Promise<boolean>;
+    selfDestruct(): Promise<void>;
+    private addPrefix;
+    private addNonceTag;
+}
+
+declare interface DeleteFileResponse {
+    status: 'OK' | 'NOT_FOUND';
+}
+
+declare interface EncryptedMessage {
+    nonce: string;
+    ctext: string;
+}
+
+export declare interface FileStatusResponse {
+    status: 'COMPLETE' | 'UPLOADING' | 'START' | 'NOT_FOUND';
+    total_chunks: number;
+    file_size: number;
+    bytes_stored: number;
+}
+
+declare interface FileUploadMetadata {
+    name: string;
+    orig_size: number;
+    md5?: string;
+    created?: number;
+    modified?: number;
+    attrs?: string;
+    skey?: Base64;
+}
+
+export declare class GlowNetworkError extends Error {
+    status: number | undefined;
+    readonly name = "GlowNetworkError";
+    constructor(status: number | undefined);
+}
+
+/**
+ * temporary created in-memory storage for testing purposes
+ */
+export declare class InMemoryStorage implements StorageDriver {
+    private storage;
+    get(key: string): Promise<string | null>;
+    getMultiple(keys: string[]): Promise<(string | null)[]>;
+    set<T extends string | null>(key: string, value: T): Promise<void>;
+    setMultiple<T extends string | null>(values: {
+        [key: string]: T;
+    }): Promise<void>;
+    remove(key: string): Promise<void>;
+    removeMultiple(keys: string[]): Promise<void>;
+    reset(): void;
+}
+
+/**
+ * Implementation based on TweetNaCl.js: {@link https://github.com/dchest/tweetnacl-js}.
+ * SHA256 is implemented using Web Crypto API (SubtleCrypto).
+ *
+ * All the methods of this class are actually synchronous, but they are defined
+ * as async to conform to the NaClDriver interface, which may have other implementations.
+ */
+export declare class JsNaClDriver implements NaClDriver {
+    crypto_secretbox_KEYBYTES: number;
+    crypto_secretbox_random_nonce(): Promise<Uint8Array>;
+    crypto_secretbox(message: Uint8Array, nonce: Uint8Array, key: Uint8Array): Promise<Uint8Array>;
+    crypto_secretbox_open(box: Uint8Array, nonce: Uint8Array, key: Uint8Array): Promise<Uint8Array | null>;
+    crypto_box_NONCEBYTES: number;
+    crypto_box(message: Uint8Array, nonce: Uint8Array, pk: Uint8Array, sk: Uint8Array): Promise<Uint8Array>;
+    crypto_box_open(cipher: Uint8Array, nonce: Uint8Array, pk: Uint8Array, sk: Uint8Array): Promise<Uint8Array | null>;
+    crypto_box_random_nonce(): Promise<Uint8Array>;
+    crypto_box_keypair(): Promise<Keypair>;
+    crypto_box_keypair_from_raw_sk(key: Uint8Array): Promise<Keypair>;
+    crypto_box_keypair_from_seed(seed: Uint8Array): Promise<Keypair>;
+    crypto_hash_sha256(data: Uint8Array): Promise<Uint8Array>;
+    random_bytes(size: number): Promise<Uint8Array>;
+    encode_latin1(data: string): Promise<Uint8Array>;
+    decode_latin1(data: Uint8Array): Promise<string>;
+    encode_utf8(data: string): Promise<Uint8Array>;
+    decode_utf8(data: Uint8Array): Promise<string>;
+    to_hex(data: Uint8Array): Promise<string>;
+    from_hex(data: string): Promise<Uint8Array>;
+    /**
+     * h2(m) = sha256(sha256(64x0 + m))
+     * Zero out initial sha256 block, and double hash 0-padded message
+     * http://cs.nyu.edu/~dodis/ps/h-of-h.pdf
+     */
+    h2(data: string | Uint8Array): Promise<Uint8Array>;
+}
+
+export declare interface Keypair {
+    boxPk: Uint8Array;
+    boxSk: Uint8Array;
+}
+
+declare interface KeyRecord {
+    pk: Base64;
+    hpk: Base64;
+}
+
+export declare class KeyRing {
+    static readonly commKeyTag = "comm_key";
+    static readonly guestRegistryTag = "guest_registry";
+    private commKey;
+    private storage;
+    private guestKeys;
+    private nacl;
+    private constructor();
+    static new(id: string): Promise<KeyRing>;
+    static fromBackup(id: string, backupString: string): Promise<KeyRing>;
+    getNumberOfGuests(): number;
+    get guests(): Map<string, KeyRecord>;
+    /**
+     * Returns public identity, which is the default communication key.
+     * Correspondents can know it, whereas Relays do not need it (other than
+     * temporarily for internal use during the ownership proof)
+     */
+    getPubCommKey(): string;
+    getPrivateCommKey(): string;
+    /**
+     * Returns HPK (hash of the public key) of the mailbox. This is what Zax relays
+     * uses as the universal address of the mailbox
+     */
+    getHpk(): Promise<Base64>;
+    getTagByHpk(hpk: string): string | null;
+    getGuestKey(guestTag: string): Base64 | null;
+    backup(): Promise<string>;
+    setCommFromSeed(seed: Uint8Array): Promise<void>;
+    setCommFromSecKey(rawSecretKey: Uint8Array): Promise<void>;
+    addGuest(guestTag: string, publicKey: Base64): Promise<string>;
+    removeGuest(guestTag: string): Promise<boolean>;
+    private loadGuestKeys;
+    private saveGuests;
+    private static getCommKeyOrCreate;
+    selfDestruct(): Promise<void>;
+}
+
+/**
+ * A simple wrapper around a public/private keys pair.
+ * Stores keys in base64 format.
+ */
+export declare class Keys {
+    keys: string | Keypair;
+    private keyPair;
+    constructor(keys: string | Keypair);
+    static isEqual(keys1: Keys, keys2: Keys): boolean;
+    toString(): string;
+    get publicKey(): Base64;
+    get privateKey(): Base64;
+}
+
+export declare class LocalStorageDriver implements StorageDriver {
+    private rootTag;
+    constructor(root?: string);
+    get(key: string): Promise<string | null>;
+    getMultiple(keys: string[]): Promise<(string | null)[]>;
+    set(key: string, value: string | null): Promise<void>;
+    setMultiple(values: {
+        [key: string]: string | null;
+    }): Promise<void>;
+    remove(key: string): Promise<void>;
+    removeMultiple(keys: string[]): Promise<void>;
+    private tag;
+}
+
+/**
+ * Mailbox class represents a wrapper around a Keyring that allows to exchange
+ * encrypted messages with other Mailboxes via a relay
+ */
+export declare class Mailbox {
+    keyRing: KeyRing;
+    identity: string;
+    /**
+     * each mailbox use it's own relays for connection
+     * this gives possibility to connect different mailboxes to same server simultaneously
+     * because they will use different session keys, tokens, server pub keys
+     */
+    private relayFactory;
+    private relayConnectionMutexes;
+    private nacl;
+    private constructor();
+    static new(identity: string): Promise<Mailbox>;
+    /**
+     * Create a Mailbox where the secret identity key is derived from a well-known seed
+     */
+    static fromSeed(id: string, seed: Uint8Array | string): Promise<Mailbox>;
+    /**
+     * Create a Mailbox from the known secret identity key
+     */
+    static fromSecKey(id: string, rawSecretKey: Uint8Array | Base64): Promise<Mailbox>;
+    /**
+     * Create a Mailbox from the backup string
+     */
+    static fromBackup(identity: string, backup: string): Promise<Mailbox>;
+    /**
+     * Sends a free-form object to a guest we already have in our keyring. Set `encrypt` to `false` to
+     * send a plaintext message. Returns a token that can be used with `messageStatus` command to check
+     * the status of the message
+     */
+    upload(url: string, guestKey: string, message: string, encrypt?: boolean): Promise<Base64>;
+    /**
+     * Downloads all messages from a relay, decrypts them with a relay key,
+     * and then parses each message to find out if it's a text message, file message,
+     * or if it can't be decrypted because HPK is missing in the keyring.
+     * Returns an array of mixed messages
+     */
+    download(url: string): Promise<ZaxParsedMessage[]>;
+    /**
+     * Marks a raw Zax message as one that can't be decrypted,
+     * because sender's HPK is not found in the keyring
+     */
+    private parsePlainMessage;
+    /**
+     * Decrypts a message that represents uploaded file metadata
+     */
+    private parseFileMessage;
+    /**
+     * Attempts to decrypt a regular encrypted Zax message. Returns plain message if it was sent encrypted
+     */
+    private parseTextMessage;
+    /**
+     * Returns the number of messages in the mailbox on a given relay
+     */
+    count(url: string): Promise<number>;
+    /**
+     * Deletes messages from a relay given a list of base64 message nonces,
+     * and returns the number of remaining messages
+     */
+    delete(url: string, nonceList: Base64[]): Promise<number>;
+    /**
+     * Gets the status of a previously sent Zax message by a storage token.
+     * Returns "time to live" in seconds or a negative value if it's not applicable.
+     * See `MessageStatusResponse` values for reference
+     */
+    messageStatus(url: string, storageToken: Base64): Promise<MessageStatusResponse | number>;
+    /**
+     * Asks Zax to start a new upload session, and returns a unique file identifier
+     * required to upload file chunks.
+     */
+    startFileUpload(url: string, guest: string, rawMetadata: FileUploadMetadata): Promise<StartFileUploadResponse>;
+    /**
+     * Encrypts the file chunk symmetrically and transfers it to a relay
+     */
+    uploadFileChunk(url: string, uploadID: string, chunk: Uint8Array, part: number, totalParts: number, skey: Uint8Array): Promise<UploadFileChunkResponse>;
+    /**
+     * Returns the status of a file upload by its relay-specific uploadID. Uploader can call it
+     * to verify the correct transfer, and downloader can check if the file exists and retrieve
+     * the number of chunks
+     */
+    getFileStatus(url: string, uploadID: string): Promise<FileStatusResponse>;
+    /**
+     * Fetches the file metadata by uploadID, which was declared by the uploader
+     */
+    getFileMetadata(url: string, uploadID: string): Promise<FileUploadMetadata>;
+    /**
+     * Downloads a binary chunk of a file from a relay by a given uploadID. The total number of chunks
+     * can be retrieved via a `getFileStatus` request
+     */
+    downloadFileChunk(url: string, uploadID: string, part: number, skey: Uint8Array | Base64): Promise<Uint8Array | null>;
+    /**
+     * Deletes a file from the relay (or all chunks uploaded so far, if the upload was not completed).
+     * Can be called by either the sender or recipient
+     */
+    deleteFile(url: string, uploadID: string): Promise<DeleteFileResponse>;
+    /**
+     * Establishes a session, exchanges temp keys and proves our ownership of this
+     * Mailbox to this specific relay. This is the first function to start
+     * communications with any relay. Returns the number of messages in the mailbox
+     */
+    connectToRelay(url: string): Promise<number>;
+    clearSession(url: string): void;
+    private encryptSignature;
+    /**
+     * Gets a singleton Relay instance, and reconnects to a relay if a previous token has expired
+     */
+    private prepareRelay;
+    /**
+     * Encrypts the payload of the command and sends it to a relay
+     */
+    private runRelayCommand;
+    /**
+     * Parses relay's response to a command, for those commands that expect an encrypted message in return.
+     * Two lines of POST response will be nonce and ctext
+     */
+    private decryptResponse;
+    /**
+     * Encodes `message` to the guest key of a guest already
+     * added to the keyring
+     */
+    encodeMessage(guest: string, message: string): Promise<EncryptedMessage>;
+    /**
+     * Decodes a ciphertext from a guest key already in our keyring with this nonce
+     * @returns null if failed to decode
+     */
+    decodeMessage(guest: string, nonce: Base64, ctext: Base64): Promise<string | null>;
+    /**
+     * Wrapper around `keyring.getGuestKey` that handles unknown guests
+     */
+    private getGuestKey;
+    /**
+     * Deletes a Mailbox and all its data from local CryptoStorage. This is a very
+     * destructive operation, use with caution - it will delete the Mailbox
+     * keyring along with all stored public keys. To restore that information, you
+     * will need to do another key exchange with all the guests on your keyring.
+     */
+    selfDestruct(): Promise<void>;
+    private getRelayConnectionMutex;
+}
+
+/**
+ * Status of a previously sent message equals redis TTL.
+ * See https://redis.io/commands/ttl.
+ * -2 : missing key
+ * -1 : key never expires
+ * 0+ : key time to live in seconds
+ */
+declare enum MessageStatusResponse {
+    MissingKey = -2,
+    NeverExpires = -1
+}
+
+/**
+ * Facade singleton to access the NaCl driver.
+ * Usage: call instance() with a chosen driver, and store the received object to perform further actions.
+ */
+export declare class NaCl {
+    private static driverInstance?;
+    private constructor();
+    static setDefaultInstance(): boolean;
+    static setInstance(driver: NaClDriver): boolean;
+    static getInstance(): NaClDriver;
+}
+
+export declare interface NaClDriver {
+    crypto_secretbox_KEYBYTES: number;
+    crypto_secretbox_random_nonce(): Promise<Uint8Array>;
+    crypto_secretbox(message: Uint8Array, nonce: Uint8Array, key: Uint8Array): Promise<Uint8Array>;
+    crypto_secretbox_open(box: Uint8Array, nonce: Uint8Array, key: Uint8Array): Promise<Uint8Array | null>;
+    crypto_box_NONCEBYTES: number;
+    crypto_box(message: Uint8Array, nonce: Uint8Array, pk: Uint8Array, sk: Uint8Array): Promise<Uint8Array>;
+    crypto_box_open(cipher: Uint8Array, nonce: Uint8Array, pk: Uint8Array, sk: Uint8Array): Promise<Uint8Array | null>;
+    crypto_box_random_nonce(): Promise<Uint8Array>;
+    crypto_box_keypair(): Promise<Keypair>;
+    crypto_box_keypair_from_raw_sk(key: Uint8Array): Promise<Keypair>;
+    crypto_box_keypair_from_seed(seed: Uint8Array): Promise<Keypair>;
+    crypto_hash_sha256(data: Uint8Array): Promise<Uint8Array>;
+    h2(data: string | Uint8Array): Promise<Uint8Array>;
+    random_bytes(size: number): Promise<Uint8Array>;
+    encode_latin1(data: string): Promise<Uint8Array>;
+    decode_latin1(data: Uint8Array): Promise<string>;
+    encode_utf8(data: string): Promise<Uint8Array>;
+    decode_utf8(data: Uint8Array): Promise<string>;
+    to_hex(data: Uint8Array): Promise<string>;
+    from_hex(data: string): Promise<Uint8Array>;
+}
+
+/**
+ * Low-level operations with Zax relay
+ */
+export declare class Relay {
+    url: string;
+    private nacl;
+    private difficulty;
+    private publicKey?;
+    private clientToken?;
+    private sessionKeys?;
+    private tokenExpirationTimeoutHandle?;
+    private sessionExpirationTimeoutHandle?;
+    constructor(url: string);
+    get isConnected(): boolean;
+    /**
+     * Exchanges tokens with a relay and gets a temp session key for this relay.
+     * Returns h₂(signature) and a relay public key
+     */
+    openConnection(): Promise<RelayConnectionData>;
+    /**
+     * Sends a client token to a relay and saves a relay token
+     */
+    private fetchRelayToken;
+    /**
+     * Completes the handshake and saves a relay pubic key
+     */
+    private fetchRelayPublicKey;
+    /**
+     * Attaches a mailbox and fetches number of messages
+     */
+    prove(payload: EncryptedMessage): Promise<string>;
+    encodeMessage(message: string): Promise<EncryptedMessage>;
+    decodeMessage<T>(nonce: Base64, ctext: Base64): Promise<T>;
+    /**
+     * Executes a message/file command on a relay, parses and validates the response
+     */
+    runCmd(command: RelayCommand, hpk: Base64, message: EncryptedMessage, ctext?: string): Promise<string[]>;
+    private getSignature;
+    /**
+     * Executes a call to a relay and return raw string response
+     */
+    private httpCall;
+    /**
+     * Parses relay response and throws an error if its format is unexpected
+     */
+    private parseResponse;
+    /**
+     * Compares the expected number of lines in response with what was actually received from a relay
+     */
+    private validateResponse;
+    /**
+     * delete token locally before it was removed on server so will reconnect without getting unauthorized error
+     */
+    private scheduleTokenExpiration;
+    clearToken(): void;
+    /**
+     * established session is valid only for some period need to remove it after it's ttl
+     * so relay will reconnect without receiving error from server
+     */
+    private scheduleSessionExpiration;
+    clearSession(): void;
+    /**
+     * Continuously calculates the nonce until one requested by a relay is found
+     */
+    private ensureNonceDifficulty;
+    /**
+     * Returns `true` if the rightmost n bits of a byte are 0.
+     * Check whether the rightmost difficulty bits of an Uint8Array are 0, where
+     * the lowest indexes of the array represent those rightmost bits. Thus if
+     * the difficulty is 17, then array[0] and array[1] should be 0, as should the
+     * rightmost bit of array[2]. This is used for our difficulty settings in Zax to
+     * reduce burden on a busy server by ensuring clients have to do some
+     * additional work during the session handshake
+     */
+    private arrayZeroBits;
+    /**
+     * Returns `true` if the rightmost n bits of a byte are 0
+     */
+    private firstZeroBits;
+}
+
+/**
+ * Interfaces of Zax relay command requests and responses.
+ * See https://github.com/vault12/zax for details.
+ *
+ * Full technical specification:
+ * https://s3-us-west-1.amazonaws.com/vault12/crypto_relay.pdf
+ */
+declare enum RelayCommand {
+    count = "count",
+    upload = "upload",
+    download = "download",
+    messageStatus = "messageStatus",
+    delete = "delete",
+    startFileUpload = "startFileUpload",
+    uploadFileChunk = "uploadFileChunk",
+    downloadFileChunk = "downloadFileChunk",
+    fileStatus = "fileStatus",
+    deleteFile = "deleteFile"
+}
+
+declare interface RelayConnectionData {
+    h2Signature: Uint8Array;
+    relayPublicKey: Uint8Array;
+}
+
+declare interface StartFileUploadResponse {
+    uploadID: string;
+    max_chunk_size: number;
+    storage_token: string;
+    skey: Uint8Array;
+}
+
+export declare interface StorageDriver {
+    get(key: string): Promise<string | null>;
+    getMultiple(keys: string[]): Promise<(string | null)[]>;
+    set(key: string, value: string | null): Promise<void>;
+    setMultiple(values: {
+        [key: string]: string | null;
+    }): Promise<void>;
+    remove(key: string): Promise<void>;
+    removeMultiple(keys: string[]): Promise<void>;
+}
+
+declare interface UploadFileChunkResponse {
+    status: 'OK' | 'NOT_FOUND';
+}
+
+export declare class Utils {
+    static toBase64(input: Uint8Array): Base64;
+    static fromBase64(input: Base64): Uint8Array;
+    static encode_latin1(data: string): Uint8Array;
+    static decode_latin1(data: Uint8Array): string;
+    static toObject(pairs: IterableIterator<[string, unknown]>): {};
+}
+
+export declare interface ZaxFileMessage {
+    data: FileUploadMetadata;
+    time: number;
+    senderTag: string;
+    uploadID: string;
+    nonce: Base64;
+    kind: ZaxMessageKind.file;
+}
+
+export declare enum ZaxMessageKind {
+    message = "message",
+    file = "file",
+    plain = "plain"
+}
+
+export declare type ZaxParsedMessage = ZaxPlainMessage | ZaxFileMessage | ZaxTextMessage;
+
+export declare interface ZaxPlainMessage {
+    data: string;
+    time: number;
+    from: Base64;
+    nonce: Base64;
+    senderTag: undefined;
+    kind: ZaxMessageKind.plain;
+}
+
+export declare interface ZaxTextMessage {
+    /**
+     * Decoded object after JSON.parse
+     */
+    data: string;
+    time: number;
+    senderTag: string;
+    nonce: Base64;
+    kind: ZaxMessageKind.message;
+}
+
+export { }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "glow.ts",
-  "version": "1.0.3",
+  "version": "1.1.1",
   "displayName": "Glow.ts",
   "description": "Client library for interacting with Zax Cryptographic Relay Servers",
   "keywords": [
@@ -23,39 +23,47 @@
   "homepage": "https://github.com/vault12/glow.ts#readme",
   "license": "MIT",
   "scripts": {
-    "clean": "rm -rf dist/",
-    "build:esm": "tsc",
-    "build:commonjs": "tsc -p ./tscconfig.cjs.json",
-    "build": "npm run clean && npm run build:esm && npm run build:commonjs",
+    "build": "vite build",
+    "dev": "vite build --watch",
     "prepublishOnly": "npm run build",
-    "lint": "eslint 'src/**'",
-    "lint:fix": "eslint 'src/**' --fix",
+    "lint": "eslint",
+    "lint:fix": "eslint --fix",
     "test": "jest",
-    "test:coverage": "jest --coverage",
-    "test:watch": "jest --watch"
+    "test:jsdom": "jest --selectProjects jsdom",
+    "test:node": "jest --selectProjects node",
+    "test:coverage": "jest --selectProjects node --coverage",
+    "test:watch": "jest --selectProjects node --watch"
   },
-  "main": "dist/cjs/index.js",
-  "module": "dist/esm/index.js",
-  "types": "dist/types/index.d.ts",
+  "type": "module",
   "files": [
-    "dist/**/*"
+    "dist"
   ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/glow.es.js",
+      "require": "./dist/glow.cjs.js"
+    }
+  },
   "dependencies": {
-    "async-mutex": "0.3.2",
-    "axios": "0.28.0",
-    "js-sha256": "0.9.0",
+    "async-mutex": "0.5.0",
     "tweetnacl": "1.0.3"
   },
   "devDependencies": {
-    "@types/jest": "27.4.0",
-    "@typescript-eslint/eslint-plugin": "5.12.0",
-    "@typescript-eslint/parser": "5.12.0",
-    "axios-mock-adapter": "1.20.0",
-    "eslint": "8.9.0",
-    "jest": "27.5.1",
-    "jest-localstorage-mock": "2.4.19",
-    "ts-jest": "27.1.3",
-    "ts-node": "10.5.0",
-    "typescript": "4.5.5"
+    "@eslint/js": "9.36.0",
+    "@jest/types": "30.0.5",
+    "@microsoft/api-extractor": "7.52.13",
+    "@types/jest": "30.0.0",
+    "@types/node": "24.5.2",
+    "eslint": "9.36.0",
+    "jest": "30.1.3",
+    "jest-environment-jsdom": "30.1.2",
+    "jest-localstorage-mock": "2.4.26",
+    "ts-jest": "29.4.4",
+    "ts-node": "10.9.2",
+    "typescript": "5.8.2",
+    "typescript-eslint": "8.44.0",
+    "unplugin-dts": "1.0.0-beta.6",
+    "vite": "7.1.6"
   }
 }

package/dist/cjs2/config.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.config = void 0;
-const sessionTimeoutBuffer = 30 * 1000;
-exports.config = {
-    NONCE_TAG: '__nc',
-    SKEY_TAG: 'storage_key',
-    STORAGE_ROOT: '.v1.stor.vlt12',
-    // Relay tokens, keys and hashes are 32 bytes
-    RELAY_TOKEN_LEN: 32,
-    // 5 min - Token expiration on the server side, matched with config.x.relay.token_timeout on Zax server
-    RELAY_TOKEN_TIMEOUT: 5 * 60 * 1000 - sessionTimeoutBuffer,
-    // 20 min - Session expiration on the server side, matched with config.x.relay.session_timeout on Zax server
-    RELAY_SESSION_TIMEOUT: 20 * 60 * 1000 - sessionTimeoutBuffer,
-    // 5 sec - Ajax request timeout
-    RELAY_AJAX_TIMEOUT: 5 * 1000
-};
-//# sourceMappingURL=config.js.map

package/dist/cjs2/config.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"config.js","sourceRoot":"","sources":["../../src/config.ts"],"names":[],"mappings":";;;AAAA,MAAM,oBAAoB,GAAG,EAAE,GAAG,IAAI,CAAC;AAE1B,QAAA,MAAM,GAAG;IACpB,SAAS,EAAE,MAAM;IACjB,QAAQ,EAAE,aAAa;IACvB,YAAY,EAAE,gBAAgB;IAC9B,6CAA6C;IAC7C,eAAe,EAAE,EAAE;IACnB,uGAAuG;IACvG,mBAAmB,EAAE,CAAC,GAAG,EAAE,GAAG,IAAI,GAAG,oBAAoB;IACzD,4GAA4G;IAC5G,qBAAqB,EAAE,EAAE,GAAG,EAAE,GAAG,IAAI,GAAG,oBAAoB;IAC5D,+BAA+B;IAC/B,kBAAkB,EAAE,CAAC,GAAG,IAAI;CAC7B,CAAC"}