@lynxship/cli 0.1.0

package/dist/r2.js

@@ -0,0 +1,135 @@
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { GetObjectCommand, HeadBucketCommand, S3Client, } from "@aws-sdk/client-s3";
+import { Upload } from "@aws-sdk/lib-storage";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+import { assert, sha256 } from "@lynxship/contracts";
+import { loadCredentials } from "./secure-store.js";
+import { globalLynxShipDirectory } from "./paths.js";
+const configFileName = "r2.json";
+function configFile(root) {
+    return join(root, ".lynxship", configFileName);
+}
+function globalConfigFile() {
+    return join(globalLynxShipDirectory(), configFileName);
+}
+function defaultEndpoint(accountId) {
+    return `https://${accountId}.r2.cloudflarestorage.com`;
+}
+function validateConfig(config) {
+    assert(/^[a-f0-9]{32}$/i.test(config.accountId), "CLI_R2_ACCOUNT_ID", "Cloudflare account ID must be a 32-character hexadecimal value");
+    assert(/^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$/.test(config.bucket), "CLI_R2_BUCKET", "R2 bucket name is invalid");
+    assert(config.endpoint.startsWith("https://"), "CLI_R2_ENDPOINT", "R2 S3 endpoint must use HTTPS");
+    assert(config.expiresIn >= 1 && config.expiresIn <= 604800, "CLI_R2_EXPIRY", "R2 download URL expiry must be between 1 second and 7 days");
+    return config;
+}
+export async function loadR2(root) {
+    let config;
+    try {
+        let file = configFile(root);
+        if (!(await access(file)
+            .then(() => true)
+            .catch(() => false)))
+            file = globalConfigFile();
+        config = JSON.parse(await readFile(file, "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            const accountId = process.env.CLOUDFLARE_ACCOUNT_ID;
+            const bucket = process.env.R2_BUCKET;
+            assert(accountId && bucket, "CLI_R2_REQUIRED", "R2 is not configured. Run `lynxship storage configure` first.");
+            config = {
+                accountId,
+                bucket,
+                endpoint: process.env.R2_ENDPOINT ?? defaultEndpoint(accountId),
+                expiresIn: Number(process.env.R2_DOWNLOAD_EXPIRES_IN ?? "86400"),
+            };
+        }
+        else
+            throw error;
+    }
+    const credentials = (await loadCredentials(root)).r2 ??
+        (process.env.R2_ACCESS_KEY_ID && process.env.R2_SECRET_ACCESS_KEY
+            ? {
+                accessKeyId: process.env.R2_ACCESS_KEY_ID,
+                secretAccessKey: process.env.R2_SECRET_ACCESS_KEY,
+            }
+            : undefined);
+    assert(credentials, "CLI_R2_CREDENTIALS", "R2 credentials are missing. Run `lynxship storage configure` again.");
+    return { config: validateConfig(config), credentials };
+}
+export function createR2Client(config, credentials) {
+    return new S3Client({
+        region: "auto",
+        endpoint: config.endpoint,
+        credentials,
+    });
+}
+export async function verifyR2(config, credentials) {
+    const client = createR2Client(config, credentials);
+    try {
+        await client.send(new HeadBucketCommand({ Bucket: config.bucket }));
+    }
+    finally {
+        client.destroy();
+    }
+}
+export async function uploadR2Artifact(root, projectId, buildId, file, contentType, objectName, options = {}) {
+    const { config, credentials } = await loadR2(root);
+    const content = await readFile(file);
+    const hash = sha256(content);
+    const filename = file.split(/[\\/]/).at(-1) ?? "artifact";
+    const key = `artifacts/${projectId}/${buildId}/${objectName ?? filename}`;
+    const client = createR2Client(config, credentials);
+    options.onProgress?.(0, content.length);
+    try {
+        const upload = new Upload({
+            client,
+            queueSize: 1,
+            partSize: 8 * 1024 * 1024,
+            params: {
+                Bucket: config.bucket,
+                Key: key,
+                Body: content,
+                ContentType: contentType,
+                ContentDisposition: `attachment; filename="${filename}"`,
+                ContentLength: content.length,
+                Metadata: { sha256: hash, buildId },
+            },
+        });
+        upload.on("httpUploadProgress", (progress) => {
+            options.onProgress?.(progress.loaded ?? 0, progress.total ?? content.length);
+        });
+        await upload.done();
+        const expiresAt = new Date(Date.now() + config.expiresIn * 1000);
+        const url = await getSignedUrl(client, new GetObjectCommand({
+            Bucket: config.bucket,
+            Key: key,
+        }), { expiresIn: config.expiresIn });
+        return {
+            key,
+            hash,
+            size: content.length,
+            contentType,
+            url,
+            expiresAt: expiresAt.toISOString(),
+        };
+    }
+    finally {
+        client.destroy();
+    }
+}
+export async function writeR2Config(root, config, options = {}) {
+    validateConfig(config);
+    const directory = options.global
+        ? globalLynxShipDirectory()
+        : join(root, ".lynxship");
+    await mkdir(directory, { recursive: true });
+    const file = options.global ? globalConfigFile() : configFile(root);
+    await writeFile(file, `${JSON.stringify(config, null, 2)}\n`, {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+    await access(file);
+}
+export { defaultEndpoint };

package/dist/remote.d.ts

@@ -0,0 +1,33 @@
+import type { BuildJob } from "@lynxship/contracts";
+import type { LynxShipConfig } from "./config.js";
+export interface RemoteCliState {
+    remoteOrganizationId?: string;
+    remoteProjectId?: string;
+}
+export interface OtaPublishRequest {
+    projectId: string;
+    organizationId: string;
+    channel: string;
+    platform: "android" | "ios";
+    runtimeVersion: string;
+    assets: Array<{
+        path: string;
+        hash: string;
+        size: number;
+        url: string;
+    }>;
+    message?: string;
+    rollout?: number;
+    policyApprovalId?: string | null;
+}
+export declare function ensureRemoteTarget(config: LynxShipConfig, state: RemoteCliState): Promise<{
+    organizationId: string;
+    projectId: string;
+}>;
+export declare function submitRealArtifact(config: LynxShipConfig, state: RemoteCliState, job: BuildJob, latest: boolean): Promise<unknown>;
+export declare function publishOtaRelease(config: LynxShipConfig, state: RemoteCliState, input: OtaPublishRequest): Promise<unknown>;
+export declare function fetchOtaPublicKey(config: LynxShipConfig): Promise<{
+    keyId: string;
+    publicKey: string;
+}>;
+//# sourceMappingURL=remote.d.ts.map

package/dist/remote.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote.d.ts","sourceRoot":"","sources":["../src/remote.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,MAAM,WAAW,cAAc;IAC7B,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,SAAS,GAAG,KAAK,CAAC;IAC5B,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACzE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAClC;AAsCD,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,cAAc,EACtB,KAAK,EAAE,cAAc,GACpB,OAAO,CAAC;IAAE,cAAc,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,CA+CxD;AAED,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,cAAc,EACtB,KAAK,EAAE,cAAc,EACrB,GAAG,EAAE,QAAQ,EACb,MAAM,EAAE,OAAO,GACd,OAAO,CAAC,OAAO,CAAC,CAoDlB;AAED,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,cAAc,EACtB,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE,iBAAiB,GACvB,OAAO,CAAC,OAAO,CAAC,CAalB;AAED,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,cAAc,GACrB,OAAO,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,CAQ/C"}

package/dist/remote.js

@@ -0,0 +1,116 @@
+function apiUrl(options) {
+    return (options.apiUrl ??
+        process.env.LYNXSHIP_API_URL ??
+        "http://127.0.0.1:8787").replace(/\/$/, "");
+}
+async function request(options, path, init = {}) {
+    const headers = new Headers(init.headers);
+    headers.set("content-type", "application/json");
+    if (options.token)
+        headers.set("authorization", `Bearer ${options.token}`);
+    const response = await fetch(`${apiUrl(options)}${path}`, {
+        ...init,
+        headers,
+    });
+    const body = (await response.json());
+    if (!response.ok)
+        throw new Error(`LynxShip API ${response.status}: ${body.message ?? body.error ?? response.statusText}`);
+    return body;
+}
+export async function ensureRemoteTarget(config, state) {
+    const options = {
+        apiUrl: config.cli?.apiUrl,
+        token: config.cli?.token ?? process.env.LYNXSHIP_TOKEN,
+    };
+    let organizationId = state.remoteOrganizationId ??
+        config.cli?.organizationId ??
+        process.env.LYNXSHIP_ORGANIZATION_ID;
+    if (!organizationId) {
+        const organization = await request(options, "/v1/organizations", {
+            method: "POST",
+            body: JSON.stringify({
+                name: `${config.projectId ?? "local_project"} organization`,
+                ownerUserId: "cli",
+            }),
+        });
+        organizationId = organization.id;
+        state.remoteOrganizationId = organizationId;
+    }
+    let projectId = state.remoteProjectId;
+    if (!projectId) {
+        const projects = await request(options, `/v1/projects?organizationId=${encodeURIComponent(organizationId)}`);
+        const projectName = config.projectId ?? "local_project";
+        projectId = projects.find((project) => project.name === projectName)?.id;
+        if (!projectId) {
+            const project = await request(options, "/v1/projects", {
+                method: "POST",
+                body: JSON.stringify({
+                    organizationId,
+                    name: projectName,
+                }),
+            });
+            projectId = project.id;
+        }
+        state.remoteProjectId = projectId;
+    }
+    return { organizationId, projectId };
+}
+export async function submitRealArtifact(config, state, job, latest) {
+    if (!job.artifact?.key || !job.artifact.url)
+        throw new Error("The build artifact is not registered in Cloudflare R2");
+    const { organizationId, projectId } = await ensureRemoteTarget(config, state);
+    const filename = job.artifact.name;
+    const artifactResponse = await request({
+        apiUrl: config.cli?.apiUrl,
+        token: config.cli?.token ?? process.env.LYNXSHIP_TOKEN,
+    }, "/v1/artifacts", {
+        method: "POST",
+        body: JSON.stringify({
+            projectId,
+            organizationId,
+            filename,
+            artifact: {
+                key: job.artifact.key,
+                hash: job.artifact.hash,
+                size: job.artifact.size,
+                contentType: job.artifact.contentType,
+                url: job.artifact.url,
+                expiresAt: job.artifact.expiresAt,
+            },
+        }),
+    });
+    return request({
+        apiUrl: config.cli?.apiUrl,
+        token: config.cli?.token ?? process.env.LYNXSHIP_TOKEN,
+    }, "/v1/submissions", {
+        method: "POST",
+        body: JSON.stringify({
+            projectId,
+            organizationId,
+            platform: job.platform,
+            artifact: { hash: artifactResponse.artifact.hash },
+            artifactKey: artifactResponse.artifact.key,
+            downloadUrl: artifactResponse.artifact.url,
+            downloadExpiresAt: job.artifact.expiresAt,
+            latest,
+            buildId: latest ? null : job.id,
+            idempotencyKey: `cli:${job.id}:${job.artifact.hash}`,
+        }),
+    });
+}
+export async function publishOtaRelease(config, state, input) {
+    const target = await ensureRemoteTarget(config, state);
+    return request({
+        apiUrl: config.cli?.apiUrl,
+        token: config.cli?.token ?? process.env.LYNXSHIP_TOKEN,
+    }, "/v1/ota/releases", {
+        method: "POST",
+        body: JSON.stringify({ ...input, ...target }),
+    });
+}
+export async function fetchOtaPublicKey(config) {
+    return request({
+        apiUrl: config.cli?.apiUrl,
+        token: config.cli?.token ?? process.env.LYNXSHIP_TOKEN,
+    }, "/v1/ota/public-key");
+}

package/dist/runtime-fingerprint.d.ts

@@ -0,0 +1,10 @@
+import { type BuildOrchestrator } from "@lynxship/build-orchestrator";
+import { type Platform } from "@lynxship/contracts";
+import type { LynxShipConfig } from "./config.js";
+export interface RuntimeFingerprintReport {
+    value: string;
+    inputs: Record<string, unknown>;
+}
+export declare function assertCompatibleBinaryBuild(builds: BuildOrchestrator, platform: Platform, runtimeVersion: string): void;
+export declare function inspectRuntimeFingerprint(root: string, platform: Platform, config: LynxShipConfig): Promise<RuntimeFingerprintReport>;
+//# sourceMappingURL=runtime-fingerprint.d.ts.map

package/dist/runtime-fingerprint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-fingerprint.d.ts","sourceRoot":"","sources":["../src/runtime-fingerprint.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,KAAK,iBAAiB,EAGvB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAQlD,MAAM,WAAW,wBAAwB;IACvC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC;AAED,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,iBAAiB,EACzB,QAAQ,EAAE,QAAQ,EAClB,cAAc,EAAE,MAAM,GACrB,IAAI,CAmBN;AA0MD,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,cAAc,GACrB,OAAO,CAAC,wBAAwB,CAAC,CAyCnC"}

package/dist/runtime-fingerprint.js

@@ -0,0 +1,238 @@
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import { readdir, readFile, realpath, stat } from "node:fs/promises";
+import { basename, dirname, extname, join, relative, sep } from "node:path";
+import { runtimeFingerprint, } from "@lynxship/build-orchestrator";
+import { assert, sha256 } from "@lynxship/contracts";
+export function assertCompatibleBinaryBuild(builds, platform, runtimeVersion) {
+    const successfulBuild = builds
+        .list()
+        .filter((job) => job.platform === platform && job.state === "success")
+        .sort((left, right) => {
+        const leftAt = left.transitions.at(-1)?.at ?? "";
+        const rightAt = right.transitions.at(-1)?.at ?? "";
+        return rightAt.localeCompare(leftAt);
+    })[0];
+    assert(successfulBuild?.runtimeVersion === runtimeVersion, "OTA_NATIVE_CHANGE_REQUIRED", "Native project inputs changed or no compatible binary build exists. Run `lynxship build` before publishing an OTA update.", {
+        platform,
+        runtimeVersion,
+        lastBuildRuntimeVersion: successfulBuild?.runtimeVersion ?? null,
+    });
+}
+const nativeExtensions = new Set([
+    ".gradle",
+    ".gradle.kts",
+    ".h",
+    ".java",
+    ".json",
+    ".kt",
+    ".m",
+    ".mm",
+    ".plist",
+    ".podspec",
+    ".properties",
+    ".rb",
+    ".swift",
+    ".xml",
+    ".entitlements",
+    ".storyboard",
+    ".xib",
+    ".xcconfig",
+]);
+const nativeNames = new Set([
+    "Podfile",
+    "Podfile.lock",
+    "project.pbxproj",
+    "settings.gradle",
+    "settings.gradle.kts",
+    "gradle-wrapper.properties",
+    "AndroidManifest.xml",
+]);
+const ignoredDirectories = new Set([
+    ".gradle",
+    ".git",
+    ".lynxship",
+    "build",
+    "DerivedData",
+    "Pods",
+]);
+function normalizedPath(value) {
+    return value.split(sep).join("/");
+}
+async function readJsonFile(file) {
+    try {
+        return JSON.parse(await readFile(file, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+async function fileFingerprint(root, file) {
+    const data = await readFile(file);
+    return {
+        path: normalizedPath(relative(root, file)),
+        hash: createHash("sha256")
+            .update(data.toString("latin1"), "latin1")
+            .digest("hex"),
+        size: data.byteLength,
+    };
+}
+async function collectNativeFiles(root, directory) {
+    const result = [];
+    async function visit(current) {
+        let entries;
+        try {
+            entries = await readdir(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (ignoredDirectories.has(entry.name))
+                continue;
+            const file = join(current, entry.name);
+            if (entry.isDirectory()) {
+                await visit(file);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            if (!nativeNames.has(entry.name) &&
+                !nativeExtensions.has(extname(entry.name).toLowerCase()))
+                continue;
+            const details = await stat(file);
+            if (details.size > 2_000_000)
+                continue;
+            result.push(await fileFingerprint(root, file));
+        }
+    }
+    await visit(directory);
+    return result.sort((a, b) => a.path.localeCompare(b.path));
+}
+async function collectLynxLibraryManifests(root) {
+    const result = [];
+    const visited = new Set();
+    async function visit(current, depth) {
+        if (depth > 7)
+            return;
+        let realDirectory;
+        try {
+            realDirectory = (await stat(current)).isDirectory()
+                ? await realpath(current)
+                : "";
+        }
+        catch {
+            return;
+        }
+        if (!realDirectory || visited.has(realDirectory))
+            return;
+        visited.add(realDirectory);
+        let entries;
+        try {
+            entries = await readdir(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const file = join(current, entry.name);
+            if (entry.isFile() && entry.name === "lynx.lib.json") {
+                result.push(await fileFingerprint(root, file));
+                continue;
+            }
+            if (entry.name === ".cache")
+                continue;
+            if (entry.isDirectory()) {
+                await visit(file, depth + 1);
+                continue;
+            }
+            if (entry.isSymbolicLink()) {
+                try {
+                    if ((await stat(file)).isDirectory())
+                        await visit(file, depth + 1);
+                }
+                catch {
+                    // Broken package links are ignored; the lockfile still fingerprints them.
+                }
+            }
+        }
+    }
+    await visit(join(root, "node_modules"), 0);
+    const rootManifest = join(root, "lynx.lib.json");
+    try {
+        result.push(await fileFingerprint(root, rootManifest));
+    }
+    catch {
+        // A root manifest is optional; package manifests are discovered above.
+    }
+    return result.sort((a, b) => a.path.localeCompare(b.path));
+}
+function packageManager(packageJson) {
+    if (typeof packageJson.packageManager === "string")
+        return packageJson.packageManager;
+    return "pnpm-lock.yaml";
+}
+function findLockfile(root) {
+    let current = root;
+    while (true) {
+        for (const name of ["pnpm-lock.yaml", "package-lock.json", "yarn.lock"]) {
+            const file = join(current, name);
+            if (existsSync(file))
+                return file;
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            return undefined;
+        current = parent;
+    }
+}
+function lynxPackages(packageJson) {
+    const versions = {};
+    for (const field of ["dependencies", "devDependencies", "peerDependencies"]) {
+        const dependencies = packageJson[field];
+        if (!dependencies || typeof dependencies !== "object")
+            continue;
+        for (const [name, value] of Object.entries(dependencies)) {
+            if ((name.startsWith("@lynx-js/") || name.startsWith("lynx")) &&
+                typeof value === "string")
+                versions[name] = value;
+        }
+    }
+    return Object.fromEntries(Object.entries(versions).sort(([a], [b]) => a.localeCompare(b)));
+}
+export async function inspectRuntimeFingerprint(root, platform, config) {
+    const packageJson = (await readJsonFile(join(root, "package.json"))) ??
+        {};
+    const lockfile = findLockfile(root);
+    const lockfileHash = lockfile ? sha256(await readFile(lockfile)) : "none";
+    const nativeFiles = await collectNativeFiles(root, join(root, platform));
+    const moduleManifests = await collectLynxLibraryManifests(root);
+    const nativeHash = sha256(JSON.stringify(nativeFiles));
+    const modulesHash = sha256(JSON.stringify(moduleManifests));
+    const packages = lynxPackages(packageJson);
+    const managerPackageJson = {
+        ...packageJson,
+        packageManager: packageJson.packageManager ?? (lockfile ? basename(lockfile) : undefined),
+    };
+    const input = {
+        platform,
+        config: { update: { protocolVersion: config.update?.protocolVersion } },
+        packageManager: packageManager(managerPackageJson),
+        lockfileHash,
+        native: {
+            engine: packages["@lynx-js/lynx"] ?? "unknown",
+            sdk: packages["@lynx-js/react"] ?? "unknown",
+            nativeHash,
+            modulesHash,
+        },
+    };
+    const fingerprint = runtimeFingerprint(input);
+    if (config.runtimeVersion?.policy === "manual") {
+        assert(config.runtimeVersion.value, "CONFIG_RUNTIME_VALUE", "Manual runtimeVersion.value is required");
+        return {
+            value: config.runtimeVersion.value,
+            inputs: { ...fingerprint.inputs, policy: "manual" },
+        };
+    }
+    return fingerprint;
+}

package/dist/secure-store.d.ts

@@ -0,0 +1,32 @@
+export interface StoredCredentials {
+    r2?: {
+        accessKeyId: string;
+        secretAccessKey: string;
+    };
+    android?: {
+        keystorePath: string;
+        keyAlias: string;
+        keystorePassword: string;
+        keyPassword: string;
+    };
+    googlePlay?: {
+        serviceAccountJson: string;
+        applicationId: string;
+        track: string;
+        releaseStatus: "draft" | "completed" | "inProgress" | "halted";
+    };
+    appStoreConnect?: {
+        apiKeyId: string;
+        issuerId: string;
+        privateKey: string;
+        bundleIdentifier: string;
+        ascAppId?: string;
+        transporterPath?: string;
+    };
+}
+export declare function credentialStorageDescription(): string;
+export declare function loadCredentials(root: string): Promise<StoredCredentials>;
+export declare function saveCredentials(root: string, credentials: StoredCredentials, options?: {
+    global?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=secure-store.d.ts.map

package/dist/secure-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secure-store.d.ts","sourceRoot":"","sources":["../src/secure-store.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,iBAAiB;IAChC,EAAE,CAAC,EAAE;QACH,WAAW,EAAE,MAAM,CAAC;QACpB,eAAe,EAAE,MAAM,CAAC;KACzB,CAAC;IACF,OAAO,CAAC,EAAE;QACR,YAAY,EAAE,MAAM,CAAC;QACrB,QAAQ,EAAE,MAAM,CAAC;QACjB,gBAAgB,EAAE,MAAM,CAAC;QACzB,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC;IACF,UAAU,CAAC,EAAE;QACX,kBAAkB,EAAE,MAAM,CAAC;QAC3B,aAAa,EAAE,MAAM,CAAC;QACtB,KAAK,EAAE,MAAM,CAAC;QACd,aAAa,EAAE,OAAO,GAAG,WAAW,GAAG,YAAY,GAAG,QAAQ,CAAC;KAChE,CAAC;IACF,eAAe,CAAC,EAAE;QAChB,QAAQ,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;QACjB,UAAU,EAAE,MAAM,CAAC;QACnB,gBAAgB,EAAE,MAAM,CAAC;QACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,eAAe,CAAC,EAAE,MAAM,CAAC;KAC1B,CAAC;CACH;AAED,wBAAgB,4BAA4B,IAAI,MAAM,CAIrD;AA6RD,wBAAsB,eAAe,CACnC,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,iBAAiB,CAAC,CAM5B;AAED,wBAAsB,eAAe,CACnC,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,iBAAiB,EAC9B,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAO,GACjC,OAAO,CAAC,IAAI,CAAC,CA6Bf"}